Mirrors/libwebsockets
1
0
Fork 0
mirror of https://github.com/warmcat/libwebsockets.git synced 2025-03-09 00:00:04 +01:00
Code Issues Releases Wiki Activity

lws_display: add display list / DLO support

Browse source 
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.
This commit is contained in:
Andy Green 2022-01-04 06:00:55 +00:00
parent aa696773f0
commit e3dca87f23
62 changed files with 15992 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
CMakeLists.txt
View file

@ -1,7 +1,7 @@
#
# libwebsockets - small server side websockets and web server implementation
#
# Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
# Copyright (C) 2010 - 2022 Andy Green <andy@warmcat.com>
#
# 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(

103
LICENSE
View file

@ -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.
```

148
READMEs/README.display-list.md Normal file
View file

@ -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);
```

1
cmake/lws_config.h.in
View file

@ -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

31
contrib/mcufont/LICENSE Normal file
View file

@ -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.

102
contrib/mcufont/README.md Normal file
View file

@ -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 <libwebsockets/mf_rlefont.h>` 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
```

7
contrib/mcufont/encoder/.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
mcufont
unittests
unittests.cc
cmake-build-debug/
build/
.idea/
.vscode/

35
contrib/mcufont/encoder/CMakeLists.txt Normal file
View file

@ -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)

156
contrib/mcufont/encoder/bdf_import.cc Normal file
View file

@ -0,0 +1,156 @@
#include "bdf_import.hh"
#include "importtools.hh"
#include <sstream>
#include <string>
#include <cctype>
#include <stdexcept>
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<DataFile> LoadBDF(std::istream &file)
{
DataFile::fontinfo_t fontinfo = {};
std::vector<DataFile::glyphentry_t> glyphtable;
std::vector<DataFile::dictentry_t> 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<DataFile> result(new DataFile(
dictionary, glyphtable, fontinfo));
return result;
}
}

80
contrib/mcufont/encoder/bdf_import.hh Normal file
View file

@ -0,0 +1,80 @@
// Function for importing .BDF fonts as data files.
#pragma once
#include "datafile.hh"
namespace mcufont
{
std::unique_ptr<DataFile> LoadBDF(std::istream &file);
}
#ifdef CXXTEST_RUNNING
#include <cxxtest/TestSuite.h>
using namespace mcufont;
class BDFTests: public CxxTest::TestSuite
{
public:
void testLoadBDF()
{
std::istringstream s(testfile);
std::unique_ptr<DataFile> 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

152
contrib/mcufont/encoder/ccfixes.hh Normal file
View file

@ -0,0 +1,152 @@
#ifdef NEED_STRING_FIXES
#include <string>
#include <sstream>
#include <stdexcept>
#include <limits>
#include <cstdlib>
namespace std {
template <typename T> 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<int>::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 <windows.h>
#include <functional>
#include <memory>
#include <chrono>
#include <system_error>
#include <process.h>
#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<class Function, class... Args>
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<Call>,
(LPVOID)call, 0, (unsigned*)&(mThreadId.mId));
}
template <class Call>
static unsigned int __stdcall threadfunc(void* arg)
{
std::unique_ptr<Call> upCall(static_cast<Call*>(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<thread>(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<Rep,Period>& sleep_duration)
{
Sleep(chrono::duration_cast<chrono::milliseconds>(sleep_duration).count());
}
template <class Clock, class Duration>
void sleep_until(const std::chrono::time_point<Clock,Duration>& sleep_time)
{
sleep_for(sleep_time-Clock::now());
}
}
}
#endif
#endif

239
contrib/mcufont/encoder/datafile.cc Normal file
View file

@ -0,0 +1,239 @@
#include "datafile.hh"
#include <sstream>
#include <algorithm>
#include <cctype>
#include <stdexcept>
#include "ccfixes.hh"
#define DATAFILE_FORMAT_VERSION 1
namespace mcufont {
DataFile::DataFile(const std::vector<dictentry_t> &dictionary,
const std::vector<glyphentry_t> &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> DataFile::Load(std::istream &file)
{
fontinfo_t fontinfo = {};
std::vector<dictentry_t> dictionary;
std::vector<glyphentry_t> 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<DataFile>(nullptr);
}
std::unique_ptr<DataFile> 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<size_t, size_t> DataFile::GetCharToGlyphMap() const
{
std::map<size_t, size_t> 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;
}
}

174
contrib/mcufont/encoder/datafile.hh Normal file
View file

@ -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 <cstdint>
#include <vector>
#include <string>
#include <fstream>
#include <memory>
#include <map>
namespace mcufont
{
class DataFile
{
public:
typedef std::vector<uint8_t> 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<int> 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<dictentry_t> &dictionary,
const std::vector<glyphentry_t> &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<DataFile> 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<dictentry_t> &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<glyphentry_t> &GetGlyphTable() const
{ return m_glyphtable; }
// Create a map of char indices to glyph indices
std::map<size_t, size_t> 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<dictentry_t> m_dictionary;
std::vector<glyphentry_t> 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 <cxxtest/TestSuite.h>
using namespace mcufont;
class DataFileTests: public CxxTest::TestSuite
{
public:
void testFileLoad()
{
std::istringstream s(testfile);
std::unique_ptr<DataFile> 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<DataFile> f1 = DataFile::Load(is1);
std::ostringstream os;
f1->Save(os);
std::string text = os.str();
std::istringstream is2(text);
std::unique_ptr<DataFile> 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

735
contrib/mcufont/encoder/encode_rlefont.cc Normal file
View file

@ -0,0 +1,735 @@
#include "encode_rlefont.hh"
#include <algorithm>
#include <stdexcept>
#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<DictTreeNode*[]> 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<DictTreeNode[]> 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<DataFile::dictentry_t> &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<encoding_link_t[]> 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<DataFile::dictentry_t> &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<encoded_font_t> encode_font(const DataFile &datafile,
bool fast)
{
std::unique_ptr<encoded_font_t> 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<DataFile::dictentry_t> 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<DataFile::pixels_t> 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<DataFile::pixels_t> decode_glyph(
const encoded_font_t &encoded,
const encoded_font_t::refstring_t &refstring,
const DataFile::fontinfo_t &fontinfo)
{
std::unique_ptr<DataFile::pixels_t> 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<DataFile::pixels_t> 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<DataFile::pixels_t> decode_glyph(
const encoded_font_t &encoded, size_t index,
const DataFile::fontinfo_t &fontinfo)
{
return decode_glyph(encoded, encoded.glyphs.at(index), fontinfo);
}
}}

126
contrib/mcufont/encoder/encode_rlefont.hh Normal file
View file

@ -0,0 +1,126 @@
// Given a dictionary and glyphs, encode the data for all the glyphs.
#pragma once
#include "datafile.hh"
#include <vector>
#include <memory>
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<uint8_t> 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<uint8_t> refstring_t;
std::vector<rlestring_t> rle_dictionary;
std::vector<refstring_t> ref_dictionary;
std::vector<refstring_t> glyphs;
};
// Encode all the glyphs.
std::unique_ptr<encoded_font_t> 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<encoded_font_t> e = encode_font(datafile, fast);
return get_encoded_size(*e);
}
// Decode a single glyph (for verification).
std::unique_ptr<DataFile::pixels_t> 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<DataFile::pixels_t> decode_glyph(
const encoded_font_t &encoded, size_t index,
const DataFile::fontinfo_t &fontinfo);
}}
#ifdef CXXTEST_RUNNING
#include <cxxtest/TestSuite.h>
using namespace mcufont;
using namespace mcufont::rlefont;
class RLEFontEncodeTests: public CxxTest::TestSuite
{
public:
void testEncode()
{
std::istringstream s(testfile);
std::unique_ptr<DataFile> f = DataFile::Load(s);
std::unique_ptr<encoded_font_t> 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<DataFile> f = DataFile::Load(s);
std::unique_ptr<encoded_font_t> e = encode_font(*f, false);
for (size_t i = 0; i < 3; i++)
{
std::unique_ptr<DataFile::pixels_t> 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

250
contrib/mcufont/encoder/export_bwfont.cc Normal file
View file

@ -0,0 +1,250 @@
#include "export_bwfont.hh"
#include <vector>
#include <iomanip>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <cctype>
#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<unsigned> &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<DataFile::glyphentry_t> 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<unsigned> offsets;
std::vector<unsigned> data;
std::vector<unsigned> 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<char_range_t> ranges = compute_char_ranges(datafile,
get_glyph_size, 65536, 16);
// Write out glyph data for character ranges
std::vector<cropinfo_t> 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;
}
}}

16
contrib/mcufont/encoder/export_bwfont.hh Normal file
View file

@ -0,0 +1,16 @@
// Write out the encoded data in C source code files for mf_bwfont format.
#pragma once
#include "datafile.hh"
#include <iostream>
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);
} }

336
contrib/mcufont/encoder/export_rlefont.cc Normal file
View file

@ -0,0 +1,336 @@
#include "export_rlefont.hh"
#include <vector>
#include <iomanip>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <cctype>
#include "exporttools.hh"
#include "ccfixes.hh"
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#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_font_t> encoded = encode_font(datafile, false);
std::vector<char_range_t> 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<unsigned> offsets;
std::vector<unsigned> 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<unsigned> offsets;
std::vector<unsigned> data;
std::map<size_t, unsigned> 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");
}
}}

15
contrib/mcufont/encoder/export_rlefont.hh Normal file
View file

@ -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 <iostream>
namespace mcufont {
namespace rlefont {
void write_source(std::ostream &out, std::string name, const DataFile &datafile);
} }

184
contrib/mcufont/encoder/exporttools.cc Normal file
View file

@ -0,0 +1,184 @@
#include "exporttools.hh"
#include <iomanip>
#include <set>
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<unsigned> &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<unsigned> &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<int> 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<char_range_t> compute_char_ranges(const DataFile &datafile,
std::function<size_t(size_t)> get_encoded_glyph_size,
size_t maximum_size,
size_t minimum_gap)
{
std::vector<char_range_t> result;
std::map<size_t, size_t> char_to_glyph = datafile.GetCharToGlyphMap();
std::vector<size_t> 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;
}
}

52
contrib/mcufont/encoder/exporttools.hh Normal file
View file

@ -0,0 +1,52 @@
// Utility functions for exporting to C source code files.
#pragma once
#include <string>
#include <vector>
#include <iostream>
#include <functional>
#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<unsigned> &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<unsigned> &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<int> 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<char_range_t> compute_char_ranges(const DataFile &datafile,
std::function<size_t(size_t)> get_encoded_glyph_size,
size_t maximum_size,
size_t minimum_gap);
}

177
contrib/mcufont/encoder/freetype_import.cc Normal file
View file

@ -0,0 +1,177 @@
#include "freetype_import.hh"
#include "importtools.hh"
#include <map>
#include <string>
#include <stdexcept>
#include <iostream>
#include "ccfixes.hh"
#include <ft2build.h>
#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_Error, std::string> 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<char> &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<char> &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<DataFile> LoadFreetype(std::istream &file, int size, bool bw)
{
std::vector<char> 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<DataFile::glyphentry_t> glyphtable;
std::vector<DataFile::dictentry_t> 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<DataFile> result(new DataFile(
dictionary, glyphtable, fontinfo));
return result;
}
}

10
contrib/mcufont/encoder/freetype_import.hh Normal file
View file

@ -0,0 +1,10 @@
// Function for importing any font supported by libfreetype.
#pragma once
#include "datafile.hh"
namespace mcufont {
std::unique_ptr<DataFile> LoadFreetype(std::istream &file, int size, bool bw);
}

771
contrib/mcufont/encoder/gb2312_in_ucs2.h Normal file
View file

@ -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__ */

143
contrib/mcufont/encoder/importtools.cc Normal file
View file

@ -0,0 +1,143 @@
#include "importtools.hh"
#include <limits>
namespace mcufont {
void eliminate_duplicates(std::vector<DataFile::glyphentry_t> &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<int>::max();
top = std::numeric_limits<int>::max();
right = std::numeric_limits<int>::min();
bottom = std::numeric_limits<int>::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<DataFile::glyphentry_t> &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<DataFile::glyphentry_t> &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;
}
}

20
contrib/mcufont/encoder/importtools.hh Normal file
View file

@ -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<DataFile::glyphentry_t> &glyphtable);
// Calculate the maximum bounding box of the glyphs and crop them to that.
// Adjust fontinfo accordingly.
void crop_glyphs(std::vector<DataFile::glyphentry_t> &glyphtable,
DataFile::fontinfo_t &fontinfo);
// Fill in the flags (BW, monospace) automatically.
void detect_flags(const std::vector<DataFile::glyphentry_t> &glyphtable,
DataFile::fontinfo_t &fontinfo);
}

487
contrib/mcufont/encoder/main.cc Normal file
View file

@ -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 <vector>
#include <string>
#include <set>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <map>
#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<DataFile> 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<DataFile> 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<std::string> &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<DataFile> 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<std::string> &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<DataFile> 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<std::string> &args)
{
if (args.size() < 3)
return STATUS_INVALID;
std::set<int> 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<DataFile> f = load_dat(src);
if (!f)
return STATUS_ERROR;
std::cout << "Font originally had " << f->GetGlyphCount() << " glyphs." << std::endl;
// Filter the glyphs
std::vector<DataFile::glyphentry_t> 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<std::string> &args)
{
if (args.size() != 3)
return STATUS_INVALID;
std::string src = args.at(1);
std::unique_ptr<DataFile> f = load_dat(src);
if (!f)
return STATUS_ERROR;
size_t index = 0;
if (args.at(2) == "largest")
{
std::unique_ptr<mcufont::rlefont::encoded_font_t> 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<std::string> &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<DataFile> 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<std::string> &args)
{
if (args.size() != 2)
return STATUS_INVALID;
std::string src = args.at(1);
std::unique_ptr<DataFile> 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<std::string> &args)
{
if (args.size() != 2 && args.size() != 3)
return STATUS_INVALID;
std::string src = args.at(1);
std::unique_ptr<DataFile> 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<std::string> &args)
{
if (args.size() != 2)
return STATUS_INVALID;
std::string src = args.at(1);
std::unique_ptr<DataFile> f = load_dat(src);
if (!f)
return STATUS_ERROR;
std::unique_ptr<mcufont::rlefont::encoded_font_t> 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<std::string> &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<DataFile> 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 <command> [options] ...\n"
"Commands for importing:\n"
" import_ttf <ttffile> <size> [bw] Import a .ttf font into a data file.\n"
" import_bdf <bdffile> Import a .bdf font into a data file.\n"
"\n"
"Commands for inspecting and editing data files:\n"
" filter <datfile> <range> ... Remove everything except specified characters.\n"
" show_glyph <datfile> <index> Show the glyph at index.\n"
"\n"
"Commands specific to rlefont format:\n"
" rlefont_size <datfile> Check the encoded size of the data file.\n"
" rlefont_optimize <datfile> Perform an optimization pass on the data file.\n"
" rlefont_export <datfile> [outfile] Export to .c source code.\n"
" rlefont_show_encoded <datfile> Show the encoded data for debugging.\n"
"\n"
"Commands specific to bwfont format:\n"
" bwfont_export <datfile> [outfile] Export to .c source code.\n"
"";
typedef status_t (*cmd_t)(const std::vector<std::string> &args);
static const std::map<std::string, cmd_t> 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<std::string> 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;
}

417
contrib/mcufont/encoder/optimize_rlefont.cc Normal file
View file

@ -0,0 +1,417 @@
#include "optimize_rlefont.hh"
#include "encode_rlefont.hh"
#include <random>
#include <iostream>
#include <set>
#include <thread>
#include <algorithm>
#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<DataFile::pixels_t> random_substring(const DataFile &datafile, rnd_t &rnd)
{
std::uniform_int_distribution<size_t> dist1(0, datafile.GetGlyphCount() - 1);
size_t index = dist1(rnd);
const DataFile::pixels_t &pixels = datafile.GetGlyphEntry(index).data;
std::uniform_int_distribution<size_t> dist2(2, pixels.size());
size_t length = dist2(rnd);
std::uniform_int_distribution<size_t> dist3(0, pixels.size() - length);
size_t start = dist3(rnd);
std::unique_ptr<DataFile::pixels_t> 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<size_t> 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<size_t> 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<size_t> dist1(0, DataFile::dictionarysize - 1);
size_t index = dist1(rnd);
DataFile::dictentry_t d = trial.GetDictionaryEntry(index);
std::uniform_int_distribution<size_t> dist3(1, 3);
size_t count = dist3(rnd);
for (size_t i = 0; i < count; i++)
{
std::uniform_int_distribution<size_t> booldist(0, 1);
std::uniform_int_distribution<size_t> 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<size_t> 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<size_t> 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<size_t> 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<size_t> 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<encoded_font_t> e = encode_font(datafile);
// Pick a random encoded glyph
std::uniform_int_distribution<size_t> 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<size_t> dist2(2, refstr.size());
size_t length = dist2(rnd);
std::uniform_int_distribution<size_t> 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<DataFile::pixels_t> 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<DataFile> datafiles;
std::vector<size_t> sizes;
std::vector<rnd_t> rnds;
std::vector<std::unique_ptr<std::thread> > 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<DataFile::pixels_t> seen_substrings;
std::set<DataFile::pixels_t> 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<size_t> dist(0, std::numeric_limits<uint32_t>::max());
datafile.SetSeed(dist(rnd));
}
}}

15
contrib/mcufont/encoder/optimize_rlefont.hh Normal file
View file

@ -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);
}}

BIN
contrib/mcufont/fonts/FiraSansCondensed-Bold.ttf Normal file
View file

Binary file not shown.

346
contrib/mcufont/fonts/FiraSansCondensed-Bold10.mcufont.h Normal file
View file

@ -0,0 +1,346 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 10
* blob size: 5175, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x03, 0x85, 0x00, 0x00, 0x00, 0x89,
/* 0020 */ 0x00, 0x00, 0x00, 0xD3, 0x00, 0x00, 0x13, 0xF7, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x0A, 0x00, 0x0F, 0x00, 0x02, 0x00, 0x09, 0x00, 0x01, 0x00, 0x0B, 0x00, 0x0C, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x30, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x31, 0x30, 0x00,
/* dictionary data */
0x07, 0x04, 0x0C, 0xC2, 0x07, 0xCD, 0xCC, 0x80, 0xC1, 0x07, 0xC7,
/* 0080 */ 0x80, 0xC1, 0x07, 0xC7, 0xC9, 0xCE, 0x03, 0x08, 0xC3, 0x06, 0x05, 0xC7, 0xC9, 0x05, 0xCE, 0xC9,
/* 0090 */ 0x05, 0x06, 0xC1, 0x06, 0x20, 0xC1, 0x80, 0xC3, 0x07, 0x1F, 0xC7, 0xCA, 0x05, 0xCA, 0xCE, 0x01,
/* 00A0 */ 0x33, 0x0B, 0x1F, 0x06, 0xC7, 0xCE, 0xCC, 0x04, 0xC7, 0x01, 0xC5, 0xC8, 0xCD, 0x80, 0xC1, 0x09,
/* 00B0 */ 0xC2, 0x05, 0x80, 0xD2, 0x06, 0xC2, 0x07, 0xC2, 0xCA, 0x80, 0x80, 0xCE, 0x80, 0xC1, 0x06, 0xCC,
/* 00C0 */ 0xC9, 0x80, 0xC4, 0x05, 0x07, 0xC4, 0x80, 0xCB, 0xC8, 0x80, 0xC2, 0x06, 0xCD, 0x80, 0xCE, 0xCA,
/* 00D0 */ 0x3C, 0x08, 0xC2, 0xC9, 0x81, 0xC3, 0x05, 0x17, 0x80, 0xC6, 0xC7, 0x80, 0xC1, 0xC9, 0x06, 0x34,
/* 00E0 */ 0x80, 0xC2, 0xCD, 0xC6, 0x80, 0xC8, 0x07, 0xC7, 0x80, 0xC2, 0x07, 0xC7, 0x80, 0xC2, 0xC1, 0x07,
/* 00F0 */ 0xC6, 0xCB, 0xCE, 0xC1, 0x80, 0xC9, 0xCD, 0xC2, 0x05, 0xC8, 0x80, 0xC5, 0xCC, 0x07, 0xC7, 0xCB,
/* 0100 */ 0xC7, 0xD3, 0xCB, 0x08, 0x80, 0xCC, 0x80, 0xC5, 0xC8, 0x07, 0xCE, 0x01, 0xCE, 0xC8, 0xCE, 0xC5,
/* 0110 */ 0xC4, 0x80, 0x02, 0xC3, 0x80, 0xC7, 0xDC, 0x08, 0xC7, 0x21, 0xCC, 0xCA, 0xC8, 0xCC, 0x05, 0xC2,
/* 0120 */ 0xC1, 0x05, 0x05, 0xC6, 0xC3, 0xCD, 0xC6, 0x80, 0x80, 0xCA, 0x01, 0xC1, 0x01, 0xC2, 0xC5, 0xCD,
/* 0130 */ 0xDB, 0x82, 0xC3, 0x03, 0xC9, 0xCD, 0xC8, 0x80, 0xC1, 0x01, 0xC4, 0xCE, 0xC4, 0xCE, 0xC2, 0xCE,
/* 0140 */ 0xC3, 0xC6, 0xCE, 0xC6, 0xCC, 0xCC, 0xCB, 0xC3, 0xCE, 0xCD, 0xC5, 0xC3, 0xC2, 0xCC, 0xCE, 0xCD,
/* 0150 */ 0xC3, 0xCE, 0xCB, 0xCA, 0xCC, 0x01, 0xCC, 0xCD, 0x80, 0xC3, 0xCE, 0xC6, 0xCD, 0xCE, 0xC9, 0xCC,
/* 0160 */ 0xC3, 0xCC, 0xCD, 0xC7, 0xCD, 0xC4, 0x01, 0xC7, 0x81, 0x15, 0x80, 0xC7, 0xD6, 0xCE, 0xC7, 0xCA,
/* 0170 */ 0xC7, 0xCB, 0xCE, 0xCE, 0x80, 0xCB, 0xCC, 0xC3, 0x80, 0xC6, 0xCA, 0xC1, 0xC2, 0xCD, 0xCB, 0x01,
/* 0180 */ 0xCD, 0xC3, 0xC1, 0x80, 0xC4, 0xCD, 0xC9, 0x3C, 0x20, 0x3C, 0x1F, 0x57, 0x1B, 0x01, 0x5E, 0x94,
/* 0190 */ 0x19, 0x79, 0x88, 0x74, 0x57, 0x0F, 0x3D, 0x25, 0x98, 0x03, 0x07, 0x88, 0x19, 0x55, 0x00, 0x03,
/* 01A0 */ 0x4A, 0x91, 0x47, 0x9F, 0x6B, 0x5B, 0x9E, 0x06, 0x92, 0x19, 0x78, 0x00, 0x66, 0x19, 0x0A, 0xF5,
/* 01B0 */ 0x96, 0x19, 0x0A, 0xF5, 0x96, 0x19, 0x78, 0x00, 0x66, 0x19, 0x03, 0x52, 0x06, 0x54, 0x37, 0x67,
/* 01C0 */ 0x24, 0x06, 0x4E, 0x64, 0x4B, 0x24, 0x06, 0x4E, 0x09, 0x32, 0x03, 0x6D, 0x5E, 0x66, 0x25, 0x2D,
/* 01D0 */ 0x41, 0x25, 0x2D, 0x09, 0x0F, 0x6D, 0x5E, 0x9C, 0x27, 0x0A, 0x32, 0x02, 0x01, 0x05, 0x06, 0x4A,
/* 01E0 */ 0x25, 0x8C, 0x0F, 0x92, 0x25, 0x0A, 0x62, 0x92, 0x25, 0x0B, 0x4F, 0x50, 0x19, 0x79, 0x32, 0x08,
/* 01F0 */ 0x08, 0x7D, 0x24, 0x6B, 0x55, 0x06, 0x00, 0x26, 0x4A, 0x00, 0x26, 0x4A, 0x00, 0x26, 0x4A, 0x00,
/* 0200 */ 0x36, 0x59, 0x1D, 0x1D, 0x0F, 0x52, 0x68, 0x19, 0x78, 0x65, 0x19, 0x78, 0x65, 0x19, 0x78, 0x65,
/* 0210 */ 0x19, 0x78, 0x65, 0x19, 0x78, 0x03, 0x4A, 0x1F, 0x34, 0x50, 0x09, 0x0F, 0x48, 0x1E, 0x94, 0x51,
/* 0220 */ 0x51, 0x51, 0x91, 0x07, 0x33, 0x1C, 0x07, 0x94, 0x33, 0x0E, 0x6A, 0x8D, 0x33, 0x0E, 0x63, 0x8D,
/* 0230 */ 0x33, 0x60, 0x0E, 0x1F, 0x57, 0x1F, 0x57, 0x55, 0x06, 0x92, 0x25, 0x7D, 0x24, 0x00, 0x1E, 0x67,
/* 0240 */ 0x09, 0x20, 0x0A, 0x04, 0x0D, 0x2C, 0x22, 0x5E, 0x25, 0x80, 0x87, 0x2C, 0x00, 0x1E, 0x25, 0x2D,
/* 0250 */ 0x1E, 0x22, 0x5E, 0x8A, 0x19, 0x71, 0x86, 0x4A, 0x22, 0x0E, 0x99, 0x38, 0x99, 0x35, 0x18, 0x0E,
/* 0260 */ 0xA0, 0x18, 0x0B, 0x5E, 0x59, 0x54, 0x27, 0x6A, 0x04, 0x27, 0x1A, 0x4D, 0x09, 0x32, 0x38, 0x6F,
/* 0270 */ 0x93, 0x27, 0x2D, 0x18, 0x2D, 0x00, 0x94, 0x33, 0x0F, 0x60, 0x94, 0x33, 0x0B, 0x43, 0x38, 0x34,
/* 0280 */ 0x40, 0x18, 0x29, 0x5F, 0x29, 0x5F, 0x01, 0x92, 0x33, 0x60, 0x0B, 0x92, 0x19, 0x4B, 0x78, 0x33,
/* 0290 */ 0x4A, 0x87, 0x22, 0x09, 0x76, 0x01, 0x7B, 0x41, 0x70, 0x1F, 0x9A, 0x72, 0x03, 0x81, 0x64, 0x8F,
/* 02A0 */ 0x2A, 0x0B, 0x64, 0x95, 0x19, 0x53, 0x72, 0x54, 0x19, 0x53, 0x00, 0x09, 0x9D, 0x0A, 0x57, 0x9D,
/* 02B0 */ 0x0A, 0x57, 0x9D, 0x0A, 0x57, 0x9D, 0x0A, 0x22, 0x88, 0x44, 0x4E, 0x59, 0x4E, 0x85, 0x38, 0x7D,
/* 02C0 */ 0x73, 0x23, 0x0A, 0x90, 0x5D, 0x25, 0x0A, 0x7C, 0x82, 0x6D, 0x4A, 0x07, 0x21, 0x0A, 0x00, 0x08,
/* 02D0 */ 0x52, 0x03, 0x36, 0x27, 0x47, 0x4A, 0x6B, 0x05, 0x9F, 0x01, 0x63, 0x99, 0x48, 0x18, 0x34, 0x27,
/* 02E0 */ 0x34, 0x0F, 0x5D, 0x18, 0x1E, 0x3E, 0x27, 0x99, 0x06, 0x9F, 0x33, 0x88, 0x09, 0x4E, 0x33, 0x90,
/* 02F0 */ 0x50, 0x22, 0x0F, 0x18, 0x03, 0x4A, 0x18, 0x03, 0x4A, 0x00, 0x90, 0x4A, 0x22, 0x2B, 0x90, 0x81,
/* 0300 */ 0x22, 0x5E, 0x91, 0x01, 0x03, 0x67, 0x1D, 0x70, 0x89, 0x22, 0x92, 0x83, 0x25, 0x4B, 0x4B, 0x5E,
/* 0310 */ 0x9E, 0x22, 0x4E, 0x59, 0x88, 0x59, 0x75, 0x31, 0x5E, 0x03, 0x31, 0x5E, 0x9E, 0x22, 0x90, 0x92,
/* 0320 */ 0x0A, 0x20, 0x6A, 0x1F, 0x79, 0x24, 0x6B, 0x70, 0x05, 0x07, 0x57, 0x1B, 0x25, 0x4B, 0x7F, 0x22,
/* 0330 */ 0x4E, 0x00, 0x72, 0x04, 0x1F, 0x92, 0x33, 0x39, 0x78, 0x1E, 0x6B, 0x4A, 0x61, 0x27, 0x2E, 0x07,
/* 0340 */ 0x44, 0x3A, 0x72, 0x92, 0x18, 0x0C, 0x73, 0x1B, 0x0E, 0x8E, 0x0A, 0x88, 0x33, 0x04, 0x32, 0x49,
/* 0350 */ 0x52, 0x24, 0x9D, 0x2C, 0x04, 0x0C, 0x52, 0x05, 0x54, 0x20, 0x69, 0x20, 0x1E, 0x20, 0x0B, 0x5C,
/* 0360 */ 0x00, 0x52, 0x8C, 0x09, 0x18, 0x93, 0x6C, 0x6E, 0x40, 0x6C, 0x08, 0x0A, 0x7E, 0x26, 0x01, 0x72,
/* 0370 */ 0x0B, 0x54, 0x27, 0x99, 0x5F, 0x49, 0x46, 0x7F, 0x0D, 0x5F, 0x18, 0x0A, 0x62, 0x22, 0x0F, 0x52,
/* 0380 */ 0x4B, 0x3B, 0x1B, 0x0F, 0x0D,
/* dictionary offset */
0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x05, 0x00,
/* 0390 */ 0x07, 0x00, 0x0F, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x15, 0x00, 0x17, 0x00, 0x19, 0x00,
/* 03A0 */ 0x1B, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x22, 0x00, 0x24, 0x00, 0x26, 0x00,
/* 03B0 */ 0x28, 0x00, 0x2B, 0x00, 0x2C, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x32, 0x00, 0x34, 0x00,
/* 03C0 */ 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x41, 0x00, 0x43, 0x00,
/* 03D0 */ 0x45, 0x00, 0x47, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x53, 0x00, 0x55, 0x00, 0x57, 0x00, 0x59, 0x00,
/* 03E0 */ 0x5B, 0x00, 0x5C, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x63, 0x00, 0x65, 0x00, 0x68, 0x00,
/* 03F0 */ 0x6A, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x7D, 0x00,
/* 0400 */ 0x7F, 0x00, 0x81, 0x00, 0x83, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8A, 0x00, 0x8C, 0x00, 0x8D, 0x00,
/* 0410 */ 0x8F, 0x00, 0x91, 0x00, 0x93, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D, 0x00,
/* 0420 */ 0x9E, 0x00, 0xA1, 0x00, 0xA2, 0x00, 0xA4, 0x00, 0xA5, 0x00, 0xA7, 0x00, 0xA9, 0x00, 0xAB, 0x00,
/* 0430 */ 0xAD, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBB, 0x00,
/* 0440 */ 0xBC, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00, 0xCA, 0x00,
/* 0450 */ 0xCC, 0x00, 0xCE, 0x00, 0xD0, 0x00, 0xD2, 0x00, 0xD4, 0x00, 0xD6, 0x00, 0xD8, 0x00, 0xDA, 0x00,
/* 0460 */ 0xDC, 0x00, 0xDE, 0x00, 0xE1, 0x00, 0xE3, 0x00, 0xE5, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xEB, 0x00,
/* 0470 */ 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF4, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF8, 0x00,
/* 0480 */ 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x01, 0x08, 0x01,
/* 0490 */ 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x18, 0x01, 0x2D, 0x01, 0x32, 0x01,
/* 04A0 */ 0x46, 0x01, 0x4B, 0x01, 0x53, 0x01, 0x67, 0x01, 0x7C, 0x01, 0x80, 0x01, 0x8B, 0x01, 0x92, 0x01,
/* 04B0 */ 0xAA, 0x01, 0xAE, 0x01, 0xBE, 0x01, 0xC2, 0x01, 0xC9, 0x01, 0xCF, 0x01, 0xD1, 0x01, 0xD3, 0x01,
/* 04C0 */ 0xD7, 0x01, 0xE1, 0x01, 0xF6, 0x02, 0x00, 0x02, 0x07, 0x02, 0x12, 0x02, 0x17, 0x02, 0x1E, 0x02,
/* 04D0 */ 0x2C, 0x02, 0x37, 0x02, 0x45, 0x02, 0x48, 0x02, 0x59, 0x02, 0x5B, 0x02, 0x65, 0x02, 0x68, 0x02,
/* 04E0 */ 0x6A, 0x02, 0x6D, 0x02, 0x71, 0x02, 0x73, 0x02, 0x7E, 0x02, 0x85, 0x02, 0x88, 0x02, 0x8D, 0x02,
/* 04F0 */ 0x9A, 0x02, 0xAB, 0x02, 0xAE, 0x02, 0xB0, 0x02, 0xB7, 0x02, 0xBA, 0x02, 0xBC, 0x02, 0xC0, 0x02,
/* 0500 */ 0xC3, 0x02, 0xC9, 0x02, 0xCC, 0x02, 0xCE, 0x02, 0xD3, 0x02, 0xD5, 0x02, 0xD8, 0x02, 0xDA, 0x02,
/* 0510 */ 0xDC, 0x02, 0xDF, 0x02, 0xE4, 0x02, 0xE7, 0x02, 0xE9, 0x02, 0xEB, 0x02, 0xF2, 0x02, 0xF5, 0x02,
/* 0520 */ 0xFB, 0x03, 0x00, 0x03, 0x03, 0x03, 0x05, 0x03, 0x07, 0x03, 0x0E, 0x03, 0x10,
/* char range info */
0x00, 0x00, 0x02,
/* 0530 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x12, 0x00, 0x1D, 0x00, 0x3B, 0x00, 0x5E, 0x00, 0x90,
/* 0540 */ 0x00, 0xB5, 0x00, 0xBC, 0x00, 0xD3, 0x00, 0xEA, 0x00, 0xFC, 0x01, 0x03, 0x01, 0x0A, 0x01, 0x13,
/* 0550 */ 0x01, 0x18, 0x01, 0x2B, 0x01, 0x4A, 0x01, 0x60, 0x01, 0x79, 0x01, 0x92, 0x01, 0xAC, 0x01, 0xC7,
/* 0560 */ 0x01, 0xE6, 0x01, 0xF9, 0x02, 0x19, 0x02, 0x3B, 0x02, 0x43, 0x02, 0x4D, 0x02, 0x60, 0x02, 0x67,
/* 0570 */ 0x02, 0x79, 0x02, 0x90, 0x02, 0xC9, 0x02, 0xCF, 0x02, 0xE9, 0x02, 0xF8, 0x03, 0x0F, 0x03, 0x14,
/* 0580 */ 0x03, 0x25, 0x03, 0x45, 0x03, 0x59, 0x03, 0x5E, 0x03, 0x6F, 0x03, 0x8A, 0x03, 0x97, 0x03, 0xC4,
/* 0590 */ 0x03, 0xCD, 0x03, 0xD3, 0x03, 0xDF, 0x03, 0xEF, 0x03, 0xFF, 0x04, 0x1E, 0x04, 0x35, 0x04, 0x3B,
/* 05A0 */ 0x04, 0x59, 0x04, 0x89, 0x04, 0xA6, 0x04, 0xB0, 0x04, 0xC3, 0x04, 0xD6, 0x04, 0xED, 0x05, 0x01,
/* 05B0 */ 0x05, 0x10, 0x05, 0x1B, 0x05, 0x24, 0x05, 0x29, 0x05, 0x2F, 0x05, 0x38, 0x05, 0x4C, 0x05, 0x52,
/* 05C0 */ 0x05, 0x69, 0x05, 0x8C, 0x05, 0x9C, 0x05, 0xA2, 0x05, 0xB2, 0x05, 0xC9, 0x05, 0xD6, 0x05, 0xE7,
/* 05D0 */ 0x05, 0xF2, 0x05, 0xF6, 0x06, 0x03, 0x06, 0x16, 0x06, 0x22, 0x06, 0x37, 0x06, 0x4D, 0x06, 0x53,
/* 05E0 */ 0x06, 0x68, 0x06, 0x8B, 0x06, 0xA3, 0x06, 0xA8, 0x06, 0xB8, 0x06, 0xD1, 0x06, 0xDD, 0x06, 0xF8,
/* 05F0 */ 0x02, 0x00, 0x10, 0x02, 0x30, 0x2D, 0x18, 0x77, 0x20, 0x35, 0x20, 0x6A, 0x67, 0x0C, 0x2F, 0x59,
/* 0600 */ 0xCE, 0x10, 0x04, 0x30, 0x6A, 0x6A, 0x31, 0x5A, 0x0B, 0x27, 0x9A, 0x9A, 0x10, 0x05, 0x28, 0x5A,
/* 0610 */ 0x09, 0x4C, 0x0C, 0x53, 0x08, 0x57, 0x0F, 0x3D, 0x6B, 0x5E, 0x89, 0x25, 0x03, 0x4E, 0x88, 0x19,
/* 0620 */ 0x9D, 0x75, 0x23, 0x08, 0x8D, 0x7B, 0x19, 0xC1, 0x0B, 0x7E, 0x10, 0x05, 0x49, 0x0C, 0x52, 0x29,
/* 0630 */ 0x42, 0x03, 0x97, 0x5E, 0x25, 0x0A, 0x54, 0x04, 0x6C, 0x09, 0x92, 0x01, 0x3A, 0x0B, 0x3D, 0x2A,
/* 0640 */ 0x63, 0x2C, 0x82, 0x00, 0x85, 0x25, 0x0A, 0x3D, 0x9F, 0xC7, 0x03, 0x20, 0x4E, 0x10, 0x08, 0x20,
/* 0650 */ 0x1A, 0x26, 0x19, 0x03, 0x1C, 0x01, 0x00, 0x0C, 0x04, 0x1F, 0x09, 0x09, 0x5A, 0x73, 0x19, 0x95,
/* 0660 */ 0x0A, 0x08, 0x4F, 0xCF, 0x3D, 0x35, 0x3A, 0x02, 0x8D, 0x0D, 0x56, 0x33, 0x0C, 0x08, 0x0A, 0x0A,
/* 0670 */ 0x08, 0x64, 0x71, 0x7A, 0x09, 0x0A, 0x0A, 0x08, 0x1F, 0x53, 0x00, 0x6E, 0x56, 0x1F, 0x71, 0x10,
/* 0680 */ 0x07, 0x00, 0x2B, 0xD9, 0x19, 0x71, 0x55, 0x66, 0x27, 0x50, 0x7F, 0x31, 0x0F, 0x7B, 0x01, 0x1F,
/* 0690 */ 0x71, 0x8A, 0x7C, 0x62, 0x1F, 0x06, 0x88, 0x0A, 0x0E, 0x54, 0x64, 0x34, 0x50, 0x6F, 0x56, 0x19,
/* 06A0 */ 0x1E, 0x0D, 0x7E, 0x05, 0x10, 0x02, 0x30, 0x6A, 0x67, 0x5C, 0x9A, 0x10, 0x03, 0x91, 0x72, 0x03,
/* 06B0 */ 0x20, 0x69, 0x18, 0x63, 0x2A, 0x77, 0x20, 0xE1, 0x0D, 0x5C, 0xE1, 0x77, 0x00, 0x3F, 0x88, 0xDF,
/* 06C0 */ 0x02, 0x03, 0x10, 0x03, 0x91, 0x82, 0x00, 0xE8, 0x5C, 0x03, 0x9F, 0x20, 0xA0, 0x20, 0xE1, 0x98,
/* 06D0 */ 0x20, 0xE1, 0xA0, 0x18, 0x03, 0x9F, 0xE8, 0x5C, 0x82, 0x10, 0x04, 0x30, 0xC1, 0x0A, 0x18, 0x09,
/* 06E0 */ 0x0B, 0x7F, 0x25, 0x34, 0x0E, 0x4A, 0x27, 0x73, 0x5A, 0x3B, 0x02, 0x10, 0x05, 0x4D, 0x99, 0xC2,
/* 06F0 */ 0xC7, 0x01, 0x10, 0x02, 0x30, 0x45, 0x08, 0x5C, 0xB1, 0x10, 0x04, 0x2F, 0x45, 0x47, 0x05, 0x3A,
/* 0700 */ 0x03, 0x9E, 0x10, 0x02, 0x45, 0x2B, 0xCE, 0x10, 0x05, 0x68, 0x06, 0x60, 0xE8, 0x5C, 0xE7, 0x02,
/* 0710 */ 0x9F, 0xC5, 0x52, 0x8B, 0x20, 0xE7, 0x01, 0x5E, 0x3F, 0x36, 0x10, 0x05, 0x30, 0xC1, 0x32, 0x38,
/* 0720 */ 0x65, 0xB2, 0x07, 0x0F, 0xC1, 0x0E, 0x25, 0x1E, 0x8F, 0x0F, 0x25, 0x1E, 0x8F, 0x0F, 0x22, 0x0F,
/* 0730 */ 0xC1, 0x0E, 0x25, 0x65, 0x0C, 0x2C, 0xC1, 0x32, 0x02, 0x10, 0x04, 0x00, 0x2B, 0x50, 0x27, 0x47,
/* 0740 */ 0x08, 0x00, 0x6D, 0x04, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x20, 0x50, 0x10,
/* 0750 */ 0x05, 0x30, 0x73, 0x89, 0x27, 0x95, 0x3C, 0x52, 0x6F, 0x2A, 0x09, 0x36, 0x3A, 0x0F, 0x5F, 0x87,
/* 0760 */ 0x6C, 0xC1, 0x4A, 0x03, 0x6C, 0x0C, 0x90, 0x5E, 0x10, 0x05, 0x30, 0x73, 0x61, 0x31, 0x06, 0x09,
/* 0770 */ 0xBF, 0x25, 0xC1, 0x50, 0x3B, 0x08, 0x88, 0x3B, 0x4A, 0x25, 0x0A, 0x06, 0x08, 0x9F, 0x25, 0x7D,
/* 0780 */ 0x61, 0x10, 0x05, 0x28, 0x03, 0x0B, 0x52, 0x08, 0x0E, 0x20, 0xA0, 0x3F, 0x9F, 0x5E, 0x25, 0x09,
/* 0790 */ 0x7B, 0x5E, 0x25, 0x0C, 0xF3, 0x6B, 0x03, 0x05, 0x92, 0x3B, 0x5E, 0x10, 0x05, 0x2B, 0x90, 0x9F,
/* 07A0 */ 0x22, 0x7C, 0x9E, 0x22, 0x0E, 0x67, 0x0F, 0x32, 0x6C, 0x03, 0x06, 0x05, 0x92, 0x20, 0x24, 0x22,
/* 07B0 */ 0x07, 0x06, 0x4A, 0x25, 0x73, 0x24, 0x10, 0x05, 0x30, 0x79, 0x0D, 0x7A, 0x19, 0x71, 0x44, 0x05,
/* 07C0 */ 0x6C, 0x6F, 0x1B, 0x09, 0x40, 0x62, 0x25, 0x09, 0x5E, 0x0B, 0x0D, 0x57, 0xC1, 0xFD, 0xCF, 0x4A,
/* 07D0 */ 0x66, 0x25, 0xC1, 0x0E, 0x56, 0x10, 0x04, 0x30, 0x0E, 0x75, 0x38, 0x5B, 0x2D, 0x18, 0xA0, 0x3F,
/* 07E0 */ 0x9F, 0x18, 0xE0, 0x24, 0xC5, 0x21, 0x71, 0x05, 0x10, 0x05, 0x28, 0x0A, 0x5D, 0x03, 0x6D, 0x5E,
/* 07F0 */ 0x9C, 0x6D, 0x36, 0x74, 0x6B, 0x8A, 0x7C, 0x00, 0xCF, 0x61, 0x0E, 0x23, 0x98, 0x00, 0x41, 0x25,
/* 0800 */ 0x09, 0x7A, 0x96, 0x19, 0x71, 0x0B, 0x0F, 0x8E, 0x10, 0x05, 0x30, 0x01, 0x0B, 0x85, 0x6C, 0x08,
/* 0810 */ 0x62, 0x0E, 0x23, 0x98, 0x00, 0x98, 0x25, 0x0A, 0x7B, 0x0D, 0x0D, 0x25, 0x03, 0x3D, 0x85, 0x26,
/* 0820 */ 0x04, 0x4A, 0x19, 0x71, 0x06, 0x32, 0x27, 0x03, 0x8D, 0x01, 0x10, 0x02, 0x45, 0x8F, 0xCE, 0x2F,
/* 0830 */ 0x59, 0xCE, 0x10, 0x02, 0x45, 0x8F, 0xCE, 0x25, 0x1A, 0xC1, 0x5C, 0xB1, 0x10, 0x05, 0x4D, 0x71,
/* 0840 */ 0x07, 0x01, 0x6B, 0x08, 0x32, 0x38, 0x0B, 0x7A, 0x64, 0x6D, 0x0D, 0x8D, 0x52, 0x06, 0x84, 0x10,
/* 0850 */ 0x05, 0x00, 0x45, 0xA3, 0x25, 0xA3, 0x10, 0x05, 0x2E, 0x04, 0x05, 0x20, 0x73, 0x4F, 0x01, 0x59,
/* 0860 */ 0x92, 0x6B, 0x09, 0x32, 0x03, 0x22, 0x0B, 0x04, 0x10, 0x04, 0x30, 0x73, 0x24, 0x00, 0x6D, 0x08,
/* 0870 */ 0x41, 0x2A, 0x09, 0x4E, 0x00, 0x6D, 0x92, 0xE8, 0x5C, 0x37, 0xC1, 0x08, 0x00, 0xE8, 0x0A, 0x10,
/* 0880 */ 0x09, 0x28, 0x79, 0x83, 0x24, 0x01, 0x1F, 0x06, 0x50, 0x04, 0x05, 0x66, 0x00, 0x71, 0x94, 0x06,
/* 0890 */ 0xD9, 0x89, 0x34, 0x4E, 0x4A, 0x62, 0x0A, 0x0A, 0xC1, 0x8E, 0x36, 0x62, 0x6A, 0xC1, 0x81, 0xFD,
/* 08A0 */ 0x62, 0x09, 0x0B, 0x00, 0x06, 0x88, 0x4A, 0x24, 0x8D, 0x72, 0x0F, 0x9A, 0x7A, 0x9C, 0x01, 0x00,
/* 08B0 */ 0x8F, 0x50, 0x04, 0x04, 0x04, 0x6D, 0x83, 0x24, 0x10, 0x05, 0x30, 0x34, 0xC6, 0xA2, 0x10, 0x06,
/* 08C0 */ 0x2B, 0x90, 0x4F, 0xB3, 0x0C, 0x36, 0x33, 0x88, 0x0A, 0x54, 0x33, 0xCA, 0x5E, 0x0A, 0x4E, 0x33,
/* 08D0 */ 0x4E, 0x04, 0x5E, 0x33, 0x5E, 0xDA, 0x90, 0x8D, 0x10, 0x05, 0x28, 0x73, 0xD0, 0xA1, 0x03, 0x70,
/* 08E0 */ 0x04, 0x08, 0x00, 0x6D, 0x0D, 0x24, 0x01, 0x10, 0x06, 0xCB, 0xDA, 0x39, 0x92, 0x33, 0x4E, 0x01,
/* 08F0 */ 0x55, 0x33, 0x4E, 0x01, 0x55, 0x33, 0x39, 0x92, 0x33, 0x5E, 0xDA, 0x0F, 0x5D, 0x04, 0x10, 0x05,
/* 0900 */ 0x2B, 0xCA, 0xCD, 0x10, 0x04, 0x2B, 0x90, 0x9F, 0xB3, 0x9E, 0xD2, 0x59, 0x88, 0x59, 0x90, 0x60,
/* 0910 */ 0xB3, 0x03, 0x31, 0xBF, 0x10, 0x06, 0x30, 0x79, 0x0D, 0x85, 0x02, 0x1F, 0x72, 0x70, 0x04, 0x0A,
/* 0920 */ 0x01, 0x19, 0x41, 0x1B, 0x3C, 0x20, 0x3C, 0x9D, 0x92, 0x19, 0x78, 0x65, 0xCF, 0x55, 0x05, 0x92,
/* 0930 */ 0x6D, 0x0D, 0x85, 0x03, 0x10, 0x06, 0x2B, 0x39, 0xD4, 0x92, 0x33, 0x0F, 0x82, 0x92, 0x33, 0x75,
/* 0940 */ 0x92, 0x33, 0x5E, 0x05, 0xD4, 0xD4, 0xD4, 0x92, 0x10, 0x03, 0x2B, 0xBF, 0xAD, 0x10, 0x03, 0x30,
/* 0950 */ 0x03, 0x4A, 0xC9, 0xC7, 0x06, 0xC9, 0xC7, 0x05, 0x59, 0x0F, 0x2A, 0x24, 0x20, 0x03, 0x10, 0x06,
/* 0960 */ 0x2B, 0x39, 0x92, 0x33, 0x4E, 0x0A, 0x54, 0x33, 0x5E, 0x92, 0x22, 0x0F, 0x83, 0x31, 0x55, 0x9F,
/* 0970 */ 0x22, 0x88, 0x85, 0xD2, 0x08, 0x88, 0x33, 0x39, 0x70, 0x10, 0x05, 0x2B, 0xBF, 0x51, 0x51, 0x59,
/* 0980 */ 0x92, 0x06, 0x03, 0x22, 0x90, 0x92, 0x10, 0x07, 0x30, 0x04, 0xEA, 0x00, 0x0A, 0x92, 0x64, 0x34,
/* 0990 */ 0xF7, 0x0C, 0x50, 0x1F, 0x7D, 0x7B, 0x0E, 0xA0, 0x64, 0x8F, 0x32, 0x06, 0x85, 0x0A, 0x64, 0xC1,
/* 09A0 */ 0x24, 0x0B, 0x7F, 0x0A, 0x64, 0xC1, 0x8D, 0x24, 0x74, 0x1F, 0x09, 0x8E, 0x92, 0x86, 0x64, 0x86,
/* 09B0 */ 0x9E, 0x0A, 0x0D, 0x10, 0x06, 0x2B, 0x70, 0xB8, 0x43, 0x80, 0xAE, 0xBA, 0x10, 0x06, 0x28, 0xA9,
/* 09C0 */ 0xA4, 0xB0, 0x10, 0x05, 0xCB, 0x0B, 0x36, 0x33, 0x4E, 0xC8, 0x05, 0x01, 0x31, 0xBF, 0x10, 0x06,
/* 09D0 */ 0x28, 0xA9, 0xA4, 0x55, 0x06, 0x5E, 0x6D, 0x97, 0x4F, 0x00, 0x26, 0x07, 0x7B, 0x46, 0x10, 0x06,
/* 09E0 */ 0xCB, 0x0B, 0x36, 0x33, 0x4E, 0xC8, 0x07, 0x4A, 0xD2, 0x0B, 0x0D, 0xD2, 0x04, 0x92, 0x10, 0x05,
/* 09F0 */ 0x30, 0x01, 0x0A, 0x32, 0x04, 0x57, 0x06, 0x07, 0x06, 0x25, 0x0A, 0x9F, 0x18, 0x63, 0x40, 0x42,
/* 0A00 */ 0x03, 0x0B, 0x0F, 0x5C, 0x83, 0x19, 0xC1, 0x08, 0xDB, 0x25, 0x58, 0x5D, 0x03, 0x10, 0x05, 0x30,
/* 0A10 */ 0x0E, 0x90, 0xEA, 0x25, 0x03, 0x07, 0x4A, 0x38, 0x34, 0x9F, 0xC5, 0x04, 0xC5, 0x04, 0xC5, 0x04,
/* 0A20 */ 0xC5, 0x04, 0xC5, 0x04, 0x10, 0x06, 0x30, 0x78, 0x65, 0xAC, 0x10, 0x05, 0x30, 0x55, 0x34, 0x9F,
/* 0A30 */ 0x19, 0x66, 0x00, 0x4B, 0x1F, 0xC1, 0x60, 0x86, 0x1F, 0x34, 0x4E, 0x0C, 0x09, 0x6B, 0x5E, 0x4A,
/* 0A40 */ 0x25, 0x9D, 0x3C, 0x21, 0x0A, 0x97, 0x59, 0x5D, 0x10, 0x08, 0x30, 0x0D, 0x0A, 0x00, 0x40, 0x00,
/* 0A50 */ 0x61, 0x64, 0x98, 0x02, 0xEA, 0x00, 0x92, 0x64, 0x09, 0x8E, 0x0D, 0x4E, 0x5E, 0x00, 0x8F, 0x0E,
/* 0A60 */ 0x9A, 0x5E, 0x88, 0x00, 0x34, 0x50, 0x35, 0x78, 0x00, 0x79, 0x40, 0x53, 0x96, 0x64, 0x72, 0x0F,
/* 0A70 */ 0x7A, 0x09, 0x32, 0x00, 0xEC, 0x4E, 0x08, 0x70, 0x10, 0x05, 0x30, 0x0B, 0x60, 0x09, 0x54, 0x1F,
/* 0A80 */ 0x34, 0x9F, 0x61, 0x25, 0x9D, 0x0D, 0x4E, 0x31, 0x70, 0x18, 0x09, 0xEA, 0x26, 0x55, 0x5E, 0xD2,
/* 0A90 */ 0x9C, 0x25, 0x1C, 0xC1, 0x4E, 0x10, 0x05, 0x30, 0x1C, 0x34, 0x5E, 0x19, 0xD5, 0xB9, 0x50, 0x10,
/* 0AA0 */ 0x05, 0x30, 0x47, 0x70, 0x6B, 0x03, 0x07, 0x0F, 0x5F, 0xE5, 0xE5, 0x0A, 0x5E, 0x82, 0x19, 0x9D,
/* 0AB0 */ 0x90, 0x70, 0x10, 0x03, 0x91, 0x0B, 0x40, 0x18, 0x98, 0x1B, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1,
/* 0AC0 */ 0xE1, 0x0B, 0x40, 0x3B, 0x82, 0x10, 0x05, 0x91, 0x71, 0x20, 0x63, 0x52, 0x01, 0x5E, 0x20, 0xE7,
/* 0AD0 */ 0x00, 0x8B, 0xC4, 0x36, 0x3B, 0x9F, 0x20, 0xE7, 0x00, 0x0A, 0x5C, 0x7D, 0x10, 0x03, 0x91, 0x0C,
/* 0AE0 */ 0x70, 0x3B, 0x69, 0x20, 0x69, 0xDF, 0x69, 0xDF, 0x69, 0xDF, 0x69, 0x18, 0x0C, 0x70, 0x3B, 0x82,
/* 0AF0 */ 0x10, 0x05, 0x19, 0x46, 0x08, 0x03, 0xE8, 0x40, 0x3A, 0x0F, 0x6F, 0x48, 0x77, 0x00, 0x74, 0x10,
/* 0B00 */ 0x05, 0x00, 0x45, 0x45, 0x0E, 0x75, 0x23, 0x03, 0x5B, 0x82, 0x10, 0x03, 0x91, 0x01, 0x01, 0x67,
/* 0B10 */ 0x8E, 0xC4, 0x07, 0x10, 0x05, 0x2E, 0xE3, 0xA8, 0x10, 0x05, 0xCC, 0xBB, 0x85, 0x62, 0x10, 0x04,
/* 0B20 */ 0xB7, 0x18, 0x6F, 0x93, 0xE8, 0x0E, 0x56, 0x10, 0x05, 0x49, 0x72, 0x02, 0x20, 0xE0, 0x1E, 0x19,
/* 0B30 */ 0x71, 0x96, 0x8A, 0x6D, 0x4A, 0x83, 0x25, 0x1E, 0xB5, 0x83, 0x96, 0x10, 0x05, 0x4D, 0x0A, 0xC0,
/* 0B40 */ 0xD9, 0x10, 0x03, 0x28, 0x0A, 0x85, 0x64, 0xCF, 0x92, 0x48, 0xFA, 0x9F, 0x00, 0x6D, 0x4A, 0x6C,
/* 0B50 */ 0x79, 0x9F, 0x3F, 0x9F, 0x3F, 0x9F, 0x3F, 0x9F, 0x10, 0x05, 0x2F, 0x68, 0x03, 0x06, 0x6B, 0x0C,
/* 0B60 */ 0x3D, 0x2C, 0x0A, 0x62, 0x5E, 0x25, 0x0A, 0x56, 0x92, 0x25, 0x03, 0x90, 0x7B, 0x6D, 0x89, 0x42,
/* 0B70 */ 0x80, 0x90, 0x23, 0x0C, 0x08, 0x02, 0x87, 0x25, 0x7D, 0x5D, 0x04, 0x10, 0x05, 0x91, 0x01, 0x03,
/* 0B80 */ 0x67, 0x1D, 0x70, 0x62, 0x22, 0x50, 0x85, 0xD1, 0xD1, 0xD1, 0xD1, 0x10, 0x03, 0x91, 0x58, 0xA5,
/* 0B90 */ 0xAB, 0x10, 0x03, 0x91, 0x58, 0xA5, 0x1D, 0x1D, 0x0F, 0x52, 0x78, 0x26, 0x87, 0x3F, 0x84, 0x64,
/* 0BA0 */ 0x26, 0x10, 0x05, 0x91, 0x02, 0x06, 0x67, 0x1D, 0x36, 0x98, 0xB3, 0x9F, 0x22, 0x0F, 0x66, 0x31,
/* 0BB0 */ 0x70, 0x54, 0x22, 0x0F, 0x65, 0x25, 0x4B, 0x96, 0x10, 0x03, 0x91, 0x02, 0x05, 0x1F, 0x57, 0xAF,
/* 0BC0 */ 0xAF, 0xAF, 0x1B, 0x03, 0x24, 0x10, 0x08, 0xD6, 0x94, 0x9C, 0x64, 0x8F, 0x92, 0x0F, 0xA0, 0x4E,
/* 0BD0 */ 0x64, 0x4B, 0xA6, 0x64, 0x4B, 0xA6, 0x10, 0x05, 0xD6, 0x62, 0x22, 0x92, 0x9C, 0xD1, 0xD1, 0xD1,
/* 0BE0 */ 0xD1, 0x10, 0x05, 0x4D, 0xA7, 0x10, 0x05, 0xD6, 0x89, 0x22, 0x92, 0x96, 0x25, 0x4B, 0x4B, 0xBB,
/* 0BF0 */ 0x5D, 0xE9, 0x10, 0x05, 0x2E, 0x01, 0x96, 0x96, 0x6D, 0x4A, 0x83, 0x25, 0x1E, 0xB5, 0x83, 0x83,
/* 0C00 */ 0x20, 0xE0, 0xE0, 0x01, 0x03, 0x10, 0x04, 0xD6, 0x09, 0x31, 0x55, 0x02, 0x00, 0xD2, 0x59, 0x1D,
/* 0C10 */ 0x36, 0x10, 0x04, 0x2E, 0x03, 0x83, 0x4C, 0x0A, 0x8E, 0x06, 0x31, 0x70, 0x2A, 0x73, 0x54, 0x6D,
/* 0C20 */ 0x05, 0x09, 0x4E, 0x22, 0x0D, 0x61, 0x10, 0x04, 0x30, 0x01, 0x05, 0x01, 0xC5, 0x48, 0xF0, 0x88,
/* 0C30 */ 0x00, 0xB3, 0xC5, 0x21, 0x34, 0x88, 0x3F, 0x92, 0x01, 0x26, 0x0C, 0x89, 0x10, 0x05, 0x2E, 0x41,
/* 0C40 */ 0xBE, 0xB4, 0x10, 0x05, 0x2E, 0x44, 0x00, 0xB2, 0x0A, 0x0C, 0x01, 0x4A, 0x25, 0x6F, 0x63, 0x38,
/* 0C50 */ 0x99, 0x77, 0x18, 0x0E, 0x44, 0xE8, 0x4A, 0x10, 0x07, 0x2E, 0xA0, 0x05, 0x9F, 0x0A, 0x0B, 0x1F,
/* 0C60 */ 0x0B, 0x5A, 0x0F, 0x7E, 0x09, 0x64, 0xC1, 0x69, 0x0B, 0x08, 0x89, 0x1F, 0x06, 0x32, 0x07, 0x0B,
/* 0C70 */ 0x9F, 0x1F, 0x03, 0x3D, 0x80, 0x36, 0x1F, 0x29, 0x54, 0x3D, 0x10, 0x05, 0x2E, 0x0B, 0x84, 0x5E,
/* 0C80 */ 0x25, 0x03, 0x40, 0x0D, 0x18, 0x0B, 0x4A, 0x18, 0x43, 0x4C, 0x06, 0x92, 0x4E, 0x19, 0x9D, 0x0A,
/* 0C90 */ 0x01, 0x50, 0x10, 0x05, 0x2E, 0xDD, 0xB6, 0x10, 0x04, 0x2E, 0x0B, 0x75, 0x3A, 0xDB, 0x59, 0x88,
/* 0CA0 */ 0x3A, 0x24, 0xE8, 0x9F, 0x21, 0x43, 0x3D, 0x10, 0x03, 0x91, 0x01, 0x7F, 0xC5, 0x04, 0xC5, 0x52,
/* 0CB0 */ 0x4B, 0x18, 0x24, 0x18, 0xC1, 0x60, 0xC5, 0x52, 0x05, 0x36, 0xC5, 0x21, 0x71, 0x0E, 0x5C, 0x9B,
/* 0CC0 */ 0x10, 0x03, 0x91, 0x29, 0xAA, 0x26, 0x4A, 0x18, 0x29, 0xAA, 0x26, 0x4A, 0x10, 0x03, 0x91, 0x66,
/* 0CD0 */ 0x52, 0x05, 0x9F, 0x3B, 0x9F, 0x3B, 0x5E, 0x00, 0xE8, 0x0D, 0x00, 0x26, 0x92, 0x3B, 0x9F, 0x3B,
/* 0CE0 */ 0x9F, 0x18, 0x63, 0x2A, 0x87, 0x01, 0x3B, 0x10, 0x05, 0x45, 0x34, 0x61, 0x05, 0x48, 0x09, 0x06,
/* 0CF0 */ 0x43, 0x2A, 0x9B, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x13, 0x00, 0x2D, 0x00, 0x48, 0x00, 0x65,
/* 0D00 */ 0x00, 0x86, 0x00, 0x8F, 0x00, 0xB1, 0x00, 0xB5, 0x00, 0xE0, 0x00, 0xF9, 0x01, 0x14, 0x01, 0x20,
/* 0D10 */ 0x01, 0x29, 0x01, 0x47, 0x01, 0x4E, 0x01, 0x61, 0x01, 0x70, 0x01, 0x80, 0x01, 0x92, 0x01, 0x9B,
/* 0D20 */ 0x01, 0xB4, 0x01, 0xD3, 0x01, 0xDA, 0x01, 0xE8, 0x01, 0xF3, 0x02, 0x0B, 0x02, 0x25, 0x02, 0x36,
/* 0D30 */ 0x02, 0x57, 0x02, 0x77, 0x02, 0x8D, 0x02, 0x9A, 0x02, 0xA4, 0x02, 0xB1, 0x02, 0xBB, 0x02, 0xC7,
/* 0D40 */ 0x02, 0xD6, 0x02, 0xF9, 0x03, 0x0E, 0x03, 0x18, 0x03, 0x22, 0x03, 0x2E, 0x03, 0x38, 0x03, 0x44,
/* 0D50 */ 0x03, 0x4F, 0x03, 0x5A, 0x03, 0x63, 0x03, 0x87, 0x03, 0x95, 0x03, 0xA2, 0x03, 0xB0, 0x03, 0xBE,
/* 0D60 */ 0x03, 0xC9, 0x03, 0xD1, 0x03, 0xE3, 0x04, 0x10, 0x04, 0x1B, 0x04, 0x26, 0x04, 0x34, 0x04, 0x41,
/* 0D70 */ 0x04, 0x51, 0x04, 0x60, 0x04, 0x7C, 0x04, 0x88, 0x04, 0x94, 0x04, 0xA0, 0x04, 0xAB, 0x04, 0xB5,
/* 0D80 */ 0x04, 0xC5, 0x04, 0xE8, 0x04, 0xF7, 0x05, 0x02, 0x05, 0x0A, 0x05, 0x13, 0x05, 0x1D, 0x05, 0x29,
/* 0D90 */ 0x05, 0x34, 0x05, 0x3F, 0x05, 0x4A, 0x05, 0x6A, 0x05, 0x7B, 0x05, 0x84, 0x05, 0x90, 0x05, 0x9B,
/* 0DA0 */ 0x05, 0xA3, 0x05, 0xAC, 0x05, 0xB6, 0x05, 0xD6, 0x05, 0xE2, 0x05, 0xEA, 0x05, 0xF3, 0x05, 0xFE,
/* 0DB0 */ 0x06, 0x09, 0x06, 0x0F, 0x02, 0x00, 0x10, 0x02, 0x2E, 0x6A, 0x67, 0x5C, 0x64, 0x67, 0x0C, 0x20,
/* 0DC0 */ 0x6A, 0x20, 0x35, 0x20, 0xE0, 0x2D, 0x10, 0x04, 0x68, 0x7B, 0x3B, 0x62, 0x3A, 0x0E, 0x97, 0x38,
/* 0DD0 */ 0x78, 0x01, 0x27, 0x2D, 0x18, 0x09, 0x36, 0x01, 0x27, 0x80, 0x0E, 0x7B, 0x3A, 0x5E, 0x20, 0x7B,
/* 0DE0 */ 0x10, 0x05, 0x30, 0x79, 0x0D, 0x62, 0x27, 0x7F, 0x08, 0x06, 0x27, 0x92, 0x20, 0x92, 0xE8, 0x90,
/* 0DF0 */ 0x4E, 0x6B, 0x55, 0x48, 0x79, 0x92, 0x03, 0x38, 0x0C, 0x90, 0x50, 0x10, 0x05, 0x20, 0x68, 0x76,
/* 0E00 */ 0x48, 0x0A, 0x8A, 0x69, 0x19, 0x34, 0x7A, 0x81, 0x22, 0x0B, 0x00, 0x95, 0x25, 0x73, 0x01, 0x0C,
/* 0E10 */ 0x06, 0x57, 0x0F, 0x55, 0x6D, 0x9B, 0x01, 0x05, 0x10, 0x05, 0x30, 0x0D, 0x0A, 0x00, 0x4B, 0x1F,
/* 0E20 */ 0xC1, 0x60, 0x0B, 0x0A, 0x6B, 0x5E, 0x9F, 0x27, 0x96, 0x0D, 0x25, 0x34, 0x97, 0x94, 0xC7, 0x06,
/* 0E30 */ 0x25, 0x34, 0x90, 0x50, 0x19, 0x71, 0x05, 0x92, 0x02, 0x10, 0x03, 0x91, 0x29, 0xAA, 0x1F, 0x49,
/* 0E40 */ 0x29, 0xAA, 0x10, 0x05, 0x28, 0x09, 0x32, 0x48, 0x63, 0x93, 0x01, 0x6B, 0x32, 0x05, 0x25, 0x34,
/* 0E50 */ 0xA0, 0x4A, 0x22, 0x7A, 0x4F, 0x19, 0x71, 0x08, 0x0E, 0x54, 0x27, 0x03, 0x04, 0x9F, 0x25, 0x63,
/* 0E60 */ 0xEA, 0x01, 0x27, 0x9B, 0x10, 0x04, 0x30, 0xE4, 0x10, 0x07, 0x30, 0x72, 0x0B, 0x0F, 0x81, 0x19,
/* 0E70 */ 0x9D, 0x0A, 0x85, 0x84, 0x64, 0x79, 0x8B, 0x07, 0x04, 0x05, 0x09, 0x1F, 0x06, 0x07, 0x7B, 0x00,
/* 0E80 */ 0x03, 0x0B, 0x64, 0x34, 0x8B, 0x05, 0x02, 0x05, 0x09, 0x64, 0x71, 0x85, 0x5D, 0x7A, 0xCF, 0x97,
/* 0E90 */ 0x92, 0x3B, 0x01, 0x10, 0x05, 0x20, 0x68, 0x6E, 0x61, 0x26, 0x04, 0x77, 0x64, 0xCF, 0x0D, 0xEA,
/* 0EA0 */ 0x31, 0x0F, 0x83, 0x3B, 0x71, 0x27, 0x9B, 0x02, 0x38, 0xC1, 0x90, 0x88, 0x10, 0x06, 0x2E, 0x71,
/* 0EB0 */ 0x04, 0x79, 0x6C, 0x98, 0x04, 0x5E, 0x33, 0x9F, 0x85, 0x25, 0x1E, 0x99, 0x23, 0x01, 0x24, 0x07,
/* 0EC0 */ 0x4E, 0x00, 0xCF, 0x08, 0x00, 0x09, 0x03, 0x10, 0x05, 0x2F, 0x45, 0x47, 0x92, 0x6B, 0x5B, 0x8D,
/* 0ED0 */ 0x20, 0x09, 0x05, 0x10, 0x04, 0x2F, 0x45, 0x47, 0x05, 0x3A, 0x03, 0x9E, 0x10, 0x06, 0x30, 0xC1,
/* 0EE0 */ 0xD9, 0x00, 0xCF, 0x43, 0x87, 0x01, 0x19, 0x09, 0x05, 0x09, 0x5A, 0x05, 0x19, 0x09, 0x63, 0x95,
/* 0EF0 */ 0x05, 0x19, 0x53, 0x08, 0x77, 0x38, 0x3C, 0x92, 0x3B, 0x01, 0x10, 0x03, 0x30, 0x3C, 0x4E, 0x3A,
/* 0F00 */ 0x5B, 0x10, 0x05, 0x49, 0x46, 0x1C, 0x6C, 0xC1, 0x09, 0x95, 0x27, 0x09, 0x08, 0x09, 0x08, 0xC7,
/* 0F10 */ 0x7B, 0x00, 0x26, 0x01, 0x10, 0x05, 0x1F, 0x68, 0xC7, 0xC2, 0xC7, 0x52, 0x20, 0xC1, 0x90, 0x5E,
/* 0F20 */ 0x6B, 0x5B, 0x9E, 0x10, 0x04, 0x30, 0xDB, 0x3F, 0x05, 0x0F, 0x1B, 0x58, 0x18, 0x03, 0x62, 0x01,
/* 0F30 */ 0x00, 0x57, 0x9F, 0x10, 0x04, 0x49, 0xC4, 0x32, 0x18, 0x03, 0x05, 0x0F, 0x1B, 0x86, 0x26, 0x03,
/* 0F40 */ 0x7A, 0x00, 0x6D, 0x32, 0x01, 0x10, 0x03, 0xDC, 0x02, 0x74, 0x27, 0x34, 0x07, 0x01, 0x10, 0x05,
/* 0F50 */ 0x2E, 0x4B, 0xB2, 0x4B, 0xB2, 0x4B, 0xB2, 0x4B, 0xB2, 0x07, 0x4A, 0x85, 0x22, 0x0E, 0x0D, 0x87,
/* 0F60 */ 0x22, 0x0D, 0x71, 0x31, 0x0F, 0x46, 0x03, 0x10, 0x07, 0x30, 0xC1, 0x0E, 0x75, 0x76, 0x04, 0x75,
/* 0F70 */ 0x6F, 0x76, 0x06, 0x75, 0x99, 0x76, 0x03, 0x75, 0x99, 0x76, 0x34, 0x0B, 0x0F, 0x99, 0x48, 0xC3,
/* 0F80 */ 0xC3, 0xC3, 0xC3, 0x04, 0x7C, 0x7C, 0x10, 0x02, 0x18, 0x68, 0x2B, 0x5C, 0x6A, 0x10, 0x03, 0x2E,
/* 0F90 */ 0x45, 0x01, 0x0D, 0x52, 0x01, 0x09, 0x0A, 0x27, 0xC1, 0x50, 0x46, 0x10, 0x04, 0xE6, 0x64, 0x6D,
/* 0FA0 */ 0xE1, 0x53, 0x1F, 0x6D, 0x5C, 0x53, 0x10, 0x05, 0x68, 0x46, 0x0C, 0x61, 0x27, 0x77, 0x6F, 0x38,
/* 0FB0 */ 0x8B, 0x63, 0x48, 0x80, 0x40, 0x00, 0x26, 0x1B, 0x9B, 0x02, 0x42, 0x0A, 0x90, 0x88, 0x10, 0x06,
/* 0FC0 */ 0x2E, 0x01, 0x04, 0x34, 0x6C, 0x7D, 0x6E, 0x23, 0x9D, 0x81, 0x5E, 0x25, 0x0A, 0x0E, 0x65, 0xCF,
/* 0FD0 */ 0x5E, 0x98, 0x01, 0xCF, 0x08, 0x00, 0x09, 0x02, 0x10, 0x09, 0xE6, 0xD3, 0x53, 0xBD, 0x08, 0x06,
/* 0FE0 */ 0x76, 0x53, 0x01, 0x7B, 0x7B, 0x22, 0x09, 0x58, 0xBC, 0x10, 0x09, 0xE6, 0xD3, 0x53, 0xBD, 0x77,
/* 0FF0 */ 0x56, 0x64, 0x53, 0x01, 0x7C, 0x7E, 0x06, 0x33, 0x09, 0x72, 0x0D, 0x01, 0x64, 0x71, 0x7B, 0x01,
/* 1000 */ 0x8D, 0x02, 0x1F, 0x9A, 0x34, 0x0F, 0x92, 0x64, 0x8F, 0x03, 0x10, 0x09, 0x30, 0xDB, 0xD3, 0x03,
/* 1010 */ 0x05, 0x4E, 0x00, 0x95, 0x19, 0x86, 0x02, 0x54, 0x64, 0x71, 0x03, 0x7A, 0x09, 0x08, 0x06, 0x03,
/* 1020 */ 0x64, 0x06, 0x32, 0x02, 0x7B, 0x7B, 0x22, 0x09, 0x58, 0xBC, 0x10, 0x04, 0x2E, 0x79, 0x0E, 0x1B,
/* 1030 */ 0x03, 0x56, 0x37, 0xC4, 0x4E, 0x3A, 0x1C, 0x18, 0x96, 0x52, 0x87, 0x53, 0x6C, 0x04, 0x0D, 0x24,
/* 1040 */ 0x10, 0x05, 0x27, 0x26, 0x03, 0xC4, 0x61, 0xC5, 0x0F, 0x18, 0x1E, 0x3E, 0xA2, 0x10, 0x05, 0x18,
/* 1050 */ 0x26, 0x2A, 0x03, 0x9C, 0x59, 0xC6, 0xA2, 0x10, 0x05, 0x1A, 0x03, 0x24, 0x18, 0x0B, 0x53, 0x04,
/* 1060 */ 0x25, 0x34, 0xC6, 0xA2, 0x10, 0x05, 0x1A, 0x47, 0x21, 0x5B, 0x42, 0x34, 0xC6, 0xA2, 0x10, 0x05,
/* 1070 */ 0x1A, 0x8E, 0x0C, 0x06, 0x3A, 0x71, 0x27, 0x34, 0xC6, 0xA2, 0x10, 0x05, 0x64, 0x80, 0x4C, 0xC1,
/* 1080 */ 0x1E, 0xC5, 0x0B, 0xC5, 0x0D, 0x18, 0x1E, 0x3E, 0xA2, 0x10, 0x08, 0x68, 0x0E, 0xF3, 0x19, 0x99,
/* 1090 */ 0x44, 0x5B, 0x19, 0x35, 0x0A, 0x0A, 0x27, 0xA0, 0x8B, 0x6B, 0x4A, 0x07, 0x90, 0xF5, 0x8F, 0x75,
/* 10A0 */ 0x4E, 0x19, 0x0B, 0x84, 0x05, 0x4A, 0x9E, 0x71, 0x55, 0x71, 0x90, 0x4A, 0x10, 0x05, 0x28, 0x73,
/* 10B0 */ 0xD0, 0xA1, 0x02, 0x55, 0x04, 0x07, 0x27, 0x73, 0x70, 0x01, 0x27, 0x53, 0x52, 0x0C, 0x5E, 0x18,
/* 10C0 */ 0x9B, 0x10, 0x05, 0x19, 0x46, 0x1B, 0xC1, 0x89, 0x31, 0xCA, 0xCD, 0x10, 0x05, 0x25, 0x46, 0x1B,
/* 10D0 */ 0x06, 0x61, 0x31, 0xCA, 0xCD, 0x10, 0x05, 0x18, 0x6D, 0x4A, 0x26, 0x0C, 0x58, 0x01, 0x22, 0xCA,
/* 10E0 */ 0xCD, 0x10, 0x05, 0x1F, 0x46, 0x7B, 0x7C, 0xD7, 0x31, 0xCA, 0xCD, 0x10, 0x03, 0x2F, 0x9E, 0x00,
/* 10F0 */ 0xE8, 0x8E, 0x64, 0xB3, 0x64, 0xD2, 0xAD, 0x10, 0x03, 0x1A, 0x9E, 0x27, 0xC1, 0x89, 0x18, 0x0B,
/* 1100 */ 0xBF, 0xAD, 0x10, 0x03, 0x2F, 0x09, 0x9F, 0x27, 0x03, 0x0B, 0x58, 0x51, 0xAD, 0x10, 0x03, 0x64,
/* 1110 */ 0xC4, 0x84, 0x54, 0xD7, 0x51, 0xAD, 0x10, 0x06, 0x30, 0x04, 0x90, 0x8D, 0x00, 0xCF, 0x92, 0x08,
/* 1120 */ 0x5E, 0xCF, 0x5E, 0x00, 0x44, 0x1F, 0x34, 0x5E, 0x00, 0x9C, 0x19, 0x43, 0x4A, 0x1C, 0x19, 0x06,
/* 1130 */ 0x92, 0x01, 0x70, 0xCF, 0x92, 0x09, 0x5E, 0xCF, 0x90, 0x4F, 0x10, 0x06, 0x1A, 0x63, 0x92, 0x3A,
/* 1140 */ 0x5B, 0x31, 0x70, 0xB8, 0x43, 0x80, 0xAE, 0xBA, 0x10, 0x06, 0x27, 0x3F, 0x37, 0x1C, 0x42, 0x7D,
/* 1150 */ 0x40, 0x6B, 0x55, 0xA4, 0xB0, 0x10, 0x06, 0x18, 0x3F, 0x00, 0xE8, 0x0E, 0x21, 0x6F, 0x55, 0x6B,
/* 1160 */ 0x55, 0xA4, 0xB0, 0x10, 0x06, 0x00, 0x1A, 0x96, 0x42, 0x06, 0x09, 0x07, 0x0A, 0x27, 0xA9, 0xA4,
/* 1170 */ 0xB0, 0x10, 0x06, 0x1A, 0x80, 0x55, 0x3A, 0x03, 0x2A, 0xA9, 0xA4, 0xB0, 0x10, 0x06, 0x1A, 0xE4,
/* 1180 */ 0x27, 0xA9, 0xA4, 0xB0, 0x10, 0x05, 0x45, 0x79, 0x0B, 0x8C, 0x6C, 0x01, 0x0C, 0x55, 0x26, 0x8A,
/* 1190 */ 0x2C, 0x79, 0x09, 0x02, 0x0B, 0x01, 0x10, 0x06, 0x64, 0x1A, 0x9B, 0xC4, 0x0E, 0x27, 0x7D, 0xEA,
/* 11A0 */ 0x6B, 0x0F, 0x8B, 0x50, 0x19, 0x78, 0x7F, 0x0D, 0x19, 0x0A, 0x7B, 0x0A, 0x3C, 0x19, 0x0A, 0x62,
/* 11B0 */ 0x9A, 0x0E, 0x1F, 0xC1, 0x55, 0x03, 0x98, 0x19, 0x99, 0x62, 0x92, 0x25, 0x09, 0x3D, 0x4C, 0x09,
/* 11C0 */ 0x0A, 0x20, 0x9B, 0x10, 0x06, 0x27, 0x3F, 0x46, 0x85, 0x6C, 0x78, 0x08, 0x92, 0xAC, 0x10, 0x06,
/* 11D0 */ 0x18, 0x3F, 0x3B, 0x87, 0x6C, 0x08, 0x5E, 0x65, 0xAC, 0x10, 0x06, 0x27, 0x26, 0x1C, 0x6C, 0xC1,
/* 11E0 */ 0x07, 0x09, 0x07, 0x25, 0x78, 0x65, 0xAC, 0x10, 0x06, 0x1A, 0x5A, 0x09, 0x09, 0x26, 0x01, 0x01,
/* 11F0 */ 0x6C, 0x78, 0x65, 0xAC, 0x10, 0x05, 0x18, 0x26, 0x03, 0x3F, 0x9C, 0x25, 0x9D, 0x7C, 0x05, 0x5E,
/* 1200 */ 0x19, 0xD5, 0xB9, 0x50, 0x10, 0x05, 0x2B, 0xBF, 0x59, 0x90, 0x4F, 0xB3, 0x0B, 0x4E, 0x33, 0x4E,
/* 1210 */ 0xC8, 0x05, 0x01, 0x10, 0x06, 0x28, 0x0A, 0x32, 0x48, 0x05, 0x92, 0x61, 0xD2, 0x7A, 0x22, 0x0F,
/* 1220 */ 0x35, 0x31, 0x0F, 0x63, 0x2C, 0x4B, 0x07, 0x9F, 0x33, 0x4E, 0x07, 0x9F, 0x33, 0x4A, 0x44, 0x10,
/* 1230 */ 0x05, 0x91, 0x71, 0x37, 0x35, 0x76, 0x6D, 0x07, 0x27, 0xE3, 0xA8, 0x10, 0x05, 0x49, 0x01, 0x01,
/* 1240 */ 0x3F, 0x8D, 0x59, 0x05, 0x18, 0xE3, 0xA8, 0x10, 0x05, 0x25, 0x1A, 0xB3, 0x26, 0x0C, 0x73, 0x52,
/* 1250 */ 0x20, 0xE3, 0xA8, 0x10, 0x05, 0x28, 0x0C, 0xEA, 0x26, 0x03, 0x9E, 0x27, 0xE3, 0xA8, 0x10, 0x05,
/* 1260 */ 0x30, 0x03, 0x7C, 0x7B, 0xD7, 0x27, 0xE3, 0xA8, 0x10, 0x05, 0x19, 0x67, 0x62, 0x18, 0x0C, 0x08,
/* 1270 */ 0x0B, 0x18, 0x09, 0x92, 0x20, 0x1B, 0xE3, 0xA8, 0x10, 0x08, 0x2E, 0x6E, 0x24, 0x0B, 0x24, 0x64,
/* 1280 */ 0x71, 0x05, 0x05, 0x5D, 0x05, 0x5E, 0x64, 0x8C, 0xF3, 0x92, 0x64, 0x0A, 0x7A, 0x44, 0x03, 0x9E,
/* 1290 */ 0x64, 0x96, 0x6F, 0x8E, 0x08, 0x1F, 0xDB, 0x04, 0x0B, 0x85, 0x01, 0x10, 0x04, 0xB7, 0x64, 0xB3,
/* 12A0 */ 0x05, 0xE8, 0xEA, 0x1B, 0x7A, 0x20, 0x73, 0xC5, 0x0A, 0x46, 0x10, 0x05, 0xDC, 0x00, 0x06, 0x81,
/* 12B0 */ 0xC4, 0x08, 0xE8, 0xC0, 0xD9, 0x10, 0x05, 0x49, 0xE2, 0x64, 0x0A, 0xC0, 0xD9, 0x10, 0x05, 0x91,
/* 12C0 */ 0x34, 0xD8, 0x64, 0xE8, 0xC0, 0xD9, 0x10, 0x05, 0x49, 0x46, 0x7C, 0x7A, 0xD7, 0xE8, 0xC0, 0xD9,
/* 12D0 */ 0x10, 0x03, 0x91, 0x01, 0x37, 0x74, 0x42, 0x71, 0x07, 0x05, 0x59, 0xAB, 0x10, 0x03, 0x91, 0x71,
/* 12E0 */ 0xC4, 0x7A, 0x18, 0x09, 0x04, 0x67, 0xAB, 0x10, 0x03, 0x91, 0x1E, 0x48, 0x79, 0x0B, 0x7E, 0x37,
/* 12F0 */ 0x67, 0xAB, 0x10, 0x03, 0x18, 0x49, 0x7E, 0x04, 0x60, 0x26, 0x72, 0x59, 0xAB, 0x10, 0x05, 0x49,
/* 1300 */ 0x9B, 0x3A, 0x0D, 0xE7, 0x0C, 0x5D, 0x01, 0x27, 0x5B, 0x50, 0x19, 0x71, 0x83, 0x32, 0x57, 0x04,
/* 1310 */ 0x83, 0x25, 0x0A, 0x0D, 0x00, 0x1E, 0x57, 0x05, 0xB2, 0x01, 0x0B, 0x5D, 0x02, 0x10, 0x05, 0x28,
/* 1320 */ 0x47, 0x42, 0x03, 0x82, 0x31, 0x44, 0x62, 0x22, 0x92, 0x9C, 0xD1, 0xD1, 0xD1, 0xD1, 0x10, 0x05,
/* 1330 */ 0xDC, 0x34, 0x62, 0x00, 0x3F, 0x5F, 0xA7, 0x10, 0x05, 0x49, 0x71, 0x3B, 0x0B, 0x0A, 0x27, 0x34,
/* 1340 */ 0x07, 0x52, 0xA7, 0x10, 0x05, 0x00, 0x91, 0x63, 0x5F, 0x0C, 0x58, 0x48, 0x2F, 0xA7, 0x10, 0x05,
/* 1350 */ 0x28, 0x47, 0x42, 0x5B, 0x1B, 0xA7, 0x10, 0x05, 0x30, 0x01, 0x7C, 0x81, 0xD7, 0x18, 0xA7, 0x10,
/* 1360 */ 0x05, 0x37, 0x68, 0xDE, 0x19, 0x1A, 0xA3, 0x27, 0xDE, 0x10, 0x05, 0x68, 0x72, 0x37, 0x7A, 0x27,
/* 1370 */ 0x1E, 0x88, 0x6D, 0x61, 0x32, 0x25, 0x0A, 0x0B, 0x08, 0x09, 0x0F, 0x25, 0x0A, 0x74, 0x6F, 0x22,
/* 1380 */ 0x85, 0x98, 0x19, 0x71, 0x0D, 0x5D, 0x42, 0x7A, 0x46, 0x10, 0x05, 0xDC, 0x00, 0x06, 0x8E, 0xC4,
/* 1390 */ 0x08, 0x00, 0x57, 0xBE, 0xB4, 0x10, 0x05, 0x49, 0xE2, 0x00, 0x41, 0xBE, 0xB4, 0x10, 0x05, 0x91,
/* 13A0 */ 0x34, 0xD8, 0x1F, 0x57, 0xBE, 0xB4, 0x10, 0x05, 0x49, 0x46, 0x7C, 0x7A, 0xD7, 0x00, 0x57, 0xBE,
/* 13B0 */ 0xB4, 0x10, 0x05, 0xDC, 0x34, 0x89, 0x27, 0xC1, 0x05, 0x18, 0xDD, 0xB6, 0x10, 0x05, 0xCC, 0xBB,
/* 13C0 */ 0x40, 0xE9, 0x10, 0x05, 0x30, 0x04, 0x84, 0x54, 0xD7, 0x27, 0xDD, 0xB6, 0x10, 0x00, 0x00, 0x00,
/* 13D0 */ 0x0B, 0x00, 0x15, 0x00, 0x0B, 0x05, 0x2F, 0x45, 0x0D, 0x90, 0x3D, 0x25, 0x03, 0x5B, 0x5B, 0x10,
/* 13E0 */ 0x05, 0x2F, 0x45, 0x0C, 0x90, 0x50, 0x6B, 0x5B, 0x82, 0x10, 0x07, 0x2F, 0x45, 0x0C, 0x0F, 0xF3,
/* 13F0 */ 0x36, 0x00, 0x72, 0x5B, 0x5B, 0x5B, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00,
/* 1400 */ 0x00, 0x05, 0x2D, 0x00, 0x00, 0x05, 0x2F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00,
/* 1410 */ 0x00, 0x05, 0x32, 0x00, 0x00, 0x05, 0xF0, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00,
/* 1420 */ 0x00, 0x0C, 0xF4, 0x00, 0x00, 0x0D, 0xB4, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00,
/* 1430 */ 0x00, 0x13, 0xCD, 0x00, 0x00, 0x13, 0xD5,

409
contrib/mcufont/fonts/FiraSansCondensed-Bold12.mcufont.h Normal file
View file

@ -0,0 +1,409 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 12
* blob size: 6180, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0x87, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00, 0x00, 0x90,
/* 0020 */ 0x00, 0x00, 0x00, 0xDA, 0x00, 0x00, 0x17, 0xE4, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x0C, 0x00, 0x11, 0x00, 0x03, 0x00, 0x0B, 0x00, 0x01, 0x00, 0x0D, 0x00, 0x0E, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x32, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x31, 0x32, 0x00,
/* dictionary data */
0x40, 0x15, 0x07, 0x27, 0x0F, 0x09, 0x25, 0xC6, 0x02, 0x02, 0x40,
/* 0080 */ 0x09, 0xC5, 0x09, 0xC2, 0x09, 0xC1, 0xC3, 0xC1, 0xC8, 0x31, 0x08, 0xC4, 0x04, 0x80, 0xC4, 0xCE,
/* 0090 */ 0xCC, 0x1A, 0xC5, 0x80, 0xC9, 0x01, 0x05, 0x06, 0xC9, 0xC6, 0x80, 0xC9, 0xC1, 0x08, 0xC2, 0x07,
/* 00A0 */ 0xC1, 0x07, 0xC3, 0xCD, 0x0A, 0xC5, 0x06, 0x0D, 0x07, 0xC7, 0x80, 0x06, 0x06, 0xC4, 0x01, 0xCE,
/* 00B0 */ 0xC1, 0x81, 0xC5, 0x82, 0x07, 0xC9, 0x80, 0xC3, 0x80, 0xC2, 0x06, 0xC3, 0xC1, 0xCA, 0xCB, 0xCE,
/* 00C0 */ 0x08, 0xCA, 0xC1, 0x08, 0xC5, 0x81, 0x40, 0x0A, 0xC2, 0x80, 0xCB, 0xC7, 0xCC, 0xC3, 0x80, 0xC6,
/* 00D0 */ 0x80, 0xC6, 0xC4, 0xCC, 0x80, 0x01, 0xCD, 0x80, 0xC8, 0x01, 0xC1, 0xC6, 0xCD, 0xCE, 0xD7, 0xC2,
/* 00E0 */ 0x03, 0xCB, 0x80, 0xC8, 0x80, 0xC4, 0x09, 0xC9, 0x05, 0x06, 0xC8, 0x80, 0xCE, 0xCB, 0xC1, 0xCE,
/* 00F0 */ 0x08, 0xC5, 0x80, 0xC9, 0x09, 0xF5, 0x06, 0xC5, 0x03, 0x80, 0xCD, 0xD5, 0xC3, 0x09, 0xC2, 0xC1,
/* 0100 */ 0x02, 0xC3, 0xC1, 0xD2, 0xDD, 0xC8, 0x80, 0xCA, 0x07, 0xD2, 0x03, 0xC3, 0x01, 0xCA, 0x01, 0xC5,
/* 0110 */ 0xCD, 0xCC, 0x80, 0xC6, 0xCE, 0x06, 0xC9, 0x80, 0xC4, 0xCC, 0xCE, 0xC1, 0xC5, 0xC2, 0x08, 0xCD,
/* 0120 */ 0xCE, 0x01, 0xCC, 0x80, 0xC7, 0x80, 0xC1, 0x05, 0x09, 0xC1, 0x80, 0xCB, 0xC1, 0x06, 0xCC, 0xC6,
/* 0130 */ 0xC6, 0x80, 0xC8, 0x05, 0xC7, 0x80, 0xC7, 0x01, 0xC8, 0xCD, 0xC1, 0x01, 0xC6, 0x80, 0x01, 0xC3,
/* 0140 */ 0xCD, 0x80, 0xC5, 0xCD, 0xC2, 0xCE, 0xCE, 0xCD, 0x80, 0xC5, 0xC9, 0xCC, 0x05, 0xC5, 0x80, 0xC9,
/* 0150 */ 0xC3, 0xC3, 0xC1, 0xC7, 0xCE, 0xCA, 0x80, 0xCE, 0xCA, 0x80, 0xC1, 0xCC, 0xCD, 0x82, 0xC2, 0xCC,
/* 0160 */ 0xC7, 0x07, 0xC7, 0x80, 0xC8, 0xCE, 0xCE, 0xC4, 0xD9, 0x80, 0xCA, 0xC6, 0xCE, 0xCA, 0xC4, 0xCE,
/* 0170 */ 0xC9, 0x01, 0xC7, 0x01, 0xC6, 0xCD, 0xC9, 0x32, 0xC6, 0x80, 0xC7, 0xC9, 0xCB, 0x80, 0xCC, 0xC4,
/* 0180 */ 0xCC, 0x80, 0xC9, 0x01, 0xC8, 0x01, 0xC2, 0xC2, 0xCB, 0x80, 0xC5, 0xCE, 0xC8, 0xCB, 0xC9, 0x80,
/* 0190 */ 0xC5, 0x80, 0xCB, 0x80, 0xCE, 0xDC, 0xCE, 0xC8, 0x2B, 0x57, 0x2B, 0x57, 0x03, 0x37, 0x7A, 0x87,
/* 01A0 */ 0x91, 0x37, 0x76, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47, 0x37, 0x99, 0x47,
/* 01B0 */ 0x72, 0x5B, 0x72, 0x5B, 0x1C, 0x85, 0x5D, 0x52, 0xA1, 0x1C, 0x9E, 0x08, 0x00, 0x31, 0x28, 0x37,
/* 01C0 */ 0xA4, 0x07, 0x07, 0x74, 0x2B, 0x44, 0x9D, 0x02, 0x30, 0x3B, 0x0D, 0x19, 0xA4, 0x05, 0x04, 0x19,
/* 01D0 */ 0x2B, 0x42, 0xA4, 0x50, 0x5A, 0x3B, 0x80, 0x19, 0x1A, 0x02, 0x41, 0xA7, 0x19, 0x40, 0x07, 0x0D,
/* 01E0 */ 0x3D, 0x19, 0x4E, 0xA3, 0x34, 0x8B, 0x8A, 0x34, 0x0A, 0x4D, 0x86, 0x34, 0x86, 0x81, 0x70, 0x3F,
/* 01F0 */ 0x6E, 0x06, 0x9D, 0x5A, 0x99, 0x04, 0x4D, 0x00, 0x3F, 0x73, 0xA3, 0x34, 0x08, 0x80, 0x03, 0x91,
/* 0200 */ 0x2D, 0x8A, 0x9B, 0x54, 0x08, 0x5C, 0x04, 0x3F, 0x9B, 0x07, 0x0B, 0x30, 0x06, 0x0D, 0x9D, 0x37,
/* 0210 */ 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x37, 0x4A, 0x9D, 0x59, 0x91, 0x86, 0x53, 0x4E,
/* 0220 */ 0x0C, 0xA7, 0x01, 0x7C, 0xA2, 0x4D, 0x2C, 0x2E, 0x00, 0x4F, 0x43, 0x3F, 0x9B, 0xA3, 0x53, 0x9E,
/* 0230 */ 0x80, 0x39, 0x6A, 0x4C, 0x71, 0x08, 0x80, 0x39, 0x0E, 0x3F, 0x9B, 0x09, 0x9D, 0x19, 0x4F, 0x43,
/* 0240 */ 0x52, 0x85, 0x5D, 0x03, 0x02, 0x4D, 0x82, 0x70, 0x02, 0x4D, 0x82, 0x0D, 0x0B, 0x02, 0x4D, 0x2C,
/* 0250 */ 0xA4, 0x3D, 0x4D, 0x82, 0x07, 0x70, 0x4D, 0x82, 0x7D, 0x0B, 0x4D, 0x82, 0x05, 0x09, 0x0E, 0x4D,
/* 0260 */ 0x82, 0x5C, 0x0F, 0x4D, 0x82, 0x05, 0x3A, 0x08, 0x9B, 0x03, 0x4D, 0x19, 0xA3, 0x86, 0x30, 0x49,
/* 0270 */ 0x73, 0x1C, 0x4B, 0x21, 0x51, 0x5D, 0x51, 0x5D, 0x0B, 0x3D, 0x0B, 0x5E, 0x54, 0x45, 0x28, 0x2C,
/* 0280 */ 0x9F, 0x05, 0x55, 0x05, 0x31, 0x4C, 0x33, 0x61, 0x33, 0x61, 0x33, 0x61, 0x33, 0x61, 0x33, 0x07,
/* 0290 */ 0x00, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x77, 0x76, 0x2C, 0x76, 0x95, 0x70,
/* 02A0 */ 0x27, 0x9F, 0xA5, 0x8E, 0x3D, 0x59, 0x0C, 0x5B, 0x34, 0x33, 0x0E, 0x7B, 0x91, 0x37, 0x0B, 0x88,
/* 02B0 */ 0x06, 0x69, 0x2C, 0x95, 0x28, 0x09, 0x3E, 0x3F, 0x69, 0x0B, 0x62, 0x1E, 0x01, 0x27, 0x48, 0x95,
/* 02C0 */ 0x45, 0x69, 0x5A, 0x39, 0x05, 0x9F, 0x05, 0x8E, 0x02, 0x65, 0x0C, 0x19, 0x1C, 0x99, 0x1C, 0x99,
/* 02D0 */ 0x55, 0x22, 0x0A, 0x42, 0x00, 0x04, 0x49, 0x8C, 0x0B, 0x0D, 0x0A, 0x02, 0x26, 0x7F, 0x04, 0x19,
/* 02E0 */ 0x4E, 0x21, 0x1F, 0x04, 0x0A, 0x06, 0x01, 0xA5, 0x2C, 0xA3, 0x1E, 0x0D, 0x3E, 0x27, 0xA3, 0x1E,
/* 02F0 */ 0x0C, 0x3D, 0x27, 0xA3, 0x1E, 0x0D, 0x88, 0x27, 0x2E, 0x4E, 0xA5, 0x2C, 0x56, 0x0F, 0xA2, 0x70,
/* 0300 */ 0x3F, 0x51, 0xA7, 0x42, 0x79, 0x2F, 0x62, 0x7E, 0x63, 0x23, 0x7B, 0x5A, 0x4E, 0x08, 0x80, 0x19,
/* 0310 */ 0x60, 0x64, 0x1C, 0x86, 0x03, 0x08, 0x21, 0x99, 0x1C, 0x99, 0x42, 0x96, 0x91, 0x40, 0x28, 0x1F,
/* 0320 */ 0x9C, 0x5A, 0x67, 0x0A, 0x28, 0x1F, 0x0B, 0x53, 0x01, 0x28, 0x00, 0x19, 0x84, 0x23, 0x27, 0x1B,
/* 0330 */ 0x0E, 0x1C, 0x39, 0x2A, 0x01, 0x1F, 0x31, 0x2A, 0x02, 0x33, 0x99, 0x1C, 0xA1, 0x06, 0x37, 0x1B,
/* 0340 */ 0x99, 0x5A, 0x3F, 0x05, 0x45, 0x02, 0x9E, 0x69, 0x77, 0x6D, 0x0B, 0x0C, 0x0A, 0x0D, 0x79, 0x04,
/* 0350 */ 0x37, 0x7A, 0xA7, 0x9B, 0x37, 0x99, 0x4C, 0x71, 0x99, 0x6F, 0x3E, 0x2C, 0x99, 0x4C, 0x71, 0x7A,
/* 0360 */ 0x97, 0x73, 0x2C, 0x96, 0x73, 0x7F, 0x03, 0x37, 0x99, 0x1C, 0x99, 0x42, 0x2C, 0x2B, 0x09, 0xA5,
/* 0370 */ 0x54, 0x06, 0x39, 0x6A, 0x39, 0x0E, 0x54, 0x05, 0x39, 0x0E, 0x38, 0x9B, 0x09, 0xA5, 0x0E, 0x01,
/* 0380 */ 0x2C, 0x03, 0x9D, 0x37, 0x99, 0x09, 0x88, 0x5D, 0x62, 0x5D, 0x62, 0x5D, 0x62, 0x5D, 0x37, 0x4E,
/* 0390 */ 0x01, 0x33, 0x33, 0xA5, 0x33, 0xA5, 0x33, 0xA5, 0x73, 0x42, 0x9B, 0x37, 0x2F, 0x66, 0x88, 0x06,
/* 03A0 */ 0x80, 0x08, 0x26, 0x0F, 0x9B, 0x1F, 0x54, 0x86, 0x31, 0x0B, 0x0D, 0x06, 0x28, 0x2C, 0x4E, 0x73,
/* 03B0 */ 0x04, 0x4D, 0x38, 0x0F, 0x83, 0x9B, 0x54, 0x8A, 0x71, 0x0B, 0x69, 0x05, 0x0B, 0x28, 0x2C, 0xA5,
/* 03C0 */ 0x00, 0x95, 0x4D, 0x37, 0x1F, 0x3F, 0x37, 0x7A, 0xA0, 0xA7, 0x37, 0x0D, 0x0A, 0x03, 0x37, 0xA4,
/* 03D0 */ 0x37, 0x8D, 0x09, 0x28, 0x1F, 0x3C, 0x28, 0x1C, 0xA3, 0x04, 0x31, 0x0B, 0x8A, 0x07, 0x3D, 0x1E,
/* 03E0 */ 0x36, 0x1E, 0x36, 0x02, 0x0D, 0x08, 0x8A, 0x0D, 0x42, 0x94, 0x94, 0x42, 0x41, 0x69, 0x19, 0x95,
/* 03F0 */ 0x45, 0x30, 0x4E, 0x61, 0x42, 0x9C, 0x69, 0x19, 0x95, 0x0D, 0x07, 0x5A,
/* dictionary offset */
0x00, 0x00, 0x00, 0x02,
/* 0400 */ 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0C,
/* 0410 */ 0x00, 0x0E, 0x00, 0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x15, 0x00, 0x17, 0x00, 0x18, 0x00, 0x1A,
/* 0420 */ 0x00, 0x1C, 0x00, 0x1D, 0x00, 0x21, 0x00, 0x22, 0x00, 0x24, 0x00, 0x27, 0x00, 0x29, 0x00, 0x2B,
/* 0430 */ 0x00, 0x2D, 0x00, 0x2F, 0x00, 0x30, 0x00, 0x32, 0x00, 0x33, 0x00, 0x36, 0x00, 0x37, 0x00, 0x39,
/* 0440 */ 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x41, 0x00, 0x43, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49,
/* 0450 */ 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x4E, 0x00, 0x50, 0x00, 0x51, 0x00, 0x53, 0x00, 0x56, 0x00, 0x58,
/* 0460 */ 0x00, 0x5A, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x64, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6C,
/* 0470 */ 0x00, 0x6E, 0x00, 0x72, 0x00, 0x74, 0x00, 0x77, 0x00, 0x79, 0x00, 0x7B, 0x00, 0x80, 0x00, 0x81,
/* 0480 */ 0x00, 0x83, 0x00, 0x84, 0x00, 0x86, 0x00, 0x87, 0x00, 0x89, 0x00, 0x8B, 0x00, 0x8D, 0x00, 0x8F,
/* 0490 */ 0x00, 0x90, 0x00, 0x92, 0x00, 0x94, 0x00, 0x95, 0x00, 0x97, 0x00, 0x99, 0x00, 0x9B, 0x00, 0x9D,
/* 04A0 */ 0x00, 0x9F, 0x00, 0xA4, 0x00, 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xB0,
/* 04B0 */ 0x00, 0xB3, 0x00, 0xB5, 0x00, 0xB7, 0x00, 0xB9, 0x00, 0xBB, 0x00, 0xBE, 0x00, 0xC3, 0x00, 0xC5,
/* 04C0 */ 0x00, 0xC7, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5,
/* 04D0 */ 0x00, 0xD7, 0x00, 0xDA, 0x00, 0xDC, 0x00, 0xDE, 0x00, 0xE0, 0x00, 0xE2, 0x00, 0xE4, 0x00, 0xE6,
/* 04E0 */ 0x00, 0xE8, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00, 0xF3, 0x00, 0xF4,
/* 04F0 */ 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01, 0x02, 0x01, 0x03,
/* 0500 */ 0x01, 0x06, 0x01, 0x08, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x15,
/* 0510 */ 0x01, 0x17, 0x01, 0x19, 0x01, 0x1B, 0x01, 0x1E, 0x01, 0x20, 0x01, 0x21, 0x01, 0x23, 0x01, 0x27,
/* 0520 */ 0x01, 0x3B, 0x01, 0x3F, 0x01, 0x47, 0x01, 0x49, 0x01, 0x64, 0x01, 0x7D, 0x01, 0x82, 0x01, 0x99,
/* 0530 */ 0x01, 0xAD, 0x01, 0xB4, 0x01, 0xCB, 0x01, 0xCE, 0x01, 0xF3, 0x02, 0x05, 0x02, 0x11, 0x02, 0x1A,
/* 0540 */ 0x02, 0x35, 0x02, 0x45, 0x02, 0x47, 0x02, 0x57, 0x02, 0x5B, 0x02, 0x5D, 0x02, 0x5F, 0x02, 0x61,
/* 0550 */ 0x02, 0x65, 0x02, 0x6D, 0x02, 0x6F, 0x02, 0x71, 0x02, 0x8F, 0x02, 0x96, 0x02, 0x98, 0x02, 0x9B,
/* 0560 */ 0x02, 0x9D, 0x02, 0x9F, 0x02, 0xA8, 0x02, 0xB6, 0x02, 0xBB, 0x02, 0xBE, 0x02, 0xC2, 0x02, 0xCC,
/* 0570 */ 0x02, 0xCE, 0x02, 0xD0, 0x02, 0xD4, 0x02, 0xDA, 0x02, 0xF7, 0x02, 0xF9, 0x03, 0x09, 0x03, 0x0C,
/* 0580 */ 0x03, 0x10, 0x03, 0x12, 0x03, 0x19, 0x03, 0x1B, 0x03, 0x1D, 0x03, 0x23, 0x03, 0x25, 0x03, 0x27,
/* 0590 */ 0x03, 0x2A, 0x03, 0x2C, 0x03, 0x4F, 0x03, 0x51, 0x03, 0x53, 0x03, 0x56, 0x03, 0x58, 0x03, 0x5B,
/* 05A0 */ 0x03, 0x5D, 0x03, 0x64, 0x03, 0x66, 0x03, 0x68, 0x03, 0x6A, 0x03, 0x6E, 0x03, 0x70, 0x03, 0x72,
/* 05B0 */ 0x03, 0x87,
/* char range info */
0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x15, 0x00, 0x28, 0x00,
/* 05C0 */ 0x4A, 0x00, 0x72, 0x00, 0xAE, 0x00, 0xD9, 0x00, 0xE4, 0x01, 0x02, 0x01, 0x20, 0x01, 0x34, 0x01,
/* 05D0 */ 0x3D, 0x01, 0x42, 0x01, 0x4C, 0x01, 0x52, 0x01, 0x70, 0x01, 0x95, 0x01, 0xA9, 0x01, 0xCA, 0x01,
/* 05E0 */ 0xEA, 0x02, 0x07, 0x02, 0x28, 0x02, 0x4D, 0x02, 0x69, 0x02, 0x8D, 0x02, 0xB0, 0x02, 0xB8, 0x02,
/* 05F0 */ 0xBF, 0x02, 0xD6, 0x02, 0xE9, 0x03, 0x01, 0x03, 0x1B, 0x03, 0x66, 0x03, 0x6B, 0x03, 0x8A, 0x03,
/* 0600 */ 0xAB, 0x03, 0xCC, 0x03, 0xD1, 0x03, 0xE9, 0x04, 0x11, 0x04, 0x30, 0x04, 0x36, 0x04, 0x45, 0x04,
/* 0610 */ 0x66, 0x04, 0x74, 0x04, 0xAC, 0x04, 0xB1, 0x04, 0xB7, 0x04, 0xD2, 0x04, 0xFC, 0x05, 0x1F, 0x05,
/* 0620 */ 0x41, 0x05, 0x50, 0x05, 0x55, 0x05, 0x7B, 0x05, 0xB3, 0x05, 0xD6, 0x05, 0xDF, 0x05, 0xFF, 0x06,
/* 0630 */ 0x1A, 0x06, 0x39, 0x06, 0x51, 0x06, 0x62, 0x06, 0x71, 0x06, 0x7D, 0x06, 0x82, 0x06, 0x9B, 0x06,
/* 0640 */ 0xB2, 0x06, 0xC6, 0x06, 0xCD, 0x06, 0xE9, 0x07, 0x18, 0x07, 0x23, 0x07, 0x29, 0x07, 0x36, 0x07,
/* 0650 */ 0x55, 0x07, 0x66, 0x07, 0x82, 0x07, 0x88, 0x07, 0x8C, 0x07, 0x95, 0x07, 0xA7, 0x07, 0xB5, 0x07,
/* 0660 */ 0xD0, 0x07, 0xED, 0x07, 0xF3, 0x08, 0x0F, 0x08, 0x37, 0x08, 0x52, 0x08, 0x58, 0x08, 0x71, 0x08,
/* 0670 */ 0x94, 0x08, 0x9E, 0x08, 0xBF, 0x03, 0x00, 0x10, 0x03, 0x25, 0xA3, 0x21, 0x52, 0x52, 0xED, 0x5A,
/* 0680 */ 0xE5, 0x6D, 0x96, 0x3E, 0x33, 0xDD, 0x52, 0x92, 0x03, 0x10, 0x05, 0x25, 0x07, 0x3E, 0x4D, 0x37,
/* 0690 */ 0x96, 0x88, 0x70, 0x1F, 0x82, 0x39, 0x06, 0x00, 0x38, 0x0E, 0x4C, 0x06, 0x10, 0x06, 0x25, 0x95,
/* 06A0 */ 0xFD, 0xA7, 0x3C, 0x0D, 0x01, 0x69, 0xE9, 0x45, 0xA5, 0x3F, 0x29, 0xA3, 0x8C, 0xA7, 0x06, 0x71,
/* 06B0 */ 0x9F, 0x70, 0x09, 0xD8, 0x4C, 0x8A, 0x4D, 0xE9, 0x06, 0x68, 0x02, 0xE9, 0x01, 0x94, 0x10, 0x06,
/* 06C0 */ 0x1A, 0x9A, 0x1C, 0x66, 0x0C, 0x31, 0xEF, 0x45, 0x8F, 0x54, 0x07, 0x24, 0x01, 0x2D, 0x9D, 0x01,
/* 06D0 */ 0xE4, 0x0E, 0xA5, 0x8C, 0x9F, 0xA3, 0x70, 0x00, 0x44, 0x91, 0x59, 0x06, 0x01, 0x2E, 0x54, 0x0F,
/* 06E0 */ 0x5B, 0x30, 0x40, 0x0C, 0x33, 0x9A, 0x10, 0x09, 0x1A, 0xC7, 0x2C, 0x8B, 0xA7, 0x1F, 0x0B, 0x09,
/* 06F0 */ 0x5A, 0x9E, 0x97, 0x3E, 0x04, 0x3D, 0x27, 0x81, 0x05, 0x3D, 0x97, 0x5A, 0xC3, 0x0F, 0x9B, 0x85,
/* 0700 */ 0x5E, 0x27, 0x9F, 0x04, 0x02, 0x87, 0x0E, 0x69, 0x2D, 0xE7, 0x0C, 0x8E, 0x27, 0x9F, 0x80, 0x0B,
/* 0710 */ 0x08, 0x03, 0x88, 0x27, 0x0B, 0x0C, 0x00, 0x09, 0xE7, 0x0E, 0x5A, 0x9F, 0x8F, 0x9F, 0x6B, 0x05,
/* 0720 */ 0x00, 0xC7, 0x10, 0x08, 0x25, 0xC0, 0x0D, 0x9B, 0x30, 0x4B, 0x62, 0x63, 0x61, 0x00, 0x73, 0x36,
/* 0730 */ 0x0C, 0x28, 0x00, 0x38, 0x0F, 0x91, 0x9E, 0x05, 0x27, 0x56, 0xE7, 0x70, 0x70, 0x27, 0x2B, 0x0A,
/* 0740 */ 0xA5, 0x79, 0x65, 0xA5, 0x07, 0x51, 0x69, 0x2C, 0x4F, 0x0B, 0x03, 0x0C, 0x08, 0x10, 0x03, 0x25,
/* 0750 */ 0x8D, 0x22, 0x7A, 0x79, 0x44, 0xF5, 0x26, 0x0E, 0x10, 0x04, 0x00, 0x2A, 0xDD, 0x49, 0x5D, 0x89,
/* 0760 */ 0x00, 0x26, 0x4D, 0x1C, 0x52, 0x51, 0x22, 0x4B, 0x2F, 0x6F, 0x88, 0xCA, 0x6D, 0x95, 0x80, 0x72,
/* 0770 */ 0x91, 0x33, 0xA3, 0x22, 0x40, 0x02, 0x10, 0x04, 0x2A, 0xDD, 0x81, 0x1F, 0x44, 0x69, 0x33, 0x7F,
/* 0780 */ 0x00, 0xCA, 0x22, 0x8D, 0x21, 0x8D, 0x1E, 0x36, 0x06, 0x1C, 0x52, 0x51, 0x79, 0xDC, 0x91, 0x5A,
/* 0790 */ 0x54, 0x5D, 0x05, 0x07, 0x10, 0x05, 0x1D, 0x7B, 0x3D, 0x19, 0x96, 0x07, 0x70, 0x8C, 0x8E, 0x0F,
/* 07A0 */ 0xA7, 0xDC, 0x0C, 0x29, 0x31, 0x32, 0x32, 0x03, 0x10, 0x06, 0x46, 0x4C, 0x63, 0x4E, 0xEF, 0xB7,
/* 07B0 */ 0x0A, 0x10, 0x03, 0x1A, 0x18, 0xAB, 0x10, 0x05, 0x18, 0x60, 0x6D, 0xF0, 0x19, 0x9F, 0x05, 0x5C,
/* 07C0 */ 0x10, 0x03, 0x1D, 0x18, 0xDD, 0xB4, 0x10, 0x06, 0x19, 0x2A, 0x3C, 0x07, 0x33, 0x91, 0x00, 0x26,
/* 07D0 */ 0x0F, 0x1E, 0x36, 0x5D, 0x41, 0x33, 0x55, 0xD1, 0x70, 0x1C, 0xED, 0x42, 0x66, 0xCE, 0x0B, 0x42,
/* 07E0 */ 0x9F, 0x4D, 0x33, 0x64, 0x10, 0x07, 0x25, 0xC0, 0x6E, 0x63, 0x56, 0x97, 0x4D, 0x59, 0x70, 0x00,
/* 07F0 */ 0x7F, 0xE9, 0x06, 0x6F, 0x71, 0x08, 0x80, 0x6F, 0x71, 0x07, 0x69, 0x6F, 0x71, 0x05, 0x70, 0x00,
/* 0800 */ 0x7F, 0x37, 0x56, 0x97, 0x4D, 0x00, 0x38, 0x7C, 0x43, 0x10, 0x05, 0x98, 0x32, 0x28, 0x37, 0x96,
/* 0810 */ 0x45, 0x28, 0x19, 0x81, 0x0A, 0x28, 0x19, 0x79, 0xEA, 0x04, 0x1C, 0xEA, 0x04, 0x10, 0x06, 0x25,
/* 0820 */ 0x03, 0x0C, 0x9B, 0x03, 0x19, 0xA6, 0x08, 0x5B, 0xDC, 0x79, 0x4B, 0x2F, 0x39, 0x0E, 0x1C, 0x2E,
/* 0830 */ 0x19, 0x9F, 0x7F, 0x2F, 0x6B, 0x03, 0x00, 0x3C, 0x73, 0x50, 0x1F, 0x6F, 0x8A, 0x3E, 0x10, 0x06,
/* 0840 */ 0x25, 0x9C, 0x5B, 0x04, 0x19, 0x81, 0x08, 0xA5, 0x33, 0x0B, 0x88, 0xE4, 0x29, 0xE4, 0xA5, 0x03,
/* 0850 */ 0x42, 0x6C, 0x6E, 0x22, 0xA3, 0x34, 0x0B, 0x0B, 0x85, 0x3E, 0x37, 0x7D, 0x5B, 0x05, 0x10, 0x06,
/* 0860 */ 0x25, 0xC3, 0x01, 0x72, 0xDF, 0x96, 0x69, 0x1C, 0x6B, 0x31, 0x9F, 0x0F, 0xC4, 0x3D, 0x54, 0x06,
/* 0870 */ 0x09, 0x28, 0x37, 0x51, 0xF3, 0x3F, 0x5C, 0x51, 0x1E, 0x3C, 0x3D, 0x10, 0x06, 0x25, 0x06, 0x8A,
/* 0880 */ 0x3E, 0xE5, 0x0A, 0x07, 0x8C, 0xE2, 0x31, 0x96, 0xA5, 0x73, 0x00, 0x38, 0xC4, 0x4B, 0x21, 0x05,
/* 0890 */ 0x4D, 0x19, 0x79, 0x99, 0x2D, 0x0D, 0x78, 0x3E, 0x3F, 0x0C, 0x5B, 0x05, 0x10, 0x06, 0x98, 0x40,
/* 08A0 */ 0x7F, 0x03, 0x19, 0x0B, 0x4D, 0x08, 0x00, 0x3F, 0x9D, 0x01, 0x79, 0xE5, 0x51, 0x8F, 0x54, 0x75,
/* 08B0 */ 0xE0, 0x07, 0x69, 0x00, 0x7C, 0x59, 0x70, 0x39, 0x0E, 0x37, 0x56, 0x97, 0x9D, 0x00, 0x59, 0x6E,
/* 08C0 */ 0x43, 0x10, 0x05, 0x25, 0x0D, 0x45, 0xA5, 0x37, 0x96, 0x07, 0x07, 0x5B, 0x00, 0x44, 0x4D, 0xCA,
/* 08D0 */ 0x30, 0x4E, 0x9B, 0x42, 0x96, 0x69, 0x1C, 0x4B, 0x2F, 0x47, 0x1C, 0x24, 0x04, 0x10, 0x06, 0x98,
/* 08E0 */ 0x85, 0x0E, 0x43, 0x38, 0x9B, 0xA3, 0x53, 0x96, 0x69, 0x01, 0x73, 0x2C, 0x9F, 0x9B, 0xC8, 0x86,
/* 08F0 */ 0x5B, 0x02, 0xE9, 0x06, 0x04, 0xE0, 0x0A, 0x3E, 0x00, 0x4B, 0xE9, 0x0B, 0x08, 0x9B, 0x3C, 0x0E,
/* 0900 */ 0xBE, 0x10, 0x06, 0x98, 0x85, 0xA7, 0x19, 0xA4, 0x0B, 0x69, 0x2C, 0x66, 0x3D, 0x47, 0x37, 0x51,
/* 0910 */ 0x5E, 0x5B, 0x54, 0x07, 0x07, 0xE0, 0x7E, 0xA5, 0x91, 0xDC, 0x04, 0xC8, 0x95, 0x9B, 0x19, 0x56,
/* 0920 */ 0x91, 0x31, 0x95, 0x03, 0x10, 0x03, 0x46, 0xDD, 0xB4, 0x35, 0xDD, 0xB4, 0x10, 0x03, 0x46, 0xDD,
/* 0930 */ 0xB4, 0x1B, 0xAB, 0x10, 0x06, 0x46, 0xC3, 0x0A, 0x44, 0x0C, 0x9B, 0x02, 0x2D, 0x73, 0x04, 0x00,
/* 0940 */ 0x3C, 0x73, 0x04, 0x00, 0x44, 0x0C, 0x9B, 0x30, 0xC3, 0x0A, 0x10, 0x06, 0x20, 0xC9, 0x19, 0xF0,
/* 0950 */ 0x3E, 0x3F, 0x07, 0x07, 0x07, 0x07, 0x74, 0xF0, 0x3E, 0x2C, 0x9F, 0x58, 0x01, 0x10, 0x06, 0x20,
/* 0960 */ 0x04, 0x09, 0x22, 0xA1, 0x91, 0x5D, 0x06, 0x0D, 0x28, 0xDC, 0x06, 0x0D, 0x28, 0x37, 0xA1, 0x91,
/* 0970 */ 0x03, 0x00, 0x38, 0x09, 0x02, 0x10, 0x05, 0x25, 0x03, 0x0B, 0x5B, 0x34, 0x95, 0x0D, 0x8E, 0x88,
/* 0980 */ 0x1C, 0x7C, 0x2F, 0x0B, 0x4D, 0x57, 0x04, 0x0A, 0x22, 0x4E, 0x5A, 0x36, 0x21, 0x06, 0x8F, 0x10,
/* 0990 */ 0x0B, 0x00, 0x98, 0x95, 0x6B, 0x87, 0x03, 0x2C, 0x0B, 0x91, 0x07, 0x78, 0x8F, 0x1F, 0x9E, 0x28,
/* 09A0 */ 0x4E, 0x4E, 0x6B, 0x79, 0x56, 0x43, 0x0B, 0xA5, 0x06, 0x04, 0x80, 0x67, 0x80, 0x07, 0x69, 0x94,
/* 09B0 */ 0x02, 0x4D, 0x00, 0xED, 0x0B, 0x0D, 0x00, 0x94, 0x01, 0x4D, 0x95, 0x3E, 0x89, 0x00, 0x87, 0x03,
/* 09C0 */ 0x69, 0x67, 0x28, 0x09, 0x4D, 0x7F, 0x0B, 0x3E, 0x4E, 0x9D, 0x8B, 0x8F, 0x41, 0x05, 0x1F, 0x66,
/* 09D0 */ 0x3D, 0x72, 0x0D, 0x91, 0x07, 0xA2, 0x37, 0x24, 0x7C, 0xBE, 0x10, 0x07, 0x98, 0x3A, 0xE3, 0x10,
/* 09E0 */ 0x07, 0x25, 0xD2, 0x55, 0xE8, 0x08, 0xA5, 0x59, 0x9D, 0x6F, 0x3E, 0x82, 0x83, 0x7F, 0x37, 0x3B,
/* 09F0 */ 0x8F, 0x37, 0xA4, 0x7D, 0x3D, 0xD6, 0xBB, 0x5A, 0xA4, 0x85, 0x28, 0x82, 0xA5, 0x75, 0x10, 0x06,
/* 0A00 */ 0x25, 0x9F, 0x0B, 0x7F, 0x8C, 0x7C, 0x90, 0x0A, 0x00, 0x82, 0xBF, 0x9E, 0x70, 0x1F, 0x3C, 0x69,
/* 0A10 */ 0x42, 0x9E, 0x70, 0x00, 0x44, 0x91, 0x72, 0x0D, 0x9D, 0x81, 0x74, 0x02, 0x41, 0x0E, 0x07, 0x10,
/* 0A20 */ 0x07, 0x25, 0xD2, 0x55, 0xE8, 0x8E, 0x0E, 0x02, 0xD6, 0x07, 0x4D, 0xD6, 0x04, 0x91, 0xD6, 0x03,
/* 0A30 */ 0x73, 0xD6, 0x04, 0x91, 0xD6, 0x07, 0x4D, 0x2C, 0xA4, 0x8E, 0x0E, 0x02, 0x2C, 0xD2, 0x55, 0x03,
/* 0A40 */ 0x10, 0x06, 0x25, 0x3B, 0xAD, 0x10, 0x05, 0x25, 0x3B, 0x3E, 0x37, 0xA4, 0x07, 0x8C, 0x2B, 0x44,
/* 0A50 */ 0x9D, 0x02, 0x31, 0xD2, 0x73, 0x19, 0xA4, 0x05, 0x03, 0x1F, 0xD6, 0x57, 0x2B, 0x10, 0x07, 0x98,
/* 0A60 */ 0x40, 0x0E, 0x87, 0x74, 0x0C, 0x91, 0x78, 0x03, 0x82, 0xBF, 0x9E, 0x70, 0x60, 0x01, 0x2C, 0x09,
/* 0A70 */ 0x69, 0x04, 0x45, 0x53, 0x09, 0x69, 0x01, 0x8D, 0x53, 0x76, 0xC0, 0x0F, 0x53, 0x56, 0xA7, 0x0A,
/* 0A80 */ 0x9D, 0x3F, 0x4B, 0x87, 0x03, 0x10, 0x07, 0x25, 0x2B, 0x05, 0x9D, 0xD6, 0x05, 0x9D, 0xD6, 0x2B,
/* 0A90 */ 0x5A, 0x67, 0x9D, 0x02, 0x2E, 0x82, 0xF3, 0x53, 0xA4, 0x05, 0x08, 0x9D, 0xD6, 0x05, 0x9D, 0xD6,
/* 0AA0 */ 0x05, 0x9D, 0xD6, 0x2B, 0x10, 0x03, 0x25, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x00, 0x1A, 0xAA, 0xAA,
/* 0AB0 */ 0xAA, 0xAA, 0xD1, 0xDF, 0x01, 0x7C, 0x21, 0x0A, 0x05, 0x10, 0x07, 0x25, 0x2B, 0x05, 0x91, 0xD6,
/* 0AC0 */ 0x6E, 0x02, 0x82, 0x09, 0x99, 0x59, 0x91, 0x7F, 0x01, 0x59, 0x9B, 0x9B, 0x1F, 0x82, 0x9A, 0x80,
/* 0AD0 */ 0x59, 0x9D, 0x04, 0xE0, 0x2B, 0x0B, 0x80, 0xD6, 0x04, 0x5B, 0x10, 0x06, 0x25, 0x2B, 0x57, 0xA8,
/* 0AE0 */ 0x2B, 0x44, 0x5B, 0x90, 0x04, 0x37, 0x3B, 0x80, 0x10, 0x09, 0x25, 0x02, 0x0F, 0x69, 0x6F, 0x73,
/* 0AF0 */ 0x27, 0x49, 0x9D, 0x39, 0x9B, 0x1F, 0xC3, 0x5B, 0x0B, 0x01, 0x0F, 0x7F, 0x27, 0xA4, 0x0E, 0x49,
/* 0B00 */ 0x41, 0x27, 0x76, 0x70, 0x0D, 0x86, 0x27, 0xE2, 0x9B, 0x0A, 0x0A, 0x88, 0x1F, 0x95, 0x28, 0x0D,
/* 0B10 */ 0x70, 0x09, 0x3E, 0x1F, 0x9E, 0x3D, 0x0A, 0x80, 0x09, 0x3D, 0x5A, 0xA3, 0x84, 0x79, 0x09, 0x28,
/* 0B20 */ 0x10, 0x07, 0x25, 0xD2, 0xB5, 0x10, 0x08, 0x98, 0xE6, 0xB2, 0xC5, 0x10, 0x07, 0x25, 0xD2, 0x55,
/* 0B30 */ 0xE8, 0x08, 0x5B, 0x01, 0xD6, 0x0B, 0x28, 0xD6, 0x0A, 0x28, 0x82, 0x09, 0x04, 0x0E, 0x71, 0x3B,
/* 0B40 */ 0x69, 0x37, 0xA4, 0xEB, 0x2B, 0x57, 0x10, 0x08, 0x98, 0xE6, 0x00, 0x7C, 0xA2, 0x70, 0xD6, 0x01,
/* 0B50 */ 0xA5, 0x2C, 0xBB, 0x0D, 0x3E, 0x27, 0xA3, 0x1E, 0x0C, 0x3D, 0x27, 0xBB, 0x0D, 0x3E, 0x27, 0x2B,
/* 0B60 */ 0x01, 0x5B, 0x37, 0x7C, 0xA2, 0x28, 0x3F, 0x4B, 0x5B, 0x08, 0x31, 0x9F, 0x09, 0x69, 0x1C, 0x96,
/* 0B70 */ 0x10, 0x07, 0x25, 0xD2, 0x29, 0x04, 0x37, 0xA4, 0x8E, 0x3E, 0xD6, 0x0A, 0x80, 0x82, 0x09, 0x32,
/* 0B80 */ 0x3D, 0x2C, 0x3B, 0x4D, 0x37, 0xA4, 0x0B, 0x3D, 0x59, 0x9D, 0x05, 0x91, 0x59, 0x9D, 0x4C, 0x3E,
/* 0B90 */ 0xD6, 0x07, 0x9D, 0x10, 0x06, 0x98, 0x8E, 0x73, 0x03, 0xE5, 0x0C, 0x78, 0x07, 0x2D, 0x69, 0xAC,
/* 0BA0 */ 0x7A, 0x9D, 0x6D, 0xF0, 0x04, 0x00, 0xDC, 0x09, 0x9B, 0xDC, 0x4E, 0xA5, 0x2D, 0x0D, 0x08, 0x0A,
/* 0BB0 */ 0x91, 0x3F, 0x41, 0x0E, 0x43, 0x10, 0x06, 0x25, 0x0E, 0x8A, 0xE0, 0x06, 0x07, 0xA5, 0x07, 0x05,
/* 0BC0 */ 0x42, 0xA5, 0xDE, 0xDE, 0x10, 0x07, 0x25, 0x8D, 0xB9, 0x10, 0x06, 0x25, 0xA5, 0x1F, 0x09, 0x80,
/* 0BD0 */ 0x27, 0x6F, 0x3E, 0x00, 0x0B, 0x71, 0x08, 0x80, 0x00, 0x7F, 0x59, 0x4D, 0x01, 0x91, 0x1F, 0xC7,
/* 0BE0 */ 0x0F, 0x93, 0x69, 0x19, 0x61, 0xED, 0x3C, 0x91, 0x0E, 0x1F, 0xE5, 0xDF, 0x02, 0x0F, 0x4D, 0x10,
/* 0BF0 */ 0x09, 0x25, 0x4B, 0x96, 0x73, 0x66, 0x88, 0x1F, 0x0B, 0x3E, 0x08, 0x9B, 0x00, 0x6B, 0x5A, 0x09,
/* 0C00 */ 0x3D, 0x0A, 0x6E, 0x00, 0x29, 0x5A, 0x8D, 0x9C, 0x0A, 0x88, 0x91, 0x1F, 0x67, 0x0F, 0x92, 0xE2,
/* 0C10 */ 0x4D, 0x65, 0x9D, 0x3D, 0x0E, 0xBB, 0x4E, 0x9B, 0x88, 0x68, 0x28, 0x5A, 0x39, 0xA5, 0x00, 0x51,
/* 0C20 */ 0x3E, 0x5A, 0x6F, 0x9B, 0x00, 0x09, 0x45, 0x10, 0x06, 0x25, 0x0A, 0x28, 0x39, 0xD8, 0x04, 0x91,
/* 0C30 */ 0x05, 0x4D, 0x19, 0x6B, 0x51, 0x31, 0xD2, 0x09, 0x19, 0x9F, 0x0F, 0x70, 0x1F, 0x54, 0x7F, 0xDC,
/* 0C40 */ 0x29, 0x62, 0x34, 0x99, 0x03, 0xE0, 0x0D, 0x3E, 0x6F, 0x3D, 0x10, 0x07, 0x25, 0x7C, 0xD3, 0x6E,
/* 0C50 */ 0x79, 0xC7, 0xB6, 0x10, 0x06, 0x25, 0xF0, 0x9D, 0x3F, 0x07, 0x48, 0x4D, 0x19, 0x9F, 0xA5, 0x2F,
/* 0C60 */ 0xA3, 0x8C, 0x9F, 0xA5, 0x31, 0x66, 0x69, 0xE4, 0x5B, 0x1C, 0x0B, 0x73, 0x07, 0x07, 0x04, 0x2C,
/* 0C70 */ 0x6F, 0x8A, 0x4D, 0x10, 0x04, 0x35, 0x60, 0x2F, 0x86, 0x28, 0x19, 0x66, 0x80, 0x2F, 0x86, 0xE1,
/* 0C80 */ 0xCA, 0xE1, 0xCA, 0xE1, 0xCA, 0xE1, 0xCA, 0x03, 0x2F, 0x86, 0x28, 0xE4, 0x5C, 0x01, 0x10, 0x06,
/* 0C90 */ 0x1D, 0x02, 0x09, 0x04, 0x72, 0x9D, 0x33, 0x89, 0x33, 0xDA, 0x27, 0x82, 0x21, 0x02, 0x9D, 0x33,
/* 0CA0 */ 0x68, 0x33, 0xA3, 0x2F, 0x96, 0x28, 0x42, 0x9F, 0x4D, 0x33, 0x29, 0x33, 0x84, 0x10, 0x04, 0x35,
/* 0CB0 */ 0x60, 0x1C, 0x4B, 0x3D, 0x26, 0x86, 0xDB, 0x62, 0xDB, 0x08, 0x3D, 0x00, 0xDC, 0x09, 0x3D, 0x42,
/* 0CC0 */ 0x4B, 0x3D, 0x26, 0x5C, 0x01, 0x10, 0x06, 0x2A, 0x56, 0x0F, 0x6D, 0x8E, 0x87, 0x37, 0x9F, 0x9D,
/* 0CD0 */ 0x08, 0x3D, 0x37, 0xA3, 0x84, 0x91, 0x10, 0x06, 0x1C, 0x46, 0x46, 0x64, 0x64, 0x5E, 0x2C, 0x4C,
/* 0CE0 */ 0x8A, 0x4D, 0x38, 0x58, 0x03, 0x10, 0x04, 0x1D, 0x02, 0x0A, 0x30, 0xC3, 0x0D, 0x8F, 0x1F, 0x44,
/* 0CF0 */ 0x01, 0x10, 0x06, 0x20, 0xAE, 0xC4, 0x10, 0x07, 0x1D, 0xCB, 0x61, 0x04, 0xE5, 0xA7, 0xE0, 0x99,
/* 0D00 */ 0x4C, 0x71, 0x99, 0x6F, 0x3E, 0x2C, 0x99, 0x4C, 0x71, 0x7A, 0x97, 0xE0, 0x2E, 0x7F, 0x03, 0x10,
/* 0D10 */ 0x05, 0x20, 0x67, 0x6E, 0x43, 0x3F, 0x5B, 0x08, 0x63, 0xBB, 0x3C, 0x28, 0x42, 0x9E, 0x69, 0xD1,
/* 0D20 */ 0x5B, 0x07, 0x08, 0x42, 0x4F, 0x43, 0x10, 0x07, 0x42, 0x2A, 0x3C, 0x07, 0x1C, 0x39, 0xCE, 0x0E,
/* 0D30 */ 0x19, 0x8E, 0x41, 0x0E, 0x38, 0x5B, 0xD7, 0x3C, 0x87, 0x6B, 0x10, 0x06, 0x46, 0x4F, 0x08, 0xB0,
/* 0D40 */ 0xBE, 0x10, 0x04, 0x1D, 0x67, 0x6E, 0x8C, 0x39, 0xA7, 0x04, 0x37, 0x9F, 0xDF, 0xFA, 0xA5, 0x19,
/* 0D50 */ 0x95, 0x5B, 0x06, 0x42, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x1C, 0x47, 0x10, 0x06, 0x1B,
/* 0D60 */ 0x25, 0x6C, 0x07, 0x3C, 0x0E, 0x0F, 0x55, 0xE9, 0x0A, 0x0B, 0x0D, 0x02, 0x2C, 0x66, 0x3E, 0x05,
/* 0D70 */ 0x69, 0x54, 0x06, 0x62, 0x34, 0x7E, 0x0F, 0x9B, 0x01, 0x3F, 0x9B, 0x93, 0x19, 0xEF, 0x45, 0x70,
/* 0D80 */ 0x37, 0x64, 0x9F, 0xE0, 0x61, 0x05, 0x07, 0x91, 0x37, 0x9C, 0xA5, 0x43, 0x10, 0x06, 0x1D, 0x03,
/* 0D90 */ 0x08, 0x05, 0xBD, 0x1C, 0x2E, 0x6B, 0xA9, 0x10, 0x03, 0xD0, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0xD0,
/* 0DA0 */ 0xBD, 0xBD, 0xBD, 0x1C, 0x0B, 0x28, 0x42, 0x2E, 0x1C, 0x6C, 0x10, 0x06, 0x1D, 0x04, 0x75, 0x1C,
/* 0DB0 */ 0x99, 0xBD, 0x01, 0x29, 0x37, 0x99, 0x08, 0x28, 0xE5, 0xA3, 0x63, 0x06, 0x9B, 0x9D, 0x19, 0x99,
/* 0DC0 */ 0x6E, 0x74, 0x99, 0x07, 0x4D, 0x37, 0x99, 0x56, 0xD8, 0x10, 0x03, 0x1D, 0x04, 0x0A, 0x21, 0x8D,
/* 0DD0 */ 0xEE, 0xEE, 0xEE, 0x06, 0x42, 0x96, 0x73, 0x72, 0x6B, 0x03, 0x10, 0x09, 0x20, 0x76, 0x61, 0x04,
/* 0DE0 */ 0x61, 0x02, 0x1F, 0x96, 0xA5, 0x51, 0x87, 0x4D, 0x5A, 0x99, 0x05, 0x4D, 0x04, 0xAF, 0x04, 0xAF,
/* 0DF0 */ 0x04, 0xAF, 0x04, 0xAF, 0x04, 0x9D, 0x10, 0x06, 0x20, 0x76, 0x6E, 0xA9, 0x10, 0x06, 0x46, 0xB3,
/* 0E00 */ 0x10, 0x07, 0x20, 0x2E, 0x61, 0xD5, 0x7B, 0x08, 0x03, 0x10, 0x07, 0x20, 0x9E, 0x55, 0x6B, 0x38,
/* 0E10 */ 0x5B, 0xD7, 0x3C, 0x87, 0x0E, 0xCE, 0xCE, 0x0E, 0x1C, 0x95, 0x08, 0x10, 0x04, 0x20, 0x7A, 0x8E,
/* 0E20 */ 0x05, 0x00, 0xE5, 0x4D, 0x30, 0x06, 0x91, 0xBD, 0xBD, 0x10, 0x05, 0x20, 0x01, 0x0B, 0x5B, 0x05,
/* 0E30 */ 0x19, 0xA3, 0x90, 0x07, 0x3C, 0x9D, 0x2F, 0xA0, 0x70, 0xD1, 0x0E, 0x0F, 0x19, 0xA2, 0x08, 0xA5,
/* 0E40 */ 0x19, 0x7D, 0x9B, 0x04, 0x10, 0x04, 0x25, 0x02, 0x08, 0x06, 0xD1, 0x9D, 0x42, 0xFA, 0x5B, 0x19,
/* 0E50 */ 0x9E, 0x9B, 0x05, 0xE4, 0x9D, 0xD1, 0x9D, 0xD1, 0x9D, 0x42, 0x9F, 0x5B, 0x07, 0x42, 0x9E, 0x7F,
/* 0E60 */ 0x02, 0x10, 0x06, 0x20, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0x20, 0x0E, 0x0E, 0x00, 0x49, 0x53, 0x66,
/* 0E70 */ 0x3E, 0x7A, 0x34, 0xE2, 0x09, 0x71, 0x9F, 0x4D, 0xA6, 0x42, 0xE7, 0x94, 0x19, 0x66, 0x0E, 0x80,
/* 0E80 */ 0x1F, 0xE5, 0x88, 0x10, 0x08, 0x20, 0x6E, 0x6F, 0x3E, 0x09, 0x3E, 0x5A, 0x86, 0x39, 0x28, 0x41,
/* 0E90 */ 0x27, 0x62, 0x49, 0x75, 0x68, 0x5A, 0x67, 0x70, 0xE7, 0x08, 0x94, 0x00, 0x65, 0x73, 0x0B, 0xA2,
/* 0EA0 */ 0x69, 0x5A, 0xF8, 0x9D, 0x7A, 0x28, 0x27, 0x6F, 0x70, 0x49, 0x88, 0x10, 0x06, 0x20, 0x0B, 0x3D,
/* 0EB0 */ 0x09, 0x3D, 0x3F, 0x4D, 0x55, 0x42, 0x51, 0x28, 0x19, 0x95, 0x45, 0x2F, 0x61, 0x4D, 0x19, 0xE2,
/* 0EC0 */ 0x6B, 0x74, 0x6E, 0x01, 0x07, 0x4D, 0x10, 0x06, 0x20, 0x0E, 0xBA, 0xF1, 0x10, 0x05, 0x20, 0x0A,
/* 0ED0 */ 0x45, 0xE0, 0xC0, 0x07, 0x86, 0x63, 0x4E, 0x6E, 0x30, 0x9E, 0x70, 0xE4, 0x5B, 0x1C, 0x0B, 0x91,
/* 0EE0 */ 0x07, 0x34, 0x4C, 0x45, 0x73, 0x10, 0x04, 0x1B, 0xDD, 0x0B, 0x28, 0xE4, 0x73, 0x01, 0xE4, 0x70,
/* 0EF0 */ 0xD1, 0x70, 0x42, 0x96, 0x69, 0x1C, 0x29, 0x2F, 0x9E, 0x80, 0xD1, 0x70, 0xD1, 0x4D, 0xD1, 0x4D,
/* 0F00 */ 0x42, 0x9F, 0x91, 0x2F, 0x6F, 0x28, 0x33, 0xEB, 0x10, 0x04, 0x2A, 0x61, 0x33, 0x61, 0xB8, 0x61,
/* 0F10 */ 0xB8, 0x61, 0x10, 0x04, 0x35, 0xDD, 0x6F, 0x8F, 0x00, 0x44, 0x91, 0x33, 0x73, 0x33, 0x73, 0x33,
/* 0F20 */ 0x7F, 0x79, 0x44, 0x69, 0x1C, 0x89, 0x22, 0x73, 0x33, 0x73, 0x33, 0x73, 0x1C, 0x49, 0xBF, 0x6F,
/* 0F30 */ 0x80, 0xD1, 0x02, 0x10, 0x06, 0x18, 0xAC, 0x65, 0x0E, 0x8F, 0x83, 0x37, 0x90, 0x0A, 0xA5, 0x02,
/* 0F40 */ 0xD1, 0x02, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x15, 0x00, 0x33, 0x00, 0x54, 0x00, 0x79, 0x00,
/* 0F50 */ 0x9E, 0x00, 0xA7, 0x00, 0xD0, 0x00, 0xD5, 0x01, 0x08, 0x01, 0x2B, 0x01, 0x46, 0x01, 0x56, 0x01,
/* 0F60 */ 0x60, 0x01, 0x8F, 0x01, 0x9A, 0x01, 0xAE, 0x01, 0xC0, 0x01, 0xD6, 0x01, 0xEE, 0x01, 0xFA, 0x02,
/* 0F70 */ 0x11, 0x02, 0x3A, 0x02, 0x40, 0x02, 0x4F, 0x02, 0x5D, 0x02, 0x7D, 0x02, 0xA0, 0x02, 0xBD, 0x02,
/* 0F80 */ 0xE8, 0x03, 0x14, 0x03, 0x32, 0x03, 0x3F, 0x03, 0x4D, 0x03, 0x5C, 0x03, 0x6C, 0x03, 0x7A, 0x03,
/* 0F90 */ 0x89, 0x03, 0xB8, 0x03, 0xE0, 0x03, 0xEE, 0x03, 0xF9, 0x04, 0x09, 0x04, 0x18, 0x04, 0x27, 0x04,
/* 0FA0 */ 0x34, 0x04, 0x42, 0x04, 0x50, 0x04, 0x7F, 0x04, 0x90, 0x04, 0x9D, 0x04, 0xAA, 0x04, 0xBA, 0x04,
/* 0FB0 */ 0xCB, 0x04, 0xD9, 0x04, 0xEE, 0x05, 0x28, 0x05, 0x33, 0x05, 0x3F, 0x05, 0x4E, 0x05, 0x55, 0x05,
/* 0FC0 */ 0x66, 0x05, 0x82, 0x05, 0xAD, 0x05, 0xBA, 0x05, 0xC8, 0x05, 0xD5, 0x05, 0xE0, 0x05, 0xE9, 0x05,
/* 0FD0 */ 0xFC, 0x06, 0x27, 0x06, 0x49, 0x06, 0x57, 0x06, 0x61, 0x06, 0x6E, 0x06, 0x7A, 0x06, 0x89, 0x06,
/* 0FE0 */ 0x98, 0x06, 0xA9, 0x06, 0xB4, 0x06, 0xD5, 0x06, 0xE3, 0x06, 0xEF, 0x06, 0xFB, 0x07, 0x09, 0x07,
/* 0FF0 */ 0x15, 0x07, 0x24, 0x07, 0x3B, 0x07, 0x62, 0x07, 0x70, 0x07, 0x78, 0x07, 0x84, 0x07, 0x8E, 0x07,
/* 1000 */ 0x9B, 0x07, 0xA4, 0x03, 0x00, 0x10, 0x03, 0x20, 0x92, 0x5D, 0x52, 0xAC, 0x1C, 0xE5, 0x22, 0x7A,
/* 1010 */ 0x5D, 0x8D, 0x5D, 0x52, 0x52, 0x09, 0x80, 0x10, 0x05, 0x98, 0x9E, 0x0C, 0x33, 0x81, 0x2F, 0x51,
/* 1020 */ 0xA5, 0x01, 0x59, 0x9D, 0x23, 0x19, 0xA3, 0x21, 0xA3, 0x21, 0x2E, 0x23, 0xDC, 0x4B, 0xA5, 0x31,
/* 1030 */ 0x66, 0x0D, 0x6D, 0x9E, 0x0C, 0x10, 0x06, 0x25, 0x4E, 0x0B, 0x29, 0x03, 0x3C, 0x9D, 0x75, 0x19,
/* 1040 */ 0x4B, 0x72, 0x0D, 0x3E, 0x30, 0xF0, 0x0E, 0x19, 0x32, 0x80, 0x04, 0x42, 0x6E, 0x42, 0x96, 0x73,
/* 1050 */ 0x07, 0x07, 0x03, 0x37, 0xEC, 0x69, 0x10, 0x06, 0x1F, 0x98, 0xD1, 0x02, 0x00, 0x4E, 0x04, 0x2C,
/* 1060 */ 0x66, 0x0D, 0x6E, 0xE7, 0x2C, 0x9F, 0x91, 0x09, 0x3D, 0x00, 0x82, 0x79, 0x69, 0x3F, 0x69, 0x05,
/* 1070 */ 0x28, 0xE5, 0x45, 0x70, 0x2C, 0x95, 0x04, 0x03, 0x03, 0x04, 0x07, 0x10, 0x06, 0x25, 0x6E, 0x1F,
/* 1080 */ 0x0B, 0x3E, 0x2C, 0xE2, 0x02, 0x9D, 0x19, 0x55, 0x07, 0x3E, 0x36, 0xE7, 0x00, 0x3F, 0x0E, 0x0F,
/* 1090 */ 0xA5, 0x1E, 0xC7, 0x04, 0x0D, 0x28, 0x02, 0x3F, 0x8A, 0x70, 0x1F, 0xC7, 0x7D, 0x80, 0x6D, 0x4B,
/* 10A0 */ 0x10, 0x04, 0x2A, 0x61, 0xB8, 0x00, 0x35, 0xB8, 0x61, 0x10, 0x06, 0x98, 0x7D, 0x87, 0x74, 0x01,
/* 10B0 */ 0x5B, 0x07, 0x0B, 0x74, 0x47, 0x2F, 0x6F, 0xA5, 0x8C, 0x49, 0x48, 0x80, 0xE5, 0x06, 0x49, 0x34,
/* 10C0 */ 0x02, 0x7C, 0x7F, 0x2F, 0xA1, 0x0E, 0x74, 0x96, 0x03, 0x0B, 0x3E, 0x3F, 0x0E, 0x45, 0x63, 0x4E,
/* 10D0 */ 0x04, 0x03, 0x10, 0x05, 0x2A, 0xC6, 0x02, 0x10, 0x09, 0x1D, 0xC7, 0x1C, 0x8E, 0xA5, 0x06, 0x37,
/* 10E0 */ 0x8E, 0x07, 0x06, 0x09, 0x80, 0xC7, 0x28, 0x0D, 0x4D, 0x48, 0x27, 0x9C, 0x92, 0x06, 0x84, 0x0F,
/* 10F0 */ 0x27, 0x9C, 0x85, 0x03, 0x02, 0x00, 0x88, 0x1F, 0x9F, 0x28, 0x0E, 0x91, 0x7D, 0x27, 0x66, 0x75,
/* 1100 */ 0x06, 0x92, 0x07, 0x00, 0xC7, 0xEC, 0x09, 0xE4, 0x04, 0x02, 0x10, 0x05, 0x1A, 0x02, 0x2F, 0x56,
/* 1110 */ 0x0F, 0x8F, 0x19, 0x96, 0x08, 0x9D, 0x19, 0xEF, 0x45, 0x63, 0x07, 0x91, 0x73, 0x00, 0x38, 0x0F,
/* 1120 */ 0x73, 0x0C, 0xE4, 0x03, 0x9F, 0x35, 0x38, 0x07, 0x07, 0x07, 0x8C, 0x07, 0xF3, 0x10, 0x07, 0x46,
/* 1130 */ 0x96, 0x01, 0x96, 0x74, 0x06, 0x69, 0x7A, 0x1E, 0x65, 0x9B, 0x03, 0x5B, 0x2D, 0x80, 0xBB, 0x27,
/* 1140 */ 0xA4, 0xA4, 0x3C, 0x28, 0xC8, 0x83, 0x00, 0x83, 0x10, 0x06, 0x18, 0xC9, 0x74, 0xF0, 0x80, 0x2C,
/* 1150 */ 0x9F, 0x5C, 0x07, 0x80, 0xD1, 0x80, 0x72, 0xEB, 0x10, 0x05, 0x18, 0x60, 0x6D, 0xF0, 0x19, 0x9F,
/* 1160 */ 0x05, 0x5C, 0x10, 0x07, 0x1F, 0x2A, 0x79, 0x26, 0x0E, 0x5B, 0x03, 0x1F, 0xC7, 0x87, 0x07, 0x0A,
/* 1170 */ 0x0D, 0x2C, 0x96, 0x9A, 0x70, 0x0B, 0x04, 0x27, 0x9E, 0x05, 0x0B, 0x70, 0x07, 0x06, 0x27, 0x95,
/* 1180 */ 0x07, 0x0B, 0xC4, 0x09, 0x05, 0x27, 0x9F, 0xA7, 0x03, 0x09, 0xD8, 0x95, 0x45, 0x80, 0x19, 0x9F,
/* 1190 */ 0xEB, 0x10, 0x04, 0x33, 0x1B, 0x60, 0x2F, 0xA3, 0x73, 0xE4, 0x5C, 0x04, 0x10, 0x06, 0x1A, 0x01,
/* 11A0 */ 0x72, 0x7C, 0xBF, 0x78, 0xED, 0x37, 0x9E, 0x0C, 0x04, 0x28, 0x19, 0x7E, 0x9B, 0x42, 0x9F, 0x04,
/* 11B0 */ 0x10, 0x06, 0x35, 0x98, 0xE7, 0x00, 0xDC, 0xEF, 0xB7, 0xBF, 0xC9, 0x36, 0x45, 0x3D, 0x2C, 0x9F,
/* 11C0 */ 0x58, 0x01, 0x10, 0x04, 0x2A, 0x4E, 0xD1, 0x0E, 0x69, 0x26, 0x08, 0xA6, 0x33, 0x0B, 0x09, 0x42,
/* 11D0 */ 0x96, 0x0D, 0x01, 0x26, 0x9D, 0x1E, 0xE9, 0x5B, 0x10, 0x04, 0x2A, 0xAC, 0xC3, 0x0E, 0x0F, 0x8C,
/* 11E0 */ 0x9F, 0x07, 0xA6, 0x1C, 0xE2, 0x42, 0x9F, 0x41, 0x19, 0x9F, 0x04, 0x09, 0x0E, 0x44, 0x6E, 0x05,
/* 11F0 */ 0x10, 0x04, 0x1D, 0x9F, 0x0B, 0x01, 0x44, 0x9B, 0x03, 0x19, 0x9F, 0x04, 0x10, 0x06, 0x20, 0x99,
/* 1200 */ 0xD9, 0xD9, 0xD9, 0xD9, 0x04, 0x9D, 0xE5, 0xA6, 0x91, 0xE5, 0x94, 0x29, 0xE5, 0x04, 0xAC, 0xE2,
/* 1210 */ 0x00, 0x26, 0x83, 0x10, 0x09, 0x98, 0x9C, 0x8A, 0x70, 0x27, 0x7E, 0x45, 0xA7, 0x70, 0x27, 0xD2,
/* 1220 */ 0x5B, 0x03, 0x70, 0x1F, 0xC3, 0x45, 0x5B, 0x03, 0x70, 0x2C, 0x51, 0x5B, 0x03, 0x70, 0x38, 0x61,
/* 1230 */ 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0x49, 0x8C, 0x06, 0x06, 0x02, 0x08, 0x03, 0x10, 0x03, 0x00, 0x18,
/* 1240 */ 0xDD, 0xB4, 0x10, 0x04, 0x20, 0x20, 0x02, 0x33, 0x39, 0x21, 0x24, 0x3D, 0x00, 0x36, 0x3E, 0x00,
/* 1250 */ 0x26, 0x6D, 0x04, 0x25, 0x40, 0x28, 0x44, 0x0A, 0x28, 0x72, 0x28, 0x72, 0x28, 0x72, 0x28, 0x10,
/* 1260 */ 0x05, 0x1A, 0x01, 0x72, 0x4B, 0x80, 0x19, 0x76, 0x6E, 0x19, 0xDA, 0xDA, 0xE9, 0x05, 0x6B, 0x19,
/* 1270 */ 0x7E, 0x45, 0x8C, 0x4E, 0x04, 0x5D, 0x5A, 0x26, 0x07, 0x07, 0x07, 0x07, 0x3C, 0x8A, 0x88, 0x10,
/* 1280 */ 0x07, 0x20, 0x01, 0x06, 0x4E, 0x1E, 0x82, 0x07, 0x05, 0x70, 0x37, 0x6F, 0x28, 0x0B, 0x28, 0x59,
/* 1290 */ 0x9D, 0x04, 0x91, 0x37, 0x0B, 0x80, 0x0A, 0x69, 0x5A, 0xC3, 0x9D, 0x04, 0x0F, 0x53, 0x9F, 0x09,
/* 12A0 */ 0x9F, 0x09, 0x10, 0x0B, 0x25, 0xCC, 0x03, 0x3E, 0x00, 0xC7, 0x28, 0x66, 0x0A, 0x1F, 0xC7, 0x28,
/* 12B0 */ 0x02, 0x3D, 0x06, 0x0B, 0x19, 0x9A, 0x4C, 0x07, 0x1F, 0xC7, 0x8F, 0x04, 0x0F, 0x92, 0xBC, 0x10,
/* 12C0 */ 0x0B, 0x25, 0xCC, 0x49, 0x5E, 0xC7, 0x28, 0x66, 0x0B, 0x0C, 0x91, 0x1F, 0x4E, 0x28, 0x02, 0x28,
/* 12D0 */ 0x90, 0x71, 0x9A, 0x00, 0x95, 0x0D, 0x00, 0xC7, 0x8F, 0x9F, 0x8F, 0x2C, 0x48, 0x4E, 0x0D, 0x0B,
/* 12E0 */ 0x07, 0x01, 0x5A, 0x39, 0x05, 0x7B, 0x45, 0x3E, 0x65, 0x0C, 0x10, 0x0B, 0x25, 0x03, 0x6E, 0x1E,
/* 12F0 */ 0x9C, 0x00, 0x65, 0x08, 0xA6, 0x1F, 0x0B, 0x53, 0x06, 0x69, 0x7B, 0x3E, 0x1F, 0x65, 0x89, 0x66,
/* 1300 */ 0x0A, 0x2C, 0x64, 0x8E, 0x02, 0x3D, 0x06, 0x0B, 0x5A, 0xD2, 0x07, 0x9A, 0x4C, 0x07, 0xC7, 0x01,
/* 1310 */ 0x01, 0x8F, 0x04, 0x0F, 0x92, 0xBC, 0x10, 0x05, 0x20, 0x4E, 0xE7, 0x72, 0x29, 0x00, 0x72, 0xDD,
/* 1320 */ 0x06, 0x05, 0x72, 0xDF, 0x01, 0x51, 0x1E, 0x2D, 0x91, 0x1C, 0x4B, 0x5E, 0x74, 0x66, 0x73, 0x61,
/* 1330 */ 0x19, 0x8B, 0x5B, 0x05, 0x10, 0x07, 0x1B, 0x02, 0x33, 0x47, 0x30, 0xC3, 0x0A, 0x08, 0x42, 0x3A,
/* 1340 */ 0xE3, 0x10, 0x07, 0x19, 0x72, 0x2F, 0x96, 0x94, 0x00, 0xDC, 0x0C, 0x07, 0x2F, 0x3A, 0xE3, 0x10,
/* 1350 */ 0x07, 0x1B, 0x0B, 0x80, 0x00, 0x3C, 0x97, 0x0E, 0x30, 0x5E, 0x7B, 0x42, 0x3A, 0xE3, 0x10, 0x07,
/* 1360 */ 0x5A, 0xDD, 0x05, 0x70, 0x0A, 0x30, 0x90, 0x0E, 0x0E, 0x2F, 0x60, 0x42, 0x3A, 0xE3, 0x10, 0x07,
/* 1370 */ 0x1F, 0x1B, 0x2F, 0xA6, 0x04, 0x69, 0x19, 0x64, 0x00, 0xEB, 0x3A, 0xE3, 0x10, 0x07, 0xC7, 0x72,
/* 1380 */ 0x0D, 0x70, 0x26, 0x87, 0x0C, 0x42, 0x56, 0x4D, 0x42, 0x3A, 0xE3, 0x10, 0x09, 0x98, 0x95, 0xF3,
/* 1390 */ 0x70, 0x2C, 0x6B, 0x73, 0x50, 0x9F, 0x91, 0x9D, 0x36, 0x05, 0x29, 0x02, 0x5E, 0x5A, 0x6F, 0x88,
/* 13A0 */ 0x0D, 0x8A, 0x1E, 0x9F, 0x5B, 0xA0, 0x06, 0x05, 0x02, 0x1F, 0x95, 0xF3, 0x3D, 0x27, 0x6F, 0x70,
/* 13B0 */ 0x05, 0x09, 0x9D, 0x07, 0x1E, 0x02, 0xA5, 0xC3, 0x45, 0xA5, 0x10, 0x06, 0x98, 0x40, 0x7F, 0x8C,
/* 13C0 */ 0x0C, 0x9D, 0x0A, 0x0B, 0x38, 0xDF, 0x9E, 0x70, 0x1C, 0xA3, 0x1E, 0x3C, 0x69, 0x42, 0x95, 0x4D,
/* 13D0 */ 0x42, 0x9F, 0xA5, 0x64, 0x06, 0x19, 0xF0, 0xD8, 0xC3, 0x94, 0x22, 0x7F, 0x6D, 0x7A, 0x3D, 0x00,
/* 13E0 */ 0x26, 0x02, 0x10, 0x06, 0x1B, 0x22, 0x67, 0x4D, 0x79, 0xDC, 0x06, 0x0B, 0x05, 0x19, 0x3B, 0xAD,
/* 13F0 */ 0x10, 0x06, 0x19, 0xD1, 0x72, 0xC8, 0xC0, 0x75, 0x31, 0x3B, 0xAD, 0x10, 0x06, 0x35, 0x9F, 0x6E,
/* 1400 */ 0x30, 0x6F, 0x0B, 0x0A, 0x0D, 0x19, 0x9F, 0x5F, 0x19, 0x3B, 0xAD, 0x10, 0x06, 0x00, 0x35, 0x79,
/* 1410 */ 0x4E, 0xDC, 0x9D, 0x62, 0x30, 0x84, 0x23, 0x19, 0x3B, 0xAD, 0x10, 0x03, 0x35, 0x02, 0xDD, 0x0B,
/* 1420 */ 0x0D, 0x21, 0x02, 0x08, 0x0C, 0x1C, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x1B, 0x02, 0xD1, 0x89, 0x42,
/* 1430 */ 0x66, 0x09, 0x5D, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x35, 0x2E, 0x26, 0x0E, 0x8E, 0x8C, 0x9F, 0x4E,
/* 1440 */ 0x2F, 0xA8, 0xA8, 0x2B, 0x10, 0x03, 0x35, 0x79, 0x2F, 0xED, 0x55, 0x19, 0x23, 0x7B, 0x6D, 0xA8,
/* 1450 */ 0xA8, 0x2B, 0x10, 0x07, 0x25, 0x02, 0x45, 0x29, 0x34, 0x02, 0x5B, 0x78, 0x28, 0x27, 0x9F, 0x9B,
/* 1460 */ 0xC0, 0x91, 0x1F, 0x65, 0x9B, 0x5E, 0x5B, 0x27, 0x6F, 0x45, 0x88, 0xA5, 0x82, 0x0D, 0x05, 0x01,
/* 1470 */ 0x5B, 0x27, 0x9F, 0x9B, 0xC0, 0x91, 0x27, 0x9F, 0x5B, 0x07, 0x0D, 0x28, 0x27, 0x9F, 0x45, 0x9B,
/* 1480 */ 0x05, 0x10, 0x07, 0x2C, 0x72, 0x68, 0x07, 0x06, 0x19, 0x9C, 0x0B, 0x80, 0x00, 0xDC, 0x23, 0x19,
/* 1490 */ 0xD2, 0xB5, 0x10, 0x08, 0x37, 0x72, 0xDD, 0x8E, 0x06, 0x72, 0x48, 0x30, 0xE6, 0xB2, 0xC5, 0x10,
/* 14A0 */ 0x08, 0x1F, 0x1B, 0x5D, 0xA0, 0x30, 0x9E, 0x93, 0x42, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x19, 0x26,
/* 14B0 */ 0x73, 0x74, 0x9F, 0x94, 0x97, 0x19, 0x9F, 0x4E, 0x30, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x1B, 0x89,
/* 14C0 */ 0x06, 0x08, 0x37, 0x9F, 0x97, 0x4D, 0x00, 0xDC, 0xC0, 0x42, 0xE6, 0xB2, 0xC5, 0x10, 0x08, 0x1B,
/* 14D0 */ 0x2F, 0xC3, 0x80, 0x0B, 0x0D, 0x26, 0x9F, 0x30, 0xE6, 0xB2, 0xC5, 0x10, 0x06, 0x18, 0x32, 0x02,
/* 14E0 */ 0x07, 0x0B, 0xDC, 0x61, 0x4D, 0x19, 0x96, 0xA5, 0x30, 0x03, 0x91, 0x68, 0xDC, 0x07, 0x7B, 0x06,
/* 14F0 */ 0x10, 0x08, 0x2A, 0x65, 0x04, 0x5A, 0x3C, 0x0E, 0x19, 0xA0, 0xE0, 0x01, 0x7C, 0x62, 0x70, 0x2C,
/* 1500 */ 0x76, 0x03, 0x6B, 0x0E, 0x2C, 0x09, 0x80, 0x07, 0x08, 0x0C, 0x3E, 0x27, 0x09, 0x80, 0x93, 0x0B,
/* 1510 */ 0x3D, 0x27, 0xA3, 0xA1, 0x01, 0x0C, 0x88, 0x5A, 0x96, 0x91, 0x0B, 0x39, 0x0E, 0x2C, 0x56, 0x73,
/* 1520 */ 0x0A, 0x70, 0x38, 0x45, 0xA7, 0x00, 0x59, 0x3D, 0x72, 0x06, 0x10, 0x07, 0x1B, 0x30, 0x27, 0x89,
/* 1530 */ 0x04, 0xD1, 0x9A, 0x36, 0xB9, 0x10, 0x07, 0x1F, 0x1B, 0x30, 0xC3, 0x68, 0x1C, 0x0B, 0x83, 0x36,
/* 1540 */ 0xB9, 0x10, 0x07, 0x1B, 0x08, 0x4D, 0x42, 0xA1, 0x8E, 0x05, 0xDC, 0x02, 0x00, 0x5E, 0xE9, 0xB9,
/* 1550 */ 0x10, 0x07, 0x1B, 0xC6, 0x01, 0xE9, 0xB9, 0x10, 0x07, 0x19, 0x72, 0x2F, 0x96, 0xA7, 0x42, 0x8B,
/* 1560 */ 0x07, 0x31, 0x7C, 0xD3, 0x6E, 0x79, 0xC7, 0xB6, 0x10, 0x07, 0x25, 0x2B, 0x44, 0x9D, 0x2F, 0xD2,
/* 1570 */ 0xA5, 0x34, 0xA4, 0x92, 0x3E, 0xD6, 0x0A, 0x28, 0x82, 0x09, 0x32, 0x3E, 0x2C, 0x3B, 0x4D, 0x37,
/* 1580 */ 0xA4, 0x04, 0x30, 0x2B, 0x10, 0x07, 0x1D, 0x67, 0x7C, 0x43, 0x2C, 0x9F, 0x0F, 0xE7, 0x70, 0x59,
/* 1590 */ 0x70, 0x04, 0x69, 0x37, 0x99, 0x0A, 0x0C, 0x00, 0xE5, 0x8D, 0x63, 0x99, 0x0B, 0x70, 0x37, 0x99,
/* 15A0 */ 0xEF, 0x3D, 0x2C, 0x99, 0x9E, 0x69, 0x2C, 0x99, 0x05, 0x0C, 0x28, 0x2C, 0x7A, 0x48, 0xA7, 0x10,
/* 15B0 */ 0x06, 0x1D, 0x4E, 0x0B, 0x02, 0xD1, 0x4B, 0x21, 0xC0, 0x30, 0xAE, 0xC4, 0x10, 0x06, 0x1D, 0x5F,
/* 15C0 */ 0x0B, 0x31, 0x96, 0x9B, 0x02, 0xE4, 0x04, 0x1C, 0xAE, 0xC4, 0x10, 0x06, 0x1D, 0x9F, 0x7F, 0x2F,
/* 15D0 */ 0xE7, 0xA6, 0x26, 0xC3, 0x19, 0xAE, 0xC4, 0x10, 0x06, 0x1A, 0x64, 0x6D, 0xA3, 0xDF, 0x5C, 0xEB,
/* 15E0 */ 0xAE, 0xC4, 0x10, 0x06, 0xCF, 0x02, 0x70, 0xDA, 0xCD, 0xAE, 0xC4, 0x10, 0x06, 0x1B, 0x2F, 0xC3,
/* 15F0 */ 0xA5, 0x03, 0x00, 0x3C, 0xA6, 0x07, 0x5A, 0x82, 0x28, 0xD1, 0x03, 0x42, 0xAE, 0xC4, 0x10, 0x09,
/* 1600 */ 0x20, 0x01, 0x0B, 0x7F, 0x06, 0x41, 0x43, 0x5A, 0x66, 0x48, 0x5B, 0x62, 0x53, 0x24, 0x4D, 0x02,
/* 1610 */ 0x6B, 0x5A, 0x8B, 0x45, 0xF3, 0xF5, 0x66, 0x4D, 0x08, 0x91, 0x05, 0x5C, 0x5A, 0x86, 0x81, 0xA5,
/* 1620 */ 0x07, 0x0A, 0x05, 0x65, 0x6E, 0x83, 0x0C, 0x9B, 0x04, 0x10, 0x05, 0x46, 0x4F, 0x43, 0x3F, 0x5B,
/* 1630 */ 0x07, 0x09, 0x19, 0xBB, 0x3C, 0x80, 0x42, 0x9E, 0x70, 0xAC, 0x03, 0x45, 0x61, 0x79, 0x38, 0x89,
/* 1640 */ 0x07, 0x1C, 0x78, 0x04, 0xD1, 0x0C, 0xBF, 0x3A, 0x07, 0xD1, 0x03, 0x10, 0x06, 0x1A, 0x93, 0x1C,
/* 1650 */ 0xA0, 0x8C, 0x65, 0x03, 0x42, 0x4F, 0x08, 0xB0, 0xBE, 0x10, 0x06, 0x1A, 0x02, 0xC2, 0x96, 0x0D,
/* 1660 */ 0xA7, 0xB0, 0xBE, 0x10, 0x06, 0x1D, 0x4E, 0x6B, 0xD4, 0x3F, 0xC3, 0x42, 0x4F, 0x08, 0xB0, 0xBE,
/* 1670 */ 0x10, 0x06, 0xCF, 0x00, 0x87, 0xED, 0xCD, 0x96, 0x0D, 0xA7, 0xB0, 0xBE, 0x10, 0x03, 0x1D, 0x06,
/* 1680 */ 0x08, 0x1C, 0x95, 0x29, 0x01, 0x72, 0x21, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x1D, 0x96, 0x08,
/* 1690 */ 0x1C, 0x0B, 0x9D, 0x00, 0x44, 0xDD, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x1D, 0x07, 0x4D, 0x26,
/* 16A0 */ 0x0E, 0x8E, 0x05, 0x19, 0x23, 0x7B, 0x6D, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x03, 0x33, 0x1B, 0xC6,
/* 16B0 */ 0x31, 0x35, 0x99, 0xBD, 0xBD, 0xBD, 0x10, 0x06, 0x1D, 0x95, 0x7D, 0x04, 0x42, 0x4B, 0x3D, 0x42,
/* 16C0 */ 0x78, 0x7F, 0x31, 0x9F, 0x7A, 0x8C, 0x0B, 0x5B, 0x73, 0xE5, 0x0A, 0x8D, 0x6A, 0x39, 0x6A, 0x00,
/* 16D0 */ 0x29, 0x38, 0x73, 0xA3, 0x8C, 0x85, 0x94, 0x10, 0x06, 0x1A, 0x60, 0x1F, 0xE5, 0x5B, 0x79, 0x38,
/* 16E0 */ 0x5C, 0x31, 0x76, 0x6E, 0xA9, 0x10, 0x06, 0x1A, 0x93, 0x72, 0x0B, 0x4D, 0x1C, 0x9F, 0x04, 0x42,
/* 16F0 */ 0xB3, 0x10, 0x06, 0x1A, 0x40, 0x03, 0xE4, 0x7F, 0x05, 0x42, 0x6C, 0x33, 0xB3, 0x10, 0x06, 0x1A,
/* 1700 */ 0x0B, 0x3D, 0x00, 0x3C, 0x97, 0x0E, 0x31, 0x84, 0xC0, 0x42, 0xB3, 0x10, 0x06, 0x1A, 0x60, 0x1F,
/* 1710 */ 0xE5, 0xA5, 0x79, 0x38, 0x5C, 0x6D, 0xB3, 0x10, 0x06, 0x1F, 0x2A, 0xAC, 0x4C, 0x0B, 0x05, 0x80,
/* 1720 */ 0x19, 0x64, 0xC0, 0x2C, 0x1B, 0xB3, 0x10, 0x06, 0x1A, 0xDD, 0x02, 0x55, 0x72, 0x0D, 0x53, 0x1B,
/* 1730 */ 0xC9, 0x19, 0xF0, 0x3E, 0x2C, 0x9F, 0x58, 0x2F, 0xDD, 0x02, 0x55, 0x72, 0x97, 0x10, 0x06, 0x1F,
/* 1740 */ 0x98, 0x6C, 0x79, 0x44, 0x3E, 0x37, 0x96, 0x7C, 0xD8, 0x7B, 0x73, 0x0D, 0x91, 0x54, 0x32, 0x0B,
/* 1750 */ 0x6A, 0x0A, 0x0A, 0x71, 0x62, 0xC4, 0x41, 0x37, 0x49, 0x9D, 0x9D, 0x19, 0xA3, 0x87, 0x74, 0x66,
/* 1760 */ 0x0B, 0x00, 0xD1, 0x04, 0x10, 0x06, 0x1A, 0x0A, 0x5D, 0x8B, 0x70, 0x00, 0xD1, 0x03, 0x19, 0x4A,
/* 1770 */ 0xB1, 0x9D, 0x10, 0x06, 0x1A, 0x02, 0xC2, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0x1D, 0x4E, 0x6E, 0xD4,
/* 1780 */ 0x3F, 0xC3, 0x19, 0x4A, 0xB1, 0x9D, 0x10, 0x06, 0xCF, 0x01, 0x94, 0xED, 0xCD, 0x4A, 0xB1, 0x9D,
/* 1790 */ 0x10, 0x06, 0x1D, 0xC3, 0xBF, 0x95, 0x73, 0x02, 0xE4, 0x5D, 0x0E, 0xBA, 0xF1, 0x10, 0x07, 0x1D,
/* 17A0 */ 0xCB, 0x61, 0xD5, 0x7B, 0x08, 0x03, 0x10, 0x06, 0xCF, 0x04, 0x69, 0x41, 0x26, 0x01, 0x02, 0x5D,
/* 17B0 */ 0x1C, 0x39, 0xBA, 0xF1, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x17, 0x00, 0x0D, 0x06, 0x18, 0x64,
/* 17C0 */ 0x64, 0x64, 0x2C, 0x4C, 0x8A, 0xA5, 0x38, 0x58, 0x04, 0x10, 0x06, 0x18, 0xC9, 0x74, 0xEC, 0x70,
/* 17D0 */ 0x38, 0x58, 0x02, 0x10, 0x09, 0x18, 0xC9, 0x64, 0x5E, 0x5A, 0xEC, 0x8A, 0x70, 0x00, 0xC3, 0x05,
/* 17E0 */ 0x5C, 0x58, 0x02, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x05, 0xB2,
/* 17F0 */ 0x00, 0x00, 0x05, 0xB4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x05, 0xB7,
/* 1800 */ 0x00, 0x00, 0x06, 0x75, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x0F, 0x43,
/* 1810 */ 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x17, 0xB5,
/* 1820 */ 0x00, 0x00, 0x17, 0xBD,

464
contrib/mcufont/fonts/FiraSansCondensed-Bold14.mcufont.h Normal file
View file

@ -0,0 +1,464 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 14
* blob size: 7066, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x03, 0xF6, 0x00, 0x00, 0x04, 0x6B, 0x00, 0x00, 0x00, 0x91,
/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x1B, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x0E, 0x00, 0x13, 0x00, 0x03, 0x00, 0x0D, 0x00, 0x01, 0x00, 0x0F, 0x00, 0x11, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x34, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x31, 0x34, 0x00,
/* dictionary data */
0x03, 0x06, 0x80, 0xC9, 0x06, 0xC6, 0x80, 0xCD, 0x02, 0xCA, 0x80,
/* 0080 */ 0xC9, 0x06, 0xC6, 0x80, 0xCD, 0x01, 0x0C, 0x15, 0x80, 0x01, 0x05, 0x09, 0xFA, 0xCA, 0xEA, 0x04,
/* 0090 */ 0xCC, 0x81, 0xDA, 0x0A, 0xC4, 0x80, 0xCE, 0xC1, 0x05, 0xC1, 0x08, 0x3A, 0x07, 0xCD, 0x0B, 0x06,
/* 00A0 */ 0xC4, 0x80, 0x07, 0xC6, 0xCD, 0x01, 0xC5, 0x0B, 0x02, 0x40, 0x23, 0xCE, 0xC7, 0xC4, 0x06, 0x01,
/* 00B0 */ 0xC5, 0x80, 0x01, 0xC9, 0x05, 0xC8, 0x80, 0x80, 0xC3, 0xCC, 0x0B, 0x40, 0x30, 0x02, 0xC4, 0x80,
/* 00C0 */ 0x07, 0xC3, 0x0B, 0x2D, 0xC4, 0x0A, 0xCE, 0x0B, 0xC3, 0x80, 0x07, 0xC5, 0x0F, 0xC3, 0x07, 0x01,
/* 00D0 */ 0xCD, 0xCD, 0xC1, 0x40, 0x08, 0x2C, 0xC9, 0x80, 0xC1, 0xCD, 0x09, 0xC4, 0x81, 0x06, 0x80, 0xC9,
/* 00E0 */ 0xC3, 0xCC, 0x80, 0x02, 0xC4, 0x0B, 0xCE, 0xCB, 0xC1, 0xCE, 0xCA, 0xCE, 0xC9, 0xC5, 0x05, 0xC4,
/* 00F0 */ 0x81, 0x02, 0x80, 0xCD, 0x08, 0xCA, 0x0B, 0x39, 0xCD, 0x80, 0xC1, 0x80, 0xCA, 0xCD, 0xDD, 0xC8,
/* 0100 */ 0x80, 0xC1, 0xC9, 0xC2, 0x81, 0x81, 0xCB, 0xC8, 0x07, 0xC4, 0x80, 0x01, 0xCA, 0x80, 0xC4, 0x01,
/* 0110 */ 0xC4, 0xCA, 0x80, 0xC5, 0xC6, 0xCE, 0xC2, 0xC9, 0x80, 0xC6, 0xDE, 0xC7, 0xCD, 0xCD, 0xCE, 0xC9,
/* 0120 */ 0xC2, 0x80, 0xC7, 0x82, 0xCA, 0x07, 0xD6, 0xCB, 0x0B, 0x80, 0xCB, 0x80, 0xC2, 0x40, 0x07, 0x0E,
/* 0130 */ 0xCB, 0x01, 0x01, 0xC2, 0xCE, 0x80, 0xCB, 0xCC, 0x01, 0xC1, 0x1F, 0xCE, 0x80, 0xC3, 0xCA, 0xC3,
/* 0140 */ 0x01, 0xC3, 0xC8, 0x08, 0xC3, 0x09, 0xC2, 0xCE, 0xC1, 0xCC, 0x80, 0xC5, 0xC6, 0xCD, 0xCE, 0xC3,
/* 0150 */ 0x0B, 0xC9, 0xC1, 0xCB, 0xC3, 0x0B, 0xCE, 0xC2, 0xCE, 0xCC, 0xC9, 0xC7, 0xC7, 0x80, 0xCD, 0x01,
/* 0160 */ 0xCB, 0x84, 0xC9, 0xC1, 0xCC, 0xC1, 0x80, 0xC8, 0xC7, 0x80, 0x11, 0x80, 0xCA, 0xCB, 0xCD, 0xCB,
/* 0170 */ 0xCE, 0x01, 0xC6, 0xC5, 0x80, 0xC1, 0xC3, 0xC8, 0xC2, 0x01, 0xCE, 0x80, 0xC4, 0xCC, 0x2B, 0x01,
/* 0180 */ 0xCC, 0xC1, 0x0B, 0xCA, 0xCC, 0x17, 0xC7, 0xCE, 0x80, 0xCC, 0x80, 0xCE, 0xCE, 0x80, 0xC6, 0x3D,
/* 0190 */ 0xCB, 0x81, 0x80, 0xC1, 0x4D, 0x4A, 0x53, 0x4A, 0x53, 0x1F, 0xA3, 0x0E, 0x54, 0x2D, 0x54, 0x34,
/* 01A0 */ 0x0D, 0x2A, 0x08, 0x94, 0x64, 0x54, 0x2A, 0x08, 0x06, 0x0F, 0x2E, 0x62, 0x1A, 0x62, 0x1A, 0x62,
/* 01B0 */ 0x1A, 0x62, 0x4B, 0x2C, 0xA8, 0x9E, 0x91, 0x19, 0x44, 0x54, 0x6D, 0x5E, 0x18, 0x64, 0x54, 0x62,
/* 01C0 */ 0x6D, 0x5E, 0x18, 0x64, 0x54, 0x62, 0x0D, 0x6D, 0x00, 0x9E, 0x6D, 0x19, 0x07, 0xA3, 0x77, 0xA4,
/* 01D0 */ 0x01, 0x19, 0x50, 0x73, 0x07, 0x0F, 0x88, 0x0B, 0xA4, 0x7F, 0x01, 0x58, 0x96, 0x6D, 0x2D, 0xA3,
/* 01E0 */ 0x34, 0x0D, 0x2A, 0x08, 0x94, 0x7E, 0x5F, 0x2A, 0x08, 0x94, 0x7E, 0x5F, 0x2D, 0xA3, 0x34, 0x0D,
/* 01F0 */ 0x2A, 0x50, 0x72, 0x78, 0x5F, 0x3E, 0x78, 0x91, 0x30, 0x3B, 0x94, 0xA3, 0x1F, 0x92, 0x84, 0xA8,
/* 0200 */ 0x2A, 0x8D, 0x78, 0x2F, 0x78, 0x2F, 0x00, 0x08, 0x4B, 0x19, 0x62, 0x68, 0x8D, 0x83, 0x2A, 0x07,
/* 0210 */ 0x4B, 0x9B, 0x01, 0x3B, 0x72, 0x02, 0xA3, 0x1F, 0x69, 0x98, 0x7F, 0x8D, 0x4B, 0x63, 0x1F, 0x07,
/* 0220 */ 0xA4, 0xA8, 0x1F, 0x40, 0x72, 0x86, 0x68, 0x30, 0x3B, 0x0A, 0x0F, 0x90, 0x30, 0x41, 0x0D, 0x8F,
/* 0230 */ 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91, 0x41, 0xA3, 0x35, 0x91,
/* 0240 */ 0x41, 0x54, 0x8D, 0x91, 0x3B, 0x5F, 0xA7, 0x7F, 0x09, 0x8A, 0x08, 0xA3, 0x04, 0x55, 0x9E, 0x0B,
/* 0250 */ 0x0B, 0xA4, 0x9F, 0x7C, 0x55, 0x08, 0x0D, 0x5F, 0x37, 0x2D, 0xA4, 0x0A, 0x5F, 0x43, 0x0A, 0x6D,
/* 0260 */ 0x9B, 0x43, 0x5C, 0x8A, 0x0F, 0x6D, 0x2A, 0x87, 0x4F, 0x4C, 0x2F, 0x7B, 0x08, 0x0D, 0x54, 0x07,
/* 0270 */ 0x2A, 0x62, 0xA4, 0x96, 0x6D, 0x65, 0x3C, 0x65, 0x3C, 0x65, 0x0F, 0x63, 0x00, 0x08, 0x25, 0x34,
/* 0280 */ 0x09, 0x2C, 0xA4, 0x01, 0x05, 0x4B, 0x2C, 0x0E, 0x83, 0x05, 0x4B, 0x2C, 0x0B, 0x0F, 0x52, 0x4B,
/* 0290 */ 0x2C, 0x0A, 0x6B, 0x05, 0x4B, 0x2C, 0x60, 0x91, 0x4B, 0x2C, 0x0B, 0x04, 0x72, 0x4B, 0x2C, 0x76,
/* 02A0 */ 0x69, 0x4B, 0x2C, 0x0B, 0x62, 0x0F, 0x4B, 0x2C, 0x0B, 0x34, 0x2A, 0x92, 0x98, 0x38, 0x98, 0x38,
/* 02B0 */ 0x98, 0x38, 0x6E, 0x37, 0x61, 0x0F, 0x21, 0x01, 0x30, 0x53, 0x4A, 0x18, 0x3A, 0x6E, 0x6F, 0x64,
/* 02C0 */ 0x5F, 0x24, 0x06, 0x18, 0x53, 0x4A, 0x22, 0x64, 0x5F, 0x21, 0x02, 0x61, 0x6E, 0x63, 0x57, 0x65,
/* 02D0 */ 0x2A, 0x9B, 0x97, 0x4B, 0x61, 0x6E, 0x54, 0x2A, 0x08, 0x54, 0x24, 0x0F, 0x73, 0x1E, 0x8D, 0x68,
/* 02E0 */ 0x00, 0x44, 0x83, 0x1E, 0x59, 0x37, 0x00, 0x62, 0x4B, 0x47, 0x74, 0x26, 0x01, 0x01, 0x7A, 0x28,
/* 02F0 */ 0x55, 0x40, 0x2B, 0x26, 0x2B, 0x26, 0x2B, 0x26, 0x30, 0x97, 0x8E, 0x43, 0x04, 0xA0, 0x72, 0x0A,
/* 0300 */ 0x02, 0x22, 0x36, 0x33, 0x36, 0x26, 0x71, 0x26, 0x76, 0x4B, 0x3C, 0x91, 0x25, 0x62, 0x91, 0x25,
/* 0310 */ 0x62, 0x18, 0x97, 0x01, 0x1E, 0x66, 0x0D, 0x18, 0x05, 0x37, 0x22, 0x05, 0x69, 0x0D, 0x30, 0x9E,
/* 0320 */ 0x0B, 0x1E, 0x77, 0x95, 0x3A, 0x04, 0x2A, 0x8A, 0x02, 0x61, 0x0F, 0x6B, 0x91, 0x61, 0x0E, 0x26,
/* 0330 */ 0x2E, 0x5C, 0x6F, 0x00, 0x46, 0x08, 0x94, 0x00, 0x53, 0x08, 0x94, 0x00, 0x53, 0x08, 0x94, 0x00,
/* 0340 */ 0x53, 0x5C, 0x0A, 0x72, 0x25, 0x77, 0x25, 0x59, 0x37, 0x34, 0x27, 0x8C, 0x30, 0x59, 0x63, 0x36,
/* 0350 */ 0x0C, 0x18, 0xA5, 0x36, 0x0C, 0x18, 0xA5, 0x1E, 0x8C, 0x30, 0x59, 0x63, 0x1E, 0x40, 0x37, 0x34,
/* 0360 */ 0x27, 0x62, 0xA4, 0x96, 0x6D, 0x55, 0x08, 0x0D, 0x54, 0x06, 0x18, 0x08, 0x0E, 0x01, 0x98, 0x96,
/* 0370 */ 0x45, 0x18, 0x7A, 0x32, 0x97, 0x6E, 0x73, 0x22, 0xA2, 0x01, 0x22, 0x0E, 0x2C, 0x1D, 0x0E, 0x72,
/* 0380 */ 0x1F, 0x62, 0x5F, 0x3E, 0x98, 0x3F, 0x98, 0x3F, 0x54, 0x06, 0x00, 0x5C, 0x71, 0x86, 0x68, 0x86,
/* 0390 */ 0x68, 0x86, 0x68, 0x86, 0x68, 0x86, 0x20, 0x00, 0x2D, 0x8E, 0x30, 0x19, 0x40, 0x05, 0xA3, 0x35,
/* 03A0 */ 0x91, 0x09, 0x91, 0x00, 0x19, 0x77, 0x51, 0x8A, 0x4E, 0x42, 0x0D, 0x19, 0x7A, 0x5F, 0x96, 0x54,
/* 03B0 */ 0x55, 0x66, 0x5C, 0x80, 0x9E, 0x72, 0x80, 0x64, 0x02, 0x0F, 0x54, 0x6C, 0x61, 0x94, 0x30, 0x28,
/* 03C0 */ 0x4C, 0x2F, 0x48, 0x38, 0x04, 0x32, 0x8A, 0x02, 0x61, 0xA3, 0x0D, 0x72, 0x61, 0x0E, 0x99, 0x5F,
/* 03D0 */ 0x61, 0x2E, 0x59, 0x73, 0x2C, 0x2E, 0x59, 0x73, 0x2C, 0x0E, 0x64, 0xA4, 0x61, 0xA3, 0x58, 0x6F,
/* 03E0 */ 0x04, 0xA4, 0x0A, 0x4F, 0x01, 0x61, 0x2B, 0x04, 0x54, 0x2A, 0x2A, 0x35, 0x6D, 0x0C, 0x73, 0x2A,
/* 03F0 */ 0x77, 0x0F, 0x07, 0x22, 0x41, 0x73, 0x3C, 0x08, 0x71, 0x55, 0x0D, 0x55, 0x49, 0x0B, 0x49, 0x0B,
/* 0400 */ 0x0B, 0x09, 0x22, 0x2D, 0x5F, 0x3C, 0x81, 0x56, 0x75, 0x2B, 0x04, 0x54, 0x55, 0x06, 0x55, 0x4C,
/* 0410 */ 0x0F, 0x09, 0x55, 0x3C, 0x65, 0x3C, 0x65, 0x22, 0x00, 0x26, 0x55, 0x7A, 0x03, 0x55, 0x05, 0x0E,
/* 0420 */ 0x31, 0x26, 0x3D, 0x7A, 0x37, 0x00, 0x3B, 0x0B, 0xA4, 0x8F, 0x0E, 0x01, 0x6B, 0x28, 0x95, 0x1F,
/* 0430 */ 0x77, 0x23, 0x02, 0x04, 0x6D, 0x3F, 0x40, 0x0B, 0x02, 0x25, 0x44, 0x6D, 0x86, 0x85, 0x02, 0x72,
/* 0440 */ 0x55, 0x49, 0x06, 0x72, 0x2C, 0x2E, 0x06, 0x94, 0x3F, 0x98, 0x3F, 0xA3, 0x05, 0x55, 0x50, 0x72,
/* 0450 */ 0x7C, 0x2D, 0x94, 0x97, 0x4B, 0x30, 0x36, 0x6E, 0x72, 0x2A, 0x08, 0x54, 0x21, 0x07, 0x2D, 0xA3,
/* 0460 */ 0x30, 0x28, 0x50, 0xA3, 0x0B, 0x91, 0x2A, 0x25, 0x40, 0x08, 0x68,
/* dictionary offset */
0x00, 0x00, 0x00, 0x01, 0x00,
/* 0470 */ 0x02, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x19, 0x00,
/* 0480 */ 0x1A, 0x00, 0x1B, 0x00, 0x1D, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x21, 0x00, 0x24, 0x00, 0x26, 0x00,
/* 0490 */ 0x27, 0x00, 0x28, 0x00, 0x2A, 0x00, 0x2D, 0x00, 0x2F, 0x00, 0x31, 0x00, 0x33, 0x00, 0x34, 0x00,
/* 04A0 */ 0x36, 0x00, 0x38, 0x00, 0x3A, 0x00, 0x3D, 0x00, 0x3F, 0x00, 0x42, 0x00, 0x44, 0x00, 0x46, 0x00,
/* 04B0 */ 0x48, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4E, 0x00, 0x4F, 0x00, 0x51, 0x00, 0x53, 0x00, 0x55, 0x00,
/* 04C0 */ 0x57, 0x00, 0x58, 0x00, 0x5A, 0x00, 0x5C, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x61, 0x00, 0x63, 0x00,
/* 04D0 */ 0x65, 0x00, 0x69, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x71, 0x00, 0x73, 0x00, 0x75, 0x00,
/* 04E0 */ 0x77, 0x00, 0x79, 0x00, 0x7D, 0x00, 0x7F, 0x00, 0x80, 0x00, 0x82, 0x00, 0x83, 0x00, 0x85, 0x00,
/* 04F0 */ 0x87, 0x00, 0x89, 0x00, 0x8A, 0x00, 0x8C, 0x00, 0x8E, 0x00, 0x90, 0x00, 0x91, 0x00, 0x93, 0x00,
/* 0500 */ 0x96, 0x00, 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9F, 0x00, 0xA1, 0x00, 0xA3, 0x00, 0xA5, 0x00,
/* 0510 */ 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xAF, 0x00, 0xB1, 0x00, 0xB2, 0x00,
/* 0520 */ 0xB4, 0x00, 0xB6, 0x00, 0xB8, 0x00, 0xBA, 0x00, 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00,
/* 0530 */ 0xC3, 0x00, 0xC5, 0x00, 0xC6, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00,
/* 0540 */ 0xD3, 0x00, 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE1, 0x00,
/* 0550 */ 0xE3, 0x00, 0xE5, 0x00, 0xE7, 0x00, 0xEA, 0x00, 0xEC, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00,
/* 0560 */ 0xF3, 0x00, 0xF5, 0x00, 0xF6, 0x00, 0xF8, 0x00, 0xFA, 0x00, 0xFC, 0x00, 0xFE, 0x01, 0x00, 0x01,
/* 0570 */ 0x02, 0x01, 0x04, 0x01, 0x07, 0x01, 0x09, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01,
/* 0580 */ 0x11, 0x01, 0x13, 0x01, 0x15, 0x01, 0x17, 0x01, 0x1A, 0x01, 0x1B, 0x01, 0x1D, 0x01, 0x1F, 0x01,
/* 0590 */ 0x25, 0x01, 0x33, 0x01, 0x45, 0x01, 0x51, 0x01, 0x60, 0x01, 0x62, 0x01, 0x7F, 0x01, 0x8D, 0x01,
/* 05A0 */ 0x91, 0x01, 0xBB, 0x01, 0xD6, 0x01, 0xF7, 0x02, 0x00, 0x02, 0x05, 0x02, 0x08, 0x02, 0x0A, 0x02,
/* 05B0 */ 0x35, 0x02, 0x37, 0x02, 0x3D, 0x02, 0x5A, 0x02, 0x75, 0x02, 0x77, 0x02, 0x7B, 0x02, 0x7D, 0x02,
/* 05C0 */ 0x83, 0x02, 0x90, 0x02, 0x94, 0x02, 0x96, 0x02, 0x9C, 0x02, 0xB2, 0x02, 0xBA, 0x02, 0xBE, 0x02,
/* 05D0 */ 0xC0, 0x02, 0xCD, 0x02, 0xCF, 0x02, 0xD1, 0x02, 0xD3, 0x02, 0xF6, 0x03, 0x07, 0x03, 0x09, 0x03,
/* 05E0 */ 0x13, 0x03, 0x16, 0x03, 0x18, 0x03, 0x21, 0x03, 0x26, 0x03, 0x28, 0x03, 0x2C, 0x03, 0x2F, 0x03,
/* 05F0 */ 0x35, 0x03, 0x3D, 0x03, 0x44, 0x03, 0x49, 0x03, 0x4B, 0x03, 0x51, 0x03, 0x75, 0x03, 0x7D, 0x03,
/* 0600 */ 0x85, 0x03, 0x8B, 0x03, 0x8D, 0x03, 0x94, 0x03, 0x98, 0x03, 0x9C, 0x03, 0x9E, 0x03, 0xA3, 0x03,
/* 0610 */ 0xA5, 0x03, 0xA7, 0x03, 0xA9, 0x03, 0xAB, 0x03, 0xAD, 0x03, 0xAF, 0x03, 0xB5, 0x03, 0xBA, 0x03,
/* 0620 */ 0xBC, 0x03, 0xBE, 0x03, 0xC0, 0x03, 0xC2, 0x03, 0xC9, 0x03, 0xCB, 0x03, 0xCD, 0x03, 0xCF, 0x03,
/* 0630 */ 0xD1, 0x03, 0xD3, 0x03, 0xD6, 0x03, 0xF0, 0x03, 0xF2, 0x03, 0xF4, 0x03, 0xF6,
/* char range info */
0x00, 0x00, 0x03,
/* 0640 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x14, 0x00, 0x28, 0x00, 0x51, 0x00, 0x82, 0x00, 0xC4,
/* 0650 */ 0x00, 0xFA, 0x01, 0x07, 0x01, 0x2E, 0x01, 0x53, 0x01, 0x6C, 0x01, 0x76, 0x01, 0x80, 0x01, 0x8B,
/* 0660 */ 0x01, 0x90, 0x01, 0xB0, 0x01, 0xE0, 0x01, 0xF8, 0x02, 0x1B, 0x02, 0x44, 0x02, 0x64, 0x02, 0x90,
/* 0670 */ 0x02, 0xBA, 0x02, 0xD8, 0x03, 0x04, 0x03, 0x33, 0x03, 0x3A, 0x03, 0x46, 0x03, 0x63, 0x03, 0x6B,
/* 0680 */ 0x03, 0x84, 0x03, 0xA0, 0x03, 0xFA, 0x04, 0x01, 0x04, 0x25, 0x04, 0x46, 0x04, 0x68, 0x04, 0x6C,
/* 0690 */ 0x04, 0x86, 0x04, 0xB7, 0x04, 0xC8, 0x04, 0xCE, 0x04, 0xE0, 0x05, 0x06, 0x05, 0x16, 0x05, 0x5A,
/* 06A0 */ 0x05, 0x60, 0x05, 0x66, 0x05, 0x80, 0x05, 0xB6, 0x05, 0xDC, 0x06, 0x09, 0x06, 0x1E, 0x06, 0x24,
/* 06B0 */ 0x06, 0x50, 0x06, 0x97, 0x06, 0xC0, 0x06, 0xC9, 0x06, 0xED, 0x06, 0xFF, 0x07, 0x22, 0x07, 0x3B,
/* 06C0 */ 0x07, 0x53, 0x07, 0x5D, 0x07, 0x6A, 0x07, 0x70, 0x07, 0x96, 0x07, 0xB3, 0x07, 0xCB, 0x07, 0xD2,
/* 06D0 */ 0x07, 0xF5, 0x08, 0x2C, 0x08, 0x3D, 0x08, 0x47, 0x08, 0x5B, 0x08, 0x81, 0x08, 0x8F, 0x08, 0xAB,
/* 06E0 */ 0x08, 0xB8, 0x08, 0xBF, 0x08, 0xC7, 0x08, 0xE0, 0x08, 0xF2, 0x09, 0x13, 0x09, 0x33, 0x09, 0x39,
/* 06F0 */ 0x09, 0x59, 0x09, 0x8D, 0x09, 0xB0, 0x09, 0xB5, 0x09, 0xD2, 0x09, 0xF4, 0x09, 0xFE, 0x0A, 0x24,
/* 0700 */ 0x03, 0x00, 0x10, 0x03, 0x74, 0xD3, 0x92, 0x56, 0x06, 0xC4, 0x06, 0xC4, 0x05, 0x91, 0x3C, 0xF3,
/* 0710 */ 0x30, 0xA1, 0xDE, 0x10, 0x06, 0x74, 0x05, 0x6D, 0x5C, 0x33, 0x3A, 0x06, 0x92, 0x43, 0x7E, 0x83,
/* 0720 */ 0x06, 0x73, 0x2A, 0x77, 0x63, 0x05, 0x73, 0x10, 0x07, 0x46, 0xF3, 0xF3, 0x00, 0x41, 0x83, 0x06,
/* 0730 */ 0x83, 0x41, 0x8E, 0x0E, 0x3B, 0x58, 0x5A, 0x4B, 0x2A, 0x8D, 0x1D, 0x96, 0x1F, 0x5B, 0x44, 0x0C,
/* 0740 */ 0x55, 0x08, 0xA4, 0x0A, 0xA4, 0x33, 0x9E, 0x8E, 0x07, 0x3B, 0x91, 0xF3, 0x2A, 0x34, 0x70, 0x83,
/* 0750 */ 0x10, 0x07, 0x1C, 0xFE, 0x2F, 0x03, 0x83, 0x25, 0x67, 0x72, 0xEB, 0x81, 0x6E, 0x37, 0xBA, 0x0C,
/* 0760 */ 0x99, 0x7F, 0x5C, 0x38, 0x26, 0xD2, 0x1F, 0xEC, 0x5F, 0x90, 0x25, 0x66, 0x6D, 0x86, 0x94, 0x19,
/* 0770 */ 0x64, 0x0A, 0x02, 0x82, 0xFD, 0x48, 0x6E, 0x89, 0x00, 0x41, 0x0A, 0x94, 0x02, 0xFE, 0x2F, 0x03,
/* 0780 */ 0x83, 0x10, 0x0B, 0x00, 0x93, 0xEE, 0x19, 0x35, 0x8A, 0x03, 0x30, 0xA0, 0x1E, 0xF8, 0x0E, 0x76,
/* 0790 */ 0xF3, 0x36, 0x35, 0x0E, 0x00, 0x5B, 0x19, 0xF8, 0x4F, 0x07, 0x83, 0x19, 0x62, 0x8A, 0x04, 0x4F,
/* 07A0 */ 0x06, 0x09, 0x04, 0x2A, 0x62, 0x94, 0x5F, 0x37, 0x2C, 0x08, 0x0D, 0x0B, 0x50, 0x08, 0x19, 0x5B,
/* 07B0 */ 0x49, 0x0A, 0x00, 0x0E, 0x09, 0x1E, 0x07, 0x83, 0x62, 0x4F, 0x68, 0x22, 0x9E, 0x76, 0x77, 0x96,
/* 07C0 */ 0x09, 0x19, 0x7A, 0x10, 0x0A, 0x74, 0x7A, 0x0A, 0x69, 0x0A, 0x28, 0x48, 0x5B, 0x4B, 0x2A, 0x8D,
/* 07D0 */ 0x83, 0x98, 0x76, 0xBA, 0x09, 0x0A, 0x6D, 0x1F, 0x23, 0x09, 0x7A, 0x2D, 0x5F, 0x94, 0x00, 0x5B,
/* 07E0 */ 0x1E, 0x59, 0x63, 0x0A, 0xA3, 0x91, 0x1E, 0x40, 0xA8, 0x8D, 0x0F, 0x73, 0x1E, 0x50, 0x54, 0x51,
/* 07F0 */ 0x5F, 0x90, 0x22, 0x7E, 0x0B, 0x69, 0x6C, 0x0B, 0x8F, 0x10, 0x03, 0x74, 0x05, 0x6D, 0x25, 0x64,
/* 0800 */ 0x68, 0x22, 0x3B, 0x83, 0xCC, 0x63, 0x10, 0x04, 0x47, 0x62, 0x07, 0x25, 0x34, 0x71, 0x0C, 0x37,
/* 0810 */ 0xFE, 0x2B, 0x08, 0xC4, 0x0A, 0x6D, 0x25, 0x9E, 0x68, 0x25, 0x9E, 0x68, 0x25, 0x8D, 0x6D, 0x19,
/* 0820 */ 0x36, 0xB8, 0xE9, 0x38, 0x44, 0x73, 0x22, 0x2D, 0xC4, 0x9E, 0x09, 0x18, 0xEA, 0x10, 0x04, 0x9D,
/* 0830 */ 0x05, 0x0B, 0x1B, 0x08, 0x6D, 0x3C, 0x50, 0x27, 0x1E, 0x62, 0x68, 0x3C, 0xFA, 0x1E, 0xF9, 0xFE,
/* 0840 */ 0x1D, 0xFE, 0x0F, 0x22, 0x61, 0x3F, 0xF8, 0x86, 0x6D, 0x3C, 0x0E, 0x73, 0x18, 0x2D, 0xC4, 0xA2,
/* 0850 */ 0x9F, 0x7A, 0x10, 0x06, 0x00, 0x29, 0x4F, 0x1F, 0x64, 0x9C, 0x0A, 0x06, 0x43, 0x62, 0x6E, 0xFD,
/* 0860 */ 0x7A, 0x5C, 0x68, 0x28, 0x81, 0x95, 0x45, 0x1F, 0x08, 0x04, 0x70, 0x10, 0x07, 0xA1, 0xC9, 0x36,
/* 0870 */ 0x33, 0x36, 0x33, 0xC2, 0x04, 0x10, 0x03, 0x74, 0x39, 0x05, 0x32, 0x3C, 0xD3, 0x40, 0xE1, 0x10,
/* 0880 */ 0x05, 0x75, 0x39, 0x64, 0x21, 0x06, 0x30, 0x2D, 0x5F, 0x94, 0x10, 0x03, 0x57, 0x39, 0xDE, 0x10,
/* 0890 */ 0x07, 0xEE, 0x04, 0x9F, 0x05, 0xC4, 0x48, 0x2F, 0x0D, 0x73, 0xCD, 0x2B, 0x98, 0x56, 0xFF, 0x25,
/* 08A0 */ 0x9E, 0x73, 0xCD, 0x3F, 0x26, 0x56, 0x08, 0x6D, 0x25, 0x8D, 0xAE, 0x0F, 0x3F, 0x64, 0x05, 0x10,
/* 08B0 */ 0x08, 0x74, 0x7A, 0x51, 0x32, 0x55, 0x8D, 0xA3, 0x0D, 0x83, 0x19, 0x77, 0xA4, 0x34, 0x0C, 0x41,
/* 08C0 */ 0xA3, 0x00, 0x5E, 0xBA, 0x76, 0x5E, 0x01, 0x19, 0x92, 0x76, 0x5E, 0x01, 0x19, 0x05, 0xA3, 0x00,
/* 08D0 */ 0x5E, 0x19, 0x77, 0xA4, 0x34, 0x0C, 0x2A, 0x8D, 0xA3, 0x0D, 0x68, 0x2A, 0x7A, 0x51, 0x32, 0x10,
/* 08E0 */ 0x06, 0x74, 0x7A, 0x0A, 0xA4, 0x55, 0x64, 0x58, 0xA4, 0x55, 0x35, 0x4B, 0xA4, 0x1F, 0x99, 0x40,
/* 08F0 */ 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0xF4, 0x0E, 0x10, 0x06, 0xA6, 0xF1, 0x0A, 0x69, 0x8F, 0x2A, 0x9E,
/* 0900 */ 0x72, 0x78, 0x6F, 0x77, 0x04, 0x34, 0xFB, 0x0A, 0x4B, 0x1F, 0x34, 0x27, 0x22, 0x81, 0x63, 0x00,
/* 0910 */ 0xF7, 0x68, 0x1F, 0x35, 0xA4, 0x21, 0x01, 0x19, 0x8D, 0x8E, 0x10, 0x07, 0xA6, 0xF1, 0x0A, 0x69,
/* 0920 */ 0x0A, 0x28, 0xCB, 0x0D, 0x72, 0x55, 0x99, 0x00, 0x40, 0x3F, 0xF8, 0x25, 0x0E, 0x72, 0x01, 0x25,
/* 0930 */ 0x5A, 0xC4, 0x59, 0x73, 0x2A, 0x99, 0x7A, 0x5F, 0x43, 0x0C, 0x0E, 0x95, 0xA3, 0x00, 0x3B, 0x0B,
/* 0940 */ 0x69, 0x0A, 0x02, 0x10, 0x07, 0x46, 0x97, 0x6C, 0x25, 0x9E, 0x63, 0xFE, 0x2B, 0x5C, 0xB8, 0x9B,
/* 0950 */ 0x02, 0x0C, 0x1D, 0x61, 0x0C, 0x9B, 0x2A, 0x35, 0x54, 0x0A, 0x0F, 0x4B, 0x19, 0x62, 0x8E, 0x3F,
/* 0960 */ 0x5F, 0x1B, 0x5F, 0x10, 0x07, 0xBE, 0x6E, 0x1D, 0x61, 0x0E, 0x24, 0x7F, 0x26, 0x71, 0x04, 0x54,
/* 0970 */ 0x08, 0x9A, 0x00, 0x61, 0x6E, 0x45, 0x19, 0x7A, 0x05, 0x03, 0x81, 0x83, 0x25, 0x8D, 0x6D, 0x2A,
/* 0980 */ 0x64, 0x00, 0x44, 0x83, 0x2A, 0x48, 0x79, 0x0F, 0x45, 0x19, 0x7A, 0x0A, 0x69, 0x0A, 0x02, 0x10,
/* 0990 */ 0x07, 0xC9, 0x84, 0x4F, 0x28, 0x06, 0xA4, 0x0A, 0x0B, 0x55, 0x9B, 0x80, 0x64, 0x54, 0xCB, 0x01,
/* 09A0 */ 0x2D, 0x0F, 0xA3, 0x58, 0x6F, 0x8C, 0x64, 0xA4, 0x41, 0xA3, 0x00, 0x5E, 0x3B, 0xA4, 0x34, 0x0D,
/* 09B0 */ 0x2A, 0x9E, 0xA3, 0x0E, 0x6D, 0x2A, 0x77, 0x96, 0x32, 0x10, 0x06, 0x74, 0x0D, 0x6E, 0xA3, 0x55,
/* 09C0 */ 0x08, 0x0A, 0xA0, 0x72, 0x25, 0x8D, 0x68, 0xF1, 0x0F, 0xA8, 0x18, 0xBA, 0x56, 0x0D, 0x63, 0xFE,
/* 09D0 */ 0x3F, 0xD8, 0x25, 0x7C, 0x00, 0xEA, 0xA0, 0x10, 0x07, 0x46, 0x9C, 0x54, 0x7F, 0x01, 0x78, 0x96,
/* 09E0 */ 0x6D, 0x61, 0x0C, 0x00, 0xFA, 0x3B, 0xA4, 0x01, 0x08, 0x6D, 0x55, 0x08, 0xA4, 0x94, 0x55, 0x87,
/* 09F0 */ 0x94, 0x0F, 0x83, 0x2A, 0x08, 0x4B, 0x64, 0xA4, 0x2A, 0xD8, 0x5E, 0x41, 0x5F, 0x5A, 0x72, 0x55,
/* 0A00 */ 0x84, 0xA4, 0x8F, 0x10, 0x07, 0x46, 0x9C, 0x54, 0x06, 0xC0, 0x72, 0x7C, 0x19, 0x35, 0x4B, 0x00,
/* 0A10 */ 0x5C, 0x6F, 0x0A, 0x6D, 0x97, 0xA3, 0x2A, 0x08, 0x72, 0x01, 0x0A, 0xA3, 0x2A, 0x81, 0x6E, 0x94,
/* 0A20 */ 0x00, 0x3B, 0x8B, 0x0C, 0x6D, 0x18, 0x2D, 0xA4, 0x28, 0x04, 0xA7, 0x05, 0x55, 0x44, 0x72, 0x80,
/* 0A30 */ 0x64, 0x02, 0x10, 0x03, 0x31, 0xDE, 0x55, 0x7B, 0xDE, 0x10, 0x03, 0x31, 0xDE, 0x00, 0x3D, 0x41,
/* 0A40 */ 0x32, 0x3C, 0xD3, 0x40, 0xE1, 0x10, 0x07, 0x3C, 0x3D, 0xEE, 0x08, 0x0A, 0x1F, 0x67, 0x5F, 0x90,
/* 0A50 */ 0xBA, 0x72, 0x04, 0x55, 0x35, 0x94, 0x01, 0x25, 0x9C, 0x0F, 0x4B, 0x80, 0x64, 0x0B, 0xA4, 0x9F,
/* 0A60 */ 0x03, 0x06, 0x10, 0x07, 0x39, 0x64, 0xD5, 0x1E, 0x64, 0xD5, 0x10, 0x07, 0x31, 0x4C, 0x2F, 0xEC,
/* 0A70 */ 0xD2, 0xEA, 0x6A, 0x54, 0x02, 0x1F, 0x64, 0x7C, 0x00, 0x41, 0x23, 0x8F, 0xBA, 0x0E, 0x08, 0x01,
/* 0A80 */ 0xEA, 0x07, 0x01, 0x10, 0x06, 0x74, 0x5D, 0x0E, 0xA3, 0xEB, 0x08, 0xA3, 0x0D, 0x54, 0x30, 0x3B,
/* 0A90 */ 0x34, 0x0E, 0x18, 0x3B, 0x0D, 0x6D, 0x25, 0xA5, 0xF1, 0x4F, 0x30, 0xA1, 0x87, 0x07, 0xE4, 0x10,
/* 0AA0 */ 0x0D, 0xC9, 0x77, 0x08, 0x6B, 0x4F, 0x33, 0xEC, 0xA3, 0xA0, 0x0E, 0x4B, 0x18, 0x7E, 0xA4, 0x04,
/* 0AB0 */ 0x06, 0x8B, 0x03, 0x0B, 0x68, 0x30, 0x8D, 0x63, 0x07, 0x6E, 0x45, 0x69, 0x00, 0x77, 0x0F, 0x90,
/* 0AC0 */ 0x69, 0x01, 0x69, 0x8D, 0x37, 0x64, 0x4B, 0x03, 0x94, 0x00, 0x69, 0x35, 0x83, 0x34, 0x08, 0x04,
/* 0AD0 */ 0x94, 0x00, 0x69, 0x35, 0x63, 0x64, 0x4B, 0x40, 0x76, 0x69, 0x9E, 0xA8, 0x00, 0xF6, 0x9B, 0x79,
/* 0AE0 */ 0x72, 0x94, 0x30, 0x9E, 0x37, 0x04, 0x5B, 0x03, 0x08, 0x4F, 0x01, 0x18, 0x05, 0x54, 0x88, 0x92,
/* 0AF0 */ 0xA3, 0x0A, 0x95, 0x05, 0x3B, 0x0A, 0x58, 0x4F, 0x05, 0x10, 0x08, 0x46, 0x62, 0xB0, 0x37, 0xBD,
/* 0B00 */ 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x2E, 0xD0, 0x40, 0x73, 0xD0, 0x06, 0x0F, 0x27, 0x64, 0x6E, 0x54,
/* 0B10 */ 0x43, 0x04, 0x5F, 0xA0, 0x0F, 0x90, 0xD0, 0x44, 0x6D, 0xD0, 0x44, 0x6D, 0x2C, 0x94, 0x23, 0x03,
/* 0B20 */ 0x2C, 0x5F, 0x4F, 0x04, 0x10, 0x07, 0xC9, 0x6A, 0xD2, 0x30, 0x36, 0x4F, 0x8A, 0x2A, 0x5E, 0x04,
/* 0B30 */ 0x7A, 0x01, 0x2D, 0xA4, 0x19, 0x36, 0x38, 0x5C, 0x38, 0x06, 0xA4, 0xCC, 0xB7, 0x77, 0x55, 0x48,
/* 0B40 */ 0x4F, 0x5B, 0x28, 0x6A, 0xD2, 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x45, 0xD0, 0x44, 0x6D, 0x00, 0x53,
/* 0B50 */ 0x08, 0x72, 0xD0, 0x97, 0x0F, 0x2E, 0x53, 0x92, 0x2E, 0x53, 0x08, 0x72, 0xD0, 0x44, 0x91, 0x2C,
/* 0B60 */ 0x94, 0x58, 0x45, 0x2C, 0x0F, 0xA4, 0x6C, 0x10, 0x07, 0xBE, 0xBC, 0x10, 0x06, 0xBE, 0x6E, 0x1D,
/* 0B70 */ 0x61, 0x0F, 0x24, 0x09, 0x18, 0x53, 0x4A, 0x22, 0x64, 0x5F, 0x24, 0x05, 0x2A, 0x64, 0x6E, 0x91,
/* 0B80 */ 0x18, 0x53, 0x4A, 0x53, 0x4A, 0x10, 0x08, 0x46, 0x97, 0x0C, 0xA4, 0x8F, 0xBA, 0x0F, 0x79, 0x83,
/* 0B90 */ 0x1E, 0x77, 0xB7, 0x7A, 0x2D, 0x0F, 0x2B, 0x08, 0xA3, 0x62, 0x0F, 0x94, 0x19, 0x08, 0xA3, 0x00,
/* 0BA0 */ 0x05, 0x0C, 0x94, 0x19, 0x8C, 0x30, 0x07, 0x94, 0xD6, 0x73, 0x00, 0x92, 0x6F, 0x0B, 0x54, 0x0A,
/* 0BB0 */ 0x78, 0x6F, 0x5D, 0x0D, 0x54, 0x6C, 0x10, 0x08, 0xBE, 0x4D, 0xCA, 0x0A, 0x2C, 0x8E, 0x0A, 0x2C,
/* 0BC0 */ 0x94, 0x5A, 0x94, 0x00, 0x53, 0xCA, 0x0A, 0x10, 0x04, 0xBE, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x46,
/* 0BD0 */ 0xB1, 0xB1, 0xB1, 0xB1, 0x0E, 0x83, 0xCD, 0x37, 0x25, 0x48, 0x2B, 0x69, 0x88, 0x04, 0x01, 0x10,
/* 0BE0 */ 0x08, 0xBE, 0x4D, 0x07, 0xA3, 0xD0, 0x02, 0x7C, 0xD0, 0x0A, 0x4B, 0x61, 0x63, 0xA4, 0x01, 0x61,
/* 0BF0 */ 0xA3, 0xFD, 0x64, 0x5F, 0x5C, 0x2E, 0x61, 0xA8, 0xA5, 0x00, 0xD0, 0x07, 0xA4, 0x01, 0xD0, 0x50,
/* 0C00 */ 0x6D, 0x00, 0x53, 0x92, 0x27, 0x10, 0x07, 0xBE, 0xA9, 0x26, 0x4D, 0x4A, 0x53, 0x30, 0x61, 0x54,
/* 0C10 */ 0x5B, 0x04, 0x61, 0x6E, 0x37, 0x10, 0x0A, 0x46, 0x0F, 0xA4, 0x30, 0x58, 0xA8, 0x18, 0x7A, 0x5F,
/* 0C20 */ 0x73, 0x01, 0x5F, 0x73, 0x18, 0x7A, 0xA4, 0x83, 0x40, 0x7C, 0x22, 0xF6, 0x6D, 0xF8, 0x63, 0x22,
/* 0C30 */ 0x40, 0x5A, 0x0A, 0x08, 0x0E, 0x65, 0x18, 0x64, 0x94, 0x5A, 0x0B, 0xE3, 0x83, 0x22, 0x05, 0x94,
/* 0C40 */ 0x07, 0xA4, 0x08, 0x09, 0x68, 0x18, 0x97, 0x4B, 0x98, 0x83, 0x09, 0x6D, 0x22, 0x07, 0x4B, 0x81,
/* 0C50 */ 0x85, 0x08, 0x91, 0x22, 0x08, 0x91, 0x22, 0x08, 0x4B, 0x10, 0x08, 0xBE, 0x94, 0xB9, 0x4B, 0x10,
/* 0C60 */ 0x09, 0xC9, 0xB5, 0xD6, 0xCE, 0x10, 0x08, 0xBE, 0xDC, 0x58, 0x45, 0xD0, 0x01, 0xB7, 0x53, 0x0E,
/* 0C70 */ 0x83, 0xD0, 0x98, 0x37, 0x2C, 0x6E, 0x4B, 0x61, 0x94, 0x08, 0x04, 0x18, 0x53, 0x4A, 0x53, 0x10,
/* 0C80 */ 0x09, 0xC9, 0x08, 0x0D, 0xD2, 0x19, 0x62, 0xA4, 0x96, 0x6D, 0xD6, 0x37, 0x34, 0x27, 0x8C, 0x30,
/* 0C90 */ 0x59, 0x63, 0x36, 0x0C, 0x18, 0xA5, 0x36, 0x0C, 0x18, 0x0E, 0x83, 0x1E, 0x8C, 0x30, 0x59, 0x37,
/* 0CA0 */ 0x1E, 0x40, 0x37, 0x34, 0x0D, 0x19, 0x62, 0x0F, 0x4F, 0x69, 0x43, 0x5D, 0x78, 0x54, 0x09, 0x80,
/* 0CB0 */ 0x7E, 0x0B, 0x94, 0x1B, 0x8F, 0x10, 0x08, 0xBE, 0x0F, 0xA4, 0x7D, 0x61, 0x0F, 0x5A, 0xA4, 0x01,
/* 0CC0 */ 0xD0, 0x59, 0x83, 0xD0, 0x59, 0x83, 0x2C, 0x94, 0x58, 0x45, 0x2C, 0x6E, 0x89, 0x61, 0x0F, 0x59,
/* 0CD0 */ 0x37, 0x00, 0xD0, 0x48, 0x76, 0xD0, 0x40, 0x37, 0xD0, 0x8D, 0x72, 0x10, 0x07, 0x46, 0x05, 0x0C,
/* 0CE0 */ 0xA4, 0x8F, 0x3B, 0x5F, 0x79, 0x6D, 0x2A, 0x08, 0xA3, 0x00, 0x64, 0x00, 0x2D, 0x0F, 0x6D, 0x01,
/* 0CF0 */ 0xEA, 0x23, 0x0E, 0xB8, 0x06, 0x23, 0x08, 0x86, 0xA4, 0x19, 0x7A, 0x05, 0x30, 0x07, 0xA4, 0x19,
/* 0D00 */ 0x62, 0xA3, 0x51, 0xFD, 0x5D, 0x0E, 0x54, 0x07, 0x10, 0x07, 0x74, 0x78, 0x6E, 0xA3, 0x19, 0x35,
/* 0D10 */ 0x5A, 0x54, 0x0A, 0x07, 0x55, 0x62, 0x0F, 0xB8, 0x62, 0xC5, 0xC5, 0xC5, 0x91, 0x10, 0x08, 0x74,
/* 0D20 */ 0xAB, 0xF2, 0xD9, 0x10, 0x07, 0xA6, 0xEA, 0xB7, 0x9E, 0x68, 0x1E, 0x9E, 0x6D, 0x30, 0x0F, 0x73,
/* 0D30 */ 0x19, 0x08, 0x94, 0x7E, 0xA4, 0x00, 0xF9, 0xFA, 0x2A, 0x59, 0xA8, 0x08, 0x6D, 0x2A, 0x9E, 0x37,
/* 0D40 */ 0x0B, 0x0F, 0xEB, 0xFF, 0x69, 0x30, 0x41, 0x72, 0x72, 0xEA, 0x5F, 0x6D, 0x25, 0x23, 0x04, 0x10,
/* 0D50 */ 0x0B, 0x74, 0x0C, 0x83, 0x9E, 0x94, 0x00, 0x07, 0x4B, 0x30, 0x62, 0x6D, 0x9B, 0x0C, 0x35, 0x6D,
/* 0D60 */ 0x18, 0x08, 0x91, 0x01, 0xA4, 0x2E, 0x65, 0x18, 0xFA, 0x03, 0x94, 0x0F, 0x9E, 0x37, 0x30, 0x64,
/* 0D70 */ 0x72, 0x05, 0x68, 0x0F, 0x81, 0xA8, 0x30, 0x77, 0x54, 0x07, 0x85, 0x83, 0xA4, 0x1E, 0xA4, 0x0A,
/* 0D80 */ 0x90, 0x4B, 0xA3, 0x22, 0x44, 0xA3, 0x0A, 0x00, 0x8A, 0x4B, 0x1E, 0xA7, 0x08, 0x9E, 0x0F, 0x6D,
/* 0D90 */ 0x1E, 0x48, 0x68, 0x62, 0x0F, 0x83, 0x10, 0x07, 0x74, 0x0A, 0x94, 0x00, 0x40, 0x27, 0x7E, 0x5F,
/* 0DA0 */ 0x5D, 0xFD, 0x8D, 0x6D, 0x69, 0x28, 0x03, 0x6E, 0xB8, 0xF2, 0xEA, 0x78, 0x68, 0x1F, 0x07, 0x72,
/* 0DB0 */ 0x54, 0x1F, 0x7C, 0x0D, 0x83, 0x2D, 0xA3, 0x00, 0x07, 0xA3, 0x19, 0x44, 0x6D, 0x7A, 0xB7, 0x10,
/* 0DC0 */ 0x08, 0x74, 0xAD, 0x4B, 0xE0, 0xD1, 0x98, 0xFB, 0x10, 0x07, 0x74, 0x92, 0x6E, 0xFD, 0x04, 0x21,
/* 0DD0 */ 0x0F, 0x6D, 0x18, 0xBA, 0x27, 0x22, 0x50, 0x6D, 0x1F, 0x35, 0x54, 0xF1, 0x0F, 0x83, 0x25, 0xCB,
/* 0DE0 */ 0x1F, 0x64, 0x5F, 0x80, 0x8D, 0xA4, 0x21, 0x06, 0x2A, 0x23, 0x5F, 0x6D, 0x10, 0x04, 0x9D, 0x06,
/* 0DF0 */ 0x24, 0xB8, 0x48, 0x54, 0x1F, 0x35, 0x68, 0xD4, 0x68, 0xD4, 0xA3, 0xB8, 0x48, 0x54, 0x10, 0x07,
/* 0E00 */ 0x9D, 0x77, 0x4E, 0x59, 0x3F, 0x9E, 0x73, 0x3C, 0xFF, 0x22, 0x41, 0xC4, 0x59, 0x2B, 0x44, 0x73,
/* 0E10 */ 0x86, 0x83, 0x22, 0x41, 0x4B, 0xCC, 0x54, 0x1B, 0x58, 0x9F, 0x65, 0x22, 0x2D, 0x91, 0xCC, 0x06,
/* 0E20 */ 0x02, 0x10, 0x04, 0x9D, 0x07, 0x24, 0x07, 0x25, 0xA7, 0x71, 0xC3, 0x25, 0xC3, 0x25, 0xC3, 0x25,
/* 0E30 */ 0xC3, 0x25, 0xC3, 0x1F, 0x07, 0x0B, 0x72, 0x25, 0xA7, 0x0B, 0x10, 0x07, 0x7B, 0x04, 0x08, 0x05,
/* 0E40 */ 0x00, 0xEA, 0x78, 0x73, 0x1F, 0x07, 0x94, 0x4B, 0x2A, 0x7A, 0x69, 0x49, 0x73, 0x2A, 0x08, 0x91,
/* 0E50 */ 0x00, 0xFA, 0x10, 0x07, 0x31, 0x39, 0x08, 0x20, 0x33, 0x44, 0x8E, 0x07, 0x10, 0x04, 0x9D, 0x97,
/* 0E60 */ 0x3C, 0x64, 0xA3, 0x80, 0x7A, 0x06, 0x5B, 0x30, 0xCC, 0x10, 0x07, 0x31, 0x01, 0x5A, 0xB4, 0x10,
/* 0E70 */ 0x08, 0x57, 0x03, 0x0E, 0xC1, 0x0D, 0x08, 0x8A, 0x02, 0x61, 0x0F, 0x5B, 0x72, 0x61, 0x0E, 0x01,
/* 0E80 */ 0x40, 0x1D, 0xF9, 0x59, 0x73, 0xF9, 0x59, 0x73, 0x2C, 0x0E, 0x64, 0x5F, 0x61, 0xA3, 0x58, 0x6F,
/* 0E90 */ 0x04, 0x72, 0x0A, 0x4F, 0x01, 0x10, 0x06, 0x31, 0x77, 0x96, 0x0D, 0x07, 0xF7, 0xA3, 0x0C, 0x6F,
/* 0EA0 */ 0x97, 0x54, 0x19, 0x36, 0x56, 0x5C, 0x56, 0x06, 0x0F, 0x2B, 0x50, 0xA3, 0x0C, 0xE7, 0x7E, 0x0B,
/* 0EB0 */ 0x54, 0x08, 0x10, 0x08, 0xA6, 0x26, 0x38, 0x26, 0xE5, 0x04, 0x6B, 0x0A, 0x54, 0x2A, 0x50, 0xAA,
/* 0EC0 */ 0x94, 0x64, 0x54, 0x2D, 0x54, 0x34, 0xDA, 0x0D, 0x06, 0x54, 0x10, 0x07, 0x00, 0x31, 0x4C, 0xFC,
/* 0ED0 */ 0xEF, 0x10, 0x05, 0x29, 0x4C, 0x0E, 0x0D, 0x04, 0x55, 0x9E, 0xA3, 0x0B, 0x02, 0x1F, 0x5F, 0x80,
/* 0EE0 */ 0x9B, 0x0F, 0x4B, 0x1F, 0x48, 0x72, 0x05, 0x25, 0x0F, 0xAE, 0x0F, 0xAE, 0x0F, 0xAE, 0x0F, 0xAE,
/* 0EF0 */ 0x0F, 0xAE, 0x0F, 0x37, 0x10, 0x07, 0x1E, 0xC9, 0xCC, 0x07, 0x7F, 0x84, 0x5F, 0xA3, 0x41, 0xA4,
/* 0F00 */ 0x0A, 0x94, 0x55, 0xD8, 0x0B, 0x63, 0x2A, 0x08, 0x94, 0x82, 0x83, 0x2A, 0x81, 0x6E, 0x45, 0x2A,
/* 0F10 */ 0x9E, 0x0C, 0x8B, 0x28, 0x03, 0x54, 0x0A, 0x52, 0x1F, 0x51, 0x5F, 0xFD, 0x07, 0x07, 0x30, 0x07,
/* 0F20 */ 0xA3, 0x19, 0x9E, 0x0F, 0x8B, 0x0C, 0x4B, 0x3B, 0x96, 0x54, 0x08, 0x10, 0x07, 0x57, 0x03, 0x0E,
/* 0F30 */ 0xC1, 0x0D, 0x08, 0xC7, 0x01, 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x04, 0x9D, 0x02,
/* 0F40 */ 0x60, 0xE4, 0x26, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x9D, 0x02, 0x60, 0xE4, 0x26, 0xC1, 0xC1, 0x2B,
/* 0F50 */ 0x98, 0x2B, 0x0A, 0x94, 0x18, 0xBA, 0x85, 0xF1, 0x0B, 0x03, 0x10, 0x07, 0x9D, 0x77, 0x3E, 0xE9,
/* 0F60 */ 0xC1, 0x2E, 0x05, 0xA3, 0x00, 0xF9, 0x58, 0x43, 0x04, 0x54, 0xFA, 0x2A, 0x64, 0x54, 0x78, 0x43,
/* 0F70 */ 0x64, 0x54, 0x0A, 0xFD, 0x64, 0x54, 0x40, 0x27, 0x3A, 0x0D, 0x9E, 0xFD, 0x04, 0x54, 0x34, 0x27,
/* 0F80 */ 0x10, 0x04, 0x47, 0x77, 0x3C, 0xBB, 0xBB, 0xBB, 0x04, 0xA4, 0x06, 0x3C, 0x51, 0x0A, 0x10, 0x0B,
/* 0F90 */ 0xED, 0xE3, 0x4F, 0x04, 0x6B, 0x05, 0x30, 0x3A, 0xA3, 0x78, 0xA3, 0x54, 0x18, 0x64, 0xA4, 0x87,
/* 0FA0 */ 0x91, 0x5E, 0x18, 0x64, 0x54, 0x62, 0xAC, 0xAC, 0x6D, 0x5E, 0x10, 0x07, 0xED, 0xE3, 0xC7, 0x01,
/* 0FB0 */ 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x07, 0x31, 0x7E, 0xAF, 0xE6, 0x32, 0x10, 0x08,
/* 0FC0 */ 0xED, 0xE3, 0xDF, 0x18, 0x64, 0x4F, 0x10, 0x08, 0x31, 0x64, 0x6B, 0x08, 0x54, 0x2A, 0x50, 0xAA,
/* 0FD0 */ 0x94, 0x64, 0x54, 0x2D, 0xA3, 0x34, 0xDA, 0x0D, 0x48, 0x2B, 0x26, 0xE5, 0x30, 0x7E, 0x5B, 0x10,
/* 0FE0 */ 0x05, 0xED, 0x0B, 0x0A, 0xA8, 0x00, 0x61, 0xA4, 0x6F, 0x3A, 0x37, 0x18, 0x61, 0x3F, 0x26, 0xC1,
/* 0FF0 */ 0x0D, 0x10, 0x06, 0x31, 0x35, 0x0E, 0x4F, 0xEB, 0x07, 0xA4, 0x51, 0x05, 0x55, 0x48, 0x56, 0x26,
/* 1000 */ 0x54, 0x07, 0x25, 0x67, 0x78, 0xE7, 0x77, 0x97, 0x54, 0x55, 0x51, 0x95, 0x94, 0x00, 0x3B, 0x0B,
/* 1010 */ 0x69, 0x8F, 0x10, 0x05, 0x74, 0x87, 0x45, 0xCD, 0xA8, 0x25, 0x0F, 0x6E, 0x7F, 0x62, 0x0F, 0x94,
/* 1020 */ 0x04, 0x1F, 0x59, 0xA8, 0xCD, 0xA8, 0xCD, 0xA8, 0xCD, 0x0F, 0x9F, 0x0E, 0xA3, 0x07, 0x18, 0x41,
/* 1030 */ 0x6B, 0x0A, 0x10, 0x07, 0x31, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x31, 0x0E, 0x63, 0x35, 0xFD, 0x0A,
/* 1040 */ 0x6D, 0x9E, 0x63, 0x2A, 0xFA, 0x9B, 0x01, 0x19, 0x77, 0xA3, 0xF6, 0x55, 0x44, 0x68, 0x6D, 0x55,
/* 1050 */ 0x35, 0x72, 0x63, 0x55, 0x34, 0xA4, 0xCD, 0x72, 0x10, 0x0A, 0x31, 0x0D, 0x63, 0x04, 0xA4, 0x00,
/* 1060 */ 0x08, 0x6D, 0x22, 0x65, 0x06, 0x0F, 0x73, 0x0A, 0x63, 0x22, 0x08, 0x6D, 0x08, 0x58, 0x9C, 0x73,
/* 1070 */ 0x22, 0x05, 0x91, 0xE3, 0x68, 0x69, 0x22, 0x77, 0x0F, 0x5A, 0x6A, 0x08, 0xA3, 0x19, 0x8A, 0x83,
/* 1080 */ 0x79, 0x4B, 0x19, 0x23, 0x03, 0x48, 0x6D, 0x19, 0x48, 0xA8, 0x06, 0xB7, 0x10, 0x07, 0x31, 0x0A,
/* 1090 */ 0x91, 0x59, 0x73, 0x3B, 0x54, 0x05, 0x94, 0x55, 0x62, 0x54, 0x73, 0x00, 0xC0, 0x72, 0x18, 0x2D,
/* 10A0 */ 0x0F, 0xA4, 0x28, 0x44, 0x94, 0x6D, 0x55, 0xFA, 0x40, 0x27, 0x00, 0x44, 0x83, 0x9E, 0x6D, 0x10,
/* 10B0 */ 0x07, 0x31, 0x7C, 0xB2, 0x10, 0x06, 0x31, 0x48, 0x6E, 0xE7, 0x06, 0x24, 0x5F, 0xB8, 0x98, 0x27,
/* 10C0 */ 0x22, 0x50, 0x83, 0x1F, 0x35, 0x72, 0xFE, 0x89, 0x1F, 0x9E, 0x54, 0x24, 0x06, 0x2A, 0x44, 0x6E,
/* 10D0 */ 0x91, 0x10, 0x04, 0x47, 0x84, 0x38, 0x0E, 0x4B, 0xCD, 0x3F, 0x59, 0x2E, 0xCD, 0x2E, 0xFE, 0x38,
/* 10E0 */ 0x6B, 0x3E, 0x8D, 0x91, 0xCC, 0x0F, 0x2E, 0xCD, 0x3F, 0x59, 0x3F, 0x59, 0x3F, 0x9B, 0x09, 0x22,
/* 10F0 */ 0x41, 0x0D, 0x0C, 0x10, 0x05, 0x47, 0xB6, 0xE8, 0x2A, 0xB6, 0xE8, 0x2A, 0xB6, 0x10, 0x04, 0x9D,
/* 1100 */ 0x95, 0x06, 0x19, 0x36, 0xA8, 0x25, 0x9E, 0x73, 0x25, 0x9E, 0xAE, 0x0C, 0xAE, 0x0B, 0x83, 0x22,
/* 1110 */ 0x3B, 0x58, 0x22, 0xBA, 0x38, 0x0C, 0xAE, 0x0C, 0xAE, 0x0C, 0xAE, 0x0D, 0x73, 0x1E, 0x36, 0xA8,
/* 1120 */ 0x25, 0x95, 0x06, 0x10, 0x07, 0x1F, 0x39, 0x2D, 0x6C, 0x64, 0x00, 0x2D, 0x5F, 0x72, 0x37, 0x41,
/* 1130 */ 0x9A, 0x96, 0x08, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1A, 0x00, 0x41, 0x00, 0x67, 0x00, 0x93,
/* 1140 */ 0x00, 0xC3, 0x00, 0xCC, 0x00, 0xFE, 0x01, 0x0E, 0x01, 0x4D, 0x01, 0x74, 0x01, 0x9C, 0x01, 0xAA,
/* 1150 */ 0x01, 0xB5, 0x01, 0xE3, 0x01, 0xED, 0x02, 0x04, 0x02, 0x15, 0x02, 0x30, 0x02, 0x47, 0x02, 0x51,
/* 1160 */ 0x02, 0x6E, 0x02, 0xA9, 0x02, 0xAE, 0x02, 0xBE, 0x02, 0xCF, 0x02, 0xF9, 0x03, 0x21, 0x03, 0x42,
/* 1170 */ 0x03, 0x77, 0x03, 0xB2, 0x03, 0xD8, 0x03, 0xEA, 0x03, 0xF5, 0x04, 0x08, 0x04, 0x18, 0x04, 0x2B,
/* 1180 */ 0x04, 0x42, 0x04, 0x7A, 0x04, 0xA9, 0x04, 0xBB, 0x04, 0xC9, 0x04, 0xDA, 0x04, 0xE6, 0x04, 0xF8,
/* 1190 */ 0x05, 0x08, 0x05, 0x1D, 0x05, 0x31, 0x05, 0x5A, 0x05, 0x68, 0x05, 0x78, 0x05, 0x87, 0x05, 0x99,
/* 11A0 */ 0x05, 0xA8, 0x05, 0xB4, 0x05, 0xCF, 0x06, 0x10, 0x06, 0x20, 0x06, 0x2F, 0x06, 0x43, 0x06, 0x53,
/* 11B0 */ 0x06, 0x61, 0x06, 0x83, 0x06, 0xB2, 0x06, 0xC1, 0x06, 0xD1, 0x06, 0xE3, 0x06, 0xF1, 0x06, 0xFD,
/* 11C0 */ 0x07, 0x10, 0x07, 0x49, 0x07, 0x70, 0x07, 0x80, 0x07, 0x8F, 0x07, 0xA0, 0x07, 0xB3, 0x07, 0xC6,
/* 11D0 */ 0x07, 0xD7, 0x07, 0xEB, 0x07, 0xFE, 0x08, 0x2E, 0x08, 0x46, 0x08, 0x59, 0x08, 0x69, 0x08, 0x7C,
/* 11E0 */ 0x08, 0x8B, 0x08, 0x9E, 0x08, 0xA9, 0x08, 0xDA, 0x08, 0xEB, 0x08, 0xF9, 0x09, 0x09, 0x09, 0x15,
/* 11F0 */ 0x09, 0x22, 0x09, 0x2E, 0x03, 0x00, 0x10, 0x03, 0x31, 0x04, 0x32, 0x3C, 0x48, 0x38, 0x4C, 0x05,
/* 1200 */ 0x55, 0x7B, 0xF3, 0x25, 0x34, 0xB8, 0x97, 0xC4, 0xFA, 0x22, 0xBA, 0x56, 0xD3, 0x10, 0x06, 0x46,
/* 1210 */ 0x77, 0x68, 0xCC, 0x68, 0x00, 0xEA, 0x08, 0xA3, 0x04, 0x55, 0x62, 0x5F, 0x54, 0xC0, 0x85, 0x02,
/* 1220 */ 0xEB, 0x92, 0x71, 0x48, 0x56, 0xD3, 0x26, 0x89, 0x02, 0x80, 0x23, 0xA3, 0x1F, 0x5D, 0xA3, 0x05,
/* 1230 */ 0xF1, 0x68, 0xCC, 0x68, 0x10, 0x07, 0xC9, 0x08, 0x69, 0x0A, 0x28, 0x98, 0x4F, 0x68, 0x55, 0xD8,
/* 1240 */ 0x28, 0x35, 0x6D, 0x1E, 0x36, 0x6E, 0x76, 0x41, 0x0D, 0xA3, 0x0A, 0x07, 0x55, 0x35, 0x6D, 0x25,
/* 1250 */ 0x8D, 0x0F, 0x3E, 0x07, 0xA4, 0x21, 0x33, 0x62, 0x8E, 0x05, 0x10, 0x07, 0x1E, 0xC9, 0x3B, 0x04,
/* 1260 */ 0x30, 0x7E, 0x43, 0x51, 0x96, 0x95, 0x6F, 0x01, 0x78, 0x51, 0xA8, 0x19, 0x77, 0x91, 0x00, 0x92,
/* 1270 */ 0x43, 0x04, 0x68, 0x34, 0x33, 0x7A, 0x94, 0x5D, 0x73, 0x3B, 0x8E, 0x33, 0x35, 0x0B, 0x06, 0x09,
/* 1280 */ 0x06, 0x0A, 0x6F, 0x7A, 0x30, 0x7A, 0x10, 0x07, 0x74, 0x0D, 0x63, 0x30, 0x0E, 0x73, 0x19, 0x07,
/* 1290 */ 0x4B, 0x34, 0x6F, 0x01, 0x69, 0x01, 0x0A, 0x63, 0x55, 0xFF, 0xA3, 0x55, 0x77, 0xA4, 0x83, 0x55,
/* 12A0 */ 0x59, 0x6E, 0x68, 0x00, 0x3B, 0x08, 0x72, 0x03, 0x01, 0x2A, 0x59, 0x6E, 0x68, 0x19, 0x7A, 0xA0,
/* 12B0 */ 0x54, 0x0A, 0x04, 0x1F, 0x07, 0x72, 0x10, 0x05, 0x47, 0xB6, 0xE8, 0x22, 0x3D, 0xB6, 0xE8, 0x10,
/* 12C0 */ 0x07, 0xA6, 0xCC, 0x0B, 0x54, 0x7F, 0x44, 0xA3, 0x0C, 0x0D, 0x1F, 0x0F, 0xA8, 0x00, 0x28, 0x8D,
/* 12D0 */ 0xD2, 0x1F, 0x96, 0x5F, 0x90, 0x41, 0x91, 0x82, 0x83, 0x61, 0x0D, 0x04, 0x48, 0x43, 0x35, 0x5F,
/* 12E0 */ 0x4B, 0x25, 0x67, 0x54, 0x30, 0x41, 0x01, 0x5E, 0x2A, 0x7A, 0x6E, 0x94, 0x30, 0x3B, 0x08, 0x09,
/* 12F0 */ 0x06, 0x10, 0x06, 0x9D, 0x77, 0x00, 0x77, 0x30, 0x2D, 0x6D, 0x07, 0x68, 0x55, 0xEC, 0x05, 0xEC,
/* 1300 */ 0x05, 0x10, 0x0A, 0x3D, 0x67, 0x0E, 0x4F, 0x43, 0x49, 0x9A, 0x01, 0x66, 0x33, 0x0A, 0x7D, 0x6B,
/* 1310 */ 0x05, 0x6A, 0x1E, 0x59, 0x4C, 0x4F, 0x07, 0x01, 0x37, 0x18, 0x77, 0x73, 0x6D, 0x30, 0x44, 0x05,
/* 1320 */ 0x18, 0x7E, 0x73, 0x6D, 0x30, 0x44, 0x06, 0x18, 0x7A, 0x37, 0x6B, 0x0A, 0x08, 0x01, 0x37, 0x22,
/* 1330 */ 0x62, 0x7D, 0x6B, 0x05, 0x6A, 0x19, 0x81, 0x08, 0x01, 0x01, 0x66, 0x33, 0x77, 0x51, 0x4F, 0x03,
/* 1340 */ 0x10, 0x06, 0x57, 0x97, 0x09, 0x52, 0x1F, 0x44, 0x6E, 0xEB, 0x77, 0x01, 0xFF, 0x55, 0x35, 0x78,
/* 1350 */ 0x68, 0x2A, 0x34, 0x8B, 0x68, 0x00, 0x2D, 0x54, 0x78, 0xE7, 0x87, 0x32, 0x09, 0x06, 0x22, 0x7B,
/* 1360 */ 0x64, 0x0A, 0x21, 0xE7, 0x06, 0x6E, 0x54, 0x10, 0x08, 0x1C, 0xC9, 0x41, 0x06, 0x30, 0x9A, 0x19,
/* 1370 */ 0x77, 0x69, 0x01, 0x08, 0x91, 0x19, 0x82, 0x6D, 0x98, 0x27, 0x00, 0x92, 0x2E, 0xA5, 0xBA, 0x2E,
/* 1380 */ 0xA5, 0x2A, 0x49, 0x68, 0x05, 0xA4, 0x01, 0x3B, 0x69, 0x01, 0xD8, 0x41, 0x06, 0x30, 0x6C, 0x10,
/* 1390 */ 0x07, 0x75, 0x39, 0x64, 0x20, 0x02, 0x2D, 0x8E, 0x88, 0x08, 0xAE, 0x08, 0x37, 0x10, 0x05, 0x75,
/* 13A0 */ 0x39, 0x64, 0x21, 0x06, 0x30, 0x2D, 0x5F, 0x94, 0x10, 0x08, 0x29, 0x5D, 0x69, 0x8F, 0x2A, 0x8D,
/* 13B0 */ 0x8F, 0x5D, 0x0B, 0x19, 0x64, 0x0D, 0x05, 0x54, 0x02, 0x0D, 0x33, 0x07, 0x52, 0x09, 0x09, 0x06,
/* 13C0 */ 0x8B, 0x19, 0x07, 0x52, 0x69, 0x01, 0x8B, 0x19, 0x9C, 0x05, 0x09, 0x0C, 0x9C, 0x33, 0x8D, 0x7D,
/* 13D0 */ 0x02, 0xA0, 0x55, 0x5D, 0x69, 0x8F, 0x10, 0x05, 0x9D, 0x05, 0x21, 0x04, 0x1F, 0x08, 0x5F, 0x68,
/* 13E0 */ 0x10, 0x07, 0xA6, 0x86, 0x0E, 0x0D, 0x80, 0x05, 0x72, 0x8A, 0x1F, 0x08, 0x1D, 0x08, 0x4D, 0x41,
/* 13F0 */ 0x72, 0x8A, 0x25, 0x08, 0x0E, 0x0D, 0x03, 0x10, 0x07, 0x1F, 0xC9, 0x36, 0x33, 0x36, 0x33, 0xC2,
/* 1400 */ 0x33, 0x25, 0x3B, 0x20, 0x01, 0x41, 0x8E, 0x01, 0x10, 0x05, 0x47, 0x05, 0x09, 0x06, 0x18, 0x41,
/* 1410 */ 0x5F, 0x83, 0xEA, 0x05, 0xF3, 0x3C, 0x07, 0x89, 0x25, 0xEC, 0x3E, 0x04, 0x54, 0x0A, 0x06, 0x30,
/* 1420 */ 0x41, 0x5F, 0x91, 0x10, 0x05, 0x57, 0x4C, 0x8A, 0x02, 0x18, 0x3B, 0x03, 0x68, 0xFE, 0x45, 0xCC,
/* 1430 */ 0x4B, 0x30, 0x3B, 0x08, 0x06, 0x91, 0x1F, 0x4C, 0x4F, 0x01, 0x10, 0x04, 0x47, 0x77, 0x4E, 0x8C,
/* 1440 */ 0x1F, 0x34, 0x7D, 0xCC, 0x10, 0x07, 0xED, 0x2E, 0xD8, 0xF9, 0xD8, 0xF9, 0xD8, 0xF9, 0xD8, 0xF9,
/* 1450 */ 0xD8, 0x2C, 0x0E, 0x62, 0x4B, 0x61, 0x72, 0x0F, 0x94, 0x61, 0x6B, 0x08, 0x72, 0x61, 0x09, 0xDD,
/* 1460 */ 0xC3, 0x10, 0x0A, 0xA6, 0xCC, 0x51, 0x6E, 0x94, 0x19, 0x23, 0x54, 0x0B, 0x94, 0x1E, 0x5E, 0x5F,
/* 1470 */ 0x7D, 0x94, 0x1E, 0x40, 0x6E, 0x7D, 0x94, 0x1E, 0x44, 0x6E, 0x7D, 0x94, 0x1E, 0x7E, 0x58, 0x94,
/* 1480 */ 0x40, 0x6F, 0xE9, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x7D,
/* 1490 */ 0x94, 0xC0, 0x7D, 0x94, 0xC0, 0x0A, 0x40, 0x6F, 0x7A, 0x02, 0x7A, 0x02, 0x10, 0x03, 0x42, 0x39,
/* 14A0 */ 0xDE, 0x10, 0x04, 0x31, 0x39, 0x62, 0x08, 0x1B, 0x08, 0x91, 0x3C, 0x82, 0x0C, 0x18, 0x41, 0x69,
/* 14B0 */ 0x05, 0x10, 0x05, 0x29, 0x66, 0x0D, 0x18, 0x41, 0xA4, 0x0D, 0xCC, 0x95, 0x1B, 0x95, 0x1B, 0x95,
/* 14C0 */ 0x1B, 0x95, 0x10, 0x06, 0x57, 0x77, 0x08, 0x52, 0x1F, 0x50, 0x5F, 0x83, 0x00, 0x2D, 0x4B, 0x03,
/* 14D0 */ 0xA3, 0x55, 0xFF, 0x00, 0xA4, 0x55, 0x07, 0x6D, 0x01, 0xA3, 0x2A, 0x77, 0x0F, 0x8A, 0x91, 0x30,
/* 14E0 */ 0x2D, 0x6B, 0x8F, 0x19, 0xA1, 0x41, 0x0A, 0x21, 0xE7, 0x08, 0x6E, 0xA4, 0x10, 0x08, 0x31, 0x01,
/* 14F0 */ 0x9A, 0x7E, 0x07, 0x2A, 0x64, 0xA3, 0x9E, 0x83, 0x2A, 0x8D, 0x4B, 0x40, 0x89, 0x00, 0xD6, 0x37,
/* 1500 */ 0xCB, 0x2A, 0x5E, 0x03, 0x09, 0x72, 0x19, 0x8D, 0x4B, 0x40, 0x85, 0x2C, 0x0C, 0x8D, 0x83, 0x19,
/* 1510 */ 0x7A, 0x9A, 0x64, 0x07, 0x10, 0x0C, 0xA6, 0xC6, 0x95, 0x30, 0x79, 0x00, 0x33, 0x95, 0x7E, 0x83,
/* 1520 */ 0x03, 0x63, 0x22, 0x8D, 0x2E, 0x5A, 0x35, 0x0E, 0x2A, 0x77, 0x68, 0x50, 0x08, 0x60, 0x19, 0xCF,
/* 1530 */ 0x08, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x0C, 0xA6, 0xC6, 0x95, 0x30, 0x79, 0x67, 0x08, 0x01, 0x22,
/* 1540 */ 0x95, 0x7E, 0x68, 0x78, 0x94, 0x22, 0x95, 0x62, 0x2E, 0x05, 0x49, 0x0C, 0x1E, 0x77, 0x68, 0x00,
/* 1550 */ 0x7E, 0x68, 0x19, 0x08, 0x0E, 0x01, 0x77, 0x0D, 0x09, 0x1E, 0x7A, 0x32, 0x30, 0x6B, 0x0A, 0x09,
/* 1560 */ 0x1E, 0xA2, 0x01, 0x30, 0x5F, 0x54, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x0C, 0x29, 0x2D, 0x01, 0x22,
/* 1570 */ 0x4C, 0x8A, 0x02, 0x30, 0x05, 0x37, 0x22, 0x7E, 0x03, 0x68, 0x00, 0x9E, 0x0B, 0xD6, 0x45, 0xE9,
/* 1580 */ 0x33, 0x77, 0x91, 0x00, 0x79, 0x64, 0x18, 0x77, 0x06, 0x03, 0x4B, 0x03, 0x83, 0x03, 0x63, 0x18,
/* 1590 */ 0x05, 0x5F, 0x85, 0x5A, 0x35, 0x0E, 0x1E, 0x99, 0x01, 0x02, 0x68, 0x50, 0x08, 0x60, 0x19, 0xCF,
/* 15A0 */ 0x08, 0x1E, 0xE3, 0x22, 0xEA, 0x10, 0x06, 0x30, 0x31, 0xA2, 0x3E, 0x9E, 0xC4, 0x05, 0x0C, 0x43,
/* 15B0 */ 0x3C, 0x2D, 0x0B, 0x3E, 0x49, 0x63, 0x1F, 0x87, 0xA3, 0x25, 0x48, 0x90, 0x1F, 0x9E, 0x6D, 0x00,
/* 15C0 */ 0x05, 0x28, 0x48, 0x54, 0x72, 0x2A, 0x7A, 0x0A, 0x69, 0x0A, 0x02, 0x10, 0x08, 0x55, 0xEA, 0x30,
/* 15D0 */ 0x86, 0x0C, 0x4E, 0x07, 0x58, 0x2F, 0x64, 0x01, 0x1F, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x25,
/* 15E0 */ 0xEA, 0x1B, 0xDB, 0x3C, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x25, 0x41, 0xA3, 0x28, 0x64, 0xA3,
/* 15F0 */ 0x8A, 0x28, 0x03, 0x07, 0x77, 0x08, 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x2A, 0xA1, 0x82,
/* 1600 */ 0x0E, 0x5A, 0x28, 0x84, 0x96, 0x08, 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x08, 0x55, 0xEA, 0xDD,
/* 1610 */ 0x35, 0x63, 0x09, 0x63, 0x55, 0x07, 0x85, 0x08, 0x85, 0xA1, 0x0A, 0xB0, 0x37, 0xBD, 0x10, 0x08,
/* 1620 */ 0x18, 0x05, 0x8A, 0x02, 0x25, 0x0E, 0x06, 0x0B, 0xB8, 0x0E, 0x06, 0x60, 0x18, 0x41, 0x8A, 0x02,
/* 1630 */ 0xA1, 0x62, 0xB0, 0x37, 0xBD, 0x10, 0x0B, 0x46, 0x7A, 0x8E, 0x54, 0x1E, 0x97, 0x5F, 0xA3, 0x24,
/* 1640 */ 0x07, 0x1E, 0x8D, 0x94, 0xFD, 0x7A, 0xA4, 0x98, 0x6F, 0x97, 0x4B, 0x03, 0x6E, 0xA3, 0x22, 0x9E,
/* 1650 */ 0x83, 0x00, 0x5F, 0x24, 0x08, 0x18, 0x77, 0x8E, 0x37, 0x19, 0x8C, 0x0A, 0x5A, 0x83, 0x1E, 0x9E,
/* 1660 */ 0x6D, 0x00, 0x35, 0xA3, 0x24, 0x04, 0x30, 0x5E, 0x03, 0x30, 0x07, 0x6E, 0x68, 0x10, 0x07, 0xC9,
/* 1670 */ 0x84, 0xD2, 0xBA, 0x4F, 0x8A, 0x2A, 0x59, 0x83, 0x7A, 0x02, 0x2D, 0xA4, 0x19, 0x36, 0x38, 0x5C,
/* 1680 */ 0x38, 0x8C, 0x25, 0x64, 0x5F, 0x9F, 0x58, 0x8F, 0x04, 0x06, 0x2A, 0x64, 0x0E, 0x6E, 0x27, 0x30,
/* 1690 */ 0x77, 0x0A, 0x0F, 0x9A, 0x18, 0x2D, 0xC4, 0x01, 0x07, 0x37, 0x25, 0x6B, 0x6F, 0x07, 0x55, 0xEA,
/* 16A0 */ 0x1B, 0x44, 0x0A, 0x02, 0x25, 0x5D, 0x0E, 0x89, 0x30, 0xEA, 0x05, 0x30, 0x61, 0xBC, 0x10, 0x07,
/* 16B0 */ 0x25, 0xEA, 0xCC, 0x5A, 0xF1, 0x69, 0x8F, 0x18, 0x41, 0x28, 0x3A, 0xBC, 0x10, 0x07, 0x19, 0x86,
/* 16C0 */ 0x4B, 0x25, 0x08, 0x72, 0x4B, 0x30, 0x41, 0x04, 0x64, 0x06, 0x42, 0x61, 0xBC, 0x10, 0x07, 0x00,
/* 16D0 */ 0x42, 0xBF, 0x44, 0xF0, 0x9E, 0x0C, 0x42, 0x61, 0xBC, 0x10, 0x04, 0x42, 0x28, 0x1E, 0x08, 0x0D,
/* 16E0 */ 0x4E, 0x6A, 0x68, 0x3C, 0x64, 0x02, 0x18, 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x55, 0xEA, 0x1B,
/* 16F0 */ 0xA2, 0x3E, 0xCB, 0x3E, 0x03, 0x02, 0x1E, 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x04, 0x75, 0x64, 0x54,
/* 1700 */ 0x02, 0x30, 0x3B, 0x8A, 0x0E, 0x45, 0x2A, 0x77, 0x07, 0x7A, 0x08, 0x93, 0x61, 0xA9, 0x26, 0xA9,
/* 1710 */ 0x10, 0x04, 0x22, 0xCC, 0xDD, 0x00, 0x08, 0x83, 0x08, 0x83, 0x55, 0x66, 0x04, 0xA2, 0x33, 0x25,
/* 1720 */ 0x61, 0xA9, 0x26, 0xA9, 0x10, 0x09, 0x46, 0x6E, 0x4F, 0xEB, 0x0F, 0x72, 0x23, 0x43, 0xB7, 0xCB,
/* 1730 */ 0x2A, 0xB7, 0x05, 0x5F, 0x19, 0x23, 0x72, 0x40, 0xA8, 0x36, 0x72, 0x07, 0x40, 0xA8, 0x19, 0xB7,
/* 1740 */ 0x05, 0x5F, 0x2A, 0xB7, 0xCB, 0x2A, 0x0F, 0x72, 0x23, 0x43, 0x5F, 0xA4, 0x7D, 0x10, 0x08, 0x7B,
/* 1750 */ 0xA2, 0x79, 0x06, 0xF7, 0x96, 0x90, 0x75, 0x61, 0x94, 0xB9, 0x4B, 0x10, 0x09, 0x1F, 0xEA, 0x1B,
/* 1760 */ 0x50, 0x8F, 0xF1, 0x0A, 0xA4, 0x9F, 0x01, 0x3E, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x3C, 0xEA, 0xCC,
/* 1770 */ 0x79, 0xFE, 0x0E, 0x8F, 0x18, 0x41, 0x1B, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x93, 0x62, 0x0F, 0xB8,
/* 1780 */ 0xCB, 0x6D, 0x1F, 0x07, 0x03, 0x00, 0x05, 0x05, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x7B, 0x05,
/* 1790 */ 0x8A, 0x0C, 0x7F, 0x8D, 0x0B, 0x5B, 0x03, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x09, 0x93, 0xBF, 0x50,
/* 17A0 */ 0x0D, 0x50, 0xE2, 0xA1, 0xB5, 0xD6, 0xCE, 0x10, 0x07, 0x00, 0x39, 0x82, 0x05, 0x8D, 0x07, 0xF7,
/* 17B0 */ 0x72, 0x91, 0x1F, 0x5E, 0x0B, 0x1E, 0x36, 0xA4, 0x43, 0x77, 0x0F, 0x7D, 0x4F, 0x55, 0x64, 0x01,
/* 17C0 */ 0x7E, 0x01, 0x10, 0x09, 0x18, 0x3D, 0x70, 0x1B, 0x0E, 0x0D, 0x1F, 0x08, 0x58, 0x72, 0x2A, 0x62,
/* 17D0 */ 0xA4, 0x23, 0x07, 0xD6, 0x73, 0x07, 0x58, 0x27, 0x07, 0xA3, 0x8D, 0x06, 0x0F, 0x63, 0x36, 0x76,
/* 17E0 */ 0x89, 0x0D, 0x83, 0x36, 0x0B, 0x04, 0x0D, 0x44, 0x68, 0x1E, 0x07, 0xA3, 0x08, 0x09, 0x00, 0xB7,
/* 17F0 */ 0x22, 0x40, 0x54, 0x05, 0x26, 0x27, 0x62, 0x5F, 0x96, 0x6D, 0x55, 0x58, 0xD2, 0x2A, 0x59, 0x71,
/* 1800 */ 0x01, 0x07, 0x05, 0x10, 0x08, 0x1F, 0xEA, 0x1B, 0xEC, 0x06, 0x3C, 0x9C, 0x94, 0x00, 0xCC, 0xEB,
/* 1810 */ 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x25, 0xEA, 0x9F, 0x05, 0x0D, 0xB8, 0x8C, 0x06, 0xF1, 0x3E, 0xAB,
/* 1820 */ 0xF2, 0xD9, 0x10, 0x08, 0x19, 0xCC, 0x0D, 0x63, 0x00, 0xF7, 0x8A, 0x0E, 0x43, 0x7A, 0x08, 0x01,
/* 1830 */ 0x00, 0x9A, 0x1C, 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x55, 0xEA, 0xDD, 0xE9, 0x52, 0xFD, 0x7E, 0x32,
/* 1840 */ 0x04, 0x32, 0x1C, 0xAB, 0xF2, 0xD9, 0x10, 0x08, 0x25, 0xEA, 0x30, 0xEA, 0xDB, 0x25, 0xAD, 0x4B,
/* 1850 */ 0xE0, 0xD1, 0x98, 0xFB, 0x10, 0x08, 0xBE, 0x0F, 0x22, 0x61, 0x94, 0x08, 0x33, 0x3A, 0x6E, 0x94,
/* 1860 */ 0x61, 0x0F, 0xE9, 0x37, 0xD0, 0x9B, 0x05, 0xD0, 0x59, 0x63, 0x2C, 0x0F, 0x5A, 0x54, 0x61, 0x0F,
/* 1870 */ 0xA4, 0x0A, 0x02, 0x30, 0x53, 0x4A, 0x10, 0x08, 0x57, 0x77, 0x0B, 0x69, 0x08, 0x1F, 0x58, 0x96,
/* 1880 */ 0x83, 0x3B, 0xA4, 0x35, 0x68, 0x61, 0x0D, 0x49, 0x45, 0x61, 0x0D, 0x06, 0x68, 0x2A, 0x64, 0x54,
/* 1890 */ 0x92, 0x90, 0x61, 0x0D, 0x82, 0xA3, 0x00, 0xF9, 0x81, 0x83, 0xF9, 0x8D, 0x6D, 0x2C, 0x45, 0xA7,
/* 18A0 */ 0x33, 0x04, 0x54, 0x66, 0x32, 0x10, 0x07, 0x3D, 0x05, 0x9F, 0x01, 0x69, 0x2F, 0x04, 0x0B, 0xAE,
/* 18B0 */ 0x77, 0xEA, 0x5A, 0xB4, 0x10, 0x07, 0x3D, 0x77, 0x4E, 0x66, 0x0D, 0x1F, 0x64, 0x94, 0x04, 0xCC,
/* 18C0 */ 0x30, 0xEA, 0x5A, 0xB4, 0x10, 0x07, 0x47, 0x62, 0x0F, 0xB8, 0x08, 0x72, 0x68, 0x1F, 0x08, 0x04,
/* 18D0 */ 0x97, 0x07, 0x1C, 0x7A, 0x5A, 0xB4, 0x10, 0x07, 0x57, 0x64, 0x8A, 0x0C, 0xE7, 0x8D, 0x95, 0x85,
/* 18E0 */ 0x1C, 0x7A, 0x5A, 0xB4, 0x10, 0x07, 0x47, 0xBF, 0x50, 0x0D, 0x50, 0xE2, 0x1C, 0x7A, 0x5A, 0xB4,
/* 18F0 */ 0x10, 0x07, 0x7B, 0x51, 0xE7, 0x3A, 0x03, 0x73, 0x55, 0x64, 0x89, 0x73, 0x25, 0x51, 0x09, 0x75,
/* 1900 */ 0xEA, 0x5A, 0xB4, 0x10, 0x0B, 0x31, 0x35, 0x0D, 0xA3, 0x03, 0x0B, 0x8A, 0x04, 0x22, 0x8D, 0x0B,
/* 1910 */ 0xA7, 0x0E, 0x0A, 0xA4, 0x01, 0x19, 0x44, 0x6D, 0x00, 0x65, 0x22, 0x07, 0x58, 0x8E, 0x6D, 0x30,
/* 1920 */ 0x97, 0x5F, 0x51, 0xA3, 0x21, 0x05, 0x30, 0x62, 0x4B, 0x8D, 0x4B, 0x00, 0x7A, 0x22, 0x08, 0xA4,
/* 1930 */ 0x96, 0x5F, 0x79, 0x45, 0x30, 0x7A, 0x0A, 0x8A, 0x04, 0x9C, 0x54, 0x07, 0x10, 0x06, 0x31, 0x77,
/* 1940 */ 0x96, 0x0D, 0x07, 0x55, 0x50, 0xA3, 0x0C, 0x6F, 0x97, 0x54, 0x19, 0x36, 0x56, 0xD3, 0x98, 0x89,
/* 1950 */ 0x02, 0x02, 0x1F, 0x23, 0xA3, 0xEA, 0x92, 0x7D, 0x25, 0xF6, 0x9F, 0x04, 0x68, 0xF1, 0x03, 0x68,
/* 1960 */ 0x25, 0xCB, 0x01, 0x10, 0x07, 0x47, 0x7E, 0x88, 0x9E, 0x6D, 0x22, 0x3B, 0x65, 0x18, 0xEA, 0x25,
/* 1970 */ 0x4C, 0xFC, 0xEF, 0x10, 0x07, 0xEE, 0x2F, 0x04, 0x0D, 0x73, 0xEA, 0xA3, 0x05, 0xCC, 0x1B, 0x4C,
/* 1980 */ 0xFC, 0xEF, 0x10, 0x07, 0x3D, 0x07, 0x72, 0x18, 0x41, 0x72, 0x4B, 0x1F, 0x70, 0x64, 0x09, 0xA1,
/* 1990 */ 0x4C, 0xFC, 0xEF, 0x10, 0x07, 0x47, 0x7A, 0x7A, 0x28, 0x9E, 0x89, 0x0C, 0x0E, 0x28, 0x5A, 0x87,
/* 19A0 */ 0x45, 0x00, 0x1C, 0x4C, 0xFC, 0xEF, 0x10, 0x04, 0x9D, 0x02, 0x4E, 0x62, 0x0F, 0x8F, 0x25, 0x67,
/* 19B0 */ 0x0E, 0x08, 0x18, 0xEA, 0x28, 0x3A, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x47, 0x97, 0x3C, 0x4C, 0x0F,
/* 19C0 */ 0x3E, 0x5B, 0x06, 0x01, 0xF1, 0x19, 0x61, 0xC1, 0xC1, 0xE5, 0x10, 0x04, 0x9D, 0x98, 0x90, 0x30,
/* 19D0 */ 0x3B, 0xA3, 0x4F, 0x55, 0x64, 0x08, 0x77, 0x0A, 0x28, 0x55, 0x61, 0xC1, 0xC1, 0xE5, 0x10, 0x04,
/* 19E0 */ 0x9D, 0x01, 0xDD, 0x35, 0x37, 0x0A, 0x0F, 0xEB, 0x08, 0x85, 0x08, 0x89, 0x93, 0x2C, 0xC1, 0xC1,
/* 19F0 */ 0xE5, 0x10, 0x07, 0xEE, 0x05, 0x1F, 0x8D, 0x79, 0x73, 0x30, 0xBA, 0x54, 0x28, 0x34, 0x0C, 0x72,
/* 1A00 */ 0xF1, 0x9E, 0x83, 0x00, 0x41, 0x0D, 0x8A, 0x0F, 0x6F, 0x5E, 0x96, 0x54, 0xBA, 0x0B, 0x64, 0xA4,
/* 1A10 */ 0x19, 0x35, 0x4B, 0x64, 0xA4, 0xBA, 0x76, 0xF8, 0x19, 0x77, 0x78, 0x96, 0x63, 0x55, 0x4C, 0x54,
/* 1A20 */ 0x05, 0x10, 0x07, 0x57, 0x77, 0x6B, 0x95, 0x1F, 0x07, 0x0C, 0x0C, 0x0E, 0x06, 0x42, 0x61, 0xE3,
/* 1A30 */ 0xC7, 0x01, 0x5C, 0x6F, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0x10, 0x07, 0x47, 0x7E, 0x88, 0x8D, 0x91,
/* 1A40 */ 0x01, 0x18, 0x3B, 0x09, 0x32, 0x18, 0xEA, 0x28, 0x7E, 0xAF, 0xE6, 0x32, 0x10, 0x07, 0xEE, 0x2F,
/* 1A50 */ 0x03, 0x0D, 0x37, 0xEA, 0x8A, 0x06, 0xCC, 0x1E, 0x3B, 0xAF, 0xE6, 0x32, 0x10, 0x07, 0x47, 0x97,
/* 1A60 */ 0xA3, 0x28, 0xE9, 0x96, 0x0A, 0x55, 0x64, 0x07, 0x7E, 0xE7, 0x55, 0x3B, 0xAF, 0xE6, 0x32, 0x10,
/* 1A70 */ 0x07, 0x1B, 0xEE, 0x6B, 0x95, 0x1F, 0x6A, 0x0C, 0x32, 0xA1, 0x03, 0xAF, 0xE6, 0x32, 0x10, 0x07,
/* 1A80 */ 0x47, 0x7A, 0xDD, 0x62, 0x37, 0x0B, 0x73, 0x2A, 0x35, 0x0E, 0x67, 0x89, 0x42, 0x3B, 0xAF, 0xE6,
/* 1A90 */ 0x32, 0x10, 0x07, 0x46, 0x97, 0xF5, 0xA1, 0x04, 0xD5, 0x42, 0x2D, 0xF5, 0x10, 0x07, 0x2A, 0xA6,
/* 1AA0 */ 0x41, 0x07, 0x9F, 0x96, 0x30, 0x3B, 0xA7, 0x0C, 0xF7, 0x72, 0x0F, 0x6D, 0x2D, 0x0F, 0x52, 0x0C,
/* 1AB0 */ 0x54, 0x2A, 0xFF, 0x09, 0x66, 0x4D, 0x36, 0x84, 0x02, 0x78, 0x2D, 0xA3, 0x0C, 0x02, 0x54, 0x19,
/* 1AC0 */ 0x7A, 0x78, 0x5B, 0x68, 0x00, 0x61, 0xA4, 0x7F, 0x97, 0x63, 0x22, 0x3B, 0x09, 0x10, 0x07, 0x47,
/* 1AD0 */ 0x7E, 0x02, 0x3C, 0x9E, 0x6D, 0x22, 0x3B, 0x65, 0x00, 0xCC, 0x1F, 0xD7, 0xB3, 0x91, 0x10, 0x07,
/* 1AE0 */ 0xEE, 0x2F, 0xEC, 0x73, 0x1F, 0xF6, 0x05, 0xCC, 0x3C, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x3D, 0x07,
/* 1AF0 */ 0x94, 0x25, 0xF8, 0x4B, 0x1F, 0x70, 0x64, 0xE7, 0x75, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x47, 0xBF,
/* 1B00 */ 0x9E, 0xF0, 0x87, 0x45, 0x1C, 0xD7, 0xB3, 0x91, 0x10, 0x07, 0x3D, 0x7E, 0x88, 0x07, 0xA3, 0x25,
/* 1B10 */ 0xFA, 0x88, 0x9F, 0x7C, 0xB2, 0x10, 0x08, 0x57, 0x03, 0x0E, 0xC1, 0x0E, 0x08, 0xDF, 0x18, 0x64,
/* 1B20 */ 0x4F, 0x10, 0x07, 0x9D, 0x7A, 0xDD, 0x00, 0xF6, 0xF6, 0xF7, 0x0A, 0x81, 0xE7, 0x75, 0x7C, 0xB2,
/* 1B30 */ 0x10, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x15, 0x00, 0x0B, 0x07, 0x42, 0x39, 0x08, 0x20, 0x09, 0x2A,
/* 1B40 */ 0x23, 0x5F, 0x54, 0x10, 0x07, 0x42, 0x39, 0x07, 0x20, 0x43, 0xA7, 0x5F, 0x83, 0x10, 0x0A, 0x42,
/* 1B50 */ 0x39, 0x07, 0x21, 0x20, 0x08, 0x22, 0xA7, 0x8E, 0x54, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00,
/* 1B60 */ 0x00, 0x01, 0x00, 0x00, 0x06, 0x3D, 0x00, 0x00, 0x06, 0x3F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
/* 1B70 */ 0x00, 0x5F, 0x00, 0x00, 0x06, 0x42, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00,
/* 1B80 */ 0x00, 0x60, 0x00, 0x00, 0x11, 0x34, 0x00, 0x00, 0x11, 0xF4, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00,
/* 1B90 */ 0x00, 0x04, 0x00, 0x00, 0x1B, 0x31, 0x00, 0x00, 0x1B, 0x39,

521
contrib/mcufont/fonts/FiraSansCondensed-Bold16.mcufont.h Normal file
View file

@ -0,0 +1,521 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 16
* blob size: 7971, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x04, 0x7C, 0x00, 0x00, 0x04, 0xF1, 0x00, 0x00, 0x00, 0x92,
/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x1E, 0xE3, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x10, 0x00, 0x16, 0x00, 0x03, 0x00, 0x0F, 0x00, 0x01, 0x00, 0x11, 0x00, 0x13, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x31, 0x36, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x31, 0x36, 0x00,
/* dictionary data */
0x81, 0xC2, 0xC7, 0x0C, 0xC3, 0x81, 0xC4, 0x02, 0x0A, 0xCE, 0x80,
/* 0080 */ 0x08, 0xC7, 0x0C, 0xC2, 0x81, 0x34, 0xC1, 0x0E, 0xCE, 0xC6, 0xC2, 0x09, 0x08, 0xC3, 0x81, 0x05,
/* 0090 */ 0xC1, 0x0D, 0xC4, 0x01, 0x81, 0xC1, 0xC4, 0x0B, 0xC3, 0xFE, 0xC4, 0x0A, 0xC6, 0xCC, 0xD2, 0xCC,
/* 00A0 */ 0xC7, 0x28, 0x3A, 0x80, 0xCE, 0x80, 0x01, 0xC4, 0x07, 0x06, 0xC7, 0x06, 0x80, 0xC8, 0x01, 0x13,
/* 00B0 */ 0x81, 0xC8, 0x81, 0xC4, 0x01, 0x0B, 0x1D, 0xC3, 0x0A, 0xC6, 0xCC, 0xC8, 0x80, 0x1B, 0xC2, 0xCC,
/* 00C0 */ 0xCE, 0x80, 0xCC, 0xC1, 0x01, 0xCB, 0xCD, 0x80, 0x2A, 0xCE, 0x82, 0x81, 0xC5, 0x01, 0x0C, 0x07,
/* 00D0 */ 0xC2, 0x81, 0x0D, 0x41, 0x01, 0x09, 0xC7, 0x80, 0xCE, 0x03, 0x0A, 0xC2, 0x01, 0xC2, 0x82, 0x08,
/* 00E0 */ 0xC4, 0xC4, 0x81, 0xC4, 0x02, 0x01, 0xCA, 0x80, 0x40, 0x02, 0xC9, 0x08, 0xC3, 0x81, 0xC4, 0x01,
/* 00F0 */ 0xCD, 0x80, 0xCA, 0x07, 0x01, 0xC6, 0x10, 0xCE, 0xC5, 0xC4, 0xCC, 0xCE, 0xC1, 0x01, 0xCB, 0x80,
/* 0100 */ 0x09, 0x83, 0x19, 0xCD, 0xC4, 0x09, 0xC8, 0x80, 0x80, 0xC3, 0x01, 0xC9, 0x80, 0x02, 0x0A, 0xC3,
/* 0110 */ 0x81, 0xC4, 0x0C, 0xC3, 0x81, 0xC4, 0x0C, 0xC6, 0x81, 0xCE, 0xCC, 0x0A, 0xC1, 0xC8, 0xC3, 0xCB,
/* 0120 */ 0xCC, 0x80, 0xC9, 0xCE, 0xC2, 0xC1, 0x0C, 0x04, 0x14, 0x01, 0xCD, 0x0B, 0xC1, 0xCD, 0xCE, 0x80,
/* 0130 */ 0xC5, 0xC2, 0xCD, 0x09, 0xC5, 0xC1, 0xCE, 0x80, 0x01, 0xC1, 0x0D, 0xC8, 0x80, 0xED, 0xCE, 0xC9,
/* 0140 */ 0x0D, 0xC2, 0x80, 0xCC, 0xCE, 0xC3, 0xCD, 0xC1, 0xC1, 0x81, 0xC8, 0xCE, 0x80, 0xCD, 0xC7, 0xCD,
/* 0150 */ 0x09, 0xC6, 0x80, 0xC7, 0x32, 0x11, 0x40, 0x22, 0x01, 0xC8, 0xDD, 0xC7, 0x80, 0xCC, 0xC2, 0xCA,
/* 0160 */ 0x80, 0xCA, 0x40, 0x12, 0x41, 0x21, 0xCC, 0xC1, 0xC8, 0xC1, 0xCB, 0x80, 0xC2, 0xCB, 0xC4, 0x01,
/* 0170 */ 0x81, 0xC7, 0x08, 0xC4, 0x81, 0xCC, 0xC5, 0xC1, 0xC6, 0xCD, 0xC7, 0xCB, 0xC1, 0xC5, 0x81, 0x01,
/* 0180 */ 0xC7, 0x80, 0xC6, 0x0C, 0xC2, 0x80, 0xCB, 0xCB, 0xC4, 0xC9, 0x80, 0x08, 0xC5, 0x81, 0x80, 0xC1,
/* 0190 */ 0x09, 0xC3, 0xCD, 0xC3, 0x81, 0xDE, 0xC3, 0xCC, 0x40, 0x21, 0xC1, 0xCA, 0x81, 0xC3, 0xCE, 0xCB,
/* 01A0 */ 0xC4, 0xC1, 0xCD, 0xC6, 0xCA, 0x80, 0x81, 0xC6, 0xC2, 0x81, 0xCA, 0xC1, 0x08, 0xC2, 0x81, 0xCE,
/* 01B0 */ 0xC4, 0xC1, 0xC8, 0x09, 0x1D, 0x0B, 0x93, 0x6E, 0x3D, 0x00, 0x2C, 0x78, 0x2A, 0x26, 0x22, 0x01,
/* 01C0 */ 0x81, 0x1B, 0x1C, 0x04, 0xA3, 0x08, 0x1B, 0x0A, 0x91, 0x3A, 0x25, 0x42, 0x83, 0x26, 0x5B, 0x22,
/* 01D0 */ 0x93, 0x3E, 0x0E, 0x30, 0x92, 0x9F, 0x32, 0x38, 0x78, 0x44, 0x96, 0x59, 0x44, 0x48, 0xA0, 0x03,
/* 01E0 */ 0x66, 0x1B, 0x5A, 0x31, 0x54, 0x67, 0x73, 0x0F, 0x08, 0x45, 0xA4, 0x78, 0x00, 0x7A, 0x73, 0x03,
/* 01F0 */ 0x9A, 0x21, 0x0A, 0x62, 0x00, 0x0E, 0x91, 0x54, 0x0E, 0x91, 0x53, 0x0A, 0x22, 0x47, 0x43, 0x5B,
/* 0200 */ 0x2C, 0x0F, 0x78, 0x69, 0x9F, 0x2B, 0x8A, 0x8A, 0x8A, 0x03, 0x9A, 0xA1, 0x3D, 0x0F, 0x7B, 0x65,
/* 0210 */ 0x03, 0x9A, 0x04, 0x22, 0x09, 0x4A, 0x0E, 0x22, 0x04, 0x4E, 0x26, 0x2B, 0x03, 0x31, 0x06, 0x18,
/* 0220 */ 0x2B, 0x03, 0x31, 0x07, 0x18, 0x2B, 0x0E, 0xA0, 0x34, 0x0A, 0x43, 0x1C, 0x52, 0x22, 0x02, 0xA5,
/* 0230 */ 0x1E, 0x1E, 0x0E, 0x0D, 0xA2, 0x1D, 0x46, 0x55, 0x7B, 0x00, 0xA7, 0x1E, 0x1E, 0x1E, 0x0E, 0x70,
/* 0240 */ 0x07, 0x26, 0x5A, 0x0D, 0x2B, 0x4E, 0x18, 0x5A, 0x0D, 0x48, 0xA4, 0x03, 0x7F, 0x93, 0x3F, 0x2E,
/* 0250 */ 0x08, 0x93, 0x3F, 0x78, 0x7F, 0x93, 0x2D, 0x46, 0x78, 0x3A, 0x02, 0x08, 0x93, 0x3F, 0x0C, 0x9B,
/* 0260 */ 0x0A, 0x02, 0x1B, 0x0C, 0x0E, 0x3A, 0x73, 0x5F, 0x00, 0x4E, 0x26, 0x98, 0x0A, 0x0C, 0x0E, 0x26,
/* 0270 */ 0xA7, 0x9A, 0x26, 0x1D, 0x36, 0x63, 0x05, 0x26, 0x1D, 0x09, 0x78, 0x90, 0x18, 0x96, 0x0E, 0x43,
/* 0280 */ 0x7B, 0x54, 0x77, 0x20, 0x04, 0x09, 0x1C, 0x8B, 0x54, 0x53, 0x29, 0x6A, 0x1D, 0x03, 0x3D, 0x0C,
/* 0290 */ 0x73, 0x5B, 0x2C, 0x26, 0x7F, 0x9A, 0x2B, 0x7F, 0x9A, 0x00, 0x90, 0x26, 0x00, 0x2C, 0x26, 0x7F,
/* 02A0 */ 0x9A, 0x1D, 0x03, 0x3D, 0x0C, 0x73, 0x1D, 0x53, 0x43, 0x9A, 0x29, 0x7B, 0x1D, 0x39, 0x26, 0x23,
/* 02B0 */ 0x2A, 0x3D, 0x2A, 0xA4, 0x2C, 0x9F, 0x00, 0x46, 0x30, 0x23, 0x7F, 0x18, 0x5B, 0x76, 0x09, 0x2C,
/* 02C0 */ 0x9F, 0x00, 0x46, 0x30, 0x23, 0x2A, 0x3D, 0x2A, 0x3D, 0x65, 0x6E, 0x49, 0x4D, 0x49, 0x4D, 0x49,
/* 02D0 */ 0x4D, 0x49, 0x4D, 0x49, 0x4D, 0x49, 0x4D, 0x04, 0x3D, 0x00, 0x0E, 0x83, 0x3F, 0x09, 0x00, 0x03,
/* 02E0 */ 0x30, 0x1D, 0x0A, 0x55, 0x43, 0x21, 0x0C, 0x93, 0x5B, 0xA5, 0x07, 0x23, 0x6E, 0x30, 0x5B, 0x67,
/* 02F0 */ 0x93, 0x84, 0x44, 0x42, 0x01, 0x3D, 0x0F, 0x7B, 0x78, 0x72, 0x78, 0x44, 0x48, 0x0D, 0x3A, 0x78,
/* 0300 */ 0x75, 0x96, 0x9A, 0x26, 0x45, 0x0F, 0x01, 0x04, 0x06, 0x02, 0x3E, 0x1A, 0x5C, 0x03, 0x0F, 0x7B,
/* 0310 */ 0x0C, 0x0F, 0x8E, 0x22, 0x1C, 0x08, 0x5B, 0x09, 0x78, 0x40, 0x09, 0x78, 0x3E, 0x5A, 0x0F, 0x73,
/* 0320 */ 0x00, 0x7E, 0x1A, 0x1B, 0x1A, 0x5C, 0x1A, 0x5C, 0x1A, 0x00, 0x98, 0x00, 0x0C, 0x7B, 0x1D, 0x5D,
/* 0330 */ 0x0D, 0x69, 0x83, 0x5B, 0x2C, 0x0F, 0x55, 0x93, 0x1D, 0x5D, 0x64, 0x03, 0xA4, 0x6E, 0x05, 0x54,
/* 0340 */ 0x4A, 0x43, 0x9F, 0x1D, 0x6E, 0x09, 0x1C, 0x8D, 0x33, 0x07, 0x08, 0x93, 0x3F, 0x05, 0x73, 0x07,
/* 0350 */ 0x93, 0x3F, 0x02, 0x1C, 0x08, 0x93, 0x3F, 0x02, 0x09, 0x73, 0x93, 0x3F, 0x02, 0x05, 0x43, 0x93,
/* 0360 */ 0x3F, 0x02, 0x00, 0x1C, 0x93, 0x3F, 0x02, 0x38, 0x0A, 0x6F, 0x59, 0x44, 0x98, 0xA0, 0x28, 0x55,
/* 0370 */ 0x26, 0xA7, 0x0E, 0x80, 0x0C, 0x73, 0x3F, 0x07, 0x5B, 0x0C, 0x0F, 0x02, 0x65, 0x48, 0x43, 0x64,
/* 0380 */ 0x01, 0x83, 0x23, 0x48, 0x0F, 0x0B, 0x6F, 0x0B, 0x6F, 0x0B, 0x6F, 0x79, 0x9B, 0x0A, 0x02, 0x3E,
/* 0390 */ 0x40, 0x0B, 0x73, 0x8A, 0x25, 0x0F, 0x7B, 0x22, 0x05, 0x04, 0x0F, 0x7B, 0x1D, 0x76, 0x3C, 0x07,
/* 03A0 */ 0x7A, 0x9B, 0x07, 0x88, 0x05, 0x0C, 0x03, 0x01, 0x0B, 0x0C, 0x0F, 0x29, 0x78, 0x22, 0x07, 0x53,
/* 03B0 */ 0x0D, 0x2B, 0x4E, 0x18, 0x5A, 0x0D, 0x1D, 0x2D, 0x6E, 0x0B, 0x0B, 0x02, 0x65, 0x96, 0x19, 0x01,
/* 03C0 */ 0x80, 0x18, 0x4E, 0x18, 0x2B, 0x6D, 0x07, 0x53, 0x0A, 0x58, 0x0D, 0x02, 0x9F, 0x54, 0x76, 0x0A,
/* 03D0 */ 0x93, 0x1B, 0x5A, 0x2D, 0xA5, 0x44, 0x58, 0x73, 0x3E, 0x81, 0x40, 0x81, 0x40, 0x81, 0x40, 0x81,
/* 03E0 */ 0x40, 0x81, 0x65, 0x42, 0x09, 0x01, 0x2D, 0x38, 0x91, 0x5B, 0x4E, 0x6A, 0x65, 0x2A, 0x0F, 0xA4,
/* 03F0 */ 0x44, 0x80, 0x2D, 0x7F, 0x07, 0x91, 0x5B, 0x05, 0x91, 0x2B, 0x4E, 0x91, 0x5B, 0x0C, 0x52, 0x2B,
/* 0400 */ 0x4E, 0x91, 0x2A, 0x0F, 0x4B, 0x46, 0x0E, 0x6A, 0x68, 0x0D, 0x29, 0x25, 0x65, 0x7A, 0x43, 0x54,
/* 0410 */ 0x7F, 0xA8, 0x01, 0x2B, 0x8F, 0x43, 0xA4, 0x00, 0x48, 0x0B, 0x9B, 0x8B, 0x1E, 0x1E, 0x65, 0x98,
/* 0420 */ 0x3E, 0x53, 0x5B, 0x42, 0x5B, 0x98, 0x05, 0x40, 0x0E, 0x6A, 0x40, 0x0E, 0x6A, 0x03, 0x0F, 0x7B,
/* 0430 */ 0x53, 0x0D, 0x22, 0x29, 0x7B, 0x3E, 0x31, 0x3E, 0x31, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E,
/* 0440 */ 0x1E, 0x07, 0x23, 0x28, 0x04, 0x9A, 0x0F, 0x29, 0x00, 0xA7, 0x07, 0x00, 0x03, 0x01, 0x7A, 0x18,
/* 0450 */ 0x44, 0x58, 0x09, 0x40, 0x09, 0x18, 0x65, 0x48, 0x31, 0x1C, 0x08, 0x22, 0x25, 0x1C, 0x08, 0x22,
/* 0460 */ 0x25, 0x40, 0x0A, 0x01, 0x0E, 0x94, 0x59, 0x23, 0x46, 0x83, 0x2A, 0x47, 0x78, 0x23, 0x7F, 0x59,
/* 0470 */ 0x2A, 0x80, 0x9A, 0x18, 0x03, 0x9A, 0x51, 0x0E, 0xA6, 0x22, 0x43, 0xA4, 0x22, 0x09, 0x00, 0x1C,
/* 0480 */ 0x4C, 0x3A, 0x00, 0x0C, 0x78, 0x54, 0x3A, 0x29, 0x78, 0x83, 0x40, 0x0C, 0x0B, 0x65, 0x6E, 0xA0,
/* 0490 */ 0x65, 0x90, 0x59, 0x05, 0x9F, 0x3E, 0x03, 0x40, 0x0C, 0x0F, 0x62, 0x23, 0x48, 0x09, 0x0A, 0x06,
/* 04A0 */ 0x1B, 0x20, 0x65, 0x42, 0x9A, 0x8E, 0x92, 0x08, 0x40, 0x0E, 0x62, 0x40, 0x1C, 0x0F, 0x25, 0x32,
/* 04B0 */ 0x68, 0x5B, 0x68, 0x09, 0x0C, 0x44, 0x6C, 0x1C, 0x74, 0x5B, 0x6C, 0x0B, 0x05, 0x37, 0x3F, 0x07,
/* 04C0 */ 0x00, 0x47, 0x5E, 0x87, 0xA7, 0x31, 0x2B, 0x6E, 0x09, 0x0E, 0x73, 0x25, 0x03, 0x1C, 0x04, 0x0B,
/* 04D0 */ 0x9B, 0x8B, 0x6C, 0x00, 0x05, 0x60, 0x43, 0x54, 0x4A, 0x60, 0x43, 0x1B, 0x3A, 0x4C, 0x3A, 0x4C,
/* 04E0 */ 0x3A, 0x4C, 0x0D, 0x62, 0x28, 0x2B, 0x5A, 0x9D, 0x02, 0x0C, 0x62, 0x40, 0x0C, 0x62, 0x04, 0x9F,
/* 04F0 */ 0x3E,
/* dictionary offset */
0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0B, 0x00, 0x0C, 0x00,
/* 0500 */ 0x10, 0x00, 0x13, 0x00, 0x15, 0x00, 0x17, 0x00, 0x1A, 0x00, 0x1B, 0x00, 0x1D, 0x00, 0x1F, 0x00,
/* 0510 */ 0x21, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x31, 0x00, 0x33, 0x00, 0x34, 0x00, 0x36, 0x00, 0x37, 0x00,
/* 0520 */ 0x3A, 0x00, 0x3B, 0x00, 0x3D, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x44, 0x00, 0x46, 0x00,
/* 0530 */ 0x48, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x51, 0x00, 0x53, 0x00, 0x54, 0x00, 0x56, 0x00, 0x59, 0x00,
/* 0540 */ 0x5A, 0x00, 0x5D, 0x00, 0x5E, 0x00, 0x60, 0x00, 0x62, 0x00, 0x64, 0x00, 0x65, 0x00, 0x67, 0x00,
/* 0550 */ 0x69, 0x00, 0x6A, 0x00, 0x6C, 0x00, 0x70, 0x00, 0x73, 0x00, 0x75, 0x00, 0x7B, 0x00, 0x7F, 0x00,
/* 0560 */ 0x81, 0x00, 0x82, 0x00, 0x84, 0x00, 0x86, 0x00, 0x88, 0x00, 0x8B, 0x00, 0x8C, 0x00, 0x8D, 0x00,
/* 0570 */ 0x8E, 0x00, 0x90, 0x00, 0x93, 0x00, 0x95, 0x00, 0x98, 0x00, 0x99, 0x00, 0xA2, 0x00, 0xA4, 0x00,
/* 0580 */ 0xA6, 0x00, 0xA8, 0x00, 0xAA, 0x00, 0xAC, 0x00, 0xAE, 0x00, 0xB0, 0x00, 0xB2, 0x00, 0xB3, 0x00,
/* 0590 */ 0xB4, 0x00, 0xB6, 0x00, 0xB8, 0x00, 0xBA, 0x00, 0xBC, 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC3, 0x00,
/* 05A0 */ 0xC5, 0x00, 0xC8, 0x00, 0xC9, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00,
/* 05B0 */ 0xD5, 0x00, 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE0, 0x00, 0xE1, 0x00,
/* 05C0 */ 0xE3, 0x00, 0xE5, 0x00, 0xE6, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xED, 0x00, 0xEF, 0x00, 0xF1, 0x00,
/* 05D0 */ 0xF3, 0x00, 0xF5, 0x00, 0xF7, 0x00, 0xF9, 0x01, 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x01,
/* 05E0 */ 0x08, 0x01, 0x0A, 0x01, 0x0C, 0x01, 0x0E, 0x01, 0x10, 0x01, 0x12, 0x01, 0x14, 0x01, 0x16, 0x01,
/* 05F0 */ 0x19, 0x01, 0x1B, 0x01, 0x1D, 0x01, 0x1F, 0x01, 0x20, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01,
/* 0600 */ 0x27, 0x01, 0x29, 0x01, 0x2B, 0x01, 0x2D, 0x01, 0x2F, 0x01, 0x31, 0x01, 0x33, 0x01, 0x35, 0x01,
/* 0610 */ 0x37, 0x01, 0x3A, 0x01, 0x3C, 0x01, 0x3E, 0x01, 0x6C, 0x01, 0x91, 0x01, 0x94, 0x01, 0x9E, 0x01,
/* 0620 */ 0xB1, 0x01, 0xBA, 0x01, 0xCB, 0x01, 0xD6, 0x01, 0xE9, 0x02, 0x10, 0x02, 0x34, 0x02, 0x56, 0x02,
/* 0630 */ 0x71, 0x02, 0x7D, 0x02, 0x7F, 0x02, 0x83, 0x02, 0x91, 0x02, 0x9F, 0x02, 0xA2, 0x02, 0xA9, 0x02,
/* 0640 */ 0xAB, 0x02, 0xAD, 0x02, 0xB6, 0x02, 0xD4, 0x02, 0xF2, 0x02, 0xFA, 0x03, 0x00, 0x03, 0x05, 0x03,
/* 0650 */ 0x10, 0x03, 0x16, 0x03, 0x1B, 0x03, 0x1E, 0x03, 0x2F, 0x03, 0x34, 0x03, 0x42, 0x03, 0x4C, 0x03,
/* 0660 */ 0x5E, 0x03, 0x60, 0x03, 0x64, 0x03, 0x6F, 0x03, 0x71, 0x03, 0x8F, 0x03, 0x97, 0x03, 0x99, 0x03,
/* 0670 */ 0x9D, 0x03, 0xA7, 0x03, 0xA9, 0x03, 0xAB, 0x03, 0xAD, 0x03, 0xAF, 0x03, 0xB1, 0x03, 0xB8, 0x03,
/* 0680 */ 0xC0, 0x03, 0xC4, 0x03, 0xCF, 0x03, 0xD1, 0x03, 0xD3, 0x03, 0xDD, 0x03, 0xE3, 0x03, 0xEC, 0x03,
/* 0690 */ 0xEE, 0x03, 0xFD, 0x03, 0xFF, 0x04, 0x0D, 0x04, 0x14, 0x04, 0x17, 0x04, 0x1E, 0x04, 0x21, 0x04,
/* 06A0 */ 0x2A, 0x04, 0x2C, 0x04, 0x33, 0x04, 0x38, 0x04, 0x3A, 0x04, 0x49, 0x04, 0x4C, 0x04, 0x50, 0x04,
/* 06B0 */ 0x57, 0x04, 0x59, 0x04, 0x5E, 0x04, 0x60, 0x04, 0x67, 0x04, 0x70, 0x04, 0x72, 0x04, 0x74, 0x04,
/* 06C0 */ 0x79, 0x04, 0x7C,
/* char range info */
0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1D, 0x00, 0x35,
/* 06D0 */ 0x00, 0x6A, 0x00, 0xA4, 0x00, 0xF2, 0x01, 0x31, 0x01, 0x3F, 0x01, 0x6C, 0x01, 0x99, 0x01, 0xB8,
/* 06E0 */ 0x01, 0xC3, 0x01, 0xD0, 0x01, 0xDA, 0x01, 0xE0, 0x02, 0x0A, 0x02, 0x3B, 0x02, 0x54, 0x02, 0x7A,
/* 06F0 */ 0x02, 0xA7, 0x02, 0xD2, 0x02, 0xFD, 0x03, 0x2C, 0x03, 0x4F, 0x03, 0x81, 0x03, 0xB9, 0x03, 0xBF,
/* 0700 */ 0x03, 0xCC, 0x03, 0xEE, 0x04, 0x02, 0x04, 0x25, 0x04, 0x48, 0x04, 0xB6, 0x04, 0xBD, 0x04, 0xE8,
/* 0710 */ 0x05, 0x12, 0x05, 0x36, 0x05, 0x3F, 0x05, 0x57, 0x05, 0x90, 0x05, 0xA7, 0x05, 0xAD, 0x05, 0xC7,
/* 0720 */ 0x05, 0xF7, 0x06, 0x0A, 0x06, 0x55, 0x06, 0x5E, 0x06, 0x66, 0x06, 0x83, 0x06, 0xBD, 0x06, 0xEB,
/* 0730 */ 0x07, 0x1B, 0x07, 0x31, 0x07, 0x38, 0x07, 0x6C, 0x07, 0xC1, 0x07, 0xF3, 0x08, 0x05, 0x08, 0x2D,
/* 0740 */ 0x08, 0x42, 0x08, 0x6D, 0x08, 0x83, 0x08, 0x9C, 0x08, 0xA9, 0x08, 0xB6, 0x08, 0xBC, 0x08, 0xE2,
/* 0750 */ 0x08, 0xFD, 0x09, 0x16, 0x09, 0x1D, 0x09, 0x40, 0x09, 0x88, 0x09, 0xA4, 0x09, 0xAC, 0x09, 0xBF,
/* 0760 */ 0x09, 0xF0, 0x0A, 0x07, 0x0A, 0x26, 0x0A, 0x2E, 0x0A, 0x34, 0x0A, 0x4C, 0x0A, 0x64, 0x0A, 0x7A,
/* 0770 */ 0x0A, 0xA1, 0x0A, 0xC2, 0x0A, 0xCA, 0x0A, 0xF3, 0x0B, 0x30, 0x0B, 0x59, 0x0B, 0x5F, 0x0B, 0x81,
/* 0780 */ 0x0B, 0xA5, 0x0B, 0xB3, 0x0B, 0xDE, 0x03, 0x00, 0x10, 0x04, 0x9D, 0x07, 0x18, 0x3E, 0x5D, 0x64,
/* 0790 */ 0x8F, 0x23, 0x96, 0x23, 0x48, 0x43, 0xD9, 0x78, 0x72, 0x73, 0x33, 0x38, 0x0A, 0x6F, 0x59, 0x00,
/* 07A0 */ 0xDC, 0x5E, 0x10, 0x07, 0x9D, 0x04, 0x0F, 0x86, 0x26, 0x98, 0x73, 0x00, 0x9A, 0x45, 0x93, 0x00,
/* 07B0 */ 0x9B, 0x45, 0x83, 0x00, 0x80, 0x5F, 0x62, 0x00, 0x0C, 0x0D, 0x10, 0x08, 0xBF, 0x9A, 0x5A, 0x05,
/* 07C0 */ 0x1D, 0x46, 0x78, 0x53, 0x03, 0x48, 0x0F, 0x55, 0x43, 0x1D, 0xF7, 0x0E, 0x0D, 0xBE, 0x42, 0x7B,
/* 07D0 */ 0x02, 0x78, 0x1B, 0x09, 0x6A, 0x04, 0x93, 0x1B, 0x0B, 0x59, 0x05, 0x62, 0x54, 0x0C, 0x55, 0xA4,
/* 07E0 */ 0x2B, 0x4A, 0x78, 0x1C, 0x50, 0x2B, 0x46, 0x78, 0x53, 0x03, 0x00, 0x48, 0x93, 0x67, 0x97, 0x10,
/* 07F0 */ 0x08, 0x5B, 0x4B, 0x0C, 0x0F, 0x00, 0x40, 0x0C, 0x0F, 0xD5, 0x0E, 0x7B, 0x21, 0x53, 0x47, 0x63,
/* 0800 */ 0x96, 0x04, 0x8C, 0x09, 0x42, 0x18, 0x65, 0x96, 0xA2, 0x01, 0x32, 0x0B, 0x47, 0x50, 0xDB, 0x3A,
/* 0810 */ 0x9F, 0xB8, 0x30, 0x40, 0x0E, 0x62, 0x48, 0x57, 0x2A, 0xA4, 0xFC, 0x9A, 0xBE, 0x5B, 0x48, 0x09,
/* 0820 */ 0x0E, 0x91, 0x40, 0x0C, 0x0F, 0x00, 0x40, 0x0C, 0x0F, 0x10, 0x0D, 0x3E, 0x4B, 0x68, 0x01, 0x2D,
/* 0830 */ 0x4E, 0x69, 0x08, 0x44, 0x09, 0x74, 0x23, 0x03, 0x0F, 0x9B, 0x6A, 0x2A, 0x73, 0x2C, 0x0F, 0x04,
/* 0840 */ 0x03, 0x62, 0x67, 0x59, 0x2C, 0x6A, 0x04, 0x62, 0x07, 0x62, 0x3F, 0xA4, 0x0F, 0x52, 0x48, 0x61,
/* 0850 */ 0x06, 0x0B, 0x7B, 0x0B, 0x5E, 0x02, 0x2B, 0xF9, 0x93, 0x0B, 0x43, 0x73, 0x2B, 0x6D, 0x02, 0x73,
/* 0860 */ 0x4A, 0x01, 0x2D, 0x09, 0x2E, 0x73, 0x4A, 0x01, 0x23, 0x03, 0x78, 0x5B, 0x0B, 0x43, 0x73, 0x2C,
/* 0870 */ 0xF2, 0x00, 0x89, 0x5E, 0x02, 0x2D, 0x46, 0x10, 0x0B, 0x7E, 0x4E, 0x0D, 0x78, 0x08, 0x00, 0x6C,
/* 0880 */ 0xE2, 0x7B, 0x58, 0x0D, 0x4A, 0x0B, 0x7A, 0x43, 0x00, 0x0C, 0x2E, 0x2B, 0x6E, 0x0C, 0x0F, 0x3A,
/* 0890 */ 0x86, 0x00, 0x58, 0x18, 0x90, 0x07, 0x02, 0x2D, 0x36, 0xA0, 0x78, 0x02, 0x0E, 0x97, 0x65, 0x6E,
/* 08A0 */ 0x30, 0x4A, 0x30, 0xCF, 0x0A, 0x6E, 0x3A, 0x6A, 0x2B, 0x0B, 0x9A, 0x9B, 0x29, 0x6A, 0x23, 0x6E,
/* 08B0 */ 0x09, 0x3A, 0x8D, 0x9E, 0x0A, 0x02, 0x10, 0x04, 0x9D, 0x04, 0x73, 0xD9, 0x73, 0x72, 0x93, 0x72,
/* 08C0 */ 0x83, 0x5B, 0x68, 0x62, 0x10, 0x05, 0x7C, 0x46, 0xEF, 0x65, 0x0B, 0x91, 0x44, 0x6C, 0x43, 0x64,
/* 08D0 */ 0x0C, 0x2E, 0xDC, 0x9F, 0xB8, 0x43, 0xE6, 0x73, 0xDA, 0x0B, 0x40, 0x0C, 0x93, 0xDA, 0x0B, 0x40,
/* 08E0 */ 0x09, 0x73, 0x40, 0x5D, 0x72, 0x31, 0x3E, 0x0B, 0x62, 0x23, 0x48, 0x18, 0xE6, 0x6A, 0x5B, 0x68,
/* 08F0 */ 0x03, 0x10, 0x05, 0x54, 0x33, 0x68, 0x07, 0x64, 0x5A, 0x08, 0xD9, 0x18, 0xDA, 0x09, 0xD5, 0x43,
/* 0900 */ 0xD9, 0x31, 0x3E, 0x0F, 0x7B, 0x40, 0xBC, 0x32, 0xBC, 0x32, 0x0F, 0x2E, 0x68, 0xA4, 0x00, 0xDC,
/* 0910 */ 0x9F, 0xB8, 0x43, 0x40, 0x0C, 0x2E, 0x44, 0x48, 0x43, 0x64, 0x08, 0x91, 0x2D, 0x48, 0x10, 0x07,
/* 0920 */ 0x84, 0x4A, 0x05, 0x00, 0x45, 0x03, 0x08, 0x59, 0x05, 0x54, 0x7F, 0x78, 0x78, 0x59, 0x7A, 0xA3,
/* 0930 */ 0x78, 0x09, 0x34, 0x07, 0x43, 0x74, 0x5F, 0x0E, 0xA8, 0x83, 0x68, 0x05, 0x4E, 0x10, 0x08, 0x23,
/* 0940 */ 0x33, 0xFD, 0xBA, 0x0D, 0x72, 0x78, 0x72, 0x78, 0x10, 0x04, 0x00, 0x7C, 0x85, 0xD9, 0xA0, 0x6F,
/* 0950 */ 0xC6, 0x05, 0x00, 0xB8, 0x0E, 0x10, 0x06, 0x1D, 0x85, 0x48, 0x70, 0x57, 0x5B, 0x96, 0x3D, 0x10,
/* 0960 */ 0x04, 0x2D, 0x28, 0x85, 0xC3, 0x10, 0x07, 0x44, 0x4B, 0x61, 0x04, 0x40, 0x1C, 0x04, 0x65, 0x22,
/* 0970 */ 0x64, 0x81, 0xE6, 0x2E, 0x3E, 0x0E, 0x6A, 0x92, 0x26, 0x44, 0x7A, 0x78, 0xE6, 0x62, 0x3E, 0x67,
/* 0980 */ 0x6A, 0x92, 0x18, 0x44, 0x7A, 0x78, 0x40, 0x09, 0x83, 0x3E, 0x67, 0x91, 0xD5, 0x0A, 0x02, 0x10,
/* 0990 */ 0x09, 0xBF, 0x79, 0x73, 0x25, 0x42, 0xE2, 0x59, 0x54, 0x0E, 0x2E, 0x0B, 0x83, 0x22, 0x03, 0x90,
/* 09A0 */ 0x43, 0x96, 0x02, 0x4E, 0x26, 0x2D, 0x4E, 0x18, 0x4E, 0x18, 0x2D, 0xF9, 0x18, 0x4E, 0x26, 0x2B,
/* 09B0 */ 0x03, 0x9F, 0x90, 0x43, 0x54, 0x0E, 0x7B, 0x53, 0x0A, 0x42, 0xE2, 0x0F, 0x34, 0x79, 0x73, 0x04,
/* 09C0 */ 0x10, 0x07, 0x7E, 0xF9, 0x0E, 0x83, 0x1B, 0x9E, 0x9A, 0x83, 0x54, 0x4A, 0x9B, 0x83, 0x45, 0xA6,
/* 09D0 */ 0x0C, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0xEB, 0x83, 0x10, 0x07, 0x9D, 0x7F, 0x3A, 0xA2, 0x54,
/* 09E0 */ 0x53, 0x9B, 0xA4, 0x00, 0x48, 0x8E, 0x67, 0x93, 0xC9, 0x3E, 0x6D, 0x08, 0x44, 0x58, 0x63, 0x32,
/* 09F0 */ 0xE1, 0xEF, 0x46, 0xBC, 0x54, 0x6B, 0x62, 0x32, 0x4A, 0x78, 0x70, 0x54, 0x0A, 0x55, 0x78, 0x10,
/* 0A00 */ 0x08, 0x9D, 0xA9, 0x0D, 0x78, 0x08, 0x54, 0x4A, 0x43, 0x30, 0x54, 0x8C, 0x5B, 0x0B, 0x93, 0x00,
/* 0A10 */ 0x68, 0x0C, 0x2E, 0x1B, 0x09, 0x30, 0x3E, 0x09, 0x1C, 0xA8, 0xE6, 0x43, 0xD5, 0x26, 0x1D, 0x03,
/* 0A20 */ 0xD2, 0x53, 0x0E, 0x54, 0x0C, 0xE2, 0x7B, 0x1D, 0x6E, 0x09, 0x1C, 0xA2, 0x10, 0x08, 0x5B, 0x84,
/* 0A30 */ 0x25, 0xD9, 0x78, 0x64, 0x09, 0x73, 0x40, 0x0E, 0x91, 0x65, 0x96, 0x64, 0x0A, 0x93, 0x03, 0x78,
/* 0A40 */ 0x54, 0x6D, 0x06, 0x05, 0x78, 0x54, 0x5D, 0x8C, 0x78, 0x00, 0xFC, 0x55, 0x43, 0x2B, 0x7F, 0x80,
/* 0A50 */ 0x69, 0xBE, 0xB8, 0x78, 0x00, 0xB8, 0x78, 0x10, 0x08, 0x9D, 0x03, 0x55, 0x78, 0x00, 0x22, 0x70,
/* 0A60 */ 0x09, 0x98, 0x18, 0x65, 0x22, 0x0A, 0x0C, 0xA6, 0x98, 0x47, 0xBE, 0x54, 0x8C, 0x05, 0xA9, 0x9F,
/* 0A70 */ 0x92, 0x3D, 0x44, 0xA7, 0x05, 0x2B, 0x6E, 0x0B, 0x02, 0x7F, 0x18, 0xFC, 0x29, 0x62, 0x00, 0x42,
/* 0A80 */ 0x3A, 0x8D, 0x10, 0x08, 0xBF, 0x82, 0x9B, 0xD2, 0x1D, 0x46, 0x0E, 0x43, 0xA0, 0x54, 0x53, 0x86,
/* 0A90 */ 0x68, 0x0F, 0x7B, 0x61, 0x07, 0x00, 0x48, 0x55, 0xA4, 0x96, 0xD2, 0x0B, 0x73, 0x96, 0x02, 0x90,
/* 0AA0 */ 0x9A, 0x48, 0x31, 0x08, 0x43, 0x2B, 0x6E, 0x30, 0x53, 0x0B, 0x58, 0x43, 0x31, 0x1D, 0x7F, 0x3A,
/* 0AB0 */ 0x8B, 0x10, 0x07, 0x9D, 0x0D, 0x55, 0x62, 0x54, 0x0B, 0x80, 0x3A, 0x62, 0x92, 0x31, 0x1B, 0x7F,
/* 0AC0 */ 0x43, 0x40, 0xBC, 0x1B, 0xFF, 0x0A, 0x73, 0x3E, 0x76, 0x19, 0x5D, 0x64, 0x0C, 0x83, 0x00, 0x68,
/* 0AD0 */ 0x0C, 0x6A, 0x00, 0x72, 0x10, 0x08, 0x7E, 0x82, 0x9B, 0x8B, 0x1B, 0x0C, 0xE2, 0x6A, 0x22, 0x25,
/* 0AE0 */ 0x0C, 0x83, 0xA7, 0x04, 0x53, 0x08, 0x54, 0x0B, 0x78, 0x36, 0x75, 0x54, 0xF7, 0x30, 0x1D, 0x46,
/* 0AF0 */ 0x0E, 0x6A, 0x05, 0x0E, 0x62, 0x2B, 0x7F, 0x78, 0x5B, 0x5D, 0x1D, 0x36, 0x52, 0x5A, 0x0F, 0x22,
/* 0B00 */ 0x29, 0x62, 0x98, 0x0B, 0x1C, 0x8D, 0x10, 0x08, 0x7E, 0x9E, 0x0E, 0xA0, 0x03, 0x1D, 0x6E, 0x0D,
/* 0B10 */ 0xE2, 0x52, 0x2B, 0x4E, 0x18, 0x6D, 0x07, 0xFC, 0x0D, 0x5B, 0x0C, 0x83, 0xFC, 0x0D, 0x5B, 0x0B,
/* 0B20 */ 0x73, 0x2B, 0x4E, 0x9F, 0xF7, 0x0B, 0x1D, 0x6D, 0x47, 0x62, 0x98, 0x61, 0x07, 0xA4, 0x65, 0xFC,
/* 0B30 */ 0x52, 0x1B, 0x82, 0x9A, 0xEF, 0x0A, 0x9A, 0x20, 0x32, 0x09, 0x0D, 0x87, 0x00, 0x68, 0x10, 0x04,
/* 0B40 */ 0x41, 0xC3, 0x44, 0xC3, 0x10, 0x04, 0x41, 0xC3, 0x44, 0x03, 0xA0, 0x6F, 0xC6, 0x05, 0x00, 0xB8,
/* 0B50 */ 0x0E, 0x10, 0x08, 0x56, 0xBF, 0x6C, 0x0C, 0x09, 0x5B, 0x6C, 0x0C, 0xBE, 0x00, 0x48, 0x3A, 0x93,
/* 0B60 */ 0x25, 0x58, 0x99, 0xB8, 0x9A, 0xA2, 0x01, 0x44, 0x48, 0x88, 0x43, 0x08, 0x00, 0xDC, 0x0A, 0x93,
/* 0B70 */ 0x00, 0x72, 0x03, 0x10, 0x08, 0x1D, 0x41, 0x48, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x65, 0x33,
/* 0B80 */ 0x48, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x10, 0x08, 0x41, 0x01, 0x0E, 0x08, 0x02, 0x44, 0x6C,
/* 0B90 */ 0x1C, 0x62, 0x02, 0x68, 0x07, 0x1C, 0x83, 0x64, 0x08, 0x26, 0x00, 0x98, 0x09, 0x9A, 0x52, 0x1D,
/* 0BA0 */ 0x03, 0x88, 0x43, 0x07, 0x01, 0x98, 0x0F, 0xA2, 0x64, 0x05, 0x10, 0x07, 0x7E, 0x79, 0x43, 0xD2,
/* 0BB0 */ 0x58, 0x29, 0x62, 0x1D, 0x6E, 0x60, 0x53, 0x0C, 0x3E, 0xF7, 0x09, 0x32, 0xE1, 0xA6, 0x32, 0x0C,
/* 0BC0 */ 0x62, 0xE6, 0x0B, 0x03, 0x33, 0x09, 0x0C, 0x03, 0x92, 0x30, 0x40, 0x0B, 0xA8, 0x10, 0x0F, 0x2D,
/* 0BD0 */ 0x84, 0xD9, 0x0A, 0x3A, 0xA0, 0x06, 0xFC, 0x9A, 0x69, 0xBE, 0x02, 0x65, 0x5A, 0x50, 0x5B, 0x46,
/* 0BE0 */ 0xA3, 0x75, 0x5B, 0x2A, 0x0F, 0x63, 0x51, 0x0F, 0x8D, 0x53, 0x07, 0x44, 0x0B, 0x7B, 0x6D, 0x0E,
/* 0BF0 */ 0x9F, 0x04, 0x78, 0x00, 0x6E, 0x18, 0x07, 0x93, 0x67, 0x59, 0x76, 0x5B, 0x03, 0x43, 0x4A, 0x07,
/* 0C00 */ 0x67, 0x59, 0x01, 0x26, 0x2A, 0x78, 0x53, 0x07, 0x67, 0x59, 0x03, 0x43, 0x5B, 0x03, 0x43, 0x4A,
/* 0C10 */ 0x09, 0x6D, 0x04, 0x07, 0x93, 0x00, 0x46, 0x26, 0x8F, 0x5E, 0x69, 0x31, 0x5B, 0x0C, 0x91, 0x00,
/* 0C20 */ 0x77, 0x99, 0x04, 0x0E, 0x0D, 0x05, 0x44, 0x90, 0x78, 0x24, 0x0C, 0x0F, 0x57, 0x5B, 0x46, 0x03,
/* 0C30 */ 0x2D, 0x6E, 0x88, 0x43, 0x69, 0x73, 0x6C, 0x0B, 0x3A, 0x5E, 0x07, 0x10, 0x09, 0xBF, 0x8F, 0x97,
/* 0C40 */ 0xAB, 0xB7, 0x10, 0x09, 0xFD, 0xF5, 0x0E, 0x1C, 0x78, 0x00, 0xF4, 0x09, 0x18, 0xF4, 0x95, 0x52,
/* 0C50 */ 0x3F, 0x0E, 0x1C, 0x57, 0xA7, 0x9A, 0x43, 0x07, 0xA7, 0x07, 0x90, 0x0F, 0x6A, 0xF4, 0x76, 0x09,
/* 0C60 */ 0xF4, 0x05, 0x30, 0x3F, 0x0E, 0x0D, 0x9A, 0x63, 0x3F, 0x0F, 0x78, 0x0A, 0x03, 0x10, 0x08, 0xBF,
/* 0C70 */ 0x03, 0x0B, 0x9B, 0x94, 0x54, 0xE1, 0x29, 0x75, 0x1D, 0x3A, 0x75, 0xF9, 0x02, 0x48, 0xA4, 0x3E,
/* 0C80 */ 0x5D, 0x04, 0xB8, 0x9F, 0x3E, 0x5D, 0x04, 0x65, 0x48, 0xA4, 0x40, 0x1C, 0x75, 0x2A, 0x25, 0x96,
/* 0C90 */ 0x29, 0x52, 0x00, 0x48, 0x0B, 0x9B, 0x94, 0x10, 0x0A, 0xFD, 0xF5, 0x9B, 0x9A, 0x86, 0xF4, 0x8F,
/* 0CA0 */ 0x07, 0xF4, 0x67, 0x73, 0xF4, 0x4A, 0x0E, 0xF4, 0x5A, 0x0F, 0xF4, 0x4A, 0x0E, 0xF4, 0x67, 0x73,
/* 0CB0 */ 0xF4, 0x8F, 0x07, 0x3F, 0x9B, 0x9A, 0x86, 0x3F, 0xBE, 0x07, 0x01, 0x10, 0x08, 0xFD, 0xC4, 0x54,
/* 0CC0 */ 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x07, 0xFD, 0x55, 0x78, 0x00, 0xA7, 0x0E, 0x80, 0x0A, 0x00, 0xA7,
/* 0CD0 */ 0x1E, 0xD8, 0x0F, 0x31, 0xA7, 0x0E, 0x80, 0x25, 0xA7, 0x1E, 0xD8, 0x07, 0x10, 0x09, 0xBF, 0x82,
/* 0CE0 */ 0x1C, 0x8D, 0x98, 0x0E, 0xE2, 0x7B, 0x2B, 0x67, 0x78, 0x02, 0x6E, 0x05, 0x22, 0x06, 0x44, 0x7A,
/* 0CF0 */ 0x9F, 0x01, 0x70, 0x0A, 0x00, 0x2C, 0x18, 0x00, 0x0E, 0xBE, 0x00, 0x2C, 0x9F, 0x5B, 0x0A, 0x73,
/* 0D00 */ 0x2D, 0xF9, 0x3D, 0x4A, 0x0C, 0x2B, 0x6D, 0x0B, 0x5B, 0x0A, 0x73, 0x5B, 0x2C, 0x9A, 0x9B, 0xBE,
/* 0D10 */ 0x6C, 0x0C, 0x1C, 0x8D, 0x01, 0x10, 0x0A, 0xFD, 0x0F, 0x7B, 0x5B, 0x0C, 0xC5, 0xC5, 0xC5, 0x73,
/* 0D20 */ 0x3F, 0x0E, 0x80, 0xBE, 0x3F, 0x55, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0x73, 0x10, 0x04, 0x9D, 0xA5,
/* 0D30 */ 0xD8, 0xE0, 0x10, 0x05, 0x44, 0x84, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9,
/* 0D40 */ 0x40, 0x0C, 0x83, 0x3E, 0xE1, 0x07, 0x68, 0x0F, 0x78, 0x64, 0x0B, 0xD2, 0x10, 0x09, 0x1D, 0x84,
/* 0D50 */ 0xF4, 0x4A, 0x75, 0xCF, 0x07, 0x2A, 0x0F, 0x6A, 0xF4, 0x4D, 0x46, 0x0F, 0x7B, 0x07, 0x0F, 0x63,
/* 0D60 */ 0xA7, 0x77, 0x7B, 0x00, 0xA7, 0x0B, 0xA4, 0x00, 0xA7, 0x07, 0x0C, 0x0F, 0x52, 0xA7, 0x07, 0x04,
/* 0D70 */ 0x30, 0xA7, 0x07, 0x53, 0x63, 0xF4, 0x03, 0x0F, 0x83, 0xF4, 0x4A, 0x59, 0x10, 0x07, 0x9D, 0xA5,
/* 0D80 */ 0xD8, 0xD8, 0xD8, 0xD8, 0x07, 0x01, 0x01, 0x01, 0x1D, 0x46, 0x55, 0x9F, 0xA7, 0x9A, 0x26, 0x10,
/* 0D90 */ 0x0C, 0x7E, 0x0C, 0x30, 0x5B, 0x9A, 0x6A, 0x2D, 0x3A, 0x83, 0x46, 0x0F, 0xA4, 0x2D, 0x0E, 0x43,
/* 0DA0 */ 0x0D, 0xF9, 0x43, 0x7B, 0x2D, 0xBE, 0x0F, 0xA9, 0x73, 0x2E, 0x65, 0x76, 0x95, 0x04, 0x0A, 0x62,
/* 0DB0 */ 0x62, 0x65, 0x46, 0xA4, 0x0F, 0x79, 0x0C, 0x09, 0x83, 0x23, 0x03, 0x9F, 0x83, 0x62, 0x08, 0x93,
/* 0DC0 */ 0x23, 0xE1, 0x00, 0x9B, 0x91, 0x08, 0x73, 0x23, 0x8F, 0x53, 0x59, 0x07, 0x78, 0x65, 0x4E, 0x43,
/* 0DD0 */ 0x00, 0x35, 0x0C, 0x90, 0x43, 0x65, 0x90, 0x43, 0x23, 0x5D, 0x10, 0x0A, 0xFD, 0x47, 0xB2, 0x95,
/* 0DE0 */ 0xC2, 0x4A, 0x93, 0x10, 0x0A, 0xBF, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x09, 0xFD, 0xF5, 0x9B,
/* 0DF0 */ 0x9A, 0x75, 0xF4, 0x07, 0x0F, 0x6A, 0xF4, 0x03, 0x0F, 0x7B, 0xF4, 0x07, 0x3D, 0xCF, 0x9B, 0xBE,
/* 0E00 */ 0xA7, 0x0F, 0x78, 0x87, 0xA7, 0x1E, 0xD8, 0x07, 0x10, 0x0A, 0xBF, 0xF8, 0x0F, 0xE2, 0x7B, 0x1D,
/* 0E10 */ 0x39, 0x26, 0x23, 0x2A, 0x3D, 0x2A, 0xA4, 0x2C, 0x9F, 0x00, 0x46, 0x30, 0x23, 0x7F, 0x18, 0x5B,
/* 0E20 */ 0x76, 0x09, 0x2C, 0x9F, 0x5B, 0xA5, 0x07, 0x23, 0x2A, 0x3D, 0x2A, 0x31, 0x65, 0x6E, 0x39, 0x73,
/* 0E30 */ 0x1D, 0x5D, 0x43, 0x73, 0x02, 0x6C, 0x0C, 0x47, 0xA0, 0x05, 0x68, 0x05, 0x3A, 0x75, 0x00, 0x68,
/* 0E40 */ 0x0C, 0x03, 0x10, 0x09, 0xFD, 0x47, 0x78, 0x09, 0x02, 0xA7, 0x9B, 0x9A, 0x75, 0xF4, 0x07, 0x0F,
/* 0E50 */ 0x6A, 0xF4, 0x03, 0xA4, 0x3F, 0x07, 0x01, 0x09, 0x31, 0xCF, 0x47, 0x83, 0xA7, 0x9B, 0x73, 0x00,
/* 0E60 */ 0xA7, 0x07, 0x06, 0x9F, 0x00, 0xF4, 0x0E, 0x93, 0xA7, 0x07, 0x90, 0x9A, 0x04, 0xF4, 0x6D, 0x0C,
/* 0E70 */ 0x10, 0x08, 0x7E, 0x82, 0x0E, 0x73, 0x07, 0x54, 0x6D, 0x29, 0x7B, 0x1D, 0x5D, 0x04, 0x46, 0x08,
/* 0E80 */ 0x7A, 0xA4, 0x3E, 0x6D, 0x73, 0x06, 0x01, 0x1B, 0x89, 0x9A, 0x78, 0x02, 0xDC, 0x95, 0x93, 0xDA,
/* 0E90 */ 0x0E, 0x1D, 0x82, 0x02, 0x6E, 0x0D, 0x78, 0x1D, 0x0A, 0x9A, 0x9B, 0xA4, 0x42, 0x0C, 0x9B, 0x8B,
/* 0EA0 */ 0x10, 0x08, 0x9D, 0x0D, 0x55, 0xBE, 0x1D, 0x0B, 0x69, 0x9A, 0x80, 0x08, 0x1B, 0xED, 0xED, 0xED,
/* 0EB0 */ 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0x10, 0x09, 0x9D, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x08, 0x44,
/* 0EC0 */ 0x84, 0x68, 0x30, 0x5B, 0x76, 0x07, 0x2B, 0x0C, 0x93, 0x00, 0x2A, 0x9F, 0x2D, 0x7F, 0x43, 0x00,
/* 0ED0 */ 0x90, 0x43, 0x48, 0x18, 0x4A, 0x0B, 0x2B, 0x6E, 0xA4, 0x67, 0x7B, 0x54, 0x0C, 0x0F, 0xD2, 0x9F,
/* 0EE0 */ 0x58, 0x0C, 0x03, 0x43, 0x5B, 0x48, 0xA4, 0x93, 0x32, 0xBE, 0x7B, 0x32, 0x0B, 0x47, 0x04, 0xDB,
/* 0EF0 */ 0x47, 0x10, 0x0C, 0x9D, 0x0C, 0x83, 0x00, 0x03, 0x0F, 0x62, 0x2A, 0x18, 0x44, 0x0A, 0x73, 0xF9,
/* 0F00 */ 0x0F, 0x93, 0x00, 0x8F, 0x44, 0x7F, 0x78, 0x90, 0x0F, 0x78, 0x90, 0x78, 0x65, 0x8F, 0x4A, 0x0C,
/* 0F10 */ 0x0F, 0x5A, 0x0A, 0x65, 0x03, 0x26, 0x0C, 0x0D, 0x95, 0x89, 0x2E, 0x5B, 0x6E, 0x9F, 0xA0, 0x07,
/* 0F20 */ 0x0F, 0x04, 0x0D, 0x91, 0x23, 0x0E, 0x6A, 0x62, 0x05, 0x91, 0x1C, 0x04, 0x23, 0x0C, 0x62, 0x7B,
/* 0F30 */ 0x03, 0x62, 0x18, 0x65, 0x4A, 0x3A, 0xA1, 0x78, 0x43, 0x2D, 0x36, 0x18, 0x00, 0x0E, 0xBE, 0x23,
/* 0F40 */ 0x4E, 0x47, 0x5B, 0x0C, 0x0F, 0x83, 0x10, 0x08, 0x9D, 0xA3, 0x52, 0x7F, 0x18, 0x3F, 0x06, 0x00,
/* 0F50 */ 0xBC, 0x2B, 0x0A, 0x93, 0x05, 0x0F, 0x52, 0x98, 0xBE, 0x2E, 0x1B, 0x0A, 0x9A, 0x52, 0xDB, 0x0F,
/* 0F60 */ 0x43, 0x3E, 0x3C, 0xEF, 0x06, 0x0F, 0x71, 0x78, 0x1B, 0x3A, 0x08, 0x02, 0xA4, 0x2B, 0x4E, 0x18,
/* 0F70 */ 0x53, 0x0D, 0x2B, 0x67, 0x73, 0x5B, 0x8F, 0x05, 0x10, 0x09, 0x9D, 0x0D, 0x73, 0x5B, 0x6D, 0x09,
/* 0F80 */ 0x00, 0x2C, 0xCE, 0x31, 0x45, 0xBE, 0xF1, 0x09, 0xF1, 0x09, 0x10, 0x08, 0x9D, 0x8F, 0x47, 0x7B,
/* 0F90 */ 0x2B, 0xF9, 0x70, 0x1C, 0x7B, 0x32, 0x53, 0x63, 0x44, 0x96, 0x07, 0x68, 0x0D, 0x78, 0x32, 0x7F,
/* 0FA0 */ 0x31, 0x45, 0x0F, 0x83, 0x32, 0x53, 0x63, 0x44, 0x96, 0x19, 0x0B, 0x9A, 0x70, 0xA2, 0x1D, 0x0C,
/* 0FB0 */ 0x55, 0xA4, 0x10, 0x05, 0x1D, 0x33, 0xB8, 0x70, 0x05, 0x5B, 0x58, 0xA4, 0x5B, 0x58, 0xC7, 0xC7,
/* 0FC0 */ 0xC7, 0xC7, 0x78, 0x05, 0x5B, 0x58, 0xA4, 0x10, 0x07, 0x4B, 0x0A, 0x74, 0x40, 0x0C, 0x7B, 0x6F,
/* 0FD0 */ 0x0A, 0x65, 0x6C, 0x43, 0x5B, 0x68, 0x9F, 0x40, 0x0C, 0x91, 0x40, 0x09, 0x83, 0x65, 0x6C, 0x78,
/* 0FE0 */ 0x72, 0x18, 0x3E, 0x67, 0x91, 0x40, 0x09, 0x62, 0xD5, 0x78, 0x23, 0xA7, 0x24, 0x0E, 0x6A, 0x00,
/* 0FF0 */ 0xB8, 0x60, 0x10, 0x05, 0x2B, 0x3B, 0x09, 0x70, 0x34, 0x53, 0x31, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF,
/* 1000 */ 0xDF, 0x1B, 0x09, 0x0D, 0x31, 0x54, 0x53, 0x31, 0x10, 0x08, 0x00, 0x3B, 0x96, 0x19, 0x0D, 0x9A,
/* 1010 */ 0x52, 0x00, 0x7A, 0x73, 0xA3, 0x08, 0x54, 0x6D, 0x05, 0x03, 0x18, 0x2B, 0x7F, 0x78, 0x5B, 0x0B,
/* 1020 */ 0x83, 0x10, 0x08, 0x33, 0xBF, 0x85, 0x0B, 0x70, 0x70, 0x05, 0x2B, 0x67, 0x55, 0xA4, 0x10, 0x05,
/* 1030 */ 0x7C, 0x64, 0x5B, 0x67, 0x09, 0x64, 0xF7, 0x57, 0x40, 0x35, 0x04, 0x10, 0x08, 0x41, 0x7F, 0xB3,
/* 1040 */ 0x99, 0x10, 0x09, 0x2B, 0x28, 0xBB, 0x29, 0x62, 0x22, 0x09, 0x4A, 0x0E, 0x22, 0x04, 0x4E, 0x18,
/* 1050 */ 0x2B, 0x03, 0x31, 0x06, 0x9F, 0x2B, 0x03, 0x31, 0x06, 0x18, 0x2B, 0x03, 0x0F, 0x7B, 0x53, 0x0E,
/* 1060 */ 0x22, 0x29, 0x7B, 0x22, 0x06, 0x0D, 0x71, 0x10, 0x07, 0x00, 0x41, 0x7F, 0x69, 0x8B, 0x54, 0x4A,
/* 1070 */ 0x43, 0x62, 0xE3, 0x97, 0xB8, 0x18, 0x65, 0x22, 0x07, 0x00, 0x34, 0x53, 0x29, 0x08, 0x5F, 0x09,
/* 1080 */ 0x9B, 0x8B, 0x10, 0x09, 0x65, 0x28, 0x48, 0x05, 0x03, 0x40, 0xBD, 0x0D, 0x1D, 0x6E, 0x0B, 0x5E,
/* 1090 */ 0x0B, 0x78, 0x54, 0xCC, 0xB1, 0xEA, 0x54, 0x9C, 0x93, 0x07, 0x78, 0x10, 0x08, 0x41, 0x6E, 0x09,
/* 10A0 */ 0xAF, 0xC1, 0x10, 0x05, 0x28, 0x7A, 0x61, 0x0A, 0x21, 0x4E, 0x47, 0x52, 0x54, 0x53, 0x86, 0x02,
/* 10B0 */ 0x32, 0x0C, 0x62, 0x3E, 0x3C, 0x6A, 0x1B, 0x0C, 0x0F, 0x43, 0x0D, 0x02, 0x32, 0x0C, 0x62, 0x40,
/* 10C0 */ 0xFE, 0x40, 0xFE, 0x40, 0xFE, 0x10, 0x08, 0x2B, 0xBF, 0x68, 0x03, 0x09, 0x09, 0x98, 0x0B, 0x3C,
/* 10D0 */ 0x0D, 0x1D, 0x6D, 0x1C, 0x7B, 0x01, 0x5B, 0x2C, 0x0F, 0x52, 0x03, 0x0F, 0x52, 0xFC, 0x0D, 0x6E,
/* 10E0 */ 0x31, 0x00, 0x2C, 0x18, 0x05, 0x9F, 0x2B, 0x6E, 0x0D, 0x47, 0x93, 0x1B, 0x09, 0x73, 0x0C, 0x87,
/* 10F0 */ 0x54, 0x76, 0x80, 0x0B, 0xEF, 0x09, 0x3C, 0x91, 0x00, 0x68, 0x0C, 0x73, 0x1D, 0x61, 0x03, 0x5B,
/* 1100 */ 0x0B, 0x93, 0x1D, 0x0A, 0x43, 0x0A, 0x88, 0x6A, 0x1D, 0x9E, 0x0E, 0x43, 0x94, 0x10, 0x08, 0x65,
/* 1110 */ 0x7C, 0x68, 0x04, 0x06, 0x02, 0x5B, 0x5C, 0x1A, 0x5B, 0x22, 0x35, 0x0E, 0xA6, 0x22, 0x9A, 0xA4,
/* 1120 */ 0x22, 0x0A, 0x6D, 0x4C, 0x3A, 0x4C, 0x3A, 0x4C, 0xFB, 0x10, 0x04, 0x28, 0xCD, 0x21, 0x2F, 0xC0,
/* 1130 */ 0x31, 0x10, 0x04, 0x28, 0xCD, 0x21, 0x2F, 0xC0, 0x31, 0x32, 0x09, 0x26, 0xDB, 0x0F, 0x62, 0x65,
/* 1140 */ 0x48, 0x62, 0x00, 0x72, 0x10, 0x08, 0x2B, 0x28, 0xA9, 0x0A, 0x03, 0x3E, 0x1A, 0x5C, 0x03, 0x31,
/* 1150 */ 0x09, 0x73, 0x22, 0x04, 0x03, 0x9A, 0x04, 0x22, 0x04, 0x0B, 0x83, 0x98, 0x0F, 0x62, 0x18, 0x98,
/* 1160 */ 0x0F, 0x93, 0x18, 0x98, 0x0F, 0x6A, 0x0E, 0x62, 0x00, 0x22, 0x04, 0x08, 0x26, 0x22, 0x04, 0x02,
/* 1170 */ 0x30, 0x22, 0x04, 0x4A, 0x52, 0x10, 0x04, 0x2B, 0x28, 0x8C, 0x08, 0x02, 0x3E, 0xFF, 0xFF, 0xFF,
/* 1180 */ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA5, 0x52, 0xB8, 0x0E, 0xA8, 0x10, 0x0C, 0x41, 0x03,
/* 1190 */ 0x9A, 0x51, 0x71, 0x9C, 0x71, 0x23, 0x03, 0x9A, 0x43, 0x9A, 0x9B, 0x31, 0x44, 0x03, 0x30, 0xA5,
/* 11A0 */ 0xD2, 0xA4, 0x65, 0xAD, 0xB9, 0x65, 0xAD, 0xB9, 0x65, 0xAD, 0xB9, 0x10, 0x08, 0x41, 0xE9, 0x4C,
/* 11B0 */ 0x3A, 0x4C, 0xFB, 0x10, 0x09, 0x41, 0x6E, 0xB4, 0xF6, 0x10, 0x09, 0x41, 0x03, 0x0F, 0x6A, 0x3A,
/* 11C0 */ 0x8E, 0x22, 0x29, 0x62, 0xAE, 0xDE, 0x22, 0x09, 0x69, 0x08, 0x54, 0x1A, 0x5C, 0x01, 0x05, 0x03,
/* 11D0 */ 0x01, 0x10, 0x09, 0x41, 0x6E, 0x0B, 0x5E, 0x08, 0x78, 0x54, 0xCC, 0xB1, 0xEA, 0x54, 0x9C, 0x93,
/* 11E0 */ 0x0A, 0x78, 0x40, 0xBD, 0x0D, 0x5B, 0x68, 0x03, 0x04, 0x10, 0x06, 0x41, 0x03, 0x0F, 0x6A, 0x0D,
/* 11F0 */ 0x0C, 0x00, 0x98, 0x47, 0x71, 0x5B, 0x22, 0x86, 0xDC, 0x0F, 0x7B, 0x5B, 0x5C, 0x1A, 0x5C, 0x10,
/* 1200 */ 0x07, 0x41, 0x4E, 0x0D, 0x78, 0x08, 0x1B, 0xE1, 0x0E, 0x9F, 0x58, 0x0E, 0x6E, 0x04, 0x5B, 0x96,
/* 1210 */ 0x94, 0x3E, 0x77, 0xBE, 0x02, 0x68, 0x07, 0x0F, 0x62, 0x54, 0x8C, 0x5B, 0x4D, 0x00, 0x4A, 0x43,
/* 1220 */ 0xA4, 0x54, 0x9E, 0x0E, 0x5E, 0x06, 0x10, 0x06, 0x84, 0x6E, 0x24, 0xBC, 0x32, 0xBC, 0x1B, 0x0F,
/* 1230 */ 0x55, 0x34, 0x3A, 0x43, 0x75, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0xBC, 0x32, 0x0E, 0x62,
/* 1240 */ 0xE6, 0x9A, 0x50, 0x32, 0x89, 0x0E, 0xA2, 0x10, 0x08, 0x41, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10,
/* 1250 */ 0x08, 0x41, 0x0E, 0x62, 0x5B, 0x0E, 0x7B, 0x1D, 0x0A, 0x73, 0x46, 0x9F, 0x2B, 0x4E, 0x43, 0xF9,
/* 1260 */ 0x43, 0x1D, 0x46, 0x18, 0x08, 0x83, 0x54, 0x67, 0x6A, 0x88, 0xEF, 0x95, 0x08, 0x3A, 0x21, 0xF9,
/* 1270 */ 0x73, 0x43, 0x32, 0x76, 0x83, 0x3E, 0x0C, 0xA4, 0x10, 0x0B, 0x41, 0x0D, 0x2E, 0x0A, 0x73, 0x00,
/* 1280 */ 0x81, 0x23, 0x0A, 0x83, 0x67, 0x43, 0x5A, 0x0A, 0x23, 0x81, 0x00, 0x43, 0x97, 0x0B, 0x7B, 0x65,
/* 1290 */ 0x2A, 0x0F, 0x99, 0x0F, 0xA3, 0x51, 0x6A, 0x23, 0xA5, 0x05, 0x91, 0x91, 0x1C, 0x02, 0x2D, 0x1C,
/* 12A0 */ 0x95, 0x02, 0x62, 0x43, 0x2D, 0x53, 0x69, 0x00, 0x0E, 0x0D, 0x73, 0x2B, 0x09, 0xBE, 0x53, 0x62,
/* 12B0 */ 0x2B, 0x5D, 0x0A, 0x5A, 0x7B, 0x10, 0x08, 0x41, 0x0A, 0x78, 0x90, 0x0F, 0x52, 0x22, 0x51, 0x2E,
/* 12C0 */ 0x1D, 0x4A, 0x88, 0x52, 0x45, 0x0F, 0x30, 0x32, 0x67, 0xA4, 0x5B, 0x6C, 0x43, 0x78, 0x1B, 0x67,
/* 12D0 */ 0x91, 0x0E, 0x91, 0x7A, 0x0F, 0x52, 0x09, 0x78, 0x1D, 0x67, 0x62, 0x00, 0x03, 0xA4, 0x10, 0x08,
/* 12E0 */ 0x41, 0xBC, 0x3A, 0xAA, 0x10, 0x07, 0x41, 0x08, 0x47, 0xA4, 0x54, 0x79, 0x69, 0xA4, 0x32, 0x53,
/* 12F0 */ 0x75, 0x5B, 0x7A, 0x31, 0x45, 0x0E, 0x62, 0x32, 0x4A, 0x52, 0x44, 0x96, 0x05, 0x3E, 0x0C, 0x9A,
/* 1300 */ 0x80, 0xA2, 0x54, 0x0C, 0x55, 0x6A, 0x10, 0x05, 0x7C, 0x89, 0x20, 0x32, 0x53, 0x6A, 0x3E, 0x0E,
/* 1310 */ 0x91, 0x40, 0x1C, 0xDD, 0x92, 0x9F, 0x32, 0x67, 0x62, 0x40, 0x0C, 0x93, 0x40, 0x76, 0x04, 0x40,
/* 1320 */ 0x1C, 0xDD, 0x40, 0x0E, 0x91, 0xDA, 0x6A, 0x3E, 0x89, 0x20, 0x10, 0x05, 0x4B, 0xD1, 0x73, 0x40,
/* 1330 */ 0xD1, 0x73, 0x40, 0x81, 0x40, 0x81, 0x40, 0x81, 0x10, 0x05, 0x2B, 0x33, 0xE6, 0x0D, 0x09, 0x3E,
/* 1340 */ 0x4A, 0x7B, 0xDA, 0x09, 0xE6, 0x62, 0xE6, 0x62, 0xE6, 0x62, 0x6F, 0x0C, 0x40, 0x38, 0x2E, 0xDC,
/* 1350 */ 0x3A, 0x19, 0x09, 0x93, 0xE6, 0x62, 0xE6, 0x62, 0xE6, 0x62, 0xDA, 0x09, 0x3E, 0x0A, 0xA4, 0x3E,
/* 1360 */ 0x0A, 0x0D, 0x09, 0x10, 0x08, 0x85, 0x90, 0x0C, 0xD2, 0x02, 0x07, 0x7A, 0x47, 0x43, 0x63, 0x48,
/* 1370 */ 0xD2, 0x07, 0x0E, 0x57, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1F, 0x00, 0x4C, 0x00, 0x74, 0x00,
/* 1380 */ 0xAA, 0x00, 0xD9, 0x00, 0xE2, 0x01, 0x1D, 0x01, 0x2F, 0x01, 0x81, 0x01, 0xAF, 0x01, 0xDE, 0x01,
/* 1390 */ 0xF0, 0x01, 0xFA, 0x02, 0x37, 0x02, 0x40, 0x02, 0x58, 0x02, 0x6A, 0x02, 0x84, 0x02, 0x9E, 0x02,
/* 13A0 */ 0xAA, 0x02, 0xD2, 0x03, 0x04, 0x03, 0x08, 0x03, 0x19, 0x03, 0x2D, 0x03, 0x58, 0x03, 0x88, 0x03,
/* 13B0 */ 0xAA, 0x03, 0xE3, 0x04, 0x24, 0x04, 0x4B, 0x04, 0x5F, 0x04, 0x67, 0x04, 0x7C, 0x04, 0x90, 0x04,
/* 13C0 */ 0xA8, 0x04, 0xC3, 0x04, 0xFE, 0x05, 0x33, 0x05, 0x41, 0x05, 0x54, 0x05, 0x60, 0x05, 0x77, 0x05,
/* 13D0 */ 0x86, 0x05, 0x97, 0x05, 0xA9, 0x05, 0xBE, 0x06, 0x02, 0x06, 0x1A, 0x06, 0x26, 0x06, 0x37, 0x06,
/* 13E0 */ 0x42, 0x06, 0x59, 0x06, 0x6D, 0x06, 0x90, 0x06, 0xD9, 0x06, 0xED, 0x07, 0x01, 0x07, 0x14, 0x07,
/* 13F0 */ 0x2B, 0x07, 0x3D, 0x07, 0x61, 0x07, 0x9F, 0x07, 0xAE, 0x07, 0xBF, 0x07, 0xD5, 0x07, 0xE9, 0x07,
/* 1400 */ 0xFE, 0x08, 0x17, 0x08, 0x56, 0x08, 0x7D, 0x08, 0x88, 0x08, 0x98, 0x08, 0xA7, 0x08, 0xBA, 0x08,
/* 1410 */ 0xCA, 0x08, 0xDB, 0x08, 0xEE, 0x09, 0x01, 0x09, 0x41, 0x09, 0x57, 0x09, 0x69, 0x09, 0x7B, 0x09,
/* 1420 */ 0x90, 0x09, 0xA3, 0x09, 0xB9, 0x09, 0xCB, 0x0A, 0x01, 0x0A, 0x0D, 0x0A, 0x22, 0x0A, 0x30, 0x0A,
/* 1430 */ 0x45, 0x0A, 0x56, 0x0A, 0x69, 0x03, 0x00, 0x10, 0x04, 0x41, 0x03, 0xA0, 0x6F, 0x59, 0x3E, 0x38,
/* 1440 */ 0x0A, 0x2D, 0x3B, 0x72, 0x78, 0xD9, 0x78, 0x23, 0x48, 0x43, 0x40, 0xE1, 0x23, 0x96, 0xD5, 0x26,
/* 1450 */ 0x44, 0x7A, 0x18, 0x10, 0x07, 0xBF, 0x53, 0x00, 0xDA, 0x23, 0x48, 0x0D, 0x62, 0x21, 0x4E, 0x47,
/* 1460 */ 0x93, 0x54, 0x6D, 0x09, 0x8C, 0x21, 0xED, 0x07, 0x26, 0xB8, 0x26, 0x44, 0x7A, 0x9F, 0x3E, 0x76,
/* 1470 */ 0xD2, 0x05, 0x01, 0x54, 0x7F, 0x47, 0x83, 0x5B, 0x6C, 0x0E, 0x83, 0x02, 0x32, 0x53, 0x00, 0xDA,
/* 1480 */ 0x10, 0x08, 0xBF, 0x51, 0x9B, 0x08, 0x45, 0x1C, 0x9B, 0x91, 0x7A, 0x26, 0x01, 0x25, 0x42, 0x9A,
/* 1490 */ 0x44, 0x6C, 0x1C, 0x78, 0x8D, 0x7A, 0x55, 0x62, 0x00, 0x42, 0x9A, 0x00, 0xB8, 0x43, 0xE6, 0x62,
/* 14A0 */ 0x44, 0x58, 0x78, 0x70, 0x05, 0xFC, 0x47, 0x9F, 0x10, 0x08, 0x4F, 0xFD, 0x06, 0x44, 0x4E, 0x03,
/* 14B0 */ 0xFC, 0x0A, 0x0E, 0x71, 0x83, 0x2B, 0x6E, 0x0D, 0x43, 0x1C, 0x52, 0x54, 0x0E, 0x52, 0x01, 0x0D,
/* 14C0 */ 0x97, 0x2B, 0x46, 0x93, 0x5B, 0x0A, 0x59, 0x54, 0x0E, 0x52, 0x01, 0x0D, 0x97, 0x2B, 0x6E, 0x0D,
/* 14D0 */ 0x43, 0x1C, 0x52, 0xFC, 0x0A, 0x9B, 0x0A, 0x83, 0x2B, 0x46, 0x06, 0x44, 0xF9, 0x02, 0x10, 0x08,
/* 14E0 */ 0x9D, 0x0D, 0x62, 0x00, 0x2A, 0x9F, 0x2D, 0xF9, 0x0F, 0x52, 0x4A, 0x0A, 0x1D, 0x67, 0x91, 0x01,
/* 14F0 */ 0x18, 0x6C, 0x0F, 0x8D, 0x62, 0x5F, 0x0C, 0x29, 0x34, 0x3C, 0x31, 0x48, 0x05, 0x30, 0xA1, 0x54,
/* 1500 */ 0x0C, 0x3A, 0x43, 0x57, 0x54, 0x1C, 0x55, 0x04, 0x5F, 0xA4, 0x00, 0x68, 0xA4, 0x10, 0x05, 0x4B,
/* 1510 */ 0xD1, 0x73, 0x44, 0x28, 0xD1, 0x73, 0x10, 0x08, 0x7E, 0xA9, 0x9B, 0x8B, 0x5B, 0xFC, 0x43, 0x73,
/* 1520 */ 0x54, 0x67, 0x7B, 0x46, 0x34, 0x0C, 0x73, 0x04, 0x44, 0x6C, 0x47, 0x57, 0x1D, 0x6E, 0x0D, 0x20,
/* 1530 */ 0x3A, 0x52, 0x48, 0x43, 0x5B, 0x0E, 0x59, 0xA7, 0x0C, 0x06, 0x0F, 0x52, 0x54, 0x51, 0x0F, 0xA4,
/* 1540 */ 0x3E, 0x9C, 0x73, 0x5B, 0x48, 0x03, 0xA9, 0x78, 0x1B, 0x3C, 0x7B, 0x5B, 0x48, 0x0A, 0x0C, 0x0B,
/* 1550 */ 0x06, 0x10, 0x07, 0x2B, 0x3B, 0x89, 0x07, 0x7F, 0x8E, 0x42, 0x43, 0x76, 0x05, 0x98, 0x71, 0x00,
/* 1560 */ 0x0B, 0x0D, 0x02, 0x10, 0x0C, 0x00, 0x28, 0x6C, 0x0C, 0x9B, 0x0A, 0x03, 0x00, 0xFC, 0x43, 0x1C,
/* 1570 */ 0xA8, 0x2D, 0xF9, 0x93, 0x07, 0x0C, 0x0B, 0x79, 0x52, 0x2D, 0x0C, 0x0C, 0x03, 0x9A, 0x62, 0x03,
/* 1580 */ 0x91, 0x2D, 0x7B, 0x08, 0x6A, 0x01, 0x01, 0x00, 0x0C, 0x0A, 0x65, 0x6E, 0x6A, 0x0A, 0x97, 0x44,
/* 1590 */ 0x0A, 0x0B, 0x2D, 0x91, 0x09, 0x59, 0x6E, 0x00, 0x0C, 0x0A, 0x2D, 0x0C, 0x0C, 0x8F, 0x71, 0x03,
/* 15A0 */ 0x91, 0x23, 0xF9, 0x83, 0x09, 0x0E, 0x0D, 0x08, 0x0D, 0x52, 0x2B, 0x09, 0x9A, 0x9B, 0x9A, 0x04,
/* 15B0 */ 0x6C, 0x0C, 0x9B, 0x0A, 0x03, 0x10, 0x07, 0x84, 0x06, 0x61, 0x0B, 0x34, 0x53, 0x0F, 0x43, 0x00,
/* 15C0 */ 0x45, 0x01, 0x76, 0x21, 0xF9, 0x3A, 0x9F, 0x1D, 0x46, 0x43, 0x6D, 0x03, 0x6C, 0x78, 0x02, 0x9F,
/* 15D0 */ 0x00, 0x22, 0x43, 0x7B, 0x1B, 0x35, 0x0A, 0x02, 0x09, 0x03, 0x65, 0x33, 0x48, 0x80, 0x70, 0x09,
/* 15E0 */ 0x6C, 0x55, 0x93, 0x10, 0x09, 0x5B, 0x41, 0x9E, 0x02, 0x00, 0x9E, 0x21, 0x0B, 0x62, 0x53, 0x0A,
/* 15F0 */ 0x2B, 0x7F, 0x43, 0xA9, 0x18, 0x2B, 0xE1, 0x07, 0x04, 0x30, 0x5B, 0x2C, 0x9A, 0x8C, 0x18, 0x1D,
/* 1600 */ 0xE1, 0x60, 0x0F, 0x62, 0x42, 0x18, 0x06, 0x9F, 0x54, 0x0A, 0x62, 0x4A, 0x0A, 0x1D, 0x6E, 0x87,
/* 1610 */ 0x6E, 0x87, 0x10, 0x08, 0x1D, 0x85, 0x48, 0x80, 0x70, 0x75, 0x96, 0x55, 0x24, 0x1C, 0x24, 0x1C,
/* 1620 */ 0x64, 0x90, 0x07, 0x01, 0x10, 0x06, 0x1D, 0x85, 0x48, 0x70, 0x57, 0x5B, 0x96, 0x3D, 0x10, 0x09,
/* 1630 */ 0x28, 0x6C, 0x0C, 0x0E, 0x8D, 0x1B, 0x79, 0xA1, 0x9C, 0x09, 0x2B, 0x6E, 0x74, 0x0E, 0x93, 0x02,
/* 1640 */ 0x59, 0x2D, 0xF9, 0x0D, 0x00, 0x74, 0x74, 0x0B, 0x07, 0x2B, 0x35, 0x00, 0x0E, 0x93, 0x00, 0x09,
/* 1650 */ 0x08, 0x2D, 0xF9, 0x0D, 0x00, 0x0E, 0x07, 0x0C, 0x00, 0x0B, 0x07, 0x2D, 0x6E, 0x74, 0x0B, 0x82,
/* 1660 */ 0x05, 0x59, 0x1D, 0x79, 0xA1, 0x9C, 0x09, 0x1B, 0x35, 0x0F, 0x8D, 0x10, 0x05, 0x5B, 0x7C, 0xD5,
/* 1670 */ 0x0D, 0x70, 0xDB, 0x55, 0x10, 0x07, 0x84, 0x04, 0x61, 0xEF, 0x46, 0x1C, 0x3D, 0x7A, 0x91, 0x02,
/* 1680 */ 0x83, 0x00, 0x7A, 0x6A, 0x01, 0x83, 0x45, 0xE2, 0xEF, 0xF9, 0x69, 0x08, 0x10, 0x08, 0x00, 0x7D,
/* 1690 */ 0xFD, 0xBA, 0x0D, 0x72, 0x78, 0x72, 0x78, 0x4F, 0xDC, 0x70, 0x70, 0x54, 0xE1, 0x55, 0x10, 0x06,
/* 16A0 */ 0x84, 0x77, 0xA2, 0x44, 0x48, 0x43, 0x26, 0xDC, 0x00, 0x0C, 0x97, 0x65, 0x48, 0x7B, 0x44, 0x6C,
/* 16B0 */ 0x0E, 0x07, 0x65, 0x22, 0x80, 0x34, 0x04, 0xE8, 0x10, 0x06, 0x4B, 0x35, 0x94, 0x32, 0xE1, 0x43,
/* 16C0 */ 0x3E, 0xA1, 0x88, 0x64, 0x0C, 0x62, 0x40, 0x1C, 0x8E, 0xE6, 0xF2, 0x98, 0x0B, 0x79, 0x59, 0x45,
/* 16D0 */ 0x88, 0xA2, 0x10, 0x05, 0x1F, 0x07, 0x63, 0x32, 0x38, 0x43, 0xEF, 0x46, 0x8D, 0x01, 0x10, 0x08,
/* 16E0 */ 0x41, 0x03, 0xE5, 0xBC, 0x2D, 0x03, 0xE5, 0xBC, 0x2D, 0x03, 0xA4, 0x03, 0x30, 0x22, 0x47, 0x62,
/* 16F0 */ 0x1D, 0x03, 0x0F, 0x69, 0x0A, 0x09, 0x93, 0x1D, 0x03, 0x43, 0x00, 0x6E, 0x01, 0x98, 0x18, 0x00,
/* 1700 */ 0xDC, 0x18, 0x3E, 0x8C, 0x05, 0x01, 0x10, 0x0C, 0xBF, 0x35, 0x3C, 0x43, 0x2D, 0x7F, 0x47, 0x43,
/* 1710 */ 0x0D, 0x43, 0x2B, 0x0E, 0x55, 0x60, 0x43, 0xCF, 0x47, 0x60, 0x43, 0x2B, 0x0F, 0x55, 0x60, 0x43,
/* 1720 */ 0x2B, 0x0B, 0x55, 0x60, 0x43, 0x2B, 0x38, 0x47, 0x60, 0x43, 0x98, 0x88, 0xFA, 0xA3, 0xFA, 0xA3,
/* 1730 */ 0xFA, 0xA3, 0xFA, 0x03, 0x03, 0x01, 0x01, 0xA1, 0x10, 0x04, 0x85, 0xC3, 0x10, 0x05, 0x00, 0xBF,
/* 1740 */ 0x85, 0xD5, 0x0B, 0x2D, 0xFC, 0x8E, 0x00, 0x45, 0x69, 0x6A, 0xDC, 0x69, 0x8E, 0x10, 0x06, 0x84,
/* 1750 */ 0x9C, 0x91, 0x32, 0xE1, 0x91, 0x32, 0x7F, 0x07, 0x91, 0xD5, 0x91, 0xD5, 0x91, 0xD5, 0x91, 0xD5,
/* 1760 */ 0x91, 0x10, 0x07, 0x84, 0x82, 0x0C, 0x0A, 0x03, 0x32, 0x0C, 0xE8, 0x00, 0x48, 0x43, 0x82, 0x62,
/* 1770 */ 0x7A, 0x73, 0x90, 0x93, 0x7A, 0x73, 0x90, 0x93, 0x00, 0x48, 0x43, 0x9E, 0x2E, 0x54, 0x0C, 0xE8,
/* 1780 */ 0x5F, 0x09, 0x0C, 0x94, 0x33, 0xD5, 0x80, 0x70, 0x0A, 0x42, 0x55, 0x93, 0x10, 0x09, 0x41, 0x7F,
/* 1790 */ 0x05, 0x00, 0x90, 0x06, 0x98, 0x0F, 0x74, 0x03, 0x9F, 0x1D, 0x4A, 0x75, 0xA3, 0x75, 0xA7, 0x0A,
/* 17A0 */ 0x02, 0x0E, 0x83, 0x54, 0x0B, 0x73, 0x4A, 0x0D, 0x22, 0x09, 0xA5, 0x09, 0x1D, 0x0B, 0x73, 0x53,
/* 17B0 */ 0x86, 0x2D, 0x2A, 0x0F, 0x63, 0x03, 0x0F, 0x63, 0x7A, 0x25, 0x4E, 0x05, 0x10, 0x0E, 0x1D, 0x84,
/* 17C0 */ 0x8D, 0xD3, 0x07, 0x90, 0x05, 0x23, 0x4E, 0x91, 0x00, 0x0B, 0x52, 0x02, 0x83, 0x23, 0x4E, 0x91,
/* 17D0 */ 0x03, 0x62, 0x7F, 0x59, 0x00, 0xFC, 0x02, 0xE7, 0x1C, 0xEC, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x0E,
/* 17E0 */ 0x1D, 0x84, 0x8D, 0xD3, 0x07, 0x04, 0x69, 0xA6, 0x44, 0x4E, 0x91, 0x00, 0x0B, 0x52, 0x0E, 0x1C,
/* 17F0 */ 0x7B, 0x44, 0x4E, 0x91, 0x03, 0x62, 0x46, 0x8C, 0x91, 0x2D, 0x5A, 0x02, 0x00, 0x6E, 0x0C, 0x0C,
/* 1800 */ 0x2D, 0x46, 0x83, 0x5B, 0x38, 0x8E, 0x2D, 0x7F, 0x59, 0x5B, 0x3A, 0x80, 0x08, 0x65, 0x6E, 0xA0,
/* 1810 */ 0x44, 0x3A, 0x30, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x0E, 0x1D, 0x84, 0x8D, 0x23, 0x7F, 0x9B, 0x07,
/* 1820 */ 0x5B, 0x4E, 0x6A, 0x23, 0x03, 0x80, 0x26, 0x5B, 0x80, 0x2B, 0x67, 0x2E, 0xF9, 0x91, 0x1D, 0x3A,
/* 1830 */ 0x86, 0x00, 0x0C, 0x52, 0x00, 0xFC, 0x04, 0x04, 0x7B, 0x90, 0x05, 0x65, 0xA9, 0x9C, 0x59, 0x0B,
/* 1840 */ 0x52, 0x02, 0x83, 0x44, 0x2A, 0x1C, 0x83, 0x03, 0x62, 0x7F, 0x59, 0x65, 0x6E, 0x04, 0x03, 0x5A,
/* 1850 */ 0x02, 0xE7, 0x1C, 0xEC, 0x65, 0xF9, 0xF2, 0xD9, 0x10, 0x07, 0x2F, 0xBF, 0xD9, 0x0D, 0x86, 0xB8,
/* 1860 */ 0x31, 0x32, 0x38, 0x0A, 0x2F, 0x5F, 0x05, 0x05, 0x40, 0xE1, 0xDA, 0x0D, 0x3E, 0x0A, 0xA4, 0xDB,
/* 1870 */ 0x30, 0x3E, 0x0B, 0x78, 0xDA, 0x52, 0x51, 0x02, 0x7A, 0x55, 0x62, 0x00, 0x42, 0x3A, 0x8D, 0x10,
/* 1880 */ 0x09, 0x54, 0x68, 0x00, 0xD9, 0x20, 0x00, 0xB8, 0x0F, 0x93, 0x02, 0x92, 0x08, 0x86, 0x2F, 0x96,
/* 1890 */ 0x97, 0xAB, 0xB7, 0x10, 0x09, 0xF3, 0x5B, 0x8F, 0x97, 0xAB, 0xB7, 0x10, 0x09, 0x1D, 0x68, 0x0C,
/* 18A0 */ 0x2E, 0x5F, 0x0C, 0x29, 0x08, 0x1B, 0x6B, 0x05, 0x7F, 0x0C, 0x3B, 0xF9, 0x0F, 0x26, 0xAB, 0xB7,
/* 18B0 */ 0x10, 0x09, 0x2D, 0xD5, 0x8B, 0x03, 0xEF, 0xA5, 0x43, 0x0D, 0x1B, 0x89, 0x82, 0xA8, 0x3B, 0xF9,
/* 18C0 */ 0x0F, 0x26, 0xAB, 0xB7, 0x10, 0x09, 0x00, 0x7D, 0x38, 0x06, 0x00, 0x09, 0xA6, 0x58, 0x0D, 0x02,
/* 18D0 */ 0x31, 0x48, 0x0E, 0x08, 0x00, 0x0B, 0x75, 0x3B, 0x8F, 0x97, 0xAB, 0xB7, 0x10, 0x09, 0x5B, 0x6E,
/* 18E0 */ 0x09, 0x0C, 0x07, 0xB8, 0x0F, 0x9F, 0x32, 0x0A, 0x0C, 0x02, 0x0F, 0xEF, 0x7F, 0x29, 0x04, 0x68,
/* 18F0 */ 0x0B, 0x71, 0x66, 0x96, 0x97, 0xAB, 0xB7, 0x10, 0x0C, 0xBF, 0x5A, 0x55, 0x31, 0x2D, 0x3C, 0x0E,
/* 1900 */ 0x70, 0x02, 0x23, 0xF9, 0x43, 0x3A, 0xEF, 0x0A, 0x62, 0x0B, 0x62, 0x54, 0x76, 0x05, 0x09, 0x43,
/* 1910 */ 0x80, 0x99, 0x23, 0x5D, 0x8C, 0x47, 0x9F, 0x23, 0x0B, 0x73, 0x2A, 0x18, 0x3F, 0x47, 0x31, 0x2C,
/* 1920 */ 0x9A, 0x70, 0xA4, 0x2B, 0x0C, 0x78, 0x5B, 0x67, 0x43, 0x80, 0x0B, 0x44, 0x03, 0x30, 0x44, 0x0A,
/* 1930 */ 0x47, 0x78, 0x10, 0x08, 0xBF, 0x82, 0x9B, 0x94, 0x98, 0x0E, 0xE2, 0x75, 0x2B, 0x53, 0x75, 0xF9,
/* 1940 */ 0x03, 0xA7, 0x19, 0x5D, 0x04, 0xB8, 0x9F, 0xB8, 0x9F, 0xB8, 0x31, 0x44, 0x48, 0x30, 0x40, 0x1C,
/* 1950 */ 0xA8, 0x8C, 0x06, 0x42, 0x9A, 0xE8, 0x58, 0x9A, 0x20, 0x32, 0x6B, 0x0B, 0x24, 0x0E, 0x93, 0x44,
/* 1960 */ 0x6C, 0x0D, 0x26, 0x5B, 0x7A, 0x9B, 0x07, 0x10, 0x08, 0x33, 0x2C, 0x0C, 0xEE, 0x40, 0x72, 0xC4,
/* 1970 */ 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x5B, 0x66, 0x24, 0x9C, 0x08, 0xD0, 0x09, 0x09, 0x25,
/* 1980 */ 0x40, 0x72, 0xC4, 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x2F, 0xF7, 0x27, 0x46, 0xC4, 0x54,
/* 1990 */ 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x08, 0x00, 0x7D, 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x07,
/* 19A0 */ 0xD6, 0x03, 0x71, 0x33, 0x92, 0xC4, 0x54, 0xB0, 0x02, 0xA7, 0xE8, 0x10, 0x04, 0x66, 0xD5, 0x57,
/* 19B0 */ 0x3E, 0x4A, 0x83, 0xD9, 0x09, 0x0B, 0x66, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x66, 0x24, 0x89, 0x0A,
/* 19C0 */ 0xB8, 0x9A, 0x75, 0x1B, 0x7F, 0x0A, 0x25, 0x66, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x65, 0x72, 0x0E,
/* 19D0 */ 0x6A, 0x32, 0x6B, 0x43, 0x6A, 0x1B, 0xCB, 0x09, 0x2D, 0x33, 0xA7, 0xD8, 0xE0, 0x10, 0x04, 0x4F,
/* 19E0 */ 0x51, 0xA1, 0x0B, 0x08, 0x1B, 0x0B, 0x83, 0x05, 0x26, 0x7A, 0x50, 0x6B, 0x0B, 0x2D, 0x33, 0xA7,
/* 19F0 */ 0xD8, 0xE0, 0x10, 0x0A, 0x7E, 0x3A, 0x43, 0x0D, 0x09, 0x21, 0x0D, 0x43, 0x0D, 0x9A, 0x74, 0x2B,
/* 1A00 */ 0x67, 0x93, 0x46, 0x0E, 0x93, 0x2B, 0x67, 0x93, 0x5B, 0x09, 0x26, 0x23, 0x4A, 0x43, 0x0D, 0x05,
/* 1A10 */ 0x06, 0x9F, 0x2D, 0x0C, 0x9A, 0xA4, 0x5D, 0x04, 0x2D, 0x67, 0x93, 0x00, 0x4E, 0x9F, 0x2D, 0x67,
/* 1A20 */ 0x93, 0x5B, 0x09, 0x26, 0x2D, 0x67, 0x93, 0x00, 0xF7, 0x0B, 0x2B, 0x67, 0x43, 0x0D, 0x9A, 0x74,
/* 1A30 */ 0x2B, 0x67, 0x9A, 0x78, 0x09, 0x02, 0x10, 0x0A, 0x1D, 0x68, 0x0B, 0x0A, 0xA9, 0x21, 0x4A, 0x29,
/* 1A40 */ 0xEF, 0x07, 0x07, 0x05, 0x0E, 0x0A, 0x33, 0x92, 0x47, 0xB2, 0x95, 0xC2, 0x4A, 0x93, 0x10, 0x0A,
/* 1A50 */ 0x56, 0xDB, 0x0C, 0xEE, 0x37, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x44, 0x66, 0x24, 0x9C,
/* 1A60 */ 0x08, 0xD0, 0x09, 0x09, 0x25, 0x37, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x66, 0xF7, 0x27,
/* 1A70 */ 0x5B, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x66, 0x09, 0x0B, 0x02, 0x06, 0x34, 0x07, 0xE2,
/* 1A80 */ 0x09, 0x00, 0x6C, 0x09, 0x03, 0x0D, 0x86, 0x3B, 0xF8, 0xB5, 0x39, 0x43, 0xD7, 0x10, 0x0A, 0x2F,
/* 1A90 */ 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x06, 0xD6, 0x03, 0x71, 0x3B, 0xF8, 0xB5, 0x39, 0x43,
/* 1AA0 */ 0xD7, 0x10, 0x08, 0x7D, 0x41, 0x09, 0x09, 0x46, 0x99, 0x1D, 0x6E, 0x3A, 0x08, 0x0D, 0x7B, 0x1B,
/* 1AB0 */ 0xF7, 0x62, 0x68, 0x3A, 0x7B, 0x32, 0x0B, 0x93, 0x0E, 0x6A, 0x1D, 0x6E, 0x0C, 0x0C, 0x2A, 0x91,
/* 1AC0 */ 0x5F, 0x01, 0x00, 0x46, 0x10, 0x0A, 0x23, 0x4B, 0x0B, 0x08, 0xD9, 0x78, 0x5B, 0x48, 0x0B, 0x1C,
/* 1AD0 */ 0x62, 0x00, 0x96, 0x9B, 0xA4, 0x1D, 0x0E, 0x93, 0x00, 0x0B, 0x1C, 0x52, 0x2D, 0xE1, 0xA1, 0x91,
/* 1AE0 */ 0x0F, 0x6A, 0x2C, 0x18, 0x05, 0x52, 0x30, 0x2C, 0x26, 0x09, 0x0A, 0x00, 0x0F, 0x62, 0x2C, 0x18,
/* 1AF0 */ 0xA2, 0x01, 0x30, 0x23, 0x2A, 0xA4, 0x0F, 0x02, 0x03, 0x3D, 0x2D, 0x0E, 0x43, 0x0D, 0x5A, 0x52,
/* 1B00 */ 0x2B, 0x8F, 0x9B, 0xA4, 0x58, 0x43, 0x8B, 0x54, 0x53, 0x04, 0x3E, 0x7F, 0x86, 0x10, 0x09, 0x66,
/* 1B10 */ 0x64, 0x44, 0x0C, 0x09, 0x64, 0xF7, 0x50, 0x00, 0x68, 0x05, 0x0B, 0x05, 0x56, 0x49, 0x4D, 0xB6,
/* 1B20 */ 0xC8, 0x10, 0x09, 0x32, 0x68, 0x00, 0xD5, 0x74, 0x32, 0x38, 0x0F, 0x7B, 0x68, 0x0C, 0x08, 0x21,
/* 1B30 */ 0x7D, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x09, 0x2B, 0x6F, 0x75, 0xDB, 0x29, 0x86, 0x1B, 0x0B, 0xD2,
/* 1B40 */ 0x05, 0x99, 0x32, 0x33, 0x49, 0x4D, 0xB6, 0xC8, 0x10, 0x09, 0x2D, 0xE6, 0x0A, 0xF9, 0x0C, 0x03,
/* 1B50 */ 0x00, 0x22, 0x9C, 0x62, 0x1B, 0x0C, 0x86, 0x07, 0x50, 0x32, 0x33, 0x49, 0x4D, 0xB6, 0xC8, 0x10,
/* 1B60 */ 0x09, 0xF3, 0x0D, 0x73, 0x5B, 0x6D, 0x09, 0x00, 0x2C, 0xCE, 0x31, 0x45, 0xBE, 0xF1, 0x09, 0xF1,
/* 1B70 */ 0x09, 0x10, 0x09, 0x9D, 0xA5, 0x1E, 0x5E, 0x0A, 0x05, 0x00, 0xA7, 0x47, 0x83, 0xA7, 0x07, 0x9E,
/* 1B80 */ 0x9F, 0xF4, 0x03, 0xA4, 0xF4, 0x03, 0xA4, 0xF4, 0x08, 0x31, 0xCF, 0x0E, 0x1C, 0x93, 0xA7, 0x9A,
/* 1B90 */ 0x8D, 0x01, 0xA7, 0x1E, 0x07, 0x10, 0x09, 0x28, 0x7A, 0x61, 0x0A, 0x34, 0x07, 0x47, 0x43, 0x21,
/* 1BA0 */ 0x1C, 0x08, 0xA5, 0x05, 0x2B, 0x46, 0x3D, 0x18, 0x22, 0x04, 0x07, 0x2E, 0x22, 0x05, 0x1C, 0x02,
/* 1BB0 */ 0x00, 0x22, 0x8F, 0x09, 0x00, 0x22, 0x04, 0x08, 0x9A, 0x4C, 0x0A, 0x31, 0x2D, 0x03, 0x31, 0x01,
/* 1BC0 */ 0x30, 0x2B, 0x03, 0x31, 0x6D, 0x08, 0x2B, 0x03, 0x9A, 0x04, 0x77, 0x9F, 0x2B, 0x03, 0x0F, 0x6A,
/* 1BD0 */ 0x0C, 0x0F, 0xA2, 0x10, 0x08, 0x1F, 0x07, 0x57, 0x3E, 0x4A, 0x62, 0xD9, 0x09, 0x0B, 0x37, 0x08,
/* 1BE0 */ 0xB3, 0x99, 0x10, 0x08, 0x00, 0x1F, 0x05, 0x50, 0x68, 0xA3, 0x62, 0x3E, 0x0C, 0x09, 0x02, 0x37,
/* 1BF0 */ 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x4B, 0x2A, 0x0F, 0x74, 0xDC, 0x9B, 0x78, 0x02, 0x1B, 0x09, 0x0C,
/* 1C00 */ 0x02, 0x03, 0x8D, 0x44, 0x68, 0x1B, 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x4B, 0x9E, 0xA6, 0x07, 0x34,
/* 1C10 */ 0x36, 0x43, 0x7B, 0x00, 0x7A, 0x09, 0x04, 0x0D, 0x8E, 0x56, 0x7F, 0xB3, 0x99, 0x10, 0x08, 0x7C,
/* 1C20 */ 0x07, 0x8E, 0x03, 0x8B, 0x1B, 0xA4, 0x09, 0x73, 0x1B, 0x0A, 0x63, 0x04, 0x0E, 0x19, 0x33, 0x7F,
/* 1C30 */ 0xB3, 0x99, 0x10, 0x08, 0x2D, 0x33, 0x51, 0x0B, 0x02, 0x3E, 0x0E, 0xBE, 0x00, 0x45, 0x91, 0x77,
/* 1C40 */ 0x3E, 0x9B, 0x73, 0x44, 0x6C, 0x0E, 0x57, 0x37, 0x08, 0xB3, 0x99, 0x10, 0x0C, 0x41, 0x90, 0x0C,
/* 1C50 */ 0x9B, 0x08, 0x9C, 0x0F, 0xA2, 0x2D, 0x0B, 0x0E, 0x0D, 0x55, 0x3A, 0x6A, 0x65, 0x6E, 0x5B, 0x8F,
/* 1C60 */ 0x07, 0x7F, 0x73, 0x23, 0x03, 0x09, 0x0C, 0x3A, 0x78, 0x69, 0x43, 0x44, 0x46, 0x3C, 0x47, 0x55,
/* 1C70 */ 0x44, 0x7F, 0x9F, 0xA5, 0x05, 0xFC, 0x52, 0xE1, 0x0B, 0x00, 0x4E, 0x23, 0x8F, 0x0E, 0x73, 0x9A,
/* 1C80 */ 0x9B, 0x7B, 0x65, 0x7F, 0x9B, 0xD2, 0x05, 0x0C, 0x43, 0xD2, 0x10, 0x07, 0x66, 0xBF, 0xB8, 0x69,
/* 1C90 */ 0x8B, 0x5B, 0xFC, 0x43, 0x62, 0xE3, 0x97, 0xB8, 0x18, 0x65, 0x96, 0x87, 0xA1, 0x54, 0x67, 0x47,
/* 1CA0 */ 0x2E, 0x98, 0x0E, 0x9A, 0x20, 0x3E, 0x0B, 0x86, 0xDA, 0x75, 0xDC, 0x69, 0x59, 0x44, 0x48, 0x0D,
/* 1CB0 */ 0x71, 0x10, 0x08, 0x1F, 0x03, 0xF0, 0x75, 0x4F, 0x5F, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0x65, 0x7C,
/* 1CC0 */ 0x24, 0x9C, 0x09, 0xD0, 0x09, 0x0A, 0x04, 0x7D, 0x68, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0xD4, 0x7A,
/* 1CD0 */ 0x0E, 0xA1, 0x0B, 0x0A, 0x68, 0x5B, 0x6E, 0x5F, 0x09, 0xAF, 0xC1, 0x10, 0x08, 0x7C, 0xCB, 0x08,
/* 1CE0 */ 0x1B, 0x0B, 0x62, 0x05, 0x26, 0x7A, 0x50, 0x6B, 0x0A, 0x3B, 0x01, 0x09, 0xAF, 0xC1, 0x10, 0x04,
/* 1CF0 */ 0x7C, 0x24, 0xF9, 0x50, 0x6F, 0x0F, 0xA6, 0x92, 0x08, 0x0C, 0x00, 0x37, 0xC0, 0x31, 0x10, 0x04,
/* 1D00 */ 0x7C, 0x6E, 0x64, 0x2A, 0x8D, 0x65, 0xFC, 0x93, 0x3E, 0x0B, 0x09, 0x03, 0x33, 0xC0, 0x31, 0x10,
/* 1D10 */ 0x04, 0x2B, 0x28, 0xF7, 0x25, 0x45, 0x1C, 0x9B, 0x34, 0x07, 0x99, 0x38, 0x09, 0x68, 0x5B, 0x64,
/* 1D20 */ 0xC0, 0x31, 0x10, 0x04, 0x2D, 0x3B, 0x35, 0x03, 0x89, 0x07, 0x1B, 0x3A, 0x08, 0x07, 0xD6, 0x03,
/* 1D30 */ 0x71, 0x00, 0x3B, 0xC0, 0x31, 0x10, 0x09, 0x3B, 0x68, 0x65, 0x48, 0x05, 0x01, 0x0B, 0x0A, 0x32,
/* 1D40 */ 0x0A, 0x9A, 0x62, 0x32, 0x38, 0x9A, 0x86, 0x1B, 0x6B, 0x0B, 0x0D, 0x93, 0xD9, 0x31, 0x1D, 0x89,
/* 1D50 */ 0xA0, 0x0D, 0x62, 0x54, 0x3A, 0x43, 0xBE, 0x96, 0x25, 0x0B, 0x43, 0x5B, 0x2C, 0x9A, 0x00, 0x7F,
/* 1D60 */ 0x43, 0x5B, 0x2C, 0x9A, 0x5B, 0x09, 0x78, 0x48, 0x31, 0x3A, 0x08, 0x54, 0x0C, 0xE2, 0x63, 0x1D,
/* 1D70 */ 0x6E, 0x09, 0x0E, 0xA0, 0x03, 0x10, 0x08, 0x28, 0x42, 0x0C, 0x04, 0x04, 0x05, 0x5B, 0x22, 0xBE,
/* 1D80 */ 0x00, 0x98, 0x0B, 0x89, 0x99, 0x56, 0xE9, 0x4C, 0x3A, 0x4C, 0xFB, 0x10, 0x09, 0x1F, 0x02, 0x0E,
/* 1D90 */ 0x07, 0xD5, 0x0E, 0x73, 0x02, 0x00, 0x68, 0x79, 0x21, 0x2D, 0x68, 0xB4, 0xF6, 0x10, 0x09, 0x65,
/* 1DA0 */ 0x7C, 0x24, 0x89, 0x0A, 0x44, 0x7A, 0x1C, 0x75, 0x1B, 0x7F, 0x94, 0x7D, 0x68, 0xB4, 0xF6, 0x10,
/* 1DB0 */ 0x09, 0x4B, 0x6E, 0x0D, 0x7B, 0x68, 0x0C, 0x43, 0x6A, 0x5B, 0x48, 0x50, 0x9E, 0x0C, 0x68, 0x5B,
/* 1DC0 */ 0x6E, 0x5F, 0xB4, 0xF6, 0x10, 0x09, 0x28, 0x42, 0x0C, 0x04, 0x04, 0x06, 0x5B, 0x22, 0xBE, 0x1B,
/* 1DD0 */ 0x89, 0x89, 0x99, 0x4F, 0x5F, 0xB4, 0xF6, 0x10, 0x09, 0x7C, 0x03, 0x8B, 0x00, 0x0A, 0x09, 0x1B,
/* 1DE0 */ 0x09, 0x93, 0x03, 0x18, 0x6C, 0x20, 0x01, 0x0C, 0x0C, 0x3B, 0x01, 0xB4, 0xF6, 0x10, 0x08, 0xBF,
/* 1DF0 */ 0x9C, 0xE4, 0xA0, 0x3B, 0x2A, 0x80, 0x70, 0x0B, 0x6C, 0x55, 0x78, 0x37, 0x9C, 0xE4, 0xA0, 0x10,
/* 1E00 */ 0x09, 0x44, 0xBF, 0x0B, 0x09, 0x72, 0x73, 0x5F, 0x09, 0x1C, 0x62, 0x54, 0x53, 0x43, 0x31, 0x2B,
/* 1E10 */ 0x03, 0x9F, 0x0B, 0x0D, 0x93, 0x1D, 0x81, 0x01, 0x0F, 0x5D, 0x1D, 0x36, 0x94, 0x99, 0x26, 0x2B,
/* 1E20 */ 0x81, 0x09, 0x09, 0xE1, 0x22, 0xA8, 0x09, 0x73, 0x1D, 0x53, 0x43, 0x31, 0x1D, 0x76, 0x73, 0x25,
/* 1E30 */ 0x98, 0x93, 0xD9, 0x0B, 0x06, 0x10, 0x08, 0x1F, 0x04, 0xF0, 0x86, 0x56, 0xE1, 0x8A, 0xAC, 0xCA,
/* 1E40 */ 0x07, 0x10, 0x08, 0x00, 0x3B, 0x68, 0xD9, 0x0D, 0x08, 0x44, 0x58, 0x93, 0x3E, 0x0A, 0x0A, 0x03,
/* 1E50 */ 0x37, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0xD4, 0x7A, 0x99, 0x38, 0x0A, 0x32, 0x24, 0xE1,
/* 1E60 */ 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0x7C, 0xCB, 0x08, 0x1B, 0x0C, 0x62, 0x5D, 0x00, 0x42, 0xA8,
/* 1E70 */ 0x6B, 0x0A, 0x3E, 0x33, 0xE1, 0x8A, 0xAC, 0xCA, 0x07, 0x10, 0x08, 0x00, 0x1F, 0x06, 0x74, 0x00,
/* 1E80 */ 0x45, 0x88, 0x7B, 0x68, 0x0D, 0x87, 0x37, 0xBC, 0x3A, 0xAA, 0x10, 0x09, 0x2B, 0x28, 0xBB, 0x29,
/* 1E90 */ 0x62, 0xAE, 0xDE, 0x22, 0x08, 0x69, 0x08, 0x54, 0x1A, 0x5C, 0x01, 0x04, 0x03, 0x10, 0x08, 0x7C,
/* 1EA0 */ 0x09, 0x8E, 0x51, 0x04, 0x54, 0x76, 0x04, 0x0A, 0x83, 0x1B, 0x0B, 0x0D, 0x8C, 0x20, 0x3E, 0x33,
/* 1EB0 */ 0xBC, 0x3A, 0xAA, 0x10, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x19, 0x00, 0x0D, 0x08, 0x44, 0x85, 0xE6,
/* 1EC0 */ 0x70, 0x70, 0x0B, 0x1D, 0x0C, 0x0F, 0x55, 0x78, 0x10, 0x08, 0x4F, 0x85, 0x08, 0x80, 0x70, 0x99,
/* 1ED0 */ 0x1D, 0x0A, 0x55, 0x31, 0x10, 0x0C, 0x4F, 0x85, 0x08, 0x70, 0x70, 0x70, 0x99, 0x65, 0x0A, 0x55,
/* 1EE0 */ 0x55, 0x31, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x06, 0xC3, 0x00,
/* 1EF0 */ 0x00, 0x06, 0xC5, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x06, 0xC8, 0x00,
/* 1F00 */ 0x00, 0x07, 0x86, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x13, 0x75, 0x00,
/* 1F10 */ 0x00, 0x14, 0x35, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x1E, 0xB4, 0x00,
/* 1F20 */ 0x00, 0x1E, 0xBC,

637
contrib/mcufont/fonts/FiraSansCondensed-Bold20.mcufont.h Normal file
View file

@ -0,0 +1,637 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 20
* blob size: 9826, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x05, 0x56, 0x00, 0x00, 0x05, 0xCB, 0x00, 0x00, 0x00, 0x9D,
/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x26, 0x22, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x14, 0x00, 0x1A, 0x00, 0x04, 0x00, 0x12, 0x00, 0x02, 0x00, 0x14, 0x00, 0x18, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x32, 0x30, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x32, 0x30, 0x00,
/* dictionary data */
0xC1, 0x82, 0x0E, 0xC1, 0x06, 0xCC, 0xC1, 0xC1, 0xC6, 0xC2, 0x10,
/* 0080 */ 0xCE, 0x81, 0xC2, 0x10, 0xCE, 0x3E, 0x0A, 0xC2, 0x0C, 0x0F, 0xCC, 0x80, 0xC2, 0x82, 0x01, 0xCB,
/* 0090 */ 0x80, 0x0A, 0xCE, 0x81, 0x07, 0x10, 0xCB, 0x05, 0xCE, 0x80, 0xCD, 0xC5, 0x81, 0x0E, 0x10, 0xC9,
/* 00A0 */ 0x81, 0x0D, 0x80, 0xC3, 0x01, 0x81, 0x09, 0x01, 0xC4, 0x01, 0xC5, 0x10, 0xC6, 0x80, 0x11, 0x81,
/* 00B0 */ 0xC6, 0x0B, 0x04, 0xCA, 0xC3, 0x01, 0xCD, 0x80, 0x81, 0xC4, 0x01, 0xC3, 0xC1, 0xCE, 0x85, 0xDE,
/* 00C0 */ 0xC1, 0xCA, 0x0A, 0xCB, 0x87, 0x84, 0xF4, 0xCC, 0xC3, 0x08, 0x80, 0xCB, 0x81, 0xCE, 0xC1, 0x01,
/* 00D0 */ 0xCC, 0x81, 0xC5, 0x0A, 0xC1, 0x82, 0x0C, 0xC2, 0xCB, 0xC5, 0x80, 0xCD, 0xCE, 0xC6, 0x0C, 0xCE,
/* 00E0 */ 0x85, 0x41, 0x1D, 0xC5, 0xCB, 0xC6, 0xCE, 0xC1, 0xCD, 0xC1, 0xCB, 0x0C, 0xC3, 0xC4, 0x01, 0x81,
/* 00F0 */ 0xC7, 0xC8, 0xC1, 0xC9, 0xC1, 0x01, 0xC1, 0xC3, 0xC1, 0xC8, 0x0F, 0xCE, 0x81, 0xC4, 0x10, 0x81,
/* 0100 */ 0xCC, 0x0A, 0x0C, 0x80, 0xC6, 0x02, 0x21, 0x80, 0xC1, 0xC2, 0x10, 0x40, 0x01, 0xCE, 0xC7, 0xCE,
/* 0110 */ 0x82, 0x40, 0x14, 0xD4, 0xCE, 0x81, 0xC4, 0x10, 0xCE, 0x81, 0xC4, 0x10, 0xCE, 0x81, 0xC4, 0x0F,
/* 0120 */ 0x80, 0xCE, 0xC1, 0xC7, 0xC4, 0x81, 0xCD, 0xC1, 0x82, 0xC1, 0x02, 0xC5, 0x81, 0xCD, 0x09, 0xC1,
/* 0130 */ 0x82, 0xC1, 0x02, 0xC2, 0x0A, 0xC6, 0x01, 0x03, 0x19, 0x02, 0xC2, 0xC2, 0x81, 0x81, 0xCD, 0x0B,
/* 0140 */ 0xCD, 0x81, 0x82, 0xE4, 0xCA, 0x81, 0xC6, 0x80, 0xCC, 0xC5, 0x0A, 0xC3, 0x81, 0xCE, 0x81, 0xC7,
/* 0150 */ 0x80, 0xC4, 0xCB, 0xC1, 0x80, 0xC5, 0x81, 0xCA, 0x0A, 0x0A, 0xC9, 0x85, 0xCE, 0x81, 0x02, 0xC8,
/* 0160 */ 0x81, 0xCB, 0x08, 0xC5, 0x82, 0x04, 0xC6, 0x81, 0xCE, 0x08, 0xC6, 0x81, 0xCE, 0xCE, 0x01, 0xCE,
/* 0170 */ 0xC3, 0x01, 0xCA, 0xC1, 0xCE, 0x81, 0xC1, 0x81, 0xCB, 0x01, 0xCD, 0xC3, 0x80, 0xCC, 0x0C, 0xC5,
/* 0180 */ 0xCD, 0x87, 0xC5, 0x81, 0xCE, 0x10, 0xC5, 0x81, 0xCD, 0xC3, 0xCB, 0xC2, 0xCB, 0x2C, 0xC7, 0x81,
/* 0190 */ 0x82, 0xC1, 0xC4, 0x81, 0xC7, 0xCE, 0xC1, 0xC2, 0x81, 0xC9, 0x80, 0xCA, 0x80, 0xC8, 0x01, 0xC6,
/* 01A0 */ 0x80, 0xC3, 0xCA, 0x81, 0xC8, 0xC2, 0x01, 0x40, 0x03, 0xC9, 0xCD, 0x80, 0xC7, 0xCE, 0xCD, 0xCE,
/* 01B0 */ 0xC8, 0xC4, 0xCA, 0xCE, 0xC1, 0xC1, 0x81, 0x81, 0xC5, 0x01, 0x01, 0xC1, 0xCB, 0xCE, 0xD3, 0xC5,
/* 01C0 */ 0xCA, 0x83, 0x1A, 0x40, 0x3B, 0x41, 0x37, 0xC1, 0xC9, 0xC4, 0xC2, 0x22, 0xCC, 0xC7, 0xCD, 0xC1,
/* 01D0 */ 0x12, 0xCD, 0xC7, 0x40, 0x18, 0xCE, 0x80, 0x04, 0x73, 0x00, 0x66, 0x00, 0x66, 0x00, 0x0E, 0x3B,
/* 01E0 */ 0x59, 0x66, 0x2B, 0xB3, 0xA7, 0x0D, 0x3E, 0x77, 0x2E, 0x0A, 0x41, 0x7A, 0x52, 0x08, 0x05, 0x04,
/* 01F0 */ 0x2D, 0x0A, 0x5D, 0x48, 0x03, 0x76, 0x4A, 0x52, 0x0C, 0x73, 0x71, 0x01, 0x0E, 0xA8, 0x71, 0x8F,
/* 0200 */ 0x0C, 0x02, 0x02, 0x71, 0x08, 0x54, 0x00, 0x03, 0x71, 0x06, 0x30, 0x0C, 0x4E, 0x46, 0x6B, 0x01,
/* 0210 */ 0x0E, 0xA8, 0x22, 0x7A, 0x37, 0x03, 0x0C, 0x9E, 0x6C, 0x9C, 0xAE, 0x8B, 0x44, 0xA4, 0x90, 0x5D,
/* 0220 */ 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x6A, 0x8B, 0x31, 0x18, 0x9A, 0x97, 0x4A, 0x25,
/* 0230 */ 0x04, 0x5D, 0x08, 0x85, 0x31, 0x75, 0xB2, 0x08, 0x0F, 0x36, 0x44, 0x6F, 0x3D, 0x0B, 0x48, 0x9C,
/* 0240 */ 0x67, 0x0C, 0x06, 0x37, 0x8E, 0x22, 0x2F, 0x2C, 0x07, 0x54, 0x2C, 0x07, 0x54, 0x2C, 0x07, 0x54,
/* 0250 */ 0x2C, 0x07, 0xA3, 0x00, 0x22, 0x2F, 0x31, 0x07, 0x99, 0x5D, 0x46, 0x37, 0x03, 0x85, 0x03, 0x7D,
/* 0260 */ 0x5D, 0x29, 0x97, 0x7C, 0x5B, 0x75, 0xAC, 0x0F, 0x5F, 0x37, 0x97, 0x7A, 0x22, 0x0C, 0x00, 0x52,
/* 0270 */ 0x54, 0x99, 0x2B, 0xB4, 0x22, 0x7A, 0x2B, 0x75, 0x67, 0x21, 0x06, 0x30, 0x95, 0x34, 0x7C, 0x19,
/* 0280 */ 0x76, 0x4A, 0x38, 0x78, 0x67, 0x03, 0x2B, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x01, 0x00, 0x22,
/* 0290 */ 0x7C, 0x37, 0x79, 0x08, 0x30, 0x7C, 0x37, 0x0A, 0xA8, 0x72, 0x05, 0x1F, 0xA4, 0xA5, 0xB2, 0x76,
/* 02A0 */ 0x7C, 0xA9, 0x85, 0x5D, 0x22, 0x7C, 0x31, 0x18, 0x9A, 0x03, 0x71, 0x09, 0x54, 0x00, 0x08, 0x36,
/* 02B0 */ 0x37, 0x70, 0x0C, 0x3A, 0xA1, 0x5B, 0x0A, 0x54, 0x99, 0x2E, 0x91, 0x90, 0x2B, 0x22, 0x94, 0x2B,
/* 02C0 */ 0x33, 0x73, 0x02, 0x6D, 0x52, 0x73, 0x38, 0x52, 0x73, 0x4E, 0x29, 0x25, 0x4A, 0x5D, 0x29, 0x1F,
/* 02D0 */ 0xB4, 0x7F, 0x9A, 0x29, 0x1F, 0x0E, 0x45, 0x54, 0x00, 0x29, 0x1F, 0x0E, 0x45, 0x22, 0x0C, 0x00,
/* 02E0 */ 0x29, 0x1F, 0xB4, 0x0C, 0x8F, 0x50, 0x4A, 0x1F, 0x29, 0x02, 0x36, 0x0D, 0x4A, 0x1F, 0xB4, 0x81,
/* 02F0 */ 0x0D, 0x45, 0x0C, 0x4A, 0x1F, 0x0E, 0x67, 0xB4, 0x0C, 0x8D, 0x9E, 0x05, 0x5B, 0xB4, 0x3E, 0xA8,
/* 0300 */ 0x9A, 0x25, 0x0D, 0x05, 0x0C, 0x36, 0x37, 0x73, 0x02, 0x31, 0x08, 0x99, 0x6D, 0x0B, 0x36, 0x31,
/* 0310 */ 0x22, 0x7C, 0x00, 0x69, 0x1F, 0x2A, 0x0C, 0x6F, 0x90, 0x31, 0x06, 0x30, 0x0C, 0x5D, 0x18, 0x02,
/* 0320 */ 0x31, 0x2A, 0x0C, 0x6F, 0x90, 0x31, 0x03, 0x90, 0x33, 0x71, 0x22, 0x95, 0x88, 0x54, 0x37, 0x03,
/* 0330 */ 0x0E, 0x41, 0x1B, 0x5B, 0x98, 0x29, 0x55, 0x35, 0xB3, 0xB4, 0x0C, 0x6C, 0x52, 0x63, 0x99, 0x5B,
/* 0340 */ 0x0C, 0x54, 0x05, 0x72, 0x6B, 0x02, 0x85, 0x97, 0x9D, 0x1F, 0x2A, 0xA8, 0x94, 0x31, 0x97, 0x41,
/* 0350 */ 0x7D, 0x2A, 0x0C, 0x42, 0xAD, 0x78, 0x0E, 0x35, 0x22, 0x95, 0x05, 0x06, 0x0C, 0x08, 0x26, 0x0D,
/* 0360 */ 0x4E, 0x5A, 0x00, 0xB4, 0x2F, 0x02, 0x90, 0x25, 0x02, 0x5D, 0x73, 0x03, 0x25, 0x02, 0x5D, 0x7F,
/* 0370 */ 0x03, 0x25, 0x02, 0x5D, 0x73, 0x02, 0x25, 0x9A, 0x03, 0x7F, 0x1D, 0x30, 0x03, 0x73, 0x38, 0x52,
/* 0380 */ 0x73, 0x38, 0x52, 0x73, 0x5D, 0x0D, 0x96, 0x08, 0x0F, 0x56, 0x26, 0x0A, 0x9D, 0x00, 0x02, 0x41,
/* 0390 */ 0x7C, 0x28, 0x6F, 0x0F, 0xA1, 0x00, 0x02, 0x41, 0x7C, 0x26, 0x09, 0x96, 0x1A, 0x09, 0x9D, 0x26,
/* 03A0 */ 0xA2, 0x02, 0x1A, 0x09, 0x9D, 0x26, 0x08, 0x95, 0x35, 0x09, 0x54, 0x00, 0x25, 0x9A, 0x09, 0x99,
/* 03B0 */ 0x31, 0x6D, 0x08, 0x85, 0x44, 0x0D, 0x54, 0x6D, 0x0D, 0x36, 0x31, 0x06, 0x30, 0x62, 0x05, 0x75,
/* 03C0 */ 0xB0, 0x7E, 0x82, 0x37, 0x4E, 0x29, 0x09, 0x60, 0x21, 0xB3, 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B,
/* 03D0 */ 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B, 0x3B, 0x28, 0x84, 0x3A, 0x2F, 0x0B, 0xA3, 0x21, 0x08, 0xA3,
/* 03E0 */ 0x21, 0x08, 0x2D, 0x9D, 0x21, 0x72, 0x45, 0x2B, 0x70, 0x84, 0x2E, 0x06, 0x94, 0x3B, 0x5B, 0x75,
/* 03F0 */ 0x03, 0x99, 0x2E, 0xB4, 0x0C, 0x00, 0xB4, 0x0C, 0x52, 0x94, 0x24, 0x5F, 0x37, 0x8F, 0x6C, 0x08,
/* 0400 */ 0xA3, 0x1F, 0x0B, 0x54, 0x05, 0x09, 0x94, 0x1F, 0xA2, 0x41, 0x4A, 0x1F, 0x91, 0xA8, 0x5D, 0xAA,
/* 0410 */ 0x25, 0x53, 0x32, 0x46, 0x09, 0xA8, 0x46, 0x04, 0x1F, 0x2A, 0x62, 0x05, 0x75, 0xA1, 0x31, 0x0D,
/* 0420 */ 0x54, 0x6D, 0x0D, 0x54, 0x44, 0x23, 0x9A, 0x80, 0x6D, 0x33, 0x73, 0x44, 0x06, 0x46, 0x6D, 0x33,
/* 0430 */ 0x73, 0x26, 0x33, 0x73, 0x6D, 0x97, 0x4A, 0x44, 0x23, 0x02, 0x00, 0x08, 0x0F, 0x45, 0x4A, 0x1F,
/* 0440 */ 0xB4, 0x81, 0x03, 0x30, 0x29, 0x1F, 0x0E, 0x67, 0x5D, 0x7F, 0x4A, 0x1F, 0x0E, 0x67, 0x5D, 0x2D,
/* 0450 */ 0x4A, 0x1F, 0x0E, 0x67, 0x5D, 0x91, 0x4A, 0x0D, 0x67, 0xAE, 0xB3, 0x02, 0x04, 0x36, 0x00, 0x08,
/* 0460 */ 0x0E, 0x0A, 0x2C, 0x70, 0x7A, 0x21, 0x70, 0x7A, 0x2C, 0x09, 0x0E, 0x0A, 0x6D, 0x8E, 0x25, 0x1D,
/* 0470 */ 0x30, 0x0D, 0x7C, 0x1D, 0x30, 0x1D, 0x30, 0x1D, 0x30, 0x1D, 0x30, 0x2C, 0x75, 0x0A, 0x0F, 0x2C,
/* 0480 */ 0xA2, 0x0C, 0x2C, 0xA2, 0x0C, 0x28, 0x03, 0x0E, 0x41, 0xA1, 0x48, 0x0A, 0x29, 0x5F, 0x34, 0x5F,
/* 0490 */ 0x5B, 0xA4, 0x65, 0x2D, 0x05, 0x04, 0x03, 0x37, 0x03, 0x41, 0x71, 0x03, 0x41, 0x71, 0x5D, 0x97,
/* 04A0 */ 0x5F, 0x34, 0x5F, 0x34, 0x5F, 0x99, 0x2C, 0x08, 0x99, 0x2C, 0x08, 0x99, 0x38, 0x74, 0x42, 0x9A,
/* 04B0 */ 0x78, 0x73, 0x94, 0x37, 0x03, 0x41, 0x94, 0x0B, 0x04, 0x01, 0x0C, 0x0E, 0x05, 0x00, 0x0E, 0x09,
/* 04C0 */ 0x05, 0x0C, 0x6C, 0x1D, 0x30, 0x00, 0xAB, 0x0E, 0x3B, 0x0A, 0x32, 0x0E, 0x1B, 0x38, 0x48, 0x0D,
/* 04D0 */ 0x86, 0x00, 0x0B, 0x4B, 0x5B, 0x07, 0x99, 0x03, 0x5A, 0x6F, 0x0D, 0x30, 0x81, 0x25, 0x49, 0x22,
/* 04E0 */ 0x95, 0x37, 0x3D, 0x82, 0x25, 0x05, 0x0E, 0x0C, 0x93, 0x0D, 0x86, 0x37, 0x24, 0x7A, 0x07, 0x99,
/* 04F0 */ 0x37, 0x33, 0x0E, 0x0C, 0x93, 0x0D, 0x86, 0xA8, 0x95, 0x00, 0x69, 0x35, 0x0C, 0x96, 0x35, 0xB4,
/* 0500 */ 0x03, 0x38, 0x48, 0x87, 0x38, 0x33, 0x0D, 0x4C, 0x0B, 0x5B, 0x79, 0x74, 0x20, 0x0E, 0x3B, 0x59,
/* 0510 */ 0x79, 0x74, 0x2E, 0x63, 0x90, 0x4C, 0x01, 0x5B, 0x66, 0x00, 0x79, 0x42, 0x4C, 0x0E, 0x4C, 0x0E,
/* 0520 */ 0x44, 0x8E, 0x7F, 0x9A, 0x0B, 0x36, 0x0C, 0x30, 0x01, 0x21, 0x5B, 0x08, 0x30, 0x0C, 0x2C, 0x8F,
/* 0530 */ 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0C, 0x2C, 0x8F, 0x0E, 0x36, 0x09, 0x20,
/* 0540 */ 0x2C, 0x18, 0x2C, 0x18, 0x2C, 0x18, 0x2C, 0x06, 0x2C, 0x8A, 0x8A, 0x51, 0x4B, 0x1A, 0x9B, 0x08,
/* 0550 */ 0x21, 0x32, 0x7F, 0x02, 0x5D, 0x09, 0x54, 0x1F, 0x37, 0x32, 0x02, 0x0A, 0x29, 0x55, 0x52, 0x0E,
/* 0560 */ 0x41, 0x1B, 0x37, 0x22, 0x95, 0x05, 0x0C, 0x99, 0x78, 0x5F, 0x7F, 0x9A, 0x09, 0x99, 0x00, 0x25,
/* 0570 */ 0x9A, 0x09, 0x99, 0x00, 0x25, 0x9A, 0x09, 0x99, 0x37, 0x99, 0x27, 0x99, 0x27, 0x99, 0x27, 0x99,
/* 0580 */ 0x27, 0x99, 0x6D, 0x08, 0x0F, 0x95, 0x44, 0x18, 0x02, 0x5D, 0x33, 0x46, 0x4A, 0x55, 0x0C, 0x30,
/* 0590 */ 0x49, 0x22, 0x4A, 0x44, 0x6F, 0x90, 0x00, 0x69, 0x1F, 0x69, 0x5D, 0x69, 0x1F, 0x2A, 0x0C, 0x5D,
/* 05A0 */ 0x69, 0x1F, 0x8B, 0x9D, 0x38, 0x70, 0x02, 0x38, 0x6F, 0x22, 0x54, 0x38, 0x08, 0x95, 0x44, 0x0C,
/* 05B0 */ 0x09, 0x0C, 0x9D, 0x5D, 0xA4, 0xB4, 0x03, 0x1F, 0x0B, 0x9D, 0x6D, 0x07, 0x45, 0x37, 0x0B, 0x9D,
/* 05C0 */ 0x6D, 0x0E, 0x7A, 0x37, 0x0B, 0x00, 0xAA, 0x84, 0x2C, 0x84, 0x2C,
/* dictionary offset */
0x00, 0x00, 0x00, 0x02, 0x00,
/* 05D0 */ 0x04, 0x00, 0x05, 0x00, 0x07, 0x00, 0x09, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x14, 0x00,
/* 05E0 */ 0x15, 0x00, 0x17, 0x00, 0x19, 0x00, 0x1C, 0x00, 0x1F, 0x00, 0x20, 0x00, 0x22, 0x00, 0x23, 0x00,
/* 05F0 */ 0x26, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2A, 0x00, 0x2C, 0x00, 0x2D, 0x00, 0x30, 0x00, 0x31, 0x00,
/* 0600 */ 0x32, 0x00, 0x34, 0x00, 0x36, 0x00, 0x39, 0x00, 0x3A, 0x00, 0x3C, 0x00, 0x3D, 0x00, 0x3E, 0x00,
/* 0610 */ 0x40, 0x00, 0x43, 0x00, 0x46, 0x00, 0x48, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x50, 0x00,
/* 0620 */ 0x51, 0x00, 0x52, 0x00, 0x54, 0x00, 0x55, 0x00, 0x57, 0x00, 0x59, 0x00, 0x61, 0x00, 0x63, 0x00,
/* 0630 */ 0x65, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6E, 0x00, 0x70, 0x00, 0x72, 0x00, 0x74, 0x00,
/* 0640 */ 0x76, 0x00, 0x78, 0x00, 0x7A, 0x00, 0x7C, 0x00, 0x7E, 0x00, 0x81, 0x00, 0x83, 0x00, 0x85, 0x00,
/* 0650 */ 0x8A, 0x00, 0x8D, 0x00, 0x8E, 0x00, 0x90, 0x00, 0x91, 0x00, 0x92, 0x00, 0x94, 0x00, 0x96, 0x00,
/* 0660 */ 0x98, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, 0x9F, 0x00, 0xAB, 0x00, 0xAD, 0x00, 0xAF, 0x00,
/* 0670 */ 0xB2, 0x00, 0xBE, 0x00, 0xC0, 0x00, 0xC2, 0x00, 0xC3, 0x00, 0xC4, 0x00, 0xC6, 0x00, 0xC8, 0x00,
/* 0680 */ 0xCB, 0x00, 0xCD, 0x00, 0xCE, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD3, 0x00, 0xD5, 0x00, 0xD8, 0x00,
/* 0690 */ 0xDB, 0x00, 0xDD, 0x00, 0xDF, 0x00, 0xE1, 0x00, 0xE4, 0x00, 0xE7, 0x00, 0xE9, 0x00, 0xF8, 0x00,
/* 06A0 */ 0xFA, 0x00, 0xFD, 0x00, 0xFF, 0x01, 0x02, 0x01, 0x05, 0x01, 0x07, 0x01, 0x0A, 0x01, 0x0C, 0x01,
/* 06B0 */ 0x0D, 0x01, 0x11, 0x01, 0x14, 0x01, 0x16, 0x01, 0x18, 0x01, 0x19, 0x01, 0x1B, 0x01, 0x1D, 0x01,
/* 06C0 */ 0x1F, 0x01, 0x21, 0x01, 0x23, 0x01, 0x25, 0x01, 0x27, 0x01, 0x29, 0x01, 0x2C, 0x01, 0x2E, 0x01,
/* 06D0 */ 0x30, 0x01, 0x32, 0x01, 0x34, 0x01, 0x36, 0x01, 0x38, 0x01, 0x3A, 0x01, 0x3C, 0x01, 0x3E, 0x01,
/* 06E0 */ 0x40, 0x01, 0x42, 0x01, 0x45, 0x01, 0x47, 0x01, 0x49, 0x01, 0x4A, 0x01, 0x4C, 0x01, 0x4D, 0x01,
/* 06F0 */ 0x4E, 0x01, 0x50, 0x01, 0x52, 0x01, 0x54, 0x01, 0x56, 0x01, 0x57, 0x01, 0x59, 0x01, 0x5B, 0x01,
/* 0700 */ 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01, 0x64, 0x01, 0x6F, 0x01, 0xA6, 0x01, 0xD0, 0x01,
/* 0710 */ 0xD2, 0x01, 0xDD, 0x02, 0x12, 0x02, 0x2D, 0x02, 0x54, 0x02, 0x56, 0x02, 0x82, 0x02, 0x92, 0x02,
/* 0720 */ 0x9D, 0x02, 0xC4, 0x02, 0xEA, 0x03, 0x04, 0x03, 0x07, 0x03, 0x0F, 0x03, 0x34, 0x03, 0x3C, 0x03,
/* 0730 */ 0x55, 0x03, 0x67, 0x03, 0x6D, 0x03, 0x99, 0x03, 0x9B, 0x03, 0x9F, 0x03, 0xC5, 0x03, 0xE2, 0x03,
/* 0740 */ 0xE4, 0x03, 0xE6, 0x03, 0xE9, 0x03, 0xFC, 0x03, 0xFE, 0x04, 0x06, 0x04, 0x08, 0x04, 0x0A, 0x04,
/* 0750 */ 0x10, 0x04, 0x18, 0x04, 0x30, 0x04, 0x38, 0x04, 0x42, 0x04, 0x44, 0x04, 0x49, 0x04, 0x4E, 0x04,
/* 0760 */ 0x50, 0x04, 0x52, 0x04, 0x54, 0x04, 0x58, 0x04, 0x66, 0x04, 0x70, 0x04, 0x82, 0x04, 0x85, 0x04,
/* 0770 */ 0x91, 0x04, 0xAD, 0x04, 0xB1, 0x04, 0xB3, 0x04, 0xB5, 0x04, 0xB8, 0x04, 0xC7, 0x04, 0xC9, 0x04,
/* 0780 */ 0xCB, 0x04, 0xD2, 0x04, 0xDA, 0x04, 0xDD, 0x04, 0xE3, 0x04, 0xE5, 0x04, 0xF5, 0x05, 0x04, 0x05,
/* 0790 */ 0x0D, 0x05, 0x17, 0x05, 0x19, 0x05, 0x2E, 0x05, 0x50, 0x05, 0x52, 0x05, 0x56,
/* char range info */
0x00, 0x00, 0x04,
/* 07A0 */ 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x27, 0x00, 0x45, 0x00, 0x88, 0x00, 0xDA, 0x01, 0x4B,
/* 07B0 */ 0x01, 0x9F, 0x01, 0xB1, 0x01, 0xE7, 0x02, 0x21, 0x02, 0x48, 0x02, 0x4F, 0x02, 0x5B, 0x02, 0x68,
/* 07C0 */ 0x02, 0x6F, 0x02, 0xA7, 0x02, 0xEC, 0x03, 0x05, 0x03, 0x38, 0x03, 0x6F, 0x03, 0xAA, 0x03, 0xE0,
/* 07D0 */ 0x04, 0x1F, 0x04, 0x4C, 0x04, 0x95, 0x04, 0xDE, 0x04, 0xE6, 0x04, 0xF3, 0x05, 0x1B, 0x05, 0x24,
/* 07E0 */ 0x05, 0x49, 0x05, 0x7F, 0x06, 0x18, 0x06, 0x1E, 0x06, 0x57, 0x06, 0x8C, 0x06, 0xCD, 0x06, 0xD2,
/* 07F0 */ 0x06, 0xED, 0x07, 0x36, 0x07, 0x50, 0x07, 0x55, 0x07, 0x6F, 0x07, 0xB1, 0x07, 0xC7, 0x08, 0x36,
/* 0800 */ 0x08, 0x43, 0x08, 0x4A, 0x08, 0x75, 0x08, 0xC3, 0x08, 0xFD, 0x09, 0x43, 0x09, 0x5A, 0x09, 0x5F,
/* 0810 */ 0x09, 0xA3, 0x0A, 0x16, 0x0A, 0x59, 0x0A, 0x67, 0x0A, 0x96, 0x0A, 0xB5, 0x0A, 0xEC, 0x0B, 0x0B,
/* 0820 */ 0x0B, 0x2D, 0x0B, 0x3E, 0x0B, 0x52, 0x0B, 0x56, 0x0B, 0x77, 0x0B, 0x9F, 0x0B, 0xCA, 0x0B, 0xD1,
/* 0830 */ 0x0B, 0xFA, 0x0C, 0x4E, 0x0C, 0x67, 0x0C, 0x6D, 0x0C, 0x84, 0x0C, 0xBE, 0x0C, 0xD5, 0x0C, 0xFD,
/* 0840 */ 0x0D, 0x06, 0x0D, 0x0B, 0x0D, 0x25, 0x0D, 0x50, 0x0D, 0x6C, 0x0D, 0xA1, 0x0D, 0xCE, 0x0D, 0xD5,
/* 0850 */ 0x0E, 0x08, 0x0E, 0x60, 0x0E, 0x92, 0x0E, 0x9B, 0x0E, 0xC6, 0x0E, 0xFF, 0x0F, 0x0B, 0x0F, 0x48,
/* 0860 */ 0x04, 0x00, 0x10, 0x05, 0xD2, 0x8B, 0x2C, 0x69, 0x1A, 0x78, 0x0C, 0x1A, 0x78, 0x0B, 0x2C, 0x70,
/* 0870 */ 0x0B, 0x2C, 0xA2, 0x0A, 0x5D, 0x19, 0x94, 0x35, 0x94, 0x35, 0x0E, 0x96, 0x6D, 0xB1, 0x27, 0x4B,
/* 0880 */ 0x2C, 0x8A, 0x2A, 0x81, 0x27, 0x4B, 0x10, 0x09, 0xD2, 0xA2, 0x55, 0x99, 0x37, 0xA4, 0x54, 0x00,
/* 0890 */ 0x99, 0x2E, 0x30, 0x6C, 0x0E, 0x9D, 0x2E, 0xB4, 0x6C, 0x0E, 0x5C, 0x2E, 0xD5, 0x00, 0xD5, 0x2E,
/* 08A0 */ 0x22, 0x53, 0x0C, 0x7A, 0x10, 0x0A, 0xFE, 0x8F, 0x00, 0x03, 0x3B, 0x37, 0x08, 0x4A, 0x00, 0x2A,
/* 08B0 */ 0x20, 0xD8, 0x0C, 0x00, 0x8F, 0x37, 0xA2, 0x41, 0x4A, 0x1F, 0xA2, 0xA8, 0x71, 0x05, 0x99, 0x04,
/* 08C0 */ 0x0D, 0x45, 0x03, 0x37, 0x03, 0x3B, 0x0E, 0x96, 0x5B, 0x2A, 0x02, 0x01, 0x36, 0x5B, 0x8F, 0x00,
/* 08D0 */ 0x03, 0x3B, 0x40, 0x03, 0x40, 0x03, 0x1F, 0x03, 0x0D, 0x0F, 0xDE, 0x0B, 0x4A, 0x04, 0x01, 0x37,
/* 08E0 */ 0x99, 0x24, 0x0B, 0x48, 0x36, 0x3A, 0x09, 0x10, 0x0A, 0x00, 0x61, 0xB4, 0x03, 0x35, 0xB4, 0x03,
/* 08F0 */ 0x35, 0xB4, 0x03, 0x21, 0x07, 0x7F, 0x95, 0x02, 0x5D, 0x7E, 0xA1, 0x1F, 0x70, 0x82, 0x04, 0xB2,
/* 0900 */ 0x37, 0x2A, 0x0C, 0x5D, 0xA4, 0x37, 0x33, 0x0F, 0xA3, 0x19, 0x63, 0x77, 0x2B, 0x06, 0x41, 0x0C,
/* 0910 */ 0x02, 0x2E, 0x8C, 0x73, 0x4A, 0x6D, 0x52, 0x75, 0x7C, 0x2C, 0x0C, 0x99, 0x31, 0x6F, 0x38, 0x0A,
/* 0920 */ 0x54, 0x1F, 0x03, 0x0E, 0x39, 0x32, 0x7F, 0x03, 0x7E, 0x95, 0x5B, 0x07, 0x0D, 0x73, 0x9F, 0x6D,
/* 0930 */ 0x48, 0xB4, 0x03, 0x35, 0xB4, 0x03, 0x35, 0xB4, 0x03, 0x10, 0x10, 0x2E, 0xB3, 0x52, 0x26, 0x6F,
/* 0940 */ 0x0A, 0x0E, 0xB2, 0x6D, 0x97, 0x09, 0x44, 0xEC, 0x54, 0x00, 0xA4, 0x0E, 0x9D, 0x1A, 0x32, 0x67,
/* 0950 */ 0x05, 0x09, 0x67, 0x5D, 0x0A, 0x4A, 0x44, 0x06, 0x45, 0x00, 0x70, 0x01, 0x91, 0x04, 0x26, 0x32,
/* 0960 */ 0x0F, 0xB0, 0x05, 0x67, 0x3A, 0x0A, 0x44, 0xA4, 0x63, 0x95, 0x07, 0x67, 0x6B, 0x04, 0xB4, 0x45,
/* 0970 */ 0x03, 0x54, 0x00, 0x03, 0x6B, 0x03, 0x02, 0x24, 0x86, 0x72, 0x0C, 0x6B, 0x2A, 0x04, 0x72, 0x85,
/* 0980 */ 0x44, 0x50, 0x0F, 0x39, 0x67, 0x02, 0x03, 0x0F, 0x5F, 0x44, 0x08, 0x0F, 0xA1, 0x04, 0x4A, 0x5D,
/* 0990 */ 0x30, 0x02, 0x26, 0x03, 0x30, 0x6C, 0x02, 0x36, 0x8F, 0x01, 0x26, 0x22, 0x0C, 0x6D, 0x0B, 0x30,
/* 09A0 */ 0x94, 0x26, 0x3F, 0x2F, 0x5D, 0xAC, 0x3E, 0x56, 0x44, 0x03, 0x10, 0x0E, 0xCD, 0x07, 0x0D, 0x4A,
/* 09B0 */ 0x39, 0x2E, 0xD8, 0x41, 0x03, 0x31, 0x6F, 0x46, 0x05, 0x09, 0x94, 0x00, 0x78, 0x0B, 0x32, 0x7D,
/* 09C0 */ 0xA4, 0x0E, 0x67, 0x58, 0x36, 0x5B, 0x8F, 0xEC, 0x0C, 0x2B, 0x0B, 0x73, 0x7B, 0x00, 0x02, 0x6B,
/* 09D0 */ 0x08, 0xA8, 0xB0, 0x24, 0x0B, 0x26, 0x97, 0x4A, 0x08, 0x30, 0x86, 0x54, 0x44, 0xEC, 0x6C, 0x07,
/* 09E0 */ 0xA8, 0xA1, 0x44, 0xB4, 0x7C, 0x5D, 0x8F, 0x96, 0x44, 0x24, 0x4A, 0x06, 0x05, 0xD8, 0x46, 0x04,
/* 09F0 */ 0x44, 0x03, 0x3D, 0x75, 0x2F, 0x28, 0x6F, 0x0A, 0xD1, 0x39, 0x00, 0x08, 0x0B, 0x03, 0x10, 0x04,
/* 0A00 */ 0xD2, 0x01, 0x99, 0x5D, 0x19, 0x54, 0x35, 0x36, 0x35, 0x0E, 0x5C, 0x35, 0xD5, 0x35, 0x0C, 0x7A,
/* 0A10 */ 0x10, 0x06, 0x61, 0x0A, 0x83, 0x38, 0xF6, 0x99, 0x2C, 0xD1, 0xED, 0x05, 0x99, 0x2C, 0xB9, 0x2B,
/* 0A20 */ 0x70, 0x0D, 0x2C, 0x2A, 0x0A, 0x2C, 0x08, 0x99, 0xD7, 0x07, 0xD7, 0x06, 0xD7, 0x06, 0xD7, 0x07,
/* 0A30 */ 0x2C, 0x08, 0x99, 0x2C, 0x2A, 0x0A, 0x2C, 0x70, 0x0D, 0x35, 0xB9, 0x2B, 0x33, 0x99, 0x35, 0xD1,
/* 0A40 */ 0xED, 0x32, 0x99, 0x35, 0x0A, 0x83, 0x10, 0x06, 0x1E, 0x3F, 0x09, 0x28, 0xEE, 0x04, 0x5D, 0x19,
/* 0A50 */ 0xB4, 0x0C, 0x28, 0xEE, 0x05, 0x1A, 0x78, 0x0B, 0x2C, 0x3A, 0x5F, 0xD7, 0x05, 0x2C, 0x08, 0x99,
/* 0A60 */ 0x2C, 0x8F, 0x0A, 0x34, 0x95, 0x34, 0x95, 0x2C, 0x8F, 0x0A, 0x2C, 0x08, 0x99, 0xD7, 0x05, 0x2C,
/* 0A70 */ 0x72, 0xED, 0x03, 0x85, 0x21, 0x09, 0xA3, 0x19, 0xB4, 0x0C, 0x38, 0xEE, 0x04, 0x2C, 0x3F, 0x09,
/* 0A80 */ 0x10, 0x08, 0x2C, 0xB3, 0xA2, 0x6C, 0x19, 0x00, 0x0E, 0x7A, 0xA4, 0x52, 0x62, 0x0C, 0x5C, 0x0C,
/* 0A90 */ 0x09, 0x5D, 0x7E, 0x0E, 0x52, 0x06, 0x0B, 0x30, 0x62, 0x53, 0x48, 0x0E, 0x67, 0x5C, 0x2B, 0x22,
/* 0AA0 */ 0x0C, 0x76, 0x2F, 0x48, 0x77, 0x50, 0x06, 0x10, 0x0A, 0xE2, 0x97, 0x5F, 0x34, 0xDB, 0x10, 0x05,
/* 0AB0 */ 0x2E, 0xCD, 0xE2, 0x51, 0x4B, 0x34, 0x67, 0x2C, 0xE9, 0x5C, 0x10, 0x08, 0x8E, 0xE2, 0x19, 0x04,
/* 0AC0 */ 0x42, 0x03, 0x00, 0x52, 0xE8, 0x52, 0xE8, 0x10, 0x05, 0x2B, 0xCD, 0xE2, 0xA5, 0xF3, 0x10, 0x09,
/* 0AD0 */ 0x61, 0x6F, 0x01, 0xB1, 0xD8, 0xB0, 0x2C, 0x29, 0x38, 0x48, 0x94, 0x34, 0x5C, 0xD7, 0x60, 0xD1,
/* 0AE0 */ 0x2C, 0x70, 0x0A, 0x21, 0x33, 0x36, 0x2C, 0x2D, 0x03, 0x2C, 0xD1, 0x2C, 0xA2, 0x0B, 0x21, 0x33,
/* 0AF0 */ 0x54, 0x2C, 0x2D, 0x03, 0x2C, 0x0C, 0x67, 0x2C, 0xA2, 0x0B, 0x38, 0xF6, 0x99, 0x38, 0xEE, 0x04,
/* 0B00 */ 0x2C, 0x08, 0x0E, 0x5F, 0x1A, 0x48, 0x10, 0x0B, 0xFE, 0x58, 0x0D, 0x0F, 0xB2, 0x2B, 0x0C, 0xE8,
/* 0B10 */ 0x37, 0x06, 0x30, 0x49, 0x22, 0x7C, 0x37, 0xB9, 0x91, 0x0B, 0x37, 0x73, 0x6F, 0x46, 0x44, 0x6F,
/* 0B20 */ 0x46, 0x6D, 0x90, 0x31, 0x03, 0x46, 0x6D, 0x73, 0x02, 0x31, 0x03, 0x46, 0x6D, 0x73, 0x02, 0x26,
/* 0B30 */ 0x6F, 0x46, 0x6D, 0x90, 0x1F, 0x73, 0x6F, 0x46, 0x37, 0xB9, 0x91, 0x0B, 0x37, 0x06, 0x30, 0x49,
/* 0B40 */ 0x22, 0x7C, 0x5B, 0x0C, 0xA8, 0x45, 0x2E, 0x58, 0x0D, 0x4A, 0x08, 0x10, 0x08, 0xCD, 0x07, 0x90,
/* 0B50 */ 0x2E, 0x8D, 0x0F, 0x90, 0x5B, 0x06, 0x7F, 0x90, 0x5B, 0x07, 0x99, 0x84, 0x2E, 0x39, 0x00, 0xFF,
/* 0B60 */ 0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x09, 0xAA, 0x98, 0xB4, 0xAF, 0x5B, 0x97, 0xE8, 0x37, 0xD8, 0x77,
/* 0B70 */ 0x8F, 0x7A, 0x5B, 0x07, 0x01, 0x5D, 0x0B, 0x54, 0xD7, 0x07, 0x2C, 0xE3, 0x2E, 0x97, 0x4A, 0x00,
/* 0B80 */ 0x19, 0xB4, 0x7C, 0x21, 0x0B, 0x94, 0x21, 0x2D, 0x0B, 0x21, 0x06, 0x30, 0xB0, 0x2B, 0x91, 0x5C,
/* 0B90 */ 0x74, 0x03, 0x37, 0x2D, 0xE8, 0x7E, 0x96, 0x10, 0x09, 0xAA, 0xA0, 0x0E, 0xFB, 0xEE, 0xA8, 0x0C,
/* 0BA0 */ 0xF6, 0x0F, 0x49, 0x06, 0xB4, 0x7C, 0x52, 0x6D, 0x08, 0x54, 0x2C, 0x2D, 0x05, 0x5D, 0xF6, 0x07,
/* 0BB0 */ 0x29, 0x21, 0x73, 0x56, 0x2E, 0x23, 0x95, 0xED, 0x8D, 0x99, 0x2C, 0x91, 0x0C, 0x52, 0x5D, 0x33,
/* 0BC0 */ 0x71, 0x08, 0x95, 0x05, 0x06, 0x0D, 0x99, 0x37, 0xD8, 0x41, 0xB0, 0x5B, 0xBE, 0x55, 0x10, 0x0A,
/* 0BD0 */ 0x35, 0xB3, 0x93, 0xB1, 0x07, 0x0F, 0x43, 0x2C, 0xEC, 0x02, 0x28, 0x78, 0x0C, 0x2C, 0x08, 0x36,
/* 0BE0 */ 0x2C, 0x84, 0x6D, 0xF6, 0x85, 0x94, 0x5B, 0xD8, 0x7C, 0x01, 0x94, 0x1F, 0xA4, 0x0E, 0x67, 0x57,
/* 0BF0 */ 0x94, 0x37, 0x06, 0x30, 0x0C, 0x04, 0x8F, 0xDE, 0x1F, 0x08, 0x89, 0x0E, 0x1F, 0x08, 0x89, 0x0E,
/* 0C00 */ 0x2B, 0x33, 0x94, 0x21, 0x33, 0x94, 0x21, 0x33, 0x94, 0x10, 0x0A, 0xAA, 0x41, 0x94, 0x5B, 0x41,
/* 0C10 */ 0x36, 0x5B, 0x46, 0x42, 0x01, 0x5B, 0x46, 0x35, 0x46, 0x57, 0x02, 0x2B, 0x73, 0x7F, 0x7B, 0x5B,
/* 0C20 */ 0x41, 0x94, 0x5B, 0x06, 0x07, 0x04, 0x1C, 0x73, 0x26, 0x25, 0x60, 0x7F, 0x03, 0x37, 0x3C, 0x6F,
/* 0C30 */ 0x90, 0x31, 0x32, 0x9E, 0x06, 0x05, 0x0C, 0x7D, 0x33, 0x41, 0x4A, 0x20, 0x98, 0x0E, 0xFB, 0x10,
/* 0C40 */ 0x0A, 0xCD, 0x98, 0x0D, 0x0E, 0x77, 0x2E, 0xB5, 0x85, 0x1F, 0xA4, 0x0E, 0x99, 0x05, 0x08, 0x20,
/* 0C50 */ 0x08, 0x94, 0x2C, 0xEC, 0x3C, 0x3C, 0x5B, 0x18, 0x8F, 0x96, 0x37, 0x70, 0xA8, 0x36, 0x78, 0x9D,
/* 0C60 */ 0x68, 0x5A, 0x03, 0x46, 0x6F, 0x46, 0x1F, 0x18, 0x00, 0xA4, 0x46, 0x1F, 0x3A, 0x2F, 0x91, 0x0C,
/* 0C70 */ 0x37, 0x08, 0x30, 0x49, 0x0C, 0x54, 0x37, 0x50, 0x41, 0x1B, 0x37, 0xA4, 0x9C, 0xFB, 0x10, 0x09,
/* 0C80 */ 0xD2, 0x22, 0x41, 0x7A, 0x37, 0x22, 0x41, 0x7A, 0x37, 0x03, 0x74, 0x05, 0x90, 0x2B, 0x97, 0x95,
/* 0C90 */ 0x27, 0xA3, 0x5D, 0x48, 0x46, 0x2C, 0x08, 0x99, 0x2C, 0x72, 0x03, 0x21, 0x91, 0x0C, 0xD7, 0x06,
/* 0CA0 */ 0x21, 0x18, 0xED, 0x8F, 0x0A, 0x2C, 0x22, 0x7A, 0x2C, 0x1C, 0x0A, 0x10, 0x0B, 0xFE, 0x03, 0xA5,
/* 0CB0 */ 0x9E, 0x55, 0xF6, 0x0F, 0x41, 0xB0, 0x37, 0x0C, 0x99, 0x05, 0x0C, 0x54, 0x37, 0x30, 0x81, 0x33,
/* 0CC0 */ 0x94, 0x37, 0x84, 0x00, 0x07, 0x36, 0x37, 0x08, 0x30, 0x0C, 0x88, 0x0F, 0x1B, 0x5B, 0x0A, 0xA8,
/* 0CD0 */ 0xB0, 0xF6, 0x0D, 0x4A, 0x7F, 0x1B, 0x31, 0xA4, 0xB4, 0xB0, 0x3F, 0x7D, 0x06, 0x94, 0x5D, 0x18,
/* 0CE0 */ 0x1F, 0x07, 0x94, 0x00, 0xA4, 0x90, 0x31, 0x91, 0x9D, 0x05, 0x75, 0x0C, 0x00, 0x7E, 0x82, 0x37,
/* 0CF0 */ 0x06, 0x0B, 0x29, 0xF1, 0x10, 0x0A, 0xAA, 0x32, 0x0B, 0x3E, 0x0C, 0x06, 0x2E, 0x06, 0xA8, 0x99,
/* 0D00 */ 0x37, 0xA2, 0x9D, 0x05, 0x7F, 0x03, 0x31, 0x97, 0x95, 0x5D, 0x09, 0x99, 0x1F, 0x08, 0x99, 0x5D,
/* 0D10 */ 0x8F, 0x0B, 0x1F, 0x07, 0x94, 0x00, 0x97, 0x45, 0x31, 0x32, 0x46, 0x02, 0x02, 0x0D, 0x7D, 0x3A,
/* 0D20 */ 0xA8, 0x94, 0x31, 0x6F, 0x72, 0x0C, 0x22, 0x7C, 0x2E, 0xA6, 0x02, 0x90, 0x19, 0x0C, 0x99, 0x2E,
/* 0D30 */ 0x1C, 0x72, 0x1B, 0x5B, 0x06, 0x63, 0x7B, 0x2E, 0x2A, 0x77, 0x21, 0x1C, 0x02, 0x10, 0x05, 0xAB,
/* 0D40 */ 0xA5, 0xF3, 0x38, 0xA5, 0xF3, 0x10, 0x05, 0xAB, 0xA5, 0xF3, 0x6D, 0x51, 0x4B, 0x34, 0x67, 0x2C,
/* 0D50 */ 0xE9, 0x5C, 0x10, 0x09, 0x4D, 0x52, 0x2C, 0x33, 0x0C, 0x7A, 0x2B, 0x06, 0x72, 0x95, 0x37, 0x1C,
/* 0D60 */ 0x0D, 0x73, 0x77, 0x5B, 0x07, 0x73, 0x39, 0x2B, 0x07, 0x94, 0xED, 0x2A, 0x67, 0xF1, 0x6F, 0x09,
/* 0D70 */ 0xA8, 0x39, 0x2B, 0x58, 0x0E, 0x94, 0x5D, 0x19, 0x92, 0x02, 0x10, 0x09, 0x38, 0xE2, 0x19, 0xDD,
/* 0D80 */ 0x35, 0x19, 0xDD, 0x10, 0x09, 0x1A, 0x4D, 0x3C, 0xB1, 0x0D, 0x9F, 0xED, 0xB5, 0x9F, 0x20, 0x6F,
/* 0D90 */ 0x09, 0x63, 0xF1, 0x5D, 0x58, 0xB4, 0x4A, 0x21, 0x33, 0x29, 0x2B, 0x06, 0x72, 0x45, 0x37, 0x58,
/* 0DA0 */ 0x63, 0x77, 0x52, 0x73, 0xDE, 0x21, 0x0B, 0x39, 0x10, 0x09, 0xAA, 0x02, 0x09, 0xD1, 0x0A, 0x02,
/* 0DB0 */ 0xF6, 0x63, 0x46, 0x02, 0x37, 0x03, 0x0D, 0x4B, 0x88, 0x99, 0x5B, 0x93, 0x5D, 0x0A, 0x54, 0x21,
/* 0DC0 */ 0x06, 0x73, 0x03, 0x2B, 0x08, 0x46, 0x04, 0x38, 0x78, 0x0D, 0x02, 0x21, 0x06, 0x36, 0x38, 0x48,
/* 0DD0 */ 0x65, 0x6B, 0x2B, 0x48, 0x0D, 0x86, 0xD7, 0x0A, 0xD7, 0x0A, 0x38, 0x52, 0x0D, 0x86, 0x10, 0x12,
/* 0DE0 */ 0x5D, 0xCD, 0x68, 0x0C, 0x0E, 0x67, 0x0C, 0x08, 0x6B, 0x06, 0x3D, 0x54, 0x44, 0x09, 0x46, 0x09,
/* 0DF0 */ 0x06, 0x04, 0x05, 0x08, 0x0D, 0x94, 0x28, 0x97, 0x45, 0x1C, 0x0D, 0x4A, 0x09, 0x02, 0x2D, 0x05,
/* 0E00 */ 0x5D, 0x6F, 0x29, 0x00, 0x08, 0x73, 0x85, 0x0C, 0x4A, 0x38, 0x08, 0x0F, 0x7A, 0x70, 0x77, 0x0E,
/* 0E10 */ 0x45, 0x97, 0x7A, 0x6D, 0x22, 0x81, 0x06, 0x3B, 0x0D, 0x45, 0x00, 0x03, 0x54, 0x6D, 0x85, 0x2D,
/* 0E20 */ 0x9A, 0x0D, 0x45, 0xA4, 0x94, 0x6F, 0x94, 0x00, 0xD8, 0x5F, 0x3A, 0x0B, 0x00, 0x02, 0x94, 0x6F,
/* 0E30 */ 0x94, 0x00, 0xD8, 0x5F, 0x3A, 0x0B, 0x00, 0x03, 0x54, 0x5D, 0xA2, 0x0A, 0x00, 0x08, 0x30, 0x02,
/* 0E40 */ 0x3A, 0x0C, 0x97, 0x7A, 0x6D, 0x0D, 0x4A, 0x33, 0x94, 0x07, 0x0F, 0x3E, 0x88, 0x4A, 0x38, 0x2D,
/* 0E50 */ 0x03, 0x3A, 0x30, 0xAF, 0x73, 0x7A, 0x38, 0x03, 0x85, 0x03, 0x22, 0x0C, 0x9A, 0x0A, 0x0E, 0x77,
/* 0E60 */ 0x1A, 0x2D, 0x83, 0x00, 0x19, 0xEC, 0x9F, 0x05, 0x04, 0x05, 0x07, 0x39, 0x7E, 0x94, 0x37, 0x03,
/* 0E70 */ 0x09, 0x0C, 0x0E, 0x67, 0x0C, 0x08, 0x03, 0x10, 0x0B, 0xCD, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0xAA,
/* 0E80 */ 0x63, 0x9E, 0x0A, 0x04, 0x4C, 0x9D, 0x37, 0x79, 0x4E, 0x90, 0x1F, 0xE3, 0x18, 0x03, 0x1F, 0xE3,
/* 0E90 */ 0x18, 0x6B, 0x79, 0x4E, 0x7D, 0x00, 0x3D, 0x08, 0x4C, 0x96, 0x37, 0xE3, 0x04, 0xF0, 0x25, 0x04,
/* 0EA0 */ 0x5D, 0x2D, 0x0B, 0x25, 0x04, 0x5D, 0x2D, 0x0B, 0x1F, 0x79, 0x04, 0x08, 0x0F, 0x54, 0x25, 0x41,
/* 0EB0 */ 0x1B, 0x25, 0x46, 0x0B, 0x07, 0x01, 0x10, 0x0A, 0xCD, 0xA0, 0x0D, 0x4A, 0xF1, 0x8F, 0xA8, 0xA1,
/* 0EC0 */ 0x1F, 0x91, 0x96, 0x05, 0x08, 0x0E, 0x05, 0x37, 0x0C, 0x94, 0x5D, 0xA4, 0x37, 0x18, 0x03, 0x21,
/* 0ED0 */ 0xB5, 0x2C, 0x8A, 0x8A, 0xB5, 0x2C, 0x23, 0x03, 0x2C, 0x0C, 0x94, 0x5D, 0xA4, 0xF6, 0x0F, 0x99,
/* 0EE0 */ 0x04, 0x92, 0x09, 0x5B, 0x07, 0xA8, 0x46, 0x20, 0xA0, 0x29, 0xF1, 0x10, 0x0C, 0xAA, 0x63, 0x9E,
/* 0EF0 */ 0x09, 0x03, 0x4C, 0x9D, 0x37, 0x79, 0x05, 0x2D, 0x7A, 0x25, 0x04, 0x5D, 0x2D, 0x0B, 0x1F, 0xE3,
/* 0F00 */ 0x32, 0x90, 0x31, 0xE3, 0x00, 0x18, 0x03, 0x31, 0xE3, 0x00, 0xA2, 0x7A, 0x31, 0xE3, 0x00, 0xA2,
/* 0F10 */ 0x7A, 0x31, 0xE3, 0x00, 0x23, 0x03, 0x31, 0xE3, 0x00, 0xB5, 0x25, 0x04, 0x5D, 0xD8, 0x45, 0x1F,
/* 0F20 */ 0x79, 0x05, 0x2D, 0x7A, 0x25, 0x73, 0x36, 0x37, 0x63, 0x4A, 0x09, 0x03, 0x10, 0x09, 0xAA, 0x3D,
/* 0F30 */ 0xEA, 0x10, 0x09, 0xAA, 0x3D, 0x09, 0x4C, 0x07, 0x5B, 0x79, 0x74, 0x01, 0x5B, 0x66, 0x00, 0x63,
/* 0F40 */ 0x71, 0x5D, 0x63, 0x71, 0x5D, 0x79, 0x65, 0x03, 0x2E, 0xE3, 0x59, 0x66, 0x10, 0x0C, 0xAA, 0x6F,
/* 0F50 */ 0x09, 0xD1, 0x49, 0x37, 0x33, 0x3D, 0x09, 0x78, 0x95, 0x05, 0x06, 0x0A, 0x82, 0x31, 0x0B, 0x94,
/* 0F60 */ 0x6D, 0xA4, 0x1F, 0x18, 0x03, 0x21, 0xB5, 0x00, 0x32, 0x42, 0x44, 0x33, 0x46, 0x5D, 0x0C, 0xA8,
/* 0F70 */ 0x31, 0x06, 0x46, 0x5D, 0x0A, 0xA8, 0x44, 0x33, 0x73, 0x6D, 0x18, 0x31, 0x23, 0x02, 0x5D, 0x18,
/* 0F80 */ 0x1F, 0x0D, 0x36, 0x5D, 0x18, 0x1F, 0x8F, 0x62, 0x04, 0x08, 0x73, 0x1F, 0x24, 0x41, 0x4A, 0x5B,
/* 0F90 */ 0x06, 0xA5, 0x67, 0x0B, 0x06, 0x10, 0x0C, 0x6E, 0xB3, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0x1F, 0x79,
/* 0FA0 */ 0x65, 0x07, 0x46, 0x1F, 0x3D, 0x46, 0x1F, 0x3D, 0x46, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0x10,
/* 0FB0 */ 0x05, 0xAA, 0x66, 0xB6, 0x10, 0x06, 0xAA, 0x8F, 0x0C, 0x2C, 0x8F, 0xEF, 0xEF, 0x0B, 0x2C, 0x8F,
/* 0FC0 */ 0x0B, 0xD7, 0x08, 0x21, 0x8F, 0x2F, 0x2E, 0xA2, 0x9D, 0x27, 0x0C, 0x04, 0x6D, 0x19, 0x10, 0x0C,
/* 0FD0 */ 0xAA, 0xE3, 0xA4, 0xE3, 0x44, 0xE3, 0x00, 0x09, 0x94, 0x1F, 0xE3, 0x03, 0x30, 0xA1, 0x1F, 0xE3,
/* 0FE0 */ 0xEC, 0x6C, 0x25, 0x04, 0x76, 0x87, 0xB4, 0x7C, 0x7F, 0x03, 0x5B, 0xB4, 0x45, 0x5A, 0x6D, 0xF0,
/* 0FF0 */ 0x30, 0x7A, 0x5B, 0xB4, 0x7A, 0x2D, 0x0D, 0x5B, 0xB4, 0x7A, 0x01, 0xF0, 0x37, 0xE3, 0x08, 0x30,
/* 1000 */ 0xB0, 0x25, 0x04, 0xA4, 0x79, 0x25, 0x04, 0x5D, 0x08, 0x30, 0xA1, 0x31, 0xE3, 0xA4, 0x0E, 0x94,
/* 1010 */ 0x10, 0x09, 0xAA, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00, 0xE3, 0x59, 0xB4, 0x95, 0x08, 0x08, 0x08,
/* 1020 */ 0x55, 0x00, 0x25, 0x41, 0x4C, 0x0D, 0x10, 0x0E, 0xAA, 0x08, 0x0F, 0x94, 0x5D, 0x03, 0x0F, 0x46,
/* 1030 */ 0x44, 0x09, 0x73, 0x0C, 0x5D, 0x06, 0xA8, 0x44, 0xD8, 0x46, 0x5D, 0x08, 0x0F, 0x90, 0x1A, 0x24,
/* 1040 */ 0x72, 0x02, 0x24, 0x7F, 0x02, 0x26, 0x22, 0x0C, 0xD5, 0x3A, 0x0B, 0x30, 0x03, 0x26, 0x0D, 0x4A,
/* 1050 */ 0x0B, 0x0F, 0x55, 0x99, 0x3B, 0x1A, 0x29, 0x08, 0x45, 0x03, 0x4A, 0x8F, 0x05, 0x26, 0x0F, 0x4A,
/* 1060 */ 0x05, 0x4A, 0x06, 0x95, 0x8F, 0x05, 0x1A, 0xA2, 0x0C, 0x02, 0x94, 0x9D, 0x07, 0x36, 0x1A, 0x70,
/* 1070 */ 0x0C, 0x00, 0x0E, 0x67, 0x7A, 0x06, 0x54, 0x1A, 0x03, 0x85, 0x0B, 0x73, 0x1C, 0x99, 0x28, 0x32,
/* 1080 */ 0x85, 0x08, 0x46, 0x33, 0x94, 0x1A, 0x2A, 0x0A, 0x00, 0x03, 0x08, 0x08, 0x6C, 0x2A, 0x0A, 0x28,
/* 1090 */ 0x97, 0x95, 0x1A, 0x91, 0x0B, 0x10, 0x0C, 0xAA, 0x63, 0x03, 0x5D, 0x29, 0x25, 0x96, 0x5D, 0x29,
/* 10A0 */ 0xBF, 0xD0, 0x10, 0x0D, 0xCD, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0B, 0xAA, 0x63, 0x4A, 0x0A, 0x04,
/* 10B0 */ 0x4C, 0x9D, 0x37, 0x79, 0xA7, 0x73, 0x6B, 0xE3, 0x3A, 0x9D, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3,
/* 10C0 */ 0x3A, 0x9D, 0x25, 0x04, 0x68, 0x73, 0x03, 0x25, 0xE8, 0x25, 0x73, 0x9F, 0x5B, 0x79, 0x04, 0x03,
/* 10D0 */ 0x2B, 0x66, 0x00, 0xE3, 0x10, 0x0D, 0xCD, 0xBE, 0xF1, 0x2D, 0xA8, 0x82, 0x31, 0x2A, 0x62, 0x05,
/* 10E0 */ 0x75, 0xB0, 0x31, 0x0C, 0x54, 0x6D, 0x0D, 0x36, 0x44, 0x23, 0x9A, 0x80, 0x6D, 0x33, 0x73, 0x44,
/* 10F0 */ 0x06, 0x46, 0x6D, 0x33, 0x46, 0x26, 0x33, 0x73, 0x6D, 0x97, 0x4A, 0x44, 0x23, 0x02, 0x6D, 0x08,
/* 1100 */ 0x94, 0x31, 0x0D, 0x54, 0x6D, 0x72, 0x03, 0x31, 0x06, 0x30, 0x62, 0xA7, 0x99, 0x37, 0x0A, 0xA8,
/* 1110 */ 0x94, 0x2E, 0x06, 0x0C, 0x7F, 0x46, 0xF1, 0x00, 0x57, 0x08, 0x0F, 0x99, 0x38, 0x52, 0x0E, 0x0B,
/* 1120 */ 0xB1, 0x3C, 0x10, 0x0B, 0xAA, 0x7F, 0x46, 0x49, 0x4C, 0x0F, 0x09, 0x37, 0x79, 0xA7, 0x73, 0x03,
/* 1130 */ 0x1F, 0xE3, 0x3A, 0x9D, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3, 0x3A, 0x5C, 0x1F, 0x79, 0xA7, 0x73,
/* 1140 */ 0x6B, 0x3D, 0x5C, 0x37, 0x3D, 0x07, 0x5B, 0xB4, 0x7A, 0x76, 0x87, 0xE3, 0x0D, 0x36, 0x37, 0xE3,
/* 1150 */ 0x06, 0x30, 0xA1, 0x1F, 0xE3, 0x3A, 0x96, 0x1F, 0xE3, 0x97, 0x67, 0x02, 0x10, 0x0A, 0xAA, 0x32,
/* 1160 */ 0x0B, 0x29, 0xF1, 0x8F, 0xA8, 0x7C, 0x1F, 0x23, 0x09, 0x04, 0x07, 0x0D, 0x0D, 0x6B, 0x05, 0x46,
/* 1170 */ 0x5D, 0xA4, 0x6B, 0x32, 0x0F, 0xA3, 0x19, 0x63, 0x0C, 0x06, 0x01, 0x00, 0xF6, 0x7F, 0x46, 0x05,
/* 1180 */ 0x00, 0x48, 0x09, 0x63, 0x7C, 0x19, 0x92, 0x5A, 0x1A, 0x07, 0x46, 0x1F, 0x32, 0x01, 0x6D, 0x8F,
/* 1190 */ 0x0D, 0x31, 0x33, 0x0F, 0xB2, 0x04, 0x4F, 0x94, 0x1F, 0x8F, 0x41, 0x1B, 0x31, 0x6F, 0x09, 0xD1,
/* 11A0 */ 0xAF, 0x01, 0x10, 0x0A, 0xD2, 0x72, 0x41, 0x45, 0x31, 0x3A, 0x41, 0x94, 0x1F, 0x03, 0x65, 0x22,
/* 11B0 */ 0x95, 0x65, 0x20, 0x24, 0x96, 0x27, 0xF9, 0x27, 0xF9, 0x10, 0x0C, 0xD2, 0x6A, 0xB8, 0x10, 0x0B,
/* 11C0 */ 0x5E, 0xB3, 0x18, 0x02, 0x6D, 0x09, 0x94, 0x44, 0x3A, 0x7C, 0x6D, 0x22, 0x7C, 0x31, 0x09, 0x99,
/* 11D0 */ 0x6D, 0x7F, 0x02, 0x31, 0x2A, 0x0C, 0x6F, 0x0F, 0x4A, 0x1F, 0xA2, 0x81, 0x33, 0x7D, 0x3A, 0x2F,
/* 11E0 */ 0x08, 0x36, 0x37, 0x2D, 0x6C, 0x0B, 0x30, 0x6B, 0x33, 0x94, 0x00, 0xD1, 0x5B, 0xA2, 0x1B, 0x7D,
/* 11F0 */ 0x6D, 0xD1, 0x04, 0x36, 0x2E, 0x2D, 0x2D, 0x03, 0x5B, 0x33, 0x46, 0x67, 0x2B, 0x18, 0x45, 0x21,
/* 1200 */ 0x22, 0x54, 0x10, 0x0F, 0xD2, 0x0B, 0xA3, 0x00, 0x0F, 0x54, 0x5D, 0xB9, 0x6D, 0x2D, 0x6C, 0x23,
/* 1210 */ 0x09, 0x5D, 0x84, 0x38, 0x07, 0x99, 0x00, 0x91, 0x45, 0x5D, 0x46, 0x28, 0x2A, 0x0A, 0x97, 0x29,
/* 1220 */ 0x00, 0x70, 0x0B, 0x28, 0x03, 0x85, 0x08, 0x0F, 0x75, 0x32, 0x94, 0x28, 0xA2, 0x0D, 0x00, 0x0A,
/* 1230 */ 0x5C, 0x30, 0x02, 0x06, 0x54, 0x1A, 0xB4, 0x81, 0x0D, 0x7A, 0x0D, 0x7A, 0x8F, 0x05, 0x1A, 0xEC,
/* 1240 */ 0xA2, 0x8D, 0x5C, 0x2D, 0x03, 0x1A, 0xD8, 0x7A, 0x0F, 0x81, 0x09, 0x96, 0x0B, 0x0F, 0x5F, 0x1A,
/* 1250 */ 0x08, 0x99, 0x0F, 0x0C, 0x00, 0x07, 0x95, 0xD1, 0x26, 0x2A, 0x0B, 0x95, 0x33, 0x0F, 0x0C, 0x0E,
/* 1260 */ 0x45, 0x26, 0x03, 0x46, 0x96, 0x00, 0x03, 0x67, 0x94, 0x1A, 0xA4, 0xA8, 0x6C, 0x70, 0x54, 0x44,
/* 1270 */ 0x7F, 0x7A, 0x5D, 0x73, 0x7C, 0x10, 0x0B, 0xD2, 0x2D, 0x0B, 0x5D, 0x23, 0x03, 0x31, 0x23, 0x9A,
/* 1280 */ 0x08, 0x7D, 0x00, 0x0A, 0x54, 0x00, 0x72, 0x9A, 0x78, 0x0D, 0x91, 0x0A, 0x2E, 0x75, 0x72, 0x02,
/* 1290 */ 0x6D, 0x78, 0x94, 0x21, 0xEC, 0x7A, 0x2B, 0x23, 0x95, 0x5D, 0xEE, 0x7F, 0x20, 0x01, 0xB4, 0xB2,
/* 12A0 */ 0x94, 0x5B, 0x8F, 0x55, 0x90, 0x31, 0xA4, 0x7F, 0x9A, 0x0A, 0x99, 0x1F, 0x06, 0x30, 0x0C, 0x5D,
/* 12B0 */ 0x91, 0xA1, 0x31, 0x0D, 0x36, 0x6D, 0x0D, 0x54, 0x10, 0x0B, 0x5E, 0xB3, 0x01, 0xF0, 0x6D, 0x8F,
/* 12C0 */ 0x0C, 0x31, 0x08, 0xBD, 0x2C, 0xC6, 0x10, 0x0A, 0xD2, 0x03, 0x89, 0x05, 0x78, 0x41, 0x7C, 0x31,
/* 12D0 */ 0xA4, 0x42, 0x2D, 0x2F, 0x2E, 0x50, 0x94, 0x21, 0x8F, 0xA1, 0x5D, 0x48, 0x79, 0x21, 0xD8, 0x4A,
/* 12E0 */ 0x28, 0x78, 0x7C, 0x21, 0x22, 0x45, 0x21, 0x2A, 0x2F, 0x2E, 0x50, 0x94, 0x21, 0x8F, 0x7C, 0x74,
/* 12F0 */ 0xAD, 0x40, 0x05, 0x40, 0x03, 0x10, 0x06, 0x1E, 0x8F, 0x99, 0x2B, 0x8F, 0x99, 0x2B, 0x07, 0x94,
/* 1300 */ 0xAD, 0x2B, 0x07, 0x54, 0x2C, 0x07, 0x54, 0xBA, 0x54, 0xBA, 0x54, 0xBA, 0x94, 0xAD, 0x2B, 0x8F,
/* 1310 */ 0x99, 0x2B, 0x8F, 0x99, 0x10, 0x09, 0x61, 0x03, 0x35, 0x2D, 0x01, 0x38, 0xEE, 0x04, 0x38, 0xF6,
/* 1320 */ 0x99, 0x2C, 0xA2, 0x0B, 0x35, 0xEC, 0x28, 0xEE, 0x04, 0x21, 0x33, 0x54, 0x2C, 0xA2, 0x0B, 0x35,
/* 1330 */ 0xD1, 0x35, 0x2D, 0x03, 0x21, 0x33, 0x54, 0x2C, 0x70, 0x0A, 0x2C, 0x3A, 0x81, 0xD7, 0x60, 0x06,
/* 1340 */ 0x36, 0x2C, 0x70, 0x0A, 0x35, 0x29, 0x35, 0xD8, 0x1B, 0x5D, 0x19, 0x10, 0x06, 0x1E, 0x2D, 0xA3,
/* 1350 */ 0x2E, 0x2D, 0xA3, 0x00, 0x48, 0xA0, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xA3, 0x6D, 0xEE, 0x05,
/* 1360 */ 0x5D, 0x48, 0xA0, 0xA3, 0x2E, 0x2D, 0xA3, 0x2E, 0x2D, 0xA3, 0x10, 0x0A, 0x5E, 0x52, 0x08, 0x08,
/* 1370 */ 0x05, 0x2C, 0xEC, 0xA1, 0x2B, 0x2A, 0x99, 0x2E, 0x3A, 0x0C, 0x75, 0x20, 0x06, 0x36, 0x03, 0x94,
/* 1380 */ 0x1F, 0xA4, 0xD1, 0x5D, 0x0B, 0x30, 0x6B, 0x07, 0x99, 0x5D, 0x2A, 0x0A, 0x10, 0x09, 0x64, 0xD2,
/* 1390 */ 0xE2, 0x52, 0x42, 0x42, 0x01, 0x1F, 0xEC, 0x41, 0x7A, 0x1F, 0xEC, 0x41, 0x7A, 0x10, 0x06, 0x00,
/* 13A0 */ 0x1E, 0xA6, 0x5D, 0x27, 0x96, 0x38, 0x48, 0x7F, 0x86, 0x21, 0x68, 0x0D, 0x0F, 0x09, 0x35, 0x33,
/* 13B0 */ 0x01, 0x10, 0x0A, 0xAB, 0xB7, 0x10, 0x0B, 0x64, 0x57, 0x35, 0xC5, 0xE1, 0x04, 0x0B, 0x9E, 0x06,
/* 13C0 */ 0x5D, 0x25, 0x7F, 0xA3, 0x25, 0xC4, 0x73, 0x00, 0x25, 0x49, 0x22, 0x95, 0x37, 0x3D, 0x2F, 0x1F,
/* 13D0 */ 0x29, 0x04, 0x0D, 0x0F, 0x0C, 0x04, 0x10, 0x09, 0xE2, 0x02, 0x9C, 0xFB, 0x48, 0x63, 0x54, 0x5B,
/* 13E0 */ 0x0B, 0x30, 0x49, 0x07, 0x0A, 0x5B, 0x23, 0xED, 0x8B, 0x34, 0x87, 0x38, 0x8B, 0x38, 0x52, 0x90,
/* 13F0 */ 0x2C, 0xEC, 0x49, 0x07, 0x09, 0x00, 0x52, 0x0E, 0x41, 0x6C, 0x48, 0x0A, 0x0E, 0xFB, 0x10, 0x0B,
/* 1400 */ 0xB3, 0x93, 0x01, 0x35, 0x91, 0x0C, 0x2C, 0x69, 0x2C, 0x69, 0x2C, 0x69, 0xF6, 0x0C, 0x0E, 0xAF,
/* 1410 */ 0x71, 0x04, 0x41, 0x71, 0xFC, 0x5D, 0x69, 0x78, 0x5F, 0x32, 0x71, 0xB4, 0x95, 0x88, 0x71, 0x06,
/* 1420 */ 0xA8, 0xB4, 0x4A, 0x5B, 0x07, 0x0D, 0x45, 0x03, 0x29, 0x10, 0x0A, 0xE2, 0x98, 0xC3, 0xDA, 0xF1,
/* 1430 */ 0x10, 0x07, 0x64, 0x6F, 0x3C, 0x2B, 0x33, 0x7F, 0x95, 0x2E, 0x23, 0x54, 0x2E, 0x8F, 0x0B, 0x93,
/* 1440 */ 0x01, 0x2E, 0x08, 0x99, 0x21, 0x0E, 0xE8, 0x5B, 0x63, 0x54, 0x00, 0xF6, 0xD8, 0x95, 0xAD, 0x2B,
/* 1450 */ 0x08, 0xDC, 0xEE, 0x08, 0x2C, 0x08, 0xDC, 0xEE, 0x08, 0x10, 0x0A, 0xA9, 0xCD, 0xED, 0x93, 0x07,
/* 1460 */ 0x0D, 0x08, 0x37, 0x68, 0x0C, 0x7F, 0x5A, 0x00, 0x0C, 0x41, 0xB2, 0x03, 0x1F, 0x8B, 0x05, 0x06,
/* 1470 */ 0x94, 0x37, 0x07, 0x99, 0x00, 0x3A, 0x5F, 0x1F, 0x06, 0x30, 0x0C, 0x57, 0x84, 0x31, 0xA4, 0x0C,
/* 1480 */ 0x41, 0x45, 0x37, 0xA4, 0x0E, 0xA8, 0x83, 0x5B, 0x09, 0x45, 0x03, 0x3C, 0x2B, 0x29, 0x65, 0x3C,
/* 1490 */ 0x2E, 0x0B, 0xA8, 0x99, 0x48, 0x0A, 0x63, 0x54, 0x1F, 0xA6, 0x02, 0x6D, 0x08, 0x5A, 0x0E, 0x67,
/* 14A0 */ 0x3C, 0xAC, 0x7D, 0x08, 0x41, 0x46, 0x03, 0x37, 0x07, 0x0C, 0xB4, 0x9E, 0xF1, 0x10, 0x0A, 0x64,
/* 14B0 */ 0x57, 0x35, 0xC5, 0xE1, 0x98, 0x9E, 0x05, 0x5B, 0xB4, 0x4A, 0xA8, 0x9A, 0x25, 0x4B, 0x0D, 0x36,
/* 14C0 */ 0x37, 0xE3, 0xC8, 0x5D, 0xF8, 0xF8, 0x10, 0x05, 0x1E, 0xD4, 0xD6, 0x02, 0x10, 0x05, 0x1E, 0xD4,
/* 14D0 */ 0xE1, 0xE1, 0x60, 0xC5, 0x60, 0x90, 0x2B, 0x97, 0x4A, 0x21, 0x06, 0x79, 0x21, 0x2D, 0x0A, 0x38,
/* 14E0 */ 0x52, 0x0D, 0x06, 0x10, 0x0A, 0x38, 0x9B, 0xF6, 0x06, 0x07, 0x01, 0x2C, 0xC5, 0xE1, 0x9A, 0x03,
/* 14F0 */ 0x5A, 0x00, 0x7F, 0x9A, 0x0C, 0x3B, 0x25, 0x02, 0x2A, 0x0A, 0x5D, 0x25, 0x02, 0xD1, 0x20, 0x0E,
/* 1500 */ 0x94, 0x54, 0x2E, 0xB4, 0x95, 0x94, 0x6D, 0x25, 0xB5, 0x20, 0x7F, 0x02, 0x0A, 0x94, 0x5D, 0x25,
/* 1510 */ 0x02, 0x03, 0x73, 0x9A, 0x25, 0x9A, 0x0B, 0x94, 0x00, 0x25, 0x9A, 0xB5, 0x02, 0x10, 0x05, 0x38,
/* 1520 */ 0x9B, 0x48, 0x04, 0x05, 0xF2, 0x18, 0xF2, 0x18, 0xF2, 0x18, 0x35, 0x30, 0x7C, 0x27, 0x73, 0x03,
/* 1530 */ 0x21, 0x8D, 0x3E, 0x05, 0x10, 0x0F, 0xAB, 0xB4, 0x43, 0xA5, 0x86, 0x8D, 0x9E, 0x04, 0x26, 0x0E,
/* 1540 */ 0x67, 0x7F, 0x4A, 0x63, 0xA1, 0x1A, 0x7F, 0x0C, 0x2A, 0x4A, 0x05, 0x7F, 0x03, 0x1A, 0x7F, 0x03,
/* 1550 */ 0x3A, 0x7A, 0x24, 0x7A, 0x1A, 0x84, 0x3A, 0x2F, 0x0B, 0xCA, 0xCA, 0x3B, 0x10, 0x0A, 0xAB, 0xC0,
/* 1560 */ 0xE3, 0xC8, 0x5D, 0xF8, 0xF8, 0x10, 0x0B, 0xE2, 0xF7, 0xC2, 0x10, 0x0B, 0xAB, 0xB4, 0x43, 0x22,
/* 1570 */ 0xB2, 0x5B, 0x0E, 0x67, 0x7F, 0xA3, 0x25, 0xC4, 0xE6, 0x06, 0x0D, 0x0F, 0x43, 0x5B, 0xC5, 0x60,
/* 1580 */ 0x3E, 0xB0, 0x5D, 0x19, 0x10, 0x0B, 0xAB, 0x32, 0x0C, 0x9E, 0x05, 0x29, 0x1F, 0x32, 0x41, 0x71,
/* 1590 */ 0xFC, 0x5D, 0x69, 0x78, 0x81, 0x32, 0x71, 0xB4, 0x95, 0x88, 0x71, 0x76, 0x41, 0x4A, 0x5B, 0x07,
/* 15A0 */ 0x0D, 0x45, 0x8B, 0x2C, 0x69, 0x2C, 0x69, 0x2C, 0x69, 0x38, 0x52, 0x0D, 0x4A, 0x28, 0x19, 0x10,
/* 15B0 */ 0x07, 0xAB, 0xB4, 0x0C, 0x8D, 0x7C, 0x2E, 0x0E, 0x67, 0x0B, 0x30, 0x03, 0x2E, 0x0E, 0x41, 0x2B,
/* 15C0 */ 0xB4, 0x4A, 0x02, 0x01, 0x2B, 0xF0, 0x2C, 0xC5, 0x60, 0xC5, 0x02, 0x10, 0x09, 0xAB, 0x01, 0x9C,
/* 15D0 */ 0x4A, 0xF1, 0x50, 0x73, 0x71, 0x97, 0x0F, 0x77, 0x06, 0x77, 0x37, 0x97, 0x45, 0x2C, 0x23, 0x9F,
/* 15E0 */ 0x02, 0x5D, 0xF6, 0x72, 0x54, 0x21, 0xA0, 0x73, 0x03, 0x37, 0xA4, 0x6D, 0x0C, 0x36, 0x37, 0x03,
/* 15F0 */ 0x0E, 0x0A, 0x05, 0x05, 0xB4, 0x7C, 0x37, 0xD8, 0x41, 0x0C, 0x2E, 0x06, 0x0C, 0x3E, 0xAF, 0x01,
/* 1600 */ 0x10, 0x07, 0xD2, 0x32, 0x07, 0x09, 0x04, 0x27, 0x36, 0x27, 0x36, 0x21, 0xA8, 0x54, 0x2E, 0xA8,
/* 1610 */ 0xA3, 0xF6, 0x0C, 0x99, 0x04, 0x01, 0x2B, 0x0B, 0x36, 0x27, 0x36, 0x27, 0x36, 0x27, 0x36, 0xD7,
/* 1620 */ 0x06, 0x2C, 0x2D, 0x49, 0x03, 0x38, 0x78, 0x5A, 0x38, 0x33, 0x0C, 0x9E, 0x55, 0x10, 0x0A, 0x6E,
/* 1630 */ 0x4D, 0x18, 0x47, 0xBC, 0x10, 0x09, 0x21, 0x4D, 0x25, 0x03, 0x5D, 0x0A, 0x36, 0x1F, 0x0A, 0x36,
/* 1640 */ 0x5D, 0x72, 0x6B, 0x06, 0x94, 0xA4, 0x71, 0x70, 0x0C, 0x32, 0x94, 0x5B, 0x72, 0x00, 0x8F, 0x05,
/* 1650 */ 0x5B, 0x2D, 0x03, 0x2D, 0x01, 0x5B, 0x2A, 0x05, 0x0C, 0x87, 0xA4, 0x94, 0x99, 0x2B, 0x22, 0x7F,
/* 1660 */ 0x03, 0x2B, 0x8F, 0x67, 0x28, 0x78, 0x95, 0x10, 0x0E, 0x6E, 0x4D, 0xB9, 0x09, 0x54, 0x33, 0x99,
/* 1670 */ 0x1A, 0xD8, 0x7A, 0x24, 0x95, 0x00, 0x07, 0x36, 0x1A, 0x8F, 0x6C, 0x7F, 0x0C, 0x00, 0x2D, 0x03,
/* 1680 */ 0x1A, 0x91, 0x55, 0x0F, 0x22, 0x81, 0x75, 0x1A, 0xA4, 0x94, 0x04, 0x95, 0x0D, 0x5F, 0x0C, 0x4A,
/* 1690 */ 0x44, 0x0E, 0x45, 0x06, 0x9D, 0x0B, 0x0F, 0x03, 0x0E, 0x95, 0x44, 0x0B, 0x4A, 0x09, 0x7C, 0x09,
/* 16A0 */ 0x5C, 0x54, 0x44, 0x08, 0x67, 0x0B, 0x0F, 0x03, 0x07, 0x45, 0xA3, 0x1A, 0x33, 0x46, 0x5F, 0x05,
/* 16B0 */ 0x0F, 0x7F, 0x02, 0x44, 0x03, 0x73, 0x81, 0x70, 0x67, 0x1F, 0x73, 0x0C, 0x5D, 0x73, 0x0C, 0x10,
/* 16C0 */ 0x09, 0x6E, 0x4D, 0x0A, 0x99, 0x32, 0x5A, 0x00, 0x70, 0x81, 0x2D, 0x05, 0x5B, 0x2D, 0x05, 0xB4,
/* 16D0 */ 0x0C, 0x2E, 0x70, 0x72, 0x05, 0x5D, 0xEE, 0x87, 0x6D, 0x2A, 0x45, 0x21, 0xEC, 0x3B, 0x5B, 0x2A,
/* 16E0 */ 0x8F, 0x0B, 0x2E, 0xD1, 0x51, 0x3B, 0x1F, 0x06, 0x94, 0x33, 0x5A, 0x01, 0x7F, 0x03, 0x5D, 0xB4,
/* 16F0 */ 0x7C, 0x10, 0x0A, 0x6E, 0x4D, 0xF5, 0x0B, 0xBB, 0x01, 0xFB, 0x10, 0x08, 0x6E, 0x4D, 0x06, 0x30,
/* 1700 */ 0x41, 0x5B, 0x06, 0x30, 0x41, 0x48, 0x74, 0x0B, 0x85, 0x5D, 0xF6, 0x46, 0x02, 0x2B, 0x50, 0x54,
/* 1710 */ 0x6D, 0xEE, 0x0C, 0x6D, 0x52, 0x73, 0x02, 0x21, 0x0C, 0x54, 0x21, 0x08, 0x46, 0x42, 0x5B, 0xEC,
/* 1720 */ 0x41, 0x5B, 0x0C, 0x41, 0x4A, 0x10, 0x06, 0x00, 0x1E, 0x33, 0x0C, 0x62, 0x21, 0x91, 0x9D, 0x21,
/* 1730 */ 0x2D, 0xF1, 0x6D, 0x75, 0x02, 0xD7, 0x02, 0xD7, 0x02, 0xD7, 0x02, 0x27, 0x30, 0x9A, 0x19, 0xD1,
/* 1740 */ 0x2C, 0x0D, 0x36, 0x21, 0x3A, 0x43, 0x38, 0xF6, 0xB4, 0x81, 0x27, 0x30, 0x02, 0xD7, 0x02, 0xD7,
/* 1750 */ 0x02, 0xD7, 0x02, 0xD7, 0x60, 0x2D, 0xF1, 0x6D, 0x2A, 0x9D, 0x2C, 0x06, 0x0C, 0x62, 0x10, 0x07,
/* 1760 */ 0x9B, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0x10, 0x06, 0x1E, 0x09, 0x0E, 0xDE,
/* 1770 */ 0x2C, 0x09, 0x73, 0x02, 0x21, 0x98, 0x54, 0x2C, 0x2A, 0xF4, 0x30, 0xF4, 0x99, 0x2C, 0x91, 0xF4,
/* 1780 */ 0x99, 0x2C, 0x70, 0x1B, 0x38, 0xEE, 0x0A, 0x38, 0xF6, 0x0D, 0x95, 0x21, 0x70, 0x86, 0x6D, 0xF6,
/* 1790 */ 0x94, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x33, 0x99, 0x21, 0x98, 0x54,
/* 17A0 */ 0x21, 0x2D, 0x2F, 0x2B, 0x09, 0x0E, 0xDE, 0x10, 0x09, 0xB3, 0xFE, 0x48, 0x3C, 0x38, 0xEE, 0x9F,
/* 17B0 */ 0x88, 0x83, 0x31, 0x33, 0x41, 0x7D, 0x32, 0xDE, 0x58, 0x0D, 0x0E, 0x83, 0x10, 0x00, 0x00, 0x00,
/* 17C0 */ 0x03, 0x00, 0x27, 0x00, 0x5F, 0x00, 0x94, 0x00, 0xDD, 0x01, 0x21, 0x01, 0x31, 0x01, 0x7A, 0x01,
/* 17D0 */ 0x8F, 0x01, 0xFB, 0x02, 0x35, 0x02, 0x72, 0x02, 0x8A, 0x02, 0x97, 0x02, 0xF0, 0x03, 0x00, 0x03,
/* 17E0 */ 0x21, 0x03, 0x35, 0x03, 0x5C, 0x03, 0x87, 0x03, 0x9A, 0x03, 0xCE, 0x04, 0x10, 0x04, 0x17, 0x04,
/* 17F0 */ 0x2D, 0x04, 0x4A, 0x04, 0x82, 0x04, 0xC1, 0x04, 0xE8, 0x05, 0x3A, 0x05, 0x8C, 0x05, 0xC3, 0x05,
/* 1800 */ 0xD7, 0x05, 0xEC, 0x06, 0x06, 0x06, 0x1C, 0x06, 0x33, 0x06, 0x4E, 0x06, 0x9A, 0x06, 0xE1, 0x06,
/* 1810 */ 0xF4, 0x07, 0x07, 0x07, 0x1C, 0x07, 0x33, 0x07, 0x48, 0x07, 0x5C, 0x07, 0x74, 0x07, 0x84, 0x07,
/* 1820 */ 0xD2, 0x07, 0xF2, 0x08, 0x06, 0x08, 0x1D, 0x08, 0x38, 0x08, 0x4C, 0x08, 0x5F, 0x08, 0x87, 0x08,
/* 1830 */ 0xE9, 0x08, 0xFD, 0x09, 0x11, 0x09, 0x28, 0x09, 0x30, 0x09, 0x4B, 0x09, 0x77, 0x09, 0xC4, 0x09,
/* 1840 */ 0xD8, 0x09, 0xED, 0x0A, 0x02, 0x0A, 0x16, 0x0A, 0x1E, 0x0A, 0x37, 0x0A, 0x8C, 0x0A, 0xC8, 0x0A,
/* 1850 */ 0xE0, 0x0A, 0xF9, 0x0B, 0x15, 0x0B, 0x23, 0x0B, 0x3A, 0x0B, 0x4E, 0x0B, 0x69, 0x0B, 0x81, 0x0B,
/* 1860 */ 0xCF, 0x0B, 0xE6, 0x0B, 0xFA, 0x0C, 0x0F, 0x0C, 0x28, 0x0C, 0x3B, 0x0C, 0x4E, 0x0C, 0x68, 0x0C,
/* 1870 */ 0xB6, 0x0C, 0xCD, 0x0C, 0xE5, 0x0C, 0xFE, 0x0D, 0x0B, 0x0D, 0x25, 0x0D, 0x5A, 0x04, 0x00, 0x10,
/* 1880 */ 0x05, 0xAB, 0x0B, 0x4B, 0x2C, 0x8A, 0x2A, 0x81, 0x27, 0x4B, 0x2E, 0x8E, 0x0E, 0x96, 0x35, 0x94,
/* 1890 */ 0x35, 0x94, 0x2C, 0xA2, 0x0A, 0x2C, 0x70, 0x0B, 0x2C, 0x70, 0x0C, 0x1A, 0x78, 0x0C, 0x2C, 0x69,
/* 18A0 */ 0x38, 0xF6, 0x46, 0x10, 0x09, 0xCD, 0x3A, 0x04, 0x35, 0x0D, 0x7A, 0x35, 0xD5, 0x6D, 0xF6, 0x0D,
/* 18B0 */ 0x73, 0x43, 0x52, 0x41, 0x7C, 0x5B, 0x0B, 0x94, 0x57, 0x07, 0x5B, 0x23, 0xED, 0x69, 0x34, 0x87,
/* 18C0 */ 0x38, 0x8B, 0x38, 0x52, 0x46, 0x35, 0x0D, 0x99, 0x57, 0x06, 0x5B, 0x33, 0x41, 0x7A, 0x2E, 0x06,
/* 18D0 */ 0x63, 0x86, 0x19, 0x0E, 0x5C, 0x35, 0x0E, 0x7A, 0x35, 0x0E, 0x7A, 0x10, 0x0A, 0xFE, 0x33, 0x0C,
/* 18E0 */ 0x67, 0x0B, 0x03, 0x00, 0xF6, 0x41, 0x7A, 0x5B, 0x0C, 0x94, 0x88, 0x0C, 0x20, 0x90, 0xA4, 0x2E,
/* 18F0 */ 0x18, 0x2C, 0x18, 0x21, 0x91, 0x41, 0x03, 0x1F, 0x32, 0x72, 0x4A, 0x0D, 0x86, 0x5B, 0x18, 0x5D,
/* 1900 */ 0x19, 0x46, 0x2C, 0x70, 0x0C, 0x21, 0x8D, 0x36, 0x42, 0x01, 0x1F, 0x08, 0x89, 0x6B, 0x08, 0x89,
/* 1910 */ 0x10, 0x0A, 0x6E, 0xAA, 0x19, 0x83, 0x38, 0x3F, 0x6B, 0x09, 0x0F, 0x0C, 0x09, 0x3E, 0x0A, 0x0A,
/* 1920 */ 0x95, 0x1F, 0x50, 0x0F, 0x41, 0xB0, 0x37, 0x08, 0x0F, 0x4B, 0x06, 0xB4, 0x09, 0x5B, 0x0C, 0x96,
/* 1930 */ 0x5D, 0x07, 0x67, 0x5B, 0x0E, 0x5C, 0x5D, 0x2A, 0x5B, 0x0C, 0x96, 0x5D, 0x07, 0x67, 0x5B, 0x08,
/* 1940 */ 0x0F, 0x4B, 0x06, 0xB4, 0x09, 0x1F, 0xA4, 0x22, 0x41, 0xB0, 0x1F, 0x09, 0x0F, 0x0C, 0x09, 0x3E,
/* 1950 */ 0x0A, 0x0B, 0x95, 0x31, 0xA4, 0x83, 0x38, 0x3F, 0x02, 0x10, 0x0A, 0x5E, 0xB3, 0x01, 0x7F, 0x02,
/* 1960 */ 0x5D, 0x24, 0x7A, 0x31, 0x08, 0x99, 0x6F, 0x5A, 0x01, 0x29, 0x5D, 0x07, 0x36, 0x37, 0x09, 0x3B,
/* 1970 */ 0x0C, 0x67, 0x48, 0x94, 0x03, 0x54, 0x2E, 0x0A, 0x67, 0x09, 0x0F, 0xA1, 0x6D, 0x78, 0x94, 0x2E,
/* 1980 */ 0x0B, 0xA8, 0x90, 0x37, 0x07, 0x09, 0x0B, 0x0F, 0x4A, 0x09, 0x56, 0x5B, 0x2A, 0x0B, 0x2B, 0x0B,
/* 1990 */ 0xA8, 0x90, 0x37, 0x9C, 0x72, 0x9E, 0xB0, 0x2E, 0x2A, 0x0B, 0x2C, 0x2A, 0x0B, 0x10, 0x07, 0x2C,
/* 19A0 */ 0x9B, 0xA2, 0x0C, 0xD9, 0xD9, 0xD9, 0x44, 0xB3, 0xA2, 0x0C, 0xD9, 0xD9, 0xD9, 0x10, 0x0A, 0xD2,
/* 19B0 */ 0x6F, 0x0A, 0x0E, 0xFB, 0x48, 0x0E, 0xA8, 0x95, 0xEE, 0x0A, 0x05, 0x07, 0x86, 0x5B, 0x2D, 0x05,
/* 19C0 */ 0x34, 0x0F, 0x62, 0xED, 0x0D, 0x73, 0x9F, 0x2E, 0x08, 0x4A, 0x0B, 0x0F, 0x7D, 0xA4, 0x99, 0x00,
/* 19D0 */ 0x03, 0x72, 0x37, 0xA2, 0x1B, 0x00, 0x2D, 0x5B, 0x0C, 0x46, 0x9C, 0x0F, 0x09, 0x5B, 0x3F, 0xA8,
/* 19E0 */ 0xB0, 0x5D, 0x48, 0x08, 0xF0, 0x21, 0x33, 0x94, 0x52, 0x0C, 0x06, 0xA0, 0x99, 0x5B, 0x0B, 0x73,
/* 19F0 */ 0x46, 0x20, 0x98, 0x0D, 0x4A, 0xF1, 0x10, 0x09, 0x00, 0x9B, 0x19, 0x0C, 0x0E, 0x53, 0x09, 0x9F,
/* 1A00 */ 0x5B, 0x2A, 0x83, 0x46, 0x37, 0xA4, 0x0C, 0x0E, 0x53, 0x09, 0x9F, 0x10, 0x0F, 0x64, 0x6F, 0x08,
/* 1A10 */ 0x0B, 0x0C, 0x0A, 0x06, 0x2E, 0x06, 0x41, 0x4A, 0x6B, 0x76, 0x4B, 0x02, 0x57, 0xD8, 0xB0, 0x26,
/* 1A20 */ 0xA4, 0x3E, 0x02, 0x88, 0x45, 0x58, 0x0F, 0x09, 0x44, 0x06, 0x5C, 0x03, 0x30, 0x99, 0x00, 0x0D,
/* 1A30 */ 0xA1, 0x26, 0x0B, 0x5F, 0xD8, 0x77, 0x07, 0x01, 0x00, 0x08, 0x7A, 0x26, 0x0C, 0x81, 0x0C, 0x7C,
/* 1A40 */ 0x6D, 0x33, 0x5C, 0x26, 0x0D, 0x81, 0x0C, 0x7C, 0x6D, 0x33, 0x5C, 0x26, 0x0B, 0x5F, 0xD8, 0x77,
/* 1A50 */ 0x07, 0x9A, 0x07, 0x7C, 0x26, 0x07, 0x7C, 0x91, 0x94, 0x00, 0x0C, 0x5F, 0x28, 0x6F, 0x4A, 0x1C,
/* 1A60 */ 0x0D, 0x45, 0x02, 0x05, 0x95, 0x31, 0x08, 0x4A, 0x04, 0x5D, 0x68, 0x67, 0x6B, 0x2D, 0x9E, 0x46,
/* 1A70 */ 0x04, 0x5B, 0xA0, 0x0E, 0x9E, 0x08, 0x02, 0x10, 0x09, 0xD2, 0x32, 0x0B, 0xB4, 0xB2, 0x2B, 0x07,
/* 1A80 */ 0x41, 0x6C, 0x48, 0x09, 0x05, 0x76, 0x95, 0x35, 0x0E, 0x45, 0x00, 0x48, 0x0A, 0x72, 0x45, 0x2E,
/* 1A90 */ 0x0D, 0x45, 0x03, 0x0E, 0x45, 0x48, 0x0F, 0x45, 0x2A, 0xB0, 0x1F, 0xA4, 0x63, 0x84, 0xF6, 0x0D,
/* 1AA0 */ 0x45, 0x58, 0x0A, 0x38, 0xAE, 0x19, 0x74, 0x42, 0x01, 0x31, 0x6F, 0x41, 0x36, 0x31, 0x6F, 0x41,
/* 1AB0 */ 0x36, 0x10, 0x0C, 0xE2, 0x33, 0x43, 0x00, 0x32, 0x0D, 0x04, 0x31, 0x6F, 0xB4, 0x0C, 0x00, 0x02,
/* 1AC0 */ 0x29, 0x1F, 0x50, 0x3B, 0x22, 0x7C, 0x1F, 0x0A, 0x85, 0x09, 0x5A, 0xB5, 0x02, 0x03, 0x73, 0x03,
/* 1AD0 */ 0x1F, 0x8B, 0x32, 0x71, 0x70, 0x5C, 0x02, 0xF0, 0x37, 0x06, 0x30, 0xB0, 0x2A, 0xA1, 0x37, 0x09,
/* 1AE0 */ 0x99, 0x00, 0x08, 0x94, 0x5B, 0x0C, 0x45, 0x00, 0x24, 0x0C, 0x48, 0x07, 0x6D, 0x68, 0x10, 0x0A,
/* 1AF0 */ 0x8E, 0xE2, 0x19, 0x74, 0x42, 0x03, 0x37, 0x03, 0x41, 0x71, 0x03, 0x41, 0x71, 0x1A, 0x0A, 0x4A,
/* 1B00 */ 0x35, 0x0A, 0x4A, 0x35, 0x0A, 0x4A, 0x10, 0x08, 0x8E, 0xE2, 0x19, 0x04, 0x42, 0x03, 0x00, 0x52,
/* 1B10 */ 0xE8, 0x52, 0xE8, 0x10, 0x0B, 0x00, 0x64, 0x06, 0x0C, 0x9E, 0xF1, 0x00, 0x0B, 0x62, 0x03, 0xA0,
/* 1B20 */ 0x0E, 0x04, 0x37, 0x07, 0x2F, 0x6D, 0x0A, 0xB0, 0x1F, 0x0E, 0x09, 0x03, 0x0F, 0x4A, 0xAD, 0x7C,
/* 1B30 */ 0x26, 0x6F, 0x7C, 0x03, 0x0F, 0x8C, 0x0B, 0x00, 0x0D, 0x09, 0x44, 0x32, 0x0F, 0xA6, 0x46, 0x53,
/* 1B40 */ 0x0C, 0x0B, 0x31, 0x03, 0x7A, 0x03, 0x9D, 0x0F, 0x9A, 0x0D, 0x0A, 0x44, 0xA4, 0x62, 0x03, 0x0F,
/* 1B50 */ 0x02, 0x0D, 0x09, 0x01, 0x9D, 0x1F, 0x09, 0x0E, 0x02, 0x06, 0x57, 0x06, 0x08, 0xA1, 0x1F, 0x50,
/* 1B60 */ 0x0C, 0x53, 0x58, 0x5C, 0x5B, 0xAC, 0x73, 0x0C, 0x04, 0x38, 0x48, 0x01, 0x10, 0x07, 0x00, 0x9B,
/* 1B70 */ 0x19, 0x04, 0x42, 0x01, 0x5B, 0x33, 0xA8, 0x7A, 0x5B, 0x33, 0xA8, 0x7A, 0x10, 0x09, 0xAA, 0x3F,
/* 1B80 */ 0x0E, 0x9F, 0x21, 0xEC, 0x94, 0x00, 0x52, 0x0F, 0x4B, 0x8F, 0x01, 0x37, 0x33, 0x45, 0x5D, 0xB4,
/* 1B90 */ 0x02, 0x52, 0x0F, 0x4B, 0x8F, 0x01, 0x2E, 0xEC, 0x94, 0x2B, 0x3F, 0x0E, 0x9F, 0x10, 0x0A, 0x6E,
/* 1BA0 */ 0xFE, 0x34, 0x5F, 0x34, 0xDB, 0x2B, 0x74, 0x42, 0x03, 0x37, 0xA2, 0xA8, 0x45, 0x37, 0xA2, 0xA8,
/* 1BB0 */ 0x45, 0x10, 0x07, 0x6D, 0xB3, 0x52, 0x0C, 0x9E, 0x05, 0x5D, 0x48, 0x63, 0x2F, 0x5B, 0x3F, 0x08,
/* 1BC0 */ 0x06, 0x36, 0x35, 0xB4, 0x03, 0x2C, 0x09, 0x0F, 0x09, 0x2C, 0x08, 0x95, 0x2C, 0x09, 0x0F, 0x0C,
/* 1BD0 */ 0x04, 0xAD, 0x2E, 0x18, 0x99, 0x2E, 0x18, 0x36, 0x10, 0x07, 0x64, 0x57, 0x60, 0x8F, 0x95, 0x5D,
/* 1BE0 */ 0x48, 0x63, 0x7A, 0x5D, 0x52, 0x02, 0x01, 0x0E, 0x7C, 0x6D, 0xF6, 0x0D, 0x95, 0x2C, 0x8F, 0x0B,
/* 1BF0 */ 0x60, 0x01, 0x0C, 0x96, 0x5D, 0xF6, 0x01, 0x24, 0x09, 0x00, 0x52, 0x67, 0x22, 0x7C, 0x2B, 0x07,
/* 1C00 */ 0x0D, 0x4A, 0x06, 0x10, 0x06, 0x61, 0x33, 0x28, 0x52, 0x22, 0x03, 0x21, 0x08, 0x0F, 0x94, 0x2B,
/* 1C10 */ 0x70, 0x0A, 0x04, 0x21, 0x33, 0x02, 0x10, 0x0B, 0xAB, 0xEB, 0x37, 0xEB, 0x37, 0xEB, 0x37, 0xEB,
/* 1C20 */ 0x37, 0xEB, 0x37, 0xEB, 0x37, 0xEB, 0x00, 0x25, 0x9A, 0xEC, 0x6C, 0x25, 0x08, 0x08, 0x0F, 0x54,
/* 1C30 */ 0x00, 0x25, 0x46, 0x99, 0x37, 0xB4, 0x0C, 0x0E, 0xDE, 0x7D, 0x00, 0x0E, 0x45, 0x00, 0x6F, 0x2E,
/* 1C40 */ 0x29, 0x35, 0x0E, 0x67, 0x35, 0x0E, 0x67, 0x28, 0x52, 0x02, 0x10, 0x0E, 0xFE, 0x58, 0x0D, 0x41,
/* 1C50 */ 0x36, 0x44, 0x50, 0x89, 0x5C, 0x44, 0x08, 0x41, 0x7C, 0x07, 0x36, 0x26, 0x3A, 0x41, 0xD3, 0x44,
/* 1C60 */ 0x3D, 0xD3, 0x44, 0x22, 0x41, 0xD3, 0x44, 0x8F, 0xA8, 0xD3, 0x31, 0x0B, 0x41, 0xD3, 0x1F, 0x06,
/* 1C70 */ 0x0A, 0x72, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xEE,
/* 1C80 */ 0xD3, 0xEE, 0xD3, 0xEE, 0xD3, 0xF6, 0x06, 0x53, 0x02, 0x07, 0x05, 0x01, 0x10, 0x05, 0x21, 0x8E,
/* 1C90 */ 0xE2, 0xA5, 0xF3, 0x10, 0x06, 0x2C, 0xE2, 0xE2, 0xAD, 0x28, 0x48, 0x95, 0x35, 0x91, 0x1B, 0x6D,
/* 1CA0 */ 0xF6, 0x88, 0x9D, 0x19, 0x7F, 0x7C, 0x19, 0xA5, 0x9F, 0x10, 0x07, 0xFE, 0x4F, 0x9D, 0x5D, 0x48,
/* 1CB0 */ 0x22, 0x54, 0x21, 0x0C, 0x09, 0x0C, 0x9D, 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D,
/* 1CC0 */ 0x00, 0x27, 0x9D, 0x00, 0x27, 0x9D, 0x10, 0x09, 0xFE, 0x07, 0x0D, 0x4A, 0x08, 0x2B, 0x08, 0xE8,
/* 1CD0 */ 0x37, 0xA2, 0x0D, 0x05, 0xB9, 0x31, 0x32, 0x99, 0x97, 0x5C, 0x1F, 0x33, 0x54, 0x33, 0x54, 0x1F,
/* 1CE0 */ 0x32, 0x99, 0x97, 0x5C, 0x37, 0xA2, 0x0D, 0x05, 0xEC, 0x20, 0x08, 0xE8, 0x2E, 0x07, 0x0D, 0x4A,
/* 1CF0 */ 0x08, 0x28, 0xAE, 0x19, 0x74, 0x42, 0x6B, 0x33, 0x41, 0x54, 0x1F, 0x33, 0x41, 0x54, 0x10, 0x0C,
/* 1D00 */ 0xAB, 0x06, 0x0D, 0x02, 0x5D, 0x88, 0x02, 0x37, 0x70, 0x0C, 0xA4, 0xB4, 0x1B, 0x37, 0x08, 0x94,
/* 1D10 */ 0x00, 0x08, 0x7D, 0xA4, 0xF0, 0x50, 0x54, 0x37, 0x06, 0x73, 0x33, 0x90, 0x44, 0x6F, 0x90, 0x01,
/* 1D20 */ 0x90, 0x1F, 0xD8, 0x4A, 0x00, 0x2D, 0x0D, 0x78, 0x0E, 0x02, 0x03, 0x46, 0x03, 0x1F, 0x22, 0x7C,
/* 1D30 */ 0x24, 0x7C, 0x44, 0x6F, 0x0E, 0x96, 0xA4, 0xB4, 0x09, 0x5B, 0x68, 0x6D, 0x68, 0x10, 0x12, 0x6E,
/* 1D40 */ 0xB3, 0x0A, 0x43, 0x44, 0x4F, 0xFD, 0x9D, 0x00, 0x97, 0x0C, 0x5D, 0x03, 0x31, 0x0B, 0x9D, 0x5D,
/* 1D50 */ 0xD5, 0x97, 0x0A, 0x44, 0x0B, 0x9D, 0x33, 0x4A, 0x5D, 0xD5, 0x5B, 0x0C, 0x5C, 0x97, 0x0C, 0x52,
/* 1D60 */ 0x67, 0xC7, 0x68, 0x02, 0x10, 0x12, 0x6E, 0xB3, 0x0A, 0x43, 0x44, 0x4F, 0xFD, 0x9D, 0x00, 0x97,
/* 1D70 */ 0x0C, 0x00, 0x08, 0x3E, 0x83, 0x1A, 0x0B, 0x9D, 0x5D, 0xD5, 0x09, 0x73, 0x95, 0x1A, 0x0B, 0x9D,
/* 1D80 */ 0x33, 0x4A, 0x00, 0x4E, 0x4E, 0x4A, 0x1F, 0x0C, 0x5C, 0x38, 0x08, 0x95, 0x31, 0x03, 0x67, 0x38,
/* 1D90 */ 0x03, 0x3E, 0x02, 0x31, 0x0A, 0x9D, 0x6D, 0x03, 0x3E, 0x03, 0x26, 0x6F, 0x0F, 0xA1, 0x00, 0x32,
/* 1DA0 */ 0x0E, 0x9D, 0x65, 0x44, 0x09, 0x96, 0x6D, 0x09, 0x41, 0x26, 0xA2, 0x02, 0x6D, 0x09, 0x73, 0x4A,
/* 1DB0 */ 0x26, 0x08, 0x95, 0x35, 0x68, 0x02, 0x10, 0x12, 0x6E, 0xB3, 0x0A, 0x43, 0x1A, 0x32, 0x22, 0xB2,
/* 1DC0 */ 0x38, 0x70, 0x02, 0x1A, 0x23, 0x3B, 0x5D, 0x08, 0x95, 0x26, 0x33, 0x05, 0x05, 0x0E, 0x7C, 0x00,
/* 1DD0 */ 0xA4, 0xB4, 0x03, 0x44, 0x33, 0x0F, 0x9F, 0x6D, 0x07, 0x45, 0x1F, 0x06, 0xB4, 0x86, 0x5D, 0x0E,
/* 1DE0 */ 0x7A, 0x37, 0x24, 0x09, 0x97, 0x0C, 0x5D, 0x03, 0x26, 0x07, 0x3C, 0x22, 0x09, 0x00, 0xD5, 0x97,
/* 1DF0 */ 0x0A, 0x28, 0x03, 0x41, 0x03, 0x05, 0x4A, 0x5D, 0xD5, 0x1A, 0x03, 0x09, 0x0B, 0x09, 0x9A, 0x0C,
/* 1E00 */ 0x5C, 0x97, 0x0C, 0x52, 0x67, 0xC7, 0x68, 0x02, 0x10, 0x09, 0xE2, 0x32, 0x0E, 0x1B, 0x2C, 0x0C,
/* 1E10 */ 0x99, 0x2C, 0xEC, 0xF4, 0x0E, 0x1B, 0x5D, 0xAE, 0x93, 0x02, 0x01, 0x2C, 0x08, 0x3B, 0x19, 0xEC,
/* 1E20 */ 0x02, 0x2B, 0x51, 0x0F, 0x45, 0x19, 0x72, 0x1B, 0x2B, 0x8F, 0x0C, 0xED, 0x0A, 0x54, 0x00, 0x33,
/* 1E30 */ 0x01, 0x5B, 0x2D, 0xB2, 0xD8, 0x86, 0x31, 0x6F, 0x0E, 0xA8, 0x4A, 0x20, 0x98, 0x0E, 0xFB, 0x10,
/* 1E40 */ 0x0B, 0x6E, 0xA0, 0x02, 0x35, 0x22, 0x62, 0x21, 0x58, 0xB4, 0x45, 0x35, 0x4E, 0x07, 0x00, 0xAE,
/* 1E50 */ 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x00, 0xA9, 0x8C, 0x02, 0x21, 0x58, 0x7D, 0x28, 0x72, 0xB2, 0x21,
/* 1E60 */ 0x09, 0x0A, 0x04, 0x6D, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x2E, 0x48, 0x0D, 0x0F, 0x1B, 0x2B,
/* 1E70 */ 0x50, 0x73, 0x1B, 0x2E, 0x22, 0x0C, 0x88, 0x95, 0x00, 0xF6, 0x07, 0x6D, 0x08, 0x03, 0xAE, 0xCC,
/* 1E80 */ 0xC1, 0xFA, 0x10, 0x0B, 0x8E, 0x01, 0xA5, 0x0A, 0x05, 0xAF, 0x2E, 0x09, 0x73, 0x99, 0x2E, 0x09,
/* 1E90 */ 0x77, 0xA5, 0x0A, 0x00, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0B, 0x8E, 0x0A, 0x0E, 0x6C, 0x92, 0x0A,
/* 1EA0 */ 0x5B, 0x70, 0x0C, 0x00, 0x84, 0x5B, 0x0A, 0x0E, 0x6C, 0x92, 0x0A, 0xAE, 0xCC, 0xC1, 0xFA, 0x10,
/* 1EB0 */ 0x0B, 0x28, 0x03, 0x0C, 0x0E, 0x43, 0x2B, 0x3A, 0xB4, 0x0C, 0x19, 0x45, 0x3A, 0x21, 0xD1, 0x87,
/* 1EC0 */ 0x6D, 0x03, 0x0C, 0x0E, 0x43, 0x00, 0xAE, 0xCC, 0xC1, 0xFA, 0x10, 0x0F, 0xCD, 0x24, 0x89, 0x02,
/* 1ED0 */ 0x44, 0xA2, 0x41, 0x46, 0x31, 0x06, 0x30, 0xF0, 0x74, 0x03, 0x31, 0x0C, 0x99, 0xA3, 0x37, 0x70,
/* 1EE0 */ 0x49, 0x54, 0x5B, 0x07, 0x54, 0x03, 0x0F, 0x45, 0x42, 0x44, 0xEC, 0x03, 0xA2, 0x41, 0x26, 0x70,
/* 1EF0 */ 0x0D, 0x5D, 0x3D, 0x26, 0x08, 0x0F, 0x45, 0x65, 0x72, 0x6B, 0x72, 0x41, 0x7A, 0x31, 0x03, 0x89,
/* 1F00 */ 0x9D, 0x31, 0x2D, 0x0B, 0x5D, 0x97, 0x45, 0x74, 0x03, 0x28, 0xF0, 0x6D, 0x03, 0x41, 0x4A, 0x38,
/* 1F10 */ 0xB5, 0x02, 0x5D, 0xA4, 0x41, 0x4A, 0x10, 0x0A, 0xCD, 0x98, 0x0D, 0x4A, 0xF1, 0x76, 0x41, 0xA1,
/* 1F20 */ 0x78, 0x0F, 0x09, 0x05, 0x92, 0x05, 0x37, 0x0B, 0x94, 0x5D, 0xA4, 0x37, 0x18, 0x03, 0x21, 0xB5,
/* 1F30 */ 0xED, 0x8A, 0x06, 0x46, 0x21, 0x33, 0x73, 0x2C, 0x23, 0x60, 0x0D, 0x54, 0x34, 0x67, 0x53, 0x8C,
/* 1F40 */ 0x06, 0x5B, 0x75, 0x41, 0x20, 0x07, 0x72, 0x4A, 0x05, 0x21, 0x22, 0x03, 0x35, 0xD1, 0x05, 0x6D,
/* 1F50 */ 0x48, 0x05, 0x09, 0x4A, 0x21, 0x2D, 0x45, 0x21, 0x07, 0x0D, 0x0E, 0x0B, 0x02, 0x10, 0x09, 0x6E,
/* 1F60 */ 0x09, 0x06, 0x26, 0x78, 0x43, 0x21, 0x8C, 0x30, 0x7C, 0x38, 0x48, 0x07, 0x1B, 0x5E, 0x3D, 0xEA,
/* 1F70 */ 0x10, 0x09, 0x00, 0xA9, 0x06, 0x0A, 0x38, 0x52, 0xB9, 0x2E, 0x2A, 0x45, 0x03, 0x19, 0xAF, 0x6B,
/* 1F80 */ 0x2E, 0x4C, 0xEA, 0x10, 0x09, 0x6E, 0x06, 0x54, 0x2B, 0x33, 0xA8, 0x6C, 0x52, 0x99, 0x8F, 0x04,
/* 1F90 */ 0x2E, 0x08, 0x03, 0x6F, 0x09, 0x5E, 0x3D, 0xEA, 0x10, 0x09, 0x28, 0xA9, 0x52, 0x0D, 0x0D, 0x02,
/* 1FA0 */ 0xDF, 0x37, 0x08, 0x54, 0x2A, 0x0B, 0x52, 0x0D, 0x0D, 0x02, 0xDF, 0x00, 0xB1, 0x4C, 0xEA, 0x10,
/* 1FB0 */ 0x05, 0x38, 0xB1, 0x51, 0x03, 0x35, 0x08, 0x94, 0xED, 0x06, 0x72, 0xA1, 0x38, 0xF6, 0x09, 0x0A,
/* 1FC0 */ 0x5D, 0xAE, 0x66, 0xB6, 0x10, 0x05, 0x1A, 0xB1, 0x3F, 0x05, 0x2C, 0x06, 0x29, 0x21, 0x0A, 0x46,
/* 1FD0 */ 0x56, 0x5B, 0x33, 0x49, 0x38, 0xAE, 0x66, 0xB6, 0x10, 0x05, 0x26, 0x27, 0x67, 0x03, 0x21, 0xD8,
/* 1FE0 */ 0x46, 0x02, 0x2E, 0x08, 0x4A, 0xA7, 0x4A, 0x00, 0x48, 0x56, 0x00, 0x06, 0x6C, 0xAE, 0x66, 0xB6,
/* 1FF0 */ 0x10, 0x05, 0x26, 0xAE, 0x92, 0xE4, 0x5B, 0x84, 0xD8, 0x7C, 0x5B, 0x92, 0xE4, 0xAE, 0x66, 0xB6,
/* 2000 */ 0x10, 0x0C, 0xAA, 0x09, 0x73, 0x4A, 0x0A, 0x05, 0x5D, 0x7E, 0x45, 0x37, 0x2D, 0xDE, 0x92, 0x94,
/* 2010 */ 0x1F, 0x09, 0x94, 0x5D, 0xB5, 0x02, 0x31, 0x09, 0x94, 0x6D, 0xB4, 0x7C, 0x44, 0x03, 0x75, 0xDE,
/* 2020 */ 0x03, 0x00, 0x0C, 0x99, 0x44, 0x0B, 0x73, 0x85, 0x0B, 0x94, 0x44, 0x0B, 0x73, 0x85, 0x0B, 0x99,
/* 2030 */ 0x31, 0x09, 0x94, 0x6D, 0x0C, 0x54, 0x31, 0x09, 0x94, 0x6D, 0xB4, 0x7C, 0x31, 0x09, 0x94, 0x00,
/* 2040 */ 0x33, 0x90, 0x31, 0x2D, 0xDE, 0x92, 0x94, 0x7E, 0x95, 0x37, 0x2D, 0x46, 0x0A, 0x05, 0x10, 0x0C,
/* 2050 */ 0x5E, 0xF6, 0x0D, 0xB2, 0x07, 0x43, 0x37, 0xA4, 0x0E, 0x41, 0x02, 0x52, 0x0C, 0x08, 0x07, 0x0D,
/* 2060 */ 0x0E, 0x05, 0x1A, 0xA9, 0x63, 0x03, 0x5D, 0x29, 0x25, 0x96, 0x5D, 0x29, 0xBF, 0xD0, 0x10, 0x0D,
/* 2070 */ 0xA9, 0x06, 0x56, 0x2C, 0xD1, 0x05, 0x21, 0xAC, 0x0E, 0x94, 0x2C, 0x1C, 0x77, 0xAE, 0xBE, 0xF1,
/* 2080 */ 0xCF, 0xC9, 0x10, 0x0D, 0x2C, 0xF6, 0x0B, 0xED, 0x3F, 0x54, 0x5D, 0x48, 0x7F, 0x0C, 0x06, 0x21,
/* 2090 */ 0x0A, 0x09, 0x03, 0x5D, 0xAE, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x2B, 0x52, 0x0E, 0x95, 0x6D,
/* 20A0 */ 0x52, 0x7F, 0x95, 0x5B, 0xA4, 0x0E, 0x95, 0x88, 0x96, 0x2E, 0x06, 0x06, 0x5D, 0xAC, 0x02, 0x5E,
/* 20B0 */ 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x5E, 0x48, 0x0C, 0xE0, 0x5B, 0x0B, 0xA8, 0x7C, 0x2E, 0x0A,
/* 20C0 */ 0x49, 0x0C, 0x9F, 0xAE, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x0D, 0x8E, 0xDF, 0x09, 0x9F, 0x5B, 0x91,
/* 20D0 */ 0x83, 0x46, 0x5B, 0xDF, 0x09, 0x9F, 0x5E, 0xBE, 0xF1, 0xCF, 0xC9, 0x10, 0x09, 0x26, 0xE2, 0xF6,
/* 20E0 */ 0x86, 0x5D, 0x0B, 0x08, 0x2E, 0xD1, 0x02, 0xD8, 0x7C, 0x52, 0x0E, 0x67, 0x99, 0x2B, 0x2A, 0x95,
/* 20F0 */ 0x21, 0x07, 0x73, 0xB0, 0x5B, 0x97, 0x45, 0x0F, 0x87, 0x3A, 0x0C, 0x97, 0x7A, 0x37, 0xA4, 0x83,
/* 2100 */ 0x5D, 0x08, 0x05, 0x10, 0x0D, 0x9B, 0x6F, 0x02, 0xB1, 0x08, 0x4A, 0x35, 0x0C, 0x45, 0x2E, 0x4E,
/* 2110 */ 0xB4, 0x54, 0x5D, 0x7E, 0x82, 0x31, 0x2A, 0x62, 0x08, 0x73, 0xB0, 0x31, 0x72, 0x6C, 0x08, 0x4A,
/* 2120 */ 0x36, 0x1A, 0x6F, 0x90, 0x00, 0x0C, 0xAF, 0x85, 0x1A, 0x33, 0x46, 0xA4, 0x96, 0x8B, 0x26, 0x97,
/* 2130 */ 0x4A, 0x33, 0x0F, 0x65, 0x46, 0x26, 0x97, 0x4A, 0x00, 0x09, 0x81, 0xB5, 0x44, 0x91, 0x81, 0x0D,
/* 2140 */ 0x0A, 0x00, 0x8B, 0x44, 0x23, 0x03, 0x0F, 0x6C, 0x8F, 0x0B, 0x31, 0x22, 0x45, 0x0F, 0x9A, 0x0C,
/* 2150 */ 0x36, 0x31, 0x2A, 0x67, 0x05, 0x75, 0xB0, 0x7E, 0x82, 0x37, 0x72, 0x4A, 0xF1, 0x70, 0x05, 0x21,
/* 2160 */ 0x33, 0x0E, 0x5F, 0x1A, 0x52, 0x10, 0x0C, 0xA9, 0x49, 0x35, 0x2A, 0x0B, 0x02, 0x6D, 0xF6, 0xEC,
/* 2170 */ 0x2F, 0x6D, 0x48, 0x08, 0x0C, 0x1A, 0xA9, 0x6A, 0xB8, 0x10, 0x0C, 0x00, 0xA9, 0x58, 0xF4, 0x72,
/* 2180 */ 0x02, 0x2B, 0x8F, 0x95, 0x02, 0x5D, 0x52, 0x0C, 0x06, 0x01, 0x5E, 0x6A, 0xB8, 0x10, 0x0C, 0x2B,
/* 2190 */ 0xEE, 0x05, 0x6D, 0xEE, 0x3B, 0x37, 0x33, 0x0F, 0x4B, 0x09, 0x67, 0x20, 0xAC, 0x9A, 0x32, 0x07,
/* 21A0 */ 0x28, 0xA9, 0x6A, 0xB8, 0x10, 0x0C, 0x8E, 0xE7, 0x38, 0xA9, 0x6A, 0xB8, 0x10, 0x0B, 0x00, 0xA9,
/* 21B0 */ 0x8C, 0x02, 0x21, 0xAC, 0x94, 0x19, 0x72, 0xB2, 0x21, 0x09, 0x0A, 0x53, 0xB1, 0x19, 0xF0, 0x6D,
/* 21C0 */ 0x8F, 0x0C, 0x31, 0x08, 0xBD, 0x2C, 0xC6, 0x10, 0x0B, 0xAA, 0xE3, 0x59, 0x63, 0x4A, 0x39, 0x4C,
/* 21D0 */ 0x5C, 0x37, 0x79, 0x4E, 0x73, 0x6B, 0xE3, 0x00, 0xF0, 0x1F, 0xE3, 0x24, 0x96, 0x1F, 0xE3, 0x24,
/* 21E0 */ 0x96, 0x25, 0x04, 0xA4, 0xF0, 0x1F, 0x79, 0x4E, 0x30, 0xA1, 0x25, 0x41, 0x6C, 0x25, 0x46, 0x39,
/* 21F0 */ 0x5B, 0xE3, 0x59, 0x10, 0x0B, 0x26, 0x9B, 0x52, 0xAD, 0x2B, 0x33, 0x63, 0x43, 0xF6, 0xA8, 0x46,
/* 2200 */ 0x5B, 0x0B, 0x30, 0x55, 0xB9, 0x25, 0x9A, 0xD8, 0x5F, 0x00, 0x25, 0x02, 0x02, 0x0E, 0x9D, 0x5D,
/* 2210 */ 0x25, 0x8D, 0x87, 0x00, 0x7F, 0x70, 0x0A, 0x6D, 0x25, 0x02, 0x79, 0x5D, 0x25, 0x02, 0x76, 0x99,
/* 2220 */ 0x00, 0x25, 0x9A, 0x06, 0x30, 0x7A, 0x25, 0x02, 0x5D, 0x2D, 0x0A, 0x25, 0x9A, 0x97, 0x45, 0x25,
/* 2230 */ 0x02, 0x02, 0x05, 0x0C, 0x94, 0x25, 0x02, 0x2D, 0x67, 0x02, 0x25, 0x02, 0x0C, 0x3E, 0x0B, 0x03,
/* 2240 */ 0x10, 0x0A, 0x61, 0xAD, 0xB1, 0x0D, 0x4B, 0x2C, 0x91, 0x45, 0x02, 0x6D, 0x48, 0x08, 0x0E, 0x5C,
/* 2250 */ 0x35, 0x1C, 0xAE, 0xB7, 0x10, 0x0A, 0x9B, 0xA6, 0x35, 0x07, 0x87, 0x6D, 0x03, 0xEC, 0x2F, 0x2E,
/* 2260 */ 0x08, 0x0F, 0xB2, 0xED, 0x01, 0x05, 0x6D, 0xAE, 0xB7, 0x10, 0x0A, 0x00, 0x64, 0x8F, 0x05, 0x21,
/* 2270 */ 0x06, 0x30, 0x3B, 0xF6, 0x54, 0x09, 0x67, 0x20, 0x51, 0x03, 0x5D, 0xA7, 0x5E, 0xB7, 0x10, 0x0A,
/* 2280 */ 0x64, 0x05, 0x9E, 0x06, 0x08, 0x0B, 0x02, 0x48, 0x41, 0xA1, 0x52, 0xAF, 0x07, 0x9E, 0x04, 0x31,
/* 2290 */ 0x8E, 0xB7, 0x10, 0x0A, 0x2C, 0x9B, 0xE7, 0x44, 0x8E, 0xB7, 0x10, 0x0A, 0x61, 0x09, 0x0E, 0x62,
/* 22A0 */ 0x21, 0x07, 0x0F, 0xE3, 0x2E, 0xD8, 0x03, 0x06, 0x9D, 0x2B, 0x07, 0x0F, 0xE3, 0x2B, 0x09, 0x0E,
/* 22B0 */ 0x62, 0xAE, 0xB7, 0x10, 0x10, 0xAB, 0x04, 0x9C, 0x3E, 0x0A, 0x02, 0x04, 0x0C, 0x67, 0x0A, 0x02,
/* 22C0 */ 0x26, 0x08, 0xA8, 0x4A, 0x41, 0xB0, 0x38, 0x6F, 0x09, 0x05, 0x04, 0x09, 0x73, 0x49, 0x09, 0x99,
/* 22D0 */ 0x1F, 0x18, 0x02, 0x5D, 0x0F, 0x4A, 0x1A, 0x58, 0x0D, 0x73, 0x89, 0x28, 0x50, 0x41, 0x89, 0x28,
/* 22E0 */ 0x06, 0x30, 0x4B, 0x04, 0xF0, 0x04, 0x42, 0x28, 0x08, 0x0F, 0x95, 0x5D, 0x0D, 0x36, 0x31, 0x97,
/* 22F0 */ 0x4A, 0x05, 0x09, 0x73, 0x4B, 0x05, 0x09, 0xB0, 0x38, 0xA4, 0x0E, 0xA8, 0x0C, 0x0A, 0xA8, 0x54,
/* 2300 */ 0x1A, 0x8C, 0x3E, 0x56, 0x06, 0x0C, 0x3E, 0x49, 0x10, 0x09, 0xE2, 0x02, 0x9C, 0xFB, 0x48, 0x0D,
/* 2310 */ 0x73, 0x54, 0x5B, 0x0B, 0x30, 0x49, 0x07, 0x0B, 0x5B, 0x23, 0xED, 0x8B, 0x34, 0x87, 0x38, 0x2A,
/* 2320 */ 0x0C, 0x38, 0x52, 0x46, 0x35, 0x0C, 0x99, 0x57, 0x6C, 0xF6, 0xA8, 0x3B, 0xF6, 0x0C, 0x73, 0x43,
/* 2330 */ 0x21, 0x22, 0x02, 0x35, 0x0E, 0x67, 0x53, 0x19, 0x58, 0x87, 0x6D, 0x2D, 0x45, 0x21, 0x0B, 0x46,
/* 2340 */ 0x03, 0x38, 0x48, 0x3C, 0x10, 0x0A, 0x61, 0x02, 0x04, 0xB1, 0x09, 0x0F, 0x56, 0x19, 0xB4, 0x4A,
/* 2350 */ 0x04, 0x21, 0x1C, 0x0D, 0x45, 0xB1, 0xAD, 0xAE, 0x98, 0xC3, 0xDA, 0xF1, 0x10, 0x0A, 0x9B, 0x01,
/* 2360 */ 0x04, 0x35, 0x88, 0xA1, 0x19, 0xD8, 0x36, 0x5D, 0xF6, 0x67, 0x09, 0x03, 0x21, 0x33, 0x01, 0x6D,
/* 2370 */ 0xAE, 0x98, 0xC3, 0xDA, 0xF1, 0x10, 0x0A, 0x1A, 0x9B, 0x52, 0xB4, 0x09, 0x6D, 0x52, 0xB4, 0x99,
/* 2380 */ 0x5B, 0xA4, 0x0E, 0x95, 0x4F, 0x5C, 0x2E, 0x09, 0x06, 0x5D, 0x8C, 0x02, 0x5E, 0x98, 0xC3, 0xDA,
/* 2390 */ 0xF1, 0x10, 0x0A, 0x9B, 0xE5, 0x86, 0x00, 0x0B, 0x4B, 0x31, 0x8E, 0x98, 0xC3, 0xDA, 0xF1, 0x10,
/* 23A0 */ 0x05, 0x1E, 0x33, 0x1A, 0x52, 0x0F, 0x43, 0x2C, 0x2D, 0x96, 0x2C, 0xA0, 0x67, 0x02, 0x28, 0x48,
/* 23B0 */ 0x05, 0x5D, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x61, 0x05, 0x35, 0x8D, 0x5C, 0x21, 0x4F, 0x5A,
/* 23C0 */ 0x38, 0x3A, 0x77, 0x2C, 0xA6, 0x28, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x00, 0x9B, 0x19, 0x0C,
/* 23D0 */ 0x4A, 0xED, 0x0B, 0x73, 0x1B, 0x2E, 0x09, 0x4A, 0x05, 0x0C, 0x45, 0x00, 0xF6, 0x83, 0x5D, 0x09,
/* 23E0 */ 0x6C, 0xAE, 0xC5, 0xD6, 0x02, 0x10, 0x05, 0x2B, 0x9B, 0x09, 0x9F, 0x00, 0x4F, 0x0B, 0x5B, 0xA2,
/* 23F0 */ 0x81, 0xB9, 0x37, 0x09, 0x9F, 0x00, 0x4F, 0x0B, 0x37, 0x8E, 0xC5, 0xD6, 0x02, 0x10, 0x0B, 0x9B,
/* 2400 */ 0x93, 0x21, 0x07, 0x53, 0xA5, 0x03, 0x2E, 0x91, 0xB4, 0x82, 0xF6, 0x75, 0x4A, 0x02, 0x2B, 0x07,
/* 2410 */ 0xA8, 0xB0, 0x5B, 0x33, 0x77, 0x08, 0x7D, 0x26, 0x72, 0x20, 0x88, 0x0E, 0x0B, 0x0A, 0x54, 0x1F,
/* 2420 */ 0x33, 0x41, 0x85, 0x25, 0x08, 0x05, 0x0C, 0x5A, 0x69, 0x5D, 0x03, 0x46, 0x31, 0x97, 0x45, 0x6F,
/* 2430 */ 0x46, 0x31, 0x97, 0x45, 0x5D, 0x03, 0x5A, 0x03, 0x0F, 0x4A, 0x5D, 0x06, 0x94, 0x37, 0x0D, 0x99,
/* 2440 */ 0x05, 0x72, 0x03, 0x1F, 0x32, 0x63, 0x99, 0x2E, 0x98, 0x3E, 0x77, 0x10, 0x0A, 0x64, 0x02, 0x0C,
/* 2450 */ 0xE0, 0x5B, 0x0B, 0x73, 0x36, 0x2E, 0x0A, 0x49, 0x0C, 0x9F, 0x31, 0x8E, 0xC0, 0xE3, 0xC8, 0x5D,
/* 2460 */ 0xF8, 0xF8, 0x10, 0x0B, 0x61, 0x33, 0xB1, 0x07, 0x0F, 0x83, 0x2C, 0xEC, 0x4B, 0x21, 0x33, 0x22,
/* 2470 */ 0x0C, 0xB1, 0xA6, 0xAE, 0xF7, 0xC2, 0x10, 0x0B, 0x9B, 0x33, 0x28, 0x52, 0x0D, 0x2F, 0x2E, 0x58,
/* 2480 */ 0x0F, 0x99, 0x2B, 0x70, 0x39, 0x21, 0x33, 0x20, 0x6E, 0xF7, 0xC2, 0x10, 0x0B, 0x1A, 0x9B, 0x48,
/* 2490 */ 0x0E, 0x45, 0x6D, 0x48, 0x72, 0x95, 0x2B, 0x22, 0x49, 0x0E, 0x96, 0x2E, 0x08, 0x08, 0x5D, 0x8D,
/* 24A0 */ 0x03, 0x5E, 0xF7, 0xC2, 0x10, 0x0B, 0x64, 0x51, 0xE0, 0x5B, 0x0A, 0x73, 0x36, 0x2E, 0x0A, 0x49,
/* 24B0 */ 0x0C, 0x0E, 0x09, 0x1F, 0x8E, 0xF7, 0xC2, 0x10, 0x0B, 0x2C, 0x9B, 0xDF, 0x09, 0x9F, 0x5B, 0x91,
/* 24C0 */ 0x83, 0x46, 0x5B, 0xDF, 0x09, 0x9F, 0x31, 0x8E, 0xF7, 0xC2, 0x10, 0x09, 0xCD, 0x4F, 0x7B, 0x2C,
/* 24D0 */ 0xF0, 0x2C, 0xF0, 0x2C, 0x4F, 0x7B, 0x28, 0xAE, 0x19, 0xDD, 0xAE, 0x4F, 0x7B, 0x2C, 0xF0, 0x2C,
/* 24E0 */ 0xF0, 0x2C, 0x4F, 0x7B, 0x10, 0x0B, 0x00, 0xCD, 0x6F, 0x02, 0xB1, 0xD8, 0x09, 0x35, 0xB4, 0x6C,
/* 24F0 */ 0x48, 0x0A, 0x63, 0x02, 0x52, 0x0E, 0xA8, 0x87, 0x0C, 0x99, 0xD8, 0x54, 0x1F, 0x03, 0x85, 0x0C,
/* 2500 */ 0x0B, 0x29, 0x31, 0x33, 0x54, 0x01, 0x5C, 0x22, 0x5F, 0x31, 0x06, 0x54, 0x76, 0x51, 0x30, 0x02,
/* 2510 */ 0x44, 0x33, 0x54, 0x0A, 0x0C, 0x00, 0x22, 0x5F, 0x31, 0x70, 0x0A, 0x62, 0x01, 0x71, 0x22, 0x54,
/* 2520 */ 0x0B, 0x99, 0x37, 0x03, 0x0E, 0x41, 0x1B, 0x5B, 0x8F, 0xFB, 0x2E, 0x0B, 0x95, 0x35, 0x0D, 0x5C,
/* 2530 */ 0xB1, 0x3C, 0x10, 0x0A, 0x61, 0x02, 0x03, 0xB1, 0xD8, 0x56, 0x19, 0xB4, 0x4A, 0x04, 0x21, 0x1C,
/* 2540 */ 0x0D, 0x95, 0xB1, 0xAD, 0x1A, 0xA9, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0x01, 0x04, 0x2C, 0x33,
/* 2550 */ 0x0E, 0xA1, 0x19, 0xD8, 0x36, 0x5D, 0xF6, 0x67, 0xF1, 0x6D, 0x33, 0x01, 0x00, 0xAE, 0x18, 0x47,
/* 2560 */ 0xBC, 0x10, 0x0A, 0x64, 0x32, 0x99, 0x6D, 0x52, 0xB4, 0x54, 0x00, 0x48, 0xB4, 0x09, 0x76, 0x7C,
/* 2570 */ 0x2E, 0x0A, 0x06, 0x5D, 0x8C, 0x60, 0x21, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0xE5, 0x86, 0x00,
/* 2580 */ 0xA5, 0x05, 0x26, 0x8E, 0x18, 0x47, 0xBC, 0x10, 0x0A, 0x9B, 0x04, 0x60, 0xAC, 0x0F, 0x09, 0x6D,
/* 2590 */ 0xF6, 0x72, 0xA1, 0x2B, 0x0B, 0x4A, 0x06, 0xED, 0x02, 0x04, 0x5D, 0xAE, 0xF5, 0x0B, 0xBB, 0x01,
/* 25A0 */ 0xFB, 0x10, 0x0B, 0x64, 0x57, 0x35, 0xC5, 0xE1, 0x04, 0x0B, 0x0F, 0xB2, 0x5D, 0x25, 0x7F, 0xA3,
/* 25B0 */ 0x25, 0x0C, 0x4E, 0x5A, 0x00, 0xB4, 0x2F, 0x02, 0x90, 0x25, 0x02, 0x5D, 0x73, 0x03, 0x25, 0x02,
/* 25C0 */ 0x5D, 0x7F, 0x03, 0x25, 0x02, 0x5D, 0x73, 0x02, 0x25, 0x9A, 0x03, 0xE6, 0x06, 0x22, 0x43, 0x5B,
/* 25D0 */ 0xC5, 0x60, 0x3E, 0x1B, 0x5D, 0x19, 0x10, 0x0A, 0x2C, 0x9B, 0x92, 0xE4, 0x5B, 0x72, 0x02, 0x0A,
/* 25E0 */ 0x36, 0x5B, 0x92, 0xE4, 0x26, 0x8E, 0xF5, 0x0B, 0xBB, 0x01, 0xFB, 0x10, 0x00, 0x00, 0x00, 0x0D,
/* 25F0 */ 0x00, 0x1C, 0x00, 0x0D, 0x0A, 0x5D, 0x8E, 0xE2, 0x52, 0x42, 0x42, 0x03, 0x40, 0x0D, 0x40, 0x0D,
/* 2600 */ 0x10, 0x0A, 0x5D, 0x8E, 0xE2, 0x48, 0x42, 0x42, 0x37, 0x09, 0x41, 0x90, 0x7E, 0x0F, 0x5F, 0x10,
/* 2610 */ 0x0F, 0x5D, 0x8E, 0xE2, 0x48, 0x04, 0x42, 0x42, 0x42, 0x1A, 0x2D, 0x89, 0x90, 0x28, 0x2D, 0x89,
/* 2620 */ 0x90, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x9D, 0x00, 0x00,
/* 2630 */ 0x07, 0x9F, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x07, 0xA2, 0x00, 0x00,
/* 2640 */ 0x08, 0x60, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x17, 0xBD, 0x00, 0x00,
/* 2650 */ 0x18, 0x7D, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x25, 0xEC, 0x00, 0x00,
/* 2660 */ 0x25, 0xF4,

755
contrib/mcufont/fonts/FiraSansCondensed-Bold24.mcufont.h Normal file
View file

@ -0,0 +1,755 @@
/*
* LWS MCUFONT Fira Sans Condensed Bold 24
* blob size: 11720, glyphs 192
*
* Unicode 0x00000d - 0x00000d
* Unicode 0x000020 - 0x00007e
* Unicode 0x0000a0 - 0x0000ff
* Unicode 0x002012 - 0x002015
*/
/* 0000 */ 0x4D, 0x43, 0x55, 0x46, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5C,
/* 0010 */ 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x06, 0x2E, 0x00, 0x00, 0x06, 0xA3, 0x00, 0x00, 0x00, 0x9C,
/* 0020 */ 0x00, 0x00, 0x00, 0xE8, 0x00, 0x00, 0x2D, 0x88, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3F,
/* 0030 */ 0x00, 0x18, 0x00, 0x1E, 0x00, 0x05, 0x00, 0x16, 0x00, 0x02, 0x00, 0x17, 0x00, 0x1D, 0x00, 0x00,
/* full name */
/* 0040 */ 0x46, 0x69, 0x72, 0x61, 0x20, 0x53, 0x61, 0x6E, 0x73, 0x20, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E,
/* 0050 */ 0x73, 0x65, 0x64, 0x20, 0x42, 0x6F, 0x6C, 0x64, 0x20, 0x32, 0x34, 0x00,
/* short name */
0x46, 0x69, 0x72, 0x61,
/* 0060 */ 0x53, 0x61, 0x6E, 0x73, 0x43, 0x6F, 0x6E, 0x64, 0x65, 0x6E, 0x73, 0x65, 0x64, 0x5F, 0x42, 0x6F,
/* 0070 */ 0x6C, 0x64, 0x32, 0x34, 0x00,
/* dictionary data */
0xFA, 0xCA, 0x02, 0x81, 0xC4, 0x03, 0xCA, 0x42, 0x28, 0x03, 0x14,
/* 0080 */ 0x0B, 0xCA, 0x82, 0xC2, 0x02, 0x81, 0xCB, 0xC9, 0x0F, 0x81, 0xCD, 0xDA, 0x01, 0xC5, 0x81, 0xCD,
/* 0090 */ 0x02, 0x0F, 0x0C, 0xCA, 0x80, 0x06, 0xCB, 0x81, 0x09, 0x03, 0xC9, 0x81, 0x80, 0xC6, 0x0A, 0xC7,
/* 00A0 */ 0x85, 0x13, 0x05, 0x80, 0xCC, 0x0C, 0xC4, 0x82, 0xCE, 0x81, 0xCC, 0x82, 0x02, 0xCA, 0x14, 0xCB,
/* 00B0 */ 0x81, 0xCE, 0x13, 0xC4, 0x82, 0xCB, 0x13, 0xC4, 0x80, 0x0E, 0xCE, 0xC1, 0xC2, 0xCD, 0x82, 0xC1,
/* 00C0 */ 0x10, 0xC3, 0x11, 0x04, 0xCC, 0x82, 0x0C, 0xCE, 0x81, 0xCE, 0x04, 0xCC, 0x82, 0x0C, 0xCE, 0x81,
/* 00D0 */ 0xCE, 0x81, 0xCC, 0x0A, 0x02, 0xC7, 0x82, 0xC2, 0x13, 0xCA, 0x82, 0xC2, 0x13, 0xCA, 0x04, 0xCE,
/* 00E0 */ 0x82, 0xCD, 0xC1, 0x0B, 0xC6, 0x82, 0xCB, 0x03, 0xC9, 0x82, 0xC8, 0x0B, 0xCC, 0x82, 0xC3, 0x03,
/* 00F0 */ 0xC1, 0x82, 0xCE, 0x0A, 0xC1, 0x82, 0xCE, 0x05, 0xCC, 0x82, 0xC2, 0x09, 0xC3, 0x82, 0xCC, 0x05,
/* 0100 */ 0xCA, 0x82, 0xC5, 0x09, 0xC4, 0x82, 0xCB, 0x05, 0xC9, 0x82, 0x44, 0x0C, 0xCD, 0xC1, 0x84, 0x0D,
/* 0110 */ 0xC3, 0xC4, 0x0D, 0xC5, 0x82, 0x07, 0xC8, 0xCE, 0x82, 0xC7, 0x0B, 0x82, 0xCA, 0x01, 0xC1, 0xC7,
/* 0120 */ 0x1C, 0x81, 0x12, 0x40, 0x23, 0x81, 0xC9, 0x01, 0xC1, 0xC8, 0xC9, 0x81, 0x85, 0x12, 0xCA, 0x82,
/* 0130 */ 0x0E, 0xCA, 0x0E, 0xC1, 0xCB, 0xC1, 0xC8, 0xC2, 0x80, 0xC3, 0x01, 0x0E, 0xC3, 0x13, 0xC5, 0x82,
/* 0140 */ 0xCA, 0xC4, 0xCC, 0x81, 0x41, 0x2A, 0x08, 0xCD, 0xCE, 0xC7, 0x82, 0x0D, 0x82, 0xC3, 0xC4, 0x82,
/* 0150 */ 0xCC, 0xC3, 0x88, 0x82, 0xCB, 0x82, 0xC4, 0x0D, 0x01, 0xC1, 0x82, 0x81, 0xC7, 0x01, 0xC6, 0x82,
/* 0160 */ 0x15, 0x80, 0xC5, 0x13, 0xC1, 0xC7, 0xC1, 0x40, 0x2D, 0x80, 0xC9, 0x0E, 0xC2, 0x82, 0x01, 0xCA,
/* 0170 */ 0x80, 0xC4, 0xCB, 0x81, 0xCB, 0x14, 0xCB, 0x81, 0xCB, 0x14, 0xCB, 0xCB, 0x83, 0x81, 0xC2, 0x01,
/* 0180 */ 0x80, 0xC7, 0xCC, 0xCD, 0x82, 0xC8, 0x03, 0x10, 0x80, 0xC8, 0x01, 0x80, 0xCD, 0xC2, 0xC7, 0xC3,
/* 0190 */ 0xC9, 0x81, 0xCE, 0xC1, 0x0C, 0xC1, 0x81, 0xC1, 0x13, 0xCA, 0xC1, 0x01, 0xCC, 0xCE, 0x81, 0xCE,
/* 01A0 */ 0xCC, 0x14, 0xDE, 0xCB, 0x81, 0xCE, 0xC3, 0x01, 0xCC, 0xC1, 0xC9, 0xC3, 0x0B, 0xCE, 0xC2, 0x81,
/* 01B0 */ 0xCA, 0x01, 0xC5, 0xCB, 0x0C, 0x80, 0xCE, 0xCA, 0xC2, 0x01, 0xC4, 0xCE, 0xCD, 0x01, 0xC3, 0xCE,
/* 01C0 */ 0x84, 0xC2, 0xCA, 0xC6, 0xC1, 0x41, 0x16, 0xCE, 0x80, 0xCE, 0x01, 0xC8, 0x81, 0xCD, 0xCB, 0x0F,
/* 01D0 */ 0xC1, 0xC8, 0xC1, 0xC5, 0xCE, 0x82, 0xC6, 0xC8, 0x81, 0xCA, 0xC3, 0x12, 0xC2, 0x82, 0x81, 0xC8,
/* 01E0 */ 0xC8, 0x85, 0x80, 0xC1, 0x01, 0x0B, 0xC4, 0xCE, 0xC4, 0xC1, 0xCA, 0x80, 0x40, 0x10, 0x80, 0xCA,
/* 01F0 */ 0x01, 0xC5, 0xCC, 0x30, 0x80, 0xCB, 0x46, 0x04, 0x09, 0x02, 0x0B, 0x3F, 0x0E, 0x5A, 0x76, 0x06,
/* 0200 */ 0x85, 0x7C, 0x76, 0x9C, 0x4C, 0x41, 0x4B, 0x0B, 0x3F, 0x0E, 0x43, 0x06, 0x62, 0x97, 0x6A, 0x2F,
/* 0210 */ 0x09, 0xA4, 0x62, 0x99, 0x50, 0x30, 0x19, 0x1B, 0x50, 0x71, 0x29, 0x85, 0x95, 0x2F, 0x33, 0x02,
/* 0220 */ 0x2C, 0x0C, 0x66, 0x1D, 0x85, 0x95, 0x90, 0x06, 0x6A, 0x2A, 0x80, 0x90, 0x60, 0x95, 0x0B, 0x0D,
/* 0230 */ 0x6D, 0x45, 0x90, 0x6C, 0x0C, 0x46, 0x22, 0x02, 0x25, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0x90, 0x62,
/* 0240 */ 0x1B, 0x92, 0x0D, 0x0F, 0x71, 0x3A, 0x62, 0x1B, 0x92, 0xA5, 0x09, 0x3A, 0x62, 0x1B, 0x92, 0x03,
/* 0250 */ 0x22, 0x32, 0x01, 0x62, 0x1B, 0x92, 0x00, 0x0D, 0x50, 0x3A, 0x62, 0x1B, 0x92, 0x9F, 0x3A, 0x62,
/* 0260 */ 0x1B, 0x92, 0x97, 0x50, 0x3A, 0x62, 0x1B, 0x92, 0x19, 0x42, 0xAA, 0x29, 0xB1, 0x0B, 0x0C, 0xA8,
/* 0270 */ 0x25, 0xA9, 0xB2, 0x2F, 0xAB, 0x0A, 0x9E, 0x0B, 0x05, 0x0E, 0x81, 0xA2, 0x7F, 0xA9, 0x0D, 0x02,
/* 0280 */ 0x19, 0x31, 0xA0, 0x6A, 0x37, 0x60, 0x0C, 0x19, 0x49, 0x02, 0x90, 0x6C, 0x0F, 0x6E, 0x6C, 0xA4,
/* 0290 */ 0x90, 0x99, 0x69, 0x80, 0xAB, 0x69, 0x75, 0x31, 0x0C, 0x0A, 0x18, 0x06, 0x94, 0x85, 0x75, 0x1E,
/* 02A0 */ 0x60, 0x91, 0x19, 0x4E, 0x25, 0x05, 0x0F, 0x62, 0x02, 0x4C, 0x62, 0x02, 0x1F, 0x77, 0x6D, 0x02,
/* 02B0 */ 0x1F, 0x77, 0x6D, 0x02, 0x0D, 0x66, 0x2C, 0x1B, 0x6D, 0x7D, 0x0F, 0x66, 0x19, 0xAB, 0xA2, 0x25,
/* 02C0 */ 0x2D, 0x30, 0x25, 0x02, 0x95, 0x0B, 0x0B, 0x32, 0x71, 0x25, 0x02, 0x19, 0x99, 0x7E, 0x7F, 0x85,
/* 02D0 */ 0x75, 0x41, 0xAB, 0x0A, 0x9A, 0x09, 0x37, 0xA9, 0x53, 0x94, 0x02, 0x6D, 0x96, 0x00, 0x50, 0x75,
/* 02E0 */ 0x65, 0x06, 0x66, 0x19, 0x50, 0x75, 0x65, 0x64, 0x05, 0x97, 0x4D, 0x31, 0x0E, 0x0B, 0x42, 0x5C,
/* 02F0 */ 0x94, 0x33, 0xA8, 0x32, 0x01, 0x94, 0x6C, 0x09, 0x0E, 0x30, 0x05, 0x99, 0x0B, 0x0A, 0x0B, 0x19,
/* 0300 */ 0x97, 0xA4, 0x94, 0x8C, 0x1D, 0x64, 0x02, 0x94, 0x64, 0x02, 0x34, 0x22, 0x47, 0x50, 0x71, 0x19,
/* 0310 */ 0x0D, 0x53, 0x65, 0x0E, 0xA8, 0x6C, 0x6B, 0x77, 0x92, 0x05, 0x3A, 0x37, 0x06, 0x22, 0x9F, 0x0B,
/* 0320 */ 0x25, 0x02, 0x3A, 0x28, 0x07, 0x7F, 0x0D, 0x1A, 0x32, 0x02, 0x19, 0x58, 0xA8, 0x22, 0x3C, 0x06,
/* 0330 */ 0x89, 0x53, 0x19, 0x76, 0x0F, 0x71, 0x51, 0x0D, 0x0F, 0x3A, 0x2F, 0x58, 0x20, 0x5E, 0x05, 0x00,
/* 0340 */ 0xA1, 0x06, 0x0B, 0x6A, 0x51, 0x0F, 0x6D, 0x5A, 0x51, 0x88, 0x0B, 0x97, 0x4D, 0x2C, 0x6C, 0x4D,
/* 0350 */ 0x19, 0x0D, 0x89, 0x90, 0x99, 0x7E, 0x0B, 0x3A, 0xAB, 0x7E, 0x0A, 0x6D, 0x02, 0x2C, 0x99, 0x7E,
/* 0360 */ 0x0B, 0x3A, 0x2C, 0x6C, 0x4D, 0x19, 0x0D, 0x89, 0x65, 0x60, 0x91, 0x97, 0x50, 0x75, 0x65, 0x49,
/* 0370 */ 0x0E, 0x0B, 0x0E, 0x66, 0x37, 0x09, 0x56, 0x71, 0x7F, 0x93, 0x9E, 0x04, 0x0B, 0x0E, 0x81, 0xA6,
/* 0380 */ 0x7F, 0xA9, 0x2B, 0x37, 0x49, 0x0E, 0x0B, 0x0E, 0x66, 0x65, 0x4A, 0x4B, 0x68, 0x36, 0x20, 0x1E,
/* 0390 */ 0x09, 0x0E, 0x68, 0x8C, 0x19, 0x9F, 0x78, 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x1D, 0x0B, 0x3A,
/* 03A0 */ 0x94, 0x28, 0x5C, 0x02, 0x50, 0x30, 0x01, 0x41, 0x32, 0x38, 0x29, 0x9F, 0x7C, 0x1D, 0x05, 0x4C,
/* 03B0 */ 0x01, 0x32, 0x0C, 0x1B, 0x84, 0xA5, 0x5C, 0x85, 0x80, 0x90, 0x6C, 0x50, 0x6A, 0x66, 0x37, 0x06,
/* 03C0 */ 0x0D, 0x81, 0x9C, 0x66, 0x01, 0x06, 0x0B, 0x0D, 0x8B, 0x0C, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0xA1,
/* 03D0 */ 0x0C, 0x46, 0x22, 0x02, 0x65, 0x60, 0x95, 0x0B, 0x0D, 0x6D, 0x81, 0x29, 0x6C, 0x55, 0x09, 0x41,
/* 03E0 */ 0x99, 0x0F, 0x2B, 0x29, 0x05, 0x32, 0x75, 0x19, 0x1B, 0x95, 0x62, 0x6C, 0x0E, 0x81, 0x53, 0x1D,
/* 03F0 */ 0x02, 0x6E, 0x62, 0x97, 0x07, 0x02, 0x0F, 0x1D, 0x3B, 0x50, 0x00, 0x3B, 0x22, 0x19, 0x08, 0x66,
/* 0400 */ 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19,
/* 0410 */ 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D,
/* 0420 */ 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66, 0x65, 0x0D, 0x22, 0x19, 0x08, 0x66,
/* 0430 */ 0x65, 0x0C, 0x89, 0x6C, 0x8C, 0x19, 0x55, 0xAA, 0x64, 0x02, 0x4A, 0x8C, 0x19, 0x55, 0xAA, 0x64,
/* 0440 */ 0x02, 0x4A, 0x8C, 0x19, 0x55, 0xAA, 0x64, 0x02, 0x0F, 0x91, 0x65, 0x28, 0x20, 0x32, 0x75, 0x65,
/* 0450 */ 0x0B, 0xA4, 0x00, 0x78, 0x00, 0x97, 0x3A, 0x62, 0x1B, 0x50, 0x53, 0x97, 0x3A, 0x62, 0x1B, 0x50,
/* 0460 */ 0x22, 0x00, 0x97, 0x3A, 0x62, 0x1B, 0x50, 0x66, 0x97, 0x3A, 0x62, 0x1B, 0x0F, 0x30, 0xA8, 0x97,
/* 0470 */ 0x3A, 0x62, 0x1B, 0x0F, 0x75, 0x22, 0x97, 0x3A, 0x62, 0x1B, 0xA8, 0x0D, 0x50, 0x03, 0x04, 0x0F,
/* 0480 */ 0x92, 0x00, 0x26, 0x56, 0x7C, 0x58, 0x6A, 0x0A, 0x23, 0x5F, 0x1D, 0x1F, 0x1D, 0x58, 0x40, 0x6A,
/* 0490 */ 0x0A, 0x23, 0x07, 0x1D, 0x26, 0x6D, 0x4D, 0x58, 0x46, 0x92, 0x58, 0x40, 0x40, 0x6A, 0x23, 0x23,
/* 04A0 */ 0x07, 0x58, 0x50, 0x56, 0x0A, 0x58, 0x50, 0x56, 0x05, 0x63, 0x07, 0x1E, 0x42, 0x02, 0x2E, 0x42,
/* 04B0 */ 0x02, 0x2E, 0x05, 0x63, 0x07, 0x1E, 0xB1, 0x0B, 0x0E, 0x0A, 0x19, 0x4B, 0x0B, 0x00, 0x5D, 0x0F,
/* 04C0 */ 0x1A, 0x02, 0xA4, 0x5D, 0x0F, 0x1A, 0x02, 0xA4, 0x25, 0x0D, 0x50, 0x8A, 0x30, 0xAB, 0x0F, 0x71,
/* 04D0 */ 0x34, 0x0F, 0x38, 0x09, 0x30, 0x90, 0x0B, 0x02, 0x6A, 0x2E, 0x02, 0x6A, 0x2E, 0x02, 0x6A, 0x2E,
/* 04E0 */ 0x02, 0x6A, 0x00, 0xA7, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x41, 0x0D, 0x6D, 0x94, 0x0D, 0x3A, 0x1D,
/* 04F0 */ 0x0E, 0x89, 0x26, 0xA8, 0x19, 0x06, 0x6A, 0x31, 0x0F, 0x8B, 0x0F, 0x6B, 0x2D, 0x6E, 0x37, 0x83,
/* 0500 */ 0x0D, 0x0F, 0x98, 0x8F, 0x67, 0x09, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75, 0x1D, 0x0D, 0x3E,
/* 0510 */ 0x00, 0x6C, 0x6A, 0x1D, 0x0D, 0x3E, 0x1D, 0x0D, 0x50, 0x91, 0x97, 0x50, 0x30, 0x94, 0x9F, 0x95,
/* 0520 */ 0x7A, 0x0C, 0x94, 0x6C, 0x0D, 0x49, 0x02, 0x5E, 0x02, 0x5E, 0x02, 0x2E, 0x01, 0x06, 0x08, 0x00,
/* 0530 */ 0x07, 0x3A, 0x37, 0x09, 0x89, 0x00, 0x0C, 0x53, 0x76, 0x08, 0x6D, 0x02, 0x41, 0x26, 0x6D, 0x75,
/* 0540 */ 0x3C, 0x02, 0x46, 0x02, 0x57, 0x0A, 0x2E, 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x2E,
/* 0550 */ 0x06, 0xA4, 0x2E, 0x06, 0xA4, 0x1D, 0x61, 0x24, 0x90, 0x3F, 0x20, 0x0C, 0x02, 0x4A, 0x31, 0x0A,
/* 0560 */ 0x62, 0xAB, 0x6A, 0x1E, 0x28, 0x07, 0x3C, 0x2A, 0x01, 0x1E, 0x0C, 0xAF, 0x72, 0x1A, 0x1E, 0x72,
/* 0570 */ 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x72, 0xA4, 0x65, 0x05, 0x1E, 0x28, 0x05, 0x1E, 0x28,
/* 0580 */ 0x05, 0x3C, 0x0B, 0x46, 0x0E, 0x65, 0x8C, 0x1B, 0x6D, 0x02, 0x94, 0x8C, 0x2A, 0x78, 0x32, 0x95,
/* 0590 */ 0x19, 0x3B, 0x6D, 0x1A, 0x3C, 0x64, 0xA8, 0x3C, 0x60, 0x0A, 0x3E, 0x27, 0x85, 0x78, 0x3A, 0x25,
/* 05A0 */ 0x05, 0x22, 0x00, 0x32, 0x05, 0x25, 0x09, 0x92, 0x28, 0x0A, 0x25, 0x0D, 0x6E, 0x08, 0x89, 0x76,
/* 05B0 */ 0x04, 0x00, 0x05, 0x66, 0x90, 0x3F, 0x3A, 0x6C, 0x4C, 0x19, 0x0B, 0x56, 0x6A, 0x94, 0x85, 0x56,
/* 05C0 */ 0x3A, 0xAB, 0x50, 0x30, 0x0B, 0x0B, 0x0B, 0x0D, 0x50, 0x71, 0x90, 0x09, 0x66, 0x19, 0x99, 0x50,
/* 05D0 */ 0x75, 0x90, 0x0D, 0x89, 0x2F, 0x0F, 0x22, 0x2C, 0x02, 0x6A, 0x2F, 0x33, 0x02, 0x2E, 0x9D, 0x35,
/* 05E0 */ 0x35, 0x35, 0x35, 0x35, 0x35, 0x06, 0x65, 0x8C, 0x00, 0x97, 0xA4, 0x65, 0x8C, 0x00, 0x97, 0xA4,
/* 05F0 */ 0x65, 0x8C, 0x09, 0x8B, 0x0B, 0x02, 0x37, 0x28, 0x7D, 0x6D, 0x30, 0x37, 0x3C, 0x05, 0x6A, 0x05,
/* 0600 */ 0x2E, 0x0F, 0x75, 0x08, 0xA8, 0x04, 0x3A, 0x62, 0x1B, 0x50, 0x1D, 0x97, 0x61, 0x77, 0x0C, 0x20,
/* 0610 */ 0x0B, 0x06, 0x27, 0x64, 0x04, 0x2E, 0x00, 0x0E, 0xA8, 0x65, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E,
/* 0620 */ 0x0C, 0x02, 0x7F, 0xB1, 0x3C, 0xB1, 0x09, 0x0E, 0x0A, 0x19, 0x4B, 0x5A, 0x09, 0x2E, 0x06, 0x1E,
/* 0630 */ 0x0C, 0x22, 0x94, 0x74, 0x3F, 0x0B, 0x7D, 0x35, 0x35, 0x35, 0x35, 0x0E, 0x22, 0x00, 0x40, 0x40,
/* 0640 */ 0x40, 0x40, 0x40, 0x40, 0x40, 0x0F, 0x7B, 0x57, 0x0C, 0x2E, 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E,
/* 0650 */ 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E, 0x85, 0x30, 0x2E, 0x09, 0x0E, 0x0C, 0x02, 0x5E, 0x0A, 0x5E,
/* 0660 */ 0x79, 0x20, 0x1E, 0x79, 0x20, 0x1D, 0x42, 0x6A, 0x27, 0x1B, 0x95, 0x62, 0x0B, 0x30, 0x29, 0x02,
/* 0670 */ 0x6E, 0x4A, 0x0B, 0x30, 0x29, 0x09, 0x95, 0x86, 0x99, 0x0A, 0x08, 0x65, 0x74, 0x08, 0x65, 0x85,
/* 0680 */ 0x09, 0x19, 0x9F, 0x02, 0x65, 0x85, 0x09, 0x02, 0x32, 0x0D, 0x95, 0x00, 0x55, 0x01, 0x0B, 0x0E,
/* 0690 */ 0x07, 0x34, 0x0E, 0x21, 0x0D, 0xB2, 0x67, 0x07, 0x4A, 0x31, 0x07, 0x19, 0x0A, 0xA6, 0x37, 0x69,
/* 06A0 */ 0x04, 0x37, 0x50,
/* dictionary offset */
0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x05, 0x00, 0x07, 0x00, 0x09, 0x00,
/* 06B0 */ 0x0A, 0x00, 0x0B, 0x00, 0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x16, 0x00, 0x17, 0x00, 0x1C, 0x00,
/* 06C0 */ 0x1D, 0x00, 0x20, 0x00, 0x21, 0x00, 0x23, 0x00, 0x24, 0x00, 0x27, 0x00, 0x29, 0x00, 0x2A, 0x00,
/* 06D0 */ 0x2C, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x30, 0x00, 0x33, 0x00, 0x35, 0x00, 0x37, 0x00, 0x39, 0x00,
/* 06E0 */ 0x3D, 0x00, 0x44, 0x00, 0x45, 0x00, 0x47, 0x00, 0x49, 0x00, 0x4B, 0x00, 0x4D, 0x00, 0x4E, 0x00,
/* 06F0 */ 0x5C, 0x00, 0x5F, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x6C, 0x00, 0x95, 0x00, 0x97, 0x00,
/* 0700 */ 0x99, 0x00, 0x9A, 0x00, 0x9C, 0x00, 0x9E, 0x00, 0xA0, 0x00, 0xA1, 0x00, 0xA3, 0x00, 0xA6, 0x00,
/* 0710 */ 0xA9, 0x00, 0xAB, 0x00, 0xAC, 0x00, 0xAD, 0x00, 0xAE, 0x00, 0xB0, 0x00, 0xB3, 0x00, 0xB5, 0x00,
/* 0720 */ 0xB7, 0x00, 0xB8, 0x00, 0xBB, 0x00, 0xBD, 0x00, 0xBF, 0x00, 0xC1, 0x00, 0xC3, 0x00, 0xC6, 0x00,
/* 0730 */ 0xC8, 0x00, 0xCB, 0x00, 0xCD, 0x00, 0xCF, 0x00, 0xD1, 0x00, 0xD2, 0x00, 0xD4, 0x00, 0xD6, 0x00,
/* 0740 */ 0xD7, 0x00, 0xD9, 0x00, 0xDB, 0x00, 0xDD, 0x00, 0xDE, 0x00, 0xE0, 0x00, 0xE3, 0x00, 0xE5, 0x00,
/* 0750 */ 0xE6, 0x00, 0xE9, 0x00, 0xEB, 0x00, 0xEC, 0x00, 0xEE, 0x00, 0xF0, 0x00, 0xF2, 0x00, 0xF4, 0x00,
/* 0760 */ 0xF6, 0x00, 0xF9, 0x00, 0xFB, 0x00, 0xFD, 0x01, 0x06, 0x01, 0x08, 0x01, 0x0B, 0x01, 0x0D, 0x01,
/* 0770 */ 0x0F, 0x01, 0x12, 0x01, 0x13, 0x01, 0x16, 0x01, 0x18, 0x01, 0x1A, 0x01, 0x1C, 0x01, 0x20, 0x01,
/* 0780 */ 0x22, 0x01, 0x24, 0x01, 0x27, 0x01, 0x29, 0x01, 0x2B, 0x01, 0x2D, 0x01, 0x2E, 0x01, 0x31, 0x01,
/* 0790 */ 0x33, 0x01, 0x35, 0x01, 0x37, 0x01, 0x38, 0x01, 0x3A, 0x01, 0x3D, 0x01, 0x3F, 0x01, 0x40, 0x01,
/* 07A0 */ 0x42, 0x01, 0x44, 0x01, 0x46, 0x01, 0x48, 0x01, 0x4A, 0x01, 0x4C, 0x01, 0x4E, 0x01, 0x50, 0x01,
/* 07B0 */ 0x52, 0x01, 0x55, 0x01, 0x58, 0x01, 0x5A, 0x01, 0x5C, 0x01, 0x5E, 0x01, 0x60, 0x01, 0x62, 0x01,
/* 07C0 */ 0x64, 0x01, 0x66, 0x01, 0x69, 0x01, 0x6B, 0x01, 0x6D, 0x01, 0x70, 0x01, 0x72, 0x01, 0x74, 0x01,
/* 07D0 */ 0x77, 0x01, 0x79, 0x01, 0x7C, 0x01, 0x7E, 0x01, 0x7F, 0x01, 0x81, 0x01, 0x83, 0x01, 0x85, 0x01,
/* 07E0 */ 0x95, 0x01, 0xCA, 0x01, 0xF8, 0x02, 0x04, 0x02, 0x32, 0x02, 0x37, 0x02, 0x3F, 0x02, 0x49, 0x02,
/* 07F0 */ 0x89, 0x02, 0xD6, 0x03, 0x06, 0x03, 0x15, 0x03, 0x1E, 0x03, 0x31, 0x03, 0x46, 0x03, 0x4F, 0x03,
/* 0800 */ 0x55, 0x03, 0x65, 0x03, 0x82, 0x03, 0x85, 0x03, 0x87, 0x03, 0xBF, 0x03, 0xD3, 0x03, 0xDE, 0x04,
/* 0810 */ 0x0B, 0x04, 0x33, 0x04, 0x43, 0x04, 0x54, 0x04, 0x57, 0x04, 0x62, 0x04, 0x6F, 0x04, 0x8F, 0x04,
/* 0820 */ 0xB0, 0x04, 0xB7, 0x04, 0xB9, 0x04, 0xE0, 0x04, 0xE2, 0x04, 0xE6, 0x04, 0xFA, 0x05, 0x05, 0x05,
/* 0830 */ 0x0D, 0x05, 0x0F, 0x05, 0x19, 0x05, 0x6A, 0x05, 0x70, 0x05, 0x7D, 0x05, 0x87, 0x05, 0x8C, 0x05,
/* 0840 */ 0x95, 0x05, 0x97, 0x05, 0x99, 0x05, 0x9B, 0x05, 0x9D, 0x05, 0xA1, 0x05, 0xAF, 0x05, 0xB1, 0x05,
/* 0850 */ 0xB7, 0x05, 0xB9, 0x05, 0xBB, 0x05, 0xBD, 0x05, 0xC6, 0x05, 0xC9, 0x05, 0xD3, 0x05, 0xE4, 0x05,
/* 0860 */ 0xEB, 0x05, 0xF0, 0x06, 0x08, 0x06, 0x12, 0x06, 0x14, 0x06, 0x16, 0x06, 0x18, 0x06, 0x1F, 0x06,
/* 0870 */ 0x21, 0x06, 0x27, 0x06, 0x2E,
/* char range info */
0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x28,
/* 0880 */ 0x00, 0x4F, 0x00, 0xA7, 0x01, 0x08, 0x01, 0x8E, 0x01, 0xF6, 0x02, 0x0D, 0x02, 0x59, 0x02, 0xA0,
/* 0890 */ 0x02, 0xD3, 0x02, 0xEB, 0x02, 0xF3, 0x02, 0xFF, 0x03, 0x03, 0x03, 0x45, 0x03, 0x9A, 0x03, 0xC0,
/* 08A0 */ 0x04, 0x01, 0x04, 0x4C, 0x04, 0x8D, 0x04, 0xD3, 0x05, 0x28, 0x05, 0x5D, 0x05, 0xB4, 0x06, 0x0B,
/* 08B0 */ 0x06, 0x12, 0x06, 0x1D, 0x06, 0x52, 0x06, 0x63, 0x06, 0x94, 0x06, 0xC9, 0x07, 0x87, 0x07, 0x8C,
/* 08C0 */ 0x07, 0xD6, 0x08, 0x15, 0x08, 0x5B, 0x08, 0x61, 0x08, 0x84, 0x08, 0xE2, 0x08, 0xFF, 0x09, 0x04,
/* 08D0 */ 0x09, 0x25, 0x09, 0x71, 0x09, 0x87, 0x0A, 0x09, 0x0A, 0x18, 0x0A, 0x1E, 0x0A, 0x58, 0x0A, 0xAB,
/* 08E0 */ 0x0A, 0xF4, 0x0B, 0x45, 0x0B, 0x5E, 0x0B, 0x65, 0x0B, 0xB1, 0x0C, 0x3F, 0x0C, 0x91, 0x0C, 0x9C,
/* 08F0 */ 0x0C, 0xD6, 0x0C, 0xF7, 0x0D, 0x3B, 0x0D, 0x5C, 0x0D, 0x84, 0x0D, 0x95, 0x0D, 0xAB, 0x0D, 0xB1,
/* 0900 */ 0x0D, 0xF7, 0x0E, 0x2A, 0x0E, 0x67, 0x0E, 0x6F, 0x0E, 0x9A, 0x0F, 0x03, 0x0F, 0x22, 0x0F, 0x29,
/* 0910 */ 0x0F, 0x45, 0x0F, 0x89, 0x0F, 0xAF, 0x0F, 0xD8, 0x0F, 0xEF, 0x0F, 0xF8, 0x10, 0x24, 0x10, 0x60,
/* 0920 */ 0x10, 0x88, 0x10, 0xC9, 0x10, 0xFA, 0x11, 0x02, 0x11, 0x40, 0x11, 0xAE, 0x11, 0xEF, 0x11, 0xF6,
/* 0930 */ 0x12, 0x27, 0x12, 0x66, 0x12, 0x75, 0x12, 0xBA, 0x05, 0x00, 0x10, 0x06, 0x61, 0x03, 0x4D, 0xA7,
/* 0940 */ 0xEE, 0x85, 0x75, 0x1E, 0x7E, 0x3C, 0x4C, 0x29, 0x32, 0xEF, 0x0D, 0x50, 0xEF, 0x60, 0x05, 0x1E,
/* 0950 */ 0x0C, 0x1A, 0x1E, 0x28, 0x03, 0x1D, 0xEC, 0x4B, 0x68, 0x36, 0x20, 0x1E, 0x08, 0x98, 0x03, 0x10,
/* 0960 */ 0x0A, 0x00, 0x61, 0x0E, 0x1A, 0x01, 0x3A, 0x25, 0x0D, 0x0F, 0x5C, 0x3A, 0x25, 0x0C, 0x7B, 0x32,
/* 0970 */ 0x7F, 0x0B, 0x0F, 0xAA, 0x9E, 0x19, 0x58, 0x50, 0x19, 0x0D, 0x81, 0x65, 0x2A, 0x19, 0x0C, 0x30,
/* 0980 */ 0x7F, 0x08, 0x95, 0x19, 0x0B, 0xB2, 0x10, 0x0C, 0xD9, 0x32, 0x19, 0x0D, 0x50, 0x01, 0x59, 0x22,
/* 0990 */ 0x19, 0x89, 0x00, 0x5D, 0x20, 0x00, 0x02, 0x3E, 0x41, 0x0D, 0x69, 0x0D, 0x65, 0x0D, 0x69, 0x0D,
/* 09A0 */ 0x65, 0x09, 0x0D, 0x0F, 0x30, 0x0A, 0x0D, 0x0F, 0x30, 0x09, 0x37, 0x0B, 0x1A, 0x77, 0x0F, 0x71,
/* 09B0 */ 0x25, 0x0D, 0x7B, 0x60, 0x02, 0x25, 0x89, 0x19, 0x32, 0x25, 0x02, 0x0F, 0x30, 0x6C, 0x22, 0x19,
/* 09C0 */ 0x26, 0x56, 0x3A, 0x26, 0x56, 0x3A, 0x2C, 0x3F, 0x0D, 0x0F, 0x30, 0x0A, 0x0D, 0x22, 0x87, 0x26,
/* 09D0 */ 0x71, 0xFB, 0x06, 0x25, 0x0C, 0x7B, 0x0B, 0x1A, 0x25, 0x32, 0x19, 0x0D, 0x50, 0x01, 0x10, 0x0C,
/* 09E0 */ 0x1D, 0x52, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x51, 0x82, 0x50, 0xA6, 0x3C, 0xA9,
/* 09F0 */ 0x68, 0x37, 0xA9, 0x22, 0x65, 0x85, 0x81, 0x03, 0x99, 0x0A, 0x5C, 0x31, 0x08, 0x41, 0x02, 0x5D,
/* 0A00 */ 0x50, 0x30, 0x86, 0x32, 0x95, 0x07, 0x02, 0x3C, 0x05, 0x56, 0x96, 0x7F, 0x05, 0x0D, 0x46, 0xAC,
/* 0A10 */ 0x3C, 0x06, 0x60, 0x84, 0x19, 0xE6, 0x32, 0x71, 0x2E, 0x6F, 0x07, 0x65, 0x02, 0x02, 0x41, 0x06,
/* 0A20 */ 0xA4, 0x94, 0x02, 0x63, 0x07, 0x02, 0x99, 0x0D, 0x6D, 0x02, 0x29, 0x2A, 0x56, 0x75, 0x37, 0x08,
/* 0A30 */ 0x9A, 0x80, 0xA1, 0x05, 0x55, 0x0A, 0x86, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x2E, 0x02, 0x6E, 0x10,
/* 0A40 */ 0x13, 0x29, 0x9D, 0x05, 0x94, 0x06, 0x0D, 0x81, 0x08, 0x00, 0xE6, 0x81, 0x04, 0x62, 0x9F, 0x6A,
/* 0A50 */ 0x19, 0x6C, 0x0D, 0x50, 0x03, 0x4A, 0x6C, 0x89, 0x0B, 0x0E, 0x1A, 0x19, 0x08, 0xA8, 0x2F, 0xE6,
/* 0A60 */ 0x0F, 0x2B, 0x99, 0x6E, 0x03, 0x22, 0x27, 0xE6, 0x0F, 0x2B, 0x99, 0x6E, 0x0C, 0x1A, 0x29, 0x6C,
/* 0A70 */ 0x89, 0x0B, 0x0E, 0x1A, 0x07, 0x53, 0x2C, 0x9F, 0x6A, 0x03, 0x84, 0x00, 0x07, 0x0D, 0x81, 0xA2,
/* 0A80 */ 0x60, 0x05, 0x83, 0x0A, 0xA2, 0x37, 0x06, 0x50, 0x0A, 0x64, 0x95, 0x03, 0x94, 0x02, 0x9E, 0x04,
/* 0A90 */ 0x46, 0x30, 0x94, 0x28, 0x06, 0x07, 0x0F, 0x71, 0xAD, 0x0F, 0x02, 0x2C, 0x05, 0x0F, 0x30, 0x9F,
/* 0AA0 */ 0x01, 0x00, 0x06, 0x50, 0x03, 0x62, 0x6C, 0x32, 0x03, 0x9F, 0x03, 0x9F, 0x02, 0x27, 0x1B, 0x0F,
/* 0AB0 */ 0x80, 0x97, 0x89, 0x8C, 0x2F, 0xE6, 0x22, 0x41, 0x28, 0xA4, 0x29, 0x02, 0x0C, 0x78, 0x1D, 0x6C,
/* 0AC0 */ 0x4B, 0x30, 0x05, 0x00, 0xAB, 0x10, 0x11, 0xD9, 0x54, 0x0D, 0x8B, 0x0C, 0x07, 0x7F, 0x02, 0x9A,
/* 0AD0 */ 0x30, 0x25, 0x09, 0x6D, 0x7D, 0xA4, 0x37, 0x0D, 0x20, 0x19, 0x32, 0x09, 0x37, 0xE8, 0x19, 0x0E,
/* 0AE0 */ 0xA8, 0x94, 0x3F, 0x50, 0x91, 0x6F, 0x02, 0x25, 0x0C, 0x89, 0xA4, 0x00, 0xA1, 0x42, 0xAC, 0x19,
/* 0AF0 */ 0x02, 0x03, 0x94, 0x02, 0x33, 0x6E, 0x77, 0x95, 0x05, 0x62, 0x6C, 0x0D, 0x89, 0x09, 0x6D, 0xA2,
/* 0B00 */ 0x32, 0x01, 0x29, 0x64, 0x05, 0x00, 0x64, 0x60, 0x09, 0x4A, 0x1B, 0x66, 0x19, 0x6F, 0x0F, 0x38,
/* 0B10 */ 0x4A, 0x1B, 0x50, 0x7C, 0x1B, 0x0F, 0x22, 0x02, 0x2C, 0x49, 0x30, 0x0B, 0x42, 0x89, 0x03, 0x2C,
/* 0B20 */ 0x09, 0x56, 0x30, 0x6F, 0x8E, 0x27, 0xE6, 0x0A, 0xFA, 0xE9, 0x19, 0xB0, 0x05, 0x10, 0x05, 0x00,
/* 0B30 */ 0x61, 0x0E, 0x1A, 0x1E, 0x0D, 0x50, 0x03, 0x1E, 0x60, 0x02, 0x1E, 0x28, 0x86, 0x77, 0x50, 0x51,
/* 0B40 */ 0x2A, 0x70, 0x08, 0x95, 0x10, 0x07, 0x27, 0xB1, 0x05, 0x01, 0x41, 0xC9, 0x81, 0x04, 0x1E, 0x60,
/* 0B50 */ 0xEE, 0x6F, 0x02, 0x2E, 0x0D, 0x50, 0xEE, 0x05, 0x66, 0x2F, 0x58, 0x22, 0x72, 0x32, 0xEE, 0x03,
/* 0B60 */ 0xA4, 0x2E, 0x6F, 0x04, 0x2E, 0x08, 0x66, 0x2E, 0x09, 0x0F, 0x7B, 0x57, 0x86, 0x09, 0x6D, 0x02,
/* 0B70 */ 0x2E, 0x08, 0x6D, 0x02, 0x3C, 0x3F, 0x66, 0x62, 0xAB, 0xA4, 0x72, 0x7E, 0x3C, 0x28, 0x8A, 0x6F,
/* 0B80 */ 0x02, 0x72, 0x32, 0x07, 0x2E, 0x9F, 0x38, 0x72, 0x0D, 0xA8, 0x1E, 0x05, 0x6E, 0x1E, 0x08, 0x03,
/* 0B90 */ 0x10, 0x07, 0x41, 0xB1, 0x05, 0x41, 0xC9, 0x0C, 0x71, 0x51, 0x3F, 0x84, 0x62, 0x0D, 0xA8, 0x1E,
/* 0BA0 */ 0x06, 0x3A, 0x72, 0x0E, 0xA8, 0x27, 0x58, 0x22, 0x1E, 0x06, 0x66, 0xC8, 0x2B, 0x2E, 0x85, 0x75,
/* 0BB0 */ 0x1E, 0x6A, 0x1E, 0x32, 0x8A, 0x0D, 0x22, 0x1E, 0x32, 0x8A, 0x6A, 0x1E, 0x6D, 0x0A, 0xC8, 0x7C,
/* 0BC0 */ 0x2E, 0x6F, 0x04, 0x2E, 0x09, 0x89, 0x1E, 0x32, 0x09, 0x5E, 0x02, 0x2E, 0x60, 0x0A, 0x2E, 0x05,
/* 0BD0 */ 0x50, 0x91, 0x2E, 0xA3, 0x7C, 0x70, 0x54, 0x10, 0x0A, 0x37, 0x74, 0x3F, 0x6E, 0x2E, 0x05, 0x0F,
/* 0BE0 */ 0x71, 0x51, 0x5F, 0x03, 0x50, 0x03, 0x04, 0x0B, 0x41, 0xAB, 0x50, 0x60, 0x60, 0x48, 0xFB, 0x56,
/* 0BF0 */ 0x21, 0x02, 0xA3, 0x89, 0x05, 0x02, 0x2F, 0x26, 0x6A, 0x7F, 0x9F, 0x09, 0x55, 0x0A, 0x3B, 0x0D,
/* 0C00 */ 0x0F, 0x02, 0x02, 0x81, 0x03, 0x51, 0x05, 0x19, 0x05, 0x01, 0x10, 0x0C, 0x37, 0x1C, 0x28, 0xDD,
/* 0C10 */ 0x0A, 0x23, 0x32, 0x0C, 0x23, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09, 0x3C, 0x28, 0xDD, 0x1D,
/* 0C20 */ 0x28, 0x05, 0x10, 0x05, 0x4A, 0xB3, 0x4B, 0xDB, 0x04, 0x81, 0x10, 0x09, 0x4A, 0x44, 0x23, 0x18,
/* 0C30 */ 0x3C, 0x0F, 0x56, 0x3C, 0x0F, 0x56, 0x10, 0x06, 0xB3, 0xC1, 0x10, 0x0B, 0xAE, 0x04, 0x06, 0x02,
/* 0C40 */ 0x4A, 0x58, 0x92, 0x2E, 0x0D, 0x6E, 0xA7, 0x03, 0x2E, 0x05, 0x89, 0x1E, 0x09, 0x20, 0x1E, 0x0D,
/* 0C50 */ 0xA8, 0x72, 0x0F, 0x1A, 0x5E, 0x86, 0x55, 0x8A, 0x0C, 0xA8, 0x2E, 0x85, 0x71, 0x4A, 0x31, 0x86,
/* 0C60 */ 0xA5, 0x8A, 0x60, 0xEE, 0x85, 0x71, 0x4A, 0x31, 0x02, 0x3C, 0x3F, 0x22, 0x1E, 0x28, 0x09, 0x1E,
/* 0C70 */ 0x32, 0x06, 0xC8, 0x0F, 0x02, 0x3C, 0x3F, 0x89, 0x41, 0xC9, 0x06, 0x06, 0x10, 0x0D, 0xD9, 0x02,
/* 0C80 */ 0x09, 0xFA, 0x96, 0x3B, 0x9A, 0x78, 0x59, 0x0D, 0x89, 0x0B, 0x32, 0x38, 0x65, 0x6F, 0x04, 0x99,
/* 0C90 */ 0x4C, 0x19, 0x8C, 0x1D, 0x60, 0x0C, 0x65, 0x32, 0x0C, 0x1B, 0x6D, 0x65, 0x6A, 0x2A, 0x0F, 0x02,
/* 0CA0 */ 0x2C, 0x6C, 0x4D, 0x19, 0x09, 0x6D, 0x02, 0x2C, 0x6C, 0x6A, 0x2A, 0x0F, 0x02, 0x94, 0x6A, 0x2A,
/* 0CB0 */ 0x0F, 0x02, 0x94, 0x0D, 0x0F, 0x30, 0x1B, 0x6D, 0x65, 0x8C, 0x1D, 0x60, 0x0C, 0x65, 0x6F, 0x04,
/* 0CC0 */ 0x99, 0x4C, 0x00, 0x6C, 0x0D, 0x89, 0x0B, 0x32, 0x38, 0x5D, 0x9A, 0x78, 0x7F, 0x02, 0x09, 0xFA,
/* 0CD0 */ 0xA6, 0x10, 0x0A, 0xD9, 0x9F, 0x7C, 0xC9, 0x0D, 0x6D, 0x7C, 0x7F, 0xA9, 0x07, 0x94, 0x2A, 0x95,
/* 0CE0 */ 0x4C, 0x41, 0x02, 0x0E, 0x0F, 0x8F, 0x4C, 0x2F, 0x05, 0x04, 0x00, 0x02, 0x4C, 0xBA, 0x4C, 0xBA,
/* 0CF0 */ 0x4C, 0xBA, 0x4C, 0xBA, 0x4C, 0xBA, 0x4C, 0x10, 0x0B, 0x61, 0x3F, 0x88, 0x98, 0xA2, 0x25, 0x39,
/* 0D00 */ 0x56, 0x91, 0x37, 0x0C, 0x89, 0x0B, 0x0D, 0x50, 0x30, 0x37, 0x02, 0x0C, 0x8E, 0x19, 0x0D, 0x6D,
/* 0D10 */ 0x02, 0x59, 0x01, 0x2A, 0x5C, 0x57, 0x02, 0x2E, 0xF2, 0x7F, 0x3F, 0xA4, 0x00, 0xC9, 0x50, 0x30,
/* 0D20 */ 0x1D, 0xA1, 0x0D, 0x50, 0x91, 0x51, 0x28, 0x78, 0x57, 0x05, 0x25, 0x2A, 0x71, 0x51, 0x6F, 0x0E,
/* 0D30 */ 0x18, 0x05, 0x65, 0xA9, 0xA4, 0x65, 0xA9, 0x6B, 0x10, 0x0B, 0x61, 0x3F, 0x88, 0x81, 0xB4, 0x00,
/* 0D40 */ 0x5D, 0x0D, 0x46, 0x1A, 0x94, 0x3F, 0x89, 0x0B, 0x60, 0x81, 0x25, 0x06, 0x07, 0x2A, 0x0F, 0x02,
/* 0D50 */ 0x2E, 0x06, 0x50, 0xAA, 0xC9, 0x0D, 0x20, 0x3C, 0x49, 0x0F, 0x87, 0x7F, 0x08, 0x6A, 0x05, 0x7F,
/* 0D60 */ 0x3F, 0x0B, 0x0D, 0x4D, 0x51, 0x9F, 0x71, 0x00, 0xA7, 0xEE, 0x03, 0x4D, 0x90, 0x6C, 0x0C, 0x08,
/* 0D70 */ 0x2A, 0x7C, 0x65, 0x0C, 0x89, 0x0B, 0x0D, 0x6D, 0x38, 0x65, 0xA3, 0x56, 0xAC, 0x25, 0x02, 0x08,
/* 0D80 */ 0x63, 0x98, 0x5B, 0x10, 0x0C, 0x9D, 0x02, 0x86, 0x1B, 0xB2, 0x05, 0x72, 0x4C, 0x62, 0x64, 0x02,
/* 0D90 */ 0x2E, 0x0D, 0x20, 0xC8, 0x71, 0x2E, 0x09, 0x89, 0x72, 0x0E, 0x53, 0x60, 0x05, 0x37, 0x6F, 0x8D,
/* 0DA0 */ 0x32, 0x05, 0x37, 0xF0, 0x19, 0x50, 0x71, 0x65, 0x02, 0x0F, 0x6E, 0x02, 0x50, 0x71, 0x65, 0x64,
/* 0DB0 */ 0x46, 0x89, 0x94, 0x64, 0x46, 0x89, 0x94, 0x05, 0x18, 0x28, 0x30, 0x0A, 0x00, 0xC9, 0x50, 0x71,
/* 0DC0 */ 0xC8, 0x71, 0xC8, 0x71, 0x10, 0x0C, 0x00, 0x61, 0x60, 0x46, 0x71, 0x37, 0x60, 0x56, 0x02, 0x37,
/* 0DD0 */ 0x0C, 0x89, 0x18, 0x25, 0xE8, 0x1E, 0xE8, 0x1E, 0x60, 0xA0, 0x8B, 0x96, 0x25, 0x60, 0x46, 0x45,
/* 0DE0 */ 0x37, 0x60, 0xA0, 0x32, 0x75, 0x5D, 0x04, 0x03, 0x19, 0x02, 0x0F, 0x89, 0x1E, 0x28, 0xAA, 0x57,
/* 0DF0 */ 0x86, 0x0C, 0x89, 0x94, 0x3F, 0x0D, 0x02, 0x19, 0x67, 0x0A, 0x90, 0x3F, 0x6A, 0x33, 0x5C, 0x90,
/* 0E00 */ 0x6C, 0x0C, 0x56, 0x71, 0x7F, 0x06, 0x0B, 0x0E, 0x81, 0xB4, 0x10, 0x0D, 0x61, 0xE6, 0x0A, 0x0E,
/* 0E10 */ 0x81, 0xB4, 0x7F, 0x2D, 0x21, 0x6F, 0x0E, 0x0B, 0x0C, 0x45, 0x59, 0x32, 0x8E, 0x00, 0x6C, 0x25,
/* 0E20 */ 0x06, 0x66, 0x2E, 0x8C, 0x03, 0x0B, 0x8B, 0x09, 0x01, 0x37, 0x0E, 0x22, 0x42, 0x30, 0x37, 0x50,
/* 0E30 */ 0x6A, 0x0D, 0x4C, 0x6C, 0x0F, 0x89, 0x03, 0x6C, 0x32, 0x0C, 0x90, 0x6C, 0x6A, 0x1D, 0x8C, 0x65,
/* 0E40 */ 0x32, 0x0C, 0x1B, 0x6D, 0x65, 0x0C, 0x89, 0x1D, 0xF0, 0x65, 0x64, 0x04, 0x99, 0x50, 0x75, 0x94,
/* 0E50 */ 0x6C, 0x0E, 0x89, 0x0B, 0x0E, 0x66, 0x37, 0x49, 0x0F, 0xA4, 0x3B, 0x0A, 0x0E, 0x81, 0xA6, 0x10,
/* 0E60 */ 0x0A, 0x61, 0x0C, 0x56, 0x22, 0x37, 0x0C, 0x56, 0x22, 0x37, 0x08, 0x18, 0x50, 0x30, 0xC8, 0x7C,
/* 0E70 */ 0x2E, 0x09, 0x6D, 0x02, 0x1D, 0xA1, 0x0E, 0x20, 0x5E, 0x05, 0x2E, 0x8C, 0x00, 0xA7, 0x08, 0x2E,
/* 0E80 */ 0x08, 0x66, 0x2E, 0x32, 0x0C, 0x5E, 0x06, 0x2E, 0x28, 0x38, 0xA7, 0x0A, 0x65, 0xEA, 0x04, 0x0A,
/* 0E90 */ 0x81, 0x1D, 0x72, 0x03, 0x10, 0x0D, 0xD9, 0x06, 0x0B, 0x9E, 0x5F, 0x7F, 0xDE, 0xA8, 0x37, 0x64,
/* 0EA0 */ 0xA0, 0x0E, 0x66, 0x65, 0x0B, 0x22, 0x00, 0x99, 0x4C, 0x19, 0xE8, 0x1D, 0x4C, 0x00, 0xFB, 0x38,
/* 0EB0 */ 0x99, 0x6D, 0x02, 0x65, 0xF9, 0x0E, 0x07, 0x0D, 0x0F, 0x2B, 0x00, 0x5D, 0x9A, 0x07, 0xA1, 0x0A,
/* 0EC0 */ 0x22, 0x6D, 0x75, 0x37, 0x28, 0x0C, 0x00, 0x9B, 0x7E, 0x62, 0x99, 0x50, 0x71, 0x1D, 0x8C, 0x94,
/* 0ED0 */ 0x6F, 0x04, 0x1D, 0x09, 0x3A, 0xAB, 0x0F, 0x53, 0x6C, 0x0D, 0x89, 0x65, 0x0D, 0x6D, 0xA0, 0x32,
/* 0EE0 */ 0x75, 0x47, 0x32, 0x46, 0x5A, 0x37, 0x54, 0x88, 0x0F, 0xA0, 0x05, 0x10, 0x0C, 0xD9, 0x06, 0x0B,
/* 0EF0 */ 0x0E, 0x98, 0xA2, 0xA1, 0x7A, 0x22, 0x02, 0x90, 0x2A, 0x81, 0x60, 0x30, 0x65, 0x02, 0x6A, 0x00,
/* 0F00 */ 0x9F, 0x78, 0x94, 0x49, 0x05, 0x19, 0x67, 0x08, 0x94, 0x64, 0x04, 0x19, 0x02, 0x4D, 0x90, 0x6F,
/* 0F10 */ 0x05, 0x00, 0x6C, 0x6A, 0x90, 0x99, 0x4D, 0x9F, 0xAF, 0x94, 0x0D, 0x50, 0x30, 0x33, 0x75, 0x47,
/* 0F20 */ 0x32, 0x89, 0xA4, 0x5D, 0x0B, 0x8B, 0x08, 0x0A, 0x66, 0x51, 0xF9, 0x0C, 0x1D, 0xA1, 0x0D, 0x50,
/* 0F30 */ 0x71, 0x3C, 0x06, 0x42, 0x21, 0x02, 0x09, 0x42, 0x75, 0x19, 0x76, 0x81, 0x05, 0x51, 0x63, 0x5F,
/* 0F40 */ 0x1E, 0x02, 0x10, 0x06, 0x4F, 0x1C, 0xC1, 0x74, 0xC1, 0x10, 0x06, 0x4F, 0x1C, 0xC1, 0x4A, 0x74,
/* 0F50 */ 0x4B, 0xDB, 0x04, 0x81, 0x10, 0x0B, 0xEC, 0x9D, 0xAB, 0xEF, 0xB0, 0x0F, 0x38, 0x3C, 0x06, 0x0D,
/* 0F60 */ 0x0F, 0xA4, 0x37, 0x4E, 0x0D, 0x6D, 0x30, 0x05, 0x1D, 0xAB, 0x32, 0x20, 0x04, 0x7F, 0x49, 0xA6,
/* 0F70 */ 0x51, 0x49, 0x8F, 0x4A, 0xAB, 0x32, 0x20, 0x04, 0x3C, 0x4E, 0x42, 0x30, 0x06, 0x3C, 0xD7, 0x0D,
/* 0F80 */ 0x0F, 0xA4, 0x2E, 0xB0, 0x0F, 0x38, 0x70, 0x05, 0x06, 0x10, 0x0B, 0x4A, 0x4F, 0x1C, 0x23, 0x18,
/* 0F90 */ 0xFF, 0x46, 0x1A, 0x27, 0xAE, 0x23, 0x18, 0xFF, 0x46, 0x1A, 0x10, 0x0B, 0xB1, 0x61, 0x99, 0xEF,
/* 0FA0 */ 0x19, 0x0B, 0x81, 0x73, 0xA7, 0x95, 0xA2, 0xC9, 0x0A, 0x50, 0x89, 0xB4, 0x3C, 0x02, 0x09, 0x42,
/* 0FB0 */ 0x7C, 0x51, 0x54, 0x32, 0x09, 0x51, 0x4E, 0x32, 0x09, 0x7F, 0x02, 0x55, 0x4C, 0x19, 0x97, 0xDE,
/* 0FC0 */ 0xB4, 0x76, 0x95, 0x5B, 0x3C, 0x0B, 0x95, 0x73, 0x62, 0xAB, 0x73, 0x10, 0x0B, 0x19, 0x61, 0x93,
/* 0FD0 */ 0x9E, 0x5F, 0xA1, 0xDE, 0x6E, 0x65, 0x49, 0x0C, 0x33, 0xAA, 0x19, 0xAB, 0x0C, 0x8D, 0xFB, 0x78,
/* 0FE0 */ 0x2F, 0x58, 0x66, 0x51, 0x09, 0x6A, 0x19, 0xA1, 0x0B, 0x6D, 0x5A, 0x7F, 0x9F, 0x80, 0x51, 0x60,
/* 0FF0 */ 0x0A, 0x1E, 0x0D, 0x6E, 0xEC, 0x3F, 0x98, 0x03, 0xC8, 0x30, 0xC8, 0x0F, 0x8A, 0x08, 0x98, 0x03,
/* 1000 */ 0x10, 0x16, 0xD9, 0xE6, 0x09, 0x0C, 0x9E, 0x0C, 0x09, 0x48, 0x04, 0x0D, 0x69, 0x68, 0x2C, 0x64,
/* 1010 */ 0x95, 0x0C, 0x0B, 0x0B, 0x42, 0x2B, 0x27, 0x3F, 0x6A, 0x04, 0x04, 0x09, 0x0A, 0x09, 0x05, 0x03,
/* 1020 */ 0x0A, 0x50, 0x71, 0x27, 0x67, 0x08, 0x77, 0x6D, 0x22, 0x02, 0xA5, 0x38, 0x2F, 0xE8, 0x9F, 0x6D,
/* 1030 */ 0x1A, 0x00, 0x60, 0x07, 0x41, 0x67, 0x02, 0x01, 0x32, 0x9C, 0x0D, 0x1A, 0x00, 0x06, 0x0F, 0x30,
/* 1040 */ 0x00, 0x2A, 0x0C, 0x24, 0x0C, 0x1A, 0x99, 0x6D, 0x41, 0x0C, 0xA8, 0x9F, 0x0B, 0x19, 0x0C, 0x1A,
/* 1050 */ 0x00, 0x02, 0x6D, 0x02, 0x1D, 0x32, 0x06, 0xFB, 0x0A, 0x19, 0x0C, 0x1A, 0x00, 0x02, 0x3A, 0x1D,
/* 1060 */ 0x32, 0x05, 0xFB, 0x0A, 0x19, 0x0C, 0x1A, 0x99, 0x6D, 0x41, 0x32, 0x05, 0x9F, 0x0A, 0x19, 0x0C,
/* 1070 */ 0x1A, 0x00, 0x05, 0x0F, 0x30, 0x41, 0x0C, 0x6E, 0x06, 0x22, 0x6C, 0x32, 0x06, 0x77, 0x0F, 0x80,
/* 1080 */ 0x1B, 0x92, 0x02, 0x6D, 0x7D, 0x30, 0x95, 0x60, 0x38, 0x41, 0x06, 0x50, 0x38, 0xFB, 0x0F, 0x30,
/* 1090 */ 0x02, 0x42, 0x2B, 0x41, 0x6C, 0x0E, 0xA8, 0x19, 0x08, 0x63, 0x0B, 0x02, 0x97, 0x88, 0x0C, 0x04,
/* 10A0 */ 0x4A, 0x64, 0xEF, 0x0B, 0x6D, 0xA6, 0x41, 0x6C, 0x03, 0x2C, 0x6C, 0x7A, 0xA0, 0x0B, 0x7D, 0x50,
/* 10B0 */ 0x01, 0x2C, 0x3F, 0x0E, 0x56, 0xA4, 0x65, 0xD7, 0x0A, 0x63, 0x0F, 0x98, 0x0A, 0x9C, 0x10, 0x0D,
/* 10C0 */ 0x00, 0xD9, 0xE0, 0x10, 0x0D, 0xE7, 0x50, 0x89, 0xA0, 0x73, 0x58, 0x56, 0x89, 0x48, 0x0A, 0x6A,
/* 10D0 */ 0x0B, 0x42, 0x38, 0x00, 0x1F, 0x60, 0x78, 0x26, 0x7B, 0x77, 0x66, 0x26, 0x7B, 0x04, 0xF2, 0x26,
/* 10E0 */ 0x56, 0x30, 0x02, 0x2C, 0x1B, 0x46, 0x22, 0x06, 0x58, 0x6A, 0x0B, 0x0D, 0x6D, 0x8E, 0x00, 0x1F,
/* 10F0 */ 0x08, 0x0F, 0x53, 0x1F, 0x85, 0x81, 0x00, 0x1F, 0x85, 0x95, 0x00, 0x1F, 0x07, 0x6A, 0x26, 0x20,
/* 1100 */ 0x0B, 0x0D, 0x6D, 0x71, 0x26, 0x56, 0xA8, 0x2C, 0x1B, 0x6D, 0x89, 0x0C, 0x8F, 0x10, 0x0D, 0x61,
/* 1110 */ 0xE6, 0x0A, 0xFA, 0xE9, 0x65, 0x2A, 0x46, 0x8E, 0x00, 0x26, 0x89, 0x0B, 0x0C, 0x53, 0x31, 0x0D,
/* 1120 */ 0x02, 0x19, 0x82, 0x58, 0x6B, 0x2F, 0x85, 0x95, 0x00, 0xA7, 0x0C, 0x36, 0x20, 0x00, 0xA7, 0x0C,
/* 1130 */ 0x72, 0x0F, 0x89, 0x1E, 0x28, 0x78, 0x5E, 0x0D, 0x02, 0x19, 0x02, 0x96, 0x19, 0x26, 0x89, 0x0B,
/* 1140 */ 0x28, 0x45, 0x65, 0xAD, 0x46, 0x30, 0x02, 0x25, 0x05, 0x0A, 0xFA, 0xE9, 0x10, 0x0E, 0xE7, 0x0F,
/* 1150 */ 0x6D, 0x98, 0x0A, 0x9C, 0x58, 0x56, 0x89, 0x48, 0x0A, 0x6A, 0x0B, 0x42, 0x91, 0x00, 0x1F, 0x08,
/* 1160 */ 0x6A, 0x26, 0x7B, 0x19, 0x0E, 0x3A, 0x1F, 0x77, 0x50, 0x71, 0x1F, 0x9F, 0x7C, 0x1F, 0x00, 0x64,
/* 1170 */ 0x08, 0x1F, 0x00, 0x64, 0x07, 0x1F, 0x9F, 0x2B, 0x1F, 0x77, 0x0F, 0x1A, 0x1F, 0x01, 0x0E, 0x3A,
/* 1180 */ 0x1F, 0x09, 0x4D, 0x62, 0x1B, 0x6A, 0x0B, 0x42, 0x91, 0x26, 0x46, 0x22, 0x8D, 0x26, 0x50, 0x22,
/* 1190 */ 0x0A, 0x05, 0x10, 0x0B, 0xE7, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0xE7, 0x0F, 0x56, 0x71, 0x58, 0x46,
/* 11A0 */ 0x66, 0x58, 0x6A, 0x23, 0x23, 0x01, 0x58, 0x40, 0x40, 0x46, 0x6E, 0x58, 0x46, 0x6E, 0x58, 0x6A,
/* 11B0 */ 0x0A, 0x23, 0x05, 0x00, 0x58, 0x40, 0x40, 0x0F, 0x7B, 0x57, 0x02, 0x10, 0x0E, 0xD9, 0x99, 0x08,
/* 11C0 */ 0x88, 0x98, 0xB4, 0x25, 0xA9, 0xA8, 0x65, 0x08, 0x6D, 0x30, 0x0B, 0x0D, 0xA8, 0x31, 0x0D, 0x03,
/* 11D0 */ 0x19, 0x99, 0x05, 0x2C, 0x1B, 0x50, 0x71, 0x2E, 0x0E, 0x89, 0x00, 0xA7, 0x0C, 0x00, 0xFB, 0x66,
/* 11E0 */ 0x29, 0x99, 0x6A, 0x3F, 0x50, 0x66, 0x27, 0xE6, 0x6A, 0x00, 0x97, 0x0A, 0x0D, 0x66, 0x29, 0x99,
/* 11F0 */ 0x50, 0x30, 0x19, 0x3F, 0x66, 0x2C, 0x85, 0x81, 0x19, 0x3F, 0x66, 0x90, 0x0C, 0x0F, 0x7B, 0x3F,
/* 1200 */ 0x66, 0x90, 0x64, 0x0A, 0x1D, 0x08, 0x66, 0x2C, 0x6C, 0x0D, 0x6D, 0xA0, 0x33, 0x5C, 0x90, 0x39,
/* 1210 */ 0x50, 0x56, 0x5A, 0x65, 0xD7, 0x0B, 0x9E, 0x0C, 0x8F, 0x10, 0x0E, 0x2C, 0x9D, 0xBB, 0xBB, 0xBB,
/* 1220 */ 0x62, 0x1B, 0x69, 0x7B, 0x4A, 0x1B, 0x69, 0x7B, 0x4A, 0x1B, 0x6A, 0x0A, 0x23, 0x42, 0x02, 0x1F,
/* 1230 */ 0x77, 0x6D, 0x02, 0xBB, 0xBB, 0xBB, 0x10, 0x06, 0xE7, 0xF3, 0x02, 0x10, 0x07, 0x00, 0x61, 0xD3,
/* 1240 */ 0x0B, 0x2E, 0xD3, 0x0B, 0x2E, 0xD3, 0x0A, 0x4A, 0x31, 0xEE, 0x0A, 0x50, 0x71, 0x19, 0xA1, 0x28,
/* 1250 */ 0x81, 0x51, 0x85, 0x81, 0x02, 0x2F, 0x58, 0x75, 0x01, 0x1E, 0x02, 0x01, 0x10, 0x0E, 0xE7, 0x6D,
/* 1260 */ 0x02, 0x1D, 0x6F, 0x08, 0x1F, 0x01, 0xF2, 0x1F, 0x55, 0x78, 0x26, 0x7B, 0x04, 0x0F, 0x53, 0x26,
/* 1270 */ 0x7B, 0x0D, 0x50, 0x45, 0x2C, 0x1B, 0x6D, 0x82, 0x6B, 0x77, 0x0F, 0x1A, 0x0E, 0x92, 0x58, 0x6A,
/* 1280 */ 0xA4, 0x00, 0x58, 0x6D, 0x49, 0x45, 0x58, 0x6D, 0x02, 0x09, 0x0F, 0xA8, 0x58, 0x6D, 0x02, 0x02,
/* 1290 */ 0x6D, 0x91, 0x00, 0x26, 0x7B, 0x08, 0x4D, 0x26, 0x7B, 0x01, 0x32, 0x5C, 0x1F, 0x64, 0x0C, 0x26,
/* 12A0 */ 0x7B, 0x19, 0x0D, 0xA4, 0x1F, 0x00, 0x49, 0x38, 0x10, 0x0B, 0xE7, 0x40, 0x40, 0x40, 0x40, 0x40,
/* 12B0 */ 0x40, 0x0F, 0x7B, 0x57, 0x0B, 0x23, 0x23, 0x09, 0x58, 0x46, 0x6A, 0x58, 0x56, 0x53, 0x10, 0x11,
/* 12C0 */ 0x61, 0x99, 0x0F, 0x6A, 0x1D, 0x64, 0x7C, 0x29, 0x67, 0x95, 0x1B, 0x50, 0xA8, 0x29, 0x49, 0x7B,
/* 12D0 */ 0x00, 0x33, 0x75, 0x29, 0x06, 0x89, 0x1A, 0x19, 0x89, 0x92, 0x27, 0x3F, 0x0F, 0x30, 0x6E, 0x02,
/* 12E0 */ 0x50, 0xE8, 0x62, 0x9F, 0x09, 0x92, 0x05, 0x0F, 0x75, 0x22, 0x27, 0x2A, 0x09, 0x0C, 0x81, 0x9F,
/* 12F0 */ 0x06, 0x89, 0x27, 0x1B, 0x0F, 0x75, 0x55, 0xAD, 0x0C, 0x6F, 0x29, 0x28, 0x09, 0x06, 0x1A, 0x0D,
/* 1300 */ 0x75, 0x06, 0x3A, 0x62, 0x0D, 0x50, 0xB4, 0x0F, 0x7C, 0x0F, 0x2B, 0x49, 0x02, 0x62, 0x0E, 0x0F,
/* 1310 */ 0x80, 0x0E, 0x81, 0x50, 0x03, 0x05, 0x66, 0x62, 0x50, 0x80, 0x7A, 0x97, 0x0F, 0x1A, 0x4A, 0x85,
/* 1320 */ 0x7C, 0x9F, 0x30, 0x99, 0x50, 0x71, 0x4A, 0x02, 0x0F, 0x6E, 0x49, 0x09, 0x99, 0xA4, 0x27, 0x99,
/* 1330 */ 0xA4, 0x6C, 0x05, 0x05, 0x05, 0x02, 0x00, 0x02, 0x50, 0x7C, 0x1D, 0xE6, 0xA4, 0x4A, 0x02, 0x7E,
/* 1340 */ 0x10, 0x0E, 0xE7, 0x6D, 0xCD, 0x50, 0x01, 0x62, 0x1B, 0xE5, 0xA6, 0x22, 0x03, 0x3A, 0xB7, 0x10,
/* 1350 */ 0x0F, 0x00, 0xD9, 0xC6, 0xB6, 0x10, 0x0D, 0xE7, 0x6D, 0x89, 0x0B, 0x73, 0x58, 0x56, 0x89, 0x8D,
/* 1360 */ 0x26, 0x20, 0x0B, 0x42, 0x38, 0x26, 0x7B, 0x01, 0x0C, 0x0F, 0x6E, 0x1F, 0x05, 0x4D, 0x1F, 0x04,
/* 1370 */ 0x4D, 0x1F, 0x64, 0x09, 0x26, 0x50, 0x02, 0x01, 0x04, 0x32, 0x78, 0x26, 0x46, 0x6A, 0x2C, 0x1B,
/* 1380 */ 0x50, 0x56, 0x87, 0x26, 0x20, 0x0A, 0x09, 0x07, 0x02, 0x00, 0x58, 0x40, 0x40, 0x6D, 0x02, 0x10,
/* 1390 */ 0x0F, 0x00, 0xD9, 0x06, 0x0B, 0x9E, 0x0B, 0x07, 0xA1, 0x0C, 0x46, 0x22, 0x02, 0x65, 0x28, 0x95,
/* 13A0 */ 0x0B, 0x0D, 0x6D, 0x43, 0x06, 0x2F, 0xE6, 0x6A, 0x2F, 0x09, 0xA4, 0x62, 0x99, 0x50, 0x30, 0x19,
/* 13B0 */ 0x1B, 0x0F, 0x1A, 0x29, 0x85, 0x95, 0x2F, 0x33, 0x02, 0x2C, 0x0C, 0x66, 0x19, 0x6C, 0x6A, 0x90,
/* 13C0 */ 0x06, 0x6A, 0x2A, 0x0E, 0x03, 0x94, 0x60, 0x95, 0x0B, 0x0D, 0x89, 0x48, 0x02, 0x0C, 0x56, 0x7C,
/* 13D0 */ 0x03, 0x25, 0x06, 0x0C, 0x9A, 0x81, 0x06, 0x3C, 0x02, 0x06, 0x33, 0x91, 0x51, 0x9F, 0x05, 0x2E,
/* 13E0 */ 0x3F, 0x08, 0x10, 0x0D, 0xE7, 0x6D, 0x89, 0x0C, 0x5B, 0x58, 0x56, 0xA4, 0x2C, 0x1B, 0x6A, 0x0B,
/* 13F0 */ 0x32, 0x7B, 0x1F, 0x0A, 0x50, 0x80, 0x1F, 0x05, 0x4D, 0x1F, 0x6F, 0x09, 0x26, 0x7B, 0x03, 0x0D,
/* 1400 */ 0x50, 0x71, 0x26, 0x46, 0x6A, 0x00, 0x26, 0x56, 0x75, 0x01, 0x2C, 0x1B, 0x6A, 0x0D, 0x6D, 0x02,
/* 1410 */ 0x58, 0x6D, 0x02, 0x03, 0x4D, 0x00, 0x26, 0x7B, 0x28, 0x5C, 0x26, 0x7B, 0x04, 0x6A, 0x19, 0x1F,
/* 1420 */ 0x28, 0x78, 0x00, 0x1F, 0x67, 0x0C, 0x26, 0x7B, 0x19, 0x60, 0x71, 0x10, 0x0C, 0xD9, 0x07, 0x88,
/* 1430 */ 0x81, 0x0A, 0x05, 0xA1, 0x0D, 0x56, 0x30, 0x02, 0x65, 0x28, 0x95, 0x0B, 0x0C, 0x89, 0x03, 0x94,
/* 1440 */ 0x02, 0x6D, 0x45, 0x19, 0x02, 0x5F, 0x47, 0x50, 0x30, 0x72, 0x0F, 0x6D, 0x73, 0x57, 0x95, 0x09,
/* 1450 */ 0x04, 0x7F, 0xAD, 0x46, 0x0C, 0x02, 0x2F, 0xAB, 0xDE, 0x91, 0x3C, 0x02, 0x4B, 0x4D, 0x27, 0x31,
/* 1460 */ 0x0D, 0x72, 0x0F, 0x89, 0x65, 0x09, 0x0B, 0x03, 0x1D, 0x06, 0x6A, 0x94, 0x08, 0x6D, 0xA0, 0x33,
/* 1470 */ 0x71, 0x94, 0x02, 0x60, 0x46, 0x7C, 0x25, 0x05, 0x0A, 0xFA, 0x0D, 0x8F, 0x10, 0x0C, 0x61, 0x60,
/* 1480 */ 0x46, 0x6A, 0x94, 0x60, 0x56, 0xA8, 0x94, 0x09, 0x23, 0x28, 0x95, 0x23, 0x5F, 0xA1, 0x6D, 0xF4,
/* 1490 */ 0x01, 0x6D, 0xF4, 0x85, 0x30, 0x10, 0x0E, 0x00, 0x61, 0x0E, 0x89, 0xD4, 0x10, 0x0D, 0x00, 0x9D,
/* 14A0 */ 0xA7, 0x0C, 0x1D, 0x6C, 0x6A, 0x90, 0x0D, 0x6D, 0xE6, 0x4C, 0x55, 0x5C, 0x3F, 0x66, 0x90, 0x05,
/* 14B0 */ 0xA4, 0x1B, 0x89, 0x94, 0x85, 0x75, 0x1D, 0x0D, 0x20, 0x65, 0xF0, 0x19, 0x85, 0x7C, 0x94, 0x9F,
/* 14C0 */ 0xAA, 0x67, 0x8D, 0x31, 0x04, 0x00, 0x07, 0x89, 0x37, 0x85, 0x7C, 0x77, 0x20, 0x25, 0x0B, 0x92,
/* 14D0 */ 0x0D, 0x6E, 0x65, 0x9F, 0x38, 0x66, 0x1D, 0x31, 0x05, 0x89, 0x3C, 0x32, 0x28, 0x0A, 0x3C, 0x7A,
/* 14E0 */ 0x7C, 0x25, 0x3F, 0x50, 0x66, 0xC9, 0x50, 0x89, 0x10, 0x13, 0x61, 0x0B, 0x6D, 0x1D, 0x60, 0x71,
/* 14F0 */ 0x19, 0x49, 0x04, 0x2F, 0x08, 0x3A, 0x19, 0x32, 0x7C, 0x3F, 0x3A, 0x2F, 0x6F, 0x8D, 0x85, 0x53,
/* 1500 */ 0xFB, 0x0E, 0x27, 0x67, 0x05, 0x99, 0x0F, 0x6A, 0x19, 0x28, 0x0C, 0x27, 0x02, 0xA4, 0x00, 0x05,
/* 1510 */ 0x0F, 0x30, 0x95, 0x19, 0x60, 0x0A, 0x4A, 0x50, 0x80, 0x08, 0x95, 0x08, 0x0F, 0xAA, 0x32, 0x07,
/* 1520 */ 0x4A, 0x0D, 0x92, 0x0A, 0x30, 0x06, 0x50, 0x03, 0x85, 0x71, 0x41, 0x1B, 0x20, 0x00, 0x0C, 0x0F,
/* 1530 */ 0x5F, 0x0F, 0x71, 0x03, 0x66, 0x4A, 0x08, 0x22, 0x00, 0x0E, 0x0F, 0x5B, 0x0F, 0x7C, 0x05, 0x3A,
/* 1540 */ 0x4A, 0x06, 0x89, 0x85, 0x06, 0x00, 0x0F, 0x75, 0x07, 0x22, 0x62, 0x67, 0x05, 0x0F, 0x5C, 0xFD,
/* 1550 */ 0x08, 0x20, 0x62, 0x02, 0x6D, 0x55, 0x01, 0x77, 0x81, 0x0A, 0x53, 0x62, 0x32, 0x0C, 0x95, 0x00,
/* 1560 */ 0x9F, 0x60, 0x06, 0x29, 0x33, 0x30, 0x19, 0x6F, 0x1A, 0x27, 0x1B, 0x0F, 0x4D, 0x97, 0x46, 0x02,
/* 1570 */ 0x62, 0x9F, 0x6E, 0x00, 0x02, 0x46, 0x10, 0x0D, 0x61, 0x55, 0x7C, 0x1D, 0x0B, 0x66, 0x2C, 0x6C,
/* 1580 */ 0xF2, 0x00, 0x02, 0x4D, 0x90, 0x9F, 0x78, 0x9F, 0x5C, 0x90, 0x6C, 0x32, 0x09, 0x01, 0x32, 0x21,
/* 1590 */ 0x08, 0x89, 0x64, 0x02, 0xA1, 0x42, 0xA8, 0x7F, 0x9F, 0x84, 0x2F, 0x02, 0x0F, 0x4D, 0x3C, 0x64,
/* 15A0 */ 0x7B, 0xA1, 0x9A, 0x09, 0x37, 0x3F, 0x89, 0x08, 0x6D, 0x02, 0x25, 0x32, 0x09, 0x85, 0x75, 0x37,
/* 15B0 */ 0x06, 0x66, 0x77, 0x6D, 0x02, 0x65, 0x0D, 0x22, 0x19, 0x67, 0x09, 0x94, 0x6F, 0x07, 0x1D, 0x0D,
/* 15C0 */ 0x6D, 0x02, 0x90, 0x0D, 0x3A, 0x1D, 0x64, 0x09, 0x10, 0x0D, 0x9D, 0x72, 0x42, 0xC3, 0x6D, 0xD8,
/* 15D0 */ 0x2E, 0x06, 0xA4, 0x10, 0x0C, 0x61, 0x85, 0x46, 0x66, 0x94, 0x85, 0x46, 0x66, 0x65, 0x18, 0x7A,
/* 15E0 */ 0x02, 0x51, 0x08, 0x4D, 0xC9, 0x6D, 0x91, 0x51, 0x60, 0x7C, 0x51, 0x6F, 0x0C, 0x1D, 0xA1, 0x0E,
/* 15F0 */ 0x66, 0x51, 0x09, 0x0F, 0x53, 0xC9, 0x6D, 0x38, 0x51, 0x0C, 0xA4, 0x7F, 0x3F, 0x6A, 0x1D, 0xA1,
/* 1600 */ 0x0E, 0x66, 0x25, 0x2A, 0x95, 0x18, 0xA6, 0x26, 0x56, 0x66, 0x26, 0x56, 0x3A, 0x10, 0x07, 0x25,
/* 1610 */ 0xB1, 0xAB, 0x18, 0x06, 0x3C, 0x49, 0x53, 0x7F, 0x49, 0x53, 0x7F, 0xD6, 0xD6, 0xD6, 0xD6, 0xD6,
/* 1620 */ 0x49, 0x02, 0x5E, 0x02, 0x5E, 0x0B, 0x0A, 0x06, 0x3C, 0x49, 0x53, 0x7F, 0x49, 0x53, 0x10, 0x0B,
/* 1630 */ 0x29, 0xB1, 0x72, 0x05, 0x05, 0x1E, 0x06, 0x22, 0x62, 0x31, 0x02, 0x1E, 0x50, 0x71, 0x1E, 0x28,
/* 1640 */ 0xEE, 0x9F, 0x8A, 0x67, 0x86, 0x85, 0x71, 0x1E, 0x0C, 0xA8, 0x2E, 0x9F, 0x8A, 0x49, 0x86, 0x85,
/* 1650 */ 0x78, 0x1E, 0x0D, 0xA8, 0x1E, 0x09, 0x20, 0x00, 0x5E, 0x19, 0xA7, 0x04, 0x1E, 0x0D, 0x6E, 0x2F,
/* 1660 */ 0x58, 0x20, 0x1E, 0x06, 0x89, 0x1E, 0x02, 0x66, 0x1E, 0x32, 0x07, 0x27, 0x58, 0x92, 0x2E, 0x05,
/* 1670 */ 0x07, 0x03, 0x10, 0x07, 0x29, 0xEC, 0x06, 0x18, 0x04, 0x7F, 0x9F, 0xA4, 0x7F, 0x9F, 0xA4, 0xDC,
/* 1680 */ 0x2F, 0x6C, 0xA4, 0xDC, 0x2F, 0x6C, 0xA4, 0xDC, 0x41, 0x06, 0x0A, 0x0B, 0xA4, 0x7F, 0x9F, 0xA4,
/* 1690 */ 0x7F, 0x9F, 0xA4, 0x10, 0x0C, 0x27, 0xB1, 0x05, 0x08, 0x08, 0x07, 0x00, 0xA7, 0x71, 0x57, 0x81,
/* 16A0 */ 0xC9, 0x50, 0x98, 0x0F, 0x2B, 0x7F, 0x0B, 0xA8, 0x05, 0x84, 0x00, 0x97, 0x0F, 0x7B, 0x0D, 0xA8,
/* 16B0 */ 0x37, 0x60, 0x0A, 0x19, 0x06, 0x84, 0x06, 0x66, 0x1D, 0x32, 0x09, 0x10, 0x0B, 0x3C, 0x74, 0xB3,
/* 16C0 */ 0x08, 0x18, 0x18, 0x01, 0x94, 0x60, 0x46, 0x3A, 0x94, 0x60, 0x46, 0x3A, 0x10, 0x08, 0x62, 0xB1,
/* 16D0 */ 0x72, 0x96, 0x70, 0x08, 0x95, 0x06, 0x72, 0x32, 0x30, 0x02, 0x51, 0x02, 0x08, 0x32, 0x8A, 0xD7,
/* 16E0 */ 0x0C, 0x05, 0x10, 0x0C, 0x90, 0x1C, 0xC5, 0xBD, 0x10, 0x0D, 0xF1, 0x35, 0x01, 0x09, 0x8B, 0x0B,
/* 16F0 */ 0x02, 0x37, 0x28, 0x98, 0x0F, 0x6D, 0x91, 0x65, 0x7A, 0x0C, 0x32, 0x75, 0x65, 0x0B, 0xA4, 0x6C,
/* 1700 */ 0x0E, 0x89, 0x65, 0x8C, 0x1B, 0x6D, 0x02, 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x19, 0x9F, 0x78,
/* 1710 */ 0x94, 0x8C, 0x2A, 0x5C, 0x90, 0x8C, 0x1D, 0x0B, 0x3A, 0x94, 0x28, 0x5C, 0x02, 0x0F, 0x22, 0x65,
/* 1720 */ 0x28, 0x20, 0x32, 0x7C, 0x65, 0x28, 0x9A, 0x0C, 0x37, 0x28, 0x09, 0xB0, 0x81, 0xA2, 0x10, 0x0A,
/* 1730 */ 0x1C, 0x47, 0x0A, 0xFA, 0xA6, 0x7F, 0x6F, 0x0F, 0x66, 0x5D, 0x0F, 0x6A, 0x0D, 0xAF, 0x37, 0x28,
/* 1740 */ 0x78, 0x00, 0x97, 0x01, 0x37, 0x85, 0x30, 0xC8, 0x75, 0x4A, 0x31, 0xEE, 0x67, 0x09, 0x72, 0x6A,
/* 1750 */ 0x1E, 0x60, 0x5C, 0x97, 0x7F, 0x49, 0xB2, 0x0C, 0x80, 0x25, 0xA9, 0x5C, 0x41, 0xAB, 0x0A, 0x9E,
/* 1760 */ 0xA6, 0x10, 0x0D, 0x70, 0x74, 0x0C, 0x0C, 0x0B, 0x08, 0x1E, 0xD1, 0xD1, 0xD1, 0x0D, 0x3E, 0x1D,
/* 1770 */ 0x3F, 0x0D, 0x30, 0x05, 0x0D, 0x0F, 0x30, 0x58, 0x56, 0x3E, 0x1D, 0x49, 0x0E, 0x0B, 0x32, 0x30,
/* 1780 */ 0x65, 0x60, 0x5C, 0xF9, 0x0C, 0x94, 0x85, 0x30, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75, 0x1D,
/* 1790 */ 0x0D, 0x3E, 0x19, 0xD5, 0x46, 0x60, 0x0C, 0x37, 0x9B, 0x8B, 0x0B, 0x03, 0xA5, 0x0C, 0x10, 0x0C,
/* 17A0 */ 0x65, 0x1C, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x08, 0x7F, 0x74, 0x93, 0x0E, 0x81, 0xB4, 0x7F, 0x64,
/* 17B0 */ 0x66, 0xA1, 0x0E, 0x6A, 0x0C, 0x0B, 0x3B, 0x7E, 0x41, 0x31, 0x07, 0x51, 0x32, 0x46, 0x7F, 0x9A,
/* 17C0 */ 0x81, 0x19, 0x58, 0x60, 0x30, 0x0A, 0x07, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C, 0xFE, 0x3C,
/* 17D0 */ 0xFE, 0x10, 0x0C, 0x37, 0xD9, 0xC9, 0x02, 0x1D, 0xA1, 0x02, 0x93, 0x7C, 0x37, 0x02, 0x09, 0x0D,
/* 17E0 */ 0x6D, 0x6A, 0x00, 0x31, 0x0F, 0x6A, 0x0A, 0x07, 0x90, 0x6C, 0x0E, 0x6A, 0x0D, 0x50, 0x5A, 0x65,
/* 17F0 */ 0x49, 0x07, 0x19, 0x60, 0x09, 0x65, 0x6F, 0x04, 0x19, 0x09, 0x22, 0x00, 0x31, 0x07, 0x19, 0xF0,
/* 1800 */ 0x37, 0x0D, 0x6A, 0x0D, 0x50, 0x75, 0x5D, 0x0D, 0x56, 0x45, 0x59, 0x0B, 0x95, 0x8B, 0x0C, 0xA2,
/* 1810 */ 0x37, 0x9F, 0x05, 0x35, 0x0B, 0x23, 0x08, 0x03, 0x25, 0x2D, 0x92, 0x94, 0x3F, 0x0C, 0x9A, 0x7C,
/* 1820 */ 0x5E, 0x0B, 0x94, 0x0D, 0x8B, 0x06, 0x19, 0x6C, 0x4D, 0x90, 0x8C, 0x08, 0x06, 0x07, 0x0C, 0xA4,
/* 1830 */ 0x90, 0x99, 0x69, 0x09, 0x37, 0x83, 0x63, 0x0F, 0x98, 0x5F, 0x10, 0x0D, 0xF1, 0x35, 0x01, 0x09,
/* 1840 */ 0x8B, 0x0B, 0x02, 0x37, 0x8C, 0x33, 0x30, 0x37, 0x7A, 0x63, 0x6B, 0x0B, 0x0F, 0x53, 0x6F, 0xE2,
/* 1850 */ 0x19, 0x67, 0xE2, 0x19, 0x67, 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x06, 0x52, 0xCF, 0x89, 0xE1, 0xE1,
/* 1860 */ 0x10, 0x06, 0x52, 0xCF, 0x89, 0x35, 0x35, 0x35, 0x35, 0x35, 0xE1, 0x1E, 0x0D, 0x22, 0xC8, 0xAF,
/* 1870 */ 0x3C, 0x39, 0x50, 0x71, 0x51, 0x0E, 0x6A, 0x2E, 0x08, 0x53, 0x72, 0xA6, 0x10, 0x0C, 0x00, 0x52,
/* 1880 */ 0x02, 0x03, 0x05, 0xE1, 0x1D, 0x60, 0x0C, 0x65, 0x8C, 0x19, 0x05, 0x6B, 0x8C, 0x6C, 0x0D, 0x92,
/* 1890 */ 0x65, 0x8C, 0x9F, 0x91, 0x37, 0x8C, 0xF9, 0x07, 0x25, 0x8C, 0x0A, 0x22, 0x7F, 0x8C, 0x0B, 0x6D,
/* 18A0 */ 0x02, 0x25, 0x8C, 0x03, 0x6D, 0x21, 0x8C, 0x00, 0x0B, 0x6D, 0x02, 0x37, 0x8C, 0x97, 0x50, 0x75,
/* 18B0 */ 0x37, 0x8C, 0x19, 0x33, 0x02, 0x65, 0x8C, 0x19, 0x49, 0x0A, 0x65, 0x8C, 0x1D, 0x0D, 0x6D, 0x02,
/* 18C0 */ 0x10, 0x07, 0x19, 0xAE, 0x72, 0x02, 0x1E, 0x0B, 0x0E, 0x0F, 0x8A, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1,
/* 18D0 */ 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0x0D, 0x22, 0x1E, 0x0B, 0x6D, 0x5A, 0x51, 0x49,
/* 18E0 */ 0x78, 0x2E, 0x06, 0x0D, 0x81, 0x06, 0x10, 0x12, 0x90, 0x1C, 0x0B, 0xA8, 0x9B, 0x8B, 0x09, 0x6C,
/* 18F0 */ 0x09, 0x8B, 0x09, 0x01, 0x62, 0x28, 0x0C, 0x42, 0x75, 0x0D, 0x6D, 0x75, 0x62, 0x7A, 0xDE, 0x7A,
/* 1900 */ 0x62, 0x0B, 0xA4, 0x77, 0x50, 0x80, 0x09, 0x6D, 0x02, 0x4A, 0xCB, 0x4A, 0xCB, 0x4A, 0xCB, 0x10,
/* 1910 */ 0x0D, 0x90, 0x1C, 0x28, 0x5B, 0xE3, 0x7A, 0x88, 0x6B, 0x28, 0x80, 0x6F, 0xE2, 0x19, 0x67, 0xE2,
/* 1920 */ 0x19, 0x67, 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x0D, 0x65, 0x1C, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10,
/* 1930 */ 0x0D, 0x90, 0x1C, 0x28, 0x8F, 0x0A, 0x8B, 0x0B, 0x03, 0x37, 0x0B, 0x22, 0x42, 0xCC, 0x01, 0x32,
/* 1940 */ 0xDF, 0x94, 0xC2, 0x65, 0x28, 0x20, 0x0E, 0xA4, 0x65, 0xDE, 0x6A, 0x37, 0x28, 0xAC, 0x0C, 0x81,
/* 1950 */ 0xA2, 0x37, 0x8C, 0x35, 0x35, 0x35, 0x1E, 0x09, 0x0B, 0x0A, 0x07, 0x10, 0x0D, 0x90, 0x1C, 0x3F,
/* 1960 */ 0x0D, 0x81, 0x06, 0x07, 0x0F, 0x30, 0x58, 0x46, 0x32, 0x0C, 0x65, 0x49, 0x0E, 0x0B, 0x32, 0x30,
/* 1970 */ 0x65, 0x0C, 0x66, 0x99, 0x32, 0x0C, 0x90, 0x6C, 0x6A, 0x1D, 0x0D, 0x3E, 0x00, 0x99, 0x50, 0x75,
/* 1980 */ 0x1D, 0x0D, 0x3E, 0x19, 0xD5, 0x50, 0x89, 0x32, 0x0C, 0x37, 0x9B, 0x8B, 0x0B, 0x03, 0xD1, 0xD1,
/* 1990 */ 0xD1, 0xD1, 0xD1, 0x07, 0x09, 0x0B, 0x0A, 0x10, 0x09, 0x90, 0x1C, 0x28, 0xA2, 0x09, 0x0E, 0x0C,
/* 19A0 */ 0x7F, 0x28, 0x0A, 0x55, 0x0A, 0x7F, 0x0B, 0x22, 0x7E, 0x65, 0xDE, 0x2B, 0x7F, 0x28, 0x81, 0x03,
/* 19B0 */ 0x01, 0x01, 0x7F, 0x28, 0x71, 0x2E, 0x0B, 0x6D, 0x86, 0x8C, 0x35, 0x35, 0x35, 0x35, 0x35, 0x10,
/* 19C0 */ 0x0B, 0x00, 0x1C, 0xAB, 0x0B, 0x0E, 0x81, 0xA6, 0x7F, 0x2D, 0x2B, 0x76, 0x0E, 0x0B, 0xFA, 0x02,
/* 19D0 */ 0x37, 0x49, 0x05, 0x00, 0x99, 0x05, 0x41, 0xAB, 0x6A, 0x02, 0x2E, 0x60, 0x20, 0x05, 0x3C, 0xAD,
/* 19E0 */ 0x6D, 0x30, 0x02, 0x3C, 0x02, 0x4B, 0x6A, 0x72, 0x0D, 0x3A, 0x37, 0x06, 0x05, 0x1D, 0x0B, 0x3A,
/* 19F0 */ 0x65, 0x06, 0x89, 0x0B, 0x60, 0x30, 0x37, 0x2D, 0x95, 0x03, 0x25, 0x02, 0x09, 0x63, 0x81, 0xA2,
/* 1A00 */ 0x10, 0x08, 0x9D, 0x01, 0x86, 0x05, 0x88, 0x0F, 0x48, 0xEA, 0x64, 0x04, 0x51, 0x56, 0x30, 0x7F,
/* 1A10 */ 0x46, 0x92, 0x00, 0x58, 0x60, 0x30, 0x0A, 0x05, 0x90, 0xEA, 0x07, 0x6B, 0xEA, 0x07, 0x6B, 0xEA,
/* 1A20 */ 0x64, 0x04, 0x5E, 0x05, 0xC8, 0x95, 0x0B, 0x0B, 0x57, 0x0F, 0x71, 0x19, 0xA1, 0x09, 0x0E, 0x81,
/* 1A30 */ 0xB4, 0x10, 0x0C, 0x90, 0x1C, 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0B, 0x2C, 0x1C, 0xF2, 0x19, 0x49,
/* 1A40 */ 0x04, 0x94, 0x28, 0xAA, 0x9F, 0xAA, 0x90, 0x06, 0x66, 0x19, 0x0B, 0x20, 0x65, 0x02, 0xA4, 0x19,
/* 1A50 */ 0x32, 0x07, 0x37, 0x0D, 0x53, 0x02, 0x66, 0x90, 0x2A, 0x0C, 0x00, 0x05, 0x89, 0x25, 0x49, 0x9F,
/* 1A60 */ 0x0A, 0xA1, 0x66, 0x28, 0x06, 0x7F, 0x28, 0x06, 0x32, 0x02, 0x37, 0x3F, 0x20, 0x0F, 0x30, 0xC9,
/* 1A70 */ 0x6D, 0xA8, 0x51, 0x32, 0x1A, 0x57, 0xAA, 0x10, 0x10, 0x2C, 0x1C, 0x60, 0x0C, 0x19, 0x08, 0x66,
/* 1A80 */ 0x99, 0x0F, 0x1A, 0x4A, 0x09, 0x89, 0x34, 0x50, 0x71, 0x00, 0x49, 0x02, 0x4A, 0x6F, 0x19, 0x0D,
/* 1A90 */ 0x0F, 0x6E, 0x06, 0x89, 0x4A, 0x99, 0x0F, 0x7B, 0x50, 0x53, 0x08, 0x20, 0x62, 0x85, 0x78, 0x03,
/* 1AA0 */ 0x20, 0x30, 0x77, 0x53, 0x62, 0x0D, 0x0F, 0x71, 0x05, 0x95, 0x07, 0x95, 0x00, 0x60, 0x06, 0x27,
/* 1AB0 */ 0x1B, 0x0F, 0x7C, 0x08, 0x30, 0x05, 0x50, 0x01, 0x32, 0x03, 0x4A, 0x3F, 0x0F, 0x75, 0x0A, 0x0F,
/* 1AC0 */ 0x96, 0x1A, 0x3A, 0x29, 0x05, 0x20, 0x0D, 0x80, 0xA8, 0x22, 0x2C, 0x02, 0x50, 0x60, 0x05, 0x00,
/* 1AD0 */ 0x0D, 0x30, 0x92, 0x2C, 0x42, 0x5C, 0x0B, 0x0F, 0x4C, 0x7A, 0x01, 0x9F, 0x0F, 0x71, 0x62, 0x2A,
/* 1AE0 */ 0x95, 0x19, 0x6F, 0x0F, 0x02, 0x10, 0x0B, 0xAE, 0x9D, 0x26, 0x1A, 0x6C, 0x4D, 0x94, 0x02, 0x0F,
/* 1AF0 */ 0x53, 0x6F, 0x02, 0x37, 0x09, 0x89, 0x00, 0x28, 0x0A, 0xA1, 0x32, 0x6F, 0x02, 0x25, 0x9F, 0x32,
/* 1B00 */ 0x09, 0x19, 0xA1, 0x32, 0x7B, 0x3C, 0x0B, 0x6D, 0x91, 0x2F, 0x31, 0x53, 0x7F, 0xE8, 0x6D, 0x02,
/* 1B10 */ 0x25, 0x05, 0x50, 0x38, 0x32, 0x0A, 0x25, 0x0D, 0x53, 0x08, 0x66, 0x65, 0x6F, 0x8D, 0x02, 0x6A,
/* 1B20 */ 0x90, 0x6C, 0xF2, 0x19, 0x28, 0x78, 0x10, 0x0B, 0x2C, 0x1C, 0x32, 0xBE, 0x05, 0x10, 0x0A, 0xAE,
/* 1B30 */ 0x9D, 0x31, 0x46, 0x09, 0x19, 0x31, 0x46, 0x09, 0x5D, 0x23, 0x23, 0x0D, 0x7E, 0x25, 0xF9, 0x45,
/* 1B40 */ 0x51, 0x28, 0x78, 0x51, 0x6F, 0x09, 0x51, 0xF9, 0x45, 0x51, 0x28, 0x78, 0x51, 0x6F, 0x09, 0x51,
/* 1B50 */ 0xF9, 0x45, 0x57, 0x0D, 0x23, 0x23, 0x07, 0x37, 0x28, 0x46, 0x75, 0x37, 0xDE, 0x4C, 0x10, 0x07,
/* 1B60 */ 0x90, 0xEC, 0x54, 0x88, 0xEE, 0x60, 0x75, 0x27, 0x31, 0x0D, 0x06, 0x51, 0x6F, 0x86, 0x6F, 0x1E,
/* 1B70 */ 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x51, 0x3F, 0x89, 0x72, 0x28, 0x0C, 0x2E, 0x60, 0xAC, 0x2E, 0x0C,
/* 1B80 */ 0x95, 0xEF, 0x55, 0x7C, 0x1E, 0x09, 0x22, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E, 0x6F, 0x1E,
/* 1B90 */ 0x6F, 0x1E, 0x6F, 0x86, 0x67, 0x0D, 0x06, 0x2E, 0x33, 0xEE, 0x54, 0x88, 0x09, 0x10, 0x08, 0x90,
/* 1BA0 */ 0xEC, 0x0B, 0x20, 0x1E, 0x79, 0x20, 0x1E, 0xF6, 0x1E, 0xF6, 0x1E, 0xF6, 0x10, 0x07, 0x29, 0xEC,
/* 1BB0 */ 0x4B, 0x0C, 0xA2, 0x51, 0x9F, 0x81, 0x2E, 0x06, 0x0D, 0x0F, 0x1A, 0x72, 0x6D, 0xEF, 0x32, 0x07,
/* 1BC0 */ 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0x32, 0x07, 0x1E, 0xE8, 0x86, 0x04,
/* 1BD0 */ 0x32, 0x8A, 0xA3, 0x30, 0x2E, 0x64, 0xEE, 0x0D, 0x53, 0x2E, 0x4C, 0x29, 0x4C, 0x29, 0x4C, 0x29,
/* 1BE0 */ 0x4C, 0x29, 0x50, 0x7C, 0x72, 0xA4, 0x51, 0x06, 0x0D, 0x6B, 0x41, 0x9F, 0x30, 0x2E, 0x4B, 0x0C,
/* 1BF0 */ 0xA2, 0x10, 0x0B, 0x9D, 0x9D, 0xA1, 0x09, 0x8B, 0xB4, 0x99, 0xB4, 0x37, 0x28, 0x6A, 0x0E, 0x30,
/* 1C00 */ 0x65, 0x06, 0x20, 0x0D, 0x50, 0x89, 0x03, 0x65, 0x4E, 0x07, 0x19, 0x06, 0x88, 0x0C, 0x04, 0x10,
/* 1C10 */ 0x00, 0x00, 0x00, 0x03, 0x00, 0x2E, 0x00, 0x77, 0x00, 0xB6, 0x01, 0x06, 0x01, 0x51, 0x01, 0x5F,
/* 1C20 */ 0x01, 0xBD, 0x01, 0xC3, 0x02, 0x43, 0x02, 0x8C, 0x02, 0xE3, 0x02, 0xFF, 0x03, 0x0B, 0x03, 0x75,
/* 1C30 */ 0x03, 0x82, 0x03, 0xAD, 0x03, 0xD4, 0x04, 0x01, 0x04, 0x2E, 0x04, 0x45, 0x04, 0x86, 0x04, 0xD0,
/* 1C40 */ 0x04, 0xD4, 0x04, 0xF1, 0x05, 0x10, 0x05, 0x5D, 0x05, 0xB0, 0x05, 0xF8, 0x06, 0x65, 0x06, 0xD4,
/* 1C50 */ 0x07, 0x12, 0x07, 0x29, 0x07, 0x3C, 0x07, 0x59, 0x07, 0x73, 0x07, 0x90, 0x07, 0xB4, 0x08, 0x0F,
/* 1C60 */ 0x08, 0x6C, 0x08, 0x84, 0x08, 0x9C, 0x08, 0xBB, 0x08, 0xC6, 0x08, 0xDE, 0x08, 0xF8, 0x09, 0x17,
/* 1C70 */ 0x09, 0x2F, 0x09, 0x86, 0x09, 0xAE, 0x09, 0xC5, 0x09, 0xD9, 0x09, 0xF8, 0x0A, 0x14, 0x0A, 0x36,
/* 1C80 */ 0x0A, 0x6D, 0x0A, 0xE8, 0x0B, 0x00, 0x0B, 0x18, 0x0B, 0x37, 0x0B, 0x4D, 0x0B, 0x6B, 0x0B, 0xA3,
/* 1C90 */ 0x0C, 0x08, 0x0C, 0x20, 0x0C, 0x36, 0x0C, 0x52, 0x0C, 0x6F, 0x0C, 0x81, 0x0C, 0xA7, 0x0D, 0x0D,
/* 1CA0 */ 0x0D, 0x58, 0x0D, 0x73, 0x0D, 0x8D, 0x0D, 0xAE, 0x0D, 0xC5, 0x0D, 0xDE, 0x0D, 0xFA, 0x0E, 0x18,
/* 1CB0 */ 0x0E, 0x23, 0x0E, 0x87, 0x0E, 0xB5, 0x0E, 0xD1, 0x0E, 0xEB, 0x0F, 0x0D, 0x0F, 0x2A, 0x0F, 0x4B,
/* 1CC0 */ 0x0F, 0x65, 0x0F, 0xC3, 0x0F, 0xDD, 0x0F, 0xF5, 0x10, 0x14, 0x10, 0x21, 0x10, 0x35, 0x10, 0x61,
/* 1CD0 */ 0x05, 0x00, 0x10, 0x06, 0x4A, 0x4F, 0x1C, 0x4B, 0x68, 0x36, 0x20, 0x1E, 0x08, 0x98, 0x03, 0x1D,
/* 1CE0 */ 0xEC, 0x0B, 0x1A, 0x1E, 0x0C, 0x1A, 0x1E, 0x60, 0x05, 0x1E, 0x0D, 0x50, 0xEF, 0x32, 0xEF, 0x32,
/* 1CF0 */ 0x07, 0x1E, 0x7E, 0x7F, 0x85, 0x75, 0x72, 0x6D, 0xEE, 0x02, 0x4D, 0xA7, 0x0B, 0x10, 0x0A, 0xD9,
/* 1D00 */ 0x6C, 0x0F, 0x80, 0x72, 0x0F, 0x80, 0x72, 0xA8, 0x1E, 0x06, 0x0F, 0x30, 0x05, 0x3C, 0x39, 0x46,
/* 1D10 */ 0x0C, 0x02, 0x59, 0x0D, 0x56, 0x45, 0x37, 0x08, 0x6D, 0xA2, 0x02, 0x8F, 0x25, 0xF2, 0xA7, 0x0A,
/* 1D20 */ 0x4A, 0x31, 0xEE, 0x67, 0xEE, 0x03, 0x4D, 0x51, 0x85, 0x81, 0x19, 0x57, 0xA2, 0x02, 0xB4, 0x00,
/* 1D30 */ 0x5D, 0x56, 0x30, 0x7F, 0x05, 0x42, 0x22, 0x03, 0x7F, 0x02, 0x08, 0x22, 0x73, 0x1D, 0xA1, 0x0F,
/* 1D40 */ 0x80, 0x72, 0x0F, 0x80, 0x72, 0xA8, 0x10, 0x0C, 0x00, 0xD9, 0x06, 0x0C, 0x8B, 0x0C, 0x07, 0x3C,
/* 1D50 */ 0xA9, 0x8E, 0x5D, 0x0F, 0x89, 0x0B, 0x9E, 0x48, 0x9F, 0x5C, 0x02, 0x96, 0x25, 0x09, 0x6D, 0x19,
/* 1D60 */ 0x57, 0x19, 0x57, 0xA7, 0x6D, 0x22, 0x37, 0xF9, 0x89, 0x8B, 0x0C, 0x19, 0x58, 0x6D, 0x27, 0x58,
/* 1D70 */ 0x89, 0x27, 0x58, 0x22, 0x72, 0x32, 0x06, 0x4A, 0xAB, 0x0D, 0x22, 0x18, 0x87, 0x90, 0x2D, 0x0F,
/* 1D80 */ 0x89, 0x65, 0x64, 0x46, 0x30, 0x10, 0x0C, 0xB1, 0x61, 0x01, 0x0B, 0x07, 0x27, 0x05, 0x8E, 0x90,
/* 1D90 */ 0x9F, 0x07, 0x0A, 0x8B, 0xE9, 0x0E, 0xAF, 0x2C, 0x6C, 0x0D, 0x50, 0x56, 0x45, 0x47, 0x50, 0x30,
/* 1DA0 */ 0x60, 0x71, 0x37, 0x06, 0xA8, 0x19, 0x06, 0xA8, 0x19, 0x26, 0x5C, 0x6C, 0x20, 0x37, 0x28, 0x02,
/* 1DB0 */ 0x1D, 0x3E, 0x41, 0x09, 0x1A, 0x19, 0x02, 0x20, 0x1D, 0xAB, 0x20, 0x02, 0xAD, 0x2B, 0x37, 0x49,
/* 1DC0 */ 0x46, 0x07, 0x47, 0x32, 0x46, 0x1A, 0x2C, 0x3F, 0x81, 0x02, 0x06, 0x09, 0x09, 0x06, 0x39, 0x75,
/* 1DD0 */ 0x90, 0x3F, 0x03, 0x27, 0x82, 0x10, 0x0C, 0x9D, 0x72, 0x32, 0x0C, 0xE6, 0xA4, 0x90, 0x08, 0x6D,
/* 1DE0 */ 0x02, 0x1B, 0x22, 0x90, 0x6C, 0x0E, 0x0F, 0x80, 0x6C, 0xA4, 0x65, 0x08, 0x89, 0x19, 0x06, 0x84,
/* 1DF0 */ 0x00, 0x85, 0x71, 0x00, 0x60, 0x07, 0x94, 0x2A, 0x96, 0x50, 0x38, 0x00, 0x76, 0x0A, 0xA8, 0x37,
/* 1E00 */ 0x2A, 0x84, 0x1D, 0x2D, 0x89, 0x37, 0x06, 0x0E, 0x32, 0x89, 0x98, 0x3C, 0x09, 0x3A, 0x7F, 0x06,
/* 1E10 */ 0x8B, 0x32, 0x95, 0x98, 0x37, 0x2D, 0x89, 0x3C, 0x09, 0x6D, 0x86, 0x09, 0x6D, 0x86, 0x09, 0x3A,
/* 1E20 */ 0x10, 0x08, 0x90, 0xEC, 0x79, 0x20, 0x1E, 0xF6, 0x4A, 0x74, 0x79, 0x20, 0x1E, 0xF6, 0x10, 0x0C,
/* 1E30 */ 0xD9, 0x04, 0x0B, 0x0E, 0x81, 0x5F, 0x7F, 0x2D, 0x2B, 0x76, 0x0E, 0x0B, 0x0C, 0x0F, 0x38, 0x37,
/* 1E40 */ 0x05, 0x66, 0x19, 0x02, 0x04, 0x25, 0x49, 0x05, 0x72, 0x0E, 0x6A, 0x05, 0x51, 0x6F, 0x22, 0x05,
/* 1E50 */ 0x00, 0x5D, 0x50, 0x7D, 0x6D, 0x71, 0x37, 0x0B, 0x1A, 0x00, 0x05, 0x0D, 0x20, 0x37, 0x32, 0x05,
/* 1E60 */ 0x00, 0x24, 0x94, 0x0C, 0x89, 0x07, 0xD7, 0x53, 0x00, 0x31, 0x89, 0x0F, 0x45, 0x25, 0x9B, 0x46,
/* 1E70 */ 0x07, 0x51, 0x4E, 0x42, 0x02, 0xC8, 0x71, 0x25, 0x09, 0x06, 0x02, 0x00, 0x06, 0x6B, 0x97, 0x46,
/* 1E80 */ 0x84, 0x19, 0x6F, 0x0F, 0x89, 0x03, 0x7F, 0xD7, 0x09, 0x0A, 0x09, 0x9C, 0x10, 0x0A, 0x52, 0x4B,
/* 1E90 */ 0xB5, 0x5A, 0x10, 0x12, 0x51, 0x74, 0x4E, 0x0A, 0x0C, 0x0B, 0x09, 0x04, 0x7F, 0x2D, 0x30, 0x02,
/* 1EA0 */ 0x65, 0x09, 0xA8, 0x03, 0x01, 0x01, 0xB0, 0x0F, 0x91, 0x90, 0x05, 0x95, 0x03, 0x02, 0x0B, 0x8B,
/* 1EB0 */ 0x09, 0x9B, 0x30, 0x90, 0x0D, 0x2B, 0xF9, 0x50, 0x9C, 0x0D, 0x2B, 0x2F, 0xE6, 0x95, 0xFB, 0x04,
/* 1EC0 */ 0x82, 0x19, 0x06, 0xB2, 0x4A, 0x3F, 0x75, 0x00, 0xFD, 0x2F, 0x02, 0x50, 0x29, 0x09, 0x80, 0x53,
/* 1ED0 */ 0x2F, 0x50, 0x01, 0x62, 0x09, 0x7C, 0x00, 0x53, 0x2F, 0x7B, 0x4A, 0x08, 0x75, 0x00, 0xFD, 0x2F,
/* 1EE0 */ 0x85, 0x29, 0x05, 0x81, 0x77, 0x0F, 0x71, 0x02, 0xA2, 0x00, 0x06, 0x30, 0x2C, 0x0E, 0x78, 0x02,
/* 1EF0 */ 0x42, 0x80, 0x0C, 0x7C, 0x62, 0x3F, 0x81, 0x02, 0x03, 0x0B, 0x95, 0x09, 0x54, 0x0F, 0x45, 0x90,
/* 1F00 */ 0x0B, 0x95, 0x9C, 0x00, 0x99, 0x0A, 0x1A, 0x2C, 0x2A, 0x95, 0x32, 0xAC, 0x25, 0x83, 0x0D, 0x8B,
/* 1F10 */ 0x0C, 0x73, 0x10, 0x0B, 0xB1, 0x52, 0x4E, 0x88, 0x81, 0x09, 0x01, 0x3B, 0x6D, 0x6A, 0x3C, 0x63,
/* 1F20 */ 0x7D, 0x0F, 0x7B, 0xA1, 0x1D, 0x0E, 0x1A, 0x2F, 0xAB, 0x0B, 0x0D, 0x0F, 0x6B, 0x3F, 0x0F, 0x22,
/* 1F30 */ 0x6B, 0x19, 0x32, 0x05, 0x00, 0x0E, 0x1A, 0x25, 0xA4, 0x03, 0xA4, 0x25, 0x9A, 0x20, 0x25, 0x64,
/* 1F40 */ 0x75, 0x0E, 0x7C, 0x7F, 0x05, 0x0A, 0xE9, 0x00, 0x02, 0x8F, 0x4A, 0xAE, 0x0B, 0x0C, 0x0C, 0x0C,
/* 1F50 */ 0x0C, 0x0C, 0x0C, 0x0C, 0x8E, 0x37, 0x56, 0x3A, 0x37, 0x56, 0x3A, 0x10, 0x0E, 0x52, 0x74, 0x59,
/* 1F60 */ 0x01, 0x41, 0x6C, 0x19, 0x58, 0x0D, 0x04, 0x1D, 0x09, 0x0E, 0x05, 0x94, 0x3F, 0x50, 0x38, 0x00,
/* 1F70 */ 0x6F, 0x02, 0x31, 0x08, 0x99, 0x50, 0x75, 0x94, 0xF9, 0x45, 0x01, 0x0D, 0x84, 0x60, 0x71, 0x00,
/* 1F80 */ 0x0B, 0x4C, 0x99, 0x50, 0x30, 0x00, 0x02, 0x0F, 0x22, 0x47, 0x0F, 0x53, 0x02, 0x6A, 0x94, 0x6C,
/* 1F90 */ 0x0E, 0x66, 0x01, 0x0E, 0x6B, 0x05, 0x6A, 0x97, 0x50, 0x30, 0x65, 0x9F, 0x71, 0x00, 0x07, 0xA4,
/* 1FA0 */ 0x37, 0x0B, 0x22, 0x34, 0x84, 0x6C, 0x0D, 0x0F, 0x87, 0x01, 0x0D, 0x0F, 0x87, 0x47, 0x04, 0x41,
/* 1FB0 */ 0x02, 0x05, 0x10, 0x0C, 0x4A, 0x44, 0x23, 0x23, 0x18, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09,
/* 1FC0 */ 0x1E, 0x06, 0x53, 0x2E, 0x06, 0x53, 0x2E, 0x06, 0x53, 0x19, 0xC9, 0x07, 0x07, 0x05, 0x10, 0x09,
/* 1FD0 */ 0x4A, 0x44, 0x23, 0x18, 0x3C, 0x0F, 0x56, 0x3C, 0x0F, 0x56, 0x10, 0x0E, 0x7F, 0x74, 0x4E, 0x0C,
/* 1FE0 */ 0x8B, 0x0B, 0x05, 0x3B, 0x0D, 0x22, 0x32, 0x5A, 0x94, 0x6C, 0x0D, 0x75, 0x01, 0x19, 0x02, 0x0B,
/* 1FF0 */ 0xAF, 0x2C, 0x3F, 0x0F, 0x08, 0x06, 0x22, 0x07, 0x00, 0x0B, 0x78, 0x94, 0x63, 0xD7, 0x71, 0x09,
/* 2000 */ 0x0F, 0x03, 0x04, 0x75, 0x94, 0xB2, 0x00, 0x06, 0x0F, 0x03, 0x07, 0x78, 0x00, 0x30, 0x90, 0x02,
/* 2010 */ 0xAF, 0x6F, 0x09, 0x19, 0x98, 0x2C, 0x6C, 0xB2, 0x00, 0x06, 0x2B, 0x80, 0x00, 0x30, 0x94, 0x63,
/* 2020 */ 0xD7, 0x0F, 0x83, 0x0F, 0x02, 0x04, 0x75, 0x2C, 0x3F, 0x0F, 0x08, 0x03, 0x73, 0x82, 0x04, 0x0B,
/* 2030 */ 0x78, 0x90, 0x6C, 0x0D, 0x0F, 0xA2, 0x19, 0x02, 0x0B, 0xAF, 0x47, 0x0D, 0x22, 0x32, 0x5A, 0x25,
/* 2040 */ 0x4E, 0x0C, 0x8B, 0xE9, 0x10, 0x08, 0x51, 0xAE, 0x9B, 0x18, 0x05, 0x3B, 0x56, 0x08, 0x3B, 0x56,
/* 2050 */ 0x08, 0x10, 0x0B, 0x25, 0x74, 0x4E, 0x0A, 0x8F, 0x51, 0x39, 0x0F, 0xA4, 0x3C, 0x7A, 0x7B, 0x37,
/* 2060 */ 0x85, 0x0A, 0x01, 0x05, 0x6E, 0x5D, 0x1A, 0x19, 0x0E, 0x0F, 0x21, 0x02, 0x6E, 0x01, 0xA8, 0x7F,
/* 2070 */ 0x0D, 0x20, 0x0E, 0x1A, 0x41, 0x31, 0x92, 0x27, 0xAB, 0x0C, 0x98, 0x08, 0x10, 0x0C, 0x4F, 0x61,
/* 2080 */ 0x28, 0xDD, 0x0A, 0x23, 0x32, 0x0C, 0x23, 0x06, 0x37, 0x69, 0x09, 0x37, 0x69, 0x09, 0x3C, 0x28,
/* 2090 */ 0xDD, 0x1D, 0x28, 0x05, 0x29, 0xAE, 0x09, 0x0A, 0x23, 0x18, 0x05, 0x37, 0x0D, 0x56, 0x6E, 0x65,
/* 20A0 */ 0x0D, 0x56, 0x6E, 0x10, 0x09, 0x37, 0x74, 0x9B, 0x0E, 0x81, 0x06, 0x19, 0xA1, 0x9A, 0x05, 0x3C,
/* 20B0 */ 0x05, 0xB4, 0x04, 0x92, 0xC8, 0x09, 0x1E, 0x0B, 0x0F, 0x91, 0x2F, 0x58, 0x95, 0x03, 0x1D, 0xA1,
/* 20C0 */ 0x0B, 0x81, 0x03, 0x2E, 0x28, 0x0C, 0x23, 0x09, 0x3C, 0x0D, 0x46, 0x0C, 0x3C, 0x0D, 0x50, 0x6A,
/* 20D0 */ 0x10, 0x09, 0x52, 0x9B, 0x8B, 0x0C, 0x04, 0x19, 0xA1, 0x32, 0x66, 0x3C, 0x06, 0x5A, 0x04, 0x53,
/* 20E0 */ 0x1E, 0x92, 0x62, 0xAB, 0x0F, 0x71, 0x2E, 0x0C, 0x95, 0xEF, 0x0C, 0x9E, 0x05, 0x00, 0x72, 0xFA,
/* 20F0 */ 0x3C, 0x05, 0x5B, 0x03, 0x9E, 0x19, 0x76, 0x7E, 0x5D, 0x0B, 0x8B, 0x0C, 0x06, 0x10, 0x08, 0xEC,
/* 2100 */ 0x47, 0x0A, 0x1E, 0x54, 0x0F, 0x71, 0x4A, 0xAB, 0x0D, 0x50, 0x30, 0x19, 0xA1, 0x0E, 0x22, 0x73,
/* 2110 */ 0x7F, 0x3F, 0x0B, 0x05, 0x10, 0x0D, 0x90, 0x1C, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F,
/* 2120 */ 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B, 0x8C, 0x3F, 0x6B,
/* 2130 */ 0x8C, 0x3F, 0x6B, 0x28, 0xAA, 0x60, 0x71, 0x65, 0x0B, 0x6D, 0x7D, 0x0F, 0xA4, 0x65, 0xDE, 0x33,
/* 2140 */ 0x08, 0x65, 0x0B, 0x20, 0x0E, 0x5A, 0x0D, 0x53, 0x94, 0x28, 0x06, 0x1D, 0x02, 0x02, 0x25, 0x28,
/* 2150 */ 0x0A, 0x1E, 0x79, 0x98, 0x08, 0x10, 0x11, 0xD9, 0x02, 0x09, 0x0D, 0x9A, 0x22, 0x90, 0xA3, 0x69,
/* 2160 */ 0x81, 0x2C, 0xF9, 0x50, 0x89, 0x0A, 0xF0, 0x2C, 0x2D, 0xB2, 0x24, 0x2F, 0x1B, 0x46, 0x20, 0x24,
/* 2170 */ 0x2F, 0x1B, 0x46, 0x20, 0x24, 0x62, 0xA9, 0xB2, 0x24, 0x4A, 0x99, 0x46, 0x20, 0x24, 0x29, 0xA9,
/* 2180 */ 0x0B, 0x24, 0x2C, 0x06, 0x0D, 0x0F, 0x6A, 0x24, 0x94, 0x54, 0x20, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
/* 2190 */ 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0x24, 0x65, 0x05, 0x0A, 0x08, 0x05, 0x97, 0x0A, 0x08, 0x05, 0x10,
/* 21A0 */ 0x06, 0x44, 0xC1, 0x10, 0x07, 0xAE, 0xB3, 0x07, 0x5F, 0x70, 0x0C, 0x7C, 0x70, 0x32, 0x8E, 0x72,
/* 21B0 */ 0x05, 0xA8, 0x51, 0x02, 0x01, 0x03, 0xA8, 0x51, 0x60, 0x1A, 0x19, 0xA1, 0x09, 0x8B, 0x0C, 0x05,
/* 21C0 */ 0x10, 0x09, 0x74, 0xA1, 0x55, 0x09, 0x4A, 0xAB, 0x0D, 0x50, 0x75, 0x19, 0xA1, 0x9E, 0x53, 0x3C,
/* 21D0 */ 0x05, 0xB4, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x72, 0x53, 0x10,
/* 21E0 */ 0x0B, 0x90, 0x4F, 0x74, 0x02, 0x09, 0x0D, 0x81, 0x09, 0x01, 0x7F, 0x39, 0x46, 0x45, 0x1D, 0x26,
/* 21F0 */ 0x22, 0x6D, 0x21, 0x0F, 0x6E, 0x07, 0x89, 0x5D, 0x66, 0x99, 0x6D, 0x02, 0x47, 0x6D, 0x02, 0x99,
/* 2200 */ 0x6D, 0x02, 0x65, 0x02, 0x66, 0x97, 0x3A, 0x37, 0x32, 0x09, 0x01, 0x09, 0x22, 0x25, 0x09, 0x56,
/* 2210 */ 0x7C, 0xA1, 0x60, 0x6A, 0x51, 0x06, 0x0A, 0x0B, 0x0A, 0x06, 0x62, 0xAE, 0x02, 0x0C, 0x0C, 0x0C,
/* 2220 */ 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x8E, 0x47, 0x69, 0x02, 0x47, 0x69, 0x02, 0x10, 0x0E, 0x4F, 0xD9,
/* 2230 */ 0x72, 0x01, 0x1D, 0x6C, 0x01, 0x41, 0xAB, 0xA0, 0x19, 0x97, 0xA0, 0x59, 0x0E, 0xA8, 0x19, 0x0E,
/* 2240 */ 0xA8, 0x37, 0x64, 0x04, 0x00, 0x6F, 0x05, 0x37, 0x0D, 0x50, 0x91, 0x00, 0x60, 0x91, 0x65, 0x49,
/* 2250 */ 0x8E, 0x67, 0x45, 0x65, 0x28, 0x78, 0x77, 0x6B, 0x55, 0x78, 0x9F, 0x78, 0x94, 0x02, 0x6D, 0x91,
/* 2260 */ 0x02, 0x42, 0x02, 0x26, 0x0F, 0x71, 0x77, 0xA4, 0x31, 0x09, 0x99, 0x50, 0x75, 0x65, 0xE8, 0x19,
/* 2270 */ 0x60, 0x0C, 0x37, 0x09, 0x0F, 0x38, 0x19, 0x09, 0x0F, 0x91, 0x41, 0xAB, 0x03, 0xE6, 0x04, 0x10,
/* 2280 */ 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E, 0x0B, 0xC7, 0x75, 0x41, 0x09, 0x0F, 0x38, 0x94,
/* 2290 */ 0x85, 0x09, 0x1D, 0x85, 0xF8, 0x00, 0x6C, 0x0E, 0x75, 0x3F, 0x09, 0x04, 0x29, 0x85, 0x09, 0x3F,
/* 22A0 */ 0x50, 0x03, 0x6C, 0x0E, 0xAF, 0x62, 0x85, 0x09, 0x19, 0xFD, 0x19, 0x06, 0x1A, 0x62, 0x6C, 0x53,
/* 22B0 */ 0x05, 0x1A, 0x19, 0x0C, 0x30, 0x25, 0x0C, 0x30, 0x00, 0x97, 0x0F, 0x2B, 0x05, 0xD2, 0x81, 0x1D,
/* 22C0 */ 0x9A, 0x30, 0x62, 0x99, 0x0F, 0x2B, 0xF7, 0x10, 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E,
/* 22D0 */ 0x0B, 0xC7, 0x75, 0x41, 0x09, 0x0F, 0x38, 0x94, 0x85, 0x09, 0x1D, 0x85, 0xF8, 0x00, 0x6C, 0x0E,
/* 22E0 */ 0x75, 0x00, 0xB0, 0x95, 0x96, 0x4A, 0x85, 0x09, 0x3F, 0x50, 0x03, 0x07, 0x46, 0x45, 0x27, 0x85,
/* 22F0 */ 0x09, 0x19, 0xFD, 0x6C, 0x09, 0x05, 0x01, 0x28, 0x03, 0x2F, 0x6C, 0x53, 0x05, 0x1A, 0x19, 0x1B,
/* 2300 */ 0x7B, 0x2C, 0x0C, 0x30, 0x41, 0x99, 0x0F, 0x75, 0xAB, 0x0F, 0x71, 0x1D, 0x99, 0x0E, 0xAF, 0x90,
/* 2310 */ 0x0B, 0x81, 0xE6, 0x0E, 0x75, 0x90, 0x99, 0x0F, 0x2B, 0x19, 0x99, 0x89, 0x0A, 0x23, 0x05, 0x27,
/* 2320 */ 0x1B, 0x95, 0x41, 0x05, 0x46, 0x71, 0x62, 0x02, 0x6E, 0x1D, 0x49, 0x0F, 0x1A, 0x62, 0x09, 0x95,
/* 2330 */ 0x86, 0x99, 0x0A, 0x08, 0x10, 0x15, 0x1D, 0x74, 0x86, 0x1D, 0xA3, 0xA2, 0x1E, 0x0B, 0x81, 0x29,
/* 2340 */ 0x9B, 0x0E, 0x81, 0x08, 0x41, 0x99, 0x0F, 0x2B, 0x29, 0x0D, 0x50, 0x7E, 0x77, 0x95, 0x29, 0x6C,
/* 2350 */ 0x04, 0x01, 0x03, 0x53, 0x19, 0x02, 0x6E, 0x90, 0x0C, 0x95, 0x09, 0x01, 0x1D, 0x09, 0x0F, 0x38,
/* 2360 */ 0x94, 0x0C, 0x9E, 0x05, 0x00, 0x6C, 0xA8, 0x59, 0x0D, 0x81, 0x00, 0x9F, 0x02, 0xAB, 0x73, 0x02,
/* 2370 */ 0x9E, 0x6C, 0x0E, 0x75, 0x3F, 0x09, 0x04, 0x27, 0x02, 0x0F, 0x6D, 0x53, 0x07, 0x50, 0x03, 0x6C,
/* 2380 */ 0x0E, 0xAF, 0x19, 0xE6, 0xF0, 0x07, 0x19, 0xFD, 0x19, 0x06, 0x1A, 0x37, 0x05, 0x1A, 0x19, 0x0C,
/* 2390 */ 0x30, 0x25, 0x0C, 0x30, 0x00, 0x97, 0x0F, 0x2B, 0x05, 0xD2, 0x81, 0x1D, 0x9A, 0x30, 0x62, 0x99,
/* 23A0 */ 0x0F, 0x2B, 0xF7, 0x10, 0x0B, 0x62, 0x4F, 0x1C, 0x3F, 0x98, 0x03, 0xC8, 0x30, 0xC8, 0x0F, 0x8A,
/* 23B0 */ 0x08, 0x98, 0x03, 0xEC, 0x1B, 0x0C, 0x0C, 0xEF, 0x32, 0x07, 0x51, 0x9F, 0x78, 0x25, 0x2A, 0x30,
/* 23C0 */ 0x51, 0x0B, 0x6D, 0x8E, 0x3C, 0x05, 0x4D, 0x57, 0x03, 0x19, 0x6C, 0x25, 0x09, 0xA4, 0x00, 0x02,
/* 23D0 */ 0x0B, 0x0D, 0x03, 0x37, 0x6F, 0x0F, 0x42, 0x38, 0x37, 0x7A, 0x89, 0x05, 0x7F, 0x06, 0x88, 0x98,
/* 23E0 */ 0x5B, 0x10, 0x0D, 0x27, 0x05, 0x05, 0x00, 0x70, 0xFD, 0x02, 0x2E, 0x6F, 0x80, 0x3C, 0xD7, 0x0B,
/* 23F0 */ 0x6D, 0xEF, 0x02, 0x08, 0x0C, 0x19, 0xEC, 0xE0, 0x10, 0x0D, 0x29, 0x05, 0x05, 0x1E, 0x02, 0x0B,
/* 2400 */ 0x81, 0x51, 0x54, 0x0F, 0xA4, 0xE4, 0x0B, 0x5B, 0x41, 0xEC, 0xE0, 0x10, 0x0D, 0x27, 0x02, 0x9E,
/* 2410 */ 0x03, 0x51, 0xF9, 0x95, 0x03, 0x7F, 0xF9, 0x0A, 0x89, 0x03, 0x25, 0x05, 0x81, 0x04, 0x99, 0x0C,
/* 2420 */ 0x71, 0x2F, 0xAB, 0x01, 0xE6, 0x00, 0xEC, 0xE0, 0x10, 0x0D, 0x4F, 0x3F, 0x09, 0x04, 0x99, 0x06,
/* 2430 */ 0x3C, 0x0B, 0x6D, 0x88, 0x80, 0x37, 0x05, 0x56, 0x38, 0x00, 0x5D, 0x0A, 0xA2, 0x09, 0x98, 0x8D,
/* 2440 */ 0xEC, 0xE0, 0x10, 0x0D, 0x90, 0xC9, 0x0D, 0x0D, 0x8D, 0x39, 0xAC, 0x25, 0x0B, 0x20, 0x77, 0x22,
/* 2450 */ 0x25, 0x0B, 0x20, 0x77, 0x22, 0x00, 0x5D, 0x0D, 0x0D, 0x8D, 0x02, 0x63, 0x05, 0xEC, 0xE0, 0x10,
/* 2460 */ 0x0D, 0x19, 0xE6, 0x0C, 0x98, 0x05, 0x51, 0x02, 0x22, 0x1A, 0x25, 0x3F, 0xB2, 0x00, 0x09, 0x0F,
/* 2470 */ 0x21, 0x3F, 0xB2, 0x00, 0x09, 0x80, 0x7F, 0x02, 0x50, 0x32, 0x03, 0x4A, 0xAB, 0x0C, 0x98, 0x05,
/* 2480 */ 0x25, 0x4F, 0xE0, 0x10, 0x12, 0x19, 0xD9, 0x60, 0x56, 0x89, 0x2C, 0x99, 0x69, 0x3E, 0x00, 0xA9,
/* 2490 */ 0x18, 0x07, 0x90, 0x32, 0x0A, 0x3A, 0x25, 0x49, 0x67, 0x04, 0x1D, 0x26, 0x30, 0x00, 0x50, 0x7C,
/* 24A0 */ 0x59, 0x0F, 0x6E, 0x0D, 0x22, 0x23, 0x23, 0x08, 0x29, 0x6F, 0x8D, 0x0B, 0x56, 0x30, 0x29, 0xF0,
/* 24B0 */ 0x19, 0xA9, 0x30, 0x62, 0x02, 0x50, 0x75, 0x19, 0x6F, 0x02, 0x94, 0x08, 0x69, 0x71, 0x94, 0x0D,
/* 24C0 */ 0x69, 0x7C, 0xAB, 0x0F, 0x22, 0x23, 0x23, 0x4D, 0x4A, 0x2A, 0x71, 0x41, 0x0C, 0x89, 0x23, 0x23,
/* 24D0 */ 0x08, 0x41, 0x6C, 0x32, 0xAA, 0x1B, 0x56, 0x30, 0x2F, 0x05, 0x6A, 0x2F, 0x2D, 0x30, 0x10, 0x0D,
/* 24E0 */ 0xD9, 0x99, 0x0A, 0xFA, 0xE9, 0x25, 0x9F, 0x46, 0x8E, 0x94, 0x9F, 0x95, 0x0B, 0x60, 0x0A, 0x47,
/* 24F0 */ 0x0F, 0x22, 0x02, 0x00, 0x99, 0x87, 0x29, 0x2A, 0x71, 0x2E, 0x0E, 0x3A, 0xA7, 0x0D, 0xC8, 0xB2,
/* 2500 */ 0x62, 0xAB, 0x6A, 0xC8, 0x30, 0x00, 0xA7, 0x0D, 0x1E, 0x42, 0x02, 0x2E, 0x09, 0x7E, 0x6C, 0x5D,
/* 2510 */ 0x0F, 0x6D, 0x9C, 0xD7, 0x0E, 0x05, 0x37, 0xA9, 0x66, 0x37, 0x2D, 0x0F, 0x87, 0x37, 0x02, 0x08,
/* 2520 */ 0x0D, 0x81, 0x8F, 0x2E, 0x0B, 0x75, 0x01, 0x1E, 0x0D, 0x89, 0x03, 0x29, 0xAB, 0x53, 0x3C, 0x02,
/* 2530 */ 0x02, 0x02, 0x53, 0x3C, 0x28, 0x1A, 0x51, 0x09, 0x63, 0x0C, 0x05, 0x10, 0x0B, 0x27, 0xA2, 0x70,
/* 2540 */ 0x05, 0x95, 0xEF, 0x0D, 0x50, 0x30, 0x8D, 0xC9, 0x4B, 0x22, 0x70, 0x05, 0xE9, 0x19, 0xB1, 0x58,
/* 2550 */ 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x62, 0x54, 0x70, 0x06, 0x0E, 0x2B, 0x00, 0xC9, 0x60, 0x81, 0x51,
/* 2560 */ 0x0D, 0x89, 0x5B, 0x51, 0x93, 0x05, 0xEC, 0x34, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x2F, 0x9F, 0xEE,
/* 2570 */ 0xA5, 0x53, 0x7F, 0x08, 0x22, 0x60, 0x09, 0x7F, 0x0C, 0x75, 0x01, 0x00, 0x08, 0x0F, 0x8E, 0xA1,
/* 2580 */ 0x04, 0x1D, 0x99, 0x01, 0x00, 0xB1, 0x58, 0x56, 0xCE, 0x0A, 0x10, 0x0B, 0x4F, 0x09, 0xD0, 0xED,
/* 2590 */ 0xB1, 0x58, 0x56, 0xCE, 0x0A, 0x10, 0x06, 0x00, 0x3F, 0x03, 0x19, 0xC8, 0xA2, 0x4A, 0x26, 0x22,
/* 25A0 */ 0x05, 0x51, 0x82, 0x0D, 0x3A, 0x29, 0xAB, 0x0A, 0x08, 0xEC, 0x34, 0xF3, 0x02, 0x10, 0x06, 0x41,
/* 25B0 */ 0x6C, 0x5B, 0x1E, 0x05, 0x0D, 0x75, 0x51, 0x02, 0x7A, 0x02, 0x1D, 0x58, 0x89, 0x09, 0x8D, 0xC9,
/* 25C0 */ 0x0C, 0x9C, 0x4A, 0xB1, 0x58, 0xF3, 0x02, 0x10, 0x06, 0x1D, 0x06, 0x50, 0x5A, 0x51, 0x6F, 0x0F,
/* 25D0 */ 0x5A, 0x7F, 0x06, 0x89, 0x28, 0x5A, 0x25, 0x09, 0x0F, 0x87, 0x06, 0x0E, 0x91, 0x7F, 0x05, 0x41,
/* 25E0 */ 0x02, 0x03, 0xEC, 0x77, 0xF3, 0x02, 0x10, 0x06, 0x19, 0x70, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E,
/* 25F0 */ 0x0C, 0x02, 0x59, 0x0F, 0x6E, 0x0E, 0xA8, 0x37, 0x85, 0x7C, 0xEB, 0x77, 0xF3, 0x02, 0x10, 0x0F,
/* 2600 */ 0x29, 0x9D, 0x31, 0x22, 0x0C, 0x08, 0x03, 0x19, 0x31, 0x46, 0x80, 0x31, 0x0D, 0x0A, 0x33, 0x80,
/* 2610 */ 0xAB, 0x50, 0x80, 0x97, 0x42, 0x02, 0xAB, 0x7E, 0xA5, 0x7C, 0xAB, 0x7E, 0x04, 0x6A, 0x62, 0x3F,
/* 2620 */ 0x60, 0x81, 0x23, 0x01, 0x02, 0x0F, 0x22, 0x4A, 0x1B, 0x0F, 0x6D, 0x3A, 0x85, 0x95, 0x4A, 0x1B,
/* 2630 */ 0x0F, 0x6D, 0x3A, 0x85, 0x81, 0xAB, 0x7E, 0x02, 0x50, 0x30, 0xAB, 0x7E, 0x67, 0x0A, 0xAB, 0x7E,
/* 2640 */ 0x09, 0x4C, 0x67, 0x08, 0x19, 0x67, 0xAA, 0x2C, 0x67, 0x0D, 0x0A, 0x60, 0x6E, 0xAB, 0x0F, 0x56,
/* 2650 */ 0x6E, 0x31, 0x89, 0x0C, 0x5B, 0x10, 0x0E, 0x19, 0x4F, 0x02, 0x09, 0xB4, 0x00, 0x05, 0x04, 0x00,
/* 2660 */ 0xA1, 0x42, 0x28, 0x03, 0x25, 0x09, 0x6D, 0x6A, 0x7F, 0xB0, 0x04, 0x03, 0x0B, 0x0E, 0x5A, 0x7F,
/* 2670 */ 0x4F, 0x57, 0xCD, 0x50, 0x01, 0x62, 0x1B, 0xE5, 0xA6, 0x22, 0x03, 0x3A, 0xB7, 0x10, 0x0F, 0x1D,
/* 2680 */ 0xE6, 0x05, 0x00, 0x70, 0xFD, 0x02, 0x5E, 0x0F, 0xA2, 0x51, 0x93, 0x6D, 0xEF, 0x02, 0x08, 0x0C,
/* 2690 */ 0x00, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x2C, 0x05, 0x05, 0x1E, 0x02, 0x0B, 0x81, 0x2E, 0x08, 0x0F,
/* 26A0 */ 0xA4, 0xE4, 0x0B, 0x5B, 0x1D, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x4A, 0x02, 0xFA, 0x03, 0x51, 0x39,
/* 26B0 */ 0x0F, 0x89, 0x03, 0x7F, 0x39, 0x50, 0x0A, 0x89, 0x03, 0x41, 0xAB, 0x81, 0x04, 0x99, 0x0C, 0x2B,
/* 26C0 */ 0x2F, 0xAB, 0x01, 0xE6, 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x00, 0x4F, 0x3F, 0x09, 0x05, 0x99, 0x06,
/* 26D0 */ 0x1D, 0x58, 0x6D, 0x88, 0x80, 0x1D, 0xAB, 0x56, 0x91, 0x00, 0x5D, 0x0A, 0x08, 0x54, 0x98, 0x04,
/* 26E0 */ 0xEC, 0xC6, 0xB6, 0x10, 0x0F, 0x94, 0xC9, 0x0D, 0x0D, 0x04, 0x00, 0x02, 0x88, 0x05, 0x25, 0x28,
/* 26F0 */ 0x0C, 0xFB, 0x0E, 0x25, 0x28, 0x0C, 0xFB, 0x0E, 0x00, 0x5D, 0x0D, 0x0D, 0x04, 0x00, 0x02, 0x88,
/* 2700 */ 0x05, 0x7F, 0xB1, 0xC6, 0xB6, 0x10, 0x0B, 0xAE, 0x9D, 0xA1, 0x1D, 0x6C, 0x1D, 0x58, 0x0B, 0x00,
/* 2710 */ 0x3F, 0x0D, 0x02, 0x1D, 0x26, 0x80, 0x05, 0x84, 0x19, 0x67, 0x4B, 0xA8, 0x7F, 0x06, 0x46, 0x21,
/* 2720 */ 0x2A, 0x81, 0x51, 0x02, 0x42, 0x2B, 0x00, 0xA1, 0x0D, 0x50, 0x60, 0x78, 0x25, 0x28, 0x8E, 0xA5,
/* 2730 */ 0x38, 0x37, 0x39, 0x45, 0x34, 0x71, 0x00, 0xA1, 0x02, 0x19, 0x6C, 0x03, 0x10, 0x0F, 0x62, 0x52,
/* 2740 */ 0x08, 0x07, 0x8D, 0x72, 0x89, 0x1E, 0x05, 0x92, 0x25, 0x06, 0x0B, 0x42, 0x2B, 0x59, 0x0C, 0x56,
/* 2750 */ 0x30, 0x02, 0x65, 0x60, 0x81, 0x28, 0x22, 0x94, 0x06, 0x4D, 0x85, 0x4C, 0x60, 0xAA, 0x06, 0x75,
/* 2760 */ 0xF2, 0x29, 0x85, 0x30, 0x34, 0x78, 0x0A, 0x6D, 0x02, 0x62, 0x99, 0x4D, 0x00, 0x8B, 0x9F, 0x78,
/* 2770 */ 0x29, 0x67, 0x09, 0x99, 0xAF, 0xA5, 0x71, 0x2F, 0xE6, 0x0F, 0x53, 0x08, 0x2B, 0x9F, 0x2B, 0x29,
/* 2780 */ 0x02, 0x4D, 0x0C, 0xAA, 0x55, 0x71, 0x62, 0x6C, 0x6D, 0x8E, 0x30, 0x19, 0x0B, 0x6D, 0x02, 0x2C,
/* 2790 */ 0x0B, 0xA4, 0x80, 0x00, 0x0E, 0x89, 0x90, 0x6F, 0x0E, 0x5C, 0xA5, 0x80, 0x90, 0x28, 0x20, 0x0D,
/* 27A0 */ 0x6D, 0x45, 0x90, 0x6C, 0xDE, 0x22, 0x02, 0x19, 0x31, 0x95, 0x0B, 0x07, 0x25, 0x9F, 0x07, 0x1E,
/* 27B0 */ 0x0D, 0x50, 0x03, 0x1D, 0xC9, 0x07, 0x0A, 0x10, 0x0E, 0x4A, 0x5B, 0x70, 0x05, 0x95, 0x07, 0x1E,
/* 27C0 */ 0x0D, 0x6D, 0x68, 0x51, 0x02, 0x4B, 0x22, 0x70, 0x05, 0xE9, 0x25, 0xB1, 0x0E, 0x89, 0xD4, 0x10,
/* 27D0 */ 0x0E, 0x29, 0x54, 0x70, 0x06, 0x0E, 0x2B, 0x00, 0xC9, 0x60, 0x95, 0x51, 0x0C, 0x89, 0x5B, 0x51,
/* 27E0 */ 0x93, 0x05, 0x00, 0xEC, 0x0E, 0x89, 0xD4, 0x10, 0x0E, 0x27, 0x9F, 0x0A, 0x51, 0x9F, 0x53, 0x7F,
/* 27F0 */ 0x08, 0x22, 0x60, 0x09, 0x7F, 0x0B, 0x75, 0x01, 0x00, 0x07, 0x0F, 0x8E, 0xA1, 0x04, 0x1D, 0x99,
/* 2800 */ 0x01, 0x37, 0xB1, 0x0E, 0x89, 0xD4, 0x10, 0x0E, 0x00, 0x4F, 0xED, 0x5D, 0x0F, 0x1A, 0x02, 0xA4,
/* 2810 */ 0x5D, 0x0F, 0x1A, 0x02, 0xA4, 0x25, 0xED, 0x65, 0xB1, 0x0E, 0x89, 0xD4, 0x10, 0x0D, 0x29, 0x06,
/* 2820 */ 0x05, 0x1D, 0xC9, 0x0B, 0x81, 0x51, 0x54, 0x0F, 0xA4, 0x3C, 0x06, 0x6A, 0x05, 0x2E, 0x0C, 0x5B,
/* 2830 */ 0x3C, 0x4F, 0x72, 0x42, 0xC3, 0x6D, 0xD8, 0x2E, 0x06, 0xA4, 0x10, 0x0D, 0xE7, 0x40, 0x6D, 0x89,
/* 2840 */ 0x0B, 0x73, 0x58, 0x56, 0x89, 0x8D, 0x26, 0x20, 0x0B, 0x42, 0x38, 0x26, 0x7B, 0x01, 0x0C, 0xA4,
/* 2850 */ 0x00, 0x1F, 0x49, 0x09, 0x26, 0x7B, 0x97, 0x4D, 0x1F, 0x6F, 0x09, 0x26, 0x7B, 0x01, 0x0C, 0xA4,
/* 2860 */ 0x26, 0x20, 0x0B, 0x42, 0x45, 0x26, 0x46, 0x89, 0x8D, 0x26, 0x50, 0x89, 0x0C, 0x73, 0x58, 0x40,
/* 2870 */ 0x6D, 0x02, 0x10, 0x0D, 0x19, 0x52, 0xD7, 0x09, 0x0A, 0x09, 0x05, 0xC9, 0x0D, 0x6D, 0x22, 0x02,
/* 2880 */ 0x59, 0x0D, 0x46, 0x20, 0x37, 0x6F, 0x73, 0x0A, 0x3A, 0x2C, 0x1B, 0x6D, 0x19, 0x6F, 0x37, 0x8C,
/* 2890 */ 0x00, 0xFB, 0x09, 0x37, 0x8C, 0x99, 0x50, 0x45, 0x37, 0x8C, 0x00, 0x28, 0x05, 0x25, 0x28, 0x38,
/* 28A0 */ 0x66, 0x25, 0x8C, 0x00, 0x6D, 0x8E, 0x37, 0x8C, 0x77, 0x6D, 0x8E, 0x65, 0x8C, 0x6C, 0x33, 0x45,
/* 28B0 */ 0x94, 0x8C, 0x00, 0x6C, 0x0D, 0x4C, 0x00, 0x8C, 0x19, 0x99, 0x50, 0x30, 0x94, 0x8C, 0x41, 0x0D,
/* 28C0 */ 0x22, 0x94, 0x8C, 0x19, 0x6C, 0x32, 0x0C, 0x94, 0x8C, 0x99, 0x7D, 0x7E, 0x29, 0x8C, 0xFB, 0x50,
/* 28D0 */ 0x45, 0x94, 0x8C, 0x00, 0x88, 0x81, 0xA2, 0x10, 0x0C, 0x65, 0xEC, 0xA6, 0x70, 0x05, 0x0F, 0x75,
/* 28E0 */ 0x86, 0x60, 0x81, 0x04, 0x51, 0x4E, 0x0D, 0x84, 0x62, 0x93, 0x08, 0x7F, 0xB1, 0xC5, 0xBD, 0x10,
/* 28F0 */ 0x0C, 0xAE, 0x05, 0x08, 0x1E, 0xAD, 0x5C, 0x3C, 0xA3, 0x4D, 0x19, 0x76, 0x0C, 0x06, 0x2F, 0x58,
/* 2900 */ 0x5F, 0x19, 0xEC, 0xC5, 0xBD, 0x10, 0x0C, 0x52, 0x1B, 0x6E, 0x51, 0x09, 0x0F, 0xA4, 0x37, 0x2A,
/* 2910 */ 0x7D, 0x0F, 0x71, 0xA1, 0x0E, 0x75, 0x6C, 0x0B, 0x30, 0x3B, 0x05, 0x41, 0x9C, 0x90, 0x4F, 0xC5,
/* 2920 */ 0xBD, 0x10, 0x0C, 0x19, 0x52, 0x05, 0x09, 0x73, 0x00, 0x07, 0x02, 0x7F, 0x49, 0x0E, 0x0C, 0x81,
/* 2930 */ 0x7F, 0x42, 0xA4, 0x25, 0x54, 0x0C, 0x02, 0x05, 0x63, 0x08, 0x7F, 0xB1, 0xC5, 0xBD, 0x10, 0x0C,
/* 2940 */ 0x52, 0xFC, 0x06, 0x3A, 0x05, 0x66, 0x37, 0x06, 0x3A, 0x05, 0x66, 0x37, 0xFC, 0xB1, 0xC5, 0xBD,
/* 2950 */ 0x10, 0x0C, 0x94, 0xEC, 0x9B, 0x8B, 0x09, 0x01, 0x51, 0x0C, 0x0F, 0x8B, 0x75, 0x3C, 0x02, 0x50,
/* 2960 */ 0x01, 0x04, 0x95, 0x3C, 0x02, 0x50, 0x01, 0x04, 0x95, 0x51, 0x0C, 0x0F, 0x8B, 0x75, 0x51, 0x9B,
/* 2970 */ 0x8B, 0xA2, 0x94, 0x4F, 0xC5, 0xBD, 0x10, 0x13, 0x90, 0x1C, 0xD7, 0x0A, 0x0D, 0x8B, 0x0B, 0x04,
/* 2980 */ 0x00, 0xB0, 0x8B, 0x0B, 0x05, 0x29, 0x05, 0x0F, 0x56, 0x0A, 0x46, 0x7C, 0x29, 0x8B, 0x0C, 0x0B,
/* 2990 */ 0x32, 0x6A, 0x0D, 0x66, 0x62, 0x02, 0x19, 0x6C, 0x32, 0x78, 0x19, 0x0D, 0x53, 0x2C, 0x6C, 0x0D,
/* 29A0 */ 0x89, 0x2A, 0x0D, 0x41, 0xE6, 0x0B, 0x32, 0x50, 0x69, 0x27, 0x9F, 0x46, 0x69, 0x27, 0x02, 0x50,
/* 29B0 */ 0x30, 0x8D, 0x0B, 0x6D, 0x23, 0x18, 0x27, 0x06, 0xA4, 0x19, 0x08, 0x3A, 0x94, 0x64, 0x07, 0x6C,
/* 29C0 */ 0x0C, 0x7E, 0x05, 0x03, 0x4A, 0x67, 0xB2, 0x9A, 0xA0, 0xFA, 0x02, 0x4A, 0x7A, 0x81, 0x03, 0x0D,
/* 29D0 */ 0x56, 0xAC, 0x4A, 0x54, 0x0D, 0x81, 0xA2, 0x00, 0x4E, 0x88, 0x98, 0xA2, 0x10, 0x0A, 0x1C, 0x47,
/* 29E0 */ 0x0A, 0xFA, 0xA6, 0x7F, 0x6F, 0x0F, 0x66, 0x5D, 0x0F, 0x6A, 0x0D, 0xAF, 0x37, 0x28, 0x5C, 0x97,
/* 29F0 */ 0x01, 0x59, 0x6A, 0xC8, 0x75, 0x4A, 0x31, 0xEE, 0x67, 0x09, 0x72, 0x6D, 0x8A, 0x33, 0x73, 0x02,
/* 2A00 */ 0xA2, 0x1D, 0x31, 0x0F, 0x6A, 0x7F, 0x6F, 0x0F, 0x89, 0x03, 0x7F, 0x02, 0xA5, 0x0C, 0x08, 0x86,
/* 2A10 */ 0x0F, 0x71, 0x19, 0xA7, 0x8A, 0x54, 0x0F, 0x71, 0x00, 0xC9, 0xD7, 0x0F, 0x71, 0x19, 0xA1, 0x42,
/* 2A20 */ 0x38, 0x3C, 0x02, 0x0B, 0x8B, 0x0B, 0x03, 0x10, 0x0C, 0x65, 0xEC, 0x06, 0x07, 0x19, 0x72, 0x0E,
/* 2A30 */ 0x30, 0x02, 0x2E, 0x64, 0x7C, 0x2E, 0x05, 0x28, 0x71, 0x1E, 0x83, 0x0C, 0x00, 0xEC, 0x93, 0xB9,
/* 2A40 */ 0x89, 0xB8, 0x10, 0x0C, 0xAE, 0x9B, 0x01, 0x51, 0x3F, 0x0E, 0x80, 0x3C, 0x02, 0x33, 0x38, 0x3C,
/* 2A50 */ 0x0C, 0x89, 0x5B, 0x51, 0xB0, 0x9C, 0x1D, 0xEC, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x0C, 0x1D, 0x52,
/* 2A60 */ 0x05, 0x50, 0x8E, 0x51, 0x49, 0xB2, 0x27, 0xAB, 0x89, 0x28, 0x0A, 0x19, 0x58, 0x30, 0x02, 0x00,
/* 2A70 */ 0x07, 0x50, 0x03, 0x25, 0x4E, 0x1D, 0x99, 0x48, 0x4F, 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x0C, 0x51,
/* 2A80 */ 0xAE, 0x3F, 0x0E, 0x5A, 0x00, 0x06, 0x0E, 0x8E, 0x59, 0x0F, 0x6E, 0x0F, 0xA8, 0x59, 0xA4, 0xEB,
/* 2A90 */ 0x93, 0xB9, 0x89, 0xB8, 0x10, 0x06, 0x2C, 0xEC, 0x08, 0x05, 0x70, 0x02, 0x50, 0x87, 0x25, 0x2A,
/* 2AA0 */ 0x95, 0x06, 0x2E, 0xB0, 0x66, 0x1D, 0xC9, 0x23, 0x2E, 0x4F, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x94,
/* 2AB0 */ 0xB1, 0xC9, 0x0A, 0x1E, 0x9F, 0x05, 0x00, 0xC9, 0x0D, 0x50, 0x30, 0x19, 0xA1, 0x0E, 0x22, 0x73,
/* 2AC0 */ 0x7F, 0x3F, 0x0C, 0x05, 0x19, 0xB1, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x52, 0xA5, 0x0A, 0x2E, 0x64,
/* 2AD0 */ 0x75, 0x3C, 0x06, 0x22, 0x0C, 0xA8, 0x7F, 0x0C, 0x0F, 0x5A, 0x00, 0x09, 0x0F, 0x38, 0x25, 0x82,
/* 2AE0 */ 0x41, 0x05, 0x8D, 0x70, 0x35, 0xE1, 0xE1, 0x10, 0x06, 0x3C, 0xAE, 0x09, 0xD0, 0xED, 0xEC, 0x8C,
/* 2AF0 */ 0xE1, 0xE1, 0x10, 0x0D, 0xAE, 0x6C, 0x51, 0x02, 0x01, 0x19, 0x06, 0x0E, 0x03, 0x3C, 0x0C, 0x30,
/* 2B00 */ 0x08, 0x22, 0x00, 0xA1, 0x6D, 0x66, 0x27, 0xAB, 0x7A, 0x0A, 0x3C, 0xF9, 0x4D, 0x25, 0x02, 0x09,
/* 2B10 */ 0xAC, 0x08, 0xA4, 0x19, 0xA1, 0x19, 0xF0, 0x2F, 0xAB, 0x09, 0x0A, 0x07, 0x06, 0x6B, 0x9F, 0x22,
/* 2B20 */ 0x7E, 0x2C, 0x05, 0x56, 0x6A, 0x65, 0x60, 0xAC, 0xD7, 0x50, 0x30, 0x94, 0x02, 0x50, 0x75, 0x1D,
/* 2B30 */ 0x0C, 0x89, 0x31, 0x07, 0x1D, 0x0C, 0x89, 0x31, 0x07, 0x1D, 0x0D, 0x3E, 0x19, 0x02, 0x7E, 0x32,
/* 2B40 */ 0x09, 0x65, 0x0D, 0x50, 0x45, 0x00, 0x05, 0x6B, 0x6F, 0x0D, 0x28, 0x30, 0x94, 0x2A, 0x50, 0x22,
/* 2B50 */ 0x02, 0x7F, 0x93, 0x0E, 0x98, 0xA2, 0x10, 0x0D, 0x19, 0x52, 0x54, 0x8F, 0x97, 0x05, 0x00, 0xA1,
/* 2B60 */ 0x0D, 0x6D, 0x60, 0x05, 0x25, 0x2D, 0x0D, 0x2F, 0xAB, 0x0C, 0x06, 0x9B, 0x0E, 0x0C, 0x02, 0x25,
/* 2B70 */ 0xB1, 0x28, 0x5B, 0xE3, 0x7A, 0x88, 0x6B, 0x28, 0x80, 0x6F, 0xE2, 0x19, 0x67, 0xE2, 0x19, 0x67,
/* 2B80 */ 0xE2, 0x00, 0x97, 0xA4, 0x10, 0x0D, 0x19, 0xEC, 0xAB, 0xA2, 0x70, 0x0C, 0x81, 0x04, 0x4A, 0x31,
/* 2B90 */ 0x75, 0x01, 0x00, 0xC9, 0x0A, 0x7E, 0x3C, 0x02, 0x08, 0x45, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6,
/* 2BA0 */ 0x10, 0x0D, 0xEC, 0xA1, 0x96, 0x1E, 0xA3, 0xAF, 0x3C, 0xAD, 0x6D, 0x02, 0x1D, 0x58, 0x89, 0x8F,
/* 2BB0 */ 0x51, 0x39, 0x73, 0x1D, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x90, 0xAE, 0xAB, 0x0E,
/* 2BC0 */ 0x81, 0x02, 0x00, 0xC9, 0x42, 0x8E, 0x7F, 0xF9, 0x0A, 0x50, 0x8E, 0x25, 0x08, 0x81, 0x8D, 0xA3,
/* 2BD0 */ 0x71, 0x7F, 0x73, 0x1D, 0x02, 0xEF, 0x70, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x19, 0x52,
/* 2BE0 */ 0x54, 0x8F, 0x97, 0x05, 0x00, 0xA1, 0x33, 0x88, 0x2B, 0x25, 0x2D, 0x45, 0x41, 0xAB, 0xE9, 0x9B,
/* 2BF0 */ 0x0E, 0x0C, 0x02, 0xEC, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0D, 0x00, 0x52, 0xA3, 0x0C, 0x02,
/* 2C00 */ 0x97, 0x98, 0x03, 0x25, 0x0E, 0x53, 0xE8, 0x25, 0x0E, 0x53, 0x60, 0x0A, 0x25, 0xA3, 0x0C, 0x02,
/* 2C10 */ 0x97, 0x98, 0x03, 0x7F, 0xB1, 0xC0, 0x60, 0x91, 0xBF, 0xA6, 0x10, 0x0B, 0x00, 0xD9, 0xF5, 0x0A,
/* 2C20 */ 0x27, 0x58, 0x0E, 0x0C, 0x02, 0x29, 0xAE, 0x23, 0x18, 0xFF, 0x46, 0x1A, 0xEC, 0xF5, 0x0A, 0x27,
/* 2C30 */ 0x58, 0x0E, 0x0C, 0x02, 0x10, 0x0D, 0x41, 0xD9, 0x02, 0x09, 0x05, 0x01, 0x51, 0x3F, 0x50, 0xEF,
/* 2C40 */ 0x60, 0x01, 0x2F, 0xAB, 0x0B, 0x32, 0x30, 0x7F, 0xA9, 0x0E, 0x05, 0x37, 0x49, 0x0E, 0x33, 0x91,
/* 2C50 */ 0x65, 0x60, 0x0C, 0x54, 0x81, 0x53, 0x90, 0x85, 0x71, 0x00, 0x0D, 0x0D, 0x07, 0x89, 0x31, 0x02,
/* 2C60 */ 0x02, 0x75, 0x05, 0x3A, 0x90, 0x67, 0x82, 0x78, 0x67, 0x02, 0x2C, 0x99, 0x6D, 0x02, 0x0B, 0x0E,
/* 2C70 */ 0x00, 0x05, 0x3A, 0x90, 0x85, 0x71, 0xAF, 0x07, 0x89, 0x65, 0xF0, 0x2B, 0x39, 0x92, 0x31, 0x0F,
/* 2C80 */ 0x88, 0x66, 0x37, 0x2D, 0x2B, 0x7F, 0x32, 0x95, 0xA6, 0x3B, 0x92, 0x51, 0x9F, 0x05, 0x1E, 0x02,
/* 2C90 */ 0x06, 0x87, 0x10, 0x0C, 0x90, 0xEC, 0x3F, 0xEF, 0x6C, 0x0E, 0xB2, 0x02, 0x51, 0x9F, 0x95, 0x07,
/* 2CA0 */ 0x2E, 0x93, 0x6B, 0x4A, 0x83, 0x0B, 0x7F, 0xB1, 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0xAE, 0x9B,
/* 2CB0 */ 0x2E, 0x3F, 0x6E, 0xC9, 0x60, 0x95, 0x51, 0x0D, 0x89, 0xA2, 0x51, 0x06, 0x0C, 0x06, 0x19, 0xEC,
/* 2CC0 */ 0x0D, 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0x1D, 0x52, 0x06, 0x20, 0x5E, 0xAF, 0x2F, 0xAB, 0x89, 0x28,
/* 2CD0 */ 0x0A, 0x7F, 0x0B, 0x30, 0x02, 0x00, 0x07, 0x0F, 0x91, 0x25, 0x4E, 0xE6, 0x04, 0x90, 0x4F, 0x0D,
/* 2CE0 */ 0xCA, 0xBC, 0xC4, 0x10, 0x0C, 0x00, 0x52, 0x4B, 0xB5, 0x5A, 0x37, 0xB1, 0x0D, 0xCA, 0xBC, 0xC4,
/* 2CF0 */ 0x10, 0x0B, 0xAE, 0x07, 0xEF, 0x02, 0x0C, 0x0F, 0x38, 0x51, 0x64, 0x7C, 0xE4, 0x0C, 0x09, 0x8D,
/* 2D00 */ 0xEC, 0x32, 0xBE, 0x05, 0x10, 0x0D, 0xF1, 0x35, 0x9B, 0x8B, 0x0B, 0x03, 0x37, 0x28, 0x81, 0x6D,
/* 2D10 */ 0xCC, 0x01, 0x32, 0xDF, 0x94, 0xC2, 0x65, 0x28, 0x20, 0x0E, 0xA4, 0x65, 0x28, 0x95, 0x0F, 0x6A,
/* 2D20 */ 0x37, 0x8C, 0x03, 0x0C, 0x81, 0xA2, 0x37, 0x8C, 0x35, 0x35, 0x35, 0x1E, 0x09, 0x0B, 0x09, 0x07,
/* 2D30 */ 0x10, 0x0B, 0x52, 0x02, 0x88, 0x05, 0x6C, 0x88, 0x06, 0x25, 0x09, 0x89, 0x9F, 0xAA, 0x65, 0x09,
/* 2D40 */ 0x89, 0x9F, 0x0F, 0x25, 0x02, 0x88, 0x05, 0x6C, 0x88, 0x06, 0x37, 0xB1, 0x32, 0xBE, 0x05, 0x10,
/* 2D50 */ 0x00, 0x00, 0x00, 0x0E, 0x00, 0x1F, 0x00, 0x0E, 0x0C, 0x41, 0x44, 0x3F, 0x18, 0x18, 0x08, 0x26,
/* 2D60 */ 0x69, 0x0C, 0x26, 0x69, 0x0C, 0x10, 0x0B, 0x27, 0x44, 0x05, 0x23, 0x23, 0x18, 0x09, 0x94, 0x9F,
/* 2D70 */ 0x46, 0x22, 0x94, 0x9F, 0x46, 0x22, 0x10, 0x11, 0x27, 0x44, 0x05, 0x18, 0x18, 0x18, 0x09, 0x4A,
/* 2D80 */ 0xA9, 0x69, 0x0D, 0x4A, 0xA9, 0x69, 0x0D, 0x10,
/* char range ofs tables */
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01,
/* 2D90 */ 0x00, 0x00, 0x08, 0x75, 0x00, 0x00, 0x08, 0x77, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x5F,
/* 2DA0 */ 0x00, 0x00, 0x08, 0x7A, 0x00, 0x00, 0x09, 0x38, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x60,
/* 2DB0 */ 0x00, 0x00, 0x1C, 0x10, 0x00, 0x00, 0x1C, 0xD0, 0x00, 0x00, 0x20, 0x12, 0x00, 0x00, 0x00, 0x04,
/* 2DC0 */ 0x00, 0x00, 0x2D, 0x50, 0x00, 0x00, 0x2D, 0x58,

1049
contrib/mcufont/fonts/FiraSansCondensed-Bold32.mcufont.h Normal file
View file

File diff suppressed because it is too large Load diff

BIN
contrib/mcufont/fonts/FiraSansCondensed-Regular.ttf Normal file
View file

Binary file not shown.

318
contrib/mcufont/fonts/FiraSansCondensed-Regular10.mcufont.h Normal file
View file

@ -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,

364
contrib/mcufont/fonts/FiraSansCondensed-Regular12.mcufont.h Normal file
View file

@ -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,

417
contrib/mcufont/fonts/FiraSansCondensed-Regular14.mcufont.h Normal file
View file

@ -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,

474
contrib/mcufont/fonts/FiraSansCondensed-Regular16.mcufont.h Normal file
View file

@ -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,

613
contrib/mcufont/fonts/FiraSansCondensed-Regular20.mcufont.h Normal file
View file

@ -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,

714
contrib/mcufont/fonts/FiraSansCondensed-Regular24.mcufont.h Normal file
View file

@ -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,

949
contrib/mcufont/fonts/FiraSansCondensed-Regular32.mcufont.h Normal file
View file

@ -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,

93
contrib/mcufont/fonts/OFL.txt Normal file
View file

@ -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.

14
contrib/mcufont/fonts/import.sh Executable file
View file

@ -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

1
include/libwebsockets.h
View file

@ -783,6 +783,7 @@ lws_fx_string(const lws_fx_t *a, char *buf, size_t size);
#include <libwebsockets/lws-upng.h>
#include <libwebsockets/lws-jpeg.h>
#include <libwebsockets/lws-display.h>
#include <libwebsockets/lws-dlo.h>
#include <libwebsockets/lws-ssd1306-i2c.h>
#include <libwebsockets/lws-ili9341-spi.h>
#include <libwebsockets/lws-settings.h>

28
include/libwebsockets/lws-display.h
View file

@ -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
*

443
include/libwebsockets/lws-dlo.h Normal file
View file

@ -0,0 +1,443 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <stdint.h>
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);

8
lib/core/private-lib-core.h
View file

@ -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;

6
lib/drivers/CMakeLists.txt
View file

@ -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

130
lib/drivers/display/lws-display.c
View file

@ -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;
}

27
lib/misc/CMakeLists.txt
View file

@ -1,7 +1,7 @@
#
# libwebsockets - small server side websockets and web server implementation
#
# Copyright (C) 2010 - 2020 Andy Green <andy@warmcat.com>
# Copyright (C) 2010 - 2022 Andy Green <andy@warmcat.com>
#
# 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)

528
lib/misc/dlo/dlo-font-mcufont.c Normal file
View file

@ -0,0 +1,528 @@
/*
* lws abstract display
*
* Copyright (C) 2013 Petteri Aimonen
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

195
lib/misc/dlo/dlo-jpeg.c Normal file
View file

@ -0,0 +1,195 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

184
lib/misc/dlo/dlo-png.c Normal file
View file

@ -0,0 +1,184 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

247
lib/misc/dlo/dlo-rect.c Normal file
View file

@ -0,0 +1,247 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

289
lib/misc/dlo/dlo-ss.c Normal file
View file

@ -0,0 +1,289 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

413
lib/misc/dlo/dlo-text.c Normal file
View file

@ -0,0 +1,413 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

365
lib/misc/dlo/dlo.c Normal file
View file

@ -0,0 +1,365 @@
/*
* lws abstract display
*
* Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
*
* 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 <private-lib-core.h>
#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;
}

57
lib/misc/dlo/private-lib-drivers-display-dlo.h Normal file
View file

@ -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);