From e3dca87f23e8f783e1008b54829b39f9d7b083df Mon Sep 17 00:00:00 2001 From: Andy Green Date: Tue, 4 Jan 2022 06:00:55 +0000 Subject: [PATCH] lws_display: add display list / DLO support This adds optional display list support to lws_display, using DLOs (Display List Objects). DLOs for rectangle / rounded rectangle (with circle as the degenerate case), PNGs, JPEG and compressed, antialiased bitmapped fonts and text primitives are provided. Logical DLOs are instantiated on heap and listed into an lws_display_list owner, DLOs handle attributes like position, bounding box, colour + opacity, and local error diffusion backing buffer. When the display list is complete, it can be rasterized a line at a time, with scoped error diffusion resolved, such that no allocation for the framebuffer is required at any point. DLOs are freed as the rasterization moves beyond their bounding box. Adds a platform registry binding names and other metadata to lws_display fonts / PNGs / JPEGs. Provides registration, destruction and best match selection apis. --- CMakeLists.txt | 7 +- LICENSE | 103 +- READMEs/README.display-list.md | 148 +++ cmake/lws_config.h.in | 1 + contrib/mcufont/LICENSE | 31 + contrib/mcufont/README.md | 102 ++ contrib/mcufont/encoder/.gitignore | 7 + contrib/mcufont/encoder/CMakeLists.txt | 35 + contrib/mcufont/encoder/bdf_import.cc | 156 +++ contrib/mcufont/encoder/bdf_import.hh | 80 ++ contrib/mcufont/encoder/ccfixes.hh | 152 +++ contrib/mcufont/encoder/datafile.cc | 239 ++++ contrib/mcufont/encoder/datafile.hh | 174 +++ contrib/mcufont/encoder/encode_rlefont.cc | 735 ++++++++++++ contrib/mcufont/encoder/encode_rlefont.hh | 126 ++ contrib/mcufont/encoder/export_bwfont.cc | 250 ++++ contrib/mcufont/encoder/export_bwfont.hh | 16 + contrib/mcufont/encoder/export_rlefont.cc | 336 ++++++ contrib/mcufont/encoder/export_rlefont.hh | 15 + contrib/mcufont/encoder/exporttools.cc | 184 +++ contrib/mcufont/encoder/exporttools.hh | 52 + contrib/mcufont/encoder/freetype_import.cc | 177 +++ contrib/mcufont/encoder/freetype_import.hh | 10 + contrib/mcufont/encoder/gb2312_in_ucs2.h | 771 ++++++++++++ contrib/mcufont/encoder/importtools.cc | 143 +++ contrib/mcufont/encoder/importtools.hh | 20 + contrib/mcufont/encoder/main.cc | 487 ++++++++ contrib/mcufont/encoder/optimize_rlefont.cc | 417 +++++++ contrib/mcufont/encoder/optimize_rlefont.hh | 15 + .../mcufont/fonts/FiraSansCondensed-Bold.ttf | Bin 0 -> 472780 bytes .../fonts/FiraSansCondensed-Bold10.mcufont.h | 346 ++++++ .../fonts/FiraSansCondensed-Bold12.mcufont.h | 409 +++++++ .../fonts/FiraSansCondensed-Bold14.mcufont.h | 464 ++++++++ .../fonts/FiraSansCondensed-Bold16.mcufont.h | 521 ++++++++ .../fonts/FiraSansCondensed-Bold20.mcufont.h | 637 ++++++++++ .../fonts/FiraSansCondensed-Bold24.mcufont.h | 755 ++++++++++++ .../fonts/FiraSansCondensed-Bold32.mcufont.h | 1049 +++++++++++++++++ .../fonts/FiraSansCondensed-Regular.ttf | Bin 0 -> 443152 bytes .../FiraSansCondensed-Regular10.mcufont.h | 318 +++++ .../FiraSansCondensed-Regular12.mcufont.h | 364 ++++++ .../FiraSansCondensed-Regular14.mcufont.h | 417 +++++++ .../FiraSansCondensed-Regular16.mcufont.h | 474 ++++++++ .../FiraSansCondensed-Regular20.mcufont.h | 613 ++++++++++ .../FiraSansCondensed-Regular24.mcufont.h | 714 +++++++++++ .../FiraSansCondensed-Regular32.mcufont.h | 949 +++++++++++++++ contrib/mcufont/fonts/OFL.txt | 93 ++ contrib/mcufont/fonts/import.sh | 14 + include/libwebsockets.h | 1 + include/libwebsockets/lws-display.h | 28 +- include/libwebsockets/lws-dlo.h | 443 +++++++ lib/core/private-lib-core.h | 8 + lib/drivers/CMakeLists.txt | 6 +- lib/drivers/display/lws-display.c | 130 +- lib/misc/CMakeLists.txt | 27 +- lib/misc/dlo/dlo-font-mcufont.c | 528 +++++++++ lib/misc/dlo/dlo-jpeg.c | 195 +++ lib/misc/dlo/dlo-png.c | 184 +++ lib/misc/dlo/dlo-rect.c | 247 ++++ lib/misc/dlo/dlo-ss.c | 289 +++++ lib/misc/dlo/dlo-text.c | 413 +++++++ lib/misc/dlo/dlo.c | 365 ++++++ .../dlo/private-lib-drivers-display-dlo.h | 57 + 62 files changed, 15992 insertions(+), 55 deletions(-) create mode 100644 READMEs/README.display-list.md create mode 100644 contrib/mcufont/LICENSE create mode 100644 contrib/mcufont/README.md create mode 100644 contrib/mcufont/encoder/.gitignore create mode 100644 contrib/mcufont/encoder/CMakeLists.txt create mode 100644 contrib/mcufont/encoder/bdf_import.cc create mode 100644 contrib/mcufont/encoder/bdf_import.hh create mode 100644 contrib/mcufont/encoder/ccfixes.hh create mode 100644 contrib/mcufont/encoder/datafile.cc create mode 100644 contrib/mcufont/encoder/datafile.hh create mode 100644 contrib/mcufont/encoder/encode_rlefont.cc create mode 100644 contrib/mcufont/encoder/encode_rlefont.hh create mode 100644 contrib/mcufont/encoder/export_bwfont.cc create mode 100644 contrib/mcufont/encoder/export_bwfont.hh create mode 100644 contrib/mcufont/encoder/export_rlefont.cc create mode 100644 contrib/mcufont/encoder/export_rlefont.hh create mode 100644 contrib/mcufont/encoder/exporttools.cc create mode 100644 contrib/mcufont/encoder/exporttools.hh create mode 100644 contrib/mcufont/encoder/freetype_import.cc create mode 100644 contrib/mcufont/encoder/freetype_import.hh create mode 100644 contrib/mcufont/encoder/gb2312_in_ucs2.h create mode 100644 contrib/mcufont/encoder/importtools.cc create mode 100644 contrib/mcufont/encoder/importtools.hh create mode 100644 contrib/mcufont/encoder/main.cc create mode 100644 contrib/mcufont/encoder/optimize_rlefont.cc create mode 100644 contrib/mcufont/encoder/optimize_rlefont.hh create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold.ttf create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold10.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold12.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold14.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold16.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold20.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold24.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Bold32.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular.ttf create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular10.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular12.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular14.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular16.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular20.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular24.mcufont.h create mode 100644 contrib/mcufont/fonts/FiraSansCondensed-Regular32.mcufont.h create mode 100644 contrib/mcufont/fonts/OFL.txt create mode 100755 contrib/mcufont/fonts/import.sh create mode 100644 include/libwebsockets/lws-dlo.h create mode 100644 lib/misc/dlo/dlo-font-mcufont.c create mode 100644 lib/misc/dlo/dlo-jpeg.c create mode 100644 lib/misc/dlo/dlo-png.c create mode 100644 lib/misc/dlo/dlo-rect.c create mode 100644 lib/misc/dlo/dlo-ss.c create mode 100644 lib/misc/dlo/dlo-text.c create mode 100644 lib/misc/dlo/dlo.c create mode 100644 lib/misc/dlo/private-lib-drivers-display-dlo.h 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 0000000000000000000000000000000000000000..1986a25b592cce3c5e470596819fb9193088f14a GIT binary patch literal 472780 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«tUYFgb+l|ni^xYgjmw>p5hbI0B_lu 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∈=v}c^DilRYhp|!16#c)a6w7R|HJSIM@fc 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⋙XXEWZPSP>y%R=qik*O*Dv}avqYNgS2NhD1$MSJSM`^E{47d@yh-BnVprhTy zVKBQe9F7?24si67G;n!9C@tQ!uwZ9T#_CJjf=f4SSQ={$)Q#_6azX##1>^G5flzB< z!PU3la(%I{Wy$2-=b!hPNr1*d;WxR4UJU+tjMKjuzYA2($E`)uiHvd5%EbIv*`M(o zZOP8JR85pt$_z?XnQR1g$+FRgU05LzjAPZDO&KMb8ReaL2>&NBp=`og?J`V+BQaM9 zGO(!1V0L?iULR|r9g@o5qKm_Yn`aNKudeE8Xbct>P! z@q*eMm($~3m;Jw@SpxE3i?9Gf#6O$0*$JxjDrVVo+VlRLqZBm(9Y%wVc zb~Z-xLApx8&Zp%Ghr?kv;Oa1ENKrygCGK>_S@g-B*I&2g(a-KU|AH;7B{{+_OkT$x zXO|_v!Fo9=-w8yu^TH6Lxh@Vg+xtI<1Zz8zyE&Og1;JB&S!f zaWhy55o|QXIO6~d8YZ}*FF0wd1iF>#S88{>rhN^2IWP(F9_oR z*N^qe)k6H>4=-}#hsHx<9M|(z<$3-)@xoF(CrcgpUFN)z{+uKENW2;ubT?)OFQn@= zm4$6gk6W18tnVN&v0=WSiHVzc z(|&rcxn@Ay6I1(G?d%=ivsrKg9i>@cJ7kD zu~i#K$3{m-0!pSN8K($RTo6U!`sQXXuWgcz>zN!}vqnMgfSo;Hd-KOXelPh2 zsFTM>-Wio=#H-muTndqIjHJ*_I!G8N=Y<%5joq6uPEtsWzsimZ5Fv#K#4_ndH5W&( zSn&@FWDi*}*|1`2z%2`>;l+_}`yis7()Qb7+@CSQfo$3G_Wl|a6 zy4@9u+Ms0zP9e-f_CN|LtZ<(Evfjkja2$1JN~~=fzEapCF(r2Y3VS?-m3O(jg2rQT zXFRTXKw7xFg26k)Js_}{H4g}>xeqD&Qse=_QaFHPY&~DnhJ%0T6iaTNdu7oj@yHtn z@_@{P0v-@6?y~)nOei!D2r1zYDdYjsA9+mkfGpu2kjzIk56Dvf2zfvR4&G#!rf~3( zLLLw?{t{6}3TMPm#Q1S`rWhv#@XH{^^^FUV$T=a#Uxsfhy$(4i#P|tzO~yDmCos;P z6ZdlG1QX7Q6a-`&i6`G+pVVl!m_tx3oqyBwR7A6ItsT6o+1ri^>6T<)(myDZ;VL)F2!ywIN zH)j~oSHj^ySm-MxuvN)>XMggOzmsEk^qrC8IPCz|yc=uErYyQp zkOEKPl;40_;f07^s*Z!l$Rh>?8c-I4ifl3)P1|!UvcVwZfJt6ivt^Rkpa`;sU6A-b zh-;VE1&NJioH#-!{>p_z1xHBE274UpQQRCdLt2{^cf3W3w}jY3Kew0Xo%vpFEW5$h zl322_wQXJE=DfC%(a~W`w>;CC)kJ()E<1jF_QiKnbV@D=ntd0}kicL0}z#T5;D z8z~y_BH~a30QWlp*C(~8O*ZiSd}d%iW`qY2zY0+cm!L4y>993m!$G^#6{I7Ma3Hyn z8v|?suUn%?SX}Ho(ai(f&Odt(`z8Voe|vgzXt1}lwm-16w&uWwExUdH?s1|c&ol7((2c>&|Pe6X)(ORcYb?|ZmqZ;d2> zq8-rZxXWS--|=y_k#;=ymAM-J8mH8zHe<)kilc$8kKYuD!O4>1BRC~)SAuuoSJ09p z9J1T#Y@DR&*(snR4krOH9{t|;mh^Phh4V{X&45MT1vrijjYeSH_sf4D!3N3iYQn|m zq=AdCNF;onKsb<1Mv)>E1^wP@7K^y|#gZ>bv>`}CH&n<#X-R})@O%nYr#a3JpHbNu z?2awnwrW*(<8JE@H|@RrhOx_F+D4*H#f4XY?2ao-|IcXhX!m1}pZA$%KokdyYZauX zkXG>n{F}U;HSDiA4?Bn>r21WX+0gRY7`bk_7Q;zlyEGAVcp}^i(QHw2$Kp=Ggp=W) z&KM^dEyiDAe-Y!!UvaGK<8Ntxab4PzINbl0VA%>KGUZ|1R{d-t*; z2W(6R7pKJT0L2wZLAA_dvq~^4;R?d2@XtewhFi8E5>;T+I9s%!p~)O0e>y)-v)LZH zuA`%^t2x>qs;}PI);-lYIpUjQ9S+CfK+i;3Sz}dIV!CT;z1Na_LnHDbyfQ2es{^nv zvVblFXdAwcF~DOsWtq2In8^s{Vgly1D+Zhy3>>K4Y=UkXXM@3fD|uf-?i6u1&hu&j zZ6sJ?arm5u)J^*j-!OjZSjXCmc%Un`WXI~2Jx%-e?YI0;J$hC56OWv8_wq=zxuocZ zTW-I$Y;Aw<(6xZpI(H}gJfJO;8r0g7VsL2$Rhc{nWq24rz3hGHS6BUAR#c$Dt2Buv^@FAtR06MZh+KnQ4@*CV7PY8+49rdC$B8c zS~m8=_;`^znYfUR^|U3r{blhrcp=!JY{9j&Nij7Hwm@uYyFu7y@NqC6LdCCXyCGl? z;V<~)@E3dV-KnW}r&xdTX?Z63I~JIo#8ocCnuA!A#Hy-xWn0XO(F$6y8Kvzx%!cE! z$=k`ZIX$lVze$kJ6Qaa%?GU3SRSc|8`wQ3y?(w%d5pv6et$1^LJN_~CuH4a`R0s+- z+kHO%_uyF+$mM(EQs^AcYF=e8@jEKU>F$d0SJ;bU9APxVg+6|aT}Q;rowge=ULZB8 z4Y@fo1s^0MelWt6C;Q3_Unk-((5*--z%vC>fxQxbOhg@u$SxFr&2!NLd-4VVpR!yJ zzDt@4M`ec5N=U_40)XSk06{kF<{%;X&%T8}Tcn5@1j^~E?I2{fbIH}gl{Z~-SrGX^ z*j_ub9m!{>UYufPc3<*yYzhYkBA9zyiD9*3=~@w43xUg!A9p+XTEKqI=B?yvfr6`f z&eIXLvQtf^S%eLmrhbsc5OK4)=px#k;VkICckUu~437k*i!oJ^ZURpxJHvxNy~Sl0ABXIM#|9CWS)7JNA>kp$Ut`c-G5#jT z3pfFa@mE|Q;Z0^r<#r!Co(lXWRfQy|>D_JwGJmg*% zXEWc9a^euleoFsNMpHIcgpve%iMS&UaG||qe>693CB@@(xG4jvs<%kKAIpx-y~Fx| z5s5R<4|4M@EugV*?{Bocs;& zPE=E2_daBaBuz^bMGTbPf_r2piD8dF6B}+Vtf~ZEVk6MexUGZi^Nl9Gnl#wIYNyi1ID-AMYGS~azTHU2b(g&&QvrsRKM6%q_CtgnEtR;lG# zaD{^+jMy;|g~s0Du#^lIgT-vZJOy@vU>^Ym(FEtCQ|#f_{<-(<*99+0em8joJHS-j zCcZZ31-Ei6zsi2bZ`o=njP%Z+B*x!jlprQxse-PM4>$6s1Xs4feQd}z!-kjjgb5mw z^dU8Kf}SMdB}<0W96zF65V>IF@K1=03tTRkghVw``X_a*T-^W0^w3*OuN_bGPZwdUGr!ea9Vk0oyq*ujYcD-1Dg zNK>4sFtM?F*iQNtF-k@|f;Ar8@VGf(fAnA0B$)Z^zc14nHR5oDypIu5!KlB;k?N&o zIZNZ?VAQyfcpY8KuV8)-X*-Z@CI-U~W)R0v`n@EF5R9j^h!%P)ce~qRgnffvkDIx2 z<+5dLXpH%jzaPU{f#0z|Vp%uBE6_u;;pDe7gV`a}P}nvG*}OB0!M-J-x|3)Xj(-SA zvJtt)P+C&t#p7-`4_pCwfMDp-dwGZj=ml4xfTGzQOX!#9kAQ^r_H|U53Z`1()}F+a z+3xhHfXl=>n(CUBUnXx?vfJ|6SN=N1Jf22DfdvfFjG^&Q;xAU+N)~i?TSeQA%y$& zARV0L0r^UPK+ppj@v>Ygs)llNvTbIQ(SXzm@MYpOG)JQik3FCGGCv>qSz5qc;Ar_S z9Z*wXr95?0;343`7;0^0Y%2NEbn79UKNzNb3zpB9%GF4&8TXo0IWT60Nr#1e(QdiJ z?s9QX5(p`XY=sn$8KFXMX5O;Soy)E|;|7-PTAR4&@=GpZEzd8T{kv>A;|IwfKn+$H zAt=U=v#;@;kHZi=0nkFyrK%<9%~B8}BCjLmOBH3AjS3MB zW^U#&6E;nn46GOJ8hi8^JfMOfai2k0zSBL5%bbq|LlQzsAtzicWH3TmjSf<_I34x_TWVA(6XuWXt=eQO;toAtwnUPm#k0JHa6^7B`dRYE$!8H zW(bbixkP7eo$MA@UbgZhE>(T-x6$E>n-5MzK)da(e6sL?d5;_1B<{pDu*YTVg@4Un zb-~{ZmeumIt1jbgU?y~NC%b@1b?zd?k41yhJ%nxPCb&{K3FE-6{1o^&7{N0c;}l8f z7V8{mAJNw7o;Uwk z+Jik0&X?KKoGMn&)$sX6QmdNqN&D#39>uP5IB+pDD?P=~w4fO@2{J7u~ zR#M{GpTw*x@1{NQ`x-a=d@BH#?{YoyF6d916WE^IG$wGu^hc}PTk z7GO!(tb_7DX9aBo5V#OCkZuFdMEWEW*a3pZA2e(+mO{ED0qL5zqdO(+iy>CiNMATd zNBZK+q>&ESV92Q>J*1<0-c|+Dr#P}xs81n%mi>ie`(7RSf1jM<_qbLm;PQd)4dese zW0DUFEGJHY%^VjF>7pm{ZNR+FB7N8`*K!P-Na5jLF_^0oRBoL|da-+jR2@DON|64u zdb)>6<-sxz38rbtNh%Lq5k{vH^)u(d@Un~9lhzurI*~)d%@(r z_pVsAdb#}c(U~tjdGz6P?_M#Md^!2bHMf8CI_v^*nfg6dhfmRnf7&`)NbjZp|Btv$&J>{ zeuVBS-B~C!1oQ^n0tMlb2u07F01p-nz$+|(cfq(AgvG_hk>YS|q=MWe44SgzeW7Gu zc(&m2U!NLMrGHu7?&Oc(AKY$$D{xsO9aQrcU{j>82hvETY-52`o^8xS(Ay1AU`vsF zjL4vYJmXp%Aw8EIL9Sr1pdeTitS*mgXTdX)-*=Zh;Gp>?7CV=sK%l57;P<`H`P>*N zEDQz<3j_bZ9+dRHTVS6ncs9b$TI8fc^^>C?wbU%FSI>YxDOKj$5SoxH z5G)KMI_p6M#RxlzWQ5_cBq6I8P8Z6k){-2_nXhL#*3?K+O><2m-Vh2D7hzqe2camW za`8AtBV7@*JEWD2eSkfNy?KsUO-(!!><*T?ovdP!?cQxN*LfStLzSl5NrS`Va3;U< z{!~hPKMbXx)9`^XTcNyD8tvw z)r1!LE&1y(D8kZS)#?R9gyRDKr}3Evsy~5813DG_8mQ7YdY7E_Ealbn>irp<{)DC!r^v!A^bwcY;y*pCE1{rcqC ztW*BK%L=CM*Vt;Ew{Z4youQ_7OkQm4n0v8b;9hL4a49u|yx0OKZ?NanQX394F&;y` z*7MQ^tndf+E$I-|ZLygRRK$X!szX%7Vh}0}LVZ+H>4J|4$)I4_3RpHQUbr5RCXeKJ z1mbyqIkHW({BpNDE6ZK#E-Cb8xw4!QyNfuR(`$}-;gQPVUzz&fJ4Xwiefckck>_iH z2DZC?@*91JPoWDksTH#2N6-Z;q*}EKbk6hlVcQv$!#Ha0;01G@Ci5H)aZkt@MVb;h z$8;5xdkiQJA15cg$RE)aLXv&4xO`t^>-vu2T;DlU(-Hr=K$)jDTv0t$QyHuUk6kaX zKYH2cZ*6Nkc`QLibjClprhRW|lU5EjRBJhU4;1dBGdIupdIZsN(SR*b z9x2qj3hCS@9LO9u>X~Ix6o1IDhY!QRhl3eJ0T!dNS6nG&8V1gG%6<%;JdvE3%C^*e z6G=tnnn#2FqJmt6U-3o-p-49cQxlGPd1Z_4^Rd5tWbvIUQ+<8!U47c^!r6*spXYF5 zJZwst3@*w`63znJQM#T&*QRi4V3{Gko`PKXdd^F8BA={zVxny5s{TVub}gw3wU$qu z`ERjae{K2tR{812XU@BO`I2T|(Y3dthOn?T800v=5;$*waYdQ$eQJ*fvMb;(_92R4 zH3M;qQ12{RBATG<82CYl%IggWsp6?JY~&fq-0WJI08fNZiSHhf1)pI58a{GqX-Vl= zsCO7t;w$x!g`YoT{6??mi};6k)hhXd&t3YZCryW3mqtH-F=)kjk?Zox>u!IxLv|V0 zw9me7y#AA%2NC#WGBA<&rp!!QjcMLJLgj0 zk&Xy1wO!*1FX=}Aw#!G0v2KmUpIiLVLU^<93#A?Z)T|C4|#pQp`PV1;X!k^WOl zpGF#smhKK|VK(bI7@8L|F#lolY>`yKBb(?_kVA8P#)BLGKYWYYpua$}SaeR2f(=n_ zk%~SpWo7A*ts|dDpe*RHJM8vofTxHA0%UjVb)cxy^H76% zgFWiOv5EjYY)zh+u-0-cu+#h&!w8VMvHl$|QY?5Si+8l5TSdpd%rc5dGM4)i# z+T%P;p6c@0{tsV$sBh}i%a$%#ruN7)d-fdIKL=O!C;C>5_a|Qfq48I8EBi&Gv7bHKmJ0Z%1KJTiX=nTZnGUNX>^jfe^iIY0peLNV-2K?m-m zgT);yZj>L{$+3b|{`p`b-z1I1v#z-EyrHS7{_$l?m-ec1``&%$o{bdML&=W}u39pX z`~|-eACsqXBb-u+#LLLQRiG|{|H@oEX%uh{&E#F@f|ES)@D;a)i?6x;_G^Zu;k1B?-D2G~S(C21|YV7{45;`UIM z6=$Mp9~^Et=822F$VBynEr@%W=R-lHFBA_jdQ}?_b?&T1f%?~bJ|6vc31tZ1>yY1JJ>VrRI4pWOU?z^ zQ_UZ{sKy@RWzxTzQ? z|CShkm3>o;BSb+U>*H^+JsI=K$0O#y$*vXSa9U-~KSlv*!6C3dDa@G973N1W6=om@ zI*07Ro2V8PDsDa$UN&Yir;{I`(1_Y+MAkWa9LPPPn$H3c9zu$e-5#()71I#J!>$XF z^e`c5baVllSY((D%)=DmSp~;A?ZgMl?^jhf0bAmi*_M-J`}1&xs-19$(3PqmZRKVw`OLn{QD z?BO~s-77>>a6FW7*-Z@qif|_}1R+QDoCwFHe_Z$FP|z9n8xcBz+|u{Oqa_s3=fRUl zQ@dGis@@$cM3aMful)wG6ZxIZ`z>qDLxZy~VFMmb-76<6qQDFD0g(zA&gsHg&4Gic zB}U6pSx|FQ;jG77D&tn*2E%biP?7bZ@j{k3v%D_YA8YI?Xis!4t!&;taM{|1$dbB_ z;kJp*tK%Em<)_Qb6Qw0BHKkP{ho^CAN5@oReIgL*?}&F61=o+nSJr}%IiUOkA!V0~ zI^p;gpYL4LlhP;1v*-*$6DzV4WCXTIb?KLy}e$#R!J2X@7%$mMAFo zsbMh-rBJ7thDHyOsxS(l%E@R8!~LS!j=-@dSz0pk{&jq3X20@tVbAS6V_s2|W#5W< z`0tv3KxZGYHe^;ytu?Qhe;5l+D}^?4z6-Ry!oI|rj|Zs;gf@NrEjA>^iRgHoRm?xm zR%zqi^X4Dpr^PcJBW`PxwRegc3l<|46~yJ2%A6t8YV(|ZuUqq+q|P{& z5Q$e5yMhsQ<3*qT_Sx&z8dT#ZI@V6zH8IfIHnn?`{B&RIH;V7uw7;M?w^tqPGxmMg zuXZPG?5|UMaX#g66?lO^*&yx)^iSZK8ZiabQW-!iD9lYOeSk{zUJ}k{o(G#?&)M#q zdPts`nEkZ8Z32XAo14QT4^5ZJ0YWYolYoXwQT~lzL>s?|Gg6_{ zp|%#{jp$P#n|UNVg>nFZt4Apn#wjQ+nQ*v-2gJY?SYlTCMIwk$MQCSz)jjcsK!LBw zQxvVT#sHY@zV4b(O;bTbzRTryZ^Py%X15TC$iE>Z1|Wsn2o=4acZ^SY3<*F)q+gr&amwh{z)vyB-YEJw+7p0I%)_{QYIO`RVBHbr* z2ghg}xU=FPl+qJZq2;c{+xY?gHr&ma6euvXB8j?SC;$$<8Azzv^IoJ zvdlbi481&6^`liHZv@n^GUsV+*{)2p${vH4E7K^r;L^kAJlI-MGP!hUcz9%Dl0CY6 z&$;_#N33=G;}^Pi<-M3HqDX$Je*7-VktxYl3x+#idQ<<@_4faBSKs_YnjI-xO&c!ju!|rNPKs zrjY7DZnG3r37zsiDW!oEy{;{M5#+ua@1aa5^tQrv_o)RU(hNN4-WEsD8RYdnBDhUi zNAX5V|B(;w*?VB>@ZpWmZMyJ+Y4*pY|JGaC??DB8J(A}PL2@q7AHly-hJg1B<2^1Y zfIzw#S-4qvj|FMCbfs~dEfyW+MFoPnI78gR2PtZ=C-x$W4p76#L6L`B36i$9srNRv ze*C?|huLiMha99huRZ8a{_NIUQ(z$ut%3C#dyW&Q02i8pHvTI6uZ(esK5hIJ_REZM z=;_+{o9r_g=#-z z_v<{G%e2O1a6)N~$;M$b(2?q}9Mdl1!lQXv6X#+aAy^Ie6YPE*nIMg`;jAr^ke}&* zHjDfYl&Z3kQ;|uS$ON7J77&U%6?Q#)zfLk97ecM_(yZiFnY7bvDD?11D~N?4IvYf! zz)x7I#?Tdm-d*eyq198pzMNi90oBuhz&?sdDwF5KAwsCno)(yH07GbqN}JT|Ohkyl zDN<#bmZnbmF}r!HMmlC%h|CQhGhHx^!lk(|n$d5k7WYh4^)8M;-Mvq|SYCk498s0Sw~gBP&T9*5%H{s@)7f(Nsi&!WIQkK6Uyg9jGGbe{NzjRv4p`B4gGmaXIiF7=( zp&kypsv@|2u(O51ObS1N9cu9gUIB_OQ;|@xtb`o$h+!gc`*bnPMYnf+(ctA}3-)<( z(DKiV?K8#B(oFG>T3M!GEO1f~W8qGU=N8nah#83LX{_fBEz@!w@g-tmerfGdxOE_$ zwW~(e8|2{9!*VGTn#Yz3Ip1Pi7tW&CrclcLL8m)Zp=V<1l04mL57wttxzvITN>SKX{~ZY^3p~a}Qs9@!^9v#Ye_!Za#nOZA(+f^GpiKf1)(+ z)Hs3_8uDLfzeNCU8Y)5K+nh&pzt>3 zUHh;sutyycQb~ono}&3nMT1Es70%aDTj##v4g03r;{8kV9r^iAe^h?Dt0VcdGp`ytu#UZx%IaZAy;i#h;4zsQFRZLO^-v%Bc&G;v!!f`a}Yd)Gl4c>PX5Kk z7oK(C&_(N~&)t6RR*t{1*(dPtf0sAY-*_W`16RUoun^)0WPzl{Nvjd#ugDb{ z;H(Qb7>m65g*j#J+Ty+WOMuGh^)lhHJ?OJqn;fo7leq$)&__fF=xHd)h0*~vI|r0m zfT94z5j5KL=(H)rSwMbwph*PCsFA7z`(m5W2s3>nd~gzK6+E;BRdBCfgi~;4c*Cq z+c?(N-je)v8BUGjRxg9@=JjGDFJ+4APT7mC;;Y*}a?|t^_inr7(rI>H@(4>Le?Vna z$$vqw5v#t5RkNg!>NmsRaH`v%C1p7rR5-*GcnSFZfAhN=zq{?Dw}GFoOa7f@u`edS z$ku{J3CcG)?Ir~6va2{PigBV{G5(6y@L7x#?TYc2H11}A6-;pHiOkdB;2Ib;k>~^ul&CknA>`J?3D zQkDH63KZ-8PZE5)0lwe* ziJop0Qk1w`lHaC%BZ#tN_O*|qtf19u?H?utWT4khfFR~+w(`_j>I(r#(1-=fuNf`* zxU-Sizqo7I1V4M6yxqaeqtFcpeS8Svq%)yE4m*0onO9!N+JN>WD=$IF6+L0z7<_fv z$e#yaA=EF&v3*xYw`s#KI7%Ak{>q+~A^D|VwOdB~5H)D2&MZI)iRR4CEPLrr==p_M z!6y}+t}}}pSb~3-vSgNoYf75^UE^wZynMCgu@xJC)3vilF7}r-dEC=`&e`a`y+7H+ z+-F?c0|Wsqd6|4dib>b2K9C;oLlVkDHxguTFc*%jkoO@OpDBZQDaSRU{IKl+$h?Wr zwuQjt4M_knshjYZLfb?aEc|-v&L#6EidwXo6h$2xic2z^m(1&r$$OWiHrXipW0uwX zQAyKM;cuC@-OlY@4dKB~`9!!CB{f&oyPWg4?OfYGs-4icac8%j9@%VS}U%Ar!dbzE-+A^~goGn z%<3&K6#5OK78e^IRiz@8vFNmtlP3}_pYs5_5i7L&fnw* z<)z$!9O5k`>@aMAc+=WXZyncj1M*Rg>~ZCJ^SwCRTs=1+CWM?2ab88h6>_ubbMl+l zUb}r~yzz?PHpZJfYkv4cId|pKrg6t_SWa!cq2?P4KtPL`+{}jFJINV@w^LD%=I74K z%k$>J5=1r*4;t}c2C01UIO=Lm93>=P4>s=He(l;0+d0#h*8+F#H7q!uShiBm{g40n z)n95G8}V*72R)tLh3%iLm2r9(7Dk3vhEznZmEHB(^`DihIHj{G)fprTgm|#f4&T09>~e{9pLUK_{txTq^dbKXTBQQP@VmLXBYyeufPy z%ZoisYCk@55cC9Mj!3x)O=5H$L4@eZZTd$JV9A&eHIB1yIlM&`)wY7cn$=tC*0fF5 zo0i^_@VM&(&E2e}X=_>bfGtuMsk-IEs}2tgwk9tak40IwKd^20KC%+|sVXJV6A-3_ z9`Yr2F4rH#xGOdO2)i|7oHTHnPoGw~b#5d7w91#H{n`gCHfmXn`$ZOGIaHCaEBaC) zRHb7nyb7eX$db2XNt1Q+(nS{pB`QZVV7QH7upDLQEDi%bvM=M2kMehHX+P~d(B)Ob z%MANW2C#*x@rN_Uk1OY=UhoRLb8aR7tcoAsClQ~VS*hV=MJ8VKr9u|IR2naH@6d%i zX-VMaCyOrlHv6&iz(N>+mlH@=m=D8N9R_;Go{UHCni~i1x3ub|UE>Sr_eLJF2VQ=Uvw9pB-64VrADH+(y#gPYpxpcvNuncxhWZDz z%mPkFxY7FfeEJzmz2X5jIQJ9n6+5+U|3urx&dgV&ss2GNIwE#Al6nPE6lv3ZT>e{X z{7Fv2Tx$O>G8u4bjmhjyGnsU%Li$T83x4KIX0eACFd0~J|I17UytoFG{Hn%_pApU? zJ6gjja#^VZtz2MwWPEUD-VZRok==3fWZiLuPjsP2BjUy~*UCjJh6N76f{Zy7F%YTC zgh%zXj{{Rqj|Un77&6MH+>*d`(29Q=(>>kUOt!4g>WUJ36tuQ01P-k z%0sH{ve{IDW&~!q7iAPjDMN=XeM0-A#(@!@#v*Fi)lP(B0xFQR#(?Xe}AH`wzlrF z)966Txv2j9b$feVT}KBVX=|IkcX6%A06abg`dKLj5XY>>r{vbCD@%RI3{*lM2fToF zwdE#*$%rz3$z&Kq(y=mPwZJ!xu1>Ivp{Vk{>*S){%d?85Y2XVtDHe-W$EsaLp&(qM z@DAuK#SBb{a0X>MapjJGo51asW9E251{H^98_UbP<;E4&b!TdN-%`2VlCZ7po;<_wQDbpe*wAU|4qfyQR#|XqZSwmo z4*#Us^_~3nDWZ~6MD-ZEn~qtk23vYo(`d)kVPwM?SqVDgBg=v!7f3~+Pt~BkmQ0E2 zMy~FWN(+SW7_T%@T#S$bGE)7e9Ss~ z$Sye94t`nMxh6~ZB15}ncM8o`p}QdeC%~>ith7Vgpsp*!9SD~K?k42-H0EY0j66E{ zkO-hh%TMc0_@>YfPeO-BqtUd9@@w~wXWO8jio|d5g8KUUj{5eN=DON&2&5c_&7T8G zmQYDSmY7x@Nm-yg4=6)f2lJy1#+q=xaRXY3B{bC?FeZO!8fXo+mX(iBb*%RVmp2Ws zJ_kyCQ`5M6?O5BOBe8k?_O*NWWc@aIc}G!h`<0b3CKs(==_zdLkJl$^*N&`MU(wzO zY*baQzV1@rJu`1r*EhDB_t!OuQ3jrvZdQ@uoI_p2(8krkMu7|&OoJj!rxgjBr}zJhMB$#)V!IFC{d_5pBK~@T2wMC= zqO{mam~dlAmnCOzU0vQ+V47TCI9NH^+!#s}IGg>l@1|=m|5zm0F27_=z7(!Vmi_4L zsmf^bUu97sfo~QcBnYyLaP($;7vdneCjSUrT&O_Hp_LOl_zbRf?&s)RK3C2D4!4tR zI+B656Fl?b1=Wo&IZ-DqB^2~3CZhuMnb@enT$IaM@K|`Bs16y1wn3B1REMhH84ZUh z1ryzs=gk%q!EA`DU?#b?KIpoXddt(tL>crVucz`MQR0f63*1|jxQ5VcNh@*XnJZkd zgQ`W!wHxUxiyX-0XlHwIc||02>Vui;T~^ZV3P*3AcRB#F6zP@4asWZWJn0TCxtRO9 z5wtvjON*2M6LDIJ+&f#xx%+!FTzBI$g}_HxpK3sP<)U-dV8%4iKlB1rLx}16ftgp{Oex4RGq zMD7?|mGI?)$)NYCk&1grdxh70e&dwl;(Ro@DvlMS7&70NPo*{pb44w@feMdufyoGK zHzWQnV&5A3Vc$Nobjgva4M&zPz3I%I7hJe=_j!kQ`pU|R3Il;c`RSFPIe6giRru%G zcds70`PSQRy6LuCZ+<0ESm5`gF9B|cA9v!z@+YOBVSsK2{WEz$YnOHa*8@l72DkVl zu1A3smj0kR0)DrWWhQQs#YU0Cp=jKqoK(+LhOOCb+C*LCG^)4KcL+2|p;3K!k@;e3 zn(hNQ=MTQN8bv??E5nbq9ZJojKoISF3lT~v3>St__JvFmw8lrfCL3h7o?ArJ4@Y{U z#f|eniS}>QnNe@=`fIN}HQjGkd#&T@M;B7PV8F*wEm$VsyoG{L}Q695HU0p--&B7->L~H|?bgP4#>}2$EPactttd zI#hvv^^9*5;;mZAg^8Ku19%YsCp$*-E8={3Xk)htRvh>~%|g!pX{Mp%!WE(~r$OSv z)DgOQMwYn7axzLR1hUL-HaPFIX)C9Iq{?}iYai~-_-NYtoEr`SX&G2d80s|?ep(@a zk3iwW93|vL_%d>%ec(z}lp%)54!X=MazzOcLj}=rtnymuRMjLdh^C8@TB>uHKtPfL zRe{P_1S^$ADtX;xSlg$rhm)=*${8uC8#EwX$}n4Dv>s?*I}{6+GzIG7Vv7~tx{{9G zXpvfPuJX8j5pO~9AKL5Hk?axAc;Lbn=}qp5547Ls_j?Me+AS$!ArFq&=>u$9JN&oh zdgvBm={&W7EDHK$n;#)90}9c_u8lZ(68e5TAWAjB3$$<>NL+I)^Gcgi%Bh6IIsI+7 zc@spoS6B++ONJ5QO&2>)N3Z5z2Q73Z)%(%Sqa{*Ymw7RoHuXeG20OIK)rT7L?U@%O zXJtRN+gG7G(Mfu#$o2g%s`##iSMn^ls9IM?QPl?5I2#(kJ+1Ry(btK4TG2DP``~%I z>6*5Ed85PC+WyripZXTWRs-z2Pr<&U(t3Pd#^uO^4EC2GZjYR~QvT^ZWz3$B z{9RW6_Vwc~f7NTff|2m>;!w^nhsaDcERUI9Oib z-Q*}Brjq9BO>lr_7ul9!pmVm8*ZLu?y`YvSN@$3PyW zN?fJdb8!ir4y1Y^!zK^#X(E?e!*M=`)284T<$>`{q{w&y#}6grM2GV+!EcAW$o+2UW!Z{n>5AOtl3nzrggk=BH^v+Omwr>xO{xJ zWN^i8m#;iL*u(6zOUh#`tAEGN-P`!#yv=@uR(d5c-B98}3_L)VCJb#~5st{^bXa)@ z5*emA3bxaBW@%|@MQM3B7|m>WpmQuQK7&l>1ZGCYH5^efazyd)$u%PfHg|4ls$S8& zyxG=R*V{4N)LD0nC9?~?=yqH(Z(@25a@Dwp?)?|Sv6WO+m6l3URZCTKLtSZQDKv6`S&U4+ zNHz$WYc^!MLbcJlsEQ9pld%<-=uin^bgF(W=*Ycz@|A0K}|&-+Be&EyFC&nmj(9 zEGv&Pb1<}h*WN9g_aE303nr7XaxhB5=_GI(q_6QHT3|pYz4>NZ9F<6PC-@A=-RIeN zLAd;`AfNCAj~BnJ+VkP(@)a4Oqsn7wZ)VihQxPn;AVx>&#AdTDJ{eRh(m8d7L03-~ znNL$iJPWxln9J4EMdtFup0~CdB>*s8!RIDU0|Zx3c~^o^L6CPP@Y)@?igr>@c{g_5 zcSgn;YRuvZFIu^YI&wNa*{o(<${TK2e{cF;-mT95yM8gRRwt}|v!6`gO``5E%l87G zeyK)kl{Tvz3lOP|z_r>OD#=EbvL=W@;_?WW#^}leV~TvNS{gE3iDrvJ@>o;jYimg) z*S6NSG&Kfl0_cXu1#>yHZ8(WC1oM2F^xC;#hASn(KV?oE3+rTwJsxOY)$cDYjR%Tz z3P$QR2DD!Gv{xm6o7yhxiaPBD0guD`%jTNy0n4C!%oD0=(D{;e_6ynh%}sZe$549B z*%K=(ak$Hyje;oIG44CyL}g1}z9`tHQiwL`O!dz&I)@UWMn(9OWK%%_YJPSFD{pW2myEp{%mXUQ@Gi z)j3c>QIrs)L))yZ%F$OdbqAIMh@a*fP3d z&6jBXz z7atxLdD7`hS8DvA{*PY_URzjI1y0*sm1w8~<|2KQF*E1Dv3iMQT^$v{nA5A7RuJL-d?W@U0Qk4DuZ>d{aYHI3& zWlM&KySv{_w(GZ=*{%QCpZsY0Rtqk<5l2iC_qVDG7=(vKk-TWO5%6cj{G{4$^7=(V zkiy{Ore`LbB!hARn+%?EHciZAlEQcO!PZs7JS_zkM&!I&?DgF8BuOW<0WRZ$E@64< zx-HV47H~X+Z^-uefZm=R1S5X8=#eft@>c(&yTtyeQY>tTojHeKXGKgJ2p0-`+X=sMak@j z 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

$VjMouL_I2lVs2#X`p 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

    O`{YnE49J7Ycl3t{v#sR}DtgjOs> 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%0DLC2FSOxMZbZ?gQ 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 Da`;=5 literal 0 HcmV?d00001 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); +