diff --git a/CMakeLists.txt b/CMakeLists.txt index 4c9aa98b9..bdda6ddb4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ # # libwebsockets - small server side websockets and web server implementation # -# Copyright (C) 2010 - 2020 Andy Green +# Copyright (C) 2010 - 2022 Andy Green # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to @@ -162,6 +162,7 @@ option(LWS_WITH_SYS_METRICS "Lws Metrics API" OFF) option(LWS_WITH_UPNG "Enable stateful PNG stream decoder" ON) option(LWS_WITH_GZINFLATE "Enable internal minimal gzip inflator" ON) option(LWS_WITH_JPEG "Enable stateful JPEG stream decoder" ON) +option(LWS_WITH_DLO "Enable Display List Objects" ON) # # Secure Streams @@ -331,6 +332,7 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") else() set(LWS_WITH_NETLINK 0) endif() +option(LWS_WITH_MCUFONT_ENCODER "Build the ttf to mcufont encoder" OFF) # # Compressed backtraces @@ -1050,6 +1052,9 @@ if (PICO_SDK_PATH) link_libraries(pico_stdlib PRIVATE) endif() +if (LWS_WITH_MCUFONT_ENCODER) + add_subdirectory(contrib/mcufont/encoder) +endif() # Generate the lws_config.h that includes all the public compilation settings. configure_file( diff --git a/LICENSE b/LICENSE index 767d2d368..79c24845d 100644 --- a/LICENSE +++ b/LICENSE @@ -8,11 +8,13 @@ Original liberal license retained: - lib/misc/sha-1.c - 3-clause BSD license retained, link to original [BSD3] - win32port/zlib - lib/drivers/display/upng.* - ZLIB license (see zlib.h) [ZLIB] + - lib/drivers/display/upng.* - ZLIB license (see zlib.h) [ZLIB] - lib/tls/mbedtls/wrapper - Apache 2.0 (only built if linked against mbedtls) [APACHE2] - lib/tls/mbedtls/mbedtls-extensions.c + - lib/tls/mbedtls/mbedtls-extensions.c - lib/misc/base64-decode.c - already MIT + - contrib/mcufont/encoder - lib/misc/ieeehalfprecision.c - 2-clause BSD license retained [BSD2] + - contrib/mcufont/fonts - Open Font License [OFL] Relicensed to MIT: @@ -210,3 +212,100 @@ For these and/or other purposes and motivations, and without any expectation of Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. ``` +## OFL: Open Font License + +``` +Copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A. + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. +``` diff --git a/READMEs/README.display-list.md b/READMEs/README.display-list.md new file mode 100644 index 000000000..d09bbe4db --- /dev/null +++ b/READMEs/README.display-list.md @@ -0,0 +1,148 @@ +# lws_display_list + +`lws_display_list` is a modernized 1970s-style Display List of graphic +primitives held in an `lws_dll2` list of Display List Objects (DLOs). + +Provided DLO primitives are: + + - filled rectangle (with individually controllable rounded corners) + - PNG (1:1 and original orientation only, transparency supported) + - JPEG (1:1 and original orientation only) + - utf-8 text areas (using compressed, antialiased mcufonts) + +The aim of it is to process some other representation to describe the +logical scene completely using DLOs in memory, discard the earlier +representation and then rasterize the Display List a single line at a +time from top to bottom, so no backing framebuffer is required at all. +DLOs are destroyed as they go out of scope during rasterization. + +Although the memory required does scale with scene complexity in +terms of number of DLOs, it hardly scales at all with output +resolution, allowing modern 32-bpp rendering on very constrained +devices, if slowly. + +## DLO capabilities + +DLOs are quite capable + + - no floats (`lws_fx` integer fixed-point) + - 16-bit signed coordinate space with off-surface clipping handled + - Internal 32-bpp RGBA colourspace (8-bit opacity) + - correct Z-order opacity resolution + - Supports arbitrary paletteization (down to 1bpp) and error diffusion + - DLO-private error diffusion for clean opaque overlaid objects + - Antialised bitmap text using compressed fonts (eg 7 font sizes 10- + 32px in both regular and bold < ~100KB) + - Very lightweight stateful PNG and JPEG decode + +All DLOs in a Display List are consumed as they are rasterized, +individual DLOs are destroyed as soon as they go out of scope during +top - bottom rendering, freeing any related resources as soon as possible. + +## DLO PNGs + +DLOs may point to a compressed PNG, which is decompressed on the fly +and the decompression context destroyed as the rasterization goes +beyond its bounding box. Using the lws stateful rewrite of upng, the +memory cost of 32-bpp PNG decode of any dimensions is 40K + 16 x width +bytes, including error diffusion line buffers. Decoding of the +compressed PNG data is done statefully on demand as needed to fill an +output line, so no memory is needed to hold excess decode production. + +Multiple PNG DLOs including PNG-over-PNG (with alpha mixing) are +allowed. PNGs only take heap memory while the current rasterization +line intersects them, so any number of PNGs that don't intersect +vertically do not cost any more peak memory allocation than decoding one, +since the decoding contexts and DLOs of the earlier ones have been +destroyed before the next one's decoding context is allocated. + +## DLO JPEGs + +DLOs can also represent JPEGs using a stream parsing rewite of picojpeg. +No framebuffer is required to hold the output, it produces one line of +pixels at a time. JPEGs use either 8- or 16- line deep MCUs, +necessitating an 8 or 16 line RGB (or Y if grayscale) pixel buffer +during decode. + +Heap requirements while a JPG is being rasterized is 2.5KB plus the +MCU buffer dependent on the chroma coding: + +|Image type|Fixed alloc|MCU buffer| +|---|---|---| +|grayscale|2.5KB|image width x 8 bytes| +|YUV 4:4:4|2.5KB|image width x 24 bytes| +|YUV 4:4:2v|2.5KB|image width x 24 bytes| +|YUV 4:4:2h|2.5KB|image width x 48 bytes| +|YUV 4:4:0|2.5KB|image width x 48 bytes| + +## DLO text + +Text DLOs are predicated around unicode utf-8 and a stream parsing +rewrite of mcufont decoder. + +mcufont includes a ttf renderer app which is ported into lws as well, +this allows production of antialised (16 alpha level) compressed +bitmaped fonts from any ttf font at a selected size and including +specified subsets of unicode code points. + +Font glyphs are decompressed statefully as part of the DLO line +rasterization process, so there are no glyph buffers or caching. +The decompression is very fast and allows fitting over a dozen +font sizes and weights into 100KB. + +Wrapping inside a bounding box is supported as is "run-on", where text +DLOs follow one another inline, used for example to use a bold font +in part of a text using a different DLO with a different font before +continuing with another DLO using the non-bold font cleanly. DLOs +are marked as running-on or not. + +Centering and right-justification is possible by summing run-ons on +the current line by walking the display list backwards until a non- +run-on DLO is seen, and adjusting the affected DLOs x position. + +## Display List lifecycle + +### Create empty display list + +Create the display state (the dynamic counterpart of the const, static +`lws_display` definition) and the empty display list. + +``` + lws_display_state_t lds; + lws_displaylist_t dl; +``` + +Instantiate the `lws_display` and bind the display list to it +``` + lws_display_state_init(&lds, cx, 30000, 10000, lls, &disp.disp); + + lws_display_dl_init(&dl, &lds); + + + +### Create DLOs into the list + +Eg, create a png from `data` / `len`, return NULL if failed. + +``` + if (!lws_display_dlo_png_new(&dl, &box, data, len)) { +``` + +Eg, create a white background rectange the size of the `lws_display` + +``` + lws_dlo_rect_t *dr; + lws_box_t box = { 0, 0, dl.ds->disp->ic.wh_px[0].whole, + dl.ds->disp->ic.wh_px[1].whole }; + + dr = lws_display_dlo_rect_new(&dl, &box, 0, + LWSDC_RGBA(255, 255, 255, 255)); + if (!dr) + return 1; +``` + +### Rendering into an lws_display + +``` + lds->disp->blit(lds, (uint8_t *)&dl, &box); +``` diff --git a/cmake/lws_config.h.in b/cmake/lws_config.h.in index e7911983d..2bfe405aa 100644 --- a/cmake/lws_config.h.in +++ b/cmake/lws_config.h.in @@ -159,6 +159,7 @@ #cmakedefine LWS_WITH_DEPRECATED_LWS_DLL #cmakedefine LWS_WITH_DETAILED_LATENCY #cmakedefine LWS_WITH_DIR +#cmakedefine LWS_WITH_DLO #cmakedefine LWS_WITH_DRIVERS #cmakedefine LWS_WITH_ESP32 #cmakedefine LWS_HAVE_EVBACKEND_LINUXAIO diff --git a/contrib/mcufont/LICENSE b/contrib/mcufont/LICENSE new file mode 100644 index 000000000..d1fad069c --- /dev/null +++ b/contrib/mcufont/LICENSE @@ -0,0 +1,31 @@ +mcufont is available under the MIT license: + +Copyright (C) 2013 Petteri Aimonen + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +--- + +In addition, the files under the "decoder" folder and all font files +generated by the encoder are placed in the public domain. You can do +anything with them without any restriction from me. + +Note that the licenses of the fonts you import may pose additional +restrictions. diff --git a/contrib/mcufont/README.md b/contrib/mcufont/README.md new file mode 100644 index 000000000..791e3fe68 --- /dev/null +++ b/contrib/mcufont/README.md @@ -0,0 +1,102 @@ +# origin + +This is part of the MIT-licensed mcufont project which can be found here + +https://github.com/mcufont/mcufont + +That project is great but it's not actively maintained[1][2] and most work +on it was done back in 2013. + +The decoder part was rewritten for lws as `./lib/misc/dlo/dlo-font-mcufont.c`. +This directory contains the ttf-> mcufont encoder, which is a C++ +commandline tool for development. + +[1] https://github.com/mcufont/mcufont/issues/11 +[2] https://github.com/mcufont/mcufont/issues/26 + +## Building + +Install `freetype-dev` or similar package on your build host. + +Enable lws cmake option `-DLWS_WITH_MCUFONT_ENCODER=1` to get it built, but +since it is for development it is not packaged with the rest of lws by make +install. + +It produces an executable for your build host in `./bin/lws-mcufont-encoder` +or similar as part of the normal lws cmake build process then. + +## Modifications vs upstream + +1) The rledecoder is rewritten to decode statefully, emitting a rasterized +line at a time and only taking in more input when required to issue the +next pixel that is needed for the current line. This implementation is +integrated into lws dlo stuff down ./lib/misc/dlo. + +2) The mcufont decoder type headers are distributed as part of the lws +public headers, but are not imported with libwebsockets.h inclusion, you +should `#include ` if you need them (you +normally won't need them, since the dlo stuff will bring it in for its +own usage). + +3) Only the encoder part is brought into lws ./conftrib/mcufont; the +encoder can be built by selecting lws cmake option `-DLWS_WITH_MCUFONT_ENCODER=1` + +4) The encoder part is modified to issue a single table blob file, +instead of the C typed structs and arrays requiring fonts to be +selected and managed only at build-time; it's at least possible to +download or otherwise manage fonts then after build-time. + +The blob starts with a 64-byte header with a magic, versioning, flags and +a map of where the other regions can be found in the file... the overall +layout is like: + +``` + [64-byte header] + [font name string] + [font short name string] + [Dictionary Data area] + [Dictionary Offset area] + [Unicode range tables] + [offset table for range] + [data table for range] +``` + +File offsets are measured from the first byte of the blob / file. + +Dictionary and glyph offset tables contain 16-bit offsets which apply to the first +byte of the Dictionary Data area and the Glyph data table respectively. + +The header part is laid out like: + +``` + 0000 4D 43 55 46 4-byte magic "MCUF" + 0004 XX XX XX XX 4-byte MSB Flags + Version + 0008 XX XX XX XX 4-byte MSB file offset: 00-terminated string: `full_name` + 000C XX XX XX XX 4-byte MSB file offset: 00-terminated string: `short_name` + 0010 XX XX XX XX 4-byte MSB file offset: Dictionary Data area (8b) + 0014 XX XX XX XX 4-byte MSB count: extent of Dictionary Data area + 0018 XX XX XX XX 4-byte MSB file offset: Dictionary Offsets (16b) into Data area + 001C XX XX XX XX 4-byte MSB count: rle dictionary + 0020 XX XX XX XX 4-byte MSB count: ref dictionary + rle dictionary + 0024 XX XX XX XX 4-byte MSB file offset: Char Range Tables + 0028 XX XX XX XX 4-byte MSB count: Char Range Tables + 002C XX XX XX XX 4-byte MSB unicode fallback char + 0030 XX XX 2-byte MSB `width` + 0032 XX XX 2-byte MSB `height` + 0034 XX XX 2-byte MSB `min_x_advance` + 0036 XX XX 2-byte MSB `max_x_advance` + 0038 XX XX 2-byte MSB signed `baseline_x` + 003A XX XX 2-byte MSB `baseline_y` + 003C XX XX 2-byte MSB `line_height` + 003E 00 00 2-byte Reserved +``` + +Char range tables comprise for each range: + +``` ++0000 XX XX XX XX 4-byte MSB unicode index start ++0004 XX XX XX XX 4-byte MSB count of indexes covered ++0008 XX XX XX XX 4-byte MSB file offset: start of 16-bit glyph offsets table ++000C XX XX XX XX 4-byte MSB file offset: start of data above offsets point into +``` + diff --git a/contrib/mcufont/encoder/.gitignore b/contrib/mcufont/encoder/.gitignore new file mode 100644 index 000000000..b0545fb6d --- /dev/null +++ b/contrib/mcufont/encoder/.gitignore @@ -0,0 +1,7 @@ +mcufont +unittests +unittests.cc +cmake-build-debug/ +build/ +.idea/ +.vscode/ diff --git a/contrib/mcufont/encoder/CMakeLists.txt b/contrib/mcufont/encoder/CMakeLists.txt new file mode 100644 index 000000000..8f85e597a --- /dev/null +++ b/contrib/mcufont/encoder/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 3.13) +project(mfencoder) + +find_package(Freetype REQUIRED) +find_package(Threads REQUIRED) +include_directories(${FREETYPE_INCLUDE_DIRS}) + +set(CMAKE_CXX_STANDARD 14) + +include_directories(.) + +add_executable(lws-mcufont-encoder + bdf_import.cc + bdf_import.hh + ccfixes.hh + datafile.cc + datafile.hh + encode_rlefont.cc + encode_rlefont.hh + export_bwfont.cc + export_bwfont.hh + export_rlefont.cc + export_rlefont.hh + exporttools.cc + exporttools.hh + freetype_import.cc + freetype_import.hh + gb2312_in_ucs2.h + importtools.cc + importtools.hh + main.cc + optimize_rlefont.cc + optimize_rlefont.hh) + +target_link_libraries(lws-mcufont-encoder ${FREETYPE_LIBRARIES} Threads::Threads) diff --git a/contrib/mcufont/encoder/bdf_import.cc b/contrib/mcufont/encoder/bdf_import.cc new file mode 100644 index 000000000..32deb057b --- /dev/null +++ b/contrib/mcufont/encoder/bdf_import.cc @@ -0,0 +1,156 @@ +#include "bdf_import.hh" +#include "importtools.hh" +#include +#include +#include +#include + +namespace mcufont { + +static std::string toupper(const std::string &input) +{ + std::string result; + for (char c: input) result.push_back(::toupper(c)); + return result; +} + +static int hextoint(char c) +{ + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + throw std::domain_error("Hex digit not in range"); +} + +static void parse_fontinfo(std::istream &file, DataFile::fontinfo_t &fontinfo) +{ + std::string line; + while (std::getline(file, line)) + { + std::istringstream s(line); + std::string tag; + s >> tag; + tag = toupper(tag); + + if (tag == "FONT") + { + while (isspace(s.peek())) s.get(); + std::getline(s, fontinfo.name); + } + else if (tag == "FONTBOUNDINGBOX") + { + int x, y; + s >> fontinfo.max_width >> fontinfo.max_height; + s >> x >> y; + fontinfo.baseline_x = - x; + fontinfo.baseline_y = fontinfo.max_height + y; + } + else if (tag == "STARTCHAR") + { + break; + } + } +} + +static bool parse_glyph(std::istream &file, DataFile::glyphentry_t &glyph, + const DataFile::fontinfo_t &fontinfo) +{ + glyph.chars.clear(); + glyph.width = 0; + + // Initialize the character contents to all 0 with proper size. + glyph.data.clear(); + glyph.data.resize(fontinfo.max_width * fontinfo.max_height, 0); + + int bbx_w = fontinfo.max_width; + int bbx_h = fontinfo.max_height; + int bbx_x = - fontinfo.baseline_x; + int bbx_y = fontinfo.baseline_y - fontinfo.max_height; + + // Read glyph metadata + std::string line; + std::string tag; + while (std::getline(file, line)) + { + std::istringstream s(line); + s >> tag; + tag = toupper(tag); + + if (tag == "ENCODING") + { + int c; + s >> c; + glyph.chars.push_back(c); + } + else if (tag == "DWIDTH") + { + s >> glyph.width; + } + else if (tag == "BBX") + { + s >> bbx_w >> bbx_h >> bbx_x >> bbx_y; + } + else if (tag == "BITMAP") + { + break; + } + } + + if (tag != "BITMAP") + return false; + + // Read glyph bits + int x0 = fontinfo.baseline_x + bbx_x; + int y = fontinfo.baseline_y - bbx_y - bbx_h; + for (int i = 0; i < bbx_h; i++) + { + std::getline(file, line); + line = toupper(line); + + for (int x = 0; x < bbx_w; x++) + { + int nibble = hextoint(line.at(x / 4)); + uint8_t pixel = 0; + if (nibble & (8 >> (x % 4))) + pixel = 15; + + glyph.data.at(y * fontinfo.max_width + x0 + x) = pixel; + } + + y++; + } + + std::getline(file, line); + line = toupper(line); + if (line.compare(0, 7, "ENDCHAR") == 0) + return true; + else + return false; +} + +std::unique_ptr LoadBDF(std::istream &file) +{ + DataFile::fontinfo_t fontinfo = {}; + std::vector glyphtable; + std::vector dictionary; + + parse_fontinfo(file, fontinfo); + + while (file) + { + DataFile::glyphentry_t glyph = {}; + if (parse_glyph(file, glyph, fontinfo)) + glyphtable.push_back(glyph); + } + + eliminate_duplicates(glyphtable); + crop_glyphs(glyphtable, fontinfo); + detect_flags(glyphtable, fontinfo); + + fontinfo.line_height = fontinfo.max_height; + + std::unique_ptr result(new DataFile( + dictionary, glyphtable, fontinfo)); + return result; +} + +} diff --git a/contrib/mcufont/encoder/bdf_import.hh b/contrib/mcufont/encoder/bdf_import.hh new file mode 100644 index 000000000..d94103e55 --- /dev/null +++ b/contrib/mcufont/encoder/bdf_import.hh @@ -0,0 +1,80 @@ +// Function for importing .BDF fonts as data files. + +#pragma once +#include "datafile.hh" + +namespace mcufont +{ + +std::unique_ptr LoadBDF(std::istream &file); + +} + +#ifdef CXXTEST_RUNNING +#include + +using namespace mcufont; + +class BDFTests: public CxxTest::TestSuite +{ +public: + void testLoadBDF() + { + std::istringstream s(testfile); + std::unique_ptr f = LoadBDF(s); + + TS_ASSERT_EQUALS(f->GetFontInfo().name, "-Misc-Fixed-Medium-R-Normal--14-130-75-75-C-70-ISO8859-15"); + TS_ASSERT_EQUALS(f->GetFontInfo().max_width, 6); + TS_ASSERT_EQUALS(f->GetFontInfo().max_height, 11); + TS_ASSERT_EQUALS(f->GetGlyphCount(), 1); + TS_ASSERT_EQUALS(f->GetGlyphEntry(0).chars.size(), 2); + } + +private: + static constexpr const char *testfile = + "STARTFONT 2.1\n" + "FONT -Misc-Fixed-Medium-R-Normal--14-130-75-75-C-70-ISO8859-15\n" + "FONTBOUNDINGBOX 7 14 0 -2\n" + "STARTCHAR defaultchar\n" + "ENCODING 0\n" + "DWIDTH 7 0\n" + "BBX 7 14 0 -2\n" + "BITMAP\n" + "00\n" + "B4\n" + "84\n" + "00\n" + "84\n" + "84\n" + "00\n" + "84\n" + "84\n" + "00\n" + "84\n" + "B4\n" + "00\n" + "00\n" + "ENDCHAR\n" + "STARTCHAR copychar\n" + "ENCODING 2\n" + "DWIDTH 7 0\n" + "BBX 7 14 0 -2\n" + "BITMAP\n" + "00\n" + "B4\n" + "84\n" + "00\n" + "84\n" + "84\n" + "00\n" + "84\n" + "84\n" + "00\n" + "84\n" + "B4\n" + "00\n" + "00\n" + "ENDCHAR\n"; + +}; +#endif diff --git a/contrib/mcufont/encoder/ccfixes.hh b/contrib/mcufont/encoder/ccfixes.hh new file mode 100644 index 000000000..8843639ba --- /dev/null +++ b/contrib/mcufont/encoder/ccfixes.hh @@ -0,0 +1,152 @@ + +#ifdef NEED_STRING_FIXES + #include + #include + #include + #include + #include + + namespace std { + template inline std::string to_string(T value) + { + std::ostringstream os ; + os << value ; + return os.str() ; + } + + inline int stoi( const std::string& str, std::size_t* pos = 0, int base = 10 ) + { + const char* begin = str.c_str() ; + char* end = nullptr ; + long value = std::strtol( begin, &end, base ) ; + + if( errno == ERANGE || value > std::numeric_limits::max() ) + throw std::out_of_range( "stoi: out ofrange" ) ; + + if( end == str.c_str() ) + throw std::invalid_argument( "stoi: invalid argument" ) ; + + if(pos) *pos = end - begin ; + + return value ; + } + } +#endif + +#ifdef NEED_THREAD_FIXES +#ifndef WIN32STDTHREAD_H + #define WIN32STDTHREAD_H + + #include + #include + #include + #include + #include + #include + + #define _STD_THREAD_INVALID_HANDLE 0 + namespace std + { + + + class thread + { + public: + class id + { + DWORD mId; + void clear() {mId = 0;} + friend class thread; + public: + id(DWORD aId=0):mId(aId){} + bool operator==(const id& other) const {return mId == other.mId;} + }; + protected: + HANDLE mHandle; + id mThreadId; + public: + typedef HANDLE native_handle_type; + id get_id() const noexcept {return mThreadId;} + native_handle_type native_handle() const {return mHandle;} + thread(): mHandle(_STD_THREAD_INVALID_HANDLE){} + thread(thread& other) + :mHandle(other.mHandle), mThreadId(other.mThreadId) + { + other.mHandle = _STD_THREAD_INVALID_HANDLE; + other.mThreadId.clear(); + } + template + explicit thread(Function&& f, Args&&... args) + { + typedef decltype(std::bind(f, args...)) Call; + Call* call = new Call(std::bind(f, args...)); + mHandle = (HANDLE)_beginthreadex(NULL, 0, threadfunc, + (LPVOID)call, 0, (unsigned*)&(mThreadId.mId)); + } + template + static unsigned int __stdcall threadfunc(void* arg) + { + std::unique_ptr upCall(static_cast(arg)); + (*upCall)(); + return (unsigned long)0; + } + bool joinable() const {return mHandle != _STD_THREAD_INVALID_HANDLE;} + void join() + { + if (get_id() == GetCurrentThreadId()) + throw system_error(EDEADLK, generic_category()); + if (mHandle == _STD_THREAD_INVALID_HANDLE) + throw system_error(ESRCH, generic_category()); + if (!joinable()) + throw system_error(EINVAL, generic_category()); + WaitForSingleObject(mHandle, INFINITE); + CloseHandle(mHandle); + mHandle = _STD_THREAD_INVALID_HANDLE; + mThreadId.clear(); + } + + ~thread() + { + if (joinable()) + std::terminate(); + } + thread& operator=(const thread&) = delete; + thread& operator=(thread&& other) noexcept + { + if (joinable()) + std::terminate(); + swap(std::forward(other)); + return *this; + } + void swap(thread&& other) noexcept + { + std::swap(mHandle, other.mHandle); + std::swap(mThreadId.mId, other.mThreadId.mId); + } + static unsigned int hardware_concurrency() noexcept {return 1;} + void detach() + { + if (!joinable()) + throw system_error(); + mHandle = _STD_THREAD_INVALID_HANDLE; + mThreadId.clear(); + } + }; + namespace this_thread + { + inline thread::id get_id() {return thread::id(GetCurrentThreadId());} + inline void yield() {Sleep(0);} + template< class Rep, class Period > + void sleep_for( const std::chrono::duration& sleep_duration) + { + Sleep(chrono::duration_cast(sleep_duration).count()); + } + template + void sleep_until(const std::chrono::time_point& sleep_time) + { + sleep_for(sleep_time-Clock::now()); + } + } + } +#endif +#endif diff --git a/contrib/mcufont/encoder/datafile.cc b/contrib/mcufont/encoder/datafile.cc new file mode 100644 index 000000000..aba70057b --- /dev/null +++ b/contrib/mcufont/encoder/datafile.cc @@ -0,0 +1,239 @@ +#include "datafile.hh" +#include +#include +#include +#include +#include "ccfixes.hh" + +#define DATAFILE_FORMAT_VERSION 1 + +namespace mcufont { + +DataFile::DataFile(const std::vector &dictionary, + const std::vector &glyphs, + const fontinfo_t &fontinfo): + m_dictionary(dictionary), m_glyphtable(glyphs), m_fontinfo(fontinfo) +{ + dictentry_t dummy = {}; + while (m_dictionary.size() < dictionarysize) + m_dictionary.push_back(dummy); + + UpdateLowScoreIndex(); +} + +void DataFile::Save(std::ostream &file) const +{ + file << "Version " << DATAFILE_FORMAT_VERSION << std::endl; + file << "FontName " << m_fontinfo.name << std::endl; + file << "MaxWidth " << m_fontinfo.max_width << std::endl; + file << "MaxHeight " << m_fontinfo.max_height << std::endl; + file << "BaselineX " << m_fontinfo.baseline_x << std::endl; + file << "BaselineY " << m_fontinfo.baseline_y << std::endl; + file << "LineHeight " << m_fontinfo.line_height << std::endl; + file << "Flags " << m_fontinfo.flags << std::endl; + file << "RandomSeed " << m_seed << std::endl; + + for (const dictentry_t &d : m_dictionary) + { + if (d.replacement.size() != 0) + { + file << "DictEntry " << d.score << " "; + file << d.ref_encode << " " << d.replacement << std::endl; + } + } + + for (const glyphentry_t &g : m_glyphtable) + { + file << "Glyph "; + for (size_t i = 0; i < g.chars.size(); i++) + { + if (i != 0) file << ','; + file << g.chars.at(i); + } + file << " " << g.width << " " << g.data << std::endl; + } +} + +std::unique_ptr DataFile::Load(std::istream &file) +{ + fontinfo_t fontinfo = {}; + std::vector dictionary; + std::vector glyphtable; + uint32_t seed = 1234; + int version = -1; + + std::string line; + while (std::getline(file, line)) + { + std::istringstream input(line); + std::string tag; + + input >> tag; + + if (tag == "Version") + { + input >> version; + } + else if (tag == "FontName") + { + while (std::isspace(input.peek())) input.get(); + std::getline(input, fontinfo.name); + } + else if (tag == "MaxWidth") + { + input >> fontinfo.max_width; + } + else if (tag == "MaxHeight") + { + input >> fontinfo.max_height; + } + else if (tag == "BaselineX") + { + input >> fontinfo.baseline_x; + } + else if (tag == "BaselineY") + { + input >> fontinfo.baseline_y; + } + else if (tag == "LineHeight") + { + input >> fontinfo.line_height; + } + else if (tag == "RandomSeed") + { + input >> seed; + } + else if (tag == "Flags") + { + input >> fontinfo.flags; + } + else if (tag == "DictEntry" && dictionary.size() < dictionarysize) + { + dictentry_t d = {}; + input >> d.score >> d.ref_encode >> d.replacement; + dictionary.push_back(d); + } + else if (tag == "Glyph") + { + glyphentry_t g = {}; + std::string chars; + input >> chars >> g.width >> g.data; + + if ((int)g.data.size() != fontinfo.max_width * fontinfo.max_height) + throw std::runtime_error("wrong glyph data length: " + std::to_string(g.data.size())); + + size_t pos = 0; + while (pos < chars.size()) { + size_t p; + g.chars.push_back(std::stoi(chars.substr(pos), &p)); + pos += p + 1; + } + + glyphtable.push_back(g); + } + } + + if (version != DATAFILE_FORMAT_VERSION) + { + return std::unique_ptr(nullptr); + } + + std::unique_ptr result(new DataFile(dictionary, glyphtable, fontinfo)); + result->SetSeed(seed); + return result; +} + +void DataFile::SetDictionaryEntry(size_t index, const dictentry_t &value) +{ + m_dictionary.at(index) = value; + + if (index == m_lowscoreindex || + m_dictionary.at(m_lowscoreindex).score > value.score) + { + UpdateLowScoreIndex(); + } +} + +std::map DataFile::GetCharToGlyphMap() const +{ + std::map char_to_glyph; + + for (size_t i = 0; i < m_glyphtable.size(); i++) + { + for (size_t c: m_glyphtable[i].chars) + { + char_to_glyph[c] = i; + } + } + + return char_to_glyph; +} + +std::string DataFile::GlyphToText(size_t index) const +{ + std::ostringstream os; + + const char glyphchars[] = "....,,,,----XXXX"; + + for (int y = 0; y < m_fontinfo.max_height; y++) + { + for (int x = 0; x < m_fontinfo.max_width; x++) + { + size_t pos = y * m_fontinfo.max_width + x; + os << glyphchars[m_glyphtable.at(index).data.at(pos)]; + } + os << std::endl; + } + + return os.str(); +} + +void DataFile::UpdateLowScoreIndex() +{ + auto comparison = [](const dictentry_t &a, const dictentry_t &b) + { + return a.score < b.score; + }; + + auto iter = std::min_element(m_dictionary.begin(), + m_dictionary.end(), + comparison); + + m_lowscoreindex = iter - m_dictionary.begin(); +} + +std::ostream& operator<<(std::ostream& os, const DataFile::pixels_t& str) +{ + for (uint8_t p: str) + { + if (p <= 9) + os << (char)(p + '0'); + else if (p <= 15) + os << (char)(p - 10 + 'A'); + else + throw std::logic_error("invalid pixel alpha: " + std::to_string(p)); + } + return os; +} + +std::istream& operator>>(std::istream& is, DataFile::pixels_t& str) +{ + char c; + str.clear(); + + while (isspace(is.peek())) is.get(); + + while (is.get(c)) + { + if (c >= '0' && c <= '9') + str.push_back(c - '0'); + else if (c >= 'A' && c <= 'F') + str.push_back(c - 'A' + 10); + else + break; + } + + return is; +} + +} diff --git a/contrib/mcufont/encoder/datafile.hh b/contrib/mcufont/encoder/datafile.hh new file mode 100644 index 000000000..460e60393 --- /dev/null +++ b/contrib/mcufont/encoder/datafile.hh @@ -0,0 +1,174 @@ +// Class to store the data of a font while it is being processed. +// This class can be safely cloned using the default copy constructor. + +#pragma once +#include +#include +#include +#include +#include +#include + +namespace mcufont +{ + +class DataFile +{ +public: + typedef std::vector pixels_t; + + struct dictentry_t + { + pixels_t replacement; // The expanded version of this block. + int score; // Number of bytes that having this entry saves. + bool ref_encode; // Encode using references to other dictionary entries. + + dictentry_t(): score(0), ref_encode(false) {} + }; + + struct glyphentry_t + { + pixels_t data; // The full data of the glyph. + std::vector chars; // Characters that this glyph represents. + int width; // Tracking width of the character. + }; + + struct fontinfo_t + { + std::string name; // Name of the typeface + int max_width; // Width of the character bounding box. + int max_height; // Height of the character bounding box. + int baseline_x; // X coordinate (from left) of the baseline. + int baseline_y; // Y coordinate (from top) of the baseline. + int line_height; // Line height (vertical advance). + int flags; + }; + + static const int FLAG_MONOSPACE = 0x01; + static const int FLAG_BW = 0x02; + + // Construct from data in memory. + DataFile(const std::vector &dictionary, + const std::vector &glyphs, + const fontinfo_t &fontinfo); + + // Save to a file (custom format) + void Save(std::ostream &file) const; + + // Load from a file (custom format) + // Returns nullptr if load fails. + static std::unique_ptr Load(std::istream &file); + + // Get or set an entry in the dictionary. The size of the dictionary + // is constant. Entries 0 to 23 are reserved for special purposes. + static const size_t dictionarysize = 256 - 24; + const dictentry_t &GetDictionaryEntry(size_t index) const + { return m_dictionary.at(index); } + void SetDictionaryEntry(size_t index, const dictentry_t &value); + const std::vector &GetDictionary() const + { return m_dictionary; } + + // Get the index of the dictionary entry with the lowest score. + size_t GetLowScoreIndex() const + { return m_lowscoreindex; } + + // Get an entry in the glyph table. + size_t GetGlyphCount() const + { return m_glyphtable.size(); } + const glyphentry_t &GetGlyphEntry(size_t index) const + { return m_glyphtable.at(index); } + const std::vector &GetGlyphTable() const + { return m_glyphtable; } + + // Create a map of char indices to glyph indices + std::map GetCharToGlyphMap() const; + + // Get the information that applies to all glyphs. + const fontinfo_t &GetFontInfo() const + { return m_fontinfo; } + + // Show a glyph as text. + std::string GlyphToText(size_t index) const; + + // Get the random generator seed + // The seed is stored in the datafile to get deterministic behaviour + // for debugging. + uint32_t GetSeed() const { return m_seed; } + void SetSeed(uint32_t seed) { m_seed = seed; } + +private: + std::vector m_dictionary; + std::vector m_glyphtable; + fontinfo_t m_fontinfo; + uint32_t m_seed; + + size_t m_lowscoreindex; + + void UpdateLowScoreIndex(); +}; + +std::ostream& operator<<(std::ostream& os, const DataFile::pixels_t& str); +std::istream& operator>>(std::istream& is, DataFile::pixels_t& str); + +} + +#ifdef CXXTEST_RUNNING +#include + +using namespace mcufont; + +class DataFileTests: public CxxTest::TestSuite +{ +public: + void testFileLoad() + { + std::istringstream s(testfile); + std::unique_ptr f = DataFile::Load(s); + + TS_ASSERT_EQUALS(f->GetFontInfo().name, "Sans Serif"); + TS_ASSERT_EQUALS(f->GetFontInfo().max_width, 4); + TS_ASSERT_EQUALS(f->GetFontInfo().max_height, 6); + TS_ASSERT_EQUALS(f->GetDictionaryEntry(0).score, 5); + TS_ASSERT_EQUALS(f->GetDictionaryEntry(1).score, 13); + TS_ASSERT_EQUALS(f->GetGlyphCount(), 3); + + DataFile::pixels_t expected = { + 0,15,0,15, 0,15,0,15, 0,15,0,15, 0,15,0,15, 0,15,0,15, 0,15,0,15 + }; + TS_ASSERT_EQUALS(f->GetGlyphEntry(0).data.size(), 24); + TS_ASSERT(f->GetGlyphEntry(0).data == expected); + } + + void testFileSave() + { + std::istringstream is1(testfile); + std::unique_ptr f1 = DataFile::Load(is1); + + std::ostringstream os; + f1->Save(os); + + std::string text = os.str(); + std::istringstream is2(text); + std::unique_ptr f2 = DataFile::Load(is2); + + TS_ASSERT_EQUALS(f1->GetFontInfo().name, f2->GetFontInfo().name); + TS_ASSERT(f1->GetGlyphEntry(0).data == f2->GetGlyphEntry(0).data); + } + +private: + static constexpr const char *testfile = + "Version 1\n" + "FontName Sans Serif\n" + "MaxWidth 4\n" + "MaxHeight 6\n" + "BaselineX 1\n" + "BaselineY 1\n" + "DictEntry 5 0 0F0F0\n" + "DictEntry 13 0 F0F0F0\n" + "DictEntry 1 0 F0F0F0\n" + "Glyph 1,2,3 4 0F0F0F0F0F0F0F0F0F0F0F0F\n" + "Glyph 4 4 0F0F0F0F0F0F0F0F0F0F0F0F\n" + "Glyph 5 4 0F0F0F0F0F0F0F0F0F0F0F0F\n"; +}; + +#endif diff --git a/contrib/mcufont/encoder/encode_rlefont.cc b/contrib/mcufont/encoder/encode_rlefont.cc new file mode 100644 index 000000000..40ccbd354 --- /dev/null +++ b/contrib/mcufont/encoder/encode_rlefont.cc @@ -0,0 +1,735 @@ +#include "encode_rlefont.hh" +#include +#include +#include "ccfixes.hh" + +// Number of reserved codes before the dictionary entries. +#define DICT_START 24 + +// Special reference to mean "fill with zeros to the end of the glyph" +#define REF_FILLZEROS 16 + +// RLE codes +#define RLE_CODEMASK 0xC0 +#define RLE_VALMASK 0x3F +#define RLE_ZEROS 0x00 // 0 to 63 zeros +#define RLE_64ZEROS 0x40 // (1 to 64) * 64 zeros +#define RLE_ONES 0x80 // 1 to 64 full alphas +#define RLE_SHADE 0xC0 // 1 to 4 partial alphas + +// Dictionary "fill entries" for encoding bits directly. +#define DICT_START7BIT 4 +#define DICT_START6BIT 132 +#define DICT_START5BIT 196 +#define DICT_START4BIT 228 +#define DICT_START3BIT 244 +#define DICT_START2BIT 252 + +namespace mcufont { +namespace rlefont { + +// Get bit count for the "fill entries" +static size_t fillentry_bitcount(size_t index) +{ + if (index >= DICT_START2BIT) + return 2; + else if (index >= DICT_START3BIT) + return 3; + else if (index >= DICT_START4BIT) + return 4; + else if (index >= DICT_START5BIT) + return 5; + else if (index >= DICT_START6BIT) + return 6; + else + return 7; +} + +// Count the number of equal pixels at the beginning of the pixelstring. +static size_t prefix_length(const DataFile::pixels_t &pixels, size_t pos) +{ + uint8_t pixel = pixels.at(pos); + size_t count = 1; + while (pos + count < pixels.size() && + pixels.at(pos + count) == pixel) + { + count++; + } + return count; +} + +// Perform the RLE encoding for a dictionary entry. +static encoded_font_t::rlestring_t encode_rle(const DataFile::pixels_t &pixels) +{ + encoded_font_t::rlestring_t result; + + size_t pos = 0; + while (pos < pixels.size()) + { + uint8_t pixel = pixels.at(pos); + size_t count = prefix_length(pixels, pos); + pos += count; + + if (pixel == 0) + { + // Up to 63 zeros can be encoded with RLE_ZEROS. If there are more, + // encode using RLE_64ZEROS, and then whatever remains with RLE_ZEROS. + while (count >= 64) + { + size_t c = (count > 4096) ? 64 : (count / 64); + result.push_back(RLE_64ZEROS | (c - 1)); + count -= c * 64; + } + + if (count) + { + result.push_back(RLE_ZEROS | count); + } + } + else if (pixel == 15) + { + // Encode ones. + while (count) + { + size_t c = (count > 64) ? 64 : count; + result.push_back(RLE_ONES | (c - 1)); + count -= c; + } + } + else + { + // Encode shades. + while (count) + { + size_t c = (count > 4) ? 4 : count; + result.push_back(RLE_SHADE | ((c - 1) << 4) | pixel); + count -= c; + } + } + } + + return result; +} + +// We use a tree structure to represent the dictionary entries. +// Using this tree, we can perform a combined Aho-Corasick string matching +// and breadth-first search to find the optimal encoding of glyph data. +class DictTreeNode +{ +public: + DictTreeNode(): + m_index(-1), + m_ref(false), + m_length(0), + m_child0(nullptr), + m_child15(nullptr), + m_suffix(nullptr) + {} + + void SetChild(uint8_t p, DictTreeNode *child) + { + if (p == 0) + m_child0 = child; + else if (p == 15) + m_child15 = child; + else if (p > 15) + throw std::logic_error("invalid pixel alpha: " + std::to_string(p)); + else + { + if (!m_children) + { + m_children.reset(new DictTreeNode*[14]()); + } + m_children[p - 1] = child; + } + } + + DictTreeNode* GetChild(uint8_t p) const + { + if (p == 0) + return m_child0; + else if (p == 15) + return m_child15; + else if (p > 15) + throw std::logic_error("invalid pixel alpha: " + std::to_string(p)); + else if (!m_children) + return nullptr; + else + return m_children[p - 1]; + } + + bool HasIntermediateChildren() const { return m_children != nullptr; } + + int GetIndex() const { return m_index; } + void SetIndex(int index) { m_index = index; } + bool GetRef() const { return m_ref; } + void SetRef(bool ref) { m_ref = ref; } + size_t GetLength() const { return m_length; } + void SetLength(size_t length) { m_length = length; } + DictTreeNode *GetSuffix() const { return m_suffix; } + void SetSuffix(DictTreeNode *suffix) { m_suffix = suffix; } + +private: + // Index of dictionary entry or -1 if just a intermediate node. + int m_index; + + // True for ref-encoded dictionary entries. Used to avoid recursion when + // encoding them. + bool m_ref; + + // Length of the corresponding dictionary entry replacement. + // Equals the distance from the tree root. + size_t m_length; + + // Most tree nodes will only ever contains children for 0 or 15. + // Therefore the array for other nodes is allocated only on demand. + DictTreeNode *m_child0; + DictTreeNode *m_child15; + std::unique_ptr m_children; + + // Pointer to the longest suffix of this entry that exists in the + // dictionary. + DictTreeNode *m_suffix; +}; + +// Preallocated array for tree nodes +class TreeAllocator +{ +public: + TreeAllocator(size_t count) + { + m_storage.reset(new DictTreeNode[count]); + m_next = m_storage.get(); + m_left = count; + } + + DictTreeNode *allocate() + { + if (m_left == 0) + throw std::logic_error("Ran out of preallocated entries"); + + m_left--; + return m_next++; + } + +private: + std::unique_ptr m_storage; + DictTreeNode *m_next; + size_t m_left; +}; + +// Add a new dictionary entry to the tree. Adds the intermediate nodes, but +// does not yet fill the suffix pointers. +static DictTreeNode* add_tree_entry(const DataFile::pixels_t &entry, int index, + bool ref_encoded, DictTreeNode *root, + TreeAllocator &storage) +{ + DictTreeNode* node = root; + for (uint8_t p : entry) + { + DictTreeNode* branch = node->GetChild(p); + if (!branch) + { + branch = storage.allocate(); + node->SetChild(p, branch); + } + + node = branch; + } + + // Replace the entry if it either does not yet have an encoding, or if + // the new entry is non-ref (i.e. can be used in more situations). + if (node->GetIndex() < 0 || (node->GetRef() && !ref_encoded)) + { + node->SetIndex(index); + node->SetRef(ref_encoded); + node->SetLength(entry.size()); + } + + return node; +} + +// Walk the tree and find if the entry exists in the tree. If it does, +// returns a pointer to it, otherwise nullptr. +static DictTreeNode *find_tree_node(DataFile::pixels_t::const_iterator begin, + DataFile::pixels_t::const_iterator end, + DictTreeNode *root) +{ + DictTreeNode* node = root; + while (begin != end) + { + uint8_t pixel = *begin++; + node = node->GetChild(pixel); + + if (!node) + return nullptr; + } + + return node; +} + +// Fill in the suffix pointers recursively for the given subtree. +static void fill_tree_suffixes(DictTreeNode *root, DictTreeNode *subtree, + const DataFile::pixels_t &entry) +{ + for (size_t i = 1; i < entry.size(); i++) + { + DictTreeNode *node = find_tree_node(entry.begin() + i, entry.end(), root); + if (node) + { + subtree->SetSuffix(node); + break; + } + } + + if (!subtree->GetSuffix()) + subtree->SetSuffix(root); + + DataFile::pixels_t newentry(entry); + newentry.resize(entry.size() + 1); + for (uint8_t i = 0; i < 16; i++) + { + // Speed-up for the common case of 0 and 15 alphas. + if (i == 1 && !subtree->HasIntermediateChildren()) + i += 14; + + DictTreeNode *child = subtree->GetChild(i); + if (child) + { + newentry.at(entry.size()) = i; + fill_tree_suffixes(root, child, newentry); + } + } +} + +// Construct a lookup tree from the dictionary entries. +static DictTreeNode* construct_tree(const std::vector &dictionary, + TreeAllocator &storage, bool fast) +{ + DictTreeNode* root = storage.allocate(); + + // Populate the hardcoded entries for 0 to 15 alpha. + for (int j = 0; j < 16; j++) + { + DictTreeNode *node = storage.allocate(); + node->SetIndex(j); + node->SetRef(false); + node->SetLength(1); + root->SetChild(j, node); + } + + // Populate the actual dictionary entries + size_t i = DICT_START; + for (DataFile::dictentry_t d : dictionary) + { + if (!d.replacement.size()) + break; + + add_tree_entry(d.replacement, i, d.ref_encode, root, storage); + i++; + } + + if (!fast) + { + // Populate the fill entries for rest of dictionary + for (; i < 256; i++) + { + DataFile::pixels_t pixels; + size_t bitcount = fillentry_bitcount(i); + uint8_t byte = i - DICT_START7BIT; + for (size_t j = 0; j < bitcount; j++) + { + uint8_t p = (byte & (1 << j)) ? 15 : 0; + pixels.push_back(p); + } + + add_tree_entry(pixels, i, false, root, storage); + } + + // Fill in the suffix pointers for optimal encoding + DataFile::pixels_t nullentry; + fill_tree_suffixes(root, root, nullentry); + } + + return root; +} + +// Structure for keeping track of the shortest encoding to reach particular +// point of the pixel string. +struct encoding_link_t +{ + // Index of the position prior to the last dictionary entry. + size_t previous; + + // Index of the dictionary entry that brings us to this point. + int index; + + // Number of links to get here from the start of the string. + size_t length; + + constexpr encoding_link_t(): previous(0), index(-1), length(9999999) {} +}; + +// Perform the reference encoding for a glyph entry (optimal version). +// Uses a modified Aho-Corasick algorithm combined with breadth first search +// to find the shortest representation. +static encoded_font_t::refstring_t encode_ref_slow(const DataFile::pixels_t &pixels, + const DictTreeNode *root, + bool is_glyph) +{ + // Chain of encodings. Each entry in this array corresponds to a position + // in the pixel string. + std::unique_ptr chain(new encoding_link_t[pixels.size() + 1]); + + chain[0].previous = 0; + chain[0].index = 0; + chain[0].length = 0; + + // Read the pixels one-by-one and update the encoding links accordingly. + const DictTreeNode *node = root; + for (size_t pos = 0; pos < pixels.size(); pos++) + { + uint8_t pixel = pixels.at(pos); + const DictTreeNode *branch = node->GetChild(pixel); + + while (!branch) + { + // Cannot expand this sequence, defer to suffix. + node = node->GetSuffix(); + branch = node->GetChild(pixel); + } + + node = branch; + + // We have arrived at a new node, add it and any proper suffixes to + // the link chain. + const DictTreeNode *suffix = node; + while (suffix != root) + { + if (suffix->GetIndex() >= 0 && (is_glyph || !suffix->GetRef())) + { + encoding_link_t link; + link.previous = pos + 1 - suffix->GetLength(); + link.index = suffix->GetIndex(); + link.length = chain[link.previous].length + 1; + + if (link.length < chain[pos + 1].length) + chain[pos + 1] = link; + } + suffix = suffix->GetSuffix(); + } + } + + // Check if we can shorten the final encoding using REF_FILLZEROS. + if (is_glyph) + { + for (size_t pos = pixels.size() - 1; pos > 0; pos--) + { + if (pixels.at(pos) != 0) + break; + + encoding_link_t link; + link.previous = pos; + link.index = REF_FILLZEROS; + link.length = chain[pos].length + 1; + + if (link.length <= chain[pixels.size()].length) + chain[pixels.size()] = link; + } + } + + // Backtrack from the final link back to the start and construct the + // encoded string. + encoded_font_t::refstring_t result; + size_t len = chain[pixels.size()].length; + result.resize(len); + + size_t pos = pixels.size(); + for (size_t i = len; i > 0; i--) + { + result.at(i - 1) = chain[pos].index; + pos = chain[pos].previous; + } + + return result; +} + +// Walk the tree as far as possible following the given pixel string iterator. +// Returns number of pixels encoded, and index is set to the dictionary reference. +static size_t walk_tree(const DictTreeNode *tree, + DataFile::pixels_t::const_iterator pixels, + DataFile::pixels_t::const_iterator pixelsend, + int &index, bool is_glyph) +{ + size_t best_length = 0; + size_t length = 0; + index = -1; + + const DictTreeNode* node = tree; + while (pixels != pixelsend) + { + uint8_t pixel = *pixels++; + node = node->GetChild(pixel); + + if (!node) + break; + + length++; + + if (is_glyph || !node->GetRef()) + { + if (node->GetIndex() >= 0) + { + index = node->GetIndex(); + best_length = length; + } + } + } + + if (index < 0) + throw std::logic_error("walk_tree failed to find a valid encoding"); + + return best_length; +} + +// Perform the reference encoding for a glyph entry (fast version). +// Uses a simple greedy search to find select the encodings. +static encoded_font_t::refstring_t encode_ref_fast(const DataFile::pixels_t &pixels, + const DictTreeNode *tree, + bool is_glyph) +{ + encoded_font_t::refstring_t result; + + // Strip any zeroes from end + size_t end = pixels.size(); + + if (is_glyph) + { + while (end > 0 && pixels.at(end - 1) == 0) end--; + } + + size_t i = 0; + while (i < end) + { + int index; + i += walk_tree(tree, pixels.begin() + i, pixels.end(), index, is_glyph); + result.push_back(index); + } + + if (i < pixels.size()) + result.push_back(REF_FILLZEROS); + + return result; +} + +static encoded_font_t::refstring_t encode_ref(const DataFile::pixels_t &pixels, + const DictTreeNode *tree, + bool is_glyph, bool fast) +{ + if (fast) + return encode_ref_fast(pixels, tree, is_glyph); + else + return encode_ref_slow(pixels, tree, is_glyph); +} + +// Compare dictionary entries by their coding type. +// Sorts RLE-encoded entries first and any empty entries last. +static bool cmp_dict_coding(const DataFile::dictentry_t &a, + const DataFile::dictentry_t &b) +{ + if (a.replacement.size() == 0 && b.replacement.size() != 0) + return false; + else if (a.replacement.size() != 0 && b.replacement.size() == 0) + return true; + else if (a.ref_encode == false && b.ref_encode == true) + return true; + else + return false; +} + +size_t estimate_tree_node_count(const std::vector &dict) +{ + size_t count = DICT_START; // Preallocated entries + for (const DataFile::dictentry_t &d: dict) + { + count += d.replacement.size(); + } + count += 128 * 7; // Fill entries + return count; +} + +std::unique_ptr encode_font(const DataFile &datafile, + bool fast) +{ + std::unique_ptr result(new encoded_font_t); + + // Sort the dictionary so that RLE-coded entries come first. + // This way the two are easy to distinguish based on index. + std::vector sorted_dict = datafile.GetDictionary(); + std::stable_sort(sorted_dict.begin(), sorted_dict.end(), cmp_dict_coding); + + // Build the binary tree for looking up references. + size_t count = estimate_tree_node_count(sorted_dict); + TreeAllocator allocator(count); + DictTreeNode* tree = construct_tree(sorted_dict, allocator, fast); + + // Encode the dictionary entries, using either RLE or reference method. + for (const DataFile::dictentry_t &d : sorted_dict) + { + if (d.replacement.size() == 0) + { + continue; + } + else if (d.ref_encode) + { + result->ref_dictionary.push_back(encode_ref(d.replacement, tree, false, fast)); + } + else + { + result->rle_dictionary.push_back(encode_rle(d.replacement)); + } + } + + // Then reference-encode the glyphs + for (const DataFile::glyphentry_t &g : datafile.GetGlyphTable()) + { + result->glyphs.push_back(encode_ref(g.data, tree, true, fast)); + } + + // Optionally verify that the encoding was correct. + if (!fast) + { + for (size_t i = 0; i < datafile.GetGlyphCount(); i++) + { + std::unique_ptr decoded = + decode_glyph(*result, i, datafile.GetFontInfo()); + if (*decoded != datafile.GetGlyphEntry(i).data) + { + auto iter = std::mismatch(decoded->begin(), decoded->end(), + datafile.GetGlyphEntry(i).data.begin()); + size_t pos = iter.first - decoded->begin(); + throw std::logic_error("verification of glyph " + std::to_string(i) + + " failed at position " + std::to_string(pos)); + } + } + } + + return result; +} + +size_t get_encoded_size(const encoded_font_t &encoded) +{ + size_t total = 0; + for (const encoded_font_t::rlestring_t &r : encoded.rle_dictionary) + { + total += r.size(); + + if (r.size() != 0) + total += 2; // Offset table entry + } + for (const encoded_font_t::refstring_t &r : encoded.ref_dictionary) + { + total += r.size(); + + if (r.size() != 0) + total += 2; // Offset table entry + } + for (const encoded_font_t::refstring_t &r : encoded.glyphs) + { + total += r.size(); + total += 2; // Offset table entry + total += 1; // Width table entry + } + return total; +} + +std::unique_ptr decode_glyph( + const encoded_font_t &encoded, + const encoded_font_t::refstring_t &refstring, + const DataFile::fontinfo_t &fontinfo) +{ + std::unique_ptr result(new DataFile::pixels_t); + + for (uint8_t ref : refstring) + { + if (ref <= 15) + { + result->push_back(ref); + } + else if (ref == REF_FILLZEROS) + { + result->resize(fontinfo.max_width * fontinfo.max_height, 0); + } + else if (ref < DICT_START) + { + throw std::logic_error("unknown code: " + std::to_string(ref)); + } + else if (ref - DICT_START < (int)encoded.rle_dictionary.size()) + { + for (uint8_t rle : encoded.rle_dictionary.at(ref - DICT_START)) + { + if ((rle & RLE_CODEMASK) == RLE_ZEROS) + { + for (int i = 0; i < (rle & RLE_VALMASK); i++) + { + result->push_back(0); + } + } + else if ((rle & RLE_CODEMASK) == RLE_64ZEROS) + { + for (int i = 0; i < ((rle & RLE_VALMASK) + 1) * 64; i++) + { + result->push_back(0); + } + } + else if ((rle & RLE_CODEMASK) == RLE_ONES) + { + for (int i = 0; i < (rle & RLE_VALMASK) + 1; i++) + { + result->push_back(15); + } + } + else if ((rle & RLE_CODEMASK) == RLE_SHADE) + { + uint8_t count, alpha; + count = ((rle & RLE_VALMASK) >> 4) + 1; + alpha = ((rle & RLE_VALMASK) & 0xF); + for (int i = 0; i < count; i++) + { + result->push_back(alpha); + } + } + } + } + else if (ref - DICT_START - encoded.rle_dictionary.size() < encoded.ref_dictionary.size()) + { + size_t index = ref - DICT_START - encoded.rle_dictionary.size(); + std::unique_ptr part = + decode_glyph(encoded, encoded.ref_dictionary.at(index), + fontinfo); + result->insert(result->end(), part->begin(), part->end()); + } + else + { + size_t bitcount = fillentry_bitcount(ref); + + uint8_t byte = ref - DICT_START7BIT; + for (size_t i = 0; i < bitcount; i++) + { + uint8_t p = (byte & (1 << i)) ? 15 : 0; + result->push_back(p); + } + } + } + + return result; +} + +std::unique_ptr decode_glyph( + const encoded_font_t &encoded, size_t index, + const DataFile::fontinfo_t &fontinfo) +{ + return decode_glyph(encoded, encoded.glyphs.at(index), fontinfo); +} + +}} diff --git a/contrib/mcufont/encoder/encode_rlefont.hh b/contrib/mcufont/encoder/encode_rlefont.hh new file mode 100644 index 000000000..82e72523f --- /dev/null +++ b/contrib/mcufont/encoder/encode_rlefont.hh @@ -0,0 +1,126 @@ +// Given a dictionary and glyphs, encode the data for all the glyphs. + +#pragma once + +#include "datafile.hh" +#include +#include + +namespace mcufont { +namespace rlefont { + +struct encoded_font_t +{ + // RLE-encoded format for storing the dictionary entries. + // Each item is a byte. Top bit means the value in the original bitstream, + // and the bottom 7 bits store the repetition count. + typedef std::vector rlestring_t; + + // Reference encoded format for storing the glyphs. + // Each item is a reference to the dictionary. + // Values 0 and 1 are hardcoded to mean 0 and 1. + // All other values mean dictionary entry at (i-2). + typedef std::vector refstring_t; + + std::vector rle_dictionary; + std::vector ref_dictionary; + std::vector glyphs; +}; + +// Encode all the glyphs. +std::unique_ptr encode_font(const DataFile &datafile, + bool fast = true); + +// Sum up the total size of the encoded glyphs + dictionary. +size_t get_encoded_size(const encoded_font_t &encoded); + +inline size_t get_encoded_size(const DataFile &datafile, bool fast = true) +{ + std::unique_ptr e = encode_font(datafile, fast); + return get_encoded_size(*e); +} + +// Decode a single glyph (for verification). +std::unique_ptr decode_glyph( + const encoded_font_t &encoded, + const encoded_font_t::refstring_t &refstring, + const DataFile::fontinfo_t &fontinfo); + +// Decode a single glyph (for verification). +std::unique_ptr decode_glyph( + const encoded_font_t &encoded, size_t index, + const DataFile::fontinfo_t &fontinfo); + +}} + + +#ifdef CXXTEST_RUNNING +#include + +using namespace mcufont; +using namespace mcufont::rlefont; + +class RLEFontEncodeTests: public CxxTest::TestSuite +{ +public: + void testEncode() + { + std::istringstream s(testfile); + std::unique_ptr f = DataFile::Load(s); + std::unique_ptr e = encode_font(*f, false); + + TS_ASSERT_EQUALS(e->glyphs.size(), 3); + + // Expected values for dictionary + encoded_font_t::rlestring_t dict0 = {0x01, 0xCE, 0x01, 0xCE}; + encoded_font_t::rlestring_t dict1 = {0x0C}; + encoded_font_t::rlestring_t dict2 = {0xFE}; + encoded_font_t::refstring_t dict3 = {24, 24}; + + TS_ASSERT(e->rle_dictionary.at(0) == dict0); + TS_ASSERT(e->rle_dictionary.at(1) == dict1); + TS_ASSERT(e->rle_dictionary.at(2) == dict2); + TS_ASSERT(e->ref_dictionary.at(0) == dict3); + + // Expected values for glyphs + encoded_font_t::refstring_t glyph0 = {27, 27, 27}; + encoded_font_t::refstring_t glyph1 = {24, 0, 132, 25, 14}; + encoded_font_t::refstring_t glyph2 = {228, 26, 244, 14, 14, 14, 228, 26, 16}; + + TS_ASSERT_EQUALS(e->glyphs.at(0), glyph0); + TS_ASSERT_EQUALS(e->glyphs.at(1), glyph1); + TS_ASSERT_EQUALS(e->glyphs.at(2), glyph2); + } + + void testDecode() + { + std::istringstream s(testfile); + std::unique_ptr f = DataFile::Load(s); + std::unique_ptr e = encode_font(*f, false); + + for (size_t i = 0; i < 3; i++) + { + std::unique_ptr dec; + dec = decode_glyph(*e, i, f->GetFontInfo()); + + TS_ASSERT_EQUALS(*dec, f->GetGlyphEntry(i).data); + } + } + +private: + static constexpr const char *testfile = + "Version 1\n" + "FontName Sans Serif\n" + "MaxWidth 4\n" + "MaxHeight 6\n" + "BaselineX 1\n" + "BaselineY 1\n" + "DictEntry 1 0 0E0E\n" + "DictEntry 1 0 000000000000\n" + "DictEntry 1 0 EEEE\n" + "DictEntry 1 1 0E0E0E0E\n" + "Glyph 0 4 0E0E0E0E0E0E0E0E0E0E0E0E\n" + "Glyph 1 4 0E0E0000000000000000000E\n" + "Glyph 2 4 0000EEEE000EEE0000EEEE00\n"; +}; +#endif diff --git a/contrib/mcufont/encoder/export_bwfont.cc b/contrib/mcufont/encoder/export_bwfont.cc new file mode 100644 index 000000000..6fe9e53c2 --- /dev/null +++ b/contrib/mcufont/encoder/export_bwfont.cc @@ -0,0 +1,250 @@ +#include "export_bwfont.hh" +#include +#include +#include +#include +#include +#include +#include +#include "exporttools.hh" +#include "importtools.hh" +#include "ccfixes.hh" + +#define BWFONT_FORMAT_VERSION 4 + +namespace mcufont { +namespace bwfont { + +static void encode_glyph(const DataFile::glyphentry_t &glyph, + const DataFile::fontinfo_t &fontinfo, + std::vector &dest, + int num_cols) +{ + const int threshold = 8; + + if (glyph.data.size() == 0) + return; + + // Find the number of columns in the glyph data + if (num_cols == 0) + { + for (int x = 0; x < fontinfo.max_width; x++) + { + for (int y = 0; y < fontinfo.max_height; y++) + { + size_t index = y * fontinfo.max_width + x; + if (glyph.data.at(index) >= threshold) + num_cols = x + 1; + } + } + } + + // Write the bits that compose the glyph + for (int x = 0; x < num_cols; x++) + { + for (int y = 0; y < fontinfo.max_height; y+= 8) + { + size_t remain = std::min(8, fontinfo.max_height - y); + uint8_t byte = 0; + for (size_t i = 0; i < remain; i++) + { + size_t index = (y + i) * fontinfo.max_width + x; + if (glyph.data.at(index) >= threshold) + { + byte |= (1 << i); + } + } + dest.push_back(byte); + } + } +} + +struct cropinfo_t +{ + size_t offset_x; + size_t offset_y; + size_t height_bytes; + size_t height_pixels; + size_t width; +}; + +static void encode_character_range(std::ostream &out, + const std::string &name, + const DataFile &datafile, + const char_range_t &range, + unsigned range_index, + cropinfo_t &cropinfo) +{ + std::vector glyphs; + bool constant_width = true; + int width = datafile.GetGlyphEntry(range.glyph_indices[0]).width; + + // Copy all the glyphs in this range for the purpose of cropping them. + for (int glyph_index: range.glyph_indices) + { + if (glyph_index < 0) + { + // Missing glyph + DataFile::glyphentry_t dummy = {}; + glyphs.push_back(dummy); + } + else + { + auto glyph = datafile.GetGlyphEntry(glyph_index); + glyphs.push_back(glyph); + + if (glyph.width != width) + { + constant_width = false; + width = 0; + } + } + } + + // Crop the glyphs in this range. Getting rid of a few rows at top + // or left can save a bunch of bytes with minimal cost. + DataFile::fontinfo_t old_fi = datafile.GetFontInfo(); + DataFile::fontinfo_t new_fi = old_fi; + crop_glyphs(glyphs, new_fi); + + if (new_fi.max_width != width) + { + constant_width = false; + width = 0; + } + + // Fill in the crop information + cropinfo.offset_x = old_fi.baseline_x - new_fi.baseline_x; + cropinfo.offset_y = old_fi.baseline_y - new_fi.baseline_y; + cropinfo.height_pixels = new_fi.max_height; + cropinfo.height_bytes = (cropinfo.height_pixels + 7) / 8; + cropinfo.width = width; + + // Then format and write out the glyph data + std::vector offsets; + std::vector data; + std::vector widths; + size_t stride = cropinfo.height_bytes; + + for (const DataFile::glyphentry_t &g : glyphs) + { + offsets.push_back(data.size() / stride); + widths.push_back(g.width); + encode_glyph(g, new_fi, data, width); + } + offsets.push_back(data.size() / stride); + + write_const_table(out, data, "uint8_t", "mf_bwfont_" + name + "_glyph_data_" + std::to_string(range_index), 1); + + if (!constant_width) + { + write_const_table(out, offsets, "uint16_t", "mf_bwfont_" + name + "_glyph_offsets_" + std::to_string(range_index), 1, 4); + write_const_table(out, widths, "uint8_t", "mf_bwfont_" + name + "_glyph_widths_" + std::to_string(range_index), 1); + } +} + +void write_source(std::ostream &out, std::string name, const DataFile &datafile) +{ + name = filename_to_identifier(name); + + out << std::endl; + out << std::endl; + out << "/* Start of automatically generated font definition for " << name << ". */" << std::endl; + out << std::endl; + + out << "#ifndef MF_BWFONT_INTERNALS" << std::endl; + out << "#define MF_BWFONT_INTERNALS" << std::endl; + out << "#endif" << std::endl; + out << "#include \"mf_bwfont.h\"" << std::endl; + out << std::endl; + + out << "#ifndef MF_BWFONT_VERSION_" << BWFONT_FORMAT_VERSION << "_SUPPORTED" << std::endl; + out << "#error The font file is not compatible with this version of mcufont." << std::endl; + out << "#endif" << std::endl; + out << std::endl; + + // Split the characters into ranges + DataFile::fontinfo_t f = datafile.GetFontInfo(); + size_t glyph_size = f.max_width * ((f.max_height + 7) / 8); + auto get_glyph_size = [=](size_t i) { return glyph_size; }; + std::vector ranges = compute_char_ranges(datafile, + get_glyph_size, 65536, 16); + + // Write out glyph data for character ranges + std::vector crops; + for (size_t i = 0; i < ranges.size(); i++) + { + cropinfo_t cropinfo; + encode_character_range(out, name, datafile, ranges.at(i), i, cropinfo); + crops.push_back(cropinfo); + } + + // Write out a table describing the character ranges + out << "static const struct mf_bwfont_char_range_s mf_bwfont_" + name + "_char_ranges[] = {" << std::endl; + for (size_t i = 0; i < ranges.size(); i++) + { + std::string offsets = (crops[i].width) ? "0" : "mf_bwfont_" + name + "_glyph_offsets_" + std::to_string(i); + std::string widths = (crops[i].width) ? "0" : "mf_bwfont_" + name + "_glyph_widths_" + std::to_string(i); + + out << " {" << std::endl; + out << " " << ranges.at(i).first_char << ", /* first char */" << std::endl; + out << " " << ranges.at(i).char_count << ", /* char count */" << std::endl; + out << " " << crops[i].offset_x << ", /* offset x */" << std::endl; + out << " " << crops[i].offset_y << ", /* offset y */" << std::endl; + out << " " << crops[i].height_bytes << ", /* height in bytes */" << std::endl; + out << " " << crops[i].height_pixels << ", /* height in pixels */" << std::endl; + out << " " << crops[i].width << ", /* width */" << std::endl; + out << " " << widths << ", /* glyph widths */" << std::endl; + out << " " << offsets << ", /* glyph offsets */" << std::endl; + out << " " << "mf_bwfont_" << name << "_glyph_data_" << i << ", /* glyph data */" << std::endl; + out << " }," << std::endl; + } + out << "};" << std::endl; + out << std::endl; + + // Fonts in this format are always black & white + int flags = datafile.GetFontInfo().flags | DataFile::FLAG_BW; + + // Pull it all together in the rlefont_s structure. + out << "const struct mf_bwfont_s mf_bwfont_" << name << " = {" << std::endl; + out << " {" << std::endl; + out << " " << "\"" << datafile.GetFontInfo().name << "\"," << std::endl; + out << " " << "\"" << name << "\"," << std::endl; + out << " " << datafile.GetFontInfo().max_width << ", /* width */" << std::endl; + out << " " << datafile.GetFontInfo().max_height << ", /* height */" << std::endl; + out << " " << get_min_x_advance(datafile) << ", /* min x advance */" << std::endl; + out << " " << get_max_x_advance(datafile) << ", /* max x advance */" << std::endl; + out << " " << datafile.GetFontInfo().baseline_x << ", /* baseline x */" << std::endl; + out << " " << datafile.GetFontInfo().baseline_y << ", /* baseline y */" << std::endl; + out << " " << datafile.GetFontInfo().line_height << ", /* line height */" << std::endl; + out << " " << flags << ", /* flags */" << std::endl; + out << " " << select_fallback_char(datafile) << ", /* fallback character */" << std::endl; + out << " " << "&mf_bwfont_character_width," << std::endl; + out << " " << "&mf_bwfont_render_character," << std::endl; + out << " }," << std::endl; + + out << " " << BWFONT_FORMAT_VERSION << ", /* version */" << std::endl; + out << " " << ranges.size() << ", /* char range count */" << std::endl; + out << " " << "mf_bwfont_" << name << "_char_ranges," << std::endl; + out << "};" << std::endl; + + // Write the font lookup structure + out << std::endl; + out << "#ifdef MF_INCLUDED_FONTS" << std::endl; + out << "/* List entry for searching fonts by name. */" << std::endl; + out << "static const struct mf_font_list_s mf_bwfont_" << name << "_listentry = {" << std::endl; + out << " MF_INCLUDED_FONTS," << std::endl; + out << " (struct mf_font_s*)&mf_bwfont_" << name << std::endl; + out << "};" << std::endl; + out << "#undef MF_INCLUDED_FONTS" << std::endl; + out << "#define MF_INCLUDED_FONTS (&mf_bwfont_" << name << "_listentry)" << std::endl; + out << "#endif" << std::endl; + + out << std::endl; + out << std::endl; + out << "/* End of automatically generated font definition for " << name << ". */" << std::endl; + out << std::endl; +} + + +}} diff --git a/contrib/mcufont/encoder/export_bwfont.hh b/contrib/mcufont/encoder/export_bwfont.hh new file mode 100644 index 000000000..64b21bc72 --- /dev/null +++ b/contrib/mcufont/encoder/export_bwfont.hh @@ -0,0 +1,16 @@ +// Write out the encoded data in C source code files for mf_bwfont format. + +#pragma once + +#include "datafile.hh" +#include + +namespace mcufont { +namespace bwfont { + +void write_header(std::ostream &out, std::string name, const DataFile &datafile); + +void write_source(std::ostream &out, std::string name, const DataFile &datafile); + +} } + diff --git a/contrib/mcufont/encoder/export_rlefont.cc b/contrib/mcufont/encoder/export_rlefont.cc new file mode 100644 index 000000000..e8135ea37 --- /dev/null +++ b/contrib/mcufont/encoder/export_rlefont.cc @@ -0,0 +1,336 @@ +#include "export_rlefont.hh" +#include +#include +#include +#include +#include +#include +#include +#include "exporttools.hh" +#include "ccfixes.hh" + +#include +#include +#include +#include + +#define RLEFONT_FORMAT_VERSION 5 +#define RELFONT_HDR_LEN 64 +#define RELFONT_RANGE_HDR_LEN 16 + +#define MAX_RANGES 32 + +enum { + MCUFO_MAGIC = 0, + MCUFO_FLAGS_VER = 4, + MCUFO_FOFS_FULLNAME = 8, + MCUFO_FOFS_NAME = 0xc, + MCUFO_FOFS_DICT_DATA = 0x10, + MCUFO_SIZE_DICT_DATA = 0x14, + MCUFO_FOFS_DICT_OFS = 0x18, + MCUFO_COUNT_RLE_DICT = 0x1C, + MCUFO_COUNT_REF_RLE_DICT = 0x20, + MCUFO_FOFS_CHAR_RANGE_TABLES = 0x24, + MCUFO_COUNT_CHAR_RANGE_TABLES = 0x28, + MCUFO_UNICODE_FALLBACK = 0x2C, + + MCUFO16_WIDTH = 0x30, + MCUFO16_HEIGHT = 0x32, + MCUFO16_MIN_X_ADV = 0x34, + MCUFO16_MAX_X_ADV = 0x36, + MCUFO16_BASELINE_X = 0x38, + MCUFO16_BASELINE_Y = 0x3a, + MCUFO16_LINE_HEIGHT = 0x3c, + + MCUFO16_RESERVED = 0x3e +}; + +namespace mcufont { +namespace rlefont { + +int fd, fd1; +uint8_t hdr[RELFONT_HDR_LEN]; +uint32_t fofs_range_ofs[32], fofs_range_data[32]; + +static void +out32(uint8_t *b, uint32_t u) +{ + *b++ = (uint8_t)((u >> 24) & 0xff); + *b++ = (uint8_t)((u >> 16) & 0xff); + *b++ = (uint8_t)((u >> 8) & 0xff); + *b++ = (uint8_t)((u) & 0xff); +} + +static uint32_t +in32(const uint8_t *b) +{ + return ((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]); +} + +static void +out16(uint8_t *b, uint16_t u) +{ + *b++ = (uint8_t)((u >> 8) & 0xff); + *b++ = (uint8_t)((u) & 0xff); +} + +void write_source(std::ostream &out, std::string _name, const DataFile &datafile) +{ + std::string name = filename_to_identifier(_name), n1 = _name; + std::unique_ptr encoded = encode_font(datafile, false); + std::vector ranges; + uint32_t filesize, cri; + char line[200]; + size_t m, cc, ao = 0; + + auto get_glyph_size = [&encoded](size_t i) + { + return encoded->glyphs[i].size() + 1; // +1 byte for glyph width + }; + + std::cout << "Writing " + n1 + '\n'; + fd = open(n1.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0600); + if (fd < 0) { + fprintf(stderr, "Failed to open %s\n", n1.c_str()); + return; + } + + /* placeholder for header */ + if (write(fd, hdr, RELFONT_HDR_LEN) < 0) + goto fail; + + hdr[MCUFO_MAGIC] = 'M'; + hdr[MCUFO_MAGIC + 1] = 'C'; + hdr[MCUFO_MAGIC + 2] = 'U'; + hdr[MCUFO_MAGIC + 3] = 'F'; + out32(&hdr[MCUFO_FLAGS_VER], (datafile.GetFontInfo().flags << 8) | RLEFONT_FORMAT_VERSION); + out32(&hdr[MCUFO_FOFS_FULLNAME], (uint32_t)lseek(fd, 0, SEEK_END)); + if (write(fd, datafile.GetFontInfo().name.c_str(), + strlen(datafile.GetFontInfo().name.c_str()) + 1) < 0) + goto fail; + out32(&hdr[MCUFO_FOFS_NAME], (uint32_t)lseek(fd, 0, SEEK_END)); + if (write(fd, name.c_str(), strlen(name.c_str()) + 1) < 0) + goto fail; + out32(&hdr[MCUFO_FOFS_DICT_DATA], (uint32_t)lseek(fd, 0, SEEK_END)); + + /* + * Dictionaries + */ + + { + std::vector offsets; + std::vector data; + uint8_t u; + + for (const encoded_font_t::rlestring_t &r : encoded->rle_dictionary) + { + offsets.push_back(data.size()); + data.insert(data.end(), r.begin(), r.end()); + } + + for (const encoded_font_t::refstring_t &r : encoded->ref_dictionary) + { + offsets.push_back(data.size()); + data.insert(data.end(), r.begin(), r.end()); + } + offsets.push_back(data.size()); + + out32(&hdr[MCUFO_SIZE_DICT_DATA], (uint32_t)data.size()); + + for (size_t i = 0; i < data.size(); i++) { + u = data.at(i); + if (write(fd, &u, 1) < 0) + goto fail; + } + + out32(&hdr[MCUFO_FOFS_DICT_OFS], (uint32_t)lseek(fd, 0, SEEK_END)); + + for (size_t i = 0; i < offsets.size(); i++) { + uint16_t u = offsets.at(i); + uint8_t b[2]; + + b[0] = (uint8_t)(u >> 8); + b[1] = (uint8_t)(u & 0xff); + if (write(fd, b, 2) < 0) + goto fail; + } + + out32(&hdr[MCUFO_COUNT_RLE_DICT], (uint32_t)encoded->rle_dictionary.size()); + out32(&hdr[MCUFO_COUNT_REF_RLE_DICT], (uint32_t)(encoded->rle_dictionary.size() + + encoded->ref_dictionary.size())); + } + + /* + * Character ranges + */ + + cri = (uint32_t)lseek(fd, 0, SEEK_END); + + ranges = compute_char_ranges(datafile, get_glyph_size, 65536, 16); + + for (size_t i = 0; i < ranges.size(); i++) + { + std::vector offsets; + std::vector data; + std::map already_encoded; + + for (int glyph_index : ranges.at(i).glyph_indices) + { + if (already_encoded.count(glyph_index)) + { + offsets.push_back(already_encoded[glyph_index]); + } + else + { + encoded_font_t::refstring_t r; + int width = 0; + + if (glyph_index >= 0) + { + r = encoded->glyphs[glyph_index]; + width = datafile.GetGlyphEntry(glyph_index).width; + } + + offsets.push_back(data.size()); + already_encoded[glyph_index] = data.size(); + + data.push_back(width); + data.insert(data.end(), r.begin(), r.end()); + } + } + + fofs_range_ofs[i] = (uint32_t)lseek(fd, 0, SEEK_END); + + for (size_t n = 0; n < offsets.size(); n++) { + uint16_t u = offsets.at(n); + uint8_t b[2]; + + b[0] = (uint8_t)(u >> 8); + b[1] = (uint8_t)(u & 0xff); + write(fd, b, 2); + } + + fofs_range_data[i] = (uint32_t)lseek(fd, 0, SEEK_END); + + for (size_t n = 0; n < data.size(); n++) { + uint8_t u; + + u = data.at(n); + if (write(fd, &u, 1) < 0) + goto fail; + } + } + + out32(&hdr[MCUFO_FOFS_CHAR_RANGE_TABLES], (uint32_t)lseek(fd, 0, SEEK_END)); + out32(&hdr[MCUFO_COUNT_CHAR_RANGE_TABLES], ranges.size()); + + for (size_t i = 0; i < ranges.size(); i++) { + uint8_t rb[16]; + + out32(&rb[0], (uint32_t)ranges.at(i).first_char); + out32(&rb[4], (uint32_t)ranges.at(i).char_count); + out32(&rb[8], (uint32_t)fofs_range_ofs[i]); + out32(&rb[12], (uint32_t)fofs_range_data[i]); + + if (write(fd, rb, 16) < 0) + goto fail; + } + + out32(&hdr[MCUFO_UNICODE_FALLBACK], select_fallback_char(datafile)); + out16(&hdr[MCUFO16_WIDTH], datafile.GetFontInfo().max_width); + out16(&hdr[MCUFO16_HEIGHT], datafile.GetFontInfo().max_height); + out16(&hdr[MCUFO16_MIN_X_ADV], get_min_x_advance(datafile)); + out16(&hdr[MCUFO16_MAX_X_ADV], get_max_x_advance(datafile)); + out16(&hdr[MCUFO16_BASELINE_X], datafile.GetFontInfo().baseline_x); + out16(&hdr[MCUFO16_BASELINE_Y], datafile.GetFontInfo().baseline_y); + out16(&hdr[MCUFO16_LINE_HEIGHT], datafile.GetFontInfo().line_height); + out16(&hdr[MCUFO16_RESERVED], 0); + + filesize = (uint32_t)lseek(fd, 0, SEEK_END); + + if (lseek(fd, 0, SEEK_SET) < 0) + goto fail; + if (write(fd, hdr, RELFONT_HDR_LEN) < 0) + goto fail; + + if (lseek(fd, 0, SEEK_SET) < 0) + goto fail; + + n1.append(".h"); + std::cout << "Writing " + n1 + '\n'; + fd1 = open(n1.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0600); + if (fd1 < 0) { + fprintf(stderr, "Failed to open %s\n", n1.c_str()); + goto fail; + } + + cc = 0; + for (size_t i = 0; i < ranges.size(); i++) + cc += ranges.at(i).char_count - 1; + + m = snprintf(line, sizeof(line) - 1, "/*\n * LWS MCUFONT %s\n * blob size: %u, glyphs %u\n * \n", + datafile.GetFontInfo().name.c_str(), (unsigned int)filesize, + (unsigned int)cc); + + if (write(fd1, line, m) < 0) + goto fail; + + for (size_t i = 0; i < ranges.size(); i++) { + m = snprintf(line, sizeof(line) - 1, " * Unicode 0x%06x - 0x%06x\n", + ranges.at(i).first_char, + ranges.at(i).first_char + ranges.at(i).char_count - 1); + + if (write(fd1, line, m) < 0) + goto fail; + } + + m = snprintf(line, sizeof(line) - 1, "*/\n\n"); + if (write(fd1, line, m) < 0) + goto fail; + + do { + uint8_t b[16]; + size_t n; + ssize_t s; + + s = read(fd, b, sizeof(b)); + if (s <= 0) + break; + m = snprintf(line, sizeof(line) - 2, "/* %04X */ ", ao); + for (n = 0; n < (size_t)s; n++) { + m += snprintf(line + m, sizeof(line) - 2 - m, "0x%02X, ", b[n]); + ao++; + if (ao == in32(&hdr[MCUFO_FOFS_FULLNAME])) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* full name */\n"); + if (ao == in32(&hdr[MCUFO_FOFS_NAME])) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* short name */\n"); + if (ao == in32(&hdr[MCUFO_FOFS_DICT_DATA])) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* dictionary data */\n"); + if (ao == in32(&hdr[MCUFO_FOFS_DICT_OFS])) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* dictionary offset */\n"); + if (ao == cri) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* char range info */\n"); + if (ao == in32(&hdr[MCUFO_FOFS_CHAR_RANGE_TABLES])) + m += snprintf(line + m, sizeof(line) - 2 - m, "\n/* char range ofs tables */\n"); + } + + if (write(fd1, line, m) < 0) + goto fail; + line[0] = '\n'; + if (write(fd1, line, 1) < 0) + goto fail; + } while (1); + close(fd1); + close(fd); + + + + return; + +fail: + close(fd); + fprintf(stderr, "ERROR writing file\n"); +} + +}} + diff --git a/contrib/mcufont/encoder/export_rlefont.hh b/contrib/mcufont/encoder/export_rlefont.hh new file mode 100644 index 000000000..c01c56446 --- /dev/null +++ b/contrib/mcufont/encoder/export_rlefont.hh @@ -0,0 +1,15 @@ +// Write out the encoded data in C source code files for the mf_rlefont format. + +#pragma once + +#include "datafile.hh" +#include "encode_rlefont.hh" +#include + +namespace mcufont { +namespace rlefont { + +void write_source(std::ostream &out, std::string name, const DataFile &datafile); + +} } + diff --git a/contrib/mcufont/encoder/exporttools.cc b/contrib/mcufont/encoder/exporttools.cc new file mode 100644 index 000000000..bee333825 --- /dev/null +++ b/contrib/mcufont/encoder/exporttools.cc @@ -0,0 +1,184 @@ +#include "exporttools.hh" +#include +#include + +namespace mcufont { + + +// Convert a file name to a valid C identifier +std::string filename_to_identifier(std::string name) +{ + // If the name contains path separators (/ or \), take only the last part. + size_t pos = name.find_last_of("/\\"); + if (pos != std::string::npos) + name = name.substr(pos + 1); + + // If the name contains a file extension, strip it. + pos = name.find_first_of("."); + if (pos != std::string::npos) + name = name.substr(0, pos); + + // Replace any special characters with _. + for (pos = 0; pos < name.size(); pos++) + { + if (!isalnum(name.at(pos))) + name.at(pos) = '_'; + } + + return name; +} + +// Write a vector of integers as line-wrapped hex/integer data for initializing const array. +void wordwrap_vector(std::ostream &out, const std::vector &data, + const std::string &prefix, size_t width) +{ + int values_per_column = (width <= 2) ? 16 : 8; + + std::ios::fmtflags flags(out.flags()); + out << prefix; + out << std::hex << std::setfill('0'); + for (size_t i = 0; i < data.size(); i++) + { + if (i % values_per_column == 0 && i != 0) + out << std::endl << prefix; + + out << "0x" << std::setw(width) << (int)data.at(i) << ", "; + } + out.flags(flags); +} + +// Write a vector of integers as a C constant array of given datatype. + void write_const_table(std::ostream &out, const std::vector &data, + const std::string &datatype, const std::string &tablename, char flg_is_data, + size_t width) +{ + out << "static const " << datatype << " " << tablename; + out << "[" << data.size() << "]" << ((flg_is_data)?" PROGMEM ":" ") << "= {" << std::endl; + wordwrap_vector(out, data, " ", width); + out << std::endl << "};" << std::endl; + out << std::endl; +} + +int get_min_x_advance(const DataFile &datafile) +{ + int min = datafile.GetGlyphEntry(0).width; + + for (const DataFile::glyphentry_t &g : datafile.GetGlyphTable()) + { + if (min > g.width) + min = g.width; + } + + return min; +} + +int get_max_x_advance(const DataFile &datafile) +{ + int max = 0; + + for (const DataFile::glyphentry_t &g : datafile.GetGlyphTable()) + { + if (max < g.width) + max = g.width; + } + + return max; +} + +// Select the character to use as a fallback. +int select_fallback_char(const DataFile &datafile) +{ + std::set chars; + + size_t i = 0; + for (const DataFile::glyphentry_t &g: datafile.GetGlyphTable()) + { + for (size_t c: g.chars) + { + chars.insert(c); + } + i++; + } + + if (chars.count(0xFFFD)) + return 0xFFFD; // Unicode replacement character + + if (chars.count(0)) + return 0; // Used by many BDF fonts as replacement char + + if (chars.count('?')) + return '?'; + + return ' '; +} + +// Decide how to best divide the characters in the font into ranges. +// Limitations are: +// - Gaps longer than minimum_gap should result in separate ranges. +// - Each range can have encoded data size of at most maximum_size. +std::vector compute_char_ranges(const DataFile &datafile, + std::function get_encoded_glyph_size, + size_t maximum_size, + size_t minimum_gap) +{ + std::vector result; + std::map char_to_glyph = datafile.GetCharToGlyphMap(); + std::vector chars; + + // Get list of all characters in numeric order. + for (auto iter : char_to_glyph) + chars.push_back(iter.first); + + // Pick out ranges until we have processed all characters + size_t i = 0; + while (i < chars.size()) + { + char_range_t range; + range.first_char = chars.at(i); + + // Find the point where there is a gap larger than minimum_gap. + i++; + while (i < chars.size() && chars.at(i) - chars.at(i - 1) < minimum_gap) + i++; + + uint16_t last_char = chars.at(i - 1); + + // Then store the indices of glyphs for each character + size_t data_length = 0; + for (size_t j = range.first_char; j <= last_char; j++) + { + if (char_to_glyph.count(j) == 0) + { + // Missing character + range.glyph_indices.push_back(-1); + continue; + } + + int glyph_index = char_to_glyph[j]; + + // Monitor the amount of the data in the range and split it + // if it grows too large. + data_length += get_encoded_glyph_size(glyph_index); + if (data_length > maximum_size) + { + last_char = j - 1; + + // Return the rest of characters to be processed by next range. + while (chars.at(i-1) > last_char) + i--; + + break; + } + + range.glyph_indices.push_back(glyph_index); + } + + range.char_count = last_char - range.first_char + 1; + result.push_back(range); + } + + return result; +} + + +} diff --git a/contrib/mcufont/encoder/exporttools.hh b/contrib/mcufont/encoder/exporttools.hh new file mode 100644 index 000000000..68a3f1113 --- /dev/null +++ b/contrib/mcufont/encoder/exporttools.hh @@ -0,0 +1,52 @@ +// Utility functions for exporting to C source code files. + +#pragma once +#include +#include +#include +#include +#include "datafile.hh" + +namespace mcufont { + +// Convert a file name to a valid C identifier +std::string filename_to_identifier(std::string name); + +// Write a vector of integers as line-wrapped hex/integer data for initializing const array. +void wordwrap_vector(std::ostream &out, const std::vector &data, + const std::string &prefix, size_t width = 2); + +// Write a vector of integers as a C constant array of given datatype. +void write_const_table(std::ostream &out, const std::vector &data, + const std::string &datatype, const std::string &tablename, char flg_is_data, + size_t width = 2); + +// Get minimum tracking width of font +int get_min_x_advance(const DataFile &datafile); + +// Get maximum tracking width of font +int get_max_x_advance(const DataFile &datafile); + +// Select the character to use as a fallback. +int select_fallback_char(const DataFile &datafile); + +// Structure to represent one consecutive range of characters. +struct char_range_t +{ + uint16_t first_char; + uint16_t char_count; + std::vector glyph_indices; + + char_range_t(): first_char(0), char_count(0) {} +}; + +// Decide how to best divide the characters in the font into ranges. +// Limitations are: +// - Gaps longer than minimum_gap should result in separate ranges. +// - Each range can have encoded data size of at most maximum_size. +std::vector compute_char_ranges(const DataFile &datafile, + std::function get_encoded_glyph_size, + size_t maximum_size, + size_t minimum_gap); + +} diff --git a/contrib/mcufont/encoder/freetype_import.cc b/contrib/mcufont/encoder/freetype_import.cc new file mode 100644 index 000000000..27a0734d7 --- /dev/null +++ b/contrib/mcufont/encoder/freetype_import.cc @@ -0,0 +1,177 @@ +#include "freetype_import.hh" +#include "importtools.hh" +#include +#include +#include +#include +#include "ccfixes.hh" + +#include +#include FT_FREETYPE_H + +#undef __FTERRORS_H__ +#define FT_ERRORDEF( e, v, s ) std::make_pair( e, s ), +#define FT_ERROR_START_LIST static const std::map ft_errors { +#define FT_ERROR_END_LIST }; +#include FT_ERRORS_H + +namespace mcufont { + +static void checkFT(FT_Error error) +{ + if (error != 0) + { + if (ft_errors.count(error)) + throw std::runtime_error("libfreetype error " + + std::to_string(error) + ": " + ft_errors.at(error)); + else + throw std::runtime_error("unknown libfreetype error " + + std::to_string(error)); + } +} + +// Automatically allocated & freed wrapper for FT_Library +class _FT_Library +{ +public: + _FT_Library() { checkFT(FT_Init_FreeType(&m_lib)); } + ~_FT_Library() { checkFT(FT_Done_FreeType(m_lib)); } + operator FT_Library() { return m_lib; } + +private: + FT_Library m_lib; +}; + +// Automatically allocated & freed wrapper for FT_Face +class _FT_Face +{ +public: + _FT_Face(FT_Library lib, const std::vector &data) + { + checkFT(FT_New_Memory_Face(lib, (const unsigned char *)&data[0], + data.size(), 0, &m_face)); + } + ~_FT_Face() { checkFT(FT_Done_Face(m_face)); } + operator FT_Face() { return m_face; } + FT_Face operator->() { return m_face; } + +private: + FT_Face m_face; +}; + +// Read all the data from a file into a memory buffer. +static void readfile(std::istream &file, std::vector &data) +{ + while (file.good()) + { + const size_t blocksize = 4096; + size_t oldsize = data.size(); + data.resize(oldsize + blocksize); + file.read(&data[oldsize], blocksize); + data.resize(oldsize + file.gcount()); + } +} + +std::unique_ptr LoadFreetype(std::istream &file, int size, bool bw) +{ + std::vector data; + readfile(file, data); + + _FT_Library lib; + _FT_Face face(lib, data); + + checkFT(FT_Set_Pixel_Sizes(face, size, size)); + + DataFile::fontinfo_t fontinfo = {}; + std::vector glyphtable; + std::vector dictionary; + + // Convert size to pixels and round to nearest. + int u_per_em = face->units_per_EM; + auto topx = [size, u_per_em](int s) { return (s * size + u_per_em / 2) / u_per_em; }; + + fontinfo.name = std::string(face->family_name) + " " + + std::string(face->style_name) + " " + + std::to_string(size); + + // Reserve 4 pixels on each side for antialiasing + hinting. + // They will be cropped off later. + fontinfo.max_width = topx(face->bbox.xMax - face->bbox.xMin) + 8; + fontinfo.max_height = topx(face->bbox.yMax - face->bbox.yMin) + 8; + fontinfo.baseline_x = topx(-face->bbox.xMin) + 4; + fontinfo.baseline_y = topx(face->bbox.yMax) + 4; + fontinfo.line_height = topx(face->height); + + FT_Int32 loadmode = FT_LOAD_TARGET_NORMAL | FT_LOAD_RENDER; + + if (bw) + loadmode = FT_LOAD_TARGET_MONO | FT_LOAD_MONOCHROME | FT_LOAD_RENDER; + + FT_ULong charcode; + FT_UInt gindex; + charcode = FT_Get_First_Char(face, &gindex); + while (gindex) + { + try + { + checkFT(FT_Load_Glyph(face, gindex, loadmode)); + } + catch (std::runtime_error &e) + { + std::cerr << "Skipping glyph " << gindex << ": " << e.what() << std::endl; + charcode = FT_Get_Next_Char(face, charcode, &gindex); + } + + DataFile::glyphentry_t glyph; + glyph.width = (face->glyph->advance.x + 32) / 64; + glyph.chars.push_back(charcode); + glyph.data.resize(fontinfo.max_width * fontinfo.max_height); + + int w = face->glyph->bitmap.width; + int dw = fontinfo.max_width; + int dx = fontinfo.baseline_x + face->glyph->bitmap_left; + int dy = fontinfo.baseline_y - face->glyph->bitmap_top; + + /* Some combining diacritics seem to exceed the bounding box. + * We don't support them all that well anyway, so just move + * them inside the box in order not to crash.. */ + if (dy < 0) + dy = 0; + if (dy + face->glyph->bitmap.rows > fontinfo.max_height) + dy = fontinfo.max_height - face->glyph->bitmap.rows; + + size_t s = face->glyph->bitmap.pitch; + for (int y = 0; y < face->glyph->bitmap.rows; y++) + { + for (int x = 0; x < face->glyph->bitmap.width; x++) + { + size_t index = (y + dy) * dw + x + dx; + + if (face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) + { + uint8_t byte = face->glyph->bitmap.buffer[s * y + x / 8]; + byte <<= x % 8; + glyph.data.at(index) = (byte & 0x80) ? 15 : 0; + } + else + { + glyph.data.at(index) = + (face->glyph->bitmap.buffer[w * y + x] + 8) / 17; + } + } + } + glyphtable.push_back(glyph); + + charcode = FT_Get_Next_Char(face, charcode, &gindex); + } + + eliminate_duplicates(glyphtable); + crop_glyphs(glyphtable, fontinfo); + detect_flags(glyphtable, fontinfo); + + std::unique_ptr result(new DataFile( + dictionary, glyphtable, fontinfo)); + return result; +} + +} diff --git a/contrib/mcufont/encoder/freetype_import.hh b/contrib/mcufont/encoder/freetype_import.hh new file mode 100644 index 000000000..eacb8b91e --- /dev/null +++ b/contrib/mcufont/encoder/freetype_import.hh @@ -0,0 +1,10 @@ +// Function for importing any font supported by libfreetype. + +#pragma once +#include "datafile.hh" + +namespace mcufont { + +std::unique_ptr LoadFreetype(std::istream &file, int size, bool bw); + +} diff --git a/contrib/mcufont/encoder/gb2312_in_ucs2.h b/contrib/mcufont/encoder/gb2312_in_ucs2.h new file mode 100644 index 000000000..e6896ada1 --- /dev/null +++ b/contrib/mcufont/encoder/gb2312_in_ucs2.h @@ -0,0 +1,771 @@ +#ifndef __GB2312_IN_UCS2_H__ +#define __GB2312_IN_UCS2_H__ + + +const unsigned short gb2312_in_ucs2_codetable[] = { 0x0020, +0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,0x0028,0x0029,0x002a, +0x002b,0x002c,0x002d,0x002e,0x002f,0x0030,0x0031,0x0032,0x0033,0x0034, +0x0035,0x0036,0x0037,0x0038,0x0039,0x003a,0x003b,0x003c,0x003d,0x003e, +0x003f,0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,0x0048, +0x0049,0x004a,0x004b,0x004c,0x004d,0x004e,0x004f,0x0050,0x0051,0x0052, +0x0053,0x0054,0x0055,0x0056,0x0057,0x0058,0x0059,0x005a,0x005b,0x005c, +0x005d,0x005e,0x005f,0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066, +0x0067,0x0068,0x0069,0x006a,0x006b,0x006c,0x006d,0x006e,0x006f,0x0070, +0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,0x0078,0x0079,0x007a, +0x007b,0x007c,0x007d,0x007e,0x00a4,0x00a7,0x00a8,0x00b0,0x00b1,0x00b7, +0x00d7,0x00e0,0x00e1,0x00e8,0x00e9,0x00ea,0x00ec,0x00ed,0x00f2,0x00f3, +0x00f7,0x00f9,0x00fa,0x00fc,0x0101,0x0113,0x011b,0x012b,0x0144,0x0148, +0x014d,0x016b,0x01ce,0x01d0,0x01d2,0x01d4,0x01d6,0x01d8,0x01da,0x01dc, +0x0251,0x0261,0x02c7,0x02c9,0x0391,0x0392,0x0393,0x0394,0x0395,0x0396, +0x0397,0x0398,0x0399,0x039a,0x039b,0x039c,0x039d,0x039e,0x039f,0x03a0, +0x03a1,0x03a3,0x03a4,0x03a5,0x03a6,0x03a7,0x03a8,0x03a9,0x03b1,0x03b2, +0x03b3,0x03b4,0x03b5,0x03b6,0x03b7,0x03b8,0x03b9,0x03ba,0x03bb,0x03bc, +0x03bd,0x03be,0x03bf,0x03c0,0x03c1,0x03c3,0x03c4,0x03c5,0x03c6,0x03c7, +0x03c8,0x03c9,0x0401,0x0410,0x0411,0x0412,0x0413,0x0414,0x0415,0x0416, +0x0417,0x0418,0x0419,0x041a,0x041b,0x041c,0x041d,0x041e,0x041f,0x0420, +0x0421,0x0422,0x0423,0x0424,0x0425,0x0426,0x0427,0x0428,0x0429,0x042a, +0x042b,0x042c,0x042d,0x042e,0x042f,0x0430,0x0431,0x0432,0x0433,0x0434, +0x0435,0x0436,0x0437,0x0438,0x0439,0x043a,0x043b,0x043c,0x043d,0x043e, +0x043f,0x0440,0x0441,0x0442,0x0443,0x0444,0x0445,0x0446,0x0447,0x0448, +0x0449,0x044a,0x044b,0x044c,0x044d,0x044e,0x044f,0x0451,0x2014,0x2016, +0x2018,0x2019,0x201c,0x201d,0x2026,0x2030,0x2032,0x2033,0x203b,0x2103, +0x2116,0x2160,0x2161,0x2162,0x2163,0x2164,0x2165,0x2166,0x2167,0x2168, +0x2169,0x216a,0x216b,0x2170,0x2171,0x2172,0x2173,0x2174,0x2175,0x2176, +0x2177,0x2178,0x2179,0x2190,0x2191,0x2192,0x2193,0x2208,0x220f,0x2211, +0x221a,0x221d,0x221e,0x2220,0x2225,0x2227,0x2228,0x2229,0x222a,0x222b, +0x222e,0x2234,0x2235,0x2236,0x2237,0x223d,0x2248,0x224c,0x2260,0x2261, +0x2264,0x2265,0x226e,0x226f,0x2299,0x22a5,0x2312,0x2460,0x2461,0x2462, +0x2463,0x2464,0x2465,0x2466,0x2467,0x2468,0x2469,0x2474,0x2475,0x2476, +0x2477,0x2478,0x2479,0x247a,0x247b,0x247c,0x247d,0x247e,0x247f,0x2480, +0x2481,0x2482,0x2483,0x2484,0x2485,0x2486,0x2487,0x2488,0x2489,0x248a, +0x248b,0x248c,0x248d,0x248e,0x248f,0x2490,0x2491,0x2492,0x2493,0x2494, +0x2495,0x2496,0x2497,0x2498,0x2499,0x249a,0x249b,0x2500,0x2501,0x2502, +0x2503,0x2504,0x2505,0x2506,0x2507,0x2508,0x2509,0x250a,0x250b,0x250c, +0x250d,0x250e,0x250f,0x2510,0x2511,0x2512,0x2513,0x2514,0x2515,0x2516, +0x2517,0x2518,0x2519,0x251a,0x251b,0x251c,0x251d,0x251e,0x251f,0x2520, +0x2521,0x2522,0x2523,0x2524,0x2525,0x2526,0x2527,0x2528,0x2529,0x252a, +0x252b,0x252c,0x252d,0x252e,0x252f,0x2530,0x2531,0x2532,0x2533,0x2534, +0x2535,0x2536,0x2537,0x2538,0x2539,0x253a,0x253b,0x253c,0x253d,0x253e, +0x253f,0x2540,0x2541,0x2542,0x2543,0x2544,0x2545,0x2546,0x2547,0x2548, +0x2549,0x254a,0x254b,0x25a0,0x25a1,0x25b2,0x25b3,0x25c6,0x25c7,0x25cb, +0x25ce,0x25cf,0x2605,0x2606,0x2640,0x2642,0x3001,0x3002,0x3003,0x3005, +0x3008,0x3009,0x300a,0x300b,0x300c,0x300d,0x300e,0x300f,0x3010,0x3011, +0x3013,0x3014,0x3015,0x3016,0x3017,0x3041,0x3042,0x3043,0x3044,0x3045, +0x3046,0x3047,0x3048,0x3049,0x304a,0x304b,0x304c,0x304d,0x304e,0x304f, +0x3050,0x3051,0x3052,0x3053,0x3054,0x3055,0x3056,0x3057,0x3058,0x3059, +0x305a,0x305b,0x305c,0x305d,0x305e,0x305f,0x3060,0x3061,0x3062,0x3063, +0x3064,0x3065,0x3066,0x3067,0x3068,0x3069,0x306a,0x306b,0x306c,0x306d, +0x306e,0x306f,0x3070,0x3071,0x3072,0x3073,0x3074,0x3075,0x3076,0x3077, +0x3078,0x3079,0x307a,0x307b,0x307c,0x307d,0x307e,0x307f,0x3080,0x3081, +0x3082,0x3083,0x3084,0x3085,0x3086,0x3087,0x3088,0x3089,0x308a,0x308b, +0x308c,0x308d,0x308e,0x308f,0x3090,0x3091,0x3092,0x3093,0x30a1,0x30a2, +0x30a3,0x30a4,0x30a5,0x30a6,0x30a7,0x30a8,0x30a9,0x30aa,0x30ab,0x30ac, +0x30ad,0x30ae,0x30af,0x30b0,0x30b1,0x30b2,0x30b3,0x30b4,0x30b5,0x30b6, +0x30b7,0x30b8,0x30b9,0x30ba,0x30bb,0x30bc,0x30bd,0x30be,0x30bf,0x30c0, +0x30c1,0x30c2,0x30c3,0x30c4,0x30c5,0x30c6,0x30c7,0x30c8,0x30c9,0x30ca, +0x30cb,0x30cc,0x30cd,0x30ce,0x30cf,0x30d0,0x30d1,0x30d2,0x30d3,0x30d4, +0x30d5,0x30d6,0x30d7,0x30d8,0x30d9,0x30da,0x30db,0x30dc,0x30dd,0x30de, +0x30df,0x30e0,0x30e1,0x30e2,0x30e3,0x30e4,0x30e5,0x30e6,0x30e7,0x30e8, +0x30e9,0x30ea,0x30eb,0x30ec,0x30ed,0x30ee,0x30ef,0x30f0,0x30f1,0x30f2, +0x30f3,0x30f4,0x30f5,0x30f6,0x3105,0x3106,0x3107,0x3108,0x3109,0x310a, +0x310b,0x310c,0x310d,0x310e,0x310f,0x3110,0x3111,0x3112,0x3113,0x3114, +0x3115,0x3116,0x3117,0x3118,0x3119,0x311a,0x311b,0x311c,0x311d,0x311e, +0x311f,0x3120,0x3121,0x3122,0x3123,0x3124,0x3125,0x3126,0x3127,0x3128, +0x3129,0x3220,0x3221,0x3222,0x3223,0x3224,0x3225,0x3226,0x3227,0x3228, +0x3229,0x4e00,0x4e01,0x4e03,0x4e07,0x4e08,0x4e09,0x4e0a,0x4e0b,0x4e0c, +0x4e0d,0x4e0e,0x4e10,0x4e11,0x4e13,0x4e14,0x4e15,0x4e16,0x4e18,0x4e19, +0x4e1a,0x4e1b,0x4e1c,0x4e1d,0x4e1e,0x4e22,0x4e24,0x4e25,0x4e27,0x4e28, +0x4e2a,0x4e2b,0x4e2c,0x4e2d,0x4e30,0x4e32,0x4e34,0x4e36,0x4e38,0x4e39, +0x4e3a,0x4e3b,0x4e3d,0x4e3e,0x4e3f,0x4e43,0x4e45,0x4e47,0x4e48,0x4e49, +0x4e4b,0x4e4c,0x4e4d,0x4e4e,0x4e4f,0x4e50,0x4e52,0x4e53,0x4e54,0x4e56, +0x4e58,0x4e59,0x4e5c,0x4e5d,0x4e5e,0x4e5f,0x4e60,0x4e61,0x4e66,0x4e69, +0x4e70,0x4e71,0x4e73,0x4e7e,0x4e86,0x4e88,0x4e89,0x4e8b,0x4e8c,0x4e8d, +0x4e8e,0x4e8f,0x4e91,0x4e92,0x4e93,0x4e94,0x4e95,0x4e98,0x4e9a,0x4e9b, +0x4e9f,0x4ea0,0x4ea1,0x4ea2,0x4ea4,0x4ea5,0x4ea6,0x4ea7,0x4ea8,0x4ea9, +0x4eab,0x4eac,0x4ead,0x4eae,0x4eb2,0x4eb3,0x4eb5,0x4eba,0x4ebb,0x4ebf, +0x4ec0,0x4ec1,0x4ec2,0x4ec3,0x4ec4,0x4ec5,0x4ec6,0x4ec7,0x4ec9,0x4eca, +0x4ecb,0x4ecd,0x4ece,0x4ed1,0x4ed3,0x4ed4,0x4ed5,0x4ed6,0x4ed7,0x4ed8, +0x4ed9,0x4edd,0x4ede,0x4edf,0x4ee1,0x4ee3,0x4ee4,0x4ee5,0x4ee8,0x4eea, +0x4eeb,0x4eec,0x4ef0,0x4ef2,0x4ef3,0x4ef5,0x4ef6,0x4ef7,0x4efb,0x4efd, +0x4eff,0x4f01,0x4f09,0x4f0a,0x4f0d,0x4f0e,0x4f0f,0x4f10,0x4f11,0x4f17, +0x4f18,0x4f19,0x4f1a,0x4f1b,0x4f1e,0x4f1f,0x4f20,0x4f22,0x4f24,0x4f25, +0x4f26,0x4f27,0x4f2a,0x4f2b,0x4f2f,0x4f30,0x4f32,0x4f34,0x4f36,0x4f38, +0x4f3a,0x4f3c,0x4f3d,0x4f43,0x4f46,0x4f4d,0x4f4e,0x4f4f,0x4f50,0x4f51, +0x4f53,0x4f55,0x4f57,0x4f58,0x4f59,0x4f5a,0x4f5b,0x4f5c,0x4f5d,0x4f5e, +0x4f5f,0x4f60,0x4f63,0x4f64,0x4f65,0x4f67,0x4f69,0x4f6c,0x4f6f,0x4f70, +0x4f73,0x4f74,0x4f76,0x4f7b,0x4f7c,0x4f7e,0x4f7f,0x4f83,0x4f84,0x4f88, +0x4f89,0x4f8b,0x4f8d,0x4f8f,0x4f91,0x4f94,0x4f97,0x4f9b,0x4f9d,0x4fa0, +0x4fa3,0x4fa5,0x4fa6,0x4fa7,0x4fa8,0x4fa9,0x4faa,0x4fac,0x4fae,0x4faf, +0x4fb5,0x4fbf,0x4fc3,0x4fc4,0x4fc5,0x4fca,0x4fce,0x4fcf,0x4fd0,0x4fd1, +0x4fd7,0x4fd8,0x4fda,0x4fdc,0x4fdd,0x4fde,0x4fdf,0x4fe1,0x4fe3,0x4fe6, +0x4fe8,0x4fe9,0x4fea,0x4fed,0x4fee,0x4fef,0x4ff1,0x4ff3,0x4ff8,0x4ffa, +0x4ffe,0x500c,0x500d,0x500f,0x5012,0x5014,0x5018,0x5019,0x501a,0x501c, +0x501f,0x5021,0x5025,0x5026,0x5028,0x5029,0x502a,0x502c,0x502d,0x502e, +0x503a,0x503c,0x503e,0x5043,0x5047,0x5048,0x504c,0x504e,0x504f,0x5055, +0x505a,0x505c,0x5065,0x506c,0x5076,0x5077,0x507b,0x507e,0x507f,0x5080, +0x5085,0x5088,0x508d,0x50a3,0x50a5,0x50a7,0x50a8,0x50a9,0x50ac,0x50b2, +0x50ba,0x50bb,0x50cf,0x50d6,0x50da,0x50e6,0x50e7,0x50ec,0x50ed,0x50ee, +0x50f3,0x50f5,0x50fb,0x5106,0x5107,0x510b,0x5112,0x5121,0x513f,0x5140, +0x5141,0x5143,0x5144,0x5145,0x5146,0x5148,0x5149,0x514b,0x514d,0x5151, +0x5154,0x5155,0x5156,0x515a,0x515c,0x5162,0x5165,0x5168,0x516b,0x516c, +0x516d,0x516e,0x5170,0x5171,0x5173,0x5174,0x5175,0x5176,0x5177,0x5178, +0x5179,0x517b,0x517c,0x517d,0x5180,0x5181,0x5182,0x5185,0x5188,0x5189, +0x518c,0x518d,0x5192,0x5195,0x5196,0x5197,0x5199,0x519b,0x519c,0x51a0, +0x51a2,0x51a4,0x51a5,0x51ab,0x51ac,0x51af,0x51b0,0x51b1,0x51b2,0x51b3, +0x51b5,0x51b6,0x51b7,0x51bb,0x51bc,0x51bd,0x51c0,0x51c4,0x51c6,0x51c7, +0x51c9,0x51cb,0x51cc,0x51cf,0x51d1,0x51db,0x51dd,0x51e0,0x51e1,0x51e4, +0x51eb,0x51ed,0x51ef,0x51f0,0x51f3,0x51f5,0x51f6,0x51f8,0x51f9,0x51fa, +0x51fb,0x51fc,0x51fd,0x51ff,0x5200,0x5201,0x5202,0x5203,0x5206,0x5207, +0x5208,0x520a,0x520d,0x520e,0x5211,0x5212,0x5216,0x5217,0x5218,0x5219, +0x521a,0x521b,0x521d,0x5220,0x5224,0x5228,0x5229,0x522b,0x522d,0x522e, +0x5230,0x5233,0x5236,0x5237,0x5238,0x5239,0x523a,0x523b,0x523d,0x523f, +0x5240,0x5241,0x5242,0x5243,0x524a,0x524c,0x524d,0x5250,0x5251,0x5254, +0x5256,0x525c,0x525e,0x5261,0x5265,0x5267,0x5269,0x526a,0x526f,0x5272, +0x527d,0x527f,0x5281,0x5282,0x5288,0x5290,0x5293,0x529b,0x529d,0x529e, +0x529f,0x52a0,0x52a1,0x52a2,0x52a3,0x52a8,0x52a9,0x52aa,0x52ab,0x52ac, +0x52ad,0x52b1,0x52b2,0x52b3,0x52be,0x52bf,0x52c3,0x52c7,0x52c9,0x52cb, +0x52d0,0x52d2,0x52d6,0x52d8,0x52df,0x52e4,0x52f0,0x52f9,0x52fa,0x52fe, +0x52ff,0x5300,0x5305,0x5306,0x5308,0x530d,0x530f,0x5310,0x5315,0x5316, +0x5317,0x5319,0x531a,0x531d,0x5320,0x5321,0x5323,0x5326,0x532a,0x532e, +0x5339,0x533a,0x533b,0x533e,0x533f,0x5341,0x5343,0x5345,0x5347,0x5348, +0x5349,0x534a,0x534e,0x534f,0x5351,0x5352,0x5353,0x5355,0x5356,0x5357, +0x535a,0x535c,0x535e,0x535f,0x5360,0x5361,0x5362,0x5363,0x5364,0x5366, +0x5367,0x5369,0x536b,0x536e,0x536f,0x5370,0x5371,0x5373,0x5374,0x5375, +0x5377,0x5378,0x537a,0x537f,0x5382,0x5384,0x5385,0x5386,0x5389,0x538b, +0x538c,0x538d,0x5395,0x5398,0x539a,0x539d,0x539f,0x53a2,0x53a3,0x53a5, +0x53a6,0x53a8,0x53a9,0x53ae,0x53b6,0x53bb,0x53bf,0x53c1,0x53c2,0x53c8, +0x53c9,0x53ca,0x53cb,0x53cc,0x53cd,0x53d1,0x53d4,0x53d6,0x53d7,0x53d8, +0x53d9,0x53db,0x53df,0x53e0,0x53e3,0x53e4,0x53e5,0x53e6,0x53e8,0x53e9, +0x53ea,0x53eb,0x53ec,0x53ed,0x53ee,0x53ef,0x53f0,0x53f1,0x53f2,0x53f3, +0x53f5,0x53f6,0x53f7,0x53f8,0x53f9,0x53fb,0x53fc,0x53fd,0x5401,0x5403, +0x5404,0x5406,0x5408,0x5409,0x540a,0x540c,0x540d,0x540e,0x540f,0x5410, +0x5411,0x5412,0x5413,0x5415,0x5416,0x5417,0x541b,0x541d,0x541e,0x541f, +0x5420,0x5421,0x5423,0x5426,0x5427,0x5428,0x5429,0x542b,0x542c,0x542d, +0x542e,0x542f,0x5431,0x5432,0x5434,0x5435,0x5438,0x5439,0x543b,0x543c, +0x543e,0x5440,0x5443,0x5446,0x5448,0x544a,0x544b,0x5450,0x5452,0x5453, +0x5454,0x5455,0x5456,0x5457,0x5458,0x5459,0x545b,0x545c,0x5462,0x5464, +0x5466,0x5468,0x5471,0x5472,0x5473,0x5475,0x5476,0x5477,0x5478,0x547b, +0x547c,0x547d,0x5480,0x5482,0x5484,0x5486,0x548b,0x548c,0x548e,0x548f, +0x5490,0x5492,0x5494,0x5495,0x5496,0x5499,0x549a,0x549b,0x549d,0x54a3, +0x54a4,0x54a6,0x54a7,0x54a8,0x54a9,0x54aa,0x54ab,0x54ac,0x54ad,0x54af, +0x54b1,0x54b3,0x54b4,0x54b8,0x54bb,0x54bd,0x54bf,0x54c0,0x54c1,0x54c2, +0x54c4,0x54c6,0x54c7,0x54c8,0x54c9,0x54cc,0x54cd,0x54ce,0x54cf,0x54d0, +0x54d1,0x54d2,0x54d3,0x54d4,0x54d5,0x54d7,0x54d9,0x54da,0x54dc,0x54dd, +0x54de,0x54df,0x54e5,0x54e6,0x54e7,0x54e8,0x54e9,0x54ea,0x54ed,0x54ee, +0x54f2,0x54f3,0x54fa,0x54fc,0x54fd,0x54ff,0x5501,0x5506,0x5507,0x5509, +0x550f,0x5510,0x5511,0x5514,0x551b,0x5520,0x5522,0x5523,0x5524,0x5527, +0x552a,0x552c,0x552e,0x552f,0x5530,0x5531,0x5533,0x5537,0x553c,0x553e, +0x553f,0x5541,0x5543,0x5544,0x5546,0x5549,0x554a,0x5550,0x5555,0x5556, +0x555c,0x5561,0x5564,0x5565,0x5566,0x5567,0x556a,0x556c,0x556d,0x556e, +0x5575,0x5576,0x5577,0x5578,0x557b,0x557c,0x557e,0x5580,0x5581,0x5582, +0x5583,0x5584,0x5587,0x5588,0x5589,0x558a,0x558b,0x558f,0x5591,0x5594, +0x5598,0x5599,0x559c,0x559d,0x559f,0x55a7,0x55b1,0x55b3,0x55b5,0x55b7, +0x55b9,0x55bb,0x55bd,0x55be,0x55c4,0x55c5,0x55c9,0x55cc,0x55cd,0x55d1, +0x55d2,0x55d3,0x55d4,0x55d6,0x55dc,0x55dd,0x55df,0x55e1,0x55e3,0x55e4, +0x55e5,0x55e6,0x55e8,0x55ea,0x55eb,0x55ec,0x55ef,0x55f2,0x55f3,0x55f5, +0x55f7,0x55fd,0x55fe,0x5600,0x5601,0x5608,0x5609,0x560c,0x560e,0x560f, +0x5618,0x561b,0x561e,0x561f,0x5623,0x5624,0x5627,0x562c,0x562d,0x5631, +0x5632,0x5634,0x5636,0x5639,0x563b,0x563f,0x564c,0x564d,0x564e,0x5654, +0x5657,0x5658,0x5659,0x565c,0x5662,0x5664,0x5668,0x5669,0x566a,0x566b, +0x566c,0x5671,0x5676,0x567b,0x567c,0x5685,0x5686,0x568e,0x568f,0x5693, +0x56a3,0x56af,0x56b7,0x56bc,0x56ca,0x56d4,0x56d7,0x56da,0x56db,0x56dd, +0x56de,0x56df,0x56e0,0x56e1,0x56e2,0x56e4,0x56eb,0x56ed,0x56f0,0x56f1, +0x56f4,0x56f5,0x56f9,0x56fa,0x56fd,0x56fe,0x56ff,0x5703,0x5704,0x5706, +0x5708,0x5709,0x570a,0x571c,0x571f,0x5723,0x5728,0x5729,0x572a,0x572c, +0x572d,0x572e,0x572f,0x5730,0x5733,0x5739,0x573a,0x573b,0x573e,0x5740, +0x5742,0x5747,0x574a,0x574c,0x574d,0x574e,0x574f,0x5750,0x5751,0x5757, +0x575a,0x575b,0x575c,0x575d,0x575e,0x575f,0x5760,0x5761,0x5764,0x5766, +0x5768,0x5769,0x576a,0x576b,0x576d,0x576f,0x5773,0x5776,0x5777,0x577b, +0x577c,0x5782,0x5783,0x5784,0x5785,0x5786,0x578b,0x578c,0x5792,0x5793, +0x579b,0x57a0,0x57a1,0x57a2,0x57a3,0x57a4,0x57a6,0x57a7,0x57a9,0x57ab, +0x57ad,0x57ae,0x57b2,0x57b4,0x57b8,0x57c2,0x57c3,0x57cb,0x57ce,0x57cf, +0x57d2,0x57d4,0x57d5,0x57d8,0x57d9,0x57da,0x57dd,0x57df,0x57e0,0x57e4, +0x57ed,0x57ef,0x57f4,0x57f8,0x57f9,0x57fa,0x57fd,0x5800,0x5802,0x5806, +0x5807,0x580b,0x580d,0x5811,0x5815,0x5819,0x581e,0x5820,0x5821,0x5824, +0x582a,0x5830,0x5835,0x5844,0x584c,0x584d,0x5851,0x5854,0x5858,0x585e, +0x5865,0x586b,0x586c,0x587e,0x5880,0x5881,0x5883,0x5885,0x5889,0x5892, +0x5893,0x5899,0x589a,0x589e,0x589f,0x58a8,0x58a9,0x58bc,0x58c1,0x58c5, +0x58d1,0x58d5,0x58e4,0x58eb,0x58ec,0x58ee,0x58f0,0x58f3,0x58f6,0x58f9, +0x5902,0x5904,0x5907,0x590d,0x590f,0x5914,0x5915,0x5916,0x5919,0x591a, +0x591c,0x591f,0x5924,0x5925,0x5927,0x5929,0x592a,0x592b,0x592d,0x592e, +0x592f,0x5931,0x5934,0x5937,0x5938,0x5939,0x593a,0x593c,0x5941,0x5942, +0x5944,0x5947,0x5948,0x5949,0x594b,0x594e,0x594f,0x5951,0x5954,0x5955, +0x5956,0x5957,0x5958,0x595a,0x5960,0x5962,0x5965,0x5973,0x5974,0x5976, +0x5978,0x5979,0x597d,0x5981,0x5982,0x5983,0x5984,0x5986,0x5987,0x5988, +0x598a,0x598d,0x5992,0x5993,0x5996,0x5997,0x5999,0x599e,0x59a3,0x59a4, +0x59a5,0x59a8,0x59a9,0x59aa,0x59ab,0x59ae,0x59af,0x59b2,0x59b9,0x59bb, +0x59be,0x59c6,0x59ca,0x59cb,0x59d0,0x59d1,0x59d2,0x59d3,0x59d4,0x59d7, +0x59d8,0x59da,0x59dc,0x59dd,0x59e3,0x59e5,0x59e8,0x59ec,0x59f9,0x59fb, +0x59ff,0x5a01,0x5a03,0x5a04,0x5a05,0x5a06,0x5a07,0x5a08,0x5a09,0x5a0c, +0x5a11,0x5a13,0x5a18,0x5a1c,0x5a1f,0x5a20,0x5a23,0x5a25,0x5a29,0x5a31, +0x5a32,0x5a34,0x5a36,0x5a3c,0x5a40,0x5a46,0x5a49,0x5a4a,0x5a55,0x5a5a, +0x5a62,0x5a67,0x5a6a,0x5a74,0x5a75,0x5a76,0x5a77,0x5a7a,0x5a7f,0x5a92, +0x5a9a,0x5a9b,0x5aaa,0x5ab2,0x5ab3,0x5ab5,0x5ab8,0x5abe,0x5ac1,0x5ac2, +0x5ac9,0x5acc,0x5ad2,0x5ad4,0x5ad6,0x5ad8,0x5adc,0x5ae0,0x5ae1,0x5ae3, +0x5ae6,0x5ae9,0x5aeb,0x5af1,0x5b09,0x5b16,0x5b17,0x5b32,0x5b34,0x5b37, +0x5b40,0x5b50,0x5b51,0x5b53,0x5b54,0x5b55,0x5b57,0x5b58,0x5b59,0x5b5a, +0x5b5b,0x5b5c,0x5b5d,0x5b5f,0x5b62,0x5b63,0x5b64,0x5b65,0x5b66,0x5b69, +0x5b6a,0x5b6c,0x5b70,0x5b71,0x5b73,0x5b75,0x5b7a,0x5b7d,0x5b80,0x5b81, +0x5b83,0x5b84,0x5b85,0x5b87,0x5b88,0x5b89,0x5b8b,0x5b8c,0x5b8f,0x5b93, +0x5b95,0x5b97,0x5b98,0x5b99,0x5b9a,0x5b9b,0x5b9c,0x5b9d,0x5b9e,0x5ba0, +0x5ba1,0x5ba2,0x5ba3,0x5ba4,0x5ba5,0x5ba6,0x5baa,0x5bab,0x5bb0,0x5bb3, +0x5bb4,0x5bb5,0x5bb6,0x5bb8,0x5bb9,0x5bbd,0x5bbe,0x5bbf,0x5bc2,0x5bc4, +0x5bc5,0x5bc6,0x5bc7,0x5bcc,0x5bd0,0x5bd2,0x5bd3,0x5bdd,0x5bde,0x5bdf, +0x5be1,0x5be4,0x5be5,0x5be8,0x5bee,0x5bf0,0x5bf8,0x5bf9,0x5bfa,0x5bfb, +0x5bfc,0x5bff,0x5c01,0x5c04,0x5c06,0x5c09,0x5c0a,0x5c0f,0x5c11,0x5c14, +0x5c15,0x5c16,0x5c18,0x5c1a,0x5c1c,0x5c1d,0x5c22,0x5c24,0x5c25,0x5c27, +0x5c2c,0x5c31,0x5c34,0x5c38,0x5c39,0x5c3a,0x5c3b,0x5c3c,0x5c3d,0x5c3e, +0x5c3f,0x5c40,0x5c41,0x5c42,0x5c45,0x5c48,0x5c49,0x5c4a,0x5c4b,0x5c4e, +0x5c4f,0x5c50,0x5c51,0x5c55,0x5c59,0x5c5e,0x5c60,0x5c61,0x5c63,0x5c65, +0x5c66,0x5c6e,0x5c6f,0x5c71,0x5c79,0x5c7a,0x5c7f,0x5c81,0x5c82,0x5c88, +0x5c8c,0x5c8d,0x5c90,0x5c91,0x5c94,0x5c96,0x5c97,0x5c98,0x5c99,0x5c9a, +0x5c9b,0x5c9c,0x5ca2,0x5ca3,0x5ca9,0x5cab,0x5cac,0x5cad,0x5cb1,0x5cb3, +0x5cb5,0x5cb7,0x5cb8,0x5cbd,0x5cbf,0x5cc1,0x5cc4,0x5ccb,0x5cd2,0x5cd9, +0x5ce1,0x5ce4,0x5ce5,0x5ce6,0x5ce8,0x5cea,0x5ced,0x5cf0,0x5cfb,0x5d02, +0x5d03,0x5d06,0x5d07,0x5d0e,0x5d14,0x5d16,0x5d1b,0x5d1e,0x5d24,0x5d26, +0x5d27,0x5d29,0x5d2d,0x5d2e,0x5d34,0x5d3d,0x5d3e,0x5d47,0x5d4a,0x5d4b, +0x5d4c,0x5d58,0x5d5b,0x5d5d,0x5d69,0x5d6b,0x5d6c,0x5d6f,0x5d74,0x5d82, +0x5d99,0x5d9d,0x5db7,0x5dc5,0x5dcd,0x5ddb,0x5ddd,0x5dde,0x5de1,0x5de2, +0x5de5,0x5de6,0x5de7,0x5de8,0x5de9,0x5deb,0x5dee,0x5def,0x5df1,0x5df2, +0x5df3,0x5df4,0x5df7,0x5dfd,0x5dfe,0x5e01,0x5e02,0x5e03,0x5e05,0x5e06, +0x5e08,0x5e0c,0x5e0f,0x5e10,0x5e11,0x5e14,0x5e15,0x5e16,0x5e18,0x5e19, +0x5e1a,0x5e1b,0x5e1c,0x5e1d,0x5e26,0x5e27,0x5e2d,0x5e2e,0x5e31,0x5e37, +0x5e38,0x5e3b,0x5e3c,0x5e3d,0x5e42,0x5e44,0x5e45,0x5e4c,0x5e54,0x5e55, +0x5e5b,0x5e5e,0x5e61,0x5e62,0x5e72,0x5e73,0x5e74,0x5e76,0x5e78,0x5e7a, +0x5e7b,0x5e7c,0x5e7d,0x5e7f,0x5e80,0x5e84,0x5e86,0x5e87,0x5e8a,0x5e8b, +0x5e8f,0x5e90,0x5e91,0x5e93,0x5e94,0x5e95,0x5e96,0x5e97,0x5e99,0x5e9a, +0x5e9c,0x5e9e,0x5e9f,0x5ea0,0x5ea5,0x5ea6,0x5ea7,0x5ead,0x5eb3,0x5eb5, +0x5eb6,0x5eb7,0x5eb8,0x5eb9,0x5ebe,0x5ec9,0x5eca,0x5ed1,0x5ed2,0x5ed3, +0x5ed6,0x5edb,0x5ee8,0x5eea,0x5ef4,0x5ef6,0x5ef7,0x5efa,0x5efe,0x5eff, +0x5f00,0x5f01,0x5f02,0x5f03,0x5f04,0x5f08,0x5f0a,0x5f0b,0x5f0f,0x5f11, +0x5f13,0x5f15,0x5f17,0x5f18,0x5f1b,0x5f1f,0x5f20,0x5f25,0x5f26,0x5f27, +0x5f29,0x5f2a,0x5f2d,0x5f2f,0x5f31,0x5f39,0x5f3a,0x5f3c,0x5f40,0x5f50, +0x5f52,0x5f53,0x5f55,0x5f56,0x5f57,0x5f58,0x5f5d,0x5f61,0x5f62,0x5f64, +0x5f66,0x5f69,0x5f6a,0x5f6c,0x5f6d,0x5f70,0x5f71,0x5f73,0x5f77,0x5f79, +0x5f7b,0x5f7c,0x5f80,0x5f81,0x5f82,0x5f84,0x5f85,0x5f87,0x5f88,0x5f89, +0x5f8a,0x5f8b,0x5f8c,0x5f90,0x5f92,0x5f95,0x5f97,0x5f98,0x5f99,0x5f9c, +0x5fa1,0x5fa8,0x5faa,0x5fad,0x5fae,0x5fb5,0x5fb7,0x5fbc,0x5fbd,0x5fc3, +0x5fc4,0x5fc5,0x5fc6,0x5fc9,0x5fcc,0x5fcd,0x5fcf,0x5fd0,0x5fd1,0x5fd2, +0x5fd6,0x5fd7,0x5fd8,0x5fd9,0x5fdd,0x5fe0,0x5fe1,0x5fe4,0x5fe7,0x5fea, +0x5feb,0x5fed,0x5fee,0x5ff1,0x5ff5,0x5ff8,0x5ffb,0x5ffd,0x5ffe,0x5fff, +0x6000,0x6001,0x6002,0x6003,0x6004,0x6005,0x6006,0x600a,0x600d,0x600e, +0x600f,0x6012,0x6014,0x6015,0x6016,0x6019,0x601b,0x601c,0x601d,0x6020, +0x6021,0x6025,0x6026,0x6027,0x6028,0x6029,0x602a,0x602b,0x602f,0x6035, +0x603b,0x603c,0x603f,0x6041,0x6042,0x6043,0x604b,0x604d,0x6050,0x6052, +0x6055,0x6059,0x605a,0x605d,0x6062,0x6063,0x6064,0x6067,0x6068,0x6069, +0x606a,0x606b,0x606c,0x606d,0x606f,0x6070,0x6073,0x6076,0x6078,0x6079, +0x607a,0x607b,0x607c,0x607d,0x607f,0x6083,0x6084,0x6089,0x608c,0x608d, +0x6092,0x6094,0x6096,0x609a,0x609b,0x609d,0x609f,0x60a0,0x60a3,0x60a6, +0x60a8,0x60ab,0x60ac,0x60ad,0x60af,0x60b1,0x60b2,0x60b4,0x60b8,0x60bb, +0x60bc,0x60c5,0x60c6,0x60ca,0x60cb,0x60d1,0x60d5,0x60d8,0x60da,0x60dc, +0x60dd,0x60df,0x60e0,0x60e6,0x60e7,0x60e8,0x60e9,0x60eb,0x60ec,0x60ed, +0x60ee,0x60ef,0x60f0,0x60f3,0x60f4,0x60f6,0x60f9,0x60fa,0x6100,0x6101, +0x6106,0x6108,0x6109,0x610d,0x610e,0x610f,0x6115,0x611a,0x611f,0x6120, +0x6123,0x6124,0x6126,0x6127,0x612b,0x613f,0x6148,0x614a,0x614c,0x614e, +0x6151,0x6155,0x615d,0x6162,0x6167,0x6168,0x6170,0x6175,0x6177,0x618b, +0x618e,0x6194,0x619d,0x61a7,0x61a8,0x61a9,0x61ac,0x61b7,0x61be,0x61c2, +0x61c8,0x61ca,0x61cb,0x61d1,0x61d2,0x61d4,0x61e6,0x61f5,0x61ff,0x6206, +0x6208,0x620a,0x620b,0x620c,0x620d,0x620e,0x620f,0x6210,0x6211,0x6212, +0x6215,0x6216,0x6217,0x6218,0x621a,0x621b,0x621f,0x6221,0x6222,0x6224, +0x6225,0x622a,0x622c,0x622e,0x6233,0x6234,0x6237,0x623d,0x623e,0x623f, +0x6240,0x6241,0x6243,0x6247,0x6248,0x6249,0x624b,0x624c,0x624d,0x624e, +0x6251,0x6252,0x6253,0x6254,0x6258,0x625b,0x6263,0x6266,0x6267,0x6269, +0x626a,0x626b,0x626c,0x626d,0x626e,0x626f,0x6270,0x6273,0x6276,0x6279, +0x627c,0x627e,0x627f,0x6280,0x6284,0x6289,0x628a,0x6291,0x6292,0x6293, +0x6295,0x6296,0x6297,0x6298,0x629a,0x629b,0x629f,0x62a0,0x62a1,0x62a2, +0x62a4,0x62a5,0x62a8,0x62ab,0x62ac,0x62b1,0x62b5,0x62b9,0x62bb,0x62bc, +0x62bd,0x62bf,0x62c2,0x62c4,0x62c5,0x62c6,0x62c7,0x62c8,0x62c9,0x62ca, +0x62cc,0x62cd,0x62ce,0x62d0,0x62d2,0x62d3,0x62d4,0x62d6,0x62d7,0x62d8, +0x62d9,0x62da,0x62db,0x62dc,0x62df,0x62e2,0x62e3,0x62e5,0x62e6,0x62e7, +0x62e8,0x62e9,0x62ec,0x62ed,0x62ee,0x62ef,0x62f1,0x62f3,0x62f4,0x62f6, +0x62f7,0x62fc,0x62fd,0x62fe,0x62ff,0x6301,0x6302,0x6307,0x6308,0x6309, +0x630e,0x6311,0x6316,0x631a,0x631b,0x631d,0x631e,0x631f,0x6320,0x6321, +0x6322,0x6323,0x6324,0x6325,0x6328,0x632a,0x632b,0x632f,0x6332,0x6339, +0x633a,0x633d,0x6342,0x6343,0x6345,0x6346,0x6349,0x634b,0x634c,0x634d, +0x634e,0x634f,0x6350,0x6355,0x635e,0x635f,0x6361,0x6362,0x6363,0x6367, +0x6369,0x636d,0x636e,0x6371,0x6376,0x6377,0x637a,0x637b,0x6380,0x6382, +0x6387,0x6388,0x6389,0x638a,0x638c,0x638e,0x638f,0x6390,0x6392,0x6396, +0x6398,0x63a0,0x63a2,0x63a3,0x63a5,0x63a7,0x63a8,0x63a9,0x63aa,0x63ac, +0x63ad,0x63ae,0x63b0,0x63b3,0x63b4,0x63b7,0x63b8,0x63ba,0x63bc,0x63be, +0x63c4,0x63c6,0x63c9,0x63cd,0x63ce,0x63cf,0x63d0,0x63d2,0x63d6,0x63de, +0x63e0,0x63e1,0x63e3,0x63e9,0x63ea,0x63ed,0x63f2,0x63f4,0x63f6,0x63f8, +0x63fd,0x63ff,0x6400,0x6401,0x6402,0x6405,0x640b,0x640c,0x640f,0x6410, +0x6413,0x6414,0x641b,0x641c,0x641e,0x6420,0x6421,0x6426,0x642a,0x642c, +0x642d,0x6434,0x643a,0x643d,0x643f,0x6441,0x6444,0x6445,0x6446,0x6447, +0x6448,0x644a,0x6452,0x6454,0x6458,0x645e,0x6467,0x6469,0x646d,0x6478, +0x6479,0x647a,0x6482,0x6484,0x6485,0x6487,0x6491,0x6492,0x6495,0x6496, +0x6499,0x649e,0x64a4,0x64a9,0x64ac,0x64ad,0x64ae,0x64b0,0x64b5,0x64b7, +0x64b8,0x64ba,0x64bc,0x64c0,0x64c2,0x64c5,0x64cd,0x64ce,0x64d0,0x64d2, +0x64d7,0x64d8,0x64de,0x64e2,0x64e4,0x64e6,0x6500,0x6509,0x6512,0x6518, +0x6525,0x652b,0x652e,0x652f,0x6534,0x6535,0x6536,0x6538,0x6539,0x653b, +0x653e,0x653f,0x6545,0x6548,0x6549,0x654c,0x654f,0x6551,0x6555,0x6556, +0x6559,0x655b,0x655d,0x655e,0x6562,0x6563,0x6566,0x656b,0x656c,0x6570, +0x6572,0x6574,0x6577,0x6587,0x658b,0x658c,0x6590,0x6591,0x6593,0x6597, +0x6599,0x659b,0x659c,0x659f,0x65a1,0x65a4,0x65a5,0x65a7,0x65a9,0x65ab, +0x65ad,0x65af,0x65b0,0x65b9,0x65bc,0x65bd,0x65c1,0x65c3,0x65c4,0x65c5, +0x65c6,0x65cb,0x65cc,0x65ce,0x65cf,0x65d2,0x65d6,0x65d7,0x65e0,0x65e2, +0x65e5,0x65e6,0x65e7,0x65e8,0x65e9,0x65ec,0x65ed,0x65ee,0x65ef,0x65f0, +0x65f1,0x65f6,0x65f7,0x65fa,0x6600,0x6602,0x6603,0x6606,0x660a,0x660c, +0x660e,0x660f,0x6613,0x6614,0x6615,0x6619,0x661d,0x661f,0x6620,0x6625, +0x6627,0x6628,0x662d,0x662f,0x6631,0x6634,0x6635,0x6636,0x663c,0x663e, +0x6641,0x6643,0x664b,0x664c,0x664f,0x6652,0x6653,0x6654,0x6655,0x6656, +0x6657,0x665a,0x665f,0x6661,0x6664,0x6666,0x6668,0x666e,0x666f,0x6670, +0x6674,0x6676,0x6677,0x667a,0x667e,0x6682,0x6684,0x6687,0x668c,0x6691, +0x6696,0x6697,0x669d,0x66a7,0x66a8,0x66ae,0x66b4,0x66b9,0x66be,0x66d9, +0x66db,0x66dc,0x66dd,0x66e6,0x66e9,0x66f0,0x66f2,0x66f3,0x66f4,0x66f7, +0x66f9,0x66fc,0x66fe,0x66ff,0x6700,0x6708,0x6709,0x670a,0x670b,0x670d, +0x6710,0x6714,0x6715,0x6717,0x671b,0x671d,0x671f,0x6726,0x6728,0x672a, +0x672b,0x672c,0x672d,0x672f,0x6731,0x6734,0x6735,0x673a,0x673d,0x6740, +0x6742,0x6743,0x6746,0x6748,0x6749,0x674c,0x674e,0x674f,0x6750,0x6751, +0x6753,0x6756,0x675c,0x675e,0x675f,0x6760,0x6761,0x6765,0x6768,0x6769, +0x676a,0x676d,0x676f,0x6770,0x6772,0x6773,0x6775,0x6777,0x677c,0x677e, +0x677f,0x6781,0x6784,0x6787,0x6789,0x678b,0x6790,0x6795,0x6797,0x6798, +0x679a,0x679c,0x679d,0x679e,0x67a2,0x67a3,0x67a5,0x67a7,0x67a8,0x67aa, +0x67ab,0x67ad,0x67af,0x67b0,0x67b3,0x67b5,0x67b6,0x67b7,0x67b8,0x67c1, +0x67c3,0x67c4,0x67cf,0x67d0,0x67d1,0x67d2,0x67d3,0x67d4,0x67d8,0x67d9, +0x67da,0x67dc,0x67dd,0x67de,0x67e0,0x67e2,0x67e5,0x67e9,0x67ec,0x67ef, +0x67f0,0x67f1,0x67f3,0x67f4,0x67fd,0x67ff,0x6800,0x6805,0x6807,0x6808, +0x6809,0x680a,0x680b,0x680c,0x680e,0x680f,0x6811,0x6813,0x6816,0x6817, +0x681d,0x6821,0x6829,0x682a,0x6832,0x6833,0x6837,0x6838,0x6839,0x683c, +0x683d,0x683e,0x6840,0x6841,0x6842,0x6843,0x6844,0x6845,0x6846,0x6848, +0x6849,0x684a,0x684c,0x684e,0x6850,0x6851,0x6853,0x6854,0x6855,0x6860, +0x6861,0x6862,0x6863,0x6864,0x6865,0x6866,0x6867,0x6868,0x6869,0x686b, +0x6874,0x6876,0x6877,0x6881,0x6883,0x6885,0x6886,0x688f,0x6893,0x6897, +0x68a2,0x68a6,0x68a7,0x68a8,0x68ad,0x68af,0x68b0,0x68b3,0x68b5,0x68c0, +0x68c2,0x68c9,0x68cb,0x68cd,0x68d2,0x68d5,0x68d8,0x68da,0x68e0,0x68e3, +0x68ee,0x68f0,0x68f1,0x68f5,0x68f9,0x68fa,0x68fc,0x6901,0x6905,0x690b, +0x690d,0x690e,0x6910,0x6912,0x691f,0x6920,0x6924,0x692d,0x6930,0x6934, +0x6939,0x693d,0x693f,0x6942,0x6954,0x6957,0x695a,0x695d,0x695e,0x6960, +0x6963,0x6966,0x696b,0x696e,0x6971,0x6977,0x6978,0x6979,0x697c,0x6980, +0x6982,0x6984,0x6986,0x6987,0x6988,0x6989,0x698d,0x6994,0x6995,0x6998, +0x699b,0x699c,0x69a7,0x69a8,0x69ab,0x69ad,0x69b1,0x69b4,0x69b7,0x69bb, +0x69c1,0x69ca,0x69cc,0x69ce,0x69d0,0x69d4,0x69db,0x69df,0x69e0,0x69ed, +0x69f2,0x69fd,0x69ff,0x6a0a,0x6a17,0x6a18,0x6a1f,0x6a21,0x6a28,0x6a2a, +0x6a2f,0x6a31,0x6a35,0x6a3d,0x6a3e,0x6a44,0x6a47,0x6a50,0x6a58,0x6a59, +0x6a5b,0x6a61,0x6a65,0x6a71,0x6a79,0x6a7c,0x6a80,0x6a84,0x6a8e,0x6a90, +0x6a91,0x6a97,0x6aa0,0x6aa9,0x6aab,0x6aac,0x6b20,0x6b21,0x6b22,0x6b23, +0x6b24,0x6b27,0x6b32,0x6b37,0x6b39,0x6b3a,0x6b3e,0x6b43,0x6b46,0x6b47, +0x6b49,0x6b4c,0x6b59,0x6b62,0x6b63,0x6b64,0x6b65,0x6b66,0x6b67,0x6b6a, +0x6b79,0x6b7b,0x6b7c,0x6b81,0x6b82,0x6b83,0x6b84,0x6b86,0x6b87,0x6b89, +0x6b8a,0x6b8b,0x6b8d,0x6b92,0x6b93,0x6b96,0x6b9a,0x6b9b,0x6ba1,0x6baa, +0x6bb3,0x6bb4,0x6bb5,0x6bb7,0x6bbf,0x6bc1,0x6bc2,0x6bc5,0x6bcb,0x6bcd, +0x6bcf,0x6bd2,0x6bd3,0x6bd4,0x6bd5,0x6bd6,0x6bd7,0x6bd9,0x6bdb,0x6be1, +0x6bea,0x6beb,0x6bef,0x6bf3,0x6bf5,0x6bf9,0x6bfd,0x6c05,0x6c06,0x6c07, +0x6c0d,0x6c0f,0x6c10,0x6c11,0x6c13,0x6c14,0x6c15,0x6c16,0x6c18,0x6c19, +0x6c1a,0x6c1b,0x6c1f,0x6c21,0x6c22,0x6c24,0x6c26,0x6c27,0x6c28,0x6c29, +0x6c2a,0x6c2e,0x6c2f,0x6c30,0x6c32,0x6c34,0x6c35,0x6c38,0x6c3d,0x6c40, +0x6c41,0x6c42,0x6c46,0x6c47,0x6c49,0x6c4a,0x6c50,0x6c54,0x6c55,0x6c57, +0x6c5b,0x6c5c,0x6c5d,0x6c5e,0x6c5f,0x6c60,0x6c61,0x6c64,0x6c68,0x6c69, +0x6c6a,0x6c70,0x6c72,0x6c74,0x6c76,0x6c79,0x6c7d,0x6c7e,0x6c81,0x6c82, +0x6c83,0x6c85,0x6c86,0x6c88,0x6c89,0x6c8c,0x6c8f,0x6c90,0x6c93,0x6c94, +0x6c99,0x6c9b,0x6c9f,0x6ca1,0x6ca3,0x6ca4,0x6ca5,0x6ca6,0x6ca7,0x6ca9, +0x6caa,0x6cab,0x6cad,0x6cae,0x6cb1,0x6cb2,0x6cb3,0x6cb8,0x6cb9,0x6cbb, +0x6cbc,0x6cbd,0x6cbe,0x6cbf,0x6cc4,0x6cc5,0x6cc9,0x6cca,0x6ccc,0x6cd0, +0x6cd3,0x6cd4,0x6cd5,0x6cd6,0x6cd7,0x6cdb,0x6cde,0x6ce0,0x6ce1,0x6ce2, +0x6ce3,0x6ce5,0x6ce8,0x6cea,0x6ceb,0x6cee,0x6cef,0x6cf0,0x6cf1,0x6cf3, +0x6cf5,0x6cf6,0x6cf7,0x6cf8,0x6cfa,0x6cfb,0x6cfc,0x6cfd,0x6cfe,0x6d01, +0x6d04,0x6d07,0x6d0b,0x6d0c,0x6d0e,0x6d12,0x6d17,0x6d19,0x6d1a,0x6d1b, +0x6d1e,0x6d25,0x6d27,0x6d2a,0x6d2b,0x6d2e,0x6d31,0x6d32,0x6d33,0x6d35, +0x6d39,0x6d3b,0x6d3c,0x6d3d,0x6d3e,0x6d41,0x6d43,0x6d45,0x6d46,0x6d47, +0x6d48,0x6d4a,0x6d4b,0x6d4d,0x6d4e,0x6d4f,0x6d51,0x6d52,0x6d53,0x6d54, +0x6d59,0x6d5a,0x6d5c,0x6d5e,0x6d60,0x6d63,0x6d66,0x6d69,0x6d6a,0x6d6e, +0x6d6f,0x6d74,0x6d77,0x6d78,0x6d7c,0x6d82,0x6d85,0x6d88,0x6d89,0x6d8c, +0x6d8e,0x6d91,0x6d93,0x6d94,0x6d95,0x6d9b,0x6d9d,0x6d9e,0x6d9f,0x6da0, +0x6da1,0x6da3,0x6da4,0x6da6,0x6da7,0x6da8,0x6da9,0x6daa,0x6dab,0x6dae, +0x6daf,0x6db2,0x6db5,0x6db8,0x6dbf,0x6dc0,0x6dc4,0x6dc5,0x6dc6,0x6dc7, +0x6dcb,0x6dcc,0x6dd1,0x6dd6,0x6dd8,0x6dd9,0x6ddd,0x6dde,0x6de0,0x6de1, +0x6de4,0x6de6,0x6deb,0x6dec,0x6dee,0x6df1,0x6df3,0x6df7,0x6df9,0x6dfb, +0x6dfc,0x6e05,0x6e0a,0x6e0c,0x6e0d,0x6e0e,0x6e10,0x6e11,0x6e14,0x6e16, +0x6e17,0x6e1a,0x6e1d,0x6e20,0x6e21,0x6e23,0x6e24,0x6e25,0x6e29,0x6e2b, +0x6e2d,0x6e2f,0x6e32,0x6e34,0x6e38,0x6e3a,0x6e43,0x6e44,0x6e4d,0x6e4e, +0x6e53,0x6e54,0x6e56,0x6e58,0x6e5b,0x6e5f,0x6e6b,0x6e6e,0x6e7e,0x6e7f, +0x6e83,0x6e85,0x6e86,0x6e89,0x6e8f,0x6e90,0x6e98,0x6e9c,0x6e9f,0x6ea2, +0x6ea5,0x6ea7,0x6eaa,0x6eaf,0x6eb1,0x6eb2,0x6eb4,0x6eb6,0x6eb7,0x6eba, +0x6ebb,0x6ebd,0x6ec1,0x6ec2,0x6ec7,0x6ecb,0x6ecf,0x6ed1,0x6ed3,0x6ed4, +0x6ed5,0x6ed7,0x6eda,0x6ede,0x6edf,0x6ee0,0x6ee1,0x6ee2,0x6ee4,0x6ee5, +0x6ee6,0x6ee8,0x6ee9,0x6ef4,0x6ef9,0x6f02,0x6f06,0x6f09,0x6f0f,0x6f13, +0x6f14,0x6f15,0x6f20,0x6f24,0x6f29,0x6f2a,0x6f2b,0x6f2d,0x6f2f,0x6f31, +0x6f33,0x6f36,0x6f3e,0x6f46,0x6f47,0x6f4b,0x6f4d,0x6f58,0x6f5c,0x6f5e, +0x6f62,0x6f66,0x6f6d,0x6f6e,0x6f72,0x6f74,0x6f78,0x6f7a,0x6f7c,0x6f84, +0x6f88,0x6f89,0x6f8c,0x6f8d,0x6f8e,0x6f9c,0x6fa1,0x6fa7,0x6fb3,0x6fb6, +0x6fb9,0x6fc0,0x6fc2,0x6fc9,0x6fd1,0x6fd2,0x6fde,0x6fe0,0x6fe1,0x6fee, +0x6fef,0x7011,0x701a,0x701b,0x7023,0x7035,0x7039,0x704c,0x704f,0x705e, +0x706b,0x706c,0x706d,0x706f,0x7070,0x7075,0x7076,0x7078,0x707c,0x707e, +0x707f,0x7080,0x7085,0x7089,0x708a,0x708e,0x7092,0x7094,0x7095,0x7096, +0x7099,0x709c,0x709d,0x70ab,0x70ac,0x70ad,0x70ae,0x70af,0x70b1,0x70b3, +0x70b7,0x70b8,0x70b9,0x70bb,0x70bc,0x70bd,0x70c0,0x70c1,0x70c2,0x70c3, +0x70c8,0x70ca,0x70d8,0x70d9,0x70db,0x70df,0x70e4,0x70e6,0x70e7,0x70e8, +0x70e9,0x70eb,0x70ec,0x70ed,0x70ef,0x70f7,0x70f9,0x70fd,0x7109,0x710a, +0x7110,0x7113,0x7115,0x7116,0x7118,0x7119,0x711a,0x7126,0x712f,0x7130, +0x7131,0x7136,0x7145,0x714a,0x714c,0x714e,0x715c,0x715e,0x7164,0x7166, +0x7167,0x7168,0x716e,0x7172,0x7173,0x7178,0x717a,0x717d,0x7184,0x718a, +0x718f,0x7194,0x7198,0x7199,0x719f,0x71a0,0x71a8,0x71ac,0x71b3,0x71b5, +0x71b9,0x71c3,0x71ce,0x71d4,0x71d5,0x71e0,0x71e5,0x71e7,0x71ee,0x71f9, +0x7206,0x721d,0x7228,0x722a,0x722c,0x7230,0x7231,0x7235,0x7236,0x7237, +0x7238,0x7239,0x723b,0x723d,0x723f,0x7247,0x7248,0x724c,0x724d,0x7252, +0x7256,0x7259,0x725b,0x725d,0x725f,0x7261,0x7262,0x7266,0x7267,0x7269, +0x726e,0x726f,0x7272,0x7275,0x7279,0x727a,0x727e,0x727f,0x7280,0x7281, +0x7284,0x728a,0x728b,0x728d,0x728f,0x7292,0x729f,0x72ac,0x72ad,0x72af, +0x72b0,0x72b4,0x72b6,0x72b7,0x72b8,0x72b9,0x72c1,0x72c2,0x72c3,0x72c4, +0x72c8,0x72cd,0x72ce,0x72d0,0x72d2,0x72d7,0x72d9,0x72de,0x72e0,0x72e1, +0x72e8,0x72e9,0x72ec,0x72ed,0x72ee,0x72ef,0x72f0,0x72f1,0x72f2,0x72f3, +0x72f4,0x72f7,0x72f8,0x72fa,0x72fb,0x72fc,0x7301,0x7303,0x730a,0x730e, +0x7313,0x7315,0x7316,0x7317,0x731b,0x731c,0x731d,0x731e,0x7321,0x7322, +0x7325,0x7329,0x732a,0x732b,0x732c,0x732e,0x7331,0x7334,0x7337,0x7338, +0x7339,0x733e,0x733f,0x734d,0x7350,0x7352,0x7357,0x7360,0x736c,0x736d, +0x736f,0x737e,0x7384,0x7387,0x7389,0x738b,0x738e,0x7391,0x7396,0x739b, +0x739f,0x73a2,0x73a9,0x73ab,0x73ae,0x73af,0x73b0,0x73b2,0x73b3,0x73b7, +0x73ba,0x73bb,0x73c0,0x73c2,0x73c8,0x73c9,0x73ca,0x73cd,0x73cf,0x73d0, +0x73d1,0x73d9,0x73de,0x73e0,0x73e5,0x73e7,0x73e9,0x73ed,0x73f2,0x7403, +0x7405,0x7406,0x7409,0x740a,0x740f,0x7410,0x741a,0x741b,0x7422,0x7425, +0x7426,0x7428,0x742a,0x742c,0x742e,0x7430,0x7433,0x7434,0x7435,0x7436, +0x743c,0x7441,0x7455,0x7457,0x7459,0x745a,0x745b,0x745c,0x745e,0x745f, +0x746d,0x7470,0x7476,0x7477,0x747e,0x7480,0x7481,0x7483,0x7487,0x748b, +0x748e,0x7490,0x749c,0x749e,0x74a7,0x74a8,0x74a9,0x74ba,0x74d2,0x74dc, +0x74de,0x74e0,0x74e2,0x74e3,0x74e4,0x74e6,0x74ee,0x74ef,0x74f4,0x74f6, +0x74f7,0x74ff,0x7504,0x750d,0x750f,0x7511,0x7513,0x7518,0x7519,0x751a, +0x751c,0x751f,0x7525,0x7528,0x7529,0x752b,0x752c,0x752d,0x752f,0x7530, +0x7531,0x7532,0x7533,0x7535,0x7537,0x7538,0x753a,0x753b,0x753e,0x7540, +0x7545,0x7548,0x754b,0x754c,0x754e,0x754f,0x7554,0x7559,0x755a,0x755b, +0x755c,0x7565,0x7566,0x756a,0x7572,0x7574,0x7578,0x7579,0x757f,0x7583, +0x7586,0x758b,0x758f,0x7591,0x7592,0x7594,0x7596,0x7597,0x7599,0x759a, +0x759d,0x759f,0x75a0,0x75a1,0x75a3,0x75a4,0x75a5,0x75ab,0x75ac,0x75ae, +0x75af,0x75b0,0x75b1,0x75b2,0x75b3,0x75b4,0x75b5,0x75b8,0x75b9,0x75bc, +0x75bd,0x75be,0x75c2,0x75c3,0x75c4,0x75c5,0x75c7,0x75c8,0x75c9,0x75ca, +0x75cd,0x75d2,0x75d4,0x75d5,0x75d6,0x75d8,0x75db,0x75de,0x75e2,0x75e3, +0x75e4,0x75e6,0x75e7,0x75e8,0x75ea,0x75eb,0x75f0,0x75f1,0x75f4,0x75f9, +0x75fc,0x75ff,0x7600,0x7601,0x7603,0x7605,0x760a,0x760c,0x7610,0x7615, +0x7617,0x7618,0x7619,0x761b,0x761f,0x7620,0x7622,0x7624,0x7625,0x7626, +0x7629,0x762a,0x762b,0x762d,0x7630,0x7633,0x7634,0x7635,0x7638,0x763c, +0x763e,0x763f,0x7640,0x7643,0x764c,0x764d,0x7654,0x7656,0x765c,0x765e, +0x7663,0x766b,0x766f,0x7678,0x767b,0x767d,0x767e,0x7682,0x7684,0x7686, +0x7687,0x7688,0x768b,0x768e,0x7691,0x7693,0x7696,0x7699,0x76a4,0x76ae, +0x76b1,0x76b2,0x76b4,0x76bf,0x76c2,0x76c5,0x76c6,0x76c8,0x76ca,0x76cd, +0x76ce,0x76cf,0x76d0,0x76d1,0x76d2,0x76d4,0x76d6,0x76d7,0x76d8,0x76db, +0x76df,0x76e5,0x76ee,0x76ef,0x76f1,0x76f2,0x76f4,0x76f8,0x76f9,0x76fc, +0x76fe,0x7701,0x7704,0x7707,0x7708,0x7709,0x770b,0x770d,0x7719,0x771a, +0x771f,0x7720,0x7722,0x7726,0x7728,0x7729,0x772d,0x772f,0x7735,0x7736, +0x7737,0x7738,0x773a,0x773c,0x7740,0x7741,0x7743,0x7747,0x7750,0x7751, +0x775a,0x775b,0x7761,0x7762,0x7763,0x7765,0x7766,0x7768,0x776b,0x776c, +0x7779,0x777d,0x777e,0x777f,0x7780,0x7784,0x7785,0x778c,0x778d,0x778e, +0x7791,0x7792,0x779f,0x77a0,0x77a2,0x77a5,0x77a7,0x77a9,0x77aa,0x77ac, +0x77b0,0x77b3,0x77b5,0x77bb,0x77bd,0x77bf,0x77cd,0x77d7,0x77db,0x77dc, +0x77e2,0x77e3,0x77e5,0x77e7,0x77e9,0x77eb,0x77ec,0x77ed,0x77ee,0x77f3, +0x77f6,0x77f8,0x77fd,0x77fe,0x77ff,0x7800,0x7801,0x7802,0x7809,0x780c, +0x780d,0x7811,0x7812,0x7814,0x7816,0x7817,0x7818,0x781a,0x781c,0x781d, +0x781f,0x7823,0x7825,0x7826,0x7827,0x7829,0x782c,0x782d,0x7830,0x7834, +0x7837,0x7838,0x7839,0x783a,0x783b,0x783c,0x783e,0x7840,0x7845,0x7847, +0x784c,0x784e,0x7850,0x7852,0x7855,0x7856,0x7857,0x785d,0x786a,0x786b, +0x786c,0x786d,0x786e,0x7877,0x787c,0x7887,0x7889,0x788c,0x788d,0x788e, +0x7891,0x7893,0x7897,0x7898,0x789a,0x789b,0x789c,0x789f,0x78a1,0x78a3, +0x78a5,0x78a7,0x78b0,0x78b1,0x78b2,0x78b3,0x78b4,0x78b9,0x78be,0x78c1, +0x78c5,0x78c9,0x78ca,0x78cb,0x78d0,0x78d4,0x78d5,0x78d9,0x78e8,0x78ec, +0x78f2,0x78f4,0x78f7,0x78fa,0x7901,0x7905,0x7913,0x791e,0x7924,0x7934, +0x793a,0x793b,0x793c,0x793e,0x7940,0x7941,0x7946,0x7948,0x7949,0x7953, +0x7956,0x7957,0x795a,0x795b,0x795c,0x795d,0x795e,0x795f,0x7960,0x7962, +0x7965,0x7967,0x7968,0x796d,0x796f,0x7977,0x7978,0x797a,0x7980,0x7981, +0x7984,0x7985,0x798a,0x798f,0x799a,0x79a7,0x79b3,0x79b9,0x79ba,0x79bb, +0x79bd,0x79be,0x79c0,0x79c1,0x79c3,0x79c6,0x79c9,0x79cb,0x79cd,0x79d1, +0x79d2,0x79d5,0x79d8,0x79df,0x79e3,0x79e4,0x79e6,0x79e7,0x79e9,0x79eb, +0x79ed,0x79ef,0x79f0,0x79f8,0x79fb,0x79fd,0x7a00,0x7a02,0x7a03,0x7a06, +0x7a0b,0x7a0d,0x7a0e,0x7a14,0x7a17,0x7a1a,0x7a1e,0x7a20,0x7a23,0x7a33, +0x7a37,0x7a39,0x7a3b,0x7a3c,0x7a3d,0x7a3f,0x7a46,0x7a51,0x7a57,0x7a70, +0x7a74,0x7a76,0x7a77,0x7a78,0x7a79,0x7a7a,0x7a7f,0x7a80,0x7a81,0x7a83, +0x7a84,0x7a86,0x7a88,0x7a8d,0x7a91,0x7a92,0x7a95,0x7a96,0x7a97,0x7a98, +0x7a9c,0x7a9d,0x7a9f,0x7aa0,0x7aa5,0x7aa6,0x7aa8,0x7aac,0x7aad,0x7ab3, +0x7abf,0x7acb,0x7ad6,0x7ad9,0x7ade,0x7adf,0x7ae0,0x7ae3,0x7ae5,0x7ae6, +0x7aed,0x7aef,0x7af9,0x7afa,0x7afd,0x7aff,0x7b03,0x7b04,0x7b06,0x7b08, +0x7b0a,0x7b0b,0x7b0f,0x7b11,0x7b14,0x7b15,0x7b19,0x7b1b,0x7b1e,0x7b20, +0x7b24,0x7b25,0x7b26,0x7b28,0x7b2a,0x7b2b,0x7b2c,0x7b2e,0x7b31,0x7b33, +0x7b38,0x7b3a,0x7b3c,0x7b3e,0x7b45,0x7b47,0x7b49,0x7b4b,0x7b4c,0x7b4f, +0x7b50,0x7b51,0x7b52,0x7b54,0x7b56,0x7b58,0x7b5a,0x7b5b,0x7b5d,0x7b60, +0x7b62,0x7b6e,0x7b71,0x7b72,0x7b75,0x7b77,0x7b79,0x7b7b,0x7b7e,0x7b80, +0x7b85,0x7b8d,0x7b90,0x7b94,0x7b95,0x7b97,0x7b9c,0x7b9d,0x7ba1,0x7ba2, +0x7ba6,0x7ba7,0x7ba8,0x7ba9,0x7baa,0x7bab,0x7bac,0x7bad,0x7bb1,0x7bb4, +0x7bb8,0x7bc1,0x7bc6,0x7bc7,0x7bcc,0x7bd1,0x7bd3,0x7bd9,0x7bda,0x7bdd, +0x7be1,0x7be5,0x7be6,0x7bea,0x7bee,0x7bf1,0x7bf7,0x7bfc,0x7bfe,0x7c07, +0x7c0b,0x7c0c,0x7c0f,0x7c16,0x7c1f,0x7c26,0x7c27,0x7c2a,0x7c38,0x7c3f, +0x7c40,0x7c41,0x7c4d,0x7c73,0x7c74,0x7c7b,0x7c7c,0x7c7d,0x7c89,0x7c91, +0x7c92,0x7c95,0x7c97,0x7c98,0x7c9c,0x7c9d,0x7c9e,0x7c9f,0x7ca2,0x7ca4, +0x7ca5,0x7caa,0x7cae,0x7cb1,0x7cb2,0x7cb3,0x7cb9,0x7cbc,0x7cbd,0x7cbe, +0x7cc1,0x7cc5,0x7cc7,0x7cc8,0x7cca,0x7ccc,0x7ccd,0x7cd5,0x7cd6,0x7cd7, +0x7cd9,0x7cdc,0x7cdf,0x7ce0,0x7ce8,0x7cef,0x7cf8,0x7cfb,0x7d0a,0x7d20, +0x7d22,0x7d27,0x7d2b,0x7d2f,0x7d6e,0x7d77,0x7da6,0x7dae,0x7e3b,0x7e41, +0x7e47,0x7e82,0x7e9b,0x7e9f,0x7ea0,0x7ea1,0x7ea2,0x7ea3,0x7ea4,0x7ea5, +0x7ea6,0x7ea7,0x7ea8,0x7ea9,0x7eaa,0x7eab,0x7eac,0x7ead,0x7eaf,0x7eb0, +0x7eb1,0x7eb2,0x7eb3,0x7eb5,0x7eb6,0x7eb7,0x7eb8,0x7eb9,0x7eba,0x7ebd, +0x7ebe,0x7ebf,0x7ec0,0x7ec1,0x7ec2,0x7ec3,0x7ec4,0x7ec5,0x7ec6,0x7ec7, +0x7ec8,0x7ec9,0x7eca,0x7ecb,0x7ecc,0x7ecd,0x7ece,0x7ecf,0x7ed0,0x7ed1, +0x7ed2,0x7ed3,0x7ed4,0x7ed5,0x7ed7,0x7ed8,0x7ed9,0x7eda,0x7edb,0x7edc, +0x7edd,0x7ede,0x7edf,0x7ee0,0x7ee1,0x7ee2,0x7ee3,0x7ee5,0x7ee6,0x7ee7, +0x7ee8,0x7ee9,0x7eea,0x7eeb,0x7eed,0x7eee,0x7eef,0x7ef0,0x7ef1,0x7ef2, +0x7ef3,0x7ef4,0x7ef5,0x7ef6,0x7ef7,0x7ef8,0x7efa,0x7efb,0x7efc,0x7efd, +0x7efe,0x7eff,0x7f00,0x7f01,0x7f02,0x7f03,0x7f04,0x7f05,0x7f06,0x7f07, +0x7f08,0x7f09,0x7f0b,0x7f0c,0x7f0d,0x7f0e,0x7f0f,0x7f11,0x7f12,0x7f13, +0x7f14,0x7f15,0x7f16,0x7f17,0x7f18,0x7f19,0x7f1a,0x7f1b,0x7f1c,0x7f1d, +0x7f1f,0x7f20,0x7f21,0x7f22,0x7f23,0x7f24,0x7f25,0x7f26,0x7f27,0x7f28, +0x7f29,0x7f2a,0x7f2b,0x7f2c,0x7f2d,0x7f2e,0x7f2f,0x7f30,0x7f31,0x7f32, +0x7f33,0x7f34,0x7f35,0x7f36,0x7f38,0x7f3a,0x7f42,0x7f44,0x7f45,0x7f50, +0x7f51,0x7f54,0x7f55,0x7f57,0x7f58,0x7f5a,0x7f5f,0x7f61,0x7f62,0x7f68, +0x7f69,0x7f6a,0x7f6e,0x7f71,0x7f72,0x7f74,0x7f79,0x7f7e,0x7f81,0x7f8a, +0x7f8c,0x7f8e,0x7f94,0x7f9a,0x7f9d,0x7f9e,0x7f9f,0x7fa1,0x7fa4,0x7fa7, +0x7faf,0x7fb0,0x7fb2,0x7fb8,0x7fb9,0x7fbc,0x7fbd,0x7fbf,0x7fc1,0x7fc5, +0x7fca,0x7fcc,0x7fce,0x7fd4,0x7fd5,0x7fd8,0x7fdf,0x7fe0,0x7fe1,0x7fe5, +0x7fe6,0x7fe9,0x7fee,0x7ff0,0x7ff1,0x7ff3,0x7ffb,0x7ffc,0x8000,0x8001, +0x8003,0x8004,0x8005,0x8006,0x800b,0x800c,0x800d,0x8010,0x8012,0x8014, +0x8015,0x8016,0x8017,0x8018,0x8019,0x801c,0x8020,0x8022,0x8025,0x8026, +0x8027,0x8028,0x8029,0x802a,0x8031,0x8033,0x8035,0x8036,0x8037,0x8038, +0x803b,0x803d,0x803f,0x8042,0x8043,0x8046,0x804a,0x804b,0x804c,0x804d, +0x8052,0x8054,0x8058,0x805a,0x8069,0x806a,0x8071,0x807f,0x8080,0x8083, +0x8084,0x8086,0x8087,0x8089,0x808b,0x808c,0x8093,0x8096,0x8098,0x809a, +0x809b,0x809c,0x809d,0x809f,0x80a0,0x80a1,0x80a2,0x80a4,0x80a5,0x80a9, +0x80aa,0x80ab,0x80ad,0x80ae,0x80af,0x80b1,0x80b2,0x80b4,0x80b7,0x80ba, +0x80bc,0x80bd,0x80be,0x80bf,0x80c0,0x80c1,0x80c2,0x80c3,0x80c4,0x80c6, +0x80cc,0x80cd,0x80ce,0x80d6,0x80d7,0x80d9,0x80da,0x80db,0x80dc,0x80dd, +0x80de,0x80e1,0x80e4,0x80e5,0x80e7,0x80e8,0x80e9,0x80ea,0x80eb,0x80ec, +0x80ed,0x80ef,0x80f0,0x80f1,0x80f2,0x80f3,0x80f4,0x80f6,0x80f8,0x80fa, +0x80fc,0x80fd,0x8102,0x8106,0x8109,0x810a,0x810d,0x810e,0x810f,0x8110, +0x8111,0x8112,0x8113,0x8114,0x8116,0x8118,0x811a,0x811e,0x812c,0x812f, +0x8131,0x8132,0x8136,0x8138,0x813e,0x8146,0x8148,0x814a,0x814b,0x814c, +0x8150,0x8151,0x8153,0x8154,0x8155,0x8159,0x815a,0x8160,0x8165,0x8167, +0x8169,0x816d,0x816e,0x8170,0x8171,0x8174,0x8179,0x817a,0x817b,0x817c, +0x817d,0x817e,0x817f,0x8180,0x8182,0x8188,0x818a,0x818f,0x8191,0x8198, +0x819b,0x819c,0x819d,0x81a3,0x81a6,0x81a8,0x81aa,0x81b3,0x81ba,0x81bb, +0x81c0,0x81c1,0x81c2,0x81c3,0x81c6,0x81ca,0x81cc,0x81e3,0x81e7,0x81ea, +0x81ec,0x81ed,0x81f3,0x81f4,0x81fb,0x81fc,0x81fe,0x8200,0x8201,0x8202, +0x8204,0x8205,0x8206,0x820c,0x820d,0x8210,0x8212,0x8214,0x821b,0x821c, +0x821e,0x821f,0x8221,0x8222,0x8223,0x8228,0x822a,0x822b,0x822c,0x822d, +0x822f,0x8230,0x8231,0x8233,0x8234,0x8235,0x8236,0x8237,0x8238,0x8239, +0x823b,0x823e,0x8244,0x8247,0x8249,0x824b,0x824f,0x8258,0x825a,0x825f, +0x8268,0x826e,0x826f,0x8270,0x8272,0x8273,0x8274,0x8279,0x827a,0x827d, +0x827e,0x827f,0x8282,0x8284,0x8288,0x828a,0x828b,0x828d,0x828e,0x828f, +0x8291,0x8292,0x8297,0x8298,0x8299,0x829c,0x829d,0x829f,0x82a1,0x82a4, +0x82a5,0x82a6,0x82a8,0x82a9,0x82aa,0x82ab,0x82ac,0x82ad,0x82ae,0x82af, +0x82b0,0x82b1,0x82b3,0x82b4,0x82b7,0x82b8,0x82b9,0x82bd,0x82be,0x82c1, +0x82c4,0x82c7,0x82c8,0x82ca,0x82cb,0x82cc,0x82cd,0x82ce,0x82cf,0x82d1, +0x82d2,0x82d3,0x82d4,0x82d5,0x82d7,0x82d8,0x82db,0x82dc,0x82de,0x82df, +0x82e0,0x82e1,0x82e3,0x82e4,0x82e5,0x82e6,0x82eb,0x82ef,0x82f1,0x82f4, +0x82f7,0x82f9,0x82fb,0x8301,0x8302,0x8303,0x8304,0x8305,0x8306,0x8307, +0x8308,0x8309,0x830c,0x830e,0x830f,0x8311,0x8314,0x8315,0x8317,0x831a, +0x831b,0x831c,0x8327,0x8328,0x832b,0x832c,0x832d,0x832f,0x8331,0x8333, +0x8334,0x8335,0x8336,0x8338,0x8339,0x833a,0x833c,0x8340,0x8343,0x8346, +0x8347,0x8349,0x834f,0x8350,0x8351,0x8352,0x8354,0x835a,0x835b,0x835c, +0x835e,0x835f,0x8360,0x8361,0x8363,0x8364,0x8365,0x8366,0x8367,0x8368, +0x8369,0x836a,0x836b,0x836c,0x836d,0x836e,0x836f,0x8377,0x8378,0x837b, +0x837c,0x837d,0x8385,0x8386,0x8389,0x838e,0x8392,0x8393,0x8398,0x839b, +0x839c,0x839e,0x83a0,0x83a8,0x83a9,0x83aa,0x83ab,0x83b0,0x83b1,0x83b2, +0x83b3,0x83b4,0x83b6,0x83b7,0x83b8,0x83b9,0x83ba,0x83bc,0x83bd,0x83c0, +0x83c1,0x83c5,0x83c7,0x83ca,0x83cc,0x83cf,0x83d4,0x83d6,0x83d8,0x83dc, +0x83dd,0x83df,0x83e0,0x83e1,0x83e5,0x83e9,0x83ea,0x83f0,0x83f1,0x83f2, +0x83f8,0x83f9,0x83fd,0x8401,0x8403,0x8404,0x8406,0x840b,0x840c,0x840d, +0x840e,0x840f,0x8411,0x8418,0x841c,0x841d,0x8424,0x8425,0x8426,0x8427, +0x8428,0x8431,0x8438,0x843c,0x843d,0x8446,0x8451,0x8457,0x8459,0x845a, +0x845b,0x845c,0x8461,0x8463,0x8469,0x846b,0x846c,0x846d,0x8471,0x8473, +0x8475,0x8476,0x8478,0x847a,0x8482,0x8487,0x8488,0x8489,0x848b,0x848c, +0x848e,0x8497,0x8499,0x849c,0x84a1,0x84af,0x84b2,0x84b4,0x84b8,0x84b9, +0x84ba,0x84bd,0x84bf,0x84c1,0x84c4,0x84c9,0x84ca,0x84cd,0x84d0,0x84d1, +0x84d3,0x84d6,0x84dd,0x84df,0x84e0,0x84e3,0x84e5,0x84e6,0x84ec,0x84f0, +0x84fc,0x84ff,0x850c,0x8511,0x8513,0x8517,0x851a,0x851f,0x8521,0x852b, +0x852c,0x8537,0x8538,0x8539,0x853a,0x853b,0x853c,0x853d,0x8543,0x8548, +0x8549,0x854a,0x8556,0x8559,0x855e,0x8564,0x8568,0x8572,0x8574,0x8579, +0x857a,0x857b,0x857e,0x8584,0x8585,0x8587,0x858f,0x859b,0x859c,0x85a4, +0x85a8,0x85aa,0x85ae,0x85af,0x85b0,0x85b7,0x85b9,0x85c1,0x85c9,0x85cf, +0x85d0,0x85d3,0x85d5,0x85dc,0x85e4,0x85e9,0x85fb,0x85ff,0x8605,0x8611, +0x8616,0x8627,0x8629,0x8638,0x863c,0x864d,0x864e,0x864f,0x8650,0x8651, +0x8654,0x865a,0x865e,0x8662,0x866b,0x866c,0x866e,0x8671,0x8679,0x867a, +0x867b,0x867c,0x867d,0x867e,0x867f,0x8680,0x8681,0x8682,0x868a,0x868b, +0x868c,0x868d,0x8693,0x8695,0x869c,0x869d,0x86a3,0x86a4,0x86a7,0x86a8, +0x86a9,0x86aa,0x86ac,0x86af,0x86b0,0x86b1,0x86b4,0x86b5,0x86b6,0x86ba, +0x86c0,0x86c4,0x86c6,0x86c7,0x86c9,0x86ca,0x86cb,0x86ce,0x86cf,0x86d0, +0x86d1,0x86d4,0x86d8,0x86d9,0x86db,0x86de,0x86df,0x86e4,0x86e9,0x86ed, +0x86ee,0x86f0,0x86f1,0x86f2,0x86f3,0x86f4,0x86f8,0x86f9,0x86fe,0x8700, +0x8702,0x8703,0x8707,0x8708,0x8709,0x870a,0x870d,0x8712,0x8713,0x8715, +0x8717,0x8718,0x871a,0x871c,0x871e,0x8721,0x8722,0x8723,0x8725,0x8729, +0x872e,0x8731,0x8734,0x8737,0x873b,0x873e,0x873f,0x8747,0x8748,0x8749, +0x874c,0x874e,0x8753,0x8757,0x8759,0x8760,0x8763,0x8764,0x8765,0x876e, +0x8770,0x8774,0x8776,0x877b,0x877c,0x877d,0x877e,0x8782,0x8783,0x8785, +0x8788,0x878b,0x878d,0x8793,0x8797,0x879f,0x87a8,0x87ab,0x87ac,0x87ad, +0x87af,0x87b3,0x87b5,0x87ba,0x87bd,0x87c0,0x87c6,0x87ca,0x87cb,0x87d1, +0x87d2,0x87d3,0x87db,0x87e0,0x87e5,0x87ea,0x87ee,0x87f9,0x87fe,0x8803, +0x880a,0x8813,0x8815,0x8816,0x881b,0x8821,0x8822,0x8832,0x8839,0x883c, +0x8840,0x8844,0x8845,0x884c,0x884d,0x8854,0x8857,0x8859,0x8861,0x8862, +0x8863,0x8864,0x8865,0x8868,0x8869,0x886b,0x886c,0x886e,0x8870,0x8872, +0x8877,0x887d,0x887e,0x887f,0x8881,0x8882,0x8884,0x8885,0x8888,0x888b, +0x888d,0x8892,0x8896,0x889c,0x88a2,0x88a4,0x88ab,0x88ad,0x88b1,0x88b7, +0x88bc,0x88c1,0x88c2,0x88c5,0x88c6,0x88c9,0x88ce,0x88d2,0x88d4,0x88d5, +0x88d8,0x88d9,0x88df,0x88e2,0x88e3,0x88e4,0x88e5,0x88e8,0x88f0,0x88f1, +0x88f3,0x88f4,0x88f8,0x88f9,0x88fc,0x88fe,0x8902,0x890a,0x8910,0x8912, +0x8913,0x8919,0x891a,0x891b,0x8921,0x8925,0x892a,0x892b,0x8930,0x8934, +0x8936,0x8941,0x8944,0x895e,0x895f,0x8966,0x897b,0x897f,0x8981,0x8983, +0x8986,0x89c1,0x89c2,0x89c4,0x89c5,0x89c6,0x89c7,0x89c8,0x89c9,0x89ca, +0x89cb,0x89cc,0x89ce,0x89cf,0x89d0,0x89d1,0x89d2,0x89d6,0x89da,0x89dc, +0x89de,0x89e3,0x89e5,0x89e6,0x89eb,0x89ef,0x89f3,0x8a00,0x8a07,0x8a3e, +0x8a48,0x8a79,0x8a89,0x8a8a,0x8a93,0x8b07,0x8b26,0x8b66,0x8b6c,0x8ba0, +0x8ba1,0x8ba2,0x8ba3,0x8ba4,0x8ba5,0x8ba6,0x8ba7,0x8ba8,0x8ba9,0x8baa, +0x8bab,0x8bad,0x8bae,0x8baf,0x8bb0,0x8bb2,0x8bb3,0x8bb4,0x8bb5,0x8bb6, +0x8bb7,0x8bb8,0x8bb9,0x8bba,0x8bbc,0x8bbd,0x8bbe,0x8bbf,0x8bc0,0x8bc1, +0x8bc2,0x8bc3,0x8bc4,0x8bc5,0x8bc6,0x8bc8,0x8bc9,0x8bca,0x8bcb,0x8bcc, +0x8bcd,0x8bce,0x8bcf,0x8bd1,0x8bd2,0x8bd3,0x8bd4,0x8bd5,0x8bd6,0x8bd7, +0x8bd8,0x8bd9,0x8bda,0x8bdb,0x8bdc,0x8bdd,0x8bde,0x8bdf,0x8be0,0x8be1, +0x8be2,0x8be3,0x8be4,0x8be5,0x8be6,0x8be7,0x8be8,0x8be9,0x8beb,0x8bec, +0x8bed,0x8bee,0x8bef,0x8bf0,0x8bf1,0x8bf2,0x8bf3,0x8bf4,0x8bf5,0x8bf6, +0x8bf7,0x8bf8,0x8bf9,0x8bfa,0x8bfb,0x8bfc,0x8bfd,0x8bfe,0x8bff,0x8c00, +0x8c01,0x8c02,0x8c03,0x8c04,0x8c05,0x8c06,0x8c07,0x8c08,0x8c0a,0x8c0b, +0x8c0c,0x8c0d,0x8c0e,0x8c0f,0x8c10,0x8c11,0x8c12,0x8c13,0x8c14,0x8c15, +0x8c16,0x8c17,0x8c18,0x8c19,0x8c1a,0x8c1b,0x8c1c,0x8c1d,0x8c1f,0x8c20, +0x8c21,0x8c22,0x8c23,0x8c24,0x8c25,0x8c26,0x8c27,0x8c28,0x8c29,0x8c2a, +0x8c2b,0x8c2c,0x8c2d,0x8c2e,0x8c2f,0x8c30,0x8c31,0x8c32,0x8c33,0x8c34, +0x8c35,0x8c36,0x8c37,0x8c41,0x8c46,0x8c47,0x8c49,0x8c4c,0x8c55,0x8c5a, +0x8c61,0x8c62,0x8c6a,0x8c6b,0x8c73,0x8c78,0x8c79,0x8c7a,0x8c82,0x8c85, +0x8c89,0x8c8a,0x8c8c,0x8c94,0x8c98,0x8d1d,0x8d1e,0x8d1f,0x8d21,0x8d22, +0x8d23,0x8d24,0x8d25,0x8d26,0x8d27,0x8d28,0x8d29,0x8d2a,0x8d2b,0x8d2c, +0x8d2d,0x8d2e,0x8d2f,0x8d30,0x8d31,0x8d32,0x8d33,0x8d34,0x8d35,0x8d36, +0x8d37,0x8d38,0x8d39,0x8d3a,0x8d3b,0x8d3c,0x8d3d,0x8d3e,0x8d3f,0x8d40, +0x8d41,0x8d42,0x8d43,0x8d44,0x8d45,0x8d46,0x8d47,0x8d48,0x8d49,0x8d4a, +0x8d4b,0x8d4c,0x8d4d,0x8d4e,0x8d4f,0x8d50,0x8d53,0x8d54,0x8d55,0x8d56, +0x8d58,0x8d59,0x8d5a,0x8d5b,0x8d5c,0x8d5d,0x8d5e,0x8d60,0x8d61,0x8d62, +0x8d63,0x8d64,0x8d66,0x8d67,0x8d6b,0x8d6d,0x8d70,0x8d73,0x8d74,0x8d75, +0x8d76,0x8d77,0x8d81,0x8d84,0x8d85,0x8d8a,0x8d8b,0x8d91,0x8d94,0x8d9f, +0x8da3,0x8db1,0x8db3,0x8db4,0x8db5,0x8db8,0x8dba,0x8dbc,0x8dbe,0x8dbf, +0x8dc3,0x8dc4,0x8dc6,0x8dcb,0x8dcc,0x8dce,0x8dcf,0x8dd1,0x8dd6,0x8dd7, +0x8dda,0x8ddb,0x8ddd,0x8dde,0x8ddf,0x8de3,0x8de4,0x8de8,0x8dea,0x8deb, +0x8dec,0x8def,0x8df3,0x8df5,0x8df7,0x8df8,0x8df9,0x8dfa,0x8dfb,0x8dfd, +0x8e05,0x8e09,0x8e0a,0x8e0c,0x8e0f,0x8e14,0x8e1d,0x8e1e,0x8e1f,0x8e22, +0x8e23,0x8e29,0x8e2a,0x8e2c,0x8e2e,0x8e2f,0x8e31,0x8e35,0x8e39,0x8e3a, +0x8e3d,0x8e40,0x8e41,0x8e42,0x8e44,0x8e47,0x8e48,0x8e49,0x8e4a,0x8e4b, +0x8e51,0x8e52,0x8e59,0x8e66,0x8e69,0x8e6c,0x8e6d,0x8e6f,0x8e70,0x8e72, +0x8e74,0x8e76,0x8e7c,0x8e7f,0x8e81,0x8e85,0x8e87,0x8e8f,0x8e90,0x8e94, +0x8e9c,0x8e9e,0x8eab,0x8eac,0x8eaf,0x8eb2,0x8eba,0x8ece,0x8f66,0x8f67, +0x8f68,0x8f69,0x8f6b,0x8f6c,0x8f6d,0x8f6e,0x8f6f,0x8f70,0x8f71,0x8f72, +0x8f73,0x8f74,0x8f75,0x8f76,0x8f77,0x8f78,0x8f79,0x8f7a,0x8f7b,0x8f7c, +0x8f7d,0x8f7e,0x8f7f,0x8f81,0x8f82,0x8f83,0x8f84,0x8f85,0x8f86,0x8f87, +0x8f88,0x8f89,0x8f8a,0x8f8b,0x8f8d,0x8f8e,0x8f8f,0x8f90,0x8f91,0x8f93, +0x8f94,0x8f95,0x8f96,0x8f97,0x8f98,0x8f99,0x8f9a,0x8f9b,0x8f9c,0x8f9e, +0x8f9f,0x8fa3,0x8fa8,0x8fa9,0x8fab,0x8fb0,0x8fb1,0x8fb6,0x8fb9,0x8fbd, +0x8fbe,0x8fc1,0x8fc2,0x8fc4,0x8fc5,0x8fc7,0x8fc8,0x8fce,0x8fd0,0x8fd1, +0x8fd3,0x8fd4,0x8fd5,0x8fd8,0x8fd9,0x8fdb,0x8fdc,0x8fdd,0x8fde,0x8fdf, +0x8fe2,0x8fe4,0x8fe5,0x8fe6,0x8fe8,0x8fe9,0x8fea,0x8feb,0x8fed,0x8fee, +0x8ff0,0x8ff3,0x8ff7,0x8ff8,0x8ff9,0x8ffd,0x9000,0x9001,0x9002,0x9003, +0x9004,0x9005,0x9006,0x9009,0x900a,0x900b,0x900d,0x900f,0x9010,0x9011, +0x9012,0x9014,0x9016,0x9017,0x901a,0x901b,0x901d,0x901e,0x901f,0x9020, +0x9021,0x9022,0x9026,0x902d,0x902e,0x902f,0x9035,0x9036,0x9038,0x903b, +0x903c,0x903e,0x9041,0x9042,0x9044,0x9047,0x904d,0x904f,0x9050,0x9051, +0x9052,0x9053,0x9057,0x9058,0x905b,0x9062,0x9063,0x9065,0x9068,0x906d, +0x906e,0x9074,0x9075,0x907d,0x907f,0x9080,0x9082,0x9083,0x9088,0x908b, +0x9091,0x9093,0x9095,0x9097,0x9099,0x909b,0x909d,0x90a1,0x90a2,0x90a3, +0x90a6,0x90aa,0x90ac,0x90ae,0x90af,0x90b0,0x90b1,0x90b3,0x90b4,0x90b5, +0x90b6,0x90b8,0x90b9,0x90ba,0x90bb,0x90be,0x90c1,0x90c4,0x90c5,0x90c7, +0x90ca,0x90ce,0x90cf,0x90d0,0x90d1,0x90d3,0x90d7,0x90db,0x90dc,0x90dd, +0x90e1,0x90e2,0x90e6,0x90e7,0x90e8,0x90eb,0x90ed,0x90ef,0x90f4,0x90f8, +0x90fd,0x90fe,0x9102,0x9104,0x9119,0x911e,0x9122,0x9123,0x912f,0x9131, +0x9139,0x9143,0x9146,0x9149,0x914a,0x914b,0x914c,0x914d,0x914e,0x914f, +0x9150,0x9152,0x9157,0x915a,0x915d,0x915e,0x9161,0x9162,0x9163,0x9164, +0x9165,0x9169,0x916a,0x916c,0x916e,0x916f,0x9170,0x9171,0x9172,0x9174, +0x9175,0x9176,0x9177,0x9178,0x9179,0x917d,0x917e,0x917f,0x9185,0x9187, +0x9189,0x918b,0x918c,0x918d,0x9190,0x9191,0x9192,0x919a,0x919b,0x91a2, +0x91a3,0x91aa,0x91ad,0x91ae,0x91af,0x91b4,0x91b5,0x91ba,0x91c7,0x91c9, +0x91ca,0x91cc,0x91cd,0x91ce,0x91cf,0x91d1,0x91dc,0x9274,0x928e,0x92ae, +0x92c8,0x933e,0x936a,0x938f,0x93ca,0x93d6,0x943e,0x946b,0x9485,0x9486, +0x9487,0x9488,0x9489,0x948a,0x948b,0x948c,0x948d,0x948e,0x948f,0x9490, +0x9492,0x9493,0x9494,0x9495,0x9497,0x9499,0x949a,0x949b,0x949c,0x949d, +0x949e,0x949f,0x94a0,0x94a1,0x94a2,0x94a3,0x94a4,0x94a5,0x94a6,0x94a7, +0x94a8,0x94a9,0x94aa,0x94ab,0x94ac,0x94ad,0x94ae,0x94af,0x94b0,0x94b1, +0x94b2,0x94b3,0x94b4,0x94b5,0x94b6,0x94b7,0x94b8,0x94b9,0x94ba,0x94bb, +0x94bc,0x94bd,0x94be,0x94bf,0x94c0,0x94c1,0x94c2,0x94c3,0x94c4,0x94c5, +0x94c6,0x94c8,0x94c9,0x94ca,0x94cb,0x94cc,0x94cd,0x94ce,0x94d0,0x94d1, +0x94d2,0x94d5,0x94d6,0x94d7,0x94d8,0x94d9,0x94db,0x94dc,0x94dd,0x94de, +0x94df,0x94e0,0x94e1,0x94e2,0x94e3,0x94e4,0x94e5,0x94e7,0x94e8,0x94e9, +0x94ea,0x94eb,0x94ec,0x94ed,0x94ee,0x94ef,0x94f0,0x94f1,0x94f2,0x94f3, +0x94f4,0x94f5,0x94f6,0x94f7,0x94f8,0x94f9,0x94fa,0x94fc,0x94fd,0x94fe, +0x94ff,0x9500,0x9501,0x9502,0x9503,0x9504,0x9505,0x9506,0x9507,0x9508, +0x9509,0x950a,0x950b,0x950c,0x950d,0x950e,0x950f,0x9510,0x9511,0x9512, +0x9513,0x9514,0x9515,0x9516,0x9517,0x9518,0x9519,0x951a,0x951b,0x951d, +0x951e,0x951f,0x9521,0x9522,0x9523,0x9524,0x9525,0x9526,0x9528,0x9529, +0x952a,0x952b,0x952c,0x952d,0x952e,0x952f,0x9530,0x9531,0x9532,0x9534, +0x9535,0x9536,0x9537,0x9538,0x9539,0x953a,0x953b,0x953c,0x953e,0x953f, +0x9540,0x9541,0x9542,0x9544,0x9545,0x9546,0x9547,0x9549,0x954a,0x954c, +0x954d,0x954e,0x954f,0x9550,0x9551,0x9552,0x9553,0x9554,0x9556,0x9557, +0x9558,0x9559,0x955b,0x955c,0x955d,0x955e,0x955f,0x9561,0x9562,0x9563, +0x9564,0x9565,0x9566,0x9567,0x9568,0x9569,0x956a,0x956b,0x956c,0x956d, +0x956f,0x9570,0x9571,0x9572,0x9573,0x9576,0x957f,0x95e8,0x95e9,0x95ea, +0x95eb,0x95ed,0x95ee,0x95ef,0x95f0,0x95f1,0x95f2,0x95f3,0x95f4,0x95f5, +0x95f6,0x95f7,0x95f8,0x95f9,0x95fa,0x95fb,0x95fc,0x95fd,0x95fe,0x9600, +0x9601,0x9602,0x9603,0x9604,0x9605,0x9606,0x9608,0x9609,0x960a,0x960b, +0x960c,0x960d,0x960e,0x960f,0x9610,0x9611,0x9612,0x9614,0x9615,0x9616, +0x9617,0x9619,0x961a,0x961c,0x961d,0x961f,0x9621,0x9622,0x962a,0x962e, +0x9631,0x9632,0x9633,0x9634,0x9635,0x9636,0x963b,0x963c,0x963d,0x963f, +0x9640,0x9642,0x9644,0x9645,0x9646,0x9647,0x9648,0x9649,0x964b,0x964c, +0x964d,0x9650,0x9654,0x9655,0x965b,0x965f,0x9661,0x9662,0x9664,0x9667, +0x9668,0x9669,0x966a,0x966c,0x9672,0x9674,0x9675,0x9676,0x9677,0x9685, +0x9686,0x9688,0x968b,0x968d,0x968f,0x9690,0x9694,0x9697,0x9698,0x9699, +0x969c,0x96a7,0x96b0,0x96b3,0x96b6,0x96b9,0x96bc,0x96bd,0x96be,0x96c0, +0x96c1,0x96c4,0x96c5,0x96c6,0x96c7,0x96c9,0x96cc,0x96cd,0x96ce,0x96cf, +0x96d2,0x96d5,0x96e0,0x96e8,0x96e9,0x96ea,0x96ef,0x96f3,0x96f6,0x96f7, +0x96f9,0x96fe,0x9700,0x9701,0x9704,0x9706,0x9707,0x9708,0x9709,0x970d, +0x970e,0x970f,0x9713,0x9716,0x971c,0x971e,0x972a,0x972d,0x9730,0x9732, +0x9738,0x9739,0x973e,0x9752,0x9753,0x9756,0x9759,0x975b,0x975e,0x9760, +0x9761,0x9762,0x9765,0x9769,0x9773,0x9774,0x9776,0x977c,0x9785,0x978b, +0x978d,0x9791,0x9792,0x9794,0x9798,0x97a0,0x97a3,0x97ab,0x97ad,0x97af, +0x97b2,0x97b4,0x97e6,0x97e7,0x97e9,0x97ea,0x97eb,0x97ec,0x97ed,0x97f3, +0x97f5,0x97f6,0x9875,0x9876,0x9877,0x9878,0x9879,0x987a,0x987b,0x987c, +0x987d,0x987e,0x987f,0x9880,0x9881,0x9882,0x9883,0x9884,0x9885,0x9886, +0x9887,0x9888,0x9889,0x988a,0x988c,0x988d,0x988f,0x9890,0x9891,0x9893, +0x9894,0x9896,0x9897,0x9898,0x989a,0x989b,0x989c,0x989d,0x989e,0x989f, +0x98a0,0x98a1,0x98a2,0x98a4,0x98a5,0x98a6,0x98a7,0x98ce,0x98d1,0x98d2, +0x98d3,0x98d5,0x98d8,0x98d9,0x98da,0x98de,0x98df,0x98e7,0x98e8,0x990d, +0x9910,0x992e,0x9954,0x9955,0x9963,0x9965,0x9967,0x9968,0x9969,0x996a, +0x996b,0x996c,0x996d,0x996e,0x996f,0x9970,0x9971,0x9972,0x9974,0x9975, +0x9976,0x9977,0x997a,0x997c,0x997d,0x997f,0x9980,0x9981,0x9984,0x9985, +0x9986,0x9987,0x9988,0x998a,0x998b,0x998d,0x998f,0x9990,0x9991,0x9992, +0x9993,0x9994,0x9995,0x9996,0x9997,0x9998,0x9999,0x99a5,0x99a8,0x9a6c, +0x9a6d,0x9a6e,0x9a6f,0x9a70,0x9a71,0x9a73,0x9a74,0x9a75,0x9a76,0x9a77, +0x9a78,0x9a79,0x9a7a,0x9a7b,0x9a7c,0x9a7d,0x9a7e,0x9a7f,0x9a80,0x9a81, +0x9a82,0x9a84,0x9a85,0x9a86,0x9a87,0x9a88,0x9a8a,0x9a8b,0x9a8c,0x9a8f, +0x9a90,0x9a91,0x9a92,0x9a93,0x9a96,0x9a97,0x9a98,0x9a9a,0x9a9b,0x9a9c, +0x9a9d,0x9a9e,0x9a9f,0x9aa0,0x9aa1,0x9aa2,0x9aa3,0x9aa4,0x9aa5,0x9aa7, +0x9aa8,0x9ab0,0x9ab1,0x9ab6,0x9ab7,0x9ab8,0x9aba,0x9abc,0x9ac0,0x9ac1, +0x9ac2,0x9ac5,0x9acb,0x9acc,0x9ad1,0x9ad3,0x9ad8,0x9adf,0x9ae1,0x9ae6, +0x9aeb,0x9aed,0x9aef,0x9af9,0x9afb,0x9b03,0x9b08,0x9b0f,0x9b13,0x9b1f, +0x9b23,0x9b2f,0x9b32,0x9b3b,0x9b3c,0x9b41,0x9b42,0x9b43,0x9b44,0x9b45, +0x9b47,0x9b48,0x9b49,0x9b4d,0x9b4f,0x9b51,0x9b54,0x9c7c,0x9c7f,0x9c81, +0x9c82,0x9c85,0x9c86,0x9c87,0x9c88,0x9c8b,0x9c8d,0x9c8e,0x9c90,0x9c91, +0x9c92,0x9c94,0x9c95,0x9c9a,0x9c9b,0x9c9c,0x9c9e,0x9c9f,0x9ca0,0x9ca1, +0x9ca2,0x9ca3,0x9ca4,0x9ca5,0x9ca6,0x9ca7,0x9ca8,0x9ca9,0x9cab,0x9cad, +0x9cae,0x9cb0,0x9cb1,0x9cb2,0x9cb3,0x9cb4,0x9cb5,0x9cb6,0x9cb7,0x9cb8, +0x9cba,0x9cbb,0x9cbc,0x9cbd,0x9cc3,0x9cc4,0x9cc5,0x9cc6,0x9cc7,0x9cca, +0x9ccb,0x9ccc,0x9ccd,0x9cce,0x9ccf,0x9cd0,0x9cd3,0x9cd4,0x9cd5,0x9cd6, +0x9cd7,0x9cd8,0x9cd9,0x9cdc,0x9cdd,0x9cde,0x9cdf,0x9ce2,0x9e1f,0x9e20, +0x9e21,0x9e22,0x9e23,0x9e25,0x9e26,0x9e28,0x9e29,0x9e2a,0x9e2b,0x9e2c, +0x9e2d,0x9e2f,0x9e31,0x9e32,0x9e33,0x9e35,0x9e36,0x9e37,0x9e38,0x9e39, +0x9e3a,0x9e3d,0x9e3e,0x9e3f,0x9e41,0x9e42,0x9e43,0x9e44,0x9e45,0x9e46, +0x9e47,0x9e48,0x9e49,0x9e4a,0x9e4b,0x9e4c,0x9e4e,0x9e4f,0x9e51,0x9e55, +0x9e57,0x9e58,0x9e5a,0x9e5b,0x9e5c,0x9e5e,0x9e63,0x9e64,0x9e66,0x9e67, +0x9e68,0x9e69,0x9e6a,0x9e6b,0x9e6c,0x9e6d,0x9e70,0x9e71,0x9e73,0x9e7e, +0x9e7f,0x9e82,0x9e87,0x9e88,0x9e8b,0x9e92,0x9e93,0x9e9d,0x9e9f,0x9ea6, +0x9eb4,0x9eb8,0x9ebb,0x9ebd,0x9ebe,0x9ec4,0x9ec9,0x9ecd,0x9ece,0x9ecf, +0x9ed1,0x9ed4,0x9ed8,0x9edb,0x9edc,0x9edd,0x9edf,0x9ee0,0x9ee2,0x9ee5, +0x9ee7,0x9ee9,0x9eea,0x9eef,0x9ef9,0x9efb,0x9efc,0x9efe,0x9f0b,0x9f0d, +0x9f0e,0x9f10,0x9f13,0x9f17,0x9f19,0x9f20,0x9f22,0x9f2c,0x9f2f,0x9f37, +0x9f39,0x9f3b,0x9f3d,0x9f3e,0x9f44,0x9f50,0x9f51,0x9f7f,0x9f80,0x9f83, +0x9f84,0x9f85,0x9f86,0x9f87,0x9f88,0x9f89,0x9f8a,0x9f8b,0x9f8c,0x9f99, +0x9f9a,0x9f9b,0x9f9f,0x9fa0,0xe7c7,0xe7c8,0xfe31,0xfe33,0xfe34,0xfe35, +0xfe36,0xfe37,0xfe38,0xfe39,0xfe3a,0xfe3b,0xfe3c,0xfe3d,0xfe3e,0xfe3f, +0xfe40,0xfe41,0xfe42,0xfe43,0xfe44,0xff01,0xff02,0xff03,0xff04,0xff05, +0xff06,0xff07,0xff08,0xff09,0xff0a,0xff0b,0xff0c,0xff0d,0xff0e,0xff0f, +0xff10,0xff11,0xff12,0xff13,0xff14,0xff15,0xff16,0xff17,0xff18,0xff19, +0xff1a,0xff1b,0xff1c,0xff1d,0xff1e,0xff1f,0xff20,0xff21,0xff22,0xff23, +0xff24,0xff25,0xff26,0xff27,0xff28,0xff29,0xff2a,0xff2b,0xff2c,0xff2d, +0xff2e,0xff2f,0xff30,0xff31,0xff32,0xff33,0xff34,0xff35,0xff36,0xff37, +0xff38,0xff39,0xff3a,0xff3b,0xff3c,0xff3d,0xff3e,0xff3f,0xff40,0xff41, +0xff42,0xff43,0xff44,0xff45,0xff46,0xff47,0xff48,0xff49,0xff4a,0xff4b, +0xff4c,0xff4d,0xff4e,0xff4f,0xff50,0xff51,0xff52,0xff53,0xff54,0xff55, +0xff56,0xff57,0xff58,0xff59,0xff5a,0xff5b,0xff5c,0xff5d,0xff5e,0xffe0, +0xffe1,0xffe3,0xffe5 +}; + + +/* total number of code points (and glyphs) */ +#define GLYPH_COUNT (sizeof(gb2312_in_ucs2_codetable) / sizeof(short)) + + +#endif /* __GB2312_IN_UCS2_H__ */ diff --git a/contrib/mcufont/encoder/importtools.cc b/contrib/mcufont/encoder/importtools.cc new file mode 100644 index 000000000..fdd7108ee --- /dev/null +++ b/contrib/mcufont/encoder/importtools.cc @@ -0,0 +1,143 @@ +#include "importtools.hh" +#include + +namespace mcufont { + +void eliminate_duplicates(std::vector &glyphtable) +{ + for (size_t i = 0; i + 1 < glyphtable.size(); i++) + { + for (size_t j = i + 1; j < glyphtable.size(); j++) + { + if (glyphtable.at(i).data == glyphtable.at(j).data && + glyphtable.at(i).width == glyphtable.at(j).width) + { + for (int c : glyphtable.at(j).chars) + glyphtable.at(i).chars.push_back(c); + + glyphtable.erase(glyphtable.begin() + j); + j--; + } + } + } +} + +struct bbox_t +{ + int left; + int top; + int right; + int bottom; + + bbox_t() + { + left = std::numeric_limits::max(); + top = std::numeric_limits::max(); + right = std::numeric_limits::min(); + bottom = std::numeric_limits::min(); + } + + void update(int x, int y) + { + if (x < left) left = x; + if (x > right) right = x; + if (y < top) top = y; + if (y > bottom) bottom = y; + } +}; + +void crop_glyphs(std::vector &glyphtable, + DataFile::fontinfo_t &fontinfo) +{ + // Find out the maximum bounding box + bbox_t bbox; + for (DataFile::glyphentry_t &glyph : glyphtable) + { + if (glyph.data.size() == 0) + continue; // Dummy glyph + + for (int y = 0; y < fontinfo.max_height; y++) + { + for (int x = 0; x < fontinfo.max_width; x++) + { + if (glyph.data.at(y * fontinfo.max_width + x)) + bbox.update(x, y); + } + } + } + + if (bbox.right < bbox.left) + return; // There were no glyphs + + // Crop the glyphs to that + size_t old_w = fontinfo.max_width; + size_t new_w = bbox.right - bbox.left + 1; + size_t new_h = bbox.bottom - bbox.top + 1; + for (DataFile::glyphentry_t &glyph : glyphtable) + { + if (glyph.data.size() == 0) + continue; // Dummy glyph + + DataFile::pixels_t old = glyph.data; + glyph.data.clear(); + + for (size_t y = 0; y < new_h; y++) + { + for (size_t x = 0; x < new_w; x++) + { + size_t old_x = bbox.left + x; + size_t old_y = bbox.top + y; + size_t old_pos = old_w * old_y + old_x; + glyph.data.push_back(old.at(old_pos)); + } + } + } + + fontinfo.max_width = new_w; + fontinfo.max_height = new_h; + fontinfo.baseline_x -= bbox.left; + fontinfo.baseline_y -= bbox.top; +} + +void detect_flags(const std::vector &glyphtable, + DataFile::fontinfo_t &fontinfo) +{ + if (!glyphtable.size()) + return; + + // Check if all glyphs have equal width + int width = glyphtable[0].width; + bool is_monospace = true; + for (const DataFile::glyphentry_t &g : glyphtable) + { + if (g.width != width) + { + is_monospace = false; + break; + } + } + + if (is_monospace) + fontinfo.flags |= DataFile::FLAG_MONOSPACE; + + // Check if all glyphs contain only 0 or 15 alpha + bool is_bw = true; + for (const DataFile::glyphentry_t &g : glyphtable) + { + for (uint8_t pixel : g.data) + { + if (pixel != 0 && pixel != 15) + { + is_bw = false; + break; + } + } + if (!is_bw) break; + } + + if (is_bw) + fontinfo.flags |= DataFile::FLAG_BW; +} + + +} diff --git a/contrib/mcufont/encoder/importtools.hh b/contrib/mcufont/encoder/importtools.hh new file mode 100644 index 000000000..20371f227 --- /dev/null +++ b/contrib/mcufont/encoder/importtools.hh @@ -0,0 +1,20 @@ +// Utility functions for processing imported font files. + +#pragma once +#include "datafile.hh" + +namespace mcufont { + +// Find and eliminate any duplicate glyphs by appending their char vectors. +void eliminate_duplicates(std::vector &glyphtable); + +// Calculate the maximum bounding box of the glyphs and crop them to that. +// Adjust fontinfo accordingly. +void crop_glyphs(std::vector &glyphtable, + DataFile::fontinfo_t &fontinfo); + +// Fill in the flags (BW, monospace) automatically. +void detect_flags(const std::vector &glyphtable, + DataFile::fontinfo_t &fontinfo); + +} diff --git a/contrib/mcufont/encoder/main.cc b/contrib/mcufont/encoder/main.cc new file mode 100644 index 000000000..2c317b231 --- /dev/null +++ b/contrib/mcufont/encoder/main.cc @@ -0,0 +1,487 @@ +#include "datafile.hh" +#include "importtools.hh" +#include "bdf_import.hh" +#include "freetype_import.hh" +#include "export_rlefont.hh" +#include "encode_rlefont.hh" +#include "optimize_rlefont.hh" +#include "export_bwfont.hh" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ccfixes.hh" +#include "gb2312_in_ucs2.h" + +using namespace mcufont; + +static std::string strip_extension(std::string filename) +{ + size_t pos = filename.find_last_of('.'); + + if (pos == std::string::npos) + { + return filename; + } + else + { + return filename.substr(0, pos); + } +} + +static std::unique_ptr load_dat(std::string src) +{ + std::ifstream infile(src); + + if (!infile.good()) + { + std::cerr << "Could not open " << src << std::endl; + return nullptr; + } + + std::unique_ptr f = DataFile::Load(infile); + if (!f) + { + std::cerr << "Invalid format for .dat file: " << src << std::endl; + return nullptr; + } + + return f; +} + +static bool save_dat(std::string dest, DataFile *f) +{ + std::ofstream outfile(dest); + + if (!outfile.good()) + { + std::cerr << "Could not open " << dest << std::endl; + return false; + } + + f->Save(outfile); + + if (!outfile.good()) + { + std::cerr << "Could not write to " << dest << std::endl; + return false; + } + + return true; +} + +enum status_t +{ + STATUS_OK = 0, // All good + STATUS_INVALID = 1, // Invalid command or args + STATUS_ERROR = 2 // Error when executing command +}; + +static status_t cmd_import_ttf(const std::vector &args) +{ + if (args.size() != 3 && args.size() != 4) + return STATUS_INVALID; + + std::string src = args.at(1); + int size = std::stoi(args.at(2)); + bool bw = (args.size() == 4 && args.at(3) == "bw"); + std::string dest = strip_extension(src) + std::to_string(size) + (bw ? "bw" : "") + ".dat"; + std::ifstream infile(src); + + if (!infile.good()) + { + std::cerr << "Could not open " << src << std::endl; + return STATUS_ERROR; + } + + std::cout << "Importing " << src << " to " << dest << std::endl; + + std::unique_ptr f = LoadFreetype(infile, size, bw); + + mcufont::rlefont::init_dictionary(*f); + + if (!save_dat(dest, f.get())) + return STATUS_ERROR; + + std::cout << "Done: " << f->GetGlyphCount() << " unique glyphs." << std::endl; + return STATUS_OK; +} + +static status_t cmd_import_bdf(const std::vector &args) +{ + if (args.size() != 2) + return STATUS_INVALID; + + std::string src = args.at(1); + std::string dest = strip_extension(args.at(1)) + ".dat"; + std::ifstream infile(src); + + if (!infile.good()) + { + std::cerr << "Could not open " << src << std::endl; + return STATUS_ERROR; + } + + std::cout << "Importing " << src << " to " << dest << std::endl; + + std::unique_ptr f = LoadBDF(infile); + + mcufont::rlefont::init_dictionary(*f); + + if (!save_dat(dest, f.get())) + return STATUS_ERROR; + + std::cout << "Done: " << f->GetGlyphCount() << " unique glyphs." << std::endl; + return STATUS_OK; +} + +static status_t cmd_filter(const std::vector &args) +{ + if (args.size() < 3) + return STATUS_INVALID; + + std::set allowed; + + // Parse arguments + for (size_t i = 2; i < args.size(); i++) + { + std::string s = args.at(i); + size_t pos = s.find('-'); + if (pos == std::string::npos) + { + if(s == "gb2312") { + allowed.insert( + &gb2312_in_ucs2_codetable[0], + &gb2312_in_ucs2_codetable[sizeof(gb2312_in_ucs2_codetable)/sizeof(gb2312_in_ucs2_codetable[0])]); + } else { + // Single char + allowed.insert(std::stoi(s, nullptr, 0)); + } + } + else + { + // Range + int start = std::stoi(s.substr(0, pos), nullptr, 0); + int end = std::stoi(s.substr(pos + 1), nullptr, 0); + + for (int j = start; j <= end; j++) + { + allowed.insert(j); + } + } + } + + std::string src = args.at(1); + std::unique_ptr f = load_dat(src); + if (!f) + return STATUS_ERROR; + + std::cout << "Font originally had " << f->GetGlyphCount() << " glyphs." << std::endl; + + // Filter the glyphs + std::vector newglyphs; + for (size_t i = 0; i < f->GetGlyphCount(); i++) + { + DataFile::glyphentry_t g = f->GetGlyphEntry(i); + + for (size_t j = 0; j < g.chars.size(); j++) + { + if (!allowed.count(g.chars.at(j))) + { + g.chars.erase(g.chars.begin() + j); + j--; + } + } + + if (g.chars.size()) + { + newglyphs.push_back(g); + } + } + + DataFile::fontinfo_t fontinfo = f->GetFontInfo(); + crop_glyphs(newglyphs, fontinfo); + detect_flags(newglyphs, fontinfo); + + f.reset(new DataFile(f->GetDictionary(), newglyphs, fontinfo)); + std::cout << "After filtering, " << f->GetGlyphCount() << " glyphs remain." << std::endl; + + if (!save_dat(src, f.get())) + return STATUS_ERROR; + + return STATUS_OK; +} + +static status_t cmd_show_glyph(const std::vector &args) +{ + if (args.size() != 3) + return STATUS_INVALID; + + std::string src = args.at(1); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + size_t index = 0; + if (args.at(2) == "largest") + { + std::unique_ptr e = + mcufont::rlefont::encode_font(*f, false); + size_t maxlen = 0; + size_t i = 0; + for (mcufont::rlefont::encoded_font_t::refstring_t g : e->glyphs) + { + if (g.size() > maxlen) + { + maxlen = g.size(); + index = i; + } + i++; + } + + std::cout << "Index " << index << ", length " << maxlen << std::endl; + } + else + { + index = strtol(args.at(2).c_str(), nullptr, 0); + } + + if (index >= f->GetGlyphCount()) + { + std::cerr << "No such glyph " << index << std::endl; + return STATUS_ERROR; + } + + std::cout << "Width: " << f->GetGlyphEntry(index).width << std::endl; + std::cout << "Chars: "; + for (int c: f->GetGlyphEntry(index).chars) std::cout << c << " "; + std::cout << std::endl; + + std::cout << f->GlyphToText(index); + return STATUS_OK; +} + +static status_t cmd_rlefont_export(const std::vector &args) +{ + if (args.size() != 2 && args.size() != 3) + return STATUS_INVALID; + + std::string src = args.at(1); + std::string dst = (args.size() == 2) ? strip_extension(src) + ".mcufont" : args.at(2); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + { + std::ofstream source(dst); + mcufont::rlefont::write_source(source, dst, *f); + std::cout << "Wrote " << dst << std::endl; + } + + return STATUS_OK; +} + +static status_t cmd_rlefont_size(const std::vector &args) +{ + if (args.size() != 2) + return STATUS_INVALID; + + std::string src = args.at(1); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + size_t size = mcufont::rlefont::get_encoded_size(*f); + + std::cout << "Glyph count: " << f->GetGlyphCount() << std::endl; + std::cout << "Glyph bbox: " << f->GetFontInfo().max_width << "x" + << f->GetFontInfo().max_height << " pixels" << std::endl; + std::cout << "Uncompressed size: " << f->GetGlyphCount() * + f->GetFontInfo().max_width * f->GetFontInfo().max_height / 2 + << " bytes" << std::endl; + std::cout << "Compressed size: " << size << " bytes" << std::endl; + std::cout << "Bytes per glyph: " << size / f->GetGlyphCount() << std::endl; + return STATUS_OK; +} + +static status_t cmd_rlefont_optimize(const std::vector &args) +{ + if (args.size() != 2 && args.size() != 3) + return STATUS_INVALID; + + std::string src = args.at(1); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + size_t oldsize = mcufont::rlefont::get_encoded_size(*f); + + std::cout << "Original size is " << oldsize << " bytes" << std::endl; + std::cout << "Press ctrl-C at any time to stop." << std::endl; + std::cout << "Results are saved automatically after each iteration." << std::endl; + + int limit = 100; + if (args.size() == 3) + { + limit = std::stoi(args.at(2)); + } + + if (limit > 0) + std::cout << "Limit is " << limit << " iterations" << std::endl; + + int i = 0; + time_t oldtime = time(NULL); + while (!limit || i < limit) + { + mcufont::rlefont::optimize(*f); + + size_t newsize = mcufont::rlefont::get_encoded_size(*f); + time_t newtime = time(NULL); + + int bytes_per_min = (oldsize - newsize) * 60 / (newtime - oldtime + 1); + + i++; + std::cout << "iteration " << i << ", size " << newsize + << " bytes, speed " << bytes_per_min << " B/min" + << std::endl; + + { + if (!save_dat(src, f.get())) + return STATUS_ERROR; + } + } + + return STATUS_OK; +} + +static status_t cmd_rlefont_show_encoded(const std::vector &args) +{ + if (args.size() != 2) + return STATUS_INVALID; + + std::string src = args.at(1); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + std::unique_ptr e = + mcufont::rlefont::encode_font(*f, false); + + int i = 0; + for (mcufont::rlefont::encoded_font_t::rlestring_t d : e->rle_dictionary) + { + std::cout << "Dict RLE " << 24 + i++ << ": "; + for (uint8_t v : d) + std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " "; + std::cout << std::endl; + } + + for (mcufont::rlefont::encoded_font_t::refstring_t d : e->ref_dictionary) + { + std::cout << "Dict Ref " << 24 + i++ << ": "; + for (uint8_t v : d) + std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " "; + std::cout << std::endl; + } + + i = 0; + for (mcufont::rlefont::encoded_font_t::refstring_t g : e->glyphs) + { + std::cout << "Glyph " << i++ << ": "; + for (uint8_t v : g) + std::cout << std::setfill('0') << std::setw(2) << std::hex << (int)v << " "; + std::cout << std::endl; + } + + return STATUS_OK; +} + +static status_t cmd_bwfont_export(const std::vector &args) +{ + if (args.size() != 2 && args.size() != 3) + return STATUS_INVALID; + + std::string src = args.at(1); + std::string dst = (args.size() == 2) ? strip_extension(src) + ".c" : args.at(2); + std::unique_ptr f = load_dat(src); + + if (!f) + return STATUS_ERROR; + + if (!(f->GetFontInfo().flags & DataFile::FLAG_BW)) + { + std::cout << "Warning: font is not black and white" << std::endl; + } + + { + std::ofstream source(dst); + mcufont::bwfont::write_source(source, dst, *f); + std::cout << "Wrote " << dst << std::endl; + } + + return STATUS_OK; +} + + +static const char *usage_msg = + "Usage: mcufont [options] ...\n" + "Commands for importing:\n" + " import_ttf [bw] Import a .ttf font into a data file.\n" + " import_bdf Import a .bdf font into a data file.\n" + "\n" + "Commands for inspecting and editing data files:\n" + " filter ... Remove everything except specified characters.\n" + " show_glyph Show the glyph at index.\n" + "\n" + "Commands specific to rlefont format:\n" + " rlefont_size Check the encoded size of the data file.\n" + " rlefont_optimize Perform an optimization pass on the data file.\n" + " rlefont_export [outfile] Export to .c source code.\n" + " rlefont_show_encoded Show the encoded data for debugging.\n" + "\n" + "Commands specific to bwfont format:\n" + " bwfont_export [outfile] Export to .c source code.\n" + ""; + +typedef status_t (*cmd_t)(const std::vector &args); +static const std::map command_list { + {"import_ttf", cmd_import_ttf}, + {"import_bdf", cmd_import_bdf}, + {"filter", cmd_filter}, + {"show_glyph", cmd_show_glyph}, + {"rlefont_size", cmd_rlefont_size}, + {"rlefont_optimize", cmd_rlefont_optimize}, + {"rlefont_export", cmd_rlefont_export}, + {"rlefont_show_encoded", cmd_rlefont_show_encoded}, + {"bwfont_export", cmd_bwfont_export}, +}; + +int main(int argc, char **argv) +{ + std::vector args; + for (int i = 1; i < argc; i++) + args.push_back(argv[i]); + + status_t status = STATUS_INVALID; + if (args.size() >= 1 && command_list.count(args.at(0))) + { + status = command_list.find(args.at(0))->second(args); + } + + if (status == STATUS_INVALID) + { + std::cout << usage_msg << std::endl; + } + + return status; +} diff --git a/contrib/mcufont/encoder/optimize_rlefont.cc b/contrib/mcufont/encoder/optimize_rlefont.cc new file mode 100644 index 000000000..20c340db1 --- /dev/null +++ b/contrib/mcufont/encoder/optimize_rlefont.cc @@ -0,0 +1,417 @@ +#include "optimize_rlefont.hh" +#include "encode_rlefont.hh" +#include +#include +#include +#include +#include +#include "ccfixes.hh" + +namespace mcufont { +namespace rlefont { + +typedef std::mt19937 rnd_t; + +// Select a random substring among all the glyphs in the datafile. +std::unique_ptr random_substring(const DataFile &datafile, rnd_t &rnd) +{ + std::uniform_int_distribution dist1(0, datafile.GetGlyphCount() - 1); + size_t index = dist1(rnd); + + const DataFile::pixels_t &pixels = datafile.GetGlyphEntry(index).data; + + std::uniform_int_distribution dist2(2, pixels.size()); + size_t length = dist2(rnd); + + std::uniform_int_distribution dist3(0, pixels.size() - length); + size_t start = dist3(rnd); + + std::unique_ptr result; + result.reset(new DataFile::pixels_t(pixels.begin() + start, + pixels.begin() + start + length)); + return result; +} + +// Try to replace the worst dictionary entry with a better one. +void optimize_worst(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + std::uniform_int_distribution dist(0, 1); + + DataFile trial = datafile; + size_t worst = trial.GetLowScoreIndex(); + DataFile::dictentry_t d = trial.GetDictionaryEntry(worst); + d.replacement = *random_substring(datafile, rnd); + d.ref_encode = dist(rnd); + trial.SetDictionaryEntry(worst, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(worst, d); + size = newsize; + + if (verbose) + std::cout << "optimize_worst: replaced " << worst + << " score " << d.score << std::endl; + } +} + +// Try to replace random dictionary entry with another one. +void optimize_any(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + DataFile trial = datafile; + std::uniform_int_distribution dist(0, DataFile::dictionarysize - 1); + size_t index = dist(rnd); + DataFile::dictentry_t d = trial.GetDictionaryEntry(index); + d.replacement = *random_substring(datafile, rnd); + trial.SetDictionaryEntry(index, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(index, d); + size = newsize; + + if (verbose) + std::cout << "optimize_any: replaced " << index + << " score " << d.score << std::endl; + } +} + +// Try to append or prepend random dictionary entry. +void optimize_expand(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose, bool binary_only) +{ + DataFile trial = datafile; + std::uniform_int_distribution dist1(0, DataFile::dictionarysize - 1); + size_t index = dist1(rnd); + DataFile::dictentry_t d = trial.GetDictionaryEntry(index); + + std::uniform_int_distribution dist3(1, 3); + size_t count = dist3(rnd); + + for (size_t i = 0; i < count; i++) + { + std::uniform_int_distribution booldist(0, 1); + std::uniform_int_distribution pixeldist(0, 15); + uint8_t pixel; + + if (binary_only) + { + pixel = booldist(rnd) ? 15 : 0; + } + else + { + pixel = pixeldist(rnd); + } + + bool prepend = booldist(rnd); + + if (prepend) + { + d.replacement.insert(d.replacement.begin(), pixel); + } + else + { + d.replacement.push_back(pixel); + } + } + + trial.SetDictionaryEntry(index, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(index, d); + size = newsize; + + if (verbose) + std::cout << "optimize_expand: expanded " << index + << " by " << count << " pixels, score " << d.score << std::endl; + } +} + +// Try to trim random dictionary entry. +void optimize_trim(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + DataFile trial = datafile; + std::uniform_int_distribution dist1(0, DataFile::dictionarysize - 1); + size_t index = dist1(rnd); + DataFile::dictentry_t d = trial.GetDictionaryEntry(index); + + if (d.replacement.size() <= 2) return; + + std::uniform_int_distribution dist2(0, std::min((int)d.replacement.size() / 2, 5)); + size_t start = dist2(rnd); + size_t end = dist2(rnd); + + if (start) + { + d.replacement.erase(d.replacement.begin(), d.replacement.begin() + start); + } + + if (end) + { + d.replacement.erase(d.replacement.end() - end, d.replacement.end() - 1); + } + + trial.SetDictionaryEntry(index, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(index, d); + size = newsize; + + if (verbose) + std::cout << "optimize_trim: trimmed " << index + << " by " << start << " pixels from start and " + << end << " pixels from end, score " << d.score << std::endl; + } +} + +// Switch random dictionary entry to use ref encoding or back to rle. +void optimize_refdict(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + DataFile trial = datafile; + std::uniform_int_distribution dist1(0, DataFile::dictionarysize - 1); + size_t index = dist1(rnd); + DataFile::dictentry_t d = trial.GetDictionaryEntry(index); + + d.ref_encode = !d.ref_encode; + + trial.SetDictionaryEntry(index, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(index, d); + size = newsize; + + if (verbose) + std::cout << "optimize_refdict: switched " << index + << " to " << (d.ref_encode ? "ref" : "RLE") + << ", score " << d.score << std::endl; + } +} + +// Combine two random dictionary entries. +void optimize_combine(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + DataFile trial = datafile; + std::uniform_int_distribution dist1(0, DataFile::dictionarysize - 1); + size_t worst = datafile.GetLowScoreIndex(); + size_t index1 = dist1(rnd); + size_t index2 = dist1(rnd); + + const DataFile::pixels_t &part1 = datafile.GetDictionaryEntry(index1).replacement; + const DataFile::pixels_t &part2 = datafile.GetDictionaryEntry(index2).replacement; + + DataFile::dictentry_t d; + d.replacement = part1; + d.replacement.insert(d.replacement.end(), part2.begin(), part2.end()); + d.ref_encode = true; + trial.SetDictionaryEntry(worst, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(worst, d); + size = newsize; + + if (verbose) + std::cout << "optimize_combine: combined " << index1 + << " and " << index2 << " to replace " << worst + << ", score " << d.score << std::endl; + } +} + +// Pick a random part of an encoded glyph and encode it as a ref dict. +void optimize_encpart(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + std::unique_ptr e = encode_font(datafile); + + // Pick a random encoded glyph + std::uniform_int_distribution dist1(0, datafile.GetGlyphCount() - 1); + size_t index = dist1(rnd); + const encoded_font_t::refstring_t &refstr = e->glyphs.at(index); + + if (refstr.size() < 2) + return; + + // Pick a random part of it + std::uniform_int_distribution dist2(2, refstr.size()); + size_t length = dist2(rnd); + std::uniform_int_distribution dist3(0, refstr.size() - length); + size_t start = dist3(rnd); + + // Decode that part + encoded_font_t::refstring_t substr(refstr.begin() + start, + refstr.begin() + start + length); + std::unique_ptr decoded = + decode_glyph(*e, substr, datafile.GetFontInfo()); + + // Add that as a new dictionary entry + DataFile trial = datafile; + size_t worst = trial.GetLowScoreIndex(); + DataFile::dictentry_t d = trial.GetDictionaryEntry(worst); + d.replacement = *decoded; + d.ref_encode = true; + trial.SetDictionaryEntry(worst, d); + + size_t newsize = get_encoded_size(trial); + + if (newsize < size) + { + d.score = size - newsize; + datafile.SetDictionaryEntry(worst, d); + size = newsize; + + if (verbose) + std::cout << "optimize_encpart: replaced " << worst + << " score " << d.score << std::endl; + } +} + +// Execute all the optimization algorithms once. +void optimize_pass(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose) +{ + optimize_worst(datafile, size, rnd, verbose); + optimize_any(datafile, size, rnd, verbose); + optimize_expand(datafile, size, rnd, verbose, false); + optimize_expand(datafile, size, rnd, verbose, true); + optimize_trim(datafile, size, rnd, verbose); + optimize_refdict(datafile, size, rnd, verbose); + optimize_combine(datafile, size, rnd, verbose); + optimize_encpart(datafile, size, rnd, verbose); +} + +// Execute multiple passes in parallel and take the one with the best result. +// The amount of parallelism is hardcoded in order to retain deterministic +// behaviour. +void optimize_parallel(DataFile &datafile, size_t &size, rnd_t &rnd, bool verbose, int num_threads = 4) +{ + std::vector datafiles; + std::vector sizes; + std::vector rnds; + std::vector > threads; + + for (int i = 0; i < num_threads; i++) + { + datafiles.emplace_back(datafile); + sizes.emplace_back(size); + rnds.emplace_back(rnd()); + } + + for (int i = 0; i < num_threads; i++) + { + threads.emplace_back(new std::thread(optimize_pass, + std::ref(datafiles.at(i)), + std::ref(sizes.at(i)), + std::ref(rnds.at(i)), + verbose)); + } + + for (int i = 0; i < num_threads; i++) + { + threads.at(i)->join(); + } + + int best = std::min_element(sizes.begin(), sizes.end()) - sizes.begin(); + size = sizes.at(best); + datafile = datafiles.at(best); +} + +// Go through all the dictionary entries and check what it costs to remove +// them. Removes any entries with negative or zero score. +void update_scores(DataFile &datafile, bool verbose) +{ + size_t oldsize = get_encoded_size(datafile); + + for (size_t i = 0; i < DataFile::dictionarysize; i++) + { + DataFile trial = datafile; + DataFile::dictentry_t dummy = {}; + trial.SetDictionaryEntry(i, dummy); + size_t newsize = get_encoded_size(trial); + + DataFile::dictentry_t d = datafile.GetDictionaryEntry(i); + d.score = newsize - oldsize; + + if (d.score > 0) + { + datafile.SetDictionaryEntry(i, d); + } + else + { + datafile.SetDictionaryEntry(i, dummy); + + if (verbose && d.replacement.size() != 0) + std::cout << "update_scores: dropped " << i + << " score " << -d.score << std::endl; + } + } +} + +void init_dictionary(DataFile &datafile) +{ + rnd_t rnd(datafile.GetSeed()); + + if (datafile.GetGlyphCount() == 0) + return; + + std::set seen_substrings; + std::set added_substrings; + + size_t i = 0; + while (i < DataFile::dictionarysize) + { + DataFile::pixels_t substring = *random_substring(datafile, rnd); + + if (!seen_substrings.count(substring)) + { + seen_substrings.insert(substring); + } + else if (!added_substrings.count(substring)) + { + // When we see a substring second time, add it. + DataFile::dictentry_t d; + d.score = 0; + d.replacement = substring; + datafile.SetDictionaryEntry(i, d); + i++; + added_substrings.insert(substring); + } + } +} + +void optimize(DataFile &datafile, size_t iterations) +{ + bool verbose = false; + rnd_t rnd(datafile.GetSeed()); + + update_scores(datafile, verbose); + + size_t size = get_encoded_size(datafile); + + for (size_t i = 0; i < iterations; i++) + { + optimize_parallel(datafile, size, rnd, verbose); + } + + std::uniform_int_distribution dist(0, std::numeric_limits::max()); + datafile.SetSeed(dist(rnd)); +} + +}} diff --git a/contrib/mcufont/encoder/optimize_rlefont.hh b/contrib/mcufont/encoder/optimize_rlefont.hh new file mode 100644 index 000000000..e4f7c78f7 --- /dev/null +++ b/contrib/mcufont/encoder/optimize_rlefont.hh @@ -0,0 +1,15 @@ +// This implements the actual optimization passes of the compressor. + +#include "datafile.hh" + +namespace mcufont { +namespace rlefont { + +// Initialize the dictionary table with reasonable guesses. +void init_dictionary(DataFile &datafile); + +// Perform a single optimization step, consisting itself of multiple passes +// of each of the optimization algorithms. +void optimize(DataFile &datafile, size_t iterations = 50); + +}} diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold.ttf b/contrib/mcufont/fonts/FiraSansCondensed-Bold.ttf new file mode 100644 index 000000000..1986a25b5 Binary files /dev/null and b/contrib/mcufont/fonts/FiraSansCondensed-Bold.ttf differ diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold10.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold10.mcufont.h new file mode 100644 index 000000000..26d138776 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold10.mcufont.h @@ -0,0 +1,346 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 10 + * blob size: 5175, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x03, 0x85, 0x00, 0x00, 0x00, 0x89, +/* 0020 */ 0x00, 0x00, 0x00, 0xD3, 0x00, 0x00, 0x13, 0xF7, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0A, 0x00, 0x0F, 0x00, 0x02, 0x00, 0x09, 0x00, 0x01, 0x00, 0x0B, 0x00, 0x0C, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x30, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x31, 0x30, 0x00, +/* dictionary data */ +0x07, 0x04, 0x0C, 0xC2, 0x07, 0xCD, 0xCC, 0x80, 0xC1, 0x07, 0xC7, +/* 0080 */ 0x80, 0xC1, 0x07, 0xC7, 0xC9, 0xCE, 0x03, 0x08, 0xC3, 0x06, 0x05, 0xC7, 0xC9, 0x05, 0xCE, 0xC9, +/* 0090 */ 0x05, 0x06, 0xC1, 0x06, 0x20, 0xC1, 0x80, 0xC3, 0x07, 0x1F, 0xC7, 0xCA, 0x05, 0xCA, 0xCE, 0x01, +/* 00A0 */ 0x33, 0x0B, 0x1F, 0x06, 0xC7, 0xCE, 0xCC, 0x04, 0xC7, 0x01, 0xC5, 0xC8, 0xCD, 0x80, 0xC1, 0x09, +/* 00B0 */ 0xC2, 0x05, 0x80, 0xD2, 0x06, 0xC2, 0x07, 0xC2, 0xCA, 0x80, 0x80, 0xCE, 0x80, 0xC1, 0x06, 0xCC, +/* 00C0 */ 0xC9, 0x80, 0xC4, 0x05, 0x07, 0xC4, 0x80, 0xCB, 0xC8, 0x80, 0xC2, 0x06, 0xCD, 0x80, 0xCE, 0xCA, +/* 00D0 */ 0x3C, 0x08, 0xC2, 0xC9, 0x81, 0xC3, 0x05, 0x17, 0x80, 0xC6, 0xC7, 0x80, 0xC1, 0xC9, 0x06, 0x34, +/* 00E0 */ 0x80, 0xC2, 0xCD, 0xC6, 0x80, 0xC8, 0x07, 0xC7, 0x80, 0xC2, 0x07, 0xC7, 0x80, 0xC2, 0xC1, 0x07, +/* 00F0 */ 0xC6, 0xCB, 0xCE, 0xC1, 0x80, 0xC9, 0xCD, 0xC2, 0x05, 0xC8, 0x80, 0xC5, 0xCC, 0x07, 0xC7, 0xCB, +/* 0100 */ 0xC7, 0xD3, 0xCB, 0x08, 0x80, 0xCC, 0x80, 0xC5, 0xC8, 0x07, 0xCE, 0x01, 0xCE, 0xC8, 0xCE, 0xC5, +/* 0110 */ 0xC4, 0x80, 0x02, 0xC3, 0x80, 0xC7, 0xDC, 0x08, 0xC7, 0x21, 0xCC, 0xCA, 0xC8, 0xCC, 0x05, 0xC2, +/* 0120 */ 0xC1, 0x05, 0x05, 0xC6, 0xC3, 0xCD, 0xC6, 0x80, 0x80, 0xCA, 0x01, 0xC1, 0x01, 0xC2, 0xC5, 0xCD, +/* 0130 */ 0xDB, 0x82, 0xC3, 0x03, 0xC9, 0xCD, 0xC8, 0x80, 0xC1, 0x01, 0xC4, 0xCE, 0xC4, 0xCE, 0xC2, 0xCE, +/* 0140 */ 0xC3, 0xC6, 0xCE, 0xC6, 0xCC, 0xCC, 0xCB, 0xC3, 0xCE, 0xCD, 0xC5, 0xC3, 0xC2, 0xCC, 0xCE, 0xCD, +/* 0150 */ 0xC3, 0xCE, 0xCB, 0xCA, 0xCC, 0x01, 0xCC, 0xCD, 0x80, 0xC3, 0xCE, 0xC6, 0xCD, 0xCE, 0xC9, 0xCC, +/* 0160 */ 0xC3, 0xCC, 0xCD, 0xC7, 0xCD, 0xC4, 0x01, 0xC7, 0x81, 0x15, 0x80, 0xC7, 0xD6, 0xCE, 0xC7, 0xCA, +/* 0170 */ 0xC7, 0xCB, 0xCE, 0xCE, 0x80, 0xCB, 0xCC, 0xC3, 0x80, 0xC6, 0xCA, 0xC1, 0xC2, 0xCD, 0xCB, 0x01, +/* 0180 */ 0xCD, 0xC3, 0xC1, 0x80, 0xC4, 0xCD, 0xC9, 0x3C, 0x20, 0x3C, 0x1F, 0x57, 0x1B, 0x01, 0x5E, 0x94, +/* 0190 */ 0x19, 0x79, 0x88, 0x74, 0x57, 0x0F, 0x3D, 0x25, 0x98, 0x03, 0x07, 0x88, 0x19, 0x55, 0x00, 0x03, +/* 01A0 */ 0x4A, 0x91, 0x47, 0x9F, 0x6B, 0x5B, 0x9E, 0x06, 0x92, 0x19, 0x78, 0x00, 0x66, 0x19, 0x0A, 0xF5, +/* 01B0 */ 0x96, 0x19, 0x0A, 0xF5, 0x96, 0x19, 0x78, 0x00, 0x66, 0x19, 0x03, 0x52, 0x06, 0x54, 0x37, 0x67, +/* 01C0 */ 0x24, 0x06, 0x4E, 0x64, 0x4B, 0x24, 0x06, 0x4E, 0x09, 0x32, 0x03, 0x6D, 0x5E, 0x66, 0x25, 0x2D, +/* 01D0 */ 0x41, 0x25, 0x2D, 0x09, 0x0F, 0x6D, 0x5E, 0x9C, 0x27, 0x0A, 0x32, 0x02, 0x01, 0x05, 0x06, 0x4A, +/* 01E0 */ 0x25, 0x8C, 0x0F, 0x92, 0x25, 0x0A, 0x62, 0x92, 0x25, 0x0B, 0x4F, 0x50, 0x19, 0x79, 0x32, 0x08, +/* 01F0 */ 0x08, 0x7D, 0x24, 0x6B, 0x55, 0x06, 0x00, 0x26, 0x4A, 0x00, 0x26, 0x4A, 0x00, 0x26, 0x4A, 0x00, +/* 0200 */ 0x36, 0x59, 0x1D, 0x1D, 0x0F, 0x52, 0x68, 0x19, 0x78, 0x65, 0x19, 0x78, 0x65, 0x19, 0x78, 0x65, +/* 0210 */ 0x19, 0x78, 0x65, 0x19, 0x78, 0x03, 0x4A, 0x1F, 0x34, 0x50, 0x09, 0x0F, 0x48, 0x1E, 0x94, 0x51, +/* 0220 */ 0x51, 0x51, 0x91, 0x07, 0x33, 0x1C, 0x07, 0x94, 0x33, 0x0E, 0x6A, 0x8D, 0x33, 0x0E, 0x63, 0x8D, +/* 0230 */ 0x33, 0x60, 0x0E, 0x1F, 0x57, 0x1F, 0x57, 0x55, 0x06, 0x92, 0x25, 0x7D, 0x24, 0x00, 0x1E, 0x67, +/* 0240 */ 0x09, 0x20, 0x0A, 0x04, 0x0D, 0x2C, 0x22, 0x5E, 0x25, 0x80, 0x87, 0x2C, 0x00, 0x1E, 0x25, 0x2D, +/* 0250 */ 0x1E, 0x22, 0x5E, 0x8A, 0x19, 0x71, 0x86, 0x4A, 0x22, 0x0E, 0x99, 0x38, 0x99, 0x35, 0x18, 0x0E, +/* 0260 */ 0xA0, 0x18, 0x0B, 0x5E, 0x59, 0x54, 0x27, 0x6A, 0x04, 0x27, 0x1A, 0x4D, 0x09, 0x32, 0x38, 0x6F, +/* 0270 */ 0x93, 0x27, 0x2D, 0x18, 0x2D, 0x00, 0x94, 0x33, 0x0F, 0x60, 0x94, 0x33, 0x0B, 0x43, 0x38, 0x34, +/* 0280 */ 0x40, 0x18, 0x29, 0x5F, 0x29, 0x5F, 0x01, 0x92, 0x33, 0x60, 0x0B, 0x92, 0x19, 0x4B, 0x78, 0x33, +/* 0290 */ 0x4A, 0x87, 0x22, 0x09, 0x76, 0x01, 0x7B, 0x41, 0x70, 0x1F, 0x9A, 0x72, 0x03, 0x81, 0x64, 0x8F, +/* 02A0 */ 0x2A, 0x0B, 0x64, 0x95, 0x19, 0x53, 0x72, 0x54, 0x19, 0x53, 0x00, 0x09, 0x9D, 0x0A, 0x57, 0x9D, +/* 02B0 */ 0x0A, 0x57, 0x9D, 0x0A, 0x57, 0x9D, 0x0A, 0x22, 0x88, 0x44, 0x4E, 0x59, 0x4E, 0x85, 0x38, 0x7D, +/* 02C0 */ 0x73, 0x23, 0x0A, 0x90, 0x5D, 0x25, 0x0A, 0x7C, 0x82, 0x6D, 0x4A, 0x07, 0x21, 0x0A, 0x00, 0x08, +/* 02D0 */ 0x52, 0x03, 0x36, 0x27, 0x47, 0x4A, 0x6B, 0x05, 0x9F, 0x01, 0x63, 0x99, 0x48, 0x18, 0x34, 0x27, +/* 02E0 */ 0x34, 0x0F, 0x5D, 0x18, 0x1E, 0x3E, 0x27, 0x99, 0x06, 0x9F, 0x33, 0x88, 0x09, 0x4E, 0x33, 0x90, +/* 02F0 */ 0x50, 0x22, 0x0F, 0x18, 0x03, 0x4A, 0x18, 0x03, 0x4A, 0x00, 0x90, 0x4A, 0x22, 0x2B, 0x90, 0x81, +/* 0300 */ 0x22, 0x5E, 0x91, 0x01, 0x03, 0x67, 0x1D, 0x70, 0x89, 0x22, 0x92, 0x83, 0x25, 0x4B, 0x4B, 0x5E, +/* 0310 */ 0x9E, 0x22, 0x4E, 0x59, 0x88, 0x59, 0x75, 0x31, 0x5E, 0x03, 0x31, 0x5E, 0x9E, 0x22, 0x90, 0x92, +/* 0320 */ 0x0A, 0x20, 0x6A, 0x1F, 0x79, 0x24, 0x6B, 0x70, 0x05, 0x07, 0x57, 0x1B, 0x25, 0x4B, 0x7F, 0x22, +/* 0330 */ 0x4E, 0x00, 0x72, 0x04, 0x1F, 0x92, 0x33, 0x39, 0x78, 0x1E, 0x6B, 0x4A, 0x61, 0x27, 0x2E, 0x07, +/* 0340 */ 0x44, 0x3A, 0x72, 0x92, 0x18, 0x0C, 0x73, 0x1B, 0x0E, 0x8E, 0x0A, 0x88, 0x33, 0x04, 0x32, 0x49, +/* 0350 */ 0x52, 0x24, 0x9D, 0x2C, 0x04, 0x0C, 0x52, 0x05, 0x54, 0x20, 0x69, 0x20, 0x1E, 0x20, 0x0B, 0x5C, +/* 0360 */ 0x00, 0x52, 0x8C, 0x09, 0x18, 0x93, 0x6C, 0x6E, 0x40, 0x6C, 0x08, 0x0A, 0x7E, 0x26, 0x01, 0x72, +/* 0370 */ 0x0B, 0x54, 0x27, 0x99, 0x5F, 0x49, 0x46, 0x7F, 0x0D, 0x5F, 0x18, 0x0A, 0x62, 0x22, 0x0F, 0x52, +/* 0380 */ 0x4B, 0x3B, 0x1B, 0x0F, 0x0D, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x05, 0x00, +/* 0390 */ 0x07, 0x00, 0x0F, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x15, 0x00, 0x17, 0x00, 0x19, 0x00, +/* 03A0 */ 0x1B, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x22, 0x00, 0x24, 0x00, 0x26, 0x00, +/* 03B0 */ 0x28, 0x00, 0x2B, 0x00, 0x2C, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x32, 0x00, 0x34, 0x00, +/* 03C0 */ 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x41, 0x00, 0x43, 0x00, +/* 03D0 */ 0x45, 0x00, 0x47, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x53, 0x00, 0x55, 0x00, 0x57, 0x00, 0x59, 0x00, +/* 03E0 */ 0x5B, 0x00, 0x5C, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x63, 0x00, 0x65, 0x00, 0x68, 0x00, +/* 03F0 */ 0x6A, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x7D, 0x00, +/* 0400 */ 0x7F, 0x00, 0x81, 0x00, 0x83, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8A, 0x00, 0x8C, 0x00, 0x8D, 0x00, +/* 0410 */ 0x8F, 0x00, 0x91, 0x00, 0x93, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D, 0x00, +/* 0420 */ 0x9E, 0x00, 0xA1, 0x00, 0xA2, 0x00, 0xA4, 0x00, 0xA5, 0x00, 0xA7, 0x00, 0xA9, 0x00, 0xAB, 0x00, +/* 0430 */ 0xAD, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBB, 0x00, +/* 0440 */ 0xBC, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00, 0xCA, 0x00, +/* 0450 */ 0xCC, 0x00, 0xCE, 0x00, 0xD0, 0x00, 0xD2, 0x00, 0xD4, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00, +/* 0460 */ 0xDC, 0x00, 0xDE, 0x00, 0xE1, 0x00, 0xE3, 0x00, 0xE5, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEB, 0x00, +/* 0470 */ 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF8, 0x00, +/* 0480 */ 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x01, 0x08, 0x01, +/* 0490 */ 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x18, 0x01, 0x2D, 0x01, 0x32, 0x01, +/* 04A0 */ 0x46, 0x01, 0x4B, 0x01, 0x53, 0x01, 0x67, 0x01, 0x7C, 0x01, 0x80, 0x01, 0x8B, 0x01, 0x92, 0x01, +/* 04B0 */ 0xAA, 0x01, 0xAE, 0x01, 0xBE, 0x01, 0xC2, 0x01, 0xC9, 0x01, 0xCF, 0x01, 0xD1, 0x01, 0xD3, 0x01, +/* 04C0 */ 0xD7, 0x01, 0xE1, 0x01, 0xF6, 0x02, 0x00, 0x02, 0x07, 0x02, 0x12, 0x02, 0x17, 0x02, 0x1E, 0x02, +/* 04D0 */ 0x2C, 0x02, 0x37, 0x02, 0x45, 0x02, 0x48, 0x02, 0x59, 0x02, 0x5B, 0x02, 0x65, 0x02, 0x68, 0x02, +/* 04E0 */ 0x6A, 0x02, 0x6D, 0x02, 0x71, 0x02, 0x73, 0x02, 0x7E, 0x02, 0x85, 0x02, 0x88, 0x02, 0x8D, 0x02, +/* 04F0 */ 0x9A, 0x02, 0xAB, 0x02, 0xAE, 0x02, 0xB0, 0x02, 0xB7, 0x02, 0xBA, 0x02, 0xBC, 0x02, 0xC0, 0x02, +/* 0500 */ 0xC3, 0x02, 0xC9, 0x02, 0xCC, 0x02, 0xCE, 0x02, 0xD3, 0x02, 0xD5, 0x02, 0xD8, 0x02, 0xDA, 0x02, +/* 0510 */ 0xDC, 0x02, 0xDF, 0x02, 0xE4, 0x02, 0xE7, 0x02, 0xE9, 0x02, 0xEB, 0x02, 0xF2, 0x02, 0xF5, 0x02, +/* 0520 */ 0xFB, 0x03, 0x00, 0x03, 0x03, 0x03, 0x05, 0x03, 0x07, 0x03, 0x0E, 0x03, 0x10, +/* char range info */ +0x00, 0x00, 0x02, +/* 0530 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x12, 0x00, 0x1D, 0x00, 0x3B, 0x00, 0x5E, 0x00, 0x90, +/* 0540 */ 0x00, 0xB5, 0x00, 0xBC, 0x00, 0xD3, 0x00, 0xEA, 0x00, 0xFC, 0x01, 0x03, 0x01, 0x0A, 0x01, 0x13, +/* 0550 */ 0x01, 0x18, 0x01, 0x2B, 0x01, 0x4A, 0x01, 0x60, 0x01, 0x79, 0x01, 0x92, 0x01, 0xAC, 0x01, 0xC7, +/* 0560 */ 0x01, 0xE6, 0x01, 0xF9, 0x02, 0x19, 0x02, 0x3B, 0x02, 0x43, 0x02, 0x4D, 0x02, 0x60, 0x02, 0x67, +/* 0570 */ 0x02, 0x79, 0x02, 0x90, 0x02, 0xC9, 0x02, 0xCF, 0x02, 0xE9, 0x02, 0xF8, 0x03, 0x0F, 0x03, 0x14, +/* 0580 */ 0x03, 0x25, 0x03, 0x45, 0x03, 0x59, 0x03, 0x5E, 0x03, 0x6F, 0x03, 0x8A, 0x03, 0x97, 0x03, 0xC4, +/* 0590 */ 0x03, 0xCD, 0x03, 0xD3, 0x03, 0xDF, 0x03, 0xEF, 0x03, 0xFF, 0x04, 0x1E, 0x04, 0x35, 0x04, 0x3B, +/* 05A0 */ 0x04, 0x59, 0x04, 0x89, 0x04, 0xA6, 0x04, 0xB0, 0x04, 0xC3, 0x04, 0xD6, 0x04, 0xED, 0x05, 0x01, +/* 05B0 */ 0x05, 0x10, 0x05, 0x1B, 0x05, 0x24, 0x05, 0x29, 0x05, 0x2F, 0x05, 0x38, 0x05, 0x4C, 0x05, 0x52, +/* 05C0 */ 0x05, 0x69, 0x05, 0x8C, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xB2, 0x05, 0xC9, 0x05, 0xD6, 0x05, 0xE7, +/* 05D0 */ 0x05, 0xF2, 0x05, 0xF6, 0x06, 0x03, 0x06, 0x16, 0x06, 0x22, 0x06, 0x37, 0x06, 0x4D, 0x06, 0x53, +/* 05E0 */ 0x06, 0x68, 0x06, 0x8B, 0x06, 0xA3, 0x06, 0xA8, 0x06, 0xB8, 0x06, 0xD1, 0x06, 0xDD, 0x06, 0xF8, +/* 05F0 */ 0x02, 0x00, 0x10, 0x02, 0x30, 0x2D, 0x18, 0x77, 0x20, 0x35, 0x20, 0x6A, 0x67, 0x0C, 0x2F, 0x59, +/* 0600 */ 0xCE, 0x10, 0x04, 0x30, 0x6A, 0x6A, 0x31, 0x5A, 0x0B, 0x27, 0x9A, 0x9A, 0x10, 0x05, 0x28, 0x5A, +/* 0610 */ 0x09, 0x4C, 0x0C, 0x53, 0x08, 0x57, 0x0F, 0x3D, 0x6B, 0x5E, 0x89, 0x25, 0x03, 0x4E, 0x88, 0x19, +/* 0620 */ 0x9D, 0x75, 0x23, 0x08, 0x8D, 0x7B, 0x19, 0xC1, 0x0B, 0x7E, 0x10, 0x05, 0x49, 0x0C, 0x52, 0x29, +/* 0630 */ 0x42, 0x03, 0x97, 0x5E, 0x25, 0x0A, 0x54, 0x04, 0x6C, 0x09, 0x92, 0x01, 0x3A, 0x0B, 0x3D, 0x2A, +/* 0640 */ 0x63, 0x2C, 0x82, 0x00, 0x85, 0x25, 0x0A, 0x3D, 0x9F, 0xC7, 0x03, 0x20, 0x4E, 0x10, 0x08, 0x20, +/* 0650 */ 0x1A, 0x26, 0x19, 0x03, 0x1C, 0x01, 0x00, 0x0C, 0x04, 0x1F, 0x09, 0x09, 0x5A, 0x73, 0x19, 0x95, +/* 0660 */ 0x0A, 0x08, 0x4F, 0xCF, 0x3D, 0x35, 0x3A, 0x02, 0x8D, 0x0D, 0x56, 0x33, 0x0C, 0x08, 0x0A, 0x0A, +/* 0670 */ 0x08, 0x64, 0x71, 0x7A, 0x09, 0x0A, 0x0A, 0x08, 0x1F, 0x53, 0x00, 0x6E, 0x56, 0x1F, 0x71, 0x10, +/* 0680 */ 0x07, 0x00, 0x2B, 0xD9, 0x19, 0x71, 0x55, 0x66, 0x27, 0x50, 0x7F, 0x31, 0x0F, 0x7B, 0x01, 0x1F, +/* 0690 */ 0x71, 0x8A, 0x7C, 0x62, 0x1F, 0x06, 0x88, 0x0A, 0x0E, 0x54, 0x64, 0x34, 0x50, 0x6F, 0x56, 0x19, +/* 06A0 */ 0x1E, 0x0D, 0x7E, 0x05, 0x10, 0x02, 0x30, 0x6A, 0x67, 0x5C, 0x9A, 0x10, 0x03, 0x91, 0x72, 0x03, +/* 06B0 */ 0x20, 0x69, 0x18, 0x63, 0x2A, 0x77, 0x20, 0xE1, 0x0D, 0x5C, 0xE1, 0x77, 0x00, 0x3F, 0x88, 0xDF, +/* 06C0 */ 0x02, 0x03, 0x10, 0x03, 0x91, 0x82, 0x00, 0xE8, 0x5C, 0x03, 0x9F, 0x20, 0xA0, 0x20, 0xE1, 0x98, +/* 06D0 */ 0x20, 0xE1, 0xA0, 0x18, 0x03, 0x9F, 0xE8, 0x5C, 0x82, 0x10, 0x04, 0x30, 0xC1, 0x0A, 0x18, 0x09, +/* 06E0 */ 0x0B, 0x7F, 0x25, 0x34, 0x0E, 0x4A, 0x27, 0x73, 0x5A, 0x3B, 0x02, 0x10, 0x05, 0x4D, 0x99, 0xC2, +/* 06F0 */ 0xC7, 0x01, 0x10, 0x02, 0x30, 0x45, 0x08, 0x5C, 0xB1, 0x10, 0x04, 0x2F, 0x45, 0x47, 0x05, 0x3A, +/* 0700 */ 0x03, 0x9E, 0x10, 0x02, 0x45, 0x2B, 0xCE, 0x10, 0x05, 0x68, 0x06, 0x60, 0xE8, 0x5C, 0xE7, 0x02, +/* 0710 */ 0x9F, 0xC5, 0x52, 0x8B, 0x20, 0xE7, 0x01, 0x5E, 0x3F, 0x36, 0x10, 0x05, 0x30, 0xC1, 0x32, 0x38, +/* 0720 */ 0x65, 0xB2, 0x07, 0x0F, 0xC1, 0x0E, 0x25, 0x1E, 0x8F, 0x0F, 0x25, 0x1E, 0x8F, 0x0F, 0x22, 0x0F, +/* 0730 */ 0xC1, 0x0E, 0x25, 0x65, 0x0C, 0x2C, 0xC1, 0x32, 0x02, 0x10, 0x04, 0x00, 0x2B, 0x50, 0x27, 0x47, +/* 0740 */ 0x08, 0x00, 0x6D, 0x04, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x10, +/* 0750 */ 0x05, 0x30, 0x73, 0x89, 0x27, 0x95, 0x3C, 0x52, 0x6F, 0x2A, 0x09, 0x36, 0x3A, 0x0F, 0x5F, 0x87, +/* 0760 */ 0x6C, 0xC1, 0x4A, 0x03, 0x6C, 0x0C, 0x90, 0x5E, 0x10, 0x05, 0x30, 0x73, 0x61, 0x31, 0x06, 0x09, +/* 0770 */ 0xBF, 0x25, 0xC1, 0x50, 0x3B, 0x08, 0x88, 0x3B, 0x4A, 0x25, 0x0A, 0x06, 0x08, 0x9F, 0x25, 0x7D, +/* 0780 */ 0x61, 0x10, 0x05, 0x28, 0x03, 0x0B, 0x52, 0x08, 0x0E, 0x20, 0xA0, 0x3F, 0x9F, 0x5E, 0x25, 0x09, +/* 0790 */ 0x7B, 0x5E, 0x25, 0x0C, 0xF3, 0x6B, 0x03, 0x05, 0x92, 0x3B, 0x5E, 0x10, 0x05, 0x2B, 0x90, 0x9F, +/* 07A0 */ 0x22, 0x7C, 0x9E, 0x22, 0x0E, 0x67, 0x0F, 0x32, 0x6C, 0x03, 0x06, 0x05, 0x92, 0x20, 0x24, 0x22, +/* 07B0 */ 0x07, 0x06, 0x4A, 0x25, 0x73, 0x24, 0x10, 0x05, 0x30, 0x79, 0x0D, 0x7A, 0x19, 0x71, 0x44, 0x05, +/* 07C0 */ 0x6C, 0x6F, 0x1B, 0x09, 0x40, 0x62, 0x25, 0x09, 0x5E, 0x0B, 0x0D, 0x57, 0xC1, 0xFD, 0xCF, 0x4A, +/* 07D0 */ 0x66, 0x25, 0xC1, 0x0E, 0x56, 0x10, 0x04, 0x30, 0x0E, 0x75, 0x38, 0x5B, 0x2D, 0x18, 0xA0, 0x3F, +/* 07E0 */ 0x9F, 0x18, 0xE0, 0x24, 0xC5, 0x21, 0x71, 0x05, 0x10, 0x05, 0x28, 0x0A, 0x5D, 0x03, 0x6D, 0x5E, +/* 07F0 */ 0x9C, 0x6D, 0x36, 0x74, 0x6B, 0x8A, 0x7C, 0x00, 0xCF, 0x61, 0x0E, 0x23, 0x98, 0x00, 0x41, 0x25, +/* 0800 */ 0x09, 0x7A, 0x96, 0x19, 0x71, 0x0B, 0x0F, 0x8E, 0x10, 0x05, 0x30, 0x01, 0x0B, 0x85, 0x6C, 0x08, +/* 0810 */ 0x62, 0x0E, 0x23, 0x98, 0x00, 0x98, 0x25, 0x0A, 0x7B, 0x0D, 0x0D, 0x25, 0x03, 0x3D, 0x85, 0x26, +/* 0820 */ 0x04, 0x4A, 0x19, 0x71, 0x06, 0x32, 0x27, 0x03, 0x8D, 0x01, 0x10, 0x02, 0x45, 0x8F, 0xCE, 0x2F, +/* 0830 */ 0x59, 0xCE, 0x10, 0x02, 0x45, 0x8F, 0xCE, 0x25, 0x1A, 0xC1, 0x5C, 0xB1, 0x10, 0x05, 0x4D, 0x71, +/* 0840 */ 0x07, 0x01, 0x6B, 0x08, 0x32, 0x38, 0x0B, 0x7A, 0x64, 0x6D, 0x0D, 0x8D, 0x52, 0x06, 0x84, 0x10, +/* 0850 */ 0x05, 0x00, 0x45, 0xA3, 0x25, 0xA3, 0x10, 0x05, 0x2E, 0x04, 0x05, 0x20, 0x73, 0x4F, 0x01, 0x59, +/* 0860 */ 0x92, 0x6B, 0x09, 0x32, 0x03, 0x22, 0x0B, 0x04, 0x10, 0x04, 0x30, 0x73, 0x24, 0x00, 0x6D, 0x08, +/* 0870 */ 0x41, 0x2A, 0x09, 0x4E, 0x00, 0x6D, 0x92, 0xE8, 0x5C, 0x37, 0xC1, 0x08, 0x00, 0xE8, 0x0A, 0x10, +/* 0880 */ 0x09, 0x28, 0x79, 0x83, 0x24, 0x01, 0x1F, 0x06, 0x50, 0x04, 0x05, 0x66, 0x00, 0x71, 0x94, 0x06, +/* 0890 */ 0xD9, 0x89, 0x34, 0x4E, 0x4A, 0x62, 0x0A, 0x0A, 0xC1, 0x8E, 0x36, 0x62, 0x6A, 0xC1, 0x81, 0xFD, +/* 08A0 */ 0x62, 0x09, 0x0B, 0x00, 0x06, 0x88, 0x4A, 0x24, 0x8D, 0x72, 0x0F, 0x9A, 0x7A, 0x9C, 0x01, 0x00, +/* 08B0 */ 0x8F, 0x50, 0x04, 0x04, 0x04, 0x6D, 0x83, 0x24, 0x10, 0x05, 0x30, 0x34, 0xC6, 0xA2, 0x10, 0x06, +/* 08C0 */ 0x2B, 0x90, 0x4F, 0xB3, 0x0C, 0x36, 0x33, 0x88, 0x0A, 0x54, 0x33, 0xCA, 0x5E, 0x0A, 0x4E, 0x33, +/* 08D0 */ 0x4E, 0x04, 0x5E, 0x33, 0x5E, 0xDA, 0x90, 0x8D, 0x10, 0x05, 0x28, 0x73, 0xD0, 0xA1, 0x03, 0x70, +/* 08E0 */ 0x04, 0x08, 0x00, 0x6D, 0x0D, 0x24, 0x01, 0x10, 0x06, 0xCB, 0xDA, 0x39, 0x92, 0x33, 0x4E, 0x01, +/* 08F0 */ 0x55, 0x33, 0x4E, 0x01, 0x55, 0x33, 0x39, 0x92, 0x33, 0x5E, 0xDA, 0x0F, 0x5D, 0x04, 0x10, 0x05, +/* 0900 */ 0x2B, 0xCA, 0xCD, 0x10, 0x04, 0x2B, 0x90, 0x9F, 0xB3, 0x9E, 0xD2, 0x59, 0x88, 0x59, 0x90, 0x60, +/* 0910 */ 0xB3, 0x03, 0x31, 0xBF, 0x10, 0x06, 0x30, 0x79, 0x0D, 0x85, 0x02, 0x1F, 0x72, 0x70, 0x04, 0x0A, +/* 0920 */ 0x01, 0x19, 0x41, 0x1B, 0x3C, 0x20, 0x3C, 0x9D, 0x92, 0x19, 0x78, 0x65, 0xCF, 0x55, 0x05, 0x92, +/* 0930 */ 0x6D, 0x0D, 0x85, 0x03, 0x10, 0x06, 0x2B, 0x39, 0xD4, 0x92, 0x33, 0x0F, 0x82, 0x92, 0x33, 0x75, +/* 0940 */ 0x92, 0x33, 0x5E, 0x05, 0xD4, 0xD4, 0xD4, 0x92, 0x10, 0x03, 0x2B, 0xBF, 0xAD, 0x10, 0x03, 0x30, +/* 0950 */ 0x03, 0x4A, 0xC9, 0xC7, 0x06, 0xC9, 0xC7, 0x05, 0x59, 0x0F, 0x2A, 0x24, 0x20, 0x03, 0x10, 0x06, +/* 0960 */ 0x2B, 0x39, 0x92, 0x33, 0x4E, 0x0A, 0x54, 0x33, 0x5E, 0x92, 0x22, 0x0F, 0x83, 0x31, 0x55, 0x9F, +/* 0970 */ 0x22, 0x88, 0x85, 0xD2, 0x08, 0x88, 0x33, 0x39, 0x70, 0x10, 0x05, 0x2B, 0xBF, 0x51, 0x51, 0x59, +/* 0980 */ 0x92, 0x06, 0x03, 0x22, 0x90, 0x92, 0x10, 0x07, 0x30, 0x04, 0xEA, 0x00, 0x0A, 0x92, 0x64, 0x34, +/* 0990 */ 0xF7, 0x0C, 0x50, 0x1F, 0x7D, 0x7B, 0x0E, 0xA0, 0x64, 0x8F, 0x32, 0x06, 0x85, 0x0A, 0x64, 0xC1, +/* 09A0 */ 0x24, 0x0B, 0x7F, 0x0A, 0x64, 0xC1, 0x8D, 0x24, 0x74, 0x1F, 0x09, 0x8E, 0x92, 0x86, 0x64, 0x86, +/* 09B0 */ 0x9E, 0x0A, 0x0D, 0x10, 0x06, 0x2B, 0x70, 0xB8, 0x43, 0x80, 0xAE, 0xBA, 0x10, 0x06, 0x28, 0xA9, +/* 09C0 */ 0xA4, 0xB0, 0x10, 0x05, 0xCB, 0x0B, 0x36, 0x33, 0x4E, 0xC8, 0x05, 0x01, 0x31, 0xBF, 0x10, 0x06, +/* 09D0 */ 0x28, 0xA9, 0xA4, 0x55, 0x06, 0x5E, 0x6D, 0x97, 0x4F, 0x00, 0x26, 0x07, 0x7B, 0x46, 0x10, 0x06, +/* 09E0 */ 0xCB, 0x0B, 0x36, 0x33, 0x4E, 0xC8, 0x07, 0x4A, 0xD2, 0x0B, 0x0D, 0xD2, 0x04, 0x92, 0x10, 0x05, +/* 09F0 */ 0x30, 0x01, 0x0A, 0x32, 0x04, 0x57, 0x06, 0x07, 0x06, 0x25, 0x0A, 0x9F, 0x18, 0x63, 0x40, 0x42, +/* 0A00 */ 0x03, 0x0B, 0x0F, 0x5C, 0x83, 0x19, 0xC1, 0x08, 0xDB, 0x25, 0x58, 0x5D, 0x03, 0x10, 0x05, 0x30, +/* 0A10 */ 0x0E, 0x90, 0xEA, 0x25, 0x03, 0x07, 0x4A, 0x38, 0x34, 0x9F, 0xC5, 0x04, 0xC5, 0x04, 0xC5, 0x04, +/* 0A20 */ 0xC5, 0x04, 0xC5, 0x04, 0x10, 0x06, 0x30, 0x78, 0x65, 0xAC, 0x10, 0x05, 0x30, 0x55, 0x34, 0x9F, +/* 0A30 */ 0x19, 0x66, 0x00, 0x4B, 0x1F, 0xC1, 0x60, 0x86, 0x1F, 0x34, 0x4E, 0x0C, 0x09, 0x6B, 0x5E, 0x4A, +/* 0A40 */ 0x25, 0x9D, 0x3C, 0x21, 0x0A, 0x97, 0x59, 0x5D, 0x10, 0x08, 0x30, 0x0D, 0x0A, 0x00, 0x40, 0x00, +/* 0A50 */ 0x61, 0x64, 0x98, 0x02, 0xEA, 0x00, 0x92, 0x64, 0x09, 0x8E, 0x0D, 0x4E, 0x5E, 0x00, 0x8F, 0x0E, +/* 0A60 */ 0x9A, 0x5E, 0x88, 0x00, 0x34, 0x50, 0x35, 0x78, 0x00, 0x79, 0x40, 0x53, 0x96, 0x64, 0x72, 0x0F, +/* 0A70 */ 0x7A, 0x09, 0x32, 0x00, 0xEC, 0x4E, 0x08, 0x70, 0x10, 0x05, 0x30, 0x0B, 0x60, 0x09, 0x54, 0x1F, +/* 0A80 */ 0x34, 0x9F, 0x61, 0x25, 0x9D, 0x0D, 0x4E, 0x31, 0x70, 0x18, 0x09, 0xEA, 0x26, 0x55, 0x5E, 0xD2, +/* 0A90 */ 0x9C, 0x25, 0x1C, 0xC1, 0x4E, 0x10, 0x05, 0x30, 0x1C, 0x34, 0x5E, 0x19, 0xD5, 0xB9, 0x50, 0x10, +/* 0AA0 */ 0x05, 0x30, 0x47, 0x70, 0x6B, 0x03, 0x07, 0x0F, 0x5F, 0xE5, 0xE5, 0x0A, 0x5E, 0x82, 0x19, 0x9D, +/* 0AB0 */ 0x90, 0x70, 0x10, 0x03, 0x91, 0x0B, 0x40, 0x18, 0x98, 0x1B, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, +/* 0AC0 */ 0xE1, 0x0B, 0x40, 0x3B, 0x82, 0x10, 0x05, 0x91, 0x71, 0x20, 0x63, 0x52, 0x01, 0x5E, 0x20, 0xE7, +/* 0AD0 */ 0x00, 0x8B, 0xC4, 0x36, 0x3B, 0x9F, 0x20, 0xE7, 0x00, 0x0A, 0x5C, 0x7D, 0x10, 0x03, 0x91, 0x0C, +/* 0AE0 */ 0x70, 0x3B, 0x69, 0x20, 0x69, 0xDF, 0x69, 0xDF, 0x69, 0xDF, 0x69, 0x18, 0x0C, 0x70, 0x3B, 0x82, +/* 0AF0 */ 0x10, 0x05, 0x19, 0x46, 0x08, 0x03, 0xE8, 0x40, 0x3A, 0x0F, 0x6F, 0x48, 0x77, 0x00, 0x74, 0x10, +/* 0B00 */ 0x05, 0x00, 0x45, 0x45, 0x0E, 0x75, 0x23, 0x03, 0x5B, 0x82, 0x10, 0x03, 0x91, 0x01, 0x01, 0x67, +/* 0B10 */ 0x8E, 0xC4, 0x07, 0x10, 0x05, 0x2E, 0xE3, 0xA8, 0x10, 0x05, 0xCC, 0xBB, 0x85, 0x62, 0x10, 0x04, +/* 0B20 */ 0xB7, 0x18, 0x6F, 0x93, 0xE8, 0x0E, 0x56, 0x10, 0x05, 0x49, 0x72, 0x02, 0x20, 0xE0, 0x1E, 0x19, +/* 0B30 */ 0x71, 0x96, 0x8A, 0x6D, 0x4A, 0x83, 0x25, 0x1E, 0xB5, 0x83, 0x96, 0x10, 0x05, 0x4D, 0x0A, 0xC0, +/* 0B40 */ 0xD9, 0x10, 0x03, 0x28, 0x0A, 0x85, 0x64, 0xCF, 0x92, 0x48, 0xFA, 0x9F, 0x00, 0x6D, 0x4A, 0x6C, +/* 0B50 */ 0x79, 0x9F, 0x3F, 0x9F, 0x3F, 0x9F, 0x3F, 0x9F, 0x10, 0x05, 0x2F, 0x68, 0x03, 0x06, 0x6B, 0x0C, +/* 0B60 */ 0x3D, 0x2C, 0x0A, 0x62, 0x5E, 0x25, 0x0A, 0x56, 0x92, 0x25, 0x03, 0x90, 0x7B, 0x6D, 0x89, 0x42, +/* 0B70 */ 0x80, 0x90, 0x23, 0x0C, 0x08, 0x02, 0x87, 0x25, 0x7D, 0x5D, 0x04, 0x10, 0x05, 0x91, 0x01, 0x03, +/* 0B80 */ 0x67, 0x1D, 0x70, 0x62, 0x22, 0x50, 0x85, 0xD1, 0xD1, 0xD1, 0xD1, 0x10, 0x03, 0x91, 0x58, 0xA5, +/* 0B90 */ 0xAB, 0x10, 0x03, 0x91, 0x58, 0xA5, 0x1D, 0x1D, 0x0F, 0x52, 0x78, 0x26, 0x87, 0x3F, 0x84, 0x64, +/* 0BA0 */ 0x26, 0x10, 0x05, 0x91, 0x02, 0x06, 0x67, 0x1D, 0x36, 0x98, 0xB3, 0x9F, 0x22, 0x0F, 0x66, 0x31, +/* 0BB0 */ 0x70, 0x54, 0x22, 0x0F, 0x65, 0x25, 0x4B, 0x96, 0x10, 0x03, 0x91, 0x02, 0x05, 0x1F, 0x57, 0xAF, +/* 0BC0 */ 0xAF, 0xAF, 0x1B, 0x03, 0x24, 0x10, 0x08, 0xD6, 0x94, 0x9C, 0x64, 0x8F, 0x92, 0x0F, 0xA0, 0x4E, +/* 0BD0 */ 0x64, 0x4B, 0xA6, 0x64, 0x4B, 0xA6, 0x10, 0x05, 0xD6, 0x62, 0x22, 0x92, 0x9C, 0xD1, 0xD1, 0xD1, +/* 0BE0 */ 0xD1, 0x10, 0x05, 0x4D, 0xA7, 0x10, 0x05, 0xD6, 0x89, 0x22, 0x92, 0x96, 0x25, 0x4B, 0x4B, 0xBB, +/* 0BF0 */ 0x5D, 0xE9, 0x10, 0x05, 0x2E, 0x01, 0x96, 0x96, 0x6D, 0x4A, 0x83, 0x25, 0x1E, 0xB5, 0x83, 0x83, +/* 0C00 */ 0x20, 0xE0, 0xE0, 0x01, 0x03, 0x10, 0x04, 0xD6, 0x09, 0x31, 0x55, 0x02, 0x00, 0xD2, 0x59, 0x1D, +/* 0C10 */ 0x36, 0x10, 0x04, 0x2E, 0x03, 0x83, 0x4C, 0x0A, 0x8E, 0x06, 0x31, 0x70, 0x2A, 0x73, 0x54, 0x6D, +/* 0C20 */ 0x05, 0x09, 0x4E, 0x22, 0x0D, 0x61, 0x10, 0x04, 0x30, 0x01, 0x05, 0x01, 0xC5, 0x48, 0xF0, 0x88, +/* 0C30 */ 0x00, 0xB3, 0xC5, 0x21, 0x34, 0x88, 0x3F, 0x92, 0x01, 0x26, 0x0C, 0x89, 0x10, 0x05, 0x2E, 0x41, +/* 0C40 */ 0xBE, 0xB4, 0x10, 0x05, 0x2E, 0x44, 0x00, 0xB2, 0x0A, 0x0C, 0x01, 0x4A, 0x25, 0x6F, 0x63, 0x38, +/* 0C50 */ 0x99, 0x77, 0x18, 0x0E, 0x44, 0xE8, 0x4A, 0x10, 0x07, 0x2E, 0xA0, 0x05, 0x9F, 0x0A, 0x0B, 0x1F, +/* 0C60 */ 0x0B, 0x5A, 0x0F, 0x7E, 0x09, 0x64, 0xC1, 0x69, 0x0B, 0x08, 0x89, 0x1F, 0x06, 0x32, 0x07, 0x0B, +/* 0C70 */ 0x9F, 0x1F, 0x03, 0x3D, 0x80, 0x36, 0x1F, 0x29, 0x54, 0x3D, 0x10, 0x05, 0x2E, 0x0B, 0x84, 0x5E, +/* 0C80 */ 0x25, 0x03, 0x40, 0x0D, 0x18, 0x0B, 0x4A, 0x18, 0x43, 0x4C, 0x06, 0x92, 0x4E, 0x19, 0x9D, 0x0A, +/* 0C90 */ 0x01, 0x50, 0x10, 0x05, 0x2E, 0xDD, 0xB6, 0x10, 0x04, 0x2E, 0x0B, 0x75, 0x3A, 0xDB, 0x59, 0x88, +/* 0CA0 */ 0x3A, 0x24, 0xE8, 0x9F, 0x21, 0x43, 0x3D, 0x10, 0x03, 0x91, 0x01, 0x7F, 0xC5, 0x04, 0xC5, 0x52, +/* 0CB0 */ 0x4B, 0x18, 0x24, 0x18, 0xC1, 0x60, 0xC5, 0x52, 0x05, 0x36, 0xC5, 0x21, 0x71, 0x0E, 0x5C, 0x9B, +/* 0CC0 */ 0x10, 0x03, 0x91, 0x29, 0xAA, 0x26, 0x4A, 0x18, 0x29, 0xAA, 0x26, 0x4A, 0x10, 0x03, 0x91, 0x66, +/* 0CD0 */ 0x52, 0x05, 0x9F, 0x3B, 0x9F, 0x3B, 0x5E, 0x00, 0xE8, 0x0D, 0x00, 0x26, 0x92, 0x3B, 0x9F, 0x3B, +/* 0CE0 */ 0x9F, 0x18, 0x63, 0x2A, 0x87, 0x01, 0x3B, 0x10, 0x05, 0x45, 0x34, 0x61, 0x05, 0x48, 0x09, 0x06, +/* 0CF0 */ 0x43, 0x2A, 0x9B, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x13, 0x00, 0x2D, 0x00, 0x48, 0x00, 0x65, +/* 0D00 */ 0x00, 0x86, 0x00, 0x8F, 0x00, 0xB1, 0x00, 0xB5, 0x00, 0xE0, 0x00, 0xF9, 0x01, 0x14, 0x01, 0x20, +/* 0D10 */ 0x01, 0x29, 0x01, 0x47, 0x01, 0x4E, 0x01, 0x61, 0x01, 0x70, 0x01, 0x80, 0x01, 0x92, 0x01, 0x9B, +/* 0D20 */ 0x01, 0xB4, 0x01, 0xD3, 0x01, 0xDA, 0x01, 0xE8, 0x01, 0xF3, 0x02, 0x0B, 0x02, 0x25, 0x02, 0x36, +/* 0D30 */ 0x02, 0x57, 0x02, 0x77, 0x02, 0x8D, 0x02, 0x9A, 0x02, 0xA4, 0x02, 0xB1, 0x02, 0xBB, 0x02, 0xC7, +/* 0D40 */ 0x02, 0xD6, 0x02, 0xF9, 0x03, 0x0E, 0x03, 0x18, 0x03, 0x22, 0x03, 0x2E, 0x03, 0x38, 0x03, 0x44, +/* 0D50 */ 0x03, 0x4F, 0x03, 0x5A, 0x03, 0x63, 0x03, 0x87, 0x03, 0x95, 0x03, 0xA2, 0x03, 0xB0, 0x03, 0xBE, +/* 0D60 */ 0x03, 0xC9, 0x03, 0xD1, 0x03, 0xE3, 0x04, 0x10, 0x04, 0x1B, 0x04, 0x26, 0x04, 0x34, 0x04, 0x41, +/* 0D70 */ 0x04, 0x51, 0x04, 0x60, 0x04, 0x7C, 0x04, 0x88, 0x04, 0x94, 0x04, 0xA0, 0x04, 0xAB, 0x04, 0xB5, +/* 0D80 */ 0x04, 0xC5, 0x04, 0xE8, 0x04, 0xF7, 0x05, 0x02, 0x05, 0x0A, 0x05, 0x13, 0x05, 0x1D, 0x05, 0x29, +/* 0D90 */ 0x05, 0x34, 0x05, 0x3F, 0x05, 0x4A, 0x05, 0x6A, 0x05, 0x7B, 0x05, 0x84, 0x05, 0x90, 0x05, 0x9B, +/* 0DA0 */ 0x05, 0xA3, 0x05, 0xAC, 0x05, 0xB6, 0x05, 0xD6, 0x05, 0xE2, 0x05, 0xEA, 0x05, 0xF3, 0x05, 0xFE, +/* 0DB0 */ 0x06, 0x09, 0x06, 0x0F, 0x02, 0x00, 0x10, 0x02, 0x2E, 0x6A, 0x67, 0x5C, 0x64, 0x67, 0x0C, 0x20, +/* 0DC0 */ 0x6A, 0x20, 0x35, 0x20, 0xE0, 0x2D, 0x10, 0x04, 0x68, 0x7B, 0x3B, 0x62, 0x3A, 0x0E, 0x97, 0x38, +/* 0DD0 */ 0x78, 0x01, 0x27, 0x2D, 0x18, 0x09, 0x36, 0x01, 0x27, 0x80, 0x0E, 0x7B, 0x3A, 0x5E, 0x20, 0x7B, +/* 0DE0 */ 0x10, 0x05, 0x30, 0x79, 0x0D, 0x62, 0x27, 0x7F, 0x08, 0x06, 0x27, 0x92, 0x20, 0x92, 0xE8, 0x90, +/* 0DF0 */ 0x4E, 0x6B, 0x55, 0x48, 0x79, 0x92, 0x03, 0x38, 0x0C, 0x90, 0x50, 0x10, 0x05, 0x20, 0x68, 0x76, +/* 0E00 */ 0x48, 0x0A, 0x8A, 0x69, 0x19, 0x34, 0x7A, 0x81, 0x22, 0x0B, 0x00, 0x95, 0x25, 0x73, 0x01, 0x0C, +/* 0E10 */ 0x06, 0x57, 0x0F, 0x55, 0x6D, 0x9B, 0x01, 0x05, 0x10, 0x05, 0x30, 0x0D, 0x0A, 0x00, 0x4B, 0x1F, +/* 0E20 */ 0xC1, 0x60, 0x0B, 0x0A, 0x6B, 0x5E, 0x9F, 0x27, 0x96, 0x0D, 0x25, 0x34, 0x97, 0x94, 0xC7, 0x06, +/* 0E30 */ 0x25, 0x34, 0x90, 0x50, 0x19, 0x71, 0x05, 0x92, 0x02, 0x10, 0x03, 0x91, 0x29, 0xAA, 0x1F, 0x49, +/* 0E40 */ 0x29, 0xAA, 0x10, 0x05, 0x28, 0x09, 0x32, 0x48, 0x63, 0x93, 0x01, 0x6B, 0x32, 0x05, 0x25, 0x34, +/* 0E50 */ 0xA0, 0x4A, 0x22, 0x7A, 0x4F, 0x19, 0x71, 0x08, 0x0E, 0x54, 0x27, 0x03, 0x04, 0x9F, 0x25, 0x63, +/* 0E60 */ 0xEA, 0x01, 0x27, 0x9B, 0x10, 0x04, 0x30, 0xE4, 0x10, 0x07, 0x30, 0x72, 0x0B, 0x0F, 0x81, 0x19, +/* 0E70 */ 0x9D, 0x0A, 0x85, 0x84, 0x64, 0x79, 0x8B, 0x07, 0x04, 0x05, 0x09, 0x1F, 0x06, 0x07, 0x7B, 0x00, +/* 0E80 */ 0x03, 0x0B, 0x64, 0x34, 0x8B, 0x05, 0x02, 0x05, 0x09, 0x64, 0x71, 0x85, 0x5D, 0x7A, 0xCF, 0x97, +/* 0E90 */ 0x92, 0x3B, 0x01, 0x10, 0x05, 0x20, 0x68, 0x6E, 0x61, 0x26, 0x04, 0x77, 0x64, 0xCF, 0x0D, 0xEA, +/* 0EA0 */ 0x31, 0x0F, 0x83, 0x3B, 0x71, 0x27, 0x9B, 0x02, 0x38, 0xC1, 0x90, 0x88, 0x10, 0x06, 0x2E, 0x71, +/* 0EB0 */ 0x04, 0x79, 0x6C, 0x98, 0x04, 0x5E, 0x33, 0x9F, 0x85, 0x25, 0x1E, 0x99, 0x23, 0x01, 0x24, 0x07, +/* 0EC0 */ 0x4E, 0x00, 0xCF, 0x08, 0x00, 0x09, 0x03, 0x10, 0x05, 0x2F, 0x45, 0x47, 0x92, 0x6B, 0x5B, 0x8D, +/* 0ED0 */ 0x20, 0x09, 0x05, 0x10, 0x04, 0x2F, 0x45, 0x47, 0x05, 0x3A, 0x03, 0x9E, 0x10, 0x06, 0x30, 0xC1, +/* 0EE0 */ 0xD9, 0x00, 0xCF, 0x43, 0x87, 0x01, 0x19, 0x09, 0x05, 0x09, 0x5A, 0x05, 0x19, 0x09, 0x63, 0x95, +/* 0EF0 */ 0x05, 0x19, 0x53, 0x08, 0x77, 0x38, 0x3C, 0x92, 0x3B, 0x01, 0x10, 0x03, 0x30, 0x3C, 0x4E, 0x3A, +/* 0F00 */ 0x5B, 0x10, 0x05, 0x49, 0x46, 0x1C, 0x6C, 0xC1, 0x09, 0x95, 0x27, 0x09, 0x08, 0x09, 0x08, 0xC7, +/* 0F10 */ 0x7B, 0x00, 0x26, 0x01, 0x10, 0x05, 0x1F, 0x68, 0xC7, 0xC2, 0xC7, 0x52, 0x20, 0xC1, 0x90, 0x5E, +/* 0F20 */ 0x6B, 0x5B, 0x9E, 0x10, 0x04, 0x30, 0xDB, 0x3F, 0x05, 0x0F, 0x1B, 0x58, 0x18, 0x03, 0x62, 0x01, +/* 0F30 */ 0x00, 0x57, 0x9F, 0x10, 0x04, 0x49, 0xC4, 0x32, 0x18, 0x03, 0x05, 0x0F, 0x1B, 0x86, 0x26, 0x03, +/* 0F40 */ 0x7A, 0x00, 0x6D, 0x32, 0x01, 0x10, 0x03, 0xDC, 0x02, 0x74, 0x27, 0x34, 0x07, 0x01, 0x10, 0x05, +/* 0F50 */ 0x2E, 0x4B, 0xB2, 0x4B, 0xB2, 0x4B, 0xB2, 0x4B, 0xB2, 0x07, 0x4A, 0x85, 0x22, 0x0E, 0x0D, 0x87, +/* 0F60 */ 0x22, 0x0D, 0x71, 0x31, 0x0F, 0x46, 0x03, 0x10, 0x07, 0x30, 0xC1, 0x0E, 0x75, 0x76, 0x04, 0x75, +/* 0F70 */ 0x6F, 0x76, 0x06, 0x75, 0x99, 0x76, 0x03, 0x75, 0x99, 0x76, 0x34, 0x0B, 0x0F, 0x99, 0x48, 0xC3, +/* 0F80 */ 0xC3, 0xC3, 0xC3, 0x04, 0x7C, 0x7C, 0x10, 0x02, 0x18, 0x68, 0x2B, 0x5C, 0x6A, 0x10, 0x03, 0x2E, +/* 0F90 */ 0x45, 0x01, 0x0D, 0x52, 0x01, 0x09, 0x0A, 0x27, 0xC1, 0x50, 0x46, 0x10, 0x04, 0xE6, 0x64, 0x6D, +/* 0FA0 */ 0xE1, 0x53, 0x1F, 0x6D, 0x5C, 0x53, 0x10, 0x05, 0x68, 0x46, 0x0C, 0x61, 0x27, 0x77, 0x6F, 0x38, +/* 0FB0 */ 0x8B, 0x63, 0x48, 0x80, 0x40, 0x00, 0x26, 0x1B, 0x9B, 0x02, 0x42, 0x0A, 0x90, 0x88, 0x10, 0x06, +/* 0FC0 */ 0x2E, 0x01, 0x04, 0x34, 0x6C, 0x7D, 0x6E, 0x23, 0x9D, 0x81, 0x5E, 0x25, 0x0A, 0x0E, 0x65, 0xCF, +/* 0FD0 */ 0x5E, 0x98, 0x01, 0xCF, 0x08, 0x00, 0x09, 0x02, 0x10, 0x09, 0xE6, 0xD3, 0x53, 0xBD, 0x08, 0x06, +/* 0FE0 */ 0x76, 0x53, 0x01, 0x7B, 0x7B, 0x22, 0x09, 0x58, 0xBC, 0x10, 0x09, 0xE6, 0xD3, 0x53, 0xBD, 0x77, +/* 0FF0 */ 0x56, 0x64, 0x53, 0x01, 0x7C, 0x7E, 0x06, 0x33, 0x09, 0x72, 0x0D, 0x01, 0x64, 0x71, 0x7B, 0x01, +/* 1000 */ 0x8D, 0x02, 0x1F, 0x9A, 0x34, 0x0F, 0x92, 0x64, 0x8F, 0x03, 0x10, 0x09, 0x30, 0xDB, 0xD3, 0x03, +/* 1010 */ 0x05, 0x4E, 0x00, 0x95, 0x19, 0x86, 0x02, 0x54, 0x64, 0x71, 0x03, 0x7A, 0x09, 0x08, 0x06, 0x03, +/* 1020 */ 0x64, 0x06, 0x32, 0x02, 0x7B, 0x7B, 0x22, 0x09, 0x58, 0xBC, 0x10, 0x04, 0x2E, 0x79, 0x0E, 0x1B, +/* 1030 */ 0x03, 0x56, 0x37, 0xC4, 0x4E, 0x3A, 0x1C, 0x18, 0x96, 0x52, 0x87, 0x53, 0x6C, 0x04, 0x0D, 0x24, +/* 1040 */ 0x10, 0x05, 0x27, 0x26, 0x03, 0xC4, 0x61, 0xC5, 0x0F, 0x18, 0x1E, 0x3E, 0xA2, 0x10, 0x05, 0x18, +/* 1050 */ 0x26, 0x2A, 0x03, 0x9C, 0x59, 0xC6, 0xA2, 0x10, 0x05, 0x1A, 0x03, 0x24, 0x18, 0x0B, 0x53, 0x04, +/* 1060 */ 0x25, 0x34, 0xC6, 0xA2, 0x10, 0x05, 0x1A, 0x47, 0x21, 0x5B, 0x42, 0x34, 0xC6, 0xA2, 0x10, 0x05, +/* 1070 */ 0x1A, 0x8E, 0x0C, 0x06, 0x3A, 0x71, 0x27, 0x34, 0xC6, 0xA2, 0x10, 0x05, 0x64, 0x80, 0x4C, 0xC1, +/* 1080 */ 0x1E, 0xC5, 0x0B, 0xC5, 0x0D, 0x18, 0x1E, 0x3E, 0xA2, 0x10, 0x08, 0x68, 0x0E, 0xF3, 0x19, 0x99, +/* 1090 */ 0x44, 0x5B, 0x19, 0x35, 0x0A, 0x0A, 0x27, 0xA0, 0x8B, 0x6B, 0x4A, 0x07, 0x90, 0xF5, 0x8F, 0x75, +/* 10A0 */ 0x4E, 0x19, 0x0B, 0x84, 0x05, 0x4A, 0x9E, 0x71, 0x55, 0x71, 0x90, 0x4A, 0x10, 0x05, 0x28, 0x73, +/* 10B0 */ 0xD0, 0xA1, 0x02, 0x55, 0x04, 0x07, 0x27, 0x73, 0x70, 0x01, 0x27, 0x53, 0x52, 0x0C, 0x5E, 0x18, +/* 10C0 */ 0x9B, 0x10, 0x05, 0x19, 0x46, 0x1B, 0xC1, 0x89, 0x31, 0xCA, 0xCD, 0x10, 0x05, 0x25, 0x46, 0x1B, +/* 10D0 */ 0x06, 0x61, 0x31, 0xCA, 0xCD, 0x10, 0x05, 0x18, 0x6D, 0x4A, 0x26, 0x0C, 0x58, 0x01, 0x22, 0xCA, +/* 10E0 */ 0xCD, 0x10, 0x05, 0x1F, 0x46, 0x7B, 0x7C, 0xD7, 0x31, 0xCA, 0xCD, 0x10, 0x03, 0x2F, 0x9E, 0x00, +/* 10F0 */ 0xE8, 0x8E, 0x64, 0xB3, 0x64, 0xD2, 0xAD, 0x10, 0x03, 0x1A, 0x9E, 0x27, 0xC1, 0x89, 0x18, 0x0B, +/* 1100 */ 0xBF, 0xAD, 0x10, 0x03, 0x2F, 0x09, 0x9F, 0x27, 0x03, 0x0B, 0x58, 0x51, 0xAD, 0x10, 0x03, 0x64, +/* 1110 */ 0xC4, 0x84, 0x54, 0xD7, 0x51, 0xAD, 0x10, 0x06, 0x30, 0x04, 0x90, 0x8D, 0x00, 0xCF, 0x92, 0x08, +/* 1120 */ 0x5E, 0xCF, 0x5E, 0x00, 0x44, 0x1F, 0x34, 0x5E, 0x00, 0x9C, 0x19, 0x43, 0x4A, 0x1C, 0x19, 0x06, +/* 1130 */ 0x92, 0x01, 0x70, 0xCF, 0x92, 0x09, 0x5E, 0xCF, 0x90, 0x4F, 0x10, 0x06, 0x1A, 0x63, 0x92, 0x3A, +/* 1140 */ 0x5B, 0x31, 0x70, 0xB8, 0x43, 0x80, 0xAE, 0xBA, 0x10, 0x06, 0x27, 0x3F, 0x37, 0x1C, 0x42, 0x7D, +/* 1150 */ 0x40, 0x6B, 0x55, 0xA4, 0xB0, 0x10, 0x06, 0x18, 0x3F, 0x00, 0xE8, 0x0E, 0x21, 0x6F, 0x55, 0x6B, +/* 1160 */ 0x55, 0xA4, 0xB0, 0x10, 0x06, 0x00, 0x1A, 0x96, 0x42, 0x06, 0x09, 0x07, 0x0A, 0x27, 0xA9, 0xA4, +/* 1170 */ 0xB0, 0x10, 0x06, 0x1A, 0x80, 0x55, 0x3A, 0x03, 0x2A, 0xA9, 0xA4, 0xB0, 0x10, 0x06, 0x1A, 0xE4, +/* 1180 */ 0x27, 0xA9, 0xA4, 0xB0, 0x10, 0x05, 0x45, 0x79, 0x0B, 0x8C, 0x6C, 0x01, 0x0C, 0x55, 0x26, 0x8A, +/* 1190 */ 0x2C, 0x79, 0x09, 0x02, 0x0B, 0x01, 0x10, 0x06, 0x64, 0x1A, 0x9B, 0xC4, 0x0E, 0x27, 0x7D, 0xEA, +/* 11A0 */ 0x6B, 0x0F, 0x8B, 0x50, 0x19, 0x78, 0x7F, 0x0D, 0x19, 0x0A, 0x7B, 0x0A, 0x3C, 0x19, 0x0A, 0x62, +/* 11B0 */ 0x9A, 0x0E, 0x1F, 0xC1, 0x55, 0x03, 0x98, 0x19, 0x99, 0x62, 0x92, 0x25, 0x09, 0x3D, 0x4C, 0x09, +/* 11C0 */ 0x0A, 0x20, 0x9B, 0x10, 0x06, 0x27, 0x3F, 0x46, 0x85, 0x6C, 0x78, 0x08, 0x92, 0xAC, 0x10, 0x06, +/* 11D0 */ 0x18, 0x3F, 0x3B, 0x87, 0x6C, 0x08, 0x5E, 0x65, 0xAC, 0x10, 0x06, 0x27, 0x26, 0x1C, 0x6C, 0xC1, +/* 11E0 */ 0x07, 0x09, 0x07, 0x25, 0x78, 0x65, 0xAC, 0x10, 0x06, 0x1A, 0x5A, 0x09, 0x09, 0x26, 0x01, 0x01, +/* 11F0 */ 0x6C, 0x78, 0x65, 0xAC, 0x10, 0x05, 0x18, 0x26, 0x03, 0x3F, 0x9C, 0x25, 0x9D, 0x7C, 0x05, 0x5E, +/* 1200 */ 0x19, 0xD5, 0xB9, 0x50, 0x10, 0x05, 0x2B, 0xBF, 0x59, 0x90, 0x4F, 0xB3, 0x0B, 0x4E, 0x33, 0x4E, +/* 1210 */ 0xC8, 0x05, 0x01, 0x10, 0x06, 0x28, 0x0A, 0x32, 0x48, 0x05, 0x92, 0x61, 0xD2, 0x7A, 0x22, 0x0F, +/* 1220 */ 0x35, 0x31, 0x0F, 0x63, 0x2C, 0x4B, 0x07, 0x9F, 0x33, 0x4E, 0x07, 0x9F, 0x33, 0x4A, 0x44, 0x10, +/* 1230 */ 0x05, 0x91, 0x71, 0x37, 0x35, 0x76, 0x6D, 0x07, 0x27, 0xE3, 0xA8, 0x10, 0x05, 0x49, 0x01, 0x01, +/* 1240 */ 0x3F, 0x8D, 0x59, 0x05, 0x18, 0xE3, 0xA8, 0x10, 0x05, 0x25, 0x1A, 0xB3, 0x26, 0x0C, 0x73, 0x52, +/* 1250 */ 0x20, 0xE3, 0xA8, 0x10, 0x05, 0x28, 0x0C, 0xEA, 0x26, 0x03, 0x9E, 0x27, 0xE3, 0xA8, 0x10, 0x05, +/* 1260 */ 0x30, 0x03, 0x7C, 0x7B, 0xD7, 0x27, 0xE3, 0xA8, 0x10, 0x05, 0x19, 0x67, 0x62, 0x18, 0x0C, 0x08, +/* 1270 */ 0x0B, 0x18, 0x09, 0x92, 0x20, 0x1B, 0xE3, 0xA8, 0x10, 0x08, 0x2E, 0x6E, 0x24, 0x0B, 0x24, 0x64, +/* 1280 */ 0x71, 0x05, 0x05, 0x5D, 0x05, 0x5E, 0x64, 0x8C, 0xF3, 0x92, 0x64, 0x0A, 0x7A, 0x44, 0x03, 0x9E, +/* 1290 */ 0x64, 0x96, 0x6F, 0x8E, 0x08, 0x1F, 0xDB, 0x04, 0x0B, 0x85, 0x01, 0x10, 0x04, 0xB7, 0x64, 0xB3, +/* 12A0 */ 0x05, 0xE8, 0xEA, 0x1B, 0x7A, 0x20, 0x73, 0xC5, 0x0A, 0x46, 0x10, 0x05, 0xDC, 0x00, 0x06, 0x81, +/* 12B0 */ 0xC4, 0x08, 0xE8, 0xC0, 0xD9, 0x10, 0x05, 0x49, 0xE2, 0x64, 0x0A, 0xC0, 0xD9, 0x10, 0x05, 0x91, +/* 12C0 */ 0x34, 0xD8, 0x64, 0xE8, 0xC0, 0xD9, 0x10, 0x05, 0x49, 0x46, 0x7C, 0x7A, 0xD7, 0xE8, 0xC0, 0xD9, +/* 12D0 */ 0x10, 0x03, 0x91, 0x01, 0x37, 0x74, 0x42, 0x71, 0x07, 0x05, 0x59, 0xAB, 0x10, 0x03, 0x91, 0x71, +/* 12E0 */ 0xC4, 0x7A, 0x18, 0x09, 0x04, 0x67, 0xAB, 0x10, 0x03, 0x91, 0x1E, 0x48, 0x79, 0x0B, 0x7E, 0x37, +/* 12F0 */ 0x67, 0xAB, 0x10, 0x03, 0x18, 0x49, 0x7E, 0x04, 0x60, 0x26, 0x72, 0x59, 0xAB, 0x10, 0x05, 0x49, +/* 1300 */ 0x9B, 0x3A, 0x0D, 0xE7, 0x0C, 0x5D, 0x01, 0x27, 0x5B, 0x50, 0x19, 0x71, 0x83, 0x32, 0x57, 0x04, +/* 1310 */ 0x83, 0x25, 0x0A, 0x0D, 0x00, 0x1E, 0x57, 0x05, 0xB2, 0x01, 0x0B, 0x5D, 0x02, 0x10, 0x05, 0x28, +/* 1320 */ 0x47, 0x42, 0x03, 0x82, 0x31, 0x44, 0x62, 0x22, 0x92, 0x9C, 0xD1, 0xD1, 0xD1, 0xD1, 0x10, 0x05, +/* 1330 */ 0xDC, 0x34, 0x62, 0x00, 0x3F, 0x5F, 0xA7, 0x10, 0x05, 0x49, 0x71, 0x3B, 0x0B, 0x0A, 0x27, 0x34, +/* 1340 */ 0x07, 0x52, 0xA7, 0x10, 0x05, 0x00, 0x91, 0x63, 0x5F, 0x0C, 0x58, 0x48, 0x2F, 0xA7, 0x10, 0x05, +/* 1350 */ 0x28, 0x47, 0x42, 0x5B, 0x1B, 0xA7, 0x10, 0x05, 0x30, 0x01, 0x7C, 0x81, 0xD7, 0x18, 0xA7, 0x10, +/* 1360 */ 0x05, 0x37, 0x68, 0xDE, 0x19, 0x1A, 0xA3, 0x27, 0xDE, 0x10, 0x05, 0x68, 0x72, 0x37, 0x7A, 0x27, +/* 1370 */ 0x1E, 0x88, 0x6D, 0x61, 0x32, 0x25, 0x0A, 0x0B, 0x08, 0x09, 0x0F, 0x25, 0x0A, 0x74, 0x6F, 0x22, +/* 1380 */ 0x85, 0x98, 0x19, 0x71, 0x0D, 0x5D, 0x42, 0x7A, 0x46, 0x10, 0x05, 0xDC, 0x00, 0x06, 0x8E, 0xC4, +/* 1390 */ 0x08, 0x00, 0x57, 0xBE, 0xB4, 0x10, 0x05, 0x49, 0xE2, 0x00, 0x41, 0xBE, 0xB4, 0x10, 0x05, 0x91, +/* 13A0 */ 0x34, 0xD8, 0x1F, 0x57, 0xBE, 0xB4, 0x10, 0x05, 0x49, 0x46, 0x7C, 0x7A, 0xD7, 0x00, 0x57, 0xBE, +/* 13B0 */ 0xB4, 0x10, 0x05, 0xDC, 0x34, 0x89, 0x27, 0xC1, 0x05, 0x18, 0xDD, 0xB6, 0x10, 0x05, 0xCC, 0xBB, +/* 13C0 */ 0x40, 0xE9, 0x10, 0x05, 0x30, 0x04, 0x84, 0x54, 0xD7, 0x27, 0xDD, 0xB6, 0x10, 0x00, 0x00, 0x00, +/* 13D0 */ 0x0B, 0x00, 0x15, 0x00, 0x0B, 0x05, 0x2F, 0x45, 0x0D, 0x90, 0x3D, 0x25, 0x03, 0x5B, 0x5B, 0x10, +/* 13E0 */ 0x05, 0x2F, 0x45, 0x0C, 0x90, 0x50, 0x6B, 0x5B, 0x82, 0x10, 0x07, 0x2F, 0x45, 0x0C, 0x0F, 0xF3, +/* 13F0 */ 0x36, 0x00, 0x72, 0x5B, 0x5B, 0x5B, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, +/* 1400 */ 0x00, 0x05, 0x2D, 0x00, 0x00, 0x05, 0x2F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, +/* 1410 */ 0x00, 0x05, 0x32, 0x00, 0x00, 0x05, 0xF0, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, +/* 1420 */ 0x00, 0x0C, 0xF4, 0x00, 0x00, 0x0D, 0xB4, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, +/* 1430 */ 0x00, 0x13, 0xCD, 0x00, 0x00, 0x13, 0xD5, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold12.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold12.mcufont.h new file mode 100644 index 000000000..7a15c47c5 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold12.mcufont.h @@ -0,0 +1,409 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 12 + * blob size: 6180, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0x87, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00, 0x00, 0x90, +/* 0020 */ 0x00, 0x00, 0x00, 0xDA, 0x00, 0x00, 0x17, 0xE4, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0C, 0x00, 0x11, 0x00, 0x03, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x32, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x31, 0x32, 0x00, +/* dictionary data */ +0x40, 0x15, 0x07, 0x27, 0x0F, 0x09, 0x25, 0xC6, 0x02, 0x02, 0x40, +/* 0080 */ 0x09, 0xC5, 0x09, 0xC2, 0x09, 0xC1, 0xC3, 0xC1, 0xC8, 0x31, 0x08, 0xC4, 0x04, 0x80, 0xC4, 0xCE, +/* 0090 */ 0xCC, 0x1A, 0xC5, 0x80, 0xC9, 0x01, 0x05, 0x06, 0xC9, 0xC6, 0x80, 0xC9, 0xC1, 0x08, 0xC2, 0x07, +/* 00A0 */ 0xC1, 0x07, 0xC3, 0xCD, 0x0A, 0xC5, 0x06, 0x0D, 0x07, 0xC7, 0x80, 0x06, 0x06, 0xC4, 0x01, 0xCE, +/* 00B0 */ 0xC1, 0x81, 0xC5, 0x82, 0x07, 0xC9, 0x80, 0xC3, 0x80, 0xC2, 0x06, 0xC3, 0xC1, 0xCA, 0xCB, 0xCE, +/* 00C0 */ 0x08, 0xCA, 0xC1, 0x08, 0xC5, 0x81, 0x40, 0x0A, 0xC2, 0x80, 0xCB, 0xC7, 0xCC, 0xC3, 0x80, 0xC6, +/* 00D0 */ 0x80, 0xC6, 0xC4, 0xCC, 0x80, 0x01, 0xCD, 0x80, 0xC8, 0x01, 0xC1, 0xC6, 0xCD, 0xCE, 0xD7, 0xC2, +/* 00E0 */ 0x03, 0xCB, 0x80, 0xC8, 0x80, 0xC4, 0x09, 0xC9, 0x05, 0x06, 0xC8, 0x80, 0xCE, 0xCB, 0xC1, 0xCE, +/* 00F0 */ 0x08, 0xC5, 0x80, 0xC9, 0x09, 0xF5, 0x06, 0xC5, 0x03, 0x80, 0xCD, 0xD5, 0xC3, 0x09, 0xC2, 0xC1, +/* 0100 */ 0x02, 0xC3, 0xC1, 0xD2, 0xDD, 0xC8, 0x80, 0xCA, 0x07, 0xD2, 0x03, 0xC3, 0x01, 0xCA, 0x01, 0xC5, +/* 0110 */ 0xCD, 0xCC, 0x80, 0xC6, 0xCE, 0x06, 0xC9, 0x80, 0xC4, 0xCC, 0xCE, 0xC1, 0xC5, 0xC2, 0x08, 0xCD, +/* 0120 */ 0xCE, 0x01, 0xCC, 0x80, 0xC7, 0x80, 0xC1, 0x05, 0x09, 0xC1, 0x80, 0xCB, 0xC1, 0x06, 0xCC, 0xC6, +/* 0130 */ 0xC6, 0x80, 0xC8, 0x05, 0xC7, 0x80, 0xC7, 0x01, 0xC8, 0xCD, 0xC1, 0x01, 0xC6, 0x80, 0x01, 0xC3, +/* 0140 */ 0xCD, 0x80, 0xC5, 0xCD, 0xC2, 0xCE, 0xCE, 0xCD, 0x80, 0xC5, 0xC9, 0xCC, 0x05, 0xC5, 0x80, 0xC9, +/* 0150 */ 0xC3, 0xC3, 0xC1, 0xC7, 0xCE, 0xCA, 0x80, 0xCE, 0xCA, 0x80, 0xC1, 0xCC, 0xCD, 0x82, 0xC2, 0xCC, +/* 0160 */ 0xC7, 0x07, 0xC7, 0x80, 0xC8, 0xCE, 0xCE, 0xC4, 0xD9, 0x80, 0xCA, 0xC6, 0xCE, 0xCA, 0xC4, 0xCE, +/* 0170 */ 0xC9, 0x01, 0xC7, 0x01, 0xC6, 0xCD, 0xC9, 0x32, 0xC6, 0x80, 0xC7, 0xC9, 0xCB, 0x80, 0xCC, 0xC4, +/* 0180 */ 0xCC, 0x80, 0xC9, 0x01, 0xC8, 0x01, 0xC2, 0xC2, 0xCB, 0x80, 0xC5, 0xCE, 0xC8, 0xCB, 0xC9, 0x80, +/* 0190 */ 0xC5, 0x80, 0xCB, 0x80, 0xCE, 0xDC, 0xCE, 0xC8, 0x2B, 0x57, 0x2B, 0x57, 0x03, 0x37, 0x7A, 0x87, +/* 01A0 */ 0x91, 0x37, 0x76, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47, +/* 01B0 */ 0x72, 0x5B, 0x72, 0x5B, 0x1C, 0x85, 0x5D, 0x52, 0xA1, 0x1C, 0x9E, 0x08, 0x00, 0x31, 0x28, 0x37, +/* 01C0 */ 0xA4, 0x07, 0x07, 0x74, 0x2B, 0x44, 0x9D, 0x02, 0x30, 0x3B, 0x0D, 0x19, 0xA4, 0x05, 0x04, 0x19, +/* 01D0 */ 0x2B, 0x42, 0xA4, 0x50, 0x5A, 0x3B, 0x80, 0x19, 0x1A, 0x02, 0x41, 0xA7, 0x19, 0x40, 0x07, 0x0D, +/* 01E0 */ 0x3D, 0x19, 0x4E, 0xA3, 0x34, 0x8B, 0x8A, 0x34, 0x0A, 0x4D, 0x86, 0x34, 0x86, 0x81, 0x70, 0x3F, +/* 01F0 */ 0x6E, 0x06, 0x9D, 0x5A, 0x99, 0x04, 0x4D, 0x00, 0x3F, 0x73, 0xA3, 0x34, 0x08, 0x80, 0x03, 0x91, +/* 0200 */ 0x2D, 0x8A, 0x9B, 0x54, 0x08, 0x5C, 0x04, 0x3F, 0x9B, 0x07, 0x0B, 0x30, 0x06, 0x0D, 0x9D, 0x37, +/* 0210 */ 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x59, 0x91, 0x86, 0x53, 0x4E, +/* 0220 */ 0x0C, 0xA7, 0x01, 0x7C, 0xA2, 0x4D, 0x2C, 0x2E, 0x00, 0x4F, 0x43, 0x3F, 0x9B, 0xA3, 0x53, 0x9E, +/* 0230 */ 0x80, 0x39, 0x6A, 0x4C, 0x71, 0x08, 0x80, 0x39, 0x0E, 0x3F, 0x9B, 0x09, 0x9D, 0x19, 0x4F, 0x43, +/* 0240 */ 0x52, 0x85, 0x5D, 0x03, 0x02, 0x4D, 0x82, 0x70, 0x02, 0x4D, 0x82, 0x0D, 0x0B, 0x02, 0x4D, 0x2C, +/* 0250 */ 0xA4, 0x3D, 0x4D, 0x82, 0x07, 0x70, 0x4D, 0x82, 0x7D, 0x0B, 0x4D, 0x82, 0x05, 0x09, 0x0E, 0x4D, +/* 0260 */ 0x82, 0x5C, 0x0F, 0x4D, 0x82, 0x05, 0x3A, 0x08, 0x9B, 0x03, 0x4D, 0x19, 0xA3, 0x86, 0x30, 0x49, +/* 0270 */ 0x73, 0x1C, 0x4B, 0x21, 0x51, 0x5D, 0x51, 0x5D, 0x0B, 0x3D, 0x0B, 0x5E, 0x54, 0x45, 0x28, 0x2C, +/* 0280 */ 0x9F, 0x05, 0x55, 0x05, 0x31, 0x4C, 0x33, 0x61, 0x33, 0x61, 0x33, 0x61, 0x33, 0x61, 0x33, 0x07, +/* 0290 */ 0x00, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x2C, 0x76, 0x95, 0x70, +/* 02A0 */ 0x27, 0x9F, 0xA5, 0x8E, 0x3D, 0x59, 0x0C, 0x5B, 0x34, 0x33, 0x0E, 0x7B, 0x91, 0x37, 0x0B, 0x88, +/* 02B0 */ 0x06, 0x69, 0x2C, 0x95, 0x28, 0x09, 0x3E, 0x3F, 0x69, 0x0B, 0x62, 0x1E, 0x01, 0x27, 0x48, 0x95, +/* 02C0 */ 0x45, 0x69, 0x5A, 0x39, 0x05, 0x9F, 0x05, 0x8E, 0x02, 0x65, 0x0C, 0x19, 0x1C, 0x99, 0x1C, 0x99, +/* 02D0 */ 0x55, 0x22, 0x0A, 0x42, 0x00, 0x04, 0x49, 0x8C, 0x0B, 0x0D, 0x0A, 0x02, 0x26, 0x7F, 0x04, 0x19, +/* 02E0 */ 0x4E, 0x21, 0x1F, 0x04, 0x0A, 0x06, 0x01, 0xA5, 0x2C, 0xA3, 0x1E, 0x0D, 0x3E, 0x27, 0xA3, 0x1E, +/* 02F0 */ 0x0C, 0x3D, 0x27, 0xA3, 0x1E, 0x0D, 0x88, 0x27, 0x2E, 0x4E, 0xA5, 0x2C, 0x56, 0x0F, 0xA2, 0x70, +/* 0300 */ 0x3F, 0x51, 0xA7, 0x42, 0x79, 0x2F, 0x62, 0x7E, 0x63, 0x23, 0x7B, 0x5A, 0x4E, 0x08, 0x80, 0x19, +/* 0310 */ 0x60, 0x64, 0x1C, 0x86, 0x03, 0x08, 0x21, 0x99, 0x1C, 0x99, 0x42, 0x96, 0x91, 0x40, 0x28, 0x1F, +/* 0320 */ 0x9C, 0x5A, 0x67, 0x0A, 0x28, 0x1F, 0x0B, 0x53, 0x01, 0x28, 0x00, 0x19, 0x84, 0x23, 0x27, 0x1B, +/* 0330 */ 0x0E, 0x1C, 0x39, 0x2A, 0x01, 0x1F, 0x31, 0x2A, 0x02, 0x33, 0x99, 0x1C, 0xA1, 0x06, 0x37, 0x1B, +/* 0340 */ 0x99, 0x5A, 0x3F, 0x05, 0x45, 0x02, 0x9E, 0x69, 0x77, 0x6D, 0x0B, 0x0C, 0x0A, 0x0D, 0x79, 0x04, +/* 0350 */ 0x37, 0x7A, 0xA7, 0x9B, 0x37, 0x99, 0x4C, 0x71, 0x99, 0x6F, 0x3E, 0x2C, 0x99, 0x4C, 0x71, 0x7A, +/* 0360 */ 0x97, 0x73, 0x2C, 0x96, 0x73, 0x7F, 0x03, 0x37, 0x99, 0x1C, 0x99, 0x42, 0x2C, 0x2B, 0x09, 0xA5, +/* 0370 */ 0x54, 0x06, 0x39, 0x6A, 0x39, 0x0E, 0x54, 0x05, 0x39, 0x0E, 0x38, 0x9B, 0x09, 0xA5, 0x0E, 0x01, +/* 0380 */ 0x2C, 0x03, 0x9D, 0x37, 0x99, 0x09, 0x88, 0x5D, 0x62, 0x5D, 0x62, 0x5D, 0x62, 0x5D, 0x37, 0x4E, +/* 0390 */ 0x01, 0x33, 0x33, 0xA5, 0x33, 0xA5, 0x33, 0xA5, 0x73, 0x42, 0x9B, 0x37, 0x2F, 0x66, 0x88, 0x06, +/* 03A0 */ 0x80, 0x08, 0x26, 0x0F, 0x9B, 0x1F, 0x54, 0x86, 0x31, 0x0B, 0x0D, 0x06, 0x28, 0x2C, 0x4E, 0x73, +/* 03B0 */ 0x04, 0x4D, 0x38, 0x0F, 0x83, 0x9B, 0x54, 0x8A, 0x71, 0x0B, 0x69, 0x05, 0x0B, 0x28, 0x2C, 0xA5, +/* 03C0 */ 0x00, 0x95, 0x4D, 0x37, 0x1F, 0x3F, 0x37, 0x7A, 0xA0, 0xA7, 0x37, 0x0D, 0x0A, 0x03, 0x37, 0xA4, +/* 03D0 */ 0x37, 0x8D, 0x09, 0x28, 0x1F, 0x3C, 0x28, 0x1C, 0xA3, 0x04, 0x31, 0x0B, 0x8A, 0x07, 0x3D, 0x1E, +/* 03E0 */ 0x36, 0x1E, 0x36, 0x02, 0x0D, 0x08, 0x8A, 0x0D, 0x42, 0x94, 0x94, 0x42, 0x41, 0x69, 0x19, 0x95, +/* 03F0 */ 0x45, 0x30, 0x4E, 0x61, 0x42, 0x9C, 0x69, 0x19, 0x95, 0x0D, 0x07, 0x5A, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, +/* 0400 */ 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0C, +/* 0410 */ 0x00, 0x0E, 0x00, 0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x15, 0x00, 0x17, 0x00, 0x18, 0x00, 0x1A, +/* 0420 */ 0x00, 0x1C, 0x00, 0x1D, 0x00, 0x21, 0x00, 0x22, 0x00, 0x24, 0x00, 0x27, 0x00, 0x29, 0x00, 0x2B, +/* 0430 */ 0x00, 0x2D, 0x00, 0x2F, 0x00, 0x30, 0x00, 0x32, 0x00, 0x33, 0x00, 0x36, 0x00, 0x37, 0x00, 0x39, +/* 0440 */ 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x41, 0x00, 0x43, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49, +/* 0450 */ 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4E, 0x00, 0x50, 0x00, 0x51, 0x00, 0x53, 0x00, 0x56, 0x00, 0x58, +/* 0460 */ 0x00, 0x5A, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x64, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6C, +/* 0470 */ 0x00, 0x6E, 0x00, 0x72, 0x00, 0x74, 0x00, 0x77, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x80, 0x00, 0x81, +/* 0480 */ 0x00, 0x83, 0x00, 0x84, 0x00, 0x86, 0x00, 0x87, 0x00, 0x89, 0x00, 0x8B, 0x00, 0x8D, 0x00, 0x8F, +/* 0490 */ 0x00, 0x90, 0x00, 0x92, 0x00, 0x94, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D, +/* 04A0 */ 0x00, 0x9F, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xB0, +/* 04B0 */ 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBB, 0x00, 0xBE, 0x00, 0xC3, 0x00, 0xC5, +/* 04C0 */ 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5, +/* 04D0 */ 0x00, 0xD7, 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xDE, 0x00, 0xE0, 0x00, 0xE2, 0x00, 0xE4, 0x00, 0xE6, +/* 04E0 */ 0x00, 0xE8, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF4, +/* 04F0 */ 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01, 0x02, 0x01, 0x03, +/* 0500 */ 0x01, 0x06, 0x01, 0x08, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x15, +/* 0510 */ 0x01, 0x17, 0x01, 0x19, 0x01, 0x1B, 0x01, 0x1E, 0x01, 0x20, 0x01, 0x21, 0x01, 0x23, 0x01, 0x27, +/* 0520 */ 0x01, 0x3B, 0x01, 0x3F, 0x01, 0x47, 0x01, 0x49, 0x01, 0x64, 0x01, 0x7D, 0x01, 0x82, 0x01, 0x99, +/* 0530 */ 0x01, 0xAD, 0x01, 0xB4, 0x01, 0xCB, 0x01, 0xCE, 0x01, 0xF3, 0x02, 0x05, 0x02, 0x11, 0x02, 0x1A, +/* 0540 */ 0x02, 0x35, 0x02, 0x45, 0x02, 0x47, 0x02, 0x57, 0x02, 0x5B, 0x02, 0x5D, 0x02, 0x5F, 0x02, 0x61, +/* 0550 */ 0x02, 0x65, 0x02, 0x6D, 0x02, 0x6F, 0x02, 0x71, 0x02, 0x8F, 0x02, 0x96, 0x02, 0x98, 0x02, 0x9B, +/* 0560 */ 0x02, 0x9D, 0x02, 0x9F, 0x02, 0xA8, 0x02, 0xB6, 0x02, 0xBB, 0x02, 0xBE, 0x02, 0xC2, 0x02, 0xCC, +/* 0570 */ 0x02, 0xCE, 0x02, 0xD0, 0x02, 0xD4, 0x02, 0xDA, 0x02, 0xF7, 0x02, 0xF9, 0x03, 0x09, 0x03, 0x0C, +/* 0580 */ 0x03, 0x10, 0x03, 0x12, 0x03, 0x19, 0x03, 0x1B, 0x03, 0x1D, 0x03, 0x23, 0x03, 0x25, 0x03, 0x27, +/* 0590 */ 0x03, 0x2A, 0x03, 0x2C, 0x03, 0x4F, 0x03, 0x51, 0x03, 0x53, 0x03, 0x56, 0x03, 0x58, 0x03, 0x5B, +/* 05A0 */ 0x03, 0x5D, 0x03, 0x64, 0x03, 0x66, 0x03, 0x68, 0x03, 0x6A, 0x03, 0x6E, 0x03, 0x70, 0x03, 0x72, +/* 05B0 */ 0x03, 0x87, +/* char range info */ +0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x15, 0x00, 0x28, 0x00, +/* 05C0 */ 0x4A, 0x00, 0x72, 0x00, 0xAE, 0x00, 0xD9, 0x00, 0xE4, 0x01, 0x02, 0x01, 0x20, 0x01, 0x34, 0x01, +/* 05D0 */ 0x3D, 0x01, 0x42, 0x01, 0x4C, 0x01, 0x52, 0x01, 0x70, 0x01, 0x95, 0x01, 0xA9, 0x01, 0xCA, 0x01, +/* 05E0 */ 0xEA, 0x02, 0x07, 0x02, 0x28, 0x02, 0x4D, 0x02, 0x69, 0x02, 0x8D, 0x02, 0xB0, 0x02, 0xB8, 0x02, +/* 05F0 */ 0xBF, 0x02, 0xD6, 0x02, 0xE9, 0x03, 0x01, 0x03, 0x1B, 0x03, 0x66, 0x03, 0x6B, 0x03, 0x8A, 0x03, +/* 0600 */ 0xAB, 0x03, 0xCC, 0x03, 0xD1, 0x03, 0xE9, 0x04, 0x11, 0x04, 0x30, 0x04, 0x36, 0x04, 0x45, 0x04, +/* 0610 */ 0x66, 0x04, 0x74, 0x04, 0xAC, 0x04, 0xB1, 0x04, 0xB7, 0x04, 0xD2, 0x04, 0xFC, 0x05, 0x1F, 0x05, +/* 0620 */ 0x41, 0x05, 0x50, 0x05, 0x55, 0x05, 0x7B, 0x05, 0xB3, 0x05, 0xD6, 0x05, 0xDF, 0x05, 0xFF, 0x06, +/* 0630 */ 0x1A, 0x06, 0x39, 0x06, 0x51, 0x06, 0x62, 0x06, 0x71, 0x06, 0x7D, 0x06, 0x82, 0x06, 0x9B, 0x06, +/* 0640 */ 0xB2, 0x06, 0xC6, 0x06, 0xCD, 0x06, 0xE9, 0x07, 0x18, 0x07, 0x23, 0x07, 0x29, 0x07, 0x36, 0x07, +/* 0650 */ 0x55, 0x07, 0x66, 0x07, 0x82, 0x07, 0x88, 0x07, 0x8C, 0x07, 0x95, 0x07, 0xA7, 0x07, 0xB5, 0x07, +/* 0660 */ 0xD0, 0x07, 0xED, 0x07, 0xF3, 0x08, 0x0F, 0x08, 0x37, 0x08, 0x52, 0x08, 0x58, 0x08, 0x71, 0x08, +/* 0670 */ 0x94, 0x08, 0x9E, 0x08, 0xBF, 0x03, 0x00, 0x10, 0x03, 0x25, 0xA3, 0x21, 0x52, 0x52, 0xED, 0x5A, +/* 0680 */ 0xE5, 0x6D, 0x96, 0x3E, 0x33, 0xDD, 0x52, 0x92, 0x03, 0x10, 0x05, 0x25, 0x07, 0x3E, 0x4D, 0x37, +/* 0690 */ 0x96, 0x88, 0x70, 0x1F, 0x82, 0x39, 0x06, 0x00, 0x38, 0x0E, 0x4C, 0x06, 0x10, 0x06, 0x25, 0x95, +/* 06A0 */ 0xFD, 0xA7, 0x3C, 0x0D, 0x01, 0x69, 0xE9, 0x45, 0xA5, 0x3F, 0x29, 0xA3, 0x8C, 0xA7, 0x06, 0x71, +/* 06B0 */ 0x9F, 0x70, 0x09, 0xD8, 0x4C, 0x8A, 0x4D, 0xE9, 0x06, 0x68, 0x02, 0xE9, 0x01, 0x94, 0x10, 0x06, +/* 06C0 */ 0x1A, 0x9A, 0x1C, 0x66, 0x0C, 0x31, 0xEF, 0x45, 0x8F, 0x54, 0x07, 0x24, 0x01, 0x2D, 0x9D, 0x01, +/* 06D0 */ 0xE4, 0x0E, 0xA5, 0x8C, 0x9F, 0xA3, 0x70, 0x00, 0x44, 0x91, 0x59, 0x06, 0x01, 0x2E, 0x54, 0x0F, +/* 06E0 */ 0x5B, 0x30, 0x40, 0x0C, 0x33, 0x9A, 0x10, 0x09, 0x1A, 0xC7, 0x2C, 0x8B, 0xA7, 0x1F, 0x0B, 0x09, +/* 06F0 */ 0x5A, 0x9E, 0x97, 0x3E, 0x04, 0x3D, 0x27, 0x81, 0x05, 0x3D, 0x97, 0x5A, 0xC3, 0x0F, 0x9B, 0x85, +/* 0700 */ 0x5E, 0x27, 0x9F, 0x04, 0x02, 0x87, 0x0E, 0x69, 0x2D, 0xE7, 0x0C, 0x8E, 0x27, 0x9F, 0x80, 0x0B, +/* 0710 */ 0x08, 0x03, 0x88, 0x27, 0x0B, 0x0C, 0x00, 0x09, 0xE7, 0x0E, 0x5A, 0x9F, 0x8F, 0x9F, 0x6B, 0x05, +/* 0720 */ 0x00, 0xC7, 0x10, 0x08, 0x25, 0xC0, 0x0D, 0x9B, 0x30, 0x4B, 0x62, 0x63, 0x61, 0x00, 0x73, 0x36, +/* 0730 */ 0x0C, 0x28, 0x00, 0x38, 0x0F, 0x91, 0x9E, 0x05, 0x27, 0x56, 0xE7, 0x70, 0x70, 0x27, 0x2B, 0x0A, +/* 0740 */ 0xA5, 0x79, 0x65, 0xA5, 0x07, 0x51, 0x69, 0x2C, 0x4F, 0x0B, 0x03, 0x0C, 0x08, 0x10, 0x03, 0x25, +/* 0750 */ 0x8D, 0x22, 0x7A, 0x79, 0x44, 0xF5, 0x26, 0x0E, 0x10, 0x04, 0x00, 0x2A, 0xDD, 0x49, 0x5D, 0x89, +/* 0760 */ 0x00, 0x26, 0x4D, 0x1C, 0x52, 0x51, 0x22, 0x4B, 0x2F, 0x6F, 0x88, 0xCA, 0x6D, 0x95, 0x80, 0x72, +/* 0770 */ 0x91, 0x33, 0xA3, 0x22, 0x40, 0x02, 0x10, 0x04, 0x2A, 0xDD, 0x81, 0x1F, 0x44, 0x69, 0x33, 0x7F, +/* 0780 */ 0x00, 0xCA, 0x22, 0x8D, 0x21, 0x8D, 0x1E, 0x36, 0x06, 0x1C, 0x52, 0x51, 0x79, 0xDC, 0x91, 0x5A, +/* 0790 */ 0x54, 0x5D, 0x05, 0x07, 0x10, 0x05, 0x1D, 0x7B, 0x3D, 0x19, 0x96, 0x07, 0x70, 0x8C, 0x8E, 0x0F, +/* 07A0 */ 0xA7, 0xDC, 0x0C, 0x29, 0x31, 0x32, 0x32, 0x03, 0x10, 0x06, 0x46, 0x4C, 0x63, 0x4E, 0xEF, 0xB7, +/* 07B0 */ 0x0A, 0x10, 0x03, 0x1A, 0x18, 0xAB, 0x10, 0x05, 0x18, 0x60, 0x6D, 0xF0, 0x19, 0x9F, 0x05, 0x5C, +/* 07C0 */ 0x10, 0x03, 0x1D, 0x18, 0xDD, 0xB4, 0x10, 0x06, 0x19, 0x2A, 0x3C, 0x07, 0x33, 0x91, 0x00, 0x26, +/* 07D0 */ 0x0F, 0x1E, 0x36, 0x5D, 0x41, 0x33, 0x55, 0xD1, 0x70, 0x1C, 0xED, 0x42, 0x66, 0xCE, 0x0B, 0x42, +/* 07E0 */ 0x9F, 0x4D, 0x33, 0x64, 0x10, 0x07, 0x25, 0xC0, 0x6E, 0x63, 0x56, 0x97, 0x4D, 0x59, 0x70, 0x00, +/* 07F0 */ 0x7F, 0xE9, 0x06, 0x6F, 0x71, 0x08, 0x80, 0x6F, 0x71, 0x07, 0x69, 0x6F, 0x71, 0x05, 0x70, 0x00, +/* 0800 */ 0x7F, 0x37, 0x56, 0x97, 0x4D, 0x00, 0x38, 0x7C, 0x43, 0x10, 0x05, 0x98, 0x32, 0x28, 0x37, 0x96, +/* 0810 */ 0x45, 0x28, 0x19, 0x81, 0x0A, 0x28, 0x19, 0x79, 0xEA, 0x04, 0x1C, 0xEA, 0x04, 0x10, 0x06, 0x25, +/* 0820 */ 0x03, 0x0C, 0x9B, 0x03, 0x19, 0xA6, 0x08, 0x5B, 0xDC, 0x79, 0x4B, 0x2F, 0x39, 0x0E, 0x1C, 0x2E, +/* 0830 */ 0x19, 0x9F, 0x7F, 0x2F, 0x6B, 0x03, 0x00, 0x3C, 0x73, 0x50, 0x1F, 0x6F, 0x8A, 0x3E, 0x10, 0x06, +/* 0840 */ 0x25, 0x9C, 0x5B, 0x04, 0x19, 0x81, 0x08, 0xA5, 0x33, 0x0B, 0x88, 0xE4, 0x29, 0xE4, 0xA5, 0x03, +/* 0850 */ 0x42, 0x6C, 0x6E, 0x22, 0xA3, 0x34, 0x0B, 0x0B, 0x85, 0x3E, 0x37, 0x7D, 0x5B, 0x05, 0x10, 0x06, +/* 0860 */ 0x25, 0xC3, 0x01, 0x72, 0xDF, 0x96, 0x69, 0x1C, 0x6B, 0x31, 0x9F, 0x0F, 0xC4, 0x3D, 0x54, 0x06, +/* 0870 */ 0x09, 0x28, 0x37, 0x51, 0xF3, 0x3F, 0x5C, 0x51, 0x1E, 0x3C, 0x3D, 0x10, 0x06, 0x25, 0x06, 0x8A, +/* 0880 */ 0x3E, 0xE5, 0x0A, 0x07, 0x8C, 0xE2, 0x31, 0x96, 0xA5, 0x73, 0x00, 0x38, 0xC4, 0x4B, 0x21, 0x05, +/* 0890 */ 0x4D, 0x19, 0x79, 0x99, 0x2D, 0x0D, 0x78, 0x3E, 0x3F, 0x0C, 0x5B, 0x05, 0x10, 0x06, 0x98, 0x40, +/* 08A0 */ 0x7F, 0x03, 0x19, 0x0B, 0x4D, 0x08, 0x00, 0x3F, 0x9D, 0x01, 0x79, 0xE5, 0x51, 0x8F, 0x54, 0x75, +/* 08B0 */ 0xE0, 0x07, 0x69, 0x00, 0x7C, 0x59, 0x70, 0x39, 0x0E, 0x37, 0x56, 0x97, 0x9D, 0x00, 0x59, 0x6E, +/* 08C0 */ 0x43, 0x10, 0x05, 0x25, 0x0D, 0x45, 0xA5, 0x37, 0x96, 0x07, 0x07, 0x5B, 0x00, 0x44, 0x4D, 0xCA, +/* 08D0 */ 0x30, 0x4E, 0x9B, 0x42, 0x96, 0x69, 0x1C, 0x4B, 0x2F, 0x47, 0x1C, 0x24, 0x04, 0x10, 0x06, 0x98, +/* 08E0 */ 0x85, 0x0E, 0x43, 0x38, 0x9B, 0xA3, 0x53, 0x96, 0x69, 0x01, 0x73, 0x2C, 0x9F, 0x9B, 0xC8, 0x86, +/* 08F0 */ 0x5B, 0x02, 0xE9, 0x06, 0x04, 0xE0, 0x0A, 0x3E, 0x00, 0x4B, 0xE9, 0x0B, 0x08, 0x9B, 0x3C, 0x0E, +/* 0900 */ 0xBE, 0x10, 0x06, 0x98, 0x85, 0xA7, 0x19, 0xA4, 0x0B, 0x69, 0x2C, 0x66, 0x3D, 0x47, 0x37, 0x51, +/* 0910 */ 0x5E, 0x5B, 0x54, 0x07, 0x07, 0xE0, 0x7E, 0xA5, 0x91, 0xDC, 0x04, 0xC8, 0x95, 0x9B, 0x19, 0x56, +/* 0920 */ 0x91, 0x31, 0x95, 0x03, 0x10, 0x03, 0x46, 0xDD, 0xB4, 0x35, 0xDD, 0xB4, 0x10, 0x03, 0x46, 0xDD, +/* 0930 */ 0xB4, 0x1B, 0xAB, 0x10, 0x06, 0x46, 0xC3, 0x0A, 0x44, 0x0C, 0x9B, 0x02, 0x2D, 0x73, 0x04, 0x00, +/* 0940 */ 0x3C, 0x73, 0x04, 0x00, 0x44, 0x0C, 0x9B, 0x30, 0xC3, 0x0A, 0x10, 0x06, 0x20, 0xC9, 0x19, 0xF0, +/* 0950 */ 0x3E, 0x3F, 0x07, 0x07, 0x07, 0x07, 0x74, 0xF0, 0x3E, 0x2C, 0x9F, 0x58, 0x01, 0x10, 0x06, 0x20, +/* 0960 */ 0x04, 0x09, 0x22, 0xA1, 0x91, 0x5D, 0x06, 0x0D, 0x28, 0xDC, 0x06, 0x0D, 0x28, 0x37, 0xA1, 0x91, +/* 0970 */ 0x03, 0x00, 0x38, 0x09, 0x02, 0x10, 0x05, 0x25, 0x03, 0x0B, 0x5B, 0x34, 0x95, 0x0D, 0x8E, 0x88, +/* 0980 */ 0x1C, 0x7C, 0x2F, 0x0B, 0x4D, 0x57, 0x04, 0x0A, 0x22, 0x4E, 0x5A, 0x36, 0x21, 0x06, 0x8F, 0x10, +/* 0990 */ 0x0B, 0x00, 0x98, 0x95, 0x6B, 0x87, 0x03, 0x2C, 0x0B, 0x91, 0x07, 0x78, 0x8F, 0x1F, 0x9E, 0x28, +/* 09A0 */ 0x4E, 0x4E, 0x6B, 0x79, 0x56, 0x43, 0x0B, 0xA5, 0x06, 0x04, 0x80, 0x67, 0x80, 0x07, 0x69, 0x94, +/* 09B0 */ 0x02, 0x4D, 0x00, 0xED, 0x0B, 0x0D, 0x00, 0x94, 0x01, 0x4D, 0x95, 0x3E, 0x89, 0x00, 0x87, 0x03, +/* 09C0 */ 0x69, 0x67, 0x28, 0x09, 0x4D, 0x7F, 0x0B, 0x3E, 0x4E, 0x9D, 0x8B, 0x8F, 0x41, 0x05, 0x1F, 0x66, +/* 09D0 */ 0x3D, 0x72, 0x0D, 0x91, 0x07, 0xA2, 0x37, 0x24, 0x7C, 0xBE, 0x10, 0x07, 0x98, 0x3A, 0xE3, 0x10, +/* 09E0 */ 0x07, 0x25, 0xD2, 0x55, 0xE8, 0x08, 0xA5, 0x59, 0x9D, 0x6F, 0x3E, 0x82, 0x83, 0x7F, 0x37, 0x3B, +/* 09F0 */ 0x8F, 0x37, 0xA4, 0x7D, 0x3D, 0xD6, 0xBB, 0x5A, 0xA4, 0x85, 0x28, 0x82, 0xA5, 0x75, 0x10, 0x06, +/* 0A00 */ 0x25, 0x9F, 0x0B, 0x7F, 0x8C, 0x7C, 0x90, 0x0A, 0x00, 0x82, 0xBF, 0x9E, 0x70, 0x1F, 0x3C, 0x69, +/* 0A10 */ 0x42, 0x9E, 0x70, 0x00, 0x44, 0x91, 0x72, 0x0D, 0x9D, 0x81, 0x74, 0x02, 0x41, 0x0E, 0x07, 0x10, +/* 0A20 */ 0x07, 0x25, 0xD2, 0x55, 0xE8, 0x8E, 0x0E, 0x02, 0xD6, 0x07, 0x4D, 0xD6, 0x04, 0x91, 0xD6, 0x03, +/* 0A30 */ 0x73, 0xD6, 0x04, 0x91, 0xD6, 0x07, 0x4D, 0x2C, 0xA4, 0x8E, 0x0E, 0x02, 0x2C, 0xD2, 0x55, 0x03, +/* 0A40 */ 0x10, 0x06, 0x25, 0x3B, 0xAD, 0x10, 0x05, 0x25, 0x3B, 0x3E, 0x37, 0xA4, 0x07, 0x8C, 0x2B, 0x44, +/* 0A50 */ 0x9D, 0x02, 0x31, 0xD2, 0x73, 0x19, 0xA4, 0x05, 0x03, 0x1F, 0xD6, 0x57, 0x2B, 0x10, 0x07, 0x98, +/* 0A60 */ 0x40, 0x0E, 0x87, 0x74, 0x0C, 0x91, 0x78, 0x03, 0x82, 0xBF, 0x9E, 0x70, 0x60, 0x01, 0x2C, 0x09, +/* 0A70 */ 0x69, 0x04, 0x45, 0x53, 0x09, 0x69, 0x01, 0x8D, 0x53, 0x76, 0xC0, 0x0F, 0x53, 0x56, 0xA7, 0x0A, +/* 0A80 */ 0x9D, 0x3F, 0x4B, 0x87, 0x03, 0x10, 0x07, 0x25, 0x2B, 0x05, 0x9D, 0xD6, 0x05, 0x9D, 0xD6, 0x2B, +/* 0A90 */ 0x5A, 0x67, 0x9D, 0x02, 0x2E, 0x82, 0xF3, 0x53, 0xA4, 0x05, 0x08, 0x9D, 0xD6, 0x05, 0x9D, 0xD6, +/* 0AA0 */ 0x05, 0x9D, 0xD6, 0x2B, 0x10, 0x03, 0x25, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x00, 0x1A, 0xAA, 0xAA, +/* 0AB0 */ 0xAA, 0xAA, 0xD1, 0xDF, 0x01, 0x7C, 0x21, 0x0A, 0x05, 0x10, 0x07, 0x25, 0x2B, 0x05, 0x91, 0xD6, +/* 0AC0 */ 0x6E, 0x02, 0x82, 0x09, 0x99, 0x59, 0x91, 0x7F, 0x01, 0x59, 0x9B, 0x9B, 0x1F, 0x82, 0x9A, 0x80, +/* 0AD0 */ 0x59, 0x9D, 0x04, 0xE0, 0x2B, 0x0B, 0x80, 0xD6, 0x04, 0x5B, 0x10, 0x06, 0x25, 0x2B, 0x57, 0xA8, +/* 0AE0 */ 0x2B, 0x44, 0x5B, 0x90, 0x04, 0x37, 0x3B, 0x80, 0x10, 0x09, 0x25, 0x02, 0x0F, 0x69, 0x6F, 0x73, +/* 0AF0 */ 0x27, 0x49, 0x9D, 0x39, 0x9B, 0x1F, 0xC3, 0x5B, 0x0B, 0x01, 0x0F, 0x7F, 0x27, 0xA4, 0x0E, 0x49, +/* 0B00 */ 0x41, 0x27, 0x76, 0x70, 0x0D, 0x86, 0x27, 0xE2, 0x9B, 0x0A, 0x0A, 0x88, 0x1F, 0x95, 0x28, 0x0D, +/* 0B10 */ 0x70, 0x09, 0x3E, 0x1F, 0x9E, 0x3D, 0x0A, 0x80, 0x09, 0x3D, 0x5A, 0xA3, 0x84, 0x79, 0x09, 0x28, +/* 0B20 */ 0x10, 0x07, 0x25, 0xD2, 0xB5, 0x10, 0x08, 0x98, 0xE6, 0xB2, 0xC5, 0x10, 0x07, 0x25, 0xD2, 0x55, +/* 0B30 */ 0xE8, 0x08, 0x5B, 0x01, 0xD6, 0x0B, 0x28, 0xD6, 0x0A, 0x28, 0x82, 0x09, 0x04, 0x0E, 0x71, 0x3B, +/* 0B40 */ 0x69, 0x37, 0xA4, 0xEB, 0x2B, 0x57, 0x10, 0x08, 0x98, 0xE6, 0x00, 0x7C, 0xA2, 0x70, 0xD6, 0x01, +/* 0B50 */ 0xA5, 0x2C, 0xBB, 0x0D, 0x3E, 0x27, 0xA3, 0x1E, 0x0C, 0x3D, 0x27, 0xBB, 0x0D, 0x3E, 0x27, 0x2B, +/* 0B60 */ 0x01, 0x5B, 0x37, 0x7C, 0xA2, 0x28, 0x3F, 0x4B, 0x5B, 0x08, 0x31, 0x9F, 0x09, 0x69, 0x1C, 0x96, +/* 0B70 */ 0x10, 0x07, 0x25, 0xD2, 0x29, 0x04, 0x37, 0xA4, 0x8E, 0x3E, 0xD6, 0x0A, 0x80, 0x82, 0x09, 0x32, +/* 0B80 */ 0x3D, 0x2C, 0x3B, 0x4D, 0x37, 0xA4, 0x0B, 0x3D, 0x59, 0x9D, 0x05, 0x91, 0x59, 0x9D, 0x4C, 0x3E, +/* 0B90 */ 0xD6, 0x07, 0x9D, 0x10, 0x06, 0x98, 0x8E, 0x73, 0x03, 0xE5, 0x0C, 0x78, 0x07, 0x2D, 0x69, 0xAC, +/* 0BA0 */ 0x7A, 0x9D, 0x6D, 0xF0, 0x04, 0x00, 0xDC, 0x09, 0x9B, 0xDC, 0x4E, 0xA5, 0x2D, 0x0D, 0x08, 0x0A, +/* 0BB0 */ 0x91, 0x3F, 0x41, 0x0E, 0x43, 0x10, 0x06, 0x25, 0x0E, 0x8A, 0xE0, 0x06, 0x07, 0xA5, 0x07, 0x05, +/* 0BC0 */ 0x42, 0xA5, 0xDE, 0xDE, 0x10, 0x07, 0x25, 0x8D, 0xB9, 0x10, 0x06, 0x25, 0xA5, 0x1F, 0x09, 0x80, +/* 0BD0 */ 0x27, 0x6F, 0x3E, 0x00, 0x0B, 0x71, 0x08, 0x80, 0x00, 0x7F, 0x59, 0x4D, 0x01, 0x91, 0x1F, 0xC7, +/* 0BE0 */ 0x0F, 0x93, 0x69, 0x19, 0x61, 0xED, 0x3C, 0x91, 0x0E, 0x1F, 0xE5, 0xDF, 0x02, 0x0F, 0x4D, 0x10, +/* 0BF0 */ 0x09, 0x25, 0x4B, 0x96, 0x73, 0x66, 0x88, 0x1F, 0x0B, 0x3E, 0x08, 0x9B, 0x00, 0x6B, 0x5A, 0x09, +/* 0C00 */ 0x3D, 0x0A, 0x6E, 0x00, 0x29, 0x5A, 0x8D, 0x9C, 0x0A, 0x88, 0x91, 0x1F, 0x67, 0x0F, 0x92, 0xE2, +/* 0C10 */ 0x4D, 0x65, 0x9D, 0x3D, 0x0E, 0xBB, 0x4E, 0x9B, 0x88, 0x68, 0x28, 0x5A, 0x39, 0xA5, 0x00, 0x51, +/* 0C20 */ 0x3E, 0x5A, 0x6F, 0x9B, 0x00, 0x09, 0x45, 0x10, 0x06, 0x25, 0x0A, 0x28, 0x39, 0xD8, 0x04, 0x91, +/* 0C30 */ 0x05, 0x4D, 0x19, 0x6B, 0x51, 0x31, 0xD2, 0x09, 0x19, 0x9F, 0x0F, 0x70, 0x1F, 0x54, 0x7F, 0xDC, +/* 0C40 */ 0x29, 0x62, 0x34, 0x99, 0x03, 0xE0, 0x0D, 0x3E, 0x6F, 0x3D, 0x10, 0x07, 0x25, 0x7C, 0xD3, 0x6E, +/* 0C50 */ 0x79, 0xC7, 0xB6, 0x10, 0x06, 0x25, 0xF0, 0x9D, 0x3F, 0x07, 0x48, 0x4D, 0x19, 0x9F, 0xA5, 0x2F, +/* 0C60 */ 0xA3, 0x8C, 0x9F, 0xA5, 0x31, 0x66, 0x69, 0xE4, 0x5B, 0x1C, 0x0B, 0x73, 0x07, 0x07, 0x04, 0x2C, +/* 0C70 */ 0x6F, 0x8A, 0x4D, 0x10, 0x04, 0x35, 0x60, 0x2F, 0x86, 0x28, 0x19, 0x66, 0x80, 0x2F, 0x86, 0xE1, +/* 0C80 */ 0xCA, 0xE1, 0xCA, 0xE1, 0xCA, 0xE1, 0xCA, 0x03, 0x2F, 0x86, 0x28, 0xE4, 0x5C, 0x01, 0x10, 0x06, +/* 0C90 */ 0x1D, 0x02, 0x09, 0x04, 0x72, 0x9D, 0x33, 0x89, 0x33, 0xDA, 0x27, 0x82, 0x21, 0x02, 0x9D, 0x33, +/* 0CA0 */ 0x68, 0x33, 0xA3, 0x2F, 0x96, 0x28, 0x42, 0x9F, 0x4D, 0x33, 0x29, 0x33, 0x84, 0x10, 0x04, 0x35, +/* 0CB0 */ 0x60, 0x1C, 0x4B, 0x3D, 0x26, 0x86, 0xDB, 0x62, 0xDB, 0x08, 0x3D, 0x00, 0xDC, 0x09, 0x3D, 0x42, +/* 0CC0 */ 0x4B, 0x3D, 0x26, 0x5C, 0x01, 0x10, 0x06, 0x2A, 0x56, 0x0F, 0x6D, 0x8E, 0x87, 0x37, 0x9F, 0x9D, +/* 0CD0 */ 0x08, 0x3D, 0x37, 0xA3, 0x84, 0x91, 0x10, 0x06, 0x1C, 0x46, 0x46, 0x64, 0x64, 0x5E, 0x2C, 0x4C, +/* 0CE0 */ 0x8A, 0x4D, 0x38, 0x58, 0x03, 0x10, 0x04, 0x1D, 0x02, 0x0A, 0x30, 0xC3, 0x0D, 0x8F, 0x1F, 0x44, +/* 0CF0 */ 0x01, 0x10, 0x06, 0x20, 0xAE, 0xC4, 0x10, 0x07, 0x1D, 0xCB, 0x61, 0x04, 0xE5, 0xA7, 0xE0, 0x99, +/* 0D00 */ 0x4C, 0x71, 0x99, 0x6F, 0x3E, 0x2C, 0x99, 0x4C, 0x71, 0x7A, 0x97, 0xE0, 0x2E, 0x7F, 0x03, 0x10, +/* 0D10 */ 0x05, 0x20, 0x67, 0x6E, 0x43, 0x3F, 0x5B, 0x08, 0x63, 0xBB, 0x3C, 0x28, 0x42, 0x9E, 0x69, 0xD1, +/* 0D20 */ 0x5B, 0x07, 0x08, 0x42, 0x4F, 0x43, 0x10, 0x07, 0x42, 0x2A, 0x3C, 0x07, 0x1C, 0x39, 0xCE, 0x0E, +/* 0D30 */ 0x19, 0x8E, 0x41, 0x0E, 0x38, 0x5B, 0xD7, 0x3C, 0x87, 0x6B, 0x10, 0x06, 0x46, 0x4F, 0x08, 0xB0, +/* 0D40 */ 0xBE, 0x10, 0x04, 0x1D, 0x67, 0x6E, 0x8C, 0x39, 0xA7, 0x04, 0x37, 0x9F, 0xDF, 0xFA, 0xA5, 0x19, +/* 0D50 */ 0x95, 0x5B, 0x06, 0x42, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x10, 0x06, 0x1B, +/* 0D60 */ 0x25, 0x6C, 0x07, 0x3C, 0x0E, 0x0F, 0x55, 0xE9, 0x0A, 0x0B, 0x0D, 0x02, 0x2C, 0x66, 0x3E, 0x05, +/* 0D70 */ 0x69, 0x54, 0x06, 0x62, 0x34, 0x7E, 0x0F, 0x9B, 0x01, 0x3F, 0x9B, 0x93, 0x19, 0xEF, 0x45, 0x70, +/* 0D80 */ 0x37, 0x64, 0x9F, 0xE0, 0x61, 0x05, 0x07, 0x91, 0x37, 0x9C, 0xA5, 0x43, 0x10, 0x06, 0x1D, 0x03, +/* 0D90 */ 0x08, 0x05, 0xBD, 0x1C, 0x2E, 0x6B, 0xA9, 0x10, 0x03, 0xD0, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0xD0, +/* 0DA0 */ 0xBD, 0xBD, 0xBD, 0x1C, 0x0B, 0x28, 0x42, 0x2E, 0x1C, 0x6C, 0x10, 0x06, 0x1D, 0x04, 0x75, 0x1C, +/* 0DB0 */ 0x99, 0xBD, 0x01, 0x29, 0x37, 0x99, 0x08, 0x28, 0xE5, 0xA3, 0x63, 0x06, 0x9B, 0x9D, 0x19, 0x99, +/* 0DC0 */ 0x6E, 0x74, 0x99, 0x07, 0x4D, 0x37, 0x99, 0x56, 0xD8, 0x10, 0x03, 0x1D, 0x04, 0x0A, 0x21, 0x8D, +/* 0DD0 */ 0xEE, 0xEE, 0xEE, 0x06, 0x42, 0x96, 0x73, 0x72, 0x6B, 0x03, 0x10, 0x09, 0x20, 0x76, 0x61, 0x04, +/* 0DE0 */ 0x61, 0x02, 0x1F, 0x96, 0xA5, 0x51, 0x87, 0x4D, 0x5A, 0x99, 0x05, 0x4D, 0x04, 0xAF, 0x04, 0xAF, +/* 0DF0 */ 0x04, 0xAF, 0x04, 0xAF, 0x04, 0x9D, 0x10, 0x06, 0x20, 0x76, 0x6E, 0xA9, 0x10, 0x06, 0x46, 0xB3, +/* 0E00 */ 0x10, 0x07, 0x20, 0x2E, 0x61, 0xD5, 0x7B, 0x08, 0x03, 0x10, 0x07, 0x20, 0x9E, 0x55, 0x6B, 0x38, +/* 0E10 */ 0x5B, 0xD7, 0x3C, 0x87, 0x0E, 0xCE, 0xCE, 0x0E, 0x1C, 0x95, 0x08, 0x10, 0x04, 0x20, 0x7A, 0x8E, +/* 0E20 */ 0x05, 0x00, 0xE5, 0x4D, 0x30, 0x06, 0x91, 0xBD, 0xBD, 0x10, 0x05, 0x20, 0x01, 0x0B, 0x5B, 0x05, +/* 0E30 */ 0x19, 0xA3, 0x90, 0x07, 0x3C, 0x9D, 0x2F, 0xA0, 0x70, 0xD1, 0x0E, 0x0F, 0x19, 0xA2, 0x08, 0xA5, +/* 0E40 */ 0x19, 0x7D, 0x9B, 0x04, 0x10, 0x04, 0x25, 0x02, 0x08, 0x06, 0xD1, 0x9D, 0x42, 0xFA, 0x5B, 0x19, +/* 0E50 */ 0x9E, 0x9B, 0x05, 0xE4, 0x9D, 0xD1, 0x9D, 0xD1, 0x9D, 0x42, 0x9F, 0x5B, 0x07, 0x42, 0x9E, 0x7F, +/* 0E60 */ 0x02, 0x10, 0x06, 0x20, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0x20, 0x0E, 0x0E, 0x00, 0x49, 0x53, 0x66, +/* 0E70 */ 0x3E, 0x7A, 0x34, 0xE2, 0x09, 0x71, 0x9F, 0x4D, 0xA6, 0x42, 0xE7, 0x94, 0x19, 0x66, 0x0E, 0x80, +/* 0E80 */ 0x1F, 0xE5, 0x88, 0x10, 0x08, 0x20, 0x6E, 0x6F, 0x3E, 0x09, 0x3E, 0x5A, 0x86, 0x39, 0x28, 0x41, +/* 0E90 */ 0x27, 0x62, 0x49, 0x75, 0x68, 0x5A, 0x67, 0x70, 0xE7, 0x08, 0x94, 0x00, 0x65, 0x73, 0x0B, 0xA2, +/* 0EA0 */ 0x69, 0x5A, 0xF8, 0x9D, 0x7A, 0x28, 0x27, 0x6F, 0x70, 0x49, 0x88, 0x10, 0x06, 0x20, 0x0B, 0x3D, +/* 0EB0 */ 0x09, 0x3D, 0x3F, 0x4D, 0x55, 0x42, 0x51, 0x28, 0x19, 0x95, 0x45, 0x2F, 0x61, 0x4D, 0x19, 0xE2, +/* 0EC0 */ 0x6B, 0x74, 0x6E, 0x01, 0x07, 0x4D, 0x10, 0x06, 0x20, 0x0E, 0xBA, 0xF1, 0x10, 0x05, 0x20, 0x0A, +/* 0ED0 */ 0x45, 0xE0, 0xC0, 0x07, 0x86, 0x63, 0x4E, 0x6E, 0x30, 0x9E, 0x70, 0xE4, 0x5B, 0x1C, 0x0B, 0x91, +/* 0EE0 */ 0x07, 0x34, 0x4C, 0x45, 0x73, 0x10, 0x04, 0x1B, 0xDD, 0x0B, 0x28, 0xE4, 0x73, 0x01, 0xE4, 0x70, +/* 0EF0 */ 0xD1, 0x70, 0x42, 0x96, 0x69, 0x1C, 0x29, 0x2F, 0x9E, 0x80, 0xD1, 0x70, 0xD1, 0x4D, 0xD1, 0x4D, +/* 0F00 */ 0x42, 0x9F, 0x91, 0x2F, 0x6F, 0x28, 0x33, 0xEB, 0x10, 0x04, 0x2A, 0x61, 0x33, 0x61, 0xB8, 0x61, +/* 0F10 */ 0xB8, 0x61, 0x10, 0x04, 0x35, 0xDD, 0x6F, 0x8F, 0x00, 0x44, 0x91, 0x33, 0x73, 0x33, 0x73, 0x33, +/* 0F20 */ 0x7F, 0x79, 0x44, 0x69, 0x1C, 0x89, 0x22, 0x73, 0x33, 0x73, 0x33, 0x73, 0x1C, 0x49, 0xBF, 0x6F, +/* 0F30 */ 0x80, 0xD1, 0x02, 0x10, 0x06, 0x18, 0xAC, 0x65, 0x0E, 0x8F, 0x83, 0x37, 0x90, 0x0A, 0xA5, 0x02, +/* 0F40 */ 0xD1, 0x02, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x15, 0x00, 0x33, 0x00, 0x54, 0x00, 0x79, 0x00, +/* 0F50 */ 0x9E, 0x00, 0xA7, 0x00, 0xD0, 0x00, 0xD5, 0x01, 0x08, 0x01, 0x2B, 0x01, 0x46, 0x01, 0x56, 0x01, +/* 0F60 */ 0x60, 0x01, 0x8F, 0x01, 0x9A, 0x01, 0xAE, 0x01, 0xC0, 0x01, 0xD6, 0x01, 0xEE, 0x01, 0xFA, 0x02, +/* 0F70 */ 0x11, 0x02, 0x3A, 0x02, 0x40, 0x02, 0x4F, 0x02, 0x5D, 0x02, 0x7D, 0x02, 0xA0, 0x02, 0xBD, 0x02, +/* 0F80 */ 0xE8, 0x03, 0x14, 0x03, 0x32, 0x03, 0x3F, 0x03, 0x4D, 0x03, 0x5C, 0x03, 0x6C, 0x03, 0x7A, 0x03, +/* 0F90 */ 0x89, 0x03, 0xB8, 0x03, 0xE0, 0x03, 0xEE, 0x03, 0xF9, 0x04, 0x09, 0x04, 0x18, 0x04, 0x27, 0x04, +/* 0FA0 */ 0x34, 0x04, 0x42, 0x04, 0x50, 0x04, 0x7F, 0x04, 0x90, 0x04, 0x9D, 0x04, 0xAA, 0x04, 0xBA, 0x04, +/* 0FB0 */ 0xCB, 0x04, 0xD9, 0x04, 0xEE, 0x05, 0x28, 0x05, 0x33, 0x05, 0x3F, 0x05, 0x4E, 0x05, 0x55, 0x05, +/* 0FC0 */ 0x66, 0x05, 0x82, 0x05, 0xAD, 0x05, 0xBA, 0x05, 0xC8, 0x05, 0xD5, 0x05, 0xE0, 0x05, 0xE9, 0x05, +/* 0FD0 */ 0xFC, 0x06, 0x27, 0x06, 0x49, 0x06, 0x57, 0x06, 0x61, 0x06, 0x6E, 0x06, 0x7A, 0x06, 0x89, 0x06, +/* 0FE0 */ 0x98, 0x06, 0xA9, 0x06, 0xB4, 0x06, 0xD5, 0x06, 0xE3, 0x06, 0xEF, 0x06, 0xFB, 0x07, 0x09, 0x07, +/* 0FF0 */ 0x15, 0x07, 0x24, 0x07, 0x3B, 0x07, 0x62, 0x07, 0x70, 0x07, 0x78, 0x07, 0x84, 0x07, 0x8E, 0x07, +/* 1000 */ 0x9B, 0x07, 0xA4, 0x03, 0x00, 0x10, 0x03, 0x20, 0x92, 0x5D, 0x52, 0xAC, 0x1C, 0xE5, 0x22, 0x7A, +/* 1010 */ 0x5D, 0x8D, 0x5D, 0x52, 0x52, 0x09, 0x80, 0x10, 0x05, 0x98, 0x9E, 0x0C, 0x33, 0x81, 0x2F, 0x51, +/* 1020 */ 0xA5, 0x01, 0x59, 0x9D, 0x23, 0x19, 0xA3, 0x21, 0xA3, 0x21, 0x2E, 0x23, 0xDC, 0x4B, 0xA5, 0x31, +/* 1030 */ 0x66, 0x0D, 0x6D, 0x9E, 0x0C, 0x10, 0x06, 0x25, 0x4E, 0x0B, 0x29, 0x03, 0x3C, 0x9D, 0x75, 0x19, +/* 1040 */ 0x4B, 0x72, 0x0D, 0x3E, 0x30, 0xF0, 0x0E, 0x19, 0x32, 0x80, 0x04, 0x42, 0x6E, 0x42, 0x96, 0x73, +/* 1050 */ 0x07, 0x07, 0x03, 0x37, 0xEC, 0x69, 0x10, 0x06, 0x1F, 0x98, 0xD1, 0x02, 0x00, 0x4E, 0x04, 0x2C, +/* 1060 */ 0x66, 0x0D, 0x6E, 0xE7, 0x2C, 0x9F, 0x91, 0x09, 0x3D, 0x00, 0x82, 0x79, 0x69, 0x3F, 0x69, 0x05, +/* 1070 */ 0x28, 0xE5, 0x45, 0x70, 0x2C, 0x95, 0x04, 0x03, 0x03, 0x04, 0x07, 0x10, 0x06, 0x25, 0x6E, 0x1F, +/* 1080 */ 0x0B, 0x3E, 0x2C, 0xE2, 0x02, 0x9D, 0x19, 0x55, 0x07, 0x3E, 0x36, 0xE7, 0x00, 0x3F, 0x0E, 0x0F, +/* 1090 */ 0xA5, 0x1E, 0xC7, 0x04, 0x0D, 0x28, 0x02, 0x3F, 0x8A, 0x70, 0x1F, 0xC7, 0x7D, 0x80, 0x6D, 0x4B, +/* 10A0 */ 0x10, 0x04, 0x2A, 0x61, 0xB8, 0x00, 0x35, 0xB8, 0x61, 0x10, 0x06, 0x98, 0x7D, 0x87, 0x74, 0x01, +/* 10B0 */ 0x5B, 0x07, 0x0B, 0x74, 0x47, 0x2F, 0x6F, 0xA5, 0x8C, 0x49, 0x48, 0x80, 0xE5, 0x06, 0x49, 0x34, +/* 10C0 */ 0x02, 0x7C, 0x7F, 0x2F, 0xA1, 0x0E, 0x74, 0x96, 0x03, 0x0B, 0x3E, 0x3F, 0x0E, 0x45, 0x63, 0x4E, +/* 10D0 */ 0x04, 0x03, 0x10, 0x05, 0x2A, 0xC6, 0x02, 0x10, 0x09, 0x1D, 0xC7, 0x1C, 0x8E, 0xA5, 0x06, 0x37, +/* 10E0 */ 0x8E, 0x07, 0x06, 0x09, 0x80, 0xC7, 0x28, 0x0D, 0x4D, 0x48, 0x27, 0x9C, 0x92, 0x06, 0x84, 0x0F, +/* 10F0 */ 0x27, 0x9C, 0x85, 0x03, 0x02, 0x00, 0x88, 0x1F, 0x9F, 0x28, 0x0E, 0x91, 0x7D, 0x27, 0x66, 0x75, +/* 1100 */ 0x06, 0x92, 0x07, 0x00, 0xC7, 0xEC, 0x09, 0xE4, 0x04, 0x02, 0x10, 0x05, 0x1A, 0x02, 0x2F, 0x56, +/* 1110 */ 0x0F, 0x8F, 0x19, 0x96, 0x08, 0x9D, 0x19, 0xEF, 0x45, 0x63, 0x07, 0x91, 0x73, 0x00, 0x38, 0x0F, +/* 1120 */ 0x73, 0x0C, 0xE4, 0x03, 0x9F, 0x35, 0x38, 0x07, 0x07, 0x07, 0x8C, 0x07, 0xF3, 0x10, 0x07, 0x46, +/* 1130 */ 0x96, 0x01, 0x96, 0x74, 0x06, 0x69, 0x7A, 0x1E, 0x65, 0x9B, 0x03, 0x5B, 0x2D, 0x80, 0xBB, 0x27, +/* 1140 */ 0xA4, 0xA4, 0x3C, 0x28, 0xC8, 0x83, 0x00, 0x83, 0x10, 0x06, 0x18, 0xC9, 0x74, 0xF0, 0x80, 0x2C, +/* 1150 */ 0x9F, 0x5C, 0x07, 0x80, 0xD1, 0x80, 0x72, 0xEB, 0x10, 0x05, 0x18, 0x60, 0x6D, 0xF0, 0x19, 0x9F, +/* 1160 */ 0x05, 0x5C, 0x10, 0x07, 0x1F, 0x2A, 0x79, 0x26, 0x0E, 0x5B, 0x03, 0x1F, 0xC7, 0x87, 0x07, 0x0A, +/* 1170 */ 0x0D, 0x2C, 0x96, 0x9A, 0x70, 0x0B, 0x04, 0x27, 0x9E, 0x05, 0x0B, 0x70, 0x07, 0x06, 0x27, 0x95, +/* 1180 */ 0x07, 0x0B, 0xC4, 0x09, 0x05, 0x27, 0x9F, 0xA7, 0x03, 0x09, 0xD8, 0x95, 0x45, 0x80, 0x19, 0x9F, +/* 1190 */ 0xEB, 0x10, 0x04, 0x33, 0x1B, 0x60, 0x2F, 0xA3, 0x73, 0xE4, 0x5C, 0x04, 0x10, 0x06, 0x1A, 0x01, +/* 11A0 */ 0x72, 0x7C, 0xBF, 0x78, 0xED, 0x37, 0x9E, 0x0C, 0x04, 0x28, 0x19, 0x7E, 0x9B, 0x42, 0x9F, 0x04, +/* 11B0 */ 0x10, 0x06, 0x35, 0x98, 0xE7, 0x00, 0xDC, 0xEF, 0xB7, 0xBF, 0xC9, 0x36, 0x45, 0x3D, 0x2C, 0x9F, +/* 11C0 */ 0x58, 0x01, 0x10, 0x04, 0x2A, 0x4E, 0xD1, 0x0E, 0x69, 0x26, 0x08, 0xA6, 0x33, 0x0B, 0x09, 0x42, +/* 11D0 */ 0x96, 0x0D, 0x01, 0x26, 0x9D, 0x1E, 0xE9, 0x5B, 0x10, 0x04, 0x2A, 0xAC, 0xC3, 0x0E, 0x0F, 0x8C, +/* 11E0 */ 0x9F, 0x07, 0xA6, 0x1C, 0xE2, 0x42, 0x9F, 0x41, 0x19, 0x9F, 0x04, 0x09, 0x0E, 0x44, 0x6E, 0x05, +/* 11F0 */ 0x10, 0x04, 0x1D, 0x9F, 0x0B, 0x01, 0x44, 0x9B, 0x03, 0x19, 0x9F, 0x04, 0x10, 0x06, 0x20, 0x99, +/* 1200 */ 0xD9, 0xD9, 0xD9, 0xD9, 0x04, 0x9D, 0xE5, 0xA6, 0x91, 0xE5, 0x94, 0x29, 0xE5, 0x04, 0xAC, 0xE2, +/* 1210 */ 0x00, 0x26, 0x83, 0x10, 0x09, 0x98, 0x9C, 0x8A, 0x70, 0x27, 0x7E, 0x45, 0xA7, 0x70, 0x27, 0xD2, +/* 1220 */ 0x5B, 0x03, 0x70, 0x1F, 0xC3, 0x45, 0x5B, 0x03, 0x70, 0x2C, 0x51, 0x5B, 0x03, 0x70, 0x38, 0x61, +/* 1230 */ 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0x49, 0x8C, 0x06, 0x06, 0x02, 0x08, 0x03, 0x10, 0x03, 0x00, 0x18, +/* 1240 */ 0xDD, 0xB4, 0x10, 0x04, 0x20, 0x20, 0x02, 0x33, 0x39, 0x21, 0x24, 0x3D, 0x00, 0x36, 0x3E, 0x00, +/* 1250 */ 0x26, 0x6D, 0x04, 0x25, 0x40, 0x28, 0x44, 0x0A, 0x28, 0x72, 0x28, 0x72, 0x28, 0x72, 0x28, 0x10, +/* 1260 */ 0x05, 0x1A, 0x01, 0x72, 0x4B, 0x80, 0x19, 0x76, 0x6E, 0x19, 0xDA, 0xDA, 0xE9, 0x05, 0x6B, 0x19, +/* 1270 */ 0x7E, 0x45, 0x8C, 0x4E, 0x04, 0x5D, 0x5A, 0x26, 0x07, 0x07, 0x07, 0x07, 0x3C, 0x8A, 0x88, 0x10, +/* 1280 */ 0x07, 0x20, 0x01, 0x06, 0x4E, 0x1E, 0x82, 0x07, 0x05, 0x70, 0x37, 0x6F, 0x28, 0x0B, 0x28, 0x59, +/* 1290 */ 0x9D, 0x04, 0x91, 0x37, 0x0B, 0x80, 0x0A, 0x69, 0x5A, 0xC3, 0x9D, 0x04, 0x0F, 0x53, 0x9F, 0x09, +/* 12A0 */ 0x9F, 0x09, 0x10, 0x0B, 0x25, 0xCC, 0x03, 0x3E, 0x00, 0xC7, 0x28, 0x66, 0x0A, 0x1F, 0xC7, 0x28, +/* 12B0 */ 0x02, 0x3D, 0x06, 0x0B, 0x19, 0x9A, 0x4C, 0x07, 0x1F, 0xC7, 0x8F, 0x04, 0x0F, 0x92, 0xBC, 0x10, +/* 12C0 */ 0x0B, 0x25, 0xCC, 0x49, 0x5E, 0xC7, 0x28, 0x66, 0x0B, 0x0C, 0x91, 0x1F, 0x4E, 0x28, 0x02, 0x28, +/* 12D0 */ 0x90, 0x71, 0x9A, 0x00, 0x95, 0x0D, 0x00, 0xC7, 0x8F, 0x9F, 0x8F, 0x2C, 0x48, 0x4E, 0x0D, 0x0B, +/* 12E0 */ 0x07, 0x01, 0x5A, 0x39, 0x05, 0x7B, 0x45, 0x3E, 0x65, 0x0C, 0x10, 0x0B, 0x25, 0x03, 0x6E, 0x1E, +/* 12F0 */ 0x9C, 0x00, 0x65, 0x08, 0xA6, 0x1F, 0x0B, 0x53, 0x06, 0x69, 0x7B, 0x3E, 0x1F, 0x65, 0x89, 0x66, +/* 1300 */ 0x0A, 0x2C, 0x64, 0x8E, 0x02, 0x3D, 0x06, 0x0B, 0x5A, 0xD2, 0x07, 0x9A, 0x4C, 0x07, 0xC7, 0x01, +/* 1310 */ 0x01, 0x8F, 0x04, 0x0F, 0x92, 0xBC, 0x10, 0x05, 0x20, 0x4E, 0xE7, 0x72, 0x29, 0x00, 0x72, 0xDD, +/* 1320 */ 0x06, 0x05, 0x72, 0xDF, 0x01, 0x51, 0x1E, 0x2D, 0x91, 0x1C, 0x4B, 0x5E, 0x74, 0x66, 0x73, 0x61, +/* 1330 */ 0x19, 0x8B, 0x5B, 0x05, 0x10, 0x07, 0x1B, 0x02, 0x33, 0x47, 0x30, 0xC3, 0x0A, 0x08, 0x42, 0x3A, +/* 1340 */ 0xE3, 0x10, 0x07, 0x19, 0x72, 0x2F, 0x96, 0x94, 0x00, 0xDC, 0x0C, 0x07, 0x2F, 0x3A, 0xE3, 0x10, +/* 1350 */ 0x07, 0x1B, 0x0B, 0x80, 0x00, 0x3C, 0x97, 0x0E, 0x30, 0x5E, 0x7B, 0x42, 0x3A, 0xE3, 0x10, 0x07, +/* 1360 */ 0x5A, 0xDD, 0x05, 0x70, 0x0A, 0x30, 0x90, 0x0E, 0x0E, 0x2F, 0x60, 0x42, 0x3A, 0xE3, 0x10, 0x07, +/* 1370 */ 0x1F, 0x1B, 0x2F, 0xA6, 0x04, 0x69, 0x19, 0x64, 0x00, 0xEB, 0x3A, 0xE3, 0x10, 0x07, 0xC7, 0x72, +/* 1380 */ 0x0D, 0x70, 0x26, 0x87, 0x0C, 0x42, 0x56, 0x4D, 0x42, 0x3A, 0xE3, 0x10, 0x09, 0x98, 0x95, 0xF3, +/* 1390 */ 0x70, 0x2C, 0x6B, 0x73, 0x50, 0x9F, 0x91, 0x9D, 0x36, 0x05, 0x29, 0x02, 0x5E, 0x5A, 0x6F, 0x88, +/* 13A0 */ 0x0D, 0x8A, 0x1E, 0x9F, 0x5B, 0xA0, 0x06, 0x05, 0x02, 0x1F, 0x95, 0xF3, 0x3D, 0x27, 0x6F, 0x70, +/* 13B0 */ 0x05, 0x09, 0x9D, 0x07, 0x1E, 0x02, 0xA5, 0xC3, 0x45, 0xA5, 0x10, 0x06, 0x98, 0x40, 0x7F, 0x8C, +/* 13C0 */ 0x0C, 0x9D, 0x0A, 0x0B, 0x38, 0xDF, 0x9E, 0x70, 0x1C, 0xA3, 0x1E, 0x3C, 0x69, 0x42, 0x95, 0x4D, +/* 13D0 */ 0x42, 0x9F, 0xA5, 0x64, 0x06, 0x19, 0xF0, 0xD8, 0xC3, 0x94, 0x22, 0x7F, 0x6D, 0x7A, 0x3D, 0x00, +/* 13E0 */ 0x26, 0x02, 0x10, 0x06, 0x1B, 0x22, 0x67, 0x4D, 0x79, 0xDC, 0x06, 0x0B, 0x05, 0x19, 0x3B, 0xAD, +/* 13F0 */ 0x10, 0x06, 0x19, 0xD1, 0x72, 0xC8, 0xC0, 0x75, 0x31, 0x3B, 0xAD, 0x10, 0x06, 0x35, 0x9F, 0x6E, +/* 1400 */ 0x30, 0x6F, 0x0B, 0x0A, 0x0D, 0x19, 0x9F, 0x5F, 0x19, 0x3B, 0xAD, 0x10, 0x06, 0x00, 0x35, 0x79, +/* 1410 */ 0x4E, 0xDC, 0x9D, 0x62, 0x30, 0x84, 0x23, 0x19, 0x3B, 0xAD, 0x10, 0x03, 0x35, 0x02, 0xDD, 0x0B, +/* 1420 */ 0x0D, 0x21, 0x02, 0x08, 0x0C, 0x1C, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x1B, 0x02, 0xD1, 0x89, 0x42, +/* 1430 */ 0x66, 0x09, 0x5D, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x35, 0x2E, 0x26, 0x0E, 0x8E, 0x8C, 0x9F, 0x4E, +/* 1440 */ 0x2F, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x35, 0x79, 0x2F, 0xED, 0x55, 0x19, 0x23, 0x7B, 0x6D, 0xA8, +/* 1450 */ 0xA8, 0x2B, 0x10, 0x07, 0x25, 0x02, 0x45, 0x29, 0x34, 0x02, 0x5B, 0x78, 0x28, 0x27, 0x9F, 0x9B, +/* 1460 */ 0xC0, 0x91, 0x1F, 0x65, 0x9B, 0x5E, 0x5B, 0x27, 0x6F, 0x45, 0x88, 0xA5, 0x82, 0x0D, 0x05, 0x01, +/* 1470 */ 0x5B, 0x27, 0x9F, 0x9B, 0xC0, 0x91, 0x27, 0x9F, 0x5B, 0x07, 0x0D, 0x28, 0x27, 0x9F, 0x45, 0x9B, +/* 1480 */ 0x05, 0x10, 0x07, 0x2C, 0x72, 0x68, 0x07, 0x06, 0x19, 0x9C, 0x0B, 0x80, 0x00, 0xDC, 0x23, 0x19, +/* 1490 */ 0xD2, 0xB5, 0x10, 0x08, 0x37, 0x72, 0xDD, 0x8E, 0x06, 0x72, 0x48, 0x30, 0xE6, 0xB2, 0xC5, 0x10, +/* 14A0 */ 0x08, 0x1F, 0x1B, 0x5D, 0xA0, 0x30, 0x9E, 0x93, 0x42, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x19, 0x26, +/* 14B0 */ 0x73, 0x74, 0x9F, 0x94, 0x97, 0x19, 0x9F, 0x4E, 0x30, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x1B, 0x89, +/* 14C0 */ 0x06, 0x08, 0x37, 0x9F, 0x97, 0x4D, 0x00, 0xDC, 0xC0, 0x42, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x1B, +/* 14D0 */ 0x2F, 0xC3, 0x80, 0x0B, 0x0D, 0x26, 0x9F, 0x30, 0xE6, 0xB2, 0xC5, 0x10, 0x06, 0x18, 0x32, 0x02, +/* 14E0 */ 0x07, 0x0B, 0xDC, 0x61, 0x4D, 0x19, 0x96, 0xA5, 0x30, 0x03, 0x91, 0x68, 0xDC, 0x07, 0x7B, 0x06, +/* 14F0 */ 0x10, 0x08, 0x2A, 0x65, 0x04, 0x5A, 0x3C, 0x0E, 0x19, 0xA0, 0xE0, 0x01, 0x7C, 0x62, 0x70, 0x2C, +/* 1500 */ 0x76, 0x03, 0x6B, 0x0E, 0x2C, 0x09, 0x80, 0x07, 0x08, 0x0C, 0x3E, 0x27, 0x09, 0x80, 0x93, 0x0B, +/* 1510 */ 0x3D, 0x27, 0xA3, 0xA1, 0x01, 0x0C, 0x88, 0x5A, 0x96, 0x91, 0x0B, 0x39, 0x0E, 0x2C, 0x56, 0x73, +/* 1520 */ 0x0A, 0x70, 0x38, 0x45, 0xA7, 0x00, 0x59, 0x3D, 0x72, 0x06, 0x10, 0x07, 0x1B, 0x30, 0x27, 0x89, +/* 1530 */ 0x04, 0xD1, 0x9A, 0x36, 0xB9, 0x10, 0x07, 0x1F, 0x1B, 0x30, 0xC3, 0x68, 0x1C, 0x0B, 0x83, 0x36, +/* 1540 */ 0xB9, 0x10, 0x07, 0x1B, 0x08, 0x4D, 0x42, 0xA1, 0x8E, 0x05, 0xDC, 0x02, 0x00, 0x5E, 0xE9, 0xB9, +/* 1550 */ 0x10, 0x07, 0x1B, 0xC6, 0x01, 0xE9, 0xB9, 0x10, 0x07, 0x19, 0x72, 0x2F, 0x96, 0xA7, 0x42, 0x8B, +/* 1560 */ 0x07, 0x31, 0x7C, 0xD3, 0x6E, 0x79, 0xC7, 0xB6, 0x10, 0x07, 0x25, 0x2B, 0x44, 0x9D, 0x2F, 0xD2, +/* 1570 */ 0xA5, 0x34, 0xA4, 0x92, 0x3E, 0xD6, 0x0A, 0x28, 0x82, 0x09, 0x32, 0x3E, 0x2C, 0x3B, 0x4D, 0x37, +/* 1580 */ 0xA4, 0x04, 0x30, 0x2B, 0x10, 0x07, 0x1D, 0x67, 0x7C, 0x43, 0x2C, 0x9F, 0x0F, 0xE7, 0x70, 0x59, +/* 1590 */ 0x70, 0x04, 0x69, 0x37, 0x99, 0x0A, 0x0C, 0x00, 0xE5, 0x8D, 0x63, 0x99, 0x0B, 0x70, 0x37, 0x99, +/* 15A0 */ 0xEF, 0x3D, 0x2C, 0x99, 0x9E, 0x69, 0x2C, 0x99, 0x05, 0x0C, 0x28, 0x2C, 0x7A, 0x48, 0xA7, 0x10, +/* 15B0 */ 0x06, 0x1D, 0x4E, 0x0B, 0x02, 0xD1, 0x4B, 0x21, 0xC0, 0x30, 0xAE, 0xC4, 0x10, 0x06, 0x1D, 0x5F, +/* 15C0 */ 0x0B, 0x31, 0x96, 0x9B, 0x02, 0xE4, 0x04, 0x1C, 0xAE, 0xC4, 0x10, 0x06, 0x1D, 0x9F, 0x7F, 0x2F, +/* 15D0 */ 0xE7, 0xA6, 0x26, 0xC3, 0x19, 0xAE, 0xC4, 0x10, 0x06, 0x1A, 0x64, 0x6D, 0xA3, 0xDF, 0x5C, 0xEB, +/* 15E0 */ 0xAE, 0xC4, 0x10, 0x06, 0xCF, 0x02, 0x70, 0xDA, 0xCD, 0xAE, 0xC4, 0x10, 0x06, 0x1B, 0x2F, 0xC3, +/* 15F0 */ 0xA5, 0x03, 0x00, 0x3C, 0xA6, 0x07, 0x5A, 0x82, 0x28, 0xD1, 0x03, 0x42, 0xAE, 0xC4, 0x10, 0x09, +/* 1600 */ 0x20, 0x01, 0x0B, 0x7F, 0x06, 0x41, 0x43, 0x5A, 0x66, 0x48, 0x5B, 0x62, 0x53, 0x24, 0x4D, 0x02, +/* 1610 */ 0x6B, 0x5A, 0x8B, 0x45, 0xF3, 0xF5, 0x66, 0x4D, 0x08, 0x91, 0x05, 0x5C, 0x5A, 0x86, 0x81, 0xA5, +/* 1620 */ 0x07, 0x0A, 0x05, 0x65, 0x6E, 0x83, 0x0C, 0x9B, 0x04, 0x10, 0x05, 0x46, 0x4F, 0x43, 0x3F, 0x5B, +/* 1630 */ 0x07, 0x09, 0x19, 0xBB, 0x3C, 0x80, 0x42, 0x9E, 0x70, 0xAC, 0x03, 0x45, 0x61, 0x79, 0x38, 0x89, +/* 1640 */ 0x07, 0x1C, 0x78, 0x04, 0xD1, 0x0C, 0xBF, 0x3A, 0x07, 0xD1, 0x03, 0x10, 0x06, 0x1A, 0x93, 0x1C, +/* 1650 */ 0xA0, 0x8C, 0x65, 0x03, 0x42, 0x4F, 0x08, 0xB0, 0xBE, 0x10, 0x06, 0x1A, 0x02, 0xC2, 0x96, 0x0D, +/* 1660 */ 0xA7, 0xB0, 0xBE, 0x10, 0x06, 0x1D, 0x4E, 0x6B, 0xD4, 0x3F, 0xC3, 0x42, 0x4F, 0x08, 0xB0, 0xBE, +/* 1670 */ 0x10, 0x06, 0xCF, 0x00, 0x87, 0xED, 0xCD, 0x96, 0x0D, 0xA7, 0xB0, 0xBE, 0x10, 0x03, 0x1D, 0x06, +/* 1680 */ 0x08, 0x1C, 0x95, 0x29, 0x01, 0x72, 0x21, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x1D, 0x96, 0x08, +/* 1690 */ 0x1C, 0x0B, 0x9D, 0x00, 0x44, 0xDD, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x1D, 0x07, 0x4D, 0x26, +/* 16A0 */ 0x0E, 0x8E, 0x05, 0x19, 0x23, 0x7B, 0x6D, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x33, 0x1B, 0xC6, +/* 16B0 */ 0x31, 0x35, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x06, 0x1D, 0x95, 0x7D, 0x04, 0x42, 0x4B, 0x3D, 0x42, +/* 16C0 */ 0x78, 0x7F, 0x31, 0x9F, 0x7A, 0x8C, 0x0B, 0x5B, 0x73, 0xE5, 0x0A, 0x8D, 0x6A, 0x39, 0x6A, 0x00, +/* 16D0 */ 0x29, 0x38, 0x73, 0xA3, 0x8C, 0x85, 0x94, 0x10, 0x06, 0x1A, 0x60, 0x1F, 0xE5, 0x5B, 0x79, 0x38, +/* 16E0 */ 0x5C, 0x31, 0x76, 0x6E, 0xA9, 0x10, 0x06, 0x1A, 0x93, 0x72, 0x0B, 0x4D, 0x1C, 0x9F, 0x04, 0x42, +/* 16F0 */ 0xB3, 0x10, 0x06, 0x1A, 0x40, 0x03, 0xE4, 0x7F, 0x05, 0x42, 0x6C, 0x33, 0xB3, 0x10, 0x06, 0x1A, +/* 1700 */ 0x0B, 0x3D, 0x00, 0x3C, 0x97, 0x0E, 0x31, 0x84, 0xC0, 0x42, 0xB3, 0x10, 0x06, 0x1A, 0x60, 0x1F, +/* 1710 */ 0xE5, 0xA5, 0x79, 0x38, 0x5C, 0x6D, 0xB3, 0x10, 0x06, 0x1F, 0x2A, 0xAC, 0x4C, 0x0B, 0x05, 0x80, +/* 1720 */ 0x19, 0x64, 0xC0, 0x2C, 0x1B, 0xB3, 0x10, 0x06, 0x1A, 0xDD, 0x02, 0x55, 0x72, 0x0D, 0x53, 0x1B, +/* 1730 */ 0xC9, 0x19, 0xF0, 0x3E, 0x2C, 0x9F, 0x58, 0x2F, 0xDD, 0x02, 0x55, 0x72, 0x97, 0x10, 0x06, 0x1F, +/* 1740 */ 0x98, 0x6C, 0x79, 0x44, 0x3E, 0x37, 0x96, 0x7C, 0xD8, 0x7B, 0x73, 0x0D, 0x91, 0x54, 0x32, 0x0B, +/* 1750 */ 0x6A, 0x0A, 0x0A, 0x71, 0x62, 0xC4, 0x41, 0x37, 0x49, 0x9D, 0x9D, 0x19, 0xA3, 0x87, 0x74, 0x66, +/* 1760 */ 0x0B, 0x00, 0xD1, 0x04, 0x10, 0x06, 0x1A, 0x0A, 0x5D, 0x8B, 0x70, 0x00, 0xD1, 0x03, 0x19, 0x4A, +/* 1770 */ 0xB1, 0x9D, 0x10, 0x06, 0x1A, 0x02, 0xC2, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0x1D, 0x4E, 0x6E, 0xD4, +/* 1780 */ 0x3F, 0xC3, 0x19, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0xCF, 0x01, 0x94, 0xED, 0xCD, 0x4A, 0xB1, 0x9D, +/* 1790 */ 0x10, 0x06, 0x1D, 0xC3, 0xBF, 0x95, 0x73, 0x02, 0xE4, 0x5D, 0x0E, 0xBA, 0xF1, 0x10, 0x07, 0x1D, +/* 17A0 */ 0xCB, 0x61, 0xD5, 0x7B, 0x08, 0x03, 0x10, 0x06, 0xCF, 0x04, 0x69, 0x41, 0x26, 0x01, 0x02, 0x5D, +/* 17B0 */ 0x1C, 0x39, 0xBA, 0xF1, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x17, 0x00, 0x0D, 0x06, 0x18, 0x64, +/* 17C0 */ 0x64, 0x64, 0x2C, 0x4C, 0x8A, 0xA5, 0x38, 0x58, 0x04, 0x10, 0x06, 0x18, 0xC9, 0x74, 0xEC, 0x70, +/* 17D0 */ 0x38, 0x58, 0x02, 0x10, 0x09, 0x18, 0xC9, 0x64, 0x5E, 0x5A, 0xEC, 0x8A, 0x70, 0x00, 0xC3, 0x05, +/* 17E0 */ 0x5C, 0x58, 0x02, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x05, 0xB2, +/* 17F0 */ 0x00, 0x00, 0x05, 0xB4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x05, 0xB7, +/* 1800 */ 0x00, 0x00, 0x06, 0x75, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x0F, 0x43, +/* 1810 */ 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x17, 0xB5, +/* 1820 */ 0x00, 0x00, 0x17, 0xBD, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold14.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold14.mcufont.h new file mode 100644 index 000000000..2b1cd65c2 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold14.mcufont.h @@ -0,0 +1,464 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 14 + * blob size: 7066, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0xF6, 0x00, 0x00, 0x04, 0x6B, 0x00, 0x00, 0x00, 0x91, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x1B, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0E, 0x00, 0x13, 0x00, 0x03, 0x00, 0x0D, 0x00, 0x01, 0x00, 0x0F, 0x00, 0x11, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x34, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x31, 0x34, 0x00, +/* dictionary data */ +0x03, 0x06, 0x80, 0xC9, 0x06, 0xC6, 0x80, 0xCD, 0x02, 0xCA, 0x80, +/* 0080 */ 0xC9, 0x06, 0xC6, 0x80, 0xCD, 0x01, 0x0C, 0x15, 0x80, 0x01, 0x05, 0x09, 0xFA, 0xCA, 0xEA, 0x04, +/* 0090 */ 0xCC, 0x81, 0xDA, 0x0A, 0xC4, 0x80, 0xCE, 0xC1, 0x05, 0xC1, 0x08, 0x3A, 0x07, 0xCD, 0x0B, 0x06, +/* 00A0 */ 0xC4, 0x80, 0x07, 0xC6, 0xCD, 0x01, 0xC5, 0x0B, 0x02, 0x40, 0x23, 0xCE, 0xC7, 0xC4, 0x06, 0x01, +/* 00B0 */ 0xC5, 0x80, 0x01, 0xC9, 0x05, 0xC8, 0x80, 0x80, 0xC3, 0xCC, 0x0B, 0x40, 0x30, 0x02, 0xC4, 0x80, +/* 00C0 */ 0x07, 0xC3, 0x0B, 0x2D, 0xC4, 0x0A, 0xCE, 0x0B, 0xC3, 0x80, 0x07, 0xC5, 0x0F, 0xC3, 0x07, 0x01, +/* 00D0 */ 0xCD, 0xCD, 0xC1, 0x40, 0x08, 0x2C, 0xC9, 0x80, 0xC1, 0xCD, 0x09, 0xC4, 0x81, 0x06, 0x80, 0xC9, +/* 00E0 */ 0xC3, 0xCC, 0x80, 0x02, 0xC4, 0x0B, 0xCE, 0xCB, 0xC1, 0xCE, 0xCA, 0xCE, 0xC9, 0xC5, 0x05, 0xC4, +/* 00F0 */ 0x81, 0x02, 0x80, 0xCD, 0x08, 0xCA, 0x0B, 0x39, 0xCD, 0x80, 0xC1, 0x80, 0xCA, 0xCD, 0xDD, 0xC8, +/* 0100 */ 0x80, 0xC1, 0xC9, 0xC2, 0x81, 0x81, 0xCB, 0xC8, 0x07, 0xC4, 0x80, 0x01, 0xCA, 0x80, 0xC4, 0x01, +/* 0110 */ 0xC4, 0xCA, 0x80, 0xC5, 0xC6, 0xCE, 0xC2, 0xC9, 0x80, 0xC6, 0xDE, 0xC7, 0xCD, 0xCD, 0xCE, 0xC9, +/* 0120 */ 0xC2, 0x80, 0xC7, 0x82, 0xCA, 0x07, 0xD6, 0xCB, 0x0B, 0x80, 0xCB, 0x80, 0xC2, 0x40, 0x07, 0x0E, +/* 0130 */ 0xCB, 0x01, 0x01, 0xC2, 0xCE, 0x80, 0xCB, 0xCC, 0x01, 0xC1, 0x1F, 0xCE, 0x80, 0xC3, 0xCA, 0xC3, +/* 0140 */ 0x01, 0xC3, 0xC8, 0x08, 0xC3, 0x09, 0xC2, 0xCE, 0xC1, 0xCC, 0x80, 0xC5, 0xC6, 0xCD, 0xCE, 0xC3, +/* 0150 */ 0x0B, 0xC9, 0xC1, 0xCB, 0xC3, 0x0B, 0xCE, 0xC2, 0xCE, 0xCC, 0xC9, 0xC7, 0xC7, 0x80, 0xCD, 0x01, +/* 0160 */ 0xCB, 0x84, 0xC9, 0xC1, 0xCC, 0xC1, 0x80, 0xC8, 0xC7, 0x80, 0x11, 0x80, 0xCA, 0xCB, 0xCD, 0xCB, +/* 0170 */ 0xCE, 0x01, 0xC6, 0xC5, 0x80, 0xC1, 0xC3, 0xC8, 0xC2, 0x01, 0xCE, 0x80, 0xC4, 0xCC, 0x2B, 0x01, +/* 0180 */ 0xCC, 0xC1, 0x0B, 0xCA, 0xCC, 0x17, 0xC7, 0xCE, 0x80, 0xCC, 0x80, 0xCE, 0xCE, 0x80, 0xC6, 0x3D, +/* 0190 */ 0xCB, 0x81, 0x80, 0xC1, 0x4D, 0x4A, 0x53, 0x4A, 0x53, 0x1F, 0xA3, 0x0E, 0x54, 0x2D, 0x54, 0x34, +/* 01A0 */ 0x0D, 0x2A, 0x08, 0x94, 0x64, 0x54, 0x2A, 0x08, 0x06, 0x0F, 0x2E, 0x62, 0x1A, 0x62, 0x1A, 0x62, +/* 01B0 */ 0x1A, 0x62, 0x4B, 0x2C, 0xA8, 0x9E, 0x91, 0x19, 0x44, 0x54, 0x6D, 0x5E, 0x18, 0x64, 0x54, 0x62, +/* 01C0 */ 0x6D, 0x5E, 0x18, 0x64, 0x54, 0x62, 0x0D, 0x6D, 0x00, 0x9E, 0x6D, 0x19, 0x07, 0xA3, 0x77, 0xA4, +/* 01D0 */ 0x01, 0x19, 0x50, 0x73, 0x07, 0x0F, 0x88, 0x0B, 0xA4, 0x7F, 0x01, 0x58, 0x96, 0x6D, 0x2D, 0xA3, +/* 01E0 */ 0x34, 0x0D, 0x2A, 0x08, 0x94, 0x7E, 0x5F, 0x2A, 0x08, 0x94, 0x7E, 0x5F, 0x2D, 0xA3, 0x34, 0x0D, +/* 01F0 */ 0x2A, 0x50, 0x72, 0x78, 0x5F, 0x3E, 0x78, 0x91, 0x30, 0x3B, 0x94, 0xA3, 0x1F, 0x92, 0x84, 0xA8, +/* 0200 */ 0x2A, 0x8D, 0x78, 0x2F, 0x78, 0x2F, 0x00, 0x08, 0x4B, 0x19, 0x62, 0x68, 0x8D, 0x83, 0x2A, 0x07, +/* 0210 */ 0x4B, 0x9B, 0x01, 0x3B, 0x72, 0x02, 0xA3, 0x1F, 0x69, 0x98, 0x7F, 0x8D, 0x4B, 0x63, 0x1F, 0x07, +/* 0220 */ 0xA4, 0xA8, 0x1F, 0x40, 0x72, 0x86, 0x68, 0x30, 0x3B, 0x0A, 0x0F, 0x90, 0x30, 0x41, 0x0D, 0x8F, +/* 0230 */ 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91, +/* 0240 */ 0x41, 0x54, 0x8D, 0x91, 0x3B, 0x5F, 0xA7, 0x7F, 0x09, 0x8A, 0x08, 0xA3, 0x04, 0x55, 0x9E, 0x0B, +/* 0250 */ 0x0B, 0xA4, 0x9F, 0x7C, 0x55, 0x08, 0x0D, 0x5F, 0x37, 0x2D, 0xA4, 0x0A, 0x5F, 0x43, 0x0A, 0x6D, +/* 0260 */ 0x9B, 0x43, 0x5C, 0x8A, 0x0F, 0x6D, 0x2A, 0x87, 0x4F, 0x4C, 0x2F, 0x7B, 0x08, 0x0D, 0x54, 0x07, +/* 0270 */ 0x2A, 0x62, 0xA4, 0x96, 0x6D, 0x65, 0x3C, 0x65, 0x3C, 0x65, 0x0F, 0x63, 0x00, 0x08, 0x25, 0x34, +/* 0280 */ 0x09, 0x2C, 0xA4, 0x01, 0x05, 0x4B, 0x2C, 0x0E, 0x83, 0x05, 0x4B, 0x2C, 0x0B, 0x0F, 0x52, 0x4B, +/* 0290 */ 0x2C, 0x0A, 0x6B, 0x05, 0x4B, 0x2C, 0x60, 0x91, 0x4B, 0x2C, 0x0B, 0x04, 0x72, 0x4B, 0x2C, 0x76, +/* 02A0 */ 0x69, 0x4B, 0x2C, 0x0B, 0x62, 0x0F, 0x4B, 0x2C, 0x0B, 0x34, 0x2A, 0x92, 0x98, 0x38, 0x98, 0x38, +/* 02B0 */ 0x98, 0x38, 0x6E, 0x37, 0x61, 0x0F, 0x21, 0x01, 0x30, 0x53, 0x4A, 0x18, 0x3A, 0x6E, 0x6F, 0x64, +/* 02C0 */ 0x5F, 0x24, 0x06, 0x18, 0x53, 0x4A, 0x22, 0x64, 0x5F, 0x21, 0x02, 0x61, 0x6E, 0x63, 0x57, 0x65, +/* 02D0 */ 0x2A, 0x9B, 0x97, 0x4B, 0x61, 0x6E, 0x54, 0x2A, 0x08, 0x54, 0x24, 0x0F, 0x73, 0x1E, 0x8D, 0x68, +/* 02E0 */ 0x00, 0x44, 0x83, 0x1E, 0x59, 0x37, 0x00, 0x62, 0x4B, 0x47, 0x74, 0x26, 0x01, 0x01, 0x7A, 0x28, +/* 02F0 */ 0x55, 0x40, 0x2B, 0x26, 0x2B, 0x26, 0x2B, 0x26, 0x30, 0x97, 0x8E, 0x43, 0x04, 0xA0, 0x72, 0x0A, +/* 0300 */ 0x02, 0x22, 0x36, 0x33, 0x36, 0x26, 0x71, 0x26, 0x76, 0x4B, 0x3C, 0x91, 0x25, 0x62, 0x91, 0x25, +/* 0310 */ 0x62, 0x18, 0x97, 0x01, 0x1E, 0x66, 0x0D, 0x18, 0x05, 0x37, 0x22, 0x05, 0x69, 0x0D, 0x30, 0x9E, +/* 0320 */ 0x0B, 0x1E, 0x77, 0x95, 0x3A, 0x04, 0x2A, 0x8A, 0x02, 0x61, 0x0F, 0x6B, 0x91, 0x61, 0x0E, 0x26, +/* 0330 */ 0x2E, 0x5C, 0x6F, 0x00, 0x46, 0x08, 0x94, 0x00, 0x53, 0x08, 0x94, 0x00, 0x53, 0x08, 0x94, 0x00, +/* 0340 */ 0x53, 0x5C, 0x0A, 0x72, 0x25, 0x77, 0x25, 0x59, 0x37, 0x34, 0x27, 0x8C, 0x30, 0x59, 0x63, 0x36, +/* 0350 */ 0x0C, 0x18, 0xA5, 0x36, 0x0C, 0x18, 0xA5, 0x1E, 0x8C, 0x30, 0x59, 0x63, 0x1E, 0x40, 0x37, 0x34, +/* 0360 */ 0x27, 0x62, 0xA4, 0x96, 0x6D, 0x55, 0x08, 0x0D, 0x54, 0x06, 0x18, 0x08, 0x0E, 0x01, 0x98, 0x96, +/* 0370 */ 0x45, 0x18, 0x7A, 0x32, 0x97, 0x6E, 0x73, 0x22, 0xA2, 0x01, 0x22, 0x0E, 0x2C, 0x1D, 0x0E, 0x72, +/* 0380 */ 0x1F, 0x62, 0x5F, 0x3E, 0x98, 0x3F, 0x98, 0x3F, 0x54, 0x06, 0x00, 0x5C, 0x71, 0x86, 0x68, 0x86, +/* 0390 */ 0x68, 0x86, 0x68, 0x86, 0x68, 0x86, 0x20, 0x00, 0x2D, 0x8E, 0x30, 0x19, 0x40, 0x05, 0xA3, 0x35, +/* 03A0 */ 0x91, 0x09, 0x91, 0x00, 0x19, 0x77, 0x51, 0x8A, 0x4E, 0x42, 0x0D, 0x19, 0x7A, 0x5F, 0x96, 0x54, +/* 03B0 */ 0x55, 0x66, 0x5C, 0x80, 0x9E, 0x72, 0x80, 0x64, 0x02, 0x0F, 0x54, 0x6C, 0x61, 0x94, 0x30, 0x28, +/* 03C0 */ 0x4C, 0x2F, 0x48, 0x38, 0x04, 0x32, 0x8A, 0x02, 0x61, 0xA3, 0x0D, 0x72, 0x61, 0x0E, 0x99, 0x5F, +/* 03D0 */ 0x61, 0x2E, 0x59, 0x73, 0x2C, 0x2E, 0x59, 0x73, 0x2C, 0x0E, 0x64, 0xA4, 0x61, 0xA3, 0x58, 0x6F, +/* 03E0 */ 0x04, 0xA4, 0x0A, 0x4F, 0x01, 0x61, 0x2B, 0x04, 0x54, 0x2A, 0x2A, 0x35, 0x6D, 0x0C, 0x73, 0x2A, +/* 03F0 */ 0x77, 0x0F, 0x07, 0x22, 0x41, 0x73, 0x3C, 0x08, 0x71, 0x55, 0x0D, 0x55, 0x49, 0x0B, 0x49, 0x0B, +/* 0400 */ 0x0B, 0x09, 0x22, 0x2D, 0x5F, 0x3C, 0x81, 0x56, 0x75, 0x2B, 0x04, 0x54, 0x55, 0x06, 0x55, 0x4C, +/* 0410 */ 0x0F, 0x09, 0x55, 0x3C, 0x65, 0x3C, 0x65, 0x22, 0x00, 0x26, 0x55, 0x7A, 0x03, 0x55, 0x05, 0x0E, +/* 0420 */ 0x31, 0x26, 0x3D, 0x7A, 0x37, 0x00, 0x3B, 0x0B, 0xA4, 0x8F, 0x0E, 0x01, 0x6B, 0x28, 0x95, 0x1F, +/* 0430 */ 0x77, 0x23, 0x02, 0x04, 0x6D, 0x3F, 0x40, 0x0B, 0x02, 0x25, 0x44, 0x6D, 0x86, 0x85, 0x02, 0x72, +/* 0440 */ 0x55, 0x49, 0x06, 0x72, 0x2C, 0x2E, 0x06, 0x94, 0x3F, 0x98, 0x3F, 0xA3, 0x05, 0x55, 0x50, 0x72, +/* 0450 */ 0x7C, 0x2D, 0x94, 0x97, 0x4B, 0x30, 0x36, 0x6E, 0x72, 0x2A, 0x08, 0x54, 0x21, 0x07, 0x2D, 0xA3, +/* 0460 */ 0x30, 0x28, 0x50, 0xA3, 0x0B, 0x91, 0x2A, 0x25, 0x40, 0x08, 0x68, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, 0x00, +/* 0470 */ 0x02, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x19, 0x00, +/* 0480 */ 0x1A, 0x00, 0x1B, 0x00, 0x1D, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x21, 0x00, 0x24, 0x00, 0x26, 0x00, +/* 0490 */ 0x27, 0x00, 0x28, 0x00, 0x2A, 0x00, 0x2D, 0x00, 0x2F, 0x00, 0x31, 0x00, 0x33, 0x00, 0x34, 0x00, +/* 04A0 */ 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x42, 0x00, 0x44, 0x00, 0x46, 0x00, +/* 04B0 */ 0x48, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4E, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x53, 0x00, 0x55, 0x00, +/* 04C0 */ 0x57, 0x00, 0x58, 0x00, 0x5A, 0x00, 0x5C, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x61, 0x00, 0x63, 0x00, +/* 04D0 */ 0x65, 0x00, 0x69, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x73, 0x00, 0x75, 0x00, +/* 04E0 */ 0x77, 0x00, 0x79, 0x00, 0x7D, 0x00, 0x7F, 0x00, 0x80, 0x00, 0x82, 0x00, 0x83, 0x00, 0x85, 0x00, +/* 04F0 */ 0x87, 0x00, 0x89, 0x00, 0x8A, 0x00, 0x8C, 0x00, 0x8E, 0x00, 0x90, 0x00, 0x91, 0x00, 0x93, 0x00, +/* 0500 */ 0x96, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9F, 0x00, 0xA1, 0x00, 0xA3, 0x00, 0xA5, 0x00, +/* 0510 */ 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB2, 0x00, +/* 0520 */ 0xB4, 0x00, 0xB6, 0x00, 0xB8, 0x00, 0xBA, 0x00, 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, +/* 0530 */ 0xC3, 0x00, 0xC5, 0x00, 0xC6, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, +/* 0540 */ 0xD3, 0x00, 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE1, 0x00, +/* 0550 */ 0xE3, 0x00, 0xE5, 0x00, 0xE7, 0x00, 0xEA, 0x00, 0xEC, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, +/* 0560 */ 0xF3, 0x00, 0xF5, 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01, +/* 0570 */ 0x02, 0x01, 0x04, 0x01, 0x07, 0x01, 0x09, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, +/* 0580 */ 0x11, 0x01, 0x13, 0x01, 0x15, 0x01, 0x17, 0x01, 0x1A, 0x01, 0x1B, 0x01, 0x1D, 0x01, 0x1F, 0x01, +/* 0590 */ 0x25, 0x01, 0x33, 0x01, 0x45, 0x01, 0x51, 0x01, 0x60, 0x01, 0x62, 0x01, 0x7F, 0x01, 0x8D, 0x01, +/* 05A0 */ 0x91, 0x01, 0xBB, 0x01, 0xD6, 0x01, 0xF7, 0x02, 0x00, 0x02, 0x05, 0x02, 0x08, 0x02, 0x0A, 0x02, +/* 05B0 */ 0x35, 0x02, 0x37, 0x02, 0x3D, 0x02, 0x5A, 0x02, 0x75, 0x02, 0x77, 0x02, 0x7B, 0x02, 0x7D, 0x02, +/* 05C0 */ 0x83, 0x02, 0x90, 0x02, 0x94, 0x02, 0x96, 0x02, 0x9C, 0x02, 0xB2, 0x02, 0xBA, 0x02, 0xBE, 0x02, +/* 05D0 */ 0xC0, 0x02, 0xCD, 0x02, 0xCF, 0x02, 0xD1, 0x02, 0xD3, 0x02, 0xF6, 0x03, 0x07, 0x03, 0x09, 0x03, +/* 05E0 */ 0x13, 0x03, 0x16, 0x03, 0x18, 0x03, 0x21, 0x03, 0x26, 0x03, 0x28, 0x03, 0x2C, 0x03, 0x2F, 0x03, +/* 05F0 */ 0x35, 0x03, 0x3D, 0x03, 0x44, 0x03, 0x49, 0x03, 0x4B, 0x03, 0x51, 0x03, 0x75, 0x03, 0x7D, 0x03, +/* 0600 */ 0x85, 0x03, 0x8B, 0x03, 0x8D, 0x03, 0x94, 0x03, 0x98, 0x03, 0x9C, 0x03, 0x9E, 0x03, 0xA3, 0x03, +/* 0610 */ 0xA5, 0x03, 0xA7, 0x03, 0xA9, 0x03, 0xAB, 0x03, 0xAD, 0x03, 0xAF, 0x03, 0xB5, 0x03, 0xBA, 0x03, +/* 0620 */ 0xBC, 0x03, 0xBE, 0x03, 0xC0, 0x03, 0xC2, 0x03, 0xC9, 0x03, 0xCB, 0x03, 0xCD, 0x03, 0xCF, 0x03, +/* 0630 */ 0xD1, 0x03, 0xD3, 0x03, 0xD6, 0x03, 0xF0, 0x03, 0xF2, 0x03, 0xF4, 0x03, 0xF6, +/* char range info */ +0x00, 0x00, 0x03, +/* 0640 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x14, 0x00, 0x28, 0x00, 0x51, 0x00, 0x82, 0x00, 0xC4, +/* 0650 */ 0x00, 0xFA, 0x01, 0x07, 0x01, 0x2E, 0x01, 0x53, 0x01, 0x6C, 0x01, 0x76, 0x01, 0x80, 0x01, 0x8B, +/* 0660 */ 0x01, 0x90, 0x01, 0xB0, 0x01, 0xE0, 0x01, 0xF8, 0x02, 0x1B, 0x02, 0x44, 0x02, 0x64, 0x02, 0x90, +/* 0670 */ 0x02, 0xBA, 0x02, 0xD8, 0x03, 0x04, 0x03, 0x33, 0x03, 0x3A, 0x03, 0x46, 0x03, 0x63, 0x03, 0x6B, +/* 0680 */ 0x03, 0x84, 0x03, 0xA0, 0x03, 0xFA, 0x04, 0x01, 0x04, 0x25, 0x04, 0x46, 0x04, 0x68, 0x04, 0x6C, +/* 0690 */ 0x04, 0x86, 0x04, 0xB7, 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xE0, 0x05, 0x06, 0x05, 0x16, 0x05, 0x5A, +/* 06A0 */ 0x05, 0x60, 0x05, 0x66, 0x05, 0x80, 0x05, 0xB6, 0x05, 0xDC, 0x06, 0x09, 0x06, 0x1E, 0x06, 0x24, +/* 06B0 */ 0x06, 0x50, 0x06, 0x97, 0x06, 0xC0, 0x06, 0xC9, 0x06, 0xED, 0x06, 0xFF, 0x07, 0x22, 0x07, 0x3B, +/* 06C0 */ 0x07, 0x53, 0x07, 0x5D, 0x07, 0x6A, 0x07, 0x70, 0x07, 0x96, 0x07, 0xB3, 0x07, 0xCB, 0x07, 0xD2, +/* 06D0 */ 0x07, 0xF5, 0x08, 0x2C, 0x08, 0x3D, 0x08, 0x47, 0x08, 0x5B, 0x08, 0x81, 0x08, 0x8F, 0x08, 0xAB, +/* 06E0 */ 0x08, 0xB8, 0x08, 0xBF, 0x08, 0xC7, 0x08, 0xE0, 0x08, 0xF2, 0x09, 0x13, 0x09, 0x33, 0x09, 0x39, +/* 06F0 */ 0x09, 0x59, 0x09, 0x8D, 0x09, 0xB0, 0x09, 0xB5, 0x09, 0xD2, 0x09, 0xF4, 0x09, 0xFE, 0x0A, 0x24, +/* 0700 */ 0x03, 0x00, 0x10, 0x03, 0x74, 0xD3, 0x92, 0x56, 0x06, 0xC4, 0x06, 0xC4, 0x05, 0x91, 0x3C, 0xF3, +/* 0710 */ 0x30, 0xA1, 0xDE, 0x10, 0x06, 0x74, 0x05, 0x6D, 0x5C, 0x33, 0x3A, 0x06, 0x92, 0x43, 0x7E, 0x83, +/* 0720 */ 0x06, 0x73, 0x2A, 0x77, 0x63, 0x05, 0x73, 0x10, 0x07, 0x46, 0xF3, 0xF3, 0x00, 0x41, 0x83, 0x06, +/* 0730 */ 0x83, 0x41, 0x8E, 0x0E, 0x3B, 0x58, 0x5A, 0x4B, 0x2A, 0x8D, 0x1D, 0x96, 0x1F, 0x5B, 0x44, 0x0C, +/* 0740 */ 0x55, 0x08, 0xA4, 0x0A, 0xA4, 0x33, 0x9E, 0x8E, 0x07, 0x3B, 0x91, 0xF3, 0x2A, 0x34, 0x70, 0x83, +/* 0750 */ 0x10, 0x07, 0x1C, 0xFE, 0x2F, 0x03, 0x83, 0x25, 0x67, 0x72, 0xEB, 0x81, 0x6E, 0x37, 0xBA, 0x0C, +/* 0760 */ 0x99, 0x7F, 0x5C, 0x38, 0x26, 0xD2, 0x1F, 0xEC, 0x5F, 0x90, 0x25, 0x66, 0x6D, 0x86, 0x94, 0x19, +/* 0770 */ 0x64, 0x0A, 0x02, 0x82, 0xFD, 0x48, 0x6E, 0x89, 0x00, 0x41, 0x0A, 0x94, 0x02, 0xFE, 0x2F, 0x03, +/* 0780 */ 0x83, 0x10, 0x0B, 0x00, 0x93, 0xEE, 0x19, 0x35, 0x8A, 0x03, 0x30, 0xA0, 0x1E, 0xF8, 0x0E, 0x76, +/* 0790 */ 0xF3, 0x36, 0x35, 0x0E, 0x00, 0x5B, 0x19, 0xF8, 0x4F, 0x07, 0x83, 0x19, 0x62, 0x8A, 0x04, 0x4F, +/* 07A0 */ 0x06, 0x09, 0x04, 0x2A, 0x62, 0x94, 0x5F, 0x37, 0x2C, 0x08, 0x0D, 0x0B, 0x50, 0x08, 0x19, 0x5B, +/* 07B0 */ 0x49, 0x0A, 0x00, 0x0E, 0x09, 0x1E, 0x07, 0x83, 0x62, 0x4F, 0x68, 0x22, 0x9E, 0x76, 0x77, 0x96, +/* 07C0 */ 0x09, 0x19, 0x7A, 0x10, 0x0A, 0x74, 0x7A, 0x0A, 0x69, 0x0A, 0x28, 0x48, 0x5B, 0x4B, 0x2A, 0x8D, +/* 07D0 */ 0x83, 0x98, 0x76, 0xBA, 0x09, 0x0A, 0x6D, 0x1F, 0x23, 0x09, 0x7A, 0x2D, 0x5F, 0x94, 0x00, 0x5B, +/* 07E0 */ 0x1E, 0x59, 0x63, 0x0A, 0xA3, 0x91, 0x1E, 0x40, 0xA8, 0x8D, 0x0F, 0x73, 0x1E, 0x50, 0x54, 0x51, +/* 07F0 */ 0x5F, 0x90, 0x22, 0x7E, 0x0B, 0x69, 0x6C, 0x0B, 0x8F, 0x10, 0x03, 0x74, 0x05, 0x6D, 0x25, 0x64, +/* 0800 */ 0x68, 0x22, 0x3B, 0x83, 0xCC, 0x63, 0x10, 0x04, 0x47, 0x62, 0x07, 0x25, 0x34, 0x71, 0x0C, 0x37, +/* 0810 */ 0xFE, 0x2B, 0x08, 0xC4, 0x0A, 0x6D, 0x25, 0x9E, 0x68, 0x25, 0x9E, 0x68, 0x25, 0x8D, 0x6D, 0x19, +/* 0820 */ 0x36, 0xB8, 0xE9, 0x38, 0x44, 0x73, 0x22, 0x2D, 0xC4, 0x9E, 0x09, 0x18, 0xEA, 0x10, 0x04, 0x9D, +/* 0830 */ 0x05, 0x0B, 0x1B, 0x08, 0x6D, 0x3C, 0x50, 0x27, 0x1E, 0x62, 0x68, 0x3C, 0xFA, 0x1E, 0xF9, 0xFE, +/* 0840 */ 0x1D, 0xFE, 0x0F, 0x22, 0x61, 0x3F, 0xF8, 0x86, 0x6D, 0x3C, 0x0E, 0x73, 0x18, 0x2D, 0xC4, 0xA2, +/* 0850 */ 0x9F, 0x7A, 0x10, 0x06, 0x00, 0x29, 0x4F, 0x1F, 0x64, 0x9C, 0x0A, 0x06, 0x43, 0x62, 0x6E, 0xFD, +/* 0860 */ 0x7A, 0x5C, 0x68, 0x28, 0x81, 0x95, 0x45, 0x1F, 0x08, 0x04, 0x70, 0x10, 0x07, 0xA1, 0xC9, 0x36, +/* 0870 */ 0x33, 0x36, 0x33, 0xC2, 0x04, 0x10, 0x03, 0x74, 0x39, 0x05, 0x32, 0x3C, 0xD3, 0x40, 0xE1, 0x10, +/* 0880 */ 0x05, 0x75, 0x39, 0x64, 0x21, 0x06, 0x30, 0x2D, 0x5F, 0x94, 0x10, 0x03, 0x57, 0x39, 0xDE, 0x10, +/* 0890 */ 0x07, 0xEE, 0x04, 0x9F, 0x05, 0xC4, 0x48, 0x2F, 0x0D, 0x73, 0xCD, 0x2B, 0x98, 0x56, 0xFF, 0x25, +/* 08A0 */ 0x9E, 0x73, 0xCD, 0x3F, 0x26, 0x56, 0x08, 0x6D, 0x25, 0x8D, 0xAE, 0x0F, 0x3F, 0x64, 0x05, 0x10, +/* 08B0 */ 0x08, 0x74, 0x7A, 0x51, 0x32, 0x55, 0x8D, 0xA3, 0x0D, 0x83, 0x19, 0x77, 0xA4, 0x34, 0x0C, 0x41, +/* 08C0 */ 0xA3, 0x00, 0x5E, 0xBA, 0x76, 0x5E, 0x01, 0x19, 0x92, 0x76, 0x5E, 0x01, 0x19, 0x05, 0xA3, 0x00, +/* 08D0 */ 0x5E, 0x19, 0x77, 0xA4, 0x34, 0x0C, 0x2A, 0x8D, 0xA3, 0x0D, 0x68, 0x2A, 0x7A, 0x51, 0x32, 0x10, +/* 08E0 */ 0x06, 0x74, 0x7A, 0x0A, 0xA4, 0x55, 0x64, 0x58, 0xA4, 0x55, 0x35, 0x4B, 0xA4, 0x1F, 0x99, 0x40, +/* 08F0 */ 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0x0E, 0x10, 0x06, 0xA6, 0xF1, 0x0A, 0x69, 0x8F, 0x2A, 0x9E, +/* 0900 */ 0x72, 0x78, 0x6F, 0x77, 0x04, 0x34, 0xFB, 0x0A, 0x4B, 0x1F, 0x34, 0x27, 0x22, 0x81, 0x63, 0x00, +/* 0910 */ 0xF7, 0x68, 0x1F, 0x35, 0xA4, 0x21, 0x01, 0x19, 0x8D, 0x8E, 0x10, 0x07, 0xA6, 0xF1, 0x0A, 0x69, +/* 0920 */ 0x0A, 0x28, 0xCB, 0x0D, 0x72, 0x55, 0x99, 0x00, 0x40, 0x3F, 0xF8, 0x25, 0x0E, 0x72, 0x01, 0x25, +/* 0930 */ 0x5A, 0xC4, 0x59, 0x73, 0x2A, 0x99, 0x7A, 0x5F, 0x43, 0x0C, 0x0E, 0x95, 0xA3, 0x00, 0x3B, 0x0B, +/* 0940 */ 0x69, 0x0A, 0x02, 0x10, 0x07, 0x46, 0x97, 0x6C, 0x25, 0x9E, 0x63, 0xFE, 0x2B, 0x5C, 0xB8, 0x9B, +/* 0950 */ 0x02, 0x0C, 0x1D, 0x61, 0x0C, 0x9B, 0x2A, 0x35, 0x54, 0x0A, 0x0F, 0x4B, 0x19, 0x62, 0x8E, 0x3F, +/* 0960 */ 0x5F, 0x1B, 0x5F, 0x10, 0x07, 0xBE, 0x6E, 0x1D, 0x61, 0x0E, 0x24, 0x7F, 0x26, 0x71, 0x04, 0x54, +/* 0970 */ 0x08, 0x9A, 0x00, 0x61, 0x6E, 0x45, 0x19, 0x7A, 0x05, 0x03, 0x81, 0x83, 0x25, 0x8D, 0x6D, 0x2A, +/* 0980 */ 0x64, 0x00, 0x44, 0x83, 0x2A, 0x48, 0x79, 0x0F, 0x45, 0x19, 0x7A, 0x0A, 0x69, 0x0A, 0x02, 0x10, +/* 0990 */ 0x07, 0xC9, 0x84, 0x4F, 0x28, 0x06, 0xA4, 0x0A, 0x0B, 0x55, 0x9B, 0x80, 0x64, 0x54, 0xCB, 0x01, +/* 09A0 */ 0x2D, 0x0F, 0xA3, 0x58, 0x6F, 0x8C, 0x64, 0xA4, 0x41, 0xA3, 0x00, 0x5E, 0x3B, 0xA4, 0x34, 0x0D, +/* 09B0 */ 0x2A, 0x9E, 0xA3, 0x0E, 0x6D, 0x2A, 0x77, 0x96, 0x32, 0x10, 0x06, 0x74, 0x0D, 0x6E, 0xA3, 0x55, +/* 09C0 */ 0x08, 0x0A, 0xA0, 0x72, 0x25, 0x8D, 0x68, 0xF1, 0x0F, 0xA8, 0x18, 0xBA, 0x56, 0x0D, 0x63, 0xFE, +/* 09D0 */ 0x3F, 0xD8, 0x25, 0x7C, 0x00, 0xEA, 0xA0, 0x10, 0x07, 0x46, 0x9C, 0x54, 0x7F, 0x01, 0x78, 0x96, +/* 09E0 */ 0x6D, 0x61, 0x0C, 0x00, 0xFA, 0x3B, 0xA4, 0x01, 0x08, 0x6D, 0x55, 0x08, 0xA4, 0x94, 0x55, 0x87, +/* 09F0 */ 0x94, 0x0F, 0x83, 0x2A, 0x08, 0x4B, 0x64, 0xA4, 0x2A, 0xD8, 0x5E, 0x41, 0x5F, 0x5A, 0x72, 0x55, +/* 0A00 */ 0x84, 0xA4, 0x8F, 0x10, 0x07, 0x46, 0x9C, 0x54, 0x06, 0xC0, 0x72, 0x7C, 0x19, 0x35, 0x4B, 0x00, +/* 0A10 */ 0x5C, 0x6F, 0x0A, 0x6D, 0x97, 0xA3, 0x2A, 0x08, 0x72, 0x01, 0x0A, 0xA3, 0x2A, 0x81, 0x6E, 0x94, +/* 0A20 */ 0x00, 0x3B, 0x8B, 0x0C, 0x6D, 0x18, 0x2D, 0xA4, 0x28, 0x04, 0xA7, 0x05, 0x55, 0x44, 0x72, 0x80, +/* 0A30 */ 0x64, 0x02, 0x10, 0x03, 0x31, 0xDE, 0x55, 0x7B, 0xDE, 0x10, 0x03, 0x31, 0xDE, 0x00, 0x3D, 0x41, +/* 0A40 */ 0x32, 0x3C, 0xD3, 0x40, 0xE1, 0x10, 0x07, 0x3C, 0x3D, 0xEE, 0x08, 0x0A, 0x1F, 0x67, 0x5F, 0x90, +/* 0A50 */ 0xBA, 0x72, 0x04, 0x55, 0x35, 0x94, 0x01, 0x25, 0x9C, 0x0F, 0x4B, 0x80, 0x64, 0x0B, 0xA4, 0x9F, +/* 0A60 */ 0x03, 0x06, 0x10, 0x07, 0x39, 0x64, 0xD5, 0x1E, 0x64, 0xD5, 0x10, 0x07, 0x31, 0x4C, 0x2F, 0xEC, +/* 0A70 */ 0xD2, 0xEA, 0x6A, 0x54, 0x02, 0x1F, 0x64, 0x7C, 0x00, 0x41, 0x23, 0x8F, 0xBA, 0x0E, 0x08, 0x01, +/* 0A80 */ 0xEA, 0x07, 0x01, 0x10, 0x06, 0x74, 0x5D, 0x0E, 0xA3, 0xEB, 0x08, 0xA3, 0x0D, 0x54, 0x30, 0x3B, +/* 0A90 */ 0x34, 0x0E, 0x18, 0x3B, 0x0D, 0x6D, 0x25, 0xA5, 0xF1, 0x4F, 0x30, 0xA1, 0x87, 0x07, 0xE4, 0x10, +/* 0AA0 */ 0x0D, 0xC9, 0x77, 0x08, 0x6B, 0x4F, 0x33, 0xEC, 0xA3, 0xA0, 0x0E, 0x4B, 0x18, 0x7E, 0xA4, 0x04, +/* 0AB0 */ 0x06, 0x8B, 0x03, 0x0B, 0x68, 0x30, 0x8D, 0x63, 0x07, 0x6E, 0x45, 0x69, 0x00, 0x77, 0x0F, 0x90, +/* 0AC0 */ 0x69, 0x01, 0x69, 0x8D, 0x37, 0x64, 0x4B, 0x03, 0x94, 0x00, 0x69, 0x35, 0x83, 0x34, 0x08, 0x04, +/* 0AD0 */ 0x94, 0x00, 0x69, 0x35, 0x63, 0x64, 0x4B, 0x40, 0x76, 0x69, 0x9E, 0xA8, 0x00, 0xF6, 0x9B, 0x79, +/* 0AE0 */ 0x72, 0x94, 0x30, 0x9E, 0x37, 0x04, 0x5B, 0x03, 0x08, 0x4F, 0x01, 0x18, 0x05, 0x54, 0x88, 0x92, +/* 0AF0 */ 0xA3, 0x0A, 0x95, 0x05, 0x3B, 0x0A, 0x58, 0x4F, 0x05, 0x10, 0x08, 0x46, 0x62, 0xB0, 0x37, 0xBD, +/* 0B00 */ 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x2E, 0xD0, 0x40, 0x73, 0xD0, 0x06, 0x0F, 0x27, 0x64, 0x6E, 0x54, +/* 0B10 */ 0x43, 0x04, 0x5F, 0xA0, 0x0F, 0x90, 0xD0, 0x44, 0x6D, 0xD0, 0x44, 0x6D, 0x2C, 0x94, 0x23, 0x03, +/* 0B20 */ 0x2C, 0x5F, 0x4F, 0x04, 0x10, 0x07, 0xC9, 0x6A, 0xD2, 0x30, 0x36, 0x4F, 0x8A, 0x2A, 0x5E, 0x04, +/* 0B30 */ 0x7A, 0x01, 0x2D, 0xA4, 0x19, 0x36, 0x38, 0x5C, 0x38, 0x06, 0xA4, 0xCC, 0xB7, 0x77, 0x55, 0x48, +/* 0B40 */ 0x4F, 0x5B, 0x28, 0x6A, 0xD2, 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x45, 0xD0, 0x44, 0x6D, 0x00, 0x53, +/* 0B50 */ 0x08, 0x72, 0xD0, 0x97, 0x0F, 0x2E, 0x53, 0x92, 0x2E, 0x53, 0x08, 0x72, 0xD0, 0x44, 0x91, 0x2C, +/* 0B60 */ 0x94, 0x58, 0x45, 0x2C, 0x0F, 0xA4, 0x6C, 0x10, 0x07, 0xBE, 0xBC, 0x10, 0x06, 0xBE, 0x6E, 0x1D, +/* 0B70 */ 0x61, 0x0F, 0x24, 0x09, 0x18, 0x53, 0x4A, 0x22, 0x64, 0x5F, 0x24, 0x05, 0x2A, 0x64, 0x6E, 0x91, +/* 0B80 */ 0x18, 0x53, 0x4A, 0x53, 0x4A, 0x10, 0x08, 0x46, 0x97, 0x0C, 0xA4, 0x8F, 0xBA, 0x0F, 0x79, 0x83, +/* 0B90 */ 0x1E, 0x77, 0xB7, 0x7A, 0x2D, 0x0F, 0x2B, 0x08, 0xA3, 0x62, 0x0F, 0x94, 0x19, 0x08, 0xA3, 0x00, +/* 0BA0 */ 0x05, 0x0C, 0x94, 0x19, 0x8C, 0x30, 0x07, 0x94, 0xD6, 0x73, 0x00, 0x92, 0x6F, 0x0B, 0x54, 0x0A, +/* 0BB0 */ 0x78, 0x6F, 0x5D, 0x0D, 0x54, 0x6C, 0x10, 0x08, 0xBE, 0x4D, 0xCA, 0x0A, 0x2C, 0x8E, 0x0A, 0x2C, +/* 0BC0 */ 0x94, 0x5A, 0x94, 0x00, 0x53, 0xCA, 0x0A, 0x10, 0x04, 0xBE, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x46, +/* 0BD0 */ 0xB1, 0xB1, 0xB1, 0xB1, 0x0E, 0x83, 0xCD, 0x37, 0x25, 0x48, 0x2B, 0x69, 0x88, 0x04, 0x01, 0x10, +/* 0BE0 */ 0x08, 0xBE, 0x4D, 0x07, 0xA3, 0xD0, 0x02, 0x7C, 0xD0, 0x0A, 0x4B, 0x61, 0x63, 0xA4, 0x01, 0x61, +/* 0BF0 */ 0xA3, 0xFD, 0x64, 0x5F, 0x5C, 0x2E, 0x61, 0xA8, 0xA5, 0x00, 0xD0, 0x07, 0xA4, 0x01, 0xD0, 0x50, +/* 0C00 */ 0x6D, 0x00, 0x53, 0x92, 0x27, 0x10, 0x07, 0xBE, 0xA9, 0x26, 0x4D, 0x4A, 0x53, 0x30, 0x61, 0x54, +/* 0C10 */ 0x5B, 0x04, 0x61, 0x6E, 0x37, 0x10, 0x0A, 0x46, 0x0F, 0xA4, 0x30, 0x58, 0xA8, 0x18, 0x7A, 0x5F, +/* 0C20 */ 0x73, 0x01, 0x5F, 0x73, 0x18, 0x7A, 0xA4, 0x83, 0x40, 0x7C, 0x22, 0xF6, 0x6D, 0xF8, 0x63, 0x22, +/* 0C30 */ 0x40, 0x5A, 0x0A, 0x08, 0x0E, 0x65, 0x18, 0x64, 0x94, 0x5A, 0x0B, 0xE3, 0x83, 0x22, 0x05, 0x94, +/* 0C40 */ 0x07, 0xA4, 0x08, 0x09, 0x68, 0x18, 0x97, 0x4B, 0x98, 0x83, 0x09, 0x6D, 0x22, 0x07, 0x4B, 0x81, +/* 0C50 */ 0x85, 0x08, 0x91, 0x22, 0x08, 0x91, 0x22, 0x08, 0x4B, 0x10, 0x08, 0xBE, 0x94, 0xB9, 0x4B, 0x10, +/* 0C60 */ 0x09, 0xC9, 0xB5, 0xD6, 0xCE, 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x45, 0xD0, 0x01, 0xB7, 0x53, 0x0E, +/* 0C70 */ 0x83, 0xD0, 0x98, 0x37, 0x2C, 0x6E, 0x4B, 0x61, 0x94, 0x08, 0x04, 0x18, 0x53, 0x4A, 0x53, 0x10, +/* 0C80 */ 0x09, 0xC9, 0x08, 0x0D, 0xD2, 0x19, 0x62, 0xA4, 0x96, 0x6D, 0xD6, 0x37, 0x34, 0x27, 0x8C, 0x30, +/* 0C90 */ 0x59, 0x63, 0x36, 0x0C, 0x18, 0xA5, 0x36, 0x0C, 0x18, 0x0E, 0x83, 0x1E, 0x8C, 0x30, 0x59, 0x37, +/* 0CA0 */ 0x1E, 0x40, 0x37, 0x34, 0x0D, 0x19, 0x62, 0x0F, 0x4F, 0x69, 0x43, 0x5D, 0x78, 0x54, 0x09, 0x80, +/* 0CB0 */ 0x7E, 0x0B, 0x94, 0x1B, 0x8F, 0x10, 0x08, 0xBE, 0x0F, 0xA4, 0x7D, 0x61, 0x0F, 0x5A, 0xA4, 0x01, +/* 0CC0 */ 0xD0, 0x59, 0x83, 0xD0, 0x59, 0x83, 0x2C, 0x94, 0x58, 0x45, 0x2C, 0x6E, 0x89, 0x61, 0x0F, 0x59, +/* 0CD0 */ 0x37, 0x00, 0xD0, 0x48, 0x76, 0xD0, 0x40, 0x37, 0xD0, 0x8D, 0x72, 0x10, 0x07, 0x46, 0x05, 0x0C, +/* 0CE0 */ 0xA4, 0x8F, 0x3B, 0x5F, 0x79, 0x6D, 0x2A, 0x08, 0xA3, 0x00, 0x64, 0x00, 0x2D, 0x0F, 0x6D, 0x01, +/* 0CF0 */ 0xEA, 0x23, 0x0E, 0xB8, 0x06, 0x23, 0x08, 0x86, 0xA4, 0x19, 0x7A, 0x05, 0x30, 0x07, 0xA4, 0x19, +/* 0D00 */ 0x62, 0xA3, 0x51, 0xFD, 0x5D, 0x0E, 0x54, 0x07, 0x10, 0x07, 0x74, 0x78, 0x6E, 0xA3, 0x19, 0x35, +/* 0D10 */ 0x5A, 0x54, 0x0A, 0x07, 0x55, 0x62, 0x0F, 0xB8, 0x62, 0xC5, 0xC5, 0xC5, 0x91, 0x10, 0x08, 0x74, +/* 0D20 */ 0xAB, 0xF2, 0xD9, 0x10, 0x07, 0xA6, 0xEA, 0xB7, 0x9E, 0x68, 0x1E, 0x9E, 0x6D, 0x30, 0x0F, 0x73, +/* 0D30 */ 0x19, 0x08, 0x94, 0x7E, 0xA4, 0x00, 0xF9, 0xFA, 0x2A, 0x59, 0xA8, 0x08, 0x6D, 0x2A, 0x9E, 0x37, +/* 0D40 */ 0x0B, 0x0F, 0xEB, 0xFF, 0x69, 0x30, 0x41, 0x72, 0x72, 0xEA, 0x5F, 0x6D, 0x25, 0x23, 0x04, 0x10, +/* 0D50 */ 0x0B, 0x74, 0x0C, 0x83, 0x9E, 0x94, 0x00, 0x07, 0x4B, 0x30, 0x62, 0x6D, 0x9B, 0x0C, 0x35, 0x6D, +/* 0D60 */ 0x18, 0x08, 0x91, 0x01, 0xA4, 0x2E, 0x65, 0x18, 0xFA, 0x03, 0x94, 0x0F, 0x9E, 0x37, 0x30, 0x64, +/* 0D70 */ 0x72, 0x05, 0x68, 0x0F, 0x81, 0xA8, 0x30, 0x77, 0x54, 0x07, 0x85, 0x83, 0xA4, 0x1E, 0xA4, 0x0A, +/* 0D80 */ 0x90, 0x4B, 0xA3, 0x22, 0x44, 0xA3, 0x0A, 0x00, 0x8A, 0x4B, 0x1E, 0xA7, 0x08, 0x9E, 0x0F, 0x6D, +/* 0D90 */ 0x1E, 0x48, 0x68, 0x62, 0x0F, 0x83, 0x10, 0x07, 0x74, 0x0A, 0x94, 0x00, 0x40, 0x27, 0x7E, 0x5F, +/* 0DA0 */ 0x5D, 0xFD, 0x8D, 0x6D, 0x69, 0x28, 0x03, 0x6E, 0xB8, 0xF2, 0xEA, 0x78, 0x68, 0x1F, 0x07, 0x72, +/* 0DB0 */ 0x54, 0x1F, 0x7C, 0x0D, 0x83, 0x2D, 0xA3, 0x00, 0x07, 0xA3, 0x19, 0x44, 0x6D, 0x7A, 0xB7, 0x10, +/* 0DC0 */ 0x08, 0x74, 0xAD, 0x4B, 0xE0, 0xD1, 0x98, 0xFB, 0x10, 0x07, 0x74, 0x92, 0x6E, 0xFD, 0x04, 0x21, +/* 0DD0 */ 0x0F, 0x6D, 0x18, 0xBA, 0x27, 0x22, 0x50, 0x6D, 0x1F, 0x35, 0x54, 0xF1, 0x0F, 0x83, 0x25, 0xCB, +/* 0DE0 */ 0x1F, 0x64, 0x5F, 0x80, 0x8D, 0xA4, 0x21, 0x06, 0x2A, 0x23, 0x5F, 0x6D, 0x10, 0x04, 0x9D, 0x06, +/* 0DF0 */ 0x24, 0xB8, 0x48, 0x54, 0x1F, 0x35, 0x68, 0xD4, 0x68, 0xD4, 0xA3, 0xB8, 0x48, 0x54, 0x10, 0x07, +/* 0E00 */ 0x9D, 0x77, 0x4E, 0x59, 0x3F, 0x9E, 0x73, 0x3C, 0xFF, 0x22, 0x41, 0xC4, 0x59, 0x2B, 0x44, 0x73, +/* 0E10 */ 0x86, 0x83, 0x22, 0x41, 0x4B, 0xCC, 0x54, 0x1B, 0x58, 0x9F, 0x65, 0x22, 0x2D, 0x91, 0xCC, 0x06, +/* 0E20 */ 0x02, 0x10, 0x04, 0x9D, 0x07, 0x24, 0x07, 0x25, 0xA7, 0x71, 0xC3, 0x25, 0xC3, 0x25, 0xC3, 0x25, +/* 0E30 */ 0xC3, 0x25, 0xC3, 0x1F, 0x07, 0x0B, 0x72, 0x25, 0xA7, 0x0B, 0x10, 0x07, 0x7B, 0x04, 0x08, 0x05, +/* 0E40 */ 0x00, 0xEA, 0x78, 0x73, 0x1F, 0x07, 0x94, 0x4B, 0x2A, 0x7A, 0x69, 0x49, 0x73, 0x2A, 0x08, 0x91, +/* 0E50 */ 0x00, 0xFA, 0x10, 0x07, 0x31, 0x39, 0x08, 0x20, 0x33, 0x44, 0x8E, 0x07, 0x10, 0x04, 0x9D, 0x97, +/* 0E60 */ 0x3C, 0x64, 0xA3, 0x80, 0x7A, 0x06, 0x5B, 0x30, 0xCC, 0x10, 0x07, 0x31, 0x01, 0x5A, 0xB4, 0x10, +/* 0E70 */ 0x08, 0x57, 0x03, 0x0E, 0xC1, 0x0D, 0x08, 0x8A, 0x02, 0x61, 0x0F, 0x5B, 0x72, 0x61, 0x0E, 0x01, +/* 0E80 */ 0x40, 0x1D, 0xF9, 0x59, 0x73, 0xF9, 0x59, 0x73, 0x2C, 0x0E, 0x64, 0x5F, 0x61, 0xA3, 0x58, 0x6F, +/* 0E90 */ 0x04, 0x72, 0x0A, 0x4F, 0x01, 0x10, 0x06, 0x31, 0x77, 0x96, 0x0D, 0x07, 0xF7, 0xA3, 0x0C, 0x6F, +/* 0EA0 */ 0x97, 0x54, 0x19, 0x36, 0x56, 0x5C, 0x56, 0x06, 0x0F, 0x2B, 0x50, 0xA3, 0x0C, 0xE7, 0x7E, 0x0B, +/* 0EB0 */ 0x54, 0x08, 0x10, 0x08, 0xA6, 0x26, 0x38, 0x26, 0xE5, 0x04, 0x6B, 0x0A, 0x54, 0x2A, 0x50, 0xAA, +/* 0EC0 */ 0x94, 0x64, 0x54, 0x2D, 0x54, 0x34, 0xDA, 0x0D, 0x06, 0x54, 0x10, 0x07, 0x00, 0x31, 0x4C, 0xFC, +/* 0ED0 */ 0xEF, 0x10, 0x05, 0x29, 0x4C, 0x0E, 0x0D, 0x04, 0x55, 0x9E, 0xA3, 0x0B, 0x02, 0x1F, 0x5F, 0x80, +/* 0EE0 */ 0x9B, 0x0F, 0x4B, 0x1F, 0x48, 0x72, 0x05, 0x25, 0x0F, 0xAE, 0x0F, 0xAE, 0x0F, 0xAE, 0x0F, 0xAE, +/* 0EF0 */ 0x0F, 0xAE, 0x0F, 0x37, 0x10, 0x07, 0x1E, 0xC9, 0xCC, 0x07, 0x7F, 0x84, 0x5F, 0xA3, 0x41, 0xA4, +/* 0F00 */ 0x0A, 0x94, 0x55, 0xD8, 0x0B, 0x63, 0x2A, 0x08, 0x94, 0x82, 0x83, 0x2A, 0x81, 0x6E, 0x45, 0x2A, +/* 0F10 */ 0x9E, 0x0C, 0x8B, 0x28, 0x03, 0x54, 0x0A, 0x52, 0x1F, 0x51, 0x5F, 0xFD, 0x07, 0x07, 0x30, 0x07, +/* 0F20 */ 0xA3, 0x19, 0x9E, 0x0F, 0x8B, 0x0C, 0x4B, 0x3B, 0x96, 0x54, 0x08, 0x10, 0x07, 0x57, 0x03, 0x0E, +/* 0F30 */ 0xC1, 0x0D, 0x08, 0xC7, 0x01, 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x04, 0x9D, 0x02, +/* 0F40 */ 0x60, 0xE4, 0x26, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x9D, 0x02, 0x60, 0xE4, 0x26, 0xC1, 0xC1, 0x2B, +/* 0F50 */ 0x98, 0x2B, 0x0A, 0x94, 0x18, 0xBA, 0x85, 0xF1, 0x0B, 0x03, 0x10, 0x07, 0x9D, 0x77, 0x3E, 0xE9, +/* 0F60 */ 0xC1, 0x2E, 0x05, 0xA3, 0x00, 0xF9, 0x58, 0x43, 0x04, 0x54, 0xFA, 0x2A, 0x64, 0x54, 0x78, 0x43, +/* 0F70 */ 0x64, 0x54, 0x0A, 0xFD, 0x64, 0x54, 0x40, 0x27, 0x3A, 0x0D, 0x9E, 0xFD, 0x04, 0x54, 0x34, 0x27, +/* 0F80 */ 0x10, 0x04, 0x47, 0x77, 0x3C, 0xBB, 0xBB, 0xBB, 0x04, 0xA4, 0x06, 0x3C, 0x51, 0x0A, 0x10, 0x0B, +/* 0F90 */ 0xED, 0xE3, 0x4F, 0x04, 0x6B, 0x05, 0x30, 0x3A, 0xA3, 0x78, 0xA3, 0x54, 0x18, 0x64, 0xA4, 0x87, +/* 0FA0 */ 0x91, 0x5E, 0x18, 0x64, 0x54, 0x62, 0xAC, 0xAC, 0x6D, 0x5E, 0x10, 0x07, 0xED, 0xE3, 0xC7, 0x01, +/* 0FB0 */ 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x07, 0x31, 0x7E, 0xAF, 0xE6, 0x32, 0x10, 0x08, +/* 0FC0 */ 0xED, 0xE3, 0xDF, 0x18, 0x64, 0x4F, 0x10, 0x08, 0x31, 0x64, 0x6B, 0x08, 0x54, 0x2A, 0x50, 0xAA, +/* 0FD0 */ 0x94, 0x64, 0x54, 0x2D, 0xA3, 0x34, 0xDA, 0x0D, 0x48, 0x2B, 0x26, 0xE5, 0x30, 0x7E, 0x5B, 0x10, +/* 0FE0 */ 0x05, 0xED, 0x0B, 0x0A, 0xA8, 0x00, 0x61, 0xA4, 0x6F, 0x3A, 0x37, 0x18, 0x61, 0x3F, 0x26, 0xC1, +/* 0FF0 */ 0x0D, 0x10, 0x06, 0x31, 0x35, 0x0E, 0x4F, 0xEB, 0x07, 0xA4, 0x51, 0x05, 0x55, 0x48, 0x56, 0x26, +/* 1000 */ 0x54, 0x07, 0x25, 0x67, 0x78, 0xE7, 0x77, 0x97, 0x54, 0x55, 0x51, 0x95, 0x94, 0x00, 0x3B, 0x0B, +/* 1010 */ 0x69, 0x8F, 0x10, 0x05, 0x74, 0x87, 0x45, 0xCD, 0xA8, 0x25, 0x0F, 0x6E, 0x7F, 0x62, 0x0F, 0x94, +/* 1020 */ 0x04, 0x1F, 0x59, 0xA8, 0xCD, 0xA8, 0xCD, 0xA8, 0xCD, 0x0F, 0x9F, 0x0E, 0xA3, 0x07, 0x18, 0x41, +/* 1030 */ 0x6B, 0x0A, 0x10, 0x07, 0x31, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x31, 0x0E, 0x63, 0x35, 0xFD, 0x0A, +/* 1040 */ 0x6D, 0x9E, 0x63, 0x2A, 0xFA, 0x9B, 0x01, 0x19, 0x77, 0xA3, 0xF6, 0x55, 0x44, 0x68, 0x6D, 0x55, +/* 1050 */ 0x35, 0x72, 0x63, 0x55, 0x34, 0xA4, 0xCD, 0x72, 0x10, 0x0A, 0x31, 0x0D, 0x63, 0x04, 0xA4, 0x00, +/* 1060 */ 0x08, 0x6D, 0x22, 0x65, 0x06, 0x0F, 0x73, 0x0A, 0x63, 0x22, 0x08, 0x6D, 0x08, 0x58, 0x9C, 0x73, +/* 1070 */ 0x22, 0x05, 0x91, 0xE3, 0x68, 0x69, 0x22, 0x77, 0x0F, 0x5A, 0x6A, 0x08, 0xA3, 0x19, 0x8A, 0x83, +/* 1080 */ 0x79, 0x4B, 0x19, 0x23, 0x03, 0x48, 0x6D, 0x19, 0x48, 0xA8, 0x06, 0xB7, 0x10, 0x07, 0x31, 0x0A, +/* 1090 */ 0x91, 0x59, 0x73, 0x3B, 0x54, 0x05, 0x94, 0x55, 0x62, 0x54, 0x73, 0x00, 0xC0, 0x72, 0x18, 0x2D, +/* 10A0 */ 0x0F, 0xA4, 0x28, 0x44, 0x94, 0x6D, 0x55, 0xFA, 0x40, 0x27, 0x00, 0x44, 0x83, 0x9E, 0x6D, 0x10, +/* 10B0 */ 0x07, 0x31, 0x7C, 0xB2, 0x10, 0x06, 0x31, 0x48, 0x6E, 0xE7, 0x06, 0x24, 0x5F, 0xB8, 0x98, 0x27, +/* 10C0 */ 0x22, 0x50, 0x83, 0x1F, 0x35, 0x72, 0xFE, 0x89, 0x1F, 0x9E, 0x54, 0x24, 0x06, 0x2A, 0x44, 0x6E, +/* 10D0 */ 0x91, 0x10, 0x04, 0x47, 0x84, 0x38, 0x0E, 0x4B, 0xCD, 0x3F, 0x59, 0x2E, 0xCD, 0x2E, 0xFE, 0x38, +/* 10E0 */ 0x6B, 0x3E, 0x8D, 0x91, 0xCC, 0x0F, 0x2E, 0xCD, 0x3F, 0x59, 0x3F, 0x59, 0x3F, 0x9B, 0x09, 0x22, +/* 10F0 */ 0x41, 0x0D, 0x0C, 0x10, 0x05, 0x47, 0xB6, 0xE8, 0x2A, 0xB6, 0xE8, 0x2A, 0xB6, 0x10, 0x04, 0x9D, +/* 1100 */ 0x95, 0x06, 0x19, 0x36, 0xA8, 0x25, 0x9E, 0x73, 0x25, 0x9E, 0xAE, 0x0C, 0xAE, 0x0B, 0x83, 0x22, +/* 1110 */ 0x3B, 0x58, 0x22, 0xBA, 0x38, 0x0C, 0xAE, 0x0C, 0xAE, 0x0C, 0xAE, 0x0D, 0x73, 0x1E, 0x36, 0xA8, +/* 1120 */ 0x25, 0x95, 0x06, 0x10, 0x07, 0x1F, 0x39, 0x2D, 0x6C, 0x64, 0x00, 0x2D, 0x5F, 0x72, 0x37, 0x41, +/* 1130 */ 0x9A, 0x96, 0x08, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1A, 0x00, 0x41, 0x00, 0x67, 0x00, 0x93, +/* 1140 */ 0x00, 0xC3, 0x00, 0xCC, 0x00, 0xFE, 0x01, 0x0E, 0x01, 0x4D, 0x01, 0x74, 0x01, 0x9C, 0x01, 0xAA, +/* 1150 */ 0x01, 0xB5, 0x01, 0xE3, 0x01, 0xED, 0x02, 0x04, 0x02, 0x15, 0x02, 0x30, 0x02, 0x47, 0x02, 0x51, +/* 1160 */ 0x02, 0x6E, 0x02, 0xA9, 0x02, 0xAE, 0x02, 0xBE, 0x02, 0xCF, 0x02, 0xF9, 0x03, 0x21, 0x03, 0x42, +/* 1170 */ 0x03, 0x77, 0x03, 0xB2, 0x03, 0xD8, 0x03, 0xEA, 0x03, 0xF5, 0x04, 0x08, 0x04, 0x18, 0x04, 0x2B, +/* 1180 */ 0x04, 0x42, 0x04, 0x7A, 0x04, 0xA9, 0x04, 0xBB, 0x04, 0xC9, 0x04, 0xDA, 0x04, 0xE6, 0x04, 0xF8, +/* 1190 */ 0x05, 0x08, 0x05, 0x1D, 0x05, 0x31, 0x05, 0x5A, 0x05, 0x68, 0x05, 0x78, 0x05, 0x87, 0x05, 0x99, +/* 11A0 */ 0x05, 0xA8, 0x05, 0xB4, 0x05, 0xCF, 0x06, 0x10, 0x06, 0x20, 0x06, 0x2F, 0x06, 0x43, 0x06, 0x53, +/* 11B0 */ 0x06, 0x61, 0x06, 0x83, 0x06, 0xB2, 0x06, 0xC1, 0x06, 0xD1, 0x06, 0xE3, 0x06, 0xF1, 0x06, 0xFD, +/* 11C0 */ 0x07, 0x10, 0x07, 0x49, 0x07, 0x70, 0x07, 0x80, 0x07, 0x8F, 0x07, 0xA0, 0x07, 0xB3, 0x07, 0xC6, +/* 11D0 */ 0x07, 0xD7, 0x07, 0xEB, 0x07, 0xFE, 0x08, 0x2E, 0x08, 0x46, 0x08, 0x59, 0x08, 0x69, 0x08, 0x7C, +/* 11E0 */ 0x08, 0x8B, 0x08, 0x9E, 0x08, 0xA9, 0x08, 0xDA, 0x08, 0xEB, 0x08, 0xF9, 0x09, 0x09, 0x09, 0x15, +/* 11F0 */ 0x09, 0x22, 0x09, 0x2E, 0x03, 0x00, 0x10, 0x03, 0x31, 0x04, 0x32, 0x3C, 0x48, 0x38, 0x4C, 0x05, +/* 1200 */ 0x55, 0x7B, 0xF3, 0x25, 0x34, 0xB8, 0x97, 0xC4, 0xFA, 0x22, 0xBA, 0x56, 0xD3, 0x10, 0x06, 0x46, +/* 1210 */ 0x77, 0x68, 0xCC, 0x68, 0x00, 0xEA, 0x08, 0xA3, 0x04, 0x55, 0x62, 0x5F, 0x54, 0xC0, 0x85, 0x02, +/* 1220 */ 0xEB, 0x92, 0x71, 0x48, 0x56, 0xD3, 0x26, 0x89, 0x02, 0x80, 0x23, 0xA3, 0x1F, 0x5D, 0xA3, 0x05, +/* 1230 */ 0xF1, 0x68, 0xCC, 0x68, 0x10, 0x07, 0xC9, 0x08, 0x69, 0x0A, 0x28, 0x98, 0x4F, 0x68, 0x55, 0xD8, +/* 1240 */ 0x28, 0x35, 0x6D, 0x1E, 0x36, 0x6E, 0x76, 0x41, 0x0D, 0xA3, 0x0A, 0x07, 0x55, 0x35, 0x6D, 0x25, +/* 1250 */ 0x8D, 0x0F, 0x3E, 0x07, 0xA4, 0x21, 0x33, 0x62, 0x8E, 0x05, 0x10, 0x07, 0x1E, 0xC9, 0x3B, 0x04, +/* 1260 */ 0x30, 0x7E, 0x43, 0x51, 0x96, 0x95, 0x6F, 0x01, 0x78, 0x51, 0xA8, 0x19, 0x77, 0x91, 0x00, 0x92, +/* 1270 */ 0x43, 0x04, 0x68, 0x34, 0x33, 0x7A, 0x94, 0x5D, 0x73, 0x3B, 0x8E, 0x33, 0x35, 0x0B, 0x06, 0x09, +/* 1280 */ 0x06, 0x0A, 0x6F, 0x7A, 0x30, 0x7A, 0x10, 0x07, 0x74, 0x0D, 0x63, 0x30, 0x0E, 0x73, 0x19, 0x07, +/* 1290 */ 0x4B, 0x34, 0x6F, 0x01, 0x69, 0x01, 0x0A, 0x63, 0x55, 0xFF, 0xA3, 0x55, 0x77, 0xA4, 0x83, 0x55, +/* 12A0 */ 0x59, 0x6E, 0x68, 0x00, 0x3B, 0x08, 0x72, 0x03, 0x01, 0x2A, 0x59, 0x6E, 0x68, 0x19, 0x7A, 0xA0, +/* 12B0 */ 0x54, 0x0A, 0x04, 0x1F, 0x07, 0x72, 0x10, 0x05, 0x47, 0xB6, 0xE8, 0x22, 0x3D, 0xB6, 0xE8, 0x10, +/* 12C0 */ 0x07, 0xA6, 0xCC, 0x0B, 0x54, 0x7F, 0x44, 0xA3, 0x0C, 0x0D, 0x1F, 0x0F, 0xA8, 0x00, 0x28, 0x8D, +/* 12D0 */ 0xD2, 0x1F, 0x96, 0x5F, 0x90, 0x41, 0x91, 0x82, 0x83, 0x61, 0x0D, 0x04, 0x48, 0x43, 0x35, 0x5F, +/* 12E0 */ 0x4B, 0x25, 0x67, 0x54, 0x30, 0x41, 0x01, 0x5E, 0x2A, 0x7A, 0x6E, 0x94, 0x30, 0x3B, 0x08, 0x09, +/* 12F0 */ 0x06, 0x10, 0x06, 0x9D, 0x77, 0x00, 0x77, 0x30, 0x2D, 0x6D, 0x07, 0x68, 0x55, 0xEC, 0x05, 0xEC, +/* 1300 */ 0x05, 0x10, 0x0A, 0x3D, 0x67, 0x0E, 0x4F, 0x43, 0x49, 0x9A, 0x01, 0x66, 0x33, 0x0A, 0x7D, 0x6B, +/* 1310 */ 0x05, 0x6A, 0x1E, 0x59, 0x4C, 0x4F, 0x07, 0x01, 0x37, 0x18, 0x77, 0x73, 0x6D, 0x30, 0x44, 0x05, +/* 1320 */ 0x18, 0x7E, 0x73, 0x6D, 0x30, 0x44, 0x06, 0x18, 0x7A, 0x37, 0x6B, 0x0A, 0x08, 0x01, 0x37, 0x22, +/* 1330 */ 0x62, 0x7D, 0x6B, 0x05, 0x6A, 0x19, 0x81, 0x08, 0x01, 0x01, 0x66, 0x33, 0x77, 0x51, 0x4F, 0x03, +/* 1340 */ 0x10, 0x06, 0x57, 0x97, 0x09, 0x52, 0x1F, 0x44, 0x6E, 0xEB, 0x77, 0x01, 0xFF, 0x55, 0x35, 0x78, +/* 1350 */ 0x68, 0x2A, 0x34, 0x8B, 0x68, 0x00, 0x2D, 0x54, 0x78, 0xE7, 0x87, 0x32, 0x09, 0x06, 0x22, 0x7B, +/* 1360 */ 0x64, 0x0A, 0x21, 0xE7, 0x06, 0x6E, 0x54, 0x10, 0x08, 0x1C, 0xC9, 0x41, 0x06, 0x30, 0x9A, 0x19, +/* 1370 */ 0x77, 0x69, 0x01, 0x08, 0x91, 0x19, 0x82, 0x6D, 0x98, 0x27, 0x00, 0x92, 0x2E, 0xA5, 0xBA, 0x2E, +/* 1380 */ 0xA5, 0x2A, 0x49, 0x68, 0x05, 0xA4, 0x01, 0x3B, 0x69, 0x01, 0xD8, 0x41, 0x06, 0x30, 0x6C, 0x10, +/* 1390 */ 0x07, 0x75, 0x39, 0x64, 0x20, 0x02, 0x2D, 0x8E, 0x88, 0x08, 0xAE, 0x08, 0x37, 0x10, 0x05, 0x75, +/* 13A0 */ 0x39, 0x64, 0x21, 0x06, 0x30, 0x2D, 0x5F, 0x94, 0x10, 0x08, 0x29, 0x5D, 0x69, 0x8F, 0x2A, 0x8D, +/* 13B0 */ 0x8F, 0x5D, 0x0B, 0x19, 0x64, 0x0D, 0x05, 0x54, 0x02, 0x0D, 0x33, 0x07, 0x52, 0x09, 0x09, 0x06, +/* 13C0 */ 0x8B, 0x19, 0x07, 0x52, 0x69, 0x01, 0x8B, 0x19, 0x9C, 0x05, 0x09, 0x0C, 0x9C, 0x33, 0x8D, 0x7D, +/* 13D0 */ 0x02, 0xA0, 0x55, 0x5D, 0x69, 0x8F, 0x10, 0x05, 0x9D, 0x05, 0x21, 0x04, 0x1F, 0x08, 0x5F, 0x68, +/* 13E0 */ 0x10, 0x07, 0xA6, 0x86, 0x0E, 0x0D, 0x80, 0x05, 0x72, 0x8A, 0x1F, 0x08, 0x1D, 0x08, 0x4D, 0x41, +/* 13F0 */ 0x72, 0x8A, 0x25, 0x08, 0x0E, 0x0D, 0x03, 0x10, 0x07, 0x1F, 0xC9, 0x36, 0x33, 0x36, 0x33, 0xC2, +/* 1400 */ 0x33, 0x25, 0x3B, 0x20, 0x01, 0x41, 0x8E, 0x01, 0x10, 0x05, 0x47, 0x05, 0x09, 0x06, 0x18, 0x41, +/* 1410 */ 0x5F, 0x83, 0xEA, 0x05, 0xF3, 0x3C, 0x07, 0x89, 0x25, 0xEC, 0x3E, 0x04, 0x54, 0x0A, 0x06, 0x30, +/* 1420 */ 0x41, 0x5F, 0x91, 0x10, 0x05, 0x57, 0x4C, 0x8A, 0x02, 0x18, 0x3B, 0x03, 0x68, 0xFE, 0x45, 0xCC, +/* 1430 */ 0x4B, 0x30, 0x3B, 0x08, 0x06, 0x91, 0x1F, 0x4C, 0x4F, 0x01, 0x10, 0x04, 0x47, 0x77, 0x4E, 0x8C, +/* 1440 */ 0x1F, 0x34, 0x7D, 0xCC, 0x10, 0x07, 0xED, 0x2E, 0xD8, 0xF9, 0xD8, 0xF9, 0xD8, 0xF9, 0xD8, 0xF9, +/* 1450 */ 0xD8, 0x2C, 0x0E, 0x62, 0x4B, 0x61, 0x72, 0x0F, 0x94, 0x61, 0x6B, 0x08, 0x72, 0x61, 0x09, 0xDD, +/* 1460 */ 0xC3, 0x10, 0x0A, 0xA6, 0xCC, 0x51, 0x6E, 0x94, 0x19, 0x23, 0x54, 0x0B, 0x94, 0x1E, 0x5E, 0x5F, +/* 1470 */ 0x7D, 0x94, 0x1E, 0x40, 0x6E, 0x7D, 0x94, 0x1E, 0x44, 0x6E, 0x7D, 0x94, 0x1E, 0x7E, 0x58, 0x94, +/* 1480 */ 0x40, 0x6F, 0xE9, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D, +/* 1490 */ 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x0A, 0x40, 0x6F, 0x7A, 0x02, 0x7A, 0x02, 0x10, 0x03, 0x42, 0x39, +/* 14A0 */ 0xDE, 0x10, 0x04, 0x31, 0x39, 0x62, 0x08, 0x1B, 0x08, 0x91, 0x3C, 0x82, 0x0C, 0x18, 0x41, 0x69, +/* 14B0 */ 0x05, 0x10, 0x05, 0x29, 0x66, 0x0D, 0x18, 0x41, 0xA4, 0x0D, 0xCC, 0x95, 0x1B, 0x95, 0x1B, 0x95, +/* 14C0 */ 0x1B, 0x95, 0x10, 0x06, 0x57, 0x77, 0x08, 0x52, 0x1F, 0x50, 0x5F, 0x83, 0x00, 0x2D, 0x4B, 0x03, +/* 14D0 */ 0xA3, 0x55, 0xFF, 0x00, 0xA4, 0x55, 0x07, 0x6D, 0x01, 0xA3, 0x2A, 0x77, 0x0F, 0x8A, 0x91, 0x30, +/* 14E0 */ 0x2D, 0x6B, 0x8F, 0x19, 0xA1, 0x41, 0x0A, 0x21, 0xE7, 0x08, 0x6E, 0xA4, 0x10, 0x08, 0x31, 0x01, +/* 14F0 */ 0x9A, 0x7E, 0x07, 0x2A, 0x64, 0xA3, 0x9E, 0x83, 0x2A, 0x8D, 0x4B, 0x40, 0x89, 0x00, 0xD6, 0x37, +/* 1500 */ 0xCB, 0x2A, 0x5E, 0x03, 0x09, 0x72, 0x19, 0x8D, 0x4B, 0x40, 0x85, 0x2C, 0x0C, 0x8D, 0x83, 0x19, +/* 1510 */ 0x7A, 0x9A, 0x64, 0x07, 0x10, 0x0C, 0xA6, 0xC6, 0x95, 0x30, 0x79, 0x00, 0x33, 0x95, 0x7E, 0x83, +/* 1520 */ 0x03, 0x63, 0x22, 0x8D, 0x2E, 0x5A, 0x35, 0x0E, 0x2A, 0x77, 0x68, 0x50, 0x08, 0x60, 0x19, 0xCF, +/* 1530 */ 0x08, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x0C, 0xA6, 0xC6, 0x95, 0x30, 0x79, 0x67, 0x08, 0x01, 0x22, +/* 1540 */ 0x95, 0x7E, 0x68, 0x78, 0x94, 0x22, 0x95, 0x62, 0x2E, 0x05, 0x49, 0x0C, 0x1E, 0x77, 0x68, 0x00, +/* 1550 */ 0x7E, 0x68, 0x19, 0x08, 0x0E, 0x01, 0x77, 0x0D, 0x09, 0x1E, 0x7A, 0x32, 0x30, 0x6B, 0x0A, 0x09, +/* 1560 */ 0x1E, 0xA2, 0x01, 0x30, 0x5F, 0x54, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x0C, 0x29, 0x2D, 0x01, 0x22, +/* 1570 */ 0x4C, 0x8A, 0x02, 0x30, 0x05, 0x37, 0x22, 0x7E, 0x03, 0x68, 0x00, 0x9E, 0x0B, 0xD6, 0x45, 0xE9, +/* 1580 */ 0x33, 0x77, 0x91, 0x00, 0x79, 0x64, 0x18, 0x77, 0x06, 0x03, 0x4B, 0x03, 0x83, 0x03, 0x63, 0x18, +/* 1590 */ 0x05, 0x5F, 0x85, 0x5A, 0x35, 0x0E, 0x1E, 0x99, 0x01, 0x02, 0x68, 0x50, 0x08, 0x60, 0x19, 0xCF, +/* 15A0 */ 0x08, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x06, 0x30, 0x31, 0xA2, 0x3E, 0x9E, 0xC4, 0x05, 0x0C, 0x43, +/* 15B0 */ 0x3C, 0x2D, 0x0B, 0x3E, 0x49, 0x63, 0x1F, 0x87, 0xA3, 0x25, 0x48, 0x90, 0x1F, 0x9E, 0x6D, 0x00, +/* 15C0 */ 0x05, 0x28, 0x48, 0x54, 0x72, 0x2A, 0x7A, 0x0A, 0x69, 0x0A, 0x02, 0x10, 0x08, 0x55, 0xEA, 0x30, +/* 15D0 */ 0x86, 0x0C, 0x4E, 0x07, 0x58, 0x2F, 0x64, 0x01, 0x1F, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x25, +/* 15E0 */ 0xEA, 0x1B, 0xDB, 0x3C, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x25, 0x41, 0xA3, 0x28, 0x64, 0xA3, +/* 15F0 */ 0x8A, 0x28, 0x03, 0x07, 0x77, 0x08, 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x2A, 0xA1, 0x82, +/* 1600 */ 0x0E, 0x5A, 0x28, 0x84, 0x96, 0x08, 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x55, 0xEA, 0xDD, +/* 1610 */ 0x35, 0x63, 0x09, 0x63, 0x55, 0x07, 0x85, 0x08, 0x85, 0xA1, 0x0A, 0xB0, 0x37, 0xBD, 0x10, 0x08, +/* 1620 */ 0x18, 0x05, 0x8A, 0x02, 0x25, 0x0E, 0x06, 0x0B, 0xB8, 0x0E, 0x06, 0x60, 0x18, 0x41, 0x8A, 0x02, +/* 1630 */ 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x0B, 0x46, 0x7A, 0x8E, 0x54, 0x1E, 0x97, 0x5F, 0xA3, 0x24, +/* 1640 */ 0x07, 0x1E, 0x8D, 0x94, 0xFD, 0x7A, 0xA4, 0x98, 0x6F, 0x97, 0x4B, 0x03, 0x6E, 0xA3, 0x22, 0x9E, +/* 1650 */ 0x83, 0x00, 0x5F, 0x24, 0x08, 0x18, 0x77, 0x8E, 0x37, 0x19, 0x8C, 0x0A, 0x5A, 0x83, 0x1E, 0x9E, +/* 1660 */ 0x6D, 0x00, 0x35, 0xA3, 0x24, 0x04, 0x30, 0x5E, 0x03, 0x30, 0x07, 0x6E, 0x68, 0x10, 0x07, 0xC9, +/* 1670 */ 0x84, 0xD2, 0xBA, 0x4F, 0x8A, 0x2A, 0x59, 0x83, 0x7A, 0x02, 0x2D, 0xA4, 0x19, 0x36, 0x38, 0x5C, +/* 1680 */ 0x38, 0x8C, 0x25, 0x64, 0x5F, 0x9F, 0x58, 0x8F, 0x04, 0x06, 0x2A, 0x64, 0x0E, 0x6E, 0x27, 0x30, +/* 1690 */ 0x77, 0x0A, 0x0F, 0x9A, 0x18, 0x2D, 0xC4, 0x01, 0x07, 0x37, 0x25, 0x6B, 0x6F, 0x07, 0x55, 0xEA, +/* 16A0 */ 0x1B, 0x44, 0x0A, 0x02, 0x25, 0x5D, 0x0E, 0x89, 0x30, 0xEA, 0x05, 0x30, 0x61, 0xBC, 0x10, 0x07, +/* 16B0 */ 0x25, 0xEA, 0xCC, 0x5A, 0xF1, 0x69, 0x8F, 0x18, 0x41, 0x28, 0x3A, 0xBC, 0x10, 0x07, 0x19, 0x86, +/* 16C0 */ 0x4B, 0x25, 0x08, 0x72, 0x4B, 0x30, 0x41, 0x04, 0x64, 0x06, 0x42, 0x61, 0xBC, 0x10, 0x07, 0x00, +/* 16D0 */ 0x42, 0xBF, 0x44, 0xF0, 0x9E, 0x0C, 0x42, 0x61, 0xBC, 0x10, 0x04, 0x42, 0x28, 0x1E, 0x08, 0x0D, +/* 16E0 */ 0x4E, 0x6A, 0x68, 0x3C, 0x64, 0x02, 0x18, 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x55, 0xEA, 0x1B, +/* 16F0 */ 0xA2, 0x3E, 0xCB, 0x3E, 0x03, 0x02, 0x1E, 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x75, 0x64, 0x54, +/* 1700 */ 0x02, 0x30, 0x3B, 0x8A, 0x0E, 0x45, 0x2A, 0x77, 0x07, 0x7A, 0x08, 0x93, 0x61, 0xA9, 0x26, 0xA9, +/* 1710 */ 0x10, 0x04, 0x22, 0xCC, 0xDD, 0x00, 0x08, 0x83, 0x08, 0x83, 0x55, 0x66, 0x04, 0xA2, 0x33, 0x25, +/* 1720 */ 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x09, 0x46, 0x6E, 0x4F, 0xEB, 0x0F, 0x72, 0x23, 0x43, 0xB7, 0xCB, +/* 1730 */ 0x2A, 0xB7, 0x05, 0x5F, 0x19, 0x23, 0x72, 0x40, 0xA8, 0x36, 0x72, 0x07, 0x40, 0xA8, 0x19, 0xB7, +/* 1740 */ 0x05, 0x5F, 0x2A, 0xB7, 0xCB, 0x2A, 0x0F, 0x72, 0x23, 0x43, 0x5F, 0xA4, 0x7D, 0x10, 0x08, 0x7B, +/* 1750 */ 0xA2, 0x79, 0x06, 0xF7, 0x96, 0x90, 0x75, 0x61, 0x94, 0xB9, 0x4B, 0x10, 0x09, 0x1F, 0xEA, 0x1B, +/* 1760 */ 0x50, 0x8F, 0xF1, 0x0A, 0xA4, 0x9F, 0x01, 0x3E, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x3C, 0xEA, 0xCC, +/* 1770 */ 0x79, 0xFE, 0x0E, 0x8F, 0x18, 0x41, 0x1B, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x93, 0x62, 0x0F, 0xB8, +/* 1780 */ 0xCB, 0x6D, 0x1F, 0x07, 0x03, 0x00, 0x05, 0x05, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x7B, 0x05, +/* 1790 */ 0x8A, 0x0C, 0x7F, 0x8D, 0x0B, 0x5B, 0x03, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x93, 0xBF, 0x50, +/* 17A0 */ 0x0D, 0x50, 0xE2, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x07, 0x00, 0x39, 0x82, 0x05, 0x8D, 0x07, 0xF7, +/* 17B0 */ 0x72, 0x91, 0x1F, 0x5E, 0x0B, 0x1E, 0x36, 0xA4, 0x43, 0x77, 0x0F, 0x7D, 0x4F, 0x55, 0x64, 0x01, +/* 17C0 */ 0x7E, 0x01, 0x10, 0x09, 0x18, 0x3D, 0x70, 0x1B, 0x0E, 0x0D, 0x1F, 0x08, 0x58, 0x72, 0x2A, 0x62, +/* 17D0 */ 0xA4, 0x23, 0x07, 0xD6, 0x73, 0x07, 0x58, 0x27, 0x07, 0xA3, 0x8D, 0x06, 0x0F, 0x63, 0x36, 0x76, +/* 17E0 */ 0x89, 0x0D, 0x83, 0x36, 0x0B, 0x04, 0x0D, 0x44, 0x68, 0x1E, 0x07, 0xA3, 0x08, 0x09, 0x00, 0xB7, +/* 17F0 */ 0x22, 0x40, 0x54, 0x05, 0x26, 0x27, 0x62, 0x5F, 0x96, 0x6D, 0x55, 0x58, 0xD2, 0x2A, 0x59, 0x71, +/* 1800 */ 0x01, 0x07, 0x05, 0x10, 0x08, 0x1F, 0xEA, 0x1B, 0xEC, 0x06, 0x3C, 0x9C, 0x94, 0x00, 0xCC, 0xEB, +/* 1810 */ 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x25, 0xEA, 0x9F, 0x05, 0x0D, 0xB8, 0x8C, 0x06, 0xF1, 0x3E, 0xAB, +/* 1820 */ 0xF2, 0xD9, 0x10, 0x08, 0x19, 0xCC, 0x0D, 0x63, 0x00, 0xF7, 0x8A, 0x0E, 0x43, 0x7A, 0x08, 0x01, +/* 1830 */ 0x00, 0x9A, 0x1C, 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x55, 0xEA, 0xDD, 0xE9, 0x52, 0xFD, 0x7E, 0x32, +/* 1840 */ 0x04, 0x32, 0x1C, 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x25, 0xEA, 0x30, 0xEA, 0xDB, 0x25, 0xAD, 0x4B, +/* 1850 */ 0xE0, 0xD1, 0x98, 0xFB, 0x10, 0x08, 0xBE, 0x0F, 0x22, 0x61, 0x94, 0x08, 0x33, 0x3A, 0x6E, 0x94, +/* 1860 */ 0x61, 0x0F, 0xE9, 0x37, 0xD0, 0x9B, 0x05, 0xD0, 0x59, 0x63, 0x2C, 0x0F, 0x5A, 0x54, 0x61, 0x0F, +/* 1870 */ 0xA4, 0x0A, 0x02, 0x30, 0x53, 0x4A, 0x10, 0x08, 0x57, 0x77, 0x0B, 0x69, 0x08, 0x1F, 0x58, 0x96, +/* 1880 */ 0x83, 0x3B, 0xA4, 0x35, 0x68, 0x61, 0x0D, 0x49, 0x45, 0x61, 0x0D, 0x06, 0x68, 0x2A, 0x64, 0x54, +/* 1890 */ 0x92, 0x90, 0x61, 0x0D, 0x82, 0xA3, 0x00, 0xF9, 0x81, 0x83, 0xF9, 0x8D, 0x6D, 0x2C, 0x45, 0xA7, +/* 18A0 */ 0x33, 0x04, 0x54, 0x66, 0x32, 0x10, 0x07, 0x3D, 0x05, 0x9F, 0x01, 0x69, 0x2F, 0x04, 0x0B, 0xAE, +/* 18B0 */ 0x77, 0xEA, 0x5A, 0xB4, 0x10, 0x07, 0x3D, 0x77, 0x4E, 0x66, 0x0D, 0x1F, 0x64, 0x94, 0x04, 0xCC, +/* 18C0 */ 0x30, 0xEA, 0x5A, 0xB4, 0x10, 0x07, 0x47, 0x62, 0x0F, 0xB8, 0x08, 0x72, 0x68, 0x1F, 0x08, 0x04, +/* 18D0 */ 0x97, 0x07, 0x1C, 0x7A, 0x5A, 0xB4, 0x10, 0x07, 0x57, 0x64, 0x8A, 0x0C, 0xE7, 0x8D, 0x95, 0x85, +/* 18E0 */ 0x1C, 0x7A, 0x5A, 0xB4, 0x10, 0x07, 0x47, 0xBF, 0x50, 0x0D, 0x50, 0xE2, 0x1C, 0x7A, 0x5A, 0xB4, +/* 18F0 */ 0x10, 0x07, 0x7B, 0x51, 0xE7, 0x3A, 0x03, 0x73, 0x55, 0x64, 0x89, 0x73, 0x25, 0x51, 0x09, 0x75, +/* 1900 */ 0xEA, 0x5A, 0xB4, 0x10, 0x0B, 0x31, 0x35, 0x0D, 0xA3, 0x03, 0x0B, 0x8A, 0x04, 0x22, 0x8D, 0x0B, +/* 1910 */ 0xA7, 0x0E, 0x0A, 0xA4, 0x01, 0x19, 0x44, 0x6D, 0x00, 0x65, 0x22, 0x07, 0x58, 0x8E, 0x6D, 0x30, +/* 1920 */ 0x97, 0x5F, 0x51, 0xA3, 0x21, 0x05, 0x30, 0x62, 0x4B, 0x8D, 0x4B, 0x00, 0x7A, 0x22, 0x08, 0xA4, +/* 1930 */ 0x96, 0x5F, 0x79, 0x45, 0x30, 0x7A, 0x0A, 0x8A, 0x04, 0x9C, 0x54, 0x07, 0x10, 0x06, 0x31, 0x77, +/* 1940 */ 0x96, 0x0D, 0x07, 0x55, 0x50, 0xA3, 0x0C, 0x6F, 0x97, 0x54, 0x19, 0x36, 0x56, 0xD3, 0x98, 0x89, +/* 1950 */ 0x02, 0x02, 0x1F, 0x23, 0xA3, 0xEA, 0x92, 0x7D, 0x25, 0xF6, 0x9F, 0x04, 0x68, 0xF1, 0x03, 0x68, +/* 1960 */ 0x25, 0xCB, 0x01, 0x10, 0x07, 0x47, 0x7E, 0x88, 0x9E, 0x6D, 0x22, 0x3B, 0x65, 0x18, 0xEA, 0x25, +/* 1970 */ 0x4C, 0xFC, 0xEF, 0x10, 0x07, 0xEE, 0x2F, 0x04, 0x0D, 0x73, 0xEA, 0xA3, 0x05, 0xCC, 0x1B, 0x4C, +/* 1980 */ 0xFC, 0xEF, 0x10, 0x07, 0x3D, 0x07, 0x72, 0x18, 0x41, 0x72, 0x4B, 0x1F, 0x70, 0x64, 0x09, 0xA1, +/* 1990 */ 0x4C, 0xFC, 0xEF, 0x10, 0x07, 0x47, 0x7A, 0x7A, 0x28, 0x9E, 0x89, 0x0C, 0x0E, 0x28, 0x5A, 0x87, +/* 19A0 */ 0x45, 0x00, 0x1C, 0x4C, 0xFC, 0xEF, 0x10, 0x04, 0x9D, 0x02, 0x4E, 0x62, 0x0F, 0x8F, 0x25, 0x67, +/* 19B0 */ 0x0E, 0x08, 0x18, 0xEA, 0x28, 0x3A, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x47, 0x97, 0x3C, 0x4C, 0x0F, +/* 19C0 */ 0x3E, 0x5B, 0x06, 0x01, 0xF1, 0x19, 0x61, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x9D, 0x98, 0x90, 0x30, +/* 19D0 */ 0x3B, 0xA3, 0x4F, 0x55, 0x64, 0x08, 0x77, 0x0A, 0x28, 0x55, 0x61, 0xC1, 0xC1, 0xE5, 0x10, 0x04, +/* 19E0 */ 0x9D, 0x01, 0xDD, 0x35, 0x37, 0x0A, 0x0F, 0xEB, 0x08, 0x85, 0x08, 0x89, 0x93, 0x2C, 0xC1, 0xC1, +/* 19F0 */ 0xE5, 0x10, 0x07, 0xEE, 0x05, 0x1F, 0x8D, 0x79, 0x73, 0x30, 0xBA, 0x54, 0x28, 0x34, 0x0C, 0x72, +/* 1A00 */ 0xF1, 0x9E, 0x83, 0x00, 0x41, 0x0D, 0x8A, 0x0F, 0x6F, 0x5E, 0x96, 0x54, 0xBA, 0x0B, 0x64, 0xA4, +/* 1A10 */ 0x19, 0x35, 0x4B, 0x64, 0xA4, 0xBA, 0x76, 0xF8, 0x19, 0x77, 0x78, 0x96, 0x63, 0x55, 0x4C, 0x54, +/* 1A20 */ 0x05, 0x10, 0x07, 0x57, 0x77, 0x6B, 0x95, 0x1F, 0x07, 0x0C, 0x0C, 0x0E, 0x06, 0x42, 0x61, 0xE3, +/* 1A30 */ 0xC7, 0x01, 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x07, 0x47, 0x7E, 0x88, 0x8D, 0x91, +/* 1A40 */ 0x01, 0x18, 0x3B, 0x09, 0x32, 0x18, 0xEA, 0x28, 0x7E, 0xAF, 0xE6, 0x32, 0x10, 0x07, 0xEE, 0x2F, +/* 1A50 */ 0x03, 0x0D, 0x37, 0xEA, 0x8A, 0x06, 0xCC, 0x1E, 0x3B, 0xAF, 0xE6, 0x32, 0x10, 0x07, 0x47, 0x97, +/* 1A60 */ 0xA3, 0x28, 0xE9, 0x96, 0x0A, 0x55, 0x64, 0x07, 0x7E, 0xE7, 0x55, 0x3B, 0xAF, 0xE6, 0x32, 0x10, +/* 1A70 */ 0x07, 0x1B, 0xEE, 0x6B, 0x95, 0x1F, 0x6A, 0x0C, 0x32, 0xA1, 0x03, 0xAF, 0xE6, 0x32, 0x10, 0x07, +/* 1A80 */ 0x47, 0x7A, 0xDD, 0x62, 0x37, 0x0B, 0x73, 0x2A, 0x35, 0x0E, 0x67, 0x89, 0x42, 0x3B, 0xAF, 0xE6, +/* 1A90 */ 0x32, 0x10, 0x07, 0x46, 0x97, 0xF5, 0xA1, 0x04, 0xD5, 0x42, 0x2D, 0xF5, 0x10, 0x07, 0x2A, 0xA6, +/* 1AA0 */ 0x41, 0x07, 0x9F, 0x96, 0x30, 0x3B, 0xA7, 0x0C, 0xF7, 0x72, 0x0F, 0x6D, 0x2D, 0x0F, 0x52, 0x0C, +/* 1AB0 */ 0x54, 0x2A, 0xFF, 0x09, 0x66, 0x4D, 0x36, 0x84, 0x02, 0x78, 0x2D, 0xA3, 0x0C, 0x02, 0x54, 0x19, +/* 1AC0 */ 0x7A, 0x78, 0x5B, 0x68, 0x00, 0x61, 0xA4, 0x7F, 0x97, 0x63, 0x22, 0x3B, 0x09, 0x10, 0x07, 0x47, +/* 1AD0 */ 0x7E, 0x02, 0x3C, 0x9E, 0x6D, 0x22, 0x3B, 0x65, 0x00, 0xCC, 0x1F, 0xD7, 0xB3, 0x91, 0x10, 0x07, +/* 1AE0 */ 0xEE, 0x2F, 0xEC, 0x73, 0x1F, 0xF6, 0x05, 0xCC, 0x3C, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x3D, 0x07, +/* 1AF0 */ 0x94, 0x25, 0xF8, 0x4B, 0x1F, 0x70, 0x64, 0xE7, 0x75, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x47, 0xBF, +/* 1B00 */ 0x9E, 0xF0, 0x87, 0x45, 0x1C, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x3D, 0x7E, 0x88, 0x07, 0xA3, 0x25, +/* 1B10 */ 0xFA, 0x88, 0x9F, 0x7C, 0xB2, 0x10, 0x08, 0x57, 0x03, 0x0E, 0xC1, 0x0E, 0x08, 0xDF, 0x18, 0x64, +/* 1B20 */ 0x4F, 0x10, 0x07, 0x9D, 0x7A, 0xDD, 0x00, 0xF6, 0xF6, 0xF7, 0x0A, 0x81, 0xE7, 0x75, 0x7C, 0xB2, +/* 1B30 */ 0x10, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x15, 0x00, 0x0B, 0x07, 0x42, 0x39, 0x08, 0x20, 0x09, 0x2A, +/* 1B40 */ 0x23, 0x5F, 0x54, 0x10, 0x07, 0x42, 0x39, 0x07, 0x20, 0x43, 0xA7, 0x5F, 0x83, 0x10, 0x0A, 0x42, +/* 1B50 */ 0x39, 0x07, 0x21, 0x20, 0x08, 0x22, 0xA7, 0x8E, 0x54, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, +/* 1B60 */ 0x00, 0x01, 0x00, 0x00, 0x06, 0x3D, 0x00, 0x00, 0x06, 0x3F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, +/* 1B70 */ 0x00, 0x5F, 0x00, 0x00, 0x06, 0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, +/* 1B80 */ 0x00, 0x60, 0x00, 0x00, 0x11, 0x34, 0x00, 0x00, 0x11, 0xF4, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, +/* 1B90 */ 0x00, 0x04, 0x00, 0x00, 0x1B, 0x31, 0x00, 0x00, 0x1B, 0x39, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold16.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold16.mcufont.h new file mode 100644 index 000000000..31f5914d7 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold16.mcufont.h @@ -0,0 +1,521 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 16 + * blob size: 7971, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x04, 0x7C, 0x00, 0x00, 0x04, 0xF1, 0x00, 0x00, 0x00, 0x92, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x1E, 0xE3, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x10, 0x00, 0x16, 0x00, 0x03, 0x00, 0x0F, 0x00, 0x01, 0x00, 0x11, 0x00, 0x13, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x36, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x31, 0x36, 0x00, +/* dictionary data */ +0x81, 0xC2, 0xC7, 0x0C, 0xC3, 0x81, 0xC4, 0x02, 0x0A, 0xCE, 0x80, +/* 0080 */ 0x08, 0xC7, 0x0C, 0xC2, 0x81, 0x34, 0xC1, 0x0E, 0xCE, 0xC6, 0xC2, 0x09, 0x08, 0xC3, 0x81, 0x05, +/* 0090 */ 0xC1, 0x0D, 0xC4, 0x01, 0x81, 0xC1, 0xC4, 0x0B, 0xC3, 0xFE, 0xC4, 0x0A, 0xC6, 0xCC, 0xD2, 0xCC, +/* 00A0 */ 0xC7, 0x28, 0x3A, 0x80, 0xCE, 0x80, 0x01, 0xC4, 0x07, 0x06, 0xC7, 0x06, 0x80, 0xC8, 0x01, 0x13, +/* 00B0 */ 0x81, 0xC8, 0x81, 0xC4, 0x01, 0x0B, 0x1D, 0xC3, 0x0A, 0xC6, 0xCC, 0xC8, 0x80, 0x1B, 0xC2, 0xCC, +/* 00C0 */ 0xCE, 0x80, 0xCC, 0xC1, 0x01, 0xCB, 0xCD, 0x80, 0x2A, 0xCE, 0x82, 0x81, 0xC5, 0x01, 0x0C, 0x07, +/* 00D0 */ 0xC2, 0x81, 0x0D, 0x41, 0x01, 0x09, 0xC7, 0x80, 0xCE, 0x03, 0x0A, 0xC2, 0x01, 0xC2, 0x82, 0x08, +/* 00E0 */ 0xC4, 0xC4, 0x81, 0xC4, 0x02, 0x01, 0xCA, 0x80, 0x40, 0x02, 0xC9, 0x08, 0xC3, 0x81, 0xC4, 0x01, +/* 00F0 */ 0xCD, 0x80, 0xCA, 0x07, 0x01, 0xC6, 0x10, 0xCE, 0xC5, 0xC4, 0xCC, 0xCE, 0xC1, 0x01, 0xCB, 0x80, +/* 0100 */ 0x09, 0x83, 0x19, 0xCD, 0xC4, 0x09, 0xC8, 0x80, 0x80, 0xC3, 0x01, 0xC9, 0x80, 0x02, 0x0A, 0xC3, +/* 0110 */ 0x81, 0xC4, 0x0C, 0xC3, 0x81, 0xC4, 0x0C, 0xC6, 0x81, 0xCE, 0xCC, 0x0A, 0xC1, 0xC8, 0xC3, 0xCB, +/* 0120 */ 0xCC, 0x80, 0xC9, 0xCE, 0xC2, 0xC1, 0x0C, 0x04, 0x14, 0x01, 0xCD, 0x0B, 0xC1, 0xCD, 0xCE, 0x80, +/* 0130 */ 0xC5, 0xC2, 0xCD, 0x09, 0xC5, 0xC1, 0xCE, 0x80, 0x01, 0xC1, 0x0D, 0xC8, 0x80, 0xED, 0xCE, 0xC9, +/* 0140 */ 0x0D, 0xC2, 0x80, 0xCC, 0xCE, 0xC3, 0xCD, 0xC1, 0xC1, 0x81, 0xC8, 0xCE, 0x80, 0xCD, 0xC7, 0xCD, +/* 0150 */ 0x09, 0xC6, 0x80, 0xC7, 0x32, 0x11, 0x40, 0x22, 0x01, 0xC8, 0xDD, 0xC7, 0x80, 0xCC, 0xC2, 0xCA, +/* 0160 */ 0x80, 0xCA, 0x40, 0x12, 0x41, 0x21, 0xCC, 0xC1, 0xC8, 0xC1, 0xCB, 0x80, 0xC2, 0xCB, 0xC4, 0x01, +/* 0170 */ 0x81, 0xC7, 0x08, 0xC4, 0x81, 0xCC, 0xC5, 0xC1, 0xC6, 0xCD, 0xC7, 0xCB, 0xC1, 0xC5, 0x81, 0x01, +/* 0180 */ 0xC7, 0x80, 0xC6, 0x0C, 0xC2, 0x80, 0xCB, 0xCB, 0xC4, 0xC9, 0x80, 0x08, 0xC5, 0x81, 0x80, 0xC1, +/* 0190 */ 0x09, 0xC3, 0xCD, 0xC3, 0x81, 0xDE, 0xC3, 0xCC, 0x40, 0x21, 0xC1, 0xCA, 0x81, 0xC3, 0xCE, 0xCB, +/* 01A0 */ 0xC4, 0xC1, 0xCD, 0xC6, 0xCA, 0x80, 0x81, 0xC6, 0xC2, 0x81, 0xCA, 0xC1, 0x08, 0xC2, 0x81, 0xCE, +/* 01B0 */ 0xC4, 0xC1, 0xC8, 0x09, 0x1D, 0x0B, 0x93, 0x6E, 0x3D, 0x00, 0x2C, 0x78, 0x2A, 0x26, 0x22, 0x01, +/* 01C0 */ 0x81, 0x1B, 0x1C, 0x04, 0xA3, 0x08, 0x1B, 0x0A, 0x91, 0x3A, 0x25, 0x42, 0x83, 0x26, 0x5B, 0x22, +/* 01D0 */ 0x93, 0x3E, 0x0E, 0x30, 0x92, 0x9F, 0x32, 0x38, 0x78, 0x44, 0x96, 0x59, 0x44, 0x48, 0xA0, 0x03, +/* 01E0 */ 0x66, 0x1B, 0x5A, 0x31, 0x54, 0x67, 0x73, 0x0F, 0x08, 0x45, 0xA4, 0x78, 0x00, 0x7A, 0x73, 0x03, +/* 01F0 */ 0x9A, 0x21, 0x0A, 0x62, 0x00, 0x0E, 0x91, 0x54, 0x0E, 0x91, 0x53, 0x0A, 0x22, 0x47, 0x43, 0x5B, +/* 0200 */ 0x2C, 0x0F, 0x78, 0x69, 0x9F, 0x2B, 0x8A, 0x8A, 0x8A, 0x03, 0x9A, 0xA1, 0x3D, 0x0F, 0x7B, 0x65, +/* 0210 */ 0x03, 0x9A, 0x04, 0x22, 0x09, 0x4A, 0x0E, 0x22, 0x04, 0x4E, 0x26, 0x2B, 0x03, 0x31, 0x06, 0x18, +/* 0220 */ 0x2B, 0x03, 0x31, 0x07, 0x18, 0x2B, 0x0E, 0xA0, 0x34, 0x0A, 0x43, 0x1C, 0x52, 0x22, 0x02, 0xA5, +/* 0230 */ 0x1E, 0x1E, 0x0E, 0x0D, 0xA2, 0x1D, 0x46, 0x55, 0x7B, 0x00, 0xA7, 0x1E, 0x1E, 0x1E, 0x0E, 0x70, +/* 0240 */ 0x07, 0x26, 0x5A, 0x0D, 0x2B, 0x4E, 0x18, 0x5A, 0x0D, 0x48, 0xA4, 0x03, 0x7F, 0x93, 0x3F, 0x2E, +/* 0250 */ 0x08, 0x93, 0x3F, 0x78, 0x7F, 0x93, 0x2D, 0x46, 0x78, 0x3A, 0x02, 0x08, 0x93, 0x3F, 0x0C, 0x9B, +/* 0260 */ 0x0A, 0x02, 0x1B, 0x0C, 0x0E, 0x3A, 0x73, 0x5F, 0x00, 0x4E, 0x26, 0x98, 0x0A, 0x0C, 0x0E, 0x26, +/* 0270 */ 0xA7, 0x9A, 0x26, 0x1D, 0x36, 0x63, 0x05, 0x26, 0x1D, 0x09, 0x78, 0x90, 0x18, 0x96, 0x0E, 0x43, +/* 0280 */ 0x7B, 0x54, 0x77, 0x20, 0x04, 0x09, 0x1C, 0x8B, 0x54, 0x53, 0x29, 0x6A, 0x1D, 0x03, 0x3D, 0x0C, +/* 0290 */ 0x73, 0x5B, 0x2C, 0x26, 0x7F, 0x9A, 0x2B, 0x7F, 0x9A, 0x00, 0x90, 0x26, 0x00, 0x2C, 0x26, 0x7F, +/* 02A0 */ 0x9A, 0x1D, 0x03, 0x3D, 0x0C, 0x73, 0x1D, 0x53, 0x43, 0x9A, 0x29, 0x7B, 0x1D, 0x39, 0x26, 0x23, +/* 02B0 */ 0x2A, 0x3D, 0x2A, 0xA4, 0x2C, 0x9F, 0x00, 0x46, 0x30, 0x23, 0x7F, 0x18, 0x5B, 0x76, 0x09, 0x2C, +/* 02C0 */ 0x9F, 0x00, 0x46, 0x30, 0x23, 0x2A, 0x3D, 0x2A, 0x3D, 0x65, 0x6E, 0x49, 0x4D, 0x49, 0x4D, 0x49, +/* 02D0 */ 0x4D, 0x49, 0x4D, 0x49, 0x4D, 0x49, 0x4D, 0x04, 0x3D, 0x00, 0x0E, 0x83, 0x3F, 0x09, 0x00, 0x03, +/* 02E0 */ 0x30, 0x1D, 0x0A, 0x55, 0x43, 0x21, 0x0C, 0x93, 0x5B, 0xA5, 0x07, 0x23, 0x6E, 0x30, 0x5B, 0x67, +/* 02F0 */ 0x93, 0x84, 0x44, 0x42, 0x01, 0x3D, 0x0F, 0x7B, 0x78, 0x72, 0x78, 0x44, 0x48, 0x0D, 0x3A, 0x78, +/* 0300 */ 0x75, 0x96, 0x9A, 0x26, 0x45, 0x0F, 0x01, 0x04, 0x06, 0x02, 0x3E, 0x1A, 0x5C, 0x03, 0x0F, 0x7B, +/* 0310 */ 0x0C, 0x0F, 0x8E, 0x22, 0x1C, 0x08, 0x5B, 0x09, 0x78, 0x40, 0x09, 0x78, 0x3E, 0x5A, 0x0F, 0x73, +/* 0320 */ 0x00, 0x7E, 0x1A, 0x1B, 0x1A, 0x5C, 0x1A, 0x5C, 0x1A, 0x00, 0x98, 0x00, 0x0C, 0x7B, 0x1D, 0x5D, +/* 0330 */ 0x0D, 0x69, 0x83, 0x5B, 0x2C, 0x0F, 0x55, 0x93, 0x1D, 0x5D, 0x64, 0x03, 0xA4, 0x6E, 0x05, 0x54, +/* 0340 */ 0x4A, 0x43, 0x9F, 0x1D, 0x6E, 0x09, 0x1C, 0x8D, 0x33, 0x07, 0x08, 0x93, 0x3F, 0x05, 0x73, 0x07, +/* 0350 */ 0x93, 0x3F, 0x02, 0x1C, 0x08, 0x93, 0x3F, 0x02, 0x09, 0x73, 0x93, 0x3F, 0x02, 0x05, 0x43, 0x93, +/* 0360 */ 0x3F, 0x02, 0x00, 0x1C, 0x93, 0x3F, 0x02, 0x38, 0x0A, 0x6F, 0x59, 0x44, 0x98, 0xA0, 0x28, 0x55, +/* 0370 */ 0x26, 0xA7, 0x0E, 0x80, 0x0C, 0x73, 0x3F, 0x07, 0x5B, 0x0C, 0x0F, 0x02, 0x65, 0x48, 0x43, 0x64, +/* 0380 */ 0x01, 0x83, 0x23, 0x48, 0x0F, 0x0B, 0x6F, 0x0B, 0x6F, 0x0B, 0x6F, 0x79, 0x9B, 0x0A, 0x02, 0x3E, +/* 0390 */ 0x40, 0x0B, 0x73, 0x8A, 0x25, 0x0F, 0x7B, 0x22, 0x05, 0x04, 0x0F, 0x7B, 0x1D, 0x76, 0x3C, 0x07, +/* 03A0 */ 0x7A, 0x9B, 0x07, 0x88, 0x05, 0x0C, 0x03, 0x01, 0x0B, 0x0C, 0x0F, 0x29, 0x78, 0x22, 0x07, 0x53, +/* 03B0 */ 0x0D, 0x2B, 0x4E, 0x18, 0x5A, 0x0D, 0x1D, 0x2D, 0x6E, 0x0B, 0x0B, 0x02, 0x65, 0x96, 0x19, 0x01, +/* 03C0 */ 0x80, 0x18, 0x4E, 0x18, 0x2B, 0x6D, 0x07, 0x53, 0x0A, 0x58, 0x0D, 0x02, 0x9F, 0x54, 0x76, 0x0A, +/* 03D0 */ 0x93, 0x1B, 0x5A, 0x2D, 0xA5, 0x44, 0x58, 0x73, 0x3E, 0x81, 0x40, 0x81, 0x40, 0x81, 0x40, 0x81, +/* 03E0 */ 0x40, 0x81, 0x65, 0x42, 0x09, 0x01, 0x2D, 0x38, 0x91, 0x5B, 0x4E, 0x6A, 0x65, 0x2A, 0x0F, 0xA4, +/* 03F0 */ 0x44, 0x80, 0x2D, 0x7F, 0x07, 0x91, 0x5B, 0x05, 0x91, 0x2B, 0x4E, 0x91, 0x5B, 0x0C, 0x52, 0x2B, +/* 0400 */ 0x4E, 0x91, 0x2A, 0x0F, 0x4B, 0x46, 0x0E, 0x6A, 0x68, 0x0D, 0x29, 0x25, 0x65, 0x7A, 0x43, 0x54, +/* 0410 */ 0x7F, 0xA8, 0x01, 0x2B, 0x8F, 0x43, 0xA4, 0x00, 0x48, 0x0B, 0x9B, 0x8B, 0x1E, 0x1E, 0x65, 0x98, +/* 0420 */ 0x3E, 0x53, 0x5B, 0x42, 0x5B, 0x98, 0x05, 0x40, 0x0E, 0x6A, 0x40, 0x0E, 0x6A, 0x03, 0x0F, 0x7B, +/* 0430 */ 0x53, 0x0D, 0x22, 0x29, 0x7B, 0x3E, 0x31, 0x3E, 0x31, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, +/* 0440 */ 0x1E, 0x07, 0x23, 0x28, 0x04, 0x9A, 0x0F, 0x29, 0x00, 0xA7, 0x07, 0x00, 0x03, 0x01, 0x7A, 0x18, +/* 0450 */ 0x44, 0x58, 0x09, 0x40, 0x09, 0x18, 0x65, 0x48, 0x31, 0x1C, 0x08, 0x22, 0x25, 0x1C, 0x08, 0x22, +/* 0460 */ 0x25, 0x40, 0x0A, 0x01, 0x0E, 0x94, 0x59, 0x23, 0x46, 0x83, 0x2A, 0x47, 0x78, 0x23, 0x7F, 0x59, +/* 0470 */ 0x2A, 0x80, 0x9A, 0x18, 0x03, 0x9A, 0x51, 0x0E, 0xA6, 0x22, 0x43, 0xA4, 0x22, 0x09, 0x00, 0x1C, +/* 0480 */ 0x4C, 0x3A, 0x00, 0x0C, 0x78, 0x54, 0x3A, 0x29, 0x78, 0x83, 0x40, 0x0C, 0x0B, 0x65, 0x6E, 0xA0, +/* 0490 */ 0x65, 0x90, 0x59, 0x05, 0x9F, 0x3E, 0x03, 0x40, 0x0C, 0x0F, 0x62, 0x23, 0x48, 0x09, 0x0A, 0x06, +/* 04A0 */ 0x1B, 0x20, 0x65, 0x42, 0x9A, 0x8E, 0x92, 0x08, 0x40, 0x0E, 0x62, 0x40, 0x1C, 0x0F, 0x25, 0x32, +/* 04B0 */ 0x68, 0x5B, 0x68, 0x09, 0x0C, 0x44, 0x6C, 0x1C, 0x74, 0x5B, 0x6C, 0x0B, 0x05, 0x37, 0x3F, 0x07, +/* 04C0 */ 0x00, 0x47, 0x5E, 0x87, 0xA7, 0x31, 0x2B, 0x6E, 0x09, 0x0E, 0x73, 0x25, 0x03, 0x1C, 0x04, 0x0B, +/* 04D0 */ 0x9B, 0x8B, 0x6C, 0x00, 0x05, 0x60, 0x43, 0x54, 0x4A, 0x60, 0x43, 0x1B, 0x3A, 0x4C, 0x3A, 0x4C, +/* 04E0 */ 0x3A, 0x4C, 0x0D, 0x62, 0x28, 0x2B, 0x5A, 0x9D, 0x02, 0x0C, 0x62, 0x40, 0x0C, 0x62, 0x04, 0x9F, +/* 04F0 */ 0x3E, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0B, 0x00, 0x0C, 0x00, +/* 0500 */ 0x10, 0x00, 0x13, 0x00, 0x15, 0x00, 0x17, 0x00, 0x1A, 0x00, 0x1B, 0x00, 0x1D, 0x00, 0x1F, 0x00, +/* 0510 */ 0x21, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x31, 0x00, 0x33, 0x00, 0x34, 0x00, 0x36, 0x00, 0x37, 0x00, +/* 0520 */ 0x3A, 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x44, 0x00, 0x46, 0x00, +/* 0530 */ 0x48, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x51, 0x00, 0x53, 0x00, 0x54, 0x00, 0x56, 0x00, 0x59, 0x00, +/* 0540 */ 0x5A, 0x00, 0x5D, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x64, 0x00, 0x65, 0x00, 0x67, 0x00, +/* 0550 */ 0x69, 0x00, 0x6A, 0x00, 0x6C, 0x00, 0x70, 0x00, 0x73, 0x00, 0x75, 0x00, 0x7B, 0x00, 0x7F, 0x00, +/* 0560 */ 0x81, 0x00, 0x82, 0x00, 0x84, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8B, 0x00, 0x8C, 0x00, 0x8D, 0x00, +/* 0570 */ 0x8E, 0x00, 0x90, 0x00, 0x93, 0x00, 0x95, 0x00, 0x98, 0x00, 0x99, 0x00, 0xA2, 0x00, 0xA4, 0x00, +/* 0580 */ 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xB0, 0x00, 0xB2, 0x00, 0xB3, 0x00, +/* 0590 */ 0xB4, 0x00, 0xB6, 0x00, 0xB8, 0x00, 0xBA, 0x00, 0xBC, 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC3, 0x00, +/* 05A0 */ 0xC5, 0x00, 0xC8, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, +/* 05B0 */ 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE0, 0x00, 0xE1, 0x00, +/* 05C0 */ 0xE3, 0x00, 0xE5, 0x00, 0xE6, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, +/* 05D0 */ 0xF3, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF9, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x01, +/* 05E0 */ 0x08, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x14, 0x01, 0x16, 0x01, +/* 05F0 */ 0x19, 0x01, 0x1B, 0x01, 0x1D, 0x01, 0x1F, 0x01, 0x20, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01, +/* 0600 */ 0x27, 0x01, 0x29, 0x01, 0x2B, 0x01, 0x2D, 0x01, 0x2F, 0x01, 0x31, 0x01, 0x33, 0x01, 0x35, 0x01, +/* 0610 */ 0x37, 0x01, 0x3A, 0x01, 0x3C, 0x01, 0x3E, 0x01, 0x6C, 0x01, 0x91, 0x01, 0x94, 0x01, 0x9E, 0x01, +/* 0620 */ 0xB1, 0x01, 0xBA, 0x01, 0xCB, 0x01, 0xD6, 0x01, 0xE9, 0x02, 0x10, 0x02, 0x34, 0x02, 0x56, 0x02, +/* 0630 */ 0x71, 0x02, 0x7D, 0x02, 0x7F, 0x02, 0x83, 0x02, 0x91, 0x02, 0x9F, 0x02, 0xA2, 0x02, 0xA9, 0x02, +/* 0640 */ 0xAB, 0x02, 0xAD, 0x02, 0xB6, 0x02, 0xD4, 0x02, 0xF2, 0x02, 0xFA, 0x03, 0x00, 0x03, 0x05, 0x03, +/* 0650 */ 0x10, 0x03, 0x16, 0x03, 0x1B, 0x03, 0x1E, 0x03, 0x2F, 0x03, 0x34, 0x03, 0x42, 0x03, 0x4C, 0x03, +/* 0660 */ 0x5E, 0x03, 0x60, 0x03, 0x64, 0x03, 0x6F, 0x03, 0x71, 0x03, 0x8F, 0x03, 0x97, 0x03, 0x99, 0x03, +/* 0670 */ 0x9D, 0x03, 0xA7, 0x03, 0xA9, 0x03, 0xAB, 0x03, 0xAD, 0x03, 0xAF, 0x03, 0xB1, 0x03, 0xB8, 0x03, +/* 0680 */ 0xC0, 0x03, 0xC4, 0x03, 0xCF, 0x03, 0xD1, 0x03, 0xD3, 0x03, 0xDD, 0x03, 0xE3, 0x03, 0xEC, 0x03, +/* 0690 */ 0xEE, 0x03, 0xFD, 0x03, 0xFF, 0x04, 0x0D, 0x04, 0x14, 0x04, 0x17, 0x04, 0x1E, 0x04, 0x21, 0x04, +/* 06A0 */ 0x2A, 0x04, 0x2C, 0x04, 0x33, 0x04, 0x38, 0x04, 0x3A, 0x04, 0x49, 0x04, 0x4C, 0x04, 0x50, 0x04, +/* 06B0 */ 0x57, 0x04, 0x59, 0x04, 0x5E, 0x04, 0x60, 0x04, 0x67, 0x04, 0x70, 0x04, 0x72, 0x04, 0x74, 0x04, +/* 06C0 */ 0x79, 0x04, 0x7C, +/* char range info */ +0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x35, +/* 06D0 */ 0x00, 0x6A, 0x00, 0xA4, 0x00, 0xF2, 0x01, 0x31, 0x01, 0x3F, 0x01, 0x6C, 0x01, 0x99, 0x01, 0xB8, +/* 06E0 */ 0x01, 0xC3, 0x01, 0xD0, 0x01, 0xDA, 0x01, 0xE0, 0x02, 0x0A, 0x02, 0x3B, 0x02, 0x54, 0x02, 0x7A, +/* 06F0 */ 0x02, 0xA7, 0x02, 0xD2, 0x02, 0xFD, 0x03, 0x2C, 0x03, 0x4F, 0x03, 0x81, 0x03, 0xB9, 0x03, 0xBF, +/* 0700 */ 0x03, 0xCC, 0x03, 0xEE, 0x04, 0x02, 0x04, 0x25, 0x04, 0x48, 0x04, 0xB6, 0x04, 0xBD, 0x04, 0xE8, +/* 0710 */ 0x05, 0x12, 0x05, 0x36, 0x05, 0x3F, 0x05, 0x57, 0x05, 0x90, 0x05, 0xA7, 0x05, 0xAD, 0x05, 0xC7, +/* 0720 */ 0x05, 0xF7, 0x06, 0x0A, 0x06, 0x55, 0x06, 0x5E, 0x06, 0x66, 0x06, 0x83, 0x06, 0xBD, 0x06, 0xEB, +/* 0730 */ 0x07, 0x1B, 0x07, 0x31, 0x07, 0x38, 0x07, 0x6C, 0x07, 0xC1, 0x07, 0xF3, 0x08, 0x05, 0x08, 0x2D, +/* 0740 */ 0x08, 0x42, 0x08, 0x6D, 0x08, 0x83, 0x08, 0x9C, 0x08, 0xA9, 0x08, 0xB6, 0x08, 0xBC, 0x08, 0xE2, +/* 0750 */ 0x08, 0xFD, 0x09, 0x16, 0x09, 0x1D, 0x09, 0x40, 0x09, 0x88, 0x09, 0xA4, 0x09, 0xAC, 0x09, 0xBF, +/* 0760 */ 0x09, 0xF0, 0x0A, 0x07, 0x0A, 0x26, 0x0A, 0x2E, 0x0A, 0x34, 0x0A, 0x4C, 0x0A, 0x64, 0x0A, 0x7A, +/* 0770 */ 0x0A, 0xA1, 0x0A, 0xC2, 0x0A, 0xCA, 0x0A, 0xF3, 0x0B, 0x30, 0x0B, 0x59, 0x0B, 0x5F, 0x0B, 0x81, +/* 0780 */ 0x0B, 0xA5, 0x0B, 0xB3, 0x0B, 0xDE, 0x03, 0x00, 0x10, 0x04, 0x9D, 0x07, 0x18, 0x3E, 0x5D, 0x64, +/* 0790 */ 0x8F, 0x23, 0x96, 0x23, 0x48, 0x43, 0xD9, 0x78, 0x72, 0x73, 0x33, 0x38, 0x0A, 0x6F, 0x59, 0x00, +/* 07A0 */ 0xDC, 0x5E, 0x10, 0x07, 0x9D, 0x04, 0x0F, 0x86, 0x26, 0x98, 0x73, 0x00, 0x9A, 0x45, 0x93, 0x00, +/* 07B0 */ 0x9B, 0x45, 0x83, 0x00, 0x80, 0x5F, 0x62, 0x00, 0x0C, 0x0D, 0x10, 0x08, 0xBF, 0x9A, 0x5A, 0x05, +/* 07C0 */ 0x1D, 0x46, 0x78, 0x53, 0x03, 0x48, 0x0F, 0x55, 0x43, 0x1D, 0xF7, 0x0E, 0x0D, 0xBE, 0x42, 0x7B, +/* 07D0 */ 0x02, 0x78, 0x1B, 0x09, 0x6A, 0x04, 0x93, 0x1B, 0x0B, 0x59, 0x05, 0x62, 0x54, 0x0C, 0x55, 0xA4, +/* 07E0 */ 0x2B, 0x4A, 0x78, 0x1C, 0x50, 0x2B, 0x46, 0x78, 0x53, 0x03, 0x00, 0x48, 0x93, 0x67, 0x97, 0x10, +/* 07F0 */ 0x08, 0x5B, 0x4B, 0x0C, 0x0F, 0x00, 0x40, 0x0C, 0x0F, 0xD5, 0x0E, 0x7B, 0x21, 0x53, 0x47, 0x63, +/* 0800 */ 0x96, 0x04, 0x8C, 0x09, 0x42, 0x18, 0x65, 0x96, 0xA2, 0x01, 0x32, 0x0B, 0x47, 0x50, 0xDB, 0x3A, +/* 0810 */ 0x9F, 0xB8, 0x30, 0x40, 0x0E, 0x62, 0x48, 0x57, 0x2A, 0xA4, 0xFC, 0x9A, 0xBE, 0x5B, 0x48, 0x09, +/* 0820 */ 0x0E, 0x91, 0x40, 0x0C, 0x0F, 0x00, 0x40, 0x0C, 0x0F, 0x10, 0x0D, 0x3E, 0x4B, 0x68, 0x01, 0x2D, +/* 0830 */ 0x4E, 0x69, 0x08, 0x44, 0x09, 0x74, 0x23, 0x03, 0x0F, 0x9B, 0x6A, 0x2A, 0x73, 0x2C, 0x0F, 0x04, +/* 0840 */ 0x03, 0x62, 0x67, 0x59, 0x2C, 0x6A, 0x04, 0x62, 0x07, 0x62, 0x3F, 0xA4, 0x0F, 0x52, 0x48, 0x61, +/* 0850 */ 0x06, 0x0B, 0x7B, 0x0B, 0x5E, 0x02, 0x2B, 0xF9, 0x93, 0x0B, 0x43, 0x73, 0x2B, 0x6D, 0x02, 0x73, +/* 0860 */ 0x4A, 0x01, 0x2D, 0x09, 0x2E, 0x73, 0x4A, 0x01, 0x23, 0x03, 0x78, 0x5B, 0x0B, 0x43, 0x73, 0x2C, +/* 0870 */ 0xF2, 0x00, 0x89, 0x5E, 0x02, 0x2D, 0x46, 0x10, 0x0B, 0x7E, 0x4E, 0x0D, 0x78, 0x08, 0x00, 0x6C, +/* 0880 */ 0xE2, 0x7B, 0x58, 0x0D, 0x4A, 0x0B, 0x7A, 0x43, 0x00, 0x0C, 0x2E, 0x2B, 0x6E, 0x0C, 0x0F, 0x3A, +/* 0890 */ 0x86, 0x00, 0x58, 0x18, 0x90, 0x07, 0x02, 0x2D, 0x36, 0xA0, 0x78, 0x02, 0x0E, 0x97, 0x65, 0x6E, +/* 08A0 */ 0x30, 0x4A, 0x30, 0xCF, 0x0A, 0x6E, 0x3A, 0x6A, 0x2B, 0x0B, 0x9A, 0x9B, 0x29, 0x6A, 0x23, 0x6E, +/* 08B0 */ 0x09, 0x3A, 0x8D, 0x9E, 0x0A, 0x02, 0x10, 0x04, 0x9D, 0x04, 0x73, 0xD9, 0x73, 0x72, 0x93, 0x72, +/* 08C0 */ 0x83, 0x5B, 0x68, 0x62, 0x10, 0x05, 0x7C, 0x46, 0xEF, 0x65, 0x0B, 0x91, 0x44, 0x6C, 0x43, 0x64, +/* 08D0 */ 0x0C, 0x2E, 0xDC, 0x9F, 0xB8, 0x43, 0xE6, 0x73, 0xDA, 0x0B, 0x40, 0x0C, 0x93, 0xDA, 0x0B, 0x40, +/* 08E0 */ 0x09, 0x73, 0x40, 0x5D, 0x72, 0x31, 0x3E, 0x0B, 0x62, 0x23, 0x48, 0x18, 0xE6, 0x6A, 0x5B, 0x68, +/* 08F0 */ 0x03, 0x10, 0x05, 0x54, 0x33, 0x68, 0x07, 0x64, 0x5A, 0x08, 0xD9, 0x18, 0xDA, 0x09, 0xD5, 0x43, +/* 0900 */ 0xD9, 0x31, 0x3E, 0x0F, 0x7B, 0x40, 0xBC, 0x32, 0xBC, 0x32, 0x0F, 0x2E, 0x68, 0xA4, 0x00, 0xDC, +/* 0910 */ 0x9F, 0xB8, 0x43, 0x40, 0x0C, 0x2E, 0x44, 0x48, 0x43, 0x64, 0x08, 0x91, 0x2D, 0x48, 0x10, 0x07, +/* 0920 */ 0x84, 0x4A, 0x05, 0x00, 0x45, 0x03, 0x08, 0x59, 0x05, 0x54, 0x7F, 0x78, 0x78, 0x59, 0x7A, 0xA3, +/* 0930 */ 0x78, 0x09, 0x34, 0x07, 0x43, 0x74, 0x5F, 0x0E, 0xA8, 0x83, 0x68, 0x05, 0x4E, 0x10, 0x08, 0x23, +/* 0940 */ 0x33, 0xFD, 0xBA, 0x0D, 0x72, 0x78, 0x72, 0x78, 0x10, 0x04, 0x00, 0x7C, 0x85, 0xD9, 0xA0, 0x6F, +/* 0950 */ 0xC6, 0x05, 0x00, 0xB8, 0x0E, 0x10, 0x06, 0x1D, 0x85, 0x48, 0x70, 0x57, 0x5B, 0x96, 0x3D, 0x10, +/* 0960 */ 0x04, 0x2D, 0x28, 0x85, 0xC3, 0x10, 0x07, 0x44, 0x4B, 0x61, 0x04, 0x40, 0x1C, 0x04, 0x65, 0x22, +/* 0970 */ 0x64, 0x81, 0xE6, 0x2E, 0x3E, 0x0E, 0x6A, 0x92, 0x26, 0x44, 0x7A, 0x78, 0xE6, 0x62, 0x3E, 0x67, +/* 0980 */ 0x6A, 0x92, 0x18, 0x44, 0x7A, 0x78, 0x40, 0x09, 0x83, 0x3E, 0x67, 0x91, 0xD5, 0x0A, 0x02, 0x10, +/* 0990 */ 0x09, 0xBF, 0x79, 0x73, 0x25, 0x42, 0xE2, 0x59, 0x54, 0x0E, 0x2E, 0x0B, 0x83, 0x22, 0x03, 0x90, +/* 09A0 */ 0x43, 0x96, 0x02, 0x4E, 0x26, 0x2D, 0x4E, 0x18, 0x4E, 0x18, 0x2D, 0xF9, 0x18, 0x4E, 0x26, 0x2B, +/* 09B0 */ 0x03, 0x9F, 0x90, 0x43, 0x54, 0x0E, 0x7B, 0x53, 0x0A, 0x42, 0xE2, 0x0F, 0x34, 0x79, 0x73, 0x04, +/* 09C0 */ 0x10, 0x07, 0x7E, 0xF9, 0x0E, 0x83, 0x1B, 0x9E, 0x9A, 0x83, 0x54, 0x4A, 0x9B, 0x83, 0x45, 0xA6, +/* 09D0 */ 0x0C, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0x83, 0x10, 0x07, 0x9D, 0x7F, 0x3A, 0xA2, 0x54, +/* 09E0 */ 0x53, 0x9B, 0xA4, 0x00, 0x48, 0x8E, 0x67, 0x93, 0xC9, 0x3E, 0x6D, 0x08, 0x44, 0x58, 0x63, 0x32, +/* 09F0 */ 0xE1, 0xEF, 0x46, 0xBC, 0x54, 0x6B, 0x62, 0x32, 0x4A, 0x78, 0x70, 0x54, 0x0A, 0x55, 0x78, 0x10, +/* 0A00 */ 0x08, 0x9D, 0xA9, 0x0D, 0x78, 0x08, 0x54, 0x4A, 0x43, 0x30, 0x54, 0x8C, 0x5B, 0x0B, 0x93, 0x00, +/* 0A10 */ 0x68, 0x0C, 0x2E, 0x1B, 0x09, 0x30, 0x3E, 0x09, 0x1C, 0xA8, 0xE6, 0x43, 0xD5, 0x26, 0x1D, 0x03, +/* 0A20 */ 0xD2, 0x53, 0x0E, 0x54, 0x0C, 0xE2, 0x7B, 0x1D, 0x6E, 0x09, 0x1C, 0xA2, 0x10, 0x08, 0x5B, 0x84, +/* 0A30 */ 0x25, 0xD9, 0x78, 0x64, 0x09, 0x73, 0x40, 0x0E, 0x91, 0x65, 0x96, 0x64, 0x0A, 0x93, 0x03, 0x78, +/* 0A40 */ 0x54, 0x6D, 0x06, 0x05, 0x78, 0x54, 0x5D, 0x8C, 0x78, 0x00, 0xFC, 0x55, 0x43, 0x2B, 0x7F, 0x80, +/* 0A50 */ 0x69, 0xBE, 0xB8, 0x78, 0x00, 0xB8, 0x78, 0x10, 0x08, 0x9D, 0x03, 0x55, 0x78, 0x00, 0x22, 0x70, +/* 0A60 */ 0x09, 0x98, 0x18, 0x65, 0x22, 0x0A, 0x0C, 0xA6, 0x98, 0x47, 0xBE, 0x54, 0x8C, 0x05, 0xA9, 0x9F, +/* 0A70 */ 0x92, 0x3D, 0x44, 0xA7, 0x05, 0x2B, 0x6E, 0x0B, 0x02, 0x7F, 0x18, 0xFC, 0x29, 0x62, 0x00, 0x42, +/* 0A80 */ 0x3A, 0x8D, 0x10, 0x08, 0xBF, 0x82, 0x9B, 0xD2, 0x1D, 0x46, 0x0E, 0x43, 0xA0, 0x54, 0x53, 0x86, +/* 0A90 */ 0x68, 0x0F, 0x7B, 0x61, 0x07, 0x00, 0x48, 0x55, 0xA4, 0x96, 0xD2, 0x0B, 0x73, 0x96, 0x02, 0x90, +/* 0AA0 */ 0x9A, 0x48, 0x31, 0x08, 0x43, 0x2B, 0x6E, 0x30, 0x53, 0x0B, 0x58, 0x43, 0x31, 0x1D, 0x7F, 0x3A, +/* 0AB0 */ 0x8B, 0x10, 0x07, 0x9D, 0x0D, 0x55, 0x62, 0x54, 0x0B, 0x80, 0x3A, 0x62, 0x92, 0x31, 0x1B, 0x7F, +/* 0AC0 */ 0x43, 0x40, 0xBC, 0x1B, 0xFF, 0x0A, 0x73, 0x3E, 0x76, 0x19, 0x5D, 0x64, 0x0C, 0x83, 0x00, 0x68, +/* 0AD0 */ 0x0C, 0x6A, 0x00, 0x72, 0x10, 0x08, 0x7E, 0x82, 0x9B, 0x8B, 0x1B, 0x0C, 0xE2, 0x6A, 0x22, 0x25, +/* 0AE0 */ 0x0C, 0x83, 0xA7, 0x04, 0x53, 0x08, 0x54, 0x0B, 0x78, 0x36, 0x75, 0x54, 0xF7, 0x30, 0x1D, 0x46, +/* 0AF0 */ 0x0E, 0x6A, 0x05, 0x0E, 0x62, 0x2B, 0x7F, 0x78, 0x5B, 0x5D, 0x1D, 0x36, 0x52, 0x5A, 0x0F, 0x22, +/* 0B00 */ 0x29, 0x62, 0x98, 0x0B, 0x1C, 0x8D, 0x10, 0x08, 0x7E, 0x9E, 0x0E, 0xA0, 0x03, 0x1D, 0x6E, 0x0D, +/* 0B10 */ 0xE2, 0x52, 0x2B, 0x4E, 0x18, 0x6D, 0x07, 0xFC, 0x0D, 0x5B, 0x0C, 0x83, 0xFC, 0x0D, 0x5B, 0x0B, +/* 0B20 */ 0x73, 0x2B, 0x4E, 0x9F, 0xF7, 0x0B, 0x1D, 0x6D, 0x47, 0x62, 0x98, 0x61, 0x07, 0xA4, 0x65, 0xFC, +/* 0B30 */ 0x52, 0x1B, 0x82, 0x9A, 0xEF, 0x0A, 0x9A, 0x20, 0x32, 0x09, 0x0D, 0x87, 0x00, 0x68, 0x10, 0x04, +/* 0B40 */ 0x41, 0xC3, 0x44, 0xC3, 0x10, 0x04, 0x41, 0xC3, 0x44, 0x03, 0xA0, 0x6F, 0xC6, 0x05, 0x00, 0xB8, +/* 0B50 */ 0x0E, 0x10, 0x08, 0x56, 0xBF, 0x6C, 0x0C, 0x09, 0x5B, 0x6C, 0x0C, 0xBE, 0x00, 0x48, 0x3A, 0x93, +/* 0B60 */ 0x25, 0x58, 0x99, 0xB8, 0x9A, 0xA2, 0x01, 0x44, 0x48, 0x88, 0x43, 0x08, 0x00, 0xDC, 0x0A, 0x93, +/* 0B70 */ 0x00, 0x72, 0x03, 0x10, 0x08, 0x1D, 0x41, 0x48, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x65, 0x33, +/* 0B80 */ 0x48, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x10, 0x08, 0x41, 0x01, 0x0E, 0x08, 0x02, 0x44, 0x6C, +/* 0B90 */ 0x1C, 0x62, 0x02, 0x68, 0x07, 0x1C, 0x83, 0x64, 0x08, 0x26, 0x00, 0x98, 0x09, 0x9A, 0x52, 0x1D, +/* 0BA0 */ 0x03, 0x88, 0x43, 0x07, 0x01, 0x98, 0x0F, 0xA2, 0x64, 0x05, 0x10, 0x07, 0x7E, 0x79, 0x43, 0xD2, +/* 0BB0 */ 0x58, 0x29, 0x62, 0x1D, 0x6E, 0x60, 0x53, 0x0C, 0x3E, 0xF7, 0x09, 0x32, 0xE1, 0xA6, 0x32, 0x0C, +/* 0BC0 */ 0x62, 0xE6, 0x0B, 0x03, 0x33, 0x09, 0x0C, 0x03, 0x92, 0x30, 0x40, 0x0B, 0xA8, 0x10, 0x0F, 0x2D, +/* 0BD0 */ 0x84, 0xD9, 0x0A, 0x3A, 0xA0, 0x06, 0xFC, 0x9A, 0x69, 0xBE, 0x02, 0x65, 0x5A, 0x50, 0x5B, 0x46, +/* 0BE0 */ 0xA3, 0x75, 0x5B, 0x2A, 0x0F, 0x63, 0x51, 0x0F, 0x8D, 0x53, 0x07, 0x44, 0x0B, 0x7B, 0x6D, 0x0E, +/* 0BF0 */ 0x9F, 0x04, 0x78, 0x00, 0x6E, 0x18, 0x07, 0x93, 0x67, 0x59, 0x76, 0x5B, 0x03, 0x43, 0x4A, 0x07, +/* 0C00 */ 0x67, 0x59, 0x01, 0x26, 0x2A, 0x78, 0x53, 0x07, 0x67, 0x59, 0x03, 0x43, 0x5B, 0x03, 0x43, 0x4A, +/* 0C10 */ 0x09, 0x6D, 0x04, 0x07, 0x93, 0x00, 0x46, 0x26, 0x8F, 0x5E, 0x69, 0x31, 0x5B, 0x0C, 0x91, 0x00, +/* 0C20 */ 0x77, 0x99, 0x04, 0x0E, 0x0D, 0x05, 0x44, 0x90, 0x78, 0x24, 0x0C, 0x0F, 0x57, 0x5B, 0x46, 0x03, +/* 0C30 */ 0x2D, 0x6E, 0x88, 0x43, 0x69, 0x73, 0x6C, 0x0B, 0x3A, 0x5E, 0x07, 0x10, 0x09, 0xBF, 0x8F, 0x97, +/* 0C40 */ 0xAB, 0xB7, 0x10, 0x09, 0xFD, 0xF5, 0x0E, 0x1C, 0x78, 0x00, 0xF4, 0x09, 0x18, 0xF4, 0x95, 0x52, +/* 0C50 */ 0x3F, 0x0E, 0x1C, 0x57, 0xA7, 0x9A, 0x43, 0x07, 0xA7, 0x07, 0x90, 0x0F, 0x6A, 0xF4, 0x76, 0x09, +/* 0C60 */ 0xF4, 0x05, 0x30, 0x3F, 0x0E, 0x0D, 0x9A, 0x63, 0x3F, 0x0F, 0x78, 0x0A, 0x03, 0x10, 0x08, 0xBF, +/* 0C70 */ 0x03, 0x0B, 0x9B, 0x94, 0x54, 0xE1, 0x29, 0x75, 0x1D, 0x3A, 0x75, 0xF9, 0x02, 0x48, 0xA4, 0x3E, +/* 0C80 */ 0x5D, 0x04, 0xB8, 0x9F, 0x3E, 0x5D, 0x04, 0x65, 0x48, 0xA4, 0x40, 0x1C, 0x75, 0x2A, 0x25, 0x96, +/* 0C90 */ 0x29, 0x52, 0x00, 0x48, 0x0B, 0x9B, 0x94, 0x10, 0x0A, 0xFD, 0xF5, 0x9B, 0x9A, 0x86, 0xF4, 0x8F, +/* 0CA0 */ 0x07, 0xF4, 0x67, 0x73, 0xF4, 0x4A, 0x0E, 0xF4, 0x5A, 0x0F, 0xF4, 0x4A, 0x0E, 0xF4, 0x67, 0x73, +/* 0CB0 */ 0xF4, 0x8F, 0x07, 0x3F, 0x9B, 0x9A, 0x86, 0x3F, 0xBE, 0x07, 0x01, 0x10, 0x08, 0xFD, 0xC4, 0x54, +/* 0CC0 */ 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x07, 0xFD, 0x55, 0x78, 0x00, 0xA7, 0x0E, 0x80, 0x0A, 0x00, 0xA7, +/* 0CD0 */ 0x1E, 0xD8, 0x0F, 0x31, 0xA7, 0x0E, 0x80, 0x25, 0xA7, 0x1E, 0xD8, 0x07, 0x10, 0x09, 0xBF, 0x82, +/* 0CE0 */ 0x1C, 0x8D, 0x98, 0x0E, 0xE2, 0x7B, 0x2B, 0x67, 0x78, 0x02, 0x6E, 0x05, 0x22, 0x06, 0x44, 0x7A, +/* 0CF0 */ 0x9F, 0x01, 0x70, 0x0A, 0x00, 0x2C, 0x18, 0x00, 0x0E, 0xBE, 0x00, 0x2C, 0x9F, 0x5B, 0x0A, 0x73, +/* 0D00 */ 0x2D, 0xF9, 0x3D, 0x4A, 0x0C, 0x2B, 0x6D, 0x0B, 0x5B, 0x0A, 0x73, 0x5B, 0x2C, 0x9A, 0x9B, 0xBE, +/* 0D10 */ 0x6C, 0x0C, 0x1C, 0x8D, 0x01, 0x10, 0x0A, 0xFD, 0x0F, 0x7B, 0x5B, 0x0C, 0xC5, 0xC5, 0xC5, 0x73, +/* 0D20 */ 0x3F, 0x0E, 0x80, 0xBE, 0x3F, 0x55, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0x73, 0x10, 0x04, 0x9D, 0xA5, +/* 0D30 */ 0xD8, 0xE0, 0x10, 0x05, 0x44, 0x84, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, +/* 0D40 */ 0x40, 0x0C, 0x83, 0x3E, 0xE1, 0x07, 0x68, 0x0F, 0x78, 0x64, 0x0B, 0xD2, 0x10, 0x09, 0x1D, 0x84, +/* 0D50 */ 0xF4, 0x4A, 0x75, 0xCF, 0x07, 0x2A, 0x0F, 0x6A, 0xF4, 0x4D, 0x46, 0x0F, 0x7B, 0x07, 0x0F, 0x63, +/* 0D60 */ 0xA7, 0x77, 0x7B, 0x00, 0xA7, 0x0B, 0xA4, 0x00, 0xA7, 0x07, 0x0C, 0x0F, 0x52, 0xA7, 0x07, 0x04, +/* 0D70 */ 0x30, 0xA7, 0x07, 0x53, 0x63, 0xF4, 0x03, 0x0F, 0x83, 0xF4, 0x4A, 0x59, 0x10, 0x07, 0x9D, 0xA5, +/* 0D80 */ 0xD8, 0xD8, 0xD8, 0xD8, 0x07, 0x01, 0x01, 0x01, 0x1D, 0x46, 0x55, 0x9F, 0xA7, 0x9A, 0x26, 0x10, +/* 0D90 */ 0x0C, 0x7E, 0x0C, 0x30, 0x5B, 0x9A, 0x6A, 0x2D, 0x3A, 0x83, 0x46, 0x0F, 0xA4, 0x2D, 0x0E, 0x43, +/* 0DA0 */ 0x0D, 0xF9, 0x43, 0x7B, 0x2D, 0xBE, 0x0F, 0xA9, 0x73, 0x2E, 0x65, 0x76, 0x95, 0x04, 0x0A, 0x62, +/* 0DB0 */ 0x62, 0x65, 0x46, 0xA4, 0x0F, 0x79, 0x0C, 0x09, 0x83, 0x23, 0x03, 0x9F, 0x83, 0x62, 0x08, 0x93, +/* 0DC0 */ 0x23, 0xE1, 0x00, 0x9B, 0x91, 0x08, 0x73, 0x23, 0x8F, 0x53, 0x59, 0x07, 0x78, 0x65, 0x4E, 0x43, +/* 0DD0 */ 0x00, 0x35, 0x0C, 0x90, 0x43, 0x65, 0x90, 0x43, 0x23, 0x5D, 0x10, 0x0A, 0xFD, 0x47, 0xB2, 0x95, +/* 0DE0 */ 0xC2, 0x4A, 0x93, 0x10, 0x0A, 0xBF, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x09, 0xFD, 0xF5, 0x9B, +/* 0DF0 */ 0x9A, 0x75, 0xF4, 0x07, 0x0F, 0x6A, 0xF4, 0x03, 0x0F, 0x7B, 0xF4, 0x07, 0x3D, 0xCF, 0x9B, 0xBE, +/* 0E00 */ 0xA7, 0x0F, 0x78, 0x87, 0xA7, 0x1E, 0xD8, 0x07, 0x10, 0x0A, 0xBF, 0xF8, 0x0F, 0xE2, 0x7B, 0x1D, +/* 0E10 */ 0x39, 0x26, 0x23, 0x2A, 0x3D, 0x2A, 0xA4, 0x2C, 0x9F, 0x00, 0x46, 0x30, 0x23, 0x7F, 0x18, 0x5B, +/* 0E20 */ 0x76, 0x09, 0x2C, 0x9F, 0x5B, 0xA5, 0x07, 0x23, 0x2A, 0x3D, 0x2A, 0x31, 0x65, 0x6E, 0x39, 0x73, +/* 0E30 */ 0x1D, 0x5D, 0x43, 0x73, 0x02, 0x6C, 0x0C, 0x47, 0xA0, 0x05, 0x68, 0x05, 0x3A, 0x75, 0x00, 0x68, +/* 0E40 */ 0x0C, 0x03, 0x10, 0x09, 0xFD, 0x47, 0x78, 0x09, 0x02, 0xA7, 0x9B, 0x9A, 0x75, 0xF4, 0x07, 0x0F, +/* 0E50 */ 0x6A, 0xF4, 0x03, 0xA4, 0x3F, 0x07, 0x01, 0x09, 0x31, 0xCF, 0x47, 0x83, 0xA7, 0x9B, 0x73, 0x00, +/* 0E60 */ 0xA7, 0x07, 0x06, 0x9F, 0x00, 0xF4, 0x0E, 0x93, 0xA7, 0x07, 0x90, 0x9A, 0x04, 0xF4, 0x6D, 0x0C, +/* 0E70 */ 0x10, 0x08, 0x7E, 0x82, 0x0E, 0x73, 0x07, 0x54, 0x6D, 0x29, 0x7B, 0x1D, 0x5D, 0x04, 0x46, 0x08, +/* 0E80 */ 0x7A, 0xA4, 0x3E, 0x6D, 0x73, 0x06, 0x01, 0x1B, 0x89, 0x9A, 0x78, 0x02, 0xDC, 0x95, 0x93, 0xDA, +/* 0E90 */ 0x0E, 0x1D, 0x82, 0x02, 0x6E, 0x0D, 0x78, 0x1D, 0x0A, 0x9A, 0x9B, 0xA4, 0x42, 0x0C, 0x9B, 0x8B, +/* 0EA0 */ 0x10, 0x08, 0x9D, 0x0D, 0x55, 0xBE, 0x1D, 0x0B, 0x69, 0x9A, 0x80, 0x08, 0x1B, 0xED, 0xED, 0xED, +/* 0EB0 */ 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0x10, 0x09, 0x9D, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x08, 0x44, +/* 0EC0 */ 0x84, 0x68, 0x30, 0x5B, 0x76, 0x07, 0x2B, 0x0C, 0x93, 0x00, 0x2A, 0x9F, 0x2D, 0x7F, 0x43, 0x00, +/* 0ED0 */ 0x90, 0x43, 0x48, 0x18, 0x4A, 0x0B, 0x2B, 0x6E, 0xA4, 0x67, 0x7B, 0x54, 0x0C, 0x0F, 0xD2, 0x9F, +/* 0EE0 */ 0x58, 0x0C, 0x03, 0x43, 0x5B, 0x48, 0xA4, 0x93, 0x32, 0xBE, 0x7B, 0x32, 0x0B, 0x47, 0x04, 0xDB, +/* 0EF0 */ 0x47, 0x10, 0x0C, 0x9D, 0x0C, 0x83, 0x00, 0x03, 0x0F, 0x62, 0x2A, 0x18, 0x44, 0x0A, 0x73, 0xF9, +/* 0F00 */ 0x0F, 0x93, 0x00, 0x8F, 0x44, 0x7F, 0x78, 0x90, 0x0F, 0x78, 0x90, 0x78, 0x65, 0x8F, 0x4A, 0x0C, +/* 0F10 */ 0x0F, 0x5A, 0x0A, 0x65, 0x03, 0x26, 0x0C, 0x0D, 0x95, 0x89, 0x2E, 0x5B, 0x6E, 0x9F, 0xA0, 0x07, +/* 0F20 */ 0x0F, 0x04, 0x0D, 0x91, 0x23, 0x0E, 0x6A, 0x62, 0x05, 0x91, 0x1C, 0x04, 0x23, 0x0C, 0x62, 0x7B, +/* 0F30 */ 0x03, 0x62, 0x18, 0x65, 0x4A, 0x3A, 0xA1, 0x78, 0x43, 0x2D, 0x36, 0x18, 0x00, 0x0E, 0xBE, 0x23, +/* 0F40 */ 0x4E, 0x47, 0x5B, 0x0C, 0x0F, 0x83, 0x10, 0x08, 0x9D, 0xA3, 0x52, 0x7F, 0x18, 0x3F, 0x06, 0x00, +/* 0F50 */ 0xBC, 0x2B, 0x0A, 0x93, 0x05, 0x0F, 0x52, 0x98, 0xBE, 0x2E, 0x1B, 0x0A, 0x9A, 0x52, 0xDB, 0x0F, +/* 0F60 */ 0x43, 0x3E, 0x3C, 0xEF, 0x06, 0x0F, 0x71, 0x78, 0x1B, 0x3A, 0x08, 0x02, 0xA4, 0x2B, 0x4E, 0x18, +/* 0F70 */ 0x53, 0x0D, 0x2B, 0x67, 0x73, 0x5B, 0x8F, 0x05, 0x10, 0x09, 0x9D, 0x0D, 0x73, 0x5B, 0x6D, 0x09, +/* 0F80 */ 0x00, 0x2C, 0xCE, 0x31, 0x45, 0xBE, 0xF1, 0x09, 0xF1, 0x09, 0x10, 0x08, 0x9D, 0x8F, 0x47, 0x7B, +/* 0F90 */ 0x2B, 0xF9, 0x70, 0x1C, 0x7B, 0x32, 0x53, 0x63, 0x44, 0x96, 0x07, 0x68, 0x0D, 0x78, 0x32, 0x7F, +/* 0FA0 */ 0x31, 0x45, 0x0F, 0x83, 0x32, 0x53, 0x63, 0x44, 0x96, 0x19, 0x0B, 0x9A, 0x70, 0xA2, 0x1D, 0x0C, +/* 0FB0 */ 0x55, 0xA4, 0x10, 0x05, 0x1D, 0x33, 0xB8, 0x70, 0x05, 0x5B, 0x58, 0xA4, 0x5B, 0x58, 0xC7, 0xC7, +/* 0FC0 */ 0xC7, 0xC7, 0x78, 0x05, 0x5B, 0x58, 0xA4, 0x10, 0x07, 0x4B, 0x0A, 0x74, 0x40, 0x0C, 0x7B, 0x6F, +/* 0FD0 */ 0x0A, 0x65, 0x6C, 0x43, 0x5B, 0x68, 0x9F, 0x40, 0x0C, 0x91, 0x40, 0x09, 0x83, 0x65, 0x6C, 0x78, +/* 0FE0 */ 0x72, 0x18, 0x3E, 0x67, 0x91, 0x40, 0x09, 0x62, 0xD5, 0x78, 0x23, 0xA7, 0x24, 0x0E, 0x6A, 0x00, +/* 0FF0 */ 0xB8, 0x60, 0x10, 0x05, 0x2B, 0x3B, 0x09, 0x70, 0x34, 0x53, 0x31, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, +/* 1000 */ 0xDF, 0x1B, 0x09, 0x0D, 0x31, 0x54, 0x53, 0x31, 0x10, 0x08, 0x00, 0x3B, 0x96, 0x19, 0x0D, 0x9A, +/* 1010 */ 0x52, 0x00, 0x7A, 0x73, 0xA3, 0x08, 0x54, 0x6D, 0x05, 0x03, 0x18, 0x2B, 0x7F, 0x78, 0x5B, 0x0B, +/* 1020 */ 0x83, 0x10, 0x08, 0x33, 0xBF, 0x85, 0x0B, 0x70, 0x70, 0x05, 0x2B, 0x67, 0x55, 0xA4, 0x10, 0x05, +/* 1030 */ 0x7C, 0x64, 0x5B, 0x67, 0x09, 0x64, 0xF7, 0x57, 0x40, 0x35, 0x04, 0x10, 0x08, 0x41, 0x7F, 0xB3, +/* 1040 */ 0x99, 0x10, 0x09, 0x2B, 0x28, 0xBB, 0x29, 0x62, 0x22, 0x09, 0x4A, 0x0E, 0x22, 0x04, 0x4E, 0x18, +/* 1050 */ 0x2B, 0x03, 0x31, 0x06, 0x9F, 0x2B, 0x03, 0x31, 0x06, 0x18, 0x2B, 0x03, 0x0F, 0x7B, 0x53, 0x0E, +/* 1060 */ 0x22, 0x29, 0x7B, 0x22, 0x06, 0x0D, 0x71, 0x10, 0x07, 0x00, 0x41, 0x7F, 0x69, 0x8B, 0x54, 0x4A, +/* 1070 */ 0x43, 0x62, 0xE3, 0x97, 0xB8, 0x18, 0x65, 0x22, 0x07, 0x00, 0x34, 0x53, 0x29, 0x08, 0x5F, 0x09, +/* 1080 */ 0x9B, 0x8B, 0x10, 0x09, 0x65, 0x28, 0x48, 0x05, 0x03, 0x40, 0xBD, 0x0D, 0x1D, 0x6E, 0x0B, 0x5E, +/* 1090 */ 0x0B, 0x78, 0x54, 0xCC, 0xB1, 0xEA, 0x54, 0x9C, 0x93, 0x07, 0x78, 0x10, 0x08, 0x41, 0x6E, 0x09, +/* 10A0 */ 0xAF, 0xC1, 0x10, 0x05, 0x28, 0x7A, 0x61, 0x0A, 0x21, 0x4E, 0x47, 0x52, 0x54, 0x53, 0x86, 0x02, +/* 10B0 */ 0x32, 0x0C, 0x62, 0x3E, 0x3C, 0x6A, 0x1B, 0x0C, 0x0F, 0x43, 0x0D, 0x02, 0x32, 0x0C, 0x62, 0x40, +/* 10C0 */ 0xFE, 0x40, 0xFE, 0x40, 0xFE, 0x10, 0x08, 0x2B, 0xBF, 0x68, 0x03, 0x09, 0x09, 0x98, 0x0B, 0x3C, +/* 10D0 */ 0x0D, 0x1D, 0x6D, 0x1C, 0x7B, 0x01, 0x5B, 0x2C, 0x0F, 0x52, 0x03, 0x0F, 0x52, 0xFC, 0x0D, 0x6E, +/* 10E0 */ 0x31, 0x00, 0x2C, 0x18, 0x05, 0x9F, 0x2B, 0x6E, 0x0D, 0x47, 0x93, 0x1B, 0x09, 0x73, 0x0C, 0x87, +/* 10F0 */ 0x54, 0x76, 0x80, 0x0B, 0xEF, 0x09, 0x3C, 0x91, 0x00, 0x68, 0x0C, 0x73, 0x1D, 0x61, 0x03, 0x5B, +/* 1100 */ 0x0B, 0x93, 0x1D, 0x0A, 0x43, 0x0A, 0x88, 0x6A, 0x1D, 0x9E, 0x0E, 0x43, 0x94, 0x10, 0x08, 0x65, +/* 1110 */ 0x7C, 0x68, 0x04, 0x06, 0x02, 0x5B, 0x5C, 0x1A, 0x5B, 0x22, 0x35, 0x0E, 0xA6, 0x22, 0x9A, 0xA4, +/* 1120 */ 0x22, 0x0A, 0x6D, 0x4C, 0x3A, 0x4C, 0x3A, 0x4C, 0xFB, 0x10, 0x04, 0x28, 0xCD, 0x21, 0x2F, 0xC0, +/* 1130 */ 0x31, 0x10, 0x04, 0x28, 0xCD, 0x21, 0x2F, 0xC0, 0x31, 0x32, 0x09, 0x26, 0xDB, 0x0F, 0x62, 0x65, +/* 1140 */ 0x48, 0x62, 0x00, 0x72, 0x10, 0x08, 0x2B, 0x28, 0xA9, 0x0A, 0x03, 0x3E, 0x1A, 0x5C, 0x03, 0x31, +/* 1150 */ 0x09, 0x73, 0x22, 0x04, 0x03, 0x9A, 0x04, 0x22, 0x04, 0x0B, 0x83, 0x98, 0x0F, 0x62, 0x18, 0x98, +/* 1160 */ 0x0F, 0x93, 0x18, 0x98, 0x0F, 0x6A, 0x0E, 0x62, 0x00, 0x22, 0x04, 0x08, 0x26, 0x22, 0x04, 0x02, +/* 1170 */ 0x30, 0x22, 0x04, 0x4A, 0x52, 0x10, 0x04, 0x2B, 0x28, 0x8C, 0x08, 0x02, 0x3E, 0xFF, 0xFF, 0xFF, +/* 1180 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA5, 0x52, 0xB8, 0x0E, 0xA8, 0x10, 0x0C, 0x41, 0x03, +/* 1190 */ 0x9A, 0x51, 0x71, 0x9C, 0x71, 0x23, 0x03, 0x9A, 0x43, 0x9A, 0x9B, 0x31, 0x44, 0x03, 0x30, 0xA5, +/* 11A0 */ 0xD2, 0xA4, 0x65, 0xAD, 0xB9, 0x65, 0xAD, 0xB9, 0x65, 0xAD, 0xB9, 0x10, 0x08, 0x41, 0xE9, 0x4C, +/* 11B0 */ 0x3A, 0x4C, 0xFB, 0x10, 0x09, 0x41, 0x6E, 0xB4, 0xF6, 0x10, 0x09, 0x41, 0x03, 0x0F, 0x6A, 0x3A, +/* 11C0 */ 0x8E, 0x22, 0x29, 0x62, 0xAE, 0xDE, 0x22, 0x09, 0x69, 0x08, 0x54, 0x1A, 0x5C, 0x01, 0x05, 0x03, +/* 11D0 */ 0x01, 0x10, 0x09, 0x41, 0x6E, 0x0B, 0x5E, 0x08, 0x78, 0x54, 0xCC, 0xB1, 0xEA, 0x54, 0x9C, 0x93, +/* 11E0 */ 0x0A, 0x78, 0x40, 0xBD, 0x0D, 0x5B, 0x68, 0x03, 0x04, 0x10, 0x06, 0x41, 0x03, 0x0F, 0x6A, 0x0D, +/* 11F0 */ 0x0C, 0x00, 0x98, 0x47, 0x71, 0x5B, 0x22, 0x86, 0xDC, 0x0F, 0x7B, 0x5B, 0x5C, 0x1A, 0x5C, 0x10, +/* 1200 */ 0x07, 0x41, 0x4E, 0x0D, 0x78, 0x08, 0x1B, 0xE1, 0x0E, 0x9F, 0x58, 0x0E, 0x6E, 0x04, 0x5B, 0x96, +/* 1210 */ 0x94, 0x3E, 0x77, 0xBE, 0x02, 0x68, 0x07, 0x0F, 0x62, 0x54, 0x8C, 0x5B, 0x4D, 0x00, 0x4A, 0x43, +/* 1220 */ 0xA4, 0x54, 0x9E, 0x0E, 0x5E, 0x06, 0x10, 0x06, 0x84, 0x6E, 0x24, 0xBC, 0x32, 0xBC, 0x1B, 0x0F, +/* 1230 */ 0x55, 0x34, 0x3A, 0x43, 0x75, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0x0E, 0x62, +/* 1240 */ 0xE6, 0x9A, 0x50, 0x32, 0x89, 0x0E, 0xA2, 0x10, 0x08, 0x41, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10, +/* 1250 */ 0x08, 0x41, 0x0E, 0x62, 0x5B, 0x0E, 0x7B, 0x1D, 0x0A, 0x73, 0x46, 0x9F, 0x2B, 0x4E, 0x43, 0xF9, +/* 1260 */ 0x43, 0x1D, 0x46, 0x18, 0x08, 0x83, 0x54, 0x67, 0x6A, 0x88, 0xEF, 0x95, 0x08, 0x3A, 0x21, 0xF9, +/* 1270 */ 0x73, 0x43, 0x32, 0x76, 0x83, 0x3E, 0x0C, 0xA4, 0x10, 0x0B, 0x41, 0x0D, 0x2E, 0x0A, 0x73, 0x00, +/* 1280 */ 0x81, 0x23, 0x0A, 0x83, 0x67, 0x43, 0x5A, 0x0A, 0x23, 0x81, 0x00, 0x43, 0x97, 0x0B, 0x7B, 0x65, +/* 1290 */ 0x2A, 0x0F, 0x99, 0x0F, 0xA3, 0x51, 0x6A, 0x23, 0xA5, 0x05, 0x91, 0x91, 0x1C, 0x02, 0x2D, 0x1C, +/* 12A0 */ 0x95, 0x02, 0x62, 0x43, 0x2D, 0x53, 0x69, 0x00, 0x0E, 0x0D, 0x73, 0x2B, 0x09, 0xBE, 0x53, 0x62, +/* 12B0 */ 0x2B, 0x5D, 0x0A, 0x5A, 0x7B, 0x10, 0x08, 0x41, 0x0A, 0x78, 0x90, 0x0F, 0x52, 0x22, 0x51, 0x2E, +/* 12C0 */ 0x1D, 0x4A, 0x88, 0x52, 0x45, 0x0F, 0x30, 0x32, 0x67, 0xA4, 0x5B, 0x6C, 0x43, 0x78, 0x1B, 0x67, +/* 12D0 */ 0x91, 0x0E, 0x91, 0x7A, 0x0F, 0x52, 0x09, 0x78, 0x1D, 0x67, 0x62, 0x00, 0x03, 0xA4, 0x10, 0x08, +/* 12E0 */ 0x41, 0xBC, 0x3A, 0xAA, 0x10, 0x07, 0x41, 0x08, 0x47, 0xA4, 0x54, 0x79, 0x69, 0xA4, 0x32, 0x53, +/* 12F0 */ 0x75, 0x5B, 0x7A, 0x31, 0x45, 0x0E, 0x62, 0x32, 0x4A, 0x52, 0x44, 0x96, 0x05, 0x3E, 0x0C, 0x9A, +/* 1300 */ 0x80, 0xA2, 0x54, 0x0C, 0x55, 0x6A, 0x10, 0x05, 0x7C, 0x89, 0x20, 0x32, 0x53, 0x6A, 0x3E, 0x0E, +/* 1310 */ 0x91, 0x40, 0x1C, 0xDD, 0x92, 0x9F, 0x32, 0x67, 0x62, 0x40, 0x0C, 0x93, 0x40, 0x76, 0x04, 0x40, +/* 1320 */ 0x1C, 0xDD, 0x40, 0x0E, 0x91, 0xDA, 0x6A, 0x3E, 0x89, 0x20, 0x10, 0x05, 0x4B, 0xD1, 0x73, 0x40, +/* 1330 */ 0xD1, 0x73, 0x40, 0x81, 0x40, 0x81, 0x40, 0x81, 0x10, 0x05, 0x2B, 0x33, 0xE6, 0x0D, 0x09, 0x3E, +/* 1340 */ 0x4A, 0x7B, 0xDA, 0x09, 0xE6, 0x62, 0xE6, 0x62, 0xE6, 0x62, 0x6F, 0x0C, 0x40, 0x38, 0x2E, 0xDC, +/* 1350 */ 0x3A, 0x19, 0x09, 0x93, 0xE6, 0x62, 0xE6, 0x62, 0xE6, 0x62, 0xDA, 0x09, 0x3E, 0x0A, 0xA4, 0x3E, +/* 1360 */ 0x0A, 0x0D, 0x09, 0x10, 0x08, 0x85, 0x90, 0x0C, 0xD2, 0x02, 0x07, 0x7A, 0x47, 0x43, 0x63, 0x48, +/* 1370 */ 0xD2, 0x07, 0x0E, 0x57, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1F, 0x00, 0x4C, 0x00, 0x74, 0x00, +/* 1380 */ 0xAA, 0x00, 0xD9, 0x00, 0xE2, 0x01, 0x1D, 0x01, 0x2F, 0x01, 0x81, 0x01, 0xAF, 0x01, 0xDE, 0x01, +/* 1390 */ 0xF0, 0x01, 0xFA, 0x02, 0x37, 0x02, 0x40, 0x02, 0x58, 0x02, 0x6A, 0x02, 0x84, 0x02, 0x9E, 0x02, +/* 13A0 */ 0xAA, 0x02, 0xD2, 0x03, 0x04, 0x03, 0x08, 0x03, 0x19, 0x03, 0x2D, 0x03, 0x58, 0x03, 0x88, 0x03, +/* 13B0 */ 0xAA, 0x03, 0xE3, 0x04, 0x24, 0x04, 0x4B, 0x04, 0x5F, 0x04, 0x67, 0x04, 0x7C, 0x04, 0x90, 0x04, +/* 13C0 */ 0xA8, 0x04, 0xC3, 0x04, 0xFE, 0x05, 0x33, 0x05, 0x41, 0x05, 0x54, 0x05, 0x60, 0x05, 0x77, 0x05, +/* 13D0 */ 0x86, 0x05, 0x97, 0x05, 0xA9, 0x05, 0xBE, 0x06, 0x02, 0x06, 0x1A, 0x06, 0x26, 0x06, 0x37, 0x06, +/* 13E0 */ 0x42, 0x06, 0x59, 0x06, 0x6D, 0x06, 0x90, 0x06, 0xD9, 0x06, 0xED, 0x07, 0x01, 0x07, 0x14, 0x07, +/* 13F0 */ 0x2B, 0x07, 0x3D, 0x07, 0x61, 0x07, 0x9F, 0x07, 0xAE, 0x07, 0xBF, 0x07, 0xD5, 0x07, 0xE9, 0x07, +/* 1400 */ 0xFE, 0x08, 0x17, 0x08, 0x56, 0x08, 0x7D, 0x08, 0x88, 0x08, 0x98, 0x08, 0xA7, 0x08, 0xBA, 0x08, +/* 1410 */ 0xCA, 0x08, 0xDB, 0x08, 0xEE, 0x09, 0x01, 0x09, 0x41, 0x09, 0x57, 0x09, 0x69, 0x09, 0x7B, 0x09, +/* 1420 */ 0x90, 0x09, 0xA3, 0x09, 0xB9, 0x09, 0xCB, 0x0A, 0x01, 0x0A, 0x0D, 0x0A, 0x22, 0x0A, 0x30, 0x0A, +/* 1430 */ 0x45, 0x0A, 0x56, 0x0A, 0x69, 0x03, 0x00, 0x10, 0x04, 0x41, 0x03, 0xA0, 0x6F, 0x59, 0x3E, 0x38, +/* 1440 */ 0x0A, 0x2D, 0x3B, 0x72, 0x78, 0xD9, 0x78, 0x23, 0x48, 0x43, 0x40, 0xE1, 0x23, 0x96, 0xD5, 0x26, +/* 1450 */ 0x44, 0x7A, 0x18, 0x10, 0x07, 0xBF, 0x53, 0x00, 0xDA, 0x23, 0x48, 0x0D, 0x62, 0x21, 0x4E, 0x47, +/* 1460 */ 0x93, 0x54, 0x6D, 0x09, 0x8C, 0x21, 0xED, 0x07, 0x26, 0xB8, 0x26, 0x44, 0x7A, 0x9F, 0x3E, 0x76, +/* 1470 */ 0xD2, 0x05, 0x01, 0x54, 0x7F, 0x47, 0x83, 0x5B, 0x6C, 0x0E, 0x83, 0x02, 0x32, 0x53, 0x00, 0xDA, +/* 1480 */ 0x10, 0x08, 0xBF, 0x51, 0x9B, 0x08, 0x45, 0x1C, 0x9B, 0x91, 0x7A, 0x26, 0x01, 0x25, 0x42, 0x9A, +/* 1490 */ 0x44, 0x6C, 0x1C, 0x78, 0x8D, 0x7A, 0x55, 0x62, 0x00, 0x42, 0x9A, 0x00, 0xB8, 0x43, 0xE6, 0x62, +/* 14A0 */ 0x44, 0x58, 0x78, 0x70, 0x05, 0xFC, 0x47, 0x9F, 0x10, 0x08, 0x4F, 0xFD, 0x06, 0x44, 0x4E, 0x03, +/* 14B0 */ 0xFC, 0x0A, 0x0E, 0x71, 0x83, 0x2B, 0x6E, 0x0D, 0x43, 0x1C, 0x52, 0x54, 0x0E, 0x52, 0x01, 0x0D, +/* 14C0 */ 0x97, 0x2B, 0x46, 0x93, 0x5B, 0x0A, 0x59, 0x54, 0x0E, 0x52, 0x01, 0x0D, 0x97, 0x2B, 0x6E, 0x0D, +/* 14D0 */ 0x43, 0x1C, 0x52, 0xFC, 0x0A, 0x9B, 0x0A, 0x83, 0x2B, 0x46, 0x06, 0x44, 0xF9, 0x02, 0x10, 0x08, +/* 14E0 */ 0x9D, 0x0D, 0x62, 0x00, 0x2A, 0x9F, 0x2D, 0xF9, 0x0F, 0x52, 0x4A, 0x0A, 0x1D, 0x67, 0x91, 0x01, +/* 14F0 */ 0x18, 0x6C, 0x0F, 0x8D, 0x62, 0x5F, 0x0C, 0x29, 0x34, 0x3C, 0x31, 0x48, 0x05, 0x30, 0xA1, 0x54, +/* 1500 */ 0x0C, 0x3A, 0x43, 0x57, 0x54, 0x1C, 0x55, 0x04, 0x5F, 0xA4, 0x00, 0x68, 0xA4, 0x10, 0x05, 0x4B, +/* 1510 */ 0xD1, 0x73, 0x44, 0x28, 0xD1, 0x73, 0x10, 0x08, 0x7E, 0xA9, 0x9B, 0x8B, 0x5B, 0xFC, 0x43, 0x73, +/* 1520 */ 0x54, 0x67, 0x7B, 0x46, 0x34, 0x0C, 0x73, 0x04, 0x44, 0x6C, 0x47, 0x57, 0x1D, 0x6E, 0x0D, 0x20, +/* 1530 */ 0x3A, 0x52, 0x48, 0x43, 0x5B, 0x0E, 0x59, 0xA7, 0x0C, 0x06, 0x0F, 0x52, 0x54, 0x51, 0x0F, 0xA4, +/* 1540 */ 0x3E, 0x9C, 0x73, 0x5B, 0x48, 0x03, 0xA9, 0x78, 0x1B, 0x3C, 0x7B, 0x5B, 0x48, 0x0A, 0x0C, 0x0B, +/* 1550 */ 0x06, 0x10, 0x07, 0x2B, 0x3B, 0x89, 0x07, 0x7F, 0x8E, 0x42, 0x43, 0x76, 0x05, 0x98, 0x71, 0x00, +/* 1560 */ 0x0B, 0x0D, 0x02, 0x10, 0x0C, 0x00, 0x28, 0x6C, 0x0C, 0x9B, 0x0A, 0x03, 0x00, 0xFC, 0x43, 0x1C, +/* 1570 */ 0xA8, 0x2D, 0xF9, 0x93, 0x07, 0x0C, 0x0B, 0x79, 0x52, 0x2D, 0x0C, 0x0C, 0x03, 0x9A, 0x62, 0x03, +/* 1580 */ 0x91, 0x2D, 0x7B, 0x08, 0x6A, 0x01, 0x01, 0x00, 0x0C, 0x0A, 0x65, 0x6E, 0x6A, 0x0A, 0x97, 0x44, +/* 1590 */ 0x0A, 0x0B, 0x2D, 0x91, 0x09, 0x59, 0x6E, 0x00, 0x0C, 0x0A, 0x2D, 0x0C, 0x0C, 0x8F, 0x71, 0x03, +/* 15A0 */ 0x91, 0x23, 0xF9, 0x83, 0x09, 0x0E, 0x0D, 0x08, 0x0D, 0x52, 0x2B, 0x09, 0x9A, 0x9B, 0x9A, 0x04, +/* 15B0 */ 0x6C, 0x0C, 0x9B, 0x0A, 0x03, 0x10, 0x07, 0x84, 0x06, 0x61, 0x0B, 0x34, 0x53, 0x0F, 0x43, 0x00, +/* 15C0 */ 0x45, 0x01, 0x76, 0x21, 0xF9, 0x3A, 0x9F, 0x1D, 0x46, 0x43, 0x6D, 0x03, 0x6C, 0x78, 0x02, 0x9F, +/* 15D0 */ 0x00, 0x22, 0x43, 0x7B, 0x1B, 0x35, 0x0A, 0x02, 0x09, 0x03, 0x65, 0x33, 0x48, 0x80, 0x70, 0x09, +/* 15E0 */ 0x6C, 0x55, 0x93, 0x10, 0x09, 0x5B, 0x41, 0x9E, 0x02, 0x00, 0x9E, 0x21, 0x0B, 0x62, 0x53, 0x0A, +/* 15F0 */ 0x2B, 0x7F, 0x43, 0xA9, 0x18, 0x2B, 0xE1, 0x07, 0x04, 0x30, 0x5B, 0x2C, 0x9A, 0x8C, 0x18, 0x1D, +/* 1600 */ 0xE1, 0x60, 0x0F, 0x62, 0x42, 0x18, 0x06, 0x9F, 0x54, 0x0A, 0x62, 0x4A, 0x0A, 0x1D, 0x6E, 0x87, +/* 1610 */ 0x6E, 0x87, 0x10, 0x08, 0x1D, 0x85, 0x48, 0x80, 0x70, 0x75, 0x96, 0x55, 0x24, 0x1C, 0x24, 0x1C, +/* 1620 */ 0x64, 0x90, 0x07, 0x01, 0x10, 0x06, 0x1D, 0x85, 0x48, 0x70, 0x57, 0x5B, 0x96, 0x3D, 0x10, 0x09, +/* 1630 */ 0x28, 0x6C, 0x0C, 0x0E, 0x8D, 0x1B, 0x79, 0xA1, 0x9C, 0x09, 0x2B, 0x6E, 0x74, 0x0E, 0x93, 0x02, +/* 1640 */ 0x59, 0x2D, 0xF9, 0x0D, 0x00, 0x74, 0x74, 0x0B, 0x07, 0x2B, 0x35, 0x00, 0x0E, 0x93, 0x00, 0x09, +/* 1650 */ 0x08, 0x2D, 0xF9, 0x0D, 0x00, 0x0E, 0x07, 0x0C, 0x00, 0x0B, 0x07, 0x2D, 0x6E, 0x74, 0x0B, 0x82, +/* 1660 */ 0x05, 0x59, 0x1D, 0x79, 0xA1, 0x9C, 0x09, 0x1B, 0x35, 0x0F, 0x8D, 0x10, 0x05, 0x5B, 0x7C, 0xD5, +/* 1670 */ 0x0D, 0x70, 0xDB, 0x55, 0x10, 0x07, 0x84, 0x04, 0x61, 0xEF, 0x46, 0x1C, 0x3D, 0x7A, 0x91, 0x02, +/* 1680 */ 0x83, 0x00, 0x7A, 0x6A, 0x01, 0x83, 0x45, 0xE2, 0xEF, 0xF9, 0x69, 0x08, 0x10, 0x08, 0x00, 0x7D, +/* 1690 */ 0xFD, 0xBA, 0x0D, 0x72, 0x78, 0x72, 0x78, 0x4F, 0xDC, 0x70, 0x70, 0x54, 0xE1, 0x55, 0x10, 0x06, +/* 16A0 */ 0x84, 0x77, 0xA2, 0x44, 0x48, 0x43, 0x26, 0xDC, 0x00, 0x0C, 0x97, 0x65, 0x48, 0x7B, 0x44, 0x6C, +/* 16B0 */ 0x0E, 0x07, 0x65, 0x22, 0x80, 0x34, 0x04, 0xE8, 0x10, 0x06, 0x4B, 0x35, 0x94, 0x32, 0xE1, 0x43, +/* 16C0 */ 0x3E, 0xA1, 0x88, 0x64, 0x0C, 0x62, 0x40, 0x1C, 0x8E, 0xE6, 0xF2, 0x98, 0x0B, 0x79, 0x59, 0x45, +/* 16D0 */ 0x88, 0xA2, 0x10, 0x05, 0x1F, 0x07, 0x63, 0x32, 0x38, 0x43, 0xEF, 0x46, 0x8D, 0x01, 0x10, 0x08, +/* 16E0 */ 0x41, 0x03, 0xE5, 0xBC, 0x2D, 0x03, 0xE5, 0xBC, 0x2D, 0x03, 0xA4, 0x03, 0x30, 0x22, 0x47, 0x62, +/* 16F0 */ 0x1D, 0x03, 0x0F, 0x69, 0x0A, 0x09, 0x93, 0x1D, 0x03, 0x43, 0x00, 0x6E, 0x01, 0x98, 0x18, 0x00, +/* 1700 */ 0xDC, 0x18, 0x3E, 0x8C, 0x05, 0x01, 0x10, 0x0C, 0xBF, 0x35, 0x3C, 0x43, 0x2D, 0x7F, 0x47, 0x43, +/* 1710 */ 0x0D, 0x43, 0x2B, 0x0E, 0x55, 0x60, 0x43, 0xCF, 0x47, 0x60, 0x43, 0x2B, 0x0F, 0x55, 0x60, 0x43, +/* 1720 */ 0x2B, 0x0B, 0x55, 0x60, 0x43, 0x2B, 0x38, 0x47, 0x60, 0x43, 0x98, 0x88, 0xFA, 0xA3, 0xFA, 0xA3, +/* 1730 */ 0xFA, 0xA3, 0xFA, 0x03, 0x03, 0x01, 0x01, 0xA1, 0x10, 0x04, 0x85, 0xC3, 0x10, 0x05, 0x00, 0xBF, +/* 1740 */ 0x85, 0xD5, 0x0B, 0x2D, 0xFC, 0x8E, 0x00, 0x45, 0x69, 0x6A, 0xDC, 0x69, 0x8E, 0x10, 0x06, 0x84, +/* 1750 */ 0x9C, 0x91, 0x32, 0xE1, 0x91, 0x32, 0x7F, 0x07, 0x91, 0xD5, 0x91, 0xD5, 0x91, 0xD5, 0x91, 0xD5, +/* 1760 */ 0x91, 0x10, 0x07, 0x84, 0x82, 0x0C, 0x0A, 0x03, 0x32, 0x0C, 0xE8, 0x00, 0x48, 0x43, 0x82, 0x62, +/* 1770 */ 0x7A, 0x73, 0x90, 0x93, 0x7A, 0x73, 0x90, 0x93, 0x00, 0x48, 0x43, 0x9E, 0x2E, 0x54, 0x0C, 0xE8, +/* 1780 */ 0x5F, 0x09, 0x0C, 0x94, 0x33, 0xD5, 0x80, 0x70, 0x0A, 0x42, 0x55, 0x93, 0x10, 0x09, 0x41, 0x7F, +/* 1790 */ 0x05, 0x00, 0x90, 0x06, 0x98, 0x0F, 0x74, 0x03, 0x9F, 0x1D, 0x4A, 0x75, 0xA3, 0x75, 0xA7, 0x0A, +/* 17A0 */ 0x02, 0x0E, 0x83, 0x54, 0x0B, 0x73, 0x4A, 0x0D, 0x22, 0x09, 0xA5, 0x09, 0x1D, 0x0B, 0x73, 0x53, +/* 17B0 */ 0x86, 0x2D, 0x2A, 0x0F, 0x63, 0x03, 0x0F, 0x63, 0x7A, 0x25, 0x4E, 0x05, 0x10, 0x0E, 0x1D, 0x84, +/* 17C0 */ 0x8D, 0xD3, 0x07, 0x90, 0x05, 0x23, 0x4E, 0x91, 0x00, 0x0B, 0x52, 0x02, 0x83, 0x23, 0x4E, 0x91, +/* 17D0 */ 0x03, 0x62, 0x7F, 0x59, 0x00, 0xFC, 0x02, 0xE7, 0x1C, 0xEC, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x0E, +/* 17E0 */ 0x1D, 0x84, 0x8D, 0xD3, 0x07, 0x04, 0x69, 0xA6, 0x44, 0x4E, 0x91, 0x00, 0x0B, 0x52, 0x0E, 0x1C, +/* 17F0 */ 0x7B, 0x44, 0x4E, 0x91, 0x03, 0x62, 0x46, 0x8C, 0x91, 0x2D, 0x5A, 0x02, 0x00, 0x6E, 0x0C, 0x0C, +/* 1800 */ 0x2D, 0x46, 0x83, 0x5B, 0x38, 0x8E, 0x2D, 0x7F, 0x59, 0x5B, 0x3A, 0x80, 0x08, 0x65, 0x6E, 0xA0, +/* 1810 */ 0x44, 0x3A, 0x30, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x0E, 0x1D, 0x84, 0x8D, 0x23, 0x7F, 0x9B, 0x07, +/* 1820 */ 0x5B, 0x4E, 0x6A, 0x23, 0x03, 0x80, 0x26, 0x5B, 0x80, 0x2B, 0x67, 0x2E, 0xF9, 0x91, 0x1D, 0x3A, +/* 1830 */ 0x86, 0x00, 0x0C, 0x52, 0x00, 0xFC, 0x04, 0x04, 0x7B, 0x90, 0x05, 0x65, 0xA9, 0x9C, 0x59, 0x0B, +/* 1840 */ 0x52, 0x02, 0x83, 0x44, 0x2A, 0x1C, 0x83, 0x03, 0x62, 0x7F, 0x59, 0x65, 0x6E, 0x04, 0x03, 0x5A, +/* 1850 */ 0x02, 0xE7, 0x1C, 0xEC, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x07, 0x2F, 0xBF, 0xD9, 0x0D, 0x86, 0xB8, +/* 1860 */ 0x31, 0x32, 0x38, 0x0A, 0x2F, 0x5F, 0x05, 0x05, 0x40, 0xE1, 0xDA, 0x0D, 0x3E, 0x0A, 0xA4, 0xDB, +/* 1870 */ 0x30, 0x3E, 0x0B, 0x78, 0xDA, 0x52, 0x51, 0x02, 0x7A, 0x55, 0x62, 0x00, 0x42, 0x3A, 0x8D, 0x10, +/* 1880 */ 0x09, 0x54, 0x68, 0x00, 0xD9, 0x20, 0x00, 0xB8, 0x0F, 0x93, 0x02, 0x92, 0x08, 0x86, 0x2F, 0x96, +/* 1890 */ 0x97, 0xAB, 0xB7, 0x10, 0x09, 0xF3, 0x5B, 0x8F, 0x97, 0xAB, 0xB7, 0x10, 0x09, 0x1D, 0x68, 0x0C, +/* 18A0 */ 0x2E, 0x5F, 0x0C, 0x29, 0x08, 0x1B, 0x6B, 0x05, 0x7F, 0x0C, 0x3B, 0xF9, 0x0F, 0x26, 0xAB, 0xB7, +/* 18B0 */ 0x10, 0x09, 0x2D, 0xD5, 0x8B, 0x03, 0xEF, 0xA5, 0x43, 0x0D, 0x1B, 0x89, 0x82, 0xA8, 0x3B, 0xF9, +/* 18C0 */ 0x0F, 0x26, 0xAB, 0xB7, 0x10, 0x09, 0x00, 0x7D, 0x38, 0x06, 0x00, 0x09, 0xA6, 0x58, 0x0D, 0x02, +/* 18D0 */ 0x31, 0x48, 0x0E, 0x08, 0x00, 0x0B, 0x75, 0x3B, 0x8F, 0x97, 0xAB, 0xB7, 0x10, 0x09, 0x5B, 0x6E, +/* 18E0 */ 0x09, 0x0C, 0x07, 0xB8, 0x0F, 0x9F, 0x32, 0x0A, 0x0C, 0x02, 0x0F, 0xEF, 0x7F, 0x29, 0x04, 0x68, +/* 18F0 */ 0x0B, 0x71, 0x66, 0x96, 0x97, 0xAB, 0xB7, 0x10, 0x0C, 0xBF, 0x5A, 0x55, 0x31, 0x2D, 0x3C, 0x0E, +/* 1900 */ 0x70, 0x02, 0x23, 0xF9, 0x43, 0x3A, 0xEF, 0x0A, 0x62, 0x0B, 0x62, 0x54, 0x76, 0x05, 0x09, 0x43, +/* 1910 */ 0x80, 0x99, 0x23, 0x5D, 0x8C, 0x47, 0x9F, 0x23, 0x0B, 0x73, 0x2A, 0x18, 0x3F, 0x47, 0x31, 0x2C, +/* 1920 */ 0x9A, 0x70, 0xA4, 0x2B, 0x0C, 0x78, 0x5B, 0x67, 0x43, 0x80, 0x0B, 0x44, 0x03, 0x30, 0x44, 0x0A, +/* 1930 */ 0x47, 0x78, 0x10, 0x08, 0xBF, 0x82, 0x9B, 0x94, 0x98, 0x0E, 0xE2, 0x75, 0x2B, 0x53, 0x75, 0xF9, +/* 1940 */ 0x03, 0xA7, 0x19, 0x5D, 0x04, 0xB8, 0x9F, 0xB8, 0x9F, 0xB8, 0x31, 0x44, 0x48, 0x30, 0x40, 0x1C, +/* 1950 */ 0xA8, 0x8C, 0x06, 0x42, 0x9A, 0xE8, 0x58, 0x9A, 0x20, 0x32, 0x6B, 0x0B, 0x24, 0x0E, 0x93, 0x44, +/* 1960 */ 0x6C, 0x0D, 0x26, 0x5B, 0x7A, 0x9B, 0x07, 0x10, 0x08, 0x33, 0x2C, 0x0C, 0xEE, 0x40, 0x72, 0xC4, +/* 1970 */ 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x5B, 0x66, 0x24, 0x9C, 0x08, 0xD0, 0x09, 0x09, 0x25, +/* 1980 */ 0x40, 0x72, 0xC4, 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x2F, 0xF7, 0x27, 0x46, 0xC4, 0x54, +/* 1990 */ 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x00, 0x7D, 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x07, +/* 19A0 */ 0xD6, 0x03, 0x71, 0x33, 0x92, 0xC4, 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x04, 0x66, 0xD5, 0x57, +/* 19B0 */ 0x3E, 0x4A, 0x83, 0xD9, 0x09, 0x0B, 0x66, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x66, 0x24, 0x89, 0x0A, +/* 19C0 */ 0xB8, 0x9A, 0x75, 0x1B, 0x7F, 0x0A, 0x25, 0x66, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x65, 0x72, 0x0E, +/* 19D0 */ 0x6A, 0x32, 0x6B, 0x43, 0x6A, 0x1B, 0xCB, 0x09, 0x2D, 0x33, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x4F, +/* 19E0 */ 0x51, 0xA1, 0x0B, 0x08, 0x1B, 0x0B, 0x83, 0x05, 0x26, 0x7A, 0x50, 0x6B, 0x0B, 0x2D, 0x33, 0xA7, +/* 19F0 */ 0xD8, 0xE0, 0x10, 0x0A, 0x7E, 0x3A, 0x43, 0x0D, 0x09, 0x21, 0x0D, 0x43, 0x0D, 0x9A, 0x74, 0x2B, +/* 1A00 */ 0x67, 0x93, 0x46, 0x0E, 0x93, 0x2B, 0x67, 0x93, 0x5B, 0x09, 0x26, 0x23, 0x4A, 0x43, 0x0D, 0x05, +/* 1A10 */ 0x06, 0x9F, 0x2D, 0x0C, 0x9A, 0xA4, 0x5D, 0x04, 0x2D, 0x67, 0x93, 0x00, 0x4E, 0x9F, 0x2D, 0x67, +/* 1A20 */ 0x93, 0x5B, 0x09, 0x26, 0x2D, 0x67, 0x93, 0x00, 0xF7, 0x0B, 0x2B, 0x67, 0x43, 0x0D, 0x9A, 0x74, +/* 1A30 */ 0x2B, 0x67, 0x9A, 0x78, 0x09, 0x02, 0x10, 0x0A, 0x1D, 0x68, 0x0B, 0x0A, 0xA9, 0x21, 0x4A, 0x29, +/* 1A40 */ 0xEF, 0x07, 0x07, 0x05, 0x0E, 0x0A, 0x33, 0x92, 0x47, 0xB2, 0x95, 0xC2, 0x4A, 0x93, 0x10, 0x0A, +/* 1A50 */ 0x56, 0xDB, 0x0C, 0xEE, 0x37, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x44, 0x66, 0x24, 0x9C, +/* 1A60 */ 0x08, 0xD0, 0x09, 0x09, 0x25, 0x37, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x66, 0xF7, 0x27, +/* 1A70 */ 0x5B, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x66, 0x09, 0x0B, 0x02, 0x06, 0x34, 0x07, 0xE2, +/* 1A80 */ 0x09, 0x00, 0x6C, 0x09, 0x03, 0x0D, 0x86, 0x3B, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x2F, +/* 1A90 */ 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x06, 0xD6, 0x03, 0x71, 0x3B, 0xF8, 0xB5, 0x39, 0x43, +/* 1AA0 */ 0xD7, 0x10, 0x08, 0x7D, 0x41, 0x09, 0x09, 0x46, 0x99, 0x1D, 0x6E, 0x3A, 0x08, 0x0D, 0x7B, 0x1B, +/* 1AB0 */ 0xF7, 0x62, 0x68, 0x3A, 0x7B, 0x32, 0x0B, 0x93, 0x0E, 0x6A, 0x1D, 0x6E, 0x0C, 0x0C, 0x2A, 0x91, +/* 1AC0 */ 0x5F, 0x01, 0x00, 0x46, 0x10, 0x0A, 0x23, 0x4B, 0x0B, 0x08, 0xD9, 0x78, 0x5B, 0x48, 0x0B, 0x1C, +/* 1AD0 */ 0x62, 0x00, 0x96, 0x9B, 0xA4, 0x1D, 0x0E, 0x93, 0x00, 0x0B, 0x1C, 0x52, 0x2D, 0xE1, 0xA1, 0x91, +/* 1AE0 */ 0x0F, 0x6A, 0x2C, 0x18, 0x05, 0x52, 0x30, 0x2C, 0x26, 0x09, 0x0A, 0x00, 0x0F, 0x62, 0x2C, 0x18, +/* 1AF0 */ 0xA2, 0x01, 0x30, 0x23, 0x2A, 0xA4, 0x0F, 0x02, 0x03, 0x3D, 0x2D, 0x0E, 0x43, 0x0D, 0x5A, 0x52, +/* 1B00 */ 0x2B, 0x8F, 0x9B, 0xA4, 0x58, 0x43, 0x8B, 0x54, 0x53, 0x04, 0x3E, 0x7F, 0x86, 0x10, 0x09, 0x66, +/* 1B10 */ 0x64, 0x44, 0x0C, 0x09, 0x64, 0xF7, 0x50, 0x00, 0x68, 0x05, 0x0B, 0x05, 0x56, 0x49, 0x4D, 0xB6, +/* 1B20 */ 0xC8, 0x10, 0x09, 0x32, 0x68, 0x00, 0xD5, 0x74, 0x32, 0x38, 0x0F, 0x7B, 0x68, 0x0C, 0x08, 0x21, +/* 1B30 */ 0x7D, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x09, 0x2B, 0x6F, 0x75, 0xDB, 0x29, 0x86, 0x1B, 0x0B, 0xD2, +/* 1B40 */ 0x05, 0x99, 0x32, 0x33, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x09, 0x2D, 0xE6, 0x0A, 0xF9, 0x0C, 0x03, +/* 1B50 */ 0x00, 0x22, 0x9C, 0x62, 0x1B, 0x0C, 0x86, 0x07, 0x50, 0x32, 0x33, 0x49, 0x4D, 0xB6, 0xC8, 0x10, +/* 1B60 */ 0x09, 0xF3, 0x0D, 0x73, 0x5B, 0x6D, 0x09, 0x00, 0x2C, 0xCE, 0x31, 0x45, 0xBE, 0xF1, 0x09, 0xF1, +/* 1B70 */ 0x09, 0x10, 0x09, 0x9D, 0xA5, 0x1E, 0x5E, 0x0A, 0x05, 0x00, 0xA7, 0x47, 0x83, 0xA7, 0x07, 0x9E, +/* 1B80 */ 0x9F, 0xF4, 0x03, 0xA4, 0xF4, 0x03, 0xA4, 0xF4, 0x08, 0x31, 0xCF, 0x0E, 0x1C, 0x93, 0xA7, 0x9A, +/* 1B90 */ 0x8D, 0x01, 0xA7, 0x1E, 0x07, 0x10, 0x09, 0x28, 0x7A, 0x61, 0x0A, 0x34, 0x07, 0x47, 0x43, 0x21, +/* 1BA0 */ 0x1C, 0x08, 0xA5, 0x05, 0x2B, 0x46, 0x3D, 0x18, 0x22, 0x04, 0x07, 0x2E, 0x22, 0x05, 0x1C, 0x02, +/* 1BB0 */ 0x00, 0x22, 0x8F, 0x09, 0x00, 0x22, 0x04, 0x08, 0x9A, 0x4C, 0x0A, 0x31, 0x2D, 0x03, 0x31, 0x01, +/* 1BC0 */ 0x30, 0x2B, 0x03, 0x31, 0x6D, 0x08, 0x2B, 0x03, 0x9A, 0x04, 0x77, 0x9F, 0x2B, 0x03, 0x0F, 0x6A, +/* 1BD0 */ 0x0C, 0x0F, 0xA2, 0x10, 0x08, 0x1F, 0x07, 0x57, 0x3E, 0x4A, 0x62, 0xD9, 0x09, 0x0B, 0x37, 0x08, +/* 1BE0 */ 0xB3, 0x99, 0x10, 0x08, 0x00, 0x1F, 0x05, 0x50, 0x68, 0xA3, 0x62, 0x3E, 0x0C, 0x09, 0x02, 0x37, +/* 1BF0 */ 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x4B, 0x2A, 0x0F, 0x74, 0xDC, 0x9B, 0x78, 0x02, 0x1B, 0x09, 0x0C, +/* 1C00 */ 0x02, 0x03, 0x8D, 0x44, 0x68, 0x1B, 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x4B, 0x9E, 0xA6, 0x07, 0x34, +/* 1C10 */ 0x36, 0x43, 0x7B, 0x00, 0x7A, 0x09, 0x04, 0x0D, 0x8E, 0x56, 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x7C, +/* 1C20 */ 0x07, 0x8E, 0x03, 0x8B, 0x1B, 0xA4, 0x09, 0x73, 0x1B, 0x0A, 0x63, 0x04, 0x0E, 0x19, 0x33, 0x7F, +/* 1C30 */ 0xB3, 0x99, 0x10, 0x08, 0x2D, 0x33, 0x51, 0x0B, 0x02, 0x3E, 0x0E, 0xBE, 0x00, 0x45, 0x91, 0x77, +/* 1C40 */ 0x3E, 0x9B, 0x73, 0x44, 0x6C, 0x0E, 0x57, 0x37, 0x08, 0xB3, 0x99, 0x10, 0x0C, 0x41, 0x90, 0x0C, +/* 1C50 */ 0x9B, 0x08, 0x9C, 0x0F, 0xA2, 0x2D, 0x0B, 0x0E, 0x0D, 0x55, 0x3A, 0x6A, 0x65, 0x6E, 0x5B, 0x8F, +/* 1C60 */ 0x07, 0x7F, 0x73, 0x23, 0x03, 0x09, 0x0C, 0x3A, 0x78, 0x69, 0x43, 0x44, 0x46, 0x3C, 0x47, 0x55, +/* 1C70 */ 0x44, 0x7F, 0x9F, 0xA5, 0x05, 0xFC, 0x52, 0xE1, 0x0B, 0x00, 0x4E, 0x23, 0x8F, 0x0E, 0x73, 0x9A, +/* 1C80 */ 0x9B, 0x7B, 0x65, 0x7F, 0x9B, 0xD2, 0x05, 0x0C, 0x43, 0xD2, 0x10, 0x07, 0x66, 0xBF, 0xB8, 0x69, +/* 1C90 */ 0x8B, 0x5B, 0xFC, 0x43, 0x62, 0xE3, 0x97, 0xB8, 0x18, 0x65, 0x96, 0x87, 0xA1, 0x54, 0x67, 0x47, +/* 1CA0 */ 0x2E, 0x98, 0x0E, 0x9A, 0x20, 0x3E, 0x0B, 0x86, 0xDA, 0x75, 0xDC, 0x69, 0x59, 0x44, 0x48, 0x0D, +/* 1CB0 */ 0x71, 0x10, 0x08, 0x1F, 0x03, 0xF0, 0x75, 0x4F, 0x5F, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0x65, 0x7C, +/* 1CC0 */ 0x24, 0x9C, 0x09, 0xD0, 0x09, 0x0A, 0x04, 0x7D, 0x68, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0xD4, 0x7A, +/* 1CD0 */ 0x0E, 0xA1, 0x0B, 0x0A, 0x68, 0x5B, 0x6E, 0x5F, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0x7C, 0xCB, 0x08, +/* 1CE0 */ 0x1B, 0x0B, 0x62, 0x05, 0x26, 0x7A, 0x50, 0x6B, 0x0A, 0x3B, 0x01, 0x09, 0xAF, 0xC1, 0x10, 0x04, +/* 1CF0 */ 0x7C, 0x24, 0xF9, 0x50, 0x6F, 0x0F, 0xA6, 0x92, 0x08, 0x0C, 0x00, 0x37, 0xC0, 0x31, 0x10, 0x04, +/* 1D00 */ 0x7C, 0x6E, 0x64, 0x2A, 0x8D, 0x65, 0xFC, 0x93, 0x3E, 0x0B, 0x09, 0x03, 0x33, 0xC0, 0x31, 0x10, +/* 1D10 */ 0x04, 0x2B, 0x28, 0xF7, 0x25, 0x45, 0x1C, 0x9B, 0x34, 0x07, 0x99, 0x38, 0x09, 0x68, 0x5B, 0x64, +/* 1D20 */ 0xC0, 0x31, 0x10, 0x04, 0x2D, 0x3B, 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x07, 0xD6, 0x03, +/* 1D30 */ 0x71, 0x00, 0x3B, 0xC0, 0x31, 0x10, 0x09, 0x3B, 0x68, 0x65, 0x48, 0x05, 0x01, 0x0B, 0x0A, 0x32, +/* 1D40 */ 0x0A, 0x9A, 0x62, 0x32, 0x38, 0x9A, 0x86, 0x1B, 0x6B, 0x0B, 0x0D, 0x93, 0xD9, 0x31, 0x1D, 0x89, +/* 1D50 */ 0xA0, 0x0D, 0x62, 0x54, 0x3A, 0x43, 0xBE, 0x96, 0x25, 0x0B, 0x43, 0x5B, 0x2C, 0x9A, 0x00, 0x7F, +/* 1D60 */ 0x43, 0x5B, 0x2C, 0x9A, 0x5B, 0x09, 0x78, 0x48, 0x31, 0x3A, 0x08, 0x54, 0x0C, 0xE2, 0x63, 0x1D, +/* 1D70 */ 0x6E, 0x09, 0x0E, 0xA0, 0x03, 0x10, 0x08, 0x28, 0x42, 0x0C, 0x04, 0x04, 0x05, 0x5B, 0x22, 0xBE, +/* 1D80 */ 0x00, 0x98, 0x0B, 0x89, 0x99, 0x56, 0xE9, 0x4C, 0x3A, 0x4C, 0xFB, 0x10, 0x09, 0x1F, 0x02, 0x0E, +/* 1D90 */ 0x07, 0xD5, 0x0E, 0x73, 0x02, 0x00, 0x68, 0x79, 0x21, 0x2D, 0x68, 0xB4, 0xF6, 0x10, 0x09, 0x65, +/* 1DA0 */ 0x7C, 0x24, 0x89, 0x0A, 0x44, 0x7A, 0x1C, 0x75, 0x1B, 0x7F, 0x94, 0x7D, 0x68, 0xB4, 0xF6, 0x10, +/* 1DB0 */ 0x09, 0x4B, 0x6E, 0x0D, 0x7B, 0x68, 0x0C, 0x43, 0x6A, 0x5B, 0x48, 0x50, 0x9E, 0x0C, 0x68, 0x5B, +/* 1DC0 */ 0x6E, 0x5F, 0xB4, 0xF6, 0x10, 0x09, 0x28, 0x42, 0x0C, 0x04, 0x04, 0x06, 0x5B, 0x22, 0xBE, 0x1B, +/* 1DD0 */ 0x89, 0x89, 0x99, 0x4F, 0x5F, 0xB4, 0xF6, 0x10, 0x09, 0x7C, 0x03, 0x8B, 0x00, 0x0A, 0x09, 0x1B, +/* 1DE0 */ 0x09, 0x93, 0x03, 0x18, 0x6C, 0x20, 0x01, 0x0C, 0x0C, 0x3B, 0x01, 0xB4, 0xF6, 0x10, 0x08, 0xBF, +/* 1DF0 */ 0x9C, 0xE4, 0xA0, 0x3B, 0x2A, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x37, 0x9C, 0xE4, 0xA0, 0x10, +/* 1E00 */ 0x09, 0x44, 0xBF, 0x0B, 0x09, 0x72, 0x73, 0x5F, 0x09, 0x1C, 0x62, 0x54, 0x53, 0x43, 0x31, 0x2B, +/* 1E10 */ 0x03, 0x9F, 0x0B, 0x0D, 0x93, 0x1D, 0x81, 0x01, 0x0F, 0x5D, 0x1D, 0x36, 0x94, 0x99, 0x26, 0x2B, +/* 1E20 */ 0x81, 0x09, 0x09, 0xE1, 0x22, 0xA8, 0x09, 0x73, 0x1D, 0x53, 0x43, 0x31, 0x1D, 0x76, 0x73, 0x25, +/* 1E30 */ 0x98, 0x93, 0xD9, 0x0B, 0x06, 0x10, 0x08, 0x1F, 0x04, 0xF0, 0x86, 0x56, 0xE1, 0x8A, 0xAC, 0xCA, +/* 1E40 */ 0x07, 0x10, 0x08, 0x00, 0x3B, 0x68, 0xD9, 0x0D, 0x08, 0x44, 0x58, 0x93, 0x3E, 0x0A, 0x0A, 0x03, +/* 1E50 */ 0x37, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0xD4, 0x7A, 0x99, 0x38, 0x0A, 0x32, 0x24, 0xE1, +/* 1E60 */ 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0x7C, 0xCB, 0x08, 0x1B, 0x0C, 0x62, 0x5D, 0x00, 0x42, 0xA8, +/* 1E70 */ 0x6B, 0x0A, 0x3E, 0x33, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0x00, 0x1F, 0x06, 0x74, 0x00, +/* 1E80 */ 0x45, 0x88, 0x7B, 0x68, 0x0D, 0x87, 0x37, 0xBC, 0x3A, 0xAA, 0x10, 0x09, 0x2B, 0x28, 0xBB, 0x29, +/* 1E90 */ 0x62, 0xAE, 0xDE, 0x22, 0x08, 0x69, 0x08, 0x54, 0x1A, 0x5C, 0x01, 0x04, 0x03, 0x10, 0x08, 0x7C, +/* 1EA0 */ 0x09, 0x8E, 0x51, 0x04, 0x54, 0x76, 0x04, 0x0A, 0x83, 0x1B, 0x0B, 0x0D, 0x8C, 0x20, 0x3E, 0x33, +/* 1EB0 */ 0xBC, 0x3A, 0xAA, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x19, 0x00, 0x0D, 0x08, 0x44, 0x85, 0xE6, +/* 1EC0 */ 0x70, 0x70, 0x0B, 0x1D, 0x0C, 0x0F, 0x55, 0x78, 0x10, 0x08, 0x4F, 0x85, 0x08, 0x80, 0x70, 0x99, +/* 1ED0 */ 0x1D, 0x0A, 0x55, 0x31, 0x10, 0x0C, 0x4F, 0x85, 0x08, 0x70, 0x70, 0x70, 0x99, 0x65, 0x0A, 0x55, +/* 1EE0 */ 0x55, 0x31, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x06, 0xC3, 0x00, +/* 1EF0 */ 0x00, 0x06, 0xC5, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x06, 0xC8, 0x00, +/* 1F00 */ 0x00, 0x07, 0x86, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x13, 0x75, 0x00, +/* 1F10 */ 0x00, 0x14, 0x35, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x1E, 0xB4, 0x00, +/* 1F20 */ 0x00, 0x1E, 0xBC, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold20.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold20.mcufont.h new file mode 100644 index 000000000..740cb599e --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold20.mcufont.h @@ -0,0 +1,637 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 20 + * blob size: 9826, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x05, 0x56, 0x00, 0x00, 0x05, 0xCB, 0x00, 0x00, 0x00, 0x9D, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x26, 0x22, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x04, 0x00, 0x12, 0x00, 0x02, 0x00, 0x14, 0x00, 0x18, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x32, 0x30, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x32, 0x30, 0x00, +/* dictionary data */ +0xC1, 0x82, 0x0E, 0xC1, 0x06, 0xCC, 0xC1, 0xC1, 0xC6, 0xC2, 0x10, +/* 0080 */ 0xCE, 0x81, 0xC2, 0x10, 0xCE, 0x3E, 0x0A, 0xC2, 0x0C, 0x0F, 0xCC, 0x80, 0xC2, 0x82, 0x01, 0xCB, +/* 0090 */ 0x80, 0x0A, 0xCE, 0x81, 0x07, 0x10, 0xCB, 0x05, 0xCE, 0x80, 0xCD, 0xC5, 0x81, 0x0E, 0x10, 0xC9, +/* 00A0 */ 0x81, 0x0D, 0x80, 0xC3, 0x01, 0x81, 0x09, 0x01, 0xC4, 0x01, 0xC5, 0x10, 0xC6, 0x80, 0x11, 0x81, +/* 00B0 */ 0xC6, 0x0B, 0x04, 0xCA, 0xC3, 0x01, 0xCD, 0x80, 0x81, 0xC4, 0x01, 0xC3, 0xC1, 0xCE, 0x85, 0xDE, +/* 00C0 */ 0xC1, 0xCA, 0x0A, 0xCB, 0x87, 0x84, 0xF4, 0xCC, 0xC3, 0x08, 0x80, 0xCB, 0x81, 0xCE, 0xC1, 0x01, +/* 00D0 */ 0xCC, 0x81, 0xC5, 0x0A, 0xC1, 0x82, 0x0C, 0xC2, 0xCB, 0xC5, 0x80, 0xCD, 0xCE, 0xC6, 0x0C, 0xCE, +/* 00E0 */ 0x85, 0x41, 0x1D, 0xC5, 0xCB, 0xC6, 0xCE, 0xC1, 0xCD, 0xC1, 0xCB, 0x0C, 0xC3, 0xC4, 0x01, 0x81, +/* 00F0 */ 0xC7, 0xC8, 0xC1, 0xC9, 0xC1, 0x01, 0xC1, 0xC3, 0xC1, 0xC8, 0x0F, 0xCE, 0x81, 0xC4, 0x10, 0x81, +/* 0100 */ 0xCC, 0x0A, 0x0C, 0x80, 0xC6, 0x02, 0x21, 0x80, 0xC1, 0xC2, 0x10, 0x40, 0x01, 0xCE, 0xC7, 0xCE, +/* 0110 */ 0x82, 0x40, 0x14, 0xD4, 0xCE, 0x81, 0xC4, 0x10, 0xCE, 0x81, 0xC4, 0x10, 0xCE, 0x81, 0xC4, 0x0F, +/* 0120 */ 0x80, 0xCE, 0xC1, 0xC7, 0xC4, 0x81, 0xCD, 0xC1, 0x82, 0xC1, 0x02, 0xC5, 0x81, 0xCD, 0x09, 0xC1, +/* 0130 */ 0x82, 0xC1, 0x02, 0xC2, 0x0A, 0xC6, 0x01, 0x03, 0x19, 0x02, 0xC2, 0xC2, 0x81, 0x81, 0xCD, 0x0B, +/* 0140 */ 0xCD, 0x81, 0x82, 0xE4, 0xCA, 0x81, 0xC6, 0x80, 0xCC, 0xC5, 0x0A, 0xC3, 0x81, 0xCE, 0x81, 0xC7, +/* 0150 */ 0x80, 0xC4, 0xCB, 0xC1, 0x80, 0xC5, 0x81, 0xCA, 0x0A, 0x0A, 0xC9, 0x85, 0xCE, 0x81, 0x02, 0xC8, +/* 0160 */ 0x81, 0xCB, 0x08, 0xC5, 0x82, 0x04, 0xC6, 0x81, 0xCE, 0x08, 0xC6, 0x81, 0xCE, 0xCE, 0x01, 0xCE, +/* 0170 */ 0xC3, 0x01, 0xCA, 0xC1, 0xCE, 0x81, 0xC1, 0x81, 0xCB, 0x01, 0xCD, 0xC3, 0x80, 0xCC, 0x0C, 0xC5, +/* 0180 */ 0xCD, 0x87, 0xC5, 0x81, 0xCE, 0x10, 0xC5, 0x81, 0xCD, 0xC3, 0xCB, 0xC2, 0xCB, 0x2C, 0xC7, 0x81, +/* 0190 */ 0x82, 0xC1, 0xC4, 0x81, 0xC7, 0xCE, 0xC1, 0xC2, 0x81, 0xC9, 0x80, 0xCA, 0x80, 0xC8, 0x01, 0xC6, +/* 01A0 */ 0x80, 0xC3, 0xCA, 0x81, 0xC8, 0xC2, 0x01, 0x40, 0x03, 0xC9, 0xCD, 0x80, 0xC7, 0xCE, 0xCD, 0xCE, +/* 01B0 */ 0xC8, 0xC4, 0xCA, 0xCE, 0xC1, 0xC1, 0x81, 0x81, 0xC5, 0x01, 0x01, 0xC1, 0xCB, 0xCE, 0xD3, 0xC5, +/* 01C0 */ 0xCA, 0x83, 0x1A, 0x40, 0x3B, 0x41, 0x37, 0xC1, 0xC9, 0xC4, 0xC2, 0x22, 0xCC, 0xC7, 0xCD, 0xC1, +/* 01D0 */ 0x12, 0xCD, 0xC7, 0x40, 0x18, 0xCE, 0x80, 0x04, 0x73, 0x00, 0x66, 0x00, 0x66, 0x00, 0x0E, 0x3B, +/* 01E0 */ 0x59, 0x66, 0x2B, 0xB3, 0xA7, 0x0D, 0x3E, 0x77, 0x2E, 0x0A, 0x41, 0x7A, 0x52, 0x08, 0x05, 0x04, +/* 01F0 */ 0x2D, 0x0A, 0x5D, 0x48, 0x03, 0x76, 0x4A, 0x52, 0x0C, 0x73, 0x71, 0x01, 0x0E, 0xA8, 0x71, 0x8F, +/* 0200 */ 0x0C, 0x02, 0x02, 0x71, 0x08, 0x54, 0x00, 0x03, 0x71, 0x06, 0x30, 0x0C, 0x4E, 0x46, 0x6B, 0x01, +/* 0210 */ 0x0E, 0xA8, 0x22, 0x7A, 0x37, 0x03, 0x0C, 0x9E, 0x6C, 0x9C, 0xAE, 0x8B, 0x44, 0xA4, 0x90, 0x5D, +/* 0220 */ 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x18, 0x9A, 0x97, 0x4A, 0x25, +/* 0230 */ 0x04, 0x5D, 0x08, 0x85, 0x31, 0x75, 0xB2, 0x08, 0x0F, 0x36, 0x44, 0x6F, 0x3D, 0x0B, 0x48, 0x9C, +/* 0240 */ 0x67, 0x0C, 0x06, 0x37, 0x8E, 0x22, 0x2F, 0x2C, 0x07, 0x54, 0x2C, 0x07, 0x54, 0x2C, 0x07, 0x54, +/* 0250 */ 0x2C, 0x07, 0xA3, 0x00, 0x22, 0x2F, 0x31, 0x07, 0x99, 0x5D, 0x46, 0x37, 0x03, 0x85, 0x03, 0x7D, +/* 0260 */ 0x5D, 0x29, 0x97, 0x7C, 0x5B, 0x75, 0xAC, 0x0F, 0x5F, 0x37, 0x97, 0x7A, 0x22, 0x0C, 0x00, 0x52, +/* 0270 */ 0x54, 0x99, 0x2B, 0xB4, 0x22, 0x7A, 0x2B, 0x75, 0x67, 0x21, 0x06, 0x30, 0x95, 0x34, 0x7C, 0x19, +/* 0280 */ 0x76, 0x4A, 0x38, 0x78, 0x67, 0x03, 0x2B, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x01, 0x00, 0x22, +/* 0290 */ 0x7C, 0x37, 0x79, 0x08, 0x30, 0x7C, 0x37, 0x0A, 0xA8, 0x72, 0x05, 0x1F, 0xA4, 0xA5, 0xB2, 0x76, +/* 02A0 */ 0x7C, 0xA9, 0x85, 0x5D, 0x22, 0x7C, 0x31, 0x18, 0x9A, 0x03, 0x71, 0x09, 0x54, 0x00, 0x08, 0x36, +/* 02B0 */ 0x37, 0x70, 0x0C, 0x3A, 0xA1, 0x5B, 0x0A, 0x54, 0x99, 0x2E, 0x91, 0x90, 0x2B, 0x22, 0x94, 0x2B, +/* 02C0 */ 0x33, 0x73, 0x02, 0x6D, 0x52, 0x73, 0x38, 0x52, 0x73, 0x4E, 0x29, 0x25, 0x4A, 0x5D, 0x29, 0x1F, +/* 02D0 */ 0xB4, 0x7F, 0x9A, 0x29, 0x1F, 0x0E, 0x45, 0x54, 0x00, 0x29, 0x1F, 0x0E, 0x45, 0x22, 0x0C, 0x00, +/* 02E0 */ 0x29, 0x1F, 0xB4, 0x0C, 0x8F, 0x50, 0x4A, 0x1F, 0x29, 0x02, 0x36, 0x0D, 0x4A, 0x1F, 0xB4, 0x81, +/* 02F0 */ 0x0D, 0x45, 0x0C, 0x4A, 0x1F, 0x0E, 0x67, 0xB4, 0x0C, 0x8D, 0x9E, 0x05, 0x5B, 0xB4, 0x3E, 0xA8, +/* 0300 */ 0x9A, 0x25, 0x0D, 0x05, 0x0C, 0x36, 0x37, 0x73, 0x02, 0x31, 0x08, 0x99, 0x6D, 0x0B, 0x36, 0x31, +/* 0310 */ 0x22, 0x7C, 0x00, 0x69, 0x1F, 0x2A, 0x0C, 0x6F, 0x90, 0x31, 0x06, 0x30, 0x0C, 0x5D, 0x18, 0x02, +/* 0320 */ 0x31, 0x2A, 0x0C, 0x6F, 0x90, 0x31, 0x03, 0x90, 0x33, 0x71, 0x22, 0x95, 0x88, 0x54, 0x37, 0x03, +/* 0330 */ 0x0E, 0x41, 0x1B, 0x5B, 0x98, 0x29, 0x55, 0x35, 0xB3, 0xB4, 0x0C, 0x6C, 0x52, 0x63, 0x99, 0x5B, +/* 0340 */ 0x0C, 0x54, 0x05, 0x72, 0x6B, 0x02, 0x85, 0x97, 0x9D, 0x1F, 0x2A, 0xA8, 0x94, 0x31, 0x97, 0x41, +/* 0350 */ 0x7D, 0x2A, 0x0C, 0x42, 0xAD, 0x78, 0x0E, 0x35, 0x22, 0x95, 0x05, 0x06, 0x0C, 0x08, 0x26, 0x0D, +/* 0360 */ 0x4E, 0x5A, 0x00, 0xB4, 0x2F, 0x02, 0x90, 0x25, 0x02, 0x5D, 0x73, 0x03, 0x25, 0x02, 0x5D, 0x7F, +/* 0370 */ 0x03, 0x25, 0x02, 0x5D, 0x73, 0x02, 0x25, 0x9A, 0x03, 0x7F, 0x1D, 0x30, 0x03, 0x73, 0x38, 0x52, +/* 0380 */ 0x73, 0x38, 0x52, 0x73, 0x5D, 0x0D, 0x96, 0x08, 0x0F, 0x56, 0x26, 0x0A, 0x9D, 0x00, 0x02, 0x41, +/* 0390 */ 0x7C, 0x28, 0x6F, 0x0F, 0xA1, 0x00, 0x02, 0x41, 0x7C, 0x26, 0x09, 0x96, 0x1A, 0x09, 0x9D, 0x26, +/* 03A0 */ 0xA2, 0x02, 0x1A, 0x09, 0x9D, 0x26, 0x08, 0x95, 0x35, 0x09, 0x54, 0x00, 0x25, 0x9A, 0x09, 0x99, +/* 03B0 */ 0x31, 0x6D, 0x08, 0x85, 0x44, 0x0D, 0x54, 0x6D, 0x0D, 0x36, 0x31, 0x06, 0x30, 0x62, 0x05, 0x75, +/* 03C0 */ 0xB0, 0x7E, 0x82, 0x37, 0x4E, 0x29, 0x09, 0x60, 0x21, 0xB3, 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B, +/* 03D0 */ 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B, 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B, 0xA3, 0x21, 0x08, 0xA3, +/* 03E0 */ 0x21, 0x08, 0x2D, 0x9D, 0x21, 0x72, 0x45, 0x2B, 0x70, 0x84, 0x2E, 0x06, 0x94, 0x3B, 0x5B, 0x75, +/* 03F0 */ 0x03, 0x99, 0x2E, 0xB4, 0x0C, 0x00, 0xB4, 0x0C, 0x52, 0x94, 0x24, 0x5F, 0x37, 0x8F, 0x6C, 0x08, +/* 0400 */ 0xA3, 0x1F, 0x0B, 0x54, 0x05, 0x09, 0x94, 0x1F, 0xA2, 0x41, 0x4A, 0x1F, 0x91, 0xA8, 0x5D, 0xAA, +/* 0410 */ 0x25, 0x53, 0x32, 0x46, 0x09, 0xA8, 0x46, 0x04, 0x1F, 0x2A, 0x62, 0x05, 0x75, 0xA1, 0x31, 0x0D, +/* 0420 */ 0x54, 0x6D, 0x0D, 0x54, 0x44, 0x23, 0x9A, 0x80, 0x6D, 0x33, 0x73, 0x44, 0x06, 0x46, 0x6D, 0x33, +/* 0430 */ 0x73, 0x26, 0x33, 0x73, 0x6D, 0x97, 0x4A, 0x44, 0x23, 0x02, 0x00, 0x08, 0x0F, 0x45, 0x4A, 0x1F, +/* 0440 */ 0xB4, 0x81, 0x03, 0x30, 0x29, 0x1F, 0x0E, 0x67, 0x5D, 0x7F, 0x4A, 0x1F, 0x0E, 0x67, 0x5D, 0x2D, +/* 0450 */ 0x4A, 0x1F, 0x0E, 0x67, 0x5D, 0x91, 0x4A, 0x0D, 0x67, 0xAE, 0xB3, 0x02, 0x04, 0x36, 0x00, 0x08, +/* 0460 */ 0x0E, 0x0A, 0x2C, 0x70, 0x7A, 0x21, 0x70, 0x7A, 0x2C, 0x09, 0x0E, 0x0A, 0x6D, 0x8E, 0x25, 0x1D, +/* 0470 */ 0x30, 0x0D, 0x7C, 0x1D, 0x30, 0x1D, 0x30, 0x1D, 0x30, 0x1D, 0x30, 0x2C, 0x75, 0x0A, 0x0F, 0x2C, +/* 0480 */ 0xA2, 0x0C, 0x2C, 0xA2, 0x0C, 0x28, 0x03, 0x0E, 0x41, 0xA1, 0x48, 0x0A, 0x29, 0x5F, 0x34, 0x5F, +/* 0490 */ 0x5B, 0xA4, 0x65, 0x2D, 0x05, 0x04, 0x03, 0x37, 0x03, 0x41, 0x71, 0x03, 0x41, 0x71, 0x5D, 0x97, +/* 04A0 */ 0x5F, 0x34, 0x5F, 0x34, 0x5F, 0x99, 0x2C, 0x08, 0x99, 0x2C, 0x08, 0x99, 0x38, 0x74, 0x42, 0x9A, +/* 04B0 */ 0x78, 0x73, 0x94, 0x37, 0x03, 0x41, 0x94, 0x0B, 0x04, 0x01, 0x0C, 0x0E, 0x05, 0x00, 0x0E, 0x09, +/* 04C0 */ 0x05, 0x0C, 0x6C, 0x1D, 0x30, 0x00, 0xAB, 0x0E, 0x3B, 0x0A, 0x32, 0x0E, 0x1B, 0x38, 0x48, 0x0D, +/* 04D0 */ 0x86, 0x00, 0x0B, 0x4B, 0x5B, 0x07, 0x99, 0x03, 0x5A, 0x6F, 0x0D, 0x30, 0x81, 0x25, 0x49, 0x22, +/* 04E0 */ 0x95, 0x37, 0x3D, 0x82, 0x25, 0x05, 0x0E, 0x0C, 0x93, 0x0D, 0x86, 0x37, 0x24, 0x7A, 0x07, 0x99, +/* 04F0 */ 0x37, 0x33, 0x0E, 0x0C, 0x93, 0x0D, 0x86, 0xA8, 0x95, 0x00, 0x69, 0x35, 0x0C, 0x96, 0x35, 0xB4, +/* 0500 */ 0x03, 0x38, 0x48, 0x87, 0x38, 0x33, 0x0D, 0x4C, 0x0B, 0x5B, 0x79, 0x74, 0x20, 0x0E, 0x3B, 0x59, +/* 0510 */ 0x79, 0x74, 0x2E, 0x63, 0x90, 0x4C, 0x01, 0x5B, 0x66, 0x00, 0x79, 0x42, 0x4C, 0x0E, 0x4C, 0x0E, +/* 0520 */ 0x44, 0x8E, 0x7F, 0x9A, 0x0B, 0x36, 0x0C, 0x30, 0x01, 0x21, 0x5B, 0x08, 0x30, 0x0C, 0x2C, 0x8F, +/* 0530 */ 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0E, 0x36, 0x09, 0x20, +/* 0540 */ 0x2C, 0x18, 0x2C, 0x18, 0x2C, 0x18, 0x2C, 0x06, 0x2C, 0x8A, 0x8A, 0x51, 0x4B, 0x1A, 0x9B, 0x08, +/* 0550 */ 0x21, 0x32, 0x7F, 0x02, 0x5D, 0x09, 0x54, 0x1F, 0x37, 0x32, 0x02, 0x0A, 0x29, 0x55, 0x52, 0x0E, +/* 0560 */ 0x41, 0x1B, 0x37, 0x22, 0x95, 0x05, 0x0C, 0x99, 0x78, 0x5F, 0x7F, 0x9A, 0x09, 0x99, 0x00, 0x25, +/* 0570 */ 0x9A, 0x09, 0x99, 0x00, 0x25, 0x9A, 0x09, 0x99, 0x37, 0x99, 0x27, 0x99, 0x27, 0x99, 0x27, 0x99, +/* 0580 */ 0x27, 0x99, 0x6D, 0x08, 0x0F, 0x95, 0x44, 0x18, 0x02, 0x5D, 0x33, 0x46, 0x4A, 0x55, 0x0C, 0x30, +/* 0590 */ 0x49, 0x22, 0x4A, 0x44, 0x6F, 0x90, 0x00, 0x69, 0x1F, 0x69, 0x5D, 0x69, 0x1F, 0x2A, 0x0C, 0x5D, +/* 05A0 */ 0x69, 0x1F, 0x8B, 0x9D, 0x38, 0x70, 0x02, 0x38, 0x6F, 0x22, 0x54, 0x38, 0x08, 0x95, 0x44, 0x0C, +/* 05B0 */ 0x09, 0x0C, 0x9D, 0x5D, 0xA4, 0xB4, 0x03, 0x1F, 0x0B, 0x9D, 0x6D, 0x07, 0x45, 0x37, 0x0B, 0x9D, +/* 05C0 */ 0x6D, 0x0E, 0x7A, 0x37, 0x0B, 0x00, 0xAA, 0x84, 0x2C, 0x84, 0x2C, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, +/* 05D0 */ 0x04, 0x00, 0x05, 0x00, 0x07, 0x00, 0x09, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x14, 0x00, +/* 05E0 */ 0x15, 0x00, 0x17, 0x00, 0x19, 0x00, 0x1C, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x22, 0x00, 0x23, 0x00, +/* 05F0 */ 0x26, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2A, 0x00, 0x2C, 0x00, 0x2D, 0x00, 0x30, 0x00, 0x31, 0x00, +/* 0600 */ 0x32, 0x00, 0x34, 0x00, 0x36, 0x00, 0x39, 0x00, 0x3A, 0x00, 0x3C, 0x00, 0x3D, 0x00, 0x3E, 0x00, +/* 0610 */ 0x40, 0x00, 0x43, 0x00, 0x46, 0x00, 0x48, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x50, 0x00, +/* 0620 */ 0x51, 0x00, 0x52, 0x00, 0x54, 0x00, 0x55, 0x00, 0x57, 0x00, 0x59, 0x00, 0x61, 0x00, 0x63, 0x00, +/* 0630 */ 0x65, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x74, 0x00, +/* 0640 */ 0x76, 0x00, 0x78, 0x00, 0x7A, 0x00, 0x7C, 0x00, 0x7E, 0x00, 0x81, 0x00, 0x83, 0x00, 0x85, 0x00, +/* 0650 */ 0x8A, 0x00, 0x8D, 0x00, 0x8E, 0x00, 0x90, 0x00, 0x91, 0x00, 0x92, 0x00, 0x94, 0x00, 0x96, 0x00, +/* 0660 */ 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, 0x9F, 0x00, 0xAB, 0x00, 0xAD, 0x00, 0xAF, 0x00, +/* 0670 */ 0xB2, 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC2, 0x00, 0xC3, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00, +/* 0680 */ 0xCB, 0x00, 0xCD, 0x00, 0xCE, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5, 0x00, 0xD8, 0x00, +/* 0690 */ 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE1, 0x00, 0xE4, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xF8, 0x00, +/* 06A0 */ 0xFA, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x02, 0x01, 0x05, 0x01, 0x07, 0x01, 0x0A, 0x01, 0x0C, 0x01, +/* 06B0 */ 0x0D, 0x01, 0x11, 0x01, 0x14, 0x01, 0x16, 0x01, 0x18, 0x01, 0x19, 0x01, 0x1B, 0x01, 0x1D, 0x01, +/* 06C0 */ 0x1F, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01, 0x27, 0x01, 0x29, 0x01, 0x2C, 0x01, 0x2E, 0x01, +/* 06D0 */ 0x30, 0x01, 0x32, 0x01, 0x34, 0x01, 0x36, 0x01, 0x38, 0x01, 0x3A, 0x01, 0x3C, 0x01, 0x3E, 0x01, +/* 06E0 */ 0x40, 0x01, 0x42, 0x01, 0x45, 0x01, 0x47, 0x01, 0x49, 0x01, 0x4A, 0x01, 0x4C, 0x01, 0x4D, 0x01, +/* 06F0 */ 0x4E, 0x01, 0x50, 0x01, 0x52, 0x01, 0x54, 0x01, 0x56, 0x01, 0x57, 0x01, 0x59, 0x01, 0x5B, 0x01, +/* 0700 */ 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01, 0x64, 0x01, 0x6F, 0x01, 0xA6, 0x01, 0xD0, 0x01, +/* 0710 */ 0xD2, 0x01, 0xDD, 0x02, 0x12, 0x02, 0x2D, 0x02, 0x54, 0x02, 0x56, 0x02, 0x82, 0x02, 0x92, 0x02, +/* 0720 */ 0x9D, 0x02, 0xC4, 0x02, 0xEA, 0x03, 0x04, 0x03, 0x07, 0x03, 0x0F, 0x03, 0x34, 0x03, 0x3C, 0x03, +/* 0730 */ 0x55, 0x03, 0x67, 0x03, 0x6D, 0x03, 0x99, 0x03, 0x9B, 0x03, 0x9F, 0x03, 0xC5, 0x03, 0xE2, 0x03, +/* 0740 */ 0xE4, 0x03, 0xE6, 0x03, 0xE9, 0x03, 0xFC, 0x03, 0xFE, 0x04, 0x06, 0x04, 0x08, 0x04, 0x0A, 0x04, +/* 0750 */ 0x10, 0x04, 0x18, 0x04, 0x30, 0x04, 0x38, 0x04, 0x42, 0x04, 0x44, 0x04, 0x49, 0x04, 0x4E, 0x04, +/* 0760 */ 0x50, 0x04, 0x52, 0x04, 0x54, 0x04, 0x58, 0x04, 0x66, 0x04, 0x70, 0x04, 0x82, 0x04, 0x85, 0x04, +/* 0770 */ 0x91, 0x04, 0xAD, 0x04, 0xB1, 0x04, 0xB3, 0x04, 0xB5, 0x04, 0xB8, 0x04, 0xC7, 0x04, 0xC9, 0x04, +/* 0780 */ 0xCB, 0x04, 0xD2, 0x04, 0xDA, 0x04, 0xDD, 0x04, 0xE3, 0x04, 0xE5, 0x04, 0xF5, 0x05, 0x04, 0x05, +/* 0790 */ 0x0D, 0x05, 0x17, 0x05, 0x19, 0x05, 0x2E, 0x05, 0x50, 0x05, 0x52, 0x05, 0x56, +/* char range info */ +0x00, 0x00, 0x04, +/* 07A0 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x27, 0x00, 0x45, 0x00, 0x88, 0x00, 0xDA, 0x01, 0x4B, +/* 07B0 */ 0x01, 0x9F, 0x01, 0xB1, 0x01, 0xE7, 0x02, 0x21, 0x02, 0x48, 0x02, 0x4F, 0x02, 0x5B, 0x02, 0x68, +/* 07C0 */ 0x02, 0x6F, 0x02, 0xA7, 0x02, 0xEC, 0x03, 0x05, 0x03, 0x38, 0x03, 0x6F, 0x03, 0xAA, 0x03, 0xE0, +/* 07D0 */ 0x04, 0x1F, 0x04, 0x4C, 0x04, 0x95, 0x04, 0xDE, 0x04, 0xE6, 0x04, 0xF3, 0x05, 0x1B, 0x05, 0x24, +/* 07E0 */ 0x05, 0x49, 0x05, 0x7F, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x57, 0x06, 0x8C, 0x06, 0xCD, 0x06, 0xD2, +/* 07F0 */ 0x06, 0xED, 0x07, 0x36, 0x07, 0x50, 0x07, 0x55, 0x07, 0x6F, 0x07, 0xB1, 0x07, 0xC7, 0x08, 0x36, +/* 0800 */ 0x08, 0x43, 0x08, 0x4A, 0x08, 0x75, 0x08, 0xC3, 0x08, 0xFD, 0x09, 0x43, 0x09, 0x5A, 0x09, 0x5F, +/* 0810 */ 0x09, 0xA3, 0x0A, 0x16, 0x0A, 0x59, 0x0A, 0x67, 0x0A, 0x96, 0x0A, 0xB5, 0x0A, 0xEC, 0x0B, 0x0B, +/* 0820 */ 0x0B, 0x2D, 0x0B, 0x3E, 0x0B, 0x52, 0x0B, 0x56, 0x0B, 0x77, 0x0B, 0x9F, 0x0B, 0xCA, 0x0B, 0xD1, +/* 0830 */ 0x0B, 0xFA, 0x0C, 0x4E, 0x0C, 0x67, 0x0C, 0x6D, 0x0C, 0x84, 0x0C, 0xBE, 0x0C, 0xD5, 0x0C, 0xFD, +/* 0840 */ 0x0D, 0x06, 0x0D, 0x0B, 0x0D, 0x25, 0x0D, 0x50, 0x0D, 0x6C, 0x0D, 0xA1, 0x0D, 0xCE, 0x0D, 0xD5, +/* 0850 */ 0x0E, 0x08, 0x0E, 0x60, 0x0E, 0x92, 0x0E, 0x9B, 0x0E, 0xC6, 0x0E, 0xFF, 0x0F, 0x0B, 0x0F, 0x48, +/* 0860 */ 0x04, 0x00, 0x10, 0x05, 0xD2, 0x8B, 0x2C, 0x69, 0x1A, 0x78, 0x0C, 0x1A, 0x78, 0x0B, 0x2C, 0x70, +/* 0870 */ 0x0B, 0x2C, 0xA2, 0x0A, 0x5D, 0x19, 0x94, 0x35, 0x94, 0x35, 0x0E, 0x96, 0x6D, 0xB1, 0x27, 0x4B, +/* 0880 */ 0x2C, 0x8A, 0x2A, 0x81, 0x27, 0x4B, 0x10, 0x09, 0xD2, 0xA2, 0x55, 0x99, 0x37, 0xA4, 0x54, 0x00, +/* 0890 */ 0x99, 0x2E, 0x30, 0x6C, 0x0E, 0x9D, 0x2E, 0xB4, 0x6C, 0x0E, 0x5C, 0x2E, 0xD5, 0x00, 0xD5, 0x2E, +/* 08A0 */ 0x22, 0x53, 0x0C, 0x7A, 0x10, 0x0A, 0xFE, 0x8F, 0x00, 0x03, 0x3B, 0x37, 0x08, 0x4A, 0x00, 0x2A, +/* 08B0 */ 0x20, 0xD8, 0x0C, 0x00, 0x8F, 0x37, 0xA2, 0x41, 0x4A, 0x1F, 0xA2, 0xA8, 0x71, 0x05, 0x99, 0x04, +/* 08C0 */ 0x0D, 0x45, 0x03, 0x37, 0x03, 0x3B, 0x0E, 0x96, 0x5B, 0x2A, 0x02, 0x01, 0x36, 0x5B, 0x8F, 0x00, +/* 08D0 */ 0x03, 0x3B, 0x40, 0x03, 0x40, 0x03, 0x1F, 0x03, 0x0D, 0x0F, 0xDE, 0x0B, 0x4A, 0x04, 0x01, 0x37, +/* 08E0 */ 0x99, 0x24, 0x0B, 0x48, 0x36, 0x3A, 0x09, 0x10, 0x0A, 0x00, 0x61, 0xB4, 0x03, 0x35, 0xB4, 0x03, +/* 08F0 */ 0x35, 0xB4, 0x03, 0x21, 0x07, 0x7F, 0x95, 0x02, 0x5D, 0x7E, 0xA1, 0x1F, 0x70, 0x82, 0x04, 0xB2, +/* 0900 */ 0x37, 0x2A, 0x0C, 0x5D, 0xA4, 0x37, 0x33, 0x0F, 0xA3, 0x19, 0x63, 0x77, 0x2B, 0x06, 0x41, 0x0C, +/* 0910 */ 0x02, 0x2E, 0x8C, 0x73, 0x4A, 0x6D, 0x52, 0x75, 0x7C, 0x2C, 0x0C, 0x99, 0x31, 0x6F, 0x38, 0x0A, +/* 0920 */ 0x54, 0x1F, 0x03, 0x0E, 0x39, 0x32, 0x7F, 0x03, 0x7E, 0x95, 0x5B, 0x07, 0x0D, 0x73, 0x9F, 0x6D, +/* 0930 */ 0x48, 0xB4, 0x03, 0x35, 0xB4, 0x03, 0x35, 0xB4, 0x03, 0x10, 0x10, 0x2E, 0xB3, 0x52, 0x26, 0x6F, +/* 0940 */ 0x0A, 0x0E, 0xB2, 0x6D, 0x97, 0x09, 0x44, 0xEC, 0x54, 0x00, 0xA4, 0x0E, 0x9D, 0x1A, 0x32, 0x67, +/* 0950 */ 0x05, 0x09, 0x67, 0x5D, 0x0A, 0x4A, 0x44, 0x06, 0x45, 0x00, 0x70, 0x01, 0x91, 0x04, 0x26, 0x32, +/* 0960 */ 0x0F, 0xB0, 0x05, 0x67, 0x3A, 0x0A, 0x44, 0xA4, 0x63, 0x95, 0x07, 0x67, 0x6B, 0x04, 0xB4, 0x45, +/* 0970 */ 0x03, 0x54, 0x00, 0x03, 0x6B, 0x03, 0x02, 0x24, 0x86, 0x72, 0x0C, 0x6B, 0x2A, 0x04, 0x72, 0x85, +/* 0980 */ 0x44, 0x50, 0x0F, 0x39, 0x67, 0x02, 0x03, 0x0F, 0x5F, 0x44, 0x08, 0x0F, 0xA1, 0x04, 0x4A, 0x5D, +/* 0990 */ 0x30, 0x02, 0x26, 0x03, 0x30, 0x6C, 0x02, 0x36, 0x8F, 0x01, 0x26, 0x22, 0x0C, 0x6D, 0x0B, 0x30, +/* 09A0 */ 0x94, 0x26, 0x3F, 0x2F, 0x5D, 0xAC, 0x3E, 0x56, 0x44, 0x03, 0x10, 0x0E, 0xCD, 0x07, 0x0D, 0x4A, +/* 09B0 */ 0x39, 0x2E, 0xD8, 0x41, 0x03, 0x31, 0x6F, 0x46, 0x05, 0x09, 0x94, 0x00, 0x78, 0x0B, 0x32, 0x7D, +/* 09C0 */ 0xA4, 0x0E, 0x67, 0x58, 0x36, 0x5B, 0x8F, 0xEC, 0x0C, 0x2B, 0x0B, 0x73, 0x7B, 0x00, 0x02, 0x6B, +/* 09D0 */ 0x08, 0xA8, 0xB0, 0x24, 0x0B, 0x26, 0x97, 0x4A, 0x08, 0x30, 0x86, 0x54, 0x44, 0xEC, 0x6C, 0x07, +/* 09E0 */ 0xA8, 0xA1, 0x44, 0xB4, 0x7C, 0x5D, 0x8F, 0x96, 0x44, 0x24, 0x4A, 0x06, 0x05, 0xD8, 0x46, 0x04, +/* 09F0 */ 0x44, 0x03, 0x3D, 0x75, 0x2F, 0x28, 0x6F, 0x0A, 0xD1, 0x39, 0x00, 0x08, 0x0B, 0x03, 0x10, 0x04, +/* 0A00 */ 0xD2, 0x01, 0x99, 0x5D, 0x19, 0x54, 0x35, 0x36, 0x35, 0x0E, 0x5C, 0x35, 0xD5, 0x35, 0x0C, 0x7A, +/* 0A10 */ 0x10, 0x06, 0x61, 0x0A, 0x83, 0x38, 0xF6, 0x99, 0x2C, 0xD1, 0xED, 0x05, 0x99, 0x2C, 0xB9, 0x2B, +/* 0A20 */ 0x70, 0x0D, 0x2C, 0x2A, 0x0A, 0x2C, 0x08, 0x99, 0xD7, 0x07, 0xD7, 0x06, 0xD7, 0x06, 0xD7, 0x07, +/* 0A30 */ 0x2C, 0x08, 0x99, 0x2C, 0x2A, 0x0A, 0x2C, 0x70, 0x0D, 0x35, 0xB9, 0x2B, 0x33, 0x99, 0x35, 0xD1, +/* 0A40 */ 0xED, 0x32, 0x99, 0x35, 0x0A, 0x83, 0x10, 0x06, 0x1E, 0x3F, 0x09, 0x28, 0xEE, 0x04, 0x5D, 0x19, +/* 0A50 */ 0xB4, 0x0C, 0x28, 0xEE, 0x05, 0x1A, 0x78, 0x0B, 0x2C, 0x3A, 0x5F, 0xD7, 0x05, 0x2C, 0x08, 0x99, +/* 0A60 */ 0x2C, 0x8F, 0x0A, 0x34, 0x95, 0x34, 0x95, 0x2C, 0x8F, 0x0A, 0x2C, 0x08, 0x99, 0xD7, 0x05, 0x2C, +/* 0A70 */ 0x72, 0xED, 0x03, 0x85, 0x21, 0x09, 0xA3, 0x19, 0xB4, 0x0C, 0x38, 0xEE, 0x04, 0x2C, 0x3F, 0x09, +/* 0A80 */ 0x10, 0x08, 0x2C, 0xB3, 0xA2, 0x6C, 0x19, 0x00, 0x0E, 0x7A, 0xA4, 0x52, 0x62, 0x0C, 0x5C, 0x0C, +/* 0A90 */ 0x09, 0x5D, 0x7E, 0x0E, 0x52, 0x06, 0x0B, 0x30, 0x62, 0x53, 0x48, 0x0E, 0x67, 0x5C, 0x2B, 0x22, +/* 0AA0 */ 0x0C, 0x76, 0x2F, 0x48, 0x77, 0x50, 0x06, 0x10, 0x0A, 0xE2, 0x97, 0x5F, 0x34, 0xDB, 0x10, 0x05, +/* 0AB0 */ 0x2E, 0xCD, 0xE2, 0x51, 0x4B, 0x34, 0x67, 0x2C, 0xE9, 0x5C, 0x10, 0x08, 0x8E, 0xE2, 0x19, 0x04, +/* 0AC0 */ 0x42, 0x03, 0x00, 0x52, 0xE8, 0x52, 0xE8, 0x10, 0x05, 0x2B, 0xCD, 0xE2, 0xA5, 0xF3, 0x10, 0x09, +/* 0AD0 */ 0x61, 0x6F, 0x01, 0xB1, 0xD8, 0xB0, 0x2C, 0x29, 0x38, 0x48, 0x94, 0x34, 0x5C, 0xD7, 0x60, 0xD1, +/* 0AE0 */ 0x2C, 0x70, 0x0A, 0x21, 0x33, 0x36, 0x2C, 0x2D, 0x03, 0x2C, 0xD1, 0x2C, 0xA2, 0x0B, 0x21, 0x33, +/* 0AF0 */ 0x54, 0x2C, 0x2D, 0x03, 0x2C, 0x0C, 0x67, 0x2C, 0xA2, 0x0B, 0x38, 0xF6, 0x99, 0x38, 0xEE, 0x04, +/* 0B00 */ 0x2C, 0x08, 0x0E, 0x5F, 0x1A, 0x48, 0x10, 0x0B, 0xFE, 0x58, 0x0D, 0x0F, 0xB2, 0x2B, 0x0C, 0xE8, +/* 0B10 */ 0x37, 0x06, 0x30, 0x49, 0x22, 0x7C, 0x37, 0xB9, 0x91, 0x0B, 0x37, 0x73, 0x6F, 0x46, 0x44, 0x6F, +/* 0B20 */ 0x46, 0x6D, 0x90, 0x31, 0x03, 0x46, 0x6D, 0x73, 0x02, 0x31, 0x03, 0x46, 0x6D, 0x73, 0x02, 0x26, +/* 0B30 */ 0x6F, 0x46, 0x6D, 0x90, 0x1F, 0x73, 0x6F, 0x46, 0x37, 0xB9, 0x91, 0x0B, 0x37, 0x06, 0x30, 0x49, +/* 0B40 */ 0x22, 0x7C, 0x5B, 0x0C, 0xA8, 0x45, 0x2E, 0x58, 0x0D, 0x4A, 0x08, 0x10, 0x08, 0xCD, 0x07, 0x90, +/* 0B50 */ 0x2E, 0x8D, 0x0F, 0x90, 0x5B, 0x06, 0x7F, 0x90, 0x5B, 0x07, 0x99, 0x84, 0x2E, 0x39, 0x00, 0xFF, +/* 0B60 */ 0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x09, 0xAA, 0x98, 0xB4, 0xAF, 0x5B, 0x97, 0xE8, 0x37, 0xD8, 0x77, +/* 0B70 */ 0x8F, 0x7A, 0x5B, 0x07, 0x01, 0x5D, 0x0B, 0x54, 0xD7, 0x07, 0x2C, 0xE3, 0x2E, 0x97, 0x4A, 0x00, +/* 0B80 */ 0x19, 0xB4, 0x7C, 0x21, 0x0B, 0x94, 0x21, 0x2D, 0x0B, 0x21, 0x06, 0x30, 0xB0, 0x2B, 0x91, 0x5C, +/* 0B90 */ 0x74, 0x03, 0x37, 0x2D, 0xE8, 0x7E, 0x96, 0x10, 0x09, 0xAA, 0xA0, 0x0E, 0xFB, 0xEE, 0xA8, 0x0C, +/* 0BA0 */ 0xF6, 0x0F, 0x49, 0x06, 0xB4, 0x7C, 0x52, 0x6D, 0x08, 0x54, 0x2C, 0x2D, 0x05, 0x5D, 0xF6, 0x07, +/* 0BB0 */ 0x29, 0x21, 0x73, 0x56, 0x2E, 0x23, 0x95, 0xED, 0x8D, 0x99, 0x2C, 0x91, 0x0C, 0x52, 0x5D, 0x33, +/* 0BC0 */ 0x71, 0x08, 0x95, 0x05, 0x06, 0x0D, 0x99, 0x37, 0xD8, 0x41, 0xB0, 0x5B, 0xBE, 0x55, 0x10, 0x0A, +/* 0BD0 */ 0x35, 0xB3, 0x93, 0xB1, 0x07, 0x0F, 0x43, 0x2C, 0xEC, 0x02, 0x28, 0x78, 0x0C, 0x2C, 0x08, 0x36, +/* 0BE0 */ 0x2C, 0x84, 0x6D, 0xF6, 0x85, 0x94, 0x5B, 0xD8, 0x7C, 0x01, 0x94, 0x1F, 0xA4, 0x0E, 0x67, 0x57, +/* 0BF0 */ 0x94, 0x37, 0x06, 0x30, 0x0C, 0x04, 0x8F, 0xDE, 0x1F, 0x08, 0x89, 0x0E, 0x1F, 0x08, 0x89, 0x0E, +/* 0C00 */ 0x2B, 0x33, 0x94, 0x21, 0x33, 0x94, 0x21, 0x33, 0x94, 0x10, 0x0A, 0xAA, 0x41, 0x94, 0x5B, 0x41, +/* 0C10 */ 0x36, 0x5B, 0x46, 0x42, 0x01, 0x5B, 0x46, 0x35, 0x46, 0x57, 0x02, 0x2B, 0x73, 0x7F, 0x7B, 0x5B, +/* 0C20 */ 0x41, 0x94, 0x5B, 0x06, 0x07, 0x04, 0x1C, 0x73, 0x26, 0x25, 0x60, 0x7F, 0x03, 0x37, 0x3C, 0x6F, +/* 0C30 */ 0x90, 0x31, 0x32, 0x9E, 0x06, 0x05, 0x0C, 0x7D, 0x33, 0x41, 0x4A, 0x20, 0x98, 0x0E, 0xFB, 0x10, +/* 0C40 */ 0x0A, 0xCD, 0x98, 0x0D, 0x0E, 0x77, 0x2E, 0xB5, 0x85, 0x1F, 0xA4, 0x0E, 0x99, 0x05, 0x08, 0x20, +/* 0C50 */ 0x08, 0x94, 0x2C, 0xEC, 0x3C, 0x3C, 0x5B, 0x18, 0x8F, 0x96, 0x37, 0x70, 0xA8, 0x36, 0x78, 0x9D, +/* 0C60 */ 0x68, 0x5A, 0x03, 0x46, 0x6F, 0x46, 0x1F, 0x18, 0x00, 0xA4, 0x46, 0x1F, 0x3A, 0x2F, 0x91, 0x0C, +/* 0C70 */ 0x37, 0x08, 0x30, 0x49, 0x0C, 0x54, 0x37, 0x50, 0x41, 0x1B, 0x37, 0xA4, 0x9C, 0xFB, 0x10, 0x09, +/* 0C80 */ 0xD2, 0x22, 0x41, 0x7A, 0x37, 0x22, 0x41, 0x7A, 0x37, 0x03, 0x74, 0x05, 0x90, 0x2B, 0x97, 0x95, +/* 0C90 */ 0x27, 0xA3, 0x5D, 0x48, 0x46, 0x2C, 0x08, 0x99, 0x2C, 0x72, 0x03, 0x21, 0x91, 0x0C, 0xD7, 0x06, +/* 0CA0 */ 0x21, 0x18, 0xED, 0x8F, 0x0A, 0x2C, 0x22, 0x7A, 0x2C, 0x1C, 0x0A, 0x10, 0x0B, 0xFE, 0x03, 0xA5, +/* 0CB0 */ 0x9E, 0x55, 0xF6, 0x0F, 0x41, 0xB0, 0x37, 0x0C, 0x99, 0x05, 0x0C, 0x54, 0x37, 0x30, 0x81, 0x33, +/* 0CC0 */ 0x94, 0x37, 0x84, 0x00, 0x07, 0x36, 0x37, 0x08, 0x30, 0x0C, 0x88, 0x0F, 0x1B, 0x5B, 0x0A, 0xA8, +/* 0CD0 */ 0xB0, 0xF6, 0x0D, 0x4A, 0x7F, 0x1B, 0x31, 0xA4, 0xB4, 0xB0, 0x3F, 0x7D, 0x06, 0x94, 0x5D, 0x18, +/* 0CE0 */ 0x1F, 0x07, 0x94, 0x00, 0xA4, 0x90, 0x31, 0x91, 0x9D, 0x05, 0x75, 0x0C, 0x00, 0x7E, 0x82, 0x37, +/* 0CF0 */ 0x06, 0x0B, 0x29, 0xF1, 0x10, 0x0A, 0xAA, 0x32, 0x0B, 0x3E, 0x0C, 0x06, 0x2E, 0x06, 0xA8, 0x99, +/* 0D00 */ 0x37, 0xA2, 0x9D, 0x05, 0x7F, 0x03, 0x31, 0x97, 0x95, 0x5D, 0x09, 0x99, 0x1F, 0x08, 0x99, 0x5D, +/* 0D10 */ 0x8F, 0x0B, 0x1F, 0x07, 0x94, 0x00, 0x97, 0x45, 0x31, 0x32, 0x46, 0x02, 0x02, 0x0D, 0x7D, 0x3A, +/* 0D20 */ 0xA8, 0x94, 0x31, 0x6F, 0x72, 0x0C, 0x22, 0x7C, 0x2E, 0xA6, 0x02, 0x90, 0x19, 0x0C, 0x99, 0x2E, +/* 0D30 */ 0x1C, 0x72, 0x1B, 0x5B, 0x06, 0x63, 0x7B, 0x2E, 0x2A, 0x77, 0x21, 0x1C, 0x02, 0x10, 0x05, 0xAB, +/* 0D40 */ 0xA5, 0xF3, 0x38, 0xA5, 0xF3, 0x10, 0x05, 0xAB, 0xA5, 0xF3, 0x6D, 0x51, 0x4B, 0x34, 0x67, 0x2C, +/* 0D50 */ 0xE9, 0x5C, 0x10, 0x09, 0x4D, 0x52, 0x2C, 0x33, 0x0C, 0x7A, 0x2B, 0x06, 0x72, 0x95, 0x37, 0x1C, +/* 0D60 */ 0x0D, 0x73, 0x77, 0x5B, 0x07, 0x73, 0x39, 0x2B, 0x07, 0x94, 0xED, 0x2A, 0x67, 0xF1, 0x6F, 0x09, +/* 0D70 */ 0xA8, 0x39, 0x2B, 0x58, 0x0E, 0x94, 0x5D, 0x19, 0x92, 0x02, 0x10, 0x09, 0x38, 0xE2, 0x19, 0xDD, +/* 0D80 */ 0x35, 0x19, 0xDD, 0x10, 0x09, 0x1A, 0x4D, 0x3C, 0xB1, 0x0D, 0x9F, 0xED, 0xB5, 0x9F, 0x20, 0x6F, +/* 0D90 */ 0x09, 0x63, 0xF1, 0x5D, 0x58, 0xB4, 0x4A, 0x21, 0x33, 0x29, 0x2B, 0x06, 0x72, 0x45, 0x37, 0x58, +/* 0DA0 */ 0x63, 0x77, 0x52, 0x73, 0xDE, 0x21, 0x0B, 0x39, 0x10, 0x09, 0xAA, 0x02, 0x09, 0xD1, 0x0A, 0x02, +/* 0DB0 */ 0xF6, 0x63, 0x46, 0x02, 0x37, 0x03, 0x0D, 0x4B, 0x88, 0x99, 0x5B, 0x93, 0x5D, 0x0A, 0x54, 0x21, +/* 0DC0 */ 0x06, 0x73, 0x03, 0x2B, 0x08, 0x46, 0x04, 0x38, 0x78, 0x0D, 0x02, 0x21, 0x06, 0x36, 0x38, 0x48, +/* 0DD0 */ 0x65, 0x6B, 0x2B, 0x48, 0x0D, 0x86, 0xD7, 0x0A, 0xD7, 0x0A, 0x38, 0x52, 0x0D, 0x86, 0x10, 0x12, +/* 0DE0 */ 0x5D, 0xCD, 0x68, 0x0C, 0x0E, 0x67, 0x0C, 0x08, 0x6B, 0x06, 0x3D, 0x54, 0x44, 0x09, 0x46, 0x09, +/* 0DF0 */ 0x06, 0x04, 0x05, 0x08, 0x0D, 0x94, 0x28, 0x97, 0x45, 0x1C, 0x0D, 0x4A, 0x09, 0x02, 0x2D, 0x05, +/* 0E00 */ 0x5D, 0x6F, 0x29, 0x00, 0x08, 0x73, 0x85, 0x0C, 0x4A, 0x38, 0x08, 0x0F, 0x7A, 0x70, 0x77, 0x0E, +/* 0E10 */ 0x45, 0x97, 0x7A, 0x6D, 0x22, 0x81, 0x06, 0x3B, 0x0D, 0x45, 0x00, 0x03, 0x54, 0x6D, 0x85, 0x2D, +/* 0E20 */ 0x9A, 0x0D, 0x45, 0xA4, 0x94, 0x6F, 0x94, 0x00, 0xD8, 0x5F, 0x3A, 0x0B, 0x00, 0x02, 0x94, 0x6F, +/* 0E30 */ 0x94, 0x00, 0xD8, 0x5F, 0x3A, 0x0B, 0x00, 0x03, 0x54, 0x5D, 0xA2, 0x0A, 0x00, 0x08, 0x30, 0x02, +/* 0E40 */ 0x3A, 0x0C, 0x97, 0x7A, 0x6D, 0x0D, 0x4A, 0x33, 0x94, 0x07, 0x0F, 0x3E, 0x88, 0x4A, 0x38, 0x2D, +/* 0E50 */ 0x03, 0x3A, 0x30, 0xAF, 0x73, 0x7A, 0x38, 0x03, 0x85, 0x03, 0x22, 0x0C, 0x9A, 0x0A, 0x0E, 0x77, +/* 0E60 */ 0x1A, 0x2D, 0x83, 0x00, 0x19, 0xEC, 0x9F, 0x05, 0x04, 0x05, 0x07, 0x39, 0x7E, 0x94, 0x37, 0x03, +/* 0E70 */ 0x09, 0x0C, 0x0E, 0x67, 0x0C, 0x08, 0x03, 0x10, 0x0B, 0xCD, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0xAA, +/* 0E80 */ 0x63, 0x9E, 0x0A, 0x04, 0x4C, 0x9D, 0x37, 0x79, 0x4E, 0x90, 0x1F, 0xE3, 0x18, 0x03, 0x1F, 0xE3, +/* 0E90 */ 0x18, 0x6B, 0x79, 0x4E, 0x7D, 0x00, 0x3D, 0x08, 0x4C, 0x96, 0x37, 0xE3, 0x04, 0xF0, 0x25, 0x04, +/* 0EA0 */ 0x5D, 0x2D, 0x0B, 0x25, 0x04, 0x5D, 0x2D, 0x0B, 0x1F, 0x79, 0x04, 0x08, 0x0F, 0x54, 0x25, 0x41, +/* 0EB0 */ 0x1B, 0x25, 0x46, 0x0B, 0x07, 0x01, 0x10, 0x0A, 0xCD, 0xA0, 0x0D, 0x4A, 0xF1, 0x8F, 0xA8, 0xA1, +/* 0EC0 */ 0x1F, 0x91, 0x96, 0x05, 0x08, 0x0E, 0x05, 0x37, 0x0C, 0x94, 0x5D, 0xA4, 0x37, 0x18, 0x03, 0x21, +/* 0ED0 */ 0xB5, 0x2C, 0x8A, 0x8A, 0xB5, 0x2C, 0x23, 0x03, 0x2C, 0x0C, 0x94, 0x5D, 0xA4, 0xF6, 0x0F, 0x99, +/* 0EE0 */ 0x04, 0x92, 0x09, 0x5B, 0x07, 0xA8, 0x46, 0x20, 0xA0, 0x29, 0xF1, 0x10, 0x0C, 0xAA, 0x63, 0x9E, +/* 0EF0 */ 0x09, 0x03, 0x4C, 0x9D, 0x37, 0x79, 0x05, 0x2D, 0x7A, 0x25, 0x04, 0x5D, 0x2D, 0x0B, 0x1F, 0xE3, +/* 0F00 */ 0x32, 0x90, 0x31, 0xE3, 0x00, 0x18, 0x03, 0x31, 0xE3, 0x00, 0xA2, 0x7A, 0x31, 0xE3, 0x00, 0xA2, +/* 0F10 */ 0x7A, 0x31, 0xE3, 0x00, 0x23, 0x03, 0x31, 0xE3, 0x00, 0xB5, 0x25, 0x04, 0x5D, 0xD8, 0x45, 0x1F, +/* 0F20 */ 0x79, 0x05, 0x2D, 0x7A, 0x25, 0x73, 0x36, 0x37, 0x63, 0x4A, 0x09, 0x03, 0x10, 0x09, 0xAA, 0x3D, +/* 0F30 */ 0xEA, 0x10, 0x09, 0xAA, 0x3D, 0x09, 0x4C, 0x07, 0x5B, 0x79, 0x74, 0x01, 0x5B, 0x66, 0x00, 0x63, +/* 0F40 */ 0x71, 0x5D, 0x63, 0x71, 0x5D, 0x79, 0x65, 0x03, 0x2E, 0xE3, 0x59, 0x66, 0x10, 0x0C, 0xAA, 0x6F, +/* 0F50 */ 0x09, 0xD1, 0x49, 0x37, 0x33, 0x3D, 0x09, 0x78, 0x95, 0x05, 0x06, 0x0A, 0x82, 0x31, 0x0B, 0x94, +/* 0F60 */ 0x6D, 0xA4, 0x1F, 0x18, 0x03, 0x21, 0xB5, 0x00, 0x32, 0x42, 0x44, 0x33, 0x46, 0x5D, 0x0C, 0xA8, +/* 0F70 */ 0x31, 0x06, 0x46, 0x5D, 0x0A, 0xA8, 0x44, 0x33, 0x73, 0x6D, 0x18, 0x31, 0x23, 0x02, 0x5D, 0x18, +/* 0F80 */ 0x1F, 0x0D, 0x36, 0x5D, 0x18, 0x1F, 0x8F, 0x62, 0x04, 0x08, 0x73, 0x1F, 0x24, 0x41, 0x4A, 0x5B, +/* 0F90 */ 0x06, 0xA5, 0x67, 0x0B, 0x06, 0x10, 0x0C, 0x6E, 0xB3, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0x1F, 0x79, +/* 0FA0 */ 0x65, 0x07, 0x46, 0x1F, 0x3D, 0x46, 0x1F, 0x3D, 0x46, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0x10, +/* 0FB0 */ 0x05, 0xAA, 0x66, 0xB6, 0x10, 0x06, 0xAA, 0x8F, 0x0C, 0x2C, 0x8F, 0xEF, 0xEF, 0x0B, 0x2C, 0x8F, +/* 0FC0 */ 0x0B, 0xD7, 0x08, 0x21, 0x8F, 0x2F, 0x2E, 0xA2, 0x9D, 0x27, 0x0C, 0x04, 0x6D, 0x19, 0x10, 0x0C, +/* 0FD0 */ 0xAA, 0xE3, 0xA4, 0xE3, 0x44, 0xE3, 0x00, 0x09, 0x94, 0x1F, 0xE3, 0x03, 0x30, 0xA1, 0x1F, 0xE3, +/* 0FE0 */ 0xEC, 0x6C, 0x25, 0x04, 0x76, 0x87, 0xB4, 0x7C, 0x7F, 0x03, 0x5B, 0xB4, 0x45, 0x5A, 0x6D, 0xF0, +/* 0FF0 */ 0x30, 0x7A, 0x5B, 0xB4, 0x7A, 0x2D, 0x0D, 0x5B, 0xB4, 0x7A, 0x01, 0xF0, 0x37, 0xE3, 0x08, 0x30, +/* 1000 */ 0xB0, 0x25, 0x04, 0xA4, 0x79, 0x25, 0x04, 0x5D, 0x08, 0x30, 0xA1, 0x31, 0xE3, 0xA4, 0x0E, 0x94, +/* 1010 */ 0x10, 0x09, 0xAA, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00, 0xE3, 0x59, 0xB4, 0x95, 0x08, 0x08, 0x08, +/* 1020 */ 0x55, 0x00, 0x25, 0x41, 0x4C, 0x0D, 0x10, 0x0E, 0xAA, 0x08, 0x0F, 0x94, 0x5D, 0x03, 0x0F, 0x46, +/* 1030 */ 0x44, 0x09, 0x73, 0x0C, 0x5D, 0x06, 0xA8, 0x44, 0xD8, 0x46, 0x5D, 0x08, 0x0F, 0x90, 0x1A, 0x24, +/* 1040 */ 0x72, 0x02, 0x24, 0x7F, 0x02, 0x26, 0x22, 0x0C, 0xD5, 0x3A, 0x0B, 0x30, 0x03, 0x26, 0x0D, 0x4A, +/* 1050 */ 0x0B, 0x0F, 0x55, 0x99, 0x3B, 0x1A, 0x29, 0x08, 0x45, 0x03, 0x4A, 0x8F, 0x05, 0x26, 0x0F, 0x4A, +/* 1060 */ 0x05, 0x4A, 0x06, 0x95, 0x8F, 0x05, 0x1A, 0xA2, 0x0C, 0x02, 0x94, 0x9D, 0x07, 0x36, 0x1A, 0x70, +/* 1070 */ 0x0C, 0x00, 0x0E, 0x67, 0x7A, 0x06, 0x54, 0x1A, 0x03, 0x85, 0x0B, 0x73, 0x1C, 0x99, 0x28, 0x32, +/* 1080 */ 0x85, 0x08, 0x46, 0x33, 0x94, 0x1A, 0x2A, 0x0A, 0x00, 0x03, 0x08, 0x08, 0x6C, 0x2A, 0x0A, 0x28, +/* 1090 */ 0x97, 0x95, 0x1A, 0x91, 0x0B, 0x10, 0x0C, 0xAA, 0x63, 0x03, 0x5D, 0x29, 0x25, 0x96, 0x5D, 0x29, +/* 10A0 */ 0xBF, 0xD0, 0x10, 0x0D, 0xCD, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0B, 0xAA, 0x63, 0x4A, 0x0A, 0x04, +/* 10B0 */ 0x4C, 0x9D, 0x37, 0x79, 0xA7, 0x73, 0x6B, 0xE3, 0x3A, 0x9D, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3, +/* 10C0 */ 0x3A, 0x9D, 0x25, 0x04, 0x68, 0x73, 0x03, 0x25, 0xE8, 0x25, 0x73, 0x9F, 0x5B, 0x79, 0x04, 0x03, +/* 10D0 */ 0x2B, 0x66, 0x00, 0xE3, 0x10, 0x0D, 0xCD, 0xBE, 0xF1, 0x2D, 0xA8, 0x82, 0x31, 0x2A, 0x62, 0x05, +/* 10E0 */ 0x75, 0xB0, 0x31, 0x0C, 0x54, 0x6D, 0x0D, 0x36, 0x44, 0x23, 0x9A, 0x80, 0x6D, 0x33, 0x73, 0x44, +/* 10F0 */ 0x06, 0x46, 0x6D, 0x33, 0x46, 0x26, 0x33, 0x73, 0x6D, 0x97, 0x4A, 0x44, 0x23, 0x02, 0x6D, 0x08, +/* 1100 */ 0x94, 0x31, 0x0D, 0x54, 0x6D, 0x72, 0x03, 0x31, 0x06, 0x30, 0x62, 0xA7, 0x99, 0x37, 0x0A, 0xA8, +/* 1110 */ 0x94, 0x2E, 0x06, 0x0C, 0x7F, 0x46, 0xF1, 0x00, 0x57, 0x08, 0x0F, 0x99, 0x38, 0x52, 0x0E, 0x0B, +/* 1120 */ 0xB1, 0x3C, 0x10, 0x0B, 0xAA, 0x7F, 0x46, 0x49, 0x4C, 0x0F, 0x09, 0x37, 0x79, 0xA7, 0x73, 0x03, +/* 1130 */ 0x1F, 0xE3, 0x3A, 0x9D, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3, 0x3A, 0x5C, 0x1F, 0x79, 0xA7, 0x73, +/* 1140 */ 0x6B, 0x3D, 0x5C, 0x37, 0x3D, 0x07, 0x5B, 0xB4, 0x7A, 0x76, 0x87, 0xE3, 0x0D, 0x36, 0x37, 0xE3, +/* 1150 */ 0x06, 0x30, 0xA1, 0x1F, 0xE3, 0x3A, 0x96, 0x1F, 0xE3, 0x97, 0x67, 0x02, 0x10, 0x0A, 0xAA, 0x32, +/* 1160 */ 0x0B, 0x29, 0xF1, 0x8F, 0xA8, 0x7C, 0x1F, 0x23, 0x09, 0x04, 0x07, 0x0D, 0x0D, 0x6B, 0x05, 0x46, +/* 1170 */ 0x5D, 0xA4, 0x6B, 0x32, 0x0F, 0xA3, 0x19, 0x63, 0x0C, 0x06, 0x01, 0x00, 0xF6, 0x7F, 0x46, 0x05, +/* 1180 */ 0x00, 0x48, 0x09, 0x63, 0x7C, 0x19, 0x92, 0x5A, 0x1A, 0x07, 0x46, 0x1F, 0x32, 0x01, 0x6D, 0x8F, +/* 1190 */ 0x0D, 0x31, 0x33, 0x0F, 0xB2, 0x04, 0x4F, 0x94, 0x1F, 0x8F, 0x41, 0x1B, 0x31, 0x6F, 0x09, 0xD1, +/* 11A0 */ 0xAF, 0x01, 0x10, 0x0A, 0xD2, 0x72, 0x41, 0x45, 0x31, 0x3A, 0x41, 0x94, 0x1F, 0x03, 0x65, 0x22, +/* 11B0 */ 0x95, 0x65, 0x20, 0x24, 0x96, 0x27, 0xF9, 0x27, 0xF9, 0x10, 0x0C, 0xD2, 0x6A, 0xB8, 0x10, 0x0B, +/* 11C0 */ 0x5E, 0xB3, 0x18, 0x02, 0x6D, 0x09, 0x94, 0x44, 0x3A, 0x7C, 0x6D, 0x22, 0x7C, 0x31, 0x09, 0x99, +/* 11D0 */ 0x6D, 0x7F, 0x02, 0x31, 0x2A, 0x0C, 0x6F, 0x0F, 0x4A, 0x1F, 0xA2, 0x81, 0x33, 0x7D, 0x3A, 0x2F, +/* 11E0 */ 0x08, 0x36, 0x37, 0x2D, 0x6C, 0x0B, 0x30, 0x6B, 0x33, 0x94, 0x00, 0xD1, 0x5B, 0xA2, 0x1B, 0x7D, +/* 11F0 */ 0x6D, 0xD1, 0x04, 0x36, 0x2E, 0x2D, 0x2D, 0x03, 0x5B, 0x33, 0x46, 0x67, 0x2B, 0x18, 0x45, 0x21, +/* 1200 */ 0x22, 0x54, 0x10, 0x0F, 0xD2, 0x0B, 0xA3, 0x00, 0x0F, 0x54, 0x5D, 0xB9, 0x6D, 0x2D, 0x6C, 0x23, +/* 1210 */ 0x09, 0x5D, 0x84, 0x38, 0x07, 0x99, 0x00, 0x91, 0x45, 0x5D, 0x46, 0x28, 0x2A, 0x0A, 0x97, 0x29, +/* 1220 */ 0x00, 0x70, 0x0B, 0x28, 0x03, 0x85, 0x08, 0x0F, 0x75, 0x32, 0x94, 0x28, 0xA2, 0x0D, 0x00, 0x0A, +/* 1230 */ 0x5C, 0x30, 0x02, 0x06, 0x54, 0x1A, 0xB4, 0x81, 0x0D, 0x7A, 0x0D, 0x7A, 0x8F, 0x05, 0x1A, 0xEC, +/* 1240 */ 0xA2, 0x8D, 0x5C, 0x2D, 0x03, 0x1A, 0xD8, 0x7A, 0x0F, 0x81, 0x09, 0x96, 0x0B, 0x0F, 0x5F, 0x1A, +/* 1250 */ 0x08, 0x99, 0x0F, 0x0C, 0x00, 0x07, 0x95, 0xD1, 0x26, 0x2A, 0x0B, 0x95, 0x33, 0x0F, 0x0C, 0x0E, +/* 1260 */ 0x45, 0x26, 0x03, 0x46, 0x96, 0x00, 0x03, 0x67, 0x94, 0x1A, 0xA4, 0xA8, 0x6C, 0x70, 0x54, 0x44, +/* 1270 */ 0x7F, 0x7A, 0x5D, 0x73, 0x7C, 0x10, 0x0B, 0xD2, 0x2D, 0x0B, 0x5D, 0x23, 0x03, 0x31, 0x23, 0x9A, +/* 1280 */ 0x08, 0x7D, 0x00, 0x0A, 0x54, 0x00, 0x72, 0x9A, 0x78, 0x0D, 0x91, 0x0A, 0x2E, 0x75, 0x72, 0x02, +/* 1290 */ 0x6D, 0x78, 0x94, 0x21, 0xEC, 0x7A, 0x2B, 0x23, 0x95, 0x5D, 0xEE, 0x7F, 0x20, 0x01, 0xB4, 0xB2, +/* 12A0 */ 0x94, 0x5B, 0x8F, 0x55, 0x90, 0x31, 0xA4, 0x7F, 0x9A, 0x0A, 0x99, 0x1F, 0x06, 0x30, 0x0C, 0x5D, +/* 12B0 */ 0x91, 0xA1, 0x31, 0x0D, 0x36, 0x6D, 0x0D, 0x54, 0x10, 0x0B, 0x5E, 0xB3, 0x01, 0xF0, 0x6D, 0x8F, +/* 12C0 */ 0x0C, 0x31, 0x08, 0xBD, 0x2C, 0xC6, 0x10, 0x0A, 0xD2, 0x03, 0x89, 0x05, 0x78, 0x41, 0x7C, 0x31, +/* 12D0 */ 0xA4, 0x42, 0x2D, 0x2F, 0x2E, 0x50, 0x94, 0x21, 0x8F, 0xA1, 0x5D, 0x48, 0x79, 0x21, 0xD8, 0x4A, +/* 12E0 */ 0x28, 0x78, 0x7C, 0x21, 0x22, 0x45, 0x21, 0x2A, 0x2F, 0x2E, 0x50, 0x94, 0x21, 0x8F, 0x7C, 0x74, +/* 12F0 */ 0xAD, 0x40, 0x05, 0x40, 0x03, 0x10, 0x06, 0x1E, 0x8F, 0x99, 0x2B, 0x8F, 0x99, 0x2B, 0x07, 0x94, +/* 1300 */ 0xAD, 0x2B, 0x07, 0x54, 0x2C, 0x07, 0x54, 0xBA, 0x54, 0xBA, 0x54, 0xBA, 0x94, 0xAD, 0x2B, 0x8F, +/* 1310 */ 0x99, 0x2B, 0x8F, 0x99, 0x10, 0x09, 0x61, 0x03, 0x35, 0x2D, 0x01, 0x38, 0xEE, 0x04, 0x38, 0xF6, +/* 1320 */ 0x99, 0x2C, 0xA2, 0x0B, 0x35, 0xEC, 0x28, 0xEE, 0x04, 0x21, 0x33, 0x54, 0x2C, 0xA2, 0x0B, 0x35, +/* 1330 */ 0xD1, 0x35, 0x2D, 0x03, 0x21, 0x33, 0x54, 0x2C, 0x70, 0x0A, 0x2C, 0x3A, 0x81, 0xD7, 0x60, 0x06, +/* 1340 */ 0x36, 0x2C, 0x70, 0x0A, 0x35, 0x29, 0x35, 0xD8, 0x1B, 0x5D, 0x19, 0x10, 0x06, 0x1E, 0x2D, 0xA3, +/* 1350 */ 0x2E, 0x2D, 0xA3, 0x00, 0x48, 0xA0, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xA3, 0x6D, 0xEE, 0x05, +/* 1360 */ 0x5D, 0x48, 0xA0, 0xA3, 0x2E, 0x2D, 0xA3, 0x2E, 0x2D, 0xA3, 0x10, 0x0A, 0x5E, 0x52, 0x08, 0x08, +/* 1370 */ 0x05, 0x2C, 0xEC, 0xA1, 0x2B, 0x2A, 0x99, 0x2E, 0x3A, 0x0C, 0x75, 0x20, 0x06, 0x36, 0x03, 0x94, +/* 1380 */ 0x1F, 0xA4, 0xD1, 0x5D, 0x0B, 0x30, 0x6B, 0x07, 0x99, 0x5D, 0x2A, 0x0A, 0x10, 0x09, 0x64, 0xD2, +/* 1390 */ 0xE2, 0x52, 0x42, 0x42, 0x01, 0x1F, 0xEC, 0x41, 0x7A, 0x1F, 0xEC, 0x41, 0x7A, 0x10, 0x06, 0x00, +/* 13A0 */ 0x1E, 0xA6, 0x5D, 0x27, 0x96, 0x38, 0x48, 0x7F, 0x86, 0x21, 0x68, 0x0D, 0x0F, 0x09, 0x35, 0x33, +/* 13B0 */ 0x01, 0x10, 0x0A, 0xAB, 0xB7, 0x10, 0x0B, 0x64, 0x57, 0x35, 0xC5, 0xE1, 0x04, 0x0B, 0x9E, 0x06, +/* 13C0 */ 0x5D, 0x25, 0x7F, 0xA3, 0x25, 0xC4, 0x73, 0x00, 0x25, 0x49, 0x22, 0x95, 0x37, 0x3D, 0x2F, 0x1F, +/* 13D0 */ 0x29, 0x04, 0x0D, 0x0F, 0x0C, 0x04, 0x10, 0x09, 0xE2, 0x02, 0x9C, 0xFB, 0x48, 0x63, 0x54, 0x5B, +/* 13E0 */ 0x0B, 0x30, 0x49, 0x07, 0x0A, 0x5B, 0x23, 0xED, 0x8B, 0x34, 0x87, 0x38, 0x8B, 0x38, 0x52, 0x90, +/* 13F0 */ 0x2C, 0xEC, 0x49, 0x07, 0x09, 0x00, 0x52, 0x0E, 0x41, 0x6C, 0x48, 0x0A, 0x0E, 0xFB, 0x10, 0x0B, +/* 1400 */ 0xB3, 0x93, 0x01, 0x35, 0x91, 0x0C, 0x2C, 0x69, 0x2C, 0x69, 0x2C, 0x69, 0xF6, 0x0C, 0x0E, 0xAF, +/* 1410 */ 0x71, 0x04, 0x41, 0x71, 0xFC, 0x5D, 0x69, 0x78, 0x5F, 0x32, 0x71, 0xB4, 0x95, 0x88, 0x71, 0x06, +/* 1420 */ 0xA8, 0xB4, 0x4A, 0x5B, 0x07, 0x0D, 0x45, 0x03, 0x29, 0x10, 0x0A, 0xE2, 0x98, 0xC3, 0xDA, 0xF1, +/* 1430 */ 0x10, 0x07, 0x64, 0x6F, 0x3C, 0x2B, 0x33, 0x7F, 0x95, 0x2E, 0x23, 0x54, 0x2E, 0x8F, 0x0B, 0x93, +/* 1440 */ 0x01, 0x2E, 0x08, 0x99, 0x21, 0x0E, 0xE8, 0x5B, 0x63, 0x54, 0x00, 0xF6, 0xD8, 0x95, 0xAD, 0x2B, +/* 1450 */ 0x08, 0xDC, 0xEE, 0x08, 0x2C, 0x08, 0xDC, 0xEE, 0x08, 0x10, 0x0A, 0xA9, 0xCD, 0xED, 0x93, 0x07, +/* 1460 */ 0x0D, 0x08, 0x37, 0x68, 0x0C, 0x7F, 0x5A, 0x00, 0x0C, 0x41, 0xB2, 0x03, 0x1F, 0x8B, 0x05, 0x06, +/* 1470 */ 0x94, 0x37, 0x07, 0x99, 0x00, 0x3A, 0x5F, 0x1F, 0x06, 0x30, 0x0C, 0x57, 0x84, 0x31, 0xA4, 0x0C, +/* 1480 */ 0x41, 0x45, 0x37, 0xA4, 0x0E, 0xA8, 0x83, 0x5B, 0x09, 0x45, 0x03, 0x3C, 0x2B, 0x29, 0x65, 0x3C, +/* 1490 */ 0x2E, 0x0B, 0xA8, 0x99, 0x48, 0x0A, 0x63, 0x54, 0x1F, 0xA6, 0x02, 0x6D, 0x08, 0x5A, 0x0E, 0x67, +/* 14A0 */ 0x3C, 0xAC, 0x7D, 0x08, 0x41, 0x46, 0x03, 0x37, 0x07, 0x0C, 0xB4, 0x9E, 0xF1, 0x10, 0x0A, 0x64, +/* 14B0 */ 0x57, 0x35, 0xC5, 0xE1, 0x98, 0x9E, 0x05, 0x5B, 0xB4, 0x4A, 0xA8, 0x9A, 0x25, 0x4B, 0x0D, 0x36, +/* 14C0 */ 0x37, 0xE3, 0xC8, 0x5D, 0xF8, 0xF8, 0x10, 0x05, 0x1E, 0xD4, 0xD6, 0x02, 0x10, 0x05, 0x1E, 0xD4, +/* 14D0 */ 0xE1, 0xE1, 0x60, 0xC5, 0x60, 0x90, 0x2B, 0x97, 0x4A, 0x21, 0x06, 0x79, 0x21, 0x2D, 0x0A, 0x38, +/* 14E0 */ 0x52, 0x0D, 0x06, 0x10, 0x0A, 0x38, 0x9B, 0xF6, 0x06, 0x07, 0x01, 0x2C, 0xC5, 0xE1, 0x9A, 0x03, +/* 14F0 */ 0x5A, 0x00, 0x7F, 0x9A, 0x0C, 0x3B, 0x25, 0x02, 0x2A, 0x0A, 0x5D, 0x25, 0x02, 0xD1, 0x20, 0x0E, +/* 1500 */ 0x94, 0x54, 0x2E, 0xB4, 0x95, 0x94, 0x6D, 0x25, 0xB5, 0x20, 0x7F, 0x02, 0x0A, 0x94, 0x5D, 0x25, +/* 1510 */ 0x02, 0x03, 0x73, 0x9A, 0x25, 0x9A, 0x0B, 0x94, 0x00, 0x25, 0x9A, 0xB5, 0x02, 0x10, 0x05, 0x38, +/* 1520 */ 0x9B, 0x48, 0x04, 0x05, 0xF2, 0x18, 0xF2, 0x18, 0xF2, 0x18, 0x35, 0x30, 0x7C, 0x27, 0x73, 0x03, +/* 1530 */ 0x21, 0x8D, 0x3E, 0x05, 0x10, 0x0F, 0xAB, 0xB4, 0x43, 0xA5, 0x86, 0x8D, 0x9E, 0x04, 0x26, 0x0E, +/* 1540 */ 0x67, 0x7F, 0x4A, 0x63, 0xA1, 0x1A, 0x7F, 0x0C, 0x2A, 0x4A, 0x05, 0x7F, 0x03, 0x1A, 0x7F, 0x03, +/* 1550 */ 0x3A, 0x7A, 0x24, 0x7A, 0x1A, 0x84, 0x3A, 0x2F, 0x0B, 0xCA, 0xCA, 0x3B, 0x10, 0x0A, 0xAB, 0xC0, +/* 1560 */ 0xE3, 0xC8, 0x5D, 0xF8, 0xF8, 0x10, 0x0B, 0xE2, 0xF7, 0xC2, 0x10, 0x0B, 0xAB, 0xB4, 0x43, 0x22, +/* 1570 */ 0xB2, 0x5B, 0x0E, 0x67, 0x7F, 0xA3, 0x25, 0xC4, 0xE6, 0x06, 0x0D, 0x0F, 0x43, 0x5B, 0xC5, 0x60, +/* 1580 */ 0x3E, 0xB0, 0x5D, 0x19, 0x10, 0x0B, 0xAB, 0x32, 0x0C, 0x9E, 0x05, 0x29, 0x1F, 0x32, 0x41, 0x71, +/* 1590 */ 0xFC, 0x5D, 0x69, 0x78, 0x81, 0x32, 0x71, 0xB4, 0x95, 0x88, 0x71, 0x76, 0x41, 0x4A, 0x5B, 0x07, +/* 15A0 */ 0x0D, 0x45, 0x8B, 0x2C, 0x69, 0x2C, 0x69, 0x2C, 0x69, 0x38, 0x52, 0x0D, 0x4A, 0x28, 0x19, 0x10, +/* 15B0 */ 0x07, 0xAB, 0xB4, 0x0C, 0x8D, 0x7C, 0x2E, 0x0E, 0x67, 0x0B, 0x30, 0x03, 0x2E, 0x0E, 0x41, 0x2B, +/* 15C0 */ 0xB4, 0x4A, 0x02, 0x01, 0x2B, 0xF0, 0x2C, 0xC5, 0x60, 0xC5, 0x02, 0x10, 0x09, 0xAB, 0x01, 0x9C, +/* 15D0 */ 0x4A, 0xF1, 0x50, 0x73, 0x71, 0x97, 0x0F, 0x77, 0x06, 0x77, 0x37, 0x97, 0x45, 0x2C, 0x23, 0x9F, +/* 15E0 */ 0x02, 0x5D, 0xF6, 0x72, 0x54, 0x21, 0xA0, 0x73, 0x03, 0x37, 0xA4, 0x6D, 0x0C, 0x36, 0x37, 0x03, +/* 15F0 */ 0x0E, 0x0A, 0x05, 0x05, 0xB4, 0x7C, 0x37, 0xD8, 0x41, 0x0C, 0x2E, 0x06, 0x0C, 0x3E, 0xAF, 0x01, +/* 1600 */ 0x10, 0x07, 0xD2, 0x32, 0x07, 0x09, 0x04, 0x27, 0x36, 0x27, 0x36, 0x21, 0xA8, 0x54, 0x2E, 0xA8, +/* 1610 */ 0xA3, 0xF6, 0x0C, 0x99, 0x04, 0x01, 0x2B, 0x0B, 0x36, 0x27, 0x36, 0x27, 0x36, 0x27, 0x36, 0xD7, +/* 1620 */ 0x06, 0x2C, 0x2D, 0x49, 0x03, 0x38, 0x78, 0x5A, 0x38, 0x33, 0x0C, 0x9E, 0x55, 0x10, 0x0A, 0x6E, +/* 1630 */ 0x4D, 0x18, 0x47, 0xBC, 0x10, 0x09, 0x21, 0x4D, 0x25, 0x03, 0x5D, 0x0A, 0x36, 0x1F, 0x0A, 0x36, +/* 1640 */ 0x5D, 0x72, 0x6B, 0x06, 0x94, 0xA4, 0x71, 0x70, 0x0C, 0x32, 0x94, 0x5B, 0x72, 0x00, 0x8F, 0x05, +/* 1650 */ 0x5B, 0x2D, 0x03, 0x2D, 0x01, 0x5B, 0x2A, 0x05, 0x0C, 0x87, 0xA4, 0x94, 0x99, 0x2B, 0x22, 0x7F, +/* 1660 */ 0x03, 0x2B, 0x8F, 0x67, 0x28, 0x78, 0x95, 0x10, 0x0E, 0x6E, 0x4D, 0xB9, 0x09, 0x54, 0x33, 0x99, +/* 1670 */ 0x1A, 0xD8, 0x7A, 0x24, 0x95, 0x00, 0x07, 0x36, 0x1A, 0x8F, 0x6C, 0x7F, 0x0C, 0x00, 0x2D, 0x03, +/* 1680 */ 0x1A, 0x91, 0x55, 0x0F, 0x22, 0x81, 0x75, 0x1A, 0xA4, 0x94, 0x04, 0x95, 0x0D, 0x5F, 0x0C, 0x4A, +/* 1690 */ 0x44, 0x0E, 0x45, 0x06, 0x9D, 0x0B, 0x0F, 0x03, 0x0E, 0x95, 0x44, 0x0B, 0x4A, 0x09, 0x7C, 0x09, +/* 16A0 */ 0x5C, 0x54, 0x44, 0x08, 0x67, 0x0B, 0x0F, 0x03, 0x07, 0x45, 0xA3, 0x1A, 0x33, 0x46, 0x5F, 0x05, +/* 16B0 */ 0x0F, 0x7F, 0x02, 0x44, 0x03, 0x73, 0x81, 0x70, 0x67, 0x1F, 0x73, 0x0C, 0x5D, 0x73, 0x0C, 0x10, +/* 16C0 */ 0x09, 0x6E, 0x4D, 0x0A, 0x99, 0x32, 0x5A, 0x00, 0x70, 0x81, 0x2D, 0x05, 0x5B, 0x2D, 0x05, 0xB4, +/* 16D0 */ 0x0C, 0x2E, 0x70, 0x72, 0x05, 0x5D, 0xEE, 0x87, 0x6D, 0x2A, 0x45, 0x21, 0xEC, 0x3B, 0x5B, 0x2A, +/* 16E0 */ 0x8F, 0x0B, 0x2E, 0xD1, 0x51, 0x3B, 0x1F, 0x06, 0x94, 0x33, 0x5A, 0x01, 0x7F, 0x03, 0x5D, 0xB4, +/* 16F0 */ 0x7C, 0x10, 0x0A, 0x6E, 0x4D, 0xF5, 0x0B, 0xBB, 0x01, 0xFB, 0x10, 0x08, 0x6E, 0x4D, 0x06, 0x30, +/* 1700 */ 0x41, 0x5B, 0x06, 0x30, 0x41, 0x48, 0x74, 0x0B, 0x85, 0x5D, 0xF6, 0x46, 0x02, 0x2B, 0x50, 0x54, +/* 1710 */ 0x6D, 0xEE, 0x0C, 0x6D, 0x52, 0x73, 0x02, 0x21, 0x0C, 0x54, 0x21, 0x08, 0x46, 0x42, 0x5B, 0xEC, +/* 1720 */ 0x41, 0x5B, 0x0C, 0x41, 0x4A, 0x10, 0x06, 0x00, 0x1E, 0x33, 0x0C, 0x62, 0x21, 0x91, 0x9D, 0x21, +/* 1730 */ 0x2D, 0xF1, 0x6D, 0x75, 0x02, 0xD7, 0x02, 0xD7, 0x02, 0xD7, 0x02, 0x27, 0x30, 0x9A, 0x19, 0xD1, +/* 1740 */ 0x2C, 0x0D, 0x36, 0x21, 0x3A, 0x43, 0x38, 0xF6, 0xB4, 0x81, 0x27, 0x30, 0x02, 0xD7, 0x02, 0xD7, +/* 1750 */ 0x02, 0xD7, 0x02, 0xD7, 0x60, 0x2D, 0xF1, 0x6D, 0x2A, 0x9D, 0x2C, 0x06, 0x0C, 0x62, 0x10, 0x07, +/* 1760 */ 0x9B, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0x10, 0x06, 0x1E, 0x09, 0x0E, 0xDE, +/* 1770 */ 0x2C, 0x09, 0x73, 0x02, 0x21, 0x98, 0x54, 0x2C, 0x2A, 0xF4, 0x30, 0xF4, 0x99, 0x2C, 0x91, 0xF4, +/* 1780 */ 0x99, 0x2C, 0x70, 0x1B, 0x38, 0xEE, 0x0A, 0x38, 0xF6, 0x0D, 0x95, 0x21, 0x70, 0x86, 0x6D, 0xF6, +/* 1790 */ 0x94, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x98, 0x54, +/* 17A0 */ 0x21, 0x2D, 0x2F, 0x2B, 0x09, 0x0E, 0xDE, 0x10, 0x09, 0xB3, 0xFE, 0x48, 0x3C, 0x38, 0xEE, 0x9F, +/* 17B0 */ 0x88, 0x83, 0x31, 0x33, 0x41, 0x7D, 0x32, 0xDE, 0x58, 0x0D, 0x0E, 0x83, 0x10, 0x00, 0x00, 0x00, +/* 17C0 */ 0x03, 0x00, 0x27, 0x00, 0x5F, 0x00, 0x94, 0x00, 0xDD, 0x01, 0x21, 0x01, 0x31, 0x01, 0x7A, 0x01, +/* 17D0 */ 0x8F, 0x01, 0xFB, 0x02, 0x35, 0x02, 0x72, 0x02, 0x8A, 0x02, 0x97, 0x02, 0xF0, 0x03, 0x00, 0x03, +/* 17E0 */ 0x21, 0x03, 0x35, 0x03, 0x5C, 0x03, 0x87, 0x03, 0x9A, 0x03, 0xCE, 0x04, 0x10, 0x04, 0x17, 0x04, +/* 17F0 */ 0x2D, 0x04, 0x4A, 0x04, 0x82, 0x04, 0xC1, 0x04, 0xE8, 0x05, 0x3A, 0x05, 0x8C, 0x05, 0xC3, 0x05, +/* 1800 */ 0xD7, 0x05, 0xEC, 0x06, 0x06, 0x06, 0x1C, 0x06, 0x33, 0x06, 0x4E, 0x06, 0x9A, 0x06, 0xE1, 0x06, +/* 1810 */ 0xF4, 0x07, 0x07, 0x07, 0x1C, 0x07, 0x33, 0x07, 0x48, 0x07, 0x5C, 0x07, 0x74, 0x07, 0x84, 0x07, +/* 1820 */ 0xD2, 0x07, 0xF2, 0x08, 0x06, 0x08, 0x1D, 0x08, 0x38, 0x08, 0x4C, 0x08, 0x5F, 0x08, 0x87, 0x08, +/* 1830 */ 0xE9, 0x08, 0xFD, 0x09, 0x11, 0x09, 0x28, 0x09, 0x30, 0x09, 0x4B, 0x09, 0x77, 0x09, 0xC4, 0x09, +/* 1840 */ 0xD8, 0x09, 0xED, 0x0A, 0x02, 0x0A, 0x16, 0x0A, 0x1E, 0x0A, 0x37, 0x0A, 0x8C, 0x0A, 0xC8, 0x0A, +/* 1850 */ 0xE0, 0x0A, 0xF9, 0x0B, 0x15, 0x0B, 0x23, 0x0B, 0x3A, 0x0B, 0x4E, 0x0B, 0x69, 0x0B, 0x81, 0x0B, +/* 1860 */ 0xCF, 0x0B, 0xE6, 0x0B, 0xFA, 0x0C, 0x0F, 0x0C, 0x28, 0x0C, 0x3B, 0x0C, 0x4E, 0x0C, 0x68, 0x0C, +/* 1870 */ 0xB6, 0x0C, 0xCD, 0x0C, 0xE5, 0x0C, 0xFE, 0x0D, 0x0B, 0x0D, 0x25, 0x0D, 0x5A, 0x04, 0x00, 0x10, +/* 1880 */ 0x05, 0xAB, 0x0B, 0x4B, 0x2C, 0x8A, 0x2A, 0x81, 0x27, 0x4B, 0x2E, 0x8E, 0x0E, 0x96, 0x35, 0x94, +/* 1890 */ 0x35, 0x94, 0x2C, 0xA2, 0x0A, 0x2C, 0x70, 0x0B, 0x2C, 0x70, 0x0C, 0x1A, 0x78, 0x0C, 0x2C, 0x69, +/* 18A0 */ 0x38, 0xF6, 0x46, 0x10, 0x09, 0xCD, 0x3A, 0x04, 0x35, 0x0D, 0x7A, 0x35, 0xD5, 0x6D, 0xF6, 0x0D, +/* 18B0 */ 0x73, 0x43, 0x52, 0x41, 0x7C, 0x5B, 0x0B, 0x94, 0x57, 0x07, 0x5B, 0x23, 0xED, 0x69, 0x34, 0x87, +/* 18C0 */ 0x38, 0x8B, 0x38, 0x52, 0x46, 0x35, 0x0D, 0x99, 0x57, 0x06, 0x5B, 0x33, 0x41, 0x7A, 0x2E, 0x06, +/* 18D0 */ 0x63, 0x86, 0x19, 0x0E, 0x5C, 0x35, 0x0E, 0x7A, 0x35, 0x0E, 0x7A, 0x10, 0x0A, 0xFE, 0x33, 0x0C, +/* 18E0 */ 0x67, 0x0B, 0x03, 0x00, 0xF6, 0x41, 0x7A, 0x5B, 0x0C, 0x94, 0x88, 0x0C, 0x20, 0x90, 0xA4, 0x2E, +/* 18F0 */ 0x18, 0x2C, 0x18, 0x21, 0x91, 0x41, 0x03, 0x1F, 0x32, 0x72, 0x4A, 0x0D, 0x86, 0x5B, 0x18, 0x5D, +/* 1900 */ 0x19, 0x46, 0x2C, 0x70, 0x0C, 0x21, 0x8D, 0x36, 0x42, 0x01, 0x1F, 0x08, 0x89, 0x6B, 0x08, 0x89, +/* 1910 */ 0x10, 0x0A, 0x6E, 0xAA, 0x19, 0x83, 0x38, 0x3F, 0x6B, 0x09, 0x0F, 0x0C, 0x09, 0x3E, 0x0A, 0x0A, +/* 1920 */ 0x95, 0x1F, 0x50, 0x0F, 0x41, 0xB0, 0x37, 0x08, 0x0F, 0x4B, 0x06, 0xB4, 0x09, 0x5B, 0x0C, 0x96, +/* 1930 */ 0x5D, 0x07, 0x67, 0x5B, 0x0E, 0x5C, 0x5D, 0x2A, 0x5B, 0x0C, 0x96, 0x5D, 0x07, 0x67, 0x5B, 0x08, +/* 1940 */ 0x0F, 0x4B, 0x06, 0xB4, 0x09, 0x1F, 0xA4, 0x22, 0x41, 0xB0, 0x1F, 0x09, 0x0F, 0x0C, 0x09, 0x3E, +/* 1950 */ 0x0A, 0x0B, 0x95, 0x31, 0xA4, 0x83, 0x38, 0x3F, 0x02, 0x10, 0x0A, 0x5E, 0xB3, 0x01, 0x7F, 0x02, +/* 1960 */ 0x5D, 0x24, 0x7A, 0x31, 0x08, 0x99, 0x6F, 0x5A, 0x01, 0x29, 0x5D, 0x07, 0x36, 0x37, 0x09, 0x3B, +/* 1970 */ 0x0C, 0x67, 0x48, 0x94, 0x03, 0x54, 0x2E, 0x0A, 0x67, 0x09, 0x0F, 0xA1, 0x6D, 0x78, 0x94, 0x2E, +/* 1980 */ 0x0B, 0xA8, 0x90, 0x37, 0x07, 0x09, 0x0B, 0x0F, 0x4A, 0x09, 0x56, 0x5B, 0x2A, 0x0B, 0x2B, 0x0B, +/* 1990 */ 0xA8, 0x90, 0x37, 0x9C, 0x72, 0x9E, 0xB0, 0x2E, 0x2A, 0x0B, 0x2C, 0x2A, 0x0B, 0x10, 0x07, 0x2C, +/* 19A0 */ 0x9B, 0xA2, 0x0C, 0xD9, 0xD9, 0xD9, 0x44, 0xB3, 0xA2, 0x0C, 0xD9, 0xD9, 0xD9, 0x10, 0x0A, 0xD2, +/* 19B0 */ 0x6F, 0x0A, 0x0E, 0xFB, 0x48, 0x0E, 0xA8, 0x95, 0xEE, 0x0A, 0x05, 0x07, 0x86, 0x5B, 0x2D, 0x05, +/* 19C0 */ 0x34, 0x0F, 0x62, 0xED, 0x0D, 0x73, 0x9F, 0x2E, 0x08, 0x4A, 0x0B, 0x0F, 0x7D, 0xA4, 0x99, 0x00, +/* 19D0 */ 0x03, 0x72, 0x37, 0xA2, 0x1B, 0x00, 0x2D, 0x5B, 0x0C, 0x46, 0x9C, 0x0F, 0x09, 0x5B, 0x3F, 0xA8, +/* 19E0 */ 0xB0, 0x5D, 0x48, 0x08, 0xF0, 0x21, 0x33, 0x94, 0x52, 0x0C, 0x06, 0xA0, 0x99, 0x5B, 0x0B, 0x73, +/* 19F0 */ 0x46, 0x20, 0x98, 0x0D, 0x4A, 0xF1, 0x10, 0x09, 0x00, 0x9B, 0x19, 0x0C, 0x0E, 0x53, 0x09, 0x9F, +/* 1A00 */ 0x5B, 0x2A, 0x83, 0x46, 0x37, 0xA4, 0x0C, 0x0E, 0x53, 0x09, 0x9F, 0x10, 0x0F, 0x64, 0x6F, 0x08, +/* 1A10 */ 0x0B, 0x0C, 0x0A, 0x06, 0x2E, 0x06, 0x41, 0x4A, 0x6B, 0x76, 0x4B, 0x02, 0x57, 0xD8, 0xB0, 0x26, +/* 1A20 */ 0xA4, 0x3E, 0x02, 0x88, 0x45, 0x58, 0x0F, 0x09, 0x44, 0x06, 0x5C, 0x03, 0x30, 0x99, 0x00, 0x0D, +/* 1A30 */ 0xA1, 0x26, 0x0B, 0x5F, 0xD8, 0x77, 0x07, 0x01, 0x00, 0x08, 0x7A, 0x26, 0x0C, 0x81, 0x0C, 0x7C, +/* 1A40 */ 0x6D, 0x33, 0x5C, 0x26, 0x0D, 0x81, 0x0C, 0x7C, 0x6D, 0x33, 0x5C, 0x26, 0x0B, 0x5F, 0xD8, 0x77, +/* 1A50 */ 0x07, 0x9A, 0x07, 0x7C, 0x26, 0x07, 0x7C, 0x91, 0x94, 0x00, 0x0C, 0x5F, 0x28, 0x6F, 0x4A, 0x1C, +/* 1A60 */ 0x0D, 0x45, 0x02, 0x05, 0x95, 0x31, 0x08, 0x4A, 0x04, 0x5D, 0x68, 0x67, 0x6B, 0x2D, 0x9E, 0x46, +/* 1A70 */ 0x04, 0x5B, 0xA0, 0x0E, 0x9E, 0x08, 0x02, 0x10, 0x09, 0xD2, 0x32, 0x0B, 0xB4, 0xB2, 0x2B, 0x07, +/* 1A80 */ 0x41, 0x6C, 0x48, 0x09, 0x05, 0x76, 0x95, 0x35, 0x0E, 0x45, 0x00, 0x48, 0x0A, 0x72, 0x45, 0x2E, +/* 1A90 */ 0x0D, 0x45, 0x03, 0x0E, 0x45, 0x48, 0x0F, 0x45, 0x2A, 0xB0, 0x1F, 0xA4, 0x63, 0x84, 0xF6, 0x0D, +/* 1AA0 */ 0x45, 0x58, 0x0A, 0x38, 0xAE, 0x19, 0x74, 0x42, 0x01, 0x31, 0x6F, 0x41, 0x36, 0x31, 0x6F, 0x41, +/* 1AB0 */ 0x36, 0x10, 0x0C, 0xE2, 0x33, 0x43, 0x00, 0x32, 0x0D, 0x04, 0x31, 0x6F, 0xB4, 0x0C, 0x00, 0x02, +/* 1AC0 */ 0x29, 0x1F, 0x50, 0x3B, 0x22, 0x7C, 0x1F, 0x0A, 0x85, 0x09, 0x5A, 0xB5, 0x02, 0x03, 0x73, 0x03, +/* 1AD0 */ 0x1F, 0x8B, 0x32, 0x71, 0x70, 0x5C, 0x02, 0xF0, 0x37, 0x06, 0x30, 0xB0, 0x2A, 0xA1, 0x37, 0x09, +/* 1AE0 */ 0x99, 0x00, 0x08, 0x94, 0x5B, 0x0C, 0x45, 0x00, 0x24, 0x0C, 0x48, 0x07, 0x6D, 0x68, 0x10, 0x0A, +/* 1AF0 */ 0x8E, 0xE2, 0x19, 0x74, 0x42, 0x03, 0x37, 0x03, 0x41, 0x71, 0x03, 0x41, 0x71, 0x1A, 0x0A, 0x4A, +/* 1B00 */ 0x35, 0x0A, 0x4A, 0x35, 0x0A, 0x4A, 0x10, 0x08, 0x8E, 0xE2, 0x19, 0x04, 0x42, 0x03, 0x00, 0x52, +/* 1B10 */ 0xE8, 0x52, 0xE8, 0x10, 0x0B, 0x00, 0x64, 0x06, 0x0C, 0x9E, 0xF1, 0x00, 0x0B, 0x62, 0x03, 0xA0, +/* 1B20 */ 0x0E, 0x04, 0x37, 0x07, 0x2F, 0x6D, 0x0A, 0xB0, 0x1F, 0x0E, 0x09, 0x03, 0x0F, 0x4A, 0xAD, 0x7C, +/* 1B30 */ 0x26, 0x6F, 0x7C, 0x03, 0x0F, 0x8C, 0x0B, 0x00, 0x0D, 0x09, 0x44, 0x32, 0x0F, 0xA6, 0x46, 0x53, +/* 1B40 */ 0x0C, 0x0B, 0x31, 0x03, 0x7A, 0x03, 0x9D, 0x0F, 0x9A, 0x0D, 0x0A, 0x44, 0xA4, 0x62, 0x03, 0x0F, +/* 1B50 */ 0x02, 0x0D, 0x09, 0x01, 0x9D, 0x1F, 0x09, 0x0E, 0x02, 0x06, 0x57, 0x06, 0x08, 0xA1, 0x1F, 0x50, +/* 1B60 */ 0x0C, 0x53, 0x58, 0x5C, 0x5B, 0xAC, 0x73, 0x0C, 0x04, 0x38, 0x48, 0x01, 0x10, 0x07, 0x00, 0x9B, +/* 1B70 */ 0x19, 0x04, 0x42, 0x01, 0x5B, 0x33, 0xA8, 0x7A, 0x5B, 0x33, 0xA8, 0x7A, 0x10, 0x09, 0xAA, 0x3F, +/* 1B80 */ 0x0E, 0x9F, 0x21, 0xEC, 0x94, 0x00, 0x52, 0x0F, 0x4B, 0x8F, 0x01, 0x37, 0x33, 0x45, 0x5D, 0xB4, +/* 1B90 */ 0x02, 0x52, 0x0F, 0x4B, 0x8F, 0x01, 0x2E, 0xEC, 0x94, 0x2B, 0x3F, 0x0E, 0x9F, 0x10, 0x0A, 0x6E, +/* 1BA0 */ 0xFE, 0x34, 0x5F, 0x34, 0xDB, 0x2B, 0x74, 0x42, 0x03, 0x37, 0xA2, 0xA8, 0x45, 0x37, 0xA2, 0xA8, +/* 1BB0 */ 0x45, 0x10, 0x07, 0x6D, 0xB3, 0x52, 0x0C, 0x9E, 0x05, 0x5D, 0x48, 0x63, 0x2F, 0x5B, 0x3F, 0x08, +/* 1BC0 */ 0x06, 0x36, 0x35, 0xB4, 0x03, 0x2C, 0x09, 0x0F, 0x09, 0x2C, 0x08, 0x95, 0x2C, 0x09, 0x0F, 0x0C, +/* 1BD0 */ 0x04, 0xAD, 0x2E, 0x18, 0x99, 0x2E, 0x18, 0x36, 0x10, 0x07, 0x64, 0x57, 0x60, 0x8F, 0x95, 0x5D, +/* 1BE0 */ 0x48, 0x63, 0x7A, 0x5D, 0x52, 0x02, 0x01, 0x0E, 0x7C, 0x6D, 0xF6, 0x0D, 0x95, 0x2C, 0x8F, 0x0B, +/* 1BF0 */ 0x60, 0x01, 0x0C, 0x96, 0x5D, 0xF6, 0x01, 0x24, 0x09, 0x00, 0x52, 0x67, 0x22, 0x7C, 0x2B, 0x07, +/* 1C00 */ 0x0D, 0x4A, 0x06, 0x10, 0x06, 0x61, 0x33, 0x28, 0x52, 0x22, 0x03, 0x21, 0x08, 0x0F, 0x94, 0x2B, +/* 1C10 */ 0x70, 0x0A, 0x04, 0x21, 0x33, 0x02, 0x10, 0x0B, 0xAB, 0xEB, 0x37, 0xEB, 0x37, 0xEB, 0x37, 0xEB, +/* 1C20 */ 0x37, 0xEB, 0x37, 0xEB, 0x37, 0xEB, 0x00, 0x25, 0x9A, 0xEC, 0x6C, 0x25, 0x08, 0x08, 0x0F, 0x54, +/* 1C30 */ 0x00, 0x25, 0x46, 0x99, 0x37, 0xB4, 0x0C, 0x0E, 0xDE, 0x7D, 0x00, 0x0E, 0x45, 0x00, 0x6F, 0x2E, +/* 1C40 */ 0x29, 0x35, 0x0E, 0x67, 0x35, 0x0E, 0x67, 0x28, 0x52, 0x02, 0x10, 0x0E, 0xFE, 0x58, 0x0D, 0x41, +/* 1C50 */ 0x36, 0x44, 0x50, 0x89, 0x5C, 0x44, 0x08, 0x41, 0x7C, 0x07, 0x36, 0x26, 0x3A, 0x41, 0xD3, 0x44, +/* 1C60 */ 0x3D, 0xD3, 0x44, 0x22, 0x41, 0xD3, 0x44, 0x8F, 0xA8, 0xD3, 0x31, 0x0B, 0x41, 0xD3, 0x1F, 0x06, +/* 1C70 */ 0x0A, 0x72, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, +/* 1C80 */ 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xF6, 0x06, 0x53, 0x02, 0x07, 0x05, 0x01, 0x10, 0x05, 0x21, 0x8E, +/* 1C90 */ 0xE2, 0xA5, 0xF3, 0x10, 0x06, 0x2C, 0xE2, 0xE2, 0xAD, 0x28, 0x48, 0x95, 0x35, 0x91, 0x1B, 0x6D, +/* 1CA0 */ 0xF6, 0x88, 0x9D, 0x19, 0x7F, 0x7C, 0x19, 0xA5, 0x9F, 0x10, 0x07, 0xFE, 0x4F, 0x9D, 0x5D, 0x48, +/* 1CB0 */ 0x22, 0x54, 0x21, 0x0C, 0x09, 0x0C, 0x9D, 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D, +/* 1CC0 */ 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D, 0x10, 0x09, 0xFE, 0x07, 0x0D, 0x4A, 0x08, 0x2B, 0x08, 0xE8, +/* 1CD0 */ 0x37, 0xA2, 0x0D, 0x05, 0xB9, 0x31, 0x32, 0x99, 0x97, 0x5C, 0x1F, 0x33, 0x54, 0x33, 0x54, 0x1F, +/* 1CE0 */ 0x32, 0x99, 0x97, 0x5C, 0x37, 0xA2, 0x0D, 0x05, 0xEC, 0x20, 0x08, 0xE8, 0x2E, 0x07, 0x0D, 0x4A, +/* 1CF0 */ 0x08, 0x28, 0xAE, 0x19, 0x74, 0x42, 0x6B, 0x33, 0x41, 0x54, 0x1F, 0x33, 0x41, 0x54, 0x10, 0x0C, +/* 1D00 */ 0xAB, 0x06, 0x0D, 0x02, 0x5D, 0x88, 0x02, 0x37, 0x70, 0x0C, 0xA4, 0xB4, 0x1B, 0x37, 0x08, 0x94, +/* 1D10 */ 0x00, 0x08, 0x7D, 0xA4, 0xF0, 0x50, 0x54, 0x37, 0x06, 0x73, 0x33, 0x90, 0x44, 0x6F, 0x90, 0x01, +/* 1D20 */ 0x90, 0x1F, 0xD8, 0x4A, 0x00, 0x2D, 0x0D, 0x78, 0x0E, 0x02, 0x03, 0x46, 0x03, 0x1F, 0x22, 0x7C, +/* 1D30 */ 0x24, 0x7C, 0x44, 0x6F, 0x0E, 0x96, 0xA4, 0xB4, 0x09, 0x5B, 0x68, 0x6D, 0x68, 0x10, 0x12, 0x6E, +/* 1D40 */ 0xB3, 0x0A, 0x43, 0x44, 0x4F, 0xFD, 0x9D, 0x00, 0x97, 0x0C, 0x5D, 0x03, 0x31, 0x0B, 0x9D, 0x5D, +/* 1D50 */ 0xD5, 0x97, 0x0A, 0x44, 0x0B, 0x9D, 0x33, 0x4A, 0x5D, 0xD5, 0x5B, 0x0C, 0x5C, 0x97, 0x0C, 0x52, +/* 1D60 */ 0x67, 0xC7, 0x68, 0x02, 0x10, 0x12, 0x6E, 0xB3, 0x0A, 0x43, 0x44, 0x4F, 0xFD, 0x9D, 0x00, 0x97, +/* 1D70 */ 0x0C, 0x00, 0x08, 0x3E, 0x83, 0x1A, 0x0B, 0x9D, 0x5D, 0xD5, 0x09, 0x73, 0x95, 0x1A, 0x0B, 0x9D, +/* 1D80 */ 0x33, 0x4A, 0x00, 0x4E, 0x4E, 0x4A, 0x1F, 0x0C, 0x5C, 0x38, 0x08, 0x95, 0x31, 0x03, 0x67, 0x38, +/* 1D90 */ 0x03, 0x3E, 0x02, 0x31, 0x0A, 0x9D, 0x6D, 0x03, 0x3E, 0x03, 0x26, 0x6F, 0x0F, 0xA1, 0x00, 0x32, +/* 1DA0 */ 0x0E, 0x9D, 0x65, 0x44, 0x09, 0x96, 0x6D, 0x09, 0x41, 0x26, 0xA2, 0x02, 0x6D, 0x09, 0x73, 0x4A, +/* 1DB0 */ 0x26, 0x08, 0x95, 0x35, 0x68, 0x02, 0x10, 0x12, 0x6E, 0xB3, 0x0A, 0x43, 0x1A, 0x32, 0x22, 0xB2, +/* 1DC0 */ 0x38, 0x70, 0x02, 0x1A, 0x23, 0x3B, 0x5D, 0x08, 0x95, 0x26, 0x33, 0x05, 0x05, 0x0E, 0x7C, 0x00, +/* 1DD0 */ 0xA4, 0xB4, 0x03, 0x44, 0x33, 0x0F, 0x9F, 0x6D, 0x07, 0x45, 0x1F, 0x06, 0xB4, 0x86, 0x5D, 0x0E, +/* 1DE0 */ 0x7A, 0x37, 0x24, 0x09, 0x97, 0x0C, 0x5D, 0x03, 0x26, 0x07, 0x3C, 0x22, 0x09, 0x00, 0xD5, 0x97, +/* 1DF0 */ 0x0A, 0x28, 0x03, 0x41, 0x03, 0x05, 0x4A, 0x5D, 0xD5, 0x1A, 0x03, 0x09, 0x0B, 0x09, 0x9A, 0x0C, +/* 1E00 */ 0x5C, 0x97, 0x0C, 0x52, 0x67, 0xC7, 0x68, 0x02, 0x10, 0x09, 0xE2, 0x32, 0x0E, 0x1B, 0x2C, 0x0C, +/* 1E10 */ 0x99, 0x2C, 0xEC, 0xF4, 0x0E, 0x1B, 0x5D, 0xAE, 0x93, 0x02, 0x01, 0x2C, 0x08, 0x3B, 0x19, 0xEC, +/* 1E20 */ 0x02, 0x2B, 0x51, 0x0F, 0x45, 0x19, 0x72, 0x1B, 0x2B, 0x8F, 0x0C, 0xED, 0x0A, 0x54, 0x00, 0x33, +/* 1E30 */ 0x01, 0x5B, 0x2D, 0xB2, 0xD8, 0x86, 0x31, 0x6F, 0x0E, 0xA8, 0x4A, 0x20, 0x98, 0x0E, 0xFB, 0x10, +/* 1E40 */ 0x0B, 0x6E, 0xA0, 0x02, 0x35, 0x22, 0x62, 0x21, 0x58, 0xB4, 0x45, 0x35, 0x4E, 0x07, 0x00, 0xAE, +/* 1E50 */ 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x00, 0xA9, 0x8C, 0x02, 0x21, 0x58, 0x7D, 0x28, 0x72, 0xB2, 0x21, +/* 1E60 */ 0x09, 0x0A, 0x04, 0x6D, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x2E, 0x48, 0x0D, 0x0F, 0x1B, 0x2B, +/* 1E70 */ 0x50, 0x73, 0x1B, 0x2E, 0x22, 0x0C, 0x88, 0x95, 0x00, 0xF6, 0x07, 0x6D, 0x08, 0x03, 0xAE, 0xCC, +/* 1E80 */ 0xC1, 0xFA, 0x10, 0x0B, 0x8E, 0x01, 0xA5, 0x0A, 0x05, 0xAF, 0x2E, 0x09, 0x73, 0x99, 0x2E, 0x09, +/* 1E90 */ 0x77, 0xA5, 0x0A, 0x00, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x8E, 0x0A, 0x0E, 0x6C, 0x92, 0x0A, +/* 1EA0 */ 0x5B, 0x70, 0x0C, 0x00, 0x84, 0x5B, 0x0A, 0x0E, 0x6C, 0x92, 0x0A, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, +/* 1EB0 */ 0x0B, 0x28, 0x03, 0x0C, 0x0E, 0x43, 0x2B, 0x3A, 0xB4, 0x0C, 0x19, 0x45, 0x3A, 0x21, 0xD1, 0x87, +/* 1EC0 */ 0x6D, 0x03, 0x0C, 0x0E, 0x43, 0x00, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0F, 0xCD, 0x24, 0x89, 0x02, +/* 1ED0 */ 0x44, 0xA2, 0x41, 0x46, 0x31, 0x06, 0x30, 0xF0, 0x74, 0x03, 0x31, 0x0C, 0x99, 0xA3, 0x37, 0x70, +/* 1EE0 */ 0x49, 0x54, 0x5B, 0x07, 0x54, 0x03, 0x0F, 0x45, 0x42, 0x44, 0xEC, 0x03, 0xA2, 0x41, 0x26, 0x70, +/* 1EF0 */ 0x0D, 0x5D, 0x3D, 0x26, 0x08, 0x0F, 0x45, 0x65, 0x72, 0x6B, 0x72, 0x41, 0x7A, 0x31, 0x03, 0x89, +/* 1F00 */ 0x9D, 0x31, 0x2D, 0x0B, 0x5D, 0x97, 0x45, 0x74, 0x03, 0x28, 0xF0, 0x6D, 0x03, 0x41, 0x4A, 0x38, +/* 1F10 */ 0xB5, 0x02, 0x5D, 0xA4, 0x41, 0x4A, 0x10, 0x0A, 0xCD, 0x98, 0x0D, 0x4A, 0xF1, 0x76, 0x41, 0xA1, +/* 1F20 */ 0x78, 0x0F, 0x09, 0x05, 0x92, 0x05, 0x37, 0x0B, 0x94, 0x5D, 0xA4, 0x37, 0x18, 0x03, 0x21, 0xB5, +/* 1F30 */ 0xED, 0x8A, 0x06, 0x46, 0x21, 0x33, 0x73, 0x2C, 0x23, 0x60, 0x0D, 0x54, 0x34, 0x67, 0x53, 0x8C, +/* 1F40 */ 0x06, 0x5B, 0x75, 0x41, 0x20, 0x07, 0x72, 0x4A, 0x05, 0x21, 0x22, 0x03, 0x35, 0xD1, 0x05, 0x6D, +/* 1F50 */ 0x48, 0x05, 0x09, 0x4A, 0x21, 0x2D, 0x45, 0x21, 0x07, 0x0D, 0x0E, 0x0B, 0x02, 0x10, 0x09, 0x6E, +/* 1F60 */ 0x09, 0x06, 0x26, 0x78, 0x43, 0x21, 0x8C, 0x30, 0x7C, 0x38, 0x48, 0x07, 0x1B, 0x5E, 0x3D, 0xEA, +/* 1F70 */ 0x10, 0x09, 0x00, 0xA9, 0x06, 0x0A, 0x38, 0x52, 0xB9, 0x2E, 0x2A, 0x45, 0x03, 0x19, 0xAF, 0x6B, +/* 1F80 */ 0x2E, 0x4C, 0xEA, 0x10, 0x09, 0x6E, 0x06, 0x54, 0x2B, 0x33, 0xA8, 0x6C, 0x52, 0x99, 0x8F, 0x04, +/* 1F90 */ 0x2E, 0x08, 0x03, 0x6F, 0x09, 0x5E, 0x3D, 0xEA, 0x10, 0x09, 0x28, 0xA9, 0x52, 0x0D, 0x0D, 0x02, +/* 1FA0 */ 0xDF, 0x37, 0x08, 0x54, 0x2A, 0x0B, 0x52, 0x0D, 0x0D, 0x02, 0xDF, 0x00, 0xB1, 0x4C, 0xEA, 0x10, +/* 1FB0 */ 0x05, 0x38, 0xB1, 0x51, 0x03, 0x35, 0x08, 0x94, 0xED, 0x06, 0x72, 0xA1, 0x38, 0xF6, 0x09, 0x0A, +/* 1FC0 */ 0x5D, 0xAE, 0x66, 0xB6, 0x10, 0x05, 0x1A, 0xB1, 0x3F, 0x05, 0x2C, 0x06, 0x29, 0x21, 0x0A, 0x46, +/* 1FD0 */ 0x56, 0x5B, 0x33, 0x49, 0x38, 0xAE, 0x66, 0xB6, 0x10, 0x05, 0x26, 0x27, 0x67, 0x03, 0x21, 0xD8, +/* 1FE0 */ 0x46, 0x02, 0x2E, 0x08, 0x4A, 0xA7, 0x4A, 0x00, 0x48, 0x56, 0x00, 0x06, 0x6C, 0xAE, 0x66, 0xB6, +/* 1FF0 */ 0x10, 0x05, 0x26, 0xAE, 0x92, 0xE4, 0x5B, 0x84, 0xD8, 0x7C, 0x5B, 0x92, 0xE4, 0xAE, 0x66, 0xB6, +/* 2000 */ 0x10, 0x0C, 0xAA, 0x09, 0x73, 0x4A, 0x0A, 0x05, 0x5D, 0x7E, 0x45, 0x37, 0x2D, 0xDE, 0x92, 0x94, +/* 2010 */ 0x1F, 0x09, 0x94, 0x5D, 0xB5, 0x02, 0x31, 0x09, 0x94, 0x6D, 0xB4, 0x7C, 0x44, 0x03, 0x75, 0xDE, +/* 2020 */ 0x03, 0x00, 0x0C, 0x99, 0x44, 0x0B, 0x73, 0x85, 0x0B, 0x94, 0x44, 0x0B, 0x73, 0x85, 0x0B, 0x99, +/* 2030 */ 0x31, 0x09, 0x94, 0x6D, 0x0C, 0x54, 0x31, 0x09, 0x94, 0x6D, 0xB4, 0x7C, 0x31, 0x09, 0x94, 0x00, +/* 2040 */ 0x33, 0x90, 0x31, 0x2D, 0xDE, 0x92, 0x94, 0x7E, 0x95, 0x37, 0x2D, 0x46, 0x0A, 0x05, 0x10, 0x0C, +/* 2050 */ 0x5E, 0xF6, 0x0D, 0xB2, 0x07, 0x43, 0x37, 0xA4, 0x0E, 0x41, 0x02, 0x52, 0x0C, 0x08, 0x07, 0x0D, +/* 2060 */ 0x0E, 0x05, 0x1A, 0xA9, 0x63, 0x03, 0x5D, 0x29, 0x25, 0x96, 0x5D, 0x29, 0xBF, 0xD0, 0x10, 0x0D, +/* 2070 */ 0xA9, 0x06, 0x56, 0x2C, 0xD1, 0x05, 0x21, 0xAC, 0x0E, 0x94, 0x2C, 0x1C, 0x77, 0xAE, 0xBE, 0xF1, +/* 2080 */ 0xCF, 0xC9, 0x10, 0x0D, 0x2C, 0xF6, 0x0B, 0xED, 0x3F, 0x54, 0x5D, 0x48, 0x7F, 0x0C, 0x06, 0x21, +/* 2090 */ 0x0A, 0x09, 0x03, 0x5D, 0xAE, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x2B, 0x52, 0x0E, 0x95, 0x6D, +/* 20A0 */ 0x52, 0x7F, 0x95, 0x5B, 0xA4, 0x0E, 0x95, 0x88, 0x96, 0x2E, 0x06, 0x06, 0x5D, 0xAC, 0x02, 0x5E, +/* 20B0 */ 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x5E, 0x48, 0x0C, 0xE0, 0x5B, 0x0B, 0xA8, 0x7C, 0x2E, 0x0A, +/* 20C0 */ 0x49, 0x0C, 0x9F, 0xAE, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x8E, 0xDF, 0x09, 0x9F, 0x5B, 0x91, +/* 20D0 */ 0x83, 0x46, 0x5B, 0xDF, 0x09, 0x9F, 0x5E, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x09, 0x26, 0xE2, 0xF6, +/* 20E0 */ 0x86, 0x5D, 0x0B, 0x08, 0x2E, 0xD1, 0x02, 0xD8, 0x7C, 0x52, 0x0E, 0x67, 0x99, 0x2B, 0x2A, 0x95, +/* 20F0 */ 0x21, 0x07, 0x73, 0xB0, 0x5B, 0x97, 0x45, 0x0F, 0x87, 0x3A, 0x0C, 0x97, 0x7A, 0x37, 0xA4, 0x83, +/* 2100 */ 0x5D, 0x08, 0x05, 0x10, 0x0D, 0x9B, 0x6F, 0x02, 0xB1, 0x08, 0x4A, 0x35, 0x0C, 0x45, 0x2E, 0x4E, +/* 2110 */ 0xB4, 0x54, 0x5D, 0x7E, 0x82, 0x31, 0x2A, 0x62, 0x08, 0x73, 0xB0, 0x31, 0x72, 0x6C, 0x08, 0x4A, +/* 2120 */ 0x36, 0x1A, 0x6F, 0x90, 0x00, 0x0C, 0xAF, 0x85, 0x1A, 0x33, 0x46, 0xA4, 0x96, 0x8B, 0x26, 0x97, +/* 2130 */ 0x4A, 0x33, 0x0F, 0x65, 0x46, 0x26, 0x97, 0x4A, 0x00, 0x09, 0x81, 0xB5, 0x44, 0x91, 0x81, 0x0D, +/* 2140 */ 0x0A, 0x00, 0x8B, 0x44, 0x23, 0x03, 0x0F, 0x6C, 0x8F, 0x0B, 0x31, 0x22, 0x45, 0x0F, 0x9A, 0x0C, +/* 2150 */ 0x36, 0x31, 0x2A, 0x67, 0x05, 0x75, 0xB0, 0x7E, 0x82, 0x37, 0x72, 0x4A, 0xF1, 0x70, 0x05, 0x21, +/* 2160 */ 0x33, 0x0E, 0x5F, 0x1A, 0x52, 0x10, 0x0C, 0xA9, 0x49, 0x35, 0x2A, 0x0B, 0x02, 0x6D, 0xF6, 0xEC, +/* 2170 */ 0x2F, 0x6D, 0x48, 0x08, 0x0C, 0x1A, 0xA9, 0x6A, 0xB8, 0x10, 0x0C, 0x00, 0xA9, 0x58, 0xF4, 0x72, +/* 2180 */ 0x02, 0x2B, 0x8F, 0x95, 0x02, 0x5D, 0x52, 0x0C, 0x06, 0x01, 0x5E, 0x6A, 0xB8, 0x10, 0x0C, 0x2B, +/* 2190 */ 0xEE, 0x05, 0x6D, 0xEE, 0x3B, 0x37, 0x33, 0x0F, 0x4B, 0x09, 0x67, 0x20, 0xAC, 0x9A, 0x32, 0x07, +/* 21A0 */ 0x28, 0xA9, 0x6A, 0xB8, 0x10, 0x0C, 0x8E, 0xE7, 0x38, 0xA9, 0x6A, 0xB8, 0x10, 0x0B, 0x00, 0xA9, +/* 21B0 */ 0x8C, 0x02, 0x21, 0xAC, 0x94, 0x19, 0x72, 0xB2, 0x21, 0x09, 0x0A, 0x53, 0xB1, 0x19, 0xF0, 0x6D, +/* 21C0 */ 0x8F, 0x0C, 0x31, 0x08, 0xBD, 0x2C, 0xC6, 0x10, 0x0B, 0xAA, 0xE3, 0x59, 0x63, 0x4A, 0x39, 0x4C, +/* 21D0 */ 0x5C, 0x37, 0x79, 0x4E, 0x73, 0x6B, 0xE3, 0x00, 0xF0, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3, 0x24, +/* 21E0 */ 0x96, 0x25, 0x04, 0xA4, 0xF0, 0x1F, 0x79, 0x4E, 0x30, 0xA1, 0x25, 0x41, 0x6C, 0x25, 0x46, 0x39, +/* 21F0 */ 0x5B, 0xE3, 0x59, 0x10, 0x0B, 0x26, 0x9B, 0x52, 0xAD, 0x2B, 0x33, 0x63, 0x43, 0xF6, 0xA8, 0x46, +/* 2200 */ 0x5B, 0x0B, 0x30, 0x55, 0xB9, 0x25, 0x9A, 0xD8, 0x5F, 0x00, 0x25, 0x02, 0x02, 0x0E, 0x9D, 0x5D, +/* 2210 */ 0x25, 0x8D, 0x87, 0x00, 0x7F, 0x70, 0x0A, 0x6D, 0x25, 0x02, 0x79, 0x5D, 0x25, 0x02, 0x76, 0x99, +/* 2220 */ 0x00, 0x25, 0x9A, 0x06, 0x30, 0x7A, 0x25, 0x02, 0x5D, 0x2D, 0x0A, 0x25, 0x9A, 0x97, 0x45, 0x25, +/* 2230 */ 0x02, 0x02, 0x05, 0x0C, 0x94, 0x25, 0x02, 0x2D, 0x67, 0x02, 0x25, 0x02, 0x0C, 0x3E, 0x0B, 0x03, +/* 2240 */ 0x10, 0x0A, 0x61, 0xAD, 0xB1, 0x0D, 0x4B, 0x2C, 0x91, 0x45, 0x02, 0x6D, 0x48, 0x08, 0x0E, 0x5C, +/* 2250 */ 0x35, 0x1C, 0xAE, 0xB7, 0x10, 0x0A, 0x9B, 0xA6, 0x35, 0x07, 0x87, 0x6D, 0x03, 0xEC, 0x2F, 0x2E, +/* 2260 */ 0x08, 0x0F, 0xB2, 0xED, 0x01, 0x05, 0x6D, 0xAE, 0xB7, 0x10, 0x0A, 0x00, 0x64, 0x8F, 0x05, 0x21, +/* 2270 */ 0x06, 0x30, 0x3B, 0xF6, 0x54, 0x09, 0x67, 0x20, 0x51, 0x03, 0x5D, 0xA7, 0x5E, 0xB7, 0x10, 0x0A, +/* 2280 */ 0x64, 0x05, 0x9E, 0x06, 0x08, 0x0B, 0x02, 0x48, 0x41, 0xA1, 0x52, 0xAF, 0x07, 0x9E, 0x04, 0x31, +/* 2290 */ 0x8E, 0xB7, 0x10, 0x0A, 0x2C, 0x9B, 0xE7, 0x44, 0x8E, 0xB7, 0x10, 0x0A, 0x61, 0x09, 0x0E, 0x62, +/* 22A0 */ 0x21, 0x07, 0x0F, 0xE3, 0x2E, 0xD8, 0x03, 0x06, 0x9D, 0x2B, 0x07, 0x0F, 0xE3, 0x2B, 0x09, 0x0E, +/* 22B0 */ 0x62, 0xAE, 0xB7, 0x10, 0x10, 0xAB, 0x04, 0x9C, 0x3E, 0x0A, 0x02, 0x04, 0x0C, 0x67, 0x0A, 0x02, +/* 22C0 */ 0x26, 0x08, 0xA8, 0x4A, 0x41, 0xB0, 0x38, 0x6F, 0x09, 0x05, 0x04, 0x09, 0x73, 0x49, 0x09, 0x99, +/* 22D0 */ 0x1F, 0x18, 0x02, 0x5D, 0x0F, 0x4A, 0x1A, 0x58, 0x0D, 0x73, 0x89, 0x28, 0x50, 0x41, 0x89, 0x28, +/* 22E0 */ 0x06, 0x30, 0x4B, 0x04, 0xF0, 0x04, 0x42, 0x28, 0x08, 0x0F, 0x95, 0x5D, 0x0D, 0x36, 0x31, 0x97, +/* 22F0 */ 0x4A, 0x05, 0x09, 0x73, 0x4B, 0x05, 0x09, 0xB0, 0x38, 0xA4, 0x0E, 0xA8, 0x0C, 0x0A, 0xA8, 0x54, +/* 2300 */ 0x1A, 0x8C, 0x3E, 0x56, 0x06, 0x0C, 0x3E, 0x49, 0x10, 0x09, 0xE2, 0x02, 0x9C, 0xFB, 0x48, 0x0D, +/* 2310 */ 0x73, 0x54, 0x5B, 0x0B, 0x30, 0x49, 0x07, 0x0B, 0x5B, 0x23, 0xED, 0x8B, 0x34, 0x87, 0x38, 0x2A, +/* 2320 */ 0x0C, 0x38, 0x52, 0x46, 0x35, 0x0C, 0x99, 0x57, 0x6C, 0xF6, 0xA8, 0x3B, 0xF6, 0x0C, 0x73, 0x43, +/* 2330 */ 0x21, 0x22, 0x02, 0x35, 0x0E, 0x67, 0x53, 0x19, 0x58, 0x87, 0x6D, 0x2D, 0x45, 0x21, 0x0B, 0x46, +/* 2340 */ 0x03, 0x38, 0x48, 0x3C, 0x10, 0x0A, 0x61, 0x02, 0x04, 0xB1, 0x09, 0x0F, 0x56, 0x19, 0xB4, 0x4A, +/* 2350 */ 0x04, 0x21, 0x1C, 0x0D, 0x45, 0xB1, 0xAD, 0xAE, 0x98, 0xC3, 0xDA, 0xF1, 0x10, 0x0A, 0x9B, 0x01, +/* 2360 */ 0x04, 0x35, 0x88, 0xA1, 0x19, 0xD8, 0x36, 0x5D, 0xF6, 0x67, 0x09, 0x03, 0x21, 0x33, 0x01, 0x6D, +/* 2370 */ 0xAE, 0x98, 0xC3, 0xDA, 0xF1, 0x10, 0x0A, 0x1A, 0x9B, 0x52, 0xB4, 0x09, 0x6D, 0x52, 0xB4, 0x99, +/* 2380 */ 0x5B, 0xA4, 0x0E, 0x95, 0x4F, 0x5C, 0x2E, 0x09, 0x06, 0x5D, 0x8C, 0x02, 0x5E, 0x98, 0xC3, 0xDA, +/* 2390 */ 0xF1, 0x10, 0x0A, 0x9B, 0xE5, 0x86, 0x00, 0x0B, 0x4B, 0x31, 0x8E, 0x98, 0xC3, 0xDA, 0xF1, 0x10, +/* 23A0 */ 0x05, 0x1E, 0x33, 0x1A, 0x52, 0x0F, 0x43, 0x2C, 0x2D, 0x96, 0x2C, 0xA0, 0x67, 0x02, 0x28, 0x48, +/* 23B0 */ 0x05, 0x5D, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x61, 0x05, 0x35, 0x8D, 0x5C, 0x21, 0x4F, 0x5A, +/* 23C0 */ 0x38, 0x3A, 0x77, 0x2C, 0xA6, 0x28, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x00, 0x9B, 0x19, 0x0C, +/* 23D0 */ 0x4A, 0xED, 0x0B, 0x73, 0x1B, 0x2E, 0x09, 0x4A, 0x05, 0x0C, 0x45, 0x00, 0xF6, 0x83, 0x5D, 0x09, +/* 23E0 */ 0x6C, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x2B, 0x9B, 0x09, 0x9F, 0x00, 0x4F, 0x0B, 0x5B, 0xA2, +/* 23F0 */ 0x81, 0xB9, 0x37, 0x09, 0x9F, 0x00, 0x4F, 0x0B, 0x37, 0x8E, 0xC5, 0xD6, 0x02, 0x10, 0x0B, 0x9B, +/* 2400 */ 0x93, 0x21, 0x07, 0x53, 0xA5, 0x03, 0x2E, 0x91, 0xB4, 0x82, 0xF6, 0x75, 0x4A, 0x02, 0x2B, 0x07, +/* 2410 */ 0xA8, 0xB0, 0x5B, 0x33, 0x77, 0x08, 0x7D, 0x26, 0x72, 0x20, 0x88, 0x0E, 0x0B, 0x0A, 0x54, 0x1F, +/* 2420 */ 0x33, 0x41, 0x85, 0x25, 0x08, 0x05, 0x0C, 0x5A, 0x69, 0x5D, 0x03, 0x46, 0x31, 0x97, 0x45, 0x6F, +/* 2430 */ 0x46, 0x31, 0x97, 0x45, 0x5D, 0x03, 0x5A, 0x03, 0x0F, 0x4A, 0x5D, 0x06, 0x94, 0x37, 0x0D, 0x99, +/* 2440 */ 0x05, 0x72, 0x03, 0x1F, 0x32, 0x63, 0x99, 0x2E, 0x98, 0x3E, 0x77, 0x10, 0x0A, 0x64, 0x02, 0x0C, +/* 2450 */ 0xE0, 0x5B, 0x0B, 0x73, 0x36, 0x2E, 0x0A, 0x49, 0x0C, 0x9F, 0x31, 0x8E, 0xC0, 0xE3, 0xC8, 0x5D, +/* 2460 */ 0xF8, 0xF8, 0x10, 0x0B, 0x61, 0x33, 0xB1, 0x07, 0x0F, 0x83, 0x2C, 0xEC, 0x4B, 0x21, 0x33, 0x22, +/* 2470 */ 0x0C, 0xB1, 0xA6, 0xAE, 0xF7, 0xC2, 0x10, 0x0B, 0x9B, 0x33, 0x28, 0x52, 0x0D, 0x2F, 0x2E, 0x58, +/* 2480 */ 0x0F, 0x99, 0x2B, 0x70, 0x39, 0x21, 0x33, 0x20, 0x6E, 0xF7, 0xC2, 0x10, 0x0B, 0x1A, 0x9B, 0x48, +/* 2490 */ 0x0E, 0x45, 0x6D, 0x48, 0x72, 0x95, 0x2B, 0x22, 0x49, 0x0E, 0x96, 0x2E, 0x08, 0x08, 0x5D, 0x8D, +/* 24A0 */ 0x03, 0x5E, 0xF7, 0xC2, 0x10, 0x0B, 0x64, 0x51, 0xE0, 0x5B, 0x0A, 0x73, 0x36, 0x2E, 0x0A, 0x49, +/* 24B0 */ 0x0C, 0x0E, 0x09, 0x1F, 0x8E, 0xF7, 0xC2, 0x10, 0x0B, 0x2C, 0x9B, 0xDF, 0x09, 0x9F, 0x5B, 0x91, +/* 24C0 */ 0x83, 0x46, 0x5B, 0xDF, 0x09, 0x9F, 0x31, 0x8E, 0xF7, 0xC2, 0x10, 0x09, 0xCD, 0x4F, 0x7B, 0x2C, +/* 24D0 */ 0xF0, 0x2C, 0xF0, 0x2C, 0x4F, 0x7B, 0x28, 0xAE, 0x19, 0xDD, 0xAE, 0x4F, 0x7B, 0x2C, 0xF0, 0x2C, +/* 24E0 */ 0xF0, 0x2C, 0x4F, 0x7B, 0x10, 0x0B, 0x00, 0xCD, 0x6F, 0x02, 0xB1, 0xD8, 0x09, 0x35, 0xB4, 0x6C, +/* 24F0 */ 0x48, 0x0A, 0x63, 0x02, 0x52, 0x0E, 0xA8, 0x87, 0x0C, 0x99, 0xD8, 0x54, 0x1F, 0x03, 0x85, 0x0C, +/* 2500 */ 0x0B, 0x29, 0x31, 0x33, 0x54, 0x01, 0x5C, 0x22, 0x5F, 0x31, 0x06, 0x54, 0x76, 0x51, 0x30, 0x02, +/* 2510 */ 0x44, 0x33, 0x54, 0x0A, 0x0C, 0x00, 0x22, 0x5F, 0x31, 0x70, 0x0A, 0x62, 0x01, 0x71, 0x22, 0x54, +/* 2520 */ 0x0B, 0x99, 0x37, 0x03, 0x0E, 0x41, 0x1B, 0x5B, 0x8F, 0xFB, 0x2E, 0x0B, 0x95, 0x35, 0x0D, 0x5C, +/* 2530 */ 0xB1, 0x3C, 0x10, 0x0A, 0x61, 0x02, 0x03, 0xB1, 0xD8, 0x56, 0x19, 0xB4, 0x4A, 0x04, 0x21, 0x1C, +/* 2540 */ 0x0D, 0x95, 0xB1, 0xAD, 0x1A, 0xA9, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0x01, 0x04, 0x2C, 0x33, +/* 2550 */ 0x0E, 0xA1, 0x19, 0xD8, 0x36, 0x5D, 0xF6, 0x67, 0xF1, 0x6D, 0x33, 0x01, 0x00, 0xAE, 0x18, 0x47, +/* 2560 */ 0xBC, 0x10, 0x0A, 0x64, 0x32, 0x99, 0x6D, 0x52, 0xB4, 0x54, 0x00, 0x48, 0xB4, 0x09, 0x76, 0x7C, +/* 2570 */ 0x2E, 0x0A, 0x06, 0x5D, 0x8C, 0x60, 0x21, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0xE5, 0x86, 0x00, +/* 2580 */ 0xA5, 0x05, 0x26, 0x8E, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0x04, 0x60, 0xAC, 0x0F, 0x09, 0x6D, +/* 2590 */ 0xF6, 0x72, 0xA1, 0x2B, 0x0B, 0x4A, 0x06, 0xED, 0x02, 0x04, 0x5D, 0xAE, 0xF5, 0x0B, 0xBB, 0x01, +/* 25A0 */ 0xFB, 0x10, 0x0B, 0x64, 0x57, 0x35, 0xC5, 0xE1, 0x04, 0x0B, 0x0F, 0xB2, 0x5D, 0x25, 0x7F, 0xA3, +/* 25B0 */ 0x25, 0x0C, 0x4E, 0x5A, 0x00, 0xB4, 0x2F, 0x02, 0x90, 0x25, 0x02, 0x5D, 0x73, 0x03, 0x25, 0x02, +/* 25C0 */ 0x5D, 0x7F, 0x03, 0x25, 0x02, 0x5D, 0x73, 0x02, 0x25, 0x9A, 0x03, 0xE6, 0x06, 0x22, 0x43, 0x5B, +/* 25D0 */ 0xC5, 0x60, 0x3E, 0x1B, 0x5D, 0x19, 0x10, 0x0A, 0x2C, 0x9B, 0x92, 0xE4, 0x5B, 0x72, 0x02, 0x0A, +/* 25E0 */ 0x36, 0x5B, 0x92, 0xE4, 0x26, 0x8E, 0xF5, 0x0B, 0xBB, 0x01, 0xFB, 0x10, 0x00, 0x00, 0x00, 0x0D, +/* 25F0 */ 0x00, 0x1C, 0x00, 0x0D, 0x0A, 0x5D, 0x8E, 0xE2, 0x52, 0x42, 0x42, 0x03, 0x40, 0x0D, 0x40, 0x0D, +/* 2600 */ 0x10, 0x0A, 0x5D, 0x8E, 0xE2, 0x48, 0x42, 0x42, 0x37, 0x09, 0x41, 0x90, 0x7E, 0x0F, 0x5F, 0x10, +/* 2610 */ 0x0F, 0x5D, 0x8E, 0xE2, 0x48, 0x04, 0x42, 0x42, 0x42, 0x1A, 0x2D, 0x89, 0x90, 0x28, 0x2D, 0x89, +/* 2620 */ 0x90, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x9D, 0x00, 0x00, +/* 2630 */ 0x07, 0x9F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x07, 0xA2, 0x00, 0x00, +/* 2640 */ 0x08, 0x60, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x17, 0xBD, 0x00, 0x00, +/* 2650 */ 0x18, 0x7D, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x25, 0xEC, 0x00, 0x00, +/* 2660 */ 0x25, 0xF4, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold24.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold24.mcufont.h new file mode 100644 index 000000000..337b020f8 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold24.mcufont.h @@ -0,0 +1,755 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 24 + * blob size: 11720, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x06, 0x2E, 0x00, 0x00, 0x06, 0xA3, 0x00, 0x00, 0x00, 0x9C, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x2D, 0x88, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x18, 0x00, 0x1E, 0x00, 0x05, 0x00, 0x16, 0x00, 0x02, 0x00, 0x17, 0x00, 0x1D, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x32, 0x34, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x32, 0x34, 0x00, +/* dictionary data */ +0xFA, 0xCA, 0x02, 0x81, 0xC4, 0x03, 0xCA, 0x42, 0x28, 0x03, 0x14, +/* 0080 */ 0x0B, 0xCA, 0x82, 0xC2, 0x02, 0x81, 0xCB, 0xC9, 0x0F, 0x81, 0xCD, 0xDA, 0x01, 0xC5, 0x81, 0xCD, +/* 0090 */ 0x02, 0x0F, 0x0C, 0xCA, 0x80, 0x06, 0xCB, 0x81, 0x09, 0x03, 0xC9, 0x81, 0x80, 0xC6, 0x0A, 0xC7, +/* 00A0 */ 0x85, 0x13, 0x05, 0x80, 0xCC, 0x0C, 0xC4, 0x82, 0xCE, 0x81, 0xCC, 0x82, 0x02, 0xCA, 0x14, 0xCB, +/* 00B0 */ 0x81, 0xCE, 0x13, 0xC4, 0x82, 0xCB, 0x13, 0xC4, 0x80, 0x0E, 0xCE, 0xC1, 0xC2, 0xCD, 0x82, 0xC1, +/* 00C0 */ 0x10, 0xC3, 0x11, 0x04, 0xCC, 0x82, 0x0C, 0xCE, 0x81, 0xCE, 0x04, 0xCC, 0x82, 0x0C, 0xCE, 0x81, +/* 00D0 */ 0xCE, 0x81, 0xCC, 0x0A, 0x02, 0xC7, 0x82, 0xC2, 0x13, 0xCA, 0x82, 0xC2, 0x13, 0xCA, 0x04, 0xCE, +/* 00E0 */ 0x82, 0xCD, 0xC1, 0x0B, 0xC6, 0x82, 0xCB, 0x03, 0xC9, 0x82, 0xC8, 0x0B, 0xCC, 0x82, 0xC3, 0x03, +/* 00F0 */ 0xC1, 0x82, 0xCE, 0x0A, 0xC1, 0x82, 0xCE, 0x05, 0xCC, 0x82, 0xC2, 0x09, 0xC3, 0x82, 0xCC, 0x05, +/* 0100 */ 0xCA, 0x82, 0xC5, 0x09, 0xC4, 0x82, 0xCB, 0x05, 0xC9, 0x82, 0x44, 0x0C, 0xCD, 0xC1, 0x84, 0x0D, +/* 0110 */ 0xC3, 0xC4, 0x0D, 0xC5, 0x82, 0x07, 0xC8, 0xCE, 0x82, 0xC7, 0x0B, 0x82, 0xCA, 0x01, 0xC1, 0xC7, +/* 0120 */ 0x1C, 0x81, 0x12, 0x40, 0x23, 0x81, 0xC9, 0x01, 0xC1, 0xC8, 0xC9, 0x81, 0x85, 0x12, 0xCA, 0x82, +/* 0130 */ 0x0E, 0xCA, 0x0E, 0xC1, 0xCB, 0xC1, 0xC8, 0xC2, 0x80, 0xC3, 0x01, 0x0E, 0xC3, 0x13, 0xC5, 0x82, +/* 0140 */ 0xCA, 0xC4, 0xCC, 0x81, 0x41, 0x2A, 0x08, 0xCD, 0xCE, 0xC7, 0x82, 0x0D, 0x82, 0xC3, 0xC4, 0x82, +/* 0150 */ 0xCC, 0xC3, 0x88, 0x82, 0xCB, 0x82, 0xC4, 0x0D, 0x01, 0xC1, 0x82, 0x81, 0xC7, 0x01, 0xC6, 0x82, +/* 0160 */ 0x15, 0x80, 0xC5, 0x13, 0xC1, 0xC7, 0xC1, 0x40, 0x2D, 0x80, 0xC9, 0x0E, 0xC2, 0x82, 0x01, 0xCA, +/* 0170 */ 0x80, 0xC4, 0xCB, 0x81, 0xCB, 0x14, 0xCB, 0x81, 0xCB, 0x14, 0xCB, 0xCB, 0x83, 0x81, 0xC2, 0x01, +/* 0180 */ 0x80, 0xC7, 0xCC, 0xCD, 0x82, 0xC8, 0x03, 0x10, 0x80, 0xC8, 0x01, 0x80, 0xCD, 0xC2, 0xC7, 0xC3, +/* 0190 */ 0xC9, 0x81, 0xCE, 0xC1, 0x0C, 0xC1, 0x81, 0xC1, 0x13, 0xCA, 0xC1, 0x01, 0xCC, 0xCE, 0x81, 0xCE, +/* 01A0 */ 0xCC, 0x14, 0xDE, 0xCB, 0x81, 0xCE, 0xC3, 0x01, 0xCC, 0xC1, 0xC9, 0xC3, 0x0B, 0xCE, 0xC2, 0x81, +/* 01B0 */ 0xCA, 0x01, 0xC5, 0xCB, 0x0C, 0x80, 0xCE, 0xCA, 0xC2, 0x01, 0xC4, 0xCE, 0xCD, 0x01, 0xC3, 0xCE, +/* 01C0 */ 0x84, 0xC2, 0xCA, 0xC6, 0xC1, 0x41, 0x16, 0xCE, 0x80, 0xCE, 0x01, 0xC8, 0x81, 0xCD, 0xCB, 0x0F, +/* 01D0 */ 0xC1, 0xC8, 0xC1, 0xC5, 0xCE, 0x82, 0xC6, 0xC8, 0x81, 0xCA, 0xC3, 0x12, 0xC2, 0x82, 0x81, 0xC8, +/* 01E0 */ 0xC8, 0x85, 0x80, 0xC1, 0x01, 0x0B, 0xC4, 0xCE, 0xC4, 0xC1, 0xCA, 0x80, 0x40, 0x10, 0x80, 0xCA, +/* 01F0 */ 0x01, 0xC5, 0xCC, 0x30, 0x80, 0xCB, 0x46, 0x04, 0x09, 0x02, 0x0B, 0x3F, 0x0E, 0x5A, 0x76, 0x06, +/* 0200 */ 0x85, 0x7C, 0x76, 0x9C, 0x4C, 0x41, 0x4B, 0x0B, 0x3F, 0x0E, 0x43, 0x06, 0x62, 0x97, 0x6A, 0x2F, +/* 0210 */ 0x09, 0xA4, 0x62, 0x99, 0x50, 0x30, 0x19, 0x1B, 0x50, 0x71, 0x29, 0x85, 0x95, 0x2F, 0x33, 0x02, +/* 0220 */ 0x2C, 0x0C, 0x66, 0x1D, 0x85, 0x95, 0x90, 0x06, 0x6A, 0x2A, 0x80, 0x90, 0x60, 0x95, 0x0B, 0x0D, +/* 0230 */ 0x6D, 0x45, 0x90, 0x6C, 0x0C, 0x46, 0x22, 0x02, 0x25, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0x90, 0x62, +/* 0240 */ 0x1B, 0x92, 0x0D, 0x0F, 0x71, 0x3A, 0x62, 0x1B, 0x92, 0xA5, 0x09, 0x3A, 0x62, 0x1B, 0x92, 0x03, +/* 0250 */ 0x22, 0x32, 0x01, 0x62, 0x1B, 0x92, 0x00, 0x0D, 0x50, 0x3A, 0x62, 0x1B, 0x92, 0x9F, 0x3A, 0x62, +/* 0260 */ 0x1B, 0x92, 0x97, 0x50, 0x3A, 0x62, 0x1B, 0x92, 0x19, 0x42, 0xAA, 0x29, 0xB1, 0x0B, 0x0C, 0xA8, +/* 0270 */ 0x25, 0xA9, 0xB2, 0x2F, 0xAB, 0x0A, 0x9E, 0x0B, 0x05, 0x0E, 0x81, 0xA2, 0x7F, 0xA9, 0x0D, 0x02, +/* 0280 */ 0x19, 0x31, 0xA0, 0x6A, 0x37, 0x60, 0x0C, 0x19, 0x49, 0x02, 0x90, 0x6C, 0x0F, 0x6E, 0x6C, 0xA4, +/* 0290 */ 0x90, 0x99, 0x69, 0x80, 0xAB, 0x69, 0x75, 0x31, 0x0C, 0x0A, 0x18, 0x06, 0x94, 0x85, 0x75, 0x1E, +/* 02A0 */ 0x60, 0x91, 0x19, 0x4E, 0x25, 0x05, 0x0F, 0x62, 0x02, 0x4C, 0x62, 0x02, 0x1F, 0x77, 0x6D, 0x02, +/* 02B0 */ 0x1F, 0x77, 0x6D, 0x02, 0x0D, 0x66, 0x2C, 0x1B, 0x6D, 0x7D, 0x0F, 0x66, 0x19, 0xAB, 0xA2, 0x25, +/* 02C0 */ 0x2D, 0x30, 0x25, 0x02, 0x95, 0x0B, 0x0B, 0x32, 0x71, 0x25, 0x02, 0x19, 0x99, 0x7E, 0x7F, 0x85, +/* 02D0 */ 0x75, 0x41, 0xAB, 0x0A, 0x9A, 0x09, 0x37, 0xA9, 0x53, 0x94, 0x02, 0x6D, 0x96, 0x00, 0x50, 0x75, +/* 02E0 */ 0x65, 0x06, 0x66, 0x19, 0x50, 0x75, 0x65, 0x64, 0x05, 0x97, 0x4D, 0x31, 0x0E, 0x0B, 0x42, 0x5C, +/* 02F0 */ 0x94, 0x33, 0xA8, 0x32, 0x01, 0x94, 0x6C, 0x09, 0x0E, 0x30, 0x05, 0x99, 0x0B, 0x0A, 0x0B, 0x19, +/* 0300 */ 0x97, 0xA4, 0x94, 0x8C, 0x1D, 0x64, 0x02, 0x94, 0x64, 0x02, 0x34, 0x22, 0x47, 0x50, 0x71, 0x19, +/* 0310 */ 0x0D, 0x53, 0x65, 0x0E, 0xA8, 0x6C, 0x6B, 0x77, 0x92, 0x05, 0x3A, 0x37, 0x06, 0x22, 0x9F, 0x0B, +/* 0320 */ 0x25, 0x02, 0x3A, 0x28, 0x07, 0x7F, 0x0D, 0x1A, 0x32, 0x02, 0x19, 0x58, 0xA8, 0x22, 0x3C, 0x06, +/* 0330 */ 0x89, 0x53, 0x19, 0x76, 0x0F, 0x71, 0x51, 0x0D, 0x0F, 0x3A, 0x2F, 0x58, 0x20, 0x5E, 0x05, 0x00, +/* 0340 */ 0xA1, 0x06, 0x0B, 0x6A, 0x51, 0x0F, 0x6D, 0x5A, 0x51, 0x88, 0x0B, 0x97, 0x4D, 0x2C, 0x6C, 0x4D, +/* 0350 */ 0x19, 0x0D, 0x89, 0x90, 0x99, 0x7E, 0x0B, 0x3A, 0xAB, 0x7E, 0x0A, 0x6D, 0x02, 0x2C, 0x99, 0x7E, +/* 0360 */ 0x0B, 0x3A, 0x2C, 0x6C, 0x4D, 0x19, 0x0D, 0x89, 0x65, 0x60, 0x91, 0x97, 0x50, 0x75, 0x65, 0x49, +/* 0370 */ 0x0E, 0x0B, 0x0E, 0x66, 0x37, 0x09, 0x56, 0x71, 0x7F, 0x93, 0x9E, 0x04, 0x0B, 0x0E, 0x81, 0xA6, +/* 0380 */ 0x7F, 0xA9, 0x2B, 0x37, 0x49, 0x0E, 0x0B, 0x0E, 0x66, 0x65, 0x4A, 0x4B, 0x68, 0x36, 0x20, 0x1E, +/* 0390 */ 0x09, 0x0E, 0x68, 0x8C, 0x19, 0x9F, 0x78, 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x1D, 0x0B, 0x3A, +/* 03A0 */ 0x94, 0x28, 0x5C, 0x02, 0x50, 0x30, 0x01, 0x41, 0x32, 0x38, 0x29, 0x9F, 0x7C, 0x1D, 0x05, 0x4C, +/* 03B0 */ 0x01, 0x32, 0x0C, 0x1B, 0x84, 0xA5, 0x5C, 0x85, 0x80, 0x90, 0x6C, 0x50, 0x6A, 0x66, 0x37, 0x06, +/* 03C0 */ 0x0D, 0x81, 0x9C, 0x66, 0x01, 0x06, 0x0B, 0x0D, 0x8B, 0x0C, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0xA1, +/* 03D0 */ 0x0C, 0x46, 0x22, 0x02, 0x65, 0x60, 0x95, 0x0B, 0x0D, 0x6D, 0x81, 0x29, 0x6C, 0x55, 0x09, 0x41, +/* 03E0 */ 0x99, 0x0F, 0x2B, 0x29, 0x05, 0x32, 0x75, 0x19, 0x1B, 0x95, 0x62, 0x6C, 0x0E, 0x81, 0x53, 0x1D, +/* 03F0 */ 0x02, 0x6E, 0x62, 0x97, 0x07, 0x02, 0x0F, 0x1D, 0x3B, 0x50, 0x00, 0x3B, 0x22, 0x19, 0x08, 0x66, +/* 0400 */ 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, +/* 0410 */ 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, +/* 0420 */ 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, +/* 0430 */ 0x65, 0x0C, 0x89, 0x6C, 0x8C, 0x19, 0x55, 0xAA, 0x64, 0x02, 0x4A, 0x8C, 0x19, 0x55, 0xAA, 0x64, +/* 0440 */ 0x02, 0x4A, 0x8C, 0x19, 0x55, 0xAA, 0x64, 0x02, 0x0F, 0x91, 0x65, 0x28, 0x20, 0x32, 0x75, 0x65, +/* 0450 */ 0x0B, 0xA4, 0x00, 0x78, 0x00, 0x97, 0x3A, 0x62, 0x1B, 0x50, 0x53, 0x97, 0x3A, 0x62, 0x1B, 0x50, +/* 0460 */ 0x22, 0x00, 0x97, 0x3A, 0x62, 0x1B, 0x50, 0x66, 0x97, 0x3A, 0x62, 0x1B, 0x0F, 0x30, 0xA8, 0x97, +/* 0470 */ 0x3A, 0x62, 0x1B, 0x0F, 0x75, 0x22, 0x97, 0x3A, 0x62, 0x1B, 0xA8, 0x0D, 0x50, 0x03, 0x04, 0x0F, +/* 0480 */ 0x92, 0x00, 0x26, 0x56, 0x7C, 0x58, 0x6A, 0x0A, 0x23, 0x5F, 0x1D, 0x1F, 0x1D, 0x58, 0x40, 0x6A, +/* 0490 */ 0x0A, 0x23, 0x07, 0x1D, 0x26, 0x6D, 0x4D, 0x58, 0x46, 0x92, 0x58, 0x40, 0x40, 0x6A, 0x23, 0x23, +/* 04A0 */ 0x07, 0x58, 0x50, 0x56, 0x0A, 0x58, 0x50, 0x56, 0x05, 0x63, 0x07, 0x1E, 0x42, 0x02, 0x2E, 0x42, +/* 04B0 */ 0x02, 0x2E, 0x05, 0x63, 0x07, 0x1E, 0xB1, 0x0B, 0x0E, 0x0A, 0x19, 0x4B, 0x0B, 0x00, 0x5D, 0x0F, +/* 04C0 */ 0x1A, 0x02, 0xA4, 0x5D, 0x0F, 0x1A, 0x02, 0xA4, 0x25, 0x0D, 0x50, 0x8A, 0x30, 0xAB, 0x0F, 0x71, +/* 04D0 */ 0x34, 0x0F, 0x38, 0x09, 0x30, 0x90, 0x0B, 0x02, 0x6A, 0x2E, 0x02, 0x6A, 0x2E, 0x02, 0x6A, 0x2E, +/* 04E0 */ 0x02, 0x6A, 0x00, 0xA7, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x41, 0x0D, 0x6D, 0x94, 0x0D, 0x3A, 0x1D, +/* 04F0 */ 0x0E, 0x89, 0x26, 0xA8, 0x19, 0x06, 0x6A, 0x31, 0x0F, 0x8B, 0x0F, 0x6B, 0x2D, 0x6E, 0x37, 0x83, +/* 0500 */ 0x0D, 0x0F, 0x98, 0x8F, 0x67, 0x09, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75, 0x1D, 0x0D, 0x3E, +/* 0510 */ 0x00, 0x6C, 0x6A, 0x1D, 0x0D, 0x3E, 0x1D, 0x0D, 0x50, 0x91, 0x97, 0x50, 0x30, 0x94, 0x9F, 0x95, +/* 0520 */ 0x7A, 0x0C, 0x94, 0x6C, 0x0D, 0x49, 0x02, 0x5E, 0x02, 0x5E, 0x02, 0x2E, 0x01, 0x06, 0x08, 0x00, +/* 0530 */ 0x07, 0x3A, 0x37, 0x09, 0x89, 0x00, 0x0C, 0x53, 0x76, 0x08, 0x6D, 0x02, 0x41, 0x26, 0x6D, 0x75, +/* 0540 */ 0x3C, 0x02, 0x46, 0x02, 0x57, 0x0A, 0x2E, 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x2E, +/* 0550 */ 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x1D, 0x61, 0x24, 0x90, 0x3F, 0x20, 0x0C, 0x02, 0x4A, 0x31, 0x0A, +/* 0560 */ 0x62, 0xAB, 0x6A, 0x1E, 0x28, 0x07, 0x3C, 0x2A, 0x01, 0x1E, 0x0C, 0xAF, 0x72, 0x1A, 0x1E, 0x72, +/* 0570 */ 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x65, 0x05, 0x1E, 0x28, 0x05, 0x1E, 0x28, +/* 0580 */ 0x05, 0x3C, 0x0B, 0x46, 0x0E, 0x65, 0x8C, 0x1B, 0x6D, 0x02, 0x94, 0x8C, 0x2A, 0x78, 0x32, 0x95, +/* 0590 */ 0x19, 0x3B, 0x6D, 0x1A, 0x3C, 0x64, 0xA8, 0x3C, 0x60, 0x0A, 0x3E, 0x27, 0x85, 0x78, 0x3A, 0x25, +/* 05A0 */ 0x05, 0x22, 0x00, 0x32, 0x05, 0x25, 0x09, 0x92, 0x28, 0x0A, 0x25, 0x0D, 0x6E, 0x08, 0x89, 0x76, +/* 05B0 */ 0x04, 0x00, 0x05, 0x66, 0x90, 0x3F, 0x3A, 0x6C, 0x4C, 0x19, 0x0B, 0x56, 0x6A, 0x94, 0x85, 0x56, +/* 05C0 */ 0x3A, 0xAB, 0x50, 0x30, 0x0B, 0x0B, 0x0B, 0x0D, 0x50, 0x71, 0x90, 0x09, 0x66, 0x19, 0x99, 0x50, +/* 05D0 */ 0x75, 0x90, 0x0D, 0x89, 0x2F, 0x0F, 0x22, 0x2C, 0x02, 0x6A, 0x2F, 0x33, 0x02, 0x2E, 0x9D, 0x35, +/* 05E0 */ 0x35, 0x35, 0x35, 0x35, 0x35, 0x06, 0x65, 0x8C, 0x00, 0x97, 0xA4, 0x65, 0x8C, 0x00, 0x97, 0xA4, +/* 05F0 */ 0x65, 0x8C, 0x09, 0x8B, 0x0B, 0x02, 0x37, 0x28, 0x7D, 0x6D, 0x30, 0x37, 0x3C, 0x05, 0x6A, 0x05, +/* 0600 */ 0x2E, 0x0F, 0x75, 0x08, 0xA8, 0x04, 0x3A, 0x62, 0x1B, 0x50, 0x1D, 0x97, 0x61, 0x77, 0x0C, 0x20, +/* 0610 */ 0x0B, 0x06, 0x27, 0x64, 0x04, 0x2E, 0x00, 0x0E, 0xA8, 0x65, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E, +/* 0620 */ 0x0C, 0x02, 0x7F, 0xB1, 0x3C, 0xB1, 0x09, 0x0E, 0x0A, 0x19, 0x4B, 0x5A, 0x09, 0x2E, 0x06, 0x1E, +/* 0630 */ 0x0C, 0x22, 0x94, 0x74, 0x3F, 0x0B, 0x7D, 0x35, 0x35, 0x35, 0x35, 0x0E, 0x22, 0x00, 0x40, 0x40, +/* 0640 */ 0x40, 0x40, 0x40, 0x40, 0x40, 0x0F, 0x7B, 0x57, 0x0C, 0x2E, 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E, +/* 0650 */ 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E, 0x09, 0x0E, 0x0C, 0x02, 0x5E, 0x0A, 0x5E, +/* 0660 */ 0x79, 0x20, 0x1E, 0x79, 0x20, 0x1D, 0x42, 0x6A, 0x27, 0x1B, 0x95, 0x62, 0x0B, 0x30, 0x29, 0x02, +/* 0670 */ 0x6E, 0x4A, 0x0B, 0x30, 0x29, 0x09, 0x95, 0x86, 0x99, 0x0A, 0x08, 0x65, 0x74, 0x08, 0x65, 0x85, +/* 0680 */ 0x09, 0x19, 0x9F, 0x02, 0x65, 0x85, 0x09, 0x02, 0x32, 0x0D, 0x95, 0x00, 0x55, 0x01, 0x0B, 0x0E, +/* 0690 */ 0x07, 0x34, 0x0E, 0x21, 0x0D, 0xB2, 0x67, 0x07, 0x4A, 0x31, 0x07, 0x19, 0x0A, 0xA6, 0x37, 0x69, +/* 06A0 */ 0x04, 0x37, 0x50, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x05, 0x00, 0x07, 0x00, 0x09, 0x00, +/* 06B0 */ 0x0A, 0x00, 0x0B, 0x00, 0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x16, 0x00, 0x17, 0x00, 0x1C, 0x00, +/* 06C0 */ 0x1D, 0x00, 0x20, 0x00, 0x21, 0x00, 0x23, 0x00, 0x24, 0x00, 0x27, 0x00, 0x29, 0x00, 0x2A, 0x00, +/* 06D0 */ 0x2C, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x33, 0x00, 0x35, 0x00, 0x37, 0x00, 0x39, 0x00, +/* 06E0 */ 0x3D, 0x00, 0x44, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4E, 0x00, +/* 06F0 */ 0x5C, 0x00, 0x5F, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x6C, 0x00, 0x95, 0x00, 0x97, 0x00, +/* 0700 */ 0x99, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, 0xA0, 0x00, 0xA1, 0x00, 0xA3, 0x00, 0xA6, 0x00, +/* 0710 */ 0xA9, 0x00, 0xAB, 0x00, 0xAC, 0x00, 0xAD, 0x00, 0xAE, 0x00, 0xB0, 0x00, 0xB3, 0x00, 0xB5, 0x00, +/* 0720 */ 0xB7, 0x00, 0xB8, 0x00, 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, 0xC3, 0x00, 0xC6, 0x00, +/* 0730 */ 0xC8, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD2, 0x00, 0xD4, 0x00, 0xD6, 0x00, +/* 0740 */ 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDE, 0x00, 0xE0, 0x00, 0xE3, 0x00, 0xE5, 0x00, +/* 0750 */ 0xE6, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xEC, 0x00, 0xEE, 0x00, 0xF0, 0x00, 0xF2, 0x00, 0xF4, 0x00, +/* 0760 */ 0xF6, 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFD, 0x01, 0x06, 0x01, 0x08, 0x01, 0x0B, 0x01, 0x0D, 0x01, +/* 0770 */ 0x0F, 0x01, 0x12, 0x01, 0x13, 0x01, 0x16, 0x01, 0x18, 0x01, 0x1A, 0x01, 0x1C, 0x01, 0x20, 0x01, +/* 0780 */ 0x22, 0x01, 0x24, 0x01, 0x27, 0x01, 0x29, 0x01, 0x2B, 0x01, 0x2D, 0x01, 0x2E, 0x01, 0x31, 0x01, +/* 0790 */ 0x33, 0x01, 0x35, 0x01, 0x37, 0x01, 0x38, 0x01, 0x3A, 0x01, 0x3D, 0x01, 0x3F, 0x01, 0x40, 0x01, +/* 07A0 */ 0x42, 0x01, 0x44, 0x01, 0x46, 0x01, 0x48, 0x01, 0x4A, 0x01, 0x4C, 0x01, 0x4E, 0x01, 0x50, 0x01, +/* 07B0 */ 0x52, 0x01, 0x55, 0x01, 0x58, 0x01, 0x5A, 0x01, 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01, +/* 07C0 */ 0x64, 0x01, 0x66, 0x01, 0x69, 0x01, 0x6B, 0x01, 0x6D, 0x01, 0x70, 0x01, 0x72, 0x01, 0x74, 0x01, +/* 07D0 */ 0x77, 0x01, 0x79, 0x01, 0x7C, 0x01, 0x7E, 0x01, 0x7F, 0x01, 0x81, 0x01, 0x83, 0x01, 0x85, 0x01, +/* 07E0 */ 0x95, 0x01, 0xCA, 0x01, 0xF8, 0x02, 0x04, 0x02, 0x32, 0x02, 0x37, 0x02, 0x3F, 0x02, 0x49, 0x02, +/* 07F0 */ 0x89, 0x02, 0xD6, 0x03, 0x06, 0x03, 0x15, 0x03, 0x1E, 0x03, 0x31, 0x03, 0x46, 0x03, 0x4F, 0x03, +/* 0800 */ 0x55, 0x03, 0x65, 0x03, 0x82, 0x03, 0x85, 0x03, 0x87, 0x03, 0xBF, 0x03, 0xD3, 0x03, 0xDE, 0x04, +/* 0810 */ 0x0B, 0x04, 0x33, 0x04, 0x43, 0x04, 0x54, 0x04, 0x57, 0x04, 0x62, 0x04, 0x6F, 0x04, 0x8F, 0x04, +/* 0820 */ 0xB0, 0x04, 0xB7, 0x04, 0xB9, 0x04, 0xE0, 0x04, 0xE2, 0x04, 0xE6, 0x04, 0xFA, 0x05, 0x05, 0x05, +/* 0830 */ 0x0D, 0x05, 0x0F, 0x05, 0x19, 0x05, 0x6A, 0x05, 0x70, 0x05, 0x7D, 0x05, 0x87, 0x05, 0x8C, 0x05, +/* 0840 */ 0x95, 0x05, 0x97, 0x05, 0x99, 0x05, 0x9B, 0x05, 0x9D, 0x05, 0xA1, 0x05, 0xAF, 0x05, 0xB1, 0x05, +/* 0850 */ 0xB7, 0x05, 0xB9, 0x05, 0xBB, 0x05, 0xBD, 0x05, 0xC6, 0x05, 0xC9, 0x05, 0xD3, 0x05, 0xE4, 0x05, +/* 0860 */ 0xEB, 0x05, 0xF0, 0x06, 0x08, 0x06, 0x12, 0x06, 0x14, 0x06, 0x16, 0x06, 0x18, 0x06, 0x1F, 0x06, +/* 0870 */ 0x21, 0x06, 0x27, 0x06, 0x2E, +/* char range info */ +0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x28, +/* 0880 */ 0x00, 0x4F, 0x00, 0xA7, 0x01, 0x08, 0x01, 0x8E, 0x01, 0xF6, 0x02, 0x0D, 0x02, 0x59, 0x02, 0xA0, +/* 0890 */ 0x02, 0xD3, 0x02, 0xEB, 0x02, 0xF3, 0x02, 0xFF, 0x03, 0x03, 0x03, 0x45, 0x03, 0x9A, 0x03, 0xC0, +/* 08A0 */ 0x04, 0x01, 0x04, 0x4C, 0x04, 0x8D, 0x04, 0xD3, 0x05, 0x28, 0x05, 0x5D, 0x05, 0xB4, 0x06, 0x0B, +/* 08B0 */ 0x06, 0x12, 0x06, 0x1D, 0x06, 0x52, 0x06, 0x63, 0x06, 0x94, 0x06, 0xC9, 0x07, 0x87, 0x07, 0x8C, +/* 08C0 */ 0x07, 0xD6, 0x08, 0x15, 0x08, 0x5B, 0x08, 0x61, 0x08, 0x84, 0x08, 0xE2, 0x08, 0xFF, 0x09, 0x04, +/* 08D0 */ 0x09, 0x25, 0x09, 0x71, 0x09, 0x87, 0x0A, 0x09, 0x0A, 0x18, 0x0A, 0x1E, 0x0A, 0x58, 0x0A, 0xAB, +/* 08E0 */ 0x0A, 0xF4, 0x0B, 0x45, 0x0B, 0x5E, 0x0B, 0x65, 0x0B, 0xB1, 0x0C, 0x3F, 0x0C, 0x91, 0x0C, 0x9C, +/* 08F0 */ 0x0C, 0xD6, 0x0C, 0xF7, 0x0D, 0x3B, 0x0D, 0x5C, 0x0D, 0x84, 0x0D, 0x95, 0x0D, 0xAB, 0x0D, 0xB1, +/* 0900 */ 0x0D, 0xF7, 0x0E, 0x2A, 0x0E, 0x67, 0x0E, 0x6F, 0x0E, 0x9A, 0x0F, 0x03, 0x0F, 0x22, 0x0F, 0x29, +/* 0910 */ 0x0F, 0x45, 0x0F, 0x89, 0x0F, 0xAF, 0x0F, 0xD8, 0x0F, 0xEF, 0x0F, 0xF8, 0x10, 0x24, 0x10, 0x60, +/* 0920 */ 0x10, 0x88, 0x10, 0xC9, 0x10, 0xFA, 0x11, 0x02, 0x11, 0x40, 0x11, 0xAE, 0x11, 0xEF, 0x11, 0xF6, +/* 0930 */ 0x12, 0x27, 0x12, 0x66, 0x12, 0x75, 0x12, 0xBA, 0x05, 0x00, 0x10, 0x06, 0x61, 0x03, 0x4D, 0xA7, +/* 0940 */ 0xEE, 0x85, 0x75, 0x1E, 0x7E, 0x3C, 0x4C, 0x29, 0x32, 0xEF, 0x0D, 0x50, 0xEF, 0x60, 0x05, 0x1E, +/* 0950 */ 0x0C, 0x1A, 0x1E, 0x28, 0x03, 0x1D, 0xEC, 0x4B, 0x68, 0x36, 0x20, 0x1E, 0x08, 0x98, 0x03, 0x10, +/* 0960 */ 0x0A, 0x00, 0x61, 0x0E, 0x1A, 0x01, 0x3A, 0x25, 0x0D, 0x0F, 0x5C, 0x3A, 0x25, 0x0C, 0x7B, 0x32, +/* 0970 */ 0x7F, 0x0B, 0x0F, 0xAA, 0x9E, 0x19, 0x58, 0x50, 0x19, 0x0D, 0x81, 0x65, 0x2A, 0x19, 0x0C, 0x30, +/* 0980 */ 0x7F, 0x08, 0x95, 0x19, 0x0B, 0xB2, 0x10, 0x0C, 0xD9, 0x32, 0x19, 0x0D, 0x50, 0x01, 0x59, 0x22, +/* 0990 */ 0x19, 0x89, 0x00, 0x5D, 0x20, 0x00, 0x02, 0x3E, 0x41, 0x0D, 0x69, 0x0D, 0x65, 0x0D, 0x69, 0x0D, +/* 09A0 */ 0x65, 0x09, 0x0D, 0x0F, 0x30, 0x0A, 0x0D, 0x0F, 0x30, 0x09, 0x37, 0x0B, 0x1A, 0x77, 0x0F, 0x71, +/* 09B0 */ 0x25, 0x0D, 0x7B, 0x60, 0x02, 0x25, 0x89, 0x19, 0x32, 0x25, 0x02, 0x0F, 0x30, 0x6C, 0x22, 0x19, +/* 09C0 */ 0x26, 0x56, 0x3A, 0x26, 0x56, 0x3A, 0x2C, 0x3F, 0x0D, 0x0F, 0x30, 0x0A, 0x0D, 0x22, 0x87, 0x26, +/* 09D0 */ 0x71, 0xFB, 0x06, 0x25, 0x0C, 0x7B, 0x0B, 0x1A, 0x25, 0x32, 0x19, 0x0D, 0x50, 0x01, 0x10, 0x0C, +/* 09E0 */ 0x1D, 0x52, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x51, 0x82, 0x50, 0xA6, 0x3C, 0xA9, +/* 09F0 */ 0x68, 0x37, 0xA9, 0x22, 0x65, 0x85, 0x81, 0x03, 0x99, 0x0A, 0x5C, 0x31, 0x08, 0x41, 0x02, 0x5D, +/* 0A00 */ 0x50, 0x30, 0x86, 0x32, 0x95, 0x07, 0x02, 0x3C, 0x05, 0x56, 0x96, 0x7F, 0x05, 0x0D, 0x46, 0xAC, +/* 0A10 */ 0x3C, 0x06, 0x60, 0x84, 0x19, 0xE6, 0x32, 0x71, 0x2E, 0x6F, 0x07, 0x65, 0x02, 0x02, 0x41, 0x06, +/* 0A20 */ 0xA4, 0x94, 0x02, 0x63, 0x07, 0x02, 0x99, 0x0D, 0x6D, 0x02, 0x29, 0x2A, 0x56, 0x75, 0x37, 0x08, +/* 0A30 */ 0x9A, 0x80, 0xA1, 0x05, 0x55, 0x0A, 0x86, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x10, +/* 0A40 */ 0x13, 0x29, 0x9D, 0x05, 0x94, 0x06, 0x0D, 0x81, 0x08, 0x00, 0xE6, 0x81, 0x04, 0x62, 0x9F, 0x6A, +/* 0A50 */ 0x19, 0x6C, 0x0D, 0x50, 0x03, 0x4A, 0x6C, 0x89, 0x0B, 0x0E, 0x1A, 0x19, 0x08, 0xA8, 0x2F, 0xE6, +/* 0A60 */ 0x0F, 0x2B, 0x99, 0x6E, 0x03, 0x22, 0x27, 0xE6, 0x0F, 0x2B, 0x99, 0x6E, 0x0C, 0x1A, 0x29, 0x6C, +/* 0A70 */ 0x89, 0x0B, 0x0E, 0x1A, 0x07, 0x53, 0x2C, 0x9F, 0x6A, 0x03, 0x84, 0x00, 0x07, 0x0D, 0x81, 0xA2, +/* 0A80 */ 0x60, 0x05, 0x83, 0x0A, 0xA2, 0x37, 0x06, 0x50, 0x0A, 0x64, 0x95, 0x03, 0x94, 0x02, 0x9E, 0x04, +/* 0A90 */ 0x46, 0x30, 0x94, 0x28, 0x06, 0x07, 0x0F, 0x71, 0xAD, 0x0F, 0x02, 0x2C, 0x05, 0x0F, 0x30, 0x9F, +/* 0AA0 */ 0x01, 0x00, 0x06, 0x50, 0x03, 0x62, 0x6C, 0x32, 0x03, 0x9F, 0x03, 0x9F, 0x02, 0x27, 0x1B, 0x0F, +/* 0AB0 */ 0x80, 0x97, 0x89, 0x8C, 0x2F, 0xE6, 0x22, 0x41, 0x28, 0xA4, 0x29, 0x02, 0x0C, 0x78, 0x1D, 0x6C, +/* 0AC0 */ 0x4B, 0x30, 0x05, 0x00, 0xAB, 0x10, 0x11, 0xD9, 0x54, 0x0D, 0x8B, 0x0C, 0x07, 0x7F, 0x02, 0x9A, +/* 0AD0 */ 0x30, 0x25, 0x09, 0x6D, 0x7D, 0xA4, 0x37, 0x0D, 0x20, 0x19, 0x32, 0x09, 0x37, 0xE8, 0x19, 0x0E, +/* 0AE0 */ 0xA8, 0x94, 0x3F, 0x50, 0x91, 0x6F, 0x02, 0x25, 0x0C, 0x89, 0xA4, 0x00, 0xA1, 0x42, 0xAC, 0x19, +/* 0AF0 */ 0x02, 0x03, 0x94, 0x02, 0x33, 0x6E, 0x77, 0x95, 0x05, 0x62, 0x6C, 0x0D, 0x89, 0x09, 0x6D, 0xA2, +/* 0B00 */ 0x32, 0x01, 0x29, 0x64, 0x05, 0x00, 0x64, 0x60, 0x09, 0x4A, 0x1B, 0x66, 0x19, 0x6F, 0x0F, 0x38, +/* 0B10 */ 0x4A, 0x1B, 0x50, 0x7C, 0x1B, 0x0F, 0x22, 0x02, 0x2C, 0x49, 0x30, 0x0B, 0x42, 0x89, 0x03, 0x2C, +/* 0B20 */ 0x09, 0x56, 0x30, 0x6F, 0x8E, 0x27, 0xE6, 0x0A, 0xFA, 0xE9, 0x19, 0xB0, 0x05, 0x10, 0x05, 0x00, +/* 0B30 */ 0x61, 0x0E, 0x1A, 0x1E, 0x0D, 0x50, 0x03, 0x1E, 0x60, 0x02, 0x1E, 0x28, 0x86, 0x77, 0x50, 0x51, +/* 0B40 */ 0x2A, 0x70, 0x08, 0x95, 0x10, 0x07, 0x27, 0xB1, 0x05, 0x01, 0x41, 0xC9, 0x81, 0x04, 0x1E, 0x60, +/* 0B50 */ 0xEE, 0x6F, 0x02, 0x2E, 0x0D, 0x50, 0xEE, 0x05, 0x66, 0x2F, 0x58, 0x22, 0x72, 0x32, 0xEE, 0x03, +/* 0B60 */ 0xA4, 0x2E, 0x6F, 0x04, 0x2E, 0x08, 0x66, 0x2E, 0x09, 0x0F, 0x7B, 0x57, 0x86, 0x09, 0x6D, 0x02, +/* 0B70 */ 0x2E, 0x08, 0x6D, 0x02, 0x3C, 0x3F, 0x66, 0x62, 0xAB, 0xA4, 0x72, 0x7E, 0x3C, 0x28, 0x8A, 0x6F, +/* 0B80 */ 0x02, 0x72, 0x32, 0x07, 0x2E, 0x9F, 0x38, 0x72, 0x0D, 0xA8, 0x1E, 0x05, 0x6E, 0x1E, 0x08, 0x03, +/* 0B90 */ 0x10, 0x07, 0x41, 0xB1, 0x05, 0x41, 0xC9, 0x0C, 0x71, 0x51, 0x3F, 0x84, 0x62, 0x0D, 0xA8, 0x1E, +/* 0BA0 */ 0x06, 0x3A, 0x72, 0x0E, 0xA8, 0x27, 0x58, 0x22, 0x1E, 0x06, 0x66, 0xC8, 0x2B, 0x2E, 0x85, 0x75, +/* 0BB0 */ 0x1E, 0x6A, 0x1E, 0x32, 0x8A, 0x0D, 0x22, 0x1E, 0x32, 0x8A, 0x6A, 0x1E, 0x6D, 0x0A, 0xC8, 0x7C, +/* 0BC0 */ 0x2E, 0x6F, 0x04, 0x2E, 0x09, 0x89, 0x1E, 0x32, 0x09, 0x5E, 0x02, 0x2E, 0x60, 0x0A, 0x2E, 0x05, +/* 0BD0 */ 0x50, 0x91, 0x2E, 0xA3, 0x7C, 0x70, 0x54, 0x10, 0x0A, 0x37, 0x74, 0x3F, 0x6E, 0x2E, 0x05, 0x0F, +/* 0BE0 */ 0x71, 0x51, 0x5F, 0x03, 0x50, 0x03, 0x04, 0x0B, 0x41, 0xAB, 0x50, 0x60, 0x60, 0x48, 0xFB, 0x56, +/* 0BF0 */ 0x21, 0x02, 0xA3, 0x89, 0x05, 0x02, 0x2F, 0x26, 0x6A, 0x7F, 0x9F, 0x09, 0x55, 0x0A, 0x3B, 0x0D, +/* 0C00 */ 0x0F, 0x02, 0x02, 0x81, 0x03, 0x51, 0x05, 0x19, 0x05, 0x01, 0x10, 0x0C, 0x37, 0x1C, 0x28, 0xDD, +/* 0C10 */ 0x0A, 0x23, 0x32, 0x0C, 0x23, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09, 0x3C, 0x28, 0xDD, 0x1D, +/* 0C20 */ 0x28, 0x05, 0x10, 0x05, 0x4A, 0xB3, 0x4B, 0xDB, 0x04, 0x81, 0x10, 0x09, 0x4A, 0x44, 0x23, 0x18, +/* 0C30 */ 0x3C, 0x0F, 0x56, 0x3C, 0x0F, 0x56, 0x10, 0x06, 0xB3, 0xC1, 0x10, 0x0B, 0xAE, 0x04, 0x06, 0x02, +/* 0C40 */ 0x4A, 0x58, 0x92, 0x2E, 0x0D, 0x6E, 0xA7, 0x03, 0x2E, 0x05, 0x89, 0x1E, 0x09, 0x20, 0x1E, 0x0D, +/* 0C50 */ 0xA8, 0x72, 0x0F, 0x1A, 0x5E, 0x86, 0x55, 0x8A, 0x0C, 0xA8, 0x2E, 0x85, 0x71, 0x4A, 0x31, 0x86, +/* 0C60 */ 0xA5, 0x8A, 0x60, 0xEE, 0x85, 0x71, 0x4A, 0x31, 0x02, 0x3C, 0x3F, 0x22, 0x1E, 0x28, 0x09, 0x1E, +/* 0C70 */ 0x32, 0x06, 0xC8, 0x0F, 0x02, 0x3C, 0x3F, 0x89, 0x41, 0xC9, 0x06, 0x06, 0x10, 0x0D, 0xD9, 0x02, +/* 0C80 */ 0x09, 0xFA, 0x96, 0x3B, 0x9A, 0x78, 0x59, 0x0D, 0x89, 0x0B, 0x32, 0x38, 0x65, 0x6F, 0x04, 0x99, +/* 0C90 */ 0x4C, 0x19, 0x8C, 0x1D, 0x60, 0x0C, 0x65, 0x32, 0x0C, 0x1B, 0x6D, 0x65, 0x6A, 0x2A, 0x0F, 0x02, +/* 0CA0 */ 0x2C, 0x6C, 0x4D, 0x19, 0x09, 0x6D, 0x02, 0x2C, 0x6C, 0x6A, 0x2A, 0x0F, 0x02, 0x94, 0x6A, 0x2A, +/* 0CB0 */ 0x0F, 0x02, 0x94, 0x0D, 0x0F, 0x30, 0x1B, 0x6D, 0x65, 0x8C, 0x1D, 0x60, 0x0C, 0x65, 0x6F, 0x04, +/* 0CC0 */ 0x99, 0x4C, 0x00, 0x6C, 0x0D, 0x89, 0x0B, 0x32, 0x38, 0x5D, 0x9A, 0x78, 0x7F, 0x02, 0x09, 0xFA, +/* 0CD0 */ 0xA6, 0x10, 0x0A, 0xD9, 0x9F, 0x7C, 0xC9, 0x0D, 0x6D, 0x7C, 0x7F, 0xA9, 0x07, 0x94, 0x2A, 0x95, +/* 0CE0 */ 0x4C, 0x41, 0x02, 0x0E, 0x0F, 0x8F, 0x4C, 0x2F, 0x05, 0x04, 0x00, 0x02, 0x4C, 0xBA, 0x4C, 0xBA, +/* 0CF0 */ 0x4C, 0xBA, 0x4C, 0xBA, 0x4C, 0xBA, 0x4C, 0x10, 0x0B, 0x61, 0x3F, 0x88, 0x98, 0xA2, 0x25, 0x39, +/* 0D00 */ 0x56, 0x91, 0x37, 0x0C, 0x89, 0x0B, 0x0D, 0x50, 0x30, 0x37, 0x02, 0x0C, 0x8E, 0x19, 0x0D, 0x6D, +/* 0D10 */ 0x02, 0x59, 0x01, 0x2A, 0x5C, 0x57, 0x02, 0x2E, 0xF2, 0x7F, 0x3F, 0xA4, 0x00, 0xC9, 0x50, 0x30, +/* 0D20 */ 0x1D, 0xA1, 0x0D, 0x50, 0x91, 0x51, 0x28, 0x78, 0x57, 0x05, 0x25, 0x2A, 0x71, 0x51, 0x6F, 0x0E, +/* 0D30 */ 0x18, 0x05, 0x65, 0xA9, 0xA4, 0x65, 0xA9, 0x6B, 0x10, 0x0B, 0x61, 0x3F, 0x88, 0x81, 0xB4, 0x00, +/* 0D40 */ 0x5D, 0x0D, 0x46, 0x1A, 0x94, 0x3F, 0x89, 0x0B, 0x60, 0x81, 0x25, 0x06, 0x07, 0x2A, 0x0F, 0x02, +/* 0D50 */ 0x2E, 0x06, 0x50, 0xAA, 0xC9, 0x0D, 0x20, 0x3C, 0x49, 0x0F, 0x87, 0x7F, 0x08, 0x6A, 0x05, 0x7F, +/* 0D60 */ 0x3F, 0x0B, 0x0D, 0x4D, 0x51, 0x9F, 0x71, 0x00, 0xA7, 0xEE, 0x03, 0x4D, 0x90, 0x6C, 0x0C, 0x08, +/* 0D70 */ 0x2A, 0x7C, 0x65, 0x0C, 0x89, 0x0B, 0x0D, 0x6D, 0x38, 0x65, 0xA3, 0x56, 0xAC, 0x25, 0x02, 0x08, +/* 0D80 */ 0x63, 0x98, 0x5B, 0x10, 0x0C, 0x9D, 0x02, 0x86, 0x1B, 0xB2, 0x05, 0x72, 0x4C, 0x62, 0x64, 0x02, +/* 0D90 */ 0x2E, 0x0D, 0x20, 0xC8, 0x71, 0x2E, 0x09, 0x89, 0x72, 0x0E, 0x53, 0x60, 0x05, 0x37, 0x6F, 0x8D, +/* 0DA0 */ 0x32, 0x05, 0x37, 0xF0, 0x19, 0x50, 0x71, 0x65, 0x02, 0x0F, 0x6E, 0x02, 0x50, 0x71, 0x65, 0x64, +/* 0DB0 */ 0x46, 0x89, 0x94, 0x64, 0x46, 0x89, 0x94, 0x05, 0x18, 0x28, 0x30, 0x0A, 0x00, 0xC9, 0x50, 0x71, +/* 0DC0 */ 0xC8, 0x71, 0xC8, 0x71, 0x10, 0x0C, 0x00, 0x61, 0x60, 0x46, 0x71, 0x37, 0x60, 0x56, 0x02, 0x37, +/* 0DD0 */ 0x0C, 0x89, 0x18, 0x25, 0xE8, 0x1E, 0xE8, 0x1E, 0x60, 0xA0, 0x8B, 0x96, 0x25, 0x60, 0x46, 0x45, +/* 0DE0 */ 0x37, 0x60, 0xA0, 0x32, 0x75, 0x5D, 0x04, 0x03, 0x19, 0x02, 0x0F, 0x89, 0x1E, 0x28, 0xAA, 0x57, +/* 0DF0 */ 0x86, 0x0C, 0x89, 0x94, 0x3F, 0x0D, 0x02, 0x19, 0x67, 0x0A, 0x90, 0x3F, 0x6A, 0x33, 0x5C, 0x90, +/* 0E00 */ 0x6C, 0x0C, 0x56, 0x71, 0x7F, 0x06, 0x0B, 0x0E, 0x81, 0xB4, 0x10, 0x0D, 0x61, 0xE6, 0x0A, 0x0E, +/* 0E10 */ 0x81, 0xB4, 0x7F, 0x2D, 0x21, 0x6F, 0x0E, 0x0B, 0x0C, 0x45, 0x59, 0x32, 0x8E, 0x00, 0x6C, 0x25, +/* 0E20 */ 0x06, 0x66, 0x2E, 0x8C, 0x03, 0x0B, 0x8B, 0x09, 0x01, 0x37, 0x0E, 0x22, 0x42, 0x30, 0x37, 0x50, +/* 0E30 */ 0x6A, 0x0D, 0x4C, 0x6C, 0x0F, 0x89, 0x03, 0x6C, 0x32, 0x0C, 0x90, 0x6C, 0x6A, 0x1D, 0x8C, 0x65, +/* 0E40 */ 0x32, 0x0C, 0x1B, 0x6D, 0x65, 0x0C, 0x89, 0x1D, 0xF0, 0x65, 0x64, 0x04, 0x99, 0x50, 0x75, 0x94, +/* 0E50 */ 0x6C, 0x0E, 0x89, 0x0B, 0x0E, 0x66, 0x37, 0x49, 0x0F, 0xA4, 0x3B, 0x0A, 0x0E, 0x81, 0xA6, 0x10, +/* 0E60 */ 0x0A, 0x61, 0x0C, 0x56, 0x22, 0x37, 0x0C, 0x56, 0x22, 0x37, 0x08, 0x18, 0x50, 0x30, 0xC8, 0x7C, +/* 0E70 */ 0x2E, 0x09, 0x6D, 0x02, 0x1D, 0xA1, 0x0E, 0x20, 0x5E, 0x05, 0x2E, 0x8C, 0x00, 0xA7, 0x08, 0x2E, +/* 0E80 */ 0x08, 0x66, 0x2E, 0x32, 0x0C, 0x5E, 0x06, 0x2E, 0x28, 0x38, 0xA7, 0x0A, 0x65, 0xEA, 0x04, 0x0A, +/* 0E90 */ 0x81, 0x1D, 0x72, 0x03, 0x10, 0x0D, 0xD9, 0x06, 0x0B, 0x9E, 0x5F, 0x7F, 0xDE, 0xA8, 0x37, 0x64, +/* 0EA0 */ 0xA0, 0x0E, 0x66, 0x65, 0x0B, 0x22, 0x00, 0x99, 0x4C, 0x19, 0xE8, 0x1D, 0x4C, 0x00, 0xFB, 0x38, +/* 0EB0 */ 0x99, 0x6D, 0x02, 0x65, 0xF9, 0x0E, 0x07, 0x0D, 0x0F, 0x2B, 0x00, 0x5D, 0x9A, 0x07, 0xA1, 0x0A, +/* 0EC0 */ 0x22, 0x6D, 0x75, 0x37, 0x28, 0x0C, 0x00, 0x9B, 0x7E, 0x62, 0x99, 0x50, 0x71, 0x1D, 0x8C, 0x94, +/* 0ED0 */ 0x6F, 0x04, 0x1D, 0x09, 0x3A, 0xAB, 0x0F, 0x53, 0x6C, 0x0D, 0x89, 0x65, 0x0D, 0x6D, 0xA0, 0x32, +/* 0EE0 */ 0x75, 0x47, 0x32, 0x46, 0x5A, 0x37, 0x54, 0x88, 0x0F, 0xA0, 0x05, 0x10, 0x0C, 0xD9, 0x06, 0x0B, +/* 0EF0 */ 0x0E, 0x98, 0xA2, 0xA1, 0x7A, 0x22, 0x02, 0x90, 0x2A, 0x81, 0x60, 0x30, 0x65, 0x02, 0x6A, 0x00, +/* 0F00 */ 0x9F, 0x78, 0x94, 0x49, 0x05, 0x19, 0x67, 0x08, 0x94, 0x64, 0x04, 0x19, 0x02, 0x4D, 0x90, 0x6F, +/* 0F10 */ 0x05, 0x00, 0x6C, 0x6A, 0x90, 0x99, 0x4D, 0x9F, 0xAF, 0x94, 0x0D, 0x50, 0x30, 0x33, 0x75, 0x47, +/* 0F20 */ 0x32, 0x89, 0xA4, 0x5D, 0x0B, 0x8B, 0x08, 0x0A, 0x66, 0x51, 0xF9, 0x0C, 0x1D, 0xA1, 0x0D, 0x50, +/* 0F30 */ 0x71, 0x3C, 0x06, 0x42, 0x21, 0x02, 0x09, 0x42, 0x75, 0x19, 0x76, 0x81, 0x05, 0x51, 0x63, 0x5F, +/* 0F40 */ 0x1E, 0x02, 0x10, 0x06, 0x4F, 0x1C, 0xC1, 0x74, 0xC1, 0x10, 0x06, 0x4F, 0x1C, 0xC1, 0x4A, 0x74, +/* 0F50 */ 0x4B, 0xDB, 0x04, 0x81, 0x10, 0x0B, 0xEC, 0x9D, 0xAB, 0xEF, 0xB0, 0x0F, 0x38, 0x3C, 0x06, 0x0D, +/* 0F60 */ 0x0F, 0xA4, 0x37, 0x4E, 0x0D, 0x6D, 0x30, 0x05, 0x1D, 0xAB, 0x32, 0x20, 0x04, 0x7F, 0x49, 0xA6, +/* 0F70 */ 0x51, 0x49, 0x8F, 0x4A, 0xAB, 0x32, 0x20, 0x04, 0x3C, 0x4E, 0x42, 0x30, 0x06, 0x3C, 0xD7, 0x0D, +/* 0F80 */ 0x0F, 0xA4, 0x2E, 0xB0, 0x0F, 0x38, 0x70, 0x05, 0x06, 0x10, 0x0B, 0x4A, 0x4F, 0x1C, 0x23, 0x18, +/* 0F90 */ 0xFF, 0x46, 0x1A, 0x27, 0xAE, 0x23, 0x18, 0xFF, 0x46, 0x1A, 0x10, 0x0B, 0xB1, 0x61, 0x99, 0xEF, +/* 0FA0 */ 0x19, 0x0B, 0x81, 0x73, 0xA7, 0x95, 0xA2, 0xC9, 0x0A, 0x50, 0x89, 0xB4, 0x3C, 0x02, 0x09, 0x42, +/* 0FB0 */ 0x7C, 0x51, 0x54, 0x32, 0x09, 0x51, 0x4E, 0x32, 0x09, 0x7F, 0x02, 0x55, 0x4C, 0x19, 0x97, 0xDE, +/* 0FC0 */ 0xB4, 0x76, 0x95, 0x5B, 0x3C, 0x0B, 0x95, 0x73, 0x62, 0xAB, 0x73, 0x10, 0x0B, 0x19, 0x61, 0x93, +/* 0FD0 */ 0x9E, 0x5F, 0xA1, 0xDE, 0x6E, 0x65, 0x49, 0x0C, 0x33, 0xAA, 0x19, 0xAB, 0x0C, 0x8D, 0xFB, 0x78, +/* 0FE0 */ 0x2F, 0x58, 0x66, 0x51, 0x09, 0x6A, 0x19, 0xA1, 0x0B, 0x6D, 0x5A, 0x7F, 0x9F, 0x80, 0x51, 0x60, +/* 0FF0 */ 0x0A, 0x1E, 0x0D, 0x6E, 0xEC, 0x3F, 0x98, 0x03, 0xC8, 0x30, 0xC8, 0x0F, 0x8A, 0x08, 0x98, 0x03, +/* 1000 */ 0x10, 0x16, 0xD9, 0xE6, 0x09, 0x0C, 0x9E, 0x0C, 0x09, 0x48, 0x04, 0x0D, 0x69, 0x68, 0x2C, 0x64, +/* 1010 */ 0x95, 0x0C, 0x0B, 0x0B, 0x42, 0x2B, 0x27, 0x3F, 0x6A, 0x04, 0x04, 0x09, 0x0A, 0x09, 0x05, 0x03, +/* 1020 */ 0x0A, 0x50, 0x71, 0x27, 0x67, 0x08, 0x77, 0x6D, 0x22, 0x02, 0xA5, 0x38, 0x2F, 0xE8, 0x9F, 0x6D, +/* 1030 */ 0x1A, 0x00, 0x60, 0x07, 0x41, 0x67, 0x02, 0x01, 0x32, 0x9C, 0x0D, 0x1A, 0x00, 0x06, 0x0F, 0x30, +/* 1040 */ 0x00, 0x2A, 0x0C, 0x24, 0x0C, 0x1A, 0x99, 0x6D, 0x41, 0x0C, 0xA8, 0x9F, 0x0B, 0x19, 0x0C, 0x1A, +/* 1050 */ 0x00, 0x02, 0x6D, 0x02, 0x1D, 0x32, 0x06, 0xFB, 0x0A, 0x19, 0x0C, 0x1A, 0x00, 0x02, 0x3A, 0x1D, +/* 1060 */ 0x32, 0x05, 0xFB, 0x0A, 0x19, 0x0C, 0x1A, 0x99, 0x6D, 0x41, 0x32, 0x05, 0x9F, 0x0A, 0x19, 0x0C, +/* 1070 */ 0x1A, 0x00, 0x05, 0x0F, 0x30, 0x41, 0x0C, 0x6E, 0x06, 0x22, 0x6C, 0x32, 0x06, 0x77, 0x0F, 0x80, +/* 1080 */ 0x1B, 0x92, 0x02, 0x6D, 0x7D, 0x30, 0x95, 0x60, 0x38, 0x41, 0x06, 0x50, 0x38, 0xFB, 0x0F, 0x30, +/* 1090 */ 0x02, 0x42, 0x2B, 0x41, 0x6C, 0x0E, 0xA8, 0x19, 0x08, 0x63, 0x0B, 0x02, 0x97, 0x88, 0x0C, 0x04, +/* 10A0 */ 0x4A, 0x64, 0xEF, 0x0B, 0x6D, 0xA6, 0x41, 0x6C, 0x03, 0x2C, 0x6C, 0x7A, 0xA0, 0x0B, 0x7D, 0x50, +/* 10B0 */ 0x01, 0x2C, 0x3F, 0x0E, 0x56, 0xA4, 0x65, 0xD7, 0x0A, 0x63, 0x0F, 0x98, 0x0A, 0x9C, 0x10, 0x0D, +/* 10C0 */ 0x00, 0xD9, 0xE0, 0x10, 0x0D, 0xE7, 0x50, 0x89, 0xA0, 0x73, 0x58, 0x56, 0x89, 0x48, 0x0A, 0x6A, +/* 10D0 */ 0x0B, 0x42, 0x38, 0x00, 0x1F, 0x60, 0x78, 0x26, 0x7B, 0x77, 0x66, 0x26, 0x7B, 0x04, 0xF2, 0x26, +/* 10E0 */ 0x56, 0x30, 0x02, 0x2C, 0x1B, 0x46, 0x22, 0x06, 0x58, 0x6A, 0x0B, 0x0D, 0x6D, 0x8E, 0x00, 0x1F, +/* 10F0 */ 0x08, 0x0F, 0x53, 0x1F, 0x85, 0x81, 0x00, 0x1F, 0x85, 0x95, 0x00, 0x1F, 0x07, 0x6A, 0x26, 0x20, +/* 1100 */ 0x0B, 0x0D, 0x6D, 0x71, 0x26, 0x56, 0xA8, 0x2C, 0x1B, 0x6D, 0x89, 0x0C, 0x8F, 0x10, 0x0D, 0x61, +/* 1110 */ 0xE6, 0x0A, 0xFA, 0xE9, 0x65, 0x2A, 0x46, 0x8E, 0x00, 0x26, 0x89, 0x0B, 0x0C, 0x53, 0x31, 0x0D, +/* 1120 */ 0x02, 0x19, 0x82, 0x58, 0x6B, 0x2F, 0x85, 0x95, 0x00, 0xA7, 0x0C, 0x36, 0x20, 0x00, 0xA7, 0x0C, +/* 1130 */ 0x72, 0x0F, 0x89, 0x1E, 0x28, 0x78, 0x5E, 0x0D, 0x02, 0x19, 0x02, 0x96, 0x19, 0x26, 0x89, 0x0B, +/* 1140 */ 0x28, 0x45, 0x65, 0xAD, 0x46, 0x30, 0x02, 0x25, 0x05, 0x0A, 0xFA, 0xE9, 0x10, 0x0E, 0xE7, 0x0F, +/* 1150 */ 0x6D, 0x98, 0x0A, 0x9C, 0x58, 0x56, 0x89, 0x48, 0x0A, 0x6A, 0x0B, 0x42, 0x91, 0x00, 0x1F, 0x08, +/* 1160 */ 0x6A, 0x26, 0x7B, 0x19, 0x0E, 0x3A, 0x1F, 0x77, 0x50, 0x71, 0x1F, 0x9F, 0x7C, 0x1F, 0x00, 0x64, +/* 1170 */ 0x08, 0x1F, 0x00, 0x64, 0x07, 0x1F, 0x9F, 0x2B, 0x1F, 0x77, 0x0F, 0x1A, 0x1F, 0x01, 0x0E, 0x3A, +/* 1180 */ 0x1F, 0x09, 0x4D, 0x62, 0x1B, 0x6A, 0x0B, 0x42, 0x91, 0x26, 0x46, 0x22, 0x8D, 0x26, 0x50, 0x22, +/* 1190 */ 0x0A, 0x05, 0x10, 0x0B, 0xE7, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0xE7, 0x0F, 0x56, 0x71, 0x58, 0x46, +/* 11A0 */ 0x66, 0x58, 0x6A, 0x23, 0x23, 0x01, 0x58, 0x40, 0x40, 0x46, 0x6E, 0x58, 0x46, 0x6E, 0x58, 0x6A, +/* 11B0 */ 0x0A, 0x23, 0x05, 0x00, 0x58, 0x40, 0x40, 0x0F, 0x7B, 0x57, 0x02, 0x10, 0x0E, 0xD9, 0x99, 0x08, +/* 11C0 */ 0x88, 0x98, 0xB4, 0x25, 0xA9, 0xA8, 0x65, 0x08, 0x6D, 0x30, 0x0B, 0x0D, 0xA8, 0x31, 0x0D, 0x03, +/* 11D0 */ 0x19, 0x99, 0x05, 0x2C, 0x1B, 0x50, 0x71, 0x2E, 0x0E, 0x89, 0x00, 0xA7, 0x0C, 0x00, 0xFB, 0x66, +/* 11E0 */ 0x29, 0x99, 0x6A, 0x3F, 0x50, 0x66, 0x27, 0xE6, 0x6A, 0x00, 0x97, 0x0A, 0x0D, 0x66, 0x29, 0x99, +/* 11F0 */ 0x50, 0x30, 0x19, 0x3F, 0x66, 0x2C, 0x85, 0x81, 0x19, 0x3F, 0x66, 0x90, 0x0C, 0x0F, 0x7B, 0x3F, +/* 1200 */ 0x66, 0x90, 0x64, 0x0A, 0x1D, 0x08, 0x66, 0x2C, 0x6C, 0x0D, 0x6D, 0xA0, 0x33, 0x5C, 0x90, 0x39, +/* 1210 */ 0x50, 0x56, 0x5A, 0x65, 0xD7, 0x0B, 0x9E, 0x0C, 0x8F, 0x10, 0x0E, 0x2C, 0x9D, 0xBB, 0xBB, 0xBB, +/* 1220 */ 0x62, 0x1B, 0x69, 0x7B, 0x4A, 0x1B, 0x69, 0x7B, 0x4A, 0x1B, 0x6A, 0x0A, 0x23, 0x42, 0x02, 0x1F, +/* 1230 */ 0x77, 0x6D, 0x02, 0xBB, 0xBB, 0xBB, 0x10, 0x06, 0xE7, 0xF3, 0x02, 0x10, 0x07, 0x00, 0x61, 0xD3, +/* 1240 */ 0x0B, 0x2E, 0xD3, 0x0B, 0x2E, 0xD3, 0x0A, 0x4A, 0x31, 0xEE, 0x0A, 0x50, 0x71, 0x19, 0xA1, 0x28, +/* 1250 */ 0x81, 0x51, 0x85, 0x81, 0x02, 0x2F, 0x58, 0x75, 0x01, 0x1E, 0x02, 0x01, 0x10, 0x0E, 0xE7, 0x6D, +/* 1260 */ 0x02, 0x1D, 0x6F, 0x08, 0x1F, 0x01, 0xF2, 0x1F, 0x55, 0x78, 0x26, 0x7B, 0x04, 0x0F, 0x53, 0x26, +/* 1270 */ 0x7B, 0x0D, 0x50, 0x45, 0x2C, 0x1B, 0x6D, 0x82, 0x6B, 0x77, 0x0F, 0x1A, 0x0E, 0x92, 0x58, 0x6A, +/* 1280 */ 0xA4, 0x00, 0x58, 0x6D, 0x49, 0x45, 0x58, 0x6D, 0x02, 0x09, 0x0F, 0xA8, 0x58, 0x6D, 0x02, 0x02, +/* 1290 */ 0x6D, 0x91, 0x00, 0x26, 0x7B, 0x08, 0x4D, 0x26, 0x7B, 0x01, 0x32, 0x5C, 0x1F, 0x64, 0x0C, 0x26, +/* 12A0 */ 0x7B, 0x19, 0x0D, 0xA4, 0x1F, 0x00, 0x49, 0x38, 0x10, 0x0B, 0xE7, 0x40, 0x40, 0x40, 0x40, 0x40, +/* 12B0 */ 0x40, 0x0F, 0x7B, 0x57, 0x0B, 0x23, 0x23, 0x09, 0x58, 0x46, 0x6A, 0x58, 0x56, 0x53, 0x10, 0x11, +/* 12C0 */ 0x61, 0x99, 0x0F, 0x6A, 0x1D, 0x64, 0x7C, 0x29, 0x67, 0x95, 0x1B, 0x50, 0xA8, 0x29, 0x49, 0x7B, +/* 12D0 */ 0x00, 0x33, 0x75, 0x29, 0x06, 0x89, 0x1A, 0x19, 0x89, 0x92, 0x27, 0x3F, 0x0F, 0x30, 0x6E, 0x02, +/* 12E0 */ 0x50, 0xE8, 0x62, 0x9F, 0x09, 0x92, 0x05, 0x0F, 0x75, 0x22, 0x27, 0x2A, 0x09, 0x0C, 0x81, 0x9F, +/* 12F0 */ 0x06, 0x89, 0x27, 0x1B, 0x0F, 0x75, 0x55, 0xAD, 0x0C, 0x6F, 0x29, 0x28, 0x09, 0x06, 0x1A, 0x0D, +/* 1300 */ 0x75, 0x06, 0x3A, 0x62, 0x0D, 0x50, 0xB4, 0x0F, 0x7C, 0x0F, 0x2B, 0x49, 0x02, 0x62, 0x0E, 0x0F, +/* 1310 */ 0x80, 0x0E, 0x81, 0x50, 0x03, 0x05, 0x66, 0x62, 0x50, 0x80, 0x7A, 0x97, 0x0F, 0x1A, 0x4A, 0x85, +/* 1320 */ 0x7C, 0x9F, 0x30, 0x99, 0x50, 0x71, 0x4A, 0x02, 0x0F, 0x6E, 0x49, 0x09, 0x99, 0xA4, 0x27, 0x99, +/* 1330 */ 0xA4, 0x6C, 0x05, 0x05, 0x05, 0x02, 0x00, 0x02, 0x50, 0x7C, 0x1D, 0xE6, 0xA4, 0x4A, 0x02, 0x7E, +/* 1340 */ 0x10, 0x0E, 0xE7, 0x6D, 0xCD, 0x50, 0x01, 0x62, 0x1B, 0xE5, 0xA6, 0x22, 0x03, 0x3A, 0xB7, 0x10, +/* 1350 */ 0x0F, 0x00, 0xD9, 0xC6, 0xB6, 0x10, 0x0D, 0xE7, 0x6D, 0x89, 0x0B, 0x73, 0x58, 0x56, 0x89, 0x8D, +/* 1360 */ 0x26, 0x20, 0x0B, 0x42, 0x38, 0x26, 0x7B, 0x01, 0x0C, 0x0F, 0x6E, 0x1F, 0x05, 0x4D, 0x1F, 0x04, +/* 1370 */ 0x4D, 0x1F, 0x64, 0x09, 0x26, 0x50, 0x02, 0x01, 0x04, 0x32, 0x78, 0x26, 0x46, 0x6A, 0x2C, 0x1B, +/* 1380 */ 0x50, 0x56, 0x87, 0x26, 0x20, 0x0A, 0x09, 0x07, 0x02, 0x00, 0x58, 0x40, 0x40, 0x6D, 0x02, 0x10, +/* 1390 */ 0x0F, 0x00, 0xD9, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0xA1, 0x0C, 0x46, 0x22, 0x02, 0x65, 0x28, 0x95, +/* 13A0 */ 0x0B, 0x0D, 0x6D, 0x43, 0x06, 0x2F, 0xE6, 0x6A, 0x2F, 0x09, 0xA4, 0x62, 0x99, 0x50, 0x30, 0x19, +/* 13B0 */ 0x1B, 0x0F, 0x1A, 0x29, 0x85, 0x95, 0x2F, 0x33, 0x02, 0x2C, 0x0C, 0x66, 0x19, 0x6C, 0x6A, 0x90, +/* 13C0 */ 0x06, 0x6A, 0x2A, 0x0E, 0x03, 0x94, 0x60, 0x95, 0x0B, 0x0D, 0x89, 0x48, 0x02, 0x0C, 0x56, 0x7C, +/* 13D0 */ 0x03, 0x25, 0x06, 0x0C, 0x9A, 0x81, 0x06, 0x3C, 0x02, 0x06, 0x33, 0x91, 0x51, 0x9F, 0x05, 0x2E, +/* 13E0 */ 0x3F, 0x08, 0x10, 0x0D, 0xE7, 0x6D, 0x89, 0x0C, 0x5B, 0x58, 0x56, 0xA4, 0x2C, 0x1B, 0x6A, 0x0B, +/* 13F0 */ 0x32, 0x7B, 0x1F, 0x0A, 0x50, 0x80, 0x1F, 0x05, 0x4D, 0x1F, 0x6F, 0x09, 0x26, 0x7B, 0x03, 0x0D, +/* 1400 */ 0x50, 0x71, 0x26, 0x46, 0x6A, 0x00, 0x26, 0x56, 0x75, 0x01, 0x2C, 0x1B, 0x6A, 0x0D, 0x6D, 0x02, +/* 1410 */ 0x58, 0x6D, 0x02, 0x03, 0x4D, 0x00, 0x26, 0x7B, 0x28, 0x5C, 0x26, 0x7B, 0x04, 0x6A, 0x19, 0x1F, +/* 1420 */ 0x28, 0x78, 0x00, 0x1F, 0x67, 0x0C, 0x26, 0x7B, 0x19, 0x60, 0x71, 0x10, 0x0C, 0xD9, 0x07, 0x88, +/* 1430 */ 0x81, 0x0A, 0x05, 0xA1, 0x0D, 0x56, 0x30, 0x02, 0x65, 0x28, 0x95, 0x0B, 0x0C, 0x89, 0x03, 0x94, +/* 1440 */ 0x02, 0x6D, 0x45, 0x19, 0x02, 0x5F, 0x47, 0x50, 0x30, 0x72, 0x0F, 0x6D, 0x73, 0x57, 0x95, 0x09, +/* 1450 */ 0x04, 0x7F, 0xAD, 0x46, 0x0C, 0x02, 0x2F, 0xAB, 0xDE, 0x91, 0x3C, 0x02, 0x4B, 0x4D, 0x27, 0x31, +/* 1460 */ 0x0D, 0x72, 0x0F, 0x89, 0x65, 0x09, 0x0B, 0x03, 0x1D, 0x06, 0x6A, 0x94, 0x08, 0x6D, 0xA0, 0x33, +/* 1470 */ 0x71, 0x94, 0x02, 0x60, 0x46, 0x7C, 0x25, 0x05, 0x0A, 0xFA, 0x0D, 0x8F, 0x10, 0x0C, 0x61, 0x60, +/* 1480 */ 0x46, 0x6A, 0x94, 0x60, 0x56, 0xA8, 0x94, 0x09, 0x23, 0x28, 0x95, 0x23, 0x5F, 0xA1, 0x6D, 0xF4, +/* 1490 */ 0x01, 0x6D, 0xF4, 0x85, 0x30, 0x10, 0x0E, 0x00, 0x61, 0x0E, 0x89, 0xD4, 0x10, 0x0D, 0x00, 0x9D, +/* 14A0 */ 0xA7, 0x0C, 0x1D, 0x6C, 0x6A, 0x90, 0x0D, 0x6D, 0xE6, 0x4C, 0x55, 0x5C, 0x3F, 0x66, 0x90, 0x05, +/* 14B0 */ 0xA4, 0x1B, 0x89, 0x94, 0x85, 0x75, 0x1D, 0x0D, 0x20, 0x65, 0xF0, 0x19, 0x85, 0x7C, 0x94, 0x9F, +/* 14C0 */ 0xAA, 0x67, 0x8D, 0x31, 0x04, 0x00, 0x07, 0x89, 0x37, 0x85, 0x7C, 0x77, 0x20, 0x25, 0x0B, 0x92, +/* 14D0 */ 0x0D, 0x6E, 0x65, 0x9F, 0x38, 0x66, 0x1D, 0x31, 0x05, 0x89, 0x3C, 0x32, 0x28, 0x0A, 0x3C, 0x7A, +/* 14E0 */ 0x7C, 0x25, 0x3F, 0x50, 0x66, 0xC9, 0x50, 0x89, 0x10, 0x13, 0x61, 0x0B, 0x6D, 0x1D, 0x60, 0x71, +/* 14F0 */ 0x19, 0x49, 0x04, 0x2F, 0x08, 0x3A, 0x19, 0x32, 0x7C, 0x3F, 0x3A, 0x2F, 0x6F, 0x8D, 0x85, 0x53, +/* 1500 */ 0xFB, 0x0E, 0x27, 0x67, 0x05, 0x99, 0x0F, 0x6A, 0x19, 0x28, 0x0C, 0x27, 0x02, 0xA4, 0x00, 0x05, +/* 1510 */ 0x0F, 0x30, 0x95, 0x19, 0x60, 0x0A, 0x4A, 0x50, 0x80, 0x08, 0x95, 0x08, 0x0F, 0xAA, 0x32, 0x07, +/* 1520 */ 0x4A, 0x0D, 0x92, 0x0A, 0x30, 0x06, 0x50, 0x03, 0x85, 0x71, 0x41, 0x1B, 0x20, 0x00, 0x0C, 0x0F, +/* 1530 */ 0x5F, 0x0F, 0x71, 0x03, 0x66, 0x4A, 0x08, 0x22, 0x00, 0x0E, 0x0F, 0x5B, 0x0F, 0x7C, 0x05, 0x3A, +/* 1540 */ 0x4A, 0x06, 0x89, 0x85, 0x06, 0x00, 0x0F, 0x75, 0x07, 0x22, 0x62, 0x67, 0x05, 0x0F, 0x5C, 0xFD, +/* 1550 */ 0x08, 0x20, 0x62, 0x02, 0x6D, 0x55, 0x01, 0x77, 0x81, 0x0A, 0x53, 0x62, 0x32, 0x0C, 0x95, 0x00, +/* 1560 */ 0x9F, 0x60, 0x06, 0x29, 0x33, 0x30, 0x19, 0x6F, 0x1A, 0x27, 0x1B, 0x0F, 0x4D, 0x97, 0x46, 0x02, +/* 1570 */ 0x62, 0x9F, 0x6E, 0x00, 0x02, 0x46, 0x10, 0x0D, 0x61, 0x55, 0x7C, 0x1D, 0x0B, 0x66, 0x2C, 0x6C, +/* 1580 */ 0xF2, 0x00, 0x02, 0x4D, 0x90, 0x9F, 0x78, 0x9F, 0x5C, 0x90, 0x6C, 0x32, 0x09, 0x01, 0x32, 0x21, +/* 1590 */ 0x08, 0x89, 0x64, 0x02, 0xA1, 0x42, 0xA8, 0x7F, 0x9F, 0x84, 0x2F, 0x02, 0x0F, 0x4D, 0x3C, 0x64, +/* 15A0 */ 0x7B, 0xA1, 0x9A, 0x09, 0x37, 0x3F, 0x89, 0x08, 0x6D, 0x02, 0x25, 0x32, 0x09, 0x85, 0x75, 0x37, +/* 15B0 */ 0x06, 0x66, 0x77, 0x6D, 0x02, 0x65, 0x0D, 0x22, 0x19, 0x67, 0x09, 0x94, 0x6F, 0x07, 0x1D, 0x0D, +/* 15C0 */ 0x6D, 0x02, 0x90, 0x0D, 0x3A, 0x1D, 0x64, 0x09, 0x10, 0x0D, 0x9D, 0x72, 0x42, 0xC3, 0x6D, 0xD8, +/* 15D0 */ 0x2E, 0x06, 0xA4, 0x10, 0x0C, 0x61, 0x85, 0x46, 0x66, 0x94, 0x85, 0x46, 0x66, 0x65, 0x18, 0x7A, +/* 15E0 */ 0x02, 0x51, 0x08, 0x4D, 0xC9, 0x6D, 0x91, 0x51, 0x60, 0x7C, 0x51, 0x6F, 0x0C, 0x1D, 0xA1, 0x0E, +/* 15F0 */ 0x66, 0x51, 0x09, 0x0F, 0x53, 0xC9, 0x6D, 0x38, 0x51, 0x0C, 0xA4, 0x7F, 0x3F, 0x6A, 0x1D, 0xA1, +/* 1600 */ 0x0E, 0x66, 0x25, 0x2A, 0x95, 0x18, 0xA6, 0x26, 0x56, 0x66, 0x26, 0x56, 0x3A, 0x10, 0x07, 0x25, +/* 1610 */ 0xB1, 0xAB, 0x18, 0x06, 0x3C, 0x49, 0x53, 0x7F, 0x49, 0x53, 0x7F, 0xD6, 0xD6, 0xD6, 0xD6, 0xD6, +/* 1620 */ 0x49, 0x02, 0x5E, 0x02, 0x5E, 0x0B, 0x0A, 0x06, 0x3C, 0x49, 0x53, 0x7F, 0x49, 0x53, 0x10, 0x0B, +/* 1630 */ 0x29, 0xB1, 0x72, 0x05, 0x05, 0x1E, 0x06, 0x22, 0x62, 0x31, 0x02, 0x1E, 0x50, 0x71, 0x1E, 0x28, +/* 1640 */ 0xEE, 0x9F, 0x8A, 0x67, 0x86, 0x85, 0x71, 0x1E, 0x0C, 0xA8, 0x2E, 0x9F, 0x8A, 0x49, 0x86, 0x85, +/* 1650 */ 0x78, 0x1E, 0x0D, 0xA8, 0x1E, 0x09, 0x20, 0x00, 0x5E, 0x19, 0xA7, 0x04, 0x1E, 0x0D, 0x6E, 0x2F, +/* 1660 */ 0x58, 0x20, 0x1E, 0x06, 0x89, 0x1E, 0x02, 0x66, 0x1E, 0x32, 0x07, 0x27, 0x58, 0x92, 0x2E, 0x05, +/* 1670 */ 0x07, 0x03, 0x10, 0x07, 0x29, 0xEC, 0x06, 0x18, 0x04, 0x7F, 0x9F, 0xA4, 0x7F, 0x9F, 0xA4, 0xDC, +/* 1680 */ 0x2F, 0x6C, 0xA4, 0xDC, 0x2F, 0x6C, 0xA4, 0xDC, 0x41, 0x06, 0x0A, 0x0B, 0xA4, 0x7F, 0x9F, 0xA4, +/* 1690 */ 0x7F, 0x9F, 0xA4, 0x10, 0x0C, 0x27, 0xB1, 0x05, 0x08, 0x08, 0x07, 0x00, 0xA7, 0x71, 0x57, 0x81, +/* 16A0 */ 0xC9, 0x50, 0x98, 0x0F, 0x2B, 0x7F, 0x0B, 0xA8, 0x05, 0x84, 0x00, 0x97, 0x0F, 0x7B, 0x0D, 0xA8, +/* 16B0 */ 0x37, 0x60, 0x0A, 0x19, 0x06, 0x84, 0x06, 0x66, 0x1D, 0x32, 0x09, 0x10, 0x0B, 0x3C, 0x74, 0xB3, +/* 16C0 */ 0x08, 0x18, 0x18, 0x01, 0x94, 0x60, 0x46, 0x3A, 0x94, 0x60, 0x46, 0x3A, 0x10, 0x08, 0x62, 0xB1, +/* 16D0 */ 0x72, 0x96, 0x70, 0x08, 0x95, 0x06, 0x72, 0x32, 0x30, 0x02, 0x51, 0x02, 0x08, 0x32, 0x8A, 0xD7, +/* 16E0 */ 0x0C, 0x05, 0x10, 0x0C, 0x90, 0x1C, 0xC5, 0xBD, 0x10, 0x0D, 0xF1, 0x35, 0x01, 0x09, 0x8B, 0x0B, +/* 16F0 */ 0x02, 0x37, 0x28, 0x98, 0x0F, 0x6D, 0x91, 0x65, 0x7A, 0x0C, 0x32, 0x75, 0x65, 0x0B, 0xA4, 0x6C, +/* 1700 */ 0x0E, 0x89, 0x65, 0x8C, 0x1B, 0x6D, 0x02, 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x19, 0x9F, 0x78, +/* 1710 */ 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x1D, 0x0B, 0x3A, 0x94, 0x28, 0x5C, 0x02, 0x0F, 0x22, 0x65, +/* 1720 */ 0x28, 0x20, 0x32, 0x7C, 0x65, 0x28, 0x9A, 0x0C, 0x37, 0x28, 0x09, 0xB0, 0x81, 0xA2, 0x10, 0x0A, +/* 1730 */ 0x1C, 0x47, 0x0A, 0xFA, 0xA6, 0x7F, 0x6F, 0x0F, 0x66, 0x5D, 0x0F, 0x6A, 0x0D, 0xAF, 0x37, 0x28, +/* 1740 */ 0x78, 0x00, 0x97, 0x01, 0x37, 0x85, 0x30, 0xC8, 0x75, 0x4A, 0x31, 0xEE, 0x67, 0x09, 0x72, 0x6A, +/* 1750 */ 0x1E, 0x60, 0x5C, 0x97, 0x7F, 0x49, 0xB2, 0x0C, 0x80, 0x25, 0xA9, 0x5C, 0x41, 0xAB, 0x0A, 0x9E, +/* 1760 */ 0xA6, 0x10, 0x0D, 0x70, 0x74, 0x0C, 0x0C, 0x0B, 0x08, 0x1E, 0xD1, 0xD1, 0xD1, 0x0D, 0x3E, 0x1D, +/* 1770 */ 0x3F, 0x0D, 0x30, 0x05, 0x0D, 0x0F, 0x30, 0x58, 0x56, 0x3E, 0x1D, 0x49, 0x0E, 0x0B, 0x32, 0x30, +/* 1780 */ 0x65, 0x60, 0x5C, 0xF9, 0x0C, 0x94, 0x85, 0x30, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75, 0x1D, +/* 1790 */ 0x0D, 0x3E, 0x19, 0xD5, 0x46, 0x60, 0x0C, 0x37, 0x9B, 0x8B, 0x0B, 0x03, 0xA5, 0x0C, 0x10, 0x0C, +/* 17A0 */ 0x65, 0x1C, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x08, 0x7F, 0x74, 0x93, 0x0E, 0x81, 0xB4, 0x7F, 0x64, +/* 17B0 */ 0x66, 0xA1, 0x0E, 0x6A, 0x0C, 0x0B, 0x3B, 0x7E, 0x41, 0x31, 0x07, 0x51, 0x32, 0x46, 0x7F, 0x9A, +/* 17C0 */ 0x81, 0x19, 0x58, 0x60, 0x30, 0x0A, 0x07, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C, +/* 17D0 */ 0xFE, 0x10, 0x0C, 0x37, 0xD9, 0xC9, 0x02, 0x1D, 0xA1, 0x02, 0x93, 0x7C, 0x37, 0x02, 0x09, 0x0D, +/* 17E0 */ 0x6D, 0x6A, 0x00, 0x31, 0x0F, 0x6A, 0x0A, 0x07, 0x90, 0x6C, 0x0E, 0x6A, 0x0D, 0x50, 0x5A, 0x65, +/* 17F0 */ 0x49, 0x07, 0x19, 0x60, 0x09, 0x65, 0x6F, 0x04, 0x19, 0x09, 0x22, 0x00, 0x31, 0x07, 0x19, 0xF0, +/* 1800 */ 0x37, 0x0D, 0x6A, 0x0D, 0x50, 0x75, 0x5D, 0x0D, 0x56, 0x45, 0x59, 0x0B, 0x95, 0x8B, 0x0C, 0xA2, +/* 1810 */ 0x37, 0x9F, 0x05, 0x35, 0x0B, 0x23, 0x08, 0x03, 0x25, 0x2D, 0x92, 0x94, 0x3F, 0x0C, 0x9A, 0x7C, +/* 1820 */ 0x5E, 0x0B, 0x94, 0x0D, 0x8B, 0x06, 0x19, 0x6C, 0x4D, 0x90, 0x8C, 0x08, 0x06, 0x07, 0x0C, 0xA4, +/* 1830 */ 0x90, 0x99, 0x69, 0x09, 0x37, 0x83, 0x63, 0x0F, 0x98, 0x5F, 0x10, 0x0D, 0xF1, 0x35, 0x01, 0x09, +/* 1840 */ 0x8B, 0x0B, 0x02, 0x37, 0x8C, 0x33, 0x30, 0x37, 0x7A, 0x63, 0x6B, 0x0B, 0x0F, 0x53, 0x6F, 0xE2, +/* 1850 */ 0x19, 0x67, 0xE2, 0x19, 0x67, 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x06, 0x52, 0xCF, 0x89, 0xE1, 0xE1, +/* 1860 */ 0x10, 0x06, 0x52, 0xCF, 0x89, 0x35, 0x35, 0x35, 0x35, 0x35, 0xE1, 0x1E, 0x0D, 0x22, 0xC8, 0xAF, +/* 1870 */ 0x3C, 0x39, 0x50, 0x71, 0x51, 0x0E, 0x6A, 0x2E, 0x08, 0x53, 0x72, 0xA6, 0x10, 0x0C, 0x00, 0x52, +/* 1880 */ 0x02, 0x03, 0x05, 0xE1, 0x1D, 0x60, 0x0C, 0x65, 0x8C, 0x19, 0x05, 0x6B, 0x8C, 0x6C, 0x0D, 0x92, +/* 1890 */ 0x65, 0x8C, 0x9F, 0x91, 0x37, 0x8C, 0xF9, 0x07, 0x25, 0x8C, 0x0A, 0x22, 0x7F, 0x8C, 0x0B, 0x6D, +/* 18A0 */ 0x02, 0x25, 0x8C, 0x03, 0x6D, 0x21, 0x8C, 0x00, 0x0B, 0x6D, 0x02, 0x37, 0x8C, 0x97, 0x50, 0x75, +/* 18B0 */ 0x37, 0x8C, 0x19, 0x33, 0x02, 0x65, 0x8C, 0x19, 0x49, 0x0A, 0x65, 0x8C, 0x1D, 0x0D, 0x6D, 0x02, +/* 18C0 */ 0x10, 0x07, 0x19, 0xAE, 0x72, 0x02, 0x1E, 0x0B, 0x0E, 0x0F, 0x8A, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, +/* 18D0 */ 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0x0D, 0x22, 0x1E, 0x0B, 0x6D, 0x5A, 0x51, 0x49, +/* 18E0 */ 0x78, 0x2E, 0x06, 0x0D, 0x81, 0x06, 0x10, 0x12, 0x90, 0x1C, 0x0B, 0xA8, 0x9B, 0x8B, 0x09, 0x6C, +/* 18F0 */ 0x09, 0x8B, 0x09, 0x01, 0x62, 0x28, 0x0C, 0x42, 0x75, 0x0D, 0x6D, 0x75, 0x62, 0x7A, 0xDE, 0x7A, +/* 1900 */ 0x62, 0x0B, 0xA4, 0x77, 0x50, 0x80, 0x09, 0x6D, 0x02, 0x4A, 0xCB, 0x4A, 0xCB, 0x4A, 0xCB, 0x10, +/* 1910 */ 0x0D, 0x90, 0x1C, 0x28, 0x5B, 0xE3, 0x7A, 0x88, 0x6B, 0x28, 0x80, 0x6F, 0xE2, 0x19, 0x67, 0xE2, +/* 1920 */ 0x19, 0x67, 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x0D, 0x65, 0x1C, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, +/* 1930 */ 0x0D, 0x90, 0x1C, 0x28, 0x8F, 0x0A, 0x8B, 0x0B, 0x03, 0x37, 0x0B, 0x22, 0x42, 0xCC, 0x01, 0x32, +/* 1940 */ 0xDF, 0x94, 0xC2, 0x65, 0x28, 0x20, 0x0E, 0xA4, 0x65, 0xDE, 0x6A, 0x37, 0x28, 0xAC, 0x0C, 0x81, +/* 1950 */ 0xA2, 0x37, 0x8C, 0x35, 0x35, 0x35, 0x1E, 0x09, 0x0B, 0x0A, 0x07, 0x10, 0x0D, 0x90, 0x1C, 0x3F, +/* 1960 */ 0x0D, 0x81, 0x06, 0x07, 0x0F, 0x30, 0x58, 0x46, 0x32, 0x0C, 0x65, 0x49, 0x0E, 0x0B, 0x32, 0x30, +/* 1970 */ 0x65, 0x0C, 0x66, 0x99, 0x32, 0x0C, 0x90, 0x6C, 0x6A, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75, +/* 1980 */ 0x1D, 0x0D, 0x3E, 0x19, 0xD5, 0x50, 0x89, 0x32, 0x0C, 0x37, 0x9B, 0x8B, 0x0B, 0x03, 0xD1, 0xD1, +/* 1990 */ 0xD1, 0xD1, 0xD1, 0x07, 0x09, 0x0B, 0x0A, 0x10, 0x09, 0x90, 0x1C, 0x28, 0xA2, 0x09, 0x0E, 0x0C, +/* 19A0 */ 0x7F, 0x28, 0x0A, 0x55, 0x0A, 0x7F, 0x0B, 0x22, 0x7E, 0x65, 0xDE, 0x2B, 0x7F, 0x28, 0x81, 0x03, +/* 19B0 */ 0x01, 0x01, 0x7F, 0x28, 0x71, 0x2E, 0x0B, 0x6D, 0x86, 0x8C, 0x35, 0x35, 0x35, 0x35, 0x35, 0x10, +/* 19C0 */ 0x0B, 0x00, 0x1C, 0xAB, 0x0B, 0x0E, 0x81, 0xA6, 0x7F, 0x2D, 0x2B, 0x76, 0x0E, 0x0B, 0xFA, 0x02, +/* 19D0 */ 0x37, 0x49, 0x05, 0x00, 0x99, 0x05, 0x41, 0xAB, 0x6A, 0x02, 0x2E, 0x60, 0x20, 0x05, 0x3C, 0xAD, +/* 19E0 */ 0x6D, 0x30, 0x02, 0x3C, 0x02, 0x4B, 0x6A, 0x72, 0x0D, 0x3A, 0x37, 0x06, 0x05, 0x1D, 0x0B, 0x3A, +/* 19F0 */ 0x65, 0x06, 0x89, 0x0B, 0x60, 0x30, 0x37, 0x2D, 0x95, 0x03, 0x25, 0x02, 0x09, 0x63, 0x81, 0xA2, +/* 1A00 */ 0x10, 0x08, 0x9D, 0x01, 0x86, 0x05, 0x88, 0x0F, 0x48, 0xEA, 0x64, 0x04, 0x51, 0x56, 0x30, 0x7F, +/* 1A10 */ 0x46, 0x92, 0x00, 0x58, 0x60, 0x30, 0x0A, 0x05, 0x90, 0xEA, 0x07, 0x6B, 0xEA, 0x07, 0x6B, 0xEA, +/* 1A20 */ 0x64, 0x04, 0x5E, 0x05, 0xC8, 0x95, 0x0B, 0x0B, 0x57, 0x0F, 0x71, 0x19, 0xA1, 0x09, 0x0E, 0x81, +/* 1A30 */ 0xB4, 0x10, 0x0C, 0x90, 0x1C, 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0B, 0x2C, 0x1C, 0xF2, 0x19, 0x49, +/* 1A40 */ 0x04, 0x94, 0x28, 0xAA, 0x9F, 0xAA, 0x90, 0x06, 0x66, 0x19, 0x0B, 0x20, 0x65, 0x02, 0xA4, 0x19, +/* 1A50 */ 0x32, 0x07, 0x37, 0x0D, 0x53, 0x02, 0x66, 0x90, 0x2A, 0x0C, 0x00, 0x05, 0x89, 0x25, 0x49, 0x9F, +/* 1A60 */ 0x0A, 0xA1, 0x66, 0x28, 0x06, 0x7F, 0x28, 0x06, 0x32, 0x02, 0x37, 0x3F, 0x20, 0x0F, 0x30, 0xC9, +/* 1A70 */ 0x6D, 0xA8, 0x51, 0x32, 0x1A, 0x57, 0xAA, 0x10, 0x10, 0x2C, 0x1C, 0x60, 0x0C, 0x19, 0x08, 0x66, +/* 1A80 */ 0x99, 0x0F, 0x1A, 0x4A, 0x09, 0x89, 0x34, 0x50, 0x71, 0x00, 0x49, 0x02, 0x4A, 0x6F, 0x19, 0x0D, +/* 1A90 */ 0x0F, 0x6E, 0x06, 0x89, 0x4A, 0x99, 0x0F, 0x7B, 0x50, 0x53, 0x08, 0x20, 0x62, 0x85, 0x78, 0x03, +/* 1AA0 */ 0x20, 0x30, 0x77, 0x53, 0x62, 0x0D, 0x0F, 0x71, 0x05, 0x95, 0x07, 0x95, 0x00, 0x60, 0x06, 0x27, +/* 1AB0 */ 0x1B, 0x0F, 0x7C, 0x08, 0x30, 0x05, 0x50, 0x01, 0x32, 0x03, 0x4A, 0x3F, 0x0F, 0x75, 0x0A, 0x0F, +/* 1AC0 */ 0x96, 0x1A, 0x3A, 0x29, 0x05, 0x20, 0x0D, 0x80, 0xA8, 0x22, 0x2C, 0x02, 0x50, 0x60, 0x05, 0x00, +/* 1AD0 */ 0x0D, 0x30, 0x92, 0x2C, 0x42, 0x5C, 0x0B, 0x0F, 0x4C, 0x7A, 0x01, 0x9F, 0x0F, 0x71, 0x62, 0x2A, +/* 1AE0 */ 0x95, 0x19, 0x6F, 0x0F, 0x02, 0x10, 0x0B, 0xAE, 0x9D, 0x26, 0x1A, 0x6C, 0x4D, 0x94, 0x02, 0x0F, +/* 1AF0 */ 0x53, 0x6F, 0x02, 0x37, 0x09, 0x89, 0x00, 0x28, 0x0A, 0xA1, 0x32, 0x6F, 0x02, 0x25, 0x9F, 0x32, +/* 1B00 */ 0x09, 0x19, 0xA1, 0x32, 0x7B, 0x3C, 0x0B, 0x6D, 0x91, 0x2F, 0x31, 0x53, 0x7F, 0xE8, 0x6D, 0x02, +/* 1B10 */ 0x25, 0x05, 0x50, 0x38, 0x32, 0x0A, 0x25, 0x0D, 0x53, 0x08, 0x66, 0x65, 0x6F, 0x8D, 0x02, 0x6A, +/* 1B20 */ 0x90, 0x6C, 0xF2, 0x19, 0x28, 0x78, 0x10, 0x0B, 0x2C, 0x1C, 0x32, 0xBE, 0x05, 0x10, 0x0A, 0xAE, +/* 1B30 */ 0x9D, 0x31, 0x46, 0x09, 0x19, 0x31, 0x46, 0x09, 0x5D, 0x23, 0x23, 0x0D, 0x7E, 0x25, 0xF9, 0x45, +/* 1B40 */ 0x51, 0x28, 0x78, 0x51, 0x6F, 0x09, 0x51, 0xF9, 0x45, 0x51, 0x28, 0x78, 0x51, 0x6F, 0x09, 0x51, +/* 1B50 */ 0xF9, 0x45, 0x57, 0x0D, 0x23, 0x23, 0x07, 0x37, 0x28, 0x46, 0x75, 0x37, 0xDE, 0x4C, 0x10, 0x07, +/* 1B60 */ 0x90, 0xEC, 0x54, 0x88, 0xEE, 0x60, 0x75, 0x27, 0x31, 0x0D, 0x06, 0x51, 0x6F, 0x86, 0x6F, 0x1E, +/* 1B70 */ 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x51, 0x3F, 0x89, 0x72, 0x28, 0x0C, 0x2E, 0x60, 0xAC, 0x2E, 0x0C, +/* 1B80 */ 0x95, 0xEF, 0x55, 0x7C, 0x1E, 0x09, 0x22, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E, +/* 1B90 */ 0x6F, 0x1E, 0x6F, 0x86, 0x67, 0x0D, 0x06, 0x2E, 0x33, 0xEE, 0x54, 0x88, 0x09, 0x10, 0x08, 0x90, +/* 1BA0 */ 0xEC, 0x0B, 0x20, 0x1E, 0x79, 0x20, 0x1E, 0xF6, 0x1E, 0xF6, 0x1E, 0xF6, 0x10, 0x07, 0x29, 0xEC, +/* 1BB0 */ 0x4B, 0x0C, 0xA2, 0x51, 0x9F, 0x81, 0x2E, 0x06, 0x0D, 0x0F, 0x1A, 0x72, 0x6D, 0xEF, 0x32, 0x07, +/* 1BC0 */ 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0xE8, 0x86, 0x04, +/* 1BD0 */ 0x32, 0x8A, 0xA3, 0x30, 0x2E, 0x64, 0xEE, 0x0D, 0x53, 0x2E, 0x4C, 0x29, 0x4C, 0x29, 0x4C, 0x29, +/* 1BE0 */ 0x4C, 0x29, 0x50, 0x7C, 0x72, 0xA4, 0x51, 0x06, 0x0D, 0x6B, 0x41, 0x9F, 0x30, 0x2E, 0x4B, 0x0C, +/* 1BF0 */ 0xA2, 0x10, 0x0B, 0x9D, 0x9D, 0xA1, 0x09, 0x8B, 0xB4, 0x99, 0xB4, 0x37, 0x28, 0x6A, 0x0E, 0x30, +/* 1C00 */ 0x65, 0x06, 0x20, 0x0D, 0x50, 0x89, 0x03, 0x65, 0x4E, 0x07, 0x19, 0x06, 0x88, 0x0C, 0x04, 0x10, +/* 1C10 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x2E, 0x00, 0x77, 0x00, 0xB6, 0x01, 0x06, 0x01, 0x51, 0x01, 0x5F, +/* 1C20 */ 0x01, 0xBD, 0x01, 0xC3, 0x02, 0x43, 0x02, 0x8C, 0x02, 0xE3, 0x02, 0xFF, 0x03, 0x0B, 0x03, 0x75, +/* 1C30 */ 0x03, 0x82, 0x03, 0xAD, 0x03, 0xD4, 0x04, 0x01, 0x04, 0x2E, 0x04, 0x45, 0x04, 0x86, 0x04, 0xD0, +/* 1C40 */ 0x04, 0xD4, 0x04, 0xF1, 0x05, 0x10, 0x05, 0x5D, 0x05, 0xB0, 0x05, 0xF8, 0x06, 0x65, 0x06, 0xD4, +/* 1C50 */ 0x07, 0x12, 0x07, 0x29, 0x07, 0x3C, 0x07, 0x59, 0x07, 0x73, 0x07, 0x90, 0x07, 0xB4, 0x08, 0x0F, +/* 1C60 */ 0x08, 0x6C, 0x08, 0x84, 0x08, 0x9C, 0x08, 0xBB, 0x08, 0xC6, 0x08, 0xDE, 0x08, 0xF8, 0x09, 0x17, +/* 1C70 */ 0x09, 0x2F, 0x09, 0x86, 0x09, 0xAE, 0x09, 0xC5, 0x09, 0xD9, 0x09, 0xF8, 0x0A, 0x14, 0x0A, 0x36, +/* 1C80 */ 0x0A, 0x6D, 0x0A, 0xE8, 0x0B, 0x00, 0x0B, 0x18, 0x0B, 0x37, 0x0B, 0x4D, 0x0B, 0x6B, 0x0B, 0xA3, +/* 1C90 */ 0x0C, 0x08, 0x0C, 0x20, 0x0C, 0x36, 0x0C, 0x52, 0x0C, 0x6F, 0x0C, 0x81, 0x0C, 0xA7, 0x0D, 0x0D, +/* 1CA0 */ 0x0D, 0x58, 0x0D, 0x73, 0x0D, 0x8D, 0x0D, 0xAE, 0x0D, 0xC5, 0x0D, 0xDE, 0x0D, 0xFA, 0x0E, 0x18, +/* 1CB0 */ 0x0E, 0x23, 0x0E, 0x87, 0x0E, 0xB5, 0x0E, 0xD1, 0x0E, 0xEB, 0x0F, 0x0D, 0x0F, 0x2A, 0x0F, 0x4B, +/* 1CC0 */ 0x0F, 0x65, 0x0F, 0xC3, 0x0F, 0xDD, 0x0F, 0xF5, 0x10, 0x14, 0x10, 0x21, 0x10, 0x35, 0x10, 0x61, +/* 1CD0 */ 0x05, 0x00, 0x10, 0x06, 0x4A, 0x4F, 0x1C, 0x4B, 0x68, 0x36, 0x20, 0x1E, 0x08, 0x98, 0x03, 0x1D, +/* 1CE0 */ 0xEC, 0x0B, 0x1A, 0x1E, 0x0C, 0x1A, 0x1E, 0x60, 0x05, 0x1E, 0x0D, 0x50, 0xEF, 0x32, 0xEF, 0x32, +/* 1CF0 */ 0x07, 0x1E, 0x7E, 0x7F, 0x85, 0x75, 0x72, 0x6D, 0xEE, 0x02, 0x4D, 0xA7, 0x0B, 0x10, 0x0A, 0xD9, +/* 1D00 */ 0x6C, 0x0F, 0x80, 0x72, 0x0F, 0x80, 0x72, 0xA8, 0x1E, 0x06, 0x0F, 0x30, 0x05, 0x3C, 0x39, 0x46, +/* 1D10 */ 0x0C, 0x02, 0x59, 0x0D, 0x56, 0x45, 0x37, 0x08, 0x6D, 0xA2, 0x02, 0x8F, 0x25, 0xF2, 0xA7, 0x0A, +/* 1D20 */ 0x4A, 0x31, 0xEE, 0x67, 0xEE, 0x03, 0x4D, 0x51, 0x85, 0x81, 0x19, 0x57, 0xA2, 0x02, 0xB4, 0x00, +/* 1D30 */ 0x5D, 0x56, 0x30, 0x7F, 0x05, 0x42, 0x22, 0x03, 0x7F, 0x02, 0x08, 0x22, 0x73, 0x1D, 0xA1, 0x0F, +/* 1D40 */ 0x80, 0x72, 0x0F, 0x80, 0x72, 0xA8, 0x10, 0x0C, 0x00, 0xD9, 0x06, 0x0C, 0x8B, 0x0C, 0x07, 0x3C, +/* 1D50 */ 0xA9, 0x8E, 0x5D, 0x0F, 0x89, 0x0B, 0x9E, 0x48, 0x9F, 0x5C, 0x02, 0x96, 0x25, 0x09, 0x6D, 0x19, +/* 1D60 */ 0x57, 0x19, 0x57, 0xA7, 0x6D, 0x22, 0x37, 0xF9, 0x89, 0x8B, 0x0C, 0x19, 0x58, 0x6D, 0x27, 0x58, +/* 1D70 */ 0x89, 0x27, 0x58, 0x22, 0x72, 0x32, 0x06, 0x4A, 0xAB, 0x0D, 0x22, 0x18, 0x87, 0x90, 0x2D, 0x0F, +/* 1D80 */ 0x89, 0x65, 0x64, 0x46, 0x30, 0x10, 0x0C, 0xB1, 0x61, 0x01, 0x0B, 0x07, 0x27, 0x05, 0x8E, 0x90, +/* 1D90 */ 0x9F, 0x07, 0x0A, 0x8B, 0xE9, 0x0E, 0xAF, 0x2C, 0x6C, 0x0D, 0x50, 0x56, 0x45, 0x47, 0x50, 0x30, +/* 1DA0 */ 0x60, 0x71, 0x37, 0x06, 0xA8, 0x19, 0x06, 0xA8, 0x19, 0x26, 0x5C, 0x6C, 0x20, 0x37, 0x28, 0x02, +/* 1DB0 */ 0x1D, 0x3E, 0x41, 0x09, 0x1A, 0x19, 0x02, 0x20, 0x1D, 0xAB, 0x20, 0x02, 0xAD, 0x2B, 0x37, 0x49, +/* 1DC0 */ 0x46, 0x07, 0x47, 0x32, 0x46, 0x1A, 0x2C, 0x3F, 0x81, 0x02, 0x06, 0x09, 0x09, 0x06, 0x39, 0x75, +/* 1DD0 */ 0x90, 0x3F, 0x03, 0x27, 0x82, 0x10, 0x0C, 0x9D, 0x72, 0x32, 0x0C, 0xE6, 0xA4, 0x90, 0x08, 0x6D, +/* 1DE0 */ 0x02, 0x1B, 0x22, 0x90, 0x6C, 0x0E, 0x0F, 0x80, 0x6C, 0xA4, 0x65, 0x08, 0x89, 0x19, 0x06, 0x84, +/* 1DF0 */ 0x00, 0x85, 0x71, 0x00, 0x60, 0x07, 0x94, 0x2A, 0x96, 0x50, 0x38, 0x00, 0x76, 0x0A, 0xA8, 0x37, +/* 1E00 */ 0x2A, 0x84, 0x1D, 0x2D, 0x89, 0x37, 0x06, 0x0E, 0x32, 0x89, 0x98, 0x3C, 0x09, 0x3A, 0x7F, 0x06, +/* 1E10 */ 0x8B, 0x32, 0x95, 0x98, 0x37, 0x2D, 0x89, 0x3C, 0x09, 0x6D, 0x86, 0x09, 0x6D, 0x86, 0x09, 0x3A, +/* 1E20 */ 0x10, 0x08, 0x90, 0xEC, 0x79, 0x20, 0x1E, 0xF6, 0x4A, 0x74, 0x79, 0x20, 0x1E, 0xF6, 0x10, 0x0C, +/* 1E30 */ 0xD9, 0x04, 0x0B, 0x0E, 0x81, 0x5F, 0x7F, 0x2D, 0x2B, 0x76, 0x0E, 0x0B, 0x0C, 0x0F, 0x38, 0x37, +/* 1E40 */ 0x05, 0x66, 0x19, 0x02, 0x04, 0x25, 0x49, 0x05, 0x72, 0x0E, 0x6A, 0x05, 0x51, 0x6F, 0x22, 0x05, +/* 1E50 */ 0x00, 0x5D, 0x50, 0x7D, 0x6D, 0x71, 0x37, 0x0B, 0x1A, 0x00, 0x05, 0x0D, 0x20, 0x37, 0x32, 0x05, +/* 1E60 */ 0x00, 0x24, 0x94, 0x0C, 0x89, 0x07, 0xD7, 0x53, 0x00, 0x31, 0x89, 0x0F, 0x45, 0x25, 0x9B, 0x46, +/* 1E70 */ 0x07, 0x51, 0x4E, 0x42, 0x02, 0xC8, 0x71, 0x25, 0x09, 0x06, 0x02, 0x00, 0x06, 0x6B, 0x97, 0x46, +/* 1E80 */ 0x84, 0x19, 0x6F, 0x0F, 0x89, 0x03, 0x7F, 0xD7, 0x09, 0x0A, 0x09, 0x9C, 0x10, 0x0A, 0x52, 0x4B, +/* 1E90 */ 0xB5, 0x5A, 0x10, 0x12, 0x51, 0x74, 0x4E, 0x0A, 0x0C, 0x0B, 0x09, 0x04, 0x7F, 0x2D, 0x30, 0x02, +/* 1EA0 */ 0x65, 0x09, 0xA8, 0x03, 0x01, 0x01, 0xB0, 0x0F, 0x91, 0x90, 0x05, 0x95, 0x03, 0x02, 0x0B, 0x8B, +/* 1EB0 */ 0x09, 0x9B, 0x30, 0x90, 0x0D, 0x2B, 0xF9, 0x50, 0x9C, 0x0D, 0x2B, 0x2F, 0xE6, 0x95, 0xFB, 0x04, +/* 1EC0 */ 0x82, 0x19, 0x06, 0xB2, 0x4A, 0x3F, 0x75, 0x00, 0xFD, 0x2F, 0x02, 0x50, 0x29, 0x09, 0x80, 0x53, +/* 1ED0 */ 0x2F, 0x50, 0x01, 0x62, 0x09, 0x7C, 0x00, 0x53, 0x2F, 0x7B, 0x4A, 0x08, 0x75, 0x00, 0xFD, 0x2F, +/* 1EE0 */ 0x85, 0x29, 0x05, 0x81, 0x77, 0x0F, 0x71, 0x02, 0xA2, 0x00, 0x06, 0x30, 0x2C, 0x0E, 0x78, 0x02, +/* 1EF0 */ 0x42, 0x80, 0x0C, 0x7C, 0x62, 0x3F, 0x81, 0x02, 0x03, 0x0B, 0x95, 0x09, 0x54, 0x0F, 0x45, 0x90, +/* 1F00 */ 0x0B, 0x95, 0x9C, 0x00, 0x99, 0x0A, 0x1A, 0x2C, 0x2A, 0x95, 0x32, 0xAC, 0x25, 0x83, 0x0D, 0x8B, +/* 1F10 */ 0x0C, 0x73, 0x10, 0x0B, 0xB1, 0x52, 0x4E, 0x88, 0x81, 0x09, 0x01, 0x3B, 0x6D, 0x6A, 0x3C, 0x63, +/* 1F20 */ 0x7D, 0x0F, 0x7B, 0xA1, 0x1D, 0x0E, 0x1A, 0x2F, 0xAB, 0x0B, 0x0D, 0x0F, 0x6B, 0x3F, 0x0F, 0x22, +/* 1F30 */ 0x6B, 0x19, 0x32, 0x05, 0x00, 0x0E, 0x1A, 0x25, 0xA4, 0x03, 0xA4, 0x25, 0x9A, 0x20, 0x25, 0x64, +/* 1F40 */ 0x75, 0x0E, 0x7C, 0x7F, 0x05, 0x0A, 0xE9, 0x00, 0x02, 0x8F, 0x4A, 0xAE, 0x0B, 0x0C, 0x0C, 0x0C, +/* 1F50 */ 0x0C, 0x0C, 0x0C, 0x0C, 0x8E, 0x37, 0x56, 0x3A, 0x37, 0x56, 0x3A, 0x10, 0x0E, 0x52, 0x74, 0x59, +/* 1F60 */ 0x01, 0x41, 0x6C, 0x19, 0x58, 0x0D, 0x04, 0x1D, 0x09, 0x0E, 0x05, 0x94, 0x3F, 0x50, 0x38, 0x00, +/* 1F70 */ 0x6F, 0x02, 0x31, 0x08, 0x99, 0x50, 0x75, 0x94, 0xF9, 0x45, 0x01, 0x0D, 0x84, 0x60, 0x71, 0x00, +/* 1F80 */ 0x0B, 0x4C, 0x99, 0x50, 0x30, 0x00, 0x02, 0x0F, 0x22, 0x47, 0x0F, 0x53, 0x02, 0x6A, 0x94, 0x6C, +/* 1F90 */ 0x0E, 0x66, 0x01, 0x0E, 0x6B, 0x05, 0x6A, 0x97, 0x50, 0x30, 0x65, 0x9F, 0x71, 0x00, 0x07, 0xA4, +/* 1FA0 */ 0x37, 0x0B, 0x22, 0x34, 0x84, 0x6C, 0x0D, 0x0F, 0x87, 0x01, 0x0D, 0x0F, 0x87, 0x47, 0x04, 0x41, +/* 1FB0 */ 0x02, 0x05, 0x10, 0x0C, 0x4A, 0x44, 0x23, 0x23, 0x18, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09, +/* 1FC0 */ 0x1E, 0x06, 0x53, 0x2E, 0x06, 0x53, 0x2E, 0x06, 0x53, 0x19, 0xC9, 0x07, 0x07, 0x05, 0x10, 0x09, +/* 1FD0 */ 0x4A, 0x44, 0x23, 0x18, 0x3C, 0x0F, 0x56, 0x3C, 0x0F, 0x56, 0x10, 0x0E, 0x7F, 0x74, 0x4E, 0x0C, +/* 1FE0 */ 0x8B, 0x0B, 0x05, 0x3B, 0x0D, 0x22, 0x32, 0x5A, 0x94, 0x6C, 0x0D, 0x75, 0x01, 0x19, 0x02, 0x0B, +/* 1FF0 */ 0xAF, 0x2C, 0x3F, 0x0F, 0x08, 0x06, 0x22, 0x07, 0x00, 0x0B, 0x78, 0x94, 0x63, 0xD7, 0x71, 0x09, +/* 2000 */ 0x0F, 0x03, 0x04, 0x75, 0x94, 0xB2, 0x00, 0x06, 0x0F, 0x03, 0x07, 0x78, 0x00, 0x30, 0x90, 0x02, +/* 2010 */ 0xAF, 0x6F, 0x09, 0x19, 0x98, 0x2C, 0x6C, 0xB2, 0x00, 0x06, 0x2B, 0x80, 0x00, 0x30, 0x94, 0x63, +/* 2020 */ 0xD7, 0x0F, 0x83, 0x0F, 0x02, 0x04, 0x75, 0x2C, 0x3F, 0x0F, 0x08, 0x03, 0x73, 0x82, 0x04, 0x0B, +/* 2030 */ 0x78, 0x90, 0x6C, 0x0D, 0x0F, 0xA2, 0x19, 0x02, 0x0B, 0xAF, 0x47, 0x0D, 0x22, 0x32, 0x5A, 0x25, +/* 2040 */ 0x4E, 0x0C, 0x8B, 0xE9, 0x10, 0x08, 0x51, 0xAE, 0x9B, 0x18, 0x05, 0x3B, 0x56, 0x08, 0x3B, 0x56, +/* 2050 */ 0x08, 0x10, 0x0B, 0x25, 0x74, 0x4E, 0x0A, 0x8F, 0x51, 0x39, 0x0F, 0xA4, 0x3C, 0x7A, 0x7B, 0x37, +/* 2060 */ 0x85, 0x0A, 0x01, 0x05, 0x6E, 0x5D, 0x1A, 0x19, 0x0E, 0x0F, 0x21, 0x02, 0x6E, 0x01, 0xA8, 0x7F, +/* 2070 */ 0x0D, 0x20, 0x0E, 0x1A, 0x41, 0x31, 0x92, 0x27, 0xAB, 0x0C, 0x98, 0x08, 0x10, 0x0C, 0x4F, 0x61, +/* 2080 */ 0x28, 0xDD, 0x0A, 0x23, 0x32, 0x0C, 0x23, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09, 0x3C, 0x28, +/* 2090 */ 0xDD, 0x1D, 0x28, 0x05, 0x29, 0xAE, 0x09, 0x0A, 0x23, 0x18, 0x05, 0x37, 0x0D, 0x56, 0x6E, 0x65, +/* 20A0 */ 0x0D, 0x56, 0x6E, 0x10, 0x09, 0x37, 0x74, 0x9B, 0x0E, 0x81, 0x06, 0x19, 0xA1, 0x9A, 0x05, 0x3C, +/* 20B0 */ 0x05, 0xB4, 0x04, 0x92, 0xC8, 0x09, 0x1E, 0x0B, 0x0F, 0x91, 0x2F, 0x58, 0x95, 0x03, 0x1D, 0xA1, +/* 20C0 */ 0x0B, 0x81, 0x03, 0x2E, 0x28, 0x0C, 0x23, 0x09, 0x3C, 0x0D, 0x46, 0x0C, 0x3C, 0x0D, 0x50, 0x6A, +/* 20D0 */ 0x10, 0x09, 0x52, 0x9B, 0x8B, 0x0C, 0x04, 0x19, 0xA1, 0x32, 0x66, 0x3C, 0x06, 0x5A, 0x04, 0x53, +/* 20E0 */ 0x1E, 0x92, 0x62, 0xAB, 0x0F, 0x71, 0x2E, 0x0C, 0x95, 0xEF, 0x0C, 0x9E, 0x05, 0x00, 0x72, 0xFA, +/* 20F0 */ 0x3C, 0x05, 0x5B, 0x03, 0x9E, 0x19, 0x76, 0x7E, 0x5D, 0x0B, 0x8B, 0x0C, 0x06, 0x10, 0x08, 0xEC, +/* 2100 */ 0x47, 0x0A, 0x1E, 0x54, 0x0F, 0x71, 0x4A, 0xAB, 0x0D, 0x50, 0x30, 0x19, 0xA1, 0x0E, 0x22, 0x73, +/* 2110 */ 0x7F, 0x3F, 0x0B, 0x05, 0x10, 0x0D, 0x90, 0x1C, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, +/* 2120 */ 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, +/* 2130 */ 0x8C, 0x3F, 0x6B, 0x28, 0xAA, 0x60, 0x71, 0x65, 0x0B, 0x6D, 0x7D, 0x0F, 0xA4, 0x65, 0xDE, 0x33, +/* 2140 */ 0x08, 0x65, 0x0B, 0x20, 0x0E, 0x5A, 0x0D, 0x53, 0x94, 0x28, 0x06, 0x1D, 0x02, 0x02, 0x25, 0x28, +/* 2150 */ 0x0A, 0x1E, 0x79, 0x98, 0x08, 0x10, 0x11, 0xD9, 0x02, 0x09, 0x0D, 0x9A, 0x22, 0x90, 0xA3, 0x69, +/* 2160 */ 0x81, 0x2C, 0xF9, 0x50, 0x89, 0x0A, 0xF0, 0x2C, 0x2D, 0xB2, 0x24, 0x2F, 0x1B, 0x46, 0x20, 0x24, +/* 2170 */ 0x2F, 0x1B, 0x46, 0x20, 0x24, 0x62, 0xA9, 0xB2, 0x24, 0x4A, 0x99, 0x46, 0x20, 0x24, 0x29, 0xA9, +/* 2180 */ 0x0B, 0x24, 0x2C, 0x06, 0x0D, 0x0F, 0x6A, 0x24, 0x94, 0x54, 0x20, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, +/* 2190 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0x24, 0x65, 0x05, 0x0A, 0x08, 0x05, 0x97, 0x0A, 0x08, 0x05, 0x10, +/* 21A0 */ 0x06, 0x44, 0xC1, 0x10, 0x07, 0xAE, 0xB3, 0x07, 0x5F, 0x70, 0x0C, 0x7C, 0x70, 0x32, 0x8E, 0x72, +/* 21B0 */ 0x05, 0xA8, 0x51, 0x02, 0x01, 0x03, 0xA8, 0x51, 0x60, 0x1A, 0x19, 0xA1, 0x09, 0x8B, 0x0C, 0x05, +/* 21C0 */ 0x10, 0x09, 0x74, 0xA1, 0x55, 0x09, 0x4A, 0xAB, 0x0D, 0x50, 0x75, 0x19, 0xA1, 0x9E, 0x53, 0x3C, +/* 21D0 */ 0x05, 0xB4, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x10, +/* 21E0 */ 0x0B, 0x90, 0x4F, 0x74, 0x02, 0x09, 0x0D, 0x81, 0x09, 0x01, 0x7F, 0x39, 0x46, 0x45, 0x1D, 0x26, +/* 21F0 */ 0x22, 0x6D, 0x21, 0x0F, 0x6E, 0x07, 0x89, 0x5D, 0x66, 0x99, 0x6D, 0x02, 0x47, 0x6D, 0x02, 0x99, +/* 2200 */ 0x6D, 0x02, 0x65, 0x02, 0x66, 0x97, 0x3A, 0x37, 0x32, 0x09, 0x01, 0x09, 0x22, 0x25, 0x09, 0x56, +/* 2210 */ 0x7C, 0xA1, 0x60, 0x6A, 0x51, 0x06, 0x0A, 0x0B, 0x0A, 0x06, 0x62, 0xAE, 0x02, 0x0C, 0x0C, 0x0C, +/* 2220 */ 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x8E, 0x47, 0x69, 0x02, 0x47, 0x69, 0x02, 0x10, 0x0E, 0x4F, 0xD9, +/* 2230 */ 0x72, 0x01, 0x1D, 0x6C, 0x01, 0x41, 0xAB, 0xA0, 0x19, 0x97, 0xA0, 0x59, 0x0E, 0xA8, 0x19, 0x0E, +/* 2240 */ 0xA8, 0x37, 0x64, 0x04, 0x00, 0x6F, 0x05, 0x37, 0x0D, 0x50, 0x91, 0x00, 0x60, 0x91, 0x65, 0x49, +/* 2250 */ 0x8E, 0x67, 0x45, 0x65, 0x28, 0x78, 0x77, 0x6B, 0x55, 0x78, 0x9F, 0x78, 0x94, 0x02, 0x6D, 0x91, +/* 2260 */ 0x02, 0x42, 0x02, 0x26, 0x0F, 0x71, 0x77, 0xA4, 0x31, 0x09, 0x99, 0x50, 0x75, 0x65, 0xE8, 0x19, +/* 2270 */ 0x60, 0x0C, 0x37, 0x09, 0x0F, 0x38, 0x19, 0x09, 0x0F, 0x91, 0x41, 0xAB, 0x03, 0xE6, 0x04, 0x10, +/* 2280 */ 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E, 0x0B, 0xC7, 0x75, 0x41, 0x09, 0x0F, 0x38, 0x94, +/* 2290 */ 0x85, 0x09, 0x1D, 0x85, 0xF8, 0x00, 0x6C, 0x0E, 0x75, 0x3F, 0x09, 0x04, 0x29, 0x85, 0x09, 0x3F, +/* 22A0 */ 0x50, 0x03, 0x6C, 0x0E, 0xAF, 0x62, 0x85, 0x09, 0x19, 0xFD, 0x19, 0x06, 0x1A, 0x62, 0x6C, 0x53, +/* 22B0 */ 0x05, 0x1A, 0x19, 0x0C, 0x30, 0x25, 0x0C, 0x30, 0x00, 0x97, 0x0F, 0x2B, 0x05, 0xD2, 0x81, 0x1D, +/* 22C0 */ 0x9A, 0x30, 0x62, 0x99, 0x0F, 0x2B, 0xF7, 0x10, 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E, +/* 22D0 */ 0x0B, 0xC7, 0x75, 0x41, 0x09, 0x0F, 0x38, 0x94, 0x85, 0x09, 0x1D, 0x85, 0xF8, 0x00, 0x6C, 0x0E, +/* 22E0 */ 0x75, 0x00, 0xB0, 0x95, 0x96, 0x4A, 0x85, 0x09, 0x3F, 0x50, 0x03, 0x07, 0x46, 0x45, 0x27, 0x85, +/* 22F0 */ 0x09, 0x19, 0xFD, 0x6C, 0x09, 0x05, 0x01, 0x28, 0x03, 0x2F, 0x6C, 0x53, 0x05, 0x1A, 0x19, 0x1B, +/* 2300 */ 0x7B, 0x2C, 0x0C, 0x30, 0x41, 0x99, 0x0F, 0x75, 0xAB, 0x0F, 0x71, 0x1D, 0x99, 0x0E, 0xAF, 0x90, +/* 2310 */ 0x0B, 0x81, 0xE6, 0x0E, 0x75, 0x90, 0x99, 0x0F, 0x2B, 0x19, 0x99, 0x89, 0x0A, 0x23, 0x05, 0x27, +/* 2320 */ 0x1B, 0x95, 0x41, 0x05, 0x46, 0x71, 0x62, 0x02, 0x6E, 0x1D, 0x49, 0x0F, 0x1A, 0x62, 0x09, 0x95, +/* 2330 */ 0x86, 0x99, 0x0A, 0x08, 0x10, 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E, 0x0B, 0x81, 0x29, +/* 2340 */ 0x9B, 0x0E, 0x81, 0x08, 0x41, 0x99, 0x0F, 0x2B, 0x29, 0x0D, 0x50, 0x7E, 0x77, 0x95, 0x29, 0x6C, +/* 2350 */ 0x04, 0x01, 0x03, 0x53, 0x19, 0x02, 0x6E, 0x90, 0x0C, 0x95, 0x09, 0x01, 0x1D, 0x09, 0x0F, 0x38, +/* 2360 */ 0x94, 0x0C, 0x9E, 0x05, 0x00, 0x6C, 0xA8, 0x59, 0x0D, 0x81, 0x00, 0x9F, 0x02, 0xAB, 0x73, 0x02, +/* 2370 */ 0x9E, 0x6C, 0x0E, 0x75, 0x3F, 0x09, 0x04, 0x27, 0x02, 0x0F, 0x6D, 0x53, 0x07, 0x50, 0x03, 0x6C, +/* 2380 */ 0x0E, 0xAF, 0x19, 0xE6, 0xF0, 0x07, 0x19, 0xFD, 0x19, 0x06, 0x1A, 0x37, 0x05, 0x1A, 0x19, 0x0C, +/* 2390 */ 0x30, 0x25, 0x0C, 0x30, 0x00, 0x97, 0x0F, 0x2B, 0x05, 0xD2, 0x81, 0x1D, 0x9A, 0x30, 0x62, 0x99, +/* 23A0 */ 0x0F, 0x2B, 0xF7, 0x10, 0x0B, 0x62, 0x4F, 0x1C, 0x3F, 0x98, 0x03, 0xC8, 0x30, 0xC8, 0x0F, 0x8A, +/* 23B0 */ 0x08, 0x98, 0x03, 0xEC, 0x1B, 0x0C, 0x0C, 0xEF, 0x32, 0x07, 0x51, 0x9F, 0x78, 0x25, 0x2A, 0x30, +/* 23C0 */ 0x51, 0x0B, 0x6D, 0x8E, 0x3C, 0x05, 0x4D, 0x57, 0x03, 0x19, 0x6C, 0x25, 0x09, 0xA4, 0x00, 0x02, +/* 23D0 */ 0x0B, 0x0D, 0x03, 0x37, 0x6F, 0x0F, 0x42, 0x38, 0x37, 0x7A, 0x89, 0x05, 0x7F, 0x06, 0x88, 0x98, +/* 23E0 */ 0x5B, 0x10, 0x0D, 0x27, 0x05, 0x05, 0x00, 0x70, 0xFD, 0x02, 0x2E, 0x6F, 0x80, 0x3C, 0xD7, 0x0B, +/* 23F0 */ 0x6D, 0xEF, 0x02, 0x08, 0x0C, 0x19, 0xEC, 0xE0, 0x10, 0x0D, 0x29, 0x05, 0x05, 0x1E, 0x02, 0x0B, +/* 2400 */ 0x81, 0x51, 0x54, 0x0F, 0xA4, 0xE4, 0x0B, 0x5B, 0x41, 0xEC, 0xE0, 0x10, 0x0D, 0x27, 0x02, 0x9E, +/* 2410 */ 0x03, 0x51, 0xF9, 0x95, 0x03, 0x7F, 0xF9, 0x0A, 0x89, 0x03, 0x25, 0x05, 0x81, 0x04, 0x99, 0x0C, +/* 2420 */ 0x71, 0x2F, 0xAB, 0x01, 0xE6, 0x00, 0xEC, 0xE0, 0x10, 0x0D, 0x4F, 0x3F, 0x09, 0x04, 0x99, 0x06, +/* 2430 */ 0x3C, 0x0B, 0x6D, 0x88, 0x80, 0x37, 0x05, 0x56, 0x38, 0x00, 0x5D, 0x0A, 0xA2, 0x09, 0x98, 0x8D, +/* 2440 */ 0xEC, 0xE0, 0x10, 0x0D, 0x90, 0xC9, 0x0D, 0x0D, 0x8D, 0x39, 0xAC, 0x25, 0x0B, 0x20, 0x77, 0x22, +/* 2450 */ 0x25, 0x0B, 0x20, 0x77, 0x22, 0x00, 0x5D, 0x0D, 0x0D, 0x8D, 0x02, 0x63, 0x05, 0xEC, 0xE0, 0x10, +/* 2460 */ 0x0D, 0x19, 0xE6, 0x0C, 0x98, 0x05, 0x51, 0x02, 0x22, 0x1A, 0x25, 0x3F, 0xB2, 0x00, 0x09, 0x0F, +/* 2470 */ 0x21, 0x3F, 0xB2, 0x00, 0x09, 0x80, 0x7F, 0x02, 0x50, 0x32, 0x03, 0x4A, 0xAB, 0x0C, 0x98, 0x05, +/* 2480 */ 0x25, 0x4F, 0xE0, 0x10, 0x12, 0x19, 0xD9, 0x60, 0x56, 0x89, 0x2C, 0x99, 0x69, 0x3E, 0x00, 0xA9, +/* 2490 */ 0x18, 0x07, 0x90, 0x32, 0x0A, 0x3A, 0x25, 0x49, 0x67, 0x04, 0x1D, 0x26, 0x30, 0x00, 0x50, 0x7C, +/* 24A0 */ 0x59, 0x0F, 0x6E, 0x0D, 0x22, 0x23, 0x23, 0x08, 0x29, 0x6F, 0x8D, 0x0B, 0x56, 0x30, 0x29, 0xF0, +/* 24B0 */ 0x19, 0xA9, 0x30, 0x62, 0x02, 0x50, 0x75, 0x19, 0x6F, 0x02, 0x94, 0x08, 0x69, 0x71, 0x94, 0x0D, +/* 24C0 */ 0x69, 0x7C, 0xAB, 0x0F, 0x22, 0x23, 0x23, 0x4D, 0x4A, 0x2A, 0x71, 0x41, 0x0C, 0x89, 0x23, 0x23, +/* 24D0 */ 0x08, 0x41, 0x6C, 0x32, 0xAA, 0x1B, 0x56, 0x30, 0x2F, 0x05, 0x6A, 0x2F, 0x2D, 0x30, 0x10, 0x0D, +/* 24E0 */ 0xD9, 0x99, 0x0A, 0xFA, 0xE9, 0x25, 0x9F, 0x46, 0x8E, 0x94, 0x9F, 0x95, 0x0B, 0x60, 0x0A, 0x47, +/* 24F0 */ 0x0F, 0x22, 0x02, 0x00, 0x99, 0x87, 0x29, 0x2A, 0x71, 0x2E, 0x0E, 0x3A, 0xA7, 0x0D, 0xC8, 0xB2, +/* 2500 */ 0x62, 0xAB, 0x6A, 0xC8, 0x30, 0x00, 0xA7, 0x0D, 0x1E, 0x42, 0x02, 0x2E, 0x09, 0x7E, 0x6C, 0x5D, +/* 2510 */ 0x0F, 0x6D, 0x9C, 0xD7, 0x0E, 0x05, 0x37, 0xA9, 0x66, 0x37, 0x2D, 0x0F, 0x87, 0x37, 0x02, 0x08, +/* 2520 */ 0x0D, 0x81, 0x8F, 0x2E, 0x0B, 0x75, 0x01, 0x1E, 0x0D, 0x89, 0x03, 0x29, 0xAB, 0x53, 0x3C, 0x02, +/* 2530 */ 0x02, 0x02, 0x53, 0x3C, 0x28, 0x1A, 0x51, 0x09, 0x63, 0x0C, 0x05, 0x10, 0x0B, 0x27, 0xA2, 0x70, +/* 2540 */ 0x05, 0x95, 0xEF, 0x0D, 0x50, 0x30, 0x8D, 0xC9, 0x4B, 0x22, 0x70, 0x05, 0xE9, 0x19, 0xB1, 0x58, +/* 2550 */ 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x62, 0x54, 0x70, 0x06, 0x0E, 0x2B, 0x00, 0xC9, 0x60, 0x81, 0x51, +/* 2560 */ 0x0D, 0x89, 0x5B, 0x51, 0x93, 0x05, 0xEC, 0x34, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x2F, 0x9F, 0xEE, +/* 2570 */ 0xA5, 0x53, 0x7F, 0x08, 0x22, 0x60, 0x09, 0x7F, 0x0C, 0x75, 0x01, 0x00, 0x08, 0x0F, 0x8E, 0xA1, +/* 2580 */ 0x04, 0x1D, 0x99, 0x01, 0x00, 0xB1, 0x58, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x4F, 0x09, 0xD0, 0xED, +/* 2590 */ 0xB1, 0x58, 0x56, 0xCE, 0x0A, 0x10, 0x06, 0x00, 0x3F, 0x03, 0x19, 0xC8, 0xA2, 0x4A, 0x26, 0x22, +/* 25A0 */ 0x05, 0x51, 0x82, 0x0D, 0x3A, 0x29, 0xAB, 0x0A, 0x08, 0xEC, 0x34, 0xF3, 0x02, 0x10, 0x06, 0x41, +/* 25B0 */ 0x6C, 0x5B, 0x1E, 0x05, 0x0D, 0x75, 0x51, 0x02, 0x7A, 0x02, 0x1D, 0x58, 0x89, 0x09, 0x8D, 0xC9, +/* 25C0 */ 0x0C, 0x9C, 0x4A, 0xB1, 0x58, 0xF3, 0x02, 0x10, 0x06, 0x1D, 0x06, 0x50, 0x5A, 0x51, 0x6F, 0x0F, +/* 25D0 */ 0x5A, 0x7F, 0x06, 0x89, 0x28, 0x5A, 0x25, 0x09, 0x0F, 0x87, 0x06, 0x0E, 0x91, 0x7F, 0x05, 0x41, +/* 25E0 */ 0x02, 0x03, 0xEC, 0x77, 0xF3, 0x02, 0x10, 0x06, 0x19, 0x70, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E, +/* 25F0 */ 0x0C, 0x02, 0x59, 0x0F, 0x6E, 0x0E, 0xA8, 0x37, 0x85, 0x7C, 0xEB, 0x77, 0xF3, 0x02, 0x10, 0x0F, +/* 2600 */ 0x29, 0x9D, 0x31, 0x22, 0x0C, 0x08, 0x03, 0x19, 0x31, 0x46, 0x80, 0x31, 0x0D, 0x0A, 0x33, 0x80, +/* 2610 */ 0xAB, 0x50, 0x80, 0x97, 0x42, 0x02, 0xAB, 0x7E, 0xA5, 0x7C, 0xAB, 0x7E, 0x04, 0x6A, 0x62, 0x3F, +/* 2620 */ 0x60, 0x81, 0x23, 0x01, 0x02, 0x0F, 0x22, 0x4A, 0x1B, 0x0F, 0x6D, 0x3A, 0x85, 0x95, 0x4A, 0x1B, +/* 2630 */ 0x0F, 0x6D, 0x3A, 0x85, 0x81, 0xAB, 0x7E, 0x02, 0x50, 0x30, 0xAB, 0x7E, 0x67, 0x0A, 0xAB, 0x7E, +/* 2640 */ 0x09, 0x4C, 0x67, 0x08, 0x19, 0x67, 0xAA, 0x2C, 0x67, 0x0D, 0x0A, 0x60, 0x6E, 0xAB, 0x0F, 0x56, +/* 2650 */ 0x6E, 0x31, 0x89, 0x0C, 0x5B, 0x10, 0x0E, 0x19, 0x4F, 0x02, 0x09, 0xB4, 0x00, 0x05, 0x04, 0x00, +/* 2660 */ 0xA1, 0x42, 0x28, 0x03, 0x25, 0x09, 0x6D, 0x6A, 0x7F, 0xB0, 0x04, 0x03, 0x0B, 0x0E, 0x5A, 0x7F, +/* 2670 */ 0x4F, 0x57, 0xCD, 0x50, 0x01, 0x62, 0x1B, 0xE5, 0xA6, 0x22, 0x03, 0x3A, 0xB7, 0x10, 0x0F, 0x1D, +/* 2680 */ 0xE6, 0x05, 0x00, 0x70, 0xFD, 0x02, 0x5E, 0x0F, 0xA2, 0x51, 0x93, 0x6D, 0xEF, 0x02, 0x08, 0x0C, +/* 2690 */ 0x00, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x2C, 0x05, 0x05, 0x1E, 0x02, 0x0B, 0x81, 0x2E, 0x08, 0x0F, +/* 26A0 */ 0xA4, 0xE4, 0x0B, 0x5B, 0x1D, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x4A, 0x02, 0xFA, 0x03, 0x51, 0x39, +/* 26B0 */ 0x0F, 0x89, 0x03, 0x7F, 0x39, 0x50, 0x0A, 0x89, 0x03, 0x41, 0xAB, 0x81, 0x04, 0x99, 0x0C, 0x2B, +/* 26C0 */ 0x2F, 0xAB, 0x01, 0xE6, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x00, 0x4F, 0x3F, 0x09, 0x05, 0x99, 0x06, +/* 26D0 */ 0x1D, 0x58, 0x6D, 0x88, 0x80, 0x1D, 0xAB, 0x56, 0x91, 0x00, 0x5D, 0x0A, 0x08, 0x54, 0x98, 0x04, +/* 26E0 */ 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x94, 0xC9, 0x0D, 0x0D, 0x04, 0x00, 0x02, 0x88, 0x05, 0x25, 0x28, +/* 26F0 */ 0x0C, 0xFB, 0x0E, 0x25, 0x28, 0x0C, 0xFB, 0x0E, 0x00, 0x5D, 0x0D, 0x0D, 0x04, 0x00, 0x02, 0x88, +/* 2700 */ 0x05, 0x7F, 0xB1, 0xC6, 0xB6, 0x10, 0x0B, 0xAE, 0x9D, 0xA1, 0x1D, 0x6C, 0x1D, 0x58, 0x0B, 0x00, +/* 2710 */ 0x3F, 0x0D, 0x02, 0x1D, 0x26, 0x80, 0x05, 0x84, 0x19, 0x67, 0x4B, 0xA8, 0x7F, 0x06, 0x46, 0x21, +/* 2720 */ 0x2A, 0x81, 0x51, 0x02, 0x42, 0x2B, 0x00, 0xA1, 0x0D, 0x50, 0x60, 0x78, 0x25, 0x28, 0x8E, 0xA5, +/* 2730 */ 0x38, 0x37, 0x39, 0x45, 0x34, 0x71, 0x00, 0xA1, 0x02, 0x19, 0x6C, 0x03, 0x10, 0x0F, 0x62, 0x52, +/* 2740 */ 0x08, 0x07, 0x8D, 0x72, 0x89, 0x1E, 0x05, 0x92, 0x25, 0x06, 0x0B, 0x42, 0x2B, 0x59, 0x0C, 0x56, +/* 2750 */ 0x30, 0x02, 0x65, 0x60, 0x81, 0x28, 0x22, 0x94, 0x06, 0x4D, 0x85, 0x4C, 0x60, 0xAA, 0x06, 0x75, +/* 2760 */ 0xF2, 0x29, 0x85, 0x30, 0x34, 0x78, 0x0A, 0x6D, 0x02, 0x62, 0x99, 0x4D, 0x00, 0x8B, 0x9F, 0x78, +/* 2770 */ 0x29, 0x67, 0x09, 0x99, 0xAF, 0xA5, 0x71, 0x2F, 0xE6, 0x0F, 0x53, 0x08, 0x2B, 0x9F, 0x2B, 0x29, +/* 2780 */ 0x02, 0x4D, 0x0C, 0xAA, 0x55, 0x71, 0x62, 0x6C, 0x6D, 0x8E, 0x30, 0x19, 0x0B, 0x6D, 0x02, 0x2C, +/* 2790 */ 0x0B, 0xA4, 0x80, 0x00, 0x0E, 0x89, 0x90, 0x6F, 0x0E, 0x5C, 0xA5, 0x80, 0x90, 0x28, 0x20, 0x0D, +/* 27A0 */ 0x6D, 0x45, 0x90, 0x6C, 0xDE, 0x22, 0x02, 0x19, 0x31, 0x95, 0x0B, 0x07, 0x25, 0x9F, 0x07, 0x1E, +/* 27B0 */ 0x0D, 0x50, 0x03, 0x1D, 0xC9, 0x07, 0x0A, 0x10, 0x0E, 0x4A, 0x5B, 0x70, 0x05, 0x95, 0x07, 0x1E, +/* 27C0 */ 0x0D, 0x6D, 0x68, 0x51, 0x02, 0x4B, 0x22, 0x70, 0x05, 0xE9, 0x25, 0xB1, 0x0E, 0x89, 0xD4, 0x10, +/* 27D0 */ 0x0E, 0x29, 0x54, 0x70, 0x06, 0x0E, 0x2B, 0x00, 0xC9, 0x60, 0x95, 0x51, 0x0C, 0x89, 0x5B, 0x51, +/* 27E0 */ 0x93, 0x05, 0x00, 0xEC, 0x0E, 0x89, 0xD4, 0x10, 0x0E, 0x27, 0x9F, 0x0A, 0x51, 0x9F, 0x53, 0x7F, +/* 27F0 */ 0x08, 0x22, 0x60, 0x09, 0x7F, 0x0B, 0x75, 0x01, 0x00, 0x07, 0x0F, 0x8E, 0xA1, 0x04, 0x1D, 0x99, +/* 2800 */ 0x01, 0x37, 0xB1, 0x0E, 0x89, 0xD4, 0x10, 0x0E, 0x00, 0x4F, 0xED, 0x5D, 0x0F, 0x1A, 0x02, 0xA4, +/* 2810 */ 0x5D, 0x0F, 0x1A, 0x02, 0xA4, 0x25, 0xED, 0x65, 0xB1, 0x0E, 0x89, 0xD4, 0x10, 0x0D, 0x29, 0x06, +/* 2820 */ 0x05, 0x1D, 0xC9, 0x0B, 0x81, 0x51, 0x54, 0x0F, 0xA4, 0x3C, 0x06, 0x6A, 0x05, 0x2E, 0x0C, 0x5B, +/* 2830 */ 0x3C, 0x4F, 0x72, 0x42, 0xC3, 0x6D, 0xD8, 0x2E, 0x06, 0xA4, 0x10, 0x0D, 0xE7, 0x40, 0x6D, 0x89, +/* 2840 */ 0x0B, 0x73, 0x58, 0x56, 0x89, 0x8D, 0x26, 0x20, 0x0B, 0x42, 0x38, 0x26, 0x7B, 0x01, 0x0C, 0xA4, +/* 2850 */ 0x00, 0x1F, 0x49, 0x09, 0x26, 0x7B, 0x97, 0x4D, 0x1F, 0x6F, 0x09, 0x26, 0x7B, 0x01, 0x0C, 0xA4, +/* 2860 */ 0x26, 0x20, 0x0B, 0x42, 0x45, 0x26, 0x46, 0x89, 0x8D, 0x26, 0x50, 0x89, 0x0C, 0x73, 0x58, 0x40, +/* 2870 */ 0x6D, 0x02, 0x10, 0x0D, 0x19, 0x52, 0xD7, 0x09, 0x0A, 0x09, 0x05, 0xC9, 0x0D, 0x6D, 0x22, 0x02, +/* 2880 */ 0x59, 0x0D, 0x46, 0x20, 0x37, 0x6F, 0x73, 0x0A, 0x3A, 0x2C, 0x1B, 0x6D, 0x19, 0x6F, 0x37, 0x8C, +/* 2890 */ 0x00, 0xFB, 0x09, 0x37, 0x8C, 0x99, 0x50, 0x45, 0x37, 0x8C, 0x00, 0x28, 0x05, 0x25, 0x28, 0x38, +/* 28A0 */ 0x66, 0x25, 0x8C, 0x00, 0x6D, 0x8E, 0x37, 0x8C, 0x77, 0x6D, 0x8E, 0x65, 0x8C, 0x6C, 0x33, 0x45, +/* 28B0 */ 0x94, 0x8C, 0x00, 0x6C, 0x0D, 0x4C, 0x00, 0x8C, 0x19, 0x99, 0x50, 0x30, 0x94, 0x8C, 0x41, 0x0D, +/* 28C0 */ 0x22, 0x94, 0x8C, 0x19, 0x6C, 0x32, 0x0C, 0x94, 0x8C, 0x99, 0x7D, 0x7E, 0x29, 0x8C, 0xFB, 0x50, +/* 28D0 */ 0x45, 0x94, 0x8C, 0x00, 0x88, 0x81, 0xA2, 0x10, 0x0C, 0x65, 0xEC, 0xA6, 0x70, 0x05, 0x0F, 0x75, +/* 28E0 */ 0x86, 0x60, 0x81, 0x04, 0x51, 0x4E, 0x0D, 0x84, 0x62, 0x93, 0x08, 0x7F, 0xB1, 0xC5, 0xBD, 0x10, +/* 28F0 */ 0x0C, 0xAE, 0x05, 0x08, 0x1E, 0xAD, 0x5C, 0x3C, 0xA3, 0x4D, 0x19, 0x76, 0x0C, 0x06, 0x2F, 0x58, +/* 2900 */ 0x5F, 0x19, 0xEC, 0xC5, 0xBD, 0x10, 0x0C, 0x52, 0x1B, 0x6E, 0x51, 0x09, 0x0F, 0xA4, 0x37, 0x2A, +/* 2910 */ 0x7D, 0x0F, 0x71, 0xA1, 0x0E, 0x75, 0x6C, 0x0B, 0x30, 0x3B, 0x05, 0x41, 0x9C, 0x90, 0x4F, 0xC5, +/* 2920 */ 0xBD, 0x10, 0x0C, 0x19, 0x52, 0x05, 0x09, 0x73, 0x00, 0x07, 0x02, 0x7F, 0x49, 0x0E, 0x0C, 0x81, +/* 2930 */ 0x7F, 0x42, 0xA4, 0x25, 0x54, 0x0C, 0x02, 0x05, 0x63, 0x08, 0x7F, 0xB1, 0xC5, 0xBD, 0x10, 0x0C, +/* 2940 */ 0x52, 0xFC, 0x06, 0x3A, 0x05, 0x66, 0x37, 0x06, 0x3A, 0x05, 0x66, 0x37, 0xFC, 0xB1, 0xC5, 0xBD, +/* 2950 */ 0x10, 0x0C, 0x94, 0xEC, 0x9B, 0x8B, 0x09, 0x01, 0x51, 0x0C, 0x0F, 0x8B, 0x75, 0x3C, 0x02, 0x50, +/* 2960 */ 0x01, 0x04, 0x95, 0x3C, 0x02, 0x50, 0x01, 0x04, 0x95, 0x51, 0x0C, 0x0F, 0x8B, 0x75, 0x51, 0x9B, +/* 2970 */ 0x8B, 0xA2, 0x94, 0x4F, 0xC5, 0xBD, 0x10, 0x13, 0x90, 0x1C, 0xD7, 0x0A, 0x0D, 0x8B, 0x0B, 0x04, +/* 2980 */ 0x00, 0xB0, 0x8B, 0x0B, 0x05, 0x29, 0x05, 0x0F, 0x56, 0x0A, 0x46, 0x7C, 0x29, 0x8B, 0x0C, 0x0B, +/* 2990 */ 0x32, 0x6A, 0x0D, 0x66, 0x62, 0x02, 0x19, 0x6C, 0x32, 0x78, 0x19, 0x0D, 0x53, 0x2C, 0x6C, 0x0D, +/* 29A0 */ 0x89, 0x2A, 0x0D, 0x41, 0xE6, 0x0B, 0x32, 0x50, 0x69, 0x27, 0x9F, 0x46, 0x69, 0x27, 0x02, 0x50, +/* 29B0 */ 0x30, 0x8D, 0x0B, 0x6D, 0x23, 0x18, 0x27, 0x06, 0xA4, 0x19, 0x08, 0x3A, 0x94, 0x64, 0x07, 0x6C, +/* 29C0 */ 0x0C, 0x7E, 0x05, 0x03, 0x4A, 0x67, 0xB2, 0x9A, 0xA0, 0xFA, 0x02, 0x4A, 0x7A, 0x81, 0x03, 0x0D, +/* 29D0 */ 0x56, 0xAC, 0x4A, 0x54, 0x0D, 0x81, 0xA2, 0x00, 0x4E, 0x88, 0x98, 0xA2, 0x10, 0x0A, 0x1C, 0x47, +/* 29E0 */ 0x0A, 0xFA, 0xA6, 0x7F, 0x6F, 0x0F, 0x66, 0x5D, 0x0F, 0x6A, 0x0D, 0xAF, 0x37, 0x28, 0x5C, 0x97, +/* 29F0 */ 0x01, 0x59, 0x6A, 0xC8, 0x75, 0x4A, 0x31, 0xEE, 0x67, 0x09, 0x72, 0x6D, 0x8A, 0x33, 0x73, 0x02, +/* 2A00 */ 0xA2, 0x1D, 0x31, 0x0F, 0x6A, 0x7F, 0x6F, 0x0F, 0x89, 0x03, 0x7F, 0x02, 0xA5, 0x0C, 0x08, 0x86, +/* 2A10 */ 0x0F, 0x71, 0x19, 0xA7, 0x8A, 0x54, 0x0F, 0x71, 0x00, 0xC9, 0xD7, 0x0F, 0x71, 0x19, 0xA1, 0x42, +/* 2A20 */ 0x38, 0x3C, 0x02, 0x0B, 0x8B, 0x0B, 0x03, 0x10, 0x0C, 0x65, 0xEC, 0x06, 0x07, 0x19, 0x72, 0x0E, +/* 2A30 */ 0x30, 0x02, 0x2E, 0x64, 0x7C, 0x2E, 0x05, 0x28, 0x71, 0x1E, 0x83, 0x0C, 0x00, 0xEC, 0x93, 0xB9, +/* 2A40 */ 0x89, 0xB8, 0x10, 0x0C, 0xAE, 0x9B, 0x01, 0x51, 0x3F, 0x0E, 0x80, 0x3C, 0x02, 0x33, 0x38, 0x3C, +/* 2A50 */ 0x0C, 0x89, 0x5B, 0x51, 0xB0, 0x9C, 0x1D, 0xEC, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x0C, 0x1D, 0x52, +/* 2A60 */ 0x05, 0x50, 0x8E, 0x51, 0x49, 0xB2, 0x27, 0xAB, 0x89, 0x28, 0x0A, 0x19, 0x58, 0x30, 0x02, 0x00, +/* 2A70 */ 0x07, 0x50, 0x03, 0x25, 0x4E, 0x1D, 0x99, 0x48, 0x4F, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x0C, 0x51, +/* 2A80 */ 0xAE, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E, 0x8E, 0x59, 0x0F, 0x6E, 0x0F, 0xA8, 0x59, 0xA4, 0xEB, +/* 2A90 */ 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x06, 0x2C, 0xEC, 0x08, 0x05, 0x70, 0x02, 0x50, 0x87, 0x25, 0x2A, +/* 2AA0 */ 0x95, 0x06, 0x2E, 0xB0, 0x66, 0x1D, 0xC9, 0x23, 0x2E, 0x4F, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x94, +/* 2AB0 */ 0xB1, 0xC9, 0x0A, 0x1E, 0x9F, 0x05, 0x00, 0xC9, 0x0D, 0x50, 0x30, 0x19, 0xA1, 0x0E, 0x22, 0x73, +/* 2AC0 */ 0x7F, 0x3F, 0x0C, 0x05, 0x19, 0xB1, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x52, 0xA5, 0x0A, 0x2E, 0x64, +/* 2AD0 */ 0x75, 0x3C, 0x06, 0x22, 0x0C, 0xA8, 0x7F, 0x0C, 0x0F, 0x5A, 0x00, 0x09, 0x0F, 0x38, 0x25, 0x82, +/* 2AE0 */ 0x41, 0x05, 0x8D, 0x70, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x3C, 0xAE, 0x09, 0xD0, 0xED, 0xEC, 0x8C, +/* 2AF0 */ 0xE1, 0xE1, 0x10, 0x0D, 0xAE, 0x6C, 0x51, 0x02, 0x01, 0x19, 0x06, 0x0E, 0x03, 0x3C, 0x0C, 0x30, +/* 2B00 */ 0x08, 0x22, 0x00, 0xA1, 0x6D, 0x66, 0x27, 0xAB, 0x7A, 0x0A, 0x3C, 0xF9, 0x4D, 0x25, 0x02, 0x09, +/* 2B10 */ 0xAC, 0x08, 0xA4, 0x19, 0xA1, 0x19, 0xF0, 0x2F, 0xAB, 0x09, 0x0A, 0x07, 0x06, 0x6B, 0x9F, 0x22, +/* 2B20 */ 0x7E, 0x2C, 0x05, 0x56, 0x6A, 0x65, 0x60, 0xAC, 0xD7, 0x50, 0x30, 0x94, 0x02, 0x50, 0x75, 0x1D, +/* 2B30 */ 0x0C, 0x89, 0x31, 0x07, 0x1D, 0x0C, 0x89, 0x31, 0x07, 0x1D, 0x0D, 0x3E, 0x19, 0x02, 0x7E, 0x32, +/* 2B40 */ 0x09, 0x65, 0x0D, 0x50, 0x45, 0x00, 0x05, 0x6B, 0x6F, 0x0D, 0x28, 0x30, 0x94, 0x2A, 0x50, 0x22, +/* 2B50 */ 0x02, 0x7F, 0x93, 0x0E, 0x98, 0xA2, 0x10, 0x0D, 0x19, 0x52, 0x54, 0x8F, 0x97, 0x05, 0x00, 0xA1, +/* 2B60 */ 0x0D, 0x6D, 0x60, 0x05, 0x25, 0x2D, 0x0D, 0x2F, 0xAB, 0x0C, 0x06, 0x9B, 0x0E, 0x0C, 0x02, 0x25, +/* 2B70 */ 0xB1, 0x28, 0x5B, 0xE3, 0x7A, 0x88, 0x6B, 0x28, 0x80, 0x6F, 0xE2, 0x19, 0x67, 0xE2, 0x19, 0x67, +/* 2B80 */ 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x0D, 0x19, 0xEC, 0xAB, 0xA2, 0x70, 0x0C, 0x81, 0x04, 0x4A, 0x31, +/* 2B90 */ 0x75, 0x01, 0x00, 0xC9, 0x0A, 0x7E, 0x3C, 0x02, 0x08, 0x45, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6, +/* 2BA0 */ 0x10, 0x0D, 0xEC, 0xA1, 0x96, 0x1E, 0xA3, 0xAF, 0x3C, 0xAD, 0x6D, 0x02, 0x1D, 0x58, 0x89, 0x8F, +/* 2BB0 */ 0x51, 0x39, 0x73, 0x1D, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x90, 0xAE, 0xAB, 0x0E, +/* 2BC0 */ 0x81, 0x02, 0x00, 0xC9, 0x42, 0x8E, 0x7F, 0xF9, 0x0A, 0x50, 0x8E, 0x25, 0x08, 0x81, 0x8D, 0xA3, +/* 2BD0 */ 0x71, 0x7F, 0x73, 0x1D, 0x02, 0xEF, 0x70, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x19, 0x52, +/* 2BE0 */ 0x54, 0x8F, 0x97, 0x05, 0x00, 0xA1, 0x33, 0x88, 0x2B, 0x25, 0x2D, 0x45, 0x41, 0xAB, 0xE9, 0x9B, +/* 2BF0 */ 0x0E, 0x0C, 0x02, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x00, 0x52, 0xA3, 0x0C, 0x02, +/* 2C00 */ 0x97, 0x98, 0x03, 0x25, 0x0E, 0x53, 0xE8, 0x25, 0x0E, 0x53, 0x60, 0x0A, 0x25, 0xA3, 0x0C, 0x02, +/* 2C10 */ 0x97, 0x98, 0x03, 0x7F, 0xB1, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0B, 0x00, 0xD9, 0xF5, 0x0A, +/* 2C20 */ 0x27, 0x58, 0x0E, 0x0C, 0x02, 0x29, 0xAE, 0x23, 0x18, 0xFF, 0x46, 0x1A, 0xEC, 0xF5, 0x0A, 0x27, +/* 2C30 */ 0x58, 0x0E, 0x0C, 0x02, 0x10, 0x0D, 0x41, 0xD9, 0x02, 0x09, 0x05, 0x01, 0x51, 0x3F, 0x50, 0xEF, +/* 2C40 */ 0x60, 0x01, 0x2F, 0xAB, 0x0B, 0x32, 0x30, 0x7F, 0xA9, 0x0E, 0x05, 0x37, 0x49, 0x0E, 0x33, 0x91, +/* 2C50 */ 0x65, 0x60, 0x0C, 0x54, 0x81, 0x53, 0x90, 0x85, 0x71, 0x00, 0x0D, 0x0D, 0x07, 0x89, 0x31, 0x02, +/* 2C60 */ 0x02, 0x75, 0x05, 0x3A, 0x90, 0x67, 0x82, 0x78, 0x67, 0x02, 0x2C, 0x99, 0x6D, 0x02, 0x0B, 0x0E, +/* 2C70 */ 0x00, 0x05, 0x3A, 0x90, 0x85, 0x71, 0xAF, 0x07, 0x89, 0x65, 0xF0, 0x2B, 0x39, 0x92, 0x31, 0x0F, +/* 2C80 */ 0x88, 0x66, 0x37, 0x2D, 0x2B, 0x7F, 0x32, 0x95, 0xA6, 0x3B, 0x92, 0x51, 0x9F, 0x05, 0x1E, 0x02, +/* 2C90 */ 0x06, 0x87, 0x10, 0x0C, 0x90, 0xEC, 0x3F, 0xEF, 0x6C, 0x0E, 0xB2, 0x02, 0x51, 0x9F, 0x95, 0x07, +/* 2CA0 */ 0x2E, 0x93, 0x6B, 0x4A, 0x83, 0x0B, 0x7F, 0xB1, 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0xAE, 0x9B, +/* 2CB0 */ 0x2E, 0x3F, 0x6E, 0xC9, 0x60, 0x95, 0x51, 0x0D, 0x89, 0xA2, 0x51, 0x06, 0x0C, 0x06, 0x19, 0xEC, +/* 2CC0 */ 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0x1D, 0x52, 0x06, 0x20, 0x5E, 0xAF, 0x2F, 0xAB, 0x89, 0x28, +/* 2CD0 */ 0x0A, 0x7F, 0x0B, 0x30, 0x02, 0x00, 0x07, 0x0F, 0x91, 0x25, 0x4E, 0xE6, 0x04, 0x90, 0x4F, 0x0D, +/* 2CE0 */ 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0x00, 0x52, 0x4B, 0xB5, 0x5A, 0x37, 0xB1, 0x0D, 0xCA, 0xBC, 0xC4, +/* 2CF0 */ 0x10, 0x0B, 0xAE, 0x07, 0xEF, 0x02, 0x0C, 0x0F, 0x38, 0x51, 0x64, 0x7C, 0xE4, 0x0C, 0x09, 0x8D, +/* 2D00 */ 0xEC, 0x32, 0xBE, 0x05, 0x10, 0x0D, 0xF1, 0x35, 0x9B, 0x8B, 0x0B, 0x03, 0x37, 0x28, 0x81, 0x6D, +/* 2D10 */ 0xCC, 0x01, 0x32, 0xDF, 0x94, 0xC2, 0x65, 0x28, 0x20, 0x0E, 0xA4, 0x65, 0x28, 0x95, 0x0F, 0x6A, +/* 2D20 */ 0x37, 0x8C, 0x03, 0x0C, 0x81, 0xA2, 0x37, 0x8C, 0x35, 0x35, 0x35, 0x1E, 0x09, 0x0B, 0x09, 0x07, +/* 2D30 */ 0x10, 0x0B, 0x52, 0x02, 0x88, 0x05, 0x6C, 0x88, 0x06, 0x25, 0x09, 0x89, 0x9F, 0xAA, 0x65, 0x09, +/* 2D40 */ 0x89, 0x9F, 0x0F, 0x25, 0x02, 0x88, 0x05, 0x6C, 0x88, 0x06, 0x37, 0xB1, 0x32, 0xBE, 0x05, 0x10, +/* 2D50 */ 0x00, 0x00, 0x00, 0x0E, 0x00, 0x1F, 0x00, 0x0E, 0x0C, 0x41, 0x44, 0x3F, 0x18, 0x18, 0x08, 0x26, +/* 2D60 */ 0x69, 0x0C, 0x26, 0x69, 0x0C, 0x10, 0x0B, 0x27, 0x44, 0x05, 0x23, 0x23, 0x18, 0x09, 0x94, 0x9F, +/* 2D70 */ 0x46, 0x22, 0x94, 0x9F, 0x46, 0x22, 0x10, 0x11, 0x27, 0x44, 0x05, 0x18, 0x18, 0x18, 0x09, 0x4A, +/* 2D80 */ 0xA9, 0x69, 0x0D, 0x4A, 0xA9, 0x69, 0x0D, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, +/* 2D90 */ 0x00, 0x00, 0x08, 0x75, 0x00, 0x00, 0x08, 0x77, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, +/* 2DA0 */ 0x00, 0x00, 0x08, 0x7A, 0x00, 0x00, 0x09, 0x38, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, +/* 2DB0 */ 0x00, 0x00, 0x1C, 0x10, 0x00, 0x00, 0x1C, 0xD0, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, +/* 2DC0 */ 0x00, 0x00, 0x2D, 0x50, 0x00, 0x00, 0x2D, 0x58, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Bold32.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Bold32.mcufont.h new file mode 100644 index 000000000..8e3aa22c5 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Bold32.mcufont.h @@ -0,0 +1,1049 @@ +/* + * LWS MCUFONT Fira Sans Condensed Bold 32 + * blob size: 16429, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C, +/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x08, 0x74, 0x00, 0x00, 0x08, 0xE9, 0x00, 0x00, 0x00, 0xA9, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x3F, 0xED, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x1F, 0x00, 0x2A, 0x00, 0x07, 0x00, 0x1E, 0x00, 0x02, 0x00, 0x21, 0x00, 0x26, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x33, 0x32, 0x00, +/* short name */ +0x46, 0x69, 0x72, 0x61, +/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F, +/* 0070 */ 0x6C, 0x64, 0x33, 0x32, 0x00, +/* dictionary data */ +0x82, 0xC6, 0x0A, 0x10, 0xC5, 0x80, 0xCD, 0xC6, 0x0E, 0xC8, 0x83, +/* 0080 */ 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, +/* 0090 */ 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, +/* 00A0 */ 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x0E, 0xC8, 0x83, +/* 00B0 */ 0xC8, 0x05, 0xCC, 0x83, 0xC6, 0x06, 0x02, 0xCE, 0x81, 0x82, 0x14, 0x83, 0xC2, 0x01, 0xC8, 0x19, +/* 00C0 */ 0x82, 0xCC, 0x83, 0xCE, 0x11, 0xC7, 0x83, 0xC7, 0x03, 0x0F, 0x19, 0xC5, 0x83, 0xC9, 0x19, 0xC5, +/* 00D0 */ 0x83, 0xC9, 0x04, 0xDB, 0xCB, 0x82, 0x12, 0x01, 0xC3, 0xFB, 0xEB, 0x19, 0xC4, 0x83, 0xCD, 0x19, +/* 00E0 */ 0xC4, 0x83, 0xCD, 0x19, 0xC4, 0x83, 0xCD, 0x19, 0xC4, 0x83, 0xCD, 0x19, 0xC4, 0x81, 0xC5, 0x83, +/* 00F0 */ 0x10, 0xC7, 0xC6, 0xC3, 0x85, 0x82, 0xC9, 0xC1, 0x82, 0x82, 0xCD, 0x02, 0xC1, 0xCE, 0x80, 0xCC, +/* 0100 */ 0x16, 0xC7, 0xCE, 0x1C, 0xC8, 0x01, 0x80, 0xC8, 0x42, 0x3D, 0xC5, 0xC1, 0xC4, 0x85, 0xC6, 0x19, +/* 0110 */ 0xC4, 0xC6, 0x82, 0xC1, 0x86, 0xC7, 0x83, 0x42, 0x02, 0x80, 0xC7, 0x01, 0x09, 0x82, 0xCA, 0x1A, +/* 0120 */ 0xC7, 0xC1, 0x84, 0x19, 0x01, 0xC6, 0x40, 0x23, 0x11, 0xC4, 0x19, 0x04, 0x0E, 0xCB, 0x83, 0xC6, +/* 0130 */ 0x02, 0xCA, 0x83, 0x80, 0xC6, 0x46, 0x07, 0xCD, 0xCE, 0x84, 0xC5, 0x05, 0x82, 0xCB, 0x0D, 0x83, +/* 0140 */ 0xC4, 0xC6, 0x83, 0x80, 0xC4, 0x02, 0x8A, 0x83, 0xCA, 0x02, 0xD4, 0xC8, 0xC2, 0xCD, 0xC1, 0x01, +/* 0150 */ 0x10, 0xC4, 0x80, 0x02, 0xC8, 0xC2, 0xCC, 0xC9, 0x83, 0x82, 0xC7, 0x0B, 0xC6, 0xCC, 0x0F, 0xCB, +/* 0160 */ 0x82, 0xCD, 0xC6, 0xD7, 0xC5, 0xC2, 0x15, 0xCE, 0x82, 0xCE, 0xC4, 0x01, 0x36, 0x13, 0x01, 0xC5, +/* 0170 */ 0x80, 0xC5, 0x02, 0x80, 0xCE, 0x83, 0xC1, 0xCA, 0x81, 0xC8, 0xC1, 0x43, 0x39, 0xCD, 0xC3, 0x83, +/* 0180 */ 0xCC, 0x02, 0x82, 0xC5, 0xCC, 0xC1, 0x0C, 0xC5, 0x83, 0xC9, 0x0B, 0x18, 0x01, 0xC2, 0x1A, 0x83, +/* 0190 */ 0xC5, 0x01, 0x83, 0xC9, 0x03, 0xCB, 0x83, 0xC3, 0x10, 0xC5, 0x83, 0xC9, 0x03, 0xCB, 0x83, 0xC3, +/* 01A0 */ 0x10, 0xC5, 0x83, 0xC9, 0x03, 0xCB, 0x83, 0x43, 0x20, 0xC4, 0xCA, 0x80, 0xC3, 0x02, 0x01, 0xC8, +/* 01B0 */ 0xCE, 0xC2, 0xCD, 0x83, 0xCE, 0x81, 0xFB, 0xC8, 0x12, 0xCA, 0x8A, 0xCB, 0x12, 0xCA, 0x8A, 0xCB, +/* 01C0 */ 0x12, 0xCA, 0x8A, 0xCB, 0x08, 0xCD, 0xC2, 0x82, 0xC8, 0x01, 0xCA, 0x82, 0x07, 0x06, 0x82, 0xCE, +/* 01D0 */ 0x01, 0x83, 0xC9, 0xC1, 0xC5, 0x01, 0xCC, 0x41, 0x07, 0xC1, 0xC7, 0xCB, 0xCE, 0x43, 0x0B, 0x82, +/* 01E0 */ 0xC2, 0x83, 0xC4, 0xC1, 0x1B, 0x80, 0xC1, 0xC9, 0xC1, 0xCE, 0x88, 0xC9, 0xC2, 0xCE, 0xCC, 0xC1, +/* 01F0 */ 0xCB, 0x81, 0xC8, 0xCE, 0x01, 0xC1, 0x82, 0xCA, 0x80, 0xC2, 0xCE, 0xC1, 0x80, 0xC9, 0x02, 0x15, +/* 0200 */ 0xCA, 0xC3, 0x11, 0xC1, 0x02, 0xCD, 0xCE, 0x83, 0x03, 0x0E, 0x01, 0xC9, 0x82, 0x83, 0xCB, 0x02, +/* 0210 */ 0xCC, 0x81, 0x02, 0xCB, 0x84, 0x84, 0xCB, 0x81, 0xCC, 0x02, 0xDD, 0x80, 0xCB, 0xC3, 0xC6, 0xC7, +/* 0220 */ 0xDC, 0xC8, 0x85, 0xCE, 0xCD, 0xC7, 0xC6, 0xC1, 0xC9, 0x02, 0xC4, 0x41, 0x26, 0x40, 0x05, 0xCD, +/* 0230 */ 0xC4, 0x17, 0x79, 0xAB, 0xAA, 0x4C, 0x79, 0xAB, 0xAA, 0x4C, 0x79, 0xAB, 0xAA, 0x4C, 0x3D, 0x2C, +/* 0240 */ 0x70, 0x4C, 0x3D, 0x97, 0x6F, 0x2E, 0xBC, 0x1E, 0x6F, 0x26, 0x26, 0x26, 0x09, 0x2E, 0xBC, 0x1E, +/* 0250 */ 0x1B, 0x2B, 0x1E, 0x6F, 0x0B, 0x26, 0x26, 0x09, 0x6C, 0x3D, 0x1E, 0x1B, 0x6C, 0x3D, 0x1E, 0x1B, +/* 0260 */ 0x6C, 0x3D, 0x1E, 0x1B, 0xAB, 0x60, 0x33, 0xA6, 0xBC, 0x1E, 0x1B, 0x2B, 0x1E, 0x6F, 0x2A, 0x02, +/* 0270 */ 0x00, 0x60, 0x41, 0x58, 0x00, 0x60, 0x41, 0x58, 0x00, 0x60, 0x41, 0x66, 0x82, 0xA9, 0x8E, 0x24, +/* 0280 */ 0x07, 0x1E, 0x6E, 0xA1, 0x5C, 0x57, 0x29, 0x1E, 0x3A, 0xAB, 0x2D, 0x06, 0x4C, 0x0E, 0x56, 0x00, +/* 0290 */ 0x61, 0x20, 0x2E, 0x71, 0x6F, 0xAB, 0x27, 0x0D, 0x28, 0x59, 0x02, 0x1D, 0xA5, 0x24, 0x7C, 0x7E, +/* 02A0 */ 0x02, 0x58, 0x4C, 0xA9, 0x1E, 0x07, 0x6D, 0x70, 0x6C, 0x09, 0xA2, 0xAD, 0x0B, 0x4E, 0x1A, 0x2C, +/* 02B0 */ 0x1B, 0x91, 0x64, 0x88, 0xA1, 0x70, 0x97, 0x03, 0x1F, 0x91, 0x1E, 0x07, 0x1E, 0x0F, 0xB5, 0x2C, +/* 02C0 */ 0x54, 0x36, 0x32, 0x70, 0xC0, 0xB1, 0x0C, 0x7B, 0x7C, 0x97, 0x07, 0x49, 0x8B, 0xA3, 0x36, 0x61, +/* 02D0 */ 0x5C, 0x28, 0xBC, 0x08, 0x85, 0x84, 0x8C, 0x66, 0x76, 0xC0, 0x63, 0xBF, 0xC0, 0x4A, 0xB9, 0x0A, +/* 02E0 */ 0x05, 0x03, 0xAB, 0x1A, 0x70, 0x03, 0x85, 0x0A, 0x28, 0x2D, 0x37, 0x48, 0x44, 0x1A, 0x5B, 0x6F, +/* 02F0 */ 0x4C, 0x2D, 0x6F, 0x06, 0x2D, 0xA3, 0x2E, 0x2D, 0x82, 0x0C, 0x97, 0x03, 0x1A, 0x7F, 0x03, 0x1A, +/* 0300 */ 0x04, 0xAB, 0x32, 0x51, 0xAC, 0x3D, 0x08, 0xAB, 0x32, 0x51, 0xAC, 0x3D, 0x0D, 0xAB, 0x32, 0x51, +/* 0310 */ 0xAC, 0x3D, 0xA3, 0xB0, 0x32, 0x51, 0xAC, 0x3D, 0x44, 0xA1, 0x0F, 0x18, 0x78, 0xBC, 0x2C, 0x6F, +/* 0320 */ 0x0F, 0xB3, 0x32, 0x51, 0x78, 0xBC, 0x56, 0x70, 0xA1, 0x0F, 0x18, 0x78, 0xBC, 0x22, 0x0B, 0x18, +/* 0330 */ 0xA1, 0x0F, 0x18, 0x78, 0xBC, 0x2C, 0x6F, 0x06, 0xA2, 0xA1, 0x0F, 0x18, 0x78, 0xBC, 0x0F, 0x96, +/* 0340 */ 0x8E, 0x32, 0x51, 0x78, 0xBC, 0x70, 0x0C, 0x1E, 0x98, 0x0F, 0x18, 0x78, 0xBC, 0x0F, 0x96, 0x07, +/* 0350 */ 0x31, 0x00, 0x0F, 0x18, 0x78, 0xBC, 0x97, 0x03, 0x03, 0x8E, 0x0E, 0x18, 0x78, 0xBC, 0x97, 0x03, +/* 0360 */ 0x00, 0x0D, 0x1E, 0x03, 0x0E, 0x18, 0x78, 0xBC, 0x97, 0x03, 0xAD, 0x08, 0x0C, 0x18, 0x78, 0xBC, +/* 0370 */ 0x58, 0x00, 0x04, 0x22, 0x0B, 0x18, 0x78, 0xBC, 0x58, 0x1D, 0xB5, 0x18, 0x78, 0xBC, 0x1E, 0x5A, +/* 0380 */ 0x71, 0x1B, 0x18, 0x78, 0xBC, 0x58, 0x00, 0x6D, 0x30, 0x7B, 0x07, 0x0E, 0x46, 0x0E, 0x46, 0x0E, +/* 0390 */ 0x46, 0x0E, 0x46, 0x0E, 0x46, 0x0E, 0x00, 0x7C, 0x94, 0x0B, 0x02, 0x4C, 0x61, 0x8E, 0x00, 0x0B, +/* 03A0 */ 0x56, 0x6C, 0x0B, 0x20, 0x86, 0x6F, 0x4C, 0x61, 0x33, 0x0B, 0x56, 0xB0, 0xA8, 0x0A, 0x9E, 0x03, +/* 03B0 */ 0x00, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, +/* 03C0 */ 0x21, 0x02, 0x0C, 0x97, 0x1C, 0x8D, 0x61, 0x8F, 0x4E, 0x91, 0x7E, 0x78, 0x4A, 0xAE, 0x55, 0xAA, +/* 03D0 */ 0x03, 0x57, 0x29, 0x97, 0xA4, 0x00, 0xBC, 0x1E, 0x6F, 0x24, 0x91, 0x97, 0x67, 0x04, 0x07, 0x69, +/* 03E0 */ 0x3A, 0x60, 0x5B, 0x5F, 0x2E, 0x59, 0x30, 0x74, 0x4C, 0xBC, 0xB1, 0x6F, 0x9B, 0xA6, 0x7C, 0x05, +/* 03F0 */ 0x07, 0xBA, 0x04, 0x49, 0x2D, 0x8F, 0xC0, 0x61, 0x8F, 0xC0, 0x61, 0x8F, 0xC0, 0x61, 0x8F, 0xC0, +/* 0400 */ 0x61, 0x8F, 0xC0, 0x61, 0x8F, 0xC0, 0x61, 0x04, 0x22, 0x7B, 0xBC, 0x22, 0x7B, 0xBC, 0x22, 0x7B, +/* 0410 */ 0xBC, 0x22, 0x36, 0x71, 0x41, 0x96, 0x4C, 0x71, 0x41, 0x96, 0x4C, 0x71, 0x41, 0x96, 0x4C, 0x07, +/* 0420 */ 0x0B, 0x26, 0x0C, 0x2C, 0x6F, 0x26, 0x26, 0x01, 0x6C, 0xBC, 0x22, 0x08, 0x4E, 0x91, 0x97, 0x1C, +/* 0430 */ 0x8D, 0x61, 0x1E, 0x3A, 0x55, 0x7A, 0xBC, 0x1E, 0x1B, 0x4E, 0xAD, 0x3A, 0x78, 0xBC, 0x1E, 0x1B, +/* 0440 */ 0x4E, 0xAD, 0x3A, 0x78, 0xBC, 0x1E, 0x1B, 0x4E, 0xAD, 0x3A, 0x78, 0xBC, 0x1E, 0xB0, 0x07, 0x33, +/* 0450 */ 0x24, 0xBC, 0x97, 0xB0, 0x07, 0x2C, 0x1B, 0x42, 0x07, 0xAB, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, +/* 0460 */ 0x23, 0x23, 0x23, 0x23, 0x23, 0x1E, 0x6F, 0x4C, 0x2C, 0x05, 0x55, 0x91, 0x0F, 0x18, 0x57, 0x09, +/* 0470 */ 0xAE, 0x4E, 0x7C, 0x97, 0xA4, 0x78, 0x29, 0x0F, 0x70, 0xB0, 0x61, 0x0F, 0x8A, 0x4F, 0xA9, 0x70, +/* 0480 */ 0x57, 0xBC, 0xAE, 0xB0, 0x29, 0x5C, 0x57, 0xA9, 0x70, 0xB0, 0x63, 0x03, 0x4C, 0x59, 0x06, 0x1D, +/* 0490 */ 0xB5, 0x28, 0x34, 0x56, 0x00, 0x04, 0x7E, 0x2E, 0x61, 0x0F, 0x96, 0x09, 0x33, 0x4C, 0x7C, 0x97, +/* 04A0 */ 0x37, 0x18, 0xA6, 0x8B, 0x69, 0xA4, 0x1F, 0x29, 0x30, 0x3A, 0xA6, 0xAF, 0x20, 0x8D, 0x1A, 0x2C, +/* 04B0 */ 0xA2, 0x49, 0xAA, 0x4D, 0x85, 0x4D, 0x85, 0x4D, 0x85, 0x4D, 0x85, 0x4D, 0x85, 0x4D, 0x85, 0x4D, +/* 04C0 */ 0x85, 0x4D, 0x0D, 0x58, 0xAC, 0xAF, 0x0C, 0x4E, 0xA9, 0x2C, 0x09, 0x24, 0xAF, 0x0C, 0x4E, 0x6D, +/* 04D0 */ 0x96, 0x01, 0x97, 0x21, 0x32, 0x3A, 0x0F, 0x22, 0x02, 0x06, 0x8E, 0x4C, 0xBC, 0x0E, 0x4C, 0x59, +/* 04E0 */ 0x0D, 0x3F, 0x69, 0x6F, 0x2E, 0x7C, 0x5B, 0x6F, 0x28, 0xB1, 0x1B, 0x09, 0x8E, 0xA8, 0x0C, 0x18, +/* 04F0 */ 0x19, 0xA1, 0x8B, 0x35, 0x88, 0x09, 0x0F, 0x1B, 0x45, 0xBC, 0x85, 0x35, 0x8D, 0xA1, 0x86, 0x07, +/* 0500 */ 0x7A, 0x27, 0x86, 0x0C, 0x8C, 0x07, 0x2C, 0xA4, 0x19, 0x7C, 0x0E, 0x74, 0x0C, 0xB3, 0xAB, 0x1D, +/* 0510 */ 0x08, 0x78, 0x29, 0xAF, 0x0C, 0x55, 0x4A, 0x40, 0x02, 0x05, 0x07, 0x2F, 0xA6, 0xBC, 0x0C, 0x30, +/* 0520 */ 0x67, 0x1F, 0xB8, 0xAE, 0x01, 0x24, 0x61, 0x41, 0xB2, 0x24, 0x29, 0x2C, 0xA2, 0x5D, 0x63, 0x51, +/* 0530 */ 0x66, 0xA5, 0xB0, 0x42, 0x0E, 0x57, 0x7C, 0x0F, 0x70, 0x55, 0xAA, 0x05, 0x57, 0x07, 0xAE, 0x8D, +/* 0540 */ 0x63, 0x0A, 0x57, 0x8B, 0x3A, 0x8D, 0x59, 0x0C, 0x57, 0x85, 0x07, 0x4E, 0xBC, 0x48, 0x57, 0xAA, +/* 0550 */ 0x05, 0x55, 0x29, 0x0F, 0x70, 0x78, 0x54, 0x55, 0x29, 0x2C, 0x96, 0x78, 0x54, 0x55, 0x7C, 0x48, +/* 0560 */ 0x03, 0x78, 0x54, 0x55, 0x29, 0x2C, 0x96, 0x78, 0xAA, 0x05, 0x55, 0x29, 0x0F, 0x70, 0x78, 0x85, +/* 0570 */ 0x07, 0x4E, 0xBC, 0x48, 0x57, 0x8B, 0x3A, 0x8D, 0x59, 0x0C, 0x57, 0x07, 0xAE, 0x8D, 0x09, 0x8F, +/* 0580 */ 0x78, 0x7C, 0x0F, 0x70, 0x55, 0x0E, 0x58, 0x57, 0x91, 0x8F, 0x4E, 0x42, 0x0D, 0x57, 0xBC, 0x2C, +/* 0590 */ 0xA2, 0x5D, 0x08, 0x54, 0x2E, 0xB8, 0x1E, 0xA2, 0x28, 0x09, 0x48, 0xB2, 0x28, 0xBC, 0x0C, 0x30, +/* 05A0 */ 0x67, 0x36, 0x7C, 0x05, 0x07, 0xA6, 0x4A, 0x30, 0x3A, 0x24, 0xA1, 0x3F, 0x68, 0x93, 0x0C, 0x30, +/* 05B0 */ 0x01, 0x54, 0x8C, 0xA8, 0x48, 0x4D, 0x0A, 0x70, 0x88, 0xA8, 0x46, 0x02, 0x1E, 0x4D, 0x6D, 0x2C, +/* 05C0 */ 0x0D, 0x1F, 0x61, 0x2C, 0x1B, 0x31, 0x1F, 0xBC, 0x49, 0x73, 0x0F, 0x44, 0xA9, 0x2C, 0x0A, 0x83, +/* 05D0 */ 0x2C, 0x05, 0xAC, 0x07, 0x2C, 0xA4, 0xBC, 0x1E, 0x04, 0x91, 0x2C, 0x05, 0x78, 0x1D, 0x39, 0x61, +/* 05E0 */ 0x1E, 0xB4, 0x2C, 0x6F, 0x09, 0x7A, 0x4A, 0x40, 0xAB, 0x63, 0xB2, 0x19, 0xA9, 0x2C, 0x09, 0x4E, +/* 05F0 */ 0x63, 0xB2, 0x19, 0x6D, 0x96, 0x19, 0x76, 0x19, 0xAF, 0x0A, 0x7A, 0x76, 0x45, 0xBC, 0x1E, 0x03, +/* 0600 */ 0x7A, 0x76, 0x7A, 0x71, 0x0B, 0x7A, 0x07, 0xC0, 0x61, 0x97, 0x07, 0xC0, 0x61, 0x97, 0x07, 0xC0, +/* 0610 */ 0x61, 0x97, 0x07, 0xC0, 0x61, 0x97, 0x07, 0xC0, 0x61, 0x97, 0x07, 0xC0, 0x61, 0x97, 0x07, 0xC0, +/* 0620 */ 0x61, 0x97, 0x07, 0xC0, 0x61, 0x97, 0x07, 0x49, 0x07, 0x28, 0x24, 0x79, 0x4E, 0x0B, 0x7E, 0xAC, +/* 0630 */ 0x79, 0x4E, 0x27, 0x51, 0x24, 0x79, 0x4E, 0x0B, 0x7E, 0xAC, 0x79, 0xAB, 0x91, 0x97, 0x03, 0x24, +/* 0640 */ 0x79, 0x4E, 0x0F, 0x70, 0xAC, 0x6D, 0xAE, 0xAB, 0x59, 0x0C, 0x1A, 0x2C, 0xA2, 0x3F, 0xAA, 0x07, +/* 0650 */ 0x1A, 0x0F, 0x9A, 0x8C, 0xA8, 0x2C, 0x96, 0x49, 0x48, 0x03, 0x7B, 0x91, 0x7E, 0x7B, 0x63, 0x0A, +/* 0660 */ 0xC0, 0xBC, 0x04, 0x85, 0x0A, 0x2E, 0x2D, 0xA4, 0x00, 0x29, 0x1E, 0x6F, 0x2E, 0x79, 0x4E, 0x69, +/* 0670 */ 0xA3, 0x24, 0x79, 0xAB, 0x91, 0x1A, 0x7F, 0x03, 0x1A, 0x7F, 0x03, 0x28, 0x52, 0x97, 0x6F, 0xC0, +/* 0680 */ 0x91, 0x30, 0x03, 0x55, 0xA8, 0x97, 0x18, 0x1F, 0xBC, 0x97, 0xA2, 0x1F, 0x61, 0x22, 0x8E, 0x1F, +/* 0690 */ 0x91, 0x1E, 0x59, 0x03, 0x1F, 0x32, 0xA3, 0x0D, 0x64, 0x88, 0x6D, 0x8E, 0x0A, 0x56, 0x1F, 0x09, +/* 06A0 */ 0x56, 0x00, 0x07, 0x8E, 0x4C, 0xA9, 0x8A, 0x04, 0x58, 0x4C, 0x7C, 0x7E, 0x32, 0x44, 0x4C, 0x59, +/* 06B0 */ 0x02, 0xA9, 0x56, 0x4C, 0xAD, 0x0E, 0xAB, 0x0A, 0x70, 0x24, 0xA9, 0x56, 0xAB, 0x07, 0x58, 0x24, +/* 06C0 */ 0x7C, 0x1E, 0x1B, 0x0B, 0x26, 0x0C, 0x1E, 0x3A, 0x2E, 0x59, 0x30, 0x22, 0x2E, 0x8B, 0x41, 0x70, +/* 06D0 */ 0x24, 0x9C, 0x54, 0x57, 0x29, 0xAE, 0x55, 0x07, 0x8F, 0xAC, 0x42, 0x08, 0xAB, 0xBC, 0x75, 0x78, +/* 06E0 */ 0x0B, 0x7E, 0xAB, 0xA1, 0x0F, 0x70, 0x57, 0x69, 0xA3, 0x8D, 0x85, 0x05, 0x7A, 0x29, 0x1E, 0x6F, +/* 06F0 */ 0x8C, 0x0A, 0x8F, 0x2E, 0x95, 0x04, 0x1E, 0x1B, 0x45, 0x60, 0x33, 0xA6, 0xBC, 0x1E, 0x1B, 0x2B, +/* 0700 */ 0x1E, 0x1B, 0x2B, 0x1E, 0x1B, 0x2B, 0x1E, 0x1B, 0x2B, 0x1E, 0x1B, 0x03, 0x07, 0x05, 0x7D, 0x4A, +/* 0710 */ 0x46, 0x0E, 0x58, 0x8C, 0xA8, 0x48, 0x3E, 0xAA, 0x4D, 0x06, 0x46, 0x29, 0x07, 0x05, 0x0E, 0x0B, +/* 0720 */ 0x02, 0xB0, 0xA8, 0x9C, 0x84, 0x6C, 0x0A, 0x41, 0xA2, 0x4C, 0xBC, 0x0C, 0x08, 0x05, 0x5D, 0x63, +/* 0730 */ 0x0E, 0x49, 0x91, 0x20, 0x7B, 0x8B, 0xA3, 0x4E, 0x1A, 0x09, 0x0B, 0x0C, 0x0D, 0xAA, 0x03, 0x2E, +/* 0740 */ 0xBC, 0x85, 0x30, 0x03, 0x2E, 0x29, 0x5B, 0x82, 0xAC, 0x91, 0x97, 0x5E, 0x00, 0x50, 0x03, 0x24, +/* 0750 */ 0x7C, 0xAE, 0xAB, 0x50, 0x03, 0x60, 0x8A, 0xB0, 0x50, 0x03, 0x60, 0xA2, 0xAB, 0x85, 0x03, 0x24, +/* 0760 */ 0x7C, 0x2C, 0x18, 0x04, 0xB1, 0x08, 0x4C, 0x85, 0x48, 0x70, 0x2E, 0x2D, 0x22, 0x06, 0x56, 0x4C, +/* 0770 */ 0x4A, 0x0E, 0xAE, 0x01, 0x00, 0x07, 0x0F, 0x51, 0x6C, 0x90, 0x2F, 0xAB, 0xA1, 0x3C, 0x49, 0x92, +/* 0780 */ 0x04, 0x99, 0x07, 0x8A, 0x8C, 0xA8, 0x2C, 0x96, 0xC0, 0x29, 0x0F, 0x58, 0x8C, 0xA8, 0x2C, 0x96, +/* 0790 */ 0xC0, 0x61, 0x1E, 0x21, 0xBC, 0x07, 0x4D, 0xBE, 0x0D, 0xC0, 0xBC, 0x1E, 0x1B, 0x0E, 0x03, 0x3F, +/* 07A0 */ 0xBA, 0x04, 0xC0, 0x4A, 0xAA, 0x6F, 0x07, 0xA6, 0x63, 0xB2, 0x01, 0x28, 0x07, 0x41, 0x8F, 0xA8, +/* 07B0 */ 0x97, 0x3A, 0x04, 0x42, 0x82, 0xAC, 0x07, 0x8F, 0xAB, 0x07, 0x8F, 0x00, 0x66, 0x5A, 0x7C, 0x1E, +/* 07C0 */ 0x1B, 0x2E, 0x69, 0xA3, 0x4E, 0x0F, 0x70, 0x24, 0x0F, 0x70, 0x4E, 0x69, 0xA3, 0x57, 0xA1, 0x48, +/* 07D0 */ 0x55, 0xAA, 0x03, 0x24, 0x0F, 0x70, 0x4E, 0x69, 0xA3, 0x24, 0x69, 0xA3, 0x4E, 0x0F, 0x70, 0x66, +/* 07E0 */ 0x5A, 0x29, 0x1E, 0x1B, 0x2E, 0x07, 0x8F, 0x00, 0x61, 0x8F, 0x24, 0x7C, 0x97, 0x3A, 0x03, 0x42, +/* 07F0 */ 0xA3, 0x4C, 0xB8, 0x97, 0x3A, 0x6C, 0x0A, 0x30, 0xA2, 0xA6, 0x07, 0xAA, 0x6F, 0x07, 0x7B, 0x3F, +/* 0800 */ 0xBA, 0x4D, 0x92, 0x25, 0xA6, 0x79, 0x25, 0xA6, 0x79, 0x49, 0x79, 0x0D, 0x05, 0xB0, 0x7B, 0xA9, +/* 0810 */ 0x27, 0x51, 0x7A, 0x4F, 0x45, 0x4F, 0x88, 0x66, 0x51, 0x0F, 0x3A, 0x19, 0x86, 0x22, 0x03, 0xA6, +/* 0820 */ 0x71, 0x30, 0x6A, 0x28, 0x42, 0x30, 0xA4, 0xA8, 0x86, 0x6F, 0x06, 0x04, 0x09, 0x8F, 0x4C, 0x42, +/* 0830 */ 0x06, 0x00, 0xAF, 0x6F, 0x4C, 0x0B, 0x70, 0xAB, 0x42, 0x03, 0xAC, 0x1D, 0x6F, 0x4E, 0x59, 0x05, +/* 0840 */ 0x2E, 0x5B, 0x18, 0x24, 0x32, 0x5B, 0x07, 0x2E, 0x5B, 0x18, 0xAC, 0x1D, 0x6F, 0x7A, 0x66, 0xA3, +/* 0850 */ 0x49, 0x42, 0x08, 0x55, 0x3C, 0x4C, 0x7C, 0x2C, 0xA2, 0x05, 0x04, 0x65, 0x0F, 0x0A, 0x6C, 0xB8, +/* 0860 */ 0x2C, 0x18, 0x6C, 0x0A, 0x41, 0x18, 0x6C, 0x4A, 0x69, 0xA2, 0x02, 0xC0, 0xB6, 0x07, 0x3C, 0x7D, +/* 0870 */ 0x4B, 0x8B, 0x51, 0xB0, 0x29, 0xAE, 0xAC, 0xA9, 0x1E, 0x82, 0x29, 0xAE, 0x2E, 0x69, 0xA3, 0xB0, +/* 0880 */ 0x29, 0xAE, 0x2E, 0x0F, 0x70, 0xB0, 0x29, 0xAE, 0x2E, 0x2C, 0x96, 0xB0, 0x29, 0xAE, 0x2E, 0x69, +/* 0890 */ 0x82, 0x29, 0xAE, 0x24, 0x91, 0x1E, 0x6E, 0x29, 0xAE, 0x2E, 0x63, 0x0A, 0xAB, 0x07, 0xAE, 0x42, +/* 08A0 */ 0x08, 0xB0, 0x2D, 0x51, 0x78, 0xBC, 0x58, 0x00, 0xA1, 0x97, 0x18, 0x78, 0xBC, 0x58, 0xAB, 0x27, +/* 08B0 */ 0x18, 0x78, 0xBC, 0x58, 0xAB, 0x07, 0x1E, 0x18, 0x78, 0xBC, 0x1E, 0x5A, 0x7C, 0x1E, 0x18, 0xC0, +/* 08C0 */ 0x61, 0x58, 0xC0, 0x61, 0x3F, 0xBA, 0x02, 0x4D, 0x50, 0x4D, 0x50, 0x4D, 0x21, 0x8B, 0x1B, 0x49, +/* 08D0 */ 0x8B, 0x1B, 0x49, 0x2D, 0x08, 0x7D, 0x07, 0x53, 0x9B, 0x57, 0xBC, 0x1E, 0x1B, 0xAB, 0xB3, 0xC0, +/* 08E0 */ 0xAF, 0x0C, 0x49, 0xAF, 0x0C, 0x49, 0xAF, 0x0C, 0x99, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, +/* 08F0 */ 0x05, 0x00, 0x07, 0x00, 0x41, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x49, 0x00, 0x4B, 0x00, +/* 0900 */ 0x4D, 0x00, 0x54, 0x00, 0x55, 0x00, 0x5E, 0x00, 0x5F, 0x00, 0x61, 0x00, 0x62, 0x00, 0x64, 0x00, +/* 0910 */ 0x66, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x7C, 0x00, 0x7F, 0x00, 0x80, 0x00, 0x82, 0x00, +/* 0920 */ 0x84, 0x00, 0x87, 0x00, 0x89, 0x00, 0x8B, 0x00, 0x8C, 0x00, 0x8E, 0x00, 0x8F, 0x00, 0x91, 0x00, +/* 0930 */ 0x93, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D, 0x00, 0x9F, 0x00, 0xA0, 0x00, +/* 0940 */ 0xA2, 0x00, 0xA4, 0x00, 0xA7, 0x00, 0xA8, 0x00, 0xAB, 0x00, 0xAD, 0x00, 0xAE, 0x00, 0xAF, 0x00, +/* 0950 */ 0xB1, 0x00, 0xB3, 0x00, 0xB4, 0x00, 0xB6, 0x00, 0xB7, 0x00, 0xBC, 0x00, 0xBE, 0x00, 0xC0, 0x00, +/* 0960 */ 0xC2, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCA, 0x00, 0xCC, 0x00, 0xCE, 0x00, +/* 0970 */ 0xD1, 0x00, 0xD2, 0x00, 0xD5, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDB, 0x00, 0xDE, 0x00, 0xE0, 0x00, +/* 0980 */ 0xE2, 0x00, 0xE4, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEC, 0x00, 0xEE, 0x00, 0xF2, 0x00, 0xF4, 0x00, +/* 0990 */ 0xF7, 0x00, 0xF8, 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFE, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, +/* 09A0 */ 0x06, 0x01, 0x08, 0x01, 0x0A, 0x01, 0x0D, 0x01, 0x0F, 0x01, 0x11, 0x01, 0x12, 0x01, 0x15, 0x01, +/* 09B0 */ 0x16, 0x01, 0x17, 0x01, 0x19, 0x01, 0x1A, 0x01, 0x1D, 0x01, 0x32, 0x01, 0x34, 0x01, 0x36, 0x01, +/* 09C0 */ 0x39, 0x01, 0x3B, 0x01, 0x3D, 0x01, 0x3F, 0x01, 0x41, 0x01, 0x4F, 0x01, 0x50, 0x01, 0x52, 0x01, +/* 09D0 */ 0x55, 0x01, 0x57, 0x01, 0x58, 0x01, 0x59, 0x01, 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01, +/* 09E0 */ 0x64, 0x01, 0x66, 0x01, 0x68, 0x01, 0x6A, 0x01, 0x6C, 0x01, 0x6D, 0x01, 0x6F, 0x01, 0x70, 0x01, +/* 09F0 */ 0x72, 0x01, 0x74, 0x01, 0x76, 0x01, 0x78, 0x01, 0x7A, 0x01, 0x7D, 0x01, 0x7F, 0x01, 0x81, 0x01, +/* 0A00 */ 0x83, 0x01, 0x85, 0x01, 0x87, 0x01, 0x8A, 0x01, 0x8B, 0x01, 0x8D, 0x01, 0x8F, 0x01, 0x91, 0x01, +/* 0A10 */ 0x93, 0x01, 0x94, 0x01, 0x95, 0x01, 0x98, 0x01, 0x9A, 0x01, 0x9D, 0x01, 0x9E, 0x01, 0xA0, 0x01, +/* 0A20 */ 0xA2, 0x01, 0xA5, 0x01, 0xA6, 0x01, 0xA8, 0x01, 0xAB, 0x01, 0xAC, 0x01, 0xAE, 0x01, 0xB0, 0x01, +/* 0A30 */ 0xB2, 0x01, 0xB4, 0x01, 0xB6, 0x01, 0xB8, 0x01, 0xBA, 0x01, 0xBC, 0x01, 0xBD, 0x01, 0xC9, 0x02, +/* 0A40 */ 0x06, 0x02, 0x48, 0x02, 0x4A, 0x02, 0x6C, 0x02, 0x8B, 0x03, 0x14, 0x03, 0x16, 0x03, 0x21, 0x03, +/* 0A50 */ 0x3C, 0x03, 0x4D, 0x03, 0x7E, 0x03, 0x80, 0x03, 0x92, 0x03, 0xB6, 0x03, 0xC0, 0x03, 0xD8, 0x03, +/* 0A60 */ 0xE2, 0x03, 0xF3, 0x04, 0x4F, 0x04, 0x5C, 0x04, 0x61, 0x04, 0x68, 0x04, 0x7A, 0x04, 0xA3, 0x05, +/* 0A70 */ 0x30, 0x05, 0x34, 0x05, 0x3B, 0x05, 0x4B, 0x05, 0x53, 0x05, 0x55, 0x05, 0x91, 0x05, 0xB3, 0x05, +/* 0A80 */ 0xB5, 0x05, 0xDC, 0x05, 0xED, 0x06, 0x00, 0x06, 0x06, 0x06, 0x08, 0x06, 0x80, 0x06, 0x96, 0x06, +/* 0A90 */ 0xA9, 0x06, 0xAB, 0x07, 0x0B, 0x07, 0x23, 0x07, 0x28, 0x07, 0x2A, 0x07, 0x8E, 0x07, 0x96, 0x07, +/* 0AA0 */ 0x99, 0x07, 0x9B, 0x07, 0xA4, 0x07, 0xA7, 0x07, 0xFC, 0x08, 0x2A, 0x08, 0x2E, 0x08, 0x4A, 0x08, +/* 0AB0 */ 0x4F, 0x08, 0x52, 0x08, 0x57, 0x08, 0x64, 0x08, 0x69, 0x08, 0x74, +/* char range info */ +0x00, 0x00, 0x07, 0x00, 0x10, +/* 0AC0 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x2E, 0x00, 0x64, 0x00, 0xDD, 0x01, 0x6C, 0x02, 0x31, 0x02, 0xD3, +/* 0AD0 */ 0x02, 0xF0, 0x03, 0x57, 0x03, 0xB8, 0x04, 0x02, 0x04, 0x16, 0x04, 0x2E, 0x04, 0x40, 0x04, 0x47, +/* 0AE0 */ 0x04, 0xA3, 0x05, 0x27, 0x05, 0x5C, 0x05, 0xB9, 0x06, 0x2F, 0x06, 0x8D, 0x06, 0xF4, 0x07, 0x70, +/* 0AF0 */ 0x07, 0xC0, 0x08, 0x4E, 0x08, 0xCD, 0x08, 0xD5, 0x08, 0xEF, 0x09, 0x36, 0x09, 0x42, 0x09, 0x89, +/* 0B00 */ 0x09, 0xE6, 0x0A, 0xFA, 0x0B, 0x00, 0x0B, 0x7B, 0x0B, 0xE3, 0x0C, 0x76, 0x0C, 0x7F, 0x0C, 0xB0, +/* 0B10 */ 0x0D, 0x42, 0x0D, 0x80, 0x0D, 0x84, 0x0D, 0xAF, 0x0E, 0x35, 0x0E, 0x52, 0x0F, 0x12, 0x0F, 0x18, +/* 0B20 */ 0x0F, 0x1D, 0x0F, 0x69, 0x10, 0x0E, 0x10, 0x7D, 0x10, 0xFA, 0x11, 0x20, 0x11, 0x28, 0x11, 0x9F, +/* 0B30 */ 0x12, 0x76, 0x12, 0xF1, 0x12, 0xF7, 0x13, 0x4D, 0x13, 0x89, 0x13, 0xE6, 0x14, 0x12, 0x14, 0x50, +/* 0B40 */ 0x14, 0x67, 0x14, 0x87, 0x14, 0x8D, 0x14, 0xF9, 0x15, 0x49, 0x15, 0x9C, 0x15, 0xA2, 0x15, 0xE1, +/* 0B50 */ 0x16, 0x75, 0x16, 0x9C, 0x16, 0xAA, 0x16, 0xD3, 0x17, 0x2C, 0x17, 0x54, 0x17, 0xE7, 0x17, 0xF2, +/* 0B60 */ 0x17, 0xF6, 0x18, 0x33, 0x18, 0x86, 0x18, 0xB1, 0x19, 0x0D, 0x19, 0x52, 0x19, 0x5B, 0x19, 0xB0, +/* 0B70 */ 0x1A, 0x44, 0x1A, 0x9D, 0x1A, 0xA9, 0x1A, 0xF1, 0x1B, 0x50, 0x1B, 0x5E, 0x1B, 0xC4, 0x07, 0x00, +/* 0B80 */ 0x10, 0x07, 0x73, 0xAA, 0x4D, 0x85, 0x03, 0x7B, 0x91, 0x20, 0xC0, 0x91, 0x70, 0x49, 0x0B, 0x70, +/* 0B90 */ 0x49, 0x50, 0x49, 0xAD, 0x0E, 0x49, 0xAD, 0x0E, 0x7B, 0x61, 0x33, 0xC8, 0x0F, 0xB3, 0xC8, 0x56, +/* 0BA0 */ 0x49, 0x4A, 0x56, 0x19, 0x1A, 0x46, 0x04, 0x31, 0xA6, 0x4B, 0xEA, 0x10, 0x0E, 0x73, 0x08, 0x56, +/* 0BB0 */ 0x7C, 0x20, 0x2E, 0x61, 0xA2, 0xA1, 0x70, 0x6C, 0x07, 0x2C, 0xA5, 0x97, 0x6C, 0x4A, 0x2C, 0x3A, +/* 0BC0 */ 0x1D, 0x0E, 0x4E, 0x1A, 0x1E, 0x07, 0xA9, 0x0F, 0x1B, 0x28, 0xBC, 0x18, 0xAF, 0x0D, 0x6C, 0x29, +/* 0BD0 */ 0x2C, 0x6E, 0x0B, 0xB3, 0x4C, 0x7C, 0x2C, 0x5A, 0x0A, 0xC4, 0xAB, 0xA8, 0x2C, 0x82, 0x09, 0x2C, +/* 0BE0 */ 0x0A, 0x10, 0x10, 0x88, 0x73, 0xF3, 0x40, 0x7C, 0x22, 0x1F, 0x8E, 0x29, 0x56, 0x28, 0x7C, 0x33, +/* 0BF0 */ 0x05, 0x31, 0x28, 0x29, 0x56, 0xB0, 0x07, 0x1E, 0xE2, 0x6D, 0x2C, 0xA5, 0x09, 0x76, 0x4C, 0xB8, +/* 0C00 */ 0x97, 0x22, 0x2E, 0xB8, 0x97, 0x22, 0x2E, 0xB8, 0x97, 0x22, 0x24, 0x4A, 0x0B, 0x69, 0x26, 0x27, +/* 0C10 */ 0xEB, 0x09, 0x28, 0x69, 0x00, 0x29, 0x0F, 0xB3, 0xA8, 0x33, 0x05, 0x31, 0x4C, 0xBC, 0x56, 0xB0, +/* 0C20 */ 0x07, 0x1E, 0xE2, 0x4A, 0x2C, 0xA5, 0x09, 0x76, 0x4C, 0x61, 0x18, 0xAF, 0x82, 0xAC, 0xAD, 0x48, +/* 0C30 */ 0xB2, 0x24, 0xAD, 0x48, 0xB2, 0x24, 0xAD, 0x48, 0xB2, 0x24, 0x4A, 0x27, 0x0E, 0x26, 0x0C, 0x2C, +/* 0C40 */ 0x1B, 0x0B, 0x08, 0x2E, 0x29, 0x22, 0x00, 0x4A, 0x8A, 0xB0, 0x1A, 0xA2, 0x61, 0x18, 0x6C, 0x07, +/* 0C50 */ 0x1E, 0x07, 0xB0, 0x8B, 0x04, 0x6C, 0x09, 0x76, 0xA9, 0x96, 0x10, 0x10, 0x43, 0x08, 0x0F, 0x6F, +/* 0C60 */ 0x49, 0x61, 0x0F, 0x6F, 0x49, 0x61, 0x0F, 0x6F, 0x49, 0x61, 0x0F, 0x6F, 0x45, 0xA8, 0x0A, 0x96, +/* 0C70 */ 0x36, 0x29, 0xB1, 0x1B, 0x07, 0x1F, 0x2D, 0x30, 0x89, 0x2E, 0x29, 0x5B, 0x44, 0x2E, 0x0A, 0xAE, +/* 0C80 */ 0x03, 0x7C, 0x37, 0xB5, 0x28, 0x69, 0xA3, 0xAB, 0x7C, 0x0A, 0x01, 0x28, 0x48, 0x7D, 0x48, 0x07, +/* 0C90 */ 0x49, 0xB1, 0xA7, 0xC0, 0x2D, 0x22, 0x05, 0xA6, 0xAD, 0x48, 0xBF, 0xA6, 0x37, 0x41, 0x44, 0xAB, +/* 0CA0 */ 0xA8, 0x08, 0x86, 0x54, 0x8C, 0x1A, 0x0C, 0x97, 0x1B, 0xC0, 0x61, 0x2C, 0x96, 0x49, 0xAA, 0x4D, +/* 0CB0 */ 0x0C, 0x58, 0x24, 0xA1, 0x0B, 0x05, 0x55, 0x34, 0x20, 0x24, 0x0B, 0xC4, 0x98, 0x01, 0x03, 0x0C, +/* 0CC0 */ 0x1E, 0x1B, 0x24, 0xAD, 0x41, 0x18, 0x24, 0x7C, 0x85, 0x97, 0xA2, 0x28, 0xBB, 0x30, 0x8A, 0x6C, +/* 0CD0 */ 0x7C, 0x07, 0x0B, 0x69, 0x5E, 0xC0, 0x61, 0x0F, 0x6F, 0x49, 0x61, 0x0F, 0x6F, 0x49, 0x61, 0x0F, +/* 0CE0 */ 0x6F, 0x49, 0x61, 0x0F, 0x6F, 0x49, 0x61, 0x0F, 0x6F, 0x10, 0x19, 0x45, 0x80, 0x4A, 0x72, 0x78, +/* 0CF0 */ 0xBC, 0x94, 0x9E, 0x06, 0x8C, 0x34, 0x1B, 0x05, 0x78, 0x07, 0x1E, 0xA2, 0x4E, 0x61, 0x64, 0x03, +/* 0D00 */ 0x41, 0x44, 0xB0, 0x7C, 0x33, 0x19, 0x71, 0x84, 0x9F, 0x0E, 0x4E, 0x0A, 0x76, 0x19, 0x1D, 0x39, +/* 0D10 */ 0x6D, 0x1E, 0x03, 0xBC, 0x56, 0x7A, 0xA1, 0x18, 0x00, 0x29, 0x1E, 0x04, 0xAF, 0x82, 0x45, 0xA1, +/* 0D20 */ 0x18, 0x00, 0x7C, 0x1E, 0x04, 0x4A, 0x31, 0x78, 0x1D, 0x08, 0xBC, 0x1E, 0x03, 0x01, 0x86, 0xA4, +/* 0D30 */ 0xAC, 0x71, 0x89, 0x9F, 0x0E, 0x83, 0x64, 0x4E, 0x3D, 0x2C, 0x07, 0x02, 0x33, 0x24, 0x42, 0xC4, +/* 0D40 */ 0x00, 0x8B, 0x04, 0x2E, 0xBC, 0x94, 0x9E, 0x06, 0x00, 0x04, 0x56, 0x49, 0x91, 0x96, 0x6D, 0x94, +/* 0D50 */ 0x9E, 0x06, 0x4C, 0x4A, 0x31, 0x83, 0x0F, 0xB2, 0x24, 0xA1, 0x86, 0xA4, 0x3D, 0xF5, 0xAB, 0x61, +/* 0D60 */ 0x18, 0x00, 0x0B, 0x2C, 0x89, 0x9F, 0x0E, 0x57, 0x7C, 0x33, 0x1E, 0x07, 0xBC, 0x1E, 0x03, 0x57, +/* 0D70 */ 0x8B, 0x04, 0xA1, 0x18, 0x00, 0x29, 0x1E, 0x04, 0x19, 0xBC, 0x56, 0x00, 0xA1, 0x18, 0x00, 0x29, +/* 0D80 */ 0x1E, 0x04, 0x7A, 0x91, 0x96, 0x00, 0x1D, 0x0A, 0x00, 0x4A, 0x96, 0x19, 0x4A, 0x31, 0x4E, 0x09, +/* 0D90 */ 0x31, 0xA0, 0xB3, 0x88, 0xA1, 0x86, 0xA4, 0xAB, 0xA1, 0x69, 0x58, 0x45, 0xBC, 0x86, 0x06, 0x8D, +/* 0DA0 */ 0x62, 0x97, 0x6A, 0x7A, 0x7C, 0x0A, 0x0D, 0x8C, 0xBC, 0x07, 0x07, 0x3C, 0x24, 0xA1, 0x10, 0x16, +/* 0DB0 */ 0x1F, 0x95, 0x90, 0x06, 0x2F, 0xC0, 0xBB, 0x1E, 0x22, 0x03, 0xAB, 0xA8, 0x0C, 0x48, 0x58, 0x6C, +/* 0DC0 */ 0xB8, 0x97, 0x5F, 0x4C, 0x69, 0x51, 0x04, 0x0C, 0x7E, 0x24, 0x7C, 0x8F, 0xBC, 0x97, 0x07, 0x2E, +/* 0DD0 */ 0x7C, 0x0F, 0x8A, 0x7C, 0x97, 0x07, 0xA8, 0x5C, 0x2D, 0x05, 0xAB, 0x66, 0x84, 0x91, 0x8E, 0x2E, +/* 0DE0 */ 0xBC, 0xAE, 0x63, 0x06, 0x28, 0x61, 0x97, 0x8F, 0x8C, 0x66, 0x31, 0xA6, 0x29, 0x0D, 0x48, 0xA4, +/* 0DF0 */ 0xB0, 0x6D, 0x0E, 0x0A, 0x06, 0x02, 0x7A, 0xBC, 0x86, 0xB2, 0x01, 0xB0, 0x09, 0x31, 0x7A, 0x7C, +/* 0E00 */ 0x69, 0x1B, 0xAE, 0xA9, 0x1E, 0x03, 0x78, 0x0A, 0x8F, 0x00, 0x0B, 0x97, 0xA7, 0x33, 0x45, 0xA1, +/* 0E10 */ 0x0F, 0x70, 0xA1, 0x0C, 0x1E, 0x1B, 0x18, 0x7A, 0x29, 0x0F, 0x33, 0xA1, 0x0D, 0x48, 0x1B, 0x7A, +/* 0E20 */ 0xBC, 0x1E, 0x6F, 0xAB, 0x7C, 0x0E, 0x54, 0x78, 0x7C, 0x0F, 0x58, 0xAB, 0x4A, 0x2C, 0xA2, 0xAC, +/* 0E30 */ 0x85, 0x0E, 0x07, 0x5D, 0x63, 0xA2, 0x57, 0x2D, 0x5B, 0xC4, 0x57, 0xB8, 0x1E, 0x3A, 0x04, 0x97, +/* 0E40 */ 0x6A, 0x7A, 0x6D, 0x85, 0xC4, 0x03, 0x00, 0x6D, 0x6F, 0x72, 0x2E, 0xB6, 0x07, 0x3C, 0x55, 0x3C, +/* 0E50 */ 0x10, 0x07, 0x73, 0x08, 0x56, 0x7B, 0x61, 0x46, 0x07, 0x31, 0x49, 0x4A, 0x0F, 0xF5, 0x1A, 0x64, +/* 0E60 */ 0x57, 0xBC, 0x1E, 0x3E, 0x29, 0x76, 0x49, 0x7C, 0x1E, 0x04, 0x7D, 0x32, 0x03, 0x10, 0x0A, 0x19, +/* 0E70 */ 0x92, 0xA8, 0x03, 0x00, 0x38, 0x09, 0x44, 0x49, 0x29, 0x1E, 0x77, 0x7B, 0x91, 0x56, 0x49, 0x59, +/* 0E80 */ 0x03, 0x7B, 0x34, 0xA2, 0x49, 0x59, 0x03, 0xC0, 0xA9, 0x22, 0x7B, 0x29, 0x97, 0x07, 0xC0, 0x61, +/* 0E90 */ 0x97, 0x03, 0xC0, 0xAF, 0x6F, 0x7D, 0x75, 0x36, 0x29, 0x0F, 0xA2, 0xCD, 0x21, 0x59, 0x07, 0x49, +/* 0EA0 */ 0x42, 0x07, 0xC0, 0x61, 0x97, 0x3E, 0x08, 0x97, 0x3E, 0x42, 0x07, 0x49, 0x59, 0x21, 0x79, 0x7B, +/* 0EB0 */ 0x7C, 0xAE, 0x7B, 0x1D, 0x1B, 0x7D, 0x0B, 0x70, 0x49, 0x59, 0x4D, 0x01, 0x8F, 0x7D, 0x71, 0x6F, +/* 0EC0 */ 0x19, 0x60, 0x18, 0x7B, 0xAF, 0x1B, 0x49, 0x29, 0x97, 0x3E, 0xAD, 0xA4, 0x49, 0x34, 0x6F, 0x06, +/* 0ED0 */ 0x7A, 0x1A, 0x0B, 0x02, 0x10, 0x0A, 0x7B, 0x92, 0x29, 0x99, 0x7C, 0x0B, 0xA3, 0x7B, 0xBC, 0x0E, +/* 0EE0 */ 0xC4, 0x49, 0x7C, 0x97, 0x3E, 0x83, 0x1E, 0x5F, 0x8C, 0xA8, 0x69, 0x21, 0xAD, 0xA4, 0x7B, 0x29, +/* 0EF0 */ 0x0F, 0x18, 0xF3, 0x22, 0x49, 0xAD, 0xA3, 0x49, 0x59, 0x3E, 0x03, 0x8F, 0x49, 0x32, 0x35, 0x7B, +/* 0F00 */ 0x1D, 0x6F, 0x7D, 0x85, 0xF3, 0x70, 0x7B, 0x91, 0x20, 0x7B, 0x85, 0x02, 0xC0, 0xA9, 0x70, 0x49, +/* 0F10 */ 0xAA, 0x7D, 0x1E, 0x6F, 0x7B, 0x7C, 0xAE, 0x45, 0x60, 0x8A, 0xC8, 0x58, 0x19, 0x66, 0x0E, 0x88, +/* 0F20 */ 0xA8, 0x5C, 0xC0, 0x59, 0x4D, 0x0C, 0x22, 0xC0, 0xBC, 0x58, 0x7B, 0x91, 0x56, 0xCD, 0x02, 0x88, +/* 0F30 */ 0xA8, 0x71, 0x08, 0x38, 0x65, 0x10, 0x0D, 0xB0, 0x95, 0x1A, 0x46, 0x03, 0x8A, 0x88, 0xA8, 0x18, +/* 0F40 */ 0xC0, 0x09, 0x9D, 0x00, 0x86, 0x04, 0x00, 0x07, 0x0D, 0x28, 0x1D, 0x09, 0x0D, 0x0F, 0x3A, 0x0D, +/* 0F50 */ 0x0F, 0x5A, 0x60, 0x30, 0x8F, 0x28, 0x42, 0x97, 0x22, 0x6C, 0x29, 0x05, 0x69, 0x3A, 0x03, 0x01, +/* 0F60 */ 0x36, 0x07, 0x48, 0x77, 0x8D, 0x1A, 0x56, 0x56, 0x55, 0x60, 0x96, 0x0B, 0x31, 0x1F, 0x9F, 0x0A, +/* 0F70 */ 0x00, 0x04, 0x2C, 0xBF, 0xA6, 0x4A, 0xEF, 0x00, 0x91, 0x0A, 0x01, 0x8C, 0xA8, 0xB0, 0xA1, 0x10, +/* 0F80 */ 0x0F, 0x38, 0xE7, 0xBC, 0x22, 0x7D, 0xCF, 0x7B, 0xBC, 0x22, 0x7B, 0xBC, 0x22, 0x7B, 0xBC, 0x22, +/* 0F90 */ 0x7B, 0xBC, 0x22, 0x10, 0x07, 0x43, 0xDF, 0xDF, 0x7C, 0x0B, 0x9E, 0x4D, 0x91, 0x1E, 0xA4, 0x7B, +/* 0FA0 */ 0xDD, 0x0D, 0x99, 0x09, 0x2C, 0x21, 0xAF, 0x02, 0x45, 0xA8, 0xC4, 0x10, 0x0C, 0x36, 0x92, 0xE7, +/* 0FB0 */ 0xC8, 0x0B, 0x2A, 0x07, 0xA6, 0x50, 0x5C, 0x6C, 0x50, 0x5C, 0x6C, 0x50, 0x5C, 0x10, 0x07, 0xB0, +/* 0FC0 */ 0x38, 0xDF, 0xE7, 0xEA, 0x10, 0x0F, 0x4C, 0x43, 0x1A, 0xEB, 0x08, 0x4D, 0x83, 0x8E, 0x7B, 0x91, +/* 0FD0 */ 0xA2, 0x49, 0x32, 0x51, 0xC0, 0xBC, 0x97, 0x03, 0xC0, 0x61, 0x8E, 0x49, 0x0B, 0x56, 0x7D, 0x97, +/* 0FE0 */ 0x07, 0xC0, 0xBC, 0x97, 0x03, 0x00, 0xC8, 0x8E, 0x49, 0x0B, 0x56, 0x7D, 0x69, 0x21, 0x03, 0x58, +/* 0FF0 */ 0x00, 0xC8, 0x70, 0x49, 0x0A, 0x22, 0x7D, 0x69, 0x21, 0x03, 0x7E, 0xC0, 0x4A, 0x70, 0x49, 0x0A, +/* 1000 */ 0x22, 0xF3, 0x31, 0x7B, 0x7C, 0x7E, 0x7B, 0x59, 0x02, 0x7B, 0xAD, 0x0D, 0xF3, 0x31, 0x49, 0x32, +/* 1010 */ 0x51, 0xCD, 0x02, 0x7B, 0xAD, 0x0E, 0x49, 0x91, 0x46, 0x94, 0x0F, 0x51, 0x99, 0x29, 0x06, 0x02, +/* 1020 */ 0x10, 0x11, 0xAB, 0x73, 0x29, 0x09, 0x0D, 0x0F, 0x9E, 0x06, 0xC0, 0xB8, 0x35, 0x02, 0x1F, 0x42, +/* 1030 */ 0x48, 0x5F, 0x2E, 0x7C, 0x2C, 0x22, 0x85, 0x08, 0x4C, 0xAD, 0x5A, 0x0B, 0x70, 0x4C, 0x0E, 0x22, +/* 1040 */ 0xAB, 0x2D, 0x06, 0x60, 0x8A, 0x00, 0xA1, 0xAE, 0x2E, 0x42, 0x06, 0xB0, 0x1D, 0x1B, 0x24, 0xAD, +/* 1050 */ 0x6E, 0xA9, 0x70, 0x24, 0x8B, 0x5A, 0xAF, 0x0F, 0xA3, 0x66, 0x5A, 0xAF, 0x2C, 0x03, 0xAC, 0x91, +/* 1060 */ 0x58, 0xAB, 0x91, 0x58, 0x66, 0x5A, 0xAF, 0x2C, 0x03, 0x66, 0x5A, 0xAF, 0x2C, 0x03, 0x24, 0x8B, +/* 1070 */ 0x5A, 0xAF, 0x0F, 0xA3, 0x57, 0x61, 0x1E, 0x6E, 0xA9, 0x8E, 0x24, 0x2D, 0x07, 0x4E, 0x75, 0x57, +/* 1080 */ 0x7C, 0x5C, 0x7C, 0x8F, 0x2E, 0x91, 0x1E, 0xA4, 0xB0, 0x07, 0x58, 0x2E, 0x4A, 0xAE, 0x3F, 0x86, +/* 1090 */ 0x1B, 0x28, 0x91, 0x48, 0x54, 0x28, 0x7C, 0x0E, 0x41, 0x3A, 0x1F, 0x7C, 0xB1, 0x0E, 0x06, 0xC0, +/* 10A0 */ 0x7C, 0x06, 0xBA, 0x04, 0x10, 0x0E, 0x45, 0xDF, 0x7C, 0x0B, 0x58, 0x8C, 0x1A, 0xAA, 0x5A, 0xB0, +/* 10B0 */ 0xA8, 0x8B, 0x58, 0x28, 0xBC, 0xAA, 0x58, 0x6C, 0x07, 0x30, 0x58, 0x28, 0x29, 0x0F, 0xA2, 0x09, +/* 10C0 */ 0x58, 0x28, 0x61, 0x6F, 0x06, 0x83, 0x58, 0xA6, 0x9D, 0x61, 0x58, 0xFA, 0x58, 0xFA, 0x58, 0xFA, +/* 10D0 */ 0x58, 0xFA, 0x58, 0xFA, 0x58, 0xFA, 0x58, 0xFA, 0x58, 0x10, 0x0F, 0xB0, 0x73, 0x81, 0x53, 0x9E, +/* 10E0 */ 0x5E, 0xA6, 0x62, 0x30, 0x6F, 0x06, 0x28, 0x7C, 0x9C, 0x6E, 0x24, 0x91, 0x0F, 0x22, 0x0B, 0xAA, +/* 10F0 */ 0xA4, 0x2E, 0x7C, 0x0D, 0x0F, 0x6A, 0x7C, 0x0E, 0x7E, 0xA8, 0x0C, 0x04, 0xB0, 0x61, 0x97, 0x21, +/* 1100 */ 0x06, 0x8F, 0x49, 0x42, 0x21, 0x8B, 0x51, 0x7B, 0x34, 0x0F, 0x96, 0xC8, 0xAE, 0xC0, 0x7C, 0x0E, +/* 1110 */ 0x58, 0x7B, 0x0B, 0x8F, 0x7B, 0x42, 0x5F, 0xA6, 0x29, 0x48, 0x03, 0x8D, 0xA8, 0x85, 0x06, 0x45, +/* 1120 */ 0x66, 0x3A, 0x7B, 0x63, 0x0A, 0xC8, 0xAE, 0xC0, 0x29, 0xB2, 0x2A, 0x4C, 0x2D, 0x48, 0x8E, 0x1A, +/* 1130 */ 0x5B, 0x35, 0x4C, 0x2D, 0x97, 0x8F, 0x10, 0x0F, 0x7A, 0x80, 0x1A, 0x09, 0x53, 0xB9, 0x09, 0x03, +/* 1140 */ 0x1F, 0x29, 0x0C, 0x41, 0x3A, 0xAB, 0x1A, 0x9C, 0x3A, 0x28, 0x2D, 0x0C, 0x0B, 0x86, 0x96, 0x4C, +/* 1150 */ 0x4A, 0x35, 0x03, 0x00, 0xA1, 0x27, 0x51, 0xAB, 0x1A, 0xAB, 0xBC, 0x97, 0x21, 0x03, 0x1E, 0x3A, +/* 1160 */ 0xCD, 0x05, 0xC0, 0x7C, 0x0D, 0x33, 0xAB, 0xA8, 0x0B, 0x0C, 0x97, 0xEF, 0xA6, 0x29, 0x1E, 0x6F, +/* 1170 */ 0x9D, 0xC0, 0x2D, 0x35, 0x06, 0xC0, 0xB8, 0xB5, 0x7B, 0x90, 0x85, 0x21, 0x03, 0x1E, 0x6F, 0x7D, +/* 1180 */ 0x69, 0xA3, 0x7B, 0x91, 0x97, 0x03, 0x00, 0xA8, 0x8D, 0x69, 0xA3, 0x2E, 0x4A, 0x0E, 0x05, 0x4E, +/* 1190 */ 0x59, 0x0E, 0x2E, 0x4A, 0xA2, 0x05, 0x04, 0x42, 0x3A, 0x24, 0xA1, 0x0D, 0x5B, 0xA4, 0x2E, 0x7C, +/* 11A0 */ 0x85, 0x48, 0xEF, 0x28, 0x61, 0x69, 0xA2, 0x01, 0xC0, 0x3F, 0xBA, 0x3C, 0x10, 0x10, 0x55, 0x73, +/* 11B0 */ 0x0A, 0x3C, 0x7A, 0x1A, 0x0F, 0x6F, 0x9D, 0x49, 0x0A, 0x70, 0x8C, 0xA8, 0xAE, 0x49, 0x42, 0x05, +/* 11C0 */ 0xC0, 0xAF, 0x6F, 0x7B, 0x29, 0x8F, 0x49, 0x63, 0x03, 0xC0, 0x1D, 0x1B, 0xCD, 0x07, 0x4A, 0x22, +/* 11D0 */ 0x6C, 0x0B, 0x20, 0x07, 0x22, 0x00, 0xA8, 0xAE, 0xB0, 0x09, 0x22, 0x28, 0x42, 0x06, 0xB0, 0x0A, +/* 11E0 */ 0x22, 0x4C, 0x91, 0x1E, 0xA4, 0xAF, 0x35, 0x2E, 0x29, 0x97, 0xEB, 0x26, 0x69, 0xEB, 0x0A, 0x24, +/* 11F0 */ 0x3D, 0x41, 0x6F, 0x24, 0x3D, 0x41, 0x6F, 0x24, 0x3D, 0x41, 0x6F, 0x7B, 0x0E, 0x22, 0x7D, 0x0E, +/* 1200 */ 0x22, 0x7D, 0x0E, 0x22, 0x7D, 0x0E, 0x22, 0x7D, 0x0E, 0x22, 0x10, 0x10, 0x8D, 0xDF, 0x59, 0x97, +/* 1210 */ 0x22, 0x28, 0x59, 0x97, 0xA2, 0x4C, 0x4A, 0x5B, 0xE2, 0x59, 0x0C, 0x26, 0x26, 0x26, 0x04, 0x28, +/* 1220 */ 0x59, 0x4D, 0x59, 0x4D, 0x59, 0x4D, 0x59, 0x05, 0x06, 0x09, 0x0A, 0x08, 0x03, 0x1F, 0x59, 0x48, +/* 1230 */ 0x3A, 0x6C, 0x59, 0x97, 0x18, 0x4C, 0x4A, 0x5B, 0xA4, 0x24, 0xBC, 0xB7, 0x0B, 0x07, 0x02, 0x01, +/* 1240 */ 0x59, 0x51, 0xC0, 0x61, 0x8F, 0xC0, 0xBC, 0xAE, 0x7B, 0x29, 0xAE, 0xC0, 0xBC, 0x5C, 0xA8, 0x55, +/* 1250 */ 0x42, 0x08, 0x28, 0x26, 0x01, 0xB0, 0xA9, 0x58, 0x2E, 0x9F, 0x67, 0x04, 0x05, 0x27, 0x1B, 0x4C, +/* 1260 */ 0x59, 0x97, 0x58, 0x28, 0x07, 0x41, 0x18, 0x6C, 0x29, 0x0C, 0x0F, 0xB2, 0x03, 0x36, 0x7C, 0x05, +/* 1270 */ 0x68, 0x10, 0x11, 0x4E, 0x73, 0x29, 0x09, 0x53, 0x9E, 0x5E, 0x1F, 0x61, 0x41, 0xEF, 0x1F, 0x0A, +/* 1280 */ 0x41, 0x1B, 0x1F, 0x07, 0x48, 0xB7, 0x0E, 0x6E, 0x2E, 0x7C, 0x69, 0x5A, 0x90, 0x28, 0x61, 0x97, +/* 1290 */ 0x07, 0xC0, 0xA9, 0x1E, 0xA4, 0xC0, 0x29, 0x5C, 0xC0, 0x59, 0x47, 0x08, 0x0D, 0x1B, 0x72, 0x28, +/* 12A0 */ 0x63, 0x07, 0x0D, 0x48, 0x89, 0x4C, 0x0A, 0x41, 0xB2, 0x4C, 0x0B, 0x30, 0xB7, 0x0F, 0x58, 0x24, +/* 12B0 */ 0x91, 0x1E, 0x6F, 0x05, 0x61, 0x1E, 0xA5, 0x4F, 0x00, 0x32, 0x1B, 0x00, 0x66, 0x5A, 0x1D, 0x6F, +/* 12C0 */ 0x2E, 0x63, 0x05, 0x4E, 0xAA, 0x2E, 0x42, 0x06, 0xB0, 0x1D, 0x1B, 0x60, 0x31, 0xAB, 0x32, 0x35, +/* 12D0 */ 0x4C, 0x69, 0xA4, 0xB0, 0x59, 0x07, 0x24, 0x61, 0xAE, 0x3F, 0x69, 0xA3, 0xA8, 0x9C, 0x3A, 0x6C, +/* 12E0 */ 0x3D, 0x56, 0x1F, 0x29, 0x0C, 0x48, 0x3A, 0xC0, 0x7C, 0x06, 0x07, 0x07, 0x3C, 0x10, 0x0E, 0xAB, +/* 12F0 */ 0xDF, 0x61, 0x0B, 0x26, 0x26, 0x2A, 0x02, 0x4C, 0xB1, 0x41, 0x03, 0x4C, 0x0B, 0x5B, 0x82, 0x66, +/* 1300 */ 0x30, 0x96, 0x7B, 0x32, 0x1B, 0x49, 0x59, 0x21, 0x0C, 0x20, 0x36, 0x7C, 0xAE, 0xC0, 0x61, 0x97, +/* 1310 */ 0x3E, 0x0D, 0x1E, 0xA4, 0x88, 0x60, 0xA2, 0x49, 0x0A, 0x58, 0x7B, 0x32, 0x1B, 0x49, 0x59, 0x21, +/* 1320 */ 0x0C, 0x20, 0x36, 0x7C, 0x75, 0xA6, 0x61, 0x97, 0x3E, 0x0D, 0x70, 0x88, 0x60, 0xA2, 0x49, 0x50, +/* 1330 */ 0x05, 0x7B, 0x32, 0x6F, 0x7B, 0x7C, 0x0B, 0x31, 0x19, 0xA8, 0x06, 0x0B, 0x03, 0x10, 0x11, 0xAB, +/* 1340 */ 0x73, 0x93, 0x0C, 0x0E, 0x0F, 0x9E, 0x47, 0x55, 0x1A, 0x0E, 0x30, 0x6F, 0x05, 0x6C, 0x3D, 0x54, +/* 1350 */ 0x28, 0x85, 0xEB, 0x69, 0x1B, 0x24, 0xBC, 0xAE, 0x01, 0xA1, 0x0C, 0x97, 0x03, 0x2E, 0x59, 0x05, +/* 1360 */ 0xAB, 0x59, 0x05, 0x24, 0x4A, 0x58, 0xAB, 0x2D, 0x05, 0x1A, 0x0F, 0x18, 0xAB, 0x42, 0x02, 0x24, +/* 1370 */ 0xA1, 0x69, 0x89, 0xAF, 0xB5, 0x2E, 0x61, 0x1E, 0x6F, 0x06, 0x08, 0x1E, 0x84, 0x6C, 0xB1, 0x22, +/* 1380 */ 0x02, 0x1F, 0x91, 0x97, 0xA2, 0x01, 0x6C, 0x62, 0x2C, 0x41, 0xEF, 0xA8, 0x0D, 0x22, 0x02, 0x06, +/* 1390 */ 0x85, 0xA4, 0x24, 0xAD, 0xA3, 0xAB, 0x0A, 0x8F, 0x2E, 0x75, 0xB0, 0x34, 0x8E, 0x57, 0x7C, 0x5C, +/* 13A0 */ 0xAB, 0x0B, 0x70, 0x57, 0x29, 0xAE, 0x4E, 0x91, 0x70, 0x57, 0xA1, 0x97, 0xA4, 0xB0, 0x7C, 0x0F, +/* 13B0 */ 0x8E, 0x66, 0x0F, 0x67, 0x3F, 0x0D, 0x8F, 0x24, 0x29, 0x0F, 0x5B, 0x84, 0x4C, 0x59, 0x30, 0x6A, +/* 13C0 */ 0x4C, 0x29, 0xB1, 0x6F, 0x0A, 0x02, 0x36, 0x90, 0x06, 0xBA, 0x98, 0x10, 0x11, 0xB0, 0x73, 0x7C, +/* 13D0 */ 0x08, 0x0C, 0x0E, 0x1B, 0x0A, 0x05, 0x36, 0x42, 0xAE, 0x01, 0x6C, 0xB8, 0x75, 0x60, 0x1E, 0x1B, +/* 13E0 */ 0xB1, 0x07, 0x4C, 0x50, 0x07, 0xBC, 0x1E, 0x1B, 0x2E, 0x32, 0x1B, 0xAB, 0x91, 0x97, 0x03, 0xAC, +/* 13F0 */ 0x29, 0x5C, 0x00, 0xAD, 0x51, 0x57, 0xBC, 0x5C, 0xB0, 0x42, 0x08, 0xAC, 0x29, 0x5C, 0xB0, 0x07, +/* 1400 */ 0x8F, 0xAC, 0x7C, 0x0F, 0x33, 0x61, 0x8F, 0x2E, 0x85, 0x06, 0xB0, 0x2D, 0x3A, 0xAC, 0x61, 0x48, +/* 1410 */ 0xB7, 0x30, 0x07, 0x2E, 0x34, 0x41, 0x54, 0x2E, 0x29, 0x0E, 0xB2, 0x85, 0x02, 0x4C, 0x7C, 0x09, +/* 1420 */ 0x0D, 0x1B, 0x07, 0x02, 0x1E, 0x1B, 0x49, 0x63, 0x07, 0x36, 0xBC, 0x97, 0xA4, 0xC0, 0x2D, 0x44, +/* 1430 */ 0x1F, 0x7C, 0x0A, 0xB2, 0x1F, 0x90, 0x0B, 0x30, 0x77, 0x1F, 0x0B, 0x41, 0x9B, 0xA6, 0x42, 0x35, +/* 1440 */ 0x04, 0x36, 0x29, 0x0F, 0x6F, 0x09, 0x03, 0xB0, 0xC8, 0x04, 0x10, 0x07, 0x99, 0xE7, 0xEA, 0x4C, +/* 1450 */ 0x92, 0xEA, 0x10, 0x07, 0x99, 0xE7, 0xEA, 0x24, 0xBD, 0x7C, 0x0B, 0x9E, 0x4D, 0x91, 0x1E, 0xA4, +/* 1460 */ 0x7B, 0xDD, 0x0D, 0x99, 0x09, 0x2C, 0x21, 0xAF, 0x02, 0x45, 0xA8, 0xC4, 0x10, 0x0F, 0x43, 0x3B, +/* 1470 */ 0xA1, 0x7D, 0xBC, 0x94, 0x19, 0x1A, 0x0C, 0x18, 0x36, 0x4A, 0x85, 0x1B, 0xAB, 0xA8, 0x37, 0x30, +/* 1480 */ 0x67, 0x00, 0xA8, 0x08, 0x69, 0x22, 0x05, 0x28, 0x7C, 0x97, 0xA2, 0x04, 0x1F, 0x7C, 0x48, 0x9D, +/* 1490 */ 0x36, 0x7C, 0x97, 0x07, 0x7B, 0x7C, 0x97, 0x6F, 0x47, 0x36, 0x9F, 0x48, 0x9D, 0xA6, 0x29, 0x27, +/* 14A0 */ 0xAE, 0x04, 0xA6, 0x29, 0x0A, 0x41, 0x77, 0xA6, 0x7C, 0x09, 0xB2, 0x88, 0xA8, 0x08, 0x86, 0x04, +/* 14B0 */ 0x99, 0x93, 0x0B, 0x10, 0x0F, 0x3B, 0x3B, 0xC8, 0x2A, 0x87, 0xB0, 0x6B, 0xC8, 0x2A, 0x87, 0x10, +/* 14C0 */ 0x0F, 0x4B, 0xDF, 0xA1, 0x4E, 0xF3, 0x0C, 0x05, 0x7D, 0x4A, 0x1E, 0x67, 0xC0, 0xA9, 0x48, 0x67, +/* 14D0 */ 0x01, 0xA6, 0x4A, 0x0D, 0x48, 0x6F, 0x47, 0x8D, 0x1A, 0xB1, 0x6F, 0x5E, 0xA6, 0x29, 0x50, 0x96, +/* 14E0 */ 0x36, 0x7C, 0x63, 0x82, 0xC0, 0x42, 0x03, 0x36, 0x93, 0xAA, 0x82, 0x4C, 0x7C, 0x09, 0x0E, 0x30, +/* 14F0 */ 0x77, 0x2E, 0xBC, 0x27, 0xAE, 0x04, 0x28, 0x91, 0x41, 0xA7, 0xA6, 0x0A, 0x48, 0x9D, 0x36, 0x29, +/* 1500 */ 0x0F, 0x6F, 0x5E, 0x7D, 0x0A, 0x47, 0x10, 0x0E, 0x28, 0x95, 0x90, 0x06, 0x2F, 0x36, 0x7C, 0x0A, +/* 1510 */ 0x30, 0xBF, 0x4E, 0x1A, 0x9C, 0x06, 0x28, 0x3D, 0x1E, 0x96, 0x28, 0x71, 0x3A, 0x04, 0x05, 0x69, +/* 1520 */ 0x3A, 0x4C, 0x61, 0xEF, 0xAB, 0x07, 0xAE, 0xAB, 0xA8, 0xAB, 0x4A, 0xAE, 0xC0, 0xAF, 0xF5, 0x57, +/* 1530 */ 0x9F, 0x96, 0x55, 0xA8, 0x0C, 0x48, 0x07, 0xA6, 0xAF, 0x18, 0xC0, 0x2D, 0x6A, 0xC0, 0x50, 0x4D, +/* 1540 */ 0x0C, 0x56, 0xF3, 0x31, 0x19, 0x1A, 0x06, 0x06, 0x06, 0x03, 0x28, 0xBE, 0xBC, 0x07, 0x03, 0x7D, +/* 1550 */ 0xAD, 0x3E, 0x03, 0x0F, 0x70, 0x7B, 0x2D, 0x82, 0xA6, 0x29, 0x0F, 0x70, 0x7B, 0xAD, 0x07, 0x49, +/* 1560 */ 0xBC, 0x07, 0x03, 0x10, 0x1E, 0x55, 0x80, 0xB6, 0xBA, 0x05, 0x02, 0xA6, 0x81, 0x0E, 0x30, 0x1B, +/* 1570 */ 0x72, 0x24, 0x7C, 0x0B, 0x5B, 0x6F, 0x07, 0x57, 0x6D, 0x69, 0x41, 0xB2, 0x01, 0x7A, 0x59, 0x1B, +/* 1580 */ 0x09, 0x05, 0x04, 0x03, 0x3F, 0x0A, 0xAA, 0x77, 0x8C, 0xBC, 0x1E, 0x6F, 0x06, 0x88, 0xBB, 0x5C, +/* 1590 */ 0x55, 0xA1, 0x69, 0x89, 0x19, 0x4A, 0x58, 0x8D, 0xAD, 0xEF, 0xB0, 0x4A, 0x94, 0x1B, 0x0A, 0x05, +/* 15A0 */ 0xAB, 0x0A, 0x22, 0x55, 0x7C, 0x1E, 0x44, 0xA1, 0x0C, 0x97, 0x22, 0x02, 0x7C, 0x58, 0xAB, 0x61, +/* 15B0 */ 0x8E, 0xB0, 0x27, 0x48, 0x6E, 0x0A, 0x31, 0xAB, 0xA9, 0x8A, 0x6D, 0x0F, 0x22, 0x27, 0x6E, 0x07, +/* 15C0 */ 0x33, 0x00, 0x7C, 0x58, 0x00, 0x91, 0xA2, 0xAF, 0x6E, 0x04, 0x97, 0xAB, 0x6D, 0x70, 0xA1, 0x97, +/* 15D0 */ 0x03, 0xAF, 0x6E, 0x03, 0x20, 0xB0, 0x07, 0x33, 0x04, 0x97, 0x00, 0xAF, 0x6E, 0x02, 0x1E, 0x82, +/* 15E0 */ 0x83, 0x22, 0x00, 0x4A, 0x8E, 0xAF, 0x6E, 0x02, 0x20, 0xB0, 0x09, 0x56, 0xB0, 0x07, 0x33, 0x91, +/* 15F0 */ 0x76, 0x00, 0x29, 0x70, 0xAB, 0x09, 0x22, 0x61, 0x33, 0x91, 0x76, 0xBC, 0x8E, 0x00, 0x61, 0x0F, +/* 1600 */ 0xB3, 0x07, 0x33, 0x91, 0x18, 0x00, 0x4A, 0x56, 0x4E, 0x07, 0x8E, 0x00, 0x2D, 0x00, 0xAF, 0x44, +/* 1610 */ 0x00, 0x8B, 0x07, 0xAB, 0x6D, 0x70, 0x7C, 0x7E, 0x03, 0x0F, 0xA2, 0x29, 0x97, 0x03, 0xAB, 0x7C, +/* 1620 */ 0x0F, 0x76, 0xA9, 0x2C, 0x6F, 0x94, 0x35, 0x86, 0x0C, 0x0E, 0x56, 0x4E, 0xA9, 0xA2, 0xB0, 0x59, +/* 1630 */ 0x76, 0x0A, 0x30, 0x84, 0x4E, 0x61, 0x1E, 0xA4, 0xB0, 0x71, 0xA2, 0x7C, 0xAA, 0x6A, 0x55, 0x7C, +/* 1640 */ 0x8F, 0xAB, 0x07, 0x0D, 0x6F, 0x08, 0xB0, 0x29, 0x0B, 0x6F, 0x0A, 0x02, 0x45, 0x63, 0x05, 0x88, +/* 1650 */ 0xA8, 0xAA, 0x07, 0xC0, 0xBC, 0x2C, 0x22, 0x3C, 0x4E, 0xA1, 0x04, 0x72, 0x57, 0x6D, 0x30, 0x1B, +/* 1660 */ 0x0C, 0x26, 0x0D, 0x76, 0xAC, 0x29, 0x85, 0x97, 0xB2, 0x2E, 0x93, 0x9C, 0xB3, 0x24, 0xBC, 0x09, +/* 1670 */ 0x94, 0x0E, 0x0F, 0xB9, 0x0A, 0x07, 0x03, 0x10, 0x11, 0xB0, 0x73, 0x61, 0xE8, 0x10, 0x12, 0x73, +/* 1680 */ 0x3D, 0xB9, 0x0B, 0x09, 0x04, 0xAB, 0x60, 0x41, 0x22, 0x03, 0x4C, 0x3D, 0x1E, 0x58, 0x60, 0x2C, +/* 1690 */ 0x6F, 0x26, 0xAA, 0x1B, 0x60, 0x33, 0x83, 0x0F, 0x58, 0xFE, 0x00, 0x69, 0x51, 0xFE, 0x91, 0x0F, +/* 16A0 */ 0x18, 0xFE, 0x00, 0xAA, 0x03, 0xFE, 0x08, 0x75, 0x78, 0xBC, 0x1E, 0x6F, 0x26, 0x85, 0x89, 0x60, +/* 16B0 */ 0x0F, 0x41, 0x6F, 0x72, 0x4C, 0x3D, 0xB2, 0x05, 0x4C, 0x3D, 0x97, 0xA2, 0x60, 0x33, 0x02, 0x07, +/* 16C0 */ 0x69, 0x3A, 0xFE, 0x4A, 0x1E, 0x6F, 0xFE, 0x7C, 0x48, 0x03, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x48, +/* 16D0 */ 0x03, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, 0x29, 0x2C, 0x96, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, 0x62, 0x1E, +/* 16E0 */ 0x6F, 0x57, 0xBC, 0x1E, 0x6F, 0x26, 0x0C, 0x48, 0x3A, 0x24, 0x3D, 0x41, 0x77, 0x24, 0x3D, 0x1E, +/* 16F0 */ 0xA2, 0x01, 0x60, 0x30, 0xB9, 0x0B, 0x07, 0x02, 0x10, 0x11, 0x80, 0x02, 0x05, 0x07, 0x2F, 0x36, +/* 1700 */ 0x29, 0x0B, 0x30, 0x67, 0x6C, 0x4A, 0x41, 0x22, 0x02, 0x2E, 0x4A, 0x5B, 0x5F, 0xAC, 0x7C, 0x69, +/* 1710 */ 0x35, 0x06, 0x04, 0x65, 0x0F, 0xEF, 0x4C, 0x50, 0x77, 0xB0, 0x61, 0x05, 0xA8, 0x0F, 0x58, 0x7B, +/* 1720 */ 0x59, 0x0D, 0x49, 0x50, 0x0A, 0x7B, 0x91, 0x97, 0x07, 0x49, 0xAA, 0x3E, 0x54, 0x8C, 0xA8, 0x54, +/* 1730 */ 0x49, 0x54, 0x49, 0xAA, 0x3E, 0x85, 0x07, 0x49, 0x50, 0x0A, 0x49, 0x59, 0x0D, 0x7B, 0x7C, 0x48, +/* 1740 */ 0x4D, 0x50, 0x77, 0xAB, 0x4A, 0x0A, 0x4C, 0x29, 0x48, 0x67, 0x03, 0x05, 0x0B, 0xF5, 0x88, 0x07, +/* 1750 */ 0x41, 0x54, 0x28, 0x42, 0x30, 0x77, 0x4C, 0xBC, 0x0C, 0x30, 0x67, 0x36, 0x7C, 0x05, 0x07, 0x2F, +/* 1760 */ 0x10, 0x13, 0x73, 0x3D, 0xB9, 0x0B, 0x07, 0x03, 0xAB, 0x60, 0x41, 0x22, 0x03, 0x4C, 0x3D, 0x1E, +/* 1770 */ 0x58, 0x60, 0x2C, 0x6F, 0x26, 0x0D, 0x48, 0x84, 0xFE, 0x04, 0x0D, 0xAE, 0xFE, 0x00, 0x04, 0x2C, +/* 1780 */ 0x96, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x85, 0x07, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, 0x61, 0xAE, 0x78, +/* 1790 */ 0xBC, 0x1E, 0x1B, 0x55, 0x59, 0x0D, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x2D, 0x0E, 0x78, 0xBC, 0x1E, +/* 17A0 */ 0x1B, 0xAB, 0xBC, 0x48, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, 0xBC, 0x48, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, +/* 17B0 */ 0xBC, 0x48, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x2D, 0x0E, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x59, 0x0D, +/* 17C0 */ 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x63, 0x0A, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x85, 0x06, 0x78, 0xBC, +/* 17D0 */ 0x1E, 0x1B, 0x4E, 0x2D, 0xA3, 0x78, 0xBC, 0x1E, 0x1B, 0x00, 0xBC, 0xAA, 0x0A, 0x57, 0xBC, 0x1E, +/* 17E0 */ 0x6F, 0x26, 0x0D, 0x48, 0x84, 0x24, 0x3D, 0x30, 0xEF, 0x60, 0x41, 0xA2, 0x02, 0x4C, 0x3D, 0x1B, +/* 17F0 */ 0x0B, 0x08, 0x03, 0x10, 0x0F, 0x73, 0x3D, 0x30, 0x03, 0x4C, 0xC2, 0x58, 0x10, 0x0E, 0x73, 0x3D, +/* 1800 */ 0x97, 0x1B, 0x28, 0x3D, 0xB2, 0x28, 0x3D, 0x97, 0x3A, 0x2E, 0xBC, 0x1E, 0x6F, 0x26, 0x26, 0x26, +/* 1810 */ 0x04, 0x2E, 0xBC, 0x97, 0xEE, 0x2B, 0x97, 0xEB, 0x26, 0x26, 0x06, 0x6C, 0x3D, 0x8F, 0x6C, 0x3D, +/* 1820 */ 0x8F, 0x6C, 0x3D, 0x8F, 0x4E, 0xFE, 0x1F, 0xBC, 0x97, 0xEE, 0x2B, 0x97, 0xEE, 0x10, 0x13, 0x00, +/* 1830 */ 0x80, 0x3F, 0xBA, 0x3C, 0x55, 0xA8, 0xA0, 0x0F, 0xB2, 0x03, 0x4C, 0xBC, 0x9C, 0xA5, 0x57, 0xBC, +/* 1840 */ 0x9C, 0x1E, 0x03, 0xAC, 0xA1, 0x85, 0x0E, 0x07, 0x5D, 0x07, 0x0D, 0x2C, 0x05, 0xAC, 0x61, 0x97, +/* 1850 */ 0x89, 0x4E, 0xBB, 0x07, 0x2E, 0x34, 0x7E, 0xC0, 0x59, 0x0D, 0x49, 0x09, 0x8F, 0x7B, 0x91, 0x97, +/* 1860 */ 0x07, 0x49, 0xAA, 0x05, 0x49, 0x97, 0x5A, 0x03, 0x30, 0x3A, 0x78, 0xA1, 0x97, 0x5A, 0x01, 0x30, +/* 1870 */ 0x3A, 0xAC, 0x0F, 0x58, 0xAB, 0x69, 0x8A, 0x57, 0xAA, 0x05, 0xAB, 0x09, 0x0B, 0x0C, 0x1E, 0x3A, +/* 1880 */ 0xAC, 0x85, 0x06, 0xAB, 0xBC, 0x1E, 0x3A, 0xAC, 0x27, 0x3A, 0xAB, 0xBC, 0x1E, 0x3A, 0x78, 0x61, +/* 1890 */ 0x5C, 0x00, 0xBC, 0x1E, 0x3A, 0x57, 0x29, 0x97, 0xA4, 0xB0, 0xBC, 0x1E, 0x3A, 0x24, 0x85, 0x07, +/* 18A0 */ 0xB0, 0xBC, 0x1E, 0x3A, 0xAC, 0x4A, 0x0F, 0x8F, 0x04, 0x3F, 0x85, 0x39, 0x66, 0x41, 0x8A, 0xAC, +/* 18B0 */ 0xA1, 0x0B, 0x5B, 0xBF, 0x4C, 0x4A, 0x85, 0x56, 0x06, 0xA6, 0x7C, 0x05, 0x07, 0xBA, 0x98, 0x10, +/* 18C0 */ 0x13, 0x19, 0x80, 0xFE, 0xB0, 0x63, 0x39, 0xD1, 0x1B, 0x55, 0x63, 0x39, 0xD1, 0x1B, 0x4E, 0xAD, +/* 18D0 */ 0x3A, 0x78, 0xBC, 0x97, 0xEB, 0x26, 0x26, 0x85, 0x08, 0xAC, 0x3D, 0x30, 0x8A, 0x57, 0x3D, 0x30, +/* 18E0 */ 0x8A, 0x57, 0x3D, 0x30, 0x8A, 0x7A, 0xBC, 0x1E, 0x1B, 0x4E, 0xAD, 0x3A, 0x78, 0xBC, 0x1E, 0x1B, +/* 18F0 */ 0x55, 0x63, 0x39, 0xD1, 0x1B, 0x55, 0x63, 0x39, 0xD1, 0x1B, 0x4E, 0xAD, 0x3A, 0x10, 0x09, 0x73, +/* 1900 */ 0xE9, 0x10, 0x09, 0x73, 0x83, 0x8F, 0xC0, 0x61, 0xCE, 0xCE, 0xCE, 0x8F, 0x49, 0x63, 0x21, 0x27, +/* 1910 */ 0x51, 0x8C, 0xA8, 0x48, 0x03, 0x8D, 0xA8, 0x0C, 0x75, 0x1F, 0x29, 0xAA, 0x5A, 0x4E, 0xA8, 0x48, +/* 1920 */ 0x07, 0x49, 0x0B, 0x0F, 0x6F, 0x05, 0x19, 0x1A, 0x0E, 0x72, 0x7A, 0xA8, 0x10, 0x13, 0x19, 0x80, +/* 1930 */ 0xFE, 0x00, 0xA1, 0xAA, 0x03, 0x7A, 0xBC, 0x1E, 0x1B, 0x55, 0x09, 0x8F, 0x78, 0xBC, 0x1E, 0x1B, +/* 1940 */ 0xAB, 0x29, 0x97, 0xA4, 0x78, 0xBC, 0x1E, 0x1B, 0x4E, 0x27, 0x51, 0xFE, 0x2D, 0x0C, 0x00, 0xFE, +/* 1950 */ 0x85, 0x03, 0x60, 0x33, 0x07, 0x8F, 0x24, 0xBC, 0x1E, 0x1B, 0xA1, 0x69, 0xA4, 0x24, 0xBC, 0x1E, +/* 1960 */ 0x1B, 0xAD, 0x51, 0x2E, 0xBC, 0x97, 0x74, 0x75, 0x24, 0xBC, 0x1E, 0x1B, 0x27, 0x51, 0x4C, 0xBC, +/* 1970 */ 0x1E, 0x1B, 0x63, 0x0C, 0x4C, 0xBC, 0x97, 0x89, 0x54, 0x2E, 0xBC, 0x1E, 0x1B, 0xAD, 0x1B, 0x2E, +/* 1980 */ 0xBC, 0x1E, 0x1B, 0x7C, 0x2C, 0x18, 0x00, 0x60, 0x33, 0x63, 0xA4, 0x60, 0x33, 0x02, 0x97, 0x44, +/* 1990 */ 0xFE, 0x08, 0x97, 0xA4, 0xFE, 0x01, 0x69, 0x3A, 0xFE, 0x83, 0x2C, 0x96, 0x78, 0xBC, 0x1E, 0x1B, +/* 19A0 */ 0x4E, 0x34, 0x8F, 0x78, 0xBC, 0x1E, 0x1B, 0xAB, 0x61, 0x48, 0x03, 0x7A, 0xBC, 0x1E, 0x1B, 0x55, +/* 19B0 */ 0x34, 0xAE, 0x10, 0x0F, 0x80, 0x2B, 0x1E, 0x1B, 0x2B, 0x1E, 0x1B, 0x2B, 0x1E, 0x1B, 0x2B, 0x1E, +/* 19C0 */ 0x6F, 0x2A, 0x06, 0x4C, 0x3D, 0x1E, 0x18, 0x00, 0x60, 0x41, 0x58, 0x4C, 0x3D, 0x1E, 0x96, 0x10, +/* 19D0 */ 0x17, 0x00, 0x73, 0x63, 0x6F, 0xAB, 0x1D, 0xA2, 0x78, 0x71, 0x70, 0xAB, 0x32, 0x56, 0x78, 0xB1, +/* 19E0 */ 0x5A, 0x00, 0x3D, 0x0C, 0x7A, 0x91, 0x30, 0x07, 0xB0, 0x4A, 0x48, 0x1B, 0x19, 0xA9, 0x48, 0xA5, +/* 19F0 */ 0x83, 0x48, 0x1B, 0x19, 0x1D, 0x1B, 0xB3, 0x00, 0x0B, 0x0F, 0x1B, 0x8E, 0x7A, 0xAE, 0x0F, 0x6F, +/* 1A00 */ 0x00, 0xA9, 0xC4, 0x97, 0x7A, 0x32, 0x3A, 0x96, 0xA1, 0x2C, 0x3A, 0x70, 0x45, 0x7C, 0x0F, 0x18, +/* 1A10 */ 0x76, 0x29, 0x18, 0x20, 0x88, 0x29, 0x97, 0x03, 0x8A, 0x06, 0x2C, 0xEF, 0x97, 0x03, 0x88, 0xBC, +/* 1A20 */ 0x97, 0x03, 0x0D, 0x2C, 0x0A, 0x83, 0x0F, 0x35, 0x03, 0x58, 0x19, 0x2D, 0x02, 0x71, 0x0D, 0x00, +/* 1A30 */ 0x0B, 0x2C, 0x09, 0x03, 0x7E, 0x45, 0x59, 0x02, 0x07, 0x40, 0x0D, 0x0F, 0x51, 0x02, 0x0F, 0x18, +/* 1A40 */ 0x19, 0x42, 0x02, 0x04, 0x1E, 0x04, 0x1E, 0x03, 0x02, 0x97, 0x07, 0x88, 0x61, 0x70, 0x01, 0x31, +/* 1A50 */ 0x40, 0x32, 0x3A, 0x88, 0x61, 0x70, 0x00, 0x0D, 0x2C, 0x86, 0x0D, 0xA1, 0x8F, 0x19, 0x63, 0xB0, +/* 1A60 */ 0x0A, 0x0F, 0x5C, 0x5C, 0x88, 0x50, 0xB0, 0x42, 0x44, 0x00, 0xAE, 0x19, 0x0B, 0x97, 0xBC, 0x54, +/* 1A70 */ 0x1D, 0x35, 0x45, 0x91, 0x8E, 0xA1, 0x2C, 0x96, 0x1D, 0x1B, 0x88, 0xA9, 0x8E, 0x61, 0x09, 0x09, +/* 1A80 */ 0x09, 0x39, 0xA9, 0x8E, 0x8C, 0x1D, 0x1B, 0x7A, 0x85, 0x19, 0x1E, 0x1B, 0x19, 0x91, 0x70, 0x10, +/* 1A90 */ 0x13, 0x73, 0x3D, 0xC7, 0xF9, 0x10, 0x14, 0x80, 0xDA, 0x2F, 0x10, 0x11, 0x73, 0x04, 0x41, 0x9E, +/* 1AA0 */ 0x09, 0x04, 0x4C, 0xBC, 0x5B, 0x74, 0x4C, 0x3D, 0x1E, 0x58, 0x60, 0x1E, 0xEB, 0x94, 0x48, 0xA4, +/* 1AB0 */ 0xFE, 0x06, 0x48, 0x07, 0xFE, 0x00, 0x0A, 0xAE, 0xFE, 0x4A, 0x1E, 0x1B, 0xFE, 0x6D, 0x1E, 0x1B, +/* 1AC0 */ 0xFE, 0x4A, 0x0F, 0x22, 0xFE, 0x00, 0x50, 0x0A, 0xFE, 0x59, 0x51, 0x57, 0xBC, 0x1E, 0x6F, 0x26, +/* 1AD0 */ 0xAA, 0x1B, 0x60, 0x5B, 0x5A, 0x78, 0xBC, 0x5B, 0x74, 0x24, 0xBC, 0x41, 0xB9, 0x0A, 0x05, 0x4C, +/* 1AE0 */ 0xBC, 0x97, 0xEE, 0x2B, 0x97, 0xEE, 0x10, 0x14, 0x80, 0x02, 0x05, 0x07, 0x07, 0x05, 0x03, 0xA6, +/* 1AF0 */ 0xBC, 0x0C, 0x30, 0x67, 0x1F, 0xB8, 0xAE, 0x28, 0x42, 0x48, 0xA2, 0x24, 0x29, 0x2C, 0xA2, 0x5D, +/* 1B00 */ 0x09, 0x54, 0x66, 0xA5, 0xB0, 0x42, 0x0D, 0x57, 0x7C, 0x0F, 0x70, 0x55, 0x0E, 0x58, 0x57, 0x07, +/* 1B10 */ 0xAE, 0x8D, 0x09, 0x8F, 0x57, 0x8B, 0x3A, 0x8D, 0x59, 0x0C, 0x57, 0x85, 0x07, 0x4E, 0xBC, 0x48, +/* 1B20 */ 0x57, 0xAA, 0x05, 0x55, 0x29, 0x0F, 0x70, 0x78, 0x54, 0x55, 0x29, 0x2C, 0x96, 0x78, 0x54, 0x55, +/* 1B30 */ 0x7C, 0x48, 0x03, 0x78, 0x54, 0x55, 0x29, 0x2C, 0x96, 0x78, 0xAA, 0x05, 0x55, 0x29, 0x2C, 0x96, +/* 1B40 */ 0x78, 0x85, 0x07, 0x4E, 0xBC, 0x1E, 0x6F, 0x57, 0x8B, 0x3A, 0x8D, 0x59, 0x0C, 0x57, 0x07, 0xAE, +/* 1B50 */ 0x8D, 0x63, 0x07, 0x78, 0x7C, 0x0F, 0x70, 0xAB, 0xA9, 0x70, 0x57, 0x91, 0x8F, 0x4E, 0x42, 0x07, +/* 1B60 */ 0x57, 0xBC, 0x2C, 0xA2, 0x5D, 0x08, 0xAE, 0x4C, 0x09, 0x30, 0xB2, 0x01, 0x28, 0x0A, 0x30, 0x22, +/* 1B70 */ 0x04, 0x02, 0xAB, 0x1A, 0x85, 0x48, 0x6F, 0x72, 0x28, 0xB6, 0x08, 0x0A, 0x0D, 0x30, 0x74, 0x8C, +/* 1B80 */ 0x1A, 0x85, 0x5F, 0xC0, 0x9F, 0x82, 0x49, 0x0A, 0x51, 0x38, 0x93, 0x10, 0x12, 0x73, 0x04, 0x41, +/* 1B90 */ 0xB9, 0x0A, 0x06, 0x01, 0x28, 0x3D, 0x97, 0x6F, 0x06, 0x4C, 0x3D, 0x41, 0x07, 0x60, 0x2C, 0x6F, +/* 1BA0 */ 0x26, 0x0D, 0x1E, 0x96, 0xFE, 0x2D, 0x3A, 0xFE, 0xAD, 0xB5, 0xFE, 0x4A, 0x1E, 0x1B, 0xFE, 0x00, +/* 1BB0 */ 0x42, 0x0C, 0xFE, 0x00, 0x50, 0x0A, 0xFE, 0x2D, 0x51, 0x57, 0xBC, 0x1E, 0x6F, 0x26, 0x0D, 0x48, +/* 1BC0 */ 0xA4, 0x24, 0x3D, 0x30, 0xEF, 0x60, 0x41, 0x22, 0x02, 0x00, 0x60, 0x41, 0x18, 0x2E, 0xBC, 0x1E, +/* 1BD0 */ 0x1B, 0x29, 0x0F, 0x33, 0x60, 0x33, 0x0C, 0x0F, 0x18, 0x00, 0x60, 0x33, 0x05, 0x0F, 0x33, 0xFE, +/* 1BE0 */ 0x85, 0x06, 0x00, 0xFE, 0x42, 0x0D, 0x00, 0xFE, 0x34, 0x0F, 0x18, 0xFE, 0x83, 0x1E, 0x1B, 0xFE, +/* 1BF0 */ 0x7C, 0x2C, 0x18, 0x78, 0xBC, 0x1E, 0x1B, 0x55, 0x8B, 0x1B, 0x10, 0x11, 0x1F, 0x95, 0x3F, 0xBA, +/* 1C00 */ 0x98, 0x36, 0xBB, 0x69, 0xA2, 0x02, 0x28, 0x7C, 0x85, 0x30, 0x07, 0xA8, 0x0D, 0x5B, 0x82, 0xAC, +/* 1C10 */ 0x59, 0x3A, 0x5D, 0xA0, 0xF5, 0x8D, 0x91, 0x1E, 0x3A, 0xAB, 0xA1, 0x26, 0x28, 0x0E, 0x58, 0x55, +/* 1C20 */ 0xA1, 0x28, 0x48, 0x07, 0x49, 0x85, 0x0E, 0x05, 0x7B, 0x8B, 0x22, 0x06, 0x01, 0x1F, 0x29, 0x41, +/* 1C30 */ 0x6F, 0x72, 0x1F, 0x42, 0x97, 0x6F, 0x05, 0x4E, 0x1A, 0x9C, 0x06, 0xAB, 0xA8, 0xA0, 0x41, 0x84, +/* 1C40 */ 0x4E, 0xA8, 0x06, 0x85, 0xF5, 0xAC, 0x42, 0x35, 0x49, 0x8B, 0x6F, 0x49, 0x59, 0x0E, 0x2E, 0x7C, +/* 1C50 */ 0x8C, 0x42, 0x0C, 0x24, 0x29, 0xEB, 0x02, 0x4E, 0x91, 0x8F, 0xAC, 0x7C, 0x0D, 0x0F, 0x6F, 0x09, +/* 1C60 */ 0x05, 0x03, 0x05, 0x0C, 0x48, 0x03, 0xAC, 0xAD, 0x30, 0x8F, 0x4C, 0xB8, 0x2C, 0xA2, 0x28, 0x29, +/* 1C70 */ 0x0A, 0x69, 0x22, 0x05, 0xC0, 0x3F, 0x68, 0x10, 0x10, 0xC0, 0x80, 0x91, 0x5B, 0xA2, 0x57, 0xAF, +/* 1C80 */ 0x5B, 0x44, 0x78, 0xAF, 0x41, 0x54, 0x57, 0x61, 0x26, 0x26, 0x69, 0x35, 0x26, 0x26, 0x02, 0x8D, +/* 1C90 */ 0x4F, 0x45, 0x4F, 0x45, 0x4F, 0xC0, 0xF4, 0x49, 0xF4, 0x49, 0xF4, 0x49, 0xF4, 0x10, 0x13, 0x73, +/* 1CA0 */ 0x08, 0x97, 0xD0, 0xCC, 0x01, 0x10, 0x11, 0xA6, 0x80, 0xBC, 0x48, 0x55, 0xA1, 0x0F, 0x70, 0x57, +/* 1CB0 */ 0x48, 0x03, 0xAB, 0xBC, 0x0F, 0x22, 0x4F, 0xB0, 0x4A, 0x8F, 0x78, 0x61, 0x8F, 0x55, 0x63, 0x05, +/* 1CC0 */ 0x78, 0xBC, 0x75, 0xB0, 0x91, 0x70, 0xAC, 0x32, 0x6F, 0xAB, 0x1D, 0x1B, 0x24, 0x91, 0x1E, 0x82, +/* 1CD0 */ 0x7C, 0x8F, 0xAC, 0x61, 0x0F, 0x18, 0xAB, 0x2D, 0x06, 0x60, 0x8A, 0x61, 0x20, 0xAC, 0xA1, 0xAE, +/* 1CE0 */ 0xAB, 0x71, 0x6F, 0x4C, 0x91, 0x8E, 0xA9, 0xA2, 0x2E, 0x61, 0x20, 0x32, 0x44, 0x24, 0xBC, 0x7E, +/* 1CF0 */ 0x04, 0x97, 0x03, 0x28, 0x32, 0x3A, 0x4A, 0x8E, 0x28, 0x91, 0x56, 0xAD, 0x0B, 0x28, 0x61, 0x8E, +/* 1D00 */ 0x0C, 0x8A, 0x6C, 0x2D, 0x02, 0x69, 0x04, 0xAB, 0xA8, 0x97, 0x07, 0x70, 0x6C, 0xAF, 0x1B, 0x22, +/* 1D10 */ 0xA6, 0xAD, 0x8F, 0x36, 0x2D, 0x76, 0x36, 0x32, 0x20, 0x36, 0x85, 0x1B, 0x10, 0x19, 0x7B, 0x80, +/* 1D20 */ 0x8B, 0x5A, 0x6D, 0x2C, 0x96, 0xAB, 0x59, 0x05, 0x4E, 0x61, 0x0F, 0x18, 0xAB, 0x42, 0x5A, 0x83, +/* 1D30 */ 0x97, 0x03, 0x8D, 0x59, 0x07, 0xAB, 0x09, 0x54, 0xAB, 0x0A, 0x70, 0x4E, 0xBC, 0x8F, 0xAB, 0xB1, +/* 1D40 */ 0x07, 0xAB, 0x27, 0x0E, 0x8D, 0x7C, 0x5C, 0x00, 0x85, 0xA5, 0x00, 0x0D, 0x22, 0x88, 0x75, 0x00, +/* 1D50 */ 0x2C, 0x6F, 0xC4, 0xAB, 0x5C, 0x4E, 0xA9, 0x33, 0x02, 0x56, 0x0F, 0x1B, 0x00, 0x7C, 0x1E, 0x3A, +/* 1D60 */ 0x88, 0x0B, 0x97, 0xBC, 0x1E, 0x07, 0x1E, 0x00, 0x29, 0x0F, 0x18, 0x88, 0x09, 0x70, 0x4A, 0x2C, +/* 1D70 */ 0xBF, 0x96, 0x6D, 0x58, 0x88, 0x42, 0x03, 0x83, 0xC4, 0x03, 0x1E, 0x04, 0x00, 0x07, 0x70, 0x8C, +/* 1D80 */ 0x6D, 0x58, 0x00, 0x71, 0x9B, 0x18, 0x83, 0x8E, 0x8C, 0x7C, 0x0F, 0x18, 0x00, 0x0D, 0x0F, 0x44, +/* 1D90 */ 0x86, 0x39, 0x0A, 0x22, 0x19, 0x1E, 0x44, 0x86, 0x05, 0x91, 0x2C, 0x0A, 0x91, 0xA2, 0x88, 0xA9, +/* 1DA0 */ 0x1E, 0x9D, 0x1E, 0x03, 0x00, 0x0A, 0xC4, 0x00, 0x0E, 0x0F, 0xF5, 0x0B, 0xA2, 0x04, 0x40, 0x83, +/* 1DB0 */ 0x0F, 0x1B, 0x00, 0x0F, 0x18, 0x19, 0x09, 0x22, 0x06, 0x0F, 0x6F, 0x00, 0x4A, 0x96, 0x58, 0x19, +/* 1DC0 */ 0x07, 0x2C, 0x1B, 0x08, 0xB3, 0x04, 0x18, 0x20, 0x45, 0x2D, 0x71, 0x0A, 0x00, 0x7C, 0x1E, 0x63, +/* 1DD0 */ 0x19, 0x29, 0x1E, 0x1B, 0x0F, 0x3A, 0xAB, 0x2C, 0x1B, 0x33, 0x88, 0xA1, 0x97, 0x18, 0xAB, 0x85, +/* 1DE0 */ 0xC4, 0x19, 0x1D, 0x58, 0xAB, 0x0B, 0x97, 0xF5, 0xAF, 0x70, 0xB0, 0xAD, 0x18, 0x78, 0x50, 0x6F, +/* 1DF0 */ 0x4E, 0xB8, 0x04, 0x10, 0x11, 0x36, 0x80, 0x61, 0x1E, 0x1B, 0x55, 0x85, 0x06, 0x57, 0x7C, 0x97, +/* 1E00 */ 0x82, 0x29, 0x1E, 0x1B, 0x24, 0xAD, 0x3A, 0xB0, 0xAD, 0x51, 0x24, 0x7C, 0x0F, 0x8E, 0xA1, 0x86, +/* 1E10 */ 0x6F, 0x28, 0x0A, 0x58, 0x00, 0x59, 0xE2, 0x03, 0x0F, 0xA2, 0x00, 0x27, 0xA4, 0x4E, 0x66, 0xEF, +/* 1E20 */ 0x97, 0xE2, 0xBC, 0x1E, 0x1B, 0x1E, 0xA4, 0x1F, 0x91, 0x41, 0x07, 0x8D, 0x1A, 0x30, 0xA4, 0xC0, +/* 1E30 */ 0x85, 0x3A, 0x7B, 0xAA, 0x1B, 0xC0, 0x59, 0x76, 0x36, 0x85, 0x56, 0xA6, 0x2D, 0x0C, 0x97, 0x03, +/* 1E40 */ 0x55, 0x66, 0x74, 0x5C, 0x2E, 0x29, 0x1E, 0x3A, 0x91, 0x20, 0x4C, 0x8B, 0xA3, 0x4A, 0x8F, 0x2E, +/* 1E50 */ 0x7C, 0x75, 0x34, 0x70, 0x2E, 0x63, 0x07, 0xAB, 0x8B, 0x3A, 0x24, 0x34, 0x70, 0x00, 0xBC, 0x97, +/* 1E60 */ 0xA4, 0x78, 0x61, 0xAE, 0x55, 0x85, 0x07, 0x57, 0x34, 0x7E, 0xB0, 0x61, 0x1E, 0x1B, 0x10, 0x11, +/* 1E70 */ 0xC0, 0x80, 0x32, 0xD4, 0x10, 0x10, 0x73, 0x0B, 0x5B, 0x6F, 0x4C, 0x0B, 0x5B, 0x6F, 0x4C, 0x0B, +/* 1E80 */ 0x5B, 0x6F, 0x24, 0x61, 0x2A, 0x69, 0x1B, 0xC0, 0x29, 0x48, 0x07, 0x45, 0x66, 0x1B, 0x88, 0x1A, +/* 1E90 */ 0x54, 0x7B, 0x85, 0x0C, 0x7B, 0x59, 0x82, 0xA6, 0x34, 0x5C, 0x1F, 0x61, 0x2C, 0x96, 0x36, 0x7C, +/* 1EA0 */ 0x97, 0x3A, 0x7B, 0x50, 0xA4, 0x36, 0x29, 0x2C, 0x18, 0x45, 0x66, 0x1B, 0x88, 0x1A, 0x54, 0x36, +/* 1EB0 */ 0xA9, 0xAE, 0x7B, 0x59, 0x82, 0xA6, 0x34, 0x5C, 0x36, 0x42, 0x35, 0x0B, 0x2A, 0x01, 0x57, 0x61, +/* 1EC0 */ 0x1E, 0x5B, 0x2E, 0xB8, 0x30, 0x1B, 0x2E, 0xB8, 0x97, 0xA2, 0x10, 0x09, 0xA6, 0xBD, 0x7C, 0x97, +/* 1ED0 */ 0x22, 0xA6, 0x7C, 0x97, 0x22, 0xA6, 0x7C, 0x97, 0x22, 0xA6, 0x7C, 0x1E, 0x1B, 0x26, 0x08, 0xA6, +/* 1EE0 */ 0x7C, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, 0x97, 0x21, 0x02, +/* 1EF0 */ 0x97, 0xCB, 0x97, 0xCB, 0x97, 0xCB, 0x1E, 0x1B, 0x26, 0x08, 0xA6, 0x7C, 0x97, 0x22, 0xA6, 0x7C, +/* 1F00 */ 0x97, 0x22, 0xA6, 0x7C, 0x97, 0x22, 0x10, 0x0F, 0x49, 0x43, 0xBC, 0x07, 0x94, 0x04, 0x7B, 0x1D, +/* 1F10 */ 0x3A, 0x7D, 0x0A, 0x56, 0x7D, 0x42, 0x49, 0x29, 0x58, 0x7D, 0x0E, 0x64, 0x66, 0x0B, 0xB0, 0xC8, +/* 1F20 */ 0x8E, 0xC0, 0xBC, 0x97, 0x03, 0x49, 0x32, 0x44, 0x7B, 0x91, 0x46, 0x08, 0x8E, 0xC0, 0xBC, 0x97, +/* 1F30 */ 0x03, 0x88, 0xA8, 0x97, 0x3E, 0x91, 0x46, 0x09, 0x8E, 0xCD, 0x02, 0x49, 0x32, 0x51, 0xF3, 0x31, +/* 1F40 */ 0x49, 0xAD, 0x0D, 0x7D, 0x59, 0x02, 0x7B, 0x7C, 0x0F, 0x76, 0xF3, 0x31, 0x7D, 0x71, 0x1B, 0x49, +/* 1F50 */ 0x4A, 0x70, 0x7B, 0x29, 0x7E, 0xC0, 0x1D, 0x3A, 0x7D, 0x0A, 0x0F, 0xB3, 0xC8, 0x2C, 0xEB, 0x49, +/* 1F60 */ 0x7C, 0x06, 0x03, 0x10, 0x09, 0xBD, 0xDB, 0xDB, 0xDB, 0x1F, 0xBC, 0x0B, 0x26, 0x97, 0x21, 0xD6, +/* 1F70 */ 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, 0x49, 0xD6, +/* 1F80 */ 0x49, 0xD6, 0x88, 0xA8, 0x97, 0x21, 0xD6, 0x1F, 0xBC, 0x26, 0x27, 0x3A, 0xDB, 0xDB, 0xDB, 0x10, +/* 1F90 */ 0x10, 0x7D, 0x92, 0x7C, 0x08, 0x08, 0x08, 0x08, 0x4D, 0x63, 0x0D, 0xC0, 0x7C, 0x30, 0x07, 0xC0, +/* 1FA0 */ 0x0A, 0x30, 0xA4, 0x1F, 0x29, 0x1E, 0x1B, 0x64, 0x19, 0x0B, 0x31, 0x06, 0x1E, 0xA4, 0x28, 0x29, +/* 1FB0 */ 0x97, 0x03, 0x34, 0x8A, 0x28, 0x0B, 0x22, 0x61, 0x1E, 0xA4, 0x24, 0xBC, 0x1E, 0x6E, 0x32, 0x3A, +/* 1FC0 */ 0x24, 0xAF, 0x6F, 0xAB, 0xAD, 0x84, 0x57, 0xBC, 0x1E, 0x3A, 0xAB, 0x7C, 0x8F, 0x10, 0x0F, 0x4E, +/* 1FD0 */ 0x92, 0xE7, 0xE7, 0x61, 0x26, 0x26, 0x26, 0x2A, 0x39, 0x66, 0x41, 0x22, 0x00, 0x66, 0x41, 0x22, +/* 1FE0 */ 0x00, 0x66, 0x41, 0x22, 0x10, 0x0A, 0xC0, 0xBD, 0x7C, 0x03, 0x00, 0x38, 0x09, 0x0F, 0x72, 0x49, +/* 1FF0 */ 0x7C, 0x2C, 0x1B, 0x4D, 0x0A, 0x48, 0x9B, 0xC0, 0x81, 0x48, 0x89, 0xC0, 0x7C, 0xA0, 0x0F, 0x1B, +/* 2000 */ 0x19, 0xA8, 0x06, 0xF2, 0x10, 0x10, 0x52, 0xDC, 0xB5, 0xEC, 0x10, 0x11, 0x3B, 0x01, 0x03, 0x04, +/* 2010 */ 0x03, 0xF1, 0x00, 0x6D, 0x2F, 0x6C, 0x79, 0x04, 0x85, 0x0A, 0x01, 0x4C, 0x2D, 0x0C, 0x97, 0xA2, +/* 2020 */ 0x4C, 0x2D, 0x48, 0x58, 0x2E, 0x2D, 0x1B, 0x05, 0x04, 0x85, 0x0A, 0x2E, 0x2D, 0x84, 0x00, 0x29, +/* 2030 */ 0x1E, 0x6F, 0x2E, 0x79, 0x4E, 0x69, 0xA3, 0x24, 0x79, 0xAB, 0x91, 0x58, 0x24, 0x79, 0x4E, 0x0B, +/* 2040 */ 0x7E, 0xAC, 0x79, 0x4E, 0x27, 0x51, 0x24, 0x79, 0x4E, 0x0B, 0x7E, 0xAC, 0x79, 0xAB, 0x91, 0x58, +/* 2050 */ 0x24, 0x79, 0x4E, 0x0E, 0x70, 0xAC, 0x6D, 0x75, 0x6D, 0x0F, 0x22, 0x1A, 0x2C, 0xA2, 0x04, 0x05, +/* 2060 */ 0x69, 0x3A, 0x1A, 0x0F, 0x5B, 0xA4, 0x1A, 0x0F, 0x22, 0x1E, 0x7E, 0x1A, 0x0F, 0x96, 0x08, 0x1E, +/* 2070 */ 0x6F, 0x3E, 0x02, 0x06, 0x07, 0x3C, 0x10, 0x0E, 0xE7, 0xB6, 0x06, 0x98, 0x8C, 0x1A, 0x85, 0x6F, +/* 2080 */ 0x07, 0xA6, 0x07, 0x30, 0xA2, 0xAB, 0x1A, 0x30, 0x58, 0x00, 0xA8, 0x0D, 0xAE, 0x5D, 0xA0, 0x08, +/* 2090 */ 0x6C, 0x2D, 0x0C, 0xAB, 0x7C, 0x1F, 0x50, 0x3E, 0x85, 0x03, 0x49, 0x2C, 0x96, 0x8C, 0xA8, 0x0F, +/* 20A0 */ 0x70, 0x49, 0x2C, 0x96, 0x49, 0xAA, 0x03, 0x7A, 0x4F, 0xC0, 0x07, 0xAE, 0xAB, 0xA1, 0x6C, 0x7C, +/* 20B0 */ 0x2C, 0xA2, 0x5D, 0xA0, 0x05, 0x1F, 0x42, 0x48, 0x84, 0x1F, 0x09, 0x30, 0xA2, 0x1F, 0x4A, 0x85, +/* 20C0 */ 0x6F, 0x72, 0xC0, 0xB6, 0x07, 0x98, 0x10, 0x11, 0x8C, 0x3B, 0x90, 0x03, 0x02, 0x7D, 0x29, 0x5C, +/* 20D0 */ 0x36, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x1F, +/* 20E0 */ 0xB6, 0x3C, 0x03, 0xAE, 0x28, 0x9F, 0x2C, 0x67, 0xAE, 0xA8, 0x0C, 0x30, 0xB2, 0x24, 0x61, 0x41, +/* 20F0 */ 0xB2, 0x24, 0x7C, 0x0F, 0x8F, 0x04, 0x07, 0xB2, 0x24, 0x4A, 0xAE, 0xB0, 0x4A, 0xAE, 0x2E, 0xF7, +/* 2100 */ 0x60, 0x1E, 0x3A, 0x04, 0x08, 0xB2, 0x2E, 0x91, 0x41, 0xB2, 0x2E, 0x29, 0x41, 0xB7, 0x56, 0x2E, +/* 2110 */ 0xBC, 0x0E, 0xAE, 0x01, 0x0A, 0x56, 0x4E, 0x1A, 0x2F, 0x10, 0x10, 0xE7, 0xFB, 0xC8, 0xF6, 0x10, +/* 2120 */ 0x0B, 0x00, 0x3B, 0x4A, 0x94, 0x0F, 0xEB, 0x47, 0x4E, 0xA8, 0x0C, 0x41, 0x07, 0xA6, 0x50, 0x20, +/* 2130 */ 0x28, 0x29, 0x48, 0xB7, 0xEB, 0xA6, 0x07, 0x8F, 0x00, 0xA1, 0x02, 0xA6, 0x63, 0x05, 0x49, 0x50, +/* 2140 */ 0x4D, 0x0A, 0x58, 0xC0, 0x9C, 0x0A, 0x1F, 0x9C, 0x08, 0x1F, 0x9C, 0x06, 0x1F, 0x0A, 0x0B, 0x85, +/* 2150 */ 0x0C, 0x26, 0x03, 0x36, 0x50, 0xFC, 0x50, 0xFC, 0x50, 0xFC, 0x50, 0xFC, 0x0A, 0x58, 0x10, 0x10, +/* 2160 */ 0xBD, 0x3B, 0x06, 0x99, 0x93, 0x0D, 0x82, 0x28, 0xB6, 0x08, 0x09, 0x0C, 0x97, 0xE2, 0x06, 0x9C, +/* 2170 */ 0x35, 0x4C, 0x71, 0x41, 0xB9, 0x0B, 0x06, 0x2E, 0x42, 0x48, 0x3A, 0x4C, 0xA9, 0x8F, 0x04, 0x05, +/* 2180 */ 0x0D, 0xA2, 0x2E, 0x7C, 0x75, 0x00, 0x04, 0x58, 0x24, 0x29, 0x5C, 0x7C, 0x1E, 0x3A, 0x24, 0x7C, +/* 2190 */ 0x75, 0x29, 0x1E, 0x3A, 0x4C, 0x69, 0x51, 0x01, 0x02, 0x27, 0x51, 0x4C, 0x07, 0x5B, 0xA4, 0x2E, +/* 21A0 */ 0x61, 0x41, 0x18, 0x1F, 0x0B, 0x30, 0x6F, 0x06, 0x6C, 0xAD, 0x08, 0x0A, 0x0A, 0x08, 0x3C, 0x6C, +/* 21B0 */ 0x7C, 0x22, 0x00, 0xCD, 0x0C, 0x26, 0x0A, 0x0A, 0x07, 0x03, 0x28, 0x29, 0x5B, 0x0A, 0x01, 0x28, +/* 21C0 */ 0x0A, 0x30, 0xB2, 0x6C, 0x65, 0xAA, 0x54, 0xC0, 0x7C, 0x0B, 0x8F, 0x24, 0x09, 0x0A, 0x0A, 0x0A, +/* 21D0 */ 0x05, 0x55, 0x2D, 0x0A, 0x57, 0xA9, 0x1E, 0x77, 0x4E, 0x8B, 0x3A, 0x24, 0x50, 0xEB, 0x26, 0xAA, +/* 21E0 */ 0x82, 0x78, 0x29, 0x5B, 0xF5, 0x8D, 0x4A, 0x5B, 0xE2, 0x7C, 0x07, 0x0B, 0x53, 0x0F, 0xB9, 0x0B, +/* 21F0 */ 0x07, 0x02, 0x10, 0x11, 0x3B, 0x01, 0x03, 0x04, 0x03, 0xF1, 0xBC, 0x07, 0x07, 0x03, 0x6C, 0x79, +/* 2200 */ 0x03, 0x85, 0x0A, 0x28, 0x2D, 0x94, 0x48, 0x44, 0x1A, 0x5B, 0x6F, 0x4C, 0x2D, 0x6F, 0x05, 0x2D, +/* 2210 */ 0xA3, 0x2E, 0x2D, 0x82, 0x0C, 0x97, 0x03, 0xE6, 0xE6, 0x10, 0x08, 0xBD, 0xC8, 0x53, 0x9B, 0xCD, +/* 2220 */ 0xFD, 0xAC, 0x92, 0x79, 0xF1, 0xF1, 0x25, 0x10, 0x08, 0xBD, 0xC8, 0x53, 0x9B, 0xCD, 0xFD, 0x49, +/* 2230 */ 0x4B, 0xF1, 0xF1, 0x25, 0xA6, 0x59, 0x21, 0x42, 0x07, 0x7B, 0x91, 0x58, 0xC8, 0x1E, 0x6F, 0x8D, +/* 2240 */ 0xA8, 0x63, 0x3A, 0xA6, 0xBC, 0x48, 0x5F, 0x36, 0x91, 0x1E, 0x77, 0x7B, 0x4A, 0xF5, 0x28, 0x72, +/* 2250 */ 0x10, 0x10, 0x3B, 0x02, 0x03, 0x05, 0x4D, 0x79, 0xF1, 0xB0, 0xA1, 0x0D, 0x33, 0xAC, 0x79, 0x00, +/* 2260 */ 0x61, 0x58, 0x2E, 0x79, 0x00, 0x7C, 0x5C, 0x24, 0x79, 0xB0, 0x27, 0x84, 0x4C, 0x79, 0x00, 0x2D, +/* 2270 */ 0xE2, 0x79, 0x00, 0x0D, 0x33, 0x4C, 0x79, 0x07, 0x58, 0x6C, 0x2D, 0x0A, 0x0E, 0x22, 0x1F, 0x79, +/* 2280 */ 0x85, 0x02, 0x6C, 0x79, 0x59, 0x0A, 0x6C, 0x2D, 0x9B, 0xAA, 0x03, 0x28, 0x79, 0x00, 0x42, 0x0A, +/* 2290 */ 0x28, 0x79, 0xA1, 0xAA, 0x03, 0x4C, 0x79, 0x61, 0xAE, 0x4C, 0x79, 0xB0, 0x34, 0x58, 0x2E, 0x79, +/* 22A0 */ 0x00, 0x61, 0x75, 0xAC, 0x79, 0xB0, 0xA1, 0x0F, 0x58, 0x10, 0x09, 0x4B, 0x92, 0xA8, 0x04, 0x05, +/* 22B0 */ 0x07, 0x08, 0x4D, 0x08, 0x97, 0xE1, 0x08, 0x97, 0xE1, 0x08, 0x1E, 0x44, 0xC8, 0x1E, 0x44, 0xC8, +/* 22C0 */ 0xAE, 0x04, 0x7B, 0x3D, 0x02, 0x7B, 0x85, 0x51, 0xC0, 0x7C, 0x85, 0x0A, 0x7B, 0xBC, 0x07, 0x07, +/* 22D0 */ 0x3C, 0x10, 0x18, 0x55, 0x52, 0x1A, 0xBA, 0x01, 0xB0, 0xBC, 0xBA, 0x02, 0x19, 0x6D, 0x70, 0x04, +/* 22E0 */ 0x69, 0x6A, 0x03, 0x85, 0x06, 0x19, 0x2D, 0x07, 0x30, 0xEF, 0x0E, 0x30, 0x03, 0x88, 0x6D, 0x48, +/* 22F0 */ 0x5B, 0x8F, 0x45, 0x2D, 0x35, 0x04, 0x50, 0x1B, 0x05, 0x08, 0x75, 0x8C, 0x2D, 0xA4, 0x29, 0x48, +/* 2300 */ 0x03, 0x00, 0x32, 0x1B, 0x45, 0x79, 0x00, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2310 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2320 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2330 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2340 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2350 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, 0xAE, 0xAB, 0x1E, 0x1B, 0x45, 0x2D, 0x39, 0x7C, +/* 2360 */ 0xAE, 0xAB, 0x1E, 0x1B, 0x10, 0x11, 0x00, 0xE7, 0xBC, 0x07, 0x07, 0xC6, 0x7F, 0x03, 0xE6, 0x10, +/* 2370 */ 0x11, 0xE7, 0xF0, 0x10, 0x11, 0xB0, 0xE7, 0x90, 0x2F, 0x6C, 0x2D, 0x90, 0xAA, 0x0A, 0x01, 0x4C, +/* 2380 */ 0x2D, 0x08, 0x97, 0xA2, 0x4C, 0x2D, 0x48, 0x58, 0x2E, 0x2D, 0x1B, 0x05, 0xE5, 0x58, 0xE3, 0x0F, +/* 2390 */ 0x5B, 0xA4, 0x1A, 0x5B, 0x5A, 0x24, 0x79, 0x63, 0x0E, 0x05, 0x28, 0x79, 0x7C, 0x06, 0x07, 0x3C, +/* 23A0 */ 0x6C, 0x79, 0x25, 0xA6, 0x79, 0x49, 0x79, 0x45, 0x1A, 0x2C, 0x9E, 0x07, 0x88, 0xA8, 0x02, 0x01, +/* 23B0 */ 0x10, 0x11, 0x4C, 0x52, 0xB6, 0x05, 0x49, 0x9F, 0x2C, 0xBF, 0x09, 0x56, 0xA8, 0x0C, 0x30, 0xB9, +/* 23C0 */ 0x56, 0x24, 0x61, 0x41, 0xB2, 0x24, 0x7C, 0x0F, 0x8F, 0x04, 0x07, 0xB2, 0x24, 0x4A, 0x75, 0x4A, +/* 23D0 */ 0xAE, 0x2E, 0xF7, 0x60, 0x97, 0x07, 0x04, 0x08, 0xB2, 0x2E, 0x91, 0x41, 0xB2, 0x2E, 0x29, 0x30, +/* 23E0 */ 0x1B, 0xAE, 0x2E, 0xBC, 0xAA, 0x0A, 0x04, 0xAE, 0x4E, 0x1A, 0x2F, 0x29, 0xAE, 0x7B, 0x29, 0xAE, +/* 23F0 */ 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x7B, 0x29, 0xAE, 0x49, 0x62, 0x0D, 0xC4, +/* 2400 */ 0x38, 0x7C, 0x02, 0x10, 0x0C, 0xB0, 0xE7, 0x90, 0x07, 0x04, 0x4E, 0x1A, 0x70, 0x02, 0x0D, 0xC4, +/* 2410 */ 0x1F, 0x2D, 0x03, 0x0D, 0x31, 0x1F, 0x2D, 0x8B, 0x51, 0x4E, 0x1A, 0x48, 0x58, 0x4E, 0x1A, 0x1E, +/* 2420 */ 0x22, 0x08, 0x9B, 0x4E, 0x1A, 0xB2, 0x7B, 0x2D, 0x82, 0x36, 0x2D, 0x0D, 0xF1, 0x25, 0x10, 0x0E, +/* 2430 */ 0x2E, 0x52, 0x90, 0x07, 0xBA, 0x02, 0xC0, 0xBB, 0x30, 0xF2, 0x00, 0xA8, 0x0D, 0x48, 0x8F, 0x6C, +/* 2440 */ 0x8B, 0x41, 0x07, 0x6C, 0x2C, 0x18, 0x03, 0x05, 0x0A, 0x35, 0x28, 0x7C, 0xAE, 0xAB, 0x7C, 0x03, +/* 2450 */ 0xB0, 0xA8, 0x97, 0xEF, 0x7B, 0x91, 0xB2, 0x05, 0xC0, 0x3D, 0x6F, 0x47, 0x6C, 0xBC, 0x0D, 0x41, +/* 2460 */ 0x89, 0xA6, 0x4A, 0xB1, 0x1B, 0xC0, 0x7C, 0x63, 0x5A, 0x88, 0x66, 0x44, 0x28, 0x72, 0x4E, 0x63, +/* 2470 */ 0xE2, 0x0A, 0x6F, 0x08, 0x04, 0x03, 0x42, 0x5A, 0xAC, 0xAD, 0x41, 0x1B, 0x2E, 0xBC, 0x9C, 0xEF, +/* 2480 */ 0x6C, 0xBB, 0x69, 0xA2, 0x02, 0xC0, 0x3F, 0x07, 0x07, 0x3C, 0x10, 0x0B, 0x4C, 0x73, 0xA8, 0x03, +/* 2490 */ 0x05, 0x49, 0x91, 0x69, 0x7D, 0xAA, 0x7D, 0xAA, 0x7D, 0xAA, 0x7B, 0x41, 0x18, 0x1F, 0x30, 0x58, +/* 24A0 */ 0x1F, 0x41, 0x96, 0x1F, 0x0A, 0x0B, 0xB2, 0x26, 0xC0, 0xAA, 0x7D, 0xAA, 0x7D, 0xAA, 0x7D, 0xAA, +/* 24B0 */ 0x7D, 0xAA, 0x7D, 0xAA, 0x7D, 0xAA, 0x7D, 0xAA, 0xF3, 0x70, 0x7B, 0x91, 0x8F, 0x04, 0x47, 0x36, +/* 24C0 */ 0xB8, 0xA5, 0x1F, 0x34, 0x41, 0x03, 0xA6, 0x29, 0x85, 0x35, 0x03, 0x36, 0xBC, 0x07, 0x2F, 0x10, +/* 24D0 */ 0x11, 0x7D, 0xE7, 0xD3, 0xF8, 0xD8, 0xD7, 0x2F, 0x10, 0x0F, 0x8C, 0xE7, 0xA8, 0x0F, 0x70, 0x4E, +/* 24E0 */ 0x0B, 0x70, 0x66, 0x5A, 0x1D, 0x35, 0x2E, 0x42, 0x07, 0xB0, 0x29, 0x1E, 0x3A, 0x24, 0x7C, 0x5C, +/* 24F0 */ 0x4A, 0x58, 0x24, 0xA9, 0x33, 0xAD, 0x0E, 0x28, 0x09, 0x70, 0xAF, 0xB5, 0xB0, 0x1A, 0x1E, 0x5A, +/* 2500 */ 0x0F, 0x18, 0x28, 0x32, 0x44, 0x03, 0x20, 0x28, 0x0B, 0xA2, 0x4A, 0x33, 0x28, 0x07, 0x2C, 0x1B, +/* 2510 */ 0xAD, 0x09, 0x6C, 0x29, 0x70, 0x0C, 0x76, 0x6C, 0xA9, 0x1E, 0x04, 0x70, 0xA6, 0x09, 0xA2, 0x56, +/* 2520 */ 0x36, 0x2D, 0x64, 0x19, 0xA1, 0x41, 0x03, 0xC0, 0xB1, 0x0E, 0xC8, 0x2C, 0xA2, 0x10, 0x16, 0x49, +/* 2530 */ 0xE7, 0x0B, 0x70, 0xB0, 0x2D, 0x39, 0xA9, 0x56, 0x8C, 0x61, 0x20, 0x00, 0x42, 0x0A, 0xAB, 0x1E, +/* 2540 */ 0x3A, 0x88, 0x4A, 0x1E, 0x5A, 0x8B, 0x1B, 0x00, 0x7C, 0x0F, 0x18, 0x88, 0x29, 0x0F, 0x18, 0xAF, +/* 2550 */ 0x1E, 0xBC, 0x97, 0x03, 0x19, 0x1E, 0x3A, 0xB0, 0x2C, 0x20, 0x59, 0x19, 0x91, 0x31, 0x7C, 0x2C, +/* 2560 */ 0xB4, 0x2C, 0x04, 0x83, 0x22, 0x7A, 0x09, 0x56, 0x6D, 0xC4, 0x0A, 0x0F, 0x44, 0x0A, 0xA2, 0x7A, +/* 2570 */ 0x07, 0x2C, 0x1B, 0x00, 0x07, 0x0F, 0x3A, 0x08, 0x2C, 0x09, 0x91, 0x64, 0x04, 0x97, 0x00, 0x71, +/* 2580 */ 0x06, 0x06, 0xC4, 0x00, 0x69, 0x04, 0x19, 0xA1, 0x70, 0x0C, 0x2C, 0x5D, 0x0F, 0x6F, 0x00, 0x70, +/* 2590 */ 0x19, 0xA9, 0x1E, 0x03, 0x96, 0x32, 0x03, 0x8E, 0x78, 0x8B, 0x07, 0x0F, 0x6F, 0x1D, 0x07, 0x56, +/* 25A0 */ 0x57, 0x07, 0x22, 0xB3, 0x0C, 0x0F, 0x35, 0x8A, 0x7A, 0x6D, 0x2C, 0x5C, 0x8B, 0x76, 0x78, 0x7C, +/* 25B0 */ 0x48, 0x3A, 0xB0, 0x07, 0x30, 0x03, 0xAC, 0xAA, 0x6E, 0x05, 0x30, 0x66, 0x0F, 0x82, 0x03, 0x2C, +/* 25C0 */ 0x22, 0x10, 0x0F, 0x49, 0xE7, 0x09, 0x8F, 0xAB, 0x0B, 0x58, 0x2E, 0x34, 0x8E, 0xA1, 0x75, 0xAC, +/* 25D0 */ 0x61, 0x7E, 0x06, 0x58, 0x28, 0x34, 0x56, 0x91, 0x56, 0x1F, 0x59, 0x03, 0x97, 0x03, 0x6C, 0xA9, +/* 25E0 */ 0x2C, 0x1B, 0xA2, 0x8D, 0x1A, 0x41, 0x03, 0xA6, 0xAF, 0xA2, 0x7B, 0x0A, 0xB2, 0x36, 0x29, 0x1E, +/* 25F0 */ 0x58, 0x8C, 0x66, 0x0E, 0x22, 0x55, 0x1A, 0x2C, 0x6F, 0x2D, 0x06, 0x28, 0xA9, 0x31, 0x00, 0x0D, +/* 2600 */ 0x33, 0x4C, 0x59, 0x03, 0x00, 0x42, 0x07, 0x4C, 0x34, 0x33, 0x01, 0x97, 0xA4, 0x2E, 0x42, 0x07, +/* 2610 */ 0xB0, 0xAD, 0x3A, 0x24, 0x34, 0x70, 0xB0, 0x29, 0x97, 0xA4, 0x10, 0x0F, 0x8C, 0xE7, 0xA8, 0x48, +/* 2620 */ 0x55, 0x0A, 0x58, 0xC3, 0xDE, 0xC5, 0x10, 0x0D, 0x49, 0xE7, 0x32, 0x48, 0x22, 0x28, 0x32, 0x48, +/* 2630 */ 0x22, 0x28, 0x32, 0x48, 0x22, 0x00, 0xA8, 0x26, 0x26, 0x26, 0xAA, 0x0A, 0x36, 0xBC, 0x97, 0x84, +/* 2640 */ 0x8D, 0xA8, 0x85, 0x05, 0x7B, 0x50, 0x0A, 0x7B, 0x2D, 0x5F, 0xA6, 0x7C, 0x0E, 0x58, 0x45, 0x66, +/* 2650 */ 0x3A, 0xC8, 0x75, 0xA6, 0x29, 0x97, 0x84, 0xC0, 0x91, 0x0F, 0x18, 0x36, 0x61, 0x48, 0x26, 0x26, +/* 2660 */ 0x26, 0x0A, 0x28, 0x71, 0x30, 0x22, 0x28, 0x71, 0x30, 0xA2, 0x28, 0x0A, 0x41, 0x8F, 0x10, 0x09, +/* 2670 */ 0x7D, 0xBD, 0x81, 0x0D, 0xEB, 0x7B, 0xAD, 0x35, 0x7B, 0x2D, 0x35, 0x7B, 0x8B, 0x6F, 0x09, 0x36, +/* 2680 */ 0xAF, 0x1B, 0xF3, 0xA2, 0xF3, 0x31, 0xF3, 0x31, 0xF3, 0x31, 0xF3, 0x31, 0xF3, 0x31, 0x7D, 0x0E, +/* 2690 */ 0x31, 0x7D, 0x8F, 0x7B, 0x93, 0x0F, 0x18, 0x7B, 0x0B, 0x97, 0x77, 0x7B, 0x0B, 0x0F, 0x6F, 0x47, +/* 26A0 */ 0x49, 0x0B, 0x56, 0x02, 0x49, 0x09, 0x69, 0x84, 0x7B, 0x29, 0x97, 0x07, 0x7D, 0x0E, 0x31, 0xF3, +/* 26B0 */ 0xA2, 0xF3, 0xA2, 0xF3, 0xA2, 0xF3, 0xA2, 0xF3, 0xA2, 0xF3, 0xA2, 0xF3, 0x46, 0x0C, 0x33, 0x7B, +/* 26C0 */ 0x8B, 0x6F, 0x09, 0x7B, 0x2D, 0x35, 0x7B, 0xAD, 0x35, 0x7D, 0x81, 0x0D, 0xEB, 0x10, 0x0B, 0x49, +/* 26D0 */ 0xBD, 0xC9, 0x46, 0xC9, 0x46, 0xC9, 0x46, 0xC9, 0x46, 0xC9, 0xA2, 0x10, 0x09, 0xA6, 0xBD, 0x4A, +/* 26E0 */ 0x1B, 0x0B, 0x47, 0x49, 0x59, 0x89, 0xC0, 0x4A, 0xB2, 0x36, 0xBC, 0x0C, 0x0F, 0x70, 0xC0, 0x61, +/* 26F0 */ 0x97, 0x03, 0xCD, 0x4D, 0x04, 0x58, 0xC0, 0xBC, 0x58, 0xC0, 0xBC, 0x58, 0xC0, 0xBC, 0x58, 0xC0, +/* 2700 */ 0xBC, 0x58, 0xC0, 0xBC, 0x58, 0x7B, 0x29, 0x7E, 0x8C, 0xA8, 0xAE, 0x01, 0xC0, 0x61, 0x0F, 0x70, +/* 2710 */ 0x45, 0x1A, 0x0C, 0x40, 0x49, 0xA0, 0x40, 0x7B, 0x50, 0x77, 0x36, 0x7C, 0x8F, 0x45, 0x60, 0x76, +/* 2720 */ 0xCD, 0x4D, 0x05, 0x58, 0xCD, 0x4D, 0x05, 0x58, 0xCD, 0x4D, 0x05, 0x58, 0xCD, 0x4D, 0x08, 0x97, +/* 2730 */ 0x03, 0xA6, 0xBC, 0x0C, 0x0F, 0x70, 0x36, 0x4A, 0xB2, 0x7B, 0x59, 0x89, 0xC0, 0x4A, 0x1B, 0x0B, +/* 2740 */ 0x47, 0x10, 0x0F, 0x8D, 0x4B, 0xE7, 0x1A, 0x09, 0x0A, 0x47, 0xAB, 0x7C, 0x6C, 0xAD, 0x6F, 0x06, +/* 2750 */ 0xB0, 0x07, 0x0F, 0x9D, 0x4C, 0x07, 0x30, 0x1B, 0x0C, 0x18, 0x2E, 0x34, 0x5B, 0x0D, 0x2E, 0x29, +/* 2760 */ 0x0D, 0x35, 0x02, 0x02, 0x09, 0x48, 0x84, 0x28, 0x93, 0x02, 0xB0, 0x29, 0x94, 0xEB, 0x02, 0x10, +/* 2770 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x49, 0x00, 0xAB, 0x01, 0x04, 0x01, 0x78, 0x01, 0xDA, 0x01, 0xE8, +/* 2780 */ 0x02, 0x6B, 0x02, 0x93, 0x03, 0x53, 0x03, 0xBA, 0x04, 0x28, 0x04, 0x4F, 0x04, 0x61, 0x05, 0x08, +/* 2790 */ 0x05, 0x18, 0x05, 0x56, 0x05, 0x7E, 0x05, 0xC5, 0x06, 0x0B, 0x06, 0x27, 0x06, 0x6B, 0x06, 0xF3, +/* 27A0 */ 0x07, 0x0E, 0x07, 0x36, 0x07, 0x57, 0x07, 0xB4, 0x08, 0x24, 0x08, 0x7D, 0x09, 0x13, 0x09, 0xB3, +/* 27B0 */ 0x0A, 0x0B, 0x0A, 0x2E, 0x0A, 0x52, 0x0A, 0x7B, 0x0A, 0x9E, 0x0A, 0xCB, 0x0A, 0xFE, 0x0B, 0x8D, +/* 27C0 */ 0x0C, 0x17, 0x0C, 0x39, 0x0C, 0x5D, 0x0C, 0x89, 0x0C, 0x9D, 0x0C, 0xC0, 0x0C, 0xDF, 0x0D, 0x04, +/* 27D0 */ 0x0D, 0x29, 0x0D, 0xA5, 0x0D, 0xC8, 0x0D, 0xE6, 0x0E, 0x05, 0x0E, 0x2C, 0x0E, 0x4F, 0x0E, 0x79, +/* 27E0 */ 0x0E, 0xC6, 0x0F, 0x97, 0x0F, 0xBC, 0x0F, 0xE0, 0x10, 0x0C, 0x10, 0x32, 0x10, 0x56, 0x10, 0xA6, +/* 27F0 */ 0x11, 0x2F, 0x11, 0x50, 0x11, 0x74, 0x11, 0x9E, 0x11, 0xC6, 0x11, 0xED, 0x12, 0x25, 0x12, 0xB8, +/* 2800 */ 0x13, 0x19, 0x13, 0x38, 0x13, 0x59, 0x13, 0x83, 0x13, 0xA8, 0x13, 0xCE, 0x13, 0xF5, 0x14, 0x23, +/* 2810 */ 0x14, 0x35, 0x14, 0xC9, 0x14, 0xF4, 0x15, 0x15, 0x15, 0x34, 0x15, 0x5A, 0x15, 0x7F, 0x15, 0xA2, +/* 2820 */ 0x15, 0xB2, 0x16, 0x41, 0x16, 0x65, 0x16, 0x88, 0x16, 0xB2, 0x16, 0xDB, 0x17, 0x00, 0x17, 0x43, +/* 2830 */ 0x07, 0x00, 0x10, 0x07, 0x45, 0xE7, 0xA8, 0x0A, 0x9E, 0x04, 0x7A, 0x66, 0xA4, 0x8C, 0xA8, 0x2C, +/* 2840 */ 0x18, 0x8C, 0xA8, 0x48, 0x3E, 0x27, 0xA4, 0x88, 0xA8, 0x0A, 0x9E, 0x04, 0x28, 0x4B, 0xBC, 0x46, +/* 2850 */ 0x05, 0x46, 0x06, 0x56, 0x49, 0x4A, 0x0F, 0xB3, 0xC8, 0x22, 0x7B, 0x61, 0x33, 0x36, 0x61, 0x8E, +/* 2860 */ 0x7B, 0xAD, 0x0E, 0x7D, 0x63, 0x7D, 0x0A, 0x70, 0x49, 0x0B, 0x70, 0x19, 0x66, 0xA3, 0x7B, 0x91, +/* 2870 */ 0x97, 0x03, 0x49, 0x85, 0x03, 0xC0, 0xA9, 0x58, 0x10, 0x0E, 0x4E, 0x73, 0x4A, 0x40, 0x49, 0x4A, +/* 2880 */ 0x40, 0x49, 0x4A, 0x40, 0x49, 0x4A, 0x40, 0x49, 0x4A, 0x40, 0x45, 0x1A, 0x0C, 0x22, 0x47, 0x4E, +/* 2890 */ 0xA8, 0x0C, 0x41, 0x74, 0xB0, 0xA8, 0x0D, 0x30, 0xA2, 0x28, 0xAD, 0x30, 0x84, 0x4C, 0x7C, 0x48, +/* 28A0 */ 0x72, 0x90, 0x67, 0x6C, 0x07, 0xAE, 0xAB, 0xA1, 0x8D, 0x4F, 0xC0, 0xAA, 0x03, 0x49, 0x2C, 0x96, +/* 28B0 */ 0x7B, 0x32, 0xE4, 0x48, 0x47, 0x90, 0x74, 0x28, 0xAF, 0x41, 0x5F, 0x4C, 0x7C, 0x9C, 0x09, 0x6C, +/* 28C0 */ 0x29, 0x0E, 0x30, 0x6F, 0x05, 0x4E, 0xA8, 0x08, 0x0D, 0x2C, 0x6F, 0x9D, 0xC8, 0x40, 0xB0, 0xC8, +/* 28D0 */ 0x40, 0xB0, 0xC8, 0x40, 0xB0, 0xC8, 0x40, 0xB0, 0xC8, 0x40, 0x10, 0x10, 0x4E, 0x73, 0x4A, 0x94, +/* 28E0 */ 0x1B, 0x0B, 0x05, 0x36, 0x9F, 0xB2, 0x01, 0x1F, 0x71, 0x41, 0x77, 0x4C, 0x29, 0x48, 0xB7, 0x1E, +/* 28F0 */ 0x89, 0x2E, 0x61, 0x1E, 0x44, 0x6D, 0x0F, 0x0A, 0x01, 0x6C, 0x0B, 0x70, 0xB0, 0x29, 0xA6, 0x85, +/* 2900 */ 0x7D, 0x85, 0x7D, 0x85, 0x7D, 0x85, 0x7B, 0x85, 0x97, 0x96, 0x28, 0x85, 0x97, 0x96, 0x28, 0x0B, +/* 2910 */ 0x0D, 0x48, 0xB4, 0xB4, 0x89, 0x1F, 0x85, 0x7D, 0x85, 0xF3, 0x8E, 0xC0, 0x1D, 0x1B, 0x88, 0xA8, +/* 2920 */ 0x8F, 0x7B, 0xAD, 0x77, 0xC0, 0x62, 0xAE, 0x2A, 0x08, 0x60, 0x2C, 0x41, 0xA2, 0x60, 0x5B, 0x3A, +/* 2930 */ 0x60, 0x5B, 0x51, 0x10, 0x10, 0x4B, 0xDF, 0x62, 0x02, 0x45, 0x0B, 0x04, 0x24, 0x29, 0x0E, 0x35, +/* 2940 */ 0xBC, 0x07, 0x07, 0x05, 0xB0, 0x09, 0x6F, 0x04, 0xAC, 0x4A, 0x56, 0x85, 0x0E, 0x09, 0x8A, 0x24, +/* 2950 */ 0x09, 0x41, 0xB2, 0x2E, 0xAF, 0x41, 0x1B, 0x01, 0x2E, 0x61, 0x56, 0x05, 0x81, 0x56, 0x4C, 0x1D, +/* 2960 */ 0x0D, 0x4E, 0x0B, 0x96, 0x2E, 0x7C, 0x31, 0xAB, 0x4A, 0x76, 0x24, 0xBC, 0x1E, 0x07, 0xAB, 0x6D, +/* 2970 */ 0x18, 0x2E, 0x29, 0x8A, 0xB0, 0x6D, 0x18, 0xA8, 0x56, 0xB0, 0x61, 0x1E, 0x04, 0x2E, 0xAF, 0x5A, +/* 2980 */ 0x03, 0x86, 0x0E, 0x4C, 0x61, 0x97, 0xB7, 0x5C, 0x24, 0x29, 0x41, 0x54, 0x24, 0xA1, 0x0D, 0x0F, +/* 2990 */ 0x5B, 0xEF, 0x24, 0x07, 0x1E, 0x04, 0x65, 0x0E, 0x35, 0x07, 0x03, 0x86, 0x09, 0x2E, 0x09, 0x6E, +/* 29A0 */ 0x4E, 0xBC, 0xA5, 0xAC, 0xBC, 0x45, 0x29, 0x10, 0x11, 0x4E, 0xDF, 0x34, 0x8E, 0xAB, 0xBC, 0x8F, +/* 29B0 */ 0x78, 0x61, 0x7E, 0x4E, 0x8B, 0xA3, 0xAC, 0x34, 0x56, 0xAB, 0xA1, 0x8F, 0xAC, 0x61, 0x20, 0xB0, +/* 29C0 */ 0x42, 0x02, 0x2E, 0x34, 0x8A, 0xA9, 0x31, 0x2E, 0x61, 0x2C, 0x6F, 0xBC, 0x20, 0xA8, 0x7E, 0x0A, +/* 29D0 */ 0x31, 0x1F, 0x09, 0x56, 0x32, 0xA3, 0x6C, 0x7C, 0x8F, 0xA2, 0x36, 0x63, 0x96, 0x1F, 0x09, 0x0A, +/* 29E0 */ 0xB1, 0x6F, 0x0A, 0x0A, 0x06, 0x28, 0x9C, 0xF5, 0x88, 0x9C, 0xF5, 0x19, 0x7C, 0xAE, 0x7B, 0x7C, +/* 29F0 */ 0xAE, 0xA6, 0x91, 0xB4, 0x85, 0xB9, 0xB4, 0xE2, 0x9C, 0xF5, 0x88, 0x9C, 0xF5, 0x19, 0x7C, 0xAE, +/* 2A00 */ 0x7B, 0x7C, 0xAE, 0x7B, 0x7C, 0xAE, 0x7B, 0x7C, 0xAE, 0x10, 0x0B, 0x49, 0xBD, 0xC9, 0x46, 0xC9, +/* 2A10 */ 0xA2, 0x28, 0x43, 0xC9, 0x46, 0xC9, 0xA2, 0x10, 0x10, 0xAB, 0x73, 0x4A, 0x94, 0x0F, 0x9E, 0x47, +/* 2A20 */ 0x1F, 0x7C, 0x85, 0x97, 0xE2, 0xA1, 0x85, 0x97, 0x1B, 0x6C, 0x42, 0xEB, 0x0C, 0x86, 0x06, 0x4E, +/* 2A30 */ 0x66, 0xA4, 0xAB, 0x65, 0x28, 0xA9, 0x22, 0x7D, 0x0B, 0x7E, 0xC8, 0x2C, 0x22, 0x06, 0x01, 0x36, +/* 2A40 */ 0x91, 0x48, 0x6F, 0x72, 0xA6, 0x71, 0x30, 0x74, 0x6C, 0x0A, 0xA2, 0x0E, 0x48, 0x5F, 0x60, 0xC4, +/* 2A50 */ 0xA1, 0x06, 0xAA, 0x05, 0x24, 0x61, 0xA2, 0xAB, 0x34, 0x8A, 0x24, 0xAD, 0x5F, 0xB0, 0x27, 0x07, +/* 2A60 */ 0x4C, 0x59, 0x67, 0xA9, 0x1E, 0x03, 0xA8, 0xAA, 0x6F, 0x0A, 0x31, 0x28, 0x29, 0x85, 0x5C, 0x1F, +/* 2A70 */ 0x65, 0x0F, 0xB2, 0xC0, 0x29, 0x63, 0x44, 0xC0, 0x29, 0x75, 0xC0, 0x91, 0x22, 0x28, 0x7C, 0x0E, +/* 2A80 */ 0x08, 0x03, 0x01, 0x90, 0xAE, 0x6C, 0x0A, 0x41, 0x18, 0x4C, 0x7C, 0x48, 0xB2, 0x6C, 0x4A, 0x0D, +/* 2A90 */ 0x41, 0x9B, 0x1F, 0xBC, 0x08, 0x0A, 0x0A, 0x09, 0x07, 0x02, 0x10, 0x0E, 0x49, 0x43, 0x7C, 0x0B, +/* 2AA0 */ 0xEB, 0x02, 0x00, 0x29, 0x0C, 0x0E, 0x0A, 0x01, 0x6C, 0x0B, 0x56, 0x1D, 0x3A, 0x4C, 0x1D, 0x6F, +/* 2AB0 */ 0x7C, 0xAE, 0x6C, 0x0B, 0x56, 0x1D, 0x3A, 0x28, 0x7C, 0x0B, 0xEB, 0x02, 0x00, 0x29, 0x0C, 0x0E, +/* 2AC0 */ 0x0A, 0x01, 0x10, 0x17, 0x4E, 0x3B, 0x93, 0x94, 0x0F, 0x9E, 0x09, 0x03, 0xA6, 0x37, 0x48, 0xA2, +/* 2AD0 */ 0x01, 0xA8, 0xB1, 0x0D, 0xAA, 0xEF, 0x2E, 0x8B, 0xA7, 0xB0, 0x7C, 0x07, 0x86, 0x84, 0x57, 0x4A, +/* 2AE0 */ 0x0F, 0x6F, 0x05, 0x8C, 0x62, 0xC4, 0x57, 0x34, 0x0F, 0x6E, 0x07, 0x0C, 0x6F, 0xA7, 0xA1, 0x86, +/* 2AF0 */ 0x05, 0x7A, 0x4A, 0x2C, 0x0A, 0xB0, 0x0B, 0x2C, 0x58, 0x6D, 0xC4, 0x78, 0x0B, 0x2C, 0x04, 0x00, +/* 2B00 */ 0x42, 0x0E, 0x0F, 0xA4, 0x1D, 0x01, 0x7A, 0x0E, 0x6F, 0x1D, 0x77, 0x00, 0x5D, 0xAB, 0x09, 0x2C, +/* 2B10 */ 0x04, 0x45, 0x7C, 0xC4, 0x29, 0x1E, 0x04, 0x8C, 0x07, 0x2C, 0x07, 0x45, 0x29, 0x2C, 0x0A, 0x6D, +/* 2B20 */ 0x40, 0x8D, 0x6D, 0xF5, 0x03, 0x2C, 0x0A, 0x6D, 0x40, 0x8D, 0x6D, 0xF5, 0x02, 0xC4, 0x6D, 0x96, +/* 2B30 */ 0x8D, 0x4A, 0x2C, 0x07, 0x7A, 0x0E, 0x6F, 0x29, 0x76, 0x8C, 0x09, 0x2C, 0x04, 0x7A, 0x0B, 0x2C, +/* 2B40 */ 0x03, 0x00, 0x0D, 0x2C, 0x74, 0x90, 0x39, 0x1D, 0x01, 0x19, 0x4A, 0x2C, 0x0A, 0x00, 0x07, 0x1E, +/* 2B50 */ 0x58, 0x6D, 0xB3, 0x45, 0xA1, 0x86, 0x04, 0x00, 0x50, 0x6F, 0x3C, 0x86, 0x05, 0x57, 0x07, 0x2C, +/* 2B60 */ 0x6A, 0x05, 0x0B, 0x0D, 0x0C, 0x5E, 0x62, 0xB3, 0x57, 0x0B, 0x31, 0x03, 0xAB, 0x93, 0x86, 0x84, +/* 2B70 */ 0x24, 0x9F, 0x2C, 0x1B, 0xAA, 0xEF, 0x28, 0x07, 0x69, 0xB2, 0x02, 0x1F, 0x93, 0x94, 0x0F, 0x9E, +/* 2B80 */ 0x09, 0x03, 0x10, 0x0F, 0x73, 0xA1, 0x06, 0x0A, 0x0D, 0x0F, 0x1B, 0xA7, 0x8C, 0x66, 0x54, 0xA6, +/* 2B90 */ 0x42, 0x97, 0xA4, 0x6C, 0x29, 0x0F, 0x35, 0x94, 0x58, 0xA6, 0x98, 0x00, 0x7C, 0x0F, 0x18, 0x8D, +/* 2BA0 */ 0xA8, 0x02, 0x02, 0x0E, 0x18, 0xA6, 0x65, 0x97, 0x18, 0x1F, 0x0A, 0x30, 0x18, 0xAB, 0x1A, 0x1E, +/* 2BB0 */ 0x74, 0x00, 0x0E, 0x18, 0x6C, 0x71, 0xA5, 0x0E, 0x18, 0x4E, 0x66, 0x77, 0x2D, 0x08, 0x6C, 0x0A, +/* 2BC0 */ 0x5B, 0xAB, 0x1A, 0x48, 0x6F, 0x86, 0x0C, 0x6C, 0xAD, 0x6F, 0x04, 0x05, 0xF5, 0x19, 0x6D, 0x09, +/* 2BD0 */ 0x0A, 0x5E, 0x00, 0x7C, 0x07, 0x03, 0x1F, 0x4B, 0xC8, 0x26, 0x26, 0x2A, 0x04, 0x4C, 0xAD, 0x48, +/* 2BE0 */ 0x18, 0x4C, 0xAD, 0x48, 0x18, 0x4C, 0xAD, 0x48, 0x18, 0x10, 0x13, 0xE7, 0x07, 0x03, 0x8D, 0x07, +/* 2BF0 */ 0x04, 0x6C, 0x4A, 0x0F, 0x3A, 0xB0, 0xBC, 0x2C, 0x9B, 0x2E, 0x29, 0x1E, 0x44, 0x7C, 0x86, 0x3A, +/* 2C00 */ 0x24, 0xA1, 0x0D, 0x1E, 0xA4, 0xAF, 0x0F, 0xA4, 0xB0, 0x4F, 0x63, 0x07, 0x2E, 0x07, 0x75, 0x59, +/* 2C10 */ 0x0D, 0x60, 0x58, 0x29, 0x54, 0xAC, 0xA9, 0x5C, 0x0C, 0xAE, 0x4C, 0x0E, 0x20, 0x91, 0x97, 0x03, +/* 2C20 */ 0x4C, 0x69, 0x5A, 0x0C, 0x7E, 0x24, 0x91, 0x75, 0x27, 0x1B, 0x2E, 0x7C, 0x69, 0x51, 0x7C, 0xAA, +/* 2C30 */ 0x07, 0x4C, 0x2D, 0x5F, 0x04, 0x97, 0xA4, 0x24, 0x61, 0x1E, 0x3A, 0xB0, 0x07, 0x8F, 0xAB, 0x66, +/* 2C40 */ 0x84, 0xB0, 0x50, 0x03, 0x4C, 0x34, 0x18, 0x00, 0xA1, 0x0D, 0x8A, 0x00, 0x60, 0xBF, 0xAB, 0x29, +/* 2C50 */ 0x0E, 0x0E, 0x05, 0x1F, 0x98, 0x8D, 0x98, 0x10, 0x0F, 0x99, 0x4B, 0xE7, 0xC8, 0x0B, 0x26, 0x26, +/* 2C60 */ 0x2A, 0x02, 0x4C, 0x0A, 0x5B, 0x82, 0x24, 0x0A, 0x5B, 0x82, 0x24, 0x0A, 0x0F, 0x5B, 0x03, 0xF3, +/* 2C70 */ 0x1E, 0x03, 0xF3, 0x1E, 0x03, 0xF3, 0x1E, 0x03, 0xF3, 0x1E, 0x03, 0xF3, 0x1E, 0x03, 0x10, 0x0C, +/* 2C80 */ 0x36, 0x92, 0xE7, 0xC8, 0x0B, 0x2A, 0x07, 0xA6, 0x50, 0x5C, 0x6C, 0x50, 0x5C, 0x6C, 0x50, 0x5C, +/* 2C90 */ 0x10, 0x12, 0x00, 0x3B, 0x7C, 0x08, 0x0C, 0x0E, 0x1B, 0x0A, 0x04, 0xA6, 0x4A, 0x48, 0xA2, 0x01, +/* 2CA0 */ 0x6C, 0x07, 0x2C, 0x67, 0x04, 0x03, 0x05, 0x71, 0x77, 0x24, 0xBC, 0x2C, 0x0A, 0x4E, 0xBC, 0x2C, +/* 2CB0 */ 0x09, 0x24, 0xA9, 0x35, 0x00, 0x0B, 0xB4, 0x0B, 0x5E, 0x4A, 0x2C, 0x03, 0x57, 0xBC, 0x2C, 0x03, +/* 2CC0 */ 0x00, 0x85, 0x5F, 0x0D, 0xA5, 0x57, 0x09, 0x1B, 0xA9, 0x0F, 0x98, 0x0D, 0x51, 0x83, 0x6F, 0x24, +/* 2CD0 */ 0x0B, 0xA5, 0x0D, 0x0F, 0x98, 0x0D, 0x51, 0x6D, 0x0F, 0x9A, 0x57, 0x91, 0x3A, 0xA9, 0x0F, 0x86, +/* 2CE0 */ 0xA4, 0x29, 0x0F, 0xA3, 0x57, 0x91, 0x3A, 0xA9, 0x20, 0x29, 0x0F, 0xA3, 0xAC, 0x0B, 0xA5, 0x0D, +/* 2CF0 */ 0x0F, 0x04, 0x0D, 0x51, 0x00, 0x6D, 0x0F, 0x9A, 0xAC, 0x09, 0x1B, 0xA9, 0x0F, 0x3F, 0x1B, 0x61, +/* 2D00 */ 0x6F, 0x57, 0xBC, 0x2C, 0x03, 0x00, 0x0D, 0x0F, 0x04, 0x00, 0x0D, 0x44, 0x0D, 0xA5, 0x78, 0xA9, +/* 2D10 */ 0xB5, 0x4A, 0x06, 0x02, 0x00, 0x3F, 0x05, 0x06, 0x2C, 0x03, 0x60, 0xA5, 0xB0, 0xBC, 0x0E, 0xA5, +/* 2D20 */ 0xAC, 0x61, 0x0F, 0x1B, 0x07, 0x04, 0x03, 0x05, 0x71, 0x77, 0x28, 0x4A, 0x48, 0xA2, 0x01, 0x1F, +/* 2D30 */ 0x7C, 0x08, 0x0C, 0x0E, 0x1B, 0x0A, 0x04, 0x10, 0x0B, 0x7D, 0x43, 0x0A, 0x0B, 0x2A, 0x1F, 0x1D, +/* 2D40 */ 0x30, 0x1F, 0x1D, 0x30, 0x1F, 0x1D, 0x30, 0x10, 0x0F, 0x00, 0x73, 0x29, 0x0A, 0x0E, 0x9E, 0x07, +/* 2D50 */ 0xC0, 0x4A, 0x30, 0x77, 0x1F, 0x29, 0x1E, 0x6F, 0xA2, 0xA6, 0x09, 0x2C, 0x89, 0x00, 0x07, 0x96, +/* 2D60 */ 0x6C, 0x91, 0x0F, 0x44, 0x1D, 0x06, 0x28, 0x1D, 0x06, 0x00, 0xA9, 0x2C, 0xE2, 0xAF, 0x39, 0x1D, +/* 2D70 */ 0x05, 0x1F, 0x09, 0x2C, 0xEF, 0x83, 0x96, 0x6C, 0x7C, 0x48, 0xA2, 0x8D, 0x1A, 0x30, 0x77, 0x36, +/* 2D80 */ 0x29, 0x0A, 0x0E, 0x9E, 0x47, 0x10, 0x0F, 0xB0, 0x4B, 0xDF, 0xBC, 0x22, 0x7D, 0xCF, 0x7B, 0xBC, +/* 2D90 */ 0x22, 0x7B, 0xBC, 0x22, 0x7B, 0xBC, 0x22, 0x7B, 0xBC, 0x22, 0x45, 0x38, 0x1A, 0x26, 0x26, 0x2A, +/* 2DA0 */ 0x0A, 0x28, 0x42, 0x30, 0x6F, 0x28, 0x42, 0x30, 0x6F, 0x28, 0x42, 0x30, 0x6F, 0x10, 0x0C, 0x57, +/* 2DB0 */ 0x3B, 0xA8, 0x08, 0x0D, 0x0F, 0xEB, 0x04, 0x36, 0x29, 0x69, 0x76, 0x1F, 0xAF, 0x0E, 0x86, 0x6F, +/* 2DC0 */ 0x55, 0xA8, 0x0C, 0x0A, 0x01, 0x00, 0x8B, 0x04, 0x55, 0xA8, 0xAB, 0x07, 0x1E, 0x04, 0x7D, 0x0A, +/* 2DD0 */ 0x40, 0x7B, 0x29, 0xA2, 0x88, 0xA8, 0x0D, 0x2C, 0x5F, 0x8D, 0xA8, 0x0C, 0x2C, 0xEF, 0x49, 0x0B, +/* 2DE0 */ 0x2C, 0xEF, 0x49, 0x71, 0xEF, 0x00, 0xC8, 0x2C, 0x6F, 0xB4, 0xB4, 0x07, 0x6C, 0x61, 0x48, 0x18, +/* 2DF0 */ 0x6C, 0x61, 0x97, 0x58, 0x10, 0x0C, 0x24, 0x95, 0x7C, 0x09, 0x0D, 0x0F, 0xEB, 0x04, 0x8C, 0x1A, +/* 2E00 */ 0x69, 0x8A, 0xA6, 0x07, 0x2C, 0x1B, 0x70, 0xA6, 0x4A, 0x05, 0xB0, 0x07, 0x2C, 0x82, 0xC8, 0x2C, +/* 2E10 */ 0xA4, 0x7B, 0x09, 0x0D, 0x76, 0xC0, 0xAF, 0x0E, 0x06, 0x7D, 0x0E, 0xAE, 0x7D, 0xBB, 0x18, 0x45, +/* 2E20 */ 0xA8, 0x31, 0x36, 0x3C, 0x00, 0x29, 0xA2, 0x1F, 0x4A, 0x1B, 0x07, 0x65, 0x18, 0x6C, 0xA9, 0x41, +/* 2E30 */ 0x5F, 0x6C, 0x7C, 0xB1, 0x0C, 0x02, 0xC0, 0x7C, 0x06, 0x2F, 0x10, 0x0A, 0x43, 0x01, 0x04, 0x7D, +/* 2E40 */ 0xBC, 0x0D, 0xA4, 0x88, 0xA8, 0x71, 0x3A, 0x88, 0x1A, 0xAA, 0xA4, 0x36, 0x09, 0x48, 0x67, 0x01, +/* 2E50 */ 0x36, 0x07, 0x56, 0x04, 0xF3, 0x9D, 0x10, 0x11, 0x7D, 0xE7, 0x79, 0xAB, 0xAA, 0x4C, 0x79, 0xAB, +/* 2E60 */ 0xAA, 0x4C, 0xC1, 0xC1, 0xC1, 0x79, 0x00, 0xA1, 0x0F, 0x70, 0x1A, 0x75, 0x71, 0x40, 0x1A, 0x2C, +/* 2E70 */ 0x22, 0x0D, 0x1E, 0x96, 0x1A, 0x41, 0x6F, 0x58, 0x1A, 0x30, 0x1B, 0x59, 0x07, 0x1A, 0xA2, 0x0C, +/* 2E80 */ 0xEB, 0x02, 0x32, 0x0E, 0x08, 0x1A, 0x33, 0xB0, 0x29, 0x02, 0x01, 0x28, 0x2D, 0x02, 0xCD, 0x04, +/* 2E90 */ 0xCD, 0x4D, 0x05, 0x58, 0xCD, 0x4D, 0x05, 0x9E, 0x0A, 0x9D, 0x10, 0x17, 0xAB, 0x73, 0x29, 0x09, +/* 2EA0 */ 0x0C, 0x9C, 0x1B, 0x57, 0xA1, 0x71, 0x5B, 0x1B, 0xAC, 0x27, 0x5B, 0x1B, 0x57, 0x59, 0x30, 0x26, +/* 2EB0 */ 0x0D, 0x33, 0x7A, 0x85, 0x30, 0xB0, 0x07, 0x33, 0x45, 0x7C, 0x5B, 0xB0, 0x07, 0x33, 0x45, 0x29, +/* 2EC0 */ 0x5B, 0xB0, 0x07, 0x33, 0x88, 0xBC, 0x5B, 0xB0, 0x07, 0x33, 0x45, 0x7C, 0x5B, 0xB0, 0x07, 0x33, +/* 2ED0 */ 0x7A, 0x69, 0x41, 0xB0, 0x07, 0x33, 0x19, 0xAD, 0x41, 0xB0, 0x07, 0x33, 0x19, 0x7C, 0x9C, 0xB0, +/* 2EE0 */ 0x07, 0x33, 0x19, 0xBC, 0x86, 0x30, 0xB0, 0x07, 0x33, 0x78, 0x7C, 0x09, 0x0E, 0x30, 0xB0, 0x07, +/* 2EF0 */ 0x33, 0x24, 0xA1, 0x59, 0xB0, 0x07, 0x33, 0x24, 0xBC, 0x97, 0xD2, 0x4C, 0xBC, 0x97, 0xD2, 0x4C, +/* 2F00 */ 0xBC, 0x97, 0xD2, 0x4C, 0xBC, 0x97, 0xD2, 0x4C, 0xBC, 0x97, 0xD2, 0x4C, 0xBC, 0x97, 0xD2, 0x4C, +/* 2F10 */ 0xBC, 0x97, 0xD2, 0xAB, 0x60, 0xB9, 0x0A, 0xB0, 0x07, 0x0F, 0x9E, 0x09, 0xB0, 0xA8, 0x02, 0x4E, +/* 2F20 */ 0xA1, 0x01, 0x10, 0x07, 0x2E, 0x92, 0x52, 0xA8, 0x0A, 0x9E, 0x03, 0x7A, 0x66, 0xA4, 0x8C, 0xA8, +/* 2F30 */ 0x2C, 0x18, 0x8C, 0xA8, 0x48, 0x3E, 0x27, 0xA4, 0x88, 0xA8, 0x0A, 0x9E, 0x04, 0x10, 0x0A, 0x95, +/* 2F40 */ 0x80, 0xE7, 0x0E, 0x35, 0x19, 0xA8, 0xB3, 0x7B, 0x29, 0x1E, 0x67, 0x7B, 0x29, 0x94, 0x18, 0x45, +/* 2F50 */ 0xA8, 0x0D, 0xC4, 0xC0, 0x29, 0xAF, 0x0C, 0x36, 0x29, 0x6F, 0x0E, 0x31, 0xC0, 0xB1, 0x84, 0x36, +/* 2F60 */ 0x29, 0x0A, 0x0D, 0x6F, 0x9D, 0x10, 0x0C, 0xB0, 0x95, 0x1A, 0x86, 0x0C, 0x7B, 0xBB, 0x75, 0x6C, +/* 2F70 */ 0xBC, 0x85, 0x35, 0x88, 0x66, 0x86, 0x0C, 0x36, 0x7C, 0x0E, 0x74, 0x0C, 0xB3, 0xA6, 0x29, 0x01, +/* 2F80 */ 0x91, 0xFF, 0x0C, 0xFF, 0x0C, 0xB3, 0x10, 0x0F, 0xB0, 0x73, 0x4A, 0x94, 0x1B, 0xA7, 0x36, 0x9F, +/* 2F90 */ 0x48, 0x07, 0xA6, 0x50, 0x54, 0x4C, 0xBC, 0x97, 0x9E, 0x1E, 0x1B, 0x28, 0xAD, 0xA4, 0x00, 0x59, +/* 2FA0 */ 0x03, 0x4C, 0x91, 0xA2, 0xAB, 0x0F, 0x18, 0x28, 0x0E, 0x8A, 0x1D, 0x3A, 0x28, 0x0E, 0x8A, 0xA9, +/* 2FB0 */ 0x8A, 0x4C, 0x0E, 0x8A, 0x1D, 0x44, 0x2E, 0x91, 0xA2, 0x00, 0xA1, 0x7E, 0x24, 0x61, 0x58, 0xBB, +/* 2FC0 */ 0x20, 0x2E, 0x7C, 0x41, 0xA2, 0x1F, 0xB8, 0x2C, 0x84, 0xA6, 0xB8, 0x74, 0x36, 0x7C, 0x07, 0x0A, +/* 2FD0 */ 0x0A, 0x09, 0x05, 0x7A, 0x92, 0x0A, 0x26, 0x26, 0x2A, 0x05, 0x28, 0x9C, 0xF5, 0x88, 0x9C, 0xF5, +/* 2FE0 */ 0x88, 0x9C, 0xF5, 0x10, 0x13, 0xBD, 0x80, 0x1A, 0x05, 0x55, 0x6D, 0x05, 0xB0, 0xA8, 0x0A, 0x0F, +/* 2FF0 */ 0x84, 0xB0, 0xA1, 0x71, 0x03, 0xAB, 0x66, 0x5F, 0x00, 0x8B, 0x5F, 0x24, 0x29, 0x5C, 0x02, 0xAE, +/* 3000 */ 0x4C, 0xAD, 0x44, 0xAD, 0x3A, 0x2E, 0x7C, 0x0E, 0x58, 0x00, 0x34, 0x58, 0x4C, 0x42, 0xA4, 0x00, +/* 3010 */ 0x59, 0x84, 0x24, 0xA1, 0x0D, 0x8F, 0xA9, 0x5C, 0xAC, 0x6D, 0x5C, 0x05, 0xAE, 0x4C, 0x07, 0x5C, +/* 3020 */ 0x07, 0xAE, 0x24, 0x7C, 0xAA, 0x39, 0x34, 0x8F, 0x2E, 0x63, 0x77, 0x83, 0x97, 0x5F, 0x57, 0x29, +/* 3030 */ 0x97, 0x84, 0x7C, 0x97, 0xEF, 0x00, 0x66, 0x5A, 0x50, 0x05, 0x1A, 0x1E, 0x3A, 0xBC, 0x8F, 0x4C, +/* 3040 */ 0x0A, 0x56, 0xAB, 0x09, 0x22, 0x6C, 0x07, 0x1B, 0x01, 0xAB, 0x4A, 0x0E, 0x84, 0x6C, 0x7C, 0x03, +/* 3050 */ 0x55, 0x7C, 0x03, 0x10, 0x1C, 0x95, 0xA1, 0xB0, 0x38, 0x0A, 0x67, 0x01, 0x78, 0x6D, 0x86, 0x0C, +/* 3060 */ 0x8C, 0x7C, 0xD9, 0xD5, 0x24, 0xAF, 0x0C, 0xAB, 0xAF, 0x0A, 0x00, 0xA1, 0x03, 0x57, 0x91, 0xB3, +/* 3070 */ 0xBC, 0x1E, 0x03, 0x61, 0x35, 0x06, 0x19, 0xAF, 0x0C, 0x4E, 0x0B, 0xC4, 0x00, 0xA9, 0x2C, 0x09, +/* 3080 */ 0x7A, 0x91, 0xB3, 0x29, 0x1E, 0x04, 0xBC, 0x1E, 0x03, 0x19, 0xAF, 0x0C, 0xAB, 0x09, 0xB3, 0x00, +/* 3090 */ 0x71, 0x0D, 0x78, 0x91, 0xB3, 0x02, 0x18, 0xB0, 0x32, 0xE2, 0x83, 0x0F, 0x1B, 0xAB, 0x07, 0x1E, +/* 30A0 */ 0x90, 0x2C, 0x05, 0xAC, 0x34, 0xE0, 0x2E, 0x71, 0x04, 0x99, 0x7C, 0x08, 0x10, 0x1C, 0x95, 0xA1, +/* 30B0 */ 0xB0, 0x38, 0x0A, 0x67, 0x01, 0x78, 0x6D, 0x86, 0x0C, 0x8C, 0x7C, 0xD9, 0xD5, 0x24, 0xAF, 0x0C, +/* 30C0 */ 0xAB, 0xAF, 0x0A, 0x4C, 0x91, 0xB3, 0xBC, 0x1E, 0x03, 0x29, 0x0A, 0x0D, 0x1B, 0x9D, 0x88, 0xAF, +/* 30D0 */ 0x0C, 0x4E, 0x0B, 0xC4, 0x4A, 0x30, 0x84, 0x88, 0x91, 0xB3, 0x29, 0x1E, 0x98, 0x86, 0x0E, 0x0E, +/* 30E0 */ 0xA2, 0x8C, 0xAF, 0x0C, 0xAB, 0x09, 0xB3, 0x04, 0x0E, 0x06, 0xA1, 0x0D, 0x1E, 0x88, 0x91, 0xB3, +/* 30F0 */ 0x02, 0x18, 0xB0, 0xA1, 0xAB, 0x27, 0x57, 0x61, 0x0F, 0x1B, 0x8D, 0x1D, 0x0C, 0x57, 0xA1, 0x86, +/* 3100 */ 0x07, 0x8C, 0x07, 0x18, 0xAC, 0x07, 0x2C, 0xA4, 0x4E, 0xBC, 0xA2, 0x57, 0x1D, 0x08, 0x55, 0x7C, +/* 3110 */ 0x86, 0x77, 0x57, 0x4A, 0x40, 0x4E, 0x7C, 0x0D, 0x2C, 0x77, 0x57, 0xA9, 0x2C, 0x09, 0x4E, 0x7C, +/* 3120 */ 0x0D, 0x2C, 0x77, 0xAC, 0x6D, 0x96, 0x55, 0x27, 0xB4, 0xB4, 0x74, 0x45, 0xAF, 0x0A, 0x55, 0x91, +/* 3130 */ 0x48, 0x96, 0x88, 0xBC, 0x1E, 0x03, 0x4E, 0xAF, 0x30, 0x7A, 0x0A, 0xC4, 0x99, 0x71, 0x04, 0x99, +/* 3140 */ 0x7C, 0x08, 0x10, 0x1C, 0x95, 0xA1, 0x24, 0x90, 0x07, 0x07, 0x03, 0x19, 0x0A, 0x67, 0x01, 0x19, +/* 3150 */ 0xBB, 0xB2, 0x01, 0x8D, 0x7C, 0x18, 0x19, 0x50, 0xA2, 0x8C, 0x09, 0x0F, 0x1B, 0x19, 0x29, 0x6F, +/* 3160 */ 0x08, 0x06, 0x0D, 0x40, 0x4E, 0xA1, 0x86, 0x07, 0x7A, 0x6D, 0x02, 0x00, 0x6D, 0x1E, 0x03, 0x55, +/* 3170 */ 0x07, 0x2C, 0xA4, 0x1A, 0x96, 0xAB, 0x1D, 0x08, 0x2E, 0x9F, 0x0C, 0x4E, 0x4A, 0x40, 0x24, 0x8B, +/* 3180 */ 0x89, 0xAB, 0xA9, 0x2C, 0x09, 0xAC, 0xA9, 0x0F, 0x1B, 0x47, 0xAB, 0x6D, 0x96, 0x24, 0x91, 0x69, +/* 3190 */ 0x5F, 0xAF, 0x0A, 0x00, 0xA1, 0x03, 0xAC, 0x4A, 0x1E, 0x07, 0xBC, 0x1E, 0x03, 0x61, 0x35, 0x06, +/* 31A0 */ 0x78, 0xA1, 0xA2, 0xB0, 0x0B, 0xC4, 0x00, 0xA9, 0x2C, 0x09, 0x8C, 0xA1, 0x0B, 0x06, 0x00, 0x4A, +/* 31B0 */ 0x31, 0x29, 0x1E, 0x04, 0xBC, 0x1E, 0x03, 0x8D, 0xAF, 0x6F, 0x58, 0x00, 0x09, 0xB3, 0x00, 0x71, +/* 31C0 */ 0x0D, 0x45, 0x42, 0x8A, 0x02, 0x18, 0xB0, 0x32, 0x07, 0x45, 0x29, 0x0A, 0x0E, 0x0F, 0xEB, 0x05, +/* 31D0 */ 0x61, 0x0F, 0x1B, 0xAB, 0x07, 0x1E, 0x90, 0x2C, 0x05, 0xAC, 0x34, 0xE0, 0x2E, 0x71, 0x04, 0x99, +/* 31E0 */ 0x7C, 0x08, 0x10, 0x0E, 0xB0, 0x38, 0xE7, 0xBB, 0xB9, 0x05, 0x49, 0xAD, 0xA3, 0x49, 0xAA, 0x07, +/* 31F0 */ 0x49, 0xAA, 0x07, 0x7B, 0xAD, 0xA3, 0x88, 0xA8, 0x0A, 0xB9, 0x05, 0x4E, 0x4B, 0x1A, 0x0C, 0xB7, +/* 3200 */ 0x77, 0x49, 0x42, 0x7D, 0x0B, 0x8E, 0xC8, 0xAE, 0x7B, 0x63, 0x5A, 0x1F, 0x9F, 0x31, 0xC0, 0x50, +/* 3210 */ 0x3A, 0x36, 0x29, 0x2C, 0x18, 0xC8, 0xAE, 0xC0, 0x61, 0x1E, 0x3A, 0x4E, 0x98, 0x6C, 0x42, 0x0C, +/* 3220 */ 0xAB, 0x07, 0x6F, 0x04, 0x4C, 0x29, 0x97, 0x1B, 0x94, 0x0F, 0x18, 0x28, 0x8B, 0x41, 0x89, 0x00, +/* 3230 */ 0xA8, 0x8B, 0xB2, 0x02, 0xA6, 0x81, 0x53, 0xB9, 0x09, 0x04, 0x10, 0x11, 0xBE, 0x7C, 0x38, 0x7C, +/* 3240 */ 0x0F, 0x0A, 0x02, 0x99, 0x09, 0x0F, 0x6F, 0x07, 0x7B, 0x7C, 0x48, 0xBF, 0x36, 0x7C, 0x0A, 0xAA, +/* 3250 */ 0x44, 0x8D, 0xA8, 0x65, 0x1E, 0x04, 0x7D, 0x29, 0x09, 0x0B, 0x6B, 0x83, 0xE8, 0x10, 0x11, 0x4E, +/* 3260 */ 0xBE, 0x7C, 0x01, 0x7D, 0x61, 0x44, 0xC0, 0xBC, 0x0D, 0x2C, 0xA4, 0x36, 0x7C, 0x50, 0x44, 0x1F, +/* 3270 */ 0x29, 0x0E, 0xB2, 0x05, 0xA6, 0xA9, 0x0F, 0x6F, 0x5E, 0x7B, 0x4A, 0x0B, 0x05, 0xAB, 0x6B, 0x61, +/* 3280 */ 0xE8, 0x10, 0x11, 0xAC, 0x6B, 0xBC, 0xA2, 0xC0, 0xBC, 0x0E, 0x8F, 0x36, 0x29, 0x69, 0x8A, 0x6C, +/* 3290 */ 0x29, 0x0E, 0xA2, 0x86, 0x3A, 0x1F, 0x09, 0x0F, 0x6F, 0x05, 0x7C, 0x0B, 0x2C, 0xA4, 0x1F, 0x0B, +/* 32A0 */ 0x0A, 0x01, 0x4E, 0x37, 0x04, 0x78, 0xA8, 0x6B, 0x08, 0xE8, 0x10, 0x11, 0x00, 0x4B, 0xA0, 0x0E, +/* 32B0 */ 0x9B, 0x4A, 0xA7, 0x6C, 0x61, 0x97, 0xEB, 0x40, 0x28, 0x29, 0x30, 0xA2, 0x1F, 0x71, 0x0D, 0x85, +/* 32C0 */ 0xA4, 0x6C, 0x7C, 0x08, 0x77, 0x6D, 0x0C, 0xB5, 0x03, 0xAC, 0xBE, 0x61, 0xE8, 0x10, 0x11, 0x38, +/* 32D0 */ 0xBE, 0x29, 0x0C, 0x0E, 0x0A, 0x01, 0x00, 0x6D, 0x53, 0x08, 0x28, 0xA9, 0x8A, 0x02, 0x0F, 0x18, +/* 32E0 */ 0x00, 0xA8, 0xAE, 0x00, 0x04, 0x8F, 0x4C, 0xA9, 0x8A, 0x02, 0x0F, 0x18, 0x28, 0x29, 0x0C, 0x0E, +/* 32F0 */ 0x0A, 0x01, 0x00, 0x6D, 0x53, 0x08, 0x57, 0xBE, 0x61, 0xE8, 0x10, 0x11, 0x8C, 0x29, 0x0A, 0x0C, +/* 3300 */ 0x0B, 0x47, 0x88, 0x1A, 0xB2, 0xC0, 0x34, 0x30, 0x07, 0x8D, 0x1A, 0xC4, 0x90, 0xC4, 0xA6, 0x4A, +/* 3310 */ 0x2C, 0x07, 0xA1, 0x0F, 0x1B, 0x8D, 0x1A, 0x2C, 0x0A, 0x00, 0x04, 0xB3, 0xAB, 0xA8, 0x86, 0x69, +/* 3320 */ 0x07, 0xC0, 0x42, 0x1B, 0x01, 0x88, 0x1A, 0x0C, 0x6F, 0x9B, 0x6B, 0x83, 0xE8, 0x10, 0x19, 0x57, +/* 3330 */ 0x80, 0xA8, 0x5B, 0x8F, 0xAC, 0x59, 0x5B, 0x07, 0xAC, 0x27, 0x41, 0x54, 0x78, 0xA1, 0x41, 0x1B, +/* 3340 */ 0x2A, 0x02, 0x78, 0x4A, 0x1E, 0x9E, 0xA2, 0xA6, 0x0B, 0xA2, 0x71, 0x1B, 0x1F, 0x32, 0x51, 0x08, +/* 3350 */ 0x97, 0x1F, 0x59, 0x02, 0x59, 0x03, 0x4E, 0x66, 0x0D, 0x00, 0x04, 0x7E, 0x2E, 0x7C, 0x8F, 0x00, +/* 3360 */ 0x32, 0x1B, 0x26, 0x26, 0x26, 0x04, 0x7A, 0x42, 0x05, 0x1D, 0x48, 0x18, 0x19, 0x91, 0x70, 0xA9, +/* 3370 */ 0x41, 0x18, 0x45, 0x7C, 0xAE, 0xAB, 0x0A, 0x41, 0x18, 0x19, 0x07, 0x1E, 0x44, 0x61, 0x97, 0x03, +/* 3380 */ 0x24, 0x91, 0x0F, 0x22, 0x0B, 0x26, 0x85, 0x05, 0xAC, 0x7C, 0x5B, 0x64, 0x4E, 0x42, 0x30, 0x8F, +/* 3390 */ 0xAC, 0x91, 0x5B, 0x22, 0x57, 0x29, 0x0F, 0x70, 0xAB, 0xA9, 0x8E, 0x7A, 0x61, 0xAE, 0x8D, 0x0B, +/* 33A0 */ 0x97, 0x26, 0x26, 0x26, 0x08, 0x8C, 0x85, 0x07, 0x8D, 0x09, 0x48, 0xB2, 0x55, 0x29, 0x48, 0x03, +/* 33B0 */ 0x8D, 0x07, 0x48, 0xB2, 0x4E, 0x61, 0x1E, 0x6F, 0x8D, 0x6D, 0x48, 0xB2, 0x10, 0x11, 0x80, 0x02, +/* 33C0 */ 0x05, 0x07, 0x2F, 0x36, 0x29, 0x0B, 0x30, 0x67, 0x1F, 0x07, 0x41, 0x22, 0x02, 0x2E, 0x4A, 0x5B, +/* 33D0 */ 0x5F, 0xAC, 0x29, 0x2C, 0x22, 0x05, 0x03, 0x05, 0x0B, 0x0F, 0x84, 0x4C, 0x50, 0x77, 0xAB, 0x4A, +/* 33E0 */ 0x04, 0x2E, 0x7C, 0x48, 0x03, 0xC8, 0x1E, 0x1B, 0x49, 0x0A, 0x8F, 0x49, 0x85, 0x07, 0x49, 0x54, +/* 33F0 */ 0x49, 0x54, 0x49, 0x54, 0x49, 0x54, 0x49, 0xAA, 0x3E, 0x0C, 0x97, 0x21, 0x63, 0x0C, 0xCD, 0xA3, +/* 3400 */ 0x49, 0xAA, 0x0A, 0x4E, 0x7C, 0x06, 0x28, 0x07, 0x2C, 0xA2, 0x02, 0x7C, 0xA0, 0x6E, 0x24, 0x91, +/* 3410 */ 0x5B, 0x84, 0x2E, 0x7C, 0x0D, 0x30, 0x54, 0x28, 0x9F, 0x30, 0x74, 0x1F, 0x29, 0x09, 0x0D, 0x0F, +/* 3420 */ 0x6F, 0x0A, 0x05, 0x49, 0x09, 0x2C, 0x04, 0x99, 0x0B, 0x0F, 0x1B, 0x72, 0xC0, 0xA9, 0xAE, 0x49, +/* 3430 */ 0x7C, 0x09, 0x96, 0x36, 0x7C, 0x00, 0x6D, 0x1E, 0x03, 0x36, 0x91, 0xB9, 0x70, 0x36, 0x3D, 0x07, +/* 3440 */ 0xC0, 0x93, 0x0C, 0x0E, 0x9E, 0x05, 0x10, 0x0F, 0xBE, 0x02, 0x01, 0x00, 0x38, 0x0B, 0xBF, 0x7D, +/* 3450 */ 0x29, 0xA2, 0x02, 0x19, 0x66, 0x6F, 0x07, 0xC8, 0x85, 0x35, 0x49, 0x81, 0x46, 0xA1, 0x65, 0x02, +/* 3460 */ 0x8C, 0x38, 0x60, 0x5B, 0x03, 0x4C, 0xC2, 0x58, 0x10, 0x0F, 0x4E, 0xBE, 0x7C, 0x7D, 0xBC, 0x0D, +/* 3470 */ 0x0C, 0x49, 0x7C, 0x0A, 0x76, 0xC8, 0x69, 0x35, 0x36, 0x91, 0x97, 0x1B, 0x47, 0x1F, 0x61, 0xA2, +/* 3480 */ 0x4D, 0x01, 0x0C, 0x47, 0x7A, 0x38, 0x60, 0x5B, 0x03, 0x4C, 0xC2, 0x58, 0x10, 0x0F, 0xBE, 0x01, +/* 3490 */ 0x0C, 0x2C, 0x89, 0x8C, 0xA8, 0x0C, 0x97, 0x89, 0x36, 0x9F, 0x97, 0x5F, 0x55, 0x66, 0xB7, 0x1E, +/* 34A0 */ 0x77, 0x4C, 0xBC, 0x8A, 0x00, 0x07, 0x18, 0x6C, 0x4A, 0xBF, 0xAB, 0x29, 0x0D, 0x08, 0x78, 0xA8, +/* 34B0 */ 0x8C, 0x38, 0x60, 0x5B, 0x03, 0x4C, 0xC2, 0x58, 0x10, 0x0F, 0x38, 0xBE, 0xBB, 0x9E, 0x03, 0xCA, +/* 34C0 */ 0x7C, 0x0B, 0xEB, 0x02, 0x19, 0x6B, 0x60, 0x5B, 0x03, 0x4C, 0xC2, 0x58, 0x10, 0x09, 0x1F, 0x38, +/* 34D0 */ 0xA8, 0x01, 0x00, 0x38, 0x37, 0x06, 0x99, 0x34, 0x0F, 0x35, 0x03, 0xC0, 0x61, 0x48, 0x9B, 0xC0, +/* 34E0 */ 0x65, 0x48, 0x84, 0xC0, 0x29, 0x09, 0x86, 0x0D, 0x78, 0x1A, 0x0B, 0x05, 0x00, 0x6B, 0xE9, 0x10, +/* 34F0 */ 0x09, 0xBE, 0x29, 0x99, 0x29, 0x0B, 0xA4, 0x88, 0xA8, 0x08, 0x8A, 0x8C, 0x1A, 0x85, 0xA4, 0x36, +/* 3500 */ 0x63, 0x6F, 0x9D, 0x8D, 0x1A, 0x56, 0x06, 0x01, 0x49, 0x0B, 0x5E, 0x55, 0x6B, 0xE9, 0x10, 0x09, +/* 3510 */ 0x78, 0x6B, 0x8B, 0x4D, 0x63, 0xEF, 0xC0, 0x09, 0x30, 0xEF, 0x6C, 0x61, 0x2C, 0x6F, 0x8B, 0xEF, +/* 3520 */ 0x28, 0x7C, 0x0E, 0xC4, 0x01, 0x6D, 0x86, 0x09, 0x28, 0xBC, 0x0E, 0x06, 0xAB, 0x7C, 0x26, 0x57, +/* 3530 */ 0xA8, 0x6B, 0xE9, 0x10, 0x09, 0x49, 0xBE, 0x37, 0x67, 0xAB, 0x09, 0x9E, 0x04, 0x4C, 0xBC, 0x20, +/* 3540 */ 0x07, 0x1E, 0xA4, 0x28, 0x07, 0x7E, 0x27, 0x82, 0xAC, 0xBC, 0x20, 0x07, 0x1E, 0xA4, 0x6C, 0x37, +/* 3550 */ 0x67, 0xB0, 0xBB, 0x0E, 0xBF, 0x24, 0xBE, 0xE9, 0x10, 0x14, 0x00, 0x73, 0xB1, 0x1B, 0x0C, 0x09, +/* 3560 */ 0x3C, 0x4E, 0x66, 0x41, 0x3A, 0x28, 0x0B, 0x41, 0xB2, 0xB0, 0x66, 0x35, 0x0B, 0x0C, 0xAA, 0xA5, +/* 3570 */ 0x4F, 0xBB, 0x48, 0x03, 0x66, 0x51, 0x4E, 0x0B, 0x0F, 0xA2, 0x66, 0x51, 0x4E, 0x2D, 0x0E, 0x66, +/* 3580 */ 0x51, 0xAB, 0xA1, 0x48, 0x03, 0x4F, 0xAB, 0x85, 0x06, 0x7A, 0x4A, 0x94, 0x0F, 0x22, 0x26, 0x39, +/* 3590 */ 0x91, 0x0F, 0x64, 0x83, 0x48, 0x75, 0x0B, 0x2C, 0xF5, 0x61, 0x48, 0x75, 0x0B, 0x2C, 0xF5, 0x61, +/* 35A0 */ 0x48, 0x75, 0x0B, 0x97, 0x07, 0x4F, 0xB0, 0x91, 0x97, 0x07, 0x4F, 0xAB, 0xAA, 0x05, 0x4F, 0x00, +/* 35B0 */ 0xA1, 0x2C, 0x96, 0x4F, 0xB0, 0x2D, 0x0E, 0x66, 0x51, 0xAB, 0x91, 0x8F, 0x00, 0x4F, 0xBB, 0x48, +/* 35C0 */ 0x03, 0x66, 0x35, 0x0B, 0x0C, 0x86, 0x8A, 0x66, 0x48, 0x5C, 0x66, 0x30, 0x6F, 0x06, 0x28, 0x0B, +/* 35D0 */ 0x30, 0xB9, 0x0A, 0x06, 0x10, 0x13, 0x4B, 0x61, 0xB9, 0x72, 0x00, 0x07, 0xA7, 0xA6, 0x63, 0x9E, +/* 35E0 */ 0x2C, 0xA4, 0x6C, 0x3D, 0x31, 0x1F, 0x71, 0x0D, 0x85, 0x5F, 0x28, 0x7C, 0x08, 0x0B, 0xB0, 0x65, +/* 35F0 */ 0xB5, 0x02, 0x7A, 0xBE, 0x3D, 0xC7, 0xF9, 0x10, 0x14, 0x00, 0xBE, 0x7C, 0x01, 0x00, 0x38, 0x0B, +/* 3600 */ 0xF2, 0x7B, 0x29, 0xA2, 0x02, 0x19, 0x66, 0x6F, 0x07, 0xC8, 0x85, 0x1B, 0x49, 0x81, 0x46, 0xA1, +/* 3610 */ 0x65, 0x02, 0x7B, 0xDA, 0x2F, 0x10, 0x14, 0x8D, 0xBE, 0x7C, 0x7D, 0xBC, 0x0D, 0x0C, 0x49, 0x7C, +/* 3620 */ 0x0A, 0x76, 0xC8, 0x69, 0x1B, 0x36, 0x91, 0x97, 0x1B, 0x72, 0x1F, 0x61, 0xA2, 0x4D, 0x01, 0x0C, +/* 3630 */ 0x47, 0x38, 0xDA, 0x2F, 0x10, 0x14, 0x6B, 0xA8, 0x0C, 0x2C, 0x89, 0x8C, 0xA8, 0x0C, 0x97, 0x89, +/* 3640 */ 0x36, 0x9F, 0x97, 0x5F, 0x55, 0x66, 0x0D, 0x27, 0x77, 0x4C, 0xBC, 0x8A, 0x00, 0x07, 0x18, 0x6C, +/* 3650 */ 0x4A, 0xBF, 0xAB, 0x29, 0x0D, 0x09, 0x78, 0xA8, 0x7B, 0xDA, 0x2F, 0x10, 0x14, 0x4B, 0xBC, 0x0C, +/* 3660 */ 0xEB, 0x03, 0x00, 0x62, 0x06, 0x1F, 0x29, 0x2C, 0x22, 0x86, 0xE2, 0xAF, 0x30, 0xA4, 0xAB, 0x60, +/* 3670 */ 0x6F, 0xB1, 0x06, 0xA6, 0x65, 0x04, 0x7C, 0x0A, 0x0E, 0x67, 0x00, 0x6B, 0xDA, 0x2F, 0x10, 0x14, +/* 3680 */ 0x00, 0x4B, 0x09, 0x9E, 0x03, 0x00, 0x7C, 0x0B, 0xEB, 0x02, 0x6C, 0x07, 0x8E, 0x00, 0x0B, 0x56, +/* 3690 */ 0x6C, 0x0B, 0x20, 0x86, 0x6F, 0x6C, 0x07, 0x8E, 0x00, 0x0B, 0x56, 0x6C, 0xBB, 0x9E, 0x03, 0x00, +/* 36A0 */ 0x7C, 0x0B, 0xEB, 0x02, 0x49, 0x38, 0xDA, 0x2F, 0x10, 0x0F, 0x78, 0xE7, 0xA8, 0x4E, 0xA1, 0x55, +/* 36B0 */ 0xA8, 0x0A, 0x0C, 0x55, 0x26, 0x01, 0xB0, 0xA8, 0x0C, 0x2C, 0x0A, 0xAB, 0x71, 0x77, 0x28, 0x2D, +/* 36C0 */ 0x07, 0x83, 0x0F, 0x18, 0x4C, 0x61, 0x8F, 0x1E, 0x3A, 0xA6, 0x50, 0xA2, 0xC0, 0x0B, 0xB2, 0x7B, +/* 36D0 */ 0x59, 0x3A, 0xC0, 0x3D, 0x6E, 0x28, 0x29, 0x86, 0x6F, 0x58, 0x28, 0x7C, 0x69, 0x77, 0x27, 0xEF, +/* 36E0 */ 0x2E, 0xBC, 0x1E, 0x84, 0xA1, 0x0D, 0x76, 0x28, 0x29, 0x0E, 0xEF, 0xB0, 0x7C, 0x0E, 0x6A, 0x6C, +/* 36F0 */ 0x7C, 0x04, 0xAB, 0xBC, 0x03, 0x10, 0x14, 0xB0, 0xBD, 0x29, 0x01, 0xAB, 0xF3, 0x35, 0x47, 0x7B, +/* 3700 */ 0x7C, 0x8E, 0x7B, 0x4A, 0xA2, 0xA6, 0x7C, 0x05, 0x07, 0x07, 0x0C, 0x18, 0x28, 0xBC, 0x0C, 0x48, +/* 3710 */ 0x96, 0x6C, 0xB8, 0x97, 0x77, 0x24, 0x61, 0x41, 0xB2, 0x24, 0x29, 0x0F, 0x8F, 0x3F, 0x30, 0x07, +/* 3720 */ 0x66, 0x44, 0x00, 0x07, 0x30, 0xA4, 0x78, 0x7C, 0x1E, 0x6F, 0xAB, 0x0B, 0x35, 0x0B, 0x7E, 0x78, +/* 3730 */ 0x07, 0x8F, 0xAB, 0x0E, 0x0F, 0x09, 0x42, 0x0A, 0x57, 0x8B, 0x51, 0x00, 0x29, 0x2C, 0x05, 0x04, +/* 3740 */ 0x1E, 0x1B, 0x7A, 0xA9, 0x1E, 0x5A, 0x07, 0x0F, 0x9A, 0x02, 0x48, 0x57, 0x69, 0x82, 0x0A, 0x1B, +/* 3750 */ 0xA1, 0x2C, 0x96, 0x78, 0x2C, 0x96, 0xB0, 0x0E, 0xA5, 0x2C, 0x96, 0x19, 0xA1, 0x2C, 0x96, 0x7C, +/* 3760 */ 0x0F, 0x6E, 0x48, 0x03, 0x78, 0x2C, 0x96, 0x4A, 0x0F, 0xA3, 0xB0, 0x2C, 0x96, 0x78, 0xAA, 0x03, +/* 3770 */ 0x00, 0x0A, 0x1B, 0x00, 0xA1, 0x0F, 0x70, 0x19, 0xA9, 0x58, 0x00, 0x0D, 0xA5, 0x02, 0x48, 0x57, +/* 3780 */ 0x27, 0x51, 0x02, 0x2C, 0x05, 0xBC, 0x75, 0x7A, 0x07, 0x8F, 0x06, 0x0F, 0xA3, 0xB0, 0x07, 0x8F, +/* 3790 */ 0x78, 0x29, 0x1E, 0x1B, 0x09, 0x1B, 0xB0, 0x91, 0x58, 0x57, 0x91, 0x1E, 0x6F, 0xA5, 0x2D, 0x0D, +/* 37A0 */ 0xAC, 0x6D, 0x48, 0x3A, 0x04, 0x08, 0x54, 0x2E, 0x71, 0x41, 0xA2, 0x28, 0x0A, 0x41, 0xA2, 0x1F, +/* 37B0 */ 0x0E, 0x41, 0x67, 0x6C, 0x29, 0x2C, 0x1B, 0x07, 0x2F, 0x36, 0x07, 0x8A, 0xC0, 0xAF, 0x5A, 0xC8, +/* 37C0 */ 0x0B, 0x0F, 0x9A, 0x7A, 0xA8, 0x03, 0x10, 0x13, 0x00, 0xBE, 0x7C, 0x38, 0x4A, 0x3A, 0xB0, 0xF3, +/* 37D0 */ 0x2C, 0xBF, 0x7B, 0x4A, 0x2C, 0xA2, 0x02, 0xA6, 0xBC, 0xB1, 0x6A, 0x36, 0x7C, 0x08, 0x0D, 0x2C, +/* 37E0 */ 0xA4, 0x99, 0x81, 0x07, 0x1F, 0x38, 0x61, 0x97, 0xD0, 0xCC, 0x01, 0x10, 0x13, 0x55, 0xBE, 0x29, +/* 37F0 */ 0x99, 0x7C, 0x0A, 0xA3, 0xB0, 0xC8, 0x86, 0x0A, 0x36, 0xBC, 0x85, 0x82, 0x1F, 0x42, 0x6F, 0x9D, +/* 3800 */ 0xA6, 0x29, 0x22, 0x06, 0x01, 0x49, 0x0A, 0x09, 0x03, 0x6B, 0x08, 0x97, 0xD0, 0xCC, 0x01, 0x10, +/* 3810 */ 0x13, 0xBE, 0x61, 0x76, 0xC0, 0x61, 0x54, 0xC0, 0x07, 0x1E, 0x58, 0x1F, 0x4A, 0x2C, 0x6F, 0x8B, +/* 3820 */ 0x5A, 0xA8, 0x0D, 0x0F, 0x35, 0x02, 0x00, 0x04, 0x0D, 0xC4, 0x6C, 0x7C, 0x0E, 0x07, 0xAB, 0xA1, +/* 3830 */ 0x0A, 0x5F, 0x7A, 0xA8, 0x6C, 0x38, 0x61, 0x97, 0xD0, 0xCC, 0x01, 0x10, 0x13, 0x4B, 0x06, 0x53, +/* 3840 */ 0x07, 0xAB, 0xA0, 0xF2, 0x2E, 0x29, 0x58, 0x4A, 0x20, 0x4C, 0x59, 0x07, 0xAD, 0x5A, 0x24, 0x29, +/* 3850 */ 0x58, 0x4A, 0x20, 0x4C, 0x4A, 0x53, 0x07, 0xAB, 0xA0, 0xF2, 0x8D, 0xBE, 0x61, 0x97, 0xD0, 0xCC, +/* 3860 */ 0x01, 0x10, 0x11, 0x4E, 0xBE, 0x7C, 0x7A, 0xA8, 0x08, 0x51, 0x19, 0x1A, 0x0D, 0x0F, 0x1B, 0xC0, +/* 3870 */ 0x7C, 0x50, 0x44, 0x1F, 0x29, 0x0E, 0xB2, 0x04, 0x36, 0x34, 0x0F, 0x1B, 0x5E, 0x7B, 0x4A, 0x0A, +/* 3880 */ 0x05, 0x49, 0x38, 0x32, 0xD4, 0x10, 0x11, 0x80, 0x2B, 0x41, 0xB9, 0x0A, 0x05, 0x4C, 0xBC, 0x5B, +/* 3890 */ 0xBF, 0x00, 0x60, 0x41, 0x54, 0x60, 0x2C, 0x6F, 0x26, 0x0D, 0x48, 0xA4, 0xFE, 0x06, 0x48, 0x07, +/* 38A0 */ 0xFE, 0xAD, 0xB5, 0xFE, 0x6D, 0x1E, 0x1B, 0xFE, 0x00, 0x04, 0x1E, 0x6F, 0xFE, 0x4A, 0x0F, 0x22, +/* 38B0 */ 0xFE, 0x00, 0x50, 0x0A, 0xFE, 0x59, 0x51, 0x57, 0xBC, 0x1E, 0x6F, 0x26, 0x0D, 0x48, 0xA4, 0x24, +/* 38C0 */ 0x3D, 0x1E, 0x58, 0xAC, 0xBC, 0x5B, 0xBF, 0x24, 0xBC, 0x41, 0xB9, 0x0A, 0x05, 0x4C, 0xBC, 0x97, +/* 38D0 */ 0xEE, 0xC0, 0xBC, 0x97, 0xEE, 0x10, 0x12, 0x00, 0x3B, 0x4A, 0x94, 0x0F, 0x9E, 0x47, 0x1F, 0x7C, +/* 38E0 */ 0x0D, 0x41, 0x6A, 0x00, 0xA8, 0x85, 0x48, 0x84, 0x28, 0x63, 0xEB, 0x69, 0x3A, 0x28, 0xAA, 0x03, +/* 38F0 */ 0x7C, 0xAE, 0x2E, 0x29, 0xAE, 0xB0, 0x91, 0x56, 0x4C, 0x79, 0xAB, 0x69, 0x07, 0x4C, 0x79, 0xBC, +/* 3900 */ 0x1E, 0x5F, 0x2E, 0x79, 0xA1, 0x0D, 0x1E, 0x03, 0x28, 0x79, 0x83, 0x8A, 0x28, 0x79, 0x00, 0x0E, +/* 3910 */ 0x96, 0x6C, 0x2D, 0x9B, 0x7E, 0x28, 0x79, 0x00, 0x97, 0x84, 0x28, 0x79, 0x00, 0x0B, 0x97, 0xEF, +/* 3920 */ 0x4C, 0x79, 0x29, 0xAA, 0x6A, 0x24, 0x79, 0xBC, 0x48, 0xA4, 0x24, 0x79, 0xAB, 0x2D, 0xA5, 0x57, +/* 3930 */ 0x79, 0x4E, 0x42, 0x0E, 0x24, 0x79, 0x4E, 0x34, 0x20, 0x57, 0x79, 0x55, 0x85, 0x03, 0xAC, 0x79, +/* 3940 */ 0x55, 0x69, 0xA3, 0xAC, 0x79, 0x00, 0x6D, 0x04, 0x63, 0x0E, 0x24, 0x79, 0x29, 0x30, 0x3A, 0x24, +/* 3950 */ 0x79, 0xAD, 0x22, 0x2E, 0x2D, 0x9B, 0x86, 0xA2, 0x01, 0x7B, 0x3F, 0x07, 0x05, 0x02, 0x10, 0x10, +/* 3960 */ 0x7D, 0xBD, 0x7C, 0x03, 0x00, 0x38, 0x0A, 0x3A, 0x7D, 0x29, 0x1E, 0x74, 0x49, 0xB1, 0x72, 0xA6, +/* 3970 */ 0xBC, 0xB1, 0x5F, 0x36, 0x7C, 0x09, 0x86, 0x0C, 0x99, 0x93, 0xBF, 0xBE, 0xDC, 0xB5, 0xEC, 0x10, +/* 3980 */ 0x10, 0x00, 0x43, 0xBC, 0x7A, 0xA8, 0x0A, 0x44, 0x45, 0x1A, 0x86, 0xA4, 0x8D, 0xA8, 0x50, 0x3A, +/* 3990 */ 0xA6, 0x29, 0x86, 0x31, 0x03, 0x36, 0x34, 0x0F, 0x6F, 0x47, 0x00, 0xC8, 0x0C, 0x05, 0x55, 0xBE, +/* 39A0 */ 0xDC, 0xB5, 0xEC, 0x10, 0x10, 0x7D, 0xBD, 0x7C, 0x0E, 0xC4, 0x7B, 0x7C, 0x85, 0x0A, 0x8D, 0xA8, +/* 39B0 */ 0x0C, 0x2C, 0x8F, 0x36, 0x0B, 0x56, 0x0D, 0x8A, 0x6C, 0x07, 0x2C, 0x44, 0x9F, 0x82, 0xA8, 0x0C, +/* 39C0 */ 0x6A, 0xAB, 0x07, 0xA5, 0xB0, 0xA8, 0x02, 0x55, 0x29, 0xBE, 0xDC, 0xB5, 0xEC, 0x10, 0x10, 0x38, +/* 39D0 */ 0x43, 0x4A, 0x53, 0x0A, 0x02, 0x00, 0x04, 0x0B, 0x05, 0x1F, 0x4A, 0xB2, 0x2C, 0x5A, 0xA8, 0xAA, +/* 39E0 */ 0x75, 0x28, 0x07, 0x2C, 0x9E, 0x48, 0x03, 0x1F, 0x93, 0x0C, 0x02, 0x00, 0x04, 0x0B, 0x9E, 0x04, +/* 39F0 */ 0x00, 0x4B, 0xDC, 0xB5, 0xEC, 0x10, 0x10, 0x7D, 0x43, 0x7C, 0x0B, 0xEB, 0x01, 0xBC, 0x53, 0x09, +/* 3A00 */ 0x1F, 0x0B, 0xA2, 0xA1, 0x69, 0x07, 0x6C, 0x1E, 0x1B, 0x29, 0x5C, 0x4C, 0x0B, 0xA2, 0xA1, 0x69, +/* 3A10 */ 0xE2, 0x7C, 0x0B, 0xEB, 0x01, 0xBC, 0x53, 0x09, 0x4B, 0xDC, 0xB5, 0xEC, 0x10, 0x10, 0xAB, 0x38, +/* 3A20 */ 0x4B, 0x29, 0x09, 0xB7, 0x72, 0x36, 0xBC, 0xAA, 0x5F, 0x36, 0x85, 0xF5, 0x7A, 0x29, 0x0F, 0x1B, +/* 3A30 */ 0x01, 0x04, 0x0F, 0x1B, 0x8D, 0x60, 0xA5, 0x86, 0xA6, 0x29, 0x0F, 0x35, 0x7C, 0x0F, 0x6F, 0xA6, +/* 3A40 */ 0xA9, 0x0F, 0x6F, 0x86, 0x09, 0x8C, 0x1A, 0x48, 0x84, 0x36, 0xBC, 0x0C, 0x6F, 0x0A, 0x02, 0x00, +/* 3A50 */ 0xBE, 0xDC, 0xB5, 0xEC, 0x10, 0x19, 0xBD, 0x80, 0xA8, 0x3F, 0x07, 0x07, 0x04, 0x55, 0xB6, 0x06, +/* 3A60 */ 0x02, 0x78, 0x6D, 0x0B, 0x30, 0x6A, 0x62, 0x2C, 0xA2, 0x01, 0x19, 0x91, 0x30, 0x18, 0x0E, 0x41, +/* 3A70 */ 0x5F, 0x45, 0x42, 0x5B, 0x5C, 0x8C, 0xA1, 0x0C, 0x09, 0x05, 0x5D, 0x07, 0x1E, 0x22, 0x05, 0x05, +/* 3A80 */ 0x85, 0x03, 0x2E, 0x63, 0xA4, 0x00, 0x7C, 0x8F, 0x2E, 0x07, 0x5C, 0xA9, 0x22, 0x19, 0x6D, 0x09, +/* 3A90 */ 0x0C, 0xB4, 0x69, 0x3A, 0x4E, 0x27, 0x0E, 0x8C, 0xBC, 0x85, 0x48, 0x5B, 0x8C, 0x29, 0x41, 0x5B, +/* 3AA0 */ 0x70, 0x8D, 0x91, 0xAE, 0x03, 0x6D, 0x1E, 0x5B, 0x8D, 0x7C, 0x97, 0xA4, 0xBC, 0x8F, 0x60, 0x22, +/* 3AB0 */ 0xAB, 0x32, 0x35, 0x60, 0x8E, 0xB0, 0x59, 0x5A, 0xB0, 0x90, 0x88, 0x7C, 0x97, 0x3A, 0x04, 0xB8, +/* 3AC0 */ 0x0E, 0x07, 0x5D, 0xA0, 0x5A, 0x55, 0xAF, 0x41, 0x85, 0x30, 0x84, 0x88, 0x3D, 0x2C, 0x72, 0x0C, +/* 3AD0 */ 0x30, 0x22, 0x02, 0x88, 0x6D, 0x69, 0x6F, 0x06, 0x00, 0xA1, 0x08, 0xAA, 0x6F, 0x47, 0x7A, 0x90, +/* 3AE0 */ 0x07, 0x07, 0x04, 0x8C, 0x3F, 0xBA, 0x04, 0x10, 0x0E, 0xE7, 0xB6, 0x06, 0x98, 0xA6, 0xBC, 0x85, +/* 3AF0 */ 0x6F, 0x07, 0x1F, 0x4A, 0x30, 0xA2, 0x6C, 0x3D, 0x58, 0x4C, 0xA9, 0xAE, 0x5D, 0x08, 0x3A, 0x6C, +/* 3B00 */ 0x2D, 0x0C, 0xAB, 0x29, 0x1F, 0x63, 0x3E, 0x85, 0x03, 0x49, 0x69, 0xA3, 0x7B, 0x32, 0xE4, 0x48, +/* 3B10 */ 0x47, 0x90, 0x74, 0x55, 0x66, 0x30, 0x5F, 0x4C, 0x7C, 0x9C, 0x09, 0x1F, 0x62, 0x41, 0x6A, 0x55, +/* 3B20 */ 0x1A, 0x0B, 0x2C, 0xEB, 0x47, 0x88, 0x1A, 0xF5, 0x2E, 0x4A, 0x0F, 0x6F, 0xA7, 0xC0, 0x61, 0x97, +/* 3B30 */ 0x84, 0x49, 0x90, 0x64, 0x7A, 0xA1, 0x03, 0x01, 0x02, 0x8A, 0x36, 0xB8, 0x05, 0x55, 0xA8, 0x86, +/* 3B40 */ 0xA2, 0xC0, 0x29, 0x09, 0x0B, 0x0C, 0x0A, 0x05, 0x10, 0x10, 0x43, 0x05, 0x38, 0x29, 0x35, 0x03, +/* 3B50 */ 0x78, 0x66, 0x21, 0x04, 0x2C, 0x22, 0x03, 0x8D, 0xA8, 0xA0, 0x48, 0x3E, 0x65, 0x1E, 0x04, 0x99, +/* 3B60 */ 0x81, 0x0A, 0x28, 0xBE, 0xFB, 0xC8, 0xF6, 0x10, 0x10, 0xAC, 0xBD, 0xA8, 0x04, 0x78, 0x1A, 0xB9, +/* 3B70 */ 0x45, 0xA8, 0x8B, 0x07, 0xC0, 0x4A, 0xAA, 0xA4, 0x36, 0x71, 0x22, 0x06, 0xA6, 0x61, 0xA2, 0x4D, +/* 3B80 */ 0x01, 0x0D, 0x5E, 0x36, 0xBE, 0xFB, 0xC8, 0xF6, 0x10, 0x10, 0x43, 0x8B, 0x4D, 0x08, 0x97, 0xEF, +/* 3B90 */ 0xC0, 0x07, 0x30, 0x84, 0x55, 0x1A, 0x2C, 0x6F, 0x8B, 0x5F, 0x00, 0xA8, 0x22, 0x02, 0x4A, 0x86, +/* 3BA0 */ 0x0A, 0x6C, 0x4A, 0xA5, 0x00, 0x29, 0x0D, 0x89, 0x1F, 0x29, 0x55, 0xA1, 0x02, 0x4C, 0xBE, 0xFB, +/* 3BB0 */ 0xC8, 0xF6, 0x10, 0x10, 0x38, 0x43, 0x37, 0xF2, 0x01, 0x0A, 0x9E, 0x03, 0x6C, 0x2D, 0x02, 0x83, +/* 3BC0 */ 0x8E, 0x2E, 0x61, 0x7E, 0x27, 0xA3, 0x28, 0x2D, 0x02, 0x83, 0x8E, 0x6C, 0xA0, 0xF2, 0x01, 0x0A, +/* 3BD0 */ 0x9E, 0x03, 0x4C, 0x4B, 0xFB, 0xC8, 0xF6, 0x10, 0x08, 0x88, 0xBD, 0x1A, 0x38, 0x4A, 0x0F, 0x0A, +/* 3BE0 */ 0x01, 0x00, 0xF3, 0x0F, 0x6F, 0x3E, 0x07, 0xB2, 0x02, 0x36, 0x7C, 0x09, 0xAA, 0x6A, 0xC0, 0x93, +/* 3BF0 */ 0x0D, 0x2C, 0x84, 0x7A, 0x1A, 0x0B, 0x08, 0x28, 0x4B, 0x79, 0xF1, 0xF1, 0x25, 0x10, 0x08, 0x7D, +/* 3C00 */ 0xBD, 0x7C, 0x02, 0x4E, 0xC8, 0xB5, 0x49, 0x29, 0x0C, 0x1E, 0x04, 0x36, 0x61, 0x2C, 0x22, 0x55, +/* 3C10 */ 0xA8, 0x0C, 0xB2, 0x05, 0xC0, 0x0B, 0x0F, 0x6F, 0x09, 0x03, 0x7B, 0x29, 0x0D, 0x47, 0x36, 0x4B, +/* 3C20 */ 0x79, 0xF1, 0xF1, 0x25, 0x10, 0x08, 0x8D, 0xBD, 0xA8, 0x0C, 0x2C, 0x84, 0x19, 0x66, 0x1B, 0x01, +/* 3C30 */ 0xC0, 0x0A, 0x30, 0x77, 0x6C, 0x61, 0x2C, 0x1B, 0x0B, 0x56, 0x28, 0xBC, 0xA2, 0x01, 0x83, 0x64, +/* 3C40 */ 0x45, 0x09, 0x44, 0xB0, 0x6D, 0x0E, 0x77, 0x1F, 0x29, 0x55, 0x7C, 0x01, 0x4C, 0x4B, 0x79, 0xF1, +/* 3C50 */ 0xF1, 0x25, 0x10, 0x08, 0xC0, 0x43, 0xBB, 0x9E, 0x03, 0xCA, 0x7C, 0x0B, 0xEB, 0x02, 0x7A, 0x92, +/* 3C60 */ 0x79, 0xF1, 0xF1, 0x25, 0x10, 0x11, 0x2E, 0x43, 0xA8, 0x0C, 0x06, 0xC0, 0x0A, 0x08, 0x05, 0xB0, +/* 3C70 */ 0x0B, 0x2C, 0x09, 0x1F, 0x7C, 0x1E, 0x9E, 0x22, 0x1F, 0x4A, 0x41, 0x5F, 0x4E, 0x1A, 0x0B, 0x30, +/* 3C80 */ 0x89, 0x36, 0x4A, 0x30, 0x84, 0x1F, 0x29, 0x0E, 0x41, 0x5F, 0xAB, 0x1A, 0x0D, 0x2C, 0x04, 0x63, +/* 3C90 */ 0x0A, 0x8D, 0x1A, 0x05, 0xAF, 0x2C, 0x03, 0x7B, 0x29, 0x5C, 0x28, 0x93, 0x0A, 0x0A, 0x47, 0x0C, +/* 3CA0 */ 0x70, 0xB0, 0x1A, 0x69, 0x6F, 0x0A, 0x7E, 0x60, 0x5B, 0x08, 0x24, 0xA9, 0x41, 0xB2, 0x2E, 0x59, +/* 3CB0 */ 0x74, 0x00, 0x04, 0x85, 0x0C, 0x2E, 0x8B, 0x6E, 0x29, 0x1E, 0x1B, 0x2E, 0x0E, 0x70, 0xAB, 0x32, +/* 3CC0 */ 0x6F, 0x2E, 0x1E, 0x6F, 0x4E, 0x32, 0x1B, 0x24, 0x32, 0x6F, 0x4E, 0x32, 0x35, 0xAC, 0x1D, 0x6F, +/* 3CD0 */ 0xAB, 0x7C, 0x5C, 0x78, 0xA9, 0x70, 0xAB, 0x2D, 0x06, 0xAC, 0x61, 0x0F, 0x18, 0xAB, 0x8B, 0xA3, +/* 3CE0 */ 0x24, 0x29, 0x1E, 0x6F, 0x06, 0x03, 0x08, 0x5C, 0x24, 0xAD, 0x41, 0x84, 0x28, 0x9F, 0x30, 0x6A, +/* 3CF0 */ 0x1F, 0x07, 0x86, 0x22, 0x03, 0x7B, 0x3F, 0x2F, 0x10, 0x11, 0x78, 0x43, 0xA8, 0x0A, 0xB9, 0x07, +/* 3D00 */ 0xB0, 0x09, 0x9D, 0xA6, 0x0B, 0x97, 0x9E, 0x0F, 0x1B, 0x1F, 0x59, 0x48, 0xE2, 0xAF, 0x0C, 0x85, +/* 3D10 */ 0x0C, 0x1F, 0x29, 0x09, 0x0A, 0xB0, 0x07, 0x53, 0x0A, 0x01, 0x6C, 0x4B, 0xBC, 0x07, 0x07, 0xC6, +/* 3D20 */ 0x7F, 0x03, 0xE6, 0x10, 0x11, 0x43, 0x98, 0x38, 0x34, 0x0E, 0x05, 0x49, 0x61, 0xA2, 0x01, 0x8C, +/* 3D30 */ 0xA8, 0x69, 0x6F, 0x05, 0x8D, 0xA8, 0x06, 0x85, 0xA5, 0xA6, 0xBC, 0x27, 0x07, 0x7D, 0x7C, 0x09, +/* 3D40 */ 0x5F, 0x2E, 0xBE, 0xF0, 0x10, 0x11, 0xB0, 0x43, 0xBC, 0x99, 0x29, 0x0D, 0xA3, 0x88, 0xA8, 0x08, +/* 3D50 */ 0xA2, 0x36, 0xBC, 0x85, 0x82, 0x1F, 0x42, 0x1B, 0x47, 0x8D, 0x1A, 0x22, 0x05, 0x7D, 0x0B, 0xA7, +/* 3D60 */ 0x36, 0xBE, 0xF0, 0x10, 0x11, 0x43, 0x06, 0x1E, 0x07, 0xCD, 0x51, 0xC0, 0x3D, 0x6E, 0x28, 0x29, +/* 3D70 */ 0x69, 0x8B, 0x6A, 0x4C, 0xAF, 0x6A, 0x03, 0x0D, 0x0F, 0x1B, 0x6C, 0x29, 0xEB, 0x01, 0xB0, 0xA1, +/* 3D80 */ 0x0B, 0x5A, 0x28, 0x7C, 0x8D, 0x29, 0x4C, 0xBE, 0xF0, 0x10, 0x11, 0x00, 0x38, 0x43, 0xBB, 0xB9, +/* 3D90 */ 0x47, 0x83, 0x9D, 0xA6, 0x0B, 0x97, 0x9E, 0x0F, 0x6F, 0x1F, 0x2D, 0x48, 0xE2, 0xAF, 0x0C, 0x85, +/* 3DA0 */ 0x0C, 0x1F, 0x29, 0x09, 0x0A, 0xB0, 0x07, 0x0D, 0x0F, 0x0A, 0x01, 0x28, 0x4B, 0xF0, 0x10, 0x11, +/* 3DB0 */ 0x78, 0x43, 0x1A, 0x53, 0x08, 0xAB, 0x37, 0x67, 0x28, 0x7C, 0x7E, 0x2D, 0x02, 0xB0, 0x60, 0x8A, +/* 3DC0 */ 0x08, 0x7E, 0x2E, 0x7C, 0x7E, 0x2D, 0x02, 0xAB, 0x1A, 0x53, 0x08, 0xAB, 0xA0, 0x67, 0x4C, 0x4B, +/* 3DD0 */ 0xF0, 0x10, 0x0F, 0xAB, 0x73, 0xBC, 0x07, 0xED, 0x36, 0x07, 0x2A, 0x87, 0xAC, 0xBE, 0xBC, 0x07, +/* 3DE0 */ 0xED, 0x10, 0x11, 0xAC, 0xDF, 0x7C, 0x02, 0x00, 0x38, 0x0A, 0x35, 0x21, 0x1D, 0x0D, 0x7B, 0xBC, +/* 3DF0 */ 0x8A, 0x36, 0x3F, 0x07, 0x27, 0x04, 0x1F, 0x4A, 0x69, 0x8E, 0x1F, 0x09, 0x48, 0x8F, 0x6C, 0x42, +/* 3E00 */ 0x30, 0x3A, 0x4C, 0x32, 0x6F, 0x06, 0x06, 0x1E, 0x96, 0x2E, 0x42, 0x03, 0x00, 0x07, 0x6F, 0x0E, +/* 3E10 */ 0x8A, 0x66, 0x0C, 0xB0, 0x0B, 0x0F, 0x09, 0x0A, 0x22, 0x2E, 0x0E, 0x31, 0xA1, 0x2C, 0x05, 0x42, +/* 3E20 */ 0x2E, 0x1E, 0x3A, 0x6D, 0x0F, 0x9A, 0x06, 0x70, 0xAC, 0x32, 0x44, 0x09, 0xB5, 0x4A, 0x20, 0xAC, +/* 3E30 */ 0x1E, 0x44, 0x0D, 0x44, 0x59, 0x02, 0x24, 0x0E, 0x31, 0x03, 0x0F, 0xA3, 0x00, 0x07, 0x70, 0x66, +/* 3E40 */ 0x0B, 0x07, 0x1B, 0xB0, 0x27, 0x0D, 0x2E, 0x42, 0x0C, 0x3A, 0x7C, 0x8F, 0x2E, 0x34, 0x48, 0xBA, +/* 3E50 */ 0x85, 0x03, 0x4C, 0x07, 0x41, 0x8F, 0x6C, 0x63, 0xB2, 0x6C, 0xA9, 0x48, 0x6F, 0x07, 0x4E, 0xA8, +/* 3E60 */ 0x22, 0xBA, 0x04, 0x36, 0x4A, 0x64, 0x24, 0x0A, 0x96, 0x49, 0x4A, 0x0B, 0x1B, 0x78, 0xA8, 0x03, +/* 3E70 */ 0x10, 0x11, 0x43, 0x05, 0x99, 0xBC, 0xB5, 0x02, 0x49, 0xAF, 0x0E, 0x07, 0xCD, 0x35, 0x03, 0x36, +/* 3E80 */ 0x7C, 0xA0, 0x54, 0x8C, 0xA8, 0x06, 0x0D, 0x1E, 0x03, 0x49, 0xBC, 0x0B, 0x09, 0xAC, 0x4B, 0xD3, +/* 3E90 */ 0xF8, 0xD8, 0xD7, 0x2F, 0x10, 0x11, 0xB0, 0x43, 0x7C, 0x03, 0x99, 0x4A, 0x9E, 0x49, 0x7C, 0x0B, +/* 3EA0 */ 0x18, 0xC0, 0x4A, 0x69, 0x1B, 0xC0, 0xB1, 0x0C, 0x06, 0x36, 0xAD, 0xA7, 0x7B, 0x7C, 0x0D, 0x5E, +/* 3EB0 */ 0x28, 0x4B, 0xD3, 0xF8, 0xD8, 0xD7, 0x2F, 0x10, 0x11, 0x43, 0x71, 0xEF, 0x49, 0x63, 0x84, 0xC0, +/* 3EC0 */ 0xB8, 0x89, 0x1F, 0x4A, 0x2C, 0x6F, 0x8B, 0x77, 0x28, 0x7C, 0x56, 0x02, 0x4A, 0x31, 0x1F, 0x07, +/* 3ED0 */ 0x3A, 0xAB, 0x29, 0xB4, 0x01, 0x1F, 0x29, 0x55, 0xA1, 0x02, 0x57, 0x4B, 0xD3, 0xF8, 0xD8, 0xD7, +/* 3EE0 */ 0x2F, 0x10, 0x11, 0x38, 0x43, 0xA0, 0xF2, 0x01, 0x0A, 0x9E, 0x03, 0x28, 0x4A, 0x1E, 0xA4, 0xAD, +/* 3EF0 */ 0x0D, 0x6C, 0x09, 0x58, 0x91, 0x70, 0x4C, 0x4A, 0x1E, 0xA4, 0xAD, 0x0D, 0x1F, 0xA0, 0xF2, 0x01, +/* 3F00 */ 0x0A, 0x9E, 0x03, 0x8C, 0x92, 0xD3, 0xF8, 0xD8, 0xD7, 0x2F, 0x10, 0x0F, 0x24, 0xBD, 0x1A, 0x99, +/* 3F10 */ 0x29, 0x0C, 0x82, 0xC8, 0x56, 0xC0, 0x29, 0x0C, 0x0F, 0x58, 0x36, 0x59, 0x6F, 0x5E, 0x1F, 0xBC, +/* 3F20 */ 0x22, 0x06, 0x7D, 0x0A, 0x0A, 0x04, 0x4B, 0xA8, 0x48, 0x55, 0x0A, 0x58, 0xC3, 0xDE, 0xC5, 0x10, +/* 3F30 */ 0x11, 0x3B, 0x01, 0x03, 0x04, 0x03, 0xF1, 0x00, 0x90, 0x2F, 0x6C, 0x79, 0x04, 0xAA, 0x0A, 0x01, +/* 3F40 */ 0x4C, 0x2D, 0x0C, 0x97, 0xA2, 0x4C, 0x2D, 0x48, 0x58, 0x2E, 0x2D, 0x1B, 0x05, 0xE5, 0x58, 0xE3, +/* 3F50 */ 0x0F, 0x5B, 0xA4, 0x2E, 0x2D, 0x69, 0x58, 0x4C, 0x79, 0x08, 0x1E, 0x6F, 0x05, 0x28, 0x79, 0x7C, +/* 3F60 */ 0x06, 0x07, 0x3C, 0x6C, 0x79, 0x25, 0xA6, 0x79, 0x49, 0x79, 0x45, 0x1A, 0x0F, 0x1B, 0x0C, 0x3E, +/* 3F70 */ 0x01, 0x02, 0x10, 0x0F, 0x49, 0x43, 0xBC, 0x53, 0x09, 0xB0, 0x4A, 0x0E, 0x0E, 0x06, 0x6C, 0x34, +/* 3F80 */ 0x18, 0x29, 0x97, 0x03, 0x4C, 0x29, 0x8F, 0x00, 0x42, 0xE2, 0x34, 0x18, 0x29, 0x97, 0x03, 0x4C, +/* 3F90 */ 0xBC, 0x53, 0x09, 0xAB, 0x37, 0x0E, 0x07, 0x49, 0x4B, 0xA8, 0x48, 0x55, 0x0A, 0x58, 0xC3, 0xDE, +/* 3FA0 */ 0xC5, 0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x2A, 0x00, 0x14, 0x10, 0xBD, 0x52, 0x4A, 0x2A, 0x2A, +/* 3FB0 */ 0x08, 0xAC, 0xAD, 0x30, 0xB2, 0xAC, 0xAD, 0x30, 0xB2, 0xAC, 0xAD, 0x30, 0xB2, 0x10, 0x0F, 0x57, +/* 3FC0 */ 0xBD, 0xE7, 0x29, 0x26, 0x26, 0x26, 0x2A, 0x06, 0x1A, 0x5B, 0xF5, 0x8D, 0x2D, 0x30, 0x8A, 0x24, +/* 3FD0 */ 0x2D, 0x30, 0x8A, 0x10, 0x17, 0x57, 0xBD, 0xE7, 0x29, 0x2A, 0x2A, 0x2A, 0x06, 0x88, 0x2D, 0x48, +/* 3FE0 */ 0x5B, 0x3A, 0x88, 0x2D, 0x48, 0x5B, 0x3A, 0x88, 0x2D, 0x48, 0x5B, 0x3A, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, +/* 3FF0 */ 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0A, 0xBB, 0x00, 0x00, 0x0A, 0xBD, 0x00, 0x00, 0x00, +/* 4000 */ 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x0A, 0xC0, 0x00, 0x00, 0x0B, 0x7E, 0x00, 0x00, 0x00, +/* 4010 */ 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x27, 0x70, 0x00, 0x00, 0x28, 0x30, 0x00, 0x00, 0x20, +/* 4020 */ 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x3F, 0xA2, 0x00, 0x00, 0x3F, 0xAA, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular.ttf b/contrib/mcufont/fonts/FiraSansCondensed-Regular.ttf new file mode 100644 index 000000000..7fd88fbf3 Binary files /dev/null and b/contrib/mcufont/fonts/FiraSansCondensed-Regular.ttf differ diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular10.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular10.mcufont.h new file mode 100644 index 000000000..a04063aab --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular10.mcufont.h @@ -0,0 +1,318 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 10 + * blob size: 4724, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x02, 0xAE, 0x00, 0x00, 0x03, 0x29, 0x00, 0x00, 0x00, 0x6F, +/* 0020 */ 0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x12, 0x34, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0A, 0x00, 0x0E, 0x00, 0x02, 0x00, 0x09, 0x00, 0x01, 0x00, 0x0B, 0x00, 0x0C, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x31, 0x30, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x31, 0x30, 0x00, +/* dictionary data */ +0x06, 0x0C, 0x03, 0x04, 0x08, +/* 0080 */ 0xC3, 0xCB, 0x0A, 0xCC, 0xCB, 0x07, 0x08, 0x05, 0xC2, 0xCC, 0x08, 0xC2, 0xCC, 0x08, 0x1F, 0x15, +/* 0090 */ 0x01, 0xC2, 0xCC, 0x05, 0x09, 0x01, 0xCB, 0xC3, 0x01, 0x05, 0xC5, 0xDC, 0x02, 0xC3, 0xCD, 0xC1, +/* 00A0 */ 0x80, 0x40, 0x07, 0xCD, 0xC2, 0x05, 0xC2, 0xCC, 0x01, 0x33, 0xC5, 0xEC, 0x10, 0xC3, 0x07, 0xD6, +/* 00B0 */ 0x20, 0xC4, 0xCA, 0xC2, 0xCB, 0x09, 0xCE, 0x09, 0xCE, 0xC5, 0xC8, 0x02, 0xCC, 0x11, 0xC3, 0xCA, +/* 00C0 */ 0xC2, 0x04, 0xC4, 0xCA, 0x02, 0xCC, 0xCB, 0xC1, 0xC3, 0x04, 0xC1, 0x06, 0xC5, 0xC7, 0x02, 0x10, +/* 00D0 */ 0x01, 0xC9, 0xC2, 0x07, 0xC1, 0xCB, 0xC8, 0xC5, 0x08, 0xC7, 0xC6, 0xC7, 0xC6, 0x07, 0x16, 0xC1, +/* 00E0 */ 0x05, 0x01, 0xCC, 0xCD, 0xC5, 0xC1, 0xCC, 0xD2, 0xC1, 0xC4, 0xCC, 0xC5, 0xCA, 0xC2, 0xC4, 0xCB, +/* 00F0 */ 0x01, 0x3D, 0xD7, 0x01, 0xC6, 0xC9, 0x1A, 0xCC, 0xC4, 0xCC, 0x07, 0xCD, 0xC4, 0xC7, 0xC8, 0xD8, +/* 0100 */ 0xCB, 0xC5, 0x06, 0xCB, 0xCE, 0xCC, 0xC2, 0xC6, 0xC1, 0xCA, 0xC1, 0xC9, 0xC9, 0x05, 0xCD, 0xC1, +/* 0110 */ 0xCB, 0xC2, 0xC5, 0xC9, 0xC5, 0xCB, 0xDB, 0xC2, 0x80, 0xC5, 0xC6, 0xCC, 0xC8, 0x01, 0xCA, 0x01, +/* 0120 */ 0xC8, 0xD4, 0xC2, 0xCE, 0xCC, 0xC3, 0xC9, 0xCC, 0xC7, 0xC4, 0xC9, 0xC2, 0xC8, 0xC7, 0xC6, 0xC6, +/* 0130 */ 0xC8, 0x01, 0xC7, 0xC6, 0x01, 0xC3, 0xCB, 0xCC, 0xCE, 0xC6, 0xC1, 0xC1, 0xC8, 0xC2, 0xCA, 0xC3, +/* 0140 */ 0xCC, 0xC3, 0xC7, 0xCC, 0xC2, 0xCC, 0xCD, 0x01, 0xC6, 0xCC, 0xC6, 0xC4, 0xCC, 0xCC, 0xCA, 0xCD, +/* 0150 */ 0xC9, 0x01, 0xC7, 0xC1, 0xCD, 0x1C, 0x1C, 0x22, 0x22, 0x78, 0x59, 0x61, 0x20, 0x61, 0x3B, 0x77, +/* 0160 */ 0x25, 0x77, 0x00, 0x37, 0x21, 0x7C, 0x80, 0x63, 0x2C, 0x0B, 0x7E, 0x21, 0x77, 0x1C, 0x20, 0x01, +/* 0170 */ 0x27, 0x04, 0x1B, 0x05, 0x0A, 0x2B, 0x66, 0x1B, 0x5B, 0x2B, 0x53, 0x1A, 0x5B, 0x2B, 0x53, 0x1A, +/* 0180 */ 0x66, 0x2B, 0x66, 0x1B, 0x86, 0x1F, 0x67, 0x09, 0x18, 0x43, 0x82, 0x21, 0x3A, 0x4E, 0x4B, 0x4E, +/* 0190 */ 0x00, 0x46, 0x29, 0x0E, 0x7F, 0x08, 0x1B, 0x43, 0x05, 0x25, 0x7E, 0x2B, 0x64, 0x21, 0x86, 0x18, +/* 01A0 */ 0x03, 0x20, 0x4E, 0x20, 0x0D, 0x4B, 0x61, 0x78, 0x4B, 0x5B, 0x4C, 0x4B, 0x08, 0x79, 0x0E, 0x02, +/* 01B0 */ 0x21, 0x2C, 0x0B, 0x46, 0x2F, 0x03, 0x64, 0x55, 0x1B, 0x77, 0x00, 0x75, 0x36, 0x09, 0x3F, 0x7B, +/* 01C0 */ 0x00, 0x83, 0x3F, 0x7B, 0x6D, 0x0D, 0x3F, 0x7B, 0x00, 0x69, 0x03, 0x1A, 0x21, 0x30, 0x1F, 0x22, +/* 01D0 */ 0x6F, 0x0A, 0x18, 0x22, 0x02, 0x83, 0x18, 0x72, 0x85, 0x05, 0x1B, 0x85, 0x0D, 0x0C, 0x81, 0x21, +/* 01E0 */ 0x55, 0x1F, 0x53, 0x44, 0x09, 0x1E, 0x27, 0x04, 0x29, 0x7F, 0x08, 0x36, 0x76, 0x1B, 0x36, 0x76, +/* 01F0 */ 0x1B, 0x36, 0x76, 0x2B, 0x1E, 0x4B, 0x53, 0x5B, 0x21, 0x55, 0x77, 0x21, 0x55, 0x77, 0x21, 0x53, +/* 0200 */ 0x55, 0x1B, 0x43, 0x0C, 0x46, 0x20, 0x46, 0x20, 0x46, 0x18, 0x33, 0x6C, 0x33, 0x6C, 0x33, 0x6C, +/* 0210 */ 0x28, 0x00, 0x04, 0x21, 0x85, 0x03, 0x08, 0x03, 0x08, 0x1B, 0x61, 0x6C, 0x78, 0x01, 0x2B, 0x80, +/* 0220 */ 0x04, 0x2B, 0x04, 0x08, 0x20, 0x69, 0x03, 0x43, 0x3F, 0x02, 0x0D, 0x26, 0x0D, 0x26, 0x0D, 0x26, +/* 0230 */ 0x20, 0x72, 0x1F, 0x82, 0x44, 0x02, 0x01, 0x43, 0x05, 0x18, 0x64, 0x59, 0x08, 0x09, 0x08, 0x1F, +/* 0240 */ 0x69, 0x02, 0x20, 0x0E, 0x38, 0x1A, 0x20, 0x5B, 0x0C, 0x09, 0x00, 0x21, 0x77, 0x00, 0x75, 0x21, +/* 0250 */ 0x77, 0x00, 0x75, 0x21, 0x77, 0x80, 0x00, 0x39, 0x21, 0x23, 0x6F, 0x0C, 0x03, 0x21, 0x30, 0x0B, +/* 0260 */ 0x04, 0x84, 0x43, 0x3F, 0x7B, 0x0D, 0x43, 0x3F, 0x7B, 0x09, 0x72, 0x3F, 0x7B, 0x2B, 0x36, 0x76, +/* 0270 */ 0x1B, 0x3C, 0x43, 0x06, 0x5E, 0x0A, 0x0A, 0x1B, 0x77, 0x1B, 0x70, 0x7E, 0x6C, 0x04, 0x21, 0x46, +/* 0280 */ 0x00, 0x0D, 0x18, 0x72, 0x37, 0x1F, 0x51, 0x07, 0x00, 0x5E, 0x0A, 0x33, 0x07, 0x0D, 0x0C, 0x03, +/* 0290 */ 0x18, 0x02, 0x41, 0x09, 0x01, 0x1B, 0x7D, 0x00, 0x73, 0x21, 0x7D, 0x6D, 0x02, 0x2A, 0x09, 0x00, +/* 02A0 */ 0x20, 0x48, 0x20, 0x0D, 0x1A, 0x77, 0x43, 0x05, 0x00, 0x01, 0x03, 0x1C, 0x1C, 0x20, 0x03, 0x83, +/* 02B0 */ 0x2F, 0x2C, 0x00, 0x01, 0x0E, 0x21, 0x30, 0x67, 0x21, 0x6F, 0x52, 0x21, 0x3F, 0x30, 0x27, 0x3F, +/* 02C0 */ 0x30, 0x27, 0x18, 0x02, 0x02, 0x07, 0x77, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x20, 0x30, 0x1F, 0x55, +/* 02D0 */ 0x1F, 0x55, 0x1F, 0x53, 0x40, 0x43, 0x00, 0x31, 0x61, 0x2B, 0x29, 0x35, 0x04, 0x2A, 0x20, 0x39, +/* 02E0 */ 0x01, 0x44, 0x31, 0x6D, 0x83, 0x18, 0x53, 0x05, 0x63, 0x20, 0x36, 0x21, 0x30, 0x18, 0x01, 0x77, +/* 02F0 */ 0x00, 0x5B, 0x21, 0x48, 0x01, 0x20, 0x18, 0x43, 0x43, 0x04, 0x21, 0x23, 0x45, 0x07, 0x2B, 0x4F, +/* 0300 */ 0x1A, 0x1B, 0x30, 0x01, 0x1F, 0x18, 0x02, 0x0C, 0x2D, 0x05, 0x0D, 0x20, 0x1B, 0x86, 0x00, 0x6C, +/* 0310 */ 0x04, 0x1B, 0x86, 0x1F, 0x74, 0x47, 0x49, 0x76, 0x1F, 0x00, 0x02, 0x3D, 0x3D, 0x3D, 0x3D, 0x02, +/* 0320 */ 0x1B, 0x86, 0x00, 0x86, 0x21, 0x80, 0x0C, 0x51, 0x21, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, +/* 0330 */ 0x03, 0x00, 0x04, 0x00, 0x07, 0x00, 0x08, 0x00, 0x0A, 0x00, 0x0B, 0x00, 0x0C, 0x00, 0x0D, 0x00, +/* 0340 */ 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x19, 0x00, 0x1A, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x20, 0x00, +/* 0350 */ 0x21, 0x00, 0x22, 0x00, 0x24, 0x00, 0x26, 0x00, 0x28, 0x00, 0x2B, 0x00, 0x2E, 0x00, 0x2F, 0x00, +/* 0360 */ 0x32, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3E, 0x00, 0x40, 0x00, +/* 0370 */ 0x42, 0x00, 0x43, 0x00, 0x45, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x54, 0x00, +/* 0380 */ 0x55, 0x00, 0x57, 0x00, 0x59, 0x00, 0x5B, 0x00, 0x5D, 0x00, 0x5F, 0x00, 0x61, 0x00, 0x63, 0x00, +/* 0390 */ 0x64, 0x00, 0x66, 0x00, 0x68, 0x00, 0x6A, 0x00, 0x6C, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, +/* 03A0 */ 0x73, 0x00, 0x76, 0x00, 0x77, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x7C, 0x00, 0x7E, 0x00, 0x80, 0x00, +/* 03B0 */ 0x82, 0x00, 0x84, 0x00, 0x85, 0x00, 0x87, 0x00, 0x89, 0x00, 0x8B, 0x00, 0x8D, 0x00, 0x8F, 0x00, +/* 03C0 */ 0x91, 0x00, 0x93, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9C, 0x00, 0x9E, 0x00, +/* 03D0 */ 0xA0, 0x00, 0xA2, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA7, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, +/* 03E0 */ 0xB0, 0x00, 0xB2, 0x00, 0xB4, 0x00, 0xB6, 0x00, 0xBA, 0x00, 0xBC, 0x00, 0xBE, 0x00, 0xC0, 0x00, +/* 03F0 */ 0xC2, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00, 0xCA, 0x00, 0xCC, 0x00, 0xCE, 0x00, 0xD0, 0x00, +/* 0400 */ 0xD2, 0x00, 0xD4, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xDE, 0x00, 0xE4, 0x00, +/* 0410 */ 0xF4, 0x01, 0x0A, 0x01, 0x22, 0x01, 0x24, 0x01, 0x26, 0x01, 0x28, 0x01, 0x39, 0x01, 0x41, 0x01, +/* 0420 */ 0x51, 0x01, 0x5A, 0x01, 0x6B, 0x01, 0x70, 0x01, 0x79, 0x01, 0x89, 0x01, 0x8F, 0x01, 0x96, 0x01, +/* 0430 */ 0x98, 0x01, 0xA7, 0x01, 0xAA, 0x01, 0xAF, 0x01, 0xB5, 0x01, 0xBC, 0x01, 0xCB, 0x01, 0xCD, 0x01, +/* 0440 */ 0xD0, 0x01, 0xDB, 0x01, 0xDE, 0x01, 0xE4, 0x01, 0xE6, 0x01, 0xF2, 0x01, 0xFC, 0x01, 0xFE, 0x02, +/* 0450 */ 0x00, 0x02, 0x13, 0x02, 0x16, 0x02, 0x21, 0x02, 0x25, 0x02, 0x28, 0x02, 0x2E, 0x02, 0x38, 0x02, +/* 0460 */ 0x41, 0x02, 0x47, 0x02, 0x49, 0x02, 0x4B, 0x02, 0x51, 0x02, 0x54, 0x02, 0x5B, 0x02, 0x60, 0x02, +/* 0470 */ 0x63, 0x02, 0x65, 0x02, 0x67, 0x02, 0x6C, 0x02, 0x6E, 0x02, 0x70, 0x02, 0x72, 0x02, 0x74, 0x02, +/* 0480 */ 0x79, 0x02, 0x7B, 0x02, 0x7D, 0x02, 0x80, 0x02, 0x86, 0x02, 0x88, 0x02, 0x8A, 0x02, 0x8D, 0x02, +/* 0490 */ 0x8F, 0x02, 0x91, 0x02, 0x98, 0x02, 0x9E, 0x02, 0xA0, 0x02, 0xAE, +/* char range info */ +0x00, 0x00, 0x02, 0x00, 0x10, +/* 04A0 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x12, 0x00, 0x20, 0x00, 0x3E, 0x00, 0x64, 0x00, 0x8C, 0x00, 0xAE, +/* 04B0 */ 0x00, 0xB7, 0x00, 0xCC, 0x00, 0xDF, 0x00, 0xEF, 0x00, 0xF3, 0x00, 0xFC, 0x01, 0x02, 0x01, 0x08, +/* 04C0 */ 0x01, 0x1E, 0x01, 0x34, 0x01, 0x42, 0x01, 0x57, 0x01, 0x6D, 0x01, 0x83, 0x01, 0x9C, 0x01, 0xB5, +/* 04D0 */ 0x01, 0xC8, 0x01, 0xE2, 0x01, 0xFF, 0x02, 0x06, 0x02, 0x10, 0x02, 0x22, 0x02, 0x27, 0x02, 0x38, +/* 04E0 */ 0x02, 0x4C, 0x02, 0x80, 0x02, 0x85, 0x02, 0x9C, 0x02, 0xB1, 0x02, 0xC6, 0x02, 0xCE, 0x02, 0xDB, +/* 04F0 */ 0x02, 0xF6, 0x03, 0x02, 0x03, 0x07, 0x03, 0x10, 0x03, 0x28, 0x03, 0x33, 0x03, 0x61, 0x03, 0x67, +/* 0500 */ 0x03, 0x6F, 0x03, 0x77, 0x03, 0x86, 0x03, 0x9A, 0x03, 0xB5, 0x03, 0xBF, 0x03, 0xC6, 0x03, 0xE3, +/* 0510 */ 0x04, 0x11, 0x04, 0x2D, 0x04, 0x36, 0x04, 0x4E, 0x04, 0x5B, 0x04, 0x70, 0x04, 0x7D, 0x04, 0x8A, +/* 0520 */ 0x04, 0x92, 0x04, 0x99, 0x04, 0x9E, 0x04, 0xAF, 0x04, 0xB5, 0x04, 0xCD, 0x04, 0xD3, 0x04, 0xE3, +/* 0530 */ 0x05, 0x04, 0x05, 0x0F, 0x05, 0x16, 0x05, 0x24, 0x05, 0x39, 0x05, 0x48, 0x05, 0x59, 0x05, 0x61, +/* 0540 */ 0x05, 0x67, 0x05, 0x71, 0x05, 0x88, 0x05, 0x93, 0x05, 0xAA, 0x05, 0xB7, 0x05, 0xBD, 0x05, 0xD2, +/* 0550 */ 0x05, 0xF5, 0x06, 0x09, 0x06, 0x0E, 0x06, 0x1F, 0x06, 0x37, 0x06, 0x43, 0x06, 0x57, 0x02, 0x00, +/* 0560 */ 0x10, 0x02, 0x23, 0x66, 0x20, 0x66, 0x20, 0x72, 0x20, 0x9C, 0x9C, 0x2B, 0x3B, 0x9A, 0x07, 0x10, +/* 0570 */ 0x04, 0x23, 0x34, 0x0A, 0x28, 0x29, 0x56, 0x02, 0x21, 0x9A, 0x05, 0x07, 0x01, 0x10, 0x05, 0x23, +/* 0580 */ 0x6C, 0x62, 0x02, 0x5E, 0x6C, 0x4B, 0x06, 0x0E, 0x78, 0x07, 0x5E, 0x27, 0xB4, 0x09, 0x27, 0x5E, +/* 0590 */ 0x0D, 0x78, 0x03, 0x21, 0x6A, 0x04, 0x07, 0x21, 0x85, 0x04, 0x6A, 0x10, 0x05, 0x1F, 0xB4, 0x1A, +/* 05A0 */ 0x5E, 0x47, 0x0E, 0x06, 0x18, 0x56, 0x01, 0x06, 0x4B, 0x55, 0x00, 0xB4, 0x84, 0x44, 0x01, 0x07, +/* 05B0 */ 0x0D, 0x44, 0x6D, 0x06, 0x1B, 0x9A, 0x01, 0x6C, 0x05, 0x1B, 0x9A, 0x7F, 0x0A, 0x2B, 0x5E, 0x1B, +/* 05C0 */ 0x29, 0x10, 0x07, 0x57, 0x01, 0x1A, 0xCE, 0x1E, 0x00, 0x27, 0x1A, 0x6D, 0x7D, 0x04, 0x34, 0x1A, +/* 05D0 */ 0x85, 0x04, 0x08, 0x53, 0x1B, 0x37, 0x0A, 0x06, 0x05, 0x20, 0x5D, 0x71, 0x1B, 0x85, 0x67, 0x27, +/* 05E0 */ 0x1B, 0x45, 0x27, 0x27, 0x1A, 0x80, 0x04, 0x80, 0x6B, 0x10, 0x07, 0x23, 0x80, 0x1E, 0x40, 0x64, +/* 05F0 */ 0x74, 0x18, 0x65, 0x09, 0x04, 0x21, 0x9A, 0x84, 0x00, 0x4B, 0x0B, 0x09, 0x0A, 0x4C, 0xA9, 0x85, +/* 0600 */ 0x0B, 0x09, 0xC7, 0x01, 0x0E, 0x08, 0x1B, 0x6D, 0x0C, 0x58, 0x65, 0x10, 0x02, 0x23, 0x34, 0x1A, +/* 0610 */ 0x29, 0x49, 0x9A, 0x05, 0x10, 0x03, 0x4A, 0xBC, 0x6D, 0x04, 0x1F, 0x4E, 0xAF, 0x46, 0x1F, 0xC5, +/* 0620 */ 0x1A, 0x46, 0xAF, 0x4E, 0x20, 0x6D, 0x04, 0x20, 0xBC, 0x10, 0x03, 0x24, 0x3F, 0x29, 0x07, 0x1F, +/* 0630 */ 0x3A, 0xC3, 0x46, 0xAF, 0x39, 0xAF, 0x46, 0x18, 0x3A, 0xC8, 0x41, 0x8E, 0x10, 0x04, 0x35, 0x6A, +/* 0640 */ 0x18, 0x85, 0x09, 0x09, 0x08, 0x18, 0x61, 0x3E, 0xB4, 0x09, 0x08, 0x03, 0x10, 0x05, 0xB9, 0x89, +/* 0650 */ 0x10, 0x02, 0x1B, 0x57, 0x2E, 0x75, 0xAF, 0x08, 0x01, 0x10, 0x04, 0x2E, 0x05, 0x0C, 0x7E, 0x10, +/* 0660 */ 0x02, 0x1B, 0x57, 0x2E, 0x6A, 0x10, 0x05, 0x00, 0x35, 0x7B, 0x20, 0x41, 0x21, 0x43, 0x33, 0x4C, +/* 0670 */ 0x20, 0x45, 0x20, 0x41, 0x21, 0x6D, 0x04, 0x20, 0x3E, 0x2B, 0x5E, 0x10, 0x05, 0x23, 0x85, 0x83, +/* 0680 */ 0x18, 0x4E, 0xC5, 0x66, 0xA4, 0x75, 0x9A, 0x63, 0x48, 0x9A, 0x63, 0x39, 0xA4, 0x4E, 0xC5, 0x85, +/* 0690 */ 0x83, 0x10, 0x04, 0x23, 0x85, 0x0E, 0x18, 0x85, 0x0A, 0x0E, 0x00, 0xC1, 0x00, 0x9E, 0x9E, 0x10, +/* 06A0 */ 0x04, 0x23, 0x04, 0x7F, 0x28, 0x29, 0x01, 0x77, 0xB7, 0x66, 0x18, 0x3A, 0x44, 0x5B, 0x1A, 0xA9, +/* 06B0 */ 0x1F, 0x6C, 0x0D, 0x1E, 0x10, 0x05, 0x23, 0x82, 0x58, 0xB4, 0x25, 0x1A, 0x3C, 0x18, 0x80, 0x0E, +/* 06C0 */ 0x3F, 0xC7, 0x20, 0x0D, 0x00, 0x29, 0x25, 0x80, 0x2A, 0x03, 0x10, 0x05, 0x35, 0x62, 0x20, 0x75, +/* 06D0 */ 0x2B, 0x5E, 0x44, 0x4E, 0x4C, 0x18, 0x48, 0x4C, 0x21, 0x43, 0x0C, 0x78, 0x07, 0x1F, 0x4E, 0x8F, +/* 06E0 */ 0x10, 0x05, 0x57, 0x29, 0x0D, 0x1E, 0x18, 0x39, 0xBB, 0x1A, 0x29, 0x0C, 0x81, 0xC1, 0x01, 0x86, +/* 06F0 */ 0xC3, 0x65, 0x21, 0x03, 0x01, 0x86, 0x4B, 0x82, 0x51, 0x10, 0x05, 0xBA, 0x1F, 0x0D, 0xC8, 0x36, +/* 0700 */ 0x20, 0x56, 0x68, 0x4B, 0x06, 0x0B, 0x6D, 0x06, 0x21, 0x39, 0xA4, 0x37, 0x00, 0x46, 0x21, 0x85, +/* 0710 */ 0x0C, 0x3E, 0x10, 0x04, 0x23, 0x09, 0x0C, 0x2A, 0xBB, 0x1F, 0x6C, 0x33, 0x4E, 0x20, 0x75, 0x2B, +/* 0720 */ 0x5E, 0x33, 0x4E, 0x20, 0x50, 0x10, 0x05, 0x23, 0x43, 0x83, 0x18, 0x72, 0xC5, 0x36, 0xC5, 0x27, +/* 0730 */ 0x0A, 0x0A, 0x2B, 0xA9, 0x82, 0x3F, 0x6D, 0x06, 0xA4, 0x55, 0x55, 0x1B, 0x45, 0x0C, 0x3E, 0x10, +/* 0740 */ 0x05, 0x23, 0x45, 0x6B, 0x18, 0x48, 0x00, 0x7E, 0x21, 0x46, 0x43, 0x05, 0x21, 0x75, 0x00, 0x51, +/* 0750 */ 0x21, 0x6C, 0x0B, 0x58, 0x2B, 0x8D, 0x00, 0x8E, 0x51, 0x18, 0x61, 0x03, 0x10, 0x02, 0x54, 0x6A, +/* 0760 */ 0x18, 0x35, 0x6A, 0x10, 0x02, 0x54, 0x6A, 0x18, 0x35, 0x75, 0xAF, 0x08, 0x01, 0x10, 0x05, 0x1A, +/* 0770 */ 0x31, 0x33, 0x04, 0x0B, 0x08, 0x21, 0x85, 0x0A, 0x40, 0xCE, 0x09, 0x0A, 0x33, 0xCE, 0x09, 0x10, +/* 0780 */ 0x05, 0x54, 0x32, 0x32, 0x10, 0x05, 0x31, 0x02, 0x01, 0x1C, 0x08, 0xC8, 0x9A, 0x0D, 0x4B, 0x80, +/* 0790 */ 0x0B, 0x06, 0x21, 0x9A, 0x06, 0x10, 0x04, 0x23, 0x7C, 0x4D, 0x21, 0x9A, 0x4F, 0xCB, 0x7C, 0x00, +/* 07A0 */ 0xC1, 0x5A, 0x1F, 0x5B, 0x47, 0x04, 0x3B, 0x80, 0x04, 0x10, 0x09, 0x1A, 0x4A, 0x1C, 0x0C, 0x6B, +/* 07B0 */ 0xA9, 0x02, 0x00, 0x80, 0x0A, 0x1A, 0x7E, 0x04, 0x1E, 0x61, 0x28, 0x37, 0x4C, 0x62, 0x03, 0x48, +/* 07C0 */ 0x9A, 0x08, 0x7B, 0x43, 0x03, 0x72, 0x00, 0x39, 0x3C, 0x43, 0x03, 0x39, 0x00, 0x3C, 0x4E, 0x00, +/* 07D0 */ 0xA6, 0x46, 0x3A, 0x7A, 0x51, 0x83, 0x1A, 0x67, 0xC8, 0x9A, 0x0B, 0x0C, 0x71, 0x10, 0x05, 0x35, +/* 07E0 */ 0xCA, 0x8C, 0x10, 0x05, 0xA5, 0x53, 0xC7, 0x05, 0x0A, 0x21, 0x6F, 0x0E, 0x03, 0xC0, 0x2C, 0xC0, +/* 07F0 */ 0x00, 0x0E, 0x01, 0xC7, 0x02, 0x0E, 0x21, 0x6F, 0x58, 0x10, 0x05, 0xBA, 0x07, 0x8D, 0x02, 0xCE, +/* 0800 */ 0x29, 0x0A, 0xA1, 0xA1, 0x1A, 0x29, 0x0A, 0x1A, 0x8D, 0x02, 0xCE, 0x18, 0x82, 0x71, 0x10, 0x06, +/* 0810 */ 0xA5, 0x2C, 0xC0, 0x00, 0x7E, 0xC7, 0x6C, 0x04, 0xC7, 0x6C, 0x04, 0xC7, 0x00, 0x7E, 0xC7, 0x82, +/* 0820 */ 0x21, 0x6F, 0x65, 0x10, 0x05, 0x23, 0x6F, 0x7E, 0x93, 0x5F, 0xAC, 0x10, 0x04, 0x23, 0x6F, 0x7E, +/* 0830 */ 0xC0, 0x1F, 0x22, 0x6F, 0x09, 0x18, 0x22, 0x30, 0x10, 0x06, 0xBA, 0x09, 0x8D, 0x02, 0x9A, 0x29, +/* 0840 */ 0x0A, 0xA1, 0xA1, 0x6C, 0x0D, 0x02, 0x1B, 0x66, 0x00, 0x27, 0x3F, 0x01, 0x64, 0x27, 0x03, 0x21, +/* 0850 */ 0x82, 0x83, 0x01, 0x10, 0x06, 0x57, 0xC0, 0x27, 0xB3, 0x3F, 0x6F, 0x78, 0xB3, 0xB3, 0x03, 0x10, +/* 0860 */ 0x03, 0x23, 0x88, 0x88, 0x10, 0x03, 0x35, 0x0E, 0x38, 0x38, 0x38, 0xB7, 0xA6, 0x10, 0x05, 0x57, +/* 0870 */ 0xC0, 0x7C, 0xC0, 0x0B, 0x3F, 0xCE, 0x0C, 0x75, 0xB4, 0x0D, 0x64, 0xC9, 0x5D, 0xC9, 0x2C, 0xC9, +/* 0880 */ 0x43, 0x07, 0xC0, 0x01, 0x64, 0x10, 0x04, 0x00, 0x4A, 0xB7, 0x22, 0x88, 0x69, 0x0D, 0x0D, 0x03, +/* 0890 */ 0x10, 0x07, 0x35, 0x0E, 0x06, 0x00, 0x05, 0x0F, 0x01, 0x1B, 0x84, 0x6D, 0x0D, 0x02, 0x1A, 0x01, +/* 08A0 */ 0x68, 0x6C, 0x0A, 0x03, 0x1A, 0x7B, 0x0A, 0x45, 0x09, 0x04, 0x1A, 0x70, 0x07, 0x75, 0x46, 0x1A, +/* 08B0 */ 0x72, 0x04, 0x51, 0x74, 0x1A, 0x39, 0x2D, 0x02, 0x48, 0x1A, 0x48, 0x00, 0x01, 0xA4, 0x10, 0x06, +/* 08C0 */ 0x23, 0x9D, 0xA7, 0x92, 0x10, 0x06, 0xBA, 0x08, 0x8D, 0x8B, 0x01, 0x95, 0x10, 0x05, 0xA5, 0x82, +/* 08D0 */ 0xC0, 0xB2, 0x22, 0x30, 0x10, 0x06, 0xBA, 0x08, 0x8D, 0x8B, 0x01, 0x00, 0xA6, 0x29, 0x7F, 0x65, +/* 08E0 */ 0x00, 0xC1, 0x67, 0x10, 0x05, 0xA5, 0x53, 0xC7, 0x86, 0xC0, 0x67, 0x21, 0x6F, 0x2F, 0x02, 0x0C, +/* 08F0 */ 0x01, 0x64, 0xC0, 0x5B, 0xC0, 0x01, 0x64, 0x10, 0x05, 0x23, 0x61, 0x83, 0x4B, 0x75, 0x00, 0x03, +/* 0900 */ 0x4B, 0x07, 0x09, 0x8F, 0x58, 0x1A, 0x29, 0x0E, 0x04, 0xA1, 0x1B, 0x9A, 0x01, 0x43, 0x06, 0x21, +/* 0910 */ 0x82, 0x83, 0x10, 0x05, 0x23, 0x0A, 0x78, 0x81, 0x18, 0x22, 0x88, 0x30, 0x10, 0x06, 0x23, 0x36, +/* 0920 */ 0x3A, 0x3D, 0xCF, 0x10, 0x05, 0x23, 0x7E, 0x00, 0x86, 0x1B, 0x43, 0x05, 0x00, 0x36, 0x21, 0x66, +/* 0930 */ 0x76, 0x1B, 0x4E, 0x6C, 0x03, 0x18, 0x0D, 0x4E, 0xC4, 0x67, 0x18, 0x80, 0x71, 0x1F, 0x69, 0x03, +/* 0940 */ 0x10, 0x07, 0x23, 0x0A, 0x28, 0x4D, 0x6C, 0x03, 0x2B, 0x46, 0x00, 0x0D, 0x07, 0x4C, 0x01, 0x2B, +/* 0950 */ 0x48, 0x70, 0x0A, 0x00, 0x0D, 0x1A, 0x72, 0x05, 0x67, 0x45, 0x1A, 0x45, 0x07, 0x3C, 0x72, 0x1B, +/* 0960 */ 0x83, 0x01, 0x5C, 0x06, 0x1B, 0x1E, 0x80, 0x58, 0x1A, 0x6C, 0x0B, 0x9A, 0x0F, 0x02, 0x10, 0x05, +/* 0970 */ 0x23, 0x09, 0x06, 0x6D, 0x06, 0xC0, 0x59, 0x0A, 0x08, 0x07, 0x18, 0x9A, 0x0F, 0x40, 0x85, 0x4D, +/* 0980 */ 0x21, 0x3A, 0x77, 0x18, 0x66, 0x27, 0x3F, 0x27, 0x28, 0x66, 0x10, 0x05, 0x23, 0x0B, 0x28, 0x77, +/* 0990 */ 0x21, 0x66, 0xA0, 0x10, 0x05, 0x57, 0x29, 0x0C, 0x78, 0x05, 0x2B, 0x8D, 0xC8, 0x5B, 0x20, 0x0D, +/* 09A0 */ 0xC8, 0x56, 0x20, 0x0D, 0x44, 0x56, 0x2B, 0x5E, 0x0D, 0x0C, 0x58, 0x10, 0x03, 0x1D, 0x80, 0x51, +/* 09B0 */ 0xCD, 0x74, 0x47, 0x49, 0x76, 0xCD, 0x06, 0x51, 0x10, 0x05, 0x57, 0x5E, 0x1A, 0x5E, 0xC8, 0x6D, +/* 09C0 */ 0x04, 0x20, 0x9C, 0x45, 0x1F, 0x3A, 0x2B, 0xC4, 0x03, 0x20, 0x41, 0x18, 0x7B, 0x10, 0x03, 0x1A, +/* 09D0 */ 0x47, 0x5A, 0x20, 0x98, 0x2B, 0x98, 0x2B, 0x98, 0x85, 0x5A, 0x10, 0x05, 0x18, 0xC1, 0x07, 0x47, +/* 09E0 */ 0x4D, 0x1F, 0x7E, 0x0C, 0x18, 0x75, 0xC5, 0x10, 0x05, 0x3B, 0x35, 0x2E, 0x6C, 0x2A, 0x81, 0x10, +/* 09F0 */ 0x03, 0x00, 0x4A, 0xAF, 0x9A, 0x03, 0x10, 0x05, 0x31, 0xAE, 0x90, 0x10, 0x05, 0x24, 0xB1, 0xBE, +/* 0A00 */ 0x77, 0x25, 0x77, 0x00, 0x37, 0x21, 0x7C, 0x80, 0x63, 0x03, 0x1E, 0x7E, 0x10, 0x04, 0xBD, 0x40, +/* 0A10 */ 0xB8, 0x83, 0x10, 0x05, 0x2B, 0x4A, 0x4F, 0xBB, 0x1F, 0xA4, 0x43, 0x1E, 0x08, 0x21, 0xC2, 0xA4, +/* 0A20 */ 0x07, 0x07, 0xA4, 0x53, 0x5B, 0x21, 0x6C, 0x0C, 0x09, 0x08, 0x10, 0x05, 0x31, 0x43, 0x94, 0x02, +/* 0A30 */ 0x10, 0x03, 0x23, 0x6C, 0x81, 0xC1, 0xCB, 0x0B, 0x0E, 0x0B, 0x1F, 0x4E, 0x8F, 0x8F, 0x8F, 0x8F, +/* 0A40 */ 0x10, 0x05, 0x18, 0x35, 0xB4, 0x03, 0x21, 0x37, 0x0D, 0x51, 0x1B, 0x6D, 0x06, 0x4C, 0x4B, 0x55, +/* 0A50 */ 0x7E, 0x8D, 0x71, 0x18, 0x9C, 0x02, 0x0D, 0x83, 0x01, 0x29, 0x01, 0x6D, 0x07, 0x1B, 0x80, 0x2A, +/* 0A60 */ 0x65, 0x10, 0x05, 0x24, 0x01, 0x03, 0x1C, 0x87, 0x0A, 0x91, 0xA3, 0x08, 0x10, 0x03, 0x23, 0x73, +/* 0A70 */ 0x00, 0x3B, 0xB6, 0x10, 0x03, 0x23, 0x73, 0x1D, 0x1C, 0x87, 0x87, 0x20, 0x3C, 0x20, 0x66, 0x20, +/* 0A80 */ 0x7E, 0x10, 0x05, 0x24, 0x50, 0x1C, 0x87, 0x27, 0x28, 0xA9, 0x48, 0x8E, 0x2A, 0x1A, 0xA9, 0xAC, +/* 0A90 */ 0x77, 0x77, 0x2B, 0xA9, 0x6C, 0x05, 0x10, 0x03, 0x24, 0x50, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, +/* 0AA0 */ 0x20, 0x3C, 0x2B, 0xC1, 0x5A, 0x10, 0x08, 0x31, 0x77, 0x0A, 0x81, 0x6B, 0x1A, 0x2C, 0x62, 0x08, +/* 0AB0 */ 0x00, 0xB0, 0xB0, 0xB0, 0xB0, 0x0D, 0x10, 0x05, 0x31, 0x3C, 0x0A, 0x91, 0xA3, 0x08, 0x10, 0x05, +/* 0AC0 */ 0x31, 0x43, 0x97, 0x3E, 0x10, 0x05, 0x31, 0x77, 0x0A, 0x2F, 0x2C, 0x00, 0xBE, 0x8A, 0xBC, 0x05, +/* 0AD0 */ 0x31, 0x43, 0x83, 0x08, 0x21, 0xC2, 0xA4, 0x07, 0x07, 0xA4, 0x53, 0x5C, 0x21, 0x6C, 0x83, 0x08, +/* 0AE0 */ 0xBB, 0xBB, 0x2B, 0xC1, 0x02, 0x10, 0x03, 0x31, 0x3C, 0xA6, 0x8E, 0x0E, 0xC8, 0x77, 0x1C, 0x87, +/* 0AF0 */ 0x10, 0x04, 0x31, 0x02, 0x0C, 0x81, 0x21, 0x6D, 0x07, 0x00, 0x01, 0x8E, 0x81, 0x20, 0x7A, 0x0A, +/* 0B00 */ 0xB4, 0x00, 0x86, 0x00, 0x29, 0x7F, 0x06, 0x10, 0x03, 0x23, 0x01, 0x05, 0xB7, 0x0B, 0x0E, 0x0A, +/* 0B10 */ 0x1F, 0x88, 0x27, 0x7E, 0x10, 0x05, 0x31, 0x96, 0xA8, 0x06, 0x10, 0x04, 0x31, 0x7E, 0x6C, 0x3F, +/* 0B20 */ 0x6D, 0x06, 0x00, 0x0D, 0x18, 0x72, 0x37, 0x21, 0x3A, 0x48, 0x1F, 0x68, 0x33, 0x06, 0x0E, 0x10, +/* 0B30 */ 0x07, 0x31, 0x65, 0x04, 0x0D, 0x43, 0x04, 0x1A, 0x46, 0x07, 0x0C, 0x01, 0x3E, 0x1A, 0x05, 0x07, +/* 0B40 */ 0x09, 0x07, 0x7C, 0xAA, 0x0A, 0x04, 0x06, 0x0B, 0x1B, 0x27, 0x0A, 0x37, 0x08, 0x21, 0x6B, 0x00, +/* 0B50 */ 0x0E, 0x06, 0x10, 0x04, 0x31, 0x08, 0x06, 0x4E, 0xC1, 0x71, 0x05, 0x18, 0x6D, 0xCB, 0x0A, 0x7E, +/* 0B60 */ 0x18, 0x3C, 0xBE, 0x6C, 0x28, 0x2F, 0x10, 0x04, 0x31, 0xAB, 0x9F, 0x10, 0x04, 0x31, 0x07, 0x7F, +/* 0B70 */ 0x0A, 0x20, 0xA6, 0x1F, 0x36, 0x18, 0x3A, 0x44, 0x66, 0x20, 0x7F, 0x6B, 0x10, 0x03, 0x24, 0x43, +/* 0B80 */ 0x49, 0x4E, 0x20, 0x45, 0x20, 0x45, 0x20, 0x37, 0x20, 0x5D, 0x20, 0x37, 0x20, 0x45, 0x20, 0x45, +/* 0B90 */ 0x8F, 0x2B, 0xC4, 0x06, 0x10, 0x04, 0x24, 0x6C, 0x99, 0x18, 0x6C, 0x33, 0x6C, 0x33, 0x6C, 0x99, +/* 0BA0 */ 0x10, 0x03, 0x24, 0x5B, 0x26, 0xCB, 0x4C, 0x26, 0x59, 0x3A, 0xC3, 0x56, 0x18, 0x3A, 0xC3, 0x59, +/* 0BB0 */ 0x3A, 0x26, 0x0D, 0xA1, 0x10, 0x04, 0x54, 0x7C, 0x34, 0x00, 0x29, 0x61, 0x08, 0x10, 0x00, 0x00, +/* 0BC0 */ 0x00, 0x03, 0x00, 0x13, 0x00, 0x2A, 0x00, 0x41, 0x00, 0x60, 0x00, 0x7A, 0x00, 0x82, 0x00, 0x9F, +/* 0BD0 */ 0x00, 0xA5, 0x00, 0xC8, 0x00, 0xDA, 0x00, 0xF3, 0x00, 0xFD, 0x01, 0x03, 0x01, 0x20, 0x01, 0x25, +/* 0BE0 */ 0x01, 0x38, 0x01, 0x3D, 0x01, 0x4E, 0x01, 0x5D, 0x01, 0x65, 0x01, 0x7B, 0x01, 0xA1, 0x01, 0xA7, +/* 0BF0 */ 0x01, 0xB2, 0x01, 0xC0, 0x01, 0xD4, 0x01, 0xEB, 0x01, 0xF8, 0x02, 0x14, 0x02, 0x33, 0x02, 0x4A, +/* 0C00 */ 0x02, 0x52, 0x02, 0x5C, 0x02, 0x65, 0x02, 0x6D, 0x02, 0x75, 0x02, 0x83, 0x02, 0xA5, 0x02, 0xC1, +/* 0C10 */ 0x02, 0xCE, 0x02, 0xDA, 0x02, 0xE8, 0x02, 0xF3, 0x02, 0xFD, 0x03, 0x07, 0x03, 0x13, 0x03, 0x1B, +/* 0C20 */ 0x03, 0x35, 0x03, 0x3F, 0x03, 0x4B, 0x03, 0x59, 0x03, 0x6A, 0x03, 0x76, 0x03, 0x83, 0x03, 0x8F, +/* 0C30 */ 0x03, 0xBD, 0x03, 0xC8, 0x03, 0xD3, 0x03, 0xE2, 0x03, 0xEC, 0x03, 0xF8, 0x04, 0x03, 0x04, 0x1F, +/* 0C40 */ 0x04, 0x28, 0x04, 0x31, 0x04, 0x3C, 0x04, 0x44, 0x04, 0x4C, 0x04, 0x59, 0x04, 0x79, 0x04, 0x87, +/* 0C50 */ 0x04, 0x91, 0x04, 0x9C, 0x04, 0xA8, 0x04, 0xB1, 0x04, 0xB9, 0x04, 0xC2, 0x04, 0xCC, 0x04, 0xD4, +/* 0C60 */ 0x04, 0xF3, 0x04, 0xFE, 0x05, 0x08, 0x05, 0x12, 0x05, 0x1D, 0x05, 0x26, 0x05, 0x2F, 0x05, 0x38, +/* 0C70 */ 0x05, 0x58, 0x05, 0x63, 0x05, 0x6D, 0x05, 0x79, 0x05, 0x82, 0x05, 0x8B, 0x05, 0x91, 0x02, 0x00, +/* 0C80 */ 0x10, 0x02, 0x31, 0x66, 0x1A, 0xC1, 0x19, 0x8E, 0x08, 0x20, 0x9C, 0x72, 0x20, 0x72, 0x20, 0x66, +/* 0C90 */ 0x10, 0x04, 0x35, 0x27, 0x2B, 0xB4, 0x4D, 0xC1, 0x58, 0x06, 0x18, 0x75, 0x47, 0x07, 0x20, 0x75, +/* 0CA0 */ 0x2B, 0xB4, 0x5A, 0x49, 0x2C, 0x49, 0x27, 0x10, 0x05, 0x35, 0x82, 0x65, 0x18, 0x65, 0x03, 0x40, +/* 0CB0 */ 0x0D, 0x26, 0xCB, 0x06, 0x0F, 0x83, 0x1F, 0x0D, 0x26, 0x59, 0x6D, 0x0D, 0x2A, 0x03, 0x10, 0x05, +/* 0CC0 */ 0x1A, 0x35, 0x8E, 0x1A, 0x3F, 0x80, 0x2A, 0x81, 0x1B, 0xCE, 0x09, 0x43, 0x3F, 0x9A, 0x07, 0x80, +/* 0CD0 */ 0x05, 0x21, 0x7B, 0x6C, 0x3F, 0x80, 0x0B, 0x1E, 0x07, 0x1B, 0xCE, 0x2B, 0xCE, 0x10, 0x05, 0x23, +/* 0CE0 */ 0x0B, 0x28, 0xBE, 0x39, 0x6C, 0x3F, 0x3A, 0x45, 0x18, 0x6D, 0x5D, 0x18, 0x37, 0x0F, 0x0A, 0x40, +/* 0CF0 */ 0x86, 0x1F, 0x7C, 0x0F, 0x0C, 0x40, 0x86, 0x10, 0x04, 0x24, 0x6C, 0x99, 0x57, 0x6C, 0x99, 0x10, +/* 0D00 */ 0x05, 0x23, 0x43, 0x83, 0x18, 0x4E, 0x00, 0xC8, 0x84, 0x02, 0x21, 0x9A, 0x08, 0x2C, 0x4B, 0x7C, +/* 0D10 */ 0x03, 0x52, 0xB4, 0x09, 0x0B, 0x00, 0xC1, 0x00, 0x0E, 0x18, 0x37, 0x81, 0x10, 0x04, 0x23, 0x06, +/* 0D20 */ 0x7D, 0x01, 0x10, 0x07, 0x35, 0x85, 0x5C, 0x02, 0x21, 0x46, 0x71, 0x09, 0x1B, 0x7A, 0x52, 0x9A, +/* 0D30 */ 0x05, 0x1A, 0x60, 0x0A, 0x2B, 0xB5, 0x1A, 0x7A, 0x52, 0x50, 0x05, 0x1A, 0x6D, 0x06, 0x71, 0x0A, +/* 0D40 */ 0x4B, 0x07, 0x09, 0x09, 0x02, 0x10, 0x05, 0x26, 0x35, 0x45, 0x4D, 0x1B, 0xAA, 0x2B, 0xA9, 0xA2, +/* 0D50 */ 0x00, 0xA9, 0x5C, 0x57, 0x04, 0x0B, 0x68, 0x10, 0x05, 0x42, 0x23, 0xB4, 0xCE, 0x18, 0x74, 0x39, +/* 0D60 */ 0x21, 0x03, 0x7E, 0x64, 0x29, 0x0A, 0x7C, 0x18, 0x6C, 0x04, 0x08, 0x06, 0x18, 0x50, 0x00, 0x05, +/* 0D70 */ 0x10, 0x05, 0x2E, 0x05, 0x2A, 0x64, 0x2B, 0x5E, 0xC8, 0x9A, 0x10, 0x04, 0x2E, 0x05, 0x0C, 0x7E, +/* 0D80 */ 0x10, 0x06, 0x57, 0x8E, 0x5C, 0x02, 0x21, 0x7A, 0x09, 0x07, 0x09, 0x29, 0x77, 0x07, 0x07, 0x02, +/* 0D90 */ 0x1B, 0x05, 0x03, 0x5C, 0x07, 0x02, 0x1B, 0x7A, 0x02, 0x70, 0x8E, 0x5C, 0x02, 0x10, 0x03, 0x23, +/* 0DA0 */ 0x08, 0xA2, 0x10, 0x05, 0x23, 0x61, 0x0A, 0x4B, 0x80, 0x05, 0x05, 0x05, 0x21, 0x80, 0x05, 0x05, +/* 0DB0 */ 0x05, 0x18, 0x61, 0x0A, 0x01, 0x10, 0x05, 0xB9, 0x89, 0x32, 0x10, 0x04, 0x23, 0x37, 0x08, 0x00, +/* 0DC0 */ 0xB4, 0x45, 0x20, 0x62, 0x00, 0xC4, 0x40, 0x80, 0x0D, 0x0C, 0x01, 0x10, 0x04, 0x23, 0x37, 0x09, +/* 0DD0 */ 0x00, 0xC1, 0x27, 0x47, 0x0A, 0x26, 0x52, 0x18, 0x72, 0x0A, 0x10, 0x03, 0x23, 0x62, 0x04, 0x2B, +/* 0DE0 */ 0x29, 0x03, 0x10, 0x05, 0x31, 0x77, 0x76, 0xA9, 0x76, 0xA9, 0x76, 0xA9, 0x76, 0xA9, 0x6C, 0x07, +/* 0DF0 */ 0x21, 0x2C, 0x6B, 0x63, 0x3C, 0x20, 0x3C, 0x20, 0xBC, 0x07, 0x23, 0x85, 0x0E, 0x0E, 0x0D, 0x07, +/* 0E00 */ 0x1A, 0xCE, 0xFF, 0x09, 0x41, 0x00, 0xCE, 0xFF, 0x09, 0x41, 0x00, 0x3A, 0x0F, 0x09, 0x41, 0x1B, +/* 0E10 */ 0x66, 0x41, 0xAA, 0x41, 0xAA, 0x41, 0xAA, 0x41, 0xAA, 0x41, 0x1B, 0xB5, 0x04, 0x05, 0x10, 0x02, +/* 0E20 */ 0x2E, 0x75, 0x1A, 0xC1, 0x10, 0x03, 0x20, 0x35, 0x2E, 0xB5, 0x20, 0x6D, 0x33, 0x07, 0x0C, 0x40, +/* 0E30 */ 0x04, 0x23, 0x45, 0x07, 0x00, 0xB4, 0x48, 0x20, 0x7D, 0x20, 0x7D, 0x20, 0x7D, 0x10, 0x05, 0x26, +/* 0E40 */ 0x35, 0x45, 0x71, 0x18, 0x48, 0x00, 0x0D, 0x18, 0x48, 0x00, 0x0D, 0x18, 0x61, 0x5D, 0x57, 0x67, +/* 0E50 */ 0x68, 0x10, 0x05, 0x31, 0x01, 0x01, 0x00, 0x40, 0x3C, 0x37, 0xC4, 0x06, 0x5B, 0x21, 0x85, 0x46, +/* 0E60 */ 0x0A, 0x21, 0x4E, 0x4E, 0x4B, 0x02, 0x03, 0x50, 0x10, 0x08, 0xC6, 0xAD, 0x60, 0x1B, 0x7D, 0x62, +/* 0E70 */ 0x73, 0x9B, 0x62, 0x1A, 0x80, 0x10, 0x08, 0xC6, 0xAD, 0x05, 0x71, 0x1A, 0x7D, 0x62, 0x02, 0x27, +/* 0E80 */ 0x1B, 0x85, 0x28, 0x03, 0x08, 0x1B, 0x61, 0x00, 0x61, 0x1B, 0x80, 0x04, 0x6D, 0x0D, 0x0B, 0x1A, +/* 0E90 */ 0x80, 0x10, 0x08, 0x23, 0x03, 0x83, 0x2B, 0x4F, 0x1B, 0x27, 0x00, 0x43, 0x01, 0x1A, 0x85, 0x0A, +/* 0EA0 */ 0x00, 0x73, 0x1B, 0x01, 0x6C, 0x73, 0x60, 0x1A, 0x3C, 0x08, 0x62, 0x73, 0x9B, 0x62, 0x1A, 0x80, +/* 0EB0 */ 0x10, 0x04, 0x31, 0xCE, 0x09, 0x19, 0xC1, 0x07, 0xBF, 0x00, 0xB4, 0x0D, 0x03, 0xC4, 0x07, 0x00, +/* 0EC0 */ 0xC4, 0x05, 0x01, 0x06, 0x18, 0x7C, 0x4D, 0x10, 0x05, 0x4A, 0x36, 0x44, 0x2D, 0x08, 0x8C, 0x10, +/* 0ED0 */ 0x05, 0x4A, 0x62, 0x07, 0x00, 0x8E, 0x0F, 0x05, 0x8C, 0x10, 0x05, 0x19, 0x2C, 0x49, 0x79, 0x49, +/* 0EE0 */ 0xCA, 0x8C, 0x10, 0x05, 0x19, 0x06, 0xA2, 0x42, 0xCA, 0x8C, 0x10, 0x05, 0x1B, 0x47, 0x7A, 0x3B, +/* 0EF0 */ 0xCA, 0x8C, 0x10, 0x05, 0x00, 0xCE, 0x51, 0x18, 0x80, 0x72, 0x00, 0xB4, 0x51, 0x1F, 0xCA, 0x8C, +/* 0F00 */ 0x10, 0x07, 0x23, 0x3A, 0x5F, 0x81, 0x1B, 0x37, 0x59, 0x34, 0x59, 0x65, 0x52, 0x21, 0x4E, 0x85, +/* 0F10 */ 0x0D, 0x51, 0x1A, 0x05, 0x0E, 0x7F, 0x07, 0x1B, 0x6C, 0x04, 0x00, 0x7B, 0x21, 0x0E, 0x01, 0x2B, +/* 0F20 */ 0x0E, 0x1E, 0x10, 0x05, 0xBA, 0x07, 0x8D, 0x02, 0xCE, 0x21, 0x66, 0xA1, 0xA1, 0x1A, 0x29, 0x0A, +/* 0F30 */ 0x26, 0x5A, 0x01, 0x05, 0x18, 0x7C, 0x4D, 0x1A, 0xAA, 0x20, 0x6D, 0x33, 0x07, 0x3E, 0x10, 0x05, +/* 0F40 */ 0x3B, 0x29, 0x52, 0xB4, 0x0E, 0x0D, 0x0F, 0x02, 0x93, 0x5F, 0xAC, 0x10, 0x05, 0x4A, 0x62, 0x06, +/* 0F50 */ 0x18, 0x69, 0x0E, 0x7E, 0x93, 0x5F, 0xAC, 0x10, 0x05, 0x18, 0x8E, 0x4D, 0x1F, 0x79, 0x06, 0x18, +/* 0F60 */ 0x6F, 0x7E, 0x93, 0x5F, 0xAC, 0x10, 0x05, 0x19, 0x08, 0x62, 0x42, 0x6F, 0x7E, 0x93, 0x5F, 0xAC, +/* 0F70 */ 0x10, 0x03, 0x24, 0x5C, 0xC8, 0x69, 0xC8, 0x22, 0x88, 0x30, 0x10, 0x03, 0x3B, 0xA9, 0x33, 0x06, +/* 0F80 */ 0xCB, 0x22, 0x88, 0x30, 0x10, 0x03, 0x1A, 0x47, 0x0D, 0x02, 0xC1, 0x79, 0x05, 0x1F, 0x88, 0x88, +/* 0F90 */ 0x10, 0x03, 0x1D, 0x7A, 0xB5, 0x3B, 0x88, 0x88, 0x10, 0x06, 0x23, 0x2D, 0x0C, 0x58, 0x8D, 0xCE, +/* 0FA0 */ 0x64, 0xCC, 0x00, 0x43, 0x06, 0x1A, 0x6C, 0x0F, 0x0C, 0x70, 0x06, 0xCC, 0xCE, 0x64, 0x1B, 0x2D, +/* 0FB0 */ 0x1E, 0x03, 0x10, 0x06, 0x19, 0x37, 0xA6, 0x1A, 0x19, 0x9D, 0xA7, 0x92, 0x10, 0x06, 0x4A, 0x6C, +/* 0FC0 */ 0x49, 0x82, 0x0F, 0x08, 0x8D, 0x8B, 0x01, 0x95, 0x10, 0x06, 0x4A, 0x9A, 0x0B, 0x4B, 0x9A, 0x0F, +/* 0FD0 */ 0x0D, 0x08, 0x8D, 0x8B, 0x01, 0x95, 0x10, 0x06, 0x18, 0xC4, 0x0C, 0x01, 0xB4, 0x04, 0x02, 0x04, +/* 0FE0 */ 0x18, 0x82, 0x6B, 0x8D, 0x8B, 0x01, 0x95, 0x10, 0x06, 0x19, 0x45, 0xA6, 0x42, 0x82, 0x6B, 0x8D, +/* 0FF0 */ 0x8B, 0x01, 0x95, 0x10, 0x06, 0x19, 0xB5, 0x03, 0x06, 0x42, 0x82, 0x6B, 0x8D, 0x8B, 0x01, 0x95, +/* 1000 */ 0x10, 0x05, 0x54, 0x60, 0x7A, 0xC4, 0xAC, 0x27, 0xA6, 0xB4, 0x05, 0x80, 0x10, 0x06, 0x26, 0xB4, +/* 1010 */ 0x2B, 0xB4, 0x63, 0x9A, 0x7F, 0x0A, 0x8D, 0x7A, 0x5D, 0x1B, 0x66, 0x6D, 0x66, 0x1A, 0x85, 0x07, +/* 1020 */ 0x7A, 0x77, 0x1A, 0x85, 0x07, 0x6E, 0x77, 0x1B, 0x66, 0x07, 0x01, 0x66, 0x1B, 0x01, 0x84, 0x00, +/* 1030 */ 0xA6, 0x1B, 0x80, 0x0E, 0x6B, 0x18, 0x6A, 0x2B, 0xC1, 0x01, 0x10, 0x06, 0x42, 0xC1, 0x5D, 0x18, +/* 1040 */ 0x36, 0x00, 0x82, 0x3D, 0xCF, 0x10, 0x06, 0x4A, 0x80, 0x0A, 0x21, 0x9A, 0xA6, 0x4C, 0x3D, 0xCF, +/* 1050 */ 0x10, 0x06, 0x19, 0x45, 0x0A, 0x18, 0x9A, 0x02, 0x04, 0x03, 0x21, 0x36, 0x3A, 0x3D, 0xCF, 0x10, +/* 1060 */ 0x06, 0x19, 0x04, 0x6A, 0x33, 0xBF, 0x3A, 0x3D, 0xCF, 0x10, 0x05, 0x4A, 0x7B, 0x05, 0x5E, 0x06, +/* 1070 */ 0x02, 0x77, 0x21, 0x66, 0xA0, 0x10, 0x05, 0x23, 0x22, 0x6F, 0x52, 0xC0, 0x67, 0xC0, 0xB2, 0x30, +/* 1080 */ 0x10, 0x05, 0x23, 0x6D, 0x1E, 0x4B, 0x4E, 0xC5, 0x77, 0x45, 0x4B, 0x77, 0x48, 0x8E, 0x3E, 0x58, +/* 1090 */ 0x00, 0xA9, 0xCE, 0x0D, 0x00, 0xA9, 0x2B, 0x0E, 0x21, 0x03, 0xA6, 0x71, 0x10, 0x05, 0x35, 0x48, +/* 10A0 */ 0x26, 0x6E, 0x18, 0xAE, 0x90, 0x10, 0x05, 0x35, 0x61, 0x33, 0x05, 0x44, 0xAE, 0x90, 0x10, 0x05, +/* 10B0 */ 0x24, 0x80, 0x0D, 0x33, 0x79, 0x06, 0x42, 0xAE, 0x90, 0x10, 0x05, 0x23, 0x43, 0x81, 0x42, 0xAE, +/* 10C0 */ 0x90, 0x10, 0x05, 0x23, 0x43, 0x7A, 0x42, 0xAE, 0x90, 0x10, 0x05, 0x19, 0x72, 0x01, 0xC4, 0x03, +/* 10D0 */ 0x49, 0x72, 0x01, 0x42, 0xAE, 0x90, 0x10, 0x08, 0x31, 0x4E, 0x6B, 0x0A, 0x6B, 0x18, 0x51, 0x00, +/* 10E0 */ 0x65, 0x2B, 0x61, 0x0C, 0x5F, 0x7F, 0x03, 0x2B, 0x5B, 0x6C, 0x3F, 0x6D, 0x07, 0x00, 0x0D, 0x08, +/* 10F0 */ 0xCE, 0x2B, 0xCE, 0x1E, 0x77, 0xA2, 0x10, 0x04, 0xBD, 0x40, 0xB8, 0x0D, 0x0B, 0x20, 0x52, 0x1B, +/* 1100 */ 0xAA, 0x00, 0xB4, 0x51, 0x10, 0x05, 0x35, 0x72, 0xC3, 0x03, 0x05, 0xC4, 0x94, 0x02, 0x10, 0x05, +/* 1110 */ 0x57, 0xC1, 0x46, 0x1F, 0x6E, 0x00, 0xC4, 0x94, 0x02, 0x10, 0x05, 0x24, 0x9A, 0x5A, 0x1F, 0x79, +/* 1120 */ 0x07, 0x1D, 0xC4, 0x94, 0x02, 0x10, 0x05, 0x23, 0x6D, 0x43, 0x1D, 0xC4, 0x94, 0x02, 0x10, 0x03, +/* 1130 */ 0x23, 0x74, 0x1B, 0x29, 0x33, 0xB6, 0x10, 0x03, 0x23, 0x7B, 0x40, 0x80, 0x02, 0x20, 0xB6, 0x10, +/* 1140 */ 0x03, 0x24, 0x07, 0x7E, 0xC1, 0x79, 0x05, 0x3B, 0xB6, 0x10, 0x03, 0x1B, 0x57, 0x7A, 0x60, 0x3B, +/* 1150 */ 0xB6, 0x10, 0x05, 0x2B, 0x4A, 0x40, 0x6C, 0x09, 0x49, 0x04, 0x0D, 0x08, 0x00, 0xB4, 0x01, 0xAC, +/* 1160 */ 0x09, 0x1E, 0x07, 0x29, 0x0A, 0x6D, 0x09, 0x1B, 0x76, 0xBE, 0x66, 0x6D, 0x06, 0x21, 0x6C, 0x83, +/* 1170 */ 0x10, 0x05, 0x23, 0x80, 0x83, 0x42, 0x3C, 0x0A, 0x91, 0xA3, 0x08, 0x10, 0x05, 0x35, 0x3C, 0xC8, +/* 1180 */ 0xCE, 0x05, 0xC4, 0x97, 0x3E, 0x10, 0x05, 0x35, 0x76, 0x8E, 0x04, 0x00, 0xC4, 0x97, 0x3E, 0x10, +/* 1190 */ 0x05, 0x4A, 0x2C, 0x49, 0x79, 0x07, 0x1D, 0xC4, 0x97, 0x3E, 0x10, 0x05, 0x23, 0x80, 0xA2, 0x26, +/* 11A0 */ 0xC4, 0x97, 0x3E, 0x10, 0x05, 0x23, 0x6D, 0x62, 0x1D, 0xC4, 0x97, 0x3E, 0x10, 0x05, 0x00, 0x31, +/* 11B0 */ 0x73, 0x3B, 0x32, 0x00, 0x73, 0x10, 0x05, 0x2B, 0x57, 0xB4, 0x1A, 0x5E, 0xC4, 0x7F, 0x4B, 0x36, +/* 11C0 */ 0x3C, 0x08, 0x1B, 0x85, 0x48, 0x77, 0x1B, 0x85, 0x75, 0x37, 0x21, 0x36, 0x07, 0x48, 0x5E, 0x0D, +/* 11D0 */ 0x0B, 0x4B, 0x6C, 0xC8, 0xCE, 0x10, 0x05, 0x35, 0x70, 0xC3, 0x03, 0x05, 0x18, 0x96, 0xA8, 0x06, +/* 11E0 */ 0x10, 0x05, 0x35, 0x85, 0x49, 0x6E, 0x1F, 0x96, 0xA8, 0x06, 0x10, 0x05, 0x42, 0x8E, 0x4D, 0x1F, +/* 11F0 */ 0x79, 0x07, 0x42, 0x96, 0xA8, 0x06, 0x10, 0x05, 0x23, 0x6D, 0x62, 0x42, 0x96, 0xA8, 0x06, 0x10, +/* 1200 */ 0x04, 0x35, 0x7B, 0x40, 0x80, 0x44, 0xAB, 0x9F, 0x10, 0x05, 0x24, 0xB1, 0xBE, 0x8A, 0xBC, 0x04, +/* 1210 */ 0x23, 0x01, 0x07, 0x03, 0x06, 0x42, 0xAB, 0x9F, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x0C, 0x00, +/* 1220 */ 0x06, 0x05, 0x2E, 0x09, 0x2A, 0x83, 0x10, 0x05, 0x2E, 0x08, 0x2A, 0x51, 0x10, 0x07, 0x2E, 0x08, +/* 1230 */ 0x2A, 0x2A, 0x83, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x04, 0x9B, +/* 1240 */ 0x00, 0x00, 0x04, 0x9D, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x04, 0xA0, +/* 1250 */ 0x00, 0x00, 0x05, 0x5E, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x0B, 0xBE, +/* 1260 */ 0x00, 0x00, 0x0C, 0x7E, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x12, 0x19, +/* 1270 */ 0x00, 0x00, 0x12, 0x21, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular12.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular12.mcufont.h new file mode 100644 index 000000000..772419496 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular12.mcufont.h @@ -0,0 +1,364 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 12 + * blob size: 5461, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x03, 0x68, 0x00, 0x00, 0x03, 0xE3, 0x00, 0x00, 0x00, 0x8F, +/* 0020 */ 0x00, 0x00, 0x00, 0xCC, 0x00, 0x00, 0x15, 0x15, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0C, 0x00, 0x10, 0x00, 0x02, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x31, 0x32, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x31, 0x32, 0x00, +/* dictionary data */ +0x40, 0x0A, 0x06, 0x33, 0x03, +/* 0080 */ 0x32, 0x08, 0x02, 0x15, 0x09, 0x0F, 0xC9, 0xC1, 0x04, 0x1A, 0x14, 0xC9, 0x07, 0x80, 0xC1, 0x0A, +/* 0090 */ 0x80, 0xC1, 0x0A, 0x80, 0xC1, 0x05, 0x80, 0xC2, 0x0A, 0x80, 0xC2, 0x05, 0x07, 0x0A, 0xCE, 0xC3, +/* 00A0 */ 0xD8, 0x0A, 0xC9, 0x0A, 0x0A, 0xC9, 0x31, 0xC4, 0x0B, 0xEE, 0xC8, 0xC9, 0xC4, 0xCC, 0xCC, 0xC2, +/* 00B0 */ 0xCD, 0xC3, 0xD6, 0xC3, 0x29, 0x09, 0xC4, 0x25, 0xCA, 0xC6, 0xCA, 0xC1, 0xC1, 0xCA, 0x01, 0xCB, +/* 00C0 */ 0xC3, 0xCE, 0x08, 0xC1, 0x01, 0xCC, 0x28, 0xCE, 0xC6, 0x06, 0x06, 0xC2, 0x80, 0x02, 0xCC, 0xCD, +/* 00D0 */ 0x0A, 0x05, 0xC5, 0xCD, 0x03, 0xC4, 0xCD, 0x05, 0x01, 0xC5, 0xC4, 0xCA, 0x0A, 0xC5, 0xCC, 0x21, +/* 00E0 */ 0xC2, 0xCD, 0x40, 0x21, 0x07, 0xC6, 0xC8, 0xCE, 0x08, 0xC5, 0xCA, 0xC2, 0xC1, 0xCC, 0xC5, 0xCC, +/* 00F0 */ 0xC7, 0xC5, 0xC3, 0xCC, 0x07, 0xCB, 0xC9, 0x01, 0xC2, 0xCE, 0xC4, 0x05, 0xC2, 0x80, 0xC1, 0x02, +/* 0100 */ 0xC8, 0xCA, 0x05, 0xC5, 0xCD, 0xC3, 0xCB, 0x0A, 0xC1, 0x02, 0xCB, 0x02, 0xC9, 0xC7, 0xC6, 0xCB, +/* 0110 */ 0xCD, 0xCB, 0xDD, 0x40, 0x09, 0xCE, 0xCB, 0x07, 0xC1, 0xCC, 0xC1, 0xC8, 0xCA, 0x1C, 0x26, 0xCA, +/* 0120 */ 0xC8, 0xCA, 0xC7, 0xCE, 0xC7, 0x01, 0xCA, 0xCB, 0xC1, 0x07, 0x80, 0x80, 0xC2, 0x02, 0x80, 0xDE, +/* 0130 */ 0xC4, 0xC8, 0xC4, 0xC1, 0xC7, 0xCA, 0x80, 0xC3, 0xCD, 0xC1, 0xC3, 0xCD, 0x01, 0xC8, 0xC5, 0xCD, +/* 0140 */ 0xC2, 0xCE, 0xC8, 0x01, 0x80, 0xC2, 0xC7, 0xC1, 0xC9, 0xC5, 0xCE, 0x80, 0x01, 0xC6, 0x01, 0xC1, +/* 0150 */ 0x01, 0xCD, 0xCC, 0xC5, 0x01, 0xC3, 0xC2, 0xCE, 0xCE, 0xCD, 0xC7, 0xC8, 0xC4, 0xCB, 0xC2, 0xCB, +/* 0160 */ 0xC1, 0xCB, 0xCA, 0xC5, 0xCE, 0xC2, 0xCE, 0xCC, 0xCD, 0xC4, 0x81, 0xC5, 0xC9, 0xC6, 0xC7, 0xCE, +/* 0170 */ 0xC6, 0xCA, 0xCD, 0xC5, 0xCB, 0xC5, 0x07, 0x80, 0xC1, 0x01, 0xCE, 0xC4, 0xC6, 0xC8, 0xD6, 0xC5, +/* 0180 */ 0xDE, 0xC7, 0xCC, 0xCE, 0xC1, 0xC5, 0xCD, 0xC1, 0xC4, 0xC4, 0xCD, 0x05, 0xC1, 0x80, 0x03, 0xC2, +/* 0190 */ 0xCC, 0xD8, 0xCB, 0xC9, 0x01, 0xC9, 0xC8, 0xCE, 0xCA, 0x01, 0xC8, 0x01, 0xC2, 0xCD, 0xC7, 0xC6, +/* 01A0 */ 0xCC, 0xCA, 0xC4, 0x01, 0xC7, 0xC9, 0x01, 0xC5, 0xCB, 0xCC, 0xC4, 0xCC, 0xC3, 0x80, 0xC1, 0x29, +/* 01B0 */ 0x28, 0x29, 0x28, 0x0A, 0x0E, 0x2B, 0x0E, 0xA4, 0x1D, 0x53, 0x99, 0x1D, 0x07, 0x09, 0x34, 0x1D, +/* 01C0 */ 0x8C, 0x01, 0xA6, 0x2A, 0x84, 0x00, 0x7B, 0x19, 0x04, 0x6A, 0x0F, 0x09, 0x19, 0x33, 0x1E, 0x01, +/* 01D0 */ 0x2C, 0x01, 0x9F, 0x19, 0x96, 0x58, 0x19, 0xA0, 0x58, 0x19, 0x96, 0x58, 0x28, 0x79, 0x6E, 0x01, +/* 01E0 */ 0x9F, 0x4C, 0x85, 0x64, 0x7B, 0x2B, 0x7B, 0x2B, 0x7B, 0x2B, 0x7B, 0x1B, 0x00, 0x40, 0x19, 0x57, +/* 01F0 */ 0x07, 0x1E, 0x59, 0x19, 0x51, 0x1E, 0xA4, 0x2A, 0x36, 0x03, 0xA0, 0x1B, 0x04, 0x0E, 0x0D, 0x06, +/* 0200 */ 0x5E, 0x84, 0x01, 0x6F, 0x19, 0x34, 0x1E, 0x83, 0x28, 0x78, 0x6A, 0x43, 0x34, 0x56, 0x0F, 0x56, +/* 0210 */ 0xF5, 0x2B, 0x93, 0x2B, 0xE5, 0x2C, 0x97, 0x2C, 0x97, 0x2C, 0x97, 0x2C, 0x97, 0x2C, 0x97, 0x2C, +/* 0220 */ 0x23, 0x79, 0xA6, 0x1E, 0x74, 0x28, 0x41, 0x06, 0x00, 0x94, 0x2A, 0x53, 0x00, 0x36, 0x00, 0xA4, +/* 0230 */ 0x0B, 0x0E, 0x86, 0x1E, 0x44, 0x00, 0xA0, 0x2B, 0x7D, 0x1D, 0x09, 0x0D, 0x0E, 0x0E, 0x4C, 0x5F, +/* 0240 */ 0x7D, 0x2A, 0x07, 0x0B, 0x78, 0x0E, 0x2A, 0x50, 0x0E, 0x33, 0x04, 0x24, 0x8A, 0x2B, 0x8A, 0x2B, +/* 0250 */ 0x8A, 0x2B, 0x8A, 0x2B, 0x8A, 0x2B, 0x47, 0x02, 0xA6, 0x1E, 0x6D, 0x19, 0x9A, 0x02, 0x86, 0x19, +/* 0260 */ 0x82, 0x7E, 0x06, 0x25, 0x00, 0x09, 0x04, 0x28, 0x79, 0xF5, 0xA4, 0x28, 0x79, 0xF5, 0xA4, 0x28, +/* 0270 */ 0x79, 0xF5, 0xA4, 0x28, 0x79, 0xF5, 0xA4, 0x2A, 0xA6, 0x02, 0x8E, 0x19, 0x9D, 0x0C, 0x0A, 0x0B, +/* 0280 */ 0x0B, 0x03, 0x4E, 0x77, 0x5D, 0x2A, 0x57, 0x03, 0x1D, 0x57, 0x03, 0x3A, 0x66, 0x31, 0xA6, 0x2B, +/* 0290 */ 0xA6, 0x1B, 0x68, 0x07, 0x34, 0x2B, 0x34, 0x2B, 0x34, 0x2B, 0x34, 0x2B, 0x04, 0x5B, 0x08, 0x5E, +/* 02A0 */ 0x2C, 0x01, 0x7B, 0x19, 0x34, 0x1E, 0xA2, 0x28, 0x59, 0x1E, 0x8A, 0x19, 0x34, 0x1E, 0x33, 0x28, +/* 02B0 */ 0x79, 0x2C, 0x01, 0x86, 0x2A, 0x04, 0x5B, 0x08, 0x04, 0x19, 0x0E, 0x93, 0x3E, 0x04, 0x19, 0x0E, +/* 02C0 */ 0x3B, 0x3E, 0x04, 0x19, 0x0E, 0x34, 0x3E, 0x04, 0x1B, 0xEC, 0x7A, 0x81, 0x04, 0x23, 0xE8, 0x99, +/* 02D0 */ 0x0B, 0x04, 0x1B, 0xEC, 0x9E, 0x5D, 0x04, 0x1B, 0xEC, 0x57, 0x8E, 0x23, 0xE8, 0x48, 0x0F, 0x0D, +/* 02E0 */ 0x1D, 0x07, 0x09, 0x88, 0x40, 0x0E, 0x6F, 0x1D, 0x66, 0x2E, 0x9B, 0x2B, 0x9B, 0x2B, 0x9B, 0x0B, +/* 02F0 */ 0x2A, 0x82, 0x00, 0x52, 0x09, 0x02, 0x28, 0x52, 0x3E, 0x77, 0x0A, 0x23, 0x41, 0x23, 0x4F, 0x23, +/* 0300 */ 0x04, 0x94, 0x19, 0x7B, 0x00, 0x79, 0x74, 0x0F, 0x7E, 0x6A, 0x93, 0x2A, 0x29, 0x28, 0x74, 0x2B, +/* 0310 */ 0x6A, 0x09, 0x1D, 0x29, 0x28, 0x74, 0x2B, 0x6A, 0x84, 0x62, 0x0D, 0x6B, 0x00, 0x4C, 0x98, 0x8C, +/* 0320 */ 0x1E, 0x84, 0x19, 0xA2, 0x70, 0x19, 0x53, 0x00, 0x7F, 0x1D, 0x93, 0xA1, 0x19, 0x66, 0x04, 0x6F, +/* 0330 */ 0x1D, 0x8A, 0x0B, 0x1B, 0x44, 0x0F, 0x07, 0x2B, 0x35, 0x1E, 0x44, 0x09, 0x0A, 0x39, 0x23, 0x21, +/* 0340 */ 0x3D, 0x7E, 0x06, 0x54, 0x1B, 0x94, 0x28, 0x06, 0x07, 0x01, 0x68, 0x06, 0x3E, 0x07, 0x8D, 0x6D, +/* 0350 */ 0x8D, 0x59, 0x8D, 0x6D, 0x68, 0x05, 0x41, 0x06, 0x0E, 0x8B, 0x19, 0x66, 0x09, 0x9E, 0x04, 0x44, +/* 0360 */ 0xA6, 0x00, 0x4E, 0x46, 0xA0, 0x2B, 0x0C, 0x07, 0x04, 0x0A, 0x0F, 0x08, 0x00, 0x7B, 0x8D, 0x3B, +/* 0370 */ 0x8D, 0x3B, 0x8D, 0x3B, 0x8D, 0x0E, 0xA5, 0x38, 0x03, 0x2B, 0x2B, 0xA3, 0x2B, 0xA3, 0x2B, 0xA3, +/* 0380 */ 0x68, 0x09, 0x9C, 0x1D, 0xA6, 0x2B, 0xA6, 0x2B, 0x0D, 0x5F, 0x2A, 0x4D, 0x1B, 0x04, 0x06, 0x1B, +/* 0390 */ 0x79, 0x51, 0x1B, 0x67, 0x28, 0x41, 0x00, 0x86, 0x19, 0x69, 0x86, 0x19, 0x69, 0x86, 0x19, 0x74, +/* 03A0 */ 0x0A, 0x32, 0x2A, 0x74, 0x62, 0x48, 0x2B, 0x9D, 0xA5, 0x56, 0x23, 0x44, 0xA6, 0x2B, 0x27, 0x2B, +/* 03B0 */ 0x27, 0x05, 0x08, 0x08, 0x2B, 0x9F, 0x5E, 0x8E, 0x7C, 0x2A, 0x04, 0x46, 0x59, 0x2B, 0x54, 0x1B, +/* 03C0 */ 0x94, 0x28, 0x31, 0x18, 0x1D, 0xA6, 0x03, 0x02, 0x05, 0x1D, 0x3B, 0x8D, 0x3B, 0x00, 0x4F, 0x3A, +/* 03D0 */ 0x01, 0x5F, 0x19, 0x61, 0x0C, 0x2B, 0x94, 0x00, 0x39, 0x2E, 0x07, 0x04, 0x2C, 0x00, 0x04, 0x1D, +/* 03E0 */ 0x04, 0x5B, 0x22, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, +/* 03F0 */ 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0B, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x0F, 0x00, +/* 0400 */ 0x10, 0x00, 0x12, 0x00, 0x1A, 0x00, 0x1B, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x25, 0x00, +/* 0410 */ 0x27, 0x00, 0x29, 0x00, 0x2B, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x2F, 0x00, 0x31, 0x00, 0x33, 0x00, +/* 0420 */ 0x35, 0x00, 0x37, 0x00, 0x39, 0x00, 0x3A, 0x00, 0x3C, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x41, 0x00, +/* 0430 */ 0x43, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x51, 0x00, +/* 0440 */ 0x54, 0x00, 0x56, 0x00, 0x5D, 0x00, 0x5F, 0x00, 0x65, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6B, 0x00, +/* 0450 */ 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x73, 0x00, 0x75, 0x00, 0x77, 0x00, 0x79, 0x00, 0x8A, 0x00, +/* 0460 */ 0x8C, 0x00, 0x8E, 0x00, 0x90, 0x00, 0x93, 0x00, 0x95, 0x00, 0x97, 0x00, 0x98, 0x00, 0x9A, 0x00, +/* 0470 */ 0x9C, 0x00, 0x9E, 0x00, 0xA0, 0x00, 0xA2, 0x00, 0xA3, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA8, 0x00, +/* 0480 */ 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xB0, 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, +/* 0490 */ 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC2, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC9, 0x00, 0xCB, 0x00, +/* 04A0 */ 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, +/* 04B0 */ 0xDD, 0x00, 0xDF, 0x00, 0xE1, 0x00, 0xE3, 0x00, 0xE5, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEB, 0x00, +/* 04C0 */ 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF9, 0x00, 0xFB, 0x00, +/* 04D0 */ 0xFF, 0x01, 0x01, 0x01, 0x03, 0x01, 0x04, 0x01, 0x06, 0x01, 0x08, 0x01, 0x0A, 0x01, 0x0C, 0x01, +/* 04E0 */ 0x0E, 0x01, 0x10, 0x01, 0x14, 0x01, 0x16, 0x01, 0x17, 0x01, 0x1A, 0x01, 0x1C, 0x01, 0x1E, 0x01, +/* 04F0 */ 0x20, 0x01, 0x22, 0x01, 0x24, 0x01, 0x26, 0x01, 0x29, 0x01, 0x2C, 0x01, 0x2E, 0x01, 0x30, 0x01, +/* 0500 */ 0x32, 0x01, 0x34, 0x01, 0x38, 0x01, 0x54, 0x01, 0x69, 0x01, 0x71, 0x01, 0x73, 0x01, 0x7F, 0x01, +/* 0510 */ 0x83, 0x01, 0x93, 0x01, 0x96, 0x01, 0x99, 0x01, 0xB1, 0x01, 0xB5, 0x01, 0xD1, 0x01, 0xDB, 0x01, +/* 0520 */ 0xE9, 0x01, 0xEB, 0x02, 0x05, 0x02, 0x10, 0x02, 0x19, 0x02, 0x21, 0x02, 0x3D, 0x02, 0x64, 0x02, +/* 0530 */ 0x74, 0x02, 0x86, 0x02, 0x8C, 0x02, 0x8E, 0x02, 0x9F, 0x02, 0xA4, 0x02, 0xC3, 0x02, 0xCC, 0x02, +/* 0540 */ 0xCE, 0x02, 0xDD, 0x02, 0xEB, 0x02, 0xED, 0x02, 0xEF, 0x02, 0xFA, 0x02, 0xFD, 0x02, 0xFF, 0x03, +/* 0550 */ 0x05, 0x03, 0x0D, 0x03, 0x10, 0x03, 0x1C, 0x03, 0x25, 0x03, 0x27, 0x03, 0x29, 0x03, 0x2F, 0x03, +/* 0560 */ 0x31, 0x03, 0x36, 0x03, 0x38, 0x03, 0x3A, 0x03, 0x43, 0x03, 0x47, 0x03, 0x49, 0x03, 0x4B, 0x03, +/* 0570 */ 0x4D, 0x03, 0x4F, 0x03, 0x52, 0x03, 0x54, 0x03, 0x59, 0x03, 0x61, 0x03, 0x68, +/* char range info */ +0x00, 0x00, 0x03, +/* 0580 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x15, 0x00, 0x22, 0x00, 0x47, 0x00, 0x6F, 0x00, 0xA1, +/* 0590 */ 0x00, 0xCE, 0x00, 0xD8, 0x00, 0xF1, 0x01, 0x09, 0x01, 0x1D, 0x01, 0x23, 0x01, 0x29, 0x01, 0x2E, +/* 05A0 */ 0x01, 0x34, 0x01, 0x4E, 0x01, 0x72, 0x01, 0x84, 0x01, 0xA0, 0x01, 0xBD, 0x01, 0xD6, 0x01, 0xF3, +/* 05B0 */ 0x02, 0x14, 0x02, 0x29, 0x02, 0x4D, 0x02, 0x71, 0x02, 0x77, 0x02, 0x7D, 0x02, 0x90, 0x02, 0x99, +/* 05C0 */ 0x02, 0xAD, 0x02, 0xC6, 0x03, 0x0D, 0x03, 0x12, 0x03, 0x30, 0x03, 0x40, 0x03, 0x5F, 0x03, 0x63, +/* 05D0 */ 0x03, 0x71, 0x03, 0x97, 0x03, 0xA7, 0x03, 0xAD, 0x03, 0xBB, 0x03, 0xDA, 0x03, 0xE1, 0x04, 0x17, +/* 05E0 */ 0x04, 0x1F, 0x04, 0x26, 0x04, 0x3C, 0x04, 0x5F, 0x04, 0x7D, 0x04, 0x9F, 0x04, 0xAB, 0x04, 0xB0, +/* 05F0 */ 0x04, 0xD5, 0x05, 0x0F, 0x05, 0x32, 0x05, 0x37, 0x05, 0x4E, 0x05, 0x5B, 0x05, 0x78, 0x05, 0x86, +/* 0600 */ 0x05, 0x95, 0x05, 0x9C, 0x05, 0xA4, 0x05, 0xA8, 0x05, 0xB0, 0x05, 0xBC, 0x05, 0xCB, 0x05, 0xD1, +/* 0610 */ 0x05, 0xEC, 0x06, 0x17, 0x06, 0x1D, 0x06, 0x21, 0x06, 0x2F, 0x06, 0x48, 0x06, 0x57, 0x06, 0x72, +/* 0620 */ 0x06, 0x7A, 0x06, 0x7E, 0x06, 0x86, 0x06, 0x95, 0x06, 0xA1, 0x06, 0xB9, 0x06, 0xCA, 0x06, 0xD1, +/* 0630 */ 0x06, 0xE9, 0x07, 0x12, 0x07, 0x2C, 0x07, 0x31, 0x07, 0x45, 0x07, 0x5D, 0x07, 0x65, 0x07, 0x83, +/* 0640 */ 0x03, 0x00, 0x10, 0x03, 0x1D, 0x38, 0x3F, 0x2B, 0x3F, 0xD5, 0x46, 0x4A, 0xD5, 0x46, 0x50, 0x00, +/* 0650 */ 0x1F, 0x81, 0x2B, 0x70, 0x10, 0x05, 0x30, 0x0B, 0x53, 0x2A, 0x7C, 0x0A, 0x98, 0x2A, 0x7C, 0x09, +/* 0660 */ 0x82, 0x10, 0x06, 0x1C, 0xC5, 0x7A, 0x1D, 0x71, 0x7A, 0x4C, 0x6A, 0x0F, 0x07, 0x2A, 0x35, 0xC9, +/* 0670 */ 0x2A, 0x7A, 0x00, 0xD7, 0x2A, 0x7A, 0x00, 0x07, 0x07, 0x19, 0x41, 0x6A, 0x93, 0x28, 0x7C, 0x0A, +/* 0680 */ 0x66, 0x03, 0x2A, 0xD7, 0x00, 0x5F, 0x10, 0x06, 0x25, 0x4C, 0x04, 0x2B, 0x71, 0x20, 0x89, 0x8B, +/* 0690 */ 0x2A, 0x04, 0x72, 0x02, 0x26, 0x59, 0x2B, 0x7D, 0x75, 0x20, 0x55, 0x43, 0x1B, 0x7C, 0x74, 0x2B, +/* 06A0 */ 0xA4, 0x28, 0x48, 0x04, 0x7C, 0x84, 0x19, 0x53, 0x0E, 0x43, 0x1B, 0x71, 0x2B, 0x52, 0x10, 0x09, +/* 06B0 */ 0x3A, 0x44, 0x23, 0x57, 0x8B, 0x1E, 0x35, 0x23, 0xD7, 0x50, 0x78, 0x09, 0x28, 0x07, 0x06, 0x00, +/* 06C0 */ 0x6F, 0x5F, 0x23, 0x48, 0x22, 0xC8, 0x07, 0x19, 0x66, 0x0D, 0x06, 0x6F, 0x1D, 0xB6, 0x90, 0x0D, +/* 06D0 */ 0x67, 0x28, 0x98, 0x00, 0x6F, 0x71, 0x28, 0xA1, 0x0D, 0x9D, 0x06, 0x23, 0x81, 0x1E, 0x89, 0x67, +/* 06E0 */ 0x10, 0x08, 0x1C, 0x98, 0x0E, 0x09, 0x1D, 0x9B, 0x00, 0xA4, 0x28, 0x58, 0x00, 0xA4, 0x19, 0x7C, +/* 06F0 */ 0x0D, 0x60, 0x1D, 0x4A, 0x84, 0x00, 0x75, 0x23, 0x41, 0x06, 0xA0, 0x7D, 0x23, 0x79, 0xA6, 0x00, +/* 0700 */ 0x89, 0x08, 0x19, 0x0E, 0x05, 0x48, 0x5D, 0x28, 0x7C, 0x0D, 0x5D, 0x02, 0x76, 0x10, 0x02, 0x30, +/* 0710 */ 0x0B, 0x20, 0x7C, 0x0A, 0x20, 0x7C, 0x09, 0x10, 0x04, 0x62, 0x50, 0x20, 0x9D, 0x07, 0xAB, 0x93, +/* 0720 */ 0x20, 0xA3, 0x2B, 0x07, 0x2E, 0x2D, 0x2D, 0x8A, 0x20, 0x7C, 0x46, 0x41, 0xCC, 0xA3, 0x31, 0x07, +/* 0730 */ 0x10, 0x04, 0x3A, 0x8F, 0x56, 0x72, 0x2B, 0x2D, 0x70, 0xAB, 0xA6, 0x2B, 0x69, 0xDC, 0x20, 0x7D, +/* 0740 */ 0x2B, 0xA3, 0x2B, 0x83, 0x20, 0x70, 0x39, 0x04, 0x10, 0x05, 0x62, 0x7A, 0x39, 0x55, 0x04, 0x04, +/* 0750 */ 0x2A, 0xC9, 0x0F, 0x09, 0x03, 0x2A, 0x66, 0x09, 0x09, 0x40, 0x08, 0x9D, 0x10, 0x05, 0x5C, 0x57, +/* 0760 */ 0xCC, 0xB8, 0x10, 0x03, 0x61, 0x4B, 0x4E, 0xE2, 0x10, 0x04, 0x4B, 0x91, 0x0A, 0x10, 0x03, 0x1D, +/* 0770 */ 0x61, 0x4B, 0x49, 0x10, 0x06, 0x42, 0x04, 0x04, 0x2B, 0xA1, 0x20, 0x6F, 0x20, 0x98, 0x1B, 0x4C, +/* 0780 */ 0x2E, 0x76, 0x2B, 0x72, 0xAB, 0x46, 0x05, 0x2E, 0x08, 0x06, 0x2B, 0x35, 0xD5, 0x10, 0x06, 0x1C, +/* 0790 */ 0x96, 0x43, 0x1E, 0x86, 0x02, 0x84, 0x19, 0x3F, 0x1E, 0x3B, 0x19, 0x51, 0x1E, 0x9B, 0x19, 0x51, +/* 07A0 */ 0x1E, 0x33, 0x19, 0x34, 0x1E, 0x9B, 0x19, 0x7D, 0x1E, 0x3B, 0x2A, 0x86, 0x02, 0x84, 0x2A, 0x96, +/* 07B0 */ 0x43, 0x10, 0x05, 0x1C, 0x03, 0x0D, 0x08, 0x4E, 0x5A, 0x08, 0x1D, 0xDD, 0x2D, 0x2D, 0x2D, 0x2D, +/* 07C0 */ 0x2D, 0x2D, 0x99, 0x10, 0x05, 0x1D, 0x38, 0x98, 0x9C, 0x1D, 0x07, 0x04, 0x3E, 0x07, 0x20, 0x9D, +/* 07D0 */ 0x2E, 0x64, 0x1B, 0x44, 0x84, 0x20, 0x64, 0x20, 0x59, 0x1D, 0x7C, 0x6F, 0x20, 0xD2, 0x0A, 0x10, +/* 07E0 */ 0x05, 0x1D, 0x38, 0x53, 0x9C, 0x4E, 0x03, 0x00, 0x64, 0x2B, 0xA2, 0x40, 0x8C, 0x2A, 0x7C, 0x0F, +/* 07F0 */ 0x67, 0x2F, 0x2E, 0x34, 0x4C, 0x02, 0xB6, 0x0A, 0x2A, 0x96, 0x0E, 0x67, 0x10, 0x06, 0x38, 0xD5, +/* 0800 */ 0x01, 0x2B, 0xA4, 0x20, 0x70, 0x2A, 0x58, 0x2B, 0x84, 0x05, 0x26, 0xA3, 0x78, 0x26, 0x08, 0x32, +/* 0810 */ 0x65, 0x20, 0x07, 0x2E, 0xA2, 0x10, 0x06, 0x30, 0x6A, 0x26, 0x34, 0x2B, 0x34, 0x00, 0x39, 0x7E, +/* 0820 */ 0xA5, 0x2A, 0x95, 0x00, 0x92, 0xD5, 0x0F, 0xD5, 0x0F, 0x19, 0x48, 0x04, 0x00, 0x60, 0x2A, 0x53, +/* 0830 */ 0x0E, 0x67, 0x10, 0x06, 0x1C, 0x82, 0x9C, 0x1D, 0x63, 0x79, 0x5E, 0x93, 0x20, 0x96, 0x09, 0x0E, +/* 0840 */ 0x26, 0x05, 0x0F, 0x6C, 0x86, 0x19, 0x34, 0x58, 0x19, 0x70, 0x00, 0x3B, 0x19, 0x7A, 0x6C, 0x2C, +/* 0850 */ 0x2A, 0x96, 0x65, 0x10, 0x05, 0x1D, 0x38, 0xD2, 0xD8, 0x8C, 0xAB, 0x0E, 0x2B, 0x07, 0x2E, 0xA4, +/* 0860 */ 0x20, 0x7D, 0x2B, 0x07, 0x2E, 0x36, 0xAB, 0x09, 0x10, 0x06, 0x1C, 0x06, 0x5B, 0x06, 0x00, 0x44, +/* 0870 */ 0x93, 0x01, 0x84, 0x19, 0x70, 0x00, 0x36, 0x2A, 0x9F, 0x34, 0x1D, 0x92, 0x43, 0x00, 0x34, 0x9E, +/* 0880 */ 0x86, 0x19, 0x33, 0x58, 0x28, 0x48, 0x5F, 0x01, 0x7B, 0x2A, 0x4D, 0x73, 0x10, 0x06, 0x1C, 0x89, +/* 0890 */ 0x86, 0x19, 0x7C, 0x6F, 0x96, 0x2A, 0xA2, 0x00, 0x84, 0x19, 0xA2, 0x00, 0x86, 0x19, 0x04, 0x6F, +/* 08A0 */ 0x05, 0x6E, 0x2A, 0x4D, 0x08, 0x93, 0x20, 0x51, 0x1D, 0x7C, 0x86, 0x2A, 0xB6, 0x86, 0x1D, 0x7C, +/* 08B0 */ 0x10, 0x03, 0xDB, 0x49, 0x00, 0x49, 0x10, 0x03, 0xDB, 0x49, 0x48, 0xE2, 0x10, 0x05, 0x1E, 0x18, +/* 08C0 */ 0x95, 0x40, 0x07, 0x9F, 0x2A, 0x96, 0x75, 0x1D, 0x96, 0x75, 0xAB, 0x08, 0x9F, 0x2B, 0x95, 0x10, +/* 08D0 */ 0x05, 0xDB, 0x91, 0x5D, 0x23, 0x21, 0x91, 0x5D, 0x10, 0x05, 0x5C, 0x01, 0xCC, 0x81, 0x0B, 0xCC, +/* 08E0 */ 0x80, 0x0A, 0x20, 0x80, 0x0A, 0x2A, 0x81, 0x0B, 0x03, 0x1E, 0x44, 0x04, 0x10, 0x05, 0x1D, 0x38, +/* 08F0 */ 0x82, 0x0E, 0x35, 0x19, 0x48, 0x06, 0x9D, 0x2E, 0x9B, 0x1D, 0x9D, 0x5F, 0x1E, 0x44, 0x93, 0x1D, +/* 0900 */ 0x7C, 0x08, 0x00, 0x1F, 0x49, 0x10, 0x0B, 0x00, 0x1A, 0xA0, 0x7E, 0x09, 0x02, 0x23, 0xB6, 0x0B, +/* 0910 */ 0x02, 0x00, 0x48, 0x72, 0x1B, 0x51, 0x28, 0x59, 0x1B, 0xA4, 0x9D, 0x0D, 0xA5, 0x00, 0x93, 0x79, +/* 0920 */ 0x0E, 0x48, 0x5F, 0x88, 0x00, 0xA4, 0x00, 0x70, 0x88, 0x9D, 0x06, 0x3E, 0x04, 0x00, 0x53, 0x00, +/* 0930 */ 0x88, 0x9D, 0x06, 0x00, 0xA5, 0x79, 0x0E, 0x00, 0xA2, 0x63, 0x4A, 0x1B, 0x36, 0x82, 0x0E, 0x80, +/* 0940 */ 0x86, 0x1B, 0x6D, 0x20, 0x57, 0x4F, 0x00, 0x7C, 0x2A, 0x92, 0x0E, 0x9C, 0x10, 0x06, 0x1A, 0xA8, +/* 0950 */ 0xBF, 0x10, 0x07, 0x1C, 0xC0, 0x3C, 0xD3, 0x00, 0x63, 0xD3, 0x00, 0x59, 0xD3, 0x82, 0x07, 0x68, +/* 0960 */ 0x77, 0x5F, 0xD3, 0x00, 0x07, 0x0D, 0xD3, 0x79, 0xA6, 0x19, 0x74, 0x78, 0x0D, 0x68, 0x0E, 0xCB, +/* 0970 */ 0x06, 0x1C, 0x3D, 0xC7, 0x94, 0xD5, 0xA6, 0x2B, 0x9A, 0x01, 0x05, 0x2A, 0x3D, 0x7E, 0x06, 0x10, +/* 0980 */ 0x07, 0x1C, 0xC0, 0x22, 0xD3, 0xB6, 0x0B, 0xD3, 0x79, 0x74, 0x19, 0x69, 0x86, 0x19, 0x69, 0x7B, +/* 0990 */ 0x19, 0x69, 0x8B, 0x19, 0x74, 0x79, 0x74, 0x19, 0x74, 0x3D, 0x0B, 0x2A, 0xC0, 0x22, 0x10, 0x06, +/* 09A0 */ 0x1C, 0xC1, 0x10, 0x05, 0x1C, 0x6A, 0x0D, 0x1D, 0x29, 0x28, 0x74, 0x2B, 0x6A, 0x07, 0x1D, 0xA7, +/* 09B0 */ 0x10, 0x07, 0x42, 0x56, 0x09, 0x0E, 0x9F, 0x19, 0x66, 0x3C, 0x01, 0x06, 0x44, 0xA6, 0x00, 0x4E, +/* 09C0 */ 0x46, 0xA0, 0x00, 0x3F, 0x2C, 0x28, 0x51, 0x1B, 0x36, 0x23, 0x7C, 0xE5, 0x36, 0x28, 0x41, 0x08, +/* 09D0 */ 0x79, 0x36, 0x19, 0x81, 0x7E, 0x22, 0x10, 0x07, 0x1C, 0x69, 0xD1, 0x1E, 0x86, 0x19, 0x6A, 0x77, +/* 09E0 */ 0x04, 0x19, 0x69, 0xD1, 0x1E, 0x86, 0x10, 0x03, 0x1C, 0xA7, 0xA7, 0x74, 0x10, 0x03, 0x1C, 0xAA, +/* 09F0 */ 0x2A, 0xAA, 0x2A, 0x2C, 0x1D, 0x9D, 0x0C, 0x1B, 0x4C, 0x01, 0x10, 0x06, 0x1C, 0x74, 0x00, 0x51, +/* 0A00 */ 0xD3, 0x01, 0x36, 0xD3, 0x63, 0x00, 0x68, 0x92, 0x1E, 0x68, 0x9A, 0x00, 0x68, 0x04, 0x2C, 0x00, +/* 0A10 */ 0xD3, 0xA0, 0x00, 0xD3, 0x00, 0xC8, 0xD3, 0x7C, 0x84, 0x10, 0x05, 0x1C, 0xA7, 0xA7, 0xFB, 0xA6, +/* 0A20 */ 0x10, 0x09, 0x1C, 0x0B, 0x0D, 0x00, 0x48, 0x0F, 0x04, 0x23, 0x41, 0x93, 0xB6, 0x0E, 0x05, 0x23, +/* 0A30 */ 0x7A, 0x83, 0x41, 0x3B, 0x28, 0x0E, 0x8F, 0x41, 0x08, 0x07, 0x28, 0x74, 0xA4, 0x09, 0x7F, 0x1B, +/* 0A40 */ 0x79, 0x0E, 0x00, 0x9F, 0x90, 0x09, 0x23, 0x70, 0x09, 0x72, 0x05, 0x0A, 0x23, 0x34, 0x78, 0x0E, +/* 0A50 */ 0x00, 0x34, 0x23, 0xA3, 0x23, 0x96, 0x10, 0x07, 0x1C, 0x0F, 0x0A, 0x57, 0xBC, 0x04, 0x10, 0x08, +/* 0A60 */ 0x1B, 0x61, 0xC4, 0xAD, 0xB5, 0x10, 0x06, 0x1C, 0xC0, 0x3C, 0xD3, 0x66, 0x09, 0xD3, 0x00, 0x96, +/* 0A70 */ 0xD3, 0x00, 0x96, 0xD3, 0x82, 0x26, 0xC0, 0x22, 0xD3, 0x2B, 0x29, 0x10, 0x08, 0x1C, 0x3D, 0x7E, +/* 0A80 */ 0x06, 0x2A, 0x9A, 0x02, 0x86, 0x23, 0x9E, 0xA6, 0x1E, 0x6D, 0x47, 0xAD, 0x47, 0x02, 0xA6, 0x1E, +/* 0A90 */ 0x6D, 0x19, 0x9A, 0x02, 0x36, 0x19, 0x82, 0x77, 0x0A, 0x03, 0xAB, 0x06, 0x93, 0x56, 0x10, 0x07, +/* 0AA0 */ 0x1C, 0x6A, 0x0B, 0x02, 0xD3, 0xB6, 0x0B, 0xD3, 0x00, 0x94, 0xD3, 0x66, 0x0A, 0x68, 0x77, 0x67, +/* 0AB0 */ 0xD3, 0x6D, 0x00, 0xD3, 0x01, 0x84, 0xD3, 0xB6, 0x09, 0xD3, 0x9E, 0x74, 0x10, 0x06, 0x1C, 0x89, +/* 0AC0 */ 0x73, 0x19, 0x04, 0x6F, 0x01, 0x75, 0x19, 0xA0, 0x2B, 0x7D, 0x09, 0x02, 0x1B, 0x44, 0x0A, 0x0F, +/* 0AD0 */ 0x2E, 0x7D, 0x05, 0x2B, 0x64, 0x28, 0x48, 0x05, 0x9E, 0x8E, 0x19, 0x81, 0x0E, 0x9F, 0x10, 0x06, +/* 0AE0 */ 0x2A, 0x38, 0x41, 0x0E, 0x6A, 0x06, 0x1D, 0xAA, 0x2A, 0xAA, 0x10, 0x07, 0x42, 0xAB, 0xB1, 0xCB, +/* 0AF0 */ 0x06, 0x1D, 0x38, 0x7B, 0x1E, 0x70, 0x28, 0x33, 0x1E, 0x6D, 0x19, 0x34, 0x1E, 0x3B, 0x28, 0x79, +/* 0B00 */ 0xA6, 0x00, 0x84, 0x28, 0x57, 0x04, 0x4A, 0x1D, 0x99, 0x06, 0x09, 0x1D, 0x80, 0x76, 0x20, 0x0E, +/* 0B10 */ 0x72, 0x2A, 0x57, 0x0D, 0x10, 0x09, 0x1D, 0x38, 0x3B, 0x7C, 0x6E, 0x00, 0x8A, 0x1B, 0xA2, 0x06, +/* 0B20 */ 0x0E, 0x05, 0x9D, 0x07, 0x1B, 0xA3, 0x9D, 0x9B, 0x00, 0x8C, 0x1B, 0x4A, 0x3E, 0x80, 0x00, 0x72, +/* 0B30 */ 0x23, 0x0E, 0x41, 0x7A, 0x00, 0x0E, 0x23, 0x7A, 0x55, 0x41, 0x53, 0x23, 0x66, 0x33, 0xB6, 0x60, +/* 0B40 */ 0x23, 0x9D, 0x0D, 0x06, 0x00, 0x07, 0x9F, 0x23, 0x48, 0x6E, 0x00, 0x04, 0x0F, 0x05, 0x10, 0x06, +/* 0B50 */ 0x1D, 0x38, 0x60, 0x1E, 0x7B, 0x28, 0x79, 0x93, 0x34, 0x2A, 0xB6, 0x60, 0xDE, 0x7D, 0x46, 0x5D, +/* 0B60 */ 0x00, 0x4E, 0x0A, 0x36, 0x1D, 0xA4, 0x6D, 0x2A, 0x34, 0x79, 0x84, 0x23, 0x57, 0x06, 0x00, 0xB6, +/* 0B70 */ 0x09, 0x10, 0x06, 0x38, 0xAC, 0xBD, 0x10, 0x06, 0x30, 0x32, 0x0F, 0x04, 0x39, 0x46, 0x0C, 0x06, +/* 0B80 */ 0x39, 0x46, 0x0C, 0x06, 0x00, 0x4E, 0x46, 0x7B, 0x20, 0x51, 0x2B, 0xD2, 0x84, 0x10, 0x03, 0x61, +/* 0B90 */ 0x39, 0x7E, 0x20, 0xA3, 0xCD, 0xCD, 0xCD, 0x00, 0x39, 0x7E, 0x10, 0x06, 0x62, 0x75, 0x2B, 0xA1, +/* 0BA0 */ 0x20, 0x07, 0x07, 0x2B, 0x55, 0x31, 0x0E, 0x20, 0x57, 0xCC, 0x08, 0x07, 0x2B, 0xC9, 0x56, 0x0E, +/* 0BB0 */ 0x31, 0x35, 0x20, 0x9D, 0x06, 0x56, 0x01, 0x10, 0x03, 0x3A, 0x06, 0x5D, 0x2B, 0x34, 0x2B, 0xBA, +/* 0BC0 */ 0xBA, 0x34, 0x1E, 0x4C, 0x5D, 0x10, 0x06, 0x24, 0x41, 0x0A, 0x20, 0xA3, 0x36, 0x1D, 0xA4, 0x8A, +/* 0BD0 */ 0x2A, 0x51, 0x1E, 0x36, 0x10, 0x06, 0x1F, 0x1A, 0x4B, 0xD2, 0x43, 0x10, 0x03, 0x3A, 0x02, 0xCC, +/* 0BE0 */ 0x53, 0xD8, 0x9E, 0x10, 0x06, 0x18, 0xB3, 0x10, 0x06, 0xB9, 0x5D, 0xC6, 0x68, 0x08, 0x9C, 0x10, +/* 0BF0 */ 0x05, 0x18, 0x96, 0xD9, 0x34, 0x56, 0x2C, 0x7C, 0x1D, 0x96, 0x73, 0x10, 0x06, 0x38, 0x07, 0x04, +/* 0C00 */ 0x1D, 0x58, 0x1D, 0x58, 0x19, 0x48, 0x85, 0xC8, 0x19, 0xA9, 0x10, 0x06, 0x18, 0x96, 0xAE, 0xE3, +/* 0C10 */ 0x10, 0x04, 0x3A, 0x48, 0x0E, 0x72, 0x2A, 0x41, 0x6C, 0x20, 0x2C, 0x2A, 0x57, 0x0F, 0x65, 0x20, +/* 0C20 */ 0x0E, 0xCC, 0x0E, 0xCC, 0x0E, 0xCC, 0x0E, 0xCC, 0x0E, 0xCC, 0x2C, 0x10, 0x06, 0x24, 0x62, 0x95, +/* 0C30 */ 0x03, 0x19, 0xB6, 0x77, 0x8C, 0x19, 0x51, 0x48, 0x0A, 0x2A, 0xA2, 0x01, 0x0E, 0x2A, 0x04, 0x5F, +/* 0C40 */ 0x51, 0x19, 0x57, 0x0D, 0xA5, 0x5E, 0x46, 0x3E, 0x7E, 0x09, 0x5E, 0x00, 0x79, 0x7B, 0x19, 0x3B, +/* 0C50 */ 0x79, 0x7B, 0x19, 0x53, 0x5B, 0x08, 0x10, 0x06, 0xB9, 0xCF, 0xCA, 0xDF, 0x10, 0x03, 0xE1, 0xD6, +/* 0C60 */ 0x10, 0x03, 0xE1, 0x27, 0x2B, 0x27, 0xAB, 0xA6, 0x20, 0x3F, 0x2B, 0xC8, 0x1E, 0x4E, 0x10, 0x06, +/* 0C70 */ 0x62, 0x5F, 0x2B, 0x27, 0x02, 0x72, 0x68, 0x82, 0xDE, 0x0F, 0x6D, 0x1E, 0x68, 0x0B, 0x07, 0x20, +/* 0C80 */ 0x6E, 0x84, 0xDC, 0x60, 0xDC, 0x01, 0x86, 0x10, 0x03, 0x3A, 0x50, 0x56, 0xAF, 0x40, 0xAF, 0x40, +/* 0C90 */ 0xAF, 0x40, 0xAF, 0x2A, 0x57, 0x0B, 0x10, 0x09, 0x18, 0x0E, 0x89, 0x76, 0x5A, 0x1E, 0xEC, 0x75, +/* 0CA0 */ 0x73, 0x36, 0x23, 0xA6, 0xB2, 0x23, 0xA6, 0xB2, 0x23, 0xA6, 0xB2, 0x23, 0xA6, 0xB2, 0x23, 0xA6, +/* 0CB0 */ 0xB2, 0x10, 0x06, 0x18, 0x0E, 0x06, 0xCF, 0xCA, 0xDF, 0x10, 0x06, 0x18, 0xBB, 0x10, 0x06, 0x18, +/* 0CC0 */ 0x65, 0x5D, 0xC6, 0xCE, 0x08, 0x10, 0x06, 0x5C, 0x48, 0x85, 0x64, 0x19, 0xA9, 0x1D, 0x58, 0x1D, +/* 0CD0 */ 0x58, 0x1E, 0x4E, 0x04, 0x10, 0x04, 0x18, 0x0E, 0x89, 0x1E, 0x68, 0xD8, 0x69, 0xDC, 0x2B, 0x27, +/* 0CE0 */ 0x10, 0x05, 0x5C, 0x3D, 0x0E, 0xA5, 0x2A, 0x59, 0x00, 0xDD, 0x2A, 0x94, 0xCC, 0x06, 0x5A, 0x02, +/* 0CF0 */ 0x2F, 0x26, 0xDD, 0xB6, 0x26, 0x34, 0x5D, 0x02, 0x10, 0x04, 0x1C, 0x22, 0x1B, 0xD3, 0x1D, 0x41, +/* 0D00 */ 0x0F, 0x43, 0x1B, 0xA7, 0x2C, 0x01, 0x20, 0x07, 0x9C, 0x10, 0x06, 0x5C, 0x01, 0x45, 0xB7, 0x04, +/* 0D10 */ 0x10, 0x05, 0x5C, 0x8C, 0x1E, 0x93, 0x19, 0xA2, 0x53, 0x2A, 0x70, 0x7F, 0x1D, 0x93, 0xA1, 0x2A, +/* 0D20 */ 0x83, 0x93, 0x1D, 0x59, 0x0B, 0xAB, 0x0F, 0x07, 0x10, 0x08, 0x5C, 0x3B, 0x00, 0x9A, 0x7F, 0x23, +/* 0D30 */ 0x7F, 0x41, 0x0C, 0x00, 0x83, 0x1B, 0x48, 0x0A, 0x3D, 0x0C, 0x00, 0x35, 0x1B, 0x9E, 0x86, 0x60, +/* 0D40 */ 0x7D, 0x19, 0x0E, 0x52, 0x07, 0x92, 0x23, 0x57, 0xA5, 0x34, 0x09, 0x28, 0x9D, 0x0F, 0x9E, 0x0F, +/* 0D50 */ 0x07, 0x10, 0x05, 0x5C, 0x6D, 0x00, 0x8A, 0x5E, 0x84, 0x36, 0x1D, 0x92, 0x0A, 0x1B, 0x44, 0x0F, +/* 0D60 */ 0x06, 0x20, 0x63, 0x0D, 0x1D, 0x70, 0x3B, 0x2A, 0x64, 0x7C, 0x93, 0x10, 0x05, 0x5C, 0xC3, 0x07, +/* 0D70 */ 0x10, 0x05, 0x5C, 0x89, 0x77, 0x06, 0x1B, 0x44, 0x93, 0x20, 0x64, 0x39, 0x46, 0x7B, 0x20, 0x59, +/* 0D80 */ 0x1D, 0x57, 0x32, 0x05, 0x10, 0x04, 0x24, 0x06, 0x46, 0x0D, 0xCC, 0x93, 0xB0, 0x93, 0xAB, 0x0E, +/* 0D90 */ 0x20, 0x66, 0x09, 0x56, 0x93, 0xB0, 0x93, 0xB0, 0x36, 0x1B, 0x4C, 0x0D, 0x10, 0x04, 0x24, 0x8A, +/* 0DA0 */ 0x2B, 0xB4, 0xB4, 0x8A, 0x10, 0x04, 0x23, 0x1F, 0x07, 0x67, 0x2B, 0x83, 0x2B, 0x88, 0x2B, 0x88, +/* 0DB0 */ 0x2B, 0x88, 0x2B, 0x99, 0xD5, 0x2C, 0x20, 0x2D, 0x88, 0x2B, 0x88, 0x2B, 0x88, 0x2B, 0x83, 0x20, +/* 0DC0 */ 0x07, 0x67, 0x10, 0x05, 0x4B, 0x4A, 0x4F, 0x07, 0x19, 0x48, 0x03, 0x06, 0x8B, 0x10, 0x00, 0x00, +/* 0DD0 */ 0x00, 0x03, 0x00, 0x14, 0x00, 0x32, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x8D, 0x00, 0x94, 0x00, 0xB9, +/* 0DE0 */ 0x00, 0xBE, 0x00, 0xE7, 0x01, 0x00, 0x01, 0x1D, 0x01, 0x25, 0x01, 0x2A, 0x01, 0x4D, 0x01, 0x52, +/* 0DF0 */ 0x01, 0x63, 0x01, 0x6D, 0x01, 0x81, 0x01, 0x92, 0x01, 0x9D, 0x01, 0xB8, 0x01, 0xE6, 0x01, 0xEA, +/* 0E00 */ 0x01, 0xF4, 0x02, 0x00, 0x02, 0x1A, 0x02, 0x37, 0x02, 0x4A, 0x02, 0x71, 0x02, 0x95, 0x02, 0xAF, +/* 0E10 */ 0x02, 0xB9, 0x02, 0xC5, 0x02, 0xD0, 0x02, 0xDA, 0x02, 0xE4, 0x02, 0xF2, 0x03, 0x18, 0x03, 0x31, +/* 0E20 */ 0x03, 0x3B, 0x03, 0x45, 0x03, 0x50, 0x03, 0x57, 0x03, 0x62, 0x03, 0x6D, 0x03, 0x7B, 0x03, 0x86, +/* 0E30 */ 0x03, 0xAF, 0x03, 0xBF, 0x03, 0xCE, 0x03, 0xDC, 0x03, 0xE8, 0x03, 0xF5, 0x03, 0xFD, 0x04, 0x13, +/* 0E40 */ 0x04, 0x4A, 0x04, 0x54, 0x04, 0x5D, 0x04, 0x69, 0x04, 0x71, 0x04, 0x7B, 0x04, 0x92, 0x04, 0xB2, +/* 0E50 */ 0x04, 0xBC, 0x04, 0xC7, 0x04, 0xD3, 0x04, 0xE0, 0x04, 0xE8, 0x04, 0xF5, 0x05, 0x1F, 0x05, 0x31, +/* 0E60 */ 0x05, 0x3F, 0x05, 0x4C, 0x05, 0x58, 0x05, 0x62, 0x05, 0x6D, 0x05, 0x79, 0x05, 0x84, 0x05, 0x8E, +/* 0E70 */ 0x05, 0xB2, 0x05, 0xC0, 0x05, 0xC6, 0x05, 0xD2, 0x05, 0xDD, 0x05, 0xE5, 0x05, 0xED, 0x05, 0xFB, +/* 0E80 */ 0x06, 0x25, 0x06, 0x2D, 0x06, 0x3A, 0x06, 0x47, 0x06, 0x51, 0x06, 0x5D, 0x06, 0x64, 0x03, 0x00, +/* 0E90 */ 0x10, 0x03, 0xDB, 0x03, 0x46, 0x81, 0x21, 0x5E, 0x46, 0x4A, 0xD5, 0x46, 0x7D, 0x2B, 0x3F, 0x2B, +/* 0EA0 */ 0x3F, 0x10, 0x05, 0x1C, 0x48, 0xD8, 0xD7, 0x20, 0x91, 0x08, 0x5E, 0x2C, 0x9E, 0x2A, 0x51, 0x2B, +/* 0EB0 */ 0x59, 0x2B, 0x94, 0x56, 0x0E, 0x05, 0x01, 0x03, 0x1D, 0x94, 0x73, 0x4E, 0xD8, 0x04, 0x07, 0x10, +/* 0EC0 */ 0x06, 0x1C, 0x82, 0x9C, 0x1D, 0xA2, 0x06, 0x01, 0x2A, 0x3B, 0x2B, 0x3B, 0x00, 0x4E, 0x6A, 0x08, +/* 0ED0 */ 0x1D, 0x3B, 0x2B, 0x3B, 0x2B, 0xA5, 0x1D, 0x9D, 0x6A, 0x93, 0x10, 0x06, 0x20, 0x1A, 0x7C, 0x01, +/* 0EE0 */ 0x1E, 0x95, 0x19, 0x34, 0x5B, 0x7B, 0x2A, 0x6F, 0x01, 0x6F, 0x19, 0x81, 0x57, 0x03, 0x2A, 0x72, +/* 0EF0 */ 0x01, 0x6F, 0x19, 0x34, 0x5B, 0x7B, 0x28, 0x7C, 0x01, 0x00, 0x79, 0x03, 0x10, 0x06, 0x19, 0x38, +/* 0F00 */ 0x57, 0x06, 0x58, 0x19, 0x70, 0x01, 0x93, 0x2A, 0x8C, 0x7F, 0x1D, 0x53, 0x6F, 0x2A, 0x82, 0x7E, +/* 0F10 */ 0x0A, 0x20, 0x64, 0x40, 0x77, 0x85, 0x20, 0x64, 0x2B, 0x64, 0x10, 0x04, 0x24, 0xB4, 0x1B, 0x1F, +/* 0F20 */ 0xB4, 0x10, 0x06, 0x1C, 0x05, 0x5B, 0x08, 0x1D, 0x36, 0x7C, 0x2A, 0x7A, 0x06, 0x2F, 0x5A, 0x03, +/* 0F30 */ 0x2A, 0x98, 0x48, 0x0E, 0x00, 0x44, 0x84, 0x00, 0x0E, 0x1D, 0x94, 0xC8, 0x2B, 0x60, 0x2A, 0x7C, +/* 0F40 */ 0x00, 0x59, 0x2A, 0x3D, 0x0D, 0xA5, 0x10, 0x04, 0x3A, 0x37, 0x0A, 0x10, 0x09, 0x1A, 0x51, 0x5A, +/* 0F50 */ 0x02, 0x19, 0x80, 0x0A, 0x0D, 0x09, 0x5F, 0x1B, 0x57, 0x80, 0x79, 0x6B, 0x1B, 0x57, 0xD7, 0x1E, +/* 0F60 */ 0x66, 0x1B, 0x57, 0x55, 0x79, 0x66, 0x28, 0x67, 0x09, 0x8B, 0x6B, 0x28, 0x80, 0x02, 0x7C, 0x5F, +/* 0F70 */ 0x19, 0x51, 0x5D, 0x03, 0x10, 0x05, 0x1C, 0x0A, 0x0E, 0x5F, 0x40, 0x3E, 0xDE, 0x0A, 0x77, 0x05, +/* 0F80 */ 0x2A, 0x96, 0x82, 0x06, 0x2A, 0x50, 0x0D, 0x7F, 0x19, 0x61, 0x39, 0x32, 0x0C, 0x10, 0x06, 0x18, +/* 0F90 */ 0x9E, 0x00, 0x9E, 0x00, 0x44, 0x6F, 0x99, 0x2A, 0x7B, 0x04, 0x6F, 0x19, 0x94, 0x3E, 0x07, 0x5E, +/* 0FA0 */ 0x86, 0x94, 0x1D, 0x53, 0xB6, 0x07, 0x1D, 0x04, 0x00, 0x95, 0x10, 0x06, 0x4B, 0x91, 0x7E, 0x56, +/* 0FB0 */ 0x46, 0x50, 0x10, 0x04, 0x4B, 0x91, 0x0A, 0x10, 0x07, 0x61, 0x56, 0x08, 0x9B, 0x01, 0x2A, 0x63, +/* 0FC0 */ 0x88, 0x09, 0x44, 0x7F, 0x02, 0x99, 0x01, 0x28, 0x04, 0xD7, 0xA5, 0x06, 0x03, 0x23, 0x9E, 0x07, +/* 0FD0 */ 0x71, 0xD7, 0x01, 0x19, 0xA1, 0x05, 0x09, 0x5E, 0x08, 0x9B, 0x10, 0x04, 0x3A, 0x4D, 0x8E, 0x10, +/* 0FE0 */ 0x06, 0x42, 0x2F, 0x0D, 0x06, 0x1D, 0x04, 0x09, 0x41, 0x1D, 0x04, 0x09, 0x41, 0x1D, 0x66, 0x9F, +/* 0FF0 */ 0x10, 0x05, 0x5C, 0x57, 0xCC, 0xB8, 0x31, 0x39, 0x32, 0x0B, 0x10, 0x04, 0x3A, 0x82, 0x36, 0x1E, +/* 1000 */ 0x44, 0x03, 0x06, 0x2E, 0xC5, 0xAB, 0x5F, 0x1D, 0x66, 0x03, 0x39, 0x0F, 0x0E, 0x09, 0x10, 0x04, +/* 1010 */ 0x3A, 0x82, 0x36, 0x40, 0x03, 0x05, 0x2E, 0xC5, 0x39, 0x0E, 0xCC, 0x80, 0x1D, 0x81, 0x7B, 0x10, +/* 1020 */ 0x03, 0x1E, 0x61, 0x39, 0x20, 0x53, 0x08, 0x1B, 0x44, 0x01, 0x10, 0x06, 0x24, 0x38, 0x8D, 0xA4, +/* 1030 */ 0x8D, 0xA4, 0x8D, 0xA4, 0x8D, 0xA4, 0x8D, 0x7B, 0x2A, 0x6E, 0x3F, 0x05, 0x2A, 0x7E, 0x63, 0x07, +/* 1040 */ 0x68, 0x23, 0x68, 0x2B, 0x9D, 0x10, 0x08, 0x1C, 0x98, 0x6A, 0x08, 0x28, 0x41, 0x87, 0x8F, 0x1B, +/* 1050 */ 0xEC, 0x87, 0x8F, 0x19, 0x0E, 0x87, 0x8F, 0x19, 0x07, 0x87, 0x8F, 0x19, 0x7C, 0x8C, 0x8F, 0x1D, +/* 1060 */ 0x76, 0x8F, 0x1D, 0x76, 0x8F, 0x1D, 0x76, 0x8F, 0x1D, 0x76, 0x8F, 0x1D, 0x76, 0x8F, 0x1D, 0x07, +/* 1070 */ 0x04, 0x05, 0x06, 0x10, 0x03, 0x4B, 0x49, 0x10, 0x03, 0x5C, 0xDB, 0x67, 0x2B, 0xC9, 0x1E, 0x4C, +/* 1080 */ 0x43, 0x10, 0x04, 0x1C, 0x4D, 0xAB, 0x51, 0x2B, 0x41, 0x2B, 0x41, 0x2B, 0x41, 0x10, 0x05, 0x1C, +/* 1090 */ 0x4D, 0x35, 0x19, 0x7C, 0x6F, 0x6D, 0x19, 0x48, 0x0A, 0x00, 0x53, 0x19, 0x7C, 0x6F, 0x6D, 0x2A, +/* 10A0 */ 0x9D, 0x5A, 0x02, 0x1E, 0x38, 0x91, 0x5D, 0x10, 0x06, 0x5C, 0x9E, 0x9E, 0x1E, 0x44, 0x6F, 0x99, +/* 10B0 */ 0x1D, 0x07, 0x3C, 0x86, 0x5E, 0x6E, 0x07, 0x0B, 0x4C, 0x5F, 0x8B, 0x28, 0x79, 0x72, 0x07, 0x09, +/* 10C0 */ 0x5E, 0x03, 0x00, 0x6C, 0x10, 0x0A, 0x1C, 0xD0, 0x7C, 0x26, 0x0C, 0x00, 0xE0, 0x19, 0x41, 0x9E, +/* 10D0 */ 0x0A, 0xE0, 0x19, 0xB6, 0x6C, 0xBE, 0x06, 0x10, 0x0A, 0x1C, 0xD0, 0x7C, 0x26, 0x0C, 0x00, 0x66, +/* 10E0 */ 0x94, 0x5F, 0x1B, 0x41, 0x9E, 0x0A, 0xDD, 0x88, 0x28, 0xB6, 0x04, 0x00, 0xB6, 0x04, 0x28, 0x82, +/* 10F0 */ 0x1E, 0x55, 0x19, 0x52, 0x79, 0x67, 0x28, 0x41, 0x1E, 0x89, 0x65, 0x23, 0x04, 0x06, 0x10, 0x0A, +/* 1100 */ 0x1D, 0x38, 0x98, 0x8E, 0x1E, 0x04, 0x06, 0x23, 0x79, 0x8F, 0x1E, 0x67, 0x28, 0x04, 0x2C, 0x7C, +/* 1110 */ 0x26, 0x55, 0xE0, 0x23, 0x79, 0x02, 0x04, 0x4F, 0x0A, 0xE0, 0x1B, 0x81, 0x0B, 0x03, 0x09, 0x6C, +/* 1120 */ 0xBE, 0x06, 0x10, 0x05, 0x00, 0xDB, 0x41, 0x06, 0x2F, 0x04, 0x1F, 0x9D, 0x04, 0xAB, 0x2C, 0x1D, +/* 1130 */ 0x50, 0x08, 0x20, 0x60, 0x2B, 0x60, 0x48, 0x05, 0x2A, 0x82, 0x5D, 0x02, 0x10, 0x06, 0x24, 0x3D, +/* 1140 */ 0xCC, 0xC9, 0x03, 0x20, 0xA8, 0xBF, 0x10, 0x06, 0x25, 0x5E, 0x09, 0x03, 0x20, 0x3B, 0x01, 0x20, +/* 1150 */ 0xA8, 0xBF, 0x10, 0x06, 0x21, 0x0A, 0x72, 0x1D, 0x37, 0x09, 0x1F, 0xA8, 0xBF, 0x10, 0x06, 0x1E, +/* 1160 */ 0x31, 0x7C, 0xC2, 0x07, 0x1F, 0xA8, 0xBF, 0x10, 0x06, 0x24, 0x05, 0x07, 0x02, 0x0A, 0x1F, 0xA8, +/* 1170 */ 0xBF, 0x10, 0x06, 0x1E, 0x66, 0x72, 0x1D, 0x82, 0x90, 0x1D, 0x66, 0x72, 0x1F, 0xA8, 0xBF, 0x10, +/* 1180 */ 0x09, 0x1C, 0x48, 0x6A, 0x5D, 0x28, 0x66, 0x9A, 0x5E, 0x0E, 0xA3, 0x4E, 0x67, 0x0E, 0x1D, 0x64, +/* 1190 */ 0x00, 0x32, 0x0A, 0x28, 0x2C, 0x00, 0x8C, 0x19, 0x04, 0x6A, 0x73, 0x28, 0x9B, 0x1E, 0x59, 0x19, +/* 11A0 */ 0x2C, 0x00, 0x7C, 0x6A, 0x04, 0x10, 0x06, 0x1C, 0x3D, 0xC7, 0x94, 0xD5, 0x74, 0x1D, 0x57, 0x3C, +/* 11B0 */ 0x03, 0x06, 0x2A, 0x3D, 0x0F, 0x0D, 0xDE, 0x66, 0x04, 0xD5, 0x6F, 0x1D, 0x4A, 0x0A, 0x10, 0x06, +/* 11C0 */ 0x24, 0x01, 0x4F, 0x00, 0x39, 0x4F, 0x1D, 0xC1, 0x10, 0x06, 0x25, 0x5E, 0x09, 0x02, 0x40, 0x83, +/* 11D0 */ 0x20, 0xC1, 0x10, 0x06, 0x21, 0x0B, 0x5F, 0x00, 0x4C, 0x05, 0x6B, 0x25, 0xC1, 0x10, 0x06, 0x24, +/* 11E0 */ 0x37, 0x09, 0x25, 0xC1, 0x10, 0x03, 0x23, 0x1F, 0x07, 0x06, 0xD5, 0x2D, 0xA7, 0xA7, 0x74, 0x10, +/* 11F0 */ 0x03, 0x24, 0xD7, 0x20, 0x7F, 0x02, 0x2B, 0xA7, 0xA7, 0x74, 0x10, 0x03, 0x23, 0x39, 0x0E, 0x06, +/* 1200 */ 0x40, 0x22, 0x09, 0x02, 0x1F, 0xA7, 0xA7, 0x74, 0x10, 0x03, 0x1B, 0x1F, 0x82, 0x66, 0x03, 0x1F, +/* 1210 */ 0xA7, 0xA7, 0x74, 0x10, 0x07, 0x1C, 0x0D, 0x7E, 0x4F, 0x2A, 0x86, 0x00, 0x07, 0x0D, 0x2A, 0x86, +/* 1220 */ 0x1E, 0x8E, 0x19, 0x86, 0x57, 0x06, 0x23, 0x66, 0x0F, 0x85, 0x00, 0x64, 0x19, 0x86, 0x57, 0x07, +/* 1230 */ 0x19, 0x86, 0x1E, 0x8E, 0x19, 0x86, 0x9D, 0x0D, 0x19, 0x7A, 0x7E, 0x3C, 0x10, 0x07, 0x28, 0x2F, +/* 1240 */ 0x83, 0x04, 0x1D, 0x71, 0x72, 0x00, 0x31, 0x68, 0x0A, 0x57, 0xBC, 0x04, 0x10, 0x08, 0x00, 0x24, +/* 1250 */ 0xD7, 0x01, 0xAB, 0x8A, 0x1D, 0x3D, 0x7E, 0x06, 0xDA, 0xAD, 0xB5, 0x10, 0x08, 0x61, 0xC9, 0x39, +/* 1260 */ 0x09, 0x03, 0x1D, 0x3D, 0x7E, 0x06, 0xDA, 0xAD, 0xB5, 0x10, 0x08, 0x21, 0x4A, 0x09, 0x1D, 0xB6, +/* 1270 */ 0x02, 0x52, 0xC4, 0xAD, 0xB5, 0x10, 0x08, 0x21, 0x08, 0x0B, 0x04, 0xDE, 0x08, 0x04, 0x72, 0xC4, +/* 1280 */ 0xAD, 0xB5, 0x10, 0x08, 0x24, 0xE0, 0x52, 0xC4, 0xAD, 0xB5, 0x10, 0x05, 0xDB, 0x01, 0x08, 0x00, +/* 1290 */ 0x04, 0xDE, 0x09, 0x09, 0x72, 0x1E, 0x44, 0x0F, 0x09, 0x40, 0xA4, 0x8C, 0x2A, 0x7C, 0x79, 0x02, +/* 12A0 */ 0x10, 0x08, 0x61, 0x9E, 0x04, 0x2B, 0x8F, 0x2A, 0x3D, 0x77, 0x08, 0x28, 0x57, 0x08, 0x66, 0x86, +/* 12B0 */ 0x28, 0x7D, 0x79, 0x09, 0x6D, 0x28, 0x51, 0x48, 0x05, 0x96, 0x28, 0x59, 0x9D, 0x01, 0x3F, 0x28, +/* 12C0 */ 0x51, 0x66, 0x00, 0x34, 0x23, 0x9E, 0x93, 0x09, 0x00, 0x6D, 0x23, 0x57, 0x8C, 0x02, 0x86, 0x28, +/* 12D0 */ 0x79, 0x0E, 0x7E, 0x06, 0x1D, 0x46, 0x95, 0x10, 0x07, 0x24, 0x9D, 0x06, 0xD5, 0x08, 0x07, 0x5E, +/* 12E0 */ 0xB1, 0xCB, 0x07, 0x61, 0x8F, 0x20, 0x7F, 0x02, 0x5E, 0xB1, 0xCB, 0x07, 0x2A, 0x4E, 0x0E, 0x05, +/* 12F0 */ 0x40, 0x22, 0x3C, 0x1D, 0x56, 0xB1, 0xCB, 0x07, 0x24, 0x82, 0xE0, 0x1D, 0x56, 0xB1, 0xCB, 0x06, +/* 1300 */ 0x1F, 0x44, 0x3C, 0x1E, 0x44, 0x83, 0xAC, 0xBD, 0x10, 0x06, 0x1C, 0x29, 0x28, 0xC0, 0x4F, 0xD3, +/* 1310 */ 0x01, 0x09, 0x0B, 0xD3, 0x00, 0x96, 0xD3, 0x01, 0x09, 0x0A, 0x2A, 0xC0, 0x4F, 0x2A, 0x29, 0x10, +/* 1320 */ 0x06, 0x62, 0x53, 0x9F, 0x1D, 0x7B, 0x01, 0x93, 0x2A, 0xA6, 0x01, 0x93, 0x2A, 0xA6, 0x88, 0xDC, +/* 1330 */ 0x72, 0xDC, 0x06, 0x6F, 0x8D, 0x08, 0x0B, 0x8D, 0x02, 0x0F, 0x8D, 0x96, 0x68, 0x50, 0x8E, 0x10, +/* 1340 */ 0x06, 0x62, 0x95, 0xD5, 0x0A, 0x3C, 0xD5, 0x20, 0xB3, 0x10, 0x06, 0x42, 0x05, 0x20, 0x53, 0x08, +/* 1350 */ 0xAB, 0x01, 0x2B, 0xB3, 0x10, 0x06, 0x62, 0x4A, 0x0A, 0x1D, 0xB6, 0x03, 0x07, 0x06, 0x25, 0xB3, +/* 1360 */ 0x10, 0x06, 0x62, 0x07, 0x0B, 0x04, 0x06, 0x1D, 0x07, 0x03, 0x36, 0x25, 0xB3, 0x10, 0x06, 0x3A, +/* 1370 */ 0xE0, 0x52, 0x23, 0x61, 0xB3, 0x10, 0x06, 0x24, 0x4A, 0x0A, 0x20, 0x90, 0x67, 0x1D, 0x4A, 0x0A, +/* 1380 */ 0x1F, 0xB3, 0x10, 0x09, 0x5C, 0x3E, 0x7E, 0x80, 0x0E, 0x09, 0x23, 0x9E, 0x48, 0x0F, 0x06, 0x00, +/* 1390 */ 0x83, 0x44, 0xA6, 0x78, 0x09, 0x1B, 0xB6, 0x0D, 0x0E, 0x6A, 0x9C, 0x1E, 0x78, 0x5F, 0x00, 0xA6, +/* 13A0 */ 0x19, 0x92, 0x48, 0x65, 0x7C, 0x01, 0x1B, 0x50, 0x9C, 0x98, 0x5D, 0x02, 0x10, 0x05, 0x18, 0x96, +/* 13B0 */ 0xD9, 0x51, 0x56, 0x6E, 0x7C, 0x4E, 0x0E, 0x73, 0x4E, 0xD8, 0x3D, 0xDE, 0x66, 0x72, 0x10, 0x06, +/* 13C0 */ 0x62, 0x48, 0x00, 0x2F, 0x0B, 0x02, 0x56, 0x01, 0x1D, 0x96, 0xAE, 0xE3, 0x10, 0x06, 0x42, 0x05, +/* 13D0 */ 0x20, 0x82, 0x3C, 0x1B, 0x44, 0x2B, 0x96, 0xAE, 0xE3, 0x10, 0x06, 0x3A, 0x57, 0x5F, 0x1D, 0x52, +/* 13E0 */ 0x6B, 0x25, 0x96, 0xAE, 0xE3, 0x10, 0x06, 0x62, 0x52, 0x6B, 0x23, 0x61, 0x96, 0xAE, 0xE3, 0x10, +/* 13F0 */ 0x03, 0x3A, 0xDD, 0x2B, 0x34, 0x06, 0x00, 0xD5, 0x2B, 0xD6, 0x10, 0x03, 0x61, 0xD5, 0x03, 0x20, +/* 1400 */ 0xA0, 0xDE, 0x9E, 0x00, 0x31, 0xD6, 0x10, 0x03, 0x3A, 0x05, 0x0E, 0x05, 0x40, 0x4F, 0x3C, 0x1F, +/* 1410 */ 0xD6, 0x10, 0x03, 0x1D, 0x61, 0x81, 0x3E, 0x02, 0x28, 0x61, 0xD6, 0x10, 0x06, 0x62, 0x04, 0x02, +/* 1420 */ 0x07, 0x03, 0x4E, 0x5B, 0x20, 0x98, 0x63, 0x56, 0x93, 0x4C, 0x5A, 0x8B, 0x44, 0x84, 0x02, 0x9F, +/* 1430 */ 0x19, 0xA3, 0x1E, 0x99, 0x19, 0xA3, 0x1E, 0x3B, 0x44, 0x84, 0x02, 0x84, 0x4C, 0x5B, 0x06, 0x10, +/* 1440 */ 0x06, 0x62, 0x4A, 0xD7, 0x4E, 0x55, 0x08, 0x25, 0x0E, 0x06, 0xCF, 0xCA, 0xDF, 0x10, 0x06, 0xD4, +/* 1450 */ 0x02, 0x1D, 0xBB, 0x10, 0x06, 0x42, 0x6C, 0x1D, 0x3D, 0x0B, 0x02, 0x1B, 0x44, 0x2B, 0xBB, 0x10, +/* 1460 */ 0x06, 0x62, 0x66, 0x6F, 0x1D, 0xC5, 0x03, 0x09, 0x25, 0xBB, 0x10, 0x06, 0x3A, 0x7C, 0xC2, 0x07, +/* 1470 */ 0x25, 0xBB, 0x10, 0x06, 0x62, 0x37, 0x09, 0x23, 0x61, 0xBB, 0x10, 0x05, 0x1C, 0x66, 0xCC, 0x86, +/* 1480 */ 0x23, 0x61, 0x91, 0x5D, 0x25, 0x66, 0xCC, 0x86, 0x10, 0x06, 0x23, 0x38, 0x4E, 0x2B, 0x81, 0x1D, +/* 1490 */ 0x96, 0x5D, 0x5E, 0x2C, 0x09, 0x7B, 0x19, 0x80, 0x00, 0x3B, 0x09, 0x28, 0x78, 0x4F, 0x52, 0x0A, +/* 14A0 */ 0x19, 0xA3, 0x06, 0x03, 0xA2, 0x23, 0x79, 0x0E, 0x67, 0xA4, 0x4C, 0x0F, 0x0D, 0x08, 0x1D, 0xC5, +/* 14B0 */ 0x2B, 0xDD, 0x10, 0x06, 0xD4, 0x01, 0x5E, 0x45, 0xB7, 0x04, 0x10, 0x06, 0x42, 0x6C, 0x1D, 0x3D, +/* 14C0 */ 0x4F, 0x1B, 0x44, 0xAB, 0x45, 0xB7, 0x04, 0x10, 0x06, 0x62, 0x66, 0x6F, 0x1D, 0x90, 0x04, 0x2E, +/* 14D0 */ 0xAB, 0x45, 0xB7, 0x04, 0x10, 0x06, 0x62, 0x37, 0x09, 0x1F, 0x56, 0x45, 0xB7, 0x04, 0x10, 0x05, +/* 14E0 */ 0x00, 0x62, 0x95, 0x39, 0xC8, 0x1B, 0x44, 0x2B, 0xC3, 0x07, 0x10, 0x06, 0xB9, 0x5A, 0xC6, 0xCE, +/* 14F0 */ 0x08, 0x10, 0x05, 0x62, 0x67, 0x09, 0xCC, 0x1F, 0xC3, 0x07, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, +/* 1500 */ 0x0B, 0x00, 0x05, 0x06, 0x4B, 0xD2, 0x9C, 0x10, 0x06, 0x4B, 0x08, 0x32, 0x8E, 0x10, 0x09, 0x4B, +/* 1510 */ 0x08, 0x32, 0x32, 0x2C, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x05, +/* 1520 */ 0x7D, 0x00, 0x00, 0x05, 0x7F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x05, +/* 1530 */ 0x82, 0x00, 0x00, 0x06, 0x40, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x0D, +/* 1540 */ 0xCE, 0x00, 0x00, 0x0E, 0x8E, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x14, +/* 1550 */ 0xFB, 0x00, 0x00, 0x15, 0x03, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular14.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular14.mcufont.h new file mode 100644 index 000000000..735ab4412 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular14.mcufont.h @@ -0,0 +1,417 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 14 + * blob size: 6309, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x03, 0xCD, 0x00, 0x00, 0x04, 0x48, 0x00, 0x00, 0x00, 0x9A, +/* 0020 */ 0x00, 0x00, 0x00, 0xE5, 0x00, 0x00, 0x18, 0x65, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0D, 0x00, 0x13, 0x00, 0x03, 0x00, 0x0D, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x11, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x31, 0x34, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x31, 0x34, 0x00, +/* dictionary data */ +0x06, 0x0B, 0x16, 0xC9, 0xCD, +/* 0080 */ 0x29, 0x04, 0xCC, 0xC2, 0x80, 0xC2, 0xC4, 0x09, 0x05, 0x03, 0x2A, 0x02, 0x36, 0x08, 0xCC, 0xC3, +/* 0090 */ 0x08, 0x35, 0x0A, 0xC3, 0xCE, 0x80, 0xC5, 0x09, 0xC1, 0xCD, 0xC6, 0x0B, 0xCD, 0xC6, 0x0B, 0x07, +/* 00A0 */ 0xCD, 0x28, 0xCC, 0xC8, 0x07, 0xC6, 0xCD, 0x02, 0xC1, 0x08, 0xEE, 0x1C, 0x40, 0x04, 0x09, 0x01, +/* 00B0 */ 0xCA, 0xCC, 0xC6, 0xCD, 0xC3, 0xC2, 0x80, 0xC3, 0xC1, 0xCA, 0x80, 0xC3, 0xC6, 0x02, 0xCE, 0xC4, +/* 00C0 */ 0x07, 0xCD, 0xC2, 0x0A, 0x81, 0x40, 0x19, 0xCC, 0xC5, 0xC5, 0xCC, 0x08, 0xC1, 0xC7, 0xCC, 0xC3, +/* 00D0 */ 0x80, 0x07, 0xC2, 0xC7, 0xCB, 0xCD, 0xC1, 0xC1, 0x0B, 0xC8, 0xCC, 0xCE, 0xC2, 0x0B, 0xC2, 0xC7, +/* 00E0 */ 0x07, 0xCC, 0xC7, 0x01, 0xC3, 0xCC, 0xC4, 0x80, 0xC2, 0xCC, 0xC7, 0x0B, 0xCC, 0xC7, 0x0B, 0xCE, +/* 00F0 */ 0xC5, 0x01, 0xC1, 0x80, 0xC8, 0xC1, 0xC5, 0xCB, 0xCE, 0xC5, 0xCA, 0xC7, 0x06, 0xC4, 0x80, 0x07, +/* 0100 */ 0xC6, 0xCB, 0x10, 0xCB, 0xCA, 0x0A, 0xC4, 0x80, 0x80, 0xCD, 0xC5, 0xCE, 0xCB, 0xCD, 0xC7, 0xC6, +/* 0110 */ 0xCE, 0xC2, 0xC1, 0xC8, 0xCB, 0xC8, 0xCA, 0xC8, 0x80, 0x11, 0xC2, 0x80, 0xD2, 0xCB, 0xC8, 0xC1, +/* 0120 */ 0x06, 0xD1, 0x15, 0xC4, 0xCE, 0xCC, 0xC7, 0xC7, 0xC9, 0x01, 0xC1, 0x0A, 0x0A, 0xC1, 0xC7, 0x0B, +/* 0130 */ 0x80, 0xC4, 0x02, 0xC2, 0x80, 0xC3, 0x06, 0xCE, 0xC5, 0x02, 0xC2, 0x80, 0xC3, 0x06, 0xCE, 0xC5, +/* 0140 */ 0x0B, 0xC1, 0xC1, 0x01, 0xCD, 0xC6, 0xC8, 0xCD, 0xCC, 0xCA, 0xCA, 0xC2, 0xCA, 0xC8, 0x0C, 0xCC, +/* 0150 */ 0x80, 0xC6, 0xCA, 0xC3, 0x07, 0x1B, 0x01, 0xC1, 0x1D, 0xCE, 0xC3, 0xCA, 0xC9, 0xC9, 0xCB, 0xD8, +/* 0160 */ 0xC4, 0xFE, 0xC8, 0x08, 0xF2, 0xC1, 0xC2, 0xCE, 0xC9, 0xCE, 0xC6, 0xCD, 0xC2, 0xCD, 0x01, 0xC7, +/* 0170 */ 0xCA, 0x01, 0xC8, 0xC7, 0xCD, 0xC4, 0xCD, 0xC5, 0xCA, 0xCB, 0x01, 0xCB, 0x83, 0xCC, 0xC4, 0xDB, +/* 0180 */ 0xCE, 0x80, 0xCE, 0xC4, 0xC8, 0xCE, 0xCC, 0xC9, 0xCE, 0xC7, 0xC5, 0xCD, 0xC1, 0xCB, 0xC9, 0xC8, +/* 0190 */ 0xC4, 0xCD, 0x01, 0xC6, 0xC5, 0x80, 0xCE, 0xC9, 0xDA, 0xC1, 0xC6, 0xCD, 0xC2, 0xC9, 0xCA, 0xC5, +/* 01A0 */ 0xCE, 0xC2, 0xC4, 0x01, 0xC2, 0x40, 0x10, 0xC2, 0xCB, 0xC7, 0xCD, 0xC6, 0xCC, 0x37, 0xC3, 0xC2, +/* 01B0 */ 0x0F, 0xC7, 0xCE, 0xCD, 0xC9, 0x80, 0xC6, 0xC1, 0xC7, 0x80, 0xC1, 0x00, 0xA8, 0x29, 0x82, 0x02, +/* 01C0 */ 0x1A, 0x0B, 0x9E, 0x00, 0x2E, 0x8C, 0x4F, 0x57, 0x5E, 0x24, 0x94, 0x2E, 0x3D, 0x3D, 0x3D, 0x3D, +/* 01D0 */ 0x06, 0x24, 0x94, 0x54, 0x72, 0x72, 0x72, 0x24, 0x3A, 0x18, 0x5E, 0x24, 0x03, 0x1F, 0x18, 0x08, +/* 01E0 */ 0x57, 0x92, 0x4C, 0xAF, 0x21, 0x7F, 0x3C, 0x24, 0x75, 0x56, 0x01, 0x24, 0x75, 0x56, 0x01, 0x21, +/* 01F0 */ 0x7F, 0x66, 0x0D, 0xAB, 0x0A, 0x0C, 0x18, 0x7F, 0x87, 0x0E, 0x06, 0x00, 0x8F, 0x09, 0x57, 0x75, +/* 0200 */ 0x24, 0xA2, 0x57, 0x75, 0x24, 0xA2, 0x57, 0x75, 0x24, 0x67, 0x2E, 0x1E, 0x05, 0x3C, 0x06, 0x1F, +/* 0210 */ 0x18, 0x3A, 0x24, 0x6C, 0x56, 0x01, 0x24, 0x82, 0x56, 0x01, 0x24, 0x82, 0x18, 0x3A, 0x24, 0x6C, +/* 0220 */ 0x18, 0x8F, 0x78, 0x06, 0x0F, 0x74, 0x22, 0x9F, 0x56, 0x01, 0x7F, 0x71, 0x4D, 0x44, 0x26, 0x88, +/* 0230 */ 0x00, 0x8D, 0x36, 0x0E, 0x76, 0x29, 0x07, 0x0F, 0x07, 0x29, 0x45, 0x3E, 0x45, 0x3E, 0x45, 0xA7, +/* 0240 */ 0x5C, 0x57, 0x8F, 0x78, 0x1B, 0x5D, 0x32, 0x04, 0x66, 0x30, 0x19, 0x61, 0x26, 0x42, 0x93, 0x0B, +/* 0250 */ 0x57, 0x03, 0xAF, 0x02, 0x83, 0x31, 0x61, 0x57, 0x04, 0x3C, 0x03, 0x0D, 0x0C, 0x26, 0x87, 0x0C, +/* 0260 */ 0x03, 0x53, 0x36, 0x6B, 0x93, 0x9E, 0x00, 0x46, 0x58, 0x60, 0x36, 0x05, 0x7E, 0x37, 0x05, 0x19, +/* 0270 */ 0x38, 0x7D, 0x51, 0x7D, 0x51, 0x7D, 0x51, 0x7D, 0x51, 0x7D, 0x51, 0x03, 0x4D, 0x63, 0x7D, 0x9B, +/* 0280 */ 0x75, 0x19, 0x54, 0x19, 0x2E, 0x1B, 0x97, 0x26, 0x2D, 0x01, 0xA8, 0x46, 0xB1, 0x24, 0x3C, 0x56, +/* 0290 */ 0x33, 0x71, 0x56, 0x66, 0x66, 0x57, 0x3A, 0x19, 0x92, 0x02, 0x03, 0x08, 0x26, 0xA7, 0x0F, 0x75, +/* 02A0 */ 0x59, 0x00, 0x8D, 0x18, 0x0C, 0x97, 0x24, 0x8D, 0x18, 0x77, 0x0D, 0x24, 0x8D, 0x18, 0x41, 0x94, +/* 02B0 */ 0x00, 0x8D, 0x18, 0x41, 0xA2, 0x00, 0x8D, 0x18, 0x41, 0x03, 0xB1, 0x8D, 0x18, 0x41, 0x00, 0x6C, +/* 02C0 */ 0x8D, 0x18, 0x41, 0x00, 0x88, 0x41, 0x18, 0x41, 0x7F, 0x0E, 0x54, 0x18, 0x41, 0x24, 0x09, 0x02, +/* 02D0 */ 0x0C, 0xA5, 0x39, 0x0A, 0x18, 0x08, 0x06, 0x00, 0x07, 0x08, 0x04, 0x0A, 0x1D, 0x7F, 0x0D, 0x00, +/* 02E0 */ 0x37, 0x0E, 0x0E, 0x2B, 0x1D, 0x07, 0x07, 0x00, 0x7F, 0x02, 0x7C, 0x01, 0x1D, 0x1D, 0x75, 0x00, +/* 02F0 */ 0x0F, 0x09, 0x29, 0x61, 0x0D, 0x29, 0x91, 0x81, 0x43, 0x0E, 0x00, 0x55, 0x26, 0x58, 0x00, 0x58, +/* 0300 */ 0x26, 0x55, 0xA5, 0xB1, 0x57, 0x93, 0x0E, 0x0E, 0x71, 0x18, 0x2A, 0x02, 0x66, 0x82, 0x18, 0x47, +/* 0310 */ 0x22, 0x88, 0x18, 0x30, 0x22, 0x03, 0x1F, 0x28, 0x04, 0x19, 0x36, 0x74, 0x7F, 0x6B, 0x57, 0x44, +/* 0320 */ 0x24, 0x61, 0x57, 0x03, 0xB1, 0x8F, 0x06, 0x26, 0x94, 0x00, 0x1F, 0x26, 0x79, 0x9B, 0x36, 0x58, +/* 0330 */ 0x0F, 0x7D, 0x75, 0x7F, 0x0F, 0x7D, 0x75, 0x00, 0x09, 0x0B, 0x09, 0x4C, 0x26, 0x03, 0x84, 0x2B, +/* 0340 */ 0x73, 0x1A, 0x2C, 0x24, 0x1A, 0x7B, 0x3F, 0x0E, 0x26, 0x30, 0x69, 0x32, 0x50, 0x7B, 0x0E, 0x54, +/* 0350 */ 0x26, 0x30, 0x66, 0x32, 0x50, 0x30, 0x69, 0x32, 0x0C, 0x90, 0x57, 0xAA, 0x9E, 0x00, 0x2E, 0x39, +/* 0360 */ 0x04, 0x71, 0x2E, 0x19, 0x83, 0x19, 0x83, 0x19, 0x88, 0x01, 0x36, 0x03, 0x22, 0x5F, 0x21, 0x4F, +/* 0370 */ 0x22, 0x05, 0xB1, 0x1D, 0x4F, 0x22, 0x05, 0xB1, 0x1D, 0x03, 0x3C, 0x22, 0x5F, 0x18, 0x97, 0x22, +/* 0380 */ 0x8E, 0x18, 0x07, 0x54, 0x4C, 0x71, 0x57, 0xA8, 0x0F, 0x91, 0xAC, 0x06, 0x09, 0x22, 0x7F, 0x82, +/* 0390 */ 0x07, 0x22, 0x1E, 0x18, 0x8B, 0x24, 0x04, 0x0A, 0x57, 0x8B, 0x00, 0x8F, 0x03, 0x0C, 0x3E, 0x03, +/* 03A0 */ 0x81, 0x18, 0x45, 0x00, 0x04, 0xB1, 0x6D, 0x94, 0x19, 0x94, 0x19, 0x18, 0x6C, 0x22, 0x0C, 0x52, +/* 03B0 */ 0x19, 0x67, 0x24, 0x03, 0x26, 0x0C, 0x01, 0x26, 0x92, 0xA4, 0x7D, 0x3A, 0x45, 0x19, 0x45, 0x19, +/* 03C0 */ 0x45, 0x19, 0x45, 0x19, 0x45, 0x19, 0x45, 0x0E, 0x27, 0x0B, 0x09, 0x0F, 0x41, 0x18, 0x9C, 0x54, +/* 03D0 */ 0x4C, 0x71, 0x18, 0x5E, 0x22, 0x8E, 0x21, 0x65, 0x2A, 0x3E, 0x03, 0x3C, 0x29, 0x03, 0x0D, 0x29, +/* 03E0 */ 0x9C, 0x24, 0x0E, 0x06, 0x57, 0x77, 0x4C, 0xAF, 0x57, 0x03, 0x74, 0x7F, 0x6A, 0x65, 0x3E, 0x65, +/* 03F0 */ 0x3E, 0x65, 0x3E, 0x65, 0x2D, 0x2D, 0x36, 0x03, 0x00, 0xA6, 0x53, 0x19, 0x53, 0x19, 0x75, 0x19, +/* 0400 */ 0x2D, 0x18, 0x05, 0x21, 0x04, 0x5E, 0x22, 0x18, 0xA7, 0x5C, 0x50, 0x50, 0x50, 0x50, 0x50, 0x36, +/* 0410 */ 0x80, 0x42, 0x19, 0x21, 0xA6, 0x46, 0x3C, 0x19, 0x3C, 0x19, 0x3C, 0x19, 0xB1, 0x6F, 0xB1, 0x6F, +/* 0420 */ 0x4D, 0x00, 0x06, 0x19, 0x04, 0x0C, 0x45, 0x24, 0x26, 0x65, 0x0B, 0x05, 0x29, 0x7B, 0x6E, 0x58, +/* 0430 */ 0x29, 0x2A, 0x20, 0x04, 0x8D, 0x80, 0x0E, 0x91, 0x04, 0x26, 0x26, 0x04, 0xB1, 0x57, 0x25, 0x0C, +/* 0440 */ 0x3F, 0x0D, 0x08, 0x26, 0x5B, 0x01, 0x5B, 0x6E, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, +/* 0450 */ 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x09, 0x00, 0x0B, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x0F, +/* 0460 */ 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x1A, +/* 0470 */ 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x24, 0x00, 0x26, 0x00, 0x27, 0x00, 0x29, 0x00, 0x2D, 0x00, 0x2F, +/* 0480 */ 0x00, 0x30, 0x00, 0x31, 0x00, 0x33, 0x00, 0x34, 0x00, 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3D, +/* 0490 */ 0x00, 0x3F, 0x00, 0x41, 0x00, 0x47, 0x00, 0x49, 0x00, 0x4A, 0x00, 0x4C, 0x00, 0x4E, 0x00, 0x50, +/* 04A0 */ 0x00, 0x52, 0x00, 0x54, 0x00, 0x56, 0x00, 0x58, 0x00, 0x5A, 0x00, 0x5C, 0x00, 0x5E, 0x00, 0x60, +/* 04B0 */ 0x00, 0x63, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6B, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x79, 0x00, 0x7B, +/* 04C0 */ 0x00, 0x7D, 0x00, 0x7F, 0x00, 0x81, 0x00, 0x84, 0x00, 0x85, 0x00, 0x87, 0x00, 0x88, 0x00, 0x8A, +/* 04D0 */ 0x00, 0x8D, 0x00, 0x90, 0x00, 0x92, 0x00, 0x94, 0x00, 0x96, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, +/* 04E0 */ 0x00, 0x9E, 0x00, 0x9F, 0x00, 0xA1, 0x00, 0xA2, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA7, 0x00, 0xA8, +/* 04F0 */ 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xC5, +/* 0500 */ 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD4, +/* 0510 */ 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDE, 0x00, 0xE0, 0x00, 0xE2, +/* 0520 */ 0x00, 0xE4, 0x00, 0xE5, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF7, +/* 0530 */ 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x01, 0x01, 0x02, 0x01, 0x04, 0x01, 0x05, +/* 0540 */ 0x01, 0x07, 0x01, 0x09, 0x01, 0x0B, 0x01, 0x0D, 0x01, 0x0F, 0x01, 0x11, 0x01, 0x13, 0x01, 0x15, +/* 0550 */ 0x01, 0x17, 0x01, 0x19, 0x01, 0x1B, 0x01, 0x1D, 0x01, 0x1E, 0x01, 0x20, 0x01, 0x22, 0x01, 0x24, +/* 0560 */ 0x01, 0x26, 0x01, 0x28, 0x01, 0x2A, 0x01, 0x2C, 0x01, 0x2E, 0x01, 0x30, 0x01, 0x32, 0x01, 0x33, +/* 0570 */ 0x01, 0x35, 0x01, 0x36, 0x01, 0x38, 0x01, 0x3A, 0x01, 0x3C, 0x01, 0x3E, 0x01, 0x40, 0x01, 0x46, +/* 0580 */ 0x01, 0x58, 0x01, 0x65, 0x01, 0x74, 0x01, 0x77, 0x01, 0x7F, 0x01, 0x93, 0x01, 0xAB, 0x01, 0xC4, +/* 0590 */ 0x01, 0xC9, 0x01, 0xE6, 0x01, 0xF1, 0x01, 0xF6, 0x02, 0x06, 0x02, 0x09, 0x02, 0x0E, 0x02, 0x26, +/* 05A0 */ 0x02, 0x54, 0x02, 0x72, 0x02, 0x75, 0x02, 0x9D, 0x02, 0x9F, 0x02, 0xA2, 0x02, 0xB5, 0x02, 0xBC, +/* 05B0 */ 0x02, 0xBE, 0x02, 0xC7, 0x02, 0xCA, 0x02, 0xE1, 0x02, 0xE8, 0x02, 0xEC, 0x02, 0xEE, 0x02, 0xF0, +/* 05C0 */ 0x03, 0x10, 0x03, 0x22, 0x03, 0x26, 0x03, 0x28, 0x03, 0x2A, 0x03, 0x2C, 0x03, 0x30, 0x03, 0x33, +/* 05D0 */ 0x03, 0x35, 0x03, 0x38, 0x03, 0x3A, 0x03, 0x3C, 0x03, 0x41, 0x03, 0x4C, 0x03, 0x50, 0x03, 0x5D, +/* 05E0 */ 0x03, 0x66, 0x03, 0x6F, 0x03, 0x72, 0x03, 0x79, 0x03, 0x7B, 0x03, 0x7D, 0x03, 0x83, 0x03, 0x86, +/* 05F0 */ 0x03, 0x8C, 0x03, 0x8F, 0x03, 0x96, 0x03, 0x98, 0x03, 0x9B, 0x03, 0xA1, 0x03, 0xA5, 0x03, 0xA7, +/* 0600 */ 0x03, 0xA9, 0x03, 0xAB, 0x03, 0xAD, 0x03, 0xBB, 0x03, 0xBD, 0x03, 0xBF, 0x03, 0xC1, 0x03, 0xC3, +/* 0610 */ 0x03, 0xC9, 0x03, 0xCD, +/* char range info */ +0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x14, 0x00, +/* 0620 */ 0x26, 0x00, 0x56, 0x00, 0x84, 0x00, 0xC2, 0x00, 0xF5, 0x00, 0xFF, 0x01, 0x1F, 0x01, 0x3C, 0x01, +/* 0630 */ 0x54, 0x01, 0x59, 0x01, 0x5F, 0x01, 0x69, 0x01, 0x6F, 0x01, 0x8C, 0x01, 0xB6, 0x01, 0xC8, 0x01, +/* 0640 */ 0xE9, 0x02, 0x0D, 0x02, 0x2D, 0x02, 0x4E, 0x02, 0x78, 0x02, 0x91, 0x02, 0xBA, 0x02, 0xDE, 0x02, +/* 0650 */ 0xE5, 0x02, 0xED, 0x03, 0x03, 0x03, 0x0A, 0x03, 0x21, 0x03, 0x3B, 0x03, 0x92, 0x03, 0x97, 0x03, +/* 0660 */ 0xBB, 0x03, 0xD8, 0x04, 0x00, 0x04, 0x04, 0x04, 0x17, 0x04, 0x46, 0x04, 0x63, 0x04, 0x67, 0x04, +/* 0670 */ 0x77, 0x04, 0x9C, 0x04, 0xAA, 0x04, 0xEC, 0x04, 0xF3, 0x04, 0xF9, 0x05, 0x10, 0x05, 0x44, 0x05, +/* 0680 */ 0x63, 0x05, 0x89, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xC8, 0x06, 0x10, 0x06, 0x38, 0x06, 0x40, 0x06, +/* 0690 */ 0x5F, 0x06, 0x70, 0x06, 0x90, 0x06, 0xA3, 0x06, 0xB6, 0x06, 0xC2, 0x06, 0xCA, 0x06, 0xCF, 0x06, +/* 06A0 */ 0xDA, 0x06, 0xE9, 0x06, 0xFF, 0x07, 0x05, 0x07, 0x20, 0x07, 0x4F, 0x07, 0x55, 0x07, 0x5C, 0x07, +/* 06B0 */ 0x68, 0x07, 0x89, 0x07, 0x9A, 0x07, 0xBB, 0x07, 0xC0, 0x07, 0xC6, 0x07, 0xCF, 0x07, 0xE1, 0x07, +/* 06C0 */ 0xEE, 0x08, 0x0C, 0x08, 0x1F, 0x08, 0x25, 0x08, 0x43, 0x08, 0x77, 0x08, 0x95, 0x08, 0x9C, 0x08, +/* 06D0 */ 0xB5, 0x08, 0xD7, 0x08, 0xE4, 0x08, 0xFD, 0x03, 0x00, 0x10, 0x03, 0x23, 0x73, 0x71, 0x6F, 0xF0, +/* 06E0 */ 0x1F, 0x19, 0x4B, 0x4B, 0x00, 0x73, 0x27, 0x00, 0xA5, 0x94, 0x10, 0x05, 0x28, 0x45, 0x8F, 0x07, +/* 06F0 */ 0x26, 0x86, 0x37, 0x06, 0x43, 0x0E, 0xCB, 0x06, 0x43, 0x0D, 0xCB, 0x05, 0x10, 0x07, 0x25, 0x89, +/* 0700 */ 0x00, 0x4E, 0xF9, 0x0B, 0x00, 0x05, 0x0A, 0x57, 0x05, 0x90, 0xAF, 0x18, 0xCB, 0x52, 0x09, 0x07, +/* 0710 */ 0x57, 0x37, 0x05, 0x8F, 0x05, 0x26, 0x0C, 0x03, 0x00, 0x39, 0x18, 0x8F, 0x0F, 0x0E, 0x93, 0x0E, +/* 0720 */ 0x46, 0x1F, 0x2A, 0x02, 0x57, 0x89, 0x00, 0x4E, 0x26, 0xF4, 0x00, 0x53, 0x10, 0x07, 0x6A, 0x43, +/* 0730 */ 0x0E, 0x73, 0x0E, 0x29, 0x98, 0x0F, 0x0C, 0x03, 0x46, 0x2B, 0x01, 0x05, 0x09, 0x57, 0x9D, 0x19, +/* 0740 */ 0x65, 0x70, 0xA3, 0x5E, 0x6F, 0xAD, 0x0A, 0x19, 0x4F, 0x22, 0x46, 0x1F, 0x21, 0x9C, 0x09, 0xAB, +/* 0750 */ 0x0A, 0x0D, 0x57, 0x3B, 0x93, 0x27, 0x7F, 0x0E, 0x73, 0x0D, 0x10, 0x0A, 0x21, 0x23, 0x60, 0x21, +/* 0760 */ 0x08, 0x5D, 0x74, 0x8F, 0x05, 0x1D, 0x03, 0xA1, 0x09, 0x07, 0x00, 0x42, 0x21, 0x05, 0x09, 0x00, +/* 0770 */ 0x05, 0x0A, 0x00, 0x39, 0x21, 0x4E, 0x00, 0x84, 0x6D, 0x21, 0xCB, 0x0F, 0x0C, 0x2A, 0x6E, 0x55, +/* 0780 */ 0x98, 0x1E, 0x18, 0x03, 0x48, 0x81, 0x07, 0x0A, 0x18, 0x91, 0x4E, 0x00, 0x89, 0x21, 0x58, 0x7F, +/* 0790 */ 0x0E, 0x02, 0x58, 0x21, 0x1E, 0x24, 0x5F, 0x39, 0x10, 0x09, 0xAA, 0x87, 0x75, 0xF9, 0x81, 0x4F, +/* 07A0 */ 0x57, 0xA9, 0x24, 0x3C, 0x46, 0x81, 0x44, 0x36, 0xAD, 0x0C, 0x74, 0x68, 0x03, 0x9E, 0xA1, 0x00, +/* 07B0 */ 0x8D, 0x21, 0x30, 0x00, 0x88, 0xA3, 0x01, 0x21, 0x0E, 0x06, 0x24, 0x07, 0x0F, 0x08, 0x21, 0x8F, +/* 07C0 */ 0x0C, 0x66, 0x1B, 0x0E, 0x02, 0x21, 0xA7, 0x0E, 0x9E, 0x01, 0x84, 0x10, 0x03, 0x28, 0x45, 0x19, +/* 07D0 */ 0x86, 0x73, 0x0E, 0x73, 0x0D, 0x10, 0x04, 0x80, 0x05, 0x04, 0x6F, 0x81, 0x29, 0x62, 0x19, 0x54, +/* 07E0 */ 0x1D, 0xD6, 0x6E, 0x88, 0x19, 0x44, 0x19, 0x44, 0xD1, 0x19, 0x6B, 0x73, 0x94, 0x29, 0xCB, 0x09, +/* 07F0 */ 0x1D, 0x46, 0x4B, 0x07, 0x06, 0x10, 0x04, 0x7E, 0x03, 0xF3, 0x02, 0x4B, 0x62, 0x24, 0xE8, 0xB1, +/* 0800 */ 0xC0, 0x67, 0x19, 0x82, 0x19, 0x82, 0xDC, 0x36, 0x75, 0x29, 0x65, 0x3E, 0x47, 0x6F, 0x94, 0x24, +/* 0810 */ 0xF9, 0x09, 0x10, 0x06, 0x1C, 0x37, 0x06, 0x36, 0x66, 0x09, 0x05, 0x04, 0x01, 0x57, 0x88, 0x0E, +/* 0820 */ 0x0D, 0x27, 0x89, 0x0C, 0x29, 0x38, 0x79, 0xE8, 0x00, 0x60, 0x10, 0x06, 0xE9, 0xBD, 0x0B, 0x10, +/* 0830 */ 0x03, 0x35, 0x40, 0xE3, 0x07, 0x10, 0x05, 0x80, 0x40, 0x2A, 0x0E, 0x54, 0x36, 0x66, 0x60, 0x10, +/* 0840 */ 0x03, 0x29, 0xAA, 0xEF, 0xD5, 0x10, 0x07, 0x1A, 0xE8, 0x7A, 0x0E, 0x3E, 0x2A, 0x19, 0x7C, 0x29, +/* 0850 */ 0x37, 0x70, 0x81, 0x29, 0x86, 0x19, 0x58, 0x29, 0xCB, 0x70, 0x8C, 0x6F, 0x0F, 0x6E, 0xEE, 0x9A, +/* 0860 */ 0x19, 0xAB, 0x10, 0x07, 0x25, 0x99, 0x0F, 0x27, 0x09, 0x1E, 0x76, 0x26, 0x54, 0x24, 0x71, 0x21, +/* 0870 */ 0xA5, 0x1F, 0x24, 0x5E, 0xD6, 0x01, 0x24, 0x30, 0xD6, 0x01, 0x24, 0x30, 0x21, 0xA5, 0x1F, 0x24, +/* 0880 */ 0x5E, 0x57, 0x51, 0x04, 0x18, 0xCB, 0x1E, 0x76, 0x26, 0x99, 0x0F, 0x27, 0x10, 0x05, 0x28, 0x7F, +/* 0890 */ 0x09, 0x1F, 0x26, 0x03, 0x0D, 0x0C, 0x1F, 0x26, 0x05, 0x07, 0xE6, 0x3E, 0xE6, 0x02, 0x10, 0x06, +/* 08A0 */ 0x23, 0x73, 0x87, 0x75, 0x26, 0x08, 0x09, 0x02, 0x06, 0x3C, 0x19, 0x0E, 0xF3, 0x2B, 0x29, 0xA3, +/* 08B0 */ 0x01, 0x2C, 0x5E, 0x29, 0x83, 0x36, 0x9C, 0x48, 0xE8, 0x94, 0x69, 0x57, 0xCB, 0x90, 0x08, 0x10, +/* 08C0 */ 0x06, 0x28, 0x3B, 0x0E, 0x97, 0x26, 0x05, 0x07, 0xA4, 0x3C, 0x19, 0x8D, 0x29, 0x6B, 0x02, 0x24, +/* 08D0 */ 0x2E, 0x54, 0x22, 0x46, 0xA3, 0xC7, 0x82, 0x29, 0x8F, 0x09, 0x57, 0x8B, 0x02, 0x05, 0x71, 0x57, +/* 08E0 */ 0xA7, 0x0F, 0x75, 0x10, 0x07, 0xAA, 0x03, 0x0A, 0x19, 0xA2, 0x6F, 0x81, 0x29, 0xA9, 0x19, 0x75, +/* 08F0 */ 0x8F, 0x05, 0x57, 0x6B, 0x74, 0x41, 0x57, 0x63, 0x0E, 0x93, 0x0E, 0x06, 0xB6, 0x02, 0x75, 0x6E, +/* 0900 */ 0x8D, 0x19, 0x8D, 0x10, 0x06, 0x28, 0x02, 0x90, 0x07, 0x57, 0x65, 0x60, 0x32, 0x65, 0x6E, 0x65, +/* 0910 */ 0x0B, 0xAE, 0x43, 0x09, 0x04, 0x6B, 0x70, 0x61, 0x19, 0xA8, 0x19, 0x83, 0x57, 0x7C, 0xA4, 0x54, +/* 0920 */ 0x57, 0x3B, 0x0E, 0x97, 0x10, 0x07, 0xAA, 0x88, 0x97, 0x26, 0x05, 0x94, 0x66, 0x26, 0x38, 0x6F, +/* 0930 */ 0x0F, 0xA9, 0x8D, 0x00, 0xD6, 0x0B, 0x03, 0xAD, 0x68, 0x03, 0x1F, 0x24, 0x54, 0x21, 0xA5, 0x1F, +/* 0940 */ 0x24, 0x8D, 0x57, 0x94, 0x24, 0x71, 0x57, 0x83, 0x02, 0xA8, 0x26, 0x99, 0x0F, 0x27, 0x10, 0x06, +/* 0950 */ 0x28, 0x0B, 0x90, 0x05, 0x26, 0x69, 0x65, 0x3E, 0x44, 0x19, 0x38, 0x1D, 0xD6, 0x6E, 0x61, 0x19, +/* 0960 */ 0x8D, 0x29, 0x6B, 0x6E, 0xA2, 0x19, 0x91, 0x10, 0x07, 0x25, 0x03, 0x7B, 0x27, 0x0D, 0x52, 0x95, +/* 0970 */ 0x18, 0x7F, 0x1F, 0xA5, 0xFA, 0x5E, 0x00, 0x88, 0x26, 0x2A, 0x0C, 0xA1, 0x26, 0x82, 0x04, 0x77, +/* 0980 */ 0x57, 0xA3, 0x00, 0x7F, 0x54, 0x18, 0x88, 0x22, 0x75, 0xD6, 0x05, 0xA0, 0x1F, 0x57, 0x98, 0x5C, +/* 0990 */ 0x10, 0x07, 0x25, 0x9B, 0x0E, 0x0A, 0x01, 0x46, 0xAF, 0x02, 0x5A, 0x31, 0x04, 0x0F, 0x31, 0x03, +/* 09A0 */ 0x1F, 0xD6, 0x04, 0xCB, 0xFA, 0x63, 0x9E, 0x0F, 0x36, 0x74, 0x83, 0x1D, 0xD6, 0xF8, 0xB0, 0x0F, +/* 09B0 */ 0x07, 0x36, 0x9F, 0x03, 0x10, 0x03, 0xEF, 0xD5, 0x23, 0x46, 0xD5, 0x10, 0x03, 0xEF, 0xD5, 0x57, +/* 09C0 */ 0x23, 0xE3, 0x07, 0x10, 0x06, 0x18, 0x35, 0xE8, 0x04, 0xE8, 0x0B, 0x54, 0x46, 0x0A, 0x97, 0x32, +/* 09D0 */ 0x06, 0x94, 0xD1, 0x0B, 0x04, 0xD1, 0x08, 0x00, 0x73, 0x10, 0x06, 0x22, 0x40, 0x85, 0x57, 0x85, +/* 09E0 */ 0x10, 0x06, 0x35, 0x73, 0xF3, 0x02, 0x0C, 0x75, 0x22, 0xF9, 0x0B, 0x8D, 0x6F, 0x92, 0x00, 0x46, +/* 09F0 */ 0x95, 0x52, 0x57, 0x03, 0x9E, 0xD2, 0xA5, 0x10, 0x06, 0x25, 0x95, 0x9E, 0xF9, 0x78, 0x03, 0x54, +/* 0A00 */ 0x19, 0x75, 0x29, 0x1B, 0x32, 0xCB, 0x0C, 0x6E, 0x0E, 0xC7, 0x08, 0x02, 0x7A, 0x73, 0x91, 0x6F, +/* 0A10 */ 0x54, 0x10, 0x0D, 0xAA, 0x7F, 0x76, 0x0E, 0x0D, 0x0A, 0x03, 0x21, 0x03, 0x0D, 0x0A, 0x03, 0x01, +/* 0A20 */ 0x02, 0x5F, 0x06, 0x24, 0x7F, 0x5E, 0xCB, 0xF7, 0x02, 0x81, 0x24, 0x44, 0x00, 0x4A, 0x03, 0xA2, +/* 0A30 */ 0x00, 0x62, 0x24, 0x38, 0x00, 0x8C, 0x8A, 0x6B, 0x24, 0x3C, 0x01, 0x1F, 0x8A, 0x45, 0x7F, 0x0F, +/* 0A40 */ 0x60, 0xB1, 0x8A, 0xF5, 0x3C, 0x00, 0x3C, 0x8A, 0x42, 0x24, 0x8D, 0x8F, 0x09, 0xA7, 0x0D, 0xA7, +/* 0A50 */ 0x07, 0x24, 0x61, 0xA5, 0x0C, 0x94, 0xAD, 0x0A, 0x24, 0xA5, 0x54, 0x22, 0xF9, 0x9E, 0x03, 0x01, +/* 0A60 */ 0x02, 0x05, 0x68, 0x02, 0x1B, 0x0F, 0x5D, 0x03, 0x10, 0x07, 0x25, 0xD7, 0xC6, 0x10, 0x08, 0xFB, +/* 0A70 */ 0xDB, 0x04, 0x97, 0xF2, 0xA2, 0x4D, 0x02, 0x75, 0x57, 0x7B, 0x93, 0x0A, 0x26, 0x30, 0x02, 0x03, +/* 0A80 */ 0x96, 0xF2, 0x9D, 0x68, 0x6C, 0x00, 0xD7, 0x0F, 0x68, 0xDB, 0x03, 0x92, 0x57, 0x0C, 0x3F, 0x9E, +/* 0A90 */ 0x01, 0x10, 0x07, 0xAA, 0x88, 0xF7, 0x57, 0x05, 0x54, 0x02, 0x06, 0x05, 0x57, 0x5E, 0x29, 0x3A, +/* 0AA0 */ 0xFC, 0x3A, 0x19, 0x5E, 0x29, 0x9C, 0x54, 0x01, 0x05, 0x07, 0x26, 0x88, 0x0F, 0x91, 0x10, 0x08, +/* 0AB0 */ 0x25, 0x0C, 0x3F, 0x5E, 0x26, 0xDB, 0x04, 0xAE, 0xF2, 0x9D, 0x68, 0x6C, 0x00, 0x7F, 0x2B, 0xDA, +/* 0AC0 */ 0x0E, 0x06, 0xDA, 0x0E, 0x06, 0x18, 0x6C, 0x00, 0x7F, 0x2B, 0x18, 0x6C, 0x24, 0x9D, 0x68, 0xDB, +/* 0AD0 */ 0xA3, 0x08, 0x57, 0x0C, 0x3F, 0x5E, 0x10, 0x07, 0x25, 0xCE, 0x10, 0x06, 0x25, 0x7B, 0x3F, 0x0C, +/* 0AE0 */ 0x26, 0xDB, 0xD2, 0x50, 0x7B, 0x0E, 0x0E, 0xF8, 0x30, 0x66, 0x36, 0x50, 0x50, 0x10, 0x08, 0xAA, +/* 0AF0 */ 0x05, 0x7B, 0x75, 0x57, 0x05, 0xAF, 0x01, 0x04, 0x08, 0x2E, 0x08, 0x29, 0x3A, 0x5B, 0x74, 0x95, +/* 0B00 */ 0x94, 0x1D, 0xD7, 0xB1, 0x7F, 0x02, 0x71, 0x21, 0x03, 0x3C, 0x22, 0x71, 0x18, 0x0E, 0x06, 0x22, +/* 0B10 */ 0x71, 0x18, 0x07, 0x54, 0x01, 0x04, 0x71, 0x57, 0xA8, 0x0F, 0x0D, 0x52, 0x10, 0x08, 0x18, 0x23, +/* 0B20 */ 0xDA, 0x71, 0xDA, 0x71, 0xDA, 0x71, 0xDA, 0x71, 0x18, 0x7B, 0x33, 0x71, 0x18, 0x30, 0x02, 0x66, +/* 0B30 */ 0x71, 0xDA, 0x71, 0xDA, 0x71, 0xDA, 0x71, 0xDA, 0x71, 0x10, 0x04, 0x25, 0xED, 0x10, 0x04, 0x25, +/* 0B40 */ 0x83, 0xD0, 0xD0, 0xD0, 0xD0, 0x19, 0x9F, 0x22, 0x46, 0x54, 0x29, 0x30, 0x73, 0x10, 0x07, 0x21, +/* 0B50 */ 0x23, 0xF2, 0x76, 0x4D, 0x2A, 0x7D, 0x6C, 0x01, 0x5E, 0x26, 0x6C, 0x83, 0x36, 0x0C, 0x0B, 0x1F, +/* 0B60 */ 0x36, 0x0C, 0x76, 0x08, 0x36, 0x6C, 0x9D, 0xDD, 0x6C, 0x37, 0x0C, 0x26, 0x6C, 0x7F, 0x97, 0x4D, +/* 0B70 */ 0x9C, 0x1F, 0x10, 0x06, 0x25, 0x50, 0x50, 0x50, 0x50, 0x96, 0x03, 0x03, 0xDD, 0x7B, 0x3F, 0x0E, +/* 0B80 */ 0x10, 0x0A, 0x25, 0x08, 0x2B, 0x00, 0x9C, 0x0F, 0x07, 0x21, 0x87, 0x08, 0x24, 0x87, 0x08, 0x21, +/* 0B90 */ 0x9F, 0x0C, 0x24, 0x0D, 0x82, 0x1D, 0x8F, 0x5F, 0x69, 0x97, 0x0A, 0x21, 0x0C, 0x53, 0x04, 0x05, +/* 0BA0 */ 0x0A, 0xA9, 0x21, 0x94, 0x07, 0x84, 0x06, 0x98, 0x21, 0x3C, 0xF4, 0x0C, 0x03, 0x6B, 0x22, 0x7F, +/* 0BB0 */ 0x1F, 0x00, 0x0E, 0x0E, 0x00, 0x45, 0x22, 0xA5, 0xB1, 0xCB, 0x09, 0xA5, 0xB1, 0x22, 0x45, 0x1D, +/* 0BC0 */ 0x7F, 0x1F, 0x10, 0x09, 0x25, 0x7B, 0x74, 0xC3, 0x2B, 0x10, 0x09, 0xAA, 0x88, 0xE2, 0xD3, 0x10, +/* 0BD0 */ 0x07, 0xFB, 0xDB, 0x6B, 0x08, 0xF2, 0x76, 0xF2, 0xA8, 0x4D, 0x02, 0xAE, 0x57, 0x7B, 0x0E, 0x9E, +/* 0BE0 */ 0x01, 0x57, 0x30, 0x6E, 0x50, 0x6C, 0x10, 0x09, 0xAA, 0x88, 0x0F, 0x91, 0x18, 0x9C, 0x54, 0x4C, +/* 0BF0 */ 0x71, 0x18, 0x5E, 0x22, 0x8E, 0x21, 0x3A, 0x22, 0x5F, 0x21, 0x4F, 0x22, 0x05, 0xB1, 0x1D, 0x4F, +/* 0C00 */ 0x22, 0x05, 0xB1, 0x1D, 0x3A, 0x22, 0x5F, 0x18, 0x97, 0x22, 0x9F, 0x21, 0x9C, 0x54, 0x02, 0xAD, +/* 0C10 */ 0x02, 0x57, 0x88, 0x3F, 0x09, 0x20, 0xA5, 0x63, 0xC7, 0x03, 0x10, 0x08, 0xFB, 0xDB, 0x6B, 0x08, +/* 0C20 */ 0xF2, 0x4A, 0xF2, 0x4A, 0x4D, 0x89, 0x08, 0x57, 0x7B, 0x93, 0x09, 0x26, 0x30, 0x86, 0x06, 0x00, +/* 0C30 */ 0x4D, 0x5F, 0x01, 0xF2, 0x0D, 0x08, 0xF2, 0xA3, 0x02, 0x10, 0x07, 0x25, 0x9B, 0x5C, 0x57, 0x65, +/* 0C40 */ 0x07, 0x01, 0x04, 0x0A, 0x57, 0x9D, 0x6E, 0x65, 0x08, 0x19, 0xA3, 0x0E, 0x52, 0x2C, 0x88, 0x48, +/* 0C50 */ 0x22, 0x46, 0x2B, 0x19, 0x2B, 0x18, 0x7C, 0x03, 0x01, 0x95, 0x68, 0x01, 0x09, 0x93, 0x91, 0x10, +/* 0C60 */ 0x06, 0x28, 0x0D, 0x90, 0x2B, 0x21, 0x7F, 0xB0, 0x48, 0xD2, 0x88, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, +/* 0C70 */ 0xD1, 0xD1, 0x10, 0x08, 0x25, 0xB4, 0xB7, 0x78, 0x10, 0x07, 0x28, 0x30, 0x22, 0x88, 0x18, 0x4A, +/* 0C80 */ 0x22, 0x82, 0xD6, 0x01, 0x24, 0x8D, 0x57, 0x54, 0xA5, 0xFA, 0x79, 0x00, 0xA9, 0x26, 0xA9, 0x00, +/* 0C90 */ 0x9A, 0x00, 0x46, 0xB1, 0x0D, 0x20, 0x75, 0x0F, 0xD2, 0x1B, 0x0B, 0x29, 0x9D, 0x07, 0x10, 0x0A, +/* 0CA0 */ 0x28, 0xA2, 0x24, 0x08, 0xB1, 0xA5, 0xB1, 0x24, 0xA9, 0x00, 0x8F, 0x3C, 0x00, 0x6B, 0x22, 0x6B, +/* 0CB0 */ 0x24, 0x0E, 0x0A, 0x06, 0x00, 0x47, 0x24, 0x7F, 0x0F, 0x66, 0x75, 0x09, 0x00, 0x9A, 0x1D, 0x94, +/* 0CC0 */ 0x04, 0x0A, 0x4E, 0x8F, 0x06, 0x22, 0x8F, 0x06, 0x07, 0x52, 0x0E, 0x00, 0x81, 0x22, 0xCB, 0x62, +/* 0CD0 */ 0x05, 0x00, 0x39, 0xB1, 0x1D, 0x58, 0xA1, 0x37, 0x76, 0x21, 0x9B, 0x0E, 0x24, 0xA8, 0x0B, 0x1D, +/* 0CE0 */ 0x7F, 0x0F, 0x0B, 0x24, 0x9D, 0x08, 0x10, 0x07, 0x28, 0xA8, 0x24, 0x3A, 0x21, 0x7F, 0x54, 0x00, +/* 0CF0 */ 0x61, 0x26, 0x07, 0xDE, 0x81, 0x43, 0x0E, 0x8E, 0x29, 0x08, 0x71, 0x29, 0x0C, 0x9E, 0x36, 0x6B, +/* 0D00 */ 0x4F, 0x26, 0x67, 0x8F, 0x09, 0x00, 0xD6, 0x74, 0xA3, 0x68, 0x82, 0x22, 0x0D, 0x08, 0x10, 0x07, +/* 0D10 */ 0x28, 0x5A, 0xBA, 0x3E, 0x03, 0x1F, 0x10, 0x07, 0x28, 0x03, 0x90, 0x1F, 0x18, 0x7F, 0x69, 0x4A, +/* 0D20 */ 0x22, 0x46, 0x94, 0x29, 0x83, 0x00, 0xE8, 0x3C, 0x29, 0x5A, 0x5B, 0x3E, 0x96, 0x29, 0xA3, 0x02, +/* 0D30 */ 0x69, 0x68, 0x37, 0x90, 0xB1, 0x10, 0x04, 0x7E, 0x2A, 0x0E, 0x06, 0xE8, 0x1F, 0xD2, 0xE0, 0x19, +/* 0D40 */ 0xE0, 0x0E, 0x06, 0x22, 0x46, 0x60, 0x10, 0x07, 0x64, 0x73, 0x49, 0x9A, 0x19, 0x58, 0x19, 0x86, +/* 0D50 */ 0x7A, 0x39, 0x29, 0x37, 0x70, 0x7C, 0x19, 0x2A, 0x7A, 0x81, 0x29, 0x8F, 0xF3, 0x07, 0x0A, 0x24, +/* 0D60 */ 0xE8, 0x0D, 0x7A, 0x4B, 0x04, 0x01, 0x10, 0x04, 0x7E, 0xA3, 0x94, 0x2C, 0x86, 0xC7, 0xD9, 0xD9, +/* 0D70 */ 0xD9, 0xD9, 0xD9, 0x0E, 0x20, 0xA3, 0x71, 0x22, 0xB6, 0x10, 0x07, 0x59, 0x4C, 0xD2, 0x37, 0x97, +/* 0D80 */ 0x36, 0x2A, 0x6B, 0x32, 0x67, 0x00, 0x79, 0x57, 0x2A, 0x74, 0x03, 0x1F, 0x10, 0x07, 0x64, 0x40, +/* 0D90 */ 0x40, 0x37, 0x0E, 0x33, 0x54, 0xB6, 0x66, 0x60, 0x10, 0x04, 0x2F, 0x42, 0x03, 0x19, 0x53, 0x04, +/* 0DA0 */ 0x10, 0x07, 0xA6, 0xBC, 0x1E, 0x10, 0x07, 0x1C, 0xEA, 0x0D, 0x44, 0xCF, 0xB8, 0x2E, 0xA8, 0x97, +/* 0DB0 */ 0x10, 0x06, 0xA6, 0x3B, 0x0E, 0x8C, 0xDF, 0xFC, 0x3A, 0x19, 0x92, 0xA4, 0x03, 0x24, 0xEC, 0x10, +/* 0DC0 */ 0x08, 0x6A, 0x73, 0x7A, 0x2D, 0x75, 0x46, 0x0C, 0x0E, 0x87, 0x06, 0xB5, 0x24, 0x75, 0x18, 0x3A, +/* 0DD0 */ 0xE4, 0x0D, 0x0E, 0x08, 0x38, 0x10, 0x07, 0xA6, 0xA7, 0xE1, 0xC2, 0x10, 0x04, 0x2F, 0xA5, 0x0C, +/* 0DE0 */ 0x5D, 0x36, 0x83, 0x01, 0x02, 0x36, 0x67, 0x29, 0x0C, 0x3F, 0x1F, 0x43, 0x67, 0x6E, 0x67, 0xDC, +/* 0DF0 */ 0x36, 0x67, 0xDC, 0x36, 0x67, 0xDC, 0x10, 0x07, 0x24, 0x35, 0xA0, 0x7D, 0x88, 0x0F, 0x5D, 0x04, +/* 0E00 */ 0xD6, 0x04, 0xA7, 0x07, 0x31, 0xA9, 0x57, 0x03, 0x3C, 0x00, 0x9F, 0x26, 0x08, 0x3F, 0x1E, 0x26, +/* 0E10 */ 0x39, 0x6E, 0x2B, 0x6E, 0xAD, 0x3F, 0x09, 0x57, 0x60, 0x24, 0x03, 0x71, 0x18, 0xA2, 0x60, 0x05, +/* 0E20 */ 0x3C, 0x18, 0xA7, 0x93, 0x38, 0x10, 0x07, 0x1C, 0xEA, 0x5E, 0xB3, 0x10, 0x04, 0xBE, 0x26, 0x80, +/* 0E30 */ 0xE7, 0xE7, 0x10, 0x04, 0xBE, 0x26, 0x80, 0xE7, 0xE7, 0x94, 0x29, 0x1B, 0x19, 0x78, 0x10, 0x07, +/* 0E40 */ 0x34, 0xAB, 0x19, 0xEA, 0x75, 0x9C, 0x48, 0x57, 0x75, 0x86, 0xF8, 0x75, 0x67, 0x24, 0x2E, 0x0B, +/* 0E50 */ 0x0E, 0x29, 0x5E, 0x54, 0x36, 0x75, 0x5F, 0x01, 0x1D, 0xC5, 0x96, 0x1D, 0xC5, 0x03, 0x3C, 0x10, +/* 0E60 */ 0x04, 0x34, 0x60, 0xC0, 0x54, 0xC0, 0x54, 0xC0, 0x54, 0xC0, 0x54, 0xC0, 0x0E, 0xF3, 0x08, 0x94, +/* 0E70 */ 0x10, 0x0B, 0xA6, 0x0D, 0x42, 0x54, 0xA3, 0xA1, 0x1D, 0x0D, 0x39, 0xAD, 0x78, 0x30, 0xC5, 0x45, +/* 0E80 */ 0x74, 0xA2, 0xC5, 0xF5, 0x62, 0xC5, 0xF5, 0x62, 0xC5, 0xF5, 0x62, 0xC5, 0xF5, 0x62, 0xC5, 0xF5, +/* 0E90 */ 0x62, 0x10, 0x07, 0xA6, 0x8D, 0xB3, 0x10, 0x07, 0xA6, 0xBB, 0xB9, 0xEC, 0x10, 0x07, 0xA6, 0x0D, +/* 0EA0 */ 0xA9, 0xCF, 0xB8, 0xC1, 0x41, 0x10, 0x08, 0xA6, 0x02, 0x0C, 0x9E, 0x38, 0xB5, 0x24, 0x75, 0x18, +/* 0EB0 */ 0x3A, 0xE4, 0x0D, 0x97, 0xEA, 0x0B, 0x05, 0x10, 0x05, 0xA6, 0x75, 0x77, 0x24, 0x2E, 0x8C, 0xD2, +/* 0EC0 */ 0xAE, 0x19, 0xE7, 0x75, 0x10, 0x06, 0xA6, 0xAD, 0x9E, 0x74, 0x56, 0xAB, 0x52, 0x57, 0xA3, 0x6E, +/* 0ED0 */ 0x37, 0x0E, 0x08, 0x3E, 0x03, 0x0A, 0x4B, 0x5E, 0x18, 0xD7, 0x07, 0x02, 0x03, 0x54, 0x57, 0xA7, +/* 0EE0 */ 0x0E, 0x97, 0x10, 0x05, 0x25, 0x55, 0x21, 0xDA, 0x2E, 0x0F, 0x3F, 0x2C, 0x6C, 0x6E, 0x50, 0x50, +/* 0EF0 */ 0x5A, 0x60, 0xE8, 0x0D, 0x54, 0x10, 0x07, 0xA6, 0x51, 0xBF, 0x81, 0x10, 0x06, 0x35, 0xDC, 0x6B, +/* 0F00 */ 0x57, 0x44, 0x24, 0x62, 0x00, 0xD6, 0x74, 0x38, 0x26, 0x8D, 0x01, 0x1F, 0x26, 0x9A, 0x9B, 0x36, +/* 0F10 */ 0x05, 0x30, 0x09, 0x2C, 0x0F, 0x41, 0x36, 0x8F, 0xB1, 0x10, 0x09, 0x19, 0x35, 0x82, 0xA5, 0xAF, +/* 0F20 */ 0x00, 0xA9, 0x1D, 0x47, 0x00, 0x05, 0x9E, 0x00, 0x08, 0x09, 0x1D, 0x6B, 0x00, 0x08, 0x83, 0x8F, +/* 0F30 */ 0x06, 0x22, 0x7F, 0x0F, 0x99, 0x2A, 0x00, 0x8C, 0x21, 0x8C, 0x48, 0xA1, 0xB1, 0x1D, 0x37, 0xA8, +/* 0F40 */ 0x37, 0xA8, 0x18, 0x07, 0x77, 0x00, 0x07, 0x77, 0x56, 0x07, 0xD7, 0x0F, 0x07, 0x10, 0x06, 0x1D, +/* 0F50 */ 0x35, 0x31, 0x30, 0x26, 0x75, 0x6B, 0x32, 0xA9, 0x55, 0x22, 0x2E, 0x0E, 0x6F, 0x0E, 0x0E, 0xDD, +/* 0F60 */ 0xCB, 0x09, 0x61, 0x26, 0x86, 0x60, 0x94, 0x57, 0x9F, 0x24, 0x4A, 0x10, 0x06, 0x35, 0xDC, 0xC9, +/* 0F70 */ 0x6D, 0xF6, 0x10, 0x06, 0x29, 0x35, 0x9C, 0x90, 0x02, 0x26, 0x69, 0x4A, 0x22, 0x46, 0x94, 0x29, +/* 0F80 */ 0x9F, 0x5B, 0x3E, 0x30, 0x29, 0x5F, 0x69, 0x32, 0x0B, 0x90, 0x02, 0x10, 0x04, 0x34, 0x03, 0x6C, +/* 0F90 */ 0x29, 0x9F, 0xD2, 0x8F, 0xF3, 0x0B, 0xF3, 0x0B, 0xF3, 0x38, 0x36, 0xCB, 0x0C, 0x6E, 0x89, 0xC7, +/* 0FA0 */ 0x0B, 0xF3, 0x0B, 0x70, 0x0B, 0x70, 0x0B, 0x70, 0x82, 0x19, 0x2A, 0x70, 0x7F, 0x10, 0x05, 0x1D, +/* 0FB0 */ 0x73, 0x52, 0x6F, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xF1, 0xB1, 0x10, 0x04, 0x7E, 0x05, 0x91, 0x6F, +/* 0FC0 */ 0x61, 0x19, 0xEE, 0xEE, 0xEE, 0x6B, 0x7A, 0x92, 0x29, 0x2A, 0x3E, 0xEE, 0xEE, 0xEE, 0xEE, 0x47, +/* 0FD0 */ 0x36, 0x9C, 0x54, 0x10, 0x06, 0x59, 0x40, 0x8F, 0x91, 0x03, 0x05, 0x18, 0xD7, 0x08, 0x98, 0x81, +/* 0FE0 */ 0x73, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x11, 0x00, 0x2E, 0x00, 0x4F, 0x00, 0x79, 0x00, 0x9E, +/* 0FF0 */ 0x00, 0xAA, 0x00, 0xD4, 0x00, 0xDC, 0x01, 0x16, 0x01, 0x35, 0x01, 0x5B, 0x01, 0x6A, 0x01, 0x74, +/* 1000 */ 0x01, 0xA3, 0x01, 0xAC, 0x01, 0xC2, 0x01, 0xCE, 0x01, 0xE3, 0x01, 0xF9, 0x02, 0x00, 0x02, 0x1B, +/* 1010 */ 0x02, 0x4B, 0x02, 0x51, 0x02, 0x5F, 0x02, 0x6E, 0x02, 0x92, 0x02, 0xB5, 0x02, 0xCA, 0x02, 0xF8, +/* 1020 */ 0x03, 0x25, 0x03, 0x40, 0x03, 0x4B, 0x03, 0x57, 0x03, 0x63, 0x03, 0x69, 0x03, 0x73, 0x03, 0x83, +/* 1030 */ 0x03, 0xB5, 0x03, 0xE2, 0x03, 0xED, 0x03, 0xF8, 0x04, 0x04, 0x04, 0x0C, 0x04, 0x16, 0x04, 0x21, +/* 1040 */ 0x04, 0x2D, 0x04, 0x37, 0x04, 0x6A, 0x04, 0x7B, 0x04, 0x89, 0x04, 0x96, 0x04, 0xA4, 0x04, 0xB2, +/* 1050 */ 0x04, 0xBC, 0x04, 0xD3, 0x05, 0x18, 0x05, 0x26, 0x05, 0x35, 0x05, 0x42, 0x05, 0x4D, 0x05, 0x5D, +/* 1060 */ 0x05, 0x7D, 0x05, 0xAA, 0x05, 0xB4, 0x05, 0xBF, 0x05, 0xCD, 0x05, 0xDB, 0x05, 0xE5, 0x05, 0xF3, +/* 1070 */ 0x06, 0x25, 0x06, 0x3E, 0x06, 0x49, 0x06, 0x55, 0x06, 0x63, 0x06, 0x6F, 0x06, 0x79, 0x06, 0x84, +/* 1080 */ 0x06, 0x94, 0x06, 0x9F, 0x06, 0xC9, 0x06, 0xD8, 0x06, 0xE3, 0x06, 0xEA, 0x06, 0xF8, 0x06, 0xFF, +/* 1090 */ 0x07, 0x09, 0x07, 0x15, 0x07, 0x45, 0x07, 0x50, 0x07, 0x57, 0x07, 0x66, 0x07, 0x70, 0x07, 0x7D, +/* 10A0 */ 0x07, 0x89, 0x03, 0x00, 0x10, 0x03, 0xEF, 0x94, 0x6F, 0x91, 0x24, 0x1A, 0x4B, 0x4B, 0xF0, 0x71, +/* 10B0 */ 0x6F, 0x71, 0x10, 0x06, 0x00, 0xAA, 0xA1, 0x19, 0xA1, 0x36, 0x3B, 0x5C, 0x26, 0x92, 0x01, 0x03, +/* 10C0 */ 0x7D, 0x3A, 0xFC, 0x3A, 0x19, 0x77, 0x01, 0x03, 0x03, 0x24, 0xEC, 0x29, 0xA1, 0x19, 0xA1, 0x10, +/* 10D0 */ 0x07, 0xAA, 0x95, 0x97, 0xF9, 0x3C, 0x03, 0x09, 0x01, 0x57, 0xA9, 0x19, 0x44, 0x5B, 0x0F, 0x0E, +/* 10E0 */ 0x54, 0x26, 0x44, 0x66, 0x32, 0x44, 0x19, 0x47, 0x6F, 0x38, 0x01, 0x69, 0x57, 0x07, 0x90, 0x0E, +/* 10F0 */ 0x10, 0x07, 0x24, 0xAA, 0xE8, 0x03, 0x22, 0x03, 0x03, 0x18, 0x9B, 0x0B, 0x5D, 0x8C, 0x18, 0x8F, +/* 1100 */ 0x52, 0x4A, 0x26, 0x0E, 0x01, 0x7F, 0xFA, 0xB1, 0x24, 0xFA, 0x0B, 0x07, 0x00, 0xA9, 0x57, 0x89, +/* 1110 */ 0x0D, 0x0F, 0x0D, 0x39, 0x21, 0xD7, 0x05, 0x7F, 0xD7, 0x04, 0x10, 0x07, 0x28, 0x0B, 0x09, 0x22, +/* 1120 */ 0x6C, 0x18, 0x6B, 0x74, 0x2A, 0x01, 0x4D, 0x79, 0x26, 0x9B, 0x86, 0xD2, 0x0C, 0x96, 0x36, 0x0C, +/* 1130 */ 0x93, 0xAE, 0x22, 0x56, 0x22, 0x2E, 0x93, 0x0E, 0x0A, 0x00, 0x46, 0x9D, 0x60, 0x22, 0x56, 0x10, +/* 1140 */ 0x05, 0x64, 0x73, 0xF1, 0xF1, 0xB1, 0x2F, 0x2C, 0xF1, 0xF1, 0xB1, 0x10, 0x07, 0x25, 0xA7, 0xF7, +/* 1150 */ 0x26, 0x9F, 0x01, 0x04, 0xF8, 0x67, 0x19, 0x9D, 0x0A, 0x03, 0x36, 0x38, 0x95, 0x06, 0x18, 0x7F, +/* 1160 */ 0x0F, 0x74, 0x98, 0x26, 0x0C, 0x0B, 0x03, 0x7C, 0x43, 0xA8, 0x1F, 0x19, 0x30, 0xF9, 0x74, 0x30, +/* 1170 */ 0x57, 0xCB, 0x3F, 0xDE, 0x6F, 0x10, 0x05, 0x2F, 0x53, 0x37, 0x05, 0x2C, 0x7F, 0x10, 0x0A, 0x1C, +/* 1180 */ 0x7F, 0x76, 0x0D, 0x78, 0x57, 0x96, 0x03, 0x4C, 0xA1, 0x1D, 0x9C, 0x08, 0x02, 0x0C, 0x8C, 0x05, +/* 1190 */ 0x09, 0x1D, 0x8F, 0x02, 0x55, 0xAB, 0x00, 0x0C, 0x21, 0x0C, 0x00, 0xA1, 0x24, 0x8F, 0x1D, 0x8F, +/* 11A0 */ 0x99, 0x05, 0x00, 0x74, 0x0C, 0x21, 0x07, 0x07, 0x6B, 0x54, 0x03, 0x0A, 0x1D, 0x7F, 0x75, 0x69, +/* 11B0 */ 0x04, 0x39, 0x18, 0xA7, 0x3F, 0x91, 0x6F, 0x10, 0x06, 0x25, 0xA8, 0x5E, 0x36, 0x66, 0x9D, 0x36, +/* 11C0 */ 0x98, 0x93, 0x68, 0x7F, 0x2B, 0x03, 0xB1, 0x46, 0x1F, 0x4F, 0x57, 0x8F, 0x0F, 0x5A, 0x05, 0xCD, +/* 11D0 */ 0x01, 0x69, 0x69, 0x46, 0x90, 0x0A, 0x10, 0x08, 0xA6, 0x7F, 0x02, 0x7F, 0x02, 0x57, 0x8F, 0x07, +/* 11E0 */ 0x00, 0x79, 0x57, 0xA8, 0x9C, 0x48, 0x21, 0xA5, 0x71, 0x02, 0x2B, 0x46, 0x2B, 0x02, 0x2B, 0x26, +/* 11F0 */ 0xA8, 0x9C, 0x48, 0x57, 0x8F, 0x07, 0x00, 0x79, 0x43, 0x02, 0x7F, 0x02, 0x10, 0x06, 0x80, 0x40, +/* 1200 */ 0x6B, 0x33, 0x0A, 0x26, 0x66, 0x4C, 0x0A, 0x19, 0x7C, 0x19, 0x69, 0x10, 0x05, 0x80, 0x40, 0x2A, +/* 1210 */ 0x0E, 0x54, 0x36, 0x66, 0x60, 0x10, 0x08, 0x80, 0x88, 0x5E, 0x26, 0x58, 0x03, 0x03, 0x55, 0x57, +/* 1220 */ 0x0C, 0x86, 0xDE, 0x0C, 0x21, 0xA5, 0x09, 0x02, 0x9A, 0x05, 0x08, 0x03, 0x1D, 0xA5, 0x09, 0x65, +/* 1230 */ 0x48, 0x08, 0x03, 0x21, 0x8F, 0x02, 0xA2, 0x99, 0x68, 0x08, 0x09, 0xAB, 0x09, 0x09, 0x57, 0xCB, +/* 1240 */ 0x3F, 0x0A, 0xD2, 0x69, 0x10, 0x04, 0x2F, 0x95, 0x0E, 0x0C, 0x2C, 0x02, 0x60, 0x10, 0x07, 0x1C, +/* 1250 */ 0x88, 0x0B, 0x74, 0x46, 0x81, 0x08, 0x09, 0xF9, 0x0B, 0x00, 0x4E, 0x00, 0x46, 0x48, 0x7C, 0x36, +/* 1260 */ 0x63, 0xA1, 0x6F, 0x10, 0x06, 0xE9, 0xBD, 0x0B, 0xE8, 0x33, 0x9E, 0x00, 0x46, 0x66, 0x60, 0x10, +/* 1270 */ 0x05, 0x2F, 0xCB, 0x9E, 0x36, 0xB0, 0x03, 0x81, 0x1D, 0x2E, 0xD2, 0xCB, 0x05, 0x36, 0xCB, 0x07, +/* 1280 */ 0x32, 0xA5, 0x3F, 0x2B, 0x10, 0x05, 0x34, 0x1B, 0x08, 0x36, 0xB0, 0x03, 0x4B, 0x0D, 0x3E, 0x0E, +/* 1290 */ 0x0A, 0x19, 0x4E, 0xF8, 0xA5, 0x8F, 0x05, 0x26, 0x99, 0x77, 0x10, 0x04, 0x1C, 0x4E, 0x20, 0x53, +/* 12A0 */ 0x05, 0x10, 0x07, 0xA6, 0x75, 0x7F, 0xCA, 0x7F, 0xCA, 0x7F, 0x3C, 0x22, 0xC5, 0x3A, 0x2E, 0x78, +/* 12B0 */ 0x0A, 0x71, 0x2E, 0x0C, 0x54, 0x38, 0x57, 0x8D, 0x19, 0x8D, 0x19, 0x41, 0x10, 0x09, 0xAA, 0x76, +/* 12C0 */ 0x0F, 0x3F, 0x09, 0x18, 0x08, 0x3F, 0x1F, 0x08, 0x09, 0x18, 0x0C, 0x3F, 0xD8, 0x21, 0x0D, 0x3F, +/* 12D0 */ 0xD8, 0x1D, 0xCB, 0x3F, 0xD8, 0x21, 0x3B, 0x0E, 0xD8, 0x26, 0xD8, 0x26, 0xD8, 0x26, 0xD8, 0x26, +/* 12E0 */ 0xD8, 0x26, 0xD8, 0x26, 0xD8, 0x26, 0xD8, 0x26, 0x05, 0x00, 0x03, 0x03, 0x10, 0x03, 0x57, 0x40, +/* 12F0 */ 0xE8, 0xD5, 0x10, 0x04, 0x00, 0xA6, 0x40, 0x37, 0x7A, 0x5E, 0x73, 0xA1, 0x36, 0x9D, 0xDE, 0x6F, +/* 1300 */ 0x10, 0x05, 0x2F, 0xD7, 0x5E, 0x2C, 0x82, 0x70, 0x08, 0x70, 0x08, 0x70, 0x08, 0x70, 0x8B, 0x10, +/* 1310 */ 0x06, 0x25, 0xF4, 0x0D, 0x08, 0x43, 0x97, 0x03, 0x54, 0x57, 0xF5, 0x79, 0x57, 0x2A, 0x00, 0xCB, +/* 1320 */ 0x09, 0x18, 0x7F, 0x71, 0x01, 0x8D, 0x57, 0x9C, 0x3F, 0x0A, 0x19, 0x74, 0x1A, 0x69, 0x69, 0x68, +/* 1330 */ 0xD7, 0x90, 0x09, 0x10, 0x07, 0xA6, 0x03, 0x24, 0x03, 0x43, 0x94, 0x01, 0x0E, 0x7D, 0x9C, 0x48, +/* 1340 */ 0x88, 0x32, 0x96, 0x00, 0x96, 0x26, 0x96, 0x00, 0x96, 0x57, 0x88, 0xB0, 0x48, 0x21, 0x7F, 0x81, +/* 1350 */ 0x01, 0x0E, 0xDD, 0x03, 0x24, 0x03, 0x10, 0x0C, 0x23, 0xEB, 0xD4, 0x01, 0x02, 0x21, 0x8B, 0x00, +/* 1360 */ 0x4E, 0x9C, 0x08, 0x21, 0x8B, 0x37, 0x05, 0x8F, 0x7D, 0xC4, 0xDE, 0x10, 0x0C, 0x23, 0xEB, 0xD4, +/* 1370 */ 0x57, 0x8B, 0x00, 0x4E, 0x99, 0x5E, 0x1D, 0x8B, 0x37, 0x05, 0x03, 0x05, 0x04, 0x0F, 0x21, 0xA5, +/* 1380 */ 0x0C, 0x22, 0x4E, 0x18, 0x08, 0x06, 0x24, 0x99, 0x03, 0x1D, 0x7F, 0x0D, 0x24, 0x99, 0x04, 0x01, +/* 1390 */ 0x21, 0x07, 0x07, 0x24, 0x05, 0x3F, 0x1F, 0x1D, 0xDE, 0x10, 0x0C, 0x18, 0x23, 0x05, 0x1D, 0x3B, +/* 13A0 */ 0x5D, 0x74, 0x9C, 0x09, 0x21, 0xAB, 0xA1, 0x24, 0x1E, 0x21, 0xFE, 0x0B, 0x00, 0xD7, 0x0A, 0x46, +/* 13B0 */ 0x41, 0x8F, 0x03, 0x01, 0x02, 0x24, 0x7F, 0x03, 0x00, 0x41, 0x4E, 0x9C, 0x08, 0x22, 0x3B, 0xAE, +/* 13C0 */ 0x37, 0x05, 0x8F, 0x7D, 0xC4, 0xDE, 0x10, 0x06, 0x22, 0xA6, 0xD1, 0x19, 0x42, 0x64, 0x46, 0x70, +/* 13D0 */ 0xA9, 0x29, 0x2A, 0x06, 0x36, 0x86, 0x06, 0x29, 0x4A, 0x19, 0x07, 0x81, 0xF4, 0x7D, 0x37, 0x0E, +/* 13E0 */ 0x97, 0x10, 0x07, 0x59, 0x05, 0x03, 0xD1, 0x09, 0x7A, 0x20, 0xD7, 0xC6, 0x10, 0x07, 0x64, 0xB0, +/* 13F0 */ 0x36, 0x9C, 0xAE, 0x01, 0xE8, 0x6E, 0xD7, 0xC6, 0x10, 0x07, 0x22, 0x6B, 0x08, 0xE8, 0x91, 0x55, +/* 1400 */ 0x36, 0xE5, 0xD7, 0xC6, 0x10, 0x07, 0x22, 0xCC, 0xD7, 0xC6, 0x10, 0x07, 0x18, 0xE8, 0x0D, 0x00, +/* 1410 */ 0x84, 0xCD, 0xD7, 0xC6, 0x10, 0x07, 0x22, 0x05, 0xAE, 0x36, 0x8F, 0xF4, 0xD2, 0x07, 0x0F, 0x0C, +/* 1420 */ 0x73, 0x22, 0xF9, 0xC6, 0x10, 0x0A, 0x57, 0x23, 0x2E, 0x90, 0xB1, 0x21, 0x03, 0x0D, 0x8D, 0x69, +/* 1430 */ 0x68, 0x84, 0x79, 0x36, 0x39, 0x47, 0x26, 0x9B, 0xD7, 0x0F, 0x33, 0x01, 0x1D, 0x9A, 0x7F, 0x71, +/* 1440 */ 0x66, 0x21, 0x0E, 0x33, 0x2B, 0x18, 0x6B, 0x02, 0x66, 0x67, 0x21, 0xCB, 0x09, 0x22, 0x61, 0x69, +/* 1450 */ 0x1D, 0x54, 0x22, 0x9D, 0x3F, 0x0B, 0x10, 0x07, 0xAA, 0x98, 0xF7, 0x18, 0xD7, 0x2B, 0xA0, 0x06, +/* 1460 */ 0x57, 0x30, 0x22, 0x46, 0x71, 0x29, 0x4F, 0x5B, 0x74, 0xE8, 0x1F, 0x6F, 0x71, 0x29, 0x8F, 0x09, +/* 1470 */ 0x24, 0xE8, 0x97, 0x03, 0x6D, 0x46, 0x87, 0x78, 0x24, 0x46, 0x39, 0x24, 0xE8, 0x0D, 0x36, 0xCB, +/* 1480 */ 0x0F, 0x09, 0x73, 0x10, 0x07, 0xAC, 0x9C, 0x03, 0x19, 0x07, 0xAE, 0x7A, 0x20, 0xCE, 0x10, 0x07, +/* 1490 */ 0x64, 0x4C, 0x29, 0x07, 0xAE, 0x00, 0xE8, 0x6E, 0xCE, 0x10, 0x07, 0x22, 0x9D, 0x08, 0xE8, 0x91, +/* 14A0 */ 0x0B, 0xF3, 0x7F, 0x6A, 0xCE, 0x10, 0x07, 0xAC, 0x4E, 0xCB, 0x07, 0xCD, 0xCE, 0x10, 0x04, 0x18, +/* 14B0 */ 0xF9, 0xC7, 0x42, 0x0B, 0x49, 0xC7, 0xED, 0x10, 0x04, 0xAC, 0xB0, 0xD2, 0x9B, 0x78, 0xE8, 0x01, +/* 14C0 */ 0x7A, 0xED, 0x10, 0x04, 0x00, 0x2A, 0x0A, 0x2C, 0x41, 0x62, 0xC8, 0x00, 0x1A, 0xED, 0x10, 0x04, +/* 14D0 */ 0x24, 0x73, 0xA1, 0x7C, 0xC8, 0x00, 0x1A, 0xED, 0x10, 0x08, 0x28, 0x37, 0x3F, 0x0D, 0x52, 0x57, +/* 14E0 */ 0x9F, 0x01, 0x4E, 0x0B, 0x57, 0x9F, 0x24, 0x03, 0x3C, 0x18, 0x9F, 0x22, 0x5E, 0x1D, 0x37, 0x3F, +/* 14F0 */ 0x97, 0x00, 0x30, 0x21, 0x3B, 0x78, 0x74, 0x30, 0x18, 0x9F, 0x22, 0x5E, 0x18, 0x9F, 0x24, 0x03, +/* 1500 */ 0x3C, 0x18, 0x9F, 0x01, 0x9B, 0x0B, 0x18, 0x37, 0x3F, 0x0D, 0x52, 0x10, 0x09, 0x22, 0x03, 0x8D, +/* 1510 */ 0x06, 0xDD, 0x08, 0x42, 0x0E, 0x01, 0x73, 0x6A, 0x7B, 0x74, 0xC3, 0x2B, 0x10, 0x09, 0x64, 0x07, +/* 1520 */ 0x01, 0x6F, 0x09, 0x75, 0x73, 0x03, 0x36, 0x88, 0xE2, 0xD3, 0x10, 0x09, 0x36, 0xE8, 0x05, 0x36, +/* 1530 */ 0xCB, 0x5E, 0x24, 0xF9, 0xD1, 0xE2, 0xD3, 0x10, 0x09, 0x1D, 0x08, 0x2B, 0x36, 0x7C, 0x04, 0x27, +/* 1540 */ 0xE5, 0x00, 0x88, 0xE2, 0xD3, 0x10, 0x09, 0x24, 0xA5, 0x75, 0x05, 0xF8, 0x08, 0x53, 0x4B, 0x49, +/* 1550 */ 0xD1, 0xE2, 0xD3, 0x10, 0x09, 0x59, 0x7C, 0x8F, 0xC7, 0x49, 0xD1, 0xE2, 0xD3, 0x10, 0x06, 0x1D, +/* 1560 */ 0x40, 0x08, 0x74, 0x07, 0x02, 0x26, 0x83, 0x88, 0xD2, 0x0C, 0x1F, 0x00, 0xF9, 0x5D, 0x09, 0x36, +/* 1570 */ 0x8C, 0x01, 0x27, 0xE5, 0x10, 0x09, 0x22, 0x80, 0x05, 0x05, 0x29, 0x37, 0x06, 0x26, 0x88, 0x0F, +/* 1580 */ 0xAF, 0x18, 0x9C, 0x54, 0x89, 0x3C, 0x24, 0xC5, 0x05, 0x06, 0xA2, 0x1D, 0xA5, 0x1F, 0xCB, 0x02, +/* 1590 */ 0xA3, 0x1D, 0xD7, 0xB1, 0x8F, 0xD7, 0xB1, 0x22, 0xD7, 0xB1, 0x02, 0x0A, 0xD7, 0xB1, 0x22, 0xA5, +/* 15A0 */ 0x1F, 0x06, 0x06, 0x00, 0x5F, 0x18, 0x0E, 0x06, 0x78, 0x00, 0x83, 0x18, 0xAD, 0x0C, 0xA0, 0x71, +/* 15B0 */ 0x18, 0xCB, 0x3F, 0x91, 0x57, 0x37, 0xF3, 0x06, 0x02, 0x10, 0x08, 0x59, 0xB0, 0x24, 0xE8, 0x0B, +/* 15C0 */ 0x39, 0x19, 0x66, 0x26, 0xB4, 0xB7, 0x78, 0x10, 0x08, 0x00, 0x64, 0x05, 0x03, 0x36, 0xA7, 0x91, +/* 15D0 */ 0x2C, 0x03, 0x29, 0xB4, 0xB7, 0x78, 0x10, 0x08, 0x22, 0x99, 0xA1, 0x36, 0x55, 0x42, 0x32, 0xE5, +/* 15E0 */ 0xB4, 0xB7, 0x78, 0x10, 0x08, 0xAC, 0x37, 0x06, 0x89, 0x32, 0xE5, 0xB4, 0xB7, 0x78, 0x10, 0x07, +/* 15F0 */ 0x29, 0x46, 0x06, 0x29, 0x76, 0x08, 0x24, 0xF9, 0x29, 0x5A, 0xBA, 0x3E, 0x03, 0x1F, 0x10, 0x07, +/* 1600 */ 0x25, 0x0C, 0x70, 0x7B, 0x0E, 0x38, 0x26, 0x30, 0x02, 0xA3, 0x06, 0x4D, 0xCB, 0x0C, 0xF2, 0xAD, +/* 1610 */ 0xF2, 0x4A, 0x4D, 0x03, 0x97, 0x57, 0x7B, 0x0E, 0x0E, 0x08, 0x26, 0x30, 0x6E, 0x6C, 0x10, 0x07, +/* 1620 */ 0x1C, 0x3B, 0x0E, 0x0D, 0xF8, 0x08, 0x1E, 0xAD, 0x26, 0x38, 0x00, 0x2A, 0x26, 0x75, 0x8F, 0x06, +/* 1630 */ 0x26, 0x75, 0x42, 0x36, 0x75, 0x2A, 0xF8, 0x75, 0x9C, 0x94, 0x57, 0x75, 0x24, 0x4A, 0x22, 0xC5, +/* 1640 */ 0xD7, 0x0F, 0x57, 0x75, 0x01, 0x02, 0x1B, 0x57, 0x75, 0xA3, 0x39, 0x10, 0x07, 0x23, 0x5E, 0x1D, +/* 1650 */ 0x46, 0xA2, 0x1A, 0xBC, 0x1E, 0x10, 0x07, 0x1C, 0xA5, 0x79, 0x2C, 0x38, 0x01, 0x1A, 0xBC, 0x1E, +/* 1660 */ 0x10, 0x07, 0x80, 0x95, 0x20, 0x07, 0x0A, 0x04, 0xA1, 0x26, 0xE5, 0x00, 0xBC, 0x1E, 0x10, 0x07, +/* 1670 */ 0x34, 0x03, 0x8D, 0x06, 0x7D, 0xCB, 0xF4, 0x48, 0x21, 0x80, 0xBC, 0x1E, 0x10, 0x07, 0x1C, 0x84, +/* 1680 */ 0x00, 0x39, 0x73, 0x1A, 0xBC, 0x1E, 0x10, 0x07, 0x34, 0x37, 0x8D, 0x2C, 0x91, 0x0B, 0x29, 0x7B, +/* 1690 */ 0xF3, 0x6E, 0xBC, 0x1E, 0x10, 0x0B, 0xA6, 0x76, 0x0F, 0x0B, 0xA7, 0x5D, 0x02, 0x22, 0xD7, 0x66, +/* 16A0 */ 0x0C, 0x97, 0x01, 0x83, 0x57, 0x95, 0x00, 0xA5, 0xB1, 0x22, 0x42, 0x0E, 0x3F, 0x33, 0x1F, 0x24, +/* 16B0 */ 0x45, 0x07, 0x02, 0xAD, 0x66, 0x66, 0x22, 0x5F, 0x24, 0x9D, 0x68, 0x04, 0x71, 0x4E, 0xAE, 0xA4, +/* 16C0 */ 0x07, 0x1D, 0x87, 0x8C, 0x4E, 0xF7, 0x10, 0x06, 0xA6, 0x99, 0x0E, 0x8C, 0xDF, 0xFC, 0x3A, 0x19, +/* 16D0 */ 0x8E, 0xA4, 0x03, 0x43, 0x08, 0x5C, 0x29, 0x39, 0x19, 0x86, 0x32, 0x9C, 0x0F, 0x0C, 0x73, 0x10, +/* 16E0 */ 0x07, 0x23, 0x82, 0x6E, 0xB0, 0xDE, 0x6A, 0xA7, 0xE1, 0xC2, 0x10, 0x07, 0x1C, 0x7F, 0x4A, 0x29, +/* 16F0 */ 0x67, 0x02, 0x1A, 0xA7, 0xE1, 0xC2, 0x10, 0x07, 0x80, 0x9D, 0x07, 0x00, 0xF9, 0x91, 0x41, 0x43, +/* 1700 */ 0xE5, 0xA7, 0xE1, 0xC2, 0x10, 0x07, 0x1C, 0x53, 0x37, 0x06, 0x2C, 0x7F, 0x1A, 0xA7, 0xE1, 0xC2, +/* 1710 */ 0x10, 0x04, 0x2F, 0x47, 0x3E, 0x9C, 0x27, 0xAC, 0xE7, 0xE7, 0x10, 0x04, 0x1C, 0x88, 0x32, 0xCB, +/* 1720 */ 0x09, 0x7D, 0x64, 0xE7, 0xE7, 0x10, 0x04, 0x7E, 0x03, 0x9E, 0x24, 0x46, 0x8C, 0x9A, 0x36, 0x74, +/* 1730 */ 0xA5, 0x00, 0x1A, 0xE7, 0xE7, 0x10, 0x04, 0x29, 0x80, 0x89, 0xB0, 0x09, 0xCD, 0x24, 0xE7, 0xE7, +/* 1740 */ 0x10, 0x07, 0x24, 0x1A, 0x46, 0x36, 0x44, 0x76, 0x29, 0x63, 0x09, 0x29, 0x41, 0x75, 0xD1, 0x26, +/* 1750 */ 0x4E, 0x0D, 0x63, 0x7D, 0xAE, 0x4C, 0xAF, 0xD6, 0x01, 0x24, 0x6C, 0x56, 0x22, 0x75, 0xD6, 0x01, +/* 1760 */ 0x7F, 0x94, 0x57, 0xAE, 0x02, 0x76, 0x26, 0x03, 0x7B, 0x27, 0x10, 0x07, 0x80, 0x5A, 0x01, 0x08, +/* 1770 */ 0x26, 0x03, 0x09, 0x07, 0xAF, 0x73, 0x1A, 0x8D, 0xB3, 0x10, 0x07, 0x23, 0x61, 0x3E, 0xA0, 0x1E, +/* 1780 */ 0x6A, 0xBB, 0xB9, 0xEC, 0x10, 0x07, 0x23, 0xB2, 0xBB, 0xB9, 0xEC, 0x10, 0x07, 0x80, 0x6B, 0x08, +/* 1790 */ 0x24, 0x46, 0x91, 0x55, 0x36, 0xE5, 0xBB, 0xB9, 0xEC, 0x10, 0x07, 0x80, 0xCC, 0xBB, 0xB9, 0xEC, +/* 17A0 */ 0x10, 0x07, 0x1C, 0x4E, 0x00, 0x8B, 0xCD, 0xBB, 0xB9, 0xEC, 0x10, 0x06, 0x35, 0x7C, 0x19, 0x4A, +/* 17B0 */ 0x1A, 0x85, 0x1A, 0x7C, 0x19, 0x4A, 0x10, 0x07, 0x18, 0x23, 0xE8, 0xF3, 0x84, 0x26, 0xA7, 0x3F, +/* 17C0 */ 0x07, 0x26, 0x5A, 0x89, 0x1F, 0x18, 0x65, 0xA4, 0x61, 0x07, 0x56, 0x00, 0x08, 0x03, 0xA2, 0x18, +/* 17D0 */ 0x6B, 0x8F, 0xCB, 0x09, 0x18, 0x3A, 0x0A, 0x8F, 0x07, 0x57, 0x0C, 0x38, 0xA3, 0x02, 0x57, 0x65, +/* 17E0 */ 0x5C, 0x26, 0x89, 0x24, 0xE8, 0x07, 0x10, 0x07, 0x23, 0xA2, 0x3E, 0xA0, 0xDE, 0x6A, 0x51, 0xBF, +/* 17F0 */ 0x81, 0x10, 0x07, 0x23, 0xB2, 0x51, 0xBF, 0x81, 0x10, 0x07, 0x24, 0x64, 0x5B, 0x08, 0xE8, 0x91, +/* 1800 */ 0x0B, 0x06, 0x36, 0xE5, 0x51, 0xBF, 0x81, 0x10, 0x07, 0x1C, 0xF4, 0xCB, 0x07, 0xCD, 0x51, 0xBF, +/* 1810 */ 0x81, 0x10, 0x06, 0x23, 0x03, 0x41, 0x00, 0xF9, 0x41, 0x19, 0xDC, 0xC9, 0x6D, 0xF6, 0x10, 0x07, +/* 1820 */ 0x80, 0x49, 0xEA, 0x0D, 0x4A, 0xCF, 0xB8, 0xC1, 0x0B, 0x05, 0x10, 0x06, 0x2F, 0x8F, 0x05, 0x89, +/* 1830 */ 0x32, 0xE5, 0x67, 0x24, 0xC9, 0x6D, 0xF6, 0x10, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x15, 0x00, 0x0B, +/* 1840 */ 0x07, 0x59, 0x40, 0x87, 0x0E, 0x33, 0x0A, 0xB6, 0x66, 0x60, 0x10, 0x07, 0x80, 0x40, 0x95, 0x33, +/* 1850 */ 0x81, 0xB6, 0x02, 0x66, 0x10, 0x0A, 0x80, 0x40, 0x95, 0x0E, 0x33, 0x33, 0x08, 0x24, 0x7F, 0x02, +/* 1860 */ 0x66, 0x66, 0x66, 0x60, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x06, +/* 1870 */ 0x14, 0x00, 0x00, 0x06, 0x16, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x06, +/* 1880 */ 0x19, 0x00, 0x00, 0x06, 0xD7, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x0F, +/* 1890 */ 0xE2, 0x00, 0x00, 0x10, 0xA2, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x18, +/* 18A0 */ 0x38, 0x00, 0x00, 0x18, 0x40, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular16.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular16.mcufont.h new file mode 100644 index 000000000..01d7a5d5d --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular16.mcufont.h @@ -0,0 +1,474 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 16 + * blob size: 7228, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x04, 0x31, 0x00, 0x00, 0x04, 0xAC, 0x00, 0x00, 0x00, 0x98, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x1B, 0xFC, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x0F, 0x00, 0x17, 0x00, 0x03, 0x00, 0x0F, 0x00, 0x01, 0x00, 0x11, 0x00, 0x13, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x31, 0x36, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x31, 0x36, 0x00, +/* dictionary data */ +0x06, 0x0B, 0x07, 0xC3, 0xDB, +/* 0080 */ 0x0D, 0xDB, 0x0D, 0xDB, 0x07, 0x05, 0x0D, 0xCA, 0xCD, 0x0D, 0xCA, 0xCD, 0x0D, 0x08, 0x03, 0xCE, +/* 0090 */ 0xC7, 0x01, 0x03, 0xC2, 0x0A, 0x41, 0x26, 0xC2, 0x0B, 0x3F, 0xC7, 0xCE, 0x0D, 0x07, 0xCA, 0xCD, +/* 00A0 */ 0x0C, 0xC2, 0x04, 0x82, 0xCC, 0xC8, 0xCD, 0x09, 0x3D, 0xC4, 0xCC, 0x04, 0xC8, 0x30, 0x08, 0xC2, +/* 00B0 */ 0x40, 0x1C, 0x0A, 0xC5, 0xC2, 0x09, 0x80, 0xC6, 0x02, 0xC1, 0x1A, 0xC1, 0x08, 0xCC, 0xCA, 0x80, +/* 00C0 */ 0xC6, 0xCD, 0xCC, 0x21, 0xC7, 0xCD, 0x80, 0xC5, 0xCA, 0xCB, 0xC5, 0xCD, 0xCA, 0xCD, 0x84, 0xC1, +/* 00D0 */ 0x0B, 0xCE, 0xC6, 0x09, 0xC5, 0x01, 0xC1, 0x08, 0xC1, 0x80, 0xC7, 0xE3, 0x80, 0xCA, 0x0C, 0xC1, +/* 00E0 */ 0xCE, 0xCA, 0x0E, 0xC1, 0xCC, 0x40, 0x0D, 0xC1, 0xC2, 0x02, 0xC6, 0x0C, 0xCE, 0xC5, 0xCE, 0xC1, +/* 00F0 */ 0xDA, 0xC2, 0xCA, 0xCE, 0xCA, 0xCC, 0x80, 0xC4, 0xCD, 0xC4, 0x80, 0xCB, 0xCD, 0xC9, 0x01, 0xC2, +/* 0100 */ 0x1B, 0xCD, 0xCB, 0x07, 0xC1, 0xC1, 0x05, 0xC9, 0xCD, 0xCC, 0x01, 0xC8, 0xCB, 0x07, 0x02, 0xCE, +/* 0110 */ 0xCC, 0xC9, 0xCB, 0xC4, 0x80, 0xC4, 0xCE, 0xCB, 0xC9, 0xCD, 0xCA, 0xCE, 0xC2, 0xC9, 0xCC, 0xD3, +/* 0120 */ 0xCA, 0x81, 0xC3, 0xC6, 0xC9, 0xCA, 0xC1, 0xC9, 0x80, 0xC3, 0x02, 0xC4, 0xC5, 0xC5, 0xC3, 0xD2, +/* 0130 */ 0xC3, 0x09, 0x80, 0xC2, 0x01, 0xC1, 0x80, 0xCE, 0xC9, 0x80, 0xCC, 0xCE, 0xC3, 0x0F, 0x40, 0x37, +/* 0140 */ 0xD8, 0x01, 0xC8, 0xCD, 0xC7, 0xC8, 0x19, 0x09, 0xC8, 0xCC, 0x40, 0x1D, 0xCD, 0xC8, 0x01, 0xC5, +/* 0150 */ 0x02, 0xC3, 0xC1, 0xCA, 0xC4, 0xCA, 0x80, 0xCE, 0x01, 0xC3, 0x80, 0xC1, 0x08, 0xCB, 0xCA, 0xC6, +/* 0160 */ 0xCB, 0x80, 0xC9, 0xCD, 0xC5, 0x01, 0xC8, 0xC1, 0x01, 0xCD, 0xC7, 0x80, 0xC8, 0xC4, 0xC9, 0x80, +/* 0170 */ 0x02, 0xCC, 0xC9, 0xC1, 0xC4, 0xCE, 0xC4, 0x02, 0x40, 0x14, 0x22, 0xC2, 0x01, 0xC4, 0xCB, 0xC6, +/* 0180 */ 0xCC, 0x81, 0x02, 0xC5, 0xC5, 0xC4, 0xCD, 0xC3, 0xCC, 0xCB, 0xCA, 0xC9, 0xCE, 0xCB, 0xDB, 0xDD, +/* 0190 */ 0xCD, 0xC6, 0xC4, 0x80, 0xC3, 0xC6, 0xCD, 0xC3, 0xCB, 0x80, 0xC1, 0x02, 0xC9, 0xC4, 0xD4, 0xCE, +/* 01A0 */ 0xC8, 0x1D, 0x99, 0x19, 0x99, 0x33, 0x43, 0x07, 0x82, 0x6D, 0x45, 0x03, 0x44, 0x99, 0x19, 0x54, +/* 01B0 */ 0x06, 0x05, 0x82, 0x4F, 0x41, 0x0E, 0xA9, 0x1F, 0xA6, 0x64, 0xA9, 0x1F, 0xA6, 0x64, 0x42, 0x1E, +/* 01C0 */ 0x42, 0x1E, 0x42, 0x18, 0x29, 0x1E, 0x94, 0x2A, 0x21, 0x89, 0x77, 0x1C, 0x0B, 0x0C, 0x00, 0x47, +/* 01D0 */ 0x49, 0x1F, 0xA6, 0x20, 0x5C, 0x1F, 0xA6, 0x20, 0x6A, 0x1F, 0xA6, 0x20, 0x5C, 0x1F, 0xA6, 0x00, +/* 01E0 */ 0x3A, 0x52, 0x8C, 0x3A, 0x52, 0x8C, 0x3A, 0x52, 0x8C, 0x3A, 0x52, 0x8C, 0x3A, 0x52, 0x8C, 0x3A, +/* 01F0 */ 0x52, 0x8C, 0x8D, 0x64, 0x07, 0x8C, 0x62, 0x01, 0x03, 0x0D, 0x8C, 0x01, 0x0B, 0xA5, 0x05, 0x0F, +/* 0200 */ 0x28, 0x83, 0x33, 0x59, 0x47, 0x3F, 0x82, 0x93, 0x86, 0xAC, 0x1C, 0x66, 0x00, 0x66, 0x35, 0x0E, +/* 0210 */ 0x00, 0x0C, 0x07, 0x23, 0x78, 0xA9, 0x19, 0x0C, 0x0C, 0x0D, 0x1F, 0x31, 0x8F, 0x4C, 0x99, 0x23, +/* 0220 */ 0x58, 0x20, 0x33, 0xA7, 0x25, 0x01, 0x05, 0x01, 0x9B, 0x3F, 0x29, 0x22, 0x3F, 0x1C, 0x04, 0x9D, +/* 0230 */ 0x7B, 0x1C, 0x0A, 0x55, 0x20, 0x5F, 0x1C, 0x79, 0x31, 0xAC, 0x22, 0x37, 0xA0, 0x72, 0x00, 0x87, +/* 0240 */ 0x37, 0xA0, 0x59, 0x64, 0x22, 0x37, 0xA0, 0x72, 0x2B, 0x8F, 0x31, 0xAC, 0x2B, 0x42, 0x01, 0x20, +/* 0250 */ 0x5F, 0x1A, 0xA5, 0x04, 0x89, 0x7B, 0x1F, 0xAB, 0x0E, 0xA5, 0x03, 0x28, 0x45, 0x1D, 0x1A, 0x8F, +/* 0260 */ 0x28, 0x54, 0x2A, 0x0E, 0x73, 0x6F, 0x59, 0x28, 0x85, 0x82, 0xAB, 0x0E, 0x0F, 0x94, 0x48, 0x3C, +/* 0270 */ 0x04, 0x03, 0xAF, 0x1F, 0x04, 0x72, 0x85, 0x18, 0xA0, 0x77, 0x01, 0xAF, 0x48, 0x4B, 0x03, 0x0A, +/* 0280 */ 0xA5, 0x82, 0x41, 0xAF, 0x03, 0x0D, 0x04, 0x64, 0xA9, 0x1F, 0xA3, 0x64, 0xA6, 0x46, 0x0F, 0x75, +/* 0290 */ 0x59, 0x23, 0x5C, 0x83, 0x82, 0x52, 0x0E, 0x54, 0x53, 0xA7, 0x28, 0xA3, 0x28, 0xA3, 0x28, 0xA3, +/* 02A0 */ 0x28, 0x0C, 0x0E, 0x5B, 0x36, 0x07, 0x3B, 0x30, 0x0D, 0x39, 0x79, 0x87, 0x3F, 0x2B, 0x22, 0x3F, +/* 02B0 */ 0x20, 0xAF, 0x1A, 0x3F, 0x20, 0x5C, 0x60, 0x3F, 0x20, 0xAF, 0x1F, 0x79, 0x87, 0x3F, 0x1F, 0x07, +/* 02C0 */ 0x3B, 0x0D, 0x59, 0x20, 0x33, 0x0F, 0x85, 0x19, 0xAA, 0x3E, 0x19, 0x69, 0x03, 0x77, 0x48, 0x3F, +/* 02D0 */ 0x00, 0x45, 0x82, 0x67, 0x92, 0x40, 0x82, 0x6C, 0x52, 0x0E, 0x82, 0x0D, 0x43, 0x04, 0x1A, 0x0F, +/* 02E0 */ 0x2D, 0x28, 0x2D, 0x28, 0x2D, 0x28, 0x2D, 0x28, 0x2D, 0x28, 0x2D, 0x1F, 0x3A, 0x20, 0xA9, 0x1C, +/* 02F0 */ 0x3A, 0x20, 0xA9, 0x1C, 0x3A, 0x20, 0xA9, 0x1C, 0x3A, 0x20, 0xA9, 0x1C, 0x3A, 0x20, 0xA9, 0x1C, +/* 0300 */ 0x3A, 0x20, 0xA9, 0x1C, 0x3A, 0x20, 0xA9, 0x1C, 0xA3, 0x20, 0xA9, 0x29, 0x20, 0x07, 0xAC, 0x1D, +/* 0310 */ 0x04, 0x8F, 0x03, 0x05, 0x4D, 0x46, 0x0C, 0x0E, 0x0E, 0x79, 0x23, 0x27, 0xA1, 0x85, 0x82, 0xAF, +/* 0320 */ 0x52, 0x06, 0xAC, 0x23, 0x30, 0x2E, 0x91, 0x0E, 0x5B, 0x02, 0x2B, 0x84, 0x20, 0x7D, 0x69, 0x3B, +/* 0330 */ 0x1F, 0x04, 0x4C, 0x59, 0x53, 0x78, 0x04, 0x2B, 0x22, 0x3F, 0x00, 0x5D, 0x59, 0x60, 0x37, 0x02, +/* 0340 */ 0x59, 0x1F, 0x1C, 0x9A, 0x5C, 0x2A, 0x3B, 0x1D, 0x1A, 0x3F, 0x2A, 0x3B, 0x28, 0x79, 0x82, 0x31, +/* 0350 */ 0x3B, 0x95, 0x1C, 0x0A, 0x0F, 0x0D, 0x20, 0x3F, 0x1C, 0x56, 0x3F, 0x64, 0x3F, 0x1C, 0xA4, 0x40, +/* 0360 */ 0x64, 0x3F, 0x1C, 0x56, 0x04, 0x77, 0x3F, 0x1C, 0x56, 0x00, 0x85, 0x00, 0x3F, 0x1C, 0x40, 0x00, +/* 0370 */ 0x07, 0x55, 0x3F, 0x1C, 0x40, 0x47, 0x45, 0x54, 0x1C, 0x40, 0x64, 0x6C, 0x90, 0x1C, 0x40, 0x87, +/* 0380 */ 0x0F, 0x54, 0x1C, 0x40, 0x20, 0x0C, 0x3F, 0x20, 0x9A, 0x63, 0x20, 0x07, 0x0C, 0x91, 0x0B, 0x20, +/* 0390 */ 0x82, 0x0A, 0xA2, 0x3B, 0x30, 0x59, 0x1F, 0x6A, 0x87, 0x59, 0x2B, 0x22, 0x37, 0x02, 0x0F, 0x2A, +/* 03A0 */ 0x59, 0x01, 0x49, 0x53, 0x4F, 0x61, 0x88, 0x96, 0x52, 0x0A, 0x18, 0x3A, 0x0F, 0x2B, 0xA2, 0x18, +/* 03B0 */ 0x51, 0x96, 0x86, 0x0C, 0x33, 0x0F, 0x20, 0x0C, 0x05, 0x33, 0x54, 0x82, 0x0B, 0x00, 0x29, 0x20, +/* 03C0 */ 0x02, 0x43, 0x06, 0x82, 0xA6, 0x52, 0x8C, 0xA6, 0x52, 0x0B, 0x0D, 0x2B, 0x6A, 0x1C, 0x67, 0x1F, +/* 03D0 */ 0x07, 0x0F, 0x20, 0x18, 0x1A, 0x02, 0x03, 0x28, 0x07, 0x8F, 0x01, 0x2A, 0x08, 0x08, 0x02, 0x64, +/* 03E0 */ 0x9C, 0x81, 0x89, 0x0E, 0x39, 0x0B, 0x0D, 0x92, 0x64, 0x47, 0x03, 0x53, 0x28, 0x1B, 0x28, 0x06, +/* 03F0 */ 0x4A, 0x00, 0x06, 0x0A, 0x2C, 0x5B, 0x64, 0x29, 0x4A, 0x36, 0x42, 0x1E, 0x6E, 0x9F, 0x36, 0x42, +/* 0400 */ 0x4A, 0x20, 0x29, 0x18, 0x29, 0x18, 0x29, 0x4A, 0x36, 0x6E, 0x9F, 0x0D, 0x42, 0x1E, 0x00, 0x04, +/* 0410 */ 0x0F, 0x00, 0x2A, 0x0F, 0x00, 0x2A, 0x20, 0x22, 0x9E, 0x0E, 0x85, 0x23, 0x2B, 0x7D, 0x3E, 0x4D, +/* 0420 */ 0x36, 0x6C, 0x28, 0x54, 0x2B, 0x47, 0x6B, 0x1D, 0x7B, 0x20, 0x52, 0x0A, 0x64, 0x4C, 0x28, 0x7F, +/* 0430 */ 0x01, 0x07, 0x3A, 0x28, 0x40, 0x28, 0x40, 0x28, 0x40, 0x28, 0x40, 0x19, 0x1D, 0x52, 0x01, 0x23, +/* 0440 */ 0x20, 0x48, 0x00, 0x35, 0x7B, 0x23, 0x00, 0x40, 0x28, 0xA6, 0x82, 0x9B, 0x1B, 0x57, 0xA5, 0x03, +/* 0450 */ 0x33, 0xA5, 0x01, 0x82, 0x5A, 0x82, 0xAA, 0xA8, 0x23, 0x3B, 0x53, 0x0E, 0x64, 0x5A, 0x82, 0x0A, +/* 0460 */ 0x07, 0x86, 0x0C, 0x00, 0x0C, 0x03, 0x20, 0x22, 0x0E, 0x92, 0x6E, 0x8A, 0x18, 0x7E, 0x5D, 0x20, +/* 0470 */ 0x35, 0x01, 0x53, 0x9D, 0xAF, 0x01, 0x53, 0x48, 0x3F, 0x87, 0x0F, 0x02, 0x1A, 0x43, 0x72, 0x64, +/* 0480 */ 0x22, 0x49, 0x4A, 0x76, 0xAF, 0x28, 0x07, 0x45, 0x03, 0x80, 0x18, 0x31, 0x0E, 0x7A, 0x04, 0x34, +/* 0490 */ 0x5C, 0x1C, 0x27, 0x2B, 0x62, 0x1C, 0xA6, 0x64, 0x52, 0x77, 0x82, 0x9B, 0x54, 0x23, 0xA6, 0x64, +/* 04A0 */ 0x7F, 0xA0, 0xAC, 0x64, 0xA6, 0x64, 0x7F, 0xA0, 0x0F, 0x00, 0x47, 0x3F, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, +/* 04B0 */ 0x00, 0x02, 0x00, 0x04, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0B, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, +/* 04C0 */ 0x00, 0x17, 0x00, 0x19, 0x00, 0x1A, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x21, 0x00, 0x22, +/* 04D0 */ 0x00, 0x25, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2B, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x30, +/* 04E0 */ 0x00, 0x32, 0x00, 0x33, 0x00, 0x35, 0x00, 0x37, 0x00, 0x39, 0x00, 0x3B, 0x00, 0x3E, 0x00, 0x40, +/* 04F0 */ 0x00, 0x42, 0x00, 0x44, 0x00, 0x46, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4F, +/* 0500 */ 0x00, 0x51, 0x00, 0x53, 0x00, 0x54, 0x00, 0x56, 0x00, 0x58, 0x00, 0x5A, 0x00, 0x5C, 0x00, 0x5E, +/* 0510 */ 0x00, 0x60, 0x00, 0x61, 0x00, 0x63, 0x00, 0x65, 0x00, 0x67, 0x00, 0x68, 0x00, 0x6A, 0x00, 0x6C, +/* 0520 */ 0x00, 0x6E, 0x00, 0x70, 0x00, 0x71, 0x00, 0x73, 0x00, 0x75, 0x00, 0x76, 0x00, 0x79, 0x00, 0x7B, +/* 0530 */ 0x00, 0x7D, 0x00, 0x7F, 0x00, 0x81, 0x00, 0x83, 0x00, 0x85, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8A, +/* 0540 */ 0x00, 0x8C, 0x00, 0x8E, 0x00, 0x93, 0x00, 0x94, 0x00, 0x96, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, +/* 0550 */ 0x00, 0x9E, 0x00, 0xA0, 0x00, 0xA2, 0x00, 0xA4, 0x00, 0xA5, 0x00, 0xA7, 0x00, 0xA9, 0x00, 0xAB, +/* 0560 */ 0x00, 0xAD, 0x00, 0xB0, 0x00, 0xB2, 0x00, 0xB4, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xBA, 0x00, 0xBC, +/* 0570 */ 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC2, 0x00, 0xC3, 0x00, 0xC5, 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCB, +/* 0580 */ 0x00, 0xCC, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5, 0x00, 0xD7, 0x00, 0xD9, +/* 0590 */ 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE2, 0x00, 0xE4, 0x00, 0xE6, 0x00, 0xE8, 0x00, 0xEA, +/* 05A0 */ 0x00, 0xEC, 0x00, 0xEE, 0x00, 0xF0, 0x00, 0xF2, 0x00, 0xF4, 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xFA, +/* 05B0 */ 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x01, 0x07, 0x01, 0x09, +/* 05C0 */ 0x01, 0x0B, 0x01, 0x0D, 0x01, 0x0F, 0x01, 0x11, 0x01, 0x13, 0x01, 0x14, 0x01, 0x15, 0x01, 0x17, +/* 05D0 */ 0x01, 0x1A, 0x01, 0x1C, 0x01, 0x1E, 0x01, 0x21, 0x01, 0x23, 0x01, 0x24, 0x01, 0x26, 0x01, 0x34, +/* 05E0 */ 0x01, 0x3B, 0x01, 0x43, 0x01, 0x4B, 0x01, 0x4E, 0x01, 0x65, 0x01, 0x85, 0x01, 0x87, 0x01, 0xAE, +/* 05F0 */ 0x01, 0xB3, 0x01, 0xE1, 0x01, 0xE9, 0x02, 0x0B, 0x02, 0x27, 0x02, 0x46, 0x02, 0x65, 0x02, 0x71, +/* 0600 */ 0x02, 0x9D, 0x02, 0xA6, 0x02, 0xA9, 0x02, 0xB1, 0x02, 0xB4, 0x02, 0xB6, 0x02, 0xBB, 0x02, 0xC7, +/* 0610 */ 0x02, 0xC9, 0x02, 0xD7, 0x03, 0x0E, 0x03, 0x15, 0x03, 0x18, 0x03, 0x24, 0x03, 0x26, 0x03, 0x29, +/* 0620 */ 0x03, 0x3F, 0x03, 0x42, 0x03, 0x45, 0x03, 0x49, 0x03, 0x4E, 0x03, 0x54, 0x03, 0x58, 0x03, 0x5A, +/* 0630 */ 0x03, 0x63, 0x03, 0x67, 0x03, 0x6D, 0x03, 0x6F, 0x03, 0x71, 0x03, 0x74, 0x03, 0x76, 0x03, 0x78, +/* 0640 */ 0x03, 0x91, 0x03, 0x93, 0x03, 0x95, 0x03, 0x9B, 0x03, 0x9D, 0x03, 0xA1, 0x03, 0xA6, 0x03, 0xA8, +/* 0650 */ 0x03, 0xB3, 0x03, 0xB5, 0x03, 0xB7, 0x03, 0xB9, 0x03, 0xC1, 0x03, 0xC3, 0x03, 0xC5, 0x03, 0xC7, +/* 0660 */ 0x03, 0xC9, 0x03, 0xCB, 0x03, 0xD2, 0x03, 0xD7, 0x03, 0xD9, 0x03, 0xDE, 0x03, 0xE0, 0x03, 0xF4, +/* 0670 */ 0x03, 0xF6, 0x03, 0xFC, 0x04, 0x15, 0x04, 0x21, 0x04, 0x23, 0x04, 0x2E, 0x04, 0x31, +/* char range info */ +0x00, 0x00, +/* 0680 */ 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x2F, 0x00, 0x60, 0x00, 0x9C, 0x00, +/* 0690 */ 0xE6, 0x01, 0x22, 0x01, 0x2D, 0x01, 0x51, 0x01, 0x78, 0x01, 0x92, 0x01, 0x97, 0x01, 0x9F, 0x01, +/* 06A0 */ 0xA8, 0x01, 0xAF, 0x01, 0xD2, 0x02, 0x01, 0x02, 0x10, 0x02, 0x32, 0x02, 0x5A, 0x02, 0x80, 0x02, +/* 06B0 */ 0xA5, 0x02, 0xD3, 0x02, 0xF0, 0x03, 0x23, 0x03, 0x56, 0x03, 0x61, 0x03, 0x6C, 0x03, 0x7B, 0x03, +/* 06C0 */ 0x89, 0x03, 0x9A, 0x03, 0xBC, 0x04, 0x21, 0x04, 0x28, 0x04, 0x54, 0x04, 0x78, 0x04, 0x9F, 0x04, +/* 06D0 */ 0xA3, 0x04, 0xB5, 0x04, 0xE8, 0x04, 0xFE, 0x05, 0x03, 0x05, 0x1B, 0x05, 0x43, 0x05, 0x51, 0x05, +/* 06E0 */ 0x99, 0x05, 0xA1, 0x05, 0xA6, 0x05, 0xC4, 0x05, 0xFB, 0x06, 0x27, 0x06, 0x52, 0x06, 0x67, 0x06, +/* 06F0 */ 0x6D, 0x06, 0x99, 0x06, 0xEC, 0x07, 0x1A, 0x07, 0x20, 0x07, 0x46, 0x07, 0x59, 0x07, 0x7F, 0x07, +/* 0700 */ 0x92, 0x07, 0xA7, 0x07, 0xB4, 0x07, 0xBD, 0x07, 0xC3, 0x07, 0xF0, 0x07, 0xFD, 0x08, 0x1C, 0x08, +/* 0710 */ 0x23, 0x08, 0x40, 0x08, 0x7D, 0x08, 0x8D, 0x08, 0x93, 0x08, 0xA1, 0x08, 0xCB, 0x08, 0xE1, 0x09, +/* 0720 */ 0x01, 0x09, 0x0C, 0x09, 0x11, 0x09, 0x2A, 0x09, 0x49, 0x09, 0x5C, 0x09, 0x81, 0x09, 0x9C, 0x09, +/* 0730 */ 0xA2, 0x09, 0xC6, 0x0A, 0x05, 0x0A, 0x2A, 0x0A, 0x34, 0x0A, 0x52, 0x0A, 0x74, 0x0A, 0x80, 0x0A, +/* 0740 */ 0xA4, 0x04, 0x00, 0x10, 0x04, 0x34, 0x79, 0x28, 0xAF, 0x28, 0x85, 0x28, 0x85, 0x28, 0x93, 0x28, +/* 0750 */ 0x0C, 0x07, 0x28, 0x0C, 0x07, 0x28, 0x0C, 0x06, 0x7C, 0x4C, 0x4D, 0x4C, 0x5C, 0x10, 0x06, 0x9A, +/* 0760 */ 0x60, 0x59, 0x67, 0xEF, 0x0F, 0x6D, 0x0F, 0xEF, 0x7B, 0x02, 0x0F, 0x19, 0x6B, 0x01, 0x0E, 0x10, +/* 0770 */ 0x08, 0x84, 0x5A, 0x91, 0x0A, 0x00, 0x48, 0x77, 0x0A, 0x08, 0x1C, 0xE3, 0x43, 0x3F, 0x60, 0x3E, +/* 0780 */ 0x6D, 0x45, 0x39, 0x8E, 0x47, 0x77, 0x2B, 0x31, 0x0A, 0x8B, 0x0F, 0x23, 0x0A, 0x08, 0x86, 0x2E, +/* 0790 */ 0x0C, 0x43, 0x0C, 0x33, 0x45, 0x03, 0x40, 0x36, 0x77, 0x0A, 0x08, 0x00, 0x33, 0x96, 0x0C, 0x06, +/* 07A0 */ 0x10, 0x08, 0x00, 0x32, 0x0A, 0x07, 0x28, 0x0A, 0x07, 0x4C, 0x0B, 0x08, 0xF1, 0x0E, 0x9F, 0xA2, +/* 07B0 */ 0x48, 0x4D, 0x51, 0x7E, 0x1A, 0x59, 0x4C, 0x94, 0x18, 0xEE, 0x5B, 0x05, 0x1D, 0x1A, 0x09, 0x0F, +/* 07C0 */ 0x0D, 0x02, 0x2A, 0x3C, 0x18, 0xEE, 0x8C, 0x01, 0x64, 0x91, 0x0F, 0x00, 0xEE, 0x45, 0x6F, 0x79, +/* 07D0 */ 0x82, 0x3E, 0x0F, 0x79, 0x44, 0x0A, 0x07, 0x28, 0x0A, 0x07, 0x28, 0x74, 0x10, 0x0C, 0x9A, 0x75, +/* 07E0 */ 0x2B, 0x52, 0x0E, 0x45, 0x20, 0xA4, 0x64, 0x22, 0x3F, 0x05, 0x77, 0x68, 0x61, 0x04, 0x0D, 0x64, +/* 07F0 */ 0x90, 0x00, 0xA8, 0xE5, 0x0E, 0x75, 0x6B, 0x07, 0x0C, 0x00, 0xEE, 0x0E, 0x45, 0x02, 0x0E, 0xDD, +/* 0800 */ 0x69, 0x05, 0x0E, 0x5A, 0x18, 0xA0, 0x7B, 0x3F, 0x06, 0x55, 0x20, 0xDC, 0xA8, 0x05, 0x0C, 0x64, +/* 0810 */ 0x7B, 0x18, 0x83, 0x86, 0x0C, 0x64, 0x7B, 0x64, 0x22, 0x7B, 0x5D, 0x3F, 0x06, 0x0E, 0x61, 0x09, +/* 0820 */ 0x09, 0x00, 0x52, 0x0E, 0x90, 0x60, 0x10, 0x0B, 0x84, 0x30, 0x65, 0x76, 0x01, 0x4D, 0x03, 0x0A, +/* 0830 */ 0x0E, 0x64, 0x1A, 0x0F, 0x03, 0xE3, 0x8C, 0x01, 0x21, 0x62, 0x20, 0xEE, 0x0E, 0x42, 0x02, 0x35, +/* 0840 */ 0x0E, 0x37, 0x07, 0x05, 0x1D, 0xE3, 0x3F, 0x05, 0x3F, 0x00, 0x54, 0x18, 0xA6, 0x52, 0x8F, 0x55, +/* 0850 */ 0x18, 0xA3, 0x20, 0x07, 0x8F, 0x1C, 0x07, 0x49, 0x03, 0x05, 0x6A, 0x3B, 0x1C, 0x3E, 0x7A, 0x06, +/* 0860 */ 0xE0, 0x0A, 0x10, 0x03, 0x9A, 0x60, 0x59, 0x28, 0x72, 0x19, 0x7B, 0x28, 0x6B, 0x10, 0x05, 0x32, +/* 0870 */ 0xE3, 0x28, 0xAA, 0x4C, 0x54, 0x53, 0x3E, 0x28, 0x85, 0xCF, 0x00, 0xF1, 0x77, 0x19, 0xC3, 0x06, +/* 0880 */ 0x0F, 0x28, 0xC3, 0x67, 0x02, 0x23, 0xFF, 0x28, 0xEC, 0x06, 0x55, 0x28, 0x93, 0x28, 0x68, 0x64, +/* 0890 */ 0x4C, 0x10, 0x05, 0x53, 0x9B, 0xE3, 0xD8, 0x6B, 0x28, 0x40, 0xD8, 0x72, 0x19, 0x2D, 0x28, 0xE8, +/* 08A0 */ 0x06, 0x0F, 0xF9, 0x77, 0xF1, 0x77, 0xF1, 0xAC, 0x64, 0xD7, 0x23, 0x58, 0x28, 0x21, 0x19, 0x67, +/* 08B0 */ 0x02, 0x53, 0x69, 0x1D, 0x1A, 0x0E, 0x92, 0x4C, 0x10, 0x07, 0x26, 0x41, 0xF0, 0x01, 0x30, 0x5D, +/* 08C0 */ 0x64, 0xEE, 0x4D, 0x5F, 0x0E, 0x20, 0x1A, 0x0C, 0x3B, 0xF5, 0xE3, 0xAF, 0x0B, 0x19, 0x09, 0x07, +/* 08D0 */ 0x01, 0xA2, 0x10, 0x07, 0x7D, 0xB0, 0x99, 0x10, 0x03, 0x32, 0x24, 0x2A, 0xBB, 0xF9, 0x09, 0x10, +/* 08E0 */ 0x06, 0x24, 0x02, 0x0F, 0x2C, 0x2B, 0x1A, 0x4A, 0x10, 0x03, 0x9B, 0x24, 0x4C, 0xD8, 0xB4, 0x10, +/* 08F0 */ 0x07, 0x64, 0x26, 0x9D, 0xB7, 0x28, 0x0B, 0x08, 0x28, 0x99, 0x20, 0x1A, 0xAC, 0x23, 0x07, 0x0C, +/* 0900 */ 0x28, 0xA4, 0x28, 0xFD, 0x87, 0x77, 0x19, 0xAA, 0x28, 0x56, 0x28, 0xA8, 0x2A, 0x77, 0xF1, 0x0E, +/* 0910 */ 0x28, 0x6F, 0x10, 0x08, 0x84, 0x27, 0x4D, 0x01, 0x46, 0x49, 0x04, 0x6A, 0x82, 0xA6, 0x52, 0x8C, +/* 0920 */ 0x49, 0x00, 0x5D, 0x59, 0x60, 0x37, 0x01, 0x3B, 0x00, 0xE5, 0x37, 0x01, 0x49, 0x60, 0x37, 0x01, +/* 0930 */ 0xC6, 0x49, 0x00, 0x5D, 0x59, 0x1F, 0xA6, 0x52, 0x8C, 0x05, 0x49, 0x04, 0x6A, 0x23, 0x27, 0x4D, +/* 0940 */ 0x01, 0x10, 0x06, 0x9A, 0x46, 0xA5, 0x23, 0x88, 0x0E, 0xA5, 0x35, 0x0C, 0x02, 0x1B, 0xDE, 0x1B, +/* 0950 */ 0x10, 0x07, 0x34, 0x3E, 0xA5, 0x36, 0x3E, 0xA1, 0x3C, 0x82, 0x51, 0x52, 0x77, 0xF1, 0x77, 0x19, +/* 0960 */ 0x62, 0x2A, 0x45, 0x53, 0x0B, 0x0C, 0x1F, 0x31, 0x6B, 0xF1, 0xF2, 0x8B, 0x94, 0x4A, 0x39, 0x08, +/* 0970 */ 0x43, 0x05, 0x10, 0x07, 0x34, 0x7F, 0x7A, 0x76, 0x9D, 0x05, 0x9D, 0x55, 0x53, 0x67, 0x02, 0xF0, +/* 0980 */ 0x58, 0x19, 0x09, 0x7A, 0x61, 0xE5, 0x30, 0x0D, 0x00, 0x2A, 0x3F, 0x28, 0x49, 0x48, 0x01, 0x87, +/* 0990 */ 0x3F, 0x1F, 0x6C, 0x04, 0x30, 0x2E, 0x71, 0x0E, 0x4D, 0x02, 0x10, 0x08, 0x50, 0x87, 0x4E, 0x21, +/* 09A0 */ 0xF1, 0x77, 0x19, 0x40, 0x23, 0xFF, 0x53, 0x27, 0x5D, 0x0F, 0x36, 0x5C, 0x8B, 0x77, 0x1A, 0x0F, +/* 09B0 */ 0x03, 0x8B, 0x77, 0x1C, 0x07, 0x43, 0x3F, 0x60, 0x6D, 0x6F, 0x59, 0x44, 0x67, 0x25, 0xE3, 0x77, +/* 09C0 */ 0x10, 0x07, 0x34, 0x43, 0x04, 0x82, 0x94, 0x4A, 0x23, 0x3B, 0x28, 0x3B, 0x28, 0x7A, 0x0E, 0x93, +/* 09D0 */ 0x23, 0x09, 0x06, 0x03, 0x08, 0x59, 0x28, 0x79, 0x28, 0x3A, 0x4C, 0xAF, 0x18, 0xA0, 0x90, 0x89, +/* 09E0 */ 0x0E, 0x36, 0x7F, 0x7A, 0x03, 0x10, 0x08, 0x84, 0xAB, 0x0E, 0x5A, 0x00, 0x48, 0x4D, 0x73, 0x36, +/* 09F0 */ 0x7F, 0x28, 0x85, 0x0A, 0x65, 0x76, 0x8A, 0x07, 0x30, 0x0C, 0x48, 0x8F, 0x00, 0xE3, 0x77, 0xE5, +/* 0A00 */ 0x37, 0x02, 0x59, 0x1F, 0x49, 0x87, 0x59, 0x1F, 0x3A, 0x52, 0x8C, 0x06, 0x49, 0x04, 0x6A, 0x23, +/* 0A10 */ 0x27, 0x4D, 0x01, 0x10, 0x06, 0xC9, 0x0A, 0x43, 0x01, 0x33, 0x4A, 0x09, 0x0E, 0x28, 0x85, 0x1D, +/* 0A20 */ 0x1A, 0x0F, 0xDD, 0x62, 0x28, 0x21, 0xF1, 0x77, 0x19, 0x58, 0x4C, 0xF7, 0xC3, 0x8D, 0x28, 0x51, +/* 0A30 */ 0x10, 0x08, 0x34, 0x71, 0x0E, 0x4D, 0xF5, 0x42, 0xAE, 0x6A, 0x82, 0x21, 0x00, 0x27, 0x82, 0x5C, +/* 0A40 */ 0x64, 0x83, 0x46, 0xAF, 0x41, 0x76, 0x02, 0x0B, 0x0C, 0xA5, 0x36, 0x85, 0x47, 0x0B, 0x0D, 0x1C, +/* 0A50 */ 0xE3, 0x77, 0x5D, 0x59, 0x1D, 0xA0, 0x77, 0x5D, 0x3F, 0x60, 0xA5, 0x04, 0x9D, 0x0E, 0x39, 0xAB, +/* 0A60 */ 0x0E, 0xA5, 0x02, 0x10, 0x08, 0x34, 0x57, 0xAF, 0x23, 0x0C, 0x0C, 0x04, 0x06, 0xC6, 0x03, 0x59, +/* 0A70 */ 0x64, 0x58, 0x18, 0xA0, 0xAC, 0x08, 0x0E, 0x1C, 0xE3, 0x77, 0x91, 0x0F, 0x48, 0x4D, 0x01, 0x68, +/* 0A80 */ 0x0E, 0x46, 0x0E, 0x0F, 0xA3, 0x2E, 0x47, 0x9C, 0x5C, 0x53, 0x07, 0x77, 0x00, 0x48, 0x08, 0x49, +/* 0A90 */ 0x35, 0x0E, 0x90, 0x2B, 0x1A, 0x05, 0x10, 0x03, 0x7D, 0xDC, 0xD8, 0xB4, 0x19, 0x9B, 0x4C, 0xD8, +/* 0AA0 */ 0xB4, 0x10, 0x03, 0x7D, 0xDC, 0xD8, 0xB4, 0x26, 0x33, 0xBB, 0xF9, 0x09, 0x10, 0x07, 0x7D, 0xEE, +/* 0AB0 */ 0x25, 0xAA, 0xF6, 0x04, 0x49, 0x2A, 0x0B, 0xAF, 0xFA, 0x30, 0x05, 0x10, 0x07, 0x1D, 0x5E, 0x7D, +/* 0AC0 */ 0xD4, 0x6D, 0x4A, 0x39, 0x7C, 0xD4, 0x6D, 0x4A, 0x01, 0x10, 0x07, 0x20, 0x7D, 0x07, 0x01, 0x53, +/* 0AD0 */ 0x4F, 0xAF, 0xFA, 0x04, 0xAF, 0x19, 0xAA, 0xF6, 0x01, 0xA8, 0x10, 0x07, 0x34, 0x41, 0x0F, 0x5A, +/* 0AE0 */ 0x1F, 0xE3, 0x45, 0x03, 0x0A, 0xAC, 0x60, 0x64, 0xA9, 0x1D, 0x29, 0xEF, 0x4F, 0x0C, 0x25, 0x7F, +/* 0AF0 */ 0x01, 0x53, 0x56, 0x00, 0x4C, 0x92, 0x5E, 0x0C, 0x0D, 0x28, 0x0B, 0x0C, 0x10, 0x0F, 0x34, 0x22, +/* 0B00 */ 0x62, 0x0E, 0x5F, 0x05, 0xEE, 0x4B, 0x74, 0x04, 0x07, 0x4D, 0x01, 0x64, 0xA0, 0x3F, 0x64, 0xDC, +/* 0B10 */ 0x5C, 0xDC, 0x21, 0x02, 0x0C, 0x0F, 0xA8, 0x8B, 0x72, 0x06, 0x0E, 0x64, 0x5F, 0x04, 0x62, 0x64, +/* 0B20 */ 0x85, 0x64, 0x8D, 0x86, 0x0F, 0x92, 0xAA, 0x64, 0x56, 0x64, 0x85, 0x00, 0x3E, 0x64, 0xAA, 0x64, +/* 0B30 */ 0x66, 0x64, 0x45, 0x00, 0x7F, 0x64, 0xAA, 0x64, 0x56, 0x64, 0x93, 0xE0, 0x0E, 0x52, 0x0E, 0x64, +/* 0B40 */ 0x21, 0x00, 0x69, 0x5D, 0x94, 0x30, 0xA8, 0x08, 0x55, 0x64, 0x3E, 0x64, 0x41, 0x5A, 0x68, 0x5A, +/* 0B50 */ 0x22, 0xF7, 0x91, 0x99, 0x1C, 0x31, 0x4B, 0x74, 0x04, 0x07, 0x06, 0x1C, 0xE3, 0x42, 0x0F, 0xA5, +/* 0B60 */ 0x05, 0x10, 0x08, 0x00, 0x84, 0xBF, 0xDF, 0xFC, 0x10, 0x09, 0x34, 0x6E, 0x65, 0x06, 0xCD, 0x04, +/* 0B70 */ 0x08, 0x49, 0xD3, 0x6A, 0x00, 0x29, 0xA0, 0x3F, 0x1F, 0x0A, 0x2C, 0x37, 0x29, 0x6D, 0x07, 0x49, +/* 0B80 */ 0xD3, 0x09, 0x0E, 0xD3, 0x06, 0x0F, 0x02, 0x29, 0x20, 0x09, 0x0F, 0x01, 0x29, 0x6D, 0x07, 0x8F, +/* 0B90 */ 0x1F, 0x6E, 0x65, 0x07, 0x10, 0x08, 0x84, 0x57, 0xA5, 0x03, 0x33, 0x65, 0x04, 0x89, 0x07, 0x1F, +/* 0BA0 */ 0x09, 0x55, 0x53, 0x79, 0x2A, 0xF7, 0x03, 0x3B, 0x2A, 0x3B, 0x28, 0x79, 0x28, 0x0A, 0x55, 0x2A, +/* 0BB0 */ 0x65, 0x04, 0x95, 0x08, 0x82, 0x57, 0xA5, 0x03, 0x10, 0x09, 0x34, 0x6E, 0xA5, 0x05, 0xCD, 0x95, +/* 0BC0 */ 0x3B, 0xD3, 0x0A, 0x0E, 0xD3, 0x04, 0x59, 0x29, 0x22, 0x3B, 0x29, 0xDC, 0x49, 0x29, 0x22, 0x49, +/* 0BD0 */ 0x29, 0x64, 0xE3, 0x59, 0x29, 0x20, 0x0A, 0x55, 0x29, 0x03, 0x89, 0xC6, 0x6E, 0xA5, 0x04, 0x10, +/* 0BE0 */ 0x08, 0x34, 0xE1, 0x10, 0x07, 0x34, 0x0A, 0x2C, 0x4B, 0xCD, 0x6D, 0x36, 0xE2, 0x0A, 0x2C, 0xAC, +/* 0BF0 */ 0x29, 0x4A, 0x23, 0xE2, 0x42, 0x10, 0x09, 0x84, 0x71, 0x0E, 0x7A, 0x04, 0x48, 0x3C, 0xA1, 0x07, +/* 0C00 */ 0x0A, 0x1F, 0x09, 0x55, 0x53, 0x79, 0x2A, 0x37, 0x0E, 0x0F, 0x59, 0x2B, 0x87, 0x37, 0x02, 0x05, +/* 0C10 */ 0x59, 0xE5, 0x3B, 0x22, 0x59, 0x1C, 0x94, 0x22, 0x59, 0x1C, 0x0B, 0x0D, 0x22, 0x59, 0x1A, 0xA5, +/* 0C20 */ 0x05, 0x95, 0x59, 0x1F, 0xAB, 0x0E, 0x65, 0x06, 0x10, 0x0A, 0x34, 0x42, 0x22, 0xB9, 0x42, 0x22, +/* 0C30 */ 0xB9, 0x0A, 0x43, 0x3F, 0x29, 0x4A, 0x05, 0xB9, 0x42, 0x22, 0xB9, 0x42, 0x22, 0xB9, 0x10, 0x04, +/* 0C40 */ 0x34, 0xB3, 0x42, 0x10, 0x04, 0x34, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, +/* 0C50 */ 0x07, 0xAC, 0x23, 0x0B, 0x0D, 0x53, 0x09, 0x59, 0x1D, 0xEE, 0x03, 0x10, 0x08, 0x9A, 0xD3, 0x42, +/* 0C60 */ 0x01, 0x29, 0x52, 0x72, 0x18, 0x42, 0x8B, 0x37, 0x29, 0x01, 0x6A, 0x20, 0x29, 0x62, 0xEF, 0x0A, +/* 0C70 */ 0x3C, 0x0C, 0x64, 0xCD, 0x49, 0x20, 0x29, 0x91, 0x72, 0x29, 0x64, 0x3C, 0x64, 0x29, 0x87, 0x94, +/* 0C80 */ 0xD3, 0x08, 0x72, 0x10, 0x07, 0x34, 0xE2, 0xE2, 0xE2, 0x0A, 0x90, 0x05, 0xA1, 0x82, 0x0A, 0x2C, +/* 0C90 */ 0x5B, 0x10, 0x0B, 0xC9, 0x86, 0x7A, 0x20, 0x07, 0x4B, 0x2B, 0x52, 0x0E, 0xAC, 0x0A, 0xA5, 0x18, +/* 0CA0 */ 0x07, 0x0C, 0x99, 0xA5, 0x0D, 0x64, 0x31, 0x8D, 0x08, 0x5D, 0x0E, 0x27, 0x18, 0x70, 0x9E, 0x00, +/* 0CB0 */ 0x8E, 0x05, 0x0F, 0x18, 0x8D, 0x02, 0x0F, 0x88, 0x07, 0x05, 0x0F, 0x61, 0x97, 0x00, 0x5A, 0xA2, +/* 0CC0 */ 0x67, 0x02, 0x1D, 0x85, 0x00, 0x70, 0x0E, 0x8B, 0x72, 0x20, 0x21, 0x05, 0x5B, 0x47, 0x3F, 0x1D, +/* 0CD0 */ 0x3B, 0x47, 0x0B, 0x05, 0x64, 0x37, 0xFF, 0x18, 0x21, 0x10, 0x0A, 0x34, 0x0A, 0x49, 0x20, 0x3F, +/* 0CE0 */ 0xCB, 0x10, 0x0A, 0x84, 0xF4, 0xBA, 0x10, 0x08, 0x34, 0x6E, 0xA5, 0x05, 0xCD, 0x89, 0x3B, 0xD3, +/* 0CF0 */ 0x0C, 0x0C, 0xD3, 0x0A, 0x0E, 0xD3, 0x0C, 0x0C, 0x00, 0x29, 0x00, 0xEB, 0x49, 0x1F, 0x6E, 0x8A, +/* 0D00 */ 0x07, 0xCD, 0x25, 0xE2, 0x10, 0x0A, 0x84, 0xF4, 0x04, 0x9D, 0x7B, 0x1C, 0x0A, 0x55, 0x20, 0x5F, +/* 0D10 */ 0x1C, 0x79, 0x31, 0xAC, 0x22, 0x37, 0xA0, 0x72, 0x00, 0x87, 0x37, 0xA0, 0x72, 0x22, 0x37, 0xA0, +/* 0D20 */ 0x77, 0x1D, 0x79, 0x31, 0x55, 0x18, 0x42, 0x01, 0x20, 0x5C, 0x00, 0xE5, 0xA5, 0xAE, 0x58, 0x39, +/* 0D30 */ 0xAB, 0x0E, 0x0F, 0x4B, 0x05, 0xF0, 0x03, 0x09, 0x49, 0xF9, 0x01, 0x10, 0x09, 0x34, 0x6E, 0x65, +/* 0D40 */ 0x06, 0xCD, 0x04, 0x08, 0x49, 0xD3, 0x0C, 0x0C, 0xD3, 0x0B, 0x0C, 0x00, 0x29, 0x47, 0x06, 0x94, +/* 0D50 */ 0x1F, 0x0A, 0x2C, 0x94, 0xCD, 0x08, 0x77, 0x00, 0x29, 0x47, 0x79, 0x64, 0x29, 0x64, 0x07, 0x77, +/* 0D60 */ 0x29, 0x00, 0x47, 0x4D, 0xD3, 0x07, 0x72, 0x10, 0x08, 0x34, 0x57, 0x4D, 0x76, 0x3C, 0xAE, 0x6C, +/* 0D70 */ 0x00, 0x1A, 0x3F, 0x2A, 0x94, 0x82, 0x31, 0x5B, 0x05, 0x53, 0x9D, 0x0F, 0x5A, 0x2A, 0x0C, 0x0E, +/* 0D80 */ 0x44, 0xE3, 0x59, 0x1F, 0x92, 0xA0, 0x0F, 0x03, 0xEE, 0x45, 0x03, 0x05, 0x3C, 0x82, 0x9E, 0x0F, +/* 0D90 */ 0x79, 0x01, 0x10, 0x07, 0xC9, 0x0C, 0x43, 0x59, 0x00, 0xE5, 0x6D, 0x94, 0x6D, 0x23, 0xD0, 0xD0, +/* 0DA0 */ 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0x10, 0x09, 0x34, 0xC1, 0x5C, 0x01, 0x10, 0x08, 0xC9, +/* 0DB0 */ 0x0B, 0x0C, 0x2B, 0x62, 0x1C, 0x07, 0xAC, 0x00, 0x5C, 0x1A, 0x59, 0xFF, 0x1F, 0xAF, 0xA0, 0x8C, +/* 0DC0 */ 0x6C, 0x64, 0x6C, 0x46, 0x0F, 0x92, 0x93, 0x1C, 0xFF, 0x02, 0x72, 0x1F, 0x97, 0x05, 0x0E, 0x19, +/* 0DD0 */ 0x83, 0x70, 0x2B, 0x1A, 0x0F, 0x45, 0x53, 0x0E, 0x77, 0x10, 0x0C, 0xC9, 0x7F, 0x20, 0x0E, 0x0D, +/* 0DE0 */ 0x20, 0x85, 0x00, 0xA0, 0x0F, 0x92, 0x78, 0xAC, 0x3F, 0x00, 0x87, 0x0F, 0x03, 0x00, 0x30, 0x5A, +/* 0DF0 */ 0x8B, 0x77, 0x20, 0x3F, 0x00, 0x07, 0x70, 0x07, 0x86, 0x0F, 0x1D, 0x85, 0x00, 0x0A, 0x07, 0x07, +/* 0E00 */ 0x0A, 0x00, 0x83, 0x1D, 0x56, 0x00, 0x0D, 0xAE, 0x0D, 0x00, 0xA4, 0x1D, 0x3E, 0x78, 0x51, 0x0F, +/* 0E10 */ 0x01, 0x93, 0x20, 0xA0, 0x59, 0x0D, 0x64, 0x7B, 0x59, 0x64, 0x22, 0x0F, 0x70, 0x64, 0x0B, 0x08, +/* 0E20 */ 0xAC, 0x2B, 0x0E, 0x21, 0x91, 0x0E, 0x0E, 0x1C, 0x0C, 0x59, 0xA0, 0x5B, 0x10, 0x08, 0x9A, 0xEE, +/* 0E30 */ 0x77, 0x86, 0x77, 0x1C, 0x5C, 0x64, 0x97, 0x64, 0xEE, 0x0F, 0x02, 0x05, 0x77, 0x82, 0x85, 0x2D, +/* 0E40 */ 0xF1, 0x8A, 0xF5, 0x87, 0x8A, 0x44, 0xA6, 0x21, 0x64, 0x1A, 0x0F, 0x03, 0x27, 0xF5, 0xA6, 0x47, +/* 0E50 */ 0x21, 0x1A, 0x59, 0x00, 0x91, 0x55, 0x1C, 0x58, 0x22, 0x49, 0x10, 0x08, 0xC9, 0xD6, 0xBD, 0x0B, +/* 0E60 */ 0x10, 0x08, 0xC9, 0x02, 0x43, 0x96, 0x1A, 0x4A, 0x3C, 0x00, 0xF1, 0x0F, 0x03, 0xF0, 0x6A, 0x1F, +/* 0E70 */ 0x31, 0x6B, 0x20, 0x33, 0x21, 0x2B, 0x29, 0xF5, 0x87, 0x3F, 0x53, 0x0C, 0x0C, 0x00, 0xF1, 0x3B, +/* 0E80 */ 0x03, 0x4A, 0x1F, 0x09, 0x43, 0x0D, 0x10, 0x05, 0x2F, 0x78, 0x8A, 0xF0, 0x3B, 0x03, 0x19, 0x78, +/* 0E90 */ 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0x8A, 0x53, 0x4A, 0x10, 0x07, 0x2F, 0x86, 0x09, 0x28, 0x68, +/* 0EA0 */ 0x28, 0x78, 0x03, 0x28, 0x0C, 0x07, 0x28, 0x70, 0xF9, 0x0E, 0x00, 0x2A, 0x72, 0x19, 0xA8, 0x28, +/* 0EB0 */ 0x56, 0x28, 0xAA, 0x00, 0x2A, 0x77, 0x53, 0x54, 0x28, 0xA4, 0x28, 0x3E, 0x00, 0x2A, 0x07, 0x10, +/* 0EC0 */ 0x05, 0x2F, 0x67, 0x5B, 0xF0, 0x03, 0xA6, 0x28, 0xED, 0x64, 0xED, 0x64, 0xED, 0x67, 0x5B, 0xF0, +/* 0ED0 */ 0x6D, 0x02, 0x10, 0x08, 0x32, 0x01, 0x65, 0x53, 0x83, 0xFD, 0x02, 0x54, 0x3E, 0x23, 0x6C, 0x47, +/* 0EE0 */ 0x0E, 0x07, 0x33, 0x3F, 0x64, 0x07, 0x55, 0x10, 0x08, 0x53, 0x84, 0x24, 0x0B, 0x43, 0x59, 0x00, +/* 0EF0 */ 0xE5, 0x4A, 0x4A, 0x01, 0x10, 0x04, 0x2F, 0xEB, 0xD8, 0x0D, 0x5A, 0x28, 0x95, 0x10, 0x08, 0x20, +/* 0F00 */ 0x7D, 0xE6, 0xBC, 0x10, 0x09, 0x00, 0x2F, 0x73, 0xDE, 0xA6, 0x27, 0xD2, 0x4D, 0x89, 0x77, 0x1C, +/* 0F10 */ 0x0B, 0x0D, 0x00, 0x47, 0x49, 0x1F, 0xA6, 0x20, 0x6A, 0x1F, 0xA6, 0x20, 0x3A, 0x1F, 0xA6, 0x20, +/* 0F20 */ 0x5C, 0x1F, 0x0B, 0x0C, 0x00, 0x5D, 0xC6, 0x0B, 0x94, 0x9D, 0x0E, 0x39, 0x69, 0x08, 0x0E, 0x5A, +/* 0F30 */ 0x10, 0x07, 0xE7, 0x06, 0x49, 0x95, 0x76, 0xCA, 0x36, 0x91, 0x0E, 0xA5, 0x02, 0x10, 0x09, 0x20, +/* 0F40 */ 0x26, 0xEB, 0x01, 0xCF, 0xCF, 0xCF, 0x1D, 0x31, 0x0E, 0x93, 0x59, 0x1F, 0x07, 0xCE, 0xC8, 0x79, +/* 0F50 */ 0x87, 0x59, 0x2B, 0x31, 0x3B, 0x30, 0x59, 0x1F, 0x88, 0x0F, 0x5A, 0x59, 0x10, 0x08, 0x7D, 0x31, +/* 0F60 */ 0xC2, 0x0E, 0xFB, 0x10, 0x05, 0x26, 0x08, 0x0E, 0x21, 0x46, 0x3B, 0xAE, 0x18, 0x31, 0x0E, 0xEA, +/* 0F70 */ 0x53, 0x0C, 0x9F, 0x5B, 0x64, 0x33, 0x09, 0x7B, 0x25, 0x7F, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, +/* 0F80 */ 0x10, 0x08, 0x18, 0x84, 0x2A, 0x08, 0x02, 0x1F, 0xAB, 0x0E, 0x0F, 0x65, 0x04, 0x60, 0x5F, 0x04, +/* 0F90 */ 0x07, 0x6B, 0x1C, 0xE3, 0x72, 0x97, 0x1F, 0x67, 0x02, 0x64, 0x3A, 0x48, 0x79, 0x98, 0x3B, 0x46, +/* 0FA0 */ 0x9F, 0x8F, 0x23, 0x0A, 0x08, 0x02, 0x44, 0x3A, 0x6D, 0xEF, 0x41, 0x9F, 0x3B, 0x4C, 0x08, 0xAC, +/* 0FB0 */ 0x1D, 0x80, 0x20, 0xA9, 0xEE, 0x45, 0x03, 0x30, 0x2E, 0x7F, 0x0F, 0x4D, 0x02, 0x10, 0x08, 0x00, +/* 0FC0 */ 0x2F, 0x73, 0xDE, 0xA6, 0x06, 0x0E, 0xD2, 0xA5, 0xDB, 0xB2, 0xB2, 0xB2, 0xA9, 0x10, 0x04, 0x2F, +/* 0FD0 */ 0xF3, 0xDE, 0x1B, 0x10, 0x04, 0x2F, 0xF3, 0x28, 0x1B, 0xDE, 0x97, 0x00, 0xF1, 0x3F, 0xF0, 0x21, +/* 0FE0 */ 0x4C, 0x10, 0x07, 0x2F, 0xE0, 0x07, 0xDE, 0xA6, 0x64, 0x58, 0x82, 0xA6, 0xE0, 0x0E, 0x36, 0xA6, +/* 0FF0 */ 0x02, 0x45, 0x23, 0xA6, 0xA6, 0x19, 0x0B, 0x0C, 0x79, 0x19, 0xA6, 0x05, 0x72, 0x1F, 0xA6, 0x00, +/* 1000 */ 0x0B, 0x0C, 0x23, 0xA6, 0x5D, 0x21, 0x1F, 0xA6, 0x64, 0x07, 0x77, 0x10, 0x04, 0x00, 0x2F, 0x07, +/* 1010 */ 0x06, 0x28, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0xEC, 0x0B, 0x0C, 0x25, 0xE3, +/* 1020 */ 0xA5, 0x10, 0x0C, 0xC5, 0x27, 0xA2, 0x41, 0x99, 0x20, 0x0B, 0x6A, 0x04, 0x0D, 0xA3, 0x9D, 0x0D, +/* 1030 */ 0x1D, 0x0B, 0x0D, 0x00, 0x91, 0x55, 0xE0, 0xAC, 0x64, 0xFE, 0x01, 0x2B, 0xFE, 0x01, 0x2B, 0xFE, +/* 1040 */ 0x01, 0x10, 0x08, 0xC5, 0xAA, 0xD2, 0x5F, 0xDB, 0xB2, 0xB2, 0xB2, 0xA9, 0x10, 0x08, 0x7D, 0x31, +/* 1050 */ 0xBE, 0xC4, 0x09, 0xC5, 0x08, 0x0E, 0x45, 0x82, 0x0B, 0x4D, 0xB5, 0x5D, 0xC6, 0x0B, 0x49, 0x9D, +/* 1060 */ 0x0E, 0x39, 0x0B, 0x3A, 0x0E, 0x5A, 0x82, 0x1B, 0xD8, 0x02, 0x10, 0x09, 0x2B, 0x7D, 0x09, 0x0E, +/* 1070 */ 0x90, 0x59, 0x1F, 0x07, 0xCE, 0xC8, 0x79, 0x00, 0xE3, 0x59, 0x2B, 0x31, 0x3B, 0x30, 0x59, 0x1F, +/* 1080 */ 0x88, 0x7A, 0x05, 0x59, 0xCF, 0xCF, 0xCF, 0xD8, 0x01, 0x10, 0x06, 0xC5, 0x07, 0x45, 0x23, 0x0B, +/* 1090 */ 0x5F, 0x04, 0xEF, 0x0B, 0x77, 0x19, 0x0B, 0x0C, 0x28, 0xA6, 0xDE, 0xA6, 0x10, 0x07, 0x20, 0x7D, +/* 10A0 */ 0x41, 0x0F, 0xA8, 0x00, 0x33, 0x8F, 0x6F, 0x0A, 0x82, 0xA9, 0x4C, 0x3C, 0x04, 0x53, 0x71, 0x0E, +/* 10B0 */ 0x90, 0x53, 0x88, 0xAC, 0x23, 0xA9, 0x18, 0xA0, 0x0B, 0x05, 0x9D, 0x0E, 0x39, 0x71, 0x0E, 0xA5, +/* 10C0 */ 0x03, 0x10, 0x05, 0x50, 0x5D, 0x28, 0xE8, 0x6C, 0x53, 0x0C, 0x9F, 0x8F, 0x64, 0x33, 0x0A, 0xA2, +/* 10D0 */ 0x44, 0xE8, 0xE8, 0xE8, 0xE8, 0xE8, 0x27, 0x73, 0xF0, 0x0B, 0x65, 0x01, 0x10, 0x08, 0x20, 0x7D, +/* 10E0 */ 0xB6, 0x01, 0x10, 0x07, 0x64, 0x7D, 0xA6, 0x20, 0x6C, 0x00, 0xEE, 0xAC, 0x85, 0x33, 0x59, 0x47, +/* 10F0 */ 0x59, 0x82, 0x85, 0x86, 0x0E, 0x23, 0x83, 0x00, 0x66, 0x23, 0x67, 0x01, 0x93, 0x19, 0x45, 0x0F, +/* 1100 */ 0x25, 0x0B, 0xA7, 0x1D, 0xEE, 0x8F, 0x10, 0x0A, 0x64, 0x7D, 0x6C, 0x64, 0x09, 0x77, 0x04, 0xAC, +/* 1110 */ 0x52, 0x96, 0x0C, 0x54, 0x00, 0x3E, 0x20, 0x87, 0x77, 0x4D, 0x08, 0x00, 0x70, 0x18, 0x3F, 0x02, +/* 1120 */ 0xA8, 0x0A, 0x00, 0x2D, 0x18, 0x0C, 0x07, 0x05, 0x0B, 0x03, 0x0D, 0x00, 0x54, 0x18, 0x70, 0x7E, +/* 1130 */ 0x0F, 0x03, 0x77, 0x20, 0x52, 0xA3, 0x05, 0x00, 0x85, 0x0E, 0x18, 0xE3, 0x8A, 0x9C, 0x0A, 0x5F, +/* 1140 */ 0x1C, 0x78, 0x96, 0x07, 0x94, 0x10, 0x07, 0x7D, 0x52, 0x77, 0x02, 0x3F, 0x82, 0x97, 0x00, 0x6C, +/* 1150 */ 0x35, 0x0F, 0x03, 0x59, 0x19, 0x0B, 0xA5, 0x1F, 0x31, 0x94, 0xF0, 0x4D, 0x6B, 0x23, 0x83, 0x00, +/* 1160 */ 0x5C, 0x00, 0x33, 0x3F, 0xE0, 0x77, 0x1C, 0x58, 0x20, 0x6A, 0x10, 0x07, 0x64, 0x7D, 0xA6, 0x20, +/* 1170 */ 0x62, 0xD7, 0x5C, 0xB8, 0x10, 0x06, 0x7D, 0xA0, 0x0F, 0x2C, 0x2E, 0x01, 0x4A, 0x4D, 0x53, 0x27, +/* 1180 */ 0x61, 0xE5, 0x21, 0x2B, 0x29, 0x19, 0xE3, 0x59, 0x53, 0x3A, 0x53, 0x07, 0x3F, 0x6D, 0x36, 0x0A, +/* 1190 */ 0x2C, 0x7A, 0x10, 0x05, 0x32, 0x0A, 0x0E, 0x1D, 0xEE, 0x99, 0x23, 0x83, 0xB7, 0xB7, 0xB7, 0x82, +/* 11A0 */ 0x31, 0x0B, 0x28, 0x69, 0x1F, 0x31, 0x6B, 0x2A, 0x97, 0xB7, 0xB7, 0xB7, 0xB7, 0x28, 0x07, 0x55, +/* 11B0 */ 0x2A, 0x0D, 0x96, 0x2A, 0x10, 0x06, 0x26, 0xC0, 0x1D, 0xC0, 0x1D, 0x2D, 0x28, 0x2D, 0x28, 0x2D, +/* 11C0 */ 0x10, 0x05, 0x3D, 0xF9, 0xA8, 0x4C, 0x08, 0x0F, 0x01, 0x2A, 0x0F, 0xDD, 0x78, 0xC7, 0x04, 0x4C, +/* 11D0 */ 0x59, 0x28, 0x21, 0x1D, 0xEE, 0x59, 0x53, 0xAF, 0x44, 0x78, 0xC7, 0x04, 0x4C, 0x72, 0x35, 0x77, +/* 11E0 */ 0x35, 0x4B, 0x4C, 0x01, 0x10, 0x07, 0x00, 0x24, 0x0A, 0x79, 0x02, 0x07, 0x04, 0x1F, 0xAB, 0x9D, +/* 11F0 */ 0x0F, 0x0D, 0x01, 0x2A, 0x01, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1F, 0x00, 0x4E, 0x00, 0x77, +/* 1200 */ 0x00, 0xA6, 0x00, 0xCE, 0x00, 0xD5, 0x01, 0x04, 0x01, 0x0C, 0x01, 0x51, 0x01, 0x75, 0x01, 0x9E, +/* 1210 */ 0x01, 0xAD, 0x01, 0xB6, 0x01, 0xEE, 0x01, 0xF8, 0x02, 0x14, 0x02, 0x1F, 0x02, 0x38, 0x02, 0x51, +/* 1220 */ 0x02, 0x5C, 0x02, 0x7D, 0x02, 0xA7, 0x02, 0xAE, 0x02, 0xBC, 0x02, 0xC9, 0x02, 0xF1, 0x03, 0x1D, +/* 1230 */ 0x03, 0x32, 0x03, 0x6A, 0x03, 0x9A, 0x03, 0xBC, 0x03, 0xCA, 0x03, 0xD9, 0x03, 0xEA, 0x03, 0xF6, +/* 1240 */ 0x04, 0x04, 0x04, 0x1A, 0x04, 0x51, 0x04, 0x87, 0x04, 0x8D, 0x04, 0x9A, 0x04, 0xA9, 0x04, 0xB3, +/* 1250 */ 0x04, 0xBB, 0x04, 0xCB, 0x04, 0xDC, 0x04, 0xEA, 0x05, 0x26, 0x05, 0x3B, 0x05, 0x49, 0x05, 0x58, +/* 1260 */ 0x05, 0x69, 0x05, 0x79, 0x05, 0x85, 0x05, 0xA0, 0x05, 0xEA, 0x05, 0xF9, 0x06, 0x09, 0x06, 0x1A, +/* 1270 */ 0x06, 0x27, 0x06, 0x35, 0x06, 0x54, 0x06, 0x90, 0x06, 0x9E, 0x06, 0xAC, 0x06, 0xBB, 0x06, 0xCC, +/* 1280 */ 0x06, 0xD8, 0x06, 0xED, 0x07, 0x2D, 0x07, 0x45, 0x07, 0x55, 0x07, 0x65, 0x07, 0x78, 0x07, 0x84, +/* 1290 */ 0x07, 0x93, 0x07, 0xA4, 0x07, 0xB5, 0x07, 0xC2, 0x07, 0xFC, 0x08, 0x13, 0x08, 0x21, 0x08, 0x2E, +/* 12A0 */ 0x08, 0x3E, 0x08, 0x48, 0x08, 0x52, 0x08, 0x67, 0x08, 0xA5, 0x08, 0xB1, 0x08, 0xBE, 0x08, 0xCF, +/* 12B0 */ 0x08, 0xDC, 0x08, 0xEE, 0x09, 0x0A, 0x04, 0x00, 0x10, 0x04, 0x20, 0x7C, 0x7D, 0x92, 0x4C, 0x4D, +/* 12C0 */ 0x4C, 0x5C, 0x82, 0x9B, 0x0C, 0x07, 0x28, 0x0C, 0x07, 0x28, 0x0C, 0x07, 0x28, 0x85, 0x28, 0x85, +/* 12D0 */ 0x28, 0x5C, 0x28, 0x79, 0x10, 0x07, 0x00, 0x84, 0x8E, 0x28, 0x8E, 0xB7, 0xEF, 0x4F, 0x9F, 0x99, +/* 12E0 */ 0x20, 0x31, 0x0E, 0x04, 0x01, 0x06, 0xF5, 0x79, 0x2A, 0xF7, 0x03, 0x3F, 0x2A, 0x3B, 0x28, 0x79, +/* 12F0 */ 0x28, 0x09, 0x0E, 0x04, 0x01, 0x06, 0xF5, 0x4F, 0x9F, 0x59, 0x19, 0x83, 0x01, 0x53, 0x07, 0x0B, +/* 1300 */ 0x28, 0x07, 0x0B, 0x10, 0x08, 0x34, 0x5D, 0x0C, 0x65, 0x04, 0x23, 0x5F, 0x04, 0x07, 0x0C, 0x00, +/* 1310 */ 0x33, 0x59, 0x1D, 0x1A, 0x72, 0x20, 0x1A, 0x72, 0x64, 0x1A, 0x43, 0x02, 0x46, 0x3F, 0x6D, 0x20, +/* 1320 */ 0x1A, 0x0F, 0xDD, 0x67, 0x02, 0xF0, 0xA6, 0x4A, 0x9C, 0xEE, 0x43, 0x0C, 0x10, 0x08, 0x00, 0x84, +/* 1330 */ 0x2A, 0x06, 0x2B, 0x74, 0x1A, 0x79, 0x0E, 0x79, 0x7B, 0x2B, 0x31, 0x54, 0x05, 0x5C, 0x82, 0x0B, +/* 1340 */ 0x07, 0x64, 0x9E, 0x82, 0x90, 0x64, 0x68, 0x82, 0x0C, 0x06, 0x52, 0x2E, 0x7F, 0x75, 0x97, 0x48, +/* 1350 */ 0x3C, 0x0F, 0x7A, 0x6B, 0x18, 0xE3, 0x08, 0x5D, 0x9C, 0x07, 0x04, 0x10, 0x08, 0xC9, 0x58, 0xDC, +/* 1360 */ 0x3B, 0x00, 0xE5, 0x3F, 0x64, 0x83, 0x82, 0x6C, 0x47, 0x99, 0x60, 0x54, 0x08, 0x0B, 0x19, 0x7F, +/* 1370 */ 0xF2, 0x0C, 0x2C, 0x94, 0x19, 0x5C, 0x28, 0x5C, 0x19, 0x0C, 0x2C, 0x94, 0x00, 0x33, 0x03, 0x6A, +/* 1380 */ 0x03, 0x25, 0x5C, 0x10, 0x06, 0x26, 0xC0, 0x64, 0x32, 0xC0, 0x10, 0x08, 0x34, 0x91, 0x0E, 0x4D, +/* 1390 */ 0x36, 0x06, 0x54, 0x95, 0x76, 0xE8, 0x04, 0x8F, 0x01, 0xF1, 0x5F, 0x8F, 0xF5, 0xA8, 0x8B, 0x5C, +/* 13A0 */ 0x82, 0x85, 0x64, 0x66, 0x46, 0x65, 0x06, 0x90, 0x23, 0xEB, 0xA7, 0x01, 0x2A, 0x3F, 0x1F, 0xE3, +/* 13B0 */ 0x03, 0xE3, 0x59, 0x82, 0x07, 0x9F, 0x8F, 0x2A, 0x01, 0x10, 0x06, 0x26, 0xF9, 0x55, 0x68, 0xEF, +/* 13C0 */ 0xDA, 0x10, 0x0C, 0x64, 0x50, 0x9D, 0x0E, 0x4D, 0x9C, 0xEE, 0x0E, 0x07, 0x03, 0x95, 0x6B, 0xE5, +/* 13D0 */ 0x6B, 0x06, 0x65, 0x03, 0x8E, 0x18, 0x80, 0x02, 0x3F, 0x05, 0x9C, 0x0D, 0x02, 0x1D, 0xAD, 0x8E, +/* 13E0 */ 0x2B, 0xAD, 0x1D, 0x0A, 0x04, 0x8E, 0x2B, 0x09, 0x05, 0x00, 0x31, 0x07, 0x03, 0x0E, 0x75, 0x92, +/* 13F0 */ 0x0C, 0x03, 0x20, 0x87, 0x0D, 0x71, 0x9F, 0xAE, 0x0D, 0x1C, 0x83, 0x04, 0x75, 0x06, 0x99, 0x18, +/* 1400 */ 0x27, 0x0F, 0x7A, 0x04, 0x19, 0x75, 0x10, 0x07, 0x34, 0x41, 0x0F, 0x5A, 0x64, 0x33, 0x04, 0x03, +/* 1410 */ 0x40, 0x23, 0x30, 0x0F, 0x7A, 0x23, 0x4D, 0x03, 0x6C, 0x23, 0x49, 0x01, 0x0B, 0x2E, 0x91, 0x9F, +/* 1420 */ 0x27, 0x36, 0x47, 0x39, 0x9B, 0x6D, 0x4A, 0xF5, 0x43, 0x07, 0x10, 0x09, 0x2B, 0x7D, 0xE3, 0x87, +/* 1430 */ 0x02, 0x46, 0x55, 0x01, 0x93, 0x33, 0x45, 0x00, 0x09, 0x2E, 0x0C, 0x0C, 0x86, 0x59, 0x33, 0x49, +/* 1440 */ 0x00, 0x42, 0x20, 0x29, 0x98, 0x37, 0x60, 0x85, 0x91, 0x0E, 0xF5, 0x68, 0x92, 0x0B, 0x08, 0x23, +/* 1450 */ 0x9C, 0x47, 0x01, 0x10, 0x07, 0x24, 0x02, 0x43, 0x08, 0x64, 0x1A, 0x4A, 0x2D, 0x28, 0x2D, 0x82, +/* 1460 */ 0x31, 0x05, 0x10, 0x06, 0x24, 0x02, 0x0F, 0x2C, 0x2B, 0x1A, 0x4A, 0x10, 0x09, 0x00, 0x50, 0x30, +/* 1470 */ 0x0E, 0xA8, 0x1F, 0xE3, 0x0D, 0x9F, 0xA3, 0x07, 0x1F, 0x0B, 0x02, 0x0B, 0x04, 0x0D, 0x02, 0x0C, +/* 1480 */ 0x1F, 0x0C, 0x00, 0x0B, 0x4B, 0x00, 0x09, 0x03, 0x18, 0x4F, 0x00, 0x0B, 0x80, 0x00, 0x09, 0x03, +/* 1490 */ 0x1C, 0x0D, 0x02, 0x09, 0x88, 0x02, 0x0D, 0x01, 0xEE, 0x5A, 0x5D, 0x69, 0x82, 0x27, 0x0F, 0x8F, +/* 14A0 */ 0x19, 0x51, 0x01, 0x10, 0x05, 0x28, 0x26, 0x07, 0x9F, 0x37, 0x48, 0x4A, 0x01, 0x10, 0x08, 0x50, +/* 14B0 */ 0x04, 0x0D, 0xAF, 0x64, 0x48, 0x0E, 0x07, 0x04, 0x99, 0x1A, 0x0E, 0x64, 0x09, 0x07, 0x00, 0x48, +/* 14C0 */ 0x59, 0x01, 0x90, 0x23, 0x07, 0x0F, 0x5B, 0x53, 0x51, 0x10, 0x07, 0x7D, 0xB0, 0x99, 0x2B, 0x9B, +/* 14D0 */ 0xD4, 0x6D, 0x4A, 0x01, 0x10, 0x06, 0x50, 0x27, 0xA2, 0x23, 0x88, 0x04, 0x40, 0x28, 0x07, 0x0A, +/* 14E0 */ 0x53, 0x4F, 0x04, 0x53, 0x0A, 0x07, 0x53, 0x56, 0x6D, 0x64, 0x48, 0x9F, 0x8A, 0x10, 0x06, 0x50, +/* 14F0 */ 0x27, 0x5A, 0x1C, 0x31, 0x04, 0x66, 0x82, 0x31, 0x0A, 0x53, 0x0B, 0x7B, 0x2A, 0x7F, 0x23, 0xE3, +/* 1500 */ 0x86, 0x0E, 0x23, 0x71, 0x0E, 0x90, 0x10, 0x04, 0x26, 0x6F, 0xF0, 0x08, 0x8F, 0x2B, 0x1A, 0x08, +/* 1510 */ 0x02, 0x10, 0x08, 0x20, 0x7D, 0xD5, 0x8C, 0xD5, 0x8C, 0xD5, 0x8C, 0xA6, 0x00, 0x91, 0x77, 0x1C, +/* 1520 */ 0x0B, 0x54, 0x9E, 0x72, 0x18, 0x0B, 0x0C, 0x65, 0x02, 0x54, 0x1F, 0x8D, 0x28, 0x8D, 0x28, 0x8D, +/* 1530 */ 0xD8, 0x02, 0x10, 0x0B, 0x84, 0x30, 0x0E, 0x9F, 0x5B, 0x1A, 0x2C, 0xA2, 0x40, 0x1C, 0x09, 0x2C, +/* 1540 */ 0x63, 0x0B, 0x2C, 0x63, 0x08, 0x2C, 0x63, 0x02, 0x0E, 0x9F, 0x63, 0x5D, 0x83, 0xCC, 0x1C, 0x07, +/* 1550 */ 0xCC, 0x1C, 0x07, 0xCC, 0x1C, 0x07, 0xCC, 0x1C, 0x07, 0x0A, 0x91, 0x09, 0x10, 0x03, 0x32, 0x34, +/* 1560 */ 0x4C, 0xD8, 0xB4, 0x10, 0x04, 0xC9, 0x24, 0xAD, 0x28, 0x40, 0xDD, 0x71, 0x09, 0x19, 0x67, 0x3F, +/* 1570 */ 0x2A, 0x38, 0x06, 0x50, 0x88, 0x0F, 0x53, 0x97, 0x0F, 0x53, 0x51, 0xE4, 0xE4, 0x0F, 0x10, 0x07, +/* 1580 */ 0x50, 0x01, 0x0B, 0x65, 0x04, 0x23, 0x0B, 0x0C, 0x03, 0x09, 0x55, 0x18, 0xFF, 0x47, 0x3F, 0x33, +/* 1590 */ 0x72, 0x45, 0x48, 0x59, 0x64, 0x3F, 0x82, 0x3A, 0xEB, 0x55, 0x64, 0x1A, 0x0D, 0x0F, 0x54, 0x2A, +/* 15A0 */ 0x1F, 0x9B, 0x6D, 0x4A, 0x39, 0xD4, 0x10, 0x09, 0x64, 0x7D, 0xE3, 0x00, 0x5D, 0x03, 0x23, 0x93, +/* 15B0 */ 0x00, 0x3E, 0x39, 0xE3, 0x59, 0x00, 0x5C, 0x20, 0x29, 0x98, 0x3F, 0x1F, 0xE3, 0x59, 0x00, 0x6A, +/* 15C0 */ 0x82, 0x0C, 0x0C, 0xE0, 0x59, 0x00, 0xEE, 0x6B, 0x01, 0x21, 0x1F, 0xA8, 0x91, 0x0B, 0x23, 0x9C, +/* 15D0 */ 0x47, 0x01, 0x10, 0x0E, 0x9A, 0xD1, 0x96, 0x04, 0x0D, 0x00, 0x91, 0xE5, 0x96, 0x0B, 0x06, 0x00, +/* 15E0 */ 0x8E, 0xE5, 0x0F, 0x8B, 0xF8, 0x6D, 0xE9, 0x10, 0x0E, 0x9A, 0xD1, 0x96, 0x04, 0x0D, 0x00, 0x09, +/* 15F0 */ 0x65, 0x92, 0x22, 0x96, 0x0B, 0x06, 0x03, 0xAD, 0x85, 0x00, 0x22, 0x0F, 0x8B, 0x0E, 0x2B, 0x0A, +/* 1600 */ 0x07, 0x1C, 0x0A, 0x07, 0x22, 0x0D, 0x01, 0xE5, 0x55, 0x64, 0x4F, 0x04, 0x1C, 0x7E, 0x00, 0x4F, +/* 1610 */ 0x07, 0x03, 0x02, 0x64, 0xDC, 0x0E, 0x9C, 0xE3, 0x9F, 0x4B, 0x20, 0x52, 0x0A, 0x64, 0x4C, 0x10, +/* 1620 */ 0x0E, 0x9A, 0x4F, 0x61, 0x27, 0x45, 0x00, 0x52, 0x0A, 0x18, 0x74, 0x66, 0x20, 0xA2, 0x1C, 0x0B, +/* 1630 */ 0x99, 0x05, 0x0C, 0x33, 0x6C, 0x64, 0x0C, 0x05, 0x64, 0x1A, 0x0F, 0xE3, 0x0D, 0x00, 0x91, 0x2B, +/* 1640 */ 0xEB, 0xEB, 0x0C, 0x00, 0x0B, 0x06, 0x00, 0x8E, 0x1D, 0x09, 0x65, 0x6D, 0xF8, 0x6D, 0xE9, 0x10, +/* 1650 */ 0x07, 0x1C, 0x7D, 0x2A, 0xAF, 0x2A, 0x8F, 0x28, 0x38, 0x20, 0x0C, 0x06, 0x23, 0xFF, 0x53, 0x0B, +/* 1660 */ 0x0E, 0x44, 0x0B, 0x7B, 0xF1, 0x72, 0x64, 0xD7, 0x36, 0x04, 0x94, 0x95, 0x0E, 0xF5, 0xAA, 0x5B, +/* 1670 */ 0x03, 0x10, 0x08, 0x3D, 0x98, 0xF9, 0x4B, 0x02, 0x2A, 0x08, 0x09, 0x5E, 0xBF, 0xDF, 0xFC, 0x10, +/* 1680 */ 0x08, 0x5E, 0x48, 0xDD, 0x07, 0x4D, 0xF1, 0x0A, 0x04, 0x00, 0x5E, 0xBF, 0xDF, 0xFC, 0x10, 0x08, +/* 1690 */ 0x81, 0x48, 0x0B, 0x7B, 0x19, 0x8D, 0x06, 0xF2, 0x04, 0x87, 0x9C, 0x81, 0xBF, 0xDF, 0xFC, 0x10, +/* 16A0 */ 0x08, 0x3D, 0x08, 0xB1, 0x03, 0x4C, 0x01, 0x5E, 0xBF, 0xDF, 0xFC, 0x10, 0x08, 0x3D, 0xA8, 0x00, +/* 16B0 */ 0xA8, 0x64, 0x48, 0x64, 0x39, 0x9B, 0xBF, 0xDF, 0xFC, 0x10, 0x08, 0xDC, 0x0B, 0x99, 0x46, 0x0B, +/* 16C0 */ 0x9E, 0x2B, 0xEE, 0x0A, 0x03, 0x0C, 0xF0, 0x0E, 0x3B, 0x4C, 0x9C, 0x5E, 0xBF, 0xDF, 0xFC, 0x10, +/* 16D0 */ 0x0C, 0x34, 0x52, 0x43, 0x3B, 0x1C, 0x0C, 0x0C, 0x0F, 0x03, 0x4A, 0x01, 0xE5, 0x0F, 0xA9, 0x23, +/* 16E0 */ 0x3E, 0x00, 0x45, 0x23, 0x85, 0x00, 0x69, 0x64, 0x1A, 0x0F, 0x03, 0x91, 0x2C, 0x3F, 0x1D, 0x7F, +/* 16F0 */ 0xA0, 0x0F, 0x4A, 0x61, 0x0D, 0x43, 0x04, 0x18, 0xE3, 0x3F, 0x4A, 0x21, 0x18, 0x62, 0x2B, 0xA6, +/* 1700 */ 0x4A, 0x2B, 0xAF, 0x31, 0x2C, 0xAC, 0x10, 0x08, 0x84, 0x57, 0xA5, 0x03, 0x48, 0x3C, 0x04, 0x89, +/* 1710 */ 0x06, 0x1F, 0x09, 0x55, 0x53, 0x79, 0x2A, 0x49, 0x1D, 0x1A, 0xF7, 0x03, 0x3B, 0x4C, 0x94, 0x28, +/* 1720 */ 0x0C, 0x0C, 0x18, 0xEE, 0x94, 0x64, 0x73, 0x82, 0x0A, 0x8A, 0x0E, 0x49, 0x82, 0xE3, 0x8D, 0xDD, +/* 1730 */ 0x66, 0x02, 0x28, 0x70, 0x2A, 0x08, 0x0B, 0x2B, 0x1A, 0x0F, 0x3F, 0x4C, 0x39, 0x08, 0x3D, 0xD9, +/* 1740 */ 0x81, 0xE1, 0x10, 0x08, 0x5E, 0x33, 0xDD, 0x07, 0x79, 0x2B, 0xEE, 0x09, 0xDD, 0x4E, 0xE1, 0x10, +/* 1750 */ 0x08, 0x3D, 0x4F, 0x6B, 0x64, 0x48, 0x97, 0x3E, 0x36, 0xE3, 0x87, 0xF5, 0x7C, 0xE1, 0x10, 0x08, +/* 1760 */ 0x81, 0x60, 0x54, 0x01, 0xFD, 0xDA, 0x4E, 0xE1, 0x10, 0x04, 0x2B, 0x5E, 0xD9, 0x5E, 0xB3, 0x42, +/* 1770 */ 0x10, 0x04, 0x81, 0x33, 0x03, 0xF0, 0x08, 0x94, 0x2B, 0xEE, 0x09, 0x03, 0x00, 0x5E, 0xB3, 0x42, +/* 1780 */ 0x10, 0x04, 0x2B, 0x5E, 0x4F, 0x0D, 0x36, 0x47, 0x97, 0x3E, 0x36, 0xE3, 0x00, 0xE3, 0x38, 0xB3, +/* 1790 */ 0x42, 0x10, 0x04, 0x5E, 0xDC, 0x0E, 0x04, 0x01, 0x99, 0x33, 0x64, 0x36, 0x3D, 0xB3, 0x42, 0x10, +/* 17A0 */ 0x09, 0x34, 0x07, 0x9F, 0x65, 0x06, 0x82, 0x07, 0x0F, 0x6D, 0x08, 0x8F, 0xD7, 0x07, 0x77, 0x18, +/* 17B0 */ 0x07, 0x0F, 0xDC, 0x49, 0x1C, 0x07, 0x0F, 0x2B, 0x79, 0x18, 0x6E, 0x9F, 0x03, 0x00, 0x6A, 0xE5, +/* 17C0 */ 0x09, 0x0F, 0x6D, 0x64, 0x79, 0x1C, 0x07, 0x0F, 0xDC, 0x49, 0x1C, 0x07, 0x0F, 0x20, 0x07, 0x77, +/* 17D0 */ 0x18, 0x07, 0x0F, 0x03, 0x95, 0x94, 0x1F, 0x07, 0x9F, 0x65, 0x05, 0x10, 0x0A, 0x9B, 0x0B, 0x0C, +/* 17E0 */ 0x03, 0x09, 0x36, 0x9D, 0x06, 0x0F, 0x0D, 0x01, 0x4C, 0xF5, 0x7C, 0x0A, 0x49, 0x20, 0x3F, 0xCB, +/* 17F0 */ 0x10, 0x0A, 0x3D, 0x5D, 0x36, 0x31, 0x94, 0x61, 0x1A, 0x09, 0x07, 0x81, 0xF4, 0xBA, 0x10, 0x0A, +/* 1800 */ 0x64, 0x9B, 0x75, 0xF0, 0x08, 0x94, 0x19, 0x07, 0x09, 0x9C, 0x81, 0xF4, 0xBA, 0x10, 0x0A, 0x3D, +/* 1810 */ 0x5D, 0xA7, 0x36, 0x5D, 0x85, 0x7F, 0x36, 0x98, 0x00, 0xE3, 0xF5, 0x7C, 0xF4, 0xBA, 0x10, 0x0A, +/* 1820 */ 0x81, 0xCD, 0x08, 0x76, 0xAB, 0x06, 0x0E, 0x0D, 0x01, 0x4C, 0x01, 0x81, 0xF4, 0xBA, 0x10, 0x0A, +/* 1830 */ 0x81, 0x33, 0x0E, 0x04, 0x02, 0xF2, 0xDA, 0x4E, 0xF4, 0xBA, 0x10, 0x07, 0x19, 0x7D, 0xEE, 0x9C, +/* 1840 */ 0xEB, 0x23, 0x62, 0x01, 0x58, 0xEF, 0x0B, 0x0E, 0x0D, 0x44, 0x09, 0x7A, 0xEF, 0x07, 0x7B, 0x3A, +/* 1850 */ 0x23, 0xAD, 0x00, 0x88, 0x01, 0x10, 0x0A, 0x2B, 0x26, 0x09, 0x06, 0x28, 0x54, 0x82, 0x57, 0x0E, +/* 1860 */ 0x72, 0xE5, 0xA5, 0x04, 0x08, 0x0E, 0x6B, 0x29, 0x64, 0xAD, 0x6A, 0x1C, 0xAF, 0x64, 0x0C, 0xEB, +/* 1870 */ 0xAC, 0x22, 0x3F, 0x5D, 0x0B, 0x86, 0x77, 0x64, 0x87, 0x3F, 0xE0, 0x07, 0xE3, 0x72, 0x22, 0x3F, +/* 1880 */ 0x00, 0x0A, 0x03, 0x86, 0x72, 0x2B, 0xAF, 0x00, 0x0D, 0x64, 0x07, 0xAC, 0x2B, 0x42, 0x95, 0x64, +/* 1890 */ 0xA3, 0x00, 0xE5, 0x0E, 0xAF, 0x89, 0x7B, 0x00, 0x1A, 0x8A, 0xA5, 0x76, 0x68, 0xF9, 0x09, 0x10, +/* 18A0 */ 0x09, 0x3D, 0xE3, 0x01, 0x28, 0x0D, 0x90, 0xF9, 0x0B, 0x76, 0x7C, 0xC1, 0x5C, 0x01, 0x10, 0x09, +/* 18B0 */ 0x00, 0x9B, 0xE3, 0x53, 0xAB, 0x7B, 0x19, 0x0A, 0x07, 0x01, 0x81, 0xC1, 0x5C, 0x01, 0x10, 0x09, +/* 18C0 */ 0x3D, 0xE3, 0x8F, 0xF1, 0x45, 0x3A, 0x20, 0x1A, 0x9C, 0xE3, 0x82, 0x7C, 0xC1, 0x5C, 0x01, 0x10, +/* 18D0 */ 0x09, 0x3D, 0xAA, 0x00, 0xAA, 0xF0, 0x64, 0x61, 0x9B, 0xC1, 0x5C, 0x01, 0x10, 0x08, 0x3D, 0x87, +/* 18E0 */ 0x25, 0x71, 0x49, 0x19, 0x80, 0x02, 0x81, 0xD6, 0xBD, 0x0B, 0x10, 0x08, 0x34, 0x42, 0x28, 0x6E, +/* 18F0 */ 0xA5, 0x04, 0xCD, 0x89, 0x59, 0xD3, 0x5F, 0xD3, 0x42, 0xD3, 0x42, 0xD3, 0x5F, 0x00, 0x29, 0x47, +/* 1900 */ 0x08, 0x3F, 0x1F, 0x6E, 0x8A, 0x07, 0xCD, 0x25, 0x42, 0x10, 0x09, 0x26, 0xAA, 0xA5, 0x36, 0x03, +/* 1910 */ 0x49, 0x04, 0xA3, 0x82, 0x62, 0x00, 0x91, 0x2E, 0x40, 0x64, 0x69, 0x82, 0xA6, 0x00, 0x3E, 0xF5, +/* 1920 */ 0xA6, 0x00, 0x93, 0x23, 0xA6, 0x00, 0x0B, 0x0D, 0xF5, 0xA6, 0x47, 0xA7, 0x39, 0xA6, 0x00, 0x47, +/* 1930 */ 0x6A, 0x1F, 0xA6, 0x20, 0x27, 0x1F, 0xA6, 0x20, 0x07, 0x0F, 0x1F, 0xA6, 0x8B, 0x04, 0x5F, 0x1F, +/* 1940 */ 0xA6, 0x00, 0x0C, 0x5B, 0x02, 0x10, 0x08, 0x26, 0xA1, 0x28, 0x07, 0x4D, 0x01, 0x53, 0xEB, 0x05, +/* 1950 */ 0x81, 0xE6, 0xBC, 0x10, 0x08, 0x2F, 0xDC, 0x08, 0xEF, 0xE3, 0x0D, 0xA2, 0x19, 0xAD, 0x5E, 0xE6, +/* 1960 */ 0xBC, 0x10, 0x08, 0x2F, 0x87, 0xA5, 0x2B, 0x1A, 0x45, 0x8D, 0x23, 0x6D, 0x52, 0x81, 0xE6, 0xBC, +/* 1970 */ 0x10, 0x08, 0x2F, 0x47, 0x5F, 0x02, 0x0A, 0x39, 0xE0, 0x09, 0x08, 0x5B, 0x28, 0x9C, 0x81, 0xE6, +/* 1980 */ 0xBC, 0x10, 0x08, 0x50, 0xAA, 0x00, 0xAA, 0x19, 0x9C, 0x5D, 0x81, 0xE6, 0xBC, 0x10, 0x08, 0x32, +/* 1990 */ 0x04, 0xA5, 0x44, 0x0C, 0x8E, 0x05, 0x19, 0x0C, 0x95, 0x06, 0x2B, 0xEE, 0x0F, 0x55, 0x2A, 0x44, +/* 19A0 */ 0xE6, 0xBC, 0x10, 0x0C, 0x20, 0x7D, 0x9E, 0x0E, 0x45, 0x03, 0x0C, 0x7A, 0x03, 0x1D, 0x73, 0x6F, +/* 19B0 */ 0x0F, 0x79, 0x95, 0x0E, 0x82, 0x0D, 0x0E, 0x00, 0x47, 0x54, 0x2B, 0x57, 0x0F, 0x5B, 0x20, 0x93, +/* 19C0 */ 0xDC, 0x3C, 0x74, 0x0C, 0x43, 0x09, 0x64, 0xE3, 0x59, 0x64, 0x0B, 0x0C, 0x03, 0x4A, 0x9C, 0xA0, +/* 19D0 */ 0x72, 0x0B, 0x55, 0x60, 0x4D, 0x03, 0x83, 0x4D, 0x73, 0x0A, 0x01, 0x2B, 0x41, 0x4D, 0x01, 0x30, +/* 19E0 */ 0x0F, 0x93, 0x10, 0x07, 0xE7, 0x06, 0x49, 0x95, 0x76, 0xCA, 0x02, 0x23, 0x09, 0x0F, 0x5B, 0x25, +/* 19F0 */ 0x80, 0xF9, 0x85, 0x4C, 0xAA, 0x19, 0x78, 0x49, 0x53, 0x51, 0x10, 0x08, 0x26, 0x02, 0x07, 0x53, +/* 1A00 */ 0xE3, 0x3C, 0x03, 0xF9, 0x08, 0x81, 0x91, 0xC2, 0x0E, 0xFB, 0x10, 0x08, 0x64, 0x26, 0x74, 0x20, +/* 1A10 */ 0x33, 0x0B, 0xFD, 0xE0, 0x06, 0x38, 0x91, 0xC2, 0x0E, 0xFB, 0x10, 0x08, 0x26, 0x4F, 0x0D, 0x36, +/* 1A20 */ 0x47, 0x97, 0x7F, 0x9C, 0x48, 0x05, 0xA0, 0x39, 0x28, 0x31, 0xC2, 0x0E, 0xFB, 0x10, 0x08, 0x50, +/* 1A30 */ 0x02, 0x7B, 0x02, 0xF2, 0xDA, 0x08, 0xC2, 0x0E, 0xFB, 0x10, 0x04, 0x2F, 0x02, 0x07, 0x53, 0xE3, +/* 1A40 */ 0x3C, 0x03, 0xF9, 0x07, 0x5E, 0x1B, 0xDE, 0x1B, 0x10, 0x04, 0x2F, 0x52, 0x03, 0x20, 0x33, 0x0B, +/* 1A50 */ 0x54, 0x19, 0x07, 0x06, 0x64, 0x5E, 0x1B, 0xDE, 0x1B, 0x10, 0x04, 0x2F, 0x01, 0xA7, 0xF5, 0x47, +/* 1A60 */ 0x5C, 0x7F, 0x92, 0x48, 0x05, 0xA0, 0x38, 0x1B, 0xDE, 0x1B, 0x10, 0x04, 0x00, 0x2F, 0xD8, 0x0E, +/* 1A70 */ 0x6D, 0xF2, 0xDA, 0x00, 0x1B, 0xDE, 0x1B, 0x10, 0x08, 0x2F, 0x5D, 0x06, 0x01, 0x06, 0x09, 0x20, +/* 1A80 */ 0x1A, 0x0C, 0x9F, 0x76, 0x87, 0x0E, 0x79, 0x19, 0x07, 0x06, 0x03, 0x3F, 0x28, 0x58, 0x82, 0x88, +/* 1A90 */ 0x0E, 0x2D, 0x8C, 0x09, 0x54, 0x30, 0x59, 0x60, 0x49, 0x00, 0x5D, 0x3F, 0x1A, 0x59, 0xFF, 0x1A, +/* 1AA0 */ 0x59, 0x00, 0x5D, 0x59, 0x60, 0x49, 0x52, 0x8C, 0x09, 0x54, 0x05, 0x79, 0x23, 0x09, 0x0E, 0x79, +/* 1AB0 */ 0x01, 0x10, 0x08, 0x26, 0x07, 0x45, 0x05, 0x07, 0x23, 0x0C, 0x41, 0x59, 0x4C, 0x01, 0x81, 0x69, +/* 1AC0 */ 0xAA, 0xD2, 0x5F, 0xDB, 0xB2, 0xB2, 0xB2, 0xA9, 0x10, 0x08, 0x26, 0x01, 0x08, 0x61, 0x1A, 0x0C, +/* 1AD0 */ 0x5A, 0x28, 0x95, 0x81, 0x91, 0xBE, 0xC4, 0x08, 0x64, 0x26, 0x73, 0x19, 0x88, 0x21, 0x35, 0x07, +/* 1AE0 */ 0x38, 0x91, 0xBE, 0xC4, 0x08, 0x00, 0x26, 0x0B, 0x7B, 0x19, 0x40, 0x06, 0x7B, 0x35, 0x87, 0x76, +/* 1AF0 */ 0x53, 0x31, 0xBE, 0xC4, 0x08, 0x26, 0x08, 0xB1, 0x03, 0x4C, 0x38, 0x08, 0xBE, 0xC4, 0x08, 0x50, +/* 1B00 */ 0x01, 0x54, 0x00, 0xFD, 0xDA, 0x08, 0xBE, 0xC4, 0x07, 0xC9, 0xDC, 0xD8, 0x49, 0x1D, 0x1A, 0x45, +/* 1B10 */ 0x18, 0x9B, 0xD4, 0x6D, 0x4A, 0x01, 0xF0, 0xD8, 0x49, 0x1D, 0x1A, 0x45, 0x10, 0x08, 0x34, 0x31, +/* 1B20 */ 0x06, 0x28, 0x5A, 0x18, 0x31, 0x0E, 0x9F, 0x36, 0x07, 0x45, 0x08, 0x0E, 0x2E, 0xAF, 0x00, 0x09, +/* 1B30 */ 0x05, 0x3F, 0x60, 0x59, 0x00, 0x0C, 0x00, 0x85, 0x1A, 0x0F, 0x6D, 0x0A, 0x00, 0x97, 0x00, 0xE5, +/* 1B40 */ 0x59, 0x07, 0x06, 0x00, 0x85, 0x1F, 0x0E, 0x07, 0x0C, 0x51, 0x3F, 0x1F, 0x27, 0x0D, 0x30, 0x0D, +/* 1B50 */ 0x23, 0x0B, 0x0F, 0x5B, 0x02, 0x23, 0x90, 0x53, 0x4F, 0x01, 0x10, 0x08, 0x26, 0xEB, 0xD8, 0x0D, +/* 1B60 */ 0x5A, 0x28, 0x95, 0x81, 0xB6, 0x01, 0x10, 0x08, 0x64, 0x26, 0xA1, 0x19, 0x57, 0x07, 0xF1, 0x07, +/* 1B70 */ 0x38, 0xB6, 0x01, 0x10, 0x08, 0x26, 0x01, 0x0B, 0x7B, 0x19, 0x8D, 0x07, 0x7B, 0x35, 0x00, 0xE3, +/* 1B80 */ 0x36, 0x7C, 0xB6, 0x01, 0x10, 0x08, 0x50, 0x01, 0x54, 0x01, 0x99, 0x1F, 0x9C, 0x5D, 0x81, 0xB6, +/* 1B90 */ 0x01, 0x10, 0x07, 0x00, 0x26, 0xEB, 0x1D, 0xEE, 0xA5, 0xEF, 0x71, 0xDD, 0x4E, 0xA6, 0x20, 0x62, +/* 1BA0 */ 0xD7, 0x5C, 0xB8, 0x10, 0x09, 0x00, 0x2F, 0x73, 0xDE, 0xA6, 0x27, 0x45, 0x82, 0x0B, 0x4B, 0xB5, +/* 1BB0 */ 0x5D, 0xC6, 0x0B, 0x49, 0x9D, 0x0E, 0x39, 0x0B, 0x69, 0x0E, 0x5A, 0x82, 0x1B, 0xD8, 0x02, 0x10, +/* 1BC0 */ 0x07, 0x50, 0x66, 0x00, 0x66, 0x64, 0x48, 0x01, 0x47, 0xF5, 0x7C, 0xA6, 0x20, 0x62, 0xD7, 0x5C, +/* 1BD0 */ 0xB8, 0x10, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x15, 0x00, 0x0B, 0x08, 0x24, 0x09, 0x43, 0x5B, 0x00, +/* 1BE0 */ 0xE5, 0x4A, 0x4A, 0x02, 0x10, 0x08, 0x24, 0x07, 0x0F, 0x43, 0x01, 0x60, 0x4A, 0x4A, 0x10, 0x0B, +/* 1BF0 */ 0x24, 0x07, 0x2C, 0x43, 0x8A, 0x00, 0xDC, 0x03, 0x4A, 0x4A, 0x4A, 0x10, +/* char range ofs tables */ +0x00, 0x00, 0x00, 0x0D, +/* 1C00 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x06, 0x7E, 0x00, 0x00, 0x06, 0x80, 0x00, 0x00, 0x00, 0x20, +/* 1C10 */ 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x06, 0x83, 0x00, 0x00, 0x07, 0x41, 0x00, 0x00, 0x00, 0xA0, +/* 1C20 */ 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x11, 0xF6, 0x00, 0x00, 0x12, 0xB6, 0x00, 0x00, 0x20, 0x12, +/* 1C30 */ 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x1B, 0xD2, 0x00, 0x00, 0x1B, 0xDA, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular20.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular20.mcufont.h new file mode 100644 index 000000000..9f8fdaae7 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular20.mcufont.h @@ -0,0 +1,613 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 20 + * blob size: 9454, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x05, 0x40, 0x00, 0x00, 0x05, 0xBB, 0x00, 0x00, 0x00, 0x91, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x24, 0xAE, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x13, 0x00, 0x1A, 0x00, 0x04, 0x00, 0x12, 0x00, 0x01, 0x00, 0x14, 0x00, 0x18, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x32, 0x30, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x32, 0x30, 0x00, +/* dictionary data */ +0x10, 0x06, 0xC6, 0x10, 0xC6, +/* 0080 */ 0x80, 0xF2, 0xE2, 0x0C, 0xCE, 0x85, 0x0C, 0xC4, 0x08, 0x0C, 0xC3, 0x80, 0xCC, 0x05, 0xF5, 0x41, +/* 0090 */ 0x1C, 0x80, 0xC5, 0x04, 0xC9, 0x80, 0xC4, 0x09, 0xC8, 0x0E, 0xF2, 0x34, 0x40, 0x0E, 0x09, 0xCE, +/* 00A0 */ 0xC2, 0x01, 0xC2, 0x0C, 0x03, 0x0D, 0xD5, 0xCC, 0xCE, 0x80, 0xC9, 0x81, 0xCE, 0xCB, 0x10, 0xC4, +/* 00B0 */ 0x80, 0xC8, 0x10, 0xC4, 0x80, 0xC8, 0x10, 0xC4, 0x80, 0xE2, 0x02, 0x02, 0xC1, 0x80, 0xC3, 0x01, +/* 00C0 */ 0x0B, 0xC6, 0x80, 0xCA, 0x80, 0xCB, 0xCD, 0xC8, 0xC1, 0xDC, 0x11, 0x40, 0x34, 0xDB, 0x03, 0xCE, +/* 00D0 */ 0xCD, 0x0B, 0xC7, 0x80, 0xC9, 0xCB, 0x03, 0xC7, 0xDE, 0x81, 0xC8, 0x0F, 0xC4, 0x80, 0xC6, 0xCE, +/* 00E0 */ 0xC1, 0x84, 0xC9, 0xCE, 0x04, 0xC6, 0x80, 0x80, 0xCD, 0xC1, 0x0C, 0x83, 0xC3, 0xCE, 0xC4, 0x80, +/* 00F0 */ 0xC8, 0x02, 0xC4, 0xC1, 0xCD, 0xC5, 0xCC, 0xC1, 0x09, 0xCB, 0x80, 0xC3, 0x10, 0xC6, 0x80, 0x03, +/* 0100 */ 0xC1, 0xC7, 0x80, 0xC5, 0x0F, 0xC1, 0xC8, 0xCE, 0xCD, 0x80, 0xC6, 0x01, 0xC6, 0x86, 0x03, 0xC5, +/* 0110 */ 0x80, 0xC8, 0xCD, 0x0B, 0xC9, 0xC7, 0xCE, 0xC7, 0xCE, 0xC5, 0x80, 0xCE, 0x01, 0xC4, 0x42, 0x02, +/* 0120 */ 0xC8, 0xCB, 0xC7, 0x80, 0xC4, 0xCC, 0x80, 0x23, 0xCE, 0xCC, 0xCE, 0xC3, 0x01, 0xC5, 0x82, 0xCE, +/* 0130 */ 0x81, 0xC1, 0x0D, 0x80, 0xC7, 0x01, 0xC2, 0xC2, 0x80, 0xC9, 0x80, 0x80, 0xC5, 0xC1, 0x10, 0xCC, +/* 0140 */ 0xC3, 0x01, 0xC8, 0xCC, 0xC2, 0x0E, 0xC3, 0x80, 0xC5, 0xC1, 0x01, 0x02, 0xC6, 0x80, 0xCB, 0x80, +/* 0150 */ 0xC2, 0x0A, 0xC1, 0xC5, 0xCD, 0xC4, 0x10, 0xCC, 0xC7, 0xC1, 0x13, 0xC2, 0x80, 0xCA, 0xD8, 0xD7, +/* 0160 */ 0x01, 0xC7, 0x80, 0xC4, 0x80, 0xC9, 0x80, 0xC4, 0x01, 0x32, 0x07, 0x80, 0xCA, 0x0C, 0x80, 0xC2, +/* 0170 */ 0x08, 0xC1, 0xC8, 0xC7, 0x80, 0xC8, 0xC2, 0xCD, 0x01, 0xC9, 0x0A, 0xC2, 0xCA, 0xCE, 0xC9, 0xD6, +/* 0180 */ 0x80, 0xCB, 0x3E, 0x14, 0x40, 0x36, 0xCB, 0xCE, 0x41, 0x2D, 0x10, 0xC3, 0xC7, 0xC1, 0xC3, 0xC4, +/* 0190 */ 0xDD, 0xCE, 0xC4, 0xCC, 0xCD, 0xCD, 0x80, 0x1F, 0x10, 0xC7, 0x40, 0x33, 0x80, 0xC1, 0xC5, 0x10, +/* 01A0 */ 0xCA, 0xC7, 0x08, 0x18, 0x4D, 0x18, 0x4D, 0x31, 0x04, 0x8A, 0x47, 0x37, 0x03, 0x92, 0x0C, 0x8C, +/* 01B0 */ 0x00, 0x71, 0x96, 0x92, 0x6C, 0x8F, 0x65, 0x67, 0x8B, 0x0D, 0x0E, 0x33, 0x0D, 0x0C, 0x33, 0x36, +/* 01C0 */ 0x2C, 0x59, 0x2A, 0x7D, 0x30, 0x38, 0x01, 0x46, 0x1E, 0x06, 0x33, 0x7D, 0x0C, 0x8A, 0x5D, 0x70, +/* 01D0 */ 0x1C, 0x40, 0x70, 0x33, 0x4F, 0x44, 0x92, 0x68, 0x7A, 0x65, 0x74, 0x92, 0x41, 0x2A, 0x5A, 0x70, +/* 01E0 */ 0x92, 0x49, 0x2A, 0x6C, 0x8F, 0x92, 0x41, 0x2A, 0x5A, 0x70, 0x92, 0x68, 0x7A, 0x65, 0x74, 0x89, +/* 01F0 */ 0x40, 0x70, 0x34, 0x0E, 0x44, 0x7D, 0xA2, 0x5F, 0x0C, 0x59, 0x33, 0x7D, 0x46, 0x8A, 0x19, 0x7D, +/* 0200 */ 0x8A, 0x19, 0x7D, 0x8A, 0x19, 0x7D, 0x8A, 0x19, 0x7D, 0x8A, 0x19, 0x7D, 0x8A, 0x19, 0x7D, 0x8A, +/* 0210 */ 0x19, 0x7D, 0x4E, 0x70, 0x89, 0x4E, 0x67, 0x9F, 0x4E, 0x70, 0x89, 0x4E, 0x67, 0x55, 0x63, 0x70, +/* 0220 */ 0x89, 0x4E, 0x74, 0x01, 0x96, 0x63, 0x70, 0x27, 0x43, 0x00, 0x0A, 0x8C, 0x04, 0x70, 0x27, 0x43, +/* 0230 */ 0x00, 0x03, 0x8F, 0x04, 0x70, 0x27, 0x43, 0x33, 0x0C, 0x6B, 0x70, 0x27, 0x43, 0x7B, 0x07, 0x70, +/* 0240 */ 0x27, 0x43, 0x34, 0x6A, 0x70, 0x27, 0x43, 0x2A, 0x73, 0x70, 0x27, 0x43, 0x2A, 0x72, 0x01, 0x2F, +/* 0250 */ 0x75, 0x41, 0x3B, 0x41, 0x3B, 0x41, 0x09, 0x0D, 0x58, 0x09, 0x01, 0x1D, 0x0B, 0x8E, 0x0A, 0x96, +/* 0260 */ 0x3B, 0x0B, 0xA6, 0x47, 0x7D, 0x93, 0x35, 0x7D, 0x07, 0x0E, 0x4B, 0x03, 0x5E, 0x0A, 0x1E, 0x06, +/* 0270 */ 0x05, 0x52, 0x7D, 0x49, 0x2A, 0x73, 0x03, 0x92, 0x03, 0x8A, 0x2A, 0x73, 0x03, 0x7D, 0x1E, 0x34, +/* 0280 */ 0xA2, 0x03, 0x5E, 0x0B, 0x0F, 0xA8, 0x0D, 0x0B, 0x8A, 0x00, 0x7D, 0x0A, 0x41, 0x08, 0x00, 0x08, +/* 0290 */ 0x0A, 0x69, 0xA6, 0x92, 0x0E, 0x0F, 0x47, 0x0B, 0xA6, 0x06, 0x59, 0x2A, 0x55, 0x92, 0x82, 0x2A, +/* 02A0 */ 0x0B, 0xA6, 0x5E, 0x2D, 0x2A, 0x30, 0x92, 0x65, 0x35, 0x03, 0x70, 0x8B, 0x43, 0x85, 0x02, 0x2B, +/* 02B0 */ 0x0E, 0x0A, 0x00, 0x38, 0x23, 0x0A, 0x0E, 0x00, 0x94, 0x2B, 0x5A, 0x59, 0x67, 0x2B, 0x71, 0x49, +/* 02C0 */ 0x44, 0x56, 0x0D, 0x96, 0x18, 0x86, 0xA7, 0x9A, 0x2B, 0x4E, 0x0B, 0x74, 0x56, 0x0F, 0x22, 0x22, +/* 02D0 */ 0x22, 0x22, 0x22, 0x74, 0x47, 0x87, 0x1C, 0x55, 0x47, 0x87, 0x89, 0x5A, 0x70, 0x47, 0x52, 0x27, +/* 02E0 */ 0x03, 0x1E, 0x33, 0x71, 0x41, 0x92, 0x91, 0x1E, 0x83, 0x0E, 0x59, 0x27, 0x40, 0x68, 0x30, 0x04, +/* 02F0 */ 0x1C, 0x26, 0x43, 0x18, 0x43, 0x18, 0x18, 0x73, 0x38, 0x4A, 0x54, 0x2F, 0x7F, 0x0B, 0x0F, 0x75, +/* 0300 */ 0x3D, 0x3B, 0x61, 0x9C, 0x44, 0x3E, 0x05, 0x3E, 0x05, 0x3E, 0x05, 0x3E, 0x05, 0x3E, 0x05, 0x3E, +/* 0310 */ 0x05, 0x2A, 0x58, 0x36, 0x07, 0x33, 0x07, 0x49, 0x5E, 0x72, 0x60, 0x09, 0x0D, 0x9F, 0x8B, 0x7E, +/* 0320 */ 0x30, 0x02, 0x38, 0x19, 0x98, 0x3F, 0x4A, 0x54, 0x2F, 0xA7, 0x38, 0x01, 0x5E, 0x86, 0x66, 0x08, +/* 0330 */ 0x0B, 0x62, 0x02, 0x92, 0x4D, 0x00, 0x65, 0x0B, 0x96, 0x36, 0x0C, 0x01, 0x33, 0x68, 0x03, 0x27, +/* 0340 */ 0x5A, 0x59, 0x40, 0x70, 0x27, 0x5A, 0x59, 0x5C, 0x09, 0x27, 0x5A, 0x59, 0x92, 0x4E, 0x8C, 0x33, +/* 0350 */ 0x0D, 0x07, 0x00, 0x6B, 0x27, 0x0B, 0x0A, 0x00, 0x6C, 0x0F, 0x03, 0x79, 0x1C, 0x72, 0x03, 0x65, +/* 0360 */ 0x45, 0x03, 0x89, 0x3F, 0x2A, 0x03, 0x2C, 0x48, 0x9D, 0x2A, 0x54, 0x67, 0x19, 0x72, 0x03, 0x89, +/* 0370 */ 0x5D, 0x3B, 0x06, 0x70, 0x2A, 0x68, 0x36, 0x06, 0x2A, 0x68, 0x36, 0x06, 0x2A, 0x68, 0x36, 0x06, +/* 0380 */ 0x2A, 0x68, 0x36, 0x06, 0x2A, 0x68, 0x36, 0x06, 0x2A, 0x68, 0x36, 0x06, 0x2A, 0x68, 0x36, 0x53, +/* 0390 */ 0x1A, 0x1A, 0x06, 0x2B, 0x07, 0x70, 0x1F, 0x0E, 0xA6, 0x1C, 0x52, 0x1F, 0x0A, 0x74, 0x1C, 0x0D, +/* 03A0 */ 0xA6, 0x33, 0x40, 0x70, 0x1C, 0x0E, 0x0F, 0x1F, 0x5A, 0x8F, 0x1C, 0x2F, 0x1F, 0x5A, 0x8F, 0x1C, +/* 03B0 */ 0x0E, 0x0F, 0x2A, 0x40, 0x70, 0x1C, 0x52, 0x47, 0x91, 0x74, 0x1F, 0x40, 0x70, 0x1F, 0x0E, 0x08, +/* 03C0 */ 0x0F, 0x78, 0x0D, 0x0B, 0x43, 0x8B, 0x71, 0x70, 0x00, 0x8A, 0x92, 0x40, 0x35, 0x9A, 0x2B, 0x9A, +/* 03D0 */ 0x33, 0x07, 0x67, 0x00, 0x7D, 0x8A, 0x33, 0x03, 0x8F, 0x5E, 0x4D, 0x32, 0x6A, 0x5E, 0x73, 0x45, +/* 03E0 */ 0xA6, 0x92, 0x9F, 0x20, 0x09, 0x59, 0x1C, 0x71, 0x2E, 0x47, 0x82, 0x19, 0x40, 0x59, 0x1F, 0x41, +/* 03F0 */ 0x27, 0x7C, 0x1F, 0x8D, 0x41, 0x02, 0x40, 0x2E, 0x27, 0x6C, 0x62, 0x8E, 0x0B, 0x1E, 0x01, 0x5E, +/* 0400 */ 0x03, 0x0A, 0x0E, 0x49, 0x39, 0x99, 0x18, 0x79, 0x2B, 0x71, 0x02, 0x05, 0x59, 0x02, 0x29, 0x6E, +/* 0410 */ 0x4B, 0x51, 0x4E, 0x05, 0x07, 0x8F, 0x2C, 0x23, 0x79, 0x9C, 0x04, 0xA2, 0x07, 0x0E, 0x00, 0x40, +/* 0420 */ 0x0D, 0x1C, 0x40, 0x0E, 0x47, 0x26, 0x01, 0x03, 0x02, 0x53, 0x1A, 0x06, 0x01, 0x0A, 0x0E, 0x30, +/* 0430 */ 0x29, 0x4F, 0x2E, 0x08, 0x0E, 0x44, 0x1C, 0x40, 0x59, 0x33, 0x03, 0x8F, 0x5E, 0x0C, 0xA6, 0x2A, +/* 0440 */ 0x0D, 0x0C, 0x5E, 0x41, 0x24, 0x2D, 0x5E, 0x0F, 0x5B, 0x5E, 0x0E, 0x61, 0x20, 0x04, 0x5E, 0x0C, +/* 0450 */ 0xA6, 0xA4, 0x70, 0x2A, 0x29, 0x01, 0xA2, 0x5F, 0x0A, 0x59, 0x1C, 0x0F, 0x75, 0x0B, 0x1E, 0x05, +/* 0460 */ 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x06, 0x00, 0x54, 0x37, 0x03, 0x05, 0x56, 0x85, 0x1A, 0x06, 0x07, +/* 0470 */ 0x0D, 0x0E, 0x0A, 0x01, 0x36, 0x0D, 0x80, 0x03, 0x0A, 0x0D, 0x49, 0x08, 0x51, 0x4E, 0x41, 0x8E, +/* 0480 */ 0x0B, 0x1E, 0x7A, 0x8D, 0x41, 0x02, 0x33, 0x85, 0x07, 0x0E, 0x8A, 0x23, 0x7A, 0x01, 0x04, 0x5C, +/* 0490 */ 0x08, 0x27, 0x5A, 0x59, 0x40, 0x59, 0x27, 0x5A, 0x2E, 0x2A, 0x0C, 0x8C, 0x27, 0x5A, 0x9A, 0x8B, +/* 04A0 */ 0x6C, 0x67, 0x00, 0x23, 0x26, 0x73, 0x75, 0x0A, 0x2E, 0x36, 0x28, 0x00, 0x41, 0x5E, 0x06, 0x92, +/* 04B0 */ 0x40, 0x0A, 0x7A, 0x7E, 0x81, 0x09, 0x06, 0x19, 0x4E, 0x0D, 0x0E, 0x47, 0x71, 0x67, 0x1F, 0x65, +/* 04C0 */ 0x0E, 0x2D, 0x47, 0x91, 0x0C, 0x1C, 0x03, 0x02, 0x07, 0x0E, 0x0F, 0x6A, 0x23, 0x91, 0x00, 0x01, +/* 04D0 */ 0x5D, 0x1E, 0x05, 0x2B, 0x68, 0xA8, 0x38, 0x5E, 0x5A, 0x8F, 0x2A, 0x4A, 0x7C, 0x18, 0x41, 0x3B, +/* 04E0 */ 0xA5, 0x63, 0x6D, 0x26, 0x34, 0x34, 0x6F, 0x9C, 0x2E, 0x08, 0x22, 0x22, 0x0D, 0x8C, 0x4E, 0x70, +/* 04F0 */ 0x89, 0x4E, 0x70, 0x8F, 0x04, 0x00, 0x9A, 0x27, 0x58, 0x3B, 0x58, 0x3B, 0x58, 0x3B, 0x58, 0x3B, +/* 0500 */ 0x58, 0x3B, 0x4E, 0x0C, 0xA7, 0x0A, 0x96, 0x56, 0x6C, 0x0E, 0x06, 0x05, 0x0B, 0x01, 0x0B, 0x58, +/* 0510 */ 0x1F, 0x5A, 0x59, 0x00, 0x71, 0x2E, 0x2A, 0x58, 0x1F, 0x5A, 0x59, 0x00, 0x71, 0x2E, 0x2A, 0x58, +/* 0520 */ 0x47, 0x7B, 0x27, 0x4D, 0x00, 0x40, 0x59, 0x27, 0x4D, 0x00, 0x40, 0x59, 0x27, 0x4D, 0x00, 0x40, +/* 0530 */ 0x59, 0x07, 0x27, 0x4E, 0x96, 0x84, 0x84, 0x02, 0x5E, 0x4D, 0x31, 0x09, 0x32, 0x4A, 0x04, 0x4B, +/* 0540 */ 0x96, 0x92, 0x4E, 0x96, 0x05, 0x2C, 0x03, 0x8B, 0x4D, 0x18, 0x4D, 0x31, 0x0B, 0x84, 0x84, 0x04, +/* 0550 */ 0x27, 0x4E, 0x45, 0x2E, 0x88, 0x1C, 0x65, 0x70, 0x00, 0x71, 0x0E, 0xA6, 0x03, 0x7E, 0x0E, 0x0A, +/* 0560 */ 0x01, 0x36, 0x0A, 0x0E, 0x08, 0x9F, 0x3B, 0x9F, 0x3B, 0x9F, 0x3B, 0x9F, 0x27, 0x86, 0x8A, 0x00, +/* 0570 */ 0x4E, 0x70, 0x27, 0x86, 0x04, 0x2E, 0x2B, 0x4D, 0x4D, 0x31, 0x7D, 0xA2, 0x5F, 0x0D, 0x0E, 0x0F, +/* 0580 */ 0x51, 0x5A, 0x8F, 0x34, 0x02, 0x56, 0x47, 0x7D, 0xA1, 0x37, 0x69, 0x64, 0x34, 0x24, 0x9C, 0x70, +/* 0590 */ 0x92, 0x4D, 0x33, 0x06, 0x2A, 0x58, 0x36, 0x06, 0x2A, 0x58, 0x36, 0x00, 0x7B, 0x1A, 0x06, 0x08, +/* 05A0 */ 0xA6, 0x67, 0x8B, 0x00, 0xA4, 0x0C, 0x49, 0x01, 0x30, 0x33, 0x26, 0x01, 0x42, 0x05, 0x03, 0x2E, +/* 05B0 */ 0x06, 0x74, 0x0D, 0xA6, 0x46, 0x49, 0x07, 0x49, 0x3B, 0x4D, 0x2A, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x01, 0x00, +/* 05C0 */ 0x02, 0x00, 0x06, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x10, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, +/* 05D0 */ 0x16, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x21, 0x00, 0x23, 0x00, 0x24, 0x00, 0x27, 0x00, +/* 05E0 */ 0x29, 0x00, 0x2A, 0x00, 0x2B, 0x00, 0x2C, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x31, 0x00, 0x33, 0x00, +/* 05F0 */ 0x3E, 0x00, 0x3F, 0x00, 0x40, 0x00, 0x42, 0x00, 0x45, 0x00, 0x48, 0x00, 0x4A, 0x00, 0x4C, 0x00, +/* 0600 */ 0x4E, 0x00, 0x4F, 0x00, 0x50, 0x00, 0x52, 0x00, 0x53, 0x00, 0x59, 0x00, 0x5B, 0x00, 0x5D, 0x00, +/* 0610 */ 0x5E, 0x00, 0x61, 0x00, 0x64, 0x00, 0x66, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x6C, 0x00, +/* 0620 */ 0x6E, 0x00, 0x70, 0x00, 0x71, 0x00, 0x73, 0x00, 0x76, 0x00, 0x78, 0x00, 0x7A, 0x00, 0x7C, 0x00, +/* 0630 */ 0x7E, 0x00, 0x81, 0x00, 0x84, 0x00, 0x86, 0x00, 0x89, 0x00, 0x8A, 0x00, 0x8C, 0x00, 0x8E, 0x00, +/* 0640 */ 0x90, 0x00, 0x92, 0x00, 0x93, 0x00, 0x96, 0x00, 0x98, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D, 0x00, +/* 0650 */ 0x9F, 0x00, 0xA1, 0x00, 0xA3, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, +/* 0660 */ 0xAD, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB3, 0x00, 0xB4, 0x00, 0xB6, 0x00, 0xB8, 0x00, 0xBA, 0x00, +/* 0670 */ 0xBC, 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC2, 0x00, 0xC4, 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCB, 0x00, +/* 0680 */ 0xCE, 0x00, 0xD0, 0x00, 0xD3, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xDE, 0x00, +/* 0690 */ 0xE0, 0x00, 0xE3, 0x00, 0xE4, 0x00, 0xE5, 0x00, 0xE8, 0x00, 0xEA, 0x00, 0xEE, 0x00, 0xEF, 0x00, +/* 06A0 */ 0xF0, 0x00, 0xF2, 0x00, 0xF3, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFD, 0x00, +/* 06B0 */ 0xFF, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x05, 0x01, 0x07, 0x01, 0x08, 0x01, 0x09, 0x01, +/* 06C0 */ 0x0B, 0x01, 0x0D, 0x01, 0x0F, 0x01, 0x11, 0x01, 0x13, 0x01, 0x15, 0x01, 0x16, 0x01, 0x18, 0x01, +/* 06D0 */ 0x1A, 0x01, 0x1C, 0x01, 0x1D, 0x01, 0x1F, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01, 0x27, 0x01, +/* 06E0 */ 0x2D, 0x01, 0x4B, 0x01, 0x82, 0x01, 0x97, 0x01, 0xD3, 0x01, 0xDB, 0x02, 0x17, 0x02, 0x1E, 0x02, +/* 06F0 */ 0x53, 0x02, 0x77, 0x02, 0x7B, 0x02, 0x7D, 0x02, 0x8A, 0x02, 0xAA, 0x02, 0xB1, 0x02, 0xBC, 0x02, +/* 0700 */ 0xD1, 0x02, 0xF7, 0x03, 0x14, 0x03, 0x19, 0x03, 0x43, 0x03, 0x78, 0x03, 0x8B, 0x03, 0x9F, 0x03, +/* 0710 */ 0xA1, 0x03, 0xAA, 0x03, 0xB1, 0x03, 0xE0, 0x03, 0xE3, 0x03, 0xE5, 0x03, 0xEB, 0x03, 0xED, 0x03, +/* 0720 */ 0xEF, 0x03, 0xF2, 0x03, 0xFC, 0x04, 0x0D, 0x04, 0x14, 0x04, 0x23, 0x04, 0x28, 0x04, 0x2A, 0x04, +/* 0730 */ 0x2C, 0x04, 0x33, 0x04, 0x3A, 0x04, 0x4F, 0x04, 0x53, 0x04, 0x65, 0x04, 0x68, 0x04, 0x6C, 0x04, +/* 0740 */ 0x6E, 0x04, 0x71, 0x04, 0x79, 0x04, 0x7D, 0x04, 0x87, 0x04, 0x90, 0x04, 0x92, 0x04, 0x94, 0x04, +/* 0750 */ 0xA7, 0x04, 0xB6, 0x04, 0xDA, 0x04, 0xE1, 0x04, 0xEA, 0x04, 0xF1, 0x04, 0xF9, 0x04, 0xFB, 0x04, +/* 0760 */ 0xFD, 0x04, 0xFF, 0x05, 0x09, 0x05, 0x0B, 0x05, 0x0F, 0x05, 0x13, 0x05, 0x15, 0x05, 0x18, 0x05, +/* 0770 */ 0x20, 0x05, 0x24, 0x05, 0x26, 0x05, 0x28, 0x05, 0x2A, 0x05, 0x2C, 0x05, 0x2E, 0x05, 0x30, 0x05, +/* 0780 */ 0x33, 0x05, 0x35, 0x05, 0x37, 0x05, 0x39, 0x05, 0x3C, 0x05, 0x3E, 0x05, 0x40, +/* char range info */ +0x00, 0x00, 0x05, +/* 0790 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x21, 0x00, 0x39, 0x00, 0x82, 0x00, 0xCE, 0x01, 0x40, +/* 07A0 */ 0x01, 0x95, 0x01, 0xA3, 0x01, 0xCE, 0x02, 0x01, 0x02, 0x28, 0x02, 0x31, 0x02, 0x37, 0x02, 0x44, +/* 07B0 */ 0x02, 0x4A, 0x02, 0x77, 0x02, 0xC3, 0x02, 0xD7, 0x03, 0x08, 0x03, 0x43, 0x03, 0x7C, 0x03, 0xB8, +/* 07C0 */ 0x03, 0xFB, 0x04, 0x23, 0x04, 0x71, 0x04, 0xB3, 0x04, 0xB9, 0x04, 0xBF, 0x04, 0xE0, 0x04, 0xEA, +/* 07D0 */ 0x05, 0x0A, 0x05, 0x38, 0x05, 0xCB, 0x05, 0xD2, 0x06, 0x15, 0x06, 0x4A, 0x06, 0x8B, 0x06, 0x90, +/* 07E0 */ 0x06, 0xAC, 0x06, 0xF7, 0x07, 0x13, 0x07, 0x1A, 0x07, 0x37, 0x07, 0x70, 0x07, 0x81, 0x07, 0xEF, +/* 07F0 */ 0x07, 0xFB, 0x08, 0x04, 0x08, 0x2A, 0x08, 0x7E, 0x08, 0xB3, 0x08, 0xF1, 0x09, 0x03, 0x09, 0x09, +/* 0800 */ 0x09, 0x4A, 0x09, 0xBD, 0x0A, 0x03, 0x0A, 0x17, 0x0A, 0x48, 0x0A, 0x68, 0x0A, 0x96, 0x0A, 0xB2, +/* 0810 */ 0x0A, 0xD0, 0x0A, 0xDE, 0x0A, 0xEA, 0x0A, 0xEF, 0x0B, 0x13, 0x0B, 0x29, 0x0B, 0x59, 0x0B, 0x60, +/* 0820 */ 0x0B, 0x83, 0x0B, 0xD3, 0x0B, 0xE6, 0x0B, 0xF4, 0x0C, 0x0D, 0x0C, 0x46, 0x0C, 0x5F, 0x0C, 0x97, +/* 0830 */ 0x0C, 0xA1, 0x0C, 0xA7, 0x0C, 0xCB, 0x0C, 0xF6, 0x0D, 0x0D, 0x0D, 0x3B, 0x0D, 0x5C, 0x0D, 0x63, +/* 0840 */ 0x0D, 0x92, 0x0D, 0xEC, 0x0E, 0x1D, 0x0E, 0x29, 0x0E, 0x52, 0x0E, 0x7E, 0x0E, 0x8F, 0x0E, 0xBA, +/* 0850 */ 0x05, 0x00, 0x10, 0x05, 0x3C, 0xC9, 0x18, 0xC9, 0xB4, 0x03, 0xB4, 0x02, 0xB4, 0x78, 0x65, 0x0F, +/* 0860 */ 0x75, 0xF3, 0xA4, 0xA6, 0x56, 0x85, 0x25, 0x40, 0x0C, 0x02, 0x18, 0x0E, 0x8F, 0x56, 0x91, 0x6B, +/* 0870 */ 0x10, 0x08, 0x3C, 0xA1, 0x6C, 0x74, 0x2B, 0x3A, 0x63, 0x74, 0x2B, 0x3D, 0x00, 0x03, 0x67, 0x2B, +/* 0880 */ 0x0A, 0x0B, 0x71, 0xF4, 0x91, 0x0A, 0x71, 0x35, 0x10, 0x09, 0x3C, 0x6C, 0x8C, 0x71, 0x74, 0x5E, +/* 0890 */ 0x85, 0x4E, 0x35, 0x92, 0x91, 0x0D, 0x7B, 0x01, 0x7D, 0x5B, 0x35, 0x19, 0x40, 0x6A, 0x84, 0x2D, +/* 08A0 */ 0x9D, 0x5E, 0x8F, 0x33, 0x0C, 0x0B, 0x5E, 0x71, 0x59, 0x33, 0x94, 0x92, 0x4E, 0x67, 0x33, 0x70, +/* 08B0 */ 0x00, 0x7D, 0x06, 0x67, 0x02, 0x43, 0x01, 0x92, 0x0B, 0x5B, 0x08, 0x92, 0x03, 0x9A, 0x2C, 0x09, +/* 08C0 */ 0x74, 0x02, 0x5E, 0x3D, 0x65, 0x0E, 0x2B, 0x0D, 0x0A, 0x33, 0x0A, 0x0D, 0x2B, 0x0E, 0x08, 0x33, +/* 08D0 */ 0x3D, 0x10, 0x0A, 0x97, 0x0D, 0x09, 0x3B, 0x0D, 0x09, 0x18, 0x4F, 0x0A, 0x6F, 0x91, 0x6D, 0x2E, +/* 08E0 */ 0x51, 0x65, 0x0F, 0x39, 0x01, 0x07, 0xA0, 0x5E, 0x58, 0x47, 0x7A, 0x7D, 0xFE, 0x0D, 0x74, 0x2B, +/* 08F0 */ 0x5C, 0x96, 0x04, 0x56, 0xC1, 0x1E, 0x03, 0x2B, 0x4E, 0x0B, 0x0F, 0x6B, 0xA4, 0x8A, 0x19, 0x7D, +/* 0900 */ 0x1E, 0x19, 0x7D, 0x1E, 0x7D, 0x09, 0x7A, 0x7B, 0x08, 0x1C, 0x4E, 0x62, 0x5F, 0x37, 0x44, 0x5E, +/* 0910 */ 0x03, 0x0A, 0x6E, 0x0A, 0xEC, 0x0D, 0x09, 0x3B, 0x0D, 0x09, 0x3B, 0x0C, 0x09, 0x10, 0x0F, 0x47, +/* 0920 */ 0xD0, 0x7D, 0x05, 0x8D, 0x0A, 0x58, 0x05, 0x33, 0x65, 0x44, 0x89, 0x0A, 0x0E, 0x08, 0x0B, 0x35, +/* 0930 */ 0x71, 0x70, 0x1C, 0x70, 0x33, 0x0E, 0x08, 0x33, 0x38, 0x89, 0x71, 0x74, 0x33, 0x0C, 0x0A, 0x6C, +/* 0940 */ 0x67, 0x27, 0x59, 0x33, 0x0D, 0x08, 0x00, 0x0D, 0x0A, 0x27, 0x91, 0x0C, 0x03, 0x06, 0x8C, 0x08, +/* 0950 */ 0x8C, 0x5E, 0x77, 0x0B, 0x04, 0x02, 0x0E, 0x08, 0x33, 0x6F, 0x0A, 0x0D, 0x01, 0x07, 0x0F, 0x96, +/* 0960 */ 0x51, 0x63, 0x74, 0x4D, 0x06, 0x0E, 0x0A, 0x92, 0x0D, 0x0B, 0x91, 0x0D, 0x33, 0x07, 0x0E, 0x19, +/* 0970 */ 0x40, 0x8C, 0x00, 0x3D, 0x7B, 0x01, 0x19, 0x71, 0x0E, 0x08, 0x00, 0x91, 0x0D, 0x65, 0x0E, 0x1C, +/* 0980 */ 0x0A, 0x44, 0x33, 0x03, 0x8A, 0x08, 0x94, 0x2A, 0xC8, 0x61, 0x47, 0x7E, 0x94, 0x01, 0x8D, 0x10, +/* 0990 */ 0x0D, 0x99, 0x06, 0x0C, 0x58, 0x07, 0x92, 0x5C, 0x80, 0x0B, 0x70, 0x8B, 0x0A, 0xA6, 0x33, 0x6A, +/* 09A0 */ 0x8B, 0x0B, 0x0F, 0x2A, 0x9F, 0x92, 0x65, 0x67, 0x00, 0x4D, 0x8B, 0x4F, 0x0E, 0x06, 0x30, 0x6F, +/* 09B0 */ 0x86, 0x8A, 0x33, 0x71, 0x51, 0x4C, 0x9F, 0x6B, 0x33, 0x0A, 0x0E, 0x8D, 0x58, 0x01, 0x90, 0x28, +/* 09C0 */ 0x94, 0x89, 0x5A, 0x70, 0x33, 0x90, 0x60, 0x35, 0x1F, 0x65, 0x74, 0x33, 0x71, 0x0E, 0x96, 0x1C, +/* 09D0 */ 0x6C, 0x8A, 0x54, 0x68, 0x6B, 0x27, 0x68, 0x66, 0x08, 0x58, 0x04, 0x0E, 0x6B, 0x8D, 0x5D, 0x49, +/* 09E0 */ 0x09, 0x7A, 0x03, 0x76, 0x10, 0x04, 0x3C, 0xA1, 0x3B, 0x3A, 0x3B, 0x3D, 0x3B, 0x0A, 0x0B, 0x18, +/* 09F0 */ 0x91, 0x0A, 0x10, 0x06, 0x92, 0x69, 0x9C, 0x09, 0x3B, 0x3A, 0x53, 0x7F, 0x6A, 0x2B, 0x5C, 0xA7, +/* 0A00 */ 0x37, 0x75, 0x6A, 0x18, 0x82, 0xD9, 0x18, 0xFF, 0xE9, 0xD9, 0x18, 0x82, 0x3B, 0x6A, 0x3B, 0x37, +/* 0A10 */ 0x75, 0x05, 0x59, 0x3B, 0x6A, 0x18, 0x5A, 0x67, 0x3B, 0x3A, 0x00, 0x9C, 0x09, 0x10, 0x06, 0x88, +/* 0A20 */ 0x8D, 0x09, 0x02, 0x18, 0x4F, 0x0B, 0x3B, 0xFB, 0x3B, 0x0D, 0x0C, 0xF5, 0x67, 0x9C, 0x8F, 0x3B, +/* 0A30 */ 0x6A, 0x3B, 0x68, 0x3B, 0x0A, 0x8C, 0x18, 0xC9, 0x18, 0xC9, 0x18, 0x0A, 0x8C, 0x18, 0x68, 0x3B, +/* 0A40 */ 0x6A, 0xD9, 0x56, 0x85, 0x7F, 0x0D, 0x0C, 0x18, 0xFB, 0x56, 0x4F, 0x0B, 0x19, 0x7D, 0x09, 0x02, +/* 0A50 */ 0x10, 0x08, 0x89, 0xD0, 0x38, 0x18, 0x91, 0x0C, 0x23, 0x93, 0x03, 0x08, 0x0B, 0x02, 0x09, 0x04, +/* 0A60 */ 0x27, 0x4E, 0x68, 0x41, 0x49, 0x06, 0x00, 0x1D, 0x0F, 0x74, 0x56, 0x0C, 0x0B, 0x09, 0x0D, 0x6F, +/* 0A70 */ 0x48, 0x03, 0x01, 0x94, 0x8B, 0x4E, 0x4E, 0x10, 0x09, 0x33, 0x9B, 0x79, 0x18, 0x79, 0xC0, 0x74, +/* 0A80 */ 0x10, 0x04, 0x56, 0x99, 0x64, 0xB5, 0x10, 0x07, 0xA5, 0xA5, 0x02, 0x24, 0x6F, 0x0E, 0x6D, 0xF4, +/* 0A90 */ 0x63, 0x20, 0x01, 0x10, 0x04, 0x56, 0x99, 0x64, 0xB7, 0x10, 0x09, 0x33, 0x97, 0x75, 0x71, 0x59, +/* 0AA0 */ 0x2B, 0x5C, 0x7F, 0xD1, 0x3A, 0x19, 0x7D, 0x8F, 0x18, 0x86, 0x7F, 0xF3, 0x18, 0x3A, 0x3B, 0x2E, +/* 0AB0 */ 0x18, 0x86, 0xCA, 0x02, 0x18, 0x38, 0x3B, 0x0E, 0x0A, 0x9C, 0x59, 0xA4, 0x8C, 0x18, 0x0A, 0x0E, +/* 0AC0 */ 0x3B, 0x0E, 0x0A, 0x18, 0x4F, 0x07, 0x10, 0x0A, 0x00, 0x3C, 0x57, 0x0E, 0x30, 0x03, 0x2B, 0x37, +/* 0AD0 */ 0xA8, 0x41, 0x02, 0x5E, 0x03, 0x8A, 0x33, 0xFA, 0x27, 0x65, 0x67, 0x2A, 0x0D, 0x0E, 0x5E, 0x0B, +/* 0AE0 */ 0xA6, 0x2A, 0x0A, 0x8C, 0x92, 0xA2, 0x47, 0x87, 0x27, 0x0D, 0x0E, 0x33, 0x65, 0x67, 0x92, 0x0D, +/* 0AF0 */ 0x0E, 0x33, 0x65, 0x67, 0x92, 0xA2, 0x47, 0x87, 0x27, 0x0B, 0xA6, 0x2A, 0x0A, 0x8C, 0x1C, 0x65, +/* 0B00 */ 0x67, 0x2A, 0x0D, 0x0E, 0x5E, 0xFA, 0x33, 0xFA, 0x8B, 0x37, 0xA8, 0x41, 0x02, 0x5E, 0x65, 0x0E, +/* 0B10 */ 0x30, 0x03, 0x10, 0x08, 0x99, 0x06, 0x49, 0x47, 0x7D, 0x37, 0x49, 0x00, 0x1D, 0x0D, 0x8F, 0x58, +/* 0B20 */ 0x8B, 0x71, 0x76, 0xDD, 0xDD, 0x58, 0x10, 0x09, 0x3C, 0x93, 0x0E, 0x30, 0x03, 0x1D, 0x58, 0x08, +/* 0B30 */ 0x73, 0x28, 0x1C, 0x4E, 0x0B, 0x7A, 0x5A, 0x8F, 0x9C, 0x96, 0x9C, 0x8A, 0x53, 0x07, 0x18, 0x2D, +/* 0B40 */ 0x6F, 0x7B, 0x08, 0x23, 0x71, 0x6A, 0x1F, 0x7D, 0x2D, 0xEC, 0x0A, 0xF4, 0x40, 0x70, 0x2B, 0x4E, +/* 0B50 */ 0x49, 0x07, 0x84, 0x84, 0x36, 0x4B, 0x49, 0x10, 0x09, 0x3C, 0x03, 0x0A, 0x0E, 0x30, 0x03, 0x1D, +/* 0B60 */ 0x0F, 0x80, 0x08, 0x41, 0x29, 0x05, 0x2A, 0xE8, 0x19, 0x7D, 0x8A, 0x9C, 0x8F, 0x2B, 0x71, 0x04, +/* 0B70 */ 0x9F, 0x01, 0x23, 0x0E, 0x1E, 0x78, 0x6C, 0x06, 0x0D, 0xA0, 0x19, 0x7D, 0x58, 0x3B, 0x68, 0x75, +/* 0B80 */ 0x68, 0x92, 0x71, 0x07, 0x2A, 0x03, 0x96, 0x92, 0x85, 0x80, 0x08, 0x0E, 0x35, 0x92, 0x6C, 0x2D, +/* 0B90 */ 0x30, 0x03, 0x10, 0x0A, 0x47, 0xF8, 0x9C, 0x89, 0x7D, 0x2E, 0x56, 0x85, 0xA7, 0x2D, 0x9C, 0x8F, +/* 0BA0 */ 0xB4, 0x03, 0x18, 0x6A, 0x33, 0x0E, 0x0A, 0x5E, 0x6C, 0x59, 0x33, 0x0E, 0x0A, 0x8B, 0x0B, 0xA6, +/* 0BB0 */ 0x33, 0x8A, 0x92, 0x71, 0x96, 0x32, 0x8A, 0x02, 0x27, 0x6C, 0x5B, 0x8C, 0x00, 0x8D, 0x05, 0x20, +/* 0BC0 */ 0x96, 0x05, 0x4A, 0x34, 0x8A, 0x19, 0x7D, 0x8A, 0x19, 0x7D, 0x8A, 0x10, 0x09, 0x3C, 0x0B, 0x4B, +/* 0BD0 */ 0x49, 0x8B, 0x0B, 0x0F, 0x84, 0x84, 0x05, 0x8B, 0x0B, 0x0F, 0x3B, 0x0B, 0x0F, 0x3B, 0x0B, 0x0F, +/* 0BE0 */ 0x00, 0x01, 0x01, 0x23, 0x0B, 0x96, 0x0F, 0x96, 0x4A, 0x0A, 0x0D, 0x07, 0x05, 0x0A, 0x8A, 0x3B, +/* 0BF0 */ 0x0C, 0x8C, 0xB4, 0x7F, 0x08, 0x0F, 0xA7, 0xC9, 0x5E, 0x9D, 0x34, 0x58, 0x27, 0x4E, 0x49, 0x08, +/* 0C00 */ 0x5D, 0x74, 0x1D, 0x0A, 0x0E, 0x30, 0x04, 0x10, 0x0A, 0x99, 0x03, 0x0B, 0x58, 0x09, 0x4A, 0x04, +/* 0C10 */ 0x49, 0x08, 0x77, 0x2B, 0x0D, 0x0E, 0x78, 0x6C, 0x70, 0x56, 0x91, 0x35, 0x01, 0x6F, 0x52, 0x68, +/* 0C20 */ 0x2E, 0x8B, 0x0D, 0x49, 0x09, 0xDF, 0x8F, 0x5E, 0x0D, 0x59, 0x34, 0x41, 0x5E, 0x0D, 0x0E, 0x47, +/* 0C30 */ 0x0B, 0xA6, 0x92, 0x68, 0x47, 0x0A, 0x8C, 0x27, 0x91, 0x8C, 0x2A, 0x68, 0x00, 0xF0, 0x02, 0x96, +/* 0C40 */ 0x8B, 0x0B, 0x2E, 0x5D, 0x35, 0x00, 0x7D, 0x46, 0x6A, 0x04, 0x10, 0x08, 0xA5, 0x09, 0x45, 0x2E, +/* 0C50 */ 0x27, 0x4E, 0x84, 0x84, 0x09, 0x70, 0xB4, 0x29, 0x54, 0x6A, 0x56, 0x6C, 0x59, 0x18, 0x0B, 0xA6, +/* 0C60 */ 0x56, 0x82, 0x56, 0x85, 0xA7, 0x0D, 0x0E, 0xD9, 0xB4, 0x03, 0x18, 0x58, 0x56, 0x6C, 0x70, 0x9C, +/* 0C70 */ 0x0A, 0x02, 0x10, 0x0A, 0x27, 0xD0, 0x9C, 0x9A, 0x30, 0x03, 0x5E, 0x71, 0x41, 0x83, 0x0E, 0x6B, +/* 0C80 */ 0x27, 0x65, 0x67, 0x33, 0xE8, 0x5E, 0x0A, 0xA6, 0x2A, 0x96, 0x92, 0x91, 0x35, 0x71, 0x8F, 0x92, +/* 0C90 */ 0x71, 0x58, 0x04, 0x00, 0x38, 0x4A, 0x4C, 0x0F, 0x58, 0x4A, 0x02, 0x3A, 0x05, 0x0A, 0x1E, 0x02, +/* 0CA0 */ 0x5E, 0x0B, 0x44, 0x4E, 0x1E, 0x92, 0x82, 0x47, 0x0A, 0x8C, 0x27, 0xFA, 0x47, 0x0A, 0x35, 0x8D, +/* 0CB0 */ 0x58, 0x01, 0x33, 0x4F, 0x44, 0x89, 0x40, 0x49, 0x08, 0x5D, 0x70, 0x5E, 0x6C, 0x2D, 0x30, 0x05, +/* 0CC0 */ 0x10, 0x0A, 0xA5, 0x4E, 0x9A, 0x94, 0x4A, 0x04, 0x49, 0x08, 0x09, 0x96, 0x8B, 0x0C, 0x8C, 0x00, +/* 0CD0 */ 0x91, 0x67, 0x7D, 0x96, 0x2A, 0xE8, 0x92, 0xFA, 0x33, 0x71, 0x96, 0x92, 0x82, 0x54, 0x1E, 0x5E, +/* 0CE0 */ 0x58, 0x5C, 0x0B, 0x92, 0x91, 0x2E, 0x03, 0x06, 0x0E, 0x8A, 0x5E, 0xE0, 0x2F, 0x60, 0x8F, 0x2B, +/* 0CF0 */ 0x9E, 0x57, 0xF4, 0x54, 0x6A, 0x56, 0xE0, 0x67, 0x23, 0x7E, 0x74, 0x2B, 0x90, 0x96, 0x03, 0x2B, +/* 0D00 */ 0x65, 0x03, 0x10, 0x04, 0x64, 0xB7, 0xD0, 0xB7, 0x10, 0x04, 0x64, 0xB7, 0xD0, 0xB5, 0x10, 0x09, +/* 0D10 */ 0x47, 0x9B, 0x6C, 0x09, 0x23, 0x6C, 0xF6, 0x4A, 0x50, 0xC6, 0x33, 0x7D, 0x0C, 0xC6, 0x47, 0x7D, +/* 0D20 */ 0x1E, 0x02, 0xA4, 0x0E, 0x2E, 0xEC, 0x57, 0x0E, 0x2E, 0xEC, 0x57, 0x41, 0x4A, 0xC8, 0x05, 0x10, +/* 0D30 */ 0x09, 0x64, 0x1B, 0x2C, 0x20, 0xA3, 0x1B, 0x2C, 0x20, 0x10, 0x09, 0x9B, 0x08, 0x06, 0x3B, 0xF6, +/* 0D40 */ 0x06, 0x23, 0x4E, 0xF6, 0xA7, 0x04, 0x0B, 0x49, 0x29, 0x54, 0x52, 0x2B, 0x57, 0x41, 0x39, 0x92, +/* 0D50 */ 0x71, 0x73, 0x8F, 0x6F, 0x0D, 0x2E, 0x6F, 0x4E, 0x02, 0x10, 0x08, 0x3C, 0x01, 0x09, 0x0D, 0x49, +/* 0D60 */ 0x06, 0x8B, 0x90, 0x0E, 0x8E, 0x0D, 0x59, 0x5E, 0x57, 0x02, 0x00, 0x71, 0x1E, 0x19, 0x7D, 0x96, +/* 0D70 */ 0x56, 0xE0, 0x74, 0x2B, 0x71, 0x0C, 0x59, 0x56, 0x0B, 0xF4, 0x54, 0x8A, 0x56, 0x71, 0x8F, 0x00, +/* 0D80 */ 0x25, 0x71, 0x66, 0xA4, 0x2F, 0x9C, 0x94, 0x10, 0x12, 0x3C, 0xC8, 0x06, 0x9A, 0x62, 0x80, 0x51, +/* 0D90 */ 0x4C, 0x1E, 0x5F, 0x08, 0x0B, 0x0F, 0xA0, 0x19, 0x6C, 0x49, 0x03, 0x47, 0x71, 0x0B, 0x74, 0x47, +/* 0DA0 */ 0x71, 0x6A, 0x01, 0x54, 0x47, 0x0C, 0x44, 0x47, 0xC9, 0x65, 0x0E, 0x0F, 0x94, 0x02, 0x00, 0x03, +/* 0DB0 */ 0x70, 0x2A, 0x82, 0x33, 0x07, 0x8A, 0x05, 0x09, 0x74, 0x33, 0x9F, 0x2A, 0xFB, 0x00, 0xF7, 0x33, +/* 0DC0 */ 0x79, 0x33, 0x73, 0x7A, 0x91, 0x8C, 0x00, 0x43, 0x33, 0x79, 0x65, 0x8C, 0x33, 0x37, 0x7A, 0xFB, +/* 0DD0 */ 0x33, 0x79, 0x65, 0x8C, 0x33, 0x0A, 0xA6, 0x5A, 0x67, 0x33, 0x79, 0x33, 0x73, 0x7A, 0x91, 0x8C, +/* 0DE0 */ 0x63, 0x74, 0x33, 0x03, 0x59, 0x33, 0x38, 0x40, 0x67, 0x71, 0x2E, 0x65, 0x8F, 0x71, 0x2E, 0x2A, +/* 0DF0 */ 0xFA, 0x33, 0x0A, 0x2E, 0x09, 0x60, 0x60, 0x2D, 0x02, 0x47, 0x0C, 0x28, 0x01, 0x0A, 0x49, 0x04, +/* 0E00 */ 0x00, 0x0A, 0x6A, 0x03, 0x2A, 0x4E, 0x96, 0xF5, 0x96, 0xEC, 0x5A, 0x0E, 0x96, 0x8E, 0x08, 0x09, +/* 0E10 */ 0x0D, 0x02, 0x27, 0x71, 0x08, 0x2D, 0x0F, 0x6A, 0x08, 0x02, 0x10, 0x0B, 0x99, 0xF9, 0xD5, 0xBE, +/* 0E20 */ 0xC9, 0x10, 0x0B, 0xD7, 0x6A, 0x39, 0x5E, 0x86, 0x66, 0x08, 0x0B, 0x49, 0x01, 0xF0, 0x91, 0x70, +/* 0E30 */ 0xF0, 0x6C, 0x2E, 0xF0, 0x85, 0x07, 0x92, 0xE8, 0x02, 0x02, 0x06, 0x6A, 0x51, 0x63, 0x4B, 0x96, +/* 0E40 */ 0x02, 0x27, 0x4E, 0x96, 0x2C, 0x07, 0x0E, 0xA0, 0xF0, 0x71, 0x49, 0xF0, 0x33, 0x0C, 0x8C, 0x27, +/* 0E50 */ 0x4D, 0x47, 0x0C, 0x8C, 0x27, 0xFF, 0x03, 0x62, 0x1C, 0x4E, 0x96, 0x84, 0x46, 0x74, 0x1C, 0x4E, +/* 0E60 */ 0x6D, 0x62, 0x0A, 0x03, 0x10, 0x0A, 0x99, 0x93, 0x0D, 0x49, 0x07, 0x92, 0x4E, 0x41, 0x5F, 0x0A, +/* 0E70 */ 0x70, 0x92, 0x4F, 0x6B, 0x2A, 0x03, 0x36, 0x08, 0x18, 0x52, 0x18, 0xA2, 0x75, 0x0E, 0x0F, 0x3B, +/* 0E80 */ 0x0E, 0x0F, 0x3B, 0xA2, 0x75, 0x52, 0x53, 0x08, 0x19, 0x7D, 0x0E, 0x6B, 0x00, 0x4E, 0x51, 0x4E, +/* 0E90 */ 0x41, 0x5F, 0x0A, 0x2E, 0x1D, 0x0A, 0x0E, 0x49, 0x9D, 0x10, 0x0C, 0xD7, 0x0E, 0x80, 0x8B, 0x86, +/* 0EA0 */ 0x66, 0x08, 0x0B, 0x49, 0x01, 0xF0, 0x85, 0x0A, 0xF0, 0x33, 0x0D, 0x8C, 0x27, 0x4D, 0x33, 0x65, +/* 0EB0 */ 0x59, 0x27, 0xFF, 0x5A, 0x8F, 0x27, 0xFF, 0x6C, 0x2E, 0x27, 0xFF, 0x6C, 0x2E, 0x27, 0xFF, 0x5A, +/* 0EC0 */ 0x8F, 0x27, 0x4D, 0x33, 0x65, 0x74, 0x27, 0x4D, 0x47, 0x0D, 0x8C, 0x27, 0xFF, 0x08, 0x8A, 0x1C, +/* 0ED0 */ 0x4E, 0x96, 0x84, 0x0C, 0x1E, 0x51, 0x63, 0x6D, 0x6A, 0x06, 0x10, 0x09, 0xD7, 0x6D, 0xE3, 0x10, +/* 0EE0 */ 0x09, 0xD7, 0x2F, 0x74, 0x5E, 0x86, 0x66, 0x84, 0x9D, 0x5E, 0xEA, 0x09, 0x32, 0x4A, 0x04, 0x4B, +/* 0EF0 */ 0x8F, 0x92, 0x4E, 0x96, 0x05, 0x2C, 0x03, 0x8B, 0x86, 0xA9, 0x08, 0x10, 0x0B, 0x99, 0x02, 0x5D, +/* 0F00 */ 0x49, 0x09, 0x02, 0x5E, 0x4C, 0x0F, 0x5F, 0x09, 0x58, 0x01, 0x92, 0x0D, 0x67, 0x54, 0x02, 0x27, +/* 0F10 */ 0x5A, 0x8F, 0x18, 0x52, 0x18, 0xFC, 0x34, 0x32, 0x51, 0x0E, 0x0F, 0x2A, 0x0A, 0x2F, 0x74, 0x27, +/* 0F20 */ 0x2F, 0x2A, 0x03, 0x05, 0x09, 0x74, 0x27, 0x0E, 0x0F, 0x1F, 0x55, 0x27, 0x52, 0x47, 0x55, 0x19, +/* 0F30 */ 0x40, 0x70, 0x47, 0x55, 0x1C, 0x71, 0x41, 0x02, 0x2A, 0x55, 0x27, 0x5A, 0x62, 0x8E, 0x37, 0x74, +/* 0F40 */ 0x27, 0x4E, 0x9A, 0x49, 0x0A, 0x04, 0x10, 0x0C, 0x3C, 0xFF, 0x85, 0x06, 0x27, 0xFF, 0x85, 0x06, +/* 0F50 */ 0xE2, 0x27, 0xE8, 0x24, 0x08, 0x59, 0x89, 0x4E, 0x5B, 0x59, 0x89, 0x4E, 0x96, 0x20, 0x09, 0x59, +/* 0F60 */ 0xE2, 0xE2, 0x10, 0x05, 0x3C, 0xEA, 0xA9, 0xA9, 0x08, 0x10, 0x05, 0x00, 0x3C, 0xFE, 0xFE, 0xFE, +/* 0F70 */ 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x1E, 0x56, 0x71, 0x96, 0x18, 0x0A, 0x74, +/* 0F80 */ 0x56, 0x0B, 0x8A, 0x56, 0x5A, 0x05, 0x10, 0x0B, 0x3C, 0x4D, 0x54, 0x58, 0x51, 0xFF, 0x0B, 0x67, +/* 0F90 */ 0xF0, 0x07, 0x8F, 0x5E, 0x4D, 0x00, 0x03, 0x1E, 0x8B, 0x4D, 0x00, 0x2D, 0x29, 0x4D, 0x09, 0x59, +/* 0FA0 */ 0x5E, 0x4E, 0x96, 0x1E, 0x23, 0xE8, 0x0C, 0x74, 0xE9, 0x02, 0x62, 0x4A, 0x4D, 0x85, 0x0A, 0x33, +/* 0FB0 */ 0xF0, 0x0C, 0x74, 0x00, 0xF0, 0x03, 0x0F, 0x44, 0xF0, 0x85, 0x0A, 0xF0, 0x33, 0x0C, 0x74, 0x10, +/* 0FC0 */ 0x09, 0x1C, 0xD0, 0x31, 0xA9, 0xA9, 0x0C, 0x09, 0x09, 0x09, 0x09, 0x05, 0x27, 0x4E, 0x45, 0x70, +/* 0FD0 */ 0x10, 0x0E, 0x00, 0x3C, 0x0D, 0x96, 0x33, 0x65, 0x0F, 0xA6, 0x1C, 0x0E, 0x62, 0x47, 0x0B, 0x2F, +/* 0FE0 */ 0x03, 0x1C, 0x49, 0x35, 0x33, 0x49, 0x67, 0x19, 0x71, 0x2E, 0x70, 0x33, 0x4D, 0x74, 0x89, 0x03, +/* 0FF0 */ 0x59, 0x0D, 0x0A, 0x33, 0x07, 0x0E, 0x43, 0x89, 0x43, 0x46, 0x33, 0x3D, 0x03, 0x70, 0x47, 0x5C, +/* 1000 */ 0x2C, 0x35, 0x60, 0x02, 0x8F, 0x19, 0x5A, 0x67, 0x01, 0x59, 0x03, 0x0F, 0x03, 0x01, 0x2E, 0x47, +/* 1010 */ 0x40, 0x35, 0x0C, 0x0A, 0x06, 0x0E, 0x33, 0x96, 0x19, 0x91, 0x8C, 0x00, 0x08, 0x0E, 0x0A, 0x0B, +/* 1020 */ 0x33, 0x6A, 0x89, 0x37, 0x7A, 0x86, 0x60, 0x33, 0x9F, 0x89, 0x0B, 0x0F, 0x34, 0x2F, 0x03, 0x33, +/* 1030 */ 0x2D, 0x89, 0x2D, 0x33, 0x6C, 0x06, 0x2A, 0x0B, 0x0F, 0x89, 0x9F, 0x1C, 0x0A, 0xA6, 0x10, 0x0C, +/* 1040 */ 0x3C, 0x86, 0x67, 0x00, 0x4E, 0x70, 0xE7, 0xDB, 0xAD, 0x70, 0x10, 0x0D, 0x99, 0xCC, 0x09, 0x27, +/* 1050 */ 0xBD, 0xFC, 0xBF, 0x10, 0x0A, 0xD7, 0x58, 0x39, 0xB8, 0x2E, 0xF0, 0x71, 0x49, 0xF0, 0x71, 0x49, +/* 1060 */ 0xF0, 0x6C, 0x8A, 0x92, 0xE8, 0x02, 0x03, 0x06, 0x0E, 0x67, 0x1C, 0x4E, 0x4B, 0x49, 0x04, 0x27, +/* 1070 */ 0x4E, 0x96, 0x05, 0x04, 0x02, 0xE9, 0x18, 0xEA, 0x08, 0x10, 0x0D, 0x99, 0x03, 0x0A, 0x0D, 0x49, +/* 1080 */ 0x07, 0x51, 0x4E, 0x41, 0x8E, 0x0B, 0x1E, 0x7A, 0x8D, 0x41, 0x02, 0x40, 0x2E, 0x19, 0x40, 0x70, +/* 1090 */ 0x1F, 0x0E, 0x44, 0x1C, 0x52, 0x1F, 0x0A, 0x74, 0x1C, 0xFC, 0x33, 0x40, 0x70, 0x1C, 0x0E, 0x0F, +/* 10A0 */ 0x1F, 0x5A, 0x8F, 0x1C, 0x2F, 0x1F, 0x5A, 0x8F, 0x1C, 0xA2, 0x2A, 0x40, 0x70, 0x1C, 0x52, 0x1F, +/* 10B0 */ 0x87, 0x47, 0x40, 0x70, 0x1F, 0x0D, 0x44, 0x8D, 0x41, 0x02, 0x40, 0x59, 0x27, 0x6C, 0x62, 0x8E, +/* 10C0 */ 0x0B, 0x70, 0x1D, 0x0A, 0x6E, 0x0E, 0x66, 0x6F, 0x71, 0x50, 0xFE, 0x09, 0x05, 0x10, 0x0B, 0xD7, +/* 10D0 */ 0x49, 0x09, 0x02, 0xB8, 0x2E, 0x92, 0xFF, 0x03, 0x1E, 0xF0, 0x71, 0x1E, 0xF0, 0x5A, 0x2E, 0x92, +/* 10E0 */ 0xE8, 0x02, 0x03, 0x06, 0x41, 0x02, 0x1C, 0x4E, 0x45, 0x76, 0x1C, 0x4E, 0x96, 0x05, 0x08, 0x8F, +/* 10F0 */ 0x33, 0xF0, 0x0D, 0x28, 0xF0, 0x05, 0x2E, 0x5E, 0xFF, 0xA2, 0x03, 0xF0, 0x6C, 0x96, 0xF0, 0x33, +/* 1100 */ 0x0C, 0x67, 0x10, 0x0A, 0xA5, 0x4E, 0x9A, 0x6A, 0x05, 0x5E, 0x6C, 0x62, 0x8E, 0x0C, 0x70, 0x5E, +/* 1110 */ 0x0D, 0x8C, 0x33, 0x5A, 0x02, 0x5E, 0x62, 0x3B, 0xA2, 0x03, 0x53, 0x0E, 0x08, 0x78, 0x5A, 0x6E, +/* 1120 */ 0x0B, 0x03, 0x47, 0x7D, 0x05, 0x68, 0x74, 0xA4, 0xFE, 0x0D, 0x8C, 0x18, 0xA2, 0x7A, 0x8D, 0x39, +/* 1130 */ 0x2A, 0x03, 0x49, 0x1C, 0x4E, 0x41, 0x5F, 0x46, 0x67, 0x92, 0x71, 0x09, 0x0D, 0x62, 0x0A, 0x03, +/* 1140 */ 0x10, 0x09, 0xA5, 0x68, 0x5B, 0x51, 0x05, 0x84, 0x09, 0x96, 0x84, 0x06, 0xE9, 0x18, 0x86, 0xA9, +/* 1150 */ 0xA9, 0x08, 0x10, 0x0C, 0x3C, 0xDA, 0x22, 0xB2, 0x10, 0x0A, 0xA5, 0x52, 0x1F, 0x58, 0x19, 0x40, +/* 1160 */ 0x70, 0x47, 0xFA, 0x27, 0x03, 0x8A, 0x47, 0x55, 0x92, 0x0D, 0x0E, 0x47, 0x37, 0x51, 0x91, 0x35, +/* 1170 */ 0x33, 0x6A, 0x92, 0x6C, 0x70, 0x33, 0x03, 0x8F, 0x00, 0x7D, 0x96, 0x33, 0x07, 0xF4, 0x2D, 0x33, +/* 1180 */ 0x0A, 0x0E, 0x5E, 0x65, 0x35, 0x30, 0x5E, 0x4E, 0x70, 0x03, 0x70, 0x23, 0x0E, 0x66, 0x0F, 0x78, +/* 1190 */ 0x0A, 0x0E, 0x38, 0x47, 0x36, 0x2E, 0x56, 0x72, 0x74, 0x10, 0x0F, 0xA5, 0x55, 0x33, 0x91, 0x2E, +/* 11A0 */ 0x5C, 0x06, 0x33, 0x4E, 0x70, 0x2A, 0x0C, 0x1E, 0x40, 0x67, 0x47, 0x82, 0x2A, 0x58, 0x0E, 0x33, +/* 11B0 */ 0x91, 0xA6, 0x1F, 0x6A, 0x00, 0x71, 0x8F, 0x8C, 0x33, 0x2D, 0x19, 0x2D, 0x00, 0x6C, 0x8C, 0x74, +/* 11C0 */ 0x33, 0x30, 0x1F, 0x91, 0x8C, 0x00, 0x5D, 0x00, 0x0E, 0x08, 0x00, 0x01, 0x8F, 0x1F, 0x5A, 0x67, +/* 11D0 */ 0x00, 0x0B, 0x0A, 0x00, 0x3D, 0x00, 0x43, 0x19, 0x43, 0x00, 0x60, 0x00, 0x5D, 0x5A, 0x35, 0x00, +/* 11E0 */ 0xC8, 0x2E, 0x01, 0x67, 0x6C, 0xA6, 0x09, 0xA6, 0x89, 0x30, 0x04, 0xA6, 0x71, 0x67, 0x38, 0x1C, +/* 11F0 */ 0x38, 0x07, 0x0E, 0x2A, 0x60, 0x0D, 0x0A, 0x19, 0x65, 0x8A, 0x0B, 0x2A, 0x0C, 0x0A, 0x8F, 0x19, +/* 1200 */ 0x7B, 0x8F, 0x2A, 0x73, 0x74, 0x1C, 0x03, 0x0F, 0x74, 0x00, 0x7B, 0x8C, 0x10, 0x0A, 0xA5, 0x05, +/* 1210 */ 0x2E, 0x47, 0x0D, 0x44, 0x92, 0x0D, 0x8C, 0x00, 0x6C, 0x70, 0x92, 0x6C, 0x8F, 0x33, 0x2D, 0x4A, +/* 1220 */ 0x0D, 0x44, 0x04, 0x70, 0x8B, 0x6C, 0x70, 0x0B, 0x44, 0x23, 0x2D, 0x59, 0x47, 0x36, 0xA6, 0x56, +/* 1230 */ 0x0B, 0x0F, 0x70, 0x33, 0x1D, 0x70, 0x0D, 0x0E, 0x6F, 0x0B, 0x44, 0x06, 0x70, 0x8B, 0xFA, 0x33, +/* 1240 */ 0x0E, 0x44, 0x5E, 0x0A, 0x8C, 0x33, 0x07, 0x70, 0x92, 0x03, 0x8A, 0x54, 0x41, 0x51, 0xC9, 0x33, +/* 1250 */ 0x65, 0x70, 0x10, 0x0A, 0xA5, 0x0A, 0x67, 0x33, 0x4E, 0x8A, 0x27, 0xAA, 0x2B, 0x65, 0x0F, 0x70, +/* 1260 */ 0x56, 0xAE, 0x3B, 0x41, 0x3B, 0x41, 0x10, 0x09, 0x3C, 0x0D, 0x45, 0x96, 0x92, 0x5A, 0x84, 0x84, +/* 1270 */ 0x0A, 0x2E, 0x18, 0xA2, 0x78, 0x5A, 0x8F, 0x1F, 0x7D, 0x41, 0x6F, 0x65, 0x70, 0x23, 0x71, 0x49, +/* 1280 */ 0x18, 0x0A, 0x74, 0x2A, 0x1D, 0x1E, 0x18, 0x0B, 0xF4, 0x5C, 0x0A, 0x18, 0xA2, 0xEC, 0x48, 0x80, +/* 1290 */ 0x84, 0x84, 0x05, 0x1C, 0x65, 0x5B, 0x09, 0x10, 0x06, 0x89, 0x25, 0x32, 0xEC, 0xA2, 0x62, 0x56, +/* 12A0 */ 0x9F, 0x05, 0x04, 0x56, 0x9F, 0x3B, 0x9F, 0x3B, 0x9F, 0x3B, 0xE6, 0x3B, 0xE6, 0x3B, 0xE6, 0x02, +/* 12B0 */ 0xEC, 0xA2, 0x62, 0x2B, 0x4E, 0x2C, 0x04, 0x10, 0x09, 0x26, 0x01, 0x60, 0x3B, 0x0E, 0x0A, 0x3B, +/* 12C0 */ 0x0A, 0x0E, 0x00, 0x53, 0x03, 0x9C, 0x59, 0x3B, 0x0E, 0x0A, 0x3B, 0x38, 0xF5, 0x8C, 0x18, 0x79, +/* 12D0 */ 0x3B, 0x2E, 0x3B, 0x38, 0x3B, 0xF3, 0x18, 0x86, 0xA7, 0x01, 0x8F, 0x3B, 0x3A, 0x3B, 0xF3, 0x56, +/* 12E0 */ 0x6C, 0xF4, 0xC8, 0x0E, 0x06, 0x10, 0x06, 0x89, 0x25, 0x32, 0x6F, 0x71, 0x2F, 0x8A, 0x47, 0x7D, +/* 12F0 */ 0x2C, 0xAC, 0xAC, 0x8A, 0x23, 0x71, 0x03, 0x8A, 0x2B, 0x71, 0x2F, 0x8A, 0x47, 0x7D, 0x05, 0x2C, +/* 1300 */ 0x03, 0x10, 0x0A, 0x19, 0x98, 0xF5, 0x06, 0xA4, 0x2F, 0x03, 0x23, 0xF7, 0x30, 0x5E, 0x40, 0x67, +/* 1310 */ 0x07, 0xF4, 0x01, 0x6A, 0x00, 0xF7, 0x27, 0x40, 0x67, 0x65, 0x67, 0x7D, 0x6A, 0x54, 0x6A, 0x10, +/* 1320 */ 0x09, 0x2A, 0xA3, 0x99, 0xEE, 0x24, 0x92, 0x73, 0x5B, 0x51, 0x03, 0x20, 0x20, 0x10, 0x06, 0x26, +/* 1330 */ 0x0A, 0x7F, 0x90, 0x8A, 0x75, 0x05, 0x3A, 0x1C, 0x7D, 0x10, 0x0A, 0x9B, 0x03, 0xAF, 0x10, 0x0B, +/* 1340 */ 0xC3, 0x53, 0x1A, 0xCB, 0xB9, 0x2A, 0xE8, 0x27, 0x5A, 0x59, 0x5C, 0x08, 0x27, 0x5A, 0x59, 0x40, +/* 1350 */ 0x59, 0x27, 0x5A, 0x96, 0x2A, 0x0C, 0x8C, 0x27, 0x5A, 0x62, 0x66, 0x0B, 0x2E, 0x5E, 0xFB, 0x09, +/* 1360 */ 0x41, 0x08, 0x10, 0x09, 0x9B, 0xD6, 0xFE, 0x41, 0x3B, 0x0C, 0x8C, 0xA4, 0x8F, 0x54, 0x33, 0x7D, +/* 1370 */ 0xA2, 0xA8, 0x38, 0x51, 0x54, 0x46, 0x1E, 0x06, 0x10, 0x0B, 0x19, 0x97, 0x9C, 0x02, 0x3B, 0x0B, +/* 1380 */ 0xC5, 0xC5, 0xC5, 0xA6, 0x5E, 0x93, 0x58, 0x07, 0x0B, 0xA6, 0xEB, 0xFC, 0x92, 0x7C, 0x2A, 0x0B, +/* 1390 */ 0xB0, 0x92, 0x62, 0x47, 0x0B, 0xB0, 0x92, 0x0C, 0x8C, 0x2A, 0x0B, 0xA6, 0xE4, 0x7D, 0x0E, 0x2E, +/* 13A0 */ 0x5D, 0x0C, 0xA6, 0x5E, 0x03, 0xF6, 0x05, 0xF3, 0x10, 0x0A, 0x00, 0x9B, 0xC4, 0xC8, 0xFD, 0x10, +/* 13B0 */ 0x06, 0x33, 0xF8, 0x9C, 0x0B, 0x41, 0x0A, 0x6F, 0xA2, 0x8E, 0x09, 0x2B, 0x82, 0xD9, 0x56, 0x0B, +/* 13C0 */ 0x6D, 0x62, 0x8B, 0x6C, 0x08, 0x0F, 0x80, 0x05, 0x23, 0xFA, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, +/* 13D0 */ 0xD9, 0xD9, 0x10, 0x09, 0x33, 0x21, 0x71, 0x06, 0x0B, 0x5E, 0x5A, 0x0C, 0x4B, 0x6B, 0x1C, 0x65, +/* 13E0 */ 0x0F, 0x80, 0x0A, 0x61, 0x00, 0x7D, 0x49, 0x2A, 0x0A, 0xA6, 0x92, 0x82, 0x2A, 0x55, 0x7D, 0x1E, +/* 13F0 */ 0x00, 0x65, 0x67, 0x5E, 0x0A, 0x70, 0x03, 0x05, 0x58, 0x4A, 0x0C, 0x2F, 0x49, 0x03, 0x92, 0x4E, +/* 1400 */ 0x67, 0x04, 0x03, 0x23, 0x73, 0x18, 0x85, 0xA8, 0x06, 0x05, 0x6F, 0x46, 0x6D, 0x61, 0x23, 0x4E, +/* 1410 */ 0x41, 0x89, 0x40, 0x0D, 0x02, 0x47, 0xA2, 0x1C, 0x4E, 0x1E, 0x8E, 0x77, 0x2E, 0x92, 0x6C, 0x2D, +/* 1420 */ 0x62, 0x80, 0x10, 0x0B, 0xC3, 0x53, 0x06, 0x2B, 0xF2, 0x7E, 0x0E, 0x0A, 0x01, 0x36, 0x9A, 0x08, +/* 1430 */ 0xD2, 0xBB, 0x06, 0x2A, 0x68, 0x10, 0x05, 0x26, 0x71, 0xF5, 0x8F, 0x56, 0x5A, 0x60, 0x25, 0x7B, +/* 1440 */ 0xC7, 0xBC, 0xF2, 0x10, 0x05, 0x26, 0x71, 0xF5, 0x8F, 0x56, 0x5A, 0x60, 0x25, 0x7B, 0xC7, 0xBC, +/* 1450 */ 0xF2, 0x56, 0x85, 0xA7, 0xFC, 0x47, 0x7D, 0x0C, 0x70, 0x18, 0x0B, 0x05, 0x10, 0x09, 0x26, 0x02, +/* 1460 */ 0x07, 0x03, 0xBC, 0xF2, 0x33, 0xE8, 0x36, 0x06, 0x00, 0x01, 0x58, 0x01, 0x36, 0x06, 0x00, 0x0A, +/* 1470 */ 0x35, 0x36, 0x95, 0x70, 0x8B, 0x5A, 0x2E, 0x30, 0x2B, 0x5A, 0x2E, 0x96, 0x2B, 0x5A, 0x59, 0x08, +/* 1480 */ 0x59, 0x8B, 0x5A, 0x59, 0x4F, 0x28, 0x36, 0x06, 0x63, 0x8A, 0x5E, 0x5A, 0x59, 0x33, 0x0A, 0x74, +/* 1490 */ 0x36, 0x06, 0x34, 0x0E, 0x44, 0x10, 0x05, 0x26, 0x02, 0x06, 0xEC, 0x85, 0xCA, 0xCA, 0xCA, 0xCA, +/* 14A0 */ 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xA7, 0x05, 0x96, 0xA7, 0x0A, 0x30, 0x10, 0x0F, +/* 14B0 */ 0x9B, 0x48, 0x03, 0x06, 0x0D, 0x60, 0x63, 0x0C, 0x94, 0x1F, 0x7B, 0x38, 0x07, 0x0D, 0x70, 0x0E, +/* 14C0 */ 0x08, 0x0B, 0x70, 0x1F, 0x5A, 0x49, 0x7A, 0x86, 0x35, 0x01, 0x96, 0x1F, 0x5A, 0x70, 0x33, 0x82, +/* 14D0 */ 0x2A, 0xE1, 0x06, 0x00, 0x71, 0x2E, 0x2A, 0xE1, 0x06, 0x00, 0x71, 0x2E, 0x2A, 0x58, 0x1F, 0x5A, +/* 14E0 */ 0x59, 0x00, 0x71, 0x2E, 0x2A, 0x58, 0x10, 0x0B, 0x9B, 0x48, 0xE5, 0xD2, 0xBB, 0x06, 0x2A, 0x68, +/* 14F0 */ 0x10, 0x0B, 0x00, 0x9B, 0xAB, 0xC6, 0x10, 0x0B, 0x9B, 0x06, 0x67, 0x07, 0x41, 0x0A, 0x01, 0x36, +/* 1500 */ 0x0C, 0x80, 0xB9, 0x2A, 0xE8, 0x27, 0x5A, 0x59, 0xCE, 0x2F, 0x66, 0x0B, 0x2E, 0x36, 0x07, 0x0A, +/* 1510 */ 0x0E, 0x94, 0x01, 0x36, 0x06, 0x2B, 0xF2, 0x56, 0x5A, 0x61, 0x10, 0x0B, 0x00, 0x9B, 0x93, 0x58, +/* 1520 */ 0x84, 0xA6, 0xEB, 0xFC, 0x92, 0x7C, 0x2A, 0x0B, 0xB0, 0x92, 0x62, 0x47, 0x0B, 0xB0, 0x92, 0x0C, +/* 1530 */ 0x8C, 0x2A, 0x0B, 0xA6, 0xE4, 0x27, 0x71, 0x0E, 0x8F, 0x5D, 0xFC, 0x5E, 0x03, 0xF6, 0xDF, 0xC5, +/* 1540 */ 0xC5, 0xC5, 0xA6, 0xB4, 0x01, 0x10, 0x07, 0x9B, 0x48, 0x03, 0x08, 0x30, 0x8B, 0x5A, 0x8A, 0x0D, +/* 1550 */ 0x08, 0x05, 0x8B, 0x5A, 0x2F, 0x78, 0x5A, 0x8A, 0x53, 0x07, 0x53, 0xC7, 0x10, 0x09, 0x9B, 0x01, +/* 1560 */ 0xFD, 0x2B, 0x37, 0xA8, 0x0A, 0x74, 0x00, 0x7D, 0x1E, 0x2A, 0x03, 0x33, 0x7D, 0xFE, 0x08, 0x49, +/* 1570 */ 0x9D, 0x56, 0x50, 0x42, 0x71, 0x0B, 0x8F, 0x19, 0x7D, 0x1E, 0x92, 0x4E, 0x33, 0x71, 0x1E, 0x27, +/* 1580 */ 0x4E, 0x1E, 0x08, 0x5D, 0x74, 0x5E, 0x6C, 0x9A, 0x30, 0x04, 0x10, 0x07, 0xA5, 0x71, 0x09, 0xA7, +/* 1590 */ 0xFF, 0xE9, 0x56, 0x0C, 0x6D, 0x1E, 0x8B, 0x6C, 0x73, 0x66, 0x04, 0x23, 0x86, 0xA9, 0x08, 0x9C, +/* 15A0 */ 0x8F, 0x19, 0x7D, 0x0E, 0x60, 0x0A, 0x29, 0x4E, 0x0D, 0x6A, 0x04, 0x10, 0x0A, 0x9B, 0x55, 0x3E, +/* 15B0 */ 0x05, 0xB6, 0x10, 0x09, 0x18, 0x21, 0xC9, 0x2A, 0xFA, 0x27, 0x5A, 0x70, 0x40, 0x67, 0x7D, 0x96, +/* 15C0 */ 0x2A, 0x0B, 0xA6, 0x5E, 0x2D, 0x2A, 0x30, 0x27, 0x40, 0x35, 0x43, 0x1D, 0x70, 0x85, 0x02, 0x2B, +/* 15D0 */ 0x30, 0x00, 0x38, 0x2B, 0x91, 0xA6, 0x2E, 0x2B, 0x6C, 0x8F, 0xF4, 0x34, 0x62, 0xA6, 0x56, 0x0B, +/* 15E0 */ 0x96, 0x10, 0x0D, 0x23, 0x21, 0x65, 0x67, 0x33, 0x07, 0x8A, 0x34, 0x2E, 0x1F, 0x6C, 0x59, 0x33, +/* 15F0 */ 0x0A, 0x49, 0x33, 0x43, 0x1F, 0x71, 0x2E, 0x33, 0x0D, 0x0B, 0xA6, 0x5A, 0x35, 0x19, 0x30, 0x00, +/* 1600 */ 0x01, 0x59, 0x35, 0x09, 0xA6, 0x89, 0x9A, 0x00, 0x03, 0xA6, 0x0E, 0x06, 0x00, 0x38, 0x1C, 0xF3, +/* 1610 */ 0x06, 0x0D, 0x00, 0x0B, 0x09, 0x00, 0x0E, 0x0A, 0x89, 0x6C, 0x67, 0x09, 0x0A, 0x00, 0x77, 0x02, +/* 1620 */ 0x70, 0x89, 0x71, 0x70, 0x0C, 0x08, 0x5A, 0xA0, 0x67, 0x27, 0x94, 0x74, 0x00, 0xFA, 0x0F, 0x51, +/* 1630 */ 0x9A, 0x8C, 0x33, 0x0F, 0x58, 0x1C, 0x65, 0x62, 0x2A, 0x0C, 0x8A, 0x10, 0x09, 0x23, 0x21, 0x4E, +/* 1640 */ 0x8A, 0x2A, 0x0D, 0x44, 0x5E, 0x7C, 0x6C, 0x70, 0x8B, 0xFA, 0x00, 0xA1, 0x23, 0x37, 0xFB, 0x23, +/* 1650 */ 0x72, 0x1E, 0x18, 0x0D, 0x8A, 0x47, 0x36, 0x52, 0x2B, 0xF7, 0xF7, 0x5E, 0x65, 0x67, 0x00, 0x08, +/* 1660 */ 0x74, 0x92, 0x71, 0x30, 0x34, 0x58, 0x5E, 0x0A, 0x67, 0x00, 0x65, 0x59, 0x10, 0x09, 0x18, 0x21, +/* 1670 */ 0xC9, 0x2A, 0xFA, 0x92, 0xB1, 0x0D, 0xA7, 0x02, 0x10, 0x08, 0x21, 0x9C, 0x45, 0x74, 0x00, 0x7D, +/* 1680 */ 0x84, 0x84, 0xA2, 0x03, 0x2B, 0x4E, 0x8A, 0x18, 0x0D, 0x0E, 0x4A, 0x40, 0x59, 0x23, 0x71, 0x6A, +/* 1690 */ 0x18, 0xC9, 0x56, 0xE8, 0x18, 0x0D, 0x0E, 0x4A, 0x40, 0x96, 0x84, 0x84, 0x02, 0x92, 0x91, 0x45, +/* 16A0 */ 0x67, 0x10, 0x06, 0x69, 0x8D, 0x56, 0x6C, 0xA2, 0x18, 0x58, 0x06, 0x23, 0x71, 0x70, 0xEF, 0xEF, +/* 16B0 */ 0xEF, 0xEF, 0xEF, 0x1F, 0x7D, 0x09, 0xF4, 0x40, 0x70, 0x56, 0x71, 0x52, 0xEF, 0xEF, 0xEF, 0xEF, +/* 16C0 */ 0xEF, 0x56, 0x71, 0x8F, 0x19, 0x7D, 0x1E, 0x03, 0xA4, 0x2F, 0x89, 0x7D, 0x04, 0x10, 0x07, 0x89, +/* 16D0 */ 0x25, 0x71, 0x08, 0x03, 0x18, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0x10, 0x06, +/* 16E0 */ 0x1F, 0x69, 0x75, 0x71, 0x49, 0x03, 0x1F, 0x7D, 0x06, 0x6A, 0x3B, 0x37, 0x3B, 0xD1, 0xD1, 0xD1, +/* 16F0 */ 0xD1, 0xD1, 0x48, 0x9D, 0xB4, 0x05, 0x23, 0x6C, 0x2E, 0xEC, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0x37, +/* 1700 */ 0x9C, 0x9F, 0x56, 0x72, 0x61, 0x1F, 0x7D, 0x04, 0x01, 0x10, 0x09, 0xA3, 0x64, 0x8D, 0x01, 0x53, +/* 1710 */ 0x8A, 0x04, 0xDF, 0x51, 0x71, 0x0E, 0x84, 0xA2, 0x70, 0x8B, 0x7A, 0x4E, 0x03, 0x10, 0x00, 0x00, +/* 1720 */ 0x00, 0x03, 0x00, 0x26, 0x00, 0x5A, 0x00, 0x91, 0x00, 0xD3, 0x01, 0x0F, 0x01, 0x1C, 0x01, 0x61, +/* 1730 */ 0x01, 0x71, 0x01, 0xDC, 0x02, 0x13, 0x02, 0x4A, 0x02, 0x60, 0x02, 0x6D, 0x02, 0xBA, 0x02, 0xC8, +/* 1740 */ 0x02, 0xEB, 0x02, 0xFD, 0x03, 0x1F, 0x03, 0x41, 0x03, 0x4E, 0x03, 0x75, 0x03, 0xA9, 0x03, 0xAE, +/* 1750 */ 0x03, 0xCA, 0x03, 0xE3, 0x04, 0x1A, 0x04, 0x51, 0x04, 0x7F, 0x04, 0xD2, 0x05, 0x20, 0x05, 0x52, +/* 1760 */ 0x05, 0x64, 0x05, 0x76, 0x05, 0x84, 0x05, 0x96, 0x05, 0xAB, 0x05, 0xC7, 0x06, 0x12, 0x06, 0x55, +/* 1770 */ 0x06, 0x67, 0x06, 0x76, 0x06, 0x8B, 0x06, 0x9D, 0x06, 0xB1, 0x06, 0xC4, 0x06, 0xD8, 0x06, 0xEC, +/* 1780 */ 0x07, 0x41, 0x07, 0x57, 0x07, 0x6A, 0x07, 0x7D, 0x07, 0x8C, 0x07, 0xA5, 0x07, 0xBC, 0x07, 0xE2, +/* 1790 */ 0x08, 0x4F, 0x08, 0x60, 0x08, 0x71, 0x08, 0x88, 0x08, 0x9E, 0x08, 0xBD, 0x08, 0xF4, 0x09, 0x49, +/* 17A0 */ 0x09, 0x58, 0x09, 0x6B, 0x09, 0x7D, 0x09, 0x95, 0x09, 0xA8, 0x09, 0xC0, 0x0A, 0x18, 0x0A, 0x3F, +/* 17B0 */ 0x0A, 0x51, 0x0A, 0x63, 0x0A, 0x79, 0x0A, 0x8A, 0x0A, 0x9F, 0x0A, 0xB2, 0x0A, 0xCA, 0x0A, 0xDE, +/* 17C0 */ 0x0B, 0x30, 0x0B, 0x4C, 0x0B, 0x5E, 0x0B, 0x6E, 0x0B, 0x83, 0x0B, 0x91, 0x0B, 0xA2, 0x0B, 0xAD, +/* 17D0 */ 0x0B, 0xFF, 0x0C, 0x12, 0x0C, 0x26, 0x0C, 0x3B, 0x0C, 0x4C, 0x0C, 0x64, 0x0C, 0x81, 0x05, 0x00, +/* 17E0 */ 0x10, 0x05, 0x64, 0x09, 0x6B, 0x18, 0x0E, 0x8F, 0xA4, 0x0C, 0x02, 0x33, 0x69, 0xF5, 0xA6, 0xA4, +/* 17F0 */ 0xA6, 0x23, 0x65, 0x0F, 0x78, 0x65, 0x0F, 0x78, 0x65, 0x8C, 0xB4, 0x03, 0xB4, 0x03, 0xB4, 0x03, +/* 1800 */ 0x18, 0x0A, 0x67, 0x10, 0x09, 0x00, 0x99, 0x5D, 0x3B, 0x5D, 0x3B, 0x46, 0x29, 0x4E, 0x6E, 0x96, +/* 1810 */ 0x5E, 0x71, 0x58, 0x04, 0x01, 0x04, 0x07, 0x92, 0x65, 0x0F, 0x7F, 0xA2, 0x3B, 0x58, 0x3B, 0x62, +/* 1820 */ 0x3B, 0xA2, 0x3B, 0x0A, 0x67, 0x9C, 0x49, 0x03, 0x01, 0x04, 0x07, 0x8B, 0x5A, 0x6D, 0x1E, 0x51, +/* 1830 */ 0xC8, 0x0A, 0x6B, 0x18, 0x5D, 0x3B, 0x5D, 0x10, 0x09, 0x3C, 0x4E, 0x0C, 0x58, 0x08, 0x00, 0x1D, +/* 1840 */ 0x49, 0x07, 0x09, 0x2E, 0x8B, 0x73, 0x03, 0x33, 0x03, 0x4A, 0x0B, 0x0F, 0x3B, 0x68, 0x56, 0x71, +/* 1850 */ 0x68, 0x32, 0x4A, 0x0E, 0x4B, 0x8A, 0x8B, 0xC1, 0x05, 0x2C, 0x03, 0x2B, 0x68, 0x3B, 0x68, 0x3B, +/* 1860 */ 0x2D, 0x18, 0xF7, 0x23, 0x71, 0x0C, 0x8F, 0x84, 0x84, 0x04, 0x92, 0x86, 0x45, 0x70, 0x10, 0x0A, +/* 1870 */ 0x69, 0x99, 0x93, 0x01, 0x47, 0x91, 0x02, 0x1C, 0x71, 0x30, 0x46, 0x94, 0x0A, 0x28, 0x89, 0x4E, +/* 1880 */ 0x62, 0x83, 0x0E, 0x67, 0x27, 0x4E, 0x67, 0x33, 0x03, 0x59, 0x27, 0x65, 0x0F, 0x47, 0x0D, 0x0A, +/* 1890 */ 0x5E, 0x46, 0x47, 0x0D, 0x0A, 0x36, 0x02, 0x34, 0x8F, 0x92, 0x71, 0x96, 0x03, 0x03, 0x52, 0x5E, +/* 18A0 */ 0x0B, 0x58, 0x2F, 0x58, 0x0C, 0x51, 0x03, 0x6B, 0x00, 0x9E, 0x01, 0x02, 0xA0, 0x7D, 0x33, 0xC8, +/* 18B0 */ 0x10, 0x0A, 0xA5, 0xC9, 0x47, 0x55, 0x27, 0x03, 0x8A, 0x47, 0x58, 0x5E, 0x7C, 0x33, 0xFB, 0x5E, +/* 18C0 */ 0x03, 0x8F, 0x33, 0xA1, 0x2B, 0x0B, 0x44, 0x43, 0x2B, 0x43, 0x38, 0x56, 0x9A, 0x59, 0x5E, 0x65, +/* 18D0 */ 0x45, 0x35, 0x7D, 0x9E, 0x1E, 0x03, 0x03, 0x33, 0x7D, 0x02, 0x03, 0x1E, 0x02, 0x29, 0x08, 0x45, +/* 18E0 */ 0x35, 0x27, 0x71, 0x2C, 0x1E, 0x2C, 0x51, 0xC8, 0x96, 0x19, 0x7D, 0x96, 0x10, 0x07, 0x00, 0x26, +/* 18F0 */ 0xB3, 0xB3, 0xB3, 0x43, 0xD0, 0xB3, 0xB3, 0xB3, 0x43, 0x10, 0x0A, 0xA5, 0x34, 0x0A, 0x0E, 0xC6, +/* 1900 */ 0x2B, 0x0C, 0x2E, 0x08, 0x0B, 0x44, 0x5E, 0x03, 0x8F, 0x2A, 0x29, 0xFA, 0x3B, 0x0C, 0x2E, 0xEC, +/* 1910 */ 0x38, 0x0E, 0x96, 0x29, 0x07, 0x8C, 0x01, 0x07, 0x0E, 0x44, 0x5E, 0x9A, 0x5C, 0x06, 0x27, 0x65, +/* 1920 */ 0x59, 0x4E, 0x74, 0x5E, 0xE0, 0x49, 0x07, 0x38, 0x4A, 0x63, 0x0B, 0x0F, 0x74, 0x9C, 0x6A, 0x3B, +/* 1930 */ 0x2D, 0x1D, 0x0A, 0x04, 0x02, 0x06, 0x96, 0x8B, 0xC1, 0x0F, 0x1E, 0x78, 0x9E, 0x03, 0x10, 0x07, +/* 1940 */ 0x26, 0x01, 0x33, 0x71, 0x2B, 0xFA, 0x00, 0x55, 0x5E, 0x71, 0x0E, 0x08, 0x6C, 0xA0, 0x10, 0x0F, +/* 1950 */ 0x2A, 0x97, 0x6F, 0x4E, 0x0C, 0x2F, 0x94, 0x01, 0x1C, 0x40, 0x96, 0x06, 0x05, 0x08, 0x9F, 0x02, +/* 1960 */ 0x27, 0x03, 0x59, 0x33, 0x7A, 0xE0, 0x0C, 0x27, 0x0B, 0x09, 0x63, 0x0E, 0x1E, 0x02, 0x01, 0x61, +/* 1970 */ 0x2A, 0xC8, 0x8C, 0xF7, 0x06, 0x0A, 0x7A, 0x08, 0x0A, 0x1F, 0x4E, 0x0E, 0x6C, 0xA6, 0x47, 0x50, +/* 1980 */ 0x89, 0x50, 0x00, 0x07, 0x0D, 0x1F, 0x4C, 0x1F, 0x4E, 0x0D, 0x00, 0x5D, 0x2A, 0x4E, 0x0D, 0x19, +/* 1990 */ 0x71, 0xA6, 0x48, 0x7A, 0x40, 0x0B, 0x1C, 0x80, 0x02, 0x2E, 0x03, 0x07, 0x7A, 0x0D, 0x06, 0x89, +/* 19A0 */ 0x6C, 0x6B, 0x07, 0x2F, 0x6B, 0x09, 0x0D, 0x51, 0x0A, 0x0E, 0x08, 0x06, 0x07, 0x06, 0x0B, 0xA0, +/* 19B0 */ 0x1C, 0x40, 0x6E, 0x1E, 0x03, 0x2A, 0x7D, 0x9E, 0x02, 0x10, 0x09, 0xD0, 0x8D, 0x23, 0x71, 0x68, +/* 19C0 */ 0x62, 0x06, 0x8B, 0x65, 0x2C, 0x68, 0x78, 0x71, 0x07, 0xF4, 0x01, 0x09, 0x6D, 0xF4, 0x08, 0x2E, +/* 19D0 */ 0x05, 0x08, 0xF4, 0x2D, 0x00, 0x5A, 0xF4, 0x0B, 0x67, 0xC1, 0x06, 0x1D, 0x6E, 0x07, 0x0C, 0x0A, +/* 19E0 */ 0x2A, 0x7D, 0x04, 0x02, 0x00, 0x71, 0x19, 0x97, 0x6C, 0x95, 0x95, 0x95, 0x8B, 0x0C, 0x45, 0xA6, +/* 19F0 */ 0x10, 0x0B, 0x9B, 0x34, 0x06, 0x33, 0x5A, 0x4A, 0x09, 0x28, 0x43, 0x92, 0x6C, 0x70, 0x00, 0x01, +/* 1A00 */ 0x6A, 0x92, 0x71, 0x58, 0x33, 0x52, 0x5E, 0x0B, 0x74, 0x5A, 0x2E, 0x8B, 0x0E, 0xA6, 0x91, 0x74, +/* 1A10 */ 0x27, 0x40, 0x2E, 0x00, 0x03, 0x49, 0x2B, 0x52, 0x5A, 0x8F, 0x33, 0x7D, 0x6A, 0x33, 0x37, 0x29, +/* 1A20 */ 0x04, 0x28, 0x4F, 0x06, 0x2A, 0x7D, 0x54, 0x10, 0x09, 0xA5, 0xA5, 0x32, 0x32, 0x29, 0x0E, 0x45, +/* 1A30 */ 0x8C, 0x27, 0x4E, 0x20, 0x73, 0xEC, 0x85, 0xEC, 0x85, 0xEC, 0x71, 0x04, 0x01, 0x10, 0x07, 0xA5, +/* 1A40 */ 0xA5, 0x02, 0x24, 0x6F, 0x0E, 0x6D, 0xF4, 0x63, 0x20, 0x01, 0x10, 0x0C, 0x26, 0xC8, 0xA4, 0x6E, +/* 1A50 */ 0x0B, 0x29, 0x46, 0xA8, 0x06, 0x2D, 0x02, 0x1C, 0x4E, 0x0E, 0x4C, 0x49, 0x03, 0x3F, 0x27, 0x91, +/* 1A60 */ 0x08, 0x00, 0x0E, 0x06, 0x0B, 0x09, 0x01, 0x28, 0x1C, 0x0C, 0x04, 0x00, 0x6B, 0x09, 0x09, 0x00, +/* 1A70 */ 0x0B, 0x04, 0x27, 0x76, 0x0E, 0x0F, 0x28, 0x0B, 0x04, 0x27, 0x0A, 0x06, 0x00, 0x60, 0x0D, 0x7A, +/* 1A80 */ 0x28, 0x1C, 0x7E, 0xE0, 0x01, 0x07, 0x84, 0x0C, 0x5E, 0x38, 0x05, 0x02, 0x03, 0x87, 0x7D, 0x0A, +/* 1A90 */ 0x2F, 0x49, 0x05, 0x2B, 0x71, 0x04, 0x03, 0x10, 0x06, 0x1F, 0x97, 0x7D, 0x24, 0x4A, 0x6C, 0x6D, +/* 1AA0 */ 0x8F, 0x8B, 0x71, 0x20, 0x02, 0x10, 0x09, 0x27, 0xF8, 0x7D, 0x01, 0x56, 0xE0, 0x0F, 0x8A, 0x23, +/* 1AB0 */ 0x46, 0x06, 0x07, 0x70, 0x2B, 0x60, 0x00, 0x91, 0x0C, 0x2B, 0x60, 0x33, 0x77, 0x2B, 0x38, 0x9E, +/* 1AC0 */ 0x94, 0x8B, 0x71, 0xA2, 0x1E, 0x6F, 0x4E, 0x03, 0x10, 0x09, 0x21, 0x79, 0x18, 0x79, 0xC0, 0x74, +/* 1AD0 */ 0x25, 0x32, 0x32, 0x29, 0xA2, 0x45, 0x92, 0x4E, 0x2C, 0x20, 0x10, 0x07, 0x26, 0x34, 0x9C, 0xA2, +/* 1AE0 */ 0xA0, 0x23, 0x0C, 0x0A, 0x06, 0x9F, 0x23, 0x7A, 0x85, 0x18, 0x91, 0x0D, 0x56, 0x71, 0x61, 0x1F, +/* 1AF0 */ 0x7D, 0x0C, 0x09, 0x18, 0x3D, 0xB4, 0x07, 0x84, 0x6F, 0x0C, 0x6D, 0x8C, 0x10, 0x07, 0xF8, 0x75, +/* 1B00 */ 0xC1, 0xA0, 0x2B, 0x91, 0x09, 0x05, 0xA1, 0x00, 0x53, 0x9C, 0x3D, 0x23, 0x71, 0x49, 0x03, 0x1F, +/* 1B10 */ 0x7D, 0xDF, 0x44, 0x9C, 0xF4, 0x91, 0x05, 0x03, 0x0A, 0x0E, 0x6F, 0x7E, 0x1E, 0x04, 0x10, 0x06, +/* 1B20 */ 0xF8, 0x84, 0x2A, 0x1D, 0x0C, 0x8A, 0x23, 0x82, 0x03, 0x19, 0x7D, 0x10, 0x0B, 0x9B, 0x06, 0x59, +/* 1B30 */ 0x2A, 0x58, 0x36, 0xF1, 0xF1, 0xF1, 0x06, 0x2A, 0x49, 0x36, 0x08, 0x33, 0x07, 0x62, 0x36, 0x0E, +/* 1B40 */ 0x08, 0x09, 0x0D, 0x68, 0x51, 0x5A, 0x8A, 0x6A, 0x02, 0x08, 0x6B, 0x1C, 0x7B, 0x7F, 0xFB, 0x53, +/* 1B50 */ 0xA7, 0xFB, 0x10, 0x0D, 0x99, 0x06, 0x2D, 0x6D, 0x62, 0x27, 0x91, 0x4B, 0x5F, 0x0D, 0x0E, 0x1C, +/* 1B60 */ 0x71, 0x45, 0xDC, 0x06, 0x45, 0xDC, 0x06, 0x45, 0xDC, 0x04, 0x45, 0xDC, 0x00, 0x0D, 0x4B, 0xDC, +/* 1B70 */ 0x00, 0x4C, 0x6D, 0xDC, 0x34, 0x04, 0x87, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, +/* 1B80 */ 0x9A, 0x00, 0x1D, 0x07, 0x7A, 0x2C, 0x10, 0x04, 0xA5, 0xA5, 0xB7, 0x10, 0x05, 0x56, 0x9B, 0x64, +/* 1B90 */ 0x4E, 0x0D, 0x18, 0x5A, 0x0E, 0x06, 0x19, 0x7D, 0x05, 0x0E, 0x06, 0x2B, 0x4E, 0x4C, 0x08, 0x2B, +/* 1BA0 */ 0x71, 0x2F, 0x6B, 0x23, 0x71, 0x04, 0x01, 0x10, 0x07, 0xA5, 0x4E, 0x0D, 0x0E, 0x2B, 0x65, 0x0E, +/* 1BB0 */ 0x2D, 0x2A, 0x1D, 0x02, 0x07, 0x0E, 0xF5, 0x0E, 0xF5, 0x0E, 0xF5, 0x0E, 0xF5, 0x0E, 0xF5, 0x0E, +/* 1BC0 */ 0x10, 0x09, 0xD0, 0x8D, 0xA4, 0x6E, 0x08, 0x8B, 0x6C, 0x8A, 0x05, 0x0A, 0x59, 0x8B, 0x0B, 0x44, +/* 1BD0 */ 0x33, 0x6A, 0x8B, 0x6A, 0x2A, 0x0B, 0x0F, 0x8B, 0x6A, 0x2A, 0x0B, 0x0F, 0x8B, 0x2D, 0x2A, 0x9F, +/* 1BE0 */ 0x5E, 0x5A, 0x8F, 0x03, 0x08, 0x70, 0x2B, 0x0A, 0x2F, 0x96, 0x6F, 0x71, 0x04, 0x02, 0x1C, 0x97, +/* 1BF0 */ 0x5A, 0x95, 0x95, 0x95, 0x8B, 0x6E, 0x4B, 0x10, 0x0B, 0x9B, 0x9E, 0x34, 0x05, 0x2B, 0x0A, 0x28, +/* 1C00 */ 0x06, 0xF4, 0x02, 0x30, 0x33, 0x2D, 0x51, 0x40, 0x70, 0x63, 0x96, 0x2B, 0x0D, 0x35, 0x0A, 0x59, +/* 1C10 */ 0x5E, 0x91, 0x74, 0x5A, 0x2E, 0x5E, 0x03, 0x49, 0x01, 0x4F, 0x28, 0x92, 0x0B, 0x35, 0x08, 0x59, +/* 1C20 */ 0x92, 0x6C, 0x59, 0x00, 0x82, 0x5E, 0x91, 0x0A, 0x00, 0x5A, 0x0D, 0x51, 0xC8, 0x54, 0x10, 0x11, +/* 1C30 */ 0x56, 0xD0, 0xD4, 0xC8, 0x61, 0x92, 0xC2, 0x0E, 0x06, 0x1C, 0x40, 0x0E, 0x33, 0x5A, 0x44, 0x71, +/* 1C40 */ 0x01, 0x1F, 0x40, 0x0E, 0x2A, 0x0D, 0x08, 0x33, 0x0A, 0x0B, 0x1F, 0x40, 0x0E, 0x00, 0x6C, 0x0F, +/* 1C50 */ 0x7A, 0x01, 0x74, 0x8B, 0x0C, 0x09, 0x33, 0x07, 0x0D, 0xBA, 0x02, 0x03, 0x10, 0x11, 0x56, 0xD0, +/* 1C60 */ 0xD4, 0xC8, 0x61, 0x92, 0xC2, 0x0E, 0x06, 0x34, 0x1F, 0x40, 0x0E, 0x33, 0x5A, 0x44, 0x06, 0x0E, +/* 1C70 */ 0x1E, 0x01, 0x2A, 0x40, 0x0E, 0x2A, 0x0D, 0x08, 0x02, 0x60, 0x06, 0x2E, 0x2A, 0x40, 0x0E, 0x00, +/* 1C80 */ 0x6C, 0x0F, 0x7A, 0x01, 0x33, 0x3D, 0x92, 0x0C, 0x09, 0x1F, 0x0D, 0x08, 0x89, 0x4E, 0x8C, 0x2A, +/* 1C90 */ 0x5A, 0x0E, 0x51, 0x0B, 0x0A, 0x47, 0x03, 0x61, 0x27, 0x72, 0x03, 0x33, 0x71, 0x60, 0x92, 0x3F, +/* 1CA0 */ 0x47, 0x9F, 0x84, 0x06, 0x2A, 0xC8, 0x67, 0x54, 0x6D, 0x49, 0x89, 0x5D, 0x18, 0x71, 0x03, 0x10, +/* 1CB0 */ 0x11, 0x23, 0xD0, 0x91, 0x06, 0x19, 0x71, 0x0B, 0x49, 0x04, 0x2A, 0x71, 0x67, 0x1F, 0x65, 0x5F, +/* 1CC0 */ 0x2D, 0x2A, 0x91, 0x0C, 0x92, 0x57, 0x0E, 0x54, 0x61, 0x27, 0x72, 0xA0, 0x40, 0x0D, 0x7D, 0x07, +/* 1CD0 */ 0xA1, 0x01, 0x33, 0x0E, 0x06, 0x92, 0x4E, 0x67, 0x5A, 0x44, 0x71, 0x01, 0x2A, 0x40, 0x03, 0x57, +/* 1CE0 */ 0x8C, 0x00, 0x0D, 0x08, 0x33, 0x0A, 0x0B, 0x47, 0x65, 0x0F, 0x62, 0x06, 0x6C, 0x0F, 0x7A, 0x01, +/* 1CF0 */ 0x74, 0x2A, 0xC8, 0x02, 0x2A, 0x0C, 0x09, 0x33, 0x07, 0x0D, 0xBA, 0x02, 0x03, 0x10, 0x08, 0x64, +/* 1D00 */ 0x4E, 0x0E, 0x08, 0x23, 0x65, 0x49, 0x9C, 0x0C, 0x06, 0x00, 0x25, 0x71, 0x0E, 0x08, 0x23, 0x4E, +/* 1D10 */ 0x70, 0x1F, 0x7D, 0x68, 0x78, 0x03, 0x0D, 0x61, 0x23, 0x4F, 0x6B, 0x23, 0x6C, 0x8F, 0x56, 0x6C, +/* 1D20 */ 0x2E, 0x00, 0x65, 0x04, 0x00, 0x7D, 0x0E, 0x8A, 0x5D, 0x59, 0x8B, 0x93, 0x0E, 0x30, 0x04, 0x10, +/* 1D30 */ 0x0B, 0x89, 0x69, 0x3F, 0x02, 0xA4, 0x0E, 0x8F, 0x75, 0xDF, 0x02, 0x33, 0xA3, 0xF9, 0xD5, 0xBE, +/* 1D40 */ 0xC9, 0x10, 0x0B, 0x89, 0x98, 0xF5, 0x0D, 0x4A, 0x4E, 0x0D, 0x8A, 0x78, 0x8E, 0x02, 0x69, 0xF9, +/* 1D50 */ 0xD5, 0xBE, 0xC9, 0x10, 0x0B, 0x2B, 0x7D, 0x0C, 0x74, 0xED, 0xD3, 0x00, 0xA3, 0xF9, 0xD5, 0xBE, +/* 1D60 */ 0xC9, 0x10, 0x0B, 0x47, 0x98, 0x75, 0x90, 0x8F, 0x04, 0x0D, 0x4A, 0x77, 0xCD, 0x2A, 0xA3, 0xF9, +/* 1D70 */ 0xD5, 0xBE, 0xC9, 0x10, 0x0B, 0x33, 0x98, 0x71, 0x2A, 0x6F, 0x55, 0x00, 0x7C, 0x5E, 0x5A, 0xA0, +/* 1D80 */ 0x91, 0x0D, 0x7A, 0x88, 0xF9, 0xD5, 0xBE, 0xC9, 0x10, 0x0B, 0x19, 0x75, 0x04, 0x0E, 0x8A, 0x56, +/* 1D90 */ 0x3D, 0x06, 0x67, 0x23, 0x0B, 0x09, 0x03, 0xA0, 0x5E, 0x5C, 0x1E, 0x56, 0x71, 0x04, 0x01, 0x56, +/* 1DA0 */ 0xF9, 0xD5, 0xBE, 0xC9, 0x10, 0x0F, 0x99, 0x85, 0x5B, 0x92, 0x2D, 0x96, 0x84, 0x84, 0x06, 0x27, +/* 1DB0 */ 0x03, 0x70, 0x8A, 0x8B, 0x65, 0x8C, 0xA1, 0x23, 0x0D, 0x0C, 0x91, 0x8C, 0x1D, 0x70, 0x5A, 0x59, +/* 1DC0 */ 0x24, 0x89, 0x91, 0x8C, 0x00, 0x03, 0x4B, 0x62, 0x1C, 0x6A, 0x34, 0x49, 0x05, 0x2C, 0x04, 0x89, +/* 1DD0 */ 0x4D, 0x32, 0x0D, 0x0E, 0x5E, 0x73, 0x45, 0x8C, 0x92, 0x58, 0x20, 0x09, 0x74, 0x1C, 0x6C, 0x8F, +/* 1DE0 */ 0x47, 0x4D, 0x27, 0xC9, 0xC8, 0x0F, 0x80, 0x84, 0x06, 0xC8, 0x58, 0x19, 0x0D, 0x6D, 0x49, 0x10, +/* 1DF0 */ 0x0A, 0x99, 0x93, 0x0D, 0x49, 0x07, 0x1D, 0x41, 0x5F, 0x0A, 0x70, 0x5E, 0x0D, 0x6B, 0x00, 0x4E, +/* 1E00 */ 0x36, 0x08, 0x18, 0xC9, 0x18, 0xA2, 0x75, 0x0E, 0x0F, 0x3B, 0x62, 0x3B, 0x0E, 0x0F, 0x3B, 0x68, +/* 1E10 */ 0x78, 0x65, 0x59, 0x56, 0x71, 0x1E, 0xF5, 0x96, 0x02, 0x00, 0x03, 0x80, 0x5E, 0x5A, 0x6E, 0x49, +/* 1E20 */ 0x04, 0x23, 0x5D, 0x7F, 0x08, 0x60, 0x3B, 0x79, 0x2B, 0x4E, 0x43, 0x23, 0x86, 0x49, 0x01, 0x56, +/* 1E30 */ 0x9E, 0x01, 0x10, 0x09, 0x89, 0x69, 0x0A, 0x0A, 0x78, 0x65, 0x41, 0x39, 0x56, 0x5A, 0x0B, 0x01, +/* 1E40 */ 0xA3, 0x86, 0x45, 0xE3, 0x10, 0x09, 0x69, 0x8D, 0x5D, 0x56, 0x7E, 0x8A, 0x78, 0x5F, 0x6F, 0x98, +/* 1E50 */ 0x86, 0x45, 0xE3, 0x10, 0x09, 0x2A, 0x98, 0x90, 0xA0, 0x2B, 0x71, 0x9F, 0x0A, 0x74, 0x8B, 0x91, +/* 1E60 */ 0x09, 0x01, 0x5A, 0x0C, 0x88, 0x86, 0x45, 0xE3, 0x10, 0x09, 0x2B, 0x7D, 0x34, 0x6F, 0x87, 0x0D, +/* 1E70 */ 0x0E, 0x51, 0x40, 0x6B, 0x00, 0x38, 0x88, 0x86, 0x45, 0xE3, 0x10, 0x05, 0x33, 0x69, 0x4E, 0x0D, +/* 1E80 */ 0xA7, 0x04, 0x0C, 0x96, 0x03, 0x9C, 0x09, 0x06, 0x2A, 0xA3, 0xEA, 0xA9, 0xA9, 0x08, 0x10, 0x05, +/* 1E90 */ 0x47, 0x69, 0x4E, 0x0C, 0x06, 0x23, 0x93, 0xC6, 0x8B, 0x4E, 0x0A, 0x7F, 0x98, 0xEA, 0xA9, 0xA9, +/* 1EA0 */ 0x08, 0x10, 0x05, 0x47, 0xF5, 0x8A, 0x2B, 0x65, 0x2E, 0x30, 0x4A, 0x90, 0x03, 0x71, 0x0C, 0x05, +/* 1EB0 */ 0x25, 0xEA, 0xA9, 0xA9, 0x08, 0x10, 0x05, 0x92, 0x7D, 0x2A, 0x29, 0x71, 0x96, 0x5A, 0x70, 0x8B, +/* 1EC0 */ 0x4F, 0x09, 0x63, 0x61, 0x25, 0xEA, 0xA9, 0xA9, 0x08, 0x10, 0x0C, 0x3C, 0x01, 0x6D, 0x6A, 0x08, +/* 1ED0 */ 0x7A, 0x7D, 0x49, 0x84, 0x37, 0x6B, 0x7D, 0x1E, 0x00, 0x4E, 0x49, 0x7A, 0x8D, 0x1E, 0x47, 0x0A, +/* 1EE0 */ 0x74, 0x00, 0x8D, 0x1E, 0x2A, 0x6C, 0x2E, 0x8D, 0x03, 0x1E, 0x02, 0x02, 0x01, 0x71, 0x1E, 0x89, +/* 1EF0 */ 0x91, 0x4B, 0x70, 0x71, 0x1E, 0x1C, 0x03, 0x05, 0x49, 0x2C, 0x02, 0x71, 0x1E, 0x00, 0x8D, 0x1E, +/* 1F00 */ 0x47, 0x03, 0x96, 0x00, 0x8D, 0x1E, 0x2A, 0x6C, 0x2E, 0x00, 0x8D, 0x1E, 0x47, 0x0A, 0x74, 0x00, +/* 1F10 */ 0x8D, 0x1E, 0x5C, 0x0D, 0x7D, 0x49, 0x84, 0x0A, 0x49, 0x03, 0x7D, 0x6D, 0x6A, 0x39, 0x10, 0x0C, +/* 1F20 */ 0x1F, 0x98, 0x75, 0x90, 0x70, 0x04, 0x0D, 0x4A, 0x3F, 0xCD, 0xA3, 0x86, 0x67, 0x00, 0x4E, 0x70, +/* 1F30 */ 0xE7, 0xDB, 0xAD, 0x70, 0x10, 0x0D, 0x1C, 0x69, 0x3F, 0x03, 0xA4, 0x0D, 0x2E, 0x75, 0xDF, 0x29, +/* 1F40 */ 0x98, 0xCC, 0x09, 0x27, 0xBD, 0xFC, 0xBF, 0x10, 0x0D, 0x1C, 0x98, 0xF5, 0x44, 0x23, 0xC1, 0x0A, +/* 1F50 */ 0x78, 0x83, 0x78, 0x98, 0xCC, 0x09, 0x27, 0xBD, 0xFC, 0xBF, 0x10, 0x0D, 0x47, 0x98, 0xE0, 0x59, +/* 1F60 */ 0xED, 0xD3, 0xA3, 0xCC, 0x09, 0x27, 0xBD, 0xFC, 0xBF, 0x10, 0x0D, 0x1F, 0x98, 0x75, 0x4F, 0x8F, +/* 1F70 */ 0x04, 0x0D, 0x29, 0x08, 0x80, 0x0E, 0x96, 0x23, 0x7A, 0x01, 0x7F, 0x3B, 0xCC, 0x09, 0x27, 0xBD, +/* 1F80 */ 0xFC, 0xBF, 0x10, 0x0D, 0x2A, 0x98, 0x71, 0x2A, 0x6F, 0x55, 0x00, 0x7C, 0x5E, 0x6C, 0xA0, 0x91, +/* 1F90 */ 0x0D, 0x01, 0x88, 0xCC, 0x09, 0x27, 0xBD, 0xFC, 0xBF, 0x10, 0x09, 0x64, 0x01, 0x06, 0x33, 0x6C, +/* 1FA0 */ 0x29, 0x08, 0x74, 0x6C, 0x8F, 0x2B, 0x9A, 0x06, 0x30, 0x47, 0x7D, 0xF6, 0x6F, 0x71, 0x0E, 0x0F, +/* 1FB0 */ 0x6B, 0x2A, 0x7D, 0x9F, 0x02, 0x9F, 0x29, 0x08, 0x6B, 0x71, 0x94, 0x8B, 0x71, 0x33, 0x71, 0x10, +/* 1FC0 */ 0x0D, 0x33, 0x97, 0x4E, 0x3B, 0x72, 0x1A, 0x02, 0x1D, 0x0A, 0xA2, 0x62, 0x92, 0x4E, 0x41, 0x83, +/* 1FD0 */ 0x0E, 0x1E, 0x7A, 0x8D, 0x0E, 0x28, 0x01, 0x0E, 0x08, 0x8F, 0x19, 0x40, 0x59, 0x33, 0xDF, 0x00, +/* 1FE0 */ 0x0D, 0x44, 0x1C, 0x7C, 0x33, 0x5F, 0x91, 0x67, 0x1C, 0xA2, 0x2A, 0x0D, 0x03, 0x85, 0x07, 0x1C, +/* 1FF0 */ 0x41, 0x00, 0x71, 0x0E, 0x7B, 0x08, 0x1C, 0x41, 0x00, 0x5A, 0x0A, 0x7B, 0x08, 0x1C, 0xA2, 0x33, +/* 2000 */ 0x0A, 0x06, 0x33, 0x07, 0x70, 0x1C, 0x7C, 0x00, 0x28, 0x91, 0x74, 0x1F, 0x40, 0x59, 0x03, 0x0D, +/* 2010 */ 0x2A, 0xFC, 0x8D, 0x58, 0x08, 0x09, 0x33, 0x07, 0x2E, 0x27, 0x6C, 0x2F, 0x66, 0x0A, 0x1E, 0x01, +/* 2020 */ 0x36, 0x0E, 0x49, 0x08, 0x4A, 0x46, 0x3B, 0x0D, 0x0A, 0x89, 0x7D, 0x02, 0x10, 0x0C, 0x89, 0x69, +/* 2030 */ 0x4F, 0x9D, 0x56, 0x93, 0x49, 0xA7, 0x01, 0x07, 0x09, 0xA3, 0xDA, 0x22, 0xB2, 0x10, 0x0C, 0x27, +/* 2040 */ 0x69, 0x93, 0x0A, 0x23, 0x57, 0x62, 0x08, 0x23, 0xE0, 0xA7, 0x3B, 0xDA, 0x22, 0xB2, 0x10, 0x0C, +/* 2050 */ 0x33, 0x98, 0x4E, 0x58, 0x78, 0x05, 0x8A, 0x9F, 0x02, 0x2B, 0x0C, 0x06, 0x00, 0x01, 0x09, 0x09, +/* 2060 */ 0x23, 0x69, 0xDA, 0x22, 0xB2, 0x10, 0x0C, 0x2B, 0x7D, 0x01, 0x34, 0x23, 0x0D, 0x0E, 0x00, 0x82, +/* 2070 */ 0x2B, 0x0B, 0x0C, 0x00, 0x4F, 0x09, 0x23, 0x69, 0xDA, 0x22, 0xB2, 0x10, 0x0A, 0x69, 0x8D, 0x3F, +/* 2080 */ 0x8B, 0x40, 0x0E, 0x94, 0x56, 0x0A, 0x06, 0x7A, 0xA3, 0x0A, 0x67, 0x33, 0x4E, 0x8A, 0x27, 0xAA, +/* 2090 */ 0x2B, 0x65, 0x0F, 0x70, 0x56, 0xAE, 0x3B, 0x41, 0x3B, 0x41, 0x10, 0x0A, 0x1C, 0xD0, 0x31, 0x09, +/* 20A0 */ 0x02, 0x4A, 0x4E, 0x6D, 0x62, 0x0A, 0x03, 0x27, 0x4E, 0x96, 0x05, 0x06, 0x73, 0x6B, 0xF0, 0x5A, +/* 20B0 */ 0x8A, 0x92, 0x4D, 0x54, 0x49, 0x92, 0x4D, 0x54, 0x49, 0xF0, 0x6C, 0x8A, 0x92, 0xE8, 0x02, 0x03, +/* 20C0 */ 0x07, 0x0E, 0x67, 0x1C, 0x4E, 0x4B, 0x49, 0x04, 0x27, 0x4E, 0x96, 0x05, 0x04, 0x02, 0x2B, 0xFF, +/* 20D0 */ 0xE9, 0x10, 0x0B, 0x19, 0xD0, 0x57, 0x0E, 0xC6, 0x2B, 0x37, 0xA8, 0x0D, 0x67, 0x92, 0x71, 0x96, +/* 20E0 */ 0x00, 0x71, 0x2E, 0x92, 0x6C, 0x70, 0x33, 0x03, 0x8F, 0x36, 0x06, 0x33, 0x38, 0x01, 0x36, 0x06, +/* 20F0 */ 0x00, 0x08, 0x28, 0x36, 0x06, 0x00, 0x0D, 0x0C, 0x8B, 0x5A, 0x59, 0x00, 0x0A, 0x59, 0x5E, 0x5A, +/* 2100 */ 0x59, 0x00, 0xE0, 0x8F, 0x36, 0x06, 0x2A, 0x0B, 0x70, 0x27, 0x5A, 0x59, 0x54, 0x58, 0x27, 0x5A, +/* 2110 */ 0x59, 0x47, 0x68, 0x51, 0x06, 0x59, 0x47, 0x41, 0x27, 0x5A, 0x59, 0x5A, 0x07, 0x0B, 0x8F, 0x27, +/* 2120 */ 0x5A, 0x59, 0x00, 0x0B, 0x41, 0x08, 0x10, 0x0A, 0xF8, 0x0A, 0x7F, 0x90, 0x8A, 0x75, 0x05, 0xA1, +/* 2130 */ 0x00, 0x3B, 0x75, 0x9C, 0xAF, 0x10, 0x0A, 0x26, 0x54, 0x09, 0x04, 0x23, 0x6C, 0x0E, 0x8F, 0x2B, +/* 2140 */ 0x6C, 0x0E, 0x08, 0x02, 0x18, 0x81, 0x9C, 0xAF, 0x10, 0x0A, 0xF8, 0x05, 0x96, 0x6F, 0x6C, 0x8A, +/* 2150 */ 0x30, 0x51, 0x54, 0x0E, 0x06, 0x71, 0x80, 0x88, 0x03, 0xAF, 0x10, 0x0A, 0x00, 0x88, 0x7D, 0xF5, +/* 2160 */ 0x1E, 0x04, 0x0A, 0x08, 0x33, 0x7D, 0x60, 0x0B, 0x2F, 0x03, 0x2A, 0x7D, 0x33, 0x03, 0x02, 0x69, +/* 2170 */ 0x9C, 0xAF, 0x10, 0x0A, 0x89, 0x97, 0x7D, 0x2A, 0x6F, 0xF7, 0x6C, 0x70, 0x8B, 0x4F, 0x0A, 0x63, +/* 2180 */ 0x0E, 0x06, 0x88, 0x03, 0xAF, 0x10, 0x0A, 0x69, 0x8D, 0x3B, 0x37, 0x6B, 0x23, 0x43, 0x3D, 0x8B, +/* 2190 */ 0x4E, 0x6B, 0x3F, 0x56, 0x68, 0x74, 0x1F, 0x7D, 0x04, 0x02, 0x3B, 0x9C, 0xAF, 0x10, 0x0F, 0x9B, +/* 21A0 */ 0x02, 0x09, 0x0D, 0x0E, 0x94, 0x63, 0xF6, 0x07, 0x19, 0x71, 0x0C, 0x8E, 0x09, 0x96, 0x0F, 0x80, +/* 21B0 */ 0x0B, 0x8F, 0x5E, 0x0A, 0x49, 0x01, 0x33, 0x0B, 0xA6, 0x8D, 0x02, 0x09, 0x8F, 0x2A, 0xFB, 0x2A, +/* 21C0 */ 0x40, 0x0D, 0x6D, 0x70, 0x32, 0x06, 0x70, 0x47, 0x91, 0x1E, 0x06, 0x05, 0x37, 0x45, 0x70, 0xC8, +/* 21D0 */ 0x62, 0x7A, 0x85, 0x09, 0x05, 0x20, 0x02, 0x47, 0x03, 0x96, 0x5C, 0x08, 0x7D, 0x49, 0x2A, 0x37, +/* 21E0 */ 0x44, 0x33, 0x71, 0x19, 0x37, 0xA8, 0xA1, 0x07, 0x49, 0x83, 0xA1, 0x33, 0xC8, 0x0A, 0x41, 0x0A, +/* 21F0 */ 0x7A, 0x50, 0x41, 0x0A, 0x03, 0x10, 0x09, 0x9B, 0xD6, 0xFE, 0x41, 0x3B, 0x7C, 0x53, 0x08, 0x2A, +/* 2200 */ 0x6F, 0x0B, 0x0F, 0xA8, 0x38, 0x4A, 0x5A, 0x0D, 0x49, 0x06, 0x23, 0x91, 0x0A, 0x18, 0x6C, 0x38, +/* 2210 */ 0x4A, 0x34, 0x03, 0x05, 0x74, 0x2A, 0x36, 0x49, 0x01, 0x56, 0x9E, 0x01, 0x10, 0x0A, 0xF8, 0x06, +/* 2220 */ 0x07, 0x18, 0x91, 0x49, 0x7F, 0x02, 0x73, 0x03, 0x3B, 0x6F, 0x98, 0xC4, 0xC8, 0xFD, 0x10, 0x0A, +/* 2230 */ 0x00, 0xF8, 0x5A, 0x08, 0x23, 0x71, 0x0B, 0x1E, 0x23, 0xF7, 0x7F, 0x7A, 0x69, 0xC4, 0xC8, 0xFD, +/* 2240 */ 0x10, 0x0A, 0xF8, 0x90, 0x6B, 0x2B, 0x71, 0x9F, 0x0B, 0x6B, 0x2B, 0x0A, 0x0A, 0x7A, 0x77, 0x00, +/* 2250 */ 0x3B, 0x7A, 0xA3, 0xC4, 0xC8, 0xFD, 0x10, 0x0A, 0xD8, 0x7C, 0x01, 0x58, 0x8B, 0x91, 0x0D, 0x7A, +/* 2260 */ 0x0D, 0x0B, 0x00, 0x88, 0xC4, 0xC8, 0xFD, 0x10, 0x05, 0x56, 0x97, 0xE0, 0x78, 0x4E, 0x0E, 0x8F, +/* 2270 */ 0x4A, 0x54, 0x06, 0x0D, 0x09, 0x1C, 0x7D, 0xA3, 0xF2, 0x53, 0xC7, 0xBC, 0x10, 0x05, 0x00, 0x26, +/* 2280 */ 0x93, 0x29, 0x40, 0x0E, 0x61, 0x23, 0x5D, 0x9D, 0x56, 0x51, 0x2B, 0xBC, 0xF2, 0x53, 0xC7, 0x10, +/* 2290 */ 0x05, 0x26, 0x08, 0x2E, 0x2B, 0x65, 0x2E, 0x2E, 0x00, 0x1D, 0x0D, 0x03, 0x00, 0x03, 0x0D, 0x04, +/* 22A0 */ 0x3B, 0x7A, 0x3B, 0xBC, 0xF2, 0x53, 0xC7, 0x10, 0x05, 0x1F, 0x97, 0x7D, 0x54, 0xE9, 0x00, 0x08, +/* 22B0 */ 0xF4, 0x4C, 0x06, 0x00, 0x07, 0x6B, 0x88, 0x7B, 0xC7, 0xBC, 0xF2, 0x10, 0x0A, 0x97, 0x34, 0x5E, +/* 22C0 */ 0x40, 0x06, 0x01, 0x05, 0x28, 0x8B, 0x0A, 0x62, 0x8F, 0x56, 0x86, 0x8A, 0x23, 0x4F, 0xA8, 0x8F, +/* 22D0 */ 0x8B, 0x4E, 0x7A, 0x37, 0x78, 0x7A, 0x03, 0x8F, 0x8B, 0xC1, 0x60, 0x0D, 0x0C, 0x92, 0x71, 0x62, +/* 22E0 */ 0x95, 0xA2, 0xA6, 0x92, 0x87, 0x00, 0x4F, 0x8C, 0x92, 0x0D, 0x0E, 0x47, 0x73, 0x03, 0x92, 0x1E, +/* 22F0 */ 0x47, 0x73, 0x03, 0x92, 0x58, 0x47, 0x0A, 0x8C, 0x92, 0x0D, 0x0E, 0x47, 0x0D, 0x0E, 0x27, 0x65, +/* 2300 */ 0x59, 0x33, 0xE8, 0x5E, 0x4F, 0x2E, 0x08, 0x41, 0x29, 0x93, 0x0E, 0x30, 0x02, 0x10, 0x0B, 0x97, +/* 2310 */ 0x4A, 0xC8, 0x0C, 0x8F, 0x03, 0x0D, 0x03, 0x27, 0x40, 0x0C, 0x06, 0x0D, 0x1E, 0x23, 0x7A, 0x01, +/* 2320 */ 0x04, 0x69, 0x53, 0xE5, 0xD2, 0xBB, 0x06, 0x2A, 0x68, 0x10, 0x0B, 0x26, 0x4E, 0x09, 0x01, 0xA4, +/* 2330 */ 0x62, 0x06, 0x18, 0x57, 0x0E, 0x06, 0x3B, 0x6F, 0x98, 0xAB, 0xC6, 0x10, 0x0B, 0xF8, 0x4E, 0x0A, +/* 2340 */ 0x1F, 0x7D, 0x0A, 0x49, 0x78, 0x3A, 0xA7, 0x7A, 0x69, 0xAB, 0xC6, 0x10, 0x0B, 0xF8, 0xE0, 0x74, +/* 2350 */ 0x47, 0x7D, 0x9A, 0x0A, 0x74, 0x92, 0x40, 0x0B, 0x02, 0x5A, 0x44, 0x3B, 0x7A, 0xA3, 0xAB, 0xC6, +/* 2360 */ 0x10, 0x0B, 0x97, 0x75, 0x4F, 0x8F, 0x04, 0x0D, 0x4A, 0x77, 0xCD, 0x25, 0xAB, 0xC6, 0x10, 0x0B, +/* 2370 */ 0xD8, 0x08, 0x67, 0x00, 0x2D, 0x4A, 0x06, 0x6B, 0x00, 0x0A, 0x0D, 0x01, 0x88, 0xAB, 0xC6, 0x10, +/* 2380 */ 0x09, 0x3B, 0x99, 0xDE, 0x25, 0x1B, 0x2C, 0x20, 0xA3, 0xDE, 0x10, 0x0B, 0x99, 0x54, 0x03, 0x18, +/* 2390 */ 0x6C, 0x8C, 0x18, 0x0A, 0x0C, 0x2A, 0x7D, 0x46, 0x0F, 0x8A, 0x33, 0x7D, 0x0C, 0x2E, 0x73, 0x59, +/* 23A0 */ 0x1C, 0x40, 0x59, 0x6C, 0x38, 0x44, 0x92, 0x2D, 0x33, 0x0A, 0x06, 0x55, 0x92, 0x6A, 0x33, 0x0E, +/* 23B0 */ 0x02, 0x04, 0x70, 0x92, 0x1E, 0x00, 0x03, 0x0C, 0x00, 0x4D, 0x92, 0x6A, 0x00, 0x83, 0x6C, 0x70, +/* 23C0 */ 0x92, 0x2D, 0x00, 0x76, 0x55, 0x89, 0x40, 0x70, 0x0E, 0x00, 0x4F, 0x44, 0x5E, 0xF6, 0x77, 0x59, +/* 23D0 */ 0x33, 0x7D, 0x2F, 0xC6, 0x2B, 0x86, 0x03, 0x18, 0x46, 0x89, 0x7D, 0x03, 0x10, 0x0A, 0xF8, 0x05, +/* 23E0 */ 0x09, 0x75, 0x08, 0x49, 0xA7, 0x02, 0x08, 0x61, 0x3B, 0x7A, 0xA3, 0x55, 0x3E, 0x05, 0xB6, 0x10, +/* 23F0 */ 0x0A, 0x00, 0xF8, 0x6C, 0x0A, 0x56, 0x93, 0x49, 0x01, 0x23, 0x0D, 0x0B, 0xA7, 0x01, 0x69, 0x55, +/* 2400 */ 0x3E, 0x05, 0xB6, 0x10, 0x0A, 0x26, 0x34, 0x0C, 0x67, 0xED, 0x05, 0x5E, 0x65, 0x0B, 0x7A, 0x07, +/* 2410 */ 0x0D, 0x51, 0x8D, 0xA3, 0x55, 0x3E, 0x05, 0xB6, 0x10, 0x0A, 0xD8, 0x09, 0x35, 0x0D, 0x0E, 0x51, +/* 2420 */ 0x40, 0x28, 0x0B, 0x0C, 0x88, 0x55, 0x3E, 0x05, 0xB6, 0x10, 0x09, 0xF8, 0x71, 0x0B, 0x6F, 0x65, +/* 2430 */ 0x0F, 0xA0, 0x2B, 0x91, 0x0D, 0x06, 0x4A, 0x54, 0x69, 0xC9, 0x2A, 0xFA, 0x92, 0xB1, 0x0D, 0xA7, +/* 2440 */ 0x02, 0x10, 0x0B, 0xC3, 0x53, 0x1A, 0xCB, 0xB9, 0x2A, 0xE8, 0x27, 0x5A, 0x59, 0xCE, 0x62, 0x66, +/* 2450 */ 0x0B, 0x2E, 0x36, 0x07, 0x46, 0x94, 0x01, 0x36, 0x06, 0x2B, 0xF2, 0x56, 0x5A, 0x61, 0x10, 0x09, +/* 2460 */ 0x26, 0x71, 0x2A, 0x4A, 0x6C, 0x70, 0x91, 0x35, 0x27, 0x4E, 0x0E, 0x06, 0x00, 0x07, 0x0E, 0x78, +/* 2470 */ 0x69, 0xC9, 0x2A, 0xFA, 0x92, 0xB1, 0x0D, 0xA7, 0x02, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x1B, +/* 2480 */ 0x00, 0x0D, 0x0A, 0xEE, 0x24, 0x51, 0x08, 0x5B, 0x2E, 0x1C, 0x71, 0x20, 0x20, 0x03, 0x10, 0x09, +/* 2490 */ 0xEE, 0x24, 0x89, 0x5C, 0x45, 0x49, 0x27, 0x71, 0x05, 0x2C, 0x20, 0x04, 0x10, 0x0E, 0xEE, 0x24, +/* 24A0 */ 0x24, 0x01, 0x47, 0x6C, 0x4B, 0x5B, 0x96, 0x47, 0x71, 0x20, 0x20, 0x20, 0x03, 0x10, +/* char range ofs tables */ +0x00, 0x00, +/* 24B0 */ 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x8D, 0x00, 0x00, 0x07, 0x8F, 0x00, 0x00, +/* 24C0 */ 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x07, 0x92, 0x00, 0x00, 0x08, 0x50, 0x00, 0x00, +/* 24D0 */ 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x17, 0x1E, 0x00, 0x00, 0x17, 0xDE, 0x00, 0x00, +/* 24E0 */ 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x24, 0x7A, 0x00, 0x00, 0x24, 0x82, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular24.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular24.mcufont.h new file mode 100644 index 000000000..261053454 --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular24.mcufont.h @@ -0,0 +1,714 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 24 + * blob size: 11072, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x06, 0x48, 0x00, 0x00, 0x06, 0xC3, 0x00, 0x00, 0x00, 0x9F, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x16, 0x00, 0x1D, 0x00, 0x05, 0x00, 0x16, 0x00, 0x01, 0x00, 0x17, 0x00, 0x1D, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x32, 0x34, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x32, 0x34, 0x00, +/* dictionary data */ +0x41, 0x06, 0x06, 0x09, 0x02, +/* 0080 */ 0xC6, 0x13, 0xCE, 0x80, 0xC4, 0x13, 0xCE, 0x80, 0xC4, 0x80, 0xC9, 0x13, 0x13, 0xC7, 0x07, 0x43, +/* 0090 */ 0x27, 0x0D, 0x02, 0xDC, 0x08, 0x80, 0xCA, 0x0B, 0x03, 0x11, 0xDB, 0x84, 0x0E, 0xCB, 0x80, 0x0F, +/* 00A0 */ 0x03, 0xC7, 0x80, 0x80, 0xCD, 0xC2, 0x81, 0xCE, 0x80, 0xC4, 0xC1, 0x0B, 0x04, 0x28, 0xC1, 0x0E, +/* 00B0 */ 0x81, 0xCD, 0xCD, 0xC4, 0xC3, 0x12, 0x81, 0xC2, 0x0C, 0xCB, 0xCE, 0x80, 0xCB, 0xC2, 0x11, 0x0B, +/* 00C0 */ 0x40, 0x1C, 0xCB, 0xCD, 0x80, 0xC4, 0x81, 0x12, 0xC2, 0x80, 0x12, 0xC3, 0x80, 0x0D, 0xCB, 0x80, +/* 00D0 */ 0x40, 0x3C, 0xC5, 0x0F, 0xC3, 0xCA, 0xCE, 0x80, 0xCD, 0xC8, 0x02, 0xCD, 0x02, 0xC5, 0xC1, 0xCD, +/* 00E0 */ 0xCE, 0xC6, 0x05, 0x01, 0xC8, 0x81, 0x3C, 0xEB, 0x03, 0xC3, 0xC1, 0xC8, 0xCC, 0x80, 0xC9, 0x80, +/* 00F0 */ 0xC6, 0x80, 0xC5, 0x80, 0x81, 0x06, 0xCE, 0x80, 0xC5, 0x0A, 0xC3, 0x81, 0x06, 0xCE, 0x80, 0xC5, +/* 0100 */ 0x03, 0xCB, 0xC1, 0xCE, 0x80, 0xC2, 0xCE, 0x80, 0xC8, 0x13, 0x80, 0xC2, 0xCC, 0xC6, 0x01, 0xC6, +/* 0110 */ 0x80, 0xCA, 0x12, 0x40, 0x1A, 0xCD, 0xCE, 0x13, 0xC5, 0xCE, 0xCC, 0xC6, 0xCE, 0x1D, 0x0A, 0x12, +/* 0120 */ 0x10, 0xCC, 0xCE, 0x04, 0xCB, 0xCE, 0xCD, 0x82, 0x81, 0xC7, 0x02, 0xCE, 0xCB, 0xC5, 0x13, 0x14, +/* 0130 */ 0x80, 0xC5, 0xC1, 0x0D, 0xC1, 0x81, 0xC2, 0x0B, 0x80, 0xC9, 0x80, 0xC6, 0x03, 0xC5, 0x80, 0xC4, +/* 0140 */ 0x03, 0xC8, 0x80, 0xC9, 0x06, 0x42, 0x20, 0xFB, 0xCB, 0xC2, 0x2C, 0xC3, 0x0D, 0x03, 0xC6, 0xCC, +/* 0150 */ 0xCD, 0x80, 0xCC, 0xCC, 0xC4, 0x86, 0xCC, 0xCB, 0x0E, 0xC4, 0x80, 0x13, 0xC3, 0xC9, 0x80, 0xCE, +/* 0160 */ 0x02, 0xC7, 0xCE, 0xC1, 0xCE, 0xC5, 0x01, 0xCC, 0xC5, 0x0D, 0xC9, 0x13, 0xC2, 0x0E, 0x81, 0xC1, +/* 0170 */ 0x05, 0x42, 0x1E, 0xCD, 0xCC, 0xCC, 0xC1, 0x01, 0x01, 0xC2, 0xC9, 0xCE, 0x80, 0xC1, 0x80, 0xCD, +/* 0180 */ 0x12, 0xCE, 0xCA, 0xC1, 0xC3, 0xC1, 0xCE, 0x80, 0x40, 0x11, 0x80, 0xC7, 0x01, 0x01, 0xC4, 0x01, +/* 0190 */ 0xC3, 0xCE, 0xC2, 0xCA, 0xCE, 0xCC, 0xC3, 0xC3, 0x13, 0x41, 0x09, 0x1A, 0xC1, 0xCA, 0xCD, 0xCB, +/* 01A0 */ 0x02, 0xC8, 0xCD, 0x80, 0xCE, 0xC8, 0x09, 0xCA, 0x80, 0xCA, 0x07, 0xC9, 0x80, 0xCB, 0x09, 0xCB, +/* 01B0 */ 0x80, 0xC9, 0x07, 0xC8, 0x03, 0xC8, 0x80, 0xC9, 0xC3, 0x01, 0xC7, 0xC1, 0xC7, 0x80, 0xC8, 0xC2, +/* 01C0 */ 0x81, 0x04, 0xC8, 0xDD, 0x04, 0xC7, 0xC1, 0xCB, 0xCD, 0xC7, 0xDE, 0xCE, 0x80, 0xC1, 0x01, 0x01, +/* 01D0 */ 0xC5, 0xCE, 0x80, 0xCC, 0xCB, 0x0C, 0xC2, 0x81, 0x04, 0xC8, 0x80, 0xC9, 0x0C, 0xC2, 0x81, 0x04, +/* 01E0 */ 0xC8, 0x80, 0xC9, 0x01, 0x02, 0xC3, 0x39, 0x01, 0x35, 0x02, 0x22, 0x09, 0x2E, 0x39, 0x01, 0x4D, +/* 01F0 */ 0x03, 0x26, 0x01, 0x4D, 0x03, 0x3D, 0x01, 0x38, 0x22, 0x47, 0x74, 0x3D, 0x01, 0x38, 0x69, 0xAB, +/* 0200 */ 0x3D, 0x01, 0x38, 0x69, 0xAB, 0x3D, 0x01, 0x38, 0x69, 0x98, 0x65, 0x01, 0x38, 0x22, 0x47, 0x70, +/* 0210 */ 0x3D, 0x01, 0x38, 0x22, 0x90, 0x38, 0x3D, 0x01, 0x4D, 0x57, 0x22, 0x0A, 0x3B, 0x39, 0x01, 0x35, +/* 0220 */ 0x6D, 0x0D, 0x85, 0x03, 0x39, 0x01, 0x4D, 0x03, 0x91, 0x6D, 0x7B, 0x72, 0x1F, 0x72, 0x1F, 0x72, +/* 0230 */ 0x1F, 0x59, 0x02, 0x1A, 0x7C, 0x3B, 0x00, 0xA7, 0x07, 0x39, 0x09, 0x98, 0x75, 0x25, 0x00, 0x52, +/* 0240 */ 0x81, 0x4F, 0x0C, 0x7E, 0x39, 0x0C, 0x80, 0x7E, 0x39, 0x52, 0x07, 0x83, 0x0A, 0x1D, 0x06, 0x2E, +/* 0250 */ 0x83, 0x96, 0x08, 0x50, 0x08, 0x82, 0x85, 0x3F, 0x9B, 0x3D, 0x50, 0x9C, 0x2E, 0x09, 0x0A, 0xA4, +/* 0260 */ 0x6D, 0x03, 0x2A, 0x01, 0xB1, 0x81, 0x0D, 0x4D, 0x7B, 0x9A, 0x69, 0x1D, 0x06, 0x7E, 0x61, 0x7E, +/* 0270 */ 0x21, 0x90, 0x09, 0x0D, 0x6B, 0x7E, 0x65, 0x50, 0x0E, 0x4D, 0x81, 0x0C, 0x7E, 0x43, 0x8F, 0xB3, +/* 0280 */ 0x7E, 0x21, 0x0F, 0x76, 0x75, 0x7E, 0x21, 0x4D, 0x03, 0x7C, 0x7E, 0x21, 0x0C, 0xAB, 0x22, 0x59, +/* 0290 */ 0x0E, 0x65, 0x75, 0x4D, 0x81, 0x01, 0x2E, 0xB3, 0x68, 0x89, 0x01, 0x85, 0x07, 0x0F, 0x23, 0x4D, +/* 02A0 */ 0x03, 0x39, 0x01, 0x4D, 0x88, 0x00, 0x0A, 0x73, 0x39, 0x01, 0x0F, 0x74, 0x7C, 0x3B, 0x39, 0x01, +/* 02B0 */ 0x4D, 0x08, 0xAB, 0x3D, 0x0E, 0x6C, 0xA3, 0xAB, 0x3D, 0xB1, 0x2E, 0x22, 0xA3, 0xAB, 0x3D, 0x0E, +/* 02C0 */ 0xAD, 0x76, 0xA7, 0x08, 0x3D, 0x0E, 0x4A, 0x3B, 0xA7, 0x08, 0x3D, 0x58, 0x96, 0x02, 0xA3, 0xAB, +/* 02D0 */ 0x3D, 0x58, 0x00, 0x09, 0xAB, 0xA3, 0xAB, 0x3D, 0x58, 0x9A, 0x2E, 0xA3, 0xAB, 0x3D, 0xB2, 0x0C, +/* 02E0 */ 0x70, 0x4C, 0xAB, 0x3D, 0xB2, 0x06, 0x3B, 0x4C, 0xAB, 0x3D, 0xB2, 0x96, 0x02, 0x07, 0xAB, 0x3D, +/* 02F0 */ 0xB2, 0x00, 0x5E, 0x4C, 0x5E, 0x4C, 0x72, 0x1F, 0x72, 0x1F, 0x72, 0x1F, 0x72, 0x1F, 0x0A, 0x73, +/* 0300 */ 0x26, 0x47, 0x70, 0x24, 0x75, 0x2E, 0x32, 0x01, 0x4D, 0x31, 0x01, 0x0F, 0x09, 0x0D, 0x6D, 0x02, +/* 0310 */ 0x56, 0x32, 0x50, 0x56, 0x32, 0x50, 0x56, 0x32, 0x50, 0x56, 0x32, 0x50, 0x56, 0x32, 0x50, 0x56, +/* 0320 */ 0x19, 0x90, 0x38, 0x4B, 0x0F, 0x76, 0x3D, 0x0E, 0x70, 0x00, 0x50, 0x4D, 0x31, 0x09, 0x2E, 0x02, +/* 0330 */ 0x22, 0x01, 0x52, 0x0A, 0x39, 0x01, 0x52, 0x7E, 0x68, 0x2E, 0x71, 0xAA, 0x68, 0x2E, 0x08, 0x30, +/* 0340 */ 0x00, 0x69, 0xAB, 0x3D, 0x30, 0x00, 0x69, 0xAB, 0x3D, 0x75, 0x7E, 0x21, 0x0C, 0x70, 0x26, 0x53, +/* 0350 */ 0x07, 0x1A, 0xAE, 0x73, 0x26, 0xA4, 0x7B, 0x03, 0x2E, 0x00, 0x90, 0x2E, 0x2C, 0x0E, 0x5B, 0xB3, +/* 0360 */ 0x73, 0x2C, 0x09, 0x70, 0x00, 0x53, 0x45, 0x05, 0x73, 0x00, 0x0D, 0x92, 0x2C, 0x01, 0x2E, 0x02, +/* 0370 */ 0x3B, 0x27, 0x0C, 0xAB, 0x74, 0x2A, 0x2D, 0x58, 0x8B, 0x50, 0x35, 0x1E, 0xAB, 0x66, 0x01, 0xA4, +/* 0380 */ 0x3C, 0xA1, 0xAB, 0x27, 0x91, 0x3B, 0x2A, 0x69, 0xA4, 0x94, 0x04, 0x3D, 0x75, 0x35, 0x3F, 0xAB, +/* 0390 */ 0x39, 0x40, 0x05, 0x75, 0x4D, 0x73, 0xB5, 0x3D, 0xAC, 0x73, 0xB5, 0x3D, 0xAC, 0x73, 0xB5, 0x3D, +/* 03A0 */ 0x2F, 0x01, 0x26, 0x0B, 0x73, 0x21, 0x0F, 0x70, 0xA3, 0x0F, 0x73, 0x21, 0x53, 0x3B, 0x0D, 0xA5, +/* 03B0 */ 0x73, 0x21, 0x01, 0x01, 0x38, 0x77, 0x19, 0x01, 0x38, 0x77, 0x19, 0x01, 0x38, 0x77, 0x19, 0x01, +/* 03C0 */ 0x38, 0x77, 0x19, 0x01, 0x4D, 0x09, 0x70, 0x00, 0x52, 0x7B, 0x47, 0x5B, 0x4C, 0xAB, 0x3D, 0x50, +/* 03D0 */ 0x2E, 0x00, 0x99, 0x7E, 0x65, 0xAE, 0x73, 0x22, 0x01, 0x8C, 0x32, 0x69, 0x70, 0x26, 0x0C, 0x70, +/* 03E0 */ 0x39, 0x01, 0x0F, 0x92, 0x77, 0x4B, 0x99, 0x80, 0x85, 0x39, 0x53, 0x8E, 0x23, 0x23, 0x4D, 0x03, +/* 03F0 */ 0x1A, 0x47, 0x70, 0x4B, 0x2B, 0x07, 0x1A, 0x90, 0x8C, 0x08, 0x3B, 0x1F, 0x7C, 0x7E, 0x19, 0x40, +/* 0400 */ 0x01, 0x1A, 0x0A, 0xAB, 0x1F, 0x58, 0x45, 0x21, 0x07, 0x0F, 0x5A, 0x01, 0x09, 0x09, 0x02, 0xB3, +/* 0410 */ 0x45, 0x0C, 0x4D, 0x7E, 0x73, 0x2A, 0x78, 0x02, 0x09, 0x0D, 0x2E, 0x08, 0x31, 0x50, 0x0E, 0x2E, +/* 0420 */ 0x3A, 0x73, 0x2A, 0x0C, 0x73, 0x00, 0x86, 0x31, 0x48, 0x85, 0x83, 0x53, 0x0A, 0x19, 0x43, 0x5A, +/* 0430 */ 0x52, 0x07, 0x83, 0x52, 0x07, 0x83, 0x0A, 0x1D, 0x06, 0x2E, 0x83, 0x96, 0x08, 0x7C, 0x31, 0x75, +/* 0440 */ 0x35, 0x3A, 0x73, 0x03, 0x3A, 0x62, 0x45, 0x40, 0x23, 0x6C, 0x3D, 0x96, 0x05, 0x22, 0x74, 0x1E, +/* 0450 */ 0x74, 0x1E, 0x74, 0x26, 0x43, 0x29, 0x25, 0x86, 0x28, 0x0D, 0x7E, 0x28, 0x07, 0x21, 0x2D, 0x73, +/* 0460 */ 0x1F, 0x50, 0x38, 0x32, 0x01, 0x4D, 0x03, 0x3D, 0x0C, 0xAB, 0xAE, 0x3B, 0x1A, 0x75, 0x85, 0x22, +/* 0470 */ 0x47, 0x76, 0x3D, 0x47, 0x70, 0x48, 0x7E, 0x2A, 0x54, 0x06, 0x3D, 0x0C, 0xAB, 0x00, 0xAE, 0x85, +/* 0480 */ 0x1F, 0x50, 0x8C, 0x01, 0x0F, 0x70, 0x4B, 0xAE, 0x7E, 0x26, 0x69, 0x73, 0xA6, 0x7E, 0x1A, 0x0C, +/* 0490 */ 0xAB, 0x26, 0xAE, 0x2E, 0x4B, 0x69, 0x73, 0x4B, 0xA3, 0x7E, 0x1A, 0x0A, 0x0F, 0x0A, 0x1F, 0x09, +/* 04A0 */ 0x3B, 0x1F, 0xA3, 0x7E, 0x26, 0x69, 0x73, 0x1A, 0x40, 0x01, 0x19, 0x0E, 0x70, 0x24, 0x47, 0xAB, +/* 04B0 */ 0x22, 0x7C, 0x85, 0x3D, 0x55, 0x70, 0x22, 0x99, 0x0E, 0x74, 0x24, 0xAE, 0x35, 0x3F, 0xAB, 0x3D, +/* 04C0 */ 0x50, 0x0A, 0x58, 0x94, 0x04, 0x01, 0x99, 0x89, 0x9A, 0x0F, 0x76, 0x00, 0x0A, 0x3B, 0x2C, 0x7D, +/* 04D0 */ 0x01, 0xB3, 0x0F, 0x87, 0x6E, 0x52, 0x71, 0x99, 0x35, 0x3A, 0x2E, 0x01, 0x39, 0x96, 0x08, 0x22, +/* 04E0 */ 0x01, 0x0C, 0x73, 0x1A, 0x7C, 0x2E, 0x32, 0x40, 0x31, 0x0A, 0x73, 0x4B, 0x0F, 0x76, 0x3D, 0x52, +/* 04F0 */ 0x07, 0x26, 0x47, 0x74, 0x3D, 0x52, 0x07, 0x4B, 0x52, 0x07, 0x3D, 0x52, 0x07, 0x26, 0x47, 0x74, +/* 0500 */ 0x3D, 0x0A, 0x73, 0x4B, 0x0F, 0x76, 0x24, 0x7C, 0x2E, 0x26, 0x99, 0x85, 0x31, 0x96, 0x08, 0x22, +/* 0510 */ 0x01, 0x0C, 0xAB, 0x39, 0x99, 0x35, 0x3A, 0x7E, 0x34, 0x46, 0x34, 0x5F, 0x01, 0x27, 0x53, 0x73, +/* 0520 */ 0x42, 0x0F, 0x37, 0x2F, 0x3C, 0x90, 0x38, 0x41, 0x08, 0x0E, 0x8A, 0x0E, 0x4D, 0x27, 0xA3, 0x07, +/* 0530 */ 0x83, 0x0E, 0x85, 0x83, 0x0A, 0x7E, 0x83, 0x54, 0x07, 0x83, 0x09, 0x5B, 0x83, 0x09, 0x74, 0x83, +/* 0540 */ 0x09, 0x74, 0x83, 0x09, 0x74, 0x83, 0x09, 0x74, 0x83, 0x09, 0x74, 0x83, 0x53, 0x32, 0x01, 0xA4, +/* 0550 */ 0x4A, 0x67, 0x7C, 0x0C, 0x3B, 0x09, 0x1D, 0x09, 0x1D, 0x09, 0x1D, 0x09, 0x1D, 0x53, 0x4B, 0x82, +/* 0560 */ 0x0E, 0x39, 0x0C, 0xAB, 0x26, 0x99, 0x85, 0x24, 0x69, 0xAB, 0x26, 0x99, 0x85, 0x39, 0x53, 0x0A, +/* 0570 */ 0x26, 0x99, 0x85, 0x1A, 0x7C, 0x2E, 0x00, 0x75, 0x85, 0x39, 0x96, 0x07, 0xB6, 0x0E, 0x85, 0x1A, +/* 0580 */ 0xAE, 0x4D, 0x0F, 0x7B, 0x0E, 0x7E, 0x79, 0x2A, 0x30, 0x1C, 0x1C, 0x83, 0xB4, 0x4F, 0x8B, 0x0E, +/* 0590 */ 0x29, 0x76, 0x2A, 0x30, 0x83, 0x30, 0x1C, 0x1C, 0x83, 0x0E, 0x7E, 0x79, 0x7B, 0x0E, 0x80, 0x45, +/* 05A0 */ 0x05, 0x57, 0x19, 0x7C, 0xB1, 0x1F, 0x7D, 0x24, 0xA1, 0x0F, 0x85, 0x4B, 0x99, 0x74, 0x4B, 0x75, +/* 05B0 */ 0x0D, 0x05, 0x3A, 0x19, 0x3A, 0x39, 0x3A, 0x22, 0x50, 0x98, 0x3D, 0x3A, 0x4B, 0x0A, 0x87, 0x39, +/* 05C0 */ 0x3A, 0x26, 0x90, 0xAB, 0x21, 0x3A, 0x00, 0x00, 0x2B, 0x38, 0x75, 0x8C, 0x21, 0x01, 0x8C, 0x21, +/* 05D0 */ 0x01, 0x03, 0x4D, 0x67, 0x50, 0x4D, 0x67, 0x50, 0x4D, 0x67, 0x50, 0x4D, 0x67, 0x50, 0x4D, 0x83, +/* 05E0 */ 0x01, 0x26, 0x0C, 0x70, 0x77, 0x01, 0x0F, 0x92, 0x26, 0x0C, 0x70, 0x77, 0x01, 0xB2, 0x9A, 0x0F, +/* 05F0 */ 0x4A, 0xAB, 0x3D, 0xB2, 0x22, 0x52, 0x0A, 0xAB, 0x3D, 0xB2, 0x1B, 0x85, 0xAB, 0x3D, 0xB2, 0x22, +/* 0600 */ 0x96, 0xAB, 0x4B, 0x0F, 0x0A, 0x0C, 0xAB, 0x65, 0x7C, 0x0D, 0x2E, 0x08, 0x9A, 0x5C, 0x0F, 0x7E, +/* 0610 */ 0x2A, 0xAE, 0x6B, 0x3C, 0x52, 0x0A, 0x74, 0x67, 0x01, 0x2E, 0x55, 0x0A, 0x21, 0x75, 0x73, 0x01, +/* 0620 */ 0x85, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x04, 0x2C, 0x69, 0x76, 0x19, 0x43, 0x00, 0x18, +/* 0630 */ 0x58, 0x39, 0x01, 0x38, 0x75, 0x7E, 0x39, 0x01, 0x38, 0x75, 0x7E, 0x39, 0x0B, 0x22, 0x0B, 0x74, +/* 0640 */ 0x2A, 0x96, 0x03, 0x02, 0x2E, 0x2A, 0xA3, 0x73, 0x67, 0xA3, 0x0D, 0x2D, 0x29, 0x06, 0x4B, 0x50, +/* 0650 */ 0x98, 0x48, 0x4F, 0x52, 0x7F, 0x24, 0x0A, 0x87, 0x32, 0x7C, 0x76, 0x1F, 0x90, 0xAB, 0x4B, 0x7C, +/* 0660 */ 0x76, 0x24, 0x09, 0x92, 0x67, 0x7C, 0x07, 0x58, 0x29, 0x22, 0x53, 0x28, 0x79, 0x06, 0x43, 0x29, +/* 0670 */ 0x1D, 0x64, 0x32, 0x52, 0x22, 0xA4, 0x31, 0x50, 0x3B, 0x04, 0x3B, 0x22, 0x52, 0x66, 0x90, 0x93, +/* 0680 */ 0x90, 0x93, 0x90, 0x93, 0x90, 0x93, 0x90, 0x93, 0x90, 0x09, 0x34, 0x07, 0x66, 0x61, 0x7E, 0x22, +/* 0690 */ 0x6F, 0x01, 0x66, 0x73, 0x39, 0x32, 0x53, 0x0F, 0x0A, 0x37, 0x04, 0x0B, 0x4D, 0x0A, 0x37, 0x53, +/* 06A0 */ 0x0A, 0x26, 0x99, 0x85, 0x24, 0x69, 0xAB, 0x26, 0x99, 0x0F, 0x01, 0x02, 0x76, 0x1A, 0x99, 0x70, +/* 06B0 */ 0xB6, 0xAB, 0x99, 0x76, 0x65, 0x3D, 0xAE, 0x39, 0x30, 0x22, 0xA3, 0x7E, 0x39, 0x30, 0x58, 0x9E, +/* 06C0 */ 0x58, 0x9E, 0x58, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x00, 0x0E, 0x00, +/* 06D0 */ 0x11, 0x00, 0x13, 0x00, 0x14, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1A, 0x00, +/* 06E0 */ 0x1D, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x21, 0x00, 0x22, 0x00, 0x24, 0x00, 0x25, 0x00, +/* 06F0 */ 0x28, 0x00, 0x2A, 0x00, 0x2C, 0x00, 0x2F, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x35, 0x00, +/* 0700 */ 0x37, 0x00, 0x39, 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3E, 0x00, 0x40, 0x00, 0x42, 0x00, 0x44, 0x00, +/* 0710 */ 0x45, 0x00, 0x47, 0x00, 0x4A, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x52, 0x00, 0x55, 0x00, 0x57, 0x00, +/* 0720 */ 0x59, 0x00, 0x5F, 0x00, 0x61, 0x00, 0x63, 0x00, 0x65, 0x00, 0x67, 0x00, 0x68, 0x00, 0x6A, 0x00, +/* 0730 */ 0x6B, 0x00, 0x6C, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x73, 0x00, 0x75, 0x00, 0x77, 0x00, +/* 0740 */ 0x79, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8A, 0x00, 0x8D, 0x00, 0x8F, 0x00, 0x91, 0x00, 0x93, 0x00, +/* 0750 */ 0x95, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, 0xA0, 0x00, 0xA2, 0x00, 0xA3, 0x00, +/* 0760 */ 0xA4, 0x00, 0xA5, 0x00, 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAD, 0x00, 0xB0, 0x00, +/* 0770 */ 0xB2, 0x00, 0xB4, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, +/* 0780 */ 0xC3, 0x00, 0xC5, 0x00, 0xCA, 0x00, 0xCC, 0x00, 0xCE, 0x00, 0xD0, 0x00, 0xD2, 0x00, 0xD4, 0x00, +/* 0790 */ 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xE0, 0x00, 0xE1, 0x00, 0xE3, 0x00, +/* 07A0 */ 0xE5, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEC, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF6, 0x00, +/* 07B0 */ 0xF8, 0x00, 0xFA, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x01, 0x01, 0x03, 0x01, 0x06, 0x01, 0x08, 0x01, +/* 07C0 */ 0x0A, 0x01, 0x0D, 0x01, 0x0F, 0x01, 0x12, 0x01, 0x14, 0x01, 0x16, 0x01, 0x18, 0x01, 0x1A, 0x01, +/* 07D0 */ 0x1C, 0x01, 0x1E, 0x01, 0x20, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01, 0x27, 0x01, 0x29, 0x01, +/* 07E0 */ 0x2B, 0x01, 0x39, 0x01, 0x3C, 0x01, 0x3E, 0x01, 0x40, 0x01, 0x42, 0x01, 0x44, 0x01, 0x48, 0x01, +/* 07F0 */ 0x49, 0x01, 0x4B, 0x01, 0x4D, 0x01, 0x4F, 0x01, 0x50, 0x01, 0x54, 0x01, 0x56, 0x01, 0x5A, 0x01, +/* 0800 */ 0x69, 0x01, 0x6B, 0x01, 0xB6, 0x01, 0xE3, 0x02, 0x1A, 0x02, 0x36, 0x02, 0x77, 0x02, 0x7B, 0x02, +/* 0810 */ 0x83, 0x02, 0x91, 0x02, 0x95, 0x02, 0xC4, 0x02, 0xCE, 0x03, 0x0D, 0x03, 0x1A, 0x03, 0x38, 0x03, +/* 0820 */ 0x4A, 0x03, 0x8D, 0x03, 0x90, 0x03, 0x9B, 0x03, 0xC8, 0x03, 0xD3, 0x03, 0xE4, 0x03, 0xFE, 0x04, +/* 0830 */ 0x4A, 0x04, 0x57, 0x04, 0x59, 0x04, 0x5B, 0x04, 0xA1, 0x04, 0xAD, 0x04, 0xB4, 0x04, 0xC1, 0x04, +/* 0840 */ 0xD2, 0x04, 0xDA, 0x04, 0xE3, 0x04, 0xE5, 0x05, 0x07, 0x05, 0x25, 0x05, 0x4C, 0x05, 0x4E, 0x05, +/* 0850 */ 0x50, 0x05, 0x56, 0x05, 0x65, 0x05, 0x72, 0x05, 0x88, 0x05, 0x93, 0x05, 0xA6, 0x05, 0xAD, 0x05, +/* 0860 */ 0xB3, 0x05, 0xB6, 0x05, 0xC1, 0x05, 0xCD, 0x05, 0xCF, 0x05, 0xEC, 0x05, 0xEE, 0x05, 0xF0, 0x05, +/* 0870 */ 0xF7, 0x05, 0xF9, 0x05, 0xFE, 0x06, 0x00, 0x06, 0x02, 0x06, 0x0E, 0x06, 0x10, 0x06, 0x12, 0x06, +/* 0880 */ 0x14, 0x06, 0x16, 0x06, 0x18, 0x06, 0x1A, 0x06, 0x1C, 0x06, 0x24, 0x06, 0x2F, 0x06, 0x3A, 0x06, +/* 0890 */ 0x3C, 0x06, 0x43, 0x06, 0x48, +/* char range info */ +0x00, 0x00, 0x06, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x24, +/* 08A0 */ 0x00, 0x42, 0x00, 0x97, 0x00, 0xF1, 0x01, 0x7D, 0x01, 0xF0, 0x02, 0x02, 0x02, 0x3C, 0x02, 0x77, +/* 08B0 */ 0x02, 0xA6, 0x02, 0xB2, 0x02, 0xBF, 0x02, 0xC9, 0x02, 0xD0, 0x03, 0x08, 0x03, 0x65, 0x03, 0x85, +/* 08C0 */ 0x03, 0xC3, 0x04, 0x09, 0x04, 0x45, 0x04, 0x8A, 0x04, 0xE4, 0x05, 0x16, 0x05, 0x72, 0x05, 0xCB, +/* 08D0 */ 0x05, 0xD5, 0x05, 0xE5, 0x06, 0x08, 0x06, 0x11, 0x06, 0x33, 0x06, 0x66, 0x07, 0x29, 0x07, 0x30, +/* 08E0 */ 0x07, 0x84, 0x07, 0xC0, 0x08, 0x14, 0x08, 0x19, 0x08, 0x32, 0x08, 0x8D, 0x08, 0xA5, 0x08, 0xAB, +/* 08F0 */ 0x08, 0xC3, 0x09, 0x13, 0x09, 0x20, 0x09, 0xB0, 0x09, 0xC0, 0x09, 0xC6, 0x09, 0xFA, 0x0A, 0x61, +/* 0900 */ 0x0A, 0xB1, 0x0A, 0xFF, 0x0B, 0x17, 0x0B, 0x1D, 0x0B, 0x73, 0x0C, 0x0C, 0x0C, 0x61, 0x0C, 0x79, +/* 0910 */ 0x0C, 0xAD, 0x0C, 0xC7, 0x0D, 0x00, 0x0D, 0x27, 0x0D, 0x4F, 0x0D, 0x5D, 0x0D, 0x66, 0x0D, 0x6C, +/* 0920 */ 0x0D, 0xC2, 0x0D, 0xC8, 0x0D, 0xFB, 0x0E, 0x01, 0x0E, 0x2A, 0x0E, 0x91, 0x0E, 0xBF, 0x0E, 0xD0, +/* 0930 */ 0x0E, 0xEF, 0x0F, 0x3B, 0x0F, 0x4D, 0x0F, 0x88, 0x0F, 0x98, 0x0F, 0x9D, 0x0F, 0xAF, 0x0F, 0xE3, +/* 0940 */ 0x0F, 0xFE, 0x10, 0x35, 0x10, 0x5B, 0x10, 0x63, 0x10, 0x9A, 0x11, 0x0A, 0x11, 0x4D, 0x11, 0x56, +/* 0950 */ 0x11, 0x82, 0x11, 0xBD, 0x11, 0xD0, 0x11, 0xF9, 0x06, 0x00, 0x10, 0x06, 0x18, 0x06, 0x93, 0x5D, +/* 0960 */ 0x2E, 0xF5, 0xF5, 0xF5, 0x83, 0xF0, 0x83, 0xF0, 0x83, 0xF0, 0x67, 0x50, 0x5E, 0x9A, 0x5E, 0x9A, +/* 0970 */ 0x25, 0x2C, 0x33, 0x61, 0x6D, 0x2C, 0x69, 0x4D, 0x37, 0x05, 0x6D, 0x10, 0x09, 0x18, 0x09, 0x74, +/* 0980 */ 0x5D, 0x25, 0x22, 0xA3, 0x74, 0xB3, 0x73, 0xFD, 0x70, 0x99, 0xAB, 0xFD, 0x76, 0x9A, 0xAB, 0x39, +/* 0990 */ 0x7C, 0x76, 0x9A, 0x98, 0x2A, 0x55, 0x03, 0x90, 0x74, 0x10, 0x0B, 0x18, 0xF1, 0x22, 0xDC, 0x34, +/* 09A0 */ 0x6A, 0x26, 0x60, 0x2C, 0x3B, 0x26, 0x7E, 0x21, 0x90, 0x0F, 0x0A, 0x22, 0x01, 0x25, 0x47, 0x4D, +/* 09B0 */ 0x80, 0x39, 0x09, 0x0C, 0x7E, 0x28, 0x52, 0x81, 0x3D, 0xA3, 0x76, 0x86, 0x70, 0x2A, 0x09, 0x5B, +/* 09C0 */ 0xEC, 0x7B, 0xDC, 0x01, 0x00, 0xDC, 0x34, 0x60, 0x26, 0x60, 0x2C, 0x7E, 0x26, 0x6A, 0x1A, 0xAE, +/* 09D0 */ 0x0B, 0x85, 0x28, 0x2B, 0x6D, 0x02, 0x3D, 0x0A, 0x4D, 0x80, 0x03, 0x1A, 0x7C, 0x74, 0x48, 0x98, +/* 09E0 */ 0x3D, 0xA3, 0x76, 0x86, 0x70, 0x2A, 0x0A, 0x5B, 0xEC, 0x7B, 0xDC, 0x26, 0x0B, 0x92, 0x10, 0x0C, +/* 09F0 */ 0x39, 0x4E, 0x3B, 0x6F, 0x3B, 0x6F, 0x3B, 0x27, 0x90, 0x07, 0x2E, 0x06, 0x01, 0xFD, 0x29, 0x4A, +/* 0A00 */ 0x65, 0x75, 0x85, 0x05, 0x01, 0x01, 0x05, 0xAD, 0x31, 0xDC, 0x07, 0x32, 0x01, 0x02, 0x21, 0xA4, +/* 0A10 */ 0x6E, 0x2B, 0x5A, 0x54, 0xAB, 0x34, 0xF9, 0x85, 0xA8, 0x2A, 0x75, 0x0C, 0x6B, 0x0A, 0x34, 0x50, +/* 0A20 */ 0x53, 0x7E, 0xD8, 0x74, 0x83, 0x0A, 0x1D, 0x09, 0xF8, 0x01, 0x22, 0xEE, 0x07, 0x65, 0x90, 0x94, +/* 0A30 */ 0x02, 0x2D, 0x5B, 0x3D, 0x01, 0x52, 0x7E, 0x3F, 0x74, 0x3D, 0x7C, 0x0C, 0x58, 0x3B, 0x04, 0x66, +/* 0A40 */ 0x3B, 0x6F, 0x3B, 0x6F, 0x3B, 0x00, 0x1E, 0x05, 0x10, 0x12, 0x44, 0x06, 0x01, 0x19, 0x75, 0x0C, +/* 0A50 */ 0x2E, 0x05, 0x22, 0x7C, 0xAB, 0x4B, 0x50, 0x0F, 0x6D, 0x58, 0x03, 0x26, 0x01, 0x0E, 0x87, 0x24, +/* 0A60 */ 0x0A, 0x0F, 0x03, 0x90, 0x3B, 0xA7, 0x06, 0x1A, 0x8E, 0x26, 0x68, 0x00, 0x90, 0x7E, 0x65, 0x6D, +/* 0A70 */ 0x22, 0xDC, 0x00, 0xDC, 0x03, 0x65, 0x7D, 0x26, 0xAD, 0x99, 0x73, 0x1A, 0xA3, 0x74, 0x01, 0x06, +/* 0A80 */ 0x73, 0x00, 0x60, 0x31, 0x49, 0x6B, 0x9B, 0x07, 0x98, 0x39, 0x51, 0x0A, 0x08, 0x02, 0x02, 0x6A, +/* 0A90 */ 0x83, 0x0A, 0x76, 0x5D, 0xA4, 0x7F, 0x1A, 0x50, 0x0F, 0x0A, 0x00, 0x55, 0x6D, 0x58, 0x03, 0x3D, +/* 0AA0 */ 0x0C, 0x5B, 0x00, 0x0D, 0x87, 0x9A, 0x0F, 0x0A, 0x1F, 0x7C, 0xAB, 0x22, 0x0F, 0x0A, 0x26, 0xAD, +/* 0AB0 */ 0x1A, 0x01, 0x6A, 0x01, 0x22, 0x0F, 0x0A, 0x26, 0xAD, 0x1A, 0x09, 0x70, 0x00, 0x47, 0x87, 0x9A, +/* 0AC0 */ 0x0F, 0x0A, 0x4B, 0x50, 0x3B, 0x32, 0x55, 0x6D, 0x58, 0x03, 0x24, 0x54, 0x03, 0x22, 0x7C, 0x0D, +/* 0AD0 */ 0x2E, 0x05, 0x1A, 0x90, 0x10, 0x10, 0x9F, 0x07, 0xA4, 0x94, 0x02, 0x2C, 0x0A, 0x85, 0x3F, 0x0D, +/* 0AE0 */ 0x71, 0x2F, 0x03, 0x22, 0x0B, 0xAB, 0x65, 0x75, 0x7E, 0x2D, 0x0A, 0x39, 0x99, 0x7E, 0x2D, 0x09, +/* 0AF0 */ 0x21, 0x96, 0x03, 0x00, 0x01, 0xA4, 0x7B, 0x5D, 0x2E, 0x03, 0x0C, 0xAB, 0x39, 0xF9, 0x6C, 0x21, +/* 0B00 */ 0x90, 0x0C, 0x35, 0x01, 0x7C, 0x0A, 0x03, 0x24, 0x90, 0x0D, 0xAB, 0x53, 0x8F, 0xDC, 0x03, 0x4B, +/* 0B10 */ 0x69, 0x73, 0x22, 0x0A, 0x7E, 0x01, 0x01, 0x6A, 0x1A, 0x01, 0x38, 0x26, 0x0A, 0x7E, 0x54, 0x07, +/* 0B20 */ 0x19, 0x50, 0x4D, 0x32, 0xDC, 0xCF, 0x1A, 0x2F, 0x03, 0x32, 0x96, 0x0D, 0x01, 0x19, 0xEE, 0x57, +/* 0B30 */ 0x22, 0xA1, 0x2E, 0x7E, 0x01, 0x19, 0x50, 0x58, 0x6D, 0x52, 0x73, 0x01, 0x52, 0x8F, 0x1F, 0x90, +/* 0B40 */ 0x09, 0xA4, 0x94, 0x04, 0x22, 0x01, 0x5C, 0x10, 0x05, 0x18, 0x09, 0x74, 0x00, 0xE9, 0x74, 0x1E, +/* 0B50 */ 0x70, 0x1E, 0x76, 0x67, 0x7C, 0x76, 0x83, 0x55, 0x03, 0x10, 0x07, 0x1A, 0x33, 0x31, 0x65, 0x0A, +/* 0B60 */ 0x0C, 0xF7, 0xF0, 0x83, 0xA4, 0x37, 0x54, 0x0A, 0x83, 0xA4, 0x37, 0x03, 0x2E, 0x67, 0x77, 0x43, +/* 0B70 */ 0x6E, 0x58, 0x37, 0x72, 0x1F, 0x2F, 0xF7, 0x2F, 0xF7, 0x2F, 0xF7, 0x72, 0x24, 0x58, 0x9E, 0x52, +/* 0B80 */ 0x45, 0xF9, 0x5A, 0x04, 0x7E, 0x6F, 0x0E, 0x5B, 0x83, 0xC7, 0x96, 0x3C, 0x1B, 0x73, 0x6F, 0x3A, +/* 0B90 */ 0xF7, 0x90, 0x01, 0x10, 0x07, 0x1F, 0x33, 0x01, 0x6F, 0x28, 0x6F, 0x0A, 0x70, 0x66, 0x90, 0x93, +/* 0BA0 */ 0xEC, 0xF4, 0x9A, 0x93, 0xF1, 0x04, 0x00, 0xE9, 0x73, 0xF5, 0x83, 0x2F, 0x6F, 0x38, 0x83, 0x4D, +/* 0BB0 */ 0x9E, 0x58, 0x9E, 0x4D, 0x9E, 0x38, 0x41, 0x92, 0x27, 0x99, 0x2E, 0x1E, 0x5E, 0xDC, 0x05, 0x41, +/* 0BC0 */ 0x87, 0xE9, 0xAB, 0x66, 0x01, 0x0E, 0x87, 0xE9, 0x98, 0x66, 0x8E, 0x6F, 0x01, 0x02, 0x10, 0x0A, +/* 0BD0 */ 0xF6, 0x3E, 0x01, 0x2E, 0x6F, 0x3B, 0x2A, 0x75, 0x47, 0x0A, 0x00, 0x01, 0x04, 0x39, 0x90, 0x0F, +/* 0BE0 */ 0xA5, 0xA2, 0x09, 0x85, 0x21, 0x01, 0x06, 0x9C, 0x35, 0x09, 0x06, 0x31, 0xF9, 0x70, 0x27, 0x55, +/* 0BF0 */ 0x07, 0x3A, 0x03, 0x2A, 0x90, 0xB1, 0x95, 0x2E, 0x71, 0x1B, 0x06, 0xA3, 0x04, 0x10, 0x0B, 0x78, +/* 0C00 */ 0xA9, 0x74, 0x1E, 0xCB, 0x06, 0x1E, 0x74, 0x1E, 0x74, 0x10, 0x05, 0x32, 0x44, 0x20, 0x1E, 0x0E, +/* 0C10 */ 0xD4, 0x83, 0x81, 0x83, 0x01, 0x74, 0x10, 0x09, 0x20, 0xFD, 0x79, 0x06, 0x2C, 0x0A, 0x29, 0x08, +/* 0C20 */ 0x10, 0x05, 0x65, 0x9F, 0x20, 0xD3, 0xA5, 0x10, 0x0B, 0x3D, 0x4E, 0x50, 0x01, 0x6F, 0xB1, 0x67, +/* 0C30 */ 0x50, 0x3B, 0x1E, 0x98, 0x66, 0x0A, 0x76, 0x83, 0xB2, 0x67, 0x90, 0x7E, 0x83, 0x54, 0x5A, 0x53, +/* 0C40 */ 0x6E, 0xA4, 0xF7, 0x01, 0x7E, 0x61, 0x1D, 0x53, 0xD0, 0x02, 0x66, 0x01, 0x93, 0x99, 0x5E, 0x4C, +/* 0C50 */ 0x74, 0x2C, 0x69, 0x5B, 0x83, 0x85, 0xD8, 0x0A, 0x1E, 0x98, 0x4B, 0x43, 0x37, 0x90, 0x05, 0x10, +/* 0C60 */ 0x0D, 0x22, 0x18, 0x01, 0x91, 0x62, 0x45, 0x49, 0x2E, 0x2B, 0x98, 0x1A, 0xF9, 0x0A, 0xB6, 0x38, +/* 0C70 */ 0x39, 0x01, 0x38, 0x26, 0x0A, 0xAB, 0x1A, 0x75, 0x2E, 0x00, 0x75, 0x7E, 0x24, 0xAE, 0x3B, 0x00, +/* 0C80 */ 0x50, 0x4D, 0x39, 0x09, 0x73, 0x32, 0x2F, 0x31, 0x0A, 0x73, 0x32, 0x72, 0x0A, 0xAB, 0x32, 0x01, +/* 0C90 */ 0x4D, 0x03, 0x3D, 0x0A, 0x73, 0x32, 0x72, 0x09, 0x73, 0x32, 0x2F, 0x31, 0x07, 0x3B, 0x00, 0x50, +/* 0CA0 */ 0x4D, 0x3D, 0x99, 0x2E, 0x00, 0x7C, 0x7E, 0x39, 0x01, 0x38, 0x26, 0x0A, 0xAB, 0x1A, 0xF9, 0x0A, +/* 0CB0 */ 0xB6, 0x38, 0x21, 0x49, 0x2E, 0x2B, 0x98, 0x2A, 0x01, 0x91, 0x7E, 0x05, 0x10, 0x09, 0x18, 0xA7, +/* 0CC0 */ 0x92, 0x2C, 0x90, 0x52, 0x8C, 0x1F, 0x75, 0x0E, 0x7E, 0x4D, 0x31, 0x50, 0x4D, 0x07, 0x01, 0x4D, +/* 0CD0 */ 0x71, 0xA3, 0x03, 0x00, 0x01, 0xDE, 0xDE, 0xDE, 0xDE, 0xDE, 0xDE, 0x8C, 0x10, 0x0B, 0x18, 0x5D, +/* 0CE0 */ 0x68, 0x6D, 0x03, 0x2C, 0x0A, 0x85, 0x3F, 0x76, 0x21, 0x55, 0x57, 0xEC, 0x0D, 0x3D, 0x7C, 0x01, +/* 0CF0 */ 0x26, 0x72, 0x24, 0x0F, 0x76, 0x83, 0x4D, 0x37, 0x04, 0x85, 0xF7, 0x09, 0x5E, 0x2F, 0x37, 0x0B, +/* 0D00 */ 0x73, 0x26, 0xFD, 0x2E, 0x34, 0x50, 0x85, 0x03, 0x27, 0x49, 0x70, 0x2A, 0x69, 0xAB, 0x66, 0x09, +/* 0D10 */ 0x3B, 0x32, 0x82, 0x3B, 0x79, 0x06, 0x3D, 0x99, 0x80, 0x98, 0x10, 0x0B, 0x18, 0x5D, 0x68, 0x6D, +/* 0D20 */ 0x03, 0x2A, 0x01, 0x0C, 0x85, 0x3F, 0x70, 0x21, 0x49, 0x08, 0x2D, 0x0D, 0x6F, 0x58, 0x9E, 0xA4, +/* 0D30 */ 0x37, 0x01, 0x4D, 0xF7, 0x0A, 0xAB, 0x21, 0x50, 0x0B, 0xB1, 0x07, 0x22, 0xFD, 0x35, 0xF3, 0x26, +/* 0D40 */ 0x90, 0x09, 0x2E, 0x01, 0x83, 0x0C, 0x98, 0xE9, 0x5E, 0x4C, 0x25, 0x22, 0x01, 0x00, 0xEE, 0x07, +/* 0D50 */ 0x1A, 0x7C, 0x4A, 0x2D, 0x5B, 0x1A, 0x50, 0x0E, 0x2E, 0x3F, 0x74, 0x2A, 0x51, 0xA4, 0x94, 0x03, +/* 0D60 */ 0x10, 0x0C, 0x9F, 0x90, 0x22, 0x42, 0x0A, 0x2C, 0xF9, 0xF4, 0x96, 0x3C, 0x5D, 0x3B, 0x2C, 0xEE, +/* 0D70 */ 0x45, 0x50, 0x85, 0x83, 0x09, 0xAB, 0x22, 0x0A, 0x0F, 0x7B, 0x96, 0x02, 0x00, 0xDC, 0x7B, 0x06, +/* 0D80 */ 0x3B, 0x00, 0xF1, 0x7B, 0x0C, 0x70, 0x26, 0xA4, 0x03, 0x39, 0x2F, 0x4F, 0x3A, 0x3B, 0x0A, 0x24, +/* 0D90 */ 0x50, 0x6B, 0x80, 0x66, 0xA4, 0x9E, 0xA4, 0x9E, 0xA4, 0x9E, 0xA4, 0x03, 0x10, 0x0B, 0x18, 0x07, +/* 0DA0 */ 0x80, 0x06, 0x1A, 0xAE, 0x2E, 0x79, 0x7B, 0x07, 0x73, 0x1E, 0x73, 0x1E, 0x73, 0x1E, 0x73, 0x1E, +/* 0DB0 */ 0x73, 0x06, 0x0A, 0x0A, 0x06, 0xFD, 0x29, 0x3B, 0x3D, 0x75, 0x0A, 0x07, 0x02, 0x01, 0x63, 0x98, +/* 0DC0 */ 0xE9, 0x7E, 0x83, 0x40, 0x00, 0x42, 0x92, 0x27, 0x99, 0x85, 0x21, 0x01, 0x26, 0xA3, 0x3B, 0x3D, +/* 0DD0 */ 0x90, 0x0D, 0x09, 0x01, 0x00, 0x99, 0x30, 0x39, 0x01, 0x52, 0x6D, 0x52, 0xAB, 0xFD, 0x68, 0x6D, +/* 0DE0 */ 0x05, 0x10, 0x0C, 0x9F, 0x04, 0x3A, 0x6D, 0x04, 0x39, 0x75, 0x4D, 0x23, 0x25, 0x50, 0x0F, 0x76, +/* 0DF0 */ 0x00, 0x90, 0x34, 0x0A, 0xAB, 0x66, 0x72, 0x19, 0x99, 0x7E, 0x67, 0x2D, 0x0A, 0x02, 0x9C, 0x94, +/* 0E00 */ 0x31, 0xEC, 0x0A, 0x60, 0x3A, 0x2E, 0x01, 0x39, 0x0A, 0x4D, 0x0A, 0x01, 0x00, 0x49, 0x98, 0x3D, +/* 0E10 */ 0x0A, 0x7E, 0x00, 0x7C, 0x7E, 0x39, 0x09, 0xAB, 0x00, 0x50, 0x85, 0x65, 0xA3, 0x73, 0x00, 0x50, +/* 0E20 */ 0x85, 0x1A, 0x75, 0x3B, 0x00, 0x75, 0x2E, 0x39, 0x01, 0xCF, 0x77, 0x1F, 0x0A, 0x73, 0x00, 0x90, +/* 0E30 */ 0x30, 0x21, 0x59, 0x0D, 0x3A, 0x73, 0x2A, 0x90, 0x0A, 0xB1, 0x5C, 0x10, 0x0A, 0x19, 0x44, 0xA7, +/* 0E40 */ 0x80, 0x31, 0xB3, 0x79, 0x2B, 0x92, 0x2C, 0x75, 0x3B, 0x2C, 0x69, 0x74, 0x41, 0x87, 0x26, 0xFD, +/* 0E50 */ 0x1D, 0x0D, 0x76, 0x27, 0x99, 0x2E, 0x83, 0x09, 0xAB, 0x66, 0x96, 0x3C, 0x5D, 0x7E, 0x2C, 0x69, +/* 0E60 */ 0x74, 0x41, 0x87, 0xE9, 0x25, 0x19, 0x47, 0x76, 0x2C, 0x50, 0x6A, 0x6F, 0x95, 0x10, 0x0C, 0x18, +/* 0E70 */ 0x48, 0x3A, 0x62, 0x05, 0x39, 0x2D, 0x7E, 0x52, 0xAB, 0x21, 0x2F, 0x04, 0xB6, 0x38, 0x1A, 0x7C, +/* 0E80 */ 0x3B, 0x69, 0x74, 0x1A, 0x2D, 0x0A, 0xF9, 0x07, 0x3D, 0x99, 0x2E, 0xEE, 0x04, 0x21, 0x0C, 0x73, +/* 0E90 */ 0x01, 0xB3, 0x3B, 0x21, 0x90, 0x0C, 0x85, 0x53, 0x0A, 0x34, 0x01, 0x53, 0xA4, 0x73, 0x71, 0x49, +/* 0EA0 */ 0x70, 0x99, 0x0C, 0x2E, 0x01, 0x39, 0x09, 0xAB, 0x69, 0xF8, 0x58, 0x03, 0x26, 0x99, 0x85, 0x39, +/* 0EB0 */ 0x38, 0x32, 0x2F, 0x39, 0x30, 0x26, 0x99, 0x85, 0x24, 0xF9, 0x8F, 0x90, 0x0C, 0xAB, 0x39, 0x01, +/* 0EC0 */ 0x52, 0x62, 0x68, 0x7E, 0x71, 0xAA, 0x68, 0x62, 0x07, 0x10, 0x0C, 0x18, 0x86, 0x68, 0x94, 0x02, +/* 0ED0 */ 0x2C, 0x0A, 0x85, 0x3F, 0x0E, 0x7B, 0x06, 0x2E, 0x02, 0xEC, 0x0B, 0x21, 0x0C, 0x74, 0x26, 0x72, +/* 0EE0 */ 0x00, 0x4D, 0x03, 0xEE, 0x05, 0x3D, 0x01, 0x38, 0x69, 0x98, 0x3D, 0x4D, 0x03, 0x32, 0x0A, 0xAB, +/* 0EF0 */ 0x3D, 0xDC, 0x07, 0x26, 0x59, 0x07, 0x1A, 0x75, 0x85, 0x05, 0x01, 0x04, 0xA4, 0x74, 0x21, 0x0A, +/* 0F00 */ 0x0F, 0x6B, 0x0A, 0x0D, 0x76, 0x3D, 0x75, 0x09, 0x0A, 0x05, 0x01, 0x8C, 0x65, 0x7C, 0x3B, 0x27, +/* 0F10 */ 0x90, 0x30, 0x67, 0x90, 0x0D, 0x73, 0x67, 0xAA, 0x58, 0x0A, 0x2A, 0xA3, 0x58, 0x4A, 0x27, 0x0A, +/* 0F20 */ 0x5C, 0x01, 0x10, 0x05, 0x6F, 0x78, 0xD3, 0xA5, 0x2A, 0x9F, 0xD3, 0xA5, 0x10, 0x05, 0x6F, 0x78, +/* 0F30 */ 0xD3, 0xA5, 0x24, 0x44, 0x1E, 0x0E, 0xD4, 0x83, 0x81, 0x83, 0x01, 0x74, 0x10, 0x0B, 0x26, 0x78, +/* 0F40 */ 0x99, 0x0B, 0x45, 0xB6, 0x2B, 0xF8, 0x50, 0x2B, 0x3B, 0x04, 0x3D, 0x50, 0x2B, 0x3B, 0x03, 0x67, +/* 0F50 */ 0x0E, 0x3B, 0x37, 0x58, 0x0A, 0x37, 0x03, 0x2B, 0xFA, 0x04, 0x52, 0xAB, 0x66, 0x99, 0x89, 0x10, +/* 0F60 */ 0x0B, 0x64, 0x8D, 0xFD, 0xED, 0x4B, 0xAE, 0xED, 0x10, 0x0B, 0x8D, 0x06, 0x0A, 0x9E, 0x0A, 0x4D, +/* 0F70 */ 0x0A, 0x37, 0x04, 0x52, 0xFA, 0x04, 0x0B, 0x93, 0x03, 0x0B, 0x2E, 0x21, 0x50, 0x2B, 0x3B, 0x7B, +/* 0F80 */ 0x99, 0x2B, 0x3B, 0x7B, 0xEC, 0x3B, 0x7B, 0xAE, 0x0B, 0x04, 0x10, 0x0A, 0x18, 0x99, 0x9C, 0x7E, +/* 0F90 */ 0x07, 0x39, 0x2D, 0x7E, 0x52, 0x73, 0x21, 0x01, 0xAD, 0x02, 0x22, 0x40, 0x7B, 0x01, 0x01, 0x22, +/* 0FA0 */ 0x47, 0x74, 0x83, 0x0E, 0x70, 0x66, 0x09, 0x2E, 0x01, 0x67, 0xAF, 0x85, 0x7B, 0x69, 0x7E, 0x3C, +/* 0FB0 */ 0x04, 0xCF, 0xE9, 0x1D, 0x08, 0xAB, 0x66, 0x90, 0x03, 0x7A, 0x83, 0xD3, 0xA5, 0x10, 0x16, 0x9F, +/* 0FC0 */ 0x50, 0x08, 0x0C, 0x58, 0x62, 0x08, 0x03, 0x3D, 0xA1, 0x0F, 0x85, 0x81, 0x0C, 0x58, 0x73, 0x01, +/* 0FD0 */ 0x1F, 0x90, 0xA4, 0x7F, 0x32, 0x99, 0x52, 0x8F, 0x4B, 0x49, 0x73, 0x1A, 0x09, 0x3B, 0x19, 0x0A, +/* 0FE0 */ 0x73, 0x3D, 0x0C, 0x74, 0x00, 0x50, 0xCF, 0x22, 0x51, 0x0D, 0x2E, 0x09, 0x02, 0x00, 0x99, 0x2E, +/* 0FF0 */ 0x32, 0x0A, 0x98, 0x00, 0x01, 0x0C, 0x2E, 0x3A, 0x7E, 0x26, 0xA4, 0x03, 0x26, 0x0E, 0x5B, 0xA3, +/* 1000 */ 0x0F, 0x0A, 0x22, 0x01, 0x7E, 0x26, 0x09, 0x74, 0xB6, 0x2E, 0x00, 0x47, 0x5B, 0x22, 0x01, 0x7E, +/* 1010 */ 0x2D, 0x08, 0x48, 0x3B, 0x00, 0x90, 0x2E, 0x26, 0x01, 0x7E, 0x2D, 0x09, 0x22, 0x54, 0x0A, 0x22, +/* 1020 */ 0xF0, 0x26, 0x01, 0x7E, 0x2D, 0x08, 0x1B, 0x73, 0x22, 0xF0, 0x26, 0x01, 0x7E, 0xA7, 0x07, 0x1B, +/* 1030 */ 0x3B, 0x00, 0x99, 0x7E, 0x26, 0x01, 0x2E, 0x26, 0x0A, 0x70, 0x00, 0x99, 0x7E, 0x22, 0x01, 0x85, +/* 1040 */ 0x22, 0x90, 0x85, 0x00, 0x47, 0x92, 0x22, 0x01, 0x0F, 0x92, 0xF1, 0x06, 0x22, 0x3F, 0x03, 0x00, +/* 1050 */ 0x54, 0x0A, 0xEE, 0x05, 0x22, 0x40, 0x7D, 0x9B, 0xB1, 0x2B, 0x9B, 0x00, 0x7C, 0x7E, 0x75, 0xA4, +/* 1060 */ 0x9D, 0x9A, 0x0C, 0x6D, 0x02, 0x32, 0x47, 0x98, 0x42, 0x74, 0x61, 0x4D, 0x0A, 0x03, 0x32, 0x90, +/* 1070 */ 0x04, 0x24, 0x50, 0x52, 0x85, 0x28, 0x68, 0x2E, 0x39, 0x99, 0x09, 0x0C, 0x58, 0x62, 0x09, 0x05, +/* 1080 */ 0x10, 0x0D, 0x18, 0x50, 0xE3, 0x67, 0xC6, 0x10, 0x0D, 0xE6, 0x4D, 0x6A, 0xA8, 0x2A, 0xB4, 0x0C, +/* 1090 */ 0x58, 0x74, 0x21, 0x30, 0xA7, 0x5B, 0x39, 0x30, 0x32, 0xA4, 0x07, 0x39, 0x30, 0x69, 0xAB, 0x39, +/* 10A0 */ 0x30, 0x32, 0x0E, 0x70, 0x39, 0x30, 0xA7, 0x0D, 0x21, 0xB4, 0x3F, 0x0B, 0x02, 0x21, 0x0E, 0x29, +/* 10B0 */ 0x94, 0x7B, 0x30, 0x00, 0x90, 0x07, 0x0F, 0x76, 0x39, 0x30, 0x22, 0xA3, 0x2E, 0x39, 0x30, 0x00, +/* 10C0 */ 0x50, 0x38, 0x3D, 0x30, 0x32, 0x2F, 0x03, 0x3D, 0x30, 0x00, 0x75, 0x4D, 0x31, 0x30, 0x50, 0x0D, +/* 10D0 */ 0x3B, 0x39, 0xB4, 0x3F, 0x2E, 0x02, 0x39, 0x58, 0x6B, 0x6D, 0x06, 0x10, 0x0C, 0x9F, 0x02, 0x09, +/* 10E0 */ 0xA4, 0x94, 0x7B, 0xB3, 0x4D, 0xA2, 0x52, 0x70, 0x1A, 0x50, 0x6C, 0x9A, 0x0A, 0x01, 0x39, 0x0C, +/* 10F0 */ 0x73, 0x42, 0x5B, 0x26, 0xFD, 0x7E, 0x83, 0x0A, 0x5E, 0xDC, 0x8A, 0x52, 0x5A, 0x0B, 0x1D, 0x0A, +/* 1100 */ 0x5E, 0xA9, 0x93, 0x9A, 0x38, 0x83, 0x0C, 0x1D, 0x40, 0x07, 0x50, 0x9D, 0x65, 0x75, 0x4D, 0xA2, +/* 1110 */ 0x52, 0x98, 0x21, 0x84, 0xA4, 0x94, 0x04, 0x10, 0x0E, 0xE6, 0x4D, 0x62, 0x08, 0x8B, 0xB4, 0x0C, +/* 1120 */ 0x58, 0x74, 0x21, 0x30, 0x2D, 0x70, 0x39, 0x30, 0xF9, 0x0D, 0x39, 0x30, 0x32, 0x2F, 0x04, 0x3D, +/* 1130 */ 0x30, 0x4B, 0xA4, 0x07, 0x3D, 0x30, 0x4B, 0x0A, 0x25, 0x30, 0x4B, 0x09, 0x3B, 0x3D, 0x30, 0x4B, +/* 1140 */ 0x09, 0x3B, 0x3D, 0x30, 0x4B, 0x09, 0x25, 0x30, 0x00, 0x69, 0x73, 0x3D, 0x30, 0x4B, 0xA4, 0x07, +/* 1150 */ 0x3D, 0x30, 0x32, 0x2F, 0x03, 0x3D, 0x30, 0x32, 0x0A, 0x7E, 0x39, 0x30, 0x22, 0x51, 0x0F, 0x76, +/* 1160 */ 0x39, 0xB4, 0x3A, 0x85, 0x05, 0x21, 0x0E, 0x6B, 0x62, 0x08, 0x01, 0x10, 0x0B, 0xE6, 0x29, 0xDA, +/* 1170 */ 0x10, 0x0B, 0xE6, 0x0F, 0x29, 0x2A, 0xB4, 0x4F, 0x09, 0x2A, 0x30, 0x83, 0x30, 0x1C, 0x1C, 0x83, +/* 1180 */ 0xEB, 0x34, 0xB4, 0x4F, 0x34, 0x30, 0x1C, 0x1C, 0x1C, 0x10, 0x0E, 0x9F, 0x51, 0x0C, 0xB1, 0x5C, +/* 1190 */ 0x21, 0x99, 0x58, 0x6D, 0x3A, 0x7E, 0x31, 0x2F, 0x08, 0x26, 0x51, 0x07, 0x24, 0x69, 0x5E, 0x2F, +/* 11A0 */ 0x8B, 0xAE, 0x2E, 0x83, 0x0A, 0x5E, 0xDC, 0x09, 0x75, 0x0B, 0x4F, 0x05, 0x65, 0x0C, 0xAB, 0x75, +/* 11B0 */ 0x6B, 0x98, 0x4B, 0x69, 0x73, 0x4B, 0xDC, 0x07, 0x65, 0x0A, 0x0F, 0x0A, 0x4B, 0xDC, 0x07, 0x24, +/* 11C0 */ 0xA3, 0x7E, 0x4B, 0xDC, 0x07, 0x1A, 0x99, 0x8C, 0x2B, 0x07, 0x3D, 0x0E, 0x98, 0x69, 0x98, 0x65, +/* 11D0 */ 0x55, 0x70, 0x22, 0x90, 0xA4, 0x07, 0x65, 0xA3, 0x4D, 0xA2, 0x0C, 0x4D, 0x70, 0x39, 0x99, 0x0A, +/* 11E0 */ 0x58, 0x62, 0x07, 0x02, 0x10, 0x0F, 0xE6, 0x04, 0x00, 0x69, 0xAB, 0x3D, 0xC1, 0xC1, 0xC1, 0xB4, +/* 11F0 */ 0x4F, 0x3A, 0xAB, 0x3D, 0x58, 0x80, 0xAB, 0x3D, 0xC1, 0xC1, 0xC1, 0xC1, 0x10, 0x06, 0xE6, 0x04, +/* 1200 */ 0x1C, 0xE4, 0x10, 0x07, 0x00, 0x18, 0xD7, 0x8A, 0xD7, 0x8A, 0xD7, 0x8A, 0x0A, 0xAB, 0x66, 0x01, +/* 1210 */ 0x30, 0x27, 0xAF, 0x93, 0x0C, 0x2E, 0x3C, 0x5D, 0x07, 0x01, 0x10, 0x0D, 0xE6, 0x04, 0x32, 0x55, +/* 1220 */ 0x9B, 0x3D, 0x30, 0x26, 0x59, 0x05, 0x39, 0x30, 0x26, 0x0B, 0x73, 0x21, 0x30, 0x86, 0x2E, 0x71, +/* 1230 */ 0x30, 0x9A, 0x4D, 0x03, 0x2A, 0x30, 0x49, 0x98, 0x2A, 0x30, 0x09, 0x3B, 0x67, 0x0E, 0xAB, 0x0F, +/* 1240 */ 0x9B, 0x67, 0x0E, 0xAB, 0x4D, 0x03, 0x67, 0x30, 0x0A, 0x2E, 0x67, 0x30, 0x96, 0x08, 0x2C, 0x30, +/* 1250 */ 0xB3, 0x4D, 0x03, 0x2A, 0x30, 0x22, 0x0B, 0x7E, 0x2A, 0x30, 0x22, 0x59, 0x07, 0x21, 0x30, 0x7C, +/* 1260 */ 0x38, 0x39, 0x30, 0x69, 0x7E, 0x39, 0x30, 0x32, 0x2F, 0x07, 0x10, 0x0B, 0xE6, 0x04, 0xE4, 0x83, +/* 1270 */ 0x58, 0x6A, 0xAD, 0xAD, 0x7B, 0xEB, 0x5B, 0x10, 0x11, 0x24, 0x44, 0x2D, 0x73, 0x00, 0xF9, 0xAB, +/* 1280 */ 0x1F, 0xA3, 0x35, 0x4B, 0xA4, 0x73, 0x1A, 0x09, 0x85, 0x5B, 0x26, 0x01, 0x0F, 0x58, 0x0A, 0x1A, +/* 1290 */ 0x0A, 0x0F, 0x0A, 0x70, 0x26, 0x55, 0x0A, 0x3B, 0x4B, 0x69, 0x74, 0x73, 0xA7, 0x06, 0x7E, 0x1A, +/* 12A0 */ 0x0C, 0x5B, 0x2E, 0x26, 0x0C, 0x9B, 0x2E, 0x1A, 0x58, 0xAF, 0x92, 0x22, 0x0F, 0x57, 0x85, 0x1A, +/* 12B0 */ 0x4D, 0xA9, 0x70, 0x99, 0x98, 0x4D, 0x24, 0x01, 0x85, 0x9A, 0xAB, 0xA9, 0x0F, 0x03, 0x00, 0x0E, +/* 12C0 */ 0x5B, 0x19, 0x90, 0x85, 0x22, 0x62, 0x00, 0x3A, 0x22, 0xA4, 0x03, 0x32, 0x50, 0x2E, 0x22, 0x0B, +/* 12D0 */ 0x92, 0x6D, 0xF1, 0x04, 0x19, 0x99, 0x7E, 0x86, 0x0F, 0x07, 0x98, 0xDC, 0x05, 0x32, 0x75, 0x3B, +/* 12E0 */ 0xB6, 0x0F, 0x58, 0x03, 0x22, 0x0A, 0x74, 0x1F, 0x54, 0x0A, 0x26, 0x0E, 0x85, 0x00, 0xEC, 0x07, +/* 12F0 */ 0x4B, 0xA3, 0x73, 0x26, 0x0A, 0x3B, 0xA7, 0x08, 0x1F, 0x09, 0xAB, 0x26, 0x01, 0x01, 0x01, 0x2D, +/* 1300 */ 0x0A, 0x1F, 0x0A, 0x98, 0x4B, 0x7C, 0x3B, 0x10, 0x0F, 0xE6, 0x5B, 0x32, 0xBB, 0x09, 0xAB, 0x07, +/* 1310 */ 0xAB, 0x3D, 0xE1, 0x19, 0xB2, 0xA7, 0xAB, 0x10, 0x0F, 0x9F, 0x84, 0xC3, 0xCD, 0x10, 0x0D, 0xE6, +/* 1320 */ 0x4D, 0x6A, 0xA8, 0x2A, 0xB4, 0x68, 0x6C, 0x3D, 0x30, 0x22, 0x51, 0x0F, 0x76, 0x39, 0x30, 0xEE, +/* 1330 */ 0x0A, 0xFE, 0xAE, 0x2E, 0x39, 0x30, 0xF9, 0x0B, 0x39, 0x30, 0x26, 0x49, 0xAB, 0x39, 0x30, 0x00, +/* 1340 */ 0x01, 0x04, 0x0C, 0xCF, 0x39, 0xEB, 0x0D, 0x7B, 0xB4, 0x0A, 0x08, 0x45, 0x30, 0x83, 0x30, 0x1C, +/* 1350 */ 0x1C, 0x10, 0x0F, 0x9F, 0x84, 0xA4, 0x94, 0x04, 0x3D, 0x75, 0x35, 0x3F, 0x98, 0x3D, 0x40, 0x05, +/* 1360 */ 0x75, 0x0E, 0x70, 0x3D, 0x0C, 0xAB, 0x00, 0xAE, 0x85, 0x1F, 0x50, 0x8C, 0x96, 0x05, 0x4B, 0xAE, +/* 1370 */ 0x7E, 0x26, 0x69, 0xAB, 0xA6, 0x7E, 0x1A, 0x0C, 0xAB, 0x26, 0xAE, 0x2E, 0x4B, 0x69, 0x73, 0x4B, +/* 1380 */ 0xA3, 0x2E, 0x1A, 0x0A, 0x0F, 0x0A, 0x1F, 0x09, 0x3B, 0x4B, 0xAE, 0x7E, 0x26, 0x69, 0x73, 0x19, +/* 1390 */ 0x50, 0x8C, 0x00, 0x30, 0x24, 0x47, 0xAB, 0x22, 0x7C, 0x7E, 0x3D, 0x40, 0x05, 0x22, 0x99, 0x0E, +/* 13A0 */ 0x9B, 0x1A, 0x7C, 0x35, 0x3F, 0x0C, 0x8B, 0x03, 0x0A, 0x0D, 0x4D, 0x35, 0x09, 0x02, 0x67, 0x95, +/* 13B0 */ 0x08, 0x58, 0x76, 0x66, 0xAF, 0x8F, 0x83, 0x01, 0x10, 0x0D, 0xE6, 0x0F, 0x35, 0x0A, 0x04, 0x2A, +/* 13C0 */ 0xB4, 0x0B, 0x58, 0x73, 0x21, 0x30, 0x2D, 0x76, 0x39, 0x30, 0xEE, 0x0A, 0x39, 0x30, 0xF9, 0x0C, +/* 13D0 */ 0x39, 0x30, 0xF9, 0x0B, 0x39, 0x30, 0x32, 0x0C, 0xF8, 0x30, 0xA7, 0x0F, 0x03, 0x39, 0xB4, 0x0B, +/* 13E0 */ 0x58, 0x74, 0x21, 0x0E, 0x6B, 0x35, 0x03, 0x2A, 0x30, 0x00, 0x2F, 0x03, 0x2A, 0x30, 0x22, 0x0A, +/* 13F0 */ 0x3B, 0x2A, 0x30, 0x22, 0x2F, 0x7B, 0x30, 0x26, 0x09, 0x3B, 0x21, 0x30, 0x26, 0x2F, 0x04, 0x39, +/* 1400 */ 0x30, 0xF9, 0x0C, 0x39, 0x30, 0x32, 0x2F, 0x05, 0x10, 0x0C, 0x18, 0x86, 0x68, 0x62, 0x07, 0x71, +/* 1410 */ 0xDC, 0x7E, 0x3A, 0x2E, 0x02, 0x24, 0xAE, 0x85, 0x03, 0x22, 0x51, 0x0E, 0x03, 0x39, 0x0C, 0xAB, +/* 1420 */ 0x4B, 0x71, 0xA4, 0xF4, 0xDC, 0x8F, 0x67, 0x99, 0x35, 0x45, 0x7C, 0x6B, 0xA5, 0x02, 0x2C, 0x90, +/* 1430 */ 0x91, 0x4D, 0x4A, 0x27, 0x01, 0x06, 0xA4, 0x76, 0x66, 0x49, 0x3B, 0x1E, 0x85, 0x61, 0x85, 0x3D, +/* 1440 */ 0x90, 0x19, 0x09, 0x7E, 0x65, 0x90, 0x6D, 0x02, 0x26, 0x55, 0x70, 0x3D, 0xAF, 0x35, 0x3F, 0x73, +/* 1450 */ 0x21, 0x99, 0x0A, 0xA4, 0x6D, 0x05, 0x10, 0x0B, 0x4E, 0x4E, 0x43, 0x80, 0x85, 0x1A, 0xA3, 0x4F, +/* 1460 */ 0x0D, 0x85, 0x4F, 0x08, 0x21, 0xA3, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0x25, 0x10, 0x0E, +/* 1470 */ 0x18, 0x03, 0xC0, 0x01, 0x10, 0x0C, 0x1A, 0x44, 0x0A, 0x73, 0x26, 0x75, 0x2E, 0x1F, 0x7C, 0x2E, +/* 1480 */ 0x26, 0x77, 0x26, 0x90, 0x8C, 0x0C, 0x70, 0x1A, 0x47, 0x70, 0x32, 0x01, 0x4D, 0x31, 0x09, 0x73, +/* 1490 */ 0x26, 0x99, 0x7E, 0x1A, 0x75, 0x2E, 0x22, 0xA3, 0xAB, 0x39, 0x01, 0x0F, 0x92, 0x26, 0x0C, 0x76, +/* 14A0 */ 0x21, 0x0C, 0x70, 0x22, 0x01, 0x4D, 0x31, 0xA3, 0x73, 0x22, 0xF0, 0x82, 0x0D, 0xA3, 0x98, 0x2A, +/* 14B0 */ 0xB2, 0x52, 0x03, 0x3D, 0x69, 0x70, 0x01, 0x85, 0x21, 0x7C, 0x73, 0x04, 0x25, 0x32, 0x90, 0x2E, +/* 14C0 */ 0x08, 0x74, 0x27, 0xA4, 0xA4, 0x3C, 0x53, 0x93, 0x55, 0x73, 0x10, 0x12, 0x19, 0x44, 0x7C, 0x7E, +/* 14D0 */ 0x32, 0x55, 0x76, 0x69, 0x70, 0x00, 0x50, 0x85, 0xAE, 0x6C, 0x47, 0x5B, 0x32, 0x01, 0x0F, 0x92, +/* 14E0 */ 0x26, 0x0A, 0x4D, 0x0A, 0x26, 0x01, 0x4D, 0x32, 0x47, 0x76, 0x26, 0x8E, 0xAD, 0x50, 0x7E, 0x19, +/* 14F0 */ 0x0A, 0x74, 0x22, 0x01, 0x73, 0x0A, 0x92, 0x22, 0x54, 0x0A, 0x32, 0xA3, 0xAB, 0xB6, 0x74, 0x08, +/* 1500 */ 0x0F, 0x03, 0xA3, 0x98, 0x22, 0x75, 0x3B, 0x1B, 0x76, 0x05, 0x74, 0x22, 0x0A, 0x70, 0x26, 0x50, +/* 1510 */ 0x2E, 0xEC, 0x01, 0x02, 0x73, 0x47, 0x5B, 0x1F, 0x4D, 0x22, 0x7D, 0x22, 0x6D, 0x22, 0x85, 0x19, +/* 1520 */ 0x47, 0x5B, 0x00, 0x94, 0x22, 0x68, 0x90, 0x7E, 0x24, 0x0A, 0x70, 0x02, 0x98, 0x00, 0x09, 0x5B, +/* 1530 */ 0x05, 0x73, 0x4B, 0x2D, 0x07, 0x05, 0x70, 0x1B, 0x76, 0x07, 0x98, 0x32, 0x75, 0x73, 0x08, 0x5B, +/* 1540 */ 0xB6, 0x0F, 0x07, 0x0A, 0x76, 0x1F, 0x90, 0x7E, 0x9C, 0x26, 0x01, 0x0F, 0x0A, 0x0C, 0x92, 0x1A, +/* 1550 */ 0xB1, 0xA2, 0x32, 0xAD, 0xB1, 0x19, 0xEE, 0xAB, 0x32, 0x0A, 0x0F, 0x3B, 0x65, 0x0A, 0x0F, 0x74, +/* 1560 */ 0x00, 0x2D, 0x73, 0x10, 0x0C, 0x24, 0x44, 0x99, 0x38, 0x00, 0x7C, 0x2E, 0x39, 0x0C, 0xAB, 0x22, +/* 1570 */ 0x47, 0x70, 0x3D, 0x99, 0xCF, 0x48, 0x7E, 0x65, 0xEE, 0x07, 0xF1, 0x05, 0x82, 0x0D, 0x99, 0x7E, +/* 1580 */ 0x67, 0x0C, 0x70, 0x0A, 0x0F, 0x45, 0x99, 0x2E, 0x7E, 0x2A, 0xEE, 0x70, 0x2A, 0xEE, 0x98, 0x2C, +/* 1590 */ 0x99, 0x2E, 0xCF, 0x39, 0x69, 0x70, 0x0B, 0x98, 0x82, 0x0D, 0x99, 0x2E, 0x3D, 0x69, 0x74, 0xF1, +/* 15A0 */ 0x06, 0x65, 0x50, 0xCF, 0x1B, 0x2E, 0x21, 0x0A, 0xAB, 0x22, 0x47, 0x74, 0x24, 0x50, 0x0F, 0x92, +/* 15B0 */ 0xAE, 0x2E, 0x3D, 0x0A, 0x73, 0x4B, 0x96, 0x05, 0x10, 0x0C, 0x1A, 0x44, 0x0A, 0x3B, 0x19, 0x0A, +/* 15C0 */ 0xCC, 0xE8, 0x08, 0x98, 0x2C, 0x01, 0x85, 0xB1, 0xD2, 0x5B, 0x41, 0x5B, 0x41, 0x5B, 0x41, 0x5B, +/* 15D0 */ 0x10, 0x0B, 0x18, 0x0A, 0x80, 0x98, 0x1F, 0xAE, 0x79, 0x2B, 0x98, 0x2A, 0x75, 0x85, 0xF7, 0xA4, +/* 15E0 */ 0xF4, 0x07, 0x93, 0x96, 0x06, 0xE9, 0x7E, 0x41, 0x76, 0x66, 0x09, 0x3B, 0x42, 0x0F, 0x37, 0x0B, +/* 15F0 */ 0x5E, 0x40, 0x8B, 0xEE, 0x09, 0x2C, 0x75, 0x85, 0xF7, 0xA4, 0xF4, 0x05, 0x4D, 0x28, 0x79, 0x04, +/* 1600 */ 0x3D, 0x54, 0x80, 0x76, 0x10, 0x07, 0x1A, 0x33, 0x1E, 0x4F, 0x09, 0x21, 0xF9, 0x35, 0x27, 0x09, +/* 1610 */ 0x74, 0xD5, 0x06, 0xD5, 0x06, 0x83, 0x09, 0x74, 0xD5, 0x81, 0x09, 0x21, 0xF9, 0x35, 0x10, 0x0B, +/* 1620 */ 0x65, 0x4E, 0x9E, 0xDC, 0x37, 0x4C, 0x74, 0xD8, 0x0A, 0x83, 0x01, 0x93, 0xF1, 0x3C, 0xA3, 0x74, +/* 1630 */ 0x61, 0x1D, 0x01, 0x93, 0x47, 0x92, 0x2C, 0xF9, 0x6E, 0x55, 0x5A, 0x02, 0x7E, 0x66, 0x47, 0x92, +/* 1640 */ 0x83, 0x0A, 0x76, 0x83, 0x54, 0x5A, 0x03, 0x3B, 0x6F, 0x58, 0x6F, 0x0A, 0x0F, 0x03, 0x1E, 0x98, +/* 1650 */ 0x42, 0x0B, 0x6F, 0xB1, 0x00, 0x61, 0x03, 0x10, 0x07, 0x24, 0x4E, 0x0A, 0x4F, 0x06, 0x27, 0x0E, +/* 1660 */ 0x6B, 0x5A, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, +/* 1670 */ 0xC7, 0xC7, 0xC7, 0xC7, 0x07, 0xAB, 0x27, 0x0A, 0x3F, 0x08, 0x27, 0x0E, 0x4D, 0xAB, 0x10, 0x0C, +/* 1680 */ 0x24, 0x33, 0x90, 0x08, 0x07, 0x83, 0x0A, 0x4D, 0x45, 0xB6, 0x7E, 0x2E, 0x21, 0x69, 0x76, 0x09, +/* 1690 */ 0x98, 0x82, 0x0C, 0x90, 0x85, 0x34, 0x0C, 0x70, 0xEC, 0x08, 0x65, 0x75, 0x7E, 0x22, 0x90, 0x0F, +/* 16A0 */ 0x9B, 0x39, 0x0C, 0x70, 0xF9, 0x09, 0x10, 0x0B, 0x1F, 0x78, 0x20, 0x7C, 0x0B, 0x4F, 0x79, 0x09, +/* 16B0 */ 0x1A, 0xA3, 0x80, 0x35, 0x10, 0x07, 0x5F, 0x09, 0xF3, 0xD6, 0x83, 0x99, 0x06, 0x10, 0x0C, 0x8D, +/* 16C0 */ 0xB3, 0xB9, 0xE2, 0x10, 0x0D, 0x6F, 0x3E, 0x49, 0x9B, 0x66, 0xBD, 0x01, 0x38, 0x06, 0xA4, 0x89, +/* 16D0 */ 0x01, 0x4D, 0x53, 0x3F, 0x76, 0x39, 0x01, 0x0F, 0x85, 0x03, 0xEC, 0x0D, 0x39, 0x01, 0x0F, 0x76, +/* 16E0 */ 0x26, 0x01, 0x4D, 0x03, 0x3D, 0x01, 0x38, 0x22, 0x47, 0x74, 0x3D, 0x01, 0x38, 0x69, 0xAB, 0x3D, +/* 16F0 */ 0x01, 0x38, 0x69, 0xAB, 0x3D, 0x01, 0x38, 0x69, 0x98, 0x65, 0x01, 0x38, 0x22, 0x47, 0x70, 0x3D, +/* 1700 */ 0x01, 0x38, 0x22, 0x90, 0x38, 0x3D, 0x01, 0x4D, 0x57, 0x22, 0x0A, 0x3B, 0x39, 0x01, 0x4D, 0x68, +/* 1710 */ 0x3F, 0x0E, 0x03, 0x39, 0x01, 0xCF, 0x91, 0x6D, 0x03, 0x10, 0x0A, 0xC9, 0x2C, 0x46, 0x01, 0x10, +/* 1720 */ 0x0D, 0xA0, 0x3E, 0x99, 0x62, 0xD8, 0x0E, 0xD8, 0x0E, 0xD8, 0x0E, 0xD8, 0x0E, 0x3D, 0x50, 0x3A, +/* 1730 */ 0xA5, 0x04, 0x85, 0x21, 0x40, 0xA2, 0x2E, 0x85, 0x3D, 0x47, 0xAB, 0x00, 0x90, 0x0D, 0x85, 0x1A, +/* 1740 */ 0x75, 0x85, 0x26, 0x99, 0x85, 0x39, 0xFB, 0xD9, 0x23, 0x73, 0x85, 0x3D, 0x7C, 0x0D, 0x2E, 0x06, +/* 1750 */ 0x01, 0x85, 0x10, 0x0C, 0x78, 0xCA, 0xB8, 0x02, 0x10, 0x07, 0xF6, 0x3E, 0x04, 0x68, 0x6D, 0x04, +/* 1760 */ 0x00, 0x82, 0x7E, 0x3A, 0x45, 0x0A, 0xAB, 0x2C, 0xEE, 0xD0, 0x05, 0x27, 0x0A, 0x29, 0x92, 0x65, +/* 1770 */ 0xAE, 0x0B, 0xB4, 0x0A, 0x21, 0xEE, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, +/* 1780 */ 0x05, 0x10, 0x0B, 0x97, 0x44, 0x01, 0x02, 0x04, 0x09, 0x0B, 0x39, 0x90, 0x09, 0xA4, 0x29, 0x31, +/* 1790 */ 0x59, 0x0E, 0x3F, 0x0A, 0x03, 0x01, 0x39, 0x0A, 0x0F, 0x57, 0x22, 0x0A, 0x74, 0x21, 0x30, 0x50, +/* 17A0 */ 0x2E, 0x21, 0x4D, 0x03, 0x26, 0x2F, 0x3D, 0x47, 0x74, 0x22, 0x99, 0x85, 0x21, 0x54, 0x36, 0x95, +/* 17B0 */ 0x0C, 0xF8, 0xA3, 0x29, 0x0C, 0x34, 0x0A, 0xAB, 0x0A, 0x09, 0x06, 0x39, 0x50, 0x25, 0x24, 0xF0, +/* 17C0 */ 0x83, 0x96, 0x0C, 0x28, 0x09, 0x06, 0x71, 0x99, 0x68, 0x4D, 0x35, 0x3C, 0x9A, 0x0C, 0x25, 0x04, +/* 17D0 */ 0x09, 0x04, 0x22, 0x75, 0x2E, 0x24, 0x7C, 0x3B, 0x4B, 0x0A, 0x25, 0x49, 0x85, 0x28, 0x0C, 0x58, +/* 17E0 */ 0x9B, 0x39, 0x51, 0x0C, 0x58, 0x62, 0x08, 0x01, 0x10, 0x0D, 0x6F, 0x3E, 0x49, 0x9B, 0x66, 0xBD, +/* 17F0 */ 0x01, 0x38, 0x05, 0x0C, 0x2E, 0x05, 0x21, 0x01, 0x0F, 0xAB, 0x0F, 0x23, 0x4D, 0x03, 0x39, 0x01, +/* 1800 */ 0x4D, 0x70, 0x22, 0x0A, 0xF8, 0x01, 0x0F, 0x74, 0x7C, 0x3B, 0xE7, 0x01, 0xDD, 0x7E, 0xE7, 0x01, +/* 1810 */ 0xDD, 0x7E, 0xE7, 0x01, 0xDD, 0x7E, 0x10, 0x06, 0x5F, 0xA1, 0x0B, 0xF7, 0x55, 0x74, 0x27, 0x90, +/* 1820 */ 0xAD, 0x7A, 0x33, 0xBD, 0xBD, 0xBD, 0x72, 0x10, 0x06, 0x5F, 0xA1, 0x0B, 0xF7, 0x55, 0x74, 0x27, +/* 1830 */ 0x90, 0xAD, 0x7A, 0x33, 0xBD, 0xBD, 0xBD, 0x01, 0x4D, 0xF7, 0x2F, 0x1E, 0x7E, 0x2C, 0x75, 0x0E, +/* 1840 */ 0x70, 0x27, 0x2F, 0x06, 0x1E, 0x02, 0x10, 0x0B, 0x5F, 0x9A, 0x05, 0xF7, 0x72, 0x1F, 0xBD, 0x01, +/* 1850 */ 0x38, 0x26, 0x0C, 0x74, 0x39, 0x01, 0x38, 0xEC, 0x0A, 0x21, 0x01, 0x38, 0xB3, 0x2E, 0x71, 0x01, +/* 1860 */ 0x38, 0x96, 0x03, 0x2A, 0x01, 0x38, 0x2B, 0x07, 0x2C, 0x01, 0x0F, 0xAB, 0x3B, 0x67, 0x01, 0x0F, +/* 1870 */ 0xAB, 0x2E, 0x01, 0x2C, 0x01, 0x38, 0x0C, 0xAB, 0x2C, 0x01, 0x38, 0x2F, 0x03, 0x2A, 0x01, 0x38, +/* 1880 */ 0xA9, 0x2E, 0x2A, 0x01, 0x38, 0xF1, 0x08, 0x21, 0x01, 0x38, 0xB6, 0x4D, 0x03, 0x39, 0x01, 0x38, +/* 1890 */ 0xA7, 0x0C, 0x10, 0x06, 0x5F, 0x90, 0x04, 0x83, 0xDF, 0xDF, 0xDF, 0x2F, 0x01, 0x83, 0x0E, 0x7E, +/* 18A0 */ 0xF4, 0x04, 0xA4, 0x0A, 0x10, 0x12, 0x8D, 0x01, 0x2E, 0xB3, 0x0D, 0x94, 0x01, 0x9A, 0x3A, 0x36, +/* 18B0 */ 0x1F, 0x01, 0x0F, 0x4A, 0x7E, 0x58, 0x0A, 0x03, 0x0E, 0x7D, 0xCF, 0x19, 0x01, 0x0F, 0x85, 0x03, +/* 18C0 */ 0x00, 0x2F, 0xB0, 0xF1, 0x06, 0x19, 0x01, 0x0F, 0x74, 0x26, 0xA4, 0x0A, 0x26, 0x09, 0x73, 0x19, +/* 18D0 */ 0x01, 0x4D, 0xE0, 0x4D, 0xE0, 0x4D, 0xE0, 0x4D, 0xE0, 0x0F, 0x92, 0x26, 0x0C, 0x70, 0x77, 0x10, +/* 18E0 */ 0x0D, 0x8D, 0xBA, 0x02, 0x75, 0x7E, 0xE7, 0x01, 0xDD, 0x7E, 0xE7, 0x01, 0xDD, 0x7E, 0xE7, 0x10, +/* 18F0 */ 0x0D, 0x78, 0x46, 0xD1, 0x10, 0x0D, 0x8D, 0x01, 0x2E, 0xA9, 0xA4, 0x89, 0x01, 0x85, 0x53, 0x3F, +/* 1900 */ 0x70, 0xB7, 0x72, 0x1F, 0xAF, 0xF3, 0x10, 0x0D, 0x78, 0x04, 0x0B, 0x6A, 0x08, 0x01, 0x85, 0x21, +/* 1910 */ 0x40, 0xA2, 0x3B, 0x85, 0x3D, 0x47, 0xAB, 0x00, 0x90, 0x0D, 0x85, 0x1A, 0x75, 0x85, 0x00, 0x75, +/* 1920 */ 0x85, 0x39, 0xFB, 0xD9, 0x81, 0x3B, 0x85, 0x3D, 0x7C, 0x0D, 0x2E, 0x06, 0x04, 0x85, 0xD8, 0x0E, +/* 1930 */ 0xD8, 0x0E, 0xD8, 0x0E, 0xD8, 0x0E, 0x66, 0x90, 0x09, 0x0A, 0x10, 0x08, 0x8D, 0x01, 0x2E, 0xA9, +/* 1940 */ 0xA4, 0x8B, 0x01, 0x85, 0x07, 0x0F, 0x23, 0x2C, 0x01, 0x4D, 0x88, 0x67, 0x01, 0x0F, 0x5E, 0x01, +/* 1950 */ 0x0F, 0x70, 0x66, 0xBD, 0xBD, 0x10, 0x0A, 0x00, 0x8D, 0x46, 0x71, 0x99, 0x35, 0x3A, 0x2E, 0x2A, +/* 1960 */ 0x0C, 0xAB, 0x7C, 0x06, 0x2A, 0x30, 0x19, 0x43, 0x0A, 0xF7, 0x03, 0x0E, 0x85, 0xA8, 0x27, 0x51, +/* 1970 */ 0x58, 0x3B, 0x3C, 0x99, 0x0C, 0x2E, 0xF7, 0x96, 0x6E, 0x0D, 0x74, 0x21, 0x09, 0x05, 0x26, 0x40, +/* 1980 */ 0x03, 0x1A, 0x50, 0x58, 0x6D, 0x52, 0x73, 0x2A, 0x51, 0xA4, 0x6D, 0x05, 0x10, 0x08, 0x00, 0x18, +/* 1990 */ 0x90, 0x01, 0x83, 0xFF, 0x7B, 0x69, 0x29, 0x0E, 0x21, 0xA3, 0x0B, 0x4D, 0x81, 0x09, 0x27, 0x58, +/* 19A0 */ 0x9E, 0x58, 0x9E, 0xFF, 0x9E, 0xFF, 0x9E, 0x0C, 0x74, 0x67, 0x2D, 0x3B, 0x0D, 0x08, 0x2C, 0xA3, +/* 19B0 */ 0x60, 0x89, 0x10, 0x0D, 0x8D, 0xAC, 0xC4, 0xBF, 0x04, 0x73, 0x10, 0x0B, 0x26, 0x97, 0x9F, 0xBE, +/* 19C0 */ 0x5B, 0x75, 0x3B, 0x43, 0x06, 0x00, 0xEC, 0x07, 0x65, 0x2D, 0x0A, 0x00, 0x47, 0x5B, 0x39, 0x90, +/* 19D0 */ 0x85, 0x00, 0x90, 0x2E, 0x2C, 0xA4, 0x03, 0x5D, 0x73, 0x21, 0xA3, 0x98, 0x0A, 0x76, 0x2C, 0xF0, +/* 19E0 */ 0x00, 0xB2, 0x2C, 0xB1, 0x03, 0x3B, 0x27, 0x0A, 0x0F, 0x0A, 0x74, 0x2A, 0x75, 0x6B, 0x3C, 0x01, +/* 19F0 */ 0x35, 0x10, 0x10, 0x97, 0x9F, 0x2D, 0x0A, 0x75, 0x4D, 0x03, 0x00, 0x47, 0x5B, 0x4B, 0x99, 0x2E, +/* 1A00 */ 0xA7, 0x74, 0x22, 0x01, 0x85, 0x1F, 0x01, 0x0F, 0x92, 0x22, 0x3F, 0x08, 0xB6, 0x3B, 0x24, 0xA4, +/* 1A10 */ 0x03, 0x22, 0x0E, 0x09, 0xA2, 0x1B, 0xAB, 0x24, 0x0A, 0x74, 0x90, 0x74, 0x9C, 0xEC, 0x05, 0x32, +/* 1A20 */ 0xAE, 0xAB, 0xB3, 0x76, 0x07, 0x5B, 0xDC, 0x02, 0x4B, 0x50, 0x3B, 0x4C, 0x92, 0x04, 0x70, 0x00, +/* 1A30 */ 0xB1, 0x1A, 0x01, 0x2E, 0x00, 0x0A, 0x0D, 0x90, 0xAB, 0x01, 0x7E, 0x19, 0xEE, 0x49, 0x0A, 0x22, +/* 1A40 */ 0x94, 0x04, 0x73, 0x19, 0xF9, 0x55, 0x07, 0x22, 0x0B, 0xB0, 0x74, 0x65, 0x54, 0x0A, 0x76, 0xA3, +/* 1A50 */ 0x0F, 0x0A, 0x0F, 0x03, 0x1F, 0x50, 0x0F, 0x38, 0x22, 0x55, 0x85, 0x39, 0x0F, 0x85, 0x26, 0x2F, +/* 1A60 */ 0x0C, 0x10, 0x0B, 0x97, 0x9F, 0x50, 0x38, 0x26, 0x09, 0x73, 0x21, 0x0A, 0x73, 0x00, 0x90, 0x0F, +/* 1A70 */ 0x9B, 0x21, 0x59, 0x02, 0x00, 0x09, 0xAB, 0x21, 0xA3, 0x73, 0x01, 0xCF, 0x2C, 0x01, 0x0E, 0x94, +/* 1A80 */ 0x74, 0x27, 0x54, 0x7E, 0x42, 0x7E, 0x2A, 0x69, 0x7E, 0x70, 0x67, 0x55, 0x0A, 0x04, 0x2E, 0x2A, +/* 1A90 */ 0x47, 0x5B, 0xDC, 0x07, 0x3D, 0x2D, 0x0A, 0xB6, 0xCF, 0x39, 0x96, 0x02, 0x26, 0x0B, 0xF8, 0x53, +/* 1AA0 */ 0x0A, 0x00, 0x50, 0x38, 0x10, 0x0B, 0x26, 0x97, 0x9F, 0xBE, 0x92, 0xC2, 0x5C, 0x10, 0x09, 0x8D, +/* 1AB0 */ 0x80, 0x0C, 0x2A, 0x79, 0x0D, 0x3B, 0x66, 0x01, 0x30, 0x66, 0x0A, 0x73, 0x27, 0x99, 0xCF, 0x67, +/* 1AC0 */ 0x47, 0x74, 0x26, 0xFD, 0x7E, 0x66, 0x59, 0x37, 0x0B, 0x73, 0x2C, 0x75, 0xCF, 0x27, 0x49, 0x70, +/* 1AD0 */ 0x26, 0xFD, 0x4D, 0x79, 0x09, 0x65, 0xA7, 0x29, 0x3B, 0x10, 0x07, 0x4B, 0x33, 0x50, 0x08, 0x0A, +/* 1AE0 */ 0x42, 0x4D, 0x2A, 0xF9, 0xF3, 0xEE, 0x9E, 0x52, 0x3C, 0xF1, 0x3C, 0xF1, 0x3C, 0xF1, 0x3C, 0xF1, +/* 1AF0 */ 0x3C, 0xF1, 0x02, 0x66, 0x96, 0x01, 0x67, 0x99, 0xA4, 0xF4, 0x55, 0x9D, 0xD8, 0x0E, 0x6F, 0xA4, +/* 1B00 */ 0x3C, 0xF1, 0x9E, 0x52, 0x9E, 0x52, 0x9E, 0x52, 0x9E, 0x52, 0x9E, 0x52, 0x9E, 0x0A, 0x74, 0x83, +/* 1B10 */ 0x55, 0x3B, 0x1E, 0xA4, 0x10, 0x09, 0x27, 0x33, 0x43, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, +/* 1B20 */ 0xE5, 0xE5, 0xE5, 0x04, 0x2C, 0x69, 0x76, 0x10, 0x07, 0x19, 0x33, 0x0A, 0x08, 0x9E, 0x6B, 0x37, +/* 1B30 */ 0x01, 0x09, 0x5E, 0x9A, 0x7E, 0xF2, 0x2E, 0x83, 0x01, 0x0F, 0x92, 0x1E, 0x85, 0x04, 0x2C, 0x50, +/* 1B40 */ 0x0C, 0x74, 0x66, 0x30, 0x41, 0x0D, 0xF2, 0x7E, 0x61, 0x3B, 0x4B, 0x43, 0x74, 0x66, 0x0E, 0xB0, +/* 1B50 */ 0x10, 0x0B, 0x2C, 0x20, 0x01, 0x9C, 0x5C, 0x86, 0x04, 0x43, 0x0B, 0x58, 0x8E, 0x74, 0x3D, 0xA3, +/* 1B60 */ 0x04, 0x00, 0x51, 0xB1, 0x07, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x27, 0x00, 0x6C, 0x00, 0xA0, +/* 1B70 */ 0x00, 0xE8, 0x01, 0x3D, 0x01, 0x4F, 0x01, 0xA2, 0x01, 0xA9, 0x02, 0x21, 0x02, 0x61, 0x02, 0xA4, +/* 1B80 */ 0x02, 0xBA, 0x02, 0xC4, 0x03, 0x2C, 0x03, 0x37, 0x03, 0x5A, 0x03, 0x70, 0x03, 0x99, 0x03, 0xC4, +/* 1B90 */ 0x03, 0xD4, 0x04, 0x01, 0x04, 0x52, 0x04, 0x58, 0x04, 0x6E, 0x04, 0x8D, 0x04, 0xCC, 0x05, 0x0D, +/* 1BA0 */ 0x05, 0x34, 0x05, 0x85, 0x05, 0xDE, 0x06, 0x19, 0x06, 0x2F, 0x06, 0x43, 0x06, 0x61, 0x06, 0x6F, +/* 1BB0 */ 0x06, 0x89, 0x06, 0xAA, 0x07, 0x0A, 0x07, 0x5C, 0x07, 0x6D, 0x07, 0x7F, 0x07, 0x98, 0x07, 0xAF, +/* 1BC0 */ 0x07, 0xC6, 0x07, 0xDB, 0x07, 0xF5, 0x08, 0x0A, 0x08, 0x70, 0x08, 0x93, 0x08, 0xA6, 0x08, 0xBB, +/* 1BD0 */ 0x08, 0xD3, 0x08, 0xEA, 0x09, 0x03, 0x09, 0x30, 0x09, 0xBE, 0x09, 0xD2, 0x09, 0xE7, 0x0A, 0x02, +/* 1BE0 */ 0x0A, 0x1A, 0x0A, 0x40, 0x0A, 0x70, 0x0A, 0xD9, 0x0A, 0xEC, 0x0B, 0x00, 0x0B, 0x18, 0x0B, 0x2F, +/* 1BF0 */ 0x0B, 0x45, 0x0B, 0x63, 0x0B, 0xCC, 0x0B, 0xEB, 0x0B, 0xFE, 0x0C, 0x14, 0x0C, 0x2D, 0x0C, 0x45, +/* 1C00 */ 0x0C, 0x59, 0x0C, 0x6F, 0x0C, 0x8B, 0x0C, 0xA5, 0x0D, 0x0B, 0x0D, 0x2D, 0x0D, 0x3F, 0x0D, 0x53, +/* 1C10 */ 0x0D, 0x6C, 0x0D, 0x78, 0x0D, 0x82, 0x0D, 0x9A, 0x0E, 0x06, 0x0E, 0x17, 0x0E, 0x2F, 0x0E, 0x4C, +/* 1C20 */ 0x0E, 0x63, 0x0E, 0x77, 0x0E, 0x90, 0x06, 0x00, 0x10, 0x06, 0x00, 0x78, 0x61, 0x6D, 0x2C, 0x69, +/* 1C30 */ 0x4D, 0x37, 0x05, 0x6D, 0x26, 0x97, 0x90, 0x5E, 0x90, 0x5E, 0x9A, 0x3B, 0x67, 0x50, 0x3B, 0x83, +/* 1C40 */ 0xF0, 0xD8, 0x0C, 0xD8, 0x0C, 0xF5, 0x61, 0x2E, 0x61, 0x93, 0x5D, 0x2E, 0x10, 0x0A, 0x18, 0xF9, +/* 1C50 */ 0x01, 0x83, 0x09, 0x92, 0x2C, 0xF9, 0xF7, 0x04, 0x52, 0x07, 0x02, 0x2C, 0xAF, 0x29, 0x07, 0x2A, +/* 1C60 */ 0x0A, 0x0F, 0x9D, 0x9A, 0x0B, 0x7B, 0x03, 0x38, 0xE9, 0x3B, 0x19, 0x43, 0x5A, 0x52, 0x07, 0x2C, +/* 1C70 */ 0xEE, 0xF4, 0xDC, 0x5A, 0x09, 0x3B, 0xD8, 0x5B, 0x2C, 0xEE, 0x9D, 0x95, 0x0B, 0x7B, 0x90, 0xA4, +/* 1C80 */ 0x6B, 0xAB, 0x2C, 0x01, 0x06, 0x0D, 0x73, 0x04, 0x66, 0x0A, 0x92, 0x83, 0x0A, 0x92, 0x83, 0x0A, +/* 1C90 */ 0x92, 0x10, 0x0B, 0x18, 0x75, 0x52, 0x94, 0x8B, 0x5D, 0x4D, 0x23, 0x85, 0x03, 0x2A, 0x0E, 0x70, +/* 1CA0 */ 0x00, 0x99, 0x0D, 0x7B, 0x03, 0x85, 0xF5, 0xF5, 0xF5, 0xE9, 0x52, 0x6D, 0x4F, 0x02, 0x1A, 0x69, +/* 1CB0 */ 0x80, 0x7B, 0xB3, 0x7E, 0xF5, 0xF5, 0xF5, 0x1E, 0x5E, 0x01, 0x60, 0x03, 0x27, 0x96, 0xA2, 0x79, +/* 1CC0 */ 0x03, 0x65, 0x90, 0x80, 0x38, 0x10, 0x0C, 0x22, 0x4E, 0x9F, 0xAF, 0x05, 0x4B, 0x99, 0x8F, 0x1A, +/* 1CD0 */ 0x49, 0x70, 0x9C, 0x94, 0x05, 0x6A, 0x02, 0x3D, 0x59, 0x7E, 0x52, 0x85, 0x7B, 0x0B, 0x76, 0xB6, +/* 1CE0 */ 0x2E, 0x39, 0x90, 0x3B, 0xF9, 0x04, 0x3D, 0x99, 0xAB, 0xAE, 0x74, 0x3D, 0x99, 0xAB, 0xAE, 0x74, +/* 1CF0 */ 0x3D, 0x90, 0x3B, 0xF9, 0x04, 0x43, 0x04, 0xB6, 0x2E, 0x21, 0x59, 0x7E, 0x52, 0x85, 0x03, 0x3D, +/* 1D00 */ 0x49, 0x74, 0x9C, 0x6D, 0x63, 0x9B, 0x65, 0xAF, 0x05, 0x4B, 0x99, 0x0C, 0x02, 0x10, 0x0C, 0x1A, +/* 1D10 */ 0x44, 0x0A, 0x73, 0x19, 0x30, 0x1F, 0x50, 0xCF, 0x00, 0x75, 0x7E, 0x24, 0x69, 0x74, 0xEE, 0x05, +/* 1D20 */ 0x1A, 0x75, 0x2E, 0x50, 0x2E, 0x39, 0x47, 0x76, 0xEC, 0x07, 0x2A, 0x54, 0x0A, 0x00, 0x01, 0x0E, +/* 1D30 */ 0x87, 0x2C, 0x0E, 0x5B, 0x07, 0xAB, 0x00, 0xFD, 0xAB, 0xA4, 0x34, 0x90, 0x03, 0x6B, 0x0A, 0x02, +/* 1D40 */ 0x31, 0xB6, 0x80, 0x0C, 0x21, 0x01, 0x04, 0x04, 0x08, 0x85, 0x04, 0x04, 0x04, 0x2C, 0x99, 0x2E, +/* 1D50 */ 0x2C, 0x90, 0x28, 0x0C, 0x4D, 0x28, 0x09, 0x65, 0x50, 0x80, 0x0C, 0x2C, 0x99, 0x93, 0x99, 0x93, +/* 1D60 */ 0x99, 0x2E, 0x10, 0x09, 0x27, 0x33, 0x43, 0xE5, 0xE5, 0xE5, 0xE5, 0x04, 0x22, 0x3E, 0x43, 0xE5, +/* 1D70 */ 0xE5, 0xE5, 0xE5, 0x04, 0x10, 0x0C, 0x18, 0xB6, 0x3A, 0x7E, 0x07, 0x01, 0x82, 0x7E, 0x3A, 0xF8, +/* 1D80 */ 0xF1, 0x07, 0x75, 0x8B, 0x58, 0x37, 0xDC, 0x5A, 0x03, 0x58, 0x89, 0x00, 0x7C, 0x3B, 0x4D, 0x4A, +/* 1D90 */ 0x21, 0x90, 0x7E, 0x00, 0xAA, 0x0E, 0xAB, 0x1A, 0xAE, 0xAB, 0x26, 0x2F, 0x65, 0x7C, 0x3B, 0x22, +/* 1DA0 */ 0x47, 0x92, 0x39, 0x96, 0x0B, 0x04, 0x90, 0x7E, 0x21, 0x90, 0x0B, 0x35, 0x68, 0x7B, 0x50, 0x91, +/* 1DB0 */ 0x7E, 0x83, 0x49, 0x74, 0x67, 0x77, 0x4B, 0x75, 0x02, 0x00, 0xF1, 0x07, 0x21, 0x2F, 0x0C, 0x3A, +/* 1DC0 */ 0x2E, 0x71, 0x99, 0x9C, 0x2E, 0x08, 0x01, 0x10, 0x08, 0x5F, 0x0A, 0x0A, 0xCE, 0x4A, 0x10, 0x12, +/* 1DD0 */ 0xA0, 0x5F, 0x02, 0x09, 0x60, 0x6D, 0x05, 0x3D, 0x7C, 0xA5, 0x03, 0x01, 0x01, 0x05, 0x23, 0x02, +/* 1DE0 */ 0x3D, 0x63, 0x03, 0x19, 0x09, 0x0D, 0x01, 0x24, 0x90, 0x88, 0x02, 0x9C, 0xB0, 0x22, 0x0C, 0x08, +/* 1DF0 */ 0x4B, 0xAE, 0x0D, 0x22, 0xA4, 0x23, 0x87, 0xB3, 0x0E, 0x1A, 0x0C, 0x08, 0xB3, 0xAB, 0x22, 0x01, +/* 1E00 */ 0x22, 0x01, 0x76, 0x24, 0x4A, 0x4C, 0x5B, 0x19, 0x4A, 0x24, 0x74, 0x00, 0x0A, 0x92, 0x32, 0x47, +/* 1E10 */ 0x08, 0x24, 0x0E, 0x07, 0x4C, 0x5B, 0x19, 0x74, 0x24, 0x81, 0xB3, 0xAB, 0x00, 0x90, 0xB6, 0x76, +/* 1E20 */ 0x32, 0xAE, 0x5B, 0x00, 0x0D, 0x7E, 0x52, 0x03, 0x00, 0x91, 0x24, 0x90, 0x62, 0x01, 0x02, 0x2B, +/* 1E30 */ 0xB0, 0xB3, 0xAB, 0x65, 0x54, 0x9D, 0x26, 0xAA, 0x2E, 0x31, 0x06, 0x4D, 0xA2, 0x68, 0x7E, 0x02, +/* 1E40 */ 0x39, 0x90, 0x09, 0x60, 0x6D, 0x06, 0x10, 0x0B, 0x18, 0x5D, 0x3A, 0x6A, 0x06, 0x67, 0x0A, 0x7E, +/* 1E50 */ 0xA4, 0x70, 0x2A, 0x90, 0x01, 0x86, 0x25, 0x24, 0xF0, 0x39, 0x50, 0x0A, 0x0D, 0x4D, 0x3B, 0x3D, +/* 1E60 */ 0x50, 0x0F, 0x85, 0x23, 0x3B, 0x3D, 0xA7, 0x0A, 0x22, 0xF0, 0x39, 0xA3, 0x73, 0xA3, 0x7E, 0x2A, +/* 1E70 */ 0x40, 0x68, 0x6A, 0x76, 0x3D, 0x7C, 0xA4, 0x9D, 0x03, 0x8F, 0x64, 0x5F, 0x7C, 0x0C, 0x23, 0x23, +/* 1E80 */ 0x23, 0x08, 0x3D, 0xA3, 0x80, 0x0A, 0x10, 0x0D, 0x78, 0x90, 0x07, 0x26, 0x51, 0x34, 0x52, 0x03, +/* 1E90 */ 0x22, 0x0A, 0x70, 0x3D, 0xA3, 0x73, 0x1B, 0x3B, 0x39, 0x99, 0xCF, 0x00, 0x59, 0x03, 0x39, 0x96, +/* 1EA0 */ 0x06, 0xF1, 0x09, 0x21, 0x09, 0x7E, 0x86, 0x85, 0x71, 0x0A, 0x0F, 0x0A, 0x86, 0x2E, 0x82, 0x76, +/* 1EB0 */ 0x00, 0x59, 0x07, 0x65, 0xAE, 0x2E, 0x48, 0xCF, 0x00, 0x43, 0x07, 0xEC, 0x09, 0x21, 0x90, 0x0E, +/* 1EC0 */ 0x87, 0xF1, 0x7B, 0x99, 0x0B, 0x02, 0x00, 0x90, 0x9D, 0x10, 0x0B, 0x20, 0xFD, 0x28, 0x79, 0x08, +/* 1ED0 */ 0x43, 0x29, 0x3B, 0x66, 0x90, 0x3B, 0x66, 0x90, 0x3B, 0x66, 0x90, 0x3B, 0x83, 0xAA, 0x05, 0x10, +/* 1EE0 */ 0x09, 0x20, 0xFD, 0x79, 0x06, 0x2C, 0x0A, 0x29, 0x08, 0x10, 0x0E, 0x6F, 0x3E, 0x7C, 0x68, 0x6D, +/* 1EF0 */ 0x04, 0x2A, 0xAF, 0x7F, 0x01, 0x01, 0x05, 0x0D, 0x08, 0x21, 0x09, 0x0C, 0x02, 0x35, 0x06, 0x49, +/* 1F00 */ 0x06, 0x65, 0x90, 0x5B, 0x01, 0x92, 0x04, 0x92, 0x05, 0x0D, 0x24, 0x7C, 0x0C, 0x00, 0x01, 0x0F, +/* 1F10 */ 0x95, 0x5B, 0x01, 0x0F, 0x03, 0x24, 0xA3, 0x0A, 0x00, 0x01, 0x0F, 0xB1, 0x07, 0x47, 0x05, 0x24, +/* 1F20 */ 0xA3, 0x0A, 0x00, 0x01, 0x76, 0x0E, 0x03, 0x47, 0x05, 0x19, 0xAE, 0x0C, 0x00, 0x01, 0x92, 0x09, +/* 1F30 */ 0x0A, 0x22, 0x0F, 0x03, 0x1A, 0x90, 0x5B, 0x01, 0x0F, 0x95, 0x0F, 0x03, 0x05, 0x0D, 0x39, 0x09, +/* 1F40 */ 0x0B, 0x4B, 0x49, 0x06, 0x39, 0xAF, 0x7F, 0x01, 0x01, 0x05, 0x0D, 0x09, 0x39, 0x7C, 0x68, 0x6D, +/* 1F50 */ 0x05, 0x10, 0x07, 0x66, 0x3E, 0x90, 0x79, 0x06, 0x39, 0x50, 0x29, 0x09, 0x10, 0x0B, 0x00, 0x18, +/* 1F60 */ 0xAA, 0x0A, 0xA8, 0x67, 0x01, 0x0C, 0x6B, 0x70, 0xFD, 0xAB, 0x95, 0xB1, 0x2C, 0x3A, 0xA7, 0x8B, +/* 1F70 */ 0x3A, 0x2D, 0x03, 0x2A, 0x09, 0x76, 0xF1, 0x34, 0x59, 0x3F, 0x08, 0x21, 0x50, 0x3A, 0xB0, 0x10, +/* 1F80 */ 0x0B, 0x4E, 0x44, 0x1E, 0x74, 0x1E, 0xCB, 0x06, 0x1E, 0x74, 0x1E, 0x74, 0x97, 0xA9, 0x28, 0x79, +/* 1F90 */ 0x07, 0x21, 0x0A, 0x80, 0x09, 0x10, 0x09, 0x00, 0x5F, 0x84, 0x0A, 0x06, 0x26, 0x82, 0x6B, 0x0A, +/* 1FA0 */ 0x00, 0xFD, 0x0B, 0x02, 0x02, 0x0C, 0x5B, 0x67, 0xA7, 0x9E, 0x9C, 0xF7, 0x03, 0xAB, 0x66, 0x01, +/* 1FB0 */ 0x8E, 0x2C, 0x69, 0x0D, 0xF7, 0x9C, 0x8B, 0xAE, 0x2E, 0x4F, 0x45, 0x08, 0x29, 0x05, 0x10, 0x09, +/* 1FC0 */ 0x00, 0x5F, 0x84, 0x0A, 0x07, 0x2A, 0x75, 0x6B, 0x3B, 0x67, 0x84, 0x02, 0xAF, 0x5B, 0x67, 0x2D, +/* 1FD0 */ 0x37, 0x02, 0x68, 0xE9, 0x2E, 0x37, 0x07, 0x0C, 0x2E, 0xF7, 0x5D, 0x98, 0x66, 0x55, 0x07, 0x2C, +/* 1FE0 */ 0x09, 0xB0, 0x07, 0xA4, 0x8B, 0x90, 0x9C, 0x6D, 0x04, 0x10, 0x07, 0x3E, 0x02, 0x0B, 0x07, 0x2C, +/* 1FF0 */ 0x2D, 0x3B, 0x67, 0x49, 0x3B, 0x04, 0x26, 0xFD, 0x03, 0x10, 0x0D, 0x8D, 0xC5, 0x02, 0x77, 0x19, +/* 2000 */ 0xC5, 0x02, 0x00, 0xF1, 0x0A, 0x39, 0x01, 0x6C, 0x53, 0x3B, 0x39, 0x01, 0x6B, 0x7D, 0x4A, 0x2E, +/* 2010 */ 0x39, 0x01, 0x7E, 0x2B, 0x9D, 0x00, 0x6A, 0x31, 0x01, 0x85, 0x83, 0x01, 0x4D, 0x83, 0x01, 0x4D, +/* 2020 */ 0x83, 0x01, 0x4D, 0x83, 0xAF, 0x0A, 0x10, 0x10, 0x22, 0x18, 0xAA, 0x68, 0x29, 0x92, 0x65, 0x01, +/* 2030 */ 0x52, 0x6B, 0x6D, 0x3A, 0x92, 0x19, 0xF9, 0x6B, 0x3B, 0x47, 0x92, 0x65, 0x58, 0x6B, 0x3B, 0x47, +/* 2040 */ 0x92, 0x1A, 0x01, 0x29, 0x3B, 0x47, 0x92, 0x1A, 0x01, 0x29, 0x3B, 0x47, 0x92, 0x65, 0xA4, 0x6B, +/* 2050 */ 0x3B, 0x47, 0x92, 0x1F, 0x2D, 0x6B, 0x3B, 0x22, 0xA4, 0x31, 0x0A, 0x6B, 0x3B, 0x22, 0xA4, 0x31, +/* 2060 */ 0x99, 0x08, 0x0B, 0x3B, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0x22, +/* 2070 */ 0xA4, 0x71, 0x90, 0x09, 0x05, 0xA3, 0x07, 0x10, 0x05, 0x2C, 0x20, 0xD3, 0xA5, 0x10, 0x06, 0x5F, +/* 2080 */ 0x44, 0x20, 0x4A, 0x6F, 0x98, 0x66, 0x49, 0x7E, 0x01, 0x61, 0x98, 0x39, 0x69, 0x3A, 0x70, 0x67, +/* 2090 */ 0x01, 0x9C, 0xA5, 0x10, 0x09, 0x83, 0x3E, 0x7C, 0xB1, 0x27, 0xA1, 0x0F, 0x85, 0x2A, 0x75, 0x0E, +/* 20A0 */ 0x05, 0x3A, 0x66, 0x01, 0x00, 0x3A, 0x6F, 0x3A, 0x6F, 0x3A, 0x6F, 0x3A, 0x6F, 0x3A, 0x6F, 0x3A, +/* 20B0 */ 0x6F, 0x3A, 0x10, 0x0B, 0x00, 0x18, 0x51, 0x0D, 0x2E, 0x08, 0x39, 0x69, 0x85, 0x52, 0x25, 0x75, +/* 20C0 */ 0x2E, 0x01, 0x00, 0x59, 0x7B, 0x09, 0x98, 0xEC, 0x07, 0x43, 0x05, 0x2D, 0x09, 0x43, 0x05, 0x2D, +/* 20D0 */ 0x09, 0x21, 0x0A, 0x98, 0xEC, 0x07, 0x65, 0x75, 0x2E, 0x01, 0x00, 0x59, 0x03, 0x2A, 0x0C, 0x85, +/* 20E0 */ 0x52, 0x73, 0x2C, 0x01, 0x09, 0xA4, 0xB0, 0x44, 0x4C, 0x0C, 0x23, 0x23, 0x23, 0x07, 0x43, 0x29, +/* 20F0 */ 0x73, 0x10, 0x0D, 0x8D, 0x51, 0x26, 0x51, 0x71, 0xA9, 0xAB, 0x48, 0x25, 0x22, 0x47, 0x76, 0x22, +/* 2100 */ 0x0B, 0x74, 0x82, 0x87, 0x9A, 0x85, 0x8B, 0x0A, 0x3B, 0xEC, 0x0C, 0x2A, 0x59, 0x05, 0x00, 0x96, +/* 2110 */ 0x07, 0x21, 0x49, 0x74, 0xF1, 0x07, 0x3D, 0xA3, 0x2E, 0x01, 0xA9, 0x0F, 0x9B, 0x39, 0x2F, 0x03, +/* 2120 */ 0x00, 0x96, 0x05, 0x43, 0x07, 0xEC, 0x09, 0x65, 0x75, 0x3B, 0xB6, 0x7E, 0x21, 0x99, 0x8F, 0x9A, +/* 2130 */ 0x0C, 0x02, 0x10, 0x14, 0x44, 0xDB, 0xA7, 0x02, 0x21, 0x3A, 0x26, 0x01, 0x94, 0x26, 0x0B, 0x05, +/* 2140 */ 0x1A, 0x3A, 0x2D, 0x03, 0x1B, 0x70, 0x1A, 0x3A, 0x26, 0xA2, 0x26, 0x7D, 0x3D, 0x7C, 0x76, 0x00, +/* 2150 */ 0x99, 0x74, 0x2A, 0x8E, 0x26, 0x3A, 0xFC, 0x0B, 0xEA, 0x10, 0x14, 0x44, 0xDB, 0xA7, 0x02, 0xB3, +/* 2160 */ 0x0A, 0x09, 0x04, 0x24, 0x3A, 0x26, 0x01, 0x94, 0x00, 0x09, 0x6B, 0x70, 0x1F, 0x3A, 0x2D, 0x03, +/* 2170 */ 0xAF, 0x07, 0x01, 0x04, 0x7E, 0x1F, 0x3A, 0x26, 0xA2, 0x19, 0xAD, 0x24, 0x7C, 0x76, 0x4B, 0x01, +/* 2180 */ 0x25, 0x8E, 0x26, 0xA7, 0x03, 0x1A, 0x99, 0x70, 0x32, 0x99, 0x98, 0x19, 0x69, 0x0D, 0x22, 0x50, +/* 2190 */ 0x0E, 0x09, 0x24, 0x50, 0x98, 0x22, 0x90, 0x94, 0x39, 0x0A, 0x87, 0x32, 0xA4, 0x4F, 0x57, 0x19, +/* 21A0 */ 0x90, 0xAB, 0x4B, 0x0E, 0x29, 0x32, 0xF9, 0xF7, 0x5D, 0x07, 0x10, 0x14, 0x44, 0x05, 0x57, 0x32, +/* 21B0 */ 0xAE, 0x60, 0x9D, 0x19, 0x7D, 0x4B, 0x2D, 0x81, 0xCF, 0x26, 0x99, 0x74, 0x24, 0x95, 0xA3, 0x0F, +/* 21C0 */ 0x03, 0x32, 0x3A, 0x39, 0xAF, 0x87, 0x50, 0x98, 0x24, 0xA3, 0x2E, 0x03, 0x32, 0x9C, 0x31, 0x07, +/* 21D0 */ 0x52, 0x8F, 0x90, 0xAB, 0x2A, 0x54, 0x07, 0xA3, 0x5B, 0x82, 0x08, 0x00, 0x01, 0x94, 0x26, 0x0B, +/* 21E0 */ 0x05, 0x22, 0xAE, 0xA8, 0x03, 0x0B, 0x76, 0xA9, 0x0F, 0x03, 0x1B, 0x70, 0x4B, 0x99, 0x58, 0x6C, +/* 21F0 */ 0xA2, 0x26, 0x7D, 0x19, 0x50, 0x03, 0x01, 0x1B, 0x76, 0x00, 0x99, 0x74, 0x2A, 0x8E, 0x26, 0x3A, +/* 2200 */ 0xFC, 0x0B, 0xEA, 0x10, 0x0A, 0x32, 0x78, 0x1E, 0x94, 0x83, 0xA4, 0x92, 0x26, 0xFD, 0x94, 0x26, +/* 2210 */ 0x4E, 0x01, 0x02, 0xF7, 0x5D, 0x5E, 0xA9, 0x73, 0x66, 0x49, 0x74, 0x67, 0x90, 0x0C, 0x7E, 0x67, +/* 2220 */ 0x90, 0xA4, 0x57, 0x27, 0x0C, 0x5E, 0x03, 0x4D, 0xF7, 0x40, 0x32, 0x01, 0x02, 0x21, 0x01, 0x0F, +/* 2230 */ 0x74, 0x00, 0x90, 0x0C, 0x9B, 0x3D, 0xA3, 0x35, 0xA4, 0xF8, 0x7C, 0x68, 0x6D, 0x05, 0x10, 0x0D, +/* 2240 */ 0x24, 0x1E, 0x37, 0x9A, 0x4D, 0xF3, 0x00, 0x75, 0x2B, 0x4A, 0x66, 0x90, 0x09, 0x06, 0x1F, 0x64, +/* 2250 */ 0x50, 0xE3, 0x67, 0xC6, 0x10, 0x0D, 0x3D, 0x1E, 0x37, 0x05, 0xA4, 0x0A, 0x67, 0x01, 0x2B, 0xA5, +/* 2260 */ 0x3C, 0x0A, 0x6E, 0x6F, 0x50, 0xE3, 0x67, 0xC6, 0x10, 0x0D, 0x00, 0xA0, 0x01, 0x52, 0x07, 0x67, +/* 2270 */ 0x90, 0x0D, 0x2E, 0xAB, 0x2C, 0x01, 0x0E, 0x36, 0x00, 0x09, 0xAB, 0x39, 0x7C, 0x01, 0x22, 0x99, +/* 2280 */ 0x7B, 0xF6, 0x50, 0xE3, 0x67, 0xC6, 0x10, 0x0D, 0xA0, 0xC8, 0x02, 0x7F, 0x02, 0x9C, 0x57, 0x4E, +/* 2290 */ 0x03, 0xE3, 0x67, 0xC6, 0x10, 0x0D, 0xA0, 0x09, 0x57, 0x9A, 0x5C, 0x2A, 0x01, 0x0F, 0x70, 0x00, +/* 22A0 */ 0x09, 0x7E, 0x3D, 0x69, 0x0D, 0x02, 0x99, 0x0E, 0xF4, 0x33, 0xB6, 0xE3, 0x67, 0xC6, 0x10, 0x0D, +/* 22B0 */ 0x32, 0x99, 0x0D, 0x94, 0x01, 0x27, 0xA5, 0x01, 0x0C, 0x09, 0x2C, 0x90, 0x76, 0x00, 0x09, 0x0C, +/* 22C0 */ 0x27, 0xA5, 0x01, 0x0C, 0x09, 0x67, 0x99, 0x0D, 0x94, 0x34, 0xF6, 0x50, 0xE3, 0x67, 0xC6, 0x10, +/* 22D0 */ 0x12, 0x00, 0x18, 0xA7, 0x80, 0x73, 0x1A, 0x47, 0x4D, 0x3B, 0x79, 0x05, 0x1F, 0x50, 0x0F, 0x9C, +/* 22E0 */ 0x92, 0x67, 0x09, 0x74, 0x0B, 0x76, 0x67, 0x58, 0x51, 0x74, 0x2C, 0xF0, 0xB3, 0x73, 0x3D, 0xF9, +/* 22F0 */ 0x07, 0x90, 0x7E, 0x2C, 0x0E, 0x5B, 0x22, 0x58, 0x82, 0x0C, 0x26, 0x0C, 0x29, 0xAB, 0x24, 0x0A, +/* 2300 */ 0xAB, 0x00, 0xEC, 0xA2, 0x4F, 0x05, 0x24, 0x58, 0x03, 0x7C, 0xF8, 0x05, 0x80, 0x7E, 0x39, 0x0A, +/* 2310 */ 0x7E, 0x79, 0x8C, 0x4B, 0x96, 0x03, 0x4B, 0x0C, 0x76, 0x1F, 0x75, 0x2E, 0x22, 0xF9, 0x07, 0x19, +/* 2320 */ 0x69, 0xAB, 0x26, 0x2D, 0xA2, 0x4F, 0x07, 0x32, 0x01, 0x0F, 0x76, 0x4B, 0x99, 0x29, 0x73, 0x10, +/* 2330 */ 0x0C, 0x9F, 0x02, 0x09, 0xA4, 0x94, 0x7B, 0xB3, 0x35, 0x3F, 0x74, 0x1A, 0x50, 0x6C, 0x99, 0x57, +/* 2340 */ 0x39, 0x0C, 0xAB, 0x42, 0x92, 0x26, 0xFD, 0x7E, 0x83, 0x0A, 0x5E, 0xDC, 0x8A, 0x52, 0x5A, 0x0B, +/* 2350 */ 0x1D, 0x0A, 0x5E, 0xA9, 0x93, 0x9A, 0x4D, 0x9E, 0x0C, 0x3B, 0x4B, 0x71, 0x40, 0x0B, 0x03, 0x90, +/* 2360 */ 0x07, 0x74, 0x21, 0x55, 0x29, 0x88, 0x39, 0x90, 0x09, 0x0D, 0x7E, 0x08, 0x3C, 0x55, 0xF7, 0x5D, +/* 2370 */ 0x2E, 0x6E, 0x02, 0x0C, 0x92, 0x67, 0x90, 0xAF, 0x5B, 0x21, 0x75, 0x4D, 0x7E, 0x27, 0x51, 0x0A, +/* 2380 */ 0x08, 0x31, 0x0B, 0x1A, 0xE9, 0x02, 0xD8, 0xAB, 0xF7, 0x06, 0x0C, 0x85, 0x6E, 0x84, 0x45, 0xF6, +/* 2390 */ 0xEB, 0xDA, 0x10, 0x0B, 0x64, 0x51, 0xF7, 0x63, 0x73, 0x2C, 0x90, 0x52, 0xB0, 0x01, 0x67, 0xA1, +/* 23A0 */ 0x05, 0x33, 0xEB, 0xDA, 0x10, 0x0B, 0xA0, 0x90, 0x0D, 0x74, 0x2A, 0x50, 0x58, 0xA4, 0x07, 0x2A, +/* 23B0 */ 0x90, 0x6A, 0x03, 0xA1, 0x98, 0x3D, 0x7C, 0x01, 0x75, 0x8B, 0xF6, 0xEB, 0xDA, 0x10, 0x0B, 0xA0, +/* 23C0 */ 0x0A, 0x0A, 0x48, 0x7F, 0x3D, 0x50, 0x4D, 0x03, 0xDC, 0x0A, 0x2A, 0x01, 0x23, 0x01, 0x5D, 0x4A, +/* 23D0 */ 0x66, 0x33, 0xEB, 0xDA, 0x10, 0x06, 0x19, 0xE9, 0x02, 0x83, 0x55, 0xAB, 0x01, 0x27, 0x01, 0x06, +/* 23E0 */ 0x0C, 0x85, 0x04, 0x67, 0x50, 0x0A, 0x04, 0x33, 0x30, 0x1C, 0xE4, 0x10, 0x06, 0xA0, 0x51, 0xF7, +/* 23F0 */ 0x63, 0xAB, 0x21, 0x50, 0x52, 0xB0, 0x01, 0x2C, 0x90, 0x0A, 0x04, 0x26, 0x33, 0x30, 0x1C, 0xE4, +/* 2400 */ 0x10, 0x06, 0x00, 0xF6, 0x90, 0xA4, 0x45, 0xB6, 0x0E, 0x85, 0x74, 0x39, 0x50, 0x0E, 0x9D, 0xA1, +/* 2410 */ 0x74, 0x39, 0x7C, 0x00, 0x7C, 0x3C, 0xF6, 0x30, 0x1C, 0xE4, 0x10, 0x06, 0xF6, 0xA1, 0x09, 0x48, +/* 2420 */ 0x7F, 0x82, 0x5B, 0x00, 0x52, 0x0A, 0x2A, 0x01, 0x8E, 0x86, 0x88, 0x4E, 0x30, 0x1C, 0xE4, 0x10, +/* 2430 */ 0x0E, 0x18, 0xDC, 0x4D, 0x6A, 0x09, 0x04, 0x00, 0x43, 0xA2, 0x3F, 0x25, 0x22, 0x0B, 0xAB, 0x75, +/* 2440 */ 0x0E, 0xAB, 0x24, 0x69, 0xAB, 0x00, 0x75, 0x38, 0x1F, 0x69, 0xAB, 0x26, 0x47, 0xAB, 0x1F, 0x69, +/* 2450 */ 0xAB, 0x4B, 0x09, 0x3B, 0x1F, 0x69, 0xAB, 0x22, 0x7C, 0x85, 0x19, 0x75, 0x3A, 0x2E, 0x28, 0x08, +/* 2460 */ 0x48, 0x4D, 0x1F, 0xA3, 0x29, 0x3B, 0x48, 0x4D, 0x1F, 0x69, 0xAB, 0x22, 0x75, 0x85, 0x1F, 0x69, +/* 2470 */ 0xAB, 0x00, 0xAE, 0x2E, 0x1F, 0x69, 0xAB, 0x4B, 0x09, 0x3B, 0x1F, 0x69, 0xAB, 0x4B, 0xA4, 0x07, +/* 2480 */ 0x1F, 0x69, 0xAB, 0x00, 0x7C, 0x38, 0x1F, 0x69, 0xAB, 0x7C, 0x6C, 0x19, 0x69, 0x2E, 0x28, 0x58, +/* 2490 */ 0xAB, 0x43, 0x4D, 0x6A, 0xA8, 0x10, 0x0F, 0x00, 0xA0, 0x51, 0xA8, 0x99, 0x06, 0x2C, 0x0A, 0x4D, +/* 24A0 */ 0x7E, 0x6D, 0x3D, 0x69, 0x06, 0x02, 0x09, 0x62, 0x3C, 0x33, 0x0E, 0x38, 0x32, 0xBB, 0x09, 0xAB, +/* 24B0 */ 0x07, 0xAB, 0x3D, 0xE1, 0x19, 0xB2, 0xA7, 0xAB, 0x10, 0x0F, 0x1A, 0x61, 0x05, 0x6F, 0x0E, 0x3B, +/* 24C0 */ 0x37, 0x03, 0x0A, 0x0F, 0x1D, 0xAA, 0x8A, 0x83, 0x84, 0xC3, 0xCD, 0x10, 0x0F, 0x39, 0x61, 0x45, +/* 24D0 */ 0x50, 0x0C, 0x2E, 0x27, 0x09, 0x4D, 0x0A, 0x03, 0x27, 0x09, 0x07, 0x01, 0x33, 0x84, 0xC3, 0xCD, +/* 24E0 */ 0x10, 0x0F, 0x64, 0x0A, 0x25, 0x19, 0xAF, 0x2E, 0x3B, 0x31, 0x69, 0x4A, 0x5D, 0x62, 0x39, 0x75, +/* 24F0 */ 0x02, 0x22, 0x90, 0x45, 0xF6, 0x84, 0xC3, 0xCD, 0x10, 0x0F, 0x1A, 0x1E, 0x0A, 0x04, 0x9A, 0x07, +/* 2500 */ 0x21, 0xA3, 0x4D, 0x7E, 0x62, 0x2C, 0x0A, 0x07, 0x51, 0x62, 0x9E, 0x33, 0x84, 0xC3, 0xCD, 0x10, +/* 2510 */ 0x0F, 0xA0, 0x5D, 0x9D, 0x00, 0xAF, 0x08, 0x21, 0x47, 0xAB, 0x5D, 0x8C, 0x1F, 0xA3, 0x0E, 0x04, +/* 2520 */ 0x90, 0x0D, 0x0A, 0x83, 0x33, 0x84, 0xC3, 0xCD, 0x10, 0x0B, 0x22, 0x78, 0x61, 0x01, 0x22, 0x90, +/* 2530 */ 0x04, 0x2A, 0xF0, 0x22, 0x01, 0x52, 0x8B, 0x0A, 0x73, 0xDC, 0x08, 0x2C, 0x01, 0x52, 0x52, 0x0A, +/* 2540 */ 0x27, 0x01, 0x35, 0xE9, 0x4D, 0x98, 0xFD, 0x7E, 0x02, 0x0D, 0x70, 0x82, 0x0D, 0x02, 0x9A, 0xB1, +/* 2550 */ 0x8B, 0xA8, 0x22, 0x99, 0x08, 0x10, 0x0F, 0x27, 0x33, 0x61, 0x09, 0x02, 0x83, 0x0A, 0x0F, 0x9E, +/* 2560 */ 0xB1, 0x2C, 0x84, 0x0D, 0x85, 0x3B, 0x3D, 0x75, 0x4D, 0xA2, 0x58, 0xAB, 0x39, 0x40, 0x05, 0xA3, +/* 2570 */ 0xA4, 0x74, 0x1F, 0xEE, 0x07, 0x26, 0x0C, 0x08, 0x07, 0xCF, 0x19, 0x50, 0x0F, 0x92, 0x22, 0x01, +/* 2580 */ 0x76, 0x96, 0x05, 0x4B, 0xAE, 0x3B, 0x75, 0x0E, 0x22, 0x0B, 0x73, 0x1A, 0x0A, 0x73, 0x26, 0x09, +/* 2590 */ 0x0B, 0xA3, 0x3B, 0x4B, 0x69, 0xAB, 0x26, 0xB0, 0x86, 0x2E, 0x1A, 0x0C, 0x98, 0x90, 0x0F, 0x03, +/* 25A0 */ 0x86, 0x2E, 0x4B, 0x69, 0xAB, 0x22, 0x63, 0x2D, 0x0C, 0x1A, 0x0A, 0x73, 0x22, 0x0A, 0x0A, 0xA7, +/* 25B0 */ 0x0B, 0x1F, 0xA3, 0x3B, 0x47, 0x06, 0x26, 0x0B, 0x73, 0x19, 0x50, 0xCF, 0x02, 0x5B, 0x26, 0x0E, +/* 25C0 */ 0x70, 0x24, 0x47, 0x74, 0x06, 0x0D, 0x7C, 0x85, 0x3D, 0x55, 0x62, 0x09, 0x00, 0x99, 0x0E, 0x74, +/* 25D0 */ 0x65, 0xA3, 0x35, 0x3F, 0xAB, 0x2A, 0x0A, 0x0F, 0x58, 0x94, 0x04, 0x2C, 0x60, 0x67, 0x50, 0x3B, +/* 25E0 */ 0x83, 0xAA, 0x05, 0x10, 0x0E, 0x22, 0xA0, 0x09, 0x3C, 0x1B, 0x85, 0xF4, 0xAA, 0x0D, 0x2E, 0x37, +/* 25F0 */ 0x99, 0x0A, 0x7B, 0x83, 0x50, 0xC0, 0x01, 0x10, 0x0E, 0x64, 0x90, 0x09, 0x1E, 0x0E, 0x74, 0x21, +/* 2600 */ 0x50, 0xA4, 0xB0, 0x71, 0x50, 0x0A, 0x04, 0x19, 0x64, 0x50, 0xC0, 0x01, 0x10, 0x0E, 0xA0, 0xB6, +/* 2610 */ 0xB1, 0x04, 0x67, 0x99, 0xB1, 0x58, 0x45, 0x04, 0x7E, 0x02, 0x02, 0x0B, 0x70, 0x2A, 0x01, 0x06, +/* 2620 */ 0x00, 0x7C, 0x31, 0x6F, 0x50, 0xC0, 0x01, 0x10, 0x0E, 0xA0, 0xAF, 0x09, 0x1B, 0x9D, 0x2A, 0x55, +/* 2630 */ 0x92, 0x00, 0x0D, 0x73, 0x21, 0x90, 0xA2, 0xA3, 0x0E, 0x04, 0x21, 0x33, 0x50, 0xC0, 0x01, 0x10, +/* 2640 */ 0x0C, 0x64, 0x02, 0x08, 0x66, 0x51, 0x4D, 0x45, 0x99, 0xA4, 0x5C, 0x01, 0x2C, 0x99, 0xA8, 0x1A, +/* 2650 */ 0x64, 0x0A, 0x3B, 0x19, 0x0A, 0xCC, 0xE8, 0x08, 0x98, 0x2C, 0x01, 0x85, 0xB1, 0xD2, 0x5B, 0x41, +/* 2660 */ 0x5B, 0x41, 0x5B, 0x41, 0x5B, 0x10, 0x0D, 0xE6, 0x04, 0x1C, 0x83, 0xB4, 0x0A, 0x08, 0x45, 0xEB, +/* 2670 */ 0x36, 0x21, 0x30, 0x00, 0x01, 0x04, 0x52, 0x9B, 0x39, 0x30, 0x22, 0x47, 0xAB, 0xFE, 0xAE, 0x2E, +/* 2680 */ 0xFE, 0x69, 0xF8, 0x30, 0x22, 0x51, 0x4D, 0x03, 0x39, 0xB4, 0x0C, 0x58, 0x74, 0x21, 0x0E, 0x4D, +/* 2690 */ 0x35, 0xA8, 0x2A, 0x30, 0x1C, 0x10, 0x0D, 0xF6, 0x3E, 0x02, 0x91, 0x2E, 0x08, 0x71, 0x90, 0x0D, +/* 26A0 */ 0x85, 0x3A, 0x3B, 0x2A, 0x09, 0x3B, 0x22, 0x96, 0x7B, 0x30, 0x26, 0x0B, 0x70, 0x39, 0x01, 0x38, +/* 26B0 */ 0x00, 0x47, 0x5B, 0x39, 0x01, 0x38, 0xEC, 0x07, 0x21, 0x01, 0x38, 0x5D, 0x73, 0x2A, 0x01, 0x38, +/* 26C0 */ 0x00, 0xA4, 0x8B, 0x01, 0x38, 0x00, 0x0C, 0x74, 0x2A, 0x01, 0x38, 0x99, 0x6C, 0x3D, 0x01, 0x38, +/* 26D0 */ 0x00, 0x99, 0x0E, 0xF8, 0x01, 0x38, 0x50, 0x0E, 0x74, 0x3D, 0x01, 0x38, 0xAE, 0x2E, 0x3D, 0x01, +/* 26E0 */ 0x38, 0x32, 0x2F, 0x01, 0x65, 0x01, 0x38, 0x00, 0x50, 0x4D, 0x3D, 0x01, 0x38, 0xF9, 0x0C, 0x3D, +/* 26F0 */ 0x01, 0x38, 0x00, 0x09, 0x0B, 0x52, 0x76, 0x3D, 0x01, 0x38, 0x00, 0x68, 0x6D, 0x04, 0x10, 0x0C, +/* 2700 */ 0x5F, 0xB6, 0x36, 0x1E, 0x4D, 0x0A, 0xF7, 0x84, 0x85, 0x37, 0x90, 0x08, 0x01, 0x33, 0x61, 0xB9, +/* 2710 */ 0xE2, 0x10, 0x0C, 0x22, 0x3E, 0xA1, 0x09, 0x66, 0x63, 0x2E, 0x01, 0x39, 0x69, 0x7E, 0x45, 0x7C, +/* 2720 */ 0x04, 0x4E, 0x75, 0xB9, 0xE2, 0x10, 0x0C, 0x5F, 0x2D, 0x8F, 0x2A, 0xA3, 0x2E, 0x7E, 0x71, 0xA3, +/* 2730 */ 0x73, 0xB3, 0x6A, 0x71, 0x99, 0x05, 0x22, 0x90, 0x08, 0x33, 0x61, 0xB9, 0xE2, 0x10, 0x0C, 0x5F, +/* 2740 */ 0x1B, 0x0A, 0x05, 0x00, 0xAA, 0x31, 0x7C, 0x6B, 0x7D, 0x87, 0x39, 0xA3, 0x09, 0xAA, 0x0E, 0x36, +/* 2750 */ 0x97, 0x05, 0xB9, 0xE2, 0x10, 0x0C, 0x5F, 0xB3, 0x7F, 0x00, 0xAF, 0x09, 0x3D, 0xEE, 0x0A, 0xB3, +/* 2760 */ 0x38, 0x65, 0xAE, 0x88, 0x01, 0x8E, 0x97, 0x05, 0xB9, 0xE2, 0x10, 0x0C, 0x65, 0x4E, 0x01, 0x9C, +/* 2770 */ 0x36, 0x27, 0x09, 0x0C, 0xAA, 0x0E, 0x27, 0x0C, 0x09, 0x9A, 0x5B, 0x67, 0x09, 0x0C, 0xAA, 0x0E, +/* 2780 */ 0x27, 0x01, 0x9C, 0x36, 0x4E, 0x05, 0xB9, 0xE2, 0x10, 0x12, 0x8D, 0xB3, 0x0A, 0x60, 0x94, 0x02, +/* 2790 */ 0x99, 0x68, 0x94, 0x02, 0x24, 0xB4, 0x0D, 0x2E, 0x06, 0x85, 0x3F, 0x9B, 0x32, 0x50, 0x01, 0x26, +/* 27A0 */ 0x0A, 0x35, 0x02, 0xA3, 0x3B, 0x39, 0x55, 0x70, 0x32, 0x0E, 0x5B, 0x65, 0x99, 0x38, 0xEE, 0x04, +/* 27B0 */ 0x19, 0x51, 0x60, 0x6B, 0x3B, 0x4F, 0x3A, 0x74, 0x4B, 0x59, 0x0F, 0x81, 0x52, 0x80, 0x74, 0x00, +/* 27C0 */ 0x69, 0x7E, 0x02, 0xB6, 0x8C, 0x1F, 0x0F, 0x70, 0x26, 0x01, 0x4D, 0x03, 0x39, 0x0F, 0x76, 0x26, +/* 27D0 */ 0x2F, 0x08, 0x65, 0x47, 0x73, 0x00, 0x90, 0x60, 0x85, 0x04, 0x00, 0x86, 0x04, 0x26, 0x75, 0x35, +/* 27E0 */ 0x2B, 0x9B, 0x09, 0x4D, 0x81, 0x58, 0x0A, 0x32, 0x75, 0x0C, 0x85, 0x09, 0x01, 0x1B, 0x0C, 0xB1, +/* 27F0 */ 0x5C, 0x10, 0x0A, 0xC9, 0x39, 0x50, 0x3A, 0x85, 0xF3, 0x26, 0x0A, 0x0B, 0x6F, 0x3A, 0x09, 0xF7, +/* 2800 */ 0x01, 0x55, 0x0A, 0x27, 0x01, 0x01, 0x02, 0x62, 0x27, 0x0A, 0x6B, 0x07, 0x27, 0x84, 0x0A, 0x06, +/* 2810 */ 0x10, 0x0C, 0x24, 0x97, 0x69, 0x08, 0xF7, 0x59, 0x36, 0x66, 0xAA, 0xA4, 0x5A, 0xB3, 0x04, 0x4E, +/* 2820 */ 0xCA, 0xB8, 0x02, 0x10, 0x0C, 0x3E, 0x7C, 0x0D, 0x01, 0x67, 0x90, 0x2B, 0x70, 0x67, 0x55, 0xA5, +/* 2830 */ 0x3C, 0x02, 0x07, 0x01, 0x26, 0x4E, 0xCA, 0xB8, 0x02, 0x10, 0x0C, 0x5F, 0x50, 0x58, 0x45, 0xB6, +/* 2840 */ 0xB1, 0x58, 0x45, 0x03, 0x6A, 0x03, 0xAF, 0x70, 0x2A, 0x51, 0x01, 0x00, 0xA3, 0x7A, 0x2C, 0xCA, +/* 2850 */ 0xB8, 0x02, 0x10, 0x0C, 0x00, 0x5F, 0xAF, 0x08, 0x1B, 0x9D, 0x2A, 0x54, 0x92, 0x00, 0x0D, 0xAB, +/* 2860 */ 0x21, 0x90, 0xA2, 0xA3, 0x0E, 0x04, 0x97, 0xCA, 0xB8, 0x02, 0x10, 0x06, 0x5F, 0x0C, 0xF4, 0x9A, +/* 2870 */ 0x58, 0x36, 0x66, 0xAA, 0xA4, 0xF4, 0x1B, 0x04, 0x00, 0x4E, 0xBD, 0xBD, 0xBD, 0x72, 0x10, 0x06, +/* 2880 */ 0x5F, 0x1B, 0x0D, 0x34, 0x50, 0x52, 0x76, 0x67, 0x54, 0xA5, 0x34, 0x50, 0x06, 0x01, 0x32, 0x4E, +/* 2890 */ 0xBD, 0xBD, 0xBD, 0x72, 0x10, 0x06, 0x5F, 0x03, 0xB1, 0x04, 0x67, 0x99, 0xB1, 0xB1, 0x04, 0x2A, +/* 28A0 */ 0x99, 0x62, 0x02, 0x02, 0x0C, 0x76, 0x2A, 0x51, 0x22, 0xA3, 0x02, 0x4E, 0xBD, 0xBD, 0xBD, 0x72, +/* 28B0 */ 0x10, 0x06, 0x19, 0x97, 0x90, 0x0B, 0x07, 0x86, 0x0B, 0x8B, 0x07, 0x4D, 0x22, 0x6C, 0x1A, 0x50, +/* 28C0 */ 0x94, 0x22, 0x91, 0x03, 0x00, 0x97, 0xBD, 0xBD, 0xBD, 0x72, 0x10, 0x0C, 0x00, 0x5F, 0x01, 0x02, +/* 28D0 */ 0x22, 0xAF, 0x04, 0x2C, 0x55, 0xB0, 0x0A, 0x74, 0x2A, 0x90, 0x08, 0x58, 0x5E, 0x08, 0x4D, 0x76, +/* 28E0 */ 0x67, 0x54, 0x0A, 0x05, 0x85, 0x8B, 0x90, 0x07, 0xA3, 0x3B, 0x83, 0x96, 0x7B, 0x90, 0x08, 0x0A, +/* 28F0 */ 0x08, 0x02, 0x09, 0xAB, 0x65, 0x50, 0x58, 0x6B, 0x0A, 0x3B, 0x39, 0x49, 0xAB, 0x01, 0xAA, 0x0F, +/* 2900 */ 0x85, 0x1A, 0x7C, 0x2E, 0x00, 0x7C, 0x4D, 0x39, 0x0A, 0xAB, 0x32, 0x2F, 0x31, 0x0C, 0x74, 0x32, +/* 2910 */ 0x2F, 0x31, 0x0C, 0x74, 0x32, 0x2F, 0x39, 0x0A, 0x98, 0x75, 0x2E, 0x24, 0xAE, 0x3B, 0x32, 0x09, +/* 2920 */ 0xF8, 0x59, 0x05, 0x00, 0x99, 0x38, 0x21, 0x54, 0x7E, 0x52, 0x98, 0x21, 0x99, 0x3A, 0x62, 0x05, +/* 2930 */ 0x10, 0x0D, 0x3E, 0x51, 0xA8, 0x99, 0x06, 0x2C, 0x0A, 0x4D, 0x7E, 0x6D, 0x2A, 0xAF, 0x06, 0x02, +/* 2940 */ 0x09, 0x62, 0x02, 0x83, 0x4E, 0xBA, 0x02, 0x75, 0x7E, 0xE7, 0x01, 0xDD, 0x7E, 0xE7, 0x01, 0xDD, +/* 2950 */ 0x7E, 0xE7, 0x10, 0x0D, 0x3E, 0x4C, 0x0A, 0x01, 0x83, 0xA4, 0x4A, 0x61, 0x0C, 0x3B, 0x83, 0x99, +/* 2960 */ 0x06, 0x4E, 0x46, 0xD1, 0x10, 0x0D, 0x22, 0x3E, 0x99, 0x36, 0x27, 0x01, 0x53, 0xAB, 0x21, 0x50, +/* 2970 */ 0x58, 0x0A, 0x03, 0xE9, 0x7A, 0x83, 0x46, 0xD1, 0x10, 0x0D, 0x00, 0x3E, 0x01, 0x52, 0x07, 0x27, +/* 2980 */ 0x01, 0x0C, 0x2E, 0xAB, 0x2C, 0x49, 0x88, 0x09, 0xAB, 0x21, 0xA3, 0x02, 0x75, 0x6E, 0x33, 0x46, +/* 2990 */ 0xD1, 0x10, 0x0D, 0x3E, 0xC8, 0x01, 0x7F, 0x02, 0x9C, 0x57, 0x97, 0x46, 0xD1, 0x10, 0x0D, 0x3E, +/* 29A0 */ 0x0A, 0x0A, 0xCE, 0x4A, 0x97, 0x46, 0xD1, 0x10, 0x0B, 0x32, 0x33, 0x9F, 0x91, 0x07, 0x83, 0x35, +/* 29B0 */ 0x83, 0x91, 0xF4, 0x4E, 0xAE, 0xED, 0x4B, 0x64, 0x91, 0x07, 0x83, 0x35, 0x83, 0x91, 0x07, 0x10, +/* 29C0 */ 0x0D, 0xA0, 0x9F, 0x09, 0x06, 0x66, 0x90, 0x5E, 0x5D, 0x74, 0x39, 0x50, 0x9C, 0x6B, 0x8B, 0x40, +/* 29D0 */ 0xA2, 0x4D, 0x8F, 0x3D, 0x96, 0x06, 0x00, 0x01, 0x2E, 0xAB, 0x1A, 0x7C, 0x7E, 0x1B, 0x0D, 0x02, +/* 29E0 */ 0x85, 0x39, 0x0A, 0x98, 0x00, 0x0A, 0x09, 0x00, 0x0D, 0x76, 0x3D, 0x0C, 0x70, 0x22, 0x0E, 0x04, +/* 29F0 */ 0xDC, 0x06, 0x3D, 0x0C, 0x70, 0x99, 0x0E, 0x00, 0xDC, 0x07, 0x1F, 0x69, 0x70, 0x00, 0x09, 0x0A, +/* 2A00 */ 0x22, 0x0B, 0x74, 0x3D, 0x09, 0x98, 0x0D, 0x06, 0x47, 0x76, 0x24, 0x75, 0x3B, 0x03, 0x92, 0x90, +/* 2A10 */ 0x85, 0x31, 0x49, 0x3B, 0x0C, 0x00, 0xAF, 0xAB, 0x39, 0x99, 0x58, 0xA2, 0x58, 0x8F, 0x1A, 0xAE, +/* 2A20 */ 0x85, 0x2E, 0x08, 0x34, 0xDC, 0xF7, 0x01, 0x7E, 0x83, 0x51, 0x06, 0x10, 0x0D, 0x00, 0x3E, 0x09, +/* 2A30 */ 0xF3, 0xD6, 0x83, 0x99, 0x06, 0x66, 0x33, 0xAC, 0xC4, 0xBF, 0x04, 0x73, 0x10, 0x0D, 0x22, 0x3E, +/* 2A40 */ 0x99, 0x0D, 0x3C, 0x02, 0x0A, 0x6C, 0x21, 0x99, 0x0E, 0x73, 0x3C, 0x51, 0x01, 0x00, 0x4E, 0xAC, +/* 2A50 */ 0xC4, 0xBF, 0x04, 0x73, 0x10, 0x0D, 0x3E, 0x90, 0x0D, 0x74, 0x67, 0x90, 0xA4, 0xA4, 0x07, 0x2A, +/* 2A60 */ 0x90, 0x60, 0x04, 0xA1, 0x98, 0x39, 0xA3, 0x01, 0x7C, 0x04, 0x27, 0x33, 0xAC, 0xC4, 0xBF, 0x04, +/* 2A70 */ 0x73, 0x10, 0x0D, 0x3E, 0x0A, 0x0A, 0x48, 0x7F, 0x2A, 0x40, 0x03, 0xDC, 0x0A, 0x2A, 0x49, 0x8F, +/* 2A80 */ 0x63, 0x6E, 0x4E, 0xAC, 0xC4, 0xBF, 0x04, 0x73, 0x10, 0x0B, 0x3E, 0xB6, 0x7F, 0x27, 0x01, 0x53, +/* 2A90 */ 0x73, 0x67, 0x59, 0x0A, 0x03, 0xE9, 0x7A, 0x27, 0xBE, 0x92, 0xC2, 0x5C, 0x10, 0x0D, 0x6F, 0x3E, +/* 2AA0 */ 0x49, 0x5B, 0x66, 0xBD, 0x01, 0x38, 0x07, 0xA4, 0x89, 0x01, 0x4D, 0x0A, 0x0F, 0x3F, 0x70, 0xB7, +/* 2AB0 */ 0x72, 0x1F, 0xAF, 0x08, 0x01, 0x10, 0x0B, 0x00, 0x5F, 0x09, 0x57, 0x99, 0x89, 0x90, 0x0F, 0x70, +/* 2AC0 */ 0x00, 0x0A, 0x7E, 0x2C, 0x7D, 0x01, 0xB3, 0x0E, 0x07, 0x83, 0x4E, 0xBE, 0x92, 0xC2, 0x5C, 0x10, +/* 2AD0 */ 0x00, 0x00, 0x00, 0x0D, 0x00, 0x1A, 0x00, 0x0D, 0x0C, 0x21, 0x20, 0x99, 0x79, 0x79, 0x06, 0x1F, +/* 2AE0 */ 0x7C, 0x4D, 0x80, 0xAB, 0x10, 0x0B, 0x21, 0x20, 0x90, 0x0B, 0x4F, 0x79, 0x06, 0x3D, 0x40, 0x80, +/* 2AF0 */ 0x09, 0x10, 0x11, 0x21, 0x20, 0x90, 0x79, 0x79, 0x79, 0x05, 0x32, 0x99, 0x80, 0x80, 0x98, 0x10, +/* char range ofs tables */ + +/* 2B00 */ 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x95, 0x00, 0x00, 0x08, 0x97, +/* 2B10 */ 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x08, 0x9A, 0x00, 0x00, 0x09, 0x58, +/* 2B20 */ 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x1B, 0x66, 0x00, 0x00, 0x1C, 0x26, +/* 2B30 */ 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2A, 0xD0, 0x00, 0x00, 0x2A, 0xD8, diff --git a/contrib/mcufont/fonts/FiraSansCondensed-Regular32.mcufont.h b/contrib/mcufont/fonts/FiraSansCondensed-Regular32.mcufont.h new file mode 100644 index 000000000..afe6a167c --- /dev/null +++ b/contrib/mcufont/fonts/FiraSansCondensed-Regular32.mcufont.h @@ -0,0 +1,949 @@ +/* + * LWS MCUFONT Fira Sans Condensed Regular 32 + * blob size: 14830, glyphs 192 + * + * Unicode 0x00000d - 0x00000d + * Unicode 0x000020 - 0x00007e + * Unicode 0x0000a0 - 0x0000ff + * Unicode 0x002012 - 0x002015 +*/ + +/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5F, +/* 0010 */ 0x00, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x08, 0x8A, 0x00, 0x00, 0x09, 0x05, 0x00, 0x00, 0x00, 0x94, +/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x39, 0xAE, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F, +/* 0030 */ 0x00, 0x1D, 0x00, 0x28, 0x00, 0x06, 0x00, 0x1E, 0x00, 0x01, 0x00, 0x1F, 0x00, 0x26, 0x00, 0x00, +/* full name */ + +/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, +/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x20, 0x33, 0x32, 0x00, +/* short name */ +0x46, +/* 0060 */ 0x69, 0x72, 0x61, 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, +/* 0070 */ 0x5F, 0x52, 0x65, 0x67, 0x75, 0x6C, 0x61, 0x72, 0x33, 0x32, 0x00, +/* dictionary data */ +0x19, 0xC6, 0x81, 0x81, 0xC6, +/* 0080 */ 0x01, 0x1A, 0x19, 0xCA, 0x81, 0xC1, 0xCE, 0x80, 0x03, 0xC4, 0x81, 0x02, 0xC2, 0xC4, 0x81, 0xCB, +/* 0090 */ 0x19, 0x19, 0xC4, 0x81, 0xCB, 0x19, 0xC4, 0x81, 0xCB, 0x19, 0xC4, 0x81, 0xCB, 0x19, 0xC4, 0x81, +/* 00A0 */ 0xCB, 0x19, 0xC4, 0x81, 0xCB, 0x19, 0x86, 0x02, 0x11, 0x0F, 0x81, 0xC7, 0x14, 0x80, 0xC5, 0x05, +/* 00B0 */ 0xC5, 0x80, 0xE4, 0x81, 0xC7, 0x19, 0xC6, 0x81, 0xC7, 0x19, 0xC6, 0x81, 0xC7, 0x19, 0xC6, 0x81, +/* 00C0 */ 0xC7, 0x19, 0xC6, 0x81, 0x84, 0x18, 0x13, 0x81, 0xC9, 0x01, 0xF4, 0xE4, 0xCA, 0x87, 0xCB, 0xC1, +/* 00D0 */ 0x11, 0xCB, 0x81, 0xCD, 0x81, 0xCB, 0x12, 0x43, 0x08, 0xCB, 0xCE, 0x03, 0xC2, 0xCE, 0x80, 0x0F, +/* 00E0 */ 0xC6, 0x81, 0xC7, 0x01, 0x41, 0x30, 0x42, 0x0D, 0xC8, 0xCC, 0x80, 0xCB, 0xC7, 0xC1, 0x10, 0xC4, +/* 00F0 */ 0xC7, 0xCE, 0xCB, 0x01, 0xC6, 0xD4, 0x17, 0xC8, 0x81, 0x04, 0xC7, 0x19, 0xC6, 0x40, 0x0E, 0xC4, +/* 0100 */ 0x81, 0x80, 0xC9, 0x19, 0xCC, 0x80, 0xC4, 0x81, 0xCB, 0x01, 0x1A, 0xCD, 0x80, 0x0E, 0x80, 0xC2, +/* 0110 */ 0x01, 0x10, 0xC1, 0xCC, 0x1A, 0x80, 0xCD, 0x02, 0xCA, 0xC1, 0x15, 0xC1, 0xCB, 0x81, 0xCC, 0xC6, +/* 0120 */ 0xC5, 0xCC, 0xCE, 0xC3, 0x13, 0xCA, 0x86, 0xCB, 0x13, 0xC1, 0xDA, 0xD2, 0xD5, 0xC6, 0x81, 0xCD, +/* 0130 */ 0xC1, 0x03, 0x04, 0xCA, 0xC4, 0xC1, 0xC2, 0x10, 0xC6, 0xCB, 0x13, 0xC3, 0xC2, 0x16, 0x09, 0xC2, +/* 0140 */ 0x81, 0x45, 0x12, 0xC1, 0x81, 0x80, 0xC3, 0x02, 0xCD, 0xCE, 0xC4, 0xCE, 0x80, 0x19, 0xC3, 0x81, +/* 0150 */ 0xC5, 0x81, 0xC8, 0xC1, 0x11, 0xC4, 0x80, 0x80, 0xCE, 0xCC, 0xC1, 0x01, 0x0A, 0x19, 0xC8, 0x81, +/* 0160 */ 0x80, 0xCC, 0x01, 0xC2, 0x80, 0xC8, 0xCE, 0xC7, 0x02, 0xC3, 0x80, 0xC4, 0xC1, 0xCE, 0x80, 0x01, +/* 0170 */ 0xC7, 0xCE, 0xC2, 0x02, 0x80, 0xCA, 0xC6, 0xC4, 0xC9, 0x81, 0xC6, 0x07, 0x0C, 0xCD, 0xC2, 0xC5, +/* 0180 */ 0x05, 0xCB, 0x81, 0xC2, 0x10, 0xC8, 0x81, 0xC5, 0x05, 0xCB, 0x81, 0xC2, 0x10, 0xC8, 0x81, 0xC5, +/* 0190 */ 0x05, 0xCB, 0x81, 0xC2, 0x10, 0xC8, 0x81, 0xC5, 0x01, 0xCE, 0x80, 0xCA, 0xC5, 0x01, 0xC1, 0x43, +/* 01A0 */ 0x06, 0x81, 0xC4, 0x02, 0x40, 0x0C, 0x07, 0xC1, 0xC7, 0x01, 0xC4, 0xC1, 0xCC, 0xCC, 0x81, 0x80, +/* 01B0 */ 0xCE, 0xC1, 0xCA, 0xC4, 0x06, 0x88, 0x82, 0x08, 0xC9, 0xC1, 0xCE, 0xCA, 0xC9, 0xC2, 0x01, 0xCE, +/* 01C0 */ 0xCC, 0xC1, 0xCB, 0xC2, 0xCA, 0xCE, 0x81, 0xC4, 0x19, 0x0B, 0xCE, 0xC1, 0xCA, 0xC1, 0xCD, 0x80, +/* 01D0 */ 0xCC, 0xC6, 0xC4, 0xCE, 0xC9, 0x16, 0x0D, 0xC9, 0x81, 0x40, 0x3D, 0xCE, 0xC5, 0xCB, 0x81, 0x05, +/* 01E0 */ 0x01, 0xC5, 0xCC, 0x80, 0x43, 0x0A, 0xC7, 0x80, 0x11, 0xC6, 0x81, 0xCE, 0xCD, 0x80, 0xC6, 0x01, +/* 01F0 */ 0x41, 0x17, 0x40, 0x22, 0x19, 0xC1, 0x81, 0x1C, 0x90, 0x07, 0x28, 0xA5, 0x23, 0x6A, 0x25, 0x85, +/* 0200 */ 0x09, 0x06, 0x43, 0x06, 0xA3, 0x6F, 0x21, 0x73, 0x0D, 0x1A, 0x86, 0x01, 0x2F, 0x1F, 0x03, 0x03, +/* 0210 */ 0x04, 0x86, 0x01, 0x3F, 0x1F, 0x09, 0x0E, 0x23, 0x01, 0x26, 0x71, 0x0E, 0x8A, 0x01, 0x50, 0x0E, +/* 0220 */ 0x33, 0x59, 0x24, 0x86, 0x01, 0x26, 0x42, 0x33, 0xA1, 0x86, 0x01, 0x3F, 0x9D, 0x05, 0xA1, 0x86, +/* 0230 */ 0x01, 0x3F, 0xA0, 0x04, 0xA1, 0x86, 0x01, 0x79, 0x58, 0x0F, 0x29, 0x37, 0x7E, 0x93, 0x01, 0x3F, +/* 0240 */ 0xA5, 0x76, 0x58, 0x8B, 0x5A, 0x5F, 0x4A, 0x04, 0x05, 0x0B, 0x0F, 0xA3, 0x4A, 0xA6, 0x1E, 0x33, +/* 0250 */ 0x01, 0x86, 0x5A, 0x84, 0x36, 0x90, 0x07, 0x00, 0x7E, 0x09, 0x0B, 0x00, 0x1A, 0x1A, 0x03, 0x21, +/* 0260 */ 0x42, 0x90, 0xA1, 0x5C, 0x86, 0x72, 0xA1, 0x50, 0x08, 0x8B, 0x36, 0x69, 0x88, 0x25, 0x58, 0x23, +/* 0270 */ 0x0A, 0x26, 0x58, 0x0F, 0x52, 0x77, 0x05, 0x0B, 0x6F, 0x46, 0x49, 0x57, 0xA2, 0x2F, 0xA0, 0x04, +/* 0280 */ 0x2E, 0x61, 0x0E, 0x21, 0x20, 0x66, 0x0A, 0x18, 0x09, 0x18, 0x0A, 0x2E, 0xA2, 0x33, 0x00, 0x07, +/* 0290 */ 0x04, 0x40, 0x98, 0x52, 0x01, 0x26, 0x45, 0x6A, 0x37, 0x91, 0x0F, 0x76, 0x4E, 0x5F, 0x75, 0x37, +/* 02A0 */ 0x7E, 0x98, 0x72, 0x9C, 0x45, 0x09, 0x8C, 0xA5, 0x76, 0x9C, 0x98, 0x72, 0x8C, 0x5F, 0x0E, 0x95, +/* 02B0 */ 0x7E, 0x8B, 0x6B, 0x93, 0x03, 0x8C, 0x1D, 0x0F, 0x52, 0x6B, 0xA3, 0x29, 0x89, 0x2A, 0x6D, 0x6B, +/* 02C0 */ 0xA0, 0x06, 0x6B, 0x42, 0x33, 0x89, 0x58, 0x27, 0x6B, 0x42, 0x33, 0x89, 0x58, 0x27, 0x89, 0x2A, +/* 02D0 */ 0x6D, 0x6B, 0xA0, 0x06, 0x8C, 0x1D, 0x0F, 0x52, 0x6B, 0xA3, 0x29, 0x6B, 0x7E, 0x8B, 0x6B, 0x93, +/* 02E0 */ 0x02, 0x79, 0x98, 0x72, 0x8C, 0x5F, 0x0E, 0x9C, 0x9D, 0x08, 0x8C, 0x56, 0x0A, 0x95, 0x71, 0x0F, +/* 02F0 */ 0x87, 0xA1, 0x7E, 0x98, 0x72, 0x4E, 0x9D, 0x6A, 0x58, 0x0F, 0x76, 0x4E, 0x7E, 0xA3, 0x52, 0x07, +/* 0300 */ 0x04, 0x40, 0x98, 0x52, 0x01, 0x95, 0x49, 0x06, 0x08, 0x24, 0x71, 0x30, 0x3F, 0x0C, 0x87, 0xA1, +/* 0310 */ 0x0B, 0x69, 0x50, 0x33, 0x89, 0xA5, 0x62, 0x6B, 0x1D, 0x30, 0xA1, 0x56, 0x05, 0x26, 0x56, 0x8A, +/* 0320 */ 0xA8, 0x4E, 0x56, 0x8A, 0xA8, 0x4E, 0x56, 0x88, 0x31, 0x59, 0x6B, 0x2A, 0x76, 0x21, 0x5F, 0x0D, +/* 0330 */ 0x4D, 0x62, 0x9B, 0x42, 0x33, 0xA1, 0x83, 0x2F, 0x86, 0x99, 0x05, 0x08, 0x1C, 0x07, 0x34, 0x85, +/* 0340 */ 0x23, 0x0D, 0x04, 0x28, 0x5B, 0x1C, 0x1E, 0x02, 0x4E, 0x61, 0x0D, 0x89, 0x61, 0x0E, 0x3F, 0x86, +/* 0350 */ 0x03, 0xA1, 0x56, 0x09, 0x26, 0x42, 0x33, 0x37, 0x7E, 0x98, 0x62, 0x26, 0x86, 0x99, 0x06, 0x98, +/* 0360 */ 0x6F, 0x34, 0x85, 0x23, 0x09, 0x28, 0x42, 0x36, 0x69, 0x88, 0x26, 0x0A, 0x8E, 0x00, 0x53, 0x8E, +/* 0370 */ 0x2F, 0x5F, 0x4F, 0x5F, 0x4F, 0x4E, 0x58, 0x8E, 0x00, 0x53, 0x9A, 0x1C, 0x41, 0x05, 0x28, 0x85, +/* 0380 */ 0x2D, 0x33, 0x01, 0x34, 0xA0, 0x99, 0x06, 0x98, 0x76, 0xA6, 0x0B, 0x37, 0x7E, 0x98, 0x72, 0x3F, +/* 0390 */ 0x86, 0x03, 0x2A, 0x76, 0x26, 0x61, 0x0D, 0x89, 0x61, 0x0E, 0x26, 0x4C, 0x89, 0x98, 0x4F, 0x9C, +/* 03A0 */ 0x56, 0x09, 0x82, 0x86, 0x03, 0x4E, 0x56, 0x09, 0x82, 0xA0, 0x04, 0x4E, 0x56, 0x09, 0x82, 0x86, +/* 03B0 */ 0x03, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, +/* 03C0 */ 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, +/* 03D0 */ 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, +/* 03E0 */ 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x08, 0x27, 0x4E, 0x78, 0x78, 0x89, 0x74, +/* 03F0 */ 0x27, 0x37, 0x58, 0x0F, 0x29, 0x49, 0x0B, 0x82, 0x93, 0x02, 0x26, 0x98, 0x29, 0xA1, 0x08, 0x33, +/* 0400 */ 0x3F, 0x66, 0x4A, 0x05, 0x04, 0x05, 0x0A, 0x0F, 0x69, 0x5A, 0x42, 0x23, 0x69, 0x04, 0x25, 0x1F, +/* 0410 */ 0x3C, 0x1C, 0x41, 0x3E, 0x9C, 0xA9, 0x45, 0xA8, 0x44, 0x0D, 0x1E, 0x76, 0x44, 0x5F, 0x0E, 0x69, +/* 0420 */ 0x89, 0xA6, 0xA5, 0x72, 0x9B, 0x6F, 0x24, 0x50, 0x0E, 0x4F, 0x1F, 0x0F, 0x4F, 0x08, 0x29, 0x4E, +/* 0430 */ 0x08, 0x76, 0x46, 0x08, 0x76, 0x24, 0x09, 0x29, 0x9C, 0x73, 0x04, 0x37, 0x73, 0x04, 0x24, 0x0B, +/* 0440 */ 0x29, 0x79, 0x42, 0x6D, 0x00, 0x1D, 0x23, 0x52, 0x79, 0x0D, 0x29, 0x00, 0x1D, 0x23, 0x52, 0x6B, +/* 0450 */ 0xA2, 0x52, 0x46, 0x7E, 0x43, 0x2B, 0x98, 0x07, 0x03, 0x46, 0x27, 0x89, 0xA0, 0x04, 0x39, 0x00, +/* 0460 */ 0x58, 0x0F, 0x29, 0x39, 0xA1, 0x9D, 0x06, 0x39, 0x00, 0x58, 0x0F, 0x29, 0x39, 0xA1, 0xA0, 0x04, +/* 0470 */ 0x39, 0xA1, 0x93, 0x01, 0x39, 0x24, 0x71, 0x0F, 0x6D, 0x3F, 0x56, 0x75, 0x24, 0x0B, 0x27, 0x3F, +/* 0480 */ 0x56, 0x69, 0x08, 0x04, 0x05, 0xA0, 0x0D, 0x0C, 0xA1, 0xA0, 0x02, 0x82, 0x42, 0x27, 0x46, 0x61, +/* 0490 */ 0x0C, 0xA1, 0xA0, 0x02, 0x82, 0x42, 0x27, 0x46, 0x61, 0x0C, 0xA1, 0xA0, 0x02, 0x82, 0x42, 0x27, +/* 04A0 */ 0x46, 0x61, 0x39, 0x37, 0x74, 0x19, 0x39, 0x37, 0x74, 0x19, 0x0D, 0x00, 0x49, 0x0A, 0x00, 0x2A, +/* 04B0 */ 0x6F, 0x3F, 0x0E, 0x69, 0x89, 0x9D, 0x04, 0x79, 0x58, 0x1E, 0x03, 0xA1, 0x0D, 0x69, 0xA6, 0x07, +/* 04C0 */ 0x46, 0x61, 0x0A, 0x26, 0x1F, 0x33, 0x46, 0x66, 0x05, 0x34, 0x0C, 0x69, 0x46, 0x9D, 0x01, 0x34, +/* 04D0 */ 0x45, 0x03, 0x37, 0x0D, 0x3D, 0x5C, 0x27, 0x1F, 0x27, 0x28, 0x0E, 0x3D, 0x24, 0x56, 0x5A, 0x58, +/* 04E0 */ 0x1E, 0x53, 0x52, 0x3F, 0x2A, 0x72, 0x7C, 0x08, 0xA1, 0x50, 0x0F, 0x6F, 0x03, 0x80, 0x28, 0x0B, +/* 04F0 */ 0x6D, 0x07, 0x69, 0x44, 0xA5, 0x6D, 0x76, 0x9B, 0x6E, 0x8B, 0x29, 0x2E, 0x0D, 0x8B, 0x01, 0x21, +/* 0500 */ 0x0D, 0x3D, 0x8C, 0x68, 0x29, 0x8C, 0x50, 0x0D, 0x52, 0x9B, 0x1F, 0xA3, 0x72, 0x2F, 0x1D, 0xA0, +/* 0510 */ 0xA8, 0xA1, 0xA6, 0x0D, 0x04, 0xA1, 0x5C, 0x08, 0x04, 0x0E, 0x08, 0x6C, 0x62, 0x9B, 0x45, 0x62, +/* 0520 */ 0x9B, 0x38, 0x0E, 0x4D, 0x09, 0xAB, 0x94, 0x05, 0x52, 0x1A, 0x08, 0x0F, 0xA0, 0x5A, 0x45, 0x7B, +/* 0530 */ 0xA1, 0xA0, 0x5A, 0x45, 0x7B, 0xA1, 0xA0, 0x5A, 0x45, 0x06, 0x24, 0x1F, 0x93, 0x5A, 0x56, 0x0A, +/* 0540 */ 0x37, 0x85, 0x8B, 0x5A, 0x5F, 0x6F, 0x04, 0x06, 0x0D, 0x76, 0x1E, 0x02, 0x25, 0x08, 0x2D, 0x29, +/* 0550 */ 0xA5, 0x4F, 0x3F, 0x42, 0xA3, 0x8E, 0x03, 0x00, 0x56, 0x02, 0x96, 0xA1, 0x33, 0x49, 0x9D, 0x06, +/* 0560 */ 0xA1, 0x33, 0x49, 0x04, 0x0F, 0x6D, 0xA1, 0x33, 0x49, 0x04, 0x0A, 0x1E, 0x03, 0x46, 0x33, 0x49, +/* 0570 */ 0x05, 0x03, 0x0F, 0x76, 0x46, 0x33, 0x49, 0x05, 0x00, 0x86, 0x01, 0x37, 0x33, 0x49, 0x05, 0x42, +/* 0580 */ 0x27, 0x37, 0x33, 0x49, 0x06, 0x7E, 0x0E, 0x52, 0x37, 0x33, 0x49, 0x06, 0x24, 0x45, 0x05, 0x24, +/* 0590 */ 0x33, 0x49, 0x06, 0x1F, 0x33, 0x24, 0x33, 0x49, 0x06, 0x37, 0xA0, 0x02, 0x7C, 0x0B, 0x49, 0x06, +/* 05A0 */ 0x1D, 0x0F, 0x6F, 0x7C, 0x0B, 0x49, 0x06, 0x46, 0x0D, 0x87, 0x0D, 0x3D, 0x49, 0x06, 0x37, 0x74, +/* 05B0 */ 0x1E, 0x06, 0x0C, 0x3D, 0x49, 0x06, 0x46, 0x73, 0x0C, 0x0B, 0x3D, 0x95, 0x1D, 0x19, 0x65, 0x07, +/* 05C0 */ 0x02, 0x84, 0x36, 0x90, 0x05, 0x00, 0xA6, 0x03, 0xA5, 0x2D, 0x06, 0xA6, 0x0A, 0x52, 0x77, 0x9D, +/* 05D0 */ 0x0E, 0xA6, 0x3D, 0x01, 0x37, 0xA3, 0x72, 0x3F, 0x56, 0x57, 0x00, 0x08, 0x19, 0x39, 0x37, 0x74, +/* 05E0 */ 0x19, 0x39, 0x37, 0x74, 0x19, 0x39, 0x37, 0x74, 0x19, 0x39, 0x37, 0x74, 0x23, 0x3D, 0x01, 0x3F, +/* 05F0 */ 0x1D, 0x09, 0x63, 0xA7, 0x88, 0x06, 0x1C, 0x0A, 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x76, 0x49, 0x0B, +/* 0600 */ 0x46, 0x1D, 0x0F, 0x76, 0x49, 0x0B, 0x46, 0x1D, 0x1E, 0x01, 0x24, 0x7E, 0x2F, 0x1F, 0x0D, 0x33, +/* 0610 */ 0x55, 0x0D, 0x96, 0x2F, 0x98, 0x2D, 0x4A, 0x25, 0x1F, 0x0B, 0x8D, 0x03, 0x09, 0x0E, 0x9A, 0x3F, +/* 0620 */ 0x71, 0x0D, 0x9F, 0x2F, 0x08, 0x33, 0x24, 0x08, 0x0B, 0x03, 0x1A, 0x86, 0x8D, 0x82, 0x50, 0x09, +/* 0630 */ 0x93, 0x70, 0x8C, 0x50, 0x06, 0xA3, 0x4A, 0x82, 0x5C, 0x0A, 0x03, 0x6B, 0x48, 0x0F, 0x6F, 0x8C, +/* 0640 */ 0x45, 0x09, 0x95, 0x71, 0x0F, 0x69, 0x8C, 0x93, 0x02, 0x4E, 0x0B, 0x19, 0x2A, 0x76, 0x00, 0x49, +/* 0650 */ 0x0C, 0x89, 0x86, 0x03, 0x3F, 0xA3, 0x62, 0x71, 0x33, 0x79, 0x2A, 0x76, 0x46, 0x9D, 0x04, 0x34, +/* 0660 */ 0x0D, 0x1E, 0x01, 0x24, 0x73, 0x0C, 0x46, 0x39, 0x00, 0xA5, 0x29, 0x28, 0x0E, 0x52, 0x24, 0x0D, +/* 0670 */ 0x52, 0x00, 0x28, 0xA5, 0x29, 0x04, 0x19, 0x28, 0x73, 0x0B, 0x0B, 0x52, 0x44, 0x45, 0x27, 0x44, +/* 0680 */ 0x61, 0x87, 0x2E, 0x9D, 0x08, 0x6C, 0x07, 0x6C, 0x07, 0x6C, 0x07, 0x6C, 0x07, 0x6C, 0x07, 0x6C, +/* 0690 */ 0x07, 0x21, 0x08, 0x66, 0x6A, 0x1F, 0x98, 0x6F, 0x3F, 0xA0, 0x04, 0x2A, 0x6F, 0x26, 0x61, 0x0E, +/* 06A0 */ 0x00, 0x2A, 0x6F, 0x9C, 0x71, 0x0F, 0x6D, 0x00, 0x2A, 0x6F, 0x26, 0x4C, 0x2A, 0x6F, 0x6B, 0x2A, +/* 06B0 */ 0x76, 0x00, 0x2A, 0x6F, 0x26, 0x66, 0x66, 0x08, 0x3F, 0x98, 0x72, 0xA1, 0xA5, 0x6F, 0x3F, 0x08, +/* 06C0 */ 0x33, 0x00, 0x1D, 0x1E, 0x6F, 0x50, 0x20, 0x20, 0x22, 0x22, 0x22, 0x04, 0x69, 0x44, 0x1D, 0x69, +/* 06D0 */ 0x44, 0x1D, 0x69, 0x0B, 0x52, 0x61, 0x08, 0xA1, 0x50, 0x0E, 0x4A, 0x00, 0x0C, 0x6D, 0x46, 0x68, +/* 06E0 */ 0x29, 0x00, 0x45, 0x02, 0x28, 0x9D, 0x01, 0x84, 0x19, 0x2F, 0x0D, 0x3D, 0x24, 0x61, 0x0A, 0x25, +/* 06F0 */ 0x1F, 0x27, 0x37, 0x0B, 0x69, 0x2F, 0xA5, 0x62, 0x74, 0x80, 0x3F, 0x0B, 0x69, 0x24, 0x71, 0x0F, +/* 0700 */ 0x6F, 0x25, 0x61, 0x0A, 0xA1, 0x0E, 0x52, 0x3F, 0xA2, 0x19, 0x58, 0x1E, 0x5A, 0x09, 0x8A, 0x27, +/* 0710 */ 0x3F, 0x0D, 0x8A, 0x33, 0x9C, 0x71, 0x33, 0x05, 0x55, 0x55, 0x55, 0x0D, 0x1E, 0x01, 0x4E, 0xA5, +/* 0720 */ 0x29, 0x37, 0x58, 0x0F, 0x29, 0x4E, 0x86, 0x02, 0x82, 0x56, 0x09, 0x9C, 0x61, 0x0D, 0x8C, 0x5F, +/* 0730 */ 0x0D, 0x8C, 0x2A, 0x4A, 0x5E, 0x98, 0x62, 0x89, 0x58, 0x0F, 0x29, 0x5E, 0x09, 0x27, 0x6B, 0x49, +/* 0740 */ 0x00, 0x4B, 0x0A, 0x6F, 0x95, 0x74, 0x1C, 0x69, 0x8C, 0x5F, 0x02, 0x95, 0xA3, 0x8E, 0x69, 0x8C, +/* 0750 */ 0x08, 0x76, 0x79, 0x08, 0x0A, 0x02, 0x04, 0x69, 0x82, 0x73, 0x03, 0x79, 0x1D, 0x69, 0x89, 0x74, +/* 0760 */ 0x3D, 0x9C, 0x1D, 0x69, 0x89, 0x7C, 0x06, 0x27, 0x89, 0x98, 0x4F, 0x9C, 0x42, 0xA5, 0x4A, 0x6A, +/* 0770 */ 0x46, 0x5C, 0x0C, 0x27, 0x89, 0x50, 0x9D, 0x52, 0x06, 0x9B, 0x0D, 0x1B, 0x1B, 0x1B, 0x1B, 0x8A, +/* 0780 */ 0x4A, 0x68, 0x8A, 0x06, 0x68, 0x6D, 0x31, 0x01, 0x25, 0x22, 0x4C, 0x82, 0x68, 0x6D, 0x43, 0x2B, +/* 0790 */ 0x59, 0x00, 0x68, 0x23, 0x29, 0x00, 0x68, 0x23, 0x29, 0x34, 0x20, 0x22, 0x4C, 0x82, 0x68, 0x6D, +/* 07A0 */ 0x31, 0x03, 0x68, 0x8A, 0x0C, 0x68, 0x8A, 0x0C, 0x44, 0x84, 0x30, 0x91, 0x9A, 0x6C, 0x72, 0x2E, +/* 07B0 */ 0x45, 0x72, 0x2E, 0x0D, 0xAB, 0x0D, 0xAB, 0x0D, 0xAB, 0x0D, 0xAB, 0x0D, 0xAB, 0x0D, 0x05, 0x6C, +/* 07C0 */ 0x05, 0x6C, 0x05, 0x6C, 0x05, 0x6C, 0x05, 0x6C, 0x05, 0x6C, 0x02, 0x21, 0xA0, 0x70, 0x2E, 0x83, +/* 07D0 */ 0x98, 0x6D, 0x03, 0x2E, 0xA2, 0xA3, 0x51, 0x84, 0x8A, 0x52, 0x68, 0x8A, 0x0D, 0x00, 0x50, 0x2B, +/* 07E0 */ 0x64, 0x0A, 0x2B, 0x03, 0x9B, 0x0E, 0x6F, 0x1A, 0x0E, 0x28, 0x0E, 0x4A, 0x1F, 0x27, 0x28, 0x0E, +/* 07F0 */ 0x4A, 0x1F, 0x27, 0x28, 0x0E, 0x4A, 0x24, 0x5F, 0x44, 0x53, 0x8B, 0x5D, 0x53, 0x8B, 0x5D, 0x1F, +/* 0800 */ 0x0C, 0x70, 0x1A, 0x0E, 0x6F, 0x21, 0x7C, 0x0C, 0x52, 0xA1, 0xA0, 0x5A, 0x06, 0x27, 0xA1, 0xA0, +/* 0810 */ 0x5A, 0x06, 0x27, 0xA1, 0xA0, 0x5A, 0x06, 0x27, 0xA1, 0xA0, 0x5A, 0x06, 0x27, 0xA1, 0xA0, 0x5A, +/* 0820 */ 0x06, 0x2B, 0x03, 0x68, 0x8A, 0x0C, 0x68, 0x8A, 0x0C, 0xAA, 0x03, 0x1C, 0x26, 0x4C, 0xA1, 0x5A, +/* 0830 */ 0xA1, 0x64, 0x0C, 0x06, 0x1C, 0x7A, 0x2F, 0x5F, 0x08, 0x00, 0x7E, 0x0A, 0x52, 0x2F, 0x74, 0x04, +/* 0840 */ 0xA1, 0x77, 0x95, 0x48, 0x9D, 0x06, 0x89, 0x61, 0x01, 0x31, 0x08, 0xAB, 0x08, 0xAB, 0xA4, 0x71, +/* 0850 */ 0x09, 0x63, 0xA7, 0x88, 0x2F, 0xAB, 0x0C, 0xAB, 0x0C, 0xAB, 0x0C, 0x0F, 0x01, 0x82, 0x07, 0x0C, +/* 0860 */ 0x0E, 0xA7, 0x8F, 0x2F, 0x85, 0x2D, 0x69, 0x04, 0x2F, 0x86, 0x7D, 0x40, 0x0E, 0x69, 0x02, 0xA6, +/* 0870 */ 0x62, 0x44, 0x86, 0x03, 0x4B, 0x62, 0x44, 0x86, 0x03, 0x4B, 0x62, 0x44, 0x86, 0x03, 0x4B, 0x62, +/* 0880 */ 0x44, 0x86, 0x03, 0x0E, 0x06, 0x0D, 0x0D, 0x94, 0xA0, 0x0C, 0x4B, 0x52, 0x9B, 0x1D, 0x63, 0x04, +/* 0890 */ 0x26, 0x9E, 0x42, 0x2C, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x27, 0x46, 0x9D, 0x0D, 0x3D, 0x49, 0x06, +/* 08A0 */ 0x37, 0x71, 0x8B, 0x04, 0x00, 0x00, 0x03, 0x0D, 0x21, 0x07, 0x19, 0x44, 0x74, 0x19, 0x2E, 0x0C, +/* 08B0 */ 0x29, 0x8C, 0x1D, 0x87, 0x95, 0x0C, 0x29, 0x95, 0x0B, 0x0F, 0x07, 0x5E, 0x50, 0x0F, 0x33, 0x82, +/* 08C0 */ 0x33, 0x49, 0x1E, 0x02, 0x89, 0x33, 0x49, 0x0F, 0x4A, 0x21, 0x98, 0x3F, 0x4C, 0x49, 0x0B, 0x82, +/* 08D0 */ 0x0D, 0x37, 0x5C, 0x1E, 0x05, 0x04, 0x06, 0x79, 0x1D, 0x69, 0xA1, 0x42, 0x6D, 0x68, 0x0E, 0x89, +/* 08E0 */ 0x0D, 0x29, 0x68, 0x0E, 0x37, 0x42, 0x45, 0x7B, 0xA1, 0x98, 0x4F, 0x88, 0x37, 0x50, 0x32, 0x08, +/* 08F0 */ 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, 0x65, 0x08, +/* 0900 */ 0x65, 0x08, 0x65, 0x08, 0x65, +/* dictionary offset */ +0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 0x00, 0x07, 0x00, 0x0B, 0x00, +/* 0910 */ 0x0D, 0x00, 0x0F, 0x00, 0x10, 0x00, 0x12, 0x00, 0x16, 0x00, 0x17, 0x00, 0x2B, 0x00, 0x2C, 0x00, +/* 0920 */ 0x2D, 0x00, 0x2E, 0x00, 0x2F, 0x00, 0x31, 0x00, 0x32, 0x00, 0x34, 0x00, 0x37, 0x00, 0x38, 0x00, +/* 0930 */ 0x49, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x59, 0x00, 0x5B, 0x00, +/* 0940 */ 0x5C, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x61, 0x00, 0x64, 0x00, 0x69, 0x00, 0x6B, 0x00, 0x6D, 0x00, +/* 0950 */ 0x6F, 0x00, 0x71, 0x00, 0x73, 0x00, 0x74, 0x00, 0x76, 0x00, 0x78, 0x00, 0x7A, 0x00, 0x7B, 0x00, +/* 0960 */ 0x7C, 0x00, 0x7E, 0x00, 0x7F, 0x00, 0x82, 0x00, 0x83, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8B, 0x00, +/* 0970 */ 0x8F, 0x00, 0x92, 0x00, 0x93, 0x00, 0x96, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, +/* 0980 */ 0xB1, 0x00, 0xB2, 0x00, 0xB4, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, +/* 0990 */ 0xC1, 0x00, 0xC3, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00, 0xCA, 0x00, 0xCD, 0x00, 0xCF, 0x00, +/* 09A0 */ 0xD2, 0x00, 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDC, 0x00, 0xDE, 0x00, 0xE1, 0x00, 0xE2, 0x00, +/* 09B0 */ 0xE5, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF4, 0x00, +/* 09C0 */ 0xF6, 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFD, 0x01, 0x01, 0x01, 0x02, 0x01, 0x04, 0x01, 0x1D, 0x01, +/* 09D0 */ 0x20, 0x01, 0x22, 0x01, 0x24, 0x01, 0x26, 0x01, 0x29, 0x01, 0x2B, 0x01, 0x2C, 0x01, 0x2E, 0x01, +/* 09E0 */ 0x30, 0x01, 0x32, 0x01, 0x34, 0x01, 0x37, 0x01, 0x39, 0x01, 0x3A, 0x01, 0x3B, 0x01, 0x3C, 0x01, +/* 09F0 */ 0x3D, 0x01, 0x3F, 0x01, 0x41, 0x01, 0x44, 0x01, 0x46, 0x01, 0x48, 0x01, 0x4A, 0x01, 0x4C, 0x01, +/* 0A00 */ 0x4E, 0x01, 0x4F, 0x01, 0x51, 0x01, 0x53, 0x01, 0x55, 0x01, 0x58, 0x01, 0x5A, 0x01, 0x5B, 0x01, +/* 0A10 */ 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01, 0x64, 0x01, 0x65, 0x01, 0x67, 0x01, 0x69, 0x01, +/* 0A20 */ 0x6B, 0x01, 0x6D, 0x01, 0x70, 0x01, 0x72, 0x01, 0x75, 0x01, 0x77, 0x01, 0x79, 0x01, 0x7C, 0x01, +/* 0A30 */ 0xE3, 0x01, 0xEF, 0x02, 0x14, 0x02, 0x8A, 0x02, 0x8D, 0x02, 0xCB, 0x02, 0xF0, 0x03, 0x00, 0x03, +/* 0A40 */ 0x36, 0x03, 0x9B, 0x03, 0xAA, 0x03, 0xDF, 0x04, 0x0C, 0x04, 0x27, 0x04, 0x2F, 0x04, 0x9E, 0x04, +/* 0A50 */ 0xB1, 0x04, 0xDF, 0x05, 0x43, 0x05, 0x45, 0x05, 0x71, 0x05, 0x7A, 0x05, 0x7C, 0x05, 0x8E, 0x05, +/* 0A60 */ 0xA5, 0x05, 0xAD, 0x05, 0xC2, 0x06, 0x18, 0x06, 0x3B, 0x06, 0x4B, 0x06, 0x50, 0x06, 0x58, 0x06, +/* 0A70 */ 0xC3, 0x06, 0xC5, 0x06, 0xC7, 0x06, 0xEB, 0x06, 0xF2, 0x06, 0xF4, 0x07, 0x00, 0x07, 0x04, 0x07, +/* 0A80 */ 0x2D, 0x07, 0x30, 0x07, 0x38, 0x07, 0x43, 0x07, 0x4F, 0x07, 0x5C, 0x07, 0x6E, 0x07, 0x7D, 0x07, +/* 0A90 */ 0x87, 0x07, 0x8C, 0x07, 0x8E, 0x07, 0xA6, 0x07, 0xAF, 0x07, 0xB1, 0x07, 0xB4, 0x07, 0xC9, 0x07, +/* 0AA0 */ 0xCD, 0x07, 0xCF, 0x07, 0xD3, 0x07, 0xDA, 0x07, 0xE0, 0x07, 0xE3, 0x07, 0xF5, 0x08, 0x08, 0x08, +/* 0AB0 */ 0x0A, 0x08, 0x1F, 0x08, 0x28, 0x08, 0x2A, 0x08, 0x2C, 0x08, 0x2E, 0x08, 0x34, 0x08, 0x42, 0x08, +/* 0AC0 */ 0x4E, 0x08, 0x50, 0x08, 0x52, 0x08, 0x56, 0x08, 0x59, 0x08, 0x5C, 0x08, 0x69, 0x08, 0x6B, 0x08, +/* 0AD0 */ 0x6E, 0x08, 0x70, 0x08, 0x74, 0x08, 0x8A, +/* char range info */ +0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, +/* 0AE0 */ 0x00, 0x38, 0x00, 0x68, 0x00, 0xE4, 0x01, 0x70, 0x02, 0x30, 0x02, 0xC6, 0x02, 0xDB, 0x03, 0x36, +/* 0AF0 */ 0x03, 0x91, 0x03, 0xD7, 0x03, 0xE6, 0x03, 0xF2, 0x04, 0x00, 0x04, 0x09, 0x04, 0x58, 0x04, 0xDE, +/* 0B00 */ 0x05, 0x06, 0x05, 0x5C, 0x05, 0xC1, 0x06, 0x14, 0x06, 0x76, 0x06, 0xF1, 0x07, 0x35, 0x07, 0xBD, +/* 0B10 */ 0x08, 0x38, 0x08, 0x46, 0x08, 0x57, 0x08, 0x9A, 0x08, 0xA3, 0x08, 0xE3, 0x09, 0x30, 0x0A, 0x4A, +/* 0B20 */ 0x0A, 0x50, 0x0A, 0xC0, 0x0B, 0x14, 0x0B, 0x8B, 0x0B, 0x90, 0x0B, 0xB2, 0x0C, 0x37, 0x0C, 0x63, +/* 0B30 */ 0x0C, 0x68, 0x0C, 0x8B, 0x0C, 0xF1, 0x0D, 0x07, 0x0D, 0xDC, 0x0D, 0xF2, 0x0D, 0xFB, 0x0E, 0x40, +/* 0B40 */ 0x0E, 0xD4, 0x0F, 0x3A, 0x0F, 0xA6, 0x0F, 0xC4, 0x0F, 0xC9, 0x10, 0x41, 0x11, 0x1D, 0x11, 0x91, +/* 0B50 */ 0x11, 0x99, 0x11, 0xE7, 0x12, 0x05, 0x12, 0x5B, 0x12, 0x91, 0x12, 0xC8, 0x12, 0xD9, 0x12, 0xE4, +/* 0B60 */ 0x12, 0xEB, 0x13, 0x52, 0x13, 0x72, 0x13, 0xC7, 0x13, 0xCF, 0x14, 0x08, 0x14, 0x9B, 0x14, 0xC9, +/* 0B70 */ 0x14, 0xD0, 0x14, 0xEC, 0x15, 0x48, 0x15, 0x61, 0x15, 0xB6, 0x15, 0xC1, 0x15, 0xC9, 0x16, 0x06, +/* 0B80 */ 0x16, 0x5A, 0x16, 0x80, 0x16, 0xD3, 0x17, 0x09, 0x17, 0x0F, 0x17, 0x69, 0x18, 0x12, 0x18, 0x70, +/* 0B90 */ 0x18, 0x76, 0x18, 0xB3, 0x18, 0xF0, 0x18, 0xFF, 0x19, 0x46, 0x08, 0x00, 0x10, 0x07, 0x35, 0x98, +/* 0BA0 */ 0x62, 0x44, 0xFD, 0x2E, 0x86, 0x02, 0x4B, 0xE9, 0x34, 0x86, 0x01, 0x21, 0xA0, 0x01, 0x21, 0xA0, +/* 0BB0 */ 0x1A, 0xA0, 0x9B, 0x58, 0x1E, 0x9B, 0x58, 0x69, 0x1A, 0x09, 0x69, 0x1A, 0x09, 0x52, 0x1A, 0x09, +/* 0BC0 */ 0x52, 0x1A, 0x08, 0x52, 0x25, 0x9E, 0x09, 0x90, 0x01, 0xCD, 0x6F, 0xCD, 0x6F, 0x21, 0x09, 0x90, +/* 0BD0 */ 0x01, 0x10, 0x0C, 0x7F, 0x6E, 0x30, 0x74, 0x1E, 0x03, 0x2F, 0x61, 0x08, 0x24, 0xA5, 0x4F, 0x2F, +/* 0BE0 */ 0x27, 0x24, 0x56, 0x02, 0x28, 0x27, 0x24, 0x66, 0x01, 0x2F, 0x7C, 0x06, 0x24, 0x66, 0x00, 0x28, +/* 0BF0 */ 0x0D, 0x29, 0x00, 0x84, 0x1E, 0x00, 0x28, 0x0D, 0x29, 0x71, 0x69, 0x00, 0x28, 0x0C, 0x72, 0x1F, +/* 0C00 */ 0x52, 0x10, 0x0F, 0x21, 0xA4, 0x58, 0x76, 0x37, 0x7C, 0x06, 0x2F, 0x0D, 0x6F, 0x37, 0x5F, 0x04, +/* 0C10 */ 0x2F, 0x0F, 0x29, 0x1D, 0x1E, 0x01, 0x3F, 0x71, 0x0F, 0x62, 0x74, 0x69, 0x25, 0x45, 0x8A, 0x76, +/* 0C20 */ 0x26, 0x45, 0x8A, 0x76, 0x9C, 0x1F, 0x04, 0x0A, 0x52, 0x2B, 0x64, 0x88, 0x02, 0x25, 0x0B, 0x76, +/* 0C30 */ 0x46, 0x19, 0x34, 0x0C, 0x6F, 0x37, 0x61, 0x04, 0x2F, 0x0E, 0xA8, 0x71, 0x0F, 0x62, 0x50, 0x0F, +/* 0C40 */ 0x29, 0x37, 0x66, 0x01, 0x3F, 0x71, 0x0F, 0x62, 0x74, 0x69, 0xA1, 0x49, 0x01, 0x37, 0x09, 0x6D, +/* 0C50 */ 0x26, 0x1F, 0x04, 0x45, 0x04, 0x2B, 0x0B, 0x3D, 0x04, 0x02, 0x26, 0x9D, 0x8A, 0x4A, 0x26, 0x9D, +/* 0C60 */ 0x8A, 0x4A, 0x25, 0x0C, 0x4A, 0x37, 0x61, 0x04, 0x2F, 0x0E, 0xA8, 0x71, 0x1E, 0x02, 0x34, 0x61, +/* 0C70 */ 0x04, 0x37, 0x56, 0x5C, 0x1E, 0x02, 0x37, 0x08, 0x52, 0x24, 0xA6, 0x58, 0x3D, 0x10, 0x0F, 0xA9, +/* 0C80 */ 0xA2, 0x69, 0x21, 0xA2, 0x69, 0x21, 0xA2, 0x69, 0x21, 0xA2, 0x69, 0x9B, 0xFB, 0x87, 0x89, 0x50, +/* 0C90 */ 0x08, 0x0E, 0x8B, 0x6D, 0x05, 0x25, 0x1F, 0x98, 0x2D, 0x33, 0x01, 0x25, 0x0C, 0x33, 0x59, 0x01, +/* 0CA0 */ 0x04, 0x0A, 0x0F, 0x29, 0x24, 0x49, 0x0C, 0xA1, 0xA2, 0x07, 0x3F, 0x74, 0x27, 0x2E, 0x74, 0x27, +/* 0CB0 */ 0x2E, 0xA2, 0x33, 0x5E, 0x50, 0x93, 0x97, 0x44, 0x84, 0x93, 0x9A, 0x04, 0x46, 0x5C, 0x0C, 0x8B, +/* 0CC0 */ 0x52, 0x06, 0x28, 0x1D, 0x0A, 0x8B, 0x52, 0x03, 0x44, 0x83, 0x1C, 0x69, 0x03, 0x2E, 0x91, 0x33, +/* 0CD0 */ 0x21, 0x5F, 0xE9, 0x34, 0x86, 0x02, 0x21, 0x86, 0x02, 0x50, 0x82, 0x73, 0xE9, 0x82, 0x74, 0x9F, +/* 0CE0 */ 0x24, 0x58, 0x0F, 0x76, 0x26, 0x73, 0x6D, 0x07, 0x43, 0x06, 0x86, 0x75, 0x79, 0x1F, 0x0C, 0x23, +/* 0CF0 */ 0x69, 0x04, 0x34, 0xA2, 0x0A, 0x0D, 0x1E, 0x52, 0x67, 0x9B, 0xA2, 0x69, 0x21, 0xA2, 0x69, 0x21, +/* 0D00 */ 0xA2, 0x69, 0x21, 0xA2, 0x69, 0x2E, 0x1F, 0x07, 0x07, 0x10, 0x18, 0xAA, 0xA9, 0x42, 0x06, 0x6B, +/* 0D10 */ 0x1D, 0x36, 0x41, 0x04, 0x82, 0x38, 0x06, 0x89, 0x2A, 0x2D, 0x06, 0x24, 0x58, 0x52, 0x95, 0x73, +/* 0D20 */ 0x0C, 0x55, 0x0C, 0x87, 0x00, 0x1D, 0x80, 0x8C, 0xA2, 0x87, 0x24, 0x73, 0x06, 0x46, 0x0D, 0x76, +/* 0D30 */ 0x79, 0x08, 0x3D, 0x46, 0x0B, 0x4A, 0x37, 0xA5, 0x75, 0x6B, 0x09, 0x76, 0x58, 0x76, 0x24, 0x38, +/* 0D40 */ 0x07, 0x9C, 0x08, 0x3D, 0x46, 0x0B, 0x4A, 0x53, 0x52, 0x9C, 0xA2, 0x87, 0x24, 0x73, 0x06, 0x84, +/* 0D50 */ 0x80, 0x79, 0x73, 0x0C, 0x55, 0x0B, 0x87, 0x00, 0x0D, 0x76, 0x95, 0x2A, 0x8B, 0x19, 0xA5, 0x75, +/* 0D60 */ 0x79, 0x1D, 0x36, 0x41, 0x04, 0x6E, 0x27, 0x21, 0x0B, 0x6D, 0x00, 0xA2, 0x0C, 0x0E, 0x41, 0x03, +/* 0D70 */ 0x79, 0x2A, 0x72, 0x74, 0x2D, 0x72, 0x4E, 0x7E, 0x0D, 0x76, 0x6E, 0x33, 0x55, 0x0D, 0x52, 0x26, +/* 0D80 */ 0x08, 0x87, 0x00, 0x08, 0x52, 0x37, 0x5F, 0x04, 0x95, 0x1F, 0x27, 0x24, 0x0B, 0x4A, 0x46, 0x98, +/* 0D90 */ 0x07, 0x9C, 0x0B, 0x6D, 0x37, 0x0C, 0x6F, 0x46, 0x0C, 0x6F, 0x79, 0x66, 0x03, 0x37, 0x0B, 0x4A, +/* 0DA0 */ 0x46, 0x98, 0x07, 0x6B, 0x7E, 0x0D, 0x4A, 0x46, 0x08, 0x52, 0x37, 0x5F, 0x04, 0x95, 0x08, 0x87, +/* 0DB0 */ 0x24, 0x1F, 0x33, 0x55, 0x0C, 0x69, 0x95, 0x5F, 0x06, 0xA1, 0x74, 0x2D, 0x72, 0x8C, 0x1D, 0x90, +/* 0DC0 */ 0x82, 0xA2, 0x0C, 0x0E, 0x41, 0x03, 0x79, 0x7E, 0x02, 0x10, 0x15, 0xA4, 0x6E, 0x09, 0x98, 0x90, +/* 0DD0 */ 0x3E, 0x28, 0xE1, 0x2D, 0x6A, 0x34, 0x98, 0x76, 0x55, 0xA0, 0x0A, 0x00, 0x68, 0x76, 0x46, 0x98, +/* 0DE0 */ 0xE9, 0x5E, 0x74, 0x19, 0x37, 0x9D, 0x04, 0xA6, 0x05, 0x46, 0x9D, 0x03, 0x68, 0x4A, 0x46, 0x0D, +/* 0DF0 */ 0x69, 0x2F, 0x98, 0x75, 0x08, 0x27, 0x5C, 0x1E, 0x7A, 0x9D, 0x0A, 0x3F, 0x2A, 0x8B, 0x6F, 0x28, +/* 0E00 */ 0x1F, 0x98, 0x19, 0x37, 0x7E, 0x05, 0x01, 0x4E, 0x64, 0x8B, 0x7A, 0x46, 0x56, 0x03, 0x5E, 0x1D, +/* 0E10 */ 0x0F, 0x69, 0x04, 0x66, 0x7A, 0x00, 0x53, 0x52, 0x9C, 0x0D, 0x80, 0x66, 0x7A, 0x24, 0x0E, 0x6F, +/* 0E20 */ 0x82, 0x2A, 0x76, 0x46, 0x66, 0x7A, 0x66, 0x03, 0x79, 0x45, 0x06, 0x2A, 0x52, 0x0C, 0x76, 0x9C, +/* 0E30 */ 0x9D, 0x05, 0x00, 0x2A, 0x8B, 0x03, 0x9C, 0xA5, 0x6F, 0x82, 0x45, 0x0E, 0x04, 0x95, 0x71, 0x0F, +/* 0E40 */ 0x69, 0x03, 0x2A, 0x1E, 0x69, 0x04, 0x9C, 0x9D, 0x6F, 0xF9, 0xA0, 0x0A, 0x66, 0x72, 0x5E, 0x58, +/* 0E50 */ 0x23, 0x6F, 0x24, 0x66, 0x96, 0x6B, 0x1D, 0x0A, 0x98, 0x90, 0x08, 0x02, 0x46, 0x5B, 0x02, 0x10, +/* 0E60 */ 0x06, 0x7F, 0x6E, 0x0F, 0x4A, 0xAB, 0x08, 0x1A, 0x27, 0x1A, 0x27, 0x21, 0x7C, 0x06, 0x4D, 0x05, +/* 0E70 */ 0x4D, 0x05, 0xCE, 0x04, 0x10, 0x09, 0x21, 0xAA, 0x0B, 0x05, 0x1A, 0xA5, 0x4F, 0x44, 0x5F, 0x08, +/* 0E80 */ 0x21, 0x0B, 0x87, 0xCD, 0x07, 0x21, 0x0B, 0x87, 0x24, 0xF8, 0x09, 0x6C, 0x03, 0xF5, 0x0E, 0x21, +/* 0E90 */ 0x5F, 0x0A, 0x2E, 0xA2, 0x27, 0x6C, 0x05, 0x44, 0x53, 0x1E, 0x03, 0x21, 0xA0, 0x02, 0x4B, 0xE9, +/* 0EA0 */ 0x34, 0x0D, 0x1E, 0x01, 0xF5, 0xE9, 0x34, 0x86, 0x01, 0x21, 0xA0, 0x5A, 0xA1, 0x58, 0x80, 0x9B, +/* 0EB0 */ 0x74, 0x19, 0xCD, 0x08, 0xAB, 0x51, 0xA0, 0x01, 0x18, 0x05, 0x21, 0x73, 0x0B, 0x00, 0x6C, 0x03, +/* 0EC0 */ 0x21, 0x73, 0x0A, 0x1A, 0xA5, 0x62, 0x2E, 0x0D, 0x6D, 0x5E, 0x68, 0x7A, 0x21, 0xA2, 0x01, 0x10, +/* 0ED0 */ 0x09, 0x34, 0xAA, 0x1F, 0x0B, 0x04, 0x9B, 0x58, 0x52, 0x01, 0x21, 0x5F, 0x08, 0x00, 0x6C, 0x02, +/* 0EE0 */ 0x21, 0x73, 0x0A, 0x00, 0x6C, 0x02, 0x21, 0x5F, 0x09, 0xCE, 0x0E, 0x00, 0x6C, 0xEF, 0xCD, 0x09, +/* 0EF0 */ 0xAB, 0x51, 0x0E, 0x69, 0x1A, 0xA0, 0x5A, 0xA1, 0x58, 0x0F, 0x62, 0x2F, 0x58, 0x1E, 0x94, 0x9D, +/* 0F00 */ 0x94, 0x9D, 0x94, 0x0A, 0x1E, 0x03, 0x21, 0xA0, 0x03, 0x4B, 0xE9, 0x25, 0x7C, 0xF1, 0x02, 0x33, +/* 0F10 */ 0x2E, 0xA2, 0x27, 0x21, 0x9D, 0x02, 0x2E, 0x7C, 0xF1, 0x66, 0x06, 0x21, 0x0B, 0x87, 0xCD, 0x07, +/* 0F20 */ 0x4B, 0xF1, 0x66, 0x05, 0x21, 0x08, 0x76, 0x00, 0x1A, 0x59, 0x10, 0x0D, 0x82, 0x1A, 0x3B, 0x0B, +/* 0F30 */ 0x6D, 0x9B, 0x58, 0x3D, 0x1A, 0x09, 0x4A, 0x9B, 0x05, 0x06, 0x00, 0x74, 0x6F, 0x00, 0x42, 0x06, +/* 0F40 */ 0x34, 0x0C, 0x69, 0x08, 0x08, 0x6F, 0x07, 0x0E, 0x52, 0x00, 0x50, 0x0A, 0x1C, 0x2D, 0x69, 0x97, +/* 0F50 */ 0x25, 0x1F, 0xA5, 0x27, 0x03, 0x2F, 0x58, 0x52, 0x3D, 0x9B, 0x74, 0x69, 0x02, 0x0D, 0x6F, 0x34, +/* 0F60 */ 0x1D, 0x27, 0x42, 0x0F, 0x29, 0x2F, 0x74, 0x52, 0x37, 0x0C, 0x6F, 0x2F, 0x1F, 0xEF, 0x71, 0x02, +/* 0F70 */ 0x10, 0x0F, 0x95, 0x60, 0x0E, 0x6F, 0xDD, 0x08, 0xDD, 0x08, 0x28, 0xDA, 0x6F, 0xDD, 0x08, 0x10, +/* 0F80 */ 0x07, 0x2F, 0xAA, 0xA4, 0x60, 0x91, 0xBC, 0x07, 0x1A, 0x0B, 0x4F, 0x10, 0x0C, 0xA9, 0x60, 0xE5, +/* 0F90 */ 0x04, 0x37, 0x68, 0x23, 0x01, 0x24, 0x68, 0x23, 0x01, 0x10, 0x07, 0x2F, 0xAA, 0xA4, 0x60, 0xD6, +/* 0FA0 */ 0x91, 0x9A, 0x10, 0x0F, 0x37, 0xA9, 0xA2, 0x0A, 0x06, 0x9B, 0x58, 0x69, 0x4D, 0x0A, 0x21, 0x5F, +/* 0FB0 */ 0x06, 0x18, 0x03, 0x21, 0x09, 0x69, 0x4D, 0x0B, 0xAB, 0x07, 0x28, 0x2A, 0x72, 0x6C, 0xCE, 0x0C, +/* 0FC0 */ 0xAB, 0x08, 0x8C, 0x68, 0x72, 0x6C, 0x01, 0x21, 0x0B, 0x0F, 0x51, 0x0E, 0x4A, 0x65, 0x05, 0x21, +/* 0FD0 */ 0xA5, 0x4F, 0x28, 0x58, 0x52, 0x1A, 0x0E, 0x76, 0x65, 0x06, 0x18, 0x5A, 0xA1, 0x58, 0x69, 0x4D, +/* 0FE0 */ 0x0A, 0x44, 0x1F, 0x27, 0x21, 0x66, 0x03, 0x21, 0x09, 0x69, 0xCE, 0x0B, 0x4D, 0x08, 0x21, 0x1F, +/* 0FF0 */ 0x01, 0x10, 0x11, 0x35, 0x1D, 0x36, 0x52, 0x8F, 0x28, 0x08, 0x2D, 0x69, 0x04, 0x24, 0xA6, 0x0D, +/* 1000 */ 0x77, 0x45, 0x75, 0x26, 0x7C, 0x75, 0x42, 0x30, 0x95, 0x2A, 0x6F, 0xA1, 0x0D, 0x87, 0x79, 0x58, +/* 1010 */ 0x1E, 0x03, 0xA1, 0x45, 0x04, 0x3F, 0x0D, 0x1E, 0x01, 0x2A, 0x6F, 0x3F, 0x0F, 0x69, 0x46, 0x71, +/* 1020 */ 0x0F, 0x76, 0x26, 0x5F, 0x0C, 0x89, 0x5F, 0x0C, 0x9C, 0x71, 0x0F, 0x6D, 0x89, 0x5F, 0x0D, 0x9C, +/* 1030 */ 0x71, 0x33, 0x89, 0x61, 0x0D, 0x9C, 0x71, 0x33, 0x89, 0x61, 0x0D, 0x9C, 0x71, 0x0F, 0x6D, 0x89, +/* 1040 */ 0x5F, 0x0D, 0x26, 0x5F, 0x0C, 0x89, 0x5F, 0x0C, 0x3F, 0x0F, 0x69, 0x37, 0x1D, 0x0F, 0x76, 0x3F, +/* 1050 */ 0x0D, 0x1E, 0x01, 0x2A, 0x6F, 0x3F, 0x9D, 0x03, 0xA1, 0x45, 0x04, 0x95, 0x2A, 0x6F, 0xA1, 0x98, +/* 1060 */ 0xE9, 0x6B, 0x98, 0x75, 0x42, 0x30, 0x79, 0x2A, 0x52, 0x77, 0x45, 0x75, 0x25, 0x08, 0x2D, 0x69, +/* 1070 */ 0x04, 0x34, 0x1D, 0x0A, 0x0E, 0x52, 0x8F, 0x10, 0x0C, 0x24, 0x1A, 0xA4, 0x1F, 0xA0, 0x06, 0x9B, +/* 1080 */ 0xA2, 0x1C, 0x19, 0x46, 0x50, 0x0A, 0x2D, 0x06, 0x28, 0x64, 0x6D, 0x78, 0x95, 0x7E, 0x0E, 0x27, +/* 1090 */ 0x74, 0x19, 0x3F, 0x1D, 0x0C, 0x03, 0x24, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0x10, +/* 10A0 */ 0x0E, 0x7F, 0x1D, 0x0A, 0x0D, 0x52, 0x88, 0x46, 0x50, 0x0A, 0x23, 0x08, 0x2F, 0xA0, 0x7D, 0x04, +/* 10B0 */ 0x45, 0xA8, 0x4E, 0x71, 0x0E, 0xA8, 0x1D, 0x0F, 0x69, 0x3F, 0x1F, 0x06, 0x89, 0xA3, 0x62, 0x2F, +/* 10C0 */ 0x58, 0x0F, 0x29, 0x44, 0x53, 0x0F, 0x29, 0x21, 0xA0, 0x03, 0x2E, 0x61, 0x0E, 0x28, 0x2A, 0x76, +/* 10D0 */ 0xF5, 0x62, 0x9B, 0xD1, 0x2E, 0x38, 0x57, 0x28, 0x85, 0x80, 0x34, 0x58, 0x27, 0x2E, 0xA5, 0x76, +/* 10E0 */ 0xCD, 0x6A, 0x9B, 0x38, 0x75, 0xA1, 0x50, 0x0D, 0x69, 0x03, 0x2E, 0xA0, 0x08, 0x31, 0x03, 0x50, +/* 10F0 */ 0x8A, 0x33, 0x50, 0x8A, 0x30, 0x10, 0x0E, 0x35, 0xA2, 0x0A, 0x0D, 0x52, 0x88, 0x34, 0x1F, 0x0B, +/* 1100 */ 0x23, 0x09, 0x24, 0x50, 0x98, 0x4A, 0x05, 0x40, 0x93, 0x06, 0x4E, 0xFB, 0x0D, 0x03, 0x46, 0x5F, +/* 1110 */ 0x0E, 0x37, 0x50, 0x24, 0x58, 0x1E, 0x03, 0x21, 0xA5, 0x29, 0x6C, 0x94, 0xA0, 0x01, 0x2F, 0x2A, +/* 1120 */ 0x4A, 0x9B, 0x43, 0x9D, 0x0A, 0x9B, 0x5F, 0x52, 0x05, 0x28, 0x1D, 0x2D, 0x8D, 0x82, 0x50, 0x03, +/* 1130 */ 0x0A, 0x0F, 0x52, 0x01, 0x6C, 0x08, 0x21, 0x5F, 0x51, 0x0F, 0x69, 0xAB, 0xF1, 0x66, 0x0A, 0x3F, +/* 1140 */ 0x91, 0x0B, 0x01, 0x37, 0x7E, 0xA3, 0x29, 0x3F, 0x56, 0x0E, 0x08, 0x05, 0x40, 0x98, 0x76, 0x25, +/* 1150 */ 0xA2, 0x0E, 0x23, 0x97, 0x2F, 0x83, 0x0C, 0x0E, 0x52, 0x88, 0x10, 0x0F, 0x81, 0x3A, 0x50, 0x01, +/* 1160 */ 0x1A, 0x74, 0x0E, 0x8D, 0xF5, 0x0D, 0x8C, 0x68, 0x6F, 0x21, 0xA0, 0x5D, 0x1F, 0x33, 0x6C, 0x05, +/* 1170 */ 0xF5, 0x0E, 0x28, 0x2A, 0x6F, 0x21, 0xA0, 0x02, 0x71, 0x1E, 0x03, 0x3F, 0x1F, 0x33, 0x1D, 0x1E, +/* 1180 */ 0x03, 0x34, 0x45, 0x05, 0x37, 0x66, 0x03, 0x34, 0x0D, 0x69, 0x46, 0x56, 0x03, 0x79, 0x2A, 0x6F, +/* 1190 */ 0x46, 0xA5, 0x62, 0x26, 0xA0, 0x77, 0x2B, 0x9D, 0x77, 0x02, 0x26, 0x93, 0x8A, 0x76, 0x26, 0x93, +/* 11A0 */ 0x8A, 0x76, 0x44, 0x45, 0x03, 0x6C, 0x03, 0x6C, 0x03, 0x6C, 0x03, 0x6C, 0x03, 0x10, 0x0F, 0x7F, +/* 11B0 */ 0x71, 0x43, 0x31, 0x02, 0x25, 0x7C, 0x23, 0x6F, 0x34, 0x0E, 0x8A, 0x06, 0x25, 0x7C, 0x51, 0x1C, +/* 11C0 */ 0x51, 0x1C, 0x51, 0x1C, 0x51, 0x1C, 0x51, 0x0E, 0x6D, 0x06, 0x0C, 0x0E, 0x41, 0x05, 0x28, 0x0E, +/* 11D0 */ 0x23, 0x4A, 0x2F, 0x0E, 0x52, 0x07, 0x05, 0x04, 0x45, 0xA8, 0x00, 0x50, 0x01, 0xA1, 0x56, 0x0D, +/* 11E0 */ 0x1A, 0xFD, 0x28, 0x58, 0x0F, 0x29, 0x21, 0x78, 0x34, 0x9D, 0x05, 0x21, 0xA0, 0x03, 0x00, 0x50, +/* 11F0 */ 0x89, 0x61, 0x0E, 0x3F, 0xA2, 0x0E, 0xEF, 0x58, 0x0F, 0x6F, 0x50, 0x0D, 0x1E, 0x7D, 0x04, 0x05, +/* 1200 */ 0xA0, 0x0D, 0x3F, 0x1F, 0xA3, 0x2D, 0x6D, 0x02, 0x2F, 0xA2, 0x0B, 0x0D, 0x52, 0x0B, 0x05, 0x10, +/* 1210 */ 0x10, 0x00, 0xA4, 0xA2, 0x36, 0x52, 0x09, 0x03, 0x46, 0x50, 0x0A, 0x23, 0x01, 0x2F, 0xA0, 0x99, +/* 1220 */ 0x06, 0x0C, 0x08, 0x26, 0xFB, 0x33, 0x01, 0x2E, 0xFD, 0x89, 0x68, 0x4A, 0x6C, 0x94, 0x86, 0x01, +/* 1230 */ 0x1F, 0x03, 0x01, 0x28, 0x0F, 0x52, 0x84, 0xA3, 0x33, 0x5A, 0x7E, 0x33, 0x06, 0x2D, 0x69, 0x5A, +/* 1240 */ 0x5F, 0x0D, 0x6D, 0x59, 0x92, 0x33, 0x4E, 0x71, 0x0F, 0x33, 0x01, 0x46, 0xFD, 0x79, 0x71, 0x0F, +/* 1250 */ 0x87, 0x46, 0x74, 0x19, 0x4E, 0x5F, 0x0A, 0x00, 0x2A, 0x6F, 0x4E, 0x7E, 0x33, 0x37, 0x1D, 0x30, +/* 1260 */ 0x26, 0x0E, 0x52, 0x37, 0x1D, 0x0F, 0x6F, 0x3F, 0xA0, 0x01, 0xA1, 0x56, 0x06, 0x3F, 0x56, 0x05, +/* 1270 */ 0x00, 0x58, 0x1E, 0x5A, 0x73, 0x6A, 0x71, 0x0F, 0x6D, 0x34, 0xA5, 0x6D, 0x06, 0x40, 0x93, 0x03, +/* 1280 */ 0x2F, 0x09, 0x23, 0x05, 0x28, 0xA2, 0x36, 0x52, 0x09, 0x03, 0x10, 0x0D, 0x7F, 0xE5, 0x04, 0x2B, +/* 1290 */ 0x25, 0x66, 0x8A, 0x5A, 0x66, 0x8A, 0x02, 0x2E, 0x7C, 0xF1, 0x05, 0x27, 0x21, 0xA0, 0x5D, 0x1F, +/* 12A0 */ 0x33, 0x21, 0xA5, 0x29, 0xF5, 0x0E, 0x00, 0xD5, 0x28, 0x58, 0x1E, 0x03, 0x2E, 0x73, 0x0C, 0x18, +/* 12B0 */ 0x07, 0x4B, 0xE9, 0x26, 0x71, 0x0F, 0x76, 0x6C, 0x05, 0x21, 0x0E, 0x69, 0x28, 0x2A, 0x6F, 0x21, +/* 12C0 */ 0xA0, 0x03, 0x2E, 0x5F, 0x0C, 0x2E, 0x74, 0x19, 0x44, 0xA2, 0x0B, 0x96, 0x95, 0x50, 0x10, 0x10, +/* 12D0 */ 0xA4, 0x01, 0x3C, 0x0E, 0xA7, 0x08, 0x02, 0x28, 0x64, 0x2D, 0x9F, 0x34, 0x38, 0x4A, 0x55, 0x9D, +/* 12E0 */ 0x62, 0x26, 0x08, 0x27, 0xFB, 0x0F, 0x76, 0x25, 0x86, 0x89, 0x0E, 0x52, 0x25, 0x0E, 0x52, 0x89, +/* 12F0 */ 0x0D, 0x69, 0x25, 0x0D, 0x69, 0x89, 0x0D, 0x52, 0x25, 0x9D, 0x05, 0x24, 0x71, 0x0F, 0x6F, 0x25, +/* 1300 */ 0x38, 0x9F, 0x37, 0xDE, 0x01, 0x34, 0x64, 0x6D, 0x06, 0x0C, 0x6D, 0x02, 0x28, 0xE1, 0x8B, 0x7A, +/* 1310 */ 0x28, 0xC2, 0x0B, 0x08, 0x93, 0xEC, 0x34, 0xA5, 0x6F, 0x24, 0x42, 0x0E, 0x27, 0x4E, 0x1F, 0x33, +/* 1320 */ 0xA1, 0x38, 0x4F, 0x4E, 0x45, 0x05, 0x89, 0x56, 0x08, 0x26, 0xA0, 0x03, 0x46, 0x71, 0x33, 0x26, +/* 1330 */ 0xA0, 0x02, 0x89, 0x5F, 0x0A, 0x26, 0x9D, 0x05, 0x00, 0x2A, 0x6F, 0x9C, 0x71, 0x1E, 0x6A, 0x24, +/* 1340 */ 0x7E, 0x98, 0x62, 0x6B, 0x58, 0x1E, 0x70, 0x55, 0x07, 0x0E, 0x30, 0x50, 0x0A, 0x23, 0x4A, 0x25, +/* 1350 */ 0x1D, 0x0A, 0x63, 0xA7, 0x09, 0x03, 0x10, 0x10, 0x35, 0x71, 0x09, 0x98, 0x41, 0x06, 0x28, 0x74, +/* 1360 */ 0x2D, 0x33, 0x24, 0xA6, 0x70, 0x04, 0x06, 0xA3, 0x4A, 0x25, 0x73, 0x75, 0x7E, 0xFD, 0x6B, 0x2A, +/* 1370 */ 0x6F, 0xA1, 0x56, 0x08, 0x3F, 0x9D, 0x04, 0x37, 0x71, 0x33, 0x79, 0x58, 0x1E, 0x02, 0x89, 0x0F, +/* 1380 */ 0x69, 0x3F, 0xA0, 0x02, 0x89, 0x93, 0x3F, 0x9D, 0x03, 0x89, 0x93, 0x01, 0x4E, 0x74, 0x27, 0x37, +/* 1390 */ 0x71, 0x8B, 0x3F, 0x5F, 0x57, 0x02, 0x98, 0x69, 0x25, 0x9D, 0x0D, 0x06, 0x40, 0x0E, 0x1C, 0x52, +/* 13A0 */ 0x25, 0x91, 0x2D, 0x9F, 0x33, 0x34, 0x74, 0x0C, 0xA7, 0x09, 0x02, 0x05, 0x27, 0x44, 0x53, 0x1E, +/* 13B0 */ 0x03, 0x2E, 0x5F, 0x0C, 0x8C, 0x50, 0xA3, 0x29, 0x44, 0x91, 0x0F, 0x76, 0x9B, 0xA2, 0x98, 0x6D, +/* 13C0 */ 0x01, 0x28, 0xA2, 0x0C, 0x8B, 0x8D, 0x34, 0x1F, 0x93, 0x6D, 0x04, 0x44, 0x98, 0x88, 0x89, 0x5C, +/* 13D0 */ 0x01, 0x10, 0x07, 0x5E, 0x1A, 0x60, 0xD6, 0x91, 0x9A, 0x1A, 0x1A, 0x3B, 0xD6, 0x91, 0x9A, 0x10, +/* 13E0 */ 0x07, 0x5E, 0x1A, 0x60, 0xD6, 0x91, 0x9A, 0x1A, 0x1A, 0x3B, 0x91, 0xBC, 0x07, 0x1A, 0x0B, 0x4F, +/* 13F0 */ 0x10, 0x0F, 0x9E, 0x7F, 0x1F, 0x01, 0x5E, 0x50, 0x09, 0x6F, 0x82, 0x50, 0x45, 0x69, 0xA1, 0x50, +/* 1400 */ 0x08, 0x93, 0x4A, 0x02, 0x37, 0x50, 0x08, 0x93, 0x9A, 0x02, 0x37, 0x50, 0x08, 0x1C, 0x69, 0x67, +/* 1410 */ 0x00, 0x28, 0x45, 0x0E, 0x67, 0x44, 0x45, 0x06, 0x2E, 0x74, 0x1E, 0x6D, 0x05, 0xA1, 0x5C, 0xA0, +/* 1420 */ 0x6D, 0x05, 0x44, 0x84, 0xA0, 0x6D, 0x05, 0x44, 0x84, 0xA0, 0x52, 0x05, 0x44, 0x84, 0x86, 0xF1, +/* 1430 */ 0x84, 0x0C, 0x06, 0x10, 0x0F, 0x48, 0x60, 0xE5, 0xE0, 0x89, 0xE5, 0xE0, 0x10, 0x0F, 0x4E, 0xAA, +/* 1440 */ 0xA4, 0x1F, 0x95, 0x50, 0xA7, 0x05, 0x18, 0x52, 0x05, 0x44, 0xA2, 0x86, 0x6D, 0x05, 0x44, 0x84, +/* 1450 */ 0x86, 0x6D, 0x05, 0x44, 0x84, 0xA0, 0x6D, 0x05, 0x44, 0x84, 0xA0, 0x4F, 0x82, 0x50, 0xA0, 0x5D, +/* 1460 */ 0x01, 0x08, 0x1C, 0x87, 0x46, 0x50, 0x08, 0x1C, 0x69, 0x67, 0x37, 0x50, 0x08, 0x1C, 0x69, 0x67, +/* 1470 */ 0x25, 0x1F, 0x9D, 0x69, 0x67, 0x3F, 0x2A, 0x69, 0x67, 0x2E, 0x0C, 0x8D, 0x10, 0x0E, 0x35, 0x6E, +/* 1480 */ 0x3C, 0x0E, 0x90, 0x67, 0x28, 0xA5, 0x2D, 0x69, 0x03, 0x34, 0x45, 0x0D, 0x07, 0x04, 0x05, 0xA0, +/* 1490 */ 0x0D, 0x25, 0x74, 0x4A, 0xA1, 0xA0, 0x05, 0x3F, 0x1F, 0x89, 0xA5, 0x6F, 0x6C, 0x07, 0x8C, 0x50, +/* 14A0 */ 0x98, 0x62, 0x2F, 0x1F, 0xA3, 0x76, 0x44, 0x64, 0x4A, 0x89, 0x68, 0x27, 0x2E, 0x98, 0x29, 0x24, +/* 14B0 */ 0xF8, 0x0A, 0x21, 0x66, 0x06, 0x18, 0x05, 0x44, 0x1F, 0x06, 0x06, 0x02, 0x95, 0xAA, 0x1D, 0x0D, +/* 14C0 */ 0x9F, 0xF5, 0x69, 0xF5, 0x69, 0x9B, 0x1D, 0x0D, 0x9F, 0x10, 0x1E, 0x46, 0xA4, 0x1F, 0x07, 0x0A, +/* 14D0 */ 0x0D, 0x1C, 0x90, 0x7D, 0x01, 0x3F, 0x92, 0x8A, 0x69, 0x67, 0x79, 0x74, 0x8B, 0x9A, 0x06, 0x43, +/* 14E0 */ 0x05, 0x07, 0x0A, 0x1C, 0x52, 0x03, 0x95, 0x9D, 0x0D, 0x05, 0x82, 0x7E, 0x45, 0x0E, 0x03, 0x5E, +/* 14F0 */ 0x08, 0x33, 0x01, 0x95, 0x64, 0x96, 0x46, 0x1D, 0x33, 0x01, 0x8C, 0x2A, 0x76, 0x82, 0x98, 0x75, +/* 1500 */ 0x24, 0x1F, 0x03, 0x02, 0x89, 0x9D, 0x03, 0xA1, 0x56, 0x06, 0x37, 0x7E, 0x09, 0x93, 0x52, 0x3E, +/* 1510 */ 0x37, 0x5F, 0x09, 0xA1, 0x0D, 0x69, 0x24, 0x1F, 0x0D, 0x2D, 0x33, 0x46, 0x0C, 0x69, 0x24, 0x71, +/* 1520 */ 0x30, 0x37, 0xA0, 0x67, 0x01, 0x04, 0x0D, 0x6D, 0x46, 0x45, 0x03, 0x37, 0xA5, 0x72, 0x1D, 0x0F, +/* 1530 */ 0x6F, 0x46, 0x0B, 0x6D, 0xFB, 0x0F, 0x29, 0x00, 0x53, 0x1E, 0x01, 0x00, 0x53, 0x1E, 0x01, 0x46, +/* 1540 */ 0x0B, 0x6D, 0x46, 0x66, 0x06, 0x37, 0x0C, 0x69, 0x46, 0x0D, 0x6D, 0xA1, 0x0B, 0x6D, 0x00, 0x1D, +/* 1550 */ 0x27, 0x37, 0x0D, 0x52, 0x46, 0x0F, 0x76, 0xA1, 0x0B, 0x6D, 0x00, 0x1D, 0x19, 0x24, 0x0E, 0x6D, +/* 1560 */ 0x37, 0x61, 0x09, 0xA1, 0x0B, 0x6D, 0x46, 0x66, 0x05, 0x37, 0x0D, 0x6D, 0x37, 0x61, 0x09, 0xA1, +/* 1570 */ 0x0B, 0x6D, 0x46, 0x56, 0x03, 0x37, 0x0D, 0x52, 0x46, 0x0F, 0x76, 0xA1, 0x0B, 0x6D, 0x46, 0x9D, +/* 1580 */ 0x46, 0xA0, 0x46, 0xDE, 0xA1, 0xDE, 0x46, 0x0D, 0x3D, 0x46, 0x45, 0x03, 0x37, 0x08, 0x80, 0x42, +/* 1590 */ 0x8B, 0x01, 0x24, 0x66, 0x05, 0x37, 0xA2, 0x27, 0x37, 0x5F, 0x0E, 0x77, 0x08, 0x3D, 0x09, 0x6D, +/* 15A0 */ 0x05, 0xC2, 0x0C, 0xA1, 0x61, 0x0C, 0xFB, 0x2D, 0x0E, 0x02, 0x38, 0x8B, 0x75, 0x58, 0x1E, 0xEF, +/* 15B0 */ 0x1D, 0x36, 0x8E, 0x02, 0x71, 0x36, 0x8E, 0x02, 0xA1, 0x71, 0x1E, 0x51, 0x9D, 0x08, 0x5E, 0x50, +/* 15C0 */ 0xA3, 0x6F, 0x44, 0x1F, 0x98, 0x6D, 0x04, 0x82, 0x1F, 0x9C, 0x7E, 0xA0, 0x52, 0x08, 0x05, 0x2B, +/* 15D0 */ 0x06, 0x09, 0x98, 0x01, 0x4E, 0xA2, 0x98, 0x8A, 0x29, 0x26, 0x71, 0x08, 0x0B, 0x0D, 0x1C, 0xA7, +/* 15E0 */ 0x0A, 0x06, 0x02, 0x10, 0x11, 0x24, 0xA4, 0xB6, 0xCC, 0x10, 0x12, 0x35, 0x04, 0x2D, 0xA7, 0x0A, +/* 15F0 */ 0x06, 0x01, 0x26, 0x1D, 0x8A, 0xEC, 0x68, 0x6D, 0x2B, 0x06, 0xA0, 0x29, 0xF6, 0xFB, 0x0F, 0x69, +/* 1600 */ 0x00, 0xE2, 0x98, 0x72, 0xE2, 0x0A, 0x0F, 0x29, 0xE2, 0x0A, 0x0F, 0x29, 0xE2, 0xFD, 0x49, 0x0B, +/* 1610 */ 0xA1, 0xA5, 0x76, 0x24, 0x49, 0x0C, 0x2B, 0x5B, 0x33, 0x01, 0x9C, 0x1D, 0x0F, 0x23, 0xEC, 0x00, +/* 1620 */ 0x68, 0x23, 0x69, 0x8D, 0xF6, 0x00, 0x7E, 0x03, 0x9D, 0x7A, 0xE2, 0x08, 0x33, 0xE2, 0x61, 0xE9, +/* 1630 */ 0x82, 0x4C, 0x89, 0xA3, 0x72, 0x49, 0x0B, 0x82, 0xA3, 0x72, 0x49, 0x0B, 0x89, 0x61, 0x4F, 0x9C, +/* 1640 */ 0x4C, 0x00, 0x58, 0x0F, 0x6D, 0x00, 0x49, 0x0C, 0x2B, 0x05, 0x07, 0x0D, 0x8B, 0x03, 0x79, 0x1D, +/* 1650 */ 0x8A, 0x52, 0x04, 0x9C, 0x1D, 0x0F, 0x2D, 0xA7, 0x7D, 0x10, 0x10, 0xE7, 0x00, 0x09, 0x23, 0x3D, +/* 1660 */ 0x01, 0x25, 0xA0, 0x0E, 0x08, 0xF9, 0x0C, 0x69, 0x03, 0x26, 0x74, 0x1E, 0x7A, 0x46, 0x74, 0x05, +/* 1670 */ 0x3F, 0x5F, 0x4F, 0x44, 0x45, 0x09, 0xF5, 0x72, 0x2E, 0x61, 0xE9, 0x68, 0x52, 0x28, 0x2A, 0x6D, +/* 1680 */ 0x18, 0x0B, 0x18, 0x0B, 0x28, 0x2A, 0x6D, 0x00, 0xCD, 0xF1, 0x01, 0x8B, 0x01, 0xF5, 0x72, 0x6C, +/* 1690 */ 0x09, 0x44, 0x1F, 0x8B, 0x03, 0x6C, 0x7A, 0x00, 0xFB, 0x09, 0x34, 0xA0, 0x0E, 0x08, 0xF9, 0x0C, +/* 16A0 */ 0x27, 0x00, 0x50, 0x0A, 0x23, 0x3D, 0x01, 0x5C, 0x09, 0x98, 0xA7, 0x09, 0x04, 0x10, 0x13, 0x35, +/* 16B0 */ 0x04, 0x2D, 0x0D, 0x0C, 0x09, 0x05, 0x01, 0x26, 0x1D, 0x8A, 0xEC, 0x68, 0x6D, 0x43, 0x05, 0x07, +/* 16C0 */ 0x0B, 0x0F, 0x27, 0xF6, 0x46, 0x66, 0x72, 0xE2, 0xA5, 0x6D, 0xE2, 0x7C, 0x62, 0x79, 0x4C, 0x89, +/* 16D0 */ 0x9D, 0x08, 0x49, 0x0B, 0x37, 0xFB, 0x33, 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x52, 0x49, 0x0B, 0x82, +/* 16E0 */ 0x5F, 0x0E, 0x49, 0x0B, 0xA1, 0x1F, 0x8B, 0x49, 0x0B, 0x82, 0x5F, 0x0E, 0x49, 0x0B, 0xA1, 0x71, +/* 16F0 */ 0x0F, 0x52, 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x6D, 0x49, 0x0B, 0x82, 0x56, 0x0A, 0x49, 0x0B, 0x37, +/* 1700 */ 0x58, 0x27, 0x49, 0x0B, 0x89, 0x73, 0x62, 0x79, 0x4C, 0xA1, 0x08, 0x33, 0x26, 0x4C, 0x37, 0x74, +/* 1710 */ 0x8B, 0x03, 0x00, 0x49, 0x0C, 0x43, 0x40, 0x86, 0x29, 0x9C, 0x1D, 0x8A, 0x0C, 0x03, 0x4E, 0x1D, +/* 1720 */ 0x2D, 0xA7, 0x09, 0x05, 0x10, 0x0F, 0x35, 0x04, 0xD4, 0x10, 0x0E, 0x35, 0x04, 0x8A, 0x29, 0x68, +/* 1730 */ 0x8A, 0x03, 0x68, 0x6D, 0x31, 0x34, 0x20, 0x20, 0x22, 0x04, 0x8A, 0x01, 0x26, 0x1D, 0x8A, 0x01, +/* 1740 */ 0x00, 0x68, 0x6D, 0x2B, 0x2B, 0x2F, 0x20, 0x20, 0x20, 0x22, 0x4C, 0x10, 0x12, 0x24, 0xA4, 0x83, +/* 1750 */ 0x0C, 0x1C, 0x41, 0x3E, 0x34, 0x74, 0x0E, 0x23, 0x9F, 0x25, 0x09, 0x8B, 0x7D, 0x04, 0x05, 0x09, +/* 1760 */ 0x1C, 0x75, 0x9C, 0x56, 0x0E, 0x03, 0x37, 0x1F, 0x88, 0x26, 0x73, 0x62, 0x9B, 0xA5, 0x76, 0x4B, +/* 1770 */ 0x72, 0x8C, 0x50, 0x8B, 0x01, 0x24, 0xF8, 0xF1, 0x66, 0x0C, 0x37, 0x71, 0x43, 0x2B, 0x02, 0x5E, +/* 1780 */ 0xFB, 0x33, 0xA1, 0x98, 0x8B, 0x4A, 0x5E, 0xFB, 0x33, 0xA1, 0xA0, 0x1E, 0x4A, 0x8C, 0x2A, 0x6D, +/* 1790 */ 0xA1, 0x1D, 0x30, 0x5E, 0x1D, 0x0F, 0x52, 0xA1, 0x1D, 0x30, 0x95, 0x7E, 0x8B, 0xA1, 0x1D, 0x30, +/* 17A0 */ 0x9C, 0x93, 0x03, 0x46, 0x1D, 0x30, 0x9C, 0x09, 0x27, 0x46, 0x1D, 0x30, 0x95, 0x71, 0x0F, 0x87, +/* 17B0 */ 0x37, 0x1D, 0x30, 0x6B, 0x58, 0x33, 0x01, 0x2A, 0x4A, 0x4E, 0x7E, 0x98, 0x52, 0x07, 0x43, 0x06, +/* 17C0 */ 0x0A, 0x1E, 0x4A, 0x3F, 0x91, 0x23, 0x33, 0x03, 0x26, 0x1D, 0x09, 0x0D, 0x1C, 0x41, 0x08, 0x02, +/* 17D0 */ 0x10, 0x13, 0x35, 0x4C, 0x37, 0x1D, 0x1E, 0xC3, 0xC3, 0x0A, 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x76, +/* 17E0 */ 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x76, 0x49, 0x0C, 0x31, 0xA5, 0x76, 0x49, 0x0F, 0x8A, 0x76, 0x49, +/* 17F0 */ 0x1E, 0x8A, 0xC3, 0xC3, 0xC3, 0x0A, 0x49, 0x0B, 0x46, 0x1D, 0x0F, 0x76, 0x10, 0x08, 0x35, 0x22, +/* 1800 */ 0xCA, 0x10, 0x09, 0x00, 0x35, 0x86, 0x03, 0x4B, 0xEB, 0x4B, 0xEB, 0x4B, 0x62, 0x44, 0x86, 0x02, +/* 1810 */ 0x21, 0xFD, 0x2E, 0x93, 0x5E, 0xF6, 0x82, 0x50, 0x0D, 0x19, 0x9B, 0x05, 0x0D, 0x33, 0x2E, 0xA0, +/* 1820 */ 0x0A, 0x2E, 0xA2, 0x88, 0x10, 0x11, 0xAA, 0xA9, 0xE2, 0x73, 0x62, 0x79, 0x4C, 0xA1, 0x0B, 0x19, +/* 1830 */ 0x49, 0x0B, 0xA1, 0xA5, 0x76, 0xF6, 0x00, 0x71, 0x0F, 0x52, 0x01, 0xF6, 0x00, 0x7E, 0x0D, 0x1E, +/* 1840 */ 0xEF, 0xF6, 0x53, 0x27, 0x24, 0xF6, 0x42, 0x33, 0x37, 0xF6, 0x38, 0x75, 0x00, 0xF6, 0xA3, 0x29, +/* 1850 */ 0x25, 0x1D, 0x33, 0x45, 0x09, 0x82, 0x49, 0x36, 0x80, 0x3F, 0x1D, 0x33, 0x56, 0x57, 0x00, 0xF6, +/* 1860 */ 0xA0, 0x09, 0x46, 0xF6, 0x38, 0x72, 0x37, 0xF6, 0x00, 0x56, 0x57, 0x26, 0x4C, 0x24, 0xA0, 0x0A, +/* 1870 */ 0x24, 0xF6, 0x24, 0x38, 0x29, 0x68, 0x3D, 0xFB, 0x0F, 0x87, 0xF6, 0x46, 0xA0, 0x0A, 0xF6, 0x46, +/* 1880 */ 0x38, 0x29, 0xE2, 0x56, 0x96, 0x49, 0x0B, 0x82, 0xA0, 0x0A, 0x10, 0x0E, 0x35, 0x20, 0xCA, 0x4C, +/* 1890 */ 0xCD, 0x0D, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x05, 0x68, 0x8A, 0x09, 0x68, 0x23, 0x27, +/* 18A0 */ 0x10, 0x17, 0x00, 0x35, 0x09, 0x0F, 0x27, 0x82, 0xA0, 0x29, 0x8C, 0x58, 0x0F, 0x33, 0x82, 0x1E, +/* 18B0 */ 0x19, 0x95, 0xA0, 0x69, 0x37, 0x1D, 0x1E, 0x27, 0x79, 0xDE, 0x1E, 0x03, 0xA1, 0xA5, 0x98, 0x6F, +/* 18C0 */ 0x79, 0x0D, 0x4A, 0x27, 0xA1, 0x0B, 0x4A, 0x0F, 0x76, 0x79, 0x1E, 0x3C, 0x3D, 0xA1, 0x0E, 0x29, +/* 18D0 */ 0x0E, 0x3D, 0x6B, 0x7E, 0x27, 0x08, 0x69, 0x24, 0x71, 0x1E, 0x02, 0x0D, 0x6D, 0x5E, 0x1F, 0x27, +/* 18E0 */ 0x04, 0x0F, 0x62, 0x74, 0x52, 0x00, 0xDE, 0x5E, 0x71, 0x19, 0x1C, 0x07, 0x00, 0x53, 0x4A, 0x00, +/* 18F0 */ 0x0B, 0x69, 0x8C, 0x1D, 0x0F, 0x29, 0x00, 0x0B, 0x3D, 0x37, 0x0E, 0x29, 0x00, 0xA0, 0x89, 0x2A, +/* 1900 */ 0x29, 0x74, 0x69, 0x71, 0x1E, 0x01, 0x00, 0x0A, 0x1E, 0x01, 0x6B, 0x56, 0x04, 0xF0, 0x1E, 0x03, +/* 1910 */ 0x42, 0x6D, 0x24, 0x9D, 0x03, 0x6B, 0x08, 0x0F, 0x62, 0x98, 0x07, 0x00, 0x0A, 0x6F, 0x24, 0x45, +/* 1920 */ 0x04, 0x6B, 0x9D, 0x02, 0x24, 0x09, 0x3D, 0x7C, 0x05, 0x24, 0xA5, 0x29, 0x89, 0x58, 0x1E, 0x01, +/* 1930 */ 0x00, 0xA2, 0x69, 0x5F, 0x01, 0x24, 0x56, 0x06, 0x6B, 0xA0, 0x37, 0x61, 0x09, 0x6D, 0x24, 0xA2, +/* 1940 */ 0x27, 0x6B, 0x0C, 0x69, 0x46, 0x86, 0x6F, 0x1D, 0x0F, 0x6F, 0x6B, 0x0D, 0x52, 0x46, 0x08, 0x8B, +/* 1950 */ 0xEF, 0x71, 0x0F, 0x76, 0x6B, 0x0F, 0x6D, 0x00, 0x1D, 0x8B, 0x01, 0x00, 0x1F, 0x33, 0x8C, 0x7E, +/* 1960 */ 0x33, 0x37, 0x7E, 0x08, 0x08, 0x06, 0xA1, 0x0F, 0x6D, 0x5E, 0x5F, 0x0A, 0x9C, 0x0F, 0x52, 0x82, +/* 1970 */ 0x71, 0x30, 0x79, 0x0D, 0x69, 0x10, 0x13, 0x35, 0x04, 0xF4, 0x89, 0x33, 0x49, 0x1C, 0xBE, 0xEE, +/* 1980 */ 0x3D, 0x49, 0x06, 0x89, 0xA3, 0x33, 0x95, 0x1D, 0x19, 0x2A, 0x33, 0x10, 0x14, 0xE7, 0x01, 0x32, +/* 1990 */ 0xAF, 0x50, 0x0A, 0xC1, 0x10, 0x11, 0x35, 0x04, 0x2D, 0xA7, 0x0B, 0x3E, 0x26, 0x1D, 0x8A, 0x70, +/* 19A0 */ 0x68, 0x6D, 0x2B, 0x5B, 0x0F, 0x27, 0xF6, 0xFB, 0x8B, 0x02, 0xE2, 0xA0, 0x08, 0xE2, 0x06, 0x33, +/* 19B0 */ 0xE2, 0x04, 0x0F, 0x6D, 0xE2, 0x66, 0x0C, 0xE2, 0x56, 0x0A, 0xE2, 0x0B, 0x27, 0x26, 0x4C, 0xFB, +/* 19C0 */ 0x0F, 0x87, 0x00, 0x49, 0x0C, 0x2B, 0x5B, 0x8B, 0x06, 0x9C, 0x1D, 0x8A, 0x9F, 0x4E, 0x1D, 0x2D, +/* 19D0 */ 0xA7, 0x0B, 0x06, 0x01, 0x34, 0x20, 0x20, 0x22, 0x4C, 0x10, 0x14, 0xE7, 0x01, 0x32, 0x07, 0x04, +/* 19E0 */ 0x40, 0x98, 0x6D, 0x01, 0x26, 0x45, 0x6A, 0x24, 0x7E, 0x0A, 0x0F, 0x76, 0x4E, 0x5F, 0x75, 0x37, +/* 19F0 */ 0x7E, 0x98, 0x72, 0x9C, 0x45, 0x09, 0x8C, 0xA5, 0x76, 0x9C, 0x98, 0x72, 0x8C, 0x5F, 0x0E, 0x95, +/* 1A00 */ 0x7E, 0x8B, 0x6B, 0x93, 0x02, 0x8C, 0x1D, 0x0F, 0x52, 0x6B, 0xA3, 0x29, 0x89, 0x2A, 0x6D, 0x6B, +/* 1A10 */ 0xA0, 0x06, 0x82, 0xFB, 0x33, 0x89, 0x58, 0x27, 0x82, 0xFB, 0x33, 0x89, 0x58, 0x27, 0x89, 0x2A, +/* 1A20 */ 0x6D, 0x6B, 0x0B, 0x27, 0x8C, 0x1D, 0x0F, 0x52, 0x6B, 0xA3, 0x29, 0x5E, 0x1F, 0x8B, 0x6B, 0x93, +/* 1A30 */ 0x03, 0x79, 0x98, 0x72, 0x8C, 0x5F, 0x0E, 0x9C, 0x9D, 0x08, 0x8C, 0x56, 0x09, 0x9C, 0x5F, 0x96, +/* 1A40 */ 0xA1, 0x7E, 0x98, 0x75, 0x79, 0x9D, 0x6A, 0x58, 0x0F, 0x29, 0x4E, 0x7E, 0xA3, 0x52, 0x07, 0x04, +/* 1A50 */ 0x40, 0x0D, 0x19, 0x3F, 0x91, 0x23, 0xEC, 0x5A, 0x1D, 0x0A, 0x98, 0x2D, 0x52, 0x3E, 0x46, 0x50, +/* 1A60 */ 0x02, 0x04, 0x08, 0x0D, 0x8B, 0x7A, 0x2E, 0xC2, 0x6A, 0xA1, 0x5C, 0x0C, 0x02, 0x10, 0x11, 0x35, +/* 1A70 */ 0x04, 0x0F, 0x2D, 0x41, 0x08, 0x02, 0x26, 0x1D, 0x8A, 0x6F, 0x68, 0x6D, 0x2B, 0x06, 0x0A, 0x1E, +/* 1A80 */ 0x4A, 0xF6, 0x37, 0xA2, 0x8B, 0x03, 0xE2, 0x0A, 0x0F, 0x6F, 0xE2, 0xA5, 0x76, 0xE2, 0x06, 0x33, +/* 1A90 */ 0xE2, 0xA5, 0x76, 0xE2, 0x0B, 0x27, 0x26, 0x4C, 0x46, 0x66, 0x4F, 0x49, 0x0C, 0x2B, 0x06, 0x0A, +/* 1AA0 */ 0x8B, 0x06, 0x9C, 0x1D, 0x8A, 0xEC, 0x68, 0x23, 0x6A, 0x68, 0x3D, 0x24, 0x73, 0x4F, 0x68, 0x3D, +/* 1AB0 */ 0x37, 0x56, 0x0A, 0x24, 0xF6, 0x37, 0x98, 0x72, 0x68, 0x3D, 0x46, 0x66, 0x0C, 0x68, 0x3D, 0xA1, +/* 1AC0 */ 0xA3, 0x29, 0xF6, 0x46, 0x66, 0x0D, 0x00, 0xE2, 0x0C, 0x27, 0xE2, 0x04, 0x0F, 0x87, 0x49, 0x0B, +/* 1AD0 */ 0x82, 0xA0, 0x08, 0x10, 0x10, 0x35, 0x71, 0x09, 0x63, 0xA7, 0x09, 0x03, 0x28, 0x08, 0x0F, 0x23, +/* 1AE0 */ 0x8D, 0x3F, 0x74, 0x1E, 0x6F, 0x05, 0x40, 0x0C, 0x33, 0x50, 0x8B, 0xEF, 0xFB, 0x29, 0x26, 0xA2, +/* 1AF0 */ 0x33, 0xA1, 0x1F, 0x25, 0xD1, 0x18, 0x0C, 0x44, 0x1F, 0x0F, 0x27, 0x44, 0x53, 0x0F, 0x33, 0x04, +/* 1B00 */ 0x44, 0x91, 0x8B, 0x69, 0x08, 0x5D, 0x06, 0x0D, 0x2D, 0x8D, 0x9B, 0x05, 0x0A, 0x8B, 0x52, 0x5D, +/* 1B10 */ 0x7E, 0x45, 0x52, 0x00, 0xCD, 0x29, 0x44, 0x53, 0x0F, 0x6F, 0x21, 0xD1, 0x21, 0xA5, 0x6F, 0x4E, +/* 1B20 */ 0x1F, 0x8C, 0xA0, 0x05, 0x26, 0x08, 0xEC, 0x89, 0x56, 0x96, 0x9C, 0x7E, 0x98, 0x52, 0x08, 0x05, +/* 1B30 */ 0x04, 0x05, 0x0A, 0x1E, 0x29, 0x50, 0x0A, 0x0F, 0x23, 0x9F, 0x5C, 0x3C, 0x1C, 0x90, 0x3E, 0x10, +/* 1B40 */ 0x0F, 0x7F, 0x0A, 0x8B, 0x8A, 0x4A, 0x6B, 0x58, 0x1E, 0x8A, 0x19, 0x95, 0x1F, 0x43, 0x2B, 0x0F, +/* 1B50 */ 0x69, 0x04, 0x2B, 0x59, 0x2F, 0x61, 0x0D, 0xAB, 0xD7, 0xAB, 0xD7, 0xAB, 0xD7, 0x10, 0x13, 0x35, +/* 1B60 */ 0x78, 0xB5, 0x10, 0x10, 0x7F, 0x0A, 0x19, 0x82, 0x61, 0x0D, 0x8C, 0x2A, 0x76, 0xA1, 0x1D, 0x30, +/* 1B70 */ 0x79, 0x61, 0x0E, 0x8C, 0x45, 0x05, 0x4E, 0x86, 0x03, 0x82, 0x86, 0x01, 0x4E, 0x08, 0x27, 0x89, +/* 1B80 */ 0x61, 0x0C, 0xE2, 0x66, 0x08, 0x3F, 0x0E, 0x69, 0x89, 0x45, 0x03, 0x79, 0x58, 0x1E, 0x03, 0xA1, +/* 1B90 */ 0x0C, 0x69, 0xA6, 0x07, 0x46, 0x61, 0x0A, 0x26, 0x1F, 0x33, 0x46, 0x66, 0x06, 0x34, 0x0D, 0x69, +/* 1BA0 */ 0x46, 0x9D, 0x02, 0x34, 0x45, 0x04, 0x37, 0x0D, 0x52, 0x24, 0x68, 0x6F, 0x24, 0x61, 0x09, 0x28, +/* 1BB0 */ 0x0E, 0x3D, 0x24, 0x66, 0x04, 0x28, 0xA0, 0x01, 0x00, 0x9D, 0x01, 0x37, 0xA6, 0xEF, 0x0D, 0x3D, +/* 1BC0 */ 0x2F, 0x1F, 0x0F, 0x6F, 0x02, 0x27, 0x9B, 0x0D, 0x6D, 0x66, 0x03, 0x9B, 0x9D, 0x0A, 0x69, 0x9B, +/* 1BD0 */ 0xA2, 0x8B, 0x76, 0x82, 0x50, 0x8B, 0x29, 0x2E, 0xA0, 0xE9, 0x10, 0x18, 0x7F, 0x03, 0x0F, 0x76, +/* 1BE0 */ 0x89, 0xA0, 0x0A, 0x89, 0x9D, 0x02, 0x89, 0x0F, 0x52, 0xA1, 0x7C, 0x52, 0x89, 0x0C, 0x69, 0x82, +/* 1BF0 */ 0x86, 0xA1, 0x61, 0x1E, 0x01, 0xA1, 0x0E, 0x6D, 0x37, 0x58, 0x0F, 0x4F, 0x1D, 0x69, 0x80, 0x1F, +/* 1C00 */ 0x30, 0x89, 0xA5, 0x29, 0x37, 0x74, 0x6D, 0x98, 0x07, 0x00, 0x1D, 0x27, 0x46, 0x1D, 0x27, 0x58, +/* 1C10 */ 0x4A, 0x0A, 0x76, 0x46, 0xA5, 0x72, 0x82, 0x5F, 0x0A, 0x46, 0x98, 0x06, 0x07, 0x6D, 0x46, 0x9D, +/* 1C20 */ 0x01, 0x8C, 0x0E, 0x6D, 0x37, 0x61, 0x03, 0x04, 0x1E, 0x46, 0x0C, 0x69, 0x5E, 0x0C, 0x69, 0x1D, +/* 1C30 */ 0x1E, 0x7E, 0x0F, 0x62, 0x7C, 0x0B, 0x5E, 0x09, 0x0F, 0x4F, 0x42, 0x6D, 0x24, 0x0D, 0xA8, 0x7E, +/* 1C40 */ 0x0F, 0x6F, 0xA1, 0xFB, 0x80, 0x09, 0x4A, 0x24, 0x0B, 0x4A, 0x00, 0x84, 0x19, 0xA1, 0x1D, 0x19, +/* 1C50 */ 0x00, 0xA3, 0x06, 0x24, 0x08, 0x6D, 0x24, 0x56, 0x03, 0x5E, 0x61, 0x09, 0x24, 0x0F, 0x62, 0x05, +/* 1C60 */ 0x69, 0x24, 0x9D, 0x95, 0x0D, 0x3D, 0xF0, 0x1E, 0x01, 0x1F, 0x0F, 0x4F, 0x0B, 0x52, 0x95, 0x0B, +/* 1C70 */ 0x52, 0x42, 0x52, 0x46, 0x0E, 0x29, 0x7C, 0x0A, 0x95, 0x45, 0x01, 0x08, 0x76, 0x46, 0x0B, 0x0F, +/* 1C80 */ 0x67, 0x27, 0x95, 0x66, 0x03, 0x0B, 0x0F, 0x07, 0x46, 0x08, 0x3D, 0x03, 0x0F, 0x29, 0x5E, 0x71, +/* 1C90 */ 0x1E, 0xC2, 0x04, 0xFB, 0x69, 0x56, 0x02, 0x79, 0x0F, 0x76, 0x1E, 0x01, 0x24, 0x71, 0x0F, 0x76, +/* 1CA0 */ 0x69, 0x9C, 0x0D, 0x69, 0x52, 0x89, 0x0F, 0x69, 0x6D, 0x5E, 0x58, 0x1E, 0x76, 0x89, 0x86, 0x4A, +/* 1CB0 */ 0x9C, 0xA5, 0x27, 0x89, 0x9D, 0xA8, 0x10, 0x10, 0x7F, 0x02, 0x8B, 0x01, 0x89, 0xA5, 0x6F, 0x26, +/* 1CC0 */ 0x9D, 0x08, 0xA1, 0x73, 0x96, 0x26, 0x5F, 0x96, 0xFB, 0x27, 0x25, 0x09, 0x27, 0x46, 0x0D, 0x87, +/* 1CD0 */ 0x25, 0x73, 0x0D, 0x24, 0xA2, 0x27, 0x2F, 0x45, 0x06, 0x24, 0xDE, 0x28, 0x73, 0x0D, 0x84, 0x19, +/* 1CE0 */ 0x28, 0x45, 0x05, 0x0B, 0x52, 0x9B, 0x73, 0x98, 0x29, 0x9B, 0x74, 0x1E, 0x6D, 0x24, 0xF8, 0x3D, +/* 1CF0 */ 0x2E, 0x9D, 0x1E, 0x03, 0x28, 0x1F, 0x33, 0x33, 0x9B, 0x9D, 0x02, 0xA0, 0x03, 0x28, 0x5F, 0x0A, +/* 1D00 */ 0xF0, 0x33, 0x28, 0x09, 0x0F, 0x62, 0xA0, 0x03, 0x3F, 0x1F, 0x33, 0x1D, 0x33, 0x34, 0x9D, 0x04, +/* 1D10 */ 0x46, 0x86, 0x03, 0x3F, 0x5F, 0x0C, 0x2A, 0x3D, 0x3F, 0x9D, 0x05, 0x89, 0x98, 0x62, 0x79, 0x5F, +/* 1D20 */ 0x0D, 0x37, 0xFB, 0x33, 0x4E, 0x09, 0x27, 0x82, 0x73, 0x62, 0x10, 0x10, 0x7F, 0x0A, 0xC7, 0x27, +/* 1D30 */ 0x6C, 0x07, 0x10, 0x0F, 0x7F, 0xF0, 0x8B, 0x8A, 0x4E, 0x71, 0x8B, 0x8A, 0x50, 0x04, 0x31, 0x9D, +/* 1D40 */ 0x0C, 0x8C, 0x50, 0x98, 0x62, 0x9B, 0x45, 0x0A, 0x2E, 0x38, 0x4F, 0x44, 0x9D, 0x08, 0x24, 0xF8, +/* 1D50 */ 0x96, 0x2E, 0xA0, 0x06, 0x2F, 0x2A, 0x6D, 0xF5, 0x72, 0x44, 0x74, 0x33, 0x2E, 0x73, 0x62, 0x9B, +/* 1D60 */ 0x9D, 0x09, 0x2E, 0x5F, 0x96, 0x2E, 0x0B, 0x27, 0xCD, 0x0D, 0x4B, 0x29, 0x82, 0xA6, 0x0C, 0x8C, +/* 1D70 */ 0x50, 0x0E, 0x27, 0x04, 0x31, 0x03, 0x9C, 0x71, 0x1E, 0x8A, 0x52, 0x9C, 0x71, 0x1E, 0x8A, 0x76, +/* 1D80 */ 0x10, 0x09, 0x89, 0x9E, 0x50, 0x43, 0x2B, 0x03, 0xF8, 0x1E, 0x52, 0xF8, 0x1E, 0x52, 0xF8, 0x08, +/* 1D90 */ 0x65, 0x08, 0x65, 0xFF, 0xFF, 0x0A, 0x43, 0x03, 0xF8, 0x1E, 0x52, 0xF8, 0x1E, 0x52, 0x10, 0x0F, +/* 1DA0 */ 0x28, 0x9E, 0xFB, 0x09, 0x94, 0x7C, 0x09, 0x1A, 0x0B, 0x52, 0x1A, 0xA5, 0xE9, 0x00, 0x68, 0x29, +/* 1DB0 */ 0x1A, 0x0F, 0x6F, 0x1A, 0x0B, 0x6D, 0x00, 0x6C, 0x01, 0x8C, 0x68, 0x72, 0xAB, 0x08, 0xCE, 0x0B, +/* 1DC0 */ 0x1A, 0x9D, 0x1A, 0x66, 0x03, 0xAB, 0x07, 0x4D, 0x0B, 0x1A, 0x09, 0x69, 0x00, 0x18, 0x03, 0x21, +/* 1DD0 */ 0x5F, 0x06, 0x1A, 0x0E, 0x76, 0x9B, 0x58, 0x0F, 0xF1, 0x74, 0x1E, 0x02, 0x65, 0x06, 0x1A, 0x0E, +/* 1DE0 */ 0x4A, 0x1A, 0x0B, 0x52, 0x1A, 0xA5, 0xE9, 0x00, 0x68, 0x29, 0x1A, 0x0F, 0x6F, 0xCE, 0x51, 0x08, +/* 1DF0 */ 0x52, 0x6B, 0x50, 0x02, 0x10, 0x09, 0x28, 0x9E, 0x1F, 0x04, 0x2B, 0x59, 0x9B, 0x09, 0x2D, 0x06, +/* 1E00 */ 0x9B, 0x09, 0x2D, 0x06, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, +/* 1E10 */ 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0x28, 0x1F, 0x04, 0x40, +/* 1E20 */ 0x1E, 0x06, 0x9B, 0x09, 0x2D, 0x06, 0x9B, 0x09, 0x2D, 0x06, 0x10, 0x10, 0x21, 0xAA, 0xA0, 0x05, +/* 1E30 */ 0xCD, 0x52, 0x2E, 0x0C, 0x69, 0x27, 0x25, 0x2A, 0x29, 0x0B, 0x87, 0x00, 0x28, 0x0D, 0x52, 0xF0, +/* 1E40 */ 0x0F, 0x6F, 0x37, 0xA6, 0x05, 0x24, 0x0B, 0x0F, 0x75, 0x50, 0x0E, 0x52, 0x00, 0x71, 0x30, 0x25, +/* 1E50 */ 0xA5, 0x29, 0x46, 0xA0, 0x5A, 0x73, 0x0D, 0x37, 0x71, 0x0F, 0x76, 0x3F, 0x45, 0x06, 0x89, 0xA0, +/* 1E60 */ 0x03, 0x10, 0x0F, 0x9E, 0x60, 0x60, 0xE5, 0x2B, 0x2B, 0x02, 0x4E, 0x56, 0x8A, 0x27, 0x4E, 0x56, +/* 1E70 */ 0x8A, 0x27, 0x10, 0x09, 0x28, 0x9E, 0x1D, 0x2E, 0x1D, 0x3D, 0xD9, 0x84, 0x03, 0x10, 0x10, 0xA1, +/* 1E80 */ 0x60, 0x1D, 0x3C, 0xAC, 0x10, 0x11, 0x3B, 0x6E, 0x05, 0x07, 0x04, 0x18, 0x47, 0x2C, 0x47, 0x27, +/* 1E90 */ 0x42, 0x0C, 0x0E, 0x41, 0xEF, 0xA6, 0x07, 0x0A, 0x2D, 0x29, 0xA6, 0x1C, 0x7D, 0x04, 0x0A, 0x8B, +/* 1EA0 */ 0x5A, 0x56, 0xA8, 0x37, 0x9D, 0x09, 0x3F, 0x56, 0x0A, 0xA1, 0x5F, 0x0E, 0x3F, 0xD0, 0x27, 0x89, +/* 1EB0 */ 0xA0, 0x04, 0x39, 0x00, 0x58, 0x0F, 0x29, 0x39, 0xA1, 0x9D, 0x06, 0x39, 0x00, 0x58, 0x0F, 0x29, +/* 1EC0 */ 0x39, 0xA1, 0xA0, 0x04, 0x39, 0xA1, 0x93, 0x01, 0x26, 0x56, 0x08, 0x37, 0x71, 0x0F, 0x6D, 0x3F, +/* 1ED0 */ 0x56, 0x0E, 0x03, 0x46, 0x0B, 0x27, 0x79, 0xFB, 0x8B, 0x6F, 0x04, 0x05, 0xA0, 0x0D, 0xA6, 0x06, +/* 1EE0 */ 0x98, 0x8B, 0x69, 0x03, 0xA6, 0x03, 0x01, 0x08, 0x0D, 0x52, 0x8D, 0x10, 0x0E, 0x5E, 0x60, 0xA2, +/* 1EF0 */ 0xAE, 0x2E, 0x5F, 0x0E, 0x4D, 0x0F, 0x94, 0xA5, 0x6D, 0x01, 0x24, 0x71, 0x28, 0x86, 0x99, 0x05, +/* 1F00 */ 0x0A, 0x6F, 0x2F, 0x85, 0x2D, 0x33, 0x25, 0xFB, 0x36, 0x69, 0x7D, 0x10, 0x11, 0x28, 0x3A, 0x5C, +/* 1F10 */ 0x08, 0x06, 0x03, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x28, +/* 1F20 */ 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x24, 0x50, 0x08, 0x98, 0x8E, 0x02, 0x66, 0x08, 0x25, 0x85, 0x2D, +/* 1F30 */ 0x0E, 0x45, 0x08, 0x25, 0xA0, 0x99, 0x07, 0x93, 0x6F, 0x3F, 0xC8, 0x0B, 0x00, 0x2A, 0x6F, 0x00, +/* 1F40 */ 0x49, 0x0C, 0x00, 0x2A, 0x6F, 0x26, 0x61, 0x0E, 0x89, 0xC9, 0x0E, 0x33, 0x05, 0x04, 0x08, 0x0F, +/* 1F50 */ 0x98, 0x6F, 0x25, 0x64, 0x8B, 0x52, 0x03, 0x0F, 0x6F, 0x34, 0x92, 0x0E, 0x52, 0x67, 0x61, 0x08, +/* 1F60 */ 0x10, 0x10, 0x6B, 0x60, 0xEA, 0xB1, 0x41, 0x06, 0x10, 0x0A, 0x3F, 0x3A, 0x50, 0x08, 0x98, 0x90, +/* 1F70 */ 0x07, 0x02, 0x34, 0x1F, 0x0D, 0x2D, 0x29, 0x3F, 0x58, 0x33, 0x05, 0x40, 0x0B, 0x28, 0x7C, 0x96, +/* 1F80 */ 0x2E, 0x61, 0x0C, 0xAB, 0x0C, 0xAB, 0x0C, 0x44, 0x09, 0x0F, 0x2D, 0x27, 0x2F, 0x09, 0x23, 0x29, +/* 1F90 */ 0x25, 0x1F, 0x04, 0x66, 0x0D, 0x43, 0x59, 0xA1, 0x50, 0x0F, 0x6D, 0xAB, 0x0C, 0xE8, 0xE8, 0xE8, +/* 1FA0 */ 0xE8, 0x10, 0x0F, 0xAA, 0x7F, 0x1F, 0x01, 0x82, 0x50, 0x03, 0x5B, 0xA8, 0x9C, 0xFB, 0x36, 0x2D, +/* 1FB0 */ 0x33, 0x3F, 0x91, 0x23, 0x0A, 0x09, 0x08, 0x04, 0x3F, 0xA0, 0x99, 0x07, 0x0E, 0x3D, 0x01, 0x26, +/* 1FC0 */ 0x71, 0x0F, 0x52, 0x46, 0x5F, 0x0A, 0x25, 0x08, 0x19, 0x58, 0x1E, 0x5A, 0x0A, 0x80, 0x37, 0xA5, +/* 1FD0 */ 0x72, 0x79, 0x58, 0x80, 0x37, 0x45, 0x05, 0x3F, 0x08, 0x19, 0x58, 0x80, 0x79, 0x71, 0x1E, 0x57, +/* 1FE0 */ 0x5F, 0x0E, 0x34, 0x45, 0x0D, 0x06, 0x40, 0x0E, 0x27, 0x2F, 0x08, 0x23, 0x09, 0x28, 0x0B, 0x6D, +/* 1FF0 */ 0x98, 0x41, 0x05, 0x2F, 0x74, 0x87, 0x21, 0x0B, 0x0F, 0x51, 0xA0, 0x08, 0x2B, 0x03, 0x01, 0x25, +/* 2000 */ 0x1D, 0x23, 0x52, 0x05, 0x3F, 0x1D, 0x36, 0x23, 0x08, 0x9B, 0x1F, 0x07, 0x8B, 0x02, 0x21, 0x78, +/* 2010 */ 0x46, 0x1D, 0x0D, 0x0D, 0x04, 0x89, 0x74, 0x27, 0x79, 0x71, 0x0F, 0x6F, 0x89, 0x85, 0x80, 0x9C, +/* 2020 */ 0x98, 0x76, 0x06, 0x43, 0x40, 0xA3, 0x6D, 0x3F, 0xE1, 0x23, 0x3D, 0x01, 0x25, 0x83, 0x0B, 0x0D, +/* 2030 */ 0x1E, 0xA7, 0x09, 0x04, 0x10, 0x11, 0x3B, 0x6E, 0x05, 0x07, 0x04, 0x18, 0x47, 0x2C, 0x47, 0x27, +/* 2040 */ 0x84, 0x36, 0x90, 0x05, 0x4E, 0xFB, 0x27, 0x06, 0x2D, 0x29, 0xA6, 0x0B, 0x52, 0x77, 0x9D, 0x0E, +/* 2050 */ 0xA6, 0x3D, 0x01, 0x37, 0xA3, 0x72, 0x3F, 0x56, 0x57, 0x00, 0x08, 0x19, 0xBA, 0xBA, 0xBA, 0xBA, +/* 2060 */ 0xBA, 0xBA, 0x10, 0x08, 0x3A, 0x84, 0xED, 0x18, 0x07, 0x10, 0x08, 0x3A, 0x84, 0xED, 0x2E, 0x74, +/* 2070 */ 0x1E, 0x06, 0x6C, 0x05, 0x21, 0xA0, 0x02, 0xCD, 0x0C, 0x44, 0xA2, 0x93, 0xEF, 0xF8, 0x9F, 0x21, +/* 2080 */ 0x0C, 0x0B, 0x02, 0x6B, 0x50, 0x10, 0x0F, 0x3B, 0x84, 0x0C, 0x70, 0x18, 0x47, 0x2C, 0x47, 0x27, +/* 2090 */ 0x46, 0x38, 0x57, 0x5E, 0xFB, 0x27, 0x46, 0x0B, 0x80, 0x39, 0x24, 0x08, 0x27, 0x37, 0x39, 0x84, +/* 20A0 */ 0x33, 0x46, 0x39, 0x01, 0x0D, 0x87, 0x46, 0x39, 0xA0, 0x04, 0x3F, 0xFB, 0x27, 0x07, 0x27, 0x46, +/* 20B0 */ 0xA6, 0x0A, 0x0F, 0x6D, 0xA1, 0xA6, 0x08, 0x98, 0x62, 0x26, 0xFB, 0x27, 0x04, 0x0F, 0x52, 0x89, +/* 20C0 */ 0x39, 0x9D, 0x08, 0xA1, 0x39, 0x01, 0x98, 0x62, 0x24, 0x39, 0x84, 0x0F, 0x52, 0x46, 0x39, 0x24, +/* 20D0 */ 0x9D, 0x08, 0x37, 0x39, 0x00, 0x7E, 0x98, 0x62, 0x39, 0x1D, 0x0F, 0x52, 0x24, 0x39, 0x58, 0x0F, +/* 20E0 */ 0x6F, 0x10, 0x08, 0x3B, 0xA2, 0x0B, 0x0D, 0x04, 0x6C, 0x05, 0x6C, 0xD8, 0xD8, 0xD8, 0x05, 0x18, +/* 20F0 */ 0x88, 0x5D, 0x7E, 0x93, 0x4A, 0xA1, 0x5C, 0x36, 0x0E, 0x08, 0x10, 0x19, 0x82, 0x60, 0x56, 0x02, +/* 2100 */ 0x84, 0x0B, 0xA7, 0x08, 0x00, 0x1F, 0x09, 0x0E, 0x41, 0x03, 0x6B, 0x56, 0x03, 0xA5, 0x8B, 0x76, +/* 2110 */ 0xF0, 0x0E, 0x8B, 0x69, 0x03, 0x5E, 0x56, 0x08, 0x3D, 0x55, 0x1C, 0x72, 0x63, 0x77, 0xA0, 0x0A, +/* 2120 */ 0x5E, 0x56, 0x76, 0x24, 0xA2, 0x8B, 0x75, 0x01, 0x93, 0x5E, 0x56, 0x57, 0x5F, 0x72, 0x46, 0x86, +/* 2130 */ 0x02, 0x46, 0xFB, 0x27, 0x46, 0x61, 0x0C, 0xA1, 0xA0, 0x02, 0x46, 0xFB, 0x27, 0x46, 0x61, 0x0C, +/* 2140 */ 0xA1, 0xA0, 0x02, 0x46, 0xFB, 0x27, 0x46, 0x61, 0xB9, 0xB9, 0xB9, 0x0C, 0xA1, 0xA0, 0x02, 0x10, +/* 2150 */ 0x11, 0x82, 0x60, 0x56, 0xC0, 0x19, 0xBA, 0xBA, 0xBA, 0xBA, 0x10, 0x11, 0x6B, 0x60, 0x5B, 0xB4, +/* 2160 */ 0xF7, 0xB2, 0x10, 0x11, 0x82, 0x60, 0x56, 0x02, 0x42, 0x0C, 0x0E, 0x41, 0xEF, 0xA6, 0x03, 0x0B, +/* 2170 */ 0x0F, 0x2D, 0x06, 0xA6, 0xA3, 0x7D, 0x04, 0x0A, 0x8B, 0x5A, 0x06, 0x0F, 0x27, 0x46, 0x9D, 0x09, +/* 2180 */ 0x3F, 0x56, 0x0A, 0xA1, 0x5F, 0x0E, 0x3F, 0xD0, 0xB8, 0x01, 0x3F, 0x56, 0x0A, 0x1C, 0x8B, 0x69, +/* 2190 */ 0x03, 0xA6, 0x07, 0x02, 0x09, 0x0D, 0x52, 0x8F, 0xA6, 0x47, 0x2C, 0x07, 0x5E, 0x50, 0x02, 0x10, +/* 21A0 */ 0x11, 0x8C, 0x60, 0x7E, 0x08, 0x0D, 0x69, 0x8F, 0x0F, 0x6F, 0x00, 0x50, 0x98, 0x8B, 0x69, 0x04, +/* 21B0 */ 0x0F, 0x6F, 0x25, 0x86, 0x99, 0x07, 0x93, 0x6F, 0x3F, 0xC8, 0x0B, 0x00, 0x2A, 0x6F, 0x00, 0x49, +/* 21C0 */ 0x0C, 0x00, 0x2A, 0x6F, 0x26, 0x5F, 0x0E, 0x89, 0xC9, 0x0E, 0x33, 0x05, 0x04, 0x08, 0x0F, 0x1C, +/* 21D0 */ 0x6F, 0x25, 0x64, 0x8B, 0x6D, 0x56, 0x08, 0x34, 0x92, 0x0E, 0x52, 0x67, 0x66, 0x08, 0x28, 0x2A, +/* 21E0 */ 0x6F, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x28, 0x2A, 0x6F, 0x8C, 0x68, 0x6F, +/* 21F0 */ 0x21, 0x1F, 0x02, 0x10, 0x0B, 0x82, 0x60, 0x56, 0x02, 0x74, 0x0D, 0x52, 0x37, 0xA6, 0x03, 0x0A, +/* 2200 */ 0x1E, 0x76, 0x37, 0xA6, 0x08, 0x6D, 0x05, 0x43, 0x37, 0xA6, 0x6D, 0x82, 0xA6, 0x72, 0x82, 0xA6, +/* 2210 */ 0xF1, 0x06, 0x30, 0x28, 0xFB, 0x2C, 0x47, 0x2C, 0x07, 0x10, 0x0E, 0x89, 0x60, 0x1F, 0x08, 0x63, +/* 2220 */ 0x90, 0x08, 0x02, 0x25, 0x1D, 0x0E, 0x2D, 0x27, 0x34, 0x73, 0x4A, 0x05, 0x40, 0x0D, 0x3D, 0x34, +/* 2230 */ 0xA5, 0x6F, 0x00, 0xFB, 0x02, 0x34, 0x9D, 0x05, 0x21, 0xD1, 0x21, 0x38, 0x76, 0x03, 0x44, 0x84, +/* 2240 */ 0x93, 0x6D, 0x07, 0x5D, 0x83, 0x0D, 0x8B, 0x6F, 0xA1, 0x5C, 0x9D, 0x3D, 0x21, 0x38, 0x72, 0x6C, +/* 2250 */ 0x08, 0x21, 0xA5, 0x6F, 0x26, 0x1F, 0x67, 0xA1, 0xA3, 0x29, 0x50, 0x0D, 0x69, 0x08, 0xF9, 0x86, +/* 2260 */ 0x57, 0x9C, 0xA2, 0x0E, 0x23, 0x7A, 0x2F, 0x83, 0x0B, 0x1C, 0x41, 0x3E, 0x10, 0x0A, 0xA4, 0x7E, +/* 2270 */ 0x21, 0xE1, 0x09, 0x00, 0xD5, 0xD5, 0xD5, 0x34, 0x58, 0x23, 0x72, 0x26, 0x58, 0x23, 0x4F, 0x3F, +/* 2280 */ 0x1F, 0x04, 0x06, 0x33, 0x2B, 0x2F, 0x1D, 0x30, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, +/* 2290 */ 0xCD, 0x0A, 0x65, 0x51, 0x1C, 0x6F, 0x40, 0x09, 0x34, 0xFB, 0x2D, 0x29, 0x9B, 0x05, 0x0C, 0x0E, +/* 22A0 */ 0x6D, 0x3E, 0x10, 0x11, 0x82, 0x60, 0xFC, 0xBD, 0x10, 0x0E, 0xA1, 0x60, 0xE4, 0x0C, 0x00, 0x49, +/* 22B0 */ 0x0A, 0x00, 0x2A, 0x6F, 0x3F, 0x0E, 0x69, 0x89, 0x9D, 0x03, 0x79, 0x58, 0x80, 0x37, 0x0D, 0x69, +/* 22C0 */ 0x79, 0x2A, 0x6F, 0x24, 0x1F, 0x30, 0x50, 0x0F, 0x6D, 0xFB, 0x0F, 0x29, 0x34, 0xA0, 0x01, 0x00, +/* 22D0 */ 0x53, 0x1E, 0x01, 0x34, 0xA5, 0x29, 0x37, 0x0E, 0x3D, 0x2F, 0x5F, 0x09, 0x71, 0x27, 0x28, 0xDE, +/* 22E0 */ 0x24, 0xA5, 0x4F, 0x2F, 0x08, 0x0F, 0x4F, 0x0B, 0x52, 0x24, 0x5C, 0x19, 0x0E, 0x6F, 0x9B, 0x1C, +/* 22F0 */ 0x88, 0x80, 0x28, 0x09, 0x69, 0x08, 0x69, 0x89, 0x68, 0x69, 0x76, 0x2E, 0x93, 0x29, 0x28, 0x58, +/* 2300 */ 0x8B, 0x01, 0x10, 0x15, 0x1A, 0xAA, 0xA4, 0x68, 0x6F, 0x46, 0x61, 0x62, 0x24, 0xA5, 0x72, 0x82, +/* 2310 */ 0x7E, 0x33, 0x00, 0x1D, 0x8B, 0x06, 0x58, 0x1E, 0x01, 0x5E, 0x0D, 0x52, 0x46, 0xA5, 0x30, 0x37, +/* 2320 */ 0xDE, 0x89, 0x58, 0x1E, 0x01, 0x00, 0x53, 0x3D, 0x6D, 0x46, 0x0F, 0x76, 0x6B, 0xA5, 0x72, 0x37, +/* 2330 */ 0x98, 0x66, 0x00, 0x71, 0x27, 0x82, 0x1D, 0x19, 0x7E, 0x69, 0x00, 0x0E, 0x62, 0x66, 0x04, 0x5E, +/* 2340 */ 0x7E, 0x30, 0x84, 0x6D, 0x00, 0xA3, 0x06, 0x24, 0x45, 0x01, 0x95, 0x0D, 0x6D, 0x00, 0x74, 0x4A, +/* 2350 */ 0x00, 0x09, 0x6F, 0x24, 0x0B, 0x6D, 0x8C, 0x58, 0x69, 0x53, 0xA8, 0x06, 0x3D, 0x24, 0x0E, 0x4A, +/* 2360 */ 0x8C, 0xFB, 0x0F, 0x4F, 0x98, 0x03, 0xF0, 0x69, 0x7E, 0x19, 0x5E, 0x71, 0x0F, 0x29, 0x61, 0x01, +/* 2370 */ 0x24, 0x1E, 0x02, 0x04, 0x1E, 0x03, 0x9C, 0x27, 0x04, 0x6D, 0x37, 0x0C, 0x29, 0x07, 0x1E, 0x4E, +/* 2380 */ 0x0C, 0x76, 0x07, 0x76, 0x37, 0x09, 0x6F, 0x09, 0x6D, 0x4E, 0x09, 0x52, 0x0A, 0x0F, 0x07, 0x24, +/* 2390 */ 0x42, 0x3D, 0x0C, 0x4A, 0x4E, 0x56, 0x0D, 0x72, 0x1D, 0x69, 0x1C, 0x06, 0x79, 0x71, 0x0F, 0x8B, +/* 23A0 */ 0x01, 0x37, 0x61, 0x1E, 0x03, 0x4E, 0x7C, 0x52, 0xA1, 0x0D, 0x8B, 0x10, 0x0E, 0xA1, 0x60, 0x73, +/* 23B0 */ 0x4F, 0x37, 0x5F, 0x57, 0x9C, 0xD1, 0x46, 0x9D, 0x05, 0x34, 0xFD, 0x7E, 0x0E, 0x6D, 0x4E, 0x2A, +/* 23C0 */ 0x4A, 0x24, 0x45, 0x03, 0x28, 0xA0, 0x01, 0x73, 0x0A, 0x24, 0x5C, 0x0F, 0x6F, 0x08, 0x69, 0x5D, +/* 23D0 */ 0x09, 0x69, 0x1C, 0x07, 0x44, 0x73, 0x52, 0x01, 0x82, 0x50, 0x98, 0x87, 0x44, 0x08, 0x69, 0x30, +/* 23E0 */ 0x2F, 0x1F, 0x0F, 0x6F, 0x0A, 0x1E, 0x03, 0x25, 0x58, 0x87, 0x02, 0x33, 0x25, 0x1D, 0x27, 0x24, +/* 23F0 */ 0x9D, 0x05, 0x2F, 0x0C, 0x87, 0x1F, 0x0F, 0x52, 0x37, 0x39, 0x37, 0x09, 0x27, 0x50, 0x0E, 0x87, +/* 2400 */ 0x46, 0x73, 0x96, 0x26, 0x09, 0x27, 0x89, 0x45, 0x09, 0x10, 0x0E, 0xA1, 0x60, 0xE4, 0xBB, 0x10, +/* 2410 */ 0x0D, 0x24, 0x60, 0x58, 0x8A, 0x0C, 0x4E, 0x58, 0x8A, 0x0C, 0x3F, 0x1F, 0x2B, 0x2B, 0x0B, 0x27, +/* 2420 */ 0x24, 0xF8, 0x0D, 0x4B, 0x72, 0x2E, 0xD1, 0x2E, 0x38, 0x96, 0x28, 0x58, 0x0F, 0x29, 0x44, 0xA2, +/* 2430 */ 0x33, 0x8C, 0x50, 0xFD, 0x44, 0x09, 0x27, 0x24, 0xF8, 0x0D, 0x4B, 0x72, 0x2E, 0xD1, 0x2E, 0x38, +/* 2440 */ 0x29, 0x2B, 0x2B, 0x03, 0x79, 0x2A, 0x23, 0x33, 0x3F, 0xA2, 0x8A, 0x4A, 0x10, 0x09, 0x44, 0xAA, +/* 2450 */ 0x1F, 0x03, 0x2E, 0x74, 0x93, 0x2E, 0xA5, 0x8B, 0x2E, 0x98, 0x9F, 0x01, 0x44, 0x61, 0x0A, 0xAB, +/* 2460 */ 0xE6, 0xE6, 0xE6, 0x08, 0x21, 0x5F, 0x08, 0xB0, 0x44, 0xA2, 0x86, 0x5D, 0x6E, 0x33, 0x03, 0x2E, +/* 2470 */ 0x5F, 0xEC, 0x21, 0x92, 0x1E, 0x03, 0xBF, 0xAB, 0x08, 0xAB, 0xE6, 0xE6, 0xE6, 0x09, 0x1A, 0x33, +/* 2480 */ 0xCE, 0x6F, 0x04, 0xCD, 0x1E, 0x9B, 0x1D, 0x0A, 0x98, 0x10, 0x0B, 0x2E, 0x9E, 0xA2, 0x08, 0x08, +/* 2490 */ 0x00, 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0x10, 0x09, 0x34, 0xAA, 0x1F, 0x02, 0x44, 0x58, +/* 24A0 */ 0x1E, 0x97, 0x28, 0x58, 0x1E, 0x6D, 0x89, 0x5C, 0xA3, 0x72, 0xB0, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, +/* 24B0 */ 0xBF, 0xBF, 0xBF, 0xAB, 0x09, 0x1A, 0x0B, 0x27, 0x02, 0x8C, 0x50, 0x9D, 0x08, 0x9B, 0x1F, 0xA3, +/* 24C0 */ 0x6F, 0x2E, 0x0D, 0x69, 0x03, 0x2E, 0x5F, 0x09, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, +/* 24D0 */ 0x21, 0x66, 0x06, 0x46, 0x5C, 0x06, 0xFD, 0x34, 0x58, 0x1E, 0x76, 0x28, 0x58, 0x90, 0x06, 0x10, +/* 24E0 */ 0x0E, 0x00, 0xA9, 0x60, 0x92, 0xA7, 0x8F, 0x00, 0x42, 0x5A, 0x7E, 0x98, 0x8B, 0x6F, 0x04, 0x09, +/* 24F0 */ 0x52, 0x9C, 0x58, 0x3D, 0x40, 0x0D, 0x2D, 0x03, 0x26, 0x1F, 0x67, 0x24, 0x83, 0x0D, 0x90, 0x03, +/* 2500 */ 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x39, 0x00, 0x95, 0x00, 0xEB, 0x01, 0x5B, 0x01, 0xC3, 0x01, +/* 2510 */ 0xD0, 0x02, 0x50, 0x02, 0x65, 0x03, 0x1C, 0x03, 0x77, 0x03, 0xD9, 0x03, 0xF1, 0x03, 0xFF, 0x04, +/* 2520 */ 0x94, 0x04, 0xA3, 0x04, 0xE3, 0x05, 0x00, 0x05, 0x3A, 0x05, 0x78, 0x05, 0x8E, 0x05, 0xD6, 0x06, +/* 2530 */ 0x38, 0x06, 0x3F, 0x06, 0x63, 0x06, 0x7F, 0x06, 0xD6, 0x07, 0x3B, 0x07, 0x7F, 0x08, 0x05, 0x08, +/* 2540 */ 0x8A, 0x08, 0xD3, 0x08, 0xDB, 0x08, 0xE9, 0x08, 0xF8, 0x09, 0x01, 0x09, 0x0A, 0x09, 0x31, 0x09, +/* 2550 */ 0xBA, 0x0A, 0x30, 0x0A, 0x49, 0x0A, 0x65, 0x0A, 0x84, 0x0A, 0xA0, 0x0A, 0xBB, 0x0A, 0xD7, 0x0A, +/* 2560 */ 0xF7, 0x0B, 0x10, 0x0B, 0x9C, 0x0B, 0xCD, 0x0B, 0xEC, 0x0C, 0x0E, 0x0C, 0x33, 0x0C, 0x59, 0x0C, +/* 2570 */ 0x74, 0x0C, 0xB6, 0x0D, 0x7F, 0x0D, 0x87, 0x0D, 0x96, 0x0D, 0xA4, 0x0D, 0xAD, 0x0D, 0xC9, 0x0E, +/* 2580 */ 0x13, 0x0E, 0x91, 0x0E, 0xAC, 0x0E, 0xC8, 0x0E, 0xEE, 0x0E, 0xFE, 0x0F, 0x19, 0x0F, 0x41, 0x0F, +/* 2590 */ 0xD6, 0x10, 0x18, 0x10, 0x36, 0x10, 0x4A, 0x10, 0x69, 0x10, 0x7D, 0x10, 0xA4, 0x10, 0xC7, 0x10, +/* 25A0 */ 0xEB, 0x11, 0x10, 0x11, 0xAA, 0x11, 0xBE, 0x11, 0xDB, 0x11, 0xF8, 0x12, 0x1C, 0x12, 0x28, 0x12, +/* 25B0 */ 0x43, 0x12, 0x55, 0x12, 0xE5, 0x12, 0xF3, 0x13, 0x11, 0x13, 0x30, 0x13, 0x49, 0x13, 0x5B, 0x13, +/* 25C0 */ 0x9D, 0x08, 0x00, 0x10, 0x07, 0x3B, 0x7F, 0x09, 0x90, 0x01, 0xCD, 0x6F, 0xCD, 0x6F, 0x21, 0x09, +/* 25D0 */ 0x90, 0x01, 0x3F, 0x9E, 0x08, 0x52, 0x1A, 0x08, 0x52, 0x1A, 0x09, 0x69, 0x1A, 0x09, 0x69, 0x1A, +/* 25E0 */ 0x9D, 0x9B, 0x58, 0x1E, 0x9B, 0x58, 0x1E, 0x00, 0x1B, 0x21, 0xA0, 0x01, 0x21, 0xA0, 0x02, 0x4B, +/* 25F0 */ 0x4F, 0x2E, 0x86, 0x02, 0x21, 0x86, 0x03, 0xF5, 0x62, 0x10, 0x0E, 0x37, 0xA4, 0xA3, 0x06, 0xCE, +/* 2600 */ 0x06, 0xCE, 0x06, 0xCE, 0x06, 0x5E, 0x50, 0x98, 0x67, 0x9B, 0x92, 0x2D, 0x8D, 0x25, 0x1F, 0x98, +/* 2610 */ 0x2D, 0x6D, 0x2F, 0x98, 0x76, 0x03, 0x6E, 0x07, 0x9F, 0x4E, 0xFB, 0x33, 0x46, 0x7E, 0x2F, 0x86, +/* 2620 */ 0x03, 0x2E, 0x61, 0x0E, 0x21, 0x20, 0x56, 0x0A, 0x18, 0x09, 0x18, 0x0A, 0x2E, 0xA2, 0x33, 0x65, +/* 2630 */ 0xF1, 0x7C, 0x62, 0x44, 0x9D, 0x0A, 0x46, 0x7E, 0x2F, 0x38, 0x76, 0x02, 0x6E, 0x07, 0x9F, 0x34, +/* 2640 */ 0xA2, 0x23, 0x52, 0x25, 0x1D, 0x0D, 0x8B, 0x33, 0x03, 0x9B, 0xE1, 0x0A, 0x03, 0xF5, 0x06, 0x4D, +/* 2650 */ 0x06, 0x4D, 0x06, 0x4D, 0x06, 0x10, 0x0F, 0x00, 0xA4, 0x74, 0x0C, 0x0E, 0x90, 0x3E, 0x28, 0x91, +/* 2660 */ 0x2D, 0x52, 0x03, 0x2F, 0x9D, 0x0D, 0x06, 0x40, 0x1C, 0x57, 0x4E, 0x61, 0x96, 0x00, 0x1F, 0x0C, +/* 2670 */ 0xEF, 0x68, 0x4A, 0x18, 0x07, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, 0x82, 0x50, 0x04, 0x45, 0x08, +/* 2680 */ 0x04, 0x2B, 0x59, 0x79, 0x2A, 0x8A, 0x03, 0x3F, 0xA2, 0x8A, 0x62, 0xA6, 0x06, 0x18, 0x06, 0x18, +/* 2690 */ 0x06, 0x18, 0x06, 0x21, 0xA5, 0x29, 0x21, 0x9D, 0x03, 0x8C, 0x50, 0x0D, 0x6D, 0xA1, 0x5C, 0xDE, +/* 26A0 */ 0x05, 0x31, 0x03, 0x3F, 0xA3, 0x8A, 0x4A, 0x3F, 0x0C, 0x8A, 0x27, 0x10, 0x10, 0x24, 0x48, 0xA4, +/* 26B0 */ 0x5C, 0x6B, 0x5A, 0x09, 0x72, 0x89, 0x71, 0x8E, 0x26, 0x0B, 0x69, 0x03, 0x06, 0x0C, 0x0E, 0x90, +/* 26C0 */ 0x07, 0x02, 0x0D, 0x6D, 0x4E, 0x7E, 0x98, 0x8A, 0x57, 0x9C, 0x38, 0x4A, 0x43, 0x08, 0x93, 0x03, +/* 26D0 */ 0x26, 0x1F, 0x27, 0x00, 0x1D, 0x80, 0x4E, 0x74, 0x69, 0x89, 0x0C, 0x76, 0x25, 0x0B, 0x3D, 0x89, +/* 26E0 */ 0x09, 0x52, 0x25, 0x0C, 0x76, 0x89, 0x45, 0x25, 0x0B, 0x3D, 0x89, 0x09, 0x69, 0x25, 0x08, 0x69, +/* 26F0 */ 0x89, 0x0C, 0x3D, 0x26, 0x71, 0x19, 0x1D, 0x0F, 0x29, 0x25, 0x73, 0x4A, 0x43, 0x08, 0x93, 0x02, +/* 2700 */ 0x25, 0x0B, 0x8A, 0x52, 0x01, 0x95, 0x58, 0x69, 0x03, 0x06, 0x0C, 0x0E, 0x6D, 0x07, 0xE1, 0x6A, +/* 2710 */ 0x9C, 0x08, 0x72, 0x89, 0x71, 0x41, 0x01, 0x9C, 0x71, 0x8C, 0x71, 0x10, 0x0F, 0x21, 0xA4, 0x78, +/* 2720 */ 0x00, 0x0D, 0x87, 0x9C, 0x5F, 0x0D, 0x24, 0x2A, 0x6F, 0x26, 0x45, 0x06, 0x89, 0x0C, 0x87, 0x26, +/* 2730 */ 0x73, 0x0D, 0x46, 0xA2, 0x27, 0x3F, 0x74, 0x19, 0x37, 0xDE, 0x24, 0x50, 0x0D, 0x52, 0x37, 0x66, +/* 2740 */ 0x06, 0x24, 0xA6, 0x05, 0x24, 0xDE, 0x00, 0x28, 0x0D, 0x6D, 0x84, 0x0F, 0x29, 0x3F, 0x2A, 0x29, +/* 2750 */ 0x0C, 0x6D, 0x44, 0xA3, 0x1C, 0x72, 0x2F, 0x74, 0x0C, 0x0C, 0x0E, 0x8B, 0x6D, 0x0C, 0x6A, 0x3F, +/* 2760 */ 0x09, 0x8A, 0xE9, 0x4E, 0xA0, 0x03, 0x21, 0xA0, 0x03, 0x2F, 0x1F, 0x2B, 0x86, 0x06, 0x2B, 0x34, +/* 2770 */ 0x09, 0x8A, 0xE9, 0x6B, 0x09, 0x8A, 0xE9, 0x4E, 0xA0, 0x03, 0x21, 0xA0, 0x03, 0x21, 0xA0, 0x03, +/* 2780 */ 0x21, 0xA0, 0x03, 0x10, 0x0B, 0x9E, 0xD3, 0xD3, 0xD3, 0x44, 0xA9, 0x1B, 0x1B, 0x1B, 0xD3, 0xD3, +/* 2790 */ 0x10, 0x10, 0xA4, 0x83, 0x0C, 0x0E, 0x52, 0x88, 0x28, 0x85, 0x23, 0x0A, 0x2F, 0x0B, 0x33, 0xF9, +/* 27A0 */ 0x0B, 0x76, 0x34, 0x61, 0x0C, 0x24, 0x1D, 0x5A, 0x71, 0x30, 0x9B, 0x1F, 0x33, 0x4D, 0x0F, 0x8D, +/* 27B0 */ 0x2E, 0xE1, 0x69, 0x08, 0x5D, 0x05, 0x0E, 0x8B, 0x33, 0x03, 0x24, 0x68, 0x29, 0x02, 0x08, 0x93, +/* 27C0 */ 0x29, 0x34, 0x0B, 0x6D, 0x37, 0x83, 0x8B, 0x5A, 0x7C, 0x0A, 0x46, 0x74, 0x19, 0x3F, 0x0E, 0x52, +/* 27D0 */ 0x37, 0x1F, 0x27, 0x9C, 0x58, 0x1E, 0x8D, 0x00, 0x71, 0x0F, 0x29, 0x26, 0x1F, 0x98, 0x69, 0x08, +/* 27E0 */ 0x02, 0x00, 0x0A, 0x52, 0x37, 0x50, 0x09, 0x8B, 0x6D, 0x69, 0x03, 0x2F, 0x1F, 0x07, 0x98, 0x30, +/* 27F0 */ 0x44, 0xA2, 0x1C, 0x29, 0x65, 0x0B, 0x1A, 0x0F, 0x6D, 0x5C, 0x24, 0x1D, 0x0F, 0x76, 0x26, 0x1D, +/* 2800 */ 0x6D, 0x07, 0x04, 0x40, 0x1C, 0x72, 0x25, 0x74, 0x23, 0x6F, 0x00, 0x5C, 0x3C, 0x0E, 0x69, 0x88, +/* 2810 */ 0x10, 0x0B, 0x3B, 0x07, 0x0E, 0x6A, 0x74, 0x90, 0x01, 0x2F, 0x0D, 0x19, 0x7C, 0x29, 0x34, 0x74, +/* 2820 */ 0x0E, 0x6A, 0x74, 0x90, 0x01, 0x10, 0x17, 0x46, 0x3B, 0x1D, 0x09, 0x0B, 0x0C, 0x0C, 0x0A, 0x06, +/* 2830 */ 0x01, 0x5C, 0x0C, 0x23, 0xEC, 0x3F, 0xA2, 0x33, 0x05, 0x02, 0x01, 0x02, 0x04, 0x09, 0x0E, 0x76, +/* 2840 */ 0x79, 0x1D, 0x0F, 0x9F, 0xA1, 0x1F, 0x0C, 0x4A, 0x79, 0x7E, 0x98, 0xEF, 0xA2, 0x0C, 0x0E, 0x0E, +/* 2850 */ 0x8D, 0x7E, 0x0D, 0x72, 0x95, 0x74, 0x4A, 0x24, 0xA5, 0x8B, 0x6D, 0x71, 0x6D, 0x79, 0xA3, 0x02, +/* 2860 */ 0x6E, 0x33, 0x55, 0x0A, 0x06, 0x37, 0xA3, 0x02, 0x5E, 0x7E, 0x6D, 0x24, 0x08, 0x52, 0x46, 0xFB, +/* 2870 */ 0xA8, 0x89, 0x1D, 0x4A, 0x24, 0x0B, 0x6F, 0xA1, 0x1D, 0x4A, 0x5E, 0xA2, 0x6F, 0x24, 0x98, 0x06, +/* 2880 */ 0x89, 0x71, 0x76, 0x5E, 0xA2, 0x6F, 0x24, 0x0D, 0x29, 0x89, 0x71, 0x76, 0x82, 0x1D, 0x76, 0x24, +/* 2890 */ 0xA3, 0x07, 0xA1, 0x1D, 0x4A, 0x8C, 0x1F, 0x52, 0x24, 0x09, 0x3D, 0x8C, 0xA5, 0x07, 0x95, 0x98, +/* 28A0 */ 0x03, 0x84, 0x1E, 0x67, 0x01, 0x06, 0x06, 0x37, 0x98, 0x03, 0x95, 0x08, 0x3D, 0x53, 0x2D, 0x96, +/* 28B0 */ 0xA2, 0x52, 0x79, 0x73, 0x07, 0x7E, 0x9D, 0x6D, 0x03, 0x6E, 0x0E, 0x29, 0x6B, 0x1D, 0x1E, 0x67, +/* 28C0 */ 0x7E, 0x03, 0x02, 0x00, 0xA2, 0x0E, 0x76, 0x4E, 0x74, 0x1E, 0x9A, 0x77, 0x05, 0x07, 0x0C, 0x33, +/* 28D0 */ 0x01, 0x3F, 0x64, 0x23, 0x08, 0x37, 0x50, 0x5B, 0x1C, 0x90, 0x08, 0x02, 0x10, 0x0F, 0x35, 0xA2, +/* 28E0 */ 0x09, 0x0C, 0x0E, 0x52, 0x67, 0x46, 0x50, 0x23, 0x57, 0x25, 0x09, 0x09, 0x77, 0x05, 0x86, 0x06, +/* 28F0 */ 0x21, 0x5F, 0x09, 0x1A, 0x30, 0x3F, 0xFB, 0x0A, 0x0C, 0x0D, 0x98, 0x4A, 0x25, 0x1F, 0x98, 0x2D, +/* 2900 */ 0x4A, 0x2F, 0x0B, 0x27, 0x02, 0x24, 0x30, 0x00, 0x50, 0x33, 0x46, 0x30, 0x25, 0x5F, 0x0A, 0x37, +/* 2910 */ 0x5F, 0x09, 0x2F, 0x0E, 0x69, 0x04, 0xF0, 0xA3, 0x6D, 0x2F, 0x09, 0x2D, 0x4A, 0x19, 0x34, 0x9D, +/* 2920 */ 0x52, 0xEF, 0x0A, 0x4F, 0x37, 0x50, 0x03, 0x03, 0x37, 0x7E, 0x9C, 0xA9, 0x2B, 0x31, 0x03, 0x00, +/* 2930 */ 0x50, 0x8A, 0x52, 0x00, 0x50, 0x8A, 0x52, 0x10, 0x11, 0x95, 0x60, 0x09, 0x67, 0x58, 0x07, 0x4E, +/* 2940 */ 0x2A, 0x29, 0x37, 0x56, 0x03, 0x25, 0x38, 0x0B, 0x00, 0x71, 0x0F, 0x76, 0x34, 0x0B, 0x0F, 0x4F, +/* 2950 */ 0x7E, 0x0D, 0x87, 0x25, 0x45, 0x08, 0x37, 0x09, 0x27, 0x68, 0x87, 0x24, 0x66, 0x0D, 0x00, 0x50, +/* 2960 */ 0x98, 0x29, 0x24, 0x38, 0x72, 0x68, 0x6D, 0x37, 0x66, 0x0A, 0x3F, 0x71, 0x0F, 0x87, 0x24, 0x66, +/* 2970 */ 0x0D, 0x2F, 0xA0, 0x09, 0x37, 0x0C, 0x27, 0x34, 0x73, 0x62, 0x38, 0x75, 0xF6, 0x24, 0x56, 0x0A, +/* 2980 */ 0x2F, 0x45, 0x05, 0x00, 0x53, 0x80, 0x25, 0x0C, 0x87, 0x00, 0x7E, 0x0D, 0x52, 0x2F, 0x38, 0xEF, +/* 2990 */ 0x71, 0x1E, 0x03, 0x34, 0xA2, 0x03, 0x46, 0xA2, 0x03, 0x10, 0x0F, 0xA9, 0x60, 0xE5, 0x2B, 0x03, +/* 29A0 */ 0x37, 0x49, 0x8A, 0x37, 0x49, 0x8A, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6C, 0x1A, 0x40, +/* 29B0 */ 0x07, 0x10, 0x0C, 0xA9, 0x60, 0xE5, 0x04, 0x37, 0x68, 0x23, 0x01, 0x24, 0x68, 0x23, 0x01, 0x10, +/* 29C0 */ 0x12, 0x46, 0x3B, 0x83, 0x0C, 0x0E, 0xA7, 0x09, 0x03, 0x00, 0x5C, 0x0D, 0x70, 0x04, 0x03, 0x05, +/* 29D0 */ 0x0B, 0x0F, 0x07, 0x3F, 0x71, 0x41, 0x01, 0x2A, 0x08, 0x25, 0x0C, 0x0D, 0x82, 0x74, 0x72, 0x95, +/* 29E0 */ 0xFB, 0x0F, 0xEF, 0x56, 0x41, 0x03, 0x24, 0x0D, 0x0C, 0x26, 0x0B, 0x0D, 0x24, 0xA5, 0x43, 0x0C, +/* 29F0 */ 0x96, 0x00, 0x08, 0x4F, 0x9C, 0x8E, 0x24, 0xA5, 0x02, 0x42, 0x0F, 0x03, 0x84, 0xA8, 0x95, 0x7E, +/* 2A00 */ 0x6F, 0x24, 0xA5, 0x02, 0x01, 0x0A, 0x96, 0x6E, 0x0F, 0x07, 0x79, 0x7E, 0x6F, 0x00, 0x74, 0x1E, +/* 2A10 */ 0x52, 0x04, 0x1F, 0x6F, 0x4E, 0x4A, 0x00, 0x74, 0x72, 0x0C, 0x0C, 0x00, 0x71, 0xA8, 0x9C, 0x0C, +/* 2A20 */ 0x0C, 0x24, 0xA5, 0x02, 0x05, 0x29, 0x00, 0x42, 0x62, 0x79, 0xA5, 0x02, 0x74, 0x4F, 0x0C, 0x0D, +/* 2A30 */ 0x01, 0x00, 0x0B, 0x0D, 0x4E, 0x7E, 0x8E, 0x84, 0x97, 0x84, 0x88, 0x05, 0xA8, 0x4E, 0xA2, 0x6F, +/* 2A40 */ 0x46, 0x71, 0x41, 0x4E, 0xFB, 0x3D, 0x59, 0xF0, 0x08, 0x0E, 0x97, 0x5C, 0x0A, 0x93, 0x6D, 0x06, +/* 2A50 */ 0x9B, 0x1F, 0x02, 0x01, 0x10, 0x0A, 0x3B, 0x03, 0x2B, 0x2B, 0x03, 0x28, 0x7C, 0x2D, 0x0C, 0x28, +/* 2A60 */ 0x7C, 0x2D, 0x0C, 0x10, 0x0F, 0xA1, 0x1A, 0x3B, 0x1F, 0x03, 0x01, 0x44, 0x84, 0x0D, 0x8B, 0x97, +/* 2A70 */ 0x46, 0x68, 0x2D, 0x6A, 0x2F, 0x0D, 0x3D, 0x02, 0x01, 0x05, 0x1C, 0x07, 0x5C, 0x1E, 0x01, 0x24, +/* 2A80 */ 0x74, 0x6D, 0x34, 0xA2, 0x52, 0x00, 0x1D, 0x69, 0x34, 0xA2, 0x52, 0x00, 0x1D, 0x69, 0x5C, 0x1E, +/* 2A90 */ 0x03, 0x37, 0x09, 0x3D, 0x28, 0xDE, 0x77, 0x9D, 0x05, 0x28, 0x38, 0x8B, 0x76, 0x28, 0x1F, 0x09, +/* 2AA0 */ 0x0E, 0x90, 0x06, 0x10, 0x0F, 0x28, 0xAA, 0xA4, 0x0E, 0x6F, 0xDD, 0x08, 0xDD, 0x08, 0x28, 0xDA, +/* 2AB0 */ 0x6F, 0xDD, 0x08, 0x6B, 0xAA, 0xE5, 0x2B, 0x03, 0x26, 0x71, 0x8A, 0x6D, 0x26, 0x71, 0x8A, 0x6D, +/* 2AC0 */ 0x10, 0x0C, 0x00, 0x1A, 0x3B, 0xFB, 0x0C, 0xA7, 0x8D, 0x9B, 0x9D, 0x1E, 0x87, 0x00, 0x5C, 0x52, +/* 2AD0 */ 0x77, 0x45, 0x08, 0x24, 0x5C, 0x01, 0x37, 0x0C, 0x4A, 0x1A, 0x0B, 0x6F, 0xAB, 0x02, 0x21, 0x0B, +/* 2AE0 */ 0x6F, 0x21, 0x08, 0x76, 0x21, 0x08, 0x3D, 0x01, 0x2E, 0x09, 0x3D, 0x01, 0x2E, 0x09, 0x52, 0x04, +/* 2AF0 */ 0x2B, 0x03, 0x46, 0x50, 0x23, 0x0E, 0x46, 0x50, 0x23, 0x0C, 0x10, 0x0C, 0x00, 0x3B, 0x42, 0xA3, +/* 2B00 */ 0x8E, 0x5D, 0x0A, 0x2D, 0x96, 0x28, 0x85, 0x99, 0x07, 0x27, 0xA1, 0x50, 0x58, 0x4A, 0x1A, 0x0B, +/* 2B10 */ 0x6F, 0x82, 0x50, 0x04, 0x08, 0x69, 0x5D, 0x42, 0x33, 0x03, 0x2E, 0x45, 0x6D, 0x02, 0x89, 0x5C, +/* 2B20 */ 0x0D, 0x3D, 0x00, 0x18, 0x1A, 0x66, 0x46, 0x50, 0x7D, 0x24, 0x85, 0x6D, 0x28, 0xE1, 0x90, 0x0E, +/* 2B30 */ 0x69, 0x03, 0x2F, 0x1F, 0x09, 0x98, 0x8E, 0x02, 0x10, 0x09, 0xA9, 0x84, 0x1A, 0x92, 0x29, 0x2E, +/* 2B40 */ 0xC2, 0x6D, 0x37, 0x5C, 0xA3, 0x69, 0x3E, 0x9B, 0x0B, 0x52, 0x06, 0x44, 0x1F, 0x04, 0x10, 0x11, +/* 2B50 */ 0x37, 0x60, 0xFB, 0x27, 0xA1, 0xA0, 0x5A, 0x06, 0x27, 0xDF, 0x27, 0xDF, 0x27, 0xA1, 0xA0, 0x03, +/* 2B60 */ 0x3F, 0x56, 0x08, 0x24, 0x71, 0x8B, 0x03, 0x3F, 0x56, 0x0C, 0x24, 0x7E, 0x86, 0x72, 0x3F, 0x56, +/* 2B70 */ 0x4A, 0x04, 0x06, 0x98, 0x78, 0xA1, 0xFB, 0x69, 0x2D, 0x06, 0x03, 0x30, 0x26, 0x56, 0x05, 0x0D, +/* 2B80 */ 0x6D, 0x05, 0x24, 0xA7, 0x09, 0x3F, 0x56, 0x04, 0x18, 0x05, 0x18, 0x06, 0x18, 0x06, 0x18, 0x06, +/* 2B90 */ 0x18, 0x06, 0x44, 0x1F, 0x03, 0x02, 0x10, 0x15, 0xA4, 0x6E, 0x3C, 0x1C, 0x2D, 0x27, 0x95, 0xFB, +/* 2BA0 */ 0x0F, 0x8A, 0x27, 0x9C, 0xA2, 0x2D, 0x33, 0x43, 0x05, 0x27, 0x4E, 0x98, 0x2D, 0x4A, 0x1F, 0x27, +/* 2BB0 */ 0x6B, 0x1D, 0x23, 0x4A, 0x1F, 0x27, 0x5E, 0xFB, 0x23, 0x4A, 0x1F, 0x27, 0x79, 0x74, 0x23, 0x4A, +/* 2BC0 */ 0x1F, 0x27, 0x5E, 0xFB, 0x23, 0x4A, 0x1F, 0x27, 0x95, 0x71, 0x23, 0x4A, 0x1F, 0x27, 0x4E, 0xA3, +/* 2BD0 */ 0x2D, 0x4A, 0x1F, 0x27, 0x49, 0x2D, 0x09, 0x1F, 0x27, 0x26, 0x64, 0x8B, 0x4A, 0x1F, 0x27, 0x50, +/* 2BE0 */ 0x05, 0x09, 0x0A, 0x30, 0x6E, 0x27, 0xDB, 0x07, 0xDB, 0x07, 0xDB, 0x07, 0xDB, 0x07, 0xDB, 0x07, +/* 2BF0 */ 0x2F, 0xA2, 0x59, 0x00, 0x7E, 0x05, 0x03, 0x01, 0x10, 0x07, 0xA9, 0x60, 0xD6, 0x91, 0x9A, 0x10, +/* 2C00 */ 0x08, 0xAA, 0x60, 0x60, 0x03, 0x6F, 0x21, 0xA2, 0x6F, 0x9B, 0xFB, 0x76, 0x02, 0x6C, 0x6F, 0x5E, +/* 2C10 */ 0x50, 0x66, 0x03, 0x28, 0x1F, 0x05, 0x40, 0x80, 0x3F, 0x58, 0x0F, 0x8B, 0x57, 0x34, 0xA2, 0x0C, +/* 2C20 */ 0x0E, 0x8E, 0x02, 0x10, 0x0C, 0x46, 0x1A, 0x3B, 0x1F, 0x0B, 0x69, 0x44, 0x74, 0x1C, 0x69, 0x44, +/* 2C30 */ 0xA3, 0x41, 0x69, 0x44, 0x08, 0x0A, 0x02, 0x04, 0x69, 0x1A, 0xCB, 0x1A, 0xCB, 0x1A, 0xCB, 0x10, +/* 2C40 */ 0x0F, 0xA4, 0x05, 0x36, 0x52, 0x8F, 0x28, 0x09, 0x2D, 0x69, 0x03, 0x24, 0xA6, 0x0C, 0x05, 0x04, +/* 2C50 */ 0x45, 0x57, 0x26, 0x0D, 0x87, 0x24, 0x74, 0x19, 0x3F, 0x5F, 0x09, 0x46, 0x5F, 0x0A, 0x3F, 0xA2, +/* 2C60 */ 0x27, 0xA1, 0x0E, 0x6D, 0x25, 0x66, 0x06, 0xA1, 0x0E, 0x52, 0x25, 0x66, 0x06, 0xA1, 0x0E, 0x6D, +/* 2C70 */ 0x26, 0x71, 0x0F, 0x6F, 0x46, 0x61, 0x0A, 0x34, 0x0E, 0x52, 0xFB, 0x19, 0x25, 0x45, 0x0A, 0x02, +/* 2C80 */ 0x84, 0x0E, 0x87, 0x34, 0x85, 0x23, 0x05, 0x46, 0x50, 0x09, 0x93, 0x6D, 0x04, 0x82, 0x50, 0x03, +/* 2C90 */ 0x03, 0x02, 0x26, 0xA9, 0xE5, 0xE0, 0x10, 0x11, 0x89, 0x60, 0xA2, 0x6A, 0x37, 0x08, 0x0A, 0x2F, +/* 2CA0 */ 0x73, 0x09, 0x00, 0x71, 0x19, 0x00, 0xA6, 0x05, 0x00, 0x53, 0x69, 0x03, 0x2F, 0xA3, 0x75, 0x73, +/* 2CB0 */ 0x0C, 0x24, 0x68, 0x6D, 0x37, 0xD1, 0x26, 0x58, 0x0F, 0x6F, 0x37, 0x98, 0x29, 0x24, 0x50, 0x93, +/* 2CC0 */ 0xEF, 0x84, 0x1E, 0x75, 0x3F, 0xA5, 0x6F, 0x00, 0x53, 0x0F, 0x29, 0x4E, 0x58, 0x0F, 0x6F, 0x37, +/* 2CD0 */ 0x98, 0x29, 0x37, 0x49, 0x75, 0xA5, 0x6D, 0x34, 0x98, 0x29, 0x1F, 0x0E, 0x69, 0x5A, 0x74, 0x30, +/* 2CE0 */ 0x53, 0x0F, 0x29, 0x25, 0x73, 0x0C, 0x1D, 0x30, 0x9C, 0x58, 0x69, 0x02, 0x37, 0x98, 0x57, 0x9C, +/* 2CF0 */ 0x7E, 0x0E, 0xA8, 0x71, 0x1E, 0x03, 0x2F, 0x83, 0x37, 0x71, 0x05, 0x10, 0x1B, 0x9C, 0x3B, 0x58, +/* 2D00 */ 0x8D, 0x89, 0x5C, 0x87, 0x6B, 0x1F, 0x0B, 0x69, 0x5E, 0xCF, 0xEF, 0xFA, 0x2A, 0x0D, 0x26, 0x1D, +/* 2D10 */ 0x69, 0xA1, 0x0B, 0x0F, 0x07, 0x46, 0x0D, 0x97, 0x8C, 0x1D, 0x69, 0x24, 0x71, 0x87, 0x24, 0x42, +/* 2D20 */ 0x52, 0x5E, 0x1D, 0x69, 0x58, 0x6F, 0x46, 0xA3, 0x06, 0x5E, 0x1D, 0x69, 0x37, 0x5F, 0x01, 0x1D, +/* 2D30 */ 0x87, 0x34, 0x09, 0x4A, 0x58, 0xB7, 0x82, 0xA3, 0x06, 0x95, 0xF3, 0x0E, 0x96, 0x8C, 0x5C, 0x10, +/* 2D40 */ 0x1B, 0x9C, 0x3B, 0x58, 0x8D, 0x89, 0x5C, 0x87, 0x6B, 0x1F, 0x0B, 0x69, 0x5E, 0xCF, 0xEF, 0xFA, +/* 2D50 */ 0x2A, 0x0D, 0x26, 0x1D, 0x69, 0xA1, 0x0B, 0x0F, 0x07, 0x1F, 0x09, 0x0E, 0x90, 0x05, 0x82, 0x1D, +/* 2D60 */ 0x69, 0x24, 0x71, 0x87, 0x00, 0x38, 0x8B, 0x6F, 0x89, 0x1D, 0x69, 0x58, 0x6F, 0x53, 0x0F, 0x88, +/* 2D70 */ 0x05, 0x98, 0xE9, 0x84, 0x69, 0x37, 0x5F, 0x01, 0x1D, 0x1D, 0x1E, 0x02, 0x4E, 0x09, 0x4A, 0x89, +/* 2D80 */ 0x71, 0x1E, 0x01, 0x9C, 0x73, 0x02, 0x8C, 0x08, 0x76, 0x4E, 0x08, 0x76, 0x89, 0x71, 0x69, 0x02, +/* 2D90 */ 0x9C, 0x73, 0x04, 0x82, 0x38, 0x04, 0x6B, 0xFB, 0x6D, 0xA1, 0x1F, 0x0D, 0x29, 0x26, 0x0D, 0x29, +/* 2DA0 */ 0x46, 0x1F, 0x0D, 0x29, 0x4E, 0xA2, 0x52, 0x89, 0xE1, 0x07, 0x04, 0x2B, 0x02, 0x95, 0xA3, 0x06, +/* 2DB0 */ 0x89, 0x08, 0x23, 0x06, 0x82, 0x1D, 0x87, 0x89, 0x08, 0x23, 0x05, 0x6B, 0x0B, 0x0F, 0x07, 0x5E, +/* 2DC0 */ 0x50, 0x0E, 0x96, 0x8C, 0x5C, 0x10, 0x1B, 0x9C, 0x3B, 0x58, 0x8D, 0x89, 0x5C, 0x87, 0x82, 0xFB, +/* 2DD0 */ 0x0C, 0xA7, 0x0A, 0x03, 0x46, 0x58, 0x6F, 0x82, 0x58, 0x2D, 0x75, 0x46, 0x5F, 0x02, 0x6B, 0x91, +/* 2DE0 */ 0x0B, 0x77, 0xC2, 0x08, 0x89, 0x08, 0x76, 0x9C, 0x58, 0x4A, 0xA1, 0x73, 0x03, 0x3F, 0x64, 0x05, +/* 2DF0 */ 0x46, 0x74, 0x3D, 0x26, 0x56, 0x0D, 0x06, 0x89, 0x0E, 0x72, 0x26, 0xA5, 0x52, 0x67, 0xFB, 0x6D, +/* 2E00 */ 0x4E, 0x1F, 0x40, 0x0E, 0x4A, 0x46, 0x0D, 0x29, 0x34, 0x74, 0x69, 0x24, 0xA2, 0x52, 0x28, 0x66, +/* 2E10 */ 0x01, 0x24, 0x0B, 0x0F, 0x07, 0x46, 0x0D, 0x97, 0x82, 0x7E, 0x37, 0x74, 0x69, 0x71, 0x87, 0x24, +/* 2E20 */ 0x42, 0x52, 0x89, 0x71, 0x8E, 0x02, 0x01, 0x64, 0x09, 0x53, 0x6F, 0x46, 0xA3, 0x06, 0x8C, 0x85, +/* 2E30 */ 0x2D, 0x6A, 0x5F, 0x01, 0x1D, 0x87, 0x89, 0xFB, 0x0A, 0x0B, 0x0A, 0x06, 0x37, 0x09, 0x4A, 0x58, +/* 2E40 */ 0xB7, 0x82, 0xA3, 0x06, 0x95, 0xF3, 0x0E, 0x96, 0x8C, 0x5C, 0x10, 0x0E, 0x46, 0x48, 0x60, 0x91, +/* 2E50 */ 0x8E, 0x18, 0x29, 0x82, 0xA6, 0x29, 0x2E, 0x91, 0x8E, 0x79, 0xAA, 0x1D, 0x55, 0xCE, 0xF1, 0x7C, +/* 2E60 */ 0x0D, 0x8C, 0x68, 0x76, 0x9B, 0x1F, 0x98, 0x72, 0x44, 0xE1, 0x4A, 0x34, 0x2A, 0x27, 0x00, 0xF8, +/* 2E70 */ 0x29, 0x2E, 0xA0, 0x06, 0x21, 0x8B, 0x1A, 0x0F, 0x69, 0x46, 0x71, 0x2F, 0x98, 0x29, 0x37, 0xA2, +/* 2E80 */ 0x90, 0x02, 0xA6, 0x4A, 0x06, 0x06, 0xA0, 0x7A, 0x34, 0x09, 0x23, 0x0C, 0x02, 0x2F, 0xA2, 0x0A, +/* 2E90 */ 0x1C, 0x41, 0x06, 0x10, 0x11, 0x48, 0x05, 0xC6, 0x82, 0xB6, 0xCC, 0x10, 0x11, 0x48, 0xFB, 0xD2, +/* 2EA0 */ 0x1E, 0x88, 0x28, 0xFB, 0x3E, 0x5E, 0x81, 0xB6, 0xCC, 0x10, 0x11, 0x48, 0x6E, 0x0D, 0x3D, 0x01, +/* 2EB0 */ 0x46, 0x5C, 0x93, 0x6D, 0xE3, 0xA1, 0xB6, 0xCC, 0x10, 0x11, 0x48, 0xF0, 0xC4, 0x34, 0x81, 0xB6, +/* 2EC0 */ 0xCC, 0x10, 0x11, 0x3F, 0x81, 0xB3, 0x95, 0xAA, 0xB6, 0xCC, 0x10, 0x11, 0x46, 0x1D, 0x0A, 0x0C, +/* 2ED0 */ 0x0A, 0x5D, 0x84, 0x8B, 0x69, 0x5D, 0x0B, 0x29, 0x83, 0x6F, 0x9B, 0x98, 0x1F, 0x3D, 0x9B, 0x0B, +/* 2EE0 */ 0x0F, 0x03, 0xA2, 0x4A, 0x9B, 0x66, 0x98, 0x62, 0x25, 0xFB, 0x0D, 0x90, 0x04, 0x89, 0x81, 0xB6, +/* 2EF0 */ 0xCC, 0x10, 0x17, 0x00, 0x35, 0x58, 0x1E, 0x8A, 0x52, 0x9C, 0x7E, 0x93, 0x8A, 0x76, 0x4E, 0x56, +/* 2F00 */ 0x98, 0x72, 0x31, 0x02, 0x4E, 0x0B, 0x52, 0x45, 0x5A, 0xA1, 0x61, 0x08, 0x66, 0x05, 0x28, 0x74, +/* 2F10 */ 0x1E, 0x03, 0x02, 0x30, 0x28, 0xDE, 0x24, 0x0E, 0x6D, 0x28, 0x5F, 0x08, 0x24, 0x0B, 0x69, 0x28, +/* 2F20 */ 0xA5, 0x62, 0x45, 0x03, 0x2F, 0x0D, 0x52, 0x37, 0x66, 0x08, 0x2B, 0x2B, 0x02, 0x5E, 0x71, 0x0F, +/* 2F30 */ 0x6F, 0x00, 0x1F, 0x8A, 0x0A, 0x95, 0x45, 0x03, 0x46, 0x0E, 0x23, 0x76, 0x95, 0x0E, 0x52, 0xA1, +/* 2F40 */ 0xA0, 0x01, 0x24, 0x49, 0x08, 0xA1, 0x45, 0x04, 0x3F, 0x09, 0x8A, 0x27, 0x26, 0x7C, 0x8A, 0x76, +/* 2F50 */ 0x6B, 0x2A, 0x4A, 0x31, 0x0E, 0x52, 0x95, 0x58, 0x1E, 0x03, 0x82, 0xA0, 0x01, 0x9C, 0x61, 0x0D, +/* 2F60 */ 0x8C, 0x45, 0x04, 0x9C, 0x56, 0x09, 0x37, 0x2A, 0x4A, 0x43, 0x2B, 0x59, 0x89, 0xA0, 0x04, 0x89, +/* 2F70 */ 0x1F, 0x8A, 0x03, 0xA1, 0x5F, 0x0E, 0x5E, 0x7C, 0x23, 0x03, 0x10, 0x10, 0xE7, 0x00, 0x09, 0x23, +/* 2F80 */ 0x3D, 0x01, 0x9C, 0x58, 0x0F, 0x69, 0x08, 0xF9, 0x0C, 0x69, 0x03, 0x26, 0x74, 0x1E, 0x7A, 0x46, +/* 2F90 */ 0x74, 0x05, 0x50, 0x93, 0x02, 0x2E, 0xD1, 0x4B, 0x72, 0x8C, 0x50, 0x8B, 0x01, 0x24, 0xF8, 0xF1, +/* 2FA0 */ 0x66, 0x0C, 0x18, 0x0B, 0x18, 0x0B, 0x28, 0x2A, 0x6D, 0x00, 0xCD, 0xF1, 0x02, 0x8B, 0x1A, 0x93, +/* 2FB0 */ 0x03, 0x21, 0x9D, 0x08, 0x65, 0x96, 0x44, 0x53, 0x33, 0x46, 0x71, 0x06, 0x00, 0x50, 0x98, 0x6D, +/* 2FC0 */ 0x05, 0x01, 0xF0, 0x45, 0x05, 0x26, 0x1F, 0x0D, 0x23, 0x69, 0x04, 0x34, 0x83, 0x0D, 0x8B, 0x69, +/* 2FD0 */ 0x8D, 0x28, 0x1F, 0x52, 0x59, 0x9B, 0x1F, 0x6D, 0x5E, 0x68, 0x27, 0x5E, 0x50, 0x66, 0x04, 0x1A, +/* 2FE0 */ 0x0B, 0x6F, 0x44, 0x59, 0xE1, 0x07, 0x9B, 0x05, 0x2D, 0x5D, 0x05, 0x93, 0x9F, 0x44, 0x1F, 0x02, +/* 2FF0 */ 0x10, 0x0F, 0x48, 0x07, 0x0A, 0x02, 0x5E, 0x50, 0x93, 0x67, 0x44, 0x92, 0x1E, 0x52, 0x05, 0x2E, +/* 3000 */ 0x83, 0x0D, 0x19, 0x9B, 0x1D, 0x97, 0x81, 0x84, 0xD4, 0x10, 0x0F, 0x37, 0x48, 0x74, 0x0B, 0x9B, +/* 3010 */ 0x1D, 0x98, 0x29, 0x28, 0x1F, 0xA0, 0x6D, 0x05, 0x00, 0x28, 0x73, 0x9A, 0x03, 0x2E, 0x08, 0x06, +/* 3020 */ 0x01, 0x24, 0x81, 0x1D, 0xD4, 0x10, 0x0F, 0x48, 0x84, 0x0E, 0x76, 0x2E, 0x66, 0x33, 0x01, 0x25, +/* 3030 */ 0xFB, 0x33, 0x07, 0x1C, 0x6A, 0x00, 0x68, 0xEC, 0x1F, 0x0C, 0x3D, 0x28, 0x08, 0x02, 0x46, 0x74, +/* 3040 */ 0x03, 0x81, 0x04, 0xD4, 0x10, 0x0F, 0x26, 0x81, 0x85, 0x0E, 0x08, 0x24, 0x85, 0x0E, 0x08, 0x4E, +/* 3050 */ 0x2A, 0x69, 0x24, 0x66, 0x0E, 0x37, 0x50, 0x36, 0x08, 0x24, 0x91, 0x70, 0x46, 0xAA, 0x1D, 0xD4, +/* 3060 */ 0x10, 0x08, 0x8C, 0x1A, 0x1A, 0x08, 0x0A, 0x02, 0x21, 0x73, 0x70, 0x2E, 0x92, 0x1E, 0x52, 0x05, +/* 3070 */ 0x2E, 0x83, 0x98, 0x29, 0x21, 0xA2, 0x97, 0xA1, 0x81, 0x22, 0xCA, 0x10, 0x08, 0x95, 0x1A, 0x1A, +/* 3080 */ 0x83, 0x0B, 0x2E, 0xA2, 0x98, 0x72, 0x37, 0x5C, 0xA0, 0x6D, 0xEF, 0x28, 0x5F, 0x9A, 0x03, 0x2E, +/* 3090 */ 0x08, 0x06, 0x01, 0x5E, 0x81, 0x22, 0xCA, 0x10, 0x08, 0x5E, 0x1A, 0x1A, 0x64, 0x09, 0x28, 0xFB, +/* 30A0 */ 0x8B, 0x76, 0x9B, 0xA5, 0x76, 0x07, 0x33, 0x01, 0x4E, 0x2A, 0xEC, 0x71, 0x0C, 0x76, 0x28, 0x08, +/* 30B0 */ 0x02, 0xA1, 0x08, 0x5A, 0x48, 0x22, 0xCA, 0x10, 0x08, 0x95, 0x81, 0x85, 0x70, 0x24, 0x85, 0x70, +/* 30C0 */ 0x24, 0xA6, 0x0E, 0x24, 0x56, 0x0D, 0x2F, 0x85, 0x70, 0x24, 0x85, 0x70, 0x95, 0xAA, 0x22, 0xCA, +/* 30D0 */ 0x10, 0x13, 0x35, 0x7C, 0x8B, 0xA7, 0x0B, 0x06, 0x02, 0x2F, 0x0E, 0x8A, 0x8D, 0x25, 0x93, 0x2B, +/* 30E0 */ 0x06, 0x0A, 0x93, 0x6A, 0x26, 0x93, 0x01, 0x24, 0x1F, 0xA3, 0x4A, 0x3F, 0x93, 0x01, 0xA1, 0x5F, +/* 30F0 */ 0x62, 0x9C, 0x93, 0x01, 0x89, 0x9D, 0x09, 0x26, 0x93, 0x01, 0x37, 0x1D, 0x0F, 0x52, 0x26, 0x93, +/* 3100 */ 0x01, 0x89, 0x61, 0xE9, 0x89, 0x7C, 0xE9, 0x98, 0x62, 0x8C, 0x7E, 0x43, 0x93, 0x2B, 0x59, 0x37, +/* 3110 */ 0xA3, 0x72, 0x89, 0x2A, 0x23, 0x29, 0x37, 0xA3, 0x29, 0x89, 0x2A, 0x23, 0x29, 0x37, 0xA3, 0x29, +/* 3120 */ 0x9C, 0x7C, 0xE9, 0x98, 0x72, 0x9C, 0x7C, 0xE9, 0x93, 0x03, 0x4E, 0x93, 0x01, 0x89, 0x61, 0xE9, +/* 3130 */ 0x82, 0x93, 0x01, 0x37, 0x1D, 0x0F, 0x6D, 0x26, 0x93, 0x01, 0x24, 0x58, 0x0F, 0x6F, 0x26, 0x93, +/* 3140 */ 0x01, 0x37, 0x71, 0x8B, 0x02, 0x26, 0x93, 0x01, 0x46, 0xE1, 0x6F, 0x3F, 0x93, 0x2B, 0x06, 0x0A, +/* 3150 */ 0x1E, 0x76, 0x3F, 0x7C, 0x23, 0x70, 0x25, 0x7C, 0x8B, 0xA7, 0x0B, 0x3E, 0x10, 0x13, 0x2E, 0x1A, +/* 3160 */ 0x50, 0x03, 0x37, 0x7E, 0x00, 0x28, 0xA5, 0x69, 0x08, 0x04, 0x09, 0x0F, 0x07, 0x34, 0xA2, 0x23, +/* 3170 */ 0x75, 0x3F, 0x74, 0x0C, 0x59, 0x06, 0x0C, 0x90, 0x94, 0x81, 0x1D, 0xF4, 0x89, 0x33, 0x49, 0x1C, +/* 3180 */ 0xBE, 0xEE, 0x3D, 0x49, 0x06, 0x89, 0xA3, 0x33, 0x95, 0x1D, 0x19, 0x2A, 0x33, 0x10, 0x14, 0x48, +/* 3190 */ 0x53, 0x67, 0x65, 0xEC, 0xA1, 0x5C, 0xA0, 0x6D, 0x04, 0x9B, 0x1F, 0x08, 0x93, 0x03, 0x9B, 0xFB, +/* 31A0 */ 0x09, 0x24, 0x81, 0x71, 0x09, 0x63, 0xA7, 0xFE, 0xAF, 0x50, 0x0A, 0xC1, 0x10, 0x14, 0x46, 0x48, +/* 31B0 */ 0x7E, 0x09, 0x09, 0x21, 0xC2, 0x4F, 0x34, 0x1D, 0xA3, 0x33, 0x03, 0x46, 0x68, 0x69, 0x08, 0x02, +/* 31C0 */ 0x2E, 0x09, 0x05, 0x00, 0x48, 0x5C, 0x09, 0x63, 0xA7, 0xFE, 0xAF, 0x50, 0x0A, 0xC1, 0x10, 0x14, +/* 31D0 */ 0x1A, 0x1A, 0x39, 0x44, 0x08, 0x8B, 0x6F, 0x9B, 0x9D, 0x09, 0x45, 0x0A, 0x2F, 0x74, 0x69, 0xEF, +/* 31E0 */ 0x84, 0x0D, 0x6F, 0x37, 0x50, 0x67, 0x37, 0x7E, 0x67, 0x81, 0x71, 0x09, 0x63, 0xA7, 0xFE, 0xAF, +/* 31F0 */ 0x50, 0x0A, 0xC1, 0x10, 0x14, 0x2E, 0x1A, 0x50, 0x03, 0x01, 0x24, 0x7E, 0x46, 0xA6, 0x9A, 0x04, +/* 3200 */ 0x08, 0x4A, 0x5C, 0x23, 0x72, 0x26, 0xFB, 0x0C, 0x05, 0x01, 0x05, 0x0B, 0xA7, 0x05, 0x9C, 0x81, +/* 3210 */ 0x5C, 0x09, 0x63, 0xA7, 0xFE, 0xAF, 0x50, 0x0A, 0xC1, 0x10, 0x14, 0x6B, 0x48, 0x5C, 0x0D, 0x9F, +/* 3220 */ 0xC5, 0x33, 0x25, 0x1F, 0x0D, 0x9F, 0x1F, 0x0D, 0x9F, 0x79, 0x81, 0x5C, 0x09, 0x63, 0xA7, 0xFE, +/* 3230 */ 0xAF, 0x50, 0x0A, 0xC1, 0x10, 0x0F, 0x34, 0x60, 0x5C, 0x46, 0x71, 0x01, 0x34, 0x74, 0x4A, 0x24, +/* 3240 */ 0x1F, 0x90, 0x02, 0x34, 0x09, 0x19, 0x7E, 0x0D, 0x69, 0x03, 0x2F, 0xA0, 0xEF, 0xA3, 0x72, 0x46, +/* 3250 */ 0x50, 0x98, 0x41, 0x0F, 0x29, 0x9B, 0x38, 0x27, 0x2E, 0x0B, 0x8B, 0x03, 0x44, 0x9D, 0x1C, 0x75, +/* 3260 */ 0x2F, 0xD1, 0x38, 0x57, 0x26, 0xA2, 0x33, 0x00, 0x84, 0x0F, 0x6D, 0x2F, 0x0B, 0x0F, 0x57, 0x56, +/* 3270 */ 0x04, 0x2F, 0x8F, 0x37, 0x74, 0x04, 0x10, 0x14, 0xA1, 0xA9, 0x1F, 0x07, 0x03, 0x00, 0x18, 0x5A, +/* 3280 */ 0xA1, 0x58, 0x0F, 0x51, 0x0E, 0x6F, 0x00, 0x5C, 0x09, 0x63, 0xA7, 0x80, 0x50, 0x0A, 0x23, 0x3D, +/* 3290 */ 0x02, 0x25, 0xA0, 0x0D, 0x07, 0x04, 0x05, 0x86, 0x52, 0x01, 0x26, 0x08, 0x33, 0x01, 0x37, 0x0B, +/* 32A0 */ 0x90, 0x33, 0x4E, 0x5F, 0x96, 0x24, 0x7E, 0x3D, 0x01, 0x98, 0x72, 0x9C, 0x08, 0x27, 0x37, 0xA2, +/* 32B0 */ 0x0F, 0x07, 0x00, 0xA5, 0x76, 0x9C, 0xFD, 0x37, 0x09, 0x4F, 0x61, 0x0E, 0x79, 0x61, 0x0E, 0xA1, +/* 32C0 */ 0x0D, 0x0D, 0x37, 0x98, 0x62, 0x89, 0x1D, 0x0F, 0x6D, 0x24, 0x1F, 0x4A, 0x37, 0xA0, 0x05, 0x6B, +/* 32D0 */ 0xA2, 0x33, 0xFB, 0x29, 0x00, 0x53, 0x27, 0x95, 0x56, 0x0A, 0x58, 0x0F, 0x01, 0x37, 0x09, 0x27, +/* 32E0 */ 0x95, 0x56, 0x0A, 0x46, 0x90, 0x46, 0x09, 0x27, 0x89, 0x2A, 0x76, 0x00, 0x71, 0x6F, 0x58, 0x19, +/* 32F0 */ 0x6B, 0x4C, 0x00, 0x74, 0x72, 0x46, 0xA0, 0x05, 0x95, 0x5F, 0x0E, 0x37, 0x36, 0xA1, 0xFD, 0x95, +/* 3300 */ 0xFD, 0x01, 0x3D, 0x46, 0x61, 0x0E, 0x9C, 0x9D, 0x06, 0xA2, 0xA8, 0x37, 0x56, 0x0A, 0x95, 0x71, +/* 3310 */ 0x0F, 0x52, 0x00, 0x09, 0x4F, 0x37, 0x98, 0x72, 0x4E, 0x9D, 0x09, 0x0D, 0x0D, 0x46, 0x9D, 0x0A, +/* 3320 */ 0x4E, 0x7E, 0x86, 0x6D, 0x04, 0x40, 0x98, 0x52, 0x01, 0x3F, 0x91, 0x23, 0x3D, 0x01, 0x3F, 0x71, +/* 3330 */ 0x1E, 0x63, 0xA7, 0x88, 0x2F, 0x74, 0x69, 0xCE, 0x0B, 0xAB, 0x07, 0x6B, 0x50, 0x05, 0x02, 0x10, +/* 3340 */ 0x13, 0x48, 0xA2, 0xC6, 0x24, 0x78, 0xB5, 0x10, 0x13, 0x00, 0x48, 0xFB, 0xD2, 0x1E, 0x88, 0x28, +/* 3350 */ 0xFB, 0x3E, 0x46, 0x81, 0x78, 0xB5, 0x10, 0x13, 0x48, 0x1F, 0x0D, 0x3D, 0x01, 0x46, 0x5C, 0x93, +/* 3360 */ 0x6D, 0xE3, 0x78, 0xB5, 0x10, 0x13, 0x25, 0x81, 0xB3, 0x89, 0xAA, 0x78, 0xB5, 0x10, 0x10, 0x21, +/* 3370 */ 0x1A, 0x50, 0x09, 0x08, 0x2E, 0x74, 0x0E, 0x87, 0x2F, 0x1D, 0x0D, 0x1E, 0x76, 0x5A, 0x2A, 0x52, +/* 3380 */ 0x3E, 0x2E, 0x7D, 0x81, 0x58, 0xC7, 0x27, 0x6C, 0x07, 0x10, 0x11, 0x35, 0x20, 0x20, 0x20, 0x20, +/* 3390 */ 0x04, 0x2D, 0xA7, 0x0B, 0x07, 0x02, 0x00, 0x68, 0x23, 0x27, 0x68, 0x6D, 0x2B, 0x06, 0xA0, 0x6F, +/* 33A0 */ 0xF6, 0xFB, 0x8B, 0x02, 0xE2, 0x0A, 0x0F, 0x6F, 0xE2, 0x06, 0x33, 0xE2, 0x04, 0x0F, 0x6D, 0xE2, +/* 33B0 */ 0x04, 0x0F, 0x6D, 0xE2, 0x56, 0x0A, 0xE2, 0x0B, 0x27, 0x26, 0x4C, 0xFB, 0x0F, 0x87, 0x00, 0x49, +/* 33C0 */ 0x0C, 0x2B, 0x5B, 0x8B, 0x06, 0x9C, 0x1D, 0x8A, 0xEC, 0x68, 0x2D, 0x0D, 0x0B, 0x3E, 0x34, 0x20, +/* 33D0 */ 0x20, 0x20, 0x4C, 0x10, 0x11, 0x00, 0x3B, 0x1D, 0x0A, 0x1C, 0x8E, 0xEF, 0x28, 0x08, 0x23, 0x09, +/* 33E0 */ 0x24, 0xA6, 0x0E, 0x77, 0xC2, 0x29, 0x34, 0x98, 0x62, 0xF0, 0x0F, 0x76, 0x26, 0x71, 0x33, 0xA1, +/* 33F0 */ 0x0E, 0x6D, 0x79, 0x2A, 0x6F, 0xA1, 0x0F, 0x76, 0xA6, 0x07, 0x46, 0xA5, 0x72, 0xA6, 0x07, 0x1D, +/* 3400 */ 0x0F, 0x6F, 0x37, 0x39, 0xF0, 0x0E, 0x4A, 0x26, 0xFB, 0x27, 0x53, 0x52, 0xA1, 0x39, 0x00, 0x0D, +/* 3410 */ 0x6D, 0x3F, 0xFB, 0x27, 0x53, 0x0F, 0x29, 0x46, 0x39, 0xF0, 0x0F, 0x19, 0xA6, 0x07, 0x37, 0x64, +/* 3420 */ 0x4A, 0xA6, 0x07, 0x24, 0x71, 0x0E, 0x30, 0x39, 0x46, 0x38, 0x29, 0x39, 0x2A, 0x3D, 0x39, 0x89, +/* 3430 */ 0x93, 0x39, 0x89, 0x98, 0xE9, 0x37, 0xFB, 0x27, 0x82, 0x93, 0x39, 0x24, 0x1D, 0x0F, 0x6D, 0x39, +/* 3440 */ 0xF0, 0x06, 0x40, 0x1C, 0x29, 0x39, 0x00, 0x0A, 0x2D, 0x08, 0x79, 0xFB, 0x27, 0x53, 0x1C, 0x41, +/* 3450 */ 0x05, 0x10, 0x10, 0xA9, 0x03, 0x95, 0x50, 0xA7, 0x94, 0x07, 0x8B, 0x97, 0x44, 0xA2, 0x86, 0xEC, +/* 3460 */ 0x9B, 0x1D, 0x0A, 0x87, 0x2E, 0x1F, 0x05, 0x82, 0xAA, 0x1D, 0x3C, 0xAC, 0x10, 0x10, 0x46, 0xA9, +/* 3470 */ 0x94, 0x6E, 0x0B, 0x62, 0x9B, 0xA5, 0x33, 0x2F, 0x1D, 0x98, 0x52, 0x3E, 0x9B, 0x0C, 0x6D, 0x05, +/* 3480 */ 0x89, 0x5C, 0x04, 0x79, 0xAA, 0x1D, 0x3C, 0xAC, 0x10, 0x10, 0x9C, 0xA9, 0x50, 0xA3, 0x7A, 0x44, +/* 3490 */ 0x85, 0x8B, 0x7A, 0xA1, 0x50, 0xA3, 0xEC, 0x0D, 0x69, 0x03, 0x37, 0x50, 0x0D, 0x3D, 0x01, 0x7E, +/* 34A0 */ 0x09, 0x69, 0x02, 0x34, 0x74, 0x08, 0x46, 0xA2, 0x09, 0x89, 0xAA, 0x1D, 0x3C, 0xAC, 0x10, 0x10, +/* 34B0 */ 0x24, 0x3A, 0x1F, 0x02, 0x37, 0x54, 0x08, 0x63, 0x97, 0x8C, 0x9E, 0x1D, 0x3C, 0xAC, 0x10, 0x10, +/* 34C0 */ 0x24, 0x3B, 0x09, 0x41, 0x37, 0x09, 0x8E, 0x37, 0x50, 0x8B, 0x03, 0x7E, 0x8B, 0x03, 0x2F, 0x09, +/* 34D0 */ 0x8E, 0x37, 0x09, 0x8E, 0x8C, 0x9E, 0x1D, 0x3C, 0xAC, 0x10, 0x10, 0x2E, 0xAA, 0x92, 0x0C, 0x88, +/* 34E0 */ 0x44, 0x38, 0x1E, 0x72, 0x9B, 0x08, 0x0F, 0x3E, 0x05, 0x3D, 0x34, 0x58, 0x4F, 0x00, 0xA7, 0x9B, +/* 34F0 */ 0x09, 0xA8, 0x03, 0x3D, 0xF8, 0x98, 0x29, 0x28, 0x1D, 0x0C, 0xA7, 0x06, 0x8C, 0xAA, 0x1D, 0x3C, +/* 3500 */ 0xAC, 0x10, 0x19, 0x9E, 0xA4, 0x5C, 0x08, 0x0B, 0x1C, 0x41, 0x05, 0x24, 0x42, 0x0C, 0x0E, 0x90, +/* 3510 */ 0x67, 0x5E, 0xA2, 0x23, 0x6F, 0x91, 0x0F, 0x2D, 0x7A, 0x5E, 0x85, 0x09, 0x06, 0xF9, 0x86, 0xA3, +/* 3520 */ 0x6F, 0x43, 0x9D, 0x0D, 0x50, 0x93, 0x29, 0xFB, 0x19, 0x26, 0xA0, 0x0C, 0x89, 0x0E, 0x6D, 0x6B, +/* 3530 */ 0x1F, 0x03, 0x03, 0x04, 0xA0, 0x08, 0x89, 0xA0, 0x8C, 0x7E, 0x08, 0x98, 0x2D, 0x29, 0x89, 0x9D, +/* 3540 */ 0x02, 0x82, 0xE1, 0x8A, 0x8A, 0x03, 0x82, 0x98, 0x6D, 0x05, 0x01, 0x24, 0x9D, 0x8A, 0x62, 0x46, +/* 3550 */ 0x56, 0x57, 0x00, 0x45, 0x08, 0x43, 0x31, 0x82, 0x09, 0x27, 0x46, 0x74, 0x27, 0x3F, 0xA0, 0x05, +/* 3560 */ 0x24, 0x1D, 0x0F, 0x76, 0x79, 0x58, 0x19, 0x46, 0x45, 0x96, 0x4E, 0x74, 0x33, 0x37, 0xA2, 0x8B, +/* 3570 */ 0x76, 0x37, 0x1F, 0x06, 0x8C, 0x73, 0x76, 0x55, 0x09, 0x69, 0x04, 0x0D, 0x1E, 0x99, 0x05, 0x9D, +/* 3580 */ 0x04, 0x82, 0xA2, 0x2D, 0x69, 0x04, 0xF0, 0x0D, 0x2D, 0x33, 0x02, 0x82, 0x71, 0x36, 0x52, 0x8F, +/* 3590 */ 0x24, 0x83, 0x0C, 0x0E, 0x52, 0x88, 0x10, 0x0E, 0x5E, 0x60, 0xA2, 0xAE, 0x2E, 0x5F, 0x0E, 0x4D, +/* 35A0 */ 0x72, 0x18, 0x6A, 0x00, 0x71, 0x28, 0x86, 0x99, 0x05, 0x0A, 0x0F, 0x07, 0x2F, 0x91, 0x2D, 0x33, +/* 35B0 */ 0x28, 0xA2, 0x0A, 0x1E, 0x90, 0x06, 0x2E, 0x98, 0x00, 0x1A, 0x1E, 0x06, 0x02, 0x8C, 0x50, 0x0A, +/* 35C0 */ 0x0C, 0x69, 0x03, 0x9B, 0x58, 0x76, 0x46, 0x5C, 0x01, 0x91, 0x3D, 0x28, 0x1F, 0x8B, 0x27, 0x37, +/* 35D0 */ 0x5C, 0x0D, 0x1E, 0x6F, 0x44, 0x1F, 0x03, 0x01, 0x10, 0x10, 0xA9, 0xF0, 0x00, 0x1A, 0xA5, 0x8D, +/* 35E0 */ 0x21, 0x93, 0x9F, 0x9B, 0x1F, 0x08, 0x0E, 0x33, 0x02, 0x2E, 0x83, 0x0D, 0x4A, 0x1A, 0xA2, 0x01, +/* 35F0 */ 0x95, 0xAA, 0xEA, 0xB1, 0x41, 0x06, 0x10, 0x10, 0x4E, 0x9E, 0x50, 0xAD, 0x88, 0x2F, 0x1D, 0x69, +/* 3600 */ 0x8F, 0x28, 0xFB, 0x01, 0x3F, 0xAA, 0xEA, 0xB1, 0x41, 0x06, 0x10, 0x10, 0x3A, 0x2A, 0x6F, 0x2E, +/* 3610 */ 0x66, 0x30, 0x46, 0xA6, 0x0A, 0xD1, 0x2F, 0xA2, 0x19, 0x84, 0x0D, 0x4A, 0x2F, 0x91, 0x03, 0x37, +/* 3620 */ 0x7E, 0x0A, 0x03, 0x6B, 0xAA, 0xEA, 0xB1, 0x41, 0x06, 0x10, 0x10, 0x3B, 0x71, 0x0D, 0x9F, 0xC5, +/* 3630 */ 0x33, 0x5C, 0x0D, 0x9F, 0x71, 0x0D, 0x9F, 0x79, 0x9E, 0xEA, 0xB1, 0x41, 0x06, 0x10, 0x08, 0x89, +/* 3640 */ 0x9E, 0x50, 0x03, 0x00, 0x1A, 0x08, 0x0F, 0x67, 0x2E, 0x73, 0x52, 0x04, 0x9B, 0x1F, 0x09, 0x1C, +/* 3650 */ 0x76, 0x02, 0x2E, 0x83, 0x0E, 0x6F, 0x44, 0xFB, 0x01, 0x5E, 0x81, 0x18, 0x47, 0x2C, 0x47, 0x2C, +/* 3660 */ 0x47, 0x2C, 0x47, 0x27, 0x10, 0x08, 0xA9, 0x02, 0x02, 0x21, 0x74, 0x8E, 0xA1, 0x5C, 0x86, 0x4F, +/* 3670 */ 0x46, 0x50, 0x9D, 0x76, 0x03, 0x34, 0xFB, 0x69, 0x08, 0x5A, 0xA1, 0xFB, 0x01, 0xAA, 0xA6, 0x47, +/* 3680 */ 0x2C, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x27, 0x10, 0x08, 0x3A, 0x42, 0x27, 0x28, 0xFB, 0x8B, 0x6F, +/* 3690 */ 0x9B, 0xD1, 0x45, 0x08, 0x28, 0xA5, 0x9F, 0x24, 0x64, 0x08, 0x25, 0x1F, 0x0B, 0x02, 0x46, 0x92, +/* 36A0 */ 0x5A, 0x81, 0xA6, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x27, 0x10, 0x08, 0x2E, 0x3A, 0x1D, +/* 36B0 */ 0x0D, 0x0D, 0xEF, 0x84, 0x0D, 0x0D, 0x04, 0x2F, 0x9D, 0x0A, 0x53, 0x30, 0x26, 0x1D, 0x0D, 0x0D, +/* 36C0 */ 0xEF, 0x84, 0x0D, 0x0D, 0x03, 0x26, 0xAA, 0x18, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x2C, 0x47, 0x27, +/* 36D0 */ 0x10, 0x11, 0x89, 0x3A, 0x1F, 0x06, 0x34, 0x1D, 0x0B, 0x07, 0x02, 0x6E, 0x98, 0x07, 0x28, 0x9D, +/* 36E0 */ 0x76, 0xDE, 0x01, 0x34, 0x1F, 0x07, 0x98, 0x8B, 0x02, 0x2E, 0xA3, 0x33, 0x01, 0x34, 0x58, 0x69, +/* 36F0 */ 0xA0, 0x0A, 0x28, 0x74, 0x69, 0x03, 0x00, 0x0A, 0x27, 0x28, 0xA2, 0xEF, 0x7E, 0x0E, 0x87, 0x18, +/* 3700 */ 0x08, 0x2F, 0x1F, 0x03, 0x01, 0x7E, 0x0E, 0x52, 0x34, 0xA2, 0x98, 0x33, 0x03, 0x0A, 0x1E, 0x5A, +/* 3710 */ 0x74, 0x2D, 0x69, 0xA0, 0x06, 0x4E, 0x71, 0x1E, 0x9F, 0x01, 0x01, 0x05, 0x0D, 0x1E, 0x6F, 0x3F, +/* 3720 */ 0xA0, 0x05, 0x37, 0x7E, 0xA3, 0x76, 0x26, 0x61, 0x0D, 0x46, 0x71, 0x33, 0x00, 0x49, 0x09, 0x46, +/* 3730 */ 0x1F, 0x33, 0x26, 0x56, 0x08, 0x46, 0x1F, 0x33, 0x39, 0x37, 0x71, 0x0F, 0x76, 0x6B, 0x2A, 0x6F, +/* 3740 */ 0x37, 0x1D, 0x30, 0x79, 0x71, 0x0F, 0x76, 0xA1, 0x74, 0x19, 0x26, 0x0E, 0x87, 0xA1, 0x86, 0x01, +/* 3750 */ 0x3F, 0x45, 0x08, 0xFB, 0x0F, 0x76, 0x00, 0x50, 0x0D, 0x1E, 0x7D, 0x04, 0x9D, 0x0E, 0x5A, 0x1F, +/* 3760 */ 0x0D, 0x2D, 0x69, 0x03, 0x28, 0x83, 0x0C, 0x0E, 0xA7, 0x67, 0x10, 0x11, 0x37, 0x3A, 0x1F, 0x02, +/* 3770 */ 0x37, 0x54, 0x08, 0x63, 0x97, 0x95, 0xAA, 0x18, 0xC0, 0x19, 0xBA, 0xBA, 0xBA, 0xBA, 0x10, 0x11, +/* 3780 */ 0x00, 0xA9, 0x94, 0x1F, 0x6D, 0x03, 0x21, 0x09, 0x8B, 0x67, 0x82, 0x50, 0x06, 0x98, 0x52, 0x94, +/* 3790 */ 0x05, 0xDE, 0x8C, 0x5C, 0x04, 0x95, 0xAA, 0x5B, 0xB4, 0xF7, 0xB2, 0x10, 0x11, 0xA1, 0xA9, 0x94, +/* 37A0 */ 0xF0, 0x0C, 0x96, 0x82, 0x50, 0x9D, 0x6F, 0x9B, 0x05, 0x1C, 0x6D, 0x05, 0x9B, 0x73, 0x0B, 0x94, +/* 37B0 */ 0x04, 0x03, 0x3F, 0xAA, 0x5B, 0xB4, 0xF7, 0xB2, 0x10, 0x11, 0x37, 0x3A, 0x1F, 0x98, 0x6A, 0x28, +/* 37C0 */ 0x1F, 0x0D, 0x8B, 0x6A, 0x28, 0xE1, 0x0D, 0xC2, 0x6A, 0x34, 0x38, 0x97, 0x00, 0x91, 0x52, 0x01, +/* 37D0 */ 0x2F, 0x09, 0x06, 0x46, 0x74, 0x07, 0x6B, 0xAA, 0x5B, 0xB4, 0xF7, 0xB2, 0x10, 0x11, 0x95, 0xA9, +/* 37E0 */ 0x5C, 0xC4, 0x2E, 0xAA, 0x5B, 0xB4, 0xF7, 0xB2, 0x10, 0x11, 0x24, 0x3B, 0x91, 0x9A, 0x00, 0x7E, +/* 37F0 */ 0x36, 0x08, 0x5C, 0x8B, 0x00, 0x84, 0x8B, 0x28, 0x36, 0x08, 0x37, 0x36, 0x08, 0x79, 0x9E, 0x5B, +/* 3800 */ 0xB4, 0xF7, 0xB2, 0x10, 0x0F, 0x28, 0xAA, 0x3B, 0x1F, 0x0C, 0x70, 0xDC, 0x79, 0x9E, 0xE5, 0xE0, +/* 3810 */ 0x8C, 0x1F, 0x0C, 0x70, 0xDC, 0x10, 0x11, 0x2F, 0xA4, 0x50, 0x08, 0x03, 0x1A, 0x66, 0x01, 0x21, +/* 3820 */ 0x09, 0x3D, 0x4D, 0x07, 0x00, 0x28, 0x5B, 0x1C, 0x93, 0x02, 0x2F, 0x85, 0x23, 0x09, 0x2F, 0xA0, +/* 3830 */ 0x99, 0x86, 0x6F, 0xA6, 0x0A, 0x37, 0x0D, 0x0D, 0x86, 0x03, 0x3F, 0x86, 0x01, 0x1F, 0x6F, 0x04, +/* 3840 */ 0x30, 0x79, 0x1F, 0x33, 0x37, 0xA5, 0x03, 0x7C, 0x0E, 0x00, 0x49, 0x08, 0x37, 0x36, 0x24, 0xA0, +/* 3850 */ 0x01, 0x6B, 0xFB, 0x27, 0x00, 0x7E, 0x4A, 0x53, 0x1E, 0x03, 0x6B, 0xFB, 0x19, 0x42, 0x29, 0x24, +/* 3860 */ 0x9D, 0x04, 0x9C, 0xA2, 0x27, 0x53, 0x0F, 0x01, 0x24, 0x9D, 0x03, 0x49, 0x08, 0x24, 0x41, 0x37, +/* 3870 */ 0xA0, 0x02, 0x9C, 0x7E, 0x33, 0x84, 0xA8, 0x24, 0x0D, 0x69, 0x3F, 0x0C, 0x87, 0x09, 0x0F, 0x01, +/* 3880 */ 0x71, 0x30, 0x6B, 0x2A, 0x4A, 0x0D, 0x0C, 0x37, 0x86, 0x03, 0x25, 0x0B, 0x8B, 0x88, 0x06, 0xA3, +/* 3890 */ 0x6F, 0x34, 0x91, 0x23, 0x09, 0x89, 0x49, 0x1C, 0x8E, 0xEF, 0x28, 0x09, 0x6D, 0x21, 0x7C, 0x07, +/* 38A0 */ 0x65, 0x03, 0x44, 0x1D, 0x08, 0x10, 0x11, 0xA9, 0x84, 0x2E, 0x1D, 0x3D, 0xD9, 0x84, 0x03, 0x8C, +/* 38B0 */ 0xAA, 0xFC, 0xBD, 0x10, 0x11, 0x4E, 0x9E, 0x50, 0x03, 0x44, 0x1D, 0x0D, 0x96, 0x82, 0x50, 0x0A, +/* 38C0 */ 0x0F, 0x27, 0x9B, 0xC2, 0x6D, 0x05, 0x9B, 0x5F, 0x0A, 0x03, 0x2E, 0xA2, 0x02, 0x9C, 0xAA, 0xFC, +/* 38D0 */ 0xBD, 0x10, 0x11, 0xA1, 0x3A, 0xE1, 0x0B, 0x2E, 0xE1, 0x33, 0x01, 0x34, 0x1D, 0x0E, 0x6D, 0xC2, +/* 38E0 */ 0x6A, 0x34, 0xE1, 0x09, 0x1F, 0x0C, 0x6D, 0x28, 0x7D, 0xA1, 0x08, 0x05, 0x82, 0xAA, 0xFC, 0xBD, +/* 38F0 */ 0x10, 0x11, 0x24, 0x3B, 0x85, 0x70, 0x24, 0x85, 0x70, 0x4E, 0x2A, 0x69, 0x24, 0x66, 0x0E, 0x2F, +/* 3900 */ 0x85, 0x70, 0x24, 0x85, 0x70, 0x5E, 0x9E, 0xFC, 0xBD, 0x10, 0x0E, 0x9C, 0x9E, 0x50, 0xAD, 0x88, +/* 3910 */ 0x2F, 0x1D, 0x69, 0x8F, 0x28, 0xFB, 0x01, 0x79, 0xAA, 0xE4, 0xBB, 0x10, 0x11, 0x3B, 0x6E, 0x06, +/* 3920 */ 0x08, 0x04, 0x18, 0x47, 0x2C, 0x47, 0x27, 0x42, 0x0C, 0x0E, 0x41, 0xEF, 0xA6, 0x07, 0x0A, 0x0F, +/* 3930 */ 0x2D, 0x06, 0xA6, 0x1C, 0x7D, 0x04, 0x0A, 0x8B, 0x5A, 0x06, 0x0F, 0x27, 0x46, 0x9D, 0x09, 0x3F, +/* 3940 */ 0x56, 0x0A, 0xA1, 0x5F, 0x0E, 0x3F, 0xD0, 0xB8, 0x01, 0x3F, 0x56, 0x09, 0x1C, 0x8B, 0x69, 0x03, +/* 3950 */ 0xA6, 0x3E, 0x09, 0x0D, 0x52, 0x8F, 0xA6, 0x47, 0x2C, 0x06, 0x5E, 0x50, 0x02, 0x10, 0x0E, 0x3B, +/* 3960 */ 0xF0, 0x0D, 0x9F, 0xC5, 0x33, 0x5C, 0x0D, 0x9F, 0x71, 0x0D, 0x9F, 0x8C, 0x9E, 0xE4, 0xBB, 0x10, +/* 3970 */ 0x00, 0x00, 0x00, 0x12, 0x00, 0x22, 0x00, 0x12, 0x10, 0x21, 0x9E, 0x60, 0xE5, 0x31, 0x01, 0x6B, +/* 3980 */ 0x1D, 0x2D, 0x8A, 0x06, 0x6B, 0x1D, 0x2D, 0x8A, 0x06, 0x10, 0x0F, 0xA9, 0x60, 0x03, 0x43, 0x2B, +/* 3990 */ 0x31, 0x3F, 0x8B, 0x8A, 0x4F, 0x4E, 0x8B, 0x8A, 0x4F, 0x10, 0x17, 0xA9, 0x60, 0x03, 0x43, 0x2B, +/* 39A0 */ 0x31, 0x31, 0x03, 0x8C, 0x0F, 0x8A, 0x8A, 0x69, 0x8C, 0x0F, 0x8A, 0x8A, 0x69, 0x10, +/* char range ofs tables */ +0x00, 0x00, +/* 39B0 */ 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0A, 0xD7, 0x00, 0x00, 0x0A, 0xD9, 0x00, 0x00, +/* 39C0 */ 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x0A, 0xDC, 0x00, 0x00, 0x0B, 0x9A, 0x00, 0x00, +/* 39D0 */ 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x25, 0x01, 0x00, 0x00, 0x25, 0xC1, 0x00, 0x00, +/* 39E0 */ 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x39, 0x70, 0x00, 0x00, 0x39, 0x78, diff --git a/contrib/mcufont/fonts/OFL.txt b/contrib/mcufont/fonts/OFL.txt new file mode 100644 index 000000000..53aea66ca --- /dev/null +++ b/contrib/mcufont/fonts/OFL.txt @@ -0,0 +1,93 @@ +Copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A. + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/contrib/mcufont/fonts/import.sh b/contrib/mcufont/fonts/import.sh new file mode 100755 index 000000000..6665f117b --- /dev/null +++ b/contrib/mcufont/fonts/import.sh @@ -0,0 +1,14 @@ +#!/bin/sh + +PIXEL_SIZES="10 12 14 16 20 24 32" +RANGES="0-255 0x2010-0x2015" +MCUFONT=../../../build/bin/lws-mcufont-encoder + +for i in $PIXEL_SIZES ; do + $MCUFONT import_ttf $1 $i + DAT=`echo $1 | sed 's/\.ttf$//'`$i.dat + $MCUFONT filter $DAT $RANGES + $MCUFONT rlefont_optimize $DAT 50 + $MCUFONT rlefont_export $DAT +done + diff --git a/include/libwebsockets.h b/include/libwebsockets.h index 9fd5a780f..8923035bb 100644 --- a/include/libwebsockets.h +++ b/include/libwebsockets.h @@ -783,6 +783,7 @@ lws_fx_string(const lws_fx_t *a, char *buf, size_t size); #include #include #include +#include #include #include #include diff --git a/include/libwebsockets/lws-display.h b/include/libwebsockets/lws-display.h index abe3440ac..9e4e8a2d3 100644 --- a/include/libwebsockets/lws-display.h +++ b/include/libwebsockets/lws-display.h @@ -45,6 +45,7 @@ typedef enum { LWSSURF_TRUECOLOR32, LWSSURF_565, LWSSURF_PALETTE, + LWSSURF_QUANTIZED_4BPP } lws_surface_type_t; typedef struct lws_surface_info { @@ -53,7 +54,8 @@ typedef struct lws_surface_info { const lws_display_colour_t *palette; size_t palette_depth; lws_surface_type_t type; - char greyscale; /* line: 0 = RGBA, 1 = YA */ + uint8_t greyscale:1; /* line: 0 = RGBA, 1 = YA */ + uint8_t partial:1; /* can handle partial */ } lws_surface_info_t; typedef struct lws_greyscale_error { @@ -74,12 +76,14 @@ lws_surface_set_px(const lws_surface_info_t *ic, uint8_t *line, int x, const lws_display_colour_t *c); LWS_VISIBLE LWS_EXTERN lws_display_palette_idx_t -lws_display_palettize_grey(const struct lws_surface_info *ic, lws_display_colour_t c, - lws_greyscale_error_t *ectx); +lws_display_palettize_grey(const lws_surface_info_t *ic, + const lws_display_colour_t *palette, size_t pdepth, + lws_display_colour_t c, lws_greyscale_error_t *ectx); LWS_VISIBLE LWS_EXTERN lws_display_palette_idx_t -lws_display_palettize_col(const struct lws_surface_info *ic, lws_display_colour_t c, - lws_colour_error_t *ectx); +lws_display_palettize_col(const lws_surface_info_t *ic, + const lws_display_colour_t *palette, size_t pdepth, + lws_display_colour_t c, lws_colour_error_t *ectx); /* * This is embedded in the actual display implementation object at the top, @@ -97,7 +101,7 @@ typedef struct lws_display { const lws_pwm_ops_t *bl_pwm_ops; int (*contrast)(struct lws_display_state *lds, uint8_t contrast); int (*blit)(struct lws_display_state *lds, const uint8_t *src, - lws_box_t *box); + lws_box_t *box, lws_dll2_owner_t *ids); int (*power)(struct lws_display_state *lds, int state); const lws_led_sequence_def_t *bl_active; @@ -111,10 +115,12 @@ typedef struct lws_display { lws_surface_info_t ic; - uint8_t latency_wake_ms; + uint16_t latency_wake_ms; /**< ms required after wake from sleep before display usable again... * delay bringing up the backlight for this amount of time on wake. * This is managed via a sul on the event loop, not blocking. */ + uint16_t latency_update_ms; + /**< nominal update latency in ms */ } lws_display_t; /* @@ -132,6 +138,9 @@ enum lws_display_controller_state { typedef struct lws_display_state { lws_sorted_usec_list_t sul_autodim; + + char current_url[96]; + const lws_display_t *disp; struct lws_context *ctx; @@ -147,8 +156,13 @@ typedef struct lws_display_state { enum lws_display_controller_state state; + char display_busy; + } lws_display_state_t; +/* Used for async display driver events, eg, EPD refresh completion */ +typedef int (*lws_display_completion_t)(lws_display_state_t *lds, int a); + /** * lws_display_state_init() - initialize display states * diff --git a/include/libwebsockets/lws-dlo.h b/include/libwebsockets/lws-dlo.h new file mode 100644 index 000000000..fae02e87d --- /dev/null +++ b/include/libwebsockets/lws-dlo.h @@ -0,0 +1,443 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * lws display_list and display_list objects (dlo) + */ + +#include + +struct lws_display_render_state; +struct lws_surface_info; +struct lws_display_state; +struct lws_display_font; +struct lws_dlo_text; +struct lws_display; +struct lws_dlo_text; +struct lws_dlo; + +#define LWSDC_RGBA(_r, _g, _b, _a) (((uint32_t)(_r) & 0xff) | \ + (((uint32_t)(_g) & 0xff) << 8) | \ + (((uint32_t)(_b) & 0xff) << 16) | \ + (((uint32_t)(_a) & 0xff) << 24)) + +#define LWSDC_R(_c) ((_c) & 0xff) +#define LWSDC_G(_c) ((_c >> 8) & 0xff) +#define LWSDC_B(_c) ((_c >> 16) & 0xff) +#define LWSDC_ALPHA(_c) ((_c >> 24) & 0xff) + +#define RGB_TO_Y(_r, _g, _b) ((((_r) * 299) + ((_g) * 587) + ((_b) * 114)) / 1000) +/* stores Y in RGBY */ +#define PALETTE_RGBY(_r, _g, _b) LWSDC_RGBA(_r, _g, _b, (RGB_TO_Y(_r, _g, _b))) + +/* + * When using RGBA to describe native greyscale, R is Y and A is A, GB is ignored + */ + +/* composed at start of larger, font-specific glyph struct */ + +typedef struct lws_font_glyph { + lws_dll2_t list; + + lws_fx_t xorg; + lws_fx_t xpx; + lws_fx_t height; + lws_fx_t cwidth; + + int8_t x; /* x offset inside the glyph */ + +} lws_font_glyph_t; + +typedef lws_stateful_ret_t (*lws_dlo_renderer_t)(struct lws_display_render_state *rs); +typedef lws_font_glyph_t * (*lws_dlo_image_glyph_t)( + struct lws_dlo_text *text, + uint32_t unicode, char attach); +typedef void (*lws_dlo_destroy_t)(struct lws_dlo *dlo); + +/* + * Common dlo object that joins the display list, composed into a subclass + * object like lws_dlo_rect_t etc + */ + +typedef struct lws_dlo { + lws_dll2_t list; + + /* children are rendered "inside" the parent DLO box after allowing + * for parent padding */ + lws_dll2_owner_t children; + + lws_dlo_destroy_t _destroy; /* dlo-type specific cb */ + lws_dlo_renderer_t render; /* dlo-type specific cb */ + + lws_box_t box; + lws_display_colour_t dc; + + uint8_t flag_runon:1; /* continues same line */ + uint8_t flag_done_align:1; /* continues same line */ + + /* render-specific members ... */ +} lws_dlo_t; + +typedef struct lws_circle { + lws_fx_t r; + + /* rasterization temps */ + lws_fx_t orx; /* abs pixel x for centre */ + lws_fx_t ory; /* abs pixel y for centre */ + lws_fx_t rsq; + lws_fx_t ys; +} lws_circle_t; + +typedef struct lws_dlo_rect { + lws_dlo_t dlo; + lws_circle_t c[4]; /* t-l, t-r, b-l, b-r */ + lws_fx_t b[4]; /* border width on t/r/b/l */ + lws_display_colour_t dcb; /* border colour */ + + /* rasterization temps */ + + lws_fx_t btm; + lws_fx_t right; + lws_box_t db; + + uint8_t init; + uint8_t alt; +} lws_dlo_rect_t; + +typedef struct lws_dlo_circle { + lws_dlo_t dlo; +} lws_dlo_circle_t; + +typedef struct lws_font_choice { + const char *family_name; + const char *generic_name; + uint16_t weight; + uint16_t style; /* normal, italic, oblique */ + uint16_t fixed_height; +} lws_font_choice_t; + +typedef struct lws_display_font { + lws_dll2_t list; + + lws_font_choice_t choice; + + const uint8_t *data; /* may be cast to imp struct */ + uint8_t *priv; /* only used by implementation */ + size_t data_len; + lws_dlo_renderer_t renderer; + lws_dlo_image_glyph_t image_glyph; + + lws_fx_t em; /* 1 em in pixels */ + lws_fx_t ex; /* 1 ex in pixels */ +} lws_display_font_t; + +typedef struct lws_dlo_filesystem { + lws_dll2_t list; + + const char *name; + const void *data; + size_t len; +} lws_dlo_filesystem_t; + +#define LWSDLO_TEXT_FLAG_WRAP (1 << 0) + +typedef struct lws_dlo_text { + lws_dlo_t dlo; + const lws_display_font_t *font; + lws_dll2_owner_t glyphs; + lws_box_t bounding_box; /* { 0, 0, w, h } relative + * to and subject to + * clipping by .dlo.box */ + + /* referred to by glyphs */ + const struct lws_surface_info *ic; + struct lwsac *ac_glyphs; + uint8_t *line; + uint16_t curr; + + char *text; + uint8_t *kern; + size_t text_len; + lws_display_list_coord_t clkernpx; + lws_display_list_coord_t cwidth; + + lws_fx_t indent; + + uint32_t flags; + int16_t font_y_baseline; + int16_t font_height; + int16_t font_line_height; + + int16_t group_height; + int16_t group_y_baseline; + + lws_fx_t _cwidth; +} lws_dlo_text_t; + +typedef struct lws_dlo_rasterize { + lws_dll2_owner_t owner; /* lws_flow_t */ + lws_sorted_usec_list_t sul; + int lines; +} lws_dlo_rasterize_t; + +typedef struct lws_dlo_png { + lws_dlo_t dlo; /* ordering: first */ + lws_flow_t flow; /* ordering: second */ + lws_upng_t *png; +} lws_dlo_png_t; + +typedef struct lws_dlo_jpeg { + lws_dlo_t dlo; /* ordering: first */ + lws_flow_t flow; /* ordering: second */ + lws_jpeg_t *j; +} lws_dlo_jpeg_t; + +typedef enum { + LWSDLOSS_TYPE_JPEG, + LWSDLOSS_TYPE_PNG +} lws_dlo_image_type_t; + +typedef struct { + union { + lws_dlo_jpeg_t *dlo_jpeg; + lws_dlo_png_t *dlo_png; + } u; + lws_dlo_image_type_t type; + char failed; +} lws_dlo_image_t; + +typedef struct lws_display_state lws_display_state_t; + +typedef struct lws_displaylist { + lws_dll2_owner_t dl; + struct lws_display_state *ds; +} lws_displaylist_t; + +typedef struct lws_dl_rend { + lws_displaylist_t *dl; + int w; + int h; +} lws_dl_rend_t; + +typedef struct lws_display_render_stack { + lws_dlo_t *dlo; /* position in dlo owner */ + lws_box_t co; /* our origin as parent */ +} lws_display_render_stack_t; + +typedef struct lws_display_render_state { + lws_sorted_usec_list_t sul; /* return to event loop statefully */ + lws_display_state_t *lds; /* optional, if using lws_display */ + + const struct lws_surface_info *ic; /* display dimensions, palette */ + + lws_display_render_stack_t st[12]; /* DLO child stack */ + int sp; /* DLO child stack level */ + + uint8_t *line; /* Y or RGB line comp buffer */ + + lws_displaylist_t displaylist; + lws_box_t box; + lws_display_scalar curr; + char html; +} lws_display_render_state_t; + + +/** + * lws_display_dl_init() - init display list object + * + * \param dl: Pointer to the display list + * \param ds: Lws display state to bind the list to + * + * Initializes the display list \p dl and binds it to the display state \p ds. + */ +LWS_VISIBLE LWS_EXTERN void +lws_display_dl_init(lws_displaylist_t *dl, struct lws_display_state *ds); + +#if defined(_DEBUG) +LWS_VISIBLE LWS_EXTERN void +lws_display_dl_dump(lws_displaylist_t *dl); +#endif + +/** + * lws_display_list_destroy() - destroys display list and objects on it + * + * \param dl: Pointer to the display list + * + * Destroys every DLO on the list. + */ +LWS_VISIBLE LWS_EXTERN void +lws_display_list_destroy(lws_displaylist_t *dl); + +LWS_VISIBLE LWS_EXTERN void +lws_display_dlo_destroy(lws_dlo_t **r); + +LWS_VISIBLE LWS_EXTERN int +lws_display_dlo_add(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, lws_dlo_t *dlo); + +LWS_VISIBLE LWS_EXTERN int +lws_dlo_ensure_err_diff(lws_dlo_t *dlo); + +/* + * lws_display_list_render_line() - render a single raster line of the list + * + * \param rs: prepared render state object + * + * Allocates a line pair buffer into ds->line if necessary, and renders the + * current line (set by ds->curr) of the display list rasterization into it + */ +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_list_render_line(lws_display_render_state_t *rs); + +/* + * rect + */ + +LWS_VISIBLE LWS_EXTERN lws_dlo_rect_t * +lws_display_dlo_rect_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box, const lws_fx_t *radii, + lws_display_colour_t dc); + +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_render_rect(struct lws_display_render_state *rs); + +/* + * dlo text + */ + +LWS_VISIBLE LWS_EXTERN lws_dlo_text_t * +lws_display_dlo_text_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box, const lws_display_font_t *font); + +LWS_VISIBLE LWS_EXTERN int +lws_display_dlo_text_update(lws_dlo_text_t *text, lws_display_colour_t dc, + lws_fx_t indent, const char *utf8, size_t text_len); + +LWS_VISIBLE LWS_EXTERN void +lws_display_dlo_text_destroy(struct lws_dlo *dlo); + +/* + * PNG + */ + +LWS_VISIBLE LWS_EXTERN lws_dlo_png_t * +lws_display_dlo_png_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box); + +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_render_png(struct lws_display_render_state *rs); + +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_dlo_png_metadata_scan(lws_dlo_png_t *dp); + +LWS_VISIBLE LWS_EXTERN void +lws_display_dlo_png_destroy(struct lws_dlo *dlo); + +/* + * JPEG + */ + +LWS_VISIBLE LWS_EXTERN lws_dlo_jpeg_t * +lws_display_dlo_jpeg_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box); + +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_render_jpeg(struct lws_display_render_state *rs); + +LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t +lws_display_dlo_jpeg_metadata_scan(lws_dlo_jpeg_t *dj); + +LWS_VISIBLE LWS_EXTERN void +lws_display_dlo_jpeg_destroy(struct lws_dlo *dlo); + +/* + * SS / dlo images + */ + +struct lhp_ctx; + +typedef struct { + struct lws_context *cx; + lws_displaylist_t *dl; + lws_dlo_t *dlo_parent; + lws_box_t *box; + sul_cb_t on_rx; + lws_sorted_usec_list_t *on_rx_sul; + const char *url; + struct lhp_ctx *lhp; + lws_dlo_image_t *u; + int32_t window; +} lws_dlo_ss_create_info_t; + +LWS_VISIBLE LWS_EXTERN lws_dlo_t * +lws_dlo_ss_create(lws_dlo_ss_create_info_t *i); + +typedef struct lhp_ctx lhp_ctx_t; + +LWS_VISIBLE LWS_EXTERN int +lws_dlo_ss_find(struct lws_context *cx, const char *url, lws_dlo_image_t *u); + +LWS_VISIBLE LWS_EXTERN signed char +lhp_dl_render(lhp_ctx_t *ctx, char reason); + +#define lws_dlo_image_width(_u) ((_u)->failed ? -1 : \ + ((_u)->type == LWSDLOSS_TYPE_JPEG ? \ + (int)lws_jpeg_get_width((_u)->u.dlo_jpeg->j) : \ + (int)lws_upng_get_width((_u)->u.dlo_png->png))) +#define lws_dlo_image_height(_u) ((_u)->failed ? -1 : \ + ((_u)->type == LWSDLOSS_TYPE_JPEG ? \ + (int)lws_jpeg_get_height((_u)->u.dlo_jpeg->j) : \ + (int)lws_upng_get_height((_u)->u.dlo_png->png))) + +#define lws_dlo_image_metadata_scan(_u) ((_u)->failed ? LWS_SRET_FATAL : \ + ((_u)->type == LWSDLOSS_TYPE_JPEG ? \ + lws_display_dlo_jpeg_metadata_scan((_u)->u.dlo_jpeg) : \ + lws_display_dlo_png_metadata_scan((_u)->u.dlo_png))) + +/* + * Font registry + * + * Register fonts (currently, psfu) to the lws_context, and select the closest + * matching. Used to pick fonts from whatever CSS information is available. + */ + +LWS_VISIBLE LWS_EXTERN int +lws_font_register(struct lws_context *cx, const uint8_t *data, size_t data_len); + +LWS_VISIBLE LWS_EXTERN const lws_display_font_t * +lws_font_choose(struct lws_context *cx, const lws_font_choice_t *hints); + +LWS_VISIBLE LWS_EXTERN void +lws_fonts_destroy(struct lws_context *cx); + +/* + * Static blob registry (built-in, name-accessible blobs) + */ + +LWS_VISIBLE LWS_EXTERN int +lws_dlo_file_register(struct lws_context *cx, const lws_dlo_filesystem_t *f); + +LWS_VISIBLE LWS_EXTERN const lws_dlo_filesystem_t * +lws_dlo_file_choose(struct lws_context *cx, const char *name); + +LWS_VISIBLE LWS_EXTERN void +lws_dlo_file_destroy(struct lws_context *cx); + diff --git a/lib/core/private-lib-core.h b/lib/core/private-lib-core.h index 5c4cd3223..4c73957a0 100644 --- a/lib/core/private-lib-core.h +++ b/lib/core/private-lib-core.h @@ -449,6 +449,14 @@ struct lws_context { #endif lws_sorted_usec_list_t sul_cpd_defer; +#if defined(LWS_WITH_DLO) + lws_dll2_owner_t fonts; + lws_dll2_owner_t dlo_file; +#if defined(LWS_WITH_SECURE_STREAMS) + lws_dll2_owner_t active_assets; /* dloss_t */ +#endif +#endif + #if defined(LWS_WITH_NETWORK) struct lws_context_per_thread pt[LWS_MAX_SMP]; lws_retry_bo_t default_retry; diff --git a/lib/drivers/CMakeLists.txt b/lib/drivers/CMakeLists.txt index 1e1354b5b..2fd9677fe 100644 --- a/lib/drivers/CMakeLists.txt +++ b/lib/drivers/CMakeLists.txt @@ -3,9 +3,9 @@ list(APPEND SOURCES drivers/display/ssd1306-i2c.c drivers/display/ili9341-spi.c drivers/i2c/lws-i2c.c - drivers/i2c/bitbang/lws-bb-i2c.c - drivers/spi/lws-spi.c - drivers/spi/bitbang/lws-bb-spi.c + drivers/i2c/bitbang/lws-bb-i2c.c + drivers/spi/lws-spi.c + drivers/spi/bitbang/lws-bb-spi.c drivers/button/lws-button.c drivers/led/led-gpio.c drivers/led/led-seq.c diff --git a/lib/drivers/display/lws-display.c b/lib/drivers/display/lws-display.c index 1a4112fa0..23deb3ce4 100644 --- a/lib/drivers/display/lws-display.c +++ b/lib/drivers/display/lws-display.c @@ -82,7 +82,8 @@ lws_display_state_init(lws_display_state_t *lds, struct lws_context *ctx, lds->bl_lcs = bl_lcs; lds->state = LWSDISPS_OFF; - lws_led_transition(lds->bl_lcs, "backlight", &lws_pwmseq_static_off, + if (lds->bl_lcs) + lws_led_transition(lds->bl_lcs, "backlight", &lws_pwmseq_static_off, &lws_pwmseq_static_on); disp->init(lds); @@ -92,7 +93,8 @@ void lws_display_state_set_brightness(lws_display_state_t *lds, const lws_led_sequence_def_t *pwmseq) { - lws_led_transition(lds->bl_lcs, "backlight", pwmseq, + if (lds->bl_lcs) + lws_led_transition(lds->bl_lcs, "backlight", pwmseq, lds->disp->bl_transition); } @@ -108,7 +110,7 @@ lws_display_state_active(lws_display_state_t *lds) waiting_ms = lds->disp->latency_wake_ms; } else { - if (lds->state != LWSDISPS_ACTIVE) + if (lds->state != LWSDISPS_ACTIVE && lds->bl_lcs) lws_display_state_set_brightness(lds, lds->disp->bl_active); @@ -125,7 +127,10 @@ lws_display_state_active(lws_display_state_t *lds) void lws_display_state_off(lws_display_state_t *lds) { - lds->disp->power(lds, 0); + /* if no control over backlight, don't bother power down display + * since it would continue to emit, just show all-white or whatever */ + if (lds->bl_lcs) + lds->disp->power(lds, 0); lws_sul_cancel(&lds->sul_autodim); lds->state = LWSDISPS_OFF; } @@ -134,7 +139,7 @@ int lws_display_alloc_diffusion(const lws_surface_info_t *ic, lws_surface_error_t **se) { size_t size, gsize = ic->greyscale ? sizeof(lws_greyscale_error_t) : - sizeof(lws_colour_error_t); + sizeof(lws_colour_error_t), by; if (*se) return 0; @@ -142,7 +147,8 @@ lws_display_alloc_diffusion(const lws_surface_info_t *ic, lws_surface_error_t ** /* defer creation of dlo's 2px-high dlo-width, 2 bytespp or 6 bytespp * error diffusion buffer */ - size = gsize * 2u * (unsigned int)(ic->wh_px[0].whole); + by = ((ic->wh_px[0].whole + 15) / 8) * 8; + size = gsize * 2u * (unsigned int)by; lwsl_info("%s: alloc'd %u for width %d\n", __func__, (unsigned int)size, (int)ic->wh_px[0].whole); @@ -151,8 +157,7 @@ lws_display_alloc_diffusion(const lws_surface_info_t *ic, lws_surface_error_t ** if (!se[0]) return 1; - se[1] = (lws_surface_error_t *)(((uint8_t *)se[0]) + - ((size_t)ic->wh_px[0].whole * gsize)); + se[1] = (lws_surface_error_t *)(((uint8_t *)se[0]) + (size / 2)); return 0; } @@ -181,7 +186,7 @@ void dist_err_floyd_steinberg_grey(int n, int width, lws_greyscale_error_t *gedl_this, lws_greyscale_error_t *gedl_next) { - if (n != width - 1) { + if (n < width - 1) { dist_err_grey(&gedl_this[n], &gedl_this[n + 1], 7); dist_err_grey(&gedl_this[n], &gedl_next[n + 1], 1); } @@ -197,7 +202,7 @@ void dist_err_floyd_steinberg_col(int n, int width, lws_colour_error_t *edl_this, lws_colour_error_t *edl_next) { - if (n != width - 1) { + if (n < width - 1) { dist_err_col(&edl_this[n], &edl_this[n + 1], 7); dist_err_col(&edl_this[n], &edl_next[n + 1], 1); } @@ -265,33 +270,42 @@ static const uint8_t gamma2_2[] = { }; lws_display_palette_idx_t -lws_display_palettize_grey(const lws_surface_info_t *ic, lws_display_colour_t c, - lws_greyscale_error_t *ectx) +lws_display_palettize_grey(const lws_surface_info_t *ic, + const lws_display_colour_t *palette, size_t pdepth, + lws_display_colour_t c, lws_greyscale_error_t *ectx) { - int best = 0x7fffffff, best_idx = 0, yd; - lws_colour_error_t da, d; + int best = 0x7fffffff, best_idx = 0; + lws_colour_error_t da, d, ea; + int sum, y; size_t n; /* put the most desirable colour (adjusted for existing error) in d */ d.rgb[0] = (int)gamma2_2[LWSDC_R(c)]; da.rgb[0] = d.rgb[0] + ectx->rgb[0]; - yd = da.rgb[0]; + if (da.rgb[0] < 0) + da.rgb[0] = 0; + if (da.rgb[0] > 255) + da.rgb[0] = 255; + + if (ic->type == LWSSURF_565) { + y = d.rgb[0] >> 3; + ectx->rgb[0] = (int16_t)((int)da.rgb[0] - y); + + return (lws_display_palette_idx_t)y; + } /* * Choose a palette colour considering the error diffusion adjustments */ - for (n = 0; n < ic->palette_depth; n++) { - lws_colour_error_t ea; - int sum, y; + for (n = 0; n < pdepth; n++) { - y = LWSDC_ALPHA(ic->palette[n]); + y = LWSDC_ALPHA(palette[n]); - ea.rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(ic->palette[n]))); + ea.rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(palette[n]))); - sum = (ea.rgb[0] < 0 ? -ea.rgb[0] : ea.rgb[0]) + - ((yd > y ? (yd - y) * 1 : (y - yd) * 1)); + sum = ea.rgb[0] < 0 ? -ea.rgb[0] : ea.rgb[0]; if (sum < best) { best_idx = (int)n; @@ -301,7 +315,7 @@ lws_display_palettize_grey(const lws_surface_info_t *ic, lws_display_colour_t c, /* report the error between the unadjusted colour and what we chose */ - ectx->rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(ic->palette[best_idx]))); + ectx->rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(palette[best_idx]))); return (lws_display_palette_idx_t)best_idx; } @@ -338,43 +352,77 @@ yuv_to_rgb(uint8_t *rgb, const uint8_t *_yuv) #endif lws_display_palette_idx_t -lws_display_palettize_col(const lws_surface_info_t *ic, lws_display_colour_t c, - lws_colour_error_t *ectx) +lws_display_palettize_col(const lws_surface_info_t *ic, + const lws_display_colour_t *palette, size_t pdepth, + lws_display_colour_t c, lws_colour_error_t *ectx) { int best = 0x7fffffff, best_idx = 0, yd; lws_colour_error_t da, d; + uint8_t ya[3]; size_t n; + int y, ch; /* put the most desirable colour (adjusted for existing error) in d */ d.rgb[0] = (int)gamma2_2[LWSDC_R(c)]; da.rgb[0] = d.rgb[0] + ectx->rgb[0]; + if (da.rgb[0] < 0) + da.rgb[0] = 0; + if (da.rgb[0] > 255) + da.rgb[0] = 255; yd = da.rgb[0]; d.rgb[1] = (int)gamma2_2[LWSDC_G(c)]; d.rgb[2] = (int)gamma2_2[LWSDC_B(c)]; da.rgb[1] = d.rgb[1] + ectx->rgb[1]; + if (da.rgb[1] < 0) + da.rgb[1] = 0; + if (da.rgb[1] > 255) + da.rgb[1] = 255; da.rgb[2] = d.rgb[2] + ectx->rgb[2]; + if (da.rgb[2] < 0) + da.rgb[2] = 0; + if (da.rgb[2] > 255) + da.rgb[2] = 255; yd = RGB_TO_Y(da.rgb[0], da.rgb[1], da.rgb[2]); + if (ic->type == LWSSURF_565) { + ya[0] = d.rgb[0] >> 3; + ectx->rgb[0] = (int16_t)((int)da.rgb[0] - (ya[0] << 3)); + ya[1] = d.rgb[1] >> 2; + ectx->rgb[1] = (int16_t)((int)da.rgb[1] - (ya[1] << 2)); + ya[2] = d.rgb[2] >> 3; + ectx->rgb[2] = (int16_t)((int)da.rgb[2] - (ya[2] << 3)); + + return (lws_display_palette_idx_t)((ya[0] << 11) | (ya[1] << 5) | (ya[2])); + } + /* - * Choose a palette colour considering the error diffusion adjustments + * Choose a palette colour considering the error diffusion adjustments, + * separately choose the best Y match and the best RGB match */ - for (n = 0; n < ic->palette_depth; n++) { + for (n = 0; n < pdepth; n++) { lws_colour_error_t ea; - int sum, y; + int sum; - y = LWSDC_ALPHA(ic->palette[n]); + y = LWSDC_ALPHA(palette[n]); - ea.rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(ic->palette[n]))); - ea.rgb[1] = (int16_t)(da.rgb[1] - (int)(LWSDC_G(ic->palette[n]))); - ea.rgb[2] = (int16_t)(da.rgb[2] - (int)(LWSDC_B(ic->palette[n]))); + ea.rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(palette[n]))); + ea.rgb[1] = (int16_t)((int)da.rgb[1] - (int)(LWSDC_G(palette[n]))); + ea.rgb[2] = (int16_t)((int)da.rgb[2] - (int)(LWSDC_B(palette[n]))); - sum = (ea.rgb[0] < 0 ? -ea.rgb[0] : ea.rgb[0]) + - (ea.rgb[1] < 0 ? -ea.rgb[1] : ea.rgb[1]) + - (ea.rgb[2] < 0 ? -ea.rgb[2] : ea.rgb[2]) + - (yd > y ? (yd - y) * 1 : (y - yd) * 1); + /* Best considering luma match */ + + sum = (yd > y ? (yd - y) : (y - yd)); + + /* + * Best considering RGB matching + */ + + sum += ((ea.rgb[0] < 0 ? -ea.rgb[0] : ea.rgb[0]) + + (ea.rgb[1] < 0 ? -ea.rgb[1] : ea.rgb[1]) + + (ea.rgb[2] < 0 ? -ea.rgb[2] : ea.rgb[2])); if (sum < best) { best_idx = (int)n; @@ -382,12 +430,14 @@ lws_display_palettize_col(const lws_surface_info_t *ic, lws_display_colour_t c, } } + ch = best_idx; + /* report the error between the adjusted colour and what we chose */ - ectx->rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(ic->palette[best_idx]))); - ectx->rgb[1] = (int16_t)((int)da.rgb[1] - (int)(LWSDC_G(ic->palette[best_idx]))); - ectx->rgb[2] = (int16_t)((int)da.rgb[2] - (int)(LWSDC_B(ic->palette[best_idx]))); + ectx->rgb[0] = (int16_t)((int)da.rgb[0] - (int)(LWSDC_R(palette[ch]))); + ectx->rgb[1] = (int16_t)((int)da.rgb[1] - (int)(LWSDC_G(palette[ch]))); + ectx->rgb[2] = (int16_t)((int)da.rgb[2] - (int)(LWSDC_B(palette[ch]))); - return (lws_display_palette_idx_t)best_idx; + return (lws_display_palette_idx_t)ch; } diff --git a/lib/misc/CMakeLists.txt b/lib/misc/CMakeLists.txt index 120fb36a3..71a3c92c4 100644 --- a/lib/misc/CMakeLists.txt +++ b/lib/misc/CMakeLists.txt @@ -1,7 +1,7 @@ # # libwebsockets - small server side websockets and web server implementation # -# Copyright (C) 2010 - 2020 Andy Green +# Copyright (C) 2010 - 2022 Andy Green # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to @@ -75,6 +75,30 @@ if (LWS_WITH_JPEG) endif() +if (LWS_WITH_DLO) + list(APPEND SOURCES + misc/dlo/dlo.c + misc/dlo/dlo-rect.c + misc/dlo/dlo-font-mcufont.c + misc/dlo/dlo-text.c) + +if (LWS_WITH_UPNG) + list(APPEND SOURCES + misc/dlo/dlo-png.c) +endif() + +if (LWS_WITH_JPEG) + list(APPEND SOURCES + misc/dlo/dlo-jpeg.c) +endif() + +if (LWS_WITH_SECURE_STREAMS) + list(APPEND SOURCES + misc/dlo/dlo-ss.c) +endif() + +endif() #dlo + # this is an older, standalone hashed disk cache # implementation unrelated to lws-cache-ttl if (LWS_WITH_DISKCACHE) @@ -142,7 +166,6 @@ if (LWS_WITH_CBOR) misc/ieeehalfprecision.c) endif() - if (UNIX) if (NOT LWS_HAVE_GETIFADDRS) list(APPEND HDR_PRIVATE misc/getifaddrs.h) diff --git a/lib/misc/dlo/dlo-font-mcufont.c b/lib/misc/dlo/dlo-font-mcufont.c new file mode 100644 index 000000000..f8899af1d --- /dev/null +++ b/lib/misc/dlo/dlo-font-mcufont.c @@ -0,0 +1,528 @@ +/* + * lws abstract display + * + * Copyright (C) 2013 Petteri Aimonen + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object: mcufont font + * + * The mcu decoding is rewritten from the mcufont implementation at + * https://github.com/mcufont/mcufont, which is licensed under MIT already, + * to use a stateful decoder. + * + * The decoder only brings in new compression codes when needed to produce more + * pixels on the line of the glyphs being decoded. + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +#define DICT_START 24 +#define REF_FILLZEROS 16 + +#define RLE_CODEMASK 0xC0 +#define RLE_VALMASK 0x3F +#define RLE_ZEROS 0x00 +#define RLE_64ZEROS 0x40 +#define RLE_ONES 0x80 +#define RLE_SHADE 0xC0 + +#define DICT_START7BIT 4 +#define DICT_START6BIT 132 +#define DICT_START5BIT 196 +#define DICT_START4BIT 228 +#define DICT_START3BIT 244 +#define DICT_START2BIT 252 + +enum { + RS_IDLE, + RS_SKIP_PX, + RS_WRITE_PX, + RS_ALLZERO, + + COMP = 0, + DICT1, + DICT1_CONT, + DICT2, + DICT3 +}; + +typedef struct mcu_stack { + const uint8_t *dict; + int16_t dictlen; + int16_t runlen; /* for accumilation on DICT1 */ + uint8_t byte; + uint8_t bitcount; + uint8_t state; +} mcu_stack_t; + +typedef struct mcu_glyph { + lws_font_glyph_t fg; + const uint8_t *comp; + + mcu_stack_t st[3]; + int32_t runlen; + + int8_t sp; + + uint8_t runstate; + uint8_t alpha; + uint8_t code; +} mcu_glyph_t; + +/* Get bit count for the "fill entries" */ +static uint8_t +fillentry_bitcount(uint8_t index) +{ + if (index >= DICT_START2BIT) + return 2; + else if (index >= DICT_START3BIT) + return 3; + else if (index >= DICT_START4BIT) + return 4; + else if (index >= DICT_START5BIT) + return 5; + else if (index >= DICT_START6BIT) + return 6; + else + return 7; +} + +void +draw_px(lws_dlo_text_t *t, mcu_glyph_t *g) +{ + lws_display_colour_t c = (lws_display_colour_t)((lws_display_colour_t)(g->alpha << 24) | + (lws_display_colour_t)((lws_display_colour_t)t->dlo.dc & 0xffffffu)); + lws_fx_t t1, x; + int ex; + + t1.whole = g->fg.x; + + if (!g->alpha) + return; + + t1.frac = 0; + lws_fx_add(&x, &g->fg.xpx, &t1); + +#if 0 + { char b1[22], b2[22], b3[22]; + lwsl_err("fadj %s = %s + %s\n", + lws_fx_string(&x, b1, sizeof(b1)), + lws_fx_string(&g->fg.xpx, b2, sizeof(b2)), + lws_fx_string(&g->fg.xorg, b3, sizeof(b3))); } +#endif + + ex = x.whole;// - t->dlo.box.x.whole; + if (ex < 0 || ex >= t->dlo.box.w.whole) { + //lwsl_err("%s: ex %d (lim %d)\n", __func__, ex, t->dlo.box.w.whole); + return; + } + lws_fx_add(&x, &x, &g->fg.xorg); + + lws_fx_add(&t1, &t->dlo.box.x, &x); + lws_surface_set_px(t->ic, t->line, t1.whole, &c); +} + +static void +write_ref_codeword(mcu_glyph_t *g, const uint8_t *bf, uint8_t c) +{ + uint32_t o, o1; + + if (!c) { + g->runlen = 1; + g->runstate = RS_SKIP_PX; + return; + } + if (c <= 15) { + g->alpha = (uint8_t)(0x11 * c); + g->runlen = 1; + g->runstate = RS_WRITE_PX; + return; + } + if (c == REF_FILLZEROS) { + /* Fill with zeroes to end */ + g->alpha = 0; + g->runlen = 1000000; + g->runstate = RS_WRITE_PX; + return; + } + if (c < DICT_START) + return; + + if (c < DICT_START + lws_ser_ru32be(bf + MCUFO_COUNT_RLE_DICT)) { + /* write_rle_dictentry */ + o1 = lws_ser_ru32be(bf + MCUFO_FOFS_DICT_OFS); + o = lws_ser_ru16be(bf + o1 + ((c - DICT_START) * 2)); + g->st[(int)++g->sp].dictlen = (int16_t)(lws_ser_ru16be(bf + o1 + + ((c - DICT_START + 1) * 2)) - o); + + g->st[(int)g->sp].dict = bf + lws_ser_ru32be(bf + MCUFO_FOFS_DICT_DATA) + o; + g->st[(int)g->sp].state = DICT2; + return; + } + + g->st[(int)++g->sp].bitcount = fillentry_bitcount(c); + g->st[(int)g->sp].byte = (uint8_t)(c - DICT_START7BIT); + g->st[(int)g->sp].state = DICT1; + g->runlen = 0; +} + +static void +mcufont_next_code(mcu_glyph_t *g) +{ + lws_dlo_text_t *t = lws_container_of(g->fg.list.owner, lws_dlo_text_t, + glyphs); + const uint8_t *bf = (const uint8_t *)t->font->data; + uint8_t c = *g->comp++; + uint32_t o, o1; + + if (c < DICT_START + lws_ser_ru32be(&bf[MCUFO_COUNT_RLE_DICT]) || + c >= DICT_START + lws_ser_ru32be(&bf[MCUFO_COUNT_REF_RLE_DICT])) { + write_ref_codeword(g, bf, c); + return; + } + + /* write_ref_dictentry() */ + + o1 = lws_ser_ru32be(bf + MCUFO_FOFS_DICT_OFS); + o = lws_ser_ru16be(bf + o1 + ((c - DICT_START) * 2)); + g->st[(int)++g->sp].dictlen = (int16_t)(lws_ser_ru16be(bf + o1 + + ((c - DICT_START + 1) * 2)) - o); + + g->st[(int)g->sp].dict = bf + lws_ser_ru32be(bf + MCUFO_FOFS_DICT_DATA) + o; + g->st[(int)g->sp].state = DICT3; +} + +/* lookup and append a glyph for specific unicode to the text glyph list */ + +static uint32_t +font_mcufont_uniglyph_lookup(lws_dlo_text_t *text, uint32_t unicode) +{ + const uint8_t *bf = (const uint8_t *)text->font->data, + *r = bf + lws_ser_ru32be(&bf[MCUFO_FOFS_CHAR_RANGE_TABLES]); + uint32_t entries = lws_ser_ru32be(&bf[MCUFO_COUNT_CHAR_RANGE_TABLES]); + unsigned int n; + + if (entries > 8) /* coverity sanity */ + return 0; + + do { + for (n = 0; n < entries; n++) { + uint32_t cs = lws_ser_ru32be(r + 0), ce = lws_ser_ru32be(r + 4); + + if (cs >= 0x100000 || !ce || ce > 0x10000) + return 0; + + if (unicode >= cs && unicode < cs + ce) { + uint32_t cbo = lws_ser_ru32be(r + 0xc); + + if (cbo >= text->font->data_len) + return 0; + + cbo += lws_ser_ru16be(bf + + lws_ser_ru32be(r + 8) + ((unicode - cs) * 2)); + + if (cbo >= text->font->data_len) + return 0; + + return cbo; + } + + r += 16; + } + + if (unicode == lws_ser_ru32be(&bf[MCUFO_UNICODE_FALLBACK])) + return 0; + unicode = lws_ser_ru32be(&bf[MCUFO_UNICODE_FALLBACK]); + + } while (1); +} + +static mcu_glyph_t * +font_mcufont_uniglyph(lws_dlo_text_t *text, uint32_t unicode) +{ + const uint8_t *bf = (const uint8_t *)text->font->data; + uint32_t ofs; + mcu_glyph_t *g; + + ofs = font_mcufont_uniglyph_lookup(text, unicode); + if (!ofs) + return NULL; + +// lwsl_warn("%s: text->text_len %u: %c\n", __func__, text->text_len, (char)unicode); + g = lwsac_use_zero(&text->ac_glyphs, sizeof(*g), + (text->text_len + 1) * sizeof(*g)); + if (!g) + return NULL; + + g->comp = bf + ofs; + g->fg.cwidth.whole = *g->comp++; + g->fg.cwidth.frac = 0; + + lws_dll2_add_tail(&g->fg.list, &text->glyphs); + + return g; +} + +int +lws_display_font_mcufont_getcwidth(lws_dlo_text_t *text, uint32_t unicode, + lws_fx_t *fx) +{ + const uint8_t *bf = (const uint8_t *)text->font->data; + uint32_t ofs = font_mcufont_uniglyph_lookup(text, unicode); + + if (!ofs) + return 1; + + fx->whole = bf[ofs]; + fx->frac = 0; + + return 0; +} + +lws_font_glyph_t * +lws_display_font_mcufont_image_glyph(lws_dlo_text_t *text, uint32_t unicode, + char attach) +{ + const uint8_t *bf = (const uint8_t *)text->font->data; + mcu_glyph_t *g; + + /* one text dlo has glyphs from all the same fonts and attributes */ + if (!text->font_height) { + text->font_height = (int16_t)lws_ser_ru16be(&bf[MCUFO16_HEIGHT]); + text->font_y_baseline = (int16_t)(text->font_height - + lws_ser_ru16be(&bf[MCUFO16_BASELINE_Y])); + text->font_line_height = (int16_t)lws_ser_ru16be(&bf[MCUFO16_LINE_HEIGHT]); + } + + lws_display_font_mcufont_getcwidth(text, unicode, &text->_cwidth); + + if (!attach) + return NULL; + + g = font_mcufont_uniglyph(text, unicode); + if (!g) + return NULL; + + g->fg.height.whole = lws_ser_ru16be(bf + MCUFO16_HEIGHT); + g->fg.height.frac = 0; + + return &g->fg; +} + +lws_stateful_ret_t +lws_display_font_mcufont_render(struct lws_display_render_state *rs) +{ + lws_dlo_t *dlo = rs->st[rs->sp].dlo; + lws_dlo_text_t *text = lws_container_of(dlo, lws_dlo_text_t, dlo); + const uint8_t *bf = (const uint8_t *)text->font->data; + lws_fx_t ax, ay, t, t1, t2, t3; + mcu_glyph_t *g; + int s, e, yo; + uint8_t c, el; + + lws_fx_add(&ax, &rs->st[rs->sp].co.x, &dlo->box.x); + lws_fx_add(&t, &ax, &dlo->box.w); + lws_fx_add(&ay, &rs->st[rs->sp].co.y, &dlo->box.y); + lws_fx_add(&t1, &ay, &dlo->box.h); + + lws_fx_add(&t2, &ax, &text->bounding_box.w); + + text->curr = rs->curr; + text->ic = rs->ic; + text->line = rs->line; + + s = ax.whole; + e = lws_fx_roundup(&t2); + + if (e <= 0) + return LWS_SRET_OK; /* wholly off to the left */ + if (s >= rs->ic->wh_px[0].whole) + return LWS_SRET_OK; /* wholly off to the right */ + + if (e >= rs->ic->wh_px[0].whole) + e = rs->ic->wh_px[0].whole; + + /* figure out our y position inside the glyph bounding box */ + yo = rs->curr - ay.whole; + + if (!yo) { + lws_display_dlo_text_attach_glyphs(text); + + t3.whole = lws_ser_ru16be(bf + MCUFO16_BASELINE_X); + t3.frac = 0; + lws_start_foreach_dll(struct lws_dll2 *, d, + lws_dll2_get_head(&text->glyphs)) { + lws_font_glyph_t *fg = lws_container_of(d, lws_font_glyph_t, list); + lws_fx_sub(&fg->xpx, &fg->xpx, &t3); + fg->xorg = rs->st[rs->sp].co.x; + } lws_end_foreach_dll(d); + } + +#if 0 + { + uint32_t dc = 0xff0000ff; + int s1 = s; + /* from origin.x + dlo->box.x */ + for (s1 = ax.whole; s1 < t2.whole; s1++) + lws_surface_set_px(ic, line, s1, &dc); + + memset(&ce, 0, sizeof(ce)); + } +#endif + + lws_start_foreach_dll(struct lws_dll2 *, d, + lws_dll2_get_head(&text->glyphs)) { + lws_font_glyph_t *fg = lws_container_of(d, lws_font_glyph_t, list); + + g = (mcu_glyph_t *)fg; + fg->x = 0; + + while (yo < (int)fg->height.whole && + fg->x < lws_ser_ru16be(bf + MCUFO16_WIDTH)) { + switch (g->runstate) { + case RS_IDLE: + switch (g->st[(int)g->sp].state) { + case COMP: + mcufont_next_code(g); + break; + + case DICT1_CONT: + --g->sp; /* back to DICT1 after doing the skip */ + g->runstate = RS_SKIP_PX; + g->runlen = 1; + continue; + + case DICT1: + /* write_bin_codeword() states */ + el = 0; + while (g->st[(int)g->sp].bitcount--) { + c = g->st[(int)g->sp].byte; + g->st[(int)g->sp].byte >>= 1; + if (c & 1) + g->st[(int)g->sp].runlen++; + else { + if (g->st[(int)g->sp].runlen) { + g->alpha = 255; + g->runstate = RS_WRITE_PX; + g->runlen = g->st[(int)g->sp].runlen; + g->st[(int)g->sp].runlen = 0; + g->st[(int)++g->sp].state = DICT1_CONT; + el = 1; + break; + } + g->runstate = RS_SKIP_PX; + g->runlen = 1; + el = 1; + break; + } + } + + if (el) + continue; + + /* back out of DICT1 */ + if (!g->sp) + assert(0); + g->sp--; + + if (g->st[(int)g->sp + 1].runlen) { + g->alpha = 255; + g->runstate = RS_WRITE_PX; + g->runlen = g->st[(int)g->sp + 1].runlen; + g->st[(int)g->sp + 1].runlen = 0; + continue; + } + break; + + case DICT2: /* write_rle_dictentry */ + c = (*g->st[(int)g->sp].dict++); + if (!--g->st[(int)g->sp].dictlen) { + if (!g->sp) + assert(0); + g->sp--; + } + if ((c & RLE_CODEMASK) == RLE_ZEROS) { + g->runstate = RS_SKIP_PX; + g->runlen = c & RLE_VALMASK; + continue; + } + if ((c & RLE_CODEMASK) == RLE_64ZEROS) { + g->runstate = RS_SKIP_PX; + g->runlen = ((c & RLE_VALMASK) + 1) * 64; + continue; + } + if ((c & RLE_CODEMASK) == RLE_ONES) { + g->alpha = 255; + g->runstate = RS_WRITE_PX; + g->runlen = (c & RLE_VALMASK) + 1; + continue; + } + if ((c & RLE_CODEMASK) == RLE_SHADE) { + g->alpha = (uint8_t)(((c & RLE_VALMASK) & 0xf) * 0x11); + g->runstate = RS_WRITE_PX; + g->runlen = ((c & RLE_VALMASK) >> 4) + 1; + continue; + } + break; + + case DICT3: + c = *g->st[(int)g->sp].dict++; + if (!--g->st[(int)g->sp].dictlen) { + if (!g->sp) + assert(0); + + g->sp--; + } + + write_ref_codeword(g, bf, c); + break; + } + break; + case RS_SKIP_PX: + fg->x++; + if (--g->runlen) + break; + g->runstate = RS_IDLE; + break; + + case RS_WRITE_PX: + if (g->alpha) + draw_px(text, g); + g->fg.x++; + if (--g->runlen) + break; + g->runstate = RS_IDLE; + break; + + case RS_ALLZERO: + fg->x++; + if (--g->runlen) + break; + g->runstate = RS_IDLE; + break; + } + } + + } lws_end_foreach_dll(d); + + return LWS_SRET_OK; +} diff --git a/lib/misc/dlo/dlo-jpeg.c b/lib/misc/dlo/dlo-jpeg.c new file mode 100644 index 000000000..19eb0b93f --- /dev/null +++ b/lib/misc/dlo/dlo-jpeg.c @@ -0,0 +1,195 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object: JPEG + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +void +lws_display_dlo_jpeg_destroy(struct lws_dlo *dlo) +{ + lws_dlo_jpeg_t *dlo_jpeg = lws_container_of(dlo, lws_dlo_jpeg_t, dlo); + +#if defined(LWS_WITH_CLIENT) && defined(LWS_WITH_SECURE_STREAMS) + lws_ss_destroy(&dlo_jpeg->flow.h); +#endif + lws_buflist_destroy_all_segments(&dlo_jpeg->flow.bl); + + if (dlo_jpeg->j) + lws_jpeg_free(&dlo_jpeg->j); +} + +lws_stateful_ret_t +lws_display_render_jpeg(struct lws_display_render_state *rs) +{ + lws_dlo_t *dlo = rs->st[rs->sp].dlo; + lws_dlo_jpeg_t *dlo_jpeg = lws_container_of(dlo, lws_dlo_jpeg_t, dlo); + lws_display_colour_t pc; + lws_fx_t ax, ay, t, t1; + lws_stateful_ret_t r; + const uint8_t *pix; + int s, e; + + lws_fx_add(&ax, &rs->st[rs->sp].co.x, &dlo->box.x); + lws_fx_add(&t, &ax, &dlo->box.w); + lws_fx_add(&ay, &rs->st[rs->sp].co.y, &dlo->box.y); + lws_fx_add(&t1, &ay, &dlo->box.h); + + if (!lws_jpeg_get_height(dlo_jpeg->j)) { + lwsl_info("%s: jpeg does not have dimensions yet\n", __func__); + return LWS_SRET_WANT_INPUT; + } + + s = ax.whole; + e = lws_fx_roundup(&t); + + if (rs->curr > lws_fx_roundup(&t1)) + return LWS_SRET_OK; + + if (rs->curr - lws_fx_roundup(&ay) > + (int)lws_jpeg_get_height(dlo_jpeg->j)) + return LWS_SRET_OK; + + if (s < 0) + s = 0; + if (s > rs->ic->wh_px[0].whole) + return LWS_SRET_OK; /* off to the right */ + if (e > rs->ic->wh_px[0].whole) + e = rs->ic->wh_px[0].whole - 1; + if (e <= 0) + return LWS_SRET_OK; /* off to the left */ + + do { + if (lws_flow_feed(&dlo_jpeg->flow)) + /* if he says WANT_INPUT, we have nothing in the buflist */ + return LWS_SRET_WANT_INPUT; + + pix = NULL; + r = lws_jpeg_emit_next_line(dlo_jpeg->j, &pix, &dlo_jpeg->flow.data, + &dlo_jpeg->flow.len, rs->html == 1); + + if (r & LWS_SRET_NO_FURTHER_IN) + dlo_jpeg->flow.state = LWSDLOFLOW_STATE_READ_COMPLETED; + + if (r & LWS_SRET_FATAL || r == LWS_SRET_OK) + return r; + + r = lws_flow_req(&dlo_jpeg->flow); + if (r & LWS_SRET_WANT_INPUT) + return r; + + } while (!pix); + + /* + * What's in pix is either 24-bit RGB 3 bytes/px, or 8-bit grayscale + * 1 byte/px, we have to map it on to either 32-bit RGBA or 16-bit YA + * composition buf + */ + + pix = pix + (( (unsigned int)(s - ax.whole) * + (lws_jpeg_get_pixelsize(dlo_jpeg->j) / 8))); + + while (s < e && s >= ax.whole && s < lws_fx_roundup(&t) && + (s - ax.whole) < (int)lws_jpeg_get_width(dlo_jpeg->j)) { + + if (lws_jpeg_get_pixelsize(dlo_jpeg->j) == 8) + pc = LWSDC_RGBA(pix[0], pix[0], pix[0], 255); + else + pc = LWSDC_RGBA(pix[0], pix[1], pix[2], 255); + + lws_surface_set_px(rs->ic, rs->line, s, &pc); + s++; + pix += lws_jpeg_get_pixelsize(dlo_jpeg->j) / 8; + } + + return LWS_SRET_OK; +} + +lws_stateful_ret_t +lws_display_dlo_jpeg_metadata_scan(lws_dlo_jpeg_t *dlo_jpeg) +{ + lws_stateful_ret_t r; + size_t l, l1; + const uint8_t *pix; + + /* + * If we don't have the image metadata yet, provide small chunks of the + * source data until we do have the image metadata, but small enough + * we can't produce any decoded pixels too early. + */ + + while (!lws_jpeg_get_height(dlo_jpeg->j) && dlo_jpeg->flow.len) { + l1 = l = dlo_jpeg->flow.len > 128 ? 128 : dlo_jpeg->flow.len; + + r = lws_jpeg_emit_next_line(dlo_jpeg->j, &pix, &dlo_jpeg->flow.data, &l, 1); + if (r >= LWS_SRET_FATAL) { + lwsl_err("%s: hdr parse failed %d\n", __func__, r); + return r; + } + + dlo_jpeg->flow.len -= l1 - l; + + if (lws_jpeg_get_height(dlo_jpeg->j)) { + lwsl_info("jpeg: w %d, h %d\n", + lws_jpeg_get_width(dlo_jpeg->j), + lws_jpeg_get_height(dlo_jpeg->j)); + + return LWS_SRET_OK; + } + } + + return LWS_SRET_WANT_INPUT; +} + +lws_dlo_jpeg_t * +lws_display_dlo_jpeg_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box) +{ + lws_dlo_jpeg_t *dlo_jpeg = lws_zalloc(sizeof(*dlo_jpeg), __func__); + + if (!dlo_jpeg) + return NULL; + + dlo_jpeg->j = lws_jpeg_new(); + if (!dlo_jpeg->j) + goto bail; + + dlo_jpeg->dlo.box = *box; + dlo_jpeg->dlo.render = lws_display_render_jpeg; + dlo_jpeg->dlo._destroy = lws_display_dlo_jpeg_destroy; + + lws_display_dlo_add(dl, dlo_parent, &dlo_jpeg->dlo); + + return dlo_jpeg; + +bail: + lwsl_err("%s: bailed\n", __func__); + if (dlo_jpeg->j) + lws_jpeg_free(&dlo_jpeg->j); + + lws_free(dlo_jpeg); + + return NULL; +} diff --git a/lib/misc/dlo/dlo-png.c b/lib/misc/dlo/dlo-png.c new file mode 100644 index 000000000..23aa62dd2 --- /dev/null +++ b/lib/misc/dlo/dlo-png.c @@ -0,0 +1,184 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object: PNG + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +void +lws_display_dlo_png_destroy(struct lws_dlo *dlo) +{ + lws_dlo_png_t *dlo_png = lws_container_of(dlo, lws_dlo_png_t, dlo); + +#if defined(LWS_WITH_CLIENT) && defined(LWS_WITH_SECURE_STREAMS) + lws_ss_destroy(&dlo_png->flow.h); +#endif + lws_buflist_destroy_all_segments(&dlo_png->flow.bl); + + if (dlo_png->png) + lws_upng_free(&dlo_png->png); +} + +lws_stateful_ret_t +lws_display_render_png(struct lws_display_render_state *rs) +{ + lws_dlo_t *dlo = rs->st[rs->sp].dlo; + lws_dlo_png_t *dlo_png = lws_container_of(dlo, lws_dlo_png_t, dlo); + lws_fx_t ax, ay, t, t1; + lws_display_colour_t pc; + lws_stateful_ret_t r; + const uint8_t *pix; + int s, e; + + if (!lws_upng_get_height(dlo_png->png)) { + lwsl_info("%s: png does not have dimensions yet\n", __func__); + return LWS_SRET_WANT_INPUT; + } + + lws_fx_add(&ax, &rs->st[rs->sp].co.x, &dlo->box.x); + lws_fx_add(&t, &ax, &dlo->box.w); + lws_fx_add(&ay, &rs->st[rs->sp].co.y, &dlo->box.y); + lws_fx_add(&t1, &ay, &dlo->box.h); + + s = ax.whole; + e = lws_fx_roundup(&t); + + if (rs->curr > lws_fx_roundup(&t1)) + return LWS_SRET_OK; + + if (rs->curr - lws_fx_roundup(&ay) > + (int)lws_upng_get_height(dlo_png->png)) + return LWS_SRET_OK; + + if (s < 0) + s = 0; + if (s > rs->ic->wh_px[0].whole) + return LWS_SRET_OK; /* off to the right */ + if (e > rs->ic->wh_px[0].whole) + e = rs->ic->wh_px[0].whole - 1; + if (e <= 0) + return LWS_SRET_OK; /* off to the left */ + + do { + if (lws_flow_feed(&dlo_png->flow)) + /* if he says WANT_INPUT, we have nothing in the buflist */ + return LWS_SRET_WANT_INPUT; + + pix = NULL; + r = lws_upng_emit_next_line(dlo_png->png, &pix, &dlo_png->flow.data, + &dlo_png->flow.len, rs->html == 1 /* hold at metadata */); + + if (r & LWS_SRET_NO_FURTHER_IN) + dlo_png->flow.state = LWSDLOFLOW_STATE_READ_COMPLETED; + + if (r & (LWS_SRET_FATAL | LWS_SRET_YIELD) || r == LWS_SRET_OK) + return r; + + r = lws_flow_req(&dlo_png->flow); + if (r & LWS_SRET_WANT_INPUT) + return r; + + } while (!pix); + + pix = pix + (( (unsigned int)(s - ax.whole) * + (lws_upng_get_pixelsize(dlo_png->png) / 8))); + + while (s < e && s >= ax.whole && s < lws_fx_roundup(&t) && + (s - ax.whole) < (int)lws_upng_get_width(dlo_png->png)) { + + if (lws_upng_get_pixelsize(dlo_png->png)) + pc = LWSDC_RGBA(pix[0], pix[0], pix[0], pix[1]); + + pc = LWSDC_RGBA(pix[0], pix[1], pix[2], pix[3]); + + lws_surface_set_px(rs->ic, rs->line, s, &pc); + + s++; + pix += lws_upng_get_pixelsize(dlo_png->png) / 8; + } + + return LWS_SRET_OK; +} + +lws_stateful_ret_t +lws_display_dlo_png_metadata_scan(lws_dlo_png_t *dlo_png) +{ + lws_stateful_ret_t r; + size_t l, l1; + const uint8_t *pix; + + /* + * If we don't have the image metadata yet, provide small chunks of the + * source data until we do have the image metadata, but small enough + * we can't produce any decoded pixels too early. + */ + + while (!lws_upng_get_height(dlo_png->png) && dlo_png->flow.len) { + l1 = l = dlo_png->flow.len > 33 ? 33 : dlo_png->flow.len; + + r = lws_upng_emit_next_line(dlo_png->png, &pix, &dlo_png->flow.data, &l, 1); + if (r & LWS_SRET_FATAL) { + lwsl_err("%s: hdr parse failed\n", __func__); + return r; + } + + dlo_png->flow.len -= l1 - l; + + if (lws_upng_get_height(dlo_png->png)) { + lwsl_info("png: w %d, h %d\n", + lws_upng_get_width(dlo_png->png), + lws_upng_get_height(dlo_png->png)); + return LWS_SRET_OK; + } + } + + return LWS_SRET_WANT_INPUT; +} + +lws_dlo_png_t * +lws_display_dlo_png_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box) +{ + lws_dlo_png_t *dlo_png = lws_zalloc(sizeof(*dlo_png), __func__); + + dlo_png->png = lws_upng_new(); + if (!dlo_png->png) + goto bail; + + dlo_png->dlo.box = *box; + dlo_png->dlo.render = lws_display_render_png; + dlo_png->dlo._destroy = lws_display_dlo_png_destroy; + + lws_display_dlo_add(dl, dlo_parent, &dlo_png->dlo); + + return dlo_png; + +bail: + if (dlo_png->png) + lws_upng_free(&dlo_png->png); + lws_free(dlo_png); + + return NULL; +} diff --git a/lib/misc/dlo/dlo-rect.c b/lib/misc/dlo/dlo-rect.c new file mode 100644 index 000000000..1a80e7399 --- /dev/null +++ b/lib/misc/dlo/dlo-rect.c @@ -0,0 +1,247 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object: rect / rounded rect + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +/* returns where on the x axis we intercept ys (== (curr - ory) ^ 2 ) */ + +static void +isect(lws_circle_t *c, lws_fx_t *f, lws_fx_t *axsq) +{ + assert(axsq->whole >= 0); + assert(c->rsq.whole >= 0); + + lws_fx_sub(f, &c->rsq, axsq); + + if (f->whole < 0) { + f->whole = 0; + f->frac = 0; + } else + lws_fx_sqrt(f, f); + + lws_fx_sub(f, &c->r, f); +} + +/* give it absolute x, returns intersection point as absolute y*/ + +static void +isect_y_from_x(lws_circle_t *c, lws_fx_t *x, lws_fx_t *y) +{ + lws_fx_t t, t1; + + lws_fx_sub(y, x, &c->orx); + lws_fx_mul(&t, y, y); + lws_fx_sub(&t1, &c->rsq, &t); + lws_fx_sqrt(&t, &t1); + lws_fx_add(y, &c->ory, &t); +} + +lws_stateful_ret_t +lws_display_render_rect(struct lws_display_render_state *rs) + /* const lws_surface_info_t *ic, struct lws_dlo *dlo, + const lws_box_t *origin, lws_display_scalar curr, + uint8_t *line, lws_colour_error_t **nle) */ +{ + lws_dlo_t *dlo = rs->st[rs->sp].dlo; + lws_dlo_rect_t *r = lws_container_of(dlo, lws_dlo_rect_t, dlo); + lws_fx_t cf, y, w, trim, s, e, t2, sfy; + lws_display_colour_t dc; + int n, le, os; + + if (!LWSDC_ALPHA(dlo->dc)) + return LWS_SRET_OK; + + if (!r->init) { + lws_fx_add(&r->db.x, &rs->st[rs->sp].co.x, &dlo->box.x); + lws_fx_add(&r->db.y, &rs->st[rs->sp].co.y, &dlo->box.y); + lws_fx_add(&r->right, &r->db.x, &dlo->box.w); + lws_fx_add(&r->btm, &r->db.y, &dlo->box.h); + lws_fx_add(&r->c[0].ory, &r->db.y, &r->c[0].r); + lws_fx_add(&r->c[1].ory, &r->db.y, &r->c[1].r); + lws_fx_sub(&r->c[2].ory, &r->btm, &r->c[2].r); + lws_fx_sub(&r->c[3].ory, &r->btm, &r->c[3].r); + lws_fx_add(&r->c[0].orx, &r->db.x, &r->c[0].r); + lws_fx_sub(&r->c[1].orx, &r->right, &r->c[1].r); + lws_fx_add(&r->c[2].orx, &r->db.x, &r->c[2].r); + lws_fx_sub(&r->c[3].orx, &r->right, &r->c[3].r); + + r->init = 1; + } + + if (lws_fx_comp(&r->db.x, &rs->ic->wh_px[0]) >= 0) + return LWS_SRET_OK; /* off to the right */ + + if (rs->curr < r->db.y.whole - 1 || rs->curr > lws_fx_roundup(&r->btm)) + return LWS_SRET_OK; + + s = r->db.x; + lws_fx_add(&e, &s, &dlo->box.w); + + cf.whole = rs->curr; + cf.frac = 50000000; + + /* + * Account for four independently radiused corners + * + * Fractional pixel occupancy is represented by modulating alpha. + * + * We know that the subpixel intersection on the circle is at yo.frac + + * radius.frac which usually won't align to any pixel boundary. + */ + + for (n = 0; n < 4; n++) { + lws_fx_sub(&y, &cf, &r->c[n].ory); + lws_fx_mul(&r->c[n].ys, &y, &y); + } + + /* For this y line, find out how many x pixels we can skip at start + * and end before and after the first pixels that intersect */ + + if (rs->curr <= (r->c[0].ory.whole)) { /* top left trims s */ + isect(&r->c[0], &trim, &r->c[0].ys /* (cf - ory)^2 */); + lws_fx_add(&s, &s, &trim); + } + + if (rs->curr <= (r->c[1].ory.whole)) { /* top right trims e */ + isect(&r->c[1], &trim, &r->c[1].ys); + lws_fx_sub(&e, &e, &trim); + } + + if (rs->curr >= (r->c[2].ory.whole)) { /* bottom left trims s */ + isect(&r->c[2], &trim, &r->c[2].ys); + lws_fx_add(&s, &s, &trim); + } + + if (rs->curr >= (r->c[3].ory.whole)) { /* bottom right trims e */ + isect(&r->c[3], &trim, &r->c[3].ys); + lws_fx_sub(&e, &e, &trim); + } + + /* clips */ + + if (s.whole < 0) + lws_fx_set(s, 0, 0); + if (e.whole >= rs->ic->wh_px[0].whole) + lws_fx_set(e, rs->ic->wh_px[0].whole - 1, 0); + if (e.whole <= 0 || e.whole < s.whole) + return LWS_SRET_OK; /* off to the left */ + + lws_fx_sub(&w, &e, &s); + if (lws_fx_comp(&w, &dlo->box.w) > 0) + lws_fx_add(&e, &s, &dlo->box.w); + + /* render the part of the line occupied by the rect body */ + + sfy = s; + os = s.whole; + s.frac = 0; + le = e.whole + 1; + + while (s.whole <= le) { + unsigned int alpha = dlo->dc >> 24; + + if (rs->curr <= r->c[0].ory.whole - 1 && s.whole >= r->db.x.whole && + lws_fx_comp(&s, &r->c[0].orx) <= 0) { + isect_y_from_x(&r->c[0], &s, &t2); + lws_fx_sub(&t2, &t2, &r->c[0].r); + lws_fx_sub(&t2, &t2, &r->c[0].r); + if (t2.frac && lws_fx_rounddown(&t2) == rs->curr) + alpha = (((uint64_t)t2.frac * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + } + if (rs->curr <= (r->c[1].ory.whole - 1) && + s.whole >= r->c[1].orx.whole) { + isect_y_from_x(&r->c[1], &s, &t2); + lws_fx_sub(&t2, &t2, &r->c[1].r); + lws_fx_sub(&t2, &t2, &r->c[1].r); + if (t2.frac && lws_fx_rounddown(&t2) == rs->curr) + alpha = (((uint64_t)t2.frac * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + } + if (rs->curr >= (r->c[2].ory.whole + 1) && + s.whole < lws_fx_roundup(&r->c[2].orx)) { + isect_y_from_x(&r->c[2], &s, &t2); + if (t2.frac && lws_fx_rounddown(&t2) == rs->curr) + alpha = (((uint64_t)t2.frac * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + } + + if (rs->curr >= (r->c[3].ory.whole + 1) && + s.whole >= lws_fx_roundup(&r->c[3].orx)) { + isect_y_from_x(&r->c[3], &s, &t2); + if (t2.frac && lws_fx_rounddown(&t2) == rs->curr) + alpha = (((uint64_t)t2.frac * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + } + + if (s.whole == os && sfy.frac) + alpha = (((uint64_t)(99999999 - sfy.frac) * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + if (s.whole == le) + alpha = (((uint64_t)e.frac * alpha) / + LWS_FX_FRACTION_MSD) & 0xff; + + + dc = (lws_display_colour_t)(((dlo->dc & 0xffffff) | + (uint32_t)(alpha << 24))); + + lws_surface_set_px(rs->ic, rs->line, s.whole, &dc); + + s.whole++; + } + + return LWS_SRET_OK; +} + +lws_dlo_rect_t * +lws_display_dlo_rect_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box, const lws_fx_t *radii, + lws_display_colour_t dc) +{ + lws_dlo_rect_t *r = lws_zalloc(sizeof(*r), __func__); + int n; + + if (!r) + return NULL; + + r->dlo.render = lws_display_render_rect; + r->dlo.box = *box; + r->dlo.dc = dc; + if (radii) { + r->c[0].r = radii[0]; + r->c[1].r = radii[1]; + r->c[2].r = radii[2]; + r->c[3].r = radii[3]; + + for (n = 0; n < 4; n++) + lws_fx_mul(&r->c[n].rsq, &r->c[n].r, &r->c[n].r); + } + + lws_display_dlo_add(dl, dlo_parent, &r->dlo); + + return r; +} diff --git a/lib/misc/dlo/dlo-ss.c b/lib/misc/dlo/dlo-ss.c new file mode 100644 index 000000000..0f24f557e --- /dev/null +++ b/lib/misc/dlo/dlo-ss.c @@ -0,0 +1,289 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Secure Streams as DLO transport + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +LWS_SS_USER_TYPEDEF + sul_cb_t on_rx; + lhp_ctx_t *lhp; + lws_sorted_usec_list_t *ssevsul; /* sul to use to resume rz */ + lws_sorted_usec_list_t sul; /* used for initial metadata cb */ + lws_dlo_image_t u; /* we use the lws_flow_t in here */ + lws_dll2_t active_asset_list; /*cx->active_assets*/ + char url[96]; +} dloss_t; + +/* + * dlo images call back here when they have their dimensions (or have failed) + */ + +void +lws_lhp_image_dimensions_cb(lws_sorted_usec_list_t *sul) +{ + dloss_t *m = lws_container_of(sul, dloss_t, sul); + lws_display_render_state_t *rs = lws_container_of(m->ssevsul, + lws_display_render_state_t, sul); + + if (m->u.failed) { + m->u.u.dlo_png->dlo.box.w.whole = -1; + m->u.u.dlo_png->dlo.box.h.whole = -1; + lwsl_notice("%s: Failing %s\n", __func__, m->url); + } else { + + m->u.u.dlo_png->dlo.box.w.whole = (int32_t)lws_dlo_image_width(&m->u); + m->u.u.dlo_png->dlo.box.h.whole = (int32_t)lws_dlo_image_height(&m->u); + + lwsl_notice("%s: setting dlo box %d x %d\n", __func__, + (int)m->u.u.dlo_png->dlo.box.w.whole, (int)m->u.u.dlo_png->dlo.box.h.whole); + } + + if (rs->html != 1) { + lws_sul_schedule(lws_ss_get_context(m->ss), 0, m->ssevsul, m->on_rx, 1); + return; + } +} + +/* secure streams payload interface */ + +static lws_ss_state_return_t +dloss_rx(void *userobj, const uint8_t *buf, size_t len, int flags) +{ + dloss_t *m = (dloss_t *)userobj; + lws_stateful_ret_t r; + + lwsl_info("%s: %u\n", __func__, (unsigned int)len); + + /* .flow is at the same offset in both dlo_jpeg and dlo_png */ + + if (len && + lws_buflist_append_segment(&m->u.u.dlo_jpeg->flow.bl, buf, len) < 0) { + m->u.failed = 1; + lws_sul_schedule(lws_ss_get_context(m->ss), 0, + &m->sul, lws_lhp_image_dimensions_cb, 1); + return LWSSSSRET_DISCONNECT_ME; + } + + // lwsl_notice("%s: buflen size %d\n", __func__, + // (int)lws_buflist_total_len(&m->u.u.dlo_jpeg->flow.bl)); + + if (flags & LWSSS_FLAG_EOM) { + m->u.u.dlo_jpeg->flow.state = LWSDLOFLOW_STATE_READ_COMPLETED; + return LWSSSSRET_DISCONNECT_ME; + } + + if (!lws_dlo_image_width(&m->u)) { + lws_flow_feed(&m->u.u.dlo_jpeg->flow); + r = lws_dlo_image_metadata_scan(&m->u); + lws_flow_req(&m->u.u.dlo_jpeg->flow); + + if (r & LWS_SRET_FATAL) { + m->u.failed = 1; + lws_sul_schedule(lws_ss_get_context(m->ss), 0, + &m->sul, lws_lhp_image_dimensions_cb, 1); + return LWSSSSRET_DISCONNECT_ME; + } + + if (r != LWS_SRET_WANT_INPUT) { + lwsl_notice("%s: seen metadata\n", __func__); + lws_sul_schedule(lws_ss_get_context(m->ss), 0, + &m->sul, lws_lhp_image_dimensions_cb, 1); + } //else + //lwsl_err("%s: metadata scan no end yet\n", __func__); + + return LWSSSSRET_OK; + } + + lws_sul_schedule(lws_ss_get_context(m->ss), 0, m->ssevsul, m->on_rx, 1); + + return LWSSSSRET_OK; +} + +static lws_ss_state_return_t +dloss_state(void *userobj, void *sh, lws_ss_constate_t state, + lws_ss_tx_ordinal_t ack) +{ + dloss_t *m = (dloss_t *)userobj; + + switch (state) { + case LWSSSCS_CREATING: + break; + + case LWSSSCS_DESTROYING: + lws_dll2_remove(&m->active_asset_list); + break; + + default: + break; + } + + return LWSSSSRET_OK; +} + +static LWS_SS_INFO("default", dloss_t) + .rx = dloss_rx, + .state = dloss_state +}; + +/* + * If we have an active image asset from this URL, return a pointer to its + * dlo image (ie, dlo_jpeg or dlo_png) + */ + +int +lws_dlo_ss_find(struct lws_context *cx, const char *url, lws_dlo_image_t *u) +{ + lws_start_foreach_dll(struct lws_dll2 *, d, + lws_dll2_get_head(&cx->active_assets)) { + dloss_t *ds = lws_container_of(d, dloss_t, active_asset_list); + + if (!strcmp(url, ds->url)) { + *u = ds->u; + + return 0; /* found */ + } + + } lws_end_foreach_dll(d); + + return 1; /* not found */ +} + +lws_dlo_t * +lws_dlo_ss_create(lws_dlo_ss_create_info_t *i) +{ + lws_dlo_jpeg_t *dlo_jpeg = NULL; + lws_dlo_png_t *dlo_png = NULL; + size_t ul = strlen(i->url); + struct lws_ss_handle *h; + lws_ss_info_t ssi; + dloss_t *dloss; + lws_dlo_t *dlo; + char type; + + if (ul < 5) + return NULL; + + if (!strcmp(i->url + ul - 4, ".png")) + type = LWSDLOSS_TYPE_PNG; + else + if (!strcmp(i->url + ul - 4, ".jpg") || + !strcmp(i->url + ul - 5, ".jpeg")) + type = LWSDLOSS_TYPE_JPEG; + else + return NULL; + + switch (type) { + case LWSDLOSS_TYPE_PNG: + dlo_png = lws_display_dlo_png_new(i->dl, i->dlo_parent, i->box); + if (!dlo_png) + return NULL; + + i->u->u.dlo_png = dlo_png; + + dlo_png->dlo.box.w.whole = (int32_t) + lws_upng_get_width(dlo_png->png); + dlo_png->dlo.box.w.frac = 0; + dlo_png->dlo.box.h.whole = (int32_t) + lws_upng_get_height(dlo_png->png); + dlo_png->dlo.box.h.frac = 0; + + dlo = &dlo_png->dlo; + break; + + case LWSDLOSS_TYPE_JPEG: + dlo_jpeg = lws_display_dlo_jpeg_new(i->dl, i->dlo_parent, i->box); + if (!dlo_jpeg) + return NULL; + + i->u->u.dlo_jpeg = dlo_jpeg; + + dlo_jpeg->dlo.box.w.whole = (int32_t) + lws_jpeg_get_width(dlo_jpeg->j); + dlo_jpeg->dlo.box.w.frac = 0; + dlo_jpeg->dlo.box.h.whole = (int32_t) + lws_jpeg_get_height(dlo_jpeg->j); + dlo_jpeg->dlo.box.h.frac = 0; + + dlo = &dlo_jpeg->dlo; + break; + } + + /* we adapt the initial tx credit also to the requested window */ + + ssi = ssi_dloss_t; + ssi.manual_initial_tx_credit = i->window; + + if (lws_ss_create(i->cx, 0, &ssi, (void *)dlo, &h, NULL, NULL)) { + lwsl_notice("%s: unable to create ss\n", __func__); + return NULL; + } + + dloss = (dloss_t *)lws_ss_to_user_object(h); + dloss->u.type = (lws_dlo_image_type_t)type; + dloss->on_rx = i->on_rx; + dloss->ssevsul = i->on_rx_sul; + dloss->lhp = i->lhp; + lws_strncpy(dloss->url, i->url, sizeof(dloss->url)); + + switch (type) { + case LWSDLOSS_TYPE_PNG: + dloss->u.u.dlo_png = dlo_png; + dlo_png->flow.h = h; + dlo_png->flow.window = i->window; + break; + case LWSDLOSS_TYPE_JPEG: + dloss->u.u.dlo_jpeg = dlo_jpeg; + dlo_jpeg->flow.h = h; + dlo_jpeg->flow.window = i->window; + break; + } + + if (lws_ss_alloc_set_metadata(h, "endpoint", i->url, ul)) + goto fail; + + if (lws_ss_client_connect(dloss->ss)) + goto fail; + + lws_dll2_add_tail(&dloss->active_asset_list, &i->cx->active_assets); + + lwsl_notice("%s: starting %s (dlo %p)\n", __func__, i->url, dlo); + + return dlo; + +fail: + lws_ss_destroy(&h); + + switch (type) { + case LWSDLOSS_TYPE_PNG: + lws_display_dlo_png_destroy(&dlo_png->dlo); + break; + case LWSDLOSS_TYPE_JPEG: + lws_display_dlo_jpeg_destroy(&dlo_jpeg->dlo); + break; + } + + return NULL; +} diff --git a/lib/misc/dlo/dlo-text.c b/lib/misc/dlo/dlo-text.c new file mode 100644 index 000000000..dab3f69a6 --- /dev/null +++ b/lib/misc/dlo/dlo-text.c @@ -0,0 +1,413 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object: text + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +size_t +utf8_bytes(uint8_t u) +{ + if ((u & 0x80) == 0) + return 1; + + if ((u & 0xe0) == 0xc0) + return 2; + + if ((u & 0xf0) == 0xe0) + return 3; + + if ((u & 0xf8) == 0xf0) + return 4; + + return 0; +} + +static int +utf8_unicode(const char *utf8, size_t *utf8_len, uint32_t *unicode) +{ + size_t glyph_len = utf8_bytes((uint8_t)*utf8); + size_t n; + + if (!glyph_len || glyph_len > *utf8_len) { + (*utf8_len)--; + return 1; + } + + if (glyph_len == 1) + *unicode = (uint32_t)*utf8++; + else { + *unicode = (uint32_t)((*utf8++) & (0x7f >> glyph_len)); + for (n = 1; n < glyph_len; n++) + *unicode = (*unicode << 6) | ((*utf8++) & 0x3f); + } + + *utf8_len -= glyph_len; + + return 0; +} + +void +lws_display_dlo_text_destroy(struct lws_dlo *dlo) +{ + lws_dlo_text_t *text = lws_container_of(dlo, lws_dlo_text_t, dlo); + + lws_free_set_NULL(text->kern); + lws_free_set_NULL(text->text); + + lwsac_free(&text->ac_glyphs); +} + +int +lws_display_dlo_text_update(lws_dlo_text_t *text, lws_display_colour_t dc, + lws_fx_t indent, const char *utf8, size_t text_len) +{ + const char *last_utf8 = utf8, *outf8 = utf8; + size_t last_bp_n = 0, tlen = text_len; + lws_fx_t t1, eff, last_bp_eff, t2; + uint8_t r = 0; + char uc; + + if (text->kern) + lws_free_set_NULL(text->kern); + + if (text->text) + lws_free_set_NULL(text->text); + + lws_dll2_owner_clear(&text->glyphs); + lwsac_free(&text->ac_glyphs); + + text->indent = indent; + text->dlo.dc = dc; + + lws_fx_set(eff, 0, 0); + + /* + * Let's go through the new string glyph by glyph, we want to + * calculate effective kerned widths, and optionally deal with wrapping. + * + * But we don't want to instantiate the glyph objects until we are + * engaged with rendering them. Otherwise we will carry around the + * whole page-worth's of glyphs at once needlessly, which won't scale + * for text-heavy pages. lws_display_dlo_text_attach_glyphs() does the + * same flow as this but to create the glyphs and is called later + * as the text dlo becomes rasterized during rendering. + */ + +/* { char b1[22]; lwsl_err("eff %s\n", lws_fx_string(&eff, b1, sizeof(b1))); } + { char b1[22]; lwsl_err("indent %s\n", lws_fx_string(&indent, b1, sizeof(b1))); } + { char b1[22]; lwsl_err("boxw %s\n", lws_fx_string(&text->dlo.box.w, b1, sizeof(b1))); } */ + + while (tlen && + lws_fx_comp(lws_fx_add(&t1, &eff, &indent), &text->dlo.box.w) < 0) { + size_t ot = tlen; + uint32_t unicode; + + if (!utf8_unicode(utf8, &tlen, &unicode)) { + text->font->image_glyph(text, unicode, 0); + + uc = *utf8; + utf8 += (ot - tlen); + + if (uc == ' ') { /* act to snip it if used */ + last_utf8 = utf8; + last_bp_n = tlen; + last_bp_eff = eff; + } + + if (!lws_display_font_mcufont_getcwidth(text, unicode, &t2)) + lws_fx_add(&eff, &eff, &t2); + + if (uc == '-' || uc == ',' || uc == ';' || uc == ':') { + /* act to leave it in */ + last_utf8 = utf8; + last_bp_n = tlen; + last_bp_eff = eff; + } + } else + lwsl_err("%s: missing glyph\n", __func__); + } + + if (last_bp_n && + lws_fx_comp(lws_fx_add(&t1, &eff, &indent), &text->dlo.box.w) >= 0) { + eff = last_bp_eff; + utf8 = last_utf8; + tlen = last_bp_n; + r = 1; + } + + text->text_len = text_len - tlen; + if (tlen == text_len) { + lwsl_notice("we couldn't fit anything in there, newline\n"); + return 2; + } + + text->text = lws_malloc(text->text_len + 1, __func__); + if (!text->text) + return -1; + + memcpy(text->text, outf8, text->text_len); + text->text[text->text_len] = '\0'; + + memset(&text->bounding_box, 0, sizeof(text->bounding_box)); + text->bounding_box.w = eff; + text->bounding_box.h.whole = text->font_height; + text->bounding_box.h.frac = 0; + + return r; +} + +int +lws_display_dlo_text_attach_glyphs(lws_dlo_text_t *text) +{ + const char *utf8 = text->text; + size_t tlen = text->text_len; + lws_font_glyph_t *g = NULL; + uint32_t unicode; + lws_fx_t eff; + uint8_t r = 0; + + lws_fx_set(eff, 0, 0); + + while (tlen) { + size_t ot = tlen; + + g = NULL; + if (!utf8_unicode(utf8, &tlen, &unicode)) + /* instantiate the glyphs this time */ + g = text->font->image_glyph(text, unicode, 1); + if (g == NULL) { + lwsl_warn("%s: no glyph for 0x%02X '%c'\n", __func__, (unsigned int)*utf8, *utf8); + break; + } + + utf8 += (ot - tlen); + g->xpx = eff; + lws_fx_add(&eff, &eff, &g->cwidth); + } + + return r; +} + +lws_dlo_text_t * +lws_display_dlo_text_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, + lws_box_t *box, const lws_display_font_t *font) +{ + lws_dlo_text_t *text = lws_zalloc(sizeof(*text), __func__); + + if (!text) + return NULL; + + text->dlo.render = font->renderer; + text->dlo._destroy = lws_display_dlo_text_destroy; + text->dlo.box = *box; + text->font = font; + + lws_display_dlo_add(dl, dlo_parent, &text->dlo); + + return text; +} + +static const char * +castrstr(const char *haystack, const char *needle) +{ + size_t sn = strlen(needle), h = strlen(haystack) - sn + 1, n; + char c, c1; + + while (1) { + for (n = 0; n < sn; n++) { + c = (char)((haystack[h + n] >= 'A' && haystack[h + n] <= 'Z') ? + haystack[h + n] + ('a' - 'A') : haystack[h + n]); + c1 = (char)((needle[n] >= 'A' && needle[n] <= 'Z') ? + needle[n] + ('a' - 'A') : needle[n]); + if (c != c1) + break; + } + if (n == sn) + return &haystack[h]; + + if (!h) + break; + h--; + } + + return NULL; +} + +int +lws_font_register(struct lws_context *cx, const uint8_t *data, size_t data_len) +{ + lws_display_font_t *a; + + if (lws_ser_ru32be(data) != LWS_FOURCC('M', 'C', 'U', 'F')) + return 1; + + a = lws_zalloc(sizeof(*a), __func__); + if (!a) + return 1; + + a->choice.family_name = (const char *)data + + lws_ser_ru32be(data + MCUFO_FOFS_FULLNAME); + + if (castrstr(a->choice.family_name, "serif") || + castrstr(a->choice.family_name, "roman")) + a->choice.generic_name = "serif"; + else + a->choice.generic_name = "sans"; + + if (castrstr(a->choice.family_name, "italic") || + castrstr(a->choice.family_name, "oblique")) + a->choice.style = 1; + + if (castrstr(a->choice.family_name, "extrabold") || + castrstr(a->choice.family_name, "extra bold")) + a->choice.weight = 900; + else + if (castrstr(a->choice.family_name, "bold")) + a->choice.weight = 700; + else + if (castrstr(a->choice.family_name, "extralight") || + castrstr(a->choice.family_name, "extra light")) + a->choice.weight = 200; + else + if (castrstr(a->choice.family_name, "light")) + a->choice.weight = 300; + else + a->choice.weight = 400; + + a->choice.fixed_height = lws_ser_ru16be(data + MCUFO16_LINE_HEIGHT); + + a->data = data; + a->data_len = data_len; + a->renderer = lws_display_font_mcufont_render; + a->image_glyph = lws_display_font_mcufont_image_glyph; + + { + lws_dlo_text_t t; + + memset(&t, 0, sizeof(t)); + t.font = a; + + lws_display_font_mcufont_getcwidth(&t, 'm', &a->em); + a->ex.whole = a->choice.fixed_height; + a->ex.frac = 0; + } + + lws_dll2_clear(&a->list); + lws_dll2_add_tail(&a->list, &cx->fonts); + + return 0; +} + +static int +lws_font_destroy(struct lws_dll2 *d, void *user) +{ + lws_free(d); + return 0; +} + +void +lws_fonts_destroy(struct lws_context *cx) +{ + lws_dll2_foreach_safe(&cx->fonts, NULL, lws_font_destroy); +} + +struct track { + const lws_font_choice_t *hints; + const lws_display_font_t *best; + int best_score; +}; + +static int +lws_fonts_score(struct lws_dll2 *d, void *user) +{ + const lws_display_font_t *f = lws_container_of(d, lws_display_font_t, + list); + struct track *t = (struct track *)user; + struct lws_tokenize ts; + int score = 1000; + + if (t->hints->family_name) { + memset(&ts, 0, sizeof(ts)); + ts.start = t->hints->family_name; + ts.len = strlen(ts.start); + ts.flags = LWS_TOKENIZE_F_COMMA_SEP_LIST; + + do { + ts.e = (int8_t)lws_tokenize(&ts); + if (ts.e == LWS_TOKZE_TOKEN) { + if (!strncmp(f->choice.family_name, ts.token, + ts.token_len)) { + score = 0; + break; + } + + if (f->choice.generic_name && + !strncmp(f->choice.generic_name, ts.token, + ts.token_len)) { + score -= 500; + break; + } + + } + + } while (ts.e > 0); + } + + if (t->hints->weight) + score += (t->hints->weight > f->choice.weight ? + (t->hints->weight - f->choice.weight) : + (f->choice.weight - t->hints->weight)) / 100; + + if (t->hints->style != f->choice.style) + score += 100; + + if (t->hints->fixed_height) + score += 10 * (t->hints->fixed_height > f->choice.fixed_height ? + (t->hints->fixed_height - f->choice.fixed_height) : + (f->choice.fixed_height - t->hints->fixed_height)); + + if (score < t->best_score) { + t->best_score = score; + t->best = f; + } + + return 0; +} + +const lws_display_font_t * +lws_font_choose(struct lws_context *cx, const lws_font_choice_t *hints) +{ + struct track t; + + t.hints = hints; + t.best = (const lws_display_font_t *)cx->fonts.head; + t.best_score = 99999999; + + if (t.hints) + lws_dll2_foreach_safe(&cx->fonts, &t, lws_fonts_score); + + return t.best; +} diff --git a/lib/misc/dlo/dlo.c b/lib/misc/dlo/dlo.c new file mode 100644 index 000000000..07c7069e3 --- /dev/null +++ b/lib/misc/dlo/dlo.c @@ -0,0 +1,365 @@ +/* + * lws abstract display + * + * Copyright (C) 2019 - 2022 Andy Green + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Display List Object handling + */ + +#include +#include "private-lib-drivers-display-dlo.h" + +#define dlodump_loglevel LLL_NOTICE +#if (_LWS_ENABLED_LOGS & dlodump_loglevel) +#define lwsl_dlodump(...) _lws_log(dlodump_loglevel, __VA_ARGS__) +#else +#define lwsl_dlodump(...) +#endif + +void +lws_display_dl_init(lws_displaylist_t *dl, lws_display_state_t *ds) +{ + lws_dll2_owner_clear(&dl->dl); + dl->ds = ds; +} + +int +lws_display_dlo_add(lws_displaylist_t *dl, lws_dlo_t *dlo_parent, lws_dlo_t *dlo) +{ + lws_dll2_add_tail(&dlo->list, dlo_parent ? &dlo_parent->children : &dl->dl); + + return 9; +} + +void +lws_surface_set_px(const lws_surface_info_t *ic, uint8_t *line, int x, + const lws_display_colour_t *c) +{ + unsigned int alpha, ialpha; + lws_display_colour_t oc; + uint8_t rgb[3]; + + if (x < 0 || x >= ic->wh_px[0].whole) + return; + + /* + * All alpha composition takes place at 8bpp grey or 24bpp + */ + + if (ic->greyscale) { + + /* line composition buffer is 8-bit Y per pixel */ + + oc = line[x]; + alpha = LWSDC_ALPHA(*c); + ialpha = 255 - alpha; + + line[x] = (uint8_t)(((LWSDC_R(*c) * alpha) / 255) + + ((LWSDC_R(oc) * ialpha) / 255)); + return; + } + + /* line composition buffer is 24-bit RGB per pixel */ + + line += 3 * x; + + alpha = LWSDC_ALPHA(*c); + ialpha = 255 - alpha; + + rgb[0] = (uint8_t)(((LWSDC_R(*c) * alpha) / 255) + + ((line[0] * ialpha) / 255)); + rgb[1] = (uint8_t)(((LWSDC_G(*c) * alpha) / 255) + + ((line[1] * ialpha) / 255)); + rgb[2] = (uint8_t)(((LWSDC_B(*c) * alpha) / 255) + + ((line[2] * ialpha) / 255)); + + *line++ = rgb[0]; + *line++ = rgb[1]; + *line = rgb[2]; +} + + +#if defined(_DEBUG) +void +lws_display_dl_dump(lws_displaylist_t *dl) +{ + lws_display_render_stack_t st[12]; /* DLO child stack */ + int sp = 0; + lws_dll2_t *d = lws_dll2_get_head(&dl->dl); +#if (_LWS_ENABLED_LOGS & dlodump_loglevel) + static const char * const ind = " "; +#endif + char b[4][22], b1[4][22], dt[96]; + + if (!d) { + lwsl_notice("%s: empty dl\n", __func__); + + return; + } + + lwsl_notice("%s\n", __func__); + + memset(&st, 0, sizeof(st)); + st[0].dlo = lws_container_of(d, lws_dlo_t, list); + + while (sp || st[0].dlo) { + lws_dlo_t *dlo = st[sp].dlo; + lws_box_t co; + //lws_fx_t t2; + + if (!dlo) { + if (!sp) { + lwsl_err("%s: underflow\n", __func__); + return; + } + sp--; + continue; + } + + lws_fx_add(&co.x, &st[sp].co.x, &dlo->box.x); + lws_fx_add(&co.y, &st[sp].co.y, &dlo->box.y); + co.w = dlo->box.w; + co.h = dlo->box.h; + + lws_snprintf(dt, sizeof(dt), "rect: RGBA 0x%08X", (unsigned int)dlo->dc); + if (dlo->_destroy == lws_display_dlo_text_destroy) { + lws_dlo_text_t *text = lws_container_of(dlo, lws_dlo_text_t, dlo); + lws_snprintf(dt, sizeof(dt), "text: RGBA 0x%08X, chars: %u, %s", + (unsigned int)dlo->dc, (unsigned int)text->text_len, text->text); + } + else if (dlo->_destroy == lws_display_dlo_png_destroy) + lws_snprintf(dt, sizeof(dt), "png"); + else if (dlo->_destroy == lws_display_dlo_jpeg_destroy) + lws_snprintf(dt, sizeof(dt), "jpeg"); + + lws_fx_string(&dlo->box.x, b[0], sizeof(b[0])); + lws_fx_string(&dlo->box.y, b[1], sizeof(b[1])); + lws_fx_string(&dlo->box.w, b[2], sizeof(b[2])); + lws_fx_string(&dlo->box.h, b[3], sizeof(b[3])); + lws_fx_string(&co.x, b1[0], sizeof(b1[0])); + lws_fx_string(&co.y, b1[1], sizeof(b1[1])); + lws_fx_string(&co.w, b1[2], sizeof(b1[2])); + lws_fx_string(&co.h, b1[3], sizeof(b1[3])); + + lwsl_dlodump("%.*s box: (%s, %s) [%s x %s], co: (%s, %s) [%s x %s], %s\n", + sp, ind, b[0], b[1], b[2], b[3], b1[0], b1[1], b1[2], b1[3], dt); + + /* go into any children */ + + if (dlo->children.head) { + if (sp + 1 == LWS_ARRAY_SIZE(st)) { + lwsl_err("%s: DLO stack overflow\n", __func__); + return; + } + st[sp++].dlo = lws_container_of( + dlo->children.head, lws_dlo_t, list); + st[sp].co = co; + continue; + } + + d = dlo->list.next; + if (d) + st[sp].dlo = lws_container_of(d, lws_dlo_t, list); + else + st[sp].dlo = NULL; + } +} +#endif + +lws_stateful_ret_t +lws_display_list_render_line(lws_display_render_state_t *rs) +{ + lws_dll2_t *d; + + if (rs->html == 1) + return LWS_SRET_WANT_INPUT; + + if (!rs->sp && !rs->st[0].dlo) { + + /* starting a line */ + + d = lws_dll2_get_head(&rs->displaylist.dl); + if (!d) + /* nothing in dlo */ + return LWS_SRET_OK; + + // memset(rs->line, 0, (size_t)rs->ic->wh_px[0].whole * + // (rs->ic->greyscale ? 1 : 3)); + memset(&rs->st[0].co, 0, sizeof(rs->st[0].co)); + rs->st[0].dlo = lws_container_of(d, lws_dlo_t, list); + } + + while (rs->sp || rs->st[0].dlo) { + lws_dlo_t *dlo = rs->st[rs->sp].dlo; + lws_stateful_ret_t r; + lws_box_t co; + lws_fx_t t2; + + if (!dlo) { + rs->sp--; + continue; + } + + // lwsl_notice("%s: curr %d: %d %d %d %d\n", __func__, rs->curr, dlo->box.x.whole, dlo->box.y.whole, dlo->box.w.whole, dlo->box.h.whole); + + lws_fx_add(&co.x, &rs->st[rs->sp].co.x, &dlo->box.x); + lws_fx_add(&co.y, &rs->st[rs->sp].co.y, &dlo->box.y); + co.w = dlo->box.w; + co.h = dlo->box.h; + + lws_fx_add(&t2, &co.y, &dlo->box.h); + if (rs->curr > lws_fx_roundup(&t2)) { + d = dlo->list.next; + rs->st[rs->sp].dlo = d ? lws_container_of(d, lws_dlo_t, + list) : NULL; + + lws_display_dlo_destroy(&dlo); + continue; + } + +#if 0 + if (dlo->_destroy == lws_display_dlo_png_destroy) + lwsl_err("png line %d %d %d %d\n", rs->curr, co.y.whole - 1, + rs->st[rs->sp].co.y.whole, dlo->box.y.whole); +#endif + + if (rs->curr >= co.y.whole - 1) { + + r = dlo->render(rs); + //rs->ic, dlo, &rs->st[rs->sp].co, + // rs->curr, rs->line, &dlo->nle[0]); + if (r) + return r; + + /* next sibling at this level if any */ + + d = dlo->list.next; + if (d) + rs->st[rs->sp].dlo = lws_container_of(d, + lws_dlo_t, list); + else + rs->st[rs->sp].dlo = NULL; + + /* go into any children */ + + if (dlo->children.head) { + if (rs->sp + 1 == LWS_ARRAY_SIZE(rs->st)) { + lwsl_err("%s: DLO stack overflow\n", + __func__); + return LWS_SRET_FATAL; + } + rs->st[++rs->sp].dlo = lws_container_of( + dlo->children.head, lws_dlo_t, list); + rs->st[rs->sp].co = co; + continue; + } + } else { + /* next sibling at this level if any */ + + d = dlo->list.next; + if (d) + rs->st[rs->sp].dlo = lws_container_of(d, + lws_dlo_t, list); + else + rs->st[rs->sp].dlo = NULL; + } + } + + return LWS_SRET_OK; +} + +void +lws_display_dlo_destroy(lws_dlo_t **r) +{ + if (!(*r)) + return; + + lws_dll2_remove(&(*r)->list); + + while ((*r)->children.head) { + lws_dlo_t *d = lws_container_of((*r)->children.head, + lws_dlo_t, list); + + lws_display_dlo_destroy(&d); + } + + if ((*r)->_destroy) + (*r)->_destroy(*r); + + lws_free_set_NULL(*r); + *r = NULL; +} + +void +lws_display_list_destroy(lws_displaylist_t *dl) +{ + if (!dl) + return; + + while (dl->dl.head) { + lws_dlo_t *d = lws_container_of(dl->dl.head, lws_dlo_t, list); + + lws_display_dlo_destroy(&d); + } +} + +int +lws_dlo_file_register(struct lws_context *cx, const lws_dlo_filesystem_t *f) +{ + lws_dlo_filesystem_t *a = lws_malloc(sizeof(*a), __func__); + if (!a) + return 1; + + *a = *f; + lws_dll2_clear(&a->list); + lws_dll2_add_tail(&a->list, &cx->dlo_file); + + return 0; +} + +static int +_lws_dlo_file_destroy(struct lws_dll2 *d, void *user) +{ + lws_free(d); + return 0; +} + +void +lws_dlo_file_destroy(struct lws_context *cx) +{ + lws_dll2_foreach_safe(&cx->dlo_file, NULL, _lws_dlo_file_destroy); +} + +const lws_dlo_filesystem_t * +lws_dlo_file_choose(struct lws_context *cx, const char *name) +{ + lws_start_foreach_dll(struct lws_dll2 *, p, + lws_dll2_get_head(&cx->dlo_file)) { + const lws_dlo_filesystem_t *pn = lws_container_of(p, + lws_dlo_filesystem_t, list); + + if (!strcmp(name, pn->name)) + return pn; + + } lws_end_foreach_dll(p); + + return NULL; +} diff --git a/lib/misc/dlo/private-lib-drivers-display-dlo.h b/lib/misc/dlo/private-lib-drivers-display-dlo.h new file mode 100644 index 000000000..4fb8f16e0 --- /dev/null +++ b/lib/misc/dlo/private-lib-drivers-display-dlo.h @@ -0,0 +1,57 @@ +enum { + MCUFO_MAGIC = 0, + MCUFO_FLAGS_VER = 4, + MCUFO_FOFS_FULLNAME = 8, + MCUFO_FOFS_NAME = 0xc, + MCUFO_FOFS_DICT_DATA = 0x10, + MCUFO_SIZE_DICT_DATA = 0x14, + MCUFO_FOFS_DICT_OFS = 0x18, + MCUFO_COUNT_RLE_DICT = 0x1C, + MCUFO_COUNT_REF_RLE_DICT = 0x20, + MCUFO_FOFS_CHAR_RANGE_TABLES = 0x24, + MCUFO_COUNT_CHAR_RANGE_TABLES = 0x28, + MCUFO_UNICODE_FALLBACK = 0x2C, + + MCUFO16_WIDTH = 0x30, + MCUFO16_HEIGHT = 0x32, + MCUFO16_MIN_X_ADV = 0x34, + MCUFO16_MAX_X_ADV = 0x36, + MCUFO16_BASELINE_X = 0x38, + MCUFO16_BASELINE_Y = 0x3a, + MCUFO16_LINE_HEIGHT = 0x3c, +}; + +void +dist_err_floyd_steinberg_grey(int n, int width, lws_greyscale_error_t *gedl_this, + lws_greyscale_error_t *gedl_next); + +void +dist_err_floyd_steinberg_col(int n, int width, lws_colour_error_t *edl_this, + lws_colour_error_t *edl_next); + +int +lws_display_alloc_diffusion(const lws_surface_info_t *ic, lws_surface_error_t **se); + +size_t +utf8_bytes(uint8_t u); + +int +lws_display_font_mcufont_getcwidth(lws_dlo_text_t *text, uint32_t unicode, + lws_fx_t *fx); + +int +lws_display_dlo_text_attach_glyphs(lws_dlo_text_t *text); + +lws_stateful_ret_t +lws_display_font_mcufont_render(struct lws_display_render_state *rs); + +lws_font_glyph_t * +lws_display_font_mcufont_image_glyph(lws_dlo_text_t *text, uint32_t unicode, + char attach); + +void +lws_lhp_ss_html_parse_from_lhp(lhp_ctx_t *lhp); + +void +lws_lhp_image_dimensions_cb(lws_sorted_usec_list_t *sul); +