text
stringlengths 9
39.2M
| dir
stringlengths 25
226
| lang
stringclasses 163
values | created_date
timestamp[s] | updated_date
timestamp[s] | repo_name
stringclasses 751
values | repo_full_name
stringclasses 752
values | star
int64 1.01k
183k
| len_tokens
int64 1
18.5M
|
|---|---|---|---|---|---|---|---|---|
```objective-c
/*
*/
#pragma once
#include "BarcodeFormat.h"
#include "CharacterSet.h"
#include <string>
namespace ZXing {
class BitMatrix;
/**
* This class is here just for convenience as it offers single-point service
* to generate barcodes for all supported formats. As a result, this class
* offer very limited customization compared to what are available in each
* individual encoder.
*/
class MultiFormatWriter
{
public:
explicit MultiFormatWriter(BarcodeFormat format) : _format(format) {}
/**
* Used for Aztec, PDF417, and QRCode only.
*/
MultiFormatWriter& setEncoding(CharacterSet encoding) {
_encoding = encoding;
return *this;
}
/**
* Used for Aztec, PDF417, and QRCode only, [0-8].
*/
MultiFormatWriter& setEccLevel(int level) {
_eccLevel = level;
return *this;
}
/**
* Used for all formats, sets the minimum number of quiet zone pixels.
*/
MultiFormatWriter& setMargin(int margin) {
_margin = margin;
return *this;
}
BitMatrix encode(const std::wstring& contents, int width, int height) const;
BitMatrix encode(const std::string& contents, int width, int height) const;
private:
BarcodeFormat _format;
CharacterSet _encoding = CharacterSet::Unknown;
int _margin = -1;
int _eccLevel = -1;
};
} // ZXing
```
|
/content/code_sandbox/core/src/MultiFormatWriter.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 320
|
```objective-c
/*
*/
#pragma once
#include "CharacterSet.h"
#include <string>
namespace ZXing {
enum class ECI : int
{
Unknown = -1,
Cp437 = 2, // obsolete
ISO8859_1 = 3,
ISO8859_2 = 4,
ISO8859_3 = 5,
ISO8859_4 = 6,
ISO8859_5 = 7,
ISO8859_6 = 8,
ISO8859_7 = 9,
ISO8859_8 = 10,
ISO8859_9 = 11,
ISO8859_10 = 12,
ISO8859_11 = 13,
ISO8859_13 = 15,
ISO8859_14 = 16,
ISO8859_15 = 17,
ISO8859_16 = 18,
Shift_JIS = 20,
Cp1250 = 21,
Cp1251 = 22,
Cp1252 = 23,
Cp1256 = 24,
UTF16BE = 25,
UTF8 = 26,
ASCII = 27,
Big5 = 28,
GB2312 = 29,
EUC_KR = 30,
GB18030 = 32,
UTF16LE = 33,
UTF32BE = 34,
UTF32LE = 35,
ISO646_Inv = 170,
Binary = 899
};
inline constexpr int ToInt(ECI eci)
{
return static_cast<int>(eci);
}
inline constexpr bool IsText(ECI eci)
{
return ToInt(eci) >= 0 && ToInt(eci) <= 170;
}
inline constexpr bool CanProcess(ECI eci)
{
// see path_to_url#r74864359
return ToInt(eci) <= 899;
}
/**
* @brief ToString converts the numerical ECI value to a 7 character string as used in the ECI protocol
* @return e.g. "\000020"
*/
std::string ToString(ECI eci);
CharacterSet ToCharacterSet(ECI eci);
ECI ToECI(CharacterSet cs);
} // namespace ZXing
```
|
/content/code_sandbox/core/src/ECI.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 504
|
```objective-c
/*
*/
#pragma once
#include "Range.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <stdexcept>
#include <type_traits>
#include <vector>
namespace ZXing {
class ByteArray;
/**
* A simple, fast array of bits.
*/
class BitArray
{
std::vector<uint8_t> _bits;
friend class BitMatrix;
// Nothing wrong to support it, just to make it explicit, instead of by mistake.
// Use copy() below.
BitArray(const BitArray &) = default;
BitArray& operator=(const BitArray &) = delete;
public:
using Iterator = std::vector<uint8_t>::const_iterator;
BitArray() = default;
explicit BitArray(int size) : _bits(size, 0) {}
BitArray(BitArray&& other) noexcept = default;
BitArray& operator=(BitArray&& other) noexcept = default;
BitArray copy() const { return *this; }
int size() const noexcept { return Size(_bits); }
int sizeInBytes() const noexcept { return (size() + 7) / 8; }
bool get(int i) const { return _bits.at(i) != 0; }
void set(int i, bool val) { _bits.at(i) = val; }
// If you know exactly how may bits you are going to iterate
// and that you access bit in sequence, iterator is faster than get().
// However, be extremely careful since there is no check whatsoever.
// (Performance is the reason for the iterator to exist in the first place.)
Iterator iterAt(int i) const noexcept { return {_bits.cbegin() + i}; }
Iterator begin() const noexcept { return _bits.cbegin(); }
Iterator end() const noexcept { return _bits.cend(); }
/**
* Appends the least-significant bits, from value, in order from most-significant to
* least-significant. For example, appending 6 bits from 0x000001E will append the bits
* 0, 1, 1, 1, 1, 0 in that order.
*
* @param value {@code int} containing bits to append
* @param numBits bits from value to append
*/
void appendBits(int value, int numBits)
{
for (; numBits; --numBits)
_bits.push_back((value >> (numBits-1)) & 1);
}
void appendBit(bool bit) { _bits.push_back(bit); }
void appendBitArray(const BitArray& other) { _bits.insert(_bits.end(), other.begin(), other.end()); }
/**
* Reverses all bits in the array.
*/
void reverse() { std::reverse(_bits.begin(), _bits.end()); }
void bitwiseXOR(const BitArray& other);
/**
* @param bitOffset first bit to extract
* @param numBytes how many bytes to extract (-1 == until the end, padded with '0')
* @return Bytes are written most-significant bit first.
*/
ByteArray toBytes(int bitOffset = 0, int numBytes = -1) const;
using Range = ZXing::Range<Iterator>;
Range range() const { return {begin(), end()}; }
friend bool operator==(const BitArray& a, const BitArray& b) { return a._bits == b._bits; }
};
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
T& AppendBit(T& val, bool bit)
{
return (val <<= 1) |= static_cast<T>(bit);
}
template <typename ARRAY, typename = std::enable_if_t<std::is_integral_v<typename ARRAY::value_type>>>
int ToInt(const ARRAY& a)
{
assert(Reduce(a) <= 32);
int pattern = 0;
for (int i = 0; i < Size(a); i++)
pattern = (pattern << a[i]) | ~(0xffffffff << a[i]) * (~i & 1);
return pattern;
}
template <typename T = int, typename = std::enable_if_t<std::is_integral_v<T>>>
T ToInt(const BitArray& bits, int pos = 0, int count = 8 * sizeof(T))
{
assert(0 <= count && count <= 8 * (int)sizeof(T));
assert(0 <= pos && pos + count <= bits.size());
count = std::min(count, bits.size());
int res = 0;
auto it = bits.iterAt(pos);
for (int i = 0; i < count; ++i, ++it)
AppendBit(res, *it);
return res;
}
template <typename T = int, typename = std::enable_if_t<std::is_integral_v<T>>>
std::vector<T> ToInts(const BitArray& bits, int wordSize, int totalWords, int offset = 0)
{
assert(totalWords >= bits.size() / wordSize);
assert(wordSize <= 8 * (int)sizeof(T));
std::vector<T> res(totalWords, 0);
for (int i = offset; i < bits.size(); i += wordSize)
res[(i - offset) / wordSize] = ToInt(bits, i, wordSize);
return res;
}
class BitArrayView
{
const BitArray& bits;
BitArray::Iterator cur;
public:
BitArrayView(const BitArray& bits) : bits(bits), cur(bits.begin()) {}
BitArrayView& skipBits(int n)
{
if (cur + n > bits.end())
throw std::out_of_range("BitArrayView::skipBits() out of range.");
cur += n;
return *this;
}
int peakBits(int n) const
{
assert(n <= 32);
if (cur + n > bits.end())
throw std::out_of_range("BitArrayView::peakBits() out of range.");
int res = 0;
for (auto i = cur; n > 0; --n, i++)
AppendBit(res, *i);
return res;
}
int readBits(int n)
{
int res = peakBits(n);
cur += n;
return res;
}
int size() const
{
return narrow_cast<int>(bits.end() - cur);
}
explicit operator bool() const { return size(); }
};
} // ZXing
```
|
/content/code_sandbox/core/src/BitArray.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,371
|
```c++
/*
*/
#include "CharacterSet.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cctype>
namespace ZXing {
struct CharacterSetName
{
std::string_view name;
CharacterSet cs;
};
static CharacterSetName NAME_TO_CHARSET[] = {
{"Cp437", CharacterSet::Cp437},
{"ISO-8859-1", CharacterSet::ISO8859_1},
{"ISO-8859-2", CharacterSet::ISO8859_2},
{"ISO-8859-3", CharacterSet::ISO8859_3},
{"ISO-8859-4", CharacterSet::ISO8859_4},
{"ISO-8859-5", CharacterSet::ISO8859_5},
{"ISO-8859-6", CharacterSet::ISO8859_6},
{"ISO-8859-7", CharacterSet::ISO8859_7},
{"ISO-8859-8", CharacterSet::ISO8859_8},
{"ISO-8859-9", CharacterSet::ISO8859_9},
{"ISO-8859-10", CharacterSet::ISO8859_10},
{"ISO-8859-11", CharacterSet::ISO8859_11},
{"ISO-8859-13", CharacterSet::ISO8859_13},
{"ISO-8859-14", CharacterSet::ISO8859_14},
{"ISO-8859-15", CharacterSet::ISO8859_15},
{"ISO-8859-16", CharacterSet::ISO8859_16},
{"SJIS", CharacterSet::Shift_JIS},
{"Shift_JIS", CharacterSet::Shift_JIS},
{"Cp1250", CharacterSet::Cp1250},
{"windows-1250",CharacterSet::Cp1250},
{"Cp1251", CharacterSet::Cp1251},
{"windows-1251",CharacterSet::Cp1251},
{"Cp1252", CharacterSet::Cp1252},
{"windows-1252",CharacterSet::Cp1252},
{"Cp1256", CharacterSet::Cp1256},
{"windows-1256",CharacterSet::Cp1256},
{"UTF-16BE", CharacterSet::UTF16BE},
{"UTF-16LE", CharacterSet::UTF16LE},
{"UTF-32BE", CharacterSet::UTF32BE},
{"UTF-32LE", CharacterSet::UTF32LE},
{"UnicodeBigUnmarked", CharacterSet::UTF16BE},
{"UnicodeBig", CharacterSet::UTF16BE},
{"UTF-8", CharacterSet::UTF8},
{"ASCII", CharacterSet::ASCII},
{"US-ASCII", CharacterSet::ASCII},
{"Big5", CharacterSet::Big5},
{"GB2312", CharacterSet::GB2312},
{"GB18030", CharacterSet::GB18030},
{"EUC-CN", CharacterSet::GB18030},
{"GBK", CharacterSet::GB18030},
{"EUC-KR", CharacterSet::EUC_KR},
{"BINARY", CharacterSet::BINARY},
};
static std::string NormalizeName(std::string_view sv)
{
std::string str(sv);
std::transform(str.begin(), str.end(), str.begin(), [](char c) { return (char)std::tolower(c); });
str.erase(std::remove_if(str.begin(), str.end(), [](char c) { return Contains("_-[] ", c); }), str.end());
return str;
}
CharacterSet CharacterSetFromString(std::string_view name)
{
auto i = FindIf(NAME_TO_CHARSET, [str = NormalizeName(name)](auto& v) { return NormalizeName(v.name) == str; });
return i == std::end(NAME_TO_CHARSET) ? CharacterSet::Unknown : i->cs;
}
std::string ToString(CharacterSet cs)
{
auto i = FindIf(NAME_TO_CHARSET, [cs](auto& v) { return v.cs == cs; });
return i == std::end(NAME_TO_CHARSET) ? "" : std::string(i->name);
}
} // namespace ZXing
```
|
/content/code_sandbox/core/src/CharacterSet.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 897
|
```objective-c
/*
*/
#pragma once
#include <string>
#include <string_view>
namespace ZXing::TextUtfEncoding {
// The following functions are not required anymore after Barcode::text() now returns utf8 natively and the encoders accept utf8 as well.
[[deprecated]] std::string ToUtf8(std::wstring_view str);
[[deprecated]] std::string ToUtf8(std::wstring_view str, const bool angleEscape);
[[deprecated]] std::wstring FromUtf8(std::string_view utf8);
} // namespace ZXing::TextUtfEncoding
```
|
/content/code_sandbox/core/src/TextUtfEncoding.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 113
|
```objective-c
/*
*/
#pragma once
#include "BarcodeFormat.h"
#include "ReadBarcode.h"
#include "WriteBarcode.h"
#ifdef ZXING_EXPERIMENTAL_API
namespace ZXing {
enum class Operation
{
Create,
Read,
CreateAndRead,
CreateOrRead,
};
BarcodeFormats SupportedBarcodeFormats(Operation op = Operation::CreateOrRead);
} // namespace ZXing
#endif // ZXING_EXPERIMENTAL_API
```
|
/content/code_sandbox/core/src/ZXingCpp.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 85
|
```objective-c
/*
*/
#pragma once
#include "Matrix.h"
#include <cstdint>
namespace ZXing {
// TODO: If kept at all, this should be replaced by `using ByteMatrix = Matrix<uint8_t>;` to be consistent with ByteArray
// This non-template class is kept for now to stay source-compatible with older versions of the library.
// [[deprecated]]
class ByteMatrix : public Matrix<int8_t>
{
public:
ByteMatrix() = default;
ByteMatrix(int width, int height, int8_t val = 0) : Matrix<int8_t>(width, height, val) {}
ByteMatrix(ByteMatrix&&) noexcept = default;
ByteMatrix& operator=(ByteMatrix&&) noexcept = default;
};
} // ZXing
```
|
/content/code_sandbox/core/src/ByteMatrix.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 154
|
```objective-c
/*
*/
#pragma once
#include "BitMatrix.h"
#include <climits>
namespace ZXing {
enum class Direction { LEFT = -1, RIGHT = 1 };
inline Direction opposite(Direction dir) noexcept
{
return dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT;
}
/**
* @brief The BitMatrixCursor represents a current position inside an image and current direction it can advance towards.
*
* The current position and direction is a PointT<T>. So depending on the type it can be used to traverse the image
* in a Bresenham style (PointF) or in a discrete way (step only horizontal/vertical/diagonal (PointI)).
*/
template<typename POINT>
class BitMatrixCursor
{
using this_t = BitMatrixCursor<POINT>;
public:
const BitMatrix* img;
POINT p; // current position
POINT d; // current direction
BitMatrixCursor(const BitMatrix& image, POINT p, POINT d) : img(&image), p(p) { setDirection(d); }
class Value
{
enum { INVALID = -1, WHITE = 0, BLACK = 1 };
int v = INVALID;
public:
Value() = default;
Value(bool isBlack) : v(isBlack) {}
bool isValid() const noexcept { return v != INVALID; }
bool isWhite() const noexcept { return v == WHITE; }
bool isBlack() const noexcept { return v == BLACK; }
operator bool() const noexcept { return isValid(); }
bool operator==(Value o) const { return v == o.v; }
bool operator!=(Value o) const { return v != o.v; }
};
template <typename T>
Value testAt(PointT<T> p) const
{
return img->isIn(p) ? Value{img->get(p)} : Value{};
}
bool blackAt(POINT pos) const noexcept { return testAt(pos).isBlack(); }
bool whiteAt(POINT pos) const noexcept { return testAt(pos).isWhite(); }
bool isIn(POINT p) const noexcept { return img->isIn(p); }
bool isIn() const noexcept { return isIn(p); }
bool isBlack() const noexcept { return blackAt(p); }
bool isWhite() const noexcept { return whiteAt(p); }
POINT front() const noexcept { return d; }
POINT back() const noexcept { return {-d.x, -d.y}; }
POINT left() const noexcept { return {d.y, -d.x}; }
POINT right() const noexcept { return {-d.y, d.x}; }
POINT direction(Direction dir) const noexcept { return static_cast<int>(dir) * right(); }
void turnBack() noexcept { d = back(); }
void turnLeft() noexcept { d = left(); }
void turnRight() noexcept { d = right(); }
void turn(Direction dir) noexcept { d = direction(dir); }
Value edgeAt(POINT d) const noexcept
{
Value v = testAt(p);
return testAt(p + d) != v ? v : Value();
}
Value edgeAtFront() const noexcept { return edgeAt(front()); }
Value edgeAtBack() const noexcept { return edgeAt(back()); }
Value edgeAtLeft() const noexcept { return edgeAt(left()); }
Value edgeAtRight() const noexcept { return edgeAt(right()); }
Value edgeAt(Direction dir) const noexcept { return edgeAt(direction(dir)); }
this_t& setDirection(PointF dir) { return d = bresenhamDirection(dir), *this; }
this_t& setDirection(PointI dir) { return d = dir, *this; }
bool step(typename POINT::value_t s = 1)
{
p += s * d;
return isIn(p);
}
this_t movedBy(POINT o) const noexcept { return {*img, p + o, d}; }
this_t turnedBack() const noexcept { return {*img, p, back()}; }
/**
* @brief stepToEdge advances cursor to one step behind the next (or n-th) edge.
* @param nth number of edges to pass
* @param range max number of steps to take
* @param backup whether or not to backup one step so we land in front of the edge
* @return number of steps taken or 0 if moved outside of range/image
*/
int stepToEdge(int nth = 1, int range = 0, bool backup = false)
{
int steps = 0;
auto lv = testAt(p);
while (nth && (!range || steps < range) && lv.isValid()) {
++steps;
auto v = testAt(p + steps * d);
if (lv != v) {
lv = v;
--nth;
}
}
if (backup)
--steps;
p += steps * d;
return steps * (nth == 0);
}
bool stepAlongEdge(Direction dir, bool skipCorner = false)
{
if (!edgeAt(dir))
turn(dir);
else if (edgeAtFront()) {
turn(opposite(dir));
if (edgeAtFront()) {
turn(opposite(dir));
if (edgeAtFront())
return false;
}
}
bool ret = step();
if (ret && skipCorner && !edgeAt(dir)) {
turn(dir);
ret = step();
}
return ret;
}
int countEdges(int range)
{
int res = 0;
while (int steps = range ? stepToEdge(1, range) : 0) {
range -= steps;
++res;
}
return res;
}
template<typename ARRAY>
ARRAY readPattern(int range = 0)
{
ARRAY res = {};
for (auto& i : res) {
i = stepToEdge(1, range);
if (!i)
return res;
if (range)
range -= i;
}
return res;
}
template<typename ARRAY>
ARRAY readPatternFromBlack(int maxWhitePrefix, int range = 0)
{
if (maxWhitePrefix && isWhite() && !stepToEdge(1, maxWhitePrefix))
return {};
return readPattern<ARRAY>(range);
}
};
using BitMatrixCursorF = BitMatrixCursor<PointF>;
using BitMatrixCursorI = BitMatrixCursor<PointI>;
class FastEdgeToEdgeCounter
{
const uint8_t* p = nullptr;
int stride = 0;
int stepsToBorder = 0;
public:
FastEdgeToEdgeCounter(const BitMatrixCursorI& cur)
{
stride = cur.d.y * cur.img->width() + cur.d.x;
p = cur.img->row(cur.p.y).begin() + cur.p.x;
int maxStepsX = cur.d.x ? (cur.d.x > 0 ? cur.img->width() - 1 - cur.p.x : cur.p.x) : INT_MAX;
int maxStepsY = cur.d.y ? (cur.d.y > 0 ? cur.img->height() - 1 - cur.p.y : cur.p.y) : INT_MAX;
stepsToBorder = std::min(maxStepsX, maxStepsY);
}
int stepToNextEdge(int range)
{
int maxSteps = std::min(stepsToBorder, range);
int steps = 0;
do {
if (++steps > maxSteps) {
if (maxSteps == stepsToBorder)
break;
else
return 0;
}
} while (p[steps * stride] == p[0]);
p += steps * stride;
stepsToBorder -= steps;
return steps;
}
};
} // ZXing
```
|
/content/code_sandbox/core/src/BitMatrixCursor.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,658
|
```objective-c
/*
*/
#pragma once
#include <string>
#include <string_view>
namespace ZXing {
std::string ToUtf8(std::wstring_view str);
std::wstring FromUtf8(std::string_view utf8);
#if __cplusplus > 201703L
std::wstring FromUtf8(std::u8string_view utf8);
#endif
std::wstring EscapeNonGraphical(std::wstring_view str);
std::string EscapeNonGraphical(std::string_view utf8);
} // namespace ZXing
```
|
/content/code_sandbox/core/src/Utf.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 103
|
```c++
/*
*/
#include "Barcode.h"
#include "DecoderResult.h"
#include "DetectorResult.h"
#include "ZXAlgorithms.h"
#ifdef ZXING_EXPERIMENTAL_API
#include "BitMatrix.h"
#endif
#ifdef ZXING_USE_ZINT
#include <zint.h>
void zint_symbol_deleter::operator()(zint_symbol* p) const noexcept
{
ZBarcode_Delete(p);
}
#else
struct zint_symbol {};
#endif
#include <cmath>
#include <list>
#include <map>
#include <utility>
namespace ZXing {
Result::Result(const std::string& text, int y, int xStart, int xStop, BarcodeFormat format, SymbologyIdentifier si, Error error, bool readerInit)
: _content({ByteArray(text)}, si),
_error(error),
_position(Line(y, xStart, xStop)),
_format(format),
_readerInit(readerInit)
{}
Result::Result(DecoderResult&& decodeResult, DetectorResult&& detectorResult, BarcodeFormat format)
: _content(std::move(decodeResult).content()),
_error(std::move(decodeResult).error()),
_position(std::move(detectorResult).position()),
_sai(decodeResult.structuredAppend()),
_format(format),
_lineCount(decodeResult.lineCount()),
_isMirrored(decodeResult.isMirrored()),
_readerInit(decodeResult.readerInit())
#ifdef ZXING_EXPERIMENTAL_API
, _symbol(std::make_shared<BitMatrix>(std::move(detectorResult).bits()))
#endif
{
if (decodeResult.versionNumber())
snprintf(_version, 4, "%d", decodeResult.versionNumber());
snprintf(_ecLevel, 4, "%s", decodeResult.ecLevel().data());
// TODO: add type opaque and code specific 'extra data'? (see DecoderResult::extra())
}
Result::Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat format)
: Result(std::move(decodeResult), {{}, std::move(position)}, format)
{}
bool Result::isValid() const
{
return format() != BarcodeFormat::None && !_content.bytes.empty() && !error();
}
const ByteArray& Result::bytes() const
{
return _content.bytes;
}
ByteArray Result::bytesECI() const
{
return _content.bytesECI();
}
std::string Result::text(TextMode mode) const
{
return _content.text(mode);
}
std::string Result::text() const
{
return text(_readerOpts.textMode());
}
std::string Result::ecLevel() const
{
return _ecLevel;
}
ContentType Result::contentType() const
{
return _content.type();
}
bool Result::hasECI() const
{
return _content.hasECI;
}
int Result::orientation() const
{
constexpr auto std_numbers_pi_v = 3.14159265358979323846; // TODO: c++20 <numbers>
return narrow_cast<int>(std::lround(_position.orientation() * 180 / std_numbers_pi_v));
}
std::string Result::symbologyIdentifier() const
{
return _content.symbology.toString();
}
int Result::sequenceSize() const
{
return _sai.count;
}
int Result::sequenceIndex() const
{
return _sai.index;
}
std::string Result::sequenceId() const
{
return _sai.id;
}
std::string Result::version() const
{
return _version;
}
Result& Result::setReaderOptions(const ReaderOptions& opts)
{
if (opts.characterSet() != CharacterSet::Unknown)
_content.defaultCharset = opts.characterSet();
_readerOpts = opts;
return *this;
}
#ifdef ZXING_EXPERIMENTAL_API
void Result::symbol(BitMatrix&& bits)
{
bits.flipAll();
_symbol = std::make_shared<BitMatrix>(std::move(bits));
}
ImageView Result::symbol() const
{
return {_symbol->row(0).begin(), _symbol->width(), _symbol->height(), ImageFormat::Lum};
}
void Result::zint(unique_zint_symbol&& z)
{
_zint = std::shared_ptr(std::move(z));
}
#endif
bool Result::operator==(const Result& o) const
{
// handle case where both are MatrixCodes first
if (!BarcodeFormats(BarcodeFormat::LinearCodes).testFlags(format() | o.format())) {
if (format() != o.format() || (bytes() != o.bytes() && isValid() && o.isValid()))
return false;
// check for equal position if both are valid with equal bytes or at least one is in error
return IsInside(Center(o.position()), position());
}
if (format() != o.format() || bytes() != o.bytes() || error() != o.error())
return false;
if (orientation() != o.orientation())
return false;
if (lineCount() > 1 && o.lineCount() > 1)
return HaveIntersectingBoundingBoxes(o.position(), position());
// the following code is only meant for this or other lineCount == 1
assert(lineCount() == 1 || o.lineCount() == 1);
// sl == single line, ml = multi line
const auto& sl = lineCount() == 1 ? *this : o;
const auto& ml = lineCount() == 1 ? o : *this;
// If one line is less than half the length of the other away from the
// latter, we consider it to belong to the same symbol.
// Additionally, both need to have roughly the same length (see #367).
auto dTop = maxAbsComponent(ml.position().topLeft() - sl.position().topLeft());
auto dBot = maxAbsComponent(ml.position().bottomLeft() - sl.position().topLeft());
auto slLength = maxAbsComponent(sl.position().topLeft() - sl.position().bottomRight());
bool isHorizontal = sl.position().topLeft().y == sl.position().bottomRight().y;
// Measure the multi line length in the same direction as the single line one (not diagonaly)
// to make sure overly tall symbols don't get segmented (see #769).
auto mlLength = isHorizontal ? std::abs(ml.position().topLeft().x - ml.position().bottomRight().x)
: std::abs(ml.position().topLeft().y - ml.position().bottomRight().y);
return std::min(dTop, dBot) < slLength / 2 && std::abs(slLength - mlLength) < slLength / 5;
}
Barcode MergeStructuredAppendSequence(const Barcodes& barcodes)
{
if (barcodes.empty())
return {};
std::list<Barcode> allBarcodes(barcodes.begin(), barcodes.end());
allBarcodes.sort([](const Barcode& r1, const Barcode& r2) { return r1.sequenceIndex() < r2.sequenceIndex(); });
Barcode res = allBarcodes.front();
for (auto i = std::next(allBarcodes.begin()); i != allBarcodes.end(); ++i)
res._content.append(i->_content);
res._position = {};
res._sai.index = -1;
if (allBarcodes.back().sequenceSize() != Size(allBarcodes) ||
!std::all_of(allBarcodes.begin(), allBarcodes.end(),
[&](Barcode& it) { return it.sequenceId() == allBarcodes.front().sequenceId(); }))
res._error = FormatError("sequenceIDs not matching during structured append sequence merging");
return res;
}
Barcodes MergeStructuredAppendSequences(const Barcodes& barcodes)
{
std::map<std::string, Barcodes> sas;
for (auto& barcode : barcodes) {
if (barcode.isPartOfSequence())
sas[barcode.sequenceId()].push_back(barcode);
}
Barcodes res;
for (auto& [id, seq] : sas) {
auto barcode = MergeStructuredAppendSequence(seq);
if (barcode.isValid())
res.push_back(std::move(barcode));
}
return res;
}
} // namespace ZXing
```
|
/content/code_sandbox/core/src/Barcode.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,702
|
```objective-c
/*
*/
#pragma once
#include "Matrix.h"
#include "Point.h"
#include "Range.h"
#include <cstdint>
#include <stdexcept>
#include <vector>
namespace ZXing {
class BitArray;
class ByteMatrix;
/**
* @brief A simple, fast 2D array of bits.
*/
class BitMatrix
{
int _width = 0;
int _height = 0;
using data_t = uint8_t;
std::vector<data_t> _bits;
// There is nothing wrong to support this but disable to make it explicit since we may copy something very big here.
// Use copy() below.
BitMatrix(const BitMatrix&) = default;
BitMatrix& operator=(const BitMatrix&) = delete;
const data_t& get(int i) const
{
#if 1
return _bits.at(i);
#else
return _bits[i];
#endif
}
data_t& get(int i) { return const_cast<data_t&>(static_cast<const BitMatrix*>(this)->get(i)); }
bool getTopLeftOnBit(int &left, int& top) const;
bool getBottomRightOnBit(int &right, int& bottom) const;
public:
static constexpr data_t SET_V = 0xff; // allows playing with SIMD binarization
static constexpr data_t UNSET_V = 0;
static_assert(bool(SET_V) && !bool(UNSET_V), "SET_V needs to evaluate to true, UNSET_V to false, see iterator usage");
BitMatrix() = default;
#if defined(__llvm__) || (defined(__GNUC__) && (__GNUC__ > 7))
__attribute__((no_sanitize("signed-integer-overflow")))
#endif
BitMatrix(int width, int height) : _width(width), _height(height), _bits(width * height, UNSET_V)
{
if (width != 0 && Size(_bits) / width != height)
throw std::invalid_argument("Invalid size: width * height is too big");
}
explicit BitMatrix(int dimension) : BitMatrix(dimension, dimension) {} // Construct a square matrix.
BitMatrix(BitMatrix&& other) noexcept = default;
BitMatrix& operator=(BitMatrix&& other) noexcept = default;
BitMatrix copy() const { return *this; }
Range<data_t*> row(int y) { return {_bits.data() + y * _width, _bits.data() + (y + 1) * _width}; }
Range<const data_t*> row(int y) const { return {_bits.data() + y * _width, _bits.data() + (y + 1) * _width}; }
Range<StrideIter<const data_t*>> col(int x) const
{
return {{_bits.data() + x + (_height - 1) * _width, -_width}, {_bits.data() + x - _width, -_width}};
}
bool get(int x, int y) const { return get(y * _width + x); }
void set(int x, int y, bool val = true) { get(y * _width + x) = val * SET_V; }
/**
* <p>Flips the given bit.</p>
*
* @param x The horizontal component (i.e. which column)
* @param y The vertical component (i.e. which row)
*/
void flip(int x, int y)
{
auto& v = get(y * _width + x);
v = !v;
}
void flipAll()
{
for (auto& i : _bits)
i = !i * SET_V;
}
/**
* <p>Sets a square region of the bit matrix to true.</p>
*
* @param left The horizontal position to begin at (inclusive)
* @param top The vertical position to begin at (inclusive)
* @param width The width of the region
* @param height The height of the region
*/
void setRegion(int left, int top, int width, int height);
void rotate90();
void rotate180();
void mirror();
/**
* Find the rectangle that contains all non-white pixels. Useful for detection of 'pure' barcodes.
*
* @return True iff this rectangle is at least minWidth x minHeight pixels big
*/
bool findBoundingBox(int &left, int& top, int& width, int& height, int minSize = 1) const;
int width() const { return _width; }
int height() const { return _height; }
bool empty() const { return _bits.empty(); }
friend bool operator==(const BitMatrix& a, const BitMatrix& b)
{
return a._width == b._width && a._height == b._height && a._bits == b._bits;
}
template <typename T>
bool isIn(PointT<T> p, int b = 0) const noexcept
{
return b <= p.x && p.x < width() - b && b <= p.y && p.y < height() - b;
}
bool get(PointI p) const { return get(p.x, p.y); }
bool get(PointF p) const { return get(PointI(p)); }
void set(PointI p, bool v = true) { set(p.x, p.y, v); }
void set(PointF p, bool v = true) { set(PointI(p), v); }
};
void GetPatternRow(const BitMatrix& matrix, int r, std::vector<uint16_t>& pr, bool transpose);
/**
* @brief Inflate scales a BitMatrix up and adds a quiet Zone plus padding
* @param input matrix to be expanded
* @param width new width in bits (pixel)
* @param height new height in bits (pixel)
* @param quietZone size of quiet zone to add in modules
* @return expanded BitMatrix, maybe move(input) if size did not change
*/
BitMatrix Inflate(BitMatrix&& input, int width, int height, int quietZone);
/**
* @brief Deflate (crop + subsample) a bit matrix
* @param input matrix to be shrinked
* @param width new width
* @param height new height
* @param top cropping starts at top row
* @param left cropping starts at left col
* @param subSampling typically the module size
* @return deflated input
*/
BitMatrix Deflate(const BitMatrix& input, int width, int height, float top, float left, float subSampling);
template<typename T>
BitMatrix ToBitMatrix(const Matrix<T>& in, T trueValue = {true})
{
BitMatrix out(in.width(), in.height());
for (int y = 0; y < in.height(); ++y)
for (int x = 0; x < in.width(); ++x)
if (in.get(x, y) == trueValue)
out.set(x, y);
return out;
}
template<typename T>
Matrix<T> ToMatrix(const BitMatrix& in, T black = 0, T white = ~0)
{
Matrix<T> res(in.width(), in.height());
for (int y = 0; y < in.height(); ++y)
for (int x = 0; x < in.width(); ++x)
res.set(x, y, in.get(x, y) ? black : white);
return res;
}
} // ZXing
```
|
/content/code_sandbox/core/src/BitMatrix.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,565
|
```objective-c
/*
*/
#pragma once
#include "BitHacks.h"
#include <cstddef>
#include <iterator>
#include <type_traits>
namespace ZXing {
template<typename Enum>
class Flags
{
static_assert(std::is_enum<Enum>::value, "Flags is only usable on enumeration types.");
using Int = typename std::underlying_type<Enum>::type;
Int i = 0;
constexpr inline Flags(Int other) : i(other) {}
constexpr static inline unsigned highestBitSet(Int x) noexcept { return x < 2 ? x : 1 + highestBitSet(x >> 1); }
public:
using enum_type = Enum;
constexpr inline Flags() noexcept = default;
constexpr inline Flags(Enum flag) noexcept : i(Int(flag)) {}
// constexpr inline Flags(std::initializer_list<Enum> flags) noexcept
// : i(initializer_list_helper(flags.begin(), flags.end()))
// {}
class iterator
{
friend class Flags;
const Int _flags = 0;
int _pos = 0;
iterator(Int i, int p) : _flags(i), _pos(p) {}
public:
using iterator_category = std::input_iterator_tag;
using value_type = Enum;
using difference_type = std::ptrdiff_t;
using pointer = Enum*;
using reference = Enum&;
Enum operator*() const noexcept { return Enum(1 << _pos); }
iterator& operator++() noexcept
{
while (++_pos < BitHacks::HighestBitSet(_flags) && !((1 << _pos) & _flags))
;
return *this;
}
bool operator==(const iterator& rhs) const noexcept { return _pos == rhs._pos; }
bool operator!=(const iterator& rhs) const noexcept { return !(*this == rhs); }
};
iterator begin() const noexcept { return {i, BitHacks::NumberOfTrailingZeros(i)}; }
iterator end() const noexcept { return {i, BitHacks::HighestBitSet(i) + 1}; }
bool empty() const noexcept { return i == 0; }
int count() const noexcept { return BitHacks::CountBitsSet(i); }
constexpr inline bool operator==(Flags other) const noexcept { return i == other.i; }
inline Flags& operator&=(Flags mask) noexcept { return i &= mask.i, *this; }
inline Flags& operator&=(Enum mask) noexcept { return i &= Int(mask), *this; }
inline Flags& operator|=(Flags other) noexcept { return i |= other.i, *this; }
inline Flags& operator|=(Enum other) noexcept { return i |= Int(other), *this; }
// inline Flags &operator^=(Flags other) noexcept { return i ^= other.i, *this; }
// inline Flags &operator^=(Enum other) noexcept { return i ^= Int(other), *this; }
constexpr inline Flags operator&(Flags other) const noexcept { return i & other.i; }
constexpr inline Flags operator&(Enum other) const noexcept { return i & Int(other); }
constexpr inline Flags operator|(Flags other) const noexcept { return i | other.i; }
constexpr inline Flags operator|(Enum other) const noexcept { return i | Int(other); }
// constexpr inline Flags operator^(Flags other) const noexcept { return i ^ other.i; }
// constexpr inline Flags operator^(Enum other) const noexcept { return i ^ Int(other); }
// constexpr inline Flags operator~() const noexcept { return ~i; }
// constexpr inline operator Int() const noexcept { return i; }
// constexpr inline bool operator!() const noexcept { return !i; }
// constexpr inline Int asInt() const noexcept { return i; }
constexpr inline bool testFlag(Enum flag) const noexcept
{
return (i & Int(flag)) == Int(flag) && (Int(flag) != 0 || i == Int(flag));
}
constexpr inline bool testFlags(Flags mask) const noexcept { return i & mask.i; }
inline Flags& setFlag(Enum flag, bool on = true) noexcept
{
return on ? (*this |= flag) : (*this &= ~Int(flag));
}
inline void clear() noexcept { i = 0; }
constexpr static Flags all() noexcept { return ~(unsigned(~0) << highestBitSet(Int(Enum::_max))); }
private:
// constexpr static inline Int
// initializer_list_helper(typename std::initializer_list<Enum>::const_iterator it,
// typename std::initializer_list<Enum>::const_iterator end) noexcept
// {
// return (it == end ? Int(0) : (Int(*it) | initializer_list_helper(it + 1, end)));
// }
};
#define ZX_DECLARE_FLAGS(FLAGS, ENUM) \
using FLAGS = Flags<ENUM>; \
constexpr inline FLAGS operator|(FLAGS::enum_type e1, FLAGS::enum_type e2) noexcept { return FLAGS(e1) | e2; } \
constexpr inline FLAGS operator|(FLAGS::enum_type e, FLAGS f) noexcept { return f | e; } \
constexpr inline bool operator==(FLAGS::enum_type e, FLAGS f) noexcept { return FLAGS(e) == f; } \
constexpr inline bool operator==(FLAGS f, FLAGS::enum_type e) noexcept { return FLAGS(e) == f; }
} // ZXing
```
|
/content/code_sandbox/core/src/Flags.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,114
|
```objective-c
/*
*/
#pragma once
#include <vector>
namespace ZXing {
class GenericGF;
/**
* <p>Implements Reed-Solomon decoding, as the name implies.</p>
*
* <p>The algorithm will not be explained here, but the following references were helpful
* in creating this implementation:</p>
*
* <ul>
* <li>Bruce Maggs.
* <a href="path_to_url">
* "Decoding Reed-Solomon Codes"</a> (see discussion of Forney's Formula)</li>
* <li>J.I. Hall. <a href="www.mth.msu.edu/~jhall/classes/codenotes/GRS.pdf">
* "Chapter 5. Generalized Reed-Solomon Codes"</a>
* (see discussion of Euclidean algorithm)</li>
* </ul>
*
* <p>Much credit is due to William Rucklidge since portions of this code are an indirect
* port of his C++ Reed-Solomon implementation.</p>
*
* @author Sean Owen
* @author William Rucklidge
* @author sanfordsquires
*/
/**
* @brief ReedSolomonDecode fixes errors in a message containing both data and parity codewords.
*
* @param message data and error-correction/parity codewords
* @param numECCodeWords number of error-correction code words
* @return true iff message errors could successfully be fixed (or there have not been any)
*/
bool ReedSolomonDecode(const GenericGF& field, std::vector<int>& message, int numECCodeWords);
} // ZXing
```
|
/content/code_sandbox/core/src/ReedSolomonDecoder.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 337
|
```c++
/*
*/
#include "ZXingC.h"
#include "ZXingCpp.h"
#include <cstdlib>
#include <exception>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
using namespace ZXing;
static thread_local std::string lastErrorMsg;
template<typename R, typename T> R transmute_cast(const T& v) noexcept
{
static_assert(sizeof(T) == sizeof(R));
return *(const R*)(&v);
}
template<typename C, typename P = typename C::pointer>
P copy(const C& c) noexcept
{
auto ret = (P)malloc(c.size() + 1);
if (ret) {
memcpy(ret, c.data(), c.size());
ret[c.size()] = 0;
}
return ret;
}
static uint8_t* copy(const ByteArray& ba, int* len) noexcept
{
// for convencience and as a safety measure, we NULL terminate even byte arrays
auto ret = copy(ba);
if (len)
*len = ret ? Size(ba) : 0;
return ret;
}
#define ZX_CHECK( GOOD, MSG ) \
if (!(GOOD)) { \
lastErrorMsg = MSG; \
return {}; \
}
#define ZX_CATCH(...) \
catch (std::exception & e) { \
lastErrorMsg = e.what(); \
} catch (...) { \
lastErrorMsg = "Unknown error"; \
} \
return __VA_ARGS__;
#define ZX_TRY(...) \
try { \
return __VA_ARGS__; \
} \
ZX_CATCH({})
static std::tuple<Barcodes, bool> ReadBarcodesAndSetLastError(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts,
int maxSymbols)
{
ZX_CHECK(iv, "ImageView param is NULL")
try {
auto o = opts ? *opts : ReaderOptions{};
if (maxSymbols)
o.setMaxNumberOfSymbols(maxSymbols);
return {ReadBarcodes(*iv, o), true};
}
ZX_CATCH({Barcodes{}, false})
}
extern "C" {
/*
* ZXing/ImageView.h
*/
ZXing_ImageView* ZXing_ImageView_new(const uint8_t* data, int width, int height, ZXing_ImageFormat format, int rowStride,
int pixStride)
{
ImageFormat cppformat = static_cast<ImageFormat>(format);
ZX_TRY(new ImageView(data, width, height, cppformat, rowStride, pixStride))
}
ZXing_ImageView* ZXing_ImageView_new_checked(const uint8_t* data, int size, int width, int height, ZXing_ImageFormat format,
int rowStride, int pixStride)
{
ImageFormat cppformat = static_cast<ImageFormat>(format);
ZX_TRY(new ImageView(data, size, width, height, cppformat, rowStride, pixStride))
}
void ZXing_ImageView_delete(ZXing_ImageView* iv)
{
delete iv;
}
void ZXing_ImageView_crop(ZXing_ImageView* iv, int left, int top, int width, int height)
{
*iv = iv->cropped(left, top, width, height);
}
void ZXing_ImageView_rotate(ZXing_ImageView* iv, int degree)
{
*iv = iv->rotated(degree);
}
void ZXing_Image_delete(ZXing_Image* img)
{
delete img;
}
const uint8_t* ZXing_Image_data(const ZXing_Image* img)
{
return img->data();
}
int ZXing_Image_width(const ZXing_Image* img)
{
return img->width();
}
int ZXing_Image_height(const ZXing_Image* img)
{
return img->height();
}
ZXing_ImageFormat ZXing_Image_format(const ZXing_Image* img)
{
return static_cast<ZXing_ImageFormat>(img->format());
}
/*
* ZXing/BarcodeFormat.h
*/
ZXing_BarcodeFormats ZXing_BarcodeFormatsFromString(const char* str)
{
if (!str)
return {};
try {
return transmute_cast<ZXing_BarcodeFormats>(BarcodeFormatsFromString(str));
}
ZX_CATCH(ZXing_BarcodeFormat_Invalid)
}
ZXing_BarcodeFormat ZXing_BarcodeFormatFromString(const char* str)
{
ZXing_BarcodeFormat res = ZXing_BarcodeFormatsFromString(str);
return BitHacks::CountBitsSet(res) == 1 ? res : ZXing_BarcodeFormat_Invalid;
}
char* ZXing_BarcodeFormatToString(ZXing_BarcodeFormat format)
{
return copy(ToString(static_cast<BarcodeFormat>(format)));
}
/*
* ZXing/ZXingCpp.h
*/
#ifdef ZXING_EXPERIMENTAL_API
ZXing_BarcodeFormats ZXing_SupportedBarcodeFormats(ZXing_Operation op)
{
return transmute_cast<ZXing_BarcodeFormats>(SupportedBarcodeFormats(static_cast<Operation>(op)));
}
#endif
/*
* ZXing/Barcode.h
*/
char* ZXing_ContentTypeToString(ZXing_ContentType type)
{
return copy(ToString(static_cast<ContentType>(type)));
}
char* ZXing_PositionToString(ZXing_Position position)
{
return copy(ToString(transmute_cast<Position>(position)));
}
bool ZXing_Barcode_isValid(const ZXing_Barcode* barcode)
{
return barcode != NULL && barcode->isValid();
}
ZXing_ErrorType ZXing_Barcode_errorType(const ZXing_Barcode* barcode)
{
return static_cast<ZXing_ErrorType>(barcode->error().type());
}
char* ZXing_Barcode_errorMsg(const ZXing_Barcode* barcode)
{
return copy(ToString(barcode->error()));
}
uint8_t* ZXing_Barcode_bytes(const ZXing_Barcode* barcode, int* len)
{
return copy(barcode->bytes(), len);
}
uint8_t* ZXing_Barcode_bytesECI(const ZXing_Barcode* barcode, int* len)
{
return copy(barcode->bytesECI(), len);
}
#define ZX_GETTER(TYPE, GETTER, TRANS) \
TYPE ZXing_Barcode_##GETTER(const ZXing_Barcode* barcode) { return TRANS(barcode->GETTER()); }
ZX_GETTER(ZXing_BarcodeFormat, format, static_cast<ZXing_BarcodeFormat>)
ZX_GETTER(ZXing_ContentType, contentType, static_cast<ZXing_ContentType>)
ZX_GETTER(char*, text, copy)
ZX_GETTER(char*, ecLevel, copy)
ZX_GETTER(char*, symbologyIdentifier, copy)
ZX_GETTER(ZXing_Position, position, transmute_cast<ZXing_Position>)
ZX_GETTER(int, orientation,)
ZX_GETTER(bool, hasECI,)
ZX_GETTER(bool, isInverted,)
ZX_GETTER(bool, isMirrored,)
ZX_GETTER(int, lineCount,)
void ZXing_Barcode_delete(ZXing_Barcode* barcode)
{
delete barcode;
}
void ZXing_Barcodes_delete(ZXing_Barcodes* barcodes)
{
delete barcodes;
}
int ZXing_Barcodes_size(const ZXing_Barcodes* barcodes)
{
return barcodes ? Size(*barcodes) : 0;
}
const ZXing_Barcode* ZXing_Barcodes_at(const ZXing_Barcodes* barcodes, int i)
{
if (!barcodes || i < 0 || i >= Size(*barcodes))
return NULL;
return &(*barcodes)[i];
}
ZXing_Barcode* ZXing_Barcodes_move(ZXing_Barcodes* barcodes, int i)
{
if (!barcodes || i < 0 || i >= Size(*barcodes))
return NULL;
ZX_TRY(new Barcode(std::move((*barcodes)[i])));
}
/*
* ZXing/ReaderOptions.h
*/
ZXing_ReaderOptions* ZXing_ReaderOptions_new()
{
ZX_TRY(new ReaderOptions());
}
void ZXing_ReaderOptions_delete(ZXing_ReaderOptions* opts)
{
delete opts;
}
#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
TYPE ZXing_ReaderOptions_get##SETTER(const ZXing_ReaderOptions* opts) { return opts->GETTER(); } \
void ZXing_ReaderOptions_set##SETTER(ZXing_ReaderOptions* opts, TYPE val) { opts->set##SETTER(val); }
ZX_PROPERTY(bool, tryHarder, TryHarder)
ZX_PROPERTY(bool, tryRotate, TryRotate)
ZX_PROPERTY(bool, tryInvert, TryInvert)
ZX_PROPERTY(bool, tryDownscale, TryDownscale)
ZX_PROPERTY(bool, isPure, IsPure)
ZX_PROPERTY(bool, returnErrors, ReturnErrors)
ZX_PROPERTY(int, minLineCount, MinLineCount)
ZX_PROPERTY(int, maxNumberOfSymbols, MaxNumberOfSymbols)
#undef ZX_PROPERTY
void ZXing_ReaderOptions_setFormats(ZXing_ReaderOptions* opts, ZXing_BarcodeFormats formats)
{
opts->setFormats(static_cast<BarcodeFormat>(formats));
}
ZXing_BarcodeFormats ZXing_ReaderOptions_getFormats(const ZXing_ReaderOptions* opts)
{
auto v = opts->formats();
return transmute_cast<ZXing_BarcodeFormats>(v);
}
#define ZX_ENUM_PROPERTY(TYPE, GETTER, SETTER) \
ZXing_##TYPE ZXing_ReaderOptions_get##SETTER(const ZXing_ReaderOptions* opts) { return static_cast<ZXing_##TYPE>(opts->GETTER()); } \
void ZXing_ReaderOptions_set##SETTER(ZXing_ReaderOptions* opts, ZXing_##TYPE val) { opts->set##SETTER(static_cast<TYPE>(val)); }
ZX_ENUM_PROPERTY(Binarizer, binarizer, Binarizer)
ZX_ENUM_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, EanAddOnSymbol)
ZX_ENUM_PROPERTY(TextMode, textMode, TextMode)
/*
* ZXing/ReadBarcode.h
*/
ZXing_Barcode* ZXing_ReadBarcode(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts)
{
auto [res, ok] = ReadBarcodesAndSetLastError(iv, opts, 1);
return !res.empty() ? new Barcode(std::move(res.front())) : NULL;
}
ZXing_Barcodes* ZXing_ReadBarcodes(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts)
{
auto [res, ok] = ReadBarcodesAndSetLastError(iv, opts, 0);
return !res.empty() || ok ? new Barcodes(std::move(res)) : NULL;
}
#ifdef ZXING_EXPERIMENTAL_API
/*
* ZXing/WriteBarcode.h
*/
ZXing_CreatorOptions* ZXing_CreatorOptions_new(ZXing_BarcodeFormat format)
{
ZX_TRY(new CreatorOptions(static_cast<BarcodeFormat>(format)));
}
void ZXing_CreatorOptions_delete(ZXing_CreatorOptions* opts)
{
delete opts;
}
#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
TYPE ZXing_CreatorOptions_get##SETTER(const ZXing_CreatorOptions* opts) { return opts->GETTER(); } \
void ZXing_CreatorOptions_set##SETTER(ZXing_CreatorOptions* opts, TYPE val) { opts->GETTER(val); }
ZX_PROPERTY(bool, readerInit, ReaderInit)
ZX_PROPERTY(bool, forceSquareDataMatrix, ForceSquareDataMatrix)
#undef ZX_PROPERTY
//ZX_PROPERTY(BarcodeFormat, format, Format)
char* ZXing_CreatorOptions_getEcLevel(const ZXing_CreatorOptions* opts)
{
return copy(opts->ecLevel());
}
void ZXing_CreatorOptions_setEcLevel(ZXing_CreatorOptions* opts, const char* val)
{
opts->ecLevel(val);
}
ZXing_WriterOptions* ZXing_WriterOptions_new()
{
ZX_TRY(new ZXing_WriterOptions());
}
void ZXing_WriterOptions_delete(ZXing_WriterOptions* opts)
{
delete opts;
}
#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
TYPE ZXing_WriterOptions_get##SETTER(const ZXing_WriterOptions* opts) { return opts->GETTER(); } \
void ZXing_WriterOptions_set##SETTER(ZXing_WriterOptions* opts, TYPE val) { opts->GETTER(val); }
ZX_PROPERTY(int, scale, Scale)
ZX_PROPERTY(int, sizeHint, SizeHint)
ZX_PROPERTY(int, rotate, Rotate)
ZX_PROPERTY(bool, withHRT, WithHRT)
ZX_PROPERTY(bool, withQuietZones, WithQuietZones)
#undef ZX_PROPERTY
ZXing_Barcode* ZXing_CreateBarcodeFromText(const char* data, int size, const ZXing_CreatorOptions* opts)
{
ZX_CHECK(data && opts, "Data and/or options param in CreateBarcodeFromText is NULL")
ZX_TRY(new Barcode(CreateBarcodeFromText({data, size ? static_cast<size_t>(size) : strlen(data)}, *opts));)
}
ZXing_Barcode* ZXing_CreateBarcodeFromBytes(const void* data, int size, const ZXing_CreatorOptions* opts)
{
ZX_CHECK(data && size && opts, "Data and/or options param in CreateBarcodeFromBytes is NULL")
ZX_TRY(new Barcode(CreateBarcodeFromBytes(data, size, *opts)))
}
char* ZXing_WriteBarcodeToSVG(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts)
{
ZX_CHECK(barcode, "Barcode param in WriteBarcodeToSVG is NULL")
ZX_TRY(copy(opts ? WriteBarcodeToSVG(*barcode, *opts) : WriteBarcodeToSVG(*barcode)))
}
ZXing_Image* ZXing_WriteBarcodeToImage(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts)
{
ZX_CHECK(barcode, "Barcode param in WriteBarcodeToSVG is NULL")
ZX_TRY(new Image(opts ? WriteBarcodeToImage(*barcode, *opts) : WriteBarcodeToImage(*barcode)))
}
#endif
/*
* ZXingC.h
*/
char* ZXing_LastErrorMsg()
{
if (lastErrorMsg.empty())
return NULL;
return copy(std::exchange(lastErrorMsg, {}));
}
void ZXing_free(void* ptr)
{
free(ptr);
}
} // extern "C"
```
|
/content/code_sandbox/core/src/ZXingC.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,944
|
```objective-c
/*
*/
#pragma once
#include "CharacterSet.h"
#include <string>
namespace ZXing {
class TextEncoder
{
static void GetBytes(const std::string& str, CharacterSet charset, std::string& bytes);
static void GetBytes(const std::wstring& str, CharacterSet charset, std::string& bytes);
public:
static std::string FromUnicode(const std::string& str, CharacterSet charset) {
std::string r;
GetBytes(str, charset, r);
return r;
}
static std::string FromUnicode(const std::wstring& str, CharacterSet charset) {
std::string r;
GetBytes(str, charset, r);
return r;
}
};
} // ZXing
```
|
/content/code_sandbox/core/src/TextEncoder.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 152
|
```objective-c
/*
*/
#pragma once
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <vector>
namespace ZXing {
class GenericGF;
/**
* <p>Represents a polynomial whose coefficients are elements of a GF.
* Instances of this class are immutable.</p>
*
* <p>Much credit is due to William Rucklidge since portions of this code are an indirect
* port of his C++ Reed-Solomon implementation.</p>
*
* @author Sean Owen
*/
class GenericGFPoly
{
struct Coefficients : public std::vector<int>
{
void reserve(size_t s)
{
if (capacity() < s)
std::vector<int>::reserve(std::max(size_t(32), s));
}
void resize(size_t s)
{
reserve(s);
std::vector<int>::resize(s);
}
void resize(size_t s, int i)
{
reserve(s);
std::vector<int>::resize(s, i);
}
};
public:
// Build a invalid object, so that this can be used in container or return by reference,
// any access to invalid object is undefined behavior.
GenericGFPoly() = default;
/**
* @param field the {@link GenericGF} instance representing the field to use
* to perform computations
* @param coefficients coefficients as ints representing elements of GF(size), arranged
* from most significant (highest-power term) coefficient to least significant
*/
GenericGFPoly(const GenericGF& field, std::vector<int>&& coefficients) : _field(&field)
{
assert(!coefficients.empty());
_coefficients.swap(coefficients); // _coefficients = coefficients
normalize();
}
GenericGFPoly(const GenericGF& field, const std::vector<int>& coefficients) : GenericGFPoly(field, std::vector<int>(coefficients)) {}
GenericGFPoly& operator=(GenericGFPoly&& other) noexcept = default;
GenericGFPoly(GenericGFPoly&& other) noexcept = default;
GenericGFPoly& operator=(const GenericGFPoly& other) {
assert(_field == other._field);
_coefficients.reserve(other._coefficients.size());
_coefficients = other._coefficients;
return *this;
}
GenericGFPoly(const GenericGFPoly& other) {
_field = other._field;
*this = other;
}
GenericGFPoly& setField(const GenericGF& field)
{
_field = &field;
return *this;
}
const GenericGF& field() const noexcept { return *_field; }
const auto& coefficients() const noexcept { return _coefficients; }
/**
* @return degree of this polynomial
*/
int degree() const {
return Size(_coefficients) - 1;
}
/**
* @return true iff this polynomial is the monomial "0"
*/
bool isZero() const {
return _coefficients[0] == 0;
}
int leadingCoefficient() const noexcept {
return _coefficients.front();
}
int constant() const noexcept {
return _coefficients.back();
}
/**
* @brief set to the monomial representing coefficient * x^degree
*/
GenericGFPoly& setMonomial(int coefficient, int degree = 0)
{
assert(degree >= 0 && (coefficient != 0 || degree == 0));
_coefficients.resize(degree + 1);
std::fill(_coefficients.begin(), _coefficients.end(), 0);
_coefficients.front() = coefficient;
return *this;
}
/**
* @return evaluation of this polynomial at a given point
*/
int evaluateAt(int a) const;
GenericGFPoly& addOrSubtract(GenericGFPoly& other);
GenericGFPoly& multiply(const GenericGFPoly& other);
GenericGFPoly& multiplyByMonomial(int coefficient, int degree = 0);
GenericGFPoly& divide(const GenericGFPoly& other, GenericGFPoly& quotient);
friend void swap(GenericGFPoly& a, GenericGFPoly& b)
{
std::swap(a._field, b._field);
std::swap(a._coefficients, b._coefficients);
}
private:
void normalize();
const GenericGF* _field = nullptr;
Coefficients _coefficients, _cache; // _cache is used for malloc caching
};
} // ZXing
```
|
/content/code_sandbox/core/src/GenericGFPoly.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 990
|
```c++
/*
*/
#include "GenericGF.h"
namespace ZXing {
const GenericGF &
GenericGF::AztecData12()
{
static GenericGF inst(0x1069, 4096, 1); // x^12 + x^6 + x^5 + x^3 + 1
return inst;
}
const GenericGF &
GenericGF::AztecData10()
{
static GenericGF inst(0x409, 1024, 1); // x^10 + x^3 + 1
return inst;
}
const GenericGF &
GenericGF::AztecData6()
{
static GenericGF inst(0x43, 64, 1); // x^6 + x + 1
return inst;
}
const GenericGF &
GenericGF::AztecParam()
{
static GenericGF inst(0x13, 16, 1); // x^4 + x + 1
return inst;
}
const GenericGF &
GenericGF::QRCodeField256()
{
static GenericGF inst(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1
return inst;
}
const GenericGF &
GenericGF::DataMatrixField256()
{
static GenericGF inst(0x012D, 256, 1); // x^8 + x^5 + x^3 + x^2 + 1
return inst;
}
const GenericGF &
GenericGF::AztecData8()
{
static const GenericGF inst(0x012D, 256, 1); // = DATA_MATRIX_FIELD_256;
return inst;
}
const GenericGF &
GenericGF::MaxiCodeField64()
{
static const GenericGF inst(0x43, 64, 1); // = AZTEC_DATA_6;
return inst;
}
/**
* Create a representation of GF(size) using the given primitive polynomial.
*
* @param primitive irreducible polynomial whose coefficients are represented by
* the bits of an int, where the least-significant bit represents the constant
* coefficient
* @param size the size of the field
* @param b the factor b in the generator polynomial can be 0- or 1-based
* (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))).
* In most cases it should be 1, but for QR code it is 0.
*/
GenericGF::GenericGF(int primitive, int size, int b) :
_size(size),
_generatorBase(b)
{
#ifdef ZX_REED_SOLOMON_USE_MORE_MEMORY_FOR_SPEED
_expTable.resize(size * 2, 0);
#else
_expTable.resize(size, 0);
#endif
_logTable.resize(size, 0);
int x = 1;
for (int i = 0; i < size; ++i) {
_expTable[i] = x;
x *= 2; // we're assuming the generator alpha is 2
if (x >= size) {
x ^= primitive;
x &= size - 1;
}
}
#ifdef ZX_REED_SOLOMON_USE_MORE_MEMORY_FOR_SPEED
for (int i = size - 1; i < size * 2; ++i)
_expTable[i] = _expTable[i - (size - 1)];
#endif
for (int i = 0; i < size - 1; ++i)
_logTable[_expTable[i]] = i;
// logTable[0] == 0 but this should never be used
}
} // namespace ZXing
```
|
/content/code_sandbox/core/src/GenericGF.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 774
|
```objective-c
/*
*/
#pragma once
#include "Point.h"
#include "Quadrilateral.h"
namespace ZXing {
/**
* <p>This class implements a perspective transform in two dimensions. Given four source and four
* destination points, it will compute the transformation implied between them. The code is based
* directly upon section 3.4.2 of George Wolberg's "Digital Image Warping"; see pages 54-56.</p>
*/
class PerspectiveTransform
{
using value_t = PointF::value_t;
value_t a11, a12, a13, a21, a22, a23, a31, a32, a33 = NAN;
PerspectiveTransform(value_t a11, value_t a21, value_t a31, value_t a12, value_t a22, value_t a32, value_t a13,
value_t a23, value_t a33)
: a11(a11), a12(a12), a13(a13), a21(a21), a22(a22), a23(a23), a31(a31), a32(a32), a33(a33)
{}
PerspectiveTransform inverse() const;
PerspectiveTransform times(const PerspectiveTransform& other) const;
static PerspectiveTransform UnitSquareTo(const QuadrilateralF& q);
public:
PerspectiveTransform() = default;
PerspectiveTransform(const QuadrilateralF& src, const QuadrilateralF& dst);
/// Project from the destination space (grid of modules) into the image space (bit matrix)
PointF operator()(PointF p) const;
bool isValid() const { return !std::isnan(a33); }
};
} // ZXing
```
|
/content/code_sandbox/core/src/PerspectiveTransform.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 342
|
```c++
/*
*/
#ifdef ZXING_EXPERIMENTAL_API
#include "WriteBarcode.h"
#include "BitMatrix.h"
#if !defined(ZXING_READERS) && !defined(ZXING_WRITERS)
#include "Version.h"
#endif
#include <sstream>
#ifdef ZXING_USE_ZINT
#include <zint.h>
#else
struct zint_symbol {};
#endif // ZXING_USE_ZINT
namespace ZXing {
struct CreatorOptions::Data
{
BarcodeFormat format;
bool readerInit = false;
bool forceSquareDataMatrix = false;
std::string ecLevel;
// symbol size (qrcode, datamatrix, etc), map from I, 'WxH'
// structured_append (idx, cnt, ID)
mutable unique_zint_symbol zint;
#if __cplusplus <= 201703L || defined(__APPLE__)
Data(BarcodeFormat f) : format(f) {}
#endif
};
#define ZX_PROPERTY(TYPE, NAME) \
TYPE CreatorOptions::NAME() const noexcept { return d->NAME; } \
CreatorOptions& CreatorOptions::NAME(TYPE v)& { return d->NAME = std::move(v), *this; } \
CreatorOptions&& CreatorOptions::NAME(TYPE v)&& { return d->NAME = std::move(v), std::move(*this); }
ZX_PROPERTY(BarcodeFormat, format)
ZX_PROPERTY(bool, readerInit)
ZX_PROPERTY(bool, forceSquareDataMatrix)
ZX_PROPERTY(std::string, ecLevel)
#undef ZX_PROPERTY
CreatorOptions::CreatorOptions(BarcodeFormat format) : d(std::make_unique<Data>(format)) {}
CreatorOptions::~CreatorOptions() = default;
CreatorOptions::CreatorOptions(CreatorOptions&&) = default;
CreatorOptions& CreatorOptions::operator=(CreatorOptions&&) = default;
struct WriterOptions::Data
{
int scale = 0;
int sizeHint = 0;
int rotate = 0;
bool withHRT = false;
bool withQuietZones = true;
};
#define ZX_PROPERTY(TYPE, NAME) \
TYPE WriterOptions::NAME() const noexcept { return d->NAME; } \
WriterOptions& WriterOptions::NAME(TYPE v)& { return d->NAME = std::move(v), *this; } \
WriterOptions&& WriterOptions::NAME(TYPE v)&& { return d->NAME = std::move(v), std::move(*this); }
ZX_PROPERTY(int, scale)
ZX_PROPERTY(int, sizeHint)
ZX_PROPERTY(int, rotate)
ZX_PROPERTY(bool, withHRT)
ZX_PROPERTY(bool, withQuietZones)
#undef ZX_PROPERTY
WriterOptions::WriterOptions() : d(std::make_unique<Data>()) {}
WriterOptions::~WriterOptions() = default;
WriterOptions::WriterOptions(WriterOptions&&) = default;
WriterOptions& WriterOptions::operator=(WriterOptions&&) = default;
static bool IsLinearCode(BarcodeFormat format)
{
return BarcodeFormats(BarcodeFormat::LinearCodes).testFlag(format);
}
static std::string ToSVG(ImageView iv)
{
if (!iv.data())
return {};
// see path_to_url#60638350
std::ostringstream res;
res << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
<< "<svg xmlns=\"path_to_url" version=\"1.1\" viewBox=\"0 0 " << iv.width() << " " << iv.height()
<< "\" stroke=\"none\">\n"
<< "<path d=\"";
for (int y = 0; y < iv.height(); ++y)
for (int x = 0; x < iv.width(); ++x)
if (*iv.data(x, y) == 0)
res << "M" << x << "," << y << "h1v1h-1z";
res << "\"/>\n</svg>";
return res.str();
}
static Image ToImage(BitMatrix bits, bool isLinearCode, const WriterOptions& opts)
{
bits.flipAll();
auto symbol = Inflate(std::move(bits), opts.sizeHint(),
isLinearCode ? std::clamp(opts.sizeHint() / 2, 50, 300) : opts.sizeHint(),
opts.withQuietZones() ? 10 : 0);
auto bitmap = ToMatrix<uint8_t>(symbol);
auto iv = Image(symbol.width(), symbol.height());
std::memcpy(const_cast<uint8_t*>(iv.data()), bitmap.data(), iv.width() * iv.height());
return iv;
}
} // namespace ZXing
#ifdef ZXING_WRITERS
#ifdef ZXING_USE_ZINT
#include "ECI.h"
#include "ReadBarcode.h"
#include <charconv>
#include <zint.h>
namespace ZXing {
struct BarcodeFormatZXing2Zint
{
BarcodeFormat zxing;
int zint;
};
static constexpr BarcodeFormatZXing2Zint barcodeFormatZXing2Zint[] = {
{BarcodeFormat::Aztec, BARCODE_AZTEC},
{BarcodeFormat::Codabar, BARCODE_CODABAR},
{BarcodeFormat::Code39, BARCODE_CODE39},
{BarcodeFormat::Code93, BARCODE_CODE93},
{BarcodeFormat::Code128, BARCODE_CODE128},
{BarcodeFormat::DataBar, BARCODE_DBAR_OMN},
{BarcodeFormat::DataBarExpanded, BARCODE_DBAR_EXP},
{BarcodeFormat::DataMatrix, BARCODE_DATAMATRIX},
{BarcodeFormat::DXFilmEdge, -1},
{BarcodeFormat::EAN8, BARCODE_EANX},
{BarcodeFormat::EAN13, BARCODE_EANX},
{BarcodeFormat::ITF, BARCODE_C25INTER},
{BarcodeFormat::MaxiCode, BARCODE_MAXICODE},
{BarcodeFormat::MicroQRCode, BARCODE_MICROQR},
{BarcodeFormat::PDF417, BARCODE_PDF417},
{BarcodeFormat::QRCode, BARCODE_QRCODE},
{BarcodeFormat::RMQRCode, BARCODE_RMQR},
{BarcodeFormat::UPCA, BARCODE_UPCA},
{BarcodeFormat::UPCE, BARCODE_UPCE},
};
struct String2Int
{
const char* str;
int val;
};
static int ParseECLevel(int symbology, std::string_view s)
{
constexpr std::string_view EC_LABELS_QR[4] = {"L", "M", "Q", "H"};
int res = 0;
if (Contains({BARCODE_QRCODE, BARCODE_MICROQR, BARCODE_RMQR}, symbology))
if ((res = IndexOf(EC_LABELS_QR, s) != -1))
return res + 1;
if (std::from_chars(s.data(), s.data() + s.size() - (s.back() == '%'), res).ec != std::errc{})
throw std::invalid_argument("Invalid ecLevel: '" + std::string(s) + "'");
auto findClosestECLevel = [](const std::vector<int>& list, int val) {
int mIdx = -2, mAbs = 100;
for (int i = 0; i < Size(list); ++i)
if (int abs = std::abs(val - list[i]); abs < mAbs) {
mIdx = i;
mAbs = abs;
}
return mIdx + 1;
};
if (s.back()=='%'){
switch (symbology) {
case BARCODE_QRCODE:
case BARCODE_MICROQR:
case BARCODE_RMQR:
return findClosestECLevel({20, 37, 55, 65}, res);
case BARCODE_AZTEC:
return findClosestECLevel({10, 23, 26, 50}, res);
case BARCODE_PDF417:
// TODO: do something sensible with PDF417?
default:
return -1;
}
}
return res;
};
zint_symbol* CreatorOptions::zint() const
{
auto& zint = d->zint;
if (!zint) {
#ifdef PRINT_DEBUG
printf("zint version: %d, sizeof(zint_symbol): %ld\n", ZBarcode_Version(), sizeof(zint_symbol));
#endif
zint.reset(ZBarcode_Create());
auto i = FindIf(barcodeFormatZXing2Zint, [zxing = format()](auto& v) { return v.zxing == zxing; });
if (i == std::end(barcodeFormatZXing2Zint))
throw std::invalid_argument("unsupported barcode format: " + ToString(format()));
zint->symbology = i->zint;
zint->scale = 0.5f;
if (!ecLevel().empty())
zint->option_1 = ParseECLevel(zint->symbology, ecLevel());
}
return zint.get();
}
#define CHECK(ZINT_CALL) \
if (int err = (ZINT_CALL); err) \
throw std::invalid_argument(zint->errtxt);
Barcode CreateBarcode(const void* data, int size, int mode, const CreatorOptions& opts)
{
auto zint = opts.zint();
zint->input_mode = mode;
zint->output_options |= OUT_BUFFER_INTERMEDIATE | BARCODE_QUIET_ZONES;
if (mode == DATA_MODE && ZBarcode_Cap(zint->symbology, ZINT_CAP_ECI))
zint->eci = static_cast<int>(ECI::Binary);
CHECK(ZBarcode_Encode_and_Buffer(zint, (uint8_t*)data, size, 0));
#ifdef PRINT_DEBUG
printf("create symbol with size: %dx%d\n", zint->width, zint->rows);
#endif
#ifdef ZXING_READERS
auto buffer = std::vector<uint8_t>(zint->bitmap_width * zint->bitmap_height);
std::transform(zint->bitmap, zint->bitmap + zint->bitmap_width * zint->bitmap_height, buffer.data(),
[](unsigned char v) { return (v == '0') * 0xff; });
auto res = ReadBarcode({buffer.data(), zint->bitmap_width, zint->bitmap_height, ImageFormat::Lum},
ReaderOptions().setFormats(opts.format()).setIsPure(true).setBinarizer(Binarizer::BoolCast));
#else
//TODO: replace by proper construction from encoded data from within zint
auto res = Barcode(std::string((const char*)data, size), 0, 0, 0, opts.format(), {});
#endif
auto bits = BitMatrix(zint->bitmap_width, zint->bitmap_height);
std::transform(zint->bitmap, zint->bitmap + zint->bitmap_width * zint->bitmap_height, bits.row(0).begin(),
[](unsigned char v) { return (v == '1') * BitMatrix::SET_V; });
res.symbol(std::move(bits));
res.zint(std::move(opts.d->zint));
return res;
}
Barcode CreateBarcodeFromText(std::string_view contents, const CreatorOptions& opts)
{
return CreateBarcode(contents.data(), contents.size(), UNICODE_MODE, opts);
}
#if __cplusplus > 201703L
Barcode CreateBarcodeFromText(std::u8string_view contents, const CreatorOptions& opts)
{
return CreateBarcode(contents.data(), contents.size(), UNICODE_MODE, opts);
}
#endif
Barcode CreateBarcodeFromBytes(const void* data, int size, const CreatorOptions& opts)
{
return CreateBarcode(data, size, DATA_MODE, opts);
}
// Writer ========================================================================
struct SetCommonWriterOptions
{
zint_symbol* zint;
SetCommonWriterOptions(zint_symbol* zint, const WriterOptions& opts) : zint(zint)
{
zint->show_hrt = opts.withHRT();
zint->output_options &= ~OUT_BUFFER_INTERMEDIATE;
zint->output_options |= opts.withQuietZones() ? BARCODE_QUIET_ZONES : BARCODE_NO_QUIET_ZONES;
if (opts.scale())
zint->scale = opts.scale() / 2.f;
else if (opts.sizeHint()) {
int size = std::max(zint->width, zint->rows);
zint->scale = std::max(1, int(float(opts.sizeHint()) / size)) / 2.f;
}
}
// reset the defaults such that consecutive write calls don't influence each other
~SetCommonWriterOptions() { zint->scale = 0.5f; }
};
} // ZXing
#else // ZXING_USE_ZINT
#include "MultiFormatWriter.h"
#include "ReadBarcode.h"
namespace ZXing {
zint_symbol* CreatorOptions::zint() const { return nullptr; }
static Barcode CreateBarcode(BitMatrix&& bits, const CreatorOptions& opts)
{
auto img = ToMatrix<uint8_t>(bits);
auto res = ReadBarcode({img.data(), img.width(), img.height(), ImageFormat::Lum},
ReaderOptions().setFormats(opts.format()).setIsPure(true).setBinarizer(Binarizer::BoolCast));
res.symbol(std::move(bits));
return res;
}
Barcode CreateBarcodeFromText(std::string_view contents, const CreatorOptions& opts)
{
auto writer = MultiFormatWriter(opts.format()).setMargin(0);
if (!opts.ecLevel().empty())
writer.setEccLevel(std::stoi(opts.ecLevel()));
return CreateBarcode(writer.encode(std::string(contents), 0, IsLinearCode(opts.format()) ? 50 : 0), opts);
}
#if __cplusplus > 201703L
Barcode CreateBarcodeFromText(std::u8string_view contents, const CreatorOptions& opts)
{
return CreateBarcodeFromText({reinterpret_cast<const char*>(contents.data()), contents.size()}, opts);
}
#endif
Barcode CreateBarcodeFromBytes(const void* data, int size, const CreatorOptions& opts)
{
std::wstring bytes;
for (uint8_t c : std::basic_string_view<uint8_t>((uint8_t*)data, size))
bytes.push_back(c);
auto writer = MultiFormatWriter(opts.format()).setMargin(0);
if (!opts.ecLevel().empty())
writer.setEccLevel(std::stoi(opts.ecLevel()));
writer.setEncoding(CharacterSet::BINARY);
return CreateBarcode(writer.encode(bytes, 0, IsLinearCode(opts.format()) ? 50 : 0), opts);
}
} // namespace ZXing
#endif // ZXING_USE_ZINT
#else // ZXING_WRITERS
namespace ZXing {
zint_symbol* CreatorOptions::zint() const { return nullptr; }
Barcode CreateBarcodeFromText(std::string_view, const CreatorOptions&)
{
throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
}
#if __cplusplus > 201703L
Barcode CreateBarcodeFromText(std::u8string_view, const CreatorOptions&)
{
throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
}
#endif
Barcode CreateBarcodeFromBytes(const void*, int, const CreatorOptions&)
{
throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
}
} // namespace ZXing
#endif // ZXING_WRITERS
namespace ZXing {
std::string WriteBarcodeToSVG(const Barcode& barcode, [[maybe_unused]] const WriterOptions& opts)
{
auto zint = barcode.zint();
if (!zint)
return ToSVG(barcode.symbol());
#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
auto resetOnExit = SetCommonWriterOptions(zint, opts);
zint->output_options |= BARCODE_MEMORY_FILE;// | EMBED_VECTOR_FONT;
strcpy(zint->outfile, "null.svg");
CHECK(ZBarcode_Print(zint, opts.rotate()));
return std::string(reinterpret_cast<const char*>(zint->memfile), zint->memfile_size);
#else
return {}; // unreachable code
#endif
}
Image WriteBarcodeToImage(const Barcode& barcode, [[maybe_unused]] const WriterOptions& opts)
{
auto zint = barcode.zint();
if (!zint)
return ToImage(barcode._symbol->copy(), IsLinearCode(barcode.format()), opts);
#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
auto resetOnExit = SetCommonWriterOptions(zint, opts);
CHECK(ZBarcode_Buffer(zint, opts.rotate()));
#ifdef PRINT_DEBUG
printf("write symbol with size: %dx%d\n", zint->bitmap_width, zint->bitmap_height);
#endif
auto iv = Image(zint->bitmap_width, zint->bitmap_height);
auto* src = zint->bitmap;
auto* dst = const_cast<uint8_t*>(iv.data());
for(int y = 0; y < iv.height(); ++y)
for(int x = 0, w = iv.width(); x < w; ++x, src += 3)
*dst++ = RGBToLum(src[0], src[1], src[2]);
return iv;
#else
return {}; // unreachable code
#endif
}
std::string WriteBarcodeToUtf8(const Barcode& barcode, [[maybe_unused]] const WriterOptions& options)
{
auto iv = barcode.symbol();
if (!iv.data())
return {};
constexpr auto map = std::array{" ", "", "", ""};
std::ostringstream res;
bool inverted = false; // TODO: take from WriterOptions
for (int y = 0; y < iv.height(); y += 2) {
for (int x = 0; x < iv.width(); ++x) {
int tp = bool(*iv.data(x, y)) ^ inverted;
int bt = (iv.height() == 1 && tp) || (y + 1 < iv.height() && (bool(*iv.data(x, y + 1)) ^ inverted));
res << map[tp | (bt << 1)];
}
res << '\n';
}
return res.str();
}
} // namespace ZXing
#endif // ZXING_EXPERIMENTAL_API
```
|
/content/code_sandbox/core/src/WriteBarcode.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 3,806
|
```objective-c
/*
*/
#pragma once
#include "ZXAlgorithms.h"
#include <iterator>
namespace ZXing {
template <typename Iterator>
struct StrideIter
{
Iterator pos;
int stride;
using iterator_category = std::random_access_iterator_tag;
using difference_type = typename std::iterator_traits<Iterator>::difference_type;
using value_type = typename std::iterator_traits<Iterator>::value_type;
using pointer = Iterator;
using reference = typename std::iterator_traits<Iterator>::reference;
auto operator*() const { return *pos; }
auto operator[](int i) const { return *(pos + i * stride); }
StrideIter<Iterator>& operator++() { return pos += stride, *this; }
StrideIter<Iterator> operator++(int) { auto temp = *this; ++*this; return temp; }
bool operator!=(const StrideIter<Iterator>& rhs) const { return pos != rhs.pos; }
StrideIter<Iterator> operator+(int i) const { return {pos + i * stride, stride}; }
StrideIter<Iterator> operator-(int i) const { return {pos - i * stride, stride}; }
int operator-(const StrideIter<Iterator>& rhs) const { return narrow_cast<int>((pos - rhs.pos) / stride); }
};
template <typename Iterator>
StrideIter(const Iterator&, int) -> StrideIter<Iterator>;
template <typename Iterator>
struct Range
{
Iterator _begin, _end;
Range(Iterator b, Iterator e) : _begin(b), _end(e) {}
template <typename C>
Range(const C& c) : _begin(std::begin(c)), _end(std::end(c)) {}
Iterator begin() const noexcept { return _begin; }
Iterator end() const noexcept { return _end; }
explicit operator bool() const { return begin() < end(); }
int size() const { return narrow_cast<int>(end() - begin()); }
};
template <typename C>
Range(const C&) -> Range<typename C::const_iterator>;
} // namespace ZXing
```
|
/content/code_sandbox/core/src/Range.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 430
|
```objective-c
/*
*/
#pragma once
#include "BitMatrix.h"
#include "Quadrilateral.h"
#include <utility>
namespace ZXing {
/**
* Encapsulates the result of detecting a barcode in an image. This includes the raw
* matrix of black/white pixels corresponding to the barcode and the position of the code
* in the input image.
*/
class DetectorResult
{
BitMatrix _bits;
QuadrilateralI _position;
DetectorResult(const DetectorResult&) = delete;
DetectorResult& operator=(const DetectorResult&) = delete;
public:
DetectorResult() = default;
DetectorResult(DetectorResult&&) noexcept = default;
DetectorResult& operator=(DetectorResult&&) noexcept = default;
DetectorResult(BitMatrix&& bits, QuadrilateralI&& position) : _bits(std::move(bits)), _position(std::move(position)) {}
const BitMatrix& bits() const & { return _bits; }
BitMatrix&& bits() && { return std::move(_bits); }
const QuadrilateralI& position() const & { return _position; }
QuadrilateralI&& position() && { return std::move(_position); }
bool isValid() const { return !_bits.empty(); }
};
} // ZXing
```
|
/content/code_sandbox/core/src/DetectorResult.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 266
|
```objective-c
/*
*/
#pragma once
#include "ReaderOptions.h"
#include "ImageView.h"
#include "Barcode.h"
namespace ZXing {
/**
* Read barcode from an ImageView
*
* @param image view of the image data including layout and format
* @param options optional ReaderOptions to parameterize / speed up detection
* @return #Barcode structure
*/
Barcode ReadBarcode(const ImageView& image, const ReaderOptions& options = {});
/**
* Read barcodes from an ImageView
*
* @param image view of the image data including layout and format
* @param options optional ReaderOptions to parameterize / speed up detection
* @return #Barcodes list of barcodes found, may be empty
*/
Barcodes ReadBarcodes(const ImageView& image, const ReaderOptions& options = {});
} // ZXing
```
|
/content/code_sandbox/core/src/ReadBarcode.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 170
|
```objective-c
/*
*/
#pragma once
#include "Point.h"
#include "ZXAlgorithms.h"
#include <stdexcept>
#include <algorithm>
#include <cassert>
#include <vector>
namespace ZXing {
template <class T>
class Matrix
{
public:
using value_t = T;
private:
int _width = 0;
int _height = 0;
std::vector<value_t> _data;
// Nothing wrong to support it, just to make it explicit, instead of by mistake.
// Use copy() below.
Matrix(const Matrix &) = default;
Matrix& operator=(const Matrix &) = delete;
public:
Matrix() = default;
#if defined(__llvm__) || (defined(__GNUC__) && (__GNUC__ > 7))
__attribute__((no_sanitize("signed-integer-overflow")))
#endif
Matrix(int width, int height, value_t val = {}) : _width(width), _height(height), _data(_width * _height, val) {
if (width != 0 && Size(_data) / width != height)
throw std::invalid_argument("Invalid size: width * height is too big");
}
Matrix(Matrix&&) noexcept = default;
Matrix& operator=(Matrix&&) noexcept = default;
Matrix copy() const {
return *this;
}
int height() const {
return _height;
}
int width() const {
return _width;
}
int size() const {
return Size(_data);
}
value_t& operator()(int x, int y)
{
assert(x >= 0 && x < _width && y >= 0 && y < _height);
return _data[y * _width + x];
}
const T& operator()(int x, int y) const
{
assert(x >= 0 && x < _width && y >= 0 && y < _height);
return _data[y * _width + x];
}
const value_t& get(int x, int y) const {
return operator()(x, y);
}
value_t& set(int x, int y, value_t value) {
return operator()(x, y) = value;
}
const value_t& get(PointI p) const {
return operator()(p.x, p.y);
}
value_t& set(PointI p, value_t value) {
return operator()(p.x, p.y) = value;
}
const value_t* data() const {
return _data.data();
}
const value_t* begin() const {
return _data.data();
}
const value_t* end() const {
return _data.data() + _width * _height;
}
value_t* begin() {
return _data.data();
}
value_t* end() {
return _data.data() + _width * _height;
}
void clear(value_t value = {}) {
std::fill(_data.begin(), _data.end(), value);
}
};
} // ZXing
```
|
/content/code_sandbox/core/src/Matrix.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 622
|
```c++
/*
*/
#include "ConcentricFinder.h"
#include "LogMatrix.h"
#include "RegressionLine.h"
#include "ZXAlgorithms.h"
namespace ZXing {
std::optional<PointF> AverageEdgePixels(BitMatrixCursorI cur, int range, int numOfEdges)
{
PointF sum = {};
for (int i = 0; i < numOfEdges; ++i) {
if (!cur.isIn())
return {};
cur.stepToEdge(1, range);
sum += centered(cur.p) + centered(cur.p + cur.back());
log(cur.p + cur.back(), 2);
}
return sum / (2 * numOfEdges);
}
std::optional<PointF> CenterOfDoubleCross(const BitMatrix& image, PointI center, int range, int numOfEdges)
{
PointF sum = {};
for (auto d : {PointI{0, 1}, {1, 0}, {1, 1}, {1, -1}}) {
auto avr1 = AverageEdgePixels({image, center, d}, range, numOfEdges);
auto avr2 = AverageEdgePixels({image, center, -d}, range, numOfEdges);
if (!avr1 || !avr2)
return {};
sum += *avr1 + *avr2;
}
return sum / 8;
}
std::optional<PointF> CenterOfRing(const BitMatrix& image, PointI center, int range, int nth, bool requireCircle)
{
#if 0
if (requireCircle) {
// alternative implementation with the aim of discarding closed loops that are not all circle like (M > 5*m)
auto points = CollectRingPoints(image, center, range, std::abs(nth), nth < 0);
if (points.empty())
return {};
auto res = Reduce(points, PointF{}, std::plus{}) / Size(points);
double m = range, M = 0;
for (auto p : points)
UpdateMinMax(m, M, maxAbsComponent(p - res));
if (M > 5 * m)
return {};
return res;
}
#endif
// range is the approximate width/height of the nth ring, if nth>1 then it would be plausible to limit the search radius
// to approximately range / 2 * sqrt(2) == range * 0.75 but it turned out to be too limiting with realworld/noisy data.
int radius = range;
bool inner = nth < 0;
nth = std::abs(nth);
log(center, 3);
BitMatrixCursorI cur(image, center, {0, 1});
if (!cur.stepToEdge(nth, radius, inner))
return {};
cur.turnRight(); // move clock wise and keep edge on the right/left depending on backup
const auto edgeDir = inner ? Direction::LEFT : Direction::RIGHT;
uint32_t neighbourMask = 0;
auto start = cur.p;
PointF sum = {};
int n = 0;
do {
log(cur.p, 4);
sum += centered(cur.p);
++n;
// find out if we come full circle around the center. 8 bits have to be set in the end.
neighbourMask |= (1 << (4 + dot(bresenhamDirection(cur.p - center), PointI(1, 3))));
if (!cur.stepAlongEdge(edgeDir))
return {};
// use L-inf norm, simply because it is a lot faster than L2-norm and sufficiently accurate
if (maxAbsComponent(cur.p - center) > radius || center == cur.p || n > 4 * 2 * range)
return {};
} while (cur.p != start);
if (requireCircle && neighbourMask != 0b111101111)
return {};
return sum / n;
}
std::optional<PointF> CenterOfRings(const BitMatrix& image, PointF center, int range, int numOfRings)
{
int n = 1;
PointF sum = center;
for (int i = 2; i < numOfRings + 1; ++i) {
auto c = CenterOfRing(image, PointI(center), range, i);
if (!c) {
if (n == 1)
return {};
else
return sum / n;
} else if (distance(*c, center) > range / numOfRings / 2) {
return {};
}
sum += *c;
n++;
}
return sum / n;
}
static std::vector<PointF> CollectRingPoints(const BitMatrix& image, PointF center, int range, int edgeIndex, bool backup)
{
PointI centerI(center);
int radius = range;
BitMatrixCursorI cur(image, centerI, {0, 1});
if (!cur.stepToEdge(edgeIndex, radius, backup))
return {};
cur.turnRight(); // move clock wise and keep edge on the right/left depending on backup
const auto edgeDir = backup ? Direction::LEFT : Direction::RIGHT;
uint32_t neighbourMask = 0;
auto start = cur.p;
std::vector<PointF> points;
points.reserve(4 * range);
do {
log(cur.p, 4);
points.push_back(centered(cur.p));
// find out if we come full circle around the center. 8 bits have to be set in the end.
neighbourMask |= (1 << (4 + dot(bresenhamDirection(cur.p - centerI), PointI(1, 3))));
if (!cur.stepAlongEdge(edgeDir))
return {};
// use L-inf norm, simply because it is a lot faster than L2-norm and sufficiently accurate
if (maxAbsComponent(cur.p - centerI) > radius || centerI == cur.p || Size(points) > 4 * 2 * range)
return {};
} while (cur.p != start);
if (neighbourMask != 0b111101111)
return {};
return points;
}
static std::optional<QuadrilateralF> FitQadrilateralToPoints(PointF center, std::vector<PointF>& points)
{
auto dist2Center = [c = center](auto a, auto b) { return distance(a, c) < distance(b, c); };
// rotate points such that the first one is the furthest away from the center (hence, a corner)
std::rotate(points.begin(), std::max_element(points.begin(), points.end(), dist2Center), points.end());
std::array<const PointF*, 4> corners;
corners[0] = &points[0];
// find the oposite corner by looking for the farthest point near the oposite point
corners[2] = std::max_element(&points[Size(points) * 3 / 8], &points[Size(points) * 5 / 8], dist2Center);
// find the two in between corners by looking for the points farthest from the long diagonal
auto dist2Diagonal = [l = RegressionLine(*corners[0], *corners[2])](auto a, auto b) { return l.distance(a) < l.distance(b); };
corners[1] = std::max_element(&points[Size(points) * 1 / 8], &points[Size(points) * 3 / 8], dist2Diagonal);
corners[3] = std::max_element(&points[Size(points) * 5 / 8], &points[Size(points) * 7 / 8], dist2Diagonal);
std::array lines{RegressionLine{corners[0] + 1, corners[1]}, RegressionLine{corners[1] + 1, corners[2]},
RegressionLine{corners[2] + 1, corners[3]}, RegressionLine{corners[3] + 1, &points.back() + 1}};
if (std::any_of(lines.begin(), lines.end(), [](auto line) { return !line.isValid(); }))
return {};
std::array<const PointF*, 4> beg = {corners[0] + 1, corners[1] + 1, corners[2] + 1, corners[3] + 1};
std::array<const PointF*, 4> end = {corners[1], corners[2], corners[3], &points.back() + 1};
// check if all points belonging to each line segment are sufficiently close to that line
for (int i = 0; i < 4; ++i)
for (const PointF* p = beg[i]; p != end[i]; ++p) {
auto len = std::distance(beg[i], end[i]);
if (len > 3 && lines[i].distance(*p) > std::max(1., std::min(8., len / 8.))) {
#ifdef PRINT_DEBUG
printf("%d: %.2f > %.2f @ %.fx%.f\n", i, lines[i].distance(*p), std::distance(beg[i], end[i]) / 1., p->x, p->y);
#endif
return {};
}
}
QuadrilateralF res;
for (int i = 0; i < 4; ++i)
res[i] = intersect(lines[i], lines[(i + 1) % 4]);
return res;
}
static bool QuadrilateralIsPlausibleSquare(const QuadrilateralF q, int lineIndex)
{
double m, M;
m = M = distance(q[0], q[3]);
for (int i = 1; i < 4; ++i)
UpdateMinMax(m, M, distance(q[i - 1], q[i]));
return m >= lineIndex * 2 && m > M / 3;
}
static std::optional<QuadrilateralF> FitSquareToPoints(const BitMatrix& image, PointF center, int range, int lineIndex, bool backup)
{
auto points = CollectRingPoints(image, center, range, lineIndex, backup);
if (points.empty())
return {};
auto res = FitQadrilateralToPoints(center, points);
if (!res || !QuadrilateralIsPlausibleSquare(*res, lineIndex - backup))
return {};
return res;
}
std::optional<QuadrilateralF> FindConcentricPatternCorners(const BitMatrix& image, PointF center, int range, int lineIndex)
{
auto innerCorners = FitSquareToPoints(image, center, range, lineIndex, false);
if (!innerCorners)
return {};
auto outerCorners = FitSquareToPoints(image, center, range, lineIndex + 1, true);
if (!outerCorners)
return {};
auto res = Blend(*innerCorners, *outerCorners);
for (auto p : *innerCorners)
log(p, 3);
for (auto p : *outerCorners)
log(p, 3);
for (auto p : res)
log(p, 3);
return res;
}
std::optional<PointF> FinetuneConcentricPatternCenter(const BitMatrix& image, PointF center, int range, int finderPatternSize)
{
// make sure we have at least one path of white around the center
if (auto res1 = CenterOfRing(image, PointI(center), range, 1); res1 && image.get(*res1)) {
// and then either at least one more ring around that
if (auto res2 = CenterOfRings(image, *res1, range, finderPatternSize / 2); res2 && image.get(*res2))
return res2;
// or the center can be approximated by a square
if (FitSquareToPoints(image, *res1, range, 1, false))
return res1;
// TODO: this is currently only keeping #258 alive, evaluate if still worth it
if (auto res2 = CenterOfDoubleCross(image, PointI(*res1), range, finderPatternSize / 2 + 1); res2 && image.get(*res2))
return res2;
}
return {};
}
} // ZXing
```
|
/content/code_sandbox/core/src/ConcentricFinder.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,601
|
```c++
/*
*/
#include "ReedSolomonEncoder.h"
#include "GenericGF.h"
#include <algorithm>
#include <iterator>
#include <stdexcept>
namespace ZXing {
ReedSolomonEncoder::ReedSolomonEncoder(const GenericGF& field)
: _field(&field)
{
_cachedGenerators.push_back(GenericGFPoly(field, { 1 }));
}
const GenericGFPoly&
ReedSolomonEncoder::buildGenerator(int degree)
{
int cachedGenSize = Size(_cachedGenerators);
if (degree >= cachedGenSize) {
GenericGFPoly lastGenerator = _cachedGenerators.back();
for (int d = cachedGenSize; d <= degree; d++) {
lastGenerator.multiply(GenericGFPoly(*_field, { 1, _field->exp(d - 1 + _field->generatorBase()) }));
_cachedGenerators.push_back(lastGenerator);
}
}
return *std::next(_cachedGenerators.begin(), degree);
}
void
ReedSolomonEncoder::encode(std::vector<int>& message, const int numECCodeWords)
{
if (numECCodeWords == 0 || numECCodeWords >= Size(message))
throw std::invalid_argument("Invalid number of error correction code words");
GenericGFPoly info = GenericGFPoly(*_field, std::vector<int>(message.begin(), message.end() - numECCodeWords));
info.multiplyByMonomial(1, numECCodeWords);
GenericGFPoly _;
info.divide(buildGenerator(numECCodeWords), _);
auto& coefficients = info.coefficients();
int numZeroCoefficients = numECCodeWords - Size(coefficients);
std::fill_n(message.end() - numECCodeWords, numZeroCoefficients, 0);
std::copy(coefficients.begin(), coefficients.end(), message.end() - numECCodeWords + numZeroCoefficients);
}
} // ZXing
```
|
/content/code_sandbox/core/src/ReedSolomonEncoder.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 402
|
```c++
/*
*/
#include "TextUtfEncoding.h"
#include "Utf.h"
namespace ZXing::TextUtfEncoding {
std::string ToUtf8(std::wstring_view str)
{
return ZXing::ToUtf8(str);
}
// Same as `ToUtf8()` above, except if angleEscape set, places non-graphical characters in angle brackets with text name
std::string ToUtf8(std::wstring_view str, const bool angleEscape)
{
return angleEscape ? ZXing::ToUtf8(EscapeNonGraphical(str)) : ZXing::ToUtf8(str);
}
std::wstring FromUtf8(std::string_view utf8)
{
return ZXing::FromUtf8(utf8);
}
} // namespace ZXing::TextUtfEncoding
```
|
/content/code_sandbox/core/src/TextUtfEncoding.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 154
|
```objective-c
/*
*/
#pragma once
#include "BarcodeFormat.h"
#include "CharacterSet.h"
#include <string_view>
#include <utility>
namespace ZXing {
/**
* @brief The Binarizer enum
*
* Specify which algorithm to use for the grayscale to binary transformation.
* The difference is how to get to a threshold value T which results in a bit
* value R = L <= T.
*/
enum class Binarizer : unsigned char // needs to be unsigned for the bitfield below to work, uint8_t fails as well
{
LocalAverage, ///< T = average of neighboring pixels for matrix and GlobalHistogram for linear (HybridBinarizer)
GlobalHistogram, ///< T = valley between the 2 largest peaks in the histogram (per line in linear case)
FixedThreshold, ///< T = 127
BoolCast, ///< T = 0, fastest possible
};
enum class EanAddOnSymbol : unsigned char // see above
{
Ignore, ///< Ignore any Add-On symbol during read/scan
Read, ///< Read EAN-2/EAN-5 Add-On symbol if found
Require, ///< Require EAN-2/EAN-5 Add-On symbol to be present
};
enum class TextMode : unsigned char // see above
{
Plain, ///< bytes() transcoded to unicode based on ECI info or guessed charset (the default mode prior to 2.0)
ECI, ///< standard content following the ECI protocol with every character set ECI segment transcoded to unicode
HRI, ///< Human Readable Interpretation (dependent on the ContentType)
Hex, ///< bytes() transcoded to ASCII string of HEX values
Escaped, ///< Use the EscapeNonGraphical() function (e.g. ASCII 29 will be transcoded to "<GS>")
};
class ReaderOptions
{
bool _tryHarder : 1;
bool _tryRotate : 1;
bool _tryInvert : 1;
bool _tryDownscale : 1;
bool _isPure : 1;
bool _tryCode39ExtendedMode : 1;
bool _validateCode39CheckSum : 1;
bool _validateITFCheckSum : 1;
bool _returnCodabarStartEnd : 1;
bool _returnErrors : 1;
uint8_t _downscaleFactor : 3;
EanAddOnSymbol _eanAddOnSymbol : 2;
Binarizer _binarizer : 2;
TextMode _textMode : 3;
CharacterSet _characterSet : 6;
#ifdef ZXING_EXPERIMENTAL_API
bool _tryDenoise : 1;
#endif
uint8_t _minLineCount = 2;
uint8_t _maxNumberOfSymbols = 0xff;
uint16_t _downscaleThreshold = 500;
BarcodeFormats _formats = BarcodeFormat::None;
public:
// bitfields don't get default initialized to 0 before c++20
ReaderOptions()
: _tryHarder(1),
_tryRotate(1),
_tryInvert(1),
_tryDownscale(1),
_isPure(0),
_tryCode39ExtendedMode(1),
_validateCode39CheckSum(0),
_validateITFCheckSum(0),
_returnCodabarStartEnd(1),
_returnErrors(0),
_downscaleFactor(3),
_eanAddOnSymbol(EanAddOnSymbol::Ignore),
_binarizer(Binarizer::LocalAverage),
_textMode(TextMode::HRI),
_characterSet(CharacterSet::Unknown)
#ifdef ZXING_EXPERIMENTAL_API
,
_tryDenoise(0)
#endif
{}
#define ZX_PROPERTY(TYPE, GETTER, SETTER, ...) \
TYPE GETTER() const noexcept { return _##GETTER; } \
__VA_ARGS__ ReaderOptions& SETTER(TYPE v)& { return (void)(_##GETTER = std::move(v)), *this; } \
__VA_ARGS__ ReaderOptions&& SETTER(TYPE v)&& { return (void)(_##GETTER = std::move(v)), std::move(*this); }
/// Specify a set of BarcodeFormats that should be searched for, the default is all supported formats.
ZX_PROPERTY(BarcodeFormats, formats, setFormats)
/// Spend more time to try to find a barcode; optimize for accuracy, not speed.
ZX_PROPERTY(bool, tryHarder, setTryHarder)
/// Also try detecting code in 90, 180 and 270 degree rotated images.
ZX_PROPERTY(bool, tryRotate, setTryRotate)
/// Also try detecting inverted ("reversed reflectance") codes if the format allows for those.
ZX_PROPERTY(bool, tryInvert, setTryInvert)
/// Also try detecting code in downscaled images (depending on image size).
ZX_PROPERTY(bool, tryDownscale, setTryDownscale)
#ifdef ZXING_EXPERIMENTAL_API
/// Also try detecting code after denoising (currently morphological closing filter for 2D symbologies only).
ZX_PROPERTY(bool, tryDenoise, setTryDenoise)
#endif
/// Binarizer to use internally when using the ReadBarcode function
ZX_PROPERTY(Binarizer, binarizer, setBinarizer)
/// Set to true if the input contains nothing but a single perfectly aligned barcode (generated image)
ZX_PROPERTY(bool, isPure, setIsPure)
/// Image size ( min(width, height) ) threshold at which to start downscaled scanning
// WARNING: this API is experimental and may change/disappear
ZX_PROPERTY(uint16_t, downscaleThreshold, setDownscaleThreshold)
/// Scale factor used during downscaling, meaningful values are 2, 3 and 4
// WARNING: this API is experimental and may change/disappear
ZX_PROPERTY(uint8_t, downscaleFactor, setDownscaleFactor)
/// The number of scan lines in a linear barcode that have to be equal to accept the result, default is 2
ZX_PROPERTY(uint8_t, minLineCount, setMinLineCount)
/// The maximum number of symbols (barcodes) to detect / look for in the image with ReadBarcodes
ZX_PROPERTY(uint8_t, maxNumberOfSymbols, setMaxNumberOfSymbols)
/// Enable the heuristic to detect and decode "full ASCII"/extended Code39 symbols
ZX_PROPERTY(bool, tryCode39ExtendedMode, setTryCode39ExtendedMode)
/// Deprecated / does nothing. The Code39 symbol has a valid checksum iff symbologyIdentifier()[2] is an odd digit
ZX_PROPERTY(bool, validateCode39CheckSum, setValidateCode39CheckSum, [[deprecated]])
/// Deprecated / does nothing. The ITF symbol has a valid checksum iff symbologyIdentifier()[2] == '1'.
ZX_PROPERTY(bool, validateITFCheckSum, setValidateITFCheckSum, [[deprecated]])
/// Deprecated / does nothing. Codabar start/stop characters are always returned.
ZX_PROPERTY(bool, returnCodabarStartEnd, setReturnCodabarStartEnd, [[deprecated]])
/// If true, return the barcodes with errors as well (e.g. checksum errors, see @Barcode::error())
ZX_PROPERTY(bool, returnErrors, setReturnErrors)
/// Specify whether to ignore, read or require EAN-2/5 add-on symbols while scanning EAN/UPC codes
ZX_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, setEanAddOnSymbol)
/// Specifies the TextMode that controls the return of the Barcode::text() function
ZX_PROPERTY(TextMode, textMode, setTextMode)
/// Specifies fallback character set to use instead of auto-detecting it (when applicable)
ZX_PROPERTY(CharacterSet, characterSet, setCharacterSet)
ReaderOptions& setCharacterSet(std::string_view v)& { return (void)(_characterSet = CharacterSetFromString(v)), *this; }
ReaderOptions&& setCharacterSet(std::string_view v) && { return (void)(_characterSet = CharacterSetFromString(v)), std::move(*this); }
#undef ZX_PROPERTY
bool hasFormat(BarcodeFormats f) const noexcept { return _formats.testFlags(f) || _formats.empty(); }
};
#ifndef HIDE_DECODE_HINTS_ALIAS
using DecodeHints [[deprecated]] = ReaderOptions;
#endif
} // ZXing
```
|
/content/code_sandbox/core/src/ReaderOptions.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,794
|
```objective-c
/*
*/
#pragma once
#include "Point.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cmath>
#include <vector>
#ifdef PRINT_DEBUG
#include <cstdio>
#endif
namespace ZXing {
class RegressionLine
{
protected:
std::vector<PointF> _points;
PointF _directionInward;
PointF::value_t a = NAN, b = NAN, c = NAN;
friend PointF intersect(const RegressionLine& l1, const RegressionLine& l2);
template<typename T> bool evaluate(const PointT<T>* begin, const PointT<T>* end)
{
auto mean = Reduce(begin, end, PointF()) / std::distance(begin, end);
PointF::value_t sumXX = 0, sumYY = 0, sumXY = 0;
for (auto p = begin; p != end; ++p) {
auto d = *p - mean;
sumXX += d.x * d.x;
sumYY += d.y * d.y;
sumXY += d.x * d.y;
}
if (sumYY >= sumXX) {
auto l = std::sqrt(sumYY * sumYY + sumXY * sumXY);
a = +sumYY / l;
b = -sumXY / l;
} else {
auto l = std::sqrt(sumXX * sumXX + sumXY * sumXY);
a = +sumXY / l;
b = -sumXX / l;
}
if (dot(_directionInward, normal()) < 0) {
a = -a;
b = -b;
}
c = dot(normal(), mean); // (a*mean.x + b*mean.y);
return dot(_directionInward, normal()) > 0.5f; // angle between original and new direction is at most 60 degree
}
template <typename T> bool evaluate(const std::vector<PointT<T>>& points) { return evaluate(&points.front(), &points.back() + 1); }
template <typename T> static auto distance(PointT<T> a, PointT<T> b) { return ZXing::distance(a, b); }
public:
RegressionLine() { _points.reserve(16); } // arbitrary but plausible start size (tiny performance improvement)
template<typename T> RegressionLine(PointT<T> a, PointT<T> b)
{
evaluate(std::vector{a, b});
}
template<typename T> RegressionLine(const PointT<T>* b, const PointT<T>* e)
{
evaluate(b, e);
}
const auto& points() const { return _points; }
int length() const { return _points.size() >= 2 ? int(distance(_points.front(), _points.back())) : 0; }
bool isValid() const { return !std::isnan(a); }
PointF normal() const { return isValid() ? PointF(a, b) : _directionInward; }
auto signedDistance(PointF p) const { return dot(normal(), p) - c; }
template <typename T> auto distance(PointT<T> p) const { return std::abs(signedDistance(PointF(p))); }
PointF project(PointF p) const { return p - signedDistance(p) * normal(); }
PointF centroid() const { return Reduce(_points) / _points.size(); }
void reset()
{
_points.clear();
_directionInward = {};
a = b = c = NAN;
}
void add(PointF p) {
assert(_directionInward != PointF());
_points.push_back(p);
if (_points.size() == 1)
c = dot(normal(), p);
}
void pop_back() { _points.pop_back(); }
void pop_front()
{
std::rotate(_points.begin(), _points.begin() + 1, _points.end());
_points.pop_back();
}
void setDirectionInward(PointF d) { _directionInward = normalized(d); }
bool evaluate(double maxSignedDist = -1, bool updatePoints = false)
{
bool ret = evaluate(_points);
if (maxSignedDist > 0) {
auto points = _points;
while (true) {
auto old_points_size = points.size();
// remove points that are further 'inside' than maxSignedDist or further 'outside' than 2 x maxSignedDist
auto end = std::remove_if(points.begin(), points.end(), [this, maxSignedDist](auto p) {
auto sd = this->signedDistance(p);
return sd > maxSignedDist || sd < -2 * maxSignedDist;
});
points.erase(end, points.end());
// if we threw away too many points, something is off with the line to begin with
if (points.size() < old_points_size / 2 || points.size() < 2)
return false;
if (old_points_size == points.size())
break;
#ifdef PRINT_DEBUG
printf("removed %zu points -> %zu remaining\n", old_points_size - points.size(), points.size());
fflush(stdout);
#endif
ret = evaluate(points);
}
if (updatePoints)
_points = std::move(points);
}
return ret;
}
bool isHighRes() const
{
PointF min = _points.front(), max = _points.front();
for (auto p : _points) {
UpdateMinMax(min.x, max.x, p.x);
UpdateMinMax(min.y, max.y, p.y);
}
auto diff = max - min;
auto len = maxAbsComponent(diff);
auto steps = std::min(std::abs(diff.x), std::abs(diff.y));
// due to aliasing we get bad extrapolations if the line is short and too close to vertical/horizontal
return steps > 2 || len > 50;
}
};
inline PointF intersect(const RegressionLine& l1, const RegressionLine& l2)
{
assert(l1.isValid() && l2.isValid());
auto d = l1.a * l2.b - l1.b * l2.a;
auto x = (l1.c * l2.b - l1.b * l2.c) / d;
auto y = (l1.a * l2.c - l1.c * l2.a) / d;
return {x, y};
}
} // ZXing
```
|
/content/code_sandbox/core/src/RegressionLine.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,366
|
```c++
/*
*/
#include "Error.h"
namespace ZXing {
std::string Error::location() const
{
if (!_file)
return {};
std::string file(_file);
return file.substr(file.find_last_of("/\\") + 1) + ":" + std::to_string(_line);
}
std::string ToString(const Error& e)
{
const char* name[] = {"", "FormatError", "ChecksumError", "Unsupported"};
std::string ret = name[static_cast<int>(e.type())];
if (!e.msg().empty())
ret += " (" + e.msg() + ")";
if (auto location = e.location(); !location.empty())
ret += " @ " + e.location();
return ret;
}
}
```
|
/content/code_sandbox/core/src/Error.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 150
|
```c++
/*
*/
#include "GenericGFPoly.h"
#include "GenericGF.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cassert>
#include <stdexcept>
namespace ZXing {
int
GenericGFPoly::evaluateAt(int a) const
{
if (a == 0) // return the x^0 coefficient
return constant();
if (a == 1) // return the sum of the coefficients
return Reduce(_coefficients, 0, [](auto s, auto c) { return s ^ c; });
return std::accumulate(_coefficients.begin(), _coefficients.end(), 0,
[this, a](auto s, auto c) { return _field->multiply(a, s) ^ c; });
}
GenericGFPoly& GenericGFPoly::addOrSubtract(GenericGFPoly& other)
{
assert(_field == other._field); // "GenericGFPolys do not have same GenericGF field"
if (isZero()) {
swap(*this, other);
return *this;
}
if (other.isZero())
return *this;
auto& smallerCoefs = other._coefficients;
auto& largerCoefs = _coefficients;
if (smallerCoefs.size() > largerCoefs.size())
std::swap(smallerCoefs, largerCoefs);
size_t lengthDiff = largerCoefs.size() - smallerCoefs.size();
// high-order terms only found in higher-degree polynomial's coefficients stay untouched
for (size_t i = lengthDiff; i < largerCoefs.size(); ++i)
largerCoefs[i] ^= smallerCoefs[i - lengthDiff];
normalize();
return *this;
}
GenericGFPoly&
GenericGFPoly::multiply(const GenericGFPoly& other)
{
assert(_field == other._field); // "GenericGFPolys do not have same GenericGF field"
if (isZero() || other.isZero())
return setMonomial(0);
auto& a = _coefficients;
auto& b = other._coefficients;
// To disable the use of the malloc cache, simply uncomment:
// Coefficients _cache;
_cache.resize(a.size() + b.size() - 1);
std::fill(_cache.begin(), _cache.end(), 0);
for (size_t i = 0; i < a.size(); ++i)
for (size_t j = 0; j < b.size(); ++j)
_cache[i + j] ^= _field->multiply(a[i], b[j]);
_coefficients.swap(_cache);
normalize();
return *this;
}
GenericGFPoly&
GenericGFPoly::multiplyByMonomial(int coefficient, int degree)
{
assert(degree >= 0);
if (coefficient == 0)
return setMonomial(0);
for (int& c : _coefficients)
c = _field->multiply(c, coefficient);
_coefficients.resize(_coefficients.size() + degree, 0);
normalize();
return *this;
}
GenericGFPoly&
GenericGFPoly::divide(const GenericGFPoly& other, GenericGFPoly& quotient)
{
assert(_field == other._field); // "GenericGFPolys do not have same GenericGF field"
if (other.isZero())
throw std::invalid_argument("Divide by 0");
quotient.setField(*_field);
if (degree() < other.degree()) {
// the remainder is this and the quotient is 0
quotient.setMonomial(0);
return *this;
}
// use Expanded Synthetic Division (see path_to_url
// we use the memory from this (the dividend) and swap it with quotient, which will then accumulate the result as
// [quotient : remainder]. we later copy back the remainder into this and shorten the quotient.
std::swap(*this, quotient);
auto& divisor = other._coefficients;
auto& result = quotient._coefficients;
auto normalizer = _field->inverse(divisor[0]);
for (int i = 0; i < Size(result) - (Size(divisor) - 1); ++i) {
auto& ci = result[i];
if (ci == 0)
continue;
ci = _field->multiply(ci, normalizer);
// we always skip the first coefficient of the divisor, because it's only used to normalize the dividend coefficient
for (int j = 1; j < Size(divisor); ++j)
result[i + j] ^= _field->multiply(divisor[j], ci); // equivalent to: result[i + j] += -divisor[j] * ci
}
// extract the normalized remainder from result
auto firstNonZero = std::find_if(result.end() - other.degree(), result.end(), [](int c){ return c != 0; });
if (firstNonZero == result.end()) {
setMonomial(0);
} else {
_coefficients.resize(result.end() - firstNonZero);
std::copy(firstNonZero, result.end(), _coefficients.begin());
}
// cut off the tail with the remainder to leave the quotient
result.resize(result.size() - other.degree());
return *this;
}
void GenericGFPoly::normalize()
{
auto firstNonZero = FindIf(_coefficients, [](int c){ return c != 0; });
// Leading term must be non-zero for anything except the constant polynomial "0"
if (firstNonZero != _coefficients.begin()) {
if (firstNonZero == _coefficients.end()) {
_coefficients.resize(1, 0);
} else {
std::copy(firstNonZero, _coefficients.end(), _coefficients.begin());
_coefficients.resize(_coefficients.end() - firstNonZero);
}
}
}
} // namespace ZXing
```
|
/content/code_sandbox/core/src/GenericGFPoly.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,250
|
```c++
/*
*/
#include "ECI.h"
#include "ZXAlgorithms.h"
#include <map>
namespace ZXing {
static const std::map<ECI, CharacterSet> ECI_TO_CHARSET = {
{ECI(0), CharacterSet::Cp437}, // Obsolete
{ECI(1), CharacterSet::ISO8859_1}, // Obsolete
{ECI::Cp437, CharacterSet::Cp437}, // Obsolete but still used by PDF417 Macro fields (ISO/IEC 15438:2015 Annex H.2.3)
{ECI::ISO8859_1, CharacterSet::ISO8859_1},
{ECI::ISO8859_2, CharacterSet::ISO8859_2},
{ECI::ISO8859_3, CharacterSet::ISO8859_3},
{ECI::ISO8859_4, CharacterSet::ISO8859_4},
{ECI::ISO8859_5, CharacterSet::ISO8859_5},
{ECI::ISO8859_6, CharacterSet::ISO8859_6},
{ECI::ISO8859_7, CharacterSet::ISO8859_7},
{ECI::ISO8859_8, CharacterSet::ISO8859_8},
{ECI::ISO8859_9, CharacterSet::ISO8859_9},
{ECI::ISO8859_10, CharacterSet::ISO8859_10},
{ECI::ISO8859_11, CharacterSet::ISO8859_11},
{ECI::ISO8859_13, CharacterSet::ISO8859_13},
{ECI::ISO8859_14, CharacterSet::ISO8859_14},
{ECI::ISO8859_15, CharacterSet::ISO8859_15},
{ECI::ISO8859_16, CharacterSet::ISO8859_16},
{ECI::Shift_JIS, CharacterSet::Shift_JIS},
{ECI::Cp1250, CharacterSet::Cp1250},
{ECI::Cp1251, CharacterSet::Cp1251},
{ECI::Cp1252, CharacterSet::Cp1252},
{ECI::Cp1256, CharacterSet::Cp1256},
{ECI::UTF8, CharacterSet::UTF8},
{ECI::UTF16BE, CharacterSet::UTF16BE},
{ECI::UTF16LE, CharacterSet::UTF16LE},
{ECI::UTF32BE, CharacterSet::UTF32BE},
{ECI::UTF32LE, CharacterSet::UTF32LE},
{ECI::ASCII, CharacterSet::ASCII},
{ECI::Big5, CharacterSet::Big5},
{ECI::GB18030, CharacterSet::GB18030},
{ECI::GB2312, CharacterSet::GB2312},
{ECI::EUC_KR, CharacterSet::EUC_KR},
{ECI::ISO646_Inv, CharacterSet::ASCII},
{ECI::Binary, CharacterSet::BINARY},
};
std::string ToString(ECI eci)
{
return '\\' + ToString(ToInt(eci), 6);
}
CharacterSet ToCharacterSet(ECI eci)
{
if (auto it = ECI_TO_CHARSET.find(eci); it != ECI_TO_CHARSET.end())
return it->second;
return CharacterSet::Unknown;
}
ECI ToECI(CharacterSet cs)
{
// Special case ISO8859_1 to avoid obsolete ECI 1
if (cs == CharacterSet::ISO8859_1)
return ECI::ISO8859_1;
// Special case Cp437 to avoid obsolete ECI 0 for slightly less obsolete ECI 2
if (cs == CharacterSet::Cp437)
return ECI::Cp437;
for (auto& [key, value] : ECI_TO_CHARSET)
if (value == cs)
return key;
return ECI::Unknown;
}
} // namespace ZXing
```
|
/content/code_sandbox/core/src/ECI.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 895
|
```c++
/*
*/
#include "ReadBarcode.h"
#if !defined(ZXING_READERS) && !defined(ZXING_WRITERS)
#include "Version.h"
#endif
#ifdef ZXING_READERS
#include "GlobalHistogramBinarizer.h"
#include "HybridBinarizer.h"
#include "MultiFormatReader.h"
#include "Pattern.h"
#include "ThresholdBinarizer.h"
#endif
#include <climits>
#include <memory>
#include <stdexcept>
namespace ZXing {
#ifdef ZXING_READERS
class LumImage : public Image
{
public:
using Image::Image;
uint8_t* data() { return const_cast<uint8_t*>(Image::data()); }
};
template<typename P>
static LumImage ExtractLum(const ImageView& iv, P projection)
{
LumImage res(iv.width(), iv.height());
auto* dst = res.data();
for(int y = 0; y < iv.height(); ++y)
for(int x = 0, w = iv.width(); x < w; ++x)
*dst++ = projection(iv.data(x, y));
return res;
}
class LumImagePyramid
{
std::vector<LumImage> buffers;
template<int N>
void addLayer()
{
auto siv = layers.back();
buffers.emplace_back(siv.width() / N, siv.height() / N);
layers.push_back(buffers.back());
auto& div = buffers.back();
auto* d = div.data();
for (int dy = 0; dy < div.height(); ++dy)
for (int dx = 0; dx < div.width(); ++dx) {
int sum = (N * N) / 2;
for (int ty = 0; ty < N; ++ty)
for (int tx = 0; tx < N; ++tx)
sum += *siv.data(dx * N + tx, dy * N + ty);
*d++ = sum / (N * N);
}
}
void addLayer(int factor)
{
// help the compiler's auto-vectorizer by hard-coding the scale factor
switch (factor) {
case 2: addLayer<2>(); break;
case 3: addLayer<3>(); break;
case 4: addLayer<4>(); break;
default: throw std::invalid_argument("Invalid ReaderOptions::downscaleFactor"); break;
}
}
public:
std::vector<ImageView> layers;
LumImagePyramid(const ImageView& iv, int threshold, int factor)
{
if (factor < 2)
throw std::invalid_argument("Invalid ReaderOptions::downscaleFactor");
layers.push_back(iv);
// TODO: if only matrix codes were considered, then using std::min would be sufficient (see #425)
while (threshold > 0 && std::max(layers.back().width(), layers.back().height()) > threshold &&
std::min(layers.back().width(), layers.back().height()) >= factor)
addLayer(factor);
#if 0
// Reversing the layers means we'd start with the smallest. that can make sense if we are only looking for a
// single symbol. If we start with the higher resolution, we get better (high res) position information.
// TODO: see if masking out higher res layers based on found symbols in lower res helps overall performance.
std::reverse(layers.begin(), layers.end());
#endif
}
};
ImageView SetupLumImageView(ImageView iv, LumImage& lum, const ReaderOptions& opts)
{
if (iv.format() == ImageFormat::None)
throw std::invalid_argument("Invalid image format");
if (opts.binarizer() == Binarizer::GlobalHistogram || opts.binarizer() == Binarizer::LocalAverage) {
// manually spell out the 3 most common pixel formats to get at least gcc to vectorize the code
if (iv.format() == ImageFormat::RGB && iv.pixStride() == 3) {
lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
} else if (iv.format() == ImageFormat::RGBA && iv.pixStride() == 4) {
lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
} else if (iv.format() == ImageFormat::BGR && iv.pixStride() == 3) {
lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[2], src[1], src[0]); });
} else if (iv.format() != ImageFormat::Lum) {
lum = ExtractLum(iv, [r = RedIndex(iv.format()), g = GreenIndex(iv.format()), b = BlueIndex(iv.format())](
const uint8_t* src) { return RGBToLum(src[r], src[g], src[b]); });
} else if (iv.pixStride() != 1) {
// GlobalHistogram and LocalAverage need dense line memory layout
lum = ExtractLum(iv, [](const uint8_t* src) { return *src; });
}
if (lum.data())
return lum;
}
return iv;
}
std::unique_ptr<BinaryBitmap> CreateBitmap(ZXing::Binarizer binarizer, const ImageView& iv)
{
switch (binarizer) {
case Binarizer::BoolCast: return std::make_unique<ThresholdBinarizer>(iv, 0);
case Binarizer::FixedThreshold: return std::make_unique<ThresholdBinarizer>(iv, 127);
case Binarizer::GlobalHistogram: return std::make_unique<GlobalHistogramBinarizer>(iv);
case Binarizer::LocalAverage: return std::make_unique<HybridBinarizer>(iv);
}
return {}; // silence gcc warning
}
Barcode ReadBarcode(const ImageView& _iv, const ReaderOptions& opts)
{
return FirstOrDefault(ReadBarcodes(_iv, ReaderOptions(opts).setMaxNumberOfSymbols(1)));
}
Barcodes ReadBarcodes(const ImageView& _iv, const ReaderOptions& opts)
{
if (sizeof(PatternType) < 4 && (_iv.width() > 0xffff || _iv.height() > 0xffff))
throw std::invalid_argument("Maximum image width/height is 65535");
if (!_iv.data() || _iv.width() * _iv.height() == 0)
throw std::invalid_argument("ImageView is null/empty");
LumImage lum;
ImageView iv = SetupLumImageView(_iv, lum, opts);
MultiFormatReader reader(opts);
if (opts.isPure())
return {reader.read(*CreateBitmap(opts.binarizer(), iv))};
std::unique_ptr<MultiFormatReader> closedReader;
#ifdef ZXING_EXPERIMENTAL_API
auto formatsBenefittingFromClosing = BarcodeFormat::Aztec | BarcodeFormat::DataMatrix | BarcodeFormat::QRCode | BarcodeFormat::MicroQRCode;
ReaderOptions closedOptions = opts;
if (opts.tryDenoise() && opts.hasFormat(formatsBenefittingFromClosing) && _iv.height() >= 3) {
closedOptions.setFormats((opts.formats().empty() ? BarcodeFormat::Any : opts.formats()) & formatsBenefittingFromClosing);
closedReader = std::make_unique<MultiFormatReader>(closedOptions);
}
#endif
LumImagePyramid pyramid(iv, opts.downscaleThreshold() * opts.tryDownscale(), opts.downscaleFactor());
Barcodes res;
int maxSymbols = opts.maxNumberOfSymbols() ? opts.maxNumberOfSymbols() : INT_MAX;
for (auto&& iv : pyramid.layers) {
auto bitmap = CreateBitmap(opts.binarizer(), iv);
for (int close = 0; close <= (closedReader ? 1 : 0); ++close) {
if (close)
bitmap->close();
// TODO: check if closing after invert would be beneficial
for (int invert = 0; invert <= static_cast<int>(opts.tryInvert() && !close); ++invert) {
if (invert)
bitmap->invert();
auto rs = (close ? *closedReader : reader).readMultiple(*bitmap, maxSymbols);
for (auto& r : rs) {
if (iv.width() != _iv.width())
r.setPosition(Scale(r.position(), _iv.width() / iv.width()));
if (!Contains(res, r)) {
r.setReaderOptions(opts);
r.setIsInverted(bitmap->inverted());
res.push_back(std::move(r));
--maxSymbols;
}
}
if (maxSymbols <= 0)
return res;
}
}
}
return res;
}
#else // ZXING_READERS
Barcode ReadBarcode(const ImageView&, const ReaderOptions&)
{
throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
}
Barcodes ReadBarcodes(const ImageView&, const ReaderOptions&)
{
throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
}
#endif // ZXING_READERS
} // ZXing
```
|
/content/code_sandbox/core/src/ReadBarcode.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,990
|
```objective-c
/*
*/
#pragma once
#include "Error.h"
#include <algorithm>
#include <cstring>
#include <initializer_list>
#include <iterator>
#include <numeric>
#include <string>
#include <utility>
namespace ZXing {
template <class T, class U>
constexpr T narrow_cast(U&& u) noexcept {
return static_cast<T>(std::forward<U>(u));
}
template <typename Container, typename Value>
auto Find(Container& c, const Value& v) -> decltype(std::begin(c)) {
return std::find(std::begin(c), std::end(c), v);
}
template <typename Container, typename Predicate>
auto FindIf(Container& c, Predicate p) -> decltype(std::begin(c)) {
return std::find_if(std::begin(c), std::end(c), p);
}
template <typename Container, typename Value>
auto Contains(const Container& c, const Value& v) -> decltype(std::begin(c), bool()){
return Find(c, v) != std::end(c);
}
template <typename ListType, typename Value>
auto Contains(const std::initializer_list<ListType>& c, const Value& v) -> decltype(std::begin(c), bool()){
return Find(c, v) != std::end(c);
}
inline bool Contains(const char* str, char c) {
return strchr(str, c) != nullptr;
}
template <template <typename...> typename C, typename... Ts>
auto FirstOrDefault(C<Ts...>&& container)
{
return container.empty() ? typename C<Ts...>::value_type() : std::move(container.front());
}
template <typename Iterator, typename Value = typename std::iterator_traits<Iterator>::value_type, typename Op = std::plus<Value>>
Value Reduce(Iterator b, Iterator e, Value v = Value{}, Op op = {}) {
// std::reduce() first sounded like a better implementation because it is not implemented as a strict left-fold
// operation, meaning the order of the op-application is not specified. This sounded like an optimization opportunity
// but it turns out that for this use case it actually does not make a difference (falsepositives runtime). And
// when tested with a large std::vector<uint16_t> and proper autovectorization (e.g. clang++ -O2) it turns out that
// std::accumulate can be twice as fast as std::reduce.
return std::accumulate(b, e, v, op);
}
template <typename Container, typename Value = typename Container::value_type, typename Op = std::plus<Value>>
Value Reduce(const Container& c, Value v = Value{}, Op op = {}) {
return Reduce(std::begin(c), std::end(c), v, op);
}
// see C++20 ssize
template <class Container>
constexpr auto Size(const Container& c) -> decltype(c.size(), int()) {
return narrow_cast<int>(c.size());
}
template <class T, std::size_t N>
constexpr int Size(const T (&)[N]) noexcept {
return narrow_cast<int>(N);
}
template <typename Container, typename Value>
int IndexOf(const Container& c, const Value& v) {
auto i = Find(c, v);
return i == std::end(c) ? -1 : narrow_cast<int>(std::distance(std::begin(c), i));
}
inline int IndexOf(const char* str, char c) {
auto s = strchr(str, c);
return s != nullptr ? narrow_cast<int>(s - str) : -1;
}
template <typename Container, typename Value, class UnaryOp>
Value TransformReduce(const Container& c, Value s, UnaryOp op) {
for (const auto& v : c)
s += op(v);
return s;
}
template <typename T = char>
T ToDigit(int i)
{
if (i < 0 || i > 9)
throw FormatError("Invalid digit value");
return static_cast<T>('0' + i);
}
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
std::string ToString(T val, int len)
{
std::string result(len--, '0');
if (val < 0)
throw FormatError("Invalid value");
for (; len >= 0 && val != 0; --len, val /= 10)
result[len] = '0' + val % 10;
if (val)
throw FormatError("Invalid value");
return result;
}
template <typename T>
void UpdateMin(T& min, T val)
{
min = std::min(min, val);
}
template <typename T>
void UpdateMax(T& max, T val)
{
max = std::max(max, val);
}
template <typename T>
void UpdateMinMax(T& min, T& max, T val)
{
min = std::min(min, val);
max = std::max(max, val);
// Note: the above code is not equivalent to
// if (val < min) min = val;
// else if (val > max) max = val;
// It is basically the same but without the 'else'. For the 'else'-variant to work,
// both min and max have to be initialized with a value that is part of the sequence.
// Also it turns out clang and gcc can vectorize the code above but not the code below.
}
} // ZXing
```
|
/content/code_sandbox/core/src/ZXAlgorithms.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,119
|
```objective-c
/*
*/
#pragma once
#include "Content.h"
#include "Error.h"
#include "StructuredAppend.h"
#include <memory>
#include <string>
#include <utility>
namespace ZXing {
class CustomData;
class DecoderResult
{
Content _content;
std::string _ecLevel;
int _lineCount = 0;
int _versionNumber = 0;
StructuredAppendInfo _structuredAppend;
bool _isMirrored = false;
bool _readerInit = false;
Error _error;
std::shared_ptr<CustomData> _extra;
DecoderResult(const DecoderResult &) = delete;
DecoderResult& operator=(const DecoderResult &) = delete;
public:
DecoderResult() = default;
DecoderResult(Error error) : _error(std::move(error)) {}
DecoderResult(Content&& bytes) : _content(std::move(bytes)) {}
DecoderResult(DecoderResult&&) noexcept = default;
DecoderResult& operator=(DecoderResult&&) noexcept = default;
bool isValid(bool includeErrors = false) const
{
return (!_content.bytes.empty() && !_error) || (includeErrors && !!_error);
}
const Content& content() const & { return _content; }
Content&& content() && { return std::move(_content); }
// to keep the unit tests happy for now:
std::wstring text() const { return _content.utfW(); }
std::string symbologyIdentifier() const { return _content.symbology.toString(false); }
// Simple macro to set up getter/setter methods that save lots of boilerplate.
// It sets up a standard 'const & () const', 2 setters for setting lvalues via
// copy and 2 for setting rvalues via move. They are provided each to work
// either on lvalues (normal 'void (...)') or on rvalues (returning '*this' as
// rvalue). The latter can be used to optionally initialize a temporary in a
// return statement, e.g.
// return DecoderResult(bytes, text).setEcLevel(level);
#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
const TYPE& GETTER() const & { return _##GETTER; } \
TYPE&& GETTER() && { return std::move(_##GETTER); } \
void SETTER(const TYPE& v) & { _##GETTER = v; } \
void SETTER(TYPE&& v) & { _##GETTER = std::move(v); } \
DecoderResult&& SETTER(const TYPE& v) && { _##GETTER = v; return std::move(*this); } \
DecoderResult&& SETTER(TYPE&& v) && { _##GETTER = std::move(v); return std::move(*this); }
ZX_PROPERTY(std::string, ecLevel, setEcLevel)
ZX_PROPERTY(int, lineCount, setLineCount)
ZX_PROPERTY(int, versionNumber, setVersionNumber)
ZX_PROPERTY(StructuredAppendInfo, structuredAppend, setStructuredAppend)
ZX_PROPERTY(Error, error, setError)
ZX_PROPERTY(bool, isMirrored, setIsMirrored)
ZX_PROPERTY(bool, readerInit, setReaderInit)
ZX_PROPERTY(std::shared_ptr<CustomData>, extra, setExtra)
#undef ZX_PROPERTY
};
} // ZXing
```
|
/content/code_sandbox/core/src/DecoderResult.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 693
|
```objective-c
/*
*/
#pragma once
// Thread local or static memory may be used to reduce the number of (re-)allocations of temporary variables
// in e.g. the ReedSolomonDecoder. It is disabled by default. It can be enabled by modifying the following define.
// Note: The Apple clang compiler until XCode 8 does not support c++11's thread_local.
// The alternative 'static' makes the code thread unsafe.
#define ZX_THREAD_LOCAL thread_local // '' (nothing), 'thread_local' or 'static'
// The Galoir Field abstractions used in Reed-Solomon error correction code can use more memory to eliminate a modulo
// operation. This improves performance but might not be the best option if RAM is scarce. The effect is a few kB big.
#define ZX_REED_SOLOMON_USE_MORE_MEMORY_FOR_SPEED
```
|
/content/code_sandbox/core/src/ZXConfig.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 173
|
```objective-c
/*
*/
#pragma once
#include "GlobalHistogramBinarizer.h"
namespace ZXing {
/**
* This class implements a local thresholding algorithm, which while slower than the
* GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
* high frequency images of barcodes with black data on white backgrounds. For this application,
* it does a much better job than a global blackpoint with severe shadows and gradients.
* However it tends to produce artifacts on lower frequency images and is therefore not
* a good general purpose binarizer for uses outside ZXing.
*
* This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
* and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
* inherently local, and only fails for horizontal gradients. We can revisit that problem later,
* but for now it was not a win to use local blocks for 1D.
*
* This Binarizer is the default for the unit tests and the recommended class for library users.
*
* @author dswitkin@google.com (Daniel Switkin)
*/
class HybridBinarizer : public GlobalHistogramBinarizer
{
public:
explicit HybridBinarizer(const ImageView& iv);
~HybridBinarizer() override;
bool getPatternRow(int row, int rotation, PatternRow &res) const override;
std::shared_ptr<const BitMatrix> getBlackMatrix() const override;
};
} // ZXing
```
|
/content/code_sandbox/core/src/HybridBinarizer.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 318
|
```c++
/*
*/
#define HIDE_DECODE_HINTS_ALIAS
#include "ReadBarcode.h"
namespace ZXing {
// Provide a struct that is binary compatible with ReaderOptions and is actually called DecodeHints so that
// the compiler generates a correctly mangled pair of ReadBarcode(s) symbols to keep backward ABI compatibility.
struct DecodeHints
{
char data[sizeof(ReaderOptions)];
};
Barcode ReadBarcode(const ImageView& image, const DecodeHints& hints = {})
{
return ReadBarcode(image, reinterpret_cast<const ReaderOptions&>(hints));
}
Barcodes ReadBarcodes(const ImageView& image, const DecodeHints& hints = {})
{
return ReadBarcodes(image, reinterpret_cast<const ReaderOptions&>(hints));
}
} // ZXing
```
|
/content/code_sandbox/core/src/DecodeHints.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 146
|
```c++
/*
*/
#include "ResultPoint.h"
#include <cmath>
namespace ZXing {
float ResultPoint::Distance(int aX, int aY, int bX, int bY)
{
auto dx = static_cast<float>(aX - bX);
auto dy = static_cast<float>(aY - bY);
return std::sqrt(dx * dx + dy * dy);
}
} // ZXing
```
|
/content/code_sandbox/core/src/ResultPoint.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 83
|
```objective-c
/*
*/
#pragma once
namespace ZXing {
class ByteArray;
/**
* <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
* number of bits read is not often a multiple of 8.</p>
*
* <p>This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
* it passed in, in which case all bets are off.</p>
*
* @author Sean Owen
*/
class BitSource
{
const ByteArray& _bytes;
int _byteOffset = 0;
int _bitOffset = 0;
public:
/**
* @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
* Bits are read within a byte from most-significant to least-significant bit.
* IMPORTANT: Bit source DOES NOT copy data byte, thus make sure that the bytes outlive the bit source object.
*/
explicit BitSource(const ByteArray& bytes) : _bytes(bytes) {}
BitSource(BitSource &) = delete;
BitSource& operator=(const BitSource &) = delete;
/**
* @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.
*/
int bitOffset() const {
return _bitOffset;
}
/**
* @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.
*/
int byteOffset() const {
return _byteOffset;
}
/**
* @param numBits number of bits to read
* @return int representing the bits read. The bits will appear as the least-significant bits of the int
*/
int readBits(int numBits);
/**
* @param numBits number of bits to peak
* @return int representing the bits peaked. The bits will appear as the least-significant
* bits of the int
*/
int peakBits(int numBits) const;
/**
* @return number of bits that can be read successfully
*/
int available() const;
};
} // ZXing
```
|
/content/code_sandbox/core/src/BitSource.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 456
|
```objective-c
/*
*/
#pragma once
#include "BitHacks.h"
#include "Range.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <vector>
namespace ZXing {
using PatternType = uint16_t;
template<int N> using Pattern = std::array<PatternType, N>;
using PatternRow = std::vector<PatternType>;
class PatternView
{
using Iterator = PatternRow::const_pointer;
Iterator _data = nullptr;
int _size = 0;
Iterator _base = nullptr;
Iterator _end = nullptr;
public:
using value_type = PatternRow::value_type;
PatternView() = default;
// A PatternRow always starts with the width of whitespace in front of the first black bar.
// The first element of the PatternView is the first bar.
PatternView(const PatternRow& bars)
: _data(bars.data() + 1), _size(Size(bars) - 1), _base(bars.data()), _end(bars.data() + bars.size())
{}
PatternView(Iterator data, int size, Iterator base, Iterator end) : _data(data), _size(size), _base(base), _end(end) {}
template <size_t N>
PatternView(const Pattern<N>& row) : _data(row.data()), _size(N)
{}
Iterator data() const { return _data; }
Iterator begin() const { return _data; }
Iterator end() const { return _data + _size; }
value_type operator[](int i) const
{
// assert(i < _count);
return _data[i];
}
int sum(int n = 0) const { return Reduce(_data, _data + (n == 0 ? _size : n)); }
int size() const { return _size; }
// index is the number of bars and spaces from the first bar to the current position
int index() const { return narrow_cast<int>(_data - _base) - 1; }
int pixelsInFront() const { return Reduce(_base, _data); }
int pixelsTillEnd() const { return Reduce(_base, _data + _size) - 1; }
bool isAtFirstBar() const { return _data == _base + 1; }
bool isAtLastBar() const { return _data + _size == _end - 1; }
bool isValid(int n) const { return _data && _data >= _base && _data + n <= _end; }
bool isValid() const { return isValid(size()); }
template<bool acceptIfAtFirstBar = false>
bool hasQuietZoneBefore(float scale) const
{
return (acceptIfAtFirstBar && isAtFirstBar()) || _data[-1] >= sum() * scale;
}
template<bool acceptIfAtLastBar = true>
bool hasQuietZoneAfter(float scale) const
{
return (acceptIfAtLastBar && isAtLastBar()) || _data[_size] >= sum() * scale;
}
PatternView subView(int offset, int size = 0) const
{
// if(std::abs(size) > count())
// printf("%d > %d\n", std::abs(size), _count);
// assert(std::abs(size) <= count());
if (size == 0)
size = _size - offset;
else if (size < 0)
size = _size - offset + size;
return {begin() + offset, std::max(size, 0), _base, _end};
}
bool shift(int n)
{
return _data && ((_data += n) + _size <= _end);
}
bool skipPair()
{
return shift(2);
}
bool skipSymbol()
{
return shift(_size);
}
bool skipSingle(int maxWidth)
{
return shift(1) && _data[-1] <= maxWidth;
}
void extend()
{
_size = std::max(0, narrow_cast<int>(_end - _data));
}
};
/**
* @brief The BarAndSpace struct is a simple 2 element data structure to hold information about bar(s) and space(s).
*
* The operator[](int) can be used in combination with a PatternView
*/
template <typename T>
struct BarAndSpace
{
using value_type = T;
T bar = {}, space = {};
// even index -> bar, odd index -> space
constexpr T& operator[](int i) noexcept { return reinterpret_cast<T*>(this)[i & 1]; }
constexpr T operator[](int i) const noexcept { return reinterpret_cast<const T*>(this)[i & 1]; }
bool isValid() const { return bar != T{} && space != T{}; }
};
using BarAndSpaceI = BarAndSpace<PatternType>;
template <int LEN, typename RT, typename T>
constexpr auto BarAndSpaceSum(const T* view) noexcept
{
BarAndSpace<RT> res;
for (int i = 0; i < LEN; ++i)
res[i] += view[i];
return res;
}
/**
* @brief FixedPattern describes a compile-time constant (start/stop) pattern.
*
* N = number of bars/spaces
* SUM = sum over all N elements (size of pattern in modules)
* IS_SPARCE = whether or not the pattern contains '0's denoting 'wide' bars/spaces
*/
template <int N, int SUM, bool IS_SPARCE = false>
struct FixedPattern
{
using value_type = PatternRow::value_type;
value_type _data[N];
constexpr value_type operator[](int i) const noexcept { return _data[i]; }
constexpr const value_type* data() const noexcept { return _data; }
constexpr int size() const noexcept { return N; }
constexpr BarAndSpace<value_type> sums() const noexcept { return BarAndSpaceSum<N, value_type>(_data); }
};
template <int N, int SUM>
using FixedSparcePattern = FixedPattern<N, SUM, true>;
template <bool E2E = false, int LEN, int SUM>
double IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pattern, int spaceInPixel = 0,
double minQuietZone = 0, double moduleSizeRef = 0)
{
if constexpr (E2E) {
auto widths = BarAndSpaceSum<LEN, double>(view.data());
auto sums = pattern.sums();
BarAndSpace<double> modSize = {widths[0] / sums[0], widths[1] / sums[1]};
auto [m, M] = std::minmax(modSize[0], modSize[1]);
if (M > 4 * m) // make sure module sizes of bars and spaces are not too far away from each other
return 0;
if (minQuietZone && spaceInPixel < minQuietZone * modSize.space)
return 0;
const BarAndSpace<double> thr = {modSize[0] * .75 + .5, modSize[1] / (2 + (LEN < 6)) + .5};
for (int x = 0; x < LEN; ++x)
if (std::abs(view[x] - pattern[x] * modSize[x]) > thr[x])
return 0;
return (modSize[0] + modSize[1]) / 2;
}
double width = view.sum(LEN);
if (SUM > LEN && width < SUM)
return 0;
const auto moduleSize = width / SUM;
if (minQuietZone && spaceInPixel < minQuietZone * moduleSize - 1)
return 0;
if (!moduleSizeRef)
moduleSizeRef = moduleSize;
// the offset of 0.5 is to make the code less sensitive to quantization errors for small (near 1) module sizes.
// TODO: review once we have upsampling in the binarizer in place.
const auto threshold = moduleSizeRef * (0.5 + E2E * 0.25) + 0.5;
for (int x = 0; x < LEN; ++x)
if (std::abs(view[x] - pattern[x] * moduleSizeRef) > threshold)
return 0;
return moduleSize;
}
template <bool RELAXED_THRESHOLD = false, int N, int SUM>
double IsPattern(const PatternView& view, const FixedPattern<N, SUM, true>& pattern, int spaceInPixel = 0,
double minQuietZone = 0, double moduleSizeRef = 0)
{
// pattern contains the indices with the bars/spaces that need to be equally wide
double width = 0;
for (int x = 0; x < SUM; ++x)
width += view[pattern[x]];
const auto moduleSize = width / SUM;
if (minQuietZone && spaceInPixel < minQuietZone * moduleSize - 1)
return 0;
if (!moduleSizeRef)
moduleSizeRef = moduleSize;
// the offset of 0.5 is to make the code less sensitive to quantization errors for small (near 1) module sizes.
// TODO: review once we have upsampling in the binarizer in place.
const auto threshold = moduleSizeRef * (0.5 + RELAXED_THRESHOLD * 0.25) + 0.5;
for (int x = 0; x < SUM; ++x)
if (std::abs(view[pattern[x]] - moduleSizeRef) > threshold)
return 0;
return moduleSize;
}
template <int N, int SUM, bool IS_SPARCE>
bool IsRightGuard(const PatternView& view, const FixedPattern<N, SUM, IS_SPARCE>& pattern, double minQuietZone,
double moduleSizeRef = 0)
{
int spaceInPixel = view.isAtLastBar() ? std::numeric_limits<int>::max() : *view.end();
return IsPattern(view, pattern, spaceInPixel, minQuietZone, moduleSizeRef) != 0;
}
template<int LEN, typename Pred>
PatternView FindLeftGuard(const PatternView& view, int minSize, Pred isGuard)
{
if (view.size() < minSize)
return {};
auto window = view.subView(0, LEN);
if (window.isAtFirstBar() && isGuard(window, std::numeric_limits<int>::max()))
return window;
for (auto end = view.end() - minSize; window.data() < end; window.skipPair())
if (isGuard(window, window[-1]))
return window;
return {};
}
template <int LEN, int SUM, bool IS_SPARCE>
PatternView FindLeftGuard(const PatternView& view, int minSize, const FixedPattern<LEN, SUM, IS_SPARCE>& pattern,
double minQuietZone)
{
return FindLeftGuard<LEN>(view, std::max(minSize, LEN),
[&pattern, minQuietZone](const PatternView& window, int spaceInPixel) {
return IsPattern(window, pattern, spaceInPixel, minQuietZone);
});
}
template <int LEN, int SUM>
std::array<int, LEN - 2> NormalizedE2EPattern(const PatternView& view)
{
double moduleSize = static_cast<double>(view.sum(LEN)) / SUM;
std::array<int, LEN - 2> e2e;
for (int i = 0; i < LEN - 2; i++) {
double v = (view[i] + view[i + 1]) / moduleSize;
e2e[i] = int(v + .5);
}
return e2e;
}
template <int LEN, int SUM>
std::array<int, LEN> NormalizedPattern(const PatternView& view)
{
double moduleSize = static_cast<double>(view.sum(LEN)) / SUM;
#if 1
int err = SUM;
std::array<int, LEN> is;
std::array<double, LEN> rs;
for (int i = 0; i < LEN; i++) {
double v = view[i] / moduleSize;
is[i] = int(v + .5);
rs[i] = v - is[i];
err -= is[i];
}
if (std::abs(err) > 1)
return {};
if (err) {
auto mi = err > 0 ? std::max_element(std::begin(rs), std::end(rs)) - std::begin(rs)
: std::min_element(std::begin(rs), std::end(rs)) - std::begin(rs);
is[mi] += err;
rs[mi] -= err;
}
#else
std::array<int, LEN> is, e2e;
int min_v = view[0], min_i = 0;
for (int i = 1; i < LEN; i++) {
double v = (view[i - 1] + view[i]) / moduleSize;
e2e[i] = int(v + .5);
if (view[i] < min_v) {
min_v = view[i];
min_i = i;
}
}
is[min_i] = 1;
for (int i = min_i + 1; i < LEN; ++i)
is[i] = e2e[i] - is[i - 1];
for (int i = min_i - 1; i >= 0; --i)
is[i] = e2e[i + 1] - is[i + 1];
#endif
return is;
}
template<typename I>
void GetPatternRow(Range<I> b_row, PatternRow& p_row)
{
// TODO: if reactivating the bit-packed array (!ZX_FAST_BIT_STORAGE) should be of interest then the following code could be
// considerably speed up by using a specialized variant along the lines of the old BitArray::getNextSetTo() function that
// was removed between 1.4 and 2.0.
#if 0
p_row.reserve(64);
p_row.clear();
auto lastPos = b_row.begin();
if (*lastPos)
p_row.push_back(0); // first value is number of white pixels, here 0
for (auto p = b_row.begin() + 1; p < b_row.end(); ++p)
if (bool(*p) != bool(*lastPos))
p_row.push_back(p - std::exchange(lastPos, p));
p_row.push_back(b_row.end() - lastPos);
if (*lastPos)
p_row.push_back(0); // last value is number of white pixels, here 0
#else
p_row.resize(b_row.size() + 2);
std::fill(p_row.begin(), p_row.end(), 0);
auto bitPos = b_row.begin();
const auto bitPosEnd = b_row.end();
auto intPos = p_row.data();
if (*bitPos)
intPos++; // first value is number of white pixels, here 0
// The following code as been observed to cause a speedup of up to 30% on large images on an AVX cpu
// and on an a Google Pixel 3 Android phone. Your mileage may vary.
if constexpr (std::is_pointer_v<I> && sizeof(I) == 8 && sizeof(std::remove_pointer_t<I>) == 1) {
using simd_t = uint64_t;
while (bitPos < bitPosEnd - sizeof(simd_t)) {
auto asSimd0 = BitHacks::LoadU<simd_t>(bitPos);
auto asSimd1 = BitHacks::LoadU<simd_t>(bitPos + 1);
auto z = asSimd0 ^ asSimd1;
if (z) {
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
int step = BitHacks::NumberOfTrailingZeros(z) / 8 + 1;
#else
int step = BitHacks::NumberOfLeadingZeros(z) / 8 + 1;
#endif
(*intPos++) += step;
bitPos += step;
} else {
(*intPos) += sizeof(simd_t);
bitPos += sizeof(simd_t);
}
}
}
while (++bitPos != bitPosEnd) {
++(*intPos);
intPos += bitPos[0] != bitPos[-1];
}
++(*intPos);
if (bitPos[-1])
intPos++;
p_row.resize(intPos - p_row.data() + 1);
#endif
}
} // ZXing
```
|
/content/code_sandbox/core/src/Pattern.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 3,569
|
```objective-c
/*
*/
#pragma once
#include <utility>
namespace ZXing {
/**
* ScopeExit is a trivial helper meant to be later replaced by std::scope_exit from library fundamentals TS v3.
*/
template <typename EF>
class ScopeExit
{
EF fn;
public:
ScopeExit(EF&& fn) : fn(std::move(fn)) {}
~ScopeExit() { fn(); }
};
template <class EF>
ScopeExit(EF) -> ScopeExit<EF>;
/**
* The SCOPE_EXIT macro is eliminating the need to give the object a name.
* Example usage:
* SCOPE_EXIT([]{ printf("exiting scope"); });
*/
#define SCOPE_EXIT_CAT2(x, y) x##y
#define SCOPE_EXIT_CAT(x, y) SCOPE_EXIT_CAT2(x, y)
#define SCOPE_EXIT const auto SCOPE_EXIT_CAT(scopeExit_, __COUNTER__) = ScopeExit
} // ZXing
```
|
/content/code_sandbox/core/src/Scope.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 193
|
```objective-c
/* zueci_sb.h - Extended Channel Interpretations single-byte, generated by "tools/gen_zueci_sb_h.php" from
"path_to_url" and
"path_to_url" and
"path_to_url" */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_SB_H
#define ZUECI_SB_H
/* Tables for ECIs 0 & 2 IBM CP437 */
static const zueci_u16 zueci_cp437_u_u[128] = { /* Unicode codepoints sorted */
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A5, 0x00AA, 0x00AB, 0x00AC,
0x00B0, 0x00B1, 0x00B2, 0x00B5, 0x00B7, 0x00BA, 0x00BB, 0x00BC,
0x00BD, 0x00BF, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C9, 0x00D1,
0x00D6, 0x00DC, 0x00DF, 0x00E0, 0x00E1, 0x00E2, 0x00E4, 0x00E5,
0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED,
0x00EE, 0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F6, 0x00F7,
0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FF, 0x0192, 0x0393, 0x0398,
0x03A3, 0x03A6, 0x03A9, 0x03B1, 0x03B4, 0x03B5, 0x03C0, 0x03C3,
0x03C4, 0x03C6, 0x207F, 0x20A7, 0x2219, 0x221A, 0x221E, 0x2229,
0x2248, 0x2261, 0x2264, 0x2265, 0x2310, 0x2320, 0x2321, 0x2500,
0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524, 0x252C,
0x2534, 0x253C, 0x2550, 0x2551, 0x2552, 0x2553, 0x2554, 0x2555,
0x2556, 0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C, 0x255D,
0x255E, 0x255F, 0x2560, 0x2561, 0x2562, 0x2563, 0x2564, 0x2565,
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x2580,
0x2584, 0x2588, 0x258C, 0x2590, 0x2591, 0x2592, 0x2593, 0x25A0,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_cp437_u_sb[128] = { /* Single-byte in Unicode order */
0xFF, 0xAD, 0x9B, 0x9C, 0x9D, 0xA6, 0xAE, 0xAA,
0xF8, 0xF1, 0xFD, 0xE6, 0xFA, 0xA7, 0xAF, 0xAC,
0xAB, 0xA8, 0x8E, 0x8F, 0x92, 0x80, 0x90, 0xA5,
0x99, 0x9A, 0xE1, 0x85, 0xA0, 0x83, 0x84, 0x86,
0x91, 0x87, 0x8A, 0x82, 0x88, 0x89, 0x8D, 0xA1,
0x8C, 0x8B, 0xA4, 0x95, 0xA2, 0x93, 0x94, 0xF6,
0x97, 0xA3, 0x96, 0x81, 0x98, 0x9F, 0xE2, 0xE9,
0xE4, 0xE8, 0xEA, 0xE0, 0xEB, 0xEE, 0xE3, 0xE5,
0xE7, 0xED, 0xFC, 0x9E, 0xF9, 0xFB, 0xEC, 0xEF,
0xF7, 0xF0, 0xF3, 0xF2, 0xA9, 0xF4, 0xF5, 0xC4,
0xB3, 0xDA, 0xBF, 0xC0, 0xD9, 0xC3, 0xB4, 0xC2,
0xC1, 0xC5, 0xCD, 0xBA, 0xD5, 0xD6, 0xC9, 0xB8,
0xB7, 0xBB, 0xD4, 0xD3, 0xC8, 0xBE, 0xBD, 0xBC,
0xC6, 0xC7, 0xCC, 0xB5, 0xB6, 0xB9, 0xD1, 0xD2,
0xCB, 0xCF, 0xD0, 0xCA, 0xD8, 0xD7, 0xCE, 0xDF,
0xDC, 0xDB, 0xDD, 0xDE, 0xB0, 0xB1, 0xB2, 0xFE,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_cp437_sb_u[128] = { /* Single-byte sorted indexes into Unicode table */
21, 51, 35, 29, 30, 27, 31, 33,
36, 37, 34, 41, 40, 38, 18, 19,
22, 32, 20, 45, 46, 43, 50, 48,
52, 24, 25, 2, 3, 4, 67, 53,
28, 39, 44, 49, 42, 23, 5, 13,
17, 76, 7, 16, 15, 1, 6, 14,
124, 125, 126, 80, 86, 107, 108, 96,
95, 109, 91, 97, 103, 102, 101, 82,
83, 88, 87, 85, 79, 89, 104, 105,
100, 94, 115, 112, 106, 90, 118, 113,
114, 110, 111, 99, 98, 92, 93, 117,
116, 84, 81, 121, 120, 122, 123, 119,
59, 26, 54, 62, 56, 63, 11, 64,
57, 55, 58, 60, 70, 65, 61, 71,
73, 9, 75, 74, 77, 78, 47, 72,
8, 68, 12, 69, 66, 10, 127, 0,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Forward reference to base Unicode to ISO/IEC 8859 routine - see "zueci.c" */
static int zueci_u_iso8859(const zueci_u32 u, const zueci_u16 *tab_s, const zueci_u16 *tab_u_u,
const unsigned char *tab_u_sb, int e, unsigned char *dest);
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Forward reference to base ISO/IEC 8859 to Unicode routine - see "zueci.c" */
static int zueci_iso8859_u(const unsigned char c, const unsigned int flags, const zueci_u16 *tab_s,
const zueci_u16 *tab_u_u, const char *tab_sb_u, const int c2_max, zueci_u32 *p_u);
#endif
/* Tables for ECI 4 ISO/IEC 8859-2 */
static const zueci_u16 zueci_iso8859_2_s[6] = { /* Straight-thru bit-flags */
0x2191, 0x0111, 0x6A96, 0xB4D8, 0x6A96, 0x34D8,
};
static const zueci_u16 zueci_iso8859_2_u_u[57] = { /* Unicode codepoints sorted */
0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x010C, 0x010D,
0x010E, 0x010F, 0x0110, 0x0111, 0x0118, 0x0119, 0x011A, 0x011B,
0x0139, 0x013A, 0x013D, 0x013E, 0x0141, 0x0142, 0x0143, 0x0144,
0x0147, 0x0148, 0x0150, 0x0151, 0x0154, 0x0155, 0x0158, 0x0159,
0x015A, 0x015B, 0x015E, 0x015F, 0x0160, 0x0161, 0x0162, 0x0163,
0x0164, 0x0165, 0x016E, 0x016F, 0x0170, 0x0171, 0x0179, 0x017A,
0x017B, 0x017C, 0x017D, 0x017E, 0x02C7, 0x02D8, 0x02D9, 0x02DB,
0x02DD,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_2_u_sb[57] = { /* Single-byte in Unicode order */
0xC3, 0xE3, 0xA1, 0xB1, 0xC6, 0xE6, 0xC8, 0xE8,
0xCF, 0xEF, 0xD0, 0xF0, 0xCA, 0xEA, 0xCC, 0xEC,
0xC5, 0xE5, 0xA5, 0xB5, 0xA3, 0xB3, 0xD1, 0xF1,
0xD2, 0xF2, 0xD5, 0xF5, 0xC0, 0xE0, 0xD8, 0xF8,
0xA6, 0xB6, 0xAA, 0xBA, 0xA9, 0xB9, 0xDE, 0xFE,
0xAB, 0xBB, 0xD9, 0xF9, 0xDB, 0xFB, 0xAC, 0xBC,
0xAF, 0xBF, 0xAE, 0xBE, 0xB7, 0xA2, 0xFF, 0xB2,
0xBD,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_2_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 2, 53, 20, -1, 18, 32, -1,
-1, 36, 34, 40, 46, -1, 50, 48,
-1, 3, 55, 21, -1, 19, 33, 52,
-1, 37, 35, 41, 47, 56, 51, 49,
28, -1, -1, 0, -1, 16, 4, -1,
6, -1, 12, -1, 14, -1, -1, 8,
10, 22, 24, -1, -1, 26, -1, -1,
30, 42, -1, 44, -1, -1, 38, -1,
29, -1, -1, 1, -1, 17, 5, -1,
7, -1, 13, -1, 15, -1, -1, 9,
11, 23, 25, -1, -1, 27, -1, -1,
31, 43, -1, 45, -1, -1, 39, 54,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 4 ISO/IEC 8859-2 Latin alphabet No. 2 (Latin-2) */
static int zueci_u_iso8859_2(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_2_s, zueci_iso8859_2_u_u, zueci_iso8859_2_u_sb,
ZUECI_ASIZE(zueci_iso8859_2_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_2_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_2_s, zueci_iso8859_2_u_u, zueci_iso8859_2_sb_u,
ZUECI_ASIZE(zueci_iso8859_2_sb_u), p_u);
}
#endif
/* Tables for ECI 5 ISO/IEC 8859-3 */
static const zueci_u16 zueci_iso8859_3_s[6] = { /* Straight-thru bit-flags */
0x2199, 0x21BD, 0xFF97, 0x9EDE, 0xFF97, 0x1EDE,
};
static const zueci_u16 zueci_iso8859_3_u_u[28] = { /* Unicode codepoints sorted */
0x0108, 0x0109, 0x010A, 0x010B, 0x011C, 0x011D, 0x011E, 0x011F,
0x0120, 0x0121, 0x0124, 0x0125, 0x0126, 0x0127, 0x0130, 0x0131,
0x0134, 0x0135, 0x015C, 0x015D, 0x015E, 0x015F, 0x016C, 0x016D,
0x017B, 0x017C, 0x02D8, 0x02D9,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_3_u_sb[28] = { /* Single-byte in Unicode order */
0xC6, 0xE6, 0xC5, 0xE5, 0xD8, 0xF8, 0xAB, 0xBB,
0xD5, 0xF5, 0xA6, 0xB6, 0xA1, 0xB1, 0xA9, 0xB9,
0xAC, 0xBC, 0xDE, 0xFE, 0xAA, 0xBA, 0xDD, 0xFD,
0xAF, 0xBF, 0xA2, 0xFF,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_3_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 12, 26, -1, -1, -1, 10, -1,
-1, 14, 20, 6, 16, -1, -1, 24,
-1, 13, -1, -1, -1, -1, 11, -1,
-1, 15, 21, 7, 17, -1, -1, 25,
-1, -1, -1, -1, -1, 2, 0, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 8, -1, -1,
4, -1, -1, -1, -1, 22, 18, -1,
-1, -1, -1, -1, -1, 3, 1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 9, -1, -1,
5, -1, -1, -1, -1, 23, 19, 27,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 5 ISO/IEC 8859-3 Latin alphabet No. 3 (Latin-3) (South European) */
static int zueci_u_iso8859_3(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_3_s, zueci_iso8859_3_u_u, zueci_iso8859_3_u_sb,
ZUECI_ASIZE(zueci_iso8859_3_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_3_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_3_s, zueci_iso8859_3_u_u, zueci_iso8859_3_sb_u,
ZUECI_ASIZE(zueci_iso8859_3_sb_u), p_u);
}
#endif
/* Tables for ECI 6 ISO/IEC 8859-4 */
static const zueci_u16 zueci_iso8859_4_s[6] = { /* Straight-thru bit-flags */
0xA191, 0x0111, 0x6A7E, 0x9DF0, 0x6A7E, 0x1DF0,
};
static const zueci_u16 zueci_iso8859_4_u_u[50] = { /* Unicode codepoints sorted */
0x0100, 0x0101, 0x0104, 0x0105, 0x010C, 0x010D, 0x0110, 0x0111,
0x0112, 0x0113, 0x0116, 0x0117, 0x0118, 0x0119, 0x0122, 0x0123,
0x0128, 0x0129, 0x012A, 0x012B, 0x012E, 0x012F, 0x0136, 0x0137,
0x0138, 0x013B, 0x013C, 0x0145, 0x0146, 0x014A, 0x014B, 0x014C,
0x014D, 0x0156, 0x0157, 0x0160, 0x0161, 0x0166, 0x0167, 0x0168,
0x0169, 0x016A, 0x016B, 0x0172, 0x0173, 0x017D, 0x017E, 0x02C7,
0x02D9, 0x02DB,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_4_u_sb[50] = { /* Single-byte in Unicode order */
0xC0, 0xE0, 0xA1, 0xB1, 0xC8, 0xE8, 0xD0, 0xF0,
0xAA, 0xBA, 0xCC, 0xEC, 0xCA, 0xEA, 0xAB, 0xBB,
0xA5, 0xB5, 0xCF, 0xEF, 0xC7, 0xE7, 0xD3, 0xF3,
0xA2, 0xA6, 0xB6, 0xD1, 0xF1, 0xBD, 0xBF, 0xD2,
0xF2, 0xA3, 0xB3, 0xA9, 0xB9, 0xAC, 0xBC, 0xDD,
0xFD, 0xDE, 0xFE, 0xD9, 0xF9, 0xAE, 0xBE, 0xB7,
0xFF, 0xB2,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_4_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 2, 24, 33, -1, 16, 25, -1,
-1, 35, 8, 14, 37, -1, 45, -1,
-1, 3, 49, 34, -1, 17, 26, 47,
-1, 36, 9, 15, 38, 29, 46, 30,
0, -1, -1, -1, -1, -1, -1, 20,
4, -1, 12, -1, 10, -1, -1, 18,
6, 27, 31, 22, -1, -1, -1, -1,
-1, 43, -1, -1, -1, 39, 41, -1,
1, -1, -1, -1, -1, -1, -1, 21,
5, -1, 13, -1, 11, -1, -1, 19,
7, 28, 32, 23, -1, -1, -1, -1,
-1, 44, -1, -1, -1, 40, 42, 48,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 6 ISO/IEC 8859-4 Latin alphabet No. 4 (Latin-4) (North European) */
static int zueci_u_iso8859_4(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_4_s, zueci_iso8859_4_u_u, zueci_iso8859_4_u_sb,
ZUECI_ASIZE(zueci_iso8859_4_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_4_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_4_s, zueci_iso8859_4_u_u, zueci_iso8859_4_sb_u,
ZUECI_ASIZE(zueci_iso8859_4_sb_u), p_u);
}
#endif
/* Tables for ECI 7 ISO/IEC 8859-5 */
static const zueci_u16 zueci_iso8859_5_s[6] = { /* Straight-thru bit-flags */
0x2001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_iso8859_5_u_u[94] = { /* Unicode codepoints sorted */
0x00A7, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x040E, 0x040F, 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,
0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459,
0x045A, 0x045B, 0x045C, 0x045E, 0x045F, 0x2116,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_5_u_sb[94] = { /* Single-byte in Unicode order */
0xFD, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0xB0,
0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0,
0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8,
0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF1,
0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
0xFA, 0xFB, 0xFC, 0xFE, 0xFF, 0xF0,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_5_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, -1, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 78,
93, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 89, 90, 0, 91, 92,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 7 ISO/IEC 8859-5 Latin/Cyrillic */
static int zueci_u_iso8859_5(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_5_s, zueci_iso8859_5_u_u, zueci_iso8859_5_u_sb,
ZUECI_ASIZE(zueci_iso8859_5_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_5_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_5_s, zueci_iso8859_5_u_u, zueci_iso8859_5_sb_u,
ZUECI_ASIZE(zueci_iso8859_5_sb_u), p_u);
}
#endif
/* Tables for ECI 8 ISO/IEC 8859-6 */
static const zueci_u16 zueci_iso8859_6_s[6] = { /* Straight-thru bit-flags */
0x2011, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_iso8859_6_u_u[48] = { /* Unicode codepoints sorted */
0x060C, 0x061B, 0x061F, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625,
0x0626, 0x0627, 0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D,
0x062E, 0x062F, 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635,
0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0641, 0x0642,
0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A,
0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0x0650, 0x0651, 0x0652,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_6_u_sb[48] = { /* Single-byte in Unicode order */
0xAC, 0xBB, 0xBF, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5,
0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD,
0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5,
0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE0, 0xE1, 0xE2,
0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_6_sb_u[83] = { /* Single-byte sorted indexes into Unicode table */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 0, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 1, -1, -1, -1, 2,
-1, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, -1, -1, -1, -1, -1,
29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 8 ISO/IEC 8859-6 Latin/Arabic */
static int zueci_u_iso8859_6(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_6_s, zueci_iso8859_6_u_u, zueci_iso8859_6_u_sb,
ZUECI_ASIZE(zueci_iso8859_6_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_6_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_6_s, zueci_iso8859_6_u_u, zueci_iso8859_6_sb_u,
ZUECI_ASIZE(zueci_iso8859_6_sb_u), p_u);
}
#endif
/* Tables for ECI 9 ISO/IEC 8859-7 */
static const zueci_u16 zueci_iso8859_7_s[6] = { /* Straight-thru bit-flags */
0x3BC9, 0x288F, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_iso8859_7_u_u[77] = { /* Unicode codepoints sorted */
0x037A, 0x0384, 0x0385, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C,
0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395,
0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D,
0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6,
0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE,
0x03AF, 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6,
0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE,
0x03BF, 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6,
0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE,
0x2015, 0x2018, 0x2019, 0x20AC, 0x20AF,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_7_u_sb[77] = { /* Single-byte in Unicode order */
0xAA, 0xB4, 0xB5, 0xB6, 0xB8, 0xB9, 0xBA, 0xBC,
0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5,
0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD,
0xCE, 0xCF, 0xD0, 0xD1, 0xD3, 0xD4, 0xD5, 0xD6,
0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE,
0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE,
0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6,
0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE,
0xAF, 0xA1, 0xA2, 0xA4, 0xA5,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_7_sb_u[95] = { /* Single-byte sorted indexes into Unicode table */
-1, 73, 74, -1, 75, 76, -1, -1,
-1, -1, 0, -1, -1, -1, -1, 72,
-1, -1, -1, -1, 1, 2, 3, -1,
4, 5, 6, -1, 7, -1, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 9 ISO/IEC 8859-7 Latin/Greek */
static int zueci_u_iso8859_7(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_7_s, zueci_iso8859_7_u_u, zueci_iso8859_7_u_sb,
ZUECI_ASIZE(zueci_iso8859_7_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_7_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_7_s, zueci_iso8859_7_u_u, zueci_iso8859_7_sb_u,
ZUECI_ASIZE(zueci_iso8859_7_sb_u), p_u);
}
#endif
/* Tables for ECI 10 ISO/IEC 8859-8 */
static const zueci_u16 zueci_iso8859_8_s[6] = { /* Straight-thru bit-flags */
0xFBFD, 0x7BFF, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_iso8859_8_u_u[32] = { /* Unicode codepoints sorted */
0x00D7, 0x00F7, 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5,
0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD,
0x05DE, 0x05DF, 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5,
0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x200E, 0x200F, 0x2017,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_8_u_sb[32] = { /* Single-byte in Unicode order */
0xAA, 0xBA, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5,
0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED,
0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFD, 0xFE, 0xDF,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_8_sb_u[95] = { /* Single-byte sorted indexes into Unicode table */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 0, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 31,
2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, -1, -1, 29, 30,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 10 ISO/IEC 8859-8 Latin/Hebrew */
static int zueci_u_iso8859_8(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_8_s, zueci_iso8859_8_u_u, zueci_iso8859_8_u_sb,
ZUECI_ASIZE(zueci_iso8859_8_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_8_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_8_s, zueci_iso8859_8_u_u, zueci_iso8859_8_sb_u,
ZUECI_ASIZE(zueci_iso8859_8_sb_u), p_u);
}
#endif
/* Tables for ECI 11 ISO/IEC 8859-9 */
static const zueci_u16 zueci_iso8859_9_s[6] = { /* Straight-thru bit-flags */
0xFFFF, 0xFFFF, 0xFFFF, 0x9FFE, 0xFFFF, 0x9FFE,
};
static const zueci_u16 zueci_iso8859_9_u_u[6] = { /* Unicode codepoints sorted */
0x011E, 0x011F, 0x0130, 0x0131, 0x015E, 0x015F,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_9_u_sb[6] = { /* Single-byte in Unicode order */
0xD0, 0xF0, 0xDD, 0xFD, 0xDE, 0xFE,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_9_sb_u[95] = { /* Single-byte sorted indexes into Unicode table */
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
0, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 2, 4, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 3, 5,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 11 ISO/IEC 8859-9 Latin alphabet No. 5 (Latin-5) (Latin/Turkish) */
static int zueci_u_iso8859_9(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_9_s, zueci_iso8859_9_u_u, zueci_iso8859_9_u_sb,
ZUECI_ASIZE(zueci_iso8859_9_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_9_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_9_s, zueci_iso8859_9_u_u, zueci_iso8859_9_sb_u,
ZUECI_ASIZE(zueci_iso8859_9_sb_u), p_u);
}
#endif
/* Tables for ECI 12 ISO/IEC 8859-10 */
static const zueci_u16 zueci_iso8859_10_s[6] = { /* Straight-thru bit-flags */
0x2081, 0x0081, 0xEA7E, 0xFD79, 0xEA7E, 0x7D79,
};
static const zueci_u16 zueci_iso8859_10_u_u[46] = { /* Unicode codepoints sorted */
0x0100, 0x0101, 0x0104, 0x0105, 0x010C, 0x010D, 0x0110, 0x0111,
0x0112, 0x0113, 0x0116, 0x0117, 0x0118, 0x0119, 0x0122, 0x0123,
0x0128, 0x0129, 0x012A, 0x012B, 0x012E, 0x012F, 0x0136, 0x0137,
0x0138, 0x013B, 0x013C, 0x0145, 0x0146, 0x014A, 0x014B, 0x014C,
0x014D, 0x0160, 0x0161, 0x0166, 0x0167, 0x0168, 0x0169, 0x016A,
0x016B, 0x0172, 0x0173, 0x017D, 0x017E, 0x2015,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_10_u_sb[46] = { /* Single-byte in Unicode order */
0xC0, 0xE0, 0xA1, 0xB1, 0xC8, 0xE8, 0xA9, 0xB9,
0xA2, 0xB2, 0xCC, 0xEC, 0xCA, 0xEA, 0xA3, 0xB3,
0xA5, 0xB5, 0xA4, 0xB4, 0xC7, 0xE7, 0xA6, 0xB6,
0xFF, 0xA8, 0xB8, 0xD1, 0xF1, 0xAF, 0xBF, 0xD2,
0xF2, 0xAA, 0xBA, 0xAB, 0xBB, 0xD7, 0xF7, 0xAE,
0xBE, 0xD9, 0xF9, 0xAC, 0xBC, 0xBD,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_10_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 2, 8, 14, 18, 16, 22, -1,
25, 6, 33, 35, 43, -1, 39, 29,
-1, 3, 9, 15, 19, 17, 23, -1,
26, 7, 34, 36, 44, 45, 40, 30,
0, -1, -1, -1, -1, -1, -1, 20,
4, -1, 12, -1, 10, -1, -1, -1,
-1, 27, 31, -1, -1, -1, -1, 37,
-1, 41, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, 21,
5, -1, 13, -1, 11, -1, -1, -1,
-1, 28, 32, -1, -1, -1, -1, 38,
-1, 42, -1, -1, -1, -1, -1, 24,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 12 ISO/IEC 8859-10 Latin alphabet No. 6 (Latin-6) (Nordic) */
static int zueci_u_iso8859_10(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_10_s, zueci_iso8859_10_u_u, zueci_iso8859_10_u_sb,
ZUECI_ASIZE(zueci_iso8859_10_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_10_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_10_s, zueci_iso8859_10_u_u, zueci_iso8859_10_sb_u,
ZUECI_ASIZE(zueci_iso8859_10_sb_u), p_u);
}
#endif
/* Tables for ECI 13 ISO/IEC 8859-11 */
static const zueci_u16 zueci_iso8859_11_s[6] = { /* Straight-thru bit-flags */
0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_iso8859_11_u_u[87] = { /* Unicode codepoints sorted */
0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07, 0x0E08,
0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F, 0x0E10,
0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17, 0x0E18,
0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F, 0x0E20,
0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27, 0x0E28,
0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F, 0x0E30,
0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37, 0x0E38,
0x0E39, 0x0E3A, 0x0E3F, 0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44,
0x0E45, 0x0E46, 0x0E47, 0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C,
0x0E4D, 0x0E4E, 0x0E4F, 0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54,
0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59, 0x0E5A, 0x0E5B,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_11_u_sb[87] = { /* Single-byte in Unicode order */
0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0,
0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0,
0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
0xD9, 0xDA, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4,
0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC,
0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4,
0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_11_sb_u[92] = { /* Single-byte sorted indexes into Unicode table */
-1, 0, 1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, -1, -1, -1, -1, 58,
59, 60, 61, 62, 63, 64, 65, 66,
67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 13 ISO/IEC 8859-11 Latin/Thai */
static int zueci_u_iso8859_11(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_11_s, zueci_iso8859_11_u_u, zueci_iso8859_11_u_sb,
ZUECI_ASIZE(zueci_iso8859_11_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_11_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_11_s, zueci_iso8859_11_u_u, zueci_iso8859_11_sb_u,
ZUECI_ASIZE(zueci_iso8859_11_sb_u), p_u);
}
#endif
/* Tables for ECI 15 ISO/IEC 8859-13 */
static const zueci_u16 zueci_iso8859_13_s[6] = { /* Straight-thru bit-flags */
0x7ADD, 0x7AEF, 0x0230, 0x90E8, 0x0230, 0x10E8,
};
static const zueci_u16 zueci_iso8859_13_u_u[56] = { /* Unicode codepoints sorted */
0x00C6, 0x00D8, 0x00E6, 0x00F8, 0x0100, 0x0101, 0x0104, 0x0105,
0x0106, 0x0107, 0x010C, 0x010D, 0x0112, 0x0113, 0x0116, 0x0117,
0x0118, 0x0119, 0x0122, 0x0123, 0x012A, 0x012B, 0x012E, 0x012F,
0x0136, 0x0137, 0x013B, 0x013C, 0x0141, 0x0142, 0x0143, 0x0144,
0x0145, 0x0146, 0x014C, 0x014D, 0x0156, 0x0157, 0x015A, 0x015B,
0x0160, 0x0161, 0x016A, 0x016B, 0x0172, 0x0173, 0x0179, 0x017A,
0x017B, 0x017C, 0x017D, 0x017E, 0x2019, 0x201C, 0x201D, 0x201E,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_13_u_sb[56] = { /* Single-byte in Unicode order */
0xAF, 0xA8, 0xBF, 0xB8, 0xC2, 0xE2, 0xC0, 0xE0,
0xC3, 0xE3, 0xC8, 0xE8, 0xC7, 0xE7, 0xCB, 0xEB,
0xC6, 0xE6, 0xCC, 0xEC, 0xCE, 0xEE, 0xC1, 0xE1,
0xCD, 0xED, 0xCF, 0xEF, 0xD9, 0xF9, 0xD1, 0xF1,
0xD2, 0xF2, 0xD4, 0xF4, 0xAA, 0xBA, 0xDA, 0xFA,
0xD0, 0xF0, 0xDB, 0xFB, 0xD8, 0xF8, 0xCA, 0xEA,
0xDD, 0xFD, 0xDE, 0xFE, 0xFF, 0xB4, 0xA1, 0xA5,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_13_sb_u[96] = { /* Single-byte sorted indexes into Unicode table */
-1, 54, -1, -1, -1, 55, -1, -1,
1, -1, 36, -1, -1, -1, -1, 0,
-1, -1, -1, -1, 53, -1, -1, -1,
3, -1, 37, -1, -1, -1, -1, 2,
6, 22, 4, 8, -1, -1, 16, 12,
10, -1, 46, 14, 18, 24, 20, 26,
40, 30, 32, -1, 34, -1, -1, -1,
44, 28, 38, 42, -1, 48, 50, -1,
7, 23, 5, 9, -1, -1, 17, 13,
11, -1, 47, 15, 19, 25, 21, 27,
41, 31, 33, -1, 35, -1, -1, -1,
45, 29, 39, 43, -1, 49, 51, 52,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 15 ISO/IEC 8859-13 Latin alphabet No. 7 (Latin-7) (Baltic Rim) */
static int zueci_u_iso8859_13(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_13_s, zueci_iso8859_13_u_u, zueci_iso8859_13_u_sb,
ZUECI_ASIZE(zueci_iso8859_13_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_13_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_13_s, zueci_iso8859_13_u_u, zueci_iso8859_13_sb_u,
ZUECI_ASIZE(zueci_iso8859_13_sb_u), p_u);
}
#endif
/* Tables for ECI 16 ISO/IEC 8859-14 */
static const zueci_u16 zueci_iso8859_14_s[6] = { /* Straight-thru bit-flags */
0x6289, 0x0040, 0xFFFF, 0xBF7E, 0xFFFF, 0xBF7E,
};
static const zueci_u16 zueci_iso8859_14_u_u[31] = { /* Unicode codepoints sorted */
0x010A, 0x010B, 0x0120, 0x0121, 0x0174, 0x0175, 0x0176, 0x0177,
0x0178, 0x1E02, 0x1E03, 0x1E0A, 0x1E0B, 0x1E1E, 0x1E1F, 0x1E40,
0x1E41, 0x1E56, 0x1E57, 0x1E60, 0x1E61, 0x1E6A, 0x1E6B, 0x1E80,
0x1E81, 0x1E82, 0x1E83, 0x1E84, 0x1E85, 0x1EF2, 0x1EF3,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_14_u_sb[31] = { /* Single-byte in Unicode order */
0xA4, 0xA5, 0xB2, 0xB3, 0xD0, 0xF0, 0xDE, 0xFE,
0xAF, 0xA1, 0xA2, 0xA6, 0xAB, 0xB0, 0xB1, 0xB4,
0xB5, 0xB7, 0xB9, 0xBB, 0xBF, 0xD7, 0xF7, 0xA8,
0xB8, 0xAA, 0xBA, 0xBD, 0xBE, 0xAC, 0xBC,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_14_sb_u[95] = { /* Single-byte sorted indexes into Unicode table */
-1, 9, 10, -1, 0, 1, 11, -1,
23, -1, 25, 12, 29, -1, -1, 8,
13, 14, 2, 3, 15, 16, -1, 17,
24, 18, 26, 19, 30, 27, 28, 20,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
4, -1, -1, -1, -1, -1, -1, 21,
-1, -1, -1, -1, -1, -1, 6, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
5, -1, -1, -1, -1, -1, -1, 22,
-1, -1, -1, -1, -1, -1, 7,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 16 ISO/IEC 8859-14 Latin alphabet No. 8 (Latin-8) (Celtic) */
static int zueci_u_iso8859_14(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_14_s, zueci_iso8859_14_u_u, zueci_iso8859_14_u_sb,
ZUECI_ASIZE(zueci_iso8859_14_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_14_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_14_s, zueci_iso8859_14_u_u, zueci_iso8859_14_sb_u,
ZUECI_ASIZE(zueci_iso8859_14_sb_u), p_u);
}
#endif
/* Tables for ECI 17 ISO/IEC 8859-15 */
static const zueci_u16 zueci_iso8859_15_s[6] = { /* Straight-thru bit-flags */
0xFEAF, 0x8EEF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
};
static const zueci_u16 zueci_iso8859_15_u_u[8] = { /* Unicode codepoints sorted */
0x0152, 0x0153, 0x0160, 0x0161, 0x0178, 0x017D, 0x017E, 0x20AC,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_15_u_sb[8] = { /* Single-byte in Unicode order */
0xBC, 0xBD, 0xA6, 0xA8, 0xBE, 0xB4, 0xB8, 0xA4,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_15_sb_u[31] = { /* Single-byte sorted indexes into Unicode table */
-1, -1, -1, -1, 7, -1, 2, -1,
3, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 5, -1, -1, -1,
6, -1, -1, -1, 0, 1, 4,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 17 ISO/IEC 8859-15 Latin alphabet No. 9 (Latin-9) */
static int zueci_u_iso8859_15(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_15_s, zueci_iso8859_15_u_u, zueci_iso8859_15_u_sb,
ZUECI_ASIZE(zueci_iso8859_15_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_15_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_15_s, zueci_iso8859_15_u_u, zueci_iso8859_15_sb_u,
ZUECI_ASIZE(zueci_iso8859_15_sb_u), p_u);
}
#endif
/* Tables for ECI 18 ISO/IEC 8859-16 */
static const zueci_u16 zueci_iso8859_16_s[6] = { /* Straight-thru bit-flags */
0x2A81, 0x08C3, 0xFFD7, 0x9E5C, 0xFFD7, 0x9E5C,
};
static const zueci_u16 zueci_iso8859_16_u_u[40] = { /* Unicode codepoints sorted */
0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x010C, 0x010D,
0x0110, 0x0111, 0x0118, 0x0119, 0x0141, 0x0142, 0x0143, 0x0144,
0x0150, 0x0151, 0x0152, 0x0153, 0x015A, 0x015B, 0x0160, 0x0161,
0x0170, 0x0171, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D,
0x017E, 0x0218, 0x0219, 0x021A, 0x021B, 0x201D, 0x201E, 0x20AC,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_iso8859_16_u_sb[40] = { /* Single-byte in Unicode order */
0xC3, 0xE3, 0xA1, 0xA2, 0xC5, 0xE5, 0xB2, 0xB9,
0xD0, 0xF0, 0xDD, 0xFD, 0xA3, 0xB3, 0xD1, 0xF1,
0xD5, 0xF5, 0xBC, 0xBD, 0xD7, 0xF7, 0xA6, 0xA8,
0xD8, 0xF8, 0xBE, 0xAC, 0xAE, 0xAF, 0xBF, 0xB4,
0xB8, 0xAA, 0xBA, 0xDE, 0xFE, 0xB5, 0xA5, 0xA4,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_iso8859_16_sb_u[95] = { /* Single-byte sorted indexes into Unicode table */
-1, 2, 3, 12, 39, 38, 22, -1,
23, -1, 33, -1, 27, -1, 28, 29,
-1, -1, 6, 13, 31, 37, -1, -1,
32, 7, 34, -1, 18, 19, 26, 30,
-1, -1, -1, 0, -1, 4, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
8, 14, -1, -1, -1, 16, -1, 20,
24, -1, -1, -1, -1, 10, 35, -1,
-1, -1, -1, 1, -1, 5, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
9, 15, -1, -1, -1, 17, -1, 21,
25, -1, -1, -1, -1, 11, 36,
};
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 18 ISO/IEC 8859-16 Latin alphabet No. 10 (Latin-10) (South-Eastern European) */
static int zueci_u_iso8859_16(const zueci_u32 u, unsigned char *dest) {
return zueci_u_iso8859(u, zueci_iso8859_16_s, zueci_iso8859_16_u_u, zueci_iso8859_16_u_sb,
ZUECI_ASIZE(zueci_iso8859_16_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_iso8859_16_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
(void)len;
return zueci_iso8859_u(*src, flags, zueci_iso8859_16_s, zueci_iso8859_16_u_u, zueci_iso8859_16_sb_u,
ZUECI_ASIZE(zueci_iso8859_16_sb_u), p_u);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Forward reference to base Unicode to Windows-125x routine - see "zueci.c" */
static int zueci_u_cp125x(const zueci_u32 u, const zueci_u16 *tab_s, const zueci_u16 *tab_u_u,
const unsigned char *tab_u_sb, int e, unsigned char *dest);
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Forward reference to base Windows-125x to Unicode routine - see "zueci.c" */
static int zueci_cp125x_u(const unsigned char c, const unsigned int flags, const zueci_u16 *tab_s,
const zueci_u16 *tab_u_u, const char *tab_sb_u, const int c_max, zueci_u32 *p_u);
#endif
/* Tables for ECI 21 Windows 1250 */
static const zueci_u16 zueci_cp1250_s[6] = { /* Straight-thru bit-flags */
0x7BD1, 0x09F3, 0x6A96, 0xB4D8, 0x6A96, 0x34D8,
};
static const zueci_u16 zueci_cp1250_u_u[74] = { /* Unicode codepoints sorted */
0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x010C, 0x010D,
0x010E, 0x010F, 0x0110, 0x0111, 0x0118, 0x0119, 0x011A, 0x011B,
0x0139, 0x013A, 0x013D, 0x013E, 0x0141, 0x0142, 0x0143, 0x0144,
0x0147, 0x0148, 0x0150, 0x0151, 0x0154, 0x0155, 0x0158, 0x0159,
0x015A, 0x015B, 0x015E, 0x015F, 0x0160, 0x0161, 0x0162, 0x0163,
0x0164, 0x0165, 0x016E, 0x016F, 0x0170, 0x0171, 0x0179, 0x017A,
0x017B, 0x017C, 0x017D, 0x017E, 0x02C7, 0x02D8, 0x02D9, 0x02DB,
0x02DD, 0x2013, 0x2014, 0x2018, 0x2019, 0x201A, 0x201C, 0x201D,
0x201E, 0x2020, 0x2021, 0x2022, 0x2026, 0x2030, 0x2039, 0x203A,
0x20AC, 0x2122,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_cp1250_u_sb[74] = { /* Single-byte in Unicode order */
0xC3, 0xE3, 0xA5, 0xB9, 0xC6, 0xE6, 0xC8, 0xE8,
0xCF, 0xEF, 0xD0, 0xF0, 0xCA, 0xEA, 0xCC, 0xEC,
0xC5, 0xE5, 0xBC, 0xBE, 0xA3, 0xB3, 0xD1, 0xF1,
0xD2, 0xF2, 0xD5, 0xF5, 0xC0, 0xE0, 0xD8, 0xF8,
0x8C, 0x9C, 0xAA, 0xBA, 0x8A, 0x9A, 0xDE, 0xFE,
0x8D, 0x9D, 0xD9, 0xF9, 0xDB, 0xFB, 0x8F, 0x9F,
0xAF, 0xBF, 0x8E, 0x9E, 0xA1, 0xA2, 0xFF, 0xB2,
0xBD, 0x96, 0x97, 0x91, 0x92, 0x82, 0x93, 0x94,
0x84, 0x86, 0x87, 0x95, 0x85, 0x89, 0x8B, 0x9B,
0x80, 0x99,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_cp1250_sb_u[128] = { /* Single-byte sorted indexes into Unicode table */
72, -1, 61, -1, 64, 68, 65, 66,
-1, 69, 36, 70, 32, 40, 50, 46,
-1, 59, 60, 62, 63, 67, 57, 58,
-1, 73, 37, 71, 33, 41, 51, 47,
-1, 52, 53, 20, -1, 2, -1, -1,
-1, -1, 34, -1, -1, -1, -1, 48,
-1, -1, 55, 21, -1, -1, -1, -1,
-1, 3, 35, -1, 18, 56, 19, 49,
28, -1, -1, 0, -1, 16, 4, -1,
6, -1, 12, -1, 14, -1, -1, 8,
10, 22, 24, -1, -1, 26, -1, -1,
30, 42, -1, 44, -1, -1, 38, -1,
29, -1, -1, 1, -1, 17, 5, -1,
7, -1, 13, -1, 15, -1, -1, 9,
11, 23, 25, -1, -1, 27, -1, -1,
31, 43, -1, 45, -1, -1, 39, 54,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 21 Windows-1250 Latin 2 (Central Europe) */
static int zueci_u_cp1250(const zueci_u32 u, unsigned char *dest) {
return zueci_u_cp125x(u, zueci_cp1250_s, zueci_cp1250_u_u, zueci_cp1250_u_sb,
ZUECI_ASIZE(zueci_cp1250_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_cp1250_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
(void)len;
return zueci_cp125x_u(*src, flags, zueci_cp1250_s, zueci_cp1250_u_u, zueci_cp1250_sb_u,
ZUECI_ASIZE(zueci_cp1250_sb_u) + 0x80, p_u);
}
#endif
/* Tables for ECI 22 Windows 1251 */
static const zueci_u16 zueci_cp1251_s[6] = { /* Straight-thru bit-flags */
0x7AD1, 0x08E3, 0x0000, 0x0000, 0x0000, 0x0000,
};
static const zueci_u16 zueci_cp1251_u_u[112] = { /* Unicode codepoints sorted */
0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408,
0x0409, 0x040A, 0x040B, 0x040C, 0x040E, 0x040F, 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, 0x0452,
0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A,
0x045B, 0x045C, 0x045E, 0x045F, 0x0490, 0x0491, 0x2013, 0x2014,
0x2018, 0x2019, 0x201A, 0x201C, 0x201D, 0x201E, 0x2020, 0x2021,
0x2022, 0x2026, 0x2030, 0x2039, 0x203A, 0x20AC, 0x2116, 0x2122,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_cp1251_u_sb[112] = { /* Single-byte in Unicode order */
0xA8, 0x80, 0x81, 0xAA, 0xBD, 0xB2, 0xAF, 0xA3,
0x8A, 0x8C, 0x8E, 0x8D, 0xA1, 0x8F, 0xC0, 0xC1,
0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1,
0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1,
0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1,
0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xB8, 0x90,
0x83, 0xBA, 0xBE, 0xB3, 0xBF, 0xBC, 0x9A, 0x9C,
0x9E, 0x9D, 0xA2, 0x9F, 0xA5, 0xB4, 0x96, 0x97,
0x91, 0x92, 0x82, 0x93, 0x94, 0x84, 0x86, 0x87,
0x95, 0x85, 0x89, 0x8B, 0x9B, 0x88, 0xB9, 0x99,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_cp1251_sb_u[128] = { /* Single-byte sorted indexes into Unicode table */
1, 2, 98, 80, 101, 105, 102, 103,
109, 106, 8, 107, 9, 11, 10, 13,
79, 96, 97, 99, 100, 104, 94, 95,
-1, 111, 86, 108, 87, 89, 88, 91,
-1, 12, 90, 7, -1, 92, -1, -1,
0, -1, 3, -1, -1, -1, -1, 6,
-1, -1, 5, 83, 93, -1, -1, -1,
78, 110, 81, -1, 85, 4, 82, 84,
14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 77,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 22 Windows-1251 Cyrillic */
static int zueci_u_cp1251(const zueci_u32 u, unsigned char *dest) {
return zueci_u_cp125x(u, zueci_cp1251_s, zueci_cp1251_u_u, zueci_cp1251_u_sb,
ZUECI_ASIZE(zueci_cp1251_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_cp1251_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
(void)len;
return zueci_cp125x_u(*src, flags, zueci_cp1251_s, zueci_cp1251_u_u, zueci_cp1251_sb_u,
ZUECI_ASIZE(zueci_cp1251_sb_u) + 0x80, p_u);
}
#endif
/* Tables for ECI 23 Windows 1252 */
static const zueci_u16 zueci_cp1252_s[6] = { /* Straight-thru bit-flags */
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
};
static const zueci_u16 zueci_cp1252_u_u[27] = { /* Unicode codepoints sorted */
0x0152, 0x0153, 0x0160, 0x0161, 0x0178, 0x017D, 0x017E, 0x0192,
0x02C6, 0x02DC, 0x2013, 0x2014, 0x2018, 0x2019, 0x201A, 0x201C,
0x201D, 0x201E, 0x2020, 0x2021, 0x2022, 0x2026, 0x2030, 0x2039,
0x203A, 0x20AC, 0x2122,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_cp1252_u_sb[27] = { /* Single-byte in Unicode order */
0x8C, 0x9C, 0x8A, 0x9A, 0x9F, 0x8E, 0x9E, 0x83,
0x88, 0x98, 0x96, 0x97, 0x91, 0x92, 0x82, 0x93,
0x94, 0x84, 0x86, 0x87, 0x95, 0x85, 0x89, 0x8B,
0x9B, 0x80, 0x99,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_cp1252_sb_u[32] = { /* Single-byte sorted indexes into Unicode table */
25, -1, 14, 7, 17, 21, 18, 19,
8, 22, 2, 23, 0, -1, 5, -1,
-1, 12, 13, 15, 16, 20, 10, 11,
9, 26, 3, 24, 1, -1, 6, 4,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 23 Windows-1252 Latin 1 */
static int zueci_u_cp1252(const zueci_u32 u, unsigned char *dest) {
return zueci_u_cp125x(u, zueci_cp1252_s, zueci_cp1252_u_u, zueci_cp1252_u_sb,
ZUECI_ASIZE(zueci_cp1252_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_cp1252_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
(void)len;
return zueci_cp125x_u(*src, flags, zueci_cp1252_s, zueci_cp1252_u_u, zueci_cp1252_sb_u,
ZUECI_ASIZE(zueci_cp1252_sb_u) + 0x80, p_u);
}
#endif
/* Tables for ECI 24 Windows 1256 */
static const zueci_u16 zueci_cp1256_s[6] = { /* Straight-thru bit-flags */
0xFBFD, 0x7BFF, 0x0000, 0x0080, 0xCF85, 0x1A90,
};
static const zueci_u16 zueci_cp1256_u_u[85] = { /* Unicode codepoints sorted */
0x0152, 0x0153, 0x0192, 0x02C6, 0x060C, 0x061B, 0x061F, 0x0621,
0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628, 0x0629,
0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F, 0x0630, 0x0631,
0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 0x0638, 0x0639,
0x063A, 0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646,
0x0647, 0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E,
0x064F, 0x0650, 0x0651, 0x0652, 0x0679, 0x067E, 0x0686, 0x0688,
0x0691, 0x0698, 0x06A9, 0x06AF, 0x06BA, 0x06BE, 0x06C1, 0x06D2,
0x200C, 0x200D, 0x200E, 0x200F, 0x2013, 0x2014, 0x2018, 0x2019,
0x201A, 0x201C, 0x201D, 0x201E, 0x2020, 0x2021, 0x2022, 0x2026,
0x2030, 0x2039, 0x203A, 0x20AC, 0x2122,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
static const unsigned char zueci_cp1256_u_sb[85] = { /* Single-byte in Unicode order */
0x8C, 0x9C, 0x83, 0x88, 0xA1, 0xBA, 0xBF, 0xC1,
0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1,
0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD8, 0xD9, 0xDA,
0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE1, 0xE3, 0xE4,
0xE5, 0xE6, 0xEC, 0xED, 0xF0, 0xF1, 0xF2, 0xF3,
0xF5, 0xF6, 0xF8, 0xFA, 0x8A, 0x81, 0x8D, 0x8F,
0x9A, 0x8E, 0x98, 0x90, 0x9F, 0xAA, 0xC0, 0xFF,
0x9D, 0x9E, 0xFD, 0xFE, 0x96, 0x97, 0x91, 0x92,
0x82, 0x93, 0x94, 0x84, 0x86, 0x87, 0x95, 0x85,
0x89, 0x8B, 0x9B, 0x80, 0x99,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
static const char zueci_cp1256_sb_u[128] = { /* Single-byte sorted indexes into Unicode table */
83, 53, 72, 2, 75, 79, 76, 77,
3, 80, 52, 81, 0, 54, 57, 55,
59, 70, 71, 73, 74, 78, 68, 69,
58, 84, 56, 82, 1, 64, 65, 60,
-1, 4, -1, -1, -1, -1, -1, -1,
-1, -1, 61, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 5, -1, -1, -1, -1, 6,
62, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, -1,
29, 30, 31, 32, 33, 34, 35, 36,
-1, 37, -1, 38, 39, 40, 41, -1,
-1, -1, -1, -1, 42, 43, -1, -1,
44, 45, 46, 47, -1, 48, 49, -1,
50, -1, 51, -1, -1, 66, 67, 63,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* ECI 24 Windows-1256 Arabic */
static int zueci_u_cp1256(const zueci_u32 u, unsigned char *dest) {
return zueci_u_cp125x(u, zueci_cp1256_s, zueci_cp1256_u_u, zueci_cp1256_u_sb,
ZUECI_ASIZE(zueci_cp1256_u_u) - 1, dest);
}
#endif
#ifndef ZUECI_EMBED_NO_TO_UTF8
static int zueci_cp1256_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
(void)len;
return zueci_cp125x_u(*src, flags, zueci_cp1256_s, zueci_cp1256_u_u, zueci_cp1256_sb_u,
ZUECI_ASIZE(zueci_cp1256_sb_u) + 0x80, p_u);
}
#endif
#endif /* ZUECI_SB_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_sb.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 28,996
|
```objective-c
/* ksx1001.h - tables for Unicode to/from ECI 30 EUC-KR (KS X 1001), generated by "tools/gen_zueci_mb_h.php" from
"path_to_url" */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_KSX1001_H
#define ZUECI_KSX1001_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode usage bit-flags for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_ksx1001_uro_u[1306] = {
0x2F8B, 0x4372, 0x2000, 0x0B04, 0xE82C, 0xE340, 0x2800, 0x40C8,
0x5944, 0x4937, 0x7976, 0x0440, 0x2C93, 0xA3F0, 0x0038, 0x08C5,
0xEE02, 0x0003, 0x8000, 0x3550, 0xE1C8, 0x1E23, 0x8200, 0xC449,
0xAD5A, 0x2942, 0xC000, 0x8060, 0x461C, 0xA49A, 0xC003, 0x052A,
0x2A44, 0xD646, 0x3DDA, 0x0800, 0x8388, 0x1420, 0x0020, 0x0170,
0x2021, 0x0302, 0x3000, 0x40AC, 0x8620, 0x4462, 0x20A0, 0x8A00,
0x0253, 0x8004, 0x0402, 0x1484, 0x7BFB, 0x1004, 0x7FA4, 0x11E2,
0x2441, 0x00A4, 0x1421, 0x20C0, 0x3A50, 0x7000, 0x0002, 0x2743,
0x45C9, 0x2082, 0x4630, 0x0FC1, 0x3C88, 0x2850, 0x8602, 0xA024,
0x2388, 0x8806, 0x0E19, 0x4000, 0x22AA, 0xEB64, 0x001C, 0xCD28,
0xA120, 0x02E1, 0x840B, 0x8200, 0x279B, 0x549E, 0x8141, 0xA0B3,
0x0010, 0x8508, 0x2061, 0x0800, 0x2F08, 0x08D0, 0xBE3E, 0x010F,
0xF718, 0xA803, 0x0A41, 0x5B08, 0x0504, 0x0002, 0x0500, 0x382A,
0x5041, 0x0001, 0x1910, 0x2108, 0x0313, 0x0000, 0x6122, 0x0404,
0x40D0, 0x1001, 0x8000, 0x4022, 0x8050, 0x4048, 0x0008, 0x1000,
0x06D1, 0x3700, 0x5E80, 0x0000, 0x00A0, 0x9410, 0x0018, 0x6000,
0x0240, 0x0090, 0x8000, 0x0054, 0x0000, 0x0008, 0x0900, 0x0010,
0x0040, 0x0000, 0x5020, 0x1010, 0x2400, 0x4C02, 0x0001, 0x0601,
0x2918, 0x814C, 0x2100, 0x0801, 0x6485, 0x0003, 0x4452, 0x1021,
0x0904, 0x0008, 0x000D, 0x0000, 0x4988, 0x8000, 0x0001, 0x1691,
0x0765, 0x4000, 0x8492, 0x0433, 0x8C00, 0x4592, 0x0016, 0x5220,
0x0228, 0xD008, 0x4300, 0x4C08, 0x40A2, 0xC32A, 0x9810, 0x2E00,
0x8000, 0x1670, 0x6E84, 0x4082, 0xC390, 0x04B3, 0x7C85, 0x2118,
0x041C, 0x02C8, 0x1120, 0x4A00, 0x0A48, 0x361B, 0x5540, 0x8900,
0x000A, 0x9902, 0x0221, 0x1040, 0x0242, 0x0400, 0x0044, 0x0000,
0x0000, 0x0C04, 0x0010, 0x0000, 0x1216, 0x0000, 0x0242, 0x0000,
0x1A20, 0x0040, 0x0400, 0x0000, 0x0009, 0xB5B3, 0x0A18, 0x1523,
0x9BA0, 0x1FE8, 0x507C, 0x8379, 0x10FD, 0xC09D, 0xDBF6, 0x0560,
0xEF92, 0x0242, 0x0110, 0xDF02, 0x6961, 0x0822, 0x9035, 0x0202,
0x0000, 0x0003, 0x1A02, 0x45AA, 0x0001, 0x0200, 0x8101, 0x2851,
0x6080, 0x02D2, 0x0280, 0x0000, 0x1800, 0x0001, 0x9200, 0x0000,
0x0880, 0x2000, 0x0405, 0x3500, 0x2000, 0x6044, 0x49E6, 0x609E,
0x104C, 0x2A42, 0x2820, 0xA148, 0x10B1, 0x8020, 0x000E, 0x7B9C,
0x8490, 0x14A0, 0x28C1, 0x41E0, 0x0704, 0x8C49, 0x100D, 0x0CC8,
0x8412, 0x89BA, 0x02C0, 0x1422, 0x5500, 0x0AC0, 0x3EC4, 0x9283,
0x1CA3, 0x4387, 0x4703, 0x22A0, 0x3028, 0x03C0, 0x0801, 0xA020,
0x8000, 0x3044, 0x85A3, 0x0000, 0x200E, 0x2225, 0xB73C, 0x0001,
0x3220, 0x8C50, 0x0099, 0x315D, 0x00A0, 0x9402, 0x0003, 0x0E4B,
0xE342, 0x8C20, 0x0080, 0xD091, 0x1D94, 0xA328, 0x499C, 0x60C1,
0x4406, 0x0713, 0x5A90, 0x4444, 0x0F88, 0x0000, 0x0040, 0x95C4,
0x7581, 0x8447, 0x4402, 0xC053, 0x2B83, 0x0108, 0x4000, 0x9242,
0x0611, 0x09A6, 0x0800, 0x3222, 0xB384, 0x1BDD, 0xF000, 0xC08A,
0x0282, 0x0002, 0x8800, 0x6C00, 0x9200, 0x0021, 0x4180, 0x8C84,
0x1308, 0x0944, 0x07A7, 0x0000, 0x8051, 0x0C41, 0x6002, 0x00D0,
0xA000, 0x10D0, 0x3004, 0x4400, 0x0000, 0x0100, 0x8201, 0x0700,
0x0100, 0x440E, 0x6830, 0x0805, 0x64B2, 0x0514, 0x10E6, 0x4414,
0x0011, 0x2100, 0x9C08, 0xCBC0, 0xE120, 0x40C2, 0x304C, 0x41B4,
0x10AC, 0x9A83, 0x98B2, 0x3281, 0x9822, 0x0084, 0x3369, 0xBC12,
0xD6C0, 0xC03B, 0xA1A1, 0x0C53, 0x8A1E, 0xEA00, 0xCBF0, 0x05D8,
0x4390, 0x21C3, 0x4805, 0x4A1C, 0x02D0, 0x3240, 0x0041, 0xD79D,
0x2B09, 0xE8B0, 0x7DC0, 0x2452, 0xC240, 0xD04B, 0xA000, 0xC8AB,
0x8A80, 0x34A9, 0x8000, 0x41C9, 0x8010, 0x241F, 0x9200, 0x487B,
0x0000, 0x00CC, 0x8406, 0x3300, 0x410F, 0x001B, 0x2000, 0x8040,
0x8022, 0xA098, 0xA186, 0x006B, 0x2A30, 0x85A4, 0x4181, 0x0604,
0x6021, 0x0004, 0x0080, 0xA001, 0x0400, 0x46B8, 0xE90F, 0x03A0,
0x0000, 0x1820, 0x40A0, 0x0810, 0x380A, 0x0001, 0x0500, 0xA800,
0x0404, 0xC28A, 0x000A, 0x2720, 0x0910, 0x830C, 0x0802, 0x0000,
0x6211, 0x1080, 0x000C, 0x0808, 0x000C, 0x0C08, 0x0000, 0x0840,
0x1410, 0x0044, 0x000B, 0x6404, 0x50C0, 0x8001, 0x047E, 0x8984,
0x0658, 0x4140, 0xC000, 0x94A4, 0xA862, 0x09DC, 0x1800, 0x0000,
0x8100, 0x000A, 0x0008, 0x4190, 0x4007, 0xE4A1, 0x2501, 0x6445,
0x11EE, 0x0E7D, 0x4800, 0xFB08, 0x1616, 0x08A8, 0xC92E, 0x0009,
0x1800, 0x4A82, 0x06A0, 0x6B64, 0x0002, 0x1600, 0x5648, 0x8390,
0x73A0, 0x002A, 0x8000, 0x0024, 0x88F9, 0x4702, 0x4D02, 0x0FAA,
0x0000, 0x8E80, 0xB87B, 0x7554, 0x2418, 0xD940, 0xC880, 0x040C,
0x0000, 0xB041, 0x8C24, 0x0442, 0x5A34, 0x001A, 0x8000, 0xC110,
0x8046, 0x0032, 0x180D, 0x8106, 0x0002, 0xCD92, 0x6014, 0x7401,
0x6112, 0x0091, 0xC098, 0x420A, 0x040F, 0x8420, 0x9A13, 0x4002,
0x8A62, 0xFD22, 0x8188, 0x4080, 0x1000, 0x2103, 0x0808, 0x3101,
0x4420, 0x0704, 0xB812, 0x0388, 0x8900, 0xA300, 0x0000, 0x2202,
0x1210, 0x4600, 0x0042, 0x0041, 0x5680, 0x5241, 0x52F0, 0x2000,
0x8610, 0x8214, 0x1004, 0x4602, 0x430A, 0x8035, 0x60E0, 0xD800,
0x0041, 0x0801, 0x3400, 0x6C65, 0x11C1, 0xAB04, 0x0286, 0x2204,
0x0003, 0x0000, 0x9084, 0x0000, 0x4015, 0x0281, 0x0202, 0x3300,
0x0400, 0x3840, 0x0E20, 0xC0C0, 0x0030, 0x0085, 0x0500, 0x0D25,
0x4AD0, 0x81D0, 0x2280, 0x020C, 0xB605, 0x6240, 0x2679, 0x6280,
0x02EA, 0x0808, 0xDD67, 0x8579, 0x081B, 0xDEA0, 0x8735, 0x4000,
0x0A8C, 0xD100, 0x05AA, 0xA225, 0x8440, 0x1510, 0x404D, 0x0080,
0x0012, 0x8D22, 0x1968, 0x058F, 0x9080, 0x3A1A, 0x8464, 0x8561,
0xCCC0, 0x2002, 0x0820, 0x732E, 0x20A4, 0x0B34, 0x0004, 0x1415,
0x2001, 0x8200, 0x0057, 0x0800, 0x5004, 0x0044, 0x1212, 0x7905,
0x40D0, 0x0009, 0x4000, 0x8400, 0x054C, 0xD844, 0x409A, 0x5114,
0x0B12, 0x4000, 0x0201, 0x1580, 0x2001, 0x0800, 0x084A, 0xC200,
0x0800, 0x4002, 0x3020, 0x9809, 0x0000, 0x1880, 0xE22C, 0x0008,
0x0004, 0x0004, 0x10E0, 0x0014, 0x8020, 0x2000, 0x9800, 0x1000,
0x7082, 0x0082, 0x0288, 0x1C00, 0x4C22, 0x0001, 0x9100, 0x0820,
0x4002, 0x0040, 0x1C00, 0x4400, 0x0383, 0x7CC1, 0x2121, 0x8400,
0xE002, 0x0002, 0x44C0, 0xE20A, 0x0E03, 0x8126, 0x02D0, 0x0800,
0x2921, 0x9690, 0x4001, 0xB8C2, 0x6241, 0x0080, 0x0A06, 0xA651,
0x0112, 0x812C, 0xC600, 0x0400, 0x0CB0, 0xA280, 0xA429, 0x8640,
0x8000, 0x4A02, 0x3041, 0x0200, 0xBA40, 0x0057, 0x5001, 0x2020,
0x8880, 0x24B0, 0x2002, 0x0112, 0x02D3, 0x0004, 0x0211, 0x0000,
0x0080, 0x4004, 0x0C82, 0xE000, 0x3008, 0x0000, 0x1011, 0x0008,
0x0208, 0x81A4, 0x40A0, 0x420E, 0x0400, 0xC040, 0x0081, 0x4800,
0x2DF5, 0x0F91, 0xD807, 0x0629, 0x007C, 0x4001, 0x4546, 0x824E,
0xC000, 0x1008, 0x3005, 0xED36, 0x0C80, 0x6540, 0x930B, 0x0810,
0x0600, 0xE820, 0xC80A, 0x6082, 0x00CA, 0x4034, 0x2E02, 0x1201,
0x9004, 0x1948, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0540, 0x1000, 0x0031, 0x4C00, 0x02A5,
0x5520, 0x4410, 0x0310, 0x2304, 0x5422, 0x8034, 0x0A03, 0x1201,
0x126B, 0x01A1, 0x2000, 0xA048, 0x0448, 0x4540, 0x8000, 0xE08D,
0x1AF0, 0x2840, 0x8626, 0x0416, 0x5018, 0x4C00, 0x0032, 0x2112,
0x05E4, 0x0D00, 0x8A08, 0x4200, 0x4800, 0x0033, 0x0860, 0x8703,
0x8501, 0x3400, 0x0109, 0xE428, 0x2045, 0x8100, 0x25A8, 0x5C18,
0x35A0, 0xD804, 0x1C02, 0x02E0, 0x00A1, 0x0200, 0xC050, 0x4146,
0x6800, 0xA604, 0xF260, 0xBB8A, 0x0000, 0xC8B6, 0x00E2, 0x6002,
0x023E, 0x0080, 0x8900, 0x0372, 0x8681, 0x0006, 0x0000, 0x0888,
0x4600, 0x4140, 0x0E04, 0x2000, 0x1622, 0x1048, 0x8A00, 0x2217,
0x7418, 0x0000, 0x1200, 0x2102, 0x0200, 0x0880, 0x984A, 0x0420,
0x0000, 0x1211, 0x0002, 0x9904, 0x2A55, 0x0402, 0x5000, 0x1010,
0x0000, 0x459A, 0xB02A, 0xA000, 0x420A, 0x0208, 0x2708, 0x0000,
0x8090, 0x0812, 0x8740, 0x0401, 0xE202, 0x3020, 0x0630, 0x8C80,
0x04C4, 0x04C0, 0x2000, 0x8000, 0x4000, 0xD831, 0x0080, 0x0200,
0x1400, 0x0008, 0x0218, 0x0000, 0x0880, 0x8A10, 0x2010, 0x4000,
0x010D, 0x1500, 0x0000, 0x0000, 0x4000, 0x80A0, 0x0140, 0x0150,
0x2004, 0x8000, 0x0004, 0x0408, 0x0010, 0x0000, 0x9001, 0x4A04,
0x0020, 0x8000, 0x000C, 0x0842, 0x3041, 0x2A8C, 0x090E, 0xC085,
0x2906, 0x40C4, 0x0800, 0x0010, 0x8006, 0xB230, 0x0102, 0x2138,
0x0080, 0x030D, 0x0420, 0x0940, 0x0012, 0x8000, 0x0410, 0x8004,
0x88CA, 0x0048, 0x0602, 0x2404, 0x0001, 0x0004, 0x0008, 0x0110,
0x550D, 0xA9C8, 0x2428, 0x0C52, 0x0000, 0x4831, 0x624D, 0x022F,
0x30A0, 0x4128, 0x057B, 0xD205, 0xA894, 0x1844, 0x6CC2, 0x45C2,
0x4017, 0x2ED1, 0x1901, 0x0208, 0xC202, 0x1500, 0x9040, 0x2091,
0x0401, 0x044D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x8080, 0x1542, 0x0420, 0x0C02, 0x0600,
0x1404, 0x6000, 0x9F87, 0xB9D9, 0x059F, 0x540A, 0x245D, 0x3810,
0x25B0, 0x0048, 0x0000, 0x0000, 0x0000, 0x0000, 0x0850, 0x0099,
0x0420, 0x0200, 0x0108, 0x4408, 0x9840, 0x2800, 0x810A, 0x0008,
0x8400, 0x4001, 0x0400, 0x0021, 0x0794, 0x8200, 0x0001, 0x0050,
0x2482, 0x0000, 0x1C00, 0x0000, 0x3C01, 0x8004, 0x0800, 0x4900,
0x0228, 0xF83C, 0x86C0, 0xCB08, 0x6230, 0xA000, 0x0004, 0x0000,
0x0000, 0x1800, 0xA148, 0x0007, 0x4024, 0x0012, 0x2C40, 0x2285,
0xA96F, 0xE6B3, 0x400F, 0x5126, 0x6C86, 0x723B, 0xE20B, 0xB5A4,
0x859F, 0x0222, 0x854C, 0x0123, 0x0402, 0x4000, 0x2102, 0x2020,
0x0004, 0x0224, 0x2080, 0x0004, 0x7E00, 0x0004, 0x1604, 0x01A0,
0x2A80, 0x1004, 0xD800, 0x0032, 0xFA81, 0x3183, 0x0488, 0x0020,
0x2000, 0x4087, 0x0000, 0x8410, 0x0221, 0x4880, 0x0074, 0x0000,
0x0029, 0x114A, 0x0000, 0x02C8, 0x9000, 0x0004, 0x0410, 0x1100,
0x0010, 0xC501, 0xC957, 0x0000, 0x2D00, 0x0810, 0x4000, 0x5020,
0x1000, 0x0450, 0x3088, 0x0001, 0x0008, 0x4002, 0x0012, 0x0040,
0x0010, 0x0100, 0x0820, 0x0120, 0x0010, 0x0806, 0x0000, 0xA000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080,
0x8A09, 0x011E, 0x2138, 0x1802, 0x0480, 0x1070, 0x0006, 0x0000,
0x0000, 0x1000, 0x4402, 0x8804, 0x3815, 0xF801, 0x041C, 0x21E9,
0x6C60, 0x1B30, 0x0588, 0x0882, 0x7AF3, 0x1A60, 0x870C, 0x0AC5,
0x00C1, 0x524A, 0x0080, 0x2205, 0x0114, 0x5042, 0x2206, 0x0490,
0xA800, 0x0000, 0x2901, 0x0000, 0x0840, 0x1008, 0x0000, 0x8848,
0x156F, 0x018F, 0x2000, 0x0B01, 0x7040, 0x4510, 0x88A0, 0x0000,
0x0000, 0x0000, 0x8100, 0x0002, 0x0090, 0x9800, 0xE006, 0x7010,
0x1608, 0x4109, 0x0101, 0x0000, 0x3A20, 0x0096, 0x0000, 0x0000,
0x0000, 0x2240, 0x7120, 0x021A, 0x0002, 0xA227, 0x2000, 0x8002,
0xC102, 0x0200, 0x0800, 0x00C1, 0x2029, 0x8CA0, 0x0624, 0x0000,
0x0000, 0x0000, 0x0100, 0x0100, 0x0000, 0x0118, 0x4020, 0x0000,
0x0000, 0x0400, 0x0480, 0x1002, 0x803E, 0x0410, 0x8000, 0x0000,
0x4000, 0x8002, 0x4800, 0x0000, 0x0200, 0x0040, 0x0110, 0x0000,
0x2000, 0x0025, 0x0020, 0x0804, 0x0280, 0x0080, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x02A0, 0x0058,
0x0200, 0x0800, 0x0140, 0x0800, 0x0000, 0x2002, 0x1003, 0x0004,
0x0000, 0x0000, 0x8200, 0x0010, 0x0010, 0x0080, 0x0000, 0x0704,
0x0000, 0x4400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA220,
0x0000, 0xA08C, 0x0020, 0x4830, 0x6008, 0x5912, 0x0100, 0x0010,
0x4180, 0x0008, 0x0001, 0x0800, 0x4C00, 0x8004, 0x1482, 0x0080,
0x2000, 0x1021,
};
/* Multibyte indexes for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_ksx1001_uro_mb_ind[1306] = {
889, 898, 905, 906, 910, 917, 923, 925,
929, 935, 943, 953, 955, 962, 970, 973,
978, 985, 987, 988, 994, 1001, 1008, 1010,
1016, 1025, 1030, 1032, 1035, 1041, 1048, 1052,
1057, 1062, 1070, 1080, 1081, 1086, 1089, 1090,
1094, 1097, 1100, 1102, 1107, 1111, 1116, 1119,
1122, 1127, 1129, 1131, 1135, 1148, 1150, 1160,
1166, 1170, 1173, 1177, 1180, 1186, 1189, 1190,
1197, 1204, 1207, 1212, 1219, 1225, 1229, 1233,
1237, 1242, 1246, 1252, 1253, 1259, 1268, 1271,
1278, 1282, 1287, 1292, 1294, 1303, 1311, 1315,
1322, 1323, 1327, 1331, 1332, 1338, 1342, 1353,
1358, 1367, 1372, 1376, 1382, 1385, 1386, 1388,
1394, 1398, 1399, 1403, 1406, 1411, 1411, 1416,
1418, 1422, 1424, 1425, 1428, 1431, 1434, 1435,
1436, 1442, 1447, 1453, 1453, 1455, 1459, 1461,
1463, 1465, 1467, 1468, 1471, 1471, 1472, 1474,
1475, 1476, 1476, 1479, 1481, 1483, 1487, 1488,
1491, 1496, 1501, 1503, 1505, 1511, 1513, 1518,
1521, 1524, 1525, 1528, 1528, 1533, 1534, 1535,
1541, 1548, 1549, 1554, 1559, 1562, 1568, 1571,
1575, 1578, 1582, 1585, 1589, 1593, 1600, 1604,
1608, 1609, 1615, 1622, 1625, 1631, 1637, 1645,
1649, 1653, 1657, 1660, 1663, 1667, 1675, 1680,
1683, 1685, 1690, 1693, 1695, 1698, 1699, 1701,
1701, 1701, 1704, 1705, 1705, 1710, 1710, 1713,
1713, 1717, 1718, 1719, 1719, 1721, 1731, 1735,
1741, 1748, 1757, 1764, 1772, 1780, 1787, 1799,
1803, 1813, 1816, 1818, 1826, 1833, 1836, 1842,
1844, 1844, 1846, 1850, 1857, 1858, 1859, 1862,
1867, 1870, 1875, 1877, 1877, 1879, 1880, 1883,
1883, 1885, 1886, 1889, 1893, 1894, 1898, 1906,
1913, 1917, 1922, 1925, 1930, 1935, 1937, 1940,
1950, 1954, 1958, 1963, 1968, 1972, 1978, 1982,
1987, 1991, 1999, 2002, 2006, 2010, 2014, 2022,
2028, 2035, 2042, 2048, 2052, 2056, 2060, 2062,
2065, 2066, 2070, 2077, 2077, 2081, 2086, 2096,
2097, 2101, 2106, 2110, 2118, 2120, 2124, 2126,
2133, 2140, 2144, 2145, 2151, 2158, 2164, 2171,
2176, 2180, 2186, 2192, 2196, 2202, 2202, 2203,
2210, 2217, 2223, 2226, 2232, 2239, 2241, 2242,
2247, 2251, 2257, 2258, 2263, 2270, 2280, 2284,
2289, 2292, 2293, 2295, 2299, 2302, 2304, 2307,
2312, 2316, 2320, 2328, 2328, 2332, 2336, 2339,
2342, 2344, 2348, 2351, 2353, 2353, 2354, 2357,
2360, 2361, 2366, 2371, 2374, 2381, 2385, 2391,
2395, 2397, 2399, 2404, 2411, 2416, 2420, 2425,
2431, 2436, 2443, 2450, 2455, 2460, 2462, 2470,
2477, 2484, 2491, 2497, 2503, 2510, 2515, 2524,
2530, 2535, 2541, 2545, 2551, 2555, 2559, 2561,
2572, 2578, 2585, 2593, 2598, 2602, 2609, 2611,
2619, 2623, 2630, 2631, 2637, 2639, 2646, 2649,
2657, 2657, 2661, 2665, 2669, 2675, 2679, 2680,
2682, 2685, 2690, 2696, 2701, 2706, 2712, 2716,
2719, 2723, 2724, 2725, 2728, 2729, 2736, 2745,
2749, 2749, 2752, 2755, 2757, 2762, 2763, 2765,
2768, 2770, 2776, 2778, 2783, 2786, 2791, 2793,
2793, 2798, 2800, 2802, 2804, 2806, 2809, 2809,
2811, 2814, 2816, 2819, 2823, 2827, 2829, 2836,
2841, 2846, 2849, 2851, 2857, 2863, 2870, 2872,
2872, 2874, 2876, 2877, 2881, 2885, 2892, 2896,
2902, 2910, 2919, 2921, 2929, 2935, 2939, 2947,
2949, 2951, 2956, 2960, 2968, 2969, 2972, 2978,
2983, 2990, 2993, 2994, 2996, 3004, 3009, 3014,
3022, 3022, 3027, 3037, 3045, 3049, 3055, 3059,
3062, 3062, 3067, 3072, 3075, 3082, 3085, 3086,
3090, 3094, 3097, 3102, 3106, 3107, 3115, 3119,
3124, 3129, 3132, 3137, 3141, 3146, 3149, 3156,
3158, 3164, 3173, 3177, 3179, 3180, 3184, 3186,
3190, 3193, 3197, 3203, 3207, 3210, 3214, 3214,
3217, 3220, 3223, 3225, 3227, 3232, 3237, 3244,
3245, 3249, 3253, 3255, 3259, 3264, 3269, 3274,
3278, 3280, 3282, 3285, 3293, 3298, 3304, 3308,
3311, 3313, 3313, 3317, 3317, 3321, 3324, 3326,
3330, 3331, 3335, 3339, 3343, 3345, 3348, 3350,
3356, 3362, 3367, 3370, 3373, 3380, 3384, 3392,
3396, 3402, 3404, 3415, 3423, 3428, 3436, 3444,
3445, 3450, 3454, 3460, 3466, 3469, 3473, 3478,
3479, 3481, 3487, 3493, 3500, 3503, 3510, 3515,
3521, 3527, 3529, 3531, 3540, 3544, 3550, 3551,
3556, 3558, 3560, 3565, 3566, 3569, 3571, 3575,
3582, 3586, 3588, 3589, 3591, 3596, 3602, 3607,
3612, 3617, 3618, 3620, 3624, 3626, 3627, 3631,
3634, 3635, 3637, 3640, 3645, 3645, 3648, 3655,
3656, 3657, 3658, 3662, 3664, 3666, 3667, 3670,
3671, 3676, 3678, 3681, 3684, 3689, 3690, 3693,
3695, 3697, 3698, 3701, 3703, 3708, 3716, 3720,
3722, 3726, 3727, 3731, 3737, 3742, 3747, 3751,
3752, 3757, 3763, 3765, 3772, 3777, 3778, 3782,
3789, 3792, 3797, 3801, 3802, 3807, 3811, 3817,
3821, 3822, 3826, 3830, 3831, 3837, 3842, 3845,
3847, 3850, 3855, 3857, 3860, 3866, 3867, 3870,
3870, 3871, 3873, 3877, 3880, 3883, 3883, 3886,
3887, 3889, 3894, 3897, 3902, 3903, 3906, 3908,
3910, 3920, 3927, 3934, 3939, 3944, 3946, 3952,
3958, 3960, 3962, 3966, 3976, 3979, 3984, 3991,
3993, 3995, 4000, 4005, 4009, 4013, 4017, 4022,
4025, 4028, 4033, 4033, 4033, 4033, 4033, 4033,
4033, 4033, 4033, 4033, 4036, 4037, 4040, 4043,
4048, 4053, 4056, 4059, 4063, 4068, 4072, 4076,
4079, 4086, 4090, 4091, 4095, 4098, 4102, 4103,
4110, 4117, 4120, 4126, 4130, 4134, 4137, 4140,
4144, 4150, 4153, 4157, 4159, 4161, 4165, 4168,
4174, 4178, 4181, 4184, 4190, 4194, 4196, 4202,
4208, 4214, 4219, 4223, 4227, 4230, 4231, 4235,
4240, 4243, 4248, 4255, 4264, 4264, 4272, 4276,
4279, 4285, 4286, 4289, 4295, 4300, 4302, 4302,
4305, 4308, 4311, 4315, 4316, 4321, 4324, 4327,
4333, 4339, 4339, 4341, 4344, 4345, 4347, 4353,
4355, 4355, 4359, 4360, 4365, 4372, 4374, 4376,
4378, 4378, 4385, 4391, 4393, 4397, 4399, 4404,
4404, 4407, 4410, 4415, 4417, 4422, 4425, 4429,
4433, 4437, 4440, 4441, 4442, 4443, 4450, 4451,
4452, 4454, 4455, 4458, 4458, 4460, 4464, 4466,
4467, 4471, 4474, 4474, 4474, 4475, 4478, 4480,
4483, 4485, 4486, 4487, 4489, 4490, 4490, 4493,
4497, 4498, 4499, 4501, 4504, 4508, 4514, 4519,
4524, 4529, 4533, 4534, 4535, 4538, 4544, 4546,
4551, 4552, 4557, 4559, 4562, 4564, 4565, 4567,
4569, 4575, 4577, 4580, 4583, 4584, 4585, 4586,
4588, 4595, 4602, 4606, 4611, 4611, 4616, 4623,
4629, 4633, 4637, 4645, 4651, 4657, 4661, 4668,
4674, 4679, 4687, 4691, 4693, 4697, 4700, 4703,
4707, 4709, 4714, 4714, 4714, 4714, 4714, 4714,
4714, 4714, 4714, 4714, 4716, 4721, 4723, 4726,
4728, 4731, 4733, 4743, 4753, 4761, 4766, 4773,
4777, 4783, 4785, 4785, 4785, 4785, 4785, 4788,
4792, 4794, 4795, 4797, 4800, 4804, 4806, 4810,
4811, 4813, 4815, 4816, 4818, 4824, 4826, 4827,
4829, 4833, 4833, 4836, 4836, 4841, 4843, 4844,
4847, 4850, 4859, 4864, 4870, 4875, 4877, 4878,
4878, 4878, 4880, 4885, 4888, 4891, 4893, 4897,
4902, 4912, 4922, 4927, 4933, 4940, 4949, 4956,
4964, 4973, 4976, 4982, 4986, 4988, 4989, 4992,
4994, 4995, 4998, 5000, 5001, 5007, 5008, 5012,
5015, 5019, 5021, 5025, 5028, 5036, 5042, 5045,
5046, 5047, 5052, 5052, 5055, 5058, 5061, 5065,
5065, 5068, 5073, 5073, 5077, 5079, 5080, 5082,
5084, 5085, 5090, 5099, 5099, 5103, 5105, 5106,
5109, 5110, 5113, 5117, 5118, 5119, 5121, 5123,
5124, 5125, 5126, 5128, 5130, 5131, 5134, 5134,
5136, 5136, 5136, 5136, 5136, 5136, 5136, 5136,
5136, 5136, 5136, 5136, 5136, 5136, 5136, 5136,
5137, 5142, 5147, 5152, 5155, 5157, 5161, 5163,
5163, 5163, 5164, 5167, 5170, 5176, 5182, 5186,
5193, 5199, 5205, 5209, 5212, 5223, 5228, 5234,
5240, 5243, 5249, 5250, 5254, 5257, 5261, 5265,
5268, 5271, 5271, 5275, 5275, 5277, 5279, 5279,
5283, 5292, 5298, 5299, 5303, 5307, 5311, 5315,
5315, 5315, 5315, 5317, 5318, 5320, 5323, 5328,
5332, 5336, 5340, 5342, 5342, 5347, 5351, 5351,
5351, 5351, 5354, 5359, 5363, 5364, 5371, 5372,
5374, 5378, 5379, 5380, 5383, 5387, 5392, 5396,
5396, 5396, 5396, 5397, 5398, 5398, 5401, 5403,
5403, 5403, 5404, 5406, 5408, 5414, 5416, 5417,
5417, 5418, 5420, 5422, 5422, 5423, 5424, 5426,
5426, 5427, 5430, 5431, 5433, 5435, 5436, 5436,
5436, 5436, 5436, 5436, 5436, 5436, 5436, 5439,
5442, 5443, 5444, 5446, 5447, 5447, 5449, 5452,
5453, 5453, 5453, 5455, 5456, 5457, 5458, 5458,
5462, 5462, 5464, 5464, 5464, 5464, 5464, 5464,
5468, 5468, 5473, 5474, 5478, 5481, 5487, 5488,
5489, 5492, 5493, 5494, 5495, 5498, 5500, 5504,
5505, 5506,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_ksx1001_u_u[3607] = {
0x00A1, 0x00A4, 0x00A7, 0x00A8, 0x00AA, 0x00AD, 0x00AE, 0x00B0,
0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B6, 0x00B7, 0x00B8, 0x00B9,
0x00BA, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C6, 0x00D0, 0x00D7,
0x00D8, 0x00DE, 0x00DF, 0x00E6, 0x00F0, 0x00F7, 0x00F8, 0x00FE,
0x0111, 0x0126, 0x0127, 0x0131, 0x0132, 0x0133, 0x0138, 0x013F,
0x0140, 0x0141, 0x0142, 0x0149, 0x014A, 0x014B, 0x0152, 0x0153,
0x0166, 0x0167, 0x02C7, 0x02D0, 0x02D8, 0x02D9, 0x02DA, 0x02DB,
0x02DD, 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, 0x2015, 0x2018, 0x2019, 0x201C, 0x201D,
0x2020, 0x2021, 0x2025, 0x2026, 0x2030, 0x2032, 0x2033, 0x203B,
0x2074, 0x207F, 0x2081, 0x2082, 0x2083, 0x2084, 0x20AC, 0x2103,
0x2109, 0x2113, 0x2116, 0x2121, 0x2122, 0x2126, 0x212B, 0x2153,
0x2154, 0x215B, 0x215C, 0x215D, 0x215E, 0x2160, 0x2161, 0x2162,
0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x2170,
0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178,
0x2179, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196,
0x2197, 0x2198, 0x2199, 0x21D2, 0x21D4, 0x2200, 0x2202, 0x2203,
0x2207, 0x2208, 0x220B, 0x220F, 0x2211, 0x221A, 0x221D, 0x221E,
0x2220, 0x2225, 0x2227, 0x2228, 0x2229, 0x222A, 0x222B, 0x222C,
0x222E, 0x2234, 0x2235, 0x223C, 0x223D, 0x2252, 0x2260, 0x2261,
0x2264, 0x2265, 0x226A, 0x226B, 0x2282, 0x2283, 0x2286, 0x2287,
0x2299, 0x22A5, 0x2312, 0x2460, 0x2461, 0x2462, 0x2463, 0x2464,
0x2465, 0x2466, 0x2467, 0x2468, 0x2469, 0x246A, 0x246B, 0x246C,
0x246D, 0x246E, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
0x247A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480, 0x2481,
0x2482, 0x249C, 0x249D, 0x249E, 0x249F, 0x24A0, 0x24A1, 0x24A2,
0x24A3, 0x24A4, 0x24A5, 0x24A6, 0x24A7, 0x24A8, 0x24A9, 0x24AA,
0x24AB, 0x24AC, 0x24AD, 0x24AE, 0x24AF, 0x24B0, 0x24B1, 0x24B2,
0x24B3, 0x24B4, 0x24B5, 0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4,
0x24D5, 0x24D6, 0x24D7, 0x24D8, 0x24D9, 0x24DA, 0x24DB, 0x24DC,
0x24DD, 0x24DE, 0x24DF, 0x24E0, 0x24E1, 0x24E2, 0x24E3, 0x24E4,
0x24E5, 0x24E6, 0x24E7, 0x24E8, 0x24E9, 0x2500, 0x2501, 0x2502,
0x2503, 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, 0x2592, 0x25A0, 0x25A1, 0x25A3, 0x25A4, 0x25A5, 0x25A6,
0x25A7, 0x25A8, 0x25A9, 0x25B2, 0x25B3, 0x25B6, 0x25B7, 0x25BC,
0x25BD, 0x25C0, 0x25C1, 0x25C6, 0x25C7, 0x25C8, 0x25CB, 0x25CE,
0x25CF, 0x25D0, 0x25D1, 0x2605, 0x2606, 0x260E, 0x260F, 0x261C,
0x261E, 0x2640, 0x2642, 0x2660, 0x2661, 0x2663, 0x2664, 0x2665,
0x2667, 0x2668, 0x2669, 0x266A, 0x266C, 0x266D, 0x3000, 0x3001,
0x3002, 0x3003, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3010, 0x3011, 0x3013, 0x3014, 0x3015, 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,
0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137, 0x3138,
0x3139, 0x313A, 0x313B, 0x313C, 0x313D, 0x313E, 0x313F, 0x3140,
0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147, 0x3148,
0x3149, 0x314A, 0x314B, 0x314C, 0x314D, 0x314E, 0x314F, 0x3150,
0x3151, 0x3152, 0x3153, 0x3154, 0x3155, 0x3156, 0x3157, 0x3158,
0x3159, 0x315A, 0x315B, 0x315C, 0x315D, 0x315E, 0x315F, 0x3160,
0x3161, 0x3162, 0x3163, 0x3164, 0x3165, 0x3166, 0x3167, 0x3168,
0x3169, 0x316A, 0x316B, 0x316C, 0x316D, 0x316E, 0x316F, 0x3170,
0x3171, 0x3172, 0x3173, 0x3174, 0x3175, 0x3176, 0x3177, 0x3178,
0x3179, 0x317A, 0x317B, 0x317C, 0x317D, 0x317E, 0x317F, 0x3180,
0x3181, 0x3182, 0x3183, 0x3184, 0x3185, 0x3186, 0x3187, 0x3188,
0x3189, 0x318A, 0x318B, 0x318C, 0x318D, 0x318E, 0x3200, 0x3201,
0x3202, 0x3203, 0x3204, 0x3205, 0x3206, 0x3207, 0x3208, 0x3209,
0x320A, 0x320B, 0x320C, 0x320D, 0x320E, 0x320F, 0x3210, 0x3211,
0x3212, 0x3213, 0x3214, 0x3215, 0x3216, 0x3217, 0x3218, 0x3219,
0x321A, 0x321B, 0x321C, 0x3260, 0x3261, 0x3262, 0x3263, 0x3264,
0x3265, 0x3266, 0x3267, 0x3268, 0x3269, 0x326A, 0x326B, 0x326C,
0x326D, 0x326E, 0x326F, 0x3270, 0x3271, 0x3272, 0x3273, 0x3274,
0x3275, 0x3276, 0x3277, 0x3278, 0x3279, 0x327A, 0x327B, 0x327E,
0x327F, 0x3380, 0x3381, 0x3382, 0x3383, 0x3384, 0x3388, 0x3389,
0x338A, 0x338B, 0x338C, 0x338D, 0x338E, 0x338F, 0x3390, 0x3391,
0x3392, 0x3393, 0x3394, 0x3395, 0x3396, 0x3397, 0x3398, 0x3399,
0x339A, 0x339B, 0x339C, 0x339D, 0x339E, 0x339F, 0x33A0, 0x33A1,
0x33A2, 0x33A3, 0x33A4, 0x33A5, 0x33A6, 0x33A7, 0x33A8, 0x33A9,
0x33AA, 0x33AB, 0x33AC, 0x33AD, 0x33AE, 0x33AF, 0x33B0, 0x33B1,
0x33B2, 0x33B3, 0x33B4, 0x33B5, 0x33B6, 0x33B7, 0x33B8, 0x33B9,
0x33BA, 0x33BB, 0x33BC, 0x33BD, 0x33BE, 0x33BF, 0x33C0, 0x33C1,
0x33C2, 0x33C3, 0x33C4, 0x33C5, 0x33C6, 0x33C7, 0x33C8, 0x33C9,
0x33CA, 0x33CF, 0x33D0, 0x33D3, 0x33D6, 0x33D8, 0x33DB, 0x33DC,
0x33DD, 0xAC00, 0xAC01, 0xAC04, 0xAC07, 0xAC08, 0xAC09, 0xAC0A,
0xAC10, 0xAC11, 0xAC12, 0xAC13, 0xAC14, 0xAC15, 0xAC16, 0xAC17,
0xAC19, 0xAC1A, 0xAC1B, 0xAC1C, 0xAC1D, 0xAC20, 0xAC24, 0xAC2C,
0xAC2D, 0xAC2F, 0xAC30, 0xAC31, 0xAC38, 0xAC39, 0xAC3C, 0xAC40,
0xAC4B, 0xAC4D, 0xAC54, 0xAC58, 0xAC5C, 0xAC70, 0xAC71, 0xAC74,
0xAC77, 0xAC78, 0xAC7A, 0xAC80, 0xAC81, 0xAC83, 0xAC84, 0xAC85,
0xAC86, 0xAC89, 0xAC8A, 0xAC8B, 0xAC8C, 0xAC90, 0xAC94, 0xAC9C,
0xAC9D, 0xAC9F, 0xACA0, 0xACA1, 0xACA8, 0xACA9, 0xACAA, 0xACAC,
0xACAF, 0xACB0, 0xACB8, 0xACB9, 0xACBB, 0xACBC, 0xACBD, 0xACC1,
0xACC4, 0xACC8, 0xACCC, 0xACD5, 0xACD7, 0xACE0, 0xACE1, 0xACE4,
0xACE7, 0xACE8, 0xACEA, 0xACEC, 0xACEF, 0xACF0, 0xACF1, 0xACF3,
0xACF5, 0xACF6, 0xACFC, 0xACFD, 0xAD00, 0xAD04, 0xAD06, 0xAD0C,
0xAD0D, 0xAD0F, 0xAD11, 0xAD18, 0xAD1C, 0xAD20, 0xAD29, 0xAD2C,
0xAD2D, 0xAD34, 0xAD35, 0xAD38, 0xAD3C, 0xAD44, 0xAD45, 0xAD47,
0xAD49, 0xAD50, 0xAD54, 0xAD58, 0xAD61, 0xAD63, 0xAD6C, 0xAD6D,
0xAD70, 0xAD73, 0xAD74, 0xAD75, 0xAD76, 0xAD7B, 0xAD7C, 0xAD7D,
0xAD7F, 0xAD81, 0xAD82, 0xAD88, 0xAD89, 0xAD8C, 0xAD90, 0xAD9C,
0xAD9D, 0xADA4, 0xADB7, 0xADC0, 0xADC1, 0xADC4, 0xADC8, 0xADD0,
0xADD1, 0xADD3, 0xADDC, 0xADE0, 0xADE4, 0xADF8, 0xADF9, 0xADFC,
0xADFF, 0xAE00, 0xAE01, 0xAE08, 0xAE09, 0xAE0B, 0xAE0D, 0xAE14,
0xAE30, 0xAE31, 0xAE34, 0xAE37, 0xAE38, 0xAE3A, 0xAE40, 0xAE41,
0xAE43, 0xAE45, 0xAE46, 0xAE4A, 0xAE4C, 0xAE4D, 0xAE4E, 0xAE50,
0xAE54, 0xAE56, 0xAE5C, 0xAE5D, 0xAE5F, 0xAE60, 0xAE61, 0xAE65,
0xAE68, 0xAE69, 0xAE6C, 0xAE70, 0xAE78, 0xAE79, 0xAE7B, 0xAE7C,
0xAE7D, 0xAE84, 0xAE85, 0xAE8C, 0xAEBC, 0xAEBD, 0xAEBE, 0xAEC0,
0xAEC4, 0xAECC, 0xAECD, 0xAECF, 0xAED0, 0xAED1, 0xAED8, 0xAED9,
0xAEDC, 0xAEE8, 0xAEEB, 0xAEED, 0xAEF4, 0xAEF8, 0xAEFC, 0xAF07,
0xAF08, 0xAF0D, 0xAF10, 0xAF2C, 0xAF2D, 0xAF30, 0xAF32, 0xAF34,
0xAF3C, 0xAF3D, 0xAF3F, 0xAF41, 0xAF42, 0xAF43, 0xAF48, 0xAF49,
0xAF50, 0xAF5C, 0xAF5D, 0xAF64, 0xAF65, 0xAF79, 0xAF80, 0xAF84,
0xAF88, 0xAF90, 0xAF91, 0xAF95, 0xAF9C, 0xAFB8, 0xAFB9, 0xAFBC,
0xAFC0, 0xAFC7, 0xAFC8, 0xAFC9, 0xAFCB, 0xAFCD, 0xAFCE, 0xAFD4,
0xAFDC, 0xAFE8, 0xAFE9, 0xAFF0, 0xAFF1, 0xAFF4, 0xAFF8, 0xB000,
0xB001, 0xB004, 0xB00C, 0xB010, 0xB014, 0xB01C, 0xB01D, 0xB028,
0xB044, 0xB045, 0xB048, 0xB04A, 0xB04C, 0xB04E, 0xB053, 0xB054,
0xB055, 0xB057, 0xB059, 0xB05D, 0xB07C, 0xB07D, 0xB080, 0xB084,
0xB08C, 0xB08D, 0xB08F, 0xB091, 0xB098, 0xB099, 0xB09A, 0xB09C,
0xB09F, 0xB0A0, 0xB0A1, 0xB0A2, 0xB0A8, 0xB0A9, 0xB0AB, 0xB0AC,
0xB0AD, 0xB0AE, 0xB0AF, 0xB0B1, 0xB0B3, 0xB0B4, 0xB0B5, 0xB0B8,
0xB0BC, 0xB0C4, 0xB0C5, 0xB0C7, 0xB0C8, 0xB0C9, 0xB0D0, 0xB0D1,
0xB0D4, 0xB0D8, 0xB0E0, 0xB0E5, 0xB108, 0xB109, 0xB10B, 0xB10C,
0xB110, 0xB112, 0xB113, 0xB118, 0xB119, 0xB11B, 0xB11C, 0xB11D,
0xB123, 0xB124, 0xB125, 0xB128, 0xB12C, 0xB134, 0xB135, 0xB137,
0xB138, 0xB139, 0xB140, 0xB141, 0xB144, 0xB148, 0xB150, 0xB151,
0xB154, 0xB155, 0xB158, 0xB15C, 0xB160, 0xB178, 0xB179, 0xB17C,
0xB180, 0xB182, 0xB188, 0xB189, 0xB18B, 0xB18D, 0xB192, 0xB193,
0xB194, 0xB198, 0xB19C, 0xB1A8, 0xB1CC, 0xB1D0, 0xB1D4, 0xB1DC,
0xB1DD, 0xB1DF, 0xB1E8, 0xB1E9, 0xB1EC, 0xB1F0, 0xB1F9, 0xB1FB,
0xB1FD, 0xB204, 0xB205, 0xB208, 0xB20B, 0xB20C, 0xB214, 0xB215,
0xB217, 0xB219, 0xB220, 0xB234, 0xB23C, 0xB258, 0xB25C, 0xB260,
0xB268, 0xB269, 0xB274, 0xB275, 0xB27C, 0xB284, 0xB285, 0xB289,
0xB290, 0xB291, 0xB294, 0xB298, 0xB299, 0xB29A, 0xB2A0, 0xB2A1,
0xB2A3, 0xB2A5, 0xB2A6, 0xB2AA, 0xB2AC, 0xB2B0, 0xB2B4, 0xB2C8,
0xB2C9, 0xB2CC, 0xB2D0, 0xB2D2, 0xB2D8, 0xB2D9, 0xB2DB, 0xB2DD,
0xB2E2, 0xB2E4, 0xB2E5, 0xB2E6, 0xB2E8, 0xB2EB, 0xB2EC, 0xB2ED,
0xB2EE, 0xB2EF, 0xB2F3, 0xB2F4, 0xB2F5, 0xB2F7, 0xB2F8, 0xB2F9,
0xB2FA, 0xB2FB, 0xB2FF, 0xB300, 0xB301, 0xB304, 0xB308, 0xB310,
0xB311, 0xB313, 0xB314, 0xB315, 0xB31C, 0xB354, 0xB355, 0xB356,
0xB358, 0xB35B, 0xB35C, 0xB35E, 0xB35F, 0xB364, 0xB365, 0xB367,
0xB369, 0xB36B, 0xB36E, 0xB370, 0xB371, 0xB374, 0xB378, 0xB380,
0xB381, 0xB383, 0xB384, 0xB385, 0xB38C, 0xB390, 0xB394, 0xB3A0,
0xB3A1, 0xB3A8, 0xB3AC, 0xB3C4, 0xB3C5, 0xB3C8, 0xB3CB, 0xB3CC,
0xB3CE, 0xB3D0, 0xB3D4, 0xB3D5, 0xB3D7, 0xB3D9, 0xB3DB, 0xB3DD,
0xB3E0, 0xB3E4, 0xB3E8, 0xB3FC, 0xB410, 0xB418, 0xB41C, 0xB420,
0xB428, 0xB429, 0xB42B, 0xB434, 0xB450, 0xB451, 0xB454, 0xB458,
0xB460, 0xB461, 0xB463, 0xB465, 0xB46C, 0xB480, 0xB488, 0xB49D,
0xB4A4, 0xB4A8, 0xB4AC, 0xB4B5, 0xB4B7, 0xB4B9, 0xB4C0, 0xB4C4,
0xB4C8, 0xB4D0, 0xB4D5, 0xB4DC, 0xB4DD, 0xB4E0, 0xB4E3, 0xB4E4,
0xB4E6, 0xB4EC, 0xB4ED, 0xB4EF, 0xB4F1, 0xB4F8, 0xB514, 0xB515,
0xB518, 0xB51B, 0xB51C, 0xB524, 0xB525, 0xB527, 0xB528, 0xB529,
0xB52A, 0xB530, 0xB531, 0xB534, 0xB538, 0xB540, 0xB541, 0xB543,
0xB544, 0xB545, 0xB54B, 0xB54C, 0xB54D, 0xB550, 0xB554, 0xB55C,
0xB55D, 0xB55F, 0xB560, 0xB561, 0xB5A0, 0xB5A1, 0xB5A4, 0xB5A8,
0xB5AA, 0xB5AB, 0xB5B0, 0xB5B1, 0xB5B3, 0xB5B4, 0xB5B5, 0xB5BB,
0xB5BC, 0xB5BD, 0xB5C0, 0xB5C4, 0xB5CC, 0xB5CD, 0xB5CF, 0xB5D0,
0xB5D1, 0xB5D8, 0xB5EC, 0xB610, 0xB611, 0xB614, 0xB618, 0xB625,
0xB62C, 0xB634, 0xB648, 0xB664, 0xB668, 0xB69C, 0xB69D, 0xB6A0,
0xB6A4, 0xB6AB, 0xB6AC, 0xB6B1, 0xB6D4, 0xB6F0, 0xB6F4, 0xB6F8,
0xB700, 0xB701, 0xB705, 0xB728, 0xB729, 0xB72C, 0xB72F, 0xB730,
0xB738, 0xB739, 0xB73B, 0xB744, 0xB748, 0xB74C, 0xB754, 0xB755,
0xB760, 0xB764, 0xB768, 0xB770, 0xB771, 0xB773, 0xB775, 0xB77C,
0xB77D, 0xB780, 0xB784, 0xB78C, 0xB78D, 0xB78F, 0xB790, 0xB791,
0xB792, 0xB796, 0xB797, 0xB798, 0xB799, 0xB79C, 0xB7A0, 0xB7A8,
0xB7A9, 0xB7AB, 0xB7AC, 0xB7AD, 0xB7B4, 0xB7B5, 0xB7B8, 0xB7C7,
0xB7C9, 0xB7EC, 0xB7ED, 0xB7F0, 0xB7F4, 0xB7FC, 0xB7FD, 0xB7FF,
0xB800, 0xB801, 0xB807, 0xB808, 0xB809, 0xB80C, 0xB810, 0xB818,
0xB819, 0xB81B, 0xB81D, 0xB824, 0xB825, 0xB828, 0xB82C, 0xB834,
0xB835, 0xB837, 0xB838, 0xB839, 0xB840, 0xB844, 0xB851, 0xB853,
0xB85C, 0xB85D, 0xB860, 0xB864, 0xB86C, 0xB86D, 0xB86F, 0xB871,
0xB878, 0xB87C, 0xB88D, 0xB8A8, 0xB8B0, 0xB8B4, 0xB8B8, 0xB8C0,
0xB8C1, 0xB8C3, 0xB8C5, 0xB8CC, 0xB8D0, 0xB8D4, 0xB8DD, 0xB8DF,
0xB8E1, 0xB8E8, 0xB8E9, 0xB8EC, 0xB8F0, 0xB8F8, 0xB8F9, 0xB8FB,
0xB8FD, 0xB904, 0xB918, 0xB920, 0xB93C, 0xB93D, 0xB940, 0xB944,
0xB94C, 0xB94F, 0xB951, 0xB958, 0xB959, 0xB95C, 0xB960, 0xB968,
0xB969, 0xB96B, 0xB96D, 0xB974, 0xB975, 0xB978, 0xB97C, 0xB984,
0xB985, 0xB987, 0xB989, 0xB98A, 0xB98D, 0xB98E, 0xB9AC, 0xB9AD,
0xB9B0, 0xB9B4, 0xB9BC, 0xB9BD, 0xB9BF, 0xB9C1, 0xB9C8, 0xB9C9,
0xB9CC, 0xB9CE, 0xB9CF, 0xB9D0, 0xB9D1, 0xB9D2, 0xB9D8, 0xB9D9,
0xB9DB, 0xB9DD, 0xB9DE, 0xB9E1, 0xB9E3, 0xB9E4, 0xB9E5, 0xB9E8,
0xB9EC, 0xB9F4, 0xB9F5, 0xB9F7, 0xB9F8, 0xB9F9, 0xB9FA, 0xBA00,
0xBA01, 0xBA08, 0xBA15, 0xBA38, 0xBA39, 0xBA3C, 0xBA40, 0xBA42,
0xBA48, 0xBA49, 0xBA4B, 0xBA4D, 0xBA4E, 0xBA53, 0xBA54, 0xBA55,
0xBA58, 0xBA5C, 0xBA64, 0xBA65, 0xBA67, 0xBA68, 0xBA69, 0xBA70,
0xBA71, 0xBA74, 0xBA78, 0xBA83, 0xBA84, 0xBA85, 0xBA87, 0xBA8C,
0xBAA8, 0xBAA9, 0xBAAB, 0xBAAC, 0xBAB0, 0xBAB2, 0xBAB8, 0xBAB9,
0xBABB, 0xBABD, 0xBAC4, 0xBAC8, 0xBAD8, 0xBAD9, 0xBAFC, 0xBB00,
0xBB04, 0xBB0D, 0xBB0F, 0xBB11, 0xBB18, 0xBB1C, 0xBB20, 0xBB29,
0xBB2B, 0xBB34, 0xBB35, 0xBB36, 0xBB38, 0xBB3B, 0xBB3C, 0xBB3D,
0xBB3E, 0xBB44, 0xBB45, 0xBB47, 0xBB49, 0xBB4D, 0xBB4F, 0xBB50,
0xBB54, 0xBB58, 0xBB61, 0xBB63, 0xBB6C, 0xBB88, 0xBB8C, 0xBB90,
0xBBA4, 0xBBA8, 0xBBAC, 0xBBB4, 0xBBB7, 0xBBC0, 0xBBC4, 0xBBC8,
0xBBD0, 0xBBD3, 0xBBF8, 0xBBF9, 0xBBFC, 0xBBFF, 0xBC00, 0xBC02,
0xBC08, 0xBC09, 0xBC0B, 0xBC0C, 0xBC0D, 0xBC0F, 0xBC11, 0xBC14,
0xBC15, 0xBC16, 0xBC17, 0xBC18, 0xBC1B, 0xBC1C, 0xBC1D, 0xBC1E,
0xBC1F, 0xBC24, 0xBC25, 0xBC27, 0xBC29, 0xBC2D, 0xBC30, 0xBC31,
0xBC34, 0xBC38, 0xBC40, 0xBC41, 0xBC43, 0xBC44, 0xBC45, 0xBC49,
0xBC4C, 0xBC4D, 0xBC50, 0xBC5D, 0xBC84, 0xBC85, 0xBC88, 0xBC8B,
0xBC8C, 0xBC8E, 0xBC94, 0xBC95, 0xBC97, 0xBC99, 0xBC9A, 0xBCA0,
0xBCA1, 0xBCA4, 0xBCA7, 0xBCA8, 0xBCB0, 0xBCB1, 0xBCB3, 0xBCB4,
0xBCB5, 0xBCBC, 0xBCBD, 0xBCC0, 0xBCC4, 0xBCCD, 0xBCCF, 0xBCD0,
0xBCD1, 0xBCD5, 0xBCD8, 0xBCDC, 0xBCF4, 0xBCF5, 0xBCF6, 0xBCF8,
0xBCFC, 0xBD04, 0xBD05, 0xBD07, 0xBD09, 0xBD10, 0xBD14, 0xBD24,
0xBD2C, 0xBD40, 0xBD48, 0xBD49, 0xBD4C, 0xBD50, 0xBD58, 0xBD59,
0xBD64, 0xBD68, 0xBD80, 0xBD81, 0xBD84, 0xBD87, 0xBD88, 0xBD89,
0xBD8A, 0xBD90, 0xBD91, 0xBD93, 0xBD95, 0xBD99, 0xBD9A, 0xBD9C,
0xBDA4, 0xBDB0, 0xBDB8, 0xBDD4, 0xBDD5, 0xBDD8, 0xBDDC, 0xBDE9,
0xBDF0, 0xBDF4, 0xBDF8, 0xBE00, 0xBE03, 0xBE05, 0xBE0C, 0xBE0D,
0xBE10, 0xBE14, 0xBE1C, 0xBE1D, 0xBE1F, 0xBE44, 0xBE45, 0xBE48,
0xBE4C, 0xBE4E, 0xBE54, 0xBE55, 0xBE57, 0xBE59, 0xBE5A, 0xBE5B,
0xBE60, 0xBE61, 0xBE64, 0xBE68, 0xBE6A, 0xBE70, 0xBE71, 0xBE73,
0xBE74, 0xBE75, 0xBE7B, 0xBE7C, 0xBE7D, 0xBE80, 0xBE84, 0xBE8C,
0xBE8D, 0xBE8F, 0xBE90, 0xBE91, 0xBE98, 0xBE99, 0xBEA8, 0xBED0,
0xBED1, 0xBED4, 0xBED7, 0xBED8, 0xBEE0, 0xBEE3, 0xBEE4, 0xBEE5,
0xBEEC, 0xBF01, 0xBF08, 0xBF09, 0xBF18, 0xBF19, 0xBF1B, 0xBF1C,
0xBF1D, 0xBF40, 0xBF41, 0xBF44, 0xBF48, 0xBF50, 0xBF51, 0xBF55,
0xBF94, 0xBFB0, 0xBFC5, 0xBFCC, 0xBFCD, 0xBFD0, 0xBFD4, 0xBFDC,
0xBFDF, 0xBFE1, 0xC03C, 0xC051, 0xC058, 0xC05C, 0xC060, 0xC068,
0xC069, 0xC090, 0xC091, 0xC094, 0xC098, 0xC0A0, 0xC0A1, 0xC0A3,
0xC0A5, 0xC0AC, 0xC0AD, 0xC0AF, 0xC0B0, 0xC0B3, 0xC0B4, 0xC0B5,
0xC0B6, 0xC0BC, 0xC0BD, 0xC0BF, 0xC0C0, 0xC0C1, 0xC0C5, 0xC0C8,
0xC0C9, 0xC0CC, 0xC0D0, 0xC0D8, 0xC0D9, 0xC0DB, 0xC0DC, 0xC0DD,
0xC0E4, 0xC0E5, 0xC0E8, 0xC0EC, 0xC0F4, 0xC0F5, 0xC0F7, 0xC0F9,
0xC100, 0xC104, 0xC108, 0xC110, 0xC115, 0xC11C, 0xC11D, 0xC11E,
0xC11F, 0xC120, 0xC123, 0xC124, 0xC126, 0xC127, 0xC12C, 0xC12D,
0xC12F, 0xC130, 0xC131, 0xC136, 0xC138, 0xC139, 0xC13C, 0xC140,
0xC148, 0xC149, 0xC14B, 0xC14C, 0xC14D, 0xC154, 0xC155, 0xC158,
0xC15C, 0xC164, 0xC165, 0xC167, 0xC168, 0xC169, 0xC170, 0xC174,
0xC178, 0xC185, 0xC18C, 0xC18D, 0xC18E, 0xC190, 0xC194, 0xC196,
0xC19C, 0xC19D, 0xC19F, 0xC1A1, 0xC1A5, 0xC1A8, 0xC1A9, 0xC1AC,
0xC1B0, 0xC1BD, 0xC1C4, 0xC1C8, 0xC1CC, 0xC1D4, 0xC1D7, 0xC1D8,
0xC1E0, 0xC1E4, 0xC1E8, 0xC1F0, 0xC1F1, 0xC1F3, 0xC1FC, 0xC1FD,
0xC200, 0xC204, 0xC20C, 0xC20D, 0xC20F, 0xC211, 0xC218, 0xC219,
0xC21C, 0xC21F, 0xC220, 0xC228, 0xC229, 0xC22B, 0xC22D, 0xC22F,
0xC231, 0xC232, 0xC234, 0xC248, 0xC250, 0xC251, 0xC254, 0xC258,
0xC260, 0xC265, 0xC26C, 0xC26D, 0xC270, 0xC274, 0xC27C, 0xC27D,
0xC27F, 0xC281, 0xC288, 0xC289, 0xC290, 0xC298, 0xC29B, 0xC29D,
0xC2A4, 0xC2A5, 0xC2A8, 0xC2AC, 0xC2AD, 0xC2B4, 0xC2B5, 0xC2B7,
0xC2B9, 0xC2DC, 0xC2DD, 0xC2E0, 0xC2E3, 0xC2E4, 0xC2EB, 0xC2EC,
0xC2ED, 0xC2EF, 0xC2F1, 0xC2F6, 0xC2F8, 0xC2F9, 0xC2FB, 0xC2FC,
0xC300, 0xC308, 0xC309, 0xC30C, 0xC30D, 0xC313, 0xC314, 0xC315,
0xC318, 0xC31C, 0xC324, 0xC325, 0xC328, 0xC329, 0xC345, 0xC368,
0xC369, 0xC36C, 0xC370, 0xC372, 0xC378, 0xC379, 0xC37C, 0xC37D,
0xC384, 0xC388, 0xC38C, 0xC3C0, 0xC3D8, 0xC3D9, 0xC3DC, 0xC3DF,
0xC3E0, 0xC3E2, 0xC3E8, 0xC3E9, 0xC3ED, 0xC3F4, 0xC3F5, 0xC3F8,
0xC408, 0xC410, 0xC424, 0xC42C, 0xC430, 0xC434, 0xC43C, 0xC43D,
0xC448, 0xC464, 0xC465, 0xC468, 0xC46C, 0xC474, 0xC475, 0xC479,
0xC480, 0xC494, 0xC49C, 0xC4B8, 0xC4BC, 0xC4E9, 0xC4F0, 0xC4F1,
0xC4F4, 0xC4F8, 0xC4FA, 0xC4FF, 0xC500, 0xC501, 0xC50C, 0xC510,
0xC514, 0xC51C, 0xC528, 0xC529, 0xC52C, 0xC530, 0xC538, 0xC539,
0xC53B, 0xC53D, 0xC544, 0xC545, 0xC548, 0xC549, 0xC54A, 0xC54C,
0xC54D, 0xC54E, 0xC553, 0xC554, 0xC555, 0xC557, 0xC558, 0xC559,
0xC55D, 0xC55E, 0xC560, 0xC561, 0xC564, 0xC568, 0xC570, 0xC571,
0xC573, 0xC574, 0xC575, 0xC57C, 0xC57D, 0xC580, 0xC584, 0xC587,
0xC58C, 0xC58D, 0xC58F, 0xC591, 0xC595, 0xC597, 0xC598, 0xC59C,
0xC5A0, 0xC5A9, 0xC5B4, 0xC5B5, 0xC5B8, 0xC5B9, 0xC5BB, 0xC5BC,
0xC5BD, 0xC5BE, 0xC5C4, 0xC5C5, 0xC5C6, 0xC5C7, 0xC5C8, 0xC5C9,
0xC5CA, 0xC5CC, 0xC5CE, 0xC5D0, 0xC5D1, 0xC5D4, 0xC5D8, 0xC5E0,
0xC5E1, 0xC5E3, 0xC5E5, 0xC5EC, 0xC5ED, 0xC5EE, 0xC5F0, 0xC5F4,
0xC5F6, 0xC5F7, 0xC5FC, 0xC5FD, 0xC5FE, 0xC5FF, 0xC600, 0xC601,
0xC605, 0xC606, 0xC607, 0xC608, 0xC60C, 0xC610, 0xC618, 0xC619,
0xC61B, 0xC61C, 0xC624, 0xC625, 0xC628, 0xC62C, 0xC62D, 0xC62E,
0xC630, 0xC633, 0xC634, 0xC635, 0xC637, 0xC639, 0xC63B, 0xC640,
0xC641, 0xC644, 0xC648, 0xC650, 0xC651, 0xC653, 0xC654, 0xC655,
0xC65C, 0xC65D, 0xC660, 0xC66C, 0xC66F, 0xC671, 0xC678, 0xC679,
0xC67C, 0xC680, 0xC688, 0xC689, 0xC68B, 0xC68D, 0xC694, 0xC695,
0xC698, 0xC69C, 0xC6A4, 0xC6A5, 0xC6A7, 0xC6A9, 0xC6B0, 0xC6B1,
0xC6B4, 0xC6B8, 0xC6B9, 0xC6BA, 0xC6C0, 0xC6C1, 0xC6C3, 0xC6C5,
0xC6CC, 0xC6CD, 0xC6D0, 0xC6D4, 0xC6DC, 0xC6DD, 0xC6E0, 0xC6E1,
0xC6E8, 0xC6E9, 0xC6EC, 0xC6F0, 0xC6F8, 0xC6F9, 0xC6FD, 0xC704,
0xC705, 0xC708, 0xC70C, 0xC714, 0xC715, 0xC717, 0xC719, 0xC720,
0xC721, 0xC724, 0xC728, 0xC730, 0xC731, 0xC733, 0xC735, 0xC737,
0xC73C, 0xC73D, 0xC740, 0xC744, 0xC74A, 0xC74C, 0xC74D, 0xC74F,
0xC751, 0xC752, 0xC753, 0xC754, 0xC755, 0xC756, 0xC757, 0xC758,
0xC75C, 0xC760, 0xC768, 0xC76B, 0xC774, 0xC775, 0xC778, 0xC77C,
0xC77D, 0xC77E, 0xC783, 0xC784, 0xC785, 0xC787, 0xC788, 0xC789,
0xC78A, 0xC78E, 0xC790, 0xC791, 0xC794, 0xC796, 0xC797, 0xC798,
0xC79A, 0xC7A0, 0xC7A1, 0xC7A3, 0xC7A4, 0xC7A5, 0xC7A6, 0xC7AC,
0xC7AD, 0xC7B0, 0xC7B4, 0xC7BC, 0xC7BD, 0xC7BF, 0xC7C0, 0xC7C1,
0xC7C8, 0xC7C9, 0xC7CC, 0xC7CE, 0xC7D0, 0xC7D8, 0xC7DD, 0xC7E4,
0xC7E8, 0xC7EC, 0xC800, 0xC801, 0xC804, 0xC808, 0xC80A, 0xC810,
0xC811, 0xC813, 0xC815, 0xC816, 0xC81C, 0xC81D, 0xC820, 0xC824,
0xC82C, 0xC82D, 0xC82F, 0xC831, 0xC838, 0xC83C, 0xC840, 0xC848,
0xC849, 0xC84C, 0xC84D, 0xC854, 0xC870, 0xC871, 0xC874, 0xC878,
0xC87A, 0xC880, 0xC881, 0xC883, 0xC885, 0xC886, 0xC887, 0xC88B,
0xC88C, 0xC88D, 0xC894, 0xC89D, 0xC89F, 0xC8A1, 0xC8A8, 0xC8BC,
0xC8BD, 0xC8C4, 0xC8C8, 0xC8CC, 0xC8D4, 0xC8D5, 0xC8D7, 0xC8D9,
0xC8E0, 0xC8E1, 0xC8E4, 0xC8F5, 0xC8FC, 0xC8FD, 0xC900, 0xC904,
0xC905, 0xC906, 0xC90C, 0xC90D, 0xC90F, 0xC911, 0xC918, 0xC92C,
0xC934, 0xC950, 0xC951, 0xC954, 0xC958, 0xC960, 0xC961, 0xC963,
0xC96C, 0xC970, 0xC974, 0xC97C, 0xC988, 0xC989, 0xC98C, 0xC990,
0xC998, 0xC999, 0xC99B, 0xC99D, 0xC9C0, 0xC9C1, 0xC9C4, 0xC9C7,
0xC9C8, 0xC9CA, 0xC9D0, 0xC9D1, 0xC9D3, 0xC9D5, 0xC9D6, 0xC9D9,
0xC9DA, 0xC9DC, 0xC9DD, 0xC9E0, 0xC9E2, 0xC9E4, 0xC9E7, 0xC9EC,
0xC9ED, 0xC9EF, 0xC9F0, 0xC9F1, 0xC9F8, 0xC9F9, 0xC9FC, 0xCA00,
0xCA08, 0xCA09, 0xCA0B, 0xCA0C, 0xCA0D, 0xCA14, 0xCA18, 0xCA29,
0xCA4C, 0xCA4D, 0xCA50, 0xCA54, 0xCA5C, 0xCA5D, 0xCA5F, 0xCA60,
0xCA61, 0xCA68, 0xCA7D, 0xCA84, 0xCA98, 0xCABC, 0xCABD, 0xCAC0,
0xCAC4, 0xCACC, 0xCACD, 0xCACF, 0xCAD1, 0xCAD3, 0xCAD8, 0xCAD9,
0xCAE0, 0xCAEC, 0xCAF4, 0xCB08, 0xCB10, 0xCB14, 0xCB18, 0xCB20,
0xCB21, 0xCB41, 0xCB48, 0xCB49, 0xCB4C, 0xCB50, 0xCB58, 0xCB59,
0xCB5D, 0xCB64, 0xCB78, 0xCB79, 0xCB9C, 0xCBB8, 0xCBD4, 0xCBE4,
0xCBE7, 0xCBE9, 0xCC0C, 0xCC0D, 0xCC10, 0xCC14, 0xCC1C, 0xCC1D,
0xCC21, 0xCC22, 0xCC27, 0xCC28, 0xCC29, 0xCC2C, 0xCC2E, 0xCC30,
0xCC38, 0xCC39, 0xCC3B, 0xCC3C, 0xCC3D, 0xCC3E, 0xCC44, 0xCC45,
0xCC48, 0xCC4C, 0xCC54, 0xCC55, 0xCC57, 0xCC58, 0xCC59, 0xCC60,
0xCC64, 0xCC66, 0xCC68, 0xCC70, 0xCC75, 0xCC98, 0xCC99, 0xCC9C,
0xCCA0, 0xCCA8, 0xCCA9, 0xCCAB, 0xCCAC, 0xCCAD, 0xCCB4, 0xCCB5,
0xCCB8, 0xCCBC, 0xCCC4, 0xCCC5, 0xCCC7, 0xCCC9, 0xCCD0, 0xCCD4,
0xCCE4, 0xCCEC, 0xCCF0, 0xCD01, 0xCD08, 0xCD09, 0xCD0C, 0xCD10,
0xCD18, 0xCD19, 0xCD1B, 0xCD1D, 0xCD24, 0xCD28, 0xCD2C, 0xCD39,
0xCD5C, 0xCD60, 0xCD64, 0xCD6C, 0xCD6D, 0xCD6F, 0xCD71, 0xCD78,
0xCD88, 0xCD94, 0xCD95, 0xCD98, 0xCD9C, 0xCDA4, 0xCDA5, 0xCDA7,
0xCDA9, 0xCDB0, 0xCDC4, 0xCDCC, 0xCDD0, 0xCDE8, 0xCDEC, 0xCDF0,
0xCDF8, 0xCDF9, 0xCDFB, 0xCDFD, 0xCE04, 0xCE08, 0xCE0C, 0xCE14,
0xCE19, 0xCE20, 0xCE21, 0xCE24, 0xCE28, 0xCE30, 0xCE31, 0xCE33,
0xCE35, 0xCE58, 0xCE59, 0xCE5C, 0xCE5F, 0xCE60, 0xCE61, 0xCE68,
0xCE69, 0xCE6B, 0xCE6D, 0xCE74, 0xCE75, 0xCE78, 0xCE7C, 0xCE84,
0xCE85, 0xCE87, 0xCE89, 0xCE90, 0xCE91, 0xCE94, 0xCE98, 0xCEA0,
0xCEA1, 0xCEA3, 0xCEA4, 0xCEA5, 0xCEAC, 0xCEAD, 0xCEC1, 0xCEE4,
0xCEE5, 0xCEE8, 0xCEEB, 0xCEEC, 0xCEF4, 0xCEF5, 0xCEF7, 0xCEF8,
0xCEF9, 0xCF00, 0xCF01, 0xCF04, 0xCF08, 0xCF10, 0xCF11, 0xCF13,
0xCF15, 0xCF1C, 0xCF20, 0xCF24, 0xCF2C, 0xCF2D, 0xCF2F, 0xCF30,
0xCF31, 0xCF38, 0xCF54, 0xCF55, 0xCF58, 0xCF5C, 0xCF64, 0xCF65,
0xCF67, 0xCF69, 0xCF70, 0xCF71, 0xCF74, 0xCF78, 0xCF80, 0xCF85,
0xCF8C, 0xCFA1, 0xCFA8, 0xCFB0, 0xCFC4, 0xCFE0, 0xCFE1, 0xCFE4,
0xCFE8, 0xCFF0, 0xCFF1, 0xCFF3, 0xCFF5, 0xCFFC, 0xD000, 0xD004,
0xD011, 0xD018, 0xD02D, 0xD034, 0xD035, 0xD038, 0xD03C, 0xD044,
0xD045, 0xD047, 0xD049, 0xD050, 0xD054, 0xD058, 0xD060, 0xD06C,
0xD06D, 0xD070, 0xD074, 0xD07C, 0xD07D, 0xD081, 0xD0A4, 0xD0A5,
0xD0A8, 0xD0AC, 0xD0B4, 0xD0B5, 0xD0B7, 0xD0B9, 0xD0C0, 0xD0C1,
0xD0C4, 0xD0C8, 0xD0C9, 0xD0D0, 0xD0D1, 0xD0D3, 0xD0D4, 0xD0D5,
0xD0DC, 0xD0DD, 0xD0E0, 0xD0E4, 0xD0EC, 0xD0ED, 0xD0EF, 0xD0F0,
0xD0F1, 0xD0F8, 0xD10D, 0xD130, 0xD131, 0xD134, 0xD138, 0xD13A,
0xD140, 0xD141, 0xD143, 0xD144, 0xD145, 0xD14C, 0xD14D, 0xD150,
0xD154, 0xD15C, 0xD15D, 0xD15F, 0xD161, 0xD168, 0xD16C, 0xD17C,
0xD184, 0xD188, 0xD1A0, 0xD1A1, 0xD1A4, 0xD1A8, 0xD1B0, 0xD1B1,
0xD1B3, 0xD1B5, 0xD1BA, 0xD1BC, 0xD1C0, 0xD1D8, 0xD1F4, 0xD1F8,
0xD207, 0xD209, 0xD210, 0xD22C, 0xD22D, 0xD230, 0xD234, 0xD23C,
0xD23D, 0xD23F, 0xD241, 0xD248, 0xD25C, 0xD264, 0xD280, 0xD281,
0xD284, 0xD288, 0xD290, 0xD291, 0xD295, 0xD29C, 0xD2A0, 0xD2A4,
0xD2AC, 0xD2B1, 0xD2B8, 0xD2B9, 0xD2BC, 0xD2BF, 0xD2C0, 0xD2C2,
0xD2C8, 0xD2C9, 0xD2CB, 0xD2D4, 0xD2D8, 0xD2DC, 0xD2E4, 0xD2E5,
0xD2F0, 0xD2F1, 0xD2F4, 0xD2F8, 0xD300, 0xD301, 0xD303, 0xD305,
0xD30C, 0xD30D, 0xD30E, 0xD310, 0xD314, 0xD316, 0xD31C, 0xD31D,
0xD31F, 0xD320, 0xD321, 0xD325, 0xD328, 0xD329, 0xD32C, 0xD330,
0xD338, 0xD339, 0xD33B, 0xD33C, 0xD33D, 0xD344, 0xD345, 0xD37C,
0xD37D, 0xD380, 0xD384, 0xD38C, 0xD38D, 0xD38F, 0xD390, 0xD391,
0xD398, 0xD399, 0xD39C, 0xD3A0, 0xD3A8, 0xD3A9, 0xD3AB, 0xD3AD,
0xD3B4, 0xD3B8, 0xD3BC, 0xD3C4, 0xD3C5, 0xD3C8, 0xD3C9, 0xD3D0,
0xD3D8, 0xD3E1, 0xD3E3, 0xD3EC, 0xD3ED, 0xD3F0, 0xD3F4, 0xD3FC,
0xD3FD, 0xD3FF, 0xD401, 0xD408, 0xD41D, 0xD440, 0xD444, 0xD45C,
0xD460, 0xD464, 0xD46D, 0xD46F, 0xD478, 0xD479, 0xD47C, 0xD47F,
0xD480, 0xD482, 0xD488, 0xD489, 0xD48B, 0xD48D, 0xD494, 0xD4A9,
0xD4CC, 0xD4D0, 0xD4D4, 0xD4DC, 0xD4DF, 0xD4E8, 0xD4EC, 0xD4F0,
0xD4F8, 0xD4FB, 0xD4FD, 0xD504, 0xD508, 0xD50C, 0xD514, 0xD515,
0xD517, 0xD53C, 0xD53D, 0xD540, 0xD544, 0xD54C, 0xD54D, 0xD54F,
0xD551, 0xD558, 0xD559, 0xD55C, 0xD560, 0xD565, 0xD568, 0xD569,
0xD56B, 0xD56D, 0xD574, 0xD575, 0xD578, 0xD57C, 0xD584, 0xD585,
0xD587, 0xD588, 0xD589, 0xD590, 0xD5A5, 0xD5C8, 0xD5C9, 0xD5CC,
0xD5D0, 0xD5D2, 0xD5D8, 0xD5D9, 0xD5DB, 0xD5DD, 0xD5E4, 0xD5E5,
0xD5E8, 0xD5EC, 0xD5F4, 0xD5F5, 0xD5F7, 0xD5F9, 0xD600, 0xD601,
0xD604, 0xD608, 0xD610, 0xD611, 0xD613, 0xD614, 0xD615, 0xD61C,
0xD620, 0xD624, 0xD62D, 0xD638, 0xD639, 0xD63C, 0xD640, 0xD645,
0xD648, 0xD649, 0xD64B, 0xD64D, 0xD651, 0xD654, 0xD655, 0xD658,
0xD65C, 0xD667, 0xD669, 0xD670, 0xD671, 0xD674, 0xD683, 0xD685,
0xD68C, 0xD68D, 0xD690, 0xD694, 0xD69D, 0xD69F, 0xD6A1, 0xD6A8,
0xD6AC, 0xD6B0, 0xD6B9, 0xD6BB, 0xD6C4, 0xD6C5, 0xD6C8, 0xD6CC,
0xD6D1, 0xD6D4, 0xD6D7, 0xD6D9, 0xD6E0, 0xD6E4, 0xD6E8, 0xD6F0,
0xD6F5, 0xD6FC, 0xD6FD, 0xD700, 0xD704, 0xD711, 0xD718, 0xD719,
0xD71C, 0xD720, 0xD728, 0xD729, 0xD72B, 0xD72D, 0xD734, 0xD735,
0xD738, 0xD73C, 0xD744, 0xD747, 0xD749, 0xD750, 0xD751, 0xD754,
0xD756, 0xD757, 0xD758, 0xD759, 0xD760, 0xD761, 0xD763, 0xD765,
0xD769, 0xD76C, 0xD770, 0xD774, 0xD77C, 0xD77D, 0xD781, 0xD788,
0xD789, 0xD78C, 0xD790, 0xD798, 0xD799, 0xD79B, 0xD79D, 0xF900,
0xF901, 0xF902, 0xF903, 0xF904, 0xF905, 0xF906, 0xF907, 0xF908,
0xF909, 0xF90A, 0xF90B, 0xF90C, 0xF90D, 0xF90E, 0xF90F, 0xF910,
0xF911, 0xF912, 0xF913, 0xF914, 0xF915, 0xF916, 0xF917, 0xF918,
0xF919, 0xF91A, 0xF91B, 0xF91C, 0xF91D, 0xF91E, 0xF91F, 0xF920,
0xF921, 0xF922, 0xF923, 0xF924, 0xF925, 0xF926, 0xF927, 0xF928,
0xF929, 0xF92A, 0xF92B, 0xF92C, 0xF92D, 0xF92E, 0xF92F, 0xF930,
0xF931, 0xF932, 0xF933, 0xF934, 0xF935, 0xF936, 0xF937, 0xF938,
0xF939, 0xF93A, 0xF93B, 0xF93C, 0xF93D, 0xF93E, 0xF93F, 0xF940,
0xF941, 0xF942, 0xF943, 0xF944, 0xF945, 0xF946, 0xF947, 0xF948,
0xF949, 0xF94A, 0xF94B, 0xF94C, 0xF94D, 0xF94E, 0xF94F, 0xF950,
0xF951, 0xF952, 0xF953, 0xF954, 0xF955, 0xF956, 0xF957, 0xF958,
0xF959, 0xF95A, 0xF95B, 0xF95C, 0xF95D, 0xF95E, 0xF95F, 0xF960,
0xF961, 0xF962, 0xF963, 0xF964, 0xF965, 0xF966, 0xF967, 0xF968,
0xF969, 0xF96A, 0xF96B, 0xF96C, 0xF96D, 0xF96E, 0xF96F, 0xF970,
0xF971, 0xF972, 0xF973, 0xF974, 0xF975, 0xF976, 0xF977, 0xF978,
0xF979, 0xF97A, 0xF97B, 0xF97C, 0xF97D, 0xF97E, 0xF97F, 0xF980,
0xF981, 0xF982, 0xF983, 0xF984, 0xF985, 0xF986, 0xF987, 0xF988,
0xF989, 0xF98A, 0xF98B, 0xF98C, 0xF98D, 0xF98E, 0xF98F, 0xF990,
0xF991, 0xF992, 0xF993, 0xF994, 0xF995, 0xF996, 0xF997, 0xF998,
0xF999, 0xF99A, 0xF99B, 0xF99C, 0xF99D, 0xF99E, 0xF99F, 0xF9A0,
0xF9A1, 0xF9A2, 0xF9A3, 0xF9A4, 0xF9A5, 0xF9A6, 0xF9A7, 0xF9A8,
0xF9A9, 0xF9AA, 0xF9AB, 0xF9AC, 0xF9AD, 0xF9AE, 0xF9AF, 0xF9B0,
0xF9B1, 0xF9B2, 0xF9B3, 0xF9B4, 0xF9B5, 0xF9B6, 0xF9B7, 0xF9B8,
0xF9B9, 0xF9BA, 0xF9BB, 0xF9BC, 0xF9BD, 0xF9BE, 0xF9BF, 0xF9C0,
0xF9C1, 0xF9C2, 0xF9C3, 0xF9C4, 0xF9C5, 0xF9C6, 0xF9C7, 0xF9C8,
0xF9C9, 0xF9CA, 0xF9CB, 0xF9CC, 0xF9CD, 0xF9CE, 0xF9CF, 0xF9D0,
0xF9D1, 0xF9D2, 0xF9D3, 0xF9D4, 0xF9D5, 0xF9D6, 0xF9D7, 0xF9D8,
0xF9D9, 0xF9DA, 0xF9DB, 0xF9DC, 0xF9DD, 0xF9DE, 0xF9DF, 0xF9E0,
0xF9E1, 0xF9E2, 0xF9E3, 0xF9E4, 0xF9E5, 0xF9E6, 0xF9E7, 0xF9E8,
0xF9E9, 0xF9EA, 0xF9EB, 0xF9EC, 0xF9ED, 0xF9EE, 0xF9EF, 0xF9F0,
0xF9F1, 0xF9F2, 0xF9F3, 0xF9F4, 0xF9F5, 0xF9F6, 0xF9F7, 0xF9F8,
0xF9F9, 0xF9FA, 0xF9FB, 0xF9FC, 0xF9FD, 0xF9FE, 0xF9FF, 0xFA00,
0xFA01, 0xFA02, 0xFA03, 0xFA04, 0xFA05, 0xFA06, 0xFA07, 0xFA08,
0xFA09, 0xFA0A, 0xFA0B, 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, 0xFFE2, 0xFFE3, 0xFFE5, 0xFFE6,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_ksx1001_u_mb[8227] = {
0xA2AE, 0xA2B4, 0xA1D7, 0xA1A7, 0xA8A3, 0xA1A9, 0xA2E7, 0xA1C6,
0xA1BE, 0xA9F7, 0xA9F8, 0xA2A5, 0xA2D2, 0xA1A4, 0xA2AC, 0xA9F6,
0xA8AC, 0xA8F9, 0xA8F6, 0xA8FA, 0xA2AF, 0xA8A1, 0xA8A2, 0xA1BF,
0xA8AA, 0xA8AD, 0xA9AC, 0xA9A1, 0xA9A3, 0xA1C0, 0xA9AA, 0xA9AD,
0xA9A2, 0xA8A4, 0xA9A4, 0xA9A5, 0xA8A6, 0xA9A6, 0xA9A7, 0xA8A8,
0xA9A8, 0xA8A9, 0xA9A9, 0xA9B0, 0xA8AF, 0xA9AF, 0xA8AB, 0xA9AB,
0xA8AE, 0xA9AE, 0xA2A7, 0xA2B0, 0xA2A8, 0xA2AB, 0xA2AA, 0xA2AD,
0xA2A9, 0xA5C1, 0xA5C2, 0xA5C3, 0xA5C4, 0xA5C5, 0xA5C6, 0xA5C7,
0xA5C8, 0xA5C9, 0xA5CA, 0xA5CB, 0xA5CC, 0xA5CD, 0xA5CE, 0xA5CF,
0xA5D0, 0xA5D1, 0xA5D2, 0xA5D3, 0xA5D4, 0xA5D5, 0xA5D6, 0xA5D7,
0xA5D8, 0xA5E1, 0xA5E2, 0xA5E3, 0xA5E4, 0xA5E5, 0xA5E6, 0xA5E7,
0xA5E8, 0xA5E9, 0xA5EA, 0xA5EB, 0xA5EC, 0xA5ED, 0xA5EE, 0xA5EF,
0xA5F0, 0xA5F1, 0xA5F2, 0xA5F3, 0xA5F4, 0xA5F5, 0xA5F6, 0xA5F7,
0xA5F8, 0xACA7, 0xACA1, 0xACA2, 0xACA3, 0xACA4, 0xACA5, 0xACA6,
0xACA8, 0xACA9, 0xACAA, 0xACAB, 0xACAC, 0xACAD, 0xACAE, 0xACAF,
0xACB0, 0xACB1, 0xACB2, 0xACB3, 0xACB4, 0xACB5, 0xACB6, 0xACB7,
0xACB8, 0xACB9, 0xACBA, 0xACBB, 0xACBC, 0xACBD, 0xACBE, 0xACBF,
0xACC0, 0xACC1, 0xACD1, 0xACD2, 0xACD3, 0xACD4, 0xACD5, 0xACD6,
0xACD8, 0xACD9, 0xACDA, 0xACDB, 0xACDC, 0xACDD, 0xACDE, 0xACDF,
0xACE0, 0xACE1, 0xACE2, 0xACE3, 0xACE4, 0xACE5, 0xACE6, 0xACE7,
0xACE8, 0xACE9, 0xACEA, 0xACEB, 0xACEC, 0xACED, 0xACEE, 0xACEF,
0xACF0, 0xACF1, 0xACD7, 0xA1AA, 0xA1AE, 0xA1AF, 0xA1B0, 0xA1B1,
0xA2D3, 0xA2D4, 0xA1A5, 0xA1A6, 0xA2B6, 0xA1C7, 0xA1C8, 0xA1D8,
0xA9F9, 0xA9FA, 0xA9FB, 0xA9FC, 0xA9FD, 0xA9FE, 0xA2E6, 0xA1C9,
0xA2B5, 0xA7A4, 0xA2E0, 0xA2E5, 0xA2E2, 0xA7D9, 0xA1CA, 0xA8F7,
0xA8F8, 0xA8FB, 0xA8FC, 0xA8FD, 0xA8FE, 0xA5B0, 0xA5B1, 0xA5B2,
0xA5B3, 0xA5B4, 0xA5B5, 0xA5B6, 0xA5B7, 0xA5B8, 0xA5B9, 0xA5A1,
0xA5A2, 0xA5A3, 0xA5A4, 0xA5A5, 0xA5A6, 0xA5A7, 0xA5A8, 0xA5A9,
0xA5AA, 0xA1E7, 0xA1E8, 0xA1E6, 0xA1E9, 0xA1EA, 0xA2D5, 0xA2D8,
0xA2D6, 0xA2D9, 0xA2D7, 0xA2A1, 0xA2A2, 0xA2A3, 0xA1D3, 0xA2A4,
0xA1D4, 0xA1F4, 0xA1F5, 0xA2B3, 0xA2B2, 0xA1EE, 0xA1F0, 0xA1C4,
0xA1D0, 0xA1AB, 0xA1FC, 0xA1FD, 0xA1FB, 0xA1FA, 0xA1F2, 0xA1F3,
0xA2B1, 0xA1C5, 0xA1F1, 0xA1AD, 0xA1EF, 0xA1D6, 0xA1C1, 0xA1D5,
0xA1C2, 0xA1C3, 0xA1EC, 0xA1ED, 0xA1F8, 0xA1F9, 0xA1F6, 0xA1F7,
0xA2C1, 0xA1D1, 0xA1D2, 0xA8E7, 0xA8E8, 0xA8E9, 0xA8EA, 0xA8EB,
0xA8EC, 0xA8ED, 0xA8EE, 0xA8EF, 0xA8F0, 0xA8F1, 0xA8F2, 0xA8F3,
0xA8F4, 0xA8F5, 0xA9E7, 0xA9E8, 0xA9E9, 0xA9EA, 0xA9EB, 0xA9EC,
0xA9ED, 0xA9EE, 0xA9EF, 0xA9F0, 0xA9F1, 0xA9F2, 0xA9F3, 0xA9F4,
0xA9F5, 0xA9CD, 0xA9CE, 0xA9CF, 0xA9D0, 0xA9D1, 0xA9D2, 0xA9D3,
0xA9D4, 0xA9D5, 0xA9D6, 0xA9D7, 0xA9D8, 0xA9D9, 0xA9DA, 0xA9DB,
0xA9DC, 0xA9DD, 0xA9DE, 0xA9DF, 0xA9E0, 0xA9E1, 0xA9E2, 0xA9E3,
0xA9E4, 0xA9E5, 0xA9E6, 0xA8CD, 0xA8CE, 0xA8CF, 0xA8D0, 0xA8D1,
0xA8D2, 0xA8D3, 0xA8D4, 0xA8D5, 0xA8D6, 0xA8D7, 0xA8D8, 0xA8D9,
0xA8DA, 0xA8DB, 0xA8DC, 0xA8DD, 0xA8DE, 0xA8DF, 0xA8E0, 0xA8E1,
0xA8E2, 0xA8E3, 0xA8E4, 0xA8E5, 0xA8E6, 0xA6A1, 0xA6AC, 0xA6A2,
0xA6AD, 0xA6A3, 0xA6C8, 0xA6C7, 0xA6AE, 0xA6A4, 0xA6C2, 0xA6C1,
0xA6AF, 0xA6A6, 0xA6C6, 0xA6C5, 0xA6B1, 0xA6A5, 0xA6C4, 0xA6C3,
0xA6B0, 0xA6A7, 0xA6BC, 0xA6C9, 0xA6CA, 0xA6B7, 0xA6CB, 0xA6CC,
0xA6B2, 0xA6A9, 0xA6BE, 0xA6CD, 0xA6CE, 0xA6B9, 0xA6CF, 0xA6D0,
0xA6B4, 0xA6A8, 0xA6D1, 0xA6D2, 0xA6B8, 0xA6BD, 0xA6D3, 0xA6D4,
0xA6B3, 0xA6AA, 0xA6D5, 0xA6D6, 0xA6BA, 0xA6BF, 0xA6D7, 0xA6D8,
0xA6B5, 0xA6AB, 0xA6D9, 0xA6DA, 0xA6BB, 0xA6DB, 0xA6DC, 0xA6C0,
0xA6DD, 0xA6DE, 0xA6DF, 0xA6E0, 0xA6E1, 0xA6E2, 0xA6E3, 0xA6E4,
0xA6B6, 0xA2C6, 0xA1E1, 0xA1E0, 0xA2C3, 0xA2C7, 0xA2C8, 0xA2CB,
0xA2CA, 0xA2C9, 0xA2CC, 0xA1E3, 0xA1E2, 0xA2BA, 0xA2B9, 0xA1E5,
0xA1E4, 0xA2B8, 0xA2B7, 0xA1DF, 0xA1DE, 0xA2C2, 0xA1DB, 0xA1DD,
0xA1DC, 0xA2C4, 0xA2C5, 0xA1DA, 0xA1D9, 0xA2CF, 0xA2CE, 0xA2D0,
0xA2D1, 0xA1CF, 0xA1CE, 0xA2BC, 0xA2BD, 0xA2C0, 0xA2BB, 0xA2BE,
0xA2BF, 0xA2CD, 0xA2DB, 0xA2DC, 0xA2DD, 0xA2DA, 0xA1A1, 0xA1A2,
0xA1A3, 0xA1A8, 0xA1B4, 0xA1B5, 0xA1B6, 0xA1B7, 0xA1B8, 0xA1B9,
0xA1BA, 0xA1BB, 0xA1BC, 0xA1BD, 0xA1EB, 0xA1B2, 0xA1B3, 0xAAA1,
0xAAA2, 0xAAA3, 0xAAA4, 0xAAA5, 0xAAA6, 0xAAA7, 0xAAA8, 0xAAA9,
0xAAAA, 0xAAAB, 0xAAAC, 0xAAAD, 0xAAAE, 0xAAAF, 0xAAB0, 0xAAB1,
0xAAB2, 0xAAB3, 0xAAB4, 0xAAB5, 0xAAB6, 0xAAB7, 0xAAB8, 0xAAB9,
0xAABA, 0xAABB, 0xAABC, 0xAABD, 0xAABE, 0xAABF, 0xAAC0, 0xAAC1,
0xAAC2, 0xAAC3, 0xAAC4, 0xAAC5, 0xAAC6, 0xAAC7, 0xAAC8, 0xAAC9,
0xAACA, 0xAACB, 0xAACC, 0xAACD, 0xAACE, 0xAACF, 0xAAD0, 0xAAD1,
0xAAD2, 0xAAD3, 0xAAD4, 0xAAD5, 0xAAD6, 0xAAD7, 0xAAD8, 0xAAD9,
0xAADA, 0xAADB, 0xAADC, 0xAADD, 0xAADE, 0xAADF, 0xAAE0, 0xAAE1,
0xAAE2, 0xAAE3, 0xAAE4, 0xAAE5, 0xAAE6, 0xAAE7, 0xAAE8, 0xAAE9,
0xAAEA, 0xAAEB, 0xAAEC, 0xAAED, 0xAAEE, 0xAAEF, 0xAAF0, 0xAAF1,
0xAAF2, 0xAAF3, 0xABA1, 0xABA2, 0xABA3, 0xABA4, 0xABA5, 0xABA6,
0xABA7, 0xABA8, 0xABA9, 0xABAA, 0xABAB, 0xABAC, 0xABAD, 0xABAE,
0xABAF, 0xABB0, 0xABB1, 0xABB2, 0xABB3, 0xABB4, 0xABB5, 0xABB6,
0xABB7, 0xABB8, 0xABB9, 0xABBA, 0xABBB, 0xABBC, 0xABBD, 0xABBE,
0xABBF, 0xABC0, 0xABC1, 0xABC2, 0xABC3, 0xABC4, 0xABC5, 0xABC6,
0xABC7, 0xABC8, 0xABC9, 0xABCA, 0xABCB, 0xABCC, 0xABCD, 0xABCE,
0xABCF, 0xABD0, 0xABD1, 0xABD2, 0xABD3, 0xABD4, 0xABD5, 0xABD6,
0xABD7, 0xABD8, 0xABD9, 0xABDA, 0xABDB, 0xABDC, 0xABDD, 0xABDE,
0xABDF, 0xABE0, 0xABE1, 0xABE2, 0xABE3, 0xABE4, 0xABE5, 0xABE6,
0xABE7, 0xABE8, 0xABE9, 0xABEA, 0xABEB, 0xABEC, 0xABED, 0xABEE,
0xABEF, 0xABF0, 0xABF1, 0xABF2, 0xABF3, 0xABF4, 0xABF5, 0xABF6,
0xA4A1, 0xA4A2, 0xA4A3, 0xA4A4, 0xA4A5, 0xA4A6, 0xA4A7, 0xA4A8,
0xA4A9, 0xA4AA, 0xA4AB, 0xA4AC, 0xA4AD, 0xA4AE, 0xA4AF, 0xA4B0,
0xA4B1, 0xA4B2, 0xA4B3, 0xA4B4, 0xA4B5, 0xA4B6, 0xA4B7, 0xA4B8,
0xA4B9, 0xA4BA, 0xA4BB, 0xA4BC, 0xA4BD, 0xA4BE, 0xA4BF, 0xA4C0,
0xA4C1, 0xA4C2, 0xA4C3, 0xA4C4, 0xA4C5, 0xA4C6, 0xA4C7, 0xA4C8,
0xA4C9, 0xA4CA, 0xA4CB, 0xA4CC, 0xA4CD, 0xA4CE, 0xA4CF, 0xA4D0,
0xA4D1, 0xA4D2, 0xA4D3, 0xA4D4, 0xA4D5, 0xA4D6, 0xA4D7, 0xA4D8,
0xA4D9, 0xA4DA, 0xA4DB, 0xA4DC, 0xA4DD, 0xA4DE, 0xA4DF, 0xA4E0,
0xA4E1, 0xA4E2, 0xA4E3, 0xA4E4, 0xA4E5, 0xA4E6, 0xA4E7, 0xA4E8,
0xA4E9, 0xA4EA, 0xA4EB, 0xA4EC, 0xA4ED, 0xA4EE, 0xA4EF, 0xA4F0,
0xA4F1, 0xA4F2, 0xA4F3, 0xA4F4, 0xA4F5, 0xA4F6, 0xA4F7, 0xA4F8,
0xA4F9, 0xA4FA, 0xA4FB, 0xA4FC, 0xA4FD, 0xA4FE, 0xA9B1, 0xA9B2,
0xA9B3, 0xA9B4, 0xA9B5, 0xA9B6, 0xA9B7, 0xA9B8, 0xA9B9, 0xA9BA,
0xA9BB, 0xA9BC, 0xA9BD, 0xA9BE, 0xA9BF, 0xA9C0, 0xA9C1, 0xA9C2,
0xA9C3, 0xA9C4, 0xA9C5, 0xA9C6, 0xA9C7, 0xA9C8, 0xA9C9, 0xA9CA,
0xA9CB, 0xA9CC, 0xA2DF, 0xA8B1, 0xA8B2, 0xA8B3, 0xA8B4, 0xA8B5,
0xA8B6, 0xA8B7, 0xA8B8, 0xA8B9, 0xA8BA, 0xA8BB, 0xA8BC, 0xA8BD,
0xA8BE, 0xA8BF, 0xA8C0, 0xA8C1, 0xA8C2, 0xA8C3, 0xA8C4, 0xA8C5,
0xA8C6, 0xA8C7, 0xA8C8, 0xA8C9, 0xA8CA, 0xA8CB, 0xA8CC, 0xA2E8,
0xA2DE, 0xA7C9, 0xA7CA, 0xA7CB, 0xA7CC, 0xA7CD, 0xA7BA, 0xA7BB,
0xA7DC, 0xA7DD, 0xA7DE, 0xA7B6, 0xA7B7, 0xA7B8, 0xA7D4, 0xA7D5,
0xA7D6, 0xA7D7, 0xA7D8, 0xA7A1, 0xA7A2, 0xA7A3, 0xA7A5, 0xA7AB,
0xA7AC, 0xA7AD, 0xA7AE, 0xA7AF, 0xA7B0, 0xA7B1, 0xA7B2, 0xA7B3,
0xA7B4, 0xA7A7, 0xA7A8, 0xA7A9, 0xA7AA, 0xA7BD, 0xA7BE, 0xA7E5,
0xA7E6, 0xA7E7, 0xA7E8, 0xA7E1, 0xA7E2, 0xA7E3, 0xA7BF, 0xA7C0,
0xA7C1, 0xA7C2, 0xA7C3, 0xA7C4, 0xA7C5, 0xA7C6, 0xA7C7, 0xA7C8,
0xA7CE, 0xA7CF, 0xA7D0, 0xA7D1, 0xA7D2, 0xA7D3, 0xA7DA, 0xA7DB,
0xA2E3, 0xA7EC, 0xA7A6, 0xA7E0, 0xA7EF, 0xA2E1, 0xA7BC, 0xA7ED,
0xA7B5, 0xA7B9, 0xA7EA, 0xA7EB, 0xA7DF, 0xA2E4, 0xA7E4, 0xA7EE,
0xA7E9, 0xECE9, 0xEFCB, 0xF6D2, 0xD8B2, 0xEDDB, 0xDFB2, 0xDFBE,
0xF9BB, 0xDCF4, 0xF5E4, 0xF3A6, 0xDDE0, 0xE1A6, 0xCEF8, 0xDCB0,
0xE3AA, 0xF1E9, 0xCDFA, 0xFCAF, 0xD3A1, 0xF1AB, 0xE7D1, 0xD2AC,
0xCEF9, 0xF1FD, 0xDEBF, 0xFBBA, 0xF9B9, 0xCED2, 0xE3AB, 0xEBE0,
0xCEFA, 0xCBF7, 0xE5A5, 0xCAE1, 0xD4CC, 0xEAE1, 0xDCE3, 0xDFAD,
0xCBEB, 0xD5AF, 0xD6F5, 0xE5F8, 0xDEC0, 0xECA3, 0xE9CD, 0xEAA7,
0xE9F6, 0xFBBB, 0xE7E9, 0xEFCC, 0xD0E6, 0xDEC1, 0xE4AC, 0xD8CC,
0xF9F1, 0xCEDF, 0xFAA4, 0xE6B2, 0xFAFB, 0xFABD, 0xCCC8, 0xEFCD,
0xD5D5, 0xD3A2, 0xECD1, 0xE4A7, 0xECD2, 0xF6B1, 0xCEFB, 0xD0D1,
0xCBBF, 0xEDA4, 0xEDA8, 0xDEC2, 0xF6E2, 0xEDDC, 0xDCF5, 0xE0B9,
0xD4CE, 0xF4B5, 0xD3DB, 0xD6B5, 0xECA4, 0xE4E6, 0xF1EA, 0xCBEC,
0xCBC0, 0xECF2, 0xD0EA, 0xF9F2, 0xECA5, 0xD0DF, 0xE7EA, 0xD0EB,
0xDCD1, 0xDBE9, 0xFDCC, 0xDBD7, 0xDAE1, 0xD6B6, 0xE3DF, 0xDEC3,
0xDEC4, 0xCAA1, 0xEEEC, 0xD3A3, 0xEEB7, 0xF8CF, 0xEAC8, 0xEEB8,
0xF1AC, 0xF1A5, 0xE9CE, 0xF9BC, 0xE5F9, 0xECEA, 0xDDD6, 0xEDC2,
0xF8A5, 0xE5BA, 0xDBD8, 0xCAA2, 0xD1CD, 0xEEED, 0xECEB, 0xDEC5,
0xE3E0, 0xCAC9, 0xF2E9, 0xD5CE, 0xF6B6, 0xCEC2, 0xD6C7, 0xE3B4,
0xF1AD, 0xEAE2, 0xD7C2, 0xF3A7, 0xCDEA, 0xEBEE, 0xD9B2, 0xFDA5,
0xF6D5, 0xD5E2, 0xF8B5, 0xCCF5, 0xF5B5, 0xE4AD, 0xE7EB, 0xF1D5,
0xF0BB, 0xE9B5, 0xCCC9, 0xFAD5, 0xE1D4, 0xD7D6, 0xDCC1, 0xDEC6,
0xFAEF, 0xE3E1, 0xE1F3, 0xDCF6, 0xCEFC, 0xDBC4, 0xF8F1, 0xDCE4,
0xE5EF, 0xDCB1, 0xD5D6, 0xF3DA, 0xCBC1, 0xDBC3, 0xD9FA, 0xD3EE,
0xFAB8, 0xFDA6, 0xEBEF, 0xF4A6, 0xCCCA, 0xF3A8, 0xF3DB, 0xDBA7,
0xF6B7, 0xCFE6, 0xF0F2, 0xCBDA, 0xE7D2, 0xD7C3, 0xF6F0, 0xE8DE,
0xE5A6, 0xE5E7, 0xCAA3, 0xCCA7, 0xEAC9, 0xF8B6, 0xFAA5, 0xF1AE,
0xEFCE, 0xCBED, 0xF6B0, 0xEFCF, 0xE9CF, 0xF7DE, 0xCED3, 0xDCF7,
0xDBA8, 0xCBF8, 0xDFA1, 0xDDE1, 0xF5CA, 0xE9B6, 0xE7EC, 0xEEEE,
0xF3F0, 0xDFBF, 0xCCCB, 0xD0C1, 0xF4D2, 0xE0BA, 0xDFC0, 0xCEE0,
0xDCD2, 0xFDEA, 0xD6F6, 0xEACA, 0xE8E9, 0xE3AC, 0xF3D0, 0xCAA4,
0xDBF8, 0xDEC7, 0xEBF0, 0xF1D6, 0xE5E2, 0xCCCC, 0xCBFB, 0xEAE3,
0xDFC1, 0xD6ED, 0xE9D0, 0xEEB9, 0xD5E3, 0xD1D3, 0xE5F0, 0xE8B4,
0xEBC3, 0xEAAA, 0xFAFC, 0xF5F6, 0xF0BC, 0xFDD4, 0xE0BB, 0xCEC3,
0xD0BA, 0xF7BA, 0xD8F3, 0xF7CD, 0xE4AE, 0xD4DF, 0xD0E7, 0xECFD,
0xD2AE, 0xEEEF, 0xD5D7, 0xEAE4, 0xF8A2, 0xCDEB, 0xD7BF, 0xFBB1,
0xCDEC, 0xDCB2, 0xD0EC, 0xCEFD, 0xEEF0, 0xCCC2, 0xD0ED, 0xE5F7,
0xF3FC, 0xEEA2, 0xD9B3, 0xD8F4, 0xE9B7, 0xCEAE, 0xD9A2, 0xD8F1,
0xD4CF, 0xE5A7, 0xD5D2, 0xD6A9, 0xF4A2, 0xF1D7, 0xD5D8, 0xF0BD,
0xD7D0, 0xD4D0, 0xD7CF, 0xEBEA, 0xFDEB, 0xDBED, 0xFCC5, 0xCBC2,
0xFDD5, 0xF4C8, 0xE8EA, 0xF5F3, 0xF9DE, 0xD3EF, 0xECD3, 0xDDC2,
0xEFB7, 0xE7D4, 0xCACA, 0xD9FB, 0xFAFD, 0xD6AA, 0xF4F8, 0xF7F7,
0xDCAC, 0xD7D7, 0xDFA2, 0xCEBE, 0xD3F0, 0xF0A4, 0xE1EC, 0xCFE7,
0xF3CB, 0xEDA9, 0xCABE, 0xF4EF, 0xF6CE, 0xDEFB, 0xD0BB, 0xD5B7,
0xEEF1, 0xF4A8, 0xDCF8, 0xCBA7, 0xDACE, 0xE0E6, 0xEDA5, 0xEEF2,
0xDCF9, 0xF9DC, 0xF3DC, 0xF8F2, 0xF4F9, 0xFCF1, 0xD0BC, 0xDBF9,
0xD7B1, 0xCBFC, 0xF0A5, 0xCBFD, 0xD5F4, 0xCDED, 0xCAA5, 0xD6AB,
0xD0C2, 0xF0BE, 0xD2BD, 0xCCA4, 0xFAB6, 0xCCCD, 0xDAFA, 0xF6CF,
0xE9B8, 0xD8F5, 0xCCCE, 0xD7CD, 0xD4D1, 0xE9ED, 0xCAEB, 0xD9E2,
0xFDB2, 0xE3AD, 0xD6CC, 0xD9B4, 0xE1A7, 0xEED3, 0xD0C3, 0xFDB3,
0xD5E4, 0xCFE8, 0xEDC3, 0xD0B2, 0xCEFE, 0xDAA8, 0xF8D0, 0xFDD6,
0xF8D1, 0xF8D2, 0xDCD3, 0xDDE2, 0xFBF9, 0xDDC1, 0xE3B5, 0xEDDD,
0xCEC4, 0xCBA1, 0xDDE3, 0xFCDD, 0xF9AF, 0xD2FB, 0xCFA1, 0xE4A8,
0xF4B6, 0xECFE, 0xE3AE, 0xE7ED, 0xFDC1, 0xDAE2, 0xD8B3, 0xDDE4,
0xF0EF, 0xF6F1, 0xFAF0, 0xD1F5, 0xDACF, 0xDCD4, 0xDCA6, 0xEFBF,
0xCECF, 0xE0D9, 0xD9D6, 0xECD4, 0xEACB, 0xCABF, 0xD5B0, 0xCFE9,
0xF1ED, 0xCCCF, 0xE4F8, 0xE4ED, 0xD7D8, 0xFDA7, 0xEAAB, 0xF6B2,
0xCFF0, 0xF9BD, 0xE6F4, 0xCBDB, 0xF3D1, 0xE9D1, 0xF3A9, 0xD0E0,
0xE9D2, 0xDAE3, 0xE2D2, 0xF6A2, 0xE1F4, 0xDAE4, 0xE7D5, 0xF5BF,
0xCFA2, 0xCDAF, 0xCFA3, 0xCDB0, 0xF1FE, 0xD0A3, 0xE1AF, 0xF8A3,
0xCAA6, 0xF7BB, 0xF2EA, 0xDEC8, 0xE9D3, 0xDEC9, 0xFDDE, 0xCAC0,
0xF9EA, 0xD1CE, 0xEED4, 0xD4D2, 0xD9A3, 0xFDA8, 0xD7D9, 0xF7CE,
0xFABE, 0xCFD6, 0xD7F0, 0xEBE1, 0xF8C5, 0xDCFA, 0xDDC3, 0xF9DF,
0xE7EF, 0xFDE5, 0xF6A3, 0xD9FC, 0xFDA9, 0xE7EE, 0xD5E5, 0xEFD0,
0xCDB1, 0xF7A2, 0xF1B2, 0xF1B1, 0xCDB2, 0xDAAB, 0xCAA7, 0xE3E2,
0xFBBC, 0xD9A4, 0xEEBA, 0xF8D3, 0xFBFA, 0xCFA4, 0xDCFB, 0xF6E3,
0xEDAA, 0xF2A1, 0xCEE1, 0xFAA6, 0xF9E0, 0xECD6, 0xE4EE, 0xF9A1,
0xFBEF, 0xF9EB, 0xEEA3, 0xEAAC, 0xCAA8, 0xF4FA, 0xCDD6, 0xFCF6,
0xF4C9, 0xF8D4, 0xF8A6, 0xDECA, 0xF2C6, 0xD7DA, 0xD3D0, 0xD8C5,
0xEAE6, 0xF3DD, 0xE4DA, 0xF6E4, 0xF6F2, 0xDFC2, 0xD9FD, 0xCCF6,
0xD3BA, 0xE4AF, 0xF9E1, 0xF0A6, 0xCBD3, 0xE0BC, 0xF4CA, 0xD4FA,
0xFDAA, 0xF9E2, 0xF4B7, 0xFDC2, 0xFCB0, 0xFDEC, 0xCAE2, 0xFDBD,
0xEAE7, 0xDFC3, 0xD1D2, 0xCEE2, 0xD3A4, 0xFDAB, 0xDFE0, 0xF2C7,
0xE7F0, 0xD0EE, 0xF3AA, 0xDECB, 0xF6B8, 0xE1F5, 0xF1B3, 0xF7A3,
0xCAA9, 0xCFA5, 0xDFC4, 0xE1B0, 0xF0BF, 0xF6A4, 0xE3B6, 0xFAC6,
0xD0EF, 0xFDED, 0xDDC4, 0xFCF7, 0xE6BF, 0xDEAD, 0xFABF, 0xE5F1,
0xEDC4, 0xD2A5, 0xFDEE, 0xF5B6, 0xE1F6, 0xDECC, 0xFCDE, 0xECD7,
0xCDDD, 0xD6B7, 0xCDB3, 0xF8D5, 0xE5D8, 0xCFEA, 0xCFD0, 0xEACC,
0xEAAE, 0xEAAD, 0xD3F1, 0xD3A5, 0xF7CF, 0xEEA4, 0xD0A4, 0xF2A2,
0xD0F0, 0xF2A3, 0xF7F8, 0xD0B3, 0xDBA9, 0xD3BB, 0xCAEC, 0xF1A6,
0xCBD5, 0xF7E7, 0xCDDE, 0xF7A4, 0xF8C0, 0xD3DD, 0xCCD0, 0xCFA6,
0xF6F3, 0xE1F7, 0xD3DC, 0xFAFE, 0xFAA7, 0xEBD9, 0xCFA7, 0xEAAF,
0xE4EF, 0xE9B9, 0xF1D8, 0xD8D8, 0xE0F2, 0xE6B4, 0xDCFC, 0xF3F1,
0xE3D0, 0xF2FB, 0xDBC6, 0xD0F1, 0xD0F2, 0xCFDC, 0xD3D1, 0xCCB1,
0xF7D8, 0xCBA8, 0xEBBC, 0xE4BE, 0xF4DC, 0xDCC2, 0xF0A7, 0xE6C0,
0xCAED, 0xE8EB, 0xE5E8, 0xDCC3, 0xEDDE, 0xD3F2, 0xCCF7, 0xCED4,
0xE7AB, 0xCBC3, 0xE1B1, 0xF7B2, 0xD3F3, 0xD3D2, 0xF5C0, 0xDFDD,
0xEEF3, 0xE7F1, 0xFDB4, 0xF2C8, 0xF3D2, 0xEEF4, 0xE2D3, 0xCCD1,
0xDFEA, 0xE9BA, 0xD9D7, 0xF5CD, 0xF1F2, 0xFAC7, 0xD9F8, 0xD4C2,
0xF6E5, 0xDDC5, 0xE7F2, 0xEDDF, 0xCACB, 0xDBFA, 0xE8B5, 0xD3A6,
0xFDB5, 0xF9C9, 0xE4E2, 0xFBBD, 0xD7A4, 0xCEC5, 0xCED5, 0xD6E6,
0xE5BD, 0xDECD, 0xECF3, 0xEDE0, 0xECEC, 0xFBBE, 0xDFEB, 0xE1F8,
0xF9BE, 0xD0F3, 0xE0AA, 0xE8E2, 0xE2D4, 0xD2FD, 0xE5A8, 0xD9D3,
0xD3DE, 0xF4B8, 0xF7BC, 0xDCFD, 0xE8EC, 0xE4E7, 0xE3F7, 0xECA8,
0xFAF1, 0xE5F2, 0xD0F4, 0xD2AF, 0xDCE5, 0xD0A5, 0xF1B4, 0xFCB1,
0xCCF8, 0xDDC6, 0xFAD1, 0xF7DF, 0xFAA8, 0xEEF5, 0xDECE, 0xE7F3,
0xF7AC, 0xEBC4, 0xEDE1, 0xE0AB, 0xDDC7, 0xD2B3, 0xD2BF, 0xCACC,
0xFBBF, 0xE5FD, 0xDDE5, 0xD8CD, 0xECF4, 0xD0F5, 0xE8ED, 0xD0D2,
0xD9D8, 0xF6E6, 0xDBAA, 0xF7E0, 0xD8D9, 0xF4A3, 0xF4DD, 0xEFD1,
0xD9B5, 0xEDAB, 0xE3B7, 0xEEBB, 0xCDB4, 0xE0F3, 0xEACD, 0xECF5,
0xE8EE, 0xCBA9, 0xF1AF, 0xCACD, 0xECA9, 0xF2EB, 0xFDEF, 0xF9F3,
0xE6C1, 0xECD8, 0xEDAC, 0xEACE, 0xE8DF, 0xDECF, 0xD2A6, 0xE7F4,
0xD1D6, 0xE6C2, 0xE3E3, 0xE4B0, 0xD8B4, 0xF6A5, 0xF3DE, 0xD7A5,
0xF7E8, 0xE8C6, 0xFBE6, 0xDDE6, 0xDCFE, 0xD8DA, 0xDAAC, 0xEAB0,
0xE3B8, 0xCAAA, 0xE1F9, 0xEAB1, 0xF2EC, 0xFAEE, 0xEED5, 0xF9F4,
0xD2EC, 0xFBFB, 0xFDF0, 0xE0BD, 0xCEE3, 0xF8C6, 0xDEAE, 0xDFC5,
0xE5BE, 0xEDAD, 0xFAEA, 0xCDEE, 0xEDA6, 0xEDAE, 0xF0ED, 0xDDA1,
0xEDAF, 0xFCF8, 0xD8EB, 0xCCF9, 0xCDB5, 0xFAA9, 0xE1DD, 0xE2D5,
0xEDCF, 0xDDA2, 0xF9CA, 0xEAE8, 0xE5ED, 0xD3EB, 0xE9D4, 0xE1FA,
0xE4CC, 0xE1E4, 0xE8C7, 0xCEDB, 0xDCD5, 0xF7B5, 0xFCF3, 0xF0F3,
0xCEAF, 0xF1B5, 0xEFD2, 0xE8C8, 0xEBF1, 0xCBD4, 0xE0BE, 0xE3F8,
0xEAE9, 0xFCB2, 0xE0F4, 0xCFE0, 0xEEA5, 0xFAAA, 0xE6C3, 0xE1B2,
0xCAAB, 0xE3E4, 0xE9BB, 0xE2D6, 0xF3F2, 0xEED6, 0xEAB2, 0xD0F6,
0xECD9, 0xDACB, 0xCFA8, 0xDDA3, 0xD8DB, 0xF9CE, 0xE9D5, 0xE3D1,
0xD2BC, 0xD8AC, 0xF3CC, 0xCDFB, 0xF6D6, 0xE7F5, 0xE8EF, 0xE3F9,
0xD2BB, 0xF3F3, 0xE3FB, 0xDED0, 0xCEB0, 0xD6F7, 0xF1D9, 0xF5C1,
0xDCC4, 0xF5BB, 0xDED1, 0xDCE6, 0xDED2, 0xEDE2, 0xEEF6, 0xEACF,
0xF0EE, 0xE3FC, 0xD3DF, 0xD3F4, 0xE1B3, 0xE1B4, 0xF4D3, 0xDFC6,
0xE9D6, 0xDBAB, 0xF6A6, 0xE3B9, 0xEBC5, 0xF4A9, 0xCDB6, 0xD2F9,
0xDAAD, 0xD2E3, 0xCFD1, 0xCBDC, 0xCCFA, 0xCFDD, 0xE8A9, 0xE3BB,
0xE3BA, 0xE0DA, 0xEEF7, 0xDCB3, 0xD3F5, 0xD7A6, 0xF6B5, 0xD7DB,
0xE1D5, 0xD4EA, 0xDFA3, 0xFDDF, 0xD0F7, 0xEDD4, 0xCBAA, 0xE4DB,
0xE1FB, 0xCBA2, 0xD3E0, 0xE4BF, 0xFBC0, 0xDABE, 0xE4CD, 0xD6B9,
0xEFC0, 0xE1FC, 0xF6B9, 0xDFC7, 0xE4B1, 0xDCE7, 0xDCE8, 0xFAD6,
0xD3F6, 0xF1DA, 0xFAF2, 0xE2FD, 0xD5CF, 0xD0F8, 0xCDDF, 0xF5CB,
0xE4F0, 0xCBAB, 0xD7C4, 0xE2FE, 0xDDDA, 0xDAAE, 0xCAEE, 0xD5B9,
0xE3A1, 0xE8E3, 0xF3AB, 0xCFA9, 0xD3F7, 0xD4F1, 0xCEE4, 0xE8F2,
0xE5F5, 0xE7AE, 0xD6BA, 0xDFEC, 0xE4C0, 0xE8E4, 0xD8B5, 0xE4DC,
0xF4B9, 0xF1B6, 0xE2DE, 0xE1B5, 0xCDEF, 0xF1A7, 0xCEE5, 0xCBDD,
0xD9E3, 0xF3AC, 0xD0F9, 0xECAB, 0xDED3, 0xF7E9, 0xF9F5, 0xE1DE,
0xCBEE, 0xE3BC, 0xF8D6, 0xDBEE, 0xFDF1, 0xF7B6, 0xF4DE, 0xF2ED,
0xDBD9, 0xF0A8, 0xE1FD, 0xDED4, 0xE0AC, 0xEDE3, 0xD3E1, 0xDFC8,
0xD9B6, 0xFDAC, 0xEFD3, 0xE4C1, 0xF8EB, 0xDBAC, 0xFCC6, 0xD8AD,
0xF6BA, 0xDBDF, 0xD3D3, 0xF8C7, 0xCACE, 0xF8C1, 0xD2B4, 0xDCB4,
0xFAB9, 0xCACF, 0xFCB3, 0xEAEA, 0xEAEB, 0xD0FA, 0xEDE4, 0xDDE7,
0xDFC9, 0xDFED, 0xEEBC, 0xEFC1, 0xCCD2, 0xDDA4, 0xDFCA, 0xD3F8,
0xF1A8, 0xCDB7, 0xEFD4, 0xE4DD, 0xDFEE, 0xCBAC, 0xE9BC, 0xEAEC,
0xDFCB, 0xF9BF, 0xD6AF, 0xD5C6, 0xCFAA, 0xCEA9, 0xD6F8, 0xF1B7,
0xEEF8, 0xD9D9, 0xF3DF, 0xF8C8, 0xCEC6, 0xD5E6, 0xF4E6, 0xE6C5,
0xEFD5, 0xCBEF, 0xFCDF, 0xDCA7, 0xD6E7, 0xF8C9, 0xE3D2, 0xE3BD,
0xCFE1, 0xF0C0, 0xECDA, 0xDDD7, 0xFBF0, 0xECAC, 0xF0A9, 0xFAD7,
0xFBC1, 0xD2C0, 0xE5B0, 0xEDE5, 0xCBAD, 0xF9B0, 0xF7A5, 0xCBAE,
0xDAAF, 0xD8B6, 0xD3A7, 0xFBB2, 0xFDC4, 0xECAD, 0xFBA1, 0xE5E9,
0xE9EE, 0xF3F4, 0xF8F3, 0xF0C1, 0xDEAF, 0xF8B0, 0xF3E0, 0xE7AF,
0xDBAD, 0xE6B5, 0xF9A8, 0xDDD8, 0xE8D9, 0xEFD6, 0xD3E2, 0xE2DF,
0xFCE0, 0xD7C8, 0xFDAD, 0xDFEF, 0xCCD3, 0xD3F9, 0xD4F0, 0xDBC7,
0xDED5, 0xF0F4, 0xD5D0, 0xE5D9, 0xFCC7, 0xDCD6, 0xE2E0, 0xDAB0,
0xF3A3, 0xD3EC, 0xF4CB, 0xFDC5, 0xE3FD, 0xF9B1, 0xD0FB, 0xECDB,
0xF5BC, 0xF2A4, 0xD8CE, 0xD8CF, 0xF5F7, 0xF6E1, 0xD2B7, 0xFBEC,
0xDDC8, 0xE4E8, 0xD2C1, 0xF8D7, 0xD6BB, 0xDED6, 0xF7BD, 0xECAE,
0xD0E1, 0xE0F5, 0xEAB3, 0xCED6, 0xCCA5, 0xECF6, 0xE2E1, 0xE3BE,
0xFCC8, 0xCDF0, 0xF9F6, 0xDFF0, 0xE5BF, 0xCEBF, 0xFCE1, 0xEDB0,
0xFDD1, 0xF6BB, 0xF9CF, 0xEBDA, 0xCAC1, 0xD2B8, 0xCDF1, 0xE3D3,
0xFDE6, 0xE6ED, 0xE3FA, 0xF0AA, 0xF9D0, 0xFCE2, 0xF8A7, 0xE1E5,
0xEEF9, 0xE7F6, 0xEAED, 0xFCB4, 0xF5C2, 0xD7DC, 0xF0F5, 0xDDE8,
0xD3ED, 0xF5FC, 0xDABF, 0xCCFB, 0xD3FA, 0xF4A4, 0xEFD7, 0xD4C3,
0xFBE3, 0xFBED, 0xE0AD, 0xEAEE, 0xFBB3, 0xE4C2, 0xF6E7, 0xD2DD,
0xDFCC, 0xFCC9, 0xE5A9, 0xE0F6, 0xF6B3, 0xE1FE, 0xCBF0, 0xEAEF,
0xEAF0, 0xDAC0, 0xF8B4, 0xEBF2, 0xE4C3, 0xE9D7, 0xE4F1, 0xCAEF,
0xCED7, 0xFCCA, 0xF3E1, 0xCBC4, 0xE3E5, 0xCBC5, 0xEAB4, 0xE9BD,
0xD7C9, 0xEBDB, 0xEDB1, 0xCCC3, 0xF7BE, 0xFCCB, 0xF8F4, 0xD9B7,
0xF3D3, 0xF3D4, 0xF7E4, 0xF7D1, 0xD8B7, 0xCEB1, 0xCAC2, 0xFBB4,
0xCBC6, 0xF0F6, 0xD5E7, 0xEAD0, 0xCCD4, 0xCBAF, 0xF4AA, 0xE9AF,
0xF5C3, 0xE9D8, 0xDDE9, 0xF1F3, 0xD5FB, 0xDEBB, 0xF4FB, 0xFDF3,
0xFDF2, 0xF7A6, 0xDDC9, 0xD4D3, 0xCCA8, 0xDAC1, 0xCCD5, 0xD9E4,
0xFACA, 0xE5E3, 0xD3BC, 0xCAF0, 0xD0C4, 0xCAD0, 0xFAAB, 0xEBEB,
0xE7F8, 0xD9E5, 0xD1D7, 0xF3A4, 0xD4FB, 0xFCE3, 0xFAD8, 0xF3D5,
0xCFAB, 0xEBF3, 0xD5FC, 0xD3D4, 0xCDFC, 0xD9E6, 0xE2F9, 0xE2A1,
0xEBD4, 0xE0F7, 0xE4B2, 0xCCFC, 0xFBE4, 0xF4AB, 0xD0BD, 0xCAF1,
0xEFB8, 0xD7C0, 0xEEFA, 0xFDF4, 0xD3E3, 0xFBC2, 0xD5E8, 0xDBAE,
0xE1B6, 0xF8B7, 0xE0BF, 0xFBC3, 0xDDEA, 0xE2A2, 0xEEA6, 0xF6E8,
0xF6F5, 0xDDCA, 0xD0E2, 0xDDA6, 0xDDEB, 0xE4F9, 0xE3AF, 0xD0FC,
0xF4FC, 0xCCBC, 0xF7EA, 0xE5E4, 0xDFF1, 0xF7E1, 0xF9F7, 0xEFB9,
0xF8D8, 0xF9A9, 0xF8D9, 0xEEBD, 0xD8C6, 0xE4E3, 0xF5CE, 0xDDD9,
0xD9E7, 0xD2B9, 0xD5C3, 0xDAE5, 0xDAD0, 0xD1D9, 0xCED8, 0xCBDE,
0xF4AC, 0xDAFB, 0xF6E9, 0xE8F3, 0xCFAC, 0xF0F0, 0xF4FD, 0xDBC8,
0xCEC0, 0xE3D4, 0xD1CF, 0xF1F5, 0xCDF2, 0xCFEB, 0xCDB8, 0xE3A6,
0xD1DA, 0xF2A5, 0xF2A6, 0xE4CE, 0xD3FB, 0xF1A9, 0xF2C9, 0xEFD8,
0xE6C9, 0xD8B8, 0xFAF3, 0xF3B5, 0xF8A4, 0xD1F3, 0xE6C8, 0xF8DA,
0xDCE9, 0xDED7, 0xCBDF, 0xCFEC, 0xF4DF, 0xD1F4, 0xD2BA, 0xDFF2,
0xE1B7, 0xE2A3, 0xD3FC, 0xEDE6, 0xDBC9, 0xE4FA, 0xCFDE, 0xCED0,
0xD5D3, 0xF3F5, 0xF7AE, 0xEFC8, 0xCDF3, 0xF5CF, 0xE5F3, 0xF0C2,
0xCAD1, 0xEAF1, 0xD0A6, 0xD9DA, 0xF0AB, 0xEBE7, 0xE5C0, 0xFCB5,
0xE4C4, 0xCCA9, 0xFDC6, 0xEAB5, 0xE5AA, 0xDFBA, 0xE1DF, 0xDAD1,
0xE1B8, 0xE8F4, 0xD3FD, 0xE2A4, 0xF2CA, 0xDAE6, 0xF7B3, 0xFDCD,
0xF3B6, 0xEED7, 0xF5C4, 0xD8A4, 0xF2A7, 0xD9B8, 0xD9B9, 0xEFC9,
0xD6CE, 0xF7CB, 0xDFAE, 0xE8F5, 0xD2B5, 0xD3D5, 0xF4CC, 0xDAFC,
0xD9E8, 0xF7EB, 0xF5C9, 0xF3BC, 0xDAD2, 0xD3B5, 0xE8B6, 0xD6CF,
0xF4BA, 0xF7C9, 0xCCAA, 0xF0C3, 0xCCD6, 0xD0D3, 0xD3BD, 0xDBFB,
0xCBE0, 0xD3E4, 0xF6F7, 0xD5BA, 0xF3CD, 0xCBE1, 0xEBF4, 0xF4AD,
0xFCAA, 0xF7EC, 0xE8F6, 0xDAE7, 0xF7CC, 0xE5C1, 0xE0EE, 0xD5FD,
0xCEE6, 0xFCAB, 0xD5BB, 0xF2A8, 0xE2A5, 0xCDB9, 0xEAF2, 0xCBC7,
0xCDF4, 0xDBAF, 0xEFD9, 0xCDBA, 0xFCF9, 0xDFF3, 0xCEE7, 0xDAC2,
0xCFAD, 0xE7F9, 0xF8A8, 0xF3E2, 0xCAF2, 0xDFA4, 0xD4C4, 0xCCD7,
0xE5C2, 0xCDBB, 0xEFDA, 0xEED8, 0xDDA7, 0xE2A6, 0xE0C0, 0xD6B0,
0xF8CA, 0xFCFA, 0xD9FE, 0xDEB0, 0xDDEC, 0xDAE8, 0xD4E0, 0xD6F9,
0xCDD7, 0xDED8, 0xF2F8, 0xE4D6, 0xD0C5, 0xF4AE, 0xDDA8, 0xEDC5,
0xF3D6, 0xDED9, 0xE3E6, 0xD3A8, 0xDBB0, 0xE5DA, 0xE3BF, 0xDBB1,
0xD5E9, 0xE0C1, 0xEFDB, 0xF0E9, 0xD7B2, 0xD0FD, 0xD9E9, 0xD0FE,
0xECED, 0xD3A9, 0xF2A9, 0xF0C4, 0xE2E2, 0xE9EF, 0xF9D1, 0xE9D9,
0xE8DA, 0xDAC3, 0xDAC4, 0xD4C5, 0xE7FA, 0xCDE0, 0xE3B0, 0xDBB2,
0xFBC4, 0xF3E3, 0xD9A5, 0xFBE7, 0xDDCB, 0xD0D4, 0xE6B6, 0xE0AE,
0xFDDA, 0xDCB5, 0xE0F8, 0xE7B1, 0xF5F0, 0xD8DC, 0xEDC6, 0xE1B9,
0xE3C0, 0xF9C0, 0xE9F0, 0xD9DB, 0xF3E4, 0xDCB6, 0xE4E9, 0xF0C5,
0xE3C1, 0xFCCC, 0xFCCD, 0xF2CB, 0xF2CC, 0xE4CF, 0xF1DB, 0xFAD9,
0xF1B8, 0xFDF5, 0xE0F9, 0xE7FB, 0xFCB7, 0xFCE4, 0xFBC5, 0xE3E7,
0xD8B9, 0xF6F8, 0xDCC5, 0xCCD8, 0xE0AF, 0xF4E7, 0xEFDC, 0xCFFC,
0xEFDD, 0xF2AA, 0xFDBE, 0xCAAC, 0xFDBB, 0xFDC7, 0xE7B2, 0xEAD1,
0xDFF4, 0xD1EC, 0xE4DE, 0xE5C3, 0xD9A6, 0xCDBC, 0xF3E5, 0xEDD5,
0xD9BA, 0xEDE7, 0xFBB5, 0xF8EC, 0xE0E7, 0xCCD9, 0xD4C6, 0xE7A5,
0xD5F5, 0xD3BE, 0xFCFB, 0xE4F2, 0xDFF5, 0xE8F8, 0xF8ED, 0xCEC7,
0xFDF6, 0xE8D8, 0xCDD8, 0xE7D6, 0xCCDA, 0xCAE3, 0xDFF6, 0xF0C7,
0xF0C6, 0xD8BA, 0xF1F4, 0xF4F0, 0xF5CC, 0xFCE5, 0xEAC5, 0xEAF3,
0xDDDB, 0xDCD7, 0xDEFD, 0xF2F9, 0xD5C7, 0xD8D0, 0xF0C8, 0xD1A1,
0xD1A2, 0xD9D4, 0xD6E8, 0xD9CA, 0xDAB1, 0xD8C7, 0xDCE2, 0xF3CE,
0xF5F4, 0xF1B9, 0xDAD3, 0xF6EA, 0xCFF5, 0xFDAE, 0xCAD2, 0xDFB4,
0xD7DD, 0xFABA, 0xEEA7, 0xF5BD, 0xF8F5, 0xEDE8, 0xD4E1, 0xD1A3,
0xE1D6, 0xF9F8, 0xDBCA, 0xCBF9, 0xD4D4, 0xD9DC, 0xEEBE, 0xF7ED,
0xD2EE, 0xE1E6, 0xF7F9, 0xDDED, 0xE8DB, 0xDBB3, 0xD1F7, 0xE0B0,
0xD4E2, 0xF6D7, 0xD7F9, 0xD8DD, 0xCDFD, 0xF2AB, 0xCDBD, 0xF8C2,
0xF2AC, 0xCAAD, 0xCAAE, 0xCFAE, 0xE3C2, 0xDCB7, 0xDBDA, 0xD9BB,
0xCAF3, 0xF6D3, 0xE6F8, 0xEAF5, 0xEAF6, 0xF6F9, 0xCFAF, 0xCAD3,
0xCAAF, 0xD2B0, 0xF1BA, 0xD7B3, 0xE3C3, 0xF3FD, 0xDEDA, 0xDEDB,
0xEFDE, 0xE2E3, 0xEEFB, 0xDFF7, 0xD7CA, 0xCEE8, 0xDBDB, 0xF1BB,
0xE9F1, 0xFAB7, 0xD0C6, 0xCCAB, 0xEEA8, 0xCBFA, 0xF9F9, 0xCCFD,
0xD3FE, 0xE4D0, 0xF2EE, 0xD4D5, 0xDFCD, 0xFCB8, 0xD1D0, 0xF2CD,
0xF7D2, 0xCAD4, 0xD5D9, 0xD8DE, 0xCDD9, 0xEEA9, 0xF6BC, 0xCCDB,
0xF0C9, 0xFCFC, 0xE8C9, 0xF4FE, 0xE7FC, 0xD7DE, 0xDEDC, 0xF0AC,
0xCCFE, 0xCDE1, 0xE1BA, 0xDBEF, 0xDAB2, 0xD1A5, 0xDCB8, 0xD8F6,
0xD1A4, 0xCDE2, 0xDCEA, 0xF0F7, 0xF0CA, 0xD0BE, 0xDDDC, 0xD4D6,
0xD3D6, 0xEDD0, 0xCDA1, 0xDFB5, 0xDFF8, 0xD4A1, 0xCEB2, 0xE8CA,
0xEBF5, 0xE3D5, 0xF5D0, 0xF5A1, 0xD9A7, 0xE5AB, 0xE6CB, 0xF5F1,
0xE5C5, 0xF9A3, 0xE0DB, 0xF6EB, 0xCBF1, 0xD9EA, 0xF5A2, 0xD7D1,
0xD1F8, 0xEAF8, 0xEAF9, 0xDAB3, 0xEFDF, 0xF1EF, 0xE5F6, 0xEEBF,
0xE2E4, 0xD0BF, 0xFAAC, 0xF5D1, 0xE7B3, 0xE9BE, 0xF2CE, 0xDBB4,
0xFCCE, 0xDDEE, 0xE7B4, 0xD7B4, 0xF7B4, 0xCDBE, 0xDAE9, 0xCFB0,
0xF7D9, 0xF3E6, 0xCED9, 0xCEAA, 0xCBC8, 0xD0A7, 0xF0CB, 0xD0C7,
0xE4C5, 0xDBE0, 0xD5DA, 0xD7A7, 0xEEC0, 0xF8F6, 0xF5D2, 0xEDE9,
0xD9BC, 0xE5C6, 0xF5A3, 0xDAD4, 0xE2A7, 0xFBFC, 0xF1DC, 0xCAF4,
0xE8FA, 0xCEE9, 0xE9F8, 0xE2E5, 0xD0B9, 0xD4F2, 0xD1A6, 0xDFCE,
0xFCF4, 0xD3AA, 0xCCAC, 0xEFE0, 0xE5E5, 0xD0D5, 0xDBFC, 0xFCE6,
0xCBFE, 0xEDEA, 0xDEB1, 0xF9E3, 0xD4A2, 0xCFF6, 0xD6D0, 0xD5EA,
0xF1EE, 0xFACB, 0xE5A1, 0xD5B1, 0xCFED, 0xEDEB, 0xD5B2, 0xD5BC,
0xFDE2, 0xF3AD, 0xFDDB, 0xE9B0, 0xD1A7, 0xFDE3, 0xCEB3, 0xFDE4,
0xFACE, 0xCAB0, 0xF7A7, 0xCFB1, 0xE6A2, 0xFCB6, 0xF2AD, 0xEFE1,
0xF3AE, 0xDCC6, 0xD9EB, 0xE8E0, 0xE1A8, 0xD5F6, 0xCFFD, 0xDEDD,
0xD9D1, 0xE4EA, 0xF2CF, 0xF7BF, 0xE2E6, 0xE2A8, 0xE3D6, 0xEDD1,
0xE9F9, 0xD6B1, 0xDEB2, 0xE0E8, 0xD3AB, 0xEBDC, 0xDFAF, 0xCAC3,
0xEEFC, 0xFDC3, 0xEBF6, 0xCFB2, 0xD9EC, 0xD9BD, 0xD8DF, 0xD4B8,
0xEBBE, 0xDDEF, 0xDDF0, 0xDDF1, 0xDDF2, 0xD9BE, 0xFBC6, 0xCFB3,
0xEEFD, 0xE4AB, 0xDAC5, 0xD8EC, 0xD1A8, 0xE2A9, 0xDEBC, 0xE7B5,
0xDBF0, 0xEFE2, 0xF1F0, 0xCFB4, 0xDBF1, 0xE0B1, 0xDFA5, 0xF9D2,
0xE7FD, 0xE6A3, 0xFBF1, 0xCBB0, 0xF2AE, 0xCDE7, 0xE8DC, 0xE7D7,
0xF7C0, 0xD0E3, 0xDAA1, 0xCCBD, 0xD1A9, 0xDDCC, 0xE3FE, 0xD1AA,
0xE8AA, 0xEAB6, 0xF9FA, 0xE6CC, 0xF6D8, 0xD4C7, 0xD9CB, 0xD9D2,
0xD3CB, 0xD8F7, 0xDAA9, 0xF5F8, 0xDEDE, 0xF2AF, 0xF8A9, 0xD8C8,
0xEEC1, 0xF9C1, 0xDDF3, 0xEAFA, 0xF6BD, 0xE1BB, 0xCDBF, 0xF4D4,
0xE6CD, 0xFCCF, 0xFBA2, 0xE0DC, 0xF4BB, 0xDAD5, 0xF9B2, 0xFBF2,
0xDBF6, 0xDEDF, 0xDBF2, 0xF8DC, 0xF7EE, 0xEBE8, 0xD2FA, 0xF1BC,
0xFADA, 0xDAEA, 0xDAC6, 0xF7C1, 0xE7B6, 0xE5C7, 0xD6AC, 0xDCC7,
0xE1A9, 0xE2AA, 0xD5A6, 0xD4D7, 0xF2D0, 0xEAFB, 0xE0DD, 0xFBF3,
0xF1BD, 0xE2E7, 0xFDD7, 0xCEC8, 0xEAB7, 0xFCC0, 0xFDE7, 0xF7EF,
0xD7B5, 0xEFBA, 0xF1DD, 0xDEB3, 0xE8CB, 0xF8DD, 0xFBC7, 0xD5C8,
0xD7DF, 0xDDA9, 0xE9B1, 0xFAAD, 0xF6D9, 0xFAF4, 0xF8AA, 0xE6EE,
0xCCDC, 0xE1BC, 0xE0EF, 0xE9BF, 0xFCFD, 0xE6CE, 0xE1D7, 0xE6CF,
0xF4F1, 0xE4F3, 0xE4FB, 0xF9E4, 0xEFE3, 0xCFEE, 0xF6BE, 0xE0B2,
0xFCFE, 0xD1AB, 0xD7FA, 0xFBC8, 0xE2D7, 0xD4A3, 0xF0F8, 0xD7A8,
0xE1E7, 0xD3BF, 0xEFE4, 0xD7C5, 0xEBE2, 0xFCE7, 0xE4A2, 0xE2E8,
0xE6D0, 0xFBE8, 0xF4E8, 0xE5F4, 0xF4BC, 0xF4D5, 0xDFB6, 0xFCB9,
0xEEC2, 0xCAF5, 0xEFE5, 0xCBE2, 0xD4A4, 0xDEE0, 0xDAFD, 0xE4C6,
0xE8BE, 0xE0DE, 0xF6B4, 0xEAD2, 0xF9FB, 0xE0C2, 0xCAE4, 0xE7B7,
0xEAFD, 0xD9DD, 0xDAB4, 0xEEAA, 0xFBE9, 0xDBCB, 0xDAB5, 0xF1BE,
0xD3AC, 0xFBC9, 0xDFCF, 0xD3C0, 0xE3D7, 0xEFE6, 0xFCD0, 0xE9C0,
0xF5D3, 0xECDC, 0xF7B7, 0xEAB8, 0xD1F9, 0xDCC8, 0xEAB9, 0xF1DE,
0xD7B6, 0xCFB5, 0xD9A8, 0xECEE, 0xDDAA, 0xCDA2, 0xE8AE, 0xE1BD,
0xF2D1, 0xE9C1, 0xD2FC, 0xDBB5, 0xF3E7, 0xD8FE, 0xFCD1, 0xEDB2,
0xF4AF, 0xFBA3, 0xFCC1, 0xEEAB, 0xD4A5, 0xF4F2, 0xEED9, 0xFBCA,
0xCDE3, 0xD8BB, 0xE5DB, 0xF8F7, 0xF6D4, 0xD7A9, 0xCBC9, 0xE6D1,
0xF0CC, 0xD8AE, 0xF9D3, 0xD5FE, 0xD8BC, 0xF2B0, 0xE2AB, 0xF3E8,
0xEFC2, 0xEDEC, 0xE7B8, 0xDAFE, 0xCCBE, 0xF2FC, 0xDAEB, 0xE2D8,
0xEDD6, 0xD6D1, 0xE0B3, 0xFCD2, 0xEBC8, 0xD3C1, 0xF0CD, 0xCFF7,
0xEDD2, 0xD4D8, 0xDCC9, 0xD7F1, 0xDFBB, 0xF3A5, 0xF4CD, 0xF1BF,
0xF8B1, 0xE9FA, 0xFBCB, 0xCAD5, 0xF9D4, 0xF7CA, 0xD6C8, 0xFCE8,
0xF3BD, 0xEEFE, 0xE7FE, 0xD3C2, 0xD3B6, 0xCCAD, 0xF6FA, 0xD6B2,
0xD2D8, 0xE7D8, 0xE3A5, 0xE7B9, 0xF0AD, 0xFBCC, 0xEBA1, 0xD4A6,
0xFBCD, 0xD5BD, 0xF1DF, 0xF6FB, 0xDEB4, 0xD5EB, 0xE5C8, 0xFBA4,
0xD4B9, 0xDEE1, 0xE4A3, 0xD7B7, 0xF8EE, 0xDEB5, 0xD6D2, 0xF9D5,
0xE7BA, 0xEBD5, 0xD5F7, 0xEFE7, 0xE1BE, 0xFAAE, 0xD6E9, 0xD6EE,
0xE7BB, 0xECCB, 0xD5B3, 0xCEB4, 0xFBA5, 0xE1EE, 0xF7A8, 0xFBCE,
0xD8BD, 0xFBFD, 0xFCE9, 0xCFB6, 0xEDC7, 0xEEAC, 0xCCDD, 0xF6A7,
0xE6FA, 0xF5A4, 0xFDDC, 0xEDB3, 0xCEC9, 0xEFE8, 0xE1BF, 0xFADB,
0xCBE3, 0xF7A9, 0xFBA6, 0xDCB9, 0xF1C0, 0xEDC8, 0xEFC3, 0xD6AD,
0xFDCE, 0xE8A1, 0xFBF4, 0xD5A7, 0xF1F6, 0xE6D3, 0xCCDE, 0xF8B2,
0xDCEB, 0xFDB6, 0xE5EA, 0xF1E0, 0xDBCC, 0xDDCD, 0xD4C8, 0xD9ED,
0xF5A5, 0xE6FB, 0xE6D4, 0xFDC8, 0xD6A1, 0xFDBF, 0xFCD3, 0xEFA1,
0xE7BC, 0xD1EE, 0xE6D5, 0xE9F2, 0xDFB0, 0xD8E0, 0xFCBA, 0xFDAF,
0xF0CE, 0xDBE1, 0xE5C9, 0xEDB4, 0xE0C3, 0xE3D8, 0xE9FB, 0xEAA8,
0xFDB7, 0xFBA7, 0xE9C2, 0xFDF7, 0xE2D9, 0xDCEC, 0xE8A2, 0xE6F0,
0xFDF8, 0xFDF9, 0xF6BF, 0xE7A7, 0xE6D7, 0xD4F3, 0xD4C9, 0xD6FA,
0xD7F2, 0xE1C0, 0xDBE2, 0xE6D8, 0xE7BD, 0xF0CF, 0xF3BE, 0xE2AC,
0xF5B7, 0xE0F0, 0xFDB8, 0xE3E8, 0xD4A7, 0xE8FC, 0xFAD2, 0xF8EF,
0xD6D3, 0xD5B4, 0xF0D0, 0xF7F0, 0xEEB3, 0xEABA, 0xEAD3, 0xEDC9,
0xDDAB, 0xE5AC, 0xFDA1, 0xDFD0, 0xECB3, 0xDFD1, 0xEDED, 0xF8B8,
0xF7FA, 0xF8AB, 0xF4E0, 0xD4BA, 0xE4B3, 0xE9DA, 0xDEB6, 0xD9BF,
0xD9C0, 0xD6EF, 0xD9CC, 0xDAAA, 0xDFE5, 0xF7E5, 0xCCB2, 0xDFF9,
0xD7E0, 0xD4BB, 0xFDFA, 0xCCB3, 0xDBF3, 0xDFD2, 0xCECA, 0xEEDA,
0xE4E4, 0xFBCF, 0xCFB7, 0xEEC3, 0xCEEA, 0xE2AD, 0xD7E1, 0xFAF5,
0xD5C9, 0xF8AC, 0xE7D9, 0xF3E9, 0xD8ED, 0xE3C4, 0xF0F1, 0xE8E5,
0xE0FA, 0xEEC4, 0xD9DE, 0xEBA2, 0xEBA3, 0xFCC2, 0xEABB, 0xE8AB,
0xDEE2, 0xEDEF, 0xE8A3, 0xCFF1, 0xD4BC, 0xFCEA, 0xE7BE, 0xFCF2,
0xD6B4, 0xE2AE, 0xD3B7, 0xFACC, 0xFADC, 0xEDB5, 0xE1E3, 0xE8AC,
0xE8DD, 0xEFE9, 0xF4BD, 0xCFB8, 0xE9DB, 0xD1AC, 0xDAC7, 0xEBC9,
0xE8CC, 0xDEB7, 0xD6BC, 0xD3E5, 0xFADD, 0xDAD6, 0xCAB1, 0xDAC8,
0xDFA6, 0xF9B3, 0xF2D2, 0xCAC4, 0xCECB, 0xCDF5, 0xFDB0, 0xD5A8,
0xF1C1, 0xE2E9, 0xDCCA, 0xECB4, 0xFAC0, 0xFBA8, 0xD0A8, 0xDAEC,
0xD9EE, 0xE0FB, 0xEFEA, 0xFADE, 0xE0C4, 0xCFB9, 0xD5CA, 0xD7E2,
0xE2AF, 0xD7B8, 0xE8CD, 0xF6DA, 0xEFA2, 0xE2DA, 0xF6FC, 0xFBD0,
0xD1AD, 0xCDE4, 0xD1AE, 0xDCED, 0xE8CE, 0xF0F9, 0xCEB5, 0xE6FC,
0xD7FB, 0xD0D6, 0xDDF5, 0xF7F1, 0xF6FD, 0xDBF7, 0xFBEA, 0xE9DC,
0xD9C1, 0xF5F2, 0xE0C5, 0xEAD4, 0xF9C2, 0xEABC, 0xD2C5, 0xFBD1,
0xE7C0, 0xEBA5, 0xDFFA, 0xE3A2, 0xD7B9, 0xE9C3, 0xE8FD, 0xE8AF,
0xF2D3, 0xFBA9, 0xD8A5, 0xD5CB, 0xD0C8, 0xD1AF, 0xD7E3, 0xE0C6,
0xD6A2, 0xEDF0, 0xD7F3, 0xFCD4, 0xDAD7, 0xCCDF, 0xF2D4, 0xD1B0,
0xCCE0, 0xDBFD, 0xF3BF, 0xF0D1, 0xFCBB, 0xE2B0, 0xE6A5, 0xE2DB,
0xDFDE, 0xE0C7, 0xF2EF, 0xCCE1, 0xD6EA, 0xE7C2, 0xCEB6, 0xF3C0,
0xCDFE, 0xFBD2, 0xF8F8, 0xF7FB, 0xE8BF, 0xE8B7, 0xEDB6, 0xDCBA,
0xCCB4, 0xF1F7, 0xE8B8, 0xCAF6, 0xE4A4, 0xF4D6, 0xDFE6, 0xDFA7,
0xDFE7, 0xE1C1, 0xE9C4, 0xDCCB, 0xE9C5, 0xEFA3, 0xEBA6, 0xCBA3,
0xE3E9, 0xD1FB, 0xEFA4, 0xEFEB, 0xD0B4, 0xCDA3, 0xE8E6, 0xEFA5,
0xD3CC, 0xDAED, 0xD7BA, 0xF2D5, 0xF5E5, 0xD9EF, 0xF9B4, 0xD5D4,
0xFDCF, 0xDBE3, 0xF1E1, 0xECB6, 0xFBFE, 0xD3D7, 0xD1B1, 0xCBB1,
0xD1B2, 0xCBB2, 0xF1C2, 0xF4E1, 0xF9B5, 0xE1C3, 0xE1C2, 0xEBF7,
0xDFA8, 0xCBCA, 0xE6B9, 0xF8DE, 0xF9AA, 0xCAF7, 0xEDB7, 0xD3B8,
0xF2D6, 0xD4D9, 0xEEC5, 0xF2F0, 0xCAB2, 0xDCBB, 0xF1F8, 0xECB7,
0xE5CA, 0xF6C0, 0xFDDD, 0xD4E3, 0xCCE2, 0xF7D4, 0xD7E5, 0xD3C3,
0xD8A6, 0xF6C1, 0xDDF6, 0xCDC0, 0xE5DC, 0xE5CB, 0xE1C4, 0xE8B0,
0xF4B0, 0xF3EA, 0xDAEE, 0xD7BB, 0xE2B1, 0xD7AA, 0xD6FB, 0xE4DF,
0xCAD6, 0xEBA8, 0xDBFE, 0xF6C2, 0xEFBB, 0xD4FD, 0xE0C8, 0xE8B9,
0xEFA6, 0xCDA4, 0xD4F4, 0xDBA1, 0xDBDC, 0xDBDD, 0xEEDC, 0xCBCB,
0xFCD5, 0xCEEB, 0xCDC1, 0xFBD3, 0xF9AB, 0xF5D4, 0xD9A9, 0xE9DD,
0xDBCD, 0xDDCE, 0xE7C3, 0xECCC, 0xF9EC, 0xCBCC, 0xE0FC, 0xD4A8,
0xEDD3, 0xD8EF, 0xF2D7, 0xCAF8, 0xDAEF, 0xD6D4, 0xD9CD, 0xD8EE,
0xF2C1, 0xDFD3, 0xDAF0, 0xE2EA, 0xE0FD, 0xD8F8, 0xF7AF, 0xDAB6,
0xCAD7, 0xF2D8, 0xD8F9, 0xFADF, 0xCFEF, 0xD9C2, 0xF0D2, 0xE4D1,
0xF3B7, 0xFAE0, 0xEFEC, 0xE2B2, 0xD4BD, 0xD9CE, 0xF4E2, 0xD4A9,
0xCDC2, 0xE7DA, 0xF2D9, 0xD9AA, 0xD8BE, 0xDCAD, 0xE2EB, 0xD6FC,
0xCAF9, 0xD4DA, 0xF4D7, 0xCCA1, 0xCFBA, 0xF5B8, 0xD9C3, 0xD0E8,
0xE3C5, 0xEBF8, 0xF2B1, 0xCFBB, 0xD3AD, 0xE8E1, 0xCEEC, 0xE0B4,
0xDEE3, 0xDDF7, 0xF2B2, 0xF3F6, 0xF6DB, 0xD7FE, 0xF8DF, 0xF7F2,
0xD0A9, 0xE6DA, 0xF5A6, 0xD7BC, 0xCCE3, 0xE6DB, 0xDDDD, 0xD1B3,
0xEFED, 0xD6DE, 0xE4F4, 0xE1EF, 0xDDF8, 0xE8CF, 0xCAE5, 0xDCA1,
0xE0B5, 0xFCAC, 0xFCAD, 0xD8A7, 0xEDB8, 0xDBB6, 0xD6F0, 0xF3AF,
0xCDA5, 0xDAF1, 0xD8A8, 0xCCE4, 0xD1B4, 0xCAD8, 0xDAF2, 0xF5A7,
0xF5A8, 0xE6A6, 0xD5EC, 0xD5F8, 0xDAF3, 0xE3C6, 0xDEE4, 0xDEE5,
0xD1B5, 0xD1B6, 0xD1B7, 0xF2B3, 0xE9DE, 0xF0D3, 0xF2B4, 0xF0D4,
0xCBE4, 0xFBD4, 0xF5E6, 0xE3EA, 0xDEE6, 0xDFD4, 0xF8F9, 0xF0AE,
0xD1B8, 0xD6DF, 0xD0D7, 0xFCA1, 0xEFEE, 0xDCD8, 0xE9DF, 0xE5DD,
0xFDFB, 0xE0C9, 0xD6C9, 0xD4AA, 0xE5CC, 0xE9E0, 0xD0D8, 0xFCA2,
0xD4BE, 0xE2B3, 0xDEE7, 0xDCBC, 0xD2B6, 0xF5D5, 0xCEA1, 0xF5A9,
0xDDF9, 0xDDFA, 0xF0D5, 0xF6DF, 0xF2DA, 0xE4EB, 0xF2F1, 0xECB9,
0xFDFC, 0xE1AA, 0xCAD9, 0xEFEF, 0xF5AA, 0xECF9, 0xF8AD, 0xF2C2,
0xF6C3, 0xD7D2, 0xF9A2, 0xF0D6, 0xF0FA, 0xF6E0, 0xE9F3, 0xF2C3,
0xD4AB, 0xCAB3, 0xCDA6, 0xCDC3, 0xCDDA, 0xD9CF, 0xF6C4, 0xEEDD,
0xE7C4, 0xE2B4, 0xDFE2, 0xE7DB, 0xE8B1, 0xFCAE, 0xE5CD, 0xFAEB,
0xCFBC, 0xCFE2, 0xCDF6, 0xEFF0, 0xF4BE, 0xD4CD, 0xF3B8, 0xE9A1,
0xF2F2, 0xF3EB, 0xF0D7, 0xCFD7, 0xCFDF, 0xE8C0, 0xE8C1, 0xCFE3,
0xE9A2, 0xD0AA, 0xF3C1, 0xD0AB, 0xD4E4, 0xEFBC, 0xD8A1, 0xD9DF,
0xF3D7, 0xDCBD, 0xCCE5, 0xEDF1, 0xF1E2, 0xD4DB, 0xE2B5, 0xCAE6,
0xD3AE, 0xCCE6, 0xF1D3, 0xF5E7, 0xCADA, 0xFBEE, 0xE1C5, 0xDFE9,
0xEEDE, 0xF7C2, 0xD8A2, 0xDDAC, 0xF0AF, 0xD6BD, 0xE1AB, 0xF9B6,
0xD4F5, 0xD0C9, 0xEFA7, 0xE2EC, 0xDBEA, 0xCECC, 0xF5E8, 0xF7D5,
0xD3CD, 0xF3FE, 0xD0B5, 0xE0FE, 0xDFFB, 0xE6DD, 0xE8A4, 0xCBCD,
0xEFA8, 0xEEB4, 0xDAD8, 0xD1B9, 0xDFA9, 0xF3B0, 0xCCC4, 0xCEB7,
0xEFA9, 0xDFD5, 0xEDD7, 0xEEC6, 0xEFBD, 0xFCD6, 0xDBF4, 0xEFAA,
0xF8B9, 0xF5E9, 0xE3D9, 0xE1C6, 0xD4BF, 0xDEE8, 0xF0EA, 0xF3C2,
0xD3AF, 0xCADB, 0xFCD7, 0xEDD8, 0xE1C7, 0xF4D8, 0xD6B3, 0xDDAD,
0xD5BE, 0xF1C3, 0xEEDF, 0xD6EB, 0xF4D9, 0xD7E6, 0xDAB7, 0xDDFB,
0xDDCF, 0xD8A3, 0xDAD9, 0xF0D8, 0xEFC4, 0xE1D8, 0xF1D4, 0xEDF2,
0xD5DB, 0xD5DC, 0xF3C4, 0xCBD7, 0xE2B6, 0xEFF1, 0xFBD5, 0xD3D8,
0xDDD0, 0xF0D9, 0xCBB3, 0xD5DD, 0xCDA7, 0xD0AC, 0xD1BA, 0xF1C4,
0xE5B3, 0xFBF5, 0xE9E1, 0xFDE0, 0xFCBC, 0xDAA2, 0xDAA3, 0xD2A1,
0xD2EF, 0xE2ED, 0xDEE9, 0xCEDC, 0xF2B5, 0xD0E4, 0xDDD1, 0xE1C8,
0xDBB7, 0xDFE3, 0xEDB9, 0xF1C5, 0xF3CF, 0xD7AB, 0xE1AC, 0xE3EB,
0xEEC7, 0xE1C9, 0xCAFA, 0xF0FB, 0xFAE1, 0xF0DA, 0xCCE7, 0xDAF4,
0xCCBF, 0xCEED, 0xD5A9, 0xFAE2, 0xD0E5, 0xEBD6, 0xECDF, 0xDFFC,
0xF7D6, 0xDEEA, 0xCBB4, 0xEFBE, 0xCCB5, 0xCFBD, 0xEFF2, 0xE2B7,
0xCCE8, 0xF0FC, 0xD6E0, 0xF1C6, 0xE2B8, 0xEBAB, 0xCBB5, 0xD8D1,
0xF4CE, 0xF3F7, 0xD7C6, 0xD1BB, 0xF7AA, 0xEDCA, 0xD7D3, 0xD8FA,
0xF6C5, 0xD1CC, 0xDDFC, 0xDFFD, 0xF9E5, 0xE0CA, 0xF2FD, 0xD3B0,
0xF4F3, 0xDAC9, 0xE6DE, 0xF8BA, 0xE8D0, 0xD8FB, 0xEAD5, 0xD6A3,
0xF6C6, 0xF2DB, 0xE4FC, 0xE8B2, 0xDADA, 0xF2DC, 0xFBD6, 0xE9B2,
0xEEAD, 0xFAE3, 0xDCEE, 0xF5EA, 0xE6E0, 0xF0FD, 0xD7AC, 0xF5C5,
0xEEE0, 0xDBE5, 0xDDDE, 0xD9F0, 0xE9A3, 0xF1F9, 0xF2C4, 0xE0CB,
0xE9A4, 0xE2B9, 0xE3B1, 0xFCEB, 0xCDA8, 0xCCB6, 0xF0DB, 0xE6BA,
0xCDA9, 0xF3C3, 0xE1D9, 0xEFAB, 0xE7C5, 0xE0E9, 0xF3C5, 0xD4C0,
0xD5BF, 0xDDAE, 0xF9FC, 0xCCC0, 0xE5A2, 0xCEB8, 0xD8D2, 0xF9D6,
0xF1AA, 0xCED1, 0xF6C7, 0xDBEB, 0xDFFE, 0xD8E1, 0xF7F3, 0xD7E7,
0xD4FE, 0xD1BC, 0xE5CF, 0xCBB6, 0xDAB8, 0xCDC4, 0xD6BE, 0xE2BA,
0xCFD8, 0xE0CC, 0xEBF9, 0xFDFD, 0xD7E8, 0xCBD8, 0xE9E2, 0xE8BA,
0xE3C7, 0xECCD, 0xECCE, 0xD6BF, 0xE3A7, 0xDFD6, 0xFDE8, 0xEEE1,
0xF6A8, 0xDDFD, 0xF8BB, 0xE8D1, 0xF9D7, 0xCEEE, 0xECCF, 0xE9A5,
0xD6D5, 0xCDC5, 0xEDBA, 0xD1BD, 0xCFBE, 0xECBB, 0xD2B1, 0xCCE9,
0xD9C4, 0xE9FC, 0xD1BE, 0xECBC, 0xE5AD, 0xF7B0, 0xCCEA, 0xD3C4,
0xD6C0, 0xD6FD, 0xE1A1, 0xDEBD, 0xF6A9, 0xDAA4, 0xD6A4, 0xF5C6,
0xE1A2, 0xE9C6, 0xF2C5, 0xF4E9, 0xD6EC, 0xEBD3, 0xECBD, 0xE2DC,
0xDEEB, 0xF0DC, 0xEBBF, 0xD7CE, 0xD1BF, 0xF5AB, 0xF9FD, 0xCADC,
0xCDC6, 0xF2B6, 0xDDFE, 0xCCB7, 0xDBB8, 0xD0E9, 0xCEDD, 0xEBC0,
0xFDA2, 0xF8CB, 0xEAD6, 0xF1B0, 0xDBCE, 0xF7C3, 0xDBCF, 0xCBA4,
0xF8E0, 0xFBD7, 0xEBCA, 0xE0A1, 0xCECD, 0xD4DC, 0xFDD8, 0xD2F6,
0xF2B7, 0xFAF6, 0xF6AA, 0xFAF7, 0xD8E6, 0xF4B1, 0xE8D2, 0xCAC5,
0xCCEB, 0xE2EE, 0xE2BB, 0xF7AD, 0xF8E1, 0xF3EC, 0xDEA1, 0xE4FD,
0xE3EC, 0xDDAF, 0xDDB0, 0xCBB7, 0xE8D3, 0xE1A3, 0xD2E0, 0xF0FE,
0xE9A6, 0xCBF2, 0xEDF3, 0xDCD9, 0xE0CD, 0xF7DA, 0xDBB9, 0xCCAE,
0xDADB, 0xCDC7, 0xDDB1, 0xD8AF, 0xE3A3, 0xCEEF, 0xF2F3, 0xF8B3,
0xE0CE, 0xF5FD, 0xEBEC, 0xD3C5, 0xFCEC, 0xD2DB, 0xD4EB, 0xDEA2,
0xE5E6, 0xF0B0, 0xD5C4, 0xEDF4, 0xE3ED, 0xE8C2, 0xEDF5, 0xD7FC,
0xEDBB, 0xF6AB, 0xF2B8, 0xF6C8, 0xD3E6, 0xF2DD, 0xCFBF, 0xEBAC,
0xCFC0, 0xE6A8, 0xFDE9, 0xCFC1, 0xE0DF, 0xDEEC, 0xE0A2, 0xF4BF,
0xE2EF, 0xD9F1, 0xF1C7, 0xCBB8, 0xF9FE, 0xDBBA, 0xDAF5, 0xF6EC,
0xDADC, 0xFAE4, 0xE0CF, 0xDDB2, 0xE6A9, 0xEFF3, 0xF3ED, 0xEBFA,
0xF9E6, 0xCADD, 0xD5DE, 0xCADE, 0xDFE4, 0xE6FD, 0xF5AC, 0xE4F5,
0xE9E3, 0xEDCB, 0xCFE4, 0xD8D3, 0xDDB3, 0xD4EC, 0xF2B9, 0xDFB7,
0xCBCE, 0xFBD8, 0xD0D9, 0xDDD2, 0xF7F4, 0xE7DC, 0xE4A5, 0xFCA3,
0xDBBB, 0xF2BA, 0xE9FD, 0xD0CA, 0xF5D6, 0xD9C5, 0xE4B4, 0xEDA7,
0xEABD, 0xE6FE, 0xF7C4, 0xF5AD, 0xD9E0, 0xCAB4, 0xF8E2, 0xCFC2,
0xECBE, 0xE5B4, 0xCDC8, 0xEEC8, 0xE7C8, 0xCDC9, 0xF9B7, 0xF1E8,
0xD9F2, 0xDBF5, 0xCAB5, 0xD9C6, 0xD8C9, 0xD9AB, 0xEDBC, 0xD8D4,
0xDCDA, 0xE2BC, 0xFCED, 0xECE0, 0xD2FE, 0xE9C7, 0xE6AA, 0xE2F0,
0xFABB, 0xF5AE, 0xFBAA, 0xECFB, 0xECBF, 0xFCD8, 0xD4E5, 0xF9C3,
0xEEE2, 0xD7E9, 0xEDF6, 0xDEED, 0xCCEC, 0xE3EE, 0xE8D4, 0xFAF8,
0xDDB4, 0xE4B5, 0xD8B0, 0xD8D5, 0xF4EA, 0xCEB9, 0xD6E1, 0xCFD2,
0xD0B6, 0xCEA2, 0xF3EE, 0xF3F8, 0xDCCC, 0xD0CB, 0xFCA4, 0xCDCA,
0xD7D4, 0xDEA3, 0xE4E0, 0xEEC9, 0xE2DD, 0xF5FE, 0xD4AC, 0xD5D1,
0xD8F0, 0xF8C3, 0xEAD7, 0xF5D7, 0xD8BF, 0xFDC0, 0xEBAD, 0xD5AA,
0xE7A8, 0xEECA, 0xCAE7, 0xF8E3, 0xD4DD, 0xEAD8, 0xFBD9, 0xEDF7,
0xE5B5, 0xD0AD, 0xF1F1, 0xE2BD, 0xE3C8, 0xD9D5, 0xDFAA, 0xDBBC,
0xF8E4, 0xF1FA, 0xE5B6, 0xF3EF, 0xFBDA, 0xE1E0, 0xD9AC, 0xF5EB,
0xE0B6, 0xE9C8, 0xCBCF, 0xE3C9, 0xDEEE, 0xE2BE, 0xDCEF, 0xD6A5,
0xE2F1, 0xD6FE, 0xD9A1, 0xD8C0, 0xDCDB, 0xEDBD, 0xDFB8, 0xEAA5,
0xD7AD, 0xF3F9, 0xEDF8, 0xF5C7, 0xE1CA, 0xEBE3, 0xF2DE, 0xF8CC,
0xEAD9, 0xD3C6, 0xDBE6, 0xF5AF, 0xCEF0, 0xE9FE, 0xFBB6, 0xE2F2,
0xCFF2, 0xF7B9, 0xD9F3, 0xE1CB, 0xDADD, 0xDAB9, 0xEBFB, 0xCBB9,
0xEDF9, 0xE0E0, 0xF4C0, 0xFDBC, 0xDFB1, 0xE3EF, 0xE0A3, 0xFDB9,
0xF0B1, 0xCDCB, 0xEDBE, 0xD5C0, 0xE3F0, 0xEDFA, 0xE9E4, 0xD5ED,
0xE7DD, 0xD4F6, 0xE5B7, 0xDBE7, 0xE2BF, 0xEECB, 0xD7F4, 0xF0DD,
0xCEAB, 0xE7DE, 0xD6D6, 0xE1CC, 0xE8B3, 0xE5EE, 0xDCA2, 0xE0D0,
0xD5B5, 0xD5A1, 0xFBDB, 0xF9CB, 0xCBF3, 0xF4A5, 0xFAC8, 0xD6D7,
0xE9E5, 0xFBDC, 0xFDD0, 0xFBF6, 0xDAA5, 0xDBBD, 0xECE2, 0xCDF7,
0xF0DE, 0xF6C9, 0xDEEF, 0xD3B1, 0xFCEE, 0xE8C3, 0xF1C8, 0xCEF1,
0xF9ED, 0xF2F4, 0xE4B6, 0xF5B9, 0xDCF0, 0xE3F1, 0xE8A5, 0xF2BB,
0xDEA4, 0xDACC, 0xCAE9, 0xE3DA, 0xFCD9, 0xEADA, 0xF9C4, 0xE3A4,
0xFBDD, 0xEFCA, 0xE8C4, 0xD5CC, 0xEBD7, 0xD9AD, 0xFBAB, 0xD3D9,
0xD5A2, 0xF6DE, 0xDAF6, 0xE0D1, 0xE9A8, 0xF5F9, 0xFAAF, 0xEBFC,
0xE0EA, 0xE3B2, 0xD5C5, 0xF1E3, 0xD5EE, 0xCDCC, 0xEDD9, 0xD8C1,
0xFAEC, 0xF1EB, 0xFABC, 0xE6E2, 0xFAE5, 0xE2FA, 0xCAB6, 0xE4B7,
0xEADB, 0xF5FA, 0xFBAC, 0xCFC3, 0xEBFD, 0xF8FA, 0xDFB9, 0xE1F1,
0xD2A4, 0xF5FB, 0xD0DA, 0xD0DB, 0xEABE, 0xD9B1, 0xCAB7, 0xD3E7,
0xF8E5, 0xD3B2, 0xE2C0, 0xF2DF, 0xCDE5, 0xF9AC, 0xCDCD, 0xEEAE,
0xD6AE, 0xD7EA, 0xE7E0, 0xEBAE, 0xCFD9, 0xDCCD, 0xEDFB, 0xDEF0,
0xD7EB, 0xDEA5, 0xDFD7, 0xDBD0, 0xDBD1, 0xD5A3, 0xF0B2, 0xDCDC,
0xCAE8, 0xF8E6, 0xDCCE, 0xEADC, 0xDBD2, 0xE9B3, 0xF7DB, 0xE3A8,
0xD7AE, 0xE0E1, 0xCBBA, 0xE5D1, 0xD0DC, 0xD5C1, 0xD8CA, 0xE3A9,
0xE0A4, 0xE9A9, 0xD3C7, 0xDCDD, 0xF8AE, 0xCCB8, 0xD0AE, 0xD8F2,
0xE3CA, 0xCCAF, 0xD4AD, 0xF6D1, 0xD0CC, 0xCAC6, 0xD5C2, 0xCEBA,
0xCAC7, 0xFAB0, 0xDFD8, 0xF5BA, 0xE5EB, 0xEFF4, 0xDDB5, 0xCDAA,
0xE3F2, 0xFBF7, 0xF7D0, 0xFDBA, 0xFDE1, 0xF6FE, 0xD1C0, 0xE8C5,
0xE4B8, 0xE1E8, 0xCCC1, 0xD2ED, 0xDBBE, 0xE0E2, 0xFAC9, 0xE1CD,
0xCAB8, 0xF2E0, 0xF1C9, 0xDEF1, 0xF0DF, 0xF8C4, 0xEECC, 0xDEF2,
0xE7C9, 0xE2F3, 0xE7E1, 0xE3CB, 0xE3CC, 0xCFF8, 0xEFAC, 0xFDFE,
0xFCA5, 0xFAB1, 0xDFD9, 0xE0D2, 0xF4DA, 0xF1CA, 0xCEA3, 0xF2BC,
0xECE3, 0xE0A5, 0xF7AB, 0xEBAF, 0xE5DE, 0xE1A4, 0xCDAB, 0xD9F4,
0xE8A6, 0xCDCE, 0xE1E9, 0xFCEF, 0xE0E3, 0xE2C1, 0xCEA4, 0xDEA6,
0xEBFE, 0xEBDD, 0xF0E0, 0xF4DB, 0xE2F4, 0xD3C8, 0xF4EB, 0xEEB5,
0xF5D8, 0xD5DF, 0xD6E5, 0xEBB0, 0xF4E3, 0xE3CD, 0xF4F4, 0xFAB2,
0xEFF5, 0xCADF, 0xEBB1, 0xEDBF, 0xFDC9, 0xE4A6, 0xF9A4, 0xF0B3,
0xE5EC, 0xD1E7, 0xD9C7, 0xE4D7, 0xEADD, 0xD4F7, 0xDABA, 0xDACD,
0xF9CC, 0xE1DA, 0xDBBF, 0xCCC5, 0xECD0, 0xCBBB, 0xDEF3, 0xE9AA,
0xD9C8, 0xEEE3, 0xD7BD, 0xCFC4, 0xD0CD, 0xFCA6, 0xF1FB, 0xFDD2,
0xD1C1, 0xE3DB, 0xD3C9, 0xDCCF, 0xCCED, 0xDEA7, 0xE6BB, 0xECA1,
0xCCB9, 0xFBDE, 0xE7E2, 0xD4C1, 0xDCA8, 0xE2C2, 0xF3D8, 0xE5D3,
0xF3D9, 0xF3C6, 0xCDDB, 0xCDAC, 0xFCC3, 0xD4E7, 0xD1C2, 0xF9A5,
0xE8D5, 0xE3CE, 0xD4CA, 0xDFDA, 0xFBDF, 0xE7E3, 0xF8FB, 0xE3CF,
0xF5B0, 0xD8E7, 0xD9C9, 0xF8AF, 0xEFF6, 0xDDB6, 0xEEAF, 0xCDF8,
0xDEB8, 0xFCA7, 0xF7FC, 0xF7B1, 0xCEBB, 0xF4A1, 0xEECD, 0xE1AE,
0xECC3, 0xCFFE, 0xF8BF, 0xD8E2, 0xD3E8, 0xDEA8, 0xF4E4, 0xECC2,
0xD9F5, 0xF9C5, 0xDDD3, 0xD6F1, 0xECFC, 0xFCF0, 0xEDC0, 0xCAB9,
0xEEE4, 0xF2E1, 0xDEB9, 0xD6F2, 0xDEF4, 0xDFDB, 0xDBD3, 0xFAE7,
0xD8E3, 0xF4C1, 0xDDB7, 0xF2F5, 0xD4AE, 0xD6F3, 0xDDB8, 0xCFC5,
0xDFDF, 0xF2BE, 0xF6A1, 0xEBCB, 0xF1FC, 0xF3C7, 0xE0EB, 0xEDFC,
0xE1DB, 0xEEE5, 0xDEF5, 0xFAD3, 0xF1CB, 0xD0AF, 0xDDB9, 0xD1C3,
0xF5B1, 0xEAC6, 0xF0E1, 0xF6AC, 0xF5D9, 0xF0EB, 0xDDBA, 0xF2BF,
0xF7C5, 0xDBA2, 0xF2F6, 0xCABA, 0xF7F5, 0xCBE5, 0xEEE6, 0xE0D3,
0xCEA5, 0xD6D8, 0xD4AF, 0xE9C9, 0xD3CE, 0xF4C2, 0xCBE6, 0xF1A1,
0xEBB2, 0xF1A2, 0xEBB3, 0xF0B4, 0xCBF4, 0xD4B0, 0xF3B2, 0xFBB7,
0xF5EC, 0xEEE7, 0xF4B2, 0xF5ED, 0xCFF3, 0xF0E2, 0xEECE, 0xF1CC,
0xE5B8, 0xD7F5, 0xE3F3, 0xCFE5, 0xCFC6, 0xF3B3, 0xE4D8, 0xCFF9,
0xCFDA, 0xFACD, 0xE6E3, 0xF2E2, 0xF5EE, 0xCABB, 0xE3DC, 0xCEF2,
0xD6D9, 0xEEB0, 0xF4E5, 0xD8C2, 0xDCD0, 0xCCEE, 0xD5E0, 0xF6CA,
0xFDCA, 0xD8D6, 0xF4CF, 0xD6A6, 0xDCBE, 0xDBD4, 0xD7C7, 0xF2FE,
0xF1CD, 0xE2C3, 0xDCDE, 0xDCDF, 0xEFAD, 0xE6AB, 0xF9DD, 0xEABF,
0xEFAE, 0xF4D0, 0xCEF3, 0xE6AC, 0xCEDE, 0xD5F9, 0xE3F4, 0xCDD0,
0xD5B8, 0xF7FD, 0xDCA9, 0xDEF6, 0xDCAA, 0xF2E3, 0xE9B4, 0xD2DC,
0xE9E6, 0xE3F6, 0xE7CA, 0xD0CE, 0xDAF7, 0xCABC, 0xEEE8, 0xDADE,
0xF2F7, 0xE2FB, 0xCCA6, 0xDABB, 0xEEE9, 0xF5DA, 0xF7DC, 0xE1EA,
0xCEC1, 0xD4B1, 0xFDB1, 0xE6BD, 0xFBAD, 0xF8E7, 0xE1CE, 0xF7E2,
0xF5EF, 0xCFC7, 0xD4B2, 0xCCEF, 0xD4E8, 0xEECF, 0xF7D7, 0xE0A6,
0xD6C1, 0xE1DC, 0xF0E3, 0xF1E4, 0xDCF1, 0xD6A7, 0xF4F5, 0xF1CE,
0xF2E4, 0xD0B0, 0xECEF, 0xF9BA, 0xEBB5, 0xD4ED, 0xE2C4, 0xE9E7,
0xEBB4, 0xEAA1, 0xF8BC, 0xCEA6, 0xF9C6, 0xFCDA, 0xD4B3, 0xD3B9,
0xEADE, 0xE9AB, 0xE1E1, 0xD3CF, 0xF4F6, 0xEAC0, 0xE1CF, 0xCCBA,
0xEEEA, 0xF0E4, 0xF3B4, 0xD4EE, 0xF2C0, 0xF1E5, 0xF4C3, 0xE0D4,
0xEBB6, 0xD7A1, 0xCBE8, 0xF9AD, 0xE9AD, 0xD8E4, 0xFAB3, 0xE2C5,
0xFCBD, 0xECC4, 0xD8B1, 0xDCAB, 0xD5A4, 0xEBE9, 0xE8BB, 0xD8D7,
0xFBAE, 0xD1E1, 0xDBC0, 0xF5BE, 0xDEF7, 0xCAFB, 0xF7C6, 0xCFC8,
0xE1D0, 0xEED0, 0xE9F4, 0xCEF4, 0xD5CD, 0xCFDB, 0xDDBB, 0xCEAC,
0xE9E8, 0xD4B4, 0xE4C7, 0xF5DB, 0xFAC1, 0xDEA9, 0xD4F8, 0xEFF7,
0xD3B3, 0xEBB7, 0xEFF8, 0xF5DC, 0xEDCC, 0xDBD5, 0xF1CF, 0xF1D0,
0xF5B2, 0xD9AE, 0xD5AC, 0xE2C6, 0xFDA3, 0xFBE5, 0xDFAB, 0xE2F5,
0xF6AD, 0xF5B3, 0xF0B5, 0xE1A5, 0xF5DD, 0xECA2, 0xEDFD, 0xF5B4,
0xFBB8, 0xDBA3, 0xD6CA, 0xCBD9, 0xE5D4, 0xF3FA, 0xEBB8, 0xE0B7,
0xD7EC, 0xF1EC, 0xE5AF, 0xD5E1, 0xD7ED, 0xD1D1, 0xE1F2, 0xEFF9,
0xDDBC, 0xF6DC, 0xF0E5, 0xF4C4, 0xE9E9, 0xF3FB, 0xD4EF, 0xCCA2,
0xF7FE, 0xDFBC, 0xEBCD, 0xD0B7, 0xD6C2, 0xE8AD, 0xEFAF, 0xCBA5,
0xCBE9, 0xFAE8, 0xCCC6, 0xE6E7, 0xEAC7, 0xDBA4, 0xCFC9, 0xE2FC,
0xEFFA, 0xEBDE, 0xF5C8, 0xD4DE, 0xE0D5, 0xEFB0, 0xE2C7, 0xD9AF,
0xF9E7, 0xE7E5, 0xCFCA, 0xE1D1, 0xE2C8, 0xEFFB, 0xFAF9, 0xDCF2,
0xE0A7, 0xF8E8, 0xCBEA, 0xCBBC, 0xD6E2, 0xF5DE, 0xF5DF, 0xEEB6,
0xE2F6, 0xD3CA, 0xEFFC, 0xD1C4, 0xEFB1, 0xD1C5, 0xD0DE, 0xD9E1,
0xE0B8, 0xCDD1, 0xF3B9, 0xE7CC, 0xD6A8, 0xCEA7, 0xD4B5, 0xE4C8,
0xD3B4, 0xEBB9, 0xCBF5, 0xF6DD, 0xF1A3, 0xCCC7, 0xE9CA, 0xE1F0,
0xF5E0, 0xFBAF, 0xCBD1, 0xFBE0, 0xF2E5, 0xECF0, 0xF0EC, 0xEEEB,
0xE9CB, 0xCCF0, 0xD7AF, 0xF3A1, 0xFCF5, 0xF1A4, 0xE0D6, 0xEFB2,
0xF4D1, 0xF7A1, 0xF1D1, 0xCAFC, 0xCAFD, 0xCECE, 0xF3C8, 0xF3BA,
0xEDFE, 0xDAA6, 0xE0EC, 0xF8CD, 0xCBD2, 0xEBCE, 0xF9D8, 0xF9D9,
0xCAE0, 0xDACA, 0xCBA6, 0xCAC8, 0xF9EE, 0xDBEC, 0xD0B1, 0xD5EF,
0xE6F3, 0xE7A2, 0xE4D9, 0xE4E1, 0xFCC4, 0xF9EF, 0xCFF4, 0xF7E6,
0xCEBC, 0xF4C5, 0xDCA3, 0xDDBD, 0xF4C6, 0xF8A1, 0xE8D6, 0xDBC1,
0xF0E6, 0xE4B9, 0xF6ED, 0xF9AE, 0xDDBE, 0xD7B0, 0xD8E8, 0xCBBD,
0xF9DA, 0xF8CE, 0xF9F0, 0xE0ED, 0xE3B3, 0xF4B3, 0xEAC2, 0xF2E6,
0xF0B6, 0xDBD6, 0xEBE4, 0xF2E7, 0xD7D5, 0xD4B6, 0xF9E8, 0xD7C1,
0xE5D5, 0xE9EA, 0xD7CC, 0xD3E9, 0xE2C9, 0xFCDB, 0xCDAD, 0xCCB0,
0xEAA2, 0xE4F6, 0xD0C0, 0xF0B7, 0xEEA1, 0xD7F6, 0xE2CA, 0xE2CB,
0xFACF, 0xEBDF, 0xD6CB, 0xF4B4, 0xEDCD, 0xE4D2, 0xEAA9, 0xE4BA,
0xF3A2, 0xCDD2, 0xF6CB, 0xF1E6, 0xEDC1, 0xE8BC, 0xEED1, 0xF0E7,
0xE2CC, 0xE4AA, 0xF5E1, 0xEDDA, 0xD7EE, 0xD1F1, 0xE9EB, 0xE9EC,
0xE0E4, 0xDAA7, 0xDDD4, 0xEAA3, 0xD6C3, 0xD6F4, 0xDADF, 0xEFB3,
0xE2CD, 0xEFFD, 0xF2E8, 0xEFC5, 0xE7E7, 0xD7FD, 0xE7CE, 0xDFDC,
0xF9C7, 0xD9F6, 0xDFAC, 0xD6DA, 0xDCA4, 0xF0B8, 0xD5FA, 0xE4F7,
0xD6C4, 0xF4EC, 0xEFFE, 0xF0A1, 0xDEAA, 0xDABC, 0xD8FC, 0xFAD4,
0xECE5, 0xFCA8, 0xECE6, 0xD8CB, 0xFBB9, 0xE4D3, 0xCDF9, 0xCFD3,
0xCAEA, 0xCFD4, 0xF8BD, 0xF4C7, 0xEADF, 0xF9DB, 0xD4B7, 0xEBE5,
0xE1D2, 0xEAA4, 0xFAC2, 0xFBE1, 0xFAED, 0xF0A2, 0xCCF1, 0xFAA3,
0xE2F7, 0xE2CE, 0xE9F5, 0xE1EB, 0xE7E8, 0xE8D7, 0xDAF8, 0xD4CB,
0xF7F6, 0xD6C5, 0xD4E9, 0xFAFA, 0xCCF2, 0xF7DD, 0xDEBA, 0xCEA8,
0xF0B9, 0xE4FE, 0xE4C9, 0xE4D4, 0xEAC3, 0xEFB4, 0xD7BE, 0xFBE2,
0xCDD3, 0xEFB5, 0xFAE9, 0xF9A6, 0xDFBD, 0xF7C7, 0xF8FD, 0xF8FC,
0xDEAB, 0xDBE8, 0xE3DD, 0xE1E2, 0xD1C6, 0xF6D0, 0xEBE6, 0xDAF9,
0xECC7, 0xDEF8, 0xF8E9, 0xE3DE, 0xCEF5, 0xFAC3, 0xE5D7, 0xECC8,
0xF3C9, 0xE4BB, 0xE6AE, 0xEFB6, 0xDCBF, 0xCEBD, 0xD8C3, 0xD0CF,
0xCFFA, 0xF3CA, 0xE0D7, 0xD1C7, 0xE9AE, 0xE8BD, 0xFAC4, 0xE2CF,
0xFAC5, 0xF9B8, 0xDCE0, 0xFBB0, 0xD8A9, 0xE5DF, 0xF9A7, 0xF6EE,
0xF6CC, 0xE2F8, 0xECF1, 0xDAE0, 0xF1D2, 0xD2CC, 0xCFCB, 0xCABD,
0xDDBF, 0xF6EF, 0xDEF9, 0xFAB4, 0xD5AD, 0xF1E7, 0xDEBE, 0xDCC0,
0xD1C8, 0xD1C9, 0xF8BE, 0xCBF6, 0xD4F9, 0xF5E2, 0xE1D3, 0xD8E9,
0xF8FE, 0xCFCC, 0xFDA4, 0xCEF6, 0xFAD0, 0xCCF3, 0xE6BE, 0xF6AE,
0xD5F0, 0xD1CA, 0xFCBE, 0xD5F1, 0xCDE9, 0xFAB5, 0xE2D0, 0xF4F7,
0xCDD4, 0xE7A3, 0xDBA5, 0xE2D1, 0xD7A2, 0xF7E3, 0xEAA6, 0xD0A1,
0xCEDA, 0xFBEB, 0xDBA6, 0xDBDE, 0xD8E5, 0xEAE0, 0xD8AA, 0xE5E0,
0xD6DB, 0xEFC6, 0xF8EA, 0xE4D5, 0xCEF7, 0xE0D8, 0xD7EF, 0xF4ED,
0xCDE6, 0xCCF4, 0xF5E3, 0xE4CA, 0xDCE1, 0xF9C8, 0xFCBF, 0xE8A7,
0xD8C4, 0xCBBE, 0xDCAE, 0xD7F7, 0xF0E8, 0xDDC0, 0xCFCD, 0xDCF3,
0xD9B0, 0xE6E9, 0xE4BC, 0xEAC4, 0xE4EC, 0xE4E5, 0xFBF8, 0xCCBB,
0xE4BD, 0xCDDC, 0xD9F7, 0xDDDF, 0xEDCE, 0xD9D0, 0xE5A3, 0xF9CD,
0xCDAE, 0xCFCE, 0xF6AF, 0xFDD3, 0xEBED, 0xD6DC, 0xE5A4, 0xD5B6,
0xD6DD, 0xF9E9, 0xE7A4, 0xD6E3, 0xD1CB, 0xD6E4, 0xD5F2, 0xDEFA,
0xD7F8, 0xD8EA, 0xCFD5, 0xD8FD, 0xD8AB, 0xFDCB, 0xFCDC, 0xE0A8,
0xD5F3, 0xFDD9, 0xCCA3, 0xD9F9, 0xD3EA, 0xF5F5, 0xEFC7, 0xD3DA,
0xDABD, 0xE8A8, 0xDCAF, 0xF0A3, 0xCDD5, 0xE0A9, 0xDEAC, 0xF0BA,
0xEEB1, 0xEEB2, 0xF6CD, 0xEED2, 0xD6C6, 0xE0E5, 0xF3BB, 0xE5E1,
0xE4CB, 0xD7A3, 0xDBC2, 0xCAFE, 0xCFCF, 0xB0A1, 0xB0A2, 0xB0A3,
0xB0A4, 0xB0A5, 0xB0A6, 0xB0A7, 0xB0A8, 0xB0A9, 0xB0AA, 0xB0AB,
0xB0AC, 0xB0AD, 0xB0AE, 0xB0AF, 0xB0B0, 0xB0B1, 0xB0B2, 0xB0B3,
0xB0B4, 0xB0B5, 0xB0B6, 0xB0B7, 0xB0B8, 0xB0B9, 0xB0BA, 0xB0BB,
0xB0BC, 0xB0BD, 0xB0BE, 0xB0BF, 0xB0C0, 0xB0C1, 0xB0C2, 0xB0C3,
0xB0C4, 0xB0C5, 0xB0C6, 0xB0C7, 0xB0C8, 0xB0C9, 0xB0CA, 0xB0CB,
0xB0CC, 0xB0CD, 0xB0CE, 0xB0CF, 0xB0D0, 0xB0D1, 0xB0D2, 0xB0D3,
0xB0D4, 0xB0D5, 0xB0D6, 0xB0D7, 0xB0D8, 0xB0D9, 0xB0DA, 0xB0DB,
0xB0DC, 0xB0DD, 0xB0DE, 0xB0DF, 0xB0E0, 0xB0E1, 0xB0E2, 0xB0E3,
0xB0E4, 0xB0E5, 0xB0E6, 0xB0E7, 0xB0E8, 0xB0E9, 0xB0EA, 0xB0EB,
0xB0EC, 0xB0ED, 0xB0EE, 0xB0EF, 0xB0F0, 0xB0F1, 0xB0F2, 0xB0F3,
0xB0F4, 0xB0F5, 0xB0F6, 0xB0F7, 0xB0F8, 0xB0F9, 0xB0FA, 0xB0FB,
0xB0FC, 0xB0FD, 0xB0FE, 0xB1A1, 0xB1A2, 0xB1A3, 0xB1A4, 0xB1A5,
0xB1A6, 0xB1A7, 0xB1A8, 0xB1A9, 0xB1AA, 0xB1AB, 0xB1AC, 0xB1AD,
0xB1AE, 0xB1AF, 0xB1B0, 0xB1B1, 0xB1B2, 0xB1B3, 0xB1B4, 0xB1B5,
0xB1B6, 0xB1B7, 0xB1B8, 0xB1B9, 0xB1BA, 0xB1BB, 0xB1BC, 0xB1BD,
0xB1BE, 0xB1BF, 0xB1C0, 0xB1C1, 0xB1C2, 0xB1C3, 0xB1C4, 0xB1C5,
0xB1C6, 0xB1C7, 0xB1C8, 0xB1C9, 0xB1CA, 0xB1CB, 0xB1CC, 0xB1CD,
0xB1CE, 0xB1CF, 0xB1D0, 0xB1D1, 0xB1D2, 0xB1D3, 0xB1D4, 0xB1D5,
0xB1D6, 0xB1D7, 0xB1D8, 0xB1D9, 0xB1DA, 0xB1DB, 0xB1DC, 0xB1DD,
0xB1DE, 0xB1DF, 0xB1E0, 0xB1E1, 0xB1E2, 0xB1E3, 0xB1E4, 0xB1E5,
0xB1E6, 0xB1E7, 0xB1E8, 0xB1E9, 0xB1EA, 0xB1EB, 0xB1EC, 0xB1ED,
0xB1EE, 0xB1EF, 0xB1F0, 0xB1F1, 0xB1F2, 0xB1F3, 0xB1F4, 0xB1F5,
0xB1F6, 0xB1F7, 0xB1F8, 0xB1F9, 0xB1FA, 0xB1FB, 0xB1FC, 0xB1FD,
0xB1FE, 0xB2A1, 0xB2A2, 0xB2A3, 0xB2A4, 0xB2A5, 0xB2A6, 0xB2A7,
0xB2A8, 0xB2A9, 0xB2AA, 0xB2AB, 0xB2AC, 0xB2AD, 0xB2AE, 0xB2AF,
0xB2B0, 0xB2B1, 0xB2B2, 0xB2B3, 0xB2B4, 0xB2B5, 0xB2B6, 0xB2B7,
0xB2B8, 0xB2B9, 0xB2BA, 0xB2BB, 0xB2BC, 0xB2BD, 0xB2BE, 0xB2BF,
0xB2C0, 0xB2C1, 0xB2C2, 0xB2C3, 0xB2C4, 0xB2C5, 0xB2C6, 0xB2C7,
0xB2C8, 0xB2C9, 0xB2CA, 0xB2CB, 0xB2CC, 0xB2CD, 0xB2CE, 0xB2CF,
0xB2D0, 0xB2D1, 0xB2D2, 0xB2D3, 0xB2D4, 0xB2D5, 0xB2D6, 0xB2D7,
0xB2D8, 0xB2D9, 0xB2DA, 0xB2DB, 0xB2DC, 0xB2DD, 0xB2DE, 0xB2DF,
0xB2E0, 0xB2E1, 0xB2E2, 0xB2E3, 0xB2E4, 0xB2E5, 0xB2E6, 0xB2E7,
0xB2E8, 0xB2E9, 0xB2EA, 0xB2EB, 0xB2EC, 0xB2ED, 0xB2EE, 0xB2EF,
0xB2F0, 0xB2F1, 0xB2F2, 0xB2F3, 0xB2F4, 0xB2F5, 0xB2F6, 0xB2F7,
0xB2F8, 0xB2F9, 0xB2FA, 0xB2FB, 0xB2FC, 0xB2FD, 0xB2FE, 0xB3A1,
0xB3A2, 0xB3A3, 0xB3A4, 0xB3A5, 0xB3A6, 0xB3A7, 0xB3A8, 0xB3A9,
0xB3AA, 0xB3AB, 0xB3AC, 0xB3AD, 0xB3AE, 0xB3AF, 0xB3B0, 0xB3B1,
0xB3B2, 0xB3B3, 0xB3B4, 0xB3B5, 0xB3B6, 0xB3B7, 0xB3B8, 0xB3B9,
0xB3BA, 0xB3BB, 0xB3BC, 0xB3BD, 0xB3BE, 0xB3BF, 0xB3C0, 0xB3C1,
0xB3C2, 0xB3C3, 0xB3C4, 0xB3C5, 0xB3C6, 0xB3C7, 0xB3C8, 0xB3C9,
0xB3CA, 0xB3CB, 0xB3CC, 0xB3CD, 0xB3CE, 0xB3CF, 0xB3D0, 0xB3D1,
0xB3D2, 0xB3D3, 0xB3D4, 0xB3D5, 0xB3D6, 0xB3D7, 0xB3D8, 0xB3D9,
0xB3DA, 0xB3DB, 0xB3DC, 0xB3DD, 0xB3DE, 0xB3DF, 0xB3E0, 0xB3E1,
0xB3E2, 0xB3E3, 0xB3E4, 0xB3E5, 0xB3E6, 0xB3E7, 0xB3E8, 0xB3E9,
0xB3EA, 0xB3EB, 0xB3EC, 0xB3ED, 0xB3EE, 0xB3EF, 0xB3F0, 0xB3F1,
0xB3F2, 0xB3F3, 0xB3F4, 0xB3F5, 0xB3F6, 0xB3F7, 0xB3F8, 0xB3F9,
0xB3FA, 0xB3FB, 0xB3FC, 0xB3FD, 0xB3FE, 0xB4A1, 0xB4A2, 0xB4A3,
0xB4A4, 0xB4A5, 0xB4A6, 0xB4A7, 0xB4A8, 0xB4A9, 0xB4AA, 0xB4AB,
0xB4AC, 0xB4AD, 0xB4AE, 0xB4AF, 0xB4B0, 0xB4B1, 0xB4B2, 0xB4B3,
0xB4B4, 0xB4B5, 0xB4B6, 0xB4B7, 0xB4B8, 0xB4B9, 0xB4BA, 0xB4BB,
0xB4BC, 0xB4BD, 0xB4BE, 0xB4BF, 0xB4C0, 0xB4C1, 0xB4C2, 0xB4C3,
0xB4C4, 0xB4C5, 0xB4C6, 0xB4C7, 0xB4C8, 0xB4C9, 0xB4CA, 0xB4CB,
0xB4CC, 0xB4CD, 0xB4CE, 0xB4CF, 0xB4D0, 0xB4D1, 0xB4D2, 0xB4D3,
0xB4D4, 0xB4D5, 0xB4D6, 0xB4D7, 0xB4D8, 0xB4D9, 0xB4DA, 0xB4DB,
0xB4DC, 0xB4DD, 0xB4DE, 0xB4DF, 0xB4E0, 0xB4E1, 0xB4E2, 0xB4E3,
0xB4E4, 0xB4E5, 0xB4E6, 0xB4E7, 0xB4E8, 0xB4E9, 0xB4EA, 0xB4EB,
0xB4EC, 0xB4ED, 0xB4EE, 0xB4EF, 0xB4F0, 0xB4F1, 0xB4F2, 0xB4F3,
0xB4F4, 0xB4F5, 0xB4F6, 0xB4F7, 0xB4F8, 0xB4F9, 0xB4FA, 0xB4FB,
0xB4FC, 0xB4FD, 0xB4FE, 0xB5A1, 0xB5A2, 0xB5A3, 0xB5A4, 0xB5A5,
0xB5A6, 0xB5A7, 0xB5A8, 0xB5A9, 0xB5AA, 0xB5AB, 0xB5AC, 0xB5AD,
0xB5AE, 0xB5AF, 0xB5B0, 0xB5B1, 0xB5B2, 0xB5B3, 0xB5B4, 0xB5B5,
0xB5B6, 0xB5B7, 0xB5B8, 0xB5B9, 0xB5BA, 0xB5BB, 0xB5BC, 0xB5BD,
0xB5BE, 0xB5BF, 0xB5C0, 0xB5C1, 0xB5C2, 0xB5C3, 0xB5C4, 0xB5C5,
0xB5C6, 0xB5C7, 0xB5C8, 0xB5C9, 0xB5CA, 0xB5CB, 0xB5CC, 0xB5CD,
0xB5CE, 0xB5CF, 0xB5D0, 0xB5D1, 0xB5D2, 0xB5D3, 0xB5D4, 0xB5D5,
0xB5D6, 0xB5D7, 0xB5D8, 0xB5D9, 0xB5DA, 0xB5DB, 0xB5DC, 0xB5DD,
0xB5DE, 0xB5DF, 0xB5E0, 0xB5E1, 0xB5E2, 0xB5E3, 0xB5E4, 0xB5E5,
0xB5E6, 0xB5E7, 0xB5E8, 0xB5E9, 0xB5EA, 0xB5EB, 0xB5EC, 0xB5ED,
0xB5EE, 0xB5EF, 0xB5F0, 0xB5F1, 0xB5F2, 0xB5F3, 0xB5F4, 0xB5F5,
0xB5F6, 0xB5F7, 0xB5F8, 0xB5F9, 0xB5FA, 0xB5FB, 0xB5FC, 0xB5FD,
0xB5FE, 0xB6A1, 0xB6A2, 0xB6A3, 0xB6A4, 0xB6A5, 0xB6A6, 0xB6A7,
0xB6A8, 0xB6A9, 0xB6AA, 0xB6AB, 0xB6AC, 0xB6AD, 0xB6AE, 0xB6AF,
0xB6B0, 0xB6B1, 0xB6B2, 0xB6B3, 0xB6B4, 0xB6B5, 0xB6B6, 0xB6B7,
0xB6B8, 0xB6B9, 0xB6BA, 0xB6BB, 0xB6BC, 0xB6BD, 0xB6BE, 0xB6BF,
0xB6C0, 0xB6C1, 0xB6C2, 0xB6C3, 0xB6C4, 0xB6C5, 0xB6C6, 0xB6C7,
0xB6C8, 0xB6C9, 0xB6CA, 0xB6CB, 0xB6CC, 0xB6CD, 0xB6CE, 0xB6CF,
0xB6D0, 0xB6D1, 0xB6D2, 0xB6D3, 0xB6D4, 0xB6D5, 0xB6D6, 0xB6D7,
0xB6D8, 0xB6D9, 0xB6DA, 0xB6DB, 0xB6DC, 0xB6DD, 0xB6DE, 0xB6DF,
0xB6E0, 0xB6E1, 0xB6E2, 0xB6E3, 0xB6E4, 0xB6E5, 0xB6E6, 0xB6E7,
0xB6E8, 0xB6E9, 0xB6EA, 0xB6EB, 0xB6EC, 0xB6ED, 0xB6EE, 0xB6EF,
0xB6F0, 0xB6F1, 0xB6F2, 0xB6F3, 0xB6F4, 0xB6F5, 0xB6F6, 0xB6F7,
0xB6F8, 0xB6F9, 0xB6FA, 0xB6FB, 0xB6FC, 0xB6FD, 0xB6FE, 0xB7A1,
0xB7A2, 0xB7A3, 0xB7A4, 0xB7A5, 0xB7A6, 0xB7A7, 0xB7A8, 0xB7A9,
0xB7AA, 0xB7AB, 0xB7AC, 0xB7AD, 0xB7AE, 0xB7AF, 0xB7B0, 0xB7B1,
0xB7B2, 0xB7B3, 0xB7B4, 0xB7B5, 0xB7B6, 0xB7B7, 0xB7B8, 0xB7B9,
0xB7BA, 0xB7BB, 0xB7BC, 0xB7BD, 0xB7BE, 0xB7BF, 0xB7C0, 0xB7C1,
0xB7C2, 0xB7C3, 0xB7C4, 0xB7C5, 0xB7C6, 0xB7C7, 0xB7C8, 0xB7C9,
0xB7CA, 0xB7CB, 0xB7CC, 0xB7CD, 0xB7CE, 0xB7CF, 0xB7D0, 0xB7D1,
0xB7D2, 0xB7D3, 0xB7D4, 0xB7D5, 0xB7D6, 0xB7D7, 0xB7D8, 0xB7D9,
0xB7DA, 0xB7DB, 0xB7DC, 0xB7DD, 0xB7DE, 0xB7DF, 0xB7E0, 0xB7E1,
0xB7E2, 0xB7E3, 0xB7E4, 0xB7E5, 0xB7E6, 0xB7E7, 0xB7E8, 0xB7E9,
0xB7EA, 0xB7EB, 0xB7EC, 0xB7ED, 0xB7EE, 0xB7EF, 0xB7F0, 0xB7F1,
0xB7F2, 0xB7F3, 0xB7F4, 0xB7F5, 0xB7F6, 0xB7F7, 0xB7F8, 0xB7F9,
0xB7FA, 0xB7FB, 0xB7FC, 0xB7FD, 0xB7FE, 0xB8A1, 0xB8A2, 0xB8A3,
0xB8A4, 0xB8A5, 0xB8A6, 0xB8A7, 0xB8A8, 0xB8A9, 0xB8AA, 0xB8AB,
0xB8AC, 0xB8AD, 0xB8AE, 0xB8AF, 0xB8B0, 0xB8B1, 0xB8B2, 0xB8B3,
0xB8B4, 0xB8B5, 0xB8B6, 0xB8B7, 0xB8B8, 0xB8B9, 0xB8BA, 0xB8BB,
0xB8BC, 0xB8BD, 0xB8BE, 0xB8BF, 0xB8C0, 0xB8C1, 0xB8C2, 0xB8C3,
0xB8C4, 0xB8C5, 0xB8C6, 0xB8C7, 0xB8C8, 0xB8C9, 0xB8CA, 0xB8CB,
0xB8CC, 0xB8CD, 0xB8CE, 0xB8CF, 0xB8D0, 0xB8D1, 0xB8D2, 0xB8D3,
0xB8D4, 0xB8D5, 0xB8D6, 0xB8D7, 0xB8D8, 0xB8D9, 0xB8DA, 0xB8DB,
0xB8DC, 0xB8DD, 0xB8DE, 0xB8DF, 0xB8E0, 0xB8E1, 0xB8E2, 0xB8E3,
0xB8E4, 0xB8E5, 0xB8E6, 0xB8E7, 0xB8E8, 0xB8E9, 0xB8EA, 0xB8EB,
0xB8EC, 0xB8ED, 0xB8EE, 0xB8EF, 0xB8F0, 0xB8F1, 0xB8F2, 0xB8F3,
0xB8F4, 0xB8F5, 0xB8F6, 0xB8F7, 0xB8F8, 0xB8F9, 0xB8FA, 0xB8FB,
0xB8FC, 0xB8FD, 0xB8FE, 0xB9A1, 0xB9A2, 0xB9A3, 0xB9A4, 0xB9A5,
0xB9A6, 0xB9A7, 0xB9A8, 0xB9A9, 0xB9AA, 0xB9AB, 0xB9AC, 0xB9AD,
0xB9AE, 0xB9AF, 0xB9B0, 0xB9B1, 0xB9B2, 0xB9B3, 0xB9B4, 0xB9B5,
0xB9B6, 0xB9B7, 0xB9B8, 0xB9B9, 0xB9BA, 0xB9BB, 0xB9BC, 0xB9BD,
0xB9BE, 0xB9BF, 0xB9C0, 0xB9C1, 0xB9C2, 0xB9C3, 0xB9C4, 0xB9C5,
0xB9C6, 0xB9C7, 0xB9C8, 0xB9C9, 0xB9CA, 0xB9CB, 0xB9CC, 0xB9CD,
0xB9CE, 0xB9CF, 0xB9D0, 0xB9D1, 0xB9D2, 0xB9D3, 0xB9D4, 0xB9D5,
0xB9D6, 0xB9D7, 0xB9D8, 0xB9D9, 0xB9DA, 0xB9DB, 0xB9DC, 0xB9DD,
0xB9DE, 0xB9DF, 0xB9E0, 0xB9E1, 0xB9E2, 0xB9E3, 0xB9E4, 0xB9E5,
0xB9E6, 0xB9E7, 0xB9E8, 0xB9E9, 0xB9EA, 0xB9EB, 0xB9EC, 0xB9ED,
0xB9EE, 0xB9EF, 0xB9F0, 0xB9F1, 0xB9F2, 0xB9F3, 0xB9F4, 0xB9F5,
0xB9F6, 0xB9F7, 0xB9F8, 0xB9F9, 0xB9FA, 0xB9FB, 0xB9FC, 0xB9FD,
0xB9FE, 0xBAA1, 0xBAA2, 0xBAA3, 0xBAA4, 0xBAA5, 0xBAA6, 0xBAA7,
0xBAA8, 0xBAA9, 0xBAAA, 0xBAAB, 0xBAAC, 0xBAAD, 0xBAAE, 0xBAAF,
0xBAB0, 0xBAB1, 0xBAB2, 0xBAB3, 0xBAB4, 0xBAB5, 0xBAB6, 0xBAB7,
0xBAB8, 0xBAB9, 0xBABA, 0xBABB, 0xBABC, 0xBABD, 0xBABE, 0xBABF,
0xBAC0, 0xBAC1, 0xBAC2, 0xBAC3, 0xBAC4, 0xBAC5, 0xBAC6, 0xBAC7,
0xBAC8, 0xBAC9, 0xBACA, 0xBACB, 0xBACC, 0xBACD, 0xBACE, 0xBACF,
0xBAD0, 0xBAD1, 0xBAD2, 0xBAD3, 0xBAD4, 0xBAD5, 0xBAD6, 0xBAD7,
0xBAD8, 0xBAD9, 0xBADA, 0xBADB, 0xBADC, 0xBADD, 0xBADE, 0xBADF,
0xBAE0, 0xBAE1, 0xBAE2, 0xBAE3, 0xBAE4, 0xBAE5, 0xBAE6, 0xBAE7,
0xBAE8, 0xBAE9, 0xBAEA, 0xBAEB, 0xBAEC, 0xBAED, 0xBAEE, 0xBAEF,
0xBAF0, 0xBAF1, 0xBAF2, 0xBAF3, 0xBAF4, 0xBAF5, 0xBAF6, 0xBAF7,
0xBAF8, 0xBAF9, 0xBAFA, 0xBAFB, 0xBAFC, 0xBAFD, 0xBAFE, 0xBBA1,
0xBBA2, 0xBBA3, 0xBBA4, 0xBBA5, 0xBBA6, 0xBBA7, 0xBBA8, 0xBBA9,
0xBBAA, 0xBBAB, 0xBBAC, 0xBBAD, 0xBBAE, 0xBBAF, 0xBBB0, 0xBBB1,
0xBBB2, 0xBBB3, 0xBBB4, 0xBBB5, 0xBBB6, 0xBBB7, 0xBBB8, 0xBBB9,
0xBBBA, 0xBBBB, 0xBBBC, 0xBBBD, 0xBBBE, 0xBBBF, 0xBBC0, 0xBBC1,
0xBBC2, 0xBBC3, 0xBBC4, 0xBBC5, 0xBBC6, 0xBBC7, 0xBBC8, 0xBBC9,
0xBBCA, 0xBBCB, 0xBBCC, 0xBBCD, 0xBBCE, 0xBBCF, 0xBBD0, 0xBBD1,
0xBBD2, 0xBBD3, 0xBBD4, 0xBBD5, 0xBBD6, 0xBBD7, 0xBBD8, 0xBBD9,
0xBBDA, 0xBBDB, 0xBBDC, 0xBBDD, 0xBBDE, 0xBBDF, 0xBBE0, 0xBBE1,
0xBBE2, 0xBBE3, 0xBBE4, 0xBBE5, 0xBBE6, 0xBBE7, 0xBBE8, 0xBBE9,
0xBBEA, 0xBBEB, 0xBBEC, 0xBBED, 0xBBEE, 0xBBEF, 0xBBF0, 0xBBF1,
0xBBF2, 0xBBF3, 0xBBF4, 0xBBF5, 0xBBF6, 0xBBF7, 0xBBF8, 0xBBF9,
0xBBFA, 0xBBFB, 0xBBFC, 0xBBFD, 0xBBFE, 0xBCA1, 0xBCA2, 0xBCA3,
0xBCA4, 0xBCA5, 0xBCA6, 0xBCA7, 0xBCA8, 0xBCA9, 0xBCAA, 0xBCAB,
0xBCAC, 0xBCAD, 0xBCAE, 0xBCAF, 0xBCB0, 0xBCB1, 0xBCB2, 0xBCB3,
0xBCB4, 0xBCB5, 0xBCB6, 0xBCB7, 0xBCB8, 0xBCB9, 0xBCBA, 0xBCBB,
0xBCBC, 0xBCBD, 0xBCBE, 0xBCBF, 0xBCC0, 0xBCC1, 0xBCC2, 0xBCC3,
0xBCC4, 0xBCC5, 0xBCC6, 0xBCC7, 0xBCC8, 0xBCC9, 0xBCCA, 0xBCCB,
0xBCCC, 0xBCCD, 0xBCCE, 0xBCCF, 0xBCD0, 0xBCD1, 0xBCD2, 0xBCD3,
0xBCD4, 0xBCD5, 0xBCD6, 0xBCD7, 0xBCD8, 0xBCD9, 0xBCDA, 0xBCDB,
0xBCDC, 0xBCDD, 0xBCDE, 0xBCDF, 0xBCE0, 0xBCE1, 0xBCE2, 0xBCE3,
0xBCE4, 0xBCE5, 0xBCE6, 0xBCE7, 0xBCE8, 0xBCE9, 0xBCEA, 0xBCEB,
0xBCEC, 0xBCED, 0xBCEE, 0xBCEF, 0xBCF0, 0xBCF1, 0xBCF2, 0xBCF3,
0xBCF4, 0xBCF5, 0xBCF6, 0xBCF7, 0xBCF8, 0xBCF9, 0xBCFA, 0xBCFB,
0xBCFC, 0xBCFD, 0xBCFE, 0xBDA1, 0xBDA2, 0xBDA3, 0xBDA4, 0xBDA5,
0xBDA6, 0xBDA7, 0xBDA8, 0xBDA9, 0xBDAA, 0xBDAB, 0xBDAC, 0xBDAD,
0xBDAE, 0xBDAF, 0xBDB0, 0xBDB1, 0xBDB2, 0xBDB3, 0xBDB4, 0xBDB5,
0xBDB6, 0xBDB7, 0xBDB8, 0xBDB9, 0xBDBA, 0xBDBB, 0xBDBC, 0xBDBD,
0xBDBE, 0xBDBF, 0xBDC0, 0xBDC1, 0xBDC2, 0xBDC3, 0xBDC4, 0xBDC5,
0xBDC6, 0xBDC7, 0xBDC8, 0xBDC9, 0xBDCA, 0xBDCB, 0xBDCC, 0xBDCD,
0xBDCE, 0xBDCF, 0xBDD0, 0xBDD1, 0xBDD2, 0xBDD3, 0xBDD4, 0xBDD5,
0xBDD6, 0xBDD7, 0xBDD8, 0xBDD9, 0xBDDA, 0xBDDB, 0xBDDC, 0xBDDD,
0xBDDE, 0xBDDF, 0xBDE0, 0xBDE1, 0xBDE2, 0xBDE3, 0xBDE4, 0xBDE5,
0xBDE6, 0xBDE7, 0xBDE8, 0xBDE9, 0xBDEA, 0xBDEB, 0xBDEC, 0xBDED,
0xBDEE, 0xBDEF, 0xBDF0, 0xBDF1, 0xBDF2, 0xBDF3, 0xBDF4, 0xBDF5,
0xBDF6, 0xBDF7, 0xBDF8, 0xBDF9, 0xBDFA, 0xBDFB, 0xBDFC, 0xBDFD,
0xBDFE, 0xBEA1, 0xBEA2, 0xBEA3, 0xBEA4, 0xBEA5, 0xBEA6, 0xBEA7,
0xBEA8, 0xBEA9, 0xBEAA, 0xBEAB, 0xBEAC, 0xBEAD, 0xBEAE, 0xBEAF,
0xBEB0, 0xBEB1, 0xBEB2, 0xBEB3, 0xBEB4, 0xBEB5, 0xBEB6, 0xBEB7,
0xBEB8, 0xBEB9, 0xBEBA, 0xBEBB, 0xBEBC, 0xBEBD, 0xBEBE, 0xBEBF,
0xBEC0, 0xBEC1, 0xBEC2, 0xBEC3, 0xBEC4, 0xBEC5, 0xBEC6, 0xBEC7,
0xBEC8, 0xBEC9, 0xBECA, 0xBECB, 0xBECC, 0xBECD, 0xBECE, 0xBECF,
0xBED0, 0xBED1, 0xBED2, 0xBED3, 0xBED4, 0xBED5, 0xBED6, 0xBED7,
0xBED8, 0xBED9, 0xBEDA, 0xBEDB, 0xBEDC, 0xBEDD, 0xBEDE, 0xBEDF,
0xBEE0, 0xBEE1, 0xBEE2, 0xBEE3, 0xBEE4, 0xBEE5, 0xBEE6, 0xBEE7,
0xBEE8, 0xBEE9, 0xBEEA, 0xBEEB, 0xBEEC, 0xBEED, 0xBEEE, 0xBEEF,
0xBEF0, 0xBEF1, 0xBEF2, 0xBEF3, 0xBEF4, 0xBEF5, 0xBEF6, 0xBEF7,
0xBEF8, 0xBEF9, 0xBEFA, 0xBEFB, 0xBEFC, 0xBEFD, 0xBEFE, 0xBFA1,
0xBFA2, 0xBFA3, 0xBFA4, 0xBFA5, 0xBFA6, 0xBFA7, 0xBFA8, 0xBFA9,
0xBFAA, 0xBFAB, 0xBFAC, 0xBFAD, 0xBFAE, 0xBFAF, 0xBFB0, 0xBFB1,
0xBFB2, 0xBFB3, 0xBFB4, 0xBFB5, 0xBFB6, 0xBFB7, 0xBFB8, 0xBFB9,
0xBFBA, 0xBFBB, 0xBFBC, 0xBFBD, 0xBFBE, 0xBFBF, 0xBFC0, 0xBFC1,
0xBFC2, 0xBFC3, 0xBFC4, 0xBFC5, 0xBFC6, 0xBFC7, 0xBFC8, 0xBFC9,
0xBFCA, 0xBFCB, 0xBFCC, 0xBFCD, 0xBFCE, 0xBFCF, 0xBFD0, 0xBFD1,
0xBFD2, 0xBFD3, 0xBFD4, 0xBFD5, 0xBFD6, 0xBFD7, 0xBFD8, 0xBFD9,
0xBFDA, 0xBFDB, 0xBFDC, 0xBFDD, 0xBFDE, 0xBFDF, 0xBFE0, 0xBFE1,
0xBFE2, 0xBFE3, 0xBFE4, 0xBFE5, 0xBFE6, 0xBFE7, 0xBFE8, 0xBFE9,
0xBFEA, 0xBFEB, 0xBFEC, 0xBFED, 0xBFEE, 0xBFEF, 0xBFF0, 0xBFF1,
0xBFF2, 0xBFF3, 0xBFF4, 0xBFF5, 0xBFF6, 0xBFF7, 0xBFF8, 0xBFF9,
0xBFFA, 0xBFFB, 0xBFFC, 0xBFFD, 0xBFFE, 0xC0A1, 0xC0A2, 0xC0A3,
0xC0A4, 0xC0A5, 0xC0A6, 0xC0A7, 0xC0A8, 0xC0A9, 0xC0AA, 0xC0AB,
0xC0AC, 0xC0AD, 0xC0AE, 0xC0AF, 0xC0B0, 0xC0B1, 0xC0B2, 0xC0B3,
0xC0B4, 0xC0B5, 0xC0B6, 0xC0B7, 0xC0B8, 0xC0B9, 0xC0BA, 0xC0BB,
0xC0BC, 0xC0BD, 0xC0BE, 0xC0BF, 0xC0C0, 0xC0C1, 0xC0C2, 0xC0C3,
0xC0C4, 0xC0C5, 0xC0C6, 0xC0C7, 0xC0C8, 0xC0C9, 0xC0CA, 0xC0CB,
0xC0CC, 0xC0CD, 0xC0CE, 0xC0CF, 0xC0D0, 0xC0D1, 0xC0D2, 0xC0D3,
0xC0D4, 0xC0D5, 0xC0D6, 0xC0D7, 0xC0D8, 0xC0D9, 0xC0DA, 0xC0DB,
0xC0DC, 0xC0DD, 0xC0DE, 0xC0DF, 0xC0E0, 0xC0E1, 0xC0E2, 0xC0E3,
0xC0E4, 0xC0E5, 0xC0E6, 0xC0E7, 0xC0E8, 0xC0E9, 0xC0EA, 0xC0EB,
0xC0EC, 0xC0ED, 0xC0EE, 0xC0EF, 0xC0F0, 0xC0F1, 0xC0F2, 0xC0F3,
0xC0F4, 0xC0F5, 0xC0F6, 0xC0F7, 0xC0F8, 0xC0F9, 0xC0FA, 0xC0FB,
0xC0FC, 0xC0FD, 0xC0FE, 0xC1A1, 0xC1A2, 0xC1A3, 0xC1A4, 0xC1A5,
0xC1A6, 0xC1A7, 0xC1A8, 0xC1A9, 0xC1AA, 0xC1AB, 0xC1AC, 0xC1AD,
0xC1AE, 0xC1AF, 0xC1B0, 0xC1B1, 0xC1B2, 0xC1B3, 0xC1B4, 0xC1B5,
0xC1B6, 0xC1B7, 0xC1B8, 0xC1B9, 0xC1BA, 0xC1BB, 0xC1BC, 0xC1BD,
0xC1BE, 0xC1BF, 0xC1C0, 0xC1C1, 0xC1C2, 0xC1C3, 0xC1C4, 0xC1C5,
0xC1C6, 0xC1C7, 0xC1C8, 0xC1C9, 0xC1CA, 0xC1CB, 0xC1CC, 0xC1CD,
0xC1CE, 0xC1CF, 0xC1D0, 0xC1D1, 0xC1D2, 0xC1D3, 0xC1D4, 0xC1D5,
0xC1D6, 0xC1D7, 0xC1D8, 0xC1D9, 0xC1DA, 0xC1DB, 0xC1DC, 0xC1DD,
0xC1DE, 0xC1DF, 0xC1E0, 0xC1E1, 0xC1E2, 0xC1E3, 0xC1E4, 0xC1E5,
0xC1E6, 0xC1E7, 0xC1E8, 0xC1E9, 0xC1EA, 0xC1EB, 0xC1EC, 0xC1ED,
0xC1EE, 0xC1EF, 0xC1F0, 0xC1F1, 0xC1F2, 0xC1F3, 0xC1F4, 0xC1F5,
0xC1F6, 0xC1F7, 0xC1F8, 0xC1F9, 0xC1FA, 0xC1FB, 0xC1FC, 0xC1FD,
0xC1FE, 0xC2A1, 0xC2A2, 0xC2A3, 0xC2A4, 0xC2A5, 0xC2A6, 0xC2A7,
0xC2A8, 0xC2A9, 0xC2AA, 0xC2AB, 0xC2AC, 0xC2AD, 0xC2AE, 0xC2AF,
0xC2B0, 0xC2B1, 0xC2B2, 0xC2B3, 0xC2B4, 0xC2B5, 0xC2B6, 0xC2B7,
0xC2B8, 0xC2B9, 0xC2BA, 0xC2BB, 0xC2BC, 0xC2BD, 0xC2BE, 0xC2BF,
0xC2C0, 0xC2C1, 0xC2C2, 0xC2C3, 0xC2C4, 0xC2C5, 0xC2C6, 0xC2C7,
0xC2C8, 0xC2C9, 0xC2CA, 0xC2CB, 0xC2CC, 0xC2CD, 0xC2CE, 0xC2CF,
0xC2D0, 0xC2D1, 0xC2D2, 0xC2D3, 0xC2D4, 0xC2D5, 0xC2D6, 0xC2D7,
0xC2D8, 0xC2D9, 0xC2DA, 0xC2DB, 0xC2DC, 0xC2DD, 0xC2DE, 0xC2DF,
0xC2E0, 0xC2E1, 0xC2E2, 0xC2E3, 0xC2E4, 0xC2E5, 0xC2E6, 0xC2E7,
0xC2E8, 0xC2E9, 0xC2EA, 0xC2EB, 0xC2EC, 0xC2ED, 0xC2EE, 0xC2EF,
0xC2F0, 0xC2F1, 0xC2F2, 0xC2F3, 0xC2F4, 0xC2F5, 0xC2F6, 0xC2F7,
0xC2F8, 0xC2F9, 0xC2FA, 0xC2FB, 0xC2FC, 0xC2FD, 0xC2FE, 0xC3A1,
0xC3A2, 0xC3A3, 0xC3A4, 0xC3A5, 0xC3A6, 0xC3A7, 0xC3A8, 0xC3A9,
0xC3AA, 0xC3AB, 0xC3AC, 0xC3AD, 0xC3AE, 0xC3AF, 0xC3B0, 0xC3B1,
0xC3B2, 0xC3B3, 0xC3B4, 0xC3B5, 0xC3B6, 0xC3B7, 0xC3B8, 0xC3B9,
0xC3BA, 0xC3BB, 0xC3BC, 0xC3BD, 0xC3BE, 0xC3BF, 0xC3C0, 0xC3C1,
0xC3C2, 0xC3C3, 0xC3C4, 0xC3C5, 0xC3C6, 0xC3C7, 0xC3C8, 0xC3C9,
0xC3CA, 0xC3CB, 0xC3CC, 0xC3CD, 0xC3CE, 0xC3CF, 0xC3D0, 0xC3D1,
0xC3D2, 0xC3D3, 0xC3D4, 0xC3D5, 0xC3D6, 0xC3D7, 0xC3D8, 0xC3D9,
0xC3DA, 0xC3DB, 0xC3DC, 0xC3DD, 0xC3DE, 0xC3DF, 0xC3E0, 0xC3E1,
0xC3E2, 0xC3E3, 0xC3E4, 0xC3E5, 0xC3E6, 0xC3E7, 0xC3E8, 0xC3E9,
0xC3EA, 0xC3EB, 0xC3EC, 0xC3ED, 0xC3EE, 0xC3EF, 0xC3F0, 0xC3F1,
0xC3F2, 0xC3F3, 0xC3F4, 0xC3F5, 0xC3F6, 0xC3F7, 0xC3F8, 0xC3F9,
0xC3FA, 0xC3FB, 0xC3FC, 0xC3FD, 0xC3FE, 0xC4A1, 0xC4A2, 0xC4A3,
0xC4A4, 0xC4A5, 0xC4A6, 0xC4A7, 0xC4A8, 0xC4A9, 0xC4AA, 0xC4AB,
0xC4AC, 0xC4AD, 0xC4AE, 0xC4AF, 0xC4B0, 0xC4B1, 0xC4B2, 0xC4B3,
0xC4B4, 0xC4B5, 0xC4B6, 0xC4B7, 0xC4B8, 0xC4B9, 0xC4BA, 0xC4BB,
0xC4BC, 0xC4BD, 0xC4BE, 0xC4BF, 0xC4C0, 0xC4C1, 0xC4C2, 0xC4C3,
0xC4C4, 0xC4C5, 0xC4C6, 0xC4C7, 0xC4C8, 0xC4C9, 0xC4CA, 0xC4CB,
0xC4CC, 0xC4CD, 0xC4CE, 0xC4CF, 0xC4D0, 0xC4D1, 0xC4D2, 0xC4D3,
0xC4D4, 0xC4D5, 0xC4D6, 0xC4D7, 0xC4D8, 0xC4D9, 0xC4DA, 0xC4DB,
0xC4DC, 0xC4DD, 0xC4DE, 0xC4DF, 0xC4E0, 0xC4E1, 0xC4E2, 0xC4E3,
0xC4E4, 0xC4E5, 0xC4E6, 0xC4E7, 0xC4E8, 0xC4E9, 0xC4EA, 0xC4EB,
0xC4EC, 0xC4ED, 0xC4EE, 0xC4EF, 0xC4F0, 0xC4F1, 0xC4F2, 0xC4F3,
0xC4F4, 0xC4F5, 0xC4F6, 0xC4F7, 0xC4F8, 0xC4F9, 0xC4FA, 0xC4FB,
0xC4FC, 0xC4FD, 0xC4FE, 0xC5A1, 0xC5A2, 0xC5A3, 0xC5A4, 0xC5A5,
0xC5A6, 0xC5A7, 0xC5A8, 0xC5A9, 0xC5AA, 0xC5AB, 0xC5AC, 0xC5AD,
0xC5AE, 0xC5AF, 0xC5B0, 0xC5B1, 0xC5B2, 0xC5B3, 0xC5B4, 0xC5B5,
0xC5B6, 0xC5B7, 0xC5B8, 0xC5B9, 0xC5BA, 0xC5BB, 0xC5BC, 0xC5BD,
0xC5BE, 0xC5BF, 0xC5C0, 0xC5C1, 0xC5C2, 0xC5C3, 0xC5C4, 0xC5C5,
0xC5C6, 0xC5C7, 0xC5C8, 0xC5C9, 0xC5CA, 0xC5CB, 0xC5CC, 0xC5CD,
0xC5CE, 0xC5CF, 0xC5D0, 0xC5D1, 0xC5D2, 0xC5D3, 0xC5D4, 0xC5D5,
0xC5D6, 0xC5D7, 0xC5D8, 0xC5D9, 0xC5DA, 0xC5DB, 0xC5DC, 0xC5DD,
0xC5DE, 0xC5DF, 0xC5E0, 0xC5E1, 0xC5E2, 0xC5E3, 0xC5E4, 0xC5E5,
0xC5E6, 0xC5E7, 0xC5E8, 0xC5E9, 0xC5EA, 0xC5EB, 0xC5EC, 0xC5ED,
0xC5EE, 0xC5EF, 0xC5F0, 0xC5F1, 0xC5F2, 0xC5F3, 0xC5F4, 0xC5F5,
0xC5F6, 0xC5F7, 0xC5F8, 0xC5F9, 0xC5FA, 0xC5FB, 0xC5FC, 0xC5FD,
0xC5FE, 0xC6A1, 0xC6A2, 0xC6A3, 0xC6A4, 0xC6A5, 0xC6A6, 0xC6A7,
0xC6A8, 0xC6A9, 0xC6AA, 0xC6AB, 0xC6AC, 0xC6AD, 0xC6AE, 0xC6AF,
0xC6B0, 0xC6B1, 0xC6B2, 0xC6B3, 0xC6B4, 0xC6B5, 0xC6B6, 0xC6B7,
0xC6B8, 0xC6B9, 0xC6BA, 0xC6BB, 0xC6BC, 0xC6BD, 0xC6BE, 0xC6BF,
0xC6C0, 0xC6C1, 0xC6C2, 0xC6C3, 0xC6C4, 0xC6C5, 0xC6C6, 0xC6C7,
0xC6C8, 0xC6C9, 0xC6CA, 0xC6CB, 0xC6CC, 0xC6CD, 0xC6CE, 0xC6CF,
0xC6D0, 0xC6D1, 0xC6D2, 0xC6D3, 0xC6D4, 0xC6D5, 0xC6D6, 0xC6D7,
0xC6D8, 0xC6D9, 0xC6DA, 0xC6DB, 0xC6DC, 0xC6DD, 0xC6DE, 0xC6DF,
0xC6E0, 0xC6E1, 0xC6E2, 0xC6E3, 0xC6E4, 0xC6E5, 0xC6E6, 0xC6E7,
0xC6E8, 0xC6E9, 0xC6EA, 0xC6EB, 0xC6EC, 0xC6ED, 0xC6EE, 0xC6EF,
0xC6F0, 0xC6F1, 0xC6F2, 0xC6F3, 0xC6F4, 0xC6F5, 0xC6F6, 0xC6F7,
0xC6F8, 0xC6F9, 0xC6FA, 0xC6FB, 0xC6FC, 0xC6FD, 0xC6FE, 0xC7A1,
0xC7A2, 0xC7A3, 0xC7A4, 0xC7A5, 0xC7A6, 0xC7A7, 0xC7A8, 0xC7A9,
0xC7AA, 0xC7AB, 0xC7AC, 0xC7AD, 0xC7AE, 0xC7AF, 0xC7B0, 0xC7B1,
0xC7B2, 0xC7B3, 0xC7B4, 0xC7B5, 0xC7B6, 0xC7B7, 0xC7B8, 0xC7B9,
0xC7BA, 0xC7BB, 0xC7BC, 0xC7BD, 0xC7BE, 0xC7BF, 0xC7C0, 0xC7C1,
0xC7C2, 0xC7C3, 0xC7C4, 0xC7C5, 0xC7C6, 0xC7C7, 0xC7C8, 0xC7C9,
0xC7CA, 0xC7CB, 0xC7CC, 0xC7CD, 0xC7CE, 0xC7CF, 0xC7D0, 0xC7D1,
0xC7D2, 0xC7D3, 0xC7D4, 0xC7D5, 0xC7D6, 0xC7D7, 0xC7D8, 0xC7D9,
0xC7DA, 0xC7DB, 0xC7DC, 0xC7DD, 0xC7DE, 0xC7DF, 0xC7E0, 0xC7E1,
0xC7E2, 0xC7E3, 0xC7E4, 0xC7E5, 0xC7E6, 0xC7E7, 0xC7E8, 0xC7E9,
0xC7EA, 0xC7EB, 0xC7EC, 0xC7ED, 0xC7EE, 0xC7EF, 0xC7F0, 0xC7F1,
0xC7F2, 0xC7F3, 0xC7F4, 0xC7F5, 0xC7F6, 0xC7F7, 0xC7F8, 0xC7F9,
0xC7FA, 0xC7FB, 0xC7FC, 0xC7FD, 0xC7FE, 0xC8A1, 0xC8A2, 0xC8A3,
0xC8A4, 0xC8A5, 0xC8A6, 0xC8A7, 0xC8A8, 0xC8A9, 0xC8AA, 0xC8AB,
0xC8AC, 0xC8AD, 0xC8AE, 0xC8AF, 0xC8B0, 0xC8B1, 0xC8B2, 0xC8B3,
0xC8B4, 0xC8B5, 0xC8B6, 0xC8B7, 0xC8B8, 0xC8B9, 0xC8BA, 0xC8BB,
0xC8BC, 0xC8BD, 0xC8BE, 0xC8BF, 0xC8C0, 0xC8C1, 0xC8C2, 0xC8C3,
0xC8C4, 0xC8C5, 0xC8C6, 0xC8C7, 0xC8C8, 0xC8C9, 0xC8CA, 0xC8CB,
0xC8CC, 0xC8CD, 0xC8CE, 0xC8CF, 0xC8D0, 0xC8D1, 0xC8D2, 0xC8D3,
0xC8D4, 0xC8D5, 0xC8D6, 0xC8D7, 0xC8D8, 0xC8D9, 0xC8DA, 0xC8DB,
0xC8DC, 0xC8DD, 0xC8DE, 0xC8DF, 0xC8E0, 0xC8E1, 0xC8E2, 0xC8E3,
0xC8E4, 0xC8E5, 0xC8E6, 0xC8E7, 0xC8E8, 0xC8E9, 0xC8EA, 0xC8EB,
0xC8EC, 0xC8ED, 0xC8EE, 0xC8EF, 0xC8F0, 0xC8F1, 0xC8F2, 0xC8F3,
0xC8F4, 0xC8F5, 0xC8F6, 0xC8F7, 0xC8F8, 0xC8F9, 0xC8FA, 0xC8FB,
0xC8FC, 0xC8FD, 0xC8FE, 0xCBD0, 0xCBD6, 0xCBE7, 0xCDCF, 0xCDE8,
0xCEAD, 0xCFFB, 0xD0A2, 0xD0B8, 0xD0D0, 0xD0DD, 0xD1D4, 0xD1D5,
0xD1D8, 0xD1DB, 0xD1DC, 0xD1DD, 0xD1DE, 0xD1DF, 0xD1E0, 0xD1E2,
0xD1E3, 0xD1E4, 0xD1E5, 0xD1E6, 0xD1E8, 0xD1E9, 0xD1EA, 0xD1EB,
0xD1ED, 0xD1EF, 0xD1F0, 0xD1F2, 0xD1F6, 0xD1FA, 0xD1FC, 0xD1FD,
0xD1FE, 0xD2A2, 0xD2A3, 0xD2A7, 0xD2A8, 0xD2A9, 0xD2AA, 0xD2AB,
0xD2AD, 0xD2B2, 0xD2BE, 0xD2C2, 0xD2C3, 0xD2C4, 0xD2C6, 0xD2C7,
0xD2C8, 0xD2C9, 0xD2CA, 0xD2CB, 0xD2CD, 0xD2CE, 0xD2CF, 0xD2D0,
0xD2D1, 0xD2D2, 0xD2D3, 0xD2D4, 0xD2D5, 0xD2D6, 0xD2D7, 0xD2D9,
0xD2DA, 0xD2DE, 0xD2DF, 0xD2E1, 0xD2E2, 0xD2E4, 0xD2E5, 0xD2E6,
0xD2E7, 0xD2E8, 0xD2E9, 0xD2EA, 0xD2EB, 0xD2F0, 0xD2F1, 0xD2F2,
0xD2F3, 0xD2F4, 0xD2F5, 0xD2F7, 0xD2F8, 0xD4E6, 0xD4FC, 0xD5A5,
0xD5AB, 0xD5AE, 0xD6B8, 0xD6CD, 0xD7CB, 0xD7E4, 0xDBC5, 0xDBE4,
0xDCA5, 0xDDA5, 0xDDD5, 0xDDF4, 0xDEFC, 0xDEFE, 0xDFB3, 0xDFE1,
0xDFE8, 0xE0F1, 0xE1AD, 0xE1ED, 0xE3F5, 0xE4A1, 0xE4A9, 0xE5AE,
0xE5B1, 0xE5B2, 0xE5B9, 0xE5BB, 0xE5BC, 0xE5C4, 0xE5CE, 0xE5D0,
0xE5D2, 0xE5D6, 0xE5FA, 0xE5FB, 0xE5FC, 0xE5FE, 0xE6A1, 0xE6A4,
0xE6A7, 0xE6AD, 0xE6AF, 0xE6B0, 0xE6B1, 0xE6B3, 0xE6B7, 0xE6B8,
0xE6BC, 0xE6C4, 0xE6C6, 0xE6C7, 0xE6CA, 0xE6D2, 0xE6D6, 0xE6D9,
0xE6DC, 0xE6DF, 0xE6E1, 0xE6E4, 0xE6E5, 0xE6E6, 0xE6E8, 0xE6EA,
0xE6EB, 0xE6EC, 0xE6EF, 0xE6F1, 0xE6F2, 0xE6F5, 0xE6F6, 0xE6F7,
0xE6F9, 0xE7A1, 0xE7A6, 0xE7A9, 0xE7AA, 0xE7AC, 0xE7AD, 0xE7B0,
0xE7BF, 0xE7C1, 0xE7C6, 0xE7C7, 0xE7CB, 0xE7CD, 0xE7CF, 0xE7D0,
0xE7D3, 0xE7DF, 0xE7E4, 0xE7E6, 0xE7F7, 0xE8E7, 0xE8E8, 0xE8F0,
0xE8F1, 0xE8F7, 0xE8F9, 0xE8FB, 0xE8FE, 0xE9A7, 0xE9AC, 0xE9CC,
0xE9F7, 0xEAC1, 0xEAE5, 0xEAF4, 0xEAF7, 0xEAFC, 0xEAFE, 0xEBA4,
0xEBA7, 0xEBA9, 0xEBAA, 0xEBBA, 0xEBBB, 0xEBBD, 0xEBC1, 0xEBC2,
0xEBC6, 0xEBC7, 0xEBCC, 0xEBCF, 0xEBD0, 0xEBD1, 0xEBD2, 0xEBD8,
0xECA6, 0xECA7, 0xECAA, 0xECAF, 0xECB0, 0xECB1, 0xECB2, 0xECB5,
0xECB8, 0xECBA, 0xECC0, 0xECC1, 0xECC5, 0xECC6, 0xECC9, 0xECCA,
0xECD5, 0xECDD, 0xECDE, 0xECE1, 0xECE4, 0xECE7, 0xECE8, 0xECF7,
0xECF8, 0xECFA, 0xEDA1, 0xEDA2, 0xEDA3, 0xEDEE, 0xEEDB, 0xF2BD,
0xF2FA, 0xF3B1, 0xF4A7, 0xF4EE, 0xF6F4, 0xF6F6, 0xF7B8, 0xF7C8,
0xF7D3, 0xF8DB, 0xF8F0, 0xFAA1, 0xFAA2, 0xFAE6, 0xFCA9, 0xA3A1,
0xA3A2, 0xA3A3, 0xA3A4, 0xA3A5, 0xA3A6, 0xA3A7, 0xA3A8, 0xA3A9,
0xA3AA, 0xA3AB, 0xA3AC, 0xA3AD, 0xA3AE, 0xA3AF, 0xA3B0, 0xA3B1,
0xA3B2, 0xA3B3, 0xA3B4, 0xA3B5, 0xA3B6, 0xA3B7, 0xA3B8, 0xA3B9,
0xA3BA, 0xA3BB, 0xA3BC, 0xA3BD, 0xA3BE, 0xA3BF, 0xA3C0, 0xA3C1,
0xA3C2, 0xA3C3, 0xA3C4, 0xA3C5, 0xA3C6, 0xA3C7, 0xA3C8, 0xA3C9,
0xA3CA, 0xA3CB, 0xA3CC, 0xA3CD, 0xA3CE, 0xA3CF, 0xA3D0, 0xA3D1,
0xA3D2, 0xA3D3, 0xA3D4, 0xA3D5, 0xA3D6, 0xA3D7, 0xA3D8, 0xA3D9,
0xA3DA, 0xA3DB, 0xA1AC, 0xA3DD, 0xA3DE, 0xA3DF, 0xA3E0, 0xA3E1,
0xA3E2, 0xA3E3, 0xA3E4, 0xA3E5, 0xA3E6, 0xA3E7, 0xA3E8, 0xA3E9,
0xA3EA, 0xA3EB, 0xA3EC, 0xA3ED, 0xA3EE, 0xA3EF, 0xA3F0, 0xA3F1,
0xA3F2, 0xA3F3, 0xA3F4, 0xA3F5, 0xA3F6, 0xA3F7, 0xA3F8, 0xA3F9,
0xA3FA, 0xA3FB, 0xA3FC, 0xA3FD, 0xA2A6, 0xA1CB, 0xA1CC, 0xA1FE,
0xA3FE, 0xA1CD, 0xA3DC,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Indexes into Unicode `zueci_ksx1001_u_u[]` array in blocks of 0x100 */
static const zueci_u16 zueci_ksx1001_u_ind[256] = {
0, 50, 50, 73, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 171, 171, 171, 171, 171, 171,
190, 235, 273, 275, 310, 427, 470, 470,
470, 470, 470, 470, 470, 470, 470, 470,
570, 750, 809, 839, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 889, 889, 889, 889,
889, 889, 889, 889, 947, 1025, 1084, 1133,
1186, 1259, 1303, 1376, 1416, 1469, 1504, 1551,
1603, 1654, 1720, 1768, 1832, 1888, 1942, 1969,
1990, 2075, 2136, 2187, 2219, 2281, 2370, 2458,
2525, 2572, 2621, 2653, 2697, 2741, 2792, 2841,
2878, 2931, 2967, 3028, 3071, 3116, 3174, 3239,
3239, 3239, 3239, 3239, 3239, 3239, 3239, 3239,
3239, 3239, 3239, 3239, 3239, 3239, 3239, 3239,
3239, 3239, 3239, 3239, 3239, 3239, 3239, 3239,
3239, 3239, 3239, 3239, 3239, 3239, 3239, 3239,
3239, 3400, 3507, 3507, 3507, 3507, 3507, 3601,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Unicode values in multibyte order */
static const zueci_u16 zueci_ksx1001_mb_u[8366] = {
0x3000, 0x3001, 0x3002, 0x00B7, 0x2025, 0x2026, 0x00A8, 0x3003,
0x00AD, 0x2015, 0x2225, 0xFF3C, 0x223C, 0x2018, 0x2019, 0x201C,
0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C,
0x300D, 0x300E, 0x300F, 0x3010, 0x3011, 0x00B1, 0x00D7, 0x00F7,
0x2260, 0x2264, 0x2265, 0x221E, 0x2234, 0x00B0, 0x2032, 0x2033,
0x2103, 0x212B, 0xFFE0, 0xFFE1, 0xFFE5, 0x2642, 0x2640, 0x2220,
0x22A5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252, 0x00A7, 0x203B,
0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7, 0x25C6, 0x25A1,
0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC, 0x2192, 0x2190, 0x2191,
0x2193, 0x2194, 0x3013, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D,
0x2235, 0x222B, 0x222C, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282,
0x2283, 0x222A, 0x2229, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4,
0x2200, 0x2203, 0x00B4, 0xFF5E, 0x02C7, 0x02D8, 0x02DD, 0x02DA,
0x02D9, 0x00B8, 0x02DB, 0x00A1, 0x00BF, 0x02D0, 0x222E, 0x2211,
0x220F, 0x00A4, 0x2109, 0x2030, 0x25C1, 0x25C0, 0x25B7, 0x25B6,
0x2664, 0x2660, 0x2661, 0x2665, 0x2667, 0x2663, 0x2299, 0x25C8,
0x25A3, 0x25D0, 0x25D1, 0x2592, 0x25A4, 0x25A5, 0x25A8, 0x25A7,
0x25A6, 0x25A9, 0x2668, 0x260F, 0x260E, 0x261C, 0x261E, 0x00B6,
0x2020, 0x2021, 0x2195, 0x2197, 0x2199, 0x2196, 0x2198, 0x266D,
0x2669, 0x266A, 0x266C, 0x327F, 0x321C, 0x2116, 0x33C7, 0x2122,
0x33C2, 0x33D8, 0x2121, 0x20AC, 0x00AE, 0x327E, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 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, 0xFFE6,
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, 0xFFE3, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136,
0x3137, 0x3138, 0x3139, 0x313A, 0x313B, 0x313C, 0x313D, 0x313E,
0x313F, 0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146,
0x3147, 0x3148, 0x3149, 0x314A, 0x314B, 0x314C, 0x314D, 0x314E,
0x314F, 0x3150, 0x3151, 0x3152, 0x3153, 0x3154, 0x3155, 0x3156,
0x3157, 0x3158, 0x3159, 0x315A, 0x315B, 0x315C, 0x315D, 0x315E,
0x315F, 0x3160, 0x3161, 0x3162, 0x3163, 0x3164, 0x3165, 0x3166,
0x3167, 0x3168, 0x3169, 0x316A, 0x316B, 0x316C, 0x316D, 0x316E,
0x316F, 0x3170, 0x3171, 0x3172, 0x3173, 0x3174, 0x3175, 0x3176,
0x3177, 0x3178, 0x3179, 0x317A, 0x317B, 0x317C, 0x317D, 0x317E,
0x317F, 0x3180, 0x3181, 0x3182, 0x3183, 0x3184, 0x3185, 0x3186,
0x3187, 0x3188, 0x3189, 0x318A, 0x318B, 0x318C, 0x318D, 0x318E,
0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
0x2178, 0x2179, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2160,
0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168,
0x2169, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2500, 0x2502,
0x250C, 0x2510, 0x2518, 0x2514, 0x251C, 0x252C, 0x2524, 0x2534,
0x253C, 0x2501, 0x2503, 0x250F, 0x2513, 0x251B, 0x2517, 0x2523,
0x2533, 0x252B, 0x253B, 0x254B, 0x2520, 0x252F, 0x2528, 0x2537,
0x253F, 0x251D, 0x2530, 0x2525, 0x2538, 0x2542, 0x2512, 0x2511,
0x251A, 0x2519, 0x2516, 0x2515, 0x250E, 0x250D, 0x251E, 0x251F,
0x2521, 0x2522, 0x2526, 0x2527, 0x2529, 0x252A, 0x252D, 0x252E,
0x2531, 0x2532, 0x2535, 0x2536, 0x2539, 0x253A, 0x253D, 0x253E,
0x2540, 0x2541, 0x2543, 0x2544, 0x2545, 0x2546, 0x2547, 0x2548,
0x2549, 0x254A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x3395, 0x3396, 0x3397, 0x2113,
0x3398, 0x33C4, 0x33A3, 0x33A4, 0x33A5, 0x33A6, 0x3399, 0x339A,
0x339B, 0x339C, 0x339D, 0x339E, 0x339F, 0x33A0, 0x33A1, 0x33A2,
0x33CA, 0x338D, 0x338E, 0x338F, 0x33CF, 0x3388, 0x3389, 0x33C8,
0x33A7, 0x33A8, 0x33B0, 0x33B1, 0x33B2, 0x33B3, 0x33B4, 0x33B5,
0x33B6, 0x33B7, 0x33B8, 0x33B9, 0x3380, 0x3381, 0x3382, 0x3383,
0x3384, 0x33BA, 0x33BB, 0x33BC, 0x33BD, 0x33BE, 0x33BF, 0x3390,
0x3391, 0x3392, 0x3393, 0x3394, 0x2126, 0x33C0, 0x33C1, 0x338A,
0x338B, 0x338C, 0x33D6, 0x33C5, 0x33AD, 0x33AE, 0x33AF, 0x33DB,
0x33A9, 0x33AA, 0x33AB, 0x33AC, 0x33DD, 0x33D0, 0x33D3, 0x33C3,
0x33C9, 0x33DC, 0x33C6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x00C6, 0x00D0, 0x00AA, 0x0126, 0x0000, 0x0132,
0x0000, 0x013F, 0x0141, 0x00D8, 0x0152, 0x00BA, 0x00DE, 0x0166,
0x014A, 0x0000, 0x3260, 0x3261, 0x3262, 0x3263, 0x3264, 0x3265,
0x3266, 0x3267, 0x3268, 0x3269, 0x326A, 0x326B, 0x326C, 0x326D,
0x326E, 0x326F, 0x3270, 0x3271, 0x3272, 0x3273, 0x3274, 0x3275,
0x3276, 0x3277, 0x3278, 0x3279, 0x327A, 0x327B, 0x24D0, 0x24D1,
0x24D2, 0x24D3, 0x24D4, 0x24D5, 0x24D6, 0x24D7, 0x24D8, 0x24D9,
0x24DA, 0x24DB, 0x24DC, 0x24DD, 0x24DE, 0x24DF, 0x24E0, 0x24E1,
0x24E2, 0x24E3, 0x24E4, 0x24E5, 0x24E6, 0x24E7, 0x24E8, 0x24E9,
0x2460, 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467,
0x2468, 0x2469, 0x246A, 0x246B, 0x246C, 0x246D, 0x246E, 0x00BD,
0x2153, 0x2154, 0x00BC, 0x00BE, 0x215B, 0x215C, 0x215D, 0x215E,
0x00E6, 0x0111, 0x00F0, 0x0127, 0x0131, 0x0133, 0x0138, 0x0140,
0x0142, 0x00F8, 0x0153, 0x00DF, 0x00FE, 0x0167, 0x014B, 0x0149,
0x3200, 0x3201, 0x3202, 0x3203, 0x3204, 0x3205, 0x3206, 0x3207,
0x3208, 0x3209, 0x320A, 0x320B, 0x320C, 0x320D, 0x320E, 0x320F,
0x3210, 0x3211, 0x3212, 0x3213, 0x3214, 0x3215, 0x3216, 0x3217,
0x3218, 0x3219, 0x321A, 0x321B, 0x249C, 0x249D, 0x249E, 0x249F,
0x24A0, 0x24A1, 0x24A2, 0x24A3, 0x24A4, 0x24A5, 0x24A6, 0x24A7,
0x24A8, 0x24A9, 0x24AA, 0x24AB, 0x24AC, 0x24AD, 0x24AE, 0x24AF,
0x24B0, 0x24B1, 0x24B2, 0x24B3, 0x24B4, 0x24B5, 0x2474, 0x2475,
0x2476, 0x2477, 0x2478, 0x2479, 0x247A, 0x247B, 0x247C, 0x247D,
0x247E, 0x247F, 0x2480, 0x2481, 0x2482, 0x00B9, 0x00B2, 0x00B3,
0x2074, 0x207F, 0x2081, 0x2082, 0x2083, 0x2084, 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, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415,
0x0401, 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, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435,
0x0451, 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, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xAC00, 0xAC01, 0xAC04, 0xAC07, 0xAC08, 0xAC09, 0xAC0A, 0xAC10,
0xAC11, 0xAC12, 0xAC13, 0xAC14, 0xAC15, 0xAC16, 0xAC17, 0xAC19,
0xAC1A, 0xAC1B, 0xAC1C, 0xAC1D, 0xAC20, 0xAC24, 0xAC2C, 0xAC2D,
0xAC2F, 0xAC30, 0xAC31, 0xAC38, 0xAC39, 0xAC3C, 0xAC40, 0xAC4B,
0xAC4D, 0xAC54, 0xAC58, 0xAC5C, 0xAC70, 0xAC71, 0xAC74, 0xAC77,
0xAC78, 0xAC7A, 0xAC80, 0xAC81, 0xAC83, 0xAC84, 0xAC85, 0xAC86,
0xAC89, 0xAC8A, 0xAC8B, 0xAC8C, 0xAC90, 0xAC94, 0xAC9C, 0xAC9D,
0xAC9F, 0xACA0, 0xACA1, 0xACA8, 0xACA9, 0xACAA, 0xACAC, 0xACAF,
0xACB0, 0xACB8, 0xACB9, 0xACBB, 0xACBC, 0xACBD, 0xACC1, 0xACC4,
0xACC8, 0xACCC, 0xACD5, 0xACD7, 0xACE0, 0xACE1, 0xACE4, 0xACE7,
0xACE8, 0xACEA, 0xACEC, 0xACEF, 0xACF0, 0xACF1, 0xACF3, 0xACF5,
0xACF6, 0xACFC, 0xACFD, 0xAD00, 0xAD04, 0xAD06, 0xAD0C, 0xAD0D,
0xAD0F, 0xAD11, 0xAD18, 0xAD1C, 0xAD20, 0xAD29, 0xAD2C, 0xAD2D,
0xAD34, 0xAD35, 0xAD38, 0xAD3C, 0xAD44, 0xAD45, 0xAD47, 0xAD49,
0xAD50, 0xAD54, 0xAD58, 0xAD61, 0xAD63, 0xAD6C, 0xAD6D, 0xAD70,
0xAD73, 0xAD74, 0xAD75, 0xAD76, 0xAD7B, 0xAD7C, 0xAD7D, 0xAD7F,
0xAD81, 0xAD82, 0xAD88, 0xAD89, 0xAD8C, 0xAD90, 0xAD9C, 0xAD9D,
0xADA4, 0xADB7, 0xADC0, 0xADC1, 0xADC4, 0xADC8, 0xADD0, 0xADD1,
0xADD3, 0xADDC, 0xADE0, 0xADE4, 0xADF8, 0xADF9, 0xADFC, 0xADFF,
0xAE00, 0xAE01, 0xAE08, 0xAE09, 0xAE0B, 0xAE0D, 0xAE14, 0xAE30,
0xAE31, 0xAE34, 0xAE37, 0xAE38, 0xAE3A, 0xAE40, 0xAE41, 0xAE43,
0xAE45, 0xAE46, 0xAE4A, 0xAE4C, 0xAE4D, 0xAE4E, 0xAE50, 0xAE54,
0xAE56, 0xAE5C, 0xAE5D, 0xAE5F, 0xAE60, 0xAE61, 0xAE65, 0xAE68,
0xAE69, 0xAE6C, 0xAE70, 0xAE78, 0xAE79, 0xAE7B, 0xAE7C, 0xAE7D,
0xAE84, 0xAE85, 0xAE8C, 0xAEBC, 0xAEBD, 0xAEBE, 0xAEC0, 0xAEC4,
0xAECC, 0xAECD, 0xAECF, 0xAED0, 0xAED1, 0xAED8, 0xAED9, 0xAEDC,
0xAEE8, 0xAEEB, 0xAEED, 0xAEF4, 0xAEF8, 0xAEFC, 0xAF07, 0xAF08,
0xAF0D, 0xAF10, 0xAF2C, 0xAF2D, 0xAF30, 0xAF32, 0xAF34, 0xAF3C,
0xAF3D, 0xAF3F, 0xAF41, 0xAF42, 0xAF43, 0xAF48, 0xAF49, 0xAF50,
0xAF5C, 0xAF5D, 0xAF64, 0xAF65, 0xAF79, 0xAF80, 0xAF84, 0xAF88,
0xAF90, 0xAF91, 0xAF95, 0xAF9C, 0xAFB8, 0xAFB9, 0xAFBC, 0xAFC0,
0xAFC7, 0xAFC8, 0xAFC9, 0xAFCB, 0xAFCD, 0xAFCE, 0xAFD4, 0xAFDC,
0xAFE8, 0xAFE9, 0xAFF0, 0xAFF1, 0xAFF4, 0xAFF8, 0xB000, 0xB001,
0xB004, 0xB00C, 0xB010, 0xB014, 0xB01C, 0xB01D, 0xB028, 0xB044,
0xB045, 0xB048, 0xB04A, 0xB04C, 0xB04E, 0xB053, 0xB054, 0xB055,
0xB057, 0xB059, 0xB05D, 0xB07C, 0xB07D, 0xB080, 0xB084, 0xB08C,
0xB08D, 0xB08F, 0xB091, 0xB098, 0xB099, 0xB09A, 0xB09C, 0xB09F,
0xB0A0, 0xB0A1, 0xB0A2, 0xB0A8, 0xB0A9, 0xB0AB, 0xB0AC, 0xB0AD,
0xB0AE, 0xB0AF, 0xB0B1, 0xB0B3, 0xB0B4, 0xB0B5, 0xB0B8, 0xB0BC,
0xB0C4, 0xB0C5, 0xB0C7, 0xB0C8, 0xB0C9, 0xB0D0, 0xB0D1, 0xB0D4,
0xB0D8, 0xB0E0, 0xB0E5, 0xB108, 0xB109, 0xB10B, 0xB10C, 0xB110,
0xB112, 0xB113, 0xB118, 0xB119, 0xB11B, 0xB11C, 0xB11D, 0xB123,
0xB124, 0xB125, 0xB128, 0xB12C, 0xB134, 0xB135, 0xB137, 0xB138,
0xB139, 0xB140, 0xB141, 0xB144, 0xB148, 0xB150, 0xB151, 0xB154,
0xB155, 0xB158, 0xB15C, 0xB160, 0xB178, 0xB179, 0xB17C, 0xB180,
0xB182, 0xB188, 0xB189, 0xB18B, 0xB18D, 0xB192, 0xB193, 0xB194,
0xB198, 0xB19C, 0xB1A8, 0xB1CC, 0xB1D0, 0xB1D4, 0xB1DC, 0xB1DD,
0xB1DF, 0xB1E8, 0xB1E9, 0xB1EC, 0xB1F0, 0xB1F9, 0xB1FB, 0xB1FD,
0xB204, 0xB205, 0xB208, 0xB20B, 0xB20C, 0xB214, 0xB215, 0xB217,
0xB219, 0xB220, 0xB234, 0xB23C, 0xB258, 0xB25C, 0xB260, 0xB268,
0xB269, 0xB274, 0xB275, 0xB27C, 0xB284, 0xB285, 0xB289, 0xB290,
0xB291, 0xB294, 0xB298, 0xB299, 0xB29A, 0xB2A0, 0xB2A1, 0xB2A3,
0xB2A5, 0xB2A6, 0xB2AA, 0xB2AC, 0xB2B0, 0xB2B4, 0xB2C8, 0xB2C9,
0xB2CC, 0xB2D0, 0xB2D2, 0xB2D8, 0xB2D9, 0xB2DB, 0xB2DD, 0xB2E2,
0xB2E4, 0xB2E5, 0xB2E6, 0xB2E8, 0xB2EB, 0xB2EC, 0xB2ED, 0xB2EE,
0xB2EF, 0xB2F3, 0xB2F4, 0xB2F5, 0xB2F7, 0xB2F8, 0xB2F9, 0xB2FA,
0xB2FB, 0xB2FF, 0xB300, 0xB301, 0xB304, 0xB308, 0xB310, 0xB311,
0xB313, 0xB314, 0xB315, 0xB31C, 0xB354, 0xB355, 0xB356, 0xB358,
0xB35B, 0xB35C, 0xB35E, 0xB35F, 0xB364, 0xB365, 0xB367, 0xB369,
0xB36B, 0xB36E, 0xB370, 0xB371, 0xB374, 0xB378, 0xB380, 0xB381,
0xB383, 0xB384, 0xB385, 0xB38C, 0xB390, 0xB394, 0xB3A0, 0xB3A1,
0xB3A8, 0xB3AC, 0xB3C4, 0xB3C5, 0xB3C8, 0xB3CB, 0xB3CC, 0xB3CE,
0xB3D0, 0xB3D4, 0xB3D5, 0xB3D7, 0xB3D9, 0xB3DB, 0xB3DD, 0xB3E0,
0xB3E4, 0xB3E8, 0xB3FC, 0xB410, 0xB418, 0xB41C, 0xB420, 0xB428,
0xB429, 0xB42B, 0xB434, 0xB450, 0xB451, 0xB454, 0xB458, 0xB460,
0xB461, 0xB463, 0xB465, 0xB46C, 0xB480, 0xB488, 0xB49D, 0xB4A4,
0xB4A8, 0xB4AC, 0xB4B5, 0xB4B7, 0xB4B9, 0xB4C0, 0xB4C4, 0xB4C8,
0xB4D0, 0xB4D5, 0xB4DC, 0xB4DD, 0xB4E0, 0xB4E3, 0xB4E4, 0xB4E6,
0xB4EC, 0xB4ED, 0xB4EF, 0xB4F1, 0xB4F8, 0xB514, 0xB515, 0xB518,
0xB51B, 0xB51C, 0xB524, 0xB525, 0xB527, 0xB528, 0xB529, 0xB52A,
0xB530, 0xB531, 0xB534, 0xB538, 0xB540, 0xB541, 0xB543, 0xB544,
0xB545, 0xB54B, 0xB54C, 0xB54D, 0xB550, 0xB554, 0xB55C, 0xB55D,
0xB55F, 0xB560, 0xB561, 0xB5A0, 0xB5A1, 0xB5A4, 0xB5A8, 0xB5AA,
0xB5AB, 0xB5B0, 0xB5B1, 0xB5B3, 0xB5B4, 0xB5B5, 0xB5BB, 0xB5BC,
0xB5BD, 0xB5C0, 0xB5C4, 0xB5CC, 0xB5CD, 0xB5CF, 0xB5D0, 0xB5D1,
0xB5D8, 0xB5EC, 0xB610, 0xB611, 0xB614, 0xB618, 0xB625, 0xB62C,
0xB634, 0xB648, 0xB664, 0xB668, 0xB69C, 0xB69D, 0xB6A0, 0xB6A4,
0xB6AB, 0xB6AC, 0xB6B1, 0xB6D4, 0xB6F0, 0xB6F4, 0xB6F8, 0xB700,
0xB701, 0xB705, 0xB728, 0xB729, 0xB72C, 0xB72F, 0xB730, 0xB738,
0xB739, 0xB73B, 0xB744, 0xB748, 0xB74C, 0xB754, 0xB755, 0xB760,
0xB764, 0xB768, 0xB770, 0xB771, 0xB773, 0xB775, 0xB77C, 0xB77D,
0xB780, 0xB784, 0xB78C, 0xB78D, 0xB78F, 0xB790, 0xB791, 0xB792,
0xB796, 0xB797, 0xB798, 0xB799, 0xB79C, 0xB7A0, 0xB7A8, 0xB7A9,
0xB7AB, 0xB7AC, 0xB7AD, 0xB7B4, 0xB7B5, 0xB7B8, 0xB7C7, 0xB7C9,
0xB7EC, 0xB7ED, 0xB7F0, 0xB7F4, 0xB7FC, 0xB7FD, 0xB7FF, 0xB800,
0xB801, 0xB807, 0xB808, 0xB809, 0xB80C, 0xB810, 0xB818, 0xB819,
0xB81B, 0xB81D, 0xB824, 0xB825, 0xB828, 0xB82C, 0xB834, 0xB835,
0xB837, 0xB838, 0xB839, 0xB840, 0xB844, 0xB851, 0xB853, 0xB85C,
0xB85D, 0xB860, 0xB864, 0xB86C, 0xB86D, 0xB86F, 0xB871, 0xB878,
0xB87C, 0xB88D, 0xB8A8, 0xB8B0, 0xB8B4, 0xB8B8, 0xB8C0, 0xB8C1,
0xB8C3, 0xB8C5, 0xB8CC, 0xB8D0, 0xB8D4, 0xB8DD, 0xB8DF, 0xB8E1,
0xB8E8, 0xB8E9, 0xB8EC, 0xB8F0, 0xB8F8, 0xB8F9, 0xB8FB, 0xB8FD,
0xB904, 0xB918, 0xB920, 0xB93C, 0xB93D, 0xB940, 0xB944, 0xB94C,
0xB94F, 0xB951, 0xB958, 0xB959, 0xB95C, 0xB960, 0xB968, 0xB969,
0xB96B, 0xB96D, 0xB974, 0xB975, 0xB978, 0xB97C, 0xB984, 0xB985,
0xB987, 0xB989, 0xB98A, 0xB98D, 0xB98E, 0xB9AC, 0xB9AD, 0xB9B0,
0xB9B4, 0xB9BC, 0xB9BD, 0xB9BF, 0xB9C1, 0xB9C8, 0xB9C9, 0xB9CC,
0xB9CE, 0xB9CF, 0xB9D0, 0xB9D1, 0xB9D2, 0xB9D8, 0xB9D9, 0xB9DB,
0xB9DD, 0xB9DE, 0xB9E1, 0xB9E3, 0xB9E4, 0xB9E5, 0xB9E8, 0xB9EC,
0xB9F4, 0xB9F5, 0xB9F7, 0xB9F8, 0xB9F9, 0xB9FA, 0xBA00, 0xBA01,
0xBA08, 0xBA15, 0xBA38, 0xBA39, 0xBA3C, 0xBA40, 0xBA42, 0xBA48,
0xBA49, 0xBA4B, 0xBA4D, 0xBA4E, 0xBA53, 0xBA54, 0xBA55, 0xBA58,
0xBA5C, 0xBA64, 0xBA65, 0xBA67, 0xBA68, 0xBA69, 0xBA70, 0xBA71,
0xBA74, 0xBA78, 0xBA83, 0xBA84, 0xBA85, 0xBA87, 0xBA8C, 0xBAA8,
0xBAA9, 0xBAAB, 0xBAAC, 0xBAB0, 0xBAB2, 0xBAB8, 0xBAB9, 0xBABB,
0xBABD, 0xBAC4, 0xBAC8, 0xBAD8, 0xBAD9, 0xBAFC, 0xBB00, 0xBB04,
0xBB0D, 0xBB0F, 0xBB11, 0xBB18, 0xBB1C, 0xBB20, 0xBB29, 0xBB2B,
0xBB34, 0xBB35, 0xBB36, 0xBB38, 0xBB3B, 0xBB3C, 0xBB3D, 0xBB3E,
0xBB44, 0xBB45, 0xBB47, 0xBB49, 0xBB4D, 0xBB4F, 0xBB50, 0xBB54,
0xBB58, 0xBB61, 0xBB63, 0xBB6C, 0xBB88, 0xBB8C, 0xBB90, 0xBBA4,
0xBBA8, 0xBBAC, 0xBBB4, 0xBBB7, 0xBBC0, 0xBBC4, 0xBBC8, 0xBBD0,
0xBBD3, 0xBBF8, 0xBBF9, 0xBBFC, 0xBBFF, 0xBC00, 0xBC02, 0xBC08,
0xBC09, 0xBC0B, 0xBC0C, 0xBC0D, 0xBC0F, 0xBC11, 0xBC14, 0xBC15,
0xBC16, 0xBC17, 0xBC18, 0xBC1B, 0xBC1C, 0xBC1D, 0xBC1E, 0xBC1F,
0xBC24, 0xBC25, 0xBC27, 0xBC29, 0xBC2D, 0xBC30, 0xBC31, 0xBC34,
0xBC38, 0xBC40, 0xBC41, 0xBC43, 0xBC44, 0xBC45, 0xBC49, 0xBC4C,
0xBC4D, 0xBC50, 0xBC5D, 0xBC84, 0xBC85, 0xBC88, 0xBC8B, 0xBC8C,
0xBC8E, 0xBC94, 0xBC95, 0xBC97, 0xBC99, 0xBC9A, 0xBCA0, 0xBCA1,
0xBCA4, 0xBCA7, 0xBCA8, 0xBCB0, 0xBCB1, 0xBCB3, 0xBCB4, 0xBCB5,
0xBCBC, 0xBCBD, 0xBCC0, 0xBCC4, 0xBCCD, 0xBCCF, 0xBCD0, 0xBCD1,
0xBCD5, 0xBCD8, 0xBCDC, 0xBCF4, 0xBCF5, 0xBCF6, 0xBCF8, 0xBCFC,
0xBD04, 0xBD05, 0xBD07, 0xBD09, 0xBD10, 0xBD14, 0xBD24, 0xBD2C,
0xBD40, 0xBD48, 0xBD49, 0xBD4C, 0xBD50, 0xBD58, 0xBD59, 0xBD64,
0xBD68, 0xBD80, 0xBD81, 0xBD84, 0xBD87, 0xBD88, 0xBD89, 0xBD8A,
0xBD90, 0xBD91, 0xBD93, 0xBD95, 0xBD99, 0xBD9A, 0xBD9C, 0xBDA4,
0xBDB0, 0xBDB8, 0xBDD4, 0xBDD5, 0xBDD8, 0xBDDC, 0xBDE9, 0xBDF0,
0xBDF4, 0xBDF8, 0xBE00, 0xBE03, 0xBE05, 0xBE0C, 0xBE0D, 0xBE10,
0xBE14, 0xBE1C, 0xBE1D, 0xBE1F, 0xBE44, 0xBE45, 0xBE48, 0xBE4C,
0xBE4E, 0xBE54, 0xBE55, 0xBE57, 0xBE59, 0xBE5A, 0xBE5B, 0xBE60,
0xBE61, 0xBE64, 0xBE68, 0xBE6A, 0xBE70, 0xBE71, 0xBE73, 0xBE74,
0xBE75, 0xBE7B, 0xBE7C, 0xBE7D, 0xBE80, 0xBE84, 0xBE8C, 0xBE8D,
0xBE8F, 0xBE90, 0xBE91, 0xBE98, 0xBE99, 0xBEA8, 0xBED0, 0xBED1,
0xBED4, 0xBED7, 0xBED8, 0xBEE0, 0xBEE3, 0xBEE4, 0xBEE5, 0xBEEC,
0xBF01, 0xBF08, 0xBF09, 0xBF18, 0xBF19, 0xBF1B, 0xBF1C, 0xBF1D,
0xBF40, 0xBF41, 0xBF44, 0xBF48, 0xBF50, 0xBF51, 0xBF55, 0xBF94,
0xBFB0, 0xBFC5, 0xBFCC, 0xBFCD, 0xBFD0, 0xBFD4, 0xBFDC, 0xBFDF,
0xBFE1, 0xC03C, 0xC051, 0xC058, 0xC05C, 0xC060, 0xC068, 0xC069,
0xC090, 0xC091, 0xC094, 0xC098, 0xC0A0, 0xC0A1, 0xC0A3, 0xC0A5,
0xC0AC, 0xC0AD, 0xC0AF, 0xC0B0, 0xC0B3, 0xC0B4, 0xC0B5, 0xC0B6,
0xC0BC, 0xC0BD, 0xC0BF, 0xC0C0, 0xC0C1, 0xC0C5, 0xC0C8, 0xC0C9,
0xC0CC, 0xC0D0, 0xC0D8, 0xC0D9, 0xC0DB, 0xC0DC, 0xC0DD, 0xC0E4,
0xC0E5, 0xC0E8, 0xC0EC, 0xC0F4, 0xC0F5, 0xC0F7, 0xC0F9, 0xC100,
0xC104, 0xC108, 0xC110, 0xC115, 0xC11C, 0xC11D, 0xC11E, 0xC11F,
0xC120, 0xC123, 0xC124, 0xC126, 0xC127, 0xC12C, 0xC12D, 0xC12F,
0xC130, 0xC131, 0xC136, 0xC138, 0xC139, 0xC13C, 0xC140, 0xC148,
0xC149, 0xC14B, 0xC14C, 0xC14D, 0xC154, 0xC155, 0xC158, 0xC15C,
0xC164, 0xC165, 0xC167, 0xC168, 0xC169, 0xC170, 0xC174, 0xC178,
0xC185, 0xC18C, 0xC18D, 0xC18E, 0xC190, 0xC194, 0xC196, 0xC19C,
0xC19D, 0xC19F, 0xC1A1, 0xC1A5, 0xC1A8, 0xC1A9, 0xC1AC, 0xC1B0,
0xC1BD, 0xC1C4, 0xC1C8, 0xC1CC, 0xC1D4, 0xC1D7, 0xC1D8, 0xC1E0,
0xC1E4, 0xC1E8, 0xC1F0, 0xC1F1, 0xC1F3, 0xC1FC, 0xC1FD, 0xC200,
0xC204, 0xC20C, 0xC20D, 0xC20F, 0xC211, 0xC218, 0xC219, 0xC21C,
0xC21F, 0xC220, 0xC228, 0xC229, 0xC22B, 0xC22D, 0xC22F, 0xC231,
0xC232, 0xC234, 0xC248, 0xC250, 0xC251, 0xC254, 0xC258, 0xC260,
0xC265, 0xC26C, 0xC26D, 0xC270, 0xC274, 0xC27C, 0xC27D, 0xC27F,
0xC281, 0xC288, 0xC289, 0xC290, 0xC298, 0xC29B, 0xC29D, 0xC2A4,
0xC2A5, 0xC2A8, 0xC2AC, 0xC2AD, 0xC2B4, 0xC2B5, 0xC2B7, 0xC2B9,
0xC2DC, 0xC2DD, 0xC2E0, 0xC2E3, 0xC2E4, 0xC2EB, 0xC2EC, 0xC2ED,
0xC2EF, 0xC2F1, 0xC2F6, 0xC2F8, 0xC2F9, 0xC2FB, 0xC2FC, 0xC300,
0xC308, 0xC309, 0xC30C, 0xC30D, 0xC313, 0xC314, 0xC315, 0xC318,
0xC31C, 0xC324, 0xC325, 0xC328, 0xC329, 0xC345, 0xC368, 0xC369,
0xC36C, 0xC370, 0xC372, 0xC378, 0xC379, 0xC37C, 0xC37D, 0xC384,
0xC388, 0xC38C, 0xC3C0, 0xC3D8, 0xC3D9, 0xC3DC, 0xC3DF, 0xC3E0,
0xC3E2, 0xC3E8, 0xC3E9, 0xC3ED, 0xC3F4, 0xC3F5, 0xC3F8, 0xC408,
0xC410, 0xC424, 0xC42C, 0xC430, 0xC434, 0xC43C, 0xC43D, 0xC448,
0xC464, 0xC465, 0xC468, 0xC46C, 0xC474, 0xC475, 0xC479, 0xC480,
0xC494, 0xC49C, 0xC4B8, 0xC4BC, 0xC4E9, 0xC4F0, 0xC4F1, 0xC4F4,
0xC4F8, 0xC4FA, 0xC4FF, 0xC500, 0xC501, 0xC50C, 0xC510, 0xC514,
0xC51C, 0xC528, 0xC529, 0xC52C, 0xC530, 0xC538, 0xC539, 0xC53B,
0xC53D, 0xC544, 0xC545, 0xC548, 0xC549, 0xC54A, 0xC54C, 0xC54D,
0xC54E, 0xC553, 0xC554, 0xC555, 0xC557, 0xC558, 0xC559, 0xC55D,
0xC55E, 0xC560, 0xC561, 0xC564, 0xC568, 0xC570, 0xC571, 0xC573,
0xC574, 0xC575, 0xC57C, 0xC57D, 0xC580, 0xC584, 0xC587, 0xC58C,
0xC58D, 0xC58F, 0xC591, 0xC595, 0xC597, 0xC598, 0xC59C, 0xC5A0,
0xC5A9, 0xC5B4, 0xC5B5, 0xC5B8, 0xC5B9, 0xC5BB, 0xC5BC, 0xC5BD,
0xC5BE, 0xC5C4, 0xC5C5, 0xC5C6, 0xC5C7, 0xC5C8, 0xC5C9, 0xC5CA,
0xC5CC, 0xC5CE, 0xC5D0, 0xC5D1, 0xC5D4, 0xC5D8, 0xC5E0, 0xC5E1,
0xC5E3, 0xC5E5, 0xC5EC, 0xC5ED, 0xC5EE, 0xC5F0, 0xC5F4, 0xC5F6,
0xC5F7, 0xC5FC, 0xC5FD, 0xC5FE, 0xC5FF, 0xC600, 0xC601, 0xC605,
0xC606, 0xC607, 0xC608, 0xC60C, 0xC610, 0xC618, 0xC619, 0xC61B,
0xC61C, 0xC624, 0xC625, 0xC628, 0xC62C, 0xC62D, 0xC62E, 0xC630,
0xC633, 0xC634, 0xC635, 0xC637, 0xC639, 0xC63B, 0xC640, 0xC641,
0xC644, 0xC648, 0xC650, 0xC651, 0xC653, 0xC654, 0xC655, 0xC65C,
0xC65D, 0xC660, 0xC66C, 0xC66F, 0xC671, 0xC678, 0xC679, 0xC67C,
0xC680, 0xC688, 0xC689, 0xC68B, 0xC68D, 0xC694, 0xC695, 0xC698,
0xC69C, 0xC6A4, 0xC6A5, 0xC6A7, 0xC6A9, 0xC6B0, 0xC6B1, 0xC6B4,
0xC6B8, 0xC6B9, 0xC6BA, 0xC6C0, 0xC6C1, 0xC6C3, 0xC6C5, 0xC6CC,
0xC6CD, 0xC6D0, 0xC6D4, 0xC6DC, 0xC6DD, 0xC6E0, 0xC6E1, 0xC6E8,
0xC6E9, 0xC6EC, 0xC6F0, 0xC6F8, 0xC6F9, 0xC6FD, 0xC704, 0xC705,
0xC708, 0xC70C, 0xC714, 0xC715, 0xC717, 0xC719, 0xC720, 0xC721,
0xC724, 0xC728, 0xC730, 0xC731, 0xC733, 0xC735, 0xC737, 0xC73C,
0xC73D, 0xC740, 0xC744, 0xC74A, 0xC74C, 0xC74D, 0xC74F, 0xC751,
0xC752, 0xC753, 0xC754, 0xC755, 0xC756, 0xC757, 0xC758, 0xC75C,
0xC760, 0xC768, 0xC76B, 0xC774, 0xC775, 0xC778, 0xC77C, 0xC77D,
0xC77E, 0xC783, 0xC784, 0xC785, 0xC787, 0xC788, 0xC789, 0xC78A,
0xC78E, 0xC790, 0xC791, 0xC794, 0xC796, 0xC797, 0xC798, 0xC79A,
0xC7A0, 0xC7A1, 0xC7A3, 0xC7A4, 0xC7A5, 0xC7A6, 0xC7AC, 0xC7AD,
0xC7B0, 0xC7B4, 0xC7BC, 0xC7BD, 0xC7BF, 0xC7C0, 0xC7C1, 0xC7C8,
0xC7C9, 0xC7CC, 0xC7CE, 0xC7D0, 0xC7D8, 0xC7DD, 0xC7E4, 0xC7E8,
0xC7EC, 0xC800, 0xC801, 0xC804, 0xC808, 0xC80A, 0xC810, 0xC811,
0xC813, 0xC815, 0xC816, 0xC81C, 0xC81D, 0xC820, 0xC824, 0xC82C,
0xC82D, 0xC82F, 0xC831, 0xC838, 0xC83C, 0xC840, 0xC848, 0xC849,
0xC84C, 0xC84D, 0xC854, 0xC870, 0xC871, 0xC874, 0xC878, 0xC87A,
0xC880, 0xC881, 0xC883, 0xC885, 0xC886, 0xC887, 0xC88B, 0xC88C,
0xC88D, 0xC894, 0xC89D, 0xC89F, 0xC8A1, 0xC8A8, 0xC8BC, 0xC8BD,
0xC8C4, 0xC8C8, 0xC8CC, 0xC8D4, 0xC8D5, 0xC8D7, 0xC8D9, 0xC8E0,
0xC8E1, 0xC8E4, 0xC8F5, 0xC8FC, 0xC8FD, 0xC900, 0xC904, 0xC905,
0xC906, 0xC90C, 0xC90D, 0xC90F, 0xC911, 0xC918, 0xC92C, 0xC934,
0xC950, 0xC951, 0xC954, 0xC958, 0xC960, 0xC961, 0xC963, 0xC96C,
0xC970, 0xC974, 0xC97C, 0xC988, 0xC989, 0xC98C, 0xC990, 0xC998,
0xC999, 0xC99B, 0xC99D, 0xC9C0, 0xC9C1, 0xC9C4, 0xC9C7, 0xC9C8,
0xC9CA, 0xC9D0, 0xC9D1, 0xC9D3, 0xC9D5, 0xC9D6, 0xC9D9, 0xC9DA,
0xC9DC, 0xC9DD, 0xC9E0, 0xC9E2, 0xC9E4, 0xC9E7, 0xC9EC, 0xC9ED,
0xC9EF, 0xC9F0, 0xC9F1, 0xC9F8, 0xC9F9, 0xC9FC, 0xCA00, 0xCA08,
0xCA09, 0xCA0B, 0xCA0C, 0xCA0D, 0xCA14, 0xCA18, 0xCA29, 0xCA4C,
0xCA4D, 0xCA50, 0xCA54, 0xCA5C, 0xCA5D, 0xCA5F, 0xCA60, 0xCA61,
0xCA68, 0xCA7D, 0xCA84, 0xCA98, 0xCABC, 0xCABD, 0xCAC0, 0xCAC4,
0xCACC, 0xCACD, 0xCACF, 0xCAD1, 0xCAD3, 0xCAD8, 0xCAD9, 0xCAE0,
0xCAEC, 0xCAF4, 0xCB08, 0xCB10, 0xCB14, 0xCB18, 0xCB20, 0xCB21,
0xCB41, 0xCB48, 0xCB49, 0xCB4C, 0xCB50, 0xCB58, 0xCB59, 0xCB5D,
0xCB64, 0xCB78, 0xCB79, 0xCB9C, 0xCBB8, 0xCBD4, 0xCBE4, 0xCBE7,
0xCBE9, 0xCC0C, 0xCC0D, 0xCC10, 0xCC14, 0xCC1C, 0xCC1D, 0xCC21,
0xCC22, 0xCC27, 0xCC28, 0xCC29, 0xCC2C, 0xCC2E, 0xCC30, 0xCC38,
0xCC39, 0xCC3B, 0xCC3C, 0xCC3D, 0xCC3E, 0xCC44, 0xCC45, 0xCC48,
0xCC4C, 0xCC54, 0xCC55, 0xCC57, 0xCC58, 0xCC59, 0xCC60, 0xCC64,
0xCC66, 0xCC68, 0xCC70, 0xCC75, 0xCC98, 0xCC99, 0xCC9C, 0xCCA0,
0xCCA8, 0xCCA9, 0xCCAB, 0xCCAC, 0xCCAD, 0xCCB4, 0xCCB5, 0xCCB8,
0xCCBC, 0xCCC4, 0xCCC5, 0xCCC7, 0xCCC9, 0xCCD0, 0xCCD4, 0xCCE4,
0xCCEC, 0xCCF0, 0xCD01, 0xCD08, 0xCD09, 0xCD0C, 0xCD10, 0xCD18,
0xCD19, 0xCD1B, 0xCD1D, 0xCD24, 0xCD28, 0xCD2C, 0xCD39, 0xCD5C,
0xCD60, 0xCD64, 0xCD6C, 0xCD6D, 0xCD6F, 0xCD71, 0xCD78, 0xCD88,
0xCD94, 0xCD95, 0xCD98, 0xCD9C, 0xCDA4, 0xCDA5, 0xCDA7, 0xCDA9,
0xCDB0, 0xCDC4, 0xCDCC, 0xCDD0, 0xCDE8, 0xCDEC, 0xCDF0, 0xCDF8,
0xCDF9, 0xCDFB, 0xCDFD, 0xCE04, 0xCE08, 0xCE0C, 0xCE14, 0xCE19,
0xCE20, 0xCE21, 0xCE24, 0xCE28, 0xCE30, 0xCE31, 0xCE33, 0xCE35,
0xCE58, 0xCE59, 0xCE5C, 0xCE5F, 0xCE60, 0xCE61, 0xCE68, 0xCE69,
0xCE6B, 0xCE6D, 0xCE74, 0xCE75, 0xCE78, 0xCE7C, 0xCE84, 0xCE85,
0xCE87, 0xCE89, 0xCE90, 0xCE91, 0xCE94, 0xCE98, 0xCEA0, 0xCEA1,
0xCEA3, 0xCEA4, 0xCEA5, 0xCEAC, 0xCEAD, 0xCEC1, 0xCEE4, 0xCEE5,
0xCEE8, 0xCEEB, 0xCEEC, 0xCEF4, 0xCEF5, 0xCEF7, 0xCEF8, 0xCEF9,
0xCF00, 0xCF01, 0xCF04, 0xCF08, 0xCF10, 0xCF11, 0xCF13, 0xCF15,
0xCF1C, 0xCF20, 0xCF24, 0xCF2C, 0xCF2D, 0xCF2F, 0xCF30, 0xCF31,
0xCF38, 0xCF54, 0xCF55, 0xCF58, 0xCF5C, 0xCF64, 0xCF65, 0xCF67,
0xCF69, 0xCF70, 0xCF71, 0xCF74, 0xCF78, 0xCF80, 0xCF85, 0xCF8C,
0xCFA1, 0xCFA8, 0xCFB0, 0xCFC4, 0xCFE0, 0xCFE1, 0xCFE4, 0xCFE8,
0xCFF0, 0xCFF1, 0xCFF3, 0xCFF5, 0xCFFC, 0xD000, 0xD004, 0xD011,
0xD018, 0xD02D, 0xD034, 0xD035, 0xD038, 0xD03C, 0xD044, 0xD045,
0xD047, 0xD049, 0xD050, 0xD054, 0xD058, 0xD060, 0xD06C, 0xD06D,
0xD070, 0xD074, 0xD07C, 0xD07D, 0xD081, 0xD0A4, 0xD0A5, 0xD0A8,
0xD0AC, 0xD0B4, 0xD0B5, 0xD0B7, 0xD0B9, 0xD0C0, 0xD0C1, 0xD0C4,
0xD0C8, 0xD0C9, 0xD0D0, 0xD0D1, 0xD0D3, 0xD0D4, 0xD0D5, 0xD0DC,
0xD0DD, 0xD0E0, 0xD0E4, 0xD0EC, 0xD0ED, 0xD0EF, 0xD0F0, 0xD0F1,
0xD0F8, 0xD10D, 0xD130, 0xD131, 0xD134, 0xD138, 0xD13A, 0xD140,
0xD141, 0xD143, 0xD144, 0xD145, 0xD14C, 0xD14D, 0xD150, 0xD154,
0xD15C, 0xD15D, 0xD15F, 0xD161, 0xD168, 0xD16C, 0xD17C, 0xD184,
0xD188, 0xD1A0, 0xD1A1, 0xD1A4, 0xD1A8, 0xD1B0, 0xD1B1, 0xD1B3,
0xD1B5, 0xD1BA, 0xD1BC, 0xD1C0, 0xD1D8, 0xD1F4, 0xD1F8, 0xD207,
0xD209, 0xD210, 0xD22C, 0xD22D, 0xD230, 0xD234, 0xD23C, 0xD23D,
0xD23F, 0xD241, 0xD248, 0xD25C, 0xD264, 0xD280, 0xD281, 0xD284,
0xD288, 0xD290, 0xD291, 0xD295, 0xD29C, 0xD2A0, 0xD2A4, 0xD2AC,
0xD2B1, 0xD2B8, 0xD2B9, 0xD2BC, 0xD2BF, 0xD2C0, 0xD2C2, 0xD2C8,
0xD2C9, 0xD2CB, 0xD2D4, 0xD2D8, 0xD2DC, 0xD2E4, 0xD2E5, 0xD2F0,
0xD2F1, 0xD2F4, 0xD2F8, 0xD300, 0xD301, 0xD303, 0xD305, 0xD30C,
0xD30D, 0xD30E, 0xD310, 0xD314, 0xD316, 0xD31C, 0xD31D, 0xD31F,
0xD320, 0xD321, 0xD325, 0xD328, 0xD329, 0xD32C, 0xD330, 0xD338,
0xD339, 0xD33B, 0xD33C, 0xD33D, 0xD344, 0xD345, 0xD37C, 0xD37D,
0xD380, 0xD384, 0xD38C, 0xD38D, 0xD38F, 0xD390, 0xD391, 0xD398,
0xD399, 0xD39C, 0xD3A0, 0xD3A8, 0xD3A9, 0xD3AB, 0xD3AD, 0xD3B4,
0xD3B8, 0xD3BC, 0xD3C4, 0xD3C5, 0xD3C8, 0xD3C9, 0xD3D0, 0xD3D8,
0xD3E1, 0xD3E3, 0xD3EC, 0xD3ED, 0xD3F0, 0xD3F4, 0xD3FC, 0xD3FD,
0xD3FF, 0xD401, 0xD408, 0xD41D, 0xD440, 0xD444, 0xD45C, 0xD460,
0xD464, 0xD46D, 0xD46F, 0xD478, 0xD479, 0xD47C, 0xD47F, 0xD480,
0xD482, 0xD488, 0xD489, 0xD48B, 0xD48D, 0xD494, 0xD4A9, 0xD4CC,
0xD4D0, 0xD4D4, 0xD4DC, 0xD4DF, 0xD4E8, 0xD4EC, 0xD4F0, 0xD4F8,
0xD4FB, 0xD4FD, 0xD504, 0xD508, 0xD50C, 0xD514, 0xD515, 0xD517,
0xD53C, 0xD53D, 0xD540, 0xD544, 0xD54C, 0xD54D, 0xD54F, 0xD551,
0xD558, 0xD559, 0xD55C, 0xD560, 0xD565, 0xD568, 0xD569, 0xD56B,
0xD56D, 0xD574, 0xD575, 0xD578, 0xD57C, 0xD584, 0xD585, 0xD587,
0xD588, 0xD589, 0xD590, 0xD5A5, 0xD5C8, 0xD5C9, 0xD5CC, 0xD5D0,
0xD5D2, 0xD5D8, 0xD5D9, 0xD5DB, 0xD5DD, 0xD5E4, 0xD5E5, 0xD5E8,
0xD5EC, 0xD5F4, 0xD5F5, 0xD5F7, 0xD5F9, 0xD600, 0xD601, 0xD604,
0xD608, 0xD610, 0xD611, 0xD613, 0xD614, 0xD615, 0xD61C, 0xD620,
0xD624, 0xD62D, 0xD638, 0xD639, 0xD63C, 0xD640, 0xD645, 0xD648,
0xD649, 0xD64B, 0xD64D, 0xD651, 0xD654, 0xD655, 0xD658, 0xD65C,
0xD667, 0xD669, 0xD670, 0xD671, 0xD674, 0xD683, 0xD685, 0xD68C,
0xD68D, 0xD690, 0xD694, 0xD69D, 0xD69F, 0xD6A1, 0xD6A8, 0xD6AC,
0xD6B0, 0xD6B9, 0xD6BB, 0xD6C4, 0xD6C5, 0xD6C8, 0xD6CC, 0xD6D1,
0xD6D4, 0xD6D7, 0xD6D9, 0xD6E0, 0xD6E4, 0xD6E8, 0xD6F0, 0xD6F5,
0xD6FC, 0xD6FD, 0xD700, 0xD704, 0xD711, 0xD718, 0xD719, 0xD71C,
0xD720, 0xD728, 0xD729, 0xD72B, 0xD72D, 0xD734, 0xD735, 0xD738,
0xD73C, 0xD744, 0xD747, 0xD749, 0xD750, 0xD751, 0xD754, 0xD756,
0xD757, 0xD758, 0xD759, 0xD760, 0xD761, 0xD763, 0xD765, 0xD769,
0xD76C, 0xD770, 0xD774, 0xD77C, 0xD77D, 0xD781, 0xD788, 0xD789,
0xD78C, 0xD790, 0xD798, 0xD799, 0xD79B, 0xD79D, 0x4F3D, 0x4F73,
0x5047, 0x50F9, 0x52A0, 0x53EF, 0x5475, 0x54E5, 0x5609, 0x5AC1,
0x5BB6, 0x6687, 0x67B6, 0x67B7, 0x67EF, 0x6B4C, 0x73C2, 0x75C2,
0x7A3C, 0x82DB, 0x8304, 0x8857, 0x8888, 0x8A36, 0x8CC8, 0x8DCF,
0x8EFB, 0x8FE6, 0x99D5, 0x523B, 0x5374, 0x5404, 0x606A, 0x6164,
0x6BBC, 0x73CF, 0x811A, 0x89BA, 0x89D2, 0x95A3, 0x4F83, 0x520A,
0x58BE, 0x5978, 0x59E6, 0x5E72, 0x5E79, 0x61C7, 0x63C0, 0x6746,
0x67EC, 0x687F, 0x6F97, 0x764E, 0x770B, 0x78F5, 0x7A08, 0x7AFF,
0x7C21, 0x809D, 0x826E, 0x8271, 0x8AEB, 0x9593, 0x4E6B, 0x559D,
0x66F7, 0x6E34, 0x78A3, 0x7AED, 0x845B, 0x8910, 0x874E, 0x97A8,
0x52D8, 0x574E, 0x582A, 0x5D4C, 0x611F, 0x61BE, 0x6221, 0x6562,
0x67D1, 0x6A44, 0x6E1B, 0x7518, 0x75B3, 0x76E3, 0x77B0, 0x7D3A,
0x90AF, 0x9451, 0x9452, 0x9F95, 0x5323, 0x5CAC, 0x7532, 0x80DB,
0x9240, 0x9598, 0x525B, 0x5808, 0x59DC, 0x5CA1, 0x5D17, 0x5EB7,
0x5F3A, 0x5F4A, 0x6177, 0x6C5F, 0x757A, 0x7586, 0x7CE0, 0x7D73,
0x7DB1, 0x7F8C, 0x8154, 0x8221, 0x8591, 0x8941, 0x8B1B, 0x92FC,
0x964D, 0x9C47, 0x4ECB, 0x4EF7, 0x500B, 0x51F1, 0x584F, 0x6137,
0x613E, 0x6168, 0x6539, 0x69EA, 0x6F11, 0x75A5, 0x7686, 0x76D6,
0x7B87, 0x82A5, 0x84CB, 0xF900, 0x93A7, 0x958B, 0x5580, 0x5BA2,
0x5751, 0xF901, 0x7CB3, 0x7FB9, 0x91B5, 0x5028, 0x53BB, 0x5C45,
0x5DE8, 0x62D2, 0x636E, 0x64DA, 0x64E7, 0x6E20, 0x70AC, 0x795B,
0x8DDD, 0x8E1E, 0xF902, 0x907D, 0x9245, 0x92F8, 0x4E7E, 0x4EF6,
0x5065, 0x5DFE, 0x5EFA, 0x6106, 0x6957, 0x8171, 0x8654, 0x8E47,
0x9375, 0x9A2B, 0x4E5E, 0x5091, 0x6770, 0x6840, 0x5109, 0x528D,
0x5292, 0x6AA2, 0x77BC, 0x9210, 0x9ED4, 0x52AB, 0x602F, 0x8FF2,
0x5048, 0x61A9, 0x63ED, 0x64CA, 0x683C, 0x6A84, 0x6FC0, 0x8188,
0x89A1, 0x9694, 0x5805, 0x727D, 0x72AC, 0x7504, 0x7D79, 0x7E6D,
0x80A9, 0x898B, 0x8B74, 0x9063, 0x9D51, 0x6289, 0x6C7A, 0x6F54,
0x7D50, 0x7F3A, 0x8A23, 0x517C, 0x614A, 0x7B9D, 0x8B19, 0x9257,
0x938C, 0x4EAC, 0x4FD3, 0x501E, 0x50BE, 0x5106, 0x52C1, 0x52CD,
0x537F, 0x5770, 0x5883, 0x5E9A, 0x5F91, 0x6176, 0x61AC, 0x64CE,
0x656C, 0x666F, 0x66BB, 0x66F4, 0x6897, 0x6D87, 0x7085, 0x70F1,
0x749F, 0x74A5, 0x74CA, 0x75D9, 0x786C, 0x78EC, 0x7ADF, 0x7AF6,
0x7D45, 0x7D93, 0x8015, 0x803F, 0x811B, 0x8396, 0x8B66, 0x8F15,
0x9015, 0x93E1, 0x9803, 0x9838, 0x9A5A, 0x9BE8, 0x4FC2, 0x5553,
0x583A, 0x5951, 0x5B63, 0x5C46, 0x60B8, 0x6212, 0x6842, 0x68B0,
0x68E8, 0x6EAA, 0x754C, 0x7678, 0x78CE, 0x7A3D, 0x7CFB, 0x7E6B,
0x7E7C, 0x8A08, 0x8AA1, 0x8C3F, 0x968E, 0x9DC4, 0x53E4, 0x53E9,
0x544A, 0x5471, 0x56FA, 0x59D1, 0x5B64, 0x5C3B, 0x5EAB, 0x62F7,
0x6537, 0x6545, 0x6572, 0x66A0, 0x67AF, 0x69C1, 0x6CBD, 0x75FC,
0x7690, 0x777E, 0x7A3F, 0x7F94, 0x8003, 0x80A1, 0x818F, 0x82E6,
0x82FD, 0x83F0, 0x85C1, 0x8831, 0x88B4, 0x8AA5, 0xF903, 0x8F9C,
0x932E, 0x96C7, 0x9867, 0x9AD8, 0x9F13, 0x54ED, 0x659B, 0x66F2,
0x688F, 0x7A40, 0x8C37, 0x9D60, 0x56F0, 0x5764, 0x5D11, 0x6606,
0x68B1, 0x68CD, 0x6EFE, 0x7428, 0x889E, 0x9BE4, 0x6C68, 0xF904,
0x9AA8, 0x4F9B, 0x516C, 0x5171, 0x529F, 0x5B54, 0x5DE5, 0x6050,
0x606D, 0x62F1, 0x63A7, 0x653B, 0x73D9, 0x7A7A, 0x86A3, 0x8CA2,
0x978F, 0x4E32, 0x5BE1, 0x6208, 0x679C, 0x74DC, 0x79D1, 0x83D3,
0x8A87, 0x8AB2, 0x8DE8, 0x904E, 0x934B, 0x9846, 0x5ED3, 0x69E8,
0x85FF, 0x90ED, 0xF905, 0x51A0, 0x5B98, 0x5BEC, 0x6163, 0x68FA,
0x6B3E, 0x704C, 0x742F, 0x74D8, 0x7BA1, 0x7F50, 0x83C5, 0x89C0,
0x8CAB, 0x95DC, 0x9928, 0x522E, 0x605D, 0x62EC, 0x9002, 0x4F8A,
0x5149, 0x5321, 0x58D9, 0x5EE3, 0x66E0, 0x6D38, 0x709A, 0x72C2,
0x73D6, 0x7B50, 0x80F1, 0x945B, 0x5366, 0x639B, 0x7F6B, 0x4E56,
0x5080, 0x584A, 0x58DE, 0x602A, 0x6127, 0x62D0, 0x69D0, 0x9B41,
0x5B8F, 0x7D18, 0x80B1, 0x8F5F, 0x4EA4, 0x50D1, 0x54AC, 0x55AC,
0x5B0C, 0x5DA0, 0x5DE7, 0x652A, 0x654E, 0x6821, 0x6A4B, 0x72E1,
0x768E, 0x77EF, 0x7D5E, 0x7FF9, 0x81A0, 0x854E, 0x86DF, 0x8F03,
0x8F4E, 0x90CA, 0x9903, 0x9A55, 0x9BAB, 0x4E18, 0x4E45, 0x4E5D,
0x4EC7, 0x4FF1, 0x5177, 0x52FE, 0x5340, 0x53E3, 0x53E5, 0x548E,
0x5614, 0x5775, 0x57A2, 0x5BC7, 0x5D87, 0x5ED0, 0x61FC, 0x62D8,
0x6551, 0x67B8, 0x67E9, 0x69CB, 0x6B50, 0x6BC6, 0x6BEC, 0x6C42,
0x6E9D, 0x7078, 0x72D7, 0x7396, 0x7403, 0x77BF, 0x77E9, 0x7A76,
0x7D7F, 0x8009, 0x81FC, 0x8205, 0x820A, 0x82DF, 0x8862, 0x8B33,
0x8CFC, 0x8EC0, 0x9011, 0x90B1, 0x9264, 0x92B6, 0x99D2, 0x9A45,
0x9CE9, 0x9DD7, 0x9F9C, 0x570B, 0x5C40, 0x83CA, 0x97A0, 0x97AB,
0x9EB4, 0x541B, 0x7A98, 0x7FA4, 0x88D9, 0x8ECD, 0x90E1, 0x5800,
0x5C48, 0x6398, 0x7A9F, 0x5BAE, 0x5F13, 0x7A79, 0x7AAE, 0x828E,
0x8EAC, 0x5026, 0x5238, 0x52F8, 0x5377, 0x5708, 0x62F3, 0x6372,
0x6B0A, 0x6DC3, 0x7737, 0x53A5, 0x7357, 0x8568, 0x8E76, 0x95D5,
0x673A, 0x6AC3, 0x6F70, 0x8A6D, 0x8ECC, 0x994B, 0xF906, 0x6677,
0x6B78, 0x8CB4, 0x9B3C, 0xF907, 0x53EB, 0x572D, 0x594E, 0x63C6,
0x69FB, 0x73EA, 0x7845, 0x7ABA, 0x7AC5, 0x7CFE, 0x8475, 0x898F,
0x8D73, 0x9035, 0x95A8, 0x52FB, 0x5747, 0x7547, 0x7B60, 0x83CC,
0x921E, 0xF908, 0x6A58, 0x514B, 0x524B, 0x5287, 0x621F, 0x68D8,
0x6975, 0x9699, 0x50C5, 0x52A4, 0x52E4, 0x61C3, 0x65A4, 0x6839,
0x69FF, 0x747E, 0x7B4B, 0x82B9, 0x83EB, 0x89B2, 0x8B39, 0x8FD1,
0x9949, 0xF909, 0x4ECA, 0x5997, 0x64D2, 0x6611, 0x6A8E, 0x7434,
0x7981, 0x79BD, 0x82A9, 0x887E, 0x887F, 0x895F, 0xF90A, 0x9326,
0x4F0B, 0x53CA, 0x6025, 0x6271, 0x6C72, 0x7D1A, 0x7D66, 0x4E98,
0x5162, 0x77DC, 0x80AF, 0x4F01, 0x4F0E, 0x5176, 0x5180, 0x55DC,
0x5668, 0x573B, 0x57FA, 0x57FC, 0x5914, 0x5947, 0x5993, 0x5BC4,
0x5C90, 0x5D0E, 0x5DF1, 0x5E7E, 0x5FCC, 0x6280, 0x65D7, 0x65E3,
0x671E, 0x671F, 0x675E, 0x68CB, 0x68C4, 0x6A5F, 0x6B3A, 0x6C23,
0x6C7D, 0x6C82, 0x6DC7, 0x7398, 0x7426, 0x742A, 0x7482, 0x74A3,
0x7578, 0x757F, 0x7881, 0x78EF, 0x7941, 0x7947, 0x7948, 0x797A,
0x7B95, 0x7D00, 0x7DBA, 0x7F88, 0x8006, 0x802D, 0x808C, 0x8A18,
0x8B4F, 0x8C48, 0x8D77, 0x9321, 0x9324, 0x98E2, 0x9951, 0x9A0E,
0x9A0F, 0x9A65, 0x9E92, 0x7DCA, 0x4F76, 0x5409, 0x62EE, 0x6854,
0x91D1, 0x55AB, 0x513A, 0xF90B, 0xF90C, 0x5A1C, 0x61E6, 0xF90D,
0x62CF, 0x62FF, 0xF90E, 0xF90F, 0xF910, 0xF911, 0xF912, 0xF913,
0x90A3, 0xF914, 0xF915, 0xF916, 0xF917, 0xF918, 0x8AFE, 0xF919,
0xF91A, 0xF91B, 0xF91C, 0x6696, 0xF91D, 0x7156, 0xF91E, 0xF91F,
0x96E3, 0xF920, 0x634F, 0x637A, 0x5357, 0xF921, 0x678F, 0x6960,
0x6E73, 0xF922, 0x7537, 0xF923, 0xF924, 0xF925, 0x7D0D, 0xF926,
0xF927, 0x8872, 0x56CA, 0x5A18, 0xF928, 0xF929, 0xF92A, 0xF92B,
0xF92C, 0x4E43, 0xF92D, 0x5167, 0x5948, 0x67F0, 0x8010, 0xF92E,
0x5973, 0x5E74, 0x649A, 0x79CA, 0x5FF5, 0x606C, 0x62C8, 0x637B,
0x5BE7, 0x5BD7, 0x52AA, 0xF92F, 0x5974, 0x5F29, 0x6012, 0xF930,
0xF931, 0xF932, 0x7459, 0xF933, 0xF934, 0xF935, 0xF936, 0xF937,
0xF938, 0x99D1, 0xF939, 0xF93A, 0xF93B, 0xF93C, 0xF93D, 0xF93E,
0xF93F, 0xF940, 0xF941, 0xF942, 0xF943, 0x6FC3, 0xF944, 0xF945,
0x81BF, 0x8FB2, 0x60F1, 0xF946, 0xF947, 0x8166, 0xF948, 0xF949,
0x5C3F, 0xF94A, 0xF94B, 0xF94C, 0xF94D, 0xF94E, 0xF94F, 0xF950,
0xF951, 0x5AE9, 0x8A25, 0x677B, 0x7D10, 0xF952, 0xF953, 0xF954,
0xF955, 0xF956, 0xF957, 0x80FD, 0xF958, 0xF959, 0x5C3C, 0x6CE5,
0x533F, 0x6EBA, 0x591A, 0x8336, 0x4E39, 0x4EB6, 0x4F46, 0x55AE,
0x5718, 0x58C7, 0x5F56, 0x65B7, 0x65E6, 0x6A80, 0x6BB5, 0x6E4D,
0x77ED, 0x7AEF, 0x7C1E, 0x7DDE, 0x86CB, 0x8892, 0x9132, 0x935B,
0x64BB, 0x6FBE, 0x737A, 0x75B8, 0x9054, 0x5556, 0x574D, 0x61BA,
0x64D4, 0x66C7, 0x6DE1, 0x6E5B, 0x6F6D, 0x6FB9, 0x75F0, 0x8043,
0x81BD, 0x8541, 0x8983, 0x8AC7, 0x8B5A, 0x931F, 0x6C93, 0x7553,
0x7B54, 0x8E0F, 0x905D, 0x5510, 0x5802, 0x5858, 0x5E62, 0x6207,
0x649E, 0x68E0, 0x7576, 0x7CD6, 0x87B3, 0x9EE8, 0x4EE3, 0x5788,
0x576E, 0x5927, 0x5C0D, 0x5CB1, 0x5E36, 0x5F85, 0x6234, 0x64E1,
0x73B3, 0x81FA, 0x888B, 0x8CB8, 0x968A, 0x9EDB, 0x5B85, 0x5FB7,
0x60B3, 0x5012, 0x5200, 0x5230, 0x5716, 0x5835, 0x5857, 0x5C0E,
0x5C60, 0x5CF6, 0x5D8B, 0x5EA6, 0x5F92, 0x60BC, 0x6311, 0x6389,
0x6417, 0x6843, 0x68F9, 0x6AC2, 0x6DD8, 0x6E21, 0x6ED4, 0x6FE4,
0x71FE, 0x76DC, 0x7779, 0x79B1, 0x7A3B, 0x8404, 0x89A9, 0x8CED,
0x8DF3, 0x8E48, 0x9003, 0x9014, 0x9053, 0x90FD, 0x934D, 0x9676,
0x97DC, 0x6BD2, 0x7006, 0x7258, 0x72A2, 0x7368, 0x7763, 0x79BF,
0x7BE4, 0x7E9B, 0x8B80, 0x58A9, 0x60C7, 0x6566, 0x65FD, 0x66BE,
0x6C8C, 0x711E, 0x71C9, 0x8C5A, 0x9813, 0x4E6D, 0x7A81, 0x4EDD,
0x51AC, 0x51CD, 0x52D5, 0x540C, 0x61A7, 0x6771, 0x6850, 0x68DF,
0x6D1E, 0x6F7C, 0x75BC, 0x77B3, 0x7AE5, 0x80F4, 0x8463, 0x9285,
0x515C, 0x6597, 0x675C, 0x6793, 0x75D8, 0x7AC7, 0x8373, 0xF95A,
0x8C46, 0x9017, 0x982D, 0x5C6F, 0x81C0, 0x829A, 0x9041, 0x906F,
0x920D, 0x5F97, 0x5D9D, 0x6A59, 0x71C8, 0x767B, 0x7B49, 0x85E4,
0x8B04, 0x9127, 0x9A30, 0x5587, 0x61F6, 0xF95B, 0x7669, 0x7F85,
0x863F, 0x87BA, 0x88F8, 0x908F, 0xF95C, 0x6D1B, 0x70D9, 0x73DE,
0x7D61, 0x843D, 0xF95D, 0x916A, 0x99F1, 0xF95E, 0x4E82, 0x5375,
0x6B04, 0x6B12, 0x703E, 0x721B, 0x862D, 0x9E1E, 0x524C, 0x8FA3,
0x5D50, 0x64E5, 0x652C, 0x6B16, 0x6FEB, 0x7C43, 0x7E9C, 0x85CD,
0x8964, 0x89BD, 0x62C9, 0x81D8, 0x881F, 0x5ECA, 0x6717, 0x6D6A,
0x72FC, 0x7405, 0x746F, 0x8782, 0x90DE, 0x4F86, 0x5D0D, 0x5FA0,
0x840A, 0x51B7, 0x63A0, 0x7565, 0x4EAE, 0x5006, 0x5169, 0x51C9,
0x6881, 0x6A11, 0x7CAE, 0x7CB1, 0x7CE7, 0x826F, 0x8AD2, 0x8F1B,
0x91CF, 0x4FB6, 0x5137, 0x52F5, 0x5442, 0x5EEC, 0x616E, 0x623E,
0x65C5, 0x6ADA, 0x6FFE, 0x792A, 0x85DC, 0x8823, 0x95AD, 0x9A62,
0x9A6A, 0x9E97, 0x9ECE, 0x529B, 0x66C6, 0x6B77, 0x701D, 0x792B,
0x8F62, 0x9742, 0x6190, 0x6200, 0x6523, 0x6F23, 0x7149, 0x7489,
0x7DF4, 0x806F, 0x84EE, 0x8F26, 0x9023, 0x934A, 0x51BD, 0x5217,
0x52A3, 0x6D0C, 0x70C8, 0x88C2, 0x5EC9, 0x6582, 0x6BAE, 0x6FC2,
0x7C3E, 0x7375, 0x4EE4, 0x4F36, 0x56F9, 0xF95F, 0x5CBA, 0x5DBA,
0x601C, 0x73B2, 0x7B2D, 0x7F9A, 0x7FCE, 0x8046, 0x901E, 0x9234,
0x96F6, 0x9748, 0x9818, 0x9F61, 0x4F8B, 0x6FA7, 0x79AE, 0x91B4,
0x96B7, 0x52DE, 0xF960, 0x6488, 0x64C4, 0x6AD3, 0x6F5E, 0x7018,
0x7210, 0x76E7, 0x8001, 0x8606, 0x865C, 0x8DEF, 0x8F05, 0x9732,
0x9B6F, 0x9DFA, 0x9E75, 0x788C, 0x797F, 0x7DA0, 0x83C9, 0x9304,
0x9E7F, 0x9E93, 0x8AD6, 0x58DF, 0x5F04, 0x6727, 0x7027, 0x74CF,
0x7C60, 0x807E, 0x5121, 0x7028, 0x7262, 0x78CA, 0x8CC2, 0x8CDA,
0x8CF4, 0x96F7, 0x4E86, 0x50DA, 0x5BEE, 0x5ED6, 0x6599, 0x71CE,
0x7642, 0x77AD, 0x804A, 0x84FC, 0x907C, 0x9B27, 0x9F8D, 0x58D8,
0x5A41, 0x5C62, 0x6A13, 0x6DDA, 0x6F0F, 0x763B, 0x7D2F, 0x7E37,
0x851E, 0x8938, 0x93E4, 0x964B, 0x5289, 0x65D2, 0x67F3, 0x69B4,
0x6D41, 0x6E9C, 0x700F, 0x7409, 0x7460, 0x7559, 0x7624, 0x786B,
0x8B2C, 0x985E, 0x516D, 0x622E, 0x9678, 0x4F96, 0x502B, 0x5D19,
0x6DEA, 0x7DB8, 0x8F2A, 0x5F8B, 0x6144, 0x6817, 0xF961, 0x9686,
0x52D2, 0x808B, 0x51DC, 0x51CC, 0x695E, 0x7A1C, 0x7DBE, 0x83F1,
0x9675, 0x4FDA, 0x5229, 0x5398, 0x540F, 0x550E, 0x5C65, 0x60A7,
0x674E, 0x68A8, 0x6D6C, 0x7281, 0x72F8, 0x7406, 0x7483, 0xF962,
0x75E2, 0x7C6C, 0x7F79, 0x7FB8, 0x8389, 0x88CF, 0x88E1, 0x91CC,
0x91D0, 0x96E2, 0x9BC9, 0x541D, 0x6F7E, 0x71D0, 0x7498, 0x85FA,
0x8EAA, 0x96A3, 0x9C57, 0x9E9F, 0x6797, 0x6DCB, 0x7433, 0x81E8,
0x9716, 0x782C, 0x7ACB, 0x7B20, 0x7C92, 0x6469, 0x746A, 0x75F2,
0x78BC, 0x78E8, 0x99AC, 0x9B54, 0x9EBB, 0x5BDE, 0x5E55, 0x6F20,
0x819C, 0x83AB, 0x9088, 0x4E07, 0x534D, 0x5A29, 0x5DD2, 0x5F4E,
0x6162, 0x633D, 0x6669, 0x66FC, 0x6EFF, 0x6F2B, 0x7063, 0x779E,
0x842C, 0x8513, 0x883B, 0x8F13, 0x9945, 0x9C3B, 0x551C, 0x62B9,
0x672B, 0x6CAB, 0x8309, 0x896A, 0x977A, 0x4EA1, 0x5984, 0x5FD8,
0x5FD9, 0x671B, 0x7DB2, 0x7F54, 0x8292, 0x832B, 0x83BD, 0x8F1E,
0x9099, 0x57CB, 0x59B9, 0x5A92, 0x5BD0, 0x6627, 0x679A, 0x6885,
0x6BCF, 0x7164, 0x7F75, 0x8CB7, 0x8CE3, 0x9081, 0x9B45, 0x8108,
0x8C8A, 0x964C, 0x9A40, 0x9EA5, 0x5B5F, 0x6C13, 0x731B, 0x76F2,
0x76DF, 0x840C, 0x51AA, 0x8993, 0x514D, 0x5195, 0x52C9, 0x68C9,
0x6C94, 0x7704, 0x7720, 0x7DBF, 0x7DEC, 0x9762, 0x9EB5, 0x6EC5,
0x8511, 0x51A5, 0x540D, 0x547D, 0x660E, 0x669D, 0x6927, 0x6E9F,
0x76BF, 0x7791, 0x8317, 0x84C2, 0x879F, 0x9169, 0x9298, 0x9CF4,
0x8882, 0x4FAE, 0x5192, 0x52DF, 0x59C6, 0x5E3D, 0x6155, 0x6478,
0x6479, 0x66AE, 0x67D0, 0x6A21, 0x6BCD, 0x6BDB, 0x725F, 0x7261,
0x7441, 0x7738, 0x77DB, 0x8017, 0x82BC, 0x8305, 0x8B00, 0x8B28,
0x8C8C, 0x6728, 0x6C90, 0x7267, 0x76EE, 0x7766, 0x7A46, 0x9DA9,
0x6B7F, 0x6C92, 0x5922, 0x6726, 0x8499, 0x536F, 0x5893, 0x5999,
0x5EDF, 0x63CF, 0x6634, 0x6773, 0x6E3A, 0x732B, 0x7AD7, 0x82D7,
0x9328, 0x52D9, 0x5DEB, 0x61AE, 0x61CB, 0x620A, 0x62C7, 0x64AB,
0x65E0, 0x6959, 0x6B66, 0x6BCB, 0x7121, 0x73F7, 0x755D, 0x7E46,
0x821E, 0x8302, 0x856A, 0x8AA3, 0x8CBF, 0x9727, 0x9D61, 0x58A8,
0x9ED8, 0x5011, 0x520E, 0x543B, 0x554F, 0x6587, 0x6C76, 0x7D0A,
0x7D0B, 0x805E, 0x868A, 0x9580, 0x96EF, 0x52FF, 0x6C95, 0x7269,
0x5473, 0x5A9A, 0x5C3E, 0x5D4B, 0x5F4C, 0x5FAE, 0x672A, 0x68B6,
0x6963, 0x6E3C, 0x6E44, 0x7709, 0x7C73, 0x7F8E, 0x8587, 0x8B0E,
0x8FF7, 0x9761, 0x9EF4, 0x5CB7, 0x60B6, 0x610D, 0x61AB, 0x654F,
0x65FB, 0x65FC, 0x6C11, 0x6CEF, 0x739F, 0x73C9, 0x7DE1, 0x9594,
0x5BC6, 0x871C, 0x8B10, 0x525D, 0x535A, 0x62CD, 0x640F, 0x64B2,
0x6734, 0x6A38, 0x6CCA, 0x73C0, 0x749E, 0x7B94, 0x7C95, 0x7E1B,
0x818A, 0x8236, 0x8584, 0x8FEB, 0x96F9, 0x99C1, 0x4F34, 0x534A,
0x53CD, 0x53DB, 0x62CC, 0x642C, 0x6500, 0x6591, 0x69C3, 0x6CEE,
0x6F58, 0x73ED, 0x7554, 0x7622, 0x76E4, 0x76FC, 0x78D0, 0x78FB,
0x792C, 0x7D46, 0x822C, 0x87E0, 0x8FD4, 0x9812, 0x98EF, 0x52C3,
0x62D4, 0x64A5, 0x6E24, 0x6F51, 0x767C, 0x8DCB, 0x91B1, 0x9262,
0x9AEE, 0x9B43, 0x5023, 0x508D, 0x574A, 0x59A8, 0x5C28, 0x5E47,
0x5F77, 0x623F, 0x653E, 0x65B9, 0x65C1, 0x6609, 0x678B, 0x699C,
0x6EC2, 0x78C5, 0x7D21, 0x80AA, 0x8180, 0x822B, 0x82B3, 0x84A1,
0x868C, 0x8A2A, 0x8B17, 0x90A6, 0x9632, 0x9F90, 0x500D, 0x4FF3,
0xF963, 0x57F9, 0x5F98, 0x62DC, 0x6392, 0x676F, 0x6E43, 0x7119,
0x76C3, 0x80CC, 0x80DA, 0x88F4, 0x88F5, 0x8919, 0x8CE0, 0x8F29,
0x914D, 0x966A, 0x4F2F, 0x4F70, 0x5E1B, 0x67CF, 0x6822, 0x767D,
0x767E, 0x9B44, 0x5E61, 0x6A0A, 0x7169, 0x71D4, 0x756A, 0xF964,
0x7E41, 0x8543, 0x85E9, 0x98DC, 0x4F10, 0x7B4F, 0x7F70, 0x95A5,
0x51E1, 0x5E06, 0x68B5, 0x6C3E, 0x6C4E, 0x6CDB, 0x72AF, 0x7BC4,
0x8303, 0x6CD5, 0x743A, 0x50FB, 0x5288, 0x58C1, 0x64D8, 0x6A97,
0x74A7, 0x7656, 0x78A7, 0x8617, 0x95E2, 0x9739, 0xF965, 0x535E,
0x5F01, 0x8B8A, 0x8FA8, 0x8FAF, 0x908A, 0x5225, 0x77A5, 0x9C49,
0x9F08, 0x4E19, 0x5002, 0x5175, 0x5C5B, 0x5E77, 0x661E, 0x663A,
0x67C4, 0x68C5, 0x70B3, 0x7501, 0x75C5, 0x79C9, 0x7ADD, 0x8F27,
0x9920, 0x9A08, 0x4FDD, 0x5821, 0x5831, 0x5BF6, 0x666E, 0x6B65,
0x6D11, 0x6E7A, 0x6F7D, 0x73E4, 0x752B, 0x83E9, 0x88DC, 0x8913,
0x8B5C, 0x8F14, 0x4F0F, 0x50D5, 0x5310, 0x535C, 0x5B93, 0x5FA9,
0x670D, 0x798F, 0x8179, 0x832F, 0x8514, 0x8907, 0x8986, 0x8F39,
0x8F3B, 0x99A5, 0x9C12, 0x672C, 0x4E76, 0x4FF8, 0x5949, 0x5C01,
0x5CEF, 0x5CF0, 0x6367, 0x68D2, 0x70FD, 0x71A2, 0x742B, 0x7E2B,
0x84EC, 0x8702, 0x9022, 0x92D2, 0x9CF3, 0x4E0D, 0x4ED8, 0x4FEF,
0x5085, 0x5256, 0x526F, 0x5426, 0x5490, 0x57E0, 0x592B, 0x5A66,
0x5B5A, 0x5B75, 0x5BCC, 0x5E9C, 0xF966, 0x6276, 0x6577, 0x65A7,
0x6D6E, 0x6EA5, 0x7236, 0x7B26, 0x7C3F, 0x7F36, 0x8150, 0x8151,
0x819A, 0x8240, 0x8299, 0x83A9, 0x8A03, 0x8CA0, 0x8CE6, 0x8CFB,
0x8D74, 0x8DBA, 0x90E8, 0x91DC, 0x961C, 0x9644, 0x99D9, 0x9CE7,
0x5317, 0x5206, 0x5429, 0x5674, 0x58B3, 0x5954, 0x596E, 0x5FFF,
0x61A4, 0x626E, 0x6610, 0x6C7E, 0x711A, 0x76C6, 0x7C89, 0x7CDE,
0x7D1B, 0x82AC, 0x8CC1, 0x96F0, 0xF967, 0x4F5B, 0x5F17, 0x5F7F,
0x62C2, 0x5D29, 0x670B, 0x68DA, 0x787C, 0x7E43, 0x9D6C, 0x4E15,
0x5099, 0x5315, 0x532A, 0x5351, 0x5983, 0x5A62, 0x5E87, 0x60B2,
0x618A, 0x6249, 0x6279, 0x6590, 0x6787, 0x69A7, 0x6BD4, 0x6BD6,
0x6BD7, 0x6BD8, 0x6CB8, 0xF968, 0x7435, 0x75FA, 0x7812, 0x7891,
0x79D5, 0x79D8, 0x7C83, 0x7DCB, 0x7FE1, 0x80A5, 0x813E, 0x81C2,
0x83F2, 0x871A, 0x88E8, 0x8AB9, 0x8B6C, 0x8CBB, 0x9119, 0x975E,
0x98DB, 0x9F3B, 0x56AC, 0x5B2A, 0x5F6C, 0x658C, 0x6AB3, 0x6BAF,
0x6D5C, 0x6FF1, 0x7015, 0x725D, 0x73AD, 0x8CA7, 0x8CD3, 0x983B,
0x6191, 0x6C37, 0x8058, 0x9A01, 0x4E4D, 0x4E8B, 0x4E9B, 0x4ED5,
0x4F3A, 0x4F3C, 0x4F7F, 0x4FDF, 0x50FF, 0x53F2, 0x53F8, 0x5506,
0x55E3, 0x56DB, 0x58EB, 0x5962, 0x5A11, 0x5BEB, 0x5BFA, 0x5C04,
0x5DF3, 0x5E2B, 0x5F99, 0x601D, 0x6368, 0x659C, 0x65AF, 0x67F6,
0x67FB, 0x68AD, 0x6B7B, 0x6C99, 0x6CD7, 0x6E23, 0x7009, 0x7345,
0x7802, 0x793E, 0x7940, 0x7960, 0x79C1, 0x7BE9, 0x7D17, 0x7D72,
0x8086, 0x820D, 0x838E, 0x84D1, 0x86C7, 0x88DF, 0x8A50, 0x8A5E,
0x8B1D, 0x8CDC, 0x8D66, 0x8FAD, 0x90AA, 0x98FC, 0x99DF, 0x9E9D,
0x524A, 0xF969, 0x6714, 0xF96A, 0x5098, 0x522A, 0x5C71, 0x6563,
0x6C55, 0x73CA, 0x7523, 0x759D, 0x7B97, 0x849C, 0x9178, 0x9730,
0x4E77, 0x6492, 0x6BBA, 0x715E, 0x85A9, 0x4E09, 0xF96B, 0x6749,
0x68EE, 0x6E17, 0x829F, 0x8518, 0x886B, 0x63F7, 0x6F81, 0x9212,
0x98AF, 0x4E0A, 0x50B7, 0x50CF, 0x511F, 0x5546, 0x55AA, 0x5617,
0x5B40, 0x5C19, 0x5CE0, 0x5E38, 0x5E8A, 0x5EA0, 0x5EC2, 0x60F3,
0x6851, 0x6A61, 0x6E58, 0x723D, 0x7240, 0x72C0, 0x76F8, 0x7965,
0x7BB1, 0x7FD4, 0x88F3, 0x89F4, 0x8A73, 0x8C61, 0x8CDE, 0x971C,
0x585E, 0x74BD, 0x8CFD, 0x55C7, 0xF96C, 0x7A61, 0x7D22, 0x8272,
0x7272, 0x751F, 0x7525, 0xF96D, 0x7B19, 0x5885, 0x58FB, 0x5DBC,
0x5E8F, 0x5EB6, 0x5F90, 0x6055, 0x6292, 0x637F, 0x654D, 0x6691,
0x66D9, 0x66F8, 0x6816, 0x68F2, 0x7280, 0x745E, 0x7B6E, 0x7D6E,
0x7DD6, 0x7F72, 0x80E5, 0x8212, 0x85AF, 0x897F, 0x8A93, 0x901D,
0x92E4, 0x9ECD, 0x9F20, 0x5915, 0x596D, 0x5E2D, 0x60DC, 0x6614,
0x6673, 0x6790, 0x6C50, 0x6DC5, 0x6F5F, 0x77F3, 0x78A9, 0x84C6,
0x91CB, 0x932B, 0x4ED9, 0x50CA, 0x5148, 0x5584, 0x5B0B, 0x5BA3,
0x6247, 0x657E, 0x65CB, 0x6E32, 0x717D, 0x7401, 0x7444, 0x7487,
0x74BF, 0x766C, 0x79AA, 0x7DDA, 0x7E55, 0x7FA8, 0x817A, 0x81B3,
0x8239, 0x861A, 0x87EC, 0x8A75, 0x8DE3, 0x9078, 0x9291, 0x9425,
0x994D, 0x9BAE, 0x5368, 0x5C51, 0x6954, 0x6CC4, 0x6D29, 0x6E2B,
0x820C, 0x859B, 0x893B, 0x8A2D, 0x8AAA, 0x96EA, 0x9F67, 0x5261,
0x66B9, 0x6BB2, 0x7E96, 0x87FE, 0x8D0D, 0x9583, 0x965D, 0x651D,
0x6D89, 0x71EE, 0xF96E, 0x57CE, 0x59D3, 0x5BAC, 0x6027, 0x60FA,
0x6210, 0x661F, 0x665F, 0x7329, 0x73F9, 0x76DB, 0x7701, 0x7B6C,
0x8056, 0x8072, 0x8165, 0x8AA0, 0x9192, 0x4E16, 0x52E2, 0x6B72,
0x6D17, 0x7A05, 0x7B39, 0x7D30, 0xF96F, 0x8CB0, 0x53EC, 0x562F,
0x5851, 0x5BB5, 0x5C0F, 0x5C11, 0x5DE2, 0x6240, 0x6383, 0x6414,
0x662D, 0x68B3, 0x6CBC, 0x6D88, 0x6EAF, 0x701F, 0x70A4, 0x71D2,
0x7526, 0x758F, 0x758E, 0x7619, 0x7B11, 0x7BE0, 0x7C2B, 0x7D20,
0x7D39, 0x852C, 0x856D, 0x8607, 0x8A34, 0x900D, 0x9061, 0x90B5,
0x92B7, 0x97F6, 0x9A37, 0x4FD7, 0x5C6C, 0x675F, 0x6D91, 0x7C9F,
0x7E8C, 0x8B16, 0x8D16, 0x901F, 0x5B6B, 0x5DFD, 0x640D, 0x84C0,
0x905C, 0x98E1, 0x7387, 0x5B8B, 0x609A, 0x677E, 0x6DDE, 0x8A1F,
0x8AA6, 0x9001, 0x980C, 0x5237, 0xF970, 0x7051, 0x788E, 0x9396,
0x8870, 0x91D7, 0x4FEE, 0x53D7, 0x55FD, 0x56DA, 0x5782, 0x58FD,
0x5AC2, 0x5B88, 0x5CAB, 0x5CC0, 0x5E25, 0x6101, 0x620D, 0x624B,
0x6388, 0x641C, 0x6536, 0x6578, 0x6A39, 0x6B8A, 0x6C34, 0x6D19,
0x6F31, 0x71E7, 0x72E9, 0x7378, 0x7407, 0x74B2, 0x7626, 0x7761,
0x79C0, 0x7A57, 0x7AEA, 0x7CB9, 0x7D8F, 0x7DAC, 0x7E61, 0x7F9E,
0x8129, 0x8331, 0x8490, 0x84DA, 0x85EA, 0x8896, 0x8AB0, 0x8B90,
0x8F38, 0x9042, 0x9083, 0x916C, 0x9296, 0x92B9, 0x968B, 0x96A7,
0x96A8, 0x96D6, 0x9700, 0x9808, 0x9996, 0x9AD3, 0x9B1A, 0x53D4,
0x587E, 0x5919, 0x5B70, 0x5BBF, 0x6DD1, 0x6F5A, 0x719F, 0x7421,
0x74B9, 0x8085, 0x83FD, 0x5DE1, 0x5F87, 0x5FAA, 0x6042, 0x65EC,
0x6812, 0x696F, 0x6A53, 0x6B89, 0x6D35, 0x6DF3, 0x73E3, 0x76FE,
0x77AC, 0x7B4D, 0x7D14, 0x8123, 0x821C, 0x8340, 0x84F4, 0x8563,
0x8A62, 0x8AC4, 0x9187, 0x931E, 0x9806, 0x99B4, 0x620C, 0x8853,
0x8FF0, 0x9265, 0x5D07, 0x5D27, 0x5D69, 0x745F, 0x819D, 0x8768,
0x6FD5, 0x62FE, 0x7FD2, 0x8936, 0x8972, 0x4E1E, 0x4E58, 0x50E7,
0x52DD, 0x5347, 0x627F, 0x6607, 0x7E69, 0x8805, 0x965E, 0x4F8D,
0x5319, 0x5636, 0x59CB, 0x5AA4, 0x5C38, 0x5C4E, 0x5C4D, 0x5E02,
0x5F11, 0x6043, 0x65BD, 0x662F, 0x6642, 0x67BE, 0x67F4, 0x731C,
0x77E2, 0x793A, 0x7FC5, 0x8494, 0x84CD, 0x8996, 0x8A66, 0x8A69,
0x8AE1, 0x8C55, 0x8C7A, 0x57F4, 0x5BD4, 0x5F0F, 0x606F, 0x62ED,
0x690D, 0x6B96, 0x6E5C, 0x7184, 0x7BD2, 0x8755, 0x8B58, 0x8EFE,
0x98DF, 0x98FE, 0x4F38, 0x4F81, 0x4FE1, 0x547B, 0x5A20, 0x5BB8,
0x613C, 0x65B0, 0x6668, 0x71FC, 0x7533, 0x795E, 0x7D33, 0x814E,
0x81E3, 0x8398, 0x85AA, 0x85CE, 0x8703, 0x8A0A, 0x8EAB, 0x8F9B,
0xF971, 0x8FC5, 0x5931, 0x5BA4, 0x5BE6, 0x6089, 0x5BE9, 0x5C0B,
0x5FC3, 0x6C81, 0xF972, 0x6DF1, 0x700B, 0x751A, 0x82AF, 0x8AF6,
0x4EC0, 0x5341, 0xF973, 0x96D9, 0x6C0F, 0x4E9E, 0x4FC4, 0x5152,
0x555E, 0x5A25, 0x5CE8, 0x6211, 0x7259, 0x82BD, 0x83AA, 0x86FE,
0x8859, 0x8A1D, 0x963F, 0x96C5, 0x9913, 0x9D09, 0x9D5D, 0x580A,
0x5CB3, 0x5DBD, 0x5E44, 0x60E1, 0x6115, 0x63E1, 0x6A02, 0x6E25,
0x9102, 0x9354, 0x984E, 0x9C10, 0x9F77, 0x5B89, 0x5CB8, 0x6309,
0x664F, 0x6848, 0x773C, 0x96C1, 0x978D, 0x9854, 0x9B9F, 0x65A1,
0x8B01, 0x8ECB, 0x95BC, 0x5535, 0x5CA9, 0x5DD6, 0x5EB5, 0x6697,
0x764C, 0x83F4, 0x95C7, 0x58D3, 0x62BC, 0x72CE, 0x9D28, 0x4EF0,
0x592E, 0x600F, 0x663B, 0x6B83, 0x79E7, 0x9D26, 0x5393, 0x54C0,
0x57C3, 0x5D16, 0x611B, 0x66D6, 0x6DAF, 0x788D, 0x827E, 0x9698,
0x9744, 0x5384, 0x627C, 0x6396, 0x6DB2, 0x7E0A, 0x814B, 0x984D,
0x6AFB, 0x7F4C, 0x9DAF, 0x9E1A, 0x4E5F, 0x503B, 0x51B6, 0x591C,
0x60F9, 0x63F6, 0x6930, 0x723A, 0x8036, 0xF974, 0x91CE, 0x5F31,
0xF975, 0xF976, 0x7D04, 0x82E5, 0x846F, 0x84BB, 0x85E5, 0x8E8D,
0xF977, 0x4F6F, 0xF978, 0xF979, 0x58E4, 0x5B43, 0x6059, 0x63DA,
0x6518, 0x656D, 0x6698, 0xF97A, 0x694A, 0x6A23, 0x6D0B, 0x7001,
0x716C, 0x75D2, 0x760D, 0x79B3, 0x7A70, 0xF97B, 0x7F8A, 0xF97C,
0x8944, 0xF97D, 0x8B93, 0x91C0, 0x967D, 0xF97E, 0x990A, 0x5704,
0x5FA1, 0x65BC, 0x6F01, 0x7600, 0x79A6, 0x8A9E, 0x99AD, 0x9B5A,
0x9F6C, 0x5104, 0x61B6, 0x6291, 0x6A8D, 0x81C6, 0x5043, 0x5830,
0x5F66, 0x7109, 0x8A00, 0x8AFA, 0x5B7C, 0x8616, 0x4FFA, 0x513C,
0x56B4, 0x5944, 0x63A9, 0x6DF9, 0x5DAA, 0x696D, 0x5186, 0x4E88,
0x4F59, 0xF97F, 0xF980, 0xF981, 0x5982, 0xF982, 0xF983, 0x6B5F,
0x6C5D, 0xF984, 0x74B5, 0x7916, 0xF985, 0x8207, 0x8245, 0x8339,
0x8F3F, 0x8F5D, 0xF986, 0x9918, 0xF987, 0xF988, 0xF989, 0x4EA6,
0xF98A, 0x57DF, 0x5F79, 0x6613, 0xF98B, 0xF98C, 0x75AB, 0x7E79,
0x8B6F, 0xF98D, 0x9006, 0x9A5B, 0x56A5, 0x5827, 0x59F8, 0x5A1F,
0x5BB4, 0xF98E, 0x5EF6, 0xF98F, 0xF990, 0x6350, 0x633B, 0xF991,
0x693D, 0x6C87, 0x6CBF, 0x6D8E, 0x6D93, 0x6DF5, 0x6F14, 0xF992,
0x70DF, 0x7136, 0x7159, 0xF993, 0x71C3, 0x71D5, 0xF994, 0x784F,
0x786F, 0xF995, 0x7B75, 0x7DE3, 0xF996, 0x7E2F, 0xF997, 0x884D,
0x8EDF, 0xF998, 0xF999, 0xF99A, 0x925B, 0xF99B, 0x9CF6, 0xF99C,
0xF99D, 0xF99E, 0x6085, 0x6D85, 0xF99F, 0x71B1, 0xF9A0, 0xF9A1,
0x95B1, 0x53AD, 0xF9A2, 0xF9A3, 0xF9A4, 0x67D3, 0xF9A5, 0x708E,
0x7130, 0x7430, 0x8276, 0x82D2, 0xF9A6, 0x95BB, 0x9AE5, 0x9E7D,
0x66C4, 0xF9A7, 0x71C1, 0x8449, 0xF9A8, 0xF9A9, 0x584B, 0xF9AA,
0xF9AB, 0x5DB8, 0x5F71, 0xF9AC, 0x6620, 0x668E, 0x6979, 0x69AE,
0x6C38, 0x6CF3, 0x6E36, 0x6F41, 0x6FDA, 0x701B, 0x702F, 0x7150,
0x71DF, 0x7370, 0xF9AD, 0x745B, 0xF9AE, 0x74D4, 0x76C8, 0x7A4E,
0x7E93, 0xF9AF, 0xF9B0, 0x82F1, 0x8A60, 0x8FCE, 0xF9B1, 0x9348,
0xF9B2, 0x9719, 0xF9B3, 0xF9B4, 0x4E42, 0x502A, 0xF9B5, 0x5208,
0x53E1, 0x66F3, 0x6C6D, 0x6FCA, 0x730A, 0x777F, 0x7A62, 0x82AE,
0x85DD, 0x8602, 0xF9B6, 0x88D4, 0x8A63, 0x8B7D, 0x8C6B, 0xF9B7,
0x92B3, 0xF9B8, 0x9713, 0x9810, 0x4E94, 0x4F0D, 0x4FC9, 0x50B2,
0x5348, 0x543E, 0x5433, 0x55DA, 0x5862, 0x58BA, 0x5967, 0x5A1B,
0x5BE4, 0x609F, 0xF9B9, 0x61CA, 0x6556, 0x65FF, 0x6664, 0x68A7,
0x6C5A, 0x6FB3, 0x70CF, 0x71AC, 0x7352, 0x7B7D, 0x8708, 0x8AA4,
0x9C32, 0x9F07, 0x5C4B, 0x6C83, 0x7344, 0x7389, 0x923A, 0x6EAB,
0x7465, 0x761F, 0x7A69, 0x7E15, 0x860A, 0x5140, 0x58C5, 0x64C1,
0x74EE, 0x7515, 0x7670, 0x7FC1, 0x9095, 0x96CD, 0x9954, 0x6E26,
0x74E6, 0x7AA9, 0x7AAA, 0x81E5, 0x86D9, 0x8778, 0x8A1B, 0x5A49,
0x5B8C, 0x5B9B, 0x68A1, 0x6900, 0x6D63, 0x73A9, 0x7413, 0x742C,
0x7897, 0x7DE9, 0x7FEB, 0x8118, 0x8155, 0x839E, 0x8C4C, 0x962E,
0x9811, 0x66F0, 0x5F80, 0x65FA, 0x6789, 0x6C6A, 0x738B, 0x502D,
0x5A03, 0x6B6A, 0x77EE, 0x5916, 0x5D6C, 0x5DCD, 0x7325, 0x754F,
0xF9BA, 0xF9BB, 0x50E5, 0x51F9, 0x582F, 0x592D, 0x5996, 0x59DA,
0x5BE5, 0xF9BC, 0xF9BD, 0x5DA2, 0x62D7, 0x6416, 0x6493, 0x64FE,
0xF9BE, 0x66DC, 0xF9BF, 0x6A48, 0xF9C0, 0x71FF, 0x7464, 0xF9C1,
0x7A88, 0x7AAF, 0x7E47, 0x7E5E, 0x8000, 0x8170, 0xF9C2, 0x87EF,
0x8981, 0x8B20, 0x9059, 0xF9C3, 0x9080, 0x9952, 0x617E, 0x6B32,
0x6D74, 0x7E1F, 0x8925, 0x8FB1, 0x4FD1, 0x50AD, 0x5197, 0x52C7,
0x57C7, 0x5889, 0x5BB9, 0x5EB8, 0x6142, 0x6995, 0x6D8C, 0x6E67,
0x6EB6, 0x7194, 0x7462, 0x7528, 0x752C, 0x8073, 0x8338, 0x84C9,
0x8E0A, 0x9394, 0x93DE, 0xF9C4, 0x4E8E, 0x4F51, 0x5076, 0x512A,
0x53C8, 0x53CB, 0x53F3, 0x5B87, 0x5BD3, 0x5C24, 0x611A, 0x6182,
0x65F4, 0x725B, 0x7397, 0x7440, 0x76C2, 0x7950, 0x7991, 0x79B9,
0x7D06, 0x7FBD, 0x828B, 0x85D5, 0x865E, 0x8FC2, 0x9047, 0x90F5,
0x91EA, 0x9685, 0x96E8, 0x96E9, 0x52D6, 0x5F67, 0x65ED, 0x6631,
0x682F, 0x715C, 0x7A36, 0x90C1, 0x980A, 0x4E91, 0xF9C5, 0x6A52,
0x6B9E, 0x6F90, 0x7189, 0x8018, 0x82B8, 0x8553, 0x904B, 0x9695,
0x96F2, 0x97FB, 0x851A, 0x9B31, 0x4E90, 0x718A, 0x96C4, 0x5143,
0x539F, 0x54E1, 0x5713, 0x5712, 0x57A3, 0x5A9B, 0x5AC4, 0x5BC3,
0x6028, 0x613F, 0x63F4, 0x6C85, 0x6D39, 0x6E72, 0x6E90, 0x7230,
0x733F, 0x7457, 0x82D1, 0x8881, 0x8F45, 0x9060, 0xF9C6, 0x9662,
0x9858, 0x9D1B, 0x6708, 0x8D8A, 0x925E, 0x4F4D, 0x5049, 0x50DE,
0x5371, 0x570D, 0x59D4, 0x5A01, 0x5C09, 0x6170, 0x6690, 0x6E2D,
0x7232, 0x744B, 0x7DEF, 0x80C3, 0x840E, 0x8466, 0x853F, 0x875F,
0x885B, 0x8918, 0x8B02, 0x9055, 0x97CB, 0x9B4F, 0x4E73, 0x4F91,
0x5112, 0x516A, 0xF9C7, 0x552F, 0x55A9, 0x5B7A, 0x5BA5, 0x5E7C,
0x5E7D, 0x5EBE, 0x60A0, 0x60DF, 0x6108, 0x6109, 0x63C4, 0x6538,
0x6709, 0xF9C8, 0x67D4, 0x67DA, 0xF9C9, 0x6961, 0x6962, 0x6CB9,
0x6D27, 0xF9CA, 0x6E38, 0xF9CB, 0x6FE1, 0x7336, 0x7337, 0xF9CC,
0x745C, 0x7531, 0xF9CD, 0x7652, 0xF9CE, 0xF9CF, 0x7DAD, 0x81FE,
0x8438, 0x88D5, 0x8A98, 0x8ADB, 0x8AED, 0x8E30, 0x8E42, 0x904A,
0x903E, 0x907A, 0x9149, 0x91C9, 0x936E, 0xF9D0, 0xF9D1, 0x5809,
0xF9D2, 0x6BD3, 0x8089, 0x80B2, 0xF9D3, 0xF9D4, 0x5141, 0x596B,
0x5C39, 0xF9D5, 0xF9D6, 0x6F64, 0x73A7, 0x80E4, 0x8D07, 0xF9D7,
0x9217, 0x958F, 0xF9D8, 0xF9D9, 0xF9DA, 0xF9DB, 0x807F, 0x620E,
0x701C, 0x7D68, 0x878D, 0xF9DC, 0x57A0, 0x6069, 0x6147, 0x6BB7,
0x8ABE, 0x9280, 0x96B1, 0x4E59, 0x541F, 0x6DEB, 0x852D, 0x9670,
0x97F3, 0x98EE, 0x63D6, 0x6CE3, 0x9091, 0x51DD, 0x61C9, 0x81BA,
0x9DF9, 0x4F9D, 0x501A, 0x5100, 0x5B9C, 0x610F, 0x61FF, 0x64EC,
0x6905, 0x6BC5, 0x7591, 0x77E3, 0x7FA9, 0x8264, 0x858F, 0x87FB,
0x8863, 0x8ABC, 0x8B70, 0x91AB, 0x4E8C, 0x4EE5, 0x4F0A, 0xF9DD,
0xF9DE, 0x5937, 0x59E8, 0xF9DF, 0x5DF2, 0x5F1B, 0x5F5B, 0x6021,
0xF9E0, 0xF9E1, 0xF9E2, 0xF9E3, 0x723E, 0x73E5, 0xF9E4, 0x7570,
0x75CD, 0xF9E5, 0x79FB, 0xF9E6, 0x800C, 0x8033, 0x8084, 0x82E1,
0x8351, 0xF9E7, 0xF9E8, 0x8CBD, 0x8CB3, 0x9087, 0xF9E9, 0xF9EA,
0x98F4, 0x990C, 0xF9EB, 0xF9EC, 0x7037, 0x76CA, 0x7FCA, 0x7FCC,
0x7FFC, 0x8B1A, 0x4EBA, 0x4EC1, 0x5203, 0x5370, 0xF9ED, 0x54BD,
0x56E0, 0x59FB, 0x5BC5, 0x5F15, 0x5FCD, 0x6E6E, 0xF9EE, 0xF9EF,
0x7D6A, 0x8335, 0xF9F0, 0x8693, 0x8A8D, 0xF9F1, 0x976D, 0x9777,
0xF9F2, 0xF9F3, 0x4E00, 0x4F5A, 0x4F7E, 0x58F9, 0x65E5, 0x6EA2,
0x9038, 0x93B0, 0x99B9, 0x4EFB, 0x58EC, 0x598A, 0x59D9, 0x6041,
0xF9F4, 0xF9F5, 0x7A14, 0xF9F6, 0x834F, 0x8CC3, 0x5165, 0x5344,
0xF9F7, 0xF9F8, 0xF9F9, 0x4ECD, 0x5269, 0x5B55, 0x82BF, 0x4ED4,
0x523A, 0x54A8, 0x59C9, 0x59FF, 0x5B50, 0x5B57, 0x5B5C, 0x6063,
0x6148, 0x6ECB, 0x7099, 0x716E, 0x7386, 0x74F7, 0x75B5, 0x78C1,
0x7D2B, 0x8005, 0x81EA, 0x8328, 0x8517, 0x85C9, 0x8AEE, 0x8CC7,
0x96CC, 0x4F5C, 0x52FA, 0x56BC, 0x65AB, 0x6628, 0x707C, 0x70B8,
0x7235, 0x7DBD, 0x828D, 0x914C, 0x96C0, 0x9D72, 0x5B71, 0x68E7,
0x6B98, 0x6F7A, 0x76DE, 0x5C91, 0x66AB, 0x6F5B, 0x7BB4, 0x7C2A,
0x8836, 0x96DC, 0x4E08, 0x4ED7, 0x5320, 0x5834, 0x58BB, 0x58EF,
0x596C, 0x5C07, 0x5E33, 0x5E84, 0x5F35, 0x638C, 0x66B2, 0x6756,
0x6A1F, 0x6AA3, 0x6B0C, 0x6F3F, 0x7246, 0xF9FA, 0x7350, 0x748B,
0x7AE0, 0x7CA7, 0x8178, 0x81DF, 0x81E7, 0x838A, 0x846C, 0x8523,
0x8594, 0x85CF, 0x88DD, 0x8D13, 0x91AC, 0x9577, 0x969C, 0x518D,
0x54C9, 0x5728, 0x5BB0, 0x624D, 0x6750, 0x683D, 0x6893, 0x6E3D,
0x6ED3, 0x707D, 0x7E21, 0x88C1, 0x8CA1, 0x8F09, 0x9F4B, 0x9F4E,
0x722D, 0x7B8F, 0x8ACD, 0x931A, 0x4F47, 0x4F4E, 0x5132, 0x5480,
0x59D0, 0x5E95, 0x62B5, 0x6775, 0x696E, 0x6A17, 0x6CAE, 0x6E1A,
0x72D9, 0x732A, 0x75BD, 0x7BB8, 0x7D35, 0x82E7, 0x83F9, 0x8457,
0x85F7, 0x8A5B, 0x8CAF, 0x8E87, 0x9019, 0x90B8, 0x96CE, 0x9F5F,
0x52E3, 0x540A, 0x5AE1, 0x5BC2, 0x6458, 0x6575, 0x6EF4, 0x72C4,
0xF9FB, 0x7684, 0x7A4D, 0x7B1B, 0x7C4D, 0x7E3E, 0x7FDF, 0x837B,
0x8B2B, 0x8CCA, 0x8D64, 0x8DE1, 0x8E5F, 0x8FEA, 0x8FF9, 0x9069,
0x93D1, 0x4F43, 0x4F7A, 0x50B3, 0x5168, 0x5178, 0x524D, 0x526A,
0x5861, 0x587C, 0x5960, 0x5C08, 0x5C55, 0x5EDB, 0x609B, 0x6230,
0x6813, 0x6BBF, 0x6C08, 0x6FB1, 0x714E, 0x7420, 0x7530, 0x7538,
0x7551, 0x7672, 0x7B4C, 0x7B8B, 0x7BAD, 0x7BC6, 0x7E8F, 0x8A6E,
0x8F3E, 0x8F49, 0x923F, 0x9293, 0x9322, 0x942B, 0x96FB, 0x985A,
0x986B, 0x991E, 0x5207, 0x622A, 0x6298, 0x6D59, 0x7664, 0x7ACA,
0x7BC0, 0x7D76, 0x5360, 0x5CBE, 0x5E97, 0x6F38, 0x70B9, 0x7C98,
0x9711, 0x9B8E, 0x9EDE, 0x63A5, 0x647A, 0x8776, 0x4E01, 0x4E95,
0x4EAD, 0x505C, 0x5075, 0x5448, 0x59C3, 0x5B9A, 0x5E40, 0x5EAD,
0x5EF7, 0x5F81, 0x60C5, 0x633A, 0x653F, 0x6574, 0x65CC, 0x6676,
0x6678, 0x67FE, 0x6968, 0x6A89, 0x6B63, 0x6C40, 0x6DC0, 0x6DE8,
0x6E1F, 0x6E5E, 0x701E, 0x70A1, 0x738E, 0x73FD, 0x753A, 0x775B,
0x7887, 0x798E, 0x7A0B, 0x7A7D, 0x7CBE, 0x7D8E, 0x8247, 0x8A02,
0x8AEA, 0x8C9E, 0x912D, 0x914A, 0x91D8, 0x9266, 0x92CC, 0x9320,
0x9706, 0x9756, 0x975C, 0x9802, 0x9F0E, 0x5236, 0x5291, 0x557C,
0x5824, 0x5E1D, 0x5F1F, 0x608C, 0x63D0, 0x68AF, 0x6FDF, 0x796D,
0x7B2C, 0x81CD, 0x85BA, 0x88FD, 0x8AF8, 0x8E44, 0x918D, 0x9664,
0x969B, 0x973D, 0x984C, 0x9F4A, 0x4FCE, 0x5146, 0x51CB, 0x52A9,
0x5632, 0x5F14, 0x5F6B, 0x63AA, 0x64CD, 0x65E9, 0x6641, 0x66FA,
0x66F9, 0x671D, 0x689D, 0x68D7, 0x69FD, 0x6F15, 0x6F6E, 0x7167,
0x71E5, 0x722A, 0x74AA, 0x773A, 0x7956, 0x795A, 0x79DF, 0x7A20,
0x7A95, 0x7C97, 0x7CDF, 0x7D44, 0x7E70, 0x8087, 0x85FB, 0x86A4,
0x8A54, 0x8ABF, 0x8D99, 0x8E81, 0x9020, 0x906D, 0x91E3, 0x963B,
0x96D5, 0x9CE5, 0x65CF, 0x7C07, 0x8DB3, 0x93C3, 0x5B58, 0x5C0A,
0x5352, 0x62D9, 0x731D, 0x5027, 0x5B97, 0x5F9E, 0x60B0, 0x616B,
0x68D5, 0x6DD9, 0x742E, 0x7A2E, 0x7D42, 0x7D9C, 0x7E31, 0x816B,
0x8E2A, 0x8E35, 0x937E, 0x9418, 0x4F50, 0x5750, 0x5DE6, 0x5EA7,
0x632B, 0x7F6A, 0x4E3B, 0x4F4F, 0x4F8F, 0x505A, 0x59DD, 0x80C4,
0x546A, 0x5468, 0x55FE, 0x594F, 0x5B99, 0x5DDE, 0x5EDA, 0x665D,
0x6731, 0x67F1, 0x682A, 0x6CE8, 0x6D32, 0x6E4A, 0x6F8D, 0x70B7,
0x73E0, 0x7587, 0x7C4C, 0x7D02, 0x7D2C, 0x7DA2, 0x821F, 0x86DB,
0x8A3B, 0x8A85, 0x8D70, 0x8E8A, 0x8F33, 0x9031, 0x914E, 0x9152,
0x9444, 0x99D0, 0x7AF9, 0x7CA5, 0x4FCA, 0x5101, 0x51C6, 0x57C8,
0x5BEF, 0x5CFB, 0x6659, 0x6A3D, 0x6D5A, 0x6E96, 0x6FEC, 0x710C,
0x756F, 0x7AE3, 0x8822, 0x9021, 0x9075, 0x96CB, 0x99FF, 0x8301,
0x4E2D, 0x4EF2, 0x8846, 0x91CD, 0x537D, 0x6ADB, 0x696B, 0x6C41,
0x847A, 0x589E, 0x618E, 0x66FE, 0x62EF, 0x70DD, 0x7511, 0x75C7,
0x7E52, 0x84B8, 0x8B49, 0x8D08, 0x4E4B, 0x53EA, 0x54AB, 0x5730,
0x5740, 0x5FD7, 0x6301, 0x6307, 0x646F, 0x652F, 0x65E8, 0x667A,
0x679D, 0x67B3, 0x6B62, 0x6C60, 0x6C9A, 0x6F2C, 0x77E5, 0x7825,
0x7949, 0x7957, 0x7D19, 0x80A2, 0x8102, 0x81F3, 0x829D, 0x82B7,
0x8718, 0x8A8C, 0xF9FC, 0x8D04, 0x8DBE, 0x9072, 0x76F4, 0x7A19,
0x7A37, 0x7E54, 0x8077, 0x5507, 0x55D4, 0x5875, 0x632F, 0x6422,
0x6649, 0x664B, 0x686D, 0x699B, 0x6B84, 0x6D25, 0x6EB1, 0x73CD,
0x7468, 0x74A1, 0x755B, 0x75B9, 0x76E1, 0x771E, 0x778B, 0x79E6,
0x7E09, 0x7E1D, 0x81FB, 0x852F, 0x8897, 0x8A3A, 0x8CD1, 0x8EEB,
0x8FB0, 0x9032, 0x93AD, 0x9663, 0x9673, 0x9707, 0x4F84, 0x53F1,
0x59EA, 0x5AC9, 0x5E19, 0x684E, 0x74C6, 0x75BE, 0x79E9, 0x7A92,
0x81A3, 0x86ED, 0x8CEA, 0x8DCC, 0x8FED, 0x659F, 0x6715, 0xF9FD,
0x57F7, 0x6F57, 0x7DDD, 0x8F2F, 0x93F6, 0x96C6, 0x5FB5, 0x61F2,
0x6F84, 0x4E14, 0x4F98, 0x501F, 0x53C9, 0x55DF, 0x5D6F, 0x5DEE,
0x6B21, 0x6B64, 0x78CB, 0x7B9A, 0xF9FE, 0x8E49, 0x8ECA, 0x906E,
0x6349, 0x643E, 0x7740, 0x7A84, 0x932F, 0x947F, 0x9F6A, 0x64B0,
0x6FAF, 0x71E6, 0x74A8, 0x74DA, 0x7AC4, 0x7C12, 0x7E82, 0x7CB2,
0x7E98, 0x8B9A, 0x8D0A, 0x947D, 0x9910, 0x994C, 0x5239, 0x5BDF,
0x64E6, 0x672D, 0x7D2E, 0x50ED, 0x53C3, 0x5879, 0x6158, 0x6159,
0x61FA, 0x65AC, 0x7AD9, 0x8B92, 0x8B96, 0x5009, 0x5021, 0x5275,
0x5531, 0x5A3C, 0x5EE0, 0x5F70, 0x6134, 0x655E, 0x660C, 0x6636,
0x66A2, 0x69CD, 0x6EC4, 0x6F32, 0x7316, 0x7621, 0x7A93, 0x8139,
0x8259, 0x83D6, 0x84BC, 0x50B5, 0x57F0, 0x5BC0, 0x5BE8, 0x5F69,
0x63A1, 0x7826, 0x7DB5, 0x83DC, 0x8521, 0x91C7, 0x91F5, 0x518A,
0x67F5, 0x7B56, 0x8CAC, 0x51C4, 0x59BB, 0x60BD, 0x8655, 0x501C,
0xF9FF, 0x5254, 0x5C3A, 0x617D, 0x621A, 0x62D3, 0x64F2, 0x65A5,
0x6ECC, 0x7620, 0x810A, 0x8E60, 0x965F, 0x96BB, 0x4EDF, 0x5343,
0x5598, 0x5929, 0x5DDD, 0x64C5, 0x6CC9, 0x6DFA, 0x7394, 0x7A7F,
0x821B, 0x85A6, 0x8CE4, 0x8E10, 0x9077, 0x91E7, 0x95E1, 0x9621,
0x97C6, 0x51F8, 0x54F2, 0x5586, 0x5FB9, 0x64A4, 0x6F88, 0x7DB4,
0x8F1F, 0x8F4D, 0x9435, 0x50C9, 0x5C16, 0x6CBE, 0x6DFB, 0x751B,
0x77BB, 0x7C3D, 0x7C64, 0x8A79, 0x8AC2, 0x581E, 0x59BE, 0x5E16,
0x6377, 0x7252, 0x758A, 0x776B, 0x8ADC, 0x8CBC, 0x8F12, 0x5EF3,
0x6674, 0x6DF8, 0x807D, 0x83C1, 0x8ACB, 0x9751, 0x9BD6, 0xFA00,
0x5243, 0x66FF, 0x6D95, 0x6EEF, 0x7DE0, 0x8AE6, 0x902E, 0x905E,
0x9AD4, 0x521D, 0x527F, 0x54E8, 0x6194, 0x6284, 0x62DB, 0x68A2,
0x6912, 0x695A, 0x6A35, 0x7092, 0x7126, 0x785D, 0x7901, 0x790E,
0x79D2, 0x7A0D, 0x8096, 0x8278, 0x82D5, 0x8349, 0x8549, 0x8C82,
0x8D85, 0x9162, 0x918B, 0x91AE, 0x4FC3, 0x56D1, 0x71ED, 0x77D7,
0x8700, 0x89F8, 0x5BF8, 0x5FD6, 0x6751, 0x90A8, 0x53E2, 0x585A,
0x5BF5, 0x60A4, 0x6181, 0x6460, 0x7E3D, 0x8070, 0x8525, 0x9283,
0x64AE, 0x50AC, 0x5D14, 0x6700, 0x589C, 0x62BD, 0x63A8, 0x690E,
0x6978, 0x6A1E, 0x6E6B, 0x76BA, 0x79CB, 0x82BB, 0x8429, 0x8ACF,
0x8DA8, 0x8FFD, 0x9112, 0x914B, 0x919C, 0x9310, 0x9318, 0x939A,
0x96DB, 0x9A36, 0x9C0D, 0x4E11, 0x755C, 0x795D, 0x7AFA, 0x7B51,
0x7BC9, 0x7E2E, 0x84C4, 0x8E59, 0x8E74, 0x8EF8, 0x9010, 0x6625,
0x693F, 0x7443, 0x51FA, 0x672E, 0x9EDC, 0x5145, 0x5FE0, 0x6C96,
0x87F2, 0x885D, 0x8877, 0x60B4, 0x81B5, 0x8403, 0x8D05, 0x53D6,
0x5439, 0x5634, 0x5A36, 0x5C31, 0x708A, 0x7FE0, 0x805A, 0x8106,
0x81ED, 0x8DA3, 0x9189, 0x9A5F, 0x9DF2, 0x5074, 0x4EC4, 0x53A0,
0x60FB, 0x6E2C, 0x5C64, 0x4F88, 0x5024, 0x55E4, 0x5CD9, 0x5E5F,
0x6065, 0x6894, 0x6CBB, 0x6DC4, 0x71BE, 0x75D4, 0x75F4, 0x7661,
0x7A1A, 0x7A49, 0x7DC7, 0x7DFB, 0x7F6E, 0x81F4, 0x86A9, 0x8F1C,
0x96C9, 0x99B3, 0x9F52, 0x5247, 0x52C5, 0x98ED, 0x89AA, 0x4E03,
0x67D2, 0x6F06, 0x4FB5, 0x5BE2, 0x6795, 0x6C88, 0x6D78, 0x741B,
0x7827, 0x91DD, 0x937C, 0x87C4, 0x79E4, 0x7A31, 0x5FEB, 0x4ED6,
0x54A4, 0x553E, 0x58AE, 0x59A5, 0x60F0, 0x6253, 0x62D6, 0x6736,
0x6955, 0x8235, 0x9640, 0x99B1, 0x99DD, 0x502C, 0x5353, 0x5544,
0x577C, 0xFA01, 0x6258, 0xFA02, 0x64E2, 0x666B, 0x67DD, 0x6FC1,
0x6FEF, 0x7422, 0x7438, 0x8A17, 0x9438, 0x5451, 0x5606, 0x5766,
0x5F48, 0x619A, 0x6B4E, 0x7058, 0x70AD, 0x7DBB, 0x8A95, 0x596A,
0x812B, 0x63A2, 0x7708, 0x803D, 0x8CAA, 0x5854, 0x642D, 0x69BB,
0x5B95, 0x5E11, 0x6E6F, 0xFA03, 0x8569, 0x514C, 0x53F0, 0x592A,
0x6020, 0x614B, 0x6B86, 0x6C70, 0x6CF0, 0x7B1E, 0x80CE, 0x82D4,
0x8DC6, 0x90B0, 0x98B1, 0xFA04, 0x64C7, 0x6FA4, 0x6491, 0x6504,
0x514E, 0x5410, 0x571F, 0x8A0E, 0x615F, 0x6876, 0xFA05, 0x75DB,
0x7B52, 0x7D71, 0x901A, 0x5806, 0x69CC, 0x817F, 0x892A, 0x9000,
0x9839, 0x5078, 0x5957, 0x59AC, 0x6295, 0x900F, 0x9B2A, 0x615D,
0x7279, 0x95D6, 0x5761, 0x5A46, 0x5DF4, 0x628A, 0x64AD, 0x64FA,
0x6777, 0x6CE2, 0x6D3E, 0x722C, 0x7436, 0x7834, 0x7F77, 0x82AD,
0x8DDB, 0x9817, 0x5224, 0x5742, 0x677F, 0x7248, 0x74E3, 0x8CA9,
0x8FA6, 0x9211, 0x962A, 0x516B, 0x53ED, 0x634C, 0x4F69, 0x5504,
0x6096, 0x6557, 0x6C9B, 0x6D7F, 0x724C, 0x72FD, 0x7A17, 0x8987,
0x8C9D, 0x5F6D, 0x6F8E, 0x70F9, 0x81A8, 0x610E, 0x4FBF, 0x504F,
0x6241, 0x7247, 0x7BC7, 0x7DE8, 0x7FE9, 0x904D, 0x97AD, 0x9A19,
0x8CB6, 0x576A, 0x5E73, 0x67B0, 0x840D, 0x8A55, 0x5420, 0x5B16,
0x5E63, 0x5EE2, 0x5F0A, 0x6583, 0x80BA, 0x853D, 0x9589, 0x965B,
0x4F48, 0x5305, 0x530D, 0x530F, 0x5486, 0x54FA, 0x5703, 0x5E03,
0x6016, 0x629B, 0x62B1, 0x6355, 0xFA06, 0x6CE1, 0x6D66, 0x75B1,
0x7832, 0x80DE, 0x812F, 0x82DE, 0x8461, 0x84B2, 0x888D, 0x8912,
0x900B, 0x92EA, 0x98FD, 0x9B91, 0x5E45, 0x66B4, 0x66DD, 0x7011,
0x7206, 0xFA07, 0x4FF5, 0x527D, 0x5F6A, 0x6153, 0x6753, 0x6A19,
0x6F02, 0x74E2, 0x7968, 0x8868, 0x8C79, 0x98C7, 0x98C4, 0x9A43,
0x54C1, 0x7A1F, 0x6953, 0x8AF7, 0x8C4A, 0x98A8, 0x99AE, 0x5F7C,
0x62AB, 0x75B2, 0x76AE, 0x88AB, 0x907F, 0x9642, 0x5339, 0x5F3C,
0x5FC5, 0x6CCC, 0x73CC, 0x7562, 0x758B, 0x7B46, 0x82FE, 0x999D,
0x4E4F, 0x903C, 0x4E0B, 0x4F55, 0x53A6, 0x590F, 0x5EC8, 0x6630,
0x6CB3, 0x7455, 0x8377, 0x8766, 0x8CC0, 0x9050, 0x971E, 0x9C15,
0x58D1, 0x5B78, 0x8650, 0x8B14, 0x9DB4, 0x5BD2, 0x6068, 0x608D,
0x65F1, 0x6C57, 0x6F22, 0x6FA3, 0x701A, 0x7F55, 0x7FF0, 0x9591,
0x9592, 0x9650, 0x97D3, 0x5272, 0x8F44, 0x51FD, 0x542B, 0x54B8,
0x5563, 0x558A, 0x6ABB, 0x6DB5, 0x7DD8, 0x8266, 0x929C, 0x9677,
0x9E79, 0x5408, 0x54C8, 0x76D2, 0x86E4, 0x95A4, 0x95D4, 0x965C,
0x4EA2, 0x4F09, 0x59EE, 0x5AE6, 0x5DF7, 0x6052, 0x6297, 0x676D,
0x6841, 0x6C86, 0x6E2F, 0x7F38, 0x809B, 0x822A, 0xFA08, 0xFA09,
0x9805, 0x4EA5, 0x5055, 0x54B3, 0x5793, 0x595A, 0x5B69, 0x5BB3,
0x61C8, 0x6977, 0x6D77, 0x7023, 0x87F9, 0x89E3, 0x8A72, 0x8AE7,
0x9082, 0x99ED, 0x9AB8, 0x52BE, 0x6838, 0x5016, 0x5E78, 0x674F,
0x8347, 0x884C, 0x4EAB, 0x5411, 0x56AE, 0x73E6, 0x9115, 0x97FF,
0x9909, 0x9957, 0x9999, 0x5653, 0x589F, 0x865B, 0x8A31, 0x61B2,
0x6AF6, 0x737B, 0x8ED2, 0x6B47, 0x96AA, 0x9A57, 0x5955, 0x7200,
0x8D6B, 0x9769, 0x4FD4, 0x5CF4, 0x5F26, 0x61F8, 0x665B, 0x6CEB,
0x70AB, 0x7384, 0x73B9, 0x73FE, 0x7729, 0x774D, 0x7D43, 0x7D62,
0x7E23, 0x8237, 0x8852, 0xFA0A, 0x8CE2, 0x9249, 0x986F, 0x5B51,
0x7A74, 0x8840, 0x9801, 0x5ACC, 0x4FE0, 0x5354, 0x593E, 0x5CFD,
0x633E, 0x6D79, 0x72F9, 0x8105, 0x8107, 0x83A2, 0x92CF, 0x9830,
0x4EA8, 0x5144, 0x5211, 0x578B, 0x5F62, 0x6CC2, 0x6ECE, 0x7005,
0x7050, 0x70AF, 0x7192, 0x73E9, 0x7469, 0x834A, 0x87A2, 0x8861,
0x9008, 0x90A2, 0x93A3, 0x99A8, 0x516E, 0x5F57, 0x60E0, 0x6167,
0x66B3, 0x8559, 0x8E4A, 0x91AF, 0x978B, 0x4E4E, 0x4E92, 0x547C,
0x58D5, 0x58FA, 0x597D, 0x5CB5, 0x5F27, 0x6236, 0x6248, 0x660A,
0x6667, 0x6BEB, 0x6D69, 0x6DCF, 0x6E56, 0x6EF8, 0x6F94, 0x6FE0,
0x6FE9, 0x705D, 0x72D0, 0x7425, 0x745A, 0x74E0, 0x7693, 0x795C,
0x7CCA, 0x7E1E, 0x80E1, 0x82A6, 0x846B, 0x84BF, 0x864E, 0x865F,
0x8774, 0x8B77, 0x8C6A, 0x93AC, 0x9800, 0x9865, 0x60D1, 0x6216,
0x9177, 0x5A5A, 0x660F, 0x6DF7, 0x6E3E, 0x743F, 0x9B42, 0x5FFD,
0x60DA, 0x7B0F, 0x54C4, 0x5F18, 0x6C5E, 0x6CD3, 0x6D2A, 0x70D8,
0x7D05, 0x8679, 0x8A0C, 0x9D3B, 0x5316, 0x548C, 0x5B05, 0x6A3A,
0x706B, 0x7575, 0x798D, 0x79BE, 0x82B1, 0x83EF, 0x8A71, 0x8B41,
0x8CA8, 0x9774, 0xFA0B, 0x64F4, 0x652B, 0x78BA, 0x78BB, 0x7A6B,
0x4E38, 0x559A, 0x5950, 0x5BA6, 0x5E7B, 0x60A3, 0x63DB, 0x6B61,
0x6665, 0x6853, 0x6E19, 0x7165, 0x74B0, 0x7D08, 0x9084, 0x9A69,
0x9C25, 0x6D3B, 0x6ED1, 0x733E, 0x8C41, 0x95CA, 0x51F0, 0x5E4C,
0x5FA8, 0x604D, 0x60F6, 0x6130, 0x614C, 0x6643, 0x6644, 0x69A5,
0x6CC1, 0x6E5F, 0x6EC9, 0x6F62, 0x714C, 0x749C, 0x7687, 0x7BC1,
0x7C27, 0x8352, 0x8757, 0x9051, 0x968D, 0x9EC3, 0x532F, 0x56DE,
0x5EFB, 0x5F8A, 0x6062, 0x6094, 0x61F7, 0x6666, 0x6703, 0x6A9C,
0x6DEE, 0x6FAE, 0x7070, 0x736A, 0x7E6A, 0x81BE, 0x8334, 0x86D4,
0x8AA8, 0x8CC4, 0x5283, 0x7372, 0x5B96, 0x6A6B, 0x9404, 0x54EE,
0x5686, 0x5B5D, 0x6548, 0x6585, 0x66C9, 0x689F, 0x6D8D, 0x6DC6,
0x723B, 0x80B4, 0x9175, 0x9A4D, 0x4FAF, 0x5019, 0x539A, 0x540E,
0x543C, 0x5589, 0x55C5, 0x5E3F, 0x5F8C, 0x673D, 0x7166, 0x73DD,
0x9005, 0x52DB, 0x52F3, 0x5864, 0x58CE, 0x7104, 0x718F, 0x71FB,
0x85B0, 0x8A13, 0x6688, 0x85A8, 0x55A7, 0x6684, 0x714A, 0x8431,
0x5349, 0x5599, 0x6BC1, 0x5F59, 0x5FBD, 0x63EE, 0x6689, 0x7147,
0x8AF1, 0x8F1D, 0x9EBE, 0x4F11, 0x643A, 0x70CB, 0x7566, 0x8667,
0x6064, 0x8B4E, 0x9DF8, 0x5147, 0x51F6, 0x5308, 0x6D36, 0x80F8,
0x9ED1, 0x6615, 0x6B23, 0x7098, 0x75D5, 0x5403, 0x5C79, 0x7D07,
0x8A16, 0x6B20, 0x6B3D, 0x6B46, 0x5438, 0x6070, 0x6D3D, 0x7FD5,
0x8208, 0x50D6, 0x51DE, 0x559C, 0x566B, 0x56CD, 0x59EC, 0x5B09,
0x5E0C, 0x6199, 0x6198, 0x6231, 0x665E, 0x66E6, 0x7199, 0x71B9,
0x71BA, 0x72A7, 0x79A7, 0x7A00, 0x7FB2, 0x8A70,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_KSX1001_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_ksx1001.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 144,066
|
```objective-c
/* gb2312.h - tables for Unicode to/from ECI 29 GB 2312-1980 (EUC-CN), generated by "tools/gen_zueci_mb_h.php" from
"unicode.org-mappings/EASTASIA/GB/GB2312.TXT"
(see path_to_url */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_GB2312_H
#define ZUECI_GB2312_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode usage bit-flags for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_gb2312_uro_u[1263] = {
0x7F8B, 0x7F7B, 0x3DB4, 0xEF55, 0xFBA8, 0xF35D, 0x0243, 0x400B,
0xFB40, 0x8D3E, 0x7BF7, 0x8C2C, 0x6EFF, 0xE3FA, 0x1D3A, 0xA8ED,
0xE602, 0xCF83, 0x8CF5, 0x3555, 0xE048, 0xFFAB, 0x92B9, 0xD859,
0xAB18, 0x2892, 0xD7E9, 0x8020, 0xC438, 0xF583, 0xE74A, 0x450A,
0xB000, 0x9714, 0x7762, 0x5400, 0xD188, 0x1420, 0x1020, 0xC8C0,
0x2121, 0x0000, 0x13A8, 0x0C04, 0x8000, 0x0440, 0x70C0, 0x0828,
0x08C0, 0x0004, 0x0002, 0x8000, 0x2B7B, 0x1472, 0x7924, 0x3BFB,
0x3327, 0x1AE4, 0x9835, 0x38EF, 0x9AD1, 0x2802, 0xA813, 0xBF69,
0x65CF, 0x2FC6, 0x6B11, 0xAFC9, 0x340F, 0x5053, 0x86A2, 0xA004,
0x0106, 0xE809, 0x3F0F, 0xC00E, 0x0A88, 0x8145, 0x0010, 0xC601,
0xA161, 0x26E1, 0x444B, 0xCE00, 0xC7AA, 0xD4EE, 0xCADF, 0x85BB,
0x3A74, 0xA520, 0x436C, 0x8840, 0x3F06, 0x8BD2, 0xFF79, 0x3BEF,
0xF75A, 0xE8EF, 0xFBCB, 0x5B36, 0x0D49, 0x1BFD, 0x0154, 0x39EE,
0xD855, 0x2E75, 0xBFD8, 0xA91A, 0xF3D7, 0xF6BF, 0x67E0, 0xB40C,
0x82C2, 0x0813, 0xD49D, 0xD08B, 0x065A, 0x1061, 0x74F2, 0x59E0,
0x8F9F, 0xB312, 0x0080, 0x6AAA, 0x3230, 0xB05E, 0x9D7A, 0x60AC,
0xD303, 0xC900, 0x3098, 0x8A56, 0x7000, 0x1390, 0x1F14, 0x1842,
0xC060, 0x0008, 0x8008, 0x1080, 0x0400, 0xEC90, 0x2817, 0xE633,
0x0758, 0x9000, 0xF708, 0x4E09, 0xF485, 0xFC83, 0xAF53, 0x18C8,
0x187C, 0x080C, 0x6ADF, 0x0114, 0xC80C, 0xA734, 0xA011, 0x2710,
0x28C5, 0x4222, 0x0413, 0x0021, 0x3010, 0x4112, 0x1820, 0x4000,
0x022B, 0xC60C, 0x0300, 0x1000, 0x0022, 0x0022, 0x5810, 0x0249,
0xA094, 0x9670, 0xEEB0, 0x1792, 0xCB96, 0x05F2, 0x0025, 0x2358,
0x25DE, 0x42CC, 0xCF38, 0x4A04, 0x0C40, 0x359F, 0x1128, 0x8A00,
0x13FA, 0x910A, 0x0229, 0x1056, 0x0641, 0x0420, 0x0484, 0x84F0,
0x0000, 0x0C04, 0x0400, 0x412C, 0x1206, 0x1154, 0x0A4B, 0x0002,
0x0200, 0x00C0, 0x0000, 0x0094, 0x0001, 0xBFBB, 0x167C, 0x242B,
0x9BBB, 0x7FA8, 0x0C7F, 0xE379, 0x10F4, 0xE00D, 0x4132, 0x9F01,
0x8652, 0x3572, 0x10B4, 0xFF12, 0xCF27, 0x4223, 0xC06B, 0x8602,
0x3106, 0x1FD3, 0x3A0C, 0xA1AA, 0x0812, 0x0204, 0x2572, 0x0801,
0x40CC, 0x4850, 0x62D0, 0x6010, 0x1C80, 0x2900, 0x9A00, 0x0010,
0x0004, 0x2200, 0x0000, 0x0080, 0x2020, 0x6800, 0xCBE6, 0x609E,
0x916E, 0x3F73, 0x60C0, 0x3982, 0x1034, 0x4830, 0x0006, 0xBD5C,
0x8CD1, 0xD6FB, 0x20E1, 0x43E8, 0x0600, 0x084E, 0x0500, 0xC4D0,
0x8D1F, 0x89AA, 0xA6E1, 0x1602, 0x0001, 0x21ED, 0x3656, 0x1A8B,
0x1FB7, 0x13A5, 0x6502, 0x30A0, 0xB278, 0x23C7, 0x6C93, 0xE922,
0xE47F, 0x3A74, 0x8FE3, 0x9820, 0x280E, 0x2625, 0xBF9C, 0xBF49,
0x3218, 0xAC54, 0xB949, 0x1916, 0x0C60, 0xB522, 0xFBC1, 0x0659,
0xE343, 0x8420, 0x08D9, 0x8000, 0x5500, 0x2022, 0x0184, 0x00A1,
0x4800, 0x2010, 0x1380, 0x4080, 0x0D04, 0x0016, 0x0040, 0x8020,
0xFD40, 0x8DE7, 0x5436, 0xE098, 0x7B8B, 0x091E, 0xFEC8, 0xD249,
0x0611, 0x8DEE, 0x1937, 0xBA22, 0x77F4, 0x9FDD, 0xF3EC, 0xF0DA,
0x4386, 0xEC42, 0x8D3F, 0x2604, 0xFA6C, 0xC021, 0x628E, 0x0CC2,
0xD785, 0x0145, 0x77AD, 0x5599, 0xE250, 0x4045, 0x260B, 0xA154,
0x9827, 0x5819, 0x3443, 0xA410, 0x05F2, 0x4114, 0x2280, 0x0700,
0x00B4, 0x4266, 0x7210, 0x15A1, 0x6025, 0x4185, 0x0054, 0x0000,
0x0201, 0x0104, 0xC820, 0xCB70, 0x9320, 0x6A62, 0x184C, 0x0095,
0x1880, 0x9A8B, 0xAAB2, 0x3201, 0xD87A, 0x00C4, 0xF3E5, 0x04C3,
0xD44D, 0xA238, 0xA1A1, 0x5072, 0x980A, 0x84FC, 0xC152, 0x44D1,
0x1094, 0x20C2, 0x4180, 0x4210, 0x0000, 0x3A00, 0x0240, 0xD29D,
0x2F01, 0xA8B1, 0xBD40, 0x2432, 0xD34D, 0xD04B, 0xA723, 0xD0AD,
0x0A92, 0x75A1, 0xADAC, 0x01E9, 0x801A, 0x771F, 0x9225, 0xA01B,
0xDFA1, 0x20CA, 0x0602, 0x738C, 0x577F, 0x003B, 0x0BFF, 0x00D0,
0x806A, 0x0088, 0xA1C4, 0x0029, 0x2A05, 0x0524, 0x4009, 0x1623,
0x6822, 0x8005, 0x2011, 0xA211, 0x0004, 0x6490, 0x4849, 0x1382,
0x23D5, 0x1930, 0x2980, 0x0892, 0x5402, 0x8811, 0x2001, 0xA004,
0x0400, 0x8180, 0x8502, 0x6022, 0x0090, 0x0B01, 0x0022, 0x1202,
0x4011, 0x0083, 0x1A01, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x009F, 0x4684, 0x12C8, 0x0200, 0x04FC, 0x1A00,
0x2EDE, 0x0C4C, 0x0402, 0x80B8, 0xA826, 0x0AFC, 0x8C02, 0x2228,
0xA0E0, 0x8F7B, 0xC7D6, 0x2135, 0x06C7, 0xF8B1, 0x0713, 0x6255,
0x936E, 0x8A19, 0x6EFA, 0xFB0E, 0x1630, 0x48F9, 0xCD2F, 0x7DEB,
0x5892, 0x4E84, 0x4CA0, 0x7A2E, 0xEDEA, 0x561E, 0xC649, 0x1190,
0x5324, 0xE83A, 0xCFDB, 0x8124, 0x18F1, 0x6342, 0x5853, 0x1A8A,
0x7420, 0x24D3, 0xAA3B, 0x0514, 0x6018, 0x8958, 0x4800, 0xC000,
0x8268, 0x9101, 0x84A4, 0x2CD6, 0x8886, 0xC4BA, 0x0377, 0x0210,
0x8244, 0x0038, 0xAE11, 0x404A, 0x28C0, 0x5100, 0x6044, 0x1514,
0x7310, 0x1000, 0x0082, 0x0248, 0x0205, 0x4006, 0xC003, 0x0000,
0x0000, 0x0C02, 0x0008, 0x0220, 0x9000, 0x4000, 0xB800, 0xD161,
0x4621, 0x3274, 0xF800, 0x3B8A, 0x050F, 0x8B00, 0xBBD0, 0x2280,
0x0600, 0x0769, 0x8040, 0x0043, 0x5420, 0x5000, 0x41D0, 0x250C,
0x8410, 0x8310, 0x1101, 0x0228, 0x4008, 0x0030, 0x40A1, 0x0200,
0x0040, 0x2000, 0x1500, 0xABE3, 0x3180, 0xAA44, 0xC2C6, 0xC624,
0xAC13, 0x8004, 0xB000, 0x03D1, 0x611E, 0x4285, 0xF303, 0x1D9F,
0x440A, 0x78E8, 0x5E26, 0xC392, 0x2000, 0x0085, 0xB001, 0x4000,
0x4A90, 0x8842, 0xCA04, 0x0C8D, 0xA705, 0x4203, 0x22A1, 0x0004,
0x8668, 0x0C01, 0x5564, 0x1079, 0x0002, 0xDEA0, 0x2000, 0x40C1,
0x488B, 0x5001, 0x0380, 0x0400, 0x0000, 0x5004, 0xC05D, 0x80D0,
0xA010, 0x970A, 0xBB20, 0x4DAF, 0xD921, 0x1E10, 0x0460, 0x8314,
0x8848, 0xA6D6, 0xD83B, 0x733F, 0x27BC, 0x4974, 0x0DDC, 0x9213,
0x142B, 0x8BA1, 0x2E75, 0xD139, 0x3009, 0x5050, 0x8808, 0x6900,
0x49D4, 0x024A, 0x4010, 0x8016, 0xE564, 0x89D7, 0xC020, 0x5316,
0x2B92, 0x8600, 0xA345, 0x15E0, 0x008B, 0x0C03, 0x196E, 0xE200,
0x7031, 0x8006, 0x16A5, 0xA829, 0x2000, 0x1880, 0x7AAC, 0xE148,
0x3207, 0xB5D6, 0x32E8, 0x5F91, 0x50A1, 0x20E5, 0x7C00, 0x1080,
0x7280, 0x9D8A, 0x00AA, 0x421F, 0x0E22, 0x0231, 0x1100, 0x0494,
0x0022, 0x4008, 0x0010, 0x5C10, 0x0343, 0xFCC8, 0xA1A5, 0x0580,
0x8433, 0x0400, 0x0080, 0x6E08, 0x2A4B, 0x8126, 0xAAD8, 0x2901,
0x684D, 0x4490, 0x0009, 0xBA88, 0x0040, 0x0082, 0x0000, 0x87D1,
0x215B, 0xB1E6, 0x3161, 0x8008, 0x0800, 0xC240, 0xA069, 0xA600,
0x8D58, 0x4A32, 0x5D71, 0x550A, 0x9AA0, 0x2D57, 0x4005, 0x4AA6,
0x2021, 0x30B1, 0x3FC6, 0x0112, 0x10C2, 0x260A, 0x4462, 0x5082,
0x9880, 0x8040, 0x04C0, 0x8100, 0x2003, 0x0000, 0x0000, 0x3818,
0x0200, 0xF1A6, 0x4434, 0x720E, 0x35A2, 0x92E0, 0x8101, 0x0900,
0x0400, 0x0000, 0x8885, 0x0000, 0x0000, 0x0000, 0x4000, 0x0080,
0x0000, 0x0000, 0x4040, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0800, 0x0082, 0x0000, 0x0000, 0x0000,
0x0004, 0x8800, 0xBFFF, 0xE7EF, 0xFFFF, 0xFFBF, 0xEFEF, 0xFDFF,
0xFBFF, 0xBFFE, 0xFFFF, 0x057F, 0x0034, 0x85B3, 0x4706, 0x4216,
0x5402, 0xE410, 0x8092, 0xB305, 0x5422, 0x8130, 0x4263, 0x180B,
0x387B, 0x13F5, 0x07E5, 0xA9EA, 0x3C4C, 0x0514, 0x0600, 0x8002,
0x1AD9, 0xBD48, 0xEE37, 0xF496, 0x705F, 0x7EC0, 0xBFB2, 0x355F,
0xE644, 0x455F, 0x9000, 0x4146, 0x1D40, 0x063B, 0x62A1, 0xFE13,
0x8505, 0x3902, 0x0548, 0x0C08, 0x144F, 0x0000, 0x3488, 0x5818,
0x3077, 0xD815, 0xBD0E, 0x4BFB, 0x8A90, 0x8500, 0xC100, 0xE61D,
0xED14, 0xB386, 0xFF72, 0x639B, 0xFD92, 0xD9BE, 0x887B, 0x0A92,
0xD3FE, 0x1CB2, 0xB980, 0x177A, 0x82C9, 0xDC17, 0xFFFB, 0x3980,
0x4260, 0x590C, 0x0F01, 0x37DF, 0x94A3, 0xB150, 0x0623, 0x2307,
0xF85A, 0x3102, 0x01F0, 0x3102, 0x0040, 0x1E82, 0x3A0A, 0x056A,
0x5B84, 0x1280, 0x8002, 0xA714, 0x2612, 0xA04B, 0x1069, 0x9001,
0x1000, 0x848A, 0x1802, 0x3F80, 0x0708, 0x4240, 0x0110, 0x4E14,
0x80B0, 0x1800, 0xC510, 0x0281, 0x8202, 0x1029, 0x0210, 0x8800,
0x0020, 0x0042, 0x0280, 0x1100, 0xE000, 0x4413, 0x5804, 0xFE02,
0x3C07, 0x3028, 0x9798, 0x0473, 0xCED1, 0xCB13, 0x6210, 0x431F,
0x278D, 0x55AC, 0x422E, 0xC892, 0x5380, 0x0288, 0x4039, 0x7851,
0x292C, 0x8088, 0xB900, 0x2428, 0x0C41, 0x080E, 0x4421, 0x4200,
0x0408, 0x0868, 0x0006, 0x1204, 0x3031, 0x0290, 0x5B3E, 0xE085,
0x2936, 0x1044, 0x2814, 0x1082, 0x4266, 0x8334, 0x013C, 0x531B,
0x0404, 0x0E0D, 0x0C22, 0x0051, 0x0012, 0xC000, 0x0040, 0x8800,
0x004A, 0x0000, 0x0000, 0x0000, 0xDFF6, 0x5447, 0x8868, 0x0008,
0x0081, 0x0000, 0x0000, 0x4000, 0x0100, 0x0000, 0x0000, 0x0200,
0x0600, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0080, 0x0000, 0x0040, 0x0000, 0x0000, 0x0000, 0x1040, 0x0000,
0x0000, 0x0000, 0xEFFF, 0xF7FD, 0xFF7F, 0xFFFE, 0xFBFF, 0xFFFF,
0xFDFF, 0xBFFF, 0xFFFF, 0x00FF, 0x12C2, 0x0420, 0x0C06, 0x0708,
0x1624, 0x0110, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0xE000, 0xFFFE, 0xFFFF, 0xFFFF, 0x7F79, 0x28DF, 0x00F9,
0x0C32, 0x8012, 0x0008, 0xD53A, 0xD858, 0xECC2, 0x9D18, 0x2FA8,
0x9620, 0xE010, 0xD60C, 0x2622, 0x0F97, 0x0206, 0xB240, 0x9055,
0x80A2, 0x5011, 0x9800, 0x0404, 0x4000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFBC0, 0xFFFF,
0xEFFE, 0xDFFB, 0x0B08, 0x6243, 0x41B6, 0xFB3B, 0x6F74, 0x2389,
0xAE7F, 0xECD7, 0xE047, 0x5960, 0xA096, 0x098F, 0x612C, 0xA030,
0x090D, 0x2AAA, 0xD44E, 0x4F7B, 0xC4B2, 0x388B, 0xA9C6, 0x6110,
0x0014, 0x4200, 0x800C, 0x0202, 0xFE48, 0x6485, 0xD63E, 0xE3F7,
0x3AA0, 0x0C07, 0xE40C, 0x0430, 0xF680, 0x1002, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0010,
0x4000, 0x0000, 0x4000, 0x0000, 0x0100, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0400, 0x0000,
0x8000, 0x0000, 0x0000, 0x0000, 0x0400, 0x0040, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x4000, 0x0000, 0x0000, 0x0800, 0x0000,
0xFFE0, 0xFEBD, 0xFFFF, 0xFFFF, 0x7F7F, 0xFBE7, 0xFFBF, 0xF7FF,
0xFFFF, 0xEFFF, 0xFF7E, 0xDFF7, 0xF6F7, 0xFBDF, 0xBFFE, 0x804F,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xEF00, 0x7FFF,
0xFF7F, 0xB6F7, 0x4406, 0xB87E, 0x3BF5, 0x8831, 0x1796, 0x00F4,
0xA960, 0x1391, 0x0080, 0x7249, 0xF2F3, 0x0024, 0x8701, 0x42C8,
0xE3D3, 0x5048, 0x2400, 0x4305, 0x0000, 0x4A4C, 0x0227, 0x1058,
0x2820, 0x0116, 0xA809, 0x0014, 0x0000, 0x0000, 0x3EC0, 0x0068,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFE0,
0xB7FF, 0xFDDB, 0x00F7, 0x0000, 0x4000, 0xC72E, 0x0180, 0x0000,
0x2000, 0x0001, 0x4000, 0x0000, 0x0000, 0x0030, 0xFFA8, 0xB4F7,
0xADF3, 0x03FF, 0x0120, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xF000, 0xFFFB,
0x9DF7, 0xFDCF, 0x01BF, 0x15C3, 0x1827, 0x810A, 0xA842, 0x0A00,
0x8108, 0x8008, 0x8008, 0x1804, 0xA3BE, 0x0012, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9000,
0x69E6, 0xDC37, 0x6BFF, 0x3DFF, 0xFCF8, 0xF3F9, 0x0004,
};
/* Multibyte indexes for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_gb2312_uro_mb_ind[1263] = {
584, 595, 608, 617, 628, 638, 649, 653,
657, 665, 674, 687, 693, 706, 717, 725,
734, 740, 749, 758, 766, 771, 784, 792,
800, 807, 812, 823, 825, 831, 840, 849,
854, 857, 864, 873, 876, 882, 885, 887,
892, 896, 896, 902, 905, 906, 908, 913,
916, 919, 920, 921, 922, 932, 938, 945,
957, 965, 972, 979, 989, 997, 1000, 1006,
1017, 1027, 1036, 1043, 1053, 1060, 1066, 1072,
1075, 1078, 1084, 1094, 1099, 1103, 1108, 1109,
1114, 1120, 1127, 1133, 1138, 1147, 1157, 1168,
1177, 1185, 1190, 1197, 1200, 1208, 1216, 1229,
1241, 1252, 1263, 1275, 1284, 1290, 1301, 1305,
1315, 1323, 1332, 1343, 1350, 1362, 1375, 1383,
1389, 1394, 1398, 1407, 1414, 1420, 1424, 1433,
1440, 1451, 1458, 1459, 1467, 1472, 1480, 1490,
1496, 1503, 1507, 1512, 1519, 1522, 1527, 1534,
1538, 1542, 1543, 1545, 1547, 1548, 1555, 1561,
1570, 1576, 1578, 1586, 1592, 1600, 1609, 1619,
1624, 1631, 1634, 1645, 1648, 1653, 1661, 1665,
1670, 1676, 1680, 1684, 1686, 1689, 1693, 1696,
1697, 1702, 1708, 1710, 1711, 1713, 1715, 1719,
1723, 1728, 1735, 1744, 1751, 1760, 1767, 1770,
1776, 1785, 1791, 1800, 1804, 1807, 1817, 1821,
1824, 1833, 1838, 1842, 1847, 1851, 1853, 1856,
1862, 1862, 1865, 1866, 1871, 1875, 1880, 1886,
1887, 1888, 1890, 1890, 1893, 1894, 1907, 1915,
1921, 1932, 1942, 1951, 1961, 1967, 1973, 1978,
1985, 1991, 1999, 2004, 2014, 2024, 2029, 2036,
2040, 2045, 2055, 2061, 2068, 2071, 2073, 2080,
2082, 2087, 2091, 2097, 2100, 2104, 2107, 2111,
2112, 2113, 2115, 2115, 2116, 2118, 2121, 2131,
2138, 2146, 2157, 2161, 2167, 2171, 2175, 2177,
2187, 2194, 2206, 2211, 2218, 2220, 2225, 2227,
2233, 2242, 2249, 2257, 2261, 2262, 2270, 2278,
2285, 2296, 2303, 2308, 2312, 2320, 2328, 2336,
2343, 2354, 2362, 2372, 2376, 2381, 2387, 2398,
2408, 2413, 2420, 2428, 2434, 2438, 2445, 2455,
2461, 2469, 2472, 2478, 2479, 2483, 2486, 2489,
2492, 2494, 2496, 2500, 2502, 2506, 2509, 2510,
2512, 2520, 2530, 2537, 2543, 2553, 2559, 2569,
2576, 2580, 2590, 2598, 2605, 2616, 2628, 2639,
2648, 2654, 2661, 2671, 2675, 2685, 2689, 2696,
2701, 2710, 2714, 2725, 2733, 2739, 2743, 2749,
2755, 2762, 2768, 2774, 2778, 2785, 2789, 2792,
2795, 2799, 2805, 2810, 2816, 2821, 2826, 2829,
2829, 2831, 2833, 2837, 2845, 2850, 2857, 2862,
2866, 2869, 2877, 2885, 2889, 2898, 2901, 2912,
2917, 2925, 2931, 2937, 2943, 2948, 2956, 2962,
2968, 2972, 2976, 2979, 2982, 2982, 2986, 2988,
2997, 3003, 3010, 3017, 3022, 3031, 3038, 3046,
3054, 3059, 3067, 3076, 3082, 3086, 3097, 3103,
3109, 3119, 3124, 3127, 3135, 3147, 3152, 3163,
3166, 3171, 3173, 3179, 3182, 3187, 3191, 3194,
3200, 3205, 3208, 3211, 3216, 3217, 3222, 3227,
3232, 3240, 3245, 3249, 3253, 3257, 3261, 3263,
3266, 3267, 3270, 3274, 3278, 3280, 3284, 3286,
3289, 3292, 3295, 3299, 3299, 3299, 3299, 3299,
3299, 3299, 3299, 3305, 3310, 3315, 3316, 3323,
3326, 3336, 3341, 3343, 3348, 3354, 3362, 3366,
3370, 3375, 3386, 3396, 3402, 3409, 3418, 3424,
3431, 3440, 3446, 3457, 3467, 3472, 3480, 3490,
3502, 3508, 3514, 3519, 3528, 3539, 3547, 3554,
3558, 3564, 3572, 3584, 3588, 3595, 3601, 3608,
3614, 3619, 3626, 3635, 3639, 3643, 3649, 3651,
3653, 3658, 3662, 3667, 3675, 3680, 3688, 3696,
3698, 3702, 3705, 3712, 3716, 3720, 3723, 3727,
3732, 3738, 3739, 3741, 3744, 3747, 3750, 3754,
3754, 3754, 3757, 3758, 3760, 3762, 3763, 3767,
3774, 3779, 3786, 3791, 3799, 3805, 3809, 3818,
3821, 3823, 3830, 3832, 3835, 3839, 3841, 3846,
3851, 3854, 3858, 3861, 3864, 3866, 3868, 3872,
3873, 3874, 3875, 3878, 3888, 3892, 3898, 3905,
3911, 3918, 3920, 3923, 3929, 3936, 3941, 3949,
3959, 3963, 3971, 3979, 3986, 3987, 3990, 3994,
3995, 4000, 4004, 4009, 4015, 4022, 4026, 4031,
4032, 4038, 4041, 4048, 4054, 4055, 4063, 4064,
4068, 4074, 4077, 4080, 4081, 4081, 4084, 4091,
4095, 4098, 4105, 4112, 4122, 4129, 4134, 4137,
4142, 4146, 4155, 4164, 4175, 4184, 4191, 4199,
4205, 4211, 4218, 4227, 4235, 4239, 4243, 4246,
4250, 4257, 4261, 4263, 4267, 4275, 4284, 4287,
4294, 4301, 4304, 4311, 4317, 4321, 4325, 4333,
4337, 4343, 4346, 4353, 4359, 4360, 4363, 4372,
4378, 4384, 4394, 4401, 4410, 4415, 4421, 4426,
4428, 4433, 4441, 4445, 4452, 4457, 4461, 4463,
4467, 4469, 4471, 4472, 4477, 4482, 4491, 4498,
4501, 4507, 4508, 4509, 4515, 4522, 4527, 4535,
4539, 4546, 4550, 4552, 4559, 4560, 4562, 4562,
4570, 4577, 4586, 4592, 4594, 4595, 4599, 4605,
4609, 4616, 4622, 4631, 4637, 4643, 4652, 4655,
4662, 4665, 4671, 4681, 4684, 4688, 4693, 4698,
4702, 4706, 4708, 4711, 4713, 4716, 4716, 4716,
4721, 4722, 4731, 4736, 4743, 4750, 4756, 4759,
4761, 4762, 4762, 4767, 4767, 4767, 4767, 4768,
4769, 4769, 4769, 4771, 4771, 4771, 4771, 4771,
4771, 4771, 4771, 4771, 4772, 4774, 4774, 4774,
4774, 4775, 4777, 4792, 4805, 4821, 4836, 4850,
4865, 4880, 4894, 4910, 4919, 4922, 4930, 4936,
4941, 4945, 4950, 4954, 4961, 4966, 4970, 4976,
4981, 4990, 4999, 5007, 5016, 5023, 5027, 5029,
5031, 5039, 5047, 5058, 5067, 5076, 5084, 5095,
5105, 5112, 5121, 5123, 5128, 5133, 5140, 5146,
5156, 5161, 5166, 5170, 5173, 5180, 5180, 5185,
5190, 5198, 5205, 5214, 5225, 5230, 5233, 5236,
5245, 5253, 5261, 5273, 5282, 5292, 5303, 5311,
5316, 5328, 5335, 5341, 5350, 5356, 5365, 5380,
5385, 5389, 5395, 5400, 5412, 5419, 5425, 5430,
5436, 5445, 5449, 5454, 5458, 5459, 5465, 5471,
5477, 5484, 5487, 5489, 5496, 5501, 5507, 5512,
5515, 5516, 5521, 5524, 5531, 5535, 5538, 5540,
5546, 5550, 5552, 5557, 5560, 5563, 5567, 5569,
5571, 5572, 5574, 5576, 5578, 5581, 5586, 5590,
5598, 5605, 5609, 5617, 5623, 5632, 5640, 5644,
5652, 5660, 5668, 5674, 5680, 5685, 5688, 5693,
5700, 5706, 5709, 5714, 5718, 5722, 5726, 5730,
5732, 5734, 5738, 5740, 5743, 5748, 5751, 5761,
5767, 5774, 5777, 5781, 5784, 5790, 5796, 5801,
5809, 5811, 5817, 5821, 5824, 5826, 5828, 5829,
5831, 5834, 5834, 5834, 5834, 5847, 5854, 5859,
5860, 5862, 5862, 5862, 5863, 5864, 5864, 5864,
5865, 5867, 5868, 5868, 5868, 5868, 5868, 5868,
5868, 5869, 5869, 5870, 5870, 5870, 5870, 5872,
5872, 5872, 5872, 5887, 5901, 5916, 5931, 5946,
5962, 5977, 5992, 6008, 6016, 6021, 6023, 6027,
6031, 6036, 6038, 6038, 6038, 6038, 6038, 6038,
6038, 6038, 6041, 6056, 6072, 6088, 6100, 6109,
6115, 6120, 6123, 6124, 6133, 6140, 6148, 6155,
6163, 6168, 6172, 6179, 6184, 6193, 6196, 6201,
6207, 6211, 6215, 6218, 6220, 6221, 6221, 6221,
6221, 6221, 6221, 6221, 6221, 6221, 6221, 6230,
6246, 6260, 6274, 6278, 6284, 6291, 6303, 6313,
6319, 6331, 6342, 6349, 6355, 6361, 6368, 6374,
6378, 6383, 6390, 6398, 6409, 6416, 6423, 6431,
6435, 6437, 6439, 6442, 6444, 6453, 6459, 6469,
6481, 6487, 6492, 6498, 6501, 6508, 6510, 6510,
6510, 6510, 6510, 6510, 6510, 6510, 6510, 6510,
6511, 6512, 6512, 6513, 6513, 6514, 6514, 6514,
6514, 6514, 6514, 6514, 6515, 6515, 6515, 6516,
6516, 6517, 6517, 6517, 6517, 6518, 6519, 6519,
6519, 6519, 6519, 6519, 6520, 6520, 6520, 6521,
6521, 6532, 6545, 6561, 6577, 6591, 6604, 6619,
6634, 6650, 6665, 6679, 6693, 6706, 6720, 6734,
6740, 6740, 6740, 6740, 6740, 6740, 6740, 6747,
6762, 6777, 6789, 6793, 6803, 6814, 6819, 6827,
6832, 6838, 6844, 6845, 6852, 6863, 6865, 6870,
6875, 6885, 6889, 6891, 6896, 6896, 6902, 6907,
6911, 6914, 6918, 6923, 6925, 6925, 6925, 6932,
6935, 6935, 6935, 6935, 6935, 6935, 6935, 6935,
6946, 6960, 6973, 6980, 6980, 6981, 6990, 6992,
6992, 6993, 6994, 6995, 6995, 6995, 6997, 7008,
7019, 7030, 7040, 7042, 7042, 7042, 7042, 7042,
7042, 7042, 7042, 7042, 7042, 7042, 7042, 7046,
7061, 7073, 7086, 7094, 7101, 7107, 7111, 7116,
7118, 7121, 7123, 7125, 7128, 7138, 7140, 7140,
7140, 7140, 7140, 7140, 7140, 7140, 7140, 7140,
7140, 7140, 7140, 7140, 7140, 7140, 7140, 7140,
7142, 7151, 7161, 7174, 7187, 7198, 7210,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_gb2312_u_u[818] = {
0x00A4, 0x00A7, 0x00A8, 0x00B0, 0x00B1, 0x00D7, 0x00E0, 0x00E1,
0x00E8, 0x00E9, 0x00EA, 0x00EC, 0x00ED, 0x00F2, 0x00F3, 0x00F7,
0x00F9, 0x00FA, 0x00FC, 0x0101, 0x0113, 0x011B, 0x012B, 0x014D,
0x016B, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6, 0x01D8, 0x01DA,
0x01DC, 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, 0x2015, 0x2016, 0x2018,
0x2019, 0x201C, 0x201D, 0x2026, 0x2030, 0x2032, 0x2033, 0x203B,
0x2103, 0x2116, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165,
0x2166, 0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 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, 0x3000, 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,
0x30FB, 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,
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,
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,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_gb2312_u_mb[7445] = {
0xA1E8, 0xA1EC, 0xA1A7, 0xA1E3, 0xA1C0, 0xA1C1, 0xA8A4, 0xA8A2,
0xA8A8, 0xA8A6, 0xA8BA, 0xA8AC, 0xA8AA, 0xA8B0, 0xA8AE, 0xA1C2,
0xA8B4, 0xA8B2, 0xA8B9, 0xA8A1, 0xA8A5, 0xA8A7, 0xA8A9, 0xA8AD,
0xA8B1, 0xA8A3, 0xA8AB, 0xA8AF, 0xA8B3, 0xA8B5, 0xA8B6, 0xA8B7,
0xA8B8, 0xA1A6, 0xA1A5, 0xA6A1, 0xA6A2, 0xA6A3, 0xA6A4, 0xA6A5,
0xA6A6, 0xA6A7, 0xA6A8, 0xA6A9, 0xA6AA, 0xA6AB, 0xA6AC, 0xA6AD,
0xA6AE, 0xA6AF, 0xA6B0, 0xA6B1, 0xA6B2, 0xA6B3, 0xA6B4, 0xA6B5,
0xA6B6, 0xA6B7, 0xA6B8, 0xA6C1, 0xA6C2, 0xA6C3, 0xA6C4, 0xA6C5,
0xA6C6, 0xA6C7, 0xA6C8, 0xA6C9, 0xA6CA, 0xA6CB, 0xA6CC, 0xA6CD,
0xA6CE, 0xA6CF, 0xA6D0, 0xA6D1, 0xA6D2, 0xA6D3, 0xA6D4, 0xA6D5,
0xA6D6, 0xA6D7, 0xA6D8, 0xA7A7, 0xA7A1, 0xA7A2, 0xA7A3, 0xA7A4,
0xA7A5, 0xA7A6, 0xA7A8, 0xA7A9, 0xA7AA, 0xA7AB, 0xA7AC, 0xA7AD,
0xA7AE, 0xA7AF, 0xA7B0, 0xA7B1, 0xA7B2, 0xA7B3, 0xA7B4, 0xA7B5,
0xA7B6, 0xA7B7, 0xA7B8, 0xA7B9, 0xA7BA, 0xA7BB, 0xA7BC, 0xA7BD,
0xA7BE, 0xA7BF, 0xA7C0, 0xA7C1, 0xA7D1, 0xA7D2, 0xA7D3, 0xA7D4,
0xA7D5, 0xA7D6, 0xA7D8, 0xA7D9, 0xA7DA, 0xA7DB, 0xA7DC, 0xA7DD,
0xA7DE, 0xA7DF, 0xA7E0, 0xA7E1, 0xA7E2, 0xA7E3, 0xA7E4, 0xA7E5,
0xA7E6, 0xA7E7, 0xA7E8, 0xA7E9, 0xA7EA, 0xA7EB, 0xA7EC, 0xA7ED,
0xA7EE, 0xA7EF, 0xA7F0, 0xA7F1, 0xA7D7, 0xA1AA, 0xA1AC, 0xA1AE,
0xA1AF, 0xA1B0, 0xA1B1, 0xA1AD, 0xA1EB, 0xA1E4, 0xA1E5, 0xA1F9,
0xA1E6, 0xA1ED, 0xA2F1, 0xA2F2, 0xA2F3, 0xA2F4, 0xA2F5, 0xA2F6,
0xA2F7, 0xA2F8, 0xA2F9, 0xA2FA, 0xA2FB, 0xA2FC, 0xA1FB, 0xA1FC,
0xA1FA, 0xA1FD, 0xA1CA, 0xA1C7, 0xA1C6, 0xA1CC, 0xA1D8, 0xA1DE,
0xA1CF, 0xA1CE, 0xA1C4, 0xA1C5, 0xA1C9, 0xA1C8, 0xA1D2, 0xA1D3,
0xA1E0, 0xA1DF, 0xA1C3, 0xA1CB, 0xA1D7, 0xA1D6, 0xA1D5, 0xA1D9,
0xA1D4, 0xA1DC, 0xA1DD, 0xA1DA, 0xA1DB, 0xA1D1, 0xA1CD, 0xA1D0,
0xA2D9, 0xA2DA, 0xA2DB, 0xA2DC, 0xA2DD, 0xA2DE, 0xA2DF, 0xA2E0,
0xA2E1, 0xA2E2, 0xA2C5, 0xA2C6, 0xA2C7, 0xA2C8, 0xA2C9, 0xA2CA,
0xA2CB, 0xA2CC, 0xA2CD, 0xA2CE, 0xA2CF, 0xA2D0, 0xA2D1, 0xA2D2,
0xA2D3, 0xA2D4, 0xA2D5, 0xA2D6, 0xA2D7, 0xA2D8, 0xA2B1, 0xA2B2,
0xA2B3, 0xA2B4, 0xA2B5, 0xA2B6, 0xA2B7, 0xA2B8, 0xA2B9, 0xA2BA,
0xA2BB, 0xA2BC, 0xA2BD, 0xA2BE, 0xA2BF, 0xA2C0, 0xA2C1, 0xA2C2,
0xA2C3, 0xA2C4, 0xA9A4, 0xA9A5, 0xA9A6, 0xA9A7, 0xA9A8, 0xA9A9,
0xA9AA, 0xA9AB, 0xA9AC, 0xA9AD, 0xA9AE, 0xA9AF, 0xA9B0, 0xA9B1,
0xA9B2, 0xA9B3, 0xA9B4, 0xA9B5, 0xA9B6, 0xA9B7, 0xA9B8, 0xA9B9,
0xA9BA, 0xA9BB, 0xA9BC, 0xA9BD, 0xA9BE, 0xA9BF, 0xA9C0, 0xA9C1,
0xA9C2, 0xA9C3, 0xA9C4, 0xA9C5, 0xA9C6, 0xA9C7, 0xA9C8, 0xA9C9,
0xA9CA, 0xA9CB, 0xA9CC, 0xA9CD, 0xA9CE, 0xA9CF, 0xA9D0, 0xA9D1,
0xA9D2, 0xA9D3, 0xA9D4, 0xA9D5, 0xA9D6, 0xA9D7, 0xA9D8, 0xA9D9,
0xA9DA, 0xA9DB, 0xA9DC, 0xA9DD, 0xA9DE, 0xA9DF, 0xA9E0, 0xA9E1,
0xA9E2, 0xA9E3, 0xA9E4, 0xA9E5, 0xA9E6, 0xA9E7, 0xA9E8, 0xA9E9,
0xA9EA, 0xA9EB, 0xA9EC, 0xA9ED, 0xA9EE, 0xA9EF, 0xA1F6, 0xA1F5,
0xA1F8, 0xA1F7, 0xA1F4, 0xA1F3, 0xA1F0, 0xA1F2, 0xA1F1, 0xA1EF,
0xA1EE, 0xA1E2, 0xA1E1, 0xA1A1, 0xA1A2, 0xA1A3, 0xA1A8, 0xA1A9,
0xA1B4, 0xA1B5, 0xA1B6, 0xA1B7, 0xA1B8, 0xA1B9, 0xA1BA, 0xA1BB,
0xA1BE, 0xA1BF, 0xA1FE, 0xA1B2, 0xA1B3, 0xA1BC, 0xA1BD, 0xA4A1,
0xA4A2, 0xA4A3, 0xA4A4, 0xA4A5, 0xA4A6, 0xA4A7, 0xA4A8, 0xA4A9,
0xA4AA, 0xA4AB, 0xA4AC, 0xA4AD, 0xA4AE, 0xA4AF, 0xA4B0, 0xA4B1,
0xA4B2, 0xA4B3, 0xA4B4, 0xA4B5, 0xA4B6, 0xA4B7, 0xA4B8, 0xA4B9,
0xA4BA, 0xA4BB, 0xA4BC, 0xA4BD, 0xA4BE, 0xA4BF, 0xA4C0, 0xA4C1,
0xA4C2, 0xA4C3, 0xA4C4, 0xA4C5, 0xA4C6, 0xA4C7, 0xA4C8, 0xA4C9,
0xA4CA, 0xA4CB, 0xA4CC, 0xA4CD, 0xA4CE, 0xA4CF, 0xA4D0, 0xA4D1,
0xA4D2, 0xA4D3, 0xA4D4, 0xA4D5, 0xA4D6, 0xA4D7, 0xA4D8, 0xA4D9,
0xA4DA, 0xA4DB, 0xA4DC, 0xA4DD, 0xA4DE, 0xA4DF, 0xA4E0, 0xA4E1,
0xA4E2, 0xA4E3, 0xA4E4, 0xA4E5, 0xA4E6, 0xA4E7, 0xA4E8, 0xA4E9,
0xA4EA, 0xA4EB, 0xA4EC, 0xA4ED, 0xA4EE, 0xA4EF, 0xA4F0, 0xA4F1,
0xA4F2, 0xA4F3, 0xA5A1, 0xA5A2, 0xA5A3, 0xA5A4, 0xA5A5, 0xA5A6,
0xA5A7, 0xA5A8, 0xA5A9, 0xA5AA, 0xA5AB, 0xA5AC, 0xA5AD, 0xA5AE,
0xA5AF, 0xA5B0, 0xA5B1, 0xA5B2, 0xA5B3, 0xA5B4, 0xA5B5, 0xA5B6,
0xA5B7, 0xA5B8, 0xA5B9, 0xA5BA, 0xA5BB, 0xA5BC, 0xA5BD, 0xA5BE,
0xA5BF, 0xA5C0, 0xA5C1, 0xA5C2, 0xA5C3, 0xA5C4, 0xA5C5, 0xA5C6,
0xA5C7, 0xA5C8, 0xA5C9, 0xA5CA, 0xA5CB, 0xA5CC, 0xA5CD, 0xA5CE,
0xA5CF, 0xA5D0, 0xA5D1, 0xA5D2, 0xA5D3, 0xA5D4, 0xA5D5, 0xA5D6,
0xA5D7, 0xA5D8, 0xA5D9, 0xA5DA, 0xA5DB, 0xA5DC, 0xA5DD, 0xA5DE,
0xA5DF, 0xA5E0, 0xA5E1, 0xA5E2, 0xA5E3, 0xA5E4, 0xA5E5, 0xA5E6,
0xA5E7, 0xA5E8, 0xA5E9, 0xA5EA, 0xA5EB, 0xA5EC, 0xA5ED, 0xA5EE,
0xA5EF, 0xA5F0, 0xA5F1, 0xA5F2, 0xA5F3, 0xA5F4, 0xA5F5, 0xA5F6,
0xA1A4, 0xA8C5, 0xA8C6, 0xA8C7, 0xA8C8, 0xA8C9, 0xA8CA, 0xA8CB,
0xA8CC, 0xA8CD, 0xA8CE, 0xA8CF, 0xA8D0, 0xA8D1, 0xA8D2, 0xA8D3,
0xA8D4, 0xA8D5, 0xA8D6, 0xA8D7, 0xA8D8, 0xA8D9, 0xA8DA, 0xA8DB,
0xA8DC, 0xA8DD, 0xA8DE, 0xA8DF, 0xA8E0, 0xA8E1, 0xA8E2, 0xA8E3,
0xA8E4, 0xA8E5, 0xA8E6, 0xA8E7, 0xA8E8, 0xA8E9, 0xA2E5, 0xA2E6,
0xA2E7, 0xA2E8, 0xA2E9, 0xA2EA, 0xA2EB, 0xA2EC, 0xA2ED, 0xA2EE,
0xD2BB, 0xB6A1, 0xC6DF, 0xCDF2, 0xD5C9, 0xC8FD, 0xC9CF, 0xCFC2,
0xD8A2, 0xB2BB, 0xD3EB, 0xD8A4, 0xB3F3, 0xD7A8, 0xC7D2, 0xD8A7,
0xCAC0, 0xC7F0, 0xB1FB, 0xD2B5, 0xB4D4, 0xB6AB, 0xCBBF, 0xD8A9,
0xB6AA, 0xC1BD, 0xD1CF, 0xC9A5, 0xD8AD, 0xB8F6, 0xD1BE, 0xE3DC,
0xD6D0, 0xB7E1, 0xB4AE, 0xC1D9, 0xD8BC, 0xCDE8, 0xB5A4, 0xCEAA,
0xD6F7, 0xC0F6, 0xBED9, 0xD8AF, 0xC4CB, 0xBEC3, 0xD8B1, 0xC3B4,
0xD2E5, 0xD6AE, 0xCEDA, 0xD5A7, 0xBAF5, 0xB7A6, 0xC0D6, 0xC6B9,
0xC5D2, 0xC7C7, 0xB9D4, 0xB3CB, 0xD2D2, 0xD8BF, 0xBEC5, 0xC6F2,
0xD2B2, 0xCFB0, 0xCFE7, 0xCAE9, 0xD8C0, 0xC2F2, 0xC2D2, 0xC8E9,
0xC7AC, 0xC1CB, 0xD3E8, 0xD5F9, 0xCAC2, 0xB6FE, 0xD8A1, 0xD3DA,
0xBFF7, 0xD4C6, 0xBBA5, 0xD8C1, 0xCEE5, 0xBEAE, 0xD8A8, 0xD1C7,
0xD0A9, 0xD8BD, 0xD9EF, 0xCDF6, 0xBFBA, 0xBDBB, 0xBAA5, 0xD2E0,
0xB2FA, 0xBAE0, 0xC4B6, 0xCFED, 0xBEA9, 0xCDA4, 0xC1C1, 0xC7D7,
0xD9F1, 0xD9F4, 0xC8CB, 0xD8E9, 0xD2DA, 0xCAB2, 0xC8CA, 0xD8EC,
0xD8EA, 0xD8C6, 0xBDF6, 0xC6CD, 0xB3F0, 0xD8EB, 0xBDF1, 0xBDE9,
0xC8D4, 0xB4D3, 0xC2D8, 0xB2D6, 0xD7D0, 0xCACB, 0xCBFB, 0xD5CC,
0xB8B6, 0xCFC9, 0xD9DA, 0xD8F0, 0xC7AA, 0xD8EE, 0xB4FA, 0xC1EE,
0xD2D4, 0xD8ED, 0xD2C7, 0xD8EF, 0xC3C7, 0xD1F6, 0xD6D9, 0xD8F2,
0xD8F5, 0xBCFE, 0xBCDB, 0xC8CE, 0xB7DD, 0xB7C2, 0xC6F3, 0xD8F8,
0xD2C1, 0xCEE9, 0xBCBF, 0xB7FC, 0xB7A5, 0xD0DD, 0xD6DA, 0xD3C5,
0xBBEF, 0xBBE1, 0xD8F1, 0xC9A1, 0xCEB0, 0xB4AB, 0xD8F3, 0xC9CB,
0xD8F6, 0xC2D7, 0xD8F7, 0xCEB1, 0xD8F9, 0xB2AE, 0xB9C0, 0xD9A3,
0xB0E9, 0xC1E6, 0xC9EC, 0xCBC5, 0xCBC6, 0xD9A4, 0xB5E8, 0xB5AB,
0xCEBB, 0xB5CD, 0xD7A1, 0xD7F4, 0xD3D3, 0xCCE5, 0xBACE, 0xD9A2,
0xD9DC, 0xD3E0, 0xD8FD, 0xB7F0, 0xD7F7, 0xD8FE, 0xD8FA, 0xD9A1,
0xC4E3, 0xD3B6, 0xD8F4, 0xD9DD, 0xD8FB, 0xC5E5, 0xC0D0, 0xD1F0,
0xB0DB, 0xBCD1, 0xD9A6, 0xD9A5, 0xD9AC, 0xD9AE, 0xD9AB, 0xCAB9,
0xD9A9, 0xD6B6, 0xB3DE, 0xD9A8, 0xC0FD, 0xCACC, 0xD9AA, 0xD9A7,
0xD9B0, 0xB6B1, 0xB9A9, 0xD2C0, 0xCFC0, 0xC2C2, 0xBDC4, 0xD5EC,
0xB2E0, 0xC7C8, 0xBFEB, 0xD9AD, 0xD9AF, 0xCEEA, 0xBAEE, 0xC7D6,
0xB1E3, 0xB4D9, 0xB6ED, 0xD9B4, 0xBFA1, 0xD9DE, 0xC7CE, 0xC0FE,
0xD9B8, 0xCBD7, 0xB7FD, 0xD9B5, 0xD9B7, 0xB1A3, 0xD3E1, 0xD9B9,
0xD0C5, 0xD9B6, 0xD9B1, 0xD9B2, 0xC1A9, 0xD9B3, 0xBCF3, 0xD0DE,
0xB8A9, 0xBEE3, 0xD9BD, 0xD9BA, 0xB0B3, 0xD9C2, 0xD9C4, 0xB1B6,
0xD9BF, 0xB5B9, 0xBEF3, 0xCCC8, 0xBAF2, 0xD2D0, 0xD9C3, 0xBDE8,
0xB3AB, 0xD9C5, 0xBEEB, 0xD9C6, 0xD9BB, 0xC4DF, 0xD9BE, 0xD9C1,
0xD9C0, 0xD5AE, 0xD6B5, 0xC7E3, 0xD9C8, 0xBCD9, 0xD9CA, 0xD9BC,
0xD9CB, 0xC6AB, 0xD9C9, 0xD7F6, 0xCDA3, 0xBDA1, 0xD9CC, 0xC5BC,
0xCDB5, 0xD9CD, 0xD9C7, 0xB3A5, 0xBFFE, 0xB8B5, 0xC0FC, 0xB0F8,
0xB4F6, 0xD9CE, 0xD9CF, 0xB4A2, 0xD9D0, 0xB4DF, 0xB0C1, 0xD9D1,
0xC9B5, 0xCFF1, 0xD9D2, 0xC1C5, 0xD9D6, 0xC9AE, 0xD9D5, 0xD9D4,
0xD9D7, 0xCBDB, 0xBDA9, 0xC6A7, 0xD9D3, 0xD9D8, 0xD9D9, 0xC8E5,
0xC0DC, 0xB6F9, 0xD8A3, 0xD4CA, 0xD4AA, 0xD0D6, 0xB3E4, 0xD5D7,
0xCFC8, 0xB9E2, 0xBFCB, 0xC3E2, 0xB6D2, 0xCDC3, 0xD9EE, 0xD9F0,
0xB5B3, 0xB6B5, 0xBEA4, 0xC8EB, 0xC8AB, 0xB0CB, 0xB9AB, 0xC1F9,
0xD9E2, 0xC0BC, 0xB9B2, 0xB9D8, 0xD0CB, 0xB1F8, 0xC6E4, 0xBEDF,
0xB5E4, 0xD7C8, 0xD1F8, 0xBCE6, 0xCADE, 0xBCBD, 0xD9E6, 0xD8E7,
0xC4DA, 0xB8D4, 0xC8BD, 0xB2E1, 0xD4D9, 0xC3B0, 0xC3E1, 0xDAA2,
0xC8DF, 0xD0B4, 0xBEFC, 0xC5A9, 0xB9DA, 0xDAA3, 0xD4A9, 0xDAA4,
0xD9FB, 0xB6AC, 0xB7EB, 0xB1F9, 0xD9FC, 0xB3E5, 0xBEF6, 0xBFF6,
0xD2B1, 0xC0E4, 0xB6B3, 0xD9FE, 0xD9FD, 0xBEBB, 0xC6E0, 0xD7BC,
0xDAA1, 0xC1B9, 0xB5F2, 0xC1E8, 0xBCF5, 0xB4D5, 0xC1DD, 0xC4FD,
0xBCB8, 0xB7B2, 0xB7EF, 0xD9EC, 0xC6BE, 0xBFAD, 0xBBCB, 0xB5CA,
0xDBC9, 0xD0D7, 0xCDB9, 0xB0BC, 0xB3F6, 0xBBF7, 0xDBCA, 0xBAAF,
0xD4E4, 0xB5B6, 0xB5F3, 0xD8D6, 0xC8D0, 0xB7D6, 0xC7D0, 0xD8D7,
0xBFAF, 0xDBBB, 0xD8D8, 0xD0CC, 0xBBAE, 0xEBBE, 0xC1D0, 0xC1F5,
0xD4F2, 0xB8D5, 0xB4B4, 0xB3F5, 0xC9BE, 0xC5D0, 0xC5D9, 0xC0FB,
0xB1F0, 0xD8D9, 0xB9CE, 0xB5BD, 0xD8DA, 0xD6C6, 0xCBA2, 0xC8AF,
0xC9B2, 0xB4CC, 0xBFCC, 0xB9F4, 0xD8DB, 0xD8DC, 0xB6E7, 0xBCC1,
0xCCEA, 0xCFF7, 0xD8DD, 0xC7B0, 0xB9D0, 0xBDA3, 0xCCDE, 0xC6CA,
0xD8E0, 0xD8DE, 0xD8DF, 0xB0FE, 0xBEE7, 0xCAA3, 0xBCF4, 0xB8B1,
0xB8EE, 0xD8E2, 0xBDCB, 0xD8E4, 0xD8E3, 0xC5FC, 0xD8E5, 0xD8E6,
0xC1A6, 0xC8B0, 0xB0EC, 0xB9A6, 0xBCD3, 0xCEF1, 0xDBBD, 0xC1D3,
0xB6AF, 0xD6FA, 0xC5AC, 0xBDD9, 0xDBBE, 0xDBBF, 0xC0F8, 0xBEA2,
0xC0CD, 0xDBC0, 0xCAC6, 0xB2AA, 0xD3C2, 0xC3E3, 0xD1AB, 0xDBC2,
0xC0D5, 0xDBC3, 0xBFB1, 0xC4BC, 0xC7DA, 0xDBC4, 0xD9E8, 0xC9D7,
0xB9B4, 0xCEF0, 0xD4C8, 0xB0FC, 0xB4D2, 0xD0D9, 0xD9E9, 0xDECB,
0xD9EB, 0xD8B0, 0xBBAF, 0xB1B1, 0xB3D7, 0xD8CE, 0xD4D1, 0xBDB3,
0xBFEF, 0xCFBB, 0xD8D0, 0xB7CB, 0xD8D1, 0xC6A5, 0xC7F8, 0xD2BD,
0xD8D2, 0xC4E4, 0xCAAE, 0xC7A7, 0xD8A6, 0xC9FD, 0xCEE7, 0xBBDC,
0xB0EB, 0xBBAA, 0xD0AD, 0xB1B0, 0xD7E4, 0xD7BF, 0xB5A5, 0xC2F4,
0xC4CF, 0xB2A9, 0xB2B7, 0xB1E5, 0xDFB2, 0xD5BC, 0xBFA8, 0xC2AC,
0xD8D5, 0xC2B1, 0xD8D4, 0xCED4, 0xDAE0, 0xCEC0, 0xD8B4, 0xC3AE,
0xD3A1, 0xCEA3, 0xBCB4, 0xC8B4, 0xC2D1, 0xBEED, 0xD0B6, 0xDAE1,
0xC7E4, 0xB3A7, 0xB6F2, 0xCCFC, 0xC0FA, 0xC0F7, 0xD1B9, 0xD1E1,
0xD8C7, 0xB2DE, 0xC0E5, 0xBAF1, 0xD8C8, 0xD4AD, 0xCFE1, 0xD8C9,
0xD8CA, 0xCFC3, 0xB3F8, 0xBEC7, 0xD8CB, 0xDBCC, 0xC8A5, 0xCFD8,
0xC8FE, 0xB2CE, 0xD3D6, 0xB2E6, 0xBCB0, 0xD3D1, 0xCBAB, 0xB7B4,
0xB7A2, 0xCAE5, 0xC8A1, 0xCADC, 0xB1E4, 0xD0F0, 0xC5D1, 0xDBC5,
0xB5FE, 0xBFDA, 0xB9C5, 0xBEE4, 0xC1ED, 0xDFB6, 0xDFB5, 0xD6BB,
0xBDD0, 0xD5D9, 0xB0C8, 0xB6A3, 0xBFC9, 0xCCA8, 0xDFB3, 0xCAB7,
0xD3D2, 0xD8CF, 0xD2B6, 0xBAC5, 0xCBBE, 0xCCBE, 0xDFB7, 0xB5F0,
0xDFB4, 0xD3F5, 0xB3D4, 0xB8F7, 0xDFBA, 0xBACF, 0xBCAA, 0xB5F5,
0xCDAC, 0xC3FB, 0xBAF3, 0xC0F4, 0xCDC2, 0xCFF2, 0xDFB8, 0xCFC5,
0xC2C0, 0xDFB9, 0xC2F0, 0xBEFD, 0xC1DF, 0xCDCC, 0xD2F7, 0xB7CD,
0xDFC1, 0xDFC4, 0xB7F1, 0xB0C9, 0xB6D6, 0xB7D4, 0xBAAC, 0xCCFD,
0xBFD4, 0xCBB1, 0xC6F4, 0xD6A8, 0xDFC5, 0xCEE2, 0xB3B3, 0xCEFC,
0xB4B5, 0xCEC7, 0xBAF0, 0xCEE1, 0xD1BD, 0xDFC0, 0xB4F4, 0xB3CA,
0xB8E6, 0xDFBB, 0xC4C5, 0xDFBC, 0xDFBD, 0xDFBE, 0xC5BB, 0xDFBF,
0xDFC2, 0xD4B1, 0xDFC3, 0xC7BA, 0xCED8, 0xC4D8, 0xDFCA, 0xDFCF,
0xD6DC, 0xDFC9, 0xDFDA, 0xCEB6, 0xBAC7, 0xDFCE, 0xDFC8, 0xC5DE,
0xC9EB, 0xBAF4, 0xC3FC, 0xBED7, 0xDFC6, 0xDFCD, 0xC5D8, 0xD5A6,
0xBACD, 0xBECC, 0xD3BD, 0xB8C0, 0xD6E4, 0xDFC7, 0xB9BE, 0xBFA7,
0xC1FC, 0xDFCB, 0xDFCC, 0xDFD0, 0xDFDB, 0xDFE5, 0xDFD7, 0xDFD6,
0xD7C9, 0xDFE3, 0xDFE4, 0xE5EB, 0xD2A7, 0xDFD2, 0xBFA9, 0xD4DB,
0xBFC8, 0xDFD4, 0xCFCC, 0xDFDD, 0xD1CA, 0xDFDE, 0xB0A7, 0xC6B7,
0xDFD3, 0xBAE5, 0xB6DF, 0xCDDB, 0xB9FE, 0xD4D5, 0xDFDF, 0xCFEC,
0xB0A5, 0xDFE7, 0xDFD1, 0xD1C6, 0xDFD5, 0xDFD8, 0xDFD9, 0xDFDC,
0xBBA9, 0xDFE0, 0xDFE1, 0xDFE2, 0xDFE6, 0xDFE8, 0xD3B4, 0xB8E7,
0xC5B6, 0xDFEA, 0xC9DA, 0xC1A8, 0xC4C4, 0xBFDE, 0xCFF8, 0xD5DC,
0xDFEE, 0xB2B8, 0xBADF, 0xDFEC, 0xDBC1, 0xD1E4, 0xCBF4, 0xB4BD,
0xB0A6, 0xDFF1, 0xCCC6, 0xDFF2, 0xDFED, 0xDFE9, 0xDFEB, 0xDFEF,
0xDFF0, 0xBBBD, 0xDFF3, 0xDFF4, 0xBBA3, 0xCADB, 0xCEA8, 0xE0A7,
0xB3AA, 0xE0A6, 0xE0A1, 0xDFFE, 0xCDD9, 0xDFFC, 0xDFFA, 0xBFD0,
0xD7C4, 0xC9CC, 0xDFF8, 0xB0A1, 0xDFFD, 0xDFFB, 0xE0A2, 0xE0A8,
0xB7C8, 0xC6A1, 0xC9B6, 0xC0B2, 0xDFF5, 0xC5BE, 0xD8C4, 0xDFF9,
0xC4F6, 0xE0A3, 0xE0A4, 0xE0A5, 0xD0A5, 0xE0B4, 0xCCE4, 0xE0B1,
0xBFA6, 0xE0AF, 0xCEB9, 0xE0AB, 0xC9C6, 0xC0AE, 0xE0AE, 0xBAED,
0xBAB0, 0xE0A9, 0xDFF6, 0xE0B3, 0xE0B8, 0xB4AD, 0xE0B9, 0xCFB2,
0xBAC8, 0xE0B0, 0xD0FA, 0xE0AC, 0xD4FB, 0xDFF7, 0xC5E7, 0xE0AD,
0xD3F7, 0xE0B6, 0xE0B7, 0xE0C4, 0xD0E1, 0xE0BC, 0xE0C9, 0xE0CA,
0xE0BE, 0xE0AA, 0xC9A4, 0xE0C1, 0xE0B2, 0xCAC8, 0xE0C3, 0xE0B5,
0xCECB, 0xCBC3, 0xE0CD, 0xE0C6, 0xE0C2, 0xE0CB, 0xE0BA, 0xE0BF,
0xE0C0, 0xE0C5, 0xE0C7, 0xE0C8, 0xE0CC, 0xE0BB, 0xCBD4, 0xE0D5,
0xE0D6, 0xE0D2, 0xE0D0, 0xBCCE, 0xE0D1, 0xB8C2, 0xD8C5, 0xD0EA,
0xC2EF, 0xE0CF, 0xE0BD, 0xE0D4, 0xE0D3, 0xE0D7, 0xE0DC, 0xE0D8,
0xD6F6, 0xB3B0, 0xD7EC, 0xCBBB, 0xE0DA, 0xCEFB, 0xBAD9, 0xE0E1,
0xE0DD, 0xD2AD, 0xE0E2, 0xE0DB, 0xE0D9, 0xE0DF, 0xE0E0, 0xE0DE,
0xE0E4, 0xC6F7, 0xD8AC, 0xD4EB, 0xE0E6, 0xCAC9, 0xE0E5, 0xB8C1,
0xE0E7, 0xE0E8, 0xE0E9, 0xE0E3, 0xBABF, 0xCCE7, 0xE0EA, 0xCFF9,
0xE0EB, 0xC8C2, 0xBDC0, 0xC4D2, 0xE0EC, 0xE0ED, 0xC7F4, 0xCBC4,
0xE0EE, 0xBBD8, 0xD8B6, 0xD2F2, 0xE0EF, 0xCDC5, 0xB6DA, 0xE0F1,
0xD4B0, 0xC0A7, 0xB4D1, 0xCEA7, 0xE0F0, 0xE0F2, 0xB9CC, 0xB9FA,
0xCDBC, 0xE0F3, 0xC6D4, 0xE0F4, 0xD4B2, 0xC8A6, 0xE0F6, 0xE0F5,
0xE0F7, 0xCDC1, 0xCAA5, 0xD4DA, 0xDBD7, 0xDBD9, 0xDBD8, 0xB9E7,
0xDBDC, 0xDBDD, 0xB5D8, 0xDBDA, 0xDBDB, 0xB3A1, 0xDBDF, 0xBBF8,
0xD6B7, 0xDBE0, 0xBEF9, 0xB7BB, 0xDBD0, 0xCCAE, 0xBFB2, 0xBBB5,
0xD7F8, 0xBFD3, 0xBFE9, 0xBCE1, 0xCCB3, 0xDBDE, 0xB0D3, 0xCEEB,
0xB7D8, 0xD7B9, 0xC6C2, 0xC0A4, 0xCCB9, 0xDBE7, 0xDBE1, 0xC6BA,
0xDBE3, 0xDBE8, 0xC5F7, 0xDBEA, 0xDBE9, 0xBFC0, 0xDBE6, 0xDBE5,
0xB4B9, 0xC0AC, 0xC2A2, 0xDBE2, 0xDBE4, 0xD0CD, 0xDBED, 0xC0DD,
0xDBF2, 0xB6E2, 0xDBF3, 0xDBD2, 0xB9B8, 0xD4AB, 0xDBEC, 0xBFD1,
0xDBF0, 0xDBD1, 0xB5E6, 0xDBEB, 0xBFE5, 0xDBEE, 0xDBF1, 0xDBF9,
0xB9A1, 0xB0A3, 0xC2F1, 0xB3C7, 0xDBEF, 0xDBF8, 0xC6D2, 0xDBF4,
0xDBF5, 0xDBF7, 0xDBF6, 0xDBFE, 0xD3F2, 0xB2BA, 0xDBFD, 0xDCA4,
0xDBFB, 0xDBFA, 0xDBFC, 0xC5E0, 0xBBF9, 0xDCA3, 0xDCA5, 0xCCC3,
0xB6D1, 0xDDC0, 0xDCA1, 0xDCA2, 0xC7B5, 0xB6E9, 0xDCA7, 0xDCA6,
0xDCA9, 0xB1A4, 0xB5CC, 0xBFB0, 0xD1DF, 0xB6C2, 0xDCA8, 0xCBFA,
0xEBF3, 0xCBDC, 0xCBFE, 0xCCC1, 0xC8FB, 0xDCAA, 0xCCEE, 0xDCAB,
0xDBD3, 0xDCAF, 0xDCAC, 0xBEB3, 0xCAFB, 0xDCAD, 0xC9CA, 0xC4B9,
0xC7BD, 0xDCAE, 0xD4F6, 0xD0E6, 0xC4AB, 0xB6D5, 0xDBD4, 0xB1DA,
0xDBD5, 0xDBD6, 0xBABE, 0xC8C0, 0xCABF, 0xC8C9, 0xD7B3, 0xC9F9,
0xBFC7, 0xBAF8, 0xD2BC, 0xE2BA, 0xB4A6, 0xB1B8, 0xB8B4, 0xCFC4,
0xD9E7, 0xCFA6, 0xCDE2, 0xD9ED, 0xB6E0, 0xD2B9, 0xB9BB, 0xE2B9,
0xE2B7, 0xB4F3, 0xCCEC, 0xCCAB, 0xB7F2, 0xD8B2, 0xD1EB, 0xBABB,
0xCAA7, 0xCDB7, 0xD2C4, 0xBFE4, 0xBCD0, 0xB6E1, 0xDEC5, 0xDEC6,
0xDBBC, 0xD1D9, 0xC6E6, 0xC4CE, 0xB7EE, 0xB7DC, 0xBFFC, 0xD7E0,
0xC6F5, 0xB1BC, 0xDEC8, 0xBDB1, 0xCCD7, 0xDECA, 0xDEC9, 0xB5EC,
0xC9DD, 0xB0C2, 0xC5AE, 0xC5AB, 0xC4CC, 0xBCE9, 0xCBFD, 0xBAC3,
0xE5F9, 0xC8E7, 0xE5FA, 0xCDFD, 0xD7B1, 0xB8BE, 0xC2E8, 0xC8D1,
0xE5FB, 0xB6CA, 0xBCCB, 0xD1FD, 0xE6A1, 0xC3EE, 0xE6A4, 0xE5FE,
0xE6A5, 0xCDD7, 0xB7C1, 0xE5FC, 0xE5FD, 0xE6A3, 0xC4DD, 0xE6A8,
0xE6A7, 0xC3C3, 0xC6DE, 0xE6AA, 0xC4B7, 0xE6A2, 0xCABC, 0xBDE3,
0xB9C3, 0xE6A6, 0xD0D5, 0xCEAF, 0xE6A9, 0xE6B0, 0xD2A6, 0xBDAA,
0xE6AD, 0xE6AF, 0xC0D1, 0xD2CC, 0xBCA7, 0xE6B1, 0xD2F6, 0xD7CB,
0xCDFE, 0xCDDE, 0xC2A6, 0xE6AB, 0xE6AC, 0xBDBF, 0xE6AE, 0xE6B3,
0xE6B2, 0xE6B6, 0xE6B8, 0xC4EF, 0xC4C8, 0xBEEA, 0xC9EF, 0xE6B7,
0xB6F0, 0xC3E4, 0xD3E9, 0xE6B4, 0xE6B5, 0xC8A2, 0xE6BD, 0xE6B9,
0xC6C5, 0xCDF1, 0xE6BB, 0xE6BC, 0xBBE9, 0xE6BE, 0xE6BA, 0xC0B7,
0xD3A4, 0xE6BF, 0xC9F4, 0xE6C3, 0xE6C4, 0xD0F6, 0xC3BD, 0xC3C4,
0xE6C2, 0xE6C1, 0xE6C7, 0xCFB1, 0xEBF4, 0xE6CA, 0xE6C5, 0xBCDE,
0xC9A9, 0xBCB5, 0xCFD3, 0xE6C8, 0xE6C9, 0xE6CE, 0xE6D0, 0xE6D1,
0xE6CB, 0xB5D5, 0xE6CC, 0xE6CF, 0xC4DB, 0xE6C6, 0xE6CD, 0xE6D2,
0xE6D4, 0xE6D3, 0xE6D5, 0xD9F8, 0xE6D6, 0xE6D7, 0xD7D3, 0xE6DD,
0xE6DE, 0xBFD7, 0xD4D0, 0xD7D6, 0xB4E6, 0xCBEF, 0xE6DA, 0xD8C3,
0xD7CE, 0xD0A2, 0xC3CF, 0xE6DF, 0xBCBE, 0xB9C2, 0xE6DB, 0xD1A7,
0xBAA2, 0xC2CF, 0xD8AB, 0xCAEB, 0xE5EE, 0xE6DC, 0xB7F5, 0xC8E6,
0xC4F5, 0xE5B2, 0xC4FE, 0xCBFC, 0xE5B3, 0xD5AC, 0xD3EE, 0xCAD8,
0xB0B2, 0xCBCE, 0xCDEA, 0xBAEA, 0xE5B5, 0xE5B4, 0xD7DA, 0xB9D9,
0xD6E6, 0xB6A8, 0xCDF0, 0xD2CB, 0xB1A6, 0xCAB5, 0xB3E8, 0xC9F3,
0xBFCD, 0xD0FB, 0xCAD2, 0xE5B6, 0xBBC2, 0xCFDC, 0xB9AC, 0xD4D7,
0xBAA6, 0xD1E7, 0xCFFC, 0xBCD2, 0xE5B7, 0xC8DD, 0xBFED, 0xB1F6,
0xCBDE, 0xBCC5, 0xBCC4, 0xD2FA, 0xC3DC, 0xBFDC, 0xB8BB, 0xC3C2,
0xBAAE, 0xD4A2, 0xC7DE, 0xC4AF, 0xB2EC, 0xB9D1, 0xE5BB, 0xC1C8,
0xD5AF, 0xE5BC, 0xE5BE, 0xB4E7, 0xB6D4, 0xCBC2, 0xD1B0, 0xB5BC,
0xCAD9, 0xB7E2, 0xC9E4, 0xBDAB, 0xCEBE, 0xD7F0, 0xD0A1, 0xC9D9,
0xB6FB, 0xE6D8, 0xBCE2, 0xB3BE, 0xC9D0, 0xE6D9, 0xB3A2, 0xDECC,
0xD3C8, 0xDECD, 0xD2A2, 0xDECE, 0xBECD, 0xDECF, 0xCAAC, 0xD2FC,
0xB3DF, 0xE5EA, 0xC4E1, 0xBEA1, 0xCEB2, 0xC4F2, 0xBED6, 0xC6A8,
0xB2E3, 0xBED3, 0xC7FC, 0xCCEB, 0xBDEC, 0xCEDD, 0xCABA, 0xC6C1,
0xE5EC, 0xD0BC, 0xD5B9, 0xE5ED, 0xCAF4, 0xCDC0, 0xC2C5, 0xE5EF,
0xC2C4, 0xE5F0, 0xE5F8, 0xCDCD, 0xC9BD, 0xD2D9, 0xE1A8, 0xD3EC,
0xCBEA, 0xC6F1, 0xE1AC, 0xE1A7, 0xE1A9, 0xE1AA, 0xE1AF, 0xB2ED,
0xE1AB, 0xB8DA, 0xE1AD, 0xE1AE, 0xE1B0, 0xB5BA, 0xE1B1, 0xE1B3,
0xE1B8, 0xD1D2, 0xE1B6, 0xE1B5, 0xC1EB, 0xE1B7, 0xD4C0, 0xE1B2,
0xE1BA, 0xB0B6, 0xE1B4, 0xBFF9, 0xE1B9, 0xE1BB, 0xE1BE, 0xE1BC,
0xD6C5, 0xCFBF, 0xE1BD, 0xE1BF, 0xC2CD, 0xB6EB, 0xD3F8, 0xC7CD,
0xB7E5, 0xBEFE, 0xE1C0, 0xE1C1, 0xE1C7, 0xB3E7, 0xC6E9, 0xB4DE,
0xD1C2, 0xE1C8, 0xE1C6, 0xE1C5, 0xE1C3, 0xE1C2, 0xB1C0, 0xD5B8,
0xE1C4, 0xE1CB, 0xE1CC, 0xE1CA, 0xEFFA, 0xE1D3, 0xE1D2, 0xC7B6,
0xE1C9, 0xE1CE, 0xE1D0, 0xE1D4, 0xE1D1, 0xE1CD, 0xE1CF, 0xE1D5,
0xE1D6, 0xE1D7, 0xE1D8, 0xE1DA, 0xE1DB, 0xCEA1, 0xE7DD, 0xB4A8,
0xD6DD, 0xD1B2, 0xB3B2, 0xB9A4, 0xD7F3, 0xC7C9, 0xBEDE, 0xB9AE,
0xCED7, 0xB2EE, 0xDBCF, 0xBCBA, 0xD2D1, 0xCBC8, 0xB0CD, 0xCFEF,
0xD9E3, 0xBDED, 0xB1D2, 0xCAD0, 0xB2BC, 0xCBA7, 0xB7AB, 0xCAA6,
0xCFA3, 0xE0F8, 0xD5CA, 0xE0FB, 0xE0FA, 0xC5C1, 0xCCFB, 0xC1B1,
0xE0F9, 0xD6E3, 0xB2AF, 0xD6C4, 0xB5DB, 0xB4F8, 0xD6A1, 0xCFAF,
0xB0EF, 0xE0FC, 0xE1A1, 0xB3A3, 0xE0FD, 0xE0FE, 0xC3B1, 0xC3DD,
0xE1A2, 0xB7F9, 0xBBCF, 0xE1A3, 0xC4BB, 0xE1A4, 0xE1A5, 0xE1A6,
0xB4B1, 0xB8C9, 0xC6BD, 0xC4EA, 0xB2A2, 0xD0D2, 0xE7DB, 0xBBC3,
0xD3D7, 0xD3C4, 0xB9E3, 0xE2CF, 0xD7AF, 0xC7EC, 0xB1D3, 0xB4B2,
0xE2D1, 0xD0F2, 0xC2AE, 0xE2D0, 0xBFE2, 0xD3A6, 0xB5D7, 0xE2D2,
0xB5EA, 0xC3ED, 0xB8FD, 0xB8AE, 0xC5D3, 0xB7CF, 0xE2D4, 0xE2D3,
0xB6C8, 0xD7F9, 0xCDA5, 0xE2D8, 0xE2D6, 0xCAFC, 0xBFB5, 0xD3B9,
0xE2D5, 0xE2D7, 0xC1AE, 0xC0C8, 0xE2DB, 0xE2DA, 0xC0AA, 0xC1CE,
0xE2DC, 0xE2DD, 0xE2DE, 0xDBC8, 0xD1D3, 0xCDA2, 0xBDA8, 0xDEC3,
0xD8A5, 0xBFAA, 0xDBCD, 0xD2EC, 0xC6FA, 0xC5AA, 0xDEC4, 0xB1D7,
0xDFAE, 0xCABD, 0xDFB1, 0xB9AD, 0xD2FD, 0xB8A5, 0xBAEB, 0xB3DA,
0xB5DC, 0xD5C5, 0xC3D6, 0xCFD2, 0xBBA1, 0xE5F3, 0xE5F2, 0xE5F4,
0xCDE4, 0xC8F5, 0xB5AF, 0xC7BF, 0xE5F6, 0xECB0, 0xE5E6, 0xB9E9,
0xB5B1, 0xC2BC, 0xE5E8, 0xE5E7, 0xE5E9, 0xD2CD, 0xE1EA, 0xD0CE,
0xCDAE, 0xD1E5, 0xB2CA, 0xB1EB, 0xB1F2, 0xC5ED, 0xD5C3, 0xD3B0,
0xE1DC, 0xE1DD, 0xD2DB, 0xB3B9, 0xB1CB, 0xCDF9, 0xD5F7, 0xE1DE,
0xBEB6, 0xB4FD, 0xE1DF, 0xBADC, 0xE1E0, 0xBBB2, 0xC2C9, 0xE1E1,
0xD0EC, 0xCDBD, 0xE1E2, 0xB5C3, 0xC5C7, 0xE1E3, 0xE1E4, 0xD3F9,
0xE1E5, 0xD1AD, 0xE1E6, 0xCEA2, 0xE1E7, 0xB5C2, 0xE1E8, 0xBBD5,
0xD0C4, 0xE2E0, 0xB1D8, 0xD2E4, 0xE2E1, 0xBCC9, 0xC8CC, 0xE2E3,
0xECFE, 0xECFD, 0xDFAF, 0xE2E2, 0xD6BE, 0xCDFC, 0xC3A6, 0xE3C3,
0xD6D2, 0xE2E7, 0xE2E8, 0xD3C7, 0xE2EC, 0xBFEC, 0xE2ED, 0xE2E5,
0xB3C0, 0xC4EE, 0xE2EE, 0xD0C3, 0xBAF6, 0xE2E9, 0xB7DE, 0xBBB3,
0xCCAC, 0xCBCB, 0xE2E4, 0xE2E6, 0xE2EA, 0xE2EB, 0xE2F7, 0xE2F4,
0xD4F5, 0xE2F3, 0xC5AD, 0xD5FA, 0xC5C2, 0xB2C0, 0xE2EF, 0xE2F2,
0xC1AF, 0xCBBC, 0xB5A1, 0xE2F9, 0xBCB1, 0xE2F1, 0xD0D4, 0xD4B9,
0xE2F5, 0xB9D6, 0xE2F6, 0xC7D3, 0xE2F0, 0xD7DC, 0xEDA1, 0xE2F8,
0xEDA5, 0xE2FE, 0xCAD1, 0xC1B5, 0xBBD0, 0xBFD6, 0xBAE3, 0xCBA1,
0xEDA6, 0xEDA3, 0xEDA2, 0xBBD6, 0xEDA7, 0xD0F4, 0xEDA4, 0xBADE,
0xB6F7, 0xE3A1, 0xB6B2, 0xCCF1, 0xB9A7, 0xCFA2, 0xC7A1, 0xBFD2,
0xB6F1, 0xE2FA, 0xE2FB, 0xE2FD, 0xE2FC, 0xC4D5, 0xE3A2, 0xD3C1,
0xE3A7, 0xC7C4, 0xCFA4, 0xE3A9, 0xBAB7, 0xE3A8, 0xBBDA, 0xE3A3,
0xE3A4, 0xE3AA, 0xE3A6, 0xCEF2, 0xD3C6, 0xBBBC, 0xD4C3, 0xC4FA,
0xEDA8, 0xD0FC, 0xE3A5, 0xC3F5, 0xE3AD, 0xB1AF, 0xE3B2, 0xBCC2,
0xE3AC, 0xB5BF, 0xC7E9, 0xE3B0, 0xBEAA, 0xCDEF, 0xBBF3, 0xCCE8,
0xE3AF, 0xE3B1, 0xCFA7, 0xE3AE, 0xCEA9, 0xBBDD, 0xB5EB, 0xBEE5,
0xB2D2, 0xB3CD, 0xB1B9, 0xE3AB, 0xB2D1, 0xB5AC, 0xB9DF, 0xB6E8,
0xCFEB, 0xE3B7, 0xBBCC, 0xC8C7, 0xD0CA, 0xE3B8, 0xB3EE, 0xEDA9,
0xD3FA, 0xD3E4, 0xEDAA, 0xE3B9, 0xD2E2, 0xE3B5, 0xD3DE, 0xB8D0,
0xE3B3, 0xE3B6, 0xB7DF, 0xE3B4, 0xC0A2, 0xE3BA, 0xD4B8, 0xB4C8,
0xE3BB, 0xBBC5, 0xC9F7, 0xC9E5, 0xC4BD, 0xEDAB, 0xC2FD, 0xBBDB,
0xBFAE, 0xCEBF, 0xE3BC, 0xBFB6, 0xB1EF, 0xD4F7, 0xE3BE, 0xEDAD,
0xE3BF, 0xBAA9, 0xEDAC, 0xE3BD, 0xE3C0, 0xBAB6, 0xB6AE, 0xD0B8,
0xB0C3, 0xEDAE, 0xEDAF, 0xC0C1, 0xE3C1, 0xC5B3, 0xE3C2, 0xDCB2,
0xEDB0, 0xB8EA, 0xCEEC, 0xEAA7, 0xD0E7, 0xCAF9, 0xC8D6, 0xCFB7,
0xB3C9, 0xCED2, 0xBDE4, 0xE3DE, 0xBBF2, 0xEAA8, 0xD5BD, 0xC6DD,
0xEAA9, 0xEAAA, 0xEAAC, 0xEAAB, 0xEAAE, 0xEAAD, 0xBDD8, 0xEAAF,
0xC2BE, 0xB4C1, 0xB4F7, 0xBBA7, 0xECE6, 0xECE5, 0xB7BF, 0xCBF9,
0xB1E2, 0xECE7, 0xC9C8, 0xECE8, 0xECE9, 0xCAD6, 0xDED0, 0xB2C5,
0xD4FA, 0xC6CB, 0xB0C7, 0xB4F2, 0xC8D3, 0xCDD0, 0xBFB8, 0xBFDB,
0xC7A4, 0xD6B4, 0xC0A9, 0xDED1, 0xC9A8, 0xD1EF, 0xC5A4, 0xB0E7,
0xB3B6, 0xC8C5, 0xB0E2, 0xB7F6, 0xC5FA, 0xB6F3, 0xD5D2, 0xB3D0,
0xBCBC, 0xB3AD, 0xBEF1, 0xB0D1, 0xD2D6, 0xCAE3, 0xD7A5, 0xCDB6,
0xB6B6, 0xBFB9, 0xD5DB, 0xB8A7, 0xC5D7, 0xDED2, 0xBFD9, 0xC2D5,
0xC7C0, 0xBBA4, 0xB1A8, 0xC5EA, 0xC5FB, 0xCCA7, 0xB1A7, 0xB5D6,
0xC4A8, 0xDED3, 0xD1BA, 0xB3E9, 0xC3F2, 0xB7F7, 0xD6F4, 0xB5A3,
0xB2F0, 0xC4B4, 0xC4E9, 0xC0AD, 0xDED4, 0xB0E8, 0xC5C4, 0xC1E0,
0xB9D5, 0xBEDC, 0xCDD8, 0xB0CE, 0xCDCF, 0xDED6, 0xBED0, 0xD7BE,
0xDED5, 0xD5D0, 0xB0DD, 0xC4E2, 0xC2A3, 0xBCF0, 0xD3B5, 0xC0B9,
0xC5A1, 0xB2A6, 0xD4F1, 0xC0A8, 0xCAC3, 0xDED7, 0xD5FC, 0xB9B0,
0xC8AD, 0xCBA9, 0xDED9, 0xBFBD, 0xC6B4, 0xD7A7, 0xCAB0, 0xC4C3,
0xB3D6, 0xB9D2, 0xD6B8, 0xEAFC, 0xB0B4, 0xBFE6, 0xCCF4, 0xCDDA,
0xD6BF, 0xC2CE, 0xCECE, 0xCCA2, 0xD0AE, 0xC4D3, 0xB5B2, 0xDED8,
0xD5F5, 0xBCB7, 0xBBD3, 0xB0A4, 0xC5B2, 0xB4EC, 0xD5F1, 0xEAFD,
0xDEDA, 0xCDA6, 0xCDEC, 0xCEE6, 0xDEDC, 0xCDB1, 0xC0A6, 0xD7BD,
0xDEDB, 0xB0C6, 0xBAB4, 0xC9D3, 0xC4F3, 0xBEE8, 0xB2B6, 0xC0CC,
0xCBF0, 0xBCF1, 0xBBBB, 0xB5B7, 0xC5F5, 0xDEE6, 0xDEE3, 0xBEDD,
0xDEDF, 0xB4B7, 0xBDDD, 0xDEE0, 0xC4ED, 0xCFC6, 0xB5E0, 0xB6DE,
0xCADA, 0xB5F4, 0xDEE5, 0xD5C6, 0xDEE1, 0xCCCD, 0xC6FE, 0xC5C5,
0xD2B4, 0xBEF2, 0xC2D3, 0xCCBD, 0xB3B8, 0xBDD3, 0xBFD8, 0xCDC6,
0xD1DA, 0xB4EB, 0xDEE4, 0xDEDD, 0xDEE7, 0xEAFE, 0xC2B0, 0xDEE2,
0xD6C0, 0xB5A7, 0xB2F4, 0xDEE8, 0xDEF2, 0xDEED, 0xDEF1, 0xC8E0,
0xD7E1, 0xDEEF, 0xC3E8, 0xCCE1, 0xB2E5, 0xD2BE, 0xDEEE, 0xDEEB,
0xCED5, 0xB4A7, 0xBFAB, 0xBEBE, 0xBDD2, 0xDEE9, 0xD4AE, 0xDEDE,
0xDEEA, 0xC0BF, 0xDEEC, 0xB2F3, 0xB8E9, 0xC2A7, 0xBDC1, 0xDEF5,
0xDEF8, 0xB2AB, 0xB4A4, 0xB4EA, 0xC9A6, 0xDEF6, 0xCBD1, 0xB8E3,
0xDEF7, 0xDEFA, 0xDEF9, 0xCCC2, 0xB0E1, 0xB4EE, 0xE5BA, 0xD0AF,
0xB2EB, 0xEBA1, 0xDEF4, 0xC9E3, 0xDEF3, 0xB0DA, 0xD2A1, 0xB1F7,
0xCCAF, 0xDEF0, 0xCBA4, 0xD5AA, 0xDEFB, 0xB4DD, 0xC4A6, 0xDEFD,
0xC3FE, 0xC4A1, 0xDFA1, 0xC1CC, 0xDEFC, 0xBEEF, 0xC6B2, 0xB3C5,
0xC8F6, 0xCBBA, 0xDEFE, 0xDFA4, 0xD7B2, 0xB3B7, 0xC1C3, 0xC7CB,
0xB2A5, 0xB4E9, 0xD7AB, 0xC4EC, 0xDFA2, 0xDFA3, 0xDFA5, 0xBAB3,
0xDFA6, 0xC0DE, 0xC9C3, 0xB2D9, 0xC7E6, 0xDFA7, 0xC7DC, 0xDFA8,
0xEBA2, 0xCBD3, 0xDFAA, 0xDFA9, 0xB2C1, 0xC5CA, 0xDFAB, 0xD4DC,
0xC8C1, 0xDFAC, 0xBEF0, 0xDFAD, 0xD6A7, 0xEAB7, 0xEBB6, 0xCAD5,
0xD8FC, 0xB8C4, 0xB9A5, 0xB7C5, 0xD5FE, 0xB9CA, 0xD0A7, 0xF4CD,
0xB5D0, 0xC3F4, 0xBEC8, 0xEBB7, 0xB0BD, 0xBDCC, 0xC1B2, 0xB1D6,
0xB3A8, 0xB8D2, 0xC9A2, 0xB6D8, 0xEBB8, 0xBEB4, 0xCAFD, 0xC7C3,
0xD5FB, 0xB7F3, 0xCEC4, 0xD5AB, 0xB1F3, 0xECB3, 0xB0DF, 0xECB5,
0xB6B7, 0xC1CF, 0xF5FA, 0xD0B1, 0xD5E5, 0xCED3, 0xBDEF, 0xB3E2,
0xB8AB, 0xD5B6, 0xEDBD, 0xB6CF, 0xCBB9, 0xD0C2, 0xB7BD, 0xECB6,
0xCAA9, 0xC5D4, 0xECB9, 0xECB8, 0xC2C3, 0xECB7, 0xD0FD, 0xECBA,
0xECBB, 0xD7E5, 0xECBC, 0xECBD, 0xC6EC, 0xCEDE, 0xBCC8, 0xC8D5,
0xB5A9, 0xBEC9, 0xD6BC, 0xD4E7, 0xD1AE, 0xD0F1, 0xEAB8, 0xEAB9,
0xEABA, 0xBAB5, 0xCAB1, 0xBFF5, 0xCDFA, 0xEAC0, 0xB0BA, 0xEABE,
0xC0A5, 0xEABB, 0xB2FD, 0xC3F7, 0xBBE8, 0xD2D7, 0xCEF4, 0xEABF,
0xEABC, 0xEAC3, 0xD0C7, 0xD3B3, 0xB4BA, 0xC3C1, 0xD7F2, 0xD5D1,
0xCAC7, 0xEAC5, 0xEAC4, 0xEAC7, 0xEAC6, 0xD6E7, 0xCFD4, 0xEACB,
0xBBCE, 0xBDFA, 0xC9CE, 0xEACC, 0xC9B9, 0xCFFE, 0xEACA, 0xD4CE,
0xEACD, 0xEACF, 0xCDED, 0xEAC9, 0xEACE, 0xCEEE, 0xBBDE, 0xB3BF,
0xC6D5, 0xBEB0, 0xCEFA, 0xC7E7, 0xBEA7, 0xEAD0, 0xD6C7, 0xC1C0,
0xD4DD, 0xEAD1, 0xCFBE, 0xEAD2, 0xCAEE, 0xC5AF, 0xB0B5, 0xEAD4,
0xEAD3, 0xF4DF, 0xC4BA, 0xB1A9, 0xE5DF, 0xEAD5, 0xCAEF, 0xEAD6,
0xEAD7, 0xC6D8, 0xEAD8, 0xEAD9, 0xD4BB, 0xC7FA, 0xD2B7, 0xB8FC,
0xEAC2, 0xB2DC, 0xC2FC, 0xD4F8, 0xCCE6, 0xD7EE, 0xD4C2, 0xD3D0,
0xEBC3, 0xC5F3, 0xB7FE, 0xEBD4, 0xCBB7, 0xEBDE, 0xC0CA, 0xCDFB,
0xB3AF, 0xC6DA, 0xEBFC, 0xC4BE, 0xCEB4, 0xC4A9, 0xB1BE, 0xD4FD,
0xCAF5, 0xD6EC, 0xC6D3, 0xB6E4, 0xBBFA, 0xD0E0, 0xC9B1, 0xD4D3,
0xC8A8, 0xB8CB, 0xE8BE, 0xC9BC, 0xE8BB, 0xC0EE, 0xD0D3, 0xB2C4,
0xB4E5, 0xE8BC, 0xD5C8, 0xB6C5, 0xE8BD, 0xCAF8, 0xB8DC, 0xCCF5,
0xC0B4, 0xD1EE, 0xE8BF, 0xE8C2, 0xBABC, 0xB1AD, 0xBDDC, 0xEABD,
0xE8C3, 0xE8C6, 0xE8CB, 0xE8CC, 0xCBC9, 0xB0E5, 0xBCAB, 0xB9B9,
0xE8C1, 0xCDF7, 0xE8CA, 0xCEF6, 0xD5ED, 0xC1D6, 0xE8C4, 0xC3B6,
0xB9FB, 0xD6A6, 0xE8C8, 0xCAE0, 0xD4E6, 0xE8C0, 0xE8C5, 0xE8C7,
0xC7B9, 0xB7E3, 0xE8C9, 0xBFDD, 0xE8D2, 0xE8D7, 0xE8D5, 0xBCDC,
0xBCCF, 0xE8DB, 0xE8DE, 0xE8DA, 0xB1FA, 0xB0D8, 0xC4B3, 0xB8CC,
0xC6E2, 0xC8BE, 0xC8E1, 0xE8CF, 0xE8D4, 0xE8D6, 0xB9F1, 0xE8D8,
0xD7F5, 0xC4FB, 0xE8DC, 0xB2E9, 0xE8D1, 0xBCED, 0xBFC2, 0xE8CD,
0xD6F9, 0xC1F8, 0xB2F1, 0xE8DF, 0xCAC1, 0xE8D9, 0xD5A4, 0xB1EA,
0xD5BB, 0xE8CE, 0xE8D0, 0xB6B0, 0xE8D3, 0xE8DD, 0xC0B8, 0xCAF7,
0xCBA8, 0xC6DC, 0xC0F5, 0xE8E9, 0xD0A3, 0xE8F2, 0xD6EA, 0xE8E0,
0xE8E1, 0xD1F9, 0xBACB, 0xB8F9, 0xB8F1, 0xD4D4, 0xE8EF, 0xE8EE,
0xE8EC, 0xB9F0, 0xCCD2, 0xE8E6, 0xCEA6, 0xBFF2, 0xB0B8, 0xE8F1,
0xE8F0, 0xD7C0, 0xE8E4, 0xCDA9, 0xC9A3, 0xBBB8, 0xBDDB, 0xE8EA,
0xE8E2, 0xE8E3, 0xE8E5, 0xB5B5, 0xE8E7, 0xC7C5, 0xE8EB, 0xE8ED,
0xBDB0, 0xD7AE, 0xE8F8, 0xE8F5, 0xCDB0, 0xE8F6, 0xC1BA, 0xE8E8,
0xC3B7, 0xB0F0, 0xE8F4, 0xE8F7, 0xB9A3, 0xC9D2, 0xC3CE, 0xCEE0,
0xC0E6, 0xCBF3, 0xCCDD, 0xD0B5, 0xCAE1, 0xE8F3, 0xBCEC, 0xE8F9,
0xC3DE, 0xC6E5, 0xB9F7, 0xB0F4, 0xD7D8, 0xBCAC, 0xC5EF, 0xCCC4,
0xE9A6, 0xC9AD, 0xE9A2, 0xC0E2, 0xBFC3, 0xE8FE, 0xB9D7, 0xE8FB,
0xE9A4, 0xD2CE, 0xE9A3, 0xD6B2, 0xD7B5, 0xE9A7, 0xBDB7, 0xE8FC,
0xE8FD, 0xE9A1, 0xCDD6, 0xD2AC, 0xE9B2, 0xE9A9, 0xB4AA, 0xB4BB,
0xE9AB, 0xD0A8, 0xE9A5, 0xB3FE, 0xE9AC, 0xC0E3, 0xE9AA, 0xE9B9,
0xE9B8, 0xE9AE, 0xE8FA, 0xE9A8, 0xBFAC, 0xE9B1, 0xE9BA, 0xC2A5,
0xE9AF, 0xB8C5, 0xE9AD, 0xD3DC, 0xE9B4, 0xE9B5, 0xE9B7, 0xE9C7,
0xC0C6, 0xE9C5, 0xE9B0, 0xE9BB, 0xB0F1, 0xE9BC, 0xD5A5, 0xE9BE,
0xE9BF, 0xE9C1, 0xC1F1, 0xC8B6, 0xE9BD, 0xE9C2, 0xE9C3, 0xE9B3,
0xE9B6, 0xBBB1, 0xE9C0, 0xBCF7, 0xE9C4, 0xE9C6, 0xE9CA, 0xE9CE,
0xB2DB, 0xE9C8, 0xB7AE, 0xE9CB, 0xE9CC, 0xD5C1, 0xC4A3, 0xE9D8,
0xBAE1, 0xE9C9, 0xD3A3, 0xE9D4, 0xE9D7, 0xE9D0, 0xE9CF, 0xC7C1,
0xE9D2, 0xE9D9, 0xB3C8, 0xE9D3, 0xCFF0, 0xE9CD, 0xB3F7, 0xE9D6,
0xE9DA, 0xCCB4, 0xCFAD, 0xE9D5, 0xE9DC, 0xE9DB, 0xE9DE, 0xE9D1,
0xE9DD, 0xE9DF, 0xC3CA, 0xC7B7, 0xB4CE, 0xBBB6, 0xD0C0, 0xECA3,
0xC5B7, 0xD3FB, 0xECA4, 0xECA5, 0xC6DB, 0xBFEE, 0xECA6, 0xECA7,
0xD0AA, 0xC7B8, 0xB8E8, 0xECA8, 0xD6B9, 0xD5FD, 0xB4CB, 0xB2BD,
0xCEE4, 0xC6E7, 0xCDE1, 0xB4F5, 0xCBC0, 0xBCDF, 0xE9E2, 0xE9E3,
0xD1EA, 0xE9E5, 0xB4F9, 0xE9E4, 0xD1B3, 0xCAE2, 0xB2D0, 0xE9E8,
0xE9E6, 0xE9E7, 0xD6B3, 0xE9E9, 0xE9EA, 0xE9EB, 0xE9EC, 0xECAF,
0xC5B9, 0xB6CE, 0xD2F3, 0xB5EE, 0xBBD9, 0xECB1, 0xD2E3, 0xCEE3,
0xC4B8, 0xC3BF, 0xB6BE, 0xD8B9, 0xB1C8, 0xB1CF, 0xB1D1, 0xC5FE,
0xB1D0, 0xC3AB, 0xD5B1, 0xEBA4, 0xBAC1, 0xCCBA, 0xEBA5, 0xEBA7,
0xEBA8, 0xEBA6, 0xEBA9, 0xEBAB, 0xEBAA, 0xEBAC, 0xCACF, 0xD8B5,
0xC3F1, 0xC3A5, 0xC6F8, 0xEBAD, 0xC4CA, 0xEBAE, 0xEBAF, 0xEBB0,
0xB7D5, 0xB7FA, 0xEBB1, 0xC7E2, 0xEBB3, 0xBAA4, 0xD1F5, 0xB0B1,
0xEBB2, 0xEBB4, 0xB5AA, 0xC2C8, 0xC7E8, 0xEBB5, 0xCBAE, 0xE3DF,
0xD3C0, 0xD9DB, 0xCDA1, 0xD6AD, 0xC7F3, 0xD9E0, 0xBBE3, 0xBABA,
0xE3E2, 0xCFAB, 0xE3E0, 0xC9C7, 0xBAB9, 0xD1B4, 0xE3E1, 0xC8EA,
0xB9AF, 0xBDAD, 0xB3D8, 0xCEDB, 0xCCC0, 0xE3E8, 0xE3E9, 0xCDF4,
0xCCAD, 0xBCB3, 0xE3EA, 0xE3EB, 0xD0DA, 0xC6FB, 0xB7DA, 0xC7DF,
0xD2CA, 0xCED6, 0xE3E4, 0xE3EC, 0xC9F2, 0xB3C1, 0xE3E7, 0xC6E3,
0xE3E5, 0xEDB3, 0xE3E6, 0xC9B3, 0xC5E6, 0xB9B5, 0xC3BB, 0xE3E3,
0xC5BD, 0xC1A4, 0xC2D9, 0xB2D7, 0xE3ED, 0xBBA6, 0xC4AD, 0xE3F0,
0xBEDA, 0xE3FB, 0xE3F5, 0xBAD3, 0xB7D0, 0xD3CD, 0xD6CE, 0xD5D3,
0xB9C1, 0xD5B4, 0xD1D8, 0xD0B9, 0xC7F6, 0xC8AA, 0xB2B4, 0xC3DA,
0xE3EE, 0xE3FC, 0xE3EF, 0xB7A8, 0xE3F7, 0xE3F4, 0xB7BA, 0xC5A2,
0xE3F6, 0xC5DD, 0xB2A8, 0xC6FC, 0xC4E0, 0xD7A2, 0xC0E1, 0xE3F9,
0xE3FA, 0xE3FD, 0xCCA9, 0xE3F3, 0xD3BE, 0xB1C3, 0xEDB4, 0xE3F1,
0xE3F2, 0xE3F8, 0xD0BA, 0xC6C3, 0xD4F3, 0xE3FE, 0xBDE0, 0xE4A7,
0xE4A6, 0xD1F3, 0xE4A3, 0xE4A9, 0xC8F7, 0xCFB4, 0xE4A8, 0xE4AE,
0xC2E5, 0xB6B4, 0xBDF2, 0xE4A2, 0xBAE9, 0xE4AA, 0xE4AC, 0xB6FD,
0xD6DE, 0xE4B2, 0xE4AD, 0xE4A1, 0xBBEE, 0xCDDD, 0xC7A2, 0xC5C9,
0xC1F7, 0xE4A4, 0xC7B3, 0xBDAC, 0xBDBD, 0xE4A5, 0xD7C7, 0xB2E2,
0xE4AB, 0xBCC3, 0xE4AF, 0xBBEB, 0xE4B0, 0xC5A8, 0xE4B1, 0xD5E3,
0xBFA3, 0xE4BA, 0xE4B7, 0xE4BB, 0xE4BD, 0xC6D6, 0xBAC6, 0xC0CB,
0xB8A1, 0xE4B4, 0xD4A1, 0xBAA3, 0xBDFE, 0xE4BC, 0xCDBF, 0xC4F9,
0xCFFB, 0xC9E6, 0xD3BF, 0xCFD1, 0xE4B3, 0xE4B8, 0xE4B9, 0xCCE9,
0xCCCE, 0xC0D4, 0xE4B5, 0xC1B0, 0xE4B6, 0xCED0, 0xBBC1, 0xB5D3,
0xC8F3, 0xBDA7, 0xD5C7, 0xC9AC, 0xB8A2, 0xE4CA, 0xE4CC, 0xD1C4,
0xD2BA, 0xBAAD, 0xBAD4, 0xE4C3, 0xB5ED, 0xD7CD, 0xE4C0, 0xCFFD,
0xE4BF, 0xC1DC, 0xCCCA, 0xCAE7, 0xC4D7, 0xCCD4, 0xE4C8, 0xE4C7,
0xE4C1, 0xE4C4, 0xB5AD, 0xD3D9, 0xE4C6, 0xD2F9, 0xB4E3, 0xBBB4,
0xC9EE, 0xB4BE, 0xBBEC, 0xD1CD, 0xCCED, 0xEDB5, 0xC7E5, 0xD4A8,
0xE4CB, 0xD7D5, 0xE4C2, 0xBDA5, 0xE4C5, 0xD3E6, 0xE4C9, 0xC9F8,
0xE4BE, 0xD3E5, 0xC7FE, 0xB6C9, 0xD4FC, 0xB2B3, 0xE4D7, 0xCEC2,
0xE4CD, 0xCEBC, 0xB8DB, 0xE4D6, 0xBFCA, 0xD3CE, 0xC3EC, 0xC5C8,
0xE4D8, 0xCDC4, 0xE4CF, 0xE4D4, 0xE4D5, 0xBAFE, 0xCFE6, 0xD5BF,
0xE4D2, 0xE4D0, 0xE4CE, 0xCDE5, 0xCAAA, 0xC0A3, 0xBDA6, 0xE4D3,
0xB8C8, 0xE4E7, 0xD4B4, 0xE4DB, 0xC1EF, 0xE4E9, 0xD2E7, 0xE4DF,
0xE4E0, 0xCFAA, 0xCBDD, 0xE4DA, 0xE4D1, 0xE4E5, 0xC8DC, 0xE4E3,
0xC4E7, 0xE4E2, 0xE4E1, 0xB3FC, 0xE4E8, 0xB5E1, 0xD7CC, 0xE4E6,
0xBBAC, 0xD7D2, 0xCCCF, 0xEBF8, 0xE4E4, 0xB9F6, 0xD6CD, 0xE4D9,
0xE4DC, 0xC2FA, 0xE4DE, 0xC2CB, 0xC0C4, 0xC2D0, 0xB1F5, 0xCCB2,
0xB5CE, 0xE4EF, 0xC6AF, 0xC6E1, 0xE4F5, 0xC2A9, 0xC0EC, 0xD1DD,
0xE4EE, 0xC4AE, 0xE4ED, 0xE4F6, 0xE4F4, 0xC2FE, 0xE4DD, 0xE4F0,
0xCAFE, 0xD5C4, 0xE4F1, 0xD1FA, 0xE4EB, 0xE4EC, 0xE4F2, 0xCEAB,
0xC5CB, 0xC7B1, 0xC2BA, 0xE4EA, 0xC1CA, 0xCCB6, 0xB3B1, 0xE4FB,
0xE4F3, 0xE4FA, 0xE4FD, 0xE4FC, 0xB3CE, 0xB3BA, 0xE4F7, 0xE4F9,
0xE4F8, 0xC5EC, 0xC0BD, 0xD4E8, 0xE5A2, 0xB0C4, 0xE5A4, 0xE5A3,
0xBCA4, 0xE5A5, 0xE5A1, 0xE4FE, 0xB1F4, 0xE5A8, 0xE5A9, 0xE5A6,
0xE5A7, 0xE5AA, 0xC6D9, 0xE5AB, 0xE5AD, 0xE5AC, 0xE5AF, 0xE5AE,
0xB9E0, 0xE5B0, 0xE5B1, 0xBBF0, 0xECE1, 0xC3F0, 0xB5C6, 0xBBD2,
0xC1E9, 0xD4EE, 0xBEC4, 0xD7C6, 0xD4D6, 0xB2D3, 0xECBE, 0xEAC1,
0xC2AF, 0xB4B6, 0xD1D7, 0xB3B4, 0xC8B2, 0xBFBB, 0xECC0, 0xD6CB,
0xECBF, 0xECC1, 0xECC5, 0xBEE6, 0xCCBF, 0xC5DA, 0xBEBC, 0xECC6,
0xB1FE, 0xECC4, 0xD5A8, 0xB5E3, 0xECC2, 0xC1B6, 0xB3E3, 0xECC3,
0xCBB8, 0xC0C3, 0xCCFE, 0xC1D2, 0xECC8, 0xBAE6, 0xC0D3, 0xD6F2,
0xD1CC, 0xBFBE, 0xB7B3, 0xC9D5, 0xECC7, 0xBBE2, 0xCCCC, 0xBDFD,
0xC8C8, 0xCFA9, 0xCDE9, 0xC5EB, 0xB7E9, 0xD1C9, 0xBAB8, 0xECC9,
0xECCA, 0xBBC0, 0xECCB, 0xECE2, 0xB1BA, 0xB7D9, 0xBDB9, 0xECCC,
0xD1E6, 0xECCD, 0xC8BB, 0xECD1, 0xECD3, 0xBBCD, 0xBCE5, 0xECCF,
0xC9B7, 0xC3BA, 0xECE3, 0xD5D5, 0xECD0, 0xD6F3, 0xECD2, 0xECCE,
0xECD4, 0xECD5, 0xC9BF, 0xCFA8, 0xD0DC, 0xD1AC, 0xC8DB, 0xECD6,
0xCEF5, 0xCAEC, 0xECDA, 0xECD9, 0xB0BE, 0xECD7, 0xECD8, 0xECE4,
0xC8BC, 0xC1C7, 0xECDC, 0xD1E0, 0xECDB, 0xD4EF, 0xECDD, 0xDBC6,
0xECDE, 0xB1AC, 0xECDF, 0xECE0, 0xD7A6, 0xC5C0, 0xEBBC, 0xB0AE,
0xBEF4, 0xB8B8, 0xD2AF, 0xB0D6, 0xB5F9, 0xD8B3, 0xCBAC, 0xE3DD,
0xC6AC, 0xB0E6, 0xC5C6, 0xEBB9, 0xEBBA, 0xEBBB, 0xD1C0, 0xC5A3,
0xEAF2, 0xC4B2, 0xC4B5, 0xC0CE, 0xEAF3, 0xC4C1, 0xCEEF, 0xEAF0,
0xEAF4, 0xC9FC, 0xC7A3, 0xCCD8, 0xCEFE, 0xEAF5, 0xEAF6, 0xCFAC,
0xC0E7, 0xEAF7, 0xB6BF, 0xEAF8, 0xEAF9, 0xEAFA, 0xEAFB, 0xEAF1,
0xC8AE, 0xE1EB, 0xB7B8, 0xE1EC, 0xE1ED, 0xD7B4, 0xE1EE, 0xE1EF,
0xD3CC, 0xE1F1, 0xBFF1, 0xE1F0, 0xB5D2, 0xB1B7, 0xE1F3, 0xE1F2,
0xBAFC, 0xE1F4, 0xB9B7, 0xBED1, 0xC4FC, 0xBADD, 0xBDC6, 0xE1F5,
0xE1F7, 0xB6C0, 0xCFC1, 0xCAA8, 0xE1F6, 0xD5F8, 0xD3FC, 0xE1F8,
0xE1FC, 0xE1F9, 0xE1FA, 0xC0EA, 0xE1FE, 0xE2A1, 0xC0C7, 0xE1FB,
0xE1FD, 0xE2A5, 0xC1D4, 0xE2A3, 0xE2A8, 0xB2FE, 0xE2A2, 0xC3CD,
0xB2C2, 0xE2A7, 0xE2A6, 0xE2A4, 0xE2A9, 0xE2AB, 0xD0C9, 0xD6ED,
0xC3A8, 0xE2AC, 0xCFD7, 0xE2AE, 0xBAEF, 0xE9E0, 0xE2AD, 0xE2AA,
0xBBAB, 0xD4B3, 0xE2B0, 0xE2AF, 0xE9E1, 0xE2B1, 0xE2B2, 0xE2B3,
0xCCA1, 0xE2B4, 0xE2B5, 0xD0FE, 0xC2CA, 0xD3F1, 0xCDF5, 0xE7E0,
0xE7E1, 0xBEC1, 0xC2EA, 0xE7E4, 0xE7E3, 0xCDE6, 0xC3B5, 0xE7E2,
0xBBB7, 0xCFD6, 0xC1E1, 0xE7E9, 0xE7E8, 0xE7F4, 0xB2A3, 0xE7EA,
0xE7E6, 0xE7EC, 0xE7EB, 0xC9BA, 0xD5E4, 0xE7E5, 0xB7A9, 0xE7E7,
0xE7EE, 0xE7F3, 0xD6E9, 0xE7ED, 0xE7F2, 0xE7F1, 0xB0E0, 0xE7F5,
0xC7F2, 0xC0C5, 0xC0ED, 0xC1F0, 0xE7F0, 0xE7F6, 0xCBF6, 0xE8A2,
0xE8A1, 0xD7C1, 0xE7FA, 0xE7F9, 0xE7FB, 0xE7F7, 0xE7FE, 0xE7FD,
0xE7FC, 0xC1D5, 0xC7D9, 0xC5FD, 0xC5C3, 0xC7ED, 0xE8A3, 0xE8A6,
0xE8A5, 0xE8A7, 0xBAF7, 0xE7F8, 0xE8A4, 0xC8F0, 0xC9AA, 0xE8A9,
0xB9E5, 0xD1FE, 0xE8A8, 0xE8AA, 0xE8AD, 0xE8AE, 0xC1A7, 0xE8AF,
0xE8B0, 0xE8AC, 0xE8B4, 0xE8AB, 0xE8B1, 0xE8B5, 0xE8B2, 0xE8B3,
0xE8B7, 0xE8B6, 0xB9CF, 0xF0AC, 0xF0AD, 0xC6B0, 0xB0EA, 0xC8BF,
0xCDDF, 0xCECD, 0xEAB1, 0xEAB2, 0xC6BF, 0xB4C9, 0xEAB3, 0xD5E7,
0xDDF9, 0xEAB4, 0xEAB5, 0xEAB6, 0xB8CA, 0xDFB0, 0xC9F5, 0xCCF0,
0xC9FA, 0xC9FB, 0xD3C3, 0xCBA6, 0xB8A6, 0xF0AE, 0xB1C2, 0xE5B8,
0xCCEF, 0xD3C9, 0xBCD7, 0xC9EA, 0xB5E7, 0xC4D0, 0xB5E9, 0xEEAE,
0xBBAD, 0xE7DE, 0xEEAF, 0xB3A9, 0xEEB2, 0xEEB1, 0xBDE7, 0xEEB0,
0xCEB7, 0xC5CF, 0xC1F4, 0xDBCE, 0xEEB3, 0xD0F3, 0xC2D4, 0xC6E8,
0xB7AC, 0xEEB4, 0xB3EB, 0xBBFB, 0xEEB5, 0xE7DC, 0xEEB6, 0xBDAE,
0xF1E2, 0xCAE8, 0xD2C9, 0xF0DA, 0xF0DB, 0xF0DC, 0xC1C6, 0xB8ED,
0xBECE, 0xF0DE, 0xC5B1, 0xF0DD, 0xD1F1, 0xF0E0, 0xB0CC, 0xBDEA,
0xD2DF, 0xF0DF, 0xB4AF, 0xB7E8, 0xF0E6, 0xF0E5, 0xC6A3, 0xF0E1,
0xF0E2, 0xB4C3, 0xF0E3, 0xD5EE, 0xCCDB, 0xBED2, 0xBCB2, 0xF0E8,
0xF0E7, 0xF0E4, 0xB2A1, 0xD6A2, 0xD3B8, 0xBEB7, 0xC8AC, 0xF0EA,
0xD1F7, 0xD6CC, 0xBADB, 0xF0E9, 0xB6BB, 0xCDB4, 0xC6A6, 0xC1A1,
0xF0EB, 0xF0EE, 0xF0ED, 0xF0F0, 0xF0EC, 0xBBBE, 0xF0EF, 0xCCB5,
0xF0F2, 0xB3D5, 0xB1D4, 0xF0F3, 0xF0F4, 0xF0F6, 0xB4E1, 0xF0F1,
0xF0F7, 0xF0FA, 0xF0F8, 0xF0F5, 0xF0FD, 0xF0F9, 0xF0FC, 0xF0FE,
0xF1A1, 0xCEC1, 0xF1A4, 0xF1A3, 0xC1F6, 0xF0FB, 0xCADD, 0xB4F1,
0xB1F1, 0xCCB1, 0xF1A6, 0xF1A7, 0xF1AC, 0xD5CE, 0xF1A9, 0xC8B3,
0xF1A2, 0xF1AB, 0xF1A8, 0xF1A5, 0xF1AA, 0xB0A9, 0xF1AD, 0xF1AF,
0xF1B1, 0xF1B0, 0xF1AE, 0xD1A2, 0xF1B2, 0xF1B3, 0xB9EF, 0xB5C7,
0xB0D7, 0xB0D9, 0xD4ED, 0xB5C4, 0xBDD4, 0xBBCA, 0xF0A7, 0xB8DE,
0xF0A8, 0xB0A8, 0xF0A9, 0xCDEE, 0xF0AA, 0xF0AB, 0xC6A4, 0xD6E5,
0xF1E4, 0xF1E5, 0xC3F3, 0xD3DB, 0xD6D1, 0xC5E8, 0xD3AF, 0xD2E6,
0xEEC1, 0xB0BB, 0xD5B5, 0xD1CE, 0xBCE0, 0xBAD0, 0xBFF8, 0xB8C7,
0xB5C1, 0xC5CC, 0xCAA2, 0xC3CB, 0xEEC2, 0xC4BF, 0xB6A2, 0xEDEC,
0xC3A4, 0xD6B1, 0xCFE0, 0xEDEF, 0xC5CE, 0xB6DC, 0xCAA1, 0xEDED,
0xEDF0, 0xEDF1, 0xC3BC, 0xBFB4, 0xEDEE, 0xEDF4, 0xEDF2, 0xD5E6,
0xC3DF, 0xEDF3, 0xEDF6, 0xD5A3, 0xD1A3, 0xEDF5, 0xC3D0, 0xEDF7,
0xBFF4, 0xBEEC, 0xEDF8, 0xCCF7, 0xD1DB, 0xD7C5, 0xD5F6, 0xEDFC,
0xEDFB, 0xEDF9, 0xEDFA, 0xEDFD, 0xBEA6, 0xCBAF, 0xEEA1, 0xB6BD,
0xEEA2, 0xC4C0, 0xEDFE, 0xBDDE, 0xB2C7, 0xB6C3, 0xEEA5, 0xD8BA,
0xEEA3, 0xEEA6, 0xC3E9, 0xB3F2, 0xEEA7, 0xEEA4, 0xCFB9, 0xEEA8,
0xC2F7, 0xEEA9, 0xEEAA, 0xDEAB, 0xC6B3, 0xC7C6, 0xD6F5, 0xB5C9,
0xCBB2, 0xEEAB, 0xCDAB, 0xEEAC, 0xD5B0, 0xEEAD, 0xF6C4, 0xDBC7,
0xB4A3, 0xC3AC, 0xF1E6, 0xCAB8, 0xD2D3, 0xD6AA, 0xEFF2, 0xBED8,
0xBDC3, 0xEFF3, 0xB6CC, 0xB0AB, 0xCAAF, 0xEDB6, 0xEDB7, 0xCEF9,
0xB7AF, 0xBFF3, 0xEDB8, 0xC2EB, 0xC9B0, 0xEDB9, 0xC6F6, 0xBFB3,
0xEDBC, 0xC5F8, 0xD1D0, 0xD7A9, 0xEDBA, 0xEDBB, 0xD1E2, 0xEDBF,
0xEDC0, 0xEDC4, 0xEDC8, 0xEDC6, 0xEDCE, 0xD5E8, 0xEDC9, 0xEDC7,
0xEDBE, 0xC5E9, 0xC6C6, 0xC9E9, 0xD4D2, 0xEDC1, 0xEDC2, 0xEDC3,
0xEDC5, 0xC0F9, 0xB4A1, 0xB9E8, 0xEDD0, 0xEDD1, 0xEDCA, 0xEDCF,
0xCEF8, 0xCBB6, 0xEDCC, 0xEDCD, 0xCFF5, 0xEDD2, 0xC1F2, 0xD3B2,
0xEDCB, 0xC8B7, 0xBCEF, 0xC5F0, 0xEDD6, 0xB5EF, 0xC2B5, 0xB0AD,
0xCBE9, 0xB1AE, 0xEDD4, 0xCDEB, 0xB5E2, 0xEDD5, 0xEDD3, 0xEDD7,
0xB5FA, 0xEDD8, 0xEDD9, 0xEDDC, 0xB1CC, 0xC5F6, 0xBCEE, 0xEDDA,
0xCCBC, 0xB2EA, 0xEDDB, 0xC4EB, 0xB4C5, 0xB0F5, 0xEDDF, 0xC0DA,
0xB4E8, 0xC5CD, 0xEDDD, 0xBFC4, 0xEDDE, 0xC4A5, 0xEDE0, 0xEDE1,
0xEDE3, 0xC1D7, 0xBBC7, 0xBDB8, 0xEDE2, 0xEDE4, 0xEDE6, 0xEDE5,
0xEDE7, 0xCABE, 0xECEA, 0xC0F1, 0xC9E7, 0xECEB, 0xC6EE, 0xECEC,
0xC6ED, 0xECED, 0xECF0, 0xD7E6, 0xECF3, 0xECF1, 0xECEE, 0xECEF,
0xD7A3, 0xC9F1, 0xCBEE, 0xECF4, 0xECF2, 0xCFE9, 0xECF6, 0xC6B1,
0xBCC0, 0xECF5, 0xB5BB, 0xBBF6, 0xECF7, 0xD9F7, 0xBDFB, 0xC2BB,
0xECF8, 0xECF9, 0xB8A3, 0xECFA, 0xECFB, 0xECFC, 0xD3ED, 0xD8AE,
0xC0EB, 0xC7DD, 0xBACC, 0xD0E3, 0xCBBD, 0xCDBA, 0xB8D1, 0xB1FC,
0xC7EF, 0xD6D6, 0xBFC6, 0xC3EB, 0xEFF5, 0xC3D8, 0xD7E2, 0xEFF7,
0xB3D3, 0xC7D8, 0xD1ED, 0xD6C8, 0xEFF8, 0xEFF6, 0xBBFD, 0xB3C6,
0xBDD5, 0xD2C6, 0xBBE0, 0xCFA1, 0xEFFC, 0xEFFB, 0xEFF9, 0xB3CC,
0xC9D4, 0xCBB0, 0xEFFE, 0xB0DE, 0xD6C9, 0xEFFD, 0xB3ED, 0xF6D5,
0xCEC8, 0xF0A2, 0xF0A1, 0xB5BE, 0xBCDA, 0xBBFC, 0xB8E5, 0xC4C2,
0xF0A3, 0xCBEB, 0xF0A6, 0xD1A8, 0xBEBF, 0xC7EE, 0xF1B6, 0xF1B7,
0xBFD5, 0xB4A9, 0xF1B8, 0xCDBB, 0xC7D4, 0xD5AD, 0xF1B9, 0xF1BA,
0xC7CF, 0xD2A4, 0xD6CF, 0xF1BB, 0xBDD1, 0xB4B0, 0xBEBD, 0xB4DC,
0xCED1, 0xBFDF, 0xF1BD, 0xBFFA, 0xF1BC, 0xF1BF, 0xF1BE, 0xF1C0,
0xF1C1, 0xC1FE, 0xC1A2, 0xCAFA, 0xD5BE, 0xBEBA, 0xBEB9, 0xD5C2,
0xBFA2, 0xCDAF, 0xF1B5, 0xBDDF, 0xB6CB, 0xD6F1, 0xF3C3, 0xF3C4,
0xB8CD, 0xF3C6, 0xF3C7, 0xB0CA, 0xF3C5, 0xF3C9, 0xCBF1, 0xF3CB,
0xD0A6, 0xB1CA, 0xF3C8, 0xF3CF, 0xB5D1, 0xF3D7, 0xF3D2, 0xF3D4,
0xF3D3, 0xB7FB, 0xB1BF, 0xF3CE, 0xF3CA, 0xB5DA, 0xF3D0, 0xF3D1,
0xF3D5, 0xF3CD, 0xBCE3, 0xC1FD, 0xF3D6, 0xF3DA, 0xF3CC, 0xB5C8,
0xBDEE, 0xF3DC, 0xB7A4, 0xBFF0, 0xD6FE, 0xCDB2, 0xB4F0, 0xB2DF,
0xF3D8, 0xF3D9, 0xC9B8, 0xF3DD, 0xF3DE, 0xF3E1, 0xF3DF, 0xF3E3,
0xF3E2, 0xF3DB, 0xBFEA, 0xB3EF, 0xF3E0, 0xC7A9, 0xBCF2, 0xF3EB,
0xB9BF, 0xF3E4, 0xB2AD, 0xBBFE, 0xCBE3, 0xF3ED, 0xF3E9, 0xB9DC,
0xF3EE, 0xF3E5, 0xF3E6, 0xF3EA, 0xC2E1, 0xF3EC, 0xF3EF, 0xF3E8,
0xBCFD, 0xCFE4, 0xF3F0, 0xF3E7, 0xF3F2, 0xD7AD, 0xC6AA, 0xF3F3,
0xF3F1, 0xC2A8, 0xB8DD, 0xF3F5, 0xF3F4, 0xB4DB, 0xF3F6, 0xF3F7,
0xF3F8, 0xC0BA, 0xC0E9, 0xC5F1, 0xF3FB, 0xF3FA, 0xB4D8, 0xF3FE,
0xF3F9, 0xF3FC, 0xF3FD, 0xF4A1, 0xF4A3, 0xBBC9, 0xF4A2, 0xF4A4,
0xB2BE, 0xF4A6, 0xF4A5, 0xBCAE, 0xC3D7, 0xD9E1, 0xC0E0, 0xF4CC,
0xD7D1, 0xB7DB, 0xF4CE, 0xC1A3, 0xC6C9, 0xB4D6, 0xD5B3, 0xF4D0,
0xF4CF, 0xF4D1, 0xCBDA, 0xF4D2, 0xD4C1, 0xD6E0, 0xB7E0, 0xC1B8,
0xC1BB, 0xF4D3, 0xBEAC, 0xB4E2, 0xF4D4, 0xF4D5, 0xBEAB, 0xF4D6,
0xF4DB, 0xF4D7, 0xF4DA, 0xBAFD, 0xF4D8, 0xF4D9, 0xB8E2, 0xCCC7,
0xF4DC, 0xB2DA, 0xC3D3, 0xD4E3, 0xBFB7, 0xF4DD, 0xC5B4, 0xF4E9,
0xCFB5, 0xCEC9, 0xCBD8, 0xCBF7, 0xBDF4, 0xD7CF, 0xC0DB, 0xD0F5,
0xF4EA, 0xF4EB, 0xF4EC, 0xF7E3, 0xB7B1, 0xF4ED, 0xD7EB, 0xF4EE,
0xE6F9, 0xBEC0, 0xE6FA, 0xBAEC, 0xE6FB, 0xCFCB, 0xE6FC, 0xD4BC,
0xBCB6, 0xE6FD, 0xE6FE, 0xBCCD, 0xC8D2, 0xCEB3, 0xE7A1, 0xB4BF,
0xE7A2, 0xC9B4, 0xB8D9, 0xC4C9, 0xD7DD, 0xC2DA, 0xB7D7, 0xD6BD,
0xCEC6, 0xB7C4, 0xC5A6, 0xE7A3, 0xCFDF, 0xE7A4, 0xE7A5, 0xE7A6,
0xC1B7, 0xD7E9, 0xC9F0, 0xCFB8, 0xD6AF, 0xD6D5, 0xE7A7, 0xB0ED,
0xE7A8, 0xE7A9, 0xC9DC, 0xD2EF, 0xBEAD, 0xE7AA, 0xB0F3, 0xC8DE,
0xBDE1, 0xE7AB, 0xC8C6, 0xE7AC, 0xBBE6, 0xB8F8, 0xD1A4, 0xE7AD,
0xC2E7, 0xBEF8, 0xBDCA, 0xCDB3, 0xE7AE, 0xE7AF, 0xBEEE, 0xD0E5,
0xCBE7, 0xCCD0, 0xBCCC, 0xE7B0, 0xBCA8, 0xD0F7, 0xE7B1, 0xD0F8,
0xE7B2, 0xE7B3, 0xB4C2, 0xE7B4, 0xE7B5, 0xC9FE, 0xCEAC, 0xC3E0,
0xE7B7, 0xB1C1, 0xB3F1, 0xE7B8, 0xE7B9, 0xD7DB, 0xD5C0, 0xE7BA,
0xC2CC, 0xD7BA, 0xE7BB, 0xE7BC, 0xE7BD, 0xBCEA, 0xC3E5, 0xC0C2,
0xE7BE, 0xE7BF, 0xBCA9, 0xE7C0, 0xE7C1, 0xE7B6, 0xB6D0, 0xE7C2,
0xE7C3, 0xE7C4, 0xBBBA, 0xB5DE, 0xC2C6, 0xB1E0, 0xE7C5, 0xD4B5,
0xE7C6, 0xB8BF, 0xE7C8, 0xE7C7, 0xB7EC, 0xE7C9, 0xB2F8, 0xE7CA,
0xE7CB, 0xE7CC, 0xE7CD, 0xE7CE, 0xE7CF, 0xE7D0, 0xD3A7, 0xCBF5,
0xE7D1, 0xE7D2, 0xE7D3, 0xE7D4, 0xC9C9, 0xE7D5, 0xE7D6, 0xE7D7,
0xE7D8, 0xE7D9, 0xBDC9, 0xE7DA, 0xF3BE, 0xB8D7, 0xC8B1, 0xF3BF,
0xF3C0, 0xF3C1, 0xB9DE, 0xCDF8, 0xD8E8, 0xBAB1, 0xC2DE, 0xEEB7,
0xB7A3, 0xEEB9, 0xEEB8, 0xB0D5, 0xEEBB, 0xD5D6, 0xD7EF, 0xD6C3,
0xEEBD, 0xCAF0, 0xEEBC, 0xEEBE, 0xEEC0, 0xEEBF, 0xD1F2, 0xC7BC,
0xC3C0, 0xB8E1, 0xC1E7, 0xF4C6, 0xD0DF, 0xF4C7, 0xCFDB, 0xC8BA,
0xF4C8, 0xF4C9, 0xF4CA, 0xF4CB, 0xD9FA, 0xB8FE, 0xE5F1, 0xD3F0,
0xF4E0, 0xCECC, 0xB3E1, 0xF1B4, 0xD2EE, 0xF4E1, 0xCFE8, 0xF4E2,
0xC7CC, 0xB5D4, 0xB4E4, 0xF4E4, 0xF4E3, 0xF4E5, 0xF4E6, 0xF4E7,
0xBAB2, 0xB0BF, 0xF4E8, 0xB7AD, 0xD2ED, 0xD2AB, 0xC0CF, 0xBFBC,
0xEBA3, 0xD5DF, 0xEAC8, 0xF1F3, 0xB6F8, 0xCBA3, 0xC4CD, 0xF1E7,
0xF1E8, 0xB8FB, 0xF1E9, 0xBAC4, 0xD4C5, 0xB0D2, 0xF1EA, 0xF1EB,
0xF1EC, 0xF1ED, 0xF1EE, 0xF1EF, 0xF1F1, 0xF1F0, 0xC5D5, 0xF1F2,
0xB6FA, 0xF1F4, 0xD2AE, 0xDEC7, 0xCBCA, 0xB3DC, 0xB5A2, 0xB9A2,
0xC4F4, 0xF1F5, 0xF1F6, 0xC1C4, 0xC1FB, 0xD6B0, 0xF1F7, 0xF1F8,
0xC1AA, 0xC6B8, 0xBEDB, 0xF1F9, 0xB4CF, 0xF1FA, 0xEDB2, 0xEDB1,
0xCBE0, 0xD2DE, 0xCBC1, 0xD5D8, 0xC8E2, 0xC0DF, 0xBCA1, 0xEBC1,
0xD0A4, 0xD6E2, 0xB6C7, 0xB8D8, 0xEBC0, 0xB8CE, 0xEBBF, 0xB3A6,
0xB9C9, 0xD6AB, 0xB7F4, 0xB7CA, 0xBCE7, 0xB7BE, 0xEBC6, 0xEBC7,
0xB0B9, 0xBFCF, 0xEBC5, 0xD3FD, 0xEBC8, 0xEBC9, 0xB7CE, 0xEBC2,
0xEBC4, 0xC9F6, 0xD6D7, 0xD5CD, 0xD0B2, 0xEBCF, 0xCEB8, 0xEBD0,
0xB5A8, 0xB1B3, 0xEBD2, 0xCCA5, 0xC5D6, 0xEBD3, 0xEBD1, 0xC5DF,
0xEBCE, 0xCAA4, 0xEBD5, 0xB0FB, 0xBAFA, 0xD8B7, 0xF1E3, 0xEBCA,
0xEBCB, 0xEBCC, 0xEBCD, 0xEBD6, 0xE6C0, 0xEBD9, 0xBFE8, 0xD2C8,
0xEBD7, 0xEBDC, 0xB8EC, 0xEBD8, 0xBDBA, 0xD0D8, 0xB0B7, 0xEBDD,
0xC4DC, 0xD6AC, 0xB4E0, 0xC2F6, 0xBCB9, 0xEBDA, 0xEBDB, 0xD4E0,
0xC6EA, 0xC4D4, 0xEBDF, 0xC5A7, 0xD9F5, 0xB2B1, 0xEBE4, 0xBDC5,
0xEBE2, 0xEBE3, 0xB8AC, 0xCDD1, 0xEBE5, 0xEBE1, 0xC1B3, 0xC6A2,
0xCCF3, 0xEBE6, 0xC0B0, 0xD2B8, 0xEBE7, 0xB8AF, 0xB8AD, 0xEBE8,
0xC7BB, 0xCDF3, 0xEBEA, 0xEBEB, 0xEBED, 0xD0C8, 0xEBF2, 0xEBEE,
0xEBF1, 0xC8F9, 0xD1FC, 0xEBEC, 0xEBE9, 0xB8B9, 0xCFD9, 0xC4E5,
0xEBEF, 0xEBF0, 0xCCDA, 0xCDC8, 0xB0F2, 0xEBF6, 0xEBF5, 0xB2B2,
0xB8E0, 0xEBF7, 0xB1EC, 0xCCC5, 0xC4A4, 0xCFA5, 0xEBF9, 0xECA2,
0xC5F2, 0xEBFA, 0xC9C5, 0xE2DF, 0xEBFE, 0xCDCE, 0xECA1, 0xB1DB,
0xD3B7, 0xD2DC, 0xEBFD, 0xEBFB, 0xB3BC, 0xEAB0, 0xD7D4, 0xF4AB,
0xB3F4, 0xD6C1, 0xD6C2, 0xD5E9, 0xBECA, 0xF4A7, 0xD2A8, 0xF4A8,
0xF4A9, 0xF4AA, 0xBECB, 0xD3DF, 0xC9E0, 0xC9E1, 0xF3C2, 0xCAE6,
0xCCF2, 0xE2B6, 0xCBB4, 0xCEE8, 0xD6DB, 0xF4AD, 0xF4AE, 0xF4AF,
0xF4B2, 0xBABD, 0xF4B3, 0xB0E3, 0xF4B0, 0xF4B1, 0xBDA2, 0xB2D5,
0xF4B6, 0xF4B7, 0xB6E6, 0xB2B0, 0xCFCF, 0xF4B4, 0xB4AC, 0xF4B5,
0xF4B8, 0xF4B9, 0xCDA7, 0xF4BA, 0xF4BB, 0xF4BC, 0xCBD2, 0xF4BD,
0xF4BE, 0xF4BF, 0xF4DE, 0xC1BC, 0xBCE8, 0xC9AB, 0xD1DE, 0xE5F5,
0xDCB3, 0xD2D5, 0xDCB4, 0xB0AC, 0xDCB5, 0xBDDA, 0xDCB9, 0xD8C2,
0xDCB7, 0xD3F3, 0xC9D6, 0xDCBA, 0xDCB6, 0xDCBB, 0xC3A2, 0xDCBC,
0xDCC5, 0xDCBD, 0xCEDF, 0xD6A5, 0xDCCF, 0xDCCD, 0xDCD2, 0xBDE6,
0xC2AB, 0xDCB8, 0xDCCB, 0xDCCE, 0xDCBE, 0xB7D2, 0xB0C5, 0xDCC7,
0xD0BE, 0xDCC1, 0xBBA8, 0xB7BC, 0xDCCC, 0xDCC6, 0xDCBF, 0xC7DB,
0xD1BF, 0xDCC0, 0xDCCA, 0xDCD0, 0xCEAD, 0xDCC2, 0xDCC3, 0xDCC8,
0xDCC9, 0xB2D4, 0xDCD1, 0xCBD5, 0xD4B7, 0xDCDB, 0xDCDF, 0xCCA6,
0xDCE6, 0xC3E7, 0xDCDC, 0xBFC1, 0xDCD9, 0xB0FA, 0xB9B6, 0xDCE5,
0xDCD3, 0xDCC4, 0xDCD6, 0xC8F4, 0xBFE0, 0xC9BB, 0xB1BD, 0xD3A2,
0xDCDA, 0xDCD5, 0xC6BB, 0xDCDE, 0xD7C2, 0xC3AF, 0xB7B6, 0xC7D1,
0xC3A9, 0xDCE2, 0xDCD8, 0xDCEB, 0xDCD4, 0xDCDD, 0xBEA5, 0xDCD7,
0xDCE0, 0xDCE3, 0xDCE4, 0xDCF8, 0xDCE1, 0xDDA2, 0xDCE7, 0xBCEB,
0xB4C4, 0xC3A3, 0xB2E7, 0xDCFA, 0xDCF2, 0xDCEF, 0xDCFC, 0xDCEE,
0xD2F0, 0xB2E8, 0xC8D7, 0xC8E3, 0xDCFB, 0xDCED, 0xDCF7, 0xDCF5,
0xBEA3, 0xDCF4, 0xB2DD, 0xDCF3, 0xBCF6, 0xDCE8, 0xBBC4, 0xC0F3,
0xBCD4, 0xDCE9, 0xDCEA, 0xDCF1, 0xDCF6, 0xDCF9, 0xB5B4, 0xC8D9,
0xBBE7, 0xDCFE, 0xDCFD, 0xD3AB, 0xDDA1, 0xDDA3, 0xDDA5, 0xD2F1,
0xDDA4, 0xDDA6, 0xDDA7, 0xD2A9, 0xBAC9, 0xDDA9, 0xDDB6, 0xDDB1,
0xDDB4, 0xDDB0, 0xC6CE, 0xC0F2, 0xC9AF, 0xDCEC, 0xDDAE, 0xDDB7,
0xDCF0, 0xDDAF, 0xDDB8, 0xDDAC, 0xDDB9, 0xDDB3, 0xDDAD, 0xC4AA,
0xDDA8, 0xC0B3, 0xC1AB, 0xDDAA, 0xDDAB, 0xDDB2, 0xBBF1, 0xDDB5,
0xD3A8, 0xDDBA, 0xDDBB, 0xC3A7, 0xDDD2, 0xDDBC, 0xDDD1, 0xB9BD,
0xBED5, 0xBEFA, 0xBACA, 0xDDCA, 0xDDC5, 0xDDBF, 0xB2CB, 0xDDC3,
0xDDCB, 0xB2A4, 0xDDD5, 0xDDBE, 0xC6D0, 0xDDD0, 0xDDD4, 0xC1E2,
0xB7C6, 0xDDCE, 0xDDCF, 0xDDC4, 0xDDBD, 0xDDCD, 0xCCD1, 0xDDC9,
0xDDC2, 0xC3C8, 0xC6BC, 0xCEAE, 0xDDCC, 0xDDC8, 0xDDC1, 0xDDC6,
0xC2DC, 0xD3A9, 0xD3AA, 0xDDD3, 0xCFF4, 0xC8F8, 0xDDE6, 0xDDC7,
0xDDE0, 0xC2E4, 0xDDE1, 0xDDD7, 0xD6F8, 0xDDD9, 0xDDD8, 0xB8F0,
0xDDD6, 0xC6CF, 0xB6AD, 0xDDE2, 0xBAF9, 0xD4E1, 0xDDE7, 0xB4D0,
0xDDDA, 0xBFFB, 0xDDE3, 0xDDDF, 0xDDDD, 0xB5D9, 0xDDDB, 0xDDDC,
0xDDDE, 0xBDAF, 0xDDE4, 0xDDE5, 0xDDF5, 0xC3C9, 0xCBE2, 0xDDF2,
0xD8E1, 0xC6D1, 0xDDF4, 0xD5F4, 0xDDF3, 0xDDF0, 0xDDEC, 0xDDEF,
0xDDE8, 0xD0EE, 0xC8D8, 0xDDEE, 0xDDE9, 0xDDEA, 0xCBF2, 0xDDED,
0xB1CD, 0xC0B6, 0xBCBB, 0xDDF1, 0xDDF7, 0xDDF6, 0xDDEB, 0xC5EE,
0xDDFB, 0xDEA4, 0xDEA3, 0xDDF8, 0xC3EF, 0xC2FB, 0xD5E1, 0xCEB5,
0xDDFD, 0xB2CC, 0xC4E8, 0xCADF, 0xC7BE, 0xDDFA, 0xDDFC, 0xDDFE,
0xDEA2, 0xB0AA, 0xB1CE, 0xDEAC, 0xDEA6, 0xBDB6, 0xC8EF, 0xDEA1,
0xDEA5, 0xDEA9, 0xDEA8, 0xDEA7, 0xDEAD, 0xD4CC, 0xDEB3, 0xDEAA,
0xDEAE, 0xC0D9, 0xB1A1, 0xDEB6, 0xDEB1, 0xDEB2, 0xD1A6, 0xDEB5,
0xDEAF, 0xDEB0, 0xD0BD, 0xDEB4, 0xCAED, 0xDEB9, 0xDEB8, 0xDEB7,
0xDEBB, 0xBDE5, 0xB2D8, 0xC3EA, 0xDEBA, 0xC5BA, 0xDEBC, 0xCCD9,
0xB7AA, 0xD4E5, 0xDEBD, 0xDEBF, 0xC4A2, 0xDEC1, 0xDEBE, 0xDEC0,
0xD5BA, 0xDEC2, 0xF2AE, 0xBBA2, 0xC2B2, 0xC5B0, 0xC2C7, 0xF2AF,
0xD0E9, 0xD3DD, 0xEBBD, 0xB3E6, 0xF2B0, 0xF2B1, 0xCAAD, 0xBAE7,
0xF2B3, 0xF2B5, 0xF2B4, 0xCBE4, 0xCFBA, 0xF2B2, 0xCAB4, 0xD2CF,
0xC2EC, 0xCEC3, 0xF2B8, 0xB0F6, 0xF2B7, 0xF2BE, 0xB2CF, 0xD1C1,
0xF2BA, 0xF2BC, 0xD4E9, 0xF2BB, 0xF2B6, 0xF2BF, 0xF2BD, 0xF2B9,
0xF2C7, 0xF2C4, 0xF2C6, 0xF2CA, 0xF2C2, 0xF2C0, 0xF2C5, 0xD6FB,
0xF2C1, 0xC7F9, 0xC9DF, 0xF2C8, 0xB9C6, 0xB5B0, 0xF2C3, 0xF2C9,
0xF2D0, 0xF2D6, 0xBBD7, 0xF2D5, 0xCDDC, 0xD6EB, 0xF2D2, 0xF2D4,
0xB8F2, 0xF2CB, 0xF2CE, 0xC2F9, 0xD5DD, 0xF2CC, 0xF2CD, 0xF2CF,
0xF2D3, 0xF2D9, 0xD3BC, 0xB6EA, 0xCAF1, 0xB7E4, 0xF2D7, 0xF2D8,
0xF2DA, 0xF2DD, 0xF2DB, 0xF2DC, 0xD1D1, 0xF2D1, 0xCDC9, 0xCECF,
0xD6A9, 0xF2E3, 0xC3DB, 0xF2E0, 0xC0AF, 0xF2EC, 0xF2DE, 0xF2E1,
0xF2E8, 0xF2E2, 0xF2E7, 0xF2E6, 0xF2E9, 0xF2DF, 0xF2E4, 0xF2EA,
0xD3AC, 0xF2E5, 0xB2F5, 0xF2F2, 0xD0AB, 0xF2F5, 0xBBC8, 0xF2F9,
0xF2F0, 0xF2F6, 0xF2F8, 0xF2FA, 0xF2F3, 0xF2F1, 0xBAFB, 0xB5FB,
0xF2EF, 0xF2F7, 0xF2ED, 0xF2EE, 0xF2EB, 0xF3A6, 0xF3A3, 0xF3A2,
0xF2F4, 0xC8DA, 0xF2FB, 0xF3A5, 0xC3F8, 0xF2FD, 0xF3A7, 0xF3A9,
0xF3A4, 0xF2FC, 0xF3AB, 0xF3AA, 0xC2DD, 0xF3AE, 0xF3B0, 0xF3A1,
0xF3B1, 0xF3AC, 0xF3AF, 0xF2FE, 0xF3AD, 0xF3B2, 0xF3B4, 0xF3A8,
0xF3B3, 0xF3B5, 0xD0B7, 0xF3B8, 0xD9F9, 0xF3B9, 0xF3B7, 0xC8E4,
0xF3B6, 0xF3BA, 0xF3BB, 0xB4C0, 0xEEC3, 0xF3BC, 0xF3BD, 0xD1AA,
0xF4AC, 0xD0C6, 0xD0D0, 0xD1DC, 0xCFCE, 0xBDD6, 0xD1C3, 0xBAE2,
0xE1E9, 0xD2C2, 0xF1C2, 0xB2B9, 0xB1ED, 0xF1C3, 0xC9C0, 0xB3C4,
0xD9F2, 0xCBA5, 0xF1C4, 0xD6D4, 0xF1C5, 0xF4C0, 0xF1C6, 0xD4AC,
0xF1C7, 0xB0C0, 0xF4C1, 0xF4C2, 0xB4FC, 0xC5DB, 0xCCBB, 0xD0E4,
0xCDE0, 0xF1C8, 0xD9F3, 0xB1BB, 0xCFAE, 0xB8A4, 0xF1CA, 0xF1CB,
0xB2C3, 0xC1D1, 0xD7B0, 0xF1C9, 0xF1CC, 0xF1CE, 0xD9F6, 0xD2E1,
0xD4A3, 0xF4C3, 0xC8B9, 0xF4C4, 0xF1CD, 0xF1CF, 0xBFE3, 0xF1D0,
0xF1D4, 0xF1D6, 0xF1D1, 0xC9D1, 0xC5E1, 0xC2E3, 0xB9FC, 0xF1D3,
0xF1D5, 0xB9D3, 0xF1DB, 0xBAD6, 0xB0FD, 0xF1D9, 0xF1D8, 0xF1D2,
0xF1DA, 0xF1D7, 0xC8EC, 0xCDCA, 0xF1DD, 0xE5BD, 0xF1DC, 0xF1DE,
0xF1DF, 0xCFE5, 0xF4C5, 0xBDF3, 0xF1E0, 0xF1E1, 0xCEF7, 0xD2AA,
0xF1FB, 0xB8B2, 0xBCFB, 0xB9DB, 0xB9E6, 0xC3D9, 0xCAD3, 0xEAE8,
0xC0C0, 0xBEF5, 0xEAE9, 0xEAEA, 0xEAEB, 0xEAEC, 0xEAED, 0xEAEE,
0xEAEF, 0xBDC7, 0xF5FB, 0xF5FD, 0xF5FE, 0xF5FC, 0xBDE2, 0xF6A1,
0xB4A5, 0xF6A2, 0xF6A3, 0xECB2, 0xD1D4, 0xD9EA, 0xF6A4, 0xEEBA,
0xD5B2, 0xD3FE, 0xCCDC, 0xCAC4, 0xE5C0, 0xF6A5, 0xBEAF, 0xC6A9,
0xDAA5, 0xBCC6, 0xB6A9, 0xB8BC, 0xC8CF, 0xBCA5, 0xDAA6, 0xDAA7,
0xCCD6, 0xC8C3, 0xDAA8, 0xC6FD, 0xD1B5, 0xD2E9, 0xD1B6, 0xBCC7,
0xBDB2, 0xBBE4, 0xDAA9, 0xDAAA, 0xD1C8, 0xDAAB, 0xD0ED, 0xB6EF,
0xC2DB, 0xCBCF, 0xB7ED, 0xC9E8, 0xB7C3, 0xBEF7, 0xD6A4, 0xDAAC,
0xDAAD, 0xC6C0, 0xD7E7, 0xCAB6, 0xD5A9, 0xCBDF, 0xD5EF, 0xDAAE,
0xD6DF, 0xB4CA, 0xDAB0, 0xDAAF, 0xD2EB, 0xDAB1, 0xDAB2, 0xDAB3,
0xCAD4, 0xDAB4, 0xCAAB, 0xDAB5, 0xDAB6, 0xB3CF, 0xD6EF, 0xDAB7,
0xBBB0, 0xB5AE, 0xDAB8, 0xDAB9, 0xB9EE, 0xD1AF, 0xD2E8, 0xDABA,
0xB8C3, 0xCFEA, 0xB2EF, 0xDABB, 0xDABC, 0xBDEB, 0xCEDC, 0xD3EF,
0xDABD, 0xCEF3, 0xDABE, 0xD3D5, 0xBBE5, 0xDABF, 0xCBB5, 0xCBD0,
0xDAC0, 0xC7EB, 0xD6EE, 0xDAC1, 0xC5B5, 0xB6C1, 0xDAC2, 0xB7CC,
0xBFCE, 0xDAC3, 0xDAC4, 0xCBAD, 0xDAC5, 0xB5F7, 0xDAC6, 0xC1C2,
0xD7BB, 0xDAC7, 0xCCB8, 0xD2EA, 0xC4B1, 0xDAC8, 0xB5FD, 0xBBD1,
0xDAC9, 0xD0B3, 0xDACA, 0xDACB, 0xCEBD, 0xDACC, 0xDACD, 0xDACE,
0xB2F7, 0xDAD1, 0xDACF, 0xD1E8, 0xDAD0, 0xC3D5, 0xDAD2, 0xDAD3,
0xDAD4, 0xDAD5, 0xD0BB, 0xD2A5, 0xB0F9, 0xDAD6, 0xC7AB, 0xDAD7,
0xBDF7, 0xC3A1, 0xDAD8, 0xDAD9, 0xC3FD, 0xCCB7, 0xDADA, 0xDADB,
0xC0BE, 0xC6D7, 0xDADC, 0xDADD, 0xC7B4, 0xDADE, 0xDADF, 0xB9C8,
0xBBED, 0xB6B9, 0xF4F8, 0xF4F9, 0xCDE3, 0xF5B9, 0xEBE0, 0xCFF3,
0xBBBF, 0xBAC0, 0xD4A5, 0xE1D9, 0xF5F4, 0xB1AA, 0xB2F2, 0xF5F5,
0xF5F7, 0xBAD1, 0xF5F6, 0xC3B2, 0xF5F9, 0xF5F8, 0xB1B4, 0xD5EA,
0xB8BA, 0xB9B1, 0xB2C6, 0xD4F0, 0xCFCD, 0xB0DC, 0xD5CB, 0xBBF5,
0xD6CA, 0xB7B7, 0xCCB0, 0xC6B6, 0xB1E1, 0xB9BA, 0xD6FC, 0xB9E1,
0xB7A1, 0xBCFA, 0xEADA, 0xEADB, 0xCCF9, 0xB9F3, 0xEADC, 0xB4FB,
0xC3B3, 0xB7D1, 0xBAD8, 0xEADD, 0xD4F4, 0xEADE, 0xBCD6, 0xBBDF,
0xEADF, 0xC1DE, 0xC2B8, 0xD4DF, 0xD7CA, 0xEAE0, 0xEAE1, 0xEAE4,
0xEAE2, 0xEAE3, 0xC9DE, 0xB8B3, 0xB6C4, 0xEAE5, 0xCAEA, 0xC9CD,
0xB4CD, 0xE2D9, 0xC5E2, 0xEAE6, 0xC0B5, 0xD7B8, 0xEAE7, 0xD7AC,
0xC8FC, 0xD8D3, 0xD8CD, 0xD4DE, 0xD4F9, 0xC9C4, 0xD3AE, 0xB8D3,
0xB3E0, 0xC9E2, 0xF4F6, 0xBAD5, 0xF4F7, 0xD7DF, 0xF4F1, 0xB8B0,
0xD5D4, 0xB8CF, 0xC6F0, 0xB3C3, 0xF4F2, 0xB3AC, 0xD4BD, 0xC7F7,
0xF4F4, 0xF4F3, 0xCCCB, 0xC8A4, 0xF4F5, 0xD7E3, 0xC5BF, 0xF5C0,
0xF5BB, 0xF5C3, 0xF5C2, 0xD6BA, 0xF5C1, 0xD4BE, 0xF5C4, 0xF5CC,
0xB0CF, 0xB5F8, 0xF5C9, 0xF5CA, 0xC5DC, 0xF5C5, 0xF5C6, 0xF5C7,
0xF5CB, 0xBEE0, 0xF5C8, 0xB8FA, 0xF5D0, 0xF5D3, 0xBFE7, 0xB9F2,
0xF5BC, 0xF5CD, 0xC2B7, 0xCCF8, 0xBCF9, 0xF5CE, 0xF5CF, 0xF5D1,
0xB6E5, 0xF5D2, 0xF5D5, 0xF5BD, 0xF5D4, 0xD3BB, 0xB3EC, 0xCCA4,
0xF5D6, 0xF5D7, 0xBEE1, 0xF5D8, 0xCCDF, 0xF5DB, 0xB2C8, 0xD7D9,
0xF5D9, 0xF5DA, 0xF5DC, 0xF5E2, 0xF5E0, 0xF5DF, 0xF5DD, 0xF5E1,
0xF5DE, 0xF5E4, 0xF5E5, 0xCCE3, 0xE5BF, 0xB5B8, 0xF5E3, 0xF5E8,
0xCCA3, 0xF5E6, 0xF5E7, 0xF5BE, 0xB1C4, 0xF5BF, 0xB5C5, 0xB2E4,
0xF5EC, 0xF5E9, 0xB6D7, 0xF5ED, 0xF5EA, 0xF5EB, 0xB4DA, 0xD4EA,
0xF5EE, 0xB3F9, 0xF5EF, 0xF5F1, 0xF5F0, 0xF5F2, 0xF5F3, 0xC9ED,
0xB9AA, 0xC7FB, 0xB6E3, 0xCCC9, 0xEAA6, 0xB3B5, 0xD4FE, 0xB9EC,
0xD0F9, 0xE9ED, 0xD7AA, 0xE9EE, 0xC2D6, 0xC8ED, 0xBAE4, 0xE9EF,
0xE9F0, 0xE9F1, 0xD6E1, 0xE9F2, 0xE9F3, 0xE9F5, 0xE9F4, 0xE9F6,
0xE9F7, 0xC7E1, 0xE9F8, 0xD4D8, 0xE9F9, 0xBDCE, 0xE9FA, 0xE9FB,
0xBDCF, 0xE9FC, 0xB8A8, 0xC1BE, 0xE9FD, 0xB1B2, 0xBBD4, 0xB9F5,
0xE9FE, 0xEAA1, 0xEAA2, 0xEAA3, 0xB7F8, 0xBCAD, 0xCAE4, 0xE0CE,
0xD4AF, 0xCFBD, 0xD5B7, 0xEAA4, 0xD5DE, 0xEAA5, 0xD0C1, 0xB9BC,
0xB4C7, 0xB1D9, 0xC0B1, 0xB1E6, 0xB1E7, 0xB1E8, 0xB3BD, 0xC8E8,
0xE5C1, 0xB1DF, 0xC1C9, 0xB4EF, 0xC7A8, 0xD3D8, 0xC6F9, 0xD1B8,
0xB9FD, 0xC2F5, 0xD3AD, 0xD4CB, 0xBDFC, 0xE5C2, 0xB7B5, 0xE5C3,
0xBBB9, 0xD5E2, 0xBDF8, 0xD4B6, 0xCEA5, 0xC1AC, 0xB3D9, 0xCCF6,
0xE5C6, 0xE5C4, 0xE5C8, 0xE5CA, 0xE5C7, 0xB5CF, 0xC6C8, 0xB5FC,
0xE5C5, 0xCAF6, 0xE5C9, 0xC3D4, 0xB1C5, 0xBCA3, 0xD7B7, 0xCDCB,
0xCBCD, 0xCACA, 0xCCD3, 0xE5CC, 0xE5CB, 0xC4E6, 0xD1A1, 0xD1B7,
0xE5CD, 0xE5D0, 0xCDB8, 0xD6F0, 0xE5CF, 0xB5DD, 0xCDBE, 0xE5D1,
0xB6BA, 0xCDA8, 0xB9E4, 0xCAC5, 0xB3D1, 0xCBD9, 0xD4EC, 0xE5D2,
0xB7EA, 0xE5CE, 0xE5D5, 0xB4FE, 0xE5D6, 0xE5D3, 0xE5D4, 0xD2DD,
0xC2DF, 0xB1C6, 0xD3E2, 0xB6DD, 0xCBEC, 0xE5D7, 0xD3F6, 0xB1E9,
0xB6F4, 0xE5DA, 0xE5D8, 0xE5D9, 0xB5C0, 0xD2C5, 0xE5DC, 0xE5DE,
0xE5DD, 0xC7B2, 0xD2A3, 0xE5DB, 0xD4E2, 0xD5DA, 0xE5E0, 0xD7F1,
0xE5E1, 0xB1DC, 0xD1FB, 0xE5E2, 0xE5E4, 0xE5E3, 0xE5E5, 0xD2D8,
0xB5CB, 0xE7DF, 0xDAF5, 0xDAF8, 0xDAF6, 0xDAF7, 0xDAFA, 0xD0CF,
0xC4C7, 0xB0EE, 0xD0B0, 0xDAF9, 0xD3CA, 0xBAAA, 0xDBA2, 0xC7F1,
0xDAFC, 0xDAFB, 0xC9DB, 0xDAFD, 0xDBA1, 0xD7DE, 0xDAFE, 0xC1DA,
0xDBA5, 0xD3F4, 0xDBA7, 0xDBA4, 0xDBA8, 0xBDBC, 0xC0C9, 0xDBA3,
0xDBA6, 0xD6A3, 0xDBA9, 0xDBAD, 0xDBAE, 0xDBAC, 0xBAC2, 0xBFA4,
0xDBAB, 0xDBAA, 0xD4C7, 0xB2BF, 0xDBAF, 0xB9F9, 0xDBB0, 0xB3BB,
0xB5A6, 0xB6BC, 0xDBB1, 0xB6F5, 0xDBB2, 0xB1C9, 0xDBB4, 0xDBB3,
0xDBB5, 0xDBB7, 0xDBB6, 0xDBB8, 0xDBB9, 0xDBBA, 0xD3CF, 0xF4FA,
0xC7F5, 0xD7C3, 0xC5E4, 0xF4FC, 0xF4FD, 0xF4FB, 0xBEC6, 0xD0EF,
0xB7D3, 0xD4CD, 0xCCAA, 0xF5A2, 0xF5A1, 0xBAA8, 0xF4FE, 0xCBD6,
0xF5A4, 0xC0D2, 0xB3EA, 0xCDAA, 0xF5A5, 0xF5A3, 0xBDB4, 0xF5A8,
0xF5A9, 0xBDCD, 0xC3B8, 0xBFE1, 0xCBE1, 0xF5AA, 0xF5A6, 0xF5A7,
0xC4F0, 0xF5AC, 0xB4BC, 0xD7ED, 0xB4D7, 0xF5AB, 0xF5AE, 0xF5AD,
0xF5AF, 0xD0D1, 0xC3D1, 0xC8A9, 0xF5B0, 0xF5B1, 0xF5B2, 0xF5B3,
0xF5B4, 0xF5B5, 0xF5B7, 0xF5B6, 0xF5B8, 0xB2C9, 0xD3D4, 0xCACD,
0xC0EF, 0xD6D8, 0xD2B0, 0xC1BF, 0xBDF0, 0xB8AA, 0xBCF8, 0xF6C6,
0xF6C7, 0xF6C8, 0xF6C9, 0xF6CA, 0xF6CC, 0xF6CB, 0xF7E9, 0xF6CD,
0xF6CE, 0xEEC4, 0xEEC5, 0xEEC6, 0xD5EB, 0xB6A4, 0xEEC8, 0xEEC7,
0xEEC9, 0xEECA, 0xC7A5, 0xEECB, 0xEECC, 0xB7B0, 0xB5F6, 0xEECD,
0xEECF, 0xEECE, 0xB8C6, 0xEED0, 0xEED1, 0xEED2, 0xB6DB, 0xB3AE,
0xD6D3, 0xC4C6, 0xB1B5, 0xB8D6, 0xEED3, 0xEED4, 0xD4BF, 0xC7D5,
0xBEFB, 0xCED9, 0xB9B3, 0xEED6, 0xEED5, 0xEED8, 0xEED7, 0xC5A5,
0xEED9, 0xEEDA, 0xC7AE, 0xEEDB, 0xC7AF, 0xEEDC, 0xB2A7, 0xEEDD,
0xEEDE, 0xEEDF, 0xEEE0, 0xEEE1, 0xD7EA, 0xEEE2, 0xEEE3, 0xBCD8,
0xEEE4, 0xD3CB, 0xCCFA, 0xB2AC, 0xC1E5, 0xEEE5, 0xC7A6, 0xC3AD,
0xEEE6, 0xEEE7, 0xEEE8, 0xEEE9, 0xEEEA, 0xEEEB, 0xEEEC, 0xEEED,
0xEEEE, 0xEEEF, 0xEEF0, 0xEEF1, 0xEEF2, 0xEEF4, 0xEEF3, 0xEEF5,
0xCDAD, 0xC2C1, 0xEEF6, 0xEEF7, 0xEEF8, 0xD5A1, 0xEEF9, 0xCFB3,
0xEEFA, 0xEEFB, 0xEEFC, 0xEEFD, 0xEFA1, 0xEEFE, 0xEFA2, 0xB8F5,
0xC3FA, 0xEFA3, 0xEFA4, 0xBDC2, 0xD2BF, 0xB2F9, 0xEFA5, 0xEFA6,
0xEFA7, 0xD2F8, 0xEFA8, 0xD6FD, 0xEFA9, 0xC6CC, 0xEFAA, 0xEFAB,
0xC1B4, 0xEFAC, 0xCFFA, 0xCBF8, 0xEFAE, 0xEFAD, 0xB3FA, 0xB9F8,
0xEFAF, 0xEFB0, 0xD0E2, 0xEFB1, 0xEFB2, 0xB7E6, 0xD0BF, 0xEFB3,
0xEFB4, 0xEFB5, 0xC8F1, 0xCCE0, 0xEFB6, 0xEFB7, 0xEFB8, 0xEFB9,
0xEFBA, 0xD5E0, 0xEFBB, 0xB4ED, 0xC3AA, 0xEFBC, 0xEFBD, 0xEFBE,
0xEFBF, 0xCEFD, 0xEFC0, 0xC2E0, 0xB4B8, 0xD7B6, 0xBDF5, 0xCFC7,
0xEFC3, 0xEFC1, 0xEFC2, 0xEFC4, 0xB6A7, 0xBCFC, 0xBEE2, 0xC3CC,
0xEFC5, 0xEFC6, 0xEFC7, 0xEFCF, 0xEFC8, 0xEFC9, 0xEFCA, 0xC7C2,
0xEFF1, 0xB6CD, 0xEFCB, 0xEFCC, 0xEFCD, 0xB6C6, 0xC3BE, 0xEFCE,
0xEFD0, 0xEFD1, 0xEFD2, 0xD5F2, 0xEFD3, 0xC4F7, 0xEFD4, 0xC4F8,
0xEFD5, 0xEFD6, 0xB8E4, 0xB0F7, 0xEFD7, 0xEFD8, 0xEFD9, 0xEFDA,
0xEFDB, 0xEFDC, 0xEFDD, 0xEFDE, 0xBEB5, 0xEFE1, 0xEFDF, 0xEFE0,
0xEFE2, 0xEFE3, 0xC1CD, 0xEFE4, 0xEFE5, 0xEFE6, 0xEFE7, 0xEFE8,
0xEFE9, 0xEFEA, 0xEFEB, 0xEFEC, 0xC0D8, 0xEFED, 0xC1AD, 0xEFEE,
0xEFEF, 0xEFF0, 0xCFE2, 0xB3A4, 0xC3C5, 0xE3C5, 0xC9C1, 0xE3C6,
0xB1D5, 0xCECA, 0xB4B3, 0xC8F2, 0xE3C7, 0xCFD0, 0xE3C8, 0xBCE4,
0xE3C9, 0xE3CA, 0xC3C6, 0xD5A2, 0xC4D6, 0xB9EB, 0xCEC5, 0xE3CB,
0xC3F6, 0xE3CC, 0xB7A7, 0xB8F3, 0xBAD2, 0xE3CD, 0xE3CE, 0xD4C4,
0xE3CF, 0xE3D0, 0xD1CB, 0xE3D1, 0xE3D2, 0xE3D3, 0xE3D4, 0xD1D6,
0xE3D5, 0xB2FB, 0xC0BB, 0xE3D6, 0xC0AB, 0xE3D7, 0xE3D8, 0xE3D9,
0xE3DA, 0xE3DB, 0xB8B7, 0xDAE2, 0xB6D3, 0xDAE4, 0xDAE3, 0xDAE6,
0xC8EE, 0xDAE5, 0xB7C0, 0xD1F4, 0xD2F5, 0xD5F3, 0xBDD7, 0xD7E8,
0xDAE8, 0xDAE7, 0xB0A2, 0xCDD3, 0xDAE9, 0xB8BD, 0xBCCA, 0xC2BD,
0xC2A4, 0xB3C2, 0xDAEA, 0xC2AA, 0xC4B0, 0xBDB5, 0xCFDE, 0xDAEB,
0xC9C2, 0xB1DD, 0xDAEC, 0xB6B8, 0xD4BA, 0xB3FD, 0xDAED, 0xD4C9,
0xCFD5, 0xC5E3, 0xDAEE, 0xDAEF, 0xDAF0, 0xC1EA, 0xCCD5, 0xCFDD,
0xD3E7, 0xC2A1, 0xDAF1, 0xCBE5, 0xDAF2, 0xCBE6, 0xD2FE, 0xB8F4,
0xDAF3, 0xB0AF, 0xCFB6, 0xD5CF, 0xCBED, 0xDAF4, 0xE3C4, 0xC1A5,
0xF6BF, 0xF6C0, 0xF6C1, 0xC4D1, 0xC8B8, 0xD1E3, 0xD0DB, 0xD1C5,
0xBCAF, 0xB9CD, 0xEFF4, 0xB4C6, 0xD3BA, 0xF6C2, 0xB3FB, 0xF6C3,
0xB5F1, 0xF6C5, 0xD3EA, 0xF6A7, 0xD1A9, 0xF6A9, 0xF6A8, 0xC1E3,
0xC0D7, 0xB1A2, 0xCEED, 0xD0E8, 0xF6AB, 0xCFF6, 0xF6AA, 0xD5F0,
0xF6AC, 0xC3B9, 0xBBF4, 0xF6AE, 0xF6AD, 0xC4DE, 0xC1D8, 0xCBAA,
0xCFBC, 0xF6AF, 0xF6B0, 0xF6B1, 0xC2B6, 0xB0D4, 0xC5F9, 0xF6B2,
0xC7E0, 0xF6A6, 0xBEB8, 0xBEB2, 0xB5E5, 0xB7C7, 0xBFBF, 0xC3D2,
0xC3E6, 0xD8CC, 0xB8EF, 0xBDF9, 0xD1A5, 0xB0D0, 0xF7B0, 0xF7B1,
0xD0AC, 0xB0B0, 0xF7B2, 0xF7B3, 0xF7B4, 0xC7CA, 0xBECF, 0xF7B7,
0xF7B6, 0xB1DE, 0xF7B5, 0xF7B8, 0xF7B9, 0xCEA4, 0xC8CD, 0xBAAB,
0xE8B8, 0xE8B9, 0xE8BA, 0xBEC2, 0xD2F4, 0xD4CF, 0xC9D8, 0xD2B3,
0xB6A5, 0xC7EA, 0xF1FC, 0xCFEE, 0xCBB3, 0xD0EB, 0xE7EF, 0xCDE7,
0xB9CB, 0xB6D9, 0xF1FD, 0xB0E4, 0xCBCC, 0xF1FE, 0xD4A4, 0xC2AD,
0xC1EC, 0xC6C4, 0xBEB1, 0xF2A1, 0xBCD5, 0xF2A2, 0xF2A3, 0xF2A4,
0xD2C3, 0xC6B5, 0xCDC7, 0xF2A5, 0xD3B1, 0xBFC5, 0xCCE2, 0xF2A6,
0xF2A7, 0xD1D5, 0xB6EE, 0xF2A8, 0xF2A9, 0xB5DF, 0xF2AA, 0xF2AB,
0xB2FC, 0xF2AC, 0xF2AD, 0xC8A7, 0xB7E7, 0xECA9, 0xECAA, 0xECAB,
0xECAC, 0xC6AE, 0xECAD, 0xECAE, 0xB7C9, 0xCAB3, 0xE2B8, 0xF7CF,
0xF7D0, 0xB2CD, 0xF7D1, 0xF7D3, 0xF7D2, 0xE2BB, 0xBCA2, 0xE2BC,
0xE2BD, 0xE2BE, 0xE2BF, 0xE2C0, 0xE2C1, 0xB7B9, 0xD2FB, 0xBDA4,
0xCACE, 0xB1A5, 0xCBC7, 0xE2C2, 0xB6FC, 0xC8C4, 0xE2C3, 0xBDC8,
0xB1FD, 0xE2C4, 0xB6F6, 0xE2C5, 0xC4D9, 0xE2C6, 0xCFDA, 0xB9DD,
0xE2C7, 0xC0A1, 0xE2C8, 0xB2F6, 0xE2C9, 0xC1F3, 0xE2CA, 0xE2CB,
0xC2F8, 0xE2CC, 0xE2CD, 0xE2CE, 0xCAD7, 0xD8B8, 0xD9E5, 0xCFE3,
0xF0A5, 0xDCB0, 0xC2ED, 0xD4A6, 0xCDD4, 0xD1B1, 0xB3DB, 0xC7FD,
0xB2B5, 0xC2BF, 0xE6E0, 0xCABB, 0xE6E1, 0xE6E2, 0xBED4, 0xE6E3,
0xD7A4, 0xCDD5, 0xE6E5, 0xBCDD, 0xE6E4, 0xE6E6, 0xE6E7, 0xC2EE,
0xBDBE, 0xE6E8, 0xC2E6, 0xBAA7, 0xE6E9, 0xE6EA, 0xB3D2, 0xD1E9,
0xBFA5, 0xE6EB, 0xC6EF, 0xE6EC, 0xE6ED, 0xE6EE, 0xC6AD, 0xE6EF,
0xC9A7, 0xE6F0, 0xE6F1, 0xE6F2, 0xE5B9, 0xE6F3, 0xE6F4, 0xC2E2,
0xE6F5, 0xE6F6, 0xD6E8, 0xE6F7, 0xE6F8, 0xB9C7, 0xF7BB, 0xF7BA,
0xF7BE, 0xF7BC, 0xBAA1, 0xF7BF, 0xF7C0, 0xF7C2, 0xF7C1, 0xF7C4,
0xF7C3, 0xF7C5, 0xF7C6, 0xF7C7, 0xCBE8, 0xB8DF, 0xF7D4, 0xF7D5,
0xF7D6, 0xF7D8, 0xF7DA, 0xF7D7, 0xF7DB, 0xF7D9, 0xD7D7, 0xF7DC,
0xF7DD, 0xF7DE, 0xF7DF, 0xF7E0, 0xDBCB, 0xD8AA, 0xE5F7, 0xB9ED,
0xBFFD, 0xBBEA, 0xF7C9, 0xC6C7, 0xF7C8, 0xF7CA, 0xF7CC, 0xF7CB,
0xF7CD, 0xCEBA, 0xF7CE, 0xC4A7, 0xD3E3, 0xF6CF, 0xC2B3, 0xF6D0,
0xF6D1, 0xF6D2, 0xF6D3, 0xF6D4, 0xF6D6, 0xB1AB, 0xF6D7, 0xF6D8,
0xF6D9, 0xF6DA, 0xF6DB, 0xF6DC, 0xF6DD, 0xF6DE, 0xCFCA, 0xF6DF,
0xF6E0, 0xF6E1, 0xF6E2, 0xF6E3, 0xF6E4, 0xC0F0, 0xF6E5, 0xF6E6,
0xF6E7, 0xF6E8, 0xF6E9, 0xF6EA, 0xF6EB, 0xF6EC, 0xF6ED, 0xF6EE,
0xF6EF, 0xF6F0, 0xF6F1, 0xF6F2, 0xF6F3, 0xF6F4, 0xBEA8, 0xF6F5,
0xF6F6, 0xF6F7, 0xF6F8, 0xC8FA, 0xF6F9, 0xF6FA, 0xF6FB, 0xF6FC,
0xF6FD, 0xF6FE, 0xF7A1, 0xF7A2, 0xF7A3, 0xF7A4, 0xF7A5, 0xF7A6,
0xF7A7, 0xF7A8, 0xB1EE, 0xF7A9, 0xF7AA, 0xF7AB, 0xF7AC, 0xF7AD,
0xC1DB, 0xF7AE, 0xF7AF, 0xC4F1, 0xF0AF, 0xBCA6, 0xF0B0, 0xC3F9,
0xC5B8, 0xD1BB, 0xF0B1, 0xF0B2, 0xF0B3, 0xF0B4, 0xF0B5, 0xD1BC,
0xD1EC, 0xF0B7, 0xF0B6, 0xD4A7, 0xCDD2, 0xF0B8, 0xF0BA, 0xF0B9,
0xF0BB, 0xF0BC, 0xB8EB, 0xF0BD, 0xBAE8, 0xF0BE, 0xF0BF, 0xBEE9,
0xF0C0, 0xB6EC, 0xF0C1, 0xF0C2, 0xF0C3, 0xF0C4, 0xC8B5, 0xF0C5,
0xF0C6, 0xF0C7, 0xC5F4, 0xF0C8, 0xF0C9, 0xF0CA, 0xF7BD, 0xF0CB,
0xF0CC, 0xF0CD, 0xF0CE, 0xF0CF, 0xBAD7, 0xF0D0, 0xF0D1, 0xF0D2,
0xF0D3, 0xF0D4, 0xF0D5, 0xF0D6, 0xF0D8, 0xD3A5, 0xF0D7, 0xF0D9,
0xF5BA, 0xC2B9, 0xF7E4, 0xF7E5, 0xF7E6, 0xF7E7, 0xF7E8, 0xC2B4,
0xF7EA, 0xF7EB, 0xC2F3, 0xF4F0, 0xF4EF, 0xC2E9, 0xF7E1, 0xF7E2,
0xBBC6, 0xD9E4, 0xCAF2, 0xC0E8, 0xF0A4, 0xBADA, 0xC7AD, 0xC4AC,
0xF7EC, 0xF7ED, 0xF7EE, 0xF7F0, 0xF7EF, 0xF7F1, 0xF7F4, 0xF7F3,
0xF7F2, 0xF7F5, 0xF7F6, 0xEDE9, 0xEDEA, 0xEDEB, 0xF6BC, 0xF6BD,
0xF6BE, 0xB6A6, 0xD8BE, 0xB9C4, 0xD8BB, 0xDCB1, 0xCAF3, 0xF7F7,
0xF7F8, 0xF7F9, 0xF7FB, 0xF7FA, 0xB1C7, 0xF7FC, 0xF7FD, 0xF7FE,
0xC6EB, 0xECB4, 0xB3DD, 0xF6B3, 0xF6B4, 0xC1E4, 0xF6B5, 0xF6B6,
0xF6B7, 0xF6B8, 0xF6B9, 0xF6BA, 0xC8A3, 0xF6BB, 0xC1FA, 0xB9A8,
0xEDE8, 0xB9EA, 0xD9DF, 0xA3A1, 0xA3A2, 0xA3A3, 0xA1E7, 0xA3A5,
0xA3A6, 0xA3A7, 0xA3A8, 0xA3A9, 0xA3AA, 0xA3AB, 0xA3AC, 0xA3AD,
0xA3AE, 0xA3AF, 0xA3B0, 0xA3B1, 0xA3B2, 0xA3B3, 0xA3B4, 0xA3B5,
0xA3B6, 0xA3B7, 0xA3B8, 0xA3B9, 0xA3BA, 0xA3BB, 0xA3BC, 0xA3BD,
0xA3BE, 0xA3BF, 0xA3C0, 0xA3C1, 0xA3C2, 0xA3C3, 0xA3C4, 0xA3C5,
0xA3C6, 0xA3C7, 0xA3C8, 0xA3C9, 0xA3CA, 0xA3CB, 0xA3CC, 0xA3CD,
0xA3CE, 0xA3CF, 0xA3D0, 0xA3D1, 0xA3D2, 0xA3D3, 0xA3D4, 0xA3D5,
0xA3D6, 0xA3D7, 0xA3D8, 0xA3D9, 0xA3DA, 0xA3DB, 0xA3DC, 0xA3DD,
0xA3DE, 0xA3DF, 0xA3E0, 0xA3E1, 0xA3E2, 0xA3E3, 0xA3E4, 0xA3E5,
0xA3E6, 0xA3E7, 0xA3E8, 0xA3E9, 0xA3EA, 0xA3EB, 0xA3EC, 0xA3ED,
0xA3EE, 0xA3EF, 0xA3F0, 0xA3F1, 0xA3F2, 0xA3F3, 0xA3F4, 0xA3F5,
0xA3F6, 0xA3F7, 0xA3F8, 0xA3F9, 0xA3FA, 0xA3FB, 0xA3FC, 0xA3FD,
0xA1AB, 0xA1E9, 0xA1EA, 0xA3FE, 0xA3A4,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Indexes into Unicode `zueci_gb2312_u_u[]` array in blocks of 0x100 */
static const zueci_u16 zueci_gb2312_u_ind[256] = {
0, 25, 33, 53, 149, 149, 149, 149,
149, 149, 149, 149, 149, 149, 149, 149,
149, 149, 149, 149, 149, 149, 149, 149,
149, 149, 149, 149, 149, 149, 149, 149,
160, 178, 206, 208, 258, 336, 347, 347,
347, 347, 347, 347, 347, 347, 347, 347,
453, 574, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 655, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 720,
720, 720, 720, 720, 720, 720, 720, 814,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Unicode values in multibyte order */
static const zueci_u16 zueci_gb2312_mb_u[7614] = {
0x3000, 0x3001, 0x3002, 0x30FB, 0x02C9, 0x02C7, 0x00A8, 0x3003,
0x3005, 0x2015, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x2019, 0x201C,
0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C,
0x300D, 0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x3011, 0x00B1,
0x00D7, 0x00F7, 0x2236, 0x2227, 0x2228, 0x2211, 0x220F, 0x222A,
0x2229, 0x2208, 0x2237, 0x221A, 0x22A5, 0x2225, 0x2220, 0x2312,
0x2299, 0x222B, 0x222E, 0x2261, 0x224C, 0x2248, 0x223D, 0x221D,
0x2260, 0x226E, 0x226F, 0x2264, 0x2265, 0x221E, 0x2235, 0x2234,
0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFF04, 0x00A4,
0xFFE0, 0xFFE1, 0x2030, 0x00A7, 0x2116, 0x2606, 0x2605, 0x25CB,
0x25CF, 0x25CE, 0x25C7, 0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2,
0x203B, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2488, 0x2489,
0x248A, 0x248B, 0x248C, 0x248D, 0x248E, 0x248F, 0x2490, 0x2491,
0x2492, 0x2493, 0x2494, 0x2495, 0x2496, 0x2497, 0x2498, 0x2499,
0x249A, 0x249B, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
0x247A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480, 0x2481,
0x2482, 0x2483, 0x2484, 0x2485, 0x2486, 0x2487, 0x2460, 0x2461,
0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469,
0x0000, 0x0000, 0x3220, 0x3221, 0x3222, 0x3223, 0x3224, 0x3225,
0x3226, 0x3227, 0x3228, 0x3229, 0x0000, 0x0000, 0x2160, 0x2161,
0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169,
0x216A, 0x216B, 0x0000, 0x0000, 0xFF01, 0xFF02, 0xFF03, 0xFFE5,
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, 0xFFE3, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
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, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0391, 0x0392,
0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A,
0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3,
0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x03B1, 0x03B2,
0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3,
0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0410, 0x0411, 0x0412, 0x0413,
0x0414, 0x0415, 0x0401, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0430, 0x0431, 0x0432, 0x0433,
0x0434, 0x0435, 0x0451, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0101, 0x00E1, 0x01CE, 0x00E0, 0x0113, 0x00E9,
0x011B, 0x00E8, 0x012B, 0x00ED, 0x01D0, 0x00EC, 0x014D, 0x00F3,
0x01D2, 0x00F2, 0x016B, 0x00FA, 0x01D4, 0x00F9, 0x01D6, 0x01D8,
0x01DA, 0x01DC, 0x00FC, 0x00EA, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 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, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x554A, 0x963F,
0x57C3, 0x6328, 0x54CE, 0x5509, 0x54C0, 0x7691, 0x764C, 0x853C,
0x77EE, 0x827E, 0x788D, 0x7231, 0x9698, 0x978D, 0x6C28, 0x5B89,
0x4FFA, 0x6309, 0x6697, 0x5CB8, 0x80FA, 0x6848, 0x80AE, 0x6602,
0x76CE, 0x51F9, 0x6556, 0x71AC, 0x7FF1, 0x8884, 0x50B2, 0x5965,
0x61CA, 0x6FB3, 0x82AD, 0x634C, 0x6252, 0x53ED, 0x5427, 0x7B06,
0x516B, 0x75A4, 0x5DF4, 0x62D4, 0x8DCB, 0x9776, 0x628A, 0x8019,
0x575D, 0x9738, 0x7F62, 0x7238, 0x767D, 0x67CF, 0x767E, 0x6446,
0x4F70, 0x8D25, 0x62DC, 0x7A17, 0x6591, 0x73ED, 0x642C, 0x6273,
0x822C, 0x9881, 0x677F, 0x7248, 0x626E, 0x62CC, 0x4F34, 0x74E3,
0x534A, 0x529E, 0x7ECA, 0x90A6, 0x5E2E, 0x6886, 0x699C, 0x8180,
0x7ED1, 0x68D2, 0x78C5, 0x868C, 0x9551, 0x508D, 0x8C24, 0x82DE,
0x80DE, 0x5305, 0x8912, 0x5265, 0x8584, 0x96F9, 0x4FDD, 0x5821,
0x9971, 0x5B9D, 0x62B1, 0x62A5, 0x66B4, 0x8C79, 0x9C8D, 0x7206,
0x676F, 0x7891, 0x60B2, 0x5351, 0x5317, 0x8F88, 0x80CC, 0x8D1D,
0x94A1, 0x500D, 0x72C8, 0x5907, 0x60EB, 0x7119, 0x88AB, 0x5954,
0x82EF, 0x672C, 0x7B28, 0x5D29, 0x7EF7, 0x752D, 0x6CF5, 0x8E66,
0x8FF8, 0x903C, 0x9F3B, 0x6BD4, 0x9119, 0x7B14, 0x5F7C, 0x78A7,
0x84D6, 0x853D, 0x6BD5, 0x6BD9, 0x6BD6, 0x5E01, 0x5E87, 0x75F9,
0x95ED, 0x655D, 0x5F0A, 0x5FC5, 0x8F9F, 0x58C1, 0x81C2, 0x907F,
0x965B, 0x97AD, 0x8FB9, 0x7F16, 0x8D2C, 0x6241, 0x4FBF, 0x53D8,
0x535E, 0x8FA8, 0x8FA9, 0x8FAB, 0x904D, 0x6807, 0x5F6A, 0x8198,
0x8868, 0x9CD6, 0x618B, 0x522B, 0x762A, 0x5F6C, 0x658C, 0x6FD2,
0x6EE8, 0x5BBE, 0x6448, 0x5175, 0x51B0, 0x67C4, 0x4E19, 0x79C9,
0x997C, 0x70B3, 0x75C5, 0x5E76, 0x73BB, 0x83E0, 0x64AD, 0x62E8,
0x94B5, 0x6CE2, 0x535A, 0x52C3, 0x640F, 0x94C2, 0x7B94, 0x4F2F,
0x5E1B, 0x8236, 0x8116, 0x818A, 0x6E24, 0x6CCA, 0x9A73, 0x6355,
0x535C, 0x54FA, 0x8865, 0x57E0, 0x4E0D, 0x5E03, 0x6B65, 0x7C3F,
0x90E8, 0x6016, 0x64E6, 0x731C, 0x88C1, 0x6750, 0x624D, 0x8D22,
0x776C, 0x8E29, 0x91C7, 0x5F69, 0x83DC, 0x8521, 0x9910, 0x53C2,
0x8695, 0x6B8B, 0x60ED, 0x60E8, 0x707F, 0x82CD, 0x8231, 0x4ED3,
0x6CA7, 0x85CF, 0x64CD, 0x7CD9, 0x69FD, 0x66F9, 0x8349, 0x5395,
0x7B56, 0x4FA7, 0x518C, 0x6D4B, 0x5C42, 0x8E6D, 0x63D2, 0x53C9,
0x832C, 0x8336, 0x67E5, 0x78B4, 0x643D, 0x5BDF, 0x5C94, 0x5DEE,
0x8BE7, 0x62C6, 0x67F4, 0x8C7A, 0x6400, 0x63BA, 0x8749, 0x998B,
0x8C17, 0x7F20, 0x94F2, 0x4EA7, 0x9610, 0x98A4, 0x660C, 0x7316,
0x573A, 0x5C1D, 0x5E38, 0x957F, 0x507F, 0x80A0, 0x5382, 0x655E,
0x7545, 0x5531, 0x5021, 0x8D85, 0x6284, 0x949E, 0x671D, 0x5632,
0x6F6E, 0x5DE2, 0x5435, 0x7092, 0x8F66, 0x626F, 0x64A4, 0x63A3,
0x5F7B, 0x6F88, 0x90F4, 0x81E3, 0x8FB0, 0x5C18, 0x6668, 0x5FF1,
0x6C89, 0x9648, 0x8D81, 0x886C, 0x6491, 0x79F0, 0x57CE, 0x6A59,
0x6210, 0x5448, 0x4E58, 0x7A0B, 0x60E9, 0x6F84, 0x8BDA, 0x627F,
0x901E, 0x9A8B, 0x79E4, 0x5403, 0x75F4, 0x6301, 0x5319, 0x6C60,
0x8FDF, 0x5F1B, 0x9A70, 0x803B, 0x9F7F, 0x4F88, 0x5C3A, 0x8D64,
0x7FC5, 0x65A5, 0x70BD, 0x5145, 0x51B2, 0x866B, 0x5D07, 0x5BA0,
0x62BD, 0x916C, 0x7574, 0x8E0C, 0x7A20, 0x6101, 0x7B79, 0x4EC7,
0x7EF8, 0x7785, 0x4E11, 0x81ED, 0x521D, 0x51FA, 0x6A71, 0x53A8,
0x8E87, 0x9504, 0x96CF, 0x6EC1, 0x9664, 0x695A, 0x7840, 0x50A8,
0x77D7, 0x6410, 0x89E6, 0x5904, 0x63E3, 0x5DDD, 0x7A7F, 0x693D,
0x4F20, 0x8239, 0x5598, 0x4E32, 0x75AE, 0x7A97, 0x5E62, 0x5E8A,
0x95EF, 0x521B, 0x5439, 0x708A, 0x6376, 0x9524, 0x5782, 0x6625,
0x693F, 0x9187, 0x5507, 0x6DF3, 0x7EAF, 0x8822, 0x6233, 0x7EF0,
0x75B5, 0x8328, 0x78C1, 0x96CC, 0x8F9E, 0x6148, 0x74F7, 0x8BCD,
0x6B64, 0x523A, 0x8D50, 0x6B21, 0x806A, 0x8471, 0x56F1, 0x5306,
0x4ECE, 0x4E1B, 0x51D1, 0x7C97, 0x918B, 0x7C07, 0x4FC3, 0x8E7F,
0x7BE1, 0x7A9C, 0x6467, 0x5D14, 0x50AC, 0x8106, 0x7601, 0x7CB9,
0x6DEC, 0x7FE0, 0x6751, 0x5B58, 0x5BF8, 0x78CB, 0x64AE, 0x6413,
0x63AA, 0x632B, 0x9519, 0x642D, 0x8FBE, 0x7B54, 0x7629, 0x6253,
0x5927, 0x5446, 0x6B79, 0x50A3, 0x6234, 0x5E26, 0x6B86, 0x4EE3,
0x8D37, 0x888B, 0x5F85, 0x902E, 0x6020, 0x803D, 0x62C5, 0x4E39,
0x5355, 0x90F8, 0x63B8, 0x80C6, 0x65E6, 0x6C2E, 0x4F46, 0x60EE,
0x6DE1, 0x8BDE, 0x5F39, 0x86CB, 0x5F53, 0x6321, 0x515A, 0x8361,
0x6863, 0x5200, 0x6363, 0x8E48, 0x5012, 0x5C9B, 0x7977, 0x5BFC,
0x5230, 0x7A3B, 0x60BC, 0x9053, 0x76D7, 0x5FB7, 0x5F97, 0x7684,
0x8E6C, 0x706F, 0x767B, 0x7B49, 0x77AA, 0x51F3, 0x9093, 0x5824,
0x4F4E, 0x6EF4, 0x8FEA, 0x654C, 0x7B1B, 0x72C4, 0x6DA4, 0x7FDF,
0x5AE1, 0x62B5, 0x5E95, 0x5730, 0x8482, 0x7B2C, 0x5E1D, 0x5F1F,
0x9012, 0x7F14, 0x98A0, 0x6382, 0x6EC7, 0x7898, 0x70B9, 0x5178,
0x975B, 0x57AB, 0x7535, 0x4F43, 0x7538, 0x5E97, 0x60E6, 0x5960,
0x6DC0, 0x6BBF, 0x7889, 0x53FC, 0x96D5, 0x51CB, 0x5201, 0x6389,
0x540A, 0x9493, 0x8C03, 0x8DCC, 0x7239, 0x789F, 0x8776, 0x8FED,
0x8C0D, 0x53E0, 0x4E01, 0x76EF, 0x53EE, 0x9489, 0x9876, 0x9F0E,
0x952D, 0x5B9A, 0x8BA2, 0x4E22, 0x4E1C, 0x51AC, 0x8463, 0x61C2,
0x52A8, 0x680B, 0x4F97, 0x606B, 0x51BB, 0x6D1E, 0x515C, 0x6296,
0x6597, 0x9661, 0x8C46, 0x9017, 0x75D8, 0x90FD, 0x7763, 0x6BD2,
0x728A, 0x72EC, 0x8BFB, 0x5835, 0x7779, 0x8D4C, 0x675C, 0x9540,
0x809A, 0x5EA6, 0x6E21, 0x5992, 0x7AEF, 0x77ED, 0x953B, 0x6BB5,
0x65AD, 0x7F0E, 0x5806, 0x5151, 0x961F, 0x5BF9, 0x58A9, 0x5428,
0x8E72, 0x6566, 0x987F, 0x56E4, 0x949D, 0x76FE, 0x9041, 0x6387,
0x54C6, 0x591A, 0x593A, 0x579B, 0x8EB2, 0x6735, 0x8DFA, 0x8235,
0x5241, 0x60F0, 0x5815, 0x86FE, 0x5CE8, 0x9E45, 0x4FC4, 0x989D,
0x8BB9, 0x5A25, 0x6076, 0x5384, 0x627C, 0x904F, 0x9102, 0x997F,
0x6069, 0x800C, 0x513F, 0x8033, 0x5C14, 0x9975, 0x6D31, 0x4E8C,
0x8D30, 0x53D1, 0x7F5A, 0x7B4F, 0x4F10, 0x4E4F, 0x9600, 0x6CD5,
0x73D0, 0x85E9, 0x5E06, 0x756A, 0x7FFB, 0x6A0A, 0x77FE, 0x9492,
0x7E41, 0x51E1, 0x70E6, 0x53CD, 0x8FD4, 0x8303, 0x8D29, 0x72AF,
0x996D, 0x6CDB, 0x574A, 0x82B3, 0x65B9, 0x80AA, 0x623F, 0x9632,
0x59A8, 0x4EFF, 0x8BBF, 0x7EBA, 0x653E, 0x83F2, 0x975E, 0x5561,
0x98DE, 0x80A5, 0x532A, 0x8BFD, 0x5420, 0x80BA, 0x5E9F, 0x6CB8,
0x8D39, 0x82AC, 0x915A, 0x5429, 0x6C1B, 0x5206, 0x7EB7, 0x575F,
0x711A, 0x6C7E, 0x7C89, 0x594B, 0x4EFD, 0x5FFF, 0x6124, 0x7CAA,
0x4E30, 0x5C01, 0x67AB, 0x8702, 0x5CF0, 0x950B, 0x98CE, 0x75AF,
0x70FD, 0x9022, 0x51AF, 0x7F1D, 0x8BBD, 0x5949, 0x51E4, 0x4F5B,
0x5426, 0x592B, 0x6577, 0x80A4, 0x5B75, 0x6276, 0x62C2, 0x8F90,
0x5E45, 0x6C1F, 0x7B26, 0x4F0F, 0x4FD8, 0x670D, 0x6D6E, 0x6DAA,
0x798F, 0x88B1, 0x5F17, 0x752B, 0x629A, 0x8F85, 0x4FEF, 0x91DC,
0x65A7, 0x812F, 0x8151, 0x5E9C, 0x8150, 0x8D74, 0x526F, 0x8986,
0x8D4B, 0x590D, 0x5085, 0x4ED8, 0x961C, 0x7236, 0x8179, 0x8D1F,
0x5BCC, 0x8BA3, 0x9644, 0x5987, 0x7F1A, 0x5490, 0x5676, 0x560E,
0x8BE5, 0x6539, 0x6982, 0x9499, 0x76D6, 0x6E89, 0x5E72, 0x7518,
0x6746, 0x67D1, 0x7AFF, 0x809D, 0x8D76, 0x611F, 0x79C6, 0x6562,
0x8D63, 0x5188, 0x521A, 0x94A2, 0x7F38, 0x809B, 0x7EB2, 0x5C97,
0x6E2F, 0x6760, 0x7BD9, 0x768B, 0x9AD8, 0x818F, 0x7F94, 0x7CD5,
0x641E, 0x9550, 0x7A3F, 0x544A, 0x54E5, 0x6B4C, 0x6401, 0x6208,
0x9E3D, 0x80F3, 0x7599, 0x5272, 0x9769, 0x845B, 0x683C, 0x86E4,
0x9601, 0x9694, 0x94EC, 0x4E2A, 0x5404, 0x7ED9, 0x6839, 0x8DDF,
0x8015, 0x66F4, 0x5E9A, 0x7FB9, 0x57C2, 0x803F, 0x6897, 0x5DE5,
0x653B, 0x529F, 0x606D, 0x9F9A, 0x4F9B, 0x8EAC, 0x516C, 0x5BAB,
0x5F13, 0x5DE9, 0x6C5E, 0x62F1, 0x8D21, 0x5171, 0x94A9, 0x52FE,
0x6C9F, 0x82DF, 0x72D7, 0x57A2, 0x6784, 0x8D2D, 0x591F, 0x8F9C,
0x83C7, 0x5495, 0x7B8D, 0x4F30, 0x6CBD, 0x5B64, 0x59D1, 0x9F13,
0x53E4, 0x86CA, 0x9AA8, 0x8C37, 0x80A1, 0x6545, 0x987E, 0x56FA,
0x96C7, 0x522E, 0x74DC, 0x5250, 0x5BE1, 0x6302, 0x8902, 0x4E56,
0x62D0, 0x602A, 0x68FA, 0x5173, 0x5B98, 0x51A0, 0x89C2, 0x7BA1,
0x9986, 0x7F50, 0x60EF, 0x704C, 0x8D2F, 0x5149, 0x5E7F, 0x901B,
0x7470, 0x89C4, 0x572D, 0x7845, 0x5F52, 0x9F9F, 0x95FA, 0x8F68,
0x9B3C, 0x8BE1, 0x7678, 0x6842, 0x67DC, 0x8DEA, 0x8D35, 0x523D,
0x8F8A, 0x6EDA, 0x68CD, 0x9505, 0x90ED, 0x56FD, 0x679C, 0x88F9,
0x8FC7, 0x54C8, 0x9AB8, 0x5B69, 0x6D77, 0x6C26, 0x4EA5, 0x5BB3,
0x9A87, 0x9163, 0x61A8, 0x90AF, 0x97E9, 0x542B, 0x6DB5, 0x5BD2,
0x51FD, 0x558A, 0x7F55, 0x7FF0, 0x64BC, 0x634D, 0x65F1, 0x61BE,
0x608D, 0x710A, 0x6C57, 0x6C49, 0x592F, 0x676D, 0x822A, 0x58D5,
0x568E, 0x8C6A, 0x6BEB, 0x90DD, 0x597D, 0x8017, 0x53F7, 0x6D69,
0x5475, 0x559D, 0x8377, 0x83CF, 0x6838, 0x79BE, 0x548C, 0x4F55,
0x5408, 0x76D2, 0x8C89, 0x9602, 0x6CB3, 0x6DB8, 0x8D6B, 0x8910,
0x9E64, 0x8D3A, 0x563F, 0x9ED1, 0x75D5, 0x5F88, 0x72E0, 0x6068,
0x54FC, 0x4EA8, 0x6A2A, 0x8861, 0x6052, 0x8F70, 0x54C4, 0x70D8,
0x8679, 0x9E3F, 0x6D2A, 0x5B8F, 0x5F18, 0x7EA2, 0x5589, 0x4FAF,
0x7334, 0x543C, 0x539A, 0x5019, 0x540E, 0x547C, 0x4E4E, 0x5FFD,
0x745A, 0x58F6, 0x846B, 0x80E1, 0x8774, 0x72D0, 0x7CCA, 0x6E56,
0x5F27, 0x864E, 0x552C, 0x62A4, 0x4E92, 0x6CAA, 0x6237, 0x82B1,
0x54D7, 0x534E, 0x733E, 0x6ED1, 0x753B, 0x5212, 0x5316, 0x8BDD,
0x69D0, 0x5F8A, 0x6000, 0x6DEE, 0x574F, 0x6B22, 0x73AF, 0x6853,
0x8FD8, 0x7F13, 0x6362, 0x60A3, 0x5524, 0x75EA, 0x8C62, 0x7115,
0x6DA3, 0x5BA6, 0x5E7B, 0x8352, 0x614C, 0x9EC4, 0x78FA, 0x8757,
0x7C27, 0x7687, 0x51F0, 0x60F6, 0x714C, 0x6643, 0x5E4C, 0x604D,
0x8C0E, 0x7070, 0x6325, 0x8F89, 0x5FBD, 0x6062, 0x86D4, 0x56DE,
0x6BC1, 0x6094, 0x6167, 0x5349, 0x60E0, 0x6666, 0x8D3F, 0x79FD,
0x4F1A, 0x70E9, 0x6C47, 0x8BB3, 0x8BF2, 0x7ED8, 0x8364, 0x660F,
0x5A5A, 0x9B42, 0x6D51, 0x6DF7, 0x8C41, 0x6D3B, 0x4F19, 0x706B,
0x83B7, 0x6216, 0x60D1, 0x970D, 0x8D27, 0x7978, 0x51FB, 0x573E,
0x57FA, 0x673A, 0x7578, 0x7A3D, 0x79EF, 0x7B95, 0x808C, 0x9965,
0x8FF9, 0x6FC0, 0x8BA5, 0x9E21, 0x59EC, 0x7EE9, 0x7F09, 0x5409,
0x6781, 0x68D8, 0x8F91, 0x7C4D, 0x96C6, 0x53CA, 0x6025, 0x75BE,
0x6C72, 0x5373, 0x5AC9, 0x7EA7, 0x6324, 0x51E0, 0x810A, 0x5DF1,
0x84DF, 0x6280, 0x5180, 0x5B63, 0x4F0E, 0x796D, 0x5242, 0x60B8,
0x6D4E, 0x5BC4, 0x5BC2, 0x8BA1, 0x8BB0, 0x65E2, 0x5FCC, 0x9645,
0x5993, 0x7EE7, 0x7EAA, 0x5609, 0x67B7, 0x5939, 0x4F73, 0x5BB6,
0x52A0, 0x835A, 0x988A, 0x8D3E, 0x7532, 0x94BE, 0x5047, 0x7A3C,
0x4EF7, 0x67B6, 0x9A7E, 0x5AC1, 0x6B7C, 0x76D1, 0x575A, 0x5C16,
0x7B3A, 0x95F4, 0x714E, 0x517C, 0x80A9, 0x8270, 0x5978, 0x7F04,
0x8327, 0x68C0, 0x67EC, 0x78B1, 0x7877, 0x62E3, 0x6361, 0x7B80,
0x4FED, 0x526A, 0x51CF, 0x8350, 0x69DB, 0x9274, 0x8DF5, 0x8D31,
0x89C1, 0x952E, 0x7BAD, 0x4EF6, 0x5065, 0x8230, 0x5251, 0x996F,
0x6E10, 0x6E85, 0x6DA7, 0x5EFA, 0x50F5, 0x59DC, 0x5C06, 0x6D46,
0x6C5F, 0x7586, 0x848B, 0x6868, 0x5956, 0x8BB2, 0x5320, 0x9171,
0x964D, 0x8549, 0x6912, 0x7901, 0x7126, 0x80F6, 0x4EA4, 0x90CA,
0x6D47, 0x9A84, 0x5A07, 0x56BC, 0x6405, 0x94F0, 0x77EB, 0x4FA5,
0x811A, 0x72E1, 0x89D2, 0x997A, 0x7F34, 0x7EDE, 0x527F, 0x6559,
0x9175, 0x8F7F, 0x8F83, 0x53EB, 0x7A96, 0x63ED, 0x63A5, 0x7686,
0x79F8, 0x8857, 0x9636, 0x622A, 0x52AB, 0x8282, 0x6854, 0x6770,
0x6377, 0x776B, 0x7AED, 0x6D01, 0x7ED3, 0x89E3, 0x59D0, 0x6212,
0x85C9, 0x82A5, 0x754C, 0x501F, 0x4ECB, 0x75A5, 0x8BEB, 0x5C4A,
0x5DFE, 0x7B4B, 0x65A4, 0x91D1, 0x4ECA, 0x6D25, 0x895F, 0x7D27,
0x9526, 0x4EC5, 0x8C28, 0x8FDB, 0x9773, 0x664B, 0x7981, 0x8FD1,
0x70EC, 0x6D78, 0x5C3D, 0x52B2, 0x8346, 0x5162, 0x830E, 0x775B,
0x6676, 0x9CB8, 0x4EAC, 0x60CA, 0x7CBE, 0x7CB3, 0x7ECF, 0x4E95,
0x8B66, 0x666F, 0x9888, 0x9759, 0x5883, 0x656C, 0x955C, 0x5F84,
0x75C9, 0x9756, 0x7ADF, 0x7ADE, 0x51C0, 0x70AF, 0x7A98, 0x63EA,
0x7A76, 0x7EA0, 0x7396, 0x97ED, 0x4E45, 0x7078, 0x4E5D, 0x9152,
0x53A9, 0x6551, 0x65E7, 0x81FC, 0x8205, 0x548E, 0x5C31, 0x759A,
0x97A0, 0x62D8, 0x72D9, 0x75BD, 0x5C45, 0x9A79, 0x83CA, 0x5C40,
0x5480, 0x77E9, 0x4E3E, 0x6CAE, 0x805A, 0x62D2, 0x636E, 0x5DE8,
0x5177, 0x8DDD, 0x8E1E, 0x952F, 0x4FF1, 0x53E5, 0x60E7, 0x70AC,
0x5267, 0x6350, 0x9E43, 0x5A1F, 0x5026, 0x7737, 0x5377, 0x7EE2,
0x6485, 0x652B, 0x6289, 0x6398, 0x5014, 0x7235, 0x89C9, 0x51B3,
0x8BC0, 0x7EDD, 0x5747, 0x83CC, 0x94A7, 0x519B, 0x541B, 0x5CFB,
0x4FCA, 0x7AE3, 0x6D5A, 0x90E1, 0x9A8F, 0x5580, 0x5496, 0x5361,
0x54AF, 0x5F00, 0x63E9, 0x6977, 0x51EF, 0x6168, 0x520A, 0x582A,
0x52D8, 0x574E, 0x780D, 0x770B, 0x5EB7, 0x6177, 0x7CE0, 0x625B,
0x6297, 0x4EA2, 0x7095, 0x8003, 0x62F7, 0x70E4, 0x9760, 0x5777,
0x82DB, 0x67EF, 0x68F5, 0x78D5, 0x9897, 0x79D1, 0x58F3, 0x54B3,
0x53EF, 0x6E34, 0x514B, 0x523B, 0x5BA2, 0x8BFE, 0x80AF, 0x5543,
0x57A6, 0x6073, 0x5751, 0x542D, 0x7A7A, 0x6050, 0x5B54, 0x63A7,
0x62A0, 0x53E3, 0x6263, 0x5BC7, 0x67AF, 0x54ED, 0x7A9F, 0x82E6,
0x9177, 0x5E93, 0x88E4, 0x5938, 0x57AE, 0x630E, 0x8DE8, 0x80EF,
0x5757, 0x7B77, 0x4FA9, 0x5FEB, 0x5BBD, 0x6B3E, 0x5321, 0x7B50,
0x72C2, 0x6846, 0x77FF, 0x7736, 0x65F7, 0x51B5, 0x4E8F, 0x76D4,
0x5CBF, 0x7AA5, 0x8475, 0x594E, 0x9B41, 0x5080, 0x9988, 0x6127,
0x6E83, 0x5764, 0x6606, 0x6346, 0x56F0, 0x62EC, 0x6269, 0x5ED3,
0x9614, 0x5783, 0x62C9, 0x5587, 0x8721, 0x814A, 0x8FA3, 0x5566,
0x83B1, 0x6765, 0x8D56, 0x84DD, 0x5A6A, 0x680F, 0x62E6, 0x7BEE,
0x9611, 0x5170, 0x6F9C, 0x8C30, 0x63FD, 0x89C8, 0x61D2, 0x7F06,
0x70C2, 0x6EE5, 0x7405, 0x6994, 0x72FC, 0x5ECA, 0x90CE, 0x6717,
0x6D6A, 0x635E, 0x52B3, 0x7262, 0x8001, 0x4F6C, 0x59E5, 0x916A,
0x70D9, 0x6D9D, 0x52D2, 0x4E50, 0x96F7, 0x956D, 0x857E, 0x78CA,
0x7D2F, 0x5121, 0x5792, 0x64C2, 0x808B, 0x7C7B, 0x6CEA, 0x68F1,
0x695E, 0x51B7, 0x5398, 0x68A8, 0x7281, 0x9ECE, 0x7BF1, 0x72F8,
0x79BB, 0x6F13, 0x7406, 0x674E, 0x91CC, 0x9CA4, 0x793C, 0x8389,
0x8354, 0x540F, 0x6817, 0x4E3D, 0x5389, 0x52B1, 0x783E, 0x5386,
0x5229, 0x5088, 0x4F8B, 0x4FD0, 0x75E2, 0x7ACB, 0x7C92, 0x6CA5,
0x96B6, 0x529B, 0x7483, 0x54E9, 0x4FE9, 0x8054, 0x83B2, 0x8FDE,
0x9570, 0x5EC9, 0x601C, 0x6D9F, 0x5E18, 0x655B, 0x8138, 0x94FE,
0x604B, 0x70BC, 0x7EC3, 0x7CAE, 0x51C9, 0x6881, 0x7CB1, 0x826F,
0x4E24, 0x8F86, 0x91CF, 0x667E, 0x4EAE, 0x8C05, 0x64A9, 0x804A,
0x50DA, 0x7597, 0x71CE, 0x5BE5, 0x8FBD, 0x6F66, 0x4E86, 0x6482,
0x9563, 0x5ED6, 0x6599, 0x5217, 0x88C2, 0x70C8, 0x52A3, 0x730E,
0x7433, 0x6797, 0x78F7, 0x9716, 0x4E34, 0x90BB, 0x9CDE, 0x6DCB,
0x51DB, 0x8D41, 0x541D, 0x62CE, 0x73B2, 0x83F1, 0x96F6, 0x9F84,
0x94C3, 0x4F36, 0x7F9A, 0x51CC, 0x7075, 0x9675, 0x5CAD, 0x9886,
0x53E6, 0x4EE4, 0x6E9C, 0x7409, 0x69B4, 0x786B, 0x998F, 0x7559,
0x5218, 0x7624, 0x6D41, 0x67F3, 0x516D, 0x9F99, 0x804B, 0x5499,
0x7B3C, 0x7ABF, 0x9686, 0x5784, 0x62E2, 0x9647, 0x697C, 0x5A04,
0x6402, 0x7BD3, 0x6F0F, 0x964B, 0x82A6, 0x5362, 0x9885, 0x5E90,
0x7089, 0x63B3, 0x5364, 0x864F, 0x9C81, 0x9E93, 0x788C, 0x9732,
0x8DEF, 0x8D42, 0x9E7F, 0x6F5E, 0x7984, 0x5F55, 0x9646, 0x622E,
0x9A74, 0x5415, 0x94DD, 0x4FA3, 0x65C5, 0x5C65, 0x5C61, 0x7F15,
0x8651, 0x6C2F, 0x5F8B, 0x7387, 0x6EE4, 0x7EFF, 0x5CE6, 0x631B,
0x5B6A, 0x6EE6, 0x5375, 0x4E71, 0x63A0, 0x7565, 0x62A1, 0x8F6E,
0x4F26, 0x4ED1, 0x6CA6, 0x7EB6, 0x8BBA, 0x841D, 0x87BA, 0x7F57,
0x903B, 0x9523, 0x7BA9, 0x9AA1, 0x88F8, 0x843D, 0x6D1B, 0x9A86,
0x7EDC, 0x5988, 0x9EBB, 0x739B, 0x7801, 0x8682, 0x9A6C, 0x9A82,
0x561B, 0x5417, 0x57CB, 0x4E70, 0x9EA6, 0x5356, 0x8FC8, 0x8109,
0x7792, 0x9992, 0x86EE, 0x6EE1, 0x8513, 0x66FC, 0x6162, 0x6F2B,
0x8C29, 0x8292, 0x832B, 0x76F2, 0x6C13, 0x5FD9, 0x83BD, 0x732B,
0x8305, 0x951A, 0x6BDB, 0x77DB, 0x94C6, 0x536F, 0x8302, 0x5192,
0x5E3D, 0x8C8C, 0x8D38, 0x4E48, 0x73AB, 0x679A, 0x6885, 0x9176,
0x9709, 0x7164, 0x6CA1, 0x7709, 0x5A92, 0x9541, 0x6BCF, 0x7F8E,
0x6627, 0x5BD0, 0x59B9, 0x5A9A, 0x95E8, 0x95F7, 0x4EEC, 0x840C,
0x8499, 0x6AAC, 0x76DF, 0x9530, 0x731B, 0x68A6, 0x5B5F, 0x772F,
0x919A, 0x9761, 0x7CDC, 0x8FF7, 0x8C1C, 0x5F25, 0x7C73, 0x79D8,
0x89C5, 0x6CCC, 0x871C, 0x5BC6, 0x5E42, 0x68C9, 0x7720, 0x7EF5,
0x5195, 0x514D, 0x52C9, 0x5A29, 0x7F05, 0x9762, 0x82D7, 0x63CF,
0x7784, 0x85D0, 0x79D2, 0x6E3A, 0x5E99, 0x5999, 0x8511, 0x706D,
0x6C11, 0x62BF, 0x76BF, 0x654F, 0x60AF, 0x95FD, 0x660E, 0x879F,
0x9E23, 0x94ED, 0x540D, 0x547D, 0x8C2C, 0x6478, 0x6479, 0x8611,
0x6A21, 0x819C, 0x78E8, 0x6469, 0x9B54, 0x62B9, 0x672B, 0x83AB,
0x58A8, 0x9ED8, 0x6CAB, 0x6F20, 0x5BDE, 0x964C, 0x8C0B, 0x725F,
0x67D0, 0x62C7, 0x7261, 0x4EA9, 0x59C6, 0x6BCD, 0x5893, 0x66AE,
0x5E55, 0x52DF, 0x6155, 0x6728, 0x76EE, 0x7766, 0x7267, 0x7A46,
0x62FF, 0x54EA, 0x5450, 0x94A0, 0x90A3, 0x5A1C, 0x7EB3, 0x6C16,
0x4E43, 0x5976, 0x8010, 0x5948, 0x5357, 0x7537, 0x96BE, 0x56CA,
0x6320, 0x8111, 0x607C, 0x95F9, 0x6DD6, 0x5462, 0x9981, 0x5185,
0x5AE9, 0x80FD, 0x59AE, 0x9713, 0x502A, 0x6CE5, 0x5C3C, 0x62DF,
0x4F60, 0x533F, 0x817B, 0x9006, 0x6EBA, 0x852B, 0x62C8, 0x5E74,
0x78BE, 0x64B5, 0x637B, 0x5FF5, 0x5A18, 0x917F, 0x9E1F, 0x5C3F,
0x634F, 0x8042, 0x5B7D, 0x556E, 0x954A, 0x954D, 0x6D85, 0x60A8,
0x67E0, 0x72DE, 0x51DD, 0x5B81, 0x62E7, 0x6CDE, 0x725B, 0x626D,
0x94AE, 0x7EBD, 0x8113, 0x6D53, 0x519C, 0x5F04, 0x5974, 0x52AA,
0x6012, 0x5973, 0x6696, 0x8650, 0x759F, 0x632A, 0x61E6, 0x7CEF,
0x8BFA, 0x54E6, 0x6B27, 0x9E25, 0x6BB4, 0x85D5, 0x5455, 0x5076,
0x6CA4, 0x556A, 0x8DB4, 0x722C, 0x5E15, 0x6015, 0x7436, 0x62CD,
0x6392, 0x724C, 0x5F98, 0x6E43, 0x6D3E, 0x6500, 0x6F58, 0x76D8,
0x78D0, 0x76FC, 0x7554, 0x5224, 0x53DB, 0x4E53, 0x5E9E, 0x65C1,
0x802A, 0x80D6, 0x629B, 0x5486, 0x5228, 0x70AE, 0x888D, 0x8DD1,
0x6CE1, 0x5478, 0x80DA, 0x57F9, 0x88F4, 0x8D54, 0x966A, 0x914D,
0x4F69, 0x6C9B, 0x55B7, 0x76C6, 0x7830, 0x62A8, 0x70F9, 0x6F8E,
0x5F6D, 0x84EC, 0x68DA, 0x787C, 0x7BF7, 0x81A8, 0x670B, 0x9E4F,
0x6367, 0x78B0, 0x576F, 0x7812, 0x9739, 0x6279, 0x62AB, 0x5288,
0x7435, 0x6BD7, 0x5564, 0x813E, 0x75B2, 0x76AE, 0x5339, 0x75DE,
0x50FB, 0x5C41, 0x8B6C, 0x7BC7, 0x504F, 0x7247, 0x9A97, 0x98D8,
0x6F02, 0x74E2, 0x7968, 0x6487, 0x77A5, 0x62FC, 0x9891, 0x8D2B,
0x54C1, 0x8058, 0x4E52, 0x576A, 0x82F9, 0x840D, 0x5E73, 0x51ED,
0x74F6, 0x8BC4, 0x5C4F, 0x5761, 0x6CFC, 0x9887, 0x5A46, 0x7834,
0x9B44, 0x8FEB, 0x7C95, 0x5256, 0x6251, 0x94FA, 0x4EC6, 0x8386,
0x8461, 0x83E9, 0x84B2, 0x57D4, 0x6734, 0x5703, 0x666E, 0x6D66,
0x8C31, 0x66DD, 0x7011, 0x671F, 0x6B3A, 0x6816, 0x621A, 0x59BB,
0x4E03, 0x51C4, 0x6F06, 0x67D2, 0x6C8F, 0x5176, 0x68CB, 0x5947,
0x6B67, 0x7566, 0x5D0E, 0x8110, 0x9F50, 0x65D7, 0x7948, 0x7941,
0x9A91, 0x8D77, 0x5C82, 0x4E5E, 0x4F01, 0x542F, 0x5951, 0x780C,
0x5668, 0x6C14, 0x8FC4, 0x5F03, 0x6C7D, 0x6CE3, 0x8BAB, 0x6390,
0x6070, 0x6D3D, 0x7275, 0x6266, 0x948E, 0x94C5, 0x5343, 0x8FC1,
0x7B7E, 0x4EDF, 0x8C26, 0x4E7E, 0x9ED4, 0x94B1, 0x94B3, 0x524D,
0x6F5C, 0x9063, 0x6D45, 0x8C34, 0x5811, 0x5D4C, 0x6B20, 0x6B49,
0x67AA, 0x545B, 0x8154, 0x7F8C, 0x5899, 0x8537, 0x5F3A, 0x62A2,
0x6A47, 0x9539, 0x6572, 0x6084, 0x6865, 0x77A7, 0x4E54, 0x4FA8,
0x5DE7, 0x9798, 0x64AC, 0x7FD8, 0x5CED, 0x4FCF, 0x7A8D, 0x5207,
0x8304, 0x4E14, 0x602F, 0x7A83, 0x94A6, 0x4FB5, 0x4EB2, 0x79E6,
0x7434, 0x52E4, 0x82B9, 0x64D2, 0x79BD, 0x5BDD, 0x6C81, 0x9752,
0x8F7B, 0x6C22, 0x503E, 0x537F, 0x6E05, 0x64CE, 0x6674, 0x6C30,
0x60C5, 0x9877, 0x8BF7, 0x5E86, 0x743C, 0x7A77, 0x79CB, 0x4E18,
0x90B1, 0x7403, 0x6C42, 0x56DA, 0x914B, 0x6CC5, 0x8D8B, 0x533A,
0x86C6, 0x66F2, 0x8EAF, 0x5C48, 0x9A71, 0x6E20, 0x53D6, 0x5A36,
0x9F8B, 0x8DA3, 0x53BB, 0x5708, 0x98A7, 0x6743, 0x919B, 0x6CC9,
0x5168, 0x75CA, 0x62F3, 0x72AC, 0x5238, 0x529D, 0x7F3A, 0x7094,
0x7638, 0x5374, 0x9E4A, 0x69B7, 0x786E, 0x96C0, 0x88D9, 0x7FA4,
0x7136, 0x71C3, 0x5189, 0x67D3, 0x74E4, 0x58E4, 0x6518, 0x56B7,
0x8BA9, 0x9976, 0x6270, 0x7ED5, 0x60F9, 0x70ED, 0x58EC, 0x4EC1,
0x4EBA, 0x5FCD, 0x97E7, 0x4EFB, 0x8BA4, 0x5203, 0x598A, 0x7EAB,
0x6254, 0x4ECD, 0x65E5, 0x620E, 0x8338, 0x84C9, 0x8363, 0x878D,
0x7194, 0x6EB6, 0x5BB9, 0x7ED2, 0x5197, 0x63C9, 0x67D4, 0x8089,
0x8339, 0x8815, 0x5112, 0x5B7A, 0x5982, 0x8FB1, 0x4E73, 0x6C5D,
0x5165, 0x8925, 0x8F6F, 0x962E, 0x854A, 0x745E, 0x9510, 0x95F0,
0x6DA6, 0x82E5, 0x5F31, 0x6492, 0x6D12, 0x8428, 0x816E, 0x9CC3,
0x585E, 0x8D5B, 0x4E09, 0x53C1, 0x4F1E, 0x6563, 0x6851, 0x55D3,
0x4E27, 0x6414, 0x9A9A, 0x626B, 0x5AC2, 0x745F, 0x8272, 0x6DA9,
0x68EE, 0x50E7, 0x838E, 0x7802, 0x6740, 0x5239, 0x6C99, 0x7EB1,
0x50BB, 0x5565, 0x715E, 0x7B5B, 0x6652, 0x73CA, 0x82EB, 0x6749,
0x5C71, 0x5220, 0x717D, 0x886B, 0x95EA, 0x9655, 0x64C5, 0x8D61,
0x81B3, 0x5584, 0x6C55, 0x6247, 0x7F2E, 0x5892, 0x4F24, 0x5546,
0x8D4F, 0x664C, 0x4E0A, 0x5C1A, 0x88F3, 0x68A2, 0x634E, 0x7A0D,
0x70E7, 0x828D, 0x52FA, 0x97F6, 0x5C11, 0x54E8, 0x90B5, 0x7ECD,
0x5962, 0x8D4A, 0x86C7, 0x820C, 0x820D, 0x8D66, 0x6444, 0x5C04,
0x6151, 0x6D89, 0x793E, 0x8BBE, 0x7837, 0x7533, 0x547B, 0x4F38,
0x8EAB, 0x6DF1, 0x5A20, 0x7EC5, 0x795E, 0x6C88, 0x5BA1, 0x5A76,
0x751A, 0x80BE, 0x614E, 0x6E17, 0x58F0, 0x751F, 0x7525, 0x7272,
0x5347, 0x7EF3, 0x7701, 0x76DB, 0x5269, 0x80DC, 0x5723, 0x5E08,
0x5931, 0x72EE, 0x65BD, 0x6E7F, 0x8BD7, 0x5C38, 0x8671, 0x5341,
0x77F3, 0x62FE, 0x65F6, 0x4EC0, 0x98DF, 0x8680, 0x5B9E, 0x8BC6,
0x53F2, 0x77E2, 0x4F7F, 0x5C4E, 0x9A76, 0x59CB, 0x5F0F, 0x793A,
0x58EB, 0x4E16, 0x67FF, 0x4E8B, 0x62ED, 0x8A93, 0x901D, 0x52BF,
0x662F, 0x55DC, 0x566C, 0x9002, 0x4ED5, 0x4F8D, 0x91CA, 0x9970,
0x6C0F, 0x5E02, 0x6043, 0x5BA4, 0x89C6, 0x8BD5, 0x6536, 0x624B,
0x9996, 0x5B88, 0x5BFF, 0x6388, 0x552E, 0x53D7, 0x7626, 0x517D,
0x852C, 0x67A2, 0x68B3, 0x6B8A, 0x6292, 0x8F93, 0x53D4, 0x8212,
0x6DD1, 0x758F, 0x4E66, 0x8D4E, 0x5B70, 0x719F, 0x85AF, 0x6691,
0x66D9, 0x7F72, 0x8700, 0x9ECD, 0x9F20, 0x5C5E, 0x672F, 0x8FF0,
0x6811, 0x675F, 0x620D, 0x7AD6, 0x5885, 0x5EB6, 0x6570, 0x6F31,
0x6055, 0x5237, 0x800D, 0x6454, 0x8870, 0x7529, 0x5E05, 0x6813,
0x62F4, 0x971C, 0x53CC, 0x723D, 0x8C01, 0x6C34, 0x7761, 0x7A0E,
0x542E, 0x77AC, 0x987A, 0x821C, 0x8BF4, 0x7855, 0x6714, 0x70C1,
0x65AF, 0x6495, 0x5636, 0x601D, 0x79C1, 0x53F8, 0x4E1D, 0x6B7B,
0x8086, 0x5BFA, 0x55E3, 0x56DB, 0x4F3A, 0x4F3C, 0x9972, 0x5DF3,
0x677E, 0x8038, 0x6002, 0x9882, 0x9001, 0x5B8B, 0x8BBC, 0x8BF5,
0x641C, 0x8258, 0x64DE, 0x55FD, 0x82CF, 0x9165, 0x4FD7, 0x7D20,
0x901F, 0x7C9F, 0x50F3, 0x5851, 0x6EAF, 0x5BBF, 0x8BC9, 0x8083,
0x9178, 0x849C, 0x7B97, 0x867D, 0x968B, 0x968F, 0x7EE5, 0x9AD3,
0x788E, 0x5C81, 0x7A57, 0x9042, 0x96A7, 0x795F, 0x5B59, 0x635F,
0x7B0B, 0x84D1, 0x68AD, 0x5506, 0x7F29, 0x7410, 0x7D22, 0x9501,
0x6240, 0x584C, 0x4ED6, 0x5B83, 0x5979, 0x5854, 0x736D, 0x631E,
0x8E4B, 0x8E0F, 0x80CE, 0x82D4, 0x62AC, 0x53F0, 0x6CF0, 0x915E,
0x592A, 0x6001, 0x6C70, 0x574D, 0x644A, 0x8D2A, 0x762B, 0x6EE9,
0x575B, 0x6A80, 0x75F0, 0x6F6D, 0x8C2D, 0x8C08, 0x5766, 0x6BEF,
0x8892, 0x78B3, 0x63A2, 0x53F9, 0x70AD, 0x6C64, 0x5858, 0x642A,
0x5802, 0x68E0, 0x819B, 0x5510, 0x7CD6, 0x5018, 0x8EBA, 0x6DCC,
0x8D9F, 0x70EB, 0x638F, 0x6D9B, 0x6ED4, 0x7EE6, 0x8404, 0x6843,
0x9003, 0x6DD8, 0x9676, 0x8BA8, 0x5957, 0x7279, 0x85E4, 0x817E,
0x75BC, 0x8A8A, 0x68AF, 0x5254, 0x8E22, 0x9511, 0x63D0, 0x9898,
0x8E44, 0x557C, 0x4F53, 0x66FF, 0x568F, 0x60D5, 0x6D95, 0x5243,
0x5C49, 0x5929, 0x6DFB, 0x586B, 0x7530, 0x751C, 0x606C, 0x8214,
0x8146, 0x6311, 0x6761, 0x8FE2, 0x773A, 0x8DF3, 0x8D34, 0x94C1,
0x5E16, 0x5385, 0x542C, 0x70C3, 0x6C40, 0x5EF7, 0x505C, 0x4EAD,
0x5EAD, 0x633A, 0x8247, 0x901A, 0x6850, 0x916E, 0x77B3, 0x540C,
0x94DC, 0x5F64, 0x7AE5, 0x6876, 0x6345, 0x7B52, 0x7EDF, 0x75DB,
0x5077, 0x6295, 0x5934, 0x900F, 0x51F8, 0x79C3, 0x7A81, 0x56FE,
0x5F92, 0x9014, 0x6D82, 0x5C60, 0x571F, 0x5410, 0x5154, 0x6E4D,
0x56E2, 0x63A8, 0x9893, 0x817F, 0x8715, 0x892A, 0x9000, 0x541E,
0x5C6F, 0x81C0, 0x62D6, 0x6258, 0x8131, 0x9E35, 0x9640, 0x9A6E,
0x9A7C, 0x692D, 0x59A5, 0x62D3, 0x553E, 0x6316, 0x54C7, 0x86D9,
0x6D3C, 0x5A03, 0x74E6, 0x889C, 0x6B6A, 0x5916, 0x8C4C, 0x5F2F,
0x6E7E, 0x73A9, 0x987D, 0x4E38, 0x70F7, 0x5B8C, 0x7897, 0x633D,
0x665A, 0x7696, 0x60CB, 0x5B9B, 0x5A49, 0x4E07, 0x8155, 0x6C6A,
0x738B, 0x4EA1, 0x6789, 0x7F51, 0x5F80, 0x65FA, 0x671B, 0x5FD8,
0x5984, 0x5A01, 0x5DCD, 0x5FAE, 0x5371, 0x97E6, 0x8FDD, 0x6845,
0x56F4, 0x552F, 0x60DF, 0x4E3A, 0x6F4D, 0x7EF4, 0x82C7, 0x840E,
0x59D4, 0x4F1F, 0x4F2A, 0x5C3E, 0x7EAC, 0x672A, 0x851A, 0x5473,
0x754F, 0x80C3, 0x5582, 0x9B4F, 0x4F4D, 0x6E2D, 0x8C13, 0x5C09,
0x6170, 0x536B, 0x761F, 0x6E29, 0x868A, 0x6587, 0x95FB, 0x7EB9,
0x543B, 0x7A33, 0x7D0A, 0x95EE, 0x55E1, 0x7FC1, 0x74EE, 0x631D,
0x8717, 0x6DA1, 0x7A9D, 0x6211, 0x65A1, 0x5367, 0x63E1, 0x6C83,
0x5DEB, 0x545C, 0x94A8, 0x4E4C, 0x6C61, 0x8BEC, 0x5C4B, 0x65E0,
0x829C, 0x68A7, 0x543E, 0x5434, 0x6BCB, 0x6B66, 0x4E94, 0x6342,
0x5348, 0x821E, 0x4F0D, 0x4FAE, 0x575E, 0x620A, 0x96FE, 0x6664,
0x7269, 0x52FF, 0x52A1, 0x609F, 0x8BEF, 0x6614, 0x7199, 0x6790,
0x897F, 0x7852, 0x77FD, 0x6670, 0x563B, 0x5438, 0x9521, 0x727A,
0x7A00, 0x606F, 0x5E0C, 0x6089, 0x819D, 0x5915, 0x60DC, 0x7184,
0x70EF, 0x6EAA, 0x6C50, 0x7280, 0x6A84, 0x88AD, 0x5E2D, 0x4E60,
0x5AB3, 0x559C, 0x94E3, 0x6D17, 0x7CFB, 0x9699, 0x620F, 0x7EC6,
0x778E, 0x867E, 0x5323, 0x971E, 0x8F96, 0x6687, 0x5CE1, 0x4FA0,
0x72ED, 0x4E0B, 0x53A6, 0x590F, 0x5413, 0x6380, 0x9528, 0x5148,
0x4ED9, 0x9C9C, 0x7EA4, 0x54B8, 0x8D24, 0x8854, 0x8237, 0x95F2,
0x6D8E, 0x5F26, 0x5ACC, 0x663E, 0x9669, 0x73B0, 0x732E, 0x53BF,
0x817A, 0x9985, 0x7FA1, 0x5BAA, 0x9677, 0x9650, 0x7EBF, 0x76F8,
0x53A2, 0x9576, 0x9999, 0x7BB1, 0x8944, 0x6E58, 0x4E61, 0x7FD4,
0x7965, 0x8BE6, 0x60F3, 0x54CD, 0x4EAB, 0x9879, 0x5DF7, 0x6A61,
0x50CF, 0x5411, 0x8C61, 0x8427, 0x785D, 0x9704, 0x524A, 0x54EE,
0x56A3, 0x9500, 0x6D88, 0x5BB5, 0x6DC6, 0x6653, 0x5C0F, 0x5B5D,
0x6821, 0x8096, 0x5578, 0x7B11, 0x6548, 0x6954, 0x4E9B, 0x6B47,
0x874E, 0x978B, 0x534F, 0x631F, 0x643A, 0x90AA, 0x659C, 0x80C1,
0x8C10, 0x5199, 0x68B0, 0x5378, 0x87F9, 0x61C8, 0x6CC4, 0x6CFB,
0x8C22, 0x5C51, 0x85AA, 0x82AF, 0x950C, 0x6B23, 0x8F9B, 0x65B0,
0x5FFB, 0x5FC3, 0x4FE1, 0x8845, 0x661F, 0x8165, 0x7329, 0x60FA,
0x5174, 0x5211, 0x578B, 0x5F62, 0x90A2, 0x884C, 0x9192, 0x5E78,
0x674F, 0x6027, 0x59D3, 0x5144, 0x51F6, 0x80F8, 0x5308, 0x6C79,
0x96C4, 0x718A, 0x4F11, 0x4FEE, 0x7F9E, 0x673D, 0x55C5, 0x9508,
0x79C0, 0x8896, 0x7EE3, 0x589F, 0x620C, 0x9700, 0x865A, 0x5618,
0x987B, 0x5F90, 0x8BB8, 0x84C4, 0x9157, 0x53D9, 0x65ED, 0x5E8F,
0x755C, 0x6064, 0x7D6E, 0x5A7F, 0x7EEA, 0x7EED, 0x8F69, 0x55A7,
0x5BA3, 0x60AC, 0x65CB, 0x7384, 0x9009, 0x7663, 0x7729, 0x7EDA,
0x9774, 0x859B, 0x5B66, 0x7A74, 0x96EA, 0x8840, 0x52CB, 0x718F,
0x5FAA, 0x65EC, 0x8BE2, 0x5BFB, 0x9A6F, 0x5DE1, 0x6B89, 0x6C5B,
0x8BAD, 0x8BAF, 0x900A, 0x8FC5, 0x538B, 0x62BC, 0x9E26, 0x9E2D,
0x5440, 0x4E2B, 0x82BD, 0x7259, 0x869C, 0x5D16, 0x8859, 0x6DAF,
0x96C5, 0x54D1, 0x4E9A, 0x8BB6, 0x7109, 0x54BD, 0x9609, 0x70DF,
0x6DF9, 0x76D0, 0x4E25, 0x7814, 0x8712, 0x5CA9, 0x5EF6, 0x8A00,
0x989C, 0x960E, 0x708E, 0x6CBF, 0x5944, 0x63A9, 0x773C, 0x884D,
0x6F14, 0x8273, 0x5830, 0x71D5, 0x538C, 0x781A, 0x96C1, 0x5501,
0x5F66, 0x7130, 0x5BB4, 0x8C1A, 0x9A8C, 0x6B83, 0x592E, 0x9E2F,
0x79E7, 0x6768, 0x626C, 0x4F6F, 0x75A1, 0x7F8A, 0x6D0B, 0x9633,
0x6C27, 0x4EF0, 0x75D2, 0x517B, 0x6837, 0x6F3E, 0x9080, 0x8170,
0x5996, 0x7476, 0x6447, 0x5C27, 0x9065, 0x7A91, 0x8C23, 0x59DA,
0x54AC, 0x8200, 0x836F, 0x8981, 0x8000, 0x6930, 0x564E, 0x8036,
0x7237, 0x91CE, 0x51B6, 0x4E5F, 0x9875, 0x6396, 0x4E1A, 0x53F6,
0x66F3, 0x814B, 0x591C, 0x6DB2, 0x4E00, 0x58F9, 0x533B, 0x63D6,
0x94F1, 0x4F9D, 0x4F0A, 0x8863, 0x9890, 0x5937, 0x9057, 0x79FB,
0x4EEA, 0x80F0, 0x7591, 0x6C82, 0x5B9C, 0x59E8, 0x5F5D, 0x6905,
0x8681, 0x501A, 0x5DF2, 0x4E59, 0x77E3, 0x4EE5, 0x827A, 0x6291,
0x6613, 0x9091, 0x5C79, 0x4EBF, 0x5F79, 0x81C6, 0x9038, 0x8084,
0x75AB, 0x4EA6, 0x88D4, 0x610F, 0x6BC5, 0x5FC6, 0x4E49, 0x76CA,
0x6EA2, 0x8BE3, 0x8BAE, 0x8C0A, 0x8BD1, 0x5F02, 0x7FFC, 0x7FCC,
0x7ECE, 0x8335, 0x836B, 0x56E0, 0x6BB7, 0x97F3, 0x9634, 0x59FB,
0x541F, 0x94F6, 0x6DEB, 0x5BC5, 0x996E, 0x5C39, 0x5F15, 0x9690,
0x5370, 0x82F1, 0x6A31, 0x5A74, 0x9E70, 0x5E94, 0x7F28, 0x83B9,
0x8424, 0x8425, 0x8367, 0x8747, 0x8FCE, 0x8D62, 0x76C8, 0x5F71,
0x9896, 0x786C, 0x6620, 0x54DF, 0x62E5, 0x4F63, 0x81C3, 0x75C8,
0x5EB8, 0x96CD, 0x8E0A, 0x86F9, 0x548F, 0x6CF3, 0x6D8C, 0x6C38,
0x607F, 0x52C7, 0x7528, 0x5E7D, 0x4F18, 0x60A0, 0x5FE7, 0x5C24,
0x7531, 0x90AE, 0x94C0, 0x72B9, 0x6CB9, 0x6E38, 0x9149, 0x6709,
0x53CB, 0x53F3, 0x4F51, 0x91C9, 0x8BF1, 0x53C8, 0x5E7C, 0x8FC2,
0x6DE4, 0x4E8E, 0x76C2, 0x6986, 0x865E, 0x611A, 0x8206, 0x4F59,
0x4FDE, 0x903E, 0x9C7C, 0x6109, 0x6E1D, 0x6E14, 0x9685, 0x4E88,
0x5A31, 0x96E8, 0x4E0E, 0x5C7F, 0x79B9, 0x5B87, 0x8BED, 0x7FBD,
0x7389, 0x57DF, 0x828B, 0x90C1, 0x5401, 0x9047, 0x55BB, 0x5CEA,
0x5FA1, 0x6108, 0x6B32, 0x72F1, 0x80B2, 0x8A89, 0x6D74, 0x5BD3,
0x88D5, 0x9884, 0x8C6B, 0x9A6D, 0x9E33, 0x6E0A, 0x51A4, 0x5143,
0x57A3, 0x8881, 0x539F, 0x63F4, 0x8F95, 0x56ED, 0x5458, 0x5706,
0x733F, 0x6E90, 0x7F18, 0x8FDC, 0x82D1, 0x613F, 0x6028, 0x9662,
0x66F0, 0x7EA6, 0x8D8A, 0x8DC3, 0x94A5, 0x5CB3, 0x7CA4, 0x6708,
0x60A6, 0x9605, 0x8018, 0x4E91, 0x90E7, 0x5300, 0x9668, 0x5141,
0x8FD0, 0x8574, 0x915D, 0x6655, 0x97F5, 0x5B55, 0x531D, 0x7838,
0x6742, 0x683D, 0x54C9, 0x707E, 0x5BB0, 0x8F7D, 0x518D, 0x5728,
0x54B1, 0x6512, 0x6682, 0x8D5E, 0x8D43, 0x810F, 0x846C, 0x906D,
0x7CDF, 0x51FF, 0x85FB, 0x67A3, 0x65E9, 0x6FA1, 0x86A4, 0x8E81,
0x566A, 0x9020, 0x7682, 0x7076, 0x71E5, 0x8D23, 0x62E9, 0x5219,
0x6CFD, 0x8D3C, 0x600E, 0x589E, 0x618E, 0x66FE, 0x8D60, 0x624E,
0x55B3, 0x6E23, 0x672D, 0x8F67, 0x94E1, 0x95F8, 0x7728, 0x6805,
0x69A8, 0x548B, 0x4E4D, 0x70B8, 0x8BC8, 0x6458, 0x658B, 0x5B85,
0x7A84, 0x503A, 0x5BE8, 0x77BB, 0x6BE1, 0x8A79, 0x7C98, 0x6CBE,
0x76CF, 0x65A9, 0x8F97, 0x5D2D, 0x5C55, 0x8638, 0x6808, 0x5360,
0x6218, 0x7AD9, 0x6E5B, 0x7EFD, 0x6A1F, 0x7AE0, 0x5F70, 0x6F33,
0x5F20, 0x638C, 0x6DA8, 0x6756, 0x4E08, 0x5E10, 0x8D26, 0x4ED7,
0x80C0, 0x7634, 0x969C, 0x62DB, 0x662D, 0x627E, 0x6CBC, 0x8D75,
0x7167, 0x7F69, 0x5146, 0x8087, 0x53EC, 0x906E, 0x6298, 0x54F2,
0x86F0, 0x8F99, 0x8005, 0x9517, 0x8517, 0x8FD9, 0x6D59, 0x73CD,
0x659F, 0x771F, 0x7504, 0x7827, 0x81FB, 0x8D1E, 0x9488, 0x4FA6,
0x6795, 0x75B9, 0x8BCA, 0x9707, 0x632F, 0x9547, 0x9635, 0x84B8,
0x6323, 0x7741, 0x5F81, 0x72F0, 0x4E89, 0x6014, 0x6574, 0x62EF,
0x6B63, 0x653F, 0x5E27, 0x75C7, 0x90D1, 0x8BC1, 0x829D, 0x679D,
0x652F, 0x5431, 0x8718, 0x77E5, 0x80A2, 0x8102, 0x6C41, 0x4E4B,
0x7EC7, 0x804C, 0x76F4, 0x690D, 0x6B96, 0x6267, 0x503C, 0x4F84,
0x5740, 0x6307, 0x6B62, 0x8DBE, 0x53EA, 0x65E8, 0x7EB8, 0x5FD7,
0x631A, 0x63B7, 0x81F3, 0x81F4, 0x7F6E, 0x5E1C, 0x5CD9, 0x5236,
0x667A, 0x79E9, 0x7A1A, 0x8D28, 0x7099, 0x75D4, 0x6EDE, 0x6CBB,
0x7A92, 0x4E2D, 0x76C5, 0x5FE0, 0x949F, 0x8877, 0x7EC8, 0x79CD,
0x80BF, 0x91CD, 0x4EF2, 0x4F17, 0x821F, 0x5468, 0x5DDE, 0x6D32,
0x8BCC, 0x7CA5, 0x8F74, 0x8098, 0x5E1A, 0x5492, 0x76B1, 0x5B99,
0x663C, 0x9AA4, 0x73E0, 0x682A, 0x86DB, 0x6731, 0x732A, 0x8BF8,
0x8BDB, 0x9010, 0x7AF9, 0x70DB, 0x716E, 0x62C4, 0x77A9, 0x5631,
0x4E3B, 0x8457, 0x67F1, 0x52A9, 0x86C0, 0x8D2E, 0x94F8, 0x7B51,
0x4F4F, 0x6CE8, 0x795D, 0x9A7B, 0x6293, 0x722A, 0x62FD, 0x4E13,
0x7816, 0x8F6C, 0x64B0, 0x8D5A, 0x7BC6, 0x6869, 0x5E84, 0x88C5,
0x5986, 0x649E, 0x58EE, 0x72B6, 0x690E, 0x9525, 0x8FFD, 0x8D58,
0x5760, 0x7F00, 0x8C06, 0x51C6, 0x6349, 0x62D9, 0x5353, 0x684C,
0x7422, 0x8301, 0x914C, 0x5544, 0x7740, 0x707C, 0x6D4A, 0x5179,
0x54A8, 0x8D44, 0x59FF, 0x6ECB, 0x6DC4, 0x5B5C, 0x7D2B, 0x4ED4,
0x7C7D, 0x6ED3, 0x5B50, 0x81EA, 0x6E0D, 0x5B57, 0x9B03, 0x68D5,
0x8E2A, 0x5B97, 0x7EFC, 0x603B, 0x7EB5, 0x90B9, 0x8D70, 0x594F,
0x63CD, 0x79DF, 0x8DB3, 0x5352, 0x65CF, 0x7956, 0x8BC5, 0x963B,
0x7EC4, 0x94BB, 0x7E82, 0x5634, 0x9189, 0x6700, 0x7F6A, 0x5C0A,
0x9075, 0x6628, 0x5DE6, 0x4F50, 0x67DE, 0x505A, 0x4F5C, 0x5750,
0x5EA7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4E8D, 0x4E0C,
0x5140, 0x4E10, 0x5EFF, 0x5345, 0x4E15, 0x4E98, 0x4E1E, 0x9B32,
0x5B6C, 0x5669, 0x4E28, 0x79BA, 0x4E3F, 0x5315, 0x4E47, 0x592D,
0x723B, 0x536E, 0x6C10, 0x56DF, 0x80E4, 0x9997, 0x6BD3, 0x777E,
0x9F17, 0x4E36, 0x4E9F, 0x9F10, 0x4E5C, 0x4E69, 0x4E93, 0x8288,
0x5B5B, 0x556C, 0x560F, 0x4EC4, 0x538D, 0x539D, 0x53A3, 0x53A5,
0x53AE, 0x9765, 0x8D5D, 0x531A, 0x53F5, 0x5326, 0x532E, 0x533E,
0x8D5C, 0x5366, 0x5363, 0x5202, 0x5208, 0x520E, 0x522D, 0x5233,
0x523F, 0x5240, 0x524C, 0x525E, 0x5261, 0x525C, 0x84AF, 0x527D,
0x5282, 0x5281, 0x5290, 0x5293, 0x5182, 0x7F54, 0x4EBB, 0x4EC3,
0x4EC9, 0x4EC2, 0x4EE8, 0x4EE1, 0x4EEB, 0x4EDE, 0x4F1B, 0x4EF3,
0x4F22, 0x4F64, 0x4EF5, 0x4F25, 0x4F27, 0x4F09, 0x4F2B, 0x4F5E,
0x4F67, 0x6538, 0x4F5A, 0x4F5D, 0x4F5F, 0x4F57, 0x4F32, 0x4F3D,
0x4F76, 0x4F74, 0x4F91, 0x4F89, 0x4F83, 0x4F8F, 0x4F7E, 0x4F7B,
0x4FAA, 0x4F7C, 0x4FAC, 0x4F94, 0x4FE6, 0x4FE8, 0x4FEA, 0x4FC5,
0x4FDA, 0x4FE3, 0x4FDC, 0x4FD1, 0x4FDF, 0x4FF8, 0x5029, 0x504C,
0x4FF3, 0x502C, 0x500F, 0x502E, 0x502D, 0x4FFE, 0x501C, 0x500C,
0x5025, 0x5028, 0x507E, 0x5043, 0x5055, 0x5048, 0x504E, 0x506C,
0x507B, 0x50A5, 0x50A7, 0x50A9, 0x50BA, 0x50D6, 0x5106, 0x50ED,
0x50EC, 0x50E6, 0x50EE, 0x5107, 0x510B, 0x4EDD, 0x6C3D, 0x4F58,
0x4F65, 0x4FCE, 0x9FA0, 0x6C46, 0x7C74, 0x516E, 0x5DFD, 0x9EC9,
0x9998, 0x5181, 0x5914, 0x52F9, 0x530D, 0x8A07, 0x5310, 0x51EB,
0x5919, 0x5155, 0x4EA0, 0x5156, 0x4EB3, 0x886E, 0x88A4, 0x4EB5,
0x8114, 0x88D2, 0x7980, 0x5B34, 0x8803, 0x7FB8, 0x51AB, 0x51B1,
0x51BD, 0x51BC, 0x51C7, 0x5196, 0x51A2, 0x51A5, 0x8BA0, 0x8BA6,
0x8BA7, 0x8BAA, 0x8BB4, 0x8BB5, 0x8BB7, 0x8BC2, 0x8BC3, 0x8BCB,
0x8BCF, 0x8BCE, 0x8BD2, 0x8BD3, 0x8BD4, 0x8BD6, 0x8BD8, 0x8BD9,
0x8BDC, 0x8BDF, 0x8BE0, 0x8BE4, 0x8BE8, 0x8BE9, 0x8BEE, 0x8BF0,
0x8BF3, 0x8BF6, 0x8BF9, 0x8BFC, 0x8BFF, 0x8C00, 0x8C02, 0x8C04,
0x8C07, 0x8C0C, 0x8C0F, 0x8C11, 0x8C12, 0x8C14, 0x8C15, 0x8C16,
0x8C19, 0x8C1B, 0x8C18, 0x8C1D, 0x8C1F, 0x8C20, 0x8C21, 0x8C25,
0x8C27, 0x8C2A, 0x8C2B, 0x8C2E, 0x8C2F, 0x8C32, 0x8C33, 0x8C35,
0x8C36, 0x5369, 0x537A, 0x961D, 0x9622, 0x9621, 0x9631, 0x962A,
0x963D, 0x963C, 0x9642, 0x9649, 0x9654, 0x965F, 0x9667, 0x966C,
0x9672, 0x9674, 0x9688, 0x968D, 0x9697, 0x96B0, 0x9097, 0x909B,
0x909D, 0x9099, 0x90AC, 0x90A1, 0x90B4, 0x90B3, 0x90B6, 0x90BA,
0x90B8, 0x90B0, 0x90CF, 0x90C5, 0x90BE, 0x90D0, 0x90C4, 0x90C7,
0x90D3, 0x90E6, 0x90E2, 0x90DC, 0x90D7, 0x90DB, 0x90EB, 0x90EF,
0x90FE, 0x9104, 0x9122, 0x911E, 0x9123, 0x9131, 0x912F, 0x9139,
0x9143, 0x9146, 0x520D, 0x5942, 0x52A2, 0x52AC, 0x52AD, 0x52BE,
0x54FF, 0x52D0, 0x52D6, 0x52F0, 0x53DF, 0x71EE, 0x77CD, 0x5EF4,
0x51F5, 0x51FC, 0x9B2F, 0x53B6, 0x5F01, 0x755A, 0x5DEF, 0x574C,
0x57A9, 0x57A1, 0x587E, 0x58BC, 0x58C5, 0x58D1, 0x5729, 0x572C,
0x572A, 0x5733, 0x5739, 0x572E, 0x572F, 0x575C, 0x573B, 0x5742,
0x5769, 0x5785, 0x576B, 0x5786, 0x577C, 0x577B, 0x5768, 0x576D,
0x5776, 0x5773, 0x57AD, 0x57A4, 0x578C, 0x57B2, 0x57CF, 0x57A7,
0x57B4, 0x5793, 0x57A0, 0x57D5, 0x57D8, 0x57DA, 0x57D9, 0x57D2,
0x57B8, 0x57F4, 0x57EF, 0x57F8, 0x57E4, 0x57DD, 0x580B, 0x580D,
0x57FD, 0x57ED, 0x5800, 0x581E, 0x5819, 0x5844, 0x5820, 0x5865,
0x586C, 0x5881, 0x5889, 0x589A, 0x5880, 0x99A8, 0x9F19, 0x61FF,
0x8279, 0x827D, 0x827F, 0x828F, 0x828A, 0x82A8, 0x8284, 0x828E,
0x8291, 0x8297, 0x8299, 0x82AB, 0x82B8, 0x82BE, 0x82B0, 0x82C8,
0x82CA, 0x82E3, 0x8298, 0x82B7, 0x82AE, 0x82CB, 0x82CC, 0x82C1,
0x82A9, 0x82B4, 0x82A1, 0x82AA, 0x829F, 0x82C4, 0x82CE, 0x82A4,
0x82E1, 0x8309, 0x82F7, 0x82E4, 0x830F, 0x8307, 0x82DC, 0x82F4,
0x82D2, 0x82D8, 0x830C, 0x82FB, 0x82D3, 0x8311, 0x831A, 0x8306,
0x8314, 0x8315, 0x82E0, 0x82D5, 0x831C, 0x8351, 0x835B, 0x835C,
0x8308, 0x8392, 0x833C, 0x8334, 0x8331, 0x839B, 0x835E, 0x832F,
0x834F, 0x8347, 0x8343, 0x835F, 0x8340, 0x8317, 0x8360, 0x832D,
0x833A, 0x8333, 0x8366, 0x8365, 0x8368, 0x831B, 0x8369, 0x836C,
0x836A, 0x836D, 0x836E, 0x83B0, 0x8378, 0x83B3, 0x83B4, 0x83A0,
0x83AA, 0x8393, 0x839C, 0x8385, 0x837C, 0x83B6, 0x83A9, 0x837D,
0x83B8, 0x837B, 0x8398, 0x839E, 0x83A8, 0x83BA, 0x83BC, 0x83C1,
0x8401, 0x83E5, 0x83D8, 0x5807, 0x8418, 0x840B, 0x83DD, 0x83FD,
0x83D6, 0x841C, 0x8438, 0x8411, 0x8406, 0x83D4, 0x83DF, 0x840F,
0x8403, 0x83F8, 0x83F9, 0x83EA, 0x83C5, 0x83C0, 0x8426, 0x83F0,
0x83E1, 0x845C, 0x8451, 0x845A, 0x8459, 0x8473, 0x8487, 0x8488,
0x847A, 0x8489, 0x8478, 0x843C, 0x8446, 0x8469, 0x8476, 0x848C,
0x848E, 0x8431, 0x846D, 0x84C1, 0x84CD, 0x84D0, 0x84E6, 0x84BD,
0x84D3, 0x84CA, 0x84BF, 0x84BA, 0x84E0, 0x84A1, 0x84B9, 0x84B4,
0x8497, 0x84E5, 0x84E3, 0x850C, 0x750D, 0x8538, 0x84F0, 0x8539,
0x851F, 0x853A, 0x8556, 0x853B, 0x84FF, 0x84FC, 0x8559, 0x8548,
0x8568, 0x8564, 0x855E, 0x857A, 0x77A2, 0x8543, 0x8572, 0x857B,
0x85A4, 0x85A8, 0x8587, 0x858F, 0x8579, 0x85AE, 0x859C, 0x8585,
0x85B9, 0x85B7, 0x85B0, 0x85D3, 0x85C1, 0x85DC, 0x85FF, 0x8627,
0x8605, 0x8629, 0x8616, 0x863C, 0x5EFE, 0x5F08, 0x593C, 0x5941,
0x8037, 0x5955, 0x595A, 0x5958, 0x530F, 0x5C22, 0x5C25, 0x5C2C,
0x5C34, 0x624C, 0x626A, 0x629F, 0x62BB, 0x62CA, 0x62DA, 0x62D7,
0x62EE, 0x6322, 0x62F6, 0x6339, 0x634B, 0x6343, 0x63AD, 0x63F6,
0x6371, 0x637A, 0x638E, 0x63B4, 0x636D, 0x63AC, 0x638A, 0x6369,
0x63AE, 0x63BC, 0x63F2, 0x63F8, 0x63E0, 0x63FF, 0x63C4, 0x63DE,
0x63CE, 0x6452, 0x63C6, 0x63BE, 0x6445, 0x6441, 0x640B, 0x641B,
0x6420, 0x640C, 0x6426, 0x6421, 0x645E, 0x6484, 0x646D, 0x6496,
0x647A, 0x64B7, 0x64B8, 0x6499, 0x64BA, 0x64C0, 0x64D0, 0x64D7,
0x64E4, 0x64E2, 0x6509, 0x6525, 0x652E, 0x5F0B, 0x5FD2, 0x7519,
0x5F11, 0x535F, 0x53F1, 0x53FD, 0x53E9, 0x53E8, 0x53FB, 0x5412,
0x5416, 0x5406, 0x544B, 0x5452, 0x5453, 0x5454, 0x5456, 0x5443,
0x5421, 0x5457, 0x5459, 0x5423, 0x5432, 0x5482, 0x5494, 0x5477,
0x5471, 0x5464, 0x549A, 0x549B, 0x5484, 0x5476, 0x5466, 0x549D,
0x54D0, 0x54AD, 0x54C2, 0x54B4, 0x54D2, 0x54A7, 0x54A6, 0x54D3,
0x54D4, 0x5472, 0x54A3, 0x54D5, 0x54BB, 0x54BF, 0x54CC, 0x54D9,
0x54DA, 0x54DC, 0x54A9, 0x54AA, 0x54A4, 0x54DD, 0x54CF, 0x54DE,
0x551B, 0x54E7, 0x5520, 0x54FD, 0x5514, 0x54F3, 0x5522, 0x5523,
0x550F, 0x5511, 0x5527, 0x552A, 0x5567, 0x558F, 0x55B5, 0x5549,
0x556D, 0x5541, 0x5555, 0x553F, 0x5550, 0x553C, 0x5537, 0x5556,
0x5575, 0x5576, 0x5577, 0x5533, 0x5530, 0x555C, 0x558B, 0x55D2,
0x5583, 0x55B1, 0x55B9, 0x5588, 0x5581, 0x559F, 0x557E, 0x55D6,
0x5591, 0x557B, 0x55DF, 0x55BD, 0x55BE, 0x5594, 0x5599, 0x55EA,
0x55F7, 0x55C9, 0x561F, 0x55D1, 0x55EB, 0x55EC, 0x55D4, 0x55E6,
0x55DD, 0x55C4, 0x55EF, 0x55E5, 0x55F2, 0x55F3, 0x55CC, 0x55CD,
0x55E8, 0x55F5, 0x55E4, 0x8F94, 0x561E, 0x5608, 0x560C, 0x5601,
0x5624, 0x5623, 0x55FE, 0x5600, 0x5627, 0x562D, 0x5658, 0x5639,
0x5657, 0x562C, 0x564D, 0x5662, 0x5659, 0x565C, 0x564C, 0x5654,
0x5686, 0x5664, 0x5671, 0x566B, 0x567B, 0x567C, 0x5685, 0x5693,
0x56AF, 0x56D4, 0x56D7, 0x56DD, 0x56E1, 0x56F5, 0x56EB, 0x56F9,
0x56FF, 0x5704, 0x570A, 0x5709, 0x571C, 0x5E0F, 0x5E19, 0x5E14,
0x5E11, 0x5E31, 0x5E3B, 0x5E3C, 0x5E37, 0x5E44, 0x5E54, 0x5E5B,
0x5E5E, 0x5E61, 0x5C8C, 0x5C7A, 0x5C8D, 0x5C90, 0x5C96, 0x5C88,
0x5C98, 0x5C99, 0x5C91, 0x5C9A, 0x5C9C, 0x5CB5, 0x5CA2, 0x5CBD,
0x5CAC, 0x5CAB, 0x5CB1, 0x5CA3, 0x5CC1, 0x5CB7, 0x5CC4, 0x5CD2,
0x5CE4, 0x5CCB, 0x5CE5, 0x5D02, 0x5D03, 0x5D27, 0x5D26, 0x5D2E,
0x5D24, 0x5D1E, 0x5D06, 0x5D1B, 0x5D58, 0x5D3E, 0x5D34, 0x5D3D,
0x5D6C, 0x5D5B, 0x5D6F, 0x5D5D, 0x5D6B, 0x5D4B, 0x5D4A, 0x5D69,
0x5D74, 0x5D82, 0x5D99, 0x5D9D, 0x8C73, 0x5DB7, 0x5DC5, 0x5F73,
0x5F77, 0x5F82, 0x5F87, 0x5F89, 0x5F8C, 0x5F95, 0x5F99, 0x5F9C,
0x5FA8, 0x5FAD, 0x5FB5, 0x5FBC, 0x8862, 0x5F61, 0x72AD, 0x72B0,
0x72B4, 0x72B7, 0x72B8, 0x72C3, 0x72C1, 0x72CE, 0x72CD, 0x72D2,
0x72E8, 0x72EF, 0x72E9, 0x72F2, 0x72F4, 0x72F7, 0x7301, 0x72F3,
0x7303, 0x72FA, 0x72FB, 0x7317, 0x7313, 0x7321, 0x730A, 0x731E,
0x731D, 0x7315, 0x7322, 0x7339, 0x7325, 0x732C, 0x7338, 0x7331,
0x7350, 0x734D, 0x7357, 0x7360, 0x736C, 0x736F, 0x737E, 0x821B,
0x5925, 0x98E7, 0x5924, 0x5902, 0x9963, 0x9967, 0x9968, 0x9969,
0x996A, 0x996B, 0x996C, 0x9974, 0x9977, 0x997D, 0x9980, 0x9984,
0x9987, 0x998A, 0x998D, 0x9990, 0x9991, 0x9993, 0x9994, 0x9995,
0x5E80, 0x5E91, 0x5E8B, 0x5E96, 0x5EA5, 0x5EA0, 0x5EB9, 0x5EB5,
0x5EBE, 0x5EB3, 0x8D53, 0x5ED2, 0x5ED1, 0x5EDB, 0x5EE8, 0x5EEA,
0x81BA, 0x5FC4, 0x5FC9, 0x5FD6, 0x5FCF, 0x6003, 0x5FEE, 0x6004,
0x5FE1, 0x5FE4, 0x5FFE, 0x6005, 0x6006, 0x5FEA, 0x5FED, 0x5FF8,
0x6019, 0x6035, 0x6026, 0x601B, 0x600F, 0x600D, 0x6029, 0x602B,
0x600A, 0x603F, 0x6021, 0x6078, 0x6079, 0x607B, 0x607A, 0x6042,
0x606A, 0x607D, 0x6096, 0x609A, 0x60AD, 0x609D, 0x6083, 0x6092,
0x608C, 0x609B, 0x60EC, 0x60BB, 0x60B1, 0x60DD, 0x60D8, 0x60C6,
0x60DA, 0x60B4, 0x6120, 0x6126, 0x6115, 0x6123, 0x60F4, 0x6100,
0x610E, 0x612B, 0x614A, 0x6175, 0x61AC, 0x6194, 0x61A7, 0x61B7,
0x61D4, 0x61F5, 0x5FDD, 0x96B3, 0x95E9, 0x95EB, 0x95F1, 0x95F3,
0x95F5, 0x95F6, 0x95FC, 0x95FE, 0x9603, 0x9604, 0x9606, 0x9608,
0x960A, 0x960B, 0x960C, 0x960D, 0x960F, 0x9612, 0x9615, 0x9616,
0x9617, 0x9619, 0x961A, 0x4E2C, 0x723F, 0x6215, 0x6C35, 0x6C54,
0x6C5C, 0x6C4A, 0x6CA3, 0x6C85, 0x6C90, 0x6C94, 0x6C8C, 0x6C68,
0x6C69, 0x6C74, 0x6C76, 0x6C86, 0x6CA9, 0x6CD0, 0x6CD4, 0x6CAD,
0x6CF7, 0x6CF8, 0x6CF1, 0x6CD7, 0x6CB2, 0x6CE0, 0x6CD6, 0x6CFA,
0x6CEB, 0x6CEE, 0x6CB1, 0x6CD3, 0x6CEF, 0x6CFE, 0x6D39, 0x6D27,
0x6D0C, 0x6D43, 0x6D48, 0x6D07, 0x6D04, 0x6D19, 0x6D0E, 0x6D2B,
0x6D4D, 0x6D2E, 0x6D35, 0x6D1A, 0x6D4F, 0x6D52, 0x6D54, 0x6D33,
0x6D91, 0x6D6F, 0x6D9E, 0x6DA0, 0x6D5E, 0x6D93, 0x6D94, 0x6D5C,
0x6D60, 0x6D7C, 0x6D63, 0x6E1A, 0x6DC7, 0x6DC5, 0x6DDE, 0x6E0E,
0x6DBF, 0x6DE0, 0x6E11, 0x6DE6, 0x6DDD, 0x6DD9, 0x6E16, 0x6DAB,
0x6E0C, 0x6DAE, 0x6E2B, 0x6E6E, 0x6E4E, 0x6E6B, 0x6EB2, 0x6E5F,
0x6E86, 0x6E53, 0x6E54, 0x6E32, 0x6E25, 0x6E44, 0x6EDF, 0x6EB1,
0x6E98, 0x6EE0, 0x6F2D, 0x6EE2, 0x6EA5, 0x6EA7, 0x6EBD, 0x6EBB,
0x6EB7, 0x6ED7, 0x6EB4, 0x6ECF, 0x6E8F, 0x6EC2, 0x6E9F, 0x6F62,
0x6F46, 0x6F47, 0x6F24, 0x6F15, 0x6EF9, 0x6F2F, 0x6F36, 0x6F4B,
0x6F74, 0x6F2A, 0x6F09, 0x6F29, 0x6F89, 0x6F8D, 0x6F8C, 0x6F78,
0x6F72, 0x6F7C, 0x6F7A, 0x6FD1, 0x6FC9, 0x6FA7, 0x6FB9, 0x6FB6,
0x6FC2, 0x6FE1, 0x6FEE, 0x6FDE, 0x6FE0, 0x6FEF, 0x701A, 0x7023,
0x701B, 0x7039, 0x7035, 0x704F, 0x705E, 0x5B80, 0x5B84, 0x5B95,
0x5B93, 0x5BA5, 0x5BB8, 0x752F, 0x9A9E, 0x6434, 0x5BE4, 0x5BEE,
0x8930, 0x5BF0, 0x8E47, 0x8B07, 0x8FB6, 0x8FD3, 0x8FD5, 0x8FE5,
0x8FEE, 0x8FE4, 0x8FE9, 0x8FE6, 0x8FF3, 0x8FE8, 0x9005, 0x9004,
0x900B, 0x9026, 0x9011, 0x900D, 0x9016, 0x9021, 0x9035, 0x9036,
0x902D, 0x902F, 0x9044, 0x9051, 0x9052, 0x9050, 0x9068, 0x9058,
0x9062, 0x905B, 0x66B9, 0x9074, 0x907D, 0x9082, 0x9088, 0x9083,
0x908B, 0x5F50, 0x5F57, 0x5F56, 0x5F58, 0x5C3B, 0x54AB, 0x5C50,
0x5C59, 0x5B71, 0x5C63, 0x5C66, 0x7FBC, 0x5F2A, 0x5F29, 0x5F2D,
0x8274, 0x5F3C, 0x9B3B, 0x5C6E, 0x5981, 0x5983, 0x598D, 0x59A9,
0x59AA, 0x59A3, 0x5997, 0x59CA, 0x59AB, 0x599E, 0x59A4, 0x59D2,
0x59B2, 0x59AF, 0x59D7, 0x59BE, 0x5A05, 0x5A06, 0x59DD, 0x5A08,
0x59E3, 0x59D8, 0x59F9, 0x5A0C, 0x5A09, 0x5A32, 0x5A34, 0x5A11,
0x5A23, 0x5A13, 0x5A40, 0x5A67, 0x5A4A, 0x5A55, 0x5A3C, 0x5A62,
0x5A75, 0x80EC, 0x5AAA, 0x5A9B, 0x5A77, 0x5A7A, 0x5ABE, 0x5AEB,
0x5AB2, 0x5AD2, 0x5AD4, 0x5AB8, 0x5AE0, 0x5AE3, 0x5AF1, 0x5AD6,
0x5AE6, 0x5AD8, 0x5ADC, 0x5B09, 0x5B17, 0x5B16, 0x5B32, 0x5B37,
0x5B40, 0x5C15, 0x5C1C, 0x5B5A, 0x5B65, 0x5B73, 0x5B51, 0x5B53,
0x5B62, 0x9A75, 0x9A77, 0x9A78, 0x9A7A, 0x9A7F, 0x9A7D, 0x9A80,
0x9A81, 0x9A85, 0x9A88, 0x9A8A, 0x9A90, 0x9A92, 0x9A93, 0x9A96,
0x9A98, 0x9A9B, 0x9A9C, 0x9A9D, 0x9A9F, 0x9AA0, 0x9AA2, 0x9AA3,
0x9AA5, 0x9AA7, 0x7E9F, 0x7EA1, 0x7EA3, 0x7EA5, 0x7EA8, 0x7EA9,
0x7EAD, 0x7EB0, 0x7EBE, 0x7EC0, 0x7EC1, 0x7EC2, 0x7EC9, 0x7ECB,
0x7ECC, 0x7ED0, 0x7ED4, 0x7ED7, 0x7EDB, 0x7EE0, 0x7EE1, 0x7EE8,
0x7EEB, 0x7EEE, 0x7EEF, 0x7EF1, 0x7EF2, 0x7F0D, 0x7EF6, 0x7EFA,
0x7EFB, 0x7EFE, 0x7F01, 0x7F02, 0x7F03, 0x7F07, 0x7F08, 0x7F0B,
0x7F0C, 0x7F0F, 0x7F11, 0x7F12, 0x7F17, 0x7F19, 0x7F1C, 0x7F1B,
0x7F1F, 0x7F21, 0x7F22, 0x7F23, 0x7F24, 0x7F25, 0x7F26, 0x7F27,
0x7F2A, 0x7F2B, 0x7F2C, 0x7F2D, 0x7F2F, 0x7F30, 0x7F31, 0x7F32,
0x7F33, 0x7F35, 0x5E7A, 0x757F, 0x5DDB, 0x753E, 0x9095, 0x738E,
0x7391, 0x73AE, 0x73A2, 0x739F, 0x73CF, 0x73C2, 0x73D1, 0x73B7,
0x73B3, 0x73C0, 0x73C9, 0x73C8, 0x73E5, 0x73D9, 0x987C, 0x740A,
0x73E9, 0x73E7, 0x73DE, 0x73BA, 0x73F2, 0x740F, 0x742A, 0x745B,
0x7426, 0x7425, 0x7428, 0x7430, 0x742E, 0x742C, 0x741B, 0x741A,
0x7441, 0x745C, 0x7457, 0x7455, 0x7459, 0x7477, 0x746D, 0x747E,
0x749C, 0x748E, 0x7480, 0x7481, 0x7487, 0x748B, 0x749E, 0x74A8,
0x74A9, 0x7490, 0x74A7, 0x74D2, 0x74BA, 0x97EA, 0x97EB, 0x97EC,
0x674C, 0x6753, 0x675E, 0x6748, 0x6769, 0x67A5, 0x6787, 0x676A,
0x6773, 0x6798, 0x67A7, 0x6775, 0x67A8, 0x679E, 0x67AD, 0x678B,
0x6777, 0x677C, 0x67F0, 0x6809, 0x67D8, 0x680A, 0x67E9, 0x67B0,
0x680C, 0x67D9, 0x67B5, 0x67DA, 0x67B3, 0x67DD, 0x6800, 0x67C3,
0x67B8, 0x67E2, 0x680E, 0x67C1, 0x67FD, 0x6832, 0x6833, 0x6860,
0x6861, 0x684E, 0x6862, 0x6844, 0x6864, 0x6883, 0x681D, 0x6855,
0x6866, 0x6841, 0x6867, 0x6840, 0x683E, 0x684A, 0x6849, 0x6829,
0x68B5, 0x688F, 0x6874, 0x6877, 0x6893, 0x686B, 0x68C2, 0x696E,
0x68FC, 0x691F, 0x6920, 0x68F9, 0x6924, 0x68F0, 0x690B, 0x6901,
0x6957, 0x68E3, 0x6910, 0x6971, 0x6939, 0x6960, 0x6942, 0x695D,
0x6984, 0x696B, 0x6980, 0x6998, 0x6978, 0x6934, 0x69CC, 0x6987,
0x6988, 0x69CE, 0x6989, 0x6966, 0x6963, 0x6979, 0x699B, 0x69A7,
0x69BB, 0x69AB, 0x69AD, 0x69D4, 0x69B1, 0x69C1, 0x69CA, 0x69DF,
0x6995, 0x69E0, 0x698D, 0x69FF, 0x6A2F, 0x69ED, 0x6A17, 0x6A18,
0x6A65, 0x69F2, 0x6A44, 0x6A3E, 0x6AA0, 0x6A50, 0x6A5B, 0x6A35,
0x6A8E, 0x6A79, 0x6A3D, 0x6A28, 0x6A58, 0x6A7C, 0x6A91, 0x6A90,
0x6AA9, 0x6A97, 0x6AAB, 0x7337, 0x7352, 0x6B81, 0x6B82, 0x6B87,
0x6B84, 0x6B92, 0x6B93, 0x6B8D, 0x6B9A, 0x6B9B, 0x6BA1, 0x6BAA,
0x8F6B, 0x8F6D, 0x8F71, 0x8F72, 0x8F73, 0x8F75, 0x8F76, 0x8F78,
0x8F77, 0x8F79, 0x8F7A, 0x8F7C, 0x8F7E, 0x8F81, 0x8F82, 0x8F84,
0x8F87, 0x8F8B, 0x8F8D, 0x8F8E, 0x8F8F, 0x8F98, 0x8F9A, 0x8ECE,
0x620B, 0x6217, 0x621B, 0x621F, 0x6222, 0x6221, 0x6225, 0x6224,
0x622C, 0x81E7, 0x74EF, 0x74F4, 0x74FF, 0x750F, 0x7511, 0x7513,
0x6534, 0x65EE, 0x65EF, 0x65F0, 0x660A, 0x6619, 0x6772, 0x6603,
0x6615, 0x6600, 0x7085, 0x66F7, 0x661D, 0x6634, 0x6631, 0x6636,
0x6635, 0x8006, 0x665F, 0x6654, 0x6641, 0x664F, 0x6656, 0x6661,
0x6657, 0x6677, 0x6684, 0x668C, 0x66A7, 0x669D, 0x66BE, 0x66DB,
0x66DC, 0x66E6, 0x66E9, 0x8D32, 0x8D33, 0x8D36, 0x8D3B, 0x8D3D,
0x8D40, 0x8D45, 0x8D46, 0x8D48, 0x8D49, 0x8D47, 0x8D4D, 0x8D55,
0x8D59, 0x89C7, 0x89CA, 0x89CB, 0x89CC, 0x89CE, 0x89CF, 0x89D0,
0x89D1, 0x726E, 0x729F, 0x725D, 0x7266, 0x726F, 0x727E, 0x727F,
0x7284, 0x728B, 0x728D, 0x728F, 0x7292, 0x6308, 0x6332, 0x63B0,
0x643F, 0x64D8, 0x8004, 0x6BEA, 0x6BF3, 0x6BFD, 0x6BF5, 0x6BF9,
0x6C05, 0x6C07, 0x6C06, 0x6C0D, 0x6C15, 0x6C18, 0x6C19, 0x6C1A,
0x6C21, 0x6C29, 0x6C24, 0x6C2A, 0x6C32, 0x6535, 0x6555, 0x656B,
0x724D, 0x7252, 0x7256, 0x7230, 0x8662, 0x5216, 0x809F, 0x809C,
0x8093, 0x80BC, 0x670A, 0x80BD, 0x80B1, 0x80AB, 0x80AD, 0x80B4,
0x80B7, 0x80E7, 0x80E8, 0x80E9, 0x80EA, 0x80DB, 0x80C2, 0x80C4,
0x80D9, 0x80CD, 0x80D7, 0x6710, 0x80DD, 0x80EB, 0x80F1, 0x80F4,
0x80ED, 0x810D, 0x810E, 0x80F2, 0x80FC, 0x6715, 0x8112, 0x8C5A,
0x8136, 0x811E, 0x812C, 0x8118, 0x8132, 0x8148, 0x814C, 0x8153,
0x8174, 0x8159, 0x815A, 0x8171, 0x8160, 0x8169, 0x817C, 0x817D,
0x816D, 0x8167, 0x584D, 0x5AB5, 0x8188, 0x8182, 0x8191, 0x6ED5,
0x81A3, 0x81AA, 0x81CC, 0x6726, 0x81CA, 0x81BB, 0x81C1, 0x81A6,
0x6B24, 0x6B37, 0x6B39, 0x6B43, 0x6B46, 0x6B59, 0x98D1, 0x98D2,
0x98D3, 0x98D5, 0x98D9, 0x98DA, 0x6BB3, 0x5F40, 0x6BC2, 0x89F3,
0x6590, 0x9F51, 0x6593, 0x65BC, 0x65C6, 0x65C4, 0x65C3, 0x65CC,
0x65CE, 0x65D2, 0x65D6, 0x7080, 0x709C, 0x7096, 0x709D, 0x70BB,
0x70C0, 0x70B7, 0x70AB, 0x70B1, 0x70E8, 0x70CA, 0x7110, 0x7113,
0x7116, 0x712F, 0x7131, 0x7173, 0x715C, 0x7168, 0x7145, 0x7172,
0x714A, 0x7178, 0x717A, 0x7198, 0x71B3, 0x71B5, 0x71A8, 0x71A0,
0x71E0, 0x71D4, 0x71E7, 0x71F9, 0x721D, 0x7228, 0x706C, 0x7118,
0x7166, 0x71B9, 0x623E, 0x623D, 0x6243, 0x6248, 0x6249, 0x793B,
0x7940, 0x7946, 0x7949, 0x795B, 0x795C, 0x7953, 0x795A, 0x7962,
0x7957, 0x7960, 0x796F, 0x7967, 0x797A, 0x7985, 0x798A, 0x799A,
0x79A7, 0x79B3, 0x5FD1, 0x5FD0, 0x603C, 0x605D, 0x605A, 0x6067,
0x6041, 0x6059, 0x6063, 0x60AB, 0x6106, 0x610D, 0x615D, 0x61A9,
0x619D, 0x61CB, 0x61D1, 0x6206, 0x8080, 0x807F, 0x6C93, 0x6CF6,
0x6DFC, 0x77F6, 0x77F8, 0x7800, 0x7809, 0x7817, 0x7818, 0x7811,
0x65AB, 0x782D, 0x781C, 0x781D, 0x7839, 0x783A, 0x783B, 0x781F,
0x783C, 0x7825, 0x782C, 0x7823, 0x7829, 0x784E, 0x786D, 0x7856,
0x7857, 0x7826, 0x7850, 0x7847, 0x784C, 0x786A, 0x789B, 0x7893,
0x789A, 0x7887, 0x789C, 0x78A1, 0x78A3, 0x78B2, 0x78B9, 0x78A5,
0x78D4, 0x78D9, 0x78C9, 0x78EC, 0x78F2, 0x7905, 0x78F4, 0x7913,
0x7924, 0x791E, 0x7934, 0x9F9B, 0x9EF9, 0x9EFB, 0x9EFC, 0x76F1,
0x7704, 0x770D, 0x76F9, 0x7707, 0x7708, 0x771A, 0x7722, 0x7719,
0x772D, 0x7726, 0x7735, 0x7738, 0x7750, 0x7751, 0x7747, 0x7743,
0x775A, 0x7768, 0x7762, 0x7765, 0x777F, 0x778D, 0x777D, 0x7780,
0x778C, 0x7791, 0x779F, 0x77A0, 0x77B0, 0x77B5, 0x77BD, 0x753A,
0x7540, 0x754E, 0x754B, 0x7548, 0x755B, 0x7572, 0x7579, 0x7583,
0x7F58, 0x7F61, 0x7F5F, 0x8A48, 0x7F68, 0x7F74, 0x7F71, 0x7F79,
0x7F81, 0x7F7E, 0x76CD, 0x76E5, 0x8832, 0x9485, 0x9486, 0x9487,
0x948B, 0x948A, 0x948C, 0x948D, 0x948F, 0x9490, 0x9494, 0x9497,
0x9495, 0x949A, 0x949B, 0x949C, 0x94A3, 0x94A4, 0x94AB, 0x94AA,
0x94AD, 0x94AC, 0x94AF, 0x94B0, 0x94B2, 0x94B4, 0x94B6, 0x94B7,
0x94B8, 0x94B9, 0x94BA, 0x94BC, 0x94BD, 0x94BF, 0x94C4, 0x94C8,
0x94C9, 0x94CA, 0x94CB, 0x94CC, 0x94CD, 0x94CE, 0x94D0, 0x94D1,
0x94D2, 0x94D5, 0x94D6, 0x94D7, 0x94D9, 0x94D8, 0x94DB, 0x94DE,
0x94DF, 0x94E0, 0x94E2, 0x94E4, 0x94E5, 0x94E7, 0x94E8, 0x94EA,
0x94E9, 0x94EB, 0x94EE, 0x94EF, 0x94F3, 0x94F4, 0x94F5, 0x94F7,
0x94F9, 0x94FC, 0x94FD, 0x94FF, 0x9503, 0x9502, 0x9506, 0x9507,
0x9509, 0x950A, 0x950D, 0x950E, 0x950F, 0x9512, 0x9513, 0x9514,
0x9515, 0x9516, 0x9518, 0x951B, 0x951D, 0x951E, 0x951F, 0x9522,
0x952A, 0x952B, 0x9529, 0x952C, 0x9531, 0x9532, 0x9534, 0x9536,
0x9537, 0x9538, 0x953C, 0x953E, 0x953F, 0x9542, 0x9535, 0x9544,
0x9545, 0x9546, 0x9549, 0x954C, 0x954E, 0x954F, 0x9552, 0x9553,
0x9554, 0x9556, 0x9557, 0x9558, 0x9559, 0x955B, 0x955E, 0x955F,
0x955D, 0x9561, 0x9562, 0x9564, 0x9565, 0x9566, 0x9567, 0x9568,
0x9569, 0x956A, 0x956B, 0x956C, 0x956F, 0x9571, 0x9572, 0x9573,
0x953A, 0x77E7, 0x77EC, 0x96C9, 0x79D5, 0x79ED, 0x79E3, 0x79EB,
0x7A06, 0x5D47, 0x7A03, 0x7A02, 0x7A1E, 0x7A14, 0x7A39, 0x7A37,
0x7A51, 0x9ECF, 0x99A5, 0x7A70, 0x7688, 0x768E, 0x7693, 0x7699,
0x76A4, 0x74DE, 0x74E0, 0x752C, 0x9E20, 0x9E22, 0x9E28, 0x9E29,
0x9E2A, 0x9E2B, 0x9E2C, 0x9E32, 0x9E31, 0x9E36, 0x9E38, 0x9E37,
0x9E39, 0x9E3A, 0x9E3E, 0x9E41, 0x9E42, 0x9E44, 0x9E46, 0x9E47,
0x9E48, 0x9E49, 0x9E4B, 0x9E4C, 0x9E4E, 0x9E51, 0x9E55, 0x9E57,
0x9E5A, 0x9E5B, 0x9E5C, 0x9E5E, 0x9E63, 0x9E66, 0x9E67, 0x9E68,
0x9E69, 0x9E6A, 0x9E6B, 0x9E6C, 0x9E71, 0x9E6D, 0x9E73, 0x7592,
0x7594, 0x7596, 0x75A0, 0x759D, 0x75AC, 0x75A3, 0x75B3, 0x75B4,
0x75B8, 0x75C4, 0x75B1, 0x75B0, 0x75C3, 0x75C2, 0x75D6, 0x75CD,
0x75E3, 0x75E8, 0x75E6, 0x75E4, 0x75EB, 0x75E7, 0x7603, 0x75F1,
0x75FC, 0x75FF, 0x7610, 0x7600, 0x7605, 0x760C, 0x7617, 0x760A,
0x7625, 0x7618, 0x7615, 0x7619, 0x761B, 0x763C, 0x7622, 0x7620,
0x7640, 0x762D, 0x7630, 0x763F, 0x7635, 0x7643, 0x763E, 0x7633,
0x764D, 0x765E, 0x7654, 0x765C, 0x7656, 0x766B, 0x766F, 0x7FCA,
0x7AE6, 0x7A78, 0x7A79, 0x7A80, 0x7A86, 0x7A88, 0x7A95, 0x7AA6,
0x7AA0, 0x7AAC, 0x7AA8, 0x7AAD, 0x7AB3, 0x8864, 0x8869, 0x8872,
0x887D, 0x887F, 0x8882, 0x88A2, 0x88C6, 0x88B7, 0x88BC, 0x88C9,
0x88E2, 0x88CE, 0x88E3, 0x88E5, 0x88F1, 0x891A, 0x88FC, 0x88E8,
0x88FE, 0x88F0, 0x8921, 0x8919, 0x8913, 0x891B, 0x890A, 0x8934,
0x892B, 0x8936, 0x8941, 0x8966, 0x897B, 0x758B, 0x80E5, 0x76B2,
0x76B4, 0x77DC, 0x8012, 0x8014, 0x8016, 0x801C, 0x8020, 0x8022,
0x8025, 0x8026, 0x8027, 0x8029, 0x8028, 0x8031, 0x800B, 0x8035,
0x8043, 0x8046, 0x804D, 0x8052, 0x8069, 0x8071, 0x8983, 0x9878,
0x9880, 0x9883, 0x9889, 0x988C, 0x988D, 0x988F, 0x9894, 0x989A,
0x989B, 0x989E, 0x989F, 0x98A1, 0x98A2, 0x98A5, 0x98A6, 0x864D,
0x8654, 0x866C, 0x866E, 0x867F, 0x867A, 0x867C, 0x867B, 0x86A8,
0x868D, 0x868B, 0x86AC, 0x869D, 0x86A7, 0x86A3, 0x86AA, 0x8693,
0x86A9, 0x86B6, 0x86C4, 0x86B5, 0x86CE, 0x86B0, 0x86BA, 0x86B1,
0x86AF, 0x86C9, 0x86CF, 0x86B4, 0x86E9, 0x86F1, 0x86F2, 0x86ED,
0x86F3, 0x86D0, 0x8713, 0x86DE, 0x86F4, 0x86DF, 0x86D8, 0x86D1,
0x8703, 0x8707, 0x86F8, 0x8708, 0x870A, 0x870D, 0x8709, 0x8723,
0x873B, 0x871E, 0x8725, 0x872E, 0x871A, 0x873E, 0x8748, 0x8734,
0x8731, 0x8729, 0x8737, 0x873F, 0x8782, 0x8722, 0x877D, 0x877E,
0x877B, 0x8760, 0x8770, 0x874C, 0x876E, 0x878B, 0x8753, 0x8763,
0x877C, 0x8764, 0x8759, 0x8765, 0x8793, 0x87AF, 0x87A8, 0x87D2,
0x87C6, 0x8788, 0x8785, 0x87AD, 0x8797, 0x8783, 0x87AB, 0x87E5,
0x87AC, 0x87B5, 0x87B3, 0x87CB, 0x87D3, 0x87BD, 0x87D1, 0x87C0,
0x87CA, 0x87DB, 0x87EA, 0x87E0, 0x87EE, 0x8816, 0x8813, 0x87FE,
0x880A, 0x881B, 0x8821, 0x8839, 0x883C, 0x7F36, 0x7F42, 0x7F44,
0x7F45, 0x8210, 0x7AFA, 0x7AFD, 0x7B08, 0x7B03, 0x7B04, 0x7B15,
0x7B0A, 0x7B2B, 0x7B0F, 0x7B47, 0x7B38, 0x7B2A, 0x7B19, 0x7B2E,
0x7B31, 0x7B20, 0x7B25, 0x7B24, 0x7B33, 0x7B3E, 0x7B1E, 0x7B58,
0x7B5A, 0x7B45, 0x7B75, 0x7B4C, 0x7B5D, 0x7B60, 0x7B6E, 0x7B7B,
0x7B62, 0x7B72, 0x7B71, 0x7B90, 0x7BA6, 0x7BA7, 0x7BB8, 0x7BAC,
0x7B9D, 0x7BA8, 0x7B85, 0x7BAA, 0x7B9C, 0x7BA2, 0x7BAB, 0x7BB4,
0x7BD1, 0x7BC1, 0x7BCC, 0x7BDD, 0x7BDA, 0x7BE5, 0x7BE6, 0x7BEA,
0x7C0C, 0x7BFE, 0x7BFC, 0x7C0F, 0x7C16, 0x7C0B, 0x7C1F, 0x7C2A,
0x7C26, 0x7C38, 0x7C41, 0x7C40, 0x81FE, 0x8201, 0x8202, 0x8204,
0x81EC, 0x8844, 0x8221, 0x8222, 0x8223, 0x822D, 0x822F, 0x8228,
0x822B, 0x8238, 0x823B, 0x8233, 0x8234, 0x823E, 0x8244, 0x8249,
0x824B, 0x824F, 0x825A, 0x825F, 0x8268, 0x887E, 0x8885, 0x8888,
0x88D8, 0x88DF, 0x895E, 0x7F9D, 0x7F9F, 0x7FA7, 0x7FAF, 0x7FB0,
0x7FB2, 0x7C7C, 0x6549, 0x7C91, 0x7C9D, 0x7C9C, 0x7C9E, 0x7CA2,
0x7CB2, 0x7CBC, 0x7CBD, 0x7CC1, 0x7CC7, 0x7CCC, 0x7CCD, 0x7CC8,
0x7CC5, 0x7CD7, 0x7CE8, 0x826E, 0x66A8, 0x7FBF, 0x7FCE, 0x7FD5,
0x7FE5, 0x7FE1, 0x7FE6, 0x7FE9, 0x7FEE, 0x7FF3, 0x7CF8, 0x7D77,
0x7DA6, 0x7DAE, 0x7E47, 0x7E9B, 0x9EB8, 0x9EB4, 0x8D73, 0x8D84,
0x8D94, 0x8D91, 0x8DB1, 0x8D67, 0x8D6D, 0x8C47, 0x8C49, 0x914A,
0x9150, 0x914E, 0x914F, 0x9164, 0x9162, 0x9161, 0x9170, 0x9169,
0x916F, 0x917D, 0x917E, 0x9172, 0x9174, 0x9179, 0x918C, 0x9185,
0x9190, 0x918D, 0x9191, 0x91A2, 0x91A3, 0x91AA, 0x91AD, 0x91AE,
0x91AF, 0x91B5, 0x91B4, 0x91BA, 0x8C55, 0x9E7E, 0x8DB8, 0x8DEB,
0x8E05, 0x8E59, 0x8E69, 0x8DB5, 0x8DBF, 0x8DBC, 0x8DBA, 0x8DC4,
0x8DD6, 0x8DD7, 0x8DDA, 0x8DDE, 0x8DCE, 0x8DCF, 0x8DDB, 0x8DC6,
0x8DEC, 0x8DF7, 0x8DF8, 0x8DE3, 0x8DF9, 0x8DFB, 0x8DE4, 0x8E09,
0x8DFD, 0x8E14, 0x8E1D, 0x8E1F, 0x8E2C, 0x8E2E, 0x8E23, 0x8E2F,
0x8E3A, 0x8E40, 0x8E39, 0x8E35, 0x8E3D, 0x8E31, 0x8E49, 0x8E41,
0x8E42, 0x8E51, 0x8E52, 0x8E4A, 0x8E70, 0x8E76, 0x8E7C, 0x8E6F,
0x8E74, 0x8E85, 0x8E8F, 0x8E94, 0x8E90, 0x8E9C, 0x8E9E, 0x8C78,
0x8C82, 0x8C8A, 0x8C85, 0x8C98, 0x8C94, 0x659B, 0x89D6, 0x89DE,
0x89DA, 0x89DC, 0x89E5, 0x89EB, 0x89EF, 0x8A3E, 0x8B26, 0x9753,
0x96E9, 0x96F3, 0x96EF, 0x9706, 0x9701, 0x9708, 0x970F, 0x970E,
0x972A, 0x972D, 0x9730, 0x973E, 0x9F80, 0x9F83, 0x9F85, 0x9F86,
0x9F87, 0x9F88, 0x9F89, 0x9F8A, 0x9F8C, 0x9EFE, 0x9F0B, 0x9F0D,
0x96B9, 0x96BC, 0x96BD, 0x96CE, 0x96D2, 0x77BF, 0x96E0, 0x928E,
0x92AE, 0x92C8, 0x933E, 0x936A, 0x93CA, 0x938F, 0x943E, 0x946B,
0x9C7F, 0x9C82, 0x9C85, 0x9C86, 0x9C87, 0x9C88, 0x7A23, 0x9C8B,
0x9C8E, 0x9C90, 0x9C91, 0x9C92, 0x9C94, 0x9C95, 0x9C9A, 0x9C9B,
0x9C9E, 0x9C9F, 0x9CA0, 0x9CA1, 0x9CA2, 0x9CA3, 0x9CA5, 0x9CA6,
0x9CA7, 0x9CA8, 0x9CA9, 0x9CAB, 0x9CAD, 0x9CAE, 0x9CB0, 0x9CB1,
0x9CB2, 0x9CB3, 0x9CB4, 0x9CB5, 0x9CB6, 0x9CB7, 0x9CBA, 0x9CBB,
0x9CBC, 0x9CBD, 0x9CC4, 0x9CC5, 0x9CC6, 0x9CC7, 0x9CCA, 0x9CCB,
0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x9CD4, 0x9CD5,
0x9CD7, 0x9CD8, 0x9CD9, 0x9CDC, 0x9CDD, 0x9CDF, 0x9CE2, 0x977C,
0x9785, 0x9791, 0x9792, 0x9794, 0x97AF, 0x97AB, 0x97A3, 0x97B2,
0x97B4, 0x9AB1, 0x9AB0, 0x9AB7, 0x9E58, 0x9AB6, 0x9ABA, 0x9ABC,
0x9AC1, 0x9AC0, 0x9AC5, 0x9AC2, 0x9ACB, 0x9ACC, 0x9AD1, 0x9B45,
0x9B43, 0x9B47, 0x9B49, 0x9B48, 0x9B4D, 0x9B51, 0x98E8, 0x990D,
0x992E, 0x9955, 0x9954, 0x9ADF, 0x9AE1, 0x9AE6, 0x9AEF, 0x9AEB,
0x9AFB, 0x9AED, 0x9AF9, 0x9B08, 0x9B0F, 0x9B13, 0x9B1F, 0x9B23,
0x9EBD, 0x9EBE, 0x7E3B, 0x9E82, 0x9E87, 0x9E88, 0x9E8B, 0x9E92,
0x93D6, 0x9E9D, 0x9E9F, 0x9EDB, 0x9EDC, 0x9EDD, 0x9EE0, 0x9EDF,
0x9EE2, 0x9EE9, 0x9EE7, 0x9EE5, 0x9EEA, 0x9EEF, 0x9F22, 0x9F2C,
0x9F2F, 0x9F39, 0x9F37, 0x9F3D, 0x9F3E, 0x9F44,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_GB2312_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_gb2312.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 119,712
|
```objective-c
/* zueci_common.h - shared defines */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_COMMON_H
#define ZUECI_COMMON_H
#define ZUECI_ASIZE(x) ((int) (sizeof(x) / sizeof((x)[0])))
#define ZUECI_MIN(x, y) (x < y ? x : y)
#if (defined(__GNUC__) || defined(__clang__)) && !defined(ZUECI_TEST) && !defined(__MINGW32__)
# define ZUECI_INTERN __attribute__ ((visibility ("hidden")))
#elif defined(ZUECI_TEST)
/* The test suite references ZUECI_INTERN functions, so they need to be exported */
# define ZUECI_INTERN ZUECI_EXTERN
#else
# define ZUECI_INTERN
#endif
typedef unsigned short zueci_u16; /* `unsigned short` guaranteed to be at least 16 bits */
#ifndef ZUECI_U32_TYPE /* On the off chance it needs to be `unsigned long` */
typedef unsigned int zueci_u32;
#endif
typedef char zueci_static_assert_u32_at_least_32bits[sizeof(zueci_u32) < 4 ? -1 : 1];
/* vim: set ts=4 sw=4 et : */
#endif /* ZUECI_COMMON_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_common.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 292
|
```c
/* zueci.c - UTF-8 to/from Extended Channel Interpretations */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "zueci.h"
#include "zueci_common.h"
#include "zueci_sb.h"
#include "zueci_big5.h"
#include "zueci_gb18030.h"
#include "zueci_gb2312.h"
#include "zueci_gbk.h"
#include "zueci_ksx1001.h"
#include "zueci_sjis.h"
/* Whether codepoint `u` valid Unicode */
#define ZUECI_IS_VALID_UNICODE(u) ((u) < 0xD800 || ((u) >= 0xE000 && (u) <= 0x10FFFF))
/* Put 4 bytes into `zueci_u32` */
#define ZUECI_4BYTES_U32(c1, c2, c3, c4) \
(((zueci_u32) (c1) << 24) | ((zueci_u32) (c2) << 16) | ((zueci_u32) (c3) << 8) | (c4))
/* Utility funcs */
/* Whether `eci` valid character set ECI */
static int zueci_is_valid_eci(const int eci) {
return (eci <= 35 && eci >= 0 && eci != 14 && eci != 19) || eci == 170 || eci == 899;
}
/* State machine to decode UTF-8 to Unicode codepoints (state 0 means done, state 12 means error) */
static unsigned int zueci_decode_utf8(unsigned int *p_state, zueci_u32 *p_u, const unsigned char byte) {
/*
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.
See path_to_url for details.
*/
static const unsigned char utf8d[] = {
/* The first part of the table maps bytes to character classes that
* reduce the size of the transition table and create bitmasks. */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
/* The second part is a transition table that maps a combination
* of a state of the automaton and a character class to a state. */
0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
12,36,12,12,12,12,12,12,12,12,12,12,
};
const zueci_u32 type = utf8d[byte];
*p_u = *p_state ? (byte & 0x3fu) | (*p_u << 6) : (0xff >> type) & byte;
*p_state = utf8d[256 + *p_state + type];
return *p_state;
}
#ifdef ZUECI_TEST /* Wrapper to make available for use by tests */
ZUECI_INTERN unsigned int zueci_decode_utf8_test(unsigned int *p_state, zueci_u32 *p_u, const unsigned char byte) {
return zueci_decode_utf8(p_state, p_u, byte);
}
#endif
/* Whether string valid UTF-8 */
static int zueci_is_valid_utf8(const unsigned char src[], const int len) {
unsigned int state = 0;
const unsigned char *s = src;
const unsigned char *const se = src + len;
zueci_u32 u;
while (s < se) {
if (zueci_decode_utf8(&state, &u, *s++) == 12) {
return 0;
}
}
return state == 0;
}
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Convert Unicode codepoint `u` to UTF-8 `dest`, returning UTF-8 length */
static int zueci_encode_utf8(const zueci_u32 u, unsigned char *dest) {
if (u < 0x80) {
dest[0] = (unsigned char) u;
return 1;
}
if (u < 0x800) {
dest[0] = (unsigned char) (0xC0 | (u >> 6));
dest[1] = (unsigned char) (0x80 | (u & 0x3F));
return 2;
}
if (u < 0x10000) {
dest[0] = (unsigned char) (0xE0 | (u >> 12));
dest[1] = (unsigned char) (0x80 | ((u >> 6) & 0x3F));
dest[2] = (unsigned char) (0x80 | (u & 0x3F));
return 3;
}
dest[0] = (unsigned char) (0xF0 | (u >> 18));
dest[1] = (unsigned char) (0x80 | ((u >> 12) & 0x3F));
dest[2] = (unsigned char) (0x80 | ((u >> 6) & 0x3F));
dest[3] = (unsigned char) (0x80 | (u & 0x3F));
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Returns the number of times a character occurs in a string */
static int zueci_chr_cnt(const unsigned char src[], const int len, const unsigned char c) {
int count = 0;
const unsigned char *const se = src + len;
const unsigned char *s = src;
while (s < se) {
if (*s++ == c) {
count++;
}
}
return count;
}
/* Returns the number of chars in a string less than or equal to a character */
static int zueci_chr_lte_cnt(const unsigned char src[], const int len, const unsigned char c) {
int count = 0;
const unsigned char *const se = src + len;
const unsigned char *s = src;
while (s < se) {
if (*s++ <= c) {
count++;
}
}
return count;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Helper to return source increment on using replacement character */
static int zueci_replacement_incr(const int eci, const unsigned char *src, const zueci_u32 len) {
assert(len);
assert(eci != 26 && eci != 899); /* Dealt with as special cases */
if (len == 1) { /* Last char */
return 1;
}
if (eci <= 18 || (eci >= 21 && eci <= 24) || eci == 27 || eci == 170) { /* Single-byte */
return 1;
}
if (eci == 25 || eci == 33) { /* UTF-16BE/LE */
return 2;
}
if (eci == 34 || eci == 35) { /* UTF-32BE/LE */
return ZUECI_MIN(len, 4);
}
if (eci == 32) { /* GB 18030 */
/* If have 4 bytes and match start range of 4-byter [81..E3][30..39] */
if (len >= 4 && src[1] <= 0x39 && src[1] >= 0x30 && src[0] >= 0x81 && src[0] <= 0xE3) {
/* Treat as 4-byter (without checking further) */
return 4;
}
/* Else treat as 2-byter */
}
return 2;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
/* Single-byte & UTF-16/32 stuff */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECIs 0 and 2 (bottom half ASCII, top half IBM CP 437) */
static int zueci_u_cp437(const zueci_u32 u, unsigned char *dest) {
int s, e;
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
s = 0;
e = ZUECI_ASIZE(zueci_cp437_u_u) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_cp437_u_u[m] < u) {
s = m + 1;
} else if (zueci_cp437_u_u[m] > u) {
e = m - 1;
} else {
*dest = zueci_cp437_u_sb[m];
return 1;
}
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECIs 0 and 2 ASCII/CP 437 to Unicode */
static int zueci_cp437_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
const unsigned char c = *src;
(void)len; (void)flags;
if (c < 0x80) {
*p_u = c;
return 1;
}
*p_u = zueci_cp437_u_u[(int) zueci_cp437_sb_u[c - 0x80]]; /* No undefined */
return 1;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Base ISO/IEC 8859 routine to convert Unicode codepoint `u` */
static int zueci_u_iso8859(const zueci_u32 u, const zueci_u16 *tab_s, const zueci_u16 *tab_u_u,
const unsigned char *tab_u_sb, int e, unsigned char *dest) {
int s;
if (u < 0xA0) {
if (u >= 0x80) { /* U+0080-9F fail */
return 0;
}
*dest = (unsigned char) u;
return 1;
}
if (u <= 0xFF) {
const zueci_u32 u2 = u - 0xA0;
if (tab_s[u2 >> 4] & ((zueci_u16) 1 << (u2 & 0xF))) {
*dest = (unsigned char) u; /* Straight-thru */
return 1;
}
}
s = 0;
while (s <= e) {
const int m = (s + e) >> 1;
if (tab_u_u[m] < u) {
s = m + 1;
} else if (tab_u_u[m] > u) {
e = m - 1;
} else {
*dest = tab_u_sb[m];
return 1;
}
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Base ISO/IEC 8859 routine to convert single-byte `c` */
static int zueci_iso8859_u(const unsigned char c, const unsigned int flags, const zueci_u16 *tab_s,
const zueci_u16 *tab_u_u, const char *tab_sb_u, const int c2_max, zueci_u32 *p_u) {
unsigned char c2;
int idx;
if (c < 0xA0) {
if (c >= 0x80 && !(flags & ZUECI_FLAG_SB_STRAIGHT_THRU)) { /* U+0080-9F fail unless straight-thru */
return 0;
}
*p_u = c;
return 1;
}
c2 = c - 0xA0;
if (tab_s[c2 >> 4] & ((zueci_u16) 1 << (c2 & 0xF))) {
*p_u = c; /* Straight-thru */
return 1;
}
if (c2 < c2_max && (idx = (int) tab_sb_u[c2]) != -1) {
*p_u = tab_u_u[idx];
return 1;
}
if (flags & ZUECI_FLAG_SB_STRAIGHT_THRU) {
*p_u = c;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Base Windows-125x routine to convert Unicode codepoint `u` */
static int zueci_u_cp125x(const zueci_u32 u, const zueci_u16 *tab_s, const zueci_u16 *tab_u_u,
const unsigned char *tab_u_sb, int e, unsigned char *dest) {
int s;
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
if (u <= 0xFF && u >= 0xA0) {
const zueci_u32 u2 = u - 0xA0;
if (tab_s[u2 >> 4] & ((zueci_u16) 1 << (u2 & 0xF))) {
*dest = (unsigned char) u; /* Straight-thru */
return 1;
}
}
s = 0;
while (s <= e) {
const int m = (s + e) >> 1;
if (tab_u_u[m] < u) {
s = m + 1;
} else if (tab_u_u[m] > u) {
e = m - 1;
} else {
*dest = tab_u_sb[m];
return 1;
}
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Base Windows-125x routine to convert single-byte `c` */
static int zueci_cp125x_u(const unsigned char c, const unsigned int flags, const zueci_u16 *tab_s,
const zueci_u16 *tab_u_u, const char *tab_sb_u, const int c_max, zueci_u32 *p_u) {
int idx;
if (c < 0x80) {
*p_u = c;
return 1;
}
if (c >= 0xA0) {
const unsigned char c2 = c - 0xA0;
if (tab_s[c2 >> 4] & ((zueci_u16) 1 << (c2 & 0xF))) {
*p_u = c; /* Straight-thru */
return 1;
}
}
if (c < c_max && (idx = (int) tab_sb_u[c - 0x80]) != -1) {
*p_u = tab_u_u[idx];
return 1;
}
if (flags & ZUECI_FLAG_SB_STRAIGHT_THRU) {
*p_u = c;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 27 ASCII (ISO/IEC 646:1991 IRV (US)) */
static int zueci_u_ascii(const zueci_u32 u, unsigned char *dest) {
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 27 ASCII to Unicode */
static int zueci_ascii_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
(void)len;
if (*src < 0x80 || (flags & ZUECI_FLAG_SB_STRAIGHT_THRU)) {
*p_u = *src;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 170 ISO/IEC 646:1991 Invariant, ASCII subset that excludes 12 chars that historically had
national variants, namely "#$@[\]^`{|}~" */
static int zueci_u_ascii_inv(const zueci_u32 u, unsigned char *dest) {
if (u == 0x7F || (u <= 'z' && u != '#' && u != '$' && u != '@' && (u <= 'Z' || u == '_' || u >= 'a'))) {
*dest = (unsigned char) u;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 170 ISO/IEC 646:1991 Invariant to Unicode */
static int zueci_ascii_inv_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
const unsigned char c = *src;
(void)len;
if ((flags & ZUECI_FLAG_SB_STRAIGHT_THRU) || c == 0x7F || (c <= 'z' && c != '#' && c != '$' && c != '@'
&& (c <= 'Z' || c == '_' || c >= 'a'))) {
*p_u = c;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 25 UTF-16 Big Endian (ISO/IEC 10646) - assumes valid Unicode */
static int zueci_u_utf16be(const zueci_u32 u, unsigned char *dest) {
zueci_u32 u2, v;
if (u < 0x10000) {
dest[0] = (unsigned char) (u >> 8);
dest[1] = (unsigned char) u;
return 2;
}
u2 = u - 0x10000;
v = u2 >> 10;
dest[0] = (unsigned char) (0xD8 + (v >> 8));
dest[1] = (unsigned char) v;
v = u2 & 0x3FF;
dest[2] = (unsigned char) (0xDC + (v >> 8));
dest[3] = (unsigned char) v;
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 25 UTF-16 Big Endian to Unicode */
static int zueci_utf16be_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
zueci_u16 u1, u2;
(void)flags;
if (len < 2) {
return 0;
}
u1 = ((zueci_u16) src[0] << 8) | src[1];
if (u1 < 0xD800 || u1 > 0xDFFF) {
*p_u = u1;
return 2;
}
if (u1 >= 0xDC00 || len < 4) {
return 0;
}
u2 = ((zueci_u16) src[2] << 8) | src[3];
if (u2 < 0xDC00 || u2 > 0xDFFF) {
return 0;
}
*p_u = 0x10000 + (((zueci_u32) (u1 - 0xD800) << 10) | (u2 - 0xDC00));
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 33 UTF-16 Little Endian (ISO/IEC 10646) - assumes valid Unicode */
static int zueci_u_utf16le(const zueci_u32 u, unsigned char *dest) {
zueci_u32 u2, v;
if (u < 0x10000) {
dest[0] = (unsigned char) u;
dest[1] = (unsigned char) (u >> 8);
return 2;
}
u2 = u - 0x10000;
v = u2 >> 10;
dest[0] = (unsigned char) v;
dest[1] = (unsigned char) (0xD8 + (v >> 8));
v = u2 & 0x3FF;
dest[2] = (unsigned char) v;
dest[3] = (unsigned char) (0xDC + (v >> 8));
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 33 UTF-16 Little Endian to Unicode */
static int zueci_utf16le_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
zueci_u16 u1, u2;
(void)flags;
if (len < 2) {
return 0;
}
u1 = ((zueci_u16) src[1] << 8) | src[0];
if (u1 < 0xD800 || u1 > 0xDFFF) {
*p_u = u1;
return 2;
}
if (u1 >= 0xDC00 || len < 4) {
return 0;
}
u2 = ((zueci_u16) src[3] << 8) | src[2];
if (u2 < 0xDC00 || u2 > 0xDFFF) {
return 0;
}
*p_u = 0x10000 + (((zueci_u32) (u1 - 0xD800) << 10) | (u2 - 0xDC00));
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 34 UTF-32 Big Endian (ISO/IEC 10646) - assumes valid Unicode */
static int zueci_u_utf32be(const zueci_u32 u, unsigned char *dest) {
dest[0] = 0;
dest[1] = (unsigned char) (u >> 16);
dest[2] = (unsigned char) (u >> 8);
dest[3] = (unsigned char) u;
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 34 UTF-32 Big Endian to Unicode */
static int zueci_utf32be_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
zueci_u32 u;
(void)flags;
if (len < 4) {
return 0;
}
u = ZUECI_4BYTES_U32(src[0], src[1], src[2], src[3]);
if (!ZUECI_IS_VALID_UNICODE(u)) {
return 0;
}
*p_u = u;
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 35 UTF-32 Little Endian (ISO/IEC 10646) - assumes valid Unicode */
static int zueci_u_utf32le(const zueci_u32 u, unsigned char *dest) {
dest[0] = (unsigned char) u;
dest[1] = (unsigned char) (u >> 8);
dest[2] = (unsigned char) (u >> 16);
dest[3] = 0;
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 35 UTF-32 Little Endian to Unicode */
static int zueci_utf32le_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
zueci_u32 u;
(void)flags;
if (len < 4) {
return 0;
}
u = ZUECI_4BYTES_U32(src[3], src[2], src[1], src[0]);
if (!ZUECI_IS_VALID_UNICODE(u)) {
return 0;
}
*p_u = u;
return 4;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 899 Binary */
static int zueci_u_binary(const zueci_u32 u, unsigned char *dest) {
if (u <= 0xFF) {
*dest = (unsigned char) u;
return 1;
}
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
/* Multibyte stuff */
/* Acknowledgements to Bruno Haible <bruno@clisp.org> for a no. of techniques used here */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Helper to lookup Unicode codepoint `u` in the URO (Unified Repertoire and Ordering) block (U+4E00-9FFF) */
static int zueci_u_lookup_uro(const zueci_u32 u, const zueci_u16 *tab_u_u, const zueci_u16 *tab_mb_ind,
const zueci_u16 *tab_u_mb, unsigned char *dest) {
zueci_u32 u2 = (u - 0x4E00) >> 4; /* Blocks of 16 */
zueci_u32 v = (zueci_u32) 1 << (u & 0xF);
zueci_u16 mb;
if ((tab_u_u[u2] & v) == 0) {
return 0;
}
v = tab_u_u[u2] & (v - 1); /* Mask to bits prior to this one */
/* Count bits set (path_to_url~seander/bithacks.html#CountBitsSetParallel) */
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
v = (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
mb = tab_u_mb[tab_mb_ind[u2] + v];
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
/* Unicode to ECI 20 Shift JIS */
static int zueci_u_sjis(const zueci_u32 u, unsigned char *dest) {
if (u < 0x80 && u != 0x5C && u != 0x7E) { /* Backslash & tilde re-mapped according to JIS X 0201 Roman */
dest[0] = (unsigned char) u;
return 1;
}
/* Special case URO block sequential mappings (considerably lessens size of `zueci_sjis_u_u[]` array) */
if (u >= 0x4E00 && u < 0xE000) { /* 0xE000 next used value >= 0x4E00 */
if (u > 0x9FA0) {
return 0;
}
return zueci_u_lookup_uro(u, zueci_sjis_uro_u, zueci_sjis_uro_mb_ind, zueci_sjis_u_mb, dest);
}
/* PUA to user-defined (Table 4-86, Lunde, 2nd ed.) */
if (u >= 0xE000 && u <= 0xE757) {
const zueci_u32 u2 = u - 0xE000;
const unsigned char dv = (unsigned char) (u2 / (0xFC - 0x40));
const unsigned char md = (unsigned char) (u2 - dv * (0xFC - 0x40));
dest[0] = dv + 0xF0;
dest[1] = md + 0x40 + (md >= 0x3F);
return 2;
}
if (u >= zueci_sjis_u_u[0] && u <= zueci_sjis_u_u[ZUECI_ASIZE(zueci_sjis_u_u) - 1]) {
int s = 0;
int e = ZUECI_ASIZE(zueci_sjis_u_u) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_sjis_u_u[m] < u) {
s = m + 1;
} else if (zueci_sjis_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_sjis_u_mb[u >= 0x4E00 ? m + 6356 : m]; /* Adjust for URO block */
if (mb > 0xFF) {
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
dest[0] = (unsigned char) mb;
return 1;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_sjis_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_sjis(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 20 Shift JIS to Unicode */
static int zueci_sjis_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2;
int ind;
zueci_u32 u2;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
if (c1 == 0x5C) { /* Backslash to Yen sign */
*p_u = (flags & ZUECI_FLAG_SJIS_STRAIGHT_THRU) ? c1 : 0xA5;
} else if (c1 == 0x7E) { /* Tilde to overline */
*p_u = (flags & ZUECI_FLAG_SJIS_STRAIGHT_THRU) ? c1 : 0x203E;
} else {
*p_u = c1;
}
return 1;
}
if (c1 >= 0xA1 && c1 <= 0xDF) { /* Half-width katakana */
*p_u = 0xFEC0 + c1;
return 1;
}
if (len < 2 || c1 == 0x80 || c1 == 0xA0 || (c1 > 0xEA && c1 < 0xF0) || c1 > 0xF9) {
return 0;
}
c2 = src[1];
if (c2 < 0x40 || c2 == 0x7F || c2 > 0xFC) {
return 0;
}
if (c1 >= 0xF0 && c1 <= 0xF9) { /* User-defined to PUA (Table 4-86, Lunde, 2nd ed.) */
*p_u = 0xE000 + (0xFC - 0x40) * (c1 - 0xF0) + c2 - 0x40 - (c2 > 0x7F);
return 2;
}
ind = (0xFC - 0x40) * (c1 - 0x81 - (c1 > 0xA0) * (0xE0 - 0xA0)) + c2 - 0x40 - (c2 > 0x7F);
if (ind < ZUECI_ASIZE(zueci_sjis_mb_u) && (u2 = zueci_sjis_mb_u[ind])) {
*p_u = u2;
return 2;
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_sjis_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_sjis_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 28 Big5 Chinese (Taiwan) */
static int zueci_u_big5(const zueci_u32 u, unsigned char *dest) {
int s, e;
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
/* Special case URO block sequential mappings (considerably lessens size of `zueci_big5_u_u[]` array) */
if (u >= 0x4E00 && u < 0xFA0C) { /* 0xFA0C next used value >= 0x4E00 */
if (u >= 0x9FB0) {
return 0;
}
return zueci_u_lookup_uro(u, zueci_big5_uro_u, zueci_big5_uro_mb_ind, zueci_big5_u_mb, dest);
}
if (u >= zueci_big5_u_u[0] && u <= zueci_big5_u_u[ZUECI_ASIZE(zueci_big5_u_u) - 1]) {
s = 0;
e = ZUECI_ASIZE(zueci_big5_u_u) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_big5_u_u[m] < u) {
s = m + 1;
} else if (zueci_big5_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_big5_u_mb[u >= 0x4E00 ? m + 13061 : m]; /* Adjust for URO block */
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_big5_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_big5(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 28 Big5 to Unicode */
static int zueci_big5_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2;
int ind;
zueci_u32 u2;
(void)flags;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
*p_u = c1;
return 1;
}
if (len < 2 || c1 < 0xA1 || c1 == 0xC8 || c1 > 0xF9) {
return 0;
}
c2 = src[1];
if (c2 < 0x40 || (c2 > 0x7E && c2 < 0xA1) || c2 == 0xFF) {
return 0;
}
ind = 0x9D * (c1 - 0xA1 - (c1 > 0xC8)) + c2 - 0x40 - (c2 > 0x7E) * (0xA1 - 0x7F);
if (ind < ZUECI_ASIZE(zueci_big5_mb_u) && (u2 = zueci_big5_mb_u[ind])) {
*p_u = u2;
return 2;
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_big5_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_big5_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 30 EUC-KR (KS X 1001, formerly KS C 5601) Korean */
static int zueci_u_ksx1001(const zueci_u32 u, unsigned char *dest) {
int s, e;
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
/* Special case URO block sequential mappings (considerably lessens size of `zueci_ksx1001_u_u[]` array) */
if (u >= 0x4E00 && u < 0xAC00) { /* 0xAC00 next used value >= 0x4E00 */
if (u >= 0x9FA0) {
return 0;
}
return zueci_u_lookup_uro(u, zueci_ksx1001_uro_u, zueci_ksx1001_uro_mb_ind, zueci_ksx1001_u_mb, dest);
}
if (u >= zueci_ksx1001_u_u[0] && u <= zueci_ksx1001_u_u[ZUECI_ASIZE(zueci_ksx1001_u_u) - 1]) {
s = zueci_ksx1001_u_ind[(u - zueci_ksx1001_u_u[0]) >> 8];
e = ZUECI_MIN(s + 0x100, ZUECI_ASIZE(zueci_ksx1001_u_u)) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_ksx1001_u_u[m] < u) {
s = m + 1;
} else if (zueci_ksx1001_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_ksx1001_u_mb[u >= 0x4E00 ? m + 4620 : m]; /* Adjust for URO block */
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_ksx1001_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_ksx1001(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 30 EUC-KR to Unicode */
static int zueci_ksx1001_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2;
int ind;
zueci_u32 u2;
(void)flags;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
*p_u = c1;
return 1;
}
if (len < 2 || c1 < 0xA1 || (c1 > 0xAC && c1 < 0xB0) || c1 == 0xC9 || c1 > 0xFD) {
return 0;
}
c2 = src[1];
if (c2 < 0xA1 || c2 == 0xFF) {
return 0;
}
ind = (0xFF - 0xA1) * (c1 - 0xA1 - (c1 > 0xAC) * 3 - (c1 > 0xC9)) + c2 - 0xA1;
assert(ind < ZUECI_ASIZE(zueci_ksx1001_mb_u));
if ((u2 = zueci_ksx1001_mb_u[ind])) {
*p_u = u2;
return 2;
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_ksx1001_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_ksx1001_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 29 GB 2312 Chinese (PRC) */
static int zueci_u_gb2312(const zueci_u32 u, unsigned char *dest) {
if (u < 0x80) {
dest[0] = u;
return 1;
}
/* Special case URO block sequential mappings (considerably lessens size of `zueci_gb2312_u_u[]` array) */
if (u >= 0x4E00 && u < 0x9E1F) { /* 0x9E1F next used non-sequential value >= 0x4E00 */
if (u >= 0x9CF0) {
return 0;
}
return zueci_u_lookup_uro(u, zueci_gb2312_uro_u, zueci_gb2312_uro_mb_ind, zueci_gb2312_u_mb, dest);
}
if (u >= zueci_gb2312_u_u[0] && u <= zueci_gb2312_u_u[ZUECI_ASIZE(zueci_gb2312_u_u) - 1]) {
int s = zueci_gb2312_u_ind[(u - zueci_gb2312_u_u[0]) >> 8];
int e = ZUECI_MIN(s + 0x100, ZUECI_ASIZE(zueci_gb2312_u_u)) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_gb2312_u_u[m] < u) {
s = m + 1;
} else if (zueci_gb2312_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_gb2312_u_mb[u > 0x4E00 ? m + 6627 : m]; /* Adjust for URO block */
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_gb2312_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_gb2312(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 29 GB 2312 to Unicode */
static int zueci_gb2312_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2;
int ind;
zueci_u32 u2;
(void)flags;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
*p_u = c1;
return 1;
}
if (len < 2 || c1 < 0xA1 || (c1 > 0xA9 && c1 < 0xB0) || c1 > 0xF7) {
return 0;
}
c2 = src[1];
if (c2 < 0xA1 || c2 == 0xFF) {
return 0;
}
ind = (0xFF - 0xA1) * (c1 - 0xA1 - (c1 > 0xA9) * (0xB0 - 0xAA)) + c2 - 0xA1;
assert(ind < ZUECI_ASIZE(zueci_gb2312_mb_u));
if ((u2 = zueci_gb2312_mb_u[ind])) {
*p_u = u2;
return 2;
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_gb2312_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_gb2312_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode to ECI 31 GBK Chinese */
static int zueci_u_gbk(const zueci_u32 u, unsigned char *dest) {
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
/* Check GB 2312 first */
if (u == 0x30FB) {
/* KATAKANA MIDDLE DOT, mapped by GB 2312 but not by GBK (U+00B7 MIDDLE DOT mapped to 0xA1A4 instead) */
return 0;
}
if (u == 0x2015) {
/* HORIZONTAL BAR, mapped to 0xA844 by GBK rather than 0xA1AA (U+2014 EM DASH mapped there instead) */
dest[0] = 0xA8;
dest[1] = 0x44;
return 2;
}
if (zueci_u_gb2312(u, dest)) { /* Includes the 2 GB 6345.1-86 corrections given in Table 3-22, Lunde, 2nd ed. */
return 2;
}
/* Special case URO block sequential mappings (considerably lessens size of `zueci_gbk_u_u[]` array) */
if (u >= 0x4E00 && u < 0xF92C) { /* 0xF92C next used value >= 0x4E00 */
if (u >= 0x9FB0) {
return 0;
}
return zueci_u_lookup_uro(u, zueci_gbk_uro_u, zueci_gbk_uro_mb_ind, zueci_gbk_u_mb, dest);
}
if (u >= zueci_gbk_u_u[0] && u <= zueci_gbk_u_u[ZUECI_ASIZE(zueci_gbk_u_u) - 1]) {
int s = 0;
int e = ZUECI_ASIZE(zueci_gbk_u_u) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_gbk_u_u[m] < u) {
s = m + 1;
} else if (zueci_gbk_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_gbk_u_mb[u >= 0x4E00 ? m + 14139 : m]; /* Adjust for URO block */
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_gbk_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_gbk(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI 31 GBK Chinese to Unicode */
static int zueci_gbk_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2;
int ind;
zueci_u32 u2;
zueci_u16 mb;
(void)flags;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
*p_u = c1;
return 1;
}
if (len < 2 || c1 < 0x81 || c1 == 0xFF) {
return 0;
}
c2 = src[1];
if (c2 < 0x40 || c2 == 0x7F || c2 == 0xFF) {
return 0;
}
/* Try GB 2312 first */
if (((c1 >= 0xA1 && c1 <= 0xA9) || (c1 >= 0xB0 && c1 <= 0xF7)) && c2 >= 0xA1) {
if (c1 == 0xA1 && c2 == 0xA4) {
*p_u = 0x00B7; /* MIDDLE DOT */
return 2;
}
if (c1 == 0xA1 && c2 == 0xAA) {
*p_u = 0x2014; /* EM DASH */
return 2;
}
if (zueci_gb2312_u(src, len, 0 /*flags*/, p_u)) {
return 2;
}
}
/* Non-URO? */
mb = ((zueci_u16) c1 << 8) | c2;
if (mb >= zueci_gbk_nonuro_mb[0] && mb <= zueci_gbk_nonuro_mb[ZUECI_ASIZE(zueci_gbk_nonuro_mb) - 1]) {
int s = 0;
int e = ZUECI_ASIZE(zueci_gbk_nonuro_mb) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_gbk_nonuro_mb[m] < mb) {
s = m + 1;
} else if (zueci_gbk_nonuro_mb[m] > mb) {
e = m - 1;
} else {
*p_u = zueci_gbk_nonuro_u[m];
return 2;
}
}
}
if (c1 >= 0xA1 && (c1 <= 0xA7 || (c1 >= 0xA8 && c2 >= 0xA1))) {
return 0;
}
if (c1 >= 0xA8) {
ind = (0xFF - 0x40 - 1) * (0xA1 - 0x81) + (0xA1 - 0x40 - 1) * (c1 - 0xA8) + c2 - 0x40 - (c2 > 0x7F);
} else {
ind = (0xFF - 0x40 - 1) * (c1 - 0x81) + c2 - 0x40 - (c2 > 0x7F);
}
if (ind < ZUECI_ASIZE(zueci_gbk_mb_u) && (u2 = zueci_gbk_mb_u[ind])) {
*p_u = u2;
return 2;
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_gbk_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_gbk_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Helper for `u_gb18030()` to output 4-byte sequential blocks 0x[81-FE][30-39][81-FE][30-39] */
static int zueci_u_gb18030_4_sequential(zueci_u32 u2, zueci_u32 mb_lead, unsigned char *dest) {
zueci_u32 dv;
dv = u2 / 10; /* (0x39 - 0x30) + 1 */
dest[3] = (unsigned char) (u2 - dv * 10 + 0x30);
u2 = dv;
dv = u2 / 126; /* (0xFE - 0x81) + 1 */
dest[2] = (unsigned char) (u2 - dv * 126 + 0x81);
u2 = dv;
dv = u2 / 10; /* (0x39 - 0x30) + 1 */
dest[0] = (unsigned char) (dv + mb_lead);
dest[1] = (unsigned char) (u2 - dv * 10 + 0x30);
return 4;
}
/* Unicode to ECI 32 GB 18030 Chinese - assumes valid Unicode */
static int zueci_u_gb18030(const zueci_u32 u, unsigned char *dest) {
zueci_u32 u2, dv;
int s, e;
if (u < 0x80) {
*dest = (unsigned char) u;
return 1;
}
/* Check GBK first */
if (zueci_u_gbk(u, dest)) {
return 2;
}
if (u >= 0x10000) {
/* Non-BMP that were PUA, see Table 3-37, Lunde, 2nd ed. */
if (u == 0x20087) {
dest[0] = 0xFE;
dest[1] = 0x51;
return 2;
}
if (u == 0x20089) {
dest[0] = 0xFE;
dest[1] = 0x52;
return 2;
}
if (u == 0x200CC) {
dest[0] = 0xFE;
dest[1] = 0x53;
return 2;
}
if (u == 0x215D7) {
dest[0] = 0xFE;
dest[1] = 0x6C;
return 2;
}
if (u == 0x2298F) {
dest[0] = 0xFE;
dest[1] = 0x76;
return 2;
}
if (u == 0x241FE) {
dest[0] = 0xFE;
dest[1] = 0x91;
return 2;
}
/* All other non-BMP U+10000-10FFFF */
return zueci_u_gb18030_4_sequential(u - 0x10000, 0x90, dest);
}
if (u >= 0xE000 && u <= 0xE765) { /* PUA to user-defined */
if (u <= 0xE4C5) {
u2 = u - 0xE000;
dv = u2 / 94;
dest[0] = (unsigned char) (dv + (dv < 6 ? 0xAA : 0xF2));
dest[1] = (unsigned char) (u2 - dv * 94 + 0xA1);
} else {
zueci_u32 md;
u2 = u - 0xE4C6;
dv = u2 / 96;
md = u2 - dv * 96;
dest[0] = (unsigned char) (dv + 0xA1);
dest[1] = (unsigned char) (md + 0x40 + (md >= 0x3F));
}
return 2;
}
if (u >= zueci_gb18030_2_u_u[0] && u <= zueci_gb18030_2_u_u[ZUECI_ASIZE(zueci_gb18030_2_u_u) - 1]) {
int s = 0;
int e = ZUECI_ASIZE(zueci_gb18030_2_u_u) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_gb18030_2_u_u[m] < u) {
s = m + 1;
} else if (zueci_gb18030_2_u_u[m] > u) {
e = m - 1;
} else {
const zueci_u16 mb = zueci_gb18030_2_u_mb[m];
dest[0] = (unsigned char) (mb >> 8);
dest[1] = (unsigned char) mb;
return 2;
}
}
}
/* All other BMP U+0080-FFFF */
if (u == 0xE7C7) { /* PUA change to non-PUA, see Table 3-39, Lunde, 2nd ed. */
dest[0] = 0x81;
dest[1] = 0x35;
dest[2] = 0xF4;
dest[3] = 0x37;
return 4;
}
s = 0;
e = ZUECI_ASIZE(zueci_gb18030_4_u_e) - 1;
while (s < e) { /* Lower bound */
const int m = (s + e) >> 1;
if (zueci_gb18030_4_u_e[m] < u) {
s = m + 1;
} else {
e = m;
}
}
assert(s < ZUECI_ASIZE(zueci_gb18030_4_u_e));
return zueci_u_gb18030_4_sequential(u - zueci_gb18030_4_u_mb_o[s] - 0x80, 0x81, dest);
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_u_gb18030_test(const zueci_u32 u, unsigned char *dest) {
return zueci_u_gb18030(u, dest);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Helper to convert GB 18030 4-byter to Unicode */
static zueci_u32 zueci_gb18030_mb4_u(zueci_u32 mb4) {
unsigned char c1 = (unsigned char) (mb4 >> 24);
unsigned char c2 = (unsigned char) (mb4 >> 16);
unsigned char c3 = (unsigned char) (mb4 >> 8);
unsigned char c4 = (unsigned char) mb4;
return (((c1 - 0x81) * 10 + (c2 - 0x30)) * 126 + (c3 - 0x81)) * 10 + c4 - 0x30;
}
/* ECI 32 GB 18030 to Unicode */
static int zueci_gb18030_u(const unsigned char *src, const zueci_u32 len, const unsigned int flags, zueci_u32 *p_u) {
unsigned char c1, c2, c3, c4;
int ret;
zueci_u16 mb2;
zueci_u32 mb4;
(void)flags;
assert(len);
c1 = src[0];
if (c1 < 0x80) {
*p_u = c1;
return 1;
}
if (len < 2 || c1 < 0x81 || c1 == 0xFF) {
return 0;
}
if ((ret = zueci_gbk_u(src, len, 0 /*flags*/, p_u))) {
return ret;
}
c2 = src[1];
if (len >= 4 && c2 <= 0x39 && c2 >= 0x30 && c1 >= 0x81 && c1 <= 0xE3) {
c3 = src[2];
c4 = src[3];
mb4 = ZUECI_4BYTES_U32(c1, c2, c3, c4);
if (mb4 < 0x81308130 || (mb4 > 0x8431A439 && mb4 < 0x90308130) || mb4 > 0xE3329A35
|| c3 < 0x81 || c3 > 0xFE || c4 < 0x30 || c4 > 0x39) {
return 0;
}
if (mb4 == 0x8135F437) { /* PUA change to non-PUA, see Table 3-39, Lunde, 2nd ed. */
*p_u = 0xE7C7;
return 4;
}
if (c1 >= 0x90) { /* Non-BMP */
*p_u = 0x10000 + (((c1 - 0x90) * 10 + (c2 - 0x30)) * 126 + (c3 - 0x81)) * 10 + c4 - 0x30;
} else { /* BMP */
int s = 0;
int e = ZUECI_ASIZE(zueci_gb18030_4_mb_e) - 1;
while (s < e) { /* Lower bound */
const int m = (s + e) >> 1;
if (zueci_gb18030_4_mb_e[m] < mb4) {
s = m + 1;
} else {
e = m;
}
}
assert(s < ZUECI_ASIZE(zueci_gb18030_4_mb_e));
*p_u = zueci_gb18030_4_u_e[s] - (zueci_gb18030_mb4_u(zueci_gb18030_4_mb_e[s]) - zueci_gb18030_mb4_u(mb4));
}
return 4;
}
if (c2 < 0x40 || c2 == 0x7F || c2 == 0xFF) {
return 0;
}
if (((c1 >= 0xAA && c1 <= 0xAF) || (c1 >= 0xF8 && c1 <= 0xFE)) && c2 >= 0xA1 && c2 <= 0xFE) { /* UDA-1/2 PUA */
*p_u = 0xE000 + (0xFF - 0xA0 - 1) * (c1 - (c1 >= 0xF8 ? 0xF2 : 0xAA)) + c2 - 0xA1;
return 2;
}
if (c1 >= 0xA1 && c1 <= 0xA7 && c2 <= 0xA1) { /* UDA-3 PUA */
*p_u = 0xE4C6 + (0xA1 - 0x40 - 1) * (c1 - 0xA1) + c2 - 0x40 - (c2 > 0x7F);
return 2;
}
if (c1 == 0xFE && c2 >= 0x51 && c2 <= 0x91) {
/* Non-BMP that were PUA, see Table 3-37, Lunde, 2nd ed. */
if (c2 == 0x51) {
*p_u = 0x20087;
return 2;
}
if (c2 == 0x52) {
*p_u = 0x20089;
return 2;
}
if (c2 == 0x53) {
*p_u = 0x200CC;
return 2;
}
if (c2 == 0x6C) {
*p_u = 0x215D7;
return 2;
}
if (c2 == 0x76) {
*p_u = 0x2298F;
return 2;
}
if (c2 == 0x91) {
*p_u = 0x241FE;
return 2;
}
}
mb2 = ((zueci_u16) c1 << 8) | c2;
if (mb2 >= zueci_gb18030_2_mb_mb[0] && mb2 <= zueci_gb18030_2_mb_mb[ZUECI_ASIZE(zueci_gb18030_2_mb_mb) - 1]) {
int s = 0;
int e = ZUECI_ASIZE(zueci_gb18030_2_mb_mb) - 1;
while (s <= e) {
const int m = (s + e) >> 1;
if (zueci_gb18030_2_mb_mb[m] < mb2) {
s = m + 1;
} else if (zueci_gb18030_2_mb_mb[m] > mb2) {
e = m - 1;
} else {
*p_u = zueci_gb18030_2_mb_u[m];
return 2;
}
}
}
return 0;
}
#ifdef ZUECI_TEST /* Wrapper for direct testing */
ZUECI_INTERN int zueci_gb18030_u_test(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u) {
return zueci_gb18030_u(src, len, flags, p_u);
}
#endif
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
/* API */
#ifndef ZUECI_EMBED_NO_TO_ECI
/*
Convert UTF-8 `src` of length `src_len` to `eci`-encoded `dest`.
`p_dest_len` is set to length of `dest` on output.
`dest` must be big enough (4-times the `src_len`, or see `zueci_dest_len_eci()`). It is not NUL-terminated.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not
*/
ZUECI_EXTERN int zueci_utf8_to_eci(const int eci, const unsigned char src[], const int src_len,
unsigned char dest[], int *p_dest_len) {
/* Unicode to ECI function table */
typedef int (*zueci_eci_func_t)(const zueci_u32 u, unsigned char *dest);
static const zueci_eci_func_t zueci_eci_funcs[36] = {
zueci_u_cp437, NULL, zueci_u_cp437, NULL, zueci_u_iso8859_2, /*0-4*/
zueci_u_iso8859_3, zueci_u_iso8859_4, zueci_u_iso8859_5, zueci_u_iso8859_6, zueci_u_iso8859_7, /*5-9*/
zueci_u_iso8859_8, zueci_u_iso8859_9, zueci_u_iso8859_10, zueci_u_iso8859_11, NULL, /*10-14*/
zueci_u_iso8859_13, zueci_u_iso8859_14, zueci_u_iso8859_15, zueci_u_iso8859_16, NULL, /*15-19*/
zueci_u_sjis, zueci_u_cp1250, zueci_u_cp1251, zueci_u_cp1252, zueci_u_cp1256, /*20-24*/
zueci_u_utf16be, NULL, zueci_u_ascii, zueci_u_big5, zueci_u_gb2312, /*25-29*/
zueci_u_ksx1001, zueci_u_gbk, zueci_u_gb18030, zueci_u_utf16le, zueci_u_utf32be, /*30-34*/
zueci_u_utf32le,
};
unsigned int state = 0;
const unsigned char *s = src;
const unsigned char *const se = src + src_len;
unsigned char *d = dest;
zueci_eci_func_t eci_func;
zueci_u32 u;
if (!zueci_is_valid_eci(eci)) {
return ZUECI_ERROR_INVALID_ECI;
}
if (!src || !dest || !p_dest_len) {
return ZUECI_ERROR_INVALID_ARGS;
}
/* Special case ISO/IEC 8859-1 */
if (eci == 1 || eci == 3) {
while (s < se) {
do {
zueci_decode_utf8(&state, &u, *s++);
} while (s < se && state != 0 && state != 12);
if (state != 0) {
return ZUECI_ERROR_INVALID_UTF8;
}
if (u >= 0x80 && (u < 0xA0 || u >= 0x100)) {
return ZUECI_ERROR_INVALID_DATA;
}
*d++ = (unsigned char) u;
}
*p_dest_len = (int) (d - dest);
return 0;
}
/* Special case UTF-8 */
if (eci == 26) {
if (!zueci_is_valid_utf8(src, src_len)) {
return ZUECI_ERROR_INVALID_UTF8;
}
memcpy(dest, src, src_len);
*p_dest_len = src_len;
return 0;
}
if (eci == 170) { /* ASCII Invariant (archaic subset) */
eci_func = zueci_u_ascii_inv;
} else if (eci == 899) { /* Binary */
eci_func = zueci_u_binary;
} else {
eci_func = zueci_eci_funcs[eci];
}
while (s < se) {
int incr;
do {
zueci_decode_utf8(&state, &u, *s++);
} while (s < se && state != 0 && state != 12);
if (state != 0) {
return ZUECI_ERROR_INVALID_UTF8;
}
incr = (*eci_func)(u, d);
if (incr == 0) {
return ZUECI_ERROR_INVALID_DATA;
}
d += incr;
}
*p_dest_len = (int) (d - dest);
return 0;
}
/*
Calculate sufficient (i.e. approx.) length needed to convert UTF-8 `src` of length `src_len` from UTF-8 to ECI
`eci`, and place in `p_dest_len`.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not
*/
ZUECI_EXTERN int zueci_dest_len_eci(const int eci, const unsigned char src[], const int src_len, int *p_dest_len) {
int dest_len = src_len;
if (!zueci_is_valid_eci(eci)) {
return ZUECI_ERROR_INVALID_ECI;
}
if (!src || !p_dest_len) {
return ZUECI_ERROR_INVALID_ARGS;
}
if (eci == 20) { /* Shift JIS */
/* Only ASCII backslash (reverse solidus) exceeds UTF-8 length */
dest_len += zueci_chr_cnt(src, src_len, '\\');
} else if (eci == 25 || eci == 33) { /* UTF-16 */
/* All ASCII chars take 2 bytes */
dest_len += zueci_chr_lte_cnt(src, src_len, 0x7F);
/* Surrogate pairs are 4 UTF-8 bytes long so fit */
} else if (eci == 32) { /* GB 18030 */
/* Allow for GB 18030 4 byters */
dest_len *= 2;
} else if (eci == 34 || eci == 35) { /* UTF-32 */
/* Quadruple-up ASCII and double-up non-ASCII */
dest_len += zueci_chr_lte_cnt(src, src_len, 0x7F) * 2 + src_len;
}
/* Big5, GB 2312, EUC-KR and GBK fit in UTF-8 length */
*p_dest_len = dest_len;
return 0;
}
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* ECI to Unicode function table */
typedef int (*zueci_utf8_func_t)(const unsigned char *src, const zueci_u32 len, const unsigned int flags,
zueci_u32 *p_u);
static const zueci_utf8_func_t zueci_utf8_funcs[36] = {
zueci_cp437_u, NULL, zueci_cp437_u, NULL, zueci_iso8859_2_u, /*0-4*/
zueci_iso8859_3_u, zueci_iso8859_4_u, zueci_iso8859_5_u, zueci_iso8859_6_u, zueci_iso8859_7_u, /*5-9*/
zueci_iso8859_8_u, zueci_iso8859_9_u, zueci_iso8859_10_u, zueci_iso8859_11_u, NULL, /*10-14*/
zueci_iso8859_13_u, zueci_iso8859_14_u, zueci_iso8859_15_u, zueci_iso8859_16_u, NULL, /*15-19*/
zueci_sjis_u, zueci_cp1250_u, zueci_cp1251_u, zueci_cp1252_u, zueci_cp1256_u, /*20-24*/
zueci_utf16be_u, NULL, zueci_ascii_u, zueci_big5_u, zueci_gb2312_u, /*25-29*/
zueci_ksx1001_u, zueci_gbk_u, zueci_gb18030_u, zueci_utf16le_u, zueci_utf32be_u, /*30-34*/
zueci_utf32le_u,
};
/*
Convert ECI-encoded `src` of length `src_len` to UTF-8 `dest`.
`p_dest_len` is set to length of `dest` on output.
`dest` must be big enough (4-times the `src_len`, or see `zueci_dest_len_utf8()`). It is not NUL-terminated.
If the Unicode BMP `replacement_char` (<= 0xFFFF) is non-zero then it will substituted for all source characters
with no mapping and processing will continue, returning ZUECI_WARN_INVALID_DATA unless other errors.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_eci_to_utf8(const int eci, const unsigned char src[], const int src_len,
const unsigned int replacement_char, const unsigned int flags, unsigned char dest[],
int *p_dest_len) {
const unsigned char *s = src;
const unsigned char *const se = src + src_len;
unsigned char *d = dest;
zueci_utf8_func_t utf8_func;
zueci_u32 u;
int src_incr;
unsigned char replacement[5];
int replacement_len = 0; /* g++ complains with "-Wmaybe-uninitialized" if this isn't set */
int ret = 0;
if (!zueci_is_valid_eci(eci)) {
return ZUECI_ERROR_INVALID_ECI;
}
if (!src || !dest || !p_dest_len) {
return ZUECI_ERROR_INVALID_ARGS;
}
/* Special case Binary, and if straight-thru flag set then ISO/IEC 8859-1, ASCII and ISO/IEC 646 Invariant also */
if (eci == 899 || ((flags & ZUECI_FLAG_SB_STRAIGHT_THRU) && (eci == 1 || eci == 3 || eci == 27 || eci == 170))) {
while (s < se) {
d += zueci_encode_utf8(*s++, d);
}
*p_dest_len = (int) (d - dest);
return 0;
}
if (replacement_char) {
if (!ZUECI_IS_VALID_UNICODE(replacement_char) || replacement_char > 0xFFFF) { /* Allow BMP only */
return ZUECI_ERROR_INVALID_ARGS;
}
replacement_len = zueci_encode_utf8(replacement_char, replacement);
}
/* Special case ISO/IEC 8859-1 */
if (eci == 1 || eci == 3) {
for (; s < se; s++) {
if (*s >= 0x80 && *s < 0xA0) {
if (!replacement_char) {
return ZUECI_ERROR_INVALID_DATA;
}
memcpy(d, replacement, replacement_len);
d += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
} else {
d += zueci_encode_utf8(*s, d);
}
}
*p_dest_len = (int) (d - dest);
return ret;
}
/* Special case UTF-8 */
if (eci == 26) {
if (replacement_char) {
unsigned int state = 0;
while (s < se) {
do {
zueci_decode_utf8(&state, &u, *s++);
} while (s < se && state != 0 && state != 12);
if (state != 0) {
if (*(s - 1) < 0x80) { /* If previous ASCII, backtrack */
s--;
} else {
while (s < se && (*s & 0xC0) == 0x80) { /* Skip any continuation bytes */
s++;
}
}
memcpy(d, replacement, replacement_len);
d += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
state = 0;
} else {
d += zueci_encode_utf8(u, d);
}
}
*p_dest_len = (int) (d - dest);
return ret;
}
if (!zueci_is_valid_utf8(src, src_len)) {
return ZUECI_ERROR_INVALID_UTF8;
}
memcpy(dest, src, src_len);
*p_dest_len = src_len;
return 0;
}
if (eci == 170) {
utf8_func = zueci_ascii_inv_u;
} else {
utf8_func = zueci_utf8_funcs[eci];
}
while (s < se) {
if (!(src_incr = (*utf8_func)(s, (int) (se - s), flags, &u))) {
if (!replacement_char) {
return ZUECI_ERROR_INVALID_DATA;
}
memcpy(d, replacement, replacement_len);
s += zueci_replacement_incr(eci, s, (int) (se - s));
d += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
} else {
s += src_incr;
d += zueci_encode_utf8(u, d);
}
}
*p_dest_len = (int) (d - dest);
return ret;
}
/*
Calculate exact length needed to convert ECI-encoded `src` of length `len` from ECI `eci`, and place in
`p_dest_len`.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_dest_len_utf8(const int eci, const unsigned char src[], const int src_len,
const unsigned int replacement_char, const int unsigned flags, int *p_dest_len) {
const unsigned char *s = src;
const unsigned char *const se = src + src_len;
zueci_utf8_func_t utf8_func;
zueci_u32 u;
int src_incr;
unsigned char replacement[5];
int replacement_len = 0; /* g++ complains with "-Wmaybe-uninitialized" if this isn't set */
int dest_len = 0;
int ret = 0;
/* NOTE: the following is "unrolled" from `zueci_eci_to_utf8()` and should be the same except for the copying */
if (!zueci_is_valid_eci(eci)) {
return ZUECI_ERROR_INVALID_ECI;
}
if (!src || !p_dest_len) {
return ZUECI_ERROR_INVALID_ARGS;
}
/* Special case Binary, and if straight-thru flag set then ISO/IEC 8859-1, ASCII and ISO/IEC 646 Invariant also */
if (eci == 899 || ((flags & ZUECI_FLAG_SB_STRAIGHT_THRU) && (eci == 1 || eci == 3 || eci == 27 || eci == 170))) {
while (s < se) {
dest_len += 1 + (*s++ >= 0x80);
}
*p_dest_len = dest_len;
return 0;
}
if (replacement_char) {
if (!ZUECI_IS_VALID_UNICODE(replacement_char) || replacement_char > 0xFFFF) { /* Allow BMP only */
return ZUECI_ERROR_INVALID_ARGS;
}
replacement_len = zueci_encode_utf8(replacement_char, replacement);
}
/* Special case ISO/IEC 8859-1 */
if (eci == 1 || eci == 3) {
for (; s < se; s++) {
if (*s >= 0x80 && *s < 0xA0) {
if (!replacement_char) {
return ZUECI_ERROR_INVALID_DATA;
}
dest_len += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
} else {
dest_len += 1 + (*s >= 0x80);
}
}
*p_dest_len = dest_len;
return ret;
}
/* Special case UTF-8 */
if (eci == 26) {
unsigned int state = 0;
while (s < se) {
do {
zueci_decode_utf8(&state, &u, *s++);
} while (s < se && state != 0 && state != 12);
if (state != 0) {
if (!replacement_char) {
return ZUECI_ERROR_INVALID_UTF8;
}
if (*(s - 1) < 0x80) { /* If previous ASCII, backtrack */
s--;
} else {
while (s < se && (*s & 0xC0) == 0x80) { /* Skip any continuation bytes */
s++;
}
}
dest_len += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
state = 0;
} else {
dest_len += 1 + (u >= 0x80) + (u >= 0x800) + (u >= 0x10000);
}
}
*p_dest_len = dest_len;
return ret;
}
if (eci == 170) {
utf8_func = zueci_ascii_inv_u;
} else {
utf8_func = zueci_utf8_funcs[eci];
}
while (s < se) {
if (!(src_incr = (*utf8_func)(s, (int) (se - s), flags, &u))) {
if (!replacement_char) {
return ZUECI_ERROR_INVALID_DATA;
}
s += zueci_replacement_incr(eci, s, (int) (se - s));
dest_len += replacement_len;
ret = ZUECI_WARN_INVALID_DATA;
} else {
s += src_incr;
dest_len += 1 + (u >= 0x80) + (u >= 0x800) + (u >= 0x10000);
}
}
*p_dest_len = dest_len;
return ret;
}
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
/* vim: set ts=4 sw=4 et : */
```
|
/content/code_sandbox/core/src/libzueci/zueci.c
|
c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 20,089
|
```objective-c
/* sjis.h - tables for Unicode to/from ECI 20 Shift JIS, generated by "tools/gen_zueci_mb_h.php" from
"path_to_url" */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_SJIS_H
#define ZUECI_SJIS_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode usage bit-flags for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_sjis_uro_u[1307] = {
0x6F8B, 0x43F3, 0x2442, 0x9B46, 0xE82C, 0xE3E0, 0x0004, 0x400A,
0x5F65, 0xDB36, 0x7977, 0x0449, 0xECD7, 0xE3F0, 0x6038, 0x08C5,
0xE602, 0x3403, 0x8000, 0x3551, 0xE0C8, 0x7EAB, 0x8200, 0x9869,
0xA948, 0x2942, 0xE803, 0x8060, 0x441C, 0xAD93, 0xC03A, 0x4568,
0xAA60, 0x8656, 0x3F7A, 0x0240, 0x8388, 0x1461, 0x1020, 0x2174,
0x2021, 0x0702, 0x3000, 0x40BC, 0xA624, 0x4462, 0x60A8, 0x0A20,
0x0217, 0x8574, 0x0402, 0x9C84, 0x7BFB, 0x1415, 0x7F24, 0x11E2,
0xB665, 0x02EF, 0x1F75, 0x20FF, 0x3A70, 0x3840, 0x26C3, 0x6763,
0x4DD9, 0x2092, 0x46B0, 0x0FC9, 0xBC98, 0x4850, 0x8638, 0xA03F,
0x2388, 0x8816, 0x3E09, 0x5232, 0x22AA, 0xE3A4, 0x00DD, 0xC72C,
0xA166, 0x26E1, 0x840B, 0x8F0A, 0x27EB, 0x559E, 0xC241, 0x89BB,
0x0014, 0x8540, 0x6361, 0x0849, 0x7F0C, 0x8AD0, 0xFF3E, 0x05CF,
0xFF1A, 0xA803, 0x7A41, 0x7B40, 0x4745, 0x8002, 0x0500, 0x38EB,
0xD851, 0x0005, 0x9934, 0x710C, 0x0397, 0x0100, 0x6366, 0x2404,
0x80D0, 0x0051, 0xC000, 0x430A, 0x9071, 0x30C8, 0x0008, 0x5800,
0x0E99, 0xF700, 0x5F80, 0x0041, 0x00B0, 0x9410, 0x0018, 0x6280,
0x0240, 0x09D0, 0x8200, 0x0156, 0x5004, 0x0801, 0x1D10, 0x0510,
0x84C1, 0x0010, 0x4025, 0x1050, 0x410F, 0x4D8A, 0x4009, 0xA60D,
0xAB19, 0x914C, 0x21C0, 0x0981, 0xC485, 0x0003, 0x0652, 0x8000,
0x0B04, 0x0008, 0x041D, 0x0009, 0x4849, 0x905C, 0x0009, 0x1690,
0x0C65, 0x2220, 0x8412, 0x2433, 0x0C03, 0x4796, 0x0A04, 0x4225,
0x0028, 0x9088, 0x4900, 0x4F08, 0x14A2, 0xD3AA, 0xD830, 0x3E87,
0x8604, 0x1F61, 0x7EA4, 0x4186, 0xC390, 0x05B3, 0x57A5, 0x2118,
0x241E, 0x2A48, 0x1128, 0x4A04, 0x0A40, 0x161B, 0x0D60, 0x8840,
0x020A, 0x9502, 0x8221, 0x1060, 0x0243, 0x0400, 0x1444, 0x8000,
0x0000, 0x0C04, 0x0000, 0x7000, 0x1A06, 0x00C1, 0x024A, 0x0C00,
0x1A00, 0x0040, 0x1404, 0x4045, 0x0029, 0xBDB3, 0x0A78, 0x052B,
0xBBA9, 0xBFA0, 0x407C, 0x8379, 0x12FC, 0xE81D, 0x4BF6, 0xC569,
0xEFF6, 0x044A, 0x2115, 0xFF02, 0xED63, 0x402B, 0xD033, 0x0242,
0x1000, 0x0013, 0x1B02, 0x59CA, 0x00A0, 0x0200, 0xA703, 0x2C41,
0x4880, 0x8FF2, 0x0204, 0x0000, 0x5800, 0x1005, 0x9200, 0x0048,
0x1894, 0x2001, 0x5004, 0x3480, 0x3200, 0x684C, 0x49EA, 0x68BE,
0x184C, 0x2E42, 0xA820, 0x21C9, 0x50B9, 0x80B0, 0x001E, 0xFF7C,
0x849A, 0x14E0, 0x28C1, 0x01E0, 0x870E, 0xAC49, 0x130F, 0xDDDB,
0xBE1A, 0x89FB, 0xA2E0, 0x51A2, 0x5502, 0x32CA, 0x3E46, 0x928B,
0x1DBF, 0x438F, 0x6703, 0x3218, 0x3028, 0x33C0, 0x0811, 0xA923,
0xC000, 0x3A65, 0x8FE3, 0x0402, 0x2C4E, 0x8625, 0xBF3D, 0x00A1,
0x3A1A, 0x8CD4, 0x06C9, 0x317C, 0x00E0, 0x950A, 0x018B, 0x0EDB,
0xE34B, 0x8C20, 0x1182, 0xF010, 0x7D94, 0xA728, 0xC9AC, 0x40FB,
0x4484, 0x0653, 0x5A90, 0x4444, 0x3FC8, 0x0001, 0x0048, 0xF5D4,
0x7701, 0xEC57, 0xC442, 0x891D, 0x6B83, 0x4928, 0x4109, 0xD242,
0x061D, 0x59FE, 0x1800, 0x3A22, 0xB7E4, 0x3B9F, 0xF003, 0xC0EA,
0x1386, 0x8202, 0x8980, 0xE400, 0xB200, 0x10A1, 0x4B80, 0x0CC4,
0xD309, 0x8944, 0x1FAF, 0x4834, 0x8259, 0x0C45, 0x420A, 0x0450,
0xA040, 0x10C8, 0x3140, 0x4450, 0x4004, 0x0100, 0x8280, 0x0540,
0x0108, 0x442C, 0x6A30, 0x1A05, 0x20A6, 0x0514, 0x90CF, 0x6456,
0x0021, 0x3100, 0x9C18, 0xCBF0, 0xA120, 0x63E2, 0x104C, 0x01B5,
0x538C, 0x9A83, 0xB8B2, 0x3281, 0x987A, 0x0A84, 0x33E7, 0x0C02,
0xD4CC, 0x9018, 0xA1A1, 0x9070, 0x8A1E, 0xE004, 0xC3D4, 0x0451,
0x439A, 0x21C2, 0x4844, 0x5310, 0x0292, 0x3640, 0x0241, 0xF3BD,
0xAB09, 0xE8F0, 0x7DC0, 0xA5D2, 0xC242, 0xD24B, 0xA43F, 0xD0AF,
0x1AA0, 0x34A1, 0x8247, 0x03D8, 0xC452, 0x651B, 0xD294, 0xC83A,
0x001C, 0x40C8, 0x0E06, 0x3314, 0x614F, 0xB21B, 0x0088, 0xC0D0,
0xA02A, 0xA898, 0xA1C5, 0x166B, 0x2E50, 0x85B4, 0xC08B, 0x0604,
0xF933, 0x1E04, 0x056E, 0xA251, 0x0400, 0x7638, 0xEC07, 0x73B8,
0x4406, 0x1832, 0x4081, 0xC816, 0x7C8A, 0x6309, 0x2980, 0xAA04,
0x1C24, 0xCA9C, 0x4E0E, 0x2760, 0x0990, 0x8300, 0x0046, 0x8104,
0x6011, 0x1081, 0x540D, 0x0908, 0x000E, 0xCC0A, 0x0500, 0x0C00,
0x0430, 0xA044, 0x008B, 0x6784, 0x5288, 0x8A19, 0x865E, 0x8B18,
0x2E59, 0x4160, 0x8C10, 0x9CBE, 0x6861, 0x891C, 0x9800, 0x0008,
0x8100, 0x089A, 0x0018, 0x4190, 0x4007, 0xE4A1, 0x0505, 0x640D,
0x310E, 0x0E4D, 0x4806, 0xFF0A, 0x1632, 0x2AA8, 0x852E, 0x000B,
0x1800, 0xCA84, 0x0E20, 0x696C, 0x0032, 0x1600, 0x5658, 0x0390,
0x5120, 0x1A28, 0x8000, 0x1124, 0x18E1, 0x4326, 0x5D52, 0x0EAA,
0x0FA0, 0xAE28, 0xFA7B, 0x4500, 0x6408, 0x8940, 0xC880, 0xC044,
0x9005, 0xB141, 0x8424, 0x24C4, 0x1A34, 0x603A, 0x9000, 0xC194,
0x8246, 0x003A, 0x180D, 0xC106, 0x0022, 0x9910, 0xE050, 0x1511,
0x4057, 0x0082, 0x041A, 0x020A, 0x004F, 0x8930, 0xD813, 0x444A,
0x8A02, 0xED22, 0x10C0, 0x4005, 0x1000, 0x0102, 0x8808, 0x3101,
0x4600, 0x0204, 0xF000, 0x0708, 0x8900, 0xA200, 0x0000, 0x2202,
0x0200, 0x1610, 0x0042, 0x1040, 0x5200, 0x0260, 0x52F4, 0x2000,
0x8510, 0x8230, 0x1100, 0x4202, 0x4308, 0x80B5, 0x70E1, 0x9A20,
0x2040, 0x0801, 0x3500, 0xFC65, 0x19C1, 0xAB04, 0x0286, 0x6214,
0x0087, 0x0044, 0x9085, 0x0244, 0x405C, 0x0A85, 0x3207, 0x3380,
0x0400, 0xB8C0, 0xCE20, 0xC0D0, 0xC030, 0x0080, 0x0508, 0x0D25,
0x0A90, 0x0040, 0x0200, 0x080C, 0x6505, 0x4000, 0x6421, 0x4102,
0x0268, 0x0000, 0x0024, 0x847C, 0x0002, 0xDE20, 0x8619, 0x4049,
0x0808, 0x4000, 0x0084, 0x2001, 0x8400, 0x1010, 0x42CD, 0x01C7,
0x7038, 0xD52A, 0x1968, 0x1D8F, 0xBE50, 0x3E12, 0x2EF5, 0x81D9,
0xCEC4, 0x2412, 0x0828, 0x732E, 0x24AC, 0x4B34, 0x020C, 0xD41D,
0x2A02, 0x8000, 0x0097, 0x0811, 0x11C4, 0x1144, 0x1786, 0x7D45,
0x49D9, 0x0649, 0x4000, 0x8791, 0x254C, 0xD8C4, 0x44BA, 0x4914,
0x1B92, 0xC800, 0x0271, 0x1580, 0x0081, 0x0C00, 0x096A, 0xC200,
0x4800, 0x4002, 0x3021, 0xBA49, 0x2080, 0x1C80, 0xE2AC, 0x1008,
0x1004, 0x0034, 0x00E1, 0x8414, 0x0020, 0x2000, 0x9800, 0x1014,
0x70C2, 0x04AA, 0x8688, 0x5420, 0x0C62, 0x0413, 0x9180, 0x2010,
0x4082, 0x0206, 0x1C40, 0x5400, 0x0383, 0xE4E9, 0x2125, 0x8480,
0xE433, 0x2000, 0x44C0, 0xE609, 0x0A03, 0x8126, 0x12DA, 0x0801,
0x6901, 0x9790, 0x4001, 0xF886, 0xE24D, 0x0081, 0x0A0E, 0xA651,
0x011A, 0x81EC, 0xC600, 0x8441, 0xADB8, 0xB62C, 0xA46F, 0x8741,
0x8D54, 0x4B02, 0x1161, 0x0268, 0xBB60, 0x2057, 0x50A0, 0x0433,
0xA8C0, 0xB7B4, 0x2402, 0x0112, 0x9AD3, 0x2000, 0x2271, 0x00C8,
0x2081, 0x809E, 0x0C8A, 0xE180, 0xB009, 0x8151, 0x1031, 0x4028,
0x2A0E, 0x89A5, 0x69B6, 0x620E, 0x4425, 0xD144, 0x8085, 0x4D54,
0x2C75, 0x1FB1, 0xD807, 0x862D, 0xD87C, 0x4841, 0x414E, 0x226E,
0x8200, 0x9E08, 0xF80C, 0xED37, 0x8C80, 0x7526, 0x9313, 0x0814,
0x0E32, 0xC804, 0x484E, 0x6EA6, 0x2C4A, 0x6670, 0x26C0, 0xBA01,
0xD30C, 0x185D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0540, 0x7020, 0x8133, 0x4F81, 0x03A5,
0x55EC, 0x6410, 0xC318, 0x2344, 0x1462, 0x0034, 0x0A43, 0x1A09,
0x187B, 0x13A5, 0x0102, 0xA848, 0x0440, 0xC544, 0x8106, 0xE2DD,
0x1AF0, 0x2D48, 0xB626, 0x0416, 0x5058, 0x6E40, 0x8032, 0x3112,
0x07E4, 0x0C00, 0x8208, 0x420A, 0x4840, 0x803B, 0x4860, 0x8713,
0x850D, 0x3428, 0x0319, 0xE529, 0x2345, 0x870A, 0x25A9, 0x5C18,
0x77A6, 0xD9C5, 0x5E00, 0x03E8, 0x0081, 0xA700, 0xCD54, 0x41C6,
0x2800, 0xA204, 0xB860, 0x2B0A, 0x0020, 0xDA9E, 0x08EA, 0x0E1A,
0x427C, 0x11C0, 0x8908, 0x0376, 0x8621, 0x0105, 0x0000, 0x18A8,
0x46A0, 0xC448, 0x0D05, 0x2022, 0x5422, 0x9148, 0x8A01, 0x2897,
0x7898, 0x0008, 0x1605, 0x3122, 0x4240, 0x0880, 0xFA4E, 0x06A2,
0x0814, 0x9211, 0x2002, 0x9B04, 0x2E52, 0x0643, 0x5000, 0x9010,
0x0041, 0x85BA, 0x3042, 0x2020, 0x4F0B, 0x05A0, 0x2708, 0x4080,
0x0591, 0x1A93, 0xDF50, 0x0600, 0xA202, 0x3021, 0x0630, 0x4E80,
0x0CC4, 0x04C8, 0xA004, 0x8001, 0x6000, 0xD431, 0x0880, 0x0A02,
0x1C00, 0x0028, 0x8E18, 0x0041, 0x6AD0, 0xCA10, 0xF210, 0x4B00,
0x274D, 0x1506, 0x0220, 0x8890, 0x5A00, 0x82A8, 0x4549, 0x8150,
0x2004, 0x8000, 0x8804, 0x2C08, 0x08D1, 0x0005, 0x8001, 0x4AC4,
0xE020, 0x0062, 0x008E, 0x0A42, 0x3055, 0x6A8C, 0x090E, 0xE0A5,
0x2906, 0x42C4, 0x4814, 0x80B3, 0x803E, 0xB330, 0x0102, 0x731C,
0x1494, 0x600D, 0x0C20, 0x0940, 0x301A, 0xC040, 0xA451, 0xC094,
0x8DCA, 0x05C8, 0x96C2, 0xA40C, 0x0001, 0x3404, 0x00C8, 0x0110,
0x550D, 0xA9C9, 0x2428, 0x1C5A, 0x0142, 0x4837, 0x7A4D, 0x100F,
0x32B4, 0x452A, 0x317B, 0x9205, 0xB894, 0x5C44, 0x68D7, 0x458A,
0x5097, 0x2ED1, 0x1943, 0x4208, 0xD202, 0x9D40, 0x9840, 0x2097,
0x5409, 0x064D, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x8480, 0x5542, 0x0421, 0x1C06, 0x1700,
0x7624, 0x6110, 0xFF87, 0xB9DD, 0x659F, 0x5C0A, 0x245D, 0x3C00,
0xADB0, 0x0059, 0x0000, 0x0000, 0x0000, 0x0000, 0x28D0, 0x009B,
0x0422, 0x0200, 0x0108, 0x4408, 0x9804, 0xAC40, 0x8D0A, 0x9028,
0x8700, 0xE001, 0x0400, 0x0031, 0x1794, 0x8221, 0x0019, 0x1054,
0x2CB2, 0x021A, 0x9C02, 0x4003, 0x3D60, 0x8804, 0x080C, 0x7900,
0x1628, 0xBA3C, 0x8640, 0xCB08, 0x7274, 0x9080, 0x001E, 0x0000,
0x0000, 0xD800, 0xE188, 0x9C87, 0x4034, 0x0412, 0xAE64, 0x2791,
0xE86B, 0xE6FB, 0x408F, 0x5366, 0xEEA6, 0x537F, 0xE32B, 0xB5E4,
0x869F, 0x0002, 0x8548, 0x0122, 0x4402, 0x0800, 0x2116, 0x20A0,
0x0004, 0x0204, 0x2000, 0x0005, 0x7E00, 0x0154, 0x162C, 0x01AC,
0x2A84, 0x1085, 0x8C14, 0x0530, 0xFBC3, 0xB943, 0x00CA, 0x9060,
0x6000, 0x4032, 0x1200, 0x8090, 0x0B30, 0x4C81, 0x0054, 0x4002,
0x0029, 0x1D6A, 0x2000, 0x0280, 0x8000, 0x0004, 0x2610, 0x150C,
0x8040, 0x0701, 0xD94D, 0x0C24, 0x2810, 0x1850, 0x5001, 0x5020,
0x1000, 0x04D0, 0x7080, 0x0201, 0x0108, 0x21C3, 0x0132, 0x0000,
0x0088, 0x0719, 0x0802, 0x0560, 0x0012, 0x4C0E, 0x0405, 0xF0A1,
0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080,
0x8E8D, 0x035A, 0x21BD, 0x5A04, 0x3488, 0x1170, 0x0026, 0x0000,
0x0000, 0x1000, 0xC502, 0x8804, 0xB815, 0xF801, 0x147C, 0x25ED,
0xED60, 0x1BB0, 0x0589, 0x1BD7, 0x7AF3, 0x1A62, 0x0D0C, 0x0AC5,
0xE5D1, 0x524A, 0x0490, 0x6305, 0x0354, 0x5244, 0x2B57, 0x1612,
0xA872, 0x1101, 0x2949, 0x0018, 0x0948, 0x1008, 0x6000, 0x886C,
0x916E, 0x058F, 0x3012, 0x3990, 0xF840, 0x4930, 0x8880, 0x001B,
0x0000, 0x0000, 0x8500, 0x0042, 0x0058, 0x9800, 0xEA04, 0x7014,
0x1628, 0x611D, 0x5113, 0x6000, 0x1A24, 0x00A7, 0x0000, 0x0000,
0x0000, 0x03C0, 0x7120, 0x1018, 0x0172, 0xA927, 0x6004, 0x8906,
0xC022, 0x020C, 0x0900, 0x4081, 0x202D, 0x8CA0, 0x0E34, 0x0000,
0x0000, 0x0000, 0x2100, 0x1101, 0x8011, 0xC11A, 0xEC4C, 0x0892,
0x0040, 0x8500, 0xC7AC, 0x1806, 0xE03E, 0x0512, 0x8000, 0x0010,
0x4008, 0x80CE, 0x6D01, 0x0210, 0x8641, 0x0856, 0x011E, 0x0027,
0x3750, 0x083D, 0xE032, 0x4E05, 0x01C0, 0x0484, 0x0081, 0x0140,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1AA0, 0x0059,
0x43C8, 0x8824, 0x1D48, 0xC800, 0x0152, 0x7203, 0x9013, 0x0404,
0x8280, 0x0400, 0x8A10, 0x0D14, 0x8056, 0x0208, 0xA040, 0x2704,
0x0000, 0x4C00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA320,
0x1902, 0xA0AE, 0x2660, 0xDF00, 0xF010, 0x7B15, 0x8121, 0x3AD0,
0x4180, 0x0028, 0x1003, 0x4800, 0xCC00, 0x8014, 0x14CF, 0x00C4,
0x2000, 0x3020, 0x0001,
};
/* Multibyte indexes for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_sjis_uro_mb_ind[1307] = {
434, 444, 453, 457, 465, 472, 480, 481,
484, 494, 504, 515, 519, 530, 539, 544,
549, 555, 560, 561, 568, 574, 585, 587,
594, 600, 605, 611, 614, 619, 628, 634,
640, 646, 653, 664, 666, 671, 676, 678,
684, 687, 691, 693, 699, 705, 710, 715,
718, 723, 730, 732, 738, 751, 756, 765,
771, 780, 788, 798, 807, 814, 818, 825,
834, 843, 847, 853, 861, 869, 873, 879,
887, 892, 897, 904, 910, 916, 924, 930,
938, 945, 952, 957, 964, 974, 983, 988,
997, 999, 1003, 1010, 1014, 1023, 1029, 1042,
1050, 1061, 1066, 1073, 1080, 1087, 1089, 1091,
1100, 1107, 1109, 1116, 1122, 1129, 1130, 1138,
1141, 1145, 1148, 1150, 1155, 1161, 1166, 1167,
1170, 1177, 1184, 1191, 1193, 1196, 1200, 1202,
1206, 1208, 1213, 1215, 1220, 1223, 1225, 1230,
1233, 1238, 1239, 1243, 1246, 1252, 1259, 1262,
1269, 1277, 1283, 1287, 1291, 1297, 1299, 1304,
1305, 1309, 1310, 1315, 1317, 1322, 1328, 1330,
1335, 1341, 1344, 1348, 1354, 1358, 1366, 1369,
1374, 1376, 1380, 1383, 1389, 1394, 1403, 1409,
1418, 1422, 1430, 1439, 1444, 1450, 1457, 1466,
1470, 1476, 1481, 1485, 1489, 1492, 1499, 1504,
1507, 1510, 1515, 1519, 1522, 1526, 1527, 1531,
1532, 1532, 1535, 1535, 1538, 1543, 1546, 1550,
1552, 1555, 1556, 1559, 1563, 1566, 1577, 1583,
1589, 1599, 1608, 1614, 1622, 1630, 1638, 1648,
1656, 1669, 1673, 1678, 1687, 1697, 1702, 1709,
1712, 1713, 1716, 1721, 1729, 1731, 1732, 1739,
1744, 1747, 1757, 1759, 1759, 1762, 1765, 1768,
1770, 1775, 1777, 1780, 1784, 1787, 1793, 1801,
1810, 1815, 1821, 1825, 1831, 1838, 1842, 1846,
1859, 1865, 1870, 1875, 1879, 1886, 1893, 1900,
1912, 1921, 1931, 1937, 1943, 1948, 1955, 1963,
1970, 1981, 1989, 1996, 2001, 2005, 2011, 2014,
2021, 2023, 2031, 2041, 2043, 2050, 2056, 2068,
2071, 2078, 2085, 2091, 2099, 2102, 2108, 2113,
2122, 2131, 2135, 2139, 2144, 2153, 2160, 2168,
2176, 2180, 2186, 2192, 2196, 2205, 2206, 2208,
2218, 2225, 2235, 2240, 2247, 2255, 2260, 2264,
2270, 2276, 2287, 2289, 2295, 2305, 2316, 2322,
2329, 2335, 2338, 2342, 2346, 2350, 2354, 2359,
2364, 2371, 2376, 2387, 2392, 2398, 2403, 2407,
2410, 2413, 2417, 2421, 2425, 2427, 2428, 2431,
2434, 2436, 2441, 2447, 2452, 2457, 2461, 2469,
2476, 2478, 2481, 2487, 2496, 2500, 2508, 2512,
2518, 2525, 2532, 2540, 2545, 2553, 2557, 2567,
2570, 2578, 2582, 2588, 2593, 2600, 2604, 2612,
2616, 2623, 2628, 2632, 2637, 2641, 2646, 2649,
2661, 2668, 2676, 2684, 2692, 2697, 2705, 2714,
2723, 2728, 2734, 2740, 2746, 2752, 2760, 2767,
2774, 2777, 2781, 2786, 2792, 2800, 2808, 2810,
2815, 2820, 2826, 2833, 2841, 2847, 2854, 2860,
2863, 2873, 2878, 2885, 2891, 2892, 2900, 2908,
2917, 2921, 2926, 2929, 2935, 2943, 2949, 2953,
2958, 2963, 2971, 2978, 2984, 2988, 2991, 2994,
2997, 3001, 3004, 3010, 3013, 3016, 3022, 3024,
3026, 3029, 3033, 3037, 3044, 3049, 3055, 3063,
3069, 3077, 3081, 3085, 3095, 3101, 3107, 3110,
3111, 3113, 3118, 3120, 3124, 3128, 3135, 3139,
3145, 3151, 3158, 3162, 3172, 3178, 3184, 3191,
3194, 3196, 3202, 3206, 3214, 3217, 3220, 3227,
3231, 3235, 3240, 3241, 3245, 3251, 3257, 3265,
3272, 3278, 3285, 3297, 3300, 3304, 3308, 3312,
3316, 3320, 3326, 3330, 3335, 3341, 3347, 3349,
3355, 3360, 3364, 3369, 3374, 3376, 3381, 3386,
3391, 3397, 3399, 3403, 3406, 3411, 3416, 3423,
3428, 3432, 3440, 3443, 3446, 3447, 3449, 3452,
3456, 3459, 3461, 3465, 3469, 3472, 3475, 3475,
3478, 3479, 3483, 3485, 3487, 3490, 3493, 3501,
3502, 3506, 3510, 3512, 3515, 3519, 3525, 3532,
3537, 3539, 3541, 3545, 3555, 3561, 3567, 3571,
3576, 3580, 3582, 3587, 3590, 3595, 3600, 3606,
3611, 3612, 3618, 3624, 3629, 3633, 3634, 3637,
3643, 3647, 3648, 3649, 3652, 3658, 3659, 3664,
3667, 3671, 3671, 3673, 3680, 3681, 3688, 3694,
3698, 3700, 3701, 3703, 3705, 3707, 3709, 3716,
3722, 3728, 3736, 3742, 3751, 3759, 3766, 3776,
3783, 3791, 3795, 3798, 3807, 3813, 3820, 3823,
3831, 3835, 3836, 3841, 3844, 3849, 3853, 3860,
3869, 3877, 3882, 3883, 3890, 3896, 3903, 3910,
3915, 3922, 3925, 3930, 3934, 3936, 3938, 3944,
3947, 3949, 3951, 3955, 3963, 3965, 3969, 3977,
3979, 3981, 3984, 3988, 3992, 3993, 3994, 3997,
4000, 4006, 4011, 4016, 4020, 4025, 4029, 4033,
4035, 4038, 4041, 4045, 4048, 4053, 4062, 4067,
4070, 4078, 4079, 4083, 4090, 4094, 4099, 4106,
4108, 4113, 4120, 4122, 4130, 4138, 4140, 4145,
4152, 4156, 4163, 4167, 4171, 4180, 4188, 4197,
4203, 4210, 4215, 4220, 4224, 4232, 4238, 4242,
4247, 4252, 4262, 4265, 4268, 4277, 4278, 4284,
4287, 4290, 4296, 4301, 4306, 4311, 4316, 4320,
4323, 4329, 4336, 4345, 4351, 4356, 4362, 4366,
4373, 4381, 4390, 4397, 4404, 4413, 4417, 4423,
4430, 4432, 4438, 4445, 4456, 4460, 4468, 4475,
4478, 4484, 4488, 4494, 4503, 4509, 4516, 4521,
4527, 4534, 4541, 4541, 4541, 4541, 4541, 4541,
4541, 4541, 4541, 4541, 4544, 4548, 4554, 4561,
4567, 4576, 4580, 4586, 4591, 4596, 4599, 4604,
4609, 4617, 4624, 4626, 4631, 4633, 4639, 4643,
4653, 4660, 4666, 4674, 4678, 4683, 4689, 4693,
4698, 4705, 4707, 4710, 4714, 4717, 4723, 4727,
4734, 4740, 4745, 4750, 4758, 4764, 4770, 4777,
4783, 4793, 4802, 4807, 4813, 4815, 4820, 4828,
4834, 4836, 4840, 4846, 4852, 4853, 4863, 4869,
4875, 4882, 4886, 4890, 4897, 4902, 4905, 4905,
4910, 4915, 4920, 4925, 4928, 4933, 4938, 4942,
4949, 4956, 4957, 4962, 4967, 4970, 4972, 4982,
4987, 4990, 4995, 4997, 5003, 5010, 5015, 5017,
5020, 5022, 5030, 5034, 5036, 5044, 5048, 5053,
5055, 5060, 5067, 5076, 5078, 5082, 5086, 5090,
5095, 5100, 5104, 5107, 5109, 5111, 5118, 5120,
5123, 5126, 5128, 5134, 5136, 5143, 5148, 5154,
5158, 5166, 5171, 5173, 5177, 5181, 5186, 5192,
5196, 5198, 5199, 5202, 5206, 5211, 5213, 5215,
5221, 5225, 5228, 5232, 5236, 5242, 5249, 5254,
5261, 5266, 5271, 5275, 5281, 5287, 5294, 5296,
5304, 5309, 5314, 5317, 5320, 5325, 5328, 5334,
5339, 5347, 5352, 5359, 5364, 5365, 5369, 5372,
5374, 5381, 5389, 5393, 5400, 5403, 5410, 5419,
5424, 5431, 5437, 5446, 5451, 5458, 5464, 5473,
5479, 5486, 5494, 5500, 5503, 5508, 5514, 5518,
5524, 5529, 5535, 5535, 5535, 5535, 5535, 5535,
5535, 5535, 5535, 5535, 5538, 5544, 5547, 5552,
5556, 5563, 5567, 5579, 5590, 5600, 5606, 5613,
5617, 5625, 5629, 5629, 5629, 5629, 5629, 5634,
5639, 5642, 5643, 5645, 5648, 5652, 5657, 5663,
5667, 5671, 5675, 5676, 5679, 5686, 5690, 5693,
5697, 5704, 5708, 5713, 5716, 5723, 5726, 5729,
5734, 5739, 5748, 5752, 5758, 5766, 5769, 5773,
5773, 5773, 5777, 5783, 5791, 5795, 5798, 5806,
5813, 5822, 5834, 5840, 5848, 5858, 5869, 5878,
5887, 5896, 5897, 5902, 5905, 5908, 5909, 5914,
5917, 5918, 5920, 5921, 5923, 5929, 5933, 5939,
5944, 5949, 5953, 5958, 5962, 5973, 5981, 5985,
5989, 5991, 5995, 5997, 6000, 6005, 6010, 6013,
6015, 6018, 6026, 6027, 6029, 6030, 6031, 6035,
6040, 6042, 6046, 6055, 6059, 6062, 6066, 6069,
6072, 6073, 6077, 6081, 6083, 6085, 6091, 6095,
6095, 6097, 6103, 6105, 6109, 6111, 6117, 6120,
6127, 6128, 6128, 6128, 6128, 6128, 6128, 6128,
6128, 6128, 6128, 6128, 6128, 6128, 6128, 6128,
6129, 6137, 6143, 6151, 6156, 6161, 6166, 6169,
6169, 6169, 6170, 6175, 6178, 6185, 6191, 6198,
6207, 6215, 6222, 6227, 6237, 6248, 6254, 6259,
6265, 6274, 6280, 6283, 6289, 6294, 6299, 6308,
6313, 6320, 6323, 6329, 6331, 6335, 6337, 6339,
6345, 6353, 6360, 6364, 6370, 6376, 6381, 6384,
6388, 6388, 6388, 6391, 6393, 6396, 6399, 6405,
6410, 6415, 6422, 6428, 6430, 6435, 6440, 6440,
6440, 6440, 6444, 6449, 6452, 6457, 6465, 6468,
6473, 6477, 6480, 6482, 6485, 6490, 6495, 6501,
6501, 6501, 6501, 6503, 6506, 6509, 6515, 6523,
6527, 6528, 6531, 6540, 6544, 6552, 6556, 6557,
6558, 6560, 6566, 6572, 6574, 6579, 6584, 6589,
6593, 6600, 6606, 6612, 6618, 6621, 6624, 6626,
6628, 6628, 6628, 6628, 6628, 6628, 6628, 6633,
6637, 6643, 6647, 6653, 6656, 6660, 6666, 6671,
6673, 6676, 6677, 6681, 6686, 6691, 6693, 6696,
6701, 6701, 6704, 6704, 6704, 6704, 6704, 6704,
6709, 6713, 6720, 6725, 6732, 6737, 6746, 6750,
6757, 6760, 6762, 6765, 6767, 6771, 6774, 6782,
6785, 6786, 6789,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_sjis_u_u[588] = {
0x005C, 0x00A2, 0x00A3, 0x00A5, 0x00A7, 0x00A8, 0x00AC, 0x00B0,
0x00B1, 0x00B4, 0x00B6, 0x00D7, 0x00F7, 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, 0x2010,
0x2015, 0x2016, 0x2018, 0x2019, 0x201C, 0x201D, 0x2020, 0x2021,
0x2025, 0x2026, 0x2030, 0x2032, 0x2033, 0x203B, 0x203E, 0x2103,
0x212B, 0x2190, 0x2191, 0x2192, 0x2193, 0x21D2, 0x21D4, 0x2200,
0x2202, 0x2203, 0x2207, 0x2208, 0x220B, 0x2212, 0x221A, 0x221D,
0x221E, 0x2220, 0x2227, 0x2228, 0x2229, 0x222A, 0x222B, 0x222C,
0x2234, 0x2235, 0x223D, 0x2252, 0x2260, 0x2261, 0x2266, 0x2267,
0x226A, 0x226B, 0x2282, 0x2283, 0x2286, 0x2287, 0x22A5, 0x2312,
0x2500, 0x2501, 0x2502, 0x2503, 0x250C, 0x250F, 0x2510, 0x2513,
0x2514, 0x2517, 0x2518, 0x251B, 0x251C, 0x251D, 0x2520, 0x2523,
0x2524, 0x2525, 0x2528, 0x252B, 0x252C, 0x252F, 0x2530, 0x2533,
0x2534, 0x2537, 0x2538, 0x253B, 0x253C, 0x253F, 0x2542, 0x254B,
0x25A0, 0x25A1, 0x25B2, 0x25B3, 0x25BC, 0x25BD, 0x25C6, 0x25C7,
0x25CB, 0x25CE, 0x25CF, 0x25EF, 0x2605, 0x2606, 0x2640, 0x2642,
0x266A, 0x266D, 0x266F, 0x3000, 0x3001, 0x3002, 0x3003, 0x3005,
0x3006, 0x3007, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3010, 0x3011, 0x3012, 0x3013, 0x3014, 0x3015,
0x301C, 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, 0x309B, 0x309C, 0x309D, 0x309E,
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, 0x30FB, 0x30FC,
0x30FD, 0x30FE, 0xFF01, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF08,
0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 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, 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, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65,
0xFF66, 0xFF67, 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D,
0xFF6E, 0xFF6F, 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75,
0xFF76, 0xFF77, 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D,
0xFF7E, 0xFF7F, 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85,
0xFF86, 0xFF87, 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D,
0xFF8E, 0xFF8F, 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95,
0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D,
0xFF9E, 0xFF9F, 0xFFE3, 0xFFE5,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_sjis_u_mb[6944] = {
0x815F, 0x8191, 0x8192, 0x005C, 0x8198, 0x814E, 0x81CA, 0x818B,
0x817D, 0x814C, 0x81F7, 0x817E, 0x8180, 0x839F, 0x83A0, 0x83A1,
0x83A2, 0x83A3, 0x83A4, 0x83A5, 0x83A6, 0x83A7, 0x83A8, 0x83A9,
0x83AA, 0x83AB, 0x83AC, 0x83AD, 0x83AE, 0x83AF, 0x83B0, 0x83B1,
0x83B2, 0x83B3, 0x83B4, 0x83B5, 0x83B6, 0x83BF, 0x83C0, 0x83C1,
0x83C2, 0x83C3, 0x83C4, 0x83C5, 0x83C6, 0x83C7, 0x83C8, 0x83C9,
0x83CA, 0x83CB, 0x83CC, 0x83CD, 0x83CE, 0x83CF, 0x83D0, 0x83D1,
0x83D2, 0x83D3, 0x83D4, 0x83D5, 0x83D6, 0x8446, 0x8440, 0x8441,
0x8442, 0x8443, 0x8444, 0x8445, 0x8447, 0x8448, 0x8449, 0x844A,
0x844B, 0x844C, 0x844D, 0x844E, 0x844F, 0x8450, 0x8451, 0x8452,
0x8453, 0x8454, 0x8455, 0x8456, 0x8457, 0x8458, 0x8459, 0x845A,
0x845B, 0x845C, 0x845D, 0x845E, 0x845F, 0x8460, 0x8470, 0x8471,
0x8472, 0x8473, 0x8474, 0x8475, 0x8477, 0x8478, 0x8479, 0x847A,
0x847B, 0x847C, 0x847D, 0x847E, 0x8480, 0x8481, 0x8482, 0x8483,
0x8484, 0x8485, 0x8486, 0x8487, 0x8488, 0x8489, 0x848A, 0x848B,
0x848C, 0x848D, 0x848E, 0x848F, 0x8490, 0x8491, 0x8476, 0x815D,
0x815C, 0x8161, 0x8165, 0x8166, 0x8167, 0x8168, 0x81F5, 0x81F6,
0x8164, 0x8163, 0x81F1, 0x818C, 0x818D, 0x81A6, 0x007E, 0x818E,
0x81F0, 0x81A9, 0x81AA, 0x81A8, 0x81AB, 0x81CB, 0x81CC, 0x81CD,
0x81DD, 0x81CE, 0x81DE, 0x81B8, 0x81B9, 0x817C, 0x81E3, 0x81E5,
0x8187, 0x81DA, 0x81C8, 0x81C9, 0x81BF, 0x81BE, 0x81E7, 0x81E8,
0x8188, 0x81E6, 0x81E4, 0x81E0, 0x8182, 0x81DF, 0x8185, 0x8186,
0x81E1, 0x81E2, 0x81BC, 0x81BD, 0x81BA, 0x81BB, 0x81DB, 0x81DC,
0x849F, 0x84AA, 0x84A0, 0x84AB, 0x84A1, 0x84AC, 0x84A2, 0x84AD,
0x84A4, 0x84AF, 0x84A3, 0x84AE, 0x84A5, 0x84BA, 0x84B5, 0x84B0,
0x84A7, 0x84BC, 0x84B7, 0x84B2, 0x84A6, 0x84B6, 0x84BB, 0x84B1,
0x84A8, 0x84B8, 0x84BD, 0x84B3, 0x84A9, 0x84B9, 0x84BE, 0x84B4,
0x81A1, 0x81A0, 0x81A3, 0x81A2, 0x81A5, 0x81A4, 0x819F, 0x819E,
0x819B, 0x819D, 0x819C, 0x81FC, 0x819A, 0x8199, 0x818A, 0x8189,
0x81F4, 0x81F3, 0x81F2, 0x8140, 0x8141, 0x8142, 0x8156, 0x8158,
0x8159, 0x815A, 0x8171, 0x8172, 0x8173, 0x8174, 0x8175, 0x8176,
0x8177, 0x8178, 0x8179, 0x817A, 0x81A7, 0x81AC, 0x816B, 0x816C,
0x8160, 0x829F, 0x82A0, 0x82A1, 0x82A2, 0x82A3, 0x82A4, 0x82A5,
0x82A6, 0x82A7, 0x82A8, 0x82A9, 0x82AA, 0x82AB, 0x82AC, 0x82AD,
0x82AE, 0x82AF, 0x82B0, 0x82B1, 0x82B2, 0x82B3, 0x82B4, 0x82B5,
0x82B6, 0x82B7, 0x82B8, 0x82B9, 0x82BA, 0x82BB, 0x82BC, 0x82BD,
0x82BE, 0x82BF, 0x82C0, 0x82C1, 0x82C2, 0x82C3, 0x82C4, 0x82C5,
0x82C6, 0x82C7, 0x82C8, 0x82C9, 0x82CA, 0x82CB, 0x82CC, 0x82CD,
0x82CE, 0x82CF, 0x82D0, 0x82D1, 0x82D2, 0x82D3, 0x82D4, 0x82D5,
0x82D6, 0x82D7, 0x82D8, 0x82D9, 0x82DA, 0x82DB, 0x82DC, 0x82DD,
0x82DE, 0x82DF, 0x82E0, 0x82E1, 0x82E2, 0x82E3, 0x82E4, 0x82E5,
0x82E6, 0x82E7, 0x82E8, 0x82E9, 0x82EA, 0x82EB, 0x82EC, 0x82ED,
0x82EE, 0x82EF, 0x82F0, 0x82F1, 0x814A, 0x814B, 0x8154, 0x8155,
0x8340, 0x8341, 0x8342, 0x8343, 0x8344, 0x8345, 0x8346, 0x8347,
0x8348, 0x8349, 0x834A, 0x834B, 0x834C, 0x834D, 0x834E, 0x834F,
0x8350, 0x8351, 0x8352, 0x8353, 0x8354, 0x8355, 0x8356, 0x8357,
0x8358, 0x8359, 0x835A, 0x835B, 0x835C, 0x835D, 0x835E, 0x835F,
0x8360, 0x8361, 0x8362, 0x8363, 0x8364, 0x8365, 0x8366, 0x8367,
0x8368, 0x8369, 0x836A, 0x836B, 0x836C, 0x836D, 0x836E, 0x836F,
0x8370, 0x8371, 0x8372, 0x8373, 0x8374, 0x8375, 0x8376, 0x8377,
0x8378, 0x8379, 0x837A, 0x837B, 0x837C, 0x837D, 0x837E, 0x8380,
0x8381, 0x8382, 0x8383, 0x8384, 0x8385, 0x8386, 0x8387, 0x8388,
0x8389, 0x838A, 0x838B, 0x838C, 0x838D, 0x838E, 0x838F, 0x8390,
0x8391, 0x8392, 0x8393, 0x8394, 0x8395, 0x8396, 0x8145, 0x815B,
0x8152, 0x8153, 0x88EA, 0x929A, 0x8EB5, 0x969C, 0x8FE4, 0x8E4F,
0x8FE3, 0x89BA, 0x9573, 0x975E, 0x98A0, 0x894E, 0x8A8E, 0x98A1,
0x90A2, 0x99C0, 0x8B75, 0x95B8, 0x8FE5, 0x97BC, 0x95C0, 0x98A2,
0x9286, 0x98A3, 0x8BF8, 0x98A4, 0x8ADB, 0x924F, 0x8EE5, 0x98A5,
0x98A6, 0x98A7, 0x9454, 0x8B76, 0x9456, 0x93E1, 0x8CC1, 0x9652,
0xE568, 0x98A8, 0x8FE6, 0x98A9, 0x89B3, 0x8BE3, 0x8CEE, 0x96E7,
0x9BA4, 0x9790, 0x93FB, 0x8AA3, 0x8B54, 0x98AA, 0x98AB, 0x97B9,
0x975C, 0x9188, 0x98AD, 0x8E96, 0x93F1, 0x98B0, 0x895D, 0x8CDD,
0x8CDC, 0x88E4, 0x986A, 0x9869, 0x8DB1, 0x889F, 0x98B1, 0x98B2,
0x98B3, 0x9653, 0x98B4, 0x8CF0, 0x88E5, 0x9692, 0x8B9C, 0x8B9D,
0x8B9E, 0x92E0, 0x97BA, 0x98B5, 0x98B6, 0x98B7, 0x906C, 0x8F59,
0x906D, 0x98BC, 0x98BA, 0x98BB, 0x8B77, 0x8DA1, 0x89EE, 0x98B9,
0x98B8, 0x95A7, 0x8E65, 0x8E64, 0x91BC, 0x98BD, 0x9574, 0x90E5,
0x8157, 0x98BE, 0x98C0, 0x91E3, 0x97DF, 0x88C8, 0x98BF, 0x89BC,
0x8BC2, 0x9287, 0x8C8F, 0x98C1, 0x9443, 0x8AE9, 0x98C2, 0x88C9,
0x8CDE, 0x8AEA, 0x959A, 0x94B0, 0x8B78, 0x89EF, 0x98E5, 0x9360,
0x948C, 0x98C4, 0x94BA, 0x97E0, 0x904C, 0x8E66, 0x8E97, 0x89BE,
0x92CF, 0x9241, 0x98C8, 0x88CA, 0x92E1, 0x8F5A, 0x8DB2, 0x9743,
0x91CC, 0x89BD, 0x98C7, 0x975D, 0x98C3, 0x98C5, 0x8DEC, 0x98C6,
0x9B43, 0x98CE, 0x98D1, 0x98CF, 0x89C0, 0x95B9, 0x98C9, 0x98CD,
0x8CF1, 0x8E67, 0x8AA4, 0x98D2, 0x98CA, 0x97E1, 0x8E98, 0x98CB,
0x98D0, 0x98D3, 0x98CC, 0x8B9F, 0x88CB, 0x8BA0, 0x89BF, 0x9B44,
0x9699, 0x958E, 0x8CF2, 0x904E, 0x97B5, 0x95D6, 0x8C57, 0x91A3,
0x89E2, 0x8F72, 0x98D7, 0x98DC, 0x98DA, 0x98D5, 0x91AD, 0x98D8,
0x98DB, 0x98D9, 0x95DB, 0x98D6, 0x904D, 0x9693, 0x98DD, 0x98DE,
0x8F43, 0x98EB, 0x946F, 0x9555, 0x98E6, 0x95EE, 0x89B4, 0x98EA,
0x98E4, 0x98ED, 0x9171, 0x8CC2, 0x947B, 0xE0C5, 0x98EC, 0x937C,
0x98E1, 0x8CF4, 0x8CF3, 0x98DF, 0x8ED8, 0x98E7, 0x95ED, 0x926C,
0x98E3, 0x8C91, 0x98E0, 0x98E8, 0x98E2, 0x97CF, 0x98E9, 0x9860,
0x8BE4, 0x8C90, 0x98EE, 0x98EF, 0x98F3, 0x88CC, 0x95CE, 0x98F2,
0x98F1, 0x98F5, 0x98F4, 0x92E2, 0x8C92, 0x98F6, 0x8EC3, 0x91A4,
0x92E3, 0x8BF4, 0x98F7, 0x8B55, 0x98F8, 0x98FA, 0x9654, 0x8C86,
0x8E50, 0x94F5, 0x98F9, 0x8DC3, 0x9762, 0x98FC, 0x9942, 0x98FB,
0x8DC2, 0x8F9D, 0x8C58, 0x9943, 0x8BCD, 0x9940, 0x9941, 0x93AD,
0x919C, 0x8BA1, 0x966C, 0x9944, 0x97BB, 0x9945, 0x9948, 0x9946,
0x916D, 0x9947, 0x9949, 0x994B, 0x994A, 0x95C6, 0x8B56, 0x994D,
0x994E, 0x89AD, 0x994C, 0x8EF2, 0x9951, 0x9950, 0x994F, 0x98D4,
0x9952, 0x8F9E, 0x9953, 0x9744, 0x96D7, 0x9955, 0x9954, 0x9957,
0x9956, 0x9958, 0x9959, 0x88F2, 0x8CB3, 0x8C5A, 0x8F5B, 0x929B,
0x8BA2, 0x90E6, 0x8CF5, 0x8D8E, 0x995B, 0x96C6, 0x9365, 0x8E99,
0x995A, 0x995C, 0x937D, 0x8A95, 0x995D, 0x93FC, 0x9153, 0x995F,
0x9960, 0x94AA, 0x8CF6, 0x985A, 0x9961, 0x8BA4, 0x95BA, 0x91B4,
0x8BEF, 0x9354, 0x8C93, 0x9962, 0x9963, 0x93E0, 0x897E, 0x9966,
0x8DFB, 0x9965, 0x8DC4, 0x9967, 0xE3EC, 0x9968, 0x9660, 0x9969,
0x996A, 0x996B, 0x8FE7, 0x8ECA, 0x8AA5, 0x996E, 0x996C, 0x96BB,
0x996D, 0x9579, 0x996F, 0x9970, 0x9971, 0x937E, 0x9975, 0x9973,
0x9974, 0x9972, 0x8DE1, 0x9976, 0x96E8, 0x97E2, 0x9977, 0x90A6,
0x9978, 0x8F79, 0x9979, 0x929C, 0x97BD, 0x9380, 0x99C3, 0x997A,
0xEAA3, 0x8BC3, 0x997B, 0x967D, 0x8F88, 0x91FA, 0x997D, 0x93E2,
0x997E, 0x9980, 0x8A4D, 0x9981, 0x8BA5, 0x93CA, 0x899A, 0x8F6F,
0x949F, 0x9982, 0x9381, 0x906E, 0x9983, 0x95AA, 0x90D8, 0x8AA0,
0x8AA7, 0x9984, 0x9986, 0x8C59, 0x9985, 0x97F1, 0x8F89, 0x94BB,
0x95CA, 0x9987, 0x9798, 0x9988, 0x9989, 0x939E, 0x998A, 0x90A7,
0x8DFC, 0x8C94, 0x998B, 0x8E68, 0x8D8F, 0x92E4, 0x998D, 0x91A5,
0x8DED, 0x998E, 0x998F, 0x914F, 0x998C, 0x9991, 0x9655, 0x8D84,
0x9990, 0x8C95, 0x8DDC, 0x948D, 0x9994, 0x9992, 0x959B, 0x8FE8,
0x999B, 0x8A84, 0x9995, 0x9993, 0x916E, 0x9997, 0x9996, 0x8A63,
0x8C80, 0x999C, 0x97AB, 0x9998, 0x999D, 0x999A, 0x9999, 0x97CD,
0x8CF7, 0x89C1, 0x97F2, 0x8F95, 0x9377, 0x8D85, 0x99A0, 0x99A1,
0x97E3, 0x984A, 0x99A3, 0x8CF8, 0x99A2, 0x8A4E, 0x99A4, 0x9675,
0x92BA, 0x9745, 0x95D7, 0x99A5, 0xE8D3, 0x93AE, 0x99A6, 0x8AA8,
0x96B1, 0x8F9F, 0x99A7, 0x95E5, 0x99AB, 0x90A8, 0x99A8, 0x8BCE,
0x99A9, 0x8AA9, 0x8C4D, 0x99AC, 0x99AD, 0x99AE, 0x99AF, 0x8ED9,
0x8CF9, 0x96DC, 0x96E6, 0x93F5, 0x95EF, 0x99B0, 0x99B1, 0x99B3,
0x99B5, 0x99B4, 0x99B6, 0x89BB, 0x966B, 0x8DFA, 0x99B7, 0x9178,
0x8FA0, 0x8BA7, 0x99B8, 0x94D9, 0x99B9, 0x99BA, 0x99BB, 0x99BC,
0x9543, 0x8BE6, 0x88E3, 0x93BD, 0x99BD, 0x8F5C, 0x90E7, 0x99BF,
0x99BE, 0x8FA1, 0x8CDF, 0x99C1, 0x94BC, 0x99C2, 0x94DA, 0x91B2,
0x91EC, 0x8BA6, 0x93EC, 0x9250, 0x948E, 0x966D, 0x99C4, 0x90E8,
0x8C54, 0x99C5, 0x99C6, 0x894B, 0x88F3, 0x8AEB, 0x91A6, 0x8B70,
0x9791, 0x99C9, 0x89B5, 0x99C8, 0x8BA8, 0x99CA, 0x96EF, 0x99CB,
0x97D0, 0x8CFA, 0x8CB4, 0x99CC, 0x99CE, 0x99CD, 0x907E, 0x8958,
0x897D, 0x99CF, 0x99D0, 0x8CB5, 0x99D1, 0x8B8E, 0x8E51, 0x99D2,
0x9694, 0x8DB3, 0x8B79, 0x9746, 0x916F, 0x94BD, 0x8EFB, 0x8F66,
0x8EE6, 0x8EF3, 0x8F96, 0x94BE, 0x99D5, 0x8962, 0x9170, 0x8CFB,
0x8CC3, 0x8BE5, 0x99D9, 0x9240, 0x91FC, 0x8BA9, 0x8FA2, 0x99DA,
0x99D8, 0x89C2, 0x91E4, 0x8EB6, 0x8E6A, 0x8945, 0x8A90, 0x8D86,
0x8E69, 0x99DB, 0x99DC, 0x8B68, 0x8A65, 0x8D87, 0x8B67, 0x92DD,
0x8944, 0x93AF, 0x96BC, 0x8D40, 0x9799, 0x9366, 0x8CFC, 0x8C4E,
0x99E5, 0x8BE1, 0x9669, 0x94DB, 0x99E4, 0x8ADC, 0x99DF, 0x99E0,
0x99E2, 0x99E3, 0x8B7A, 0x9081, 0x95AB, 0x99E1, 0x99DD, 0x8CE1,
0x99DE, 0x9843, 0x95F0, 0x92E6, 0x8CE0, 0x8D90, 0x99E6, 0x93DB,
0x99EA, 0x8EFC, 0x8EF4, 0x99ED, 0x99EB, 0x96A1, 0x99E8, 0x99F1,
0x99EC, 0x99EF, 0x8CC4, 0x96BD, 0x99F0, 0x99F2, 0x99F4, 0x8DEE,
0x9861, 0x99E9, 0x99E7, 0x99F3, 0x99EE, 0x99F6, 0x9A42, 0x99F8,
0x99FC, 0x9A40, 0x99F9, 0x9A5D, 0x8DE7, 0x8A50, 0x99F7, 0x9A44,
0x88F4, 0x9A43, 0x88A3, 0x9569, 0x9A41, 0x99FA, 0x99F5, 0x99FB,
0x8DC6, 0x9A45, 0x88F5, 0x9A4E, 0x9A46, 0x9A47, 0x8FA3, 0x9689,
0x9A4C, 0x9A4B, 0x934E, 0x9A4D, 0x9A4A, 0x8953, 0x8DB4, 0x904F,
0x9A48, 0x9382, 0x9A49, 0x88A0, 0x9A53, 0x9742, 0x8FA5, 0x9A59,
0x9A58, 0x9A4F, 0x91C1, 0x9A50, 0x91ED, 0x9A55, 0x8FA4, 0x9A52,
0x96E2, 0x8C5B, 0x9A56, 0x9A57, 0x9A54, 0x9A5A, 0x9A51, 0x9A60,
0x9A65, 0x9A61, 0x9A5C, 0x9A66, 0x9150, 0x9A68, 0x8D41, 0x9A5E,
0x929D, 0x9A62, 0x9A5B, 0x8AAB, 0x8AEC, 0x8A85, 0x9A63, 0x9A5F,
0x8C96, 0x9A69, 0x9A67, 0x9172, 0x8B69, 0x8BAA, 0x9A64, 0x8BF2,
0x8963, 0x9A6D, 0x9A6B, 0x9AA5, 0x9A70, 0x9A6A, 0x9A6E, 0x9A6C,
0x8E6B, 0x9A6F, 0x9A72, 0x9A77, 0x9A75, 0x9A74, 0x9251, 0x89C3,
0x9A71, 0x9A73, 0x8FA6, 0x8952, 0x9A76, 0x89DC, 0x9A82, 0x8FFA,
0x9A7D, 0x9A7B, 0x9A7C, 0x9A7E, 0x895C, 0x9158, 0x9A78, 0x9A79,
0x8A9A, 0x9A81, 0x8AED, 0x9A84, 0x9A80, 0x9A83, 0x95AC, 0x93D3,
0x94B6, 0x9A86, 0x9A85, 0x8A64, 0x9A87, 0x9A8A, 0x9A89, 0x9A88,
0x9458, 0x9A8B, 0x9A8C, 0x9A8E, 0x9A8D, 0x9A90, 0x9A93, 0x9A91,
0x9A8F, 0x9A92, 0x9A94, 0x9A95, 0x9A96, 0x9A97, 0x9A98, 0x9964,
0x8EFA, 0x8E6C, 0x89F1, 0x88F6, 0x9263, 0x9A99, 0x8DA2, 0x88CD,
0x907D, 0x9A9A, 0x8CC5, 0x8D91, 0x9A9C, 0x9A9B, 0x95DE, 0x9A9D,
0x9A9F, 0x9A9E, 0x9AA0, 0x9AA1, 0x8C97, 0x8980, 0x9AA2, 0x9AA4,
0x9AA3, 0x9AA6, 0x9379, 0x9AA7, 0x88B3, 0x8DDD, 0x8C5C, 0x926E,
0x9AA8, 0x9AA9, 0x9AAB, 0x9AAC, 0x8DE2, 0x8BCF, 0x9656, 0x9AAA,
0x9AAD, 0x8DBF, 0x8D42, 0x9AB1, 0x8DA3, 0x9252, 0x9AAE, 0x92D8,
0x9AB2, 0x9082, 0x9AB0, 0x9AB3, 0x8C5E, 0x9AB4, 0x9AB5, 0x8D43,
0x8A5F, 0x9AB7, 0x9AB8, 0x9AB9, 0x9AB6, 0x9AAF, 0x9ABA, 0x9ABB,
0x9684, 0x8FE9, 0x9ABD, 0x9ABE, 0x9ABC, 0x9AC0, 0x9457, 0x88E6,
0x9575, 0x9AC1, 0x8FFB, 0x8EB7, 0x947C, 0x8AEE, 0x8DE9, 0x9678,
0x93B0, 0x8C98, 0x91CD, 0x9ABF, 0x9AC2, 0x91C2, 0x9AC3, 0x9AC4,
0x9AC6, 0x92E7, 0x8AAC, 0xEA9F, 0x8981, 0x95F1, 0x8FEA, 0x9367,
0x8DE4, 0x9ACC, 0x95BB, 0x97DB, 0x89F2, 0x9AC8, 0x9159, 0x9ACB,
0x9383, 0x9368, 0x9384, 0x94B7, 0x92CB, 0x8DC7, 0x9AC7, 0x8996,
0x9355, 0x9AC9, 0x9AC5, 0x906F, 0x9ACD, 0x8F6D, 0x8BAB, 0x9ACE,
0x95E6, 0x919D, 0x92C4, 0x9AD0, 0x966E, 0x9AD1, 0x9AD6, 0x95AD,
0x9AD5, 0x9ACF, 0x9AD2, 0x9AD4, 0x8DA4, 0x95C7, 0x9AD7, 0x9264,
0x89F3, 0x8FEB, 0x9AD9, 0x9AD8, 0x8D88, 0x9ADA, 0x9ADC, 0x9ADB,
0x9ADE, 0x9AD3, 0x9AE0, 0x9ADF, 0x9ADD, 0x8E6D, 0x9070, 0x9173,
0x9AE1, 0x90BA, 0x88EB, 0x9484, 0x92D9, 0x9AE3, 0x9AE2, 0x9AE4,
0x9AE5, 0x9AE6, 0x9AE7, 0x95CF, 0x9AE8, 0x89C4, 0x9AE9, 0x975B,
0x8A4F, 0x99C7, 0x8F67, 0x91BD, 0x9AEA, 0x96E9, 0x96B2, 0x9AEC,
0x91E5, 0x9356, 0x91BE, 0x9576, 0x9AED, 0x9AEE, 0x899B, 0x8EB8,
0x9AEF, 0x88CE, 0x9AF0, 0x9AF1, 0x8982, 0x8AEF, 0x93DE, 0x95F2,
0x9AF5, 0x9174, 0x9AF4, 0x8C5F, 0x967A, 0x9AF3, 0x9385, 0x9AF7,
0x9AF6, 0x9AF9, 0x9AF8, 0x899C, 0x9AFA, 0x8FA7, 0x9AFC, 0x9244,
0x9AFB, 0x95B1, 0x8F97, 0x937A, 0x9B40, 0x8D44, 0x9B41, 0x9440,
0x94DC, 0x96CF, 0x9444, 0x9B4A, 0x8B57, 0x9764, 0x96AD, 0x9BAA,
0x9B42, 0x9B45, 0x91C3, 0x9657, 0x9369, 0x9B46, 0x9685, 0x8DC8,
0x8FA8, 0x9B47, 0x8E6F, 0x8E6E, 0x88B7, 0x8CC6, 0x90A9, 0x88CF,
0x9B4B, 0x9B4C, 0x9B49, 0x8957, 0x8AAD, 0x9B48, 0x96C3, 0x9550,
0x88A6, 0x88F7, 0x8E70, 0x88D0, 0x88A1, 0x9B51, 0x9B4F, 0x96BA,
0x9B52, 0x9B50, 0x9B4E, 0x9050, 0x9B4D, 0x95D8, 0x8CE2, 0x9B56,
0x9B57, 0x8FA9, 0x9B53, 0x984B, 0x946B, 0x9B55, 0x8DA5, 0x9B58,
0x9577, 0x9B59, 0x9B54, 0x96B9, 0x947D, 0x9B5A, 0x9551, 0x9B5B,
0x9B5F, 0x9B5C, 0x89C5, 0x9B5E, 0x8EB9, 0x9B5D, 0x8C99, 0x9B6B,
0x9B64, 0x9B61, 0x9284, 0x9B60, 0x9B62, 0x9B63, 0x9B65, 0x9B66,
0x8AF0, 0x9B68, 0x9B67, 0x9B69, 0x8FEC, 0x9B6C, 0x92DA, 0x8964,
0x9B6A, 0x9B6D, 0x9B6E, 0x9B71, 0x9B6F, 0x9B70, 0x8E71, 0x9B72,
0x8D45, 0x9B73, 0x8E9A, 0x91B6, 0x9B74, 0x9B75, 0x8E79, 0x8D46,
0x96D0, 0x8B47, 0x8CC7, 0x9B76, 0x8A77, 0x9B77, 0x91B7, 0x9B78,
0x9BA1, 0x9B79, 0x9B7A, 0x9B7B, 0x9B7D, 0x9B7E, 0x9B80, 0x91EE,
0x8946, 0x8EE7, 0x88C0, 0x9176, 0x8AAE, 0x8EB3, 0x8D47, 0x9386,
0x8F40, 0x8AAF, 0x9288, 0x92E8, 0x88B6, 0x8B58, 0x95F3, 0x8EC0,
0x8B71, 0x90E9, 0x8EBA, 0x9747, 0x9B81, 0x8B7B, 0x8DC9, 0x8A51,
0x8983, 0x8FAA, 0x89C6, 0x9B82, 0x9765, 0x8F68, 0x8EE2, 0x9B83,
0x8AF1, 0x93D0, 0x96A7, 0x9B84, 0x9B85, 0x9578, 0x9B87, 0x8AA6,
0x8BF5, 0x9B86, 0x8AB0, 0x9051, 0x9B8B, 0x8E40, 0x89C7, 0x9B8A,
0x9B88, 0x9B8C, 0x9B89, 0x944A, 0x9ECB, 0x9052, 0x9B8D, 0x97BE,
0x9B8E, 0x9B90, 0x929E, 0x9B8F, 0x90A1, 0x8E9B, 0x91CE, 0x8EF5,
0x9595, 0x90EA, 0x8ECB, 0x9B91, 0x8FAB, 0x9B92, 0x9B93, 0x88D1,
0x91B8, 0x9071, 0x9B94, 0x93B1, 0x8FAC, 0x8FAD, 0x9B95, 0x90EB,
0x8FAE, 0x9B96, 0x9B97, 0x96DE, 0x9B98, 0x8BC4, 0x8F41, 0x9B99,
0x9B9A, 0x8EDA, 0x904B, 0x93F2, 0x9073, 0x94F6, 0x9441, 0x8BC7,
0x9B9B, 0x8B8F, 0x9B9C, 0x8BFC, 0x93CD, 0x89AE, 0x8E72, 0x9B9D,
0x9BA0, 0x9B9F, 0x8BFB, 0x9B9E, 0x9357, 0x91AE, 0x936A, 0x8EC6,
0x9177, 0x979A, 0x9BA2, 0x9BA3, 0x93D4, 0x8E52, 0x9BA5, 0x9BA6,
0x9BA7, 0x8AF2, 0x9BA8, 0x9BA9, 0x89AA, 0x915A, 0x8AE2, 0x9BAB,
0x96A6, 0x91D0, 0x8A78, 0x9BAD, 0x9BAF, 0x8ADD, 0x9BAC, 0x9BAE,
0x9BB1, 0x9BB0, 0x9BB2, 0x9BB3, 0x93BB, 0x8BAC, 0x89E3, 0x9BB4,
0x9BB9, 0x9BB7, 0x95F5, 0x95F4, 0x9387, 0x9BB6, 0x8F73, 0x9BB5,
0x9092, 0x9BBA, 0x8DE8, 0x9BC0, 0x9BC1, 0x9BBB, 0x8A52, 0x9BBC,
0x9BC5, 0x9BC4, 0x9BC3, 0x9BBF, 0x9BBE, 0x9BC2, 0x95F6, 0x9BC9,
0x9BC6, 0x9BC8, 0x9792, 0x9BC7, 0x9BBD, 0x9093, 0x9BCA, 0x8DB5,
0x9BCB, 0x9BCC, 0x9BCF, 0x9BCE, 0x9BCD, 0x9388, 0x9BB8, 0x9BD5,
0x9BD1, 0x9BD0, 0x9BD2, 0x9BD3, 0x9BD6, 0x97E4, 0x9BD7, 0x9BD4,
0x9BD8, 0x8ADE, 0x9BD9, 0x9BDB, 0x9BDA, 0x9BDC, 0x9BDD, 0x90EC,
0x8F42, 0x8F84, 0x9183, 0x8D48, 0x8DB6, 0x8D49, 0x8B90, 0x9BDE,
0x8DB7, 0x8CC8, 0x9BDF, 0x96A4, 0x9462, 0x9BE0, 0x8D4A, 0x8AAA,
0x9246, 0x8BD0, 0x8E73, 0x957A, 0x94BF, 0x9BE1, 0x8AF3, 0x9BE4,
0x929F, 0x9BE3, 0x9BE2, 0x9BE5, 0x92E9, 0x9083, 0x8E74, 0x90C8,
0x91D1, 0x8B41, 0x92A0, 0x9BE6, 0x9BE7, 0x8FED, 0x9658, 0x9BEA,
0x9BE9, 0x9BE8, 0x959D, 0x9BF1, 0x9679, 0x9BEB, 0x9BED, 0x968B,
0x9BEC, 0x9BEE, 0x94A6, 0x9BEF, 0x95BC, 0x9BF0, 0x8AB1, 0x95BD,
0x944E, 0x9BF2, 0x9BF3, 0x8D4B, 0x8AB2, 0x9BF4, 0x8CB6, 0x9763,
0x9748, 0x8AF4, 0x9BF6, 0x92A1, 0x8D4C, 0x8FAF, 0x94DD, 0x8FB0,
0x8F98, 0x92EA, 0x95F7, 0x9358, 0x8D4D, 0x957B, 0x9BF7, 0x9378,
0x8DC0, 0x8CC9, 0x92EB, 0x88C1, 0x8F8E, 0x8D4E, 0x9766, 0x9BF8,
0x9BF9, 0x9470, 0x9BFA, 0x97F5, 0x984C, 0x9BFC, 0x9BFB, 0x8A66,
0x9C40, 0x9C43, 0x9C44, 0x9C42, 0x955F, 0x8FB1, 0x9C46, 0x9C45,
0x9C41, 0x9C47, 0x9C48, 0x9C49, 0x9C4C, 0x9C4A, 0x9C4B, 0x9C4D,
0x8984, 0x92EC, 0x9C4E, 0x8C9A, 0x89F4, 0x9455, 0x9C4F, 0x93F9,
0x95D9, 0x9C50, 0x984D, 0x9C51, 0x95BE, 0x9C54, 0x989F, 0x98AF,
0x8EAE, 0x93F3, 0x9C55, 0x8B7C, 0x92A2, 0x88F8, 0x9C56, 0x95A4,
0x8D4F, 0x926F, 0x92ED, 0x96ED, 0x8CB7, 0x8CCA, 0x9C57, 0x9C58,
0x9C5E, 0x8EE3, 0x92A3, 0x8BAD, 0x9C59, 0x954A, 0x9265, 0x9C5A,
0x9C5B, 0x8BAE, 0x9C5C, 0x9C5D, 0x9C5F, 0x9396, 0x9C60, 0x9C61,
0x9C62, 0x9C53, 0x9C52, 0x9C63, 0x8C60, 0x9546, 0x8DCA, 0x9556,
0x92A4, 0x956A, 0x9C64, 0x8FB2, 0x8965, 0x9C65, 0x9C66, 0x96F0,
0x94DE, 0x9C69, 0x899D, 0x90AA, 0x9C68, 0x9C67, 0x8C61, 0x91D2,
0x9C6D, 0x9C6B, 0x9C6A, 0x97A5, 0x8CE3, 0x8F99, 0x9C6C, 0x936B,
0x8F5D, 0x93BE, 0x9C70, 0x9C6F, 0x9C6E, 0x9C71, 0x8CE4, 0x9C72,
0x959C, 0x8F7A, 0x9C73, 0x94F7, 0x93BF, 0x92A5, 0x934F, 0x9C74,
0x8B4A, 0x9053, 0x954B, 0x8AF5, 0x9445, 0x9C75, 0x8E75, 0x9659,
0x965A, 0x899E, 0x9C7A, 0x9289, 0x9C77, 0x89F5, 0x9CAB, 0x9C79,
0x944F, 0x9C78, 0x9C76, 0x8D9A, 0x9C7C, 0x9C83, 0x9C89, 0x9C81,
0x937B, 0x9C86, 0x957C, 0x9C80, 0x9C85, 0x97E5, 0x8E76, 0x91D3,
0x9C7D, 0x8B7D, 0x9C88, 0x90AB, 0x8985, 0x9C82, 0x89F6, 0x9C87,
0x8BAF, 0x9C84, 0x9C8A, 0x9C8C, 0x9C96, 0x9C94, 0x9C91, 0x9C90,
0x97F6, 0x9C92, 0x8BB0, 0x8D50, 0x8F9A, 0x9C99, 0x9C8B, 0x9C8F,
0x9C7E, 0x89F8, 0x9C93, 0x9C95, 0x9270, 0x8DA6, 0x89B6, 0x9C8D,
0x9C98, 0x9C97, 0x8BB1, 0x91A7, 0x8A86, 0x8C62, 0x9C8E, 0x9C9A,
0x9C9D, 0x9C9F, 0x8EBB, 0x9CA5, 0x92EE, 0x9C9B, 0x9CA3, 0x89F7,
0x9CA1, 0x9CA2, 0x9C9E, 0x9CA0, 0x8CE5, 0x9749, 0x8AB3, 0x8978,
0x9CA4, 0x9459, 0x88AB, 0x94DF, 0x9C7B, 0x9CAA, 0x9CAE, 0x96E3,
0x9CA7, 0x9389, 0x9CAC, 0x8FEE, 0x9CAD, 0x93D5, 0x9866, 0x9CA9,
0x9CAF, 0x8D9B, 0x90C9, 0x88D2, 0x9CA8, 0x9CA6, 0x9179, 0x9C9C,
0x8E53, 0x91C4, 0x9CBB, 0x917A, 0x9CB6, 0x9CB3, 0x9CB4, 0x8EE4,
0x9CB7, 0x9CBA, 0x9CB5, 0x8F44, 0x9CB8, 0x9CB2, 0x96FA, 0x96F9,
0x9CBC, 0x9CBD, 0x88D3, 0x9CB1, 0x8BF0, 0x88A4, 0x8AB4, 0x9CB9,
0x9CC1, 0x9CC0, 0x9CC5, 0x9CC6, 0x9CC4, 0x9CC7, 0x9CBF, 0x9CC3,
0x9CC8, 0x9CC9, 0x9CBE, 0x8E9C, 0x9CC2, 0x91D4, 0x8D51, 0x9CB0,
0x9054, 0x9CD6, 0x95E7, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CD5, 0x9CD4,
0x969D, 0x8AB5, 0x9CD2, 0x8C64, 0x8A53, 0x9CCF, 0x97B6, 0x9CD1,
0x88D4, 0x9CD3, 0x9CCA, 0x9CD0, 0x9CD7, 0x8C63, 0x9CCB, 0x977C,
0x974A, 0x9CDA, 0x9CDE, 0x919E, 0x97F7, 0x9CDF, 0x9CDC, 0x9CD9,
0x9CD8, 0x9CDD, 0x95AE, 0x93B2, 0x8C65, 0x9CE0, 0x9CDB, 0x9CE1,
0x8C9B, 0x89AF, 0x9CE9, 0x8AB6, 0x9CE7, 0x9CE8, 0x8DA7, 0x9CE6,
0x9CE4, 0x9CE3, 0x9CEA, 0x9CE2, 0x9CEC, 0x89F9, 0x9CEE, 0x9CED,
0x92A6, 0x9CF1, 0x9CEF, 0x9CE5, 0x8C9C, 0x9CF0, 0x9CF4, 0x9CF3,
0x9CF5, 0x9CF2, 0x9CF6, 0x9CF7, 0x9CF8, 0x95E8, 0x9CFA, 0x9CF9,
0x8F5E, 0x90AC, 0x89E4, 0x89FA, 0x9CFB, 0x88BD, 0x90CA, 0x9CFC,
0xE6C1, 0x9D40, 0x8C81, 0x9D41, 0x90ED, 0x9D42, 0x9D43, 0x8B59,
0x9D44, 0x9D45, 0x9D46, 0x91D5, 0x8CCB, 0x96DF, 0x965B, 0x8F8A,
0x9D47, 0x90EE, 0xE7BB, 0x94E0, 0x8EE8, 0x8DCB, 0x9D48, 0x91C5,
0x95A5, 0x91EF, 0x9D4B, 0x9D49, 0x9D4C, 0x9D4A, 0x9D4D, 0x95AF,
0x88B5, 0x957D, 0x94E1, 0x9D4E, 0x9D51, 0x8FB3, 0x8B5A, 0x9D4F,
0x9D56, 0x8FB4, 0x9D50, 0x9463, 0x977D, 0x9D52, 0x9D53, 0x9D57,
0x938A, 0x9D54, 0x8D52, 0x90DC, 0x9D65, 0x94B2, 0x91F0, 0x94E2,
0x9DAB, 0x95F8, 0x92EF, 0x9695, 0x9D5A, 0x899F, 0x928A, 0x9D63,
0x9253, 0x9D5D, 0x9D64, 0x9D5F, 0x9D66, 0x9D62, 0x9D61, 0x948F,
0x9D5B, 0x89FB, 0x9D59, 0x8B91, 0x91F1, 0x9D55, 0x9D58, 0x8D53,
0x90D9, 0x8FB5, 0x9D60, 0x9471, 0x8B92, 0x8A67, 0x8A87, 0x9040,
0x9D68, 0x9D6D, 0x9D69, 0x8C9D, 0x9D6E, 0x8E41, 0x8D89, 0x8F45,
0x9D5C, 0x8E9D, 0x9D6B, 0x8E77, 0x9D6C, 0x88C2, 0x9D67, 0x92A7,
0x8B93, 0x8BB2, 0x9D6A, 0x88A5, 0x8DC1, 0x9055, 0x92F0, 0x94D2,
0x9D70, 0x917D, 0x91A8, 0x8E4A, 0x9D71, 0x9D73, 0x9D6F, 0x95DF,
0x92BB, 0x917B, 0x95F9, 0x8ECC, 0x9D80, 0x9D7E, 0x9098, 0x8C9E,
0x9D78, 0x8FB7, 0x93E6, 0x9450, 0x9D76, 0x917C, 0x8EF6, 0x9D7B,
0x8FB6, 0x9D75, 0x9D7A, 0x9472, 0x9D74, 0x8C40, 0x8A7C, 0x9D7C,
0x97A9, 0x8DCC, 0x9254, 0x9D79, 0x90DA, 0x8D54, 0x9084, 0x8986,
0x915B, 0x9D77, 0x8B64, 0x8C66, 0x92CD, 0x9D7D, 0x917E, 0x9D81,
0x9D83, 0x91B5, 0x9D89, 0x9D84, 0x9D86, 0x9560, 0x92F1, 0x9D87,
0x974B, 0x9767, 0x8AB7, 0x88AC, 0x9D85, 0x9D82, 0x8AF6, 0x8987,
0x9D88, 0x9768, 0x9D8C, 0x91B9, 0x9D93, 0x9D8D, 0x9D8A, 0x9D91,
0x9D72, 0x9D8E, 0x9D92, 0x94C0, 0x938B, 0x9D8B, 0x9D8F, 0x8C67,
0x8DEF, 0x90DB, 0x9D97, 0x9345, 0x9D94, 0x9680, 0x9D95, 0x9D96,
0x96CC, 0x90A0, 0x8C82, 0x9D9D, 0x8E54, 0x9D9A, 0x9D99, 0x9451,
0x93B3, 0x9350, 0x9D9B, 0x9D9C, 0x958F, 0x9464, 0x8E42, 0x90EF,
0x966F, 0x8A68, 0x9DA3, 0x9D9E, 0x9769, 0x9DA5, 0x9DA1, 0x9DA2,
0x9180, 0x9DA0, 0x9D5E, 0x9DA4, 0x9D9F, 0x9DA9, 0x9DAA, 0x9346,
0x9DAC, 0x8E43, 0x9DA7, 0x8B5B, 0x9DAD, 0x9DA6, 0x9DB1, 0x9DB0,
0x9DAF, 0x9DB2, 0x9DB4, 0x8FEF, 0x9DB3, 0x9DB7, 0x9DB5, 0x9DB6,
0x9D90, 0x9DB9, 0x9DB8, 0x9D98, 0x9DBA, 0x9DAE, 0x8E78, 0x9DBB,
0x9DBC, 0x9DBE, 0x9DBD, 0x9DBF, 0x89FC, 0x8D55, 0x95FA, 0x90AD,
0x8CCC, 0x9DC1, 0x9DC4, 0x9571, 0x8B7E, 0x9DC3, 0x9DC2, 0x9473,
0x9DC5, 0x8BB3, 0x9DC7, 0x9DC6, 0x8AB8, 0x8E55, 0x93D6, 0x8C68,
0x9094, 0x9DC8, 0x90AE, 0x9347, 0x957E, 0x9DC9, 0x9DCA, 0x9DCB,
0x95B6, 0x9B7C, 0x90C4, 0x956B, 0x8DD6, 0x94E3, 0x94C1, 0x936C,
0x97BF, 0x9DCD, 0x8ECE, 0x9DCE, 0x88B4, 0x8BD2, 0x90CB, 0x9580,
0x9DCF, 0x8E61, 0x9266, 0x8E7A, 0x9056, 0x9DD0, 0x95FB, 0x8997,
0x8E7B, 0x9DD3, 0x9DD1, 0x9DD4, 0x97B7, 0x9DD2, 0x90F9, 0x9DD5,
0x91B0, 0x9DD6, 0x8AF8, 0x9DD8, 0x9DD7, 0x9DD9, 0x9DDA, 0x8AF9,
0x93FA, 0x9255, 0x8B8C, 0x8E7C, 0x9181, 0x8F7B, 0x88AE, 0x9DDB,
0x89A0, 0x9DDF, 0x8D56, 0x9DDE, 0x8DA9, 0x8FB8, 0x9DDD, 0x8FB9,
0x96BE, 0x8DA8, 0x88D5, 0x90CC, 0x9DE4, 0x90AF, 0x8966, 0x8F74,
0x9686, 0x8DF0, 0x8FBA, 0x90A5, 0x9DE3, 0x9DE1, 0x9DE2, 0x928B,
0x9E45, 0x9DE8, 0x8E9E, 0x8D57, 0x9DE6, 0x9DE7, 0x9057, 0x9DE5,
0x8E4E, 0x9DEA, 0x9DE9, 0x9DEE, 0x9DEF, 0x9DEB, 0x8A41, 0x9DEC,
0x9DED, 0x94D3, 0x9581, 0x8C69, 0x9DF0, 0x90B0, 0x8FBB, 0x9271,
0x8BC5, 0x9DF1, 0x9DF5, 0x89C9, 0x9DF2, 0x9DF4, 0x9DF3, 0x8F8B,
0x9267, 0x88C3, 0x9DF6, 0x9DF7, 0x92A8, 0x97EF, 0x8E62, 0x95E9,
0x965C, 0x9E41, 0x9DF9, 0x9DFC, 0x9DFB, 0x9DF8, 0x9E40, 0x93DC,
0x9DFA, 0x9E42, 0x8F8C, 0x9E43, 0x976A, 0x9498, 0x9E44, 0x9E46,
0x9E47, 0x9E48, 0x8BC8, 0x8967, 0x8D58, 0x9E49, 0x9E4A, 0x8F91,
0x9182, 0x99D6, 0x915D, 0x915C, 0x91D6, 0x8DC5, 0x98F0, 0x8C8E,
0x974C, 0x95FC, 0x959E, 0x9E4B, 0x8DF1, 0x92BD, 0x9E4C, 0x984E,
0x965D, 0x92A9, 0x9E4D, 0x8AFA, 0x9E4E, 0x9E4F, 0x96D8, 0x96A2,
0x9696, 0x967B, 0x8E44, 0x9E51, 0x8EE9, 0x9670, 0x9E53, 0x9E56,
0x9E55, 0x8AF7, 0x8B80, 0x9E52, 0x9E54, 0x9E57, 0x9099, 0x979B,
0x88C7, 0x8DDE, 0x91BA, 0x8EDB, 0x8FF1, 0x9E5A, 0x936D, 0x9E58,
0x91A9, 0x9E59, 0x8FF0, 0x96DB, 0x9E5B, 0x9E5C, 0x9788, 0x9E61,
0x8D59, 0x9474, 0x9E5E, 0x938C, 0x9DDC, 0x9DE0, 0x8B6E, 0x9466,
0x9E60, 0x8FBC, 0x94C2, 0x9E66, 0x94F8, 0x9E5D, 0x9E63, 0x9E62,
0x90CD, 0x968D, 0x97D1, 0x9687, 0x89CA, 0x8E7D, 0x9867, 0x9E65,
0x9095, 0x9E64, 0x9E5F, 0x8CCD, 0x9E6B, 0x9E69, 0x89CB, 0x9E67,
0x9E6D, 0x9E73, 0x91C6, 0x95BF, 0x9E75, 0x9541, 0x9E74, 0x9490,
0x965E, 0x8AB9, 0x90F5, 0x8F5F, 0x92D1, 0x974D, 0x9E70, 0x9E6F,
0x9E71, 0x9E6E, 0x9E76, 0x9E6C, 0x9E6A, 0x9E72, 0x9E68, 0x928C,
0x96F6, 0x8EC4, 0x8DF2, 0x8DB8, 0x968F, 0x8A60, 0x92CC, 0x93C8,
0x8968, 0x90F0, 0x90B2, 0x8C49, 0x9E78, 0x8D5A, 0x8A9C, 0x9E7A,
0x8A94, 0x9E81, 0x9E7D, 0x90F1, 0x8A6A, 0x8DAA, 0x8A69, 0x8DCD,
0x9E7B, 0x8C85, 0x8C6A, 0x938D, 0x9E79, 0x88C4, 0x9E7C, 0x9E7E,
0x8BCB, 0x8C4B, 0x8ABA, 0x8B6A, 0x9E82, 0x8DF7, 0x9691, 0x8E56,
0x9E83, 0x954F, 0x9E8F, 0x89B1, 0x9E84, 0x9E95, 0x9E85, 0x97C0,
0x9E8C, 0x947E, 0x9E94, 0x9E87, 0x88B2, 0x9E89, 0x8D5B, 0x9E8B,
0x9E8A, 0x9E86, 0x9E91, 0x8FBD, 0x9AEB, 0x8CE6, 0x979C, 0x9E88,
0x92F2, 0x8A42, 0x8DAB, 0x9E80, 0x9E90, 0x8A81, 0x9E8E, 0x9E92,
0x938E, 0x8AFC, 0x9EB0, 0x96C7, 0x9E97, 0x8AFB, 0x9E9E, 0x965F,
0x9E9F, 0x9EA1, 0x9EA5, 0x9E99, 0x9249, 0x938F, 0x9EA9, 0x9E9C,
0x9EA6, 0x9EA0, 0x9058, 0x9EAA, 0x90B1, 0x9EA8, 0x8ABB, 0x986F,
0x9E96, 0x9EA4, 0x88D6, 0x9E98, 0x96B8, 0x9E9D, 0x9041, 0x92C5,
0x9E93, 0x9EA3, 0x909A, 0x9EAD, 0x8A91, 0x8C9F, 0x9EAF, 0x9E9A,
0x9EAE, 0x9EA7, 0x9E9B, 0x9EAB, 0x9EAC, 0x9EBD, 0x93CC, 0x9EA2,
0x9EB9, 0x9EBB, 0x92D6, 0x976B, 0x9596, 0x9EB6, 0x91C8, 0x9EBC,
0x915E, 0x9EB3, 0x9EC0, 0x9EBF, 0x93ED, 0x9EBE, 0x93E8, 0x9EC2,
0x9EB5, 0x8BC6, 0x9EB8, 0x8F7C, 0x9480, 0x9EBA, 0x8BC9, 0x9EB2,
0x9EB4, 0x9EB1, 0x984F, 0x8A79, 0x9EB7, 0x9EC1, 0x8A54, 0x8DE5,
0x897C, 0x9ED2, 0x9850, 0x9ED5, 0x9059, 0x9ED4, 0x9ED3, 0x9ED0,
0x9EC4, 0x9EE1, 0x9EC3, 0x9ED6, 0x9ECE, 0x9EC9, 0x9EC6, 0x9EC7,
0x9ECF, 0xEAA0, 0x9ECC, 0x8D5C, 0x92C6, 0x9184, 0x9ECA, 0x9EC5,
0x9EC8, 0x976C, 0x968A, 0x9ECD, 0x9ED7, 0x9EDF, 0x9ED8, 0x9EE5,
0x9EE3, 0x9EDE, 0x9EDD, 0x92CE, 0x9185, 0x9EDB, 0x9ED9, 0x9EE0,
0x9EE6, 0x94F3, 0x9EEC, 0x9EE7, 0x9EEA, 0x9EE4, 0x9294, 0x9557,
0x9EDA, 0x9EE2, 0x8FBE, 0x96CD, 0x9EF6, 0x9EE9, 0x8CA0, 0x89A1,
0x8A7E, 0x9ED1, 0x8FBF, 0x9EEE, 0x9EF5, 0x8EF7, 0x8A92, 0x924D,
0x9EEB, 0x9EF0, 0x9EF4, 0x8BB4, 0x8B6B, 0x9EF2, 0x8B40, 0x93C9,
0x9EF1, 0x9EF3, 0x9EED, 0x9EEF, 0x8A80, 0x9268, 0x9EFA, 0x9EF8,
0x8CE7, 0x9EF7, 0x9F40, 0x9E77, 0x9EF9, 0x9EFB, 0x9EFC, 0x9F4B,
0x9F47, 0x9E8D, 0x9F46, 0x9F45, 0x9F42, 0x9EE8, 0x9F44, 0x9F43,
0x9F49, 0x9845, 0x9F4C, 0x8BF9, 0x9F48, 0x9F4A, 0x94A5, 0x9F4D,
0x9F51, 0x9F4E, 0x9793, 0x9F4F, 0x9EDC, 0x9F52, 0x9F53, 0x8954,
0x9F55, 0x8C87, 0x8E9F, 0x8BD3, 0x89A2, 0x977E, 0x9F57, 0x9F56,
0x9F59, 0x8B5C, 0x8BD4, 0x8ABC, 0x9F5C, 0x9F5B, 0x9F5D, 0x89CC,
0x9256, 0x9F5E, 0x8ABD, 0x9F60, 0x9F5F, 0x9F61, 0x9F62, 0x9F63,
0x8E7E, 0x90B3, 0x8D9F, 0x9590, 0x95E0, 0x9863, 0x8E95, 0x8DCE,
0x97F0, 0x9F64, 0x9F65, 0x8E80, 0x9F66, 0x9F67, 0x9F69, 0x9F68,
0x9677, 0x8F7D, 0x8EEA, 0x8E63, 0x9F6A, 0x9F6C, 0x9042, 0x9F6B,
0x9F6D, 0x9F6E, 0x9F6F, 0x9F70, 0x9F71, 0x9F73, 0x9F72, 0x9F74,
0x89A3, 0x9269, 0x9F75, 0x8E45, 0x8A6B, 0x9F76, 0x9361, 0x9ACA,
0x8B42, 0x9F77, 0x9F78, 0x95EA, 0x9688, 0x93C5, 0x9F79, 0x94E4,
0x94F9, 0x96D1, 0x9F7A, 0x9F7C, 0x9F7B, 0x9F7E, 0x9F7D, 0x9F81,
0x8E81, 0x96AF, 0x9F82, 0x9F83, 0x8B43, 0x9F84, 0x9F86, 0x9F85,
0x9085, 0x9558, 0x8969, 0x94C3, 0x92F3, 0x8F60, 0x8B81, 0x94C4,
0x8EAC, 0x9F88, 0x8ABE, 0x8998, 0x93F0, 0x9F87, 0x8D5D, 0x9272,
0x9F89, 0x9F91, 0x9F8A, 0x91BF, 0x8B82, 0x9F92, 0x8C88, 0x8B44,
0x9F90, 0x9F8E, 0x9F8B, 0x9780, 0x92BE, 0x93D7, 0x9F8C, 0x9F94,
0x9F93, 0x8C42, 0x89AB, 0x8DB9, 0x9F8D, 0x9F8F, 0x9676, 0x91F2,
0x9697, 0x9F9C, 0x9F9D, 0x89CD, 0x95A6, 0x96FB, 0x9F9F, 0x8EA1,
0x8FC0, 0x9F98, 0x9F9E, 0x8988, 0x8BB5, 0x9F95, 0x9F9A, 0x90F2,
0x9491, 0x94E5, 0x9F97, 0x9640, 0x9F99, 0x9FA2, 0x9FA0, 0x9F9B,
0x9641, 0x9467, 0x8B83, 0x9344, 0x928D, 0x9FA3, 0x9FA1, 0x91D7,
0x9F96, 0x896A, 0x976D, 0x9FAE, 0x9FAD, 0x90F4, 0x9FAA, 0x978C,
0x93B4, 0x9FA4, 0x92C3, 0x896B, 0x8D5E, 0x9FA7, 0x8F46, 0x9FAC,
0x9FAB, 0x9FA6, 0x9FA9, 0x8A88, 0x9FA8, 0x9468, 0x97AC, 0x8FF2,
0x90F3, 0x9FB4, 0x9FB2, 0x956C, 0x9FAF, 0x9FB1, 0x8959, 0x8D5F,
0x9851, 0x8A5C, 0x9582, 0x9781, 0x8A43, 0x905A, 0x9FB3, 0x9FB8,
0x8FC1, 0x974F, 0x9FB5, 0x9FB0, 0x9FB6, 0x97DC, 0x9393, 0x93C0,
0x8A55, 0x8974, 0x9FBC, 0x9FBF, 0x97C1, 0x9784, 0x9FC6, 0x9FC0,
0x9FBD, 0x97D2, 0x9FC3, 0x8F69, 0x9FC5, 0x9FCA, 0x9391, 0x9FC8,
0x9FC2, 0x9257, 0x9FC9, 0x9FBE, 0x9FC4, 0x9FCB, 0x88FA, 0x9FC1,
0x9FCC, 0x905B, 0x8F7E, 0x95A3, 0x8DAC, 0x9FB9, 0x9FC7, 0x9359,
0x90B4, 0x8A89, 0x8DCF, 0x8FC2, 0x9FBB, 0x8F61, 0x8C6B, 0x9FBA,
0x9FD0, 0x8F8D, 0x8CB8, 0x9FDF, 0x9FD9, 0x8B94, 0x936E, 0x9FD4,
0x9FDD, 0x88AD, 0x8951, 0x89B7, 0x9FD6, 0x91AA, 0x9FCD, 0x9FCF,
0x8D60, 0x9FE0, 0x9FDB, 0x9FD3, 0x9FDA, 0x96A9, 0x9FD8, 0x9FDC,
0x8CCE, 0x8FC3, 0x9258, 0x9FD2, 0x974E, 0x9FD5, 0x9FCE, 0x9392,
0x9FD1, 0x9FD7, 0x9870, 0x8EBC, 0x969E, 0x9FE1, 0x94AC, 0x9FED,
0x8CB9, 0x8F80, 0x9FE3, 0x97AD, 0x8D61, 0x9FF0, 0x88EC, 0x9FEE,
0x9FE2, 0x9FE8, 0x9FEA, 0x976E, 0x9FE5, 0x934D, 0x9FE7, 0x9FEF,
0x9FE9, 0x96C5, 0x9FE4, 0x8EA0, 0x9FFC, 0x8A8A, 0x9FE6, 0x9FEB,
0x9FEC, 0x91EA, 0x91D8, 0x9FF4, 0x9FFA, 0x9FF8, 0x9348, 0xE042,
0x9FF5, 0x9FF6, 0x9FDE, 0x8B99, 0x9559, 0x8EBD, 0x8D97, 0x9852,
0x9FF2, 0xE041, 0x8989, 0x9186, 0x9499, 0x8ABF, 0x97F8, 0x969F,
0x92D0, 0x9FF9, 0x9FFB, 0x9151, 0xE040, 0x9FF7, 0x9FF1, 0x8AC1,
0x8C89, 0xE04E, 0xE049, 0x90F6, 0x8A83, 0x8F81, 0xE052, 0xE04B,
0x92AA, 0xE048, 0x92D7, 0xE06B, 0xE045, 0xE044, 0xE04D, 0xE047,
0xE046, 0xE04C, 0x909F, 0xE043, 0xE04F, 0xE050, 0x8AC0, 0xE055,
0xE054, 0xE056, 0xE059, 0x9362, 0xE053, 0xE057, 0x8C83, 0x91F7,
0xE051, 0x945A, 0xE058, 0xE05D, 0xE05B, 0xE05E, 0xE061, 0xE05A,
0x8D8A, 0x9447, 0x9FB7, 0x9794, 0xE05C, 0xE060, 0x91F3, 0xE05F,
0xE04A, 0xE889, 0xE064, 0xE068, 0xE066, 0xE062, 0xE063, 0xE067,
0xE065, 0x956D, 0xE06D, 0xE06A, 0xE069, 0xE06C, 0x93D2, 0xE06E,
0x9295, 0x91EB, 0x90A3, 0xE06F, 0xE071, 0xE070, 0x9FF3, 0xE072,
0x93E5, 0xE073, 0x89CE, 0x9394, 0x8A44, 0x8B84, 0x8EDC, 0x8DD0,
0x9846, 0x9086, 0x898A, 0xE075, 0xE074, 0xE078, 0x9259, 0xE07B,
0xE076, 0xE07A, 0xE079, 0x935F, 0x88D7, 0x97F3, 0xE07D, 0x8947,
0xE080, 0xE07E, 0xE07C, 0xE077, 0x9642, 0xE082, 0xE081, 0x898B,
0xE084, 0x95B0, 0xE083, 0x96B3, 0x8FC5, 0x9152, 0x8FC4, 0x97F9,
0xE08A, 0x90F7, 0xE086, 0xE08B, 0x898C, 0xE089, 0x9481, 0xE085,
0xE088, 0x8FC6, 0x94CF, 0xE08C, 0x8ECF, 0x90F8, 0xE08F, 0xE087,
0x8C46, 0xE08D, 0x976F, 0xE090, 0xEAA4, 0x8F6E, 0xE091, 0xE092,
0x944D, 0xE094, 0xE095, 0x9452, 0x9395, 0xE097, 0xE099, 0x97D3,
0xE096, 0xE098, 0x898D, 0xE093, 0x9A7A, 0xE09A, 0x9187, 0x8E57,
0xE09C, 0xE09B, 0x9043, 0x99D7, 0xE09D, 0xE09F, 0xE08E, 0xE09E,
0xE0A0, 0x949A, 0xE0A1, 0xE0A2, 0xE0A3, 0xE0A4, 0x92DC, 0xE0A6,
0xE0A5, 0xE0A7, 0xE0A8, 0x8EDD, 0x9583, 0x96EA, 0xE0A9, 0xE0AA,
0x9175, 0x8EA2, 0xE0AB, 0xE0AC, 0xE0AD, 0x95D0, 0x94C5, 0xE0AE,
0x9476, 0x92AB, 0xE0AF, 0x89E5, 0x8B8D, 0x96C4, 0x96B4, 0x89B2,
0x9853, 0x9671, 0x95A8, 0x90B5, 0xE0B0, 0x93C1, 0x8CA1, 0xE0B1,
0x8DD2, 0xE0B3, 0xE0B2, 0xE0B4, 0xE0B5, 0xE0B6, 0x8B5D, 0xE0B7,
0xE0B8, 0x8CA2, 0x94C6, 0xE0BA, 0x8FF3, 0xE0B9, 0x8BB6, 0xE0BB,
0xE0BD, 0xE0BC, 0xE0BE, 0x8CCF, 0xE0BF, 0x8BE7, 0x915F, 0x8D9D,
0xE0C1, 0xE0C2, 0xE0C0, 0x8EEB, 0x93C6, 0x8BB7, 0xE0C4, 0x924B,
0xE0C3, 0x9854, 0x9482, 0xE0C7, 0xE0C9, 0xE0C6, 0x96D2, 0xE0C8,
0xE0CA, 0x97C2, 0xE0CE, 0xE0CD, 0x9296, 0x944C, 0x8CA3, 0xE0CC,
0xE0CB, 0x9750, 0x9751, 0xE0CF, 0x898E, 0x8D96, 0x8E82, 0xE0D0,
0xE0D1, 0xE0D3, 0x8F62, 0xE0D5, 0xE0D4, 0xE0D6, 0x8A6C, 0xE0D8,
0xE0D7, 0xE0DA, 0xE0D9, 0x8CBA, 0x97A6, 0x8BCA, 0x89A4, 0x8BE8,
0x8ADF, 0x97E6, 0xE0DC, 0xE0DE, 0xE0DF, 0x89CF, 0xE0DB, 0x8E58,
0x92BF, 0xE0DD, 0xE0E2, 0x8EEC, 0xE0E0, 0x8C5D, 0x94C7, 0xE0E1,
0xE0FC, 0xE0E7, 0x8CBB, 0x8B85, 0xE0E4, 0x979D, 0x97AE, 0x91F4,
0xE0E6, 0xE0E8, 0x97D4, 0x8BD5, 0x94FA, 0x9469, 0xE0E9, 0xE0EB,
0xE0EE, 0xE0EA, 0xE0ED, 0x8CE8, 0x896C, 0xE0EF, 0x9090, 0xE0EC,
0x97DA, 0xE0F2, 0xEAA2, 0xE0F0, 0xE0F3, 0xE0E5, 0xE0F1, 0x8DBA,
0xE0F4, 0xE0F5, 0x979E, 0xE0F6, 0xE0F7, 0xE0E3, 0xE0F8, 0x8AC2,
0x8EA3, 0xE0F9, 0xE0FA, 0xE0FB, 0x895A, 0xE140, 0x955A, 0xE141,
0x8AA2, 0xE142, 0xE143, 0xE144, 0xE146, 0xE147, 0xE145, 0x9572,
0xE149, 0xE148, 0xE14B, 0xE14A, 0xE14C, 0xE14D, 0xE14F, 0xE14E,
0x8D99, 0xE151, 0xE150, 0x8AC3, 0x9072, 0x935B, 0xE152, 0x90B6,
0x8E59, 0x8999, 0xE153, 0x9770, 0x95E1, 0xE154, 0x9363, 0x9752,
0x8D62, 0x905C, 0x926A, 0x99B2, 0x92AC, 0x89E6, 0xE155, 0xE156,
0xE15B, 0xE159, 0xE158, 0x9DC0, 0x8A45, 0xE157, 0x88D8, 0x94A8,
0x94C8, 0x97AF, 0xE15C, 0xE15A, 0x927B, 0x90A4, 0x94A9, 0x954C,
0xE15E, 0x97AA, 0x8C6C, 0xE15F, 0xE15D, 0x94D4, 0xE160, 0xE161,
0x88D9, 0x8FF4, 0xE166, 0xE163, 0x93EB, 0xE162, 0x8B45, 0xE169,
0xE164, 0xE165, 0xE168, 0xE167, 0x9544, 0x9161, 0x9160, 0x8B5E,
0xE16A, 0xE16B, 0xE16C, 0xE16E, 0xE16D, 0x8975, 0xE176, 0x94E6,
0xE170, 0xE172, 0xE174, 0x905D, 0xE175, 0xE173, 0x8EBE, 0xE16F,
0xE171, 0x9561, 0x8FC7, 0xE178, 0xE177, 0xE179, 0x8EA4, 0x8DAD,
0x9397, 0xE17A, 0x92C9, 0xE17C, 0x979F, 0xE17B, 0x9189, 0xE182,
0xE184, 0xE185, 0x9273, 0xE183, 0xE180, 0xE17D, 0xE17E, 0xE181,
0xE188, 0xE186, 0xE187, 0xE189, 0xE18B, 0xE18C, 0xE18D, 0xE18E,
0xE18A, 0xE190, 0xE18F, 0xE191, 0x97C3, 0xE194, 0xE192, 0xE193,
0x8AE0, 0x96FC, 0x95C8, 0xE196, 0xE195, 0xE197, 0xE198, 0xE19C,
0xE199, 0xE19A, 0xE19B, 0xE19D, 0xE19E, 0xE19F, 0xE1A0, 0xE1A1,
0x94AD, 0x936F, 0xE1A2, 0x9492, 0x9553, 0xE1A3, 0xE1A4, 0x9349,
0x8A46, 0x8D63, 0xE1A5, 0xE1A6, 0xE1A7, 0x8E48, 0xE1A9, 0xE1A8,
0xE1AA, 0xE1AB, 0x94E7, 0xE1AC, 0xE1AD, 0xEA89, 0xE1AE, 0xE1AF,
0xE1B0, 0x8E4D, 0xE1B1, 0x9475, 0x967E, 0x896D, 0x8976, 0xE1B2,
0xE1B4, 0xE1B3, 0x9390, 0x90B7, 0x9F58, 0xE1B5, 0x96BF, 0xE1B6,
0x8AC4, 0x94D5, 0xE1B7, 0xE1B8, 0xE1B9, 0x96DA, 0x96D3, 0x92BC,
0x918A, 0xE1BB, 0x8F82, 0x8FC8, 0xE1BE, 0xE1BD, 0xE1BC, 0x94FB,
0x8AC5, 0x8CA7, 0xE1C4, 0xE1C1, 0x905E, 0x96B0, 0xE1C0, 0xE1C2,
0xE1C3, 0xE1BF, 0xE1C5, 0xE1C6, 0x92AD, 0x8AE1, 0x9285, 0xE1C7,
0xE1C8, 0xE1CB, 0x9087, 0x93C2, 0xE1CC, 0x9672, 0xE1C9, 0xE1CA,
0xE1CF, 0xE1CE, 0xE1CD, 0xE1D1, 0xE1D0, 0xE1D2, 0xE1D4, 0xE1D3,
0x95CB, 0x8F75, 0x97C4, 0xE1D5, 0x93B5, 0xE1D6, 0xE1D7, 0xE1DB,
0xE1D9, 0xE1DA, 0xE1D8, 0xE1DC, 0xE1DD, 0xE1DE, 0xE1DF, 0x96B5,
0xE1E0, 0x96EE, 0xE1E1, 0x926D, 0x948A, 0x8BE9, 0x925A, 0xE1E2,
0x8BB8, 0x90CE, 0xE1E3, 0x8DBB, 0xE1E4, 0xE1E5, 0x8CA4, 0x8DD3,
0xE1E7, 0x9375, 0x8DD4, 0x8B6D, 0x9643, 0x946A, 0x9376, 0x8D7B,
0xE1E9, 0x8FC9, 0x97B0, 0x8D64, 0x8CA5, 0x94A1, 0xE1EB, 0xE1ED,
0x8CE9, 0xE1EC, 0x92F4, 0xE1EF, 0x8A56, 0xE1EA, 0x94E8, 0x894F,
0x8DEA, 0x9871, 0xE1EE, 0xE1F0, 0x95C9, 0x90D7, 0xE1F2, 0xE1F3,
0xE1F1, 0x8A6D, 0xE1F9, 0xE1F8, 0x8EA5, 0xE1FA, 0xE1F5, 0xE1FB,
0xE1F6, 0x94D6, 0xE1F4, 0xE1F7, 0xE241, 0xE240, 0x9681, 0xE1FC,
0x88E9, 0xE243, 0xE242, 0x8FCA, 0xE244, 0x9162, 0xE246, 0xE245,
0xE247, 0xE1E6, 0xE1E8, 0xE249, 0xE248, 0x8EA6, 0x97E7, 0x8ED0,
0xE24A, 0x8C56, 0x8B5F, 0x8B46, 0x8E83, 0x9753, 0xE250, 0xE24F,
0x9163, 0xE24C, 0xE24E, 0x8F6A, 0x905F, 0xE24D, 0xE24B, 0x9449,
0x8FCB, 0x955B, 0x8DD5, 0x9398, 0xE251, 0xE252, 0xE268, 0x8BD6,
0x985C, 0x9154, 0xE253, 0x89D0, 0x92F5, 0x959F, 0xE254, 0x8B9A,
0xE255, 0xE257, 0xE258, 0x9448, 0xE259, 0xE25A, 0xE25B, 0x8BD7,
0x89D1, 0x93C3, 0x8F47, 0x8E84, 0xE25C, 0x8F48, 0x89C8, 0x9562,
0xE25D, 0x94E9, 0x9164, 0xE260, 0xE261, 0x9489, 0x9060, 0xE25E,
0x9281, 0xE25F, 0x8FCC, 0x88DA, 0x8B48, 0xE262, 0x92F6, 0xE263,
0x90C5, 0x96AB, 0x9542, 0xE264, 0xE265, 0x9274, 0x97C5, 0xE267,
0xE266, 0x8EED, 0xE269, 0x88EE, 0xE26C, 0xE26A, 0x89D2, 0x8C6D,
0xE26B, 0x8D65, 0x8D92, 0x95E4, 0xE26D, 0x9673, 0xE26F, 0x90CF,
0x896E, 0x89B8, 0x88AA, 0xE26E, 0xE270, 0xE271, 0x8FF5, 0xE272,
0x8A6E, 0xE274, 0x8C8A, 0x8B86, 0xE275, 0x8BF3, 0xE276, 0x90FA,
0x93CB, 0x90DE, 0x8DF3, 0xE277, 0x9282, 0x918B, 0xE279, 0xE27B,
0xE278, 0xE27A, 0x8C41, 0xE27C, 0x8C45, 0x8B87, 0x9771, 0xE27E,
0xE280, 0x894D, 0xE283, 0x8A96, 0xE282, 0xE281, 0xE285, 0xE27D,
0xE286, 0x97A7, 0xE287, 0xE288, 0x9AF2, 0xE28A, 0xE289, 0xE28B,
0xE28C, 0x97B3, 0xE28D, 0xE8ED, 0x8FCD, 0xE28E, 0xE28F, 0x8F76,
0x93B6, 0xE290, 0x9247, 0xE291, 0x925B, 0xE292, 0x8BA3, 0x995E,
0x927C, 0x8EB1, 0x8AC6, 0xE293, 0xE2A0, 0xE296, 0x8B88, 0xE295,
0xE2A2, 0xE294, 0x8FCE, 0xE298, 0xE299, 0x934A, 0xE29A, 0x8A7D,
0x9079, 0x9584, 0xE29C, 0x91E6, 0xE297, 0xE29B, 0xE29D, 0x8DF9,
0xE2A4, 0x954D, 0x94A4, 0x9399, 0x8BD8, 0xE2A3, 0xE2A1, 0x94B3,
0xE29E, 0x927D, 0x939B, 0x939A, 0x8DF4, 0xE2B6, 0xE2A6, 0xE2A8,
0xE2AB, 0xE2AC, 0xE2A9, 0xE2AA, 0xE2A7, 0xE2A5, 0xE29F, 0x95CD,
0x89D3, 0xE2B3, 0xE2B0, 0xE2B5, 0xE2B4, 0x9493, 0x96A5, 0x8E5A,
0xE2AE, 0xE2B7, 0xE2B2, 0xE2B1, 0xE2AD, 0xE2AF, 0x8AC7, 0x925C,
0x90FB, 0x94A0, 0xE2BC, 0x94A2, 0x90DF, 0xE2B9, 0x94CD, 0xE2BD,
0x95D1, 0x927A, 0xE2B8, 0xE2BA, 0xE2BB, 0xE2BE, 0x8EC2, 0x93C4,
0xE2C3, 0xE2C2, 0xE2BF, 0x9855, 0xE2C8, 0xE2CC, 0xE2C9, 0xE2C5,
0xE2C6, 0xE2CB, 0xE2C0, 0x99D3, 0xE2C7, 0xE2C1, 0xE2CA, 0xE2D0,
0x8AC8, 0xE2CD, 0xE2CE, 0xE2CF, 0xE2D2, 0xE2D1, 0x94F4, 0xE2D3,
0x97FA, 0x95EB, 0xE2D8, 0xE2D5, 0xE2D4, 0x90D0, 0xE2D7, 0xE2D9,
0xE2D6, 0xE2DD, 0xE2DA, 0xE2DB, 0xE2C4, 0xE2DC, 0xE2DE, 0xE2DF,
0x95C4, 0xE2E0, 0x96E0, 0x8BCC, 0x8C48, 0xE2E1, 0x95B2, 0x9088,
0x96AE, 0xE2E2, 0x97B1, 0x9494, 0x9165, 0x9453, 0x8F6C, 0x88BE,
0xE2E7, 0xE2E5, 0xE2E3, 0x8A9F, 0x8FCF, 0xE2E8, 0xE2E6, 0xE2E4,
0xE2EC, 0xE2EB, 0xE2EA, 0xE2E9, 0xE2ED, 0xE2EE, 0x90B8, 0xE2EF,
0xE2F1, 0xE2F0, 0x8CD0, 0x9157, 0xE2F3, 0x939C, 0xE2F2, 0xE2F4,
0x95B3, 0x918C, 0x8D66, 0xE2F5, 0x97C6, 0xE2F7, 0xE2F8, 0xE2F9,
0xE2FA, 0x8E85, 0xE2FB, 0x8C6E, 0x8B8A, 0x8B49, 0xE340, 0x96F1,
0x8D67, 0xE2FC, 0xE343, 0x96E4, 0x945B, 0x9552, 0x8F83, 0xE342,
0x8ED1, 0x8D68, 0x8E86, 0x8B89, 0x95B4, 0xE341, 0x9166, 0x9661,
0x8DF5, 0x8E87, 0x92DB, 0xE346, 0x97DD, 0x8DD7, 0xE347, 0x9061,
0xE349, 0x8FD0, 0x8DAE, 0xE348, 0x8F49, 0x8CBC, 0x9167, 0xE344,
0xE34A, 0xE345, 0x8C6F, 0xE34D, 0xE351, 0x8C8B, 0xE34C, 0xE355,
0x8D69, 0x978D, 0x88BA, 0xE352, 0x8B8B, 0xE34F, 0xE350, 0x939D,
0xE34E, 0xE34B, 0x8A47, 0x90E2, 0x8CA6, 0xE357, 0xE354, 0xE356,
0xE353, 0x8C70, 0x91B1, 0xE358, 0x918E, 0xE365, 0xE361, 0xE35B,
0xE35F, 0x8EF8, 0x88DB, 0xE35A, 0xE362, 0xE366, 0x8D6A, 0x96D4,
0x92D4, 0xE35C, 0xE364, 0xE359, 0x925D, 0xE35E, 0x88BB, 0x96C8,
0xE35D, 0x8BD9, 0x94EA, 0x918D, 0x97CE, 0x8F8F, 0xE38E, 0xE367,
0x90FC, 0xE363, 0xE368, 0xE36A, 0x92F7, 0xE36D, 0xE369, 0x95D2,
0x8AC9, 0x96C9, 0x88DC, 0xE36C, 0x97FB, 0xE36B, 0x898F, 0x93EA,
0xE36E, 0xE375, 0xE36F, 0xE376, 0xE372, 0x949B, 0x8EC8, 0xE374,
0xE371, 0xE377, 0xE370, 0x8F63, 0x9644, 0x8F6B, 0xE373, 0xE380,
0xE37B, 0xE37E, 0xE37C, 0xE381, 0xE37A, 0xE360, 0x90D1, 0x94C9,
0xE37D, 0xE378, 0x9140, 0x8C71, 0x8F4A, 0x9044, 0x9155, 0xE384,
0xE386, 0xE387, 0xE383, 0xE385, 0xE379, 0xE382, 0xE38A, 0xE389,
0x969A, 0x8C4A, 0xE388, 0xE38C, 0xE38B, 0xE38F, 0xE391, 0x8E5B,
0xE38D, 0xE392, 0xE393, 0xE394, 0xE39A, 0x935A, 0xE396, 0xE395,
0xE397, 0xE398, 0xE399, 0xE39B, 0xE39C, 0x8ACA, 0xE39D, 0xE39E,
0xE39F, 0xE3A0, 0xE3A1, 0xE3A2, 0xE3A3, 0xE3A4, 0xE3A6, 0xE3A5,
0xE3A7, 0xE3A8, 0xE3A9, 0xE3AC, 0xE3AA, 0xE3AB, 0x8DDF, 0x8C72,
0x9275, 0x94B1, 0x8F90, 0x946C, 0x94EB, 0xE3AD, 0x9CEB, 0xE3AE,
0xE3B0, 0x9785, 0xE3AF, 0xE3B2, 0xE3B1, 0x9772, 0xE3B3, 0x94FC,
0xE3B4, 0xE3B7, 0xE3B6, 0xE3B5, 0xE3B8, 0x8C51, 0x9141, 0x8B60,
0xE3BC, 0xE3B9, 0xE3BA, 0xE3BD, 0xE3BE, 0xE3BB, 0x8948, 0x89A5,
0xE3C0, 0xE3C1, 0xE3C2, 0x9782, 0x8F4B, 0xE3C4, 0xE3C3, 0x9089,
0xE3C5, 0xE3C6, 0xE3C7, 0x8AE3, 0x8ACB, 0xE3C8, 0xE3C9, 0x967C,
0x9783, 0x9773, 0x9856, 0x8D6C, 0xE3CC, 0x8ED2, 0xE3CB, 0xE3CD,
0x8EA7, 0x91CF, 0xE3CE, 0x8D6B, 0x96D5, 0xE3CF, 0xE3D0, 0xE3D1,
0xE3D2, 0xE3D3, 0x8EA8, 0x96EB, 0xE3D5, 0x925E, 0xE3D4, 0xE3D7,
0xE3D6, 0xE3D8, 0x90B9, 0xE3D9, 0xE3DA, 0x95B7, 0xE3DB, 0x918F,
0xE3DC, 0xE3DD, 0x97FC, 0xE3E0, 0xE3DF, 0xE3DE, 0x92AE, 0xE3E1,
0x9045, 0xE3E2, 0xE3E3, 0x9857, 0xE3E4, 0xE3E5, 0xE3E7, 0xE3E6,
0x94A3, 0x93F7, 0x985D, 0x94A7, 0xE3E9, 0x8FD1, 0x9549, 0xE3EA,
0xE3E8, 0x8ACC, 0x8CD2, 0x8E88, 0x94EC, 0x8CA8, 0x9662, 0xE3ED,
0xE3EB, 0x8D6D, 0x8D6E, 0x88E7, 0x8DE6, 0x9478, 0x88DD, 0xE3F2,
0x925F, 0x9477, 0x91D9, 0xE3F4, 0xE3F0, 0xE3F3, 0xE3EE, 0xE3F1,
0x9645, 0x8CD3, 0x88FB, 0xE3EF, 0xE3F6, 0xE3F7, 0x93B7, 0x8BB9,
0xE445, 0x945C, 0x8E89, 0x8BBA, 0x90C6, 0x9865, 0x96AC, 0xE3F5,
0x90D2, 0x8B72, 0xE3F8, 0xE3FA, 0xE3F9, 0xE3FB, 0x9245, 0x945D,
0x92AF, 0xE442, 0xE441, 0xE3FC, 0x9074, 0x9585, 0xE444, 0xE443,
0x8D6F, 0x9872, 0xE454, 0xE448, 0xE449, 0x8EEE, 0xE447, 0x8D98,
0xE446, 0xE44A, 0x92B0, 0x95A0, 0x9142, 0x91DA, 0xE44E, 0xE44F,
0xE44B, 0xE44C, 0xE44D, 0x8D70, 0xE455, 0xE451, 0x9586, 0x968C,
0x9547, 0xE450, 0xE453, 0xE452, 0x9663, 0xE456, 0xE457, 0x9156,
0xE458, 0xE45A, 0xE45E, 0xE45B, 0xE459, 0x945E, 0xE45C, 0xE45D,
0x89B0, 0xE464, 0xE45F, 0xE460, 0xE461, 0x919F, 0xE463, 0xE462,
0xE465, 0xE466, 0xE467, 0x9062, 0x89E7, 0xE468, 0x97D5, 0x8EA9,
0x8F4C, 0x8E8A, 0x9276, 0xE469, 0xE46A, 0x8950, 0xE46B, 0xE46C,
0xE46D, 0xE46E, 0xE46F, 0x8BBB, 0x9DA8, 0xE470, 0x90E3, 0xE471,
0x8EC9, 0xE472, 0x98AE, 0xE473, 0x95DC, 0x8ADA, 0x9143, 0x8F77,
0x9591, 0x8F4D, 0xE474, 0x8D71, 0xE475, 0x94CA, 0xE484, 0xE477,
0x91C7, 0x9495, 0x8CBD, 0xE476, 0x9144, 0xE478, 0x92F8, 0xE47A,
0xE479, 0xE47C, 0xE47B, 0xE47D, 0xE480, 0xE47E, 0x8ACD, 0xE481,
0xE482, 0xE483, 0x8DAF, 0x97C7, 0xE485, 0x9046, 0x8990, 0xE486,
0xE487, 0xE488, 0x88F0, 0xE489, 0xE48A, 0x9587, 0x8EC5, 0xE48C,
0x8A48, 0x88B0, 0xE48B, 0xE48E, 0x946D, 0x9063, 0x89D4, 0x9646,
0x8C7C, 0x8BDA, 0xE48D, 0x89E8, 0x8AA1, 0x8991, 0xE492, 0x97E8,
0x91DB, 0x9563, 0xE49E, 0x89D5, 0xE49C, 0xE49A, 0xE491, 0xE48F,
0xE490, 0x8EE1, 0x8BEA, 0x9297, 0x93CF, 0x8970, 0xE494, 0xE493,
0xE499, 0xE495, 0xE498, 0x96CE, 0xE497, 0x89D6, 0x8A9D, 0xE49B,
0xE49D, 0x8C73, 0xE4A1, 0xE4AA, 0xE4AB, 0x88A9, 0xE4B2, 0x88EF,
0xE4A9, 0xE4A8, 0xE4A3, 0xE4A2, 0xE4A0, 0xE49F, 0x9283, 0x91F9,
0xE4A5, 0xE4A4, 0xE4A7, 0x9190, 0x8C74, 0x8960, 0xE4A6, 0x8D72,
0x9191, 0xE4B8, 0xE4B9, 0x89D7, 0x89AC, 0xE4B6, 0xE4AC, 0xE4B4,
0xE4BB, 0xE4B5, 0xE4B3, 0xE496, 0xE4B1, 0xE4AD, 0x8ACE, 0xE4AF,
0xE4BA, 0xE4B0, 0xE4BC, 0xE4AE, 0x949C, 0x9789, 0xE4B7, 0xE4CD,
0xE4C5, 0x909B, 0x8B65, 0x8BDB, 0xE4C0, 0x89D9, 0x8FD2, 0xE4C3,
0x8DD8, 0x9370, 0xE4C8, 0x95EC, 0xE4BF, 0x89D8, 0x8CD4, 0x9548,
0xE4C9, 0xE4BD, 0xE4C6, 0xE4D0, 0xE4C1, 0xE4C2, 0x93B8, 0xE4C7,
0xE4C4, 0x9647, 0xE4CA, 0x88DE, 0xE4BE, 0xE4CC, 0xE4CB, 0x948B,
0xE4D2, 0xE4DD, 0x8A9E, 0xE4E0, 0xE4CE, 0xE4D3, 0x978E, 0xE4DC,
0x9774, 0x97A8, 0x9298, 0x8A8B, 0x9592, 0xE4E2, 0x939F, 0x88AF,
0xE4DB, 0xE4D7, 0x9192, 0xE4D1, 0xE4D9, 0xE4DE, 0x944B, 0x88A8,
0xE4D6, 0xE4DF, 0x9598, 0xE4DA, 0xE4D5, 0x8FD3, 0x8F4E, 0x8EAA,
0x96D6, 0x9566, 0xE4E5, 0xE4EE, 0xE4D8, 0x8A97, 0x8FF6, 0xE4E3,
0xE4E8, 0x9193, 0xE4E4, 0xE4EB, 0x927E, 0xE4EC, 0x9775, 0xE4E1,
0x8A57, 0xE4E7, 0xE4EA, 0x96AA, 0xE4ED, 0xE4E6, 0xE4E9, 0x9648,
0x9840, 0xE4F1, 0xE4F8, 0xE4F0, 0x8EC1, 0xE4CF, 0x95CC, 0x96A0,
0xE4F7, 0xE4F6, 0xE4F2, 0xE4F3, 0x8955, 0xE4F5, 0xE4EF, 0x92D3,
0xE4F4, 0x88FC, 0x91A0, 0x95C1, 0xE4F9, 0xE540, 0x94D7, 0xE4FC,
0x8FD4, 0x8EC7, 0xE542, 0x8BBC, 0xE543, 0x9599, 0xE4FB, 0xE4D4,
0xE4FA, 0x986E, 0x93A0, 0x9593, 0xE54A, 0xE550, 0xE551, 0xE544,
0x9496, 0xE54E, 0xE546, 0xE548, 0xE552, 0xE547, 0xE54B, 0x8992,
0x93E3, 0xE54C, 0xE54F, 0xE545, 0x9145, 0xE549, 0x8E46, 0x9064,
0x8C4F, 0x96F2, 0x96F7, 0x8F92, 0xE556, 0xE554, 0x986D, 0xE553,
0x9795, 0xE555, 0xE557, 0xE558, 0xE55B, 0xE559, 0x93A1, 0xE55A,
0x94CB, 0xE54D, 0x8F93, 0xE55C, 0xE561, 0x9194, 0xE560, 0xE541,
0xE562, 0x9168, 0xE55D, 0xE55F, 0xE55E, 0x9F50, 0x9F41, 0xE564,
0xE563, 0x9796, 0xE1BA, 0xE565, 0xE566, 0xE567, 0x8CD5, 0x8B73,
0xE569, 0x997C, 0x8B95, 0x97B8, 0x8BF1, 0xE56A, 0xE56B, 0x928E,
0xE56C, 0x93F8, 0x88B8, 0x89E1, 0xE571, 0xE572, 0xE56D, 0x8E5C,
0xE56E, 0x9461, 0xE56F, 0xE570, 0xE57A, 0xE574, 0xE577, 0xE573,
0xE575, 0xE576, 0x8ED6, 0xE578, 0x9260, 0x8C75, 0x8A61, 0xE57B,
0x8A5E, 0xE581, 0xE57C, 0xE580, 0x94B8, 0xE57D, 0xE57E, 0x9567,
0x94D8, 0xE582, 0x91FB, 0xE58C, 0xE588, 0x89E9, 0xE586, 0x9649,
0xE587, 0xE584, 0xE585, 0xE58A, 0xE58D, 0xE58B, 0xE589, 0xE583,
0x9277, 0xE594, 0x96A8, 0xE592, 0xE593, 0xE58E, 0xE590, 0xE591,
0xE58F, 0x90E4, 0x9858, 0xE598, 0xE599, 0xE59F, 0x9049, 0xE59B,
0xE59E, 0xE596, 0xE595, 0xE5A0, 0x89DA, 0xE59C, 0xE5A1, 0xE59D,
0xE59A, 0x92B1, 0xE597, 0x9488, 0xE5A5, 0x975A, 0xE5A4, 0xE5A3,
0xE5AC, 0xE5A6, 0xE5AE, 0x9786, 0xE5B1, 0xE5A8, 0xE5A9, 0xE5AD,
0xE5B0, 0xE5AF, 0xE5A7, 0xE5AA, 0xE5BB, 0xE5B4, 0xE5B2, 0xE5B3,
0xE5B8, 0xE5B9, 0x8A49, 0x8B61, 0xE5B7, 0xE5A2, 0xE5B6, 0xE5BA,
0xE5B5, 0xE5BC, 0xE5BE, 0xE5BD, 0xE5C0, 0xE5BF, 0xE579, 0xE5C4,
0xE5C1, 0xE5C2, 0xE5C3, 0xE5C5, 0x8C8C, 0xE5C7, 0xE5C6, 0x8F4F,
0x8D73, 0x9FA5, 0xE5C8, 0x8F70, 0x8A58, 0xE5C9, 0x8971, 0x8FD5,
0xE5CA, 0x8D74, 0xE5CB, 0x88DF, 0x955C, 0xE5CC, 0x908A, 0xE5D3,
0xE5D0, 0x928F, 0xE5D1, 0xE5CE, 0x8BDC, 0xE5CD, 0xE5D4, 0x8C55,
0x91DC, 0xE5DA, 0xE5D6, 0x91B3, 0xE5D5, 0xE5D8, 0xE5CF, 0xE5D9,
0xE5DB, 0x94ED, 0xE5D7, 0xE5DC, 0xE5DE, 0x8CD1, 0xE5D2, 0x88BF,
0xE5DD, 0x8DD9, 0x97F4, 0xE5DF, 0xE5E0, 0x9195, 0x97A0, 0xE5E1,
0x9754, 0xE5E2, 0xE5E3, 0x95E2, 0xE5E4, 0x8DBE, 0x97A1, 0xE5E9,
0xE5EA, 0x8FD6, 0xE5E8, 0x9787, 0xE5E5, 0xE5E7, 0x90BB, 0x909E,
0xE5E6, 0xE5EB, 0x95A1, 0xE5ED, 0xE5EC, 0x8A8C, 0x964A, 0xE5EE,
0xE5FA, 0xE5F0, 0xE5F1, 0xE5F2, 0xE5F3, 0xE5F7, 0xE5F8, 0xE5F6,
0xE5F4, 0xE5EF, 0xE5F5, 0xE5F9, 0xE8B5, 0x89A6, 0xE5FC, 0x8BDD,
0xE5FB, 0xE641, 0xE640, 0xE643, 0xE642, 0xE644, 0x8F50, 0xE645,
0xE646, 0xE647, 0x90BC, 0x9776, 0xE648, 0x95A2, 0x9465, 0xE649,
0xE64A, 0x8CA9, 0x8B4B, 0xE64B, 0x8E8B, 0x9460, 0xE64C, 0x8A6F,
0xE64D, 0xE64F, 0x9797, 0xE64E, 0x9065, 0xE650, 0xE651, 0xE652,
0x8ACF, 0xE653, 0xE654, 0xE655, 0xE656, 0x8A70, 0xE657, 0xE658,
0xE659, 0x89F0, 0x9047, 0xE65A, 0xE65B, 0xE65C, 0x8CBE, 0x92F9,
0xE65D, 0x8C76, 0x9075, 0xE660, 0x93A2, 0xE65F, 0x8C50, 0xE65E,
0x91F5, 0x8B4C, 0xE661, 0xE662, 0x8FD7, 0x8C8D, 0xE663, 0x964B,
0x90DD, 0x8B96, 0x96F3, 0x9169, 0xE664, 0x9066, 0x9290, 0x8FD8,
0xE665, 0xE668, 0xE669, 0x8DBC, 0x91C0, 0xE667, 0x8FD9, 0x955D,
0xE666, 0x8E8C, 0x8972, 0xE66D, 0x8C77, 0x8E8E, 0x8E8D, 0x986C,
0xE66C, 0xE66B, 0x9146, 0x8B6C, 0x9862, 0x8A59, 0x8FDA, 0xE66A,
0xE66F, 0xE670, 0xE66E, 0x8CD6, 0x975F, 0x8E8F, 0x9446, 0xE673,
0x90BE, 0x9261, 0x9755, 0xE676, 0x8CEA, 0x90BD, 0xE672, 0xE677,
0x8CEB, 0xE674, 0xE675, 0xE671, 0x90E0, 0x93C7, 0x924E, 0x89DB,
0x94EE, 0x8B62, 0x92B2, 0xE67A, 0xE678, 0x926B, 0x90BF, 0x8AD0,
0xE679, 0x907A, 0x97C8, 0x985F, 0xE67B, 0xE687, 0x92B3, 0xE686,
0xE683, 0xE68B, 0xE684, 0xE680, 0x92FA, 0xE67E, 0xE67C, 0x9740,
0x8E90, 0xE681, 0xE67D, 0xE685, 0x8F94, 0x8CBF, 0x91F8, 0x9664,
0x8979, 0x88E0, 0x93A3, 0xE689, 0xE688, 0x93E4, 0xE68D, 0xE682,
0xE68C, 0xE68E, 0x8CAA, 0xE68A, 0x8D75, 0x8ED3, 0xE68F, 0x9777,
0xE692, 0xE695, 0xE693, 0x9554, 0xE690, 0x8BDE, 0xE694, 0xE696,
0xE69A, 0xE697, 0xE699, 0xE698, 0xE69B, 0x8EAF, 0xE69D, 0xE69C,
0x9588, 0xE69F, 0x8C78, 0xE69E, 0xE6A0, 0xE6A1, 0x8B63, 0xE3BF,
0x8FF7, 0xE6A2, 0x8CEC, 0xE6A3, 0xE6A4, 0x8E5D, 0x9DCC, 0xE6A5,
0xE6A6, 0x8F51, 0xE6A7, 0xE6A8, 0xE6A9, 0xE6AA, 0xE6AB, 0x924A,
0xE6AC, 0xE6AE, 0xE6AD, 0x93A4, 0xE6AF, 0x964C, 0xE6B0, 0xE6B1,
0xE6B2, 0xE6B3, 0x93D8, 0x8FDB, 0xE6B4, 0x8D8B, 0x98AC, 0xE6B5,
0xE6B6, 0x955E, 0xE6B7, 0xE6BF, 0xE6B8, 0xE6BA, 0xE6B9, 0xE6BB,
0x9665, 0xE6BC, 0xE6BD, 0xE6BE, 0xE6C0, 0x8A4C, 0x92E5, 0x9589,
0x8DE0, 0x8D76, 0x956E, 0x89DD, 0x94CC, 0xE6C3, 0x8AD1, 0x90D3,
0xE6C2, 0xE6C7, 0x9299, 0x96E1, 0xE6C5, 0xE6C6, 0x8B4D, 0xE6C8,
0x9483, 0x91DD, 0x94EF, 0x935C, 0xE6C4, 0x9666, 0x89EA, 0xE6CA,
0x9847, 0x92C0, 0x9864, 0x8E91, 0xE6C9, 0x91AF, 0xE6DA, 0x9147,
0x93F6, 0x956F, 0xE6CD, 0x8E5E, 0x8E92, 0x8FDC, 0x9485, 0x8CAB,
0xE6CC, 0xE6CB, 0x958A, 0x8EBF, 0x9371, 0xE6CF, 0xE6D0, 0x8D77,
0xE6CE, 0xE6D1, 0xE6D2, 0xE6D4, 0x91A1, 0xE6D3, 0x8AE4, 0xE6D6,
0xE6D5, 0xE6D7, 0xE6D9, 0xE6DB, 0xE6DC, 0x90D4, 0x8ECD, 0xE6DD,
0x8A71, 0xE6DE, 0x9196, 0xE6DF, 0xE6E0, 0x958B, 0x8B4E, 0xE6E1,
0x92B4, 0x897A, 0xE6E2, 0x8EEF, 0x9096, 0x91AB, 0xE6E5, 0xE6E4,
0xE6E3, 0xE6EB, 0xE6E9, 0xE6E6, 0xE6E8, 0xE6E7, 0xE6EA, 0x8B97,
0xE6EE, 0x90D5, 0xE6EF, 0x8CD7, 0xE6EC, 0xE6ED, 0x9848, 0x92B5,
0x9148, 0xE6F0, 0xE6F3, 0xE6F1, 0xE6F2, 0x9778, 0x93A5, 0xE6F6,
0xE6F4, 0xE6F5, 0xE6F7, 0xE748, 0xE6FA, 0xE6FB, 0xE6F9, 0xE6F8,
0x92FB, 0xE740, 0xE744, 0xE741, 0xE6FC, 0xE742, 0xE743, 0xE74A,
0xE745, 0x90D6, 0xE747, 0xE749, 0xE746, 0xE74C, 0x8F52, 0xE74B,
0xE74D, 0xE74E, 0xE751, 0xE750, 0xE74F, 0xE753, 0xE752, 0x96F4,
0xE755, 0xE754, 0xE756, 0xE757, 0xE759, 0xE758, 0x9067, 0xE75A,
0x8BEB, 0xE75B, 0xE75D, 0xE75E, 0xE75F, 0xE75C, 0xE760, 0x8ED4,
0xE761, 0x8B4F, 0x8C52, 0x8CAC, 0xE762, 0x93EE, 0x935D, 0xE763,
0xE766, 0x8EB2, 0xE765, 0xE764, 0x8C79, 0xE767, 0x8A72, 0xE769,
0x8DDA, 0xE768, 0xE771, 0xE76B, 0xE76D, 0x95E3, 0xE76A, 0xE76C,
0xE770, 0xE76E, 0x8B50, 0xE76F, 0xE772, 0x9479, 0x97D6, 0x8F53,
0xE773, 0x9741, 0xE775, 0xE774, 0xE778, 0x9760, 0xE777, 0x8A8D,
0xE776, 0xE77B, 0xE77A, 0xE779, 0x9351, 0xE77C, 0xE77D, 0xE77E,
0x8D8C, 0x8C44, 0xE780, 0xE781, 0xE782, 0x9068, 0xE783, 0x8EAB,
0xE784, 0xE785, 0x999F, 0x999E, 0xE786, 0xE390, 0xE787, 0x9243,
0x904A, 0x945F, 0xE788, 0x95D3, 0x92D2, 0x8D9E, 0x9248, 0x8949,
0x9698, 0x9076, 0x8C7D, 0x8BDF, 0x95D4, 0xE789, 0xE78B, 0xE78A,
0x89DE, 0x93F4, 0xE78C, 0x9497, 0x9352, 0xE78D, 0x8F71, 0xE78F,
0x96C0, 0xE79E, 0xE791, 0xE792, 0x92C7, 0x91DE, 0x9197, 0x93A6,
0xE790, 0x8B74, 0xE799, 0xE796, 0xE7A3, 0x93A7, 0x9280, 0xE793,
0x92FC, 0x9372, 0xE794, 0xE798, 0x9080, 0x9487, 0x92CA, 0x90C0,
0xE797, 0x91AC, 0x91A2, 0xE795, 0x88A7, 0x9841, 0xE79A, 0x91DF,
0x8F54, 0x9069, 0xE79C, 0xE79B, 0x88ED, 0xE79D, 0x954E, 0xE7A5,
0x93D9, 0x908B, 0x9278, 0x8BF6, 0xE7A4, 0x9756, 0x895E, 0x95D5,
0x89DF, 0xE79F, 0xE7A0, 0xE7A1, 0xE7A2, 0x93B9, 0x9242, 0x88E1,
0xE7A6, 0xE7A7, 0xEAA1, 0x91BB, 0xE7A8, 0x8993, 0x916B, 0x8CAD,
0x9779, 0xE7A9, 0x934B, 0x9198, 0x8ED5, 0xE7AA, 0xE7AD, 0x8F85,
0xE7AB, 0x914A, 0x9149, 0x88E2, 0x97C9, 0xE7AF, 0x94F0, 0xE7B1,
0xE7B0, 0xE7AE, 0xE284, 0x8AD2, 0xE78E, 0xE7B3, 0xE7B2, 0xE7B4,
0x9757, 0x93DF, 0x964D, 0xE7B5, 0x8ED7, 0xE7B6, 0xE7B7, 0xE7B8,
0x9340, 0x88E8, 0x8D78, 0x9859, 0xE7BC, 0x8C53, 0xE7B9, 0xE7BA,
0x9594, 0x8A73, 0x9758, 0x8BBD, 0x9373, 0xE7BD, 0xE7BE, 0xE7BF,
0x9341, 0xE7C1, 0xE7C0, 0x93D1, 0xE7C2, 0x8F55, 0x8EDE, 0x947A,
0x9291, 0x8EF0, 0x908C, 0xE7C3, 0xE7C4, 0x907C, 0xE7C5, 0xE7C6,
0xE7C7, 0x978F, 0x8F56, 0xE7C9, 0xE7C8, 0x8D79, 0x8D93, 0x8E5F,
0xE7CC, 0x8F86, 0xE7CB, 0xE7CA, 0x91E7, 0x8CED, 0x90C1, 0x94AE,
0x8F58, 0xE7CD, 0x8FDD, 0xE7D0, 0xE7CE, 0xE7CF, 0xE7D2, 0xE7D1,
0x8FF8, 0xE7D3, 0xE7D4, 0xE7D5, 0x94CE, 0x8DD1, 0x8EDF, 0xE7D6,
0xE7D7, 0x97A2, 0x8F64, 0x96EC, 0x97CA, 0xE7D8, 0x8BE0, 0xE7D9,
0x9342, 0xE7DC, 0x8A98, 0x906A, 0xE7DA, 0xE7DB, 0x92DE, 0x9674,
0x8BFA, 0xE7DE, 0xE7DF, 0xE7DD, 0xE7E1, 0x93DD, 0x8A62, 0xE7E5,
0xE7E2, 0xE7E4, 0xE7E0, 0xE86E, 0xE7E3, 0x97E9, 0x8CD8, 0xE7ED,
0x9353, 0xE7E8, 0xE7EB, 0xE7E9, 0xE7EE, 0xE7EF, 0xE7E7, 0xE7F4,
0x8994, 0xE7E6, 0x94AB, 0xE7EA, 0x8FDE, 0x8D7A, 0x9667, 0x8BE2,
0x8F65, 0x93BA, 0x914C, 0xE7F2, 0xE7EC, 0xE7F1, 0x96C1, 0x92B6,
0xE7F3, 0xE7F0, 0x914B, 0xE7F7, 0xE7F6, 0xE7F5, 0x964E, 0x8F9B,
0xE7F8, 0x95DD, 0x8973, 0x9565, 0x9292, 0x8B98, 0xE7FA, 0x8D7C,
0x8E4B, 0xE7F9, 0x908D, 0x908E, 0xE840, 0xE842, 0x8FF9, 0xE841,
0xE843, 0x8BD1, 0x9564, 0x8EE0, 0x9842, 0xE7FC, 0x8DF6, 0x985E,
0xE845, 0xE844, 0xE846, 0xE7FB, 0x93E7, 0x9374, 0x92D5, 0xE84B,
0x9262, 0xE847, 0xE848, 0x8C4C, 0xE84A, 0x8CAE, 0xE849, 0x8FDF,
0x8A99, 0xE84F, 0x8DBD, 0x9199, 0x92C8, 0x8A5A, 0xE84D, 0xE84E,
0x92C1, 0xE84C, 0xE850, 0xE856, 0xE859, 0xE858, 0x934C, 0xE851,
0xE852, 0xE855, 0xE857, 0x8BBE, 0xE85A, 0xE854, 0xE853, 0xE85E,
0xE85F, 0xE860, 0xE85D, 0xE85C, 0x8FE0, 0x93A8, 0xE85B, 0xE864,
0xE862, 0xE863, 0xE861, 0x91F6, 0xE865, 0xE866, 0xE868, 0x8AD3,
0xE867, 0x96F8, 0xE873, 0xE869, 0xE86C, 0xE86A, 0xE86B, 0xE86D,
0xE86F, 0xE870, 0xE871, 0xE874, 0xE872, 0xE875, 0xE877, 0xE876,
0x92B7, 0x96E5, 0xE878, 0x914D, 0xE879, 0x95C2, 0xE87A, 0x8A4A,
0x895B, 0x8AD5, 0x8AD4, 0xE87B, 0xE87C, 0xE87D, 0xE87E, 0xE880,
0x8AD6, 0x8A74, 0x8D7D, 0x94B4, 0xE882, 0xE881, 0xE883, 0x897B,
0xE886, 0xE885, 0xE884, 0xE887, 0xE88A, 0x88C5, 0xE888, 0xE88C,
0xE88B, 0xE88E, 0xE88D, 0xE88F, 0x93AC, 0xE890, 0xE891, 0xE893,
0xE892, 0x958C, 0xE894, 0xE895, 0x8DE3, 0xE896, 0xE897, 0x9668,
0x916A, 0x88A2, 0x91C9, 0xE898, 0x958D, 0xE89B, 0xE899, 0x8D7E,
0xE89A, 0x8CC0, 0x95C3, 0xE89D, 0xE89F, 0xE89E, 0xE8A0, 0x8940,
0x9077, 0x8F9C, 0x8AD7, 0xE8A1, 0x9486, 0xE8A3, 0x8941, 0xE8A2,
0x92C2, 0x97CB, 0x93A9, 0xE89C, 0x97A4, 0x8CAF, 0x977A, 0x8BF7,
0x97B2, 0x8C47, 0x91E0, 0xE440, 0xE8A4, 0x8A4B, 0x908F, 0x8A75,
0xE8A6, 0xE8A7, 0xE8A5, 0x8C84, 0x8DDB, 0x8FE1, 0x8942, 0x97D7,
0xE8A9, 0xE7AC, 0xE8A8, 0xE8AC, 0xE8AA, 0xE8AB, 0xE8AD, 0xE8AE,
0x97EA, 0xE8AF, 0xE8B0, 0x90C7, 0x94B9, 0x909D, 0x8AE5, 0x9759,
0x89EB, 0x8F57, 0x8CD9, 0xE8B3, 0xE8B2, 0x8E93, 0xE8B4, 0xE8B1,
0x8E47, 0xE8B8, 0xE5AB, 0x99D4, 0x9097, 0xE8B6, 0x97A3, 0x93EF,
0x894A, 0x90E1, 0x8EB4, 0x95B5, 0x895F, 0x97EB, 0x978B, 0xE8B9,
0x9364, 0x8EF9, 0xE8BA, 0xE8BB, 0x906B, 0xE8BC, 0x97EC, 0xE8B7,
0xE8BE, 0xE8C0, 0xE8BF, 0xE8BD, 0xE8C1, 0xE8C2, 0x919A, 0x89E0,
0xE8C3, 0x96B6, 0xE8C4, 0xE8C5, 0x9849, 0x9E50, 0xE8C6, 0xE8C7,
0xE8C8, 0xE8CC, 0xE8C9, 0xE8CA, 0xE8CB, 0xE8CD, 0x90C2, 0x96F5,
0x90C3, 0xE8CE, 0x94F1, 0xE8CF, 0xEA72, 0x96CA, 0xE8D0, 0xE8D1,
0xE8D2, 0x8A76, 0xE8D4, 0x9078, 0xE8D5, 0x8C43, 0xE8D6, 0xE8DA,
0xE8D8, 0xE8D9, 0x8A93, 0xE8D7, 0xE8DB, 0xE8DC, 0x88C6, 0xE8DD,
0xE8DE, 0x8FE2, 0xE8DF, 0x8B66, 0xE8E2, 0xE8E1, 0xE8E0, 0xE691,
0x95DA, 0xE8E3, 0xE8E4, 0xE8E5, 0xE8E6, 0xE8E7, 0xE8E8, 0x8AD8,
0xE8E9, 0xE8EA, 0x9442, 0xE8EC, 0x89B9, 0xE8EF, 0xE8EE, 0x8943,
0x8BBF, 0x95C5, 0x92B8, 0x8DA0, 0x8D80, 0x8F87, 0x907B, 0xE8F1,
0xE8F0, 0x9761, 0x8AE6, 0x94D0, 0x93DA, 0x909C, 0x97CC, 0x8C7A,
0xE8F4, 0xE8F3, 0x966A, 0x93AA, 0x896F, 0xE8F5, 0xE8F2, 0x9570,
0x978A, 0xE8F6, 0xE8F7, 0xE8F9, 0x91E8, 0x8A7A, 0x8A7B, 0xE8F8,
0x8AE7, 0x8CB0, 0x8AE8, 0x935E, 0x97DE, 0x8CDA, 0xE8FA, 0xE8FB,
0xE8FC, 0xE940, 0xE942, 0xE941, 0x9597, 0xE943, 0xE944, 0xE945,
0xE946, 0xE948, 0xE947, 0xE949, 0x94F2, 0xE3CA, 0x9048, 0x8B51,
0xE94A, 0xE94B, 0x99AA, 0x9F5A, 0x94D1, 0x88F9, 0x88B9, 0x8E94,
0x964F, 0x8FFC, 0xE94C, 0x96DD, 0xE94D, 0x977B, 0x8961, 0x8E60,
0xE94E, 0x89EC, 0xE94F, 0xE950, 0xE952, 0xE953, 0xE955, 0xE951,
0xE954, 0x8AD9, 0xE956, 0xE957, 0xE958, 0xE959, 0xE95A, 0xE95C,
0xE95B, 0xE95E, 0xE961, 0xE95D, 0xE95F, 0xE960, 0xE962, 0x8BC0,
0x8EF1, 0xE963, 0xE964, 0x8D81, 0xE965, 0x8A5D, 0x946E, 0xE966,
0xE967, 0x9279, 0x93E9, 0xE968, 0x949D, 0x91CA, 0x8977, 0x8BEC,
0x8BED, 0x9293, 0xE96D, 0x8BEE, 0x89ED, 0xE96C, 0xE96A, 0xE96B,
0xE969, 0xE977, 0xE96E, 0xE96F, 0xE970, 0xE971, 0xE973, 0xE972,
0x8F78, 0xE974, 0xE976, 0x8B52, 0xE975, 0x919B, 0x8CB1, 0xE978,
0x91CB, 0xE979, 0x93AB, 0xE97A, 0xE980, 0xE97D, 0xE97C, 0xE97E,
0xE97B, 0xE982, 0xE981, 0xE984, 0x8BC1, 0xE983, 0xE985, 0xE986,
0xE988, 0xE987, 0xE989, 0xE98B, 0xE98A, 0x8D9C, 0xE98C, 0xE98D,
0x8A5B, 0xE98E, 0xE98F, 0x9091, 0xE990, 0xE991, 0xE992, 0xE993,
0x8D82, 0xE994, 0xE995, 0xE996, 0xE997, 0xE998, 0x94AF, 0xE99A,
0x9545, 0xE99B, 0xE999, 0xE99D, 0xE99C, 0xE99E, 0xE99F, 0xE9A0,
0xE9A1, 0xE9A2, 0xE9A3, 0xE9A4, 0xE9A5, 0xE9A6, 0xE9A7, 0xE9A8,
0xE9A9, 0xE9AA, 0xE9AB, 0xE9AC, 0x9F54, 0xE9AD, 0xE2F6, 0x8B53,
0x8A40, 0x8DB0, 0xE9AF, 0xE9AE, 0x96A3, 0xE9B1, 0xE9B2, 0xE9B0,
0xE9B3, 0x9682, 0xE9B4, 0x8B9B, 0x9844, 0xE9B5, 0xE9B7, 0x88BC,
0xE9B8, 0x95A9, 0xE9B6, 0xE9B9, 0xE9BA, 0xE9BB, 0xE9BC, 0xE9BD,
0x968E, 0x8E4C, 0x8DF8, 0x914E, 0xE9BE, 0xE9C1, 0xE9BF, 0xE9C2,
0x8CEF, 0xE9C0, 0xE9C3, 0xE9C4, 0xE9C5, 0xE9C9, 0x8E49, 0x91E2,
0xE9CA, 0xE9C7, 0xE9C6, 0xE9C8, 0x8C7E, 0xE9CE, 0xE9CD, 0xE9CC,
0x88B1, 0xE9D8, 0xE9D4, 0xE9D5, 0xE9D1, 0xE9D7, 0xE9D3, 0x8A82,
0x986B, 0xE9D6, 0xE9D2, 0xE9D0, 0xE9CF, 0xE9DA, 0xE9DD, 0xE9DC,
0xE9DB, 0x9568, 0xE9D9, 0x88F1, 0xE9DE, 0xE9E0, 0x8A8F, 0xE9CB,
0x8956, 0xE9E2, 0xE9E1, 0xE9DF, 0x924C, 0x9690, 0x97D8, 0xE9E3,
0xE9E4, 0xE9E5, 0xE9E6, 0xE9E7, 0x92B9, 0xE9E8, 0x94B5, 0xE9ED,
0xE9E9, 0xE9EA, 0x9650, 0x96C2, 0x93CE, 0xE9EE, 0xE9EF, 0x93BC,
0xE9EC, 0xE9EB, 0x89A8, 0xE9F7, 0xE9F6, 0x8995, 0xE9F4, 0xE9F3,
0xE9F1, 0x8A9B, 0xE9F0, 0x8EB0, 0x89A7, 0x8D83, 0xE9FA, 0xE9F9,
0xE9F8, 0xE9F5, 0xE9FB, 0xE9FC, 0xEA44, 0xEA43, 0xEA45, 0x894C,
0xEA40, 0xEA41, 0x8D94, 0x96B7, 0xEA42, 0x9651, 0xEA4A, 0xEA46,
0xEA4B, 0xEA48, 0xEA47, 0x8C7B, 0xEA4C, 0xEA4D, 0xEA4E, 0xEA49,
0xE9F2, 0xEA4F, 0x92DF, 0xEA53, 0xEA54, 0xEA52, 0xEA51, 0xEA57,
0xEA50, 0xEA55, 0xEA56, 0xEA59, 0xEA58, 0xEA5B, 0xEA5C, 0xEA5D,
0x9868, 0xEA5A, 0x91E9, 0x8DEB, 0xEA5E, 0xEA5F, 0xEA60, 0xEA61,
0xEA62, 0x8CB2, 0xEA63, 0xEA64, 0x8EAD, 0xEA65, 0xEA66, 0xEA67,
0xEA68, 0xEA6B, 0xEA69, 0x985B, 0xEA6A, 0x97ED, 0xEA6C, 0x97D9,
0xEA6D, 0x949E, 0xEA6E, 0xEA70, 0xEA71, 0xEA6F, 0x8D8D, 0x96CB,
0x9683, 0x9BF5, 0x9F80, 0x969B, 0x89A9, 0xEA73, 0x8B6F, 0xEA74,
0xEA75, 0xEA76, 0x8D95, 0xEA77, 0xE0D2, 0x96D9, 0x91E1, 0xEA78,
0xEA7A, 0xEA79, 0xEA7B, 0xEA7C, 0xEA7D, 0xEA7E, 0xEA80, 0xEA81,
0xEA82, 0xEA83, 0xEA84, 0xEA85, 0xEA86, 0xEA87, 0xEA88, 0x9343,
0x8CDB, 0xEA8A, 0x916C, 0xEA8B, 0xEA8C, 0x9540, 0xEA8D, 0xEA8E,
0xE256, 0xE6D8, 0xE8EB, 0xEA8F, 0xEA90, 0xEA92, 0xEA93, 0xEA94,
0x97EE, 0xEA91, 0xEA95, 0xEA96, 0xEA98, 0xEA97, 0xEA9A, 0xEA9B,
0xEA99, 0x97B4, 0xEA9C, 0xEA9D, 0xE273, 0xEA9E, 0x8149, 0x8194,
0x8190, 0x8193, 0x8195, 0x8169, 0x816A, 0x8196, 0x817B, 0x8143,
0x8144, 0x815E, 0x824F, 0x8250, 0x8251, 0x8252, 0x8253, 0x8254,
0x8255, 0x8256, 0x8257, 0x8258, 0x8146, 0x8147, 0x8183, 0x8181,
0x8184, 0x8148, 0x8197, 0x8260, 0x8261, 0x8262, 0x8263, 0x8264,
0x8265, 0x8266, 0x8267, 0x8268, 0x8269, 0x826A, 0x826B, 0x826C,
0x826D, 0x826E, 0x826F, 0x8270, 0x8271, 0x8272, 0x8273, 0x8274,
0x8275, 0x8276, 0x8277, 0x8278, 0x8279, 0x816D, 0x816E, 0x814F,
0x8151, 0x814D, 0x8281, 0x8282, 0x8283, 0x8284, 0x8285, 0x8286,
0x8287, 0x8288, 0x8289, 0x828A, 0x828B, 0x828C, 0x828D, 0x828E,
0x828F, 0x8290, 0x8291, 0x8292, 0x8293, 0x8294, 0x8295, 0x8296,
0x8297, 0x8298, 0x8299, 0x829A, 0x816F, 0x8162, 0x8170, 0x00A1,
0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9,
0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0, 0x00B1,
0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9,
0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1,
0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9,
0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1,
0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9,
0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x8150, 0x818F,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Unicode values in multibyte order */
static const zueci_u16 zueci_sjis_mb_u[7808] = {
0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A, 0xFF1B,
0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8, 0xFF3E,
0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003, 0x4EDD,
0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F, 0x005C,
0x301C, 0x2016, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019, 0x201C,
0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D, 0xFF5B,
0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D, 0x300E,
0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7, 0x00F7,
0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E, 0x2234,
0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5, 0xFF04,
0x00A2, 0x00A3, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20, 0x00A7,
0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7, 0x25C6, 0x25A1,
0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC, 0x203B, 0x3012, 0x2192,
0x2190, 0x2191, 0x2193, 0x3013, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2208,
0x220B, 0x2286, 0x2287, 0x2282, 0x2283, 0x222A, 0x2229, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2227,
0x2228, 0x00AC, 0x21D2, 0x21D4, 0x2200, 0x2203, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x2220, 0x22A5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252,
0x226A, 0x226B, 0x221A, 0x223D, 0x221D, 0x2235, 0x222B, 0x222C,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x212B,
0x2030, 0x266F, 0x266D, 0x266A, 0x2020, 0x2021, 0x00B6, 0x0000,
0x0000, 0x0000, 0x0000, 0x25EF, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14,
0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000,
0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
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, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0391, 0x0392,
0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A,
0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3,
0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x03B1, 0x03B2,
0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3,
0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0410, 0x0411, 0x0412, 0x0413,
0x0414, 0x0415, 0x0401, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0430, 0x0431, 0x0432, 0x0433,
0x0434, 0x0435, 0x0451, 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, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x2500, 0x2502, 0x250C, 0x2510, 0x2518, 0x2514,
0x251C, 0x252C, 0x2524, 0x2534, 0x253C, 0x2501, 0x2503, 0x250F,
0x2513, 0x251B, 0x2517, 0x2523, 0x2533, 0x252B, 0x253B, 0x254B,
0x2520, 0x252F, 0x2528, 0x2537, 0x253F, 0x251D, 0x2530, 0x2525,
0x2538, 0x2542, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x4E9C, 0x5516, 0x5A03, 0x963F, 0x54C0, 0x611B,
0x6328, 0x59F6, 0x9022, 0x8475, 0x831C, 0x7A50, 0x60AA, 0x63E1,
0x6E25, 0x65ED, 0x8466, 0x82A6, 0x9BF5, 0x6893, 0x5727, 0x65A1,
0x6271, 0x5B9B, 0x59D0, 0x867B, 0x98F4, 0x7D62, 0x7DBE, 0x9B8E,
0x6216, 0x7C9F, 0x88B7, 0x5B89, 0x5EB5, 0x6309, 0x6697, 0x6848,
0x95C7, 0x978D, 0x674F, 0x4EE5, 0x4F0A, 0x4F4D, 0x4F9D, 0x5049,
0x56F2, 0x5937, 0x59D4, 0x5A01, 0x5C09, 0x60DF, 0x610F, 0x6170,
0x6613, 0x6905, 0x70BA, 0x754F, 0x7570, 0x79FB, 0x7DAD, 0x7DEF,
0x80C3, 0x840E, 0x8863, 0x8B02, 0x9055, 0x907A, 0x533B, 0x4E95,
0x4EA5, 0x57DF, 0x80B2, 0x90C1, 0x78EF, 0x4E00, 0x58F1, 0x6EA2,
0x9038, 0x7A32, 0x8328, 0x828B, 0x9C2F, 0x5141, 0x5370, 0x54BD,
0x54E1, 0x56E0, 0x59FB, 0x5F15, 0x98F2, 0x6DEB, 0x80E4, 0x852D,
0x9662, 0x9670, 0x96A0, 0x97FB, 0x540B, 0x53F3, 0x5B87, 0x70CF,
0x7FBD, 0x8FC2, 0x96E8, 0x536F, 0x9D5C, 0x7ABA, 0x4E11, 0x7893,
0x81FC, 0x6E26, 0x5618, 0x5504, 0x6B1D, 0x851A, 0x9C3B, 0x59E5,
0x53A9, 0x6D66, 0x74DC, 0x958F, 0x5642, 0x4E91, 0x904B, 0x96F2,
0x834F, 0x990C, 0x53E1, 0x55B6, 0x5B30, 0x5F71, 0x6620, 0x66F3,
0x6804, 0x6C38, 0x6CF3, 0x6D29, 0x745B, 0x76C8, 0x7A4E, 0x9834,
0x82F1, 0x885B, 0x8A60, 0x92ED, 0x6DB2, 0x75AB, 0x76CA, 0x99C5,
0x60A6, 0x8B01, 0x8D8A, 0x95B2, 0x698E, 0x53AD, 0x5186, 0x5712,
0x5830, 0x5944, 0x5BB4, 0x5EF6, 0x6028, 0x63A9, 0x63F4, 0x6CBF,
0x6F14, 0x708E, 0x7114, 0x7159, 0x71D5, 0x733F, 0x7E01, 0x8276,
0x82D1, 0x8597, 0x9060, 0x925B, 0x9D1B, 0x5869, 0x65BC, 0x6C5A,
0x7525, 0x51F9, 0x592E, 0x5965, 0x5F80, 0x5FDC, 0x62BC, 0x65FA,
0x6A2A, 0x6B27, 0x6BB4, 0x738B, 0x7FC1, 0x8956, 0x9D2C, 0x9D0E,
0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B, 0x61B6, 0x81C6,
0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x6069, 0x6E29, 0x7A4F,
0x97F3, 0x4E0B, 0x5316, 0x4EEE, 0x4F55, 0x4F3D, 0x4FA1, 0x4F73,
0x52A0, 0x53EF, 0x5609, 0x590F, 0x5AC1, 0x5BB6, 0x5BE1, 0x79D1,
0x6687, 0x679C, 0x67B6, 0x6B4C, 0x6CB3, 0x706B, 0x73C2, 0x798D,
0x79BE, 0x7A3C, 0x7B87, 0x82B1, 0x82DB, 0x8304, 0x8377, 0x83EF,
0x83D3, 0x8766, 0x8AB2, 0x5629, 0x8CA8, 0x8FE6, 0x904E, 0x971E,
0x868A, 0x4FC4, 0x5CE8, 0x6211, 0x7259, 0x753B, 0x81E5, 0x82BD,
0x86FE, 0x8CC0, 0x96C5, 0x9913, 0x99D5, 0x4ECB, 0x4F1A, 0x89E3,
0x56DE, 0x584A, 0x58CA, 0x5EFB, 0x5FEB, 0x602A, 0x6094, 0x6062,
0x61D0, 0x6212, 0x62D0, 0x6539, 0x9B41, 0x6666, 0x68B0, 0x6D77,
0x7070, 0x754C, 0x7686, 0x7D75, 0x82A5, 0x87F9, 0x958B, 0x968E,
0x8C9D, 0x51F1, 0x52BE, 0x5916, 0x54B3, 0x5BB3, 0x5D16, 0x6168,
0x6982, 0x6DAF, 0x788D, 0x84CB, 0x8857, 0x8A72, 0x93A7, 0x9AB8,
0x6D6C, 0x99A8, 0x86D9, 0x57A3, 0x67FF, 0x86CE, 0x920E, 0x5283,
0x5687, 0x5404, 0x5ED3, 0x62E1, 0x64B9, 0x683C, 0x6838, 0x6BBB,
0x7372, 0x78BA, 0x7A6B, 0x899A, 0x89D2, 0x8D6B, 0x8F03, 0x90ED,
0x95A3, 0x9694, 0x9769, 0x5B66, 0x5CB3, 0x697D, 0x984D, 0x984E,
0x639B, 0x7B20, 0x6A2B, 0x6A7F, 0x68B6, 0x9C0D, 0x6F5F, 0x5272,
0x559D, 0x6070, 0x62EC, 0x6D3B, 0x6E07, 0x6ED1, 0x845B, 0x8910,
0x8F44, 0x4E14, 0x9C39, 0x53F6, 0x691B, 0x6A3A, 0x9784, 0x682A,
0x515C, 0x7AC3, 0x84B2, 0x91DC, 0x938C, 0x565B, 0x9D28, 0x6822,
0x8305, 0x8431, 0x7CA5, 0x5208, 0x82C5, 0x74E6, 0x4E7E, 0x4F83,
0x51A0, 0x5BD2, 0x520A, 0x52D8, 0x52E7, 0x5DFB, 0x559A, 0x582A,
0x59E6, 0x5B8C, 0x5B98, 0x5BDB, 0x5E72, 0x5E79, 0x60A3, 0x611F,
0x6163, 0x61BE, 0x63DB, 0x6562, 0x67D1, 0x6853, 0x68FA, 0x6B3E,
0x6B53, 0x6C57, 0x6F22, 0x6F97, 0x6F45, 0x74B0, 0x7518, 0x76E3,
0x770B, 0x7AFF, 0x7BA1, 0x7C21, 0x7DE9, 0x7F36, 0x7FF0, 0x809D,
0x8266, 0x839E, 0x89B3, 0x8ACC, 0x8CAB, 0x9084, 0x9451, 0x9593,
0x9591, 0x95A2, 0x9665, 0x97D3, 0x9928, 0x8218, 0x4E38, 0x542B,
0x5CB8, 0x5DCC, 0x73A9, 0x764C, 0x773C, 0x5CA9, 0x7FEB, 0x8D0B,
0x96C1, 0x9811, 0x9854, 0x9858, 0x4F01, 0x4F0E, 0x5371, 0x559C,
0x5668, 0x57FA, 0x5947, 0x5B09, 0x5BC4, 0x5C90, 0x5E0C, 0x5E7E,
0x5FCC, 0x63EE, 0x673A, 0x65D7, 0x65E2, 0x671F, 0x68CB, 0x68C4,
0x6A5F, 0x5E30, 0x6BC5, 0x6C17, 0x6C7D, 0x757F, 0x7948, 0x5B63,
0x7A00, 0x7D00, 0x5FBD, 0x898F, 0x8A18, 0x8CB4, 0x8D77, 0x8ECC,
0x8F1D, 0x98E2, 0x9A0E, 0x9B3C, 0x4E80, 0x507D, 0x5100, 0x5993,
0x5B9C, 0x622F, 0x6280, 0x64EC, 0x6B3A, 0x72A0, 0x7591, 0x7947,
0x7FA9, 0x87FB, 0x8ABC, 0x8B70, 0x63AC, 0x83CA, 0x97A0, 0x5409,
0x5403, 0x55AB, 0x6854, 0x6A58, 0x8A70, 0x7827, 0x6775, 0x9ECD,
0x5374, 0x5BA2, 0x811A, 0x8650, 0x9006, 0x4E18, 0x4E45, 0x4EC7,
0x4F11, 0x53CA, 0x5438, 0x5BAE, 0x5F13, 0x6025, 0x6551, 0x673D,
0x6C42, 0x6C72, 0x6CE3, 0x7078, 0x7403, 0x7A76, 0x7AAE, 0x7B08,
0x7D1A, 0x7CFE, 0x7D66, 0x65E7, 0x725B, 0x53BB, 0x5C45, 0x5DE8,
0x62D2, 0x62E0, 0x6319, 0x6E20, 0x865A, 0x8A31, 0x8DDD, 0x92F8,
0x6F01, 0x79A6, 0x9B5A, 0x4EA8, 0x4EAB, 0x4EAC, 0x4F9B, 0x4FA0,
0x50D1, 0x5147, 0x7AF6, 0x5171, 0x51F6, 0x5354, 0x5321, 0x537F,
0x53EB, 0x55AC, 0x5883, 0x5CE1, 0x5F37, 0x5F4A, 0x602F, 0x6050,
0x606D, 0x631F, 0x6559, 0x6A4B, 0x6CC1, 0x72C2, 0x72ED, 0x77EF,
0x80F8, 0x8105, 0x8208, 0x854E, 0x90F7, 0x93E1, 0x97FF, 0x9957,
0x9A5A, 0x4EF0, 0x51DD, 0x5C2D, 0x6681, 0x696D, 0x5C40, 0x66F2,
0x6975, 0x7389, 0x6850, 0x7C81, 0x50C5, 0x52E4, 0x5747, 0x5DFE,
0x9326, 0x65A4, 0x6B23, 0x6B3D, 0x7434, 0x7981, 0x79BD, 0x7B4B,
0x7DCA, 0x82B9, 0x83CC, 0x887F, 0x895F, 0x8B39, 0x8FD1, 0x91D1,
0x541F, 0x9280, 0x4E5D, 0x5036, 0x53E5, 0x533A, 0x72D7, 0x7396,
0x77E9, 0x82E6, 0x8EAF, 0x99C6, 0x99C8, 0x99D2, 0x5177, 0x611A,
0x865E, 0x55B0, 0x7A7A, 0x5076, 0x5BD3, 0x9047, 0x9685, 0x4E32,
0x6ADB, 0x91E7, 0x5C51, 0x5C48, 0x6398, 0x7A9F, 0x6C93, 0x9774,
0x8F61, 0x7AAA, 0x718A, 0x9688, 0x7C82, 0x6817, 0x7E70, 0x6851,
0x936C, 0x52F2, 0x541B, 0x85AB, 0x8A13, 0x7FA4, 0x8ECD, 0x90E1,
0x5366, 0x8888, 0x7941, 0x4FC2, 0x50BE, 0x5211, 0x5144, 0x5553,
0x572D, 0x73EA, 0x578B, 0x5951, 0x5F62, 0x5F84, 0x6075, 0x6176,
0x6167, 0x61A9, 0x63B2, 0x643A, 0x656C, 0x666F, 0x6842, 0x6E13,
0x7566, 0x7A3D, 0x7CFB, 0x7D4C, 0x7D99, 0x7E4B, 0x7F6B, 0x830E,
0x834A, 0x86CD, 0x8A08, 0x8A63, 0x8B66, 0x8EFD, 0x981A, 0x9D8F,
0x82B8, 0x8FCE, 0x9BE8, 0x5287, 0x621F, 0x6483, 0x6FC0, 0x9699,
0x6841, 0x5091, 0x6B20, 0x6C7A, 0x6F54, 0x7A74, 0x7D50, 0x8840,
0x8A23, 0x6708, 0x4EF6, 0x5039, 0x5026, 0x5065, 0x517C, 0x5238,
0x5263, 0x55A7, 0x570F, 0x5805, 0x5ACC, 0x5EFA, 0x61B2, 0x61F8,
0x62F3, 0x6372, 0x691C, 0x6A29, 0x727D, 0x72AC, 0x732E, 0x7814,
0x786F, 0x7D79, 0x770C, 0x80A9, 0x898B, 0x8B19, 0x8CE2, 0x8ED2,
0x9063, 0x9375, 0x967A, 0x9855, 0x9A13, 0x9E78, 0x5143, 0x539F,
0x53B3, 0x5E7B, 0x5F26, 0x6E1B, 0x6E90, 0x7384, 0x73FE, 0x7D43,
0x8237, 0x8A00, 0x8AFA, 0x9650, 0x4E4E, 0x500B, 0x53E4, 0x547C,
0x56FA, 0x59D1, 0x5B64, 0x5DF1, 0x5EAB, 0x5F27, 0x6238, 0x6545,
0x67AF, 0x6E56, 0x72D0, 0x7CCA, 0x88B4, 0x80A1, 0x80E1, 0x83F0,
0x864E, 0x8A87, 0x8DE8, 0x9237, 0x96C7, 0x9867, 0x9F13, 0x4E94,
0x4E92, 0x4F0D, 0x5348, 0x5449, 0x543E, 0x5A2F, 0x5F8C, 0x5FA1,
0x609F, 0x68A7, 0x6A8E, 0x745A, 0x7881, 0x8A9E, 0x8AA4, 0x8B77,
0x9190, 0x4E5E, 0x9BC9, 0x4EA4, 0x4F7C, 0x4FAF, 0x5019, 0x5016,
0x5149, 0x516C, 0x529F, 0x52B9, 0x52FE, 0x539A, 0x53E3, 0x5411,
0x540E, 0x5589, 0x5751, 0x57A2, 0x597D, 0x5B54, 0x5B5D, 0x5B8F,
0x5DE5, 0x5DE7, 0x5DF7, 0x5E78, 0x5E83, 0x5E9A, 0x5EB7, 0x5F18,
0x6052, 0x614C, 0x6297, 0x62D8, 0x63A7, 0x653B, 0x6602, 0x6643,
0x66F4, 0x676D, 0x6821, 0x6897, 0x69CB, 0x6C5F, 0x6D2A, 0x6D69,
0x6E2F, 0x6E9D, 0x7532, 0x7687, 0x786C, 0x7A3F, 0x7CE0, 0x7D05,
0x7D18, 0x7D5E, 0x7DB1, 0x8015, 0x8003, 0x80AF, 0x80B1, 0x8154,
0x818F, 0x822A, 0x8352, 0x884C, 0x8861, 0x8B1B, 0x8CA2, 0x8CFC,
0x90CA, 0x9175, 0x9271, 0x783F, 0x92FC, 0x95A4, 0x964D, 0x9805,
0x9999, 0x9AD8, 0x9D3B, 0x525B, 0x52AB, 0x53F7, 0x5408, 0x58D5,
0x62F7, 0x6FE0, 0x8C6A, 0x8F5F, 0x9EB9, 0x514B, 0x523B, 0x544A,
0x56FD, 0x7A40, 0x9177, 0x9D60, 0x9ED2, 0x7344, 0x6F09, 0x8170,
0x7511, 0x5FFD, 0x60DA, 0x9AA8, 0x72DB, 0x8FBC, 0x6B64, 0x9803,
0x4ECA, 0x56F0, 0x5764, 0x58BE, 0x5A5A, 0x6068, 0x61C7, 0x660F,
0x6606, 0x6839, 0x68B1, 0x6DF7, 0x75D5, 0x7D3A, 0x826E, 0x9B42,
0x4E9B, 0x4F50, 0x53C9, 0x5506, 0x5D6F, 0x5DE6, 0x5DEE, 0x67FB,
0x6C99, 0x7473, 0x7802, 0x8A50, 0x9396, 0x88DF, 0x5750, 0x5EA7,
0x632B, 0x50B5, 0x50AC, 0x518D, 0x6700, 0x54C9, 0x585E, 0x59BB,
0x5BB0, 0x5F69, 0x624D, 0x63A1, 0x683D, 0x6B73, 0x6E08, 0x707D,
0x91C7, 0x7280, 0x7815, 0x7826, 0x796D, 0x658E, 0x7D30, 0x83DC,
0x88C1, 0x8F09, 0x969B, 0x5264, 0x5728, 0x6750, 0x7F6A, 0x8CA1,
0x51B4, 0x5742, 0x962A, 0x583A, 0x698A, 0x80B4, 0x54B2, 0x5D0E,
0x57FC, 0x7895, 0x9DFA, 0x4F5C, 0x524A, 0x548B, 0x643E, 0x6628,
0x6714, 0x67F5, 0x7A84, 0x7B56, 0x7D22, 0x932F, 0x685C, 0x9BAD,
0x7B39, 0x5319, 0x518A, 0x5237, 0x5BDF, 0x62F6, 0x64AE, 0x64E6,
0x672D, 0x6BBA, 0x85A9, 0x96D1, 0x7690, 0x9BD6, 0x634C, 0x9306,
0x9BAB, 0x76BF, 0x6652, 0x4E09, 0x5098, 0x53C2, 0x5C71, 0x60E8,
0x6492, 0x6563, 0x685F, 0x71E6, 0x73CA, 0x7523, 0x7B97, 0x7E82,
0x8695, 0x8B83, 0x8CDB, 0x9178, 0x9910, 0x65AC, 0x66AB, 0x6B8B,
0x4ED5, 0x4ED4, 0x4F3A, 0x4F7F, 0x523A, 0x53F8, 0x53F2, 0x55E3,
0x56DB, 0x58EB, 0x59CB, 0x59C9, 0x59FF, 0x5B50, 0x5C4D, 0x5E02,
0x5E2B, 0x5FD7, 0x601D, 0x6307, 0x652F, 0x5B5C, 0x65AF, 0x65BD,
0x65E8, 0x679D, 0x6B62, 0x6B7B, 0x6C0F, 0x7345, 0x7949, 0x79C1,
0x7CF8, 0x7D19, 0x7D2B, 0x80A2, 0x8102, 0x81F3, 0x8996, 0x8A5E,
0x8A69, 0x8A66, 0x8A8C, 0x8AEE, 0x8CC7, 0x8CDC, 0x96CC, 0x98FC,
0x6B6F, 0x4E8B, 0x4F3C, 0x4F8D, 0x5150, 0x5B57, 0x5BFA, 0x6148,
0x6301, 0x6642, 0x6B21, 0x6ECB, 0x6CBB, 0x723E, 0x74BD, 0x75D4,
0x78C1, 0x793A, 0x800C, 0x8033, 0x81EA, 0x8494, 0x8F9E, 0x6C50,
0x9E7F, 0x5F0F, 0x8B58, 0x9D2B, 0x7AFA, 0x8EF8, 0x5B8D, 0x96EB,
0x4E03, 0x53F1, 0x57F7, 0x5931, 0x5AC9, 0x5BA4, 0x6089, 0x6E7F,
0x6F06, 0x75BE, 0x8CEA, 0x5B9F, 0x8500, 0x7BE0, 0x5072, 0x67F4,
0x829D, 0x5C61, 0x854A, 0x7E1E, 0x820E, 0x5199, 0x5C04, 0x6368,
0x8D66, 0x659C, 0x716E, 0x793E, 0x7D17, 0x8005, 0x8B1D, 0x8ECA,
0x906E, 0x86C7, 0x90AA, 0x501F, 0x52FA, 0x5C3A, 0x6753, 0x707C,
0x7235, 0x914C, 0x91C8, 0x932B, 0x82E5, 0x5BC2, 0x5F31, 0x60F9,
0x4E3B, 0x53D6, 0x5B88, 0x624B, 0x6731, 0x6B8A, 0x72E9, 0x73E0,
0x7A2E, 0x816B, 0x8DA3, 0x9152, 0x9996, 0x5112, 0x53D7, 0x546A,
0x5BFF, 0x6388, 0x6A39, 0x7DAC, 0x9700, 0x56DA, 0x53CE, 0x5468,
0x5B97, 0x5C31, 0x5DDE, 0x4FEE, 0x6101, 0x62FE, 0x6D32, 0x79C0,
0x79CB, 0x7D42, 0x7E4D, 0x7FD2, 0x81ED, 0x821F, 0x8490, 0x8846,
0x8972, 0x8B90, 0x8E74, 0x8F2F, 0x9031, 0x914B, 0x916C, 0x96C6,
0x919C, 0x4EC0, 0x4F4F, 0x5145, 0x5341, 0x5F93, 0x620E, 0x67D4,
0x6C41, 0x6E0B, 0x7363, 0x7E26, 0x91CD, 0x9283, 0x53D4, 0x5919,
0x5BBF, 0x6DD1, 0x795D, 0x7E2E, 0x7C9B, 0x587E, 0x719F, 0x51FA,
0x8853, 0x8FF0, 0x4FCA, 0x5CFB, 0x6625, 0x77AC, 0x7AE3, 0x821C,
0x99FF, 0x51C6, 0x5FAA, 0x65EC, 0x696F, 0x6B89, 0x6DF3, 0x6E96,
0x6F64, 0x76FE, 0x7D14, 0x5DE1, 0x9075, 0x9187, 0x9806, 0x51E6,
0x521D, 0x6240, 0x6691, 0x66D9, 0x6E1A, 0x5EB6, 0x7DD2, 0x7F72,
0x66F8, 0x85AF, 0x85F7, 0x8AF8, 0x52A9, 0x53D9, 0x5973, 0x5E8F,
0x5F90, 0x6055, 0x92E4, 0x9664, 0x50B7, 0x511F, 0x52DD, 0x5320,
0x5347, 0x53EC, 0x54E8, 0x5546, 0x5531, 0x5617, 0x5968, 0x59BE,
0x5A3C, 0x5BB5, 0x5C06, 0x5C0F, 0x5C11, 0x5C1A, 0x5E84, 0x5E8A,
0x5EE0, 0x5F70, 0x627F, 0x6284, 0x62DB, 0x638C, 0x6377, 0x6607,
0x660C, 0x662D, 0x6676, 0x677E, 0x68A2, 0x6A1F, 0x6A35, 0x6CBC,
0x6D88, 0x6E09, 0x6E58, 0x713C, 0x7126, 0x7167, 0x75C7, 0x7701,
0x785D, 0x7901, 0x7965, 0x79F0, 0x7AE0, 0x7B11, 0x7CA7, 0x7D39,
0x8096, 0x83D6, 0x848B, 0x8549, 0x885D, 0x88F3, 0x8A1F, 0x8A3C,
0x8A54, 0x8A73, 0x8C61, 0x8CDE, 0x91A4, 0x9266, 0x937E, 0x9418,
0x969C, 0x9798, 0x4E0A, 0x4E08, 0x4E1E, 0x4E57, 0x5197, 0x5270,
0x57CE, 0x5834, 0x58CC, 0x5B22, 0x5E38, 0x60C5, 0x64FE, 0x6761,
0x6756, 0x6D44, 0x72B6, 0x7573, 0x7A63, 0x84B8, 0x8B72, 0x91B8,
0x9320, 0x5631, 0x57F4, 0x98FE, 0x62ED, 0x690D, 0x6B96, 0x71ED,
0x7E54, 0x8077, 0x8272, 0x89E6, 0x98DF, 0x8755, 0x8FB1, 0x5C3B,
0x4F38, 0x4FE1, 0x4FB5, 0x5507, 0x5A20, 0x5BDD, 0x5BE9, 0x5FC3,
0x614E, 0x632F, 0x65B0, 0x664B, 0x68EE, 0x699B, 0x6D78, 0x6DF1,
0x7533, 0x75B9, 0x771F, 0x795E, 0x79E6, 0x7D33, 0x81E3, 0x82AF,
0x85AA, 0x89AA, 0x8A3A, 0x8EAB, 0x8F9B, 0x9032, 0x91DD, 0x9707,
0x4EBA, 0x4EC1, 0x5203, 0x5875, 0x58EC, 0x5C0B, 0x751A, 0x5C3D,
0x814E, 0x8A0A, 0x8FC5, 0x9663, 0x976D, 0x7B25, 0x8ACF, 0x9808,
0x9162, 0x56F3, 0x53A8, 0x9017, 0x5439, 0x5782, 0x5E25, 0x63A8,
0x6C34, 0x708A, 0x7761, 0x7C8B, 0x7FE0, 0x8870, 0x9042, 0x9154,
0x9310, 0x9318, 0x968F, 0x745E, 0x9AC4, 0x5D07, 0x5D69, 0x6570,
0x67A2, 0x8DA8, 0x96DB, 0x636E, 0x6749, 0x6919, 0x83C5, 0x9817,
0x96C0, 0x88FE, 0x6F84, 0x647A, 0x5BF8, 0x4E16, 0x702C, 0x755D,
0x662F, 0x51C4, 0x5236, 0x52E2, 0x59D3, 0x5F81, 0x6027, 0x6210,
0x653F, 0x6574, 0x661F, 0x6674, 0x68F2, 0x6816, 0x6B63, 0x6E05,
0x7272, 0x751F, 0x76DB, 0x7CBE, 0x8056, 0x58F0, 0x88FD, 0x897F,
0x8AA0, 0x8A93, 0x8ACB, 0x901D, 0x9192, 0x9752, 0x9759, 0x6589,
0x7A0E, 0x8106, 0x96BB, 0x5E2D, 0x60DC, 0x621A, 0x65A5, 0x6614,
0x6790, 0x77F3, 0x7A4D, 0x7C4D, 0x7E3E, 0x810A, 0x8CAC, 0x8D64,
0x8DE1, 0x8E5F, 0x78A9, 0x5207, 0x62D9, 0x63A5, 0x6442, 0x6298,
0x8A2D, 0x7A83, 0x7BC0, 0x8AAC, 0x96EA, 0x7D76, 0x820C, 0x8749,
0x4ED9, 0x5148, 0x5343, 0x5360, 0x5BA3, 0x5C02, 0x5C16, 0x5DDD,
0x6226, 0x6247, 0x64B0, 0x6813, 0x6834, 0x6CC9, 0x6D45, 0x6D17,
0x67D3, 0x6F5C, 0x714E, 0x717D, 0x65CB, 0x7A7F, 0x7BAD, 0x7DDA,
0x7E4A, 0x7FA8, 0x817A, 0x821B, 0x8239, 0x85A6, 0x8A6E, 0x8CCE,
0x8DF5, 0x9078, 0x9077, 0x92AD, 0x9291, 0x9583, 0x9BAE, 0x524D,
0x5584, 0x6F38, 0x7136, 0x5168, 0x7985, 0x7E55, 0x81B3, 0x7CCE,
0x564C, 0x5851, 0x5CA8, 0x63AA, 0x66FE, 0x66FD, 0x695A, 0x72D9,
0x758F, 0x758E, 0x790E, 0x7956, 0x79DF, 0x7C97, 0x7D20, 0x7D44,
0x8607, 0x8A34, 0x963B, 0x9061, 0x9F20, 0x50E7, 0x5275, 0x53CC,
0x53E2, 0x5009, 0x55AA, 0x58EE, 0x594F, 0x723D, 0x5B8B, 0x5C64,
0x531D, 0x60E3, 0x60F3, 0x635C, 0x6383, 0x633F, 0x63BB, 0x64CD,
0x65E9, 0x66F9, 0x5DE3, 0x69CD, 0x69FD, 0x6F15, 0x71E5, 0x4E89,
0x75E9, 0x76F8, 0x7A93, 0x7CDF, 0x7DCF, 0x7D9C, 0x8061, 0x8349,
0x8358, 0x846C, 0x84BC, 0x85FB, 0x88C5, 0x8D70, 0x9001, 0x906D,
0x9397, 0x971C, 0x9A12, 0x50CF, 0x5897, 0x618E, 0x81D3, 0x8535,
0x8D08, 0x9020, 0x4FC3, 0x5074, 0x5247, 0x5373, 0x606F, 0x6349,
0x675F, 0x6E2C, 0x8DB3, 0x901F, 0x4FD7, 0x5C5E, 0x8CCA, 0x65CF,
0x7D9A, 0x5352, 0x8896, 0x5176, 0x63C3, 0x5B58, 0x5B6B, 0x5C0A,
0x640D, 0x6751, 0x905C, 0x4ED6, 0x591A, 0x592A, 0x6C70, 0x8A51,
0x553E, 0x5815, 0x59A5, 0x60F0, 0x6253, 0x67C1, 0x8235, 0x6955,
0x9640, 0x99C4, 0x9A28, 0x4F53, 0x5806, 0x5BFE, 0x8010, 0x5CB1,
0x5E2F, 0x5F85, 0x6020, 0x614B, 0x6234, 0x66FF, 0x6CF0, 0x6EDE,
0x80CE, 0x817F, 0x82D4, 0x888B, 0x8CB8, 0x9000, 0x902E, 0x968A,
0x9EDB, 0x9BDB, 0x4EE3, 0x53F0, 0x5927, 0x7B2C, 0x918D, 0x984C,
0x9DF9, 0x6EDD, 0x7027, 0x5353, 0x5544, 0x5B85, 0x6258, 0x629E,
0x62D3, 0x6CA2, 0x6FEF, 0x7422, 0x8A17, 0x9438, 0x6FC1, 0x8AFE,
0x8338, 0x51E7, 0x86F8, 0x53EA, 0x53E9, 0x4F46, 0x9054, 0x8FB0,
0x596A, 0x8131, 0x5DFD, 0x7AEA, 0x8FBF, 0x68DA, 0x8C37, 0x72F8,
0x9C48, 0x6A3D, 0x8AB0, 0x4E39, 0x5358, 0x5606, 0x5766, 0x62C5,
0x63A2, 0x65E6, 0x6B4E, 0x6DE1, 0x6E5B, 0x70AD, 0x77ED, 0x7AEF,
0x7BAA, 0x7DBB, 0x803D, 0x80C6, 0x86CB, 0x8A95, 0x935B, 0x56E3,
0x58C7, 0x5F3E, 0x65AD, 0x6696, 0x6A80, 0x6BB5, 0x7537, 0x8AC7,
0x5024, 0x77E5, 0x5730, 0x5F1B, 0x6065, 0x667A, 0x6C60, 0x75F4,
0x7A1A, 0x7F6E, 0x81F4, 0x8718, 0x9045, 0x99B3, 0x7BC9, 0x755C,
0x7AF9, 0x7B51, 0x84C4, 0x9010, 0x79E9, 0x7A92, 0x8336, 0x5AE1,
0x7740, 0x4E2D, 0x4EF2, 0x5B99, 0x5FE0, 0x62BD, 0x663C, 0x67F1,
0x6CE8, 0x866B, 0x8877, 0x8A3B, 0x914E, 0x92F3, 0x99D0, 0x6A17,
0x7026, 0x732A, 0x82E7, 0x8457, 0x8CAF, 0x4E01, 0x5146, 0x51CB,
0x558B, 0x5BF5, 0x5E16, 0x5E33, 0x5E81, 0x5F14, 0x5F35, 0x5F6B,
0x5FB4, 0x61F2, 0x6311, 0x66A2, 0x671D, 0x6F6E, 0x7252, 0x753A,
0x773A, 0x8074, 0x8139, 0x8178, 0x8776, 0x8ABF, 0x8ADC, 0x8D85,
0x8DF3, 0x929A, 0x9577, 0x9802, 0x9CE5, 0x52C5, 0x6357, 0x76F4,
0x6715, 0x6C88, 0x73CD, 0x8CC3, 0x93AE, 0x9673, 0x6D25, 0x589C,
0x690E, 0x69CC, 0x8FFD, 0x939A, 0x75DB, 0x901A, 0x585A, 0x6802,
0x63B4, 0x69FB, 0x4F43, 0x6F2C, 0x67D8, 0x8FBB, 0x8526, 0x7DB4,
0x9354, 0x693F, 0x6F70, 0x576A, 0x58F7, 0x5B2C, 0x7D2C, 0x722A,
0x540A, 0x91E3, 0x9DB4, 0x4EAD, 0x4F4E, 0x505C, 0x5075, 0x5243,
0x8C9E, 0x5448, 0x5824, 0x5B9A, 0x5E1D, 0x5E95, 0x5EAD, 0x5EF7,
0x5F1F, 0x608C, 0x62B5, 0x633A, 0x63D0, 0x68AF, 0x6C40, 0x7887,
0x798E, 0x7A0B, 0x7DE0, 0x8247, 0x8A02, 0x8AE6, 0x8E44, 0x9013,
0x90B8, 0x912D, 0x91D8, 0x9F0E, 0x6CE5, 0x6458, 0x64E2, 0x6575,
0x6EF4, 0x7684, 0x7B1B, 0x9069, 0x93D1, 0x6EBA, 0x54F2, 0x5FB9,
0x64A4, 0x8F4D, 0x8FED, 0x9244, 0x5178, 0x586B, 0x5929, 0x5C55,
0x5E97, 0x6DFB, 0x7E8F, 0x751C, 0x8CBC, 0x8EE2, 0x985B, 0x70B9,
0x4F1D, 0x6BBF, 0x6FB1, 0x7530, 0x96FB, 0x514E, 0x5410, 0x5835,
0x5857, 0x59AC, 0x5C60, 0x5F92, 0x6597, 0x675C, 0x6E21, 0x767B,
0x83DF, 0x8CED, 0x9014, 0x90FD, 0x934D, 0x7825, 0x783A, 0x52AA,
0x5EA6, 0x571F, 0x5974, 0x6012, 0x5012, 0x515A, 0x51AC, 0x51CD,
0x5200, 0x5510, 0x5854, 0x5858, 0x5957, 0x5B95, 0x5CF6, 0x5D8B,
0x60BC, 0x6295, 0x642D, 0x6771, 0x6843, 0x68BC, 0x68DF, 0x76D7,
0x6DD8, 0x6E6F, 0x6D9B, 0x706F, 0x71C8, 0x5F53, 0x75D8, 0x7977,
0x7B49, 0x7B54, 0x7B52, 0x7CD6, 0x7D71, 0x5230, 0x8463, 0x8569,
0x85E4, 0x8A0E, 0x8B04, 0x8C46, 0x8E0F, 0x9003, 0x900F, 0x9419,
0x9676, 0x982D, 0x9A30, 0x95D8, 0x50CD, 0x52D5, 0x540C, 0x5802,
0x5C0E, 0x61A7, 0x649E, 0x6D1E, 0x77B3, 0x7AE5, 0x80F4, 0x8404,
0x9053, 0x9285, 0x5CE0, 0x9D07, 0x533F, 0x5F97, 0x5FB3, 0x6D9C,
0x7279, 0x7763, 0x79BF, 0x7BE4, 0x6BD2, 0x72EC, 0x8AAD, 0x6803,
0x6A61, 0x51F8, 0x7A81, 0x6934, 0x5C4A, 0x9CF6, 0x82EB, 0x5BC5,
0x9149, 0x701E, 0x5678, 0x5C6F, 0x60C7, 0x6566, 0x6C8C, 0x8C5A,
0x9041, 0x9813, 0x5451, 0x66C7, 0x920D, 0x5948, 0x90A3, 0x5185,
0x4E4D, 0x51EA, 0x8599, 0x8B0E, 0x7058, 0x637A, 0x934B, 0x6962,
0x99B4, 0x7E04, 0x7577, 0x5357, 0x6960, 0x8EDF, 0x96E3, 0x6C5D,
0x4E8C, 0x5C3C, 0x5F10, 0x8FE9, 0x5302, 0x8CD1, 0x8089, 0x8679,
0x5EFF, 0x65E5, 0x4E73, 0x5165, 0x5982, 0x5C3F, 0x97EE, 0x4EFB,
0x598A, 0x5FCD, 0x8A8D, 0x6FE1, 0x79B0, 0x7962, 0x5BE7, 0x8471,
0x732B, 0x71B1, 0x5E74, 0x5FF5, 0x637B, 0x649A, 0x71C3, 0x7C98,
0x4E43, 0x5EFC, 0x4E4B, 0x57DC, 0x56A2, 0x60A9, 0x6FC3, 0x7D0D,
0x80FD, 0x8133, 0x81BF, 0x8FB2, 0x8997, 0x86A4, 0x5DF4, 0x628A,
0x64AD, 0x8987, 0x6777, 0x6CE2, 0x6D3E, 0x7436, 0x7834, 0x5A46,
0x7F75, 0x82AD, 0x99AC, 0x4FF3, 0x5EC3, 0x62DD, 0x6392, 0x6557,
0x676F, 0x76C3, 0x724C, 0x80CC, 0x80BA, 0x8F29, 0x914D, 0x500D,
0x57F9, 0x5A92, 0x6885, 0x6973, 0x7164, 0x72FD, 0x8CB7, 0x58F2,
0x8CE0, 0x966A, 0x9019, 0x877F, 0x79E4, 0x77E7, 0x8429, 0x4F2F,
0x5265, 0x535A, 0x62CD, 0x67CF, 0x6CCA, 0x767D, 0x7B94, 0x7C95,
0x8236, 0x8584, 0x8FEB, 0x66DD, 0x6F20, 0x7206, 0x7E1B, 0x83AB,
0x99C1, 0x9EA6, 0x51FD, 0x7BB1, 0x7872, 0x7BB8, 0x8087, 0x7B48,
0x6AE8, 0x5E61, 0x808C, 0x7551, 0x7560, 0x516B, 0x9262, 0x6E8C,
0x767A, 0x9197, 0x9AEA, 0x4F10, 0x7F70, 0x629C, 0x7B4F, 0x95A5,
0x9CE9, 0x567A, 0x5859, 0x86E4, 0x96BC, 0x4F34, 0x5224, 0x534A,
0x53CD, 0x53DB, 0x5E06, 0x642C, 0x6591, 0x677F, 0x6C3E, 0x6C4E,
0x7248, 0x72AF, 0x73ED, 0x7554, 0x7E41, 0x822C, 0x85E9, 0x8CA9,
0x7BC4, 0x91C6, 0x7169, 0x9812, 0x98EF, 0x633D, 0x6669, 0x756A,
0x76E4, 0x78D0, 0x8543, 0x86EE, 0x532A, 0x5351, 0x5426, 0x5983,
0x5E87, 0x5F7C, 0x60B2, 0x6249, 0x6279, 0x62AB, 0x6590, 0x6BD4,
0x6CCC, 0x75B2, 0x76AE, 0x7891, 0x79D8, 0x7DCB, 0x7F77, 0x80A5,
0x88AB, 0x8AB9, 0x8CBB, 0x907F, 0x975E, 0x98DB, 0x6A0B, 0x7C38,
0x5099, 0x5C3E, 0x5FAE, 0x6787, 0x6BD8, 0x7435, 0x7709, 0x7F8E,
0x9F3B, 0x67CA, 0x7A17, 0x5339, 0x758B, 0x9AED, 0x5F66, 0x819D,
0x83F1, 0x8098, 0x5F3C, 0x5FC5, 0x7562, 0x7B46, 0x903C, 0x6867,
0x59EB, 0x5A9B, 0x7D10, 0x767E, 0x8B2C, 0x4FF5, 0x5F6A, 0x6A19,
0x6C37, 0x6F02, 0x74E2, 0x7968, 0x8868, 0x8A55, 0x8C79, 0x5EDF,
0x63CF, 0x75C5, 0x79D2, 0x82D7, 0x9328, 0x92F2, 0x849C, 0x86ED,
0x9C2D, 0x54C1, 0x5F6C, 0x658C, 0x6D5C, 0x7015, 0x8CA7, 0x8CD3,
0x983B, 0x654F, 0x74F6, 0x4E0D, 0x4ED8, 0x57E0, 0x592B, 0x5A66,
0x5BCC, 0x51A8, 0x5E03, 0x5E9C, 0x6016, 0x6276, 0x6577, 0x65A7,
0x666E, 0x6D6E, 0x7236, 0x7B26, 0x8150, 0x819A, 0x8299, 0x8B5C,
0x8CA0, 0x8CE6, 0x8D74, 0x961C, 0x9644, 0x4FAE, 0x64AB, 0x6B66,
0x821E, 0x8461, 0x856A, 0x90E8, 0x5C01, 0x6953, 0x98A8, 0x847A,
0x8557, 0x4F0F, 0x526F, 0x5FA9, 0x5E45, 0x670D, 0x798F, 0x8179,
0x8907, 0x8986, 0x6DF5, 0x5F17, 0x6255, 0x6CB8, 0x4ECF, 0x7269,
0x9B92, 0x5206, 0x543B, 0x5674, 0x58B3, 0x61A4, 0x626E, 0x711A,
0x596E, 0x7C89, 0x7CDE, 0x7D1B, 0x96F0, 0x6587, 0x805E, 0x4E19,
0x4F75, 0x5175, 0x5840, 0x5E63, 0x5E73, 0x5F0A, 0x67C4, 0x4E26,
0x853D, 0x9589, 0x965B, 0x7C73, 0x9801, 0x50FB, 0x58C1, 0x7656,
0x78A7, 0x5225, 0x77A5, 0x8511, 0x7B86, 0x504F, 0x5909, 0x7247,
0x7BC7, 0x7DE8, 0x8FBA, 0x8FD4, 0x904D, 0x4FBF, 0x52C9, 0x5A29,
0x5F01, 0x97AD, 0x4FDD, 0x8217, 0x92EA, 0x5703, 0x6355, 0x6B69,
0x752B, 0x88DC, 0x8F14, 0x7A42, 0x52DF, 0x5893, 0x6155, 0x620A,
0x66AE, 0x6BCD, 0x7C3F, 0x83E9, 0x5023, 0x4FF8, 0x5305, 0x5446,
0x5831, 0x5949, 0x5B9D, 0x5CF0, 0x5CEF, 0x5D29, 0x5E96, 0x62B1,
0x6367, 0x653E, 0x65B9, 0x670B, 0x6CD5, 0x6CE1, 0x70F9, 0x7832,
0x7E2B, 0x80DE, 0x82B3, 0x840C, 0x84EC, 0x8702, 0x8912, 0x8A2A,
0x8C4A, 0x90A6, 0x92D2, 0x98FD, 0x9CF3, 0x9D6C, 0x4E4F, 0x4EA1,
0x508D, 0x5256, 0x574A, 0x59A8, 0x5E3D, 0x5FD8, 0x5FD9, 0x623F,
0x66B4, 0x671B, 0x67D0, 0x68D2, 0x5192, 0x7D21, 0x80AA, 0x81A8,
0x8B00, 0x8C8C, 0x8CBF, 0x927E, 0x9632, 0x5420, 0x982C, 0x5317,
0x50D5, 0x535C, 0x58A8, 0x64B2, 0x6734, 0x7267, 0x7766, 0x7A46,
0x91E6, 0x52C3, 0x6CA1, 0x6B86, 0x5800, 0x5E4C, 0x5954, 0x672C,
0x7FFB, 0x51E1, 0x76C6, 0x6469, 0x78E8, 0x9B54, 0x9EBB, 0x57CB,
0x59B9, 0x6627, 0x679A, 0x6BCE, 0x54E9, 0x69D9, 0x5E55, 0x819C,
0x6795, 0x9BAA, 0x67FE, 0x9C52, 0x685D, 0x4EA6, 0x4FE3, 0x53C8,
0x62B9, 0x672B, 0x6CAB, 0x8FC4, 0x4FAD, 0x7E6D, 0x9EBF, 0x4E07,
0x6162, 0x6E80, 0x6F2B, 0x8513, 0x5473, 0x672A, 0x9B45, 0x5DF3,
0x7B95, 0x5CAC, 0x5BC6, 0x871C, 0x6E4A, 0x84D1, 0x7A14, 0x8108,
0x5999, 0x7C8D, 0x6C11, 0x7720, 0x52D9, 0x5922, 0x7121, 0x725F,
0x77DB, 0x9727, 0x9D61, 0x690B, 0x5A7F, 0x5A18, 0x51A5, 0x540D,
0x547D, 0x660E, 0x76DF, 0x8FF7, 0x9298, 0x9CF4, 0x59EA, 0x725D,
0x6EC5, 0x514D, 0x68C9, 0x7DBF, 0x7DEC, 0x9762, 0x9EBA, 0x6478,
0x6A21, 0x8302, 0x5984, 0x5B5F, 0x6BDB, 0x731B, 0x76F2, 0x7DB2,
0x8017, 0x8499, 0x5132, 0x6728, 0x9ED9, 0x76EE, 0x6762, 0x52FF,
0x9905, 0x5C24, 0x623B, 0x7C7E, 0x8CB0, 0x554F, 0x60B6, 0x7D0B,
0x9580, 0x5301, 0x4E5F, 0x51B6, 0x591C, 0x723A, 0x8036, 0x91CE,
0x5F25, 0x77E2, 0x5384, 0x5F79, 0x7D04, 0x85AC, 0x8A33, 0x8E8D,
0x9756, 0x67F3, 0x85AE, 0x9453, 0x6109, 0x6108, 0x6CB9, 0x7652,
0x8AED, 0x8F38, 0x552F, 0x4F51, 0x512A, 0x52C7, 0x53CB, 0x5BA5,
0x5E7D, 0x60A0, 0x6182, 0x63D6, 0x6709, 0x67DA, 0x6E67, 0x6D8C,
0x7336, 0x7337, 0x7531, 0x7950, 0x88D5, 0x8A98, 0x904A, 0x9091,
0x90F5, 0x96C4, 0x878D, 0x5915, 0x4E88, 0x4F59, 0x4E0E, 0x8A89,
0x8F3F, 0x9810, 0x50AD, 0x5E7C, 0x5996, 0x5BB9, 0x5EB8, 0x63DA,
0x63FA, 0x64C1, 0x66DC, 0x694A, 0x69D8, 0x6D0B, 0x6EB6, 0x7194,
0x7528, 0x7AAF, 0x7F8A, 0x8000, 0x8449, 0x84C9, 0x8981, 0x8B21,
0x8E0A, 0x9065, 0x967D, 0x990A, 0x617E, 0x6291, 0x6B32, 0x6C83,
0x6D74, 0x7FCC, 0x7FFC, 0x6DC0, 0x7F85, 0x87BA, 0x88F8, 0x6765,
0x83B1, 0x983C, 0x96F7, 0x6D1B, 0x7D61, 0x843D, 0x916A, 0x4E71,
0x5375, 0x5D50, 0x6B04, 0x6FEB, 0x85CD, 0x862D, 0x89A7, 0x5229,
0x540F, 0x5C65, 0x674E, 0x68A8, 0x7406, 0x7483, 0x75E2, 0x88CF,
0x88E1, 0x91CC, 0x96E2, 0x9678, 0x5F8B, 0x7387, 0x7ACB, 0x844E,
0x63A0, 0x7565, 0x5289, 0x6D41, 0x6E9C, 0x7409, 0x7559, 0x786B,
0x7C92, 0x9686, 0x7ADC, 0x9F8D, 0x4FB6, 0x616E, 0x65C5, 0x865C,
0x4E86, 0x4EAE, 0x50DA, 0x4E21, 0x51CC, 0x5BEE, 0x6599, 0x6881,
0x6DBC, 0x731F, 0x7642, 0x77AD, 0x7A1C, 0x7CE7, 0x826F, 0x8AD2,
0x907C, 0x91CF, 0x9675, 0x9818, 0x529B, 0x7DD1, 0x502B, 0x5398,
0x6797, 0x6DCB, 0x71D0, 0x7433, 0x81E8, 0x8F2A, 0x96A3, 0x9C57,
0x9E9F, 0x7460, 0x5841, 0x6D99, 0x7D2F, 0x985E, 0x4EE4, 0x4F36,
0x4F8B, 0x51B7, 0x52B1, 0x5DBA, 0x601C, 0x73B2, 0x793C, 0x82D3,
0x9234, 0x96B7, 0x96F6, 0x970A, 0x9E97, 0x9F62, 0x66A6, 0x6B74,
0x5217, 0x52A3, 0x70C8, 0x88C2, 0x5EC9, 0x604B, 0x6190, 0x6F23,
0x7149, 0x7C3E, 0x7DF4, 0x806F, 0x84EE, 0x9023, 0x932C, 0x5442,
0x9B6F, 0x6AD3, 0x7089, 0x8CC2, 0x8DEF, 0x9732, 0x52B4, 0x5A41,
0x5ECA, 0x5F04, 0x6717, 0x697C, 0x6994, 0x6D6A, 0x6F0F, 0x7262,
0x72FC, 0x7BED, 0x8001, 0x807E, 0x874B, 0x90CE, 0x516D, 0x9E93,
0x7984, 0x808B, 0x9332, 0x8AD6, 0x502D, 0x548C, 0x8A71, 0x6B6A,
0x8CC4, 0x8107, 0x60D1, 0x67A0, 0x9DF2, 0x4E99, 0x4E98, 0x9C10,
0x8A6B, 0x85C1, 0x8568, 0x6900, 0x6E7E, 0x7897, 0x8155, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x5F0C, 0x4E10, 0x4E15, 0x4E2A, 0x4E31, 0x4E36,
0x4E3C, 0x4E3F, 0x4E42, 0x4E56, 0x4E58, 0x4E82, 0x4E85, 0x8C6B,
0x4E8A, 0x8212, 0x5F0D, 0x4E8E, 0x4E9E, 0x4E9F, 0x4EA0, 0x4EA2,
0x4EB0, 0x4EB3, 0x4EB6, 0x4ECE, 0x4ECD, 0x4EC4, 0x4EC6, 0x4EC2,
0x4ED7, 0x4EDE, 0x4EED, 0x4EDF, 0x4EF7, 0x4F09, 0x4F5A, 0x4F30,
0x4F5B, 0x4F5D, 0x4F57, 0x4F47, 0x4F76, 0x4F88, 0x4F8F, 0x4F98,
0x4F7B, 0x4F69, 0x4F70, 0x4F91, 0x4F6F, 0x4F86, 0x4F96, 0x5118,
0x4FD4, 0x4FDF, 0x4FCE, 0x4FD8, 0x4FDB, 0x4FD1, 0x4FDA, 0x4FD0,
0x4FE4, 0x4FE5, 0x501A, 0x5028, 0x5014, 0x502A, 0x5025, 0x5005,
0x4F1C, 0x4FF6, 0x5021, 0x5029, 0x502C, 0x4FFE, 0x4FEF, 0x5011,
0x5006, 0x5043, 0x5047, 0x6703, 0x5055, 0x5050, 0x5048, 0x505A,
0x5056, 0x506C, 0x5078, 0x5080, 0x509A, 0x5085, 0x50B4, 0x50B2,
0x50C9, 0x50CA, 0x50B3, 0x50C2, 0x50D6, 0x50DE, 0x50E5, 0x50ED,
0x50E3, 0x50EE, 0x50F9, 0x50F5, 0x5109, 0x5101, 0x5102, 0x5116,
0x5115, 0x5114, 0x511A, 0x5121, 0x513A, 0x5137, 0x513C, 0x513B,
0x513F, 0x5140, 0x5152, 0x514C, 0x5154, 0x5162, 0x7AF8, 0x5169,
0x516A, 0x516E, 0x5180, 0x5182, 0x56D8, 0x518C, 0x5189, 0x518F,
0x5191, 0x5193, 0x5195, 0x5196, 0x51A4, 0x51A6, 0x51A2, 0x51A9,
0x51AA, 0x51AB, 0x51B3, 0x51B1, 0x51B2, 0x51B0, 0x51B5, 0x51BD,
0x51C5, 0x51C9, 0x51DB, 0x51E0, 0x8655, 0x51E9, 0x51ED, 0x51F0,
0x51F5, 0x51FE, 0x5204, 0x520B, 0x5214, 0x520E, 0x5227, 0x522A,
0x522E, 0x5233, 0x5239, 0x524F, 0x5244, 0x524B, 0x524C, 0x525E,
0x5254, 0x526A, 0x5274, 0x5269, 0x5273, 0x527F, 0x527D, 0x528D,
0x5294, 0x5292, 0x5271, 0x5288, 0x5291, 0x8FA8, 0x8FA7, 0x52AC,
0x52AD, 0x52BC, 0x52B5, 0x52C1, 0x52CD, 0x52D7, 0x52DE, 0x52E3,
0x52E6, 0x98ED, 0x52E0, 0x52F3, 0x52F5, 0x52F8, 0x52F9, 0x5306,
0x5308, 0x7538, 0x530D, 0x5310, 0x530F, 0x5315, 0x531A, 0x5323,
0x532F, 0x5331, 0x5333, 0x5338, 0x5340, 0x5346, 0x5345, 0x4E17,
0x5349, 0x534D, 0x51D6, 0x535E, 0x5369, 0x536E, 0x5918, 0x537B,
0x5377, 0x5382, 0x5396, 0x53A0, 0x53A6, 0x53A5, 0x53AE, 0x53B0,
0x53B6, 0x53C3, 0x7C12, 0x96D9, 0x53DF, 0x66FC, 0x71EE, 0x53EE,
0x53E8, 0x53ED, 0x53FA, 0x5401, 0x543D, 0x5440, 0x542C, 0x542D,
0x543C, 0x542E, 0x5436, 0x5429, 0x541D, 0x544E, 0x548F, 0x5475,
0x548E, 0x545F, 0x5471, 0x5477, 0x5470, 0x5492, 0x547B, 0x5480,
0x5476, 0x5484, 0x5490, 0x5486, 0x54C7, 0x54A2, 0x54B8, 0x54A5,
0x54AC, 0x54C4, 0x54C8, 0x54A8, 0x54AB, 0x54C2, 0x54A4, 0x54BE,
0x54BC, 0x54D8, 0x54E5, 0x54E6, 0x550F, 0x5514, 0x54FD, 0x54EE,
0x54ED, 0x54FA, 0x54E2, 0x5539, 0x5540, 0x5563, 0x554C, 0x552E,
0x555C, 0x5545, 0x5556, 0x5557, 0x5538, 0x5533, 0x555D, 0x5599,
0x5580, 0x54AF, 0x558A, 0x559F, 0x557B, 0x557E, 0x5598, 0x559E,
0x55AE, 0x557C, 0x5583, 0x55A9, 0x5587, 0x55A8, 0x55DA, 0x55C5,
0x55DF, 0x55C4, 0x55DC, 0x55E4, 0x55D4, 0x5614, 0x55F7, 0x5616,
0x55FE, 0x55FD, 0x561B, 0x55F9, 0x564E, 0x5650, 0x71DF, 0x5634,
0x5636, 0x5632, 0x5638, 0x566B, 0x5664, 0x562F, 0x566C, 0x566A,
0x5686, 0x5680, 0x568A, 0x56A0, 0x5694, 0x568F, 0x56A5, 0x56AE,
0x56B6, 0x56B4, 0x56C2, 0x56BC, 0x56C1, 0x56C3, 0x56C0, 0x56C8,
0x56CE, 0x56D1, 0x56D3, 0x56D7, 0x56EE, 0x56F9, 0x5700, 0x56FF,
0x5704, 0x5709, 0x5708, 0x570B, 0x570D, 0x5713, 0x5718, 0x5716,
0x55C7, 0x571C, 0x5726, 0x5737, 0x5738, 0x574E, 0x573B, 0x5740,
0x574F, 0x5769, 0x57C0, 0x5788, 0x5761, 0x577F, 0x5789, 0x5793,
0x57A0, 0x57B3, 0x57A4, 0x57AA, 0x57B0, 0x57C3, 0x57C6, 0x57D4,
0x57D2, 0x57D3, 0x580A, 0x57D6, 0x57E3, 0x580B, 0x5819, 0x581D,
0x5872, 0x5821, 0x5862, 0x584B, 0x5870, 0x6BC0, 0x5852, 0x583D,
0x5879, 0x5885, 0x58B9, 0x589F, 0x58AB, 0x58BA, 0x58DE, 0x58BB,
0x58B8, 0x58AE, 0x58C5, 0x58D3, 0x58D1, 0x58D7, 0x58D9, 0x58D8,
0x58E5, 0x58DC, 0x58E4, 0x58DF, 0x58EF, 0x58FA, 0x58F9, 0x58FB,
0x58FC, 0x58FD, 0x5902, 0x590A, 0x5910, 0x591B, 0x68A6, 0x5925,
0x592C, 0x592D, 0x5932, 0x5938, 0x593E, 0x7AD2, 0x5955, 0x5950,
0x594E, 0x595A, 0x5958, 0x5962, 0x5960, 0x5967, 0x596C, 0x5969,
0x5978, 0x5981, 0x599D, 0x4F5E, 0x4FAB, 0x59A3, 0x59B2, 0x59C6,
0x59E8, 0x59DC, 0x598D, 0x59D9, 0x59DA, 0x5A25, 0x5A1F, 0x5A11,
0x5A1C, 0x5A09, 0x5A1A, 0x5A40, 0x5A6C, 0x5A49, 0x5A35, 0x5A36,
0x5A62, 0x5A6A, 0x5A9A, 0x5ABC, 0x5ABE, 0x5ACB, 0x5AC2, 0x5ABD,
0x5AE3, 0x5AD7, 0x5AE6, 0x5AE9, 0x5AD6, 0x5AFA, 0x5AFB, 0x5B0C,
0x5B0B, 0x5B16, 0x5B32, 0x5AD0, 0x5B2A, 0x5B36, 0x5B3E, 0x5B43,
0x5B45, 0x5B40, 0x5B51, 0x5B55, 0x5B5A, 0x5B5B, 0x5B65, 0x5B69,
0x5B70, 0x5B73, 0x5B75, 0x5B78, 0x6588, 0x5B7A, 0x5B80, 0x5B83,
0x5BA6, 0x5BB8, 0x5BC3, 0x5BC7, 0x5BC9, 0x5BD4, 0x5BD0, 0x5BE4,
0x5BE6, 0x5BE2, 0x5BDE, 0x5BE5, 0x5BEB, 0x5BF0, 0x5BF6, 0x5BF3,
0x5C05, 0x5C07, 0x5C08, 0x5C0D, 0x5C13, 0x5C20, 0x5C22, 0x5C28,
0x5C38, 0x5C39, 0x5C41, 0x5C46, 0x5C4E, 0x5C53, 0x5C50, 0x5C4F,
0x5B71, 0x5C6C, 0x5C6E, 0x4E62, 0x5C76, 0x5C79, 0x5C8C, 0x5C91,
0x5C94, 0x599B, 0x5CAB, 0x5CBB, 0x5CB6, 0x5CBC, 0x5CB7, 0x5CC5,
0x5CBE, 0x5CC7, 0x5CD9, 0x5CE9, 0x5CFD, 0x5CFA, 0x5CED, 0x5D8C,
0x5CEA, 0x5D0B, 0x5D15, 0x5D17, 0x5D5C, 0x5D1F, 0x5D1B, 0x5D11,
0x5D14, 0x5D22, 0x5D1A, 0x5D19, 0x5D18, 0x5D4C, 0x5D52, 0x5D4E,
0x5D4B, 0x5D6C, 0x5D73, 0x5D76, 0x5D87, 0x5D84, 0x5D82, 0x5DA2,
0x5D9D, 0x5DAC, 0x5DAE, 0x5DBD, 0x5D90, 0x5DB7, 0x5DBC, 0x5DC9,
0x5DCD, 0x5DD3, 0x5DD2, 0x5DD6, 0x5DDB, 0x5DEB, 0x5DF2, 0x5DF5,
0x5E0B, 0x5E1A, 0x5E19, 0x5E11, 0x5E1B, 0x5E36, 0x5E37, 0x5E44,
0x5E43, 0x5E40, 0x5E4E, 0x5E57, 0x5E54, 0x5E5F, 0x5E62, 0x5E64,
0x5E47, 0x5E75, 0x5E76, 0x5E7A, 0x9EBC, 0x5E7F, 0x5EA0, 0x5EC1,
0x5EC2, 0x5EC8, 0x5ED0, 0x5ECF, 0x5ED6, 0x5EE3, 0x5EDD, 0x5EDA,
0x5EDB, 0x5EE2, 0x5EE1, 0x5EE8, 0x5EE9, 0x5EEC, 0x5EF1, 0x5EF3,
0x5EF0, 0x5EF4, 0x5EF8, 0x5EFE, 0x5F03, 0x5F09, 0x5F5D, 0x5F5C,
0x5F0B, 0x5F11, 0x5F16, 0x5F29, 0x5F2D, 0x5F38, 0x5F41, 0x5F48,
0x5F4C, 0x5F4E, 0x5F2F, 0x5F51, 0x5F56, 0x5F57, 0x5F59, 0x5F61,
0x5F6D, 0x5F73, 0x5F77, 0x5F83, 0x5F82, 0x5F7F, 0x5F8A, 0x5F88,
0x5F91, 0x5F87, 0x5F9E, 0x5F99, 0x5F98, 0x5FA0, 0x5FA8, 0x5FAD,
0x5FBC, 0x5FD6, 0x5FFB, 0x5FE4, 0x5FF8, 0x5FF1, 0x5FDD, 0x60B3,
0x5FFF, 0x6021, 0x6060, 0x6019, 0x6010, 0x6029, 0x600E, 0x6031,
0x601B, 0x6015, 0x602B, 0x6026, 0x600F, 0x603A, 0x605A, 0x6041,
0x606A, 0x6077, 0x605F, 0x604A, 0x6046, 0x604D, 0x6063, 0x6043,
0x6064, 0x6042, 0x606C, 0x606B, 0x6059, 0x6081, 0x608D, 0x60E7,
0x6083, 0x609A, 0x6084, 0x609B, 0x6096, 0x6097, 0x6092, 0x60A7,
0x608B, 0x60E1, 0x60B8, 0x60E0, 0x60D3, 0x60B4, 0x5FF0, 0x60BD,
0x60C6, 0x60B5, 0x60D8, 0x614D, 0x6115, 0x6106, 0x60F6, 0x60F7,
0x6100, 0x60F4, 0x60FA, 0x6103, 0x6121, 0x60FB, 0x60F1, 0x610D,
0x610E, 0x6147, 0x613E, 0x6128, 0x6127, 0x614A, 0x613F, 0x613C,
0x612C, 0x6134, 0x613D, 0x6142, 0x6144, 0x6173, 0x6177, 0x6158,
0x6159, 0x615A, 0x616B, 0x6174, 0x616F, 0x6165, 0x6171, 0x615F,
0x615D, 0x6153, 0x6175, 0x6199, 0x6196, 0x6187, 0x61AC, 0x6194,
0x619A, 0x618A, 0x6191, 0x61AB, 0x61AE, 0x61CC, 0x61CA, 0x61C9,
0x61F7, 0x61C8, 0x61C3, 0x61C6, 0x61BA, 0x61CB, 0x7F79, 0x61CD,
0x61E6, 0x61E3, 0x61F6, 0x61FA, 0x61F4, 0x61FF, 0x61FD, 0x61FC,
0x61FE, 0x6200, 0x6208, 0x6209, 0x620D, 0x620C, 0x6214, 0x621B,
0x621E, 0x6221, 0x622A, 0x622E, 0x6230, 0x6232, 0x6233, 0x6241,
0x624E, 0x625E, 0x6263, 0x625B, 0x6260, 0x6268, 0x627C, 0x6282,
0x6289, 0x627E, 0x6292, 0x6293, 0x6296, 0x62D4, 0x6283, 0x6294,
0x62D7, 0x62D1, 0x62BB, 0x62CF, 0x62FF, 0x62C6, 0x64D4, 0x62C8,
0x62DC, 0x62CC, 0x62CA, 0x62C2, 0x62C7, 0x629B, 0x62C9, 0x630C,
0x62EE, 0x62F1, 0x6327, 0x6302, 0x6308, 0x62EF, 0x62F5, 0x6350,
0x633E, 0x634D, 0x641C, 0x634F, 0x6396, 0x638E, 0x6380, 0x63AB,
0x6376, 0x63A3, 0x638F, 0x6389, 0x639F, 0x63B5, 0x636B, 0x6369,
0x63BE, 0x63E9, 0x63C0, 0x63C6, 0x63E3, 0x63C9, 0x63D2, 0x63F6,
0x63C4, 0x6416, 0x6434, 0x6406, 0x6413, 0x6426, 0x6436, 0x651D,
0x6417, 0x6428, 0x640F, 0x6467, 0x646F, 0x6476, 0x644E, 0x652A,
0x6495, 0x6493, 0x64A5, 0x64A9, 0x6488, 0x64BC, 0x64DA, 0x64D2,
0x64C5, 0x64C7, 0x64BB, 0x64D8, 0x64C2, 0x64F1, 0x64E7, 0x8209,
0x64E0, 0x64E1, 0x62AC, 0x64E3, 0x64EF, 0x652C, 0x64F6, 0x64F4,
0x64F2, 0x64FA, 0x6500, 0x64FD, 0x6518, 0x651C, 0x6505, 0x6524,
0x6523, 0x652B, 0x6534, 0x6535, 0x6537, 0x6536, 0x6538, 0x754B,
0x6548, 0x6556, 0x6555, 0x654D, 0x6558, 0x655E, 0x655D, 0x6572,
0x6578, 0x6582, 0x6583, 0x8B8A, 0x659B, 0x659F, 0x65AB, 0x65B7,
0x65C3, 0x65C6, 0x65C1, 0x65C4, 0x65CC, 0x65D2, 0x65DB, 0x65D9,
0x65E0, 0x65E1, 0x65F1, 0x6772, 0x660A, 0x6603, 0x65FB, 0x6773,
0x6635, 0x6636, 0x6634, 0x661C, 0x664F, 0x6644, 0x6649, 0x6641,
0x665E, 0x665D, 0x6664, 0x6667, 0x6668, 0x665F, 0x6662, 0x6670,
0x6683, 0x6688, 0x668E, 0x6689, 0x6684, 0x6698, 0x669D, 0x66C1,
0x66B9, 0x66C9, 0x66BE, 0x66BC, 0x66C4, 0x66B8, 0x66D6, 0x66DA,
0x66E0, 0x663F, 0x66E6, 0x66E9, 0x66F0, 0x66F5, 0x66F7, 0x670F,
0x6716, 0x671E, 0x6726, 0x6727, 0x9738, 0x672E, 0x673F, 0x6736,
0x6741, 0x6738, 0x6737, 0x6746, 0x675E, 0x6760, 0x6759, 0x6763,
0x6764, 0x6789, 0x6770, 0x67A9, 0x677C, 0x676A, 0x678C, 0x678B,
0x67A6, 0x67A1, 0x6785, 0x67B7, 0x67EF, 0x67B4, 0x67EC, 0x67B3,
0x67E9, 0x67B8, 0x67E4, 0x67DE, 0x67DD, 0x67E2, 0x67EE, 0x67B9,
0x67CE, 0x67C6, 0x67E7, 0x6A9C, 0x681E, 0x6846, 0x6829, 0x6840,
0x684D, 0x6832, 0x684E, 0x68B3, 0x682B, 0x6859, 0x6863, 0x6877,
0x687F, 0x689F, 0x688F, 0x68AD, 0x6894, 0x689D, 0x689B, 0x6883,
0x6AAE, 0x68B9, 0x6874, 0x68B5, 0x68A0, 0x68BA, 0x690F, 0x688D,
0x687E, 0x6901, 0x68CA, 0x6908, 0x68D8, 0x6922, 0x6926, 0x68E1,
0x690C, 0x68CD, 0x68D4, 0x68E7, 0x68D5, 0x6936, 0x6912, 0x6904,
0x68D7, 0x68E3, 0x6925, 0x68F9, 0x68E0, 0x68EF, 0x6928, 0x692A,
0x691A, 0x6923, 0x6921, 0x68C6, 0x6979, 0x6977, 0x695C, 0x6978,
0x696B, 0x6954, 0x697E, 0x696E, 0x6939, 0x6974, 0x693D, 0x6959,
0x6930, 0x6961, 0x695E, 0x695D, 0x6981, 0x696A, 0x69B2, 0x69AE,
0x69D0, 0x69BF, 0x69C1, 0x69D3, 0x69BE, 0x69CE, 0x5BE8, 0x69CA,
0x69DD, 0x69BB, 0x69C3, 0x69A7, 0x6A2E, 0x6991, 0x69A0, 0x699C,
0x6995, 0x69B4, 0x69DE, 0x69E8, 0x6A02, 0x6A1B, 0x69FF, 0x6B0A,
0x69F9, 0x69F2, 0x69E7, 0x6A05, 0x69B1, 0x6A1E, 0x69ED, 0x6A14,
0x69EB, 0x6A0A, 0x6A12, 0x6AC1, 0x6A23, 0x6A13, 0x6A44, 0x6A0C,
0x6A72, 0x6A36, 0x6A78, 0x6A47, 0x6A62, 0x6A59, 0x6A66, 0x6A48,
0x6A38, 0x6A22, 0x6A90, 0x6A8D, 0x6AA0, 0x6A84, 0x6AA2, 0x6AA3,
0x6A97, 0x8617, 0x6ABB, 0x6AC3, 0x6AC2, 0x6AB8, 0x6AB3, 0x6AAC,
0x6ADE, 0x6AD1, 0x6ADF, 0x6AAA, 0x6ADA, 0x6AEA, 0x6AFB, 0x6B05,
0x8616, 0x6AFA, 0x6B12, 0x6B16, 0x9B31, 0x6B1F, 0x6B38, 0x6B37,
0x76DC, 0x6B39, 0x98EE, 0x6B47, 0x6B43, 0x6B49, 0x6B50, 0x6B59,
0x6B54, 0x6B5B, 0x6B5F, 0x6B61, 0x6B78, 0x6B79, 0x6B7F, 0x6B80,
0x6B84, 0x6B83, 0x6B8D, 0x6B98, 0x6B95, 0x6B9E, 0x6BA4, 0x6BAA,
0x6BAB, 0x6BAF, 0x6BB2, 0x6BB1, 0x6BB3, 0x6BB7, 0x6BBC, 0x6BC6,
0x6BCB, 0x6BD3, 0x6BDF, 0x6BEC, 0x6BEB, 0x6BF3, 0x6BEF, 0x9EBE,
0x6C08, 0x6C13, 0x6C14, 0x6C1B, 0x6C24, 0x6C23, 0x6C5E, 0x6C55,
0x6C62, 0x6C6A, 0x6C82, 0x6C8D, 0x6C9A, 0x6C81, 0x6C9B, 0x6C7E,
0x6C68, 0x6C73, 0x6C92, 0x6C90, 0x6CC4, 0x6CF1, 0x6CD3, 0x6CBD,
0x6CD7, 0x6CC5, 0x6CDD, 0x6CAE, 0x6CB1, 0x6CBE, 0x6CBA, 0x6CDB,
0x6CEF, 0x6CD9, 0x6CEA, 0x6D1F, 0x884D, 0x6D36, 0x6D2B, 0x6D3D,
0x6D38, 0x6D19, 0x6D35, 0x6D33, 0x6D12, 0x6D0C, 0x6D63, 0x6D93,
0x6D64, 0x6D5A, 0x6D79, 0x6D59, 0x6D8E, 0x6D95, 0x6FE4, 0x6D85,
0x6DF9, 0x6E15, 0x6E0A, 0x6DB5, 0x6DC7, 0x6DE6, 0x6DB8, 0x6DC6,
0x6DEC, 0x6DDE, 0x6DCC, 0x6DE8, 0x6DD2, 0x6DC5, 0x6DFA, 0x6DD9,
0x6DE4, 0x6DD5, 0x6DEA, 0x6DEE, 0x6E2D, 0x6E6E, 0x6E2E, 0x6E19,
0x6E72, 0x6E5F, 0x6E3E, 0x6E23, 0x6E6B, 0x6E2B, 0x6E76, 0x6E4D,
0x6E1F, 0x6E43, 0x6E3A, 0x6E4E, 0x6E24, 0x6EFF, 0x6E1D, 0x6E38,
0x6E82, 0x6EAA, 0x6E98, 0x6EC9, 0x6EB7, 0x6ED3, 0x6EBD, 0x6EAF,
0x6EC4, 0x6EB2, 0x6ED4, 0x6ED5, 0x6E8F, 0x6EA5, 0x6EC2, 0x6E9F,
0x6F41, 0x6F11, 0x704C, 0x6EEC, 0x6EF8, 0x6EFE, 0x6F3F, 0x6EF2,
0x6F31, 0x6EEF, 0x6F32, 0x6ECC, 0x6F3E, 0x6F13, 0x6EF7, 0x6F86,
0x6F7A, 0x6F78, 0x6F81, 0x6F80, 0x6F6F, 0x6F5B, 0x6FF3, 0x6F6D,
0x6F82, 0x6F7C, 0x6F58, 0x6F8E, 0x6F91, 0x6FC2, 0x6F66, 0x6FB3,
0x6FA3, 0x6FA1, 0x6FA4, 0x6FB9, 0x6FC6, 0x6FAA, 0x6FDF, 0x6FD5,
0x6FEC, 0x6FD4, 0x6FD8, 0x6FF1, 0x6FEE, 0x6FDB, 0x7009, 0x700B,
0x6FFA, 0x7011, 0x7001, 0x700F, 0x6FFE, 0x701B, 0x701A, 0x6F74,
0x701D, 0x7018, 0x701F, 0x7030, 0x703E, 0x7032, 0x7051, 0x7063,
0x7099, 0x7092, 0x70AF, 0x70F1, 0x70AC, 0x70B8, 0x70B3, 0x70AE,
0x70DF, 0x70CB, 0x70DD, 0x70D9, 0x7109, 0x70FD, 0x711C, 0x7119,
0x7165, 0x7155, 0x7188, 0x7166, 0x7162, 0x714C, 0x7156, 0x716C,
0x718F, 0x71FB, 0x7184, 0x7195, 0x71A8, 0x71AC, 0x71D7, 0x71B9,
0x71BE, 0x71D2, 0x71C9, 0x71D4, 0x71CE, 0x71E0, 0x71EC, 0x71E7,
0x71F5, 0x71FC, 0x71F9, 0x71FF, 0x720D, 0x7210, 0x721B, 0x7228,
0x722D, 0x722C, 0x7230, 0x7232, 0x723B, 0x723C, 0x723F, 0x7240,
0x7246, 0x724B, 0x7258, 0x7274, 0x727E, 0x7282, 0x7281, 0x7287,
0x7292, 0x7296, 0x72A2, 0x72A7, 0x72B9, 0x72B2, 0x72C3, 0x72C6,
0x72C4, 0x72CE, 0x72D2, 0x72E2, 0x72E0, 0x72E1, 0x72F9, 0x72F7,
0x500F, 0x7317, 0x730A, 0x731C, 0x7316, 0x731D, 0x7334, 0x732F,
0x7329, 0x7325, 0x733E, 0x734E, 0x734F, 0x9ED8, 0x7357, 0x736A,
0x7368, 0x7370, 0x7378, 0x7375, 0x737B, 0x737A, 0x73C8, 0x73B3,
0x73CE, 0x73BB, 0x73C0, 0x73E5, 0x73EE, 0x73DE, 0x74A2, 0x7405,
0x746F, 0x7425, 0x73F8, 0x7432, 0x743A, 0x7455, 0x743F, 0x745F,
0x7459, 0x7441, 0x745C, 0x7469, 0x7470, 0x7463, 0x746A, 0x7476,
0x747E, 0x748B, 0x749E, 0x74A7, 0x74CA, 0x74CF, 0x74D4, 0x73F1,
0x74E0, 0x74E3, 0x74E7, 0x74E9, 0x74EE, 0x74F2, 0x74F0, 0x74F1,
0x74F8, 0x74F7, 0x7504, 0x7503, 0x7505, 0x750C, 0x750E, 0x750D,
0x7515, 0x7513, 0x751E, 0x7526, 0x752C, 0x753C, 0x7544, 0x754D,
0x754A, 0x7549, 0x755B, 0x7546, 0x755A, 0x7569, 0x7564, 0x7567,
0x756B, 0x756D, 0x7578, 0x7576, 0x7586, 0x7587, 0x7574, 0x758A,
0x7589, 0x7582, 0x7594, 0x759A, 0x759D, 0x75A5, 0x75A3, 0x75C2,
0x75B3, 0x75C3, 0x75B5, 0x75BD, 0x75B8, 0x75BC, 0x75B1, 0x75CD,
0x75CA, 0x75D2, 0x75D9, 0x75E3, 0x75DE, 0x75FE, 0x75FF, 0x75FC,
0x7601, 0x75F0, 0x75FA, 0x75F2, 0x75F3, 0x760B, 0x760D, 0x7609,
0x761F, 0x7627, 0x7620, 0x7621, 0x7622, 0x7624, 0x7634, 0x7630,
0x763B, 0x7647, 0x7648, 0x7646, 0x765C, 0x7658, 0x7661, 0x7662,
0x7668, 0x7669, 0x766A, 0x7667, 0x766C, 0x7670, 0x7672, 0x7676,
0x7678, 0x767C, 0x7680, 0x7683, 0x7688, 0x768B, 0x768E, 0x7696,
0x7693, 0x7699, 0x769A, 0x76B0, 0x76B4, 0x76B8, 0x76B9, 0x76BA,
0x76C2, 0x76CD, 0x76D6, 0x76D2, 0x76DE, 0x76E1, 0x76E5, 0x76E7,
0x76EA, 0x862F, 0x76FB, 0x7708, 0x7707, 0x7704, 0x7729, 0x7724,
0x771E, 0x7725, 0x7726, 0x771B, 0x7737, 0x7738, 0x7747, 0x775A,
0x7768, 0x776B, 0x775B, 0x7765, 0x777F, 0x777E, 0x7779, 0x778E,
0x778B, 0x7791, 0x77A0, 0x779E, 0x77B0, 0x77B6, 0x77B9, 0x77BF,
0x77BC, 0x77BD, 0x77BB, 0x77C7, 0x77CD, 0x77D7, 0x77DA, 0x77DC,
0x77E3, 0x77EE, 0x77FC, 0x780C, 0x7812, 0x7926, 0x7820, 0x792A,
0x7845, 0x788E, 0x7874, 0x7886, 0x787C, 0x789A, 0x788C, 0x78A3,
0x78B5, 0x78AA, 0x78AF, 0x78D1, 0x78C6, 0x78CB, 0x78D4, 0x78BE,
0x78BC, 0x78C5, 0x78CA, 0x78EC, 0x78E7, 0x78DA, 0x78FD, 0x78F4,
0x7907, 0x7912, 0x7911, 0x7919, 0x792C, 0x792B, 0x7940, 0x7960,
0x7957, 0x795F, 0x795A, 0x7955, 0x7953, 0x797A, 0x797F, 0x798A,
0x799D, 0x79A7, 0x9F4B, 0x79AA, 0x79AE, 0x79B3, 0x79B9, 0x79BA,
0x79C9, 0x79D5, 0x79E7, 0x79EC, 0x79E1, 0x79E3, 0x7A08, 0x7A0D,
0x7A18, 0x7A19, 0x7A20, 0x7A1F, 0x7980, 0x7A31, 0x7A3B, 0x7A3E,
0x7A37, 0x7A43, 0x7A57, 0x7A49, 0x7A61, 0x7A62, 0x7A69, 0x9F9D,
0x7A70, 0x7A79, 0x7A7D, 0x7A88, 0x7A97, 0x7A95, 0x7A98, 0x7A96,
0x7AA9, 0x7AC8, 0x7AB0, 0x7AB6, 0x7AC5, 0x7AC4, 0x7ABF, 0x9083,
0x7AC7, 0x7ACA, 0x7ACD, 0x7ACF, 0x7AD5, 0x7AD3, 0x7AD9, 0x7ADA,
0x7ADD, 0x7AE1, 0x7AE2, 0x7AE6, 0x7AED, 0x7AF0, 0x7B02, 0x7B0F,
0x7B0A, 0x7B06, 0x7B33, 0x7B18, 0x7B19, 0x7B1E, 0x7B35, 0x7B28,
0x7B36, 0x7B50, 0x7B7A, 0x7B04, 0x7B4D, 0x7B0B, 0x7B4C, 0x7B45,
0x7B75, 0x7B65, 0x7B74, 0x7B67, 0x7B70, 0x7B71, 0x7B6C, 0x7B6E,
0x7B9D, 0x7B98, 0x7B9F, 0x7B8D, 0x7B9C, 0x7B9A, 0x7B8B, 0x7B92,
0x7B8F, 0x7B5D, 0x7B99, 0x7BCB, 0x7BC1, 0x7BCC, 0x7BCF, 0x7BB4,
0x7BC6, 0x7BDD, 0x7BE9, 0x7C11, 0x7C14, 0x7BE6, 0x7BE5, 0x7C60,
0x7C00, 0x7C07, 0x7C13, 0x7BF3, 0x7BF7, 0x7C17, 0x7C0D, 0x7BF6,
0x7C23, 0x7C27, 0x7C2A, 0x7C1F, 0x7C37, 0x7C2B, 0x7C3D, 0x7C4C,
0x7C43, 0x7C54, 0x7C4F, 0x7C40, 0x7C50, 0x7C58, 0x7C5F, 0x7C64,
0x7C56, 0x7C65, 0x7C6C, 0x7C75, 0x7C83, 0x7C90, 0x7CA4, 0x7CAD,
0x7CA2, 0x7CAB, 0x7CA1, 0x7CA8, 0x7CB3, 0x7CB2, 0x7CB1, 0x7CAE,
0x7CB9, 0x7CBD, 0x7CC0, 0x7CC5, 0x7CC2, 0x7CD8, 0x7CD2, 0x7CDC,
0x7CE2, 0x9B3B, 0x7CEF, 0x7CF2, 0x7CF4, 0x7CF6, 0x7CFA, 0x7D06,
0x7D02, 0x7D1C, 0x7D15, 0x7D0A, 0x7D45, 0x7D4B, 0x7D2E, 0x7D32,
0x7D3F, 0x7D35, 0x7D46, 0x7D73, 0x7D56, 0x7D4E, 0x7D72, 0x7D68,
0x7D6E, 0x7D4F, 0x7D63, 0x7D93, 0x7D89, 0x7D5B, 0x7D8F, 0x7D7D,
0x7D9B, 0x7DBA, 0x7DAE, 0x7DA3, 0x7DB5, 0x7DC7, 0x7DBD, 0x7DAB,
0x7E3D, 0x7DA2, 0x7DAF, 0x7DDC, 0x7DB8, 0x7D9F, 0x7DB0, 0x7DD8,
0x7DDD, 0x7DE4, 0x7DDE, 0x7DFB, 0x7DF2, 0x7DE1, 0x7E05, 0x7E0A,
0x7E23, 0x7E21, 0x7E12, 0x7E31, 0x7E1F, 0x7E09, 0x7E0B, 0x7E22,
0x7E46, 0x7E66, 0x7E3B, 0x7E35, 0x7E39, 0x7E43, 0x7E37, 0x7E32,
0x7E3A, 0x7E67, 0x7E5D, 0x7E56, 0x7E5E, 0x7E59, 0x7E5A, 0x7E79,
0x7E6A, 0x7E69, 0x7E7C, 0x7E7B, 0x7E83, 0x7DD5, 0x7E7D, 0x8FAE,
0x7E7F, 0x7E88, 0x7E89, 0x7E8C, 0x7E92, 0x7E90, 0x7E93, 0x7E94,
0x7E96, 0x7E8E, 0x7E9B, 0x7E9C, 0x7F38, 0x7F3A, 0x7F45, 0x7F4C,
0x7F4D, 0x7F4E, 0x7F50, 0x7F51, 0x7F55, 0x7F54, 0x7F58, 0x7F5F,
0x7F60, 0x7F68, 0x7F69, 0x7F67, 0x7F78, 0x7F82, 0x7F86, 0x7F83,
0x7F88, 0x7F87, 0x7F8C, 0x7F94, 0x7F9E, 0x7F9D, 0x7F9A, 0x7FA3,
0x7FAF, 0x7FB2, 0x7FB9, 0x7FAE, 0x7FB6, 0x7FB8, 0x8B71, 0x7FC5,
0x7FC6, 0x7FCA, 0x7FD5, 0x7FD4, 0x7FE1, 0x7FE6, 0x7FE9, 0x7FF3,
0x7FF9, 0x98DC, 0x8006, 0x8004, 0x800B, 0x8012, 0x8018, 0x8019,
0x801C, 0x8021, 0x8028, 0x803F, 0x803B, 0x804A, 0x8046, 0x8052,
0x8058, 0x805A, 0x805F, 0x8062, 0x8068, 0x8073, 0x8072, 0x8070,
0x8076, 0x8079, 0x807D, 0x807F, 0x8084, 0x8086, 0x8085, 0x809B,
0x8093, 0x809A, 0x80AD, 0x5190, 0x80AC, 0x80DB, 0x80E5, 0x80D9,
0x80DD, 0x80C4, 0x80DA, 0x80D6, 0x8109, 0x80EF, 0x80F1, 0x811B,
0x8129, 0x8123, 0x812F, 0x814B, 0x968B, 0x8146, 0x813E, 0x8153,
0x8151, 0x80FC, 0x8171, 0x816E, 0x8165, 0x8166, 0x8174, 0x8183,
0x8188, 0x818A, 0x8180, 0x8182, 0x81A0, 0x8195, 0x81A4, 0x81A3,
0x815F, 0x8193, 0x81A9, 0x81B0, 0x81B5, 0x81BE, 0x81B8, 0x81BD,
0x81C0, 0x81C2, 0x81BA, 0x81C9, 0x81CD, 0x81D1, 0x81D9, 0x81D8,
0x81C8, 0x81DA, 0x81DF, 0x81E0, 0x81E7, 0x81FA, 0x81FB, 0x81FE,
0x8201, 0x8202, 0x8205, 0x8207, 0x820A, 0x820D, 0x8210, 0x8216,
0x8229, 0x822B, 0x8238, 0x8233, 0x8240, 0x8259, 0x8258, 0x825D,
0x825A, 0x825F, 0x8264, 0x8262, 0x8268, 0x826A, 0x826B, 0x822E,
0x8271, 0x8277, 0x8278, 0x827E, 0x828D, 0x8292, 0x82AB, 0x829F,
0x82BB, 0x82AC, 0x82E1, 0x82E3, 0x82DF, 0x82D2, 0x82F4, 0x82F3,
0x82FA, 0x8393, 0x8303, 0x82FB, 0x82F9, 0x82DE, 0x8306, 0x82DC,
0x8309, 0x82D9, 0x8335, 0x8334, 0x8316, 0x8332, 0x8331, 0x8340,
0x8339, 0x8350, 0x8345, 0x832F, 0x832B, 0x8317, 0x8318, 0x8385,
0x839A, 0x83AA, 0x839F, 0x83A2, 0x8396, 0x8323, 0x838E, 0x8387,
0x838A, 0x837C, 0x83B5, 0x8373, 0x8375, 0x83A0, 0x8389, 0x83A8,
0x83F4, 0x8413, 0x83EB, 0x83CE, 0x83FD, 0x8403, 0x83D8, 0x840B,
0x83C1, 0x83F7, 0x8407, 0x83E0, 0x83F2, 0x840D, 0x8422, 0x8420,
0x83BD, 0x8438, 0x8506, 0x83FB, 0x846D, 0x842A, 0x843C, 0x855A,
0x8484, 0x8477, 0x846B, 0x84AD, 0x846E, 0x8482, 0x8469, 0x8446,
0x842C, 0x846F, 0x8479, 0x8435, 0x84CA, 0x8462, 0x84B9, 0x84BF,
0x849F, 0x84D9, 0x84CD, 0x84BB, 0x84DA, 0x84D0, 0x84C1, 0x84C6,
0x84D6, 0x84A1, 0x8521, 0x84FF, 0x84F4, 0x8517, 0x8518, 0x852C,
0x851F, 0x8515, 0x8514, 0x84FC, 0x8540, 0x8563, 0x8558, 0x8548,
0x8541, 0x8602, 0x854B, 0x8555, 0x8580, 0x85A4, 0x8588, 0x8591,
0x858A, 0x85A8, 0x856D, 0x8594, 0x859B, 0x85EA, 0x8587, 0x859C,
0x8577, 0x857E, 0x8590, 0x85C9, 0x85BA, 0x85CF, 0x85B9, 0x85D0,
0x85D5, 0x85DD, 0x85E5, 0x85DC, 0x85F9, 0x860A, 0x8613, 0x860B,
0x85FE, 0x85FA, 0x8606, 0x8622, 0x861A, 0x8630, 0x863F, 0x864D,
0x4E55, 0x8654, 0x865F, 0x8667, 0x8671, 0x8693, 0x86A3, 0x86A9,
0x86AA, 0x868B, 0x868C, 0x86B6, 0x86AF, 0x86C4, 0x86C6, 0x86B0,
0x86C9, 0x8823, 0x86AB, 0x86D4, 0x86DE, 0x86E9, 0x86EC, 0x86DF,
0x86DB, 0x86EF, 0x8712, 0x8706, 0x8708, 0x8700, 0x8703, 0x86FB,
0x8711, 0x8709, 0x870D, 0x86F9, 0x870A, 0x8734, 0x873F, 0x8737,
0x873B, 0x8725, 0x8729, 0x871A, 0x8760, 0x875F, 0x8778, 0x874C,
0x874E, 0x8774, 0x8757, 0x8768, 0x876E, 0x8759, 0x8753, 0x8763,
0x876A, 0x8805, 0x87A2, 0x879F, 0x8782, 0x87AF, 0x87CB, 0x87BD,
0x87C0, 0x87D0, 0x96D6, 0x87AB, 0x87C4, 0x87B3, 0x87C7, 0x87C6,
0x87BB, 0x87EF, 0x87F2, 0x87E0, 0x880F, 0x880D, 0x87FE, 0x87F6,
0x87F7, 0x880E, 0x87D2, 0x8811, 0x8816, 0x8815, 0x8822, 0x8821,
0x8831, 0x8836, 0x8839, 0x8827, 0x883B, 0x8844, 0x8842, 0x8852,
0x8859, 0x885E, 0x8862, 0x886B, 0x8881, 0x887E, 0x889E, 0x8875,
0x887D, 0x88B5, 0x8872, 0x8882, 0x8897, 0x8892, 0x88AE, 0x8899,
0x88A2, 0x888D, 0x88A4, 0x88B0, 0x88BF, 0x88B1, 0x88C3, 0x88C4,
0x88D4, 0x88D8, 0x88D9, 0x88DD, 0x88F9, 0x8902, 0x88FC, 0x88F4,
0x88E8, 0x88F2, 0x8904, 0x890C, 0x890A, 0x8913, 0x8943, 0x891E,
0x8925, 0x892A, 0x892B, 0x8941, 0x8944, 0x893B, 0x8936, 0x8938,
0x894C, 0x891D, 0x8960, 0x895E, 0x8966, 0x8964, 0x896D, 0x896A,
0x896F, 0x8974, 0x8977, 0x897E, 0x8983, 0x8988, 0x898A, 0x8993,
0x8998, 0x89A1, 0x89A9, 0x89A6, 0x89AC, 0x89AF, 0x89B2, 0x89BA,
0x89BD, 0x89BF, 0x89C0, 0x89DA, 0x89DC, 0x89DD, 0x89E7, 0x89F4,
0x89F8, 0x8A03, 0x8A16, 0x8A10, 0x8A0C, 0x8A1B, 0x8A1D, 0x8A25,
0x8A36, 0x8A41, 0x8A5B, 0x8A52, 0x8A46, 0x8A48, 0x8A7C, 0x8A6D,
0x8A6C, 0x8A62, 0x8A85, 0x8A82, 0x8A84, 0x8AA8, 0x8AA1, 0x8A91,
0x8AA5, 0x8AA6, 0x8A9A, 0x8AA3, 0x8AC4, 0x8ACD, 0x8AC2, 0x8ADA,
0x8AEB, 0x8AF3, 0x8AE7, 0x8AE4, 0x8AF1, 0x8B14, 0x8AE0, 0x8AE2,
0x8AF7, 0x8ADE, 0x8ADB, 0x8B0C, 0x8B07, 0x8B1A, 0x8AE1, 0x8B16,
0x8B10, 0x8B17, 0x8B20, 0x8B33, 0x97AB, 0x8B26, 0x8B2B, 0x8B3E,
0x8B28, 0x8B41, 0x8B4C, 0x8B4F, 0x8B4E, 0x8B49, 0x8B56, 0x8B5B,
0x8B5A, 0x8B6B, 0x8B5F, 0x8B6C, 0x8B6F, 0x8B74, 0x8B7D, 0x8B80,
0x8B8C, 0x8B8E, 0x8B92, 0x8B93, 0x8B96, 0x8B99, 0x8B9A, 0x8C3A,
0x8C41, 0x8C3F, 0x8C48, 0x8C4C, 0x8C4E, 0x8C50, 0x8C55, 0x8C62,
0x8C6C, 0x8C78, 0x8C7A, 0x8C82, 0x8C89, 0x8C85, 0x8C8A, 0x8C8D,
0x8C8E, 0x8C94, 0x8C7C, 0x8C98, 0x621D, 0x8CAD, 0x8CAA, 0x8CBD,
0x8CB2, 0x8CB3, 0x8CAE, 0x8CB6, 0x8CC8, 0x8CC1, 0x8CE4, 0x8CE3,
0x8CDA, 0x8CFD, 0x8CFA, 0x8CFB, 0x8D04, 0x8D05, 0x8D0A, 0x8D07,
0x8D0F, 0x8D0D, 0x8D10, 0x9F4E, 0x8D13, 0x8CCD, 0x8D14, 0x8D16,
0x8D67, 0x8D6D, 0x8D71, 0x8D73, 0x8D81, 0x8D99, 0x8DC2, 0x8DBE,
0x8DBA, 0x8DCF, 0x8DDA, 0x8DD6, 0x8DCC, 0x8DDB, 0x8DCB, 0x8DEA,
0x8DEB, 0x8DDF, 0x8DE3, 0x8DFC, 0x8E08, 0x8E09, 0x8DFF, 0x8E1D,
0x8E1E, 0x8E10, 0x8E1F, 0x8E42, 0x8E35, 0x8E30, 0x8E34, 0x8E4A,
0x8E47, 0x8E49, 0x8E4C, 0x8E50, 0x8E48, 0x8E59, 0x8E64, 0x8E60,
0x8E2A, 0x8E63, 0x8E55, 0x8E76, 0x8E72, 0x8E7C, 0x8E81, 0x8E87,
0x8E85, 0x8E84, 0x8E8B, 0x8E8A, 0x8E93, 0x8E91, 0x8E94, 0x8E99,
0x8EAA, 0x8EA1, 0x8EAC, 0x8EB0, 0x8EC6, 0x8EB1, 0x8EBE, 0x8EC5,
0x8EC8, 0x8ECB, 0x8EDB, 0x8EE3, 0x8EFC, 0x8EFB, 0x8EEB, 0x8EFE,
0x8F0A, 0x8F05, 0x8F15, 0x8F12, 0x8F19, 0x8F13, 0x8F1C, 0x8F1F,
0x8F1B, 0x8F0C, 0x8F26, 0x8F33, 0x8F3B, 0x8F39, 0x8F45, 0x8F42,
0x8F3E, 0x8F4C, 0x8F49, 0x8F46, 0x8F4E, 0x8F57, 0x8F5C, 0x8F62,
0x8F63, 0x8F64, 0x8F9C, 0x8F9F, 0x8FA3, 0x8FAD, 0x8FAF, 0x8FB7,
0x8FDA, 0x8FE5, 0x8FE2, 0x8FEA, 0x8FEF, 0x9087, 0x8FF4, 0x9005,
0x8FF9, 0x8FFA, 0x9011, 0x9015, 0x9021, 0x900D, 0x901E, 0x9016,
0x900B, 0x9027, 0x9036, 0x9035, 0x9039, 0x8FF8, 0x904F, 0x9050,
0x9051, 0x9052, 0x900E, 0x9049, 0x903E, 0x9056, 0x9058, 0x905E,
0x9068, 0x906F, 0x9076, 0x96A8, 0x9072, 0x9082, 0x907D, 0x9081,
0x9080, 0x908A, 0x9089, 0x908F, 0x90A8, 0x90AF, 0x90B1, 0x90B5,
0x90E2, 0x90E4, 0x6248, 0x90DB, 0x9102, 0x9112, 0x9119, 0x9132,
0x9130, 0x914A, 0x9156, 0x9158, 0x9163, 0x9165, 0x9169, 0x9173,
0x9172, 0x918B, 0x9189, 0x9182, 0x91A2, 0x91AB, 0x91AF, 0x91AA,
0x91B5, 0x91B4, 0x91BA, 0x91C0, 0x91C1, 0x91C9, 0x91CB, 0x91D0,
0x91D6, 0x91DF, 0x91E1, 0x91DB, 0x91FC, 0x91F5, 0x91F6, 0x921E,
0x91FF, 0x9214, 0x922C, 0x9215, 0x9211, 0x925E, 0x9257, 0x9245,
0x9249, 0x9264, 0x9248, 0x9295, 0x923F, 0x924B, 0x9250, 0x929C,
0x9296, 0x9293, 0x929B, 0x925A, 0x92CF, 0x92B9, 0x92B7, 0x92E9,
0x930F, 0x92FA, 0x9344, 0x932E, 0x9319, 0x9322, 0x931A, 0x9323,
0x933A, 0x9335, 0x933B, 0x935C, 0x9360, 0x937C, 0x936E, 0x9356,
0x93B0, 0x93AC, 0x93AD, 0x9394, 0x93B9, 0x93D6, 0x93D7, 0x93E8,
0x93E5, 0x93D8, 0x93C3, 0x93DD, 0x93D0, 0x93C8, 0x93E4, 0x941A,
0x9414, 0x9413, 0x9403, 0x9407, 0x9410, 0x9436, 0x942B, 0x9435,
0x9421, 0x943A, 0x9441, 0x9452, 0x9444, 0x945B, 0x9460, 0x9462,
0x945E, 0x946A, 0x9229, 0x9470, 0x9475, 0x9477, 0x947D, 0x945A,
0x947C, 0x947E, 0x9481, 0x947F, 0x9582, 0x9587, 0x958A, 0x9594,
0x9596, 0x9598, 0x9599, 0x95A0, 0x95A8, 0x95A7, 0x95AD, 0x95BC,
0x95BB, 0x95B9, 0x95BE, 0x95CA, 0x6FF6, 0x95C3, 0x95CD, 0x95CC,
0x95D5, 0x95D4, 0x95D6, 0x95DC, 0x95E1, 0x95E5, 0x95E2, 0x9621,
0x9628, 0x962E, 0x962F, 0x9642, 0x964C, 0x964F, 0x964B, 0x9677,
0x965C, 0x965E, 0x965D, 0x965F, 0x9666, 0x9672, 0x966C, 0x968D,
0x9698, 0x9695, 0x9697, 0x96AA, 0x96A7, 0x96B1, 0x96B2, 0x96B0,
0x96B4, 0x96B6, 0x96B8, 0x96B9, 0x96CE, 0x96CB, 0x96C9, 0x96CD,
0x894D, 0x96DC, 0x970D, 0x96D5, 0x96F9, 0x9704, 0x9706, 0x9708,
0x9713, 0x970E, 0x9711, 0x970F, 0x9716, 0x9719, 0x9724, 0x972A,
0x9730, 0x9739, 0x973D, 0x973E, 0x9744, 0x9746, 0x9748, 0x9742,
0x9749, 0x975C, 0x9760, 0x9764, 0x9766, 0x9768, 0x52D2, 0x976B,
0x9771, 0x9779, 0x9785, 0x977C, 0x9781, 0x977A, 0x9786, 0x978B,
0x978F, 0x9790, 0x979C, 0x97A8, 0x97A6, 0x97A3, 0x97B3, 0x97B4,
0x97C3, 0x97C6, 0x97C8, 0x97CB, 0x97DC, 0x97ED, 0x9F4F, 0x97F2,
0x7ADF, 0x97F6, 0x97F5, 0x980F, 0x980C, 0x9838, 0x9824, 0x9821,
0x9837, 0x983D, 0x9846, 0x984F, 0x984B, 0x986B, 0x986F, 0x9870,
0x9871, 0x9874, 0x9873, 0x98AA, 0x98AF, 0x98B1, 0x98B6, 0x98C4,
0x98C3, 0x98C6, 0x98E9, 0x98EB, 0x9903, 0x9909, 0x9912, 0x9914,
0x9918, 0x9921, 0x991D, 0x991E, 0x9924, 0x9920, 0x992C, 0x992E,
0x993D, 0x993E, 0x9942, 0x9949, 0x9945, 0x9950, 0x994B, 0x9951,
0x9952, 0x994C, 0x9955, 0x9997, 0x9998, 0x99A5, 0x99AD, 0x99AE,
0x99BC, 0x99DF, 0x99DB, 0x99DD, 0x99D8, 0x99D1, 0x99ED, 0x99EE,
0x99F1, 0x99F2, 0x99FB, 0x99F8, 0x9A01, 0x9A0F, 0x9A05, 0x99E2,
0x9A19, 0x9A2B, 0x9A37, 0x9A45, 0x9A42, 0x9A40, 0x9A43, 0x9A3E,
0x9A55, 0x9A4D, 0x9A5B, 0x9A57, 0x9A5F, 0x9A62, 0x9A65, 0x9A64,
0x9A69, 0x9A6B, 0x9A6A, 0x9AAD, 0x9AB0, 0x9ABC, 0x9AC0, 0x9ACF,
0x9AD1, 0x9AD3, 0x9AD4, 0x9ADE, 0x9ADF, 0x9AE2, 0x9AE3, 0x9AE6,
0x9AEF, 0x9AEB, 0x9AEE, 0x9AF4, 0x9AF1, 0x9AF7, 0x9AFB, 0x9B06,
0x9B18, 0x9B1A, 0x9B1F, 0x9B22, 0x9B23, 0x9B25, 0x9B27, 0x9B28,
0x9B29, 0x9B2A, 0x9B2E, 0x9B2F, 0x9B32, 0x9B44, 0x9B43, 0x9B4F,
0x9B4D, 0x9B4E, 0x9B51, 0x9B58, 0x9B74, 0x9B93, 0x9B83, 0x9B91,
0x9B96, 0x9B97, 0x9B9F, 0x9BA0, 0x9BA8, 0x9BB4, 0x9BC0, 0x9BCA,
0x9BB9, 0x9BC6, 0x9BCF, 0x9BD1, 0x9BD2, 0x9BE3, 0x9BE2, 0x9BE4,
0x9BD4, 0x9BE1, 0x9C3A, 0x9BF2, 0x9BF1, 0x9BF0, 0x9C15, 0x9C14,
0x9C09, 0x9C13, 0x9C0C, 0x9C06, 0x9C08, 0x9C12, 0x9C0A, 0x9C04,
0x9C2E, 0x9C1B, 0x9C25, 0x9C24, 0x9C21, 0x9C30, 0x9C47, 0x9C32,
0x9C46, 0x9C3E, 0x9C5A, 0x9C60, 0x9C67, 0x9C76, 0x9C78, 0x9CE7,
0x9CEC, 0x9CF0, 0x9D09, 0x9D08, 0x9CEB, 0x9D03, 0x9D06, 0x9D2A,
0x9D26, 0x9DAF, 0x9D23, 0x9D1F, 0x9D44, 0x9D15, 0x9D12, 0x9D41,
0x9D3F, 0x9D3E, 0x9D46, 0x9D48, 0x9D5D, 0x9D5E, 0x9D64, 0x9D51,
0x9D50, 0x9D59, 0x9D72, 0x9D89, 0x9D87, 0x9DAB, 0x9D6F, 0x9D7A,
0x9D9A, 0x9DA4, 0x9DA9, 0x9DB2, 0x9DC4, 0x9DC1, 0x9DBB, 0x9DB8,
0x9DBA, 0x9DC6, 0x9DCF, 0x9DC2, 0x9DD9, 0x9DD3, 0x9DF8, 0x9DE6,
0x9DED, 0x9DEF, 0x9DFD, 0x9E1A, 0x9E1B, 0x9E1E, 0x9E75, 0x9E79,
0x9E7D, 0x9E81, 0x9E88, 0x9E8B, 0x9E8C, 0x9E92, 0x9E95, 0x9E91,
0x9E9D, 0x9EA5, 0x9EA9, 0x9EB8, 0x9EAA, 0x9EAD, 0x9761, 0x9ECC,
0x9ECE, 0x9ECF, 0x9ED0, 0x9ED4, 0x9EDC, 0x9EDE, 0x9EDD, 0x9EE0,
0x9EE5, 0x9EE8, 0x9EEF, 0x9EF4, 0x9EF6, 0x9EF7, 0x9EF9, 0x9EFB,
0x9EFC, 0x9EFD, 0x9F07, 0x9F08, 0x76B7, 0x9F15, 0x9F21, 0x9F2C,
0x9F3E, 0x9F4A, 0x9F52, 0x9F54, 0x9F63, 0x9F5F, 0x9F60, 0x9F61,
0x9F66, 0x9F67, 0x9F6C, 0x9F6A, 0x9F77, 0x9F72, 0x9F76, 0x9F95,
0x9F9C, 0x9FA0, 0x582F, 0x69C7, 0x9059, 0x7464, 0x51DC, 0x7199,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_SJIS_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_sjis.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 116,322
|
```objective-c
/* big5.h - tables for Unicode to/from ECI 28 Big5, generated by "tools/gen_zueci_mb_h.php" from
"path_to_url" */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_BIG5_H
#define ZUECI_BIG5_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode usage bit-flags for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_big5_uro_u[1307] = {
0xFF8B, 0xC373, 0x6840, 0x1B0F, 0xE9AC, 0xF34C, 0x0200, 0xC008,
0x795C, 0xCA3E, 0x7976, 0x0648, 0x2FDF, 0xF7F0, 0x033A, 0xA8FF,
0xEF37, 0x233F, 0xB004, 0xFD59, 0xF3CA, 0xFFFF, 0xDE9F, 0xFFF9,
0xABFF, 0x7DF7, 0xC000, 0x8EEC, 0xEEBF, 0xFFDB, 0xD003, 0x45FA,
0xFAE1, 0xDFFE, 0xBFEF, 0x10AB, 0xFFEB, 0xFCAA, 0xEF3F, 0x24FD,
0x78AD, 0x7F76, 0xF00C, 0xEDFF, 0xCFF6, 0x2CFA, 0xF7F9, 0xEB6B,
0x1FFD, 0x95BF, 0x6677, 0xBFBF, 0x3BFB, 0xFEB4, 0x7BAE, 0x11E2,
0xA681, 0x41BE, 0x1435, 0x72C3, 0x7D70, 0x7191, 0x0003, 0x276B,
0x57CB, 0x70CF, 0x4732, 0x0DEF, 0x7EDA, 0xFC74, 0xFE06, 0xBDB4,
0x3F9F, 0x8BCA, 0x7E49, 0x5800, 0x228F, 0xEBEC, 0x8A5C, 0xDDBB,
0xEF60, 0xB6E7, 0xA40F, 0xF293, 0x37BB, 0x549E, 0xD04B, 0x9BAF,
0xC414, 0xF7D4, 0x30B0, 0x0A14, 0x2F08, 0x88D0, 0xFF7E, 0x192F,
0xFFDA, 0xFB07, 0x7FF1, 0x7BEB, 0xC5EF, 0x0010, 0x99FF, 0xFDFF,
0x79D7, 0x0567, 0xFFE7, 0xFDCB, 0xC3FF, 0x4040, 0x6FF7, 0xBD8E,
0xDFFA, 0x0497, 0xF4C0, 0x5BFF, 0xED7B, 0xD0E7, 0x047E, 0xF8E0,
0xFF9F, 0xB73E, 0x7DFE, 0x882E, 0xFFFD, 0xBE7F, 0x83FE, 0xF6C4,
0xF357, 0xB8FD, 0xD680, 0xEF7D, 0x5767, 0x4788, 0xFF7D, 0xC3DF,
0xF0FF, 0x37A9, 0x7DE0, 0x70FC, 0x3F6F, 0xEC9A, 0x4CB3, 0x8681,
0x3F9E, 0xDD5C, 0xF70D, 0x4819, 0xFEA3, 0x0007, 0xAF56, 0x38FF,
0x980D, 0xEFB8, 0x403D, 0xB760, 0xD8CE, 0x9035, 0x72BF, 0x3FFF,
0x7FF7, 0x7A11, 0xF7BB, 0xABFF, 0xFF00, 0x6FBE, 0xA93C, 0xFE72,
0xCFEF, 0xF11B, 0xDB6B, 0xF40A, 0xC3E6, 0xEF7E, 0x9B9C, 0xF610,
0xF048, 0x16F4, 0xFEB5, 0x5182, 0xC7B1, 0x15BB, 0x6E87, 0xFBDF,
0xE43F, 0x63CD, 0xC1FF, 0x7E7E, 0xFDEB, 0x7D5F, 0x777B, 0xFCFE,
0x960B, 0xDBEA, 0x6229, 0x53E8, 0x37DF, 0xFDEF, 0x36F5, 0xBD81,
0xDC18, 0xFCBD, 0xD2E4, 0xFFFF, 0x3FD7, 0xFFE0, 0x7F6F, 0xABF8,
0x9BAE, 0x6ED9, 0xF5FB, 0xF115, 0x79A9, 0xBDFB, 0x5A3C, 0xADAF,
0xDBBA, 0x1FAC, 0x71FC, 0x8379, 0x7CF7, 0xC35F, 0xDFFF, 0x0567,
0xFF9A, 0x8467, 0x1534, 0xDF8B, 0xF9F3, 0x3373, 0xF7BD, 0x5E1A,
0xBF40, 0xA03F, 0xFFFF, 0x01EB, 0xDFC0, 0xCFDD, 0x7500, 0xABD3,
0xF8C3, 0xEED6, 0x43FD, 0xB7FF, 0x5EAF, 0x4227, 0x9BAC, 0xF686,
0x27D7, 0xF6BC, 0xF787, 0x35B7, 0xAACD, 0xE176, 0x49E7, 0xE29F,
0x545C, 0xAFF2, 0x2B3F, 0x61D8, 0xFC3B, 0xBBB8, 0xFFCF, 0x7B7D,
0xBF95, 0x1CE0, 0x7DFD, 0x43FF, 0x5FF6, 0xFFFE, 0xD3EF, 0xC4CE,
0x8DB6, 0xADBC, 0x63DC, 0x11EB, 0xDF59, 0x23D0, 0xBEB4, 0xF3DB,
0x1FE7, 0xDBC7, 0xFF63, 0xFAE4, 0xB22B, 0x63F7, 0xED3B, 0xADBA,
0xFE01, 0x7EFF, 0xFFF7, 0x02BC, 0x32FF, 0xEF39, 0xFFFC, 0x8005,
0x77FB, 0xBCF5, 0x010D, 0xFFF7, 0xFFFB, 0xBF3A, 0x0057, 0xDFFF,
0xEF7B, 0xBD7D, 0xDB88, 0xC8D4, 0xFFF3, 0xED7C, 0x5DEE, 0x56FF,
0x7E0D, 0xAC5F, 0xFF96, 0xD57F, 0x3FEE, 0xC140, 0x6FF9, 0xFFE7,
0x779B, 0x8E77, 0x6EBF, 0xE45D, 0x6FCF, 0x5F1F, 0xE07F, 0xFEDF,
0xD7DB, 0x01FE, 0xFF00, 0xFB7B, 0xFFD4, 0x1FDF, 0xF800, 0xFFFF,
0xFB8F, 0x007B, 0xBF00, 0x7F5C, 0xFFFF, 0x07F3, 0xEBA0, 0x3DE7,
0xF7BF, 0xFBD7, 0xFFBF, 0x6003, 0xFFFD, 0xBFED, 0xEFBB, 0x027F,
0xFE40, 0xDDFD, 0xFDFF, 0xE2F9, 0x680B, 0xFB1F, 0xFBE3, 0xAFFD,
0x9FA4, 0xF7ED, 0x7A7D, 0xF80F, 0xEEBE, 0x0FD5, 0xBB5D, 0xFD9F,
0xF2DB, 0x3BF9, 0xFE7F, 0xEBCC, 0x876A, 0x73FA, 0x95FC, 0x9FFC,
0x109F, 0xFAF7, 0xDDB7, 0xBBCD, 0xF87E, 0xECCD, 0xF366, 0x3C3F,
0xFFFD, 0xB03F, 0xE9F7, 0x067E, 0x96AE, 0xFE06, 0xD576, 0x5FD7,
0x3FD1, 0xA3F3, 0xCF07, 0x6FB7, 0x9FD1, 0x7F44, 0x7B59, 0xD3DD,
0xAF3B, 0xA9BD, 0x7DCF, 0xFF3A, 0xFBE0, 0xF6EB, 0xB401, 0xFFFF,
0x7AFA, 0xB7BF, 0xC000, 0x0FFD, 0xFF7F, 0xFF1F, 0xFEFC, 0x95FF,
0x0000, 0xB5DC, 0xEF63, 0x3F3E, 0xFB7F, 0x001B, 0xE800, 0xFBF6,
0x9EEF, 0xB8DF, 0xFF9F, 0x003F, 0x7BD0, 0xF5FF, 0xDFDB, 0x3FFF,
0xFDF0, 0x00BF, 0x8420, 0xBBBD, 0xDF37, 0xFFDE, 0xFF6D, 0x0FF3,
0x604C, 0x5EFB, 0xFFFB, 0xFAFB, 0xFE5E, 0x0219, 0x79F4, 0xF9DE,
0xA7F7, 0xEBFA, 0x01EB, 0xFF34, 0xEBD3, 0xEF73, 0xAFD7, 0xC040,
0x72BB, 0xDCFF, 0xF17F, 0x2FD8, 0xB8EC, 0xFE0B, 0xDDA3, 0x1F0B,
0x8F1D, 0x47CF, 0xB12B, 0xFFDE, 0x7FEE, 0xDA73, 0x24FF, 0xCBC4,
0xF75D, 0xCBF2, 0xECFD, 0xB4ED, 0xBFF9, 0x4DDD, 0x99DD, 0xFB8D,
0xBB7F, 0xAF7B, 0xDDFB, 0xC959, 0xFC4F, 0xFAB5, 0xAFE3, 0x6D5F,
0xFFFF, 0x3F7D, 0x7800, 0xFFDB, 0xB6FF, 0x7EFF, 0xFBAF, 0x022F,
0xFF9B, 0xEFC7, 0xFFA5, 0xFFFF, 0x0007, 0xC700, 0xF7FF, 0xFFF1,
0x7FFD, 0x01BF, 0xDC00, 0xFDBC, 0xBFF5, 0xFFFF, 0xFF7F, 0x3EFF,
0x0029, 0xBE00, 0xF9FF, 0xFF7F, 0x6EFB, 0xFD7E, 0xCBFF, 0x039E,
0xE300, 0xFBDD, 0xCCFF, 0xF6DF, 0xFFFF, 0x117F, 0xF800, 0xFBF6,
0xE7EF, 0xD73C, 0xFEEF, 0xDFEF, 0xC00B, 0xEDBF, 0xFEDF, 0xFDCD,
0x7BF5, 0x40FD, 0xFFFF, 0xB75F, 0xFFDF, 0xF930, 0xFBDF, 0xDC97,
0xFEF3, 0xBFF2, 0x8FDF, 0xDFBF, 0x177F, 0xEDE6, 0x0F7F, 0x3553,
0x447C, 0x877E, 0xFA12, 0x45BB, 0xEDE0, 0x779E, 0x8017, 0xBFD9,
0x7E55, 0xDE89, 0xC16F, 0x0447, 0x7ADE, 0xF75D, 0x57FF, 0x2905,
0x86F7, 0xFE95, 0x97B3, 0xF32F, 0xCFFF, 0x9F75, 0x71F7, 0xFB17,
0x34EE, 0xEE19, 0x37CC, 0xEF61, 0x9FD6, 0xEF4C, 0xD68F, 0xFBDD,
0x7B73, 0x6DEF, 0xD7FE, 0xA431, 0x5E7F, 0x97D7, 0x0F5B, 0xFFD8,
0x9D83, 0x7BCE, 0x22EC, 0xDCFF, 0x763D, 0xEF87, 0xDFE7, 0xFDED,
0x4FFF, 0xA0FC, 0x3B77, 0xDBFC, 0x3DED, 0x7FDC, 0x6FA9, 0xF570,
0x3FFB, 0x2C40, 0xFF7F, 0x847F, 0xEC57, 0xDEB7, 0xE69C, 0xF22F,
0x0FEB, 0xD5B5, 0xAFEB, 0xEDE7, 0x8C2F, 0xFFF0, 0x537F, 0xE8F0,
0xB99D, 0xB5FF, 0xFF66, 0xE78F, 0xD981, 0xBE10, 0x9C7C, 0xE3C1,
0x9CD1, 0x2733, 0x0CBC, 0xFF6D, 0xFCB7, 0xEFB7, 0xA0DF, 0xFFFF,
0xBF0B, 0xFE7B, 0xA3FF, 0x353F, 0x13CC, 0x97CD, 0x7637, 0xFB27,
0xCFD6, 0x7E6C, 0xEC50, 0xED31, 0x677C, 0xFC1C, 0xF6FA, 0x5FBF,
0x0FBA, 0xAE2F, 0xA3AD, 0x7FFE, 0xFCF0, 0xDE74, 0xFFEF, 0xF200,
0xFBBF, 0xFEA2, 0x3DAF, 0xBCFF, 0xF694, 0x5FB9, 0xF3AD, 0x3F8F,
0xF26C, 0xA01F, 0xFFEF, 0x01BF, 0x7728, 0x7005, 0xFF35, 0xDA03,
0xD2F9, 0xC7FA, 0x3FBF, 0x5C1D, 0xFF3A, 0xEC33, 0xB7AF, 0xFE9C,
0x5236, 0x7A9F, 0xBFFA, 0xE722, 0x9FF7, 0xFCFF, 0x2FBB, 0xB61D,
0xED06, 0x1DFD, 0x7DD7, 0xEFDF, 0xEB23, 0xF166, 0x7ED9, 0x0DC0,
0x3D3D, 0xDFBF, 0xC945, 0xBA83, 0x7DD1, 0x9DD0, 0x7B87, 0xCF73,
0x9FF3, 0xC3F5, 0xDF0D, 0xC5FE, 0x0CB3, 0x8302, 0xE879, 0xAEC0,
0xC773, 0x6F0F, 0xFD7D, 0x093F, 0xFFF1, 0x0157, 0x62FB, 0x01FF,
0xFDB4, 0x3BF3, 0xB013, 0x43B2, 0x5ED3, 0xFF30, 0x0FFF, 0xEB9F,
0xFEEF, 0xF203, 0x3FEF, 0xFB89, 0x37A9, 0x9E99, 0xDEF9, 0xA72C,
0x3733, 0xC1F6, 0x812E, 0xFE3E, 0x5D20, 0xF2F7, 0xD585, 0x69D7,
0xFFFF, 0xFFFF, 0xDB07, 0xFF6F, 0xC4FF, 0xD97F, 0xEFCE, 0xBE0F,
0xF17B, 0xF05E, 0xF6CF, 0xFFB7, 0x5EF7, 0xEF84, 0xD7CB, 0x0EDF,
0xFF08, 0xFCFF, 0xEE3F, 0xFFFF, 0x13FF, 0xD7FF, 0xAF0F, 0x7FFD,
0xBDC7, 0x1FFA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0xE740, 0xBD38, 0xF933, 0x7FEB, 0xFEED,
0x7FE8, 0x7C76, 0xB3F7, 0xFFEF, 0xFEAF, 0xD8B7, 0xFF6F, 0xFBBF,
0xF8FB, 0xDBF7, 0x1752, 0xE2F9, 0x85C8, 0x7547, 0x9090, 0xE3EF,
0x9EF4, 0x3F6D, 0xEE2E, 0x0536, 0xF7BC, 0x7FF3, 0xA07B, 0x7F3F,
0x0567, 0xEB60, 0xBABE, 0x6601, 0xFCD8, 0x583F, 0xCAF7, 0x87DF,
0xBFCD, 0xFFA0, 0x5BCD, 0xFEBF, 0xB6FD, 0xEFA7, 0x77EF, 0xDF9C,
0x3FB7, 0xF877, 0x9D27, 0xB7FC, 0xCAB5, 0xDFEF, 0xFB5A, 0xF1B6,
0xEC39, 0xEF1F, 0xFBBF, 0x7FFB, 0x000D, 0xDAFE, 0xBDFB, 0x4E7F,
0x33FF, 0x5AC0, 0xBFF5, 0x9FFE, 0xFFBF, 0x005F, 0x0000, 0xFDF8,
0xFFCA, 0x6FFD, 0xCFFD, 0xA001, 0xDFFF, 0xFBF2, 0xDFBF, 0xFF7F,
0xFEDA, 0x080F, 0xBA08, 0xBFFF, 0x7AFD, 0xEED7, 0xFBEB, 0x67F9,
0xE044, 0xFF93, 0xDF97, 0x9F57, 0xFEF7, 0x08DF, 0xDF80, 0xFEDF,
0xFFC5, 0xF7FE, 0xFFFB, 0x6803, 0x67FB, 0x6BFA, 0x7FFF, 0x5FE2,
0xFFFF, 0xFF73, 0x87DF, 0xE7FB, 0xEBFD, 0xF7A7, 0xBF7E, 0xEFC7,
0x1EF3, 0xDF82, 0x76FF, 0xDF7E, 0x79C9, 0xDA7D, 0xEFBE, 0x1E9B,
0x7CE0, 0x77FB, 0x87BE, 0xFFFB, 0x1BFF, 0xFFDB, 0x3F5C, 0x4FE0,
0x7FFF, 0x5F0E, 0x77FF, 0xDDBF, 0xF04F, 0xFFFF, 0xFFFF, 0x0FF8,
0xA3BE, 0xFDDF, 0xFC1C, 0xFFFD, 0x1F7D, 0xFB9E, 0xBDFF, 0xDEDC,
0x3F6F, 0xBAFB, 0xDF7F, 0xFBEF, 0x7D1B, 0x2EEC, 0xAF8E, 0xF2F7,
0x7B0F, 0xCFEE, 0x1D96, 0x77C6, 0x7E07, 0xFFF5, 0xD982, 0x7FDF,
0x5EE6, 0xC7FF, 0xFEEE, 0x79EF, 0x9A56, 0xFFCF, 0xFE5F, 0xDE5E,
0x896E, 0xF9E8, 0xF45E, 0xE6C4, 0x0001, 0xBE7C, 0x3B7F, 0xDDDF,
0xD59D, 0xE9EF, 0x34AC, 0xDE53, 0xF573, 0x4BF7, 0x7B4F, 0x9EFF,
0xB8FE, 0x476E, 0x0DFB, 0xFF45, 0xABFD, 0xFBFE, 0xE9D7, 0xDDFF,
0xEDF7, 0x7FFF, 0xDDFD, 0x7EEB, 0xCFE7, 0xB7FF, 0xBDE9, 0xEF91,
0x5D75, 0xD77C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0xFA80, 0xFFEE, 0xB4F1, 0xBF76, 0x2FEF,
0xB677, 0x77BF, 0x9FBF, 0xFFFD, 0x95BF, 0xF6AE, 0x75FF, 0x7F3B,
0xA7F5, 0x0AF9, 0x0000, 0x0000, 0x0000, 0x0000, 0xFBD0, 0x2BDD,
0xF633, 0x9A7F, 0xFDAB, 0xD6FC, 0xF9E6, 0xBFEB, 0xDFDF, 0xF41F,
0xA6FD, 0xFFFF, 0x4AFF, 0xF37B, 0x7FB7, 0xFEF9, 0xB6FF, 0x1D5C,
0x7FF6, 0xE5FF, 0x1F7B, 0x2404, 0xBE05, 0xF99E, 0xDBE3, 0xDFF2,
0x6FEF, 0xFDFF, 0xD679, 0xCBFC, 0xEBFD, 0xEFFF, 0x001F, 0x0000,
0x0000, 0x9800, 0xE148, 0x8017, 0x6A74, 0x00FE, 0x6D7F, 0xFDF1,
0xB87F, 0xFEF3, 0xE01F, 0xF176, 0xEE96, 0x7B3F, 0xEB8D, 0xFFFD,
0xADFF, 0xCBB3, 0x84EF, 0xE17F, 0x4DAA, 0xBFF0, 0xBF3F, 0xFE3F,
0xEBFF, 0xFFD7, 0xFFDF, 0xCF7F, 0xFFFB, 0x85ED, 0xD73F, 0x07BC,
0xAEFF, 0xFE0F, 0xFDAF, 0x76BF, 0xFAEF, 0x37BB, 0x7FDC, 0xA3BA,
0xB6FF, 0x56F7, 0x60F8, 0xE7DF, 0xFF61, 0x4CDF, 0xB0FB, 0xFF45,
0x7DED, 0x3FFA, 0x1FFF, 0x18FC, 0xFFFF, 0xE3AF, 0xC7D3, 0xDF83,
0xFB57, 0xEF7D, 0xEFFF, 0x1378, 0xFEC0, 0x5FF7, 0x34BB, 0x5EE3,
0xF70D, 0xEFF6, 0xD7FE, 0x00BF, 0xF59D, 0xF7F7, 0x51DE, 0xFFE0,
0xFEC9, 0x037F, 0x5F01, 0xBFEF, 0x9FF1, 0x60A7, 0xEF1D, 0xF1FF,
0x000F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3C80,
0xFB4D, 0xD91F, 0x7B3A, 0xFEE3, 0x3FE9, 0xDC7F, 0x003F, 0x0000,
0x0000, 0x5000, 0xF51F, 0xBE07, 0xFC1D, 0xF91B, 0xBC1E, 0x71FF,
0x6FF9, 0x5BBE, 0x5796, 0x9B1B, 0x7FFF, 0xFFFC, 0x872E, 0xAFE7,
0xEBF5, 0xF34F, 0xDFFD, 0xE725, 0x0BDC, 0x5D44, 0x5747, 0xFDDD,
0xED3F, 0x7790, 0x7D7F, 0x8AC8, 0xFAFA, 0xF3F9, 0x202A, 0xEF4B,
0xF5FF, 0x79CF, 0xABD3, 0x0BA5, 0xF77A, 0xFB8F, 0x8EBD, 0x001F,
0x0000, 0x0000, 0xF300, 0xFD4E, 0x1A57, 0x8800, 0xAEAC, 0x7654,
0x17AD, 0xCDFF, 0xFFB2, 0xF42F, 0x5BAA, 0xDBFF, 0x0002, 0x0000,
0x0000, 0x73C0, 0xF9EA, 0x2E3F, 0xFA8E, 0xBBFF, 0x76BC, 0xFFD3,
0xEEFE, 0x7E72, 0x7EBD, 0xE7F7, 0xF77F, 0xCEFD, 0x0FF5, 0x0000,
0x0000, 0x0000, 0xA900, 0xDB9B, 0xA4C7, 0x917F, 0xF8CA, 0x7ECE,
0x7D7A, 0xC7E7, 0xCBBD, 0xDCAE, 0xFD7E, 0x8F76, 0x91D3, 0x7CF3,
0x01E5, 0x4C2F, 0xED77, 0xA360, 0x07DB, 0x5EF8, 0x1DF7, 0x2181,
0x6BE0, 0x309C, 0x3B3A, 0xFADE, 0x7F53, 0xC3F5, 0x61CD, 0x07BA,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x26E0, 0xBEFE,
0x03F9, 0xEBB5, 0xE36D, 0xE9CB, 0x9C2F, 0xBFDE, 0x9F83, 0xABBF,
0x1FF7, 0xFFD5, 0xB7DF, 0xDFFE, 0xFDAE, 0xFFEF, 0xFB7E, 0xEFFD,
0xAAFF, 0x6EBF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xB620,
0x7FCD, 0xBE9E, 0x62B3, 0x58F1, 0xF10D, 0xFD7B, 0xE9F1, 0xBEFD,
0xC6C3, 0x5F6D, 0xFF3D, 0x69FF, 0xFFCF, 0xFBF4, 0xDCFB, 0x4FF7,
0x2000, 0x1137, 0x0015,
};
/* Multibyte indexes for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_big5_uro_mb_ind[1307] = {
502, 514, 523, 527, 535, 544, 553, 554,
557, 566, 575, 585, 589, 601, 612, 618,
629, 641, 650, 654, 665, 675, 691, 703,
717, 730, 743, 745, 754, 767, 781, 786,
795, 805, 819, 833, 839, 853, 863, 876,
885, 894, 906, 912, 926, 938, 947, 960,
971, 983, 994, 1004, 1018, 1030, 1041, 1052,
1058, 1064, 1072, 1078, 1086, 1095, 1102, 1104,
1113, 1123, 1132, 1139, 1149, 1160, 1170, 1179,
1189, 1201, 1209, 1218, 1221, 1228, 1239, 1246,
1258, 1267, 1278, 1285, 1294, 1305, 1313, 1320,
1331, 1336, 1347, 1352, 1356, 1362, 1367, 1381,
1389, 1402, 1412, 1424, 1436, 1447, 1448, 1460,
1475, 1486, 1493, 1507, 1519, 1531, 1533, 1546,
1556, 1569, 1575, 1582, 1595, 1607, 1616, 1623,
1631, 1645, 1656, 1669, 1675, 1690, 1703, 1713,
1722, 1733, 1744, 1750, 1763, 1773, 1779, 1793,
1804, 1816, 1825, 1834, 1843, 1855, 1864, 1872,
1877, 1888, 1898, 1908, 1913, 1924, 1927, 1937,
1948, 1954, 1965, 1971, 1979, 1988, 1994, 2005,
2019, 2033, 2040, 2053, 2066, 2074, 2086, 2094,
2105, 2118, 2127, 2138, 2145, 2154, 2167, 2176,
2183, 2189, 2197, 2209, 2214, 2223, 2232, 2241,
2255, 2265, 2274, 2285, 2297, 2310, 2322, 2334,
2347, 2354, 2365, 2371, 2379, 2391, 2405, 2415,
2423, 2430, 2442, 2450, 2466, 2478, 2489, 2502,
2512, 2522, 2532, 2545, 2553, 2562, 2575, 2583,
2594, 2605, 2614, 2624, 2632, 2644, 2654, 2669,
2676, 2688, 2695, 2701, 2712, 2724, 2733, 2746,
2754, 2762, 2770, 2786, 2793, 2802, 2814, 2819,
2829, 2838, 2849, 2859, 2873, 2884, 2890, 2899,
2908, 2918, 2929, 2940, 2950, 2959, 2968, 2977,
2987, 2994, 3005, 3015, 3022, 3033, 3043, 3057,
3069, 3080, 3086, 3099, 3110, 3122, 3137, 3149,
3157, 3166, 3176, 3185, 3193, 3204, 3210, 3220,
3232, 3243, 3254, 3266, 3276, 3284, 3295, 3306,
3316, 3324, 3338, 3353, 3359, 3370, 3381, 3395,
3398, 3411, 3422, 3426, 3441, 3456, 3467, 3472,
3487, 3500, 3512, 3520, 3527, 3541, 3552, 3563,
3575, 3584, 3594, 3606, 3618, 3630, 3634, 3646,
3660, 3671, 3681, 3693, 3702, 3714, 3725, 3735,
3749, 3761, 3769, 3777, 3790, 3802, 3814, 3819,
3835, 3847, 3853, 3860, 3871, 3887, 3896, 3904,
3915, 3929, 3942, 3957, 3961, 3976, 3989, 4002,
4010, 4018, 4031, 4046, 4056, 4062, 4074, 4086,
4099, 4108, 4121, 4132, 4141, 4153, 4162, 4173,
4186, 4197, 4208, 4222, 4232, 4240, 4251, 4261,
4273, 4280, 4293, 4305, 4316, 4327, 4337, 4347,
4357, 4372, 4381, 4393, 4401, 4410, 4419, 4429,
4441, 4451, 4461, 4470, 4482, 4492, 4501, 4511,
4522, 4533, 4543, 4555, 4567, 4577, 4589, 4594,
4610, 4621, 4634, 4636, 4647, 4662, 4675, 4688,
4700, 4700, 4710, 4721, 4732, 4746, 4750, 4754,
4767, 4779, 4790, 4804, 4810, 4819, 4833, 4846,
4860, 4871, 4878, 4881, 4893, 4905, 4919, 4932,
4942, 4947, 4959, 4974, 4987, 4999, 5003, 5013,
5025, 5037, 5049, 5056, 5067, 5078, 5090, 5102,
5105, 5115, 5128, 5140, 5149, 5158, 5168, 5178,
5186, 5195, 5205, 5213, 5227, 5240, 5250, 5260,
5268, 5280, 5290, 5302, 5312, 5325, 5335, 5345,
5356, 5369, 5381, 5394, 5402, 5413, 5424, 5435,
5446, 5462, 5474, 5478, 5492, 5505, 5519, 5532,
5538, 5551, 5563, 5575, 5591, 5594, 5599, 5614,
5627, 5641, 5649, 5654, 5666, 5679, 5695, 5710,
5723, 5726, 5732, 5746, 5761, 5773, 5786, 5799,
5806, 5811, 5824, 5836, 5849, 5865, 5874, 5879,
5892, 5905, 5915, 5929, 5943, 5948, 5961, 5975,
5987, 5999, 6007, 6023, 6035, 6050, 6058, 6072,
6082, 6095, 6107, 6119, 6133, 6144, 6155, 6166,
6174, 6181, 6191, 6199, 6208, 6217, 6228, 6233,
6245, 6255, 6264, 6273, 6278, 6289, 6301, 6314,
6319, 6329, 6340, 6350, 6361, 6375, 6386, 6397,
6408, 6417, 6426, 6435, 6445, 6456, 6466, 6476,
6489, 6500, 6512, 6525, 6531, 6543, 6554, 6563,
6575, 6583, 6594, 6601, 6614, 6624, 6635, 6648,
6661, 6674, 6682, 6693, 6705, 6716, 6728, 6738,
6747, 6760, 6764, 6779, 6788, 6798, 6810, 6819,
6829, 6839, 6849, 6861, 6873, 6881, 6893, 6904,
6912, 6922, 6935, 6947, 6958, 6965, 6972, 6981,
6989, 6997, 7005, 7012, 7025, 7037, 7050, 7059,
7075, 7085, 7098, 7110, 7120, 7127, 7137, 7147,
7158, 7169, 7179, 7186, 7195, 7205, 7214, 7226,
7239, 7248, 7258, 7267, 7281, 7291, 7301, 7316,
7321, 7335, 7345, 7356, 7369, 7378, 7389, 7400,
7411, 7420, 7427, 7442, 7450, 7458, 7463, 7475,
7482, 7492, 7503, 7516, 7524, 7536, 7545, 7557,
7568, 7575, 7586, 7599, 7607, 7620, 7634, 7645,
7654, 7662, 7673, 7685, 7699, 7708, 7717, 7728,
7733, 7743, 7757, 7764, 7772, 7782, 7790, 7800,
7811, 7823, 7833, 7843, 7854, 7861, 7865, 7874,
7881, 7891, 7901, 7914, 7922, 7935, 7941, 7951,
7960, 7971, 7982, 7988, 7995, 8005, 8015, 8027,
8039, 8053, 8060, 8073, 8083, 8092, 8101, 8113,
8121, 8130, 8139, 8145, 8157, 8163, 8175, 8183,
8193, 8209, 8225, 8234, 8248, 8259, 8271, 8283,
8293, 8304, 8313, 8325, 8339, 8351, 8360, 8371,
8381, 8390, 8404, 8416, 8432, 8443, 8457, 8467,
8481, 8492, 8503, 8503, 8503, 8503, 8503, 8503,
8503, 8503, 8503, 8503, 8510, 8519, 8529, 8542,
8555, 8566, 8576, 8588, 8603, 8616, 8626, 8640,
8654, 8666, 8679, 8686, 8696, 8702, 8711, 8715,
8727, 8737, 8748, 8758, 8764, 8776, 8789, 8797,
8810, 8817, 8825, 8836, 8841, 8851, 8860, 8871,
8882, 8894, 8904, 8914, 8928, 8940, 8952, 8965,
8976, 8988, 8999, 9008, 9020, 9029, 9043, 9054,
9064, 9073, 9085, 9099, 9113, 9116, 9128, 9141,
9152, 9164, 9170, 9183, 9196, 9211, 9217, 9217,
9229, 9241, 9254, 9267, 9270, 9285, 9297, 9311,
9326, 9338, 9343, 9349, 9364, 9376, 9388, 9401,
9412, 9417, 9429, 9441, 9452, 9466, 9474, 9482,
9496, 9508, 9522, 9537, 9542, 9554, 9565, 9580,
9590, 9606, 9619, 9630, 9643, 9656, 9668, 9681,
9693, 9703, 9712, 9725, 9738, 9747, 9758, 9771,
9780, 9788, 9801, 9811, 9826, 9838, 9852, 9862,
9870, 9885, 9894, 9908, 9921, 9930, 9946, 9962,
9971, 9981, 9995, 10004, 10019, 10030, 10042, 10056,
10067, 10079, 10091, 10105, 10119, 10129, 10138, 10148,
10160, 10170, 10182, 10190, 10200, 10209, 10223, 10230,
10244, 10254, 10267, 10280, 10292, 10300, 10314, 10327,
10338, 10346, 10356, 10366, 10374, 10375, 10386, 10398,
10411, 10421, 10433, 10440, 10450, 10461, 10472, 10483,
10496, 10507, 10516, 10526, 10537, 10549, 10563, 10574,
10588, 10601, 10616, 10629, 10641, 10653, 10667, 10678,
10688, 10698, 10709, 10709, 10709, 10709, 10709, 10709,
10709, 10709, 10709, 10709, 10716, 10730, 10739, 10751,
10763, 10774, 10787, 10800, 10815, 10826, 10837, 10850,
10862, 10873, 10881, 10881, 10881, 10881, 10881, 10891,
10901, 10911, 10922, 10934, 10945, 10956, 10969, 10983,
10993, 11004, 11020, 11031, 11043, 11056, 11069, 11082,
11090, 11103, 11116, 11127, 11130, 11138, 11149, 11160,
11172, 11185, 11200, 11210, 11221, 11234, 11249, 11254,
11254, 11254, 11257, 11263, 11268, 11276, 11283, 11295,
11307, 11318, 11331, 11339, 11349, 11359, 11371, 11381,
11396, 11409, 11419, 11428, 11439, 11447, 11458, 11471,
11484, 11498, 11512, 11527, 11540, 11555, 11564, 11576,
11584, 11597, 11608, 11621, 11633, 11646, 11657, 11669,
11678, 11691, 11702, 11709, 11722, 11733, 11743, 11753,
11764, 11776, 11788, 11801, 11809, 11825, 11836, 11846,
11856, 11868, 11881, 11896, 11903, 11912, 11925, 11934,
11944, 11954, 11967, 11980, 11987, 11998, 12012, 12021,
12032, 12043, 12052, 12059, 12073, 12084, 12091, 12102,
12115, 12119, 12119, 12119, 12119, 12119, 12119, 12119,
12119, 12119, 12119, 12119, 12119, 12119, 12119, 12119,
12124, 12135, 12145, 12155, 12167, 12178, 12190, 12196,
12196, 12196, 12198, 12209, 12218, 12228, 12238, 12247,
12259, 12271, 12282, 12291, 12300, 12315, 12329, 12337,
12349, 12361, 12372, 12386, 12395, 12403, 12410, 12419,
12432, 12444, 12452, 12465, 12471, 12483, 12495, 12499,
12510, 12524, 12535, 12545, 12552, 12564, 12576, 12586,
12591, 12591, 12591, 12597, 12608, 12616, 12618, 12627,
12635, 12644, 12657, 12669, 12679, 12688, 12702, 12703,
12703, 12703, 12710, 12721, 12731, 12741, 12755, 12765,
12778, 12791, 12801, 12813, 12826, 12840, 12852, 12862,
12862, 12862, 12862, 12866, 12877, 12885, 12895, 12904,
12915, 12926, 12937, 12948, 12958, 12971, 12981, 12989,
13000, 13006, 13014, 13026, 13032, 13041, 13051, 13062,
13066, 13074, 13080, 13089, 13101, 13112, 13122, 13130,
13138, 13138, 13138, 13138, 13138, 13138, 13138, 13144,
13157, 13165, 13176, 13186, 13196, 13205, 13218, 13227,
13239, 13251, 13264, 13277, 13291, 13303, 13318, 13331,
13345, 13357, 13369, 13369, 13369, 13369, 13369, 13369,
13375, 13387, 13398, 13406, 13414, 13422, 13435, 13445,
13458, 13466, 13477, 13490, 13502, 13516, 13528, 13540,
13552, 13553, 13560,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_big5_u_u[642] = {
0x00A2, 0x00A3, 0x00A5, 0x00A7, 0x00B0, 0x00B1, 0x00B7, 0x00D7,
0x00F7, 0x02C7, 0x02C9, 0x02CA, 0x02CB, 0x02D9, 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, 0x0414,
0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C,
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, 0x2013, 0x2014,
0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2025, 0x2026, 0x2032,
0x2035, 0x203B, 0x203E, 0x2103, 0x2105, 0x2109, 0x2160, 0x2161,
0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169,
0x2190, 0x2191, 0x2192, 0x2193, 0x2196, 0x2197, 0x2198, 0x2199,
0x221A, 0x221E, 0x221F, 0x2220, 0x2223, 0x2225, 0x2229, 0x222A,
0x222B, 0x222E, 0x2234, 0x2235, 0x223C, 0x2252, 0x2260, 0x2261,
0x2266, 0x2267, 0x22A5, 0x22BF, 0x2460, 0x2461, 0x2462, 0x2463,
0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469, 0x2474, 0x2475,
0x2476, 0x2477, 0x2478, 0x2479, 0x247A, 0x247B, 0x247C, 0x247D,
0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
0x252C, 0x2534, 0x253C, 0x2550, 0x255E, 0x2561, 0x256A, 0x256D,
0x256E, 0x256F, 0x2570, 0x2571, 0x2572, 0x2573, 0x2581, 0x2582,
0x2583, 0x2584, 0x2585, 0x2586, 0x2587, 0x2588, 0x2589, 0x258A,
0x258B, 0x258C, 0x258D, 0x258E, 0x258F, 0x2594, 0x2595, 0x25A0,
0x25A1, 0x25B2, 0x25B3, 0x25BC, 0x25BD, 0x25C6, 0x25C7, 0x25CB,
0x25CE, 0x25CF, 0x25E2, 0x25E3, 0x25E4, 0x25E5, 0x2605, 0x2606,
0x2609, 0x2640, 0x2641, 0x2642, 0x3000, 0x3001, 0x3002, 0x3003,
0x3005, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D, 0x300E,
0x300F, 0x3010, 0x3011, 0x3012, 0x3014, 0x3015, 0x301D, 0x301E,
0x3021, 0x3022, 0x3023, 0x3024, 0x3025, 0x3026, 0x3027, 0x3028,
0x3029, 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, 0x309D, 0x309E, 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, 0x30FE, 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, 0x32A3, 0x338E, 0x338F, 0x339C, 0x339D, 0x339E,
0x33A1, 0x33C4, 0x33CE, 0x33D1, 0x33D2, 0x33D5, 0xFA0C, 0xFA0D,
0xFE30, 0xFE31, 0xFE33, 0xFE34, 0xFE35, 0xFE36, 0xFE37, 0xFE38,
0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D, 0xFE3E, 0xFE3F, 0xFE40,
0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C,
0xFE4D, 0xFE4E, 0xFE4F, 0xFE50, 0xFE52, 0xFE54, 0xFE55, 0xFE56,
0xFE57, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F,
0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE69,
0xFE6A, 0xFE6B, 0xFF01, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 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, 0xFF3C, 0xFF3F, 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, 0xFF64,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_big5_u_mb[13703] = {
0xA246, 0xA247, 0xA244, 0xA1B1, 0xA258, 0xA1D3, 0xA150, 0xA1D1,
0xA1D2, 0xA3BE, 0xA3BC, 0xA3BD, 0xA3BF, 0xA3BB, 0xA344, 0xA345,
0xA346, 0xA347, 0xA348, 0xA349, 0xA34A, 0xA34B, 0xA34C, 0xA34D,
0xA34E, 0xA34F, 0xA350, 0xA351, 0xA352, 0xA353, 0xA354, 0xA355,
0xA356, 0xA357, 0xA358, 0xA359, 0xA35A, 0xA35B, 0xA35C, 0xA35D,
0xA35E, 0xA35F, 0xA360, 0xA361, 0xA362, 0xA363, 0xA364, 0xA365,
0xA366, 0xA367, 0xA368, 0xA369, 0xA36A, 0xA36B, 0xA36C, 0xA36D,
0xA36E, 0xA36F, 0xA370, 0xA371, 0xA372, 0xA373, 0xC7B3, 0xC7B1,
0xC7B2, 0xC7B4, 0xC7B5, 0xC7B6, 0xC7B7, 0xC7B8, 0xC7B9, 0xC7BA,
0xC7BB, 0xC7BC, 0xC7BD, 0xC7BE, 0xC7BF, 0xC7C0, 0xC7C1, 0xC7C2,
0xC7C3, 0xC7C4, 0xC7C5, 0xC7C6, 0xC7C7, 0xC7C8, 0xC7C9, 0xC7CA,
0xC7CB, 0xC7CC, 0xC7CD, 0xC7CF, 0xC7D0, 0xC7D1, 0xC7D2, 0xC7D3,
0xC7D4, 0xC7D5, 0xC7D6, 0xC7D7, 0xC7D8, 0xC7D9, 0xC7DA, 0xC7DB,
0xC7DC, 0xC7DD, 0xC7DE, 0xC7DF, 0xC7E0, 0xC7E1, 0xC7E2, 0xC7E3,
0xC7E4, 0xC7E5, 0xC7E6, 0xC7E7, 0xC7E8, 0xC7CE, 0xA156, 0xA158,
0xA1A5, 0xA1A6, 0xA1A7, 0xA1A8, 0xA145, 0xA14C, 0xA14B, 0xA1AC,
0xA1AB, 0xA1B0, 0xA1C2, 0xA24A, 0xA1C1, 0xA24B, 0xA2B9, 0xA2BA,
0xA2BB, 0xA2BC, 0xA2BD, 0xA2BE, 0xA2BF, 0xA2C0, 0xA2C1, 0xA2C2,
0xA1F6, 0xA1F4, 0xA1F7, 0xA1F5, 0xA1F8, 0xA1F9, 0xA1FB, 0xA1FA,
0xA1D4, 0xA1DB, 0xA1E8, 0xA1E7, 0xA1FD, 0xA1FC, 0xA1E4, 0xA1E5,
0xA1EC, 0xA1ED, 0xA1EF, 0xA1EE, 0xA1E3, 0xA1DC, 0xA1DA, 0xA1DD,
0xA1D8, 0xA1D9, 0xA1E6, 0xA1E9, 0xC7E9, 0xC7EA, 0xC7EB, 0xC7EC,
0xC7ED, 0xC7EE, 0xC7EF, 0xC7F0, 0xC7F1, 0xC7F2, 0xC7F3, 0xC7F4,
0xC7F5, 0xC7F6, 0xC7F7, 0xC7F8, 0xC7F9, 0xC7FA, 0xC7FB, 0xC7FC,
0xA277, 0xA278, 0xA27A, 0xA27B, 0xA27C, 0xA27D, 0xA275, 0xA274,
0xA273, 0xA272, 0xA271, 0xA2A4, 0xA2A5, 0xA2A7, 0xA2A6, 0xA27E,
0xA2A1, 0xA2A3, 0xA2A2, 0xA2AC, 0xA2AD, 0xA2AE, 0xA262, 0xA263,
0xA264, 0xA265, 0xA266, 0xA267, 0xA268, 0xA269, 0xA270, 0xA26F,
0xA26E, 0xA26D, 0xA26C, 0xA26B, 0xA26A, 0xA276, 0xA279, 0xA1BD,
0xA1BC, 0xA1B6, 0xA1B5, 0xA1BF, 0xA1BE, 0xA1BB, 0xA1BA, 0xA1B3,
0xA1B7, 0xA1B4, 0xA2A8, 0xA2A9, 0xA2AB, 0xA2AA, 0xA1B9, 0xA1B8,
0xA1F3, 0xA1F0, 0xA1F2, 0xA1F1, 0xA140, 0xA142, 0xA143, 0xA1B2,
0xC6A4, 0xA171, 0xA172, 0xA16D, 0xA16E, 0xA175, 0xA176, 0xA179,
0xA17A, 0xA169, 0xA16A, 0xA245, 0xA165, 0xA166, 0xA1A9, 0xA1AA,
0xA2C3, 0xA2C4, 0xA2C5, 0xA2C6, 0xA2C7, 0xA2C8, 0xA2C9, 0xA2CA,
0xA2CB, 0xC6A5, 0xC6A6, 0xC6A7, 0xC6A8, 0xC6A9, 0xC6AA, 0xC6AB,
0xC6AC, 0xC6AD, 0xC6AE, 0xC6AF, 0xC6B0, 0xC6B1, 0xC6B2, 0xC6B3,
0xC6B4, 0xC6B5, 0xC6B6, 0xC6B7, 0xC6B8, 0xC6B9, 0xC6BA, 0xC6BB,
0xC6BC, 0xC6BD, 0xC6BE, 0xC6BF, 0xC6C0, 0xC6C1, 0xC6C2, 0xC6C3,
0xC6C4, 0xC6C5, 0xC6C6, 0xC6C7, 0xC6C8, 0xC6C9, 0xC6CA, 0xC6CB,
0xC6CC, 0xC6CD, 0xC6CE, 0xC6CF, 0xC6D0, 0xC6D1, 0xC6D2, 0xC6D3,
0xC6D4, 0xC6D5, 0xC6D6, 0xC6D7, 0xC6D8, 0xC6D9, 0xC6DA, 0xC6DB,
0xC6DC, 0xC6DD, 0xC6DE, 0xC6DF, 0xC6E0, 0xC6E1, 0xC6E2, 0xC6E3,
0xC6E4, 0xC6E5, 0xC6E6, 0xC6E7, 0xC6E8, 0xC6E9, 0xC6EA, 0xC6EB,
0xC6EC, 0xC6ED, 0xC6EE, 0xC6EF, 0xC6F0, 0xC6F1, 0xC6F2, 0xC6F3,
0xC6F4, 0xC6F5, 0xC6F6, 0xC6F7, 0xC6A2, 0xC6A3, 0xC6F8, 0xC6F9,
0xC6FA, 0xC6FB, 0xC6FC, 0xC6FD, 0xC6FE, 0xC740, 0xC741, 0xC742,
0xC743, 0xC744, 0xC745, 0xC746, 0xC747, 0xC748, 0xC749, 0xC74A,
0xC74B, 0xC74C, 0xC74D, 0xC74E, 0xC74F, 0xC750, 0xC751, 0xC752,
0xC753, 0xC754, 0xC755, 0xC756, 0xC757, 0xC758, 0xC759, 0xC75A,
0xC75B, 0xC75C, 0xC75D, 0xC75E, 0xC75F, 0xC760, 0xC761, 0xC762,
0xC763, 0xC764, 0xC765, 0xC766, 0xC767, 0xC768, 0xC769, 0xC76A,
0xC76B, 0xC76C, 0xC76D, 0xC76E, 0xC76F, 0xC770, 0xC771, 0xC772,
0xC773, 0xC774, 0xC775, 0xC776, 0xC777, 0xC778, 0xC779, 0xC77A,
0xC77B, 0xC77C, 0xC77D, 0xC77E, 0xC7A1, 0xC7A2, 0xC7A3, 0xC7A4,
0xC7A5, 0xC7A6, 0xC7A7, 0xC7A8, 0xC7A9, 0xC7AA, 0xC7AB, 0xC7AC,
0xC7AD, 0xC7AE, 0xC7AF, 0xC7B0, 0xC6A1, 0xA374, 0xA375, 0xA376,
0xA377, 0xA378, 0xA379, 0xA37A, 0xA37B, 0xA37C, 0xA37D, 0xA37E,
0xA3A1, 0xA3A2, 0xA3A3, 0xA3A4, 0xA3A5, 0xA3A6, 0xA3A7, 0xA3A8,
0xA3A9, 0xA3AA, 0xA3AB, 0xA3AC, 0xA3AD, 0xA3AE, 0xA3AF, 0xA3B0,
0xA3B1, 0xA3B2, 0xA3B3, 0xA3B4, 0xA3B5, 0xA3B6, 0xA3B7, 0xA3B8,
0xA3B9, 0xA3BA, 0xA1C0, 0xA255, 0xA256, 0xA250, 0xA251, 0xA252,
0xA254, 0xA257, 0xA253, 0xA1EB, 0xA1EA, 0xA24F, 0xA440, 0xA442,
0xA443, 0xC945, 0xA456, 0xA454, 0xA457, 0xA455, 0xC946, 0xA4A3,
0xC94F, 0xC94D, 0xA4A2, 0xA4A1, 0xA542, 0xA541, 0xA540, 0xA543,
0xA4FE, 0xA5E0, 0xA5E1, 0xA8C3, 0xA458, 0xA4A4, 0xC950, 0xA4A5,
0xC963, 0xA6EA, 0xCBB1, 0xA459, 0xA4A6, 0xA544, 0xC964, 0xC940,
0xA444, 0xA45B, 0xC947, 0xA45C, 0xA4A7, 0xA545, 0xA547, 0xA546,
0xA5E2, 0xA5E3, 0xA8C4, 0xADBC, 0xA441, 0xC941, 0xA445, 0xA45E,
0xA45D, 0xA5E4, 0xA8C5, 0xB0AE, 0xD44B, 0xB6C3, 0xDCB1, 0xDCB2,
0xA446, 0xA4A9, 0xA8C6, 0xA447, 0xC948, 0xA45F, 0xA4AA, 0xA4AC,
0xC951, 0xA4AD, 0xA4AB, 0xA5E5, 0xA8C7, 0xA8C8, 0xAB45, 0xA460,
0xA4AE, 0xA5E6, 0xA5E8, 0xA5E7, 0xA6EB, 0xA8C9, 0xA8CA, 0xAB46,
0xAB47, 0xADBD, 0xDCB3, 0xF6D6, 0xA448, 0xA4B0, 0xA4AF, 0xC952,
0xA4B1, 0xA4B7, 0xA4B2, 0xA4B3, 0xC954, 0xC953, 0xA4B5, 0xA4B6,
0xA4B4, 0xA54A, 0xA54B, 0xA54C, 0xA54D, 0xA549, 0xA550, 0xC96A,
0xC966, 0xC969, 0xA551, 0xA561, 0xC968, 0xA54E, 0xA54F, 0xA548,
0xC965, 0xC967, 0xA5F5, 0xC9B0, 0xA5F2, 0xA5F6, 0xC9BA, 0xC9AE,
0xA5F3, 0xC9B2, 0xA5F4, 0xA5F7, 0xA5E9, 0xC9B1, 0xA5F8, 0xC9B5,
0xC9B9, 0xC9B6, 0xC9B3, 0xA5EA, 0xA5EC, 0xA5F9, 0xA5EE, 0xC9AB,
0xA5F1, 0xA5EF, 0xA5F0, 0xC9BB, 0xC9B8, 0xC9AF, 0xA5ED, 0xC9AC,
0xA5EB, 0xC9B4, 0xC9B7, 0xC9AD, 0xCA66, 0xA742, 0xA6F4, 0xCA67,
0xA6F1, 0xA744, 0xA6F9, 0xA6F8, 0xCA5B, 0xA6FC, 0xA6F7, 0xCA60,
0xCA68, 0xCA64, 0xA6FA, 0xA6FD, 0xA6EE, 0xA747, 0xCA5D, 0xCBBD,
0xA6EC, 0xA743, 0xA6ED, 0xA6F5, 0xA6F6, 0xCA62, 0xCA5E, 0xA6FB,
0xA6F3, 0xCA5A, 0xA6EF, 0xCA65, 0xA745, 0xA748, 0xA6F2, 0xA740,
0xA746, 0xA6F0, 0xCA63, 0xA741, 0xCA69, 0xCA5C, 0xA6FE, 0xCA5F,
0xCA61, 0xA8D8, 0xCBBF, 0xCBCB, 0xA8D0, 0xCBCC, 0xA8CB, 0xA8D5,
0xA8CE, 0xCBB9, 0xA8D6, 0xCBB8, 0xCBBC, 0xCBC3, 0xCBC1, 0xA8DE,
0xA8D9, 0xCBB3, 0xCBB5, 0xA8DB, 0xA8CF, 0xCBB6, 0xCBC2, 0xCBC9,
0xA8D4, 0xCBBB, 0xCBB4, 0xA8D3, 0xCBB7, 0xA8D7, 0xCBBA, 0xA8D2,
0xA8CD, 0xA8DC, 0xCBC4, 0xA8DD, 0xCBC8, 0xCBC6, 0xCBCA, 0xA8DA,
0xCBBE, 0xCBB2, 0xCBC0, 0xA8D1, 0xCBC5, 0xA8CC, 0xCBC7, 0xAB56,
0xAB4A, 0xCDE0, 0xCDE8, 0xAB49, 0xAB51, 0xAB5D, 0xCDEE, 0xCDEC,
0xCDE7, 0xAB4B, 0xCDED, 0xCDE3, 0xAB59, 0xAB50, 0xAB58, 0xCDDE,
0xCDEA, 0xCDE1, 0xAB54, 0xCDE2, 0xCDDD, 0xAB5B, 0xAB4E, 0xAB57,
0xAB4D, 0xCDDF, 0xCDE4, 0xCDEB, 0xAB55, 0xAB52, 0xCDE6, 0xAB5A,
0xCDE9, 0xCDE5, 0xAB4F, 0xAB5C, 0xAB53, 0xAB4C, 0xAB48, 0xCDEF,
0xADD7, 0xADC1, 0xADD1, 0xADD6, 0xD0D0, 0xD0CF, 0xD0D4, 0xD0D5,
0xADC4, 0xADCD, 0xADDA, 0xADCE, 0xD0C9, 0xADC7, 0xD0CA, 0xADDC,
0xADD3, 0xADBE, 0xADBF, 0xD0DD, 0xB0BF, 0xADCC, 0xADCB, 0xD0CB,
0xADCF, 0xD45B, 0xADC6, 0xD0D6, 0xADD5, 0xADD4, 0xADCA, 0xD0CE,
0xD0D7, 0xD0C8, 0xADC9, 0xD0D8, 0xADD2, 0xD0CC, 0xADC0, 0xADC3,
0xADC2, 0xD0D9, 0xADD0, 0xADC5, 0xADD9, 0xADDB, 0xD0D3, 0xADD8,
0xD0DB, 0xD0CD, 0xD0DC, 0xD0D1, 0xD0DA, 0xD0D2, 0xADC8, 0xD463,
0xD457, 0xB0B3, 0xD45C, 0xD462, 0xB0B2, 0xD455, 0xB0B6, 0xD459,
0xD452, 0xB0B4, 0xD456, 0xB0B9, 0xB0BE, 0xD467, 0xD451, 0xB0BA,
0xD466, 0xB0B5, 0xD458, 0xB0B1, 0xD453, 0xD44F, 0xD45D, 0xD450,
0xD44E, 0xD45A, 0xD460, 0xD461, 0xB0B7, 0xD85B, 0xD45E, 0xD44D,
0xD45F, 0xB0C1, 0xD464, 0xB0C0, 0xD44C, 0xD454, 0xD465, 0xB0BC,
0xB0BB, 0xB0B8, 0xB0BD, 0xB0AF, 0xB0B0, 0xB3C8, 0xD85E, 0xD857,
0xB3C5, 0xD85F, 0xD855, 0xD858, 0xB3C4, 0xD859, 0xB3C7, 0xD85D,
0xD853, 0xD852, 0xB3C9, 0xB3CA, 0xB3C6, 0xB3CB, 0xD851, 0xD85C,
0xD85A, 0xD854, 0xB3C3, 0xD856, 0xB6CA, 0xB6C4, 0xDCB7, 0xB6CD,
0xDCBD, 0xDCC0, 0xB6C6, 0xB6C7, 0xDCBA, 0xB6C5, 0xDCC3, 0xB6CB,
0xDCC4, 0xDCBF, 0xB6CC, 0xDCB4, 0xB6C9, 0xDCB5, 0xDCBE, 0xDCBC,
0xDCB8, 0xB6C8, 0xDCB6, 0xB6CE, 0xDCBB, 0xDCC2, 0xDCB9, 0xDCC1,
0xB9B6, 0xB9B3, 0xB9B4, 0xE0F9, 0xE0F1, 0xB9B2, 0xB9AF, 0xE0F2,
0xB9B1, 0xE0F5, 0xE0F7, 0xE0FE, 0xE0FD, 0xE0F8, 0xB9AE, 0xE0F0,
0xB9AC, 0xE0F3, 0xB9B7, 0xE0F6, 0xE0FA, 0xB9B0, 0xB9AD, 0xE0FC,
0xE0FB, 0xB9B5, 0xE0F4, 0xBBF8, 0xE4EC, 0xE4E9, 0xBBF9, 0xBBF7,
0xE4F0, 0xE4ED, 0xE4E6, 0xBBF6, 0xBBFA, 0xE4E7, 0xBBF5, 0xBBFD,
0xE4EA, 0xE4EB, 0xBBFB, 0xBBFC, 0xE4F1, 0xE4EE, 0xE4EF, 0xBEAA,
0xE8F8, 0xBEA7, 0xE8F5, 0xBEA9, 0xBEAB, 0xE8F6, 0xBEA8, 0xE8F7,
0xE8F4, 0xC076, 0xECBD, 0xC077, 0xECBB, 0xECBC, 0xECBA, 0xECB9,
0xECBE, 0xC075, 0xEFB8, 0xEFB9, 0xE4E8, 0xEFB7, 0xC078, 0xC35F,
0xF1EB, 0xF1EC, 0xC4D7, 0xC4D8, 0xF5C1, 0xF5C0, 0xC56C, 0xC56B,
0xF7D0, 0xA449, 0xA461, 0xA4B9, 0xA4B8, 0xA553, 0xA552, 0xA5FC,
0xA5FB, 0xA5FD, 0xA5FA, 0xA74A, 0xA749, 0xA74B, 0xA8E0, 0xA8DF,
0xA8E1, 0xAB5E, 0xA259, 0xD0DE, 0xA25A, 0xB0C2, 0xA25C, 0xA25B,
0xD860, 0xA25D, 0xB9B8, 0xA25E, 0xA44A, 0xA4BA, 0xA5FE, 0xA8E2,
0xA44B, 0xA4BD, 0xA4BB, 0xA4BC, 0xA640, 0xA74C, 0xA8E4, 0xA8E3,
0xA8E5, 0xADDD, 0xBEAC, 0xC94E, 0xA554, 0xA555, 0xA641, 0xCA6A,
0xAB60, 0xAB5F, 0xD0E0, 0xD0DF, 0xB0C3, 0xA4BE, 0xC955, 0xCBCD,
0xAB61, 0xADE0, 0xADDE, 0xADDF, 0xBEAD, 0xA556, 0xA642, 0xC9BC,
0xA74D, 0xA74E, 0xCA6B, 0xCBCE, 0xA8E6, 0xCBCF, 0xD0E2, 0xD0E3,
0xADE3, 0xD0E4, 0xD0E1, 0xADE4, 0xADE2, 0xADE1, 0xD0E5, 0xD468,
0xD861, 0xDCC5, 0xE140, 0xBBFE, 0xBEAE, 0xE8F9, 0xA44C, 0xA45A,
0xB0C4, 0xB3CD, 0xB9B9, 0xC942, 0xA4BF, 0xA559, 0xA557, 0xA558,
0xA8E7, 0xA44D, 0xA44E, 0xA462, 0xA4C0, 0xA4C1, 0xA4C2, 0xC9BE,
0xA55A, 0xC96B, 0xA646, 0xC9BF, 0xA644, 0xA645, 0xC9BD, 0xA647,
0xA643, 0xCA6C, 0xAAEC, 0xCA6D, 0xCA6E, 0xA750, 0xA74F, 0xA753,
0xA751, 0xA752, 0xA8ED, 0xA8EC, 0xCBD4, 0xCBD1, 0xCBD2, 0xCBD0,
0xA8EE, 0xA8EA, 0xA8E9, 0xA8EB, 0xA8E8, 0xA8EF, 0xAB63, 0xCDF0,
0xCBD3, 0xAB68, 0xCDF1, 0xAB64, 0xAB67, 0xAB66, 0xAB65, 0xAB62,
0xD0E8, 0xADE7, 0xD0EB, 0xADE5, 0xD0E7, 0xADE8, 0xADE6, 0xADE9,
0xD0E9, 0xD0EA, 0xD0E6, 0xD0EC, 0xB3D1, 0xB0C5, 0xD469, 0xD46B,
0xD46A, 0xD46C, 0xB0C6, 0xB3CE, 0xB3CF, 0xB3D0, 0xB6D0, 0xDCC7,
0xDCC6, 0xDCC8, 0xDCC9, 0xB6D1, 0xB6CF, 0xE141, 0xE142, 0xB9BB,
0xB9BA, 0xE35A, 0xBC40, 0xBC41, 0xBC42, 0xBC44, 0xE4F2, 0xE4F3,
0xBC43, 0xBEAF, 0xBEB0, 0xF1ED, 0xF5C3, 0xF5C2, 0xF7D1, 0xA44F,
0xA55C, 0xA55B, 0xA648, 0xC9C0, 0xA755, 0xA756, 0xA754, 0xA757,
0xCA6F, 0xCA70, 0xA8F1, 0xCBD5, 0xA8F0, 0xCDF2, 0xAB6C, 0xCDF3,
0xAB6B, 0xAB69, 0xAB6A, 0xD0ED, 0xB0C7, 0xD46E, 0xB0CA, 0xD46D,
0xB1E5, 0xB0C9, 0xB0C8, 0xB3D4, 0xB3D3, 0xB3D2, 0xB6D2, 0xB6D5,
0xB6D6, 0xB6D4, 0xB6D3, 0xE143, 0xE144, 0xE4F5, 0xBC45, 0xE4F4,
0xBEB1, 0xECBF, 0xC079, 0xF1EE, 0xC455, 0xA463, 0xA4C3, 0xC956,
0xA4C4, 0xA4C5, 0xA55D, 0xA55E, 0xA649, 0xCA71, 0xCBD6, 0xCBD7,
0xAB6D, 0xD0EE, 0xB0CC, 0xB0CB, 0xD863, 0xD862, 0xA450, 0xA4C6,
0xA55F, 0xB0CD, 0xC943, 0xC96C, 0xA560, 0xC9C2, 0xA64B, 0xA64A,
0xC9C1, 0xA758, 0xADEA, 0xD46F, 0xB6D7, 0xE145, 0xB9BC, 0xE8FA,
0xF3FD, 0xA4C7, 0xCBD8, 0xCDF4, 0xB0D0, 0xB0CE, 0xB0CF, 0xA451,
0xA464, 0xA2CD, 0xA4CA, 0xA4C9, 0xA4C8, 0xA563, 0xA562, 0xC96D,
0xC9C3, 0xA8F5, 0xA8F2, 0xA8F4, 0xA8F3, 0xAB6E, 0xB3D5, 0xA452,
0xA4CB, 0xA565, 0xA564, 0xCA72, 0xA8F6, 0xC957, 0xA567, 0xA566,
0xA64C, 0xA64D, 0xCA73, 0xA759, 0xA75A, 0xA8F7, 0xA8F8, 0xA8F9,
0xAB6F, 0xCDF5, 0xADEB, 0xC944, 0xA4CC, 0xC9C4, 0xCA74, 0xCA75,
0xCBD9, 0xCBDA, 0xCDF7, 0xCDF6, 0xCDF9, 0xCDF8, 0xAB70, 0xD470,
0xADED, 0xD0EF, 0xADEC, 0xD864, 0xB3D6, 0xD865, 0xE146, 0xB9BD,
0xBC46, 0xF1EF, 0xC958, 0xA568, 0xB0D1, 0xA453, 0xA465, 0xA4CE,
0xA4CD, 0xA4CF, 0xA8FB, 0xA8FA, 0xA8FC, 0xAB71, 0xADEE, 0xE8FB,
0xC24F, 0xA466, 0xA56A, 0xA579, 0xA574, 0xA56F, 0xA56E, 0xA575,
0xA573, 0xA56C, 0xA57A, 0xA56D, 0xA569, 0xA578, 0xA577, 0xA576,
0xA56B, 0xA572, 0xA571, 0xA57B, 0xA570, 0xA653, 0xA659, 0xA655,
0xA65B, 0xC9C5, 0xA658, 0xA64E, 0xA651, 0xA654, 0xA650, 0xA657,
0xA65A, 0xA64F, 0xA652, 0xA656, 0xA65C, 0xCA7E, 0xCA7B, 0xA767,
0xCA7C, 0xA75B, 0xA75D, 0xA775, 0xA770, 0xCAA5, 0xCA7D, 0xA75F,
0xA761, 0xCAA4, 0xA768, 0xCA78, 0xA774, 0xA776, 0xA75C, 0xA76D,
0xCA76, 0xA773, 0xA764, 0xA76E, 0xA76F, 0xCA77, 0xA76C, 0xA76A,
0xA76B, 0xA771, 0xCAA1, 0xA75E, 0xA772, 0xCAA3, 0xA766, 0xA763,
0xCA7A, 0xA762, 0xCAA6, 0xA765, 0xA769, 0xA760, 0xCAA2, 0xCA79,
0xCBEB, 0xCBEA, 0xA94F, 0xCBED, 0xCBEF, 0xCBE4, 0xCBE7, 0xCBEE,
0xA950, 0xCBE1, 0xCBE5, 0xCBE9, 0xCE49, 0xA94B, 0xCE4D, 0xA8FD,
0xCBE6, 0xA8FE, 0xA94C, 0xA945, 0xA941, 0xCBE2, 0xA944, 0xA949,
0xA952, 0xCBE3, 0xCBDC, 0xA943, 0xCBDD, 0xCBDF, 0xA946, 0xA948,
0xCBDB, 0xCBE0, 0xA951, 0xA94D, 0xCBE8, 0xA953, 0xA94A, 0xCBDE,
0xA947, 0xA942, 0xA940, 0xCBEC, 0xA94E, 0xCE48, 0xCDFB, 0xCE4B,
0xCDFD, 0xAB78, 0xABA8, 0xAB74, 0xABA7, 0xAB7D, 0xABA4, 0xAB72,
0xCDFC, 0xCE43, 0xABA3, 0xCE4F, 0xABA5, 0xAB79, 0xCE45, 0xCE42,
0xAB77, 0xCDFA, 0xABA6, 0xCE4A, 0xAB7C, 0xCE4C, 0xABA9, 0xAB73,
0xAB7E, 0xAB7B, 0xCE40, 0xABA1, 0xCE46, 0xCE47, 0xAB7A, 0xABA2,
0xAB76, 0xAB75, 0xCDFE, 0xCE44, 0xCE4E, 0xD144, 0xADFB, 0xD0F1,
0xD0F6, 0xADF4, 0xAE40, 0xD0F4, 0xADEF, 0xADF9, 0xADFE, 0xD0FB,
0xADFA, 0xADFD, 0xD0FE, 0xADF5, 0xD0F5, 0xD142, 0xD143, 0xADF7,
0xD141, 0xADF3, 0xAE43, 0xD0F8, 0xADF1, 0xD146, 0xD0F9, 0xD0FD,
0xADF6, 0xAE42, 0xD0FA, 0xADFC, 0xD140, 0xD147, 0xD4A1, 0xD145,
0xAE44, 0xADF0, 0xD0FC, 0xD0F3, 0xADF8, 0xD0F2, 0xD0F7, 0xD0F0,
0xAE41, 0xD477, 0xB0E4, 0xD4A7, 0xB0E2, 0xB0DF, 0xD47C, 0xB0DB,
0xD4A2, 0xB0E6, 0xD476, 0xD47B, 0xD47A, 0xADF2, 0xB0E1, 0xD4A5,
0xD4A8, 0xD473, 0xB3E8, 0xD4A9, 0xB0E7, 0xB0D9, 0xB0D6, 0xD47E,
0xB0D3, 0xD4A6, 0xB0DA, 0xD4AA, 0xD474, 0xD4A4, 0xB0DD, 0xD475,
0xD478, 0xD47D, 0xB0DE, 0xB0DC, 0xB0E8, 0xB0E3, 0xB0D7, 0xB1D2,
0xB0D8, 0xD479, 0xB0E5, 0xB0E0, 0xD4A3, 0xB0D5, 0xB0D4, 0xD471,
0xD472, 0xD86A, 0xB3D7, 0xB3DA, 0xD875, 0xB3EE, 0xD878, 0xB3D8,
0xD871, 0xB3DE, 0xB3E4, 0xB5BD, 0xB3E2, 0xD86E, 0xB3EF, 0xB3DB,
0xB3E3, 0xD876, 0xDCD7, 0xD87B, 0xD86F, 0xD866, 0xD873, 0xD86D,
0xB3E1, 0xD879, 0xB3DD, 0xB3F1, 0xB3EA, 0xB3DF, 0xB3DC, 0xB3E7,
0xD87A, 0xD86C, 0xD872, 0xD874, 0xD868, 0xD877, 0xB3D9, 0xD867,
0xB3E0, 0xB3F0, 0xB3EC, 0xD869, 0xB3E6, 0xB3ED, 0xB3E9, 0xB3E5,
0xD870, 0xB3EB, 0xDCD5, 0xDCD1, 0xDCE0, 0xDCCA, 0xDCD3, 0xB6E5,
0xB6E6, 0xB6DE, 0xDCDC, 0xB6E8, 0xDCCF, 0xDCCE, 0xDCCC, 0xDCDE,
0xB6DC, 0xDCD8, 0xDCCD, 0xB6DF, 0xDCD6, 0xB6DA, 0xDCD2, 0xDCD9,
0xDCDB, 0xDCDF, 0xB6E3, 0xDCCB, 0xB6DD, 0xDCD0, 0xB6D8, 0xB6E4,
0xDCDA, 0xB6E0, 0xB6E1, 0xB6E7, 0xB6DB, 0xA25F, 0xB6D9, 0xDCD4,
0xB6E2, 0xDCDD, 0xB9CD, 0xB9C8, 0xE155, 0xE151, 0xE14B, 0xB9C2,
0xB9BE, 0xE154, 0xB9BF, 0xE14E, 0xE150, 0xE153, 0xB9C4, 0xB9CB,
0xB9C5, 0xE149, 0xB9C6, 0xB9C7, 0xE14C, 0xB9CC, 0xE14A, 0xE14F,
0xB9C3, 0xE148, 0xB9C9, 0xB9C1, 0xB9C0, 0xE14D, 0xE152, 0xB9CA,
0xE147, 0xBC4D, 0xE547, 0xE544, 0xBC47, 0xBC53, 0xBC54, 0xBC4A,
0xE542, 0xBC4C, 0xE4F9, 0xBC52, 0xE546, 0xBC49, 0xE548, 0xBC48,
0xE543, 0xE545, 0xBC4B, 0xE541, 0xE4FA, 0xE4F7, 0xD86B, 0xE4FD,
0xE4F6, 0xE4FC, 0xE4FB, 0xE4F8, 0xBC4F, 0xBC4E, 0xBC50, 0xE4FE,
0xBEB2, 0xE540, 0xE945, 0xE8FD, 0xBEBE, 0xE942, 0xBEB6, 0xBEBA,
0xE941, 0xBEB9, 0xBEB5, 0xBEB8, 0xBEB3, 0xBEBD, 0xE943, 0xE8FE,
0xBEBC, 0xE8FC, 0xBEBB, 0xE944, 0xE940, 0xBC51, 0xBEBF, 0xE946,
0xBEB7, 0xBEB4, 0xECC6, 0xECC8, 0xC07B, 0xECC9, 0xECC7, 0xECC5,
0xECC4, 0xC07D, 0xECC3, 0xC07E, 0xECC1, 0xECC2, 0xC07A, 0xC0A1,
0xC07C, 0xECC0, 0xC250, 0xEFBC, 0xEFBA, 0xEFBF, 0xEFBD, 0xEFBB,
0xEFBE, 0xC360, 0xF1F2, 0xF1F3, 0xC456, 0xF1F4, 0xF1F0, 0xF1F5,
0xF1F1, 0xC251, 0xF3FE, 0xF441, 0xC459, 0xF440, 0xC458, 0xC457,
0xC45A, 0xF5C5, 0xF5C6, 0xC4DA, 0xC4D9, 0xC4DB, 0xF5C4, 0xF6D8,
0xF6D7, 0xC56D, 0xC56F, 0xC56E, 0xF6D9, 0xC5C8, 0xF8A6, 0xC5F1,
0xF8A5, 0xF8EE, 0xC949, 0xA57D, 0xA57C, 0xA65F, 0xA65E, 0xC9C7,
0xA65D, 0xC9C6, 0xA779, 0xCAA9, 0xCAA8, 0xA777, 0xA77A, 0xCAA7,
0xA778, 0xCBF0, 0xCBF1, 0xA954, 0xABAA, 0xD148, 0xD149, 0xAE45,
0xAE46, 0xD4AC, 0xB0E9, 0xB0EB, 0xD4AB, 0xB0EA, 0xD87C, 0xB3F2,
0xB6E9, 0xB6EA, 0xDCE1, 0xB9CF, 0xB9CE, 0xE549, 0xE948, 0xE947,
0xF96B, 0xA467, 0xC959, 0xC96E, 0xC96F, 0xA662, 0xA666, 0xC9C9,
0xA664, 0xA663, 0xC9C8, 0xA665, 0xA661, 0xA660, 0xC9CA, 0xA7A6,
0xA7A3, 0xA77D, 0xCAAA, 0xCAAB, 0xA7A1, 0xCAAD, 0xA77B, 0xCAAE,
0xCAAC, 0xA77E, 0xA7A2, 0xA7A5, 0xA7A4, 0xA77C, 0xCAAF, 0xA959,
0xCBFE, 0xA95B, 0xA95A, 0xCC40, 0xA958, 0xA957, 0xCBF5, 0xCBF4,
0xCBF2, 0xCBF7, 0xCBF6, 0xCBF3, 0xCBFC, 0xCBFD, 0xCBFA, 0xCBF8,
0xA956, 0xCBFB, 0xA95C, 0xCC41, 0xCBF9, 0xABAB, 0xA955, 0xABAC,
0xCE54, 0xCE5A, 0xABB2, 0xCE58, 0xCE5E, 0xCE55, 0xCE59, 0xCE5B,
0xCE5D, 0xCE57, 0xCE56, 0xCE51, 0xCE52, 0xABAD, 0xABAF, 0xABAE,
0xCE53, 0xCE5C, 0xABB1, 0xCE50, 0xD153, 0xD152, 0xD157, 0xD14E,
0xD151, 0xD150, 0xD154, 0xD158, 0xAE47, 0xAE4A, 0xD14F, 0xD155,
0xAE49, 0xD14A, 0xABB0, 0xD4BA, 0xD156, 0xD14D, 0xAE48, 0xD14C,
0xD4B1, 0xB0EC, 0xB0F0, 0xD4C1, 0xD4AF, 0xD4BD, 0xB0F1, 0xD4BF,
0xD4C5, 0xD4C9, 0xD4C0, 0xD4B4, 0xD4BC, 0xD4CA, 0xD4C8, 0xD4BE,
0xD4B9, 0xD4B2, 0xD8A6, 0xD4B0, 0xB0F5, 0xD4B7, 0xB0F6, 0xB0F2,
0xD4AD, 0xD4C3, 0xD4B5, 0xD4B3, 0xD4C6, 0xB0F3, 0xD4CC, 0xB0ED,
0xB0EF, 0xD4BB, 0xD4B6, 0xAE4B, 0xB0EE, 0xD4B8, 0xD4C7, 0xD4CB,
0xD4C2, 0xD4C4, 0xD4AE, 0xD8A1, 0xD8AA, 0xD8A9, 0xB3FA, 0xD8A2,
0xB3FB, 0xB3F9, 0xD8A4, 0xB3F6, 0xD8A8, 0xD8A3, 0xD8A5, 0xD87D,
0xB3F4, 0xD8B2, 0xD8B1, 0xD8AE, 0xB3F3, 0xB3F7, 0xB3F8, 0xD14B,
0xD8AB, 0xB3F5, 0xB0F4, 0xD8AD, 0xD87E, 0xD8B0, 0xD8AF, 0xD8B3,
0xDCEF, 0xD8AC, 0xD8A7, 0xDCE7, 0xB6F4, 0xB6F7, 0xB6F2, 0xDCE6,
0xDCEA, 0xDCE5, 0xB6EC, 0xB6F6, 0xDCE2, 0xB6F0, 0xDCE9, 0xB6EE,
0xB6ED, 0xDCEC, 0xB6EF, 0xDCEE, 0xDCEB, 0xB6EB, 0xB6F5, 0xDCF0,
0xDCE4, 0xDCED, 0xDCE3, 0xB6F1, 0xB6F3, 0xDCE8, 0xDCF1, 0xE15D,
0xB9D0, 0xE163, 0xB9D5, 0xE15F, 0xE166, 0xE157, 0xB9D7, 0xB9D1,
0xE15C, 0xBC55, 0xE15B, 0xE164, 0xB9D2, 0xB9D6, 0xE15A, 0xE160,
0xE165, 0xE156, 0xB9D4, 0xE15E, 0xE162, 0xE168, 0xE158, 0xE161,
0xB9D3, 0xE167, 0xE159, 0xBC59, 0xE54B, 0xBC57, 0xBC56, 0xE54D,
0xE552, 0xE54E, 0xE551, 0xBC5C, 0xBEA5, 0xBC5B, 0xE54A, 0xE550,
0xBC5A, 0xE54F, 0xE54C, 0xBC58, 0xE94D, 0xE94F, 0xE94A, 0xBEC1,
0xE94C, 0xBEC0, 0xE94E, 0xBEC3, 0xE950, 0xBEC2, 0xE949, 0xE94B,
0xC0A5, 0xECCC, 0xC0A4, 0xECCD, 0xC0A3, 0xECCB, 0xC0A2, 0xECCA,
0xC253, 0xC252, 0xF1F6, 0xF1F8, 0xF1F7, 0xC361, 0xC362, 0xC363,
0xF442, 0xC45B, 0xF7D3, 0xF7D2, 0xC5F2, 0xA468, 0xA4D0, 0xA7A7,
0xCE5F, 0xB3FC, 0xB3FD, 0xDCF2, 0xB9D8, 0xE169, 0xE553, 0xC95A,
0xCAB0, 0xCC42, 0xCE60, 0xD159, 0xAE4C, 0xF1F9, 0xC4DC, 0xA469,
0xA57E, 0xC970, 0xA667, 0xA668, 0xA95D, 0xB0F7, 0xB9DA, 0xB9DB,
0xB9D9, 0xA46A, 0xA4D1, 0xA4D3, 0xA4D2, 0xC95B, 0xA4D4, 0xA5A1,
0xC971, 0xA5A2, 0xA669, 0xA66A, 0xC9CB, 0xA7A8, 0xCAB1, 0xA961,
0xCC43, 0xA95F, 0xA960, 0xA95E, 0xD15A, 0xABB6, 0xABB5, 0xABB7,
0xABB4, 0xCE61, 0xA962, 0xABB3, 0xAE4D, 0xAE4E, 0xAE4F, 0xD4CD,
0xB3FE, 0xD8B4, 0xB0F8, 0xB6F8, 0xB9DD, 0xB9DC, 0xE16A, 0xBC5D,
0xBEC4, 0xEFC0, 0xF6DA, 0xF7D4, 0xA46B, 0xA5A3, 0xA5A4, 0xC9D1,
0xA66C, 0xA66F, 0xC9CF, 0xC9CD, 0xA66E, 0xC9D0, 0xC9D2, 0xC9CC,
0xA671, 0xA670, 0xA66D, 0xA66B, 0xC9CE, 0xA7B3, 0xA7B0, 0xCAB6,
0xCAB9, 0xCAB8, 0xA7AA, 0xA7B2, 0xA7AF, 0xCAB5, 0xCAB3, 0xA7AE,
0xA7A9, 0xA7AC, 0xCAB4, 0xCABB, 0xCAB7, 0xA7AD, 0xA7B1, 0xA7B4,
0xCAB2, 0xCABA, 0xA7AB, 0xA967, 0xA96F, 0xCC4F, 0xCC48, 0xA970,
0xCC53, 0xCC44, 0xCC4B, 0xA966, 0xCC45, 0xA964, 0xCC4C, 0xCC50,
0xA963, 0xCC51, 0xCC4A, 0xCC4D, 0xA972, 0xA969, 0xCC54, 0xCC52,
0xA96E, 0xA96C, 0xCC49, 0xA96B, 0xCC47, 0xCC46, 0xA96A, 0xA968,
0xA971, 0xA96D, 0xA965, 0xCC4E, 0xABB9, 0xABC0, 0xCE6F, 0xABB8,
0xCE67, 0xCE63, 0xCE73, 0xCE62, 0xABBB, 0xCE6C, 0xABBE, 0xABC1,
0xABBC, 0xCE70, 0xABBF, 0xAE56, 0xCE76, 0xCE64, 0xCE66, 0xCE6D,
0xCE71, 0xCE75, 0xCE72, 0xCE6B, 0xCE6E, 0xCE68, 0xABC3, 0xCE6A,
0xCE69, 0xCE74, 0xABBA, 0xCE65, 0xABC2, 0xABBD, 0xAE5C, 0xD162,
0xAE5B, 0xD160, 0xAE50, 0xAE55, 0xD15F, 0xD15C, 0xD161, 0xAE51,
0xD15B, 0xAE54, 0xAE52, 0xD163, 0xAE53, 0xAE57, 0xAE58, 0xAE5A,
0xAE59, 0xD15D, 0xD15E, 0xD164, 0xD4D4, 0xB0F9, 0xD8C2, 0xD4D3,
0xD4E6, 0xB140, 0xD4E4, 0xB0FE, 0xB0FA, 0xD4ED, 0xD4DD, 0xD4E0,
0xB143, 0xD4EA, 0xD4E2, 0xB0FB, 0xB144, 0xD4E7, 0xD4E5, 0xD4D6,
0xD4EB, 0xD4DF, 0xD4DA, 0xD4D0, 0xD4EC, 0xD4DC, 0xD4CF, 0xB142,
0xD4E1, 0xD4EE, 0xD4DE, 0xD4D2, 0xD4D7, 0xD4CE, 0xB141, 0xD4DB,
0xD4D8, 0xB0FC, 0xD4D1, 0xD4E9, 0xB0FD, 0xD4D9, 0xD4D5, 0xD4E8,
0xB440, 0xD8BB, 0xD8B8, 0xD8C9, 0xD8BD, 0xD8CA, 0xB442, 0xD8C6,
0xD8C3, 0xD8C4, 0xD8C7, 0xD8CB, 0xD4E3, 0xD8CD, 0xDD47, 0xB443,
0xD8CE, 0xD8B6, 0xD8C0, 0xD8C5, 0xB441, 0xB444, 0xD8CC, 0xD8CF,
0xD8BA, 0xD8B7, 0xD8B9, 0xD8BE, 0xD8BC, 0xB445, 0xD8C8, 0xD8BF,
0xD8C1, 0xD8B5, 0xDCFA, 0xDCF8, 0xB742, 0xB740, 0xDD43, 0xDCF9,
0xDD44, 0xDD40, 0xDCF7, 0xDD46, 0xDCF6, 0xDCFD, 0xB6FE, 0xB6FD,
0xB6FC, 0xDCFB, 0xDD41, 0xB6F9, 0xB741, 0xDCF4, 0xDCFE, 0xDCF3,
0xDCFC, 0xB6FA, 0xDD42, 0xDCF5, 0xB6FB, 0xDD45, 0xE16E, 0xB9E2,
0xB9E1, 0xB9E3, 0xE17A, 0xE170, 0xE176, 0xE16B, 0xE179, 0xE178,
0xE17C, 0xE175, 0xB9DE, 0xE174, 0xB9E4, 0xE16D, 0xB9DF, 0xE17B,
0xB9E0, 0xE16F, 0xE172, 0xE177, 0xE171, 0xE16C, 0xE173, 0xE555,
0xBC61, 0xE558, 0xE557, 0xE55A, 0xE55C, 0xBC5F, 0xE556, 0xE554,
0xE55D, 0xE55B, 0xE559, 0xE55F, 0xE55E, 0xBC63, 0xBC5E, 0xBC60,
0xBC62, 0xE560, 0xE957, 0xE956, 0xE955, 0xE958, 0xE951, 0xE952,
0xE95A, 0xE953, 0xBEC5, 0xE95C, 0xE95B, 0xE954, 0xECD1, 0xC0A8,
0xECCF, 0xECD4, 0xECD3, 0xE959, 0xC0A7, 0xECD2, 0xECCE, 0xECD6,
0xECD5, 0xC0A6, 0xECD0, 0xBEC6, 0xC254, 0xEFC1, 0xF1FA, 0xF1FB,
0xF1FC, 0xC45C, 0xC45D, 0xF443, 0xF5C8, 0xF5C7, 0xF6DB, 0xF6DC,
0xF7D5, 0xF8A7, 0xA46C, 0xA46D, 0xA46E, 0xA4D5, 0xA5A5, 0xC9D3,
0xA672, 0xA673, 0xA7B7, 0xA7B8, 0xA7B6, 0xA7B5, 0xA973, 0xCC55,
0xA975, 0xA974, 0xCC56, 0xABC4, 0xAE5D, 0xD165, 0xD4F0, 0xB145,
0xB447, 0xD4EF, 0xB446, 0xB9E5, 0xE17D, 0xBEC7, 0xC0A9, 0xECD7,
0xC45E, 0xC570, 0xC972, 0xA5A6, 0xC973, 0xA676, 0xA674, 0xA675,
0xA677, 0xA7BA, 0xA7B9, 0xCABC, 0xA7BB, 0xCABD, 0xCC57, 0xCC58,
0xA976, 0xA978, 0xA97A, 0xA977, 0xA97B, 0xA979, 0xABC8, 0xABC5,
0xABC7, 0xABC9, 0xABC6, 0xD166, 0xCE77, 0xD168, 0xD167, 0xAE63,
0xAE5F, 0xAE60, 0xAE62, 0xAE64, 0xAE61, 0xAE66, 0xAE65, 0xB14A,
0xD4F2, 0xD4F1, 0xB149, 0xB148, 0xB147, 0xB14B, 0xB146, 0xD8D5,
0xD8D2, 0xB449, 0xD8D1, 0xD8D6, 0xB44B, 0xD8D4, 0xB448, 0xB44A,
0xD8D3, 0xDD48, 0xDD49, 0xDD4A, 0xB9E6, 0xB9EE, 0xE17E, 0xB9E8,
0xB9EC, 0xE1A1, 0xB9ED, 0xB9E9, 0xB9EA, 0xB9E7, 0xB9EB, 0xBC66,
0xD8D0, 0xBC67, 0xBC65, 0xBC64, 0xE95D, 0xBEC8, 0xECD8, 0xECD9,
0xC364, 0xC45F, 0xA46F, 0xA678, 0xABCA, 0xD169, 0xAE67, 0xB14E,
0xB14D, 0xB14C, 0xB44C, 0xB44D, 0xD8D7, 0xB9EF, 0xBEC9, 0xA470,
0xC95C, 0xA4D6, 0xC974, 0xC9D4, 0xA679, 0xA97C, 0xDD4B, 0xA471,
0xA4D7, 0xC9D5, 0xCABE, 0xCABF, 0xA7BC, 0xD8D8, 0xB44E, 0xDD4C,
0xC0AA, 0xA472, 0xA4A8, 0xA4D8, 0xC975, 0xA5A7, 0xA7C0, 0xA7BF,
0xA7BD, 0xA7BE, 0xCC59, 0xA97E, 0xA9A1, 0xCC5A, 0xA97D, 0xABCE,
0xCE78, 0xABCD, 0xABCB, 0xABCC, 0xAE6A, 0xAE68, 0xD16B, 0xAE69,
0xD16A, 0xAE5E, 0xD4F3, 0xB150, 0xB151, 0xB14F, 0xB9F0, 0xE1A2,
0xBC68, 0xBC69, 0xE561, 0xC0AB, 0xEFC2, 0xEFC3, 0xC4DD, 0xF8A8,
0xC94B, 0xA4D9, 0xA473, 0xC977, 0xC976, 0xA67A, 0xC9D7, 0xC9D8,
0xC9D6, 0xC9D9, 0xCAC7, 0xCAC2, 0xCAC4, 0xCAC6, 0xCAC3, 0xA7C4,
0xCAC0, 0xCAC1, 0xA7C1, 0xA7C2, 0xCAC5, 0xCAC8, 0xA7C3, 0xCAC9,
0xCC68, 0xCC62, 0xCC5D, 0xA9A3, 0xCC65, 0xCC63, 0xCC5C, 0xCC69,
0xCC6C, 0xCC67, 0xCC60, 0xA9A5, 0xCC66, 0xA9A6, 0xCC61, 0xCC64,
0xCC5B, 0xCC5F, 0xCC6B, 0xA9A7, 0xA9A8, 0xCC5E, 0xCC6A, 0xA9A2,
0xA9A4, 0xCEAB, 0xCEA4, 0xCEAA, 0xCEA3, 0xCEA5, 0xCE7D, 0xCE7B,
0xCEAC, 0xCEA9, 0xCE79, 0xABD0, 0xCEA7, 0xCEA8, 0xCEA6, 0xCE7C,
0xCE7A, 0xABCF, 0xCEA2, 0xCE7E, 0xCEA1, 0xCEAD, 0xAE6F, 0xAE6E,
0xD16C, 0xAE6B, 0xD16E, 0xAE70, 0xD16F, 0xAE73, 0xAE71, 0xD170,
0xCEAE, 0xD172, 0xAE6D, 0xAE6C, 0xD16D, 0xD171, 0xAE72, 0xB153,
0xB152, 0xD4F5, 0xD4F9, 0xD4FB, 0xB154, 0xD4FE, 0xB158, 0xD541,
0xB15A, 0xB156, 0xB15E, 0xB15B, 0xD4F7, 0xB155, 0xD4F6, 0xD4F4,
0xD543, 0xD4F8, 0xB157, 0xD542, 0xB15C, 0xD4FD, 0xD4FC, 0xB15D,
0xD4FA, 0xB159, 0xD544, 0xD540, 0xD8E7, 0xD8EE, 0xD8E3, 0xB451,
0xD8DF, 0xD8EF, 0xD8D9, 0xD8EC, 0xD8EA, 0xD8E4, 0xD8ED, 0xD8E6,
0xD8DE, 0xD8F0, 0xD8DC, 0xD8E9, 0xD8DA, 0xD8F1, 0xB452, 0xD8EB,
0xDD4F, 0xD8DD, 0xB44F, 0xD8E1, 0xB450, 0xD8E0, 0xD8E5, 0xD8E2,
0xD8E8, 0xDD53, 0xDD56, 0xDD4E, 0xDD50, 0xDD55, 0xDD54, 0xB743,
0xD8DB, 0xDD52, 0xB744, 0xDD4D, 0xDD51, 0xE1A9, 0xE1B0, 0xE1A7,
0xE1AE, 0xE1A5, 0xE1AD, 0xE1B1, 0xE1A4, 0xE1A8, 0xE1A3, 0xB9F1,
0xE1A6, 0xB9F2, 0xE1AC, 0xE1AB, 0xE1AA, 0xE1AF, 0xE565, 0xE567,
0xBC6B, 0xE568, 0xE563, 0xE562, 0xE56C, 0xE56A, 0xBC6A, 0xE56D,
0xE564, 0xE569, 0xE56B, 0xE566, 0xE961, 0xE966, 0xE960, 0xE965,
0xE95E, 0xE968, 0xE964, 0xE969, 0xE963, 0xE95F, 0xE967, 0xE96A,
0xE962, 0xECDA, 0xC0AF, 0xC0AD, 0xC0AC, 0xC0AE, 0xEFC4, 0xF172,
0xF1FD, 0xF444, 0xF445, 0xC460, 0xF5C9, 0xC4DE, 0xF5CA, 0xF6DE,
0xC572, 0xC571, 0xF6DD, 0xC5C9, 0xF7D6, 0xA474, 0xA67B, 0xC9DA,
0xCACA, 0xA8B5, 0xB15F, 0xA475, 0xA5AA, 0xA5A9, 0xA5A8, 0xA7C5,
0xAE74, 0xDD57, 0xA476, 0xA477, 0xA478, 0xA4DA, 0xABD1, 0xCEAF,
0xB453, 0xA479, 0xC95D, 0xA5AB, 0xA5AC, 0xC978, 0xA67C, 0xCACB,
0xA7C6, 0xCACC, 0xA9AE, 0xCC6E, 0xA9AC, 0xA9AB, 0xCC6D, 0xA9A9,
0xCC6F, 0xA9AA, 0xA9AD, 0xABD2, 0xABD4, 0xCEB3, 0xCEB0, 0xCEB1,
0xCEB2, 0xCEB4, 0xABD3, 0xD174, 0xD173, 0xAE76, 0xAE75, 0xB162,
0xD546, 0xB161, 0xB163, 0xB160, 0xB455, 0xD545, 0xB456, 0xD8F3,
0xB457, 0xD8F2, 0xB454, 0xDD5A, 0xDD5C, 0xB745, 0xDD5B, 0xDD59,
0xDD58, 0xE1B4, 0xB9F7, 0xB9F5, 0xB9F6, 0xE1B2, 0xE1B3, 0xB9F3,
0xE571, 0xE56F, 0xBC6D, 0xE570, 0xBC6E, 0xBC6C, 0xB9F4, 0xE96D,
0xE96B, 0xE96C, 0xE56E, 0xECDC, 0xC0B0, 0xECDB, 0xEFC5, 0xEFC6,
0xE96E, 0xF1FE, 0xA47A, 0xA5AD, 0xA67E, 0xC9DB, 0xA67D, 0xA9AF,
0xB746, 0xA4DB, 0xA5AE, 0xABD5, 0xB458, 0xC979, 0xC97A, 0xC9DC,
0xA7C8, 0xCAD0, 0xCACE, 0xA7C9, 0xCACD, 0xCACF, 0xCAD1, 0xA7C7,
0xA9B3, 0xA9B4, 0xA9B1, 0xA9B0, 0xCEB8, 0xA9B2, 0xABD6, 0xCEB7,
0xCEB9, 0xCEB6, 0xCEBA, 0xABD7, 0xAE79, 0xD175, 0xD177, 0xAE77,
0xD178, 0xAE78, 0xD176, 0xCEB5, 0xD547, 0xD54A, 0xD54B, 0xD548,
0xB167, 0xB166, 0xB164, 0xB165, 0xD549, 0xB168, 0xB45A, 0xB45B,
0xB45C, 0xDD5D, 0xDD5F, 0xDD61, 0xB748, 0xB747, 0xB459, 0xDD60,
0xDD5E, 0xE1B8, 0xE1B6, 0xE1BC, 0xB9F8, 0xE1BD, 0xE1BA, 0xB9F9,
0xE1B7, 0xE1B5, 0xE1BB, 0xBC70, 0xE573, 0xE1B9, 0xBC72, 0xE574,
0xBC71, 0xBC74, 0xE575, 0xBC6F, 0xBC73, 0xE973, 0xE971, 0xE970,
0xE972, 0xE96F, 0xC366, 0xF446, 0xF447, 0xF5CB, 0xF6DF, 0xC655,
0xA9B5, 0xA7CA, 0xABD8, 0xA47B, 0xA4DC, 0xA5AF, 0xC9DD, 0xA7CB,
0xCAD2, 0xCEBB, 0xABD9, 0xB9FA, 0xA47C, 0xA6A1, 0xB749, 0xA47D,
0xA4DD, 0xA4DE, 0xA5B1, 0xA5B0, 0xC9DE, 0xA6A2, 0xCAD3, 0xA7CC,
0xCC71, 0xCC72, 0xCC73, 0xA9B6, 0xA9B7, 0xCC70, 0xA9B8, 0xABDA,
0xCEBC, 0xD17A, 0xAE7A, 0xD179, 0xB169, 0xD54C, 0xB16A, 0xD54D,
0xB45D, 0xDD62, 0xE1BF, 0xE1BE, 0xB9FB, 0xBC75, 0xE576, 0xBECA,
0xE974, 0xC0B1, 0xC573, 0xF7D8, 0xCC74, 0xCEBD, 0xB16B, 0xD8F4,
0xB74A, 0xC255, 0xA7CE, 0xA7CD, 0xABDB, 0xD17B, 0xB16D, 0xB343,
0xB16E, 0xB16C, 0xB45E, 0xE1C0, 0xB9FC, 0xBC76, 0xC94C, 0xC9DF,
0xCAD5, 0xA7CF, 0xCAD4, 0xA7D0, 0xA9BC, 0xCC77, 0xCC76, 0xA9BB,
0xA9B9, 0xA9BA, 0xCC75, 0xABDD, 0xCEBE, 0xABE0, 0xABDC, 0xABE2,
0xABDE, 0xABDF, 0xABE1, 0xAE7D, 0xAE7C, 0xAE7B, 0xD54F, 0xB16F,
0xB172, 0xB170, 0xD54E, 0xB175, 0xB171, 0xD550, 0xB174, 0xB173,
0xD8F6, 0xD8F5, 0xB461, 0xB45F, 0xB460, 0xD8F7, 0xB74B, 0xDD64,
0xB74C, 0xDD63, 0xE577, 0xBC78, 0xE1C1, 0xBC77, 0xB9FD, 0xECDE,
0xE975, 0xC0B2, 0xECDD, 0xF240, 0xF448, 0xF449, 0xA4DF, 0xA5B2,
0xC97B, 0xA7D2, 0xA7D4, 0xC9E2, 0xCAD8, 0xCAD7, 0xCAD6, 0xC9E1,
0xC9E0, 0xA6A4, 0xA7D3, 0xA7D1, 0xA6A3, 0xA9BD, 0xCC78, 0xA9BE,
0xCADD, 0xCADF, 0xCADE, 0xCC79, 0xCADA, 0xA7D8, 0xA7D6, 0xCAD9,
0xCADB, 0xCAE1, 0xA7D5, 0xCADC, 0xCAE5, 0xA9C0, 0xCAE2, 0xA7D7,
0xCAE0, 0xCAE3, 0xA9BF, 0xA9C1, 0xCAE4, 0xCCAF, 0xCCA2, 0xCC7E,
0xCCAE, 0xCCA9, 0xABE7, 0xA9C2, 0xCCAA, 0xCCAD, 0xABE3, 0xCCAC,
0xA9C3, 0xA9C8, 0xA9C6, 0xCCA3, 0xCC7C, 0xCCA5, 0xA9CD, 0xCCB0,
0xABE4, 0xCCA6, 0xABE5, 0xA9C9, 0xCCA8, 0xCECD, 0xABE6, 0xCC7B,
0xA9CA, 0xABE8, 0xA9CB, 0xA9C7, 0xA9CC, 0xCCA7, 0xCC7A, 0xCCAB,
0xA9C4, 0xCC7D, 0xCCA4, 0xCCA1, 0xA9C5, 0xCEBF, 0xCEC0, 0xCECA,
0xD1A1, 0xCECB, 0xABEE, 0xCECE, 0xCEC4, 0xABED, 0xCEC6, 0xCEC7,
0xCEC9, 0xABE9, 0xAEA3, 0xCEC5, 0xCEC1, 0xAEA4, 0xCECF, 0xAE7E,
0xD17D, 0xCEC8, 0xD17C, 0xCEC3, 0xCECC, 0xABEC, 0xAEA1, 0xABF2,
0xAEA2, 0xCED0, 0xD17E, 0xABEB, 0xAEA6, 0xABF1, 0xABF0, 0xABEF,
0xAEA5, 0xCED1, 0xAEA7, 0xABEA, 0xCEC2, 0xB176, 0xD1A4, 0xD1A6,
0xD1A8, 0xAEA8, 0xAEAE, 0xD553, 0xD1AC, 0xD1A3, 0xB178, 0xD551,
0xAEAD, 0xAEAB, 0xD1AE, 0xD552, 0xD1A5, 0xAEAC, 0xD1A9, 0xAEAF,
0xD1AB, 0xAEAA, 0xD1AA, 0xD1AD, 0xD1A7, 0xAEA9, 0xB179, 0xD1A2,
0xB177, 0xB17A, 0xD555, 0xD55E, 0xB464, 0xB17C, 0xB1A3, 0xB465,
0xD560, 0xB1AA, 0xD8F9, 0xD556, 0xB1A2, 0xB1A5, 0xB17E, 0xD554,
0xD562, 0xD565, 0xD949, 0xD563, 0xD8FD, 0xB1A1, 0xB1A8, 0xB1AC,
0xD55D, 0xD8F8, 0xD561, 0xB17B, 0xD8FA, 0xD564, 0xD8FC, 0xD559,
0xB462, 0xD557, 0xD558, 0xB1A7, 0xB1A6, 0xD55B, 0xB1AB, 0xD55F,
0xB1A4, 0xD55C, 0xB1A9, 0xB466, 0xB463, 0xD8FB, 0xD55A, 0xB17D,
0xB46B, 0xB46F, 0xD940, 0xB751, 0xB46D, 0xD944, 0xB471, 0xDD65,
0xD946, 0xB753, 0xB469, 0xB46C, 0xD947, 0xD948, 0xD94E, 0xB473,
0xB754, 0xD94A, 0xD94F, 0xD943, 0xB75E, 0xB755, 0xB472, 0xD941,
0xD950, 0xB75D, 0xB470, 0xB74E, 0xD94D, 0xB474, 0xD945, 0xD8FE,
0xB46A, 0xD942, 0xD94B, 0xB74D, 0xB752, 0xB467, 0xD94C, 0xB750,
0xB468, 0xB75C, 0xE1C3, 0xDD70, 0xDD68, 0xE1C2, 0xDD6C, 0xDD6E,
0xDD6B, 0xB75B, 0xDD6A, 0xB75F, 0xE1D2, 0xB75A, 0xBA40, 0xDD71,
0xE1C4, 0xB758, 0xDD69, 0xDD6D, 0xB9FE, 0xB74F, 0xDD66, 0xDD67,
0xBA41, 0xB757, 0xB759, 0xB756, 0xDD6F, 0xE1C8, 0xE1C9, 0xE1CE,
0xBC7D, 0xE1D5, 0xBA47, 0xBA46, 0xE1D0, 0xBC7C, 0xE1C5, 0xBA45,
0xE1D4, 0xBA43, 0xBA44, 0xE1D1, 0xE5AA, 0xBC7A, 0xB46E, 0xE1D3,
0xBCA3, 0xE1CB, 0xBC7B, 0xBCA2, 0xE1C6, 0xE1CA, 0xE1C7, 0xE1CD,
0xBA48, 0xBC79, 0xBA42, 0xE57A, 0xE1CF, 0xBCA1, 0xBCA4, 0xE1CC,
0xBC7E, 0xE579, 0xE57E, 0xBECE, 0xE578, 0xE9A3, 0xE5A9, 0xBCA8,
0xBCA6, 0xBECC, 0xE5A6, 0xE5A2, 0xBCAC, 0xE978, 0xBCAA, 0xE5A1,
0xE976, 0xE5A5, 0xE5A8, 0xE57D, 0xBCAB, 0xBCA5, 0xE977, 0xBECD,
0xE5A7, 0xBCA7, 0xBCA9, 0xE5A4, 0xBCAD, 0xE5A3, 0xE57C, 0xE57B,
0xBECB, 0xE5AB, 0xE97A, 0xECE0, 0xBED0, 0xE9A2, 0xE97E, 0xECE1,
0xBED1, 0xE9A1, 0xE97C, 0xC0B4, 0xECDF, 0xE979, 0xE97B, 0xC0B5,
0xBED3, 0xC0B3, 0xBED2, 0xC0B7, 0xE97D, 0xBECF, 0xEFCF, 0xEFC7,
0xECE7, 0xEFC8, 0xECE3, 0xC256, 0xECE5, 0xECE4, 0xC0B6, 0xECE2,
0xECE6, 0xEFD0, 0xEFCC, 0xEFCE, 0xEFC9, 0xEFCA, 0xEFCD, 0xEFCB,
0xC367, 0xC36A, 0xC369, 0xC368, 0xC461, 0xF44A, 0xC462, 0xF241,
0xC4DF, 0xF5CC, 0xC4E0, 0xC574, 0xC5CA, 0xF7D9, 0xF7DA, 0xF7DB,
0xF9BA, 0xA4E0, 0xC97C, 0xA5B3, 0xA6A6, 0xA6A7, 0xA6A5, 0xA6A8,
0xA7DA, 0xA7D9, 0xCCB1, 0xA9CF, 0xA9CE, 0xD1AF, 0xB1AD, 0xB1AE,
0xB475, 0xDD72, 0xB760, 0xB761, 0xDD74, 0xDD76, 0xDD75, 0xE1D7,
0xE1D6, 0xBA49, 0xE1D8, 0xE5AC, 0xBCAE, 0xBED4, 0xC0B8, 0xC257,
0xC0B9, 0xA4E1, 0xCAE6, 0xCCB2, 0xA9D1, 0xA9D0, 0xA9D2, 0xABF3,
0xCED2, 0xCED3, 0xD1B0, 0xAEB0, 0xB1AF, 0xB476, 0xD951, 0xA4E2,
0xA47E, 0xA4E3, 0xC97D, 0xA5B7, 0xA5B6, 0xA5B4, 0xA5B5, 0xA6AB,
0xC9E9, 0xC9EB, 0xA6AA, 0xC9E3, 0xC9E4, 0xC9EA, 0xC9E6, 0xC9E8,
0xA6A9, 0xC9E5, 0xC9EC, 0xC9E7, 0xA7E1, 0xA7EA, 0xA7E8, 0xCAF0,
0xCAED, 0xCAF5, 0xA7E6, 0xCAF6, 0xA7DF, 0xCAF3, 0xA7E5, 0xCAEF,
0xCAEE, 0xA7E3, 0xCAF4, 0xA7E4, 0xA9D3, 0xA7DE, 0xCAF1, 0xCAE7,
0xA7DB, 0xA7EE, 0xCAEC, 0xCAF2, 0xA7E0, 0xA7E2, 0xCAE8, 0xCAE9,
0xCAEA, 0xA7ED, 0xA7E7, 0xA7EC, 0xCAEB, 0xA7EB, 0xA7DD, 0xA7DC,
0xA7E9, 0xA9E1, 0xCCBE, 0xCCB7, 0xA9DC, 0xA9EF, 0xCCB3, 0xCCBA,
0xCCBC, 0xCCBF, 0xA9EA, 0xCCBB, 0xCCB4, 0xA9E8, 0xCCB8, 0xCCC0,
0xA9D9, 0xCCBD, 0xA9E3, 0xA9E2, 0xCCB6, 0xA9D7, 0xA9D8, 0xA9D6,
0xA9EE, 0xA9E6, 0xA9E0, 0xA9D4, 0xCCB9, 0xA9DF, 0xA9D5, 0xA9E7,
0xA9F0, 0xCED4, 0xA9E4, 0xCCB5, 0xA9DA, 0xA9DD, 0xA9DE, 0xA9EC,
0xA9ED, 0xA9EB, 0xA9E5, 0xA9E9, 0xA9DB, 0xABF4, 0xCEDA, 0xAC41,
0xABF8, 0xABFA, 0xAC40, 0xCEE6, 0xABFD, 0xD1B1, 0xAEB1, 0xAC43,
0xCED7, 0xCEDF, 0xABFE, 0xCEDE, 0xCEDB, 0xCEE3, 0xCEE5, 0xABF7,
0xABFB, 0xAC42, 0xAEB3, 0xCEE0, 0xABF9, 0xAC45, 0xCED9, 0xABFC,
0xAEB2, 0xABF6, 0xCED6, 0xCEDD, 0xCED5, 0xCED8, 0xCEDC, 0xD1B2,
0xAC44, 0xCEE1, 0xCEE2, 0xCEE4, 0xABF5, 0xAEC1, 0xD1BE, 0xAEBF,
0xAEC0, 0xD1B4, 0xD1C4, 0xAEB6, 0xD566, 0xD1C6, 0xD1C0, 0xD1B7,
0xD1C9, 0xD1BA, 0xAEBC, 0xD57D, 0xD1BD, 0xAEBE, 0xAEB5, 0xD1CB,
0xD1BF, 0xAEB8, 0xD1B8, 0xD1B5, 0xD1B6, 0xAEB9, 0xD1C5, 0xD1CC,
0xAEBB, 0xD1BC, 0xD1BB, 0xAEC3, 0xAEC2, 0xAEB4, 0xAEBA, 0xAEBD,
0xD1C8, 0xD1C2, 0xAEB7, 0xD1B3, 0xD1CA, 0xD1C1, 0xD1C3, 0xD1C7,
0xD567, 0xB1B7, 0xB1CB, 0xB1CA, 0xB1BF, 0xD579, 0xD575, 0xD572,
0xD5A6, 0xB1BA, 0xB1B2, 0xD577, 0xB4A8, 0xB1B6, 0xD5A1, 0xB1CC,
0xB1C9, 0xD57B, 0xD56A, 0xB1C8, 0xD5A3, 0xD569, 0xB1BD, 0xB1C1,
0xD5A2, 0xD573, 0xB1C2, 0xB1BC, 0xD568, 0xB478, 0xD5A5, 0xD571,
0xB1C7, 0xD574, 0xD5A4, 0xB1C6, 0xD952, 0xB1B3, 0xD56F, 0xB1B8,
0xB1C3, 0xB1BE, 0xD578, 0xD56E, 0xD56C, 0xD57E, 0xB1B0, 0xB1C4,
0xB1B4, 0xB477, 0xD57C, 0xB1B5, 0xB1B1, 0xB1C0, 0xB1BB, 0xB1B9,
0xD570, 0xB1C5, 0xD56D, 0xD57A, 0xD576, 0xD954, 0xD953, 0xD56B,
0xD964, 0xB47A, 0xD96A, 0xD959, 0xD967, 0xDD77, 0xB47D, 0xD96B,
0xD96E, 0xB47C, 0xD95C, 0xD96D, 0xD96C, 0xB47E, 0xD955, 0xB479,
0xB4A3, 0xB4A1, 0xD969, 0xD95F, 0xB4A5, 0xD970, 0xD968, 0xD971,
0xB4AD, 0xB4AB, 0xD966, 0xD965, 0xD963, 0xD95D, 0xB4A4, 0xB4A2,
0xD1B9, 0xD956, 0xDDB7, 0xD957, 0xB47B, 0xB4AA, 0xDD79, 0xB4A6,
0xB4A7, 0xD958, 0xD96F, 0xDD78, 0xD960, 0xD95B, 0xB4A9, 0xD961,
0xD95E, 0xB4AE, 0xB770, 0xDD7C, 0xDDB1, 0xDDB6, 0xDDAA, 0xB76C,
0xDDBB, 0xB769, 0xDD7A, 0xDD7B, 0xB762, 0xB76B, 0xDDA4, 0xB76E,
0xB76F, 0xDDA5, 0xDDB2, 0xDDB8, 0xB76A, 0xB764, 0xDDA3, 0xDD7D,
0xDDBA, 0xDDA8, 0xDDA9, 0xDD7E, 0xDDB4, 0xDDAB, 0xDDB5, 0xDDAD,
0xB765, 0xE1D9, 0xB768, 0xB766, 0xDDB9, 0xDDB0, 0xDDAC, 0xDDA1,
0xBA53, 0xDDAF, 0xB76D, 0xDDA7, 0xDDA6, 0xB767, 0xB763, 0xE1EE,
0xDDB3, 0xDDAE, 0xDDA2, 0xE1E9, 0xE1DA, 0xE1E5, 0xE1EC, 0xBA51,
0xB4AC, 0xE1EA, 0xBA4C, 0xBA4B, 0xE1F1, 0xE1DB, 0xE1E8, 0xE1DC,
0xE1E7, 0xBA4F, 0xE1EB, 0xD962, 0xE1F2, 0xE1E3, 0xBA52, 0xE5BA,
0xBCAF, 0xE1F0, 0xE1EF, 0xBA54, 0xE5AD, 0xBCB0, 0xE5AE, 0xE1DF,
0xE1E0, 0xE1DD, 0xE1E2, 0xE1DE, 0xE1F3, 0xBA4E, 0xBCB1, 0xBA50,
0xBA55, 0xE1E1, 0xE1ED, 0xE1E6, 0xE5B1, 0xBA4A, 0xBCB4, 0xE9AA,
0xE5B6, 0xE5B5, 0xE5B7, 0xE5B4, 0xBCB5, 0xBCBB, 0xBCB8, 0xBCB9,
0xE5AF, 0xE5B2, 0xE5BC, 0xBCC1, 0xBCBF, 0xE5B3, 0xD95A, 0xBCB2,
0xE5B9, 0xE5B0, 0xBCC2, 0xE5B8, 0xBA4D, 0xBCB7, 0xE1E4, 0xBCBA,
0xBCBE, 0xBCC0, 0xBCBD, 0xBCBC, 0xBCB6, 0xE5BB, 0xBCB3, 0xBCC3,
0xBED8, 0xBED9, 0xE9A9, 0xBEE2, 0xBEDF, 0xBED6, 0xBEDD, 0xE9AB,
0xBEDB, 0xBED5, 0xBEDC, 0xE9A8, 0xC0BB, 0xBED7, 0xBEDE, 0xC0BA,
0xE9A7, 0xE9A6, 0xBEE0, 0xBEE1, 0xE9A5, 0xE9A4, 0xC0BC, 0xE9AE,
0xBEDA, 0xE9AC, 0xC0BD, 0xC0C2, 0xECEA, 0xECEC, 0xC0BF, 0xECED,
0xECE9, 0xECEB, 0xC0C0, 0xC0C3, 0xECE8, 0xC0BE, 0xC0C1, 0xC259,
0xE9AD, 0xC258, 0xC25E, 0xEFD4, 0xC25C, 0xC25D, 0xEFD7, 0xEFD3,
0xC25A, 0xEFD1, 0xC36B, 0xEFD5, 0xEFD6, 0xEFD2, 0xC25B, 0xF242,
0xF245, 0xF246, 0xF244, 0xF247, 0xC36C, 0xF243, 0xF44E, 0xC464,
0xF44D, 0xF44C, 0xF44B, 0xC463, 0xC465, 0xF5CD, 0xC4E2, 0xC4E1,
0xF6E1, 0xF6E0, 0xF6E3, 0xC5CB, 0xC575, 0xF7DD, 0xF6E2, 0xF7DC,
0xC5CD, 0xC5CC, 0xC5F3, 0xF8A9, 0xF8EF, 0xA4E4, 0xD972, 0xE9AF,
0xA6AC, 0xCAF7, 0xA7F1, 0xA7EF, 0xA7F0, 0xCCC1, 0xA9F1, 0xAC46,
0xCEE7, 0xCEE8, 0xAC47, 0xD1CE, 0xAEC4, 0xAEC5, 0xD1CD, 0xB1D3,
0xB1CF, 0xD5A7, 0xB1D6, 0xB1D5, 0xB1CE, 0xB1D1, 0xB1D4, 0xB1D0,
0xD976, 0xB1CD, 0xB4AF, 0xB4B1, 0xB4B2, 0xD975, 0xD978, 0xB4B0,
0xD973, 0xD977, 0xD974, 0xB771, 0xDDBC, 0xBA56, 0xE1F4, 0xBEE3,
0xBCC4, 0xE5BD, 0xBCC5, 0xBCC6, 0xE5BF, 0xE5BE, 0xE5C0, 0xE9B1,
0xE9B0, 0xECEF, 0xECEE, 0xC0C4, 0xC0C5, 0xF248, 0xA4E5, 0xD979,
0xB4B4, 0xB4B3, 0xDDBD, 0xEFD8, 0xC4E3, 0xF7DE, 0xA4E6, 0xAEC6,
0xB1D8, 0xB1D7, 0xD97A, 0xD97B, 0xB772, 0xE1F5, 0xBA57, 0xE9B2,
0xA4E7, 0xA5B8, 0xA9F2, 0xCCC2, 0xCEE9, 0xAC48, 0xB1D9, 0xD97C,
0xB4B5, 0xB773, 0xE5C1, 0xE5C2, 0xECF0, 0xC25F, 0xF8F0, 0xA4E8,
0xCCC3, 0xA9F3, 0xAC49, 0xCEEA, 0xAEC7, 0xD1D2, 0xD1D0, 0xD1D1,
0xAEC8, 0xD1CF, 0xB1DB, 0xB1DC, 0xD5A8, 0xB1DD, 0xB1DA, 0xD97D,
0xD97E, 0xDDBE, 0xBA59, 0xBA58, 0xECF1, 0xEFD9, 0xF24A, 0xF249,
0xF44F, 0xC95E, 0xAC4A, 0xA4E9, 0xA5B9, 0xA6AE, 0xA6AD, 0xA6AF,
0xA6B0, 0xC9EE, 0xC9ED, 0xCAF8, 0xA7F2, 0xCAFB, 0xCAFA, 0xCAF9,
0xCAFC, 0xA9F4, 0xCCC9, 0xCCC5, 0xCCCE, 0xA9FB, 0xA9F9, 0xCCCA,
0xCCC6, 0xCCCD, 0xA9F8, 0xAA40, 0xCCC8, 0xCCC4, 0xA9FE, 0xCCCB,
0xA9F7, 0xCCCC, 0xA9FA, 0xA9FC, 0xCCD0, 0xCCCF, 0xCCC7, 0xA9F6,
0xA9F5, 0xA9FD, 0xCEEF, 0xCEF5, 0xAC50, 0xAC4D, 0xCEEC, 0xCEF1,
0xAC53, 0xAC4B, 0xCEF0, 0xAC4E, 0xAC51, 0xCEF3, 0xAC4C, 0xCEF8,
0xAC4F, 0xAC52, 0xCEED, 0xCEF2, 0xCEF6, 0xCEEE, 0xCEEB, 0xCEF7,
0xCEF4, 0xAED0, 0xAEC9, 0xAECC, 0xAECF, 0xD1D5, 0xAECA, 0xD1D3,
0xAECE, 0xAECB, 0xD1D6, 0xAECD, 0xD5AC, 0xB1DF, 0xD5AB, 0xD5AD,
0xB1DE, 0xB1E3, 0xD1D4, 0xD5AA, 0xD5AE, 0xB1E0, 0xD5A9, 0xB1E2,
0xB1E1, 0xD9A7, 0xD9A2, 0xB4B6, 0xB4BA, 0xB4B7, 0xD9A5, 0xD9A8,
0xB4B8, 0xB4B9, 0xB4BE, 0xDDC7, 0xD9A6, 0xB4BC, 0xD9A3, 0xD9A1,
0xB4BD, 0xD9A4, 0xB779, 0xDDBF, 0xB776, 0xB777, 0xB775, 0xDDC4,
0xDDC3, 0xDDC0, 0xB77B, 0xDDC2, 0xB4BB, 0xDDC6, 0xDDC1, 0xB778,
0xB774, 0xB77A, 0xDDC5, 0xBA5C, 0xE1F8, 0xE1F7, 0xE1F6, 0xBA5A,
0xBA5B, 0xE5C5, 0xE5C8, 0xBCC8, 0xBCC7, 0xE5C9, 0xE5C4, 0xBCCA,
0xE5C6, 0xBCC9, 0xE5C3, 0xE5C7, 0xBEE9, 0xBEE6, 0xE9BB, 0xE9BA,
0xE9B9, 0xE9B4, 0xE9B5, 0xBEE7, 0xBEE4, 0xBEE8, 0xE9B3, 0xBEE5,
0xE9B6, 0xE9B7, 0xE9BC, 0xE9B8, 0xECF2, 0xC0C7, 0xEFDC, 0xC0C6,
0xEFDA, 0xEFDB, 0xC260, 0xC36E, 0xF24B, 0xC36D, 0xF451, 0xF452,
0xC466, 0xF450, 0xC4E4, 0xF7DF, 0xC5CE, 0xF8AA, 0xF8AB, 0xA4EA,
0xA6B1, 0xA6B2, 0xA7F3, 0xCCD1, 0xAC54, 0xAED1, 0xB1E4, 0xB0D2,
0xB4BF, 0xB4C0, 0xB3CC, 0xD9A9, 0xB77C, 0xE1FA, 0xE1F9, 0xA4EB,
0xA6B3, 0xCCD2, 0xAA42, 0xAA41, 0xCEF9, 0xCEFA, 0xD1D7, 0xD1D8,
0xAED2, 0xAED3, 0xAED4, 0xD5AF, 0xB1E6, 0xB4C2, 0xB4C1, 0xDDC8,
0xDF7A, 0xE1FB, 0xE9BD, 0xC261, 0xC467, 0xA4EC, 0xA5BC, 0xA5BD,
0xA5BB, 0xA5BE, 0xA5BA, 0xA6B6, 0xC9F6, 0xA6B5, 0xA6B7, 0xC9F1,
0xC9F0, 0xC9F3, 0xC9F2, 0xC9F5, 0xA6B4, 0xC9EF, 0xC9F4, 0xCAFD,
0xA7FD, 0xCAFE, 0xCB43, 0xA7FC, 0xCB47, 0xCB42, 0xCB45, 0xA7F5,
0xA7F6, 0xA7F7, 0xA7F8, 0xA840, 0xCB41, 0xA7FA, 0xA841, 0xCB40,
0xCB46, 0xA7F9, 0xCB44, 0xA7FB, 0xA7F4, 0xA7FE, 0xAA57, 0xCCD4,
0xAA43, 0xAA4D, 0xAA4E, 0xAA46, 0xAA58, 0xAA48, 0xCCDC, 0xAA53,
0xCCD7, 0xAA49, 0xCCE6, 0xCCE7, 0xCCDF, 0xCCD8, 0xAA56, 0xCCE4,
0xAA51, 0xAA4F, 0xCCE5, 0xCCE3, 0xCCDB, 0xCCD3, 0xCCDA, 0xAA4A,
0xAA50, 0xAA44, 0xCCDE, 0xCCDD, 0xCCD5, 0xAA52, 0xCCE1, 0xCCD6,
0xAA55, 0xCCE8, 0xAA45, 0xAA4C, 0xCCD9, 0xCCE2, 0xAA54, 0xAA47,
0xAA4B, 0xCCE0, 0xCF5B, 0xAC5C, 0xAC69, 0xCF56, 0xCF4C, 0xAC62,
0xCF4A, 0xAC5B, 0xCF45, 0xAC65, 0xCF52, 0xCEFE, 0xCF41, 0xCF44,
0xCEFB, 0xCF51, 0xCF61, 0xAC60, 0xCF46, 0xCF58, 0xCEFD, 0xCF5F,
0xCF60, 0xCF63, 0xCF5A, 0xCF4B, 0xCF53, 0xAC66, 0xAC59, 0xAC61,
0xAC6D, 0xAC56, 0xAC58, 0xCF43, 0xAC6A, 0xAC63, 0xCF5D, 0xCF40,
0xAC6C, 0xAC67, 0xCF49, 0xAC6B, 0xCF50, 0xCF48, 0xAC64, 0xCF5C,
0xCF54, 0xAC5E, 0xCF62, 0xCF47, 0xAC5A, 0xCF59, 0xCF4F, 0xAC5F,
0xCF55, 0xAC57, 0xCEFC, 0xAC68, 0xAEE3, 0xAC5D, 0xCF4E, 0xCF4D,
0xCF42, 0xCF5E, 0xCF57, 0xAC55, 0xD1EC, 0xAEEA, 0xD1ED, 0xD1E1,
0xAEDF, 0xAEEB, 0xD1DA, 0xD1E3, 0xD1EB, 0xD1D9, 0xD1F4, 0xAED5,
0xD1F3, 0xD1EE, 0xD1EF, 0xAEDD, 0xAEE8, 0xD1E5, 0xD1E6, 0xD1F0,
0xD1E7, 0xD1E2, 0xD1DC, 0xD1DD, 0xD1EA, 0xD1E4, 0xAED6, 0xAEDA,
0xD1F2, 0xD1DE, 0xAEE6, 0xAEE2, 0xAEE5, 0xAEEC, 0xAEDB, 0xAEE7,
0xD1E9, 0xAEE9, 0xAED8, 0xAED7, 0xD1DB, 0xD1DF, 0xAEE0, 0xD1F1,
0xD1E8, 0xD1E0, 0xAEE4, 0xAEE1, 0xAED9, 0xAEDC, 0xD5C4, 0xD5B4,
0xD5B5, 0xD5B9, 0xD5C8, 0xD5C5, 0xD5BE, 0xD5BD, 0xB1ED, 0xD5C1,
0xD5D0, 0xD5B0, 0xD5D1, 0xD5C3, 0xD5D5, 0xD5C9, 0xB1EC, 0xD5C7,
0xB1E7, 0xB1FC, 0xB1F2, 0xB1F6, 0xB1F5, 0xD5B1, 0xD5CE, 0xD5D4,
0xD5CC, 0xD5D3, 0xD5C0, 0xD5B2, 0xD5D2, 0xD5C2, 0xB1EA, 0xB1F7,
0xD5CB, 0xB1F0, 0xD5CA, 0xD5B3, 0xB1F8, 0xB1FA, 0xD5CD, 0xB1FB,
0xB1E9, 0xD5BA, 0xD5CF, 0xB1EF, 0xB1F9, 0xD5BC, 0xD5C6, 0xD5B7,
0xD5BB, 0xB1F4, 0xD5B6, 0xB1E8, 0xB1F1, 0xB1EE, 0xD5BF, 0xAEDE,
0xD9C0, 0xB1EB, 0xB1F3, 0xD9C3, 0xD9D9, 0xD9CE, 0xB4D6, 0xB4D1,
0xD9BD, 0xB4D2, 0xD9CD, 0xD9C6, 0xD9D3, 0xB4CE, 0xD9AB, 0xD9D5,
0xB4C4, 0xD9B3, 0xB4C7, 0xB4C6, 0xB4D7, 0xD9AD, 0xD9CF, 0xD9D0,
0xB4C9, 0xB4C5, 0xD9BB, 0xB4D0, 0xD9B6, 0xD9D1, 0xB4CC, 0xD9C9,
0xD9D6, 0xD9B0, 0xD9B5, 0xD9AF, 0xB4CB, 0xD9C2, 0xDDDE, 0xD9B1,
0xB4CF, 0xD9BA, 0xD9D2, 0xB4CA, 0xD9B7, 0xD9B4, 0xD9C5, 0xB4CD,
0xB4C3, 0xB4D9, 0xD9C8, 0xD9C7, 0xD9AC, 0xB4C8, 0xD9D4, 0xD9BC,
0xD9BE, 0xD9CB, 0xD9CA, 0xD9AA, 0xB4D3, 0xB4D5, 0xD9B2, 0xD9B9,
0xD9C1, 0xB4D4, 0xD9B8, 0xD9C4, 0xD9D7, 0xD9CC, 0xD9D8, 0xD9AE,
0xDDF2, 0xB7A6, 0xDDF0, 0xDDDB, 0xDDE0, 0xDDD9, 0xDDEC, 0xDDCB,
0xDDD2, 0xDDEA, 0xDDF4, 0xDDDC, 0xDDCF, 0xDDE2, 0xDDE7, 0xDDD3,
0xDDE4, 0xDDD0, 0xDDD7, 0xDDD8, 0xB7A8, 0xDDEB, 0xDDE9, 0xDDCC,
0xDDEE, 0xDDEF, 0xDDF1, 0xB7AC, 0xB7A4, 0xD5B8, 0xDDD4, 0xDDE6,
0xDDD5, 0xB7A1, 0xB7B1, 0xDDED, 0xB7AF, 0xB7AB, 0xDDCA, 0xB7A3,
0xDDCD, 0xB7B0, 0xDDDD, 0xDDC9, 0xB7A9, 0xDDE1, 0xDDD1, 0xB7AA,
0xDDDA, 0xB77E, 0xB4D8, 0xDDE3, 0xD9BF, 0xDDCE, 0xDDE8, 0xB7A5,
0xDDE5, 0xB7A2, 0xDDDF, 0xB7AD, 0xDDD6, 0xDDF3, 0xB7A7, 0xDEC6,
0xB7AE, 0xE24A, 0xE248, 0xE25E, 0xE246, 0xE258, 0xB77D, 0xBA5F,
0xE242, 0xE25D, 0xE247, 0xE255, 0xBA64, 0xBA5D, 0xE25B, 0xE240,
0xE25A, 0xBA6F, 0xE251, 0xE261, 0xBA6D, 0xE249, 0xBA5E, 0xE24B,
0xE259, 0xBA67, 0xE244, 0xBA6B, 0xBA61, 0xE24D, 0xE243, 0xE1FC,
0xE257, 0xBA68, 0xE260, 0xE1FD, 0xBA65, 0xE253, 0xBA66, 0xE245,
0xE250, 0xE24C, 0xE24E, 0xBA60, 0xE25F, 0xBA6E, 0xE24F, 0xE262,
0xE1FE, 0xE254, 0xBA63, 0xBA6C, 0xBA6A, 0xE241, 0xE256, 0xBA69,
0xBA62, 0xE252, 0xE25C, 0xE5D5, 0xE5D1, 0xE5CD, 0xE5E1, 0xE5DE,
0xBCCD, 0xE5E5, 0xE5D4, 0xBCD8, 0xE5DB, 0xE5D0, 0xE5DA, 0xBCD5,
0xE5EE, 0xE5EB, 0xE5DD, 0xE5CE, 0xE5E2, 0xE5E4, 0xBCD1, 0xE5D8,
0xE5D3, 0xE5CA, 0xBCCE, 0xBCD6, 0xE5E7, 0xBCD7, 0xE5CB, 0xE5ED,
0xE5E0, 0xE5E6, 0xBCD4, 0xE5E3, 0xE5EA, 0xBCD9, 0xBCD3, 0xE5DC,
0xE5CF, 0xE5EF, 0xE5CC, 0xE5E8, 0xBCD0, 0xE5D6, 0xE5D7, 0xBCCF,
0xBCCC, 0xE5D2, 0xBCD2, 0xBCCB, 0xE5E9, 0xE5EC, 0xE5D9, 0xE9CA,
0xE9C2, 0xE9BE, 0xBEF6, 0xBEEB, 0xBEF0, 0xBEEC, 0xE9CC, 0xE9D7,
0xBEEA, 0xE9C4, 0xE9CD, 0xE5DF, 0xE9CE, 0xBEF1, 0xE9DD, 0xBEF5,
0xBEF8, 0xE9C0, 0xBEF4, 0xE9DB, 0xE9DC, 0xE9D2, 0xE9D1, 0xE9C9,
0xE9D3, 0xE9DA, 0xE9D9, 0xBEEF, 0xBEED, 0xE9CB, 0xE9C8, 0xE9C5,
0xE9D8, 0xBEF7, 0xE9D6, 0xBEF3, 0xBEF2, 0xE9D0, 0xE9BF, 0xE9C1,
0xE9C3, 0xE9D5, 0xE9CF, 0xBEEE, 0xE9C6, 0xE9D4, 0xE9C7, 0xC0CF,
0xED45, 0xC0C8, 0xECF5, 0xED41, 0xC0CA, 0xED48, 0xECFC, 0xECF7,
0xED49, 0xECF3, 0xECFE, 0xC0D1, 0xED44, 0xED4A, 0xECFD, 0xC0C9,
0xED40, 0xECF4, 0xC0D0, 0xED47, 0xECF9, 0xC0CC, 0xECFB, 0xECF8,
0xC0D2, 0xECFA, 0xC0CB, 0xC0CE, 0xED43, 0xECF6, 0xED46, 0xED42,
0xC263, 0xEFE7, 0xC268, 0xC269, 0xC262, 0xEFE6, 0xEFE3, 0xEFE4,
0xC266, 0xEFDE, 0xEFE2, 0xC265, 0xEFDF, 0xC267, 0xC264, 0xEFDD,
0xEFE1, 0xEFE5, 0xF251, 0xF24E, 0xF257, 0xF256, 0xF254, 0xF24F,
0xC372, 0xF250, 0xC371, 0xC0CD, 0xF253, 0xC370, 0xF258, 0xF252,
0xF24D, 0xEFE0, 0xC36F, 0xF24C, 0xF456, 0xF455, 0xF255, 0xC468,
0xF459, 0xF45A, 0xF454, 0xF458, 0xF453, 0xF5D1, 0xF457, 0xC4E7,
0xC4E5, 0xF5CF, 0xF5D2, 0xF5CE, 0xF5D0, 0xC4E6, 0xF6E5, 0xF6E6,
0xC576, 0xF6E4, 0xF7E2, 0xC5CF, 0xF7E0, 0xF7E1, 0xF8AC, 0xC656,
0xF8F3, 0xF8F1, 0xF8F2, 0xF8F4, 0xF9BB, 0xA4ED, 0xA6B8, 0xAA59,
0xCCE9, 0xCF64, 0xD1F5, 0xD1F7, 0xD1F6, 0xD1F8, 0xB1FD, 0xD5D7,
0xD1F9, 0xD5D6, 0xD5D8, 0xD5D9, 0xD9DA, 0xB4DB, 0xD9DB, 0xD9DD,
0xB4DC, 0xB4DA, 0xD9DC, 0xDDFA, 0xDDF8, 0xDDF7, 0xDDF6, 0xDDF5,
0xB7B2, 0xDDF9, 0xBA70, 0xE263, 0xE265, 0xBA71, 0xE264, 0xBCDB,
0xBCDA, 0xE5F0, 0xE9DF, 0xE9DE, 0xE9E0, 0xBEF9, 0xED4B, 0xC0D3,
0xEFE8, 0xC26A, 0xF259, 0xC577, 0xA4EE, 0xA5BF, 0xA6B9, 0xA842,
0xAA5A, 0xAA5B, 0xAC6E, 0xD1FA, 0xB7B3, 0xE6D1, 0xBEFA, 0xC26B,
0xA4EF, 0xA6BA, 0xCCEB, 0xAA5C, 0xCCEA, 0xCF65, 0xAC6F, 0xCF66,
0xAC70, 0xD1FC, 0xAEEE, 0xAEED, 0xD5DE, 0xD5DC, 0xD5DD, 0xD5DB,
0xD5DA, 0xD9DE, 0xD9E1, 0xB4DE, 0xD9DF, 0xB4DD, 0xD9E0, 0xDDFB,
0xE266, 0xE267, 0xE268, 0xE5F3, 0xE5F2, 0xBCDC, 0xE5F1, 0xE5F4,
0xE9E1, 0xE9E2, 0xE9E3, 0xED4C, 0xC0D4, 0xC26C, 0xF25A, 0xC4E8,
0xC95F, 0xAC71, 0xCF67, 0xAEEF, 0xB1FE, 0xB4DF, 0xD9E2, 0xB7B5,
0xB7B4, 0xE269, 0xE26A, 0xBCDD, 0xBCDE, 0xE9E5, 0xE9E4, 0xEFE9,
0xF7E3, 0xA4F0, 0xC960, 0xA5C0, 0xA843, 0xCB48, 0xAC72, 0xB7B6,
0xA4F1, 0xCF68, 0xAC73, 0xCF69, 0xC0D5, 0xA4F2, 0xCCEC, 0xCF6A,
0xD242, 0xD241, 0xD1FE, 0xD1FD, 0xD243, 0xD240, 0xB240, 0xB241,
0xB4E0, 0xD9E3, 0xD9E4, 0xD9E5, 0xDE41, 0xDE42, 0xDE40, 0xDDFD,
0xDDFE, 0xB7B7, 0xE26B, 0xE5F7, 0xE5F6, 0xE5F5, 0xE5F8, 0xE9E7,
0xE9E6, 0xBEFB, 0xE9E8, 0xC0D6, 0xED4D, 0xEFEA, 0xF25B, 0xF6E7,
0xA4F3, 0xA5C2, 0xA5C1, 0xAA5D, 0xC961, 0xC97E, 0xA6BB, 0xC9F7,
0xCB49, 0xCB4A, 0xAA5E, 0xCCED, 0xAC74, 0xCF6B, 0xCF6C, 0xAEF0,
0xAEF4, 0xD244, 0xAEF3, 0xAEF1, 0xAEF2, 0xD5DF, 0xB242, 0xB4E3,
0xB4E1, 0xB4E2, 0xD9E6, 0xBA72, 0xA4F4, 0xC9A1, 0xA5C3, 0xC9A4,
0xA5C6, 0xC9A3, 0xA5C5, 0xA5C4, 0xA844, 0xC9A2, 0xC9F8, 0xC9FC,
0xC9FE, 0xCA40, 0xA6C5, 0xA6C6, 0xC9FB, 0xA6C1, 0xC9F9, 0xC9FD,
0xA6C2, 0xA6BD, 0xA6BE, 0xA6C4, 0xC9FA, 0xA6BC, 0xA845, 0xA6BF,
0xA6C0, 0xA6C3, 0xCB5B, 0xCB59, 0xCB4C, 0xA851, 0xCB53, 0xA84C,
0xCB4D, 0xCB55, 0xCB52, 0xA84F, 0xCB51, 0xA856, 0xCB5A, 0xA858,
0xA85A, 0xCB4B, 0xA84D, 0xCB5C, 0xA854, 0xA857, 0xCD45, 0xA847,
0xA85E, 0xA855, 0xCB4E, 0xA84A, 0xA859, 0xCB56, 0xA848, 0xA849,
0xCD43, 0xCB4F, 0xA850, 0xA85B, 0xCB5D, 0xCB50, 0xA84E, 0xA853,
0xCCEE, 0xA85C, 0xCB57, 0xA852, 0xA85D, 0xA846, 0xCB54, 0xA84B,
0xCB58, 0xCD44, 0xAA6A, 0xAA7A, 0xCCF5, 0xAA71, 0xCD4B, 0xAA62,
0xAA65, 0xCD42, 0xCCF3, 0xCCF7, 0xAA6D, 0xAA6F, 0xCCFA, 0xAA76,
0xAA68, 0xAA66, 0xAA67, 0xAA75, 0xCD47, 0xAA70, 0xCCF9, 0xCCFB,
0xAA6E, 0xAA73, 0xCCFC, 0xCD4A, 0xAC75, 0xAA79, 0xAA63, 0xCD49,
0xCD4D, 0xCCF8, 0xCD4F, 0xCD40, 0xAA6C, 0xCCF4, 0xAA6B, 0xAA7D,
0xAA72, 0xCCF2, 0xCF75, 0xAA78, 0xAA7C, 0xCD41, 0xCD46, 0xAA7E,
0xAA77, 0xAA69, 0xAA5F, 0xAA64, 0xCCF6, 0xAA60, 0xCD4E, 0xCCF0,
0xCCEF, 0xCCFD, 0xCCF1, 0xAA7B, 0xAEF5, 0xAA74, 0xCCFE, 0xAA61,
0xACA6, 0xCD4C, 0xCF7C, 0xCFA1, 0xCFA4, 0xCF77, 0xCFA7, 0xCFAA,
0xCFAC, 0xCF74, 0xAC76, 0xAC7B, 0xD249, 0xACAD, 0xCFA5, 0xCFAD,
0xCF7B, 0xCF73, 0xD264, 0xAC7E, 0xCFA2, 0xCF78, 0xCF7A, 0xACA5,
0xCF7D, 0xAC7D, 0xCF70, 0xCFA8, 0xCFAB, 0xAC7A, 0xACA8, 0xCF6D,
0xACAA, 0xAC78, 0xACAE, 0xCFA9, 0xCF6F, 0xACAB, 0xD25E, 0xCD48,
0xAC7C, 0xAC77, 0xCF76, 0xCF6E, 0xACAC, 0xACA4, 0xCFA3, 0xACA9,
0xACA7, 0xCF79, 0xACA1, 0xCF71, 0xACA2, 0xACA3, 0xCF72, 0xCFA6,
0xAC79, 0xCF7E, 0xD24C, 0xAEFD, 0xAF43, 0xD255, 0xD25B, 0xD257,
0xD24A, 0xD24D, 0xD246, 0xD247, 0xAF4A, 0xAEFA, 0xD256, 0xD25F,
0xAF45, 0xAEF6, 0xAF40, 0xD24E, 0xAF42, 0xD24F, 0xD259, 0xAF44,
0xD268, 0xD248, 0xAEFC, 0xAEFB, 0xAF48, 0xD245, 0xD266, 0xD25A,
0xD267, 0xD261, 0xD253, 0xD262, 0xD25C, 0xD265, 0xD263, 0xAF49,
0xD254, 0xAEF9, 0xAEF8, 0xAF41, 0xAF47, 0xD260, 0xAF46, 0xD251,
0xB243, 0xD269, 0xD250, 0xD24B, 0xAEFE, 0xAF4B, 0xAEF7, 0xD258,
0xD25D, 0xB265, 0xD5E1, 0xD5E5, 0xB252, 0xB250, 0xB247, 0xD5E3,
0xD5E2, 0xB25B, 0xD5E8, 0xB255, 0xD5FA, 0xD647, 0xB244, 0xD5F7,
0xD5F0, 0xB267, 0xD5E0, 0xD5FC, 0xB264, 0xB258, 0xB263, 0xB24E,
0xD5EC, 0xD5FE, 0xD5F6, 0xB24F, 0xB249, 0xD645, 0xD5FD, 0xD640,
0xB251, 0xB259, 0xD642, 0xD5EA, 0xD5FB, 0xD5EF, 0xD644, 0xB25E,
0xB246, 0xB25C, 0xD5F4, 0xD5F2, 0xD5F3, 0xB253, 0xD5EE, 0xD5ED,
0xB248, 0xD5E7, 0xD646, 0xB24A, 0xD5F1, 0xB268, 0xB262, 0xD5E6,
0xB25F, 0xB25D, 0xB266, 0xD5F8, 0xB261, 0xD252, 0xD5F9, 0xB260,
0xD641, 0xB245, 0xD5F5, 0xB257, 0xD5E9, 0xB256, 0xB254, 0xB24C,
0xB24B, 0xD9E7, 0xD643, 0xD5EB, 0xD9FC, 0xB24D, 0xB541, 0xB25A,
0xB4EE, 0xD9F6, 0xB4FC, 0xD9EA, 0xB4EB, 0xB4E7, 0xDA49, 0xB4ED,
0xB4F1, 0xB4EC, 0xB4F5, 0xDA4D, 0xDA44, 0xD9F1, 0xB4FA, 0xB4F4,
0xD9FD, 0xB4E4, 0xDA4A, 0xDA43, 0xB4E8, 0xD9F7, 0xB4F7, 0xDA55,
0xDA56, 0xB4E5, 0xDA48, 0xB4F9, 0xD9FB, 0xD9ED, 0xD9EE, 0xB4FD,
0xD9F2, 0xD9F9, 0xD9F3, 0xB4FB, 0xB544, 0xD9EF, 0xD9E8, 0xD9E9,
0xD9EB, 0xB4EA, 0xD9F8, 0xB4F8, 0xB542, 0xD9FA, 0xDA53, 0xDA4B,
0xB4E6, 0xDA51, 0xB4F2, 0xB4F0, 0xDA57, 0xB4EF, 0xDA41, 0xD9F4,
0xD9FE, 0xB547, 0xDA45, 0xDA42, 0xD9F0, 0xB543, 0xDA4F, 0xDA4C,
0xDA54, 0xB4E9, 0xDA40, 0xB546, 0xDA47, 0xB4F3, 0xB4F6, 0xDA46,
0xB545, 0xD9F5, 0xD5E4, 0xDA50, 0xDA4E, 0xDA52, 0xD9EC, 0xB540,
0xDE61, 0xDE60, 0xDE46, 0xB7BD, 0xDE5F, 0xDE49, 0xDE4A, 0xB7C7,
0xDE68, 0xB7C2, 0xDE5E, 0xDE43, 0xB7C8, 0xB7BE, 0xDE52, 0xDE48,
0xDE4B, 0xDE63, 0xB7B8, 0xDE6A, 0xDE62, 0xB7C1, 0xDE57, 0xB7CC,
0xB7CB, 0xB7C5, 0xDE69, 0xB7B9, 0xDE55, 0xDE4C, 0xDE59, 0xDE65,
0xB7CD, 0xB7BB, 0xDE54, 0xDE4D, 0xB7C4, 0xB7C3, 0xDE50, 0xDE5A,
0xDE64, 0xDE47, 0xDE51, 0xB7BC, 0xDE5B, 0xB7C9, 0xB7C0, 0xDE4E,
0xB7BF, 0xDE45, 0xDE53, 0xDE67, 0xB4FE, 0xBAB0, 0xDE56, 0xE26C,
0xDE58, 0xDE66, 0xB7C6, 0xDE4F, 0xB7BA, 0xB7CA, 0xBCF0, 0xDE44,
0xDE5D, 0xDE5C, 0xE2AA, 0xBAAD, 0xE27D, 0xE2A4, 0xBAA2, 0xE26E,
0xBAAF, 0xBA77, 0xE26D, 0xE2B0, 0xBAB1, 0xE271, 0xE2A3, 0xE273,
0xE2B3, 0xE2AF, 0xBA75, 0xBAA1, 0xE653, 0xBAAE, 0xBA7D, 0xE26F,
0xE2AE, 0xBAA3, 0xE2AB, 0xE2B8, 0xE275, 0xE27E, 0xE2B6, 0xE2AC,
0xBA7C, 0xE27C, 0xBA76, 0xBA74, 0xBAA8, 0xE27A, 0xE277, 0xE278,
0xE2B2, 0xE2B7, 0xE2B5, 0xBA7A, 0xE2B9, 0xBA7E, 0xBAA7, 0xE270,
0xE5FA, 0xE279, 0xBA78, 0xBAAC, 0xBAA9, 0xBA7B, 0xE2A5, 0xE274,
0xBAAA, 0xE2A7, 0xBAA4, 0xBAA6, 0xBA73, 0xE2A9, 0xE2A1, 0xE272,
0xBAA5, 0xE2B1, 0xE2B4, 0xE27B, 0xE2A8, 0xBA79, 0xBCDF, 0xE2A6,
0xE5F9, 0xE2AD, 0xE276, 0xE644, 0xE64E, 0xBCE2, 0xE64D, 0xE659,
0xBCE4, 0xE64B, 0xE64F, 0xBCEF, 0xE646, 0xBCE7, 0xE652, 0xE9F0,
0xBCF3, 0xBCF2, 0xE654, 0xE643, 0xE65E, 0xBCED, 0xBCE3, 0xE657,
0xE65B, 0xE660, 0xE655, 0xE649, 0xBCE6, 0xBCE9, 0xBCF1, 0xBCEC,
0xE64C, 0xE2A2, 0xE648, 0xE65F, 0xBCE8, 0xBCEB, 0xE661, 0xBCE0,
0xE656, 0xE5FB, 0xE65C, 0xC0DF, 0xE64A, 0xBCE1, 0xE645, 0xBCE5,
0xE5FC, 0xBAAB, 0xE641, 0xE65A, 0xE642, 0xE640, 0xBCEA, 0xE658,
0xE5FE, 0xE651, 0xE650, 0xE65D, 0xE647, 0xBCEE, 0xE9F3, 0xBF49,
0xBEFE, 0xEA40, 0xE9EB, 0xBF41, 0xE9F7, 0xBF48, 0xBF43, 0xE9F5,
0xED4F, 0xE9FB, 0xEA42, 0xE9FA, 0xE9E9, 0xE9F8, 0xEA44, 0xEA46,
0xBEFD, 0xEA45, 0xBF44, 0xBF4A, 0xBF47, 0xE9FE, 0xBF46, 0xE9F9,
0xE9ED, 0xE9F2, 0xE9FD, 0xBF45, 0xBF42, 0xBEFC, 0xBF40, 0xE9F1,
0xE5FD, 0xE9EC, 0xE9EF, 0xEA41, 0xE9F4, 0xE9EA, 0xED4E, 0xEA43,
0xE9EE, 0xE9FC, 0xED51, 0xC0E3, 0xC0D7, 0xC0DB, 0xED53, 0xED59,
0xED57, 0xC0D9, 0xC0DA, 0xC0E1, 0xED5A, 0xED52, 0xC0DC, 0xED56,
0xED55, 0xED5B, 0xC0E2, 0xC0DD, 0xC0E0, 0xED54, 0xC0E4, 0xC0DE,
0xC0E5, 0xC0D8, 0xED58, 0xED50, 0xEFF7, 0xC271, 0xEFF4, 0xEFF6,
0xC26F, 0xEFF2, 0xEFF3, 0xEFEE, 0xE9F6, 0xEFEF, 0xC270, 0xEFEB,
0xC26D, 0xEFF8, 0xC26E, 0xEFEC, 0xEFED, 0xEFF1, 0xC273, 0xC272,
0xEFF0, 0xC378, 0xF25F, 0xF265, 0xC379, 0xF25C, 0xC376, 0xC373,
0xF267, 0xC377, 0xC374, 0xF25E, 0xF261, 0xF262, 0xF263, 0xF266,
0xEFF5, 0xF25D, 0xC375, 0xF264, 0xF268, 0xF260, 0xF45D, 0xC46A,
0xF460, 0xC46B, 0xF468, 0xF45F, 0xF45C, 0xF45E, 0xF462, 0xF465,
0xF464, 0xF467, 0xF45B, 0xC469, 0xF463, 0xF466, 0xF469, 0xF461,
0xF5D3, 0xF5D4, 0xF5D8, 0xF5D9, 0xF5D6, 0xF5D7, 0xF5D5, 0xC4E9,
0xC578, 0xF6EB, 0xF6E8, 0xF6E9, 0xF6EA, 0xC579, 0xF7E5, 0xF7E4,
0xF8AF, 0xC5F4, 0xF8AD, 0xF8B0, 0xF8AE, 0xF8F5, 0xC657, 0xC665,
0xF9A3, 0xF96C, 0xF9A2, 0xF9D0, 0xF9D1, 0xA4F5, 0xA6C7, 0xCA41,
0xCB5E, 0xA85F, 0xA862, 0xCB5F, 0xA860, 0xA861, 0xCD58, 0xCD5A,
0xCD55, 0xCD52, 0xCD54, 0xAAA4, 0xAAA2, 0xCD56, 0xAAA3, 0xCD53,
0xCD50, 0xAAA1, 0xCD57, 0xCD51, 0xAAA5, 0xCD59, 0xCFAF, 0xCFB3,
0xACB7, 0xCFB6, 0xACAF, 0xACB2, 0xACB4, 0xACB6, 0xACB3, 0xCFB2,
0xCFB1, 0xACB1, 0xCFB4, 0xCFB5, 0xCFAE, 0xACB5, 0xACB0, 0xCFB0,
0xD277, 0xD278, 0xD279, 0xAF50, 0xAF4C, 0xD26E, 0xD276, 0xD27B,
0xAF51, 0xD26C, 0xD272, 0xD26B, 0xD275, 0xD271, 0xAF4D, 0xAF4F,
0xD27A, 0xD26A, 0xD26D, 0xD273, 0xD274, 0xD27C, 0xD270, 0xAF4E,
0xB26D, 0xD64E, 0xD650, 0xD64C, 0xD658, 0xD64A, 0xD657, 0xB269,
0xD648, 0xDA5B, 0xD652, 0xB26C, 0xD653, 0xD656, 0xD65A, 0xD64F,
0xD654, 0xB26A, 0xB26B, 0xD659, 0xD64D, 0xD649, 0xD65B, 0xD651,
0xD655, 0xD64B, 0xB548, 0xB549, 0xDA65, 0xB54F, 0xDA59, 0xDA62,
0xDA58, 0xB54C, 0xDA60, 0xDA5E, 0xDA5F, 0xB54A, 0xDA63, 0xDA5C,
0xDA5A, 0xB54B, 0xDA5D, 0xDA61, 0xB54D, 0xDA64, 0xDE70, 0xDE77,
0xDE79, 0xDEA1, 0xB7DA, 0xDE6B, 0xB7D2, 0xDE7A, 0xB7D7, 0xDEA2,
0xB7CE, 0xDE7D, 0xDE6D, 0xDE7E, 0xDE6C, 0xB7DC, 0xDE78, 0xB7CF,
0xDEA3, 0xB7D4, 0xDE71, 0xB7D9, 0xDE7C, 0xDE6F, 0xDE76, 0xDE72,
0xDE6E, 0xB7D1, 0xB7D8, 0xB7D6, 0xB7D3, 0xB7DB, 0xB7D0, 0xDE75,
0xB7D5, 0xB54E, 0xDE7B, 0xDE73, 0xDE74, 0xE2C1, 0xBAB4, 0xE2BD,
0xE2C3, 0xE2BF, 0xBAB6, 0xE2BE, 0xE2C2, 0xE2BA, 0xE2BC, 0xBAB5,
0xE2C0, 0xE2BB, 0xBAB7, 0xBAB2, 0xE2C4, 0xBAB3, 0xE667, 0xE664,
0xE670, 0xE66A, 0xE66C, 0xBCF4, 0xE666, 0xE66E, 0xE66D, 0xE66B,
0xE671, 0xBCF7, 0xE668, 0xE66F, 0xBCF5, 0xE663, 0xE665, 0xBCF6,
0xE662, 0xE672, 0xE669, 0xEA4A, 0xBF51, 0xEA55, 0xEA53, 0xBF4B,
0xEA49, 0xEA4C, 0xEA4D, 0xEA48, 0xBF55, 0xBF56, 0xEA47, 0xEA56,
0xEA51, 0xBF4F, 0xBF4C, 0xEA50, 0xEA4E, 0xBF52, 0xEA52, 0xBF4D,
0xBF4E, 0xEA4F, 0xBF50, 0xEA4B, 0xEA54, 0xBF53, 0xEA57, 0xEA58,
0xBF54, 0xC0E7, 0xC0EE, 0xED5C, 0xED62, 0xED60, 0xC0EA, 0xC0E9,
0xC0E6, 0xED5E, 0xC0EC, 0xC0EB, 0xC0E8, 0xED61, 0xED5D, 0xED5F,
0xC0ED, 0xC277, 0xEFFB, 0xC274, 0xC275, 0xEFFD, 0xC276, 0xEFFA,
0xEFF9, 0xF26C, 0xEFFC, 0xF26D, 0xC37A, 0xF26B, 0xF26A, 0xF269,
0xC37B, 0xC46C, 0xF46A, 0xF46B, 0xF5DC, 0xF5DB, 0xC4EA, 0xF5DA,
0xF6EC, 0xF6ED, 0xF7E6, 0xF8B1, 0xF8F6, 0xF9BC, 0xC679, 0xF9C6,
0xA4F6, 0xAAA6, 0xAAA7, 0xACB8, 0xC0EF, 0xA4F7, 0xAAA8, 0xAF52,
0xB7DD, 0xA4F8, 0xB26E, 0xBAB8, 0xC962, 0xCFB7, 0xD27D, 0xE2C5,
0xC0F0, 0xA4F9, 0xAAA9, 0xCFB8, 0xCFB9, 0xDA66, 0xB550, 0xDEA4,
0xB7DE, 0xE2C6, 0xBCF8, 0xC37C, 0xA4FA, 0xDA67, 0xA4FB, 0xA6C9,
0xCA42, 0xA6C8, 0xA865, 0xA864, 0xA863, 0xCB60, 0xAAAA, 0xAAAB,
0xCD5B, 0xCFBA, 0xCFBD, 0xACBA, 0xCFBB, 0xACB9, 0xCFBC, 0xACBB,
0xD2A2, 0xD2A1, 0xD27E, 0xAF53, 0xD65D, 0xD65E, 0xB26F, 0xD65C,
0xD65F, 0xB552, 0xB270, 0xB551, 0xDA6B, 0xDA6A, 0xDA68, 0xDA69,
0xDA6C, 0xDEA6, 0xDEA5, 0xDEA9, 0xDEA8, 0xDEA7, 0xBAB9, 0xE2C9,
0xE2C8, 0xBABA, 0xE2C7, 0xE673, 0xE674, 0xBCF9, 0xEA59, 0xEA5A,
0xF272, 0xC37D, 0xF271, 0xF270, 0xF26E, 0xF26F, 0xC4EB, 0xF46C,
0xF6EE, 0xF8F7, 0xA4FC, 0xC9A5, 0xA5C7, 0xC9A6, 0xCA43, 0xCA44,
0xCB66, 0xCB62, 0xCB61, 0xAAAC, 0xCB65, 0xA867, 0xCB63, 0xA866,
0xCB67, 0xCB64, 0xCD5F, 0xCFBE, 0xCD5D, 0xCD64, 0xAAAD, 0xAAB0,
0xCD65, 0xCD61, 0xCD62, 0xCD5C, 0xAAAF, 0xCD5E, 0xAAAE, 0xCD63,
0xCD60, 0xCFC2, 0xACBD, 0xACBE, 0xCFC5, 0xCFBF, 0xCFC4, 0xCFC0,
0xACBC, 0xCFC3, 0xCFC1, 0xD2A8, 0xD2A5, 0xD2A7, 0xAF58, 0xAF57,
0xAF55, 0xD2A4, 0xD2A9, 0xAF54, 0xAF56, 0xD2A6, 0xD667, 0xD2A3,
0xD2AA, 0xD662, 0xD666, 0xD665, 0xDA6E, 0xDA79, 0xD668, 0xD663,
0xDA6D, 0xB274, 0xB273, 0xD661, 0xD664, 0xB275, 0xB272, 0xB271,
0xD660, 0xD669, 0xDA70, 0xDA77, 0xB554, 0xDA76, 0xDA73, 0xB556,
0xDA75, 0xDA6F, 0xDA71, 0xDA74, 0xDA72, 0xB555, 0xDA78, 0xB553,
0xB7DF, 0xDEAD, 0xDEAC, 0xDEAA, 0xB7E2, 0xB7E1, 0xDEAE, 0xDEAB,
0xE2CA, 0xBABB, 0xB7E0, 0xDEB0, 0xDEAF, 0xE2CD, 0xE2CB, 0xBCFA,
0xBABC, 0xE2CC, 0xE676, 0xBCFB, 0xE675, 0xE67E, 0xE67D, 0xE67B,
0xE67A, 0xE677, 0xE678, 0xE679, 0xE67C, 0xE6A1, 0xEA5F, 0xEA5C,
0xEA5D, 0xBF57, 0xEA5B, 0xEA61, 0xEA60, 0xEA5E, 0xED64, 0xED65,
0xC0F1, 0xC0F2, 0xED63, 0xC279, 0xEFFE, 0xC278, 0xC37E, 0xC3A1,
0xC46D, 0xF46E, 0xF46D, 0xF5DD, 0xF6EF, 0xC57A, 0xF7E8, 0xF7E7,
0xF7E9, 0xA5C8, 0xCFC6, 0xAF59, 0xB276, 0xD66A, 0xA5C9, 0xC9A7,
0xA4FD, 0xCA45, 0xCB6C, 0xCB6A, 0xCB6B, 0xCB68, 0xA868, 0xCB69,
0xCD6D, 0xAAB3, 0xCD6B, 0xCD67, 0xCD6A, 0xCD66, 0xAAB5, 0xCD69,
0xAAB2, 0xAAB1, 0xAAB4, 0xCD6C, 0xCD68, 0xACC2, 0xACC5, 0xCFCE,
0xCFCD, 0xCFCC, 0xACBF, 0xCFD5, 0xCFCB, 0xACC1, 0xD2AF, 0xCFD2,
0xCFD0, 0xACC4, 0xCFC8, 0xCFD3, 0xCFCA, 0xCFD4, 0xCFD1, 0xCFC9,
0xACC0, 0xCFD6, 0xCFC7, 0xACC3, 0xD2B4, 0xD2AB, 0xD2B6, 0xD2AE,
0xD2B9, 0xD2BA, 0xD2AC, 0xD2B8, 0xD2B5, 0xD2B3, 0xD2B7, 0xAF5F,
0xAF5D, 0xD2B1, 0xD2AD, 0xD2B0, 0xD2BB, 0xD2B2, 0xAF5E, 0xCFCF,
0xAF5A, 0xAF5C, 0xD678, 0xD66D, 0xD66B, 0xD66C, 0xD673, 0xD674,
0xD670, 0xB27B, 0xD675, 0xD672, 0xD66F, 0xB279, 0xD66E, 0xB277,
0xB27A, 0xD671, 0xD679, 0xAF5B, 0xB278, 0xD677, 0xD676, 0xB27C,
0xDA7E, 0xDAA1, 0xB560, 0xDAA7, 0xDAA9, 0xDAA2, 0xB55A, 0xDAA6,
0xDAA5, 0xB55B, 0xB561, 0xB562, 0xDAA8, 0xB558, 0xDA7D, 0xDA7B,
0xDAA3, 0xDA7A, 0xB55F, 0xDA7C, 0xDAA4, 0xDAAA, 0xB559, 0xB55E,
0xB55C, 0xB55D, 0xB557, 0xB7E9, 0xDEB7, 0xB7E8, 0xDEBB, 0xDEB1,
0xDEBC, 0xDEB2, 0xDEB3, 0xDEBD, 0xDEBA, 0xDEB8, 0xDEB9, 0xDEB5,
0xDEB4, 0xDEBE, 0xB7E5, 0xDEB6, 0xB7EA, 0xB7E4, 0xB7EB, 0xB7EC,
0xB7E7, 0xB7E6, 0xE2CE, 0xBABE, 0xBABD, 0xE2D3, 0xBCFC, 0xBABF,
0xBAC1, 0xE2D4, 0xB7E3, 0xBAC0, 0xE2D0, 0xE2D2, 0xE2CF, 0xE2D1,
0xE6AB, 0xE6AA, 0xE6A7, 0xBD40, 0xEA62, 0xBD41, 0xE6A6, 0xBCFE,
0xE6A8, 0xE6A5, 0xE6A2, 0xE6A9, 0xE6A3, 0xE6A4, 0xBCFD, 0xED69,
0xEA66, 0xEA65, 0xEA67, 0xED66, 0xBF5A, 0xEA63, 0xBF58, 0xBF5C,
0xBF5B, 0xEA64, 0xEA68, 0xBF59, 0xED6D, 0xC0F5, 0xC27A, 0xC0F6,
0xC0F3, 0xED6A, 0xED68, 0xED6B, 0xED6E, 0xC0F4, 0xED6C, 0xED67,
0xF042, 0xF045, 0xF275, 0xF040, 0xF46F, 0xF046, 0xC3A2, 0xF044,
0xC27B, 0xF041, 0xF043, 0xF047, 0xF276, 0xF274, 0xC3A3, 0xF273,
0xC46E, 0xC4ED, 0xF6F1, 0xC4EC, 0xF6F3, 0xF6F0, 0xF6F2, 0xC5D0,
0xF8B2, 0xA5CA, 0xCD6E, 0xD2BC, 0xD2BD, 0xB27D, 0xDEBF, 0xBF5D,
0xC3A4, 0xC57B, 0xF8B3, 0xA5CB, 0xCD6F, 0xA260, 0xCFD7, 0xCFD8,
0xD2BE, 0xD2BF, 0xB27E, 0xB2A1, 0xDAAB, 0xDEC2, 0xDEC1, 0xDEC0,
0xE2D5, 0xE2D6, 0xE2D7, 0xBAC2, 0xE6AD, 0xE6AC, 0xEA69, 0xBF5E,
0xBF5F, 0xED72, 0xED6F, 0xED70, 0xED71, 0xF049, 0xF048, 0xC27C,
0xF277, 0xF5DE, 0xA5CC, 0xACC6, 0xB2A2, 0xDEC3, 0xA5CD, 0xD2C0,
0xB2A3, 0xB563, 0xB564, 0xA5CE, 0xA5CF, 0xCA46, 0xA86A, 0xA869,
0xACC7, 0xCFD9, 0xDAAC, 0xA5D0, 0xA5D1, 0xA5D2, 0xA5D3, 0xA86B,
0xA86C, 0xCB6E, 0xCB6D, 0xAAB6, 0xCD72, 0xCD70, 0xCD71, 0xCFDA,
0xCFDB, 0xACCB, 0xACC9, 0xACCA, 0xACC8, 0xAF60, 0xAF64, 0xAF63,
0xD2C1, 0xAF62, 0xAF61, 0xD2C2, 0xB2A6, 0xD67B, 0xD67A, 0xB2A4,
0xB2A5, 0xB566, 0xB565, 0xDAAE, 0xDAAD, 0xB2A7, 0xB7ED, 0xDEC5,
0xB7EE, 0xDEC4, 0xE2D8, 0xE6AE, 0xBD42, 0xEA6A, 0xED73, 0xC3A6,
0xC3A5, 0xC57C, 0xA5D4, 0xCD73, 0xB2A8, 0xE2D9, 0xBAC3, 0xCB6F,
0xCB70, 0xCD74, 0xAAB8, 0xAAB9, 0xAAB7, 0xACCF, 0xACD0, 0xACCD,
0xACCE, 0xCFDC, 0xCFDD, 0xACCC, 0xD2C3, 0xAF68, 0xAF69, 0xB2AB,
0xD2C9, 0xAF6E, 0xAF6C, 0xD2CA, 0xD2C5, 0xAF6B, 0xAF6A, 0xAF65,
0xD2C8, 0xD2C7, 0xD2C4, 0xAF6D, 0xD2C6, 0xAF66, 0xAF67, 0xB2AC,
0xD6A1, 0xD6A2, 0xB2AD, 0xD67C, 0xD67E, 0xD6A4, 0xD6A3, 0xD67D,
0xB2A9, 0xB2AA, 0xDAB6, 0xB56B, 0xB56A, 0xDAB0, 0xB568, 0xDAB3,
0xB56C, 0xDAB4, 0xB56D, 0xDAB1, 0xB567, 0xB569, 0xDAB5, 0xDAB2,
0xDAAF, 0xDED2, 0xDEC7, 0xB7F0, 0xB7F3, 0xB7F2, 0xB7F7, 0xB7F6,
0xDED3, 0xDED1, 0xDECA, 0xDECE, 0xDECD, 0xB7F4, 0xDED0, 0xDECC,
0xDED4, 0xDECB, 0xB7F5, 0xB7EF, 0xB7F1, 0xDEC9, 0xE2DB, 0xBAC7,
0xE2DF, 0xBAC6, 0xE2DC, 0xBAC5, 0xDEC8, 0xDECF, 0xE2DE, 0xBAC8,
0xE2E0, 0xE2DD, 0xE2DA, 0xE6B1, 0xE6B5, 0xE6B7, 0xE6B3, 0xE6B2,
0xE6B0, 0xBD45, 0xBD43, 0xBD48, 0xBD49, 0xE6B4, 0xBD46, 0xE6AF,
0xBD47, 0xBAC4, 0xE6B6, 0xBD44, 0xEA6C, 0xEA6B, 0xEA73, 0xEA6D,
0xEA72, 0xEA6F, 0xBF60, 0xEA71, 0xBF61, 0xBF62, 0xEA70, 0xEA6E,
0xC0F8, 0xED74, 0xC0F7, 0xED77, 0xED75, 0xED76, 0xC0F9, 0xF04D,
0xC2A1, 0xF04E, 0xC27D, 0xF04F, 0xC27E, 0xF04C, 0xF050, 0xF04A,
0xC3A7, 0xF278, 0xC3A8, 0xC46F, 0xF04B, 0xC470, 0xC4EE, 0xF5DF,
0xC57E, 0xF6F4, 0xC57D, 0xF7EA, 0xC5F5, 0xC5F6, 0xF9CC, 0xACD1,
0xCFDE, 0xB56E, 0xB56F, 0xA5D5, 0xA6CA, 0xCA47, 0xCB71, 0xA86D,
0xAABA, 0xACD2, 0xACD3, 0xACD4, 0xD6A6, 0xD2CB, 0xAF6F, 0xB2AE,
0xD6A5, 0xDAB8, 0xB571, 0xDAB7, 0xB570, 0xDED5, 0xBD4A, 0xE6BB,
0xE6B8, 0xE6B9, 0xE6BA, 0xED78, 0xF051, 0xF471, 0xF470, 0xF6F5,
0xA5D6, 0xCD75, 0xAF70, 0xB572, 0xDED6, 0xE2E1, 0xBD4B, 0xEA74,
0xF052, 0xF472, 0xA5D7, 0xAABB, 0xACD7, 0xCFDF, 0xACD8, 0xACD6,
0xACD5, 0xD2CC, 0xAF71, 0xAF72, 0xAF73, 0xB2B0, 0xD6A7, 0xB2AF,
0xDAB9, 0xB2B1, 0xB573, 0xDED7, 0xB7F8, 0xB7F9, 0xBAC9, 0xBACA,
0xBD4C, 0xBF64, 0xEA75, 0xBF63, 0xED79, 0xC0FA, 0xF053, 0xF473,
0xA5D8, 0xA86E, 0xCD78, 0xCD77, 0xAABC, 0xCD76, 0xAABD, 0xCD79,
0xCFE5, 0xACDB, 0xACDA, 0xCFE7, 0xCFE6, 0xACDF, 0xACDE, 0xACD9,
0xCFE1, 0xCFE2, 0xCFE3, 0xACE0, 0xCFE0, 0xACDC, 0xCFE4, 0xACDD,
0xD2CF, 0xD2D3, 0xD2D1, 0xD2D0, 0xD2D4, 0xD2D5, 0xD2D6, 0xD2CE,
0xD2CD, 0xAF75, 0xAF76, 0xD2D7, 0xD2D2, 0xD6B0, 0xD2D8, 0xAF77,
0xAF74, 0xD6AA, 0xD6A9, 0xD6AB, 0xD6AC, 0xD6AE, 0xD6AD, 0xD6B2,
0xB2B5, 0xB2B2, 0xB2B6, 0xD6A8, 0xB2B7, 0xD6B1, 0xB2B4, 0xD6AF,
0xB2B3, 0xDABC, 0xDABE, 0xDABA, 0xDABB, 0xDABF, 0xDAC1, 0xDAC2,
0xDABD, 0xDAC0, 0xB574, 0xDEDB, 0xDEE0, 0xDED8, 0xDEDC, 0xDEE1,
0xDEDD, 0xB7FA, 0xB843, 0xB7FD, 0xDED9, 0xDEDA, 0xBACE, 0xB846,
0xB7FE, 0xB844, 0xB7FC, 0xDEDF, 0xB845, 0xDEDE, 0xB841, 0xB7FB,
0xB842, 0xDEE2, 0xE2E6, 0xE2E8, 0xB840, 0xE2E3, 0xBACC, 0xE2E9,
0xBACD, 0xE2E7, 0xE2E2, 0xE2E5, 0xE2EA, 0xBACB, 0xE2E4, 0xBD4E,
0xE6BF, 0xE6BE, 0xBD51, 0xBD4F, 0xE6BC, 0xBD4D, 0xE6BD, 0xBD50,
0xEA7D, 0xEAA1, 0xEA7E, 0xEA76, 0xEA7A, 0xEA79, 0xEA77, 0xBF66,
0xBF67, 0xBF65, 0xEA78, 0xEA7B, 0xEA7C, 0xBF68, 0xC140, 0xEDA3,
0xC0FC, 0xED7B, 0xC0FE, 0xC141, 0xC0FD, 0xEDA2, 0xED7C, 0xC0FB,
0xEDA1, 0xED7A, 0xED7E, 0xED7D, 0xF055, 0xC2A4, 0xC2A5, 0xC2A2,
0xC2A3, 0xF054, 0xF27B, 0xC3A9, 0xF279, 0xF27A, 0xF474, 0xF477,
0xF475, 0xF476, 0xF5E0, 0xC4EF, 0xF7EB, 0xF8B4, 0xC5F7, 0xF8F8,
0xF8F9, 0xC666, 0xA5D9, 0xACE1, 0xDAC3, 0xDEE3, 0xA5DA, 0xA86F,
0xAABE, 0xCFE8, 0xCFE9, 0xAF78, 0xDAC4, 0xB575, 0xB847, 0xC142,
0xEDA4, 0xF27C, 0xF478, 0xA5DB, 0xCDA1, 0xCD7A, 0xCD7C, 0xCD7E,
0xCD7D, 0xCD7B, 0xAABF, 0xACE2, 0xCFF2, 0xCFED, 0xCFEA, 0xCFF1,
0xACE4, 0xACE5, 0xCFF0, 0xCFEF, 0xCFEE, 0xCFEB, 0xCFEC, 0xCFF3,
0xACE3, 0xAF7C, 0xAFA4, 0xAFA3, 0xD2E1, 0xD2DB, 0xD2D9, 0xAFA1,
0xD6B9, 0xAF7A, 0xD2DE, 0xD2E2, 0xD2E4, 0xD2E0, 0xD2DA, 0xAFA2,
0xD2DF, 0xD2DD, 0xAF79, 0xD2E5, 0xAFA5, 0xD2E3, 0xAF7D, 0xD2DC,
0xAF7E, 0xAF7B, 0xB2B9, 0xD6BA, 0xD6B3, 0xD6B5, 0xD6B7, 0xD6B8,
0xD6B6, 0xB2BA, 0xD6BB, 0xD6B4, 0xDAC8, 0xB576, 0xDAD0, 0xDAC5,
0xDAD1, 0xDAC6, 0xDAC7, 0xDACF, 0xDACE, 0xDACB, 0xB2B8, 0xB577,
0xDAC9, 0xDACC, 0xB578, 0xDACD, 0xDACA, 0xDEEE, 0xDEF2, 0xB84E,
0xE2F0, 0xB851, 0xDEF0, 0xDEED, 0xDEE8, 0xDEEA, 0xDEEB, 0xDEE4,
0xB84D, 0xB84C, 0xB848, 0xDEE7, 0xB84F, 0xB850, 0xDEE6, 0xDEE9,
0xDEF1, 0xB84A, 0xB84B, 0xDEEF, 0xDEE5, 0xE2F2, 0xBAD0, 0xE2F4,
0xDEEC, 0xE2F6, 0xBAD4, 0xE2F7, 0xE2F3, 0xBAD1, 0xE2EF, 0xBAD3,
0xE2EC, 0xE2F1, 0xE2F5, 0xE2EE, 0xB849, 0xE2EB, 0xBAD2, 0xE2ED,
0xBD54, 0xE6C1, 0xBD58, 0xBD56, 0xBACF, 0xE6C8, 0xE6C9, 0xBD53,
0xE6C7, 0xE6CA, 0xBD55, 0xBD52, 0xE6C3, 0xE6C0, 0xE6C5, 0xE6C2,
0xBD59, 0xE6C4, 0xE6C6, 0xBD57, 0xBF6A, 0xEAA8, 0xEAA2, 0xEAA6,
0xEAAC, 0xEAAD, 0xEAA9, 0xEAAA, 0xEAA7, 0xEAA4, 0xBF6C, 0xBF69,
0xEAA3, 0xEAA5, 0xBF6B, 0xEAAB, 0xC146, 0xEDAA, 0xEDA5, 0xC145,
0xC143, 0xEDAC, 0xC144, 0xEDA8, 0xEDA9, 0xEDA6, 0xEDAD, 0xF056,
0xC147, 0xEDA7, 0xEDAE, 0xEDAB, 0xF05A, 0xF057, 0xC2A6, 0xF05B,
0xF05D, 0xF05C, 0xF058, 0xF059, 0xF2A3, 0xC3AA, 0xF27E, 0xF2A2,
0xF27D, 0xF2A4, 0xF2A1, 0xF47A, 0xF47D, 0xF479, 0xC471, 0xF47B,
0xF47C, 0xF47E, 0xC472, 0xC474, 0xC473, 0xF5E1, 0xF5E3, 0xF5E2,
0xF6F6, 0xF8B5, 0xF8FA, 0xA5DC, 0xCB72, 0xAAC0, 0xCDA3, 0xAAC1,
0xAAC2, 0xCDA2, 0xCFF8, 0xCFF7, 0xACE6, 0xACE9, 0xACE8, 0xACE7,
0xCFF4, 0xCFF6, 0xCFF5, 0xD2E8, 0xAFA7, 0xD2EC, 0xD2EB, 0xD2EA,
0xD2E6, 0xAFA6, 0xAFAA, 0xAFAD, 0xAFAE, 0xD2E7, 0xD2E9, 0xAFAC,
0xAFAB, 0xAFA9, 0xAFA8, 0xD6C2, 0xD6C0, 0xD6BC, 0xB2BB, 0xD6BD,
0xB2BC, 0xD6BE, 0xD6BF, 0xD6C1, 0xB2BD, 0xDAD5, 0xDAD4, 0xDAD3,
0xDAD2, 0xDEF6, 0xB852, 0xDEF3, 0xDEF5, 0xB853, 0xB854, 0xDEF4,
0xE341, 0xE2F9, 0xE2FA, 0xBAD7, 0xBAD5, 0xBAD6, 0xE343, 0xE342,
0xE2FE, 0xE2FD, 0xE2FC, 0xE2FB, 0xE340, 0xE2F8, 0xE6CB, 0xE6D0,
0xE6CE, 0xE6CD, 0xE6CC, 0xE6CF, 0xEAAE, 0xBF6D, 0xC148, 0xEDB0,
0xC149, 0xEDAF, 0xF05F, 0xF05E, 0xC2A7, 0xF2A5, 0xC3AB, 0xF4A1,
0xC5A1, 0xF6F7, 0xF8B7, 0xF8B6, 0xC9A8, 0xACEA, 0xACEB, 0xD6C3,
0xB856, 0xA5DD, 0xA872, 0xA871, 0xA870, 0xCDA4, 0xAAC4, 0xAAC3,
0xACEE, 0xCFFA, 0xCFFD, 0xCFFB, 0xACEC, 0xACED, 0xCFF9, 0xCFFC,
0xAFB5, 0xD2F3, 0xD2F5, 0xD2F4, 0xAFB2, 0xD2EF, 0xAFB0, 0xAFAF,
0xAFB3, 0xAFB1, 0xAFB4, 0xD2F2, 0xD2ED, 0xD2EE, 0xD2F1, 0xD2F0,
0xD6C6, 0xD6C7, 0xD6C5, 0xD6C4, 0xB2BE, 0xB57D, 0xDAD6, 0xDAD8,
0xDADA, 0xB57C, 0xB57A, 0xDAD7, 0xB57B, 0xDAD9, 0xB579, 0xDF41,
0xDEF7, 0xDEFA, 0xDEFE, 0xB85A, 0xDEFC, 0xDEFB, 0xDEF8, 0xDEF9,
0xB858, 0xDF40, 0xB857, 0xB85C, 0xB85B, 0xB859, 0xDEFD, 0xE349,
0xE348, 0xE344, 0xBAD8, 0xE347, 0xE346, 0xBAD9, 0xBD5E, 0xE6D2,
0xBD5F, 0xBD5B, 0xBD5D, 0xBD5A, 0xBD5C, 0xEAAF, 0xBF70, 0xEAB1,
0xEAB0, 0xE345, 0xBF72, 0xBF71, 0xBF6E, 0xBF6F, 0xEDB5, 0xEDB3,
0xC14A, 0xEDB4, 0xEDB6, 0xEDB2, 0xEDB1, 0xF060, 0xC2AA, 0xC2A8,
0xC2A9, 0xF2A6, 0xF2A7, 0xC3AD, 0xC3AC, 0xF4A3, 0xF4A4, 0xF4A2,
0xF6F8, 0xF6F9, 0xA5DE, 0xCA48, 0xA873, 0xCDA5, 0xAAC6, 0xAAC5,
0xCDA6, 0xD040, 0xACEF, 0xCFFE, 0xACF0, 0xAFB6, 0xD2F8, 0xD2F6,
0xD2FC, 0xAFB7, 0xD2F7, 0xD2FB, 0xD2F9, 0xD2FA, 0xD6C8, 0xD6CA,
0xB2BF, 0xD6C9, 0xB2C0, 0xB5A2, 0xB5A1, 0xB57E, 0xDADB, 0xDF44,
0xB85D, 0xB85E, 0xDF43, 0xDF42, 0xE34A, 0xBADB, 0xBADA, 0xE34B,
0xE34C, 0xBD61, 0xBD60, 0xEAB5, 0xE6D3, 0xE6D5, 0xE6D4, 0xEAB4,
0xEAB2, 0xEAB6, 0xEAB3, 0xBF73, 0xEDB7, 0xC14B, 0xEDB8, 0xEDB9,
0xC2AB, 0xC2AC, 0xC475, 0xC5D1, 0xA5DF, 0xD041, 0xD2FD, 0xAFB8,
0xB3BA, 0xB3B9, 0xB5A4, 0xDADD, 0xB5A3, 0xDADC, 0xDF45, 0xBADC,
0xE34D, 0xBADD, 0xC476, 0xF4A5, 0xA6CB, 0xAAC7, 0xCDA7, 0xACF2,
0xACF1, 0xD042, 0xD043, 0xD340, 0xD342, 0xAFB9, 0xD344, 0xD347,
0xD345, 0xD346, 0xD343, 0xD2FE, 0xAFBA, 0xD348, 0xD341, 0xD6D3,
0xB2C6, 0xD6DC, 0xB2C3, 0xD6D5, 0xB2C7, 0xB2C1, 0xD6D0, 0xD6DD,
0xD6D1, 0xD6CE, 0xB2C5, 0xB2C2, 0xD6D4, 0xD6D7, 0xB2C4, 0xD6D8,
0xB2C8, 0xD6D9, 0xD6CF, 0xD6D6, 0xD6DA, 0xD6D2, 0xD6CD, 0xD6CB,
0xD6DB, 0xDADF, 0xDAE4, 0xDAE0, 0xDAE6, 0xB5A7, 0xD6CC, 0xDAE1,
0xB5A5, 0xDADE, 0xB5AC, 0xDAE2, 0xB5AB, 0xDAE3, 0xB5AD, 0xB5A8,
0xB5AE, 0xB5A9, 0xB5AA, 0xB5A6, 0xDAE5, 0xB861, 0xDF50, 0xDF53,
0xDF47, 0xDF4C, 0xDF46, 0xB863, 0xDF4A, 0xDF48, 0xB862, 0xDF4F,
0xDF4E, 0xDF4B, 0xDF4D, 0xDF49, 0xBAE1, 0xDF52, 0xB85F, 0xDF51,
0xE35D, 0xBAE8, 0xE358, 0xBAE7, 0xE34E, 0xE350, 0xBAE0, 0xE355,
0xE354, 0xE357, 0xBAE5, 0xE352, 0xE351, 0xBAE4, 0xBADF, 0xE353,
0xBAE2, 0xE359, 0xE35B, 0xE356, 0xE34F, 0xBAE3, 0xBD69, 0xBADE,
0xE35C, 0xE6D9, 0xBD62, 0xE6DB, 0xBD63, 0xBD65, 0xE6DE, 0xE6D6,
0xBAE6, 0xE6DC, 0xE6D8, 0xB860, 0xBD68, 0xBD64, 0xBD66, 0xBD67,
0xBF76, 0xE6DD, 0xE6D7, 0xBD6A, 0xE6DA, 0xEAC0, 0xEABB, 0xEAC5,
0xBF74, 0xEABD, 0xBF78, 0xEAC3, 0xEABA, 0xEAB7, 0xEAC6, 0xC151,
0xBF79, 0xEAC2, 0xEAB8, 0xBF77, 0xEABC, 0xBF7B, 0xEAB9, 0xEABE,
0xBF7A, 0xEAC1, 0xEAC4, 0xEDCB, 0xEDCC, 0xEDBC, 0xEDC3, 0xEDC1,
0xC14F, 0xEDC8, 0xEABF, 0xEDBF, 0xEDC9, 0xC14E, 0xEDBE, 0xEDBD,
0xEDC7, 0xEDC4, 0xEDC6, 0xEDBA, 0xEDCA, 0xC14C, 0xEDC5, 0xEDCE,
0xEDC2, 0xC150, 0xC14D, 0xEDC0, 0xEDBB, 0xEDCD, 0xBF75, 0xF063,
0xF061, 0xF067, 0xC2B0, 0xF065, 0xF064, 0xC2B2, 0xF06A, 0xC2B1,
0xF06B, 0xF068, 0xC2AE, 0xF069, 0xF062, 0xC2AF, 0xC2AD, 0xF2AB,
0xF066, 0xF06C, 0xF2A8, 0xC3B2, 0xC3B0, 0xF2AA, 0xF2AC, 0xF2A9,
0xC3B1, 0xC3AE, 0xC3AF, 0xC3B3, 0xC478, 0xF4AA, 0xF4A9, 0xF4A7,
0xF4A6, 0xF4A8, 0xC477, 0xC479, 0xC4F0, 0xF5E5, 0xF5E4, 0xF6FA,
0xF6FC, 0xF6FE, 0xF6FD, 0xF6FB, 0xC5A3, 0xC5A2, 0xC5D3, 0xC5D2,
0xC5D4, 0xF7ED, 0xF7EC, 0xF8FB, 0xF8B8, 0xF8FC, 0xC658, 0xC659,
0xF96D, 0xC67E, 0xA6CC, 0xCDA8, 0xD045, 0xD046, 0xD044, 0xACF3,
0xD047, 0xD048, 0xD049, 0xD349, 0xD34F, 0xD34D, 0xAFBB, 0xD34B,
0xD34C, 0xD34E, 0xD34A, 0xB2C9, 0xD6DE, 0xB2CB, 0xD6E0, 0xB2CA,
0xD6DF, 0xDAE8, 0xB5AF, 0xDAEA, 0xDAE7, 0xD6E1, 0xB5B0, 0xDAE9,
0xDF56, 0xB864, 0xDF54, 0xB865, 0xDF55, 0xB866, 0xBAE9, 0xE361,
0xE35E, 0xE360, 0xBAEA, 0xBAEB, 0xE35F, 0xE6DF, 0xE6E0, 0xBD6B,
0xE6E2, 0xE6E1, 0xA261, 0xEACA, 0xEACB, 0xEAC7, 0xEAC8, 0xBF7C,
0xBF7D, 0xEAC9, 0xC157, 0xC153, 0xC158, 0xC154, 0xC156, 0xC152,
0xC155, 0xC2B3, 0xEDCF, 0xF2AE, 0xF2AD, 0xF4AB, 0xC47A, 0xC47B,
0xF741, 0xF5E6, 0xF740, 0xF8FD, 0xF9A4, 0xA6CD, 0xA874, 0xCDA9,
0xAAC8, 0xACF6, 0xD04C, 0xACF4, 0xD04A, 0xACF9, 0xACF5, 0xACFA,
0xACF8, 0xD04B, 0xACF7, 0xAFBF, 0xAFBE, 0xD35A, 0xAFC7, 0xD353,
0xD359, 0xAFC3, 0xD352, 0xD358, 0xD356, 0xAFC2, 0xAFC4, 0xD355,
0xAFBD, 0xD354, 0xAFC8, 0xAFC5, 0xAFC9, 0xAFC6, 0xD351, 0xD350,
0xD357, 0xAFC0, 0xAFBC, 0xAFC1, 0xD6F0, 0xD6E9, 0xB5B5, 0xD6E8,
0xB2CF, 0xB2D6, 0xB2D3, 0xB2D9, 0xB2D8, 0xB2D4, 0xD6E2, 0xD6E5,
0xD6E4, 0xB2D0, 0xD6E6, 0xD6EF, 0xB2D1, 0xD6E3, 0xD6EC, 0xD6ED,
0xB2D2, 0xD6EA, 0xB2D7, 0xB2CD, 0xB2D5, 0xD6E7, 0xB2CC, 0xD6EB,
0xD6EE, 0xDAFB, 0xDAF2, 0xB5B2, 0xDAF9, 0xDAF6, 0xDAEE, 0xDAF7,
0xB5B4, 0xDAEF, 0xDAEB, 0xB86C, 0xDAF4, 0xB5B1, 0xDAFA, 0xB5B8,
0xB5BA, 0xDAED, 0xB5B9, 0xDAF0, 0xB5B3, 0xDAF8, 0xDAF1, 0xDAF5,
0xDAF3, 0xB5B6, 0xDAEC, 0xB5BB, 0xB2CE, 0xB5B7, 0xB5BC, 0xB868,
0xDF5D, 0xDF5F, 0xDF61, 0xDF65, 0xDF5B, 0xDF59, 0xB86A, 0xDF60,
0xDF64, 0xDF5C, 0xDF58, 0xDF57, 0xDF62, 0xDF5A, 0xDF5E, 0xB86B,
0xB869, 0xDF66, 0xB867, 0xDF63, 0xE372, 0xBAEE, 0xE36A, 0xBD78,
0xE374, 0xBAF1, 0xE378, 0xBAF7, 0xE365, 0xE375, 0xE362, 0xE377,
0xE366, 0xBAFE, 0xBAFB, 0xE376, 0xE370, 0xBAED, 0xBAF5, 0xBAF4,
0xBAF3, 0xBAF9, 0xE363, 0xBAFA, 0xE371, 0xBAF6, 0xBAEC, 0xE373,
0xBAEF, 0xBAF0, 0xBAF8, 0xE368, 0xE367, 0xE364, 0xE36C, 0xE369,
0xE36D, 0xBAFD, 0xE379, 0xBAF2, 0xE36E, 0xE36F, 0xE36B, 0xBAFC,
0xE6E7, 0xBD70, 0xBD79, 0xBD75, 0xE6E4, 0xBD72, 0xBD76, 0xE6F0,
0xBD6C, 0xE6E8, 0xBD74, 0xE6EB, 0xE6E6, 0xBD73, 0xBD77, 0xE6E5,
0xBD71, 0xE6EF, 0xBD6E, 0xE6EE, 0xE6ED, 0xBD7A, 0xE572, 0xBD6D,
0xE6EC, 0xE6E3, 0xBD7B, 0xE6EA, 0xBD6F, 0xE6E9, 0xBFA2, 0xBFA7,
0xBF7E, 0xEAD8, 0xEACF, 0xEADB, 0xEAD3, 0xEAD9, 0xBFA8, 0xBFA1,
0xEACC, 0xEAD2, 0xEADC, 0xEAD5, 0xEADA, 0xEACE, 0xEAD6, 0xBFA3,
0xEAD4, 0xBFA6, 0xBFA5, 0xEAD0, 0xEAD1, 0xEACD, 0xEAD7, 0xBFA4,
0xEADE, 0xEADD, 0xEDDA, 0xEDD6, 0xC15F, 0xEDD0, 0xC159, 0xC169,
0xEDDC, 0xC161, 0xC15D, 0xEDD3, 0xC164, 0xC167, 0xEDDE, 0xC15C,
0xEDD5, 0xC165, 0xEDE0, 0xEDDD, 0xEDD1, 0xC160, 0xC15A, 0xC168,
0xEDD8, 0xC163, 0xEDD2, 0xC15E, 0xEDDF, 0xC162, 0xC15B, 0xEDD9,
0xC166, 0xEDD7, 0xEDDB, 0xF06E, 0xF074, 0xC2B9, 0xF077, 0xC2B4,
0xC2B5, 0xF06F, 0xF076, 0xF071, 0xC2BA, 0xC2B7, 0xF06D, 0xC2B6,
0xF073, 0xF075, 0xC2B8, 0xF072, 0xF070, 0xF2B8, 0xC3B7, 0xC3B8,
0xC3B4, 0xC3B5, 0xF2B4, 0xF2B2, 0xF2B6, 0xC3BA, 0xF2B7, 0xF2B0,
0xF2AF, 0xF2B3, 0xF2B1, 0xC3B6, 0xF2B5, 0xF4AC, 0xC47E, 0xC47D,
0xF4AD, 0xF4AF, 0xF4AE, 0xC4A1, 0xF5EB, 0xF5E8, 0xF5E9, 0xF5E7,
0xF5EA, 0xC4F2, 0xF5EC, 0xC4F1, 0xF742, 0xC5D5, 0xC5D7, 0xF7EE,
0xC5D6, 0xF8B9, 0xF940, 0xF942, 0xF8FE, 0xF941, 0xC66C, 0xA6CE,
0xACFB, 0xD26F, 0xAFCA, 0xB2DA, 0xDAFC, 0xDAFD, 0xEADF, 0xC16A,
0xEDE1, 0xC2BB, 0xF2BA, 0xF2B9, 0xC4A2, 0xF5ED, 0xF743, 0xC5F8,
0xCA49, 0xAAC9, 0xA875, 0xD04D, 0xD360, 0xD35B, 0xD35F, 0xD35D,
0xAFCB, 0xD35E, 0xD35C, 0xD6F1, 0xDAFE, 0xDB40, 0xDF69, 0xDF6A,
0xB86E, 0xB86F, 0xDF68, 0xDF6B, 0xDF67, 0xB86D, 0xBB40, 0xB870,
0xE37A, 0xBD7C, 0xE6F1, 0xBD7D, 0xBFA9, 0xEAE2, 0xEAE0, 0xEAE1,
0xEDE4, 0xEDE3, 0xEDE2, 0xF2BB, 0xC3B9, 0xF2BC, 0xF744, 0xC5F9,
0xF8BA, 0xA6CF, 0xAACB, 0xAACA, 0xD04F, 0xACFC, 0xD04E, 0xD362,
0xAFCC, 0xD6F2, 0xD361, 0xB2DC, 0xD6F5, 0xD6F3, 0xD6F4, 0xB2DB,
0xDB42, 0xDB43, 0xDB41, 0xB873, 0xDF6D, 0xDF6C, 0xDF6E, 0xB872,
0xB871, 0xE6F2, 0xE6F4, 0xBD7E, 0xE6F3, 0xEAE3, 0xBFAA, 0xF079,
0xF078, 0xC3BB, 0xF2BD, 0xC3BD, 0xC3BC, 0xF4B0, 0xF5EE, 0xC4F3,
0xA6D0, 0xD050, 0xACFD, 0xD365, 0xAFCE, 0xD364, 0xD363, 0xAFCD,
0xD6FB, 0xD6FD, 0xD6F6, 0xD6F7, 0xB2DD, 0xD6F8, 0xB2DE, 0xD6FC,
0xD6F9, 0xD6FA, 0xB2DF, 0xB5BE, 0xB5BF, 0xDB44, 0xDF6F, 0xDF70,
0xE37E, 0xBB43, 0xBB41, 0xBB42, 0xE37B, 0xE37C, 0xE37D, 0xE6F9,
0xE6FA, 0xBDA1, 0xE6F7, 0xE6F6, 0xE6F8, 0xE6F5, 0xBFAD, 0xEAE4,
0xBFAB, 0xBFAC, 0xEDE6, 0xC16B, 0xEDE5, 0xEFA8, 0xF07A, 0xF07B,
0xC2BC, 0xC2BD, 0xC16C, 0xF2BE, 0xF2BF, 0xF4B1, 0xC4A3, 0xA6D1,
0xA6D2, 0xACFE, 0xAACC, 0xAFCF, 0xD051, 0xB5C0, 0xA6D3, 0xAD41,
0xD052, 0xD053, 0xAD40, 0xAD42, 0xA6D4, 0xD054, 0xAFD1, 0xD366,
0xAFD3, 0xAFD0, 0xAFD2, 0xD741, 0xB2E0, 0xD740, 0xD6FE, 0xDF71,
0xE3A1, 0xBDA2, 0xBFAE, 0xEAE6, 0xEAE5, 0xEDE7, 0xF5EF, 0xA6D5,
0xCB73, 0xCDAA, 0xAD43, 0xD055, 0xD368, 0xAFD4, 0xD367, 0xAFD5,
0xD743, 0xB2E2, 0xD742, 0xD744, 0xB2E1, 0xDB46, 0xDB47, 0xDB45,
0xB5C1, 0xB874, 0xB875, 0xBB45, 0xE3A3, 0xE3A2, 0xBB44, 0xE6FB,
0xE6FC, 0xEAE7, 0xC170, 0xC16F, 0xC16D, 0xC16E, 0xC171, 0xF07C,
0xC2BF, 0xC2BE, 0xF2C0, 0xF4B2, 0xC5A5, 0xC5A4, 0xA6D6, 0xD1FB,
0xB877, 0xB5C2, 0xB876, 0xBB46, 0xA6D7, 0xC9A9, 0xA6D8, 0xA6D9,
0xCDAB, 0xCB76, 0xCB77, 0xA877, 0xCB74, 0xA876, 0xA879, 0xCB75,
0xA87B, 0xA87A, 0xCB78, 0xA878, 0xAAD1, 0xAACF, 0xCDAD, 0xAACE,
0xAAD3, 0xAAD5, 0xAAD2, 0xCDB0, 0xCDAC, 0xAAD6, 0xAAD0, 0xA87C,
0xAAD4, 0xCDAF, 0xCDAE, 0xAACD, 0xD05B, 0xAD47, 0xAD48, 0xD05D,
0xD057, 0xD05A, 0xD063, 0xD061, 0xAD49, 0xD067, 0xAD4C, 0xD064,
0xD05C, 0xD059, 0xDB49, 0xD062, 0xAD44, 0xD065, 0xD056, 0xD05F,
0xAD46, 0xAD4B, 0xD060, 0xAD4F, 0xAD4D, 0xD058, 0xAD4A, 0xD05E,
0xAD4E, 0xAD45, 0xD066, 0xAFDA, 0xAFE3, 0xAFD8, 0xAFD6, 0xD36A,
0xAFDE, 0xAFDB, 0xD36C, 0xAFDD, 0xD36B, 0xD369, 0xD36E, 0xAFE2,
0xAFE0, 0xDB48, 0xD36F, 0xD36D, 0xAFD7, 0xAFD9, 0xAFDC, 0xAFDF,
0xAFE1, 0xD74E, 0xB2E4, 0xD745, 0xD747, 0xD748, 0xD750, 0xD74C,
0xD74A, 0xD74D, 0xD751, 0xB2E5, 0xB2E9, 0xD746, 0xD74F, 0xB2E7,
0xB2E6, 0xD74B, 0xD749, 0xB2E3, 0xB2E8, 0xB5C8, 0xDB51, 0xDB4F,
0xB5CA, 0xDB4A, 0xDFA1, 0xB5C9, 0xDB4E, 0xDB4B, 0xB5C5, 0xB5CB,
0xDB50, 0xB5C7, 0xDB4D, 0xBB47, 0xB5C6, 0xDB4C, 0xB5CC, 0xB5C4,
0xB5C3, 0xDF77, 0xDF75, 0xDF7B, 0xDF73, 0xDFA2, 0xDF78, 0xDF72,
0xB87B, 0xB8A3, 0xDF7D, 0xDF76, 0xB87E, 0xB87C, 0xDF7E, 0xB879,
0xB878, 0xDF79, 0xB87D, 0xB5CD, 0xDF7C, 0xDF74, 0xB87A, 0xB8A1,
0xB8A2, 0xBB4C, 0xBB48, 0xBB4D, 0xE3A6, 0xE3A5, 0xE3A7, 0xBB4A,
0xE3A4, 0xBB4B, 0xE3AA, 0xE3A9, 0xE3A8, 0xBB49, 0xE741, 0xE744,
0xBDA8, 0xE743, 0xBDA7, 0xBDA3, 0xBDA4, 0xBDA5, 0xE740, 0xE6FE,
0xBDA6, 0xE742, 0xE6FD, 0xEAE9, 0xEAF3, 0xBFB1, 0xBFB0, 0xEAED,
0xEAEF, 0xEAEA, 0xEAEE, 0xEAE8, 0xEAF1, 0xBFAF, 0xEAF0, 0xEAEC,
0xEAF2, 0xEAEB, 0xC174, 0xEDE8, 0xEDEE, 0xC178, 0xC17A, 0xC177,
0xC176, 0xC175, 0xC173, 0xEDE9, 0xEDEC, 0xC172, 0xEDED, 0xC179,
0xEDEB, 0xEDEA, 0xC2C0, 0xC2C1, 0xF0A1, 0xF07D, 0xF07E, 0xF2C2,
0xF2C1, 0xC3BE, 0xF4B4, 0xC4A4, 0xF4B3, 0xF5F0, 0xF745, 0xC5A6,
0xF943, 0xF944, 0xC5D8, 0xA6DA, 0xAAD7, 0xDB52, 0xBB4E, 0xC17B,
0xEDEF, 0xA6DB, 0xAFE5, 0xAFE4, 0xDB53, 0xEAF4, 0xA6DC, 0xAD50,
0xDB54, 0xDB55, 0xDB56, 0xBB4F, 0xBFB2, 0xA6DD, 0xAAD8, 0xD068,
0xAFE6, 0xD370, 0xB2EA, 0xDB57, 0xB8A4, 0xBB50, 0xBFB3, 0xC17C,
0xC2C2, 0xF4B5, 0xA6DE, 0xAAD9, 0xAFE7, 0xD752, 0xB5CE, 0xBB51,
0xE3AB, 0xE745, 0xA6DF, 0xB5CF, 0xDFA3, 0xBB52, 0xA6E0, 0xCDB1,
0xD069, 0xAD51, 0xD372, 0xAFEA, 0xAFE8, 0xAFE9, 0xAFEB, 0xD371,
0xD757, 0xD754, 0xD756, 0xB2EB, 0xB2ED, 0xB2EC, 0xD753, 0xB2EE,
0xD755, 0xDB58, 0xDB59, 0xDB5A, 0xDFA6, 0xDFA7, 0xDFA5, 0xDFA8,
0xB8A5, 0xDFA4, 0xBB53, 0xE74A, 0xE746, 0xE749, 0xE74B, 0xE748,
0xE747, 0xEAF5, 0xEAF6, 0xEAF7, 0xBFB4, 0xBFB5, 0xEDF1, 0xEDF0,
0xEDF2, 0xF0A3, 0xF0A2, 0xF2C4, 0xF2C5, 0xF2C3, 0xC4A5, 0xF4B6,
0xF4B7, 0xF746, 0xF7EF, 0xF8BB, 0xA6E1, 0xA87D, 0xC17D, 0xA6E2,
0xD758, 0xDB5B, 0xC641, 0xCA4A, 0xCA4B, 0xCA4D, 0xA6E3, 0xCA4E,
0xCA4C, 0xCBA2, 0xCBA3, 0xCB7B, 0xCBA1, 0xA8A1, 0xA8A2, 0xCB7C,
0xCB7A, 0xCB79, 0xCB7D, 0xA87E, 0xCB7E, 0xD06A, 0xCDB6, 0xAADC,
0xCDB5, 0xCDB7, 0xAADB, 0xCDBC, 0xAADF, 0xCDB2, 0xCDC0, 0xCDC6,
0xAAE6, 0xCDC3, 0xAAE3, 0xCDB9, 0xCDBF, 0xCDC1, 0xCDB4, 0xAAE2,
0xAADD, 0xCDBA, 0xAAE4, 0xAAE7, 0xAAE1, 0xAADA, 0xCDBE, 0xCDB8,
0xCDC5, 0xAAE9, 0xAAE5, 0xAAE0, 0xCDBD, 0xAFEC, 0xCDBB, 0xAADE,
0xAAE8, 0xCDB3, 0xCDC2, 0xCDC4, 0xAD62, 0xAD5C, 0xAD64, 0xAD61,
0xD071, 0xD074, 0xAD5D, 0xD06B, 0xAD56, 0xAD60, 0xAD63, 0xAD65,
0xD0A2, 0xD077, 0xAD55, 0xD0A1, 0xAD59, 0xAD57, 0xAD52, 0xD06F,
0xD07E, 0xD073, 0xD076, 0xD0A5, 0xAD66, 0xD07D, 0xAD5E, 0xD078,
0xD0A4, 0xD075, 0xD079, 0xD07C, 0xD06D, 0xD0A3, 0xD07B, 0xD06C,
0xD070, 0xAD5F, 0xAD5A, 0xAD53, 0xAD58, 0xAD54, 0xAD67, 0xD06E,
0xD3A5, 0xAD5B, 0xD07A, 0xCE41, 0xD3A8, 0xAFFA, 0xD376, 0xD3A3,
0xD37D, 0xD3B2, 0xD3AA, 0xD37E, 0xD3A9, 0xD378, 0xD37C, 0xD3B5,
0xAFFD, 0xD3AD, 0xD3A4, 0xAFED, 0xD3B3, 0xD374, 0xD3AC, 0xAFFC,
0xAFF7, 0xD373, 0xAFF5, 0xAFF4, 0xAFF9, 0xD3AB, 0xAFF1, 0xAFF8,
0xD072, 0xDB5C, 0xD3A6, 0xD37A, 0xAFFB, 0xD37B, 0xD3A1, 0xAFFE,
0xD375, 0xD3AF, 0xD3AE, 0xD3B6, 0xAFF3, 0xAFF0, 0xD3B4, 0xD3B0,
0xD3A7, 0xD3A2, 0xAFF6, 0xAFF2, 0xD377, 0xAFEE, 0xD3B1, 0xAFEF,
0xD379, 0xD75E, 0xD760, 0xD765, 0xD779, 0xB2FC, 0xB2F2, 0xD75D,
0xB2FD, 0xB2FE, 0xD768, 0xD76F, 0xD775, 0xD762, 0xD769, 0xB340,
0xD777, 0xD772, 0xB2FA, 0xB2F8, 0xD76E, 0xD76A, 0xD75C, 0xB2EF,
0xD761, 0xD759, 0xB2F7, 0xB2F9, 0xD766, 0xD763, 0xB2F4, 0xD773,
0xB2F1, 0xD764, 0xD77A, 0xD76C, 0xD76B, 0xB2F0, 0xB2FB, 0xB2F3,
0xD75A, 0xD75F, 0xD770, 0xD776, 0xB341, 0xD75B, 0xD767, 0xD76D,
0xB2F6, 0xD778, 0xD771, 0xD774, 0xB2F5, 0xDB6C, 0xDB60, 0xB5D7,
0xDB7D, 0xDBA7, 0xDBAA, 0xB5D5, 0xDB68, 0xDBA3, 0xDB69, 0xDB77,
0xB5E2, 0xDB73, 0xB5DF, 0xDB74, 0xDB5D, 0xDBA4, 0xB5E8, 0xDBA1,
0xDB75, 0xDBAC, 0xDB70, 0xDFC8, 0xDBAF, 0xB5E6, 0xDB6E, 0xDB7A,
0xB5E9, 0xB5D4, 0xDB72, 0xDBAD, 0xDB6B, 0xDB64, 0xDB6F, 0xDB63,
0xDB61, 0xB5D0, 0xDBA5, 0xDB6A, 0xDBA8, 0xDBA9, 0xB5D8, 0xB5DD,
0xB5D9, 0xB5E1, 0xDB7E, 0xB5DA, 0xDB76, 0xDB66, 0xB5D2, 0xDB5E,
0xDBA2, 0xDBAB, 0xDB65, 0xB5E0, 0xDBB0, 0xDB71, 0xDB6D, 0xB5D1,
0xB5E5, 0xDB7C, 0xB5E7, 0xDB78, 0xB5DC, 0xB5D6, 0xB5DE, 0xB5D3,
0xB5E4, 0xDB79, 0xDB67, 0xDB7B, 0xDB62, 0xDBA6, 0xDBAE, 0xDB5F,
0xDFC7, 0xDFDD, 0xB855, 0xDFCC, 0xDFCA, 0xDFB5, 0xB8A9, 0xDFC5,
0xDFD9, 0xDFC1, 0xB8B1, 0xDFD8, 0xDFBF, 0xB5E3, 0xDFCF, 0xDFC0,
0xDFD6, 0xB8B0, 0xB8A8, 0xDFAA, 0xDFB2, 0xDFCB, 0xDFC3, 0xDFDC,
0xDFC6, 0xB8B6, 0xDFD7, 0xB8AD, 0xDFC9, 0xDFD1, 0xDFB6, 0xDFD0,
0xDFE1, 0xDFB1, 0xDFD2, 0xDFDF, 0xDFAB, 0xB5DB, 0xDFB9, 0xDFB8,
0xB8AF, 0xDFBC, 0xDFBE, 0xDFCD, 0xDFDE, 0xB8B2, 0xB8B3, 0xDFB0,
0xB8AB, 0xDFB4, 0xDFDA, 0xB8B4, 0xB8AC, 0xB8AE, 0xB8B5, 0xDFE0,
0xDFD3, 0xDFCE, 0xDFBB, 0xDFBA, 0xB8AA, 0xDFAC, 0xB8A7, 0xDFC4,
0xDFAD, 0xDFC2, 0xDFB7, 0xDFDB, 0xB8A6, 0xDFB3, 0xDFAF, 0xDFD5,
0xDFAE, 0xBB60, 0xE3D3, 0xE3C2, 0xE3AC, 0xE3CA, 0xBB58, 0xE3BB,
0xE3C5, 0xBB5B, 0xE3BE, 0xBB59, 0xE3AF, 0xE3CD, 0xE3AE, 0xE3C1,
0xE3AD, 0xE3BF, 0xE3C8, 0xE3C6, 0xE3BA, 0xE3B5, 0xE3B3, 0xE3B4,
0xE3C7, 0xE3D2, 0xE3BC, 0xBB5A, 0xE3B7, 0xE3CB, 0xBB5D, 0xE3B6,
0xE3B0, 0xE3C0, 0xBB61, 0xBB55, 0xBB5E, 0xE3B8, 0xE3B2, 0xBB57,
0xDFD4, 0xBB56, 0xE3C3, 0xBB54, 0xBB63, 0xBB5C, 0xE3C4, 0xE3B9,
0xE3B1, 0xE3CC, 0xE3BD, 0xBB62, 0xE3D0, 0xBB5F, 0xE3CF, 0xE3C9,
0xE3CE, 0xE3D1, 0xE773, 0xE774, 0xE767, 0xE766, 0xE762, 0xBDB4,
0xBDAC, 0xE776, 0xE775, 0xDFA9, 0xE75F, 0xE763, 0xE75D, 0xE770,
0xE761, 0xE777, 0xE75A, 0xE758, 0xE764, 0xE76E, 0xE769, 0xBDB6,
0xE74F, 0xE76D, 0xBDB7, 0xDFBD, 0xE75B, 0xE752, 0xE755, 0xE77B,
0xE75C, 0xE753, 0xE751, 0xE74E, 0xBDB0, 0xE765, 0xBDAF, 0xBDB3,
0xE760, 0xE768, 0xBDA9, 0xE778, 0xE77C, 0xBDAB, 0xE757, 0xE76B,
0xE76F, 0xE754, 0xE779, 0xBDB2, 0xBDB1, 0xE74C, 0xBDB5, 0xE772,
0xE756, 0xE76A, 0xE750, 0xE75E, 0xE759, 0xBDAD, 0xBDAE, 0xE76C,
0xE77D, 0xE77A, 0xE771, 0xE74D, 0xBDAA, 0xEB49, 0xEB40, 0xEB43,
0xBFBB, 0xEB45, 0xEAF9, 0xEB41, 0xEB47, 0xBFB8, 0xBFBC, 0xBFB6,
0xEAFB, 0xEB4C, 0xEB46, 0xEAFC, 0xEB55, 0xEB4F, 0xEAF8, 0xEE46,
0xEAFE, 0xBFB7, 0xEB4A, 0xEB54, 0xBFBF, 0xEB51, 0xEAFD, 0xEB44,
0xEB48, 0xEB42, 0xEB56, 0xEB53, 0xEB50, 0xBFB9, 0xBFBA, 0xBFBE,
0xEAFA, 0xEB57, 0xBFBD, 0xEB4D, 0xEB4B, 0xEB4E, 0xEE53, 0xEE40,
0xEE45, 0xEE52, 0xEE44, 0xEDFB, 0xEE41, 0xC1A2, 0xEDF4, 0xEE4D,
0xEE4F, 0xEDF3, 0xC1A1, 0xEE51, 0xEE49, 0xC1A8, 0xEE50, 0xEE42,
0xC1AA, 0xEDF9, 0xEB52, 0xEE4A, 0xEE47, 0xEDF5, 0xEE55, 0xC1A4,
0xC1A5, 0xEDF7, 0xEE48, 0xEE54, 0xEE4B, 0xEDFD, 0xC1A7, 0xC1A3,
0xEE4C, 0xEDFE, 0xEE56, 0xEDF8, 0xEE43, 0xEE4E, 0xEDFA, 0xEDFC,
0xC2CB, 0xEDF6, 0xC1A9, 0xC2C4, 0xC17E, 0xC1A6, 0xC2C8, 0xF0B3,
0xF0A9, 0xF0A4, 0xF0AA, 0xF0B4, 0xF0B8, 0xF0B7, 0xC2CA, 0xC2C9,
0xF0AB, 0xF0B9, 0xF0AE, 0xF0A6, 0xF0A8, 0xF0A7, 0xF0AD, 0xF0B2,
0xF0A5, 0xF0AC, 0xF0B1, 0xC2C7, 0xF0AF, 0xC2C5, 0xF0B0, 0xC2C3,
0xC2C6, 0xF2D5, 0xF0B5, 0xC3C2, 0xF2CD, 0xF2D1, 0xF2C9, 0xF2CC,
0xF2D4, 0xC3C0, 0xF2D9, 0xF2D2, 0xF2CA, 0xF2DA, 0xF2D3, 0xC3C3,
0xC3C4, 0xF2D7, 0xF2CB, 0xC3BF, 0xC3C1, 0xF2C6, 0xF2CE, 0xF2C8,
0xF2D8, 0xF2D6, 0xF2C7, 0xF2CF, 0xF4BE, 0xC3C5, 0xF2D0, 0xC4A7,
0xC4A9, 0xC4A6, 0xF4C3, 0xF4BB, 0xF4B9, 0xF4BD, 0xF4BA, 0xF4BF,
0xF4C1, 0xC4AA, 0xC4AC, 0xF4C0, 0xC4AD, 0xC4AB, 0xF4C2, 0xC4A8,
0xC4F4, 0xF5F1, 0xF5F7, 0xC4F6, 0xF4BC, 0xF5F6, 0xF5FD, 0xF5F4,
0xF5FB, 0xF5FA, 0xF4B8, 0xF5F5, 0xF0B6, 0xF5FE, 0xF5F3, 0xF5F8,
0xF5FC, 0xF5F2, 0xF74A, 0xC4F5, 0xF5F9, 0xF7F4, 0xF74B, 0xF749,
0xF747, 0xF748, 0xF74C, 0xC5D9, 0xF7F2, 0xF7F0, 0xF7F5, 0xF7F3,
0xF7F6, 0xC5DA, 0xF7F1, 0xF8BC, 0xF945, 0xF946, 0xF947, 0xF9C7,
0xF9BD, 0xCA4F, 0xAAEA, 0xAD68, 0xD3B8, 0xD3B7, 0xB040, 0xB342,
0xD77C, 0xD77B, 0xB5EA, 0xB8B8, 0xB8B7, 0xB8B9, 0xE3D4, 0xE77E,
0xEB58, 0xEB5A, 0xEB59, 0xC1AB, 0xEE57, 0xF0BA, 0xF9A5, 0xA6E4,
0xCDC9, 0xCDCA, 0xCDC8, 0xCDC7, 0xAAEB, 0xD0A9, 0xD0A7, 0xD0A6,
0xAD69, 0xAD6B, 0xAD6A, 0xD0A8, 0xD3C4, 0xD3C1, 0xD3BF, 0xB041,
0xD3C2, 0xB046, 0xD3BC, 0xD3CB, 0xD3CD, 0xD3BD, 0xB043, 0xD3CE,
0xD3C9, 0xD3BB, 0xD3C0, 0xD3CA, 0xD3C6, 0xD3C3, 0xB048, 0xD3CC,
0xD3BE, 0xD3C7, 0xD3B9, 0xB047, 0xB044, 0xD3C5, 0xD3C8, 0xD3BA,
0xB045, 0xB042, 0xB34C, 0xD7A5, 0xB34B, 0xD7A8, 0xD7AB, 0xB348,
0xB346, 0xD77E, 0xD7A9, 0xD7A7, 0xD7A4, 0xD7AC, 0xD7AD, 0xD7AF,
0xD7B0, 0xD77D, 0xB345, 0xD7A2, 0xD7A1, 0xD7AE, 0xB347, 0xD7A3,
0xB349, 0xB344, 0xD7A6, 0xB34D, 0xB34A, 0xD7AA, 0xB5F1, 0xDBBF,
0xDBB4, 0xB5EE, 0xDFE7, 0xDBBD, 0xDBB1, 0xB5EC, 0xDBB6, 0xB5EF,
0xDBBA, 0xDBB8, 0xB5F2, 0xB5EB, 0xDBB2, 0xDBB5, 0xB5F0, 0xDBB3,
0xDBBE, 0xDBBC, 0xDBB7, 0xDBB9, 0xDBBB, 0xB5ED, 0xDFE8, 0xDFEE,
0xDFE4, 0xDFEA, 0xB8BA, 0xDFE6, 0xB8C0, 0xB8BF, 0xB8BE, 0xDFED,
0xB8C1, 0xB8C2, 0xDFE3, 0xDFF0, 0xB8C3, 0xB8BD, 0xB8BC, 0xDFEC,
0xB8C4, 0xDFE2, 0xDFE5, 0xDFEF, 0xDFEB, 0xE3F4, 0xE3E9, 0xB8BB,
0xBB6A, 0xE3DD, 0xE3F2, 0xE3DE, 0xBB65, 0xE3DB, 0xE3E4, 0xE3DC,
0xBB67, 0xE3D6, 0xE3F1, 0xBB68, 0xE3EE, 0xE3EF, 0xE3D7, 0xBB6D,
0xE3E6, 0xE3E0, 0xE3E7, 0xE3DA, 0xE3F3, 0xE3EB, 0xE3E5, 0xE3D5,
0xBB69, 0xE3EC, 0xBB6C, 0xE3F0, 0xE3EA, 0xBB66, 0xE3E8, 0xE3E2,
0xBB64, 0xE3D9, 0xE3E1, 0xE3ED, 0xE3DF, 0xE3E3, 0xBDC1, 0xDFE9,
0xE7B2, 0xE7BB, 0xE7B1, 0xE7AD, 0xE7AA, 0xBDC2, 0xE7A8, 0xBB6B,
0xE7A1, 0xBDC0, 0xE7A7, 0xBDBF, 0xE7AC, 0xE7A9, 0xE7B9, 0xE7B4,
0xE7AE, 0xE7B3, 0xBDBB, 0xE7AB, 0xE7BE, 0xE7A2, 0xE7A3, 0xE7BA,
0xBDBC, 0xE7BF, 0xBDBE, 0xE7C0, 0xE7B0, 0xE3D8, 0xE7B6, 0xE7AF,
0xE7B8, 0xE7B5, 0xE7A6, 0xBDB9, 0xE7BD, 0xBDBA, 0xE7A4, 0xBDBD,
0xEB64, 0xE7B7, 0xE7BC, 0xEB61, 0xBDB8, 0xBFC0, 0xEB6B, 0xEB67,
0xEB65, 0xEB60, 0xEB6F, 0xBFC4, 0xEB5C, 0xEB68, 0xEB69, 0xEB5F,
0xEB5E, 0xEB6C, 0xEB62, 0xEB5D, 0xEB63, 0xEB6E, 0xEB5B, 0xEB6D,
0xEB6A, 0xBFC2, 0xBFC1, 0xBFC3, 0xEB66, 0xF0CB, 0xEE59, 0xC1B1,
0xEE5D, 0xEE5A, 0xEE61, 0xEE67, 0xEE5C, 0xEE70, 0xC1AE, 0xEE6A,
0xEE5F, 0xEE6B, 0xEE66, 0xEE6D, 0xEE5E, 0xC1B3, 0xC1B2, 0xEE60,
0xEE6E, 0xEE58, 0xEE6C, 0xC1AC, 0xEE64, 0xEE63, 0xEE68, 0xEE5B,
0xC1B0, 0xC1B4, 0xEE62, 0xEE69, 0xC1B5, 0xEE65, 0xC1AD, 0xC1AF,
0xF0C7, 0xF0C5, 0xF0CC, 0xF0C9, 0xF0CD, 0xF0BE, 0xF0C6, 0xF0D1,
0xEE6F, 0xF0C2, 0xC2CF, 0xE7A5, 0xF0BD, 0xF0CA, 0xF0C4, 0xF0C1,
0xF0BC, 0xF0BB, 0xF0D0, 0xF0C0, 0xF0BF, 0xC2CD, 0xF0C8, 0xC2CC,
0xC2CE, 0xF0C3, 0xF0CF, 0xF2DE, 0xF2DF, 0xC3C9, 0xF2DC, 0xC3C6,
0xF2E4, 0xC3CA, 0xF2E6, 0xF2DB, 0xF0CE, 0xF2E8, 0xF2DD, 0xC3C7,
0xF2E3, 0xF2E5, 0xF2E0, 0xF2E7, 0xF2E2, 0xF2E1, 0xC3C8, 0xF4C5,
0xF4C6, 0xF4C8, 0xC4AE, 0xC4AF, 0xF4C9, 0xF4C7, 0xF4C4, 0xF642,
0xF645, 0xF641, 0xC4FA, 0xF643, 0xC4F9, 0xC4F8, 0xC4F7, 0xF644,
0xF751, 0xF74F, 0xF74E, 0xF640, 0xF750, 0xF646, 0xF74D, 0xF7F9,
0xF7D7, 0xF7F7, 0xC5DB, 0xF7F8, 0xF7FA, 0xF8BF, 0xC5FA, 0xF8BE,
0xF8BD, 0xC5FB, 0xC65A, 0xF96E, 0xF9A7, 0xF9A6, 0xF9A8, 0xA6E5,
0xD0AA, 0xD3CF, 0xD3D0, 0xDBC0, 0xF647, 0xF8C0, 0xA6E6, 0xAD6C,
0xD0AB, 0xD7B1, 0xB34E, 0xDBC2, 0xDBC1, 0xB5F3, 0xB8C5, 0xE7C1,
0xBDC3, 0xBDC4, 0xBFC5, 0xC5FC, 0xA6E7, 0xD0AC, 0xAAED, 0xD0AE,
0xD0AD, 0xAD6D, 0xD3D1, 0xD3D8, 0xB049, 0xD3D6, 0xD3D4, 0xD3DB,
0xD3D2, 0xD3D3, 0xB04A, 0xB04E, 0xD3DC, 0xB04D, 0xD3DA, 0xD3D7,
0xD3D5, 0xB04B, 0xB04C, 0xD3D9, 0xB350, 0xD7B2, 0xB355, 0xD7C2,
0xB354, 0xD7C4, 0xD7B8, 0xB352, 0xD7C3, 0xD7B3, 0xB353, 0xD7BF,
0xD7BB, 0xD7BD, 0xD7B7, 0xD7BE, 0xB34F, 0xD7BA, 0xD7B9, 0xD7B5,
0xD7C0, 0xD7BC, 0xD7B4, 0xD7B6, 0xB351, 0xD7C1, 0xB5F6, 0xDBCD,
0xDBC9, 0xDBCB, 0xDBC6, 0xDBC5, 0xDBC3, 0xDBCA, 0xDBCC, 0xDBC8,
0xDBC7, 0xB5F4, 0xB5F5, 0xDBCF, 0xB8CD, 0xDFF2, 0xDFF8, 0xDFF3,
0xDFF4, 0xDFF9, 0xB8CF, 0xB8C7, 0xB8CE, 0xDFF1, 0xDBC4, 0xB8CA,
0xB8C8, 0xDFF7, 0xDFF6, 0xB8C9, 0xB8CB, 0xDFF5, 0xB8C6, 0xB8CC,
0xE3F6, 0xBB74, 0xE442, 0xE441, 0xE3FB, 0xBB76, 0xE440, 0xE3F7,
0xE3F8, 0xBB6E, 0xBB70, 0xE3FD, 0xE3F5, 0xBB72, 0xBB71, 0xE3F9,
0xE3FE, 0xE3FC, 0xBB73, 0xE3FA, 0xDBCE, 0xBB6F, 0xE7C2, 0xE7C9,
0xBDC6, 0xE7CD, 0xBDCA, 0xE7C5, 0xE7C3, 0xE7CC, 0xBDC5, 0xE7CB,
0xBDC7, 0xBDC8, 0xE7C4, 0xBDC9, 0xE7CA, 0xE7C6, 0xE7C7, 0xE7C8,
0xBB75, 0xEB70, 0xEB7C, 0xBFCA, 0xEB77, 0xEB79, 0xBFC8, 0xEB71,
0xEB75, 0xEB78, 0xBFC6, 0xBFC9, 0xEB7B, 0xEB73, 0xEB74, 0xEB7A,
0xEB72, 0xEB76, 0xBFC7, 0xEE72, 0xEE71, 0xC1B7, 0xEE77, 0xC1B9,
0xC1B6, 0xEE73, 0xC1BA, 0xEE74, 0xEE75, 0xEE78, 0xC1B8, 0xF0D6,
0xF0D9, 0xF0D3, 0xF0D5, 0xF0D4, 0xF0D7, 0xF0D8, 0xEE76, 0xF0D2,
0xC3CD, 0xF2EC, 0xF2EF, 0xF2F1, 0xF2EA, 0xF2EB, 0xF2EE, 0xF2F0,
0xC3CE, 0xC3CC, 0xC3CB, 0xF2ED, 0xF2E9, 0xF4CA, 0xC4B0, 0xF4CB,
0xF649, 0xC4FB, 0xF64B, 0xC4FC, 0xF648, 0xF64A, 0xC5A8, 0xF752,
0xC5A7, 0xF7FD, 0xF7FC, 0xF7FB, 0xF948, 0xF949, 0xF94B, 0xF94A,
0xCA50, 0xA6E8, 0xAD6E, 0xD7C5, 0xB5F7, 0xDFFA, 0xC2D0, 0xF2F2,
0xA8A3, 0xB357, 0xB356, 0xDBD0, 0xB5F8, 0xDBD2, 0xDBD1, 0xDFFB,
0xB8D0, 0xE443, 0xE446, 0xE445, 0xE444, 0xE7CE, 0xE7D0, 0xE7CF,
0xBFCC, 0xBFCB, 0xC1BB, 0xEE79, 0xEE7B, 0xEE7A, 0xC2D1, 0xF2F4,
0xF2F3, 0xF4CC, 0xC4B1, 0xC4FD, 0xF754, 0xF753, 0xC65B, 0xA8A4,
0xD0AF, 0xAD6F, 0xD7C8, 0xD7C6, 0xD7C7, 0xDBD4, 0xDBD5, 0xE043,
0xDBD3, 0xDFFC, 0xE041, 0xE040, 0xE042, 0xB8D1, 0xDFFE, 0xDFFD,
0xE044, 0xE449, 0xE447, 0xE448, 0xE7D3, 0xE7D1, 0xE7D2, 0xEB7D,
0xEE7C, 0xEE7D, 0xC2D2, 0xF2F5, 0xF4CD, 0xC4B2, 0xF64C, 0xF755,
0xC5A9, 0xF7FE, 0xF94C, 0xA8A5, 0xAD71, 0xAD72, 0xD0B0, 0xD0B1,
0xAD70, 0xB054, 0xB052, 0xB051, 0xB058, 0xB050, 0xB059, 0xD3DD,
0xB056, 0xB053, 0xB057, 0xB055, 0xB04F, 0xB35F, 0xB359, 0xD7CC,
0xB35E, 0xB360, 0xB35A, 0xB35B, 0xD7CA, 0xB358, 0xD7CB, 0xB35D,
0xD7C9, 0xB35C, 0xB644, 0xB646, 0xDBD8, 0xB645, 0xB5F9, 0xB5FD,
0xB8E4, 0xE049, 0xDBDA, 0xB5FE, 0xDBDD, 0xDBDE, 0xB643, 0xDBE0,
0xDBE2, 0xDBE3, 0xDBD7, 0xDBD6, 0xDBE4, 0xB642, 0xDBE1, 0xDBDF,
0xB640, 0xB5FB, 0xB647, 0xDBDB, 0xDBDC, 0xDBD9, 0xB641, 0xB5FC,
0xB5FA, 0xE048, 0xB8DF, 0xB8DA, 0xB8D5, 0xB8E5, 0xB8D6, 0xB8D2,
0xB8E1, 0xB8DE, 0xB8E0, 0xB8D7, 0xB8DC, 0xB8D3, 0xB8D4, 0xE050,
0xE04D, 0xE045, 0xE04A, 0xB8E2, 0xE051, 0xB8E3, 0xB8D9, 0xE047,
0xE04F, 0xE04B, 0xE04E, 0xE04C, 0xB8DD, 0xE046, 0xB8D8, 0xE44C,
0xBB78, 0xBB7B, 0xE44E, 0xBBA5, 0xE44D, 0xBB7D, 0xBDCF, 0xE44F,
0xBBA4, 0xE44B, 0xBBA6, 0xBB79, 0xB8DB, 0xBB7C, 0xBB7A, 0xBB7E,
0xBBA2, 0xBB77, 0xBBA7, 0xBBA3, 0xBBA1, 0xE44A, 0xBDD6, 0xBDD2,
0xBDD9, 0xE7D6, 0xBDDA, 0xE7E2, 0xE7DB, 0xBDCB, 0xE7E3, 0xE7DD,
0xBDD5, 0xE7DE, 0xBDD4, 0xE7E1, 0xBDCE, 0xE7DF, 0xE7D5, 0xBDCD,
0xEBAA, 0xBDD3, 0xBDD0, 0xBDD8, 0xE7D4, 0xE7D8, 0xBDCC, 0xE7D7,
0xE7D9, 0xE7DA, 0xBDD7, 0xE7DC, 0xE7E0, 0xE7E4, 0xBDDB, 0xBFD2,
0xEBA5, 0xEBAB, 0xEBA8, 0xEB7E, 0xEBAC, 0xEBA1, 0xEBA7, 0xBFCD,
0xBFD3, 0xEBAD, 0xBFCF, 0xBFD9, 0xBFD4, 0xEBAF, 0xEBA9, 0xBFD0,
0xEBA2, 0xBFDA, 0xEBA3, 0xEBA4, 0xBFDB, 0xBFD8, 0xBDD1, 0xBFCE,
0xEBB0, 0xBFDC, 0xBFD5, 0xEBAE, 0xBFD1, 0xBFD6, 0xBFD7, 0xC1C3,
0xEEA4, 0xEEAD, 0xEEAA, 0xEEAC, 0xC1C0, 0xEEA5, 0xEEAB, 0xC1BC,
0xEEA7, 0xC1C4, 0xEEA3, 0xEEA8, 0xEEAF, 0xEBA6, 0xEEA9, 0xEEA2,
0xC1BD, 0xEEA1, 0xC1BE, 0xEEB0, 0xC1BF, 0xEEAE, 0xC1C2, 0xEE7E,
0xC1C1, 0xEEA6, 0xF0DC, 0xF0EA, 0xF0E5, 0xF0E7, 0xF0DB, 0xC2D3,
0xF0DA, 0xC2D6, 0xC2D5, 0xF0E9, 0xF0E1, 0xF0DE, 0xF0E4, 0xF0DD,
0xF0DF, 0xF0E8, 0xF0E6, 0xC2D4, 0xF0ED, 0xF0EB, 0xF0E2, 0xF0EC,
0xF0E3, 0xF2F9, 0xC3CF, 0xF341, 0xF64F, 0xC3D6, 0xF0E0, 0xF2F7,
0xC3D2, 0xF2F8, 0xF2FD, 0xC3D4, 0xC3D5, 0xF2F6, 0xF340, 0xF342,
0xF2FA, 0xF2FC, 0xF2FE, 0xF2FB, 0xF343, 0xC3D1, 0xC3D7, 0xC3D3,
0xC3D0, 0xF4D0, 0xC4B7, 0xF4CE, 0xF4D2, 0xF4D3, 0xC4B5, 0xF4D4,
0xF4D1, 0xF4CF, 0xC4B8, 0xC4B4, 0xF4D5, 0xC4B6, 0xC4B3, 0xC4FE,
0xC540, 0xF64E, 0xF64D, 0xF650, 0xF651, 0xC541, 0xF756, 0xF75B,
0xC5AA, 0xF758, 0xF757, 0xF75A, 0xF759, 0xF843, 0xC5DC, 0xF842,
0xF840, 0xF841, 0xC5FE, 0xC5FD, 0xF8C1, 0xF8C2, 0xC640, 0xF94D,
0xF94E, 0xC667, 0xC66D, 0xF9A9, 0xF9C8, 0xA8A6, 0xD7CD, 0xD7CE,
0xE052, 0xE450, 0xE7E5, 0xC1C6, 0xC1C5, 0xF0EE, 0xF344, 0xF844,
0xA8A7, 0xD3DE, 0xB05A, 0xB361, 0xE054, 0xE053, 0xBDDC, 0xE7E6,
0xBDDD, 0xEEB1, 0xC2D7, 0xC676, 0xA8A8, 0xCDCB, 0xD3DF, 0xB362,
0xD7CF, 0xD7D0, 0xDBE5, 0xB648, 0xB8E6, 0xE056, 0xE055, 0xE057,
0xE451, 0xE452, 0xBBA8, 0xBFDD, 0xBDDE, 0xBFDE, 0xEEB5, 0xEEB2,
0xEEB4, 0xEEB3, 0xC1C7, 0xF0EF, 0xF346, 0xF345, 0xCBA4, 0xB05C,
0xB05B, 0xD3E0, 0xD7D1, 0xDBE7, 0xDBE6, 0xB649, 0xE059, 0xE05A,
0xE058, 0xB8E8, 0xB8E7, 0xBBAA, 0xBBA9, 0xE7E7, 0xEBB3, 0xEBB1,
0xEBB2, 0xBFDF, 0xEEB7, 0xEEB6, 0xF0F2, 0xF0F1, 0xF0F0, 0xF347,
0xF9AA, 0xA8A9, 0xAD73, 0xAD74, 0xB05D, 0xB05E, 0xD3E2, 0xD3E1,
0xD7D2, 0xB368, 0xB366, 0xB363, 0xB367, 0xB365, 0xB364, 0xB64A,
0xDBEA, 0xB8ED, 0xB64C, 0xB651, 0xDBEC, 0xB653, 0xB652, 0xB655,
0xDBEB, 0xDBE8, 0xB64F, 0xB64B, 0xB64D, 0xDBE9, 0xB654, 0xB650,
0xB64E, 0xB8EF, 0xB8EE, 0xB8EC, 0xB8F0, 0xB8EA, 0xB8EB, 0xB8E9,
0xE05B, 0xE454, 0xBBAC, 0xBBAD, 0xBBAB, 0xE453, 0xE455, 0xE7EA,
0xE7EC, 0xBDE7, 0xE7ED, 0xBDE0, 0xE7E9, 0xBDDF, 0xBDE9, 0xBDE5,
0xBDE6, 0xBDE2, 0xE7E8, 0xBDE1, 0xE7EE, 0xE7EB, 0xBDE8, 0xBDE3,
0xBDE4, 0xEBB5, 0xEBB7, 0xEBB6, 0xEBB8, 0xBFE0, 0xEBB4, 0xC1CB,
0xEEB8, 0xC1C8, 0xC1CC, 0xC1CA, 0xC1C9, 0xF0F3, 0xF0F6, 0xF0F5,
0xF0F4, 0xC2D8, 0xF348, 0xF349, 0xC3D8, 0xF34A, 0xC3D9, 0xC4BA,
0xC4B9, 0xF652, 0xC542, 0xF653, 0xF75C, 0xC5AB, 0xC5AC, 0xF845,
0xC642, 0xA8AA, 0xB36A, 0xB369, 0xE05C, 0xE05D, 0xBBAE, 0xEBB9,
0xBDEA, 0xEBBA, 0xEEB9, 0xA8AB, 0xD0B2, 0xAD76, 0xAD75, 0xD3E3,
0xB05F, 0xD3E4, 0xD7D5, 0xD7D4, 0xD7D3, 0xDBEE, 0xB658, 0xDBED,
0xB657, 0xDBEF, 0xB656, 0xE05F, 0xE062, 0xE060, 0xE061, 0xE065,
0xE05E, 0xE066, 0xE063, 0xE064, 0xBBB0, 0xE456, 0xBBAF, 0xE7F2,
0xE7F0, 0xBDEB, 0xE7EF, 0xE7F1, 0xBDEC, 0xEBBB, 0xEBBC, 0xC1CD,
0xF34C, 0xF34E, 0xF34B, 0xF34D, 0xF4D6, 0xF654, 0xF96F, 0xA8AC,
0xAD77, 0xD3E5, 0xD3E7, 0xD3E6, 0xD7D8, 0xB36C, 0xD7D6, 0xB36B,
0xD7D9, 0xD7DA, 0xD7D7, 0xDBFB, 0xB660, 0xDBF3, 0xDBF9, 0xB65B,
0xB65E, 0xDBF2, 0xB659, 0xDBF6, 0xE06C, 0xB65D, 0xDBF1, 0xDBF7,
0xDBF4, 0xDBFA, 0xDBF0, 0xDBF8, 0xB65C, 0xB65F, 0xDBF5, 0xB65A,
0xB8F2, 0xE068, 0xB8F1, 0xE06F, 0xE06E, 0xB8F8, 0xB8F9, 0xE070,
0xB8F3, 0xE06D, 0xB8F7, 0xE072, 0xE069, 0xE06B, 0xB8F4, 0xE067,
0xE06A, 0xE071, 0xB8F5, 0xE073, 0xB8F6, 0xBBB1, 0xE45B, 0xE461,
0xE459, 0xE462, 0xE458, 0xE45D, 0xE463, 0xE460, 0xE45F, 0xE45E,
0xE457, 0xE45C, 0xE45A, 0xBDF1, 0xBDEE, 0xE7FB, 0xE841, 0xE843,
0xE840, 0xE7F8, 0xE7FA, 0xE845, 0xE842, 0xE7FC, 0xE846, 0xE7F9,
0xE844, 0xBDEF, 0xBDF5, 0xBDF3, 0xE7F3, 0xBDF4, 0xBDF0, 0xE7F4,
0xE7F6, 0xE7F5, 0xE7FD, 0xE7FE, 0xBDF2, 0xBDED, 0xE7F7, 0xEBC6,
0xBFE2, 0xEBBD, 0xBFE3, 0xBFE6, 0xEBC2, 0xEBBF, 0xBFE5, 0xEBC3,
0xEBC4, 0xEBBE, 0xEBC7, 0xEBC0, 0xEBC5, 0xBFE4, 0xBFE1, 0xEBC1,
0xEEBF, 0xC1D0, 0xC1CE, 0xC1D1, 0xC1CF, 0xEEBE, 0xEEBB, 0xEEBA,
0xEEBD, 0xEEBC, 0xF145, 0xC2DE, 0xF0FB, 0xF0FA, 0xC2D9, 0xF141,
0xF140, 0xF0F7, 0xF143, 0xF0FC, 0xC2DD, 0xF0F9, 0xF142, 0xF0F8,
0xC2DA, 0xC2DC, 0xF0FD, 0xC2DB, 0xF0FE, 0xF144, 0xF352, 0xC3DE,
0xF34F, 0xF353, 0xC3DB, 0xF351, 0xC3E0, 0xC3DD, 0xF350, 0xC3DF,
0xF354, 0xC3DA, 0xC4BC, 0xC4BE, 0xF4D9, 0xC4BD, 0xF4D7, 0xC3DC,
0xF4D8, 0xC4BB, 0xC543, 0xC545, 0xF656, 0xC544, 0xF655, 0xF761,
0xC5AD, 0xF760, 0xC5AE, 0xF75E, 0xF75D, 0xF762, 0xF763, 0xF846,
0xF75F, 0xF8C6, 0xF8C3, 0xF8C4, 0xF8C5, 0xC65C, 0xF951, 0xF950,
0xF94F, 0xF970, 0xF9BE, 0xF9AB, 0xC66E, 0xA8AD, 0xB060, 0xB8FA,
0xBDF6, 0xEBC8, 0xC2DF, 0xF355, 0xF9AC, 0xA8AE, 0xAAEE, 0xAD79,
0xAD78, 0xB063, 0xD3E8, 0xB061, 0xD3E9, 0xB062, 0xD7DF, 0xD7DB,
0xB36D, 0xD7DE, 0xD7DD, 0xD7DC, 0xB36E, 0xD7E0, 0xD7E1, 0xDC43,
0xDC41, 0xDC45, 0xDC46, 0xDC4C, 0xDC48, 0xDC4A, 0xDC42, 0xDBFC,
0xDC49, 0xDC4B, 0xDC44, 0xDC47, 0xDBFD, 0xB662, 0xDC40, 0xDBFE,
0xB661, 0xB663, 0xB8FD, 0xE075, 0xE077, 0xE076, 0xE07B, 0xB8FB,
0xE078, 0xE074, 0xE079, 0xE07A, 0xB8FC, 0xB8FE, 0xE07C, 0xE467,
0xE466, 0xE464, 0xE465, 0xBBB3, 0xBBB5, 0xBBB2, 0xBBB4, 0xE84D,
0xE84E, 0xE849, 0xE84A, 0xBDF8, 0xBDFD, 0xBDF7, 0xBDFE, 0xBDF9,
0xE84B, 0xE84C, 0xE848, 0xBE40, 0xBDFB, 0xBDFA, 0xBDFC, 0xE847,
0xEBCA, 0xBFE8, 0xEBCC, 0xBFEA, 0xEBCF, 0xEBCB, 0xEBC9, 0xEBCE,
0xBFE9, 0xEBCD, 0xBFE7, 0xC1D3, 0xC1D6, 0xEEC1, 0xC1D4, 0xEEC0,
0xC1D2, 0xC1D5, 0xF146, 0xF147, 0xF148, 0xC2E0, 0xF149, 0xC2E1,
0xC3E2, 0xF358, 0xF359, 0xF357, 0xF356, 0xF35A, 0xC3E1, 0xF4DD,
0xF4DB, 0xF4DC, 0xF4DE, 0xF4DA, 0xF4DF, 0xF658, 0xF659, 0xF657,
0xC546, 0xF764, 0xC5AF, 0xF765, 0xF848, 0xF847, 0xA8AF, 0xB664,
0xB940, 0xBBB6, 0xBFEC, 0xBFEB, 0xC3E3, 0xC47C, 0xC547, 0xA8B0,
0xB064, 0xB941, 0xF35B, 0xCBA6, 0xA8B1, 0xA8B4, 0xA8B3, 0xA8B2,
0xCBA5, 0xCDCD, 0xCDCF, 0xAAEF, 0xAAF1, 0xCDCC, 0xCDCE, 0xAAF0,
0xCDD1, 0xCDD0, 0xCDD2, 0xD0B6, 0xD0B4, 0xAD7C, 0xD0B3, 0xADA3,
0xAD7E, 0xAD7B, 0xADA4, 0xAD7D, 0xADA2, 0xADA1, 0xD0B5, 0xAD7A,
0xB06A, 0xD3EB, 0xD3F1, 0xB067, 0xB06E, 0xB069, 0xD3EE, 0xD3F0,
0xB06C, 0xD3EA, 0xD3ED, 0xB068, 0xB065, 0xD3EC, 0xB06B, 0xD3EF,
0xB06D, 0xB066, 0xD7E3, 0xD7E6, 0xB370, 0xB37A, 0xB376, 0xD7E4,
0xB37E, 0xB377, 0xB37C, 0xB372, 0xB36F, 0xB371, 0xB37D, 0xD7E5,
0xB375, 0xB378, 0xB374, 0xB379, 0xD7E7, 0xB37B, 0xB373, 0xD7E2,
0xDC4D, 0xB665, 0xDC4F, 0xB667, 0xB669, 0xDC4E, 0xB666, 0xB66A,
0xB668, 0xB947, 0xE0A3, 0xB94F, 0xE07E, 0xB950, 0xB945, 0xE0A1,
0xB94A, 0xE0A2, 0xB943, 0xB942, 0xB94D, 0xB94C, 0xB94B, 0xB949,
0xB94E, 0xE07D, 0xB944, 0xB946, 0xB948, 0xBBB8, 0xBBBB, 0xBBBF,
0xBBB9, 0xBBBE, 0xBBBC, 0xBBB7, 0xBBBD, 0xBBBA, 0xE852, 0xBE43,
0xBE41, 0xE853, 0xBE44, 0xBE42, 0xE851, 0xE850, 0xBFF0, 0xE84F,
0xBFEE, 0xBFED, 0xEBD0, 0xBE45, 0xBFEF, 0xEBD1, 0xBFF2, 0xEBD2,
0xBFF1, 0xC1D8, 0xEEC3, 0xC1D7, 0xC1DC, 0xC1DA, 0xC1DB, 0xC2E3,
0xC1D9, 0xEEC2, 0xEBD3, 0xC2E2, 0xC2E4, 0xC3E4, 0xC3E5, 0xF4E0,
0xC5DE, 0xC5DD, 0xA8B6, 0xCA55, 0xB06F, 0xCA52, 0xCA53, 0xCA51,
0xCA54, 0xCBAA, 0xCBA7, 0xCBAC, 0xCBA8, 0xA8B7, 0xA8BA, 0xCBA9,
0xA8B9, 0xCBAB, 0xA8B8, 0xCDD5, 0xCDD7, 0xAAF4, 0xCDD3, 0xCDD6,
0xCDD4, 0xAAF2, 0xAAF5, 0xAAF3, 0xD0B8, 0xD0BC, 0xD0B9, 0xADA7,
0xADA8, 0xD0BB, 0xD0BD, 0xD0BF, 0xADA5, 0xD0BE, 0xADA6, 0xD7EE,
0xD0BA, 0xD3F2, 0xD3FB, 0xD3F9, 0xD3F4, 0xD3F5, 0xD3FA, 0xD3FC,
0xB071, 0xD3F7, 0xD3F3, 0xB070, 0xB072, 0xD3F6, 0xD3FD, 0xD3F8,
0xB3A1, 0xD7F1, 0xD7E9, 0xD7EF, 0xD7F0, 0xB3A2, 0xD7E8, 0xD7EA,
0xD0B7, 0xD7EC, 0xD7ED, 0xD7EB, 0xB66C, 0xDC56, 0xEBD4, 0xDC57,
0xDC54, 0xB3A3, 0xB66E, 0xDC53, 0xDC59, 0xDC58, 0xB66B, 0xDC5C,
0xDC52, 0xDC5B, 0xDC50, 0xDC5A, 0xDC55, 0xB66D, 0xE0AA, 0xE0A5,
0xE0AB, 0xE0A6, 0xE0A4, 0xE0A7, 0xB951, 0xE0A9, 0xE0A8, 0xB952,
0xBBC1, 0xBBC0, 0xE46E, 0xE471, 0xE469, 0xE46D, 0xBBC2, 0xE46C,
0xE46A, 0xE470, 0xE46B, 0xE468, 0xE46F, 0xE859, 0xBE48, 0xF14A,
0xE856, 0xE857, 0xE855, 0xDC51, 0xBE47, 0xE85A, 0xE854, 0xBE46,
0xBE49, 0xE858, 0xEBD5, 0xBFF3, 0xEBD6, 0xEBD7, 0xEEC4, 0xC1DD,
0xF14B, 0xF14C, 0xF14D, 0xF35D, 0xF35C, 0xF4E2, 0xF4E1, 0xF65B,
0xF65C, 0xF65A, 0xF766, 0xC5B0, 0xA8BB, 0xADAA, 0xADA9, 0xB075,
0xB074, 0xD440, 0xD441, 0xD3FE, 0xB073, 0xD7F5, 0xD7F6, 0xD7F2,
0xB3A4, 0xD7F3, 0xD7F4, 0xDC5F, 0xDC61, 0xDC5D, 0xDC60, 0xB66F,
0xDC5E, 0xB670, 0xDD73, 0xB955, 0xB954, 0xB953, 0xE0AC, 0xE0AD,
0xE473, 0xE475, 0xBBC6, 0xBBC3, 0xBBC5, 0xBBC4, 0xE474, 0xE472,
0xE861, 0xE85E, 0xE85F, 0xBE4D, 0xE860, 0xE85B, 0xE85C, 0xBE4A,
0xBE4B, 0xE85D, 0xBE4C, 0xEBDB, 0xEBDC, 0xEBD9, 0xEBDA, 0xBFF4,
0xEBD8, 0xEEC8, 0xEEC5, 0xEEC7, 0xC1E0, 0xEECB, 0xC1DF, 0xEEC9,
0xEECC, 0xEECA, 0xEEC6, 0xC1DE, 0xF14F, 0xF150, 0xF14E, 0xF152,
0xC2E5, 0xC2E6, 0xF35F, 0xC3E7, 0xF151, 0xF35E, 0xC3E6, 0xF4E5,
0xF4E6, 0xC4BF, 0xF4E4, 0xF4E3, 0xF65D, 0xC548, 0xF849, 0xF8C8,
0xF8C7, 0xC643, 0xC65D, 0xF8C9, 0xF971, 0xC66F, 0xA8BC, 0xAAF6,
0xB956, 0xC4C0, 0xA8BD, 0xADAB, 0xB3A5, 0xB671, 0xC2E7, 0xAAF7,
0xD0C1, 0xD0C0, 0xD442, 0xB078, 0xB076, 0xB07A, 0xD444, 0xB079,
0xB077, 0xD443, 0xB3A8, 0xD7FC, 0xB3A7, 0xB3A9, 0xD842, 0xB3AB,
0xD7FE, 0xD840, 0xD7F7, 0xB3AA, 0xD843, 0xD7F9, 0xD7FA, 0xD7F8,
0xB3A6, 0xD841, 0xD7FB, 0xD7FD, 0xDC6D, 0xDC6C, 0xDC6A, 0xDC62,
0xDC71, 0xDC65, 0xDC6F, 0xDC76, 0xDC6E, 0xB679, 0xB675, 0xDC63,
0xDC69, 0xB677, 0xDC68, 0xB678, 0xB67A, 0xDC6B, 0xB672, 0xB673,
0xDC77, 0xDC75, 0xDC74, 0xDC66, 0xDC72, 0xB676, 0xB674, 0xDC73,
0xDC64, 0xDC67, 0xDC70, 0xE4BA, 0xE0B7, 0xE0B0, 0xE0C3, 0xE0CC,
0xE0B3, 0xB961, 0xE0C0, 0xB957, 0xB959, 0xB965, 0xE0B1, 0xB95A,
0xB95C, 0xB966, 0xB95B, 0xB964, 0xE0B9, 0xE0AE, 0xB962, 0xE0B8,
0xB95E, 0xE0CA, 0xB963, 0xE0C8, 0xE0BC, 0xE0C6, 0xB960, 0xE0AF,
0xE0C9, 0xE0C4, 0xE0CB, 0xB958, 0xB967, 0xB95D, 0xE0B5, 0xE0BD,
0xE0C1, 0xE0C5, 0xB95F, 0xE0B4, 0xE0B2, 0xE0BE, 0xE0BB, 0xE0BA,
0xE0BF, 0xE0C2, 0xE0C7, 0xE478, 0xBBC7, 0xE4A4, 0xE47A, 0xBBCC,
0xBBD0, 0xE4AD, 0xE4B5, 0xE4A6, 0xBBC8, 0xE4AA, 0xE0B6, 0xBBC9,
0xE4B1, 0xE4B6, 0xE4AE, 0xE4B0, 0xE4B9, 0xE4B2, 0xE47E, 0xE4A9,
0xBBD1, 0xBBCD, 0xE47C, 0xE4AB, 0xBBCB, 0xE4A5, 0xBBCA, 0xE4B3,
0xE4A2, 0xE479, 0xBBCE, 0xE4B8, 0xE47B, 0xE4AF, 0xE4AC, 0xE4A7,
0xE477, 0xE476, 0xE4A1, 0xE4B4, 0xBBCF, 0xE4B7, 0xE47D, 0xE4A3,
0xBE52, 0xBE5A, 0xBE55, 0xE8A4, 0xE8A1, 0xE867, 0xBE50, 0xBE4F,
0xBE56, 0xE865, 0xBE54, 0xE871, 0xE863, 0xE864, 0xBE4E, 0xE8A3,
0xBE58, 0xE874, 0xE879, 0xE873, 0xEBEE, 0xE86F, 0xE877, 0xE875,
0xE868, 0xE862, 0xE87D, 0xBE57, 0xE87E, 0xE878, 0xE86D, 0xE86B,
0xE866, 0xE86E, 0xE87B, 0xE86A, 0xE87A, 0xE8A2, 0xBE53, 0xE876,
0xE87C, 0xE872, 0xE86C, 0xBE51, 0xE4A8, 0xE870, 0xBE59, 0xE869,
0xEBF4, 0xBFF7, 0xEBF3, 0xEBF0, 0xEC44, 0xBFFB, 0xEC41, 0xEBF8,
0xEC43, 0xEBE9, 0xEBF6, 0xBFFD, 0xEBE1, 0xEBDF, 0xEC42, 0xEC40,
0xEBFE, 0xEBED, 0xEBEC, 0xEBE2, 0xC040, 0xEBE8, 0xEBF2, 0xEBFD,
0xC043, 0xEC45, 0xC1E8, 0xC045, 0xBFFE, 0xEBE6, 0xEBEF, 0xEBDE,
0xEBE0, 0xBFF5, 0xC042, 0xBFFA, 0xEBE7, 0xEBF7, 0xEBF1, 0xC041,
0xEBDD, 0xC1E3, 0xEBF9, 0xEBFC, 0xBFFC, 0xEBEB, 0xC044, 0xBFF9,
0xBFF8, 0xEBF5, 0xEBFB, 0xBFF6, 0xEBE4, 0xEBFA, 0xEBE5, 0xEBEA,
0xEED2, 0xEED7, 0xC1E5, 0xC1E7, 0xEEDD, 0xC1E1, 0xEEEC, 0xEEE3,
0xEED8, 0xEED9, 0xEEE2, 0xC1EE, 0xEEE1, 0xEED1, 0xEEE0, 0xEED4,
0xEEED, 0xC1ED, 0xC1EB, 0xEED5, 0xEEE8, 0xEEDA, 0xEEE7, 0xEEE9,
0xEED0, 0xC1E6, 0xEEEA, 0xEEDE, 0xC1EA, 0xEEDB, 0xC1EC, 0xEEE4,
0xC1E4, 0xEED6, 0xEEE5, 0xEEDF, 0xEBE3, 0xEEE6, 0xEED3, 0xC1E9,
0xEEEB, 0xC1E2, 0xEECE, 0xF160, 0xF159, 0xC2E9, 0xF154, 0xF163,
0xF15B, 0xEEDC, 0xF165, 0xF155, 0xC2E8, 0xF15F, 0xC2EA, 0xC2F2,
0xC2F0, 0xF161, 0xC2F1, 0xF157, 0xF158, 0xF15D, 0xF162, 0xEECD,
0xC2EB, 0xF16A, 0xF167, 0xF16B, 0xF15E, 0xF15A, 0xF168, 0xF36A,
0xF15C, 0xC2EE, 0xC2ED, 0xEECF, 0xC2EF, 0xF164, 0xF166, 0xC2EC,
0xF169, 0xF153, 0xF156, 0xF373, 0xF363, 0xC3EB, 0xF371, 0xF361,
0xC3EC, 0xF36C, 0xF368, 0xC3F1, 0xF372, 0xF362, 0xF365, 0xC3E9,
0xF374, 0xF36D, 0xF370, 0xC3EF, 0xC3F4, 0xC3F2, 0xF369, 0xF364,
0xC3ED, 0xC3EE, 0xF360, 0xC3EA, 0xC3E8, 0xC3F0, 0xF36F, 0xC3F3,
0xF36B, 0xF375, 0xC3F5, 0xF367, 0xF36E, 0xF4F3, 0xF542, 0xF4F5,
0xF4FC, 0xF366, 0xF4FA, 0xF4E9, 0xF540, 0xC4C3, 0xF4ED, 0xF4FE,
0xF4F4, 0xC4C2, 0xF544, 0xF4F6, 0xF4FB, 0xF4FD, 0xF4E7, 0xF541,
0xF4F2, 0xF4F7, 0xF4EB, 0xF4EF, 0xF543, 0xF4F9, 0xF4E8, 0xF4EC,
0xF4EE, 0xF4F8, 0xC4C1, 0xF4F1, 0xF4EA, 0xF4F0, 0xF661, 0xF666,
0xC54F, 0xF668, 0xC549, 0xF664, 0xF66A, 0xC54E, 0xC54A, 0xC54B,
0xF660, 0xF667, 0xC54D, 0xF665, 0xC54C, 0xF65F, 0xF663, 0xF662,
0xF65E, 0xF669, 0xC5B1, 0xF76D, 0xF770, 0xF76C, 0xF76E, 0xF76F,
0xF769, 0xF76A, 0xF767, 0xF76B, 0xF768, 0xC5B2, 0xC5B3, 0xF84B,
0xF84D, 0xF84C, 0xF84E, 0xC5E0, 0xF84A, 0xC5DF, 0xC5E1, 0xF8CB,
0xF8CC, 0xC644, 0xF8CA, 0xF953, 0xF952, 0xF954, 0xC65F, 0xF955,
0xC65E, 0xF956, 0xF972, 0xF975, 0xF974, 0xC668, 0xF973, 0xC672,
0xC670, 0xC671, 0xC677, 0xF9C0, 0xF9C1, 0xF9BF, 0xF9C9, 0xAAF8,
0xD844, 0xDC78, 0xE8A5, 0xF376, 0xAAF9, 0xADAC, 0xB07B, 0xD845,
0xD846, 0xB3AC, 0xB67D, 0xDC7A, 0xDC79, 0xB6A3, 0xB67C, 0xDC7B,
0xB67E, 0xB6A2, 0xB6A1, 0xB67B, 0xB968, 0xE0D0, 0xE0CE, 0xE0CF,
0xE0CD, 0xBBD2, 0xBBD5, 0xBBD7, 0xBBD6, 0xBBD3, 0xBBD4, 0xE8A7,
0xE8A6, 0xBE5B, 0xE8A8, 0xE8A9, 0xBE5C, 0xEC4D, 0xEC4B, 0xEEF3,
0xEC49, 0xEC4A, 0xC046, 0xEC46, 0xEC4E, 0xEC48, 0xEC4C, 0xEEEF,
0xEEF1, 0xEEF2, 0xC1F3, 0xEEEE, 0xC1F2, 0xEEF0, 0xC1EF, 0xC1F0,
0xC1F1, 0xEC47, 0xC2F5, 0xF16E, 0xF16C, 0xF16D, 0xC2F3, 0xC2F6,
0xC2F4, 0xF377, 0xF378, 0xC3F6, 0xF545, 0xF547, 0xF546, 0xC4C4,
0xC550, 0xF66D, 0xF66C, 0xF66B, 0xAAFA, 0xC9AA, 0xCA58, 0xA6E9,
0xCA56, 0xCA59, 0xCA57, 0xCBAE, 0xA8C1, 0xA8C2, 0xCBB0, 0xA8BF,
0xCBAF, 0xCBAD, 0xA8C0, 0xA8BE, 0xCDD8, 0xCDDB, 0xAAFD, 0xCDDA,
0xCDD9, 0xAAFC, 0xAAFB, 0xAB40, 0xCDDC, 0xAAFE, 0xD0C6, 0xADAE,
0xADAF, 0xADB0, 0xD0C7, 0xD0C3, 0xADAD, 0xD0C4, 0xD0C5, 0xD0C2,
0xB0A4, 0xB0A1, 0xD445, 0xB0A2, 0xB0A5, 0xD446, 0xB07E, 0xB07C,
0xB07D, 0xB0A3, 0xB3AD, 0xD849, 0xB3B5, 0xD848, 0xD84B, 0xB3B1,
0xD84A, 0xB6AB, 0xB3AF, 0xB3B2, 0xB3AE, 0xB3B3, 0xB3B4, 0xB3B0,
0xD847, 0xB6A7, 0xDC7D, 0xDCA3, 0xDCA2, 0xB6AC, 0xB6A8, 0xB6A9,
0xDC7C, 0xDC7E, 0xDCA1, 0xB6A4, 0xB6A6, 0xB6AA, 0xB6A5, 0xE0D3,
0xE0D1, 0xE0D2, 0xB96A, 0xB96B, 0xE0D4, 0xB969, 0xBBD8, 0xBBDA,
0xBBD9, 0xE4BB, 0xE4BC, 0xE8AB, 0xE8AA, 0xC047, 0xC048, 0xEC4F,
0xC049, 0xEEF6, 0xEEF4, 0xEEF5, 0xC1F4, 0xF16F, 0xC3F7, 0xC1F5,
0xAB41, 0xB0A6, 0xD447, 0xD84C, 0xB3B6, 0xB6AD, 0xDCA4, 0xDCA6,
0xB6AF, 0xB6AE, 0xB6B0, 0xB6B1, 0xDCA5, 0xB96E, 0xB96F, 0xB96D,
0xBBDB, 0xB96C, 0xE0D5, 0xBBDC, 0xE8AC, 0xEC50, 0xC04A, 0xC1F6,
0xF170, 0xF174, 0xC2F9, 0xF171, 0xC2FA, 0xC2F8, 0xF175, 0xC2FB,
0xF173, 0xF379, 0xC2F7, 0xC3F8, 0xF8CD, 0xAB42, 0xB3B8, 0xB3B7,
0xB6B2, 0xDCA8, 0xDCA7, 0xB6B3, 0xE0D9, 0xB973, 0xB970, 0xE0D8,
0xB972, 0xE0D6, 0xB971, 0xE0D7, 0xE4BD, 0xBBDD, 0xE8AF, 0xBE5D,
0xE8AD, 0xBE5E, 0xBE5F, 0xE8AE, 0xBE60, 0xEC51, 0xC04E, 0xC04B,
0xC050, 0xEC53, 0xC04C, 0xEC52, 0xC04F, 0xC04D, 0xEEF9, 0xEEFB,
0xC1F7, 0xEEFA, 0xC1F8, 0xEEF8, 0xEEF7, 0xF177, 0xF176, 0xC2FC,
0xF178, 0xF37E, 0xC3FA, 0xF37D, 0xF37A, 0xC3F9, 0xF37B, 0xF37C,
0xF548, 0xF549, 0xC4C5, 0xC553, 0xF66E, 0xC551, 0xC552, 0xF66F,
0xC5B4, 0xC5B5, 0xF771, 0xC645, 0xF8CF, 0xC647, 0xF8CE, 0xF8D0,
0xC646, 0xF957, 0xF9AD, 0xAB43, 0xB974, 0xE4BE, 0xE8B0, 0xC051,
0xC052, 0xAB44, 0xBE61, 0xC3FB, 0xADB1, 0xC053, 0xC5E2, 0xADB2,
0xD84D, 0xDCA9, 0xDCAB, 0xDCAA, 0xE0DD, 0xE0DA, 0xB975, 0xB976,
0xE0DB, 0xE0DC, 0xE4C0, 0xE4C5, 0xBBDE, 0xE4BF, 0xE4C1, 0xE4C8,
0xE4C3, 0xE4C7, 0xE4C4, 0xE4C2, 0xE4C6, 0xBBDF, 0xE8B3, 0xE8B1,
0xBE63, 0xBE62, 0xE8B2, 0xBE64, 0xEC56, 0xEC55, 0xC054, 0xEC54,
0xEEFC, 0xEEFE, 0xEF41, 0xEF40, 0xC1F9, 0xEEFD, 0xF1A1, 0xC2FD,
0xF17D, 0xF1A2, 0xC2FE, 0xF17B, 0xF17E, 0xF17C, 0xF179, 0xC340,
0xF17A, 0xF3A1, 0xF3A3, 0xF3A2, 0xF54A, 0xF54B, 0xF670, 0xC5B7,
0xC5B6, 0xF84F, 0xF850, 0xC648, 0xF8D1, 0xC669, 0xADB3, 0xB6B4,
0xE4CA, 0xE4C9, 0xE8B5, 0xE8B4, 0xC1FA, 0xEF43, 0xEF42, 0xF1A5,
0xF1A3, 0xF1A6, 0xF1A4, 0xC3FC, 0xF3A4, 0xF3A5, 0xF3A6, 0xF671,
0xF772, 0xF8D2, 0xADB4, 0xEC57, 0xEF44, 0xADB5, 0xBBE0, 0xEC58,
0xC341, 0xF1A7, 0xC3FD, 0xF54C, 0xF54D, 0xC554, 0xF851, 0xADB6,
0xB3BB, 0xB3BC, 0xD84E, 0xB6B5, 0xB6B6, 0xDCAC, 0xB6B7, 0xB97A,
0xB97C, 0xE0DF, 0xE0E0, 0xE0DE, 0xB977, 0xB978, 0xB97B, 0xB979,
0xE4CB, 0xBBE1, 0xBBE2, 0xE8BC, 0xBE67, 0xE8B7, 0xE8B6, 0xE8BB,
0xBE65, 0xC05B, 0xE8B8, 0xE8BD, 0xE8BA, 0xE8B9, 0xBE66, 0xC059,
0xEC5A, 0xC055, 0xEC5B, 0xEC59, 0xC058, 0xC056, 0xC05A, 0xC057,
0xEF45, 0xEF4A, 0xEF46, 0xEF49, 0xC1FB, 0xEDD4, 0xEF48, 0xEF47,
0xC344, 0xC342, 0xC345, 0xC343, 0xF1A8, 0xF1A9, 0xF1AA, 0xC346,
0xF3AA, 0xC440, 0xF3A8, 0xC441, 0xF3A7, 0xF3A9, 0xC3FE, 0xF551,
0xF54E, 0xF54F, 0xF550, 0xF672, 0xC556, 0xC555, 0xF774, 0xF773,
0xC5B8, 0xC5E3, 0xC649, 0xC660, 0xF958, 0xF9AE, 0xF9AF, 0xADB7,
0xDCAD, 0xE0E1, 0xE4CC, 0xE4CD, 0xBBE3, 0xBBE4, 0xE8BE, 0xBE68,
0xC1FC, 0xF1AB, 0xC347, 0xF3AD, 0xC442, 0xF3AC, 0xF3AE, 0xF3AB,
0xF675, 0xF552, 0xF553, 0xC4C6, 0xF674, 0xF673, 0xF775, 0xF9B0,
0xADB8, 0xADB9, 0xB0A7, 0xD448, 0xD84F, 0xB6B8, 0xB6BB, 0xB6B9,
0xDCAE, 0xB6BD, 0xB6BA, 0xB6BC, 0xB97E, 0xE0E2, 0xE0E3, 0xE8C0,
0xB97D, 0xB9A1, 0xB9A2, 0xE4CF, 0xE4CE, 0xBBE5, 0xBBE6, 0xE4D0,
0xE8BF, 0xBBE8, 0xBE69, 0xBBE7, 0xC05C, 0xE8C1, 0xBE6B, 0xBE6A,
0xE8C2, 0xE8C5, 0xE8C3, 0xE8C4, 0xBE6C, 0xC061, 0xC05F, 0xC05E,
0xEC5D, 0xC060, 0xEC5C, 0xEF4B, 0xEC5E, 0xC05D, 0xEC5F, 0xEF4E,
0xEF4C, 0xEF4D, 0xEF52, 0xC34B, 0xEF51, 0xEF54, 0xEF53, 0xEF50,
0xEF4F, 0xC1FD, 0xF1AE, 0xF1AD, 0xC34A, 0xC348, 0xC349, 0xF1AC,
0xF3B1, 0xC443, 0xF3B0, 0xF3AF, 0xC444, 0xF558, 0xF557, 0xF555,
0xF554, 0xC4C8, 0xC4C7, 0xF559, 0xF776, 0xC5B9, 0xF677, 0xC557,
0xF676, 0xF556, 0xF777, 0xC5E4, 0xC661, 0xF959, 0xF9B1, 0xADBA,
0xD850, 0xEF55, 0xADBB, 0xE4D2, 0xE4D1, 0xEC60, 0xEF57, 0xEF56,
0xC34C, 0xF3B2, 0xF3B3, 0xC4C9, 0xF9B2, 0xB0A8, 0xB6BF, 0xB6BE,
0xE0E4, 0xE0E6, 0xB9A4, 0xE0E5, 0xB9A3, 0xB9A5, 0xE0E7, 0xE4D4,
0xE4D6, 0xE4D5, 0xE4D8, 0xBBE9, 0xE4D7, 0xE4D3, 0xE4D9, 0xE8CC,
0xE8CF, 0xE8D1, 0xE8C7, 0xE8CB, 0xE8C8, 0xBE6E, 0xBE71, 0xBE73,
0xE8C9, 0xE8CA, 0xBE72, 0xE8CD, 0xE8D0, 0xE8CE, 0xBE74, 0xBE70,
0xE8C6, 0xBE6D, 0xBE6F, 0xC063, 0xEC66, 0xEC64, 0xEC63, 0xEC69,
0xEC68, 0xEC67, 0xEC62, 0xC062, 0xEC61, 0xEC65, 0xC064, 0xEF5A,
0xEF5E, 0xEF5B, 0xEF5D, 0xEF5C, 0xEF59, 0xEF5F, 0xEF62, 0xEF60,
0xEF61, 0xC240, 0xC1FE, 0xEF58, 0xEF63, 0xF1B3, 0xF1B6, 0xF1B8,
0xF1B7, 0xF1B1, 0xF1B5, 0xF1B0, 0xF1B2, 0xC34D, 0xF1AF, 0xF1B4,
0xF3C0, 0xF3B5, 0xC445, 0xC446, 0xF3B4, 0xF3B9, 0xF3BF, 0xF3B7,
0xF3BE, 0xF3BB, 0xF3BA, 0xF3BD, 0xF3B8, 0xF3B6, 0xF3BC, 0xF560,
0xF55E, 0xC4CA, 0xF55D, 0xF563, 0xF561, 0xC4CB, 0xF55C, 0xF55A,
0xF55B, 0xC4CD, 0xF55F, 0xC4CC, 0xF562, 0xF678, 0xF67E, 0xF679,
0xC55B, 0xF6A1, 0xC55A, 0xF67D, 0xF67C, 0xC559, 0xF67B, 0xC558,
0xF67A, 0xF77D, 0xF7A1, 0xF77E, 0xF77B, 0xC5BB, 0xF778, 0xF77C,
0xF7A3, 0xF7A2, 0xF779, 0xF77A, 0xC5BA, 0xF852, 0xC5E7, 0xF853,
0xC5E5, 0xC5E6, 0xF8D3, 0xC64A, 0xF976, 0xC66A, 0xF9B3, 0xC66B,
0xF9B4, 0xF9B5, 0xF9C3, 0xF9C2, 0xC67A, 0xF9CD, 0xB0A9, 0xE0E9,
0xE0E8, 0xBBEA, 0xBBEB, 0xE4DA, 0xE8D2, 0xEC6C, 0xBE75, 0xC065,
0xEC6A, 0xEC6D, 0xC066, 0xEF64, 0xEC6B, 0xF1B9, 0xC34E, 0xF3C1,
0xF566, 0xF564, 0xF565, 0xF6A2, 0xC55C, 0xF7A4, 0xC5EA, 0xC5BC,
0xC5E8, 0xC5E9, 0xF8D4, 0xC662, 0xB0AA, 0xF1BA, 0xD449, 0xB9A6,
0xE4DB, 0xBBEC, 0xE4DC, 0xE8D4, 0xE8D3, 0xC068, 0xBE76, 0xBE77,
0xE8D7, 0xE8D6, 0xE8D5, 0xEC6E, 0xEC71, 0xEC70, 0xEC6F, 0xC067,
0xEF68, 0xEF66, 0xEF65, 0xEF67, 0xC34F, 0xF1BC, 0xF1BD, 0xC350,
0xF1BB, 0xF3C3, 0xF3C2, 0xF3C5, 0xC447, 0xF3C4, 0xF567, 0xF569,
0xF568, 0xF6A3, 0xF6A6, 0xF6A4, 0xF6A5, 0xF7A5, 0xC5BD, 0xF854,
0xF855, 0xF856, 0xC64B, 0xC663, 0xF9B6, 0xB0AB, 0xBE78, 0xC069,
0xF1BE, 0xF7A6, 0xF9C4, 0xD44A, 0xC67B, 0xB0AC, 0xEC72, 0xF1BF,
0xF3C6, 0xF6A7, 0xF7A7, 0xB0AD, 0xE4DD, 0xE4DE, 0xBBED, 0xBBEE,
0xE8D9, 0xBE7A, 0xBE79, 0xE8D8, 0xEF69, 0xF1C0, 0xF1C2, 0xF1C1,
0xC353, 0xC352, 0xC351, 0xC55E, 0xF6A8, 0xC55D, 0xF7A9, 0xF7A8,
0xC64C, 0xF8D5, 0xB3BD, 0xE0EA, 0xE4E1, 0xE4DF, 0xE4E0, 0xE8E2,
0xE8DD, 0xE8DA, 0xE8E1, 0xE8E3, 0xBE7C, 0xE8E0, 0xE8DC, 0xE8DB,
0xE8DF, 0xE8DE, 0xBE7B, 0xEC7D, 0xEC78, 0xEC76, 0xECA1, 0xEC77,
0xEC73, 0xEC79, 0xEC74, 0xEF72, 0xEC75, 0xECA2, 0xEC7C, 0xC06A,
0xEC7B, 0xEC7A, 0xEC7E, 0xEF6A, 0xEF6D, 0xEF6C, 0xEF74, 0xEF6F,
0xEF73, 0xEF71, 0xEF70, 0xEF6E, 0xEF6B, 0xC243, 0xC242, 0xC244,
0xC241, 0xEF75, 0xF1C8, 0xF1CB, 0xF1C9, 0xF1CD, 0xF1CE, 0xF1C6,
0xC358, 0xF1C7, 0xF1C5, 0xF1CC, 0xF1C4, 0xF1C3, 0xC357, 0xC355,
0xC354, 0xF1CA, 0xF3CF, 0xF3D5, 0xC44A, 0xF3D0, 0xF3D3, 0xF3D7,
0xC44B, 0xF3D2, 0xF3CA, 0xF3C9, 0xF3D6, 0xF3CD, 0xF3CB, 0xF3D4,
0xF3CC, 0xC449, 0xC448, 0xF3C7, 0xF3C8, 0xF3D1, 0xF3CE, 0xF56C,
0xF56F, 0xC356, 0xF56D, 0xF573, 0xF571, 0xF56B, 0xF576, 0xF56A,
0xC4CF, 0xF572, 0xF56E, 0xC4CE, 0xF575, 0xF574, 0xF6AB, 0xF6AA,
0xF6B1, 0xF6AD, 0xF6B0, 0xC560, 0xF6AE, 0xF6AF, 0xF6A9, 0xF6AC,
0xC55F, 0xC5BF, 0xF7B4, 0xF7AF, 0xF7B3, 0xF7B6, 0xF7B2, 0xF7AE,
0xC5C1, 0xF7B1, 0xF7B5, 0xC5C0, 0xF7AC, 0xF570, 0xF7B0, 0xF7AD,
0xF7AA, 0xF7AB, 0xC5BE, 0xF85A, 0xF85C, 0xF85F, 0xF85B, 0xF860,
0xF859, 0xF857, 0xC5EB, 0xF85D, 0xC5ED, 0xC5EC, 0xF858, 0xF85E,
0xF8DA, 0xC64D, 0xF8DB, 0xF8D9, 0xF8D6, 0xF8D8, 0xF8D7, 0xF95A,
0xF95C, 0xF95B, 0xF979, 0xF978, 0xF977, 0xF97A, 0xC673, 0xC674,
0xF9CA, 0xF9CE, 0xB3BE, 0xDCAF, 0xE0ED, 0xB9A7, 0xE0EB, 0xE0EC,
0xE4E2, 0xE4E3, 0xBBF1, 0xBBEF, 0xE4E4, 0xBBF0, 0xE8E8, 0xE8EB,
0xE8E5, 0xE8EC, 0xE8E4, 0xE8E6, 0xE8E7, 0xE8EA, 0xBEA1, 0xE8EF,
0xE8EE, 0xBE7D, 0xE8E9, 0xE8ED, 0xBE7E, 0xECAC, 0xC06F, 0xECA7,
0xC06B, 0xECA4, 0xECAA, 0xECAD, 0xC070, 0xECA9, 0xECA6, 0xECAE,
0xECA5, 0xECAB, 0xC06C, 0xECA3, 0xC06D, 0xC06E, 0xECA8, 0xEFA9,
0xEF7A, 0xEF7B, 0xEF7E, 0xEF7C, 0xEF76, 0xEF79, 0xEFA5, 0xEF7D,
0xC245, 0xEFA7, 0xEFA4, 0xC246, 0xEFA6, 0xEF77, 0xEFA2, 0xEFA3,
0xEFA1, 0xF1D2, 0xF1D4, 0xF1D7, 0xF1D1, 0xC359, 0xF1D9, 0xF1D0,
0xF1DA, 0xF1D6, 0xF1D8, 0xF1DC, 0xF1D5, 0xF1DD, 0xF1D3, 0xF1CF,
0xC35A, 0xF1DB, 0xC35B, 0xC44D, 0xEF78, 0xF3F1, 0xF3E8, 0xC44F,
0xF3E4, 0xC450, 0xF3ED, 0xF3E7, 0xF3DD, 0xC44E, 0xF3EA, 0xF3E5,
0xF3E6, 0xF3D8, 0xF3DF, 0xF3EE, 0xF3EB, 0xF3E3, 0xF3EF, 0xF3DE,
0xF3D9, 0xF3EC, 0xF3DB, 0xF3E9, 0xF3E0, 0xF3F0, 0xF3DC, 0xC44C,
0xF3DA, 0xF3E1, 0xF3E2, 0xF57D, 0xF57B, 0xF5A2, 0xF5AE, 0xF5A5,
0xF57C, 0xF578, 0xF5A7, 0xF57E, 0xF5A3, 0xF57A, 0xF5AA, 0xF577,
0xF5A1, 0xF5A6, 0xF5A8, 0xF5AB, 0xF579, 0xF5AF, 0xF5B0, 0xF5A9,
0xF5AD, 0xF5A4, 0xF6C1, 0xF6C4, 0xC561, 0xF6C3, 0xF6C8, 0xF6C6,
0xC562, 0xF6BD, 0xF6B3, 0xF6B2, 0xC564, 0xF6BF, 0xF6C0, 0xF6BC,
0xF6B4, 0xF6B9, 0xF5AC, 0xF6B5, 0xC563, 0xF6BB, 0xF6BA, 0xF6B6,
0xF6C2, 0xF6B7, 0xF7BB, 0xF6C5, 0xF6C7, 0xF6BE, 0xF6B8, 0xF7BC,
0xF7BE, 0xF7B8, 0xC5C2, 0xF7C5, 0xF7C3, 0xC5C3, 0xF7C2, 0xF7C1,
0xF7BA, 0xF7B7, 0xF7BD, 0xF7C6, 0xF7B9, 0xF7BF, 0xF869, 0xF86E,
0xF864, 0xF867, 0xC5EE, 0xF86B, 0xF872, 0xF7C0, 0xF865, 0xF86F,
0xF873, 0xF86A, 0xF863, 0xF86D, 0xF86C, 0xF871, 0xF870, 0xF7C4,
0xF868, 0xF862, 0xF866, 0xC64E, 0xC64F, 0xF861, 0xF8E6, 0xF8DD,
0xF8E5, 0xF8E2, 0xF8E3, 0xF8DC, 0xF8DF, 0xF8E7, 0xF8E1, 0xF8E0,
0xF8DE, 0xF8E4, 0xF95D, 0xF95E, 0xF960, 0xF95F, 0xF962, 0xF961,
0xF97C, 0xF97B, 0xF9B7, 0xF9B8, 0xF9C5, 0xC678, 0xC67C, 0xF9CF,
0xC67D, 0xB3BF, 0xC4D0, 0xF6C9, 0xC650, 0xC651, 0xB3C0, 0xE0EE,
0xB9A8, 0xE8F0, 0xECB0, 0xECB1, 0xECAF, 0xEFAB, 0xEFAA, 0xC247,
0xF1DF, 0xEFAC, 0xF1DE, 0xF3F3, 0xC451, 0xC453, 0xF3F2, 0xC452,
0xF5B1, 0xF5B3, 0xF5B2, 0xF6CA, 0xC565, 0xC5EF, 0xF8E8, 0xF963,
0xF9D2, 0xB3C1, 0xE4E5, 0xBEA2, 0xECB3, 0xECB2, 0xEFAD, 0xC454,
0xC4D1, 0xF7C7, 0xF9CB, 0xB3C2, 0xBBF2, 0xBEA3, 0xF3F4, 0xF874,
0xB6C0, 0xEFAE, 0xC664, 0xB6C1, 0xBEA4, 0xC248, 0xF875, 0xB6C2,
0xE8F1, 0xC072, 0xECB4, 0xECB5, 0xC071, 0xEFAF, 0xC24C, 0xC24A,
0xC24B, 0xC249, 0xF1E0, 0xC35C, 0xF5B5, 0xF5B4, 0xF5B7, 0xF5B6,
0xC4D2, 0xF6CB, 0xF6CD, 0xF6CC, 0xC566, 0xF7C8, 0xF876, 0xF877,
0xC5F0, 0xF964, 0xF97D, 0xC675, 0xDCB0, 0xECB6, 0xEFB0, 0xF3F5,
0xE0EF, 0xEFB1, 0xF1E2, 0xF1E1, 0xF878, 0xC652, 0xF965, 0xF97E,
0xB9A9, 0xE8F2, 0xE8F3, 0xECB7, 0xB9AA, 0xC35D, 0xF1E3, 0xF6CF,
0xC567, 0xF6D0, 0xF6CE, 0xF879, 0xF8E9, 0xB9AB, 0xEFB4, 0xEFB3,
0xEFB2, 0xF1E4, 0xF1E8, 0xF1E7, 0xF1E6, 0xF1E5, 0xC35E, 0xF3F6,
0xF5B9, 0xC4D3, 0xF5B8, 0xF6D1, 0xF7CB, 0xF7CA, 0xC5C4, 0xF7C9,
0xF87C, 0xF87B, 0xF87A, 0xBBF3, 0xECB8, 0xC24D, 0xF3F7, 0xF3F8,
0xF7CC, 0xF87D, 0xF8EA, 0xF966, 0xF9B9, 0xF9D4, 0xBBF4, 0xC24E,
0xF1E9, 0xF3F9, 0xF6D2, 0xF87E, 0xBEA6, 0xEFB5, 0xF1EA, 0xF3FA,
0xF3FB, 0xF3FC, 0xF5BE, 0xF5BA, 0xC568, 0xF5BD, 0xF5BC, 0xC4D4,
0xF5BB, 0xC4D6, 0xC4D5, 0xF6D4, 0xF6D3, 0xC569, 0xC56A, 0xC5C6,
0xF7CD, 0xC5C5, 0xF8A3, 0xF8A4, 0xF8A2, 0xF8A1, 0xC654, 0xF8EB,
0xF8EC, 0xF8ED, 0xC653, 0xF967, 0xF96A, 0xF969, 0xF968, 0xF9D3,
0xC073, 0xC365, 0xF5BF, 0xF6D5, 0xC5C7, 0xF7CE, 0xF9D5, 0xC074,
0xEFB6, 0xF7CF, 0xF9A1, 0xC94A, 0xDDFC, 0xA14A, 0xA157, 0xA159,
0xA15B, 0xA15F, 0xA160, 0xA163, 0xA164, 0xA167, 0xA168, 0xA16B,
0xA16C, 0xA16F, 0xA170, 0xA173, 0xA174, 0xA177, 0xA178, 0xA17B,
0xA17C, 0xA1C6, 0xA1C7, 0xA1CA, 0xA1CB, 0xA1C8, 0xA1C9, 0xA15C,
0xA14D, 0xA14F, 0xA151, 0xA152, 0xA153, 0xA154, 0xA17D, 0xA17E,
0xA1A1, 0xA1A2, 0xA1A3, 0xA1A4, 0xA1CC, 0xA1CD, 0xA1CE, 0xA1DE,
0xA1DF, 0xA1E0, 0xA1E1, 0xA1E2, 0xA24C, 0xA24D, 0xA24E, 0xA149,
0xA1AD, 0xA243, 0xA248, 0xA1AE, 0xA15D, 0xA15E, 0xA1AF, 0xA1CF,
0xA141, 0xA1D0, 0xA144, 0xA241, 0xA2AF, 0xA2B0, 0xA2B1, 0xA2B2,
0xA2B3, 0xA2B4, 0xA2B5, 0xA2B6, 0xA2B7, 0xA2B8, 0xA147, 0xA146,
0xA1D5, 0xA1D7, 0xA1D6, 0xA148, 0xA249, 0xA2CF, 0xA2D0, 0xA2D1,
0xA2D2, 0xA2D3, 0xA2D4, 0xA2D5, 0xA2D6, 0xA2D7, 0xA2D8, 0xA2D9,
0xA2DA, 0xA2DB, 0xA2DC, 0xA2DD, 0xA2DE, 0xA2DF, 0xA2E0, 0xA2E1,
0xA2E2, 0xA2E3, 0xA2E4, 0xA2E5, 0xA2E6, 0xA2E7, 0xA2E8, 0xA242,
0xA1C4, 0xA2E9, 0xA2EA, 0xA2EB, 0xA2EC, 0xA2ED, 0xA2EE, 0xA2EF,
0xA2F0, 0xA2F1, 0xA2F2, 0xA2F3, 0xA2F4, 0xA2F5, 0xA2F6, 0xA2F7,
0xA2F8, 0xA2F9, 0xA2FA, 0xA2FB, 0xA2FC, 0xA2FD, 0xA2FE, 0xA340,
0xA341, 0xA342, 0xA343, 0xA161, 0xA155, 0xA162, 0xA14E,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Unicode values in multibyte order */
static const zueci_u16 zueci_big5_mb_u[13775] = {
0x3000, 0xFF0C, 0x3001, 0x3002, 0xFF0E, 0x2022, 0xFF1B, 0xFF1A,
0xFF1F, 0xFF01, 0xFE30, 0x2026, 0x2025, 0xFE50, 0xFF64, 0xFE52,
0x00B7, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFF5C, 0x2013, 0xFE31,
0x2014, 0xFE33, 0x0000, 0xFE34, 0xFE4F, 0xFF08, 0xFF09, 0xFE35,
0xFE36, 0xFF5B, 0xFF5D, 0xFE37, 0xFE38, 0x3014, 0x3015, 0xFE39,
0xFE3A, 0x3010, 0x3011, 0xFE3B, 0xFE3C, 0x300A, 0x300B, 0xFE3D,
0xFE3E, 0x3008, 0x3009, 0xFE3F, 0xFE40, 0x300C, 0x300D, 0xFE41,
0xFE42, 0x300E, 0x300F, 0xFE43, 0xFE44, 0xFE59, 0xFE5A, 0xFE5B,
0xFE5C, 0xFE5D, 0xFE5E, 0x2018, 0x2019, 0x201C, 0x201D, 0x301D,
0x301E, 0x2035, 0x2032, 0xFF03, 0xFF06, 0xFF0A, 0x203B, 0x00A7,
0x3003, 0x25CB, 0x25CF, 0x25B3, 0x25B2, 0x25CE, 0x2606, 0x2605,
0x25C7, 0x25C6, 0x25A1, 0x25A0, 0x25BD, 0x25BC, 0x32A3, 0x2105,
0x203E, 0x0000, 0xFF3F, 0x0000, 0xFE49, 0xFE4A, 0xFE4D, 0xFE4E,
0xFE4B, 0xFE4C, 0xFE5F, 0xFE60, 0xFE61, 0xFF0B, 0xFF0D, 0x00D7,
0x00F7, 0x00B1, 0x221A, 0xFF1C, 0xFF1E, 0xFF1D, 0x2266, 0x2267,
0x2260, 0x221E, 0x2252, 0x2261, 0xFE62, 0xFE63, 0xFE64, 0xFE65,
0xFE66, 0x223C, 0x2229, 0x222A, 0x22A5, 0x2220, 0x221F, 0x22BF,
0x33D2, 0x33D1, 0x222B, 0x222E, 0x2235, 0x2234, 0x2640, 0x2642,
0x2641, 0x2609, 0x2191, 0x2193, 0x2190, 0x2192, 0x2196, 0x2197,
0x2199, 0x2198, 0x2225, 0x2223, 0x0000, 0x0000, 0xFF0F, 0xFF3C,
0xFF04, 0x00A5, 0x3012, 0x00A2, 0x00A3, 0xFF05, 0xFF20, 0x2103,
0x2109, 0xFE69, 0xFE6A, 0xFE6B, 0x33D5, 0x339C, 0x339D, 0x339E,
0x33CE, 0x33A1, 0x338E, 0x338F, 0x33C4, 0x00B0, 0x5159, 0x515B,
0x515E, 0x515D, 0x5161, 0x5163, 0x55E7, 0x74E9, 0x7CCE, 0x2581,
0x2582, 0x2583, 0x2584, 0x2585, 0x2586, 0x2587, 0x2588, 0x258F,
0x258E, 0x258D, 0x258C, 0x258B, 0x258A, 0x2589, 0x253C, 0x2534,
0x252C, 0x2524, 0x251C, 0x2594, 0x2500, 0x2502, 0x2595, 0x250C,
0x2510, 0x2514, 0x2518, 0x256D, 0x256E, 0x2570, 0x256F, 0x2550,
0x255E, 0x256A, 0x2561, 0x25E2, 0x25E3, 0x25E5, 0x25E4, 0x2571,
0x2572, 0x2573, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15,
0xFF16, 0xFF17, 0xFF18, 0xFF19, 0x2160, 0x2161, 0x2162, 0x2163,
0x2164, 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0x3021, 0x3022,
0x3023, 0x3024, 0x3025, 0x3026, 0x3027, 0x3028, 0x3029, 0x0000,
0x5344, 0x0000, 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, 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, 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, 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, 0x02D9, 0x02C9, 0x02CA, 0x02C7, 0x02CB,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4E00,
0x4E59, 0x4E01, 0x4E03, 0x4E43, 0x4E5D, 0x4E86, 0x4E8C, 0x4EBA,
0x513F, 0x5165, 0x516B, 0x51E0, 0x5200, 0x5201, 0x529B, 0x5315,
0x5341, 0x535C, 0x53C8, 0x4E09, 0x4E0B, 0x4E08, 0x4E0A, 0x4E2B,
0x4E38, 0x51E1, 0x4E45, 0x4E48, 0x4E5F, 0x4E5E, 0x4E8E, 0x4EA1,
0x5140, 0x5203, 0x52FA, 0x5343, 0x53C9, 0x53E3, 0x571F, 0x58EB,
0x5915, 0x5927, 0x5973, 0x5B50, 0x5B51, 0x5B53, 0x5BF8, 0x5C0F,
0x5C22, 0x5C38, 0x5C71, 0x5DDD, 0x5DE5, 0x5DF1, 0x5DF2, 0x5DF3,
0x5DFE, 0x5E72, 0x5EFE, 0x5F0B, 0x5F13, 0x624D, 0x4E11, 0x4E10,
0x4E0D, 0x4E2D, 0x4E30, 0x4E39, 0x4E4B, 0x5C39, 0x4E88, 0x4E91,
0x4E95, 0x4E92, 0x4E94, 0x4EA2, 0x4EC1, 0x4EC0, 0x4EC3, 0x4EC6,
0x4EC7, 0x4ECD, 0x4ECA, 0x4ECB, 0x4EC4, 0x5143, 0x5141, 0x5167,
0x516D, 0x516E, 0x516C, 0x5197, 0x51F6, 0x5206, 0x5207, 0x5208,
0x52FB, 0x52FE, 0x52FF, 0x5316, 0x5339, 0x5348, 0x5347, 0x5345,
0x535E, 0x5384, 0x53CB, 0x53CA, 0x53CD, 0x58EC, 0x5929, 0x592B,
0x592A, 0x592D, 0x5B54, 0x5C11, 0x5C24, 0x5C3A, 0x5C6F, 0x5DF4,
0x5E7B, 0x5EFF, 0x5F14, 0x5F15, 0x5FC3, 0x6208, 0x6236, 0x624B,
0x624E, 0x652F, 0x6587, 0x6597, 0x65A4, 0x65B9, 0x65E5, 0x66F0,
0x6708, 0x6728, 0x6B20, 0x6B62, 0x6B79, 0x6BCB, 0x6BD4, 0x6BDB,
0x6C0F, 0x6C34, 0x706B, 0x722A, 0x7236, 0x723B, 0x7247, 0x7259,
0x725B, 0x72AC, 0x738B, 0x4E19, 0x4E16, 0x4E15, 0x4E14, 0x4E18,
0x4E3B, 0x4E4D, 0x4E4F, 0x4E4E, 0x4EE5, 0x4ED8, 0x4ED4, 0x4ED5,
0x4ED6, 0x4ED7, 0x4EE3, 0x4EE4, 0x4ED9, 0x4EDE, 0x5145, 0x5144,
0x5189, 0x518A, 0x51AC, 0x51F9, 0x51FA, 0x51F8, 0x520A, 0x52A0,
0x529F, 0x5305, 0x5306, 0x5317, 0x531D, 0x4EDF, 0x534A, 0x5349,
0x5361, 0x5360, 0x536F, 0x536E, 0x53BB, 0x53EF, 0x53E4, 0x53F3,
0x53EC, 0x53EE, 0x53E9, 0x53E8, 0x53FC, 0x53F8, 0x53F5, 0x53EB,
0x53E6, 0x53EA, 0x53F2, 0x53F1, 0x53F0, 0x53E5, 0x53ED, 0x53FB,
0x56DB, 0x56DA, 0x5916, 0x592E, 0x5931, 0x5974, 0x5976, 0x5B55,
0x5B83, 0x5C3C, 0x5DE8, 0x5DE7, 0x5DE6, 0x5E02, 0x5E03, 0x5E73,
0x5E7C, 0x5F01, 0x5F18, 0x5F17, 0x5FC5, 0x620A, 0x6253, 0x6254,
0x6252, 0x6251, 0x65A5, 0x65E6, 0x672E, 0x672C, 0x672A, 0x672B,
0x672D, 0x6B63, 0x6BCD, 0x6C11, 0x6C10, 0x6C38, 0x6C41, 0x6C40,
0x6C3E, 0x72AF, 0x7384, 0x7389, 0x74DC, 0x74E6, 0x7518, 0x751F,
0x7528, 0x7529, 0x7530, 0x7531, 0x7532, 0x7533, 0x758B, 0x767D,
0x76AE, 0x76BF, 0x76EE, 0x77DB, 0x77E2, 0x77F3, 0x793A, 0x79BE,
0x7A74, 0x7ACB, 0x4E1E, 0x4E1F, 0x4E52, 0x4E53, 0x4E69, 0x4E99,
0x4EA4, 0x4EA6, 0x4EA5, 0x4EFF, 0x4F09, 0x4F19, 0x4F0A, 0x4F15,
0x4F0D, 0x4F10, 0x4F11, 0x4F0F, 0x4EF2, 0x4EF6, 0x4EFB, 0x4EF0,
0x4EF3, 0x4EFD, 0x4F01, 0x4F0B, 0x5149, 0x5147, 0x5146, 0x5148,
0x5168, 0x5171, 0x518D, 0x51B0, 0x5217, 0x5211, 0x5212, 0x520E,
0x5216, 0x52A3, 0x5308, 0x5321, 0x5320, 0x5370, 0x5371, 0x5409,
0x540F, 0x540C, 0x540A, 0x5410, 0x5401, 0x540B, 0x5404, 0x5411,
0x540D, 0x5408, 0x5403, 0x540E, 0x5406, 0x5412, 0x56E0, 0x56DE,
0x56DD, 0x5733, 0x5730, 0x5728, 0x572D, 0x572C, 0x572F, 0x5729,
0x5919, 0x591A, 0x5937, 0x5938, 0x5984, 0x5978, 0x5983, 0x597D,
0x5979, 0x5982, 0x5981, 0x5B57, 0x5B58, 0x5B87, 0x5B88, 0x5B85,
0x5B89, 0x5BFA, 0x5C16, 0x5C79, 0x5DDE, 0x5E06, 0x5E76, 0x5E74,
0x5F0F, 0x5F1B, 0x5FD9, 0x5FD6, 0x620E, 0x620C, 0x620D, 0x6210,
0x6263, 0x625B, 0x6258, 0x6536, 0x65E9, 0x65E8, 0x65EC, 0x65ED,
0x66F2, 0x66F3, 0x6709, 0x673D, 0x6734, 0x6731, 0x6735, 0x6B21,
0x6B64, 0x6B7B, 0x6C16, 0x6C5D, 0x6C57, 0x6C59, 0x6C5F, 0x6C60,
0x6C50, 0x6C55, 0x6C61, 0x6C5B, 0x6C4D, 0x6C4E, 0x7070, 0x725F,
0x725D, 0x767E, 0x7AF9, 0x7C73, 0x7CF8, 0x7F36, 0x7F8A, 0x7FBD,
0x8001, 0x8003, 0x800C, 0x8012, 0x8033, 0x807F, 0x8089, 0x808B,
0x808C, 0x81E3, 0x81EA, 0x81F3, 0x81FC, 0x820C, 0x821B, 0x821F,
0x826E, 0x8272, 0x827E, 0x866B, 0x8840, 0x884C, 0x8863, 0x897F,
0x9621, 0x4E32, 0x4EA8, 0x4F4D, 0x4F4F, 0x4F47, 0x4F57, 0x4F5E,
0x4F34, 0x4F5B, 0x4F55, 0x4F30, 0x4F50, 0x4F51, 0x4F3D, 0x4F3A,
0x4F38, 0x4F43, 0x4F54, 0x4F3C, 0x4F46, 0x4F63, 0x4F5C, 0x4F60,
0x4F2F, 0x4F4E, 0x4F36, 0x4F59, 0x4F5D, 0x4F48, 0x4F5A, 0x514C,
0x514B, 0x514D, 0x5175, 0x51B6, 0x51B7, 0x5225, 0x5224, 0x5229,
0x522A, 0x5228, 0x52AB, 0x52A9, 0x52AA, 0x52AC, 0x5323, 0x5373,
0x5375, 0x541D, 0x542D, 0x541E, 0x543E, 0x5426, 0x544E, 0x5427,
0x5446, 0x5443, 0x5433, 0x5448, 0x5442, 0x541B, 0x5429, 0x544A,
0x5439, 0x543B, 0x5438, 0x542E, 0x5435, 0x5436, 0x5420, 0x543C,
0x5440, 0x5431, 0x542B, 0x541F, 0x542C, 0x56EA, 0x56F0, 0x56E4,
0x56EB, 0x574A, 0x5751, 0x5740, 0x574D, 0x5747, 0x574E, 0x573E,
0x5750, 0x574F, 0x573B, 0x58EF, 0x593E, 0x599D, 0x5992, 0x59A8,
0x599E, 0x59A3, 0x5999, 0x5996, 0x598D, 0x59A4, 0x5993, 0x598A,
0x59A5, 0x5B5D, 0x5B5C, 0x5B5A, 0x5B5B, 0x5B8C, 0x5B8B, 0x5B8F,
0x5C2C, 0x5C40, 0x5C41, 0x5C3F, 0x5C3E, 0x5C90, 0x5C91, 0x5C94,
0x5C8C, 0x5DEB, 0x5E0C, 0x5E8F, 0x5E87, 0x5E8A, 0x5EF7, 0x5F04,
0x5F1F, 0x5F64, 0x5F62, 0x5F77, 0x5F79, 0x5FD8, 0x5FCC, 0x5FD7,
0x5FCD, 0x5FF1, 0x5FEB, 0x5FF8, 0x5FEA, 0x6212, 0x6211, 0x6284,
0x6297, 0x6296, 0x6280, 0x6276, 0x6289, 0x626D, 0x628A, 0x627C,
0x627E, 0x6279, 0x6273, 0x6292, 0x626F, 0x6298, 0x626E, 0x6295,
0x6293, 0x6291, 0x6286, 0x6539, 0x653B, 0x6538, 0x65F1, 0x66F4,
0x675F, 0x674E, 0x674F, 0x6750, 0x6751, 0x675C, 0x6756, 0x675E,
0x6749, 0x6746, 0x6760, 0x6753, 0x6757, 0x6B65, 0x6BCF, 0x6C42,
0x6C5E, 0x6C99, 0x6C81, 0x6C88, 0x6C89, 0x6C85, 0x6C9B, 0x6C6A,
0x6C7A, 0x6C90, 0x6C70, 0x6C8C, 0x6C68, 0x6C96, 0x6C92, 0x6C7D,
0x6C83, 0x6C72, 0x6C7E, 0x6C74, 0x6C86, 0x6C76, 0x6C8D, 0x6C94,
0x6C98, 0x6C82, 0x7076, 0x707C, 0x707D, 0x7078, 0x7262, 0x7261,
0x7260, 0x72C4, 0x72C2, 0x7396, 0x752C, 0x752B, 0x7537, 0x7538,
0x7682, 0x76EF, 0x77E3, 0x79C1, 0x79C0, 0x79BF, 0x7A76, 0x7CFB,
0x7F55, 0x8096, 0x8093, 0x809D, 0x8098, 0x809B, 0x809A, 0x80B2,
0x826F, 0x8292, 0x828B, 0x828D, 0x898B, 0x89D2, 0x8A00, 0x8C37,
0x8C46, 0x8C55, 0x8C9D, 0x8D64, 0x8D70, 0x8DB3, 0x8EAB, 0x8ECA,
0x8F9B, 0x8FB0, 0x8FC2, 0x8FC6, 0x8FC5, 0x8FC4, 0x5DE1, 0x9091,
0x90A2, 0x90AA, 0x90A6, 0x90A3, 0x9149, 0x91C6, 0x91CC, 0x9632,
0x962E, 0x9631, 0x962A, 0x962C, 0x4E26, 0x4E56, 0x4E73, 0x4E8B,
0x4E9B, 0x4E9E, 0x4EAB, 0x4EAC, 0x4F6F, 0x4F9D, 0x4F8D, 0x4F73,
0x4F7F, 0x4F6C, 0x4F9B, 0x4F8B, 0x4F86, 0x4F83, 0x4F70, 0x4F75,
0x4F88, 0x4F69, 0x4F7B, 0x4F96, 0x4F7E, 0x4F8F, 0x4F91, 0x4F7A,
0x5154, 0x5152, 0x5155, 0x5169, 0x5177, 0x5176, 0x5178, 0x51BD,
0x51FD, 0x523B, 0x5238, 0x5237, 0x523A, 0x5230, 0x522E, 0x5236,
0x5241, 0x52BE, 0x52BB, 0x5352, 0x5354, 0x5353, 0x5351, 0x5366,
0x5377, 0x5378, 0x5379, 0x53D6, 0x53D4, 0x53D7, 0x5473, 0x5475,
0x5496, 0x5478, 0x5495, 0x5480, 0x547B, 0x5477, 0x5484, 0x5492,
0x5486, 0x547C, 0x5490, 0x5471, 0x5476, 0x548C, 0x549A, 0x5462,
0x5468, 0x548B, 0x547D, 0x548E, 0x56FA, 0x5783, 0x5777, 0x576A,
0x5769, 0x5761, 0x5766, 0x5764, 0x577C, 0x591C, 0x5949, 0x5947,
0x5948, 0x5944, 0x5954, 0x59BE, 0x59BB, 0x59D4, 0x59B9, 0x59AE,
0x59D1, 0x59C6, 0x59D0, 0x59CD, 0x59CB, 0x59D3, 0x59CA, 0x59AF,
0x59B3, 0x59D2, 0x59C5, 0x5B5F, 0x5B64, 0x5B63, 0x5B97, 0x5B9A,
0x5B98, 0x5B9C, 0x5B99, 0x5B9B, 0x5C1A, 0x5C48, 0x5C45, 0x5C46,
0x5CB7, 0x5CA1, 0x5CB8, 0x5CA9, 0x5CAB, 0x5CB1, 0x5CB3, 0x5E18,
0x5E1A, 0x5E16, 0x5E15, 0x5E1B, 0x5E11, 0x5E78, 0x5E9A, 0x5E97,
0x5E9C, 0x5E95, 0x5E96, 0x5EF6, 0x5F26, 0x5F27, 0x5F29, 0x5F80,
0x5F81, 0x5F7F, 0x5F7C, 0x5FDD, 0x5FE0, 0x5FFD, 0x5FF5, 0x5FFF,
0x600F, 0x6014, 0x602F, 0x6035, 0x6016, 0x602A, 0x6015, 0x6021,
0x6027, 0x6029, 0x602B, 0x601B, 0x6216, 0x6215, 0x623F, 0x623E,
0x6240, 0x627F, 0x62C9, 0x62CC, 0x62C4, 0x62BF, 0x62C2, 0x62B9,
0x62D2, 0x62DB, 0x62AB, 0x62D3, 0x62D4, 0x62CB, 0x62C8, 0x62A8,
0x62BD, 0x62BC, 0x62D0, 0x62D9, 0x62C7, 0x62CD, 0x62B5, 0x62DA,
0x62B1, 0x62D8, 0x62D6, 0x62D7, 0x62C6, 0x62AC, 0x62CE, 0x653E,
0x65A7, 0x65BC, 0x65FA, 0x6614, 0x6613, 0x660C, 0x6606, 0x6602,
0x660E, 0x6600, 0x660F, 0x6615, 0x660A, 0x6607, 0x670D, 0x670B,
0x676D, 0x678B, 0x6795, 0x6771, 0x679C, 0x6773, 0x6777, 0x6787,
0x679D, 0x6797, 0x676F, 0x6770, 0x677F, 0x6789, 0x677E, 0x6790,
0x6775, 0x679A, 0x6793, 0x677C, 0x676A, 0x6772, 0x6B23, 0x6B66,
0x6B67, 0x6B7F, 0x6C13, 0x6C1B, 0x6CE3, 0x6CE8, 0x6CF3, 0x6CB1,
0x6CCC, 0x6CE5, 0x6CB3, 0x6CBD, 0x6CBE, 0x6CBC, 0x6CE2, 0x6CAB,
0x6CD5, 0x6CD3, 0x6CB8, 0x6CC4, 0x6CB9, 0x6CC1, 0x6CAE, 0x6CD7,
0x6CC5, 0x6CF1, 0x6CBF, 0x6CBB, 0x6CE1, 0x6CDB, 0x6CCA, 0x6CAC,
0x6CEF, 0x6CDC, 0x6CD6, 0x6CE0, 0x7095, 0x708E, 0x7092, 0x708A,
0x7099, 0x722C, 0x722D, 0x7238, 0x7248, 0x7267, 0x7269, 0x72C0,
0x72CE, 0x72D9, 0x72D7, 0x72D0, 0x73A9, 0x73A8, 0x739F, 0x73AB,
0x73A5, 0x753D, 0x759D, 0x7599, 0x759A, 0x7684, 0x76C2, 0x76F2,
0x76F4, 0x77E5, 0x77FD, 0x793E, 0x7940, 0x7941, 0x79C9, 0x79C8,
0x7A7A, 0x7A79, 0x7AFA, 0x7CFE, 0x7F54, 0x7F8C, 0x7F8B, 0x8005,
0x80BA, 0x80A5, 0x80A2, 0x80B1, 0x80A1, 0x80AB, 0x80A9, 0x80B4,
0x80AA, 0x80AF, 0x81E5, 0x81FE, 0x820D, 0x82B3, 0x829D, 0x8299,
0x82AD, 0x82BD, 0x829F, 0x82B9, 0x82B1, 0x82AC, 0x82A5, 0x82AF,
0x82B8, 0x82A3, 0x82B0, 0x82BE, 0x82B7, 0x864E, 0x8671, 0x521D,
0x8868, 0x8ECB, 0x8FCE, 0x8FD4, 0x8FD1, 0x90B5, 0x90B8, 0x90B1,
0x90B6, 0x91C7, 0x91D1, 0x9577, 0x9580, 0x961C, 0x9640, 0x963F,
0x963B, 0x9644, 0x9642, 0x96B9, 0x96E8, 0x9752, 0x975E, 0x4E9F,
0x4EAD, 0x4EAE, 0x4FE1, 0x4FB5, 0x4FAF, 0x4FBF, 0x4FE0, 0x4FD1,
0x4FCF, 0x4FDD, 0x4FC3, 0x4FB6, 0x4FD8, 0x4FDF, 0x4FCA, 0x4FD7,
0x4FAE, 0x4FD0, 0x4FC4, 0x4FC2, 0x4FDA, 0x4FCE, 0x4FDE, 0x4FB7,
0x5157, 0x5192, 0x5191, 0x51A0, 0x524E, 0x5243, 0x524A, 0x524D,
0x524C, 0x524B, 0x5247, 0x52C7, 0x52C9, 0x52C3, 0x52C1, 0x530D,
0x5357, 0x537B, 0x539A, 0x53DB, 0x54AC, 0x54C0, 0x54A8, 0x54CE,
0x54C9, 0x54B8, 0x54A6, 0x54B3, 0x54C7, 0x54C2, 0x54BD, 0x54AA,
0x54C1, 0x54C4, 0x54C8, 0x54AF, 0x54AB, 0x54B1, 0x54BB, 0x54A9,
0x54A7, 0x54BF, 0x56FF, 0x5782, 0x578B, 0x57A0, 0x57A3, 0x57A2,
0x57CE, 0x57AE, 0x5793, 0x5955, 0x5951, 0x594F, 0x594E, 0x5950,
0x59DC, 0x59D8, 0x59FF, 0x59E3, 0x59E8, 0x5A03, 0x59E5, 0x59EA,
0x59DA, 0x59E6, 0x5A01, 0x59FB, 0x5B69, 0x5BA3, 0x5BA6, 0x5BA4,
0x5BA2, 0x5BA5, 0x5C01, 0x5C4E, 0x5C4F, 0x5C4D, 0x5C4B, 0x5CD9,
0x5CD2, 0x5DF7, 0x5E1D, 0x5E25, 0x5E1F, 0x5E7D, 0x5EA0, 0x5EA6,
0x5EFA, 0x5F08, 0x5F2D, 0x5F65, 0x5F88, 0x5F85, 0x5F8A, 0x5F8B,
0x5F87, 0x5F8C, 0x5F89, 0x6012, 0x601D, 0x6020, 0x6025, 0x600E,
0x6028, 0x604D, 0x6070, 0x6068, 0x6062, 0x6046, 0x6043, 0x606C,
0x606B, 0x606A, 0x6064, 0x6241, 0x62DC, 0x6316, 0x6309, 0x62FC,
0x62ED, 0x6301, 0x62EE, 0x62FD, 0x6307, 0x62F1, 0x62F7, 0x62EF,
0x62EC, 0x62FE, 0x62F4, 0x6311, 0x6302, 0x653F, 0x6545, 0x65AB,
0x65BD, 0x65E2, 0x6625, 0x662D, 0x6620, 0x6627, 0x662F, 0x661F,
0x6628, 0x6631, 0x6624, 0x66F7, 0x67FF, 0x67D3, 0x67F1, 0x67D4,
0x67D0, 0x67EC, 0x67B6, 0x67AF, 0x67F5, 0x67E9, 0x67EF, 0x67C4,
0x67D1, 0x67B4, 0x67DA, 0x67E5, 0x67B8, 0x67CF, 0x67DE, 0x67F3,
0x67B0, 0x67D9, 0x67E2, 0x67DD, 0x67D2, 0x6B6A, 0x6B83, 0x6B86,
0x6BB5, 0x6BD2, 0x6BD7, 0x6C1F, 0x6CC9, 0x6D0B, 0x6D32, 0x6D2A,
0x6D41, 0x6D25, 0x6D0C, 0x6D31, 0x6D1E, 0x6D17, 0x6D3B, 0x6D3D,
0x6D3E, 0x6D36, 0x6D1B, 0x6CF5, 0x6D39, 0x6D27, 0x6D38, 0x6D29,
0x6D2E, 0x6D35, 0x6D0E, 0x6D2B, 0x70AB, 0x70BA, 0x70B3, 0x70AC,
0x70AF, 0x70AD, 0x70B8, 0x70AE, 0x70A4, 0x7230, 0x7272, 0x726F,
0x7274, 0x72E9, 0x72E0, 0x72E1, 0x73B7, 0x73CA, 0x73BB, 0x73B2,
0x73CD, 0x73C0, 0x73B3, 0x751A, 0x752D, 0x754F, 0x754C, 0x754E,
0x754B, 0x75AB, 0x75A4, 0x75A5, 0x75A2, 0x75A3, 0x7678, 0x7686,
0x7687, 0x7688, 0x76C8, 0x76C6, 0x76C3, 0x76C5, 0x7701, 0x76F9,
0x76F8, 0x7709, 0x770B, 0x76FE, 0x76FC, 0x7707, 0x77DC, 0x7802,
0x7814, 0x780C, 0x780D, 0x7946, 0x7949, 0x7948, 0x7947, 0x79B9,
0x79BA, 0x79D1, 0x79D2, 0x79CB, 0x7A7F, 0x7A81, 0x7AFF, 0x7AFD,
0x7C7D, 0x7D02, 0x7D05, 0x7D00, 0x7D09, 0x7D07, 0x7D04, 0x7D06,
0x7F38, 0x7F8E, 0x7FBF, 0x8004, 0x8010, 0x800D, 0x8011, 0x8036,
0x80D6, 0x80E5, 0x80DA, 0x80C3, 0x80C4, 0x80CC, 0x80E1, 0x80DB,
0x80CE, 0x80DE, 0x80E4, 0x80DD, 0x81F4, 0x8222, 0x82E7, 0x8303,
0x8305, 0x82E3, 0x82DB, 0x82E6, 0x8304, 0x82E5, 0x8302, 0x8309,
0x82D2, 0x82D7, 0x82F1, 0x8301, 0x82DC, 0x82D4, 0x82D1, 0x82DE,
0x82D3, 0x82DF, 0x82EF, 0x8306, 0x8650, 0x8679, 0x867B, 0x867A,
0x884D, 0x886B, 0x8981, 0x89D4, 0x8A08, 0x8A02, 0x8A03, 0x8C9E,
0x8CA0, 0x8D74, 0x8D73, 0x8DB4, 0x8ECD, 0x8ECC, 0x8FF0, 0x8FE6,
0x8FE2, 0x8FEA, 0x8FE5, 0x8FED, 0x8FEB, 0x8FE4, 0x8FE8, 0x90CA,
0x90CE, 0x90C1, 0x90C3, 0x914B, 0x914A, 0x91CD, 0x9582, 0x9650,
0x964B, 0x964C, 0x964D, 0x9762, 0x9769, 0x97CB, 0x97ED, 0x97F3,
0x9801, 0x98A8, 0x98DB, 0x98DF, 0x9996, 0x9999, 0x4E58, 0x4EB3,
0x500C, 0x500D, 0x5023, 0x4FEF, 0x5026, 0x5025, 0x4FF8, 0x5029,
0x5016, 0x5006, 0x503C, 0x501F, 0x501A, 0x5012, 0x5011, 0x4FFA,
0x5000, 0x5014, 0x5028, 0x4FF1, 0x5021, 0x500B, 0x5019, 0x5018,
0x4FF3, 0x4FEE, 0x502D, 0x502A, 0x4FFE, 0x502B, 0x5009, 0x517C,
0x51A4, 0x51A5, 0x51A2, 0x51CD, 0x51CC, 0x51C6, 0x51CB, 0x5256,
0x525C, 0x5254, 0x525B, 0x525D, 0x532A, 0x537F, 0x539F, 0x539D,
0x53DF, 0x54E8, 0x5510, 0x5501, 0x5537, 0x54FC, 0x54E5, 0x54F2,
0x5506, 0x54FA, 0x5514, 0x54E9, 0x54ED, 0x54E1, 0x5509, 0x54EE,
0x54EA, 0x54E6, 0x5527, 0x5507, 0x54FD, 0x550F, 0x5703, 0x5704,
0x57C2, 0x57D4, 0x57CB, 0x57C3, 0x5809, 0x590F, 0x5957, 0x5958,
0x595A, 0x5A11, 0x5A18, 0x5A1C, 0x5A1F, 0x5A1B, 0x5A13, 0x59EC,
0x5A20, 0x5A23, 0x5A29, 0x5A25, 0x5A0C, 0x5A09, 0x5B6B, 0x5C58,
0x5BB0, 0x5BB3, 0x5BB6, 0x5BB4, 0x5BAE, 0x5BB5, 0x5BB9, 0x5BB8,
0x5C04, 0x5C51, 0x5C55, 0x5C50, 0x5CED, 0x5CFD, 0x5CFB, 0x5CEA,
0x5CE8, 0x5CF0, 0x5CF6, 0x5D01, 0x5CF4, 0x5DEE, 0x5E2D, 0x5E2B,
0x5EAB, 0x5EAD, 0x5EA7, 0x5F31, 0x5F92, 0x5F91, 0x5F90, 0x6059,
0x6063, 0x6065, 0x6050, 0x6055, 0x606D, 0x6069, 0x606F, 0x6084,
0x609F, 0x609A, 0x608D, 0x6094, 0x608C, 0x6085, 0x6096, 0x6247,
0x62F3, 0x6308, 0x62FF, 0x634E, 0x633E, 0x632F, 0x6355, 0x6342,
0x6346, 0x634F, 0x6349, 0x633A, 0x6350, 0x633D, 0x632A, 0x632B,
0x6328, 0x634D, 0x634C, 0x6548, 0x6549, 0x6599, 0x65C1, 0x65C5,
0x6642, 0x6649, 0x664F, 0x6643, 0x6652, 0x664C, 0x6645, 0x6641,
0x66F8, 0x6714, 0x6715, 0x6717, 0x6821, 0x6838, 0x6848, 0x6846,
0x6853, 0x6839, 0x6842, 0x6854, 0x6829, 0x68B3, 0x6817, 0x684C,
0x6851, 0x683D, 0x67F4, 0x6850, 0x6840, 0x683C, 0x6843, 0x682A,
0x6845, 0x6813, 0x6818, 0x6841, 0x6B8A, 0x6B89, 0x6BB7, 0x6C23,
0x6C27, 0x6C28, 0x6C26, 0x6C24, 0x6CF0, 0x6D6A, 0x6D95, 0x6D88,
0x6D87, 0x6D66, 0x6D78, 0x6D77, 0x6D59, 0x6D93, 0x6D6C, 0x6D89,
0x6D6E, 0x6D5A, 0x6D74, 0x6D69, 0x6D8C, 0x6D8A, 0x6D79, 0x6D85,
0x6D65, 0x6D94, 0x70CA, 0x70D8, 0x70E4, 0x70D9, 0x70C8, 0x70CF,
0x7239, 0x7279, 0x72FC, 0x72F9, 0x72FD, 0x72F8, 0x72F7, 0x7386,
0x73ED, 0x7409, 0x73EE, 0x73E0, 0x73EA, 0x73DE, 0x7554, 0x755D,
0x755C, 0x755A, 0x7559, 0x75BE, 0x75C5, 0x75C7, 0x75B2, 0x75B3,
0x75BD, 0x75BC, 0x75B9, 0x75C2, 0x75B8, 0x768B, 0x76B0, 0x76CA,
0x76CD, 0x76CE, 0x7729, 0x771F, 0x7720, 0x7728, 0x77E9, 0x7830,
0x7827, 0x7838, 0x781D, 0x7834, 0x7837, 0x7825, 0x782D, 0x7820,
0x781F, 0x7832, 0x7955, 0x7950, 0x7960, 0x795F, 0x7956, 0x795E,
0x795D, 0x7957, 0x795A, 0x79E4, 0x79E3, 0x79E7, 0x79DF, 0x79E6,
0x79E9, 0x79D8, 0x7A84, 0x7A88, 0x7AD9, 0x7B06, 0x7B11, 0x7C89,
0x7D21, 0x7D17, 0x7D0B, 0x7D0A, 0x7D20, 0x7D22, 0x7D14, 0x7D10,
0x7D15, 0x7D1A, 0x7D1C, 0x7D0D, 0x7D19, 0x7D1B, 0x7F3A, 0x7F5F,
0x7F94, 0x7FC5, 0x7FC1, 0x8006, 0x8018, 0x8015, 0x8019, 0x8017,
0x803D, 0x803F, 0x80F1, 0x8102, 0x80F0, 0x8105, 0x80ED, 0x80F4,
0x8106, 0x80F8, 0x80F3, 0x8108, 0x80FD, 0x810A, 0x80FC, 0x80EF,
0x81ED, 0x81EC, 0x8200, 0x8210, 0x822A, 0x822B, 0x8228, 0x822C,
0x82BB, 0x832B, 0x8352, 0x8354, 0x834A, 0x8338, 0x8350, 0x8349,
0x8335, 0x8334, 0x834F, 0x8332, 0x8339, 0x8336, 0x8317, 0x8340,
0x8331, 0x8328, 0x8343, 0x8654, 0x868A, 0x86AA, 0x8693, 0x86A4,
0x86A9, 0x868C, 0x86A3, 0x869C, 0x8870, 0x8877, 0x8881, 0x8882,
0x887D, 0x8879, 0x8A18, 0x8A10, 0x8A0E, 0x8A0C, 0x8A15, 0x8A0A,
0x8A17, 0x8A13, 0x8A16, 0x8A0F, 0x8A11, 0x8C48, 0x8C7A, 0x8C79,
0x8CA1, 0x8CA2, 0x8D77, 0x8EAC, 0x8ED2, 0x8ED4, 0x8ECF, 0x8FB1,
0x9001, 0x9006, 0x8FF7, 0x9000, 0x8FFA, 0x8FF4, 0x9003, 0x8FFD,
0x9005, 0x8FF8, 0x9095, 0x90E1, 0x90DD, 0x90E2, 0x9152, 0x914D,
0x914C, 0x91D8, 0x91DD, 0x91D7, 0x91DC, 0x91D9, 0x9583, 0x9662,
0x9663, 0x9661, 0x965B, 0x965D, 0x9664, 0x9658, 0x965E, 0x96BB,
0x98E2, 0x99AC, 0x9AA8, 0x9AD8, 0x9B25, 0x9B32, 0x9B3C, 0x4E7E,
0x507A, 0x507D, 0x505C, 0x5047, 0x5043, 0x504C, 0x505A, 0x5049,
0x5065, 0x5076, 0x504E, 0x5055, 0x5075, 0x5074, 0x5077, 0x504F,
0x500F, 0x506F, 0x506D, 0x515C, 0x5195, 0x51F0, 0x526A, 0x526F,
0x52D2, 0x52D9, 0x52D8, 0x52D5, 0x5310, 0x530F, 0x5319, 0x533F,
0x5340, 0x533E, 0x53C3, 0x66FC, 0x5546, 0x556A, 0x5566, 0x5544,
0x555E, 0x5561, 0x5543, 0x554A, 0x5531, 0x5556, 0x554F, 0x5555,
0x552F, 0x5564, 0x5538, 0x552E, 0x555C, 0x552C, 0x5563, 0x5533,
0x5541, 0x5557, 0x5708, 0x570B, 0x5709, 0x57DF, 0x5805, 0x580A,
0x5806, 0x57E0, 0x57E4, 0x57FA, 0x5802, 0x5835, 0x57F7, 0x57F9,
0x5920, 0x5962, 0x5A36, 0x5A41, 0x5A49, 0x5A66, 0x5A6A, 0x5A40,
0x5A3C, 0x5A62, 0x5A5A, 0x5A46, 0x5A4A, 0x5B70, 0x5BC7, 0x5BC5,
0x5BC4, 0x5BC2, 0x5BBF, 0x5BC6, 0x5C09, 0x5C08, 0x5C07, 0x5C60,
0x5C5C, 0x5C5D, 0x5D07, 0x5D06, 0x5D0E, 0x5D1B, 0x5D16, 0x5D22,
0x5D11, 0x5D29, 0x5D14, 0x5D19, 0x5D24, 0x5D27, 0x5D17, 0x5DE2,
0x5E38, 0x5E36, 0x5E33, 0x5E37, 0x5EB7, 0x5EB8, 0x5EB6, 0x5EB5,
0x5EBE, 0x5F35, 0x5F37, 0x5F57, 0x5F6C, 0x5F69, 0x5F6B, 0x5F97,
0x5F99, 0x5F9E, 0x5F98, 0x5FA1, 0x5FA0, 0x5F9C, 0x607F, 0x60A3,
0x6089, 0x60A0, 0x60A8, 0x60CB, 0x60B4, 0x60E6, 0x60BD, 0x60C5,
0x60BB, 0x60B5, 0x60DC, 0x60BC, 0x60D8, 0x60D5, 0x60C6, 0x60DF,
0x60B8, 0x60DA, 0x60C7, 0x621A, 0x621B, 0x6248, 0x63A0, 0x63A7,
0x6372, 0x6396, 0x63A2, 0x63A5, 0x6377, 0x6367, 0x6398, 0x63AA,
0x6371, 0x63A9, 0x6389, 0x6383, 0x639B, 0x636B, 0x63A8, 0x6384,
0x6388, 0x6399, 0x63A1, 0x63AC, 0x6392, 0x638F, 0x6380, 0x637B,
0x6369, 0x6368, 0x637A, 0x655D, 0x6556, 0x6551, 0x6559, 0x6557,
0x555F, 0x654F, 0x6558, 0x6555, 0x6554, 0x659C, 0x659B, 0x65AC,
0x65CF, 0x65CB, 0x65CC, 0x65CE, 0x665D, 0x665A, 0x6664, 0x6668,
0x6666, 0x665E, 0x66F9, 0x52D7, 0x671B, 0x6881, 0x68AF, 0x68A2,
0x6893, 0x68B5, 0x687F, 0x6876, 0x68B1, 0x68A7, 0x6897, 0x68B0,
0x6883, 0x68C4, 0x68AD, 0x6886, 0x6885, 0x6894, 0x689D, 0x68A8,
0x689F, 0x68A1, 0x6882, 0x6B32, 0x6BBA, 0x6BEB, 0x6BEC, 0x6C2B,
0x6D8E, 0x6DBC, 0x6DF3, 0x6DD9, 0x6DB2, 0x6DE1, 0x6DCC, 0x6DE4,
0x6DFB, 0x6DFA, 0x6E05, 0x6DC7, 0x6DCB, 0x6DAF, 0x6DD1, 0x6DAE,
0x6DDE, 0x6DF9, 0x6DB8, 0x6DF7, 0x6DF5, 0x6DC5, 0x6DD2, 0x6E1A,
0x6DB5, 0x6DDA, 0x6DEB, 0x6DD8, 0x6DEA, 0x6DF1, 0x6DEE, 0x6DE8,
0x6DC6, 0x6DC4, 0x6DAA, 0x6DEC, 0x6DBF, 0x6DE6, 0x70F9, 0x7109,
0x710A, 0x70FD, 0x70EF, 0x723D, 0x727D, 0x7281, 0x731C, 0x731B,
0x7316, 0x7313, 0x7319, 0x7387, 0x7405, 0x740A, 0x7403, 0x7406,
0x73FE, 0x740D, 0x74E0, 0x74F6, 0x74F7, 0x751C, 0x7522, 0x7565,
0x7566, 0x7562, 0x7570, 0x758F, 0x75D4, 0x75D5, 0x75B5, 0x75CA,
0x75CD, 0x768E, 0x76D4, 0x76D2, 0x76DB, 0x7737, 0x773E, 0x773C,
0x7736, 0x7738, 0x773A, 0x786B, 0x7843, 0x784E, 0x7965, 0x7968,
0x796D, 0x79FB, 0x7A92, 0x7A95, 0x7B20, 0x7B28, 0x7B1B, 0x7B2C,
0x7B26, 0x7B19, 0x7B1E, 0x7B2E, 0x7C92, 0x7C97, 0x7C95, 0x7D46,
0x7D43, 0x7D71, 0x7D2E, 0x7D39, 0x7D3C, 0x7D40, 0x7D30, 0x7D33,
0x7D44, 0x7D2F, 0x7D42, 0x7D32, 0x7D31, 0x7F3D, 0x7F9E, 0x7F9A,
0x7FCC, 0x7FCE, 0x7FD2, 0x801C, 0x804A, 0x8046, 0x812F, 0x8116,
0x8123, 0x812B, 0x8129, 0x8130, 0x8124, 0x8202, 0x8235, 0x8237,
0x8236, 0x8239, 0x838E, 0x839E, 0x8398, 0x8378, 0x83A2, 0x8396,
0x83BD, 0x83AB, 0x8392, 0x838A, 0x8393, 0x8389, 0x83A0, 0x8377,
0x837B, 0x837C, 0x8386, 0x83A7, 0x8655, 0x5F6A, 0x86C7, 0x86C0,
0x86B6, 0x86C4, 0x86B5, 0x86C6, 0x86CB, 0x86B1, 0x86AF, 0x86C9,
0x8853, 0x889E, 0x8888, 0x88AB, 0x8892, 0x8896, 0x888D, 0x888B,
0x8993, 0x898F, 0x8A2A, 0x8A1D, 0x8A23, 0x8A25, 0x8A31, 0x8A2D,
0x8A1F, 0x8A1B, 0x8A22, 0x8C49, 0x8C5A, 0x8CA9, 0x8CAC, 0x8CAB,
0x8CA8, 0x8CAA, 0x8CA7, 0x8D67, 0x8D66, 0x8DBE, 0x8DBA, 0x8EDB,
0x8EDF, 0x9019, 0x900D, 0x901A, 0x9017, 0x9023, 0x901F, 0x901D,
0x9010, 0x9015, 0x901E, 0x9020, 0x900F, 0x9022, 0x9016, 0x901B,
0x9014, 0x90E8, 0x90ED, 0x90FD, 0x9157, 0x91CE, 0x91F5, 0x91E6,
0x91E3, 0x91E7, 0x91ED, 0x91E9, 0x9589, 0x966A, 0x9675, 0x9673,
0x9678, 0x9670, 0x9674, 0x9676, 0x9677, 0x966C, 0x96C0, 0x96EA,
0x96E9, 0x7AE0, 0x7ADF, 0x9802, 0x9803, 0x9B5A, 0x9CE5, 0x9E75,
0x9E7F, 0x9EA5, 0x9EBB, 0x50A2, 0x508D, 0x5085, 0x5099, 0x5091,
0x5080, 0x5096, 0x5098, 0x509A, 0x6700, 0x51F1, 0x5272, 0x5274,
0x5275, 0x5269, 0x52DE, 0x52DD, 0x52DB, 0x535A, 0x53A5, 0x557B,
0x5580, 0x55A7, 0x557C, 0x558A, 0x559D, 0x5598, 0x5582, 0x559C,
0x55AA, 0x5594, 0x5587, 0x558B, 0x5583, 0x55B3, 0x55AE, 0x559F,
0x553E, 0x55B2, 0x559A, 0x55BB, 0x55AC, 0x55B1, 0x557E, 0x5589,
0x55AB, 0x5599, 0x570D, 0x582F, 0x582A, 0x5834, 0x5824, 0x5830,
0x5831, 0x5821, 0x581D, 0x5820, 0x58F9, 0x58FA, 0x5960, 0x5A77,
0x5A9A, 0x5A7F, 0x5A92, 0x5A9B, 0x5AA7, 0x5B73, 0x5B71, 0x5BD2,
0x5BCC, 0x5BD3, 0x5BD0, 0x5C0A, 0x5C0B, 0x5C31, 0x5D4C, 0x5D50,
0x5D34, 0x5D47, 0x5DFD, 0x5E45, 0x5E3D, 0x5E40, 0x5E43, 0x5E7E,
0x5ECA, 0x5EC1, 0x5EC2, 0x5EC4, 0x5F3C, 0x5F6D, 0x5FA9, 0x5FAA,
0x5FA8, 0x60D1, 0x60E1, 0x60B2, 0x60B6, 0x60E0, 0x611C, 0x6123,
0x60FA, 0x6115, 0x60F0, 0x60FB, 0x60F4, 0x6168, 0x60F1, 0x610E,
0x60F6, 0x6109, 0x6100, 0x6112, 0x621F, 0x6249, 0x63A3, 0x638C,
0x63CF, 0x63C0, 0x63E9, 0x63C9, 0x63C6, 0x63CD, 0x63D2, 0x63E3,
0x63D0, 0x63E1, 0x63D6, 0x63ED, 0x63EE, 0x6376, 0x63F4, 0x63EA,
0x63DB, 0x6452, 0x63DA, 0x63F9, 0x655E, 0x6566, 0x6562, 0x6563,
0x6591, 0x6590, 0x65AF, 0x666E, 0x6670, 0x6674, 0x6676, 0x666F,
0x6691, 0x667A, 0x667E, 0x6677, 0x66FE, 0x66FF, 0x671F, 0x671D,
0x68FA, 0x68D5, 0x68E0, 0x68D8, 0x68D7, 0x6905, 0x68DF, 0x68F5,
0x68EE, 0x68E7, 0x68F9, 0x68D2, 0x68F2, 0x68E3, 0x68CB, 0x68CD,
0x690D, 0x6912, 0x690E, 0x68C9, 0x68DA, 0x696E, 0x68FB, 0x6B3E,
0x6B3A, 0x6B3D, 0x6B98, 0x6B96, 0x6BBC, 0x6BEF, 0x6C2E, 0x6C2F,
0x6C2C, 0x6E2F, 0x6E38, 0x6E54, 0x6E21, 0x6E32, 0x6E67, 0x6E4A,
0x6E20, 0x6E25, 0x6E23, 0x6E1B, 0x6E5B, 0x6E58, 0x6E24, 0x6E56,
0x6E6E, 0x6E2D, 0x6E26, 0x6E6F, 0x6E34, 0x6E4D, 0x6E3A, 0x6E2C,
0x6E43, 0x6E1D, 0x6E3E, 0x6ECB, 0x6E89, 0x6E19, 0x6E4E, 0x6E63,
0x6E44, 0x6E72, 0x6E69, 0x6E5F, 0x7119, 0x711A, 0x7126, 0x7130,
0x7121, 0x7136, 0x716E, 0x711C, 0x724C, 0x7284, 0x7280, 0x7336,
0x7325, 0x7334, 0x7329, 0x743A, 0x742A, 0x7433, 0x7422, 0x7425,
0x7435, 0x7436, 0x7434, 0x742F, 0x741B, 0x7426, 0x7428, 0x7525,
0x7526, 0x756B, 0x756A, 0x75E2, 0x75DB, 0x75E3, 0x75D9, 0x75D8,
0x75DE, 0x75E0, 0x767B, 0x767C, 0x7696, 0x7693, 0x76B4, 0x76DC,
0x774F, 0x77ED, 0x785D, 0x786C, 0x786F, 0x7A0D, 0x7A08, 0x7A0B,
0x7A05, 0x7A00, 0x7A98, 0x7A97, 0x7A96, 0x7AE5, 0x7AE3, 0x7B49,
0x7B56, 0x7B46, 0x7B50, 0x7B52, 0x7B54, 0x7B4D, 0x7B4B, 0x7B4F,
0x7B51, 0x7C9F, 0x7CA5, 0x7D5E, 0x7D50, 0x7D68, 0x7D55, 0x7D2B,
0x7D6E, 0x7D72, 0x7D61, 0x7D66, 0x7D62, 0x7D70, 0x7D73, 0x5584,
0x7FD4, 0x7FD5, 0x800B, 0x8052, 0x8085, 0x8155, 0x8154, 0x814B,
0x8151, 0x814E, 0x8139, 0x8146, 0x813E, 0x814C, 0x8153, 0x8174,
0x8212, 0x821C, 0x83E9, 0x8403, 0x83F8, 0x840D, 0x83E0, 0x83C5,
0x840B, 0x83C1, 0x83EF, 0x83F1, 0x83F4, 0x8457, 0x840A, 0x83F0,
0x840C, 0x83CC, 0x83FD, 0x83F2, 0x83CA, 0x8438, 0x840E, 0x8404,
0x83DC, 0x8407, 0x83D4, 0x83DF, 0x865B, 0x86DF, 0x86D9, 0x86ED,
0x86D4, 0x86DB, 0x86E4, 0x86D0, 0x86DE, 0x8857, 0x88C1, 0x88C2,
0x88B1, 0x8983, 0x8996, 0x8A3B, 0x8A60, 0x8A55, 0x8A5E, 0x8A3C,
0x8A41, 0x8A54, 0x8A5B, 0x8A50, 0x8A46, 0x8A34, 0x8A3A, 0x8A36,
0x8A56, 0x8C61, 0x8C82, 0x8CAF, 0x8CBC, 0x8CB3, 0x8CBD, 0x8CC1,
0x8CBB, 0x8CC0, 0x8CB4, 0x8CB7, 0x8CB6, 0x8CBF, 0x8CB8, 0x8D8A,
0x8D85, 0x8D81, 0x8DCE, 0x8DDD, 0x8DCB, 0x8DDA, 0x8DD1, 0x8DCC,
0x8DDB, 0x8DC6, 0x8EFB, 0x8EF8, 0x8EFC, 0x8F9C, 0x902E, 0x9035,
0x9031, 0x9038, 0x9032, 0x9036, 0x9102, 0x90F5, 0x9109, 0x90FE,
0x9163, 0x9165, 0x91CF, 0x9214, 0x9215, 0x9223, 0x9209, 0x921E,
0x920D, 0x9210, 0x9207, 0x9211, 0x9594, 0x958F, 0x958B, 0x9591,
0x9593, 0x9592, 0x958E, 0x968A, 0x968E, 0x968B, 0x967D, 0x9685,
0x9686, 0x968D, 0x9672, 0x9684, 0x96C1, 0x96C5, 0x96C4, 0x96C6,
0x96C7, 0x96EF, 0x96F2, 0x97CC, 0x9805, 0x9806, 0x9808, 0x98E7,
0x98EA, 0x98EF, 0x98E9, 0x98F2, 0x98ED, 0x99AE, 0x99AD, 0x9EC3,
0x9ECD, 0x9ED1, 0x4E82, 0x50AD, 0x50B5, 0x50B2, 0x50B3, 0x50C5,
0x50BE, 0x50AC, 0x50B7, 0x50BB, 0x50AF, 0x50C7, 0x527F, 0x5277,
0x527D, 0x52DF, 0x52E6, 0x52E4, 0x52E2, 0x52E3, 0x532F, 0x55DF,
0x55E8, 0x55D3, 0x55E6, 0x55CE, 0x55DC, 0x55C7, 0x55D1, 0x55E3,
0x55E4, 0x55EF, 0x55DA, 0x55E1, 0x55C5, 0x55C6, 0x55E5, 0x55C9,
0x5712, 0x5713, 0x585E, 0x5851, 0x5858, 0x5857, 0x585A, 0x5854,
0x586B, 0x584C, 0x586D, 0x584A, 0x5862, 0x5852, 0x584B, 0x5967,
0x5AC1, 0x5AC9, 0x5ACC, 0x5ABE, 0x5ABD, 0x5ABC, 0x5AB3, 0x5AC2,
0x5AB2, 0x5D69, 0x5D6F, 0x5E4C, 0x5E79, 0x5EC9, 0x5EC8, 0x5F12,
0x5F59, 0x5FAC, 0x5FAE, 0x611A, 0x610F, 0x6148, 0x611F, 0x60F3,
0x611B, 0x60F9, 0x6101, 0x6108, 0x614E, 0x614C, 0x6144, 0x614D,
0x613E, 0x6134, 0x6127, 0x610D, 0x6106, 0x6137, 0x6221, 0x6222,
0x6413, 0x643E, 0x641E, 0x642A, 0x642D, 0x643D, 0x642C, 0x640F,
0x641C, 0x6414, 0x640D, 0x6436, 0x6416, 0x6417, 0x6406, 0x656C,
0x659F, 0x65B0, 0x6697, 0x6689, 0x6687, 0x6688, 0x6696, 0x6684,
0x6698, 0x668D, 0x6703, 0x6994, 0x696D, 0x695A, 0x6977, 0x6960,
0x6954, 0x6975, 0x6930, 0x6982, 0x694A, 0x6968, 0x696B, 0x695E,
0x6953, 0x6979, 0x6986, 0x695D, 0x6963, 0x695B, 0x6B47, 0x6B72,
0x6BC0, 0x6BBF, 0x6BD3, 0x6BFD, 0x6EA2, 0x6EAF, 0x6ED3, 0x6EB6,
0x6EC2, 0x6E90, 0x6E9D, 0x6EC7, 0x6EC5, 0x6EA5, 0x6E98, 0x6EBC,
0x6EBA, 0x6EAB, 0x6ED1, 0x6E96, 0x6E9C, 0x6EC4, 0x6ED4, 0x6EAA,
0x6EA7, 0x6EB4, 0x714E, 0x7159, 0x7169, 0x7164, 0x7149, 0x7167,
0x715C, 0x716C, 0x7166, 0x714C, 0x7165, 0x715E, 0x7146, 0x7168,
0x7156, 0x723A, 0x7252, 0x7337, 0x7345, 0x733F, 0x733E, 0x746F,
0x745A, 0x7455, 0x745F, 0x745E, 0x7441, 0x743F, 0x7459, 0x745B,
0x745C, 0x7576, 0x7578, 0x7600, 0x75F0, 0x7601, 0x75F2, 0x75F1,
0x75FA, 0x75FF, 0x75F4, 0x75F3, 0x76DE, 0x76DF, 0x775B, 0x776B,
0x7766, 0x775E, 0x7763, 0x7779, 0x776A, 0x776C, 0x775C, 0x7765,
0x7768, 0x7762, 0x77EE, 0x788E, 0x78B0, 0x7897, 0x7898, 0x788C,
0x7889, 0x787C, 0x7891, 0x7893, 0x787F, 0x797A, 0x797F, 0x7981,
0x842C, 0x79BD, 0x7A1C, 0x7A1A, 0x7A20, 0x7A14, 0x7A1F, 0x7A1E,
0x7A9F, 0x7AA0, 0x7B77, 0x7BC0, 0x7B60, 0x7B6E, 0x7B67, 0x7CB1,
0x7CB3, 0x7CB5, 0x7D93, 0x7D79, 0x7D91, 0x7D81, 0x7D8F, 0x7D5B,
0x7F6E, 0x7F69, 0x7F6A, 0x7F72, 0x7FA9, 0x7FA8, 0x7FA4, 0x8056,
0x8058, 0x8086, 0x8084, 0x8171, 0x8170, 0x8178, 0x8165, 0x816E,
0x8173, 0x816B, 0x8179, 0x817A, 0x8166, 0x8205, 0x8247, 0x8482,
0x8477, 0x843D, 0x8431, 0x8475, 0x8466, 0x846B, 0x8449, 0x846C,
0x845B, 0x843C, 0x8435, 0x8461, 0x8463, 0x8469, 0x846D, 0x8446,
0x865E, 0x865C, 0x865F, 0x86F9, 0x8713, 0x8708, 0x8707, 0x8700,
0x86FE, 0x86FB, 0x8702, 0x8703, 0x8706, 0x870A, 0x8859, 0x88DF,
0x88D4, 0x88D9, 0x88DC, 0x88D8, 0x88DD, 0x88E1, 0x88CA, 0x88D5,
0x88D2, 0x899C, 0x89E3, 0x8A6B, 0x8A72, 0x8A73, 0x8A66, 0x8A69,
0x8A70, 0x8A87, 0x8A7C, 0x8A63, 0x8AA0, 0x8A71, 0x8A85, 0x8A6D,
0x8A62, 0x8A6E, 0x8A6C, 0x8A79, 0x8A7B, 0x8A3E, 0x8A68, 0x8C62,
0x8C8A, 0x8C89, 0x8CCA, 0x8CC7, 0x8CC8, 0x8CC4, 0x8CB2, 0x8CC3,
0x8CC2, 0x8CC5, 0x8DE1, 0x8DDF, 0x8DE8, 0x8DEF, 0x8DF3, 0x8DFA,
0x8DEA, 0x8DE4, 0x8DE6, 0x8EB2, 0x8F03, 0x8F09, 0x8EFE, 0x8F0A,
0x8F9F, 0x8FB2, 0x904B, 0x904A, 0x9053, 0x9042, 0x9054, 0x903C,
0x9055, 0x9050, 0x9047, 0x904F, 0x904E, 0x904D, 0x9051, 0x903E,
0x9041, 0x9112, 0x9117, 0x916C, 0x916A, 0x9169, 0x91C9, 0x9237,
0x9257, 0x9238, 0x923D, 0x9240, 0x923E, 0x925B, 0x924B, 0x9264,
0x9251, 0x9234, 0x9249, 0x924D, 0x9245, 0x9239, 0x923F, 0x925A,
0x9598, 0x9698, 0x9694, 0x9695, 0x96CD, 0x96CB, 0x96C9, 0x96CA,
0x96F7, 0x96FB, 0x96F9, 0x96F6, 0x9756, 0x9774, 0x9776, 0x9810,
0x9811, 0x9813, 0x980A, 0x9812, 0x980C, 0x98FC, 0x98F4, 0x98FD,
0x98FE, 0x99B3, 0x99B1, 0x99B4, 0x9AE1, 0x9CE9, 0x9E82, 0x9F0E,
0x9F13, 0x9F20, 0x50E7, 0x50EE, 0x50E5, 0x50D6, 0x50ED, 0x50DA,
0x50D5, 0x50CF, 0x50D1, 0x50F1, 0x50CE, 0x50E9, 0x5162, 0x51F3,
0x5283, 0x5282, 0x5331, 0x53AD, 0x55FE, 0x5600, 0x561B, 0x5617,
0x55FD, 0x5614, 0x5606, 0x5609, 0x560D, 0x560E, 0x55F7, 0x5616,
0x561F, 0x5608, 0x5610, 0x55F6, 0x5718, 0x5716, 0x5875, 0x587E,
0x5883, 0x5893, 0x588A, 0x5879, 0x5885, 0x587D, 0x58FD, 0x5925,
0x5922, 0x5924, 0x596A, 0x5969, 0x5AE1, 0x5AE6, 0x5AE9, 0x5AD7,
0x5AD6, 0x5AD8, 0x5AE3, 0x5B75, 0x5BDE, 0x5BE7, 0x5BE1, 0x5BE5,
0x5BE6, 0x5BE8, 0x5BE2, 0x5BE4, 0x5BDF, 0x5C0D, 0x5C62, 0x5D84,
0x5D87, 0x5E5B, 0x5E63, 0x5E55, 0x5E57, 0x5E54, 0x5ED3, 0x5ED6,
0x5F0A, 0x5F46, 0x5F70, 0x5FB9, 0x6147, 0x613F, 0x614B, 0x6177,
0x6162, 0x6163, 0x615F, 0x615A, 0x6158, 0x6175, 0x622A, 0x6487,
0x6458, 0x6454, 0x64A4, 0x6478, 0x645F, 0x647A, 0x6451, 0x6467,
0x6434, 0x646D, 0x647B, 0x6572, 0x65A1, 0x65D7, 0x65D6, 0x66A2,
0x66A8, 0x669D, 0x699C, 0x69A8, 0x6995, 0x69C1, 0x69AE, 0x69D3,
0x69CB, 0x699B, 0x69B7, 0x69BB, 0x69AB, 0x69B4, 0x69D0, 0x69CD,
0x69AD, 0x69CC, 0x69A6, 0x69C3, 0x69A3, 0x6B49, 0x6B4C, 0x6C33,
0x6F33, 0x6F14, 0x6EFE, 0x6F13, 0x6EF4, 0x6F29, 0x6F3E, 0x6F20,
0x6F2C, 0x6F0F, 0x6F02, 0x6F22, 0x6EFF, 0x6EEF, 0x6F06, 0x6F31,
0x6F38, 0x6F32, 0x6F23, 0x6F15, 0x6F2B, 0x6F2F, 0x6F88, 0x6F2A,
0x6EEC, 0x6F01, 0x6EF2, 0x6ECC, 0x6EF7, 0x7194, 0x7199, 0x717D,
0x718A, 0x7184, 0x7192, 0x723E, 0x7292, 0x7296, 0x7344, 0x7350,
0x7464, 0x7463, 0x746A, 0x7470, 0x746D, 0x7504, 0x7591, 0x7627,
0x760D, 0x760B, 0x7609, 0x7613, 0x76E1, 0x76E3, 0x7784, 0x777D,
0x777F, 0x7761, 0x78C1, 0x789F, 0x78A7, 0x78B3, 0x78A9, 0x78A3,
0x798E, 0x798F, 0x798D, 0x7A2E, 0x7A31, 0x7AAA, 0x7AA9, 0x7AED,
0x7AEF, 0x7BA1, 0x7B95, 0x7B8B, 0x7B75, 0x7B97, 0x7B9D, 0x7B94,
0x7B8F, 0x7BB8, 0x7B87, 0x7B84, 0x7CB9, 0x7CBD, 0x7CBE, 0x7DBB,
0x7DB0, 0x7D9C, 0x7DBD, 0x7DBE, 0x7DA0, 0x7DCA, 0x7DB4, 0x7DB2,
0x7DB1, 0x7DBA, 0x7DA2, 0x7DBF, 0x7DB5, 0x7DB8, 0x7DAD, 0x7DD2,
0x7DC7, 0x7DAC, 0x7F70, 0x7FE0, 0x7FE1, 0x7FDF, 0x805E, 0x805A,
0x8087, 0x8150, 0x8180, 0x818F, 0x8188, 0x818A, 0x817F, 0x8182,
0x81E7, 0x81FA, 0x8207, 0x8214, 0x821E, 0x824B, 0x84C9, 0x84BF,
0x84C6, 0x84C4, 0x8499, 0x849E, 0x84B2, 0x849C, 0x84CB, 0x84B8,
0x84C0, 0x84D3, 0x8490, 0x84BC, 0x84D1, 0x84CA, 0x873F, 0x871C,
0x873B, 0x8722, 0x8725, 0x8734, 0x8718, 0x8755, 0x8737, 0x8729,
0x88F3, 0x8902, 0x88F4, 0x88F9, 0x88F8, 0x88FD, 0x88E8, 0x891A,
0x88EF, 0x8AA6, 0x8A8C, 0x8A9E, 0x8AA3, 0x8A8D, 0x8AA1, 0x8A93,
0x8AA4, 0x8AAA, 0x8AA5, 0x8AA8, 0x8A98, 0x8A91, 0x8A9A, 0x8AA7,
0x8C6A, 0x8C8D, 0x8C8C, 0x8CD3, 0x8CD1, 0x8CD2, 0x8D6B, 0x8D99,
0x8D95, 0x8DFC, 0x8F14, 0x8F12, 0x8F15, 0x8F13, 0x8FA3, 0x9060,
0x9058, 0x905C, 0x9063, 0x9059, 0x905E, 0x9062, 0x905D, 0x905B,
0x9119, 0x9118, 0x911E, 0x9175, 0x9178, 0x9177, 0x9174, 0x9278,
0x9280, 0x9285, 0x9298, 0x9296, 0x927B, 0x9293, 0x929C, 0x92A8,
0x927C, 0x9291, 0x95A1, 0x95A8, 0x95A9, 0x95A3, 0x95A5, 0x95A4,
0x9699, 0x969C, 0x969B, 0x96CC, 0x96D2, 0x9700, 0x977C, 0x9785,
0x97F6, 0x9817, 0x9818, 0x98AF, 0x98B1, 0x9903, 0x9905, 0x990C,
0x9909, 0x99C1, 0x9AAF, 0x9AB0, 0x9AE6, 0x9B41, 0x9B42, 0x9CF4,
0x9CF6, 0x9CF3, 0x9EBC, 0x9F3B, 0x9F4A, 0x5104, 0x5100, 0x50FB,
0x50F5, 0x50F9, 0x5102, 0x5108, 0x5109, 0x5105, 0x51DC, 0x5287,
0x5288, 0x5289, 0x528D, 0x528A, 0x52F0, 0x53B2, 0x562E, 0x563B,
0x5639, 0x5632, 0x563F, 0x5634, 0x5629, 0x5653, 0x564E, 0x5657,
0x5674, 0x5636, 0x562F, 0x5630, 0x5880, 0x589F, 0x589E, 0x58B3,
0x589C, 0x58AE, 0x58A9, 0x58A6, 0x596D, 0x5B09, 0x5AFB, 0x5B0B,
0x5AF5, 0x5B0C, 0x5B08, 0x5BEE, 0x5BEC, 0x5BE9, 0x5BEB, 0x5C64,
0x5C65, 0x5D9D, 0x5D94, 0x5E62, 0x5E5F, 0x5E61, 0x5EE2, 0x5EDA,
0x5EDF, 0x5EDD, 0x5EE3, 0x5EE0, 0x5F48, 0x5F71, 0x5FB7, 0x5FB5,
0x6176, 0x6167, 0x616E, 0x615D, 0x6155, 0x6182, 0x617C, 0x6170,
0x616B, 0x617E, 0x61A7, 0x6190, 0x61AB, 0x618E, 0x61AC, 0x619A,
0x61A4, 0x6194, 0x61AE, 0x622E, 0x6469, 0x646F, 0x6479, 0x649E,
0x64B2, 0x6488, 0x6490, 0x64B0, 0x64A5, 0x6493, 0x6495, 0x64A9,
0x6492, 0x64AE, 0x64AD, 0x64AB, 0x649A, 0x64AC, 0x6499, 0x64A2,
0x64B3, 0x6575, 0x6577, 0x6578, 0x66AE, 0x66AB, 0x66B4, 0x66B1,
0x6A23, 0x6A1F, 0x69E8, 0x6A01, 0x6A1E, 0x6A19, 0x69FD, 0x6A21,
0x6A13, 0x6A0A, 0x69F3, 0x6A02, 0x6A05, 0x69ED, 0x6A11, 0x6B50,
0x6B4E, 0x6BA4, 0x6BC5, 0x6BC6, 0x6F3F, 0x6F7C, 0x6F84, 0x6F51,
0x6F66, 0x6F54, 0x6F86, 0x6F6D, 0x6F5B, 0x6F78, 0x6F6E, 0x6F8E,
0x6F7A, 0x6F70, 0x6F64, 0x6F97, 0x6F58, 0x6ED5, 0x6F6F, 0x6F60,
0x6F5F, 0x719F, 0x71AC, 0x71B1, 0x71A8, 0x7256, 0x729B, 0x734E,
0x7357, 0x7469, 0x748B, 0x7483, 0x747E, 0x7480, 0x757F, 0x7620,
0x7629, 0x761F, 0x7624, 0x7626, 0x7621, 0x7622, 0x769A, 0x76BA,
0x76E4, 0x778E, 0x7787, 0x778C, 0x7791, 0x778B, 0x78CB, 0x78C5,
0x78BA, 0x78CA, 0x78BE, 0x78D5, 0x78BC, 0x78D0, 0x7A3F, 0x7A3C,
0x7A40, 0x7A3D, 0x7A37, 0x7A3B, 0x7AAF, 0x7AAE, 0x7BAD, 0x7BB1,
0x7BC4, 0x7BB4, 0x7BC6, 0x7BC7, 0x7BC1, 0x7BA0, 0x7BCC, 0x7CCA,
0x7DE0, 0x7DF4, 0x7DEF, 0x7DFB, 0x7DD8, 0x7DEC, 0x7DDD, 0x7DE8,
0x7DE3, 0x7DDA, 0x7DDE, 0x7DE9, 0x7D9E, 0x7DD9, 0x7DF2, 0x7DF9,
0x7F75, 0x7F77, 0x7FAF, 0x7FE9, 0x8026, 0x819B, 0x819C, 0x819D,
0x81A0, 0x819A, 0x8198, 0x8517, 0x853D, 0x851A, 0x84EE, 0x852C,
0x852D, 0x8513, 0x8511, 0x8523, 0x8521, 0x8514, 0x84EC, 0x8525,
0x84FF, 0x8506, 0x8782, 0x8774, 0x8776, 0x8760, 0x8766, 0x8778,
0x8768, 0x8759, 0x8757, 0x874C, 0x8753, 0x885B, 0x885D, 0x8910,
0x8907, 0x8912, 0x8913, 0x8915, 0x890A, 0x8ABC, 0x8AD2, 0x8AC7,
0x8AC4, 0x8A95, 0x8ACB, 0x8AF8, 0x8AB2, 0x8AC9, 0x8AC2, 0x8ABF,
0x8AB0, 0x8AD6, 0x8ACD, 0x8AB6, 0x8AB9, 0x8ADB, 0x8C4C, 0x8C4E,
0x8C6C, 0x8CE0, 0x8CDE, 0x8CE6, 0x8CE4, 0x8CEC, 0x8CED, 0x8CE2,
0x8CE3, 0x8CDC, 0x8CEA, 0x8CE1, 0x8D6D, 0x8D9F, 0x8DA3, 0x8E2B,
0x8E10, 0x8E1D, 0x8E22, 0x8E0F, 0x8E29, 0x8E1F, 0x8E21, 0x8E1E,
0x8EBA, 0x8F1D, 0x8F1B, 0x8F1F, 0x8F29, 0x8F26, 0x8F2A, 0x8F1C,
0x8F1E, 0x8F25, 0x9069, 0x906E, 0x9068, 0x906D, 0x9077, 0x9130,
0x912D, 0x9127, 0x9131, 0x9187, 0x9189, 0x918B, 0x9183, 0x92C5,
0x92BB, 0x92B7, 0x92EA, 0x92AC, 0x92E4, 0x92C1, 0x92B3, 0x92BC,
0x92D2, 0x92C7, 0x92F0, 0x92B2, 0x95AD, 0x95B1, 0x9704, 0x9706,
0x9707, 0x9709, 0x9760, 0x978D, 0x978B, 0x978F, 0x9821, 0x982B,
0x981C, 0x98B3, 0x990A, 0x9913, 0x9912, 0x9918, 0x99DD, 0x99D0,
0x99DF, 0x99DB, 0x99D1, 0x99D5, 0x99D2, 0x99D9, 0x9AB7, 0x9AEE,
0x9AEF, 0x9B27, 0x9B45, 0x9B44, 0x9B77, 0x9B6F, 0x9D06, 0x9D09,
0x9D03, 0x9EA9, 0x9EBE, 0x9ECE, 0x58A8, 0x9F52, 0x5112, 0x5118,
0x5114, 0x5110, 0x5115, 0x5180, 0x51AA, 0x51DD, 0x5291, 0x5293,
0x52F3, 0x5659, 0x566B, 0x5679, 0x5669, 0x5664, 0x5678, 0x566A,
0x5668, 0x5665, 0x5671, 0x566F, 0x566C, 0x5662, 0x5676, 0x58C1,
0x58BE, 0x58C7, 0x58C5, 0x596E, 0x5B1D, 0x5B34, 0x5B78, 0x5BF0,
0x5C0E, 0x5F4A, 0x61B2, 0x6191, 0x61A9, 0x618A, 0x61CD, 0x61B6,
0x61BE, 0x61CA, 0x61C8, 0x6230, 0x64C5, 0x64C1, 0x64CB, 0x64BB,
0x64BC, 0x64DA, 0x64C4, 0x64C7, 0x64C2, 0x64CD, 0x64BF, 0x64D2,
0x64D4, 0x64BE, 0x6574, 0x66C6, 0x66C9, 0x66B9, 0x66C4, 0x66C7,
0x66B8, 0x6A3D, 0x6A38, 0x6A3A, 0x6A59, 0x6A6B, 0x6A58, 0x6A39,
0x6A44, 0x6A62, 0x6A61, 0x6A4B, 0x6A47, 0x6A35, 0x6A5F, 0x6A48,
0x6B59, 0x6B77, 0x6C05, 0x6FC2, 0x6FB1, 0x6FA1, 0x6FC3, 0x6FA4,
0x6FC1, 0x6FA7, 0x6FB3, 0x6FC0, 0x6FB9, 0x6FB6, 0x6FA6, 0x6FA0,
0x6FB4, 0x71BE, 0x71C9, 0x71D0, 0x71D2, 0x71C8, 0x71D5, 0x71B9,
0x71CE, 0x71D9, 0x71DC, 0x71C3, 0x71C4, 0x7368, 0x749C, 0x74A3,
0x7498, 0x749F, 0x749E, 0x74E2, 0x750C, 0x750D, 0x7634, 0x7638,
0x763A, 0x76E7, 0x76E5, 0x77A0, 0x779E, 0x779F, 0x77A5, 0x78E8,
0x78DA, 0x78EC, 0x78E7, 0x79A6, 0x7A4D, 0x7A4E, 0x7A46, 0x7A4C,
0x7A4B, 0x7ABA, 0x7BD9, 0x7C11, 0x7BC9, 0x7BE4, 0x7BDB, 0x7BE1,
0x7BE9, 0x7BE6, 0x7CD5, 0x7CD6, 0x7E0A, 0x7E11, 0x7E08, 0x7E1B,
0x7E23, 0x7E1E, 0x7E1D, 0x7E09, 0x7E10, 0x7F79, 0x7FB2, 0x7FF0,
0x7FF1, 0x7FEE, 0x8028, 0x81B3, 0x81A9, 0x81A8, 0x81FB, 0x8208,
0x8258, 0x8259, 0x854A, 0x8559, 0x8548, 0x8568, 0x8569, 0x8543,
0x8549, 0x856D, 0x856A, 0x855E, 0x8783, 0x879F, 0x879E, 0x87A2,
0x878D, 0x8861, 0x892A, 0x8932, 0x8925, 0x892B, 0x8921, 0x89AA,
0x89A6, 0x8AE6, 0x8AFA, 0x8AEB, 0x8AF1, 0x8B00, 0x8ADC, 0x8AE7,
0x8AEE, 0x8AFE, 0x8B01, 0x8B02, 0x8AF7, 0x8AED, 0x8AF3, 0x8AF6,
0x8AFC, 0x8C6B, 0x8C6D, 0x8C93, 0x8CF4, 0x8E44, 0x8E31, 0x8E34,
0x8E42, 0x8E39, 0x8E35, 0x8F3B, 0x8F2F, 0x8F38, 0x8F33, 0x8FA8,
0x8FA6, 0x9075, 0x9074, 0x9078, 0x9072, 0x907C, 0x907A, 0x9134,
0x9192, 0x9320, 0x9336, 0x92F8, 0x9333, 0x932F, 0x9322, 0x92FC,
0x932B, 0x9304, 0x931A, 0x9310, 0x9326, 0x9321, 0x9315, 0x932E,
0x9319, 0x95BB, 0x96A7, 0x96A8, 0x96AA, 0x96D5, 0x970E, 0x9711,
0x9716, 0x970D, 0x9713, 0x970F, 0x975B, 0x975C, 0x9766, 0x9798,
0x9830, 0x9838, 0x983B, 0x9837, 0x982D, 0x9839, 0x9824, 0x9910,
0x9928, 0x991E, 0x991B, 0x9921, 0x991A, 0x99ED, 0x99E2, 0x99F1,
0x9AB8, 0x9ABC, 0x9AFB, 0x9AED, 0x9B28, 0x9B91, 0x9D15, 0x9D23,
0x9D26, 0x9D28, 0x9D12, 0x9D1B, 0x9ED8, 0x9ED4, 0x9F8D, 0x9F9C,
0x512A, 0x511F, 0x5121, 0x5132, 0x52F5, 0x568E, 0x5680, 0x5690,
0x5685, 0x5687, 0x568F, 0x58D5, 0x58D3, 0x58D1, 0x58CE, 0x5B30,
0x5B2A, 0x5B24, 0x5B7A, 0x5C37, 0x5C68, 0x5DBC, 0x5DBA, 0x5DBD,
0x5DB8, 0x5E6B, 0x5F4C, 0x5FBD, 0x61C9, 0x61C2, 0x61C7, 0x61E6,
0x61CB, 0x6232, 0x6234, 0x64CE, 0x64CA, 0x64D8, 0x64E0, 0x64F0,
0x64E6, 0x64EC, 0x64F1, 0x64E2, 0x64ED, 0x6582, 0x6583, 0x66D9,
0x66D6, 0x6A80, 0x6A94, 0x6A84, 0x6AA2, 0x6A9C, 0x6ADB, 0x6AA3,
0x6A7E, 0x6A97, 0x6A90, 0x6AA0, 0x6B5C, 0x6BAE, 0x6BDA, 0x6C08,
0x6FD8, 0x6FF1, 0x6FDF, 0x6FE0, 0x6FDB, 0x6FE4, 0x6FEB, 0x6FEF,
0x6F80, 0x6FEC, 0x6FE1, 0x6FE9, 0x6FD5, 0x6FEE, 0x6FF0, 0x71E7,
0x71DF, 0x71EE, 0x71E6, 0x71E5, 0x71ED, 0x71EC, 0x71F4, 0x71E0,
0x7235, 0x7246, 0x7370, 0x7372, 0x74A9, 0x74B0, 0x74A6, 0x74A8,
0x7646, 0x7642, 0x764C, 0x76EA, 0x77B3, 0x77AA, 0x77B0, 0x77AC,
0x77A7, 0x77AD, 0x77EF, 0x78F7, 0x78FA, 0x78F4, 0x78EF, 0x7901,
0x79A7, 0x79AA, 0x7A57, 0x7ABF, 0x7C07, 0x7C0D, 0x7BFE, 0x7BF7,
0x7C0C, 0x7BE0, 0x7CE0, 0x7CDC, 0x7CDE, 0x7CE2, 0x7CDF, 0x7CD9,
0x7CDD, 0x7E2E, 0x7E3E, 0x7E46, 0x7E37, 0x7E32, 0x7E43, 0x7E2B,
0x7E3D, 0x7E31, 0x7E45, 0x7E41, 0x7E34, 0x7E39, 0x7E48, 0x7E35,
0x7E3F, 0x7E2F, 0x7F44, 0x7FF3, 0x7FFC, 0x8071, 0x8072, 0x8070,
0x806F, 0x8073, 0x81C6, 0x81C3, 0x81BA, 0x81C2, 0x81C0, 0x81BF,
0x81BD, 0x81C9, 0x81BE, 0x81E8, 0x8209, 0x8271, 0x85AA, 0x8584,
0x857E, 0x859C, 0x8591, 0x8594, 0x85AF, 0x859B, 0x8587, 0x85A8,
0x858A, 0x8667, 0x87C0, 0x87D1, 0x87B3, 0x87D2, 0x87C6, 0x87AB,
0x87BB, 0x87BA, 0x87C8, 0x87CB, 0x893B, 0x8936, 0x8944, 0x8938,
0x893D, 0x89AC, 0x8B0E, 0x8B17, 0x8B19, 0x8B1B, 0x8B0A, 0x8B20,
0x8B1D, 0x8B04, 0x8B10, 0x8C41, 0x8C3F, 0x8C73, 0x8CFA, 0x8CFD,
0x8CFC, 0x8CF8, 0x8CFB, 0x8DA8, 0x8E49, 0x8E4B, 0x8E48, 0x8E4A,
0x8F44, 0x8F3E, 0x8F42, 0x8F45, 0x8F3F, 0x907F, 0x907D, 0x9084,
0x9081, 0x9082, 0x9080, 0x9139, 0x91A3, 0x919E, 0x919C, 0x934D,
0x9382, 0x9328, 0x9375, 0x934A, 0x9365, 0x934B, 0x9318, 0x937E,
0x936C, 0x935B, 0x9370, 0x935A, 0x9354, 0x95CA, 0x95CB, 0x95CC,
0x95C8, 0x95C6, 0x96B1, 0x96B8, 0x96D6, 0x971C, 0x971E, 0x97A0,
0x97D3, 0x9846, 0x98B6, 0x9935, 0x9A01, 0x99FF, 0x9BAE, 0x9BAB,
0x9BAA, 0x9BAD, 0x9D3B, 0x9D3F, 0x9E8B, 0x9ECF, 0x9EDE, 0x9EDC,
0x9EDD, 0x9EDB, 0x9F3E, 0x9F4B, 0x53E2, 0x5695, 0x56AE, 0x58D9,
0x58D8, 0x5B38, 0x5F5D, 0x61E3, 0x6233, 0x64F4, 0x64F2, 0x64FE,
0x6506, 0x64FA, 0x64FB, 0x64F7, 0x65B7, 0x66DC, 0x6726, 0x6AB3,
0x6AAC, 0x6AC3, 0x6ABB, 0x6AB8, 0x6AC2, 0x6AAE, 0x6AAF, 0x6B5F,
0x6B78, 0x6BAF, 0x7009, 0x700B, 0x6FFE, 0x7006, 0x6FFA, 0x7011,
0x700F, 0x71FB, 0x71FC, 0x71FE, 0x71F8, 0x7377, 0x7375, 0x74A7,
0x74BF, 0x7515, 0x7656, 0x7658, 0x7652, 0x77BD, 0x77BF, 0x77BB,
0x77BC, 0x790E, 0x79AE, 0x7A61, 0x7A62, 0x7A60, 0x7AC4, 0x7AC5,
0x7C2B, 0x7C27, 0x7C2A, 0x7C1E, 0x7C23, 0x7C21, 0x7CE7, 0x7E54,
0x7E55, 0x7E5E, 0x7E5A, 0x7E61, 0x7E52, 0x7E59, 0x7F48, 0x7FF9,
0x7FFB, 0x8077, 0x8076, 0x81CD, 0x81CF, 0x820A, 0x85CF, 0x85A9,
0x85CD, 0x85D0, 0x85C9, 0x85B0, 0x85BA, 0x85B9, 0x85A6, 0x87EF,
0x87EC, 0x87F2, 0x87E0, 0x8986, 0x89B2, 0x89F4, 0x8B28, 0x8B39,
0x8B2C, 0x8B2B, 0x8C50, 0x8D05, 0x8E59, 0x8E63, 0x8E66, 0x8E64,
0x8E5F, 0x8E55, 0x8EC0, 0x8F49, 0x8F4D, 0x9087, 0x9083, 0x9088,
0x91AB, 0x91AC, 0x91D0, 0x9394, 0x938A, 0x9396, 0x93A2, 0x93B3,
0x93AE, 0x93AC, 0x93B0, 0x9398, 0x939A, 0x9397, 0x95D4, 0x95D6,
0x95D0, 0x95D5, 0x96E2, 0x96DC, 0x96D9, 0x96DB, 0x96DE, 0x9724,
0x97A3, 0x97A6, 0x97AD, 0x97F9, 0x984D, 0x984F, 0x984C, 0x984E,
0x9853, 0x98BA, 0x993E, 0x993F, 0x993D, 0x992E, 0x99A5, 0x9A0E,
0x9AC1, 0x9B03, 0x9B06, 0x9B4F, 0x9B4E, 0x9B4D, 0x9BCA, 0x9BC9,
0x9BFD, 0x9BC8, 0x9BC0, 0x9D51, 0x9D5D, 0x9D60, 0x9EE0, 0x9F15,
0x9F2C, 0x5133, 0x56A5, 0x58DE, 0x58DF, 0x58E2, 0x5BF5, 0x9F90,
0x5EEC, 0x61F2, 0x61F7, 0x61F6, 0x61F5, 0x6500, 0x650F, 0x66E0,
0x66DD, 0x6AE5, 0x6ADD, 0x6ADA, 0x6AD3, 0x701B, 0x701F, 0x7028,
0x701A, 0x701D, 0x7015, 0x7018, 0x7206, 0x720D, 0x7258, 0x72A2,
0x7378, 0x737A, 0x74BD, 0x74CA, 0x74E3, 0x7587, 0x7586, 0x765F,
0x7661, 0x77C7, 0x7919, 0x79B1, 0x7A6B, 0x7A69, 0x7C3E, 0x7C3F,
0x7C38, 0x7C3D, 0x7C37, 0x7C40, 0x7E6B, 0x7E6D, 0x7E79, 0x7E69,
0x7E6A, 0x7F85, 0x7E73, 0x7FB6, 0x7FB9, 0x7FB8, 0x81D8, 0x85E9,
0x85DD, 0x85EA, 0x85D5, 0x85E4, 0x85E5, 0x85F7, 0x87FB, 0x8805,
0x880D, 0x87F9, 0x87FE, 0x8960, 0x895F, 0x8956, 0x895E, 0x8B41,
0x8B5C, 0x8B58, 0x8B49, 0x8B5A, 0x8B4E, 0x8B4F, 0x8B46, 0x8B59,
0x8D08, 0x8D0A, 0x8E7C, 0x8E72, 0x8E87, 0x8E76, 0x8E6C, 0x8E7A,
0x8E74, 0x8F54, 0x8F4E, 0x8FAD, 0x908A, 0x908B, 0x91B1, 0x91AE,
0x93E1, 0x93D1, 0x93DF, 0x93C3, 0x93C8, 0x93DC, 0x93DD, 0x93D6,
0x93E2, 0x93CD, 0x93D8, 0x93E4, 0x93D7, 0x93E8, 0x95DC, 0x96B4,
0x96E3, 0x972A, 0x9727, 0x9761, 0x97DC, 0x97FB, 0x985E, 0x9858,
0x985B, 0x98BC, 0x9945, 0x9949, 0x9A16, 0x9A19, 0x9B0D, 0x9BE8,
0x9BE7, 0x9BD6, 0x9BDB, 0x9D89, 0x9D61, 0x9D72, 0x9D6A, 0x9D6C,
0x9E92, 0x9E97, 0x9E93, 0x9EB4, 0x52F8, 0x56A8, 0x56B7, 0x56B6,
0x56B4, 0x56BC, 0x58E4, 0x5B40, 0x5B43, 0x5B7D, 0x5BF6, 0x5DC9,
0x61F8, 0x61FA, 0x6518, 0x6514, 0x6519, 0x66E6, 0x6727, 0x6AEC,
0x703E, 0x7030, 0x7032, 0x7210, 0x737B, 0x74CF, 0x7662, 0x7665,
0x7926, 0x792A, 0x792C, 0x792B, 0x7AC7, 0x7AF6, 0x7C4C, 0x7C43,
0x7C4D, 0x7CEF, 0x7CF0, 0x8FAE, 0x7E7D, 0x7E7C, 0x7E82, 0x7F4C,
0x8000, 0x81DA, 0x8266, 0x85FB, 0x85F9, 0x8611, 0x85FA, 0x8606,
0x860B, 0x8607, 0x860A, 0x8814, 0x8815, 0x8964, 0x89BA, 0x89F8,
0x8B70, 0x8B6C, 0x8B66, 0x8B6F, 0x8B5F, 0x8B6B, 0x8D0F, 0x8D0D,
0x8E89, 0x8E81, 0x8E85, 0x8E82, 0x91B4, 0x91CB, 0x9418, 0x9403,
0x93FD, 0x95E1, 0x9730, 0x98C4, 0x9952, 0x9951, 0x99A8, 0x9A2B,
0x9A30, 0x9A37, 0x9A35, 0x9C13, 0x9C0D, 0x9E79, 0x9EB5, 0x9EE8,
0x9F2F, 0x9F5F, 0x9F63, 0x9F61, 0x5137, 0x5138, 0x56C1, 0x56C0,
0x56C2, 0x5914, 0x5C6C, 0x5DCD, 0x61FC, 0x61FE, 0x651D, 0x651C,
0x6595, 0x66E9, 0x6AFB, 0x6B04, 0x6AFA, 0x6BB2, 0x704C, 0x721B,
0x72A7, 0x74D6, 0x74D4, 0x7669, 0x77D3, 0x7C50, 0x7E8F, 0x7E8C,
0x7FBC, 0x8617, 0x862D, 0x861A, 0x8823, 0x8822, 0x8821, 0x881F,
0x896A, 0x896C, 0x89BD, 0x8B74, 0x8B77, 0x8B7D, 0x8D13, 0x8E8A,
0x8E8D, 0x8E8B, 0x8F5F, 0x8FAF, 0x91BA, 0x942E, 0x9433, 0x9435,
0x943A, 0x9438, 0x9432, 0x942B, 0x95E2, 0x9738, 0x9739, 0x9732,
0x97FF, 0x9867, 0x9865, 0x9957, 0x9A45, 0x9A43, 0x9A40, 0x9A3E,
0x9ACF, 0x9B54, 0x9B51, 0x9C2D, 0x9C25, 0x9DAF, 0x9DB4, 0x9DC2,
0x9DB8, 0x9E9D, 0x9EEF, 0x9F19, 0x9F5C, 0x9F66, 0x9F67, 0x513C,
0x513B, 0x56C8, 0x56CA, 0x56C9, 0x5B7F, 0x5DD4, 0x5DD2, 0x5F4E,
0x61FF, 0x6524, 0x6B0A, 0x6B61, 0x7051, 0x7058, 0x7380, 0x74E4,
0x758A, 0x766E, 0x766C, 0x79B3, 0x7C60, 0x7C5F, 0x807E, 0x807D,
0x81DF, 0x8972, 0x896F, 0x89FC, 0x8B80, 0x8D16, 0x8D17, 0x8E91,
0x8E93, 0x8F61, 0x9148, 0x9444, 0x9451, 0x9452, 0x973D, 0x973E,
0x97C3, 0x97C1, 0x986B, 0x9955, 0x9A55, 0x9A4D, 0x9AD2, 0x9B1A,
0x9C49, 0x9C31, 0x9C3E, 0x9C3B, 0x9DD3, 0x9DD7, 0x9F34, 0x9F6C,
0x9F6A, 0x9F94, 0x56CC, 0x5DD6, 0x6200, 0x6523, 0x652B, 0x652A,
0x66EC, 0x6B10, 0x74DA, 0x7ACA, 0x7C64, 0x7C63, 0x7C65, 0x7E93,
0x7E96, 0x7E94, 0x81E2, 0x8638, 0x863F, 0x8831, 0x8B8A, 0x9090,
0x908F, 0x9463, 0x9460, 0x9464, 0x9768, 0x986F, 0x995C, 0x9A5A,
0x9A5B, 0x9A57, 0x9AD3, 0x9AD4, 0x9AD1, 0x9C54, 0x9C57, 0x9C56,
0x9DE5, 0x9E9F, 0x9EF4, 0x56D1, 0x58E9, 0x652C, 0x705E, 0x7671,
0x7672, 0x77D7, 0x7F50, 0x7F88, 0x8836, 0x8839, 0x8862, 0x8B93,
0x8B92, 0x8B96, 0x8277, 0x8D1B, 0x91C0, 0x946A, 0x9742, 0x9748,
0x9744, 0x97C6, 0x9870, 0x9A5F, 0x9B22, 0x9B58, 0x9C5F, 0x9DF9,
0x9DFA, 0x9E7C, 0x9E7D, 0x9F07, 0x9F77, 0x9F72, 0x5EF3, 0x6B16,
0x7063, 0x7C6C, 0x7C6E, 0x883B, 0x89C0, 0x8EA1, 0x91C1, 0x9472,
0x9470, 0x9871, 0x995E, 0x9AD6, 0x9B23, 0x9ECC, 0x7064, 0x77DA,
0x8B9A, 0x9477, 0x97C9, 0x9A62, 0x9A65, 0x7E9C, 0x8B9C, 0x8EAA,
0x91C5, 0x947D, 0x947E, 0x947C, 0x9C77, 0x9C78, 0x9EF7, 0x8C54,
0x947F, 0x9E1A, 0x7228, 0x9A6A, 0x9B31, 0x9E1B, 0x9E1E, 0x7C72,
0x30FE, 0x309D, 0x309E, 0x3005, 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, 0x0414, 0x0415, 0x0401,
0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x0423,
0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B,
0x042C, 0x042D, 0x042E, 0x042F, 0x0430, 0x0431, 0x0432, 0x0433,
0x0434, 0x0435, 0x0451, 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, 0x2460, 0x2461, 0x2462,
0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469, 0x2474,
0x2475, 0x2476, 0x2477, 0x2478, 0x2479, 0x247A, 0x247B, 0x247C,
0x247D, 0x0000, 0x0000, 0x4E42, 0x4E5C, 0x51F5, 0x531A, 0x5382,
0x4E07, 0x4E0C, 0x4E47, 0x4E8D, 0x56D7, 0xFA0C, 0x5C6E, 0x5F73,
0x4E0F, 0x5187, 0x4E0E, 0x4E2E, 0x4E93, 0x4EC2, 0x4EC9, 0x4EC8,
0x5198, 0x52FC, 0x536C, 0x53B9, 0x5720, 0x5903, 0x592C, 0x5C10,
0x5DFF, 0x65E1, 0x6BB3, 0x6BCC, 0x6C14, 0x723F, 0x4E31, 0x4E3C,
0x4EE8, 0x4EDC, 0x4EE9, 0x4EE1, 0x4EDD, 0x4EDA, 0x520C, 0x531C,
0x534C, 0x5722, 0x5723, 0x5917, 0x592F, 0x5B81, 0x5B84, 0x5C12,
0x5C3B, 0x5C74, 0x5C73, 0x5E04, 0x5E80, 0x5E82, 0x5FC9, 0x6209,
0x6250, 0x6C15, 0x6C36, 0x6C43, 0x6C3F, 0x6C3B, 0x72AE, 0x72B0,
0x738A, 0x79B8, 0x808A, 0x961E, 0x4F0E, 0x4F18, 0x4F2C, 0x4EF5,
0x4F14, 0x4EF1, 0x4F00, 0x4EF7, 0x4F08, 0x4F1D, 0x4F02, 0x4F05,
0x4F22, 0x4F13, 0x4F04, 0x4EF4, 0x4F12, 0x51B1, 0x5213, 0x5209,
0x5210, 0x52A6, 0x5322, 0x531F, 0x534D, 0x538A, 0x5407, 0x56E1,
0x56DF, 0x572E, 0x572A, 0x5734, 0x593C, 0x5980, 0x597C, 0x5985,
0x597B, 0x597E, 0x5977, 0x597F, 0x5B56, 0x5C15, 0x5C25, 0x5C7C,
0x5C7A, 0x5C7B, 0x5C7E, 0x5DDF, 0x5E75, 0x5E84, 0x5F02, 0x5F1A,
0x5F74, 0x5FD5, 0x5FD4, 0x5FCF, 0x625C, 0x625E, 0x6264, 0x6261,
0x6266, 0x6262, 0x6259, 0x6260, 0x625A, 0x6265, 0x65EF, 0x65EE,
0x673E, 0x6739, 0x6738, 0x673B, 0x673A, 0x673F, 0x673C, 0x6733,
0x6C18, 0x6C46, 0x6C52, 0x6C5C, 0x6C4F, 0x6C4A, 0x6C54, 0x6C4B,
0x6C4C, 0x7071, 0x725E, 0x72B4, 0x72B5, 0x738E, 0x752A, 0x767F,
0x7A75, 0x7F51, 0x8278, 0x827C, 0x8280, 0x827D, 0x827F, 0x864D,
0x897E, 0x9099, 0x9097, 0x9098, 0x909B, 0x9094, 0x9622, 0x9624,
0x9620, 0x9623, 0x4F56, 0x4F3B, 0x4F62, 0x4F49, 0x4F53, 0x4F64,
0x4F3E, 0x4F67, 0x4F52, 0x4F5F, 0x4F41, 0x4F58, 0x4F2D, 0x4F33,
0x4F3F, 0x4F61, 0x518F, 0x51B9, 0x521C, 0x521E, 0x5221, 0x52AD,
0x52AE, 0x5309, 0x5363, 0x5372, 0x538E, 0x538F, 0x5430, 0x5437,
0x542A, 0x5454, 0x5445, 0x5419, 0x541C, 0x5425, 0x5418, 0x543D,
0x544F, 0x5441, 0x5428, 0x5424, 0x5447, 0x56EE, 0x56E7, 0x56E5,
0x5741, 0x5745, 0x574C, 0x5749, 0x574B, 0x5752, 0x5906, 0x5940,
0x59A6, 0x5998, 0x59A0, 0x5997, 0x598E, 0x59A2, 0x5990, 0x598F,
0x59A7, 0x59A1, 0x5B8E, 0x5B92, 0x5C28, 0x5C2A, 0x5C8D, 0x5C8F,
0x5C88, 0x5C8B, 0x5C89, 0x5C92, 0x5C8A, 0x5C86, 0x5C93, 0x5C95,
0x5DE0, 0x5E0A, 0x5E0E, 0x5E8B, 0x5E89, 0x5E8C, 0x5E88, 0x5E8D,
0x5F05, 0x5F1D, 0x5F78, 0x5F76, 0x5FD2, 0x5FD1, 0x5FD0, 0x5FED,
0x5FE8, 0x5FEE, 0x5FF3, 0x5FE1, 0x5FE4, 0x5FE3, 0x5FFA, 0x5FEF,
0x5FF7, 0x5FFB, 0x6000, 0x5FF4, 0x623A, 0x6283, 0x628C, 0x628E,
0x628F, 0x6294, 0x6287, 0x6271, 0x627B, 0x627A, 0x6270, 0x6281,
0x6288, 0x6277, 0x627D, 0x6272, 0x6274, 0x6537, 0x65F0, 0x65F4,
0x65F3, 0x65F2, 0x65F5, 0x6745, 0x6747, 0x6759, 0x6755, 0x674C,
0x6748, 0x675D, 0x674D, 0x675A, 0x674B, 0x6BD0, 0x6C19, 0x6C1A,
0x6C78, 0x6C67, 0x6C6B, 0x6C84, 0x6C8B, 0x6C8F, 0x6C71, 0x6C6F,
0x6C69, 0x6C9A, 0x6C6D, 0x6C87, 0x6C95, 0x6C9C, 0x6C66, 0x6C73,
0x6C65, 0x6C7B, 0x6C8E, 0x7074, 0x707A, 0x7263, 0x72BF, 0x72BD,
0x72C3, 0x72C6, 0x72C1, 0x72BA, 0x72C5, 0x7395, 0x7397, 0x7393,
0x7394, 0x7392, 0x753A, 0x7539, 0x7594, 0x7595, 0x7681, 0x793D,
0x8034, 0x8095, 0x8099, 0x8090, 0x8092, 0x809C, 0x8290, 0x828F,
0x8285, 0x828E, 0x8291, 0x8293, 0x828A, 0x8283, 0x8284, 0x8C78,
0x8FC9, 0x8FBF, 0x909F, 0x90A1, 0x90A5, 0x909E, 0x90A7, 0x90A0,
0x9630, 0x9628, 0x962F, 0x962D, 0x4E33, 0x4F98, 0x4F7C, 0x4F85,
0x4F7D, 0x4F80, 0x4F87, 0x4F76, 0x4F74, 0x4F89, 0x4F84, 0x4F77,
0x4F4C, 0x4F97, 0x4F6A, 0x4F9A, 0x4F79, 0x4F81, 0x4F78, 0x4F90,
0x4F9C, 0x4F94, 0x4F9E, 0x4F92, 0x4F82, 0x4F95, 0x4F6B, 0x4F6E,
0x519E, 0x51BC, 0x51BE, 0x5235, 0x5232, 0x5233, 0x5246, 0x5231,
0x52BC, 0x530A, 0x530B, 0x533C, 0x5392, 0x5394, 0x5487, 0x547F,
0x5481, 0x5491, 0x5482, 0x5488, 0x546B, 0x547A, 0x547E, 0x5465,
0x546C, 0x5474, 0x5466, 0x548D, 0x546F, 0x5461, 0x5460, 0x5498,
0x5463, 0x5467, 0x5464, 0x56F7, 0x56F9, 0x576F, 0x5772, 0x576D,
0x576B, 0x5771, 0x5770, 0x5776, 0x5780, 0x5775, 0x577B, 0x5773,
0x5774, 0x5762, 0x5768, 0x577D, 0x590C, 0x5945, 0x59B5, 0x59BA,
0x59CF, 0x59CE, 0x59B2, 0x59CC, 0x59C1, 0x59B6, 0x59BC, 0x59C3,
0x59D6, 0x59B1, 0x59BD, 0x59C0, 0x59C8, 0x59B4, 0x59C7, 0x5B62,
0x5B65, 0x5B93, 0x5B95, 0x5C44, 0x5C47, 0x5CAE, 0x5CA4, 0x5CA0,
0x5CB5, 0x5CAF, 0x5CA8, 0x5CAC, 0x5C9F, 0x5CA3, 0x5CAD, 0x5CA2,
0x5CAA, 0x5CA7, 0x5C9D, 0x5CA5, 0x5CB6, 0x5CB0, 0x5CA6, 0x5E17,
0x5E14, 0x5E19, 0x5F28, 0x5F22, 0x5F23, 0x5F24, 0x5F54, 0x5F82,
0x5F7E, 0x5F7D, 0x5FDE, 0x5FE5, 0x602D, 0x6026, 0x6019, 0x6032,
0x600B, 0x6034, 0x600A, 0x6017, 0x6033, 0x601A, 0x601E, 0x602C,
0x6022, 0x600D, 0x6010, 0x602E, 0x6013, 0x6011, 0x600C, 0x6009,
0x601C, 0x6214, 0x623D, 0x62AD, 0x62B4, 0x62D1, 0x62BE, 0x62AA,
0x62B6, 0x62CA, 0x62AE, 0x62B3, 0x62AF, 0x62BB, 0x62A9, 0x62B0,
0x62B8, 0x653D, 0x65A8, 0x65BB, 0x6609, 0x65FC, 0x6604, 0x6612,
0x6608, 0x65FB, 0x6603, 0x660B, 0x660D, 0x6605, 0x65FD, 0x6611,
0x6610, 0x66F6, 0x670A, 0x6785, 0x676C, 0x678E, 0x6792, 0x6776,
0x677B, 0x6798, 0x6786, 0x6784, 0x6774, 0x678D, 0x678C, 0x677A,
0x679F, 0x6791, 0x6799, 0x6783, 0x677D, 0x6781, 0x6778, 0x6779,
0x6794, 0x6B25, 0x6B80, 0x6B7E, 0x6BDE, 0x6C1D, 0x6C93, 0x6CEC,
0x6CEB, 0x6CEE, 0x6CD9, 0x6CB6, 0x6CD4, 0x6CAD, 0x6CE7, 0x6CB7,
0x6CD0, 0x6CC2, 0x6CBA, 0x6CC3, 0x6CC6, 0x6CED, 0x6CF2, 0x6CD2,
0x6CDD, 0x6CB4, 0x6C8A, 0x6C9D, 0x6C80, 0x6CDE, 0x6CC0, 0x6D30,
0x6CCD, 0x6CC7, 0x6CB0, 0x6CF9, 0x6CCF, 0x6CE9, 0x6CD1, 0x7094,
0x7098, 0x7085, 0x7093, 0x7086, 0x7084, 0x7091, 0x7096, 0x7082,
0x709A, 0x7083, 0x726A, 0x72D6, 0x72CB, 0x72D8, 0x72C9, 0x72DC,
0x72D2, 0x72D4, 0x72DA, 0x72CC, 0x72D1, 0x73A4, 0x73A1, 0x73AD,
0x73A6, 0x73A2, 0x73A0, 0x73AC, 0x739D, 0x74DD, 0x74E8, 0x753F,
0x7540, 0x753E, 0x758C, 0x7598, 0x76AF, 0x76F3, 0x76F1, 0x76F0,
0x76F5, 0x77F8, 0x77FC, 0x77F9, 0x77FB, 0x77FA, 0x77F7, 0x7942,
0x793F, 0x79C5, 0x7A78, 0x7A7B, 0x7AFB, 0x7C75, 0x7CFD, 0x8035,
0x808F, 0x80AE, 0x80A3, 0x80B8, 0x80B5, 0x80AD, 0x8220, 0x82A0,
0x82C0, 0x82AB, 0x829A, 0x8298, 0x829B, 0x82B5, 0x82A7, 0x82AE,
0x82BC, 0x829E, 0x82BA, 0x82B4, 0x82A8, 0x82A1, 0x82A9, 0x82C2,
0x82A4, 0x82C3, 0x82B6, 0x82A2, 0x8670, 0x866F, 0x866D, 0x866E,
0x8C56, 0x8FD2, 0x8FCB, 0x8FD3, 0x8FCD, 0x8FD6, 0x8FD5, 0x8FD7,
0x90B2, 0x90B4, 0x90AF, 0x90B3, 0x90B0, 0x9639, 0x963D, 0x963C,
0x963A, 0x9643, 0x4FCD, 0x4FC5, 0x4FD3, 0x4FB2, 0x4FC9, 0x4FCB,
0x4FC1, 0x4FD4, 0x4FDC, 0x4FD9, 0x4FBB, 0x4FB3, 0x4FDB, 0x4FC7,
0x4FD6, 0x4FBA, 0x4FC0, 0x4FB9, 0x4FEC, 0x5244, 0x5249, 0x52C0,
0x52C2, 0x533D, 0x537C, 0x5397, 0x5396, 0x5399, 0x5398, 0x54BA,
0x54A1, 0x54AD, 0x54A5, 0x54CF, 0x54C3, 0x830D, 0x54B7, 0x54AE,
0x54D6, 0x54B6, 0x54C5, 0x54C6, 0x54A0, 0x5470, 0x54BC, 0x54A2,
0x54BE, 0x5472, 0x54DE, 0x54B0, 0x57B5, 0x579E, 0x579F, 0x57A4,
0x578C, 0x5797, 0x579D, 0x579B, 0x5794, 0x5798, 0x578F, 0x5799,
0x57A5, 0x579A, 0x5795, 0x58F4, 0x590D, 0x5953, 0x59E1, 0x59DE,
0x59EE, 0x5A00, 0x59F1, 0x59DD, 0x59FA, 0x59FD, 0x59FC, 0x59F6,
0x59E4, 0x59F2, 0x59F7, 0x59DB, 0x59E9, 0x59F3, 0x59F5, 0x59E0,
0x59FE, 0x59F4, 0x59ED, 0x5BA8, 0x5C4C, 0x5CD0, 0x5CD8, 0x5CCC,
0x5CD7, 0x5CCB, 0x5CDB, 0x5CDE, 0x5CDA, 0x5CC9, 0x5CC7, 0x5CCA,
0x5CD6, 0x5CD3, 0x5CD4, 0x5CCF, 0x5CC8, 0x5CC6, 0x5CCE, 0x5CDF,
0x5CF8, 0x5DF9, 0x5E21, 0x5E22, 0x5E23, 0x5E20, 0x5E24, 0x5EB0,
0x5EA4, 0x5EA2, 0x5E9B, 0x5EA3, 0x5EA5, 0x5F07, 0x5F2E, 0x5F56,
0x5F86, 0x6037, 0x6039, 0x6054, 0x6072, 0x605E, 0x6045, 0x6053,
0x6047, 0x6049, 0x605B, 0x604C, 0x6040, 0x6042, 0x605F, 0x6024,
0x6044, 0x6058, 0x6066, 0x606E, 0x6242, 0x6243, 0x62CF, 0x630D,
0x630B, 0x62F5, 0x630E, 0x6303, 0x62EB, 0x62F9, 0x630F, 0x630C,
0x62F8, 0x62F6, 0x6300, 0x6313, 0x6314, 0x62FA, 0x6315, 0x62FB,
0x62F0, 0x6541, 0x6543, 0x65AA, 0x65BF, 0x6636, 0x6621, 0x6632,
0x6635, 0x661C, 0x6626, 0x6622, 0x6633, 0x662B, 0x663A, 0x661D,
0x6634, 0x6639, 0x662E, 0x670F, 0x6710, 0x67C1, 0x67F2, 0x67C8,
0x67BA, 0x67DC, 0x67BB, 0x67F8, 0x67D8, 0x67C0, 0x67B7, 0x67C5,
0x67EB, 0x67E4, 0x67DF, 0x67B5, 0x67CD, 0x67B3, 0x67F7, 0x67F6,
0x67EE, 0x67E3, 0x67C2, 0x67B9, 0x67CE, 0x67E7, 0x67F0, 0x67B2,
0x67FC, 0x67C6, 0x67ED, 0x67CC, 0x67AE, 0x67E6, 0x67DB, 0x67FA,
0x67C9, 0x67CA, 0x67C3, 0x67EA, 0x67CB, 0x6B28, 0x6B82, 0x6B84,
0x6BB6, 0x6BD6, 0x6BD8, 0x6BE0, 0x6C20, 0x6C21, 0x6D28, 0x6D34,
0x6D2D, 0x6D1F, 0x6D3C, 0x6D3F, 0x6D12, 0x6D0A, 0x6CDA, 0x6D33,
0x6D04, 0x6D19, 0x6D3A, 0x6D1A, 0x6D11, 0x6D00, 0x6D1D, 0x6D42,
0x6D01, 0x6D18, 0x6D37, 0x6D03, 0x6D0F, 0x6D40, 0x6D07, 0x6D20,
0x6D2C, 0x6D08, 0x6D22, 0x6D09, 0x6D10, 0x70B7, 0x709F, 0x70BE,
0x70B1, 0x70B0, 0x70A1, 0x70B4, 0x70B5, 0x70A9, 0x7241, 0x7249,
0x724A, 0x726C, 0x7270, 0x7273, 0x726E, 0x72CA, 0x72E4, 0x72E8,
0x72EB, 0x72DF, 0x72EA, 0x72E6, 0x72E3, 0x7385, 0x73CC, 0x73C2,
0x73C8, 0x73C5, 0x73B9, 0x73B6, 0x73B5, 0x73B4, 0x73EB, 0x73BF,
0x73C7, 0x73BE, 0x73C3, 0x73C6, 0x73B8, 0x73CB, 0x74EC, 0x74EE,
0x752E, 0x7547, 0x7548, 0x75A7, 0x75AA, 0x7679, 0x76C4, 0x7708,
0x7703, 0x7704, 0x7705, 0x770A, 0x76F7, 0x76FB, 0x76FA, 0x77E7,
0x77E8, 0x7806, 0x7811, 0x7812, 0x7805, 0x7810, 0x780F, 0x780E,
0x7809, 0x7803, 0x7813, 0x794A, 0x794C, 0x794B, 0x7945, 0x7944,
0x79D5, 0x79CD, 0x79CF, 0x79D6, 0x79CE, 0x7A80, 0x7A7E, 0x7AD1,
0x7B00, 0x7B01, 0x7C7A, 0x7C78, 0x7C79, 0x7C7F, 0x7C80, 0x7C81,
0x7D03, 0x7D08, 0x7D01, 0x7F58, 0x7F91, 0x7F8D, 0x7FBE, 0x8007,
0x800E, 0x800F, 0x8014, 0x8037, 0x80D8, 0x80C7, 0x80E0, 0x80D1,
0x80C8, 0x80C2, 0x80D0, 0x80C5, 0x80E3, 0x80D9, 0x80DC, 0x80CA,
0x80D5, 0x80C9, 0x80CF, 0x80D7, 0x80E6, 0x80CD, 0x81FF, 0x8221,
0x8294, 0x82D9, 0x82FE, 0x82F9, 0x8307, 0x82E8, 0x8300, 0x82D5,
0x833A, 0x82EB, 0x82D6, 0x82F4, 0x82EC, 0x82E1, 0x82F2, 0x82F5,
0x830C, 0x82FB, 0x82F6, 0x82F0, 0x82EA, 0x82E4, 0x82E0, 0x82FA,
0x82F3, 0x82ED, 0x8677, 0x8674, 0x867C, 0x8673, 0x8841, 0x884E,
0x8867, 0x886A, 0x8869, 0x89D3, 0x8A04, 0x8A07, 0x8D72, 0x8FE3,
0x8FE1, 0x8FEE, 0x8FE0, 0x90F1, 0x90BD, 0x90BF, 0x90D5, 0x90C5,
0x90BE, 0x90C7, 0x90CB, 0x90C8, 0x91D4, 0x91D3, 0x9654, 0x964F,
0x9651, 0x9653, 0x964A, 0x964E, 0x501E, 0x5005, 0x5007, 0x5013,
0x5022, 0x5030, 0x501B, 0x4FF5, 0x4FF4, 0x5033, 0x5037, 0x502C,
0x4FF6, 0x4FF7, 0x5017, 0x501C, 0x5020, 0x5027, 0x5035, 0x502F,
0x5031, 0x500E, 0x515A, 0x5194, 0x5193, 0x51CA, 0x51C4, 0x51C5,
0x51C8, 0x51CE, 0x5261, 0x525A, 0x5252, 0x525E, 0x525F, 0x5255,
0x5262, 0x52CD, 0x530E, 0x539E, 0x5526, 0x54E2, 0x5517, 0x5512,
0x54E7, 0x54F3, 0x54E4, 0x551A, 0x54FF, 0x5504, 0x5508, 0x54EB,
0x5511, 0x5505, 0x54F1, 0x550A, 0x54FB, 0x54F7, 0x54F8, 0x54E0,
0x550E, 0x5503, 0x550B, 0x5701, 0x5702, 0x57CC, 0x5832, 0x57D5,
0x57D2, 0x57BA, 0x57C6, 0x57BD, 0x57BC, 0x57B8, 0x57B6, 0x57BF,
0x57C7, 0x57D0, 0x57B9, 0x57C1, 0x590E, 0x594A, 0x5A19, 0x5A16,
0x5A2D, 0x5A2E, 0x5A15, 0x5A0F, 0x5A17, 0x5A0A, 0x5A1E, 0x5A33,
0x5B6C, 0x5BA7, 0x5BAD, 0x5BAC, 0x5C03, 0x5C56, 0x5C54, 0x5CEC,
0x5CFF, 0x5CEE, 0x5CF1, 0x5CF7, 0x5D00, 0x5CF9, 0x5E29, 0x5E28,
0x5EA8, 0x5EAE, 0x5EAA, 0x5EAC, 0x5F33, 0x5F30, 0x5F67, 0x605D,
0x605A, 0x6067, 0x6041, 0x60A2, 0x6088, 0x6080, 0x6092, 0x6081,
0x609D, 0x6083, 0x6095, 0x609B, 0x6097, 0x6087, 0x609C, 0x608E,
0x6219, 0x6246, 0x62F2, 0x6310, 0x6356, 0x632C, 0x6344, 0x6345,
0x6336, 0x6343, 0x63E4, 0x6339, 0x634B, 0x634A, 0x633C, 0x6329,
0x6341, 0x6334, 0x6358, 0x6354, 0x6359, 0x632D, 0x6347, 0x6333,
0x635A, 0x6351, 0x6338, 0x6357, 0x6340, 0x6348, 0x654A, 0x6546,
0x65C6, 0x65C3, 0x65C4, 0x65C2, 0x664A, 0x665F, 0x6647, 0x6651,
0x6712, 0x6713, 0x681F, 0x681A, 0x6849, 0x6832, 0x6833, 0x683B,
0x684B, 0x684F, 0x6816, 0x6831, 0x681C, 0x6835, 0x682B, 0x682D,
0x682F, 0x684E, 0x6844, 0x6834, 0x681D, 0x6812, 0x6814, 0x6826,
0x6828, 0x682E, 0x684D, 0x683A, 0x6825, 0x6820, 0x6B2C, 0x6B2F,
0x6B2D, 0x6B31, 0x6B34, 0x6B6D, 0x8082, 0x6B88, 0x6BE6, 0x6BE4,
0x6BE8, 0x6BE3, 0x6BE2, 0x6BE7, 0x6C25, 0x6D7A, 0x6D63, 0x6D64,
0x6D76, 0x6D0D, 0x6D61, 0x6D92, 0x6D58, 0x6D62, 0x6D6D, 0x6D6F,
0x6D91, 0x6D8D, 0x6DEF, 0x6D7F, 0x6D86, 0x6D5E, 0x6D67, 0x6D60,
0x6D97, 0x6D70, 0x6D7C, 0x6D5F, 0x6D82, 0x6D98, 0x6D2F, 0x6D68,
0x6D8B, 0x6D7E, 0x6D80, 0x6D84, 0x6D16, 0x6D83, 0x6D7B, 0x6D7D,
0x6D75, 0x6D90, 0x70DC, 0x70D3, 0x70D1, 0x70DD, 0x70CB, 0x7F39,
0x70E2, 0x70D7, 0x70D2, 0x70DE, 0x70E0, 0x70D4, 0x70CD, 0x70C5,
0x70C6, 0x70C7, 0x70DA, 0x70CE, 0x70E1, 0x7242, 0x7278, 0x7277,
0x7276, 0x7300, 0x72FA, 0x72F4, 0x72FE, 0x72F6, 0x72F3, 0x72FB,
0x7301, 0x73D3, 0x73D9, 0x73E5, 0x73D6, 0x73BC, 0x73E7, 0x73E3,
0x73E9, 0x73DC, 0x73D2, 0x73DB, 0x73D4, 0x73DD, 0x73DA, 0x73D7,
0x73D8, 0x73E8, 0x74DE, 0x74DF, 0x74F4, 0x74F5, 0x7521, 0x755B,
0x755F, 0x75B0, 0x75C1, 0x75BB, 0x75C4, 0x75C0, 0x75BF, 0x75B6,
0x75BA, 0x768A, 0x76C9, 0x771D, 0x771B, 0x7710, 0x7713, 0x7712,
0x7723, 0x7711, 0x7715, 0x7719, 0x771A, 0x7722, 0x7727, 0x7823,
0x782C, 0x7822, 0x7835, 0x782F, 0x7828, 0x782E, 0x782B, 0x7821,
0x7829, 0x7833, 0x782A, 0x7831, 0x7954, 0x795B, 0x794F, 0x795C,
0x7953, 0x7952, 0x7951, 0x79EB, 0x79EC, 0x79E0, 0x79EE, 0x79ED,
0x79EA, 0x79DC, 0x79DE, 0x79DD, 0x7A86, 0x7A89, 0x7A85, 0x7A8B,
0x7A8C, 0x7A8A, 0x7A87, 0x7AD8, 0x7B10, 0x7B04, 0x7B13, 0x7B05,
0x7B0F, 0x7B08, 0x7B0A, 0x7B0E, 0x7B09, 0x7B12, 0x7C84, 0x7C91,
0x7C8A, 0x7C8C, 0x7C88, 0x7C8D, 0x7C85, 0x7D1E, 0x7D1D, 0x7D11,
0x7D0E, 0x7D18, 0x7D16, 0x7D13, 0x7D1F, 0x7D12, 0x7D0F, 0x7D0C,
0x7F5C, 0x7F61, 0x7F5E, 0x7F60, 0x7F5D, 0x7F5B, 0x7F96, 0x7F92,
0x7FC3, 0x7FC2, 0x7FC0, 0x8016, 0x803E, 0x8039, 0x80FA, 0x80F2,
0x80F9, 0x80F5, 0x8101, 0x80FB, 0x8100, 0x8201, 0x822F, 0x8225,
0x8333, 0x832D, 0x8344, 0x8319, 0x8351, 0x8325, 0x8356, 0x833F,
0x8341, 0x8326, 0x831C, 0x8322, 0x8342, 0x834E, 0x831B, 0x832A,
0x8308, 0x833C, 0x834D, 0x8316, 0x8324, 0x8320, 0x8337, 0x832F,
0x8329, 0x8347, 0x8345, 0x834C, 0x8353, 0x831E, 0x832C, 0x834B,
0x8327, 0x8348, 0x8653, 0x8652, 0x86A2, 0x86A8, 0x8696, 0x868D,
0x8691, 0x869E, 0x8687, 0x8697, 0x8686, 0x868B, 0x869A, 0x8685,
0x86A5, 0x8699, 0x86A1, 0x86A7, 0x8695, 0x8698, 0x868E, 0x869D,
0x8690, 0x8694, 0x8843, 0x8844, 0x886D, 0x8875, 0x8876, 0x8872,
0x8880, 0x8871, 0x887F, 0x886F, 0x8883, 0x887E, 0x8874, 0x887C,
0x8A12, 0x8C47, 0x8C57, 0x8C7B, 0x8CA4, 0x8CA3, 0x8D76, 0x8D78,
0x8DB5, 0x8DB7, 0x8DB6, 0x8ED1, 0x8ED3, 0x8FFE, 0x8FF5, 0x9002,
0x8FFF, 0x8FFB, 0x9004, 0x8FFC, 0x8FF6, 0x90D6, 0x90E0, 0x90D9,
0x90DA, 0x90E3, 0x90DF, 0x90E5, 0x90D8, 0x90DB, 0x90D7, 0x90DC,
0x90E4, 0x9150, 0x914E, 0x914F, 0x91D5, 0x91E2, 0x91DA, 0x965C,
0x965F, 0x96BC, 0x98E3, 0x9ADF, 0x9B2F, 0x4E7F, 0x5070, 0x506A,
0x5061, 0x505E, 0x5060, 0x5053, 0x504B, 0x505D, 0x5072, 0x5048,
0x504D, 0x5041, 0x505B, 0x504A, 0x5062, 0x5015, 0x5045, 0x505F,
0x5069, 0x506B, 0x5063, 0x5064, 0x5046, 0x5040, 0x506E, 0x5073,
0x5057, 0x5051, 0x51D0, 0x526B, 0x526D, 0x526C, 0x526E, 0x52D6,
0x52D3, 0x532D, 0x539C, 0x5575, 0x5576, 0x553C, 0x554D, 0x5550,
0x5534, 0x552A, 0x5551, 0x5562, 0x5536, 0x5535, 0x5530, 0x5552,
0x5545, 0x550C, 0x5532, 0x5565, 0x554E, 0x5539, 0x5548, 0x552D,
0x553B, 0x5540, 0x554B, 0x570A, 0x5707, 0x57FB, 0x5814, 0x57E2,
0x57F6, 0x57DC, 0x57F4, 0x5800, 0x57ED, 0x57FD, 0x5808, 0x57F8,
0x580B, 0x57F3, 0x57CF, 0x5807, 0x57EE, 0x57E3, 0x57F2, 0x57E5,
0x57EC, 0x57E1, 0x580E, 0x57FC, 0x5810, 0x57E7, 0x5801, 0x580C,
0x57F1, 0x57E9, 0x57F0, 0x580D, 0x5804, 0x595C, 0x5A60, 0x5A58,
0x5A55, 0x5A67, 0x5A5E, 0x5A38, 0x5A35, 0x5A6D, 0x5A50, 0x5A5F,
0x5A65, 0x5A6C, 0x5A53, 0x5A64, 0x5A57, 0x5A43, 0x5A5D, 0x5A52,
0x5A44, 0x5A5B, 0x5A48, 0x5A8E, 0x5A3E, 0x5A4D, 0x5A39, 0x5A4C,
0x5A70, 0x5A69, 0x5A47, 0x5A51, 0x5A56, 0x5A42, 0x5A5C, 0x5B72,
0x5B6E, 0x5BC1, 0x5BC0, 0x5C59, 0x5D1E, 0x5D0B, 0x5D1D, 0x5D1A,
0x5D20, 0x5D0C, 0x5D28, 0x5D0D, 0x5D26, 0x5D25, 0x5D0F, 0x5D30,
0x5D12, 0x5D23, 0x5D1F, 0x5D2E, 0x5E3E, 0x5E34, 0x5EB1, 0x5EB4,
0x5EB9, 0x5EB2, 0x5EB3, 0x5F36, 0x5F38, 0x5F9B, 0x5F96, 0x5F9F,
0x608A, 0x6090, 0x6086, 0x60BE, 0x60B0, 0x60BA, 0x60D3, 0x60D4,
0x60CF, 0x60E4, 0x60D9, 0x60DD, 0x60C8, 0x60B1, 0x60DB, 0x60B7,
0x60CA, 0x60BF, 0x60C3, 0x60CD, 0x60C0, 0x6332, 0x6365, 0x638A,
0x6382, 0x637D, 0x63BD, 0x639E, 0x63AD, 0x639D, 0x6397, 0x63AB,
0x638E, 0x636F, 0x6387, 0x6390, 0x636E, 0x63AF, 0x6375, 0x639C,
0x636D, 0x63AE, 0x637C, 0x63A4, 0x633B, 0x639F, 0x6378, 0x6385,
0x6381, 0x6391, 0x638D, 0x6370, 0x6553, 0x65CD, 0x6665, 0x6661,
0x665B, 0x6659, 0x665C, 0x6662, 0x6718, 0x6879, 0x6887, 0x6890,
0x689C, 0x686D, 0x686E, 0x68AE, 0x68AB, 0x6956, 0x686F, 0x68A3,
0x68AC, 0x68A9, 0x6875, 0x6874, 0x68B2, 0x688F, 0x6877, 0x6892,
0x687C, 0x686B, 0x6872, 0x68AA, 0x6880, 0x6871, 0x687E, 0x689B,
0x6896, 0x688B, 0x68A0, 0x6889, 0x68A4, 0x6878, 0x687B, 0x6891,
0x688C, 0x688A, 0x687D, 0x6B36, 0x6B33, 0x6B37, 0x6B38, 0x6B91,
0x6B8F, 0x6B8D, 0x6B8E, 0x6B8C, 0x6C2A, 0x6DC0, 0x6DAB, 0x6DB4,
0x6DB3, 0x6E74, 0x6DAC, 0x6DE9, 0x6DE2, 0x6DB7, 0x6DF6, 0x6DD4,
0x6E00, 0x6DC8, 0x6DE0, 0x6DDF, 0x6DD6, 0x6DBE, 0x6DE5, 0x6DDC,
0x6DDD, 0x6DDB, 0x6DF4, 0x6DCA, 0x6DBD, 0x6DED, 0x6DF0, 0x6DBA,
0x6DD5, 0x6DC2, 0x6DCF, 0x6DC9, 0x6DD0, 0x6DF2, 0x6DD3, 0x6DFD,
0x6DD7, 0x6DCD, 0x6DE3, 0x6DBB, 0x70FA, 0x710D, 0x70F7, 0x7117,
0x70F4, 0x710C, 0x70F0, 0x7104, 0x70F3, 0x7110, 0x70FC, 0x70FF,
0x7106, 0x7113, 0x7100, 0x70F8, 0x70F6, 0x710B, 0x7102, 0x710E,
0x727E, 0x727B, 0x727C, 0x727F, 0x731D, 0x7317, 0x7307, 0x7311,
0x7318, 0x730A, 0x7308, 0x72FF, 0x730F, 0x731E, 0x7388, 0x73F6,
0x73F8, 0x73F5, 0x7404, 0x7401, 0x73FD, 0x7407, 0x7400, 0x73FA,
0x73FC, 0x73FF, 0x740C, 0x740B, 0x73F4, 0x7408, 0x7564, 0x7563,
0x75CE, 0x75D2, 0x75CF, 0x75CB, 0x75CC, 0x75D1, 0x75D0, 0x768F,
0x7689, 0x76D3, 0x7739, 0x772F, 0x772D, 0x7731, 0x7732, 0x7734,
0x7733, 0x773D, 0x7725, 0x773B, 0x7735, 0x7848, 0x7852, 0x7849,
0x784D, 0x784A, 0x784C, 0x7826, 0x7845, 0x7850, 0x7964, 0x7967,
0x7969, 0x796A, 0x7963, 0x796B, 0x7961, 0x79BB, 0x79FA, 0x79F8,
0x79F6, 0x79F7, 0x7A8F, 0x7A94, 0x7A90, 0x7B35, 0x7B47, 0x7B34,
0x7B25, 0x7B30, 0x7B22, 0x7B24, 0x7B33, 0x7B18, 0x7B2A, 0x7B1D,
0x7B31, 0x7B2B, 0x7B2D, 0x7B2F, 0x7B32, 0x7B38, 0x7B1A, 0x7B23,
0x7C94, 0x7C98, 0x7C96, 0x7CA3, 0x7D35, 0x7D3D, 0x7D38, 0x7D36,
0x7D3A, 0x7D45, 0x7D2C, 0x7D29, 0x7D41, 0x7D47, 0x7D3E, 0x7D3F,
0x7D4A, 0x7D3B, 0x7D28, 0x7F63, 0x7F95, 0x7F9C, 0x7F9D, 0x7F9B,
0x7FCA, 0x7FCB, 0x7FCD, 0x7FD0, 0x7FD1, 0x7FC7, 0x7FCF, 0x7FC9,
0x801F, 0x801E, 0x801B, 0x8047, 0x8043, 0x8048, 0x8118, 0x8125,
0x8119, 0x811B, 0x812D, 0x811F, 0x812C, 0x811E, 0x8121, 0x8115,
0x8127, 0x811D, 0x8122, 0x8211, 0x8238, 0x8233, 0x823A, 0x8234,
0x8232, 0x8274, 0x8390, 0x83A3, 0x83A8, 0x838D, 0x837A, 0x8373,
0x83A4, 0x8374, 0x838F, 0x8381, 0x8395, 0x8399, 0x8375, 0x8394,
0x83A9, 0x837D, 0x8383, 0x838C, 0x839D, 0x839B, 0x83AA, 0x838B,
0x837E, 0x83A5, 0x83AF, 0x8388, 0x8397, 0x83B0, 0x837F, 0x83A6,
0x8387, 0x83AE, 0x8376, 0x839A, 0x8659, 0x8656, 0x86BF, 0x86B7,
0x86C2, 0x86C1, 0x86C5, 0x86BA, 0x86B0, 0x86C8, 0x86B9, 0x86B3,
0x86B8, 0x86CC, 0x86B4, 0x86BB, 0x86BC, 0x86C3, 0x86BD, 0x86BE,
0x8852, 0x8889, 0x8895, 0x88A8, 0x88A2, 0x88AA, 0x889A, 0x8891,
0x88A1, 0x889F, 0x8898, 0x88A7, 0x8899, 0x889B, 0x8897, 0x88A4,
0x88AC, 0x888C, 0x8893, 0x888E, 0x8982, 0x89D6, 0x89D9, 0x89D5,
0x8A30, 0x8A27, 0x8A2C, 0x8A1E, 0x8C39, 0x8C3B, 0x8C5C, 0x8C5D,
0x8C7D, 0x8CA5, 0x8D7D, 0x8D7B, 0x8D79, 0x8DBC, 0x8DC2, 0x8DB9,
0x8DBF, 0x8DC1, 0x8ED8, 0x8EDE, 0x8EDD, 0x8EDC, 0x8ED7, 0x8EE0,
0x8EE1, 0x9024, 0x900B, 0x9011, 0x901C, 0x900C, 0x9021, 0x90EF,
0x90EA, 0x90F0, 0x90F4, 0x90F2, 0x90F3, 0x90D4, 0x90EB, 0x90EC,
0x90E9, 0x9156, 0x9158, 0x915A, 0x9153, 0x9155, 0x91EC, 0x91F4,
0x91F1, 0x91F3, 0x91F8, 0x91E4, 0x91F9, 0x91EA, 0x91EB, 0x91F7,
0x91E8, 0x91EE, 0x957A, 0x9586, 0x9588, 0x967C, 0x966D, 0x966B,
0x9671, 0x966F, 0x96BF, 0x976A, 0x9804, 0x98E5, 0x9997, 0x509B,
0x5095, 0x5094, 0x509E, 0x508B, 0x50A3, 0x5083, 0x508C, 0x508E,
0x509D, 0x5068, 0x509C, 0x5092, 0x5082, 0x5087, 0x515F, 0x51D4,
0x5312, 0x5311, 0x53A4, 0x53A7, 0x5591, 0x55A8, 0x55A5, 0x55AD,
0x5577, 0x5645, 0x55A2, 0x5593, 0x5588, 0x558F, 0x55B5, 0x5581,
0x55A3, 0x5592, 0x55A4, 0x557D, 0x558C, 0x55A6, 0x557F, 0x5595,
0x55A1, 0x558E, 0x570C, 0x5829, 0x5837, 0x5819, 0x581E, 0x5827,
0x5823, 0x5828, 0x57F5, 0x5848, 0x5825, 0x581C, 0x581B, 0x5833,
0x583F, 0x5836, 0x582E, 0x5839, 0x5838, 0x582D, 0x582C, 0x583B,
0x5961, 0x5AAF, 0x5A94, 0x5A9F, 0x5A7A, 0x5AA2, 0x5A9E, 0x5A78,
0x5AA6, 0x5A7C, 0x5AA5, 0x5AAC, 0x5A95, 0x5AAE, 0x5A37, 0x5A84,
0x5A8A, 0x5A97, 0x5A83, 0x5A8B, 0x5AA9, 0x5A7B, 0x5A7D, 0x5A8C,
0x5A9C, 0x5A8F, 0x5A93, 0x5A9D, 0x5BEA, 0x5BCD, 0x5BCB, 0x5BD4,
0x5BD1, 0x5BCA, 0x5BCE, 0x5C0C, 0x5C30, 0x5D37, 0x5D43, 0x5D6B,
0x5D41, 0x5D4B, 0x5D3F, 0x5D35, 0x5D51, 0x5D4E, 0x5D55, 0x5D33,
0x5D3A, 0x5D52, 0x5D3D, 0x5D31, 0x5D59, 0x5D42, 0x5D39, 0x5D49,
0x5D38, 0x5D3C, 0x5D32, 0x5D36, 0x5D40, 0x5D45, 0x5E44, 0x5E41,
0x5F58, 0x5FA6, 0x5FA5, 0x5FAB, 0x60C9, 0x60B9, 0x60CC, 0x60E2,
0x60CE, 0x60C4, 0x6114, 0x60F2, 0x610A, 0x6116, 0x6105, 0x60F5,
0x6113, 0x60F8, 0x60FC, 0x60FE, 0x60C1, 0x6103, 0x6118, 0x611D,
0x6110, 0x60FF, 0x6104, 0x610B, 0x624A, 0x6394, 0x63B1, 0x63B0,
0x63CE, 0x63E5, 0x63E8, 0x63EF, 0x63C3, 0x649D, 0x63F3, 0x63CA,
0x63E0, 0x63F6, 0x63D5, 0x63F2, 0x63F5, 0x6461, 0x63DF, 0x63BE,
0x63DD, 0x63DC, 0x63C4, 0x63D8, 0x63D3, 0x63C2, 0x63C7, 0x63CC,
0x63CB, 0x63C8, 0x63F0, 0x63D7, 0x63D9, 0x6532, 0x6567, 0x656A,
0x6564, 0x655C, 0x6568, 0x6565, 0x658C, 0x659D, 0x659E, 0x65AE,
0x65D0, 0x65D2, 0x667C, 0x666C, 0x667B, 0x6680, 0x6671, 0x6679,
0x666A, 0x6672, 0x6701, 0x690C, 0x68D3, 0x6904, 0x68DC, 0x692A,
0x68EC, 0x68EA, 0x68F1, 0x690F, 0x68D6, 0x68F7, 0x68EB, 0x68E4,
0x68F6, 0x6913, 0x6910, 0x68F3, 0x68E1, 0x6907, 0x68CC, 0x6908,
0x6970, 0x68B4, 0x6911, 0x68EF, 0x68C6, 0x6914, 0x68F8, 0x68D0,
0x68FD, 0x68FC, 0x68E8, 0x690B, 0x690A, 0x6917, 0x68CE, 0x68C8,
0x68DD, 0x68DE, 0x68E6, 0x68F4, 0x68D1, 0x6906, 0x68D4, 0x68E9,
0x6915, 0x6925, 0x68C7, 0x6B39, 0x6B3B, 0x6B3F, 0x6B3C, 0x6B94,
0x6B97, 0x6B99, 0x6B95, 0x6BBD, 0x6BF0, 0x6BF2, 0x6BF3, 0x6C30,
0x6DFC, 0x6E46, 0x6E47, 0x6E1F, 0x6E49, 0x6E88, 0x6E3C, 0x6E3D,
0x6E45, 0x6E62, 0x6E2B, 0x6E3F, 0x6E41, 0x6E5D, 0x6E73, 0x6E1C,
0x6E33, 0x6E4B, 0x6E40, 0x6E51, 0x6E3B, 0x6E03, 0x6E2E, 0x6E5E,
0x6E68, 0x6E5C, 0x6E61, 0x6E31, 0x6E28, 0x6E60, 0x6E71, 0x6E6B,
0x6E39, 0x6E22, 0x6E30, 0x6E53, 0x6E65, 0x6E27, 0x6E78, 0x6E64,
0x6E77, 0x6E55, 0x6E79, 0x6E52, 0x6E66, 0x6E35, 0x6E36, 0x6E5A,
0x7120, 0x711E, 0x712F, 0x70FB, 0x712E, 0x7131, 0x7123, 0x7125,
0x7122, 0x7132, 0x711F, 0x7128, 0x713A, 0x711B, 0x724B, 0x725A,
0x7288, 0x7289, 0x7286, 0x7285, 0x728B, 0x7312, 0x730B, 0x7330,
0x7322, 0x7331, 0x7333, 0x7327, 0x7332, 0x732D, 0x7326, 0x7323,
0x7335, 0x730C, 0x742E, 0x742C, 0x7430, 0x742B, 0x7416, 0x741A,
0x7421, 0x742D, 0x7431, 0x7424, 0x7423, 0x741D, 0x7429, 0x7420,
0x7432, 0x74FB, 0x752F, 0x756F, 0x756C, 0x75E7, 0x75DA, 0x75E1,
0x75E6, 0x75DD, 0x75DF, 0x75E4, 0x75D7, 0x7695, 0x7692, 0x76DA,
0x7746, 0x7747, 0x7744, 0x774D, 0x7745, 0x774A, 0x774E, 0x774B,
0x774C, 0x77DE, 0x77EC, 0x7860, 0x7864, 0x7865, 0x785C, 0x786D,
0x7871, 0x786A, 0x786E, 0x7870, 0x7869, 0x7868, 0x785E, 0x7862,
0x7974, 0x7973, 0x7972, 0x7970, 0x7A02, 0x7A0A, 0x7A03, 0x7A0C,
0x7A04, 0x7A99, 0x7AE6, 0x7AE4, 0x7B4A, 0x7B3B, 0x7B44, 0x7B48,
0x7B4C, 0x7B4E, 0x7B40, 0x7B58, 0x7B45, 0x7CA2, 0x7C9E, 0x7CA8,
0x7CA1, 0x7D58, 0x7D6F, 0x7D63, 0x7D53, 0x7D56, 0x7D67, 0x7D6A,
0x7D4F, 0x7D6D, 0x7D5C, 0x7D6B, 0x7D52, 0x7D54, 0x7D69, 0x7D51,
0x7D5F, 0x7D4E, 0x7F3E, 0x7F3F, 0x7F65, 0x7F66, 0x7FA2, 0x7FA0,
0x7FA1, 0x7FD7, 0x8051, 0x804F, 0x8050, 0x80FE, 0x80D4, 0x8143,
0x814A, 0x8152, 0x814F, 0x8147, 0x813D, 0x814D, 0x813A, 0x81E6,
0x81EE, 0x81F7, 0x81F8, 0x81F9, 0x8204, 0x823C, 0x823D, 0x823F,
0x8275, 0x833B, 0x83CF, 0x83F9, 0x8423, 0x83C0, 0x83E8, 0x8412,
0x83E7, 0x83E4, 0x83FC, 0x83F6, 0x8410, 0x83C6, 0x83C8, 0x83EB,
0x83E3, 0x83BF, 0x8401, 0x83DD, 0x83E5, 0x83D8, 0x83FF, 0x83E1,
0x83CB, 0x83CE, 0x83D6, 0x83F5, 0x83C9, 0x8409, 0x840F, 0x83DE,
0x8411, 0x8406, 0x83C2, 0x83F3, 0x83D5, 0x83FA, 0x83C7, 0x83D1,
0x83EA, 0x8413, 0x83C3, 0x83EC, 0x83EE, 0x83C4, 0x83FB, 0x83D7,
0x83E2, 0x841B, 0x83DB, 0x83FE, 0x86D8, 0x86E2, 0x86E6, 0x86D3,
0x86E3, 0x86DA, 0x86EA, 0x86DD, 0x86EB, 0x86DC, 0x86EC, 0x86E9,
0x86D7, 0x86E8, 0x86D1, 0x8848, 0x8856, 0x8855, 0x88BA, 0x88D7,
0x88B9, 0x88B8, 0x88C0, 0x88BE, 0x88B6, 0x88BC, 0x88B7, 0x88BD,
0x88B2, 0x8901, 0x88C9, 0x8995, 0x8998, 0x8997, 0x89DD, 0x89DA,
0x89DB, 0x8A4E, 0x8A4D, 0x8A39, 0x8A59, 0x8A40, 0x8A57, 0x8A58,
0x8A44, 0x8A45, 0x8A52, 0x8A48, 0x8A51, 0x8A4A, 0x8A4C, 0x8A4F,
0x8C5F, 0x8C81, 0x8C80, 0x8CBA, 0x8CBE, 0x8CB0, 0x8CB9, 0x8CB5,
0x8D84, 0x8D80, 0x8D89, 0x8DD8, 0x8DD3, 0x8DCD, 0x8DC7, 0x8DD6,
0x8DDC, 0x8DCF, 0x8DD5, 0x8DD9, 0x8DC8, 0x8DD7, 0x8DC5, 0x8EEF,
0x8EF7, 0x8EFA, 0x8EF9, 0x8EE6, 0x8EEE, 0x8EE5, 0x8EF5, 0x8EE7,
0x8EE8, 0x8EF6, 0x8EEB, 0x8EF1, 0x8EEC, 0x8EF4, 0x8EE9, 0x902D,
0x9034, 0x902F, 0x9106, 0x912C, 0x9104, 0x90FF, 0x90FC, 0x9108,
0x90F9, 0x90FB, 0x9101, 0x9100, 0x9107, 0x9105, 0x9103, 0x9161,
0x9164, 0x915F, 0x9162, 0x9160, 0x9201, 0x920A, 0x9225, 0x9203,
0x921A, 0x9226, 0x920F, 0x920C, 0x9200, 0x9212, 0x91FF, 0x91FD,
0x9206, 0x9204, 0x9227, 0x9202, 0x921C, 0x9224, 0x9219, 0x9217,
0x9205, 0x9216, 0x957B, 0x958D, 0x958C, 0x9590, 0x9687, 0x967E,
0x9688, 0x9689, 0x9683, 0x9680, 0x96C2, 0x96C8, 0x96C3, 0x96F1,
0x96F0, 0x976C, 0x9770, 0x976E, 0x9807, 0x98A9, 0x98EB, 0x9CE6,
0x9EF9, 0x4E83, 0x4E84, 0x4EB6, 0x50BD, 0x50BF, 0x50C6, 0x50AE,
0x50C4, 0x50CA, 0x50B4, 0x50C8, 0x50C2, 0x50B0, 0x50C1, 0x50BA,
0x50B1, 0x50CB, 0x50C9, 0x50B6, 0x50B8, 0x51D7, 0x527A, 0x5278,
0x527B, 0x527C, 0x55C3, 0x55DB, 0x55CC, 0x55D0, 0x55CB, 0x55CA,
0x55DD, 0x55C0, 0x55D4, 0x55C4, 0x55E9, 0x55BF, 0x55D2, 0x558D,
0x55CF, 0x55D5, 0x55E2, 0x55D6, 0x55C8, 0x55F2, 0x55CD, 0x55D9,
0x55C2, 0x5714, 0x5853, 0x5868, 0x5864, 0x584F, 0x584D, 0x5849,
0x586F, 0x5855, 0x584E, 0x585D, 0x5859, 0x5865, 0x585B, 0x583D,
0x5863, 0x5871, 0x58FC, 0x5AC7, 0x5AC4, 0x5ACB, 0x5ABA, 0x5AB8,
0x5AB1, 0x5AB5, 0x5AB0, 0x5ABF, 0x5AC8, 0x5ABB, 0x5AC6, 0x5AB7,
0x5AC0, 0x5ACA, 0x5AB4, 0x5AB6, 0x5ACD, 0x5AB9, 0x5A90, 0x5BD6,
0x5BD8, 0x5BD9, 0x5C1F, 0x5C33, 0x5D71, 0x5D63, 0x5D4A, 0x5D65,
0x5D72, 0x5D6C, 0x5D5E, 0x5D68, 0x5D67, 0x5D62, 0x5DF0, 0x5E4F,
0x5E4E, 0x5E4A, 0x5E4D, 0x5E4B, 0x5EC5, 0x5ECC, 0x5EC6, 0x5ECB,
0x5EC7, 0x5F40, 0x5FAF, 0x5FAD, 0x60F7, 0x6149, 0x614A, 0x612B,
0x6145, 0x6136, 0x6132, 0x612E, 0x6146, 0x612F, 0x614F, 0x6129,
0x6140, 0x6220, 0x9168, 0x6223, 0x6225, 0x6224, 0x63C5, 0x63F1,
0x63EB, 0x6410, 0x6412, 0x6409, 0x6420, 0x6424, 0x6433, 0x6443,
0x641F, 0x6415, 0x6418, 0x6439, 0x6437, 0x6422, 0x6423, 0x640C,
0x6426, 0x6430, 0x6428, 0x6441, 0x6435, 0x642F, 0x640A, 0x641A,
0x6440, 0x6425, 0x6427, 0x640B, 0x63E7, 0x641B, 0x642E, 0x6421,
0x640E, 0x656F, 0x6592, 0x65D3, 0x6686, 0x668C, 0x6695, 0x6690,
0x668B, 0x668A, 0x6699, 0x6694, 0x6678, 0x6720, 0x6966, 0x695F,
0x6938, 0x694E, 0x6962, 0x6971, 0x693F, 0x6945, 0x696A, 0x6939,
0x6942, 0x6957, 0x6959, 0x697A, 0x6948, 0x6949, 0x6935, 0x696C,
0x6933, 0x693D, 0x6965, 0x68F0, 0x6978, 0x6934, 0x6969, 0x6940,
0x696F, 0x6944, 0x6976, 0x6958, 0x6941, 0x6974, 0x694C, 0x693B,
0x694B, 0x6937, 0x695C, 0x694F, 0x6951, 0x6932, 0x6952, 0x692F,
0x697B, 0x693C, 0x6B46, 0x6B45, 0x6B43, 0x6B42, 0x6B48, 0x6B41,
0x6B9B, 0xFA0D, 0x6BFB, 0x6BFC, 0x6BF9, 0x6BF7, 0x6BF8, 0x6E9B,
0x6ED6, 0x6EC8, 0x6E8F, 0x6EC0, 0x6E9F, 0x6E93, 0x6E94, 0x6EA0,
0x6EB1, 0x6EB9, 0x6EC6, 0x6ED2, 0x6EBD, 0x6EC1, 0x6E9E, 0x6EC9,
0x6EB7, 0x6EB0, 0x6ECD, 0x6EA6, 0x6ECF, 0x6EB2, 0x6EBE, 0x6EC3,
0x6EDC, 0x6ED8, 0x6E99, 0x6E92, 0x6E8E, 0x6E8D, 0x6EA4, 0x6EA1,
0x6EBF, 0x6EB3, 0x6ED0, 0x6ECA, 0x6E97, 0x6EAE, 0x6EA3, 0x7147,
0x7154, 0x7152, 0x7163, 0x7160, 0x7141, 0x715D, 0x7162, 0x7172,
0x7178, 0x716A, 0x7161, 0x7142, 0x7158, 0x7143, 0x714B, 0x7170,
0x715F, 0x7150, 0x7153, 0x7144, 0x714D, 0x715A, 0x724F, 0x728D,
0x728C, 0x7291, 0x7290, 0x728E, 0x733C, 0x7342, 0x733B, 0x733A,
0x7340, 0x734A, 0x7349, 0x7444, 0x744A, 0x744B, 0x7452, 0x7451,
0x7457, 0x7440, 0x744F, 0x7450, 0x744E, 0x7442, 0x7446, 0x744D,
0x7454, 0x74E1, 0x74FF, 0x74FE, 0x74FD, 0x751D, 0x7579, 0x7577,
0x6983, 0x75EF, 0x760F, 0x7603, 0x75F7, 0x75FE, 0x75FC, 0x75F9,
0x75F8, 0x7610, 0x75FB, 0x75F6, 0x75ED, 0x75F5, 0x75FD, 0x7699,
0x76B5, 0x76DD, 0x7755, 0x775F, 0x7760, 0x7752, 0x7756, 0x775A,
0x7769, 0x7767, 0x7754, 0x7759, 0x776D, 0x77E0, 0x7887, 0x789A,
0x7894, 0x788F, 0x7884, 0x7895, 0x7885, 0x7886, 0x78A1, 0x7883,
0x7879, 0x7899, 0x7880, 0x7896, 0x787B, 0x797C, 0x7982, 0x797D,
0x7979, 0x7A11, 0x7A18, 0x7A19, 0x7A12, 0x7A17, 0x7A15, 0x7A22,
0x7A13, 0x7A1B, 0x7A10, 0x7AA3, 0x7AA2, 0x7A9E, 0x7AEB, 0x7B66,
0x7B64, 0x7B6D, 0x7B74, 0x7B69, 0x7B72, 0x7B65, 0x7B73, 0x7B71,
0x7B70, 0x7B61, 0x7B78, 0x7B76, 0x7B63, 0x7CB2, 0x7CB4, 0x7CAF,
0x7D88, 0x7D86, 0x7D80, 0x7D8D, 0x7D7F, 0x7D85, 0x7D7A, 0x7D8E,
0x7D7B, 0x7D83, 0x7D7C, 0x7D8C, 0x7D94, 0x7D84, 0x7D7D, 0x7D92,
0x7F6D, 0x7F6B, 0x7F67, 0x7F68, 0x7F6C, 0x7FA6, 0x7FA5, 0x7FA7,
0x7FDB, 0x7FDC, 0x8021, 0x8164, 0x8160, 0x8177, 0x815C, 0x8169,
0x815B, 0x8162, 0x8172, 0x6721, 0x815E, 0x8176, 0x8167, 0x816F,
0x8144, 0x8161, 0x821D, 0x8249, 0x8244, 0x8240, 0x8242, 0x8245,
0x84F1, 0x843F, 0x8456, 0x8476, 0x8479, 0x848F, 0x848D, 0x8465,
0x8451, 0x8440, 0x8486, 0x8467, 0x8430, 0x844D, 0x847D, 0x845A,
0x8459, 0x8474, 0x8473, 0x845D, 0x8507, 0x845E, 0x8437, 0x843A,
0x8434, 0x847A, 0x8443, 0x8478, 0x8432, 0x8445, 0x8429, 0x83D9,
0x844B, 0x842F, 0x8442, 0x842D, 0x845F, 0x8470, 0x8439, 0x844E,
0x844C, 0x8452, 0x846F, 0x84C5, 0x848E, 0x843B, 0x8447, 0x8436,
0x8433, 0x8468, 0x847E, 0x8444, 0x842B, 0x8460, 0x8454, 0x846E,
0x8450, 0x870B, 0x8704, 0x86F7, 0x870C, 0x86FA, 0x86D6, 0x86F5,
0x874D, 0x86F8, 0x870E, 0x8709, 0x8701, 0x86F6, 0x870D, 0x8705,
0x88D6, 0x88CB, 0x88CD, 0x88CE, 0x88DE, 0x88DB, 0x88DA, 0x88CC,
0x88D0, 0x8985, 0x899B, 0x89DF, 0x89E5, 0x89E4, 0x89E1, 0x89E0,
0x89E2, 0x89DC, 0x89E6, 0x8A76, 0x8A86, 0x8A7F, 0x8A61, 0x8A3F,
0x8A77, 0x8A82, 0x8A84, 0x8A75, 0x8A83, 0x8A81, 0x8A74, 0x8A7A,
0x8C3C, 0x8C4B, 0x8C4A, 0x8C65, 0x8C64, 0x8C66, 0x8C86, 0x8C84,
0x8C85, 0x8CCC, 0x8D68, 0x8D69, 0x8D91, 0x8D8C, 0x8D8E, 0x8D8F,
0x8D8D, 0x8D93, 0x8D94, 0x8D90, 0x8D92, 0x8DF0, 0x8DE0, 0x8DEC,
0x8DF1, 0x8DEE, 0x8DD0, 0x8DE9, 0x8DE3, 0x8DE2, 0x8DE7, 0x8DF2,
0x8DEB, 0x8DF4, 0x8F06, 0x8EFF, 0x8F01, 0x8F00, 0x8F05, 0x8F07,
0x8F08, 0x8F02, 0x8F0B, 0x9052, 0x903F, 0x9044, 0x9049, 0x903D,
0x9110, 0x910D, 0x910F, 0x9111, 0x9116, 0x9114, 0x910B, 0x910E,
0x916E, 0x916F, 0x9248, 0x9252, 0x9230, 0x923A, 0x9266, 0x9233,
0x9265, 0x925E, 0x9283, 0x922E, 0x924A, 0x9246, 0x926D, 0x926C,
0x924F, 0x9260, 0x9267, 0x926F, 0x9236, 0x9261, 0x9270, 0x9231,
0x9254, 0x9263, 0x9250, 0x9272, 0x924E, 0x9253, 0x924C, 0x9256,
0x9232, 0x959F, 0x959C, 0x959E, 0x959B, 0x9692, 0x9693, 0x9691,
0x9697, 0x96CE, 0x96FA, 0x96FD, 0x96F8, 0x96F5, 0x9773, 0x9777,
0x9778, 0x9772, 0x980F, 0x980D, 0x980E, 0x98AC, 0x98F6, 0x98F9,
0x99AF, 0x99B2, 0x99B0, 0x99B5, 0x9AAD, 0x9AAB, 0x9B5B, 0x9CEA,
0x9CED, 0x9CE7, 0x9E80, 0x9EFD, 0x50E6, 0x50D4, 0x50D7, 0x50E8,
0x50F3, 0x50DB, 0x50EA, 0x50DD, 0x50E4, 0x50D3, 0x50EC, 0x50F0,
0x50EF, 0x50E3, 0x50E0, 0x51D8, 0x5280, 0x5281, 0x52E9, 0x52EB,
0x5330, 0x53AC, 0x5627, 0x5615, 0x560C, 0x5612, 0x55FC, 0x560F,
0x561C, 0x5601, 0x5613, 0x5602, 0x55FA, 0x561D, 0x5604, 0x55FF,
0x55F9, 0x5889, 0x587C, 0x5890, 0x5898, 0x5886, 0x5881, 0x587F,
0x5874, 0x588B, 0x587A, 0x5887, 0x5891, 0x588E, 0x5876, 0x5882,
0x5888, 0x587B, 0x5894, 0x588F, 0x58FE, 0x596B, 0x5ADC, 0x5AEE,
0x5AE5, 0x5AD5, 0x5AEA, 0x5ADA, 0x5AED, 0x5AEB, 0x5AF3, 0x5AE2,
0x5AE0, 0x5ADB, 0x5AEC, 0x5ADE, 0x5ADD, 0x5AD9, 0x5AE8, 0x5ADF,
0x5B77, 0x5BE0, 0x5BE3, 0x5C63, 0x5D82, 0x5D80, 0x5D7D, 0x5D86,
0x5D7A, 0x5D81, 0x5D77, 0x5D8A, 0x5D89, 0x5D88, 0x5D7E, 0x5D7C,
0x5D8D, 0x5D79, 0x5D7F, 0x5E58, 0x5E59, 0x5E53, 0x5ED8, 0x5ED1,
0x5ED7, 0x5ECE, 0x5EDC, 0x5ED5, 0x5ED9, 0x5ED2, 0x5ED4, 0x5F44,
0x5F43, 0x5F6F, 0x5FB6, 0x612C, 0x6128, 0x6141, 0x615E, 0x6171,
0x6173, 0x6152, 0x6153, 0x6172, 0x616C, 0x6180, 0x6174, 0x6154,
0x617A, 0x615B, 0x6165, 0x613B, 0x616A, 0x6161, 0x6156, 0x6229,
0x6227, 0x622B, 0x642B, 0x644D, 0x645B, 0x645D, 0x6474, 0x6476,
0x6472, 0x6473, 0x647D, 0x6475, 0x6466, 0x64A6, 0x644E, 0x6482,
0x645E, 0x645C, 0x644B, 0x6453, 0x6460, 0x6450, 0x647F, 0x643F,
0x646C, 0x646B, 0x6459, 0x6465, 0x6477, 0x6573, 0x65A0, 0x66A1,
0x66A0, 0x669F, 0x6705, 0x6704, 0x6722, 0x69B1, 0x69B6, 0x69C9,
0x69A0, 0x69CE, 0x6996, 0x69B0, 0x69AC, 0x69BC, 0x6991, 0x6999,
0x698E, 0x69A7, 0x698D, 0x69A9, 0x69BE, 0x69AF, 0x69BF, 0x69C4,
0x69BD, 0x69A4, 0x69D4, 0x69B9, 0x69CA, 0x699A, 0x69CF, 0x69B3,
0x6993, 0x69AA, 0x69A1, 0x699E, 0x69D9, 0x6997, 0x6990, 0x69C2,
0x69B5, 0x69A5, 0x69C6, 0x6B4A, 0x6B4D, 0x6B4B, 0x6B9E, 0x6B9F,
0x6BA0, 0x6BC3, 0x6BC4, 0x6BFE, 0x6ECE, 0x6EF5, 0x6EF1, 0x6F03,
0x6F25, 0x6EF8, 0x6F37, 0x6EFB, 0x6F2E, 0x6F09, 0x6F4E, 0x6F19,
0x6F1A, 0x6F27, 0x6F18, 0x6F3B, 0x6F12, 0x6EED, 0x6F0A, 0x6F36,
0x6F73, 0x6EF9, 0x6EEE, 0x6F2D, 0x6F40, 0x6F30, 0x6F3C, 0x6F35,
0x6EEB, 0x6F07, 0x6F0E, 0x6F43, 0x6F05, 0x6EFD, 0x6EF6, 0x6F39,
0x6F1C, 0x6EFC, 0x6F3A, 0x6F1F, 0x6F0D, 0x6F1E, 0x6F08, 0x6F21,
0x7187, 0x7190, 0x7189, 0x7180, 0x7185, 0x7182, 0x718F, 0x717B,
0x7186, 0x7181, 0x7197, 0x7244, 0x7253, 0x7297, 0x7295, 0x7293,
0x7343, 0x734D, 0x7351, 0x734C, 0x7462, 0x7473, 0x7471, 0x7475,
0x7472, 0x7467, 0x746E, 0x7500, 0x7502, 0x7503, 0x757D, 0x7590,
0x7616, 0x7608, 0x760C, 0x7615, 0x7611, 0x760A, 0x7614, 0x76B8,
0x7781, 0x777C, 0x7785, 0x7782, 0x776E, 0x7780, 0x776F, 0x777E,
0x7783, 0x78B2, 0x78AA, 0x78B4, 0x78AD, 0x78A8, 0x787E, 0x78AB,
0x789E, 0x78A5, 0x78A0, 0x78AC, 0x78A2, 0x78A4, 0x7998, 0x798A,
0x798B, 0x7996, 0x7995, 0x7994, 0x7993, 0x7997, 0x7988, 0x7992,
0x7990, 0x7A2B, 0x7A4A, 0x7A30, 0x7A2F, 0x7A28, 0x7A26, 0x7AA8,
0x7AAB, 0x7AAC, 0x7AEE, 0x7B88, 0x7B9C, 0x7B8A, 0x7B91, 0x7B90,
0x7B96, 0x7B8D, 0x7B8C, 0x7B9B, 0x7B8E, 0x7B85, 0x7B98, 0x5284,
0x7B99, 0x7BA4, 0x7B82, 0x7CBB, 0x7CBF, 0x7CBC, 0x7CBA, 0x7DA7,
0x7DB7, 0x7DC2, 0x7DA3, 0x7DAA, 0x7DC1, 0x7DC0, 0x7DC5, 0x7D9D,
0x7DCE, 0x7DC4, 0x7DC6, 0x7DCB, 0x7DCC, 0x7DAF, 0x7DB9, 0x7D96,
0x7DBC, 0x7D9F, 0x7DA6, 0x7DAE, 0x7DA9, 0x7DA1, 0x7DC9, 0x7F73,
0x7FE2, 0x7FE3, 0x7FE5, 0x7FDE, 0x8024, 0x805D, 0x805C, 0x8189,
0x8186, 0x8183, 0x8187, 0x818D, 0x818C, 0x818B, 0x8215, 0x8497,
0x84A4, 0x84A1, 0x849F, 0x84BA, 0x84CE, 0x84C2, 0x84AC, 0x84AE,
0x84AB, 0x84B9, 0x84B4, 0x84C1, 0x84CD, 0x84AA, 0x849A, 0x84B1,
0x84D0, 0x849D, 0x84A7, 0x84BB, 0x84A2, 0x8494, 0x84C7, 0x84CC,
0x849B, 0x84A9, 0x84AF, 0x84A8, 0x84D6, 0x8498, 0x84B6, 0x84CF,
0x84A0, 0x84D7, 0x84D4, 0x84D2, 0x84DB, 0x84B0, 0x8491, 0x8661,
0x8733, 0x8723, 0x8728, 0x876B, 0x8740, 0x872E, 0x871E, 0x8721,
0x8719, 0x871B, 0x8743, 0x872C, 0x8741, 0x873E, 0x8746, 0x8720,
0x8732, 0x872A, 0x872D, 0x873C, 0x8712, 0x873A, 0x8731, 0x8735,
0x8742, 0x8726, 0x8727, 0x8738, 0x8724, 0x871A, 0x8730, 0x8711,
0x88F7, 0x88E7, 0x88F1, 0x88F2, 0x88FA, 0x88FE, 0x88EE, 0x88FC,
0x88F6, 0x88FB, 0x88F0, 0x88EC, 0x88EB, 0x899D, 0x89A1, 0x899F,
0x899E, 0x89E9, 0x89EB, 0x89E8, 0x8AAB, 0x8A99, 0x8A8B, 0x8A92,
0x8A8F, 0x8A96, 0x8C3D, 0x8C68, 0x8C69, 0x8CD5, 0x8CCF, 0x8CD7,
0x8D96, 0x8E09, 0x8E02, 0x8DFF, 0x8E0D, 0x8DFD, 0x8E0A, 0x8E03,
0x8E07, 0x8E06, 0x8E05, 0x8DFE, 0x8E00, 0x8E04, 0x8F10, 0x8F11,
0x8F0E, 0x8F0D, 0x9123, 0x911C, 0x9120, 0x9122, 0x911F, 0x911D,
0x911A, 0x9124, 0x9121, 0x911B, 0x917A, 0x9172, 0x9179, 0x9173,
0x92A5, 0x92A4, 0x9276, 0x929B, 0x927A, 0x92A0, 0x9294, 0x92AA,
0x928D, 0x92A6, 0x929A, 0x92AB, 0x9279, 0x9297, 0x927F, 0x92A3,
0x92EE, 0x928E, 0x9282, 0x9295, 0x92A2, 0x927D, 0x9288, 0x92A1,
0x928A, 0x9286, 0x928C, 0x9299, 0x92A7, 0x927E, 0x9287, 0x92A9,
0x929D, 0x928B, 0x922D, 0x969E, 0x96A1, 0x96FF, 0x9758, 0x977D,
0x977A, 0x977E, 0x9783, 0x9780, 0x9782, 0x977B, 0x9784, 0x9781,
0x977F, 0x97CE, 0x97CD, 0x9816, 0x98AD, 0x98AE, 0x9902, 0x9900,
0x9907, 0x999D, 0x999C, 0x99C3, 0x99B9, 0x99BB, 0x99BA, 0x99C2,
0x99BD, 0x99C7, 0x9AB1, 0x9AE3, 0x9AE7, 0x9B3E, 0x9B3F, 0x9B60,
0x9B61, 0x9B5F, 0x9CF1, 0x9CF2, 0x9CF5, 0x9EA7, 0x50FF, 0x5103,
0x5130, 0x50F8, 0x5106, 0x5107, 0x50F6, 0x50FE, 0x510B, 0x510C,
0x50FD, 0x510A, 0x528B, 0x528C, 0x52F1, 0x52EF, 0x5648, 0x5642,
0x564C, 0x5635, 0x5641, 0x564A, 0x5649, 0x5646, 0x5658, 0x565A,
0x5640, 0x5633, 0x563D, 0x562C, 0x563E, 0x5638, 0x562A, 0x563A,
0x571A, 0x58AB, 0x589D, 0x58B1, 0x58A0, 0x58A3, 0x58AF, 0x58AC,
0x58A5, 0x58A1, 0x58FF, 0x5AFF, 0x5AF4, 0x5AFD, 0x5AF7, 0x5AF6,
0x5B03, 0x5AF8, 0x5B02, 0x5AF9, 0x5B01, 0x5B07, 0x5B05, 0x5B0F,
0x5C67, 0x5D99, 0x5D97, 0x5D9F, 0x5D92, 0x5DA2, 0x5D93, 0x5D95,
0x5DA0, 0x5D9C, 0x5DA1, 0x5D9A, 0x5D9E, 0x5E69, 0x5E5D, 0x5E60,
0x5E5C, 0x7DF3, 0x5EDB, 0x5EDE, 0x5EE1, 0x5F49, 0x5FB2, 0x618B,
0x6183, 0x6179, 0x61B1, 0x61B0, 0x61A2, 0x6189, 0x619B, 0x6193,
0x61AF, 0x61AD, 0x619F, 0x6192, 0x61AA, 0x61A1, 0x618D, 0x6166,
0x61B3, 0x622D, 0x646E, 0x6470, 0x6496, 0x64A0, 0x6485, 0x6497,
0x649C, 0x648F, 0x648B, 0x648A, 0x648C, 0x64A3, 0x649F, 0x6468,
0x64B1, 0x6498, 0x6576, 0x657A, 0x6579, 0x657B, 0x65B2, 0x65B3,
0x66B5, 0x66B0, 0x66A9, 0x66B2, 0x66B7, 0x66AA, 0x66AF, 0x6A00,
0x6A06, 0x6A17, 0x69E5, 0x69F8, 0x6A15, 0x69F1, 0x69E4, 0x6A20,
0x69FF, 0x69EC, 0x69E2, 0x6A1B, 0x6A1D, 0x69FE, 0x6A27, 0x69F2,
0x69EE, 0x6A14, 0x69F7, 0x69E7, 0x6A40, 0x6A08, 0x69E6, 0x69FB,
0x6A0D, 0x69FC, 0x69EB, 0x6A09, 0x6A04, 0x6A18, 0x6A25, 0x6A0F,
0x69F6, 0x6A26, 0x6A07, 0x69F4, 0x6A16, 0x6B51, 0x6BA5, 0x6BA3,
0x6BA2, 0x6BA6, 0x6C01, 0x6C00, 0x6BFF, 0x6C02, 0x6F41, 0x6F26,
0x6F7E, 0x6F87, 0x6FC6, 0x6F92, 0x6F8D, 0x6F89, 0x6F8C, 0x6F62,
0x6F4F, 0x6F85, 0x6F5A, 0x6F96, 0x6F76, 0x6F6C, 0x6F82, 0x6F55,
0x6F72, 0x6F52, 0x6F50, 0x6F57, 0x6F94, 0x6F93, 0x6F5D, 0x6F00,
0x6F61, 0x6F6B, 0x6F7D, 0x6F67, 0x6F90, 0x6F53, 0x6F8B, 0x6F69,
0x6F7F, 0x6F95, 0x6F63, 0x6F77, 0x6F6A, 0x6F7B, 0x71B2, 0x71AF,
0x719B, 0x71B0, 0x71A0, 0x719A, 0x71A9, 0x71B5, 0x719D, 0x71A5,
0x719E, 0x71A4, 0x71A1, 0x71AA, 0x719C, 0x71A7, 0x71B3, 0x7298,
0x729A, 0x7358, 0x7352, 0x735E, 0x735F, 0x7360, 0x735D, 0x735B,
0x7361, 0x735A, 0x7359, 0x7362, 0x7487, 0x7489, 0x748A, 0x7486,
0x7481, 0x747D, 0x7485, 0x7488, 0x747C, 0x7479, 0x7508, 0x7507,
0x757E, 0x7625, 0x761E, 0x7619, 0x761D, 0x761C, 0x7623, 0x761A,
0x7628, 0x761B, 0x769C, 0x769D, 0x769E, 0x769B, 0x778D, 0x778F,
0x7789, 0x7788, 0x78CD, 0x78BB, 0x78CF, 0x78CC, 0x78D1, 0x78CE,
0x78D4, 0x78C8, 0x78C3, 0x78C4, 0x78C9, 0x799A, 0x79A1, 0x79A0,
0x799C, 0x79A2, 0x799B, 0x6B76, 0x7A39, 0x7AB2, 0x7AB4, 0x7AB3,
0x7BB7, 0x7BCB, 0x7BBE, 0x7BAC, 0x7BCE, 0x7BAF, 0x7BB9, 0x7BCA,
0x7BB5, 0x7CC5, 0x7CC8, 0x7CCC, 0x7CCB, 0x7DF7, 0x7DDB, 0x7DEA,
0x7DE7, 0x7DD7, 0x7DE1, 0x7E03, 0x7DFA, 0x7DE6, 0x7DF6, 0x7DF1,
0x7DF0, 0x7DEE, 0x7DDF, 0x7F76, 0x7FAC, 0x7FB0, 0x7FAD, 0x7FED,
0x7FEB, 0x7FEA, 0x7FEC, 0x7FE6, 0x7FE8, 0x8064, 0x8067, 0x81A3,
0x819F, 0x819E, 0x8195, 0x81A2, 0x8199, 0x8197, 0x8216, 0x824F,
0x8253, 0x8252, 0x8250, 0x824E, 0x8251, 0x8524, 0x853B, 0x850F,
0x8500, 0x8529, 0x850E, 0x8509, 0x850D, 0x851F, 0x850A, 0x8527,
0x851C, 0x84FB, 0x852B, 0x84FA, 0x8508, 0x850C, 0x84F4, 0x852A,
0x84F2, 0x8515, 0x84F7, 0x84EB, 0x84F3, 0x84FC, 0x8512, 0x84EA,
0x84E9, 0x8516, 0x84FE, 0x8528, 0x851D, 0x852E, 0x8502, 0x84FD,
0x851E, 0x84F6, 0x8531, 0x8526, 0x84E7, 0x84E8, 0x84F0, 0x84EF,
0x84F9, 0x8518, 0x8520, 0x8530, 0x850B, 0x8519, 0x852F, 0x8662,
0x8756, 0x8763, 0x8764, 0x8777, 0x87E1, 0x8773, 0x8758, 0x8754,
0x875B, 0x8752, 0x8761, 0x875A, 0x8751, 0x875E, 0x876D, 0x876A,
0x8750, 0x874E, 0x875F, 0x875D, 0x876F, 0x876C, 0x877A, 0x876E,
0x875C, 0x8765, 0x874F, 0x877B, 0x8775, 0x8762, 0x8767, 0x8769,
0x885A, 0x8905, 0x890C, 0x8914, 0x890B, 0x8917, 0x8918, 0x8919,
0x8906, 0x8916, 0x8911, 0x890E, 0x8909, 0x89A2, 0x89A4, 0x89A3,
0x89ED, 0x89F0, 0x89EC, 0x8ACF, 0x8AC6, 0x8AB8, 0x8AD3, 0x8AD1,
0x8AD4, 0x8AD5, 0x8ABB, 0x8AD7, 0x8ABE, 0x8AC0, 0x8AC5, 0x8AD8,
0x8AC3, 0x8ABA, 0x8ABD, 0x8AD9, 0x8C3E, 0x8C4D, 0x8C8F, 0x8CE5,
0x8CDF, 0x8CD9, 0x8CE8, 0x8CDA, 0x8CDD, 0x8CE7, 0x8DA0, 0x8D9C,
0x8DA1, 0x8D9B, 0x8E20, 0x8E23, 0x8E25, 0x8E24, 0x8E2E, 0x8E15,
0x8E1B, 0x8E16, 0x8E11, 0x8E19, 0x8E26, 0x8E27, 0x8E14, 0x8E12,
0x8E18, 0x8E13, 0x8E1C, 0x8E17, 0x8E1A, 0x8F2C, 0x8F24, 0x8F18,
0x8F1A, 0x8F20, 0x8F23, 0x8F16, 0x8F17, 0x9073, 0x9070, 0x906F,
0x9067, 0x906B, 0x912F, 0x912B, 0x9129, 0x912A, 0x9132, 0x9126,
0x912E, 0x9185, 0x9186, 0x918A, 0x9181, 0x9182, 0x9184, 0x9180,
0x92D0, 0x92C3, 0x92C4, 0x92C0, 0x92D9, 0x92B6, 0x92CF, 0x92F1,
0x92DF, 0x92D8, 0x92E9, 0x92D7, 0x92DD, 0x92CC, 0x92EF, 0x92C2,
0x92E8, 0x92CA, 0x92C8, 0x92CE, 0x92E6, 0x92CD, 0x92D5, 0x92C9,
0x92E0, 0x92DE, 0x92E7, 0x92D1, 0x92D3, 0x92B5, 0x92E1, 0x92C6,
0x92B4, 0x957C, 0x95AC, 0x95AB, 0x95AE, 0x95B0, 0x96A4, 0x96A2,
0x96D3, 0x9705, 0x9708, 0x9702, 0x975A, 0x978A, 0x978E, 0x9788,
0x97D0, 0x97CF, 0x981E, 0x981D, 0x9826, 0x9829, 0x9828, 0x9820,
0x981B, 0x9827, 0x98B2, 0x9908, 0x98FA, 0x9911, 0x9914, 0x9916,
0x9917, 0x9915, 0x99DC, 0x99CD, 0x99CF, 0x99D3, 0x99D4, 0x99CE,
0x99C9, 0x99D6, 0x99D8, 0x99CB, 0x99D7, 0x99CC, 0x9AB3, 0x9AEC,
0x9AEB, 0x9AF3, 0x9AF2, 0x9AF1, 0x9B46, 0x9B43, 0x9B67, 0x9B74,
0x9B71, 0x9B66, 0x9B76, 0x9B75, 0x9B70, 0x9B68, 0x9B64, 0x9B6C,
0x9CFC, 0x9CFA, 0x9CFD, 0x9CFF, 0x9CF7, 0x9D07, 0x9D00, 0x9CF9,
0x9CFB, 0x9D08, 0x9D05, 0x9D04, 0x9E83, 0x9ED3, 0x9F0F, 0x9F10,
0x511C, 0x5113, 0x5117, 0x511A, 0x5111, 0x51DE, 0x5334, 0x53E1,
0x5670, 0x5660, 0x566E, 0x5673, 0x5666, 0x5663, 0x566D, 0x5672,
0x565E, 0x5677, 0x571C, 0x571B, 0x58C8, 0x58BD, 0x58C9, 0x58BF,
0x58BA, 0x58C2, 0x58BC, 0x58C6, 0x5B17, 0x5B19, 0x5B1B, 0x5B21,
0x5B14, 0x5B13, 0x5B10, 0x5B16, 0x5B28, 0x5B1A, 0x5B20, 0x5B1E,
0x5BEF, 0x5DAC, 0x5DB1, 0x5DA9, 0x5DA7, 0x5DB5, 0x5DB0, 0x5DAE,
0x5DAA, 0x5DA8, 0x5DB2, 0x5DAD, 0x5DAF, 0x5DB4, 0x5E67, 0x5E68,
0x5E66, 0x5E6F, 0x5EE9, 0x5EE7, 0x5EE6, 0x5EE8, 0x5EE5, 0x5F4B,
0x5FBC, 0x619D, 0x61A8, 0x6196, 0x61C5, 0x61B4, 0x61C6, 0x61C1,
0x61CC, 0x61BA, 0x61BF, 0x61B8, 0x618C, 0x64D7, 0x64D6, 0x64D0,
0x64CF, 0x64C9, 0x64BD, 0x6489, 0x64C3, 0x64DB, 0x64F3, 0x64D9,
0x6533, 0x657F, 0x657C, 0x65A2, 0x66C8, 0x66BE, 0x66C0, 0x66CA,
0x66CB, 0x66CF, 0x66BD, 0x66BB, 0x66BA, 0x66CC, 0x6723, 0x6A34,
0x6A66, 0x6A49, 0x6A67, 0x6A32, 0x6A68, 0x6A3E, 0x6A5D, 0x6A6D,
0x6A76, 0x6A5B, 0x6A51, 0x6A28, 0x6A5A, 0x6A3B, 0x6A3F, 0x6A41,
0x6A6A, 0x6A64, 0x6A50, 0x6A4F, 0x6A54, 0x6A6F, 0x6A69, 0x6A60,
0x6A3C, 0x6A5E, 0x6A56, 0x6A55, 0x6A4D, 0x6A4E, 0x6A46, 0x6B55,
0x6B54, 0x6B56, 0x6BA7, 0x6BAA, 0x6BAB, 0x6BC8, 0x6BC7, 0x6C04,
0x6C03, 0x6C06, 0x6FAD, 0x6FCB, 0x6FA3, 0x6FC7, 0x6FBC, 0x6FCE,
0x6FC8, 0x6F5E, 0x6FC4, 0x6FBD, 0x6F9E, 0x6FCA, 0x6FA8, 0x7004,
0x6FA5, 0x6FAE, 0x6FBA, 0x6FAC, 0x6FAA, 0x6FCF, 0x6FBF, 0x6FB8,
0x6FA2, 0x6FC9, 0x6FAB, 0x6FCD, 0x6FAF, 0x6FB2, 0x6FB0, 0x71C5,
0x71C2, 0x71BF, 0x71B8, 0x71D6, 0x71C0, 0x71C1, 0x71CB, 0x71D4,
0x71CA, 0x71C7, 0x71CF, 0x71BD, 0x71D8, 0x71BC, 0x71C6, 0x71DA,
0x71DB, 0x729D, 0x729E, 0x7369, 0x7366, 0x7367, 0x736C, 0x7365,
0x736B, 0x736A, 0x747F, 0x749A, 0x74A0, 0x7494, 0x7492, 0x7495,
0x74A1, 0x750B, 0x7580, 0x762F, 0x762D, 0x7631, 0x763D, 0x7633,
0x763C, 0x7635, 0x7632, 0x7630, 0x76BB, 0x76E6, 0x779A, 0x779D,
0x77A1, 0x779C, 0x779B, 0x77A2, 0x77A3, 0x7795, 0x7799, 0x7797,
0x78DD, 0x78E9, 0x78E5, 0x78EA, 0x78DE, 0x78E3, 0x78DB, 0x78E1,
0x78E2, 0x78ED, 0x78DF, 0x78E0, 0x79A4, 0x7A44, 0x7A48, 0x7A47,
0x7AB6, 0x7AB8, 0x7AB5, 0x7AB1, 0x7AB7, 0x7BDE, 0x7BE3, 0x7BE7,
0x7BDD, 0x7BD5, 0x7BE5, 0x7BDA, 0x7BE8, 0x7BF9, 0x7BD4, 0x7BEA,
0x7BE2, 0x7BDC, 0x7BEB, 0x7BD8, 0x7BDF, 0x7CD2, 0x7CD4, 0x7CD7,
0x7CD0, 0x7CD1, 0x7E12, 0x7E21, 0x7E17, 0x7E0C, 0x7E1F, 0x7E20,
0x7E13, 0x7E0E, 0x7E1C, 0x7E15, 0x7E1A, 0x7E22, 0x7E0B, 0x7E0F,
0x7E16, 0x7E0D, 0x7E14, 0x7E25, 0x7E24, 0x7F43, 0x7F7B, 0x7F7C,
0x7F7A, 0x7FB1, 0x7FEF, 0x802A, 0x8029, 0x806C, 0x81B1, 0x81A6,
0x81AE, 0x81B9, 0x81B5, 0x81AB, 0x81B0, 0x81AC, 0x81B4, 0x81B2,
0x81B7, 0x81A7, 0x81F2, 0x8255, 0x8256, 0x8257, 0x8556, 0x8545,
0x856B, 0x854D, 0x8553, 0x8561, 0x8558, 0x8540, 0x8546, 0x8564,
0x8541, 0x8562, 0x8544, 0x8551, 0x8547, 0x8563, 0x853E, 0x855B,
0x8571, 0x854E, 0x856E, 0x8575, 0x8555, 0x8567, 0x8560, 0x858C,
0x8566, 0x855D, 0x8554, 0x8565, 0x856C, 0x8663, 0x8665, 0x8664,
0x879B, 0x878F, 0x8797, 0x8793, 0x8792, 0x8788, 0x8781, 0x8796,
0x8798, 0x8779, 0x8787, 0x87A3, 0x8785, 0x8790, 0x8791, 0x879D,
0x8784, 0x8794, 0x879C, 0x879A, 0x8789, 0x891E, 0x8926, 0x8930,
0x892D, 0x892E, 0x8927, 0x8931, 0x8922, 0x8929, 0x8923, 0x892F,
0x892C, 0x891F, 0x89F1, 0x8AE0, 0x8AE2, 0x8AF2, 0x8AF4, 0x8AF5,
0x8ADD, 0x8B14, 0x8AE4, 0x8ADF, 0x8AF0, 0x8AC8, 0x8ADE, 0x8AE1,
0x8AE8, 0x8AFF, 0x8AEF, 0x8AFB, 0x8C91, 0x8C92, 0x8C90, 0x8CF5,
0x8CEE, 0x8CF1, 0x8CF0, 0x8CF3, 0x8D6C, 0x8D6E, 0x8DA5, 0x8DA7,
0x8E33, 0x8E3E, 0x8E38, 0x8E40, 0x8E45, 0x8E36, 0x8E3C, 0x8E3D,
0x8E41, 0x8E30, 0x8E3F, 0x8EBD, 0x8F36, 0x8F2E, 0x8F35, 0x8F32,
0x8F39, 0x8F37, 0x8F34, 0x9076, 0x9079, 0x907B, 0x9086, 0x90FA,
0x9133, 0x9135, 0x9136, 0x9193, 0x9190, 0x9191, 0x918D, 0x918F,
0x9327, 0x931E, 0x9308, 0x931F, 0x9306, 0x930F, 0x937A, 0x9338,
0x933C, 0x931B, 0x9323, 0x9312, 0x9301, 0x9346, 0x932D, 0x930E,
0x930D, 0x92CB, 0x931D, 0x92FA, 0x9325, 0x9313, 0x92F9, 0x92F7,
0x9334, 0x9302, 0x9324, 0x92FF, 0x9329, 0x9339, 0x9335, 0x932A,
0x9314, 0x930C, 0x930B, 0x92FE, 0x9309, 0x9300, 0x92FB, 0x9316,
0x95BC, 0x95CD, 0x95BE, 0x95B9, 0x95BA, 0x95B6, 0x95BF, 0x95B5,
0x95BD, 0x96A9, 0x96D4, 0x970B, 0x9712, 0x9710, 0x9799, 0x9797,
0x9794, 0x97F0, 0x97F8, 0x9835, 0x982F, 0x9832, 0x9924, 0x991F,
0x9927, 0x9929, 0x999E, 0x99EE, 0x99EC, 0x99E5, 0x99E4, 0x99F0,
0x99E3, 0x99EA, 0x99E9, 0x99E7, 0x9AB9, 0x9ABF, 0x9AB4, 0x9ABB,
0x9AF6, 0x9AFA, 0x9AF9, 0x9AF7, 0x9B33, 0x9B80, 0x9B85, 0x9B87,
0x9B7C, 0x9B7E, 0x9B7B, 0x9B82, 0x9B93, 0x9B92, 0x9B90, 0x9B7A,
0x9B95, 0x9B7D, 0x9B88, 0x9D25, 0x9D17, 0x9D20, 0x9D1E, 0x9D14,
0x9D29, 0x9D1D, 0x9D18, 0x9D22, 0x9D10, 0x9D19, 0x9D1F, 0x9E88,
0x9E86, 0x9E87, 0x9EAE, 0x9EAD, 0x9ED5, 0x9ED6, 0x9EFA, 0x9F12,
0x9F3D, 0x5126, 0x5125, 0x5122, 0x5124, 0x5120, 0x5129, 0x52F4,
0x5693, 0x568C, 0x568D, 0x5686, 0x5684, 0x5683, 0x567E, 0x5682,
0x567F, 0x5681, 0x58D6, 0x58D4, 0x58CF, 0x58D2, 0x5B2D, 0x5B25,
0x5B32, 0x5B23, 0x5B2C, 0x5B27, 0x5B26, 0x5B2F, 0x5B2E, 0x5B7B,
0x5BF1, 0x5BF2, 0x5DB7, 0x5E6C, 0x5E6A, 0x5FBE, 0x5FBB, 0x61C3,
0x61B5, 0x61BC, 0x61E7, 0x61E0, 0x61E5, 0x61E4, 0x61E8, 0x61DE,
0x64EF, 0x64E9, 0x64E3, 0x64EB, 0x64E4, 0x64E8, 0x6581, 0x6580,
0x65B6, 0x65DA, 0x66D2, 0x6A8D, 0x6A96, 0x6A81, 0x6AA5, 0x6A89,
0x6A9F, 0x6A9B, 0x6AA1, 0x6A9E, 0x6A87, 0x6A93, 0x6A8E, 0x6A95,
0x6A83, 0x6AA8, 0x6AA4, 0x6A91, 0x6A7F, 0x6AA6, 0x6A9A, 0x6A85,
0x6A8C, 0x6A92, 0x6B5B, 0x6BAD, 0x6C09, 0x6FCC, 0x6FA9, 0x6FF4,
0x6FD4, 0x6FE3, 0x6FDC, 0x6FED, 0x6FE7, 0x6FE6, 0x6FDE, 0x6FF2,
0x6FDD, 0x6FE2, 0x6FE8, 0x71E1, 0x71F1, 0x71E8, 0x71F2, 0x71E4,
0x71F0, 0x71E2, 0x7373, 0x736E, 0x736F, 0x7497, 0x74B2, 0x74AB,
0x7490, 0x74AA, 0x74AD, 0x74B1, 0x74A5, 0x74AF, 0x7510, 0x7511,
0x7512, 0x750F, 0x7584, 0x7643, 0x7648, 0x7649, 0x7647, 0x76A4,
0x76E9, 0x77B5, 0x77AB, 0x77B2, 0x77B7, 0x77B6, 0x77B4, 0x77B1,
0x77A8, 0x77F0, 0x78F3, 0x78FD, 0x7902, 0x78FB, 0x78FC, 0x78F2,
0x7905, 0x78F9, 0x78FE, 0x7904, 0x79AB, 0x79A8, 0x7A5C, 0x7A5B,
0x7A56, 0x7A58, 0x7A54, 0x7A5A, 0x7ABE, 0x7AC0, 0x7AC1, 0x7C05,
0x7C0F, 0x7BF2, 0x7C00, 0x7BFF, 0x7BFB, 0x7C0E, 0x7BF4, 0x7C0B,
0x7BF3, 0x7C02, 0x7C09, 0x7C03, 0x7C01, 0x7BF8, 0x7BFD, 0x7C06,
0x7BF0, 0x7BF1, 0x7C10, 0x7C0A, 0x7CE8, 0x7E2D, 0x7E3C, 0x7E42,
0x7E33, 0x9848, 0x7E38, 0x7E2A, 0x7E49, 0x7E40, 0x7E47, 0x7E29,
0x7E4C, 0x7E30, 0x7E3B, 0x7E36, 0x7E44, 0x7E3A, 0x7F45, 0x7F7F,
0x7F7E, 0x7F7D, 0x7FF4, 0x7FF2, 0x802C, 0x81BB, 0x81C4, 0x81CC,
0x81CA, 0x81C5, 0x81C7, 0x81BC, 0x81E9, 0x825B, 0x825A, 0x825C,
0x8583, 0x8580, 0x858F, 0x85A7, 0x8595, 0x85A0, 0x858B, 0x85A3,
0x857B, 0x85A4, 0x859A, 0x859E, 0x8577, 0x857C, 0x8589, 0x85A1,
0x857A, 0x8578, 0x8557, 0x858E, 0x8596, 0x8586, 0x858D, 0x8599,
0x859D, 0x8581, 0x85A2, 0x8582, 0x8588, 0x8585, 0x8579, 0x8576,
0x8598, 0x8590, 0x859F, 0x8668, 0x87BE, 0x87AA, 0x87AD, 0x87C5,
0x87B0, 0x87AC, 0x87B9, 0x87B5, 0x87BC, 0x87AE, 0x87C9, 0x87C3,
0x87C2, 0x87CC, 0x87B7, 0x87AF, 0x87C4, 0x87CA, 0x87B4, 0x87B6,
0x87BF, 0x87B8, 0x87BD, 0x87DE, 0x87B2, 0x8935, 0x8933, 0x893C,
0x893E, 0x8941, 0x8952, 0x8937, 0x8942, 0x89AD, 0x89AF, 0x89AE,
0x89F2, 0x89F3, 0x8B1E, 0x8B18, 0x8B16, 0x8B11, 0x8B05, 0x8B0B,
0x8B22, 0x8B0F, 0x8B12, 0x8B15, 0x8B07, 0x8B0D, 0x8B08, 0x8B06,
0x8B1C, 0x8B13, 0x8B1A, 0x8C4F, 0x8C70, 0x8C72, 0x8C71, 0x8C6F,
0x8C95, 0x8C94, 0x8CF9, 0x8D6F, 0x8E4E, 0x8E4D, 0x8E53, 0x8E50,
0x8E4C, 0x8E47, 0x8F43, 0x8F40, 0x9085, 0x907E, 0x9138, 0x919A,
0x91A2, 0x919B, 0x9199, 0x919F, 0x91A1, 0x919D, 0x91A0, 0x93A1,
0x9383, 0x93AF, 0x9364, 0x9356, 0x9347, 0x937C, 0x9358, 0x935C,
0x9376, 0x9349, 0x9350, 0x9351, 0x9360, 0x936D, 0x938F, 0x934C,
0x936A, 0x9379, 0x9357, 0x9355, 0x9352, 0x934F, 0x9371, 0x9377,
0x937B, 0x9361, 0x935E, 0x9363, 0x9367, 0x9380, 0x934E, 0x9359,
0x95C7, 0x95C0, 0x95C9, 0x95C3, 0x95C5, 0x95B7, 0x96AE, 0x96B0,
0x96AC, 0x9720, 0x971F, 0x9718, 0x971D, 0x9719, 0x979A, 0x97A1,
0x979C, 0x979E, 0x979D, 0x97D5, 0x97D4, 0x97F1, 0x9841, 0x9844,
0x984A, 0x9849, 0x9845, 0x9843, 0x9925, 0x992B, 0x992C, 0x992A,
0x9933, 0x9932, 0x992F, 0x992D, 0x9931, 0x9930, 0x9998, 0x99A3,
0x99A1, 0x9A02, 0x99FA, 0x99F4, 0x99F7, 0x99F9, 0x99F8, 0x99F6,
0x99FB, 0x99FD, 0x99FE, 0x99FC, 0x9A03, 0x9ABE, 0x9AFE, 0x9AFD,
0x9B01, 0x9AFC, 0x9B48, 0x9B9A, 0x9BA8, 0x9B9E, 0x9B9B, 0x9BA6,
0x9BA1, 0x9BA5, 0x9BA4, 0x9B86, 0x9BA2, 0x9BA0, 0x9BAF, 0x9D33,
0x9D41, 0x9D67, 0x9D36, 0x9D2E, 0x9D2F, 0x9D31, 0x9D38, 0x9D30,
0x9D45, 0x9D42, 0x9D43, 0x9D3E, 0x9D37, 0x9D40, 0x9D3D, 0x7FF5,
0x9D2D, 0x9E8A, 0x9E89, 0x9E8D, 0x9EB0, 0x9EC8, 0x9EDA, 0x9EFB,
0x9EFF, 0x9F24, 0x9F23, 0x9F22, 0x9F54, 0x9FA0, 0x5131, 0x512D,
0x512E, 0x5698, 0x569C, 0x5697, 0x569A, 0x569D, 0x5699, 0x5970,
0x5B3C, 0x5C69, 0x5C6A, 0x5DC0, 0x5E6D, 0x5E6E, 0x61D8, 0x61DF,
0x61ED, 0x61EE, 0x61F1, 0x61EA, 0x61F0, 0x61EB, 0x61D6, 0x61E9,
0x64FF, 0x6504, 0x64FD, 0x64F8, 0x6501, 0x6503, 0x64FC, 0x6594,
0x65DB, 0x66DA, 0x66DB, 0x66D8, 0x6AC5, 0x6AB9, 0x6ABD, 0x6AE1,
0x6AC6, 0x6ABA, 0x6AB6, 0x6AB7, 0x6AC7, 0x6AB4, 0x6AAD, 0x6B5E,
0x6BC9, 0x6C0B, 0x7007, 0x700C, 0x700D, 0x7001, 0x7005, 0x7014,
0x700E, 0x6FFF, 0x7000, 0x6FFB, 0x7026, 0x6FFC, 0x6FF7, 0x700A,
0x7201, 0x71FF, 0x71F9, 0x7203, 0x71FD, 0x7376, 0x74B8, 0x74C0,
0x74B5, 0x74C1, 0x74BE, 0x74B6, 0x74BB, 0x74C2, 0x7514, 0x7513,
0x765C, 0x7664, 0x7659, 0x7650, 0x7653, 0x7657, 0x765A, 0x76A6,
0x76BD, 0x76EC, 0x77C2, 0x77BA, 0x78FF, 0x790C, 0x7913, 0x7914,
0x7909, 0x7910, 0x7912, 0x7911, 0x79AD, 0x79AC, 0x7A5F, 0x7C1C,
0x7C29, 0x7C19, 0x7C20, 0x7C1F, 0x7C2D, 0x7C1D, 0x7C26, 0x7C28,
0x7C22, 0x7C25, 0x7C30, 0x7E5C, 0x7E50, 0x7E56, 0x7E63, 0x7E58,
0x7E62, 0x7E5F, 0x7E51, 0x7E60, 0x7E57, 0x7E53, 0x7FB5, 0x7FB3,
0x7FF7, 0x7FF8, 0x8075, 0x81D1, 0x81D2, 0x81D0, 0x825F, 0x825E,
0x85B4, 0x85C6, 0x85C0, 0x85C3, 0x85C2, 0x85B3, 0x85B5, 0x85BD,
0x85C7, 0x85C4, 0x85BF, 0x85CB, 0x85CE, 0x85C8, 0x85C5, 0x85B1,
0x85B6, 0x85D2, 0x8624, 0x85B8, 0x85B7, 0x85BE, 0x8669, 0x87E7,
0x87E6, 0x87E2, 0x87DB, 0x87EB, 0x87EA, 0x87E5, 0x87DF, 0x87F3,
0x87E4, 0x87D4, 0x87DC, 0x87D3, 0x87ED, 0x87D8, 0x87E3, 0x87A4,
0x87D7, 0x87D9, 0x8801, 0x87F4, 0x87E8, 0x87DD, 0x8953, 0x894B,
0x894F, 0x894C, 0x8946, 0x8950, 0x8951, 0x8949, 0x8B2A, 0x8B27,
0x8B23, 0x8B33, 0x8B30, 0x8B35, 0x8B47, 0x8B2F, 0x8B3C, 0x8B3E,
0x8B31, 0x8B25, 0x8B37, 0x8B26, 0x8B36, 0x8B2E, 0x8B24, 0x8B3B,
0x8B3D, 0x8B3A, 0x8C42, 0x8C75, 0x8C99, 0x8C98, 0x8C97, 0x8CFE,
0x8D04, 0x8D02, 0x8D00, 0x8E5C, 0x8E62, 0x8E60, 0x8E57, 0x8E56,
0x8E5E, 0x8E65, 0x8E67, 0x8E5B, 0x8E5A, 0x8E61, 0x8E5D, 0x8E69,
0x8E54, 0x8F46, 0x8F47, 0x8F48, 0x8F4B, 0x9128, 0x913A, 0x913B,
0x913E, 0x91A8, 0x91A5, 0x91A7, 0x91AF, 0x91AA, 0x93B5, 0x938C,
0x9392, 0x93B7, 0x939B, 0x939D, 0x9389, 0x93A7, 0x938E, 0x93AA,
0x939E, 0x93A6, 0x9395, 0x9388, 0x9399, 0x939F, 0x938D, 0x93B1,
0x9391, 0x93B2, 0x93A4, 0x93A8, 0x93B4, 0x93A3, 0x93A5, 0x95D2,
0x95D3, 0x95D1, 0x96B3, 0x96D7, 0x96DA, 0x5DC2, 0x96DF, 0x96D8,
0x96DD, 0x9723, 0x9722, 0x9725, 0x97AC, 0x97AE, 0x97A8, 0x97AB,
0x97A4, 0x97AA, 0x97A2, 0x97A5, 0x97D7, 0x97D9, 0x97D6, 0x97D8,
0x97FA, 0x9850, 0x9851, 0x9852, 0x98B8, 0x9941, 0x993C, 0x993A,
0x9A0F, 0x9A0B, 0x9A09, 0x9A0D, 0x9A04, 0x9A11, 0x9A0A, 0x9A05,
0x9A07, 0x9A06, 0x9AC0, 0x9ADC, 0x9B08, 0x9B04, 0x9B05, 0x9B29,
0x9B35, 0x9B4A, 0x9B4C, 0x9B4B, 0x9BC7, 0x9BC6, 0x9BC3, 0x9BBF,
0x9BC1, 0x9BB5, 0x9BB8, 0x9BD3, 0x9BB6, 0x9BC4, 0x9BB9, 0x9BBD,
0x9D5C, 0x9D53, 0x9D4F, 0x9D4A, 0x9D5B, 0x9D4B, 0x9D59, 0x9D56,
0x9D4C, 0x9D57, 0x9D52, 0x9D54, 0x9D5F, 0x9D58, 0x9D5A, 0x9E8E,
0x9E8C, 0x9EDF, 0x9F01, 0x9F00, 0x9F16, 0x9F25, 0x9F2B, 0x9F2A,
0x9F29, 0x9F28, 0x9F4C, 0x9F55, 0x5134, 0x5135, 0x5296, 0x52F7,
0x53B4, 0x56AB, 0x56AD, 0x56A6, 0x56A7, 0x56AA, 0x56AC, 0x58DA,
0x58DD, 0x58DB, 0x5912, 0x5B3D, 0x5B3E, 0x5B3F, 0x5DC3, 0x5E70,
0x5FBF, 0x61FB, 0x6507, 0x6510, 0x650D, 0x6509, 0x650C, 0x650E,
0x6584, 0x65DE, 0x65DD, 0x66DE, 0x6AE7, 0x6AE0, 0x6ACC, 0x6AD1,
0x6AD9, 0x6ACB, 0x6ADF, 0x6ADC, 0x6AD0, 0x6AEB, 0x6ACF, 0x6ACD,
0x6ADE, 0x6B60, 0x6BB0, 0x6C0C, 0x7019, 0x7027, 0x7020, 0x7016,
0x702B, 0x7021, 0x7022, 0x7023, 0x7029, 0x7017, 0x7024, 0x701C,
0x702A, 0x720C, 0x720A, 0x7207, 0x7202, 0x7205, 0x72A5, 0x72A6,
0x72A4, 0x72A3, 0x72A1, 0x74CB, 0x74C5, 0x74B7, 0x74C3, 0x7516,
0x7660, 0x77C9, 0x77CA, 0x77C4, 0x77F1, 0x791D, 0x791B, 0x7921,
0x791C, 0x7917, 0x791E, 0x79B0, 0x7A67, 0x7A68, 0x7C33, 0x7C3C,
0x7C39, 0x7C2C, 0x7C3B, 0x7CEC, 0x7CEA, 0x7E76, 0x7E75, 0x7E78,
0x7E70, 0x7E77, 0x7E6F, 0x7E7A, 0x7E72, 0x7E74, 0x7E68, 0x7F4B,
0x7F4A, 0x7F83, 0x7F86, 0x7FB7, 0x7FFD, 0x7FFE, 0x8078, 0x81D7,
0x81D5, 0x8264, 0x8261, 0x8263, 0x85EB, 0x85F1, 0x85ED, 0x85D9,
0x85E1, 0x85E8, 0x85DA, 0x85D7, 0x85EC, 0x85F2, 0x85F8, 0x85D8,
0x85DF, 0x85E3, 0x85DC, 0x85D1, 0x85F0, 0x85E6, 0x85EF, 0x85DE,
0x85E2, 0x8800, 0x87FA, 0x8803, 0x87F6, 0x87F7, 0x8809, 0x880C,
0x880B, 0x8806, 0x87FC, 0x8808, 0x87FF, 0x880A, 0x8802, 0x8962,
0x895A, 0x895B, 0x8957, 0x8961, 0x895C, 0x8958, 0x895D, 0x8959,
0x8988, 0x89B7, 0x89B6, 0x89F6, 0x8B50, 0x8B48, 0x8B4A, 0x8B40,
0x8B53, 0x8B56, 0x8B54, 0x8B4B, 0x8B55, 0x8B51, 0x8B42, 0x8B52,
0x8B57, 0x8C43, 0x8C77, 0x8C76, 0x8C9A, 0x8D06, 0x8D07, 0x8D09,
0x8DAC, 0x8DAA, 0x8DAD, 0x8DAB, 0x8E6D, 0x8E78, 0x8E73, 0x8E6A,
0x8E6F, 0x8E7B, 0x8EC2, 0x8F52, 0x8F51, 0x8F4F, 0x8F50, 0x8F53,
0x8FB4, 0x9140, 0x913F, 0x91B0, 0x91AD, 0x93DE, 0x93C7, 0x93CF,
0x93C2, 0x93DA, 0x93D0, 0x93F9, 0x93EC, 0x93CC, 0x93D9, 0x93A9,
0x93E6, 0x93CA, 0x93D4, 0x93EE, 0x93E3, 0x93D5, 0x93C4, 0x93CE,
0x93C0, 0x93D2, 0x93E7, 0x957D, 0x95DA, 0x95DB, 0x96E1, 0x9729,
0x972B, 0x972C, 0x9728, 0x9726, 0x97B3, 0x97B7, 0x97B6, 0x97DD,
0x97DE, 0x97DF, 0x985C, 0x9859, 0x985D, 0x9857, 0x98BF, 0x98BD,
0x98BB, 0x98BE, 0x9948, 0x9947, 0x9943, 0x99A6, 0x99A7, 0x9A1A,
0x9A15, 0x9A25, 0x9A1D, 0x9A24, 0x9A1B, 0x9A22, 0x9A20, 0x9A27,
0x9A23, 0x9A1E, 0x9A1C, 0x9A14, 0x9AC2, 0x9B0B, 0x9B0A, 0x9B0E,
0x9B0C, 0x9B37, 0x9BEA, 0x9BEB, 0x9BE0, 0x9BDE, 0x9BE4, 0x9BE6,
0x9BE2, 0x9BF0, 0x9BD4, 0x9BD7, 0x9BEC, 0x9BDC, 0x9BD9, 0x9BE5,
0x9BD5, 0x9BE1, 0x9BDA, 0x9D77, 0x9D81, 0x9D8A, 0x9D84, 0x9D88,
0x9D71, 0x9D80, 0x9D78, 0x9D86, 0x9D8B, 0x9D8C, 0x9D7D, 0x9D6B,
0x9D74, 0x9D75, 0x9D70, 0x9D69, 0x9D85, 0x9D73, 0x9D7B, 0x9D82,
0x9D6F, 0x9D79, 0x9D7F, 0x9D87, 0x9D68, 0x9E94, 0x9E91, 0x9EC0,
0x9EFC, 0x9F2D, 0x9F40, 0x9F41, 0x9F4D, 0x9F56, 0x9F57, 0x9F58,
0x5337, 0x56B2, 0x56B5, 0x56B3, 0x58E3, 0x5B45, 0x5DC6, 0x5DC7,
0x5EEE, 0x5EEF, 0x5FC0, 0x5FC1, 0x61F9, 0x6517, 0x6516, 0x6515,
0x6513, 0x65DF, 0x66E8, 0x66E3, 0x66E4, 0x6AF3, 0x6AF0, 0x6AEA,
0x6AE8, 0x6AF9, 0x6AF1, 0x6AEE, 0x6AEF, 0x703C, 0x7035, 0x702F,
0x7037, 0x7034, 0x7031, 0x7042, 0x7038, 0x703F, 0x703A, 0x7039,
0x7040, 0x703B, 0x7033, 0x7041, 0x7213, 0x7214, 0x72A8, 0x737D,
0x737C, 0x74BA, 0x76AB, 0x76AA, 0x76BE, 0x76ED, 0x77CC, 0x77CE,
0x77CF, 0x77CD, 0x77F2, 0x7925, 0x7923, 0x7927, 0x7928, 0x7924,
0x7929, 0x79B2, 0x7A6E, 0x7A6C, 0x7A6D, 0x7AF7, 0x7C49, 0x7C48,
0x7C4A, 0x7C47, 0x7C45, 0x7CEE, 0x7E7B, 0x7E7E, 0x7E81, 0x7E80,
0x7FBA, 0x7FFF, 0x8079, 0x81DB, 0x81D9, 0x820B, 0x8268, 0x8269,
0x8622, 0x85FF, 0x8601, 0x85FE, 0x861B, 0x8600, 0x85F6, 0x8604,
0x8609, 0x8605, 0x860C, 0x85FD, 0x8819, 0x8810, 0x8811, 0x8817,
0x8813, 0x8816, 0x8963, 0x8966, 0x89B9, 0x89F7, 0x8B60, 0x8B6A,
0x8B5D, 0x8B68, 0x8B63, 0x8B65, 0x8B67, 0x8B6D, 0x8DAE, 0x8E86,
0x8E88, 0x8E84, 0x8F59, 0x8F56, 0x8F57, 0x8F55, 0x8F58, 0x8F5A,
0x908D, 0x9143, 0x9141, 0x91B7, 0x91B5, 0x91B2, 0x91B3, 0x940B,
0x9413, 0x93FB, 0x9420, 0x940F, 0x9414, 0x93FE, 0x9415, 0x9410,
0x9428, 0x9419, 0x940D, 0x93F5, 0x9400, 0x93F7, 0x9407, 0x940E,
0x9416, 0x9412, 0x93FA, 0x9409, 0x93F8, 0x940A, 0x93FF, 0x93FC,
0x940C, 0x93F6, 0x9411, 0x9406, 0x95DE, 0x95E0, 0x95DF, 0x972E,
0x972F, 0x97B9, 0x97BB, 0x97FD, 0x97FE, 0x9860, 0x9862, 0x9863,
0x985F, 0x98C1, 0x98C2, 0x9950, 0x994E, 0x9959, 0x994C, 0x994B,
0x9953, 0x9A32, 0x9A34, 0x9A31, 0x9A2C, 0x9A2A, 0x9A36, 0x9A29,
0x9A2E, 0x9A38, 0x9A2D, 0x9AC7, 0x9ACA, 0x9AC6, 0x9B10, 0x9B12,
0x9B11, 0x9C0B, 0x9C08, 0x9BF7, 0x9C05, 0x9C12, 0x9BF8, 0x9C40,
0x9C07, 0x9C0E, 0x9C06, 0x9C17, 0x9C14, 0x9C09, 0x9D9F, 0x9D99,
0x9DA4, 0x9D9D, 0x9D92, 0x9D98, 0x9D90, 0x9D9B, 0x9DA0, 0x9D94,
0x9D9C, 0x9DAA, 0x9D97, 0x9DA1, 0x9D9A, 0x9DA2, 0x9DA8, 0x9D9E,
0x9DA3, 0x9DBF, 0x9DA9, 0x9D96, 0x9DA6, 0x9DA7, 0x9E99, 0x9E9B,
0x9E9A, 0x9EE5, 0x9EE4, 0x9EE7, 0x9EE6, 0x9F30, 0x9F2E, 0x9F5B,
0x9F60, 0x9F5E, 0x9F5D, 0x9F59, 0x9F91, 0x513A, 0x5139, 0x5298,
0x5297, 0x56C3, 0x56BD, 0x56BE, 0x5B48, 0x5B47, 0x5DCB, 0x5DCF,
0x5EF1, 0x61FD, 0x651B, 0x6B02, 0x6AFC, 0x6B03, 0x6AF8, 0x6B00,
0x7043, 0x7044, 0x704A, 0x7048, 0x7049, 0x7045, 0x7046, 0x721D,
0x721A, 0x7219, 0x737E, 0x7517, 0x766A, 0x77D0, 0x792D, 0x7931,
0x792F, 0x7C54, 0x7C53, 0x7CF2, 0x7E8A, 0x7E87, 0x7E88, 0x7E8B,
0x7E86, 0x7E8D, 0x7F4D, 0x7FBB, 0x8030, 0x81DD, 0x8618, 0x862A,
0x8626, 0x861F, 0x8623, 0x861C, 0x8619, 0x8627, 0x862E, 0x8621,
0x8620, 0x8629, 0x861E, 0x8625, 0x8829, 0x881D, 0x881B, 0x8820,
0x8824, 0x881C, 0x882B, 0x884A, 0x896D, 0x8969, 0x896E, 0x896B,
0x89FA, 0x8B79, 0x8B78, 0x8B45, 0x8B7A, 0x8B7B, 0x8D10, 0x8D14,
0x8DAF, 0x8E8E, 0x8E8C, 0x8F5E, 0x8F5B, 0x8F5D, 0x9146, 0x9144,
0x9145, 0x91B9, 0x943F, 0x943B, 0x9436, 0x9429, 0x943D, 0x943C,
0x9430, 0x9439, 0x942A, 0x9437, 0x942C, 0x9440, 0x9431, 0x95E5,
0x95E4, 0x95E3, 0x9735, 0x973A, 0x97BF, 0x97E1, 0x9864, 0x98C9,
0x98C6, 0x98C0, 0x9958, 0x9956, 0x9A39, 0x9A3D, 0x9A46, 0x9A44,
0x9A42, 0x9A41, 0x9A3A, 0x9A3F, 0x9ACD, 0x9B15, 0x9B17, 0x9B18,
0x9B16, 0x9B3A, 0x9B52, 0x9C2B, 0x9C1D, 0x9C1C, 0x9C2C, 0x9C23,
0x9C28, 0x9C29, 0x9C24, 0x9C21, 0x9DB7, 0x9DB6, 0x9DBC, 0x9DC1,
0x9DC7, 0x9DCA, 0x9DCF, 0x9DBE, 0x9DC5, 0x9DC3, 0x9DBB, 0x9DB5,
0x9DCE, 0x9DB9, 0x9DBA, 0x9DAC, 0x9DC8, 0x9DB1, 0x9DAD, 0x9DCC,
0x9DB3, 0x9DCD, 0x9DB2, 0x9E7A, 0x9E9C, 0x9EEB, 0x9EEE, 0x9EED,
0x9F1B, 0x9F18, 0x9F1A, 0x9F31, 0x9F4E, 0x9F65, 0x9F64, 0x9F92,
0x4EB9, 0x56C6, 0x56C5, 0x56CB, 0x5971, 0x5B4B, 0x5B4C, 0x5DD5,
0x5DD1, 0x5EF2, 0x6521, 0x6520, 0x6526, 0x6522, 0x6B0B, 0x6B08,
0x6B09, 0x6C0D, 0x7055, 0x7056, 0x7057, 0x7052, 0x721E, 0x721F,
0x72A9, 0x737F, 0x74D8, 0x74D5, 0x74D9, 0x74D7, 0x766D, 0x76AD,
0x7935, 0x79B4, 0x7A70, 0x7A71, 0x7C57, 0x7C5C, 0x7C59, 0x7C5B,
0x7C5A, 0x7CF4, 0x7CF1, 0x7E91, 0x7F4F, 0x7F87, 0x81DE, 0x826B,
0x8634, 0x8635, 0x8633, 0x862C, 0x8632, 0x8636, 0x882C, 0x8828,
0x8826, 0x882A, 0x8825, 0x8971, 0x89BF, 0x89BE, 0x89FB, 0x8B7E,
0x8B84, 0x8B82, 0x8B86, 0x8B85, 0x8B7F, 0x8D15, 0x8E95, 0x8E94,
0x8E9A, 0x8E92, 0x8E90, 0x8E96, 0x8E97, 0x8F60, 0x8F62, 0x9147,
0x944C, 0x9450, 0x944A, 0x944B, 0x944F, 0x9447, 0x9445, 0x9448,
0x9449, 0x9446, 0x973F, 0x97E3, 0x986A, 0x9869, 0x98CB, 0x9954,
0x995B, 0x9A4E, 0x9A53, 0x9A54, 0x9A4C, 0x9A4F, 0x9A48, 0x9A4A,
0x9A49, 0x9A52, 0x9A50, 0x9AD0, 0x9B19, 0x9B2B, 0x9B3B, 0x9B56,
0x9B55, 0x9C46, 0x9C48, 0x9C3F, 0x9C44, 0x9C39, 0x9C33, 0x9C41,
0x9C3C, 0x9C37, 0x9C34, 0x9C32, 0x9C3D, 0x9C36, 0x9DDB, 0x9DD2,
0x9DDE, 0x9DDA, 0x9DCB, 0x9DD0, 0x9DDC, 0x9DD1, 0x9DDF, 0x9DE9,
0x9DD9, 0x9DD8, 0x9DD6, 0x9DF5, 0x9DD5, 0x9DDD, 0x9EB6, 0x9EF0,
0x9F35, 0x9F33, 0x9F32, 0x9F42, 0x9F6B, 0x9F95, 0x9FA2, 0x513D,
0x5299, 0x58E8, 0x58E7, 0x5972, 0x5B4D, 0x5DD8, 0x882F, 0x5F4F,
0x6201, 0x6203, 0x6204, 0x6529, 0x6525, 0x6596, 0x66EB, 0x6B11,
0x6B12, 0x6B0F, 0x6BCA, 0x705B, 0x705A, 0x7222, 0x7382, 0x7381,
0x7383, 0x7670, 0x77D4, 0x7C67, 0x7C66, 0x7E95, 0x826C, 0x863A,
0x8640, 0x8639, 0x863C, 0x8631, 0x863B, 0x863E, 0x8830, 0x8832,
0x882E, 0x8833, 0x8976, 0x8974, 0x8973, 0x89FE, 0x8B8C, 0x8B8E,
0x8B8B, 0x8B88, 0x8C45, 0x8D19, 0x8E98, 0x8F64, 0x8F63, 0x91BC,
0x9462, 0x9455, 0x945D, 0x9457, 0x945E, 0x97C4, 0x97C5, 0x9800,
0x9A56, 0x9A59, 0x9B1E, 0x9B1F, 0x9B20, 0x9C52, 0x9C58, 0x9C50,
0x9C4A, 0x9C4D, 0x9C4B, 0x9C55, 0x9C59, 0x9C4C, 0x9C4E, 0x9DFB,
0x9DF7, 0x9DEF, 0x9DE3, 0x9DEB, 0x9DF8, 0x9DE4, 0x9DF6, 0x9DE1,
0x9DEE, 0x9DE6, 0x9DF2, 0x9DF0, 0x9DE2, 0x9DEC, 0x9DF4, 0x9DF3,
0x9DE8, 0x9DED, 0x9EC2, 0x9ED0, 0x9EF2, 0x9EF3, 0x9F06, 0x9F1C,
0x9F38, 0x9F37, 0x9F36, 0x9F43, 0x9F4F, 0x9F71, 0x9F70, 0x9F6E,
0x9F6F, 0x56D3, 0x56CD, 0x5B4E, 0x5C6D, 0x652D, 0x66ED, 0x66EE,
0x6B13, 0x705F, 0x7061, 0x705D, 0x7060, 0x7223, 0x74DB, 0x74E5,
0x77D5, 0x7938, 0x79B7, 0x79B6, 0x7C6A, 0x7E97, 0x7F89, 0x826D,
0x8643, 0x8838, 0x8837, 0x8835, 0x884B, 0x8B94, 0x8B95, 0x8E9E,
0x8E9F, 0x8EA0, 0x8E9D, 0x91BE, 0x91BD, 0x91C2, 0x946B, 0x9468,
0x9469, 0x96E5, 0x9746, 0x9743, 0x9747, 0x97C7, 0x97E5, 0x9A5E,
0x9AD5, 0x9B59, 0x9C63, 0x9C67, 0x9C66, 0x9C62, 0x9C5E, 0x9C60,
0x9E02, 0x9DFE, 0x9E07, 0x9E03, 0x9E06, 0x9E05, 0x9E00, 0x9E01,
0x9E09, 0x9DFF, 0x9DFD, 0x9E04, 0x9EA0, 0x9F1E, 0x9F46, 0x9F74,
0x9F75, 0x9F76, 0x56D4, 0x652E, 0x65B8, 0x6B18, 0x6B19, 0x6B17,
0x6B1A, 0x7062, 0x7226, 0x72AA, 0x77D8, 0x77D9, 0x7939, 0x7C69,
0x7C6B, 0x7CF6, 0x7E9A, 0x7E98, 0x7E9B, 0x7E99, 0x81E0, 0x81E1,
0x8646, 0x8647, 0x8648, 0x8979, 0x897A, 0x897C, 0x897B, 0x89FF,
0x8B98, 0x8B99, 0x8EA5, 0x8EA4, 0x8EA3, 0x946E, 0x946D, 0x946F,
0x9471, 0x9473, 0x9749, 0x9872, 0x995F, 0x9C68, 0x9C6E, 0x9C6D,
0x9E0B, 0x9E0D, 0x9E10, 0x9E0F, 0x9E12, 0x9E11, 0x9EA1, 0x9EF5,
0x9F09, 0x9F47, 0x9F78, 0x9F7B, 0x9F7A, 0x9F79, 0x571E, 0x7066,
0x7C6F, 0x883C, 0x8DB2, 0x8EA6, 0x91C3, 0x9474, 0x9478, 0x9476,
0x9475, 0x9A60, 0x9C74, 0x9C73, 0x9C71, 0x9C75, 0x9E14, 0x9E13,
0x9EF6, 0x9F0A, 0x9FA4, 0x7068, 0x7065, 0x7CF7, 0x866A, 0x883E,
0x883D, 0x883F, 0x8B9E, 0x8C9C, 0x8EA9, 0x8EC9, 0x974B, 0x9873,
0x9874, 0x98CC, 0x9961, 0x99AB, 0x9A64, 0x9A66, 0x9A67, 0x9B24,
0x9E15, 0x9E17, 0x9F48, 0x6207, 0x6B1E, 0x7227, 0x864C, 0x8EA8,
0x9482, 0x9480, 0x9481, 0x9A69, 0x9A68, 0x9B2E, 0x9E19, 0x7229,
0x864B, 0x8B9F, 0x9483, 0x9C79, 0x9EB7, 0x7675, 0x9A6B, 0x9C7A,
0x9E1D, 0x7069, 0x706A, 0x9EA4, 0x9F7E, 0x9F49, 0x9F98,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_BIG5_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_big5.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 193,686
|
```objective-c
/* zueci.h - UTF-8 to/from Extended Channel Interpretations */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_H
#define ZUECI_H
/* Version: 1.0.1 */
/* Warning and error returns from API functions below */
#define ZUECI_WARN_INVALID_DATA 1 /* Invalid data but replacement character used */
#define ZUECI_ERROR 5 /* Warn/error marker, not returned */
#define ZUECI_ERROR_INVALID_DATA 6 /* Source data invalid or unmappable */
#define ZUECI_ERROR_INVALID_ECI 7 /* ECI not a valid Character Set ECI */
#define ZUECI_ERROR_INVALID_ARGS 8 /* One or more arguments invalid (e.g. NULL) */
#define ZUECI_ERROR_INVALID_UTF8 9 /* Source data not valid UTF-8 */
#ifdef _WIN32
# if defined(DLL_EXPORT) || defined(PIC) || defined(_USRDLL)
# define ZUECI_EXTERN __declspec(dllexport)
# elif defined(ZUECI_DLL)
# define ZUECI_EXTERN __declspec(dllimport)
# else
# define ZUECI_EXTERN extern
# endif
#else
# define ZUECI_EXTERN extern
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
ECI arg `eci` must be a valid Interpretative Character Set ECI, i.e. 0-13, 15-18, 20-35, 170 or 899,
as defined by AIM ITS/04-023 International Technical Standard - Extended Channel Interpretations
Part 3: Register (Version 2, February 2022):
0 IBM CP437 (top)
1 ISO/IEC 8859-1 - Latin alphabet No. 1 (top)
2 IBM CP437 (top)
3 ISO/IEC 8859-1 - Latin alphabet No. 1 (top)
4 ISO/IEC 8859-2 - Latin alphabet No. 2 (top)
5 ISO/IEC 8859-3 - Latin alphabet No. 3 (top)
6 ISO/IEC 8859-4 - Latin alphabet No. 4 (top)
7 ISO/IEC 8859-5 - Latin/Cyrillic alphabet (top)
8 ISO/IEC 8859-6 - Latin/Arabic alphabet (top)
9 ISO/IEC 8859-7 - Latin/Greek alphabet (top)
10 ISO/IEC 8859-8 - Latin/Hebrew alphabet (top)
11 ISO/IEC 8859-9 - Latin alphabet No. 5 (Turkish) (top)
12 ISO/IEC 8859-10 - Latin alphabet No. 6 (Nordic) (top)
13 ISO/IEC 8859-11 - Latin/Thai alphabet (top)
15 ISO/IEC 8859-13 - Latin alphabet No. 7 (Baltic) (top)
16 ISO/IEC 8859-14 - Latin alphabet No. 8 (Celtic) (top)
17 ISO/IEC 8859-15 - Latin alphabet No. 9 (top)
18 ISO/IEC 8859-16 - Latin alphabet No. 10 (top)
20 Shift JIS (JIS X 0208 and JIS X 0201) Japanese
21 Windows 1250 - Latin 2 (Central Europe)
22 Windows 1251 - Cyrillic
23 Windows 1252 - Latin 1
24 Windows 1256 - Arabic
25 UTF-16BE (big-endian)
26 UTF-8
27 ASCII (ISO/IEC 646 IRV)
28 Big5 (Taiwan) Chinese
29 GB 2312 (PRC) Chinese
30 EUC-KR (KS X 1001:2002) Korean
31 GBK Chinese
32 GB 18030 Chinese
33 UTF-16LE (little-endian)
34 UTF-32BE (big-endian)
35 UTF-32LE (little-endian)
170 ISO/IEC 646 Invariant
899 8-bit binary data
"(top)" means encoding applies to codepoints 0x80..FF (or 0xA0..FF for ISO/IEC 8859) with 0x00..7F as ASCII
ECIs 0, 1 and 2 are obsolete, however ECI 2 is still referenced by ISO/IEC 15438:2015 (PDF417) Annex H.2.3
All except ECI 20 (Shift JIS) and ECI 170 (ISO/IEC 646 Invariant) map ASCII one-to-one (but see
`ZUECI_FLAG_XXX` flags below).
ECI 20 re-maps 2 characters (backslash and tilde), and ECI 170 has no mapping for 12 characters (#$@[\]^`{|}~).
All mappings are the same as libiconv with the following exception for ECI 20 (Shift JIS):
Unicode Shift JIS Unicode
libzueci U+005C -> 0x815F -> U+005C (U+005C REVERSE SOLIDUS)
U+FF3C -> no mapping (U+FF3C FULLWIDTH REVERSE SOLIDUS)
libiconv U+005C -> no mapping
U+FF3C -> 0x815F -> U+FF3C
The rationale for this difference is that libzueci is following the "official" source
path_to_url
(2015-12-02) which gives those mappings. (Note "official" is used loosely, there's no such thing unfortunately.)
Could not find a reason for libiconv doing it its way from reading the source.
All other mappings are the same; in particular:
Unicode Shift JIS Unicode
U+007E -> no mapping (U+007E TILDE)
U+203E -> 0x7E -> U+202E (U+203E OVERLINE)
U+00A5 -> 0x5C -> U+00A5 (U+00A5 YEN SIGN)
*/
/*
If embedding the library (i.e. including the 10 files directly) and only want ECI-to-UTF-8 functionality,
define `ZUECI_EMBED_NO_TO_ECI`
*/
#ifndef ZUECI_EMBED_NO_TO_ECI
/*
Convert UTF-8 `src` of length `src_len` to `eci`-encoded `dest`.
`p_dest_len` is set to length of `dest` on output.
`dest` must be big enough (4-times the `src_len`, or see `zueci_dest_len_eci()`). It is not NUL-terminated.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_utf8_to_eci(const int eci, const unsigned char src[], const int src_len,
unsigned char dest[], int *p_dest_len);
/*
Calculate sufficient (i.e. approx.) length needed to convert UTF-8 `src` of length `len` from UTF-8 to ECI
`eci`, and place in `p_dest_len`.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_dest_len_eci(const int eci, const unsigned char src[], const int src_len, int *p_dest_len);
#endif /* ZUECI_EMBED_NO_TO_ECI */
/*
These flags can be OR-ed together to change the behaviour of `zueci_eci_to_utf8()` and `zueci_dest_len_utf8()`
*/
/*
For single-byte ECIs copy the source straight-thru rather than erroring or replacing if undefined. Affects
ISO/IEC 8859 (ECIs 1, 3-13, 15-18), Windows 125x (ECIs 21-24), ASCII (ECI 27) & ISO/IEC 646 Invariant (ECI 170).
*/
#define ZUECI_FLAG_SB_STRAIGHT_THRU 1
/*
For ECI 20 Shift JIS, copy backslash & tilde straight-thru rather than mapping to Yen sign & overline resp.
*/
#define ZUECI_FLAG_SJIS_STRAIGHT_THRU 2
/*
If embedding the library (i.e. including the 10 files directly) and only want UTF-8-to-ECI functionality,
define `ZUECI_EMBED_NO_TO_UTF8`
*/
#ifndef ZUECI_EMBED_NO_TO_UTF8
/*
Convert ECI-encoded `src` of length `src_len` to UTF-8 `dest`.
`p_dest_len` is set to length of `dest` on output.
`dest` must be big enough (4-times the `src_len`, or see `zueci_dest_len_utf8()`). It is not NUL-terminated.
If the Unicode BMP `replacement_char` (<= 0xFFFF) is non-zero then it will substituted for all source characters
with no mapping and processing will continue, returning ZUECI_WARN_INVALID_DATA unless other errors.
`flags` can be set with `ZUECI_FLAG_XXX` to change behaviour.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_eci_to_utf8(const int eci, const unsigned char src[], const int src_len,
const unsigned int replacement_char, const unsigned int flags, unsigned char dest[],
int *p_dest_len);
/*
Calculate exact length needed to convert ECI-encoded `src` of length `len` from ECI `eci`, and place in
`p_dest_len`.
Returns 0 if successful, one of `ZUECI_ERROR_XXX` if not.
*/
ZUECI_EXTERN int zueci_dest_len_utf8(const int eci, const unsigned char src[], const int src_len,
const unsigned int replacement_char, const unsigned int flags, int *p_dest_len);
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifdef __cplusplus
}
#endif
/* vim: set ts=4 sw=4 et : */
#endif /* ZUECI_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,392
|
```objective-c
/* gb18030.h - tables for Unicode to/from ECI 32 GB 18030-2005, generated by "tools/gen_zueci_mb_h.php" from
"jdk-1.4.2/GB18030.TXT"
(see path_to_url */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_GB18030_H
#define ZUECI_GB18030_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_gb18030_2_u_u[273] = {
0x01F9, 0x1E3F, 0x20AC, 0x2E81, 0x2E84, 0x2E88, 0x2E8B, 0x2E8C,
0x2E97, 0x2EA7, 0x2EAA, 0x2EAE, 0x2EB3, 0x2EB6, 0x2EB7, 0x2EBB,
0x2ECA, 0x2FF0, 0x2FF1, 0x2FF2, 0x2FF3, 0x2FF4, 0x2FF5, 0x2FF6,
0x2FF7, 0x2FF8, 0x2FF9, 0x2FFA, 0x2FFB, 0x303E, 0x3447, 0x3473,
0x359E, 0x360E, 0x361A, 0x3918, 0x396E, 0x39CF, 0x39D0, 0x39DF,
0x3A73, 0x3B4E, 0x3C6E, 0x3CE0, 0x4056, 0x415F, 0x4337, 0x43AC,
0x43B1, 0x43DD, 0x44D6, 0x464C, 0x4661, 0x4723, 0x4729, 0x477C,
0x478D, 0x4947, 0x497A, 0x497D, 0x4982, 0x4983, 0x4985, 0x4986,
0x499B, 0x499F, 0x49B6, 0x49B7, 0x4C77, 0x4C9F, 0x4CA0, 0x4CA1,
0x4CA2, 0x4CA3, 0x4D13, 0x4D14, 0x4D15, 0x4D16, 0x4D17, 0x4D18,
0x4D19, 0x4DAE, 0x9FB4, 0x9FB5, 0x9FB6, 0x9FB7, 0x9FB8, 0x9FB9,
0x9FBA, 0x9FBB, 0xE766, 0xE767, 0xE768, 0xE769, 0xE76A, 0xE76B,
0xE76D, 0xE76E, 0xE76F, 0xE770, 0xE771, 0xE772, 0xE773, 0xE774,
0xE775, 0xE776, 0xE777, 0xE778, 0xE779, 0xE77A, 0xE77B, 0xE77C,
0xE77D, 0xE77E, 0xE77F, 0xE780, 0xE781, 0xE782, 0xE783, 0xE784,
0xE785, 0xE786, 0xE787, 0xE788, 0xE789, 0xE78A, 0xE78B, 0xE78C,
0xE78D, 0xE78E, 0xE78F, 0xE790, 0xE791, 0xE792, 0xE793, 0xE794,
0xE795, 0xE796, 0xE797, 0xE798, 0xE799, 0xE79A, 0xE79B, 0xE79C,
0xE79D, 0xE79E, 0xE79F, 0xE7A0, 0xE7A1, 0xE7A2, 0xE7A3, 0xE7A4,
0xE7A5, 0xE7A6, 0xE7A7, 0xE7A8, 0xE7A9, 0xE7AA, 0xE7AB, 0xE7AC,
0xE7AD, 0xE7AE, 0xE7AF, 0xE7B0, 0xE7B1, 0xE7B2, 0xE7B3, 0xE7B4,
0xE7B5, 0xE7B6, 0xE7B7, 0xE7B8, 0xE7B9, 0xE7BA, 0xE7BB, 0xE7BC,
0xE7BD, 0xE7BE, 0xE7BF, 0xE7C0, 0xE7C1, 0xE7C2, 0xE7C3, 0xE7C4,
0xE7C5, 0xE7C6, 0xE7C9, 0xE7CA, 0xE7CB, 0xE7CC, 0xE7CD, 0xE7CE,
0xE7CF, 0xE7D0, 0xE7D1, 0xE7D2, 0xE7D3, 0xE7D4, 0xE7D5, 0xE7D6,
0xE7D7, 0xE7D8, 0xE7D9, 0xE7DA, 0xE7DB, 0xE7DC, 0xE7DD, 0xE7DE,
0xE7DF, 0xE7E0, 0xE7E1, 0xE7E2, 0xE7E3, 0xE7E4, 0xE7E5, 0xE7E6,
0xE7F4, 0xE7F5, 0xE7F6, 0xE7F7, 0xE7F8, 0xE7F9, 0xE7FA, 0xE7FB,
0xE7FC, 0xE7FD, 0xE7FE, 0xE7FF, 0xE800, 0xE801, 0xE802, 0xE803,
0xE804, 0xE805, 0xE806, 0xE807, 0xE808, 0xE809, 0xE80A, 0xE80B,
0xE80C, 0xE80D, 0xE80E, 0xE80F, 0xE810, 0xE811, 0xE812, 0xE813,
0xE814, 0xE816, 0xE817, 0xE818, 0xE81E, 0xE826, 0xE82B, 0xE82C,
0xE831, 0xE832, 0xE83B, 0xE843, 0xE854, 0xE855, 0xE864, 0xFE10,
0xFE11, 0xFE12, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17, 0xFE18,
0xFE19,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_gb18030_2_u_mb[273] = {
0xA8BF, 0xA8BC, 0xA2E3, 0xFE50, 0xFE54, 0xFE57, 0xFE58, 0xFE5D,
0xFE5E, 0xFE6B, 0xFE6E, 0xFE71, 0xFE73, 0xFE74, 0xFE75, 0xFE79,
0xFE84, 0xA98A, 0xA98B, 0xA98C, 0xA98D, 0xA98E, 0xA98F, 0xA990,
0xA991, 0xA992, 0xA993, 0xA994, 0xA995, 0xA989, 0xFE56, 0xFE55,
0xFE5A, 0xFE5C, 0xFE5B, 0xFE60, 0xFE5F, 0xFE62, 0xFE65, 0xFE63,
0xFE64, 0xFE68, 0xFE69, 0xFE6A, 0xFE6F, 0xFE70, 0xFE72, 0xFE78,
0xFE77, 0xFE7A, 0xFE7B, 0xFE7D, 0xFE7C, 0xFE80, 0xFE81, 0xFE82,
0xFE83, 0xFE85, 0xFE86, 0xFE87, 0xFE88, 0xFE89, 0xFE8A, 0xFE8B,
0xFE8D, 0xFE8C, 0xFE8F, 0xFE8E, 0xFE96, 0xFE93, 0xFE94, 0xFE95,
0xFE97, 0xFE92, 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D,
0xFE9E, 0xFE9F, 0xFE59, 0xFE61, 0xFE66, 0xFE67, 0xFE6D, 0xFE7E,
0xFE90, 0xFEA0, 0xA2AB, 0xA2AC, 0xA2AD, 0xA2AE, 0xA2AF, 0xA2B0,
0xA2E4, 0xA2EF, 0xA2F0, 0xA2FD, 0xA2FE, 0xA4F4, 0xA4F5, 0xA4F6,
0xA4F7, 0xA4F8, 0xA4F9, 0xA4FA, 0xA4FB, 0xA4FC, 0xA4FD, 0xA4FE,
0xA5F7, 0xA5F8, 0xA5F9, 0xA5FA, 0xA5FB, 0xA5FC, 0xA5FD, 0xA5FE,
0xA6B9, 0xA6BA, 0xA6BB, 0xA6BC, 0xA6BD, 0xA6BE, 0xA6BF, 0xA6C0,
0xA6D9, 0xA6DA, 0xA6DB, 0xA6DC, 0xA6DD, 0xA6DE, 0xA6DF, 0xA6EC,
0xA6ED, 0xA6F3, 0xA6F6, 0xA6F7, 0xA6F8, 0xA6F9, 0xA6FA, 0xA6FB,
0xA6FC, 0xA6FD, 0xA6FE, 0xA7C2, 0xA7C3, 0xA7C4, 0xA7C5, 0xA7C6,
0xA7C7, 0xA7C8, 0xA7C9, 0xA7CA, 0xA7CB, 0xA7CC, 0xA7CD, 0xA7CE,
0xA7CF, 0xA7D0, 0xA7F2, 0xA7F3, 0xA7F4, 0xA7F5, 0xA7F6, 0xA7F7,
0xA7F8, 0xA7F9, 0xA7FA, 0xA7FB, 0xA7FC, 0xA7FD, 0xA7FE, 0xA896,
0xA897, 0xA898, 0xA899, 0xA89A, 0xA89B, 0xA89C, 0xA89D, 0xA89E,
0xA89F, 0xA8A0, 0xA8C1, 0xA8C2, 0xA8C3, 0xA8C4, 0xA8EA, 0xA8EB,
0xA8EC, 0xA8ED, 0xA8EE, 0xA8EF, 0xA8F0, 0xA8F1, 0xA8F2, 0xA8F3,
0xA8F4, 0xA8F5, 0xA8F6, 0xA8F7, 0xA8F8, 0xA8F9, 0xA8FA, 0xA8FB,
0xA8FC, 0xA8FD, 0xA8FE, 0xA958, 0xA95B, 0xA95D, 0xA95E, 0xA95F,
0xA997, 0xA998, 0xA999, 0xA99A, 0xA99B, 0xA99C, 0xA99D, 0xA99E,
0xA99F, 0xA9A0, 0xA9A1, 0xA9A2, 0xA9A3, 0xA9F0, 0xA9F1, 0xA9F2,
0xA9F3, 0xA9F4, 0xA9F5, 0xA9F6, 0xA9F7, 0xA9F8, 0xA9F9, 0xA9FA,
0xA9FB, 0xA9FC, 0xA9FD, 0xA9FE, 0xD7FA, 0xD7FB, 0xD7FC, 0xD7FD,
0xD7FE, 0xFE51, 0xFE52, 0xFE53, 0xFE59, 0xFE61, 0xFE66, 0xFE67,
0xFE6C, 0xFE6D, 0xFE76, 0xFE7E, 0xFE90, 0xFE91, 0xFEA0, 0xA6D9,
0xA6DB, 0xA6DA, 0xA6DC, 0xA6DD, 0xA6DE, 0xA6DF, 0xA6EC, 0xA6ED,
0xA6F3,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
/* End Unicode codepoints of blocks mapping consecutively to 4-byte multibyte blocks */
static const zueci_u16 zueci_gb18030_4_u_e[206] = {
0x00A3, 0x00A6, 0x00AF, 0x00B6, 0x00D6, 0x00DF, 0x00E7, 0x00EB,
0x00F1, 0x00F6, 0x00F8, 0x00FB, 0x0100, 0x0112, 0x011A, 0x012A,
0x0143, 0x0147, 0x014C, 0x016A, 0x01CD, 0x01CF, 0x01D1, 0x01D3,
0x01D5, 0x01D7, 0x01D9, 0x01DB, 0x01F8, 0x0250, 0x0260, 0x02C6,
0x02C8, 0x02D8, 0x0390, 0x03A2, 0x03B0, 0x03C2, 0x0400, 0x040F,
0x0450, 0x200F, 0x2012, 0x2017, 0x201B, 0x2024, 0x202F, 0x2031,
0x2034, 0x203A, 0x20AB, 0x2102, 0x2104, 0x2108, 0x2115, 0x2120,
0x215F, 0x216F, 0x218F, 0x2195, 0x2207, 0x220E, 0x2210, 0x2214,
0x2219, 0x221C, 0x2222, 0x2224, 0x2226, 0x222D, 0x2233, 0x223C,
0x2247, 0x224B, 0x2251, 0x225F, 0x2263, 0x226D, 0x2294, 0x2298,
0x22A4, 0x22BE, 0x2311, 0x245F, 0x2473, 0x24FF, 0x254F, 0x2580,
0x2592, 0x259F, 0x25B1, 0x25BB, 0x25C5, 0x25CA, 0x25CD, 0x25E1,
0x2604, 0x2608, 0x263F, 0x2641, 0x2E80, 0x2E83, 0x2E87, 0x2E8A,
0x2E96, 0x2EA6, 0x2EA9, 0x2EAD, 0x2EB2, 0x2EB5, 0x2EBA, 0x2EC9,
0x2FEF, 0x2FFF, 0x3004, 0x301C, 0x3020, 0x303D, 0x3040, 0x309A,
0x30A0, 0x30FB, 0x3104, 0x321F, 0x3230, 0x32A2, 0x338D, 0x339B,
0x33A0, 0x33C3, 0x33CD, 0x33D0, 0x33D4, 0x3446, 0x3472, 0x359D,
0x360D, 0x3619, 0x3917, 0x396D, 0x39CE, 0x39DE, 0x3A72, 0x3B4D,
0x3C6D, 0x3CDF, 0x4055, 0x415E, 0x4336, 0x43AB, 0x43B0, 0x43DC,
0x44D5, 0x464B, 0x4660, 0x4722, 0x4728, 0x477B, 0x478C, 0x4946,
0x4979, 0x497C, 0x4981, 0x4984, 0x499A, 0x499E, 0x49B5, 0x4C76,
0x4C9E, 0x4D12, 0x4DAD, 0x4DFF, 0xD7FF, 0xE76C, 0xE7C8, 0xE7F3,
0xE815, 0xE81D, 0xE825, 0xE82A, 0xE830, 0xE83A, 0xE842, 0xE853,
0xE863, 0xF92B, 0xF978, 0xF994, 0xF9E6, 0xF9F0, 0xFA0B, 0xFA10,
0xFA12, 0xFA17, 0xFA1E, 0xFA22, 0xFA26, 0xFE2F, 0xFE32, 0xFE48,
0xFE53, 0xFE58, 0xFE67, 0xFF00, 0xFFDF, 0xFFFF,
};
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Cumulative gaps between Unicode blocks mapping consecutively to 4-byte multibyte blocks,
used to adjust multibyte offsets */
static const zueci_u16 zueci_gb18030_4_u_mb_o[206] = {
0, 1, 3, 5, 6, 7, 9, 12,
14, 16, 17, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39,
40, 43, 44, 61, 68, 85, 92, 93,
157, 158, 159, 163, 165, 167, 169, 170,
172, 173, 174, 175, 176, 177, 178, 179,
180, 192, 202, 206, 210, 211, 212, 213,
214, 215, 219, 220, 221, 226, 227, 231,
232, 233, 234, 235, 237, 241, 243, 244,
245, 246, 247, 248, 258, 298, 374, 410,
425, 428, 430, 432, 434, 436, 437, 439,
443, 445, 446, 447, 448, 449, 450, 451,
453, 454, 455, 456, 457, 458, 460, 461,
462, 474, 478, 497, 499, 508, 509, 592,
596, 682, 685, 722, 732, 733, 734, 736,
739, 740, 741, 742, 744, 745, 746, 747,
748, 749, 750, 751, 752, 754, 755, 756,
757, 758, 759, 760, 761, 762, 763, 764,
765, 766, 767, 768, 769, 770, 771, 772,
773, 774, 775, 777, 779, 780, 781, 783,
784, 789, 796, 797, 21699, 25647, 25738, 25768,
25801, 25804, 25805, 25806, 25808, 25810, 25811, 25812,
25814, 25815, 25816, 25817, 25818, 25819, 25820, 25824,
25825, 25827, 25828, 25831, 25833, 25836, 25838, 25856,
25866, 25870, 25884, 25888, 25982, 25988,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* End multibyte codepoints of blocks mapping consecutively to 4-byte multibyte blocks */
static const zueci_u32 zueci_gb18030_4_mb_e[206] = {
0x81308435, 0x81308437, 0x81308534, 0x81308539, 0x81308930, 0x81308938, 0x81308A34, 0x81308A35,
0x81308A39, 0x81308B32, 0x81308B33, 0x81308B34, 0x81308B38, 0x81308D35, 0x81308E32, 0x81308F37,
0x81309231, 0x81309234, 0x81309238, 0x81309537, 0x81309F35, 0x81309F36, 0x81309F37, 0x81309F38,
0x81309F39, 0x8130A030, 0x8130A031, 0x8130A032, 0x8130A330, 0x8130AB37, 0x8130AD32, 0x8130B733,
0x8130B734, 0x8130B837, 0x8130CB30, 0x8130CB31, 0x8130CB38, 0x8130CB39, 0x8130D134, 0x8130D238,
0x8130D239, 0x8136A531, 0x8136A533, 0x8136A534, 0x8136A536, 0x8136A633, 0x8136A732, 0x8136A733,
0x8136A734, 0x8136A739, 0x8136B331, 0x8136BB37, 0x8136BB38, 0x8136BC31, 0x8136BD33, 0x8136BE33,
0x8136C435, 0x8136C439, 0x8136C731, 0x8136C733, 0x8136D233, 0x8136D239, 0x8136D330, 0x8136D333,
0x8136D337, 0x8136D339, 0x8136D431, 0x8136D432, 0x8136D433, 0x8136D435, 0x8136D530, 0x8136D535,
0x8136D635, 0x8136D638, 0x8136D733, 0x8136D836, 0x8136D838, 0x8136D934, 0x8136DD31, 0x8136DD34,
0x8136DE35, 0x8136E130, 0x8136E932, 0x81378C35, 0x81378D35, 0x81379735, 0x81379739, 0x81379932,
0x81379935, 0x81379A35, 0x81379C31, 0x81379C39, 0x81379D37, 0x81379E30, 0x81379E32, 0x8137A030,
0x8137A331, 0x8137A333, 0x8137A837, 0x8137A838, 0x8138FD38, 0x8138FE30, 0x8138FE33, 0x8138FE35,
0x81398135, 0x81398330, 0x81398332, 0x81398335, 0x81398339, 0x81398431, 0x81398434, 0x81398538,
0x8139A331, 0x8139A335, 0x8139A336, 0x8139A431, 0x8139A433, 0x8139A633, 0x8139A635, 0x8139A732,
0x8139A734, 0x8139A739, 0x8139A835, 0x8139C131, 0x8139C138, 0x8139CD31, 0x8139E435, 0x8139E537,
0x8139E539, 0x8139E933, 0x8139EA32, 0x8139EA34, 0x8139EA36, 0x8139F539, 0x8139FA32, 0x82309A30,
0x8230A531, 0x8230A632, 0x8230F237, 0x8230FB32, 0x82318638, 0x82318832, 0x82319639, 0x8231AC37,
0x8231C934, 0x8231D437, 0x8232AF32, 0x8232C936, 0x8232F837, 0x82338633, 0x82338637, 0x82338B30,
0x8233A338, 0x8233C931, 0x8233CB31, 0x8233DE34, 0x8233DE39, 0x8233E731, 0x8233E837, 0x82349638,
0x82349B38, 0x82349C30, 0x82349C34, 0x82349C35, 0x82349E35, 0x82349E38, 0x8234A130, 0x8234E733,
0x8234EB32, 0x8234F633, 0x82358731, 0x82358F32, 0x8336C738, 0x8336C739, 0x8336C830, 0x8336C933,
0x8336C934, 0x8336C939, 0x8336CA36, 0x8336CB30, 0x8336CB34, 0x8336CC32, 0x8336CC39, 0x8336CE35,
0x8336CF39, 0x84308534, 0x84308D30, 0x84308F37, 0x84309738, 0x84309837, 0x84309B33, 0x84309B34,
0x84309B35, 0x84309B38, 0x84309C34, 0x84309C35, 0x84309C37, 0x84318537, 0x84318538, 0x84318632,
0x84318633, 0x84318634, 0x84318635, 0x84319534, 0x8431A233, 0x8431A439,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Multibyte values sorted in multibyte order */
static const zueci_u16 zueci_gb18030_2_mb_mb[255] = {
0xA2AB, 0xA2AC, 0xA2AD, 0xA2AE, 0xA2AF, 0xA2B0, 0xA2E3, 0xA2E4,
0xA2EF, 0xA2F0, 0xA2FD, 0xA2FE, 0xA4F4, 0xA4F5, 0xA4F6, 0xA4F7,
0xA4F8, 0xA4F9, 0xA4FA, 0xA4FB, 0xA4FC, 0xA4FD, 0xA4FE, 0xA5F7,
0xA5F8, 0xA5F9, 0xA5FA, 0xA5FB, 0xA5FC, 0xA5FD, 0xA5FE, 0xA6B9,
0xA6BA, 0xA6BB, 0xA6BC, 0xA6BD, 0xA6BE, 0xA6BF, 0xA6C0, 0xA6D9,
0xA6DA, 0xA6DB, 0xA6DC, 0xA6DD, 0xA6DE, 0xA6DF, 0xA6EC, 0xA6ED,
0xA6F3, 0xA6F6, 0xA6F7, 0xA6F8, 0xA6F9, 0xA6FA, 0xA6FB, 0xA6FC,
0xA6FD, 0xA6FE, 0xA7C2, 0xA7C3, 0xA7C4, 0xA7C5, 0xA7C6, 0xA7C7,
0xA7C8, 0xA7C9, 0xA7CA, 0xA7CB, 0xA7CC, 0xA7CD, 0xA7CE, 0xA7CF,
0xA7D0, 0xA7F2, 0xA7F3, 0xA7F4, 0xA7F5, 0xA7F6, 0xA7F7, 0xA7F8,
0xA7F9, 0xA7FA, 0xA7FB, 0xA7FC, 0xA7FD, 0xA7FE, 0xA896, 0xA897,
0xA898, 0xA899, 0xA89A, 0xA89B, 0xA89C, 0xA89D, 0xA89E, 0xA89F,
0xA8A0, 0xA8BC, 0xA8BF, 0xA8C1, 0xA8C2, 0xA8C3, 0xA8C4, 0xA8EA,
0xA8EB, 0xA8EC, 0xA8ED, 0xA8EE, 0xA8EF, 0xA8F0, 0xA8F1, 0xA8F2,
0xA8F3, 0xA8F4, 0xA8F5, 0xA8F6, 0xA8F7, 0xA8F8, 0xA8F9, 0xA8FA,
0xA8FB, 0xA8FC, 0xA8FD, 0xA8FE, 0xA958, 0xA95B, 0xA95D, 0xA95E,
0xA95F, 0xA989, 0xA98A, 0xA98B, 0xA98C, 0xA98D, 0xA98E, 0xA98F,
0xA990, 0xA991, 0xA992, 0xA993, 0xA994, 0xA995, 0xA997, 0xA998,
0xA999, 0xA99A, 0xA99B, 0xA99C, 0xA99D, 0xA99E, 0xA99F, 0xA9A0,
0xA9A1, 0xA9A2, 0xA9A3, 0xA9F0, 0xA9F1, 0xA9F2, 0xA9F3, 0xA9F4,
0xA9F5, 0xA9F6, 0xA9F7, 0xA9F8, 0xA9F9, 0xA9FA, 0xA9FB, 0xA9FC,
0xA9FD, 0xA9FE, 0xD7FA, 0xD7FB, 0xD7FC, 0xD7FD, 0xD7FE, 0xFE50,
0xFE51, 0xFE52, 0xFE53, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE58,
0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F, 0xFE60,
0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE67, 0xFE68,
0xFE69, 0xFE6A, 0xFE6B, 0xFE6C, 0xFE6D, 0xFE6E, 0xFE6F, 0xFE70,
0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE75, 0xFE76, 0xFE77, 0xFE78,
0xFE79, 0xFE7A, 0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE80, 0xFE81,
0xFE82, 0xFE83, 0xFE84, 0xFE85, 0xFE86, 0xFE87, 0xFE88, 0xFE89,
0xFE8A, 0xFE8B, 0xFE8C, 0xFE8D, 0xFE8E, 0xFE8F, 0xFE90, 0xFE91,
0xFE92, 0xFE93, 0xFE94, 0xFE95, 0xFE96, 0xFE97, 0xFE98, 0xFE99,
0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E, 0xFE9F, 0xFEA0,
};
/* Unicode values sorted in multibyte order */
static const zueci_u16 zueci_gb18030_2_mb_u[255] = {
0xE766, 0xE767, 0xE768, 0xE769, 0xE76A, 0xE76B, 0x20AC, 0xE76D,
0xE76E, 0xE76F, 0xE770, 0xE771, 0xE772, 0xE773, 0xE774, 0xE775,
0xE776, 0xE777, 0xE778, 0xE779, 0xE77A, 0xE77B, 0xE77C, 0xE77D,
0xE77E, 0xE77F, 0xE780, 0xE781, 0xE782, 0xE783, 0xE784, 0xE785,
0xE786, 0xE787, 0xE788, 0xE789, 0xE78A, 0xE78B, 0xE78C, 0xFE10,
0xFE12, 0xFE11, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17, 0xFE18,
0xFE19, 0xE797, 0xE798, 0xE799, 0xE79A, 0xE79B, 0xE79C, 0xE79D,
0xE79E, 0xE79F, 0xE7A0, 0xE7A1, 0xE7A2, 0xE7A3, 0xE7A4, 0xE7A5,
0xE7A6, 0xE7A7, 0xE7A8, 0xE7A9, 0xE7AA, 0xE7AB, 0xE7AC, 0xE7AD,
0xE7AE, 0xE7AF, 0xE7B0, 0xE7B1, 0xE7B2, 0xE7B3, 0xE7B4, 0xE7B5,
0xE7B6, 0xE7B7, 0xE7B8, 0xE7B9, 0xE7BA, 0xE7BB, 0xE7BC, 0xE7BD,
0xE7BE, 0xE7BF, 0xE7C0, 0xE7C1, 0xE7C2, 0xE7C3, 0xE7C4, 0xE7C5,
0xE7C6, 0x1E3F, 0x01F9, 0xE7C9, 0xE7CA, 0xE7CB, 0xE7CC, 0xE7CD,
0xE7CE, 0xE7CF, 0xE7D0, 0xE7D1, 0xE7D2, 0xE7D3, 0xE7D4, 0xE7D5,
0xE7D6, 0xE7D7, 0xE7D8, 0xE7D9, 0xE7DA, 0xE7DB, 0xE7DC, 0xE7DD,
0xE7DE, 0xE7DF, 0xE7E0, 0xE7E1, 0xE7E2, 0xE7E3, 0xE7E4, 0xE7E5,
0xE7E6, 0x303E, 0x2FF0, 0x2FF1, 0x2FF2, 0x2FF3, 0x2FF4, 0x2FF5,
0x2FF6, 0x2FF7, 0x2FF8, 0x2FF9, 0x2FFA, 0x2FFB, 0xE7F4, 0xE7F5,
0xE7F6, 0xE7F7, 0xE7F8, 0xE7F9, 0xE7FA, 0xE7FB, 0xE7FC, 0xE7FD,
0xE7FE, 0xE7FF, 0xE800, 0xE801, 0xE802, 0xE803, 0xE804, 0xE805,
0xE806, 0xE807, 0xE808, 0xE809, 0xE80A, 0xE80B, 0xE80C, 0xE80D,
0xE80E, 0xE80F, 0xE810, 0xE811, 0xE812, 0xE813, 0xE814, 0x2E81,
0xE816, 0xE817, 0xE818, 0x2E84, 0x3473, 0x3447, 0x2E88, 0x2E8B,
0x9FB4, 0x359E, 0x361A, 0x360E, 0x2E8C, 0x2E97, 0x396E, 0x3918,
0x9FB5, 0x39CF, 0x39DF, 0x3A73, 0x39D0, 0x9FB6, 0x9FB7, 0x3B4E,
0x3C6E, 0x3CE0, 0x2EA7, 0xE831, 0x9FB8, 0x2EAA, 0x4056, 0x415F,
0x2EAE, 0x4337, 0x2EB3, 0x2EB6, 0x2EB7, 0xE83B, 0x43B1, 0x43AC,
0x2EBB, 0x43DD, 0x44D6, 0x4661, 0x464C, 0x9FB9, 0x4723, 0x4729,
0x477C, 0x478D, 0x2ECA, 0x4947, 0x497A, 0x497D, 0x4982, 0x4983,
0x4985, 0x4986, 0x499F, 0x499B, 0x49B7, 0x49B6, 0x9FBA, 0xE855,
0x4CA3, 0x4C9F, 0x4CA0, 0x4CA1, 0x4C77, 0x4CA2, 0x4D13, 0x4D14,
0x4D15, 0x4D16, 0x4D17, 0x4D18, 0x4D19, 0x4DAE, 0x9FBB,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_GB18030_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_gb18030.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 10,840
|
```objective-c
/*
*/
#pragma once
#include "CharacterSet.h"
#include <string>
namespace ZXing {
class BitMatrix;
namespace QRCode {
enum class ErrorCorrectionLevel;
/**
* This object renders a QR Code as a BitMatrix 2D array of greyscale values.
*
* @author dswitkin@google.com (Daniel Switkin)
*/
class Writer
{
public:
Writer();
Writer& setMargin(int margin) {
_margin = margin;
return *this;
}
Writer& setErrorCorrectionLevel(ErrorCorrectionLevel ecLevel) {
_ecLevel = ecLevel;
return *this;
}
Writer& setEncoding(CharacterSet encoding) {
_encoding = encoding;
return *this;
}
Writer& setVersion(int versionNumber) {
_version = versionNumber;
return *this;
}
Writer& useGS1Format() {
_useGs1Format = true;
return *this;
}
Writer& setMaskPattern(int pattern) {
_maskPattern = pattern;
return *this;
}
BitMatrix encode(const std::wstring& contents, int width, int height) const;
BitMatrix encode(const std::string& contents, int width, int height) const;
private:
int _margin;
ErrorCorrectionLevel _ecLevel;
CharacterSet _encoding;
int _version;
bool _useGs1Format;
int _maskPattern;
};
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRWriter.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 310
|
```objective-c
/*
*/
#pragma once
#include "Point.h"
#include "QRECB.h"
#include "QRErrorCorrectionLevel.h"
#include "ZXAlgorithms.h"
#include <array>
#include <initializer_list>
#include <vector>
namespace ZXing {
class BitMatrix;
namespace QRCode {
// clang-format off
constexpr std::array<PointI, 32> RMQR_SIZES {
PointI{43, 7}, {59, 7}, {77, 7}, {99, 7}, {139, 7},
{43, 9}, {59, 9}, {77, 9}, {99, 9}, {139, 9},
{27, 11}, {43, 11}, {59, 11}, {77, 11}, {99, 11}, {139, 11},
{27, 13}, {43, 13}, {59, 13}, {77, 13}, {99, 13}, {139, 13},
{43, 15}, {59, 15}, {77, 15}, {99, 15}, {139, 15},
{43, 17}, {59, 17}, {77, 17}, {99, 17}, {139, 17},
};
// clang-format on
/**
* See ISO 18004:2006 Annex D
*/
class Version
{
public:
Type type() const { return _type; }
bool isMicro() const { return type() == Type::Micro; }
bool isRMQR() const { return type() == Type::rMQR; }
bool isModel1() const { return type() == Type::Model1; }
bool isModel2() const { return type() == Type::Model2; }
int versionNumber() const { return _versionNumber; }
const std::vector<int>& alignmentPatternCenters() const { return _alignmentPatternCenters; }
int totalCodewords() const { return _totalCodewords; }
int dimension() const { return SymbolSize(versionNumber(), isMicro() ? Type::Micro : Type::Model2).x; }
const ECBlocks& ecBlocksForLevel(ErrorCorrectionLevel ecLevel) const { return _ecBlocks[(int)ecLevel]; }
BitMatrix buildFunctionPattern() const;
static constexpr PointI SymbolSize(int version, Type type)
{
auto square = [](int s) { return PointI(s, s); };
auto valid = [](int v, int max) { return v >= 1 && v <= max; };
switch (type) {
case Type::Model1: return valid(version, 32) ? square(17 + 4 * version) : PointI{};
case Type::Model2: return valid(version, 40) ? square(17 + 4 * version) : PointI{};
case Type::Micro: return valid(version, 4) ? square(9 + 2 * version) : PointI{};
case Type::rMQR: return valid(version, 32) ? RMQR_SIZES[version - 1] : PointI{};
}
return {}; // silence warning
}
static constexpr bool IsValidSize(PointI size, Type type)
{
switch (type) {
case Type::Model1: return size.x == size.y && size.x >= 21 && size.x <= 145 && (size.x % 4 == 1);
case Type::Model2: return size.x == size.y && size.x >= 21 && size.x <= 177 && (size.x % 4 == 1);
case Type::Micro: return size.x == size.y && size.x >= 11 && size.x <= 17 && (size.x % 2 == 1);
case Type::rMQR:
return size.x != size.y && size.x & 1 && size.y & 1 && size.x >= 27 && size.x <= 139 && size.y >= 7 && size.y <= 17
&& IndexOf(RMQR_SIZES, size) != -1;
}
return {}; // silence warning
}
static bool HasValidSize(const BitMatrix& bitMatrix, Type type);
static bool HasValidSize(const BitMatrix& matrix)
{
return HasValidSize(matrix, Type::Model1) || HasValidSize(matrix, Type::Model2) || HasValidSize(matrix, Type::Micro)
|| HasValidSize(matrix, Type::rMQR);
}
static constexpr int Number(PointI size)
{
if (size.x != size.y)
return IndexOf(RMQR_SIZES, size) + 1;
if (IsValidSize(size, Type::Model2))
return (size.x - 17) / 4;
if (IsValidSize(size, Type::Micro))
return (size.x - 9) / 2;
return 0;
}
static int Number(const BitMatrix& bitMatrix);
static const Version* DecodeVersionInformation(int versionBitsA, int versionBitsB = 0);
static const Version* Model1(int number);
static const Version* Model2(int number);
static const Version* Micro(int number);
static const Version* rMQR(int number);
private:
int _versionNumber;
std::vector<int> _alignmentPatternCenters;
std::array<ECBlocks, 4> _ecBlocks;
int _totalCodewords;
Type _type;
Version(int versionNumber, std::initializer_list<int> alignmentPatternCenters, const std::array<ECBlocks, 4> &ecBlocks);
Version(int versionNumber, const std::array<ECBlocks, 4>& ecBlocks);
};
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRVersion.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,235
|
```objective-c
/*
*/
#pragma once
#include "TritMatrix.h"
namespace ZXing {
class BitArray;
namespace QRCode {
enum class ErrorCorrectionLevel;
class Version;
constexpr int NUM_MASK_PATTERNS = 8;
void BuildMatrix(const BitArray& dataBits, ErrorCorrectionLevel ecLevel, const Version& version, int maskPattern, TritMatrix& matrix);
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRMatrixUtil.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 85
|
```objective-c
/*
*/
#pragma once
#include "QRErrorCorrectionLevel.h"
#include <cstdint>
namespace ZXing::QRCode {
static constexpr uint32_t FORMAT_INFO_MASK_MODEL2 = 0x5412;
static constexpr uint32_t FORMAT_INFO_MASK_MODEL1 = 0x2825;
static constexpr uint32_t FORMAT_INFO_MASK_MICRO = 0x4445;
static constexpr uint32_t FORMAT_INFO_MASK_RMQR = 0x1FAB2; // Finder pattern side
static constexpr uint32_t FORMAT_INFO_MASK_RMQR_SUB = 0x20A7B; // Finder sub pattern side
class FormatInformation
{
public:
uint32_t mask = 0;
uint8_t data = 255;
uint8_t hammingDistance = 255;
uint8_t bitsIndex = 255;
bool isMirrored = false;
uint8_t dataMask = 0;
uint8_t microVersion = 0;
ErrorCorrectionLevel ecLevel = ErrorCorrectionLevel::Invalid;
FormatInformation() = default;
static FormatInformation DecodeQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2);
static FormatInformation DecodeMQR(uint32_t formatInfoBits);
static FormatInformation DecodeRMQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2);
// Hamming distance of the 32 masked codes is 7 (64 and 8 for rMQR), by construction, so <= 3 bits differing means we found a match
bool isValid() const { return hammingDistance <= 3; }
Type type() const
{
switch (mask) {
case FORMAT_INFO_MASK_MODEL1: return Type::Model1;
case FORMAT_INFO_MASK_MICRO: return Type::Micro;
case FORMAT_INFO_MASK_RMQR: [[fallthrough]];
case FORMAT_INFO_MASK_RMQR_SUB: return Type::rMQR;
default: return Type::Model2;
}
}
bool operator==(const FormatInformation& other) const
{
return dataMask == other.dataMask && ecLevel == other.ecLevel && type() == other.type();
}
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRFormatInformation.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 451
|
```c++
/*
*/
#include "QRVersion.h"
#include "BitHacks.h"
#include "BitMatrix.h"
#include "QRECB.h"
#include <limits>
namespace ZXing::QRCode {
/**
* See ISO 18004:2006 Annex D.
* Element i represents the raw version bits that specify version i + 7
*/
static const int VERSION_DECODE_INFO[] = {
0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6,
0x0C762, 0x0D847, 0x0E60D, 0x0F928, 0x10B78,
0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683,
0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250,
0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B,
0x2542E, 0x26A64, 0x27541, 0x28C69
};
const Version* Version::Model2(int number)
{
/**
* See ISO 18004:2006 6.5.1 Table 9
*/
static const Version allVersions[] = {
{1, {}, {
7, 1, 19, 0, 0,
10, 1, 16, 0, 0,
13, 1, 13, 0, 0,
17, 1, 9 , 0, 0
}},
{2, {6, 18}, {
10, 1, 34, 0, 0,
16, 1, 28, 0, 0,
22, 1, 22, 0, 0,
28, 1, 16, 0, 0,
}},
{3, {6, 22}, {
15, 1, 55, 0, 0,
26, 1, 44, 0, 0,
18, 2, 17, 0, 0,
22, 2, 13, 0, 0,
}},
{4, {6, 26}, {
20, 1, 80, 0, 0,
18, 2, 32, 0, 0,
26, 2, 24, 0, 0,
16, 4, 9 , 0, 0,
}},
{5, {6, 30}, {
26, 1, 108, 0, 0,
24, 2, 43 , 0, 0,
18, 2, 15 , 2, 16,
22, 2, 11 , 2, 12,
}},
{6, {6, 34}, {
18, 2, 68, 0, 0,
16, 4, 27, 0, 0,
24, 4, 19, 0, 0,
28, 4, 15, 0, 0,
}},
{7, {6, 22, 38}, {
20, 2, 78, 0, 0,
18, 4, 31, 0, 0,
18, 2, 14, 4, 15,
26, 4, 13, 1, 14,
}},
{8, {6, 24, 42}, {
24, 2, 97, 0, 0,
22, 2, 38, 2, 39,
22, 4, 18, 2, 19,
26, 4, 14, 2, 15,
}},
{9, {6, 26, 46}, {
30, 2, 116, 0, 0,
22, 3, 36, 2, 37,
20, 4, 16, 4, 17,
24, 4, 12, 4, 13,
}},
{10, {6, 28, 50}, {
18, 2, 68, 2, 69,
26, 4, 43, 1, 44,
24, 6, 19, 2, 20,
28, 6, 15, 2, 16,
}},
{11, {6, 30, 54}, {
20, 4, 81, 0, 0,
30, 1, 50, 4, 51,
28, 4, 22, 4, 23,
24, 3, 12, 8, 13,
}},
{12, {6, 32, 58}, {
24, 2, 92, 2, 93,
22, 6, 36, 2, 37,
26, 4, 20, 6, 21,
28, 7, 14, 4, 15,
}},
{13, {6, 34, 62}, {
26, 4, 107, 0, 0,
22, 8, 37, 1, 38,
24, 8, 20, 4, 21,
22, 12, 11, 4, 12,
}},
{14, {6, 26, 46, 66}, {
30, 3, 115, 1, 116,
24, 4, 40, 5, 41,
20, 11, 16, 5, 17,
24, 11, 12, 5, 13,
}},
{15, {6, 26, 48, 70}, {
22, 5, 87, 1, 88,
24, 5, 41, 5, 42,
30, 5, 24, 7, 25,
24, 11, 12, 7, 13,
}},
{16, {6, 26, 50, 74}, {
24, 5, 98, 1, 99,
28, 7, 45, 3, 46,
24, 15, 19, 2, 20,
30, 3, 15, 13, 16,
}},
{17, {6, 30, 54, 78}, {
28, 1, 107, 5, 108,
28, 10, 46, 1, 47,
28, 1, 22, 15, 23,
28, 2, 14, 17, 15,
}},
{18, {6, 30, 56, 82}, {
30, 5, 120, 1, 121,
26, 9, 43, 4, 44,
28, 17, 22, 1, 23,
28, 2, 14, 19, 15,
}},
{19, {6, 30, 58, 86}, {
28, 3, 113, 4, 114,
26, 3, 44, 11, 45,
26, 17, 21, 4, 22,
26, 9, 13, 16, 14,
}},
{20, {6, 34, 62, 90}, {
28, 3, 107, 5, 108,
26, 3, 41, 13, 42,
30, 15, 24, 5, 25,
28, 15, 15, 10, 16,
}},
{21, {6, 28, 50, 72, 94}, {
28, 4, 116, 4, 117,
26, 17, 42, 0, 0,
28, 17, 22, 6, 23,
30, 19, 16, 6, 17,
}},
{22, {6, 26, 50, 74, 98}, {
28, 2, 111, 7, 112,
28, 17, 46, 0, 0,
30, 7, 24, 16, 25,
24, 34, 13, 0, 0,
}},
{23, {6, 30, 54, 78, 102}, {
30, 4, 121, 5, 122,
28, 4, 47, 14, 48,
30, 11, 24, 14, 25,
30, 16, 15, 14, 16,
}},
{24, {6, 28, 54, 80, 106}, {
30, 6, 117, 4, 118,
28, 6, 45, 14, 46,
30, 11, 24, 16, 25,
30, 30, 16, 2, 17,
}},
{25, {6, 32, 58, 84, 110}, {
26, 8, 106, 4, 107,
28, 8, 47, 13, 48,
30, 7, 24, 22, 25,
30, 22, 15, 13, 16,
}},
{26, {6, 30, 58, 86, 114}, {
28, 10, 114, 2, 115,
28, 19, 46, 4, 47,
28, 28, 22, 6, 23,
30, 33, 16, 4, 17,
}},
{27, {6, 34, 62, 90, 118}, {
30, 8, 122, 4, 123,
28, 22, 45, 3, 46,
30, 8, 23, 26, 24,
30, 12, 15, 28, 16,
}},
{28, {6, 26, 50, 74, 98, 122}, {
30, 3, 117, 10, 118,
28, 3, 45, 23, 46,
30, 4, 24, 31, 25,
30, 11, 15, 31, 16,
}},
{29, {6, 30, 54, 78, 102, 126}, {
30, 7, 116, 7, 117,
28, 21, 45, 7, 46,
30, 1, 23, 37, 24,
30, 19, 15, 26, 16,
}},
{30, {6, 26, 52, 78, 104, 130}, {
30, 5, 115, 10, 116,
28, 19, 47, 10, 48,
30, 15, 24, 25, 25,
30, 23, 15, 25, 16,
}},
{31, {6, 30, 56, 82, 108, 134}, {
30, 13, 115, 3, 116,
28, 2, 46, 29, 47,
30, 42, 24, 1, 25,
30, 23, 15, 28, 16,
}},
{32, {6, 34, 60, 86, 112, 138}, {
30, 17, 115, 0, 0,
28, 10, 46, 23, 47,
30, 10, 24, 35, 25,
30, 19, 15, 35, 16,
}},
{33, {6, 30, 58, 86, 114, 142}, {
30, 17, 115, 1, 116,
28, 14, 46, 21, 47,
30, 29, 24, 19, 25,
30, 11, 15, 46, 16,
}},
{34, {6, 34, 62, 90, 118, 146}, {
30, 13, 115, 6, 116,
28, 14, 46, 23, 47,
30, 44, 24, 7, 25,
30, 59, 16, 1, 17,
}},
{35, {6, 30, 54, 78, 102, 126, 150}, {
30, 12, 121, 7, 122,
28, 12, 47, 26, 48,
30, 39, 24, 14, 25,
30, 22, 15, 41, 16,
}},
{36, {6, 24, 50, 76, 102, 128, 154}, {
30, 6, 121, 14, 122,
28, 6, 47, 34, 48,
30, 46, 24, 10, 25,
30, 2, 15, 64, 16,
}},
{37, {6, 28, 54, 80, 106, 132, 158}, {
30, 17, 122, 4, 123,
28, 29, 46, 14, 47,
30, 49, 24, 10, 25,
30, 24, 15, 46, 16,
}},
{38, {6, 32, 58, 84, 110, 136, 162}, {
30, 4, 122, 18, 123,
28, 13, 46, 32, 47,
30, 48, 24, 14, 25,
30, 42, 15, 32, 16,
}},
{39, {6, 26, 54, 82, 110, 138, 166}, {
30, 20, 117, 4, 118,
28, 40, 47, 7, 48,
30, 43, 24, 22, 25,
30, 10, 15, 67, 16,
}},
{40, {6, 30, 58, 86, 114, 142, 170}, {
30, 19, 118, 6, 119,
28, 18, 47, 31, 48,
30, 34, 24, 34, 25,
30, 20, 15, 61, 16
}},
};
if (number < 1 || number > 40)
return nullptr;
return allVersions + number - 1;
}
const Version* Version::Micro(int number)
{
/**
* See ISO 18004:2006 6.5.1 Table 9
*/
static const Version allVersions[] = {
{1, {2, 1, 3, 0, 0}},
{2, {5, 1, 5, 0, 0, 6, 1, 4, 0, 0}},
{3, {6, 1, 11, 0, 0, 8, 1, 9, 0, 0}},
{4, {8, 1, 16, 0, 0, 10, 1, 14, 0, 0, 14, 1, 10, 0, 0}}};
if (number < 1 || number > 4)
return nullptr;
return allVersions + number - 1;
}
const Version* Version::rMQR(int number)
{
/**
* See ISO/IEC 23941:2022 Annex D, Table D.1 - Column coordinates of centre module of alignment patterns
* See ISO/IEC 23941:2022 7.5.1, Table 8 - Error correction characteristics for rMQR
*/
static const Version allVersions[] = {
// Version number, alignment pattern centres, `ECBlocks`
{ 1, {21}, { // R7x43
// 4 `ECBlocks`, one for each `ecLevel` - rMQR only uses M & H but using 2 dummies to keep `ecLevel` index same as QR Code
// Each begins with no. of error correction codewords divided by no. of error correction blocks, followed by 2 `ECBlock`s
// Each `ECBlock` begins with no. of error correction blocks followed by no. of data codewords per block
0, 0, 0, 0, 0, // L (dummy) - also used to differentiate rMQR from Model2 in `Version::Version()`
7, 1, 6, 0, 0, // M
0, 0, 0, 0, 0, // Q (dummy)
10, 1, 3, 0, 0, // H
}},
{ 2, {19, 39}, { // R7x59
0, 0, 0, 0, 0,
9, 1, 12, 0, 0,
0, 0, 0, 0, 0,
14, 1, 7, 0, 0,
}},
{ 3, {25, 51}, { // R7x77
0, 0, 0, 0, 0,
12, 1, 20, 0, 0,
0, 0, 0, 0, 0,
22, 1, 10, 0, 0,
}},
{ 4, {23, 49, 75}, { // R7x99
0, 0, 0, 0, 0,
16, 1, 28, 0, 0,
0, 0, 0, 0, 0,
30, 1, 14, 0, 0,
}},
{ 5, {27, 55, 83, 111}, { // R7x139
0, 0, 0, 0, 0,
24, 1, 44, 0, 0,
0, 0, 0, 0, 0,
22, 2, 12, 0, 0,
}},
{ 6, {21}, { // R9x43
0, 0, 0, 0, 0,
9, 1, 12, 0, 0,
0, 0, 0, 0, 0,
14, 1, 7, 0, 0,
}},
{ 7, {19, 39}, { // R9x59
0, 0, 0, 0, 0,
12, 1, 21, 0, 0,
0, 0, 0, 0, 0,
22, 1, 11, 0, 0,
}},
{ 8, {25, 51}, { // R9x77
0, 0, 0, 0, 0,
18, 1, 31, 0, 0,
0, 0, 0, 0, 0,
16, 1, 8, 1, 9,
}},
{ 9, {23, 49, 75}, { // R9x99
0, 0, 0, 0, 0,
24, 1, 42, 0, 0,
0, 0, 0, 0, 0,
22, 2, 11, 0, 0,
}},
{10, {27, 55, 83, 111}, { // R9x139
0, 0, 0, 0, 0,
18, 1, 31, 1, 32,
0, 0, 0, 0, 0,
22, 3, 11, 0, 0,
}},
{11, {}, { // R11x27
0, 0, 0, 0, 0,
8, 1, 7, 0, 0,
0, 0, 0, 0, 0,
10, 1, 5, 0, 0,
}},
{12, {21}, { // R11x43
0, 0, 0, 0, 0,
12, 1, 19, 0, 0,
0, 0, 0, 0, 0,
20, 1, 11, 0, 0,
}},
{13, {19, 39}, { // R11x59
0, 0, 0, 0, 0,
16, 1, 31, 0, 0,
0, 0, 0, 0, 0,
16, 1, 7, 1, 8,
}},
{14, {25, 51}, { // R11x77
0, 0, 0, 0, 0,
24, 1, 43, 0, 0,
0, 0, 0, 0, 0,
22, 1, 11, 1, 12,
}},
{15, {23, 49, 75}, { // R11x99
0, 0, 0, 0, 0,
16, 1, 28, 1, 29,
0, 0, 0, 0, 0,
30, 1, 14, 1, 15,
}},
{16, {27, 55, 83, 111}, { // R11x139
0, 0, 0, 0, 0,
24, 2, 42, 0, 0,
0, 0, 0, 0, 0,
30, 3, 14, 0, 0,
}},
{17, {}, { // R13x27
0, 0, 0, 0, 0,
9, 1, 12, 0, 0,
0, 0, 0, 0, 0,
14, 1, 7, 0, 0,
}},
{18, {21}, { // R13x43
0, 0, 0, 0, 0,
14, 1, 27, 0, 0,
0, 0, 0, 0, 0,
28, 1, 13, 0, 0,
}},
{19, {19, 39}, { // R13x59
0, 0, 0, 0, 0,
22, 1, 38, 0, 0,
0, 0, 0, 0, 0,
20, 2, 10, 0, 0,
}},
{20, {25, 51}, { // R13x77
0, 0, 0, 0, 0,
16, 1, 26, 1, 27,
0, 0, 0, 0, 0,
28, 1, 14, 1, 15,
}},
{21, {23, 49, 75}, { // R13x99
0, 0, 0, 0, 0,
20, 1, 36, 1, 37,
0, 0, 0, 0, 0,
26, 1, 11, 2, 12,
}},
{22, {27, 55, 83, 111}, { // R13x139
0, 0, 0, 0, 0,
20, 2, 35, 1, 36,
0, 0, 0, 0, 0,
28, 2, 13, 2, 14,
}},
{23, {21}, { // R15x43
0, 0, 0, 0, 0,
18, 1, 33, 0, 0,
0, 0, 0, 0, 0,
18, 1, 7, 1, 8,
}},
{24, {19, 39}, { // R15x59
0, 0, 0, 0, 0,
26, 1, 48, 0, 0,
0, 0, 0, 0, 0,
24, 2, 13, 0, 0,
}},
{25, {25, 51}, { // R15x77
0, 0, 0, 0, 0,
18, 1, 33, 1, 34,
0, 0, 0, 0, 0,
24, 2, 10, 1, 11,
}},
{26, {23, 49, 75}, { // R15x99
0, 0, 0, 0, 0,
24, 2, 44, 0, 0,
0, 0, 0, 0, 0,
22, 4, 12, 0, 0,
}},
{27, {27, 55, 83, 111}, { // R15x139
0, 0, 0, 0, 0,
24, 2, 42, 1, 43,
0, 0, 0, 0, 0,
26, 1, 13, 4, 14,
}},
{28, {21}, { // R17x43
0, 0, 0, 0, 0,
22, 1, 39, 0, 0,
0, 0, 0, 0, 0,
20, 1, 10, 1, 11,
}},
{29, {19, 39}, { // R17x59
0, 0, 0, 0, 0,
16, 2, 28, 0, 0,
0, 0, 0, 0, 0,
30, 2, 14, 0, 0,
}},
{30, {25, 51}, { // R17x77
0, 0, 0, 0, 0,
22, 2, 39, 0, 0,
0, 0, 0, 0, 0,
28, 1, 12, 2, 13,
}},
{31, {23, 49, 75}, { // R17x99
0, 0, 0, 0, 0,
20, 2, 33, 1, 34,
0, 0, 0, 0, 0,
26, 4, 14, 0, 0,
}},
{32, {27, 55, 83, 111}, { // R17x139
0, 0, 0, 0, 0,
20, 4, 38, 0, 0,
0, 0, 0, 0, 0,
26, 2, 12, 4, 13,
}},
};
if (number < 1 || number > Size(allVersions))
return nullptr;
return allVersions + number - 1;
}
const Version* Version::Model1(int number)
{
/**
* See ISO 18004:2000 M.4.2 Table M.2
* See ISO 18004:2000 M.5 Table M.4
*/
static const Version allVersions[] = {
{1, {
7 , 1, 19, 0, 0,
10, 1, 16, 0, 0,
13, 1, 13, 0, 0,
17, 1, 9 , 0, 0
}},
{2, {
10, 1, 36, 0, 0,
16, 1, 30, 0, 0,
22, 1, 24, 0, 0,
30, 1, 16, 0, 0,
}},
{3, {
15, 1, 57, 0, 0,
28, 1, 44, 0, 0,
36, 1, 36, 0, 0,
48, 1, 24, 0, 0,
}},
{4, {
20, 1, 80, 0, 0,
40, 1, 60, 0, 0,
50, 1, 50, 0, 0,
66, 1, 34, 0, 0,
}},
{5, {
26, 1, 108, 0, 0,
52, 1, 82 , 0, 0,
66, 1, 68 , 0, 0,
44, 2, 23 , 0, 0,
}},
{6, {
34, 1, 136, 0, 0,
32, 2, 53 , 0, 0,
42, 2, 43 , 0, 0,
56, 2, 29 , 0, 0,
}},
{7, {
42, 1, 170, 0, 0,
40, 2, 66 , 0, 0,
52, 2, 54 , 0, 0,
46, 3, 24 , 0, 0,
}},
{8, {
24, 2, 104, 0, 0,
48, 2, 80 , 0, 0,
64, 2, 64 , 0, 0,
56, 3, 29 , 0, 0,
}},
{9, {
30, 2, 123, 0, 0,
60, 2, 93 , 0, 0,
50, 3, 52 , 0, 0,
68, 3, 34 , 0, 0,
}},
{10, {
34, 2, 145, 0, 0,
68, 2, 111, 0, 0,
58, 3, 61 , 0, 0,
58, 4, 31 , 0, 0,
}},
{11, {
40, 2, 168, 0, 0,
40, 4, 64 , 0, 0,
52, 4, 52 , 0, 0,
54, 5, 29 , 0, 0,
}},
{12, {
46, 2, 192, 0, 0,
46, 4, 73 , 0, 0,
58, 4, 61 , 0, 0,
62, 5, 33 , 0, 0,
}},
{13, {
36, 3, 144, 0, 0,
52, 4, 83 , 0, 0,
66, 4, 69 , 0, 0,
58, 6, 32 , 0, 0,
}},
{14, {
40, 3, 163, 0, 0,
60, 4, 92 , 0, 0,
60, 5, 62 , 0, 0,
66, 6, 35 , 0, 0,
}},
};
if (number < 1 || number > 14)
return nullptr;
return allVersions + number - 1;
}
Version::Version(int versionNumber, std::initializer_list<int> alignmentPatternCenters, const std::array<ECBlocks, 4>& ecBlocks)
: _versionNumber(versionNumber), _alignmentPatternCenters(alignmentPatternCenters), _ecBlocks(ecBlocks),
_type(ecBlocks[0].codewordsPerBlock == 0 ? Type::rMQR : Type::Model2)
{
_totalCodewords = ecBlocks[1].totalDataCodewords(); // Use 1 (M) as 0 dummy for rMQR
}
Version::Version(int versionNumber, const std::array<ECBlocks, 4>& ecBlocks)
: _versionNumber(versionNumber),
_ecBlocks(ecBlocks),
_type(ecBlocks[0].codewordsPerBlock < 7 || ecBlocks[0].codewordsPerBlock == 8 ? Type::Micro : Type::Model1)
{
_totalCodewords = ecBlocks[0].totalDataCodewords();
}
bool Version::HasValidSize(const BitMatrix& bitMatrix, Type type)
{
return IsValidSize(PointI{bitMatrix.width(), bitMatrix.height()}, type);
}
int Version::Number(const BitMatrix& bitMatrix)
{
return Number(PointI{bitMatrix.width(), bitMatrix.height()});
}
const Version* Version::DecodeVersionInformation(int versionBitsA, int versionBitsB)
{
int bestDifference = std::numeric_limits<int>::max();
int bestVersion = 0;
int i = 0;
for (int targetVersion : VERSION_DECODE_INFO) {
for (int bits : {versionBitsA, versionBitsB}) {
int bitsDifference = BitHacks::CountBitsSet(bits ^ targetVersion);
if (bitsDifference < bestDifference) {
bestVersion = i + 7;
bestDifference = bitsDifference;
}
}
if (bestDifference == 0)
break;
++i;
}
// We can tolerate up to 3 bits of error since no two version info codewords will
// differ in less than 8 bits.
if (bestDifference <= 3)
return Model2(bestVersion);
// If we didn't find a close enough match, fail
return nullptr;
}
/**
* See ISO 18004:2006 Annex E
*/
BitMatrix Version::buildFunctionPattern() const
{
if (isRMQR()) {
PointI size = Version::SymbolSize(versionNumber(), Type::rMQR);
BitMatrix bitMatrix(size.x, size.y);
// Set edge timing patterns
bitMatrix.setRegion(0, 0, size.x, 1); // Top
bitMatrix.setRegion(0, size.y - 1, size.x, 1); // Bottom
bitMatrix.setRegion(0, 1, 1, size.y - 2); // Left
bitMatrix.setRegion(size.x - 1, 1, 1, size.y - 2); // Right
// Set vertical timing and alignment patterns
size_t max = _alignmentPatternCenters.size(); // Same as vertical timing column
for (size_t x = 0; x < max; ++x) {
int cx = _alignmentPatternCenters[x];
bitMatrix.setRegion(cx - 1, 1, 3, 2); // Top alignment pattern
bitMatrix.setRegion(cx - 1, size.y - 3, 3, 2); // Bottom alignment pattern
bitMatrix.setRegion(cx, 3, 1, size.y - 6); // Vertical timing pattern
}
// Top left finder pattern + separator
bitMatrix.setRegion(1, 1, 8 - 1, 8 - 1 - (size.y == 7)); // R7 finder bottom flush with edge
// Top left format
bitMatrix.setRegion(8, 1, 3, 5);
bitMatrix.setRegion(11, 1, 1, 3);
// Bottom right finder subpattern
bitMatrix.setRegion(size.x - 5, size.y - 5, 5 - 1, 5 - 1);
// Bottom right format
bitMatrix.setRegion(size.x - 8, size.y - 6, 3, 5);
bitMatrix.setRegion(size.x - 5, size.y - 6, 3, 1);
// Top right corner finder
bitMatrix.set(size.x - 2, 1);
if (size.y > 9) {
// Bottom left corner finder
bitMatrix.set(1, size.y - 2);
}
return bitMatrix;
}
int dimension = this->dimension();
BitMatrix bitMatrix(dimension, dimension);
// Top left finder pattern + separator + format
bitMatrix.setRegion(0, 0, 9, 9);
if (!isMicro()) {
// Top right finder pattern + separator + format
bitMatrix.setRegion(dimension - 8, 0, 8, 9);
// Bottom left finder pattern + separator + format
bitMatrix.setRegion(0, dimension - 8, 9, 8);
// Alignment patterns
size_t max = _alignmentPatternCenters.size();
for (size_t x = 0; x < max; ++x) {
int i = _alignmentPatternCenters[x] - 2;
for (size_t y = 0; y < max; ++y) {
if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
// No alignment patterns near the three finder patterns
continue;
}
bitMatrix.setRegion(_alignmentPatternCenters[y] - 2, i, 5, 5);
}
}
// Vertical timing pattern
bitMatrix.setRegion(6, 9, 1, dimension - 17);
// Horizontal timing pattern
bitMatrix.setRegion(9, 6, dimension - 17, 1);
if (_versionNumber > 6) {
// Version info, top right
bitMatrix.setRegion(dimension - 11, 0, 3, 6);
// Version info, bottom left
bitMatrix.setRegion(0, dimension - 11, 6, 3);
}
} else {
// Vertical timing pattern
bitMatrix.setRegion(9, 0, dimension - 9, 1);
// Horizontal timing pattern
bitMatrix.setRegion(0, 9, 1, dimension - 9);
}
return bitMatrix;
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRVersion.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 9,866
|
```objective-c
/*
*/
#pragma once
namespace ZXing {
class DecoderResult;
class BitMatrix;
namespace QRCode {
DecoderResult Decode(const BitMatrix& bits);
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRDecoder.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 41
|
```c++
/*
*/
#include "QRCodecMode.h"
#include "Error.h"
#include "QRVersion.h"
#include "ZXAlgorithms.h"
#include <array>
namespace ZXing::QRCode {
CodecMode CodecModeForBits(int bits, Type type)
{
if (type == Type::Micro) {
constexpr CodecMode Bits2Mode[4] = {CodecMode::NUMERIC, CodecMode::ALPHANUMERIC, CodecMode::BYTE, CodecMode::KANJI};
if (bits < Size(Bits2Mode))
return Bits2Mode[bits];
} else if (type == Type::rMQR) {
constexpr CodecMode Bits2Mode[8] = {
CodecMode::TERMINATOR, CodecMode::NUMERIC, CodecMode::ALPHANUMERIC, CodecMode::BYTE,
CodecMode::KANJI, CodecMode::FNC1_FIRST_POSITION, CodecMode::FNC1_SECOND_POSITION, CodecMode::ECI
};
if (bits < Size(Bits2Mode))
return Bits2Mode[bits];
} else {
if ((bits >= 0x00 && bits <= 0x05) || (bits >= 0x07 && bits <= 0x09) || bits == 0x0d)
return static_cast<CodecMode>(bits);
}
throw FormatError("Invalid codec mode");
}
int CharacterCountBits(CodecMode mode, const Version& version)
{
int number = version.versionNumber();
if (version.isMicro()) {
switch (mode) {
case CodecMode::NUMERIC: return std::array{3, 4, 5, 6}[number - 1];
case CodecMode::ALPHANUMERIC: return std::array{3, 4, 5}[number - 2];
case CodecMode::BYTE: return std::array{4, 5}[number - 3];
case CodecMode::KANJI: [[fallthrough]];
case CodecMode::HANZI: return std::array{3, 4}[number - 3];
default: return 0;
}
}
if (version.isRMQR()) {
// See ISO/IEC 23941:2022 7.4.1, Table 3 - Number of bits of character count indicator
constexpr char numeric[32] = {4, 5, 6, 7, 7, 5, 6, 7, 7, 8, 4, 6, 7, 7, 8, 8, 5, 6, 7, 7, 8, 8, 7, 7, 8, 8, 9, 7, 8, 8, 8, 9};
constexpr char alphanum[32] = {3, 5, 5, 6, 6, 5, 5, 6, 6, 7, 4, 5, 6, 6, 7, 7, 5, 6, 6, 7, 7, 8, 6, 7, 7, 7, 8, 6, 7, 7, 8, 8};
constexpr char byte[32] = {3, 4, 5, 5, 6, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 4, 5, 6, 6, 7, 7, 6, 6, 7, 7, 7, 6, 6, 7, 7, 8};
constexpr char kanji[32] = {2, 3, 4, 5, 5, 3, 4, 5, 5, 6, 2, 4, 5, 5, 6, 6, 3, 5, 5, 6, 6, 7, 5, 5, 6, 6, 7, 5, 6, 6, 6, 7};
switch (mode) {
case CodecMode::NUMERIC: return numeric[number - 1];
case CodecMode::ALPHANUMERIC: return alphanum[number - 1];
case CodecMode::BYTE: return byte[number - 1];
case CodecMode::KANJI: return kanji[number - 1];
default: return 0;
}
}
int i;
if (number <= 9)
i = 0;
else if (number <= 26)
i = 1;
else
i = 2;
switch (mode) {
case CodecMode::NUMERIC: return std::array{10, 12, 14}[i];
case CodecMode::ALPHANUMERIC: return std::array{9, 11, 13}[i];
case CodecMode::BYTE: return std::array{8, 16, 16}[i];
case CodecMode::KANJI: [[fallthrough]];
case CodecMode::HANZI: return std::array{8, 10, 12}[i];
default: return 0;
}
}
int CodecModeBitsLength(const Version& version)
{
return version.isMicro() ? version.versionNumber() - 1 : 4 - version.isRMQR();
}
int TerminatorBitsLength(const Version& version)
{
return version.isMicro() ? version.versionNumber() * 2 + 1 : 4 - version.isRMQR();
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRCodecMode.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,242
|
```c++
/*
*/
#include "QREncoder.h"
#include "BitArray.h"
#include "ECI.h"
#include "GenericGF.h"
#include "QREncodeResult.h"
#include "QRErrorCorrectionLevel.h"
#include "QRMaskUtil.h"
#include "QRMatrixUtil.h"
#include "ReedSolomonEncoder.h"
#include "TextEncoder.h"
#include "ZXTestSupport.h"
#include <algorithm>
#include <array>
#include <limits>
#include <stdexcept>
namespace ZXing::QRCode {
static const CharacterSet DEFAULT_BYTE_MODE_ENCODING = CharacterSet::ISO8859_1;
// The original table is defined in the table 5 of JISX0510:2004 (p.19).
static const std::array<int, 16 * 6> ALPHANUMERIC_TABLE = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f
36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f
-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f
};
static bool IsOnlyDoubleByteKanji(const std::wstring& content)
{
std::string bytes = TextEncoder::FromUnicode(content, CharacterSet::Shift_JIS);
size_t length = bytes.length();
if (length % 2 != 0) {
return false;
}
for (size_t i = 0; i < length; i += 2) {
int byte1 = bytes[i] & 0xff;
if ((byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB)) {
return false;
}
}
return true;
}
/**
* @return the code point of the table used in alphanumeric mode or
* -1 if there is no corresponding code in the table.
*/
ZXING_EXPORT_TEST_ONLY
int GetAlphanumericCode(int code)
{
if (code < Size(ALPHANUMERIC_TABLE)) {
return ALPHANUMERIC_TABLE[code];
}
return -1;
}
/**
* Choose the best mode by examining the content. Note that 'encoding' is used as a hint;
* if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}.
*/
ZXING_EXPORT_TEST_ONLY
CodecMode ChooseMode(const std::wstring& content, CharacterSet encoding)
{
if (encoding == CharacterSet::Shift_JIS && IsOnlyDoubleByteKanji(content)) {
// Choose Kanji mode if all input are double-byte characters
return CodecMode::KANJI;
}
bool hasNumeric = false;
bool hasAlphanumeric = false;
for (wchar_t c : content) {
if (c >= '0' && c <= '9') {
hasNumeric = true;
}
else if (GetAlphanumericCode(c) != -1) {
hasAlphanumeric = true;
}
else {
return CodecMode::BYTE;
}
}
if (hasAlphanumeric) {
return CodecMode::ALPHANUMERIC;
}
if (hasNumeric) {
return CodecMode::NUMERIC;
}
return CodecMode::BYTE;
}
/*
* See ISO/IEC 18004:2015 Table 4
*/
static void AppendECI(CharacterSet eci, BitArray& bits)
{
int eciValue = ToInt(ToECI(eci));
if (eciValue >= 0 && eciValue <= 999999) {
bits.appendBits(static_cast<int>(CodecMode::ECI), 4);
if (eciValue <= 127) {
bits.appendBits(eciValue, 8);
}
else if (eciValue <= 16383) {
bits.appendBits(0x8000 | eciValue, 16);
}
else {
bits.appendBits(0xC00000 | eciValue, 24);
}
}
}
/**
* Append mode info. On success, store the result in "bits".
*/
ZXING_EXPORT_TEST_ONLY
void AppendModeInfo(CodecMode mode, BitArray& bits)
{
bits.appendBits(static_cast<int>(mode), 4);
}
/**
* Append length info. On success, store the result in "bits".
*/
ZXING_EXPORT_TEST_ONLY
void AppendLengthInfo(int numLetters, const Version& version, CodecMode mode, BitArray& bits)
{
int numBits = CharacterCountBits(mode, version);
if (numLetters >= (1 << numBits)) {
throw std::invalid_argument(std::to_string(numLetters) + " is bigger than " + std::to_string((1 << numBits) - 1));
}
bits.appendBits(numLetters, numBits);
}
ZXING_EXPORT_TEST_ONLY
void AppendNumericBytes(const std::wstring& content, BitArray& bits)
{
size_t length = content.length();
size_t i = 0;
while (i < length) {
int num1 = content[i] - '0';
if (i + 2 < length) {
// Encode three numeric letters in ten bits.
int num2 = content[i + 1] - '0';
int num3 = content[i + 2] - '0';
bits.appendBits(num1 * 100 + num2 * 10 + num3, 10);
i += 3;
}
else if (i + 1 < length) {
// Encode two numeric letters in seven bits.
int num2 = content[i + 1] - '0';
bits.appendBits(num1 * 10 + num2, 7);
i += 2;
}
else {
// Encode one numeric letter in four bits.
bits.appendBits(num1, 4);
i++;
}
}
}
ZXING_EXPORT_TEST_ONLY
void AppendAlphanumericBytes(const std::wstring& content, BitArray& bits)
{
size_t length = content.length();
size_t i = 0;
while (i < length) {
int code1 = GetAlphanumericCode(content[i]);
if (code1 == -1) {
throw std::invalid_argument("Unexpected contents");
}
if (i + 1 < length) {
int code2 = GetAlphanumericCode(content[i + 1]);
if (code2 == -1) {
throw std::invalid_argument("Unexpected contents");
}
// Encode two alphanumeric letters in 11 bits.
bits.appendBits(code1 * 45 + code2, 11);
i += 2;
}
else {
// Encode one alphanumeric letter in six bits.
bits.appendBits(code1, 6);
i++;
}
}
}
ZXING_EXPORT_TEST_ONLY
void Append8BitBytes(const std::wstring& content, CharacterSet encoding, BitArray& bits)
{
for (char b : TextEncoder::FromUnicode(content, encoding)) {
bits.appendBits(b, 8);
}
}
ZXING_EXPORT_TEST_ONLY
void AppendKanjiBytes(const std::wstring& content, BitArray& bits)
{
std::string bytes = TextEncoder::FromUnicode(content, CharacterSet::Shift_JIS);
int length = Size(bytes);
if (length % 2 != 0) {
throw std::invalid_argument("Kanji byte size not even");
}
--length;
for (int i = 0; i < length; i += 2) {
int byte1 = bytes[i] & 0xff;
int byte2 = bytes[i + 1] & 0xff;
int code = (byte1 << 8) | byte2;
int subtracted = -1;
if (code >= 0x8140 && code <= 0x9ffc) {
subtracted = code - 0x8140;
}
else if (code >= 0xe040 && code <= 0xebbf) {
subtracted = code - 0xc140;
}
if (subtracted == -1) {
throw std::invalid_argument("Invalid byte sequence");
}
int encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff);
bits.appendBits(encoded, 13);
}
}
/**
* Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
*/
ZXING_EXPORT_TEST_ONLY
void AppendBytes(const std::wstring& content, CodecMode mode, CharacterSet encoding, BitArray& bits)
{
switch (mode) {
case CodecMode::NUMERIC: AppendNumericBytes(content, bits); break;
case CodecMode::ALPHANUMERIC: AppendAlphanumericBytes(content, bits); break;
case CodecMode::BYTE: Append8BitBytes(content, encoding, bits); break;
case CodecMode::KANJI: AppendKanjiBytes(content, bits); break;
default: throw std::invalid_argument("Invalid mode: " + std::to_string(static_cast<int>(mode)));
}
}
/**
* @return true if the number of input bits will fit in a code with the specified version and
* error correction level.
*/
static bool WillFit(int numInputBits, const Version& version, ErrorCorrectionLevel ecLevel) {
// In the following comments, we use numbers of Version 7-H.
// numBytes = 196
int numBytes = version.totalCodewords();
// getNumECBytes = 130
auto& ecBlocks = version.ecBlocksForLevel(ecLevel);
int numEcBytes = ecBlocks.totalCodewords();
// getNumDataBytes = 196 - 130 = 66
int numDataBytes = numBytes - numEcBytes;
int totalInputBytes = (numInputBits + 7) / 8;
return numDataBytes >= totalInputBytes;
}
static const Version& ChooseVersion(int numInputBits, ErrorCorrectionLevel ecLevel)
{
for (int versionNum = 1; versionNum <= 40; versionNum++) {
const Version* version = Version::Model2(versionNum);
if (WillFit(numInputBits, *version, ecLevel)) {
return *version;
}
}
throw std::invalid_argument("Data too big");
}
/**
* Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).
*/
ZXING_EXPORT_TEST_ONLY
void TerminateBits(int numDataBytes, BitArray& bits)
{
int capacity = numDataBytes * 8;
if (bits.size() > capacity) {
throw std::invalid_argument("data bits cannot fit in the QR Code" + std::to_string(bits.size()) + " > "
+ std::to_string(capacity));
}
for (int i = 0; i < 4 && bits.size() < capacity; ++i) {
bits.appendBit(false);
}
// Append termination bits. See 8.4.8 of JISX0510:2004 (p.24) for details.
// If the last byte isn't 8-bit aligned, we'll add padding bits.
int numBitsInLastByte = bits.size() & 0x07;
if (numBitsInLastByte > 0) {
for (int i = numBitsInLastByte; i < 8; i++) {
bits.appendBit(false);
}
}
// If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).
int numPaddingBytes = numDataBytes - bits.sizeInBytes();
for (int i = 0; i < numPaddingBytes; ++i) {
bits.appendBits((i & 0x01) == 0 ? 0xEC : 0x11, 8);
}
if (bits.size() != capacity) {
throw std::invalid_argument("Bits size does not equal capacity");
}
}
struct BlockPair
{
ByteArray dataBytes;
ByteArray ecBytes;
};
/**
* Get number of data bytes and number of error correction bytes for block id "blockID". Store
* the result in "numDataBytesInBlock", and "numECBytesInBlock". See table 12 in 8.5.1 of
* JISX0510:2004 (p.30)
*/
ZXING_EXPORT_TEST_ONLY
void GetNumDataBytesAndNumECBytesForBlockID(int numTotalBytes, int numDataBytes, int numRSBlocks, int blockID,
int& numDataBytesInBlock, int& numECBytesInBlock)
{
if (blockID >= numRSBlocks) {
throw std::invalid_argument("Block ID too large");
}
// numRsBlocksInGroup2 = 196 % 5 = 1
int numRsBlocksInGroup2 = numTotalBytes % numRSBlocks;
// numRsBlocksInGroup1 = 5 - 1 = 4
int numRsBlocksInGroup1 = numRSBlocks - numRsBlocksInGroup2;
// numTotalBytesInGroup1 = 196 / 5 = 39
int numTotalBytesInGroup1 = numTotalBytes / numRSBlocks;
// numTotalBytesInGroup2 = 39 + 1 = 40
int numTotalBytesInGroup2 = numTotalBytesInGroup1 + 1;
// numDataBytesInGroup1 = 66 / 5 = 13
int numDataBytesInGroup1 = numDataBytes / numRSBlocks;
// numDataBytesInGroup2 = 13 + 1 = 14
int numDataBytesInGroup2 = numDataBytesInGroup1 + 1;
// numEcBytesInGroup1 = 39 - 13 = 26
int numEcBytesInGroup1 = numTotalBytesInGroup1 - numDataBytesInGroup1;
// numEcBytesInGroup2 = 40 - 14 = 26
int numEcBytesInGroup2 = numTotalBytesInGroup2 - numDataBytesInGroup2;
// Sanity checks.
// 26 = 26
if (numEcBytesInGroup1 != numEcBytesInGroup2) {
throw std::invalid_argument("EC bytes mismatch");
}
// 5 = 4 + 1.
if (numRSBlocks != numRsBlocksInGroup1 + numRsBlocksInGroup2) {
throw std::invalid_argument("RS blocks mismatch");
}
// 196 = (13 + 26) * 4 + (14 + 26) * 1
if (numTotalBytes
!= ((numDataBytesInGroup1 + numEcBytesInGroup1) * numRsBlocksInGroup1)
+ ((numDataBytesInGroup2 + numEcBytesInGroup2) * numRsBlocksInGroup2)) {
throw std::invalid_argument("Total bytes mismatch");
}
if (blockID < numRsBlocksInGroup1) {
numDataBytesInBlock = numDataBytesInGroup1;
numECBytesInBlock = numEcBytesInGroup1;
}
else {
numDataBytesInBlock = numDataBytesInGroup2;
numECBytesInBlock = numEcBytesInGroup2;
}
}
ZXING_EXPORT_TEST_ONLY
void GenerateECBytes(const ByteArray& dataBytes, int numEcBytes, ByteArray& ecBytes)
{
std::vector<int> message(dataBytes.size() + numEcBytes, 0);
std::copy(dataBytes.begin(), dataBytes.end(), message.begin());
ReedSolomonEncode(GenericGF::QRCodeField256(), message, numEcBytes);
ecBytes.resize(numEcBytes);
std::transform(message.end() - numEcBytes, message.end(), ecBytes.begin(), [](auto c) { return narrow_cast<uint8_t>(c); });
}
/**
* Interleave "bits" with corresponding error correction bytes. On success, store the result in
* "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
*/
ZXING_EXPORT_TEST_ONLY
BitArray InterleaveWithECBytes(const BitArray& bits, int numTotalBytes, int numDataBytes, int numRSBlocks)
{
// "bits" must have "getNumDataBytes" bytes of data.
if (bits.sizeInBytes() != numDataBytes) {
throw std::invalid_argument("Number of bits and data bytes does not match");
}
// Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll
// store the divided data bytes blocks and error correction bytes blocks into "blocks".
int dataBytesOffset = 0;
int maxNumDataBytes = 0;
int maxNumEcBytes = 0;
// Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.
std::vector<BlockPair> blocks(numRSBlocks);
for (int i = 0; i < numRSBlocks; ++i) {
int numDataBytesInBlock = 0;
int numEcBytesInBlock = 0;
GetNumDataBytesAndNumECBytesForBlockID(numTotalBytes, numDataBytes, numRSBlocks, i, numDataBytesInBlock, numEcBytesInBlock);
blocks[i].dataBytes = bits.toBytes(8 * dataBytesOffset, numDataBytesInBlock);
GenerateECBytes(blocks[i].dataBytes, numEcBytesInBlock, blocks[i].ecBytes);
maxNumDataBytes = std::max(maxNumDataBytes, numDataBytesInBlock);
maxNumEcBytes = std::max(maxNumEcBytes, Size(blocks[i].ecBytes));
dataBytesOffset += numDataBytesInBlock;
}
if (numDataBytes != dataBytesOffset) {
throw std::invalid_argument("Data bytes does not match offset");
}
BitArray output;
// First, place data blocks.
for (int i = 0; i < maxNumDataBytes; ++i) {
for (auto& block : blocks) {
if (i < Size(block.dataBytes)) {
output.appendBits(block.dataBytes[i], 8);
}
}
}
// Then, place error correction blocks.
for (int i = 0; i < maxNumEcBytes; ++i) {
for (auto& block : blocks) {
if (i < Size(block.ecBytes)) {
output.appendBits(block.ecBytes[i], 8);
}
}
}
if (numTotalBytes != output.sizeInBytes()) { // Should be same.
throw std::invalid_argument("Interleaving error: " + std::to_string(numTotalBytes) + " and " + std::to_string(output.sizeInBytes())
+ " differ.");
}
return output;
}
static int ChooseMaskPattern(const BitArray& bits, ErrorCorrectionLevel ecLevel, const Version& version, TritMatrix& matrix)
{
int minPenalty = std::numeric_limits<int>::max(); // Lower penalty is better.
int bestMaskPattern = -1;
// We try all mask patterns to choose the best one.
for (int maskPattern = 0; maskPattern < NUM_MASK_PATTERNS; maskPattern++) {
BuildMatrix(bits, ecLevel, version, maskPattern, matrix);
int penalty = MaskUtil::CalculateMaskPenalty(matrix);
if (penalty < minPenalty) {
minPenalty = penalty;
bestMaskPattern = maskPattern;
}
}
return bestMaskPattern;
}
static int CalculateBitsNeeded(CodecMode mode, const BitArray& headerBits, const BitArray& dataBits, const Version& version)
{
return headerBits.size() + CharacterCountBits(mode, version) + dataBits.size();
}
/**
* Decides the smallest version of QR code that will contain all of the provided data.
* @throws WriterException if the data cannot fit in any version
*/
static const Version& RecommendVersion(ErrorCorrectionLevel ecLevel, CodecMode mode, const BitArray& headerBits, const BitArray& dataBits)
{
// Hard part: need to know version to know how many bits length takes. But need to know how many
// bits it takes to know version. First we take a guess at version by assuming version will be
// the minimum, 1:
int provisionalBitsNeeded = CalculateBitsNeeded(mode, headerBits, dataBits, *Version::Model2(1));
const Version& provisionalVersion = ChooseVersion(provisionalBitsNeeded, ecLevel);
// Use that guess to calculate the right version. I am still not sure this works in 100% of cases.
int bitsNeeded = CalculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion);
return ChooseVersion(bitsNeeded, ecLevel);
}
EncodeResult Encode(const std::wstring& content, ErrorCorrectionLevel ecLevel, CharacterSet charset, int versionNumber,
bool useGs1Format, int maskPattern)
{
bool charsetWasUnknown = charset == CharacterSet::Unknown;
if (charsetWasUnknown) {
charset = DEFAULT_BYTE_MODE_ENCODING;
}
// Pick an encoding mode appropriate for the content. Note that this will not attempt to use
// multiple modes / segments even if that were more efficient. Twould be nice.
CodecMode mode = ChooseMode(content, charset);
// This will store the header information, like mode and
// length, as well as "header" segments like an ECI segment.
BitArray headerBits;
// Append ECI segment if applicable
if (mode == CodecMode::BYTE && !charsetWasUnknown) {
AppendECI(charset, headerBits);
}
// Append the FNC1 mode header for GS1 formatted data if applicable
if (useGs1Format) {
// GS1 formatted codes are prefixed with a FNC1 in first position mode header
AppendModeInfo(CodecMode::FNC1_FIRST_POSITION, headerBits);
}
// (With ECI in place,) Write the mode marker
AppendModeInfo(mode, headerBits);
// Collect data within the main segment, separately, to count its size if needed. Don't add it to
// main payload yet.
BitArray dataBits;
AppendBytes(content, mode, charset, dataBits);
const Version* version;
if (versionNumber > 0) {
version = Version::Model2(versionNumber);
if (version != nullptr) {
int bitsNeeded = CalculateBitsNeeded(mode, headerBits, dataBits, *version);
if (!WillFit(bitsNeeded, *version, ecLevel)) {
throw std::invalid_argument("Data too big for requested version");
}
}
else {
version = &RecommendVersion(ecLevel, mode, headerBits, dataBits);
}
}
else {
version = &RecommendVersion(ecLevel, mode, headerBits, dataBits);
}
BitArray headerAndDataBits;
headerAndDataBits.appendBitArray(headerBits);
// Find "length" of main segment and write it
int numLetters = mode == CodecMode::BYTE ? dataBits.sizeInBytes() : Size(content);
AppendLengthInfo(numLetters, *version, mode, headerAndDataBits);
// Put data together into the overall payload
headerAndDataBits.appendBitArray(dataBits);
auto& ecBlocks = version->ecBlocksForLevel(ecLevel);
int numDataBytes = version->totalCodewords() - ecBlocks.totalCodewords();
// Terminate the bits properly.
TerminateBits(numDataBytes, headerAndDataBits);
// Interleave data bits with error correction code.
BitArray finalBits =
InterleaveWithECBytes(headerAndDataBits, version->totalCodewords(), numDataBytes, ecBlocks.numBlocks());
EncodeResult output;
output.ecLevel = ecLevel;
output.mode = mode;
output.version = version;
// Choose the mask pattern and set to "qrCode".
int dimension = version->dimension();
TritMatrix matrix(dimension, dimension);
output.maskPattern = maskPattern != -1 ? maskPattern : ChooseMaskPattern(finalBits, ecLevel, *version, matrix);
// Build the matrix and set it to "qrCode".
BuildMatrix(finalBits, ecLevel, *version, output.maskPattern, matrix);
output.matrix = ToBitMatrix(matrix);
return output;
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QREncoder.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 5,605
|
```objective-c
/*
*/
#pragma once
namespace ZXing::QRCode {
/**
* <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
* defined by the QR code standard.</p>
*
* @author Sean Owen
*/
enum class ErrorCorrectionLevel
{
Low, // L = ~7 % correction
Medium, // M = ~15% correction
Quality, // Q = ~25% correction
High, // H = ~30% correction
Invalid, // denotes in invalid/unknown value
};
const char* ToString(ErrorCorrectionLevel l);
ErrorCorrectionLevel ECLevelFromString(const char* str);
ErrorCorrectionLevel ECLevelFromBits(int bits, const bool isMicro = false);
int BitsFromECLevel(ErrorCorrectionLevel l);
enum class Type
{
Model1,
Model2,
Micro,
rMQR,
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRErrorCorrectionLevel.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 203
|
```c++
/*
*/
#include "QRDecoder.h"
#include "BitMatrix.h"
#include "BitSource.h"
#include "CharacterSet.h"
#include "DecoderResult.h"
#include "GenericGF.h"
#include "QRBitMatrixParser.h"
#include "QRCodecMode.h"
#include "QRDataBlock.h"
#include "QRFormatInformation.h"
#include "QRVersion.h"
#include "ReedSolomonDecoder.h"
#include "StructuredAppend.h"
#include "ZXAlgorithms.h"
#include "ZXTestSupport.h"
#include <algorithm>
#include <stdexcept>
#include <utility>
#include <vector>
namespace ZXing::QRCode {
/**
* <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
* correct the errors in-place using Reed-Solomon error correction.</p>
*
* @param codewordBytes data and error correction codewords
* @param numDataCodewords number of codewords that are data bytes
* @return false if error correction fails
*/
static bool CorrectErrors(ByteArray& codewordBytes, int numDataCodewords)
{
// First read into an array of ints
std::vector<int> codewordsInts(codewordBytes.begin(), codewordBytes.end());
int numECCodewords = Size(codewordBytes) - numDataCodewords;
if (!ReedSolomonDecode(GenericGF::QRCodeField256(), codewordsInts, numECCodewords))
return false;
// Copy back into array of bytes -- only need to worry about the bytes that were data
// We don't care about errors in the error-correction codewords
std::copy_n(codewordsInts.begin(), numDataCodewords, codewordBytes.begin());
return true;
}
/**
* See specification GBT 18284-2000
*/
static void DecodeHanziSegment(BitSource& bits, int count, Content& result)
{
// Each character will require 2 bytes, decode as GB2312
// There is no ECI value for GB2312, use GB18030 which is a superset
result.switchEncoding(CharacterSet::GB18030);
result.reserve(2 * count);
while (count > 0) {
// Each 13 bits encodes a 2-byte character
int twoBytes = bits.readBits(13);
int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
if (assembledTwoBytes < 0x00A00) {
// In the 0xA1A1 to 0xAAFE range
assembledTwoBytes += 0x0A1A1;
} else {
// In the 0xB0A1 to 0xFAFE range
assembledTwoBytes += 0x0A6A1;
}
result += narrow_cast<uint8_t>((assembledTwoBytes >> 8) & 0xFF);
result += narrow_cast<uint8_t>(assembledTwoBytes & 0xFF);
count--;
}
}
static void DecodeKanjiSegment(BitSource& bits, int count, Content& result)
{
// Each character will require 2 bytes. Read the characters as 2-byte pairs
// and decode as Shift_JIS afterwards
result.switchEncoding(CharacterSet::Shift_JIS);
result.reserve(2 * count);
while (count > 0) {
// Each 13 bits encodes a 2-byte character
int twoBytes = bits.readBits(13);
int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
if (assembledTwoBytes < 0x01F00) {
// In the 0x8140 to 0x9FFC range
assembledTwoBytes += 0x08140;
} else {
// In the 0xE040 to 0xEBBF range
assembledTwoBytes += 0x0C140;
}
result += narrow_cast<uint8_t>(assembledTwoBytes >> 8);
result += narrow_cast<uint8_t>(assembledTwoBytes);
count--;
}
}
static void DecodeByteSegment(BitSource& bits, int count, Content& result)
{
result.switchEncoding(CharacterSet::Unknown);
result.reserve(count);
for (int i = 0; i < count; i++)
result += narrow_cast<uint8_t>(bits.readBits(8));
}
static char ToAlphaNumericChar(int value)
{
/**
* See ISO 18004:2006, 6.4.4 Table 5
*/
static const char ALPHANUMERIC_CHARS[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
' ', '$', '%', '*', '+', '-', '.', '/', ':'
};
if (value < 0 || value >= Size(ALPHANUMERIC_CHARS))
throw std::out_of_range("ToAlphaNumericChar: out of range");
return ALPHANUMERIC_CHARS[value];
}
static void DecodeAlphanumericSegment(BitSource& bits, int count, Content& result)
{
// Read two characters at a time
std::string buffer;
while (count > 1) {
int nextTwoCharsBits = bits.readBits(11);
buffer += ToAlphaNumericChar(nextTwoCharsBits / 45);
buffer += ToAlphaNumericChar(nextTwoCharsBits % 45);
count -= 2;
}
if (count == 1) {
// special case: one character left
buffer += ToAlphaNumericChar(bits.readBits(6));
}
// See section 6.4.8.1, 6.4.8.2
if (result.symbology.aiFlag != AIFlag::None) {
// We need to massage the result a bit if in an FNC1 mode:
for (auto i = buffer.begin(); i != buffer.end(); i++) {
if (*i == '%') {
if (i + 1 != buffer.end() && *(i + 1) == '%') {
// %% is rendered as %
i = buffer.erase(i);
} else {
// In alpha mode, % should be converted to FNC1 separator 0x1D
*i = static_cast<char>(0x1D);
}
}
}
}
result.switchEncoding(CharacterSet::ISO8859_1);
result += buffer;
}
static void DecodeNumericSegment(BitSource& bits, int count, Content& result)
{
result.switchEncoding(CharacterSet::ISO8859_1);
result.reserve(count);
while (count) {
int n = std::min(count, 3);
int nDigits = bits.readBits(1 + 3 * n); // read 4, 7 or 10 bits into 1, 2 or 3 digits
result.append(ZXing::ToString(nDigits, n));
count -= n;
}
}
static ECI ParseECIValue(BitSource& bits)
{
int firstByte = bits.readBits(8);
if ((firstByte & 0x80) == 0) {
// just one byte
return ECI(firstByte & 0x7F);
}
if ((firstByte & 0xC0) == 0x80) {
// two bytes
int secondByte = bits.readBits(8);
return ECI(((firstByte & 0x3F) << 8) | secondByte);
}
if ((firstByte & 0xE0) == 0xC0) {
// three bytes
int secondThirdBytes = bits.readBits(16);
return ECI(((firstByte & 0x1F) << 16) | secondThirdBytes);
}
throw FormatError("ParseECIValue: invalid value");
}
/**
* QR codes encode mode indicators and terminator codes into a constant bit length of 4.
* Micro QR codes have terminator codes that vary in bit length but are always longer than
* the mode indicators.
* M1 - 0 length mode code, 3 bits terminator code
* M2 - 1 bit mode code, 5 bits terminator code
* M3 - 2 bit mode code, 7 bits terminator code
* M4 - 3 bit mode code, 9 bits terminator code
* IsTerminator peaks into the bit stream to see if the current position is at the start of
* a terminator code. If true, then the decoding can finish. If false, then the decoding
* can read off the next mode code.
*
* See ISO 18004:2015, 7.4.1 Table 2
*
* @param bits the stream of bits that might have a terminator code
* @param version the QR or micro QR code version
*/
bool IsEndOfStream(const BitSource& bits, const Version& version)
{
const int bitsRequired = TerminatorBitsLength(version);
const int bitsAvailable = std::min(bits.available(), bitsRequired);
return bitsAvailable == 0 || bits.peakBits(bitsAvailable) == 0;
}
/**
* <p>QR Codes can encode text as bits in one of several modes, and can use multiple modes
* in one QR Code. This method decodes the bits back into text.</p>
*
* <p>See ISO 18004:2006, 6.4.3 - 6.4.7</p>
*/
ZXING_EXPORT_TEST_ONLY
DecoderResult DecodeBitStream(ByteArray&& bytes, const Version& version, ErrorCorrectionLevel ecLevel)
{
BitSource bits(bytes);
Content result;
Error error;
result.symbology = {'Q', version.isModel1() ? '0' : '1', 1};
StructuredAppendInfo structuredAppend;
const int modeBitLength = CodecModeBitsLength(version);
if (version.isModel1())
bits.readBits(4); // Model 1 is leading with 4 0-bits -> drop them
try
{
while(!IsEndOfStream(bits, version)) {
CodecMode mode;
if (modeBitLength == 0)
mode = CodecMode::NUMERIC; // MicroQRCode version 1 is always NUMERIC and modeBitLength is 0
else
mode = CodecModeForBits(bits.readBits(modeBitLength), version.type());
switch (mode) {
case CodecMode::FNC1_FIRST_POSITION:
// if (!result.empty()) // uncomment to enforce specification
// throw FormatError("GS1 Indicator (FNC1 in first position) at illegal position");
result.symbology.modifier = '3';
result.symbology.aiFlag = AIFlag::GS1; // In Alphanumeric mode undouble doubled '%' and treat single '%' as <GS>
break;
case CodecMode::FNC1_SECOND_POSITION:
if (!result.empty())
throw FormatError("AIM Application Indicator (FNC1 in second position) at illegal position");
result.symbology.modifier = '5'; // As above
// ISO/IEC 18004:2015 7.4.8.3 AIM Application Indicator (FNC1 in second position), "00-99" or "A-Za-z"
if (int appInd = bits.readBits(8); appInd < 100) // "00-09"
result += ZXing::ToString(appInd, 2);
else if ((appInd >= 165 && appInd <= 190) || (appInd >= 197 && appInd <= 222)) // "A-Za-z"
result += narrow_cast<uint8_t>(appInd - 100);
else
throw FormatError("Invalid AIM Application Indicator");
result.symbology.aiFlag = AIFlag::AIM; // see also above
break;
case CodecMode::STRUCTURED_APPEND:
// sequence number and parity is added later to the result metadata
// Read next 4 bits of index, 4 bits of symbol count, and 8 bits of parity data, then continue
structuredAppend.index = bits.readBits(4);
structuredAppend.count = bits.readBits(4) + 1;
structuredAppend.id = std::to_string(bits.readBits(8));
break;
case CodecMode::ECI:
if (version.isModel1())
throw FormatError("QRCode Model 1 does not support ECI");
// Count doesn't apply to ECI
result.switchEncoding(ParseECIValue(bits));
break;
case CodecMode::HANZI: {
// First handle Hanzi mode which does not start with character count
// chinese mode contains a sub set indicator right after mode indicator
if (int subset = bits.readBits(4); subset != 1) // GB2312_SUBSET is the only supported one right now
throw FormatError("Unsupported HANZI subset");
int count = bits.readBits(CharacterCountBits(mode, version));
DecodeHanziSegment(bits, count, result);
break;
}
default: {
// "Normal" QR code modes:
// How many characters will follow, encoded in this mode?
int count = bits.readBits(CharacterCountBits(mode, version));
switch (mode) {
case CodecMode::NUMERIC: DecodeNumericSegment(bits, count, result); break;
case CodecMode::ALPHANUMERIC: DecodeAlphanumericSegment(bits, count, result); break;
case CodecMode::BYTE: DecodeByteSegment(bits, count, result); break;
case CodecMode::KANJI: DecodeKanjiSegment(bits, count, result); break;
default: throw FormatError("Invalid CodecMode");
}
break;
}
}
}
} catch (std::out_of_range&) { // see BitSource::readBits
error = FormatError("Truncated bit stream");
} catch (Error e) {
error = std::move(e);
}
return DecoderResult(std::move(result))
.setError(std::move(error))
.setEcLevel(ToString(ecLevel))
.setVersionNumber(version.versionNumber())
.setStructuredAppend(structuredAppend);
}
DecoderResult Decode(const BitMatrix& bits)
{
if (!Version::HasValidSize(bits))
return FormatError("Invalid symbol size");
auto formatInfo = ReadFormatInformation(bits);
if (!formatInfo.isValid())
return FormatError("Invalid format information");
const Version* pversion = ReadVersion(bits, formatInfo.type());
if (!pversion)
return FormatError("Invalid version");
const Version& version = *pversion;
// Read codewords
ByteArray codewords = ReadCodewords(bits, version, formatInfo);
if (codewords.empty())
return FormatError("Failed to read codewords");
// Separate into data blocks
std::vector<DataBlock> dataBlocks = DataBlock::GetDataBlocks(codewords, version, formatInfo.ecLevel);
if (dataBlocks.empty())
return FormatError("Failed to get data blocks");
// Count total number of data bytes
const auto op = [](auto totalBytes, const auto& dataBlock){ return totalBytes + dataBlock.numDataCodewords();};
const auto totalBytes = Reduce(dataBlocks, int{}, op);
ByteArray resultBytes(totalBytes);
auto resultIterator = resultBytes.begin();
// Error-correct and copy data blocks together into a stream of bytes
for (auto& dataBlock : dataBlocks)
{
ByteArray& codewordBytes = dataBlock.codewords();
int numDataCodewords = dataBlock.numDataCodewords();
if (!CorrectErrors(codewordBytes, numDataCodewords))
return ChecksumError();
resultIterator = std::copy_n(codewordBytes.begin(), numDataCodewords, resultIterator);
}
// Decode the contents of that stream of bytes
return DecodeBitStream(std::move(resultBytes), version, formatInfo.ecLevel).setIsMirrored(formatInfo.isMirrored);
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRDecoder.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 3,599
|
```objective-c
/*
*/
#pragma once
#include "ConcentricFinder.h"
#include "DetectorResult.h"
#include <vector>
namespace ZXing {
class DetectorResult;
class BitMatrix;
namespace QRCode {
struct FinderPatternSet
{
ConcentricPattern bl, tl, tr;
};
using FinderPatterns = std::vector<ConcentricPattern>;
using FinderPatternSets = std::vector<FinderPatternSet>;
FinderPatterns FindFinderPatterns(const BitMatrix& image, bool tryHarder);
FinderPatternSets GenerateFinderPatternSets(FinderPatterns& patterns);
DetectorResult SampleQR(const BitMatrix& image, const FinderPatternSet& fp);
DetectorResult SampleMQR(const BitMatrix& image, const ConcentricPattern& fp);
DetectorResult SampleRMQR(const BitMatrix& image, const ConcentricPattern& fp);
DetectorResult DetectPureQR(const BitMatrix& image);
DetectorResult DetectPureMQR(const BitMatrix& image);
DetectorResult DetectPureRMQR(const BitMatrix& image);
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRDetector.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 210
|
```c++
/*
*/
#include "QRFormatInformation.h"
#include "BitHacks.h"
#include "ZXAlgorithms.h"
namespace ZXing::QRCode {
static uint32_t MirrorBits(uint32_t bits)
{
return BitHacks::Reverse(bits) >> 17;
}
static FormatInformation FindBestFormatInfo(const std::vector<uint32_t>& masks, const std::vector<uint32_t>& bits)
{
// See ISO 18004:2015, Annex C, Table C.1
constexpr uint32_t MODEL2_MASKED_PATTERNS[] = {
0x5412, 0x5125, 0x5E7C, 0x5B4B, 0x45F9, 0x40CE, 0x4F97, 0x4AA0, 0x77C4, 0x72F3, 0x7DAA, 0x789D, 0x662F, 0x6318, 0x6C41, 0x6976,
0x1689, 0x13BE, 0x1CE7, 0x19D0, 0x0762, 0x0255, 0x0D0C, 0x083B, 0x355F, 0x3068, 0x3F31, 0x3A06, 0x24B4, 0x2183, 0x2EDA, 0x2BED,
};
FormatInformation fi;
for (auto mask : masks)
for (int bitsIndex = 0; bitsIndex < Size(bits); ++bitsIndex)
for (uint32_t pattern : MODEL2_MASKED_PATTERNS) {
// 'unmask' the pattern first to get the original 5-data bits + 10-ec bits back
pattern ^= FORMAT_INFO_MASK_MODEL2;
// Find the pattern with fewest bits differing
if (int hammingDist = BitHacks::CountBitsSet((bits[bitsIndex] ^ mask) ^ pattern);
hammingDist < fi.hammingDistance) {
fi.mask = mask; // store the used mask to discriminate between types/models
fi.data = pattern >> 10; // drop the 10 BCH error correction bits
fi.hammingDistance = hammingDist;
fi.bitsIndex = bitsIndex;
}
}
return fi;
}
static FormatInformation FindBestFormatInfoRMQR(const std::vector<uint32_t>& bits, const std::vector<uint32_t>& subbits)
{
// See ISO/IEC 23941:2022, Annex C, Table C.1 - Valid format information sequences
constexpr uint32_t MASKED_PATTERNS[64] = { // Finder pattern side
0x1FAB2, 0x1E597, 0x1DBDD, 0x1C4F8, 0x1B86C, 0x1A749, 0x19903, 0x18626,
0x17F0E, 0x1602B, 0x15E61, 0x14144, 0x13DD0, 0x122F5, 0x11CBF, 0x1039A,
0x0F1CA, 0x0EEEF, 0x0D0A5, 0x0CF80, 0x0B314, 0x0AC31, 0x0927B, 0x08D5E,
0x07476, 0x06B53, 0x05519, 0x04A3C, 0x036A8, 0x0298D, 0x017C7, 0x008E2,
0x3F367, 0x3EC42, 0x3D208, 0x3CD2D, 0x3B1B9, 0x3AE9C, 0x390D6, 0x38FF3,
0x376DB, 0x369FE, 0x357B4, 0x34891, 0x33405, 0x32B20, 0x3156A, 0x30A4F,
0x2F81F, 0x2E73A, 0x2D970, 0x2C655, 0x2BAC1, 0x2A5E4, 0x29BAE, 0x2848B,
0x27DA3, 0x26286, 0x25CCC, 0x243E9, 0x23F7D, 0x22058, 0x21E12, 0x20137,
};
constexpr uint32_t MASKED_PATTERNS_SUB[64] = { // Finder sub pattern side
0x20A7B, 0x2155E, 0x22B14, 0x23431, 0x248A5, 0x25780, 0x269CA, 0x276EF,
0x28FC7, 0x290E2, 0x2AEA8, 0x2B18D, 0x2CD19, 0x2D23C, 0x2EC76, 0x2F353,
0x30103, 0x31E26, 0x3206C, 0x33F49, 0x343DD, 0x35CF8, 0x362B2, 0x37D97,
0x384BF, 0x39B9A, 0x3A5D0, 0x3BAF5, 0x3C661, 0x3D944, 0x3E70E, 0x3F82B,
0x003AE, 0x01C8B, 0x022C1, 0x03DE4, 0x04170, 0x05E55, 0x0601F, 0x07F3A,
0x08612, 0x09937, 0x0A77D, 0x0B858, 0x0C4CC, 0x0DBE9, 0x0E5A3, 0x0FA86,
0x108D6, 0x117F3, 0x129B9, 0x1369C, 0x14A08, 0x1552D, 0x16B67, 0x17442,
0x18D6A, 0x1924F, 0x1AC05, 0x1B320, 0x1CFB4, 0x1D091, 0x1EEDB, 0x1F1FE,
};
FormatInformation fi;
auto best = [&fi](const std::vector<uint32_t>& bits, const uint32_t (&patterns)[64], uint32_t mask)
{
for (int bitsIndex = 0; bitsIndex < Size(bits); ++bitsIndex)
for (uint32_t pattern : patterns) {
// 'unmask' the pattern first to get the original 6-data bits + 12-ec bits back
pattern ^= mask;
// Find the pattern with fewest bits differing
if (int hammingDist = BitHacks::CountBitsSet((bits[bitsIndex] ^ mask) ^ pattern);
hammingDist < fi.hammingDistance) {
fi.mask = mask; // store the used mask to discriminate between types/models
fi.data = pattern >> 12; // drop the 12 BCH error correction bits
fi.hammingDistance = hammingDist;
fi.bitsIndex = bitsIndex;
}
}
};
best(bits, MASKED_PATTERNS, FORMAT_INFO_MASK_RMQR);
if (Size(subbits)) // TODO probably remove if `sampleRMQR()` done properly
best(subbits, MASKED_PATTERNS_SUB, FORMAT_INFO_MASK_RMQR_SUB);
return fi;
}
/**
* @param formatInfoBits1 format info indicator, with mask still applied
* @param formatInfoBits2 second copy of same info; both are checked at the same time to establish best match
*/
FormatInformation FormatInformation::DecodeQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2)
{
// maks out the 'Dark Module' for mirrored and non-mirrored case (see Figure 25 in ISO/IEC 18004:2015)
uint32_t mirroredFormatInfoBits2 = MirrorBits(((formatInfoBits2 >> 1) & 0b111111110000000) | (formatInfoBits2 & 0b1111111));
formatInfoBits2 = ((formatInfoBits2 >> 1) & 0b111111100000000) | (formatInfoBits2 & 0b11111111);
// Some (Model2) QR codes apparently do not apply the XOR mask. Try with (standard) and without (quirk) masking.
auto fi = FindBestFormatInfo({FORMAT_INFO_MASK_MODEL2, 0, FORMAT_INFO_MASK_MODEL1},
{formatInfoBits1, formatInfoBits2, MirrorBits(formatInfoBits1), mirroredFormatInfoBits2});
// Use bits 3/4 for error correction, and 0-2 for mask.
fi.ecLevel = ECLevelFromBits((fi.data >> 3) & 0x03);
fi.dataMask = static_cast<uint8_t>(fi.data & 0x07);
fi.isMirrored = fi.bitsIndex > 1;
return fi;
}
/**
* @param formatInfoBits format info indicator, with mask still applied
*/
FormatInformation FormatInformation::DecodeMQR(uint32_t formatInfoBits)
{
auto fi = FindBestFormatInfo({FORMAT_INFO_MASK_MICRO}, {formatInfoBits, MirrorBits(formatInfoBits)});
constexpr uint8_t BITS_TO_VERSION[] = {1, 2, 2, 3, 3, 4, 4, 4};
// Bits 2/3/4 contain both error correction level and version, 0/1 contain mask.
fi.ecLevel = ECLevelFromBits((fi.data >> 2) & 0x07, true);
fi.dataMask = static_cast<uint8_t>(fi.data & 0x03);
fi.microVersion = BITS_TO_VERSION[(fi.data >> 2) & 0x07];
fi.isMirrored = fi.bitsIndex == 1;
return fi;
}
/**
* @param formatInfoBits1 format info indicator, with mask still applied
* @param formatInfoBits2 second copy of same info; both are checked at the same time to establish best match
*/
FormatInformation FormatInformation::DecodeRMQR(uint32_t formatInfoBits1, uint32_t formatInfoBits2)
{
FormatInformation fi;
if (formatInfoBits2)
fi = FindBestFormatInfoRMQR({formatInfoBits1}, {formatInfoBits2});
else // TODO probably remove if `sampleRMQR()` done properly
fi = FindBestFormatInfoRMQR({formatInfoBits1}, {});
// Bit 6 is error correction (M/H), and bits 0-5 version.
fi.ecLevel = ECLevelFromBits(((fi.data >> 5) & 1) << 1); // Shift to match QRCode M/H
fi.dataMask = 4; // ((y / 2) + (x / 3)) % 2 == 0
fi.microVersion = (fi.data & 0x1F) + 1;
fi.isMirrored = false; // TODO: implement mirrored format bit reading
return fi;
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRFormatInformation.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,618
|
```objective-c
/*
*/
#pragma once
#include "Reader.h"
namespace ZXing::QRCode {
class Reader : public ZXing::Reader
{
public:
using ZXing::Reader::Reader;
Barcode decode(const BinaryBitmap& image) const override;
Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRReader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 77
|
```c++
/*
*/
#include "QRErrorCorrectionLevel.h"
#include <cassert>
namespace ZXing::QRCode {
const char* ToString(ErrorCorrectionLevel l)
{
assert(l != ErrorCorrectionLevel::Invalid);
static const char* const LEVEL_STR[] = {"L", "M", "Q", "H", nullptr};
return LEVEL_STR[static_cast<int>(l)];
}
ErrorCorrectionLevel ECLevelFromString(const char* str)
{
switch (str[0]) {
case 'L': return ErrorCorrectionLevel::Low;
case 'M': return ErrorCorrectionLevel::Medium;
case 'Q': return ErrorCorrectionLevel::Quality;
case 'H': return ErrorCorrectionLevel::High;
default: return ErrorCorrectionLevel::Invalid;
}
}
ErrorCorrectionLevel ECLevelFromBits(int bits, const bool isMicro)
{
if (isMicro) {
constexpr ErrorCorrectionLevel LEVEL_FOR_BITS[] = {
ErrorCorrectionLevel::Low, ErrorCorrectionLevel::Low, ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low,
ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low, ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Quality};
return LEVEL_FOR_BITS[bits & 0x07];
}
constexpr ErrorCorrectionLevel LEVEL_FOR_BITS[] = {ErrorCorrectionLevel::Medium, ErrorCorrectionLevel::Low,
ErrorCorrectionLevel::High, ErrorCorrectionLevel::Quality};
return LEVEL_FOR_BITS[bits & 0x3];
}
int BitsFromECLevel(ErrorCorrectionLevel l)
{
assert(l != ErrorCorrectionLevel::Invalid);
static const int BITS[] = {1, 0, 3, 2, -1};
return BITS[(int)l];
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRErrorCorrectionLevel.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 358
|
```c++
/*
*/
#include "QRWriter.h"
#include "BitMatrix.h"
#include "CharacterSet.h"
#include "QREncodeResult.h"
#include "QREncoder.h"
#include "QRErrorCorrectionLevel.h"
#include "Utf.h"
#include <stdexcept>
#include <utility>
namespace ZXing::QRCode {
static const int QUIET_ZONE_SIZE = 4;
Writer::Writer()
: _margin(QUIET_ZONE_SIZE),
_ecLevel(ErrorCorrectionLevel::Low),
_encoding(CharacterSet::Unknown),
_version(0),
_useGs1Format(false),
_maskPattern(-1)
{}
BitMatrix Writer::encode(const std::wstring& contents, int width, int height) const
{
if (contents.empty()) {
throw std::invalid_argument("Found empty contents");
}
if (width < 0 || height < 0) {
throw std::invalid_argument("Requested dimensions are invalid");
}
EncodeResult code = Encode(contents, _ecLevel, _encoding, _version, _useGs1Format, _maskPattern);
return Inflate(std::move(code.matrix), width, height, _margin);
}
BitMatrix Writer::encode(const std::string& contents, int width, int height) const
{
return encode(FromUtf8(contents), width, height);
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRWriter.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 284
|
```objective-c
/*
*/
#pragma once
#include "BitMatrix.h"
#include <array>
#include <stdexcept>
namespace ZXing::QRCode {
/**
* <p>Encapsulates data masks for the data bits in a QR and micro QR code, per ISO 18004:2006 6.8.</p>
*
* <p>Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position
* and j is row position. In fact, as the text says, i is row position and j is column position.</p>
*/
inline bool GetDataMaskBit(int maskIndex, int x, int y, bool isMicro = false)
{
if (isMicro) {
if (maskIndex < 0 || maskIndex >= 4)
throw std::invalid_argument("QRCode maskIndex out of range");
maskIndex = std::array{1, 4, 6, 7}[maskIndex]; // map from MQR to QR indices
}
switch (maskIndex) {
case 0: return (y + x) % 2 == 0;
case 1: return y % 2 == 0;
case 2: return x % 3 == 0;
case 3: return (y + x) % 3 == 0;
case 4: return ((y / 2) + (x / 3)) % 2 == 0;
case 5: return (y * x) % 6 == 0;
case 6: return ((y * x) % 6) < 3;
case 7: return (y + x + ((y * x) % 3)) % 2 == 0;
}
throw std::invalid_argument("QRCode maskIndex out of range");
}
inline bool GetMaskedBit(const BitMatrix& bits, int x, int y, int maskIndex, bool isMicro = false)
{
return GetDataMaskBit(maskIndex, x, y, isMicro) != bits.get(x, y);
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRDataMask.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 440
|
```objective-c
/*
*/
#pragma once
#include <array>
namespace ZXing::QRCode {
/**
* <p>Encapsulates the parameters for one error-correction block in one symbol version.
* This includes the number of data codewords, and the number of times a block with these
* parameters is used consecutively in the QR code version's format.</p>
*
* @author Sean Owen
*/
struct ECB
{
int count;
int dataCodewords;
};
/**
* <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
* use blocks of differing sizes within one version, so, this encapsulates the parameters for
* each set of blocks. It also holds the number of error-correction codewords per block since it
* will be the same across all blocks within one version.</p>
*
* @author Sean Owen
*/
struct ECBlocks
{
int codewordsPerBlock;
std::array<ECB, 2> blocks;
int numBlocks() const { return blocks[0].count + blocks[1].count; }
int totalCodewords() const { return codewordsPerBlock * numBlocks(); }
int totalDataCodewords() const
{
return blocks[0].count * (blocks[0].dataCodewords + codewordsPerBlock)
+ blocks[1].count * (blocks[1].dataCodewords + codewordsPerBlock);
}
const std::array<ECB, 2>& blockArray() const { return blocks; }
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRECB.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 340
|
```objective-c
/*
*/
#pragma once
#include "QRErrorCorrectionLevel.h"
namespace ZXing {
class BitMatrix;
class ByteArray;
namespace QRCode {
class Version;
class FormatInformation;
/**
* @brief Reads version information from the QR Code.
* @return {@link Version} encapsulating the QR Code's version, nullptr if neither location can be parsed
*/
const Version* ReadVersion(const BitMatrix& bitMatrix, Type type);
/**
* @brief Reads format information from one of its two locations within the QR Code.
* @return {@link FormatInformation} encapsulating the QR Code's format info, result is invalid if both format
* information locations cannot be parsed as the valid encoding of format information
*/
FormatInformation ReadFormatInformation(const BitMatrix& bitMatrix);
/**
* @brief Reads the codewords from the BitMatrix.
* @return bytes encoded within the QR Code or empty array if the exact number of bytes expected is not read
*/
ByteArray ReadCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo);
} // QRCode
} // ZXing
```
|
/content/code_sandbox/core/src/qrcode/QRBitMatrixParser.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 229
|
```objective-c
/*
*/
#pragma once
#include "ByteArray.h"
#include <vector>
namespace ZXing::QRCode {
class Version;
enum class ErrorCorrectionLevel;
/**
* <p>Encapsulates a block of data within a QR Code. QR Codes may split their data into
* multiple blocks, each of which is a unit of data and error-correction codewords. Each
* is represented by an instance of this class.</p>
*
* @author Sean Owen
*/
class DataBlock
{
public:
int numDataCodewords() const { return _numDataCodewords; }
const ByteArray& codewords() const { return _codewords; }
ByteArray& codewords() { return _codewords; }
/**
* <p>When QR Codes use multiple data blocks, they are actually interleaved.
* That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
* method will separate the data into original blocks.</p>
*
* @param rawCodewords bytes as read directly from the QR Code
* @param version version of the QR Code
* @param ecLevel error-correction level of the QR Code
* @return DataBlocks containing original bytes, "de-interleaved" from representation in the
* QR Code
*/
static std::vector<DataBlock> GetDataBlocks(const ByteArray& rawCodewords, const Version& version, ErrorCorrectionLevel ecLevel);
private:
int _numDataCodewords = 0;
ByteArray _codewords;
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRDataBlock.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 349
|
```c++
/*
*/
#include "QRDataBlock.h"
#include "QRErrorCorrectionLevel.h"
#include "QRVersion.h"
#include "ZXAlgorithms.h"
namespace ZXing::QRCode {
std::vector<DataBlock> DataBlock::GetDataBlocks(const ByteArray& rawCodewords, const Version& version, ErrorCorrectionLevel ecLevel)
{
if (Size(rawCodewords) != version.totalCodewords())
return {};
// Figure out the number and size of data blocks used by this version and
// error correction level
auto& ecBlocks = version.ecBlocksForLevel(ecLevel);
// First count the total number of data blocks
int totalBlocks = ecBlocks.numBlocks();
if (totalBlocks == 0)
return {};
std::vector<DataBlock> result(totalBlocks);
// Now establish DataBlocks of the appropriate size and number of data codewords
int numResultBlocks = 0;
for (auto& ecBlock : ecBlocks.blockArray()) {
for (int i = 0; i < ecBlock.count; i++) {
auto& item = result[numResultBlocks++];
item._numDataCodewords = ecBlock.dataCodewords;
item._codewords.resize(ecBlocks.codewordsPerBlock + ecBlock.dataCodewords);
}
}
// All blocks have the same amount of data, except that the last n
// (where n may be 0) have 1 more byte. Figure out where these start.
int shorterBlocksTotalCodewords = Size(result[0]._codewords);
int longerBlocksStartAt = Size(result) - 1;
while (longerBlocksStartAt >= 0) {
int numCodewords = Size(result[longerBlocksStartAt]._codewords);
if (numCodewords == shorterBlocksTotalCodewords) {
break;
}
longerBlocksStartAt--;
}
longerBlocksStartAt++;
int shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.codewordsPerBlock;
// The last elements of result may be 1 element longer;
// first fill out as many elements as all of them have
int rawCodewordsOffset = 0;
for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
for (int j = 0; j < numResultBlocks; j++) {
result[j]._codewords[i] = rawCodewords[rawCodewordsOffset++];
}
}
// Fill out the last data block in the longer ones
for (int j = longerBlocksStartAt; j < numResultBlocks; j++) {
result[j]._codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];
}
// Now add in error correction blocks
int max = Size(result[0]._codewords);
for (int i = shorterBlocksNumDataCodewords; i < max; i++) {
for (int j = 0; j < numResultBlocks; j++) {
int iOffset = j < longerBlocksStartAt ? i : i + 1;
result[j]._codewords[iOffset] = rawCodewords[rawCodewordsOffset++];
}
}
return result;
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRDataBlock.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 721
|
```objective-c
/*
*/
#pragma once
namespace ZXing::QRCode {
enum class Type;
class Version;
/**
* <p>See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which
* data can be encoded to bits in the QR code standard.</p>
*/
enum class CodecMode
{
TERMINATOR = 0x00, // Not really a mode...
NUMERIC = 0x01,
ALPHANUMERIC = 0x02,
STRUCTURED_APPEND = 0x03,
BYTE = 0x04,
FNC1_FIRST_POSITION = 0x05,
ECI = 0x07, // character counts don't apply
KANJI = 0x08,
FNC1_SECOND_POSITION = 0x09,
HANZI = 0x0D, // See GBT 18284-2000; "Hanzi" is a transliteration of this mode name.
};
/**
* @param bits variable number of bits encoding a QR Code data mode
* @param type type of QR Code
* @return Mode encoded by these bits
* @throws FormatError if bits do not correspond to a known mode
*/
CodecMode CodecModeForBits(int bits, Type type);
/**
* @param version version in question
* @return number of bits used, in this QR Code symbol {@link Version}, to encode the
* count of characters that will follow encoded in this Mode
*/
int CharacterCountBits(CodecMode mode, const Version& version);
/**
* @param version version in question
* @return number of bits used to encode a codec mode.
*/
int CodecModeBitsLength(const Version& version);
/**
* @param version version in question
* @return number of bits in the Terminator code.
*/
int TerminatorBitsLength(const Version& version);
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRCodecMode.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 416
|
```c++
/*
*/
#include "QRReader.h"
#include "BinaryBitmap.h"
#include "ConcentricFinder.h"
#include "ReaderOptions.h"
#include "DecoderResult.h"
#include "DetectorResult.h"
#include "LogMatrix.h"
#include "QRDecoder.h"
#include "QRDetector.h"
#include "Barcode.h"
#include <utility>
namespace ZXing::QRCode {
Barcode Reader::decode(const BinaryBitmap& image) const
{
#if 1
if (!_opts.isPure())
return FirstOrDefault(decode(image, 1));
#endif
auto binImg = image.getBitMatrix();
if (binImg == nullptr)
return {};
DetectorResult detectorResult;
if (_opts.hasFormat(BarcodeFormat::QRCode))
detectorResult = DetectPureQR(*binImg);
if (_opts.hasFormat(BarcodeFormat::MicroQRCode) && !detectorResult.isValid())
detectorResult = DetectPureMQR(*binImg);
if (_opts.hasFormat(BarcodeFormat::RMQRCode) && !detectorResult.isValid())
detectorResult = DetectPureRMQR(*binImg);
if (!detectorResult.isValid())
return {};
auto decoderResult = Decode(detectorResult.bits());
auto format = detectorResult.bits().width() != detectorResult.bits().height() ? BarcodeFormat::RMQRCode
: detectorResult.bits().width() < 21 ? BarcodeFormat::MicroQRCode
: BarcodeFormat::QRCode;
return Barcode(std::move(decoderResult), std::move(detectorResult), format);
}
void logFPSet(const FinderPatternSet& fps [[maybe_unused]])
{
#ifdef PRINT_DEBUG
auto drawLine = [](PointF a, PointF b) {
int steps = maxAbsComponent(b - a);
PointF dir = bresenhamDirection(PointF(b - a));
for (int i = 0; i < steps; ++i)
log(a + i * dir, 2);
};
drawLine(fps.bl, fps.tl);
drawLine(fps.tl, fps.tr);
drawLine(fps.tr, fps.bl);
#endif
}
Barcodes Reader::decode(const BinaryBitmap& image, int maxSymbols) const
{
auto binImg = image.getBitMatrix();
if (binImg == nullptr)
return {};
#ifdef PRINT_DEBUG
LogMatrixWriter lmw(log, *binImg, 5, "qr-log.pnm");
#endif
auto allFPs = FindFinderPatterns(*binImg, _opts.tryHarder());
#ifdef PRINT_DEBUG
printf("allFPs: %d\n", Size(allFPs));
#endif
std::vector<ConcentricPattern> usedFPs;
Barcodes res;
if (_opts.hasFormat(BarcodeFormat::QRCode)) {
auto allFPSets = GenerateFinderPatternSets(allFPs);
for (const auto& fpSet : allFPSets) {
if (Contains(usedFPs, fpSet.bl) || Contains(usedFPs, fpSet.tl) || Contains(usedFPs, fpSet.tr))
continue;
logFPSet(fpSet);
auto detectorResult = SampleQR(*binImg, fpSet);
if (detectorResult.isValid()) {
auto decoderResult = Decode(detectorResult.bits());
if (decoderResult.isValid()) {
usedFPs.push_back(fpSet.bl);
usedFPs.push_back(fpSet.tl);
usedFPs.push_back(fpSet.tr);
}
if (decoderResult.isValid(_opts.returnErrors())) {
res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::QRCode);
if (maxSymbols && Size(res) == maxSymbols)
break;
}
}
}
}
if (_opts.hasFormat(BarcodeFormat::MicroQRCode) && !(maxSymbols && Size(res) == maxSymbols)) {
for (const auto& fp : allFPs) {
if (Contains(usedFPs, fp))
continue;
auto detectorResult = SampleMQR(*binImg, fp);
if (detectorResult.isValid()) {
auto decoderResult = Decode(detectorResult.bits());
if (decoderResult.isValid(_opts.returnErrors())) {
res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::MicroQRCode);
if (maxSymbols && Size(res) == maxSymbols)
break;
}
}
}
}
if (_opts.hasFormat(BarcodeFormat::RMQRCode) && !(maxSymbols && Size(res) == maxSymbols)) {
// TODO proper
for (const auto& fp : allFPs) {
if (Contains(usedFPs, fp))
continue;
auto detectorResult = SampleRMQR(*binImg, fp);
if (detectorResult.isValid()) {
auto decoderResult = Decode(detectorResult.bits());
if (decoderResult.isValid(_opts.returnErrors())) {
res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::RMQRCode);
if (maxSymbols && Size(res) == maxSymbols)
break;
}
}
}
}
return res;
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRReader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,108
|
```c++
/*
*/
#include "QRMatrixUtil.h"
#include "BitArray.h"
#include "BitHacks.h"
#include "QRDataMask.h"
#include "QRErrorCorrectionLevel.h"
#include "QRVersion.h"
#include <stdexcept>
#include <string>
namespace ZXing::QRCode {
// From Appendix D in JISX0510:2004 (p. 67)
static const int VERSION_INFO_POLY = 0x1f25; // 1 1111 0010 0101
// From Appendix C in JISX0510:2004 (p.65).
static const int TYPE_INFO_POLY = 0x537;
static const int TYPE_INFO_MASK_PATTERN = 0x5412;
static void EmbedTimingPatterns(TritMatrix& matrix)
{
// -8 is for skipping position detection patterns (size 7), and two horizontal/vertical
// separation patterns (size 1). Thus, 8 = 7 + 1.
for (int i = 8; i < matrix.width() - 8; ++i) {
bool bit = (i + 1) % 2;
// Horizontal line.
matrix.set(i, 6, bit);
// Vertical line.
matrix.set(6, i, bit);
}
}
// Note that we cannot unify the function with embedPositionDetectionPattern() despite they are
// almost identical, since we cannot write a function that takes 2D arrays in different sizes in
// C/C++. We should live with the fact.
static void EmbedPositionAdjustmentPattern(int xStart, int yStart, TritMatrix& matrix)
{
for (int y = 0; y < 5; ++y)
for (int x = 0; x < 5; ++x)
matrix.set(xStart + x, yStart + y, maxAbsComponent(PointI(x, y) - PointI(2, 2)) != 1);
}
// Embed position adjustment patterns if need be.
static void EmbedPositionAdjustmentPatterns(const Version& version, TritMatrix& matrix)
{
if (version.versionNumber() < 2) { // The patterns appear if version >= 2
return;
}
auto& coordinates = version.alignmentPatternCenters();
for (int y : coordinates) {
for (int x : coordinates) {
// Check x/y is valid: don't place alignment patterns intersecting with the 3 finder patterns
if ((x == 6 && y == 6) || (x == 6 && y == matrix.height() - 7) || (x == matrix.width() - 7 && y == 6))
continue;
// -2 is necessary since the x/y coordinates point to the center of the pattern, not the
// left top corner.
EmbedPositionAdjustmentPattern(x - 2, y - 2, matrix);
}
}
}
static void EmbedPositionDetectionPattern(int xStart, int yStart, TritMatrix& matrix)
{
for (int y = 0; y < 7; ++y)
for (int x = 0; x < 7; ++x)
matrix.set(xStart + x, yStart + y, maxAbsComponent(PointI(x, y) - PointI(3, 3)) != 2);
// Surround the 7x7 pattern with one line of white space (separation pattern)
auto setIfInside = [&](int x, int y) {
if( x >= 0 && x < matrix.width() && y >= 0 && y < matrix.height())
matrix.set(x, y, 0);
};
for (int i = -1; i < 8; ++i) {
setIfInside(xStart + i, yStart - 1); // top
setIfInside(xStart + i, yStart + 7); // bottom
setIfInside(xStart - 1, yStart + i); // left
setIfInside(xStart + 7, yStart + i); // right
}
}
// Embed position detection patterns and surrounding vertical/horizontal separators.
static void EmbedPositionDetectionPatternsAndSeparators(TritMatrix& matrix)
{
// Left top corner.
EmbedPositionDetectionPattern(0, 0, matrix);
// Right top corner.
EmbedPositionDetectionPattern(matrix.width() - 7, 0, matrix);
// Left bottom corner.
EmbedPositionDetectionPattern(0, matrix.width() - 7, matrix);
}
// Embed the lonely dark dot at left bottom corner. JISX0510:2004 (p.46)
static void EmbedDarkDotAtLeftBottomCorner(TritMatrix& matrix)
{
matrix.set(8, matrix.height() - 8, 1);
}
// Return the position of the most significant bit set (to one) in the "value". The most
// significant bit is position 32. If there is no bit set, return 0. Examples:
// - findMSBSet(0) => 0
// - findMSBSet(1) => 1
// - findMSBSet(255) => 8
static int FindMSBSet(unsigned value)
{
return 32 - BitHacks::NumberOfLeadingZeros(value);
}
// Calculate BCH (Bose-Chaudhuri-Hocquenghem) code for "value" using polynomial "poly". The BCH
// code is used for encoding type information and version information.
// Example: Calculation of version information of 7.
// f(x) is created from 7.
// - 7 = 000111 in 6 bits
// - f(x) = x^2 + x^1 + x^0
// g(x) is given by the standard (p. 67)
// - g(x) = x^12 + x^11 + x^10 + x^9 + x^8 + x^5 + x^2 + 1
// Multiply f(x) by x^(18 - 6)
// - f'(x) = f(x) * x^(18 - 6)
// - f'(x) = x^14 + x^13 + x^12
// Calculate the remainder of f'(x) / g(x)
// x^2
// __________________________________________________
// g(x) )x^14 + x^13 + x^12
// x^14 + x^13 + x^12 + x^11 + x^10 + x^7 + x^4 + x^2
// --------------------------------------------------
// x^11 + x^10 + x^7 + x^4 + x^2
//
// The remainder is x^11 + x^10 + x^7 + x^4 + x^2
// Encode it in binary: 110010010100
// The return value is 0xc94 (1100 1001 0100)
//
// Since all coefficients in the polynomials are 1 or 0, we can do the calculation by bit
// operations. We don't care if cofficients are positive or negative.
static int CalculateBCHCode(int value, int poly)
{
// If poly is "1 1111 0010 0101" (version info poly), msbSetInPoly is 13. We'll subtract 1
// from 13 to make it 12.
int msbSetInPoly = FindMSBSet(poly);
value <<= msbSetInPoly - 1;
// Do the division business using exclusive-or operations.
while (FindMSBSet(value) >= msbSetInPoly) {
value ^= poly << (FindMSBSet(value) - msbSetInPoly);
}
// Now the "value" is the remainder (i.e. the BCH code)
return value;
}
// Make bit vector of type information. On success, store the result in "bits" and return true.
// Encode error correction level and mask pattern. See 8.9 of
// JISX0510:2004 (p.45) for details.
static BitArray MakeTypeInfoBits(ErrorCorrectionLevel ecLevel, int maskPattern)
{
if (maskPattern < 0 || maskPattern >= NUM_MASK_PATTERNS) {
throw std::invalid_argument("Invalid mask pattern");
}
BitArray bits;
int typeInfo = (BitsFromECLevel(ecLevel) << 3) | maskPattern;
bits.appendBits(typeInfo, 5);
int bchCode = CalculateBCHCode(typeInfo, TYPE_INFO_POLY);
bits.appendBits(bchCode, 10);
BitArray maskBits;
maskBits.appendBits(TYPE_INFO_MASK_PATTERN, 15);
bits.bitwiseXOR(maskBits);
if (bits.size() != 15) { // Just in case.
throw std::logic_error("Should not happen but we got: " + std::to_string(bits.size()));
}
return bits;
}
// Embed type information. On success, modify the matrix.
static void EmbedTypeInfo(ErrorCorrectionLevel ecLevel, int maskPattern, TritMatrix& matrix)
{
// Type info cells at the left top corner.
constexpr PointI TYPE_INFO_COORDINATES[] = {
{8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5}, {8, 7}, {8, 8},
{7, 8}, {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8}, {0, 8}
};
BitArray typeInfoBits = MakeTypeInfoBits(ecLevel, maskPattern);
for (int i = 0; i < typeInfoBits.size(); ++i) {
// Place bits in LSB to MSB order. LSB (least significant bit) is the last value in
// "typeInfoBits".
bool bit = typeInfoBits.get(typeInfoBits.size() - 1 - i);
// Type info bits at the left top corner. See 8.9 of JISX0510:2004 (p.46).
matrix.set(TYPE_INFO_COORDINATES[i], bit);
if (i < 8) {
// Right top corner.
matrix.set(matrix.width() - i - 1, 8, bit);
}
else {
// Left bottom corner.
matrix.set(8, matrix.height() - 7 + (i - 8), bit);
}
}
}
// Make bit vector of version information. On success, store the result in "bits" and return true.
// See 8.10 of JISX0510:2004 (p.45) for details.
static BitArray MakeVersionInfoBits(const Version& version)
{
BitArray bits;
bits.appendBits(version.versionNumber(), 6);
int bchCode = CalculateBCHCode(version.versionNumber(), VERSION_INFO_POLY);
bits.appendBits(bchCode, 12);
if (bits.size() != 18) { // Just in case.
throw std::logic_error("Should not happen but we got: " + std::to_string(bits.size()));
}
return bits;
}
// Embed version information if need be. On success, modify the matrix and return true.
// See 8.10 of JISX0510:2004 (p.47) for how to embed version information.
static void EmbedVersionInfo(const Version& version, TritMatrix& matrix)
{
if (version.versionNumber() < 7) { // Version info is necessary if version >= 7.
return; // Don't need version info.
}
BitArray versionInfoBits = MakeVersionInfoBits(version);
int bitIndex = 6 * 3 - 1; // It will decrease from 17 to 0.
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 3; ++j) {
// Place bits in LSB (least significant bit) to MSB order.
bool bit = versionInfoBits.get(bitIndex);
bitIndex--;
// Left bottom corner.
matrix.set(i, matrix.height() - 11 + j, bit);
// Right bottom corner.
matrix.set(matrix.height() - 11 + j, i, bit);
}
}
}
// Embed "dataBits" using "getMaskPattern". On success, modify the matrix and return true.
// For debugging purposes, it skips masking process if "getMaskPattern" is -1.
// See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
static void EmbedDataBits(const BitArray& dataBits, int maskPattern, TritMatrix& matrix)
{
int bitIndex = 0;
int direction = -1;
// Start from the right bottom cell.
int x = matrix.width() - 1;
int y = matrix.height() - 1;
while (x > 0) {
// Skip the vertical timing pattern.
if (x == 6) {
x -= 1;
}
while (y >= 0 && y < matrix.height()) {
for (int xx = x; xx > x - 2; --xx) {
// Skip the cell if it's not empty.
if (!matrix.get(xx, y).isEmpty()) {
continue;
}
// Padding bit. If there is no bit left, we'll fill the left cells with 0, as described
// in 8.4.9 of JISX0510:2004 (p. 24).
bool bit = bitIndex < dataBits.size() ? dataBits.get(bitIndex) : false;
++bitIndex;
// Skip masking if mask_pattern is -1.
if (maskPattern != -1 && GetDataMaskBit(maskPattern, xx, y)) {
bit = !bit;
}
matrix.set(xx, y, bit);
}
y += direction;
}
direction = -direction; // Reverse the direction.
y += direction;
x -= 2; // Move to the left.
}
// All bits should be consumed.
if (bitIndex < dataBits.size()) {
throw std::invalid_argument("Not all bits consumed: " + std::to_string(bitIndex) + '/' + std::to_string(dataBits.size()));
}
}
// Build 2D matrix of QR Code from "dataBits" with "ecLevel", "version" and "getMaskPattern". On
// success, store the result in "matrix" and return true.
void BuildMatrix(const BitArray& dataBits, ErrorCorrectionLevel ecLevel, const Version& version, int maskPattern, TritMatrix& matrix)
{
matrix.clear();
// Let's get started with embedding big squares at corners.
EmbedPositionDetectionPatternsAndSeparators(matrix);
// Then, embed the dark dot at the left bottom corner.
EmbedDarkDotAtLeftBottomCorner(matrix);
// Position adjustment patterns appear if version >= 2.
EmbedPositionAdjustmentPatterns(version, matrix);
// Timing patterns should be embedded after position adj. patterns.
EmbedTimingPatterns(matrix);
// Type information appear with any version.
EmbedTypeInfo(ecLevel, maskPattern, matrix);
// Version info appear if version >= 7.
EmbedVersionInfo(version, matrix);
// Data should be embedded at end.
EmbedDataBits(dataBits, maskPattern, matrix);
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRMatrixUtil.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 3,364
|
```c++
/*
*/
#include "QRMaskUtil.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cstdlib>
#include <utility>
namespace ZXing::QRCode::MaskUtil {
// Penalty weights from section 6.8.2.1
static const int N1 = 3;
static const int N2 = 3;
static const int N3 = 40;
static const int N4 = 10;
/**
* Helper function for applyMaskPenaltyRule1. We need this for doing this calculation in both
* vertical and horizontal orders respectively.
*/
static int ApplyMaskPenaltyRule1Internal(const TritMatrix& matrix, bool isHorizontal)
{
int penalty = 0;
int width = matrix.width();
int height = matrix.height();
int iLimit = isHorizontal ? height : width;
int jLimit = isHorizontal ? width : height;
for (int i = 0; i < iLimit; i++) {
int numSameBitCells = 0;
int prevBit = -1;
for (int j = 0; j < jLimit; j++) {
int bit = isHorizontal ? matrix.get(j, i) : matrix.get(i, j);
if (bit == prevBit) {
numSameBitCells++;
}
else {
if (numSameBitCells >= 5) {
penalty += N1 + (numSameBitCells - 5);
}
numSameBitCells = 1; // Include the cell itself.
prevBit = bit;
}
}
if (numSameBitCells >= 5) {
penalty += N1 + (numSameBitCells - 5);
}
}
return penalty;
}
/**
* Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and
* give penalty to them. Example: 00000 or 11111.
*/
static int ApplyMaskPenaltyRule1(const TritMatrix& matrix)
{
return ApplyMaskPenaltyRule1Internal(matrix, true) + ApplyMaskPenaltyRule1Internal(matrix, false);
}
/**
* Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give
* penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a
* penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.
*/
static int ApplyMaskPenaltyRule2(const TritMatrix& matrix)
{
int penalty = 0;
for (int y = 0; y < matrix.height() - 1; y++) {
for (int x = 0; x < matrix.width() - 1; x++) {
auto value = matrix.get(x, y);
if (value == matrix.get(x+1, y) && value == matrix.get(x, y+1) && value == matrix.get(x+1, y+1)) {
penalty++;
}
}
}
return N2 * penalty;
}
template <size_t N>
static bool HasPatternAt(const std::array<bool, N>& pattern, const Trit* begin, int count, int stride)
{
assert(std::abs(count) <= (int)N);
auto end = begin + count * stride;
if (count < 0)
std::swap(begin, end);
auto a = begin;
for (auto b = pattern.begin(); a < end && b != pattern.end(); a += stride, ++b)
if (*a != *b)
return false;
return true;
}
/**
* Apply mask penalty rule 3 and return the penalty. Find consecutive runs of 1:1:3:1:1:4
* starting with black, or 4:1:1:3:1:1 starting with white, and give penalty to them. If we
* find patterns like 000010111010000, we give penalty once.
*/
static int ApplyMaskPenaltyRule3(const TritMatrix& matrix)
{
const std::array<bool, 4> white = {0, 0, 0, 0};
const std::array<bool, 7> finder = {1, 0, 1, 1, 1, 0, 1};
const int whiteSize = Size(white);
const int finderSize = Size(finder);
int numPenalties = 0;
int width = matrix.width();
int height = matrix.height();
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
auto i = &matrix.get(x, y);
if (x <= width - finderSize && HasPatternAt(finder, i, finderSize, 1)
&& (HasPatternAt(white, i, -std::min(x, whiteSize), 1)
|| HasPatternAt(white, i + finderSize, std::min(width - x - finderSize, whiteSize), 1))) {
numPenalties++;
}
if (y <= height - finderSize && HasPatternAt(finder, i, finderSize, width)
&& (HasPatternAt(white, i, -std::min(y, whiteSize), width)
|| HasPatternAt(white, i + finderSize * width, std::min(height - y - finderSize, whiteSize), width))) {
numPenalties++;
}
}
}
return numPenalties * N3;
}
/**
* Apply mask penalty rule 4 and return the penalty. Calculate the ratio of dark cells and give
* penalty if the ratio is far from 50%. It gives 10 penalty for 5% distance.
*/
static int ApplyMaskPenaltyRule4(const TritMatrix& matrix)
{
auto numDarkCells = std::count_if(matrix.begin(), matrix.end(), [](Trit cell) { return cell; });
auto numTotalCells = matrix.size();
auto fivePercentVariances = std::abs(numDarkCells * 2 - numTotalCells) * 10 / numTotalCells;
return narrow_cast<int>(fivePercentVariances * N4);
}
// The mask penalty calculation is complicated. See Table 21 of JISX0510:2004 (p.45) for details.
// Basically it applies four rules and summate all penalties.
int CalculateMaskPenalty(const TritMatrix& matrix)
{
return MaskUtil::ApplyMaskPenaltyRule1(matrix)
+ MaskUtil::ApplyMaskPenaltyRule2(matrix)
+ MaskUtil::ApplyMaskPenaltyRule3(matrix)
+ MaskUtil::ApplyMaskPenaltyRule4(matrix);
}
} // namespace ZXing::QRCode::MaskUtil
```
|
/content/code_sandbox/core/src/qrcode/QRMaskUtil.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,445
|
```objective-c
/*
*/
#pragma once
#include "TritMatrix.h"
namespace ZXing::QRCode::MaskUtil {
int CalculateMaskPenalty(const TritMatrix& matrix);
} // namespace ZXing::QRCode::MaskUtil
```
|
/content/code_sandbox/core/src/qrcode/QRMaskUtil.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 46
|
```objective-c
/*
*/
#pragma once
#include "BitMatrix.h"
#include "ByteArray.h"
#include "QRCodecMode.h"
#include "QRVersion.h"
namespace ZXing::QRCode {
/**
* @author satorux@google.com (Satoru Takabayashi) - creator
* @author dswitkin@google.com (Daniel Switkin) - ported from C++
*
* Original class name in Java was QRCode, as this name is taken already for the namespace,
* so it's renamed here EncodeResult.
*/
class EncodeResult
{
public:
ErrorCorrectionLevel ecLevel = ErrorCorrectionLevel::Invalid;
CodecMode mode = CodecMode::TERMINATOR;
const Version* version = nullptr;
int maskPattern = -1;
BitMatrix matrix;
};
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QREncodeResult.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 171
|
```objective-c
/*
*/
#pragma once
#include "CharacterSet.h"
#include <string>
namespace ZXing::QRCode {
enum class ErrorCorrectionLevel;
class EncodeResult;
EncodeResult Encode(const std::wstring& content, ErrorCorrectionLevel ecLevel, CharacterSet encoding, int versionNumber,
bool useGs1Format, int maskPattern = -1);
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QREncoder.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 79
|
```c++
/*
*/
#include "QRBitMatrixParser.h"
#include "BitArray.h"
#include "BitMatrix.h"
#include "ByteArray.h"
#include "QRDataMask.h"
#include "QRFormatInformation.h"
#include "QRVersion.h"
#include <utility>
namespace ZXing::QRCode {
static bool getBit(const BitMatrix& bitMatrix, int x, int y, bool mirrored = false)
{
return mirrored ? bitMatrix.get(y, x) : bitMatrix.get(x, y);
}
const Version* ReadVersion(const BitMatrix& bitMatrix, Type type)
{
assert(Version::HasValidSize(bitMatrix));
int number = Version::Number(bitMatrix);
switch (type) {
case Type::Micro: return Version::Micro(number);
case Type::rMQR: return Version::rMQR(number);
case Type::Model1: return Version::Model1(number);
case Type::Model2: return Version::Model2(number);
}
return nullptr;
}
FormatInformation ReadFormatInformation(const BitMatrix& bitMatrix)
{
if (Version::HasValidSize(bitMatrix, Type::Micro)) {
// Read top-left format info bits
int formatInfoBits = 0;
for (int x = 1; x < 9; x++)
AppendBit(formatInfoBits, getBit(bitMatrix, x, 8));
for (int y = 7; y >= 1; y--)
AppendBit(formatInfoBits, getBit(bitMatrix, 8, y));
return FormatInformation::DecodeMQR(formatInfoBits);
}
if (Version::HasValidSize(bitMatrix, Type::rMQR)) {
// Read top-left format info bits
uint32_t formatInfoBits1 = 0;
for (int y = 3; y >= 1; y--)
AppendBit(formatInfoBits1, getBit(bitMatrix, 11, y));
for (int x = 10; x >= 8; x--)
for (int y = 5; y >= 1; y--)
AppendBit(formatInfoBits1, getBit(bitMatrix, x, y));
// Read bottom-right format info bits
uint32_t formatInfoBits2 = 0;
const int width = bitMatrix.width();
const int height = bitMatrix.height();
for (int x = 3; x <= 5; x++)
AppendBit(formatInfoBits2, getBit(bitMatrix, width - x, height - 6));
for (int x = 6; x <= 8; x++)
for (int y = 2; y <= 6; y++)
AppendBit(formatInfoBits2, getBit(bitMatrix, width - x, height - y));
return FormatInformation::DecodeRMQR(formatInfoBits1, formatInfoBits2);
}
// Read top-left format info bits
int formatInfoBits1 = 0;
for (int x = 0; x < 6; x++)
AppendBit(formatInfoBits1, getBit(bitMatrix, x, 8));
// .. and skip a bit in the timing pattern ...
AppendBit(formatInfoBits1, getBit(bitMatrix, 7, 8));
AppendBit(formatInfoBits1, getBit(bitMatrix, 8, 8));
AppendBit(formatInfoBits1, getBit(bitMatrix, 8, 7));
// .. and skip a bit in the timing pattern ...
for (int y = 5; y >= 0; y--)
AppendBit(formatInfoBits1, getBit(bitMatrix, 8, y));
// Read the top-right/bottom-left pattern including the 'Dark Module' from the bottom-left
// part that has to be considered separately when looking for mirrored symbols.
// See also FormatInformation::DecodeQR
int dimension = bitMatrix.height();
int formatInfoBits2 = 0;
for (int y = dimension - 1; y >= dimension - 8; y--)
AppendBit(formatInfoBits2, getBit(bitMatrix, 8, y));
for (int x = dimension - 8; x < dimension; x++)
AppendBit(formatInfoBits2, getBit(bitMatrix, x, 8));
return FormatInformation::DecodeQR(formatInfoBits1, formatInfoBits2);
}
static ByteArray ReadQRCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
{
BitMatrix functionPattern = version.buildFunctionPattern();
ByteArray result;
result.reserve(version.totalCodewords());
uint8_t currentByte = 0;
bool readingUp = true;
int bitsRead = 0;
int dimension = bitMatrix.height();
// Read columns in pairs, from right to left
for (int x = dimension - 1; x > 0; x -= 2) {
// Skip whole column with vertical timing pattern.
if (x == 6)
x--;
// Read alternatingly from bottom to top then top to bottom
for (int row = 0; row < dimension; row++) {
int y = readingUp ? dimension - 1 - row : row;
for (int col = 0; col < 2; col++) {
int xx = x - col;
// Ignore bits covered by the function pattern
if (!functionPattern.get(xx, y)) {
// Read a bit
AppendBit(currentByte,
GetDataMaskBit(formatInfo.dataMask, xx, y) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
// If we've made a whole byte, save it off
if (++bitsRead % 8 == 0)
result.push_back(std::exchange(currentByte, 0));
}
}
}
readingUp = !readingUp; // switch directions
}
if (Size(result) != version.totalCodewords())
return {};
return result;
}
static ByteArray ReadQRCodewordsModel1(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
{
ByteArray result;
result.reserve(version.totalCodewords());
int dimension = bitMatrix.height();
int columns = dimension / 4 + 1 + 2;
for (int j = 0; j < columns; j++) {
if (j <= 1) { // vertical symbols on the right side
int rows = (dimension - 8) / 4;
for (int i = 0; i < rows; i++) {
if (j == 0 && i % 2 == 0 && i > 0 && i < rows - 1) // extension
continue;
int x = (dimension - 1) - (j * 2);
int y = (dimension - 1) - (i * 4);
uint8_t currentByte = 0;
for (int b = 0; b < 8; b++) {
AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 2, y - (b / 2))
!= getBit(bitMatrix, x - b % 2, y - (b / 2), formatInfo.isMirrored));
}
result.push_back(currentByte);
}
} else if (columns - j <= 4) { // vertical symbols on the left side
int rows = (dimension - 16) / 4;
for (int i = 0; i < rows; i++) {
int x = (columns - j - 1) * 2 + 1 + (columns - j == 4 ? 1 : 0); // timing
int y = (dimension - 1) - 8 - (i * 4);
uint8_t currentByte = 0;
for (int b = 0; b < 8; b++) {
AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 2, y - (b / 2))
!= getBit(bitMatrix, x - b % 2, y - (b / 2), formatInfo.isMirrored));
}
result.push_back(currentByte);
}
} else { // horizontal symbols
int rows = dimension / 2;
for (int i = 0; i < rows; i++) {
if (j == 2 && i >= rows - 4) // alignment & finder
continue;
if (i == 0 && j % 2 == 1 && j + 1 != columns - 4) // extension
continue;
int x = (dimension - 1) - (2 * 2) - (j - 2) * 4;
int y = (dimension - 1) - (i * 2) - (i >= rows - 3 ? 1 : 0); // timing
uint8_t currentByte = 0;
for (int b = 0; b < 8; b++) {
AppendBit(currentByte, GetDataMaskBit(formatInfo.dataMask, x - b % 4, y - (b / 4))
!= getBit(bitMatrix, x - b % 4, y - (b / 4), formatInfo.isMirrored));
}
result.push_back(currentByte);
}
}
}
result[0] &= 0xf; // ignore corner
if (Size(result) != version.totalCodewords())
return {};
return result;
}
static ByteArray ReadMQRCodewords(const BitMatrix& bitMatrix, const QRCode::Version& version, const FormatInformation& formatInfo)
{
BitMatrix functionPattern = version.buildFunctionPattern();
// D3 in a Version M1 symbol, D11 in a Version M3-L symbol and D9
// in a Version M3-M symbol is a 2x2 square 4-module block.
// See ISO 18004:2006 6.7.3.
bool hasD4mBlock = version.versionNumber() % 2 == 1;
int d4mBlockIndex =
version.versionNumber() == 1 ? 3 : (formatInfo.ecLevel == QRCode::ErrorCorrectionLevel::Low ? 11 : 9);
ByteArray result;
result.reserve(version.totalCodewords());
uint8_t currentByte = 0;
bool readingUp = true;
int bitsRead = 0;
int dimension = bitMatrix.height();
// Read columns in pairs, from right to left
for (int x = dimension - 1; x > 0; x -= 2) {
// Read alternatingly from bottom to top then top to bottom
for (int row = 0; row < dimension; row++) {
int y = readingUp ? dimension - 1 - row : row;
for (int col = 0; col < 2; col++) {
int xx = x - col;
// Ignore bits covered by the function pattern
if (!functionPattern.get(xx, y)) {
// Read a bit
AppendBit(currentByte,
GetDataMaskBit(formatInfo.dataMask, xx, y, true) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
++bitsRead;
// If we've made a whole byte, save it off; save early if 2x2 data block.
if (bitsRead == 8 || (bitsRead == 4 && hasD4mBlock && Size(result) == d4mBlockIndex - 1)) {
result.push_back(std::exchange(currentByte, 0));
bitsRead = 0;
}
}
}
}
readingUp = !readingUp; // switch directions
}
if (Size(result) != version.totalCodewords())
return {};
return result;
}
static ByteArray ReadRMQRCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
{
BitMatrix functionPattern = version.buildFunctionPattern();
ByteArray result;
result.reserve(version.totalCodewords());
uint8_t currentByte = 0;
bool readingUp = true;
int bitsRead = 0;
const int width = bitMatrix.width();
const int height = bitMatrix.height();
// Read columns in pairs, from right to left
for (int x = width - 1 - 1; x > 0; x -= 2) { // Skip right edge alignment
// Read alternatingly from bottom to top then top to bottom
for (int row = 0; row < height; row++) {
int y = readingUp ? height - 1 - row : row;
for (int col = 0; col < 2; col++) {
int xx = x - col;
// Ignore bits covered by the function pattern
if (!functionPattern.get(xx, y)) {
// Read a bit
AppendBit(currentByte,
GetDataMaskBit(formatInfo.dataMask, xx, y) != getBit(bitMatrix, xx, y, formatInfo.isMirrored));
// If we've made a whole byte, save it off
if (++bitsRead % 8 == 0)
result.push_back(std::exchange(currentByte, 0));
}
}
}
readingUp = !readingUp; // switch directions
}
if (Size(result) != version.totalCodewords())
return {};
return result;
}
ByteArray ReadCodewords(const BitMatrix& bitMatrix, const Version& version, const FormatInformation& formatInfo)
{
switch (version.type()) {
case Type::Micro: return ReadMQRCodewords(bitMatrix, version, formatInfo);
case Type::rMQR: return ReadRMQRCodewords(bitMatrix, version, formatInfo);
case Type::Model1: return ReadQRCodewordsModel1(bitMatrix, version, formatInfo);
case Type::Model2: return ReadQRCodewords(bitMatrix, version, formatInfo);
}
return {};
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRBitMatrixParser.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 3,059
|
```c++
/*
*/
#include "QRDetector.h"
#include "BitArray.h"
#include "BitMatrix.h"
#include "BitMatrixCursor.h"
#include "ConcentricFinder.h"
#include "GridSampler.h"
#include "LogMatrix.h"
#include "Pattern.h"
#include "QRFormatInformation.h"
#include "QRVersion.h"
#include "Quadrilateral.h"
#include "RegressionLine.h"
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iterator>
#include <map>
#include <utility>
#include <vector>
#ifdef PRINT_DEBUG
#include "BitMatrixIO.h"
#else
#define printf(...){}
#endif
namespace ZXing::QRCode {
constexpr auto PATTERN = FixedPattern<5, 7>{1, 1, 3, 1, 1};
constexpr bool E2E = true;
PatternView FindPattern(const PatternView& view)
{
return FindLeftGuard<PATTERN.size()>(view, PATTERN.size(), [](const PatternView& view, int spaceInPixel) {
// perform a fast plausability test for 1:1:3:1:1 pattern
if (view[2] < 2 * std::max(view[0], view[4]) || view[2] < std::max(view[1], view[3]))
return 0.;
return IsPattern<E2E>(view, PATTERN, spaceInPixel, 0.1); // the requires 4, here we accept almost 0
});
}
std::vector<ConcentricPattern> FindFinderPatterns(const BitMatrix& image, bool tryHarder)
{
constexpr int MIN_SKIP = 3; // 1 pixel/module times 3 modules/center
constexpr int MAX_MODULES_FAST = 20 * 4 + 17; // support up to version 20 for mobile clients
// Let's assume that the maximum version QR Code we support takes up 1/4 the height of the
// image, and then account for the center being 3 modules in size. This gives the smallest
// number of pixels the center could be, so skip this often. When trying harder, look for all
// QR versions regardless of how dense they are.
int height = image.height();
int skip = (3 * height) / (4 * MAX_MODULES_FAST);
if (skip < MIN_SKIP || tryHarder)
skip = MIN_SKIP;
std::vector<ConcentricPattern> res;
[[maybe_unused]] int N = 0;
PatternRow row;
for (int y = skip - 1; y < height; y += skip) {
GetPatternRow(image, y, row, false);
PatternView next = row;
while (next = FindPattern(next), next.isValid()) {
PointF p(next.pixelsInFront() + next[0] + next[1] + next[2] / 2.0, y + 0.5);
// make sure p is not 'inside' an already found pattern area
if (FindIf(res, [p](const auto& old) { return distance(p, old) < old.size / 2; }) == res.end()) {
log(p);
N++;
auto pattern = LocateConcentricPattern<E2E>(image, PATTERN, p,
next.sum() * 3); // 3 for very skewed samples
if (pattern) {
log(*pattern, 3);
log(*pattern + PointF(.2, 0), 3);
log(*pattern - PointF(.2, 0), 3);
log(*pattern + PointF(0, .2), 3);
log(*pattern - PointF(0, .2), 3);
assert(image.get(pattern->x, pattern->y));
res.push_back(*pattern);
}
}
next.skipPair();
next.skipPair();
next.extend();
}
}
printf("FPs? : %d\n", N);
return res;
}
/**
* @brief GenerateFinderPatternSets
* @param patterns list of ConcentricPattern objects, i.e. found finder pattern squares
* @return list of plausible finder pattern sets, sorted by decreasing plausibility
*/
FinderPatternSets GenerateFinderPatternSets(FinderPatterns& patterns)
{
std::sort(patterns.begin(), patterns.end(), [](const auto& a, const auto& b) { return a.size < b.size; });
auto sets = std::multimap<double, FinderPatternSet>();
auto squaredDistance = [](const auto* a, const auto* b) {
// The scaling of the distance by the b/a size ratio is a very coarse compensation for the shortening effect of
// the camera projection on slanted symbols. The fact that the size of the finder pattern is proportional to the
// distance from the camera is used here. This approximation only works if a < b < 2*a (see below).
// Test image: fix-finderpattern-order.jpg
return dot((*a - *b), (*a - *b)) * std::pow(double(b->size) / a->size, 2);
};
const double cosUpper = std::cos(45. / 180 * 3.1415); // TODO: use c++20 std::numbers::pi_v
const double cosLower = std::cos(135. / 180 * 3.1415);
int nbPatterns = Size(patterns);
for (int i = 0; i < nbPatterns - 2; i++) {
for (int j = i + 1; j < nbPatterns - 1; j++) {
for (int k = j + 1; k < nbPatterns - 0; k++) {
const auto* a = &patterns[i];
const auto* b = &patterns[j];
const auto* c = &patterns[k];
// if the pattern sizes are too different to be part of the same symbol, skip this
// and the rest of the innermost loop (sorted list)
if (c->size > a->size * 2)
break;
// Orders the three points in an order [A,B,C] such that AB is less than AC
// and BC is less than AC, and the angle between BC and BA is less than 180 degrees.
auto distAB2 = squaredDistance(a, b);
auto distBC2 = squaredDistance(b, c);
auto distAC2 = squaredDistance(a, c);
if (distBC2 >= distAB2 && distBC2 >= distAC2) {
std::swap(a, b);
std::swap(distBC2, distAC2);
} else if (distAB2 >= distAC2 && distAB2 >= distBC2) {
std::swap(b, c);
std::swap(distAB2, distAC2);
}
auto distAB = std::sqrt(distAB2);
auto distBC = std::sqrt(distBC2);
// Make sure distAB and distBC don't differ more than reasonable
// TODO: make sure the constant 2 is not to conservative for reasonably tilted symbols
if (distAB > 2 * distBC || distBC > 2 * distAB)
continue;
// Estimate the module count and ignore this set if it can not result in a valid decoding
if (auto moduleCount = (distAB + distBC) / (2 * (a->size + b->size + c->size) / (3 * 7.f)) + 7;
moduleCount < 21 * 0.9 || moduleCount > 177 * 1.5) // moduleCount may be overestimated, see above
continue;
// Make sure the angle between AB and BC does not deviate from 90 by more than 45
auto cosAB_BC = (distAB2 + distBC2 - distAC2) / (2 * distAB * distBC);
if (std::isnan(cosAB_BC) || cosAB_BC > cosUpper || cosAB_BC < cosLower)
continue;
// a^2 + b^2 = c^2 (Pythagorean theorem), and a = b (isosceles triangle).
// Since any right triangle satisfies the formula c^2 - b^2 - a^2 = 0,
// we need to check both two equal sides separately.
// The value of |c^2 - 2 * b^2| + |c^2 - 2 * a^2| increases as dissimilarity
// from isosceles right triangle.
double d = (std::abs(distAC2 - 2 * distAB2) + std::abs(distAC2 - 2 * distBC2));
// Use cross product to figure out whether A and C are correct or flipped.
// This asks whether BC x BA has a positive z component, which is the arrangement
// we want for A, B, C. If it's negative then swap A and C.
if (cross(*c - *b, *a - *b) < 0)
std::swap(a, c);
// arbitrarily limit the number of potential sets
// (this has performance implications while limiting the maximal number of detected symbols)
const auto setSizeLimit = 256;
if (sets.size() < setSizeLimit || sets.crbegin()->first > d) {
sets.emplace(d, FinderPatternSet{*a, *b, *c});
if (sets.size() > setSizeLimit)
sets.erase(std::prev(sets.end()));
}
}
}
}
// convert from multimap to vector
FinderPatternSets res;
res.reserve(sets.size());
for (auto& [d, s] : sets)
res.push_back(s);
printf("FPSets: %d\n", Size(res));
return res;
}
static double EstimateModuleSize(const BitMatrix& image, ConcentricPattern a, ConcentricPattern b)
{
BitMatrixCursorF cur(image, a, b - a);
assert(cur.isBlack());
auto pattern = ReadSymmetricPattern<5>(cur, a.size * 2);
if (!pattern || !IsPattern<true>(*pattern, PATTERN))
return -1;
return (2 * Reduce(*pattern) - (*pattern)[0] - (*pattern)[4]) / 12.0 * length(cur.d);
}
struct DimensionEstimate
{
int dim = 0;
double ms = 0;
int err = 4;
};
static DimensionEstimate EstimateDimension(const BitMatrix& image, ConcentricPattern a, ConcentricPattern b)
{
auto ms_a = EstimateModuleSize(image, a, b);
auto ms_b = EstimateModuleSize(image, b, a);
if (ms_a < 0 || ms_b < 0)
return {};
auto moduleSize = (ms_a + ms_b) / 2;
int dimension = narrow_cast<int>(std::lround(distance(a, b) / moduleSize) + 7);
int error = 1 - (dimension % 4);
return {dimension + error, moduleSize, std::abs(error)};
}
static RegressionLine TraceLine(const BitMatrix& image, PointF p, PointF d, int edge)
{
BitMatrixCursorF cur(image, p, d - p);
RegressionLine line;
line.setDirectionInward(cur.back());
// collect points inside the black line -> backup on 3rd edge
cur.stepToEdge(edge, 0, edge == 3);
if (edge == 3)
cur.turnBack();
auto curI = BitMatrixCursorI(image, PointI(cur.p), PointI(mainDirection(cur.d)));
// make sure curI positioned such that the white->black edge is directly behind
// Test image: fix-traceline.jpg
while (!curI.edgeAtBack()) {
if (curI.edgeAtLeft())
curI.turnRight();
else if (curI.edgeAtRight())
curI.turnLeft();
else
curI.step(-1);
}
for (auto dir : {Direction::LEFT, Direction::RIGHT}) {
auto c = BitMatrixCursorI(image, curI.p, curI.direction(dir));
auto stepCount = static_cast<int>(maxAbsComponent(cur.p - p));
do {
line.add(centered(c.p));
} while (--stepCount > 0 && c.stepAlongEdge(dir, true));
}
line.evaluate(1.0, true);
for (auto p : line.points())
log(p, 2);
return line;
}
// estimate how tilted the symbol is (return value between 1 and 2, see also above)
static double EstimateTilt(const FinderPatternSet& fp)
{
int min = std::min({fp.bl.size, fp.tl.size, fp.tr.size});
int max = std::max({fp.bl.size, fp.tl.size, fp.tr.size});
return double(max) / min;
}
static PerspectiveTransform Mod2Pix(int dimension, PointF brOffset, QuadrilateralF pix)
{
auto quad = Rectangle(dimension, dimension, 3.5);
quad[2] = quad[2] - brOffset;
return {quad, pix};
}
static std::optional<PointF> LocateAlignmentPattern(const BitMatrix& image, int moduleSize, PointF estimate)
{
log(estimate, 4);
for (auto d : {PointF{0, 0}, {0, -1}, {0, 1}, {-1, 0}, {1, 0}, {-1, -1}, {1, -1}, {1, 1}, {-1, 1},
#if 1
}) {
#else
{0, -2}, {0, 2}, {-2, 0}, {2, 0}, {-1, -2}, {1, -2}, {-1, 2}, {1, 2}, {-2, -1}, {-2, 1}, {2, -1}, {2, 1}}) {
#endif
auto cor = CenterOfRing(image, PointI(estimate + moduleSize * 2.25 * d), moduleSize * 3, 1, false);
// if we did not land on a black pixel the concentric pattern finder will fail
if (!cor || !image.get(*cor))
continue;
if (auto cor1 = CenterOfRing(image, PointI(*cor), moduleSize, 1))
if (auto cor2 = CenterOfRing(image, PointI(*cor), moduleSize * 3, -2))
if (distance(*cor1, *cor2) < moduleSize / 2) {
auto res = (*cor1 + *cor2) / 2;
log(res, 3);
return res;
}
}
return {};
}
static const Version* ReadVersion(const BitMatrix& image, int dimension, const PerspectiveTransform& mod2Pix)
{
int bits[2] = {};
for (bool mirror : {false, true}) {
// Read top-right/bottom-left version info: 3 wide by 6 tall (depending on mirrored)
int versionBits = 0;
for (int y = 5; y >= 0; --y)
for (int x = dimension - 9; x >= dimension - 11; --x) {
auto mod = mirror ? PointI{y, x} : PointI{x, y};
auto pix = mod2Pix(centered(mod));
if (!image.isIn(pix))
versionBits = -1;
else
AppendBit(versionBits, image.get(pix));
log(pix, 3);
}
bits[static_cast<int>(mirror)] = versionBits;
}
return Version::DecodeVersionInformation(bits[0], bits[1]);
}
DetectorResult SampleQR(const BitMatrix& image, const FinderPatternSet& fp)
{
auto top = EstimateDimension(image, fp.tl, fp.tr);
auto left = EstimateDimension(image, fp.tl, fp.bl);
if (!top.dim && !left.dim)
return {};
auto best = top.err == left.err ? (top.dim > left.dim ? top : left) : (top.err < left.err ? top : left);
int dimension = best.dim;
int moduleSize = static_cast<int>(best.ms + 1);
auto br = PointF{-1, -1};
auto brOffset = PointF{3, 3};
// Everything except version 1 (21 modules) has an alignment pattern. Estimate the center of that by intersecting
// line extensions of the 1 module wide square around the finder patterns. This could also help with detecting
// slanted symbols of version 1.
// generate 4 lines: outer and inner edge of the 1 module wide black line between the two outer and the inner
// (tl) finder pattern
auto bl2 = TraceLine(image, fp.bl, fp.tl, 2);
auto bl3 = TraceLine(image, fp.bl, fp.tl, 3);
auto tr2 = TraceLine(image, fp.tr, fp.tl, 2);
auto tr3 = TraceLine(image, fp.tr, fp.tl, 3);
if (bl2.isValid() && tr2.isValid() && bl3.isValid() && tr3.isValid()) {
// intersect both outer and inner line pairs and take the center point between the two intersection points
auto brInter = (intersect(bl2, tr2) + intersect(bl3, tr3)) / 2;
log(brInter, 3);
if (dimension > 21)
if (auto brCP = LocateAlignmentPattern(image, moduleSize, brInter))
br = *brCP;
// if the symbol is tilted or the resolution of the RegressionLines is sufficient, use their intersection
// as the best estimate (see discussion in #199 and test image estimate-tilt.jpg )
if (!image.isIn(br) && (EstimateTilt(fp) > 1.1 || (bl2.isHighRes() && bl3.isHighRes() && tr2.isHighRes() && tr3.isHighRes())))
br = brInter;
}
// otherwise the simple estimation used by upstream is used as a best guess fallback
if (!image.isIn(br)) {
br = fp.tr - fp.tl + fp.bl;
brOffset = PointF(0, 0);
}
log(br, 3);
auto mod2Pix = Mod2Pix(dimension, brOffset, {fp.tl, fp.tr, br, fp.bl});
if( dimension >= Version::SymbolSize(7, Type::Model2).x) {
auto version = ReadVersion(image, dimension, mod2Pix);
// if the version bits are garbage -> discard the detection
if (!version || std::abs(version->dimension() - dimension) > 8)
return DetectorResult();
if (version->dimension() != dimension) {
printf("update dimension: %d -> %d\n", dimension, version->dimension());
dimension = version->dimension();
mod2Pix = Mod2Pix(dimension, brOffset, {fp.tl, fp.tr, br, fp.bl});
}
#if 1
auto& apM = version->alignmentPatternCenters(); // alignment pattern positions in modules
auto apP = Matrix<std::optional<PointF>>(Size(apM), Size(apM)); // found/guessed alignment pattern positions in pixels
const int N = Size(apM) - 1;
// project the alignment pattern at module coordinates x/y to pixel coordinate based on current mod2Pix
auto projectM2P = [&mod2Pix, &apM](int x, int y) { return mod2Pix(centered(PointI(apM[x], apM[y]))); };
auto findInnerCornerOfConcentricPattern = [&image, &apP, &projectM2P](int x, int y, const ConcentricPattern& fp) {
auto pc = *apP.set(x, y, projectM2P(x, y));
if (auto fpQuad = FindConcentricPatternCorners(image, fp, fp.size, 2))
for (auto c : *fpQuad)
if (distance(c, pc) < fp.size / 2)
apP.set(x, y, c);
};
findInnerCornerOfConcentricPattern(0, 0, fp.tl);
findInnerCornerOfConcentricPattern(0, N, fp.bl);
findInnerCornerOfConcentricPattern(N, 0, fp.tr);
auto bestGuessAPP = [&](int x, int y){
if (auto p = apP(x, y))
return *p;
return projectM2P(x, y);
};
for (int y = 0; y <= N; ++y)
for (int x = 0; x <= N; ++x) {
if (apP(x, y))
continue;
PointF guessed =
x * y == 0 ? bestGuessAPP(x, y) : bestGuessAPP(x - 1, y) + bestGuessAPP(x, y - 1) - bestGuessAPP(x - 1, y - 1);
if (auto found = LocateAlignmentPattern(image, moduleSize, guessed))
apP.set(x, y, *found);
}
// go over the whole set of alignment patters again and try to fill any remaining gap by using available neighbors as guides
for (int y = 0; y <= N; ++y)
for (int x = 0; x <= N; ++x) {
if (apP(x, y))
continue;
// find the two closest valid alignment pattern pixel positions both horizontally and vertically
std::vector<PointF> hori, verti;
for (int i = 2; i < 2 * N + 2 && Size(hori) < 2; ++i) {
int xi = x + i / 2 * (i%2 ? 1 : -1);
if (0 <= xi && xi <= N && apP(xi, y))
hori.push_back(*apP(xi, y));
}
for (int i = 2; i < 2 * N + 2 && Size(verti) < 2; ++i) {
int yi = y + i / 2 * (i%2 ? 1 : -1);
if (0 <= yi && yi <= N && apP(x, yi))
verti.push_back(*apP(x, yi));
}
// if we found 2 each, intersect the two lines that are formed by connecting the point pairs
if (Size(hori) == 2 && Size(verti) == 2) {
auto guessed = intersect(RegressionLine(hori[0], hori[1]), RegressionLine(verti[0], verti[1]));
auto found = LocateAlignmentPattern(image, moduleSize, guessed);
// search again near that intersection and if the search fails, use the intersection
if (!found) printf("location guessed at %dx%d\n", x, y);
apP.set(x, y, found ? *found : guessed);
}
}
if (auto c = apP.get(N, N))
mod2Pix = Mod2Pix(dimension, PointF(3, 3), {fp.tl, fp.tr, *c, fp.bl});
// go over the whole set of alignment patters again and fill any remaining gaps by a projection based on an updated mod2Pix
// projection. This works if the symbol is flat, wich is a reasonable fall-back assumption.
for (int y = 0; y <= N; ++y)
for (int x = 0; x <= N; ++x) {
if (apP(x, y))
continue;
printf("locate failed at %dx%d\n", x, y);
apP.set(x, y, projectM2P(x, y));
}
#ifdef PRINT_DEBUG
for (int y = 0; y <= N; ++y)
for (int x = 0; x <= N; ++x)
log(*apP(x, y), 2);
#endif
// assemble a list of region-of-interests based on the found alignment pattern pixel positions
ROIs rois;
for (int y = 0; y < N; ++y)
for (int x = 0; x < N; ++x) {
int x0 = apM[x], x1 = apM[x + 1], y0 = apM[y], y1 = apM[y + 1];
rois.push_back({x0 - (x == 0) * 6, x1 + (x == N - 1) * 7, y0 - (y == 0) * 6, y1 + (y == N - 1) * 7,
PerspectiveTransform{Rectangle(x0, x1, y0, y1),
{*apP(x, y), *apP(x + 1, y), *apP(x + 1, y + 1), *apP(x, y + 1)}}});
}
return SampleGrid(image, dimension, dimension, rois);
#endif
}
return SampleGrid(image, dimension, dimension, mod2Pix);
}
/**
* This method detects a code in a "pure" image -- that is, pure monochrome image
* which contains only an unrotated, unskewed, image of a code, with some white border
* around it. This is a specialized method that works exceptionally fast in this special
* case.
*/
DetectorResult DetectPureQR(const BitMatrix& image)
{
using Pattern = std::array<PatternView::value_type, PATTERN.size()>;
#ifdef PRINT_DEBUG
SaveAsPBM(image, "weg.pbm");
#endif
constexpr int MIN_MODULES = Version::SymbolSize(1, Type::Model2).x;
int left, top, width, height;
if (!image.findBoundingBox(left, top, width, height, MIN_MODULES) || std::abs(width - height) > 1)
return {};
int right = left + width - 1;
int bottom = top + height - 1;
PointI tl{left, top}, tr{right, top}, bl{left, bottom};
Pattern diagonal;
// allow corners be moved one pixel inside to accommodate for possible aliasing artifacts
for (auto [p, d] : {std::pair(tl, PointI{1, 1}), {tr, {-1, 1}}, {bl, {1, -1}}}) {
diagonal = BitMatrixCursorI(image, p, d).readPatternFromBlack<Pattern>(1, width / 3 + 1);
if (!IsPattern(diagonal, PATTERN))
return {};
}
auto fpWidth = Reduce(diagonal);
auto dimension =
EstimateDimension(image, {tl + fpWidth / 2 * PointF(1, 1), fpWidth}, {tr + fpWidth / 2 * PointF(-1, 1), fpWidth}).dim;
float moduleSize = float(width) / dimension;
if (!Version::IsValidSize({dimension, dimension}, Type::Model2) ||
!image.isIn(PointF{left + moduleSize / 2 + (dimension - 1) * moduleSize,
top + moduleSize / 2 + (dimension - 1) * moduleSize}))
return {};
#ifdef PRINT_DEBUG
LogMatrix log;
LogMatrixWriter lmw(log, image, 5, "grid2.pnm");
for (int y = 0; y < dimension; y++)
for (int x = 0; x < dimension; x++)
log(PointF(left + (x + .5f) * moduleSize, top + (y + .5f) * moduleSize));
#endif
// Now just read off the bits (this is a crop + subsample)
return {Deflate(image, dimension, dimension, top + moduleSize / 2, left + moduleSize / 2, moduleSize),
{{left, top}, {right, top}, {right, bottom}, {left, bottom}}};
}
DetectorResult DetectPureMQR(const BitMatrix& image)
{
using Pattern = std::array<PatternView::value_type, PATTERN.size()>;
constexpr int MIN_MODULES = Version::SymbolSize(1, Type::Micro).x;
int left, top, width, height;
if (!image.findBoundingBox(left, top, width, height, MIN_MODULES) || std::abs(width - height) > 1)
return {};
int right = left + width - 1;
int bottom = top + height - 1;
// allow corners be moved one pixel inside to accommodate for possible aliasing artifacts
auto diagonal = BitMatrixCursorI(image, {left, top}, {1, 1}).readPatternFromBlack<Pattern>(1);
if (!IsPattern(diagonal, PATTERN))
return {};
auto fpWidth = Reduce(diagonal);
float moduleSize = float(fpWidth) / 7;
int dimension = narrow_cast<int>(std::lround(width / moduleSize));
if (!Version::IsValidSize({dimension, dimension}, Type::Micro) ||
!image.isIn(PointF{left + moduleSize / 2 + (dimension - 1) * moduleSize,
top + moduleSize / 2 + (dimension - 1) * moduleSize}))
return {};
#ifdef PRINT_DEBUG
LogMatrix log;
LogMatrixWriter lmw(log, image, 5, "grid2.pnm");
for (int y = 0; y < dimension; y++)
for (int x = 0; x < dimension; x++)
log(PointF(left + (x + .5f) * moduleSize, top + (y + .5f) * moduleSize));
#endif
// Now just read off the bits (this is a crop + subsample)
return {Deflate(image, dimension, dimension, top + moduleSize / 2, left + moduleSize / 2, moduleSize),
{{left, top}, {right, top}, {right, bottom}, {left, bottom}}};
}
DetectorResult DetectPureRMQR(const BitMatrix& image)
{
constexpr auto SUBPATTERN = FixedPattern<4, 4>{1, 1, 1, 1};
constexpr auto TIMINGPATTERN = FixedPattern<10, 10>{1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
using Pattern = std::array<PatternView::value_type, PATTERN.size()>;
using SubPattern = std::array<PatternView::value_type, SUBPATTERN.size()>;
using TimingPattern = std::array<PatternView::value_type, TIMINGPATTERN.size()>;
#ifdef PRINT_DEBUG
SaveAsPBM(image, "weg.pbm");
#endif
constexpr int MIN_MODULES = Version::SymbolSize(1, Type::rMQR).y;
int left, top, width, height;
if (!image.findBoundingBox(left, top, width, height, MIN_MODULES) || height >= width)
return {};
int right = left + width - 1;
int bottom = top + height - 1;
PointI tl{left, top}, tr{right, top}, br{right, bottom}, bl{left, bottom};
// allow corners be moved one pixel inside to accommodate for possible aliasing artifacts
auto diagonal = BitMatrixCursorI(image, tl, {1, 1}).readPatternFromBlack<Pattern>(1);
if (!IsPattern(diagonal, PATTERN))
return {};
// Finder sub pattern
auto subdiagonal = BitMatrixCursorI(image, br, {-1, -1}).readPatternFromBlack<SubPattern>(1);
if (!IsPattern(subdiagonal, SUBPATTERN))
return {};
float moduleSize = Reduce(diagonal) + Reduce(subdiagonal);
// Horizontal timing patterns
for (auto [p, d] : {std::pair(tr, PointI{-1, 0}), {bl, {1, 0}}, {tl, {1, 0}}, {br, {-1, 0}}}) {
auto cur = BitMatrixCursorI(image, p, d);
// skip corner / finder / sub pattern edge
cur.stepToEdge(2 + cur.isWhite());
auto timing = cur.readPattern<TimingPattern>();
if (!IsPattern(timing, TIMINGPATTERN))
return {};
moduleSize += Reduce(timing);
}
moduleSize /= 7 + 4 + 4 * 10; // fp + sub + 4 x timing
int dimW = narrow_cast<int>(std::lround(width / moduleSize));
int dimH = narrow_cast<int>(std::lround(height / moduleSize));
if (!Version::IsValidSize(PointI{dimW, dimH}, Type::rMQR))
return {};
#ifdef PRINT_DEBUG
LogMatrix log;
LogMatrixWriter lmw(log, image, 5, "grid2.pnm");
for (int y = 0; y < dimH; y++)
for (int x = 0; x < dimW; x++)
log(PointF(left + (x + .5f) * moduleSize, top + (y + .5f) * moduleSize));
#endif
// Now just read off the bits (this is a crop + subsample)
return {Deflate(image, dimW, dimH, top + moduleSize / 2, left + moduleSize / 2, moduleSize), {tl, tr, br, bl}};
}
DetectorResult SampleMQR(const BitMatrix& image, const ConcentricPattern& fp)
{
auto fpQuad = FindConcentricPatternCorners(image, fp, fp.size, 2);
if (!fpQuad)
return {};
auto srcQuad = Rectangle(7, 7, 0.5);
#if defined(_MSVC_LANG) // TODO: see MSVC issue path_to_url
static
#else
constexpr
#endif
const PointI FORMAT_INFO_COORDS[] = {{0, 8}, {1, 8}, {2, 8}, {3, 8}, {4, 8}, {5, 8}, {6, 8}, {7, 8}, {8, 8},
{8, 7}, {8, 6}, {8, 5}, {8, 4}, {8, 3}, {8, 2}, {8, 1}, {8, 0}};
FormatInformation bestFI;
PerspectiveTransform bestPT;
BitMatrixCursorF cur(image, {}, {});
for (int i = 0; i < 4; ++i) {
auto mod2Pix = PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, i));
auto check = [&](int i, bool checkOne) {
auto p = mod2Pix(centered(FORMAT_INFO_COORDS[i]));
return image.isIn(p) && (!checkOne || image.get(p));
};
// check that we see both innermost timing pattern modules
if (!check(0, true) || !check(8, false) || !check(16, true))
continue;
int formatInfoBits = 0;
for (int i = 1; i <= 15; ++i)
AppendBit(formatInfoBits, cur.blackAt(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
auto fi = FormatInformation::DecodeMQR(formatInfoBits);
if (fi.hammingDistance < bestFI.hammingDistance) {
bestFI = fi;
bestPT = mod2Pix;
}
}
if (!bestFI.isValid())
return {};
const int dim = Version::SymbolSize(bestFI.microVersion, Type::Micro).x;
// check that we are in fact not looking at a corner of a non-micro QRCode symbol
// we accept at most 1/3rd black pixels in the quite zone (in a QRCode symbol we expect about 1/2).
int blackPixels = 0;
for (int i = 0; i < dim; ++i) {
auto px = bestPT(centered(PointI{i, dim}));
auto py = bestPT(centered(PointI{dim, i}));
blackPixels += cur.blackAt(px) && cur.blackAt(py);
}
if (blackPixels > 2 * dim / 3)
return {};
return SampleGrid(image, dim, dim, bestPT);
}
DetectorResult SampleRMQR(const BitMatrix& image, const ConcentricPattern& fp)
{
auto fpQuad = FindConcentricPatternCorners(image, fp, fp.size, 2);
if (!fpQuad)
return {};
auto srcQuad = Rectangle(7, 7, 0.5);
static const PointI FORMAT_INFO_EDGE_COORDS[] = {{8, 0}, {9, 0}, {10, 0}, {11, 0}};
static const PointI FORMAT_INFO_COORDS[] = {
{11, 3}, {11, 2}, {11, 1},
{10, 5}, {10, 4}, {10, 3}, {10, 2}, {10, 1},
{ 9, 5}, { 9, 4}, { 9, 3}, { 9, 2}, { 9, 1},
{ 8, 5}, { 8, 4}, { 8, 3}, { 8, 2}, { 8, 1},
};
FormatInformation bestFI;
PerspectiveTransform bestPT;
BitMatrixCursorF cur(image, {}, {});
for (int i = 0; i < 4; ++i) {
auto mod2Pix = PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, i));
auto check = [&](int i, bool on) {
return cur.testAt(mod2Pix(centered(FORMAT_INFO_EDGE_COORDS[i]))) == BitMatrixCursorF::Value(on);
};
// check that we see top edge timing pattern modules
if (!check(0, true) || !check(1, false) || !check(2, true) || !check(3, false))
continue;
uint32_t formatInfoBits = 0;
for (int i = 0; i < Size(FORMAT_INFO_COORDS); ++i)
AppendBit(formatInfoBits, cur.blackAt(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
auto fi = FormatInformation::DecodeRMQR(formatInfoBits, 0 /*formatInfoBits2*/);
if (fi.hammingDistance < bestFI.hammingDistance) {
bestFI = fi;
bestPT = mod2Pix;
}
}
if (!bestFI.isValid())
return {};
const PointI dim = Version::SymbolSize(bestFI.microVersion, Type::rMQR);
// TODO: this is a WIP
auto intersectQuads = [](QuadrilateralF& a, QuadrilateralF& b) {
auto tl = Center(a);
auto br = Center(b);
// rotate points such that topLeft of a is furthest away from b and topLeft of b is closest to a
auto dist2B = [c = br](auto a, auto b) { return distance(a, c) < distance(b, c); };
auto offsetA = narrow_cast<int>(std::max_element(a.begin(), a.end(), dist2B) - a.begin());
auto dist2A = [c = tl](auto a, auto b) { return distance(a, c) < distance(b, c); };
auto offsetB = narrow_cast<int>(std::min_element(b.begin(), b.end(), dist2A) - b.begin());
a = RotatedCorners(a, offsetA);
b = RotatedCorners(b, offsetB);
auto tr = (intersect(RegressionLine(a[0], a[1]), RegressionLine(b[1], b[2]))
+ intersect(RegressionLine(a[3], a[2]), RegressionLine(b[0], b[3])))
/ 2;
auto bl = (intersect(RegressionLine(a[0], a[3]), RegressionLine(b[2], b[3]))
+ intersect(RegressionLine(a[1], a[2]), RegressionLine(b[0], b[1])))
/ 2;
log(tr, 2);
log(bl, 2);
return QuadrilateralF{tl, tr, br, bl};
};
if (auto found = LocateAlignmentPattern(image, fp.size / 7, bestPT(dim - PointF(3, 3)))) {
log(*found, 2);
if (auto spQuad = FindConcentricPatternCorners(image, *found, fp.size / 2, 1)) {
auto dest = intersectQuads(*fpQuad, *spQuad);
if (dim.y <= 9) {
bestPT = PerspectiveTransform({{6.5, 0.5}, {dim.x - 1.5, dim.y - 3.5}, {dim.x - 1.5, dim.y - 1.5}, {6.5, 6.5}},
{fpQuad->topRight(), spQuad->topRight(), spQuad->bottomRight(), fpQuad->bottomRight()});
} else {
dest[0] = fp;
dest[2] = *found;
bestPT = PerspectiveTransform({{3.5, 3.5}, {dim.x - 2.5, 3.5}, {dim.x - 2.5, dim.y - 2.5}, {3.5, dim.y - 2.5}}, dest);
}
}
}
return SampleGrid(image, dim.x, dim.y, bestPT);
}
} // namespace ZXing::QRCode
```
|
/content/code_sandbox/core/src/qrcode/QRDetector.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 9,120
|
```c++
/*
*/
#include "MCReader.h"
#include "BinaryBitmap.h"
#include "BitMatrix.h"
#include "DecoderResult.h"
#include "DetectorResult.h"
#include "MCBitMatrixParser.h"
#include "MCDecoder.h"
#include "Barcode.h"
namespace ZXing::MaxiCode {
/**
* This method detects a code in a "pure" image -- that is, pure monochrome image
* which contains only an unrotated, unskewed, image of a code, with some white border
* around it. This is a specialized method that works exceptionally fast in this special
* case.
*/
static BitMatrix ExtractPureBits(const BitMatrix& image)
{
int left, top, width, height;
if (!image.findBoundingBox(left, top, width, height, BitMatrixParser::MATRIX_WIDTH))
return {};
// Now just read off the bits
BitMatrix result(BitMatrixParser::MATRIX_WIDTH, BitMatrixParser::MATRIX_HEIGHT);
for (int y = 0; y < BitMatrixParser::MATRIX_HEIGHT; y++) {
int iy = top + (y * height + height / 2) / BitMatrixParser::MATRIX_HEIGHT;
for (int x = 0; x < BitMatrixParser::MATRIX_WIDTH; x++) {
int ix = left + (x * width + width / 2 + (y & 0x01) * width / 2) / BitMatrixParser::MATRIX_WIDTH;
if (image.get(ix, iy)) {
result.set(x, y);
}
}
}
//TODO: need to return position info
return result;
}
Barcode Reader::decode(const BinaryBitmap& image) const
{
auto binImg = image.getBitMatrix();
if (binImg == nullptr)
return {};
//TODO: this only works with effectively 'pure' barcodes. Needs proper detector.
BitMatrix bits = ExtractPureBits(*binImg);
if (bits.empty())
return {};
DecoderResult decRes = Decode(bits);
// TODO: before we can meaningfully return a ChecksumError result, we need to check the center for the presence of the finder pattern
if (!decRes.isValid())
return {};
return Barcode(std::move(decRes), DetectorResult{}, BarcodeFormat::MaxiCode);
}
} // namespace ZXing::MaxiCode
```
|
/content/code_sandbox/core/src/maxicode/MCReader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 489
|
```objective-c
/*
*/
#pragma once
namespace ZXing {
class DecoderResult;
class BitMatrix;
namespace MaxiCode {
DecoderResult Decode(const BitMatrix& bits);
} // MaxiCode
} // ZXing
```
|
/content/code_sandbox/core/src/maxicode/MCDecoder.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 43
|
```c++
/*
*/
#include "MCDecoder.h"
#include "ByteArray.h"
#include "CharacterSet.h"
#include "DecoderResult.h"
#include "GenericGF.h"
#include "MCBitMatrixParser.h"
#include "ReedSolomonDecoder.h"
#include "ZXTestSupport.h"
#include <algorithm>
#include <array>
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
namespace ZXing::MaxiCode {
static const int ALL = 0;
static const int EVEN = 1;
static const int ODD = 2;
static bool CorrectErrors(ByteArray& codewordBytes, int start, int dataCodewords, int ecCodewords, int mode)
{
int codewords = dataCodewords + ecCodewords;
// in EVEN or ODD mode only half the codewords
int divisor = mode == ALL ? 1 : 2;
// First read into an array of ints
std::vector<int> codewordsInts(codewords / divisor, 0);
for (int i = 0; i < codewords; i++) {
if ((mode == ALL) || (i % 2 == (mode - 1)))
codewordsInts[i / divisor] = codewordBytes[i + start];
}
if (!ReedSolomonDecode(GenericGF::MaxiCodeField64(), codewordsInts, ecCodewords / divisor))
return false;
// Copy back into array of bytes -- only need to worry about the bytes that were data
// We don't care about errors in the error-correction codewords
for (int i = 0; i < dataCodewords; i++) {
if ((mode == ALL) || (i % 2 == (mode - 1)))
codewordBytes[i + start] = narrow_cast<uint8_t>(codewordsInts[i / divisor]);
}
return true;
}
/**
* <p>MaxiCodes can encode text or structured information as bits in one of several modes,
* with multiple character sets in one code. This class decodes the bits back into text.</p>
*
* @author mike32767
* @author Manuel Kasten
*/
namespace DecodedBitStreamParser {
static const short SHI0 = 0x100;
static const short SHI1 = 0x101;
static const short SHI2 = 0x102;
static const short SHI3 = 0x103;
static const short SHI4 = 0x104;
static const short TWSA = 0x105; // two shift A
static const short TRSA = 0x106; // three shift A
static const short LCHA = 0x107; // latch A
static const short LCHB = 0x108; // latch B
static const short LOCK = 0x109;
static const short ECI = 0x10A;
static const short NS = 0x10B;
static const short PAD = 0x10C;
static const char FS = 0x1C;
static const char GS = 0x1D;
static const char RS = 0x1E;
// clang-format off
const static std::array<short, 0x40> CHARSETS[] = {
{ // set 0 (A)
'\r', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ECI, FS, GS, RS, NS,
' ', PAD, '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', SHI1, SHI2, SHI3, SHI4, LCHB,
},
{ // set 1 (B)
'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ECI, FS, GS, RS, NS,
'{', PAD, '}', '~', 0x7F, ';', '<', '=', '>', '?', '[', '\\', ']', '^', '_', ' ',
',', '.', '/', ':', '@', '!', '|', PAD, TWSA, TRSA, PAD, SHI0, SHI2, SHI3, SHI4, LCHA,
},
{ // set 2 (C)
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, ECI, FS, GS, RS, NS, // Note that in original code in Java, NS is not there, which seems to be a bug
0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xAA, 0xAC, 0xB1, 0xB2, 0xB3, 0xB5, 0xB9, 0xBA, 0xBC, 0xBD, 0xBE,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, LCHA, 0x20, LOCK, SHI3, SHI4, LCHB,
},
{ // set 3 (D)
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, ECI, FS, GS, RS, NS,
0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xA1, 0xA8, 0xAB, 0xAF, 0xB0, 0xB4, 0xB7, 0xB8, 0xBB, 0xBF, 0x8A,
0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, LCHA, 0x20, SHI2, LOCK, SHI4, LCHB,
},
{ // set 4 (E)
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, ECI, PAD, PAD, 0x1B, NS,
FS, GS, RS, 0x1F, 0x9F, 0xA0, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA9, 0xAD, 0xAE, 0xB6,
0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, LCHA, 0x20, SHI2, SHI3, LOCK, LCHB,
},
};
// clang-format on
static int GetBit(int bit, const ByteArray& bytes)
{
bit--;
return (bytes[bit / 6] & (1 << (5 - (bit % 6)))) == 0 ? 0 : 1;
}
static unsigned int GetInt(const ByteArray& bytes, const ByteArray& x)
{
int len = Size(x);
unsigned int val = 0;
for (int i = 0; i < len; i++)
val += GetBit(x[i], bytes) << (len - i - 1);
return val;
}
static unsigned int GetPostCode2Length(const ByteArray& bytes)
{
return std::min(GetInt(bytes, {39, 40, 41, 42, 31, 32}), 9U);
}
static std::string GetPostCode2(const ByteArray& bytes)
{
unsigned int val = GetInt(bytes,
{33, 34, 35, 36, 25, 26, 27, 28, 29, 30, 19, 20, 21, 22, 23, 24, 13, 14, 15, 16, 17, 18, 7, 8, 9, 10, 11, 12, 1, 2});
unsigned int len = GetPostCode2Length(bytes);
// Pad or truncate to length
char buf[11]; // 30 bits 0x3FFFFFFF == 1073741823 (10 digits)
snprintf(buf, sizeof(buf), "%0*d", len, val);
buf[len] = '\0';
return buf;
}
static std::string GetPostCode3(const ByteArray& bytes)
{
return {
(char) CHARSETS[0].at(GetInt(bytes, { 39, 40, 41, 42, 31, 32 })),
(char) CHARSETS[0].at(GetInt(bytes, { 33, 34, 35, 36, 25, 26 })),
(char) CHARSETS[0].at(GetInt(bytes, { 27, 28, 29, 30, 19, 20 })),
(char) CHARSETS[0].at(GetInt(bytes, { 21, 22, 23, 24, 13, 14 })),
(char) CHARSETS[0].at(GetInt(bytes, { 15, 16, 17, 18, 7, 8 })),
(char) CHARSETS[0].at(GetInt(bytes, { 9, 10, 11, 12, 1, 2 })),
};
}
static unsigned int GetCountry(const ByteArray& bytes)
{
return std::min(GetInt(bytes, {53, 54, 43, 44, 45, 46, 47, 48, 37, 38}), 999U);
}
static unsigned int GetServiceClass(const ByteArray& bytes)
{
return std::min(GetInt(bytes, {55, 56, 57, 58, 59, 60, 49, 50, 51, 52}), 999U);
}
/**
* See ISO/IEC 16023:2000 Section 4.6 Table 3
*/
static ZXing::ECI ParseECIValue(const ByteArray& bytes, int& i)
{
int firstByte = bytes[++i];
if ((firstByte & 0x20) == 0)
return ZXing::ECI(firstByte);
int secondByte = bytes[++i];
if ((firstByte & 0x10) == 0)
return ZXing::ECI(((firstByte & 0x0F) << 6) | secondByte);
int thirdByte = bytes[++i];
if ((firstByte & 0x08) == 0)
return ZXing::ECI(((firstByte & 0x07) << 12) | (secondByte << 6) | thirdByte);
int fourthByte = bytes[++i];
return ZXing::ECI(((firstByte & 0x03) << 18) | (secondByte << 12) | (thirdByte << 6) | fourthByte);
}
/**
* See ISO/IEC 16023:2000 Section 4.9.1 Table 5
*/
static void ParseStructuredAppend(const ByteArray& bytes, int& i, StructuredAppendInfo& sai)
{
int byte = bytes[++i];
sai.index = (byte >> 3) & 0x07;
sai.count = (byte & 0x07) + 1;
if (sai.count == 1 || sai.count <= sai.index) // If info doesn't make sense
sai.count = 0; // Choose to mark count as unknown
// No id
}
static void GetMessage(const ByteArray& bytes, int start, int len, Content& result, StructuredAppendInfo& sai)
{
int shift = -1;
int set = 0;
int lastset = 0;
for (int i = start; i < start + len; i++) {
int c = CHARSETS[set].at(bytes[i]);
switch (c) {
case LCHA:
set = 0;
shift = -1;
break;
case LCHB:
set = 1;
shift = -1;
break;
case SHI0:
case SHI1:
case SHI2:
case SHI3:
case SHI4:
lastset = set;
set = c - SHI0;
shift = 1;
break;
case TWSA:
lastset = set;
set = 0;
shift = 2;
break;
case TRSA:
lastset = set;
set = 0;
shift = 3;
break;
case NS:
result.append(
ToString((bytes[i + 1] << 24) + (bytes[i + 2] << 18) + (bytes[i + 3] << 12) + (bytes[i + 4] << 6) + bytes[i + 5], 9));
i += 5;
break;
case LOCK: shift = -1; break;
case ECI: result.switchEncoding(ParseECIValue(bytes, i)); break;
case PAD:
if (i == start)
ParseStructuredAppend(bytes, i, sai);
shift = -1;
break;
default: result.push_back(c);
}
if (shift-- == 0)
set = lastset;
}
}
ZXING_EXPORT_TEST_ONLY
DecoderResult Decode(ByteArray&& bytes, const int mode)
{
Content result;
result.symbology = {'U', (mode == 2 || mode == 3) ? '1' : '0', 2}; // TODO: No identifier defined for mode 6?
result.defaultCharset = CharacterSet::ISO8859_1;
StructuredAppendInfo sai;
switch (mode) {
case 2:
case 3: {
auto postcode = mode == 2 ? GetPostCode2(bytes) : GetPostCode3(bytes);
auto country = ToString(GetCountry(bytes), 3);
auto service = ToString(GetServiceClass(bytes), 3);
GetMessage(bytes, 10, 84, result, sai);
if (result.bytes.asString().compare(0, 7, "[)>\u001E01\u001D") == 0) // "[)>" + RS + "01" + GS
result.insert(9, postcode + GS + country + GS + service + GS);
else
result.insert(0, postcode + GS + country + GS + service + GS);
break;
}
case 4:
case 6: GetMessage(bytes, 1, 93, result, sai); break;
case 5: GetMessage(bytes, 1, 77, result, sai); break;
}
return DecoderResult(std::move(result))
.setEcLevel(std::to_string(mode))
.setStructuredAppend(sai)
.setReaderInit(mode == 6);
}
} // DecodedBitStreamParser
DecoderResult Decode(const BitMatrix& bits)
{
ByteArray codewords = BitMatrixParser::ReadCodewords(bits);
if (!CorrectErrors(codewords, 0, 10, 10, ALL))
return ChecksumError();
int mode = codewords[0] & 0x0F;
ByteArray datawords;
switch (mode) {
case 2: // Structured Carrier Message (numeric postcode)
case 3: // Structured Carrier Message (alphanumeric postcode)
case 4: // Standard Symbol
case 6: // Reader Programming
if (CorrectErrors(codewords, 20, 84, 40, EVEN) && CorrectErrors(codewords, 20, 84, 40, ODD))
datawords.resize(94, 0);
else
return ChecksumError();
break;
case 5: // Full ECC
if (CorrectErrors(codewords, 20, 68, 56, EVEN) && CorrectErrors(codewords, 20, 68, 56, ODD))
datawords.resize(78, 0);
else
return ChecksumError();
break;
default: return FormatError("Invalid mode");
}
std::copy_n(codewords.begin(), 10, datawords.begin());
std::copy_n(codewords.begin() + 20, datawords.size() - 10, datawords.begin() + 10);
return DecodedBitStreamParser::Decode(std::move(datawords), mode);
}
} // namespace ZXing::MaxiCode
```
|
/content/code_sandbox/core/src/maxicode/MCDecoder.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 4,264
|
```objective-c
/*
*/
#pragma once
namespace ZXing {
class ByteArray;
class BitMatrix;
namespace MaxiCode {
/**
* @author mike32767
* @author Manuel Kasten
*/
class BitMatrixParser
{
public:
static ByteArray ReadCodewords(const BitMatrix& image);
static const int MATRIX_WIDTH = 30;
static const int MATRIX_HEIGHT = 33;
};
} // MaxiCode
} // ZXing
```
|
/content/code_sandbox/core/src/maxicode/MCBitMatrixParser.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 89
|
```c++
/*
*/
#include "MCBitMatrixParser.h"
#include "BitMatrix.h"
#include "ByteArray.h"
#include <array>
namespace ZXing::MaxiCode {
static const std::array<std::array<int, BitMatrixParser::MATRIX_WIDTH>, BitMatrixParser::MATRIX_HEIGHT> BITNR = {
121,120,127,126,133,132,139,138,145,144,151,150,157,156,163,162,169,168,175,174,181,180,187,186,193,192,199,198, -2, -2,
123,122,129,128,135,134,141,140,147,146,153,152,159,158,165,164,171,170,177,176,183,182,189,188,195,194,201,200,816, -3,
125,124,131,130,137,136,143,142,149,148,155,154,161,160,167,166,173,172,179,178,185,184,191,190,197,196,203,202,818,817,
283,282,277,276,271,270,265,264,259,258,253,252,247,246,241,240,235,234,229,228,223,222,217,216,211,210,205,204,819, -3,
285,284,279,278,273,272,267,266,261,260,255,254,249,248,243,242,237,236,231,230,225,224,219,218,213,212,207,206,821,820,
287,286,281,280,275,274,269,268,263,262,257,256,251,250,245,244,239,238,233,232,227,226,221,220,215,214,209,208,822, -3,
289,288,295,294,301,300,307,306,313,312,319,318,325,324,331,330,337,336,343,342,349,348,355,354,361,360,367,366,824,823,
291,290,297,296,303,302,309,308,315,314,321,320,327,326,333,332,339,338,345,344,351,350,357,356,363,362,369,368,825, -3,
293,292,299,298,305,304,311,310,317,316,323,322,329,328,335,334,341,340,347,346,353,352,359,358,365,364,371,370,827,826,
409,408,403,402,397,396,391,390, 79, 78, -2, -2, 13, 12, 37, 36, 2, -1, 44, 43,109,108,385,384,379,378,373,372,828, -3,
411,410,405,404,399,398,393,392, 81, 80, 40, -2, 15, 14, 39, 38, 3, -1, -1, 45,111,110,387,386,381,380,375,374,830,829,
413,412,407,406,401,400,395,394, 83, 82, 41, -3, -3, -3, -3, -3, 5, 4, 47, 46,113,112,389,388,383,382,377,376,831, -3,
415,414,421,420,427,426,103,102, 55, 54, 16, -3, -3, -3, -3, -3, -3, -3, 20, 19, 85, 84,433,432,439,438,445,444,833,832,
417,416,423,422,429,428,105,104, 57, 56, -3, -3, -3, -3, -3, -3, -3, -3, 22, 21, 87, 86,435,434,441,440,447,446,834, -3,
419,418,425,424,431,430,107,106, 59, 58, -3, -3, -3, -3, -3, -3, -3, -3, -3, 23, 89, 88,437,436,443,442,449,448,836,835,
481,480,475,474,469,468, 48, -2, 30, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 0, 53, 52,463,462,457,456,451,450,837, -3,
483,482,477,476,471,470, 49, -1, -2, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -1,465,464,459,458,453,452,839,838,
485,484,479,478,473,472, 51, 50, 31, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 1, -2, 42,467,466,461,460,455,454,840, -3,
487,486,493,492,499,498, 97, 96, 61, 60, -3, -3, -3, -3, -3, -3, -3, -3, -3, 26, 91, 90,505,504,511,510,517,516,842,841,
489,488,495,494,501,500, 99, 98, 63, 62, -3, -3, -3, -3, -3, -3, -3, -3, 28, 27, 93, 92,507,506,513,512,519,518,843, -3,
491,490,497,496,503,502,101,100, 65, 64, 17, -3, -3, -3, -3, -3, -3, -3, 18, 29, 95, 94,509,508,515,514,521,520,845,844,
559,558,553,552,547,546,541,540, 73, 72, 32, -3, -3, -3, -3, -3, -3, 10, 67, 66,115,114,535,534,529,528,523,522,846, -3,
561,560,555,554,549,548,543,542, 75, 74, -2, -1, 7, 6, 35, 34, 11, -2, 69, 68,117,116,537,536,531,530,525,524,848,847,
563,562,557,556,551,550,545,544, 77, 76, -2, 33, 9, 8, 25, 24, -1, -2, 71, 70,119,118,539,538,533,532,527,526,849, -3,
565,564,571,570,577,576,583,582,589,588,595,594,601,600,607,606,613,612,619,618,625,624,631,630,637,636,643,642,851,850,
567,566,573,572,579,578,585,584,591,590,597,596,603,602,609,608,615,614,621,620,627,626,633,632,639,638,645,644,852, -3,
569,568,575,574,581,580,587,586,593,592,599,598,605,604,611,610,617,616,623,622,629,628,635,634,641,640,647,646,854,853,
727,726,721,720,715,714,709,708,703,702,697,696,691,690,685,684,679,678,673,672,667,666,661,660,655,654,649,648,855, -3,
729,728,723,722,717,716,711,710,705,704,699,698,693,692,687,686,681,680,675,674,669,668,663,662,657,656,651,650,857,856,
731,730,725,724,719,718,713,712,707,706,701,700,695,694,689,688,683,682,677,676,671,670,665,664,659,658,653,652,858, -3,
733,732,739,738,745,744,751,750,757,756,763,762,769,768,775,774,781,780,787,786,793,792,799,798,805,804,811,810,860,859,
735,734,741,740,747,746,753,752,759,758,765,764,771,770,777,776,783,782,789,788,795,794,801,800,807,806,813,812,861, -3,
737,736,743,742,749,748,755,754,761,760,767,766,773,772,779,778,785,784,791,790,797,796,803,802,809,808,815,814,863,862,
};
ByteArray BitMatrixParser::ReadCodewords(const BitMatrix& image)
{
ByteArray result(144);
int height = image.height();
int width = image.width();
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int bit = BITNR[y][x];
if (bit >= 0 && image.get(x, y)) {
result[bit / 6] |= static_cast<uint8_t>(1 << (5 - (bit % 6)));
}
}
}
return result;
}
} // namespace ZXing::MaxiCode
```
|
/content/code_sandbox/core/src/maxicode/MCBitMatrixParser.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,450
|
```objective-c
/*
*/
#pragma once
#include "Reader.h"
namespace ZXing::MaxiCode {
class Reader : public ZXing::Reader
{
public:
using ZXing::Reader::Reader;
Barcode decode(const BinaryBitmap& image) const override;
};
} // namespace ZXing::MaxiCode
```
|
/content/code_sandbox/core/src/maxicode/MCReader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 62
|
```c++
/*
*/
#include "ODCode93Reader.h"
#include "Barcode.h"
#include "ZXAlgorithms.h"
#include <array>
#include <string>
namespace ZXing::OneD {
// Note that 'abcd' are dummy characters in place of control characters.
static const char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
/**
* Each character consist of 3 bars and 3 spaces and is 9 modules wide in total.
* Each bar and space is from 1 to 4 modules wide.
* These represent the encodings of characters. Each module is assigned 1 bit.
* The 9 least-significant bits of each int correspond to the 9 modules in a symbol.
* Note: bit 9 (the first) is always 1, bit 1 (the last) is always 0.
*/
static const int CHARACTER_ENCODINGS[] = {
0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9
0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J
0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T
0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z
0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %
0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars ($)==a, (%)==b, (/)==c, (+)==d, *
};
static_assert(Size(ALPHABET) - 1 == Size(CHARACTER_ENCODINGS), "table size mismatch");
static const int ASTERISK_ENCODING = 0x15E;
using CounterContainer = std::array<int, 6>;
static bool
CheckOneChecksum(const std::string& result, int checkPosition, int weightMax)
{
int weight = 1;
int checkSum = 0;
for (int i = checkPosition - 1; i >= 0; i--) {
checkSum += weight * IndexOf(ALPHABET, result[i]);
if (++weight > weightMax) {
weight = 1;
}
}
return result[checkPosition] == ALPHABET[checkSum % 47];
}
static bool
CheckChecksums(const std::string& result)
{
int length = Size(result);
return CheckOneChecksum(result, length - 2, 20) && CheckOneChecksum(result, length - 1, 15);
}
// forward declare here. see ODCode39Reader.cpp. Not put in header to not pollute the public facing API
std::string DecodeCode39AndCode93FullASCII(std::string encoded, const char ctrl[4]);
constexpr int CHAR_LEN = 6;
constexpr int CHAR_SUM = 9;
// quiet zone is half the width of a character symbol
constexpr float QUIET_ZONE_SCALE = 0.5f;
static bool IsStartGuard(const PatternView& window, int spaceInPixel)
{
// The complete start pattern is FixedPattern<CHAR_LEN, CHAR_SUM>{1, 1, 1, 1, 4, 1}.
// Use only the first 4 elements which results in more than a 2x speedup. This is counter-intuitive since we save at
// most 1/3rd of the loop iterations in FindPattern. The reason might be a successful vectorization with the limited
// pattern size that is missed otherwise. We check for the remaining 2 slots for plausibility of the 4:1 ratio.
return IsPattern(window, FixedPattern<4, 4>{1, 1, 1, 1}, spaceInPixel, QUIET_ZONE_SCALE * 12) &&
window[4] > 3 * window[5] - 2 &&
RowReader::OneToFourBitPattern<CHAR_LEN, CHAR_SUM>(window) == ASTERISK_ENCODING;
}
Barcode Code93Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
{
// minimal number of characters that must be present (including start, stop, checksum and 1 payload characters)
int minCharCount = 5;
next = FindLeftGuard<CHAR_LEN>(next, minCharCount * CHAR_LEN, IsStartGuard);
if (!next.isValid())
return {};
int xStart = next.pixelsInFront();
std::string txt;
txt.reserve(20);
do {
// check remaining input width
if (!next.skipSymbol())
return {};
txt += LookupBitPattern(OneToFourBitPattern<CHAR_LEN, CHAR_SUM>(next), CHARACTER_ENCODINGS, ALPHABET);
if (txt.back() == 0)
return {};
} while (txt.back() != '*');
txt.pop_back(); // remove asterisk
if (Size(txt) < minCharCount - 2)
return {};
// check termination bar (is present and not wider than about 2 modules) and quiet zone
next = next.subView(0, CHAR_LEN + 1);
if (!next.isValid() || next[CHAR_LEN] > next.sum(CHAR_LEN) / 4 || !next.hasQuietZoneAfter(QUIET_ZONE_SCALE))
return {};
Error error;
if (!CheckChecksums(txt))
error = ChecksumError();
// Remove checksum digits
txt.resize(txt.size() - 2);
if (!error && (txt = DecodeCode39AndCode93FullASCII(txt, "abcd")).empty())
error = FormatError("ASCII decoding of Code93 failed");
// Symbology identifier ISO/IEC 15424:2008 4.4.10 no modifiers
SymbologyIdentifier symbologyIdentifier = {'G', '0'};
int xStop = next.pixelsTillEnd();
return Barcode(txt, rowNumber, xStart, xStop, BarcodeFormat::Code93, symbologyIdentifier, error);
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode93Reader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,450
|
```objective-c
/*
*/
#pragma once
#include "ODRowReader.h"
namespace ZXing::OneD {
class Code39Reader : public RowReader
{
public:
/**
* Creates a reader that can be configured to check the last character as a check digit,
* or optionally attempt to decode "extended Code 39" sequences that are used to encode
* the full ASCII character set.
*/
using RowReader::RowReader;
Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
};
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode39Reader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 126
|
```objective-c
/*
*/
#pragma once
#include "Reader.h"
#include <memory>
#include <vector>
namespace ZXing {
class ReaderOptions;
namespace OneD {
class RowReader;
class Reader : public ZXing::Reader
{
public:
explicit Reader(const ReaderOptions& opts);
~Reader() override;
Barcode decode(const BinaryBitmap& image) const override;
Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
private:
std::vector<std::unique_ptr<RowReader>> _readers;
};
} // OneD
} // ZXing
```
|
/content/code_sandbox/core/src/oned/ODReader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 118
|
```objective-c
/*
*/
#pragma once
#include "ODRowReader.h"
namespace ZXing::OneD {
class Code128Reader : public RowReader
{
public:
using RowReader::RowReader;
Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
};
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode128Reader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 75
|
```objective-c
/*
*/
#pragma once
#include "BitArray.h"
#include "Pattern.h"
#include "Barcode.h"
#include "ZXAlgorithms.h"
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <iterator>
#include <limits>
#include <memory>
/*
Code39 : 1:2/3, 5+4+1 (0x3|2x1 wide) -> 12-15 mods, v1-? | ToNarrowWide(OMG 1) == *
Codabar: 1:2/3, 4+3+1 (1x1|1x2|3x0 wide) -> 9-13 mods, v1-? | ToNarrowWide(OMG 2) == ABCD
ITF : 1:2/3, 5+5 (2x2 wide) -> mods, v6-?| .5, .38 == * | qz:10
Code93 : 1-4, 3+3 -> 9 mods v1-? | round to 1-4 == *
Code128: 1-4, 3+3 -> 11 mods v1-? | .7, .25 == ABC | qz:10
UPC/EAN: 1-4, 2+2 -> 7 mods f | .7, .48 == *
UPC-A: 11d 95m = 3 + 6*4 + 5 + 6*4 + 3 = 59 | qz:3
EAN-13: 12d 95m
UPC-E: 6d, 3 + 6*4 + 6 = 33
EAN-8: 8d, 3 + 4*4 + 5 + 4*4 + 3 = 43
RSS14 : 1-8, finder: (15,2+3), symbol: (15/16,4+4) | .45, .2 (finder only), 14d
code = 2xguard + 2xfinder + 4xsymbol = (96,23), stacked = 2x50 mods
RSSExp.: v?-74d/?-41c
*/
namespace ZXing {
class ReaderOptions;
namespace OneD {
/**
* Encapsulates functionality and implementation that is common to all families
* of one-dimensional barcodes.
*/
class RowReader
{
protected:
const ReaderOptions& _opts;
public:
explicit RowReader(const ReaderOptions& opts) : _opts(opts) {}
explicit RowReader(ReaderOptions&&) = delete;
struct DecodingState
{
virtual ~DecodingState() = default;
};
virtual ~RowReader() {}
virtual Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const = 0;
/**
* Determines how closely a set of observed counts of runs of black/white values matches a given
* target pattern. This is reported as the ratio of the total variance from the expected pattern
* proportions across all pattern elements, to the length of the pattern.
*
* @param counters observed counters
* @param pattern expected pattern
* @param maxIndividualVariance The most any counter can differ before we give up
* @return ratio of total variance between counters and pattern compared to total pattern size
*/
template <typename CP, typename PP>
static float PatternMatchVariance(const CP* counters, const PP* pattern, size_t length, float maxIndividualVariance)
{
int total = Reduce(counters, counters + length, 0);
int patternLength = Reduce(pattern, pattern + length, 0);
if (total < patternLength) {
// If we don't even have one pixel per unit of bar width, assume this is too small
// to reliably match, so fail:
return std::numeric_limits<float>::max();
}
float unitBarWidth = (float)total / patternLength;
maxIndividualVariance *= unitBarWidth;
float totalVariance = 0.0f;
for (size_t x = 0; x < length; ++x) {
float variance = std::abs(counters[x] - pattern[x] * unitBarWidth);
if (variance > maxIndividualVariance) {
return std::numeric_limits<float>::max();
}
totalVariance += variance;
}
return totalVariance / total;
}
template <typename Counters, typename Pattern>
static float PatternMatchVariance(const Counters& counters, const Pattern& pattern, float maxIndividualVariance) {
assert(Size(counters) == Size(pattern));
return PatternMatchVariance(std::data(counters), std::data(pattern), std::size(counters), maxIndividualVariance);
}
/**
* Attempts to decode a sequence of black/white lines into single
* digit.
*
* @param counters the counts of runs of observed black/white/black/... values
* @param patterns the list of patterns to compare the contents of counters to
* @param requireUnambiguousMatch the 'best match' must be better than all other matches
* @return The decoded digit index, -1 if no pattern matched
*/
template <typename Counters, typename Patterns>
static int DecodeDigit(const Counters& counters, const Patterns& patterns, float maxAvgVariance,
float maxIndividualVariance, bool requireUnambiguousMatch = true)
{
float bestVariance = maxAvgVariance; // worst variance we'll accept
constexpr int INVALID_MATCH = -1;
int bestMatch = INVALID_MATCH;
for (int i = 0; i < Size(patterns); i++) {
float variance = PatternMatchVariance(counters, patterns[i], maxIndividualVariance);
if (variance < bestVariance) {
bestVariance = variance;
bestMatch = i;
} else if (requireUnambiguousMatch && variance == bestVariance) {
// if we find a second 'best match' with the same variance, we can not reliably report to have a suitable match
bestMatch = INVALID_MATCH;
}
}
return bestMatch;
}
/**
* @brief NarrowWideThreshold calculates width thresholds to separate narrow and wide bars and spaces.
*
* This is useful for codes like Codabar, Code39 and ITF which distinguish between narrow and wide
* bars/spaces. Where wide ones are between 2 and 3 times as wide as the narrow ones.
*
* @param view containing one character
* @return threshold value for bars and spaces
*/
static BarAndSpaceI NarrowWideThreshold(const PatternView& view)
{
BarAndSpaceI m = {view[0], view[1]};
BarAndSpaceI M = m;
for (int i = 2; i < view.size(); ++i)
UpdateMinMax(m[i], M[i], view[i]);
BarAndSpaceI res;
for (int i = 0; i < 2; ++i) {
// check that
// a) wide <= 4 * narrow
// b) bars and spaces are not more than a factor of 2 (or 3 for the max) apart from each other
if (M[i] > 4 * (m[i] + 1) || M[i] > 3 * M[i + 1] || m[i] > 2 * (m[i + 1] + 1))
return {};
// the threshold is the average of min and max but at least 1.5 * min
res[i] = std::max((m[i] + M[i]) / 2, m[i] * 3 / 2);
}
return res;
}
/**
* @brief ToNarrowWidePattern takes a PatternView, calculates a NarrowWideThreshold and returns int where a '0' bit
* means narrow and a '1' bit means 'wide'.
*/
static int NarrowWideBitPattern(const PatternView& view)
{
const auto threshold = NarrowWideThreshold(view);
if (!threshold.isValid())
return -1;
int pattern = 0;
for (int i = 0; i < view.size(); ++i) {
if (view[i] > threshold[i] * 2)
return -1;
AppendBit(pattern, view[i] > threshold[i]);
}
return pattern;
}
/**
* @brief each bar/space is 1-4 modules wide, we have N bars/spaces, they are SUM modules wide in total
*/
template <int LEN, int SUM>
static int OneToFourBitPattern(const PatternView& view)
{
// TODO: make sure none of the elements in the normalized pattern exceeds 4
return ToInt(NormalizedPattern<LEN, SUM>(view));
}
/**
* @brief Lookup the pattern in the table and return the character in alphabet at the same index.
* @returns 0 if pattern is not found. Used to be -1 but that fails on systems where char is unsigned.
*/
template<typename INDEX, typename ALPHABET>
static char LookupBitPattern(int pattern, const INDEX& table, const ALPHABET& alphabet)
{
int i = IndexOf(table, pattern);
return i == -1 ? 0 : alphabet[i];
}
template<typename INDEX, typename ALPHABET>
static char DecodeNarrowWidePattern(const PatternView& view, const INDEX& table, const ALPHABET& alphabet)
{
return LookupBitPattern(NarrowWideBitPattern(view), table, alphabet);
}
};
template<typename Range>
Barcode DecodeSingleRow(const RowReader& reader, const Range& range)
{
PatternRow row;
GetPatternRow(range, row);
PatternView view(row);
std::unique_ptr<RowReader::DecodingState> state;
return reader.decodePattern(0, view, state);
}
} // OneD
} // ZXing
```
|
/content/code_sandbox/core/src/oned/ODRowReader.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,200
|
```objective-c
/*
*/
#pragma once
#include <string>
namespace ZXing {
class BitMatrix;
namespace OneD {
/**
* This object renders an EAN8 code as a {@link BitMatrix}.
*
* @author aripollak@gmail.com (Ari Pollak)
*/
class EAN8Writer
{
public:
EAN8Writer& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; return *this; }
BitMatrix encode(const std::wstring& contents, int width, int height) const;
BitMatrix encode(const std::string& contents, int width, int height) const;
private:
int _sidesMargin = -1;
};
} // OneD
} // ZXing
```
|
/content/code_sandbox/core/src/oned/ODEAN8Writer.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 150
|
```c++
/*
*/
#include "ODEAN8Writer.h"
#include "ODUPCEANCommon.h"
#include "ODWriterHelper.h"
#include "Utf.h"
#include <vector>
namespace ZXing::OneD {
static const int CODE_WIDTH = 3 + // start guard
(7 * 4) + // left bars
5 + // middle guard
(7 * 4) + // right bars
3; // end guard
BitMatrix
EAN8Writer::encode(const std::wstring& contents, int width, int height) const
{
auto digits = UPCEANCommon::DigitString2IntArray<8>(contents);
std::vector<bool> result(CODE_WIDTH, false);
int pos = 0;
pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
for (int i = 0; i <= 3; i++) {
pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_PATTERNS[digits[i]], false);
}
pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::MIDDLE_PATTERN, false);
for (int i = 4; i <= 7; i++) {
pos += WriterHelper::AppendPattern(result, pos, UPCEANCommon::L_PATTERNS[digits[i]], true);
}
WriterHelper::AppendPattern(result, pos, UPCEANCommon::START_END_PATTERN, true);
return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 9);
}
BitMatrix EAN8Writer::encode(const std::string& contents, int width, int height) const
{
return encode(FromUtf8(contents), width, height);
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODEAN8Writer.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 386
|
```c++
/*
*/
#include "ODDataBarReader.h"
#include "BarcodeFormat.h"
#include "DecoderResult.h"
#include "DetectorResult.h"
#include "GTIN.h"
#include "ODDataBarCommon.h"
#include "Barcode.h"
#include <cmath>
#include <unordered_set>
namespace ZXing::OneD {
using namespace DataBar;
static bool IsCharacterPair(PatternView v, int modsLeft, int modsRight)
{
float modSizeRef = ModSizeFinder(v);
return IsCharacter(LeftChar(v), modsLeft, modSizeRef) && IsCharacter(RightChar(v), modsRight, modSizeRef);
}
static bool IsLeftPair(const PatternView& v)
{
return IsFinder(v[8], v[9], v[10], v[11], v[12]) && IsGuard(v[-1], v[11]) && IsCharacterPair(v, 16, 15);
}
static bool IsRightPair(const PatternView& v)
{
return IsFinder(v[12], v[11], v[10], v[9], v[8]) && IsGuard(v[9], v[21]) && IsCharacterPair(v, 15, 16);
}
static Character ReadDataCharacter(const PatternView& view, bool outsideChar, bool rightPair)
{
constexpr int OUTSIDE_EVEN_TOTAL_SUBSET[] = {1, 10, 34, 70, 126};
constexpr int INSIDE_ODD_TOTAL_SUBSET[] = {4, 20, 48, 81};
constexpr int OUTSIDE_GSUM[] = {0, 161, 961, 2015, 2715};
constexpr int INSIDE_GSUM[] = {0, 336, 1036, 1516};
constexpr int OUTSIDE_ODD_WIDEST[] = {8, 6, 4, 3, 1};
constexpr int INSIDE_ODD_WIDEST[] = {2, 4, 6, 8};
Array4I oddPattern = {}, evnPattern = {};
if (!ReadDataCharacterRaw(view, outsideChar ? 16 : 15, outsideChar == rightPair, oddPattern, evnPattern))
return {};
auto calcChecksumPortion = [](const Array4I& counts) {
int res = 0;
for (auto it = counts.rbegin(); it != counts.rend(); ++it)
res = 9 * res + *it;
return res;
};
int checksumPortion = calcChecksumPortion(oddPattern) + 3 * calcChecksumPortion(evnPattern);
if (outsideChar) {
int oddSum = Reduce(oddPattern);
assert((oddSum & 1) == 0 && oddSum <= 12 && oddSum >= 4); // checked in ReadDataCharacterRaw
int group = (12 - oddSum) / 2;
int oddWidest = OUTSIDE_ODD_WIDEST[group];
int evnWidest = 9 - oddWidest;
int vOdd = GetValue(oddPattern, oddWidest, false);
int vEvn = GetValue(evnPattern, evnWidest, true);
int tEvn = OUTSIDE_EVEN_TOTAL_SUBSET[group];
int gSum = OUTSIDE_GSUM[group];
return {vOdd * tEvn + vEvn + gSum, checksumPortion};
} else {
int evnSum = Reduce(evnPattern);
assert((evnSum & 1) == 0 && evnSum <= 12 && evnSum >= 4); // checked in ReadDataCharacterRaw
int group = (10 - evnSum) / 2;
int oddWidest = INSIDE_ODD_WIDEST[group];
int evnWidest = 9 - oddWidest;
int vOdd = GetValue(oddPattern, oddWidest, true);
int vEvn = GetValue(evnPattern, evnWidest, false);
int tOdd = INSIDE_ODD_TOTAL_SUBSET[group];
int gSum = INSIDE_GSUM[group];
return {vEvn * tOdd + vOdd + gSum, checksumPortion};
}
}
int ParseFinderPattern(const PatternView& view, bool reversed)
{
static constexpr std::array<FixedPattern<5, 15>, 10> FINDER_PATTERNS = {{
{3, 8, 2, 1, 1},
{3, 5, 5, 1, 1},
{3, 3, 7, 1, 1},
{3, 1, 9, 1, 1},
{2, 7, 4, 1, 1},
{2, 5, 6, 1, 1},
{2, 3, 8, 1, 1},
{1, 5, 7, 1, 1},
{1, 3, 9, 1, 1},
}};
// TODO: c++20 constexpr inversion from FIND_PATTERN?
static constexpr std::array<FixedPattern<5, 15>, 10> REVERSED_FINDER_PATTERNS = {{
{1, 1, 2, 8, 3}, {1, 1, 5, 5, 3}, {1, 1, 7, 3, 3}, {1, 1, 9, 1, 3}, {1, 1, 4, 7, 2},
{1, 1, 6, 5, 2}, {1, 1, 8, 3, 2}, {1, 1, 7, 5, 1}, {1, 1, 9, 3, 1},
}};
return ParseFinderPattern(view, reversed, FINDER_PATTERNS, REVERSED_FINDER_PATTERNS);
}
static Pair ReadPair(const PatternView& view, bool rightPair)
{
if (int pattern = ParseFinderPattern(Finder(view), rightPair))
if (auto outside = ReadDataCharacter(rightPair ? RightChar(view) : LeftChar(view), true, rightPair))
if (auto inside = ReadDataCharacter(rightPair ? LeftChar(view) : RightChar(view), false, rightPair)) {
// include left and right guards
int xStart = view.pixelsInFront() - view[-1];
int xStop = view.pixelsTillEnd() + 2 * view[FULL_PAIR_SIZE];
return {outside, inside, pattern, xStart, xStop};
}
return {};
}
static bool ChecksumIsValid(Pair leftPair, Pair rightPair)
{
auto checksum = [](Pair p) { return p.left.checksum + 4 * p.right.checksum; };
int a = (checksum(leftPair) + 16 * checksum(rightPair)) % 79;
int b = 9 * (std::abs(leftPair.finder) - 1) + (std::abs(rightPair.finder) - 1);
if (b > 72)
b--;
if (b > 8)
b--;
return a == b;
}
static std::string ConstructText(Pair leftPair, Pair rightPair)
{
auto value = [](Pair p) { return 1597 * p.left.value + p.right.value; };
auto res = 4537077LL * value(leftPair) + value(rightPair);
if (res >= 10000000000000LL) { // Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 5.2.3)
res -= 10000000000000LL;
assert(res <= 9999999999999LL); // 13 digits
}
auto txt = ToString(res, 13);
return txt + GTIN::ComputeCheckDigit(txt);
}
struct State : public RowReader::DecodingState
{
std::unordered_set<Pair, PairHash> leftPairs;
std::unordered_set<Pair, PairHash> rightPairs;
};
Barcode DataBarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>& state) const
{
#if 0 // non-stacked version
next = next.subView(-1, FULL_PAIR_SIZE + 1); // +1 reflects the guard pattern on the right, see IsRightPair());
// yes: the first view we test is at index 1 (black bar at 0 would be the guard pattern)
while (next.shift(2)) {
if (IsLeftPair(next)) {
if (auto leftPair = ReadPair(next, false); leftPair && next.shift(FULL_PAIR_SIZE) && IsRightPair(next)) {
if (auto rightPair = ReadPair(next, true); rightPair && ChecksumIsValid(leftPair, rightPair)) {
return {ConstructText(leftPair, rightPair), rowNumber, leftPair.xStart, rightPair.xStop,
BarcodeFormat::DataBar};
}
}
}
}
#else
if (!state)
state.reset(new State);
auto* prevState = static_cast<State*>(state.get());
next = next.subView(0, FULL_PAIR_SIZE + 1); // +1 reflects the guard pattern on the right, see IsRightPair()
// yes: the first view we test is at index 1 (black bar at 0 would be the guard pattern)
while (next.shift(1)) {
if (IsLeftPair(next)) {
if (auto leftPair = ReadPair(next, false)) {
leftPair.y = rowNumber;
prevState->leftPairs.insert(leftPair);
next.shift(FULL_PAIR_SIZE - 1);
}
}
if (next.shift(1) && IsRightPair(next)) {
if (auto rightPair = ReadPair(next, true)) {
rightPair.y = rowNumber;
prevState->rightPairs.insert(rightPair);
next.shift(FULL_PAIR_SIZE + 2);
}
}
}
for (const auto& leftPair : prevState->leftPairs)
for (const auto& rightPair : prevState->rightPairs)
if (ChecksumIsValid(leftPair, rightPair)) {
// Symbology identifier ISO/IEC 24724:2011 Section 9 and GS1 General Specifications 5.1.3 Figure 5.1.3-2
Barcode res{DecoderResult(Content(ByteArray(ConstructText(leftPair, rightPair)), {'e', '0'}))
.setLineCount(EstimateLineCount(leftPair, rightPair)),
{{}, EstimatePosition(leftPair, rightPair)},
BarcodeFormat::DataBar};
prevState->leftPairs.erase(leftPair);
prevState->rightPairs.erase(rightPair);
return res;
}
#endif
// guarantee progress (see loop in ODReader.cpp)
next = {};
return {};
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODDataBarReader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,389
|
```objective-c
/*
*/
#pragma once
#include <string>
namespace ZXing {
class BitMatrix;
namespace OneD {
/**
* This class renders CodaBar as {@code boolean[]}.
*
* @author dsbnatut@gmail.com (Kazuki Nishiura)
*/
class CodabarWriter
{
public:
CodabarWriter& setMargin(int sidesMargin) { _sidesMargin = sidesMargin; return *this; }
BitMatrix encode(const std::wstring& contents, int width, int height) const;
BitMatrix encode(const std::string& contents, int width, int height) const;
private:
int _sidesMargin = -1;
};
} // OneD
} // ZXing
```
|
/content/code_sandbox/core/src/oned/ODCodabarWriter.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 148
|
```c++
/*
*/
#include "ODCode128Reader.h"
#include "ODCode128Patterns.h"
#include "Barcode.h"
#include "ZXAlgorithms.h"
#include <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
namespace ZXing::OneD {
static const float MAX_AVG_VARIANCE = 0.25f;
static const float MAX_INDIVIDUAL_VARIANCE = 0.7f;
static const int CODE_SHIFT = 98;
static const int CODE_CODE_C = 99;
static const int CODE_CODE_B = 100;
static const int CODE_CODE_A = 101;
static const int CODE_FNC_1 = 102;
static const int CODE_FNC_2 = 97;
static const int CODE_FNC_3 = 96;
static const int CODE_START_A = 103;
static const int CODE_START_C = 105;
static const int CODE_STOP = 106;
class Raw2TxtDecoder
{
int codeSet = 0;
SymbologyIdentifier _symbologyIdentifier = {'C', '0'}; // ISO/IEC 15417:2007 Annex C Table C.1
bool _readerInit = false;
std::string txt;
size_t lastTxtSize = 0;
bool fnc4All = false;
bool fnc4Next = false;
bool shift = false;
void fnc1(const bool isCodeSetC)
{
if (txt.empty()) {
// ISO/IEC 15417:2007 Annex B.1 and GS1 General Specifications 21.0.1 Section 5.4.3.7
// If the first char after the start code is FNC1 then this is GS1-128.
_symbologyIdentifier.modifier = '1';
// GS1 General Specifications Section 5.4.6.4
// "Transmitted data ... is prefixed by the symbology identifier ]C1, if used."
// Choosing not to use symbology identifier, i.e. to not prefix to data.
_symbologyIdentifier.aiFlag = AIFlag::GS1;
}
else if ((isCodeSetC && txt.size() == 2 && txt[0] >= '0' && txt[0] <= '9' && txt[1] >= '0' && txt[1] <= '9')
|| (!isCodeSetC && txt.size() == 1 && ((txt[0] >= 'A' && txt[0] <= 'Z')
|| (txt[0] >= 'a' && txt[0] <= 'z')))) {
// ISO/IEC 15417:2007 Annex B.2
// FNC1 in second position following Code Set C "00-99" or Code Set A/B "A-Za-z" - AIM
_symbologyIdentifier.modifier = '2';
_symbologyIdentifier.aiFlag = AIFlag::AIM;
}
else {
// ISO/IEC 15417:2007 Annex B.3. Otherwise FNC1 is returned as ASCII 29 (GS)
txt.push_back((char)29);
}
};
public:
Raw2TxtDecoder(int startCode) : codeSet(204 - startCode)
{
txt.reserve(20);
}
bool decode(int code)
{
lastTxtSize = txt.size();
if (codeSet == CODE_CODE_C) {
if (code < 100) {
txt.append(ToString(code, 2));
} else if (code == CODE_FNC_1) {
fnc1(true /*isCodeSetC*/);
} else {
codeSet = code; // CODE_A / CODE_B
}
} else { // codeSet A or B
bool unshift = shift;
switch (code) {
case CODE_FNC_1: fnc1(false /*isCodeSetC*/); break;
case CODE_FNC_2:
// Message Append - do nothing?
break;
case CODE_FNC_3:
_readerInit = true; // Can occur anywhere in the symbol (ISO/IEC 15417:2007 4.3.4.2 (c))
break;
case CODE_SHIFT:
if (shift)
return false; // two shifts in a row make no sense
shift = true;
codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
break;
case CODE_CODE_A:
case CODE_CODE_B:
if (codeSet == code) {
// FNC4
if (fnc4Next)
fnc4All = !fnc4All;
fnc4Next = !fnc4Next;
} else {
codeSet = code;
}
break;
case CODE_CODE_C: codeSet = CODE_CODE_C; break;
default: {
// code < 96 at this point
int offset;
if (codeSet == CODE_CODE_A && code >= 64)
offset = fnc4All == fnc4Next ? -64 : +64;
else
offset = fnc4All == fnc4Next ? ' ' : ' ' + 128;
txt.push_back((char)(code + offset));
fnc4Next = false;
break;
}
}
// Unshift back to another code set if we were shifted
if (unshift) {
codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
shift = false;
}
}
return true;
}
std::string text() const
{
// Need to pull out the check digit(s) from string (if the checksum code happened to
// be a printable character).
return txt.substr(0, lastTxtSize);
}
SymbologyIdentifier symbologyIdentifier() const { return _symbologyIdentifier; }
bool readerInit() const { return _readerInit; }
};
// all 3 start patterns share the same 2-1-1 prefix
constexpr auto START_PATTERN_PREFIX = FixedPattern<3, 4>{2, 1, 1};
constexpr int CHAR_LEN = 6;
constexpr float QUIET_ZONE = 5; // quiet zone spec is 10 modules, real world examples ignore that, see #138
constexpr int CHAR_SUM = 11;
//TODO: make this a constexpr variable initialization
static auto E2E_PATTERNS = [] {
// This creates an array of ints for fast IndexOf lookup of the edge-2-edge patterns (ISO/IEC 15417:2007(E) Table 2)
// e.g. a code pattern of { 2, 1, 2, 2, 2, 2 } becomes the e2e pattern { 3, 3, 4, 4 } and the value 0b11100011110000.
std::array<int, 107> res;
for (int i = 0; i < Size(res); ++i) {
const auto& a = Code128::CODE_PATTERNS[i];
std::array<int, 4> e2e;
for (int j = 0; j < 4; j++)
e2e[j] = a[j] + a[j + 1];
res[i] = ToInt(e2e);
}
return res;
}();
Barcode Code128Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
{
int minCharCount = 4; // start + payload + checksum + stop
auto decodePattern = [](const PatternView& view, bool start = false) {
// This is basically the reference algorithm from the specification
int code = IndexOf(E2E_PATTERNS, ToInt(NormalizedE2EPattern<CHAR_LEN, CHAR_SUM>(view)));
if (code == -1 && !start) // if the reference algo fails, give the original upstream version a try (required to decode a few samples)
code = DecodeDigit(view, Code128::CODE_PATTERNS, MAX_AVG_VARIANCE, MAX_INDIVIDUAL_VARIANCE);
return code;
};
next = FindLeftGuard(next, minCharCount * CHAR_LEN, START_PATTERN_PREFIX, QUIET_ZONE);
if (!next.isValid())
return {};
next = next.subView(0, CHAR_LEN);
int startCode = decodePattern(next, true);
if (!(CODE_START_A <= startCode && startCode <= CODE_START_C))
return {};
int xStart = next.pixelsInFront();
ByteArray rawCodes;
rawCodes.reserve(20);
rawCodes.push_back(narrow_cast<uint8_t>(startCode));
Raw2TxtDecoder raw2txt(startCode);
while (true) {
if (!next.skipSymbol())
return {};
// Decode another code from image
int code = decodePattern(next);
if (code == -1)
return {};
if (code == CODE_STOP)
break;
if (code >= CODE_START_A)
return {};
if (!raw2txt.decode(code))
return {};
rawCodes.push_back(narrow_cast<uint8_t>(code));
}
if (Size(rawCodes) < minCharCount - 1) // stop code is missing in rawCodes
return {};
// check termination bar (is present and not wider than about 2 modules) and quiet zone (next is now 13 modules
// wide, require at least 8)
next = next.subView(0, CHAR_LEN + 1);
if (!next.isValid() || next[CHAR_LEN] > next.sum(CHAR_LEN) / 4 || !next.hasQuietZoneAfter(QUIET_ZONE/13))
return {};
Error error;
int checksum = rawCodes.front();
for (int i = 1; i < Size(rawCodes) - 1; ++i)
checksum += i * rawCodes[i];
// the last code is the checksum:
if (checksum % 103 != rawCodes.back())
error = ChecksumError();
int xStop = next.pixelsTillEnd();
return Barcode(raw2txt.text(), rowNumber, xStart, xStop, BarcodeFormat::Code128, raw2txt.symbologyIdentifier(), error,
raw2txt.readerInit());
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode128Reader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 2,260
|
```c++
/*
*/
#include "ODDataBarCommon.h"
#include <cmath>
namespace ZXing::OneD::DataBar {
static int combins(int n, int r)
{
int maxDenom;
int minDenom;
if (n - r > r) {
minDenom = r;
maxDenom = n - r;
} else {
minDenom = n - r;
maxDenom = r;
}
int val = 1;
int j = 1;
for (int i = n; i > maxDenom; i--) {
val *= i;
if (j <= minDenom) {
val /= j;
j++;
}
}
while (j <= minDenom) {
val /= j;
j++;
}
return val;
}
int GetValue(const Array4I& widths, int maxWidth, bool noNarrow)
{
int elements = Size(widths);
int n = Reduce(widths);
int val = 0;
int narrowMask = 0;
for (int bar = 0; bar < elements - 1; bar++) {
int elmWidth;
for (elmWidth = 1, narrowMask |= 1 << bar; elmWidth < widths[bar]; elmWidth++, narrowMask &= ~(1 << bar)) {
int subVal = combins(n - elmWidth - 1, elements - bar - 2);
if (noNarrow && (narrowMask == 0) && (n - elmWidth - (elements - bar - 1) >= elements - bar - 1)) {
subVal -= combins(n - elmWidth - (elements - bar), elements - bar - 2);
}
if (elements - bar - 1 > 1) {
int lessVal = 0;
for (int mxwElement = n - elmWidth - (elements - bar - 2); mxwElement > maxWidth; mxwElement--) {
lessVal += combins(n - elmWidth - mxwElement - 1, elements - bar - 3);
}
subVal -= lessVal * (elements - 1 - bar);
} else if (n - elmWidth > maxWidth) {
subVal--;
}
val += subVal;
}
n -= elmWidth;
}
return val;
}
template <typename T>
struct OddEven
{
T odd = {}, evn = {};
T& operator[](int i) { return i & 1 ? evn : odd; }
};
using Array4F = std::array<float, 4>;
bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed, Array4I& oddPattern,
Array4I& evnPattern)
{
OddEven<Array4I&> res = {oddPattern, evnPattern};
OddEven<Array4F> rem;
float moduleSize = static_cast<float>(view.sum(8)) / numModules;
auto* iter = view.data() + reversed * 7;
int inc = reversed ? -1 : 1;
for (int i = 0; i < 8; ++i, iter += inc) {
float v = *iter / moduleSize;
res[i % 2][i / 2] = int(v + .5f);
rem[i % 2][i / 2] = v - res[i % 2][i / 2];
}
// DataBarExpanded data character is 17 modules wide
// DataBar outer data character is 16 modules wide
// DataBar inner data character is 15 modules wide
int minSum = 4; // each data character has 4 bars and 4 spaces
int maxSum = numModules - minSum;
int oddSum = Reduce(res.odd);
int evnSum = Reduce(res.evn);
int sumErr = oddSum + evnSum - numModules;
// sum < min -> negative error; sum > max -> positive error
int oddSumErr = std::min(0, oddSum - (minSum + (numModules == 15))) + std::max(0, oddSum - maxSum);
int evnSumErr = std::min(0, evnSum - minSum) + std::max(0, evnSum - (maxSum - (numModules == 15)));
int oddParityErr = (oddSum & 1) == (numModules > 15);
int evnParityErr = (evnSum & 1) == (numModules < 17);
#if 0
// the 'signal improving' strategy of trying to fix off-by-one errors in the sum or parity leads to a massively
// increased likelihood of false positives / misreads especially with expanded codes that are composed of many
// pairs. the combinatorial explosion of possible pair combinations (see FindValidSequence) results in many possible
// sequences with valid checksums. It can slightly lower the minimum required resolution to detect something at all
// but the introduced error rate is clearly not worth it.
if ((sumErr == 0 && oddParityErr != evnParityErr) || (std::abs(sumErr) == 1 && oddParityErr == evnParityErr) ||
std::abs(sumErr) > 1 || std::abs(oddSumErr) > 1 || std::abs(evnSumErr) > 1)
return {};
if (sumErr == -1) {
oddParityErr *= -1;
evnParityErr *= -1;
} else if (sumErr == 0 && oddParityErr != 0) {
// both parity errors are 1 -> flip one of them
(oddSum < evnSum ? oddParityErr : evnParityErr) *= -1;
}
// check if parity and sum errors have opposite signs
if (oddParityErr * oddSumErr < 0 || evnParityErr * evnSumErr < 0)
return {};
// apparently the spec calls numbers at even indices 'odd'!?!
constexpr int odd = 0, evn = 1;
for (int i : {odd, evn}) {
int err = i == odd ? (oddSumErr | oddParityErr) : (evnSumErr | evnParityErr);
int mi = err < 0 ? std::max_element(rem[i].begin(), rem[i].end()) - rem[i].begin()
: std::min_element(rem[i].begin(), rem[i].end()) - rem[i].begin();
res[i][mi] -= err;
}
return true;
#else
// instead, we ignore any character that is not exactly fitting the requirements
return !(sumErr || oddSumErr || evnSumErr || oddParityErr || evnParityErr);
#endif
}
static bool IsStacked(const Pair& first, const Pair& last)
{
// check if we see two halfes that are far away from each other in y or overlapping in x
return std::abs(first.y - last.y) > (first.xStop - first.xStart) || last.xStart < (first.xStart + first.xStop) / 2;
}
Position EstimatePosition(const Pair& first, const Pair& last)
{
if (!IsStacked(first, last))
return Line((first.y + last.y) / 2, first.xStart, last.xStop);
else
return Position{{first.xStart, first.y}, {first.xStop, first.y}, {last.xStop, last.y}, {last.xStart, last.y}};
}
int EstimateLineCount(const Pair& first, const Pair& last)
{
// see incrementLineCount() in ODReader.cpp for the -1 here
return std::min(first.count, last.count) - 1 + IsStacked(first, last);
}
} // namespace ZXing::OneD::DataBar
```
|
/content/code_sandbox/core/src/oned/ODDataBarCommon.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,717
|
```c++
/*
*/
#include "ODCode39Reader.h"
#include "ReaderOptions.h"
#include "Barcode.h"
#include "ZXAlgorithms.h"
#include <array>
namespace ZXing::OneD {
static const char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%*";
/**
* Each character consists of 5 bars and 4 spaces, 3 of which are wide (i.e. 6 are narrow).
* Each character is followed by a narrow space. The narrow to wide ratio is between 1:2 and 1:3.
* These represent the encodings of characters, as patterns of wide and narrow bars.
* The 9 least-significant bits of each int correspond to the pattern of wide and narrow,
* with 1s representing "wide" and 0s representing "narrow".
*/
static const int CHARACTER_ENCODINGS[] = {
0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9
0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J
0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T
0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x0A8, // U-$
0x0A2, 0x08A, 0x02A, 0x094 // /-% , *
};
static_assert(Size(ALPHABET) - 1 == Size(CHARACTER_ENCODINGS), "table size mismatch");
static const char PERCENTAGE_MAPPING[26] = {
'A' - 38, 'B' - 38, 'C' - 38, 'D' - 38, 'E' - 38, // %A to %E map to control codes ESC to USep
'F' - 11, 'G' - 11, 'H' - 11, 'I' - 11, 'J' - 11, // %F to %J map to ; < = > ?
'K' + 16, 'L' + 16, 'M' + 16, 'N' + 16, 'O' + 16, // %K to %O map to [ \ ] ^ _
'P' + 43, 'Q' + 43, 'R' + 43, 'S' + 43, 'T' + 43, // %P to %T map to { | } ~ DEL
'\0', '@', '`', // %U map to NUL, %V map to @, %W map to `
127, 127, 127 // %X to %Z all map to DEL (127)
};
using CounterContainer = std::array<int, 9>;
// each character has 5 bars and 4 spaces
constexpr int CHAR_LEN = 9;
/** Decode the full ASCII string. Return empty string if FormatError occurred.
* ctrl is either "$%/+" for code39 or "abcd" for code93. */
std::string DecodeCode39AndCode93FullASCII(std::string encoded, const char ctrl[4])
{
auto out = encoded.begin();
for (auto in = encoded.cbegin(); in != encoded.cend(); ++in) {
char c = *in;
if (Contains(ctrl, c)) {
char next = *++in; // if in is one short of cend(), then next == 0
if (next < 'A' || next > 'Z')
return {};
if (c == ctrl[0])
c = next - 64; // $A to $Z map to control codes SH to SB
else if (c == ctrl[1])
c = PERCENTAGE_MAPPING[next - 'A'];
else if (c == ctrl[2])
c = next - 32; // /A to /O map to ! to , and /Z maps to :
else
c = next + 32; // +A to +Z map to a to z
}
*out++ = c;
}
encoded.erase(out, encoded.end());
return encoded;
}
Barcode Code39Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
{
// minimal number of characters that must be present (including start, stop and checksum characters)
int minCharCount = _opts.validateCode39CheckSum() ? 4 : 3;
auto isStartOrStopSymbol = [](char c) { return c == '*'; };
// provide the indices with the narrow bars/spaces which have to be equally wide
constexpr auto START_PATTERN = FixedSparcePattern<CHAR_LEN, 6>{0, 2, 3, 5, 7, 8};
// quiet zone is half the width of a character symbol
constexpr float QUIET_ZONE_SCALE = 0.5f;
next = FindLeftGuard(next, minCharCount * CHAR_LEN, START_PATTERN, QUIET_ZONE_SCALE * 12);
if (!next.isValid())
return {};
if (!isStartOrStopSymbol(DecodeNarrowWidePattern(next, CHARACTER_ENCODINGS, ALPHABET))) // read off the start pattern
return {};
int xStart = next.pixelsInFront();
int maxInterCharacterSpace = next.sum() / 2; // spec actually says 1 narrow space, width/2 is about 4
std::string txt;
txt.reserve(20);
do {
// check remaining input width and inter-character space
if (!next.skipSymbol() || !next.skipSingle(maxInterCharacterSpace))
return {};
txt += DecodeNarrowWidePattern(next, CHARACTER_ENCODINGS, ALPHABET);
if (txt.back() == 0)
return {};
} while (!isStartOrStopSymbol(txt.back()));
txt.pop_back(); // remove asterisk
// check txt length and whitespace after the last char. See also FindStartPattern.
if (Size(txt) < minCharCount - 2 || !next.hasQuietZoneAfter(QUIET_ZONE_SCALE))
return {};
auto lastChar = txt.back();
txt.pop_back();
int checksum = TransformReduce(txt, 0, [](char c) { return IndexOf(ALPHABET, c); });
bool hasValidCheckSum = lastChar == ALPHABET[checksum % 43];
if (!hasValidCheckSum)
txt.push_back(lastChar);
const char shiftChars[] = "$%/+";
auto fullASCII = _opts.tryCode39ExtendedMode() ? DecodeCode39AndCode93FullASCII(txt, shiftChars) : "";
bool hasFullASCII = !fullASCII.empty() && std::find_first_of(txt.begin(), txt.end(), shiftChars, shiftChars + 4) != txt.end();
if (hasFullASCII)
txt = fullASCII;
if (hasValidCheckSum)
txt.push_back(lastChar);
Error error = _opts.validateCode39CheckSum() && !hasValidCheckSum ? ChecksumError() : Error();
// Symbology identifier modifiers ISO/IEC 16388:2007 Annex C Table C.1
constexpr const char symbologyModifiers[4] = { '0', '1' /*checksum*/, '4' /*full ASCII*/, '5' /*checksum + full ASCII*/ };
SymbologyIdentifier symbologyIdentifier = {'A', symbologyModifiers[(int)hasValidCheckSum + 2 * (int)hasFullASCII]};
int xStop = next.pixelsTillEnd();
return {std::move(txt), rowNumber, xStart, xStop, BarcodeFormat::Code39, symbologyIdentifier, error};
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode39Reader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,794
|
```c++
/*
*/
#include "ODCode93Writer.h"
#include "ODWriterHelper.h"
#include "Utf.h"
#include "ZXAlgorithms.h"
#include "ZXTestSupport.h"
#include <stdexcept>
namespace ZXing::OneD {
static const char ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%abcd*";
/**
* These represent the encodings of characters, as patterns of wide and narrow bars.
* The 9 least-significant bits of each int correspond to the pattern of wide and narrow.
*/
static const int CHARACTER_ENCODINGS[] = {
0x114, 0x148, 0x144, 0x142, 0x128, 0x124, 0x122, 0x150, 0x112, 0x10A, // 0-9
0x1A8, 0x1A4, 0x1A2, 0x194, 0x192, 0x18A, 0x168, 0x164, 0x162, 0x134, // A-J
0x11A, 0x158, 0x14C, 0x146, 0x12C, 0x116, 0x1B4, 0x1B2, 0x1AC, 0x1A6, // K-T
0x196, 0x19A, 0x16C, 0x166, 0x136, 0x13A, // U-Z
0x12E, 0x1D4, 0x1D2, 0x1CA, 0x16E, 0x176, 0x1AE, // - - %
0x126, 0x1DA, 0x1D6, 0x132, 0x15E, // Control chars? $-*
};
static_assert(Size(ALPHABET) - 1 == Size(CHARACTER_ENCODINGS), "table size mismatch");
static const int ASTERISK_ENCODING = CHARACTER_ENCODINGS[47];
static int AppendPattern(std::vector<bool>& target, int pos, int a)
{
for (int i = 0; i < 9; i++) {
int temp = a & (1 << (8 - i));
target[pos + i] = temp != 0;
}
return 9;
}
static int ComputeChecksumIndex(const std::string& contents, int maxWeight)
{
int weight = 1;
int total = 0;
for (int i = Size(contents) - 1; i >= 0; i--) {
int indexInString = IndexOf(ALPHABET, contents[i]);
total += indexInString * weight;
if (++weight > maxWeight) {
weight = 1;
}
}
return total % 47;
}
ZXING_EXPORT_TEST_ONLY
std::string Code93ConvertToExtended(const std::wstring& contents)
{
size_t length = contents.length();
std::string extendedContent;
extendedContent.reserve(length * 2);
for (size_t i = 0; i < length; i++) {
int character = contents[i];
// ($)=a, (%)=b, (/)=c, (+)=d. see Code93Reader.ALPHABET
if (character == 0) {
// NUL: (%)U
extendedContent.append("bU");
}
else if (character <= 26) {
// SOH - SUB: ($)A - ($)Z
extendedContent.push_back('a');
extendedContent.push_back((char)('A' + character - 1));
}
else if (character <= 31) {
// ESC - US: (%)A - (%)E
extendedContent.push_back('b');
extendedContent.push_back((char)('A' + character - 27));
}
else if (character == ' ' || character == '$' || character == '%' || character == '+') {
// space $ % +
extendedContent.push_back(character);
}
else if (character <= ',') {
// ! " # & ' ( ) * ,: (/)A - (/)L
extendedContent.push_back('c');
extendedContent.push_back((char)('A' + character - '!'));
}
else if (character <= '9') {
extendedContent.push_back(character);
}
else if (character == ':') {
// :: (/)Z
extendedContent.append("cZ");
}
else if (character <= '?') {
// ; - ?: (%)F - (%)J
extendedContent.push_back('b');
extendedContent.push_back((char)('F' + character - ';'));
}
else if (character == '@') {
// @: (%)V
extendedContent.append("bV");
}
else if (character <= 'Z') {
// A - Z
extendedContent.push_back(character);
}
else if (character <= '_') {
// [ - _: (%)K - (%)O
extendedContent.push_back('b');
extendedContent.push_back((char)('K' + character - '['));
}
else if (character == '`') {
// `: (%)W
extendedContent.append("bW");
}
else if (character <= 'z') {
// a - z: (*)A - (*)Z
extendedContent.push_back('d');
extendedContent.push_back((char)('A' + character - 'a'));
}
else if (character <= 127) {
// { - DEL: (%)P - (%)T
extendedContent.push_back('b');
extendedContent.push_back((char)('P' + character - '{'));
}
else {
throw std::invalid_argument(std::string("Requested content contains a non-encodable character: '") + (char)character + "'");
}
}
return extendedContent;
}
BitMatrix
Code93Writer::encode(const std::wstring& contents_, int width, int height) const
{
std::string contents = Code93ConvertToExtended(contents_);
size_t length = contents.length();
if (length == 0) {
throw std::invalid_argument("Found empty contents");
}
if (length > 80) {
throw std::invalid_argument("Requested contents should be less than 80 digits long after converting to extended encoding");
}
//length of code + 2 start/stop characters + 2 checksums, each of 9 bits, plus a termination bar
size_t codeWidth = (contents.length() + 2 + 2) * 9 + 1;
std::vector<bool> result(codeWidth, false);
//start character (*)
int pos = AppendPattern(result, 0, ASTERISK_ENCODING);
for (size_t i = 0; i < length; i++) {
int indexInString = IndexOf(ALPHABET, contents[i]);
pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[indexInString]);
}
//add two checksums
int check1 = ComputeChecksumIndex(contents, 20);
pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[check1]);
//append the contents to reflect the first checksum added
contents += static_cast<wchar_t>(ALPHABET[check1]);
int check2 = ComputeChecksumIndex(contents, 15);
pos += AppendPattern(result, pos, CHARACTER_ENCODINGS[check2]);
//end character (*)
pos += AppendPattern(result, pos, ASTERISK_ENCODING);
//termination bar (single black bar)
result[pos] = true;
return WriterHelper::RenderResult(result, width, height, _sidesMargin >= 0 ? _sidesMargin : 10);
}
BitMatrix Code93Writer::encode(const std::string& contents, int width, int height) const
{
return encode(FromUtf8(contents), width, height);
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODCode93Writer.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 1,772
|
```c++
/*
*/
#include "ODDataBarExpandedReader.h"
#include "BarcodeFormat.h"
#include "DecoderResult.h"
#include "DetectorResult.h"
#include "ODDataBarCommon.h"
#include "ODDataBarExpandedBitDecoder.h"
#include "Barcode.h"
#include <cmath>
#include <map>
#include <vector>
namespace ZXing::OneD {
using namespace DataBar;
static bool IsFinderPattern(int a, int b, int c, int d, int e)
{
return IsFinder(a, b, c, d, e) && (c > 3 * e);
};
static bool IsCharacterPair(const PatternView& v)
{
float modSizeRef = ModSizeFinder(v);
return IsCharacter(LeftChar(v), 17, modSizeRef) &&
(v.size() == HALF_PAIR_SIZE || IsCharacter(RightChar(v), 17, modSizeRef));
}
static bool IsL2RPair(const PatternView& v)
{
return IsFinderPattern(v[8], v[9], v[10], v[11], v[12]) && IsCharacterPair(v);
}
static bool IsR2LPair(const PatternView& v)
{
return IsFinderPattern(v[12], v[11], v[10], v[9], v[8]) && IsCharacterPair(v);
}
static Character ReadDataCharacter(const PatternView& view, int finder, bool reversed)
{
constexpr int SYMBOL_WIDEST[] = {7, 5, 4, 3, 1};
constexpr int EVEN_TOTAL_SUBSET[] = {4, 20, 52, 104, 204};
constexpr int GSUM[] = {0, 348, 1388, 2948, 3988};
Array4I oddCounts = {}, evnCounts = {};
if (!ReadDataCharacterRaw(view, 17, reversed, oddCounts, evnCounts))
return {};
int weightRow = 4 * (std::abs(finder) - 1) + (finder < 0) * 2 + reversed;
auto calcChecksum = [weightRow](const Array4I& counts, bool even) {
static constexpr std::array<std::array<int, 8>, 24> WEIGHTS = {{
{0, 0, 0, 0, 0, 0, 0, 0}, // the check character itself
{1, 3, 9, 27, 81, 32, 96, 77},
{20, 60, 180, 118, 143, 7, 21, 63},
{189, 145, 13, 39, 117, 140, 209, 205},
{193, 157, 49, 147, 19, 57, 171, 91},
{62, 186, 136, 197, 169, 85, 44, 132},
{185, 133, 188, 142, 4, 12, 36, 108},
{113, 128, 173, 97, 80, 29, 87, 50},
{150, 28, 84, 41, 123, 158, 52, 156},
{46, 138, 203, 187, 139, 206, 196, 166},
{76, 17, 51, 153, 37, 111, 122, 155},
{43, 129, 176, 106, 107, 110, 119, 146},
{16, 48, 144, 10, 30, 90, 59, 177},
{109, 116, 137, 200, 178, 112, 125, 164},
{70, 210, 208, 202, 184, 130, 179, 115},
{134, 191, 151, 31, 93, 68, 204, 190},
{148, 22, 66, 198, 172, 94, 71, 2},
{6, 18, 54, 162, 64, 192, 154, 40},
{120, 149, 25, 75, 14, 42, 126, 167},
{79, 26, 78, 23, 69, 207, 199, 175},
{103, 98, 83, 38, 114, 131, 182, 124},
{161, 61, 183, 127, 170, 88, 53, 159},
{55, 165, 73, 8, 24, 72, 5, 15},
{45, 135, 194, 160, 58, 174, 100, 89},
}};
const int* weights = &WEIGHTS[weightRow][even];
return TransformReduce(counts, 0, [i = 0, weights](int c) mutable { return c * weights[2 * i++]; });
};
int checksum = calcChecksum(oddCounts, false) + calcChecksum(evnCounts, true);
int oddSum = Reduce(oddCounts);
assert ((oddSum & 1) == 0 && oddSum <= 13 && oddSum >= 4);
int group = (13 - oddSum) / 2;
int oddWidest = SYMBOL_WIDEST[group];
int evnWidest = 9 - oddWidest;
int vOdd = GetValue(oddCounts, oddWidest, true);
int vEvn = GetValue(evnCounts, evnWidest, false);
int tEvn = EVEN_TOTAL_SUBSET[group];
int gSum = GSUM[group];
int value = vOdd * tEvn + vEvn + gSum;
return {value, checksum};
}
using Pairs = std::vector<Pair>;
using Characters = std::vector<Character>;
enum Direction
{
Right = 1,
Left = -1,
};
constexpr int FINDER_A = 1;
constexpr int FINDER_B = 2;
constexpr int FINDER_C = 3;
constexpr int FINDER_D = 4;
constexpr int FINDER_E = 5;
constexpr int FINDER_F = 6;
// A negative number means the finder pattern is laid out right2left. Note: each finder may only occur once per code.
static const std::array<std::vector<int>, 10> FINDER_PATTERN_SEQUENCES = {{
{FINDER_A, -FINDER_A},
{FINDER_A, -FINDER_B, FINDER_B},
{FINDER_A, -FINDER_C, FINDER_B, -FINDER_D},
{FINDER_A, -FINDER_E, FINDER_B, -FINDER_D, FINDER_C},
{FINDER_A, -FINDER_E, FINDER_B, -FINDER_D, FINDER_D, -FINDER_F},
{FINDER_A, -FINDER_E, FINDER_B, -FINDER_D, FINDER_E, -FINDER_F, FINDER_F},
{FINDER_A, -FINDER_A, FINDER_B, -FINDER_B, FINDER_C, -FINDER_C, FINDER_D, -FINDER_D},
{FINDER_A, -FINDER_A, FINDER_B, -FINDER_B, FINDER_C, -FINDER_C, FINDER_D, -FINDER_E, FINDER_E},
{FINDER_A, -FINDER_A, FINDER_B, -FINDER_B, FINDER_C, -FINDER_C, FINDER_D, -FINDER_E, FINDER_F, -FINDER_F},
{FINDER_A, -FINDER_A, FINDER_B, -FINDER_B, FINDER_C, -FINDER_D, FINDER_D, -FINDER_E, FINDER_E, -FINDER_F, FINDER_F},
}};
static const std::array<int, 7> VALID_HALF_PAIRS = {{-FINDER_A, FINDER_B, -FINDER_D, FINDER_C, -FINDER_F, FINDER_F, FINDER_E}};
static int ParseFinderPattern(const PatternView& view, Direction dir)
{
static constexpr std::array<FixedPattern<5, 15>, 6> FINDER_PATTERNS = {{
{1, 8, 4, 1, 1}, // A
{3, 6, 4, 1, 1}, // B
{3, 4, 6, 1, 1}, // C
{3, 2, 8, 1, 1}, // D
{2, 6, 5, 1, 1}, // E
{2, 2, 9, 1, 1}, // F
}};
// TODO: c++20 constexpr inversion from FIND_PATTERN?
static constexpr std::array<FixedPattern<5, 15>, 6> REVERSED_FINDER_PATTERNS = {
{{1, 1, 4, 8, 1}, {1, 1, 4, 6, 3}, {1, 1, 6, 4, 3}, {1, 1, 8, 2, 3}, {1, 1, 5, 6, 2}, {1, 1, 9, 2, 2}}};
return ParseFinderPattern(view, dir == Direction::Left, FINDER_PATTERNS, REVERSED_FINDER_PATTERNS);
}
static bool ChecksumIsValid(const Pairs& pairs)
{
auto checksum = TransformReduce(pairs, 0, [](auto p) { return p.left.checksum + p.right.checksum; }) % 211 +
211 * (2 * Size(pairs) - 4 - !pairs.back().right);
return pairs.front().left.value == checksum;
}
// calculate the index (length of the sequence - 2) of the only valid sequence for the given FINDER_A, based on the
// checksum value stored in the first pair's left value. see also ChecksumIsValid().
static int SequenceIndex(Character first)
{
return (first.value / 211 + 4 + 1) / 2 - 2;
}
static bool ChecksumIsValid(Character first)
{
int i = SequenceIndex(first);
return 0 <= i && i < Size(FINDER_PATTERN_SEQUENCES);
}
static Pair ReadPair(const PatternView& view, Direction dir)
{
if (int finder = ParseFinderPattern(Finder(view), dir))
if (auto charL = ReadDataCharacter(LeftChar(view), finder, false))
if (finder != FINDER_A || ChecksumIsValid(charL)) {
auto charR = RightChar(view).isValid() && IsCharacter(RightChar(view), 17, ModSizeFinder(view))
? ReadDataCharacter(RightChar(view), finder, true)
: Character();
if (charR || Contains(VALID_HALF_PAIRS, finder))
return {charL, charR, finder, view.pixelsInFront(),
(charR ? RightChar(view) : Finder(view)).pixelsTillEnd()};
}
return {};
}
template<bool STACKED>
static Pairs ReadRowOfPairs(PatternView& next, int rowNumber)
{
Pairs pairs;
Pair pair;
if constexpr (STACKED) {
// a possible first pair is either left2right starting on a space or right2left starting on a bar.
// it might be a half-pair
next = next.subView(0, HALF_PAIR_SIZE);
while (next.shift(1)) {
if (IsL2RPair(next) && (pair = ReadPair(next, Direction::Right)) &&
(pair.finder != FINDER_A || IsGuard(next[-1], next[11])))
break;
if (next.shift(1) && IsR2LPair(next) && (pair = ReadPair(next, Direction::Left)))
break;
}
} else {
// the only possible first pair is a full, left2right FINDER_A pair starting on a space
// with a guard bar on the left
next = next.subView(-1, FULL_PAIR_SIZE);
while (next.shift(2)) {
if (IsL2RPair(next) && IsGuard(next[-1], next[11]) &&
(pair = ReadPair(next, Direction::Right)).finder == FINDER_A)
break;
}
// after the first full pair, the symbol may end anytime with a half pair
next = next.subView(0, HALF_PAIR_SIZE);
}
if (!pair) {
next = {}; // if we didn't find a single pair, consume the rest of the row
return {};
}
auto flippedDir = [](Pair p) { return p.finder < 0 ? Direction::Right : Direction::Left; };
auto isValidPair = [](Pair p, PatternView v) { return p.right || IsGuard(v[p.finder < 0 ? 9 : 11], v[13]); };
do {
pair.y = rowNumber;
pairs.push_back(pair);
} while (pair.right && next.shift(FULL_PAIR_SIZE) && (pair = ReadPair(next, flippedDir(pair))) &&
isValidPair(pair, next));
return pairs;
}
using PairMap = std::map<int, Pairs>;
// inserts all pairs inside row into the PairMap or increases their count respectively.
static bool Insert(PairMap& all, Pairs&& row)
{
bool res = false;
for (const Pair& pair : row) {
auto& pairs = all[pair.finder];
if (auto i = Find(pairs, pair); i != pairs.end()) {
i->count++;
// bubble sort the pairs with the highest view count to the front so we test them first in FindValidSequence
while (i != pairs.begin() && i[0].count > i[-1].count) {
std::swap(i[-1], i[0]);
--i;
}
} else
pairs.push_back(pair);
res = true;
}
return res;
}
template <typename ITER>
static bool FindValidSequence(const PairMap& all, ITER begin, ITER end, Pairs& stack)
{
if (begin == end)
return ChecksumIsValid(stack);
if (auto ppairs = all.find(*begin); ppairs != all.end()) {
// only try the N most common pairs, this means the absolute maximum number of ChecksumIsValid() evaluations
// is N^11 (11 is the maximum sequence length).
constexpr int N = 2;
// TODO c++20 ranges::views::take()
auto& pairs = ppairs->second;
int n = 0;
for (auto p = pairs.begin(), pend = pairs.end(); p != pend && n < N; ++p, ++n) {
// skip p if it is a half-pair but not the last one in the sequence
if (!p->right && std::next(begin) != end)
continue;
// to lower the chance of a misread, one can require each pair to have been seen at least N times.
// e.g: if (p.count < 2) break;
stack.push_back(*p);
if (FindValidSequence(all, std::next(begin), end, stack))
return true;
stack.pop_back();
}
}
return false;
}
static Pairs FindValidSequence(PairMap& all)
{
Pairs stack;
for (const auto& first : all[FINDER_A]) {
int sequenceIndex = SequenceIndex(first.left);
// if we have not seen enough pairs to possibly complete the sequence, wait for more
if (Size(all) < sequenceIndex + 2)
continue;
auto& sequence = FINDER_PATTERN_SEQUENCES[sequenceIndex];
stack.push_back(first);
// recursively fill the stack with pairs according to the valid finder sequence
if (FindValidSequence(all, std::next(std::begin(sequence)), std::end(sequence), stack))
break;
stack.pop_back();
}
return stack;
}
static void RemovePairs(PairMap& all, const Pairs& pairs)
{
for(const auto& p : pairs)
if (auto i = Find(all[p.finder], p); i != all[p.finder].end())
if (--i->count == 0)
all[p.finder].erase(i);
}
static BitArray BuildBitArray(const Pairs& pairs)
{
BitArray res;
res.appendBits(pairs.front().right.value, 12);
for (auto p = ++pairs.begin(); p != pairs.end(); ++p) {
res.appendBits(p->left.value, 12);
if (p->right)
res.appendBits(p->right.value, 12);
}
return res;
}
struct DBERState : public RowReader::DecodingState
{
PairMap allPairs;
};
Barcode DataBarExpandedReader::decodePattern(int rowNumber, PatternView& view, std::unique_ptr<RowReader::DecodingState>& state) const
{
#if 0 // non-stacked version
auto pairs = ReadRowOfPairs<false>(view, rowNumber);
if (pairs.empty() || !ChecksumIsValid(pairs))
return {};
#else
if (!state)
state.reset(new DBERState);
auto& allPairs = static_cast<DBERState*>(state.get())->allPairs;
// Stacked codes can be laid out in a number of ways. The following rules apply:
// * the first row starts with FINDER_A in left-to-right (l2r) layout
// * pairs in l2r layout start with a space, r2l ones with a bar
// * l2r and r2l finders always alternate
// * rows may contain any number of pairs
// * even rows may be reversed
// * a l2r pair that starts with a bar is actually a r2l pair on a reversed line
// * the last pair of the symbol may be missing the right character
//
// 3 examples: (r == l2r, l == r2l, R/L == r/l but reversed)
// r l r l | r l | r l r
// L R L R | r | l
if (!Insert(allPairs, ReadRowOfPairs<true>(view, rowNumber)))
return {};
auto pairs = FindValidSequence(allPairs);
if (pairs.empty())
return {};
#endif
auto txt = DecodeExpandedBits(BuildBitArray(pairs));
if (txt.empty())
return {};
RemovePairs(allPairs, pairs);
// TODO: EstimatePosition misses part of the symbol in the stacked case where the last row contains less pairs than
// the first
// Symbology identifier: ISO/IEC 24724:2011 Section 9 and GS1 General Specifications 5.1.3 Figure 5.1.3-2
return {DecoderResult(Content(ByteArray(txt), {'e', '0', 0, AIFlag::GS1}))
.setLineCount(EstimateLineCount(pairs.front(), pairs.back())),
{{}, EstimatePosition(pairs.front(), pairs.back())}, BarcodeFormat::DataBarExpanded};
}
} // namespace ZXing::OneD
```
|
/content/code_sandbox/core/src/oned/ODDataBarExpandedReader.cpp
|
c++
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 4,283
|
```objective-c
/* gbk.h - tables for Unicode to/from ECI 31 GBK (excl. GB 2312), generated by "tools/gen_zueci_mb_h.php" from
"path_to_url" */
/*
libzueci - an open source UTF-8 ECI library adapted from libzint
*/
#ifndef ZUECI_GBK_H
#define ZUECI_GBK_H
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode usage bit-flags for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_gbk_uro_u[1307] = {
0x8074, 0x8084, 0xC24B, 0x10AA, 0x0457, 0x0CA2, 0xFDBC, 0xBFF4,
0x04BF, 0x72C1, 0x8408, 0x73D3, 0x9100, 0x1C05, 0xE2C5, 0x5712,
0x19FD, 0x307C, 0x730A, 0xCAAA, 0x1FB7, 0x0054, 0x6D46, 0x27A6,
0x54E7, 0xD76D, 0x2816, 0x7FDF, 0x3BC7, 0x0A7C, 0x18B5, 0xBAF5,
0x4FFF, 0x68EB, 0x889D, 0xABFF, 0x2E77, 0xEBDF, 0xEFDF, 0x373F,
0xDEDE, 0xFFFF, 0xEC57, 0xF3FB, 0x7FFF, 0xFBBF, 0x8F3F, 0xF7D7,
0xF73F, 0xFFFB, 0xFFFD, 0x7FFF, 0xD484, 0xEB8D, 0x86DB, 0xC404,
0xCCD8, 0xE51B, 0x67CA, 0xC710, 0x652E, 0xD7FD, 0x57EC, 0x4096,
0x9A30, 0xD039, 0x94EE, 0x5036, 0xCBF0, 0xAFAC, 0x795D, 0x5FFB,
0xFEF9, 0x17F6, 0xC0F0, 0x3FF1, 0xF577, 0x7EBA, 0xFFEF, 0x39FE,
0x5E9E, 0xD91E, 0xBBB4, 0x31FF, 0x3855, 0x2B11, 0x3520, 0x7A44,
0xC58B, 0x5ADF, 0xBC93, 0x77BF, 0xC0F9, 0x742D, 0x0086, 0xC410,
0x08A5, 0x1710, 0x0434, 0xA4C9, 0xF2B6, 0xE402, 0xFEAB, 0xC611,
0x27AA, 0xD18A, 0x4027, 0x56E5, 0x0C28, 0x0940, 0x981F, 0x4BF3,
0x7D3D, 0xF7EC, 0x2B62, 0x2F74, 0xF9A5, 0xEF9E, 0x8B0D, 0xA61F,
0x7060, 0x4CED, 0xFF7F, 0x9555, 0xCDCF, 0x4FA1, 0x6285, 0x9F53,
0x2CFC, 0x36FF, 0xCF67, 0x75A9, 0x8FFF, 0xEC6F, 0xE0EB, 0xE7BD,
0x3F9F, 0xFFF7, 0x7FF7, 0xEF7F, 0xFBFF, 0x136F, 0xD7E8, 0x19CC,
0xF8A7, 0x6FFF, 0x08F7, 0xB1F6, 0x0B7A, 0x037C, 0x50AC, 0xE737,
0xE783, 0xF7F3, 0x9520, 0xFEEB, 0x37F3, 0x58CB, 0x5FEE, 0xD8EF,
0xD73A, 0xBDDD, 0xFBEC, 0xFFDE, 0xCFEF, 0xBEED, 0xE7DF, 0xBFFF,
0xFDD4, 0x39F3, 0xFCFF, 0xEFFF, 0xFFDD, 0xFFDD, 0xA7EF, 0xFDB6,
0x5F6B, 0x698F, 0x114F, 0xE86D, 0x3469, 0xFA0D, 0xFFDA, 0xDCA7,
0xDA21, 0xBD33, 0x30C7, 0xB5FB, 0xF3BF, 0xCA60, 0xEED7, 0x75FF,
0xEC05, 0x6EF5, 0xFDD6, 0xEFA9, 0xF9BE, 0xFBDF, 0xFB7B, 0x7B0F,
0xFFFF, 0xF3FB, 0xFBFF, 0xBED3, 0xEDF9, 0xEEAB, 0xF5B4, 0xFFFD,
0xFDFF, 0xFF3F, 0xFFFF, 0xFF6B, 0xFFFE, 0x4044, 0xE983, 0xDBD4,
0x6444, 0x8057, 0xF380, 0x1C86, 0xEF0B, 0x1FF2, 0xBECD, 0x60FE,
0x79AD, 0xCA8D, 0xEF4B, 0x00ED, 0x30D8, 0xBDDC, 0x3F94, 0x79FD,
0xCEF9, 0xE02C, 0xC5F3, 0x5E55, 0xF7ED, 0xFDFB, 0xDA8D, 0xF7FE,
0xBF33, 0xB7AF, 0x9D2F, 0x9FEF, 0xE37F, 0xD6FF, 0x65FF, 0xFFEF,
0xFFFB, 0xDDFF, 0xFFFF, 0xFF7F, 0xDFDF, 0x97FF, 0x3419, 0x9F61,
0x6E91, 0xC08C, 0x9F3F, 0xC67D, 0xEFCB, 0xB7CF, 0xFFF9, 0x42A3,
0x732E, 0x2904, 0xDF1E, 0xBC17, 0xF9FF, 0xF7B1, 0xFAFF, 0x3B2F,
0x72E0, 0x7655, 0x591E, 0xE9FD, 0xFFFE, 0xDE12, 0xC9A9, 0xE574,
0xE048, 0xEC5A, 0x9AFD, 0xCF5F, 0x4D87, 0xDC38, 0x936C, 0x16DD,
0x1B80, 0xC58B, 0x701C, 0x67DF, 0xD7F1, 0xD9DA, 0x4063, 0x40B6,
0xCDE7, 0x53AB, 0x46B6, 0xE6E9, 0xF39F, 0x4ADD, 0x043E, 0xF9A6,
0x1CBC, 0x7BDF, 0xF726, 0x7FFF, 0xAAFF, 0xDFDD, 0xFE7B, 0xFF5E,
0xB7FF, 0xDFEF, 0xEC7F, 0xBF7F, 0xF2FB, 0xFFE9, 0xFFBF, 0x7FDF,
0x02BF, 0x7218, 0xABC9, 0x1F67, 0x8474, 0xF6E1, 0x0137, 0x2DB6,
0xF9EE, 0x7211, 0xE6C8, 0x45DD, 0x880B, 0x6022, 0x0C13, 0x0F25,
0xBC79, 0x13BD, 0x72C0, 0xD9FB, 0x0593, 0x3FDE, 0x9D71, 0xF33D,
0x287A, 0xFEBA, 0x8852, 0xAA66, 0x1DAF, 0xBFBA, 0xD9F4, 0x5EAB,
0x67D8, 0xA7E6, 0xCBBC, 0x5BEF, 0xFA0D, 0xBEEB, 0xDD7F, 0xF8FF,
0xFF4B, 0xBD99, 0x8DEF, 0xEA5E, 0x9FDA, 0xBE7A, 0xFFAB, 0xFFFF,
0xFDFE, 0xFEFB, 0x37DF, 0x348F, 0x6CDF, 0x959D, 0xE7B3, 0xFF6A,
0xE77F, 0x6574, 0x554D, 0xCDFE, 0x2785, 0xFF3B, 0x0C1A, 0xFB3C,
0x2BB2, 0x5DC7, 0x5E5E, 0xAF8D, 0x67F5, 0x7B03, 0x3EAD, 0xBB2E,
0xEF6B, 0xDF3D, 0xBE7F, 0xBDEF, 0xFFFF, 0xC5FF, 0xFDBF, 0x2D62,
0xD0FE, 0x574E, 0x42BF, 0xDBCD, 0x2CB2, 0x2FB4, 0x58DC, 0x2F52,
0xF56D, 0x8A5E, 0x5253, 0xFE16, 0x7FE5, 0x88E0, 0x6DDA, 0x5FE4,
0x205E, 0xDF35, 0xF9FD, 0x8C73, 0xA880, 0xFFC4, 0xF400, 0xFF2F,
0x7F95, 0xFF77, 0x5E3B, 0xFFD6, 0xD5FA, 0xFADB, 0xBFF6, 0xE9DC,
0x97DD, 0x7FFA, 0xDFEE, 0x5DEE, 0xFFFB, 0x9B6F, 0xB7B6, 0xEC7D,
0xDC2A, 0xE6CF, 0xD67F, 0xF76D, 0xABFD, 0x77EE, 0xDFFE, 0x5FFB,
0xFBFF, 0x7E7F, 0x7AFD, 0x9FDD, 0xFF6F, 0xF4FE, 0xFFDD, 0xEDFD,
0xBFEE, 0xFF7C, 0xE5FE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFF60, 0xB97B, 0xED37, 0xFDFF, 0xFB03, 0xE5FF,
0xD121, 0xF3B3, 0xFBFD, 0x7F47, 0x57D9, 0xF503, 0x73FD, 0xDDD7,
0x5F1F, 0x7084, 0x3829, 0xDECA, 0xF938, 0x074E, 0xF8EC, 0x9DAA,
0x6C91, 0x75E6, 0x9105, 0x04F1, 0xE9CF, 0xB706, 0x32D0, 0x8214,
0xA76D, 0xB17B, 0xB35F, 0x85D1, 0x1215, 0xA9E1, 0x39B6, 0xEE6F,
0xACDB, 0x17C5, 0x3024, 0x7EDB, 0xE70E, 0x9CBD, 0xA7AC, 0xE575,
0x8BDF, 0xDB2C, 0x55C4, 0xFAEB, 0x9FE7, 0x76A7, 0xB7FF, 0x3FFF,
0x7D97, 0x6EFE, 0x7B5B, 0xD329, 0x7779, 0x3B45, 0xFC88, 0xFDEF,
0x7DBB, 0xFFC7, 0x51EE, 0xBFB5, 0xD73F, 0xAEFF, 0x9FBB, 0xEAEB,
0x8CEF, 0xEFFF, 0xFF7D, 0xFDB7, 0xFDFA, 0xBFF9, 0x3FFC, 0xFFFF,
0xFFFF, 0xF3FD, 0xFFF7, 0xFDDF, 0x6FFF, 0xBFFF, 0x47FF, 0x2E9E,
0xB9DE, 0xCD8B, 0x07FF, 0xC475, 0xFAF0, 0x74FF, 0x442F, 0xDD7F,
0xF9FF, 0xF896, 0x7FBF, 0xFFBC, 0xABDF, 0xAFFF, 0xBE2F, 0xDAF3,
0x7BEF, 0x7CEF, 0xEEFE, 0xFDD7, 0xBFF7, 0xFFCF, 0xBF5E, 0xFDFF,
0xFFBF, 0xDFFF, 0xEAFF, 0x541C, 0xCE7F, 0x55BB, 0x3D39, 0x39DB,
0x53EC, 0x7FFB, 0x4FFF, 0xFC2E, 0x9EE1, 0xBD7A, 0x0CFC, 0xE260,
0xBBF5, 0x8717, 0xA1D9, 0x3C6D, 0xDFFF, 0xFF7A, 0x4FFE, 0xBFFF,
0xB56F, 0x77BD, 0x35FB, 0xF372, 0x58FA, 0xBDFC, 0xDD5E, 0xFFFB,
0x7997, 0xF3FE, 0xAA9B, 0xEF86, 0xFFFD, 0x215F, 0xDFFF, 0xBF3E,
0xB774, 0xAFFE, 0xFC7F, 0xFBFF, 0xFFFF, 0xAFFB, 0x3FA2, 0x7F2F,
0x5FEF, 0x68F5, 0x44DF, 0xB250, 0x26DE, 0xE1EF, 0xFB9F, 0x7CEB,
0x77B7, 0x5929, 0x27C4, 0x8CC0, 0xD843, 0xB68B, 0xF223, 0x6DEC,
0xEBD4, 0x745E, 0xD18A, 0x2EC6, 0xCFF6, 0xAFAF, 0x77F7, 0x96FF,
0xB62B, 0xFDB5, 0xBFEF, 0x7FE9, 0x1A9B, 0x7628, 0x3FDF, 0xACE9,
0xD46D, 0x79FF, 0x5CBA, 0xEA1F, 0xFF74, 0xF3FC, 0xE691, 0x1DFF,
0x8FCE, 0x7FF9, 0xE95A, 0x57D6, 0xDFFF, 0xE77F, 0x8553, 0x1EB7,
0xCDF8, 0x4A29, 0xCD17, 0xA06E, 0xAF5E, 0xDF1A, 0x83FF, 0xEF7F,
0x8D7F, 0x6275, 0xFF55, 0xBDE0, 0xF1DD, 0xFDCE, 0xEEFF, 0xFB6B,
0xFFDD, 0xBFF7, 0xFFEF, 0xA3EF, 0xFCBC, 0x0337, 0x5E5A, 0xFA7F,
0x7BCC, 0xFBFF, 0xFF7F, 0x91F7, 0xD5B4, 0x7ED9, 0x5527, 0xD6FE,
0x97B2, 0xBB6F, 0xFFF6, 0x4577, 0xFFBF, 0xFF7D, 0xFFFF, 0x782E,
0xDEA4, 0x4E19, 0xCE9E, 0x7FF7, 0xF7FF, 0x3DBF, 0x5F96, 0x59FF,
0x72A7, 0xB5CD, 0xA28E, 0xAAF5, 0x655F, 0xD2A8, 0xBFFA, 0xB559,
0xDFDE, 0xCF4E, 0xC039, 0xFEED, 0xEF3D, 0xD9F5, 0xBB9D, 0xAF7D,
0x677F, 0x7FBF, 0xFB3F, 0x7EFF, 0xDFFC, 0xFFFF, 0xFFFF, 0xC7E7,
0xFDFF, 0x0E59, 0xBBCB, 0x8DF1, 0xCA5D, 0x6D1F, 0x7EFE, 0xF6FF,
0xFBFF, 0xFFFF, 0x777A, 0xFFFF, 0xFFFF, 0xFFFF, 0xBFFF, 0xFF7F,
0xFFFF, 0xFFFF, 0xBFBF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFF7D, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFB, 0x77FF, 0x4000, 0x1810, 0x0000, 0x0040, 0x1010, 0x0200,
0x0400, 0x4001, 0x0000, 0xFA80, 0xFFCB, 0x7A4C, 0xB8F9, 0xBDE9,
0xABFD, 0x1BEF, 0x7F6D, 0x4CFA, 0xABDD, 0x7ECF, 0xBD9C, 0xE7F4,
0xC784, 0xEC0A, 0xF81A, 0x5615, 0xC3B3, 0xFAEB, 0xF9FF, 0x7FFD,
0xE526, 0x42B7, 0x11C8, 0x0B69, 0x8FA0, 0x813F, 0x404D, 0xCAA0,
0x19BB, 0xBAA0, 0x6FFF, 0xBEB9, 0xE2BF, 0xF9C4, 0x9D5E, 0x01EC,
0x7AFA, 0xC6FD, 0xFAB7, 0xF3F7, 0xEBB0, 0xFFFF, 0xCB77, 0xA7E7,
0xCF88, 0x27EA, 0x42F1, 0xB404, 0x756F, 0x7AFF, 0x3EFF, 0x19E2,
0x12EB, 0x4C79, 0x008D, 0x9C64, 0x026D, 0x2641, 0x7784, 0xF56D,
0x2C01, 0xE34D, 0x467F, 0xE885, 0x7D36, 0x23E8, 0x0004, 0xC67F,
0xBD9F, 0xA6F3, 0xF0FE, 0xC820, 0x6B5C, 0x4EAF, 0xF9DC, 0xDCF8,
0x07A5, 0xCEFD, 0xFE0F, 0xCEFD, 0xFFBF, 0xE17D, 0xC5F5, 0xFA95,
0xA47B, 0xED7F, 0x7FFD, 0x58EB, 0xD9ED, 0x5FB4, 0xEF96, 0x6FFE,
0xEFFF, 0x7B75, 0xE7FD, 0xC07F, 0xF8F7, 0xBDBF, 0xFEEF, 0xB1EB,
0x7F4F, 0xE7FF, 0x3AEF, 0xFD7E, 0x7DFD, 0xEFD6, 0xFDEF, 0x77FF,
0xFFDF, 0xFFBD, 0xFD7F, 0xEEFF, 0x1FFF, 0xBBEC, 0xA7FB, 0x01FD,
0xC3F8, 0xCFD7, 0x6867, 0xFB8C, 0x312E, 0x34EC, 0x9DEF, 0xBCE0,
0xD872, 0xAA53, 0xBDD1, 0x376D, 0xAC7F, 0xFD77, 0xBFC6, 0x87AE,
0xD6D3, 0x7F77, 0x46FF, 0xDBD7, 0xF3BE, 0xF7F1, 0xBBDE, 0xBDFF,
0xFBF7, 0xF797, 0xFFF9, 0xEDFB, 0xCFCE, 0xFD6F, 0xA4C1, 0x1F7A,
0xD6C9, 0xEFBB, 0xD7EB, 0xEF7D, 0xBD99, 0x7CCB, 0xFEC3, 0xACE4,
0xFBFB, 0xF1F2, 0xF3DD, 0xFFAE, 0xFFED, 0x3FFF, 0xFFBF, 0x77FF,
0xFFB5, 0xFFFF, 0xFFFF, 0xFFFF, 0x2009, 0xABB8, 0x7797, 0xFFF7,
0xFF7E, 0xFFFF, 0xFFFF, 0xBFFF, 0xFEFF, 0xFFFF, 0xFFFF, 0xFDFF,
0xF9FF, 0xFFF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFF7F, 0xFFFF, 0xFFBF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEFBF, 0xFFFF,
0xFFFF, 0xFFFF, 0x1000, 0x0802, 0x0080, 0x0001, 0x0400, 0x0000,
0x0200, 0x4000, 0x0000, 0xFF00, 0xED3D, 0xFBDF, 0xF3F9, 0xF8F7,
0xE9DB, 0xFEEF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0x1FFF, 0x0001, 0x0000, 0x0000, 0x8086, 0xD720, 0xFF06,
0xF3CD, 0x7FED, 0xFFF7, 0x2AC5, 0x27A7, 0x133D, 0x62E7, 0xD057,
0x69DF, 0x1FEF, 0x29F3, 0xD9DD, 0xF068, 0xFDF9, 0x4DBF, 0x6FAA,
0x7F5D, 0xAFEE, 0x67FF, 0xFBFB, 0xBFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x043F, 0x0000,
0x1001, 0x2004, 0xF4F7, 0x9DBC, 0xBE49, 0x04C4, 0x908B, 0xDC76,
0x5180, 0x1328, 0x1FB8, 0xA69F, 0x5F69, 0xF670, 0x9ED3, 0x5FCF,
0xF6F2, 0xD555, 0x2BB1, 0xB084, 0x3B4D, 0xC774, 0x5639, 0x9EEF,
0xFFEB, 0xBDFF, 0x7FF3, 0xFDFD, 0x01B7, 0x9B7A, 0x29C1, 0x1C08,
0xC55F, 0xF3F8, 0x1BF3, 0xFBCF, 0x097F, 0xEFFD, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFEF,
0xBFFF, 0xFFFF, 0xBFFF, 0xFFFF, 0xFEFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xBFFF, 0xFFFF, 0xFFFF, 0xFBFF, 0xFFFF,
0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFBFF, 0xFFBF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xBFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF,
0x001F, 0x0142, 0x0000, 0x0000, 0x8080, 0x0418, 0x0040, 0x0800,
0x0000, 0x1000, 0x0081, 0x2008, 0x0908, 0x0420, 0x4001, 0x7FB0,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x10FF, 0x8000,
0x0080, 0x4908, 0xBBF9, 0x4781, 0xC40A, 0x77CE, 0xE869, 0xFF0B,
0x569F, 0xEC6E, 0xFF7F, 0x8DB6, 0x0D0C, 0xFFDB, 0x78FE, 0xBD37,
0x1C2C, 0xAFB7, 0xDBFF, 0xBCFA, 0xFFFF, 0xB5B3, 0xFDD8, 0xEFA7,
0xD7DF, 0xFEE9, 0x57F6, 0xFFEB, 0xFFFF, 0xFFFF, 0xC13F, 0xFF97,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F,
0x4800, 0x0224, 0xFF08, 0xFFFF, 0xBFFF, 0x38D1, 0xFE7F, 0xFFFF,
0xDFFF, 0xFFFE, 0xBFFF, 0xFFFF, 0xFFFF, 0xFFCF, 0x0057, 0x4B08,
0x520C, 0xFC00, 0xFEDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0FFF, 0x0004,
0x6208, 0x0230, 0xFE40, 0xEA3C, 0xE7D8, 0x7EF5, 0x57BD, 0xF5FF,
0x7EF7, 0x7FF7, 0x7FF7, 0xE7FB, 0x5C41, 0xFFED, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x6FFF,
0x9619, 0x23C8, 0x9400, 0xC200, 0x0307, 0x0C06, 0xFFFB, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0x7FFF, 0x4090, 0x1811, 0x2001, 0xA25D, 0xC027, 0x3FF4,
0xF67B, 0x5FF3, 0xFFBF, 0x96EF, 0x1DEF, 0x46ED, 0x795A, 0xA5FF,
0x97FF, 0xFD76, 0x6FFA, 0x957F, 0xFFEF, 0xFFFC, 0xFFFF, 0x7FFF,
0xE006, 0x71FF, 0x003E,
};
/* Multibyte indexes for URO (U+4E00-U+9FFF) block */
static const zueci_u16 zueci_gbk_uro_mb_ind[1307] = {
134, 139, 142, 149, 154, 160, 165, 177,
189, 197, 204, 207, 217, 220, 225, 233,
240, 250, 257, 264, 272, 283, 286, 294,
302, 311, 322, 327, 341, 351, 358, 365,
376, 389, 398, 405, 418, 428, 441, 455,
466, 478, 494, 504, 517, 532, 546, 557,
570, 583, 598, 613, 628, 634, 644, 653,
657, 665, 674, 683, 689, 697, 710, 720,
725, 731, 738, 747, 753, 762, 772, 782,
795, 808, 818, 824, 835, 847, 858, 873,
884, 894, 903, 913, 924, 931, 937, 942,
949, 957, 968, 977, 990, 998, 1006, 1009,
1013, 1018, 1023, 1027, 1034, 1044, 1049, 1061,
1067, 1075, 1082, 1087, 1096, 1100, 1103, 1111,
1121, 1132, 1144, 1151, 1160, 1170, 1182, 1189,
1198, 1203, 1212, 1227, 1235, 1246, 1254, 1260,
1270, 1279, 1291, 1302, 1311, 1324, 1335, 1344,
1356, 1368, 1383, 1397, 1411, 1426, 1435, 1445,
1452, 1462, 1476, 1484, 1494, 1502, 1509, 1515,
1526, 1535, 1548, 1553, 1566, 1577, 1585, 1597,
1608, 1618, 1630, 1642, 1656, 1669, 1681, 1694,
1709, 1720, 1730, 1744, 1759, 1773, 1787, 1799,
1811, 1822, 1831, 1838, 1847, 1854, 1863, 1876,
1886, 1893, 1903, 1910, 1922, 1935, 1941, 1953,
1966, 1973, 1984, 1996, 2007, 2019, 2033, 2046,
2056, 2072, 2085, 2100, 2111, 2123, 2134, 2144,
2159, 2174, 2188, 2204, 2217, 2232, 2235, 2243,
2253, 2258, 2264, 2271, 2277, 2287, 2297, 2308,
2317, 2327, 2335, 2346, 2352, 2358, 2369, 2378,
2390, 2401, 2407, 2417, 2426, 2439, 2453, 2462,
2476, 2487, 2499, 2509, 2522, 2534, 2547, 2559,
2574, 2589, 2603, 2619, 2634, 2648, 2661, 2667,
2676, 2684, 2689, 2701, 2711, 2723, 2735, 2749,
2755, 2764, 2768, 2779, 2788, 2802, 2813, 2827,
2837, 2844, 2853, 2861, 2873, 2888, 2896, 2904,
2913, 2918, 2927, 2938, 2950, 2958, 2966, 2974,
2983, 2988, 2996, 3002, 3014, 3025, 3035, 3040,
3046, 3057, 3066, 3074, 3084, 3096, 3105, 3111,
3121, 3129, 3142, 3152, 3167, 3179, 3192, 3205,
3218, 3232, 3246, 3258, 3272, 3284, 3297, 3312,
3326, 3334, 3340, 3349, 3359, 3365, 3375, 3381,
3390, 3402, 3408, 3416, 3425, 3430, 3434, 3439,
3446, 3456, 3465, 3471, 3483, 3489, 3501, 3510,
3521, 3528, 3540, 3545, 3553, 3563, 3575, 3585,
3595, 3604, 3614, 3624, 3636, 3645, 3657, 3670,
3683, 3695, 3705, 3716, 3726, 3737, 3748, 3761,
3777, 3791, 3805, 3817, 3825, 3836, 3845, 3856,
3868, 3881, 3889, 3897, 3909, 3916, 3929, 3934,
3945, 3953, 3963, 3973, 3983, 3994, 4002, 4012,
4022, 4034, 4046, 4059, 4072, 4088, 4100, 4114,
4121, 4131, 4140, 4149, 4160, 4167, 4176, 4184,
4192, 4203, 4211, 4218, 4228, 4240, 4245, 4255,
4265, 4271, 4282, 4295, 4303, 4307, 4318, 4323,
4336, 4347, 4361, 4371, 4384, 4395, 4407, 4420,
4430, 4441, 4454, 4467, 4478, 4493, 4504, 4515,
4526, 4534, 4545, 4557, 4569, 4581, 4593, 4607,
4620, 4635, 4648, 4660, 4672, 4686, 4698, 4712,
4725, 4738, 4751, 4763, 4779, 4795, 4811, 4827,
4843, 4859, 4875, 4885, 4896, 4907, 4922, 4931,
4944, 4950, 4961, 4975, 4986, 4996, 5004, 5016,
5028, 5039, 5044, 5050, 5060, 5069, 5076, 5086,
5095, 5102, 5112, 5117, 5123, 5134, 5142, 5148,
5152, 5162, 5172, 5183, 5190, 5195, 5203, 5212,
5224, 5234, 5242, 5246, 5258, 5267, 5277, 5286,
5296, 5307, 5316, 5323, 5335, 5347, 5357, 5371,
5385, 5396, 5408, 5419, 5427, 5438, 5446, 5454,
5468, 5480, 5493, 5502, 5514, 5526, 5539, 5551,
5562, 5572, 5587, 5601, 5614, 5627, 5640, 5652,
5668, 5684, 5697, 5712, 5726, 5740, 5755, 5767,
5776, 5787, 5796, 5807, 5815, 5825, 5837, 5844,
5857, 5871, 5880, 5894, 5907, 5919, 5933, 5944,
5955, 5968, 5980, 5993, 6006, 6020, 6034, 6046,
6061, 6076, 6091, 6104, 6110, 6122, 6132, 6141,
6151, 6160, 6174, 6187, 6197, 6206, 6217, 6225,
6231, 6243, 6251, 6259, 6268, 6283, 6296, 6308,
6323, 6334, 6346, 6357, 6367, 6376, 6388, 6399,
6414, 6424, 6437, 6446, 6456, 6471, 6479, 6494,
6506, 6516, 6529, 6542, 6557, 6573, 6586, 6595,
6607, 6620, 6629, 6638, 6644, 6653, 6664, 6677,
6688, 6700, 6707, 6714, 6719, 6726, 6735, 6743,
6753, 6763, 6772, 6779, 6787, 6799, 6811, 6824,
6836, 6845, 6857, 6871, 6883, 6891, 6898, 6911,
6920, 6929, 6942, 6951, 6961, 6973, 6985, 6993,
7005, 7015, 7028, 7037, 7047, 7062, 7075, 7082,
7092, 7102, 7108, 7117, 7124, 7135, 7145, 7156,
7170, 7181, 7189, 7201, 7210, 7221, 7233, 7247,
7259, 7273, 7287, 7302, 7313, 7324, 7331, 7340,
7353, 7363, 7378, 7393, 7403, 7412, 7423, 7431,
7443, 7452, 7464, 7478, 7487, 7502, 7516, 7532,
7540, 7549, 7556, 7566, 7580, 7595, 7607, 7617,
7629, 7638, 7648, 7655, 7665, 7675, 7682, 7695,
7704, 7717, 7727, 7733, 7746, 7758, 7769, 7780,
7792, 7804, 7818, 7831, 7845, 7858, 7874, 7890,
7901, 7916, 7923, 7934, 7943, 7952, 7962, 7975,
7989, 8004, 8020, 8031, 8047, 8063, 8079, 8094,
8109, 8125, 8141, 8155, 8171, 8187, 8203, 8219,
8235, 8251, 8267, 8283, 8298, 8312, 8328, 8344,
8360, 8375, 8389, 8390, 8393, 8393, 8394, 8396,
8397, 8398, 8400, 8400, 8407, 8420, 8428, 8438,
8449, 8461, 8472, 8484, 8493, 8504, 8516, 8526,
8537, 8544, 8551, 8559, 8566, 8575, 8587, 8601,
8615, 8623, 8631, 8636, 8643, 8650, 8658, 8663,
8669, 8678, 8685, 8699, 8710, 8721, 8730, 8740,
8746, 8757, 8768, 8780, 8793, 8802, 8818, 8829,
8840, 8848, 8857, 8864, 8869, 8880, 8893, 8906,
8913, 8921, 8929, 8933, 8940, 8946, 8951, 8959,
8970, 8974, 8983, 8993, 9000, 9010, 9017, 9018,
9029, 9041, 9051, 9062, 9066, 9075, 9085, 9096,
9106, 9113, 9125, 9136, 9148, 9163, 9173, 9183,
9193, 9202, 9215, 9229, 9238, 9249, 9259, 9270,
9283, 9298, 9309, 9322, 9331, 9343, 9356, 9370,
9380, 9392, 9406, 9417, 9430, 9443, 9455, 9469,
9483, 9498, 9512, 9526, 9540, 9553, 9564, 9576,
9584, 9593, 9605, 9613, 9623, 9630, 9638, 9650,
9658, 9666, 9674, 9684, 9694, 9705, 9718, 9729,
9738, 9748, 9761, 9772, 9784, 9796, 9808, 9820,
9834, 9848, 9860, 9874, 9887, 9898, 9911, 9917,
9927, 9936, 9949, 9961, 9974, 9984, 9994, 10005,
10013, 10027, 10037, 10049, 10062, 10076, 10090, 10105,
10119, 10132, 10148, 10164, 10180, 10183, 10192, 10203,
10218, 10232, 10248, 10264, 10279, 10294, 10310, 10326,
10341, 10355, 10370, 10386, 10402, 10418, 10434, 10450,
10466, 10481, 10497, 10512, 10528, 10544, 10560, 10574,
10590, 10606, 10622, 10623, 10625, 10626, 10627, 10628,
10628, 10629, 10630, 10630, 10638, 10649, 10663, 10675,
10687, 10698, 10712, 10728, 10744, 10760, 10776, 10792,
10808, 10824, 10837, 10838, 10838, 10838, 10842, 10849,
10859, 10870, 10883, 10898, 10905, 10914, 10922, 10931,
10939, 10950, 10962, 10971, 10982, 10989, 11002, 11013,
11023, 11035, 11047, 11060, 11074, 11089, 11105, 11121,
11137, 11153, 11169, 11185, 11201, 11217, 11233, 11240,
11240, 11242, 11244, 11256, 11266, 11275, 11279, 11285,
11295, 11299, 11304, 11313, 11323, 11333, 11342, 11352,
11364, 11375, 11384, 11392, 11397, 11406, 11415, 11423,
11435, 11449, 11463, 11476, 11490, 11497, 11507, 11513,
11517, 11527, 11538, 11548, 11561, 11570, 11584, 11600,
11616, 11632, 11648, 11664, 11680, 11696, 11712, 11728,
11743, 11758, 11774, 11789, 11805, 11820, 11836, 11852,
11868, 11884, 11900, 11916, 11931, 11947, 11963, 11978,
11994, 12009, 12025, 12041, 12057, 12072, 12087, 12103,
12119, 12135, 12151, 12167, 12182, 12198, 12214, 12229,
12245, 12250, 12253, 12253, 12253, 12255, 12258, 12259,
12260, 12260, 12261, 12263, 12265, 12268, 12270, 12272,
12282, 12298, 12314, 12330, 12346, 12362, 12378, 12387,
12388, 12389, 12393, 12405, 12411, 12416, 12427, 12435,
12446, 12456, 12466, 12481, 12490, 12495, 12509, 12520,
12531, 12537, 12549, 12563, 12574, 12590, 12600, 12611,
12623, 12636, 12648, 12659, 12673, 12689, 12705, 12714,
12727, 12743, 12759, 12775, 12791, 12807, 12823, 12839,
12844, 12846, 12849, 12858, 12874, 12889, 12896, 12910,
12926, 12941, 12956, 12971, 12987, 13003, 13017, 13022,
13027, 13032, 13038, 13052, 13068, 13084, 13100, 13116,
13132, 13148, 13164, 13180, 13196, 13212, 13228, 13240,
13241, 13245, 13248, 13256, 13265, 13275, 13287, 13298,
13312, 13325, 13339, 13353, 13366, 13372, 13386, 13402,
13418, 13434, 13450, 13466, 13482, 13498, 13514, 13530,
13546, 13562, 13578, 13594, 13610, 13626, 13642, 13658,
13672, 13679, 13685, 13688, 13691, 13696, 13700, 13715,
13731, 13747, 13763, 13779, 13795, 13811, 13827, 13843,
13859, 13875, 13891, 13907, 13923, 13939, 13955, 13971,
13987, 14003, 14018, 14021, 14025, 14027, 14035, 14041,
14052, 14064, 14076, 14091, 14102, 14113, 14122, 14131,
14143, 14156, 14168, 14180, 14191, 14206, 14220, 14236,
14251, 14256, 14268,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Unicode codepoints sorted */
static const zueci_u16 zueci_gbk_u_u[209] = {
0x00B7, 0x0144, 0x0148, 0x0251, 0x0261, 0x02CA, 0x02CB, 0x02D9,
0x2010, 0x2013, 0x2014, 0x2015, 0x2025, 0x2035, 0x2105, 0x2109,
0x2121, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176,
0x2177, 0x2178, 0x2179, 0x2196, 0x2197, 0x2198, 0x2199, 0x2215,
0x221F, 0x2223, 0x2252, 0x2266, 0x2267, 0x2295, 0x22BF, 0x2550,
0x2551, 0x2552, 0x2553, 0x2554, 0x2555, 0x2556, 0x2557, 0x2558,
0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E, 0x255F, 0x2560,
0x2561, 0x2562, 0x2563, 0x2564, 0x2565, 0x2566, 0x2567, 0x2568,
0x2569, 0x256A, 0x256B, 0x256C, 0x256D, 0x256E, 0x256F, 0x2570,
0x2571, 0x2572, 0x2573, 0x2581, 0x2582, 0x2583, 0x2584, 0x2585,
0x2586, 0x2587, 0x2588, 0x2589, 0x258A, 0x258B, 0x258C, 0x258D,
0x258E, 0x258F, 0x2593, 0x2594, 0x2595, 0x25BC, 0x25BD, 0x25E2,
0x25E3, 0x25E4, 0x25E5, 0x2609, 0x3006, 0x3007, 0x3012, 0x301D,
0x301E, 0x3021, 0x3022, 0x3023, 0x3024, 0x3025, 0x3026, 0x3027,
0x3028, 0x3029, 0x309B, 0x309C, 0x309D, 0x309E, 0x30FC, 0x30FD,
0x30FE, 0x3231, 0x32A3, 0x338E, 0x338F, 0x339C, 0x339D, 0x339E,
0x33A1, 0x33C4, 0x33CE, 0x33D1, 0x33D2, 0x33D5, 0xF92C, 0xF979,
0xF995, 0xF9E7, 0xF9F1, 0xFA0C, 0xFA0D, 0xFA0E, 0xFA0F, 0xFA11,
0xFA13, 0xFA14, 0xFA18, 0xFA1F, 0xFA20, 0xFA21, 0xFA23, 0xFA24,
0xFA27, 0xFA28, 0xFA29, 0xFE30, 0xFE31, 0xFE33, 0xFE34, 0xFE35,
0xFE36, 0xFE37, 0xFE38, 0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D,
0xFE3E, 0xFE3F, 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE49,
0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F, 0xFE50, 0xFE51,
0xFE52, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE59, 0xFE5A, 0xFE5B,
0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F, 0xFE60, 0xFE61, 0xFE62, 0xFE63,
0xFE64, 0xFE65, 0xFE66, 0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0xFFE2,
0xFFE4,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_ECI
/* Multibyte values sorted in Unicode order */
static const zueci_u16 zueci_gbk_u_mb[14348] = {
0xA1A4, 0xA8BD, 0xA8BE, 0xA8BB, 0xA8C0, 0xA840, 0xA841, 0xA842,
0xA95C, 0xA843, 0xA1AA, 0xA844, 0xA845, 0xA846, 0xA847, 0xA848,
0xA959, 0xA2A1, 0xA2A2, 0xA2A3, 0xA2A4, 0xA2A5, 0xA2A6, 0xA2A7,
0xA2A8, 0xA2A9, 0xA2AA, 0xA849, 0xA84A, 0xA84B, 0xA84C, 0xA84D,
0xA84E, 0xA84F, 0xA850, 0xA851, 0xA852, 0xA892, 0xA853, 0xA854,
0xA855, 0xA856, 0xA857, 0xA858, 0xA859, 0xA85A, 0xA85B, 0xA85C,
0xA85D, 0xA85E, 0xA85F, 0xA860, 0xA861, 0xA862, 0xA863, 0xA864,
0xA865, 0xA866, 0xA867, 0xA868, 0xA869, 0xA86A, 0xA86B, 0xA86C,
0xA86D, 0xA86E, 0xA86F, 0xA870, 0xA871, 0xA872, 0xA873, 0xA874,
0xA875, 0xA876, 0xA877, 0xA878, 0xA879, 0xA87A, 0xA87B, 0xA87C,
0xA87D, 0xA87E, 0xA880, 0xA881, 0xA882, 0xA883, 0xA884, 0xA885,
0xA886, 0xA887, 0xA888, 0xA889, 0xA88A, 0xA88B, 0xA88C, 0xA88D,
0xA88E, 0xA88F, 0xA890, 0xA891, 0xA965, 0xA996, 0xA893, 0xA894,
0xA895, 0xA940, 0xA941, 0xA942, 0xA943, 0xA944, 0xA945, 0xA946,
0xA947, 0xA948, 0xA961, 0xA962, 0xA966, 0xA967, 0xA960, 0xA963,
0xA964, 0xA95A, 0xA949, 0xA94A, 0xA94B, 0xA94C, 0xA94D, 0xA94E,
0xA94F, 0xA950, 0xA951, 0xA952, 0xA953, 0xA954, 0x8140, 0x8141,
0x8142, 0x8143, 0x8144, 0x8145, 0x8146, 0x8147, 0x8148, 0x8149,
0x814A, 0x814B, 0x814C, 0x814D, 0x814E, 0x814F, 0x8150, 0x8151,
0x8152, 0x8153, 0x8154, 0x8155, 0x8156, 0x8157, 0x8158, 0x8159,
0x815A, 0x815B, 0x815C, 0x815D, 0x815E, 0x815F, 0x8160, 0x8161,
0x8162, 0x8163, 0x8164, 0x8165, 0x8166, 0x8167, 0x8168, 0x8169,
0x816A, 0x816B, 0x816C, 0x816D, 0x816E, 0x816F, 0x8170, 0x8171,
0x8172, 0x8173, 0x8174, 0x8175, 0x8176, 0x8177, 0x8178, 0x8179,
0x817A, 0x817B, 0x817C, 0x817D, 0x817E, 0x8180, 0x8181, 0x8182,
0x8183, 0x8184, 0x8185, 0x8186, 0x8187, 0x8188, 0x8189, 0x818A,
0x818B, 0x818C, 0x818D, 0x818E, 0x818F, 0x8190, 0x8191, 0x8192,
0x8193, 0x8194, 0x8195, 0x8196, 0x8197, 0x8198, 0x8199, 0x819A,
0x819B, 0x819C, 0x819D, 0x819E, 0x819F, 0x81A0, 0x81A1, 0x81A2,
0x81A3, 0x81A4, 0x81A5, 0x81A6, 0x81A7, 0x81A8, 0x81A9, 0x81AA,
0x81AB, 0x81AC, 0x81AD, 0x81AE, 0x81AF, 0x81B0, 0x81B1, 0x81B2,
0x81B3, 0x81B4, 0x81B5, 0x81B6, 0x81B7, 0x81B8, 0x81B9, 0x81BA,
0x81BB, 0x81BC, 0x81BD, 0x81BE, 0x81BF, 0x81C0, 0x81C1, 0x81C2,
0x81C3, 0x81C4, 0x81C5, 0x81C6, 0x81C7, 0x81C8, 0x81C9, 0x81CA,
0x81CB, 0x81CC, 0x81CD, 0x81CE, 0x81CF, 0x81D0, 0x81D1, 0x81D2,
0x81D3, 0x81D4, 0x81D5, 0x81D6, 0x81D7, 0x81D8, 0x81D9, 0x81DA,
0x81DB, 0x81DC, 0x81DD, 0x81DE, 0x81DF, 0x81E0, 0x81E1, 0x81E2,
0x81E3, 0x81E4, 0x81E5, 0x81E6, 0x81E7, 0x81E8, 0x81E9, 0x81EA,
0x81EB, 0x81EC, 0x81ED, 0x81EE, 0x81EF, 0x81F0, 0x81F1, 0x81F2,
0x81F3, 0x81F4, 0x81F5, 0x81F6, 0x81F7, 0x81F8, 0x81F9, 0x81FA,
0x81FB, 0x81FC, 0x81FD, 0x81FE, 0x8240, 0x8241, 0x8242, 0x8243,
0x8244, 0x8245, 0x8246, 0x8247, 0x8248, 0x8249, 0x824A, 0x824B,
0x824C, 0x824D, 0x824E, 0x824F, 0x8250, 0x8251, 0x8252, 0x8253,
0x8254, 0x8255, 0x8256, 0x8257, 0x8258, 0x8259, 0x825A, 0x825B,
0x825C, 0x825D, 0x825E, 0x825F, 0x8260, 0x8261, 0x8262, 0x8263,
0x8264, 0x8265, 0x8266, 0x8267, 0x8268, 0x8269, 0x826A, 0x826B,
0x826C, 0x826D, 0x826E, 0x826F, 0x8270, 0x8271, 0x8272, 0x8273,
0x8274, 0x8275, 0x8276, 0x8277, 0x8278, 0x8279, 0x827A, 0x827B,
0x827C, 0x827D, 0x827E, 0x8280, 0x8281, 0x8282, 0x8283, 0x8284,
0x8285, 0x8286, 0x8287, 0x8288, 0x8289, 0x828A, 0x828B, 0x828C,
0x828D, 0x828E, 0x828F, 0x8290, 0x8291, 0x8292, 0x8293, 0x8294,
0x8295, 0x8296, 0x8297, 0x8298, 0x8299, 0x829A, 0x829B, 0x829C,
0x829D, 0x829E, 0x829F, 0x82A0, 0x82A1, 0x82A2, 0x82A3, 0x82A4,
0x82A5, 0x82A6, 0x82A7, 0x82A8, 0x82A9, 0x82AA, 0x82AB, 0x82AC,
0x82AD, 0x82AE, 0x82AF, 0x82B0, 0x82B1, 0x82B2, 0x82B3, 0x82B4,
0x82B5, 0x82B6, 0x82B7, 0x82B8, 0x82B9, 0x82BA, 0x82BB, 0x82BC,
0x82BD, 0x82BE, 0x82BF, 0x82C0, 0x82C1, 0x82C2, 0x82C3, 0x82C4,
0x82C5, 0x82C6, 0x82C7, 0x82C8, 0x82C9, 0x82CA, 0x82CB, 0x82CC,
0x82CD, 0x82CE, 0x82CF, 0x82D0, 0x82D1, 0x82D2, 0x82D3, 0x82D4,
0x82D5, 0x82D6, 0x82D7, 0x82D8, 0x82D9, 0x82DA, 0x82DB, 0x82DC,
0x82DD, 0x82DE, 0x82DF, 0x82E0, 0x82E1, 0x82E2, 0x82E3, 0x82E4,
0x82E5, 0x82E6, 0x82E7, 0x82E8, 0x82E9, 0x82EA, 0x82EB, 0x82EC,
0x82ED, 0x82EE, 0x82EF, 0x82F0, 0x82F1, 0x82F2, 0x82F3, 0x82F4,
0x82F5, 0x82F6, 0x82F7, 0x82F8, 0x82F9, 0x82FA, 0x82FB, 0x82FC,
0x82FD, 0x82FE, 0x8340, 0x8341, 0x8342, 0x8343, 0x8344, 0x8345,
0x8346, 0x8347, 0x8348, 0x8349, 0x834A, 0x834B, 0x834C, 0x834D,
0x834E, 0x834F, 0x8350, 0x8351, 0x8352, 0x8353, 0x8354, 0x8355,
0x8356, 0x8357, 0x8358, 0x8359, 0x835A, 0x835B, 0x835C, 0x835D,
0x835E, 0x835F, 0x8360, 0x8361, 0x8362, 0x8363, 0x8364, 0x8365,
0x8366, 0x8367, 0x8368, 0x8369, 0x836A, 0x836B, 0x836C, 0x836D,
0x836E, 0x836F, 0x8370, 0x8371, 0x8372, 0x8373, 0x8374, 0x8375,
0x8376, 0x8377, 0x8378, 0x8379, 0x837A, 0x837B, 0x837C, 0x837D,
0x837E, 0x8380, 0x8381, 0x8382, 0x8383, 0x8384, 0x8385, 0x8386,
0x8387, 0x8388, 0x8389, 0x838A, 0x838B, 0x838C, 0x838D, 0x838E,
0x838F, 0x8390, 0x8391, 0x8392, 0x8393, 0x8394, 0x8395, 0x8396,
0x8397, 0x8398, 0x8399, 0x839A, 0x839B, 0x839C, 0x839D, 0x839E,
0x839F, 0x83A0, 0x83A1, 0x83A2, 0x83A3, 0x83A4, 0x83A5, 0x83A6,
0x83A7, 0x83A8, 0x83A9, 0x83AA, 0x83AB, 0x83AC, 0x83AD, 0x83AE,
0x83AF, 0x83B0, 0x83B1, 0x83B2, 0x83B3, 0x83B4, 0x83B5, 0x83B6,
0x83B7, 0x83B8, 0x83B9, 0x83BA, 0x83BB, 0x83BC, 0x83BD, 0x83BE,
0x83BF, 0x83C0, 0x83C1, 0x83C2, 0x83C3, 0x83C4, 0x83C5, 0x83C6,
0x83C7, 0x83C8, 0x83C9, 0x83CA, 0x83CB, 0x83CC, 0x83CD, 0x83CE,
0x83CF, 0x83D0, 0x83D1, 0x83D2, 0x83D3, 0x83D4, 0x83D5, 0x83D6,
0x83D7, 0x83D8, 0x83D9, 0x83DA, 0x83DB, 0x83DC, 0x83DD, 0x83DE,
0x83DF, 0x83E0, 0x83E1, 0x83E2, 0x83E3, 0x83E4, 0x83E5, 0x83E6,
0x83E7, 0x83E8, 0x83E9, 0x83EA, 0x83EB, 0x83EC, 0x83ED, 0x83EE,
0x83EF, 0x83F0, 0x83F1, 0x83F2, 0x83F3, 0x83F4, 0x83F5, 0x83F6,
0x83F7, 0x83F8, 0x83F9, 0x83FA, 0x83FB, 0x83FC, 0x83FD, 0x83FE,
0x8440, 0x8441, 0x8442, 0x8443, 0x8444, 0x8445, 0x8446, 0x8447,
0x8448, 0x8449, 0x844A, 0x844B, 0x844C, 0x844D, 0x844E, 0x844F,
0x8450, 0x8451, 0x8452, 0x8453, 0x8454, 0x8455, 0x8456, 0x8457,
0x8458, 0x8459, 0x845A, 0x845B, 0x845C, 0x845D, 0x845E, 0x845F,
0x8460, 0x8461, 0x8462, 0x8463, 0x8464, 0x8465, 0x8466, 0x8467,
0x8468, 0x8469, 0x846A, 0x846B, 0x846C, 0x846D, 0x846E, 0x846F,
0x8470, 0x8471, 0x8472, 0x8473, 0x8474, 0x8475, 0x8476, 0x8477,
0x8478, 0x8479, 0x847A, 0x847B, 0x847C, 0x847D, 0x847E, 0x8480,
0x8481, 0x8482, 0x8483, 0x8484, 0x8485, 0x8486, 0x8487, 0x8488,
0x8489, 0x848A, 0x848B, 0x848C, 0x848D, 0x848E, 0x848F, 0x8490,
0x8491, 0x8492, 0x8493, 0x8494, 0x8495, 0x8496, 0x8497, 0x8498,
0x8499, 0x849A, 0x849B, 0x849C, 0x849D, 0x849E, 0x849F, 0x84A0,
0x84A1, 0x84A2, 0x84A3, 0x84A4, 0x84A5, 0x84A6, 0x84A7, 0x84A8,
0x84A9, 0x84AA, 0x84AB, 0x84AC, 0x84AD, 0x84AE, 0x84AF, 0x84B0,
0x84B1, 0x84B2, 0x84B3, 0x84B4, 0x84B5, 0x84B6, 0x84B7, 0x84B8,
0x84B9, 0x84BA, 0x84BB, 0x84BC, 0x84BD, 0x84BE, 0x84BF, 0x84C0,
0x84C1, 0x84C2, 0x84C3, 0x84C4, 0x84C5, 0x84C6, 0x84C7, 0x84C8,
0x84C9, 0x84CA, 0x84CB, 0x84CC, 0x84CD, 0x84CE, 0x84CF, 0x84D0,
0x84D1, 0x84D2, 0x84D3, 0x84D4, 0x84D5, 0x84D6, 0x84D7, 0x84D8,
0x84D9, 0x84DA, 0x84DB, 0x84DC, 0x84DD, 0x84DE, 0x84DF, 0x84E0,
0x84E1, 0x84E2, 0x84E3, 0x84E4, 0x84E5, 0x84E6, 0x84E7, 0x84E8,
0x84E9, 0x84EA, 0x84EB, 0x84EC, 0x84ED, 0x84EE, 0x84EF, 0x84F0,
0x84F1, 0x84F2, 0x84F3, 0x84F4, 0x84F5, 0x84F6, 0x84F7, 0x84F8,
0x84F9, 0x84FA, 0x84FB, 0x84FC, 0x84FD, 0x84FE, 0x8540, 0x8541,
0x8542, 0x8543, 0x8544, 0x8545, 0x8546, 0x8547, 0x8548, 0x8549,
0x854A, 0x854B, 0x854C, 0x854D, 0x854E, 0x854F, 0x8550, 0x8551,
0x8552, 0x8553, 0x8554, 0x8555, 0x8556, 0x8557, 0x8558, 0x8559,
0x855A, 0x855B, 0x855C, 0x855D, 0x855E, 0x855F, 0x8560, 0x8561,
0x8562, 0x8563, 0x8564, 0x8565, 0x8566, 0x8567, 0x8568, 0x8569,
0x856A, 0x856B, 0x856C, 0x856D, 0x856E, 0x856F, 0x8570, 0x8571,
0x8572, 0x8573, 0x8574, 0x8575, 0x8576, 0x8577, 0x8578, 0x8579,
0x857A, 0x857B, 0x857C, 0x857D, 0x857E, 0x8580, 0x8581, 0x8582,
0x8583, 0x8584, 0x8585, 0x8586, 0x8587, 0x8588, 0x8589, 0x858A,
0x858B, 0x858C, 0x858D, 0x858E, 0x858F, 0x8590, 0x8591, 0x8592,
0x8593, 0x8594, 0x8595, 0x8596, 0x8597, 0x8598, 0x8599, 0x859A,
0x859B, 0x859C, 0x859D, 0x859E, 0x859F, 0x85A0, 0x85A1, 0x85A2,
0x85A3, 0x85A4, 0x85A5, 0x85A6, 0x85A7, 0x85A8, 0x85A9, 0x85AA,
0x85AB, 0x85AC, 0x85AD, 0x85AE, 0x85AF, 0x85B0, 0x85B1, 0x85B2,
0x85B3, 0x85B4, 0x85B5, 0x85B6, 0x85B7, 0x85B8, 0x85B9, 0x85BA,
0x85BB, 0x85BC, 0x85BD, 0x85BE, 0x85BF, 0x85C0, 0x85C1, 0x85C2,
0x85C3, 0x85C4, 0x85C5, 0x85C6, 0x85C7, 0x85C8, 0x85C9, 0x85CA,
0x85CB, 0x85CC, 0x85CD, 0x85CE, 0x85CF, 0x85D0, 0x85D1, 0x85D2,
0x85D3, 0x85D4, 0x85D5, 0x85D6, 0x85D7, 0x85D8, 0x85D9, 0x85DA,
0x85DB, 0x85DC, 0x85DD, 0x85DE, 0x85DF, 0x85E0, 0x85E1, 0x85E2,
0x85E3, 0x85E4, 0x85E5, 0x85E6, 0x85E7, 0x85E8, 0x85E9, 0x85EA,
0x85EB, 0x85EC, 0x85ED, 0x85EE, 0x85EF, 0x85F0, 0x85F1, 0x85F2,
0x85F3, 0x85F4, 0x85F5, 0x85F6, 0x85F7, 0x85F8, 0x85F9, 0x85FA,
0x85FB, 0x85FC, 0x85FD, 0x85FE, 0x8640, 0x8641, 0x8642, 0x8643,
0x8644, 0x8645, 0x8646, 0x8647, 0x8648, 0x8649, 0x864A, 0x864B,
0x864C, 0x864D, 0x864E, 0x864F, 0x8650, 0x8651, 0x8652, 0x8653,
0x8654, 0x8655, 0x8656, 0x8657, 0x8658, 0x8659, 0x865A, 0x865B,
0x865C, 0x865D, 0x865E, 0x865F, 0x8660, 0x8661, 0x8662, 0x8663,
0x8664, 0x8665, 0x8666, 0x8667, 0x8668, 0x8669, 0x866A, 0x866B,
0x866C, 0x866D, 0x866E, 0x866F, 0x8670, 0x8671, 0x8672, 0x8673,
0x8674, 0x8675, 0x8676, 0x8677, 0x8678, 0x8679, 0x867A, 0x867B,
0x867C, 0x867D, 0x867E, 0x8680, 0x8681, 0x8682, 0x8683, 0x8684,
0x8685, 0x8686, 0x8687, 0x8688, 0x8689, 0x868A, 0x868B, 0x868C,
0x868D, 0x868E, 0x868F, 0x8690, 0x8691, 0x8692, 0x8693, 0x8694,
0x8695, 0x8696, 0x8697, 0x8698, 0x8699, 0x869A, 0x869B, 0x869C,
0x869D, 0x869E, 0x869F, 0x86A0, 0x86A1, 0x86A2, 0x86A3, 0x86A4,
0x86A5, 0x86A6, 0x86A7, 0x86A8, 0x86A9, 0x86AA, 0x86AB, 0x86AC,
0x86AD, 0x86AE, 0x86AF, 0x86B0, 0x86B1, 0x86B2, 0x86B3, 0x86B4,
0x86B5, 0x86B6, 0x86B7, 0x86B8, 0x86B9, 0x86BA, 0x86BB, 0x86BC,
0x86BD, 0x86BE, 0x86BF, 0x86C0, 0x86C1, 0x86C2, 0x86C3, 0x86C4,
0x86C5, 0x86C6, 0x86C7, 0x86C8, 0x86C9, 0x86CA, 0x86CB, 0x86CC,
0x86CD, 0x86CE, 0x86CF, 0x86D0, 0x86D1, 0x86D2, 0x86D3, 0x86D4,
0x86D5, 0x86D6, 0x86D7, 0x86D8, 0x86D9, 0x86DA, 0x86DB, 0x86DC,
0x86DD, 0x86DE, 0x86DF, 0x86E0, 0x86E1, 0x86E2, 0x86E3, 0x86E4,
0x86E5, 0x86E6, 0x86E7, 0x86E8, 0x86E9, 0x86EA, 0x86EB, 0x86EC,
0x86ED, 0x86EE, 0x86EF, 0x86F0, 0x86F1, 0x86F2, 0x86F3, 0x86F4,
0x86F5, 0x86F6, 0x86F7, 0x86F8, 0x86F9, 0x86FA, 0x86FB, 0x86FC,
0x86FD, 0x86FE, 0x8740, 0x8741, 0x8742, 0x8743, 0x8744, 0x8745,
0x8746, 0x8747, 0x8748, 0x8749, 0x874A, 0x874B, 0x874C, 0x874D,
0x874E, 0x874F, 0x8750, 0x8751, 0x8752, 0x8753, 0x8754, 0x8755,
0x8756, 0x8757, 0x8758, 0x8759, 0x875A, 0x875B, 0x875C, 0x875D,
0x875E, 0x875F, 0x8760, 0x8761, 0x8762, 0x8763, 0x8764, 0x8765,
0x8766, 0x8767, 0x8768, 0x8769, 0x876A, 0x876B, 0x876C, 0x876D,
0x876E, 0x876F, 0x8770, 0x8771, 0x8772, 0x8773, 0x8774, 0x8775,
0x8776, 0x8777, 0x8778, 0x8779, 0x877A, 0x877B, 0x877C, 0x877D,
0x877E, 0x8780, 0x8781, 0x8782, 0x8783, 0x8784, 0x8785, 0x8786,
0x8787, 0x8788, 0x8789, 0x878A, 0x878B, 0x878C, 0x878D, 0x878E,
0x878F, 0x8790, 0x8791, 0x8792, 0x8793, 0x8794, 0x8795, 0x8796,
0x8797, 0x8798, 0x8799, 0x879A, 0x879B, 0x879C, 0x879D, 0x879E,
0x879F, 0x87A0, 0x87A1, 0x87A2, 0x87A3, 0x87A4, 0x87A5, 0x87A6,
0x87A7, 0x87A8, 0x87A9, 0x87AA, 0x87AB, 0x87AC, 0x87AD, 0x87AE,
0x87AF, 0x87B0, 0x87B1, 0x87B2, 0x87B3, 0x87B4, 0x87B5, 0x87B6,
0x87B7, 0x87B8, 0x87B9, 0x87BA, 0x87BB, 0x87BC, 0x87BD, 0x87BE,
0x87BF, 0x87C0, 0x87C1, 0x87C2, 0x87C3, 0x87C4, 0x87C5, 0x87C6,
0x87C7, 0x87C8, 0x87C9, 0x87CA, 0x87CB, 0x87CC, 0x87CD, 0x87CE,
0x87CF, 0x87D0, 0x87D1, 0x87D2, 0x87D3, 0x87D4, 0x87D5, 0x87D6,
0x87D7, 0x87D8, 0x87D9, 0x87DA, 0x87DB, 0x87DC, 0x87DD, 0x87DE,
0x87DF, 0x87E0, 0x87E1, 0x87E2, 0x87E3, 0x87E4, 0x87E5, 0x87E6,
0x87E7, 0x87E8, 0x87E9, 0x87EA, 0x87EB, 0x87EC, 0x87ED, 0x87EE,
0x87EF, 0x87F0, 0x87F1, 0x87F2, 0x87F3, 0x87F4, 0x87F5, 0x87F6,
0x87F7, 0x87F8, 0x87F9, 0x87FA, 0x87FB, 0x87FC, 0x87FD, 0x87FE,
0x8840, 0x8841, 0x8842, 0x8843, 0x8844, 0x8845, 0x8846, 0x8847,
0x8848, 0x8849, 0x884A, 0x884B, 0x884C, 0x884D, 0x884E, 0x884F,
0x8850, 0x8851, 0x8852, 0x8853, 0x8854, 0x8855, 0x8856, 0x8857,
0x8858, 0x8859, 0x885A, 0x885B, 0x885C, 0x885D, 0x885E, 0x885F,
0x8860, 0x8861, 0x8862, 0x8863, 0x8864, 0x8865, 0x8866, 0x8867,
0x8868, 0x8869, 0x886A, 0x886B, 0x886C, 0x886D, 0x886E, 0x886F,
0x8870, 0x8871, 0x8872, 0x8873, 0x8874, 0x8875, 0x8876, 0x8877,
0x8878, 0x8879, 0x887A, 0x887B, 0x887C, 0x887D, 0x887E, 0x8880,
0x8881, 0x8882, 0x8883, 0x8884, 0x8885, 0x8886, 0x8887, 0x8888,
0x8889, 0x888A, 0x888B, 0x888C, 0x888D, 0x888E, 0x888F, 0x8890,
0x8891, 0x8892, 0x8893, 0x8894, 0x8895, 0x8896, 0x8897, 0x8898,
0x8899, 0x889A, 0x889B, 0x889C, 0x889D, 0x889E, 0x889F, 0x88A0,
0x88A1, 0x88A2, 0x88A3, 0x88A4, 0x88A5, 0x88A6, 0x88A7, 0x88A8,
0x88A9, 0x88AA, 0x88AB, 0x88AC, 0x88AD, 0x88AE, 0x88AF, 0x88B0,
0x88B1, 0x88B2, 0x88B3, 0x88B4, 0x88B5, 0x88B6, 0x88B7, 0x88B8,
0x88B9, 0x88BA, 0x88BB, 0x88BC, 0x88BD, 0x88BE, 0x88BF, 0x88C0,
0x88C1, 0x88C2, 0x88C3, 0x88C4, 0x88C5, 0x88C6, 0x88C7, 0x88C8,
0x88C9, 0x88CA, 0x88CB, 0x88CC, 0x88CD, 0x88CE, 0x88CF, 0x88D0,
0x88D1, 0x88D2, 0x88D3, 0x88D4, 0x88D5, 0x88D6, 0x88D7, 0x88D8,
0x88D9, 0x88DA, 0x88DB, 0x88DC, 0x88DD, 0x88DE, 0x88DF, 0x88E0,
0x88E1, 0x88E2, 0x88E3, 0x88E4, 0x88E5, 0x88E6, 0x88E7, 0x88E8,
0x88E9, 0x88EA, 0x88EB, 0x88EC, 0x88ED, 0x88EE, 0x88EF, 0x88F0,
0x88F1, 0x88F2, 0x88F3, 0x88F4, 0x88F5, 0x88F6, 0x88F7, 0x88F8,
0x88F9, 0x88FA, 0x88FB, 0x88FC, 0x88FD, 0x88FE, 0x8940, 0x8941,
0x8942, 0x8943, 0x8944, 0x8945, 0x8946, 0x8947, 0x8948, 0x8949,
0x894A, 0x894B, 0x894C, 0x894D, 0x894E, 0x894F, 0x8950, 0x8951,
0x8952, 0x8953, 0x8954, 0x8955, 0x8956, 0x8957, 0x8958, 0x8959,
0x895A, 0x895B, 0x895C, 0x895D, 0x895E, 0x895F, 0x8960, 0x8961,
0x8962, 0x8963, 0x8964, 0x8965, 0x8966, 0x8967, 0x8968, 0x8969,
0x896A, 0x896B, 0x896C, 0x896D, 0x896E, 0x896F, 0x8970, 0x8971,
0x8972, 0x8973, 0x8974, 0x8975, 0x8976, 0x8977, 0x8978, 0x8979,
0x897A, 0x897B, 0x897C, 0x897D, 0x897E, 0x8980, 0x8981, 0x8982,
0x8983, 0x8984, 0x8985, 0x8986, 0x8987, 0x8988, 0x8989, 0x898A,
0x898B, 0x898C, 0x898D, 0x898E, 0x898F, 0x8990, 0x8991, 0x8992,
0x8993, 0x8994, 0x8995, 0x8996, 0x8997, 0x8998, 0x8999, 0x899A,
0x899B, 0x899C, 0x899D, 0x899E, 0x899F, 0x89A0, 0x89A1, 0x89A2,
0x89A3, 0x89A4, 0x89A5, 0x89A6, 0x89A7, 0x89A8, 0x89A9, 0x89AA,
0x89AB, 0x89AC, 0x89AD, 0x89AE, 0x89AF, 0x89B0, 0x89B1, 0x89B2,
0x89B3, 0x89B4, 0x89B5, 0x89B6, 0x89B7, 0x89B8, 0x89B9, 0x89BA,
0x89BB, 0x89BC, 0x89BD, 0x89BE, 0x89BF, 0x89C0, 0x89C1, 0x89C2,
0x89C3, 0x89C4, 0x89C5, 0x89C6, 0x89C7, 0x89C8, 0x89C9, 0x89CA,
0x89CB, 0x89CC, 0x89CD, 0x89CE, 0x89CF, 0x89D0, 0x89D1, 0x89D2,
0x89D3, 0x89D4, 0x89D5, 0x89D6, 0x89D7, 0x89D8, 0x89D9, 0x89DA,
0x89DB, 0x89DC, 0x89DD, 0x89DE, 0x89DF, 0x89E0, 0x89E1, 0x89E2,
0x89E3, 0x89E4, 0x89E5, 0x89E6, 0x89E7, 0x89E8, 0x89E9, 0x89EA,
0x89EB, 0x89EC, 0x89ED, 0x89EE, 0x89EF, 0x89F0, 0x89F1, 0x89F2,
0x89F3, 0x89F4, 0x89F5, 0x89F6, 0x89F7, 0x89F8, 0x89F9, 0x89FA,
0x89FB, 0x89FC, 0x89FD, 0x89FE, 0x8A40, 0x8A41, 0x8A42, 0x8A43,
0x8A44, 0x8A45, 0x8A46, 0x8A47, 0x8A48, 0x8A49, 0x8A4A, 0x8A4B,
0x8A4C, 0x8A4D, 0x8A4E, 0x8A4F, 0x8A50, 0x8A51, 0x8A52, 0x8A53,
0x8A54, 0x8A55, 0x8A56, 0x8A57, 0x8A58, 0x8A59, 0x8A5A, 0x8A5B,
0x8A5C, 0x8A5D, 0x8A5E, 0x8A5F, 0x8A60, 0x8A61, 0x8A62, 0x8A63,
0x8A64, 0x8A65, 0x8A66, 0x8A67, 0x8A68, 0x8A69, 0x8A6A, 0x8A6B,
0x8A6C, 0x8A6D, 0x8A6E, 0x8A6F, 0x8A70, 0x8A71, 0x8A72, 0x8A73,
0x8A74, 0x8A75, 0x8A76, 0x8A77, 0x8A78, 0x8A79, 0x8A7A, 0x8A7B,
0x8A7C, 0x8A7D, 0x8A7E, 0x8A80, 0x8A81, 0x8A82, 0x8A83, 0x8A84,
0x8A85, 0x8A86, 0x8A87, 0x8A88, 0x8A89, 0x8A8A, 0x8A8B, 0x8A8C,
0x8A8D, 0x8A8E, 0x8A8F, 0x8A90, 0x8A91, 0x8A92, 0x8A93, 0x8A94,
0x8A95, 0x8A96, 0x8A97, 0x8A98, 0x8A99, 0x8A9A, 0x8A9B, 0x8A9C,
0x8A9D, 0x8A9E, 0x8A9F, 0x8AA0, 0x8AA1, 0x8AA2, 0x8AA3, 0x8AA4,
0x8AA5, 0x8AA6, 0x8AA7, 0x8AA8, 0x8AA9, 0x8AAA, 0x8AAB, 0x8AAC,
0x8AAD, 0x8AAE, 0x8AAF, 0x8AB0, 0x8AB1, 0x8AB2, 0x8AB3, 0x8AB4,
0x8AB5, 0x8AB6, 0x8AB7, 0x8AB8, 0x8AB9, 0x8ABA, 0x8ABB, 0x8ABC,
0x8ABD, 0x8ABE, 0x8ABF, 0x8AC0, 0x8AC1, 0x8AC2, 0x8AC3, 0x8AC4,
0x8AC5, 0x8AC6, 0x8AC7, 0x8AC8, 0x8AC9, 0x8ACA, 0x8ACB, 0x8ACC,
0x8ACD, 0x8ACE, 0x8ACF, 0x8AD0, 0x8AD1, 0x8AD2, 0x8AD3, 0x8AD4,
0x8AD5, 0x8AD6, 0x8AD7, 0x8AD8, 0x8AD9, 0x8ADA, 0x8ADB, 0x8ADC,
0x8ADD, 0x8ADE, 0x8ADF, 0x8AE0, 0x8AE1, 0x8AE2, 0x8AE3, 0x8AE4,
0x8AE5, 0x8AE6, 0x8AE7, 0x8AE8, 0x8AE9, 0x8AEA, 0x8AEB, 0x8AEC,
0x8AED, 0x8AEE, 0x8AEF, 0x8AF0, 0x8AF1, 0x8AF2, 0x8AF3, 0x8AF4,
0x8AF5, 0x8AF6, 0x8AF7, 0x8AF8, 0x8AF9, 0x8AFA, 0x8AFB, 0x8AFC,
0x8AFD, 0x8AFE, 0x8B40, 0x8B41, 0x8B42, 0x8B43, 0x8B44, 0x8B45,
0x8B46, 0x8B47, 0x8B48, 0x8B49, 0x8B4A, 0x8B4B, 0x8B4C, 0x8B4D,
0x8B4E, 0x8B4F, 0x8B50, 0x8B51, 0x8B52, 0x8B53, 0x8B54, 0x8B55,
0x8B56, 0x8B57, 0x8B58, 0x8B59, 0x8B5A, 0x8B5B, 0x8B5C, 0x8B5D,
0x8B5E, 0x8B5F, 0x8B60, 0x8B61, 0x8B62, 0x8B63, 0x8B64, 0x8B65,
0x8B66, 0x8B67, 0x8B68, 0x8B69, 0x8B6A, 0x8B6B, 0x8B6C, 0x8B6D,
0x8B6E, 0x8B6F, 0x8B70, 0x8B71, 0x8B72, 0x8B73, 0x8B74, 0x8B75,
0x8B76, 0x8B77, 0x8B78, 0x8B79, 0x8B7A, 0x8B7B, 0x8B7C, 0x8B7D,
0x8B7E, 0x8B80, 0x8B81, 0x8B82, 0x8B83, 0x8B84, 0x8B85, 0x8B86,
0x8B87, 0x8B88, 0x8B89, 0x8B8A, 0x8B8B, 0x8B8C, 0x8B8D, 0x8B8E,
0x8B8F, 0x8B90, 0x8B91, 0x8B92, 0x8B93, 0x8B94, 0x8B95, 0x8B96,
0x8B97, 0x8B98, 0x8B99, 0x8B9A, 0x8B9B, 0x8B9C, 0x8B9D, 0x8B9E,
0x8B9F, 0x8BA0, 0x8BA1, 0x8BA2, 0x8BA3, 0x8BA4, 0x8BA5, 0x8BA6,
0x8BA7, 0x8BA8, 0x8BA9, 0x8BAA, 0x8BAB, 0x8BAC, 0x8BAD, 0x8BAE,
0x8BAF, 0x8BB0, 0x8BB1, 0x8BB2, 0x8BB3, 0x8BB4, 0x8BB5, 0x8BB6,
0x8BB7, 0x8BB8, 0x8BB9, 0x8BBA, 0x8BBB, 0x8BBC, 0x8BBD, 0x8BBE,
0x8BBF, 0x8BC0, 0x8BC1, 0x8BC2, 0x8BC3, 0x8BC4, 0x8BC5, 0x8BC6,
0x8BC7, 0x8BC8, 0x8BC9, 0x8BCA, 0x8BCB, 0x8BCC, 0x8BCD, 0x8BCE,
0x8BCF, 0x8BD0, 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, 0x8BEA, 0x8BEB, 0x8BEC, 0x8BED, 0x8BEE,
0x8BEF, 0x8BF0, 0x8BF1, 0x8BF2, 0x8BF3, 0x8BF4, 0x8BF5, 0x8BF6,
0x8BF7, 0x8BF8, 0x8BF9, 0x8BFA, 0x8BFB, 0x8BFC, 0x8BFD, 0x8BFE,
0x8C40, 0x8C41, 0x8C42, 0x8C43, 0x8C44, 0x8C45, 0x8C46, 0x8C47,
0x8C48, 0x8C49, 0x8C4A, 0x8C4B, 0x8C4C, 0x8C4D, 0x8C4E, 0x8C4F,
0x8C50, 0x8C51, 0x8C52, 0x8C53, 0x8C54, 0x8C55, 0x8C56, 0x8C57,
0x8C58, 0x8C59, 0x8C5A, 0x8C5B, 0x8C5C, 0x8C5D, 0x8C5E, 0x8C5F,
0x8C60, 0x8C61, 0x8C62, 0x8C63, 0x8C64, 0x8C65, 0x8C66, 0x8C67,
0x8C68, 0x8C69, 0x8C6A, 0x8C6B, 0x8C6C, 0x8C6D, 0x8C6E, 0x8C6F,
0x8C70, 0x8C71, 0x8C72, 0x8C73, 0x8C74, 0x8C75, 0x8C76, 0x8C77,
0x8C78, 0x8C79, 0x8C7A, 0x8C7B, 0x8C7C, 0x8C7D, 0x8C7E, 0x8C80,
0x8C81, 0x8C82, 0x8C83, 0x8C84, 0x8C85, 0x8C86, 0x8C87, 0x8C88,
0x8C89, 0x8C8A, 0x8C8B, 0x8C8C, 0x8C8D, 0x8C8E, 0x8C8F, 0x8C90,
0x8C91, 0x8C92, 0x8C93, 0x8C94, 0x8C95, 0x8C96, 0x8C97, 0x8C98,
0x8C99, 0x8C9A, 0x8C9B, 0x8C9C, 0x8C9D, 0x8C9E, 0x8C9F, 0x8CA0,
0x8CA1, 0x8CA2, 0x8CA3, 0x8CA4, 0x8CA5, 0x8CA6, 0x8CA7, 0x8CA8,
0x8CA9, 0x8CAA, 0x8CAB, 0x8CAC, 0x8CAD, 0x8CAE, 0x8CAF, 0x8CB0,
0x8CB1, 0x8CB2, 0x8CB3, 0x8CB4, 0x8CB5, 0x8CB6, 0x8CB7, 0x8CB8,
0x8CB9, 0x8CBA, 0x8CBB, 0x8CBC, 0x8CBD, 0x8CBE, 0x8CBF, 0x8CC0,
0x8CC1, 0x8CC2, 0x8CC3, 0x8CC4, 0x8CC5, 0x8CC6, 0x8CC7, 0x8CC8,
0x8CC9, 0x8CCA, 0x8CCB, 0x8CCC, 0x8CCD, 0x8CCE, 0x8CCF, 0x8CD0,
0x8CD1, 0x8CD2, 0x8CD3, 0x8CD4, 0x8CD5, 0x8CD6, 0x8CD7, 0x8CD8,
0x8CD9, 0x8CDA, 0x8CDB, 0x8CDC, 0x8CDD, 0x8CDE, 0x8CDF, 0x8CE0,
0x8CE1, 0x8CE2, 0x8CE3, 0x8CE4, 0x8CE5, 0x8CE6, 0x8CE7, 0x8CE8,
0x8CE9, 0x8CEA, 0x8CEB, 0x8CEC, 0x8CED, 0x8CEE, 0x8CEF, 0x8CF0,
0x8CF1, 0x8CF2, 0x8CF3, 0x8CF4, 0x8CF5, 0x8CF6, 0x8CF7, 0x8CF8,
0x8CF9, 0x8CFA, 0x8CFB, 0x8CFC, 0x8CFD, 0x8CFE, 0x8D40, 0x8D41,
0x8D42, 0x8D43, 0x8D44, 0x8D45, 0x8D46, 0x8D47, 0x8D48, 0x8D49,
0x8D4A, 0x8D4B, 0x8D4C, 0x8D4D, 0x8D4E, 0x8D4F, 0x8D50, 0x8D51,
0x8D52, 0x8D53, 0x8D54, 0x8D55, 0x8D56, 0x8D57, 0x8D58, 0x8D59,
0x8D5A, 0x8D5B, 0x8D5C, 0x8D5D, 0x8D5E, 0x8D5F, 0x8D60, 0x8D61,
0x8D62, 0x8D63, 0x8D64, 0x8D65, 0x8D66, 0x8D67, 0x8D68, 0x8D69,
0x8D6A, 0x8D6B, 0x8D6C, 0x8D6D, 0x8D6E, 0x8D6F, 0x8D70, 0x8D71,
0x8D72, 0x8D73, 0x8D74, 0x8D75, 0x8D76, 0x8D77, 0x8D78, 0x8D79,
0x8D7A, 0x8D7B, 0x8D7C, 0x8D7D, 0x8D7E, 0x8D80, 0x8D81, 0x8D82,
0x8D83, 0x8D84, 0x8D85, 0x8D86, 0x8D87, 0x8D88, 0x8D89, 0x8D8A,
0x8D8B, 0x8D8C, 0x8D8D, 0x8D8E, 0x8D8F, 0x8D90, 0x8D91, 0x8D92,
0x8D93, 0x8D94, 0x8D95, 0x8D96, 0x8D97, 0x8D98, 0x8D99, 0x8D9A,
0x8D9B, 0x8D9C, 0x8D9D, 0x8D9E, 0x8D9F, 0x8DA0, 0x8DA1, 0x8DA2,
0x8DA3, 0x8DA4, 0x8DA5, 0x8DA6, 0x8DA7, 0x8DA8, 0x8DA9, 0x8DAA,
0x8DAB, 0x8DAC, 0x8DAD, 0x8DAE, 0x8DAF, 0x8DB0, 0x8DB1, 0x8DB2,
0x8DB3, 0x8DB4, 0x8DB5, 0x8DB6, 0x8DB7, 0x8DB8, 0x8DB9, 0x8DBA,
0x8DBB, 0x8DBC, 0x8DBD, 0x8DBE, 0x8DBF, 0x8DC0, 0x8DC1, 0x8DC2,
0x8DC3, 0x8DC4, 0x8DC5, 0x8DC6, 0x8DC7, 0x8DC8, 0x8DC9, 0x8DCA,
0x8DCB, 0x8DCC, 0x8DCD, 0x8DCE, 0x8DCF, 0x8DD0, 0x8DD1, 0x8DD2,
0x8DD3, 0x8DD4, 0x8DD5, 0x8DD6, 0x8DD7, 0x8DD8, 0x8DD9, 0x8DDA,
0x8DDB, 0x8DDC, 0x8DDD, 0x8DDE, 0x8DDF, 0x8DE0, 0x8DE1, 0x8DE2,
0x8DE3, 0x8DE4, 0x8DE5, 0x8DE6, 0x8DE7, 0x8DE8, 0x8DE9, 0x8DEA,
0x8DEB, 0x8DEC, 0x8DED, 0x8DEE, 0x8DEF, 0x8DF0, 0x8DF1, 0x8DF2,
0x8DF3, 0x8DF4, 0x8DF5, 0x8DF6, 0x8DF7, 0x8DF8, 0x8DF9, 0x8DFA,
0x8DFB, 0x8DFC, 0x8DFD, 0x8DFE, 0x8E40, 0x8E41, 0x8E42, 0x8E43,
0x8E44, 0x8E45, 0x8E46, 0x8E47, 0x8E48, 0x8E49, 0x8E4A, 0x8E4B,
0x8E4C, 0x8E4D, 0x8E4E, 0x8E4F, 0x8E50, 0x8E51, 0x8E52, 0x8E53,
0x8E54, 0x8E55, 0x8E56, 0x8E57, 0x8E58, 0x8E59, 0x8E5A, 0x8E5B,
0x8E5C, 0x8E5D, 0x8E5E, 0x8E5F, 0x8E60, 0x8E61, 0x8E62, 0x8E63,
0x8E64, 0x8E65, 0x8E66, 0x8E67, 0x8E68, 0x8E69, 0x8E6A, 0x8E6B,
0x8E6C, 0x8E6D, 0x8E6E, 0x8E6F, 0x8E70, 0x8E71, 0x8E72, 0x8E73,
0x8E74, 0x8E75, 0x8E76, 0x8E77, 0x8E78, 0x8E79, 0x8E7A, 0x8E7B,
0x8E7C, 0x8E7D, 0x8E7E, 0x8E80, 0x8E81, 0x8E82, 0x8E83, 0x8E84,
0x8E85, 0x8E86, 0x8E87, 0x8E88, 0x8E89, 0x8E8A, 0x8E8B, 0x8E8C,
0x8E8D, 0x8E8E, 0x8E8F, 0x8E90, 0x8E91, 0x8E92, 0x8E93, 0x8E94,
0x8E95, 0x8E96, 0x8E97, 0x8E98, 0x8E99, 0x8E9A, 0x8E9B, 0x8E9C,
0x8E9D, 0x8E9E, 0x8E9F, 0x8EA0, 0x8EA1, 0x8EA2, 0x8EA3, 0x8EA4,
0x8EA5, 0x8EA6, 0x8EA7, 0x8EA8, 0x8EA9, 0x8EAA, 0x8EAB, 0x8EAC,
0x8EAD, 0x8EAE, 0x8EAF, 0x8EB0, 0x8EB1, 0x8EB2, 0x8EB3, 0x8EB4,
0x8EB5, 0x8EB6, 0x8EB7, 0x8EB8, 0x8EB9, 0x8EBA, 0x8EBB, 0x8EBC,
0x8EBD, 0x8EBE, 0x8EBF, 0x8EC0, 0x8EC1, 0x8EC2, 0x8EC3, 0x8EC4,
0x8EC5, 0x8EC6, 0x8EC7, 0x8EC8, 0x8EC9, 0x8ECA, 0x8ECB, 0x8ECC,
0x8ECD, 0x8ECE, 0x8ECF, 0x8ED0, 0x8ED1, 0x8ED2, 0x8ED3, 0x8ED4,
0x8ED5, 0x8ED6, 0x8ED7, 0x8ED8, 0x8ED9, 0x8EDA, 0x8EDB, 0x8EDC,
0x8EDD, 0x8EDE, 0x8EDF, 0x8EE0, 0x8EE1, 0x8EE2, 0x8EE3, 0x8EE4,
0x8EE5, 0x8EE6, 0x8EE7, 0x8EE8, 0x8EE9, 0x8EEA, 0x8EEB, 0x8EEC,
0x8EED, 0x8EEE, 0x8EEF, 0x8EF0, 0x8EF1, 0x8EF2, 0x8EF3, 0x8EF4,
0x8EF5, 0x8EF6, 0x8EF7, 0x8EF8, 0x8EF9, 0x8EFA, 0x8EFB, 0x8EFC,
0x8EFD, 0x8EFE, 0x8F40, 0x8F41, 0x8F42, 0x8F43, 0x8F44, 0x8F45,
0x8F46, 0x8F47, 0x8F48, 0x8F49, 0x8F4A, 0x8F4B, 0x8F4C, 0x8F4D,
0x8F4E, 0x8F4F, 0x8F50, 0x8F51, 0x8F52, 0x8F53, 0x8F54, 0x8F55,
0x8F56, 0x8F57, 0x8F58, 0x8F59, 0x8F5A, 0x8F5B, 0x8F5C, 0x8F5D,
0x8F5E, 0x8F5F, 0x8F60, 0x8F61, 0x8F62, 0x8F63, 0x8F64, 0x8F65,
0x8F66, 0x8F67, 0x8F68, 0x8F69, 0x8F6A, 0x8F6B, 0x8F6C, 0x8F6D,
0x8F6E, 0x8F6F, 0x8F70, 0x8F71, 0x8F72, 0x8F73, 0x8F74, 0x8F75,
0x8F76, 0x8F77, 0x8F78, 0x8F79, 0x8F7A, 0x8F7B, 0x8F7C, 0x8F7D,
0x8F7E, 0x8F80, 0x8F81, 0x8F82, 0x8F83, 0x8F84, 0x8F85, 0x8F86,
0x8F87, 0x8F88, 0x8F89, 0x8F8A, 0x8F8B, 0x8F8C, 0x8F8D, 0x8F8E,
0x8F8F, 0x8F90, 0x8F91, 0x8F92, 0x8F93, 0x8F94, 0x8F95, 0x8F96,
0x8F97, 0x8F98, 0x8F99, 0x8F9A, 0x8F9B, 0x8F9C, 0x8F9D, 0x8F9E,
0x8F9F, 0x8FA0, 0x8FA1, 0x8FA2, 0x8FA3, 0x8FA4, 0x8FA5, 0x8FA6,
0x8FA7, 0x8FA8, 0x8FA9, 0x8FAA, 0x8FAB, 0x8FAC, 0x8FAD, 0x8FAE,
0x8FAF, 0x8FB0, 0x8FB1, 0x8FB2, 0x8FB3, 0x8FB4, 0x8FB5, 0x8FB6,
0x8FB7, 0x8FB8, 0x8FB9, 0x8FBA, 0x8FBB, 0x8FBC, 0x8FBD, 0x8FBE,
0x8FBF, 0x8FC0, 0x8FC1, 0x8FC2, 0x8FC3, 0x8FC4, 0x8FC5, 0x8FC6,
0x8FC7, 0x8FC8, 0x8FC9, 0x8FCA, 0x8FCB, 0x8FCC, 0x8FCD, 0x8FCE,
0x8FCF, 0x8FD0, 0x8FD1, 0x8FD2, 0x8FD3, 0x8FD4, 0x8FD5, 0x8FD6,
0x8FD7, 0x8FD8, 0x8FD9, 0x8FDA, 0x8FDB, 0x8FDC, 0x8FDD, 0x8FDE,
0x8FDF, 0x8FE0, 0x8FE1, 0x8FE2, 0x8FE3, 0x8FE4, 0x8FE5, 0x8FE6,
0x8FE7, 0x8FE8, 0x8FE9, 0x8FEA, 0x8FEB, 0x8FEC, 0x8FED, 0x8FEE,
0x8FEF, 0x8FF0, 0x8FF1, 0x8FF2, 0x8FF3, 0x8FF4, 0x8FF5, 0x8FF6,
0x8FF7, 0x8FF8, 0x8FF9, 0x8FFA, 0x8FFB, 0x8FFC, 0x8FFD, 0x8FFE,
0x9040, 0x9041, 0x9042, 0x9043, 0x9044, 0x9045, 0x9046, 0x9047,
0x9048, 0x9049, 0x904A, 0x904B, 0x904C, 0x904D, 0x904E, 0x904F,
0x9050, 0x9051, 0x9052, 0x9053, 0x9054, 0x9055, 0x9056, 0x9057,
0x9058, 0x9059, 0x905A, 0x905B, 0x905C, 0x905D, 0x905E, 0x905F,
0x9060, 0x9061, 0x9062, 0x9063, 0x9064, 0x9065, 0x9066, 0x9067,
0x9068, 0x9069, 0x906A, 0x906B, 0x906C, 0x906D, 0x906E, 0x906F,
0x9070, 0x9071, 0x9072, 0x9073, 0x9074, 0x9075, 0x9076, 0x9077,
0x9078, 0x9079, 0x907A, 0x907B, 0x907C, 0x907D, 0x907E, 0x9080,
0x9081, 0x9082, 0x9083, 0x9084, 0x9085, 0x9086, 0x9087, 0x9088,
0x9089, 0x908A, 0x908B, 0x908C, 0x908D, 0x908E, 0x908F, 0x9090,
0x9091, 0x9092, 0x9093, 0x9094, 0x9095, 0x9096, 0x9097, 0x9098,
0x9099, 0x909A, 0x909B, 0x909C, 0x909D, 0x909E, 0x909F, 0x90A0,
0x90A1, 0x90A2, 0x90A3, 0x90A4, 0x90A5, 0x90A6, 0x90A7, 0x90A8,
0x90A9, 0x90AA, 0x90AB, 0x90AC, 0x90AD, 0x90AE, 0x90AF, 0x90B0,
0x90B1, 0x90B2, 0x90B3, 0x90B4, 0x90B5, 0x90B6, 0x90B7, 0x90B8,
0x90B9, 0x90BA, 0x90BB, 0x90BC, 0x90BD, 0x90BE, 0x90BF, 0x90C0,
0x90C1, 0x90C2, 0x90C3, 0x90C4, 0x90C5, 0x90C6, 0x90C7, 0x90C8,
0x90C9, 0x90CA, 0x90CB, 0x90CC, 0x90CD, 0x90CE, 0x90CF, 0x90D0,
0x90D1, 0x90D2, 0x90D3, 0x90D4, 0x90D5, 0x90D6, 0x90D7, 0x90D8,
0x90D9, 0x90DA, 0x90DB, 0x90DC, 0x90DD, 0x90DE, 0x90DF, 0x90E0,
0x90E1, 0x90E2, 0x90E3, 0x90E4, 0x90E5, 0x90E6, 0x90E7, 0x90E8,
0x90E9, 0x90EA, 0x90EB, 0x90EC, 0x90ED, 0x90EE, 0x90EF, 0x90F0,
0x90F1, 0x90F2, 0x90F3, 0x90F4, 0x90F5, 0x90F6, 0x90F7, 0x90F8,
0x90F9, 0x90FA, 0x90FB, 0x90FC, 0x90FD, 0x90FE, 0x9140, 0x9141,
0x9142, 0x9143, 0x9144, 0x9145, 0x9146, 0x9147, 0x9148, 0x9149,
0x914A, 0x914B, 0x914C, 0x914D, 0x914E, 0x914F, 0x9150, 0x9151,
0x9152, 0x9153, 0x9154, 0x9155, 0x9156, 0x9157, 0x9158, 0x9159,
0x915A, 0x915B, 0x915C, 0x915D, 0x915E, 0x915F, 0x9160, 0x9161,
0x9162, 0x9163, 0x9164, 0x9165, 0x9166, 0x9167, 0x9168, 0x9169,
0x916A, 0x916B, 0x916C, 0x916D, 0x916E, 0x916F, 0x9170, 0x9171,
0x9172, 0x9173, 0x9174, 0x9175, 0x9176, 0x9177, 0x9178, 0x9179,
0x917A, 0x917B, 0x917C, 0x917D, 0x917E, 0x9180, 0x9181, 0x9182,
0x9183, 0x9184, 0x9185, 0x9186, 0x9187, 0x9188, 0x9189, 0x918A,
0x918B, 0x918C, 0x918D, 0x918E, 0x918F, 0x9190, 0x9191, 0x9192,
0x9193, 0x9194, 0x9195, 0x9196, 0x9197, 0x9198, 0x9199, 0x919A,
0x919B, 0x919C, 0x919D, 0x919E, 0x919F, 0x91A0, 0x91A1, 0x91A2,
0x91A3, 0x91A4, 0x91A5, 0x91A6, 0x91A7, 0x91A8, 0x91A9, 0x91AA,
0x91AB, 0x91AC, 0x91AD, 0x91AE, 0x91AF, 0x91B0, 0x91B1, 0x91B2,
0x91B3, 0x91B4, 0x91B5, 0x91B6, 0x91B7, 0x91B8, 0x91B9, 0x91BA,
0x91BB, 0x91BC, 0x91BD, 0x91BE, 0x91BF, 0x91C0, 0x91C1, 0x91C2,
0x91C3, 0x91C4, 0x91C5, 0x91C6, 0x91C7, 0x91C8, 0x91C9, 0x91CA,
0x91CB, 0x91CC, 0x91CD, 0x91CE, 0x91CF, 0x91D0, 0x91D1, 0x91D2,
0x91D3, 0x91D4, 0x91D5, 0x91D6, 0x91D7, 0x91D8, 0x91D9, 0x91DA,
0x91DB, 0x91DC, 0x91DD, 0x91DE, 0x91DF, 0x91E0, 0x91E1, 0x91E2,
0x91E3, 0x91E4, 0x91E5, 0x91E6, 0x91E7, 0x91E8, 0x91E9, 0x91EA,
0x91EB, 0x91EC, 0x91ED, 0x91EE, 0x91EF, 0x91F0, 0x91F1, 0x91F2,
0x91F3, 0x91F4, 0x91F5, 0x91F6, 0x91F7, 0x91F8, 0x91F9, 0x91FA,
0x91FB, 0x91FC, 0x91FD, 0x91FE, 0x9240, 0x9241, 0x9242, 0x9243,
0x9244, 0x9245, 0x9246, 0x9247, 0x9248, 0x9249, 0x924A, 0x924B,
0x924C, 0x924D, 0x924E, 0x924F, 0x9250, 0x9251, 0x9252, 0x9253,
0x9254, 0x9255, 0x9256, 0x9257, 0x9258, 0x9259, 0x925A, 0x925B,
0x925C, 0x925D, 0x925E, 0x925F, 0x9260, 0x9261, 0x9262, 0x9263,
0x9264, 0x9265, 0x9266, 0x9267, 0x9268, 0x9269, 0x926A, 0x926B,
0x926C, 0x926D, 0x926E, 0x926F, 0x9270, 0x9271, 0x9272, 0x9273,
0x9274, 0x9275, 0x9276, 0x9277, 0x9278, 0x9279, 0x927A, 0x927B,
0x927C, 0x927D, 0x927E, 0x9280, 0x9281, 0x9282, 0x9283, 0x9284,
0x9285, 0x9286, 0x9287, 0x9288, 0x9289, 0x928A, 0x928B, 0x928C,
0x928D, 0x928E, 0x928F, 0x9290, 0x9291, 0x9292, 0x9293, 0x9294,
0x9295, 0x9296, 0x9297, 0x9298, 0x9299, 0x929A, 0x929B, 0x929C,
0x929D, 0x929E, 0x929F, 0x92A0, 0x92A1, 0x92A2, 0x92A3, 0x92A4,
0x92A5, 0x92A6, 0x92A7, 0x92A8, 0x92A9, 0x92AA, 0x92AB, 0x92AC,
0x92AD, 0x92AE, 0x92AF, 0x92B0, 0x92B1, 0x92B2, 0x92B3, 0x92B4,
0x92B5, 0x92B6, 0x92B7, 0x92B8, 0x92B9, 0x92BA, 0x92BB, 0x92BC,
0x92BD, 0x92BE, 0x92BF, 0x92C0, 0x92C1, 0x92C2, 0x92C3, 0x92C4,
0x92C5, 0x92C6, 0x92C7, 0x92C8, 0x92C9, 0x92CA, 0x92CB, 0x92CC,
0x92CD, 0x92CE, 0x92CF, 0x92D0, 0x92D1, 0x92D2, 0x92D3, 0x92D4,
0x92D5, 0x92D6, 0x92D7, 0x92D8, 0x92D9, 0x92DA, 0x92DB, 0x92DC,
0x92DD, 0x92DE, 0x92DF, 0x92E0, 0x92E1, 0x92E2, 0x92E3, 0x92E4,
0x92E5, 0x92E6, 0x92E7, 0x92E8, 0x92E9, 0x92EA, 0x92EB, 0x92EC,
0x92ED, 0x92EE, 0x92EF, 0x92F0, 0x92F1, 0x92F2, 0x92F3, 0x92F4,
0x92F5, 0x92F6, 0x92F7, 0x92F8, 0x92F9, 0x92FA, 0x92FB, 0x92FC,
0x92FD, 0x92FE, 0x9340, 0x9341, 0x9342, 0x9343, 0x9344, 0x9345,
0x9346, 0x9347, 0x9348, 0x9349, 0x934A, 0x934B, 0x934C, 0x934D,
0x934E, 0x934F, 0x9350, 0x9351, 0x9352, 0x9353, 0x9354, 0x9355,
0x9356, 0x9357, 0x9358, 0x9359, 0x935A, 0x935B, 0x935C, 0x935D,
0x935E, 0x935F, 0x9360, 0x9361, 0x9362, 0x9363, 0x9364, 0x9365,
0x9366, 0x9367, 0x9368, 0x9369, 0x936A, 0x936B, 0x936C, 0x936D,
0x936E, 0x936F, 0x9370, 0x9371, 0x9372, 0x9373, 0x9374, 0x9375,
0x9376, 0x9377, 0x9378, 0x9379, 0x937A, 0x937B, 0x937C, 0x937D,
0x937E, 0x9380, 0x9381, 0x9382, 0x9383, 0x9384, 0x9385, 0x9386,
0x9387, 0x9388, 0x9389, 0x938A, 0x938B, 0x938C, 0x938D, 0x938E,
0x938F, 0x9390, 0x9391, 0x9392, 0x9393, 0x9394, 0x9395, 0x9396,
0x9397, 0x9398, 0x9399, 0x939A, 0x939B, 0x939C, 0x939D, 0x939E,
0x939F, 0x93A0, 0x93A1, 0x93A2, 0x93A3, 0x93A4, 0x93A5, 0x93A6,
0x93A7, 0x93A8, 0x93A9, 0x93AA, 0x93AB, 0x93AC, 0x93AD, 0x93AE,
0x93AF, 0x93B0, 0x93B1, 0x93B2, 0x93B3, 0x93B4, 0x93B5, 0x93B6,
0x93B7, 0x93B8, 0x93B9, 0x93BA, 0x93BB, 0x93BC, 0x93BD, 0x93BE,
0x93BF, 0x93C0, 0x93C1, 0x93C2, 0x93C3, 0x93C4, 0x93C5, 0x93C6,
0x93C7, 0x93C8, 0x93C9, 0x93CA, 0x93CB, 0x93CC, 0x93CD, 0x93CE,
0x93CF, 0x93D0, 0x93D1, 0x93D2, 0x93D3, 0x93D4, 0x93D5, 0x93D6,
0x93D7, 0x93D8, 0x93D9, 0x93DA, 0x93DB, 0x93DC, 0x93DD, 0x93DE,
0x93DF, 0x93E0, 0x93E1, 0x93E2, 0x93E3, 0x93E4, 0x93E5, 0x93E6,
0x93E7, 0x93E8, 0x93E9, 0x93EA, 0x93EB, 0x93EC, 0x93ED, 0x93EE,
0x93EF, 0x93F0, 0x93F1, 0x93F2, 0x93F3, 0x93F4, 0x93F5, 0x93F6,
0x93F7, 0x93F8, 0x93F9, 0x93FA, 0x93FB, 0x93FC, 0x93FD, 0x93FE,
0x9440, 0x9441, 0x9442, 0x9443, 0x9444, 0x9445, 0x9446, 0x9447,
0x9448, 0x9449, 0x944A, 0x944B, 0x944C, 0x944D, 0x944E, 0x944F,
0x9450, 0x9451, 0x9452, 0x9453, 0x9454, 0x9455, 0x9456, 0x9457,
0x9458, 0x9459, 0x945A, 0x945B, 0x945C, 0x945D, 0x945E, 0x945F,
0x9460, 0x9461, 0x9462, 0x9463, 0x9464, 0x9465, 0x9466, 0x9467,
0x9468, 0x9469, 0x946A, 0x946B, 0x946C, 0x946D, 0x946E, 0x946F,
0x9470, 0x9471, 0x9472, 0x9473, 0x9474, 0x9475, 0x9476, 0x9477,
0x9478, 0x9479, 0x947A, 0x947B, 0x947C, 0x947D, 0x947E, 0x9480,
0x9481, 0x9482, 0x9483, 0x9484, 0x9485, 0x9486, 0x9487, 0x9488,
0x9489, 0x948A, 0x948B, 0x948C, 0x948D, 0x948E, 0x948F, 0x9490,
0x9491, 0x9492, 0x9493, 0x9494, 0x9495, 0x9496, 0x9497, 0x9498,
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, 0x94C7, 0x94C8,
0x94C9, 0x94CA, 0x94CB, 0x94CC, 0x94CD, 0x94CE, 0x94CF, 0x94D0,
0x94D1, 0x94D2, 0x94D3, 0x94D4, 0x94D5, 0x94D6, 0x94D7, 0x94D8,
0x94D9, 0x94DA, 0x94DB, 0x94DC, 0x94DD, 0x94DE, 0x94DF, 0x94E0,
0x94E1, 0x94E2, 0x94E3, 0x94E4, 0x94E5, 0x94E6, 0x94E7, 0x94E8,
0x94E9, 0x94EA, 0x94EB, 0x94EC, 0x94ED, 0x94EE, 0x94EF, 0x94F0,
0x94F1, 0x94F2, 0x94F3, 0x94F4, 0x94F5, 0x94F6, 0x94F7, 0x94F8,
0x94F9, 0x94FA, 0x94FB, 0x94FC, 0x94FD, 0x94FE, 0x9540, 0x9541,
0x9542, 0x9543, 0x9544, 0x9545, 0x9546, 0x9547, 0x9548, 0x9549,
0x954A, 0x954B, 0x954C, 0x954D, 0x954E, 0x954F, 0x9550, 0x9551,
0x9552, 0x9553, 0x9554, 0x9555, 0x9556, 0x9557, 0x9558, 0x9559,
0x955A, 0x955B, 0x955C, 0x955D, 0x955E, 0x955F, 0x9560, 0x9561,
0x9562, 0x9563, 0x9564, 0x9565, 0x9566, 0x9567, 0x9568, 0x9569,
0x956A, 0x956B, 0x956C, 0x956D, 0x956E, 0x956F, 0x9570, 0x9571,
0x9572, 0x9573, 0x9574, 0x9575, 0x9576, 0x9577, 0x9578, 0x9579,
0x957A, 0x957B, 0x957C, 0x957D, 0x957E, 0x9580, 0x9581, 0x9582,
0x9583, 0x9584, 0x9585, 0x9586, 0x9587, 0x9588, 0x9589, 0x958A,
0x958B, 0x958C, 0x958D, 0x958E, 0x958F, 0x9590, 0x9591, 0x9592,
0x9593, 0x9594, 0x9595, 0x9596, 0x9597, 0x9598, 0x9599, 0x959A,
0x959B, 0x959C, 0x959D, 0x959E, 0x959F, 0x95A0, 0x95A1, 0x95A2,
0x95A3, 0x95A4, 0x95A5, 0x95A6, 0x95A7, 0x95A8, 0x95A9, 0x95AA,
0x95AB, 0x95AC, 0x95AD, 0x95AE, 0x95AF, 0x95B0, 0x95B1, 0x95B2,
0x95B3, 0x95B4, 0x95B5, 0x95B6, 0x95B7, 0x95B8, 0x95B9, 0x95BA,
0x95BB, 0x95BC, 0x95BD, 0x95BE, 0x95BF, 0x95C0, 0x95C1, 0x95C2,
0x95C3, 0x95C4, 0x95C5, 0x95C6, 0x95C7, 0x95C8, 0x95C9, 0x95CA,
0x95CB, 0x95CC, 0x95CD, 0x95CE, 0x95CF, 0x95D0, 0x95D1, 0x95D2,
0x95D3, 0x95D4, 0x95D5, 0x95D6, 0x95D7, 0x95D8, 0x95D9, 0x95DA,
0x95DB, 0x95DC, 0x95DD, 0x95DE, 0x95DF, 0x95E0, 0x95E1, 0x95E2,
0x95E3, 0x95E4, 0x95E5, 0x95E6, 0x95E7, 0x95E8, 0x95E9, 0x95EA,
0x95EB, 0x95EC, 0x95ED, 0x95EE, 0x95EF, 0x95F0, 0x95F1, 0x95F2,
0x95F3, 0x95F4, 0x95F5, 0x95F6, 0x95F7, 0x95F8, 0x95F9, 0x95FA,
0x95FB, 0x95FC, 0x95FD, 0x95FE, 0x9640, 0x9641, 0x9642, 0x9643,
0x9644, 0x9645, 0x9646, 0x9647, 0x9648, 0x9649, 0x964A, 0x964B,
0x964C, 0x964D, 0x964E, 0x964F, 0x9650, 0x9651, 0x9652, 0x9653,
0x9654, 0x9655, 0x9656, 0x9657, 0x9658, 0x9659, 0x965A, 0x965B,
0x965C, 0x965D, 0x965E, 0x965F, 0x9660, 0x9661, 0x9662, 0x9663,
0x9664, 0x9665, 0x9666, 0x9667, 0x9668, 0x9669, 0x966A, 0x966B,
0x966C, 0x966D, 0x966E, 0x966F, 0x9670, 0x9671, 0x9672, 0x9673,
0x9674, 0x9675, 0x9676, 0x9677, 0x9678, 0x9679, 0x967A, 0x967B,
0x967C, 0x967D, 0x967E, 0x9680, 0x9681, 0x9682, 0x9683, 0x9684,
0x9685, 0x9686, 0x9687, 0x9688, 0x9689, 0x968A, 0x968B, 0x968C,
0x968D, 0x968E, 0x968F, 0x9690, 0x9691, 0x9692, 0x9693, 0x9694,
0x9695, 0x9696, 0x9697, 0x9698, 0x9699, 0x969A, 0x969B, 0x969C,
0x969D, 0x969E, 0x969F, 0x96A0, 0x96A1, 0x96A2, 0x96A3, 0x96A4,
0x96A5, 0x96A6, 0x96A7, 0x96A8, 0x96A9, 0x96AA, 0x96AB, 0x96AC,
0x96AD, 0x96AE, 0x96AF, 0x96B0, 0x96B1, 0x96B2, 0x96B3, 0x96B4,
0x96B5, 0x96B6, 0x96B7, 0x96B8, 0x96B9, 0x96BA, 0x96BB, 0x96BC,
0x96BD, 0x96BE, 0x96BF, 0x96C0, 0x96C1, 0x96C2, 0x96C3, 0x96C4,
0x96C5, 0x96C6, 0x96C7, 0x96C8, 0x96C9, 0x96CA, 0x96CB, 0x96CC,
0x96CD, 0x96CE, 0x96CF, 0x96D0, 0x96D1, 0x96D2, 0x96D3, 0x96D4,
0x96D5, 0x96D6, 0x96D7, 0x96D8, 0x96D9, 0x96DA, 0x96DB, 0x96DC,
0x96DD, 0x96DE, 0x96DF, 0x96E0, 0x96E1, 0x96E2, 0x96E3, 0x96E4,
0x96E5, 0x96E6, 0x96E7, 0x96E8, 0x96E9, 0x96EA, 0x96EB, 0x96EC,
0x96ED, 0x96EE, 0x96EF, 0x96F0, 0x96F1, 0x96F2, 0x96F3, 0x96F4,
0x96F5, 0x96F6, 0x96F7, 0x96F8, 0x96F9, 0x96FA, 0x96FB, 0x96FC,
0x96FD, 0x96FE, 0x9740, 0x9741, 0x9742, 0x9743, 0x9744, 0x9745,
0x9746, 0x9747, 0x9748, 0x9749, 0x974A, 0x974B, 0x974C, 0x974D,
0x974E, 0x974F, 0x9750, 0x9751, 0x9752, 0x9753, 0x9754, 0x9755,
0x9756, 0x9757, 0x9758, 0x9759, 0x975A, 0x975B, 0x975C, 0x975D,
0x975E, 0x975F, 0x9760, 0x9761, 0x9762, 0x9763, 0x9764, 0x9765,
0x9766, 0x9767, 0x9768, 0x9769, 0x976A, 0x976B, 0x976C, 0x976D,
0x976E, 0x976F, 0x9770, 0x9771, 0x9772, 0x9773, 0x9774, 0x9775,
0x9776, 0x9777, 0x9778, 0x9779, 0x977A, 0x977B, 0x977C, 0x977D,
0x977E, 0x9780, 0x9781, 0x9782, 0x9783, 0x9784, 0x9785, 0x9786,
0x9787, 0x9788, 0x9789, 0x978A, 0x978B, 0x978C, 0x978D, 0x978E,
0x978F, 0x9790, 0x9791, 0x9792, 0x9793, 0x9794, 0x9795, 0x9796,
0x9797, 0x9798, 0x9799, 0x979A, 0x979B, 0x979C, 0x979D, 0x979E,
0x979F, 0x97A0, 0x97A1, 0x97A2, 0x97A3, 0x97A4, 0x97A5, 0x97A6,
0x97A7, 0x97A8, 0x97A9, 0x97AA, 0x97AB, 0x97AC, 0x97AD, 0x97AE,
0x97AF, 0x97B0, 0x97B1, 0x97B2, 0x97B3, 0x97B4, 0x97B5, 0x97B6,
0x97B7, 0x97B8, 0x97B9, 0x97BA, 0x97BB, 0x97BC, 0x97BD, 0x97BE,
0x97BF, 0x97C0, 0x97C1, 0x97C2, 0x97C3, 0x97C4, 0x97C5, 0x97C6,
0x97C7, 0x97C8, 0x97C9, 0x97CA, 0x97CB, 0x97CC, 0x97CD, 0x97CE,
0x97CF, 0x97D0, 0x97D1, 0x97D2, 0x97D3, 0x97D4, 0x97D5, 0x97D6,
0x97D7, 0x97D8, 0x97D9, 0x97DA, 0x97DB, 0x97DC, 0x97DD, 0x97DE,
0x97DF, 0x97E0, 0x97E1, 0x97E2, 0x97E3, 0x97E4, 0x97E5, 0x97E6,
0x97E7, 0x97E8, 0x97E9, 0x97EA, 0x97EB, 0x97EC, 0x97ED, 0x97EE,
0x97EF, 0x97F0, 0x97F1, 0x97F2, 0x97F3, 0x97F4, 0x97F5, 0x97F6,
0x97F7, 0x97F8, 0x97F9, 0x97FA, 0x97FB, 0x97FC, 0x97FD, 0x97FE,
0x9840, 0x9841, 0x9842, 0x9843, 0x9844, 0x9845, 0x9846, 0x9847,
0x9848, 0x9849, 0x984A, 0x984B, 0x984C, 0x984D, 0x984E, 0x984F,
0x9850, 0x9851, 0x9852, 0x9853, 0x9854, 0x9855, 0x9856, 0x9857,
0x9858, 0x9859, 0x985A, 0x985B, 0x985C, 0x985D, 0x985E, 0x985F,
0x9860, 0x9861, 0x9862, 0x9863, 0x9864, 0x9865, 0x9866, 0x9867,
0x9868, 0x9869, 0x986A, 0x986B, 0x986C, 0x986D, 0x986E, 0x986F,
0x9870, 0x9871, 0x9872, 0x9873, 0x9874, 0x9875, 0x9876, 0x9877,
0x9878, 0x9879, 0x987A, 0x987B, 0x987C, 0x987D, 0x987E, 0x9880,
0x9881, 0x9882, 0x9883, 0x9884, 0x9885, 0x9886, 0x9887, 0x9888,
0x9889, 0x988A, 0x988B, 0x988C, 0x988D, 0x988E, 0x988F, 0x9890,
0x9891, 0x9892, 0x9893, 0x9894, 0x9895, 0x9896, 0x9897, 0x9898,
0x9899, 0x989A, 0x989B, 0x989C, 0x989D, 0x989E, 0x989F, 0x98A0,
0x98A1, 0x98A2, 0x98A3, 0x98A4, 0x98A5, 0x98A6, 0x98A7, 0x98A8,
0x98A9, 0x98AA, 0x98AB, 0x98AC, 0x98AD, 0x98AE, 0x98AF, 0x98B0,
0x98B1, 0x98B2, 0x98B3, 0x98B4, 0x98B5, 0x98B6, 0x98B7, 0x98B8,
0x98B9, 0x98BA, 0x98BB, 0x98BC, 0x98BD, 0x98BE, 0x98BF, 0x98C0,
0x98C1, 0x98C2, 0x98C3, 0x98C4, 0x98C5, 0x98C6, 0x98C7, 0x98C8,
0x98C9, 0x98CA, 0x98CB, 0x98CC, 0x98CD, 0x98CE, 0x98CF, 0x98D0,
0x98D1, 0x98D2, 0x98D3, 0x98D4, 0x98D5, 0x98D6, 0x98D7, 0x98D8,
0x98D9, 0x98DA, 0x98DB, 0x98DC, 0x98DD, 0x98DE, 0x98DF, 0x98E0,
0x98E1, 0x98E2, 0x98E3, 0x98E4, 0x98E5, 0x98E6, 0x98E7, 0x98E8,
0x98E9, 0x98EA, 0x98EB, 0x98EC, 0x98ED, 0x98EE, 0x98EF, 0x98F0,
0x98F1, 0x98F2, 0x98F3, 0x98F4, 0x98F5, 0x98F6, 0x98F7, 0x98F8,
0x98F9, 0x98FA, 0x98FB, 0x98FC, 0x98FD, 0x98FE, 0x9940, 0x9941,
0x9942, 0x9943, 0x9944, 0x9945, 0x9946, 0x9947, 0x9948, 0x9949,
0x994A, 0x994B, 0x994C, 0x994D, 0x994E, 0x994F, 0x9950, 0x9951,
0x9952, 0x9953, 0x9954, 0x9955, 0x9956, 0x9957, 0x9958, 0x9959,
0x995A, 0x995B, 0x995C, 0x995D, 0x995E, 0x995F, 0x9960, 0x9961,
0x9962, 0x9963, 0x9964, 0x9965, 0x9966, 0x9967, 0x9968, 0x9969,
0x996A, 0x996B, 0x996C, 0x996D, 0x996E, 0x996F, 0x9970, 0x9971,
0x9972, 0x9973, 0x9974, 0x9975, 0x9976, 0x9977, 0x9978, 0x9979,
0x997A, 0x997B, 0x997C, 0x997D, 0x997E, 0x9980, 0x9981, 0x9982,
0x9983, 0x9984, 0x9985, 0x9986, 0x9987, 0x9988, 0x9989, 0x998A,
0x998B, 0x998C, 0x998D, 0x998E, 0x998F, 0x9990, 0x9991, 0x9992,
0x9993, 0x9994, 0x9995, 0x9996, 0x9997, 0x9998, 0x9999, 0x999A,
0x999B, 0x999C, 0x999D, 0x999E, 0x999F, 0x99A0, 0x99A1, 0x99A2,
0x99A3, 0x99A4, 0x99A5, 0x99A6, 0x99A7, 0x99A8, 0x99A9, 0x99AA,
0x99AB, 0x99AC, 0x99AD, 0x99AE, 0x99AF, 0x99B0, 0x99B1, 0x99B2,
0x99B3, 0x99B4, 0x99B5, 0x99B6, 0x99B7, 0x99B8, 0x99B9, 0x99BA,
0x99BB, 0x99BC, 0x99BD, 0x99BE, 0x99BF, 0x99C0, 0x99C1, 0x99C2,
0x99C3, 0x99C4, 0x99C5, 0x99C6, 0x99C7, 0x99C8, 0x99C9, 0x99CA,
0x99CB, 0x99CC, 0x99CD, 0x99CE, 0x99CF, 0x99D0, 0x99D1, 0x99D2,
0x99D3, 0x99D4, 0x99D5, 0x99D6, 0x99D7, 0x99D8, 0x99D9, 0x99DA,
0x99DB, 0x99DC, 0x99DD, 0x99DE, 0x99DF, 0x99E0, 0x99E1, 0x99E2,
0x99E3, 0x99E4, 0x99E5, 0x99E6, 0x99E7, 0x99E8, 0x99E9, 0x99EA,
0x99EB, 0x99EC, 0x99ED, 0x99EE, 0x99EF, 0x99F0, 0x99F1, 0x99F2,
0x99F3, 0x99F4, 0x99F5, 0x99F6, 0x99F7, 0x99F8, 0x99F9, 0x99FA,
0x99FB, 0x99FC, 0x99FD, 0x99FE, 0x9A40, 0x9A41, 0x9A42, 0x9A43,
0x9A44, 0x9A45, 0x9A46, 0x9A47, 0x9A48, 0x9A49, 0x9A4A, 0x9A4B,
0x9A4C, 0x9A4D, 0x9A4E, 0x9A4F, 0x9A50, 0x9A51, 0x9A52, 0x9A53,
0x9A54, 0x9A55, 0x9A56, 0x9A57, 0x9A58, 0x9A59, 0x9A5A, 0x9A5B,
0x9A5C, 0x9A5D, 0x9A5E, 0x9A5F, 0x9A60, 0x9A61, 0x9A62, 0x9A63,
0x9A64, 0x9A65, 0x9A66, 0x9A67, 0x9A68, 0x9A69, 0x9A6A, 0x9A6B,
0x9A6C, 0x9A6D, 0x9A6E, 0x9A6F, 0x9A70, 0x9A71, 0x9A72, 0x9A73,
0x9A74, 0x9A75, 0x9A76, 0x9A77, 0x9A78, 0x9A79, 0x9A7A, 0x9A7B,
0x9A7C, 0x9A7D, 0x9A7E, 0x9A80, 0x9A81, 0x9A82, 0x9A83, 0x9A84,
0x9A85, 0x9A86, 0x9A87, 0x9A88, 0x9A89, 0x9A8A, 0x9A8B, 0x9A8C,
0x9A8D, 0x9A8E, 0x9A8F, 0x9A90, 0x9A91, 0x9A92, 0x9A93, 0x9A94,
0x9A95, 0x9A96, 0x9A97, 0x9A98, 0x9A99, 0x9A9A, 0x9A9B, 0x9A9C,
0x9A9D, 0x9A9E, 0x9A9F, 0x9AA0, 0x9AA1, 0x9AA2, 0x9AA3, 0x9AA4,
0x9AA5, 0x9AA6, 0x9AA7, 0x9AA8, 0x9AA9, 0x9AAA, 0x9AAB, 0x9AAC,
0x9AAD, 0x9AAE, 0x9AAF, 0x9AB0, 0x9AB1, 0x9AB2, 0x9AB3, 0x9AB4,
0x9AB5, 0x9AB6, 0x9AB7, 0x9AB8, 0x9AB9, 0x9ABA, 0x9ABB, 0x9ABC,
0x9ABD, 0x9ABE, 0x9ABF, 0x9AC0, 0x9AC1, 0x9AC2, 0x9AC3, 0x9AC4,
0x9AC5, 0x9AC6, 0x9AC7, 0x9AC8, 0x9AC9, 0x9ACA, 0x9ACB, 0x9ACC,
0x9ACD, 0x9ACE, 0x9ACF, 0x9AD0, 0x9AD1, 0x9AD2, 0x9AD3, 0x9AD4,
0x9AD5, 0x9AD6, 0x9AD7, 0x9AD8, 0x9AD9, 0x9ADA, 0x9ADB, 0x9ADC,
0x9ADD, 0x9ADE, 0x9ADF, 0x9AE0, 0x9AE1, 0x9AE2, 0x9AE3, 0x9AE4,
0x9AE5, 0x9AE6, 0x9AE7, 0x9AE8, 0x9AE9, 0x9AEA, 0x9AEB, 0x9AEC,
0x9AED, 0x9AEE, 0x9AEF, 0x9AF0, 0x9AF1, 0x9AF2, 0x9AF3, 0x9AF4,
0x9AF5, 0x9AF6, 0x9AF7, 0x9AF8, 0x9AF9, 0x9AFA, 0x9AFB, 0x9AFC,
0x9AFD, 0x9AFE, 0x9B40, 0x9B41, 0x9B42, 0x9B43, 0x9B44, 0x9B45,
0x9B46, 0x9B47, 0x9B48, 0x9B49, 0x9B4A, 0x9B4B, 0x9B4C, 0x9B4D,
0x9B4E, 0x9B4F, 0x9B50, 0x9B51, 0x9B52, 0x9B53, 0x9B54, 0x9B55,
0x9B56, 0x9B57, 0x9B58, 0x9B59, 0x9B5A, 0x9B5B, 0x9B5C, 0x9B5D,
0x9B5E, 0x9B5F, 0x9B60, 0x9B61, 0x9B62, 0x9B63, 0x9B64, 0x9B65,
0x9B66, 0x9B67, 0x9B68, 0x9B69, 0x9B6A, 0x9B6B, 0x9B6C, 0x9B6D,
0x9B6E, 0x9B6F, 0x9B70, 0x9B71, 0x9B72, 0x9B73, 0x9B74, 0x9B75,
0x9B76, 0x9B77, 0x9B78, 0x9B79, 0x9B7A, 0x9B7B, 0x9B7C, 0x9B7D,
0x9B7E, 0x9B80, 0x9B81, 0x9B82, 0x9B83, 0x9B84, 0x9B85, 0x9B86,
0x9B87, 0x9B88, 0x9B89, 0x9B8A, 0x9B8B, 0x9B8C, 0x9B8D, 0x9B8E,
0x9B8F, 0x9B90, 0x9B91, 0x9B92, 0x9B93, 0x9B94, 0x9B95, 0x9B96,
0x9B97, 0x9B98, 0x9B99, 0x9B9A, 0x9B9B, 0x9B9C, 0x9B9D, 0x9B9E,
0x9B9F, 0x9BA0, 0x9BA1, 0x9BA2, 0x9BA3, 0x9BA4, 0x9BA5, 0x9BA6,
0x9BA7, 0x9BA8, 0x9BA9, 0x9BAA, 0x9BAB, 0x9BAC, 0x9BAD, 0x9BAE,
0x9BAF, 0x9BB0, 0x9BB1, 0x9BB2, 0x9BB3, 0x9BB4, 0x9BB5, 0x9BB6,
0x9BB7, 0x9BB8, 0x9BB9, 0x9BBA, 0x9BBB, 0x9BBC, 0x9BBD, 0x9BBE,
0x9BBF, 0x9BC0, 0x9BC1, 0x9BC2, 0x9BC3, 0x9BC4, 0x9BC5, 0x9BC6,
0x9BC7, 0x9BC8, 0x9BC9, 0x9BCA, 0x9BCB, 0x9BCC, 0x9BCD, 0x9BCE,
0x9BCF, 0x9BD0, 0x9BD1, 0x9BD2, 0x9BD3, 0x9BD4, 0x9BD5, 0x9BD6,
0x9BD7, 0x9BD8, 0x9BD9, 0x9BDA, 0x9BDB, 0x9BDC, 0x9BDD, 0x9BDE,
0x9BDF, 0x9BE0, 0x9BE1, 0x9BE2, 0x9BE3, 0x9BE4, 0x9BE5, 0x9BE6,
0x9BE7, 0x9BE8, 0x9BE9, 0x9BEA, 0x9BEB, 0x9BEC, 0x9BED, 0x9BEE,
0x9BEF, 0x9BF0, 0x9BF1, 0x9BF2, 0x9BF3, 0x9BF4, 0x9BF5, 0x9BF6,
0x9BF7, 0x9BF8, 0x9BF9, 0x9BFA, 0x9BFB, 0x9BFC, 0x9BFD, 0x9BFE,
0x9C40, 0x9C41, 0x9C42, 0x9C43, 0x9C44, 0x9C45, 0x9C46, 0x9C47,
0x9C48, 0x9C49, 0x9C4A, 0x9C4B, 0x9C4C, 0x9C4D, 0x9C4E, 0x9C4F,
0x9C50, 0x9C51, 0x9C52, 0x9C53, 0x9C54, 0x9C55, 0x9C56, 0x9C57,
0x9C58, 0x9C59, 0x9C5A, 0x9C5B, 0x9C5C, 0x9C5D, 0x9C5E, 0x9C5F,
0x9C60, 0x9C61, 0x9C62, 0x9C63, 0x9C64, 0x9C65, 0x9C66, 0x9C67,
0x9C68, 0x9C69, 0x9C6A, 0x9C6B, 0x9C6C, 0x9C6D, 0x9C6E, 0x9C6F,
0x9C70, 0x9C71, 0x9C72, 0x9C73, 0x9C74, 0x9C75, 0x9C76, 0x9C77,
0x9C78, 0x9C79, 0x9C7A, 0x9C7B, 0x9C7C, 0x9C7D, 0x9C7E, 0x9C80,
0x9C81, 0x9C82, 0x9C83, 0x9C84, 0x9C85, 0x9C86, 0x9C87, 0x9C88,
0x9C89, 0x9C8A, 0x9C8B, 0x9C8C, 0x9C8D, 0x9C8E, 0x9C8F, 0x9C90,
0x9C91, 0x9C92, 0x9C93, 0x9C94, 0x9C95, 0x9C96, 0x9C97, 0x9C98,
0x9C99, 0x9C9A, 0x9C9B, 0x9C9C, 0x9C9D, 0x9C9E, 0x9C9F, 0x9CA0,
0x9CA1, 0x9CA2, 0x9CA3, 0x9CA4, 0x9CA5, 0x9CA6, 0x9CA7, 0x9CA8,
0x9CA9, 0x9CAA, 0x9CAB, 0x9CAC, 0x9CAD, 0x9CAE, 0x9CAF, 0x9CB0,
0x9CB1, 0x9CB2, 0x9CB3, 0x9CB4, 0x9CB5, 0x9CB6, 0x9CB7, 0x9CB8,
0x9CB9, 0x9CBA, 0x9CBB, 0x9CBC, 0x9CBD, 0x9CBE, 0x9CBF, 0x9CC0,
0x9CC1, 0x9CC2, 0x9CC3, 0x9CC4, 0x9CC5, 0x9CC6, 0x9CC7, 0x9CC8,
0x9CC9, 0x9CCA, 0x9CCB, 0x9CCC, 0x9CCD, 0x9CCE, 0x9CCF, 0x9CD0,
0x9CD1, 0x9CD2, 0x9CD3, 0x9CD4, 0x9CD5, 0x9CD6, 0x9CD7, 0x9CD8,
0x9CD9, 0x9CDA, 0x9CDB, 0x9CDC, 0x9CDD, 0x9CDE, 0x9CDF, 0x9CE0,
0x9CE1, 0x9CE2, 0x9CE3, 0x9CE4, 0x9CE5, 0x9CE6, 0x9CE7, 0x9CE8,
0x9CE9, 0x9CEA, 0x9CEB, 0x9CEC, 0x9CED, 0x9CEE, 0x9CEF, 0x9CF0,
0x9CF1, 0x9CF2, 0x9CF3, 0x9CF4, 0x9CF5, 0x9CF6, 0x9CF7, 0x9CF8,
0x9CF9, 0x9CFA, 0x9CFB, 0x9CFC, 0x9CFD, 0x9CFE, 0x9D40, 0x9D41,
0x9D42, 0x9D43, 0x9D44, 0x9D45, 0x9D46, 0x9D47, 0x9D48, 0x9D49,
0x9D4A, 0x9D4B, 0x9D4C, 0x9D4D, 0x9D4E, 0x9D4F, 0x9D50, 0x9D51,
0x9D52, 0x9D53, 0x9D54, 0x9D55, 0x9D56, 0x9D57, 0x9D58, 0x9D59,
0x9D5A, 0x9D5B, 0x9D5C, 0x9D5D, 0x9D5E, 0x9D5F, 0x9D60, 0x9D61,
0x9D62, 0x9D63, 0x9D64, 0x9D65, 0x9D66, 0x9D67, 0x9D68, 0x9D69,
0x9D6A, 0x9D6B, 0x9D6C, 0x9D6D, 0x9D6E, 0x9D6F, 0x9D70, 0x9D71,
0x9D72, 0x9D73, 0x9D74, 0x9D75, 0x9D76, 0x9D77, 0x9D78, 0x9D79,
0x9D7A, 0x9D7B, 0x9D7C, 0x9D7D, 0x9D7E, 0x9D80, 0x9D81, 0x9D82,
0x9D83, 0x9D84, 0x9D85, 0x9D86, 0x9D87, 0x9D88, 0x9D89, 0x9D8A,
0x9D8B, 0x9D8C, 0x9D8D, 0x9D8E, 0x9D8F, 0x9D90, 0x9D91, 0x9D92,
0x9D93, 0x9D94, 0x9D95, 0x9D96, 0x9D97, 0x9D98, 0x9D99, 0x9D9A,
0x9D9B, 0x9D9C, 0x9D9D, 0x9D9E, 0x9D9F, 0x9DA0, 0x9DA1, 0x9DA2,
0x9DA3, 0x9DA4, 0x9DA5, 0x9DA6, 0x9DA7, 0x9DA8, 0x9DA9, 0x9DAA,
0x9DAB, 0x9DAC, 0x9DAD, 0x9DAE, 0x9DAF, 0x9DB0, 0x9DB1, 0x9DB2,
0x9DB3, 0x9DB4, 0x9DB5, 0x9DB6, 0x9DB7, 0x9DB8, 0x9DB9, 0x9DBA,
0x9DBB, 0x9DBC, 0x9DBD, 0x9DBE, 0x9DBF, 0x9DC0, 0x9DC1, 0x9DC2,
0x9DC3, 0x9DC4, 0x9DC5, 0x9DC6, 0x9DC7, 0x9DC8, 0x9DC9, 0x9DCA,
0x9DCB, 0x9DCC, 0x9DCD, 0x9DCE, 0x9DCF, 0x9DD0, 0x9DD1, 0x9DD2,
0x9DD3, 0x9DD4, 0x9DD5, 0x9DD6, 0x9DD7, 0x9DD8, 0x9DD9, 0x9DDA,
0x9DDB, 0x9DDC, 0x9DDD, 0x9DDE, 0x9DDF, 0x9DE0, 0x9DE1, 0x9DE2,
0x9DE3, 0x9DE4, 0x9DE5, 0x9DE6, 0x9DE7, 0x9DE8, 0x9DE9, 0x9DEA,
0x9DEB, 0x9DEC, 0x9DED, 0x9DEE, 0x9DEF, 0x9DF0, 0x9DF1, 0x9DF2,
0x9DF3, 0x9DF4, 0x9DF5, 0x9DF6, 0x9DF7, 0x9DF8, 0x9DF9, 0x9DFA,
0x9DFB, 0x9DFC, 0x9DFD, 0x9DFE, 0x9E40, 0x9E41, 0x9E42, 0x9E43,
0x9E44, 0x9E45, 0x9E46, 0x9E47, 0x9E48, 0x9E49, 0x9E4A, 0x9E4B,
0x9E4C, 0x9E4D, 0x9E4E, 0x9E4F, 0x9E50, 0x9E51, 0x9E52, 0x9E53,
0x9E54, 0x9E55, 0x9E56, 0x9E57, 0x9E58, 0x9E59, 0x9E5A, 0x9E5B,
0x9E5C, 0x9E5D, 0x9E5E, 0x9E5F, 0x9E60, 0x9E61, 0x9E62, 0x9E63,
0x9E64, 0x9E65, 0x9E66, 0x9E67, 0x9E68, 0x9E69, 0x9E6A, 0x9E6B,
0x9E6C, 0x9E6D, 0x9E6E, 0x9E6F, 0x9E70, 0x9E71, 0x9E72, 0x9E73,
0x9E74, 0x9E75, 0x9E76, 0x9E77, 0x9E78, 0x9E79, 0x9E7A, 0x9E7B,
0x9E7C, 0x9E7D, 0x9E7E, 0x9E80, 0x9E81, 0x9E82, 0x9E83, 0x9E84,
0x9E85, 0x9E86, 0x9E87, 0x9E88, 0x9E89, 0x9E8A, 0x9E8B, 0x9E8C,
0x9E8D, 0x9E8E, 0x9E8F, 0x9E90, 0x9E91, 0x9E92, 0x9E93, 0x9E94,
0x9E95, 0x9E96, 0x9E97, 0x9E98, 0x9E99, 0x9E9A, 0x9E9B, 0x9E9C,
0x9E9D, 0x9E9E, 0x9E9F, 0x9EA0, 0x9EA1, 0x9EA2, 0x9EA3, 0x9EA4,
0x9EA5, 0x9EA6, 0x9EA7, 0x9EA8, 0x9EA9, 0x9EAA, 0x9EAB, 0x9EAC,
0x9EAD, 0x9EAE, 0x9EAF, 0x9EB0, 0x9EB1, 0x9EB2, 0x9EB3, 0x9EB4,
0x9EB5, 0x9EB6, 0x9EB7, 0x9EB8, 0x9EB9, 0x9EBA, 0x9EBB, 0x9EBC,
0x9EBD, 0x9EBE, 0x9EBF, 0x9EC0, 0x9EC1, 0x9EC2, 0x9EC3, 0x9EC4,
0x9EC5, 0x9EC6, 0x9EC7, 0x9EC8, 0x9EC9, 0x9ECA, 0x9ECB, 0x9ECC,
0x9ECD, 0x9ECE, 0x9ECF, 0x9ED0, 0x9ED1, 0x9ED2, 0x9ED3, 0x9ED4,
0x9ED5, 0x9ED6, 0x9ED7, 0x9ED8, 0x9ED9, 0x9EDA, 0x9EDB, 0x9EDC,
0x9EDD, 0x9EDE, 0x9EDF, 0x9EE0, 0x9EE1, 0x9EE2, 0x9EE3, 0x9EE4,
0x9EE5, 0x9EE6, 0x9EE7, 0x9EE8, 0x9EE9, 0x9EEA, 0x9EEB, 0x9EEC,
0x9EED, 0x9EEE, 0x9EEF, 0x9EF0, 0x9EF1, 0x9EF2, 0x9EF3, 0x9EF4,
0x9EF5, 0x9EF6, 0x9EF7, 0x9EF8, 0x9EF9, 0x9EFA, 0x9EFB, 0x9EFC,
0x9EFD, 0x9EFE, 0x9F40, 0x9F41, 0x9F42, 0x9F43, 0x9F44, 0x9F45,
0x9F46, 0x9F47, 0x9F48, 0x9F49, 0x9F4A, 0x9F4B, 0x9F4C, 0x9F4D,
0x9F4E, 0x9F4F, 0x9F50, 0x9F51, 0x9F52, 0x9F53, 0x9F54, 0x9F55,
0x9F56, 0x9F57, 0x9F58, 0x9F59, 0x9F5A, 0x9F5B, 0x9F5C, 0x9F5D,
0x9F5E, 0x9F5F, 0x9F60, 0x9F61, 0x9F62, 0x9F63, 0x9F64, 0x9F65,
0x9F66, 0x9F67, 0x9F68, 0x9F69, 0x9F6A, 0x9F6B, 0x9F6C, 0x9F6D,
0x9F6E, 0x9F6F, 0x9F70, 0x9F71, 0x9F72, 0x9F73, 0x9F74, 0x9F75,
0x9F76, 0x9F77, 0x9F78, 0x9F79, 0x9F7A, 0x9F7B, 0x9F7C, 0x9F7D,
0x9F7E, 0x9F80, 0x9F81, 0x9F82, 0x9F83, 0x9F84, 0x9F85, 0x9F86,
0x9F87, 0x9F88, 0x9F89, 0x9F8A, 0x9F8B, 0x9F8C, 0x9F8D, 0x9F8E,
0x9F8F, 0x9F90, 0x9F91, 0x9F92, 0x9F93, 0x9F94, 0x9F95, 0x9F96,
0x9F97, 0x9F98, 0x9F99, 0x9F9A, 0x9F9B, 0x9F9C, 0x9F9D, 0x9F9E,
0x9F9F, 0x9FA0, 0x9FA1, 0x9FA2, 0x9FA3, 0x9FA4, 0x9FA5, 0x9FA6,
0x9FA7, 0x9FA8, 0x9FA9, 0x9FAA, 0x9FAB, 0x9FAC, 0x9FAD, 0x9FAE,
0x9FAF, 0x9FB0, 0x9FB1, 0x9FB2, 0x9FB3, 0x9FB4, 0x9FB5, 0x9FB6,
0x9FB7, 0x9FB8, 0x9FB9, 0x9FBA, 0x9FBB, 0x9FBC, 0x9FBD, 0x9FBE,
0x9FBF, 0x9FC0, 0x9FC1, 0x9FC2, 0x9FC3, 0x9FC4, 0x9FC5, 0x9FC6,
0x9FC7, 0x9FC8, 0x9FC9, 0x9FCA, 0x9FCB, 0x9FCC, 0x9FCD, 0x9FCE,
0x9FCF, 0x9FD0, 0x9FD1, 0x9FD2, 0x9FD3, 0x9FD4, 0x9FD5, 0x9FD6,
0x9FD7, 0x9FD8, 0x9FD9, 0x9FDA, 0x9FDB, 0x9FDC, 0x9FDD, 0x9FDE,
0x9FDF, 0x9FE0, 0x9FE1, 0x9FE2, 0x9FE3, 0x9FE4, 0x9FE5, 0x9FE6,
0x9FE7, 0x9FE8, 0x9FE9, 0x9FEA, 0x9FEB, 0x9FEC, 0x9FED, 0x9FEE,
0x9FEF, 0x9FF0, 0x9FF1, 0x9FF2, 0x9FF3, 0x9FF4, 0x9FF5, 0x9FF6,
0x9FF7, 0x9FF8, 0x9FF9, 0x9FFA, 0x9FFB, 0x9FFC, 0x9FFD, 0x9FFE,
0xA040, 0xA041, 0xA042, 0xA043, 0xA044, 0xA045, 0xA046, 0xA047,
0xA048, 0xA049, 0xA04A, 0xA04B, 0xA04C, 0xA04D, 0xA04E, 0xA04F,
0xA050, 0xA051, 0xA052, 0xA053, 0xA054, 0xA055, 0xA056, 0xA057,
0xA058, 0xA059, 0xA05A, 0xA05B, 0xA05C, 0xA05D, 0xA05E, 0xA05F,
0xA060, 0xA061, 0xA062, 0xA063, 0xA064, 0xA065, 0xA066, 0xA067,
0xA068, 0xA069, 0xA06A, 0xA06B, 0xA06C, 0xA06D, 0xA06E, 0xA06F,
0xA070, 0xA071, 0xA072, 0xA073, 0xA074, 0xA075, 0xA076, 0xA077,
0xA078, 0xA079, 0xA07A, 0xA07B, 0xA07C, 0xA07D, 0xA07E, 0xA080,
0xA081, 0xA082, 0xA083, 0xA084, 0xA085, 0xA086, 0xA087, 0xA088,
0xA089, 0xA08A, 0xA08B, 0xA08C, 0xA08D, 0xA08E, 0xA08F, 0xA090,
0xA091, 0xA092, 0xA093, 0xA094, 0xA095, 0xA096, 0xA097, 0xA098,
0xA099, 0xA09A, 0xA09B, 0xA09C, 0xA09D, 0xA09E, 0xA09F, 0xA0A0,
0xA0A1, 0xA0A2, 0xA0A3, 0xA0A4, 0xA0A5, 0xA0A6, 0xA0A7, 0xA0A8,
0xA0A9, 0xA0AA, 0xA0AB, 0xA0AC, 0xA0AD, 0xA0AE, 0xA0AF, 0xA0B0,
0xA0B1, 0xA0B2, 0xA0B3, 0xA0B4, 0xA0B5, 0xA0B6, 0xA0B7, 0xA0B8,
0xA0B9, 0xA0BA, 0xA0BB, 0xA0BC, 0xA0BD, 0xA0BE, 0xA0BF, 0xA0C0,
0xA0C1, 0xA0C2, 0xA0C3, 0xA0C4, 0xA0C5, 0xA0C6, 0xA0C7, 0xA0C8,
0xA0C9, 0xA0CA, 0xA0CB, 0xA0CC, 0xA0CD, 0xA0CE, 0xA0CF, 0xA0D0,
0xA0D1, 0xA0D2, 0xA0D3, 0xA0D4, 0xA0D5, 0xA0D6, 0xA0D7, 0xA0D8,
0xA0D9, 0xA0DA, 0xA0DB, 0xA0DC, 0xA0DD, 0xA0DE, 0xA0DF, 0xA0E0,
0xA0E1, 0xA0E2, 0xA0E3, 0xA0E4, 0xA0E5, 0xA0E6, 0xA0E7, 0xA0E8,
0xA0E9, 0xA0EA, 0xA0EB, 0xA0EC, 0xA0ED, 0xA0EE, 0xA0EF, 0xA0F0,
0xA0F1, 0xA0F2, 0xA0F3, 0xA0F4, 0xA0F5, 0xA0F6, 0xA0F7, 0xA0F8,
0xA0F9, 0xA0FA, 0xA0FB, 0xA0FC, 0xA0FD, 0xA0FE, 0xAA40, 0xAA41,
0xAA42, 0xAA43, 0xAA44, 0xAA45, 0xAA46, 0xAA47, 0xAA48, 0xAA49,
0xAA4A, 0xAA4B, 0xAA4C, 0xAA4D, 0xAA4E, 0xAA4F, 0xAA50, 0xAA51,
0xAA52, 0xAA53, 0xAA54, 0xAA55, 0xAA56, 0xAA57, 0xAA58, 0xAA59,
0xAA5A, 0xAA5B, 0xAA5C, 0xAA5D, 0xAA5E, 0xAA5F, 0xAA60, 0xAA61,
0xAA62, 0xAA63, 0xAA64, 0xAA65, 0xAA66, 0xAA67, 0xAA68, 0xAA69,
0xAA6A, 0xAA6B, 0xAA6C, 0xAA6D, 0xAA6E, 0xAA6F, 0xAA70, 0xAA71,
0xAA72, 0xAA73, 0xAA74, 0xAA75, 0xAA76, 0xAA77, 0xAA78, 0xAA79,
0xAA7A, 0xAA7B, 0xAA7C, 0xAA7D, 0xAA7E, 0xAA80, 0xAA81, 0xAA82,
0xAA83, 0xAA84, 0xAA85, 0xAA86, 0xAA87, 0xAA88, 0xAA89, 0xAA8A,
0xAA8B, 0xAA8C, 0xAA8D, 0xAA8E, 0xAA8F, 0xAA90, 0xAA91, 0xAA92,
0xAA93, 0xAA94, 0xAA95, 0xAA96, 0xAA97, 0xAA98, 0xAA99, 0xAA9A,
0xAA9B, 0xAA9C, 0xAA9D, 0xAA9E, 0xAA9F, 0xAAA0, 0xAB40, 0xAB41,
0xAB42, 0xAB43, 0xAB44, 0xAB45, 0xAB46, 0xAB47, 0xAB48, 0xAB49,
0xAB4A, 0xAB4B, 0xAB4C, 0xAB4D, 0xAB4E, 0xAB4F, 0xAB50, 0xAB51,
0xAB52, 0xAB53, 0xAB54, 0xAB55, 0xAB56, 0xAB57, 0xAB58, 0xAB59,
0xAB5A, 0xAB5B, 0xAB5C, 0xAB5D, 0xAB5E, 0xAB5F, 0xAB60, 0xAB61,
0xAB62, 0xAB63, 0xAB64, 0xAB65, 0xAB66, 0xAB67, 0xAB68, 0xAB69,
0xAB6A, 0xAB6B, 0xAB6C, 0xAB6D, 0xAB6E, 0xAB6F, 0xAB70, 0xAB71,
0xAB72, 0xAB73, 0xAB74, 0xAB75, 0xAB76, 0xAB77, 0xAB78, 0xAB79,
0xAB7A, 0xAB7B, 0xAB7C, 0xAB7D, 0xAB7E, 0xAB80, 0xAB81, 0xAB82,
0xAB83, 0xAB84, 0xAB85, 0xAB86, 0xAB87, 0xAB88, 0xAB89, 0xAB8A,
0xAB8B, 0xAB8C, 0xAB8D, 0xAB8E, 0xAB8F, 0xAB90, 0xAB91, 0xAB92,
0xAB93, 0xAB94, 0xAB95, 0xAB96, 0xAB97, 0xAB98, 0xAB99, 0xAB9A,
0xAB9B, 0xAB9C, 0xAB9D, 0xAB9E, 0xAB9F, 0xABA0, 0xAC40, 0xAC41,
0xAC42, 0xAC43, 0xAC44, 0xAC45, 0xAC46, 0xAC47, 0xAC48, 0xAC49,
0xAC4A, 0xAC4B, 0xAC4C, 0xAC4D, 0xAC4E, 0xAC4F, 0xAC50, 0xAC51,
0xAC52, 0xAC53, 0xAC54, 0xAC55, 0xAC56, 0xAC57, 0xAC58, 0xAC59,
0xAC5A, 0xAC5B, 0xAC5C, 0xAC5D, 0xAC5E, 0xAC5F, 0xAC60, 0xAC61,
0xAC62, 0xAC63, 0xAC64, 0xAC65, 0xAC66, 0xAC67, 0xAC68, 0xAC69,
0xAC6A, 0xAC6B, 0xAC6C, 0xAC6D, 0xAC6E, 0xAC6F, 0xAC70, 0xAC71,
0xAC72, 0xAC73, 0xAC74, 0xAC75, 0xAC76, 0xAC77, 0xAC78, 0xAC79,
0xAC7A, 0xAC7B, 0xAC7C, 0xAC7D, 0xAC7E, 0xAC80, 0xAC81, 0xAC82,
0xAC83, 0xAC84, 0xAC85, 0xAC86, 0xAC87, 0xAC88, 0xAC89, 0xAC8A,
0xAC8B, 0xAC8C, 0xAC8D, 0xAC8E, 0xAC8F, 0xAC90, 0xAC91, 0xAC92,
0xAC93, 0xAC94, 0xAC95, 0xAC96, 0xAC97, 0xAC98, 0xAC99, 0xAC9A,
0xAC9B, 0xAC9C, 0xAC9D, 0xAC9E, 0xAC9F, 0xACA0, 0xAD40, 0xAD41,
0xAD42, 0xAD43, 0xAD44, 0xAD45, 0xAD46, 0xAD47, 0xAD48, 0xAD49,
0xAD4A, 0xAD4B, 0xAD4C, 0xAD4D, 0xAD4E, 0xAD4F, 0xAD50, 0xAD51,
0xAD52, 0xAD53, 0xAD54, 0xAD55, 0xAD56, 0xAD57, 0xAD58, 0xAD59,
0xAD5A, 0xAD5B, 0xAD5C, 0xAD5D, 0xAD5E, 0xAD5F, 0xAD60, 0xAD61,
0xAD62, 0xAD63, 0xAD64, 0xAD65, 0xAD66, 0xAD67, 0xAD68, 0xAD69,
0xAD6A, 0xAD6B, 0xAD6C, 0xAD6D, 0xAD6E, 0xAD6F, 0xAD70, 0xAD71,
0xAD72, 0xAD73, 0xAD74, 0xAD75, 0xAD76, 0xAD77, 0xAD78, 0xAD79,
0xAD7A, 0xAD7B, 0xAD7C, 0xAD7D, 0xAD7E, 0xAD80, 0xAD81, 0xAD82,
0xAD83, 0xAD84, 0xAD85, 0xAD86, 0xAD87, 0xAD88, 0xAD89, 0xAD8A,
0xAD8B, 0xAD8C, 0xAD8D, 0xAD8E, 0xAD8F, 0xAD90, 0xAD91, 0xAD92,
0xAD93, 0xAD94, 0xAD95, 0xAD96, 0xAD97, 0xAD98, 0xAD99, 0xAD9A,
0xAD9B, 0xAD9C, 0xAD9D, 0xAD9E, 0xAD9F, 0xADA0, 0xAE40, 0xAE41,
0xAE42, 0xAE43, 0xAE44, 0xAE45, 0xAE46, 0xAE47, 0xAE48, 0xAE49,
0xAE4A, 0xAE4B, 0xAE4C, 0xAE4D, 0xAE4E, 0xAE4F, 0xAE50, 0xAE51,
0xAE52, 0xAE53, 0xAE54, 0xAE55, 0xAE56, 0xAE57, 0xAE58, 0xAE59,
0xAE5A, 0xAE5B, 0xAE5C, 0xAE5D, 0xAE5E, 0xAE5F, 0xAE60, 0xAE61,
0xAE62, 0xAE63, 0xAE64, 0xAE65, 0xAE66, 0xAE67, 0xAE68, 0xAE69,
0xAE6A, 0xAE6B, 0xAE6C, 0xAE6D, 0xAE6E, 0xAE6F, 0xAE70, 0xAE71,
0xAE72, 0xAE73, 0xAE74, 0xAE75, 0xAE76, 0xAE77, 0xAE78, 0xAE79,
0xAE7A, 0xAE7B, 0xAE7C, 0xAE7D, 0xAE7E, 0xAE80, 0xAE81, 0xAE82,
0xAE83, 0xAE84, 0xAE85, 0xAE86, 0xAE87, 0xAE88, 0xAE89, 0xAE8A,
0xAE8B, 0xAE8C, 0xAE8D, 0xAE8E, 0xAE8F, 0xAE90, 0xAE91, 0xAE92,
0xAE93, 0xAE94, 0xAE95, 0xAE96, 0xAE97, 0xAE98, 0xAE99, 0xAE9A,
0xAE9B, 0xAE9C, 0xAE9D, 0xAE9E, 0xAE9F, 0xAEA0, 0xAF40, 0xAF41,
0xAF42, 0xAF43, 0xAF44, 0xAF45, 0xAF46, 0xAF47, 0xAF48, 0xAF49,
0xAF4A, 0xAF4B, 0xAF4C, 0xAF4D, 0xAF4E, 0xAF4F, 0xAF50, 0xAF51,
0xAF52, 0xAF53, 0xAF54, 0xAF55, 0xAF56, 0xAF57, 0xAF58, 0xAF59,
0xAF5A, 0xAF5B, 0xAF5C, 0xAF5D, 0xAF5E, 0xAF5F, 0xAF60, 0xAF61,
0xAF62, 0xAF63, 0xAF64, 0xAF65, 0xAF66, 0xAF67, 0xAF68, 0xAF69,
0xAF6A, 0xAF6B, 0xAF6C, 0xAF6D, 0xAF6E, 0xAF6F, 0xAF70, 0xAF71,
0xAF72, 0xAF73, 0xAF74, 0xAF75, 0xAF76, 0xAF77, 0xAF78, 0xAF79,
0xAF7A, 0xAF7B, 0xAF7C, 0xAF7D, 0xAF7E, 0xAF80, 0xAF81, 0xAF82,
0xAF83, 0xAF84, 0xAF85, 0xAF86, 0xAF87, 0xAF88, 0xAF89, 0xAF8A,
0xAF8B, 0xAF8C, 0xAF8D, 0xAF8E, 0xAF8F, 0xAF90, 0xAF91, 0xAF92,
0xAF93, 0xAF94, 0xAF95, 0xAF96, 0xAF97, 0xAF98, 0xAF99, 0xAF9A,
0xAF9B, 0xAF9C, 0xAF9D, 0xAF9E, 0xAF9F, 0xAFA0, 0xB040, 0xB041,
0xB042, 0xB043, 0xB044, 0xB045, 0xB046, 0xB047, 0xB048, 0xB049,
0xB04A, 0xB04B, 0xB04C, 0xB04D, 0xB04E, 0xB04F, 0xB050, 0xB051,
0xB052, 0xB053, 0xB054, 0xB055, 0xB056, 0xB057, 0xB058, 0xB059,
0xB05A, 0xB05B, 0xB05C, 0xB05D, 0xB05E, 0xB05F, 0xB060, 0xB061,
0xB062, 0xB063, 0xB064, 0xB065, 0xB066, 0xB067, 0xB068, 0xB069,
0xB06A, 0xB06B, 0xB06C, 0xB06D, 0xB06E, 0xB06F, 0xB070, 0xB071,
0xB072, 0xB073, 0xB074, 0xB075, 0xB076, 0xB077, 0xB078, 0xB079,
0xB07A, 0xB07B, 0xB07C, 0xB07D, 0xB07E, 0xB080, 0xB081, 0xB082,
0xB083, 0xB084, 0xB085, 0xB086, 0xB087, 0xB088, 0xB089, 0xB08A,
0xB08B, 0xB08C, 0xB08D, 0xB08E, 0xB08F, 0xB090, 0xB091, 0xB092,
0xB093, 0xB094, 0xB095, 0xB096, 0xB097, 0xB098, 0xB099, 0xB09A,
0xB09B, 0xB09C, 0xB09D, 0xB09E, 0xB09F, 0xB0A0, 0xB140, 0xB141,
0xB142, 0xB143, 0xB144, 0xB145, 0xB146, 0xB147, 0xB148, 0xB149,
0xB14A, 0xB14B, 0xB14C, 0xB14D, 0xB14E, 0xB14F, 0xB150, 0xB151,
0xB152, 0xB153, 0xB154, 0xB155, 0xB156, 0xB157, 0xB158, 0xB159,
0xB15A, 0xB15B, 0xB15C, 0xB15D, 0xB15E, 0xB15F, 0xB160, 0xB161,
0xB162, 0xB163, 0xB164, 0xB165, 0xB166, 0xB167, 0xB168, 0xB169,
0xB16A, 0xB16B, 0xB16C, 0xB16D, 0xB16E, 0xB16F, 0xB170, 0xB171,
0xB172, 0xB173, 0xB174, 0xB175, 0xB176, 0xB177, 0xB178, 0xB179,
0xB17A, 0xB17B, 0xB17C, 0xB17D, 0xB17E, 0xB180, 0xB181, 0xB182,
0xB183, 0xB184, 0xB185, 0xB186, 0xB187, 0xB188, 0xB189, 0xB18A,
0xB18B, 0xB18C, 0xB18D, 0xB18E, 0xB18F, 0xB190, 0xB191, 0xB192,
0xB193, 0xB194, 0xB195, 0xB196, 0xB197, 0xB198, 0xB199, 0xB19A,
0xB19B, 0xB19C, 0xB19D, 0xB19E, 0xB19F, 0xB1A0, 0xB240, 0xB241,
0xB242, 0xB243, 0xB244, 0xB245, 0xB246, 0xB247, 0xB248, 0xB249,
0xB24A, 0xB24B, 0xB24C, 0xB24D, 0xB24E, 0xB24F, 0xB250, 0xB251,
0xB252, 0xB253, 0xB254, 0xB255, 0xB256, 0xB257, 0xB258, 0xB259,
0xB25A, 0xB25B, 0xB25C, 0xB25D, 0xB25E, 0xB25F, 0xB260, 0xB261,
0xB262, 0xB263, 0xB264, 0xB265, 0xB266, 0xB267, 0xB268, 0xB269,
0xB26A, 0xB26B, 0xB26C, 0xB26D, 0xB26E, 0xB26F, 0xB270, 0xB271,
0xB272, 0xB273, 0xB274, 0xB275, 0xB276, 0xB277, 0xB278, 0xB279,
0xB27A, 0xB27B, 0xB27C, 0xB27D, 0xB27E, 0xB280, 0xB281, 0xB282,
0xB283, 0xB284, 0xB285, 0xB286, 0xB287, 0xB288, 0xB289, 0xB28A,
0xB28B, 0xB28C, 0xB28D, 0xB28E, 0xB28F, 0xB290, 0xB291, 0xB292,
0xB293, 0xB294, 0xB295, 0xB296, 0xB297, 0xB298, 0xB299, 0xB29A,
0xB29B, 0xB29C, 0xB29D, 0xB29E, 0xB29F, 0xB2A0, 0xB340, 0xB341,
0xB342, 0xB343, 0xB344, 0xB345, 0xB346, 0xB347, 0xB348, 0xB349,
0xB34A, 0xB34B, 0xB34C, 0xB34D, 0xB34E, 0xB34F, 0xB350, 0xB351,
0xB352, 0xB353, 0xB354, 0xB355, 0xB356, 0xB357, 0xB358, 0xB359,
0xB35A, 0xB35B, 0xB35C, 0xB35D, 0xB35E, 0xB35F, 0xB360, 0xB361,
0xB362, 0xB363, 0xB364, 0xB365, 0xB366, 0xB367, 0xB368, 0xB369,
0xB36A, 0xB36B, 0xB36C, 0xB36D, 0xB36E, 0xB36F, 0xB370, 0xB371,
0xB372, 0xB373, 0xB374, 0xB375, 0xB376, 0xB377, 0xB378, 0xB379,
0xB37A, 0xB37B, 0xB37C, 0xB37D, 0xB37E, 0xB380, 0xB381, 0xB382,
0xB383, 0xB384, 0xB385, 0xB386, 0xB387, 0xB388, 0xB389, 0xB38A,
0xB38B, 0xB38C, 0xB38D, 0xB38E, 0xB38F, 0xB390, 0xB391, 0xB392,
0xB393, 0xB394, 0xB395, 0xB396, 0xB397, 0xB398, 0xB399, 0xB39A,
0xB39B, 0xB39C, 0xB39D, 0xB39E, 0xB39F, 0xB3A0, 0xB440, 0xB441,
0xB442, 0xB443, 0xB444, 0xB445, 0xB446, 0xB447, 0xB448, 0xB449,
0xB44A, 0xB44B, 0xB44C, 0xB44D, 0xB44E, 0xB44F, 0xB450, 0xB451,
0xB452, 0xB453, 0xB454, 0xB455, 0xB456, 0xB457, 0xB458, 0xB459,
0xB45A, 0xB45B, 0xB45C, 0xB45D, 0xB45E, 0xB45F, 0xB460, 0xB461,
0xB462, 0xB463, 0xB464, 0xB465, 0xB466, 0xB467, 0xB468, 0xB469,
0xB46A, 0xB46B, 0xB46C, 0xB46D, 0xB46E, 0xB46F, 0xB470, 0xB471,
0xB472, 0xB473, 0xB474, 0xB475, 0xB476, 0xB477, 0xB478, 0xB479,
0xB47A, 0xB47B, 0xB47C, 0xB47D, 0xB47E, 0xB480, 0xB481, 0xB482,
0xB483, 0xB484, 0xB485, 0xB486, 0xB487, 0xB488, 0xB489, 0xB48A,
0xB48B, 0xB48C, 0xB48D, 0xB48E, 0xB48F, 0xB490, 0xB491, 0xB492,
0xB493, 0xB494, 0xB495, 0xB496, 0xB497, 0xB498, 0xB499, 0xB49A,
0xB49B, 0xB49C, 0xB49D, 0xB49E, 0xB49F, 0xB4A0, 0xB540, 0xB541,
0xB542, 0xB543, 0xB544, 0xB545, 0xB546, 0xB547, 0xB548, 0xB549,
0xB54A, 0xB54B, 0xB54C, 0xB54D, 0xB54E, 0xB54F, 0xB550, 0xB551,
0xB552, 0xB553, 0xB554, 0xB555, 0xB556, 0xB557, 0xB558, 0xB559,
0xB55A, 0xB55B, 0xB55C, 0xB55D, 0xB55E, 0xB55F, 0xB560, 0xB561,
0xB562, 0xB563, 0xB564, 0xB565, 0xB566, 0xB567, 0xB568, 0xB569,
0xB56A, 0xB56B, 0xB56C, 0xB56D, 0xB56E, 0xB56F, 0xB570, 0xB571,
0xB572, 0xB573, 0xB574, 0xB575, 0xB576, 0xB577, 0xB578, 0xB579,
0xB57A, 0xB57B, 0xB57C, 0xB57D, 0xB57E, 0xB580, 0xB581, 0xB582,
0xB583, 0xB584, 0xB585, 0xB586, 0xB587, 0xB588, 0xB589, 0xB58A,
0xB58B, 0xB58C, 0xB58D, 0xB58E, 0xB58F, 0xB590, 0xB591, 0xB592,
0xB593, 0xB594, 0xB595, 0xB596, 0xB597, 0xB598, 0xB599, 0xB59A,
0xB59B, 0xB59C, 0xB59D, 0xB59E, 0xB59F, 0xB5A0, 0xB640, 0xB641,
0xB642, 0xB643, 0xB644, 0xB645, 0xB646, 0xB647, 0xB648, 0xB649,
0xB64A, 0xB64B, 0xB64C, 0xB64D, 0xB64E, 0xB64F, 0xB650, 0xB651,
0xB652, 0xB653, 0xB654, 0xB655, 0xB656, 0xB657, 0xB658, 0xB659,
0xB65A, 0xB65B, 0xB65C, 0xB65D, 0xB65E, 0xB65F, 0xB660, 0xB661,
0xB662, 0xB663, 0xB664, 0xB665, 0xB666, 0xB667, 0xB668, 0xB669,
0xB66A, 0xB66B, 0xB66C, 0xB66D, 0xB66E, 0xB66F, 0xB670, 0xB671,
0xB672, 0xB673, 0xB674, 0xB675, 0xB676, 0xB677, 0xB678, 0xB679,
0xB67A, 0xB67B, 0xB67C, 0xB67D, 0xB67E, 0xB680, 0xB681, 0xB682,
0xB683, 0xB684, 0xB685, 0xB686, 0xB687, 0xB688, 0xB689, 0xB68A,
0xB68B, 0xB68C, 0xB68D, 0xB68E, 0xB68F, 0xB690, 0xB691, 0xB692,
0xB693, 0xB694, 0xB695, 0xB696, 0xB697, 0xB698, 0xB699, 0xB69A,
0xB69B, 0xB69C, 0xB69D, 0xB69E, 0xB69F, 0xB6A0, 0xB740, 0xB741,
0xB742, 0xB743, 0xB744, 0xB745, 0xB746, 0xB747, 0xB748, 0xB749,
0xB74A, 0xB74B, 0xB74C, 0xB74D, 0xB74E, 0xB74F, 0xB750, 0xB751,
0xB752, 0xB753, 0xB754, 0xB755, 0xB756, 0xB757, 0xB758, 0xB759,
0xB75A, 0xB75B, 0xB75C, 0xB75D, 0xB75E, 0xB75F, 0xB760, 0xB761,
0xB762, 0xB763, 0xB764, 0xB765, 0xB766, 0xB767, 0xB768, 0xB769,
0xB76A, 0xB76B, 0xB76C, 0xB76D, 0xB76E, 0xB76F, 0xB770, 0xB771,
0xB772, 0xB773, 0xB774, 0xB775, 0xB776, 0xB777, 0xB778, 0xB779,
0xB77A, 0xB77B, 0xB77C, 0xB77D, 0xB77E, 0xB780, 0xB781, 0xB782,
0xB783, 0xB784, 0xB785, 0xB786, 0xB787, 0xB788, 0xB789, 0xB78A,
0xB78B, 0xB78C, 0xB78D, 0xB78E, 0xB78F, 0xB790, 0xB791, 0xB792,
0xB793, 0xB794, 0xB795, 0xB796, 0xB797, 0xB798, 0xB799, 0xB79A,
0xB79B, 0xB79C, 0xB79D, 0xB79E, 0xB79F, 0xB7A0, 0xB840, 0xB841,
0xB842, 0xB843, 0xB844, 0xB845, 0xB846, 0xB847, 0xB848, 0xB849,
0xB84A, 0xB84B, 0xB84C, 0xB84D, 0xB84E, 0xB84F, 0xB850, 0xB851,
0xB852, 0xB853, 0xB854, 0xB855, 0xB856, 0xB857, 0xB858, 0xB859,
0xB85A, 0xB85B, 0xB85C, 0xB85D, 0xB85E, 0xB85F, 0xB860, 0xB861,
0xB862, 0xB863, 0xB864, 0xB865, 0xB866, 0xB867, 0xB868, 0xB869,
0xB86A, 0xB86B, 0xB86C, 0xB86D, 0xB86E, 0xB86F, 0xB870, 0xB871,
0xB872, 0xB873, 0xB874, 0xB875, 0xB876, 0xB877, 0xB878, 0xB879,
0xB87A, 0xB87B, 0xB87C, 0xB87D, 0xB87E, 0xB880, 0xB881, 0xB882,
0xB883, 0xB884, 0xB885, 0xB886, 0xB887, 0xB888, 0xB889, 0xB88A,
0xB88B, 0xB88C, 0xB88D, 0xB88E, 0xB88F, 0xB890, 0xB891, 0xB892,
0xB893, 0xB894, 0xB895, 0xB896, 0xB897, 0xB898, 0xB899, 0xB89A,
0xB89B, 0xB89C, 0xB89D, 0xB89E, 0xB89F, 0xB8A0, 0xB940, 0xB941,
0xB942, 0xB943, 0xB944, 0xB945, 0xB946, 0xB947, 0xB948, 0xB949,
0xB94A, 0xB94B, 0xB94C, 0xB94D, 0xB94E, 0xB94F, 0xB950, 0xB951,
0xB952, 0xB953, 0xB954, 0xB955, 0xB956, 0xB957, 0xB958, 0xB959,
0xB95A, 0xB95B, 0xB95C, 0xB95D, 0xB95E, 0xB95F, 0xB960, 0xB961,
0xB962, 0xB963, 0xB964, 0xB965, 0xB966, 0xB967, 0xB968, 0xB969,
0xB96A, 0xB96B, 0xB96C, 0xB96D, 0xB96E, 0xB96F, 0xB970, 0xB971,
0xB972, 0xB973, 0xB974, 0xB975, 0xB976, 0xB977, 0xB978, 0xB979,
0xB97A, 0xB97B, 0xB97C, 0xB97D, 0xB97E, 0xB980, 0xB981, 0xB982,
0xB983, 0xB984, 0xB985, 0xB986, 0xB987, 0xB988, 0xB989, 0xB98A,
0xB98B, 0xB98C, 0xB98D, 0xB98E, 0xB98F, 0xB990, 0xB991, 0xB992,
0xB993, 0xB994, 0xB995, 0xB996, 0xB997, 0xB998, 0xB999, 0xB99A,
0xB99B, 0xB99C, 0xB99D, 0xB99E, 0xB99F, 0xB9A0, 0xBA40, 0xBA41,
0xBA42, 0xBA43, 0xBA44, 0xBA45, 0xBA46, 0xBA47, 0xBA48, 0xBA49,
0xBA4A, 0xBA4B, 0xBA4C, 0xBA4D, 0xBA4E, 0xBA4F, 0xBA50, 0xBA51,
0xBA52, 0xBA53, 0xBA54, 0xBA55, 0xBA56, 0xBA57, 0xBA58, 0xBA59,
0xBA5A, 0xBA5B, 0xBA5C, 0xBA5D, 0xBA5E, 0xBA5F, 0xBA60, 0xBA61,
0xBA62, 0xBA63, 0xBA64, 0xBA65, 0xBA66, 0xBA67, 0xBA68, 0xBA69,
0xBA6A, 0xBA6B, 0xBA6C, 0xBA6D, 0xBA6E, 0xBA6F, 0xBA70, 0xBA71,
0xBA72, 0xBA73, 0xBA74, 0xBA75, 0xBA76, 0xBA77, 0xBA78, 0xBA79,
0xBA7A, 0xBA7B, 0xBA7C, 0xBA7D, 0xBA7E, 0xBA80, 0xBA81, 0xBA82,
0xBA83, 0xBA84, 0xBA85, 0xBA86, 0xBA87, 0xBA88, 0xBA89, 0xBA8A,
0xBA8B, 0xBA8C, 0xBA8D, 0xBA8E, 0xBA8F, 0xBA90, 0xBA91, 0xBA92,
0xBA93, 0xBA94, 0xBA95, 0xBA96, 0xBA97, 0xBA98, 0xBA99, 0xBA9A,
0xBA9B, 0xBA9C, 0xBA9D, 0xBA9E, 0xBA9F, 0xBAA0, 0xBB40, 0xBB41,
0xBB42, 0xBB43, 0xBB44, 0xBB45, 0xBB46, 0xBB47, 0xBB48, 0xBB49,
0xBB4A, 0xBB4B, 0xBB4C, 0xBB4D, 0xBB4E, 0xBB4F, 0xBB50, 0xBB51,
0xBB52, 0xBB53, 0xBB54, 0xBB55, 0xBB56, 0xBB57, 0xBB58, 0xBB59,
0xBB5A, 0xBB5B, 0xBB5C, 0xBB5D, 0xBB5E, 0xBB5F, 0xBB60, 0xBB61,
0xBB62, 0xBB63, 0xBB64, 0xBB65, 0xBB66, 0xBB67, 0xBB68, 0xBB69,
0xBB6A, 0xBB6B, 0xBB6C, 0xBB6D, 0xBB6E, 0xBB6F, 0xBB70, 0xBB71,
0xBB72, 0xBB73, 0xBB74, 0xBB75, 0xBB76, 0xBB77, 0xBB78, 0xBB79,
0xBB7A, 0xBB7B, 0xBB7C, 0xBB7D, 0xBB7E, 0xBB80, 0xBB81, 0xBB82,
0xBB83, 0xBB84, 0xBB85, 0xBB86, 0xBB87, 0xBB88, 0xBB89, 0xBB8A,
0xBB8B, 0xBB8C, 0xBB8D, 0xBB8E, 0xBB8F, 0xBB90, 0xBB91, 0xBB92,
0xBB93, 0xBB94, 0xBB95, 0xBB96, 0xBB97, 0xBB98, 0xBB99, 0xBB9A,
0xBB9B, 0xBB9C, 0xBB9D, 0xBB9E, 0xBB9F, 0xBBA0, 0xBC40, 0xBC41,
0xBC42, 0xBC43, 0xBC44, 0xBC45, 0xBC46, 0xBC47, 0xBC48, 0xBC49,
0xBC4A, 0xBC4B, 0xBC4C, 0xBC4D, 0xBC4E, 0xBC4F, 0xBC50, 0xBC51,
0xBC52, 0xBC53, 0xBC54, 0xBC55, 0xBC56, 0xBC57, 0xBC58, 0xBC59,
0xBC5A, 0xBC5B, 0xBC5C, 0xBC5D, 0xBC5E, 0xBC5F, 0xBC60, 0xBC61,
0xBC62, 0xBC63, 0xBC64, 0xBC65, 0xBC66, 0xBC67, 0xBC68, 0xBC69,
0xBC6A, 0xBC6B, 0xBC6C, 0xBC6D, 0xBC6E, 0xBC6F, 0xBC70, 0xBC71,
0xBC72, 0xBC73, 0xBC74, 0xBC75, 0xBC76, 0xBC77, 0xBC78, 0xBC79,
0xBC7A, 0xBC7B, 0xBC7C, 0xBC7D, 0xBC7E, 0xBC80, 0xBC81, 0xBC82,
0xBC83, 0xBC84, 0xBC85, 0xBC86, 0xBC87, 0xBC88, 0xBC89, 0xBC8A,
0xBC8B, 0xBC8C, 0xBC8D, 0xBC8E, 0xBC8F, 0xBC90, 0xBC91, 0xBC92,
0xBC93, 0xBC94, 0xBC95, 0xBC96, 0xBC97, 0xBC98, 0xBC99, 0xBC9A,
0xBC9B, 0xBC9C, 0xBC9D, 0xBC9E, 0xBC9F, 0xBCA0, 0xBD40, 0xBD41,
0xBD42, 0xBD43, 0xBD44, 0xBD45, 0xBD46, 0xBD47, 0xBD48, 0xBD49,
0xBD4A, 0xBD4B, 0xBD4C, 0xBD4D, 0xBD4E, 0xBD4F, 0xBD50, 0xBD51,
0xBD52, 0xBD53, 0xBD54, 0xBD55, 0xBD56, 0xBD57, 0xBD58, 0xBD59,
0xBD5A, 0xBD5B, 0xBD5C, 0xBD5D, 0xBD5E, 0xBD5F, 0xBD60, 0xBD61,
0xBD62, 0xBD63, 0xBD64, 0xBD65, 0xBD66, 0xBD67, 0xBD68, 0xBD69,
0xBD6A, 0xBD6B, 0xBD6C, 0xBD6D, 0xBD6E, 0xBD6F, 0xBD70, 0xBD71,
0xBD72, 0xBD73, 0xBD74, 0xBD75, 0xBD76, 0xBD77, 0xBD78, 0xBD79,
0xBD7A, 0xBD7B, 0xBD7C, 0xBD7D, 0xBD7E, 0xBD80, 0xBD81, 0xBD82,
0xBD83, 0xBD84, 0xBD85, 0xBD86, 0xBD87, 0xBD88, 0xBD89, 0xBD8A,
0xBD8B, 0xBD8C, 0xBD8D, 0xBD8E, 0xBD8F, 0xBD90, 0xBD91, 0xBD92,
0xBD93, 0xBD94, 0xBD95, 0xBD96, 0xBD97, 0xBD98, 0xBD99, 0xBD9A,
0xBD9B, 0xBD9C, 0xBD9D, 0xBD9E, 0xBD9F, 0xBDA0, 0xBE40, 0xBE41,
0xBE42, 0xBE43, 0xBE44, 0xBE45, 0xBE46, 0xBE47, 0xBE48, 0xBE49,
0xBE4A, 0xBE4B, 0xBE4C, 0xBE4D, 0xBE4E, 0xBE4F, 0xBE50, 0xBE51,
0xBE52, 0xBE53, 0xBE54, 0xBE55, 0xBE56, 0xBE57, 0xBE58, 0xBE59,
0xBE5A, 0xBE5B, 0xBE5C, 0xBE5D, 0xBE5E, 0xBE5F, 0xBE60, 0xBE61,
0xBE62, 0xBE63, 0xBE64, 0xBE65, 0xBE66, 0xBE67, 0xBE68, 0xBE69,
0xBE6A, 0xBE6B, 0xBE6C, 0xBE6D, 0xBE6E, 0xBE6F, 0xBE70, 0xBE71,
0xBE72, 0xBE73, 0xBE74, 0xBE75, 0xBE76, 0xBE77, 0xBE78, 0xBE79,
0xBE7A, 0xBE7B, 0xBE7C, 0xBE7D, 0xBE7E, 0xBE80, 0xBE81, 0xBE82,
0xBE83, 0xBE84, 0xBE85, 0xBE86, 0xBE87, 0xBE88, 0xBE89, 0xBE8A,
0xBE8B, 0xBE8C, 0xBE8D, 0xBE8E, 0xBE8F, 0xBE90, 0xBE91, 0xBE92,
0xBE93, 0xBE94, 0xBE95, 0xBE96, 0xBE97, 0xBE98, 0xBE99, 0xBE9A,
0xBE9B, 0xBE9C, 0xBE9D, 0xBE9E, 0xBE9F, 0xBEA0, 0xBF40, 0xBF41,
0xBF42, 0xBF43, 0xBF44, 0xBF45, 0xBF46, 0xBF47, 0xBF48, 0xBF49,
0xBF4A, 0xBF4B, 0xBF4C, 0xBF4D, 0xBF4E, 0xBF4F, 0xBF50, 0xBF51,
0xBF52, 0xBF53, 0xBF54, 0xBF55, 0xBF56, 0xBF57, 0xBF58, 0xBF59,
0xBF5A, 0xBF5B, 0xBF5C, 0xBF5D, 0xBF5E, 0xBF5F, 0xBF60, 0xBF61,
0xBF62, 0xBF63, 0xBF64, 0xBF65, 0xBF66, 0xBF67, 0xBF68, 0xBF69,
0xBF6A, 0xBF6B, 0xBF6C, 0xBF6D, 0xBF6E, 0xBF6F, 0xBF70, 0xBF71,
0xBF72, 0xBF73, 0xBF74, 0xBF75, 0xBF76, 0xBF77, 0xBF78, 0xBF79,
0xBF7A, 0xBF7B, 0xBF7C, 0xBF7D, 0xBF7E, 0xBF80, 0xBF81, 0xBF82,
0xBF83, 0xBF84, 0xBF85, 0xBF86, 0xBF87, 0xBF88, 0xBF89, 0xBF8A,
0xBF8B, 0xBF8C, 0xBF8D, 0xBF8E, 0xBF8F, 0xBF90, 0xBF91, 0xBF92,
0xBF93, 0xBF94, 0xBF95, 0xBF96, 0xBF97, 0xBF98, 0xBF99, 0xBF9A,
0xBF9B, 0xBF9C, 0xBF9D, 0xBF9E, 0xBF9F, 0xBFA0, 0xC040, 0xC041,
0xC042, 0xC043, 0xC044, 0xC045, 0xC046, 0xC047, 0xC048, 0xC049,
0xC04A, 0xC04B, 0xC04C, 0xC04D, 0xC04E, 0xC04F, 0xC050, 0xC051,
0xC052, 0xC053, 0xC054, 0xC055, 0xC056, 0xC057, 0xC058, 0xC059,
0xC05A, 0xC05B, 0xC05C, 0xC05D, 0xC05E, 0xC05F, 0xC060, 0xC061,
0xC062, 0xC063, 0xC064, 0xC065, 0xC066, 0xC067, 0xC068, 0xC069,
0xC06A, 0xC06B, 0xC06C, 0xC06D, 0xC06E, 0xC06F, 0xC070, 0xC071,
0xC072, 0xC073, 0xC074, 0xC075, 0xC076, 0xC077, 0xC078, 0xC079,
0xC07A, 0xC07B, 0xC07C, 0xC07D, 0xC07E, 0xC080, 0xC081, 0xC082,
0xC083, 0xC084, 0xC085, 0xC086, 0xC087, 0xC088, 0xC089, 0xC08A,
0xC08B, 0xC08C, 0xC08D, 0xC08E, 0xC08F, 0xC090, 0xC091, 0xC092,
0xC093, 0xC094, 0xC095, 0xC096, 0xC097, 0xC098, 0xC099, 0xC09A,
0xC09B, 0xC09C, 0xC09D, 0xC09E, 0xC09F, 0xC0A0, 0xC140, 0xC141,
0xC142, 0xC143, 0xC144, 0xC145, 0xC146, 0xC147, 0xC148, 0xC149,
0xC14A, 0xC14B, 0xC14C, 0xC14D, 0xC14E, 0xC14F, 0xC150, 0xC151,
0xC152, 0xC153, 0xC154, 0xC155, 0xC156, 0xC157, 0xC158, 0xC159,
0xC15A, 0xC15B, 0xC15C, 0xC15D, 0xC15E, 0xC15F, 0xC160, 0xC161,
0xC162, 0xC163, 0xC164, 0xC165, 0xC166, 0xC167, 0xC168, 0xC169,
0xC16A, 0xC16B, 0xC16C, 0xC16D, 0xC16E, 0xC16F, 0xC170, 0xC171,
0xC172, 0xC173, 0xC174, 0xC175, 0xC176, 0xC177, 0xC178, 0xC179,
0xC17A, 0xC17B, 0xC17C, 0xC17D, 0xC17E, 0xC180, 0xC181, 0xC182,
0xC183, 0xC184, 0xC185, 0xC186, 0xC187, 0xC188, 0xC189, 0xC18A,
0xC18B, 0xC18C, 0xC18D, 0xC18E, 0xC18F, 0xC190, 0xC191, 0xC192,
0xC193, 0xC194, 0xC195, 0xC196, 0xC197, 0xC198, 0xC199, 0xC19A,
0xC19B, 0xC19C, 0xC19D, 0xC19E, 0xC19F, 0xC1A0, 0xC240, 0xC241,
0xC242, 0xC243, 0xC244, 0xC245, 0xC246, 0xC247, 0xC248, 0xC249,
0xC24A, 0xC24B, 0xC24C, 0xC24D, 0xC24E, 0xC24F, 0xC250, 0xC251,
0xC252, 0xC253, 0xC254, 0xC255, 0xC256, 0xC257, 0xC258, 0xC259,
0xC25A, 0xC25B, 0xC25C, 0xC25D, 0xC25E, 0xC25F, 0xC260, 0xC261,
0xC262, 0xC263, 0xC264, 0xC265, 0xC266, 0xC267, 0xC268, 0xC269,
0xC26A, 0xC26B, 0xC26C, 0xC26D, 0xC26E, 0xC26F, 0xC270, 0xC271,
0xC272, 0xC273, 0xC274, 0xC275, 0xC276, 0xC277, 0xC278, 0xC279,
0xC27A, 0xC27B, 0xC27C, 0xC27D, 0xC27E, 0xC280, 0xC281, 0xC282,
0xC283, 0xC284, 0xC285, 0xC286, 0xC287, 0xC288, 0xC289, 0xC28A,
0xC28B, 0xC28C, 0xC28D, 0xC28E, 0xC28F, 0xC290, 0xC291, 0xC292,
0xC293, 0xC294, 0xC295, 0xC296, 0xC297, 0xC298, 0xC299, 0xC29A,
0xC29B, 0xC29C, 0xC29D, 0xC29E, 0xC29F, 0xC2A0, 0xC340, 0xC341,
0xC342, 0xC343, 0xC344, 0xC345, 0xC346, 0xC347, 0xC348, 0xC349,
0xC34A, 0xC34B, 0xC34C, 0xC34D, 0xC34E, 0xC34F, 0xC350, 0xC351,
0xC352, 0xC353, 0xC354, 0xC355, 0xC356, 0xC357, 0xC358, 0xC359,
0xC35A, 0xC35B, 0xC35C, 0xC35D, 0xC35E, 0xC35F, 0xC360, 0xC361,
0xC362, 0xC363, 0xC364, 0xC365, 0xC366, 0xC367, 0xC368, 0xC369,
0xC36A, 0xC36B, 0xC36C, 0xC36D, 0xC36E, 0xC36F, 0xC370, 0xC371,
0xC372, 0xC373, 0xC374, 0xC375, 0xC376, 0xC377, 0xC378, 0xC379,
0xC37A, 0xC37B, 0xC37C, 0xC37D, 0xC37E, 0xC380, 0xC381, 0xC382,
0xC383, 0xC384, 0xC385, 0xC386, 0xC387, 0xC388, 0xC389, 0xC38A,
0xC38B, 0xC38C, 0xC38D, 0xC38E, 0xC38F, 0xC390, 0xC391, 0xC392,
0xC393, 0xC394, 0xC395, 0xC396, 0xC397, 0xC398, 0xC399, 0xC39A,
0xC39B, 0xC39C, 0xC39D, 0xC39E, 0xC39F, 0xC3A0, 0xC440, 0xC441,
0xC442, 0xC443, 0xC444, 0xC445, 0xC446, 0xC447, 0xC448, 0xC449,
0xC44A, 0xC44B, 0xC44C, 0xC44D, 0xC44E, 0xC44F, 0xC450, 0xC451,
0xC452, 0xC453, 0xC454, 0xC455, 0xC456, 0xC457, 0xC458, 0xC459,
0xC45A, 0xC45B, 0xC45C, 0xC45D, 0xC45E, 0xC45F, 0xC460, 0xC461,
0xC462, 0xC463, 0xC464, 0xC465, 0xC466, 0xC467, 0xC468, 0xC469,
0xC46A, 0xC46B, 0xC46C, 0xC46D, 0xC46E, 0xC46F, 0xC470, 0xC471,
0xC472, 0xC473, 0xC474, 0xC475, 0xC476, 0xC477, 0xC478, 0xC479,
0xC47A, 0xC47B, 0xC47C, 0xC47D, 0xC47E, 0xC480, 0xC481, 0xC482,
0xC483, 0xC484, 0xC485, 0xC486, 0xC487, 0xC488, 0xC489, 0xC48A,
0xC48B, 0xC48C, 0xC48D, 0xC48E, 0xC48F, 0xC490, 0xC491, 0xC492,
0xC493, 0xC494, 0xC495, 0xC496, 0xC497, 0xC498, 0xC499, 0xC49A,
0xC49B, 0xC49C, 0xC49D, 0xC49E, 0xC49F, 0xC4A0, 0xC540, 0xC541,
0xC542, 0xC543, 0xC544, 0xC545, 0xC546, 0xC547, 0xC548, 0xC549,
0xC54A, 0xC54B, 0xC54C, 0xC54D, 0xC54E, 0xC54F, 0xC550, 0xC551,
0xC552, 0xC553, 0xC554, 0xC555, 0xC556, 0xC557, 0xC558, 0xC559,
0xC55A, 0xC55B, 0xC55C, 0xC55D, 0xC55E, 0xC55F, 0xC560, 0xC561,
0xC562, 0xC563, 0xC564, 0xC565, 0xC566, 0xC567, 0xC568, 0xC569,
0xC56A, 0xC56B, 0xC56C, 0xC56D, 0xC56E, 0xC56F, 0xC570, 0xC571,
0xC572, 0xC573, 0xC574, 0xC575, 0xC576, 0xC577, 0xC578, 0xC579,
0xC57A, 0xC57B, 0xC57C, 0xC57D, 0xC57E, 0xC580, 0xC581, 0xC582,
0xC583, 0xC584, 0xC585, 0xC586, 0xC587, 0xC588, 0xC589, 0xC58A,
0xC58B, 0xC58C, 0xC58D, 0xC58E, 0xC58F, 0xC590, 0xC591, 0xC592,
0xC593, 0xC594, 0xC595, 0xC596, 0xC597, 0xC598, 0xC599, 0xC59A,
0xC59B, 0xC59C, 0xC59D, 0xC59E, 0xC59F, 0xC5A0, 0xC640, 0xC641,
0xC642, 0xC643, 0xC644, 0xC645, 0xC646, 0xC647, 0xC648, 0xC649,
0xC64A, 0xC64B, 0xC64C, 0xC64D, 0xC64E, 0xC64F, 0xC650, 0xC651,
0xC652, 0xC653, 0xC654, 0xC655, 0xC656, 0xC657, 0xC658, 0xC659,
0xC65A, 0xC65B, 0xC65C, 0xC65D, 0xC65E, 0xC65F, 0xC660, 0xC661,
0xC662, 0xC663, 0xC664, 0xC665, 0xC666, 0xC667, 0xC668, 0xC669,
0xC66A, 0xC66B, 0xC66C, 0xC66D, 0xC66E, 0xC66F, 0xC670, 0xC671,
0xC672, 0xC673, 0xC674, 0xC675, 0xC676, 0xC677, 0xC678, 0xC679,
0xC67A, 0xC67B, 0xC67C, 0xC67D, 0xC67E, 0xC680, 0xC681, 0xC682,
0xC683, 0xC684, 0xC685, 0xC686, 0xC687, 0xC688, 0xC689, 0xC68A,
0xC68B, 0xC68C, 0xC68D, 0xC68E, 0xC68F, 0xC690, 0xC691, 0xC692,
0xC693, 0xC694, 0xC695, 0xC696, 0xC697, 0xC698, 0xC699, 0xC69A,
0xC69B, 0xC69C, 0xC69D, 0xC69E, 0xC69F, 0xC6A0, 0xC740, 0xC741,
0xC742, 0xC743, 0xC744, 0xC745, 0xC746, 0xC747, 0xC748, 0xC749,
0xC74A, 0xC74B, 0xC74C, 0xC74D, 0xC74E, 0xC74F, 0xC750, 0xC751,
0xC752, 0xC753, 0xC754, 0xC755, 0xC756, 0xC757, 0xC758, 0xC759,
0xC75A, 0xC75B, 0xC75C, 0xC75D, 0xC75E, 0xC75F, 0xC760, 0xC761,
0xC762, 0xC763, 0xC764, 0xC765, 0xC766, 0xC767, 0xC768, 0xC769,
0xC76A, 0xC76B, 0xC76C, 0xC76D, 0xC76E, 0xC76F, 0xC770, 0xC771,
0xC772, 0xC773, 0xC774, 0xC775, 0xC776, 0xC777, 0xC778, 0xC779,
0xC77A, 0xC77B, 0xC77C, 0xC77D, 0xC77E, 0xC780, 0xC781, 0xC782,
0xC783, 0xC784, 0xC785, 0xC786, 0xC787, 0xC788, 0xC789, 0xC78A,
0xC78B, 0xC78C, 0xC78D, 0xC78E, 0xC78F, 0xC790, 0xC791, 0xC792,
0xC793, 0xC794, 0xC795, 0xC796, 0xC797, 0xC798, 0xC799, 0xC79A,
0xC79B, 0xC79C, 0xC79D, 0xC79E, 0xC79F, 0xC7A0, 0xC840, 0xC841,
0xC842, 0xC843, 0xC844, 0xC845, 0xC846, 0xC847, 0xC848, 0xC849,
0xC84A, 0xC84B, 0xC84C, 0xC84D, 0xC84E, 0xC84F, 0xC850, 0xC851,
0xC852, 0xC853, 0xC854, 0xC855, 0xC856, 0xC857, 0xC858, 0xC859,
0xC85A, 0xC85B, 0xC85C, 0xC85D, 0xC85E, 0xC85F, 0xC860, 0xC861,
0xC862, 0xC863, 0xC864, 0xC865, 0xC866, 0xC867, 0xC868, 0xC869,
0xC86A, 0xC86B, 0xC86C, 0xC86D, 0xC86E, 0xC86F, 0xC870, 0xC871,
0xC872, 0xC873, 0xC874, 0xC875, 0xC876, 0xC877, 0xC878, 0xC879,
0xC87A, 0xC87B, 0xC87C, 0xC87D, 0xC87E, 0xC880, 0xC881, 0xC882,
0xC883, 0xC884, 0xC885, 0xC886, 0xC887, 0xC888, 0xC889, 0xC88A,
0xC88B, 0xC88C, 0xC88D, 0xC88E, 0xC88F, 0xC890, 0xC891, 0xC892,
0xC893, 0xC894, 0xC895, 0xC896, 0xC897, 0xC898, 0xC899, 0xC89A,
0xC89B, 0xC89C, 0xC89D, 0xC89E, 0xC89F, 0xC8A0, 0xC940, 0xC941,
0xC942, 0xC943, 0xC944, 0xC945, 0xC946, 0xC947, 0xC948, 0xC949,
0xC94A, 0xC94B, 0xC94C, 0xC94D, 0xC94E, 0xC94F, 0xC950, 0xC951,
0xC952, 0xC953, 0xC954, 0xC955, 0xC956, 0xC957, 0xC958, 0xC959,
0xC95A, 0xC95B, 0xC95C, 0xC95D, 0xC95E, 0xC95F, 0xC960, 0xC961,
0xC962, 0xC963, 0xC964, 0xC965, 0xC966, 0xC967, 0xC968, 0xC969,
0xC96A, 0xC96B, 0xC96C, 0xC96D, 0xC96E, 0xC96F, 0xC970, 0xC971,
0xC972, 0xC973, 0xC974, 0xC975, 0xC976, 0xC977, 0xC978, 0xC979,
0xC97A, 0xC97B, 0xC97C, 0xC97D, 0xC97E, 0xC980, 0xC981, 0xC982,
0xC983, 0xC984, 0xC985, 0xC986, 0xC987, 0xC988, 0xC989, 0xC98A,
0xC98B, 0xC98C, 0xC98D, 0xC98E, 0xC98F, 0xC990, 0xC991, 0xC992,
0xC993, 0xC994, 0xC995, 0xC996, 0xC997, 0xC998, 0xC999, 0xC99A,
0xC99B, 0xC99C, 0xC99D, 0xC99E, 0xC99F, 0xC9A0, 0xCA40, 0xCA41,
0xCA42, 0xCA43, 0xCA44, 0xCA45, 0xCA46, 0xCA47, 0xCA48, 0xCA49,
0xCA4A, 0xCA4B, 0xCA4C, 0xCA4D, 0xCA4E, 0xCA4F, 0xCA50, 0xCA51,
0xCA52, 0xCA53, 0xCA54, 0xCA55, 0xCA56, 0xCA57, 0xCA58, 0xCA59,
0xCA5A, 0xCA5B, 0xCA5C, 0xCA5D, 0xCA5E, 0xCA5F, 0xCA60, 0xCA61,
0xCA62, 0xCA63, 0xCA64, 0xCA65, 0xCA66, 0xCA67, 0xCA68, 0xCA69,
0xCA6A, 0xCA6B, 0xCA6C, 0xCA6D, 0xCA6E, 0xCA6F, 0xCA70, 0xCA71,
0xCA72, 0xCA73, 0xCA74, 0xCA75, 0xCA76, 0xCA77, 0xCA78, 0xCA79,
0xCA7A, 0xCA7B, 0xCA7C, 0xCA7D, 0xCA7E, 0xCA80, 0xCA81, 0xCA82,
0xCA83, 0xCA84, 0xCA85, 0xCA86, 0xCA87, 0xCA88, 0xCA89, 0xCA8A,
0xCA8B, 0xCA8C, 0xCA8D, 0xCA8E, 0xCA8F, 0xCA90, 0xCA91, 0xCA92,
0xCA93, 0xCA94, 0xCA95, 0xCA96, 0xCA97, 0xCA98, 0xCA99, 0xCA9A,
0xCA9B, 0xCA9C, 0xCA9D, 0xCA9E, 0xCA9F, 0xCAA0, 0xCB40, 0xCB41,
0xCB42, 0xCB43, 0xCB44, 0xCB45, 0xCB46, 0xCB47, 0xCB48, 0xCB49,
0xCB4A, 0xCB4B, 0xCB4C, 0xCB4D, 0xCB4E, 0xCB4F, 0xCB50, 0xCB51,
0xCB52, 0xCB53, 0xCB54, 0xCB55, 0xCB56, 0xCB57, 0xCB58, 0xCB59,
0xCB5A, 0xCB5B, 0xCB5C, 0xCB5D, 0xCB5E, 0xCB5F, 0xCB60, 0xCB61,
0xCB62, 0xCB63, 0xCB64, 0xCB65, 0xCB66, 0xCB67, 0xCB68, 0xCB69,
0xCB6A, 0xCB6B, 0xCB6C, 0xCB6D, 0xCB6E, 0xCB6F, 0xCB70, 0xCB71,
0xCB72, 0xCB73, 0xCB74, 0xCB75, 0xCB76, 0xCB77, 0xCB78, 0xCB79,
0xCB7A, 0xCB7B, 0xCB7C, 0xCB7D, 0xCB7E, 0xCB80, 0xCB81, 0xCB82,
0xCB83, 0xCB84, 0xCB85, 0xCB86, 0xCB87, 0xCB88, 0xCB89, 0xCB8A,
0xCB8B, 0xCB8C, 0xCB8D, 0xCB8E, 0xCB8F, 0xCB90, 0xCB91, 0xCB92,
0xCB93, 0xCB94, 0xCB95, 0xCB96, 0xCB97, 0xCB98, 0xCB99, 0xCB9A,
0xCB9B, 0xCB9C, 0xCB9D, 0xCB9E, 0xCB9F, 0xCBA0, 0xCC40, 0xCC41,
0xCC42, 0xCC43, 0xCC44, 0xCC45, 0xCC46, 0xCC47, 0xCC48, 0xCC49,
0xCC4A, 0xCC4B, 0xCC4C, 0xCC4D, 0xCC4E, 0xCC4F, 0xCC50, 0xCC51,
0xCC52, 0xCC53, 0xCC54, 0xCC55, 0xCC56, 0xCC57, 0xCC58, 0xCC59,
0xCC5A, 0xCC5B, 0xCC5C, 0xCC5D, 0xCC5E, 0xCC5F, 0xCC60, 0xCC61,
0xCC62, 0xCC63, 0xCC64, 0xCC65, 0xCC66, 0xCC67, 0xCC68, 0xCC69,
0xCC6A, 0xCC6B, 0xCC6C, 0xCC6D, 0xCC6E, 0xCC6F, 0xCC70, 0xCC71,
0xCC72, 0xCC73, 0xCC74, 0xCC75, 0xCC76, 0xCC77, 0xCC78, 0xCC79,
0xCC7A, 0xCC7B, 0xCC7C, 0xCC7D, 0xCC7E, 0xCC80, 0xCC81, 0xCC82,
0xCC83, 0xCC84, 0xCC85, 0xCC86, 0xCC87, 0xCC88, 0xCC89, 0xCC8A,
0xCC8B, 0xCC8C, 0xCC8D, 0xCC8E, 0xCC8F, 0xCC90, 0xCC91, 0xCC92,
0xCC93, 0xCC94, 0xCC95, 0xCC96, 0xCC97, 0xCC98, 0xCC99, 0xCC9A,
0xCC9B, 0xCC9C, 0xCC9D, 0xCC9E, 0xCC9F, 0xCCA0, 0xCD40, 0xCD41,
0xCD42, 0xCD43, 0xCD44, 0xCD45, 0xCD46, 0xCD47, 0xCD48, 0xCD49,
0xCD4A, 0xCD4B, 0xCD4C, 0xCD4D, 0xCD4E, 0xCD4F, 0xCD50, 0xCD51,
0xCD52, 0xCD53, 0xCD54, 0xCD55, 0xCD56, 0xCD57, 0xCD58, 0xCD59,
0xCD5A, 0xCD5B, 0xCD5C, 0xCD5D, 0xCD5E, 0xCD5F, 0xCD60, 0xCD61,
0xCD62, 0xCD63, 0xCD64, 0xCD65, 0xCD66, 0xCD67, 0xCD68, 0xCD69,
0xCD6A, 0xCD6B, 0xCD6C, 0xCD6D, 0xCD6E, 0xCD6F, 0xCD70, 0xCD71,
0xCD72, 0xCD73, 0xCD74, 0xCD75, 0xCD76, 0xCD77, 0xCD78, 0xCD79,
0xCD7A, 0xCD7B, 0xCD7C, 0xCD7D, 0xCD7E, 0xCD80, 0xCD81, 0xCD82,
0xCD83, 0xCD84, 0xCD85, 0xCD86, 0xCD87, 0xCD88, 0xCD89, 0xCD8A,
0xCD8B, 0xCD8C, 0xCD8D, 0xCD8E, 0xCD8F, 0xCD90, 0xCD91, 0xCD92,
0xCD93, 0xCD94, 0xCD95, 0xCD96, 0xCD97, 0xCD98, 0xCD99, 0xCD9A,
0xCD9B, 0xCD9C, 0xCD9D, 0xCD9E, 0xCD9F, 0xCDA0, 0xCE40, 0xCE41,
0xCE42, 0xCE43, 0xCE44, 0xCE45, 0xCE46, 0xCE47, 0xCE48, 0xCE49,
0xCE4A, 0xCE4B, 0xCE4C, 0xCE4D, 0xCE4E, 0xCE4F, 0xCE50, 0xCE51,
0xCE52, 0xCE53, 0xCE54, 0xCE55, 0xCE56, 0xCE57, 0xCE58, 0xCE59,
0xCE5A, 0xCE5B, 0xCE5C, 0xCE5D, 0xCE5E, 0xCE5F, 0xCE60, 0xCE61,
0xCE62, 0xCE63, 0xCE64, 0xCE65, 0xCE66, 0xCE67, 0xCE68, 0xCE69,
0xCE6A, 0xCE6B, 0xCE6C, 0xCE6D, 0xCE6E, 0xCE6F, 0xCE70, 0xCE71,
0xCE72, 0xCE73, 0xCE74, 0xCE75, 0xCE76, 0xCE77, 0xCE78, 0xCE79,
0xCE7A, 0xCE7B, 0xCE7C, 0xCE7D, 0xCE7E, 0xCE80, 0xCE81, 0xCE82,
0xCE83, 0xCE84, 0xCE85, 0xCE86, 0xCE87, 0xCE88, 0xCE89, 0xCE8A,
0xCE8B, 0xCE8C, 0xCE8D, 0xCE8E, 0xCE8F, 0xCE90, 0xCE91, 0xCE92,
0xCE93, 0xCE94, 0xCE95, 0xCE96, 0xCE97, 0xCE98, 0xCE99, 0xCE9A,
0xCE9B, 0xCE9C, 0xCE9D, 0xCE9E, 0xCE9F, 0xCEA0, 0xCF40, 0xCF41,
0xCF42, 0xCF43, 0xCF44, 0xCF45, 0xCF46, 0xCF47, 0xCF48, 0xCF49,
0xCF4A, 0xCF4B, 0xCF4C, 0xCF4D, 0xCF4E, 0xCF4F, 0xCF50, 0xCF51,
0xCF52, 0xCF53, 0xCF54, 0xCF55, 0xCF56, 0xCF57, 0xCF58, 0xCF59,
0xCF5A, 0xCF5B, 0xCF5C, 0xCF5D, 0xCF5E, 0xCF5F, 0xCF60, 0xCF61,
0xCF62, 0xCF63, 0xCF64, 0xCF65, 0xCF66, 0xCF67, 0xCF68, 0xCF69,
0xCF6A, 0xCF6B, 0xCF6C, 0xCF6D, 0xCF6E, 0xCF6F, 0xCF70, 0xCF71,
0xCF72, 0xCF73, 0xCF74, 0xCF75, 0xCF76, 0xCF77, 0xCF78, 0xCF79,
0xCF7A, 0xCF7B, 0xCF7C, 0xCF7D, 0xCF7E, 0xCF80, 0xCF81, 0xCF82,
0xCF83, 0xCF84, 0xCF85, 0xCF86, 0xCF87, 0xCF88, 0xCF89, 0xCF8A,
0xCF8B, 0xCF8C, 0xCF8D, 0xCF8E, 0xCF8F, 0xCF90, 0xCF91, 0xCF92,
0xCF93, 0xCF94, 0xCF95, 0xCF96, 0xCF97, 0xCF98, 0xCF99, 0xCF9A,
0xCF9B, 0xCF9C, 0xCF9D, 0xCF9E, 0xCF9F, 0xCFA0, 0xD040, 0xD041,
0xD042, 0xD043, 0xD044, 0xD045, 0xD046, 0xD047, 0xD048, 0xD049,
0xD04A, 0xD04B, 0xD04C, 0xD04D, 0xD04E, 0xD04F, 0xD050, 0xD051,
0xD052, 0xD053, 0xD054, 0xD055, 0xD056, 0xD057, 0xD058, 0xD059,
0xD05A, 0xD05B, 0xD05C, 0xD05D, 0xD05E, 0xD05F, 0xD060, 0xD061,
0xD062, 0xD063, 0xD064, 0xD065, 0xD066, 0xD067, 0xD068, 0xD069,
0xD06A, 0xD06B, 0xD06C, 0xD06D, 0xD06E, 0xD06F, 0xD070, 0xD071,
0xD072, 0xD073, 0xD074, 0xD075, 0xD076, 0xD077, 0xD078, 0xD079,
0xD07A, 0xD07B, 0xD07C, 0xD07D, 0xD07E, 0xD080, 0xD081, 0xD082,
0xD083, 0xD084, 0xD085, 0xD086, 0xD087, 0xD088, 0xD089, 0xD08A,
0xD08B, 0xD08C, 0xD08D, 0xD08E, 0xD08F, 0xD090, 0xD091, 0xD092,
0xD093, 0xD094, 0xD095, 0xD096, 0xD097, 0xD098, 0xD099, 0xD09A,
0xD09B, 0xD09C, 0xD09D, 0xD09E, 0xD09F, 0xD0A0, 0xD140, 0xD141,
0xD142, 0xD143, 0xD144, 0xD145, 0xD146, 0xD147, 0xD148, 0xD149,
0xD14A, 0xD14B, 0xD14C, 0xD14D, 0xD14E, 0xD14F, 0xD150, 0xD151,
0xD152, 0xD153, 0xD154, 0xD155, 0xD156, 0xD157, 0xD158, 0xD159,
0xD15A, 0xD15B, 0xD15C, 0xD15D, 0xD15E, 0xD15F, 0xD160, 0xD161,
0xD162, 0xD163, 0xD164, 0xD165, 0xD166, 0xD167, 0xD168, 0xD169,
0xD16A, 0xD16B, 0xD16C, 0xD16D, 0xD16E, 0xD16F, 0xD170, 0xD171,
0xD172, 0xD173, 0xD174, 0xD175, 0xD176, 0xD177, 0xD178, 0xD179,
0xD17A, 0xD17B, 0xD17C, 0xD17D, 0xD17E, 0xD180, 0xD181, 0xD182,
0xD183, 0xD184, 0xD185, 0xD186, 0xD187, 0xD188, 0xD189, 0xD18A,
0xD18B, 0xD18C, 0xD18D, 0xD18E, 0xD18F, 0xD190, 0xD191, 0xD192,
0xD193, 0xD194, 0xD195, 0xD196, 0xD197, 0xD198, 0xD199, 0xD19A,
0xD19B, 0xD19C, 0xD19D, 0xD19E, 0xD19F, 0xD1A0, 0xD240, 0xD241,
0xD242, 0xD243, 0xD244, 0xD245, 0xD246, 0xD247, 0xD248, 0xD249,
0xD24A, 0xD24B, 0xD24C, 0xD24D, 0xD24E, 0xD24F, 0xD250, 0xD251,
0xD252, 0xD253, 0xD254, 0xD255, 0xD256, 0xD257, 0xD258, 0xD259,
0xD25A, 0xD25B, 0xD25C, 0xD25D, 0xD25E, 0xD25F, 0xD260, 0xD261,
0xD262, 0xD263, 0xD264, 0xD265, 0xD266, 0xD267, 0xD268, 0xD269,
0xD26A, 0xD26B, 0xD26C, 0xD26D, 0xD26E, 0xD26F, 0xD270, 0xD271,
0xD272, 0xD273, 0xD274, 0xD275, 0xD276, 0xD277, 0xD278, 0xD279,
0xD27A, 0xD27B, 0xD27C, 0xD27D, 0xD27E, 0xD280, 0xD281, 0xD282,
0xD283, 0xD284, 0xD285, 0xD286, 0xD287, 0xD288, 0xD289, 0xD28A,
0xD28B, 0xD28C, 0xD28D, 0xD28E, 0xD28F, 0xD290, 0xD291, 0xD292,
0xD293, 0xD294, 0xD295, 0xD296, 0xD297, 0xD298, 0xD299, 0xD29A,
0xD29B, 0xD29C, 0xD29D, 0xD29E, 0xD29F, 0xD2A0, 0xD340, 0xD341,
0xD342, 0xD343, 0xD344, 0xD345, 0xD346, 0xD347, 0xD348, 0xD349,
0xD34A, 0xD34B, 0xD34C, 0xD34D, 0xD34E, 0xD34F, 0xD350, 0xD351,
0xD352, 0xD353, 0xD354, 0xD355, 0xD356, 0xD357, 0xD358, 0xD359,
0xD35A, 0xD35B, 0xD35C, 0xD35D, 0xD35E, 0xD35F, 0xD360, 0xD361,
0xD362, 0xD363, 0xD364, 0xD365, 0xD366, 0xD367, 0xD368, 0xD369,
0xD36A, 0xD36B, 0xD36C, 0xD36D, 0xD36E, 0xD36F, 0xD370, 0xD371,
0xD372, 0xD373, 0xD374, 0xD375, 0xD376, 0xD377, 0xD378, 0xD379,
0xD37A, 0xD37B, 0xD37C, 0xD37D, 0xD37E, 0xD380, 0xD381, 0xD382,
0xD383, 0xD384, 0xD385, 0xD386, 0xD387, 0xD388, 0xD389, 0xD38A,
0xD38B, 0xD38C, 0xD38D, 0xD38E, 0xD38F, 0xD390, 0xD391, 0xD392,
0xD393, 0xD394, 0xD395, 0xD396, 0xD397, 0xD398, 0xD399, 0xD39A,
0xD39B, 0xD39C, 0xD39D, 0xD39E, 0xD39F, 0xD3A0, 0xD440, 0xD441,
0xD442, 0xD443, 0xD444, 0xD445, 0xD446, 0xD447, 0xD448, 0xD449,
0xD44A, 0xD44B, 0xD44C, 0xD44D, 0xD44E, 0xD44F, 0xD450, 0xD451,
0xD452, 0xD453, 0xD454, 0xD455, 0xD456, 0xD457, 0xD458, 0xD459,
0xD45A, 0xD45B, 0xD45C, 0xD45D, 0xD45E, 0xD45F, 0xD460, 0xD461,
0xD462, 0xD463, 0xD464, 0xD465, 0xD466, 0xD467, 0xD468, 0xD469,
0xD46A, 0xD46B, 0xD46C, 0xD46D, 0xD46E, 0xD46F, 0xD470, 0xD471,
0xD472, 0xD473, 0xD474, 0xD475, 0xD476, 0xD477, 0xD478, 0xD479,
0xD47A, 0xD47B, 0xD47C, 0xD47D, 0xD47E, 0xD480, 0xD481, 0xD482,
0xD483, 0xD484, 0xD485, 0xD486, 0xD487, 0xD488, 0xD489, 0xD48A,
0xD48B, 0xD48C, 0xD48D, 0xD48E, 0xD48F, 0xD490, 0xD491, 0xD492,
0xD493, 0xD494, 0xD495, 0xD496, 0xD497, 0xD498, 0xD499, 0xD49A,
0xD49B, 0xD49C, 0xD49D, 0xD49E, 0xD49F, 0xD4A0, 0xD540, 0xD541,
0xD542, 0xD543, 0xD544, 0xD545, 0xD546, 0xD547, 0xD548, 0xD549,
0xD54A, 0xD54B, 0xD54C, 0xD54D, 0xD54E, 0xD54F, 0xD550, 0xD551,
0xD552, 0xD553, 0xD554, 0xD555, 0xD556, 0xD557, 0xD558, 0xD559,
0xD55A, 0xD55B, 0xD55C, 0xD55D, 0xD55E, 0xD55F, 0xD560, 0xD561,
0xD562, 0xD563, 0xD564, 0xD565, 0xD566, 0xD567, 0xD568, 0xD569,
0xD56A, 0xD56B, 0xD56C, 0xD56D, 0xD56E, 0xD56F, 0xD570, 0xD571,
0xD572, 0xD573, 0xD574, 0xD575, 0xD576, 0xD577, 0xD578, 0xD579,
0xD57A, 0xD57B, 0xD57C, 0xD57D, 0xD57E, 0xD580, 0xD581, 0xD582,
0xD583, 0xD584, 0xD585, 0xD586, 0xD587, 0xD588, 0xD589, 0xD58A,
0xD58B, 0xD58C, 0xD58D, 0xD58E, 0xD58F, 0xD590, 0xD591, 0xD592,
0xD593, 0xD594, 0xD595, 0xD596, 0xD597, 0xD598, 0xD599, 0xD59A,
0xD59B, 0xD59C, 0xD59D, 0xD59E, 0xD59F, 0xD5A0, 0xD640, 0xD641,
0xD642, 0xD643, 0xD644, 0xD645, 0xD646, 0xD647, 0xD648, 0xD649,
0xD64A, 0xD64B, 0xD64C, 0xD64D, 0xD64E, 0xD64F, 0xD650, 0xD651,
0xD652, 0xD653, 0xD654, 0xD655, 0xD656, 0xD657, 0xD658, 0xD659,
0xD65A, 0xD65B, 0xD65C, 0xD65D, 0xD65E, 0xD65F, 0xD660, 0xD661,
0xD662, 0xD663, 0xD664, 0xD665, 0xD666, 0xD667, 0xD668, 0xD669,
0xD66A, 0xD66B, 0xD66C, 0xD66D, 0xD66E, 0xD66F, 0xD670, 0xD671,
0xD672, 0xD673, 0xD674, 0xD675, 0xD676, 0xD677, 0xD678, 0xD679,
0xD67A, 0xD67B, 0xD67C, 0xD67D, 0xD67E, 0xD680, 0xD681, 0xD682,
0xD683, 0xD684, 0xD685, 0xD686, 0xD687, 0xD688, 0xD689, 0xD68A,
0xD68B, 0xD68C, 0xD68D, 0xD68E, 0xD68F, 0xD690, 0xD691, 0xD692,
0xD693, 0xD694, 0xD695, 0xD696, 0xD697, 0xD698, 0xD699, 0xD69A,
0xD69B, 0xD69C, 0xD69D, 0xD69E, 0xD69F, 0xD6A0, 0xD740, 0xD741,
0xD742, 0xD743, 0xD744, 0xD745, 0xD746, 0xD747, 0xD748, 0xD749,
0xD74A, 0xD74B, 0xD74C, 0xD74D, 0xD74E, 0xD74F, 0xD750, 0xD751,
0xD752, 0xD753, 0xD754, 0xD755, 0xD756, 0xD757, 0xD758, 0xD759,
0xD75A, 0xD75B, 0xD75C, 0xD75D, 0xD75E, 0xD75F, 0xD760, 0xD761,
0xD762, 0xD763, 0xD764, 0xD765, 0xD766, 0xD767, 0xD768, 0xD769,
0xD76A, 0xD76B, 0xD76C, 0xD76D, 0xD76E, 0xD76F, 0xD770, 0xD771,
0xD772, 0xD773, 0xD774, 0xD775, 0xD776, 0xD777, 0xD778, 0xD779,
0xD77A, 0xD77B, 0xD77C, 0xD77D, 0xD77E, 0xD780, 0xD781, 0xD782,
0xD783, 0xD784, 0xD785, 0xD786, 0xD787, 0xD788, 0xD789, 0xD78A,
0xD78B, 0xD78C, 0xD78D, 0xD78E, 0xD78F, 0xD790, 0xD791, 0xD792,
0xD793, 0xD794, 0xD795, 0xD796, 0xD797, 0xD798, 0xD799, 0xD79A,
0xD79B, 0xD79C, 0xD79D, 0xD79E, 0xD79F, 0xD7A0, 0xD840, 0xD841,
0xD842, 0xD843, 0xD844, 0xD845, 0xD846, 0xD847, 0xD848, 0xD849,
0xD84A, 0xD84B, 0xD84C, 0xD84D, 0xD84E, 0xD84F, 0xD850, 0xD851,
0xD852, 0xD853, 0xD854, 0xD855, 0xD856, 0xD857, 0xD858, 0xD859,
0xD85A, 0xD85B, 0xD85C, 0xD85D, 0xD85E, 0xD85F, 0xD860, 0xD861,
0xD862, 0xD863, 0xD864, 0xD865, 0xD866, 0xD867, 0xD868, 0xD869,
0xD86A, 0xD86B, 0xD86C, 0xD86D, 0xD86E, 0xD86F, 0xD870, 0xD871,
0xD872, 0xD873, 0xD874, 0xD875, 0xD876, 0xD877, 0xD878, 0xD879,
0xD87A, 0xD87B, 0xD87C, 0xD87D, 0xD87E, 0xD880, 0xD881, 0xD882,
0xD883, 0xD884, 0xD885, 0xD886, 0xD887, 0xD888, 0xD889, 0xD88A,
0xD88B, 0xD88C, 0xD88D, 0xD88E, 0xD88F, 0xD890, 0xD891, 0xD892,
0xD893, 0xD894, 0xD895, 0xD896, 0xD897, 0xD898, 0xD899, 0xD89A,
0xD89B, 0xD89C, 0xD89D, 0xD89E, 0xD89F, 0xD8A0, 0xD940, 0xD941,
0xD942, 0xD943, 0xD944, 0xD945, 0xD946, 0xD947, 0xD948, 0xD949,
0xD94A, 0xD94B, 0xD94C, 0xD94D, 0xD94E, 0xD94F, 0xD950, 0xD951,
0xD952, 0xD953, 0xD954, 0xD955, 0xD956, 0xD957, 0xD958, 0xD959,
0xD95A, 0xD95B, 0xD95C, 0xD95D, 0xD95E, 0xD95F, 0xD960, 0xD961,
0xD962, 0xD963, 0xD964, 0xD965, 0xD966, 0xD967, 0xD968, 0xD969,
0xD96A, 0xD96B, 0xD96C, 0xD96D, 0xD96E, 0xD96F, 0xD970, 0xD971,
0xD972, 0xD973, 0xD974, 0xD975, 0xD976, 0xD977, 0xD978, 0xD979,
0xD97A, 0xD97B, 0xD97C, 0xD97D, 0xD97E, 0xD980, 0xD981, 0xD982,
0xD983, 0xD984, 0xD985, 0xD986, 0xD987, 0xD988, 0xD989, 0xD98A,
0xD98B, 0xD98C, 0xD98D, 0xD98E, 0xD98F, 0xD990, 0xD991, 0xD992,
0xD993, 0xD994, 0xD995, 0xD996, 0xD997, 0xD998, 0xD999, 0xD99A,
0xD99B, 0xD99C, 0xD99D, 0xD99E, 0xD99F, 0xD9A0, 0xDA40, 0xDA41,
0xDA42, 0xDA43, 0xDA44, 0xDA45, 0xDA46, 0xDA47, 0xDA48, 0xDA49,
0xDA4A, 0xDA4B, 0xDA4C, 0xDA4D, 0xDA4E, 0xDA4F, 0xDA50, 0xDA51,
0xDA52, 0xDA53, 0xDA54, 0xDA55, 0xDA56, 0xDA57, 0xDA58, 0xDA59,
0xDA5A, 0xDA5B, 0xDA5C, 0xDA5D, 0xDA5E, 0xDA5F, 0xDA60, 0xDA61,
0xDA62, 0xDA63, 0xDA64, 0xDA65, 0xDA66, 0xDA67, 0xDA68, 0xDA69,
0xDA6A, 0xDA6B, 0xDA6C, 0xDA6D, 0xDA6E, 0xDA6F, 0xDA70, 0xDA71,
0xDA72, 0xDA73, 0xDA74, 0xDA75, 0xDA76, 0xDA77, 0xDA78, 0xDA79,
0xDA7A, 0xDA7B, 0xDA7C, 0xDA7D, 0xDA7E, 0xDA80, 0xDA81, 0xDA82,
0xDA83, 0xDA84, 0xDA85, 0xDA86, 0xDA87, 0xDA88, 0xDA89, 0xDA8A,
0xDA8B, 0xDA8C, 0xDA8D, 0xDA8E, 0xDA8F, 0xDA90, 0xDA91, 0xDA92,
0xDA93, 0xDA94, 0xDA95, 0xDA96, 0xDA97, 0xDA98, 0xDA99, 0xDA9A,
0xDA9B, 0xDA9C, 0xDA9D, 0xDA9E, 0xDA9F, 0xDAA0, 0xDB40, 0xDB41,
0xDB42, 0xDB43, 0xDB44, 0xDB45, 0xDB46, 0xDB47, 0xDB48, 0xDB49,
0xDB4A, 0xDB4B, 0xDB4C, 0xDB4D, 0xDB4E, 0xDB4F, 0xDB50, 0xDB51,
0xDB52, 0xDB53, 0xDB54, 0xDB55, 0xDB56, 0xDB57, 0xDB58, 0xDB59,
0xDB5A, 0xDB5B, 0xDB5C, 0xDB5D, 0xDB5E, 0xDB5F, 0xDB60, 0xDB61,
0xDB62, 0xDB63, 0xDB64, 0xDB65, 0xDB66, 0xDB67, 0xDB68, 0xDB69,
0xDB6A, 0xDB6B, 0xDB6C, 0xDB6D, 0xDB6E, 0xDB6F, 0xDB70, 0xDB71,
0xDB72, 0xDB73, 0xDB74, 0xDB75, 0xDB76, 0xDB77, 0xDB78, 0xDB79,
0xDB7A, 0xDB7B, 0xDB7C, 0xDB7D, 0xDB7E, 0xDB80, 0xDB81, 0xDB82,
0xDB83, 0xDB84, 0xDB85, 0xDB86, 0xDB87, 0xDB88, 0xDB89, 0xDB8A,
0xDB8B, 0xDB8C, 0xDB8D, 0xDB8E, 0xDB8F, 0xDB90, 0xDB91, 0xDB92,
0xDB93, 0xDB94, 0xDB95, 0xDB96, 0xDB97, 0xDB98, 0xDB99, 0xDB9A,
0xDB9B, 0xDB9C, 0xDB9D, 0xDB9E, 0xDB9F, 0xDBA0, 0xDC40, 0xDC41,
0xDC42, 0xDC43, 0xDC44, 0xDC45, 0xDC46, 0xDC47, 0xDC48, 0xDC49,
0xDC4A, 0xDC4B, 0xDC4C, 0xDC4D, 0xDC4E, 0xDC4F, 0xDC50, 0xDC51,
0xDC52, 0xDC53, 0xDC54, 0xDC55, 0xDC56, 0xDC57, 0xDC58, 0xDC59,
0xDC5A, 0xDC5B, 0xDC5C, 0xDC5D, 0xDC5E, 0xDC5F, 0xDC60, 0xDC61,
0xDC62, 0xDC63, 0xDC64, 0xDC65, 0xDC66, 0xDC67, 0xDC68, 0xDC69,
0xDC6A, 0xDC6B, 0xDC6C, 0xDC6D, 0xDC6E, 0xDC6F, 0xDC70, 0xDC71,
0xDC72, 0xDC73, 0xDC74, 0xDC75, 0xDC76, 0xDC77, 0xDC78, 0xDC79,
0xDC7A, 0xDC7B, 0xDC7C, 0xDC7D, 0xDC7E, 0xDC80, 0xDC81, 0xDC82,
0xDC83, 0xDC84, 0xDC85, 0xDC86, 0xDC87, 0xDC88, 0xDC89, 0xDC8A,
0xDC8B, 0xDC8C, 0xDC8D, 0xDC8E, 0xDC8F, 0xDC90, 0xDC91, 0xDC92,
0xDC93, 0xDC94, 0xDC95, 0xDC96, 0xDC97, 0xDC98, 0xDC99, 0xDC9A,
0xDC9B, 0xDC9C, 0xDC9D, 0xDC9E, 0xDC9F, 0xDCA0, 0xDD40, 0xDD41,
0xDD42, 0xDD43, 0xDD44, 0xDD45, 0xDD46, 0xDD47, 0xDD48, 0xDD49,
0xDD4A, 0xDD4B, 0xDD4C, 0xDD4D, 0xDD4E, 0xDD4F, 0xDD50, 0xDD51,
0xDD52, 0xDD53, 0xDD54, 0xDD55, 0xDD56, 0xDD57, 0xDD58, 0xDD59,
0xDD5A, 0xDD5B, 0xDD5C, 0xDD5D, 0xDD5E, 0xDD5F, 0xDD60, 0xDD61,
0xDD62, 0xDD63, 0xDD64, 0xDD65, 0xDD66, 0xDD67, 0xDD68, 0xDD69,
0xDD6A, 0xDD6B, 0xDD6C, 0xDD6D, 0xDD6E, 0xDD6F, 0xDD70, 0xDD71,
0xDD72, 0xDD73, 0xDD74, 0xDD75, 0xDD76, 0xDD77, 0xDD78, 0xDD79,
0xDD7A, 0xDD7B, 0xDD7C, 0xDD7D, 0xDD7E, 0xDD80, 0xDD81, 0xDD82,
0xDD83, 0xDD84, 0xDD85, 0xDD86, 0xDD87, 0xDD88, 0xDD89, 0xDD8A,
0xDD8B, 0xDD8C, 0xDD8D, 0xDD8E, 0xDD8F, 0xDD90, 0xDD91, 0xDD92,
0xDD93, 0xDD94, 0xDD95, 0xDD96, 0xDD97, 0xDD98, 0xDD99, 0xDD9A,
0xDD9B, 0xDD9C, 0xDD9D, 0xDD9E, 0xDD9F, 0xDDA0, 0xDE40, 0xDE41,
0xDE42, 0xDE43, 0xDE44, 0xDE45, 0xDE46, 0xDE47, 0xDE48, 0xDE49,
0xDE4A, 0xDE4B, 0xDE4C, 0xDE4D, 0xDE4E, 0xDE4F, 0xDE50, 0xDE51,
0xDE52, 0xDE53, 0xDE54, 0xDE55, 0xDE56, 0xDE57, 0xDE58, 0xDE59,
0xDE5A, 0xDE5B, 0xDE5C, 0xDE5D, 0xDE5E, 0xDE5F, 0xDE60, 0xDE61,
0xDE62, 0xDE63, 0xDE64, 0xDE65, 0xDE66, 0xDE67, 0xDE68, 0xDE69,
0xDE6A, 0xDE6B, 0xDE6C, 0xDE6D, 0xDE6E, 0xDE6F, 0xDE70, 0xDE71,
0xDE72, 0xDE73, 0xDE74, 0xDE75, 0xDE76, 0xDE77, 0xDE78, 0xDE79,
0xDE7A, 0xDE7B, 0xDE7C, 0xDE7D, 0xDE7E, 0xDE80, 0xDE81, 0xDE82,
0xDE83, 0xDE84, 0xDE85, 0xDE86, 0xDE87, 0xDE88, 0xDE89, 0xDE8A,
0xDE8B, 0xDE8C, 0xDE8D, 0xDE8E, 0xDE8F, 0xDE90, 0xDE91, 0xDE92,
0xDE93, 0xDE94, 0xDE95, 0xDE96, 0xDE97, 0xDE98, 0xDE99, 0xDE9A,
0xDE9B, 0xDE9C, 0xDE9D, 0xDE9E, 0xDE9F, 0xDEA0, 0xDF40, 0xDF41,
0xDF42, 0xDF43, 0xDF44, 0xDF45, 0xDF46, 0xDF47, 0xDF48, 0xDF49,
0xDF4A, 0xDF4B, 0xDF4C, 0xDF4D, 0xDF4E, 0xDF4F, 0xDF50, 0xDF51,
0xDF52, 0xDF53, 0xDF54, 0xDF55, 0xDF56, 0xDF57, 0xDF58, 0xDF59,
0xDF5A, 0xDF5B, 0xDF5C, 0xDF5D, 0xDF5E, 0xDF5F, 0xDF60, 0xDF61,
0xDF62, 0xDF63, 0xDF64, 0xDF65, 0xDF66, 0xDF67, 0xDF68, 0xDF69,
0xDF6A, 0xDF6B, 0xDF6C, 0xDF6D, 0xDF6E, 0xDF6F, 0xDF70, 0xDF71,
0xDF72, 0xDF73, 0xDF74, 0xDF75, 0xDF76, 0xDF77, 0xDF78, 0xDF79,
0xDF7A, 0xDF7B, 0xDF7C, 0xDF7D, 0xDF7E, 0xDF80, 0xDF81, 0xDF82,
0xDF83, 0xDF84, 0xDF85, 0xDF86, 0xDF87, 0xDF88, 0xDF89, 0xDF8A,
0xDF8B, 0xDF8C, 0xDF8D, 0xDF8E, 0xDF8F, 0xDF90, 0xDF91, 0xDF92,
0xDF93, 0xDF94, 0xDF95, 0xDF96, 0xDF97, 0xDF98, 0xDF99, 0xDF9A,
0xDF9B, 0xDF9C, 0xDF9D, 0xDF9E, 0xDF9F, 0xDFA0, 0xE040, 0xE041,
0xE042, 0xE043, 0xE044, 0xE045, 0xE046, 0xE047, 0xE048, 0xE049,
0xE04A, 0xE04B, 0xE04C, 0xE04D, 0xE04E, 0xE04F, 0xE050, 0xE051,
0xE052, 0xE053, 0xE054, 0xE055, 0xE056, 0xE057, 0xE058, 0xE059,
0xE05A, 0xE05B, 0xE05C, 0xE05D, 0xE05E, 0xE05F, 0xE060, 0xE061,
0xE062, 0xE063, 0xE064, 0xE065, 0xE066, 0xE067, 0xE068, 0xE069,
0xE06A, 0xE06B, 0xE06C, 0xE06D, 0xE06E, 0xE06F, 0xE070, 0xE071,
0xE072, 0xE073, 0xE074, 0xE075, 0xE076, 0xE077, 0xE078, 0xE079,
0xE07A, 0xE07B, 0xE07C, 0xE07D, 0xE07E, 0xE080, 0xE081, 0xE082,
0xE083, 0xE084, 0xE085, 0xE086, 0xE087, 0xE088, 0xE089, 0xE08A,
0xE08B, 0xE08C, 0xE08D, 0xE08E, 0xE08F, 0xE090, 0xE091, 0xE092,
0xE093, 0xE094, 0xE095, 0xE096, 0xE097, 0xE098, 0xE099, 0xE09A,
0xE09B, 0xE09C, 0xE09D, 0xE09E, 0xE09F, 0xE0A0, 0xE140, 0xE141,
0xE142, 0xE143, 0xE144, 0xE145, 0xE146, 0xE147, 0xE148, 0xE149,
0xE14A, 0xE14B, 0xE14C, 0xE14D, 0xE14E, 0xE14F, 0xE150, 0xE151,
0xE152, 0xE153, 0xE154, 0xE155, 0xE156, 0xE157, 0xE158, 0xE159,
0xE15A, 0xE15B, 0xE15C, 0xE15D, 0xE15E, 0xE15F, 0xE160, 0xE161,
0xE162, 0xE163, 0xE164, 0xE165, 0xE166, 0xE167, 0xE168, 0xE169,
0xE16A, 0xE16B, 0xE16C, 0xE16D, 0xE16E, 0xE16F, 0xE170, 0xE171,
0xE172, 0xE173, 0xE174, 0xE175, 0xE176, 0xE177, 0xE178, 0xE179,
0xE17A, 0xE17B, 0xE17C, 0xE17D, 0xE17E, 0xE180, 0xE181, 0xE182,
0xE183, 0xE184, 0xE185, 0xE186, 0xE187, 0xE188, 0xE189, 0xE18A,
0xE18B, 0xE18C, 0xE18D, 0xE18E, 0xE18F, 0xE190, 0xE191, 0xE192,
0xE193, 0xE194, 0xE195, 0xE196, 0xE197, 0xE198, 0xE199, 0xE19A,
0xE19B, 0xE19C, 0xE19D, 0xE19E, 0xE19F, 0xE1A0, 0xE240, 0xE241,
0xE242, 0xE243, 0xE244, 0xE245, 0xE246, 0xE247, 0xE248, 0xE249,
0xE24A, 0xE24B, 0xE24C, 0xE24D, 0xE24E, 0xE24F, 0xE250, 0xE251,
0xE252, 0xE253, 0xE254, 0xE255, 0xE256, 0xE257, 0xE258, 0xE259,
0xE25A, 0xE25B, 0xE25C, 0xE25D, 0xE25E, 0xE25F, 0xE260, 0xE261,
0xE262, 0xE263, 0xE264, 0xE265, 0xE266, 0xE267, 0xE268, 0xE269,
0xE26A, 0xE26B, 0xE26C, 0xE26D, 0xE26E, 0xE26F, 0xE270, 0xE271,
0xE272, 0xE273, 0xE274, 0xE275, 0xE276, 0xE277, 0xE278, 0xE279,
0xE27A, 0xE27B, 0xE27C, 0xE27D, 0xE27E, 0xE280, 0xE281, 0xE282,
0xE283, 0xE284, 0xE285, 0xE286, 0xE287, 0xE288, 0xE289, 0xE28A,
0xE28B, 0xE28C, 0xE28D, 0xE28E, 0xE28F, 0xE290, 0xE291, 0xE292,
0xE293, 0xE294, 0xE295, 0xE296, 0xE297, 0xE298, 0xE299, 0xE29A,
0xE29B, 0xE29C, 0xE29D, 0xE29E, 0xE29F, 0xE2A0, 0xE340, 0xE341,
0xE342, 0xE343, 0xE344, 0xE345, 0xE346, 0xE347, 0xE348, 0xE349,
0xE34A, 0xE34B, 0xE34C, 0xE34D, 0xE34E, 0xE34F, 0xE350, 0xE351,
0xE352, 0xE353, 0xE354, 0xE355, 0xE356, 0xE357, 0xE358, 0xE359,
0xE35A, 0xE35B, 0xE35C, 0xE35D, 0xE35E, 0xE35F, 0xE360, 0xE361,
0xE362, 0xE363, 0xE364, 0xE365, 0xE366, 0xE367, 0xE368, 0xE369,
0xE36A, 0xE36B, 0xE36C, 0xE36D, 0xE36E, 0xE36F, 0xE370, 0xE371,
0xE372, 0xE373, 0xE374, 0xE375, 0xE376, 0xE377, 0xE378, 0xE379,
0xE37A, 0xE37B, 0xE37C, 0xE37D, 0xE37E, 0xE380, 0xE381, 0xE382,
0xE383, 0xE384, 0xE385, 0xE386, 0xE387, 0xE388, 0xE389, 0xE38A,
0xE38B, 0xE38C, 0xE38D, 0xE38E, 0xE38F, 0xE390, 0xE391, 0xE392,
0xE393, 0xE394, 0xE395, 0xE396, 0xE397, 0xE398, 0xE399, 0xE39A,
0xE39B, 0xE39C, 0xE39D, 0xE39E, 0xE39F, 0xE3A0, 0xE440, 0xE441,
0xE442, 0xE443, 0xE444, 0xE445, 0xE446, 0xE447, 0xE448, 0xE449,
0xE44A, 0xE44B, 0xE44C, 0xE44D, 0xE44E, 0xE44F, 0xE450, 0xE451,
0xE452, 0xE453, 0xE454, 0xE455, 0xE456, 0xE457, 0xE458, 0xE459,
0xE45A, 0xE45B, 0xE45C, 0xE45D, 0xE45E, 0xE45F, 0xE460, 0xE461,
0xE462, 0xE463, 0xE464, 0xE465, 0xE466, 0xE467, 0xE468, 0xE469,
0xE46A, 0xE46B, 0xE46C, 0xE46D, 0xE46E, 0xE46F, 0xE470, 0xE471,
0xE472, 0xE473, 0xE474, 0xE475, 0xE476, 0xE477, 0xE478, 0xE479,
0xE47A, 0xE47B, 0xE47C, 0xE47D, 0xE47E, 0xE480, 0xE481, 0xE482,
0xE483, 0xE484, 0xE485, 0xE486, 0xE487, 0xE488, 0xE489, 0xE48A,
0xE48B, 0xE48C, 0xE48D, 0xE48E, 0xE48F, 0xE490, 0xE491, 0xE492,
0xE493, 0xE494, 0xE495, 0xE496, 0xE497, 0xE498, 0xE499, 0xE49A,
0xE49B, 0xE49C, 0xE49D, 0xE49E, 0xE49F, 0xE4A0, 0xE540, 0xE541,
0xE542, 0xE543, 0xE544, 0xE545, 0xE546, 0xE547, 0xE548, 0xE549,
0xE54A, 0xE54B, 0xE54C, 0xE54D, 0xE54E, 0xE54F, 0xE550, 0xE551,
0xE552, 0xE553, 0xE554, 0xE555, 0xE556, 0xE557, 0xE558, 0xE559,
0xE55A, 0xE55B, 0xE55C, 0xE55D, 0xE55E, 0xE55F, 0xE560, 0xE561,
0xE562, 0xE563, 0xE564, 0xE565, 0xE566, 0xE567, 0xE568, 0xE569,
0xE56A, 0xE56B, 0xE56C, 0xE56D, 0xE56E, 0xE56F, 0xE570, 0xE571,
0xE572, 0xE573, 0xE574, 0xE575, 0xE576, 0xE577, 0xE578, 0xE579,
0xE57A, 0xE57B, 0xE57C, 0xE57D, 0xE57E, 0xE580, 0xE581, 0xE582,
0xE583, 0xE584, 0xE585, 0xE586, 0xE587, 0xE588, 0xE589, 0xE58A,
0xE58B, 0xE58C, 0xE58D, 0xE58E, 0xE58F, 0xE590, 0xE591, 0xE592,
0xE593, 0xE594, 0xE595, 0xE596, 0xE597, 0xE598, 0xE599, 0xE59A,
0xE59B, 0xE59C, 0xE59D, 0xE59E, 0xE59F, 0xE5A0, 0xE640, 0xE641,
0xE642, 0xE643, 0xE644, 0xE645, 0xE646, 0xE647, 0xE648, 0xE649,
0xE64A, 0xE64B, 0xE64C, 0xE64D, 0xE64E, 0xE64F, 0xE650, 0xE651,
0xE652, 0xE653, 0xE654, 0xE655, 0xE656, 0xE657, 0xE658, 0xE659,
0xE65A, 0xE65B, 0xE65C, 0xE65D, 0xE65E, 0xE65F, 0xE660, 0xE661,
0xE662, 0xE663, 0xE664, 0xE665, 0xE666, 0xE667, 0xE668, 0xE669,
0xE66A, 0xE66B, 0xE66C, 0xE66D, 0xE66E, 0xE66F, 0xE670, 0xE671,
0xE672, 0xE673, 0xE674, 0xE675, 0xE676, 0xE677, 0xE678, 0xE679,
0xE67A, 0xE67B, 0xE67C, 0xE67D, 0xE67E, 0xE680, 0xE681, 0xE682,
0xE683, 0xE684, 0xE685, 0xE686, 0xE687, 0xE688, 0xE689, 0xE68A,
0xE68B, 0xE68C, 0xE68D, 0xE68E, 0xE68F, 0xE690, 0xE691, 0xE692,
0xE693, 0xE694, 0xE695, 0xE696, 0xE697, 0xE698, 0xE699, 0xE69A,
0xE69B, 0xE69C, 0xE69D, 0xE69E, 0xE69F, 0xE6A0, 0xE740, 0xE741,
0xE742, 0xE743, 0xE744, 0xE745, 0xE746, 0xE747, 0xE748, 0xE749,
0xE74A, 0xE74B, 0xE74C, 0xE74D, 0xE74E, 0xE74F, 0xE750, 0xE751,
0xE752, 0xE753, 0xE754, 0xE755, 0xE756, 0xE757, 0xE758, 0xE759,
0xE75A, 0xE75B, 0xE75C, 0xE75D, 0xE75E, 0xE75F, 0xE760, 0xE761,
0xE762, 0xE763, 0xE764, 0xE765, 0xE766, 0xE767, 0xE768, 0xE769,
0xE76A, 0xE76B, 0xE76C, 0xE76D, 0xE76E, 0xE76F, 0xE770, 0xE771,
0xE772, 0xE773, 0xE774, 0xE775, 0xE776, 0xE777, 0xE778, 0xE779,
0xE77A, 0xE77B, 0xE77C, 0xE77D, 0xE77E, 0xE780, 0xE781, 0xE782,
0xE783, 0xE784, 0xE785, 0xE786, 0xE787, 0xE788, 0xE789, 0xE78A,
0xE78B, 0xE78C, 0xE78D, 0xE78E, 0xE78F, 0xE790, 0xE791, 0xE792,
0xE793, 0xE794, 0xE795, 0xE796, 0xE797, 0xE798, 0xE799, 0xE79A,
0xE79B, 0xE79C, 0xE79D, 0xE79E, 0xE79F, 0xE7A0, 0xE840, 0xE841,
0xE842, 0xE843, 0xE844, 0xE845, 0xE846, 0xE847, 0xE848, 0xE849,
0xE84A, 0xE84B, 0xE84C, 0xE84D, 0xE84E, 0xE84F, 0xE850, 0xE851,
0xE852, 0xE853, 0xE854, 0xE855, 0xE856, 0xE857, 0xE858, 0xE859,
0xE85A, 0xE85B, 0xE85C, 0xE85D, 0xE85E, 0xE85F, 0xE860, 0xE861,
0xE862, 0xE863, 0xE864, 0xE865, 0xE866, 0xE867, 0xE868, 0xE869,
0xE86A, 0xE86B, 0xE86C, 0xE86D, 0xE86E, 0xE86F, 0xE870, 0xE871,
0xE872, 0xE873, 0xE874, 0xE875, 0xE876, 0xE877, 0xE878, 0xE879,
0xE87A, 0xE87B, 0xE87C, 0xE87D, 0xE87E, 0xE880, 0xE881, 0xE882,
0xE883, 0xE884, 0xE885, 0xE886, 0xE887, 0xE888, 0xE889, 0xE88A,
0xE88B, 0xE88C, 0xE88D, 0xE88E, 0xE88F, 0xE890, 0xE891, 0xE892,
0xE893, 0xE894, 0xE895, 0xE896, 0xE897, 0xE898, 0xE899, 0xE89A,
0xE89B, 0xE89C, 0xE89D, 0xE89E, 0xE89F, 0xE8A0, 0xE940, 0xE941,
0xE942, 0xE943, 0xE944, 0xE945, 0xE946, 0xE947, 0xE948, 0xE949,
0xE94A, 0xE94B, 0xE94C, 0xE94D, 0xE94E, 0xE94F, 0xE950, 0xE951,
0xE952, 0xE953, 0xE954, 0xE955, 0xE956, 0xE957, 0xE958, 0xE959,
0xE95A, 0xE95B, 0xE95C, 0xE95D, 0xE95E, 0xE95F, 0xE960, 0xE961,
0xE962, 0xE963, 0xE964, 0xE965, 0xE966, 0xE967, 0xE968, 0xE969,
0xE96A, 0xE96B, 0xE96C, 0xE96D, 0xE96E, 0xE96F, 0xE970, 0xE971,
0xE972, 0xE973, 0xE974, 0xE975, 0xE976, 0xE977, 0xE978, 0xE979,
0xE97A, 0xE97B, 0xE97C, 0xE97D, 0xE97E, 0xE980, 0xE981, 0xE982,
0xE983, 0xE984, 0xE985, 0xE986, 0xE987, 0xE988, 0xE989, 0xE98A,
0xE98B, 0xE98C, 0xE98D, 0xE98E, 0xE98F, 0xE990, 0xE991, 0xE992,
0xE993, 0xE994, 0xE995, 0xE996, 0xE997, 0xE998, 0xE999, 0xE99A,
0xE99B, 0xE99C, 0xE99D, 0xE99E, 0xE99F, 0xE9A0, 0xEA40, 0xEA41,
0xEA42, 0xEA43, 0xEA44, 0xEA45, 0xEA46, 0xEA47, 0xEA48, 0xEA49,
0xEA4A, 0xEA4B, 0xEA4C, 0xEA4D, 0xEA4E, 0xEA4F, 0xEA50, 0xEA51,
0xEA52, 0xEA53, 0xEA54, 0xEA55, 0xEA56, 0xEA57, 0xEA58, 0xEA59,
0xEA5A, 0xEA5B, 0xEA5C, 0xEA5D, 0xEA5E, 0xEA5F, 0xEA60, 0xEA61,
0xEA62, 0xEA63, 0xEA64, 0xEA65, 0xEA66, 0xEA67, 0xEA68, 0xEA69,
0xEA6A, 0xEA6B, 0xEA6C, 0xEA6D, 0xEA6E, 0xEA6F, 0xEA70, 0xEA71,
0xEA72, 0xEA73, 0xEA74, 0xEA75, 0xEA76, 0xEA77, 0xEA78, 0xEA79,
0xEA7A, 0xEA7B, 0xEA7C, 0xEA7D, 0xEA7E, 0xEA80, 0xEA81, 0xEA82,
0xEA83, 0xEA84, 0xEA85, 0xEA86, 0xEA87, 0xEA88, 0xEA89, 0xEA8A,
0xEA8B, 0xEA8C, 0xEA8D, 0xEA8E, 0xEA8F, 0xEA90, 0xEA91, 0xEA92,
0xEA93, 0xEA94, 0xEA95, 0xEA96, 0xEA97, 0xEA98, 0xEA99, 0xEA9A,
0xEA9B, 0xEA9C, 0xEA9D, 0xEA9E, 0xEA9F, 0xEAA0, 0xEB40, 0xEB41,
0xEB42, 0xEB43, 0xEB44, 0xEB45, 0xEB46, 0xEB47, 0xEB48, 0xEB49,
0xEB4A, 0xEB4B, 0xEB4C, 0xEB4D, 0xEB4E, 0xEB4F, 0xEB50, 0xEB51,
0xEB52, 0xEB53, 0xEB54, 0xEB55, 0xEB56, 0xEB57, 0xEB58, 0xEB59,
0xEB5A, 0xEB5B, 0xEB5C, 0xEB5D, 0xEB5E, 0xEB5F, 0xEB60, 0xEB61,
0xEB62, 0xEB63, 0xEB64, 0xEB65, 0xEB66, 0xEB67, 0xEB68, 0xEB69,
0xEB6A, 0xEB6B, 0xEB6C, 0xEB6D, 0xEB6E, 0xEB6F, 0xEB70, 0xEB71,
0xEB72, 0xEB73, 0xEB74, 0xEB75, 0xEB76, 0xEB77, 0xEB78, 0xEB79,
0xEB7A, 0xEB7B, 0xEB7C, 0xEB7D, 0xEB7E, 0xEB80, 0xEB81, 0xEB82,
0xEB83, 0xEB84, 0xEB85, 0xEB86, 0xEB87, 0xEB88, 0xEB89, 0xEB8A,
0xEB8B, 0xEB8C, 0xEB8D, 0xEB8E, 0xEB8F, 0xEB90, 0xEB91, 0xEB92,
0xEB93, 0xEB94, 0xEB95, 0xEB96, 0xEB97, 0xEB98, 0xEB99, 0xEB9A,
0xEB9B, 0xEB9C, 0xEB9D, 0xEB9E, 0xEB9F, 0xEBA0, 0xEC40, 0xEC41,
0xEC42, 0xEC43, 0xEC44, 0xEC45, 0xEC46, 0xEC47, 0xEC48, 0xEC49,
0xEC4A, 0xEC4B, 0xEC4C, 0xEC4D, 0xEC4E, 0xEC4F, 0xEC50, 0xEC51,
0xEC52, 0xEC53, 0xEC54, 0xEC55, 0xEC56, 0xEC57, 0xEC58, 0xEC59,
0xEC5A, 0xEC5B, 0xEC5C, 0xEC5D, 0xEC5E, 0xEC5F, 0xEC60, 0xEC61,
0xEC62, 0xEC63, 0xEC64, 0xEC65, 0xEC66, 0xEC67, 0xEC68, 0xEC69,
0xEC6A, 0xEC6B, 0xEC6C, 0xEC6D, 0xEC6E, 0xEC6F, 0xEC70, 0xEC71,
0xEC72, 0xEC73, 0xEC74, 0xEC75, 0xEC76, 0xEC77, 0xEC78, 0xEC79,
0xEC7A, 0xEC7B, 0xEC7C, 0xEC7D, 0xEC7E, 0xEC80, 0xEC81, 0xEC82,
0xEC83, 0xEC84, 0xEC85, 0xEC86, 0xEC87, 0xEC88, 0xEC89, 0xEC8A,
0xEC8B, 0xEC8C, 0xEC8D, 0xEC8E, 0xEC8F, 0xEC90, 0xEC91, 0xEC92,
0xEC93, 0xEC94, 0xEC95, 0xEC96, 0xEC97, 0xEC98, 0xEC99, 0xEC9A,
0xEC9B, 0xEC9C, 0xEC9D, 0xEC9E, 0xEC9F, 0xECA0, 0xED40, 0xED41,
0xED42, 0xED43, 0xED44, 0xED45, 0xED46, 0xED47, 0xED48, 0xED49,
0xED4A, 0xED4B, 0xED4C, 0xED4D, 0xED4E, 0xED4F, 0xED50, 0xED51,
0xED52, 0xED53, 0xED54, 0xED55, 0xED56, 0xED57, 0xED58, 0xED59,
0xED5A, 0xED5B, 0xED5C, 0xED5D, 0xED5E, 0xED5F, 0xED60, 0xED61,
0xED62, 0xED63, 0xED64, 0xED65, 0xED66, 0xED67, 0xED68, 0xED69,
0xED6A, 0xED6B, 0xED6C, 0xED6D, 0xED6E, 0xED6F, 0xED70, 0xED71,
0xED72, 0xED73, 0xED74, 0xED75, 0xED76, 0xED77, 0xED78, 0xED79,
0xED7A, 0xED7B, 0xED7C, 0xED7D, 0xED7E, 0xED80, 0xED81, 0xED82,
0xED83, 0xED84, 0xED85, 0xED86, 0xED87, 0xED88, 0xED89, 0xED8A,
0xED8B, 0xED8C, 0xED8D, 0xED8E, 0xED8F, 0xED90, 0xED91, 0xED92,
0xED93, 0xED94, 0xED95, 0xED96, 0xED97, 0xED98, 0xED99, 0xED9A,
0xED9B, 0xED9C, 0xED9D, 0xED9E, 0xED9F, 0xEDA0, 0xEE40, 0xEE41,
0xEE42, 0xEE43, 0xEE44, 0xEE45, 0xEE46, 0xEE47, 0xEE48, 0xEE49,
0xEE4A, 0xEE4B, 0xEE4C, 0xEE4D, 0xEE4E, 0xEE4F, 0xEE50, 0xEE51,
0xEE52, 0xEE53, 0xEE54, 0xEE55, 0xEE56, 0xEE57, 0xEE58, 0xEE59,
0xEE5A, 0xEE5B, 0xEE5C, 0xEE5D, 0xEE5E, 0xEE5F, 0xEE60, 0xEE61,
0xEE62, 0xEE63, 0xEE64, 0xEE65, 0xEE66, 0xEE67, 0xEE68, 0xEE69,
0xEE6A, 0xEE6B, 0xEE6C, 0xEE6D, 0xEE6E, 0xEE6F, 0xEE70, 0xEE71,
0xEE72, 0xEE73, 0xEE74, 0xEE75, 0xEE76, 0xEE77, 0xEE78, 0xEE79,
0xEE7A, 0xEE7B, 0xEE7C, 0xEE7D, 0xEE7E, 0xEE80, 0xEE81, 0xEE82,
0xEE83, 0xEE84, 0xEE85, 0xEE86, 0xEE87, 0xEE88, 0xEE89, 0xEE8A,
0xEE8B, 0xEE8C, 0xEE8D, 0xEE8E, 0xEE8F, 0xEE90, 0xEE91, 0xEE92,
0xEE93, 0xEE94, 0xEE95, 0xEE96, 0xEE97, 0xEE98, 0xEE99, 0xEE9A,
0xEE9B, 0xEE9C, 0xEE9D, 0xEE9E, 0xEE9F, 0xEEA0, 0xEF40, 0xEF41,
0xEF42, 0xEF43, 0xEF44, 0xEF45, 0xEF46, 0xEF47, 0xEF48, 0xEF49,
0xEF4A, 0xEF4B, 0xEF4C, 0xEF4D, 0xEF4E, 0xEF4F, 0xEF50, 0xEF51,
0xEF52, 0xEF53, 0xEF54, 0xEF55, 0xEF56, 0xEF57, 0xEF58, 0xEF59,
0xEF5A, 0xEF5B, 0xEF5C, 0xEF5D, 0xEF5E, 0xEF5F, 0xEF60, 0xEF61,
0xEF62, 0xEF63, 0xEF64, 0xEF65, 0xEF66, 0xEF67, 0xEF68, 0xEF69,
0xEF6A, 0xEF6B, 0xEF6C, 0xEF6D, 0xEF6E, 0xEF6F, 0xEF70, 0xEF71,
0xEF72, 0xEF73, 0xEF74, 0xEF75, 0xEF76, 0xEF77, 0xEF78, 0xEF79,
0xEF7A, 0xEF7B, 0xEF7C, 0xEF7D, 0xEF7E, 0xEF80, 0xEF81, 0xEF82,
0xEF83, 0xEF84, 0xEF85, 0xEF86, 0xEF87, 0xEF88, 0xEF89, 0xEF8A,
0xEF8B, 0xEF8C, 0xEF8D, 0xEF8E, 0xEF8F, 0xEF90, 0xEF91, 0xEF92,
0xEF93, 0xEF94, 0xEF95, 0xEF96, 0xEF97, 0xEF98, 0xEF99, 0xEF9A,
0xEF9B, 0xEF9C, 0xEF9D, 0xEF9E, 0xEF9F, 0xEFA0, 0xF040, 0xF041,
0xF042, 0xF043, 0xF044, 0xF045, 0xF046, 0xF047, 0xF048, 0xF049,
0xF04A, 0xF04B, 0xF04C, 0xF04D, 0xF04E, 0xF04F, 0xF050, 0xF051,
0xF052, 0xF053, 0xF054, 0xF055, 0xF056, 0xF057, 0xF058, 0xF059,
0xF05A, 0xF05B, 0xF05C, 0xF05D, 0xF05E, 0xF05F, 0xF060, 0xF061,
0xF062, 0xF063, 0xF064, 0xF065, 0xF066, 0xF067, 0xF068, 0xF069,
0xF06A, 0xF06B, 0xF06C, 0xF06D, 0xF06E, 0xF06F, 0xF070, 0xF071,
0xF072, 0xF073, 0xF074, 0xF075, 0xF076, 0xF077, 0xF078, 0xF079,
0xF07A, 0xF07B, 0xF07C, 0xF07D, 0xF07E, 0xF080, 0xF081, 0xF082,
0xF083, 0xF084, 0xF085, 0xF086, 0xF087, 0xF088, 0xF089, 0xF08A,
0xF08B, 0xF08C, 0xF08D, 0xF08E, 0xF08F, 0xF090, 0xF091, 0xF092,
0xF093, 0xF094, 0xF095, 0xF096, 0xF097, 0xF098, 0xF099, 0xF09A,
0xF09B, 0xF09C, 0xF09D, 0xF09E, 0xF09F, 0xF0A0, 0xF140, 0xF141,
0xF142, 0xF143, 0xF144, 0xF145, 0xF146, 0xF147, 0xF148, 0xF149,
0xF14A, 0xF14B, 0xF14C, 0xF14D, 0xF14E, 0xF14F, 0xF150, 0xF151,
0xF152, 0xF153, 0xF154, 0xF155, 0xF156, 0xF157, 0xF158, 0xF159,
0xF15A, 0xF15B, 0xF15C, 0xF15D, 0xF15E, 0xF15F, 0xF160, 0xF161,
0xF162, 0xF163, 0xF164, 0xF165, 0xF166, 0xF167, 0xF168, 0xF169,
0xF16A, 0xF16B, 0xF16C, 0xF16D, 0xF16E, 0xF16F, 0xF170, 0xF171,
0xF172, 0xF173, 0xF174, 0xF175, 0xF176, 0xF177, 0xF178, 0xF179,
0xF17A, 0xF17B, 0xF17C, 0xF17D, 0xF17E, 0xF180, 0xF181, 0xF182,
0xF183, 0xF184, 0xF185, 0xF186, 0xF187, 0xF188, 0xF189, 0xF18A,
0xF18B, 0xF18C, 0xF18D, 0xF18E, 0xF18F, 0xF190, 0xF191, 0xF192,
0xF193, 0xF194, 0xF195, 0xF196, 0xF197, 0xF198, 0xF199, 0xF19A,
0xF19B, 0xF19C, 0xF19D, 0xF19E, 0xF19F, 0xF1A0, 0xF240, 0xF241,
0xF242, 0xF243, 0xF244, 0xF245, 0xF246, 0xF247, 0xF248, 0xF249,
0xF24A, 0xF24B, 0xF24C, 0xF24D, 0xF24E, 0xF24F, 0xF250, 0xF251,
0xF252, 0xF253, 0xF254, 0xF255, 0xF256, 0xF257, 0xF258, 0xF259,
0xF25A, 0xF25B, 0xF25C, 0xF25D, 0xF25E, 0xF25F, 0xF260, 0xF261,
0xF262, 0xF263, 0xF264, 0xF265, 0xF266, 0xF267, 0xF268, 0xF269,
0xF26A, 0xF26B, 0xF26C, 0xF26D, 0xF26E, 0xF26F, 0xF270, 0xF271,
0xF272, 0xF273, 0xF274, 0xF275, 0xF276, 0xF277, 0xF278, 0xF279,
0xF27A, 0xF27B, 0xF27C, 0xF27D, 0xF27E, 0xF280, 0xF281, 0xF282,
0xF283, 0xF284, 0xF285, 0xF286, 0xF287, 0xF288, 0xF289, 0xF28A,
0xF28B, 0xF28C, 0xF28D, 0xF28E, 0xF28F, 0xF290, 0xF291, 0xF292,
0xF293, 0xF294, 0xF295, 0xF296, 0xF297, 0xF298, 0xF299, 0xF29A,
0xF29B, 0xF29C, 0xF29D, 0xF29E, 0xF29F, 0xF2A0, 0xF340, 0xF341,
0xF342, 0xF343, 0xF344, 0xF345, 0xF346, 0xF347, 0xF348, 0xF349,
0xF34A, 0xF34B, 0xF34C, 0xF34D, 0xF34E, 0xF34F, 0xF350, 0xF351,
0xF352, 0xF353, 0xF354, 0xF355, 0xF356, 0xF357, 0xF358, 0xF359,
0xF35A, 0xF35B, 0xF35C, 0xF35D, 0xF35E, 0xF35F, 0xF360, 0xF361,
0xF362, 0xF363, 0xF364, 0xF365, 0xF366, 0xF367, 0xF368, 0xF369,
0xF36A, 0xF36B, 0xF36C, 0xF36D, 0xF36E, 0xF36F, 0xF370, 0xF371,
0xF372, 0xF373, 0xF374, 0xF375, 0xF376, 0xF377, 0xF378, 0xF379,
0xF37A, 0xF37B, 0xF37C, 0xF37D, 0xF37E, 0xF380, 0xF381, 0xF382,
0xF383, 0xF384, 0xF385, 0xF386, 0xF387, 0xF388, 0xF389, 0xF38A,
0xF38B, 0xF38C, 0xF38D, 0xF38E, 0xF38F, 0xF390, 0xF391, 0xF392,
0xF393, 0xF394, 0xF395, 0xF396, 0xF397, 0xF398, 0xF399, 0xF39A,
0xF39B, 0xF39C, 0xF39D, 0xF39E, 0xF39F, 0xF3A0, 0xF440, 0xF441,
0xF442, 0xF443, 0xF444, 0xF445, 0xF446, 0xF447, 0xF448, 0xF449,
0xF44A, 0xF44B, 0xF44C, 0xF44D, 0xF44E, 0xF44F, 0xF450, 0xF451,
0xF452, 0xF453, 0xF454, 0xF455, 0xF456, 0xF457, 0xF458, 0xF459,
0xF45A, 0xF45B, 0xF45C, 0xF45D, 0xF45E, 0xF45F, 0xF460, 0xF461,
0xF462, 0xF463, 0xF464, 0xF465, 0xF466, 0xF467, 0xF468, 0xF469,
0xF46A, 0xF46B, 0xF46C, 0xF46D, 0xF46E, 0xF46F, 0xF470, 0xF471,
0xF472, 0xF473, 0xF474, 0xF475, 0xF476, 0xF477, 0xF478, 0xF479,
0xF47A, 0xF47B, 0xF47C, 0xF47D, 0xF47E, 0xF480, 0xF481, 0xF482,
0xF483, 0xF484, 0xF485, 0xF486, 0xF487, 0xF488, 0xF489, 0xF48A,
0xF48B, 0xF48C, 0xF48D, 0xF48E, 0xF48F, 0xF490, 0xF491, 0xF492,
0xF493, 0xF494, 0xF495, 0xF496, 0xF497, 0xF498, 0xF499, 0xF49A,
0xF49B, 0xF49C, 0xF49D, 0xF49E, 0xF49F, 0xF4A0, 0xF540, 0xF541,
0xF542, 0xF543, 0xF544, 0xF545, 0xF546, 0xF547, 0xF548, 0xF549,
0xF54A, 0xF54B, 0xF54C, 0xF54D, 0xF54E, 0xF54F, 0xF550, 0xF551,
0xF552, 0xF553, 0xF554, 0xF555, 0xF556, 0xF557, 0xF558, 0xF559,
0xF55A, 0xF55B, 0xF55C, 0xF55D, 0xF55E, 0xF55F, 0xF560, 0xF561,
0xF562, 0xF563, 0xF564, 0xF565, 0xF566, 0xF567, 0xF568, 0xF569,
0xF56A, 0xF56B, 0xF56C, 0xF56D, 0xF56E, 0xF56F, 0xF570, 0xF571,
0xF572, 0xF573, 0xF574, 0xF575, 0xF576, 0xF577, 0xF578, 0xF579,
0xF57A, 0xF57B, 0xF57C, 0xF57D, 0xF57E, 0xF580, 0xF581, 0xF582,
0xF583, 0xF584, 0xF585, 0xF586, 0xF587, 0xF588, 0xF589, 0xF58A,
0xF58B, 0xF58C, 0xF58D, 0xF58E, 0xF58F, 0xF590, 0xF591, 0xF592,
0xF593, 0xF594, 0xF595, 0xF596, 0xF597, 0xF598, 0xF599, 0xF59A,
0xF59B, 0xF59C, 0xF59D, 0xF59E, 0xF59F, 0xF5A0, 0xF640, 0xF641,
0xF642, 0xF643, 0xF644, 0xF645, 0xF646, 0xF647, 0xF648, 0xF649,
0xF64A, 0xF64B, 0xF64C, 0xF64D, 0xF64E, 0xF64F, 0xF650, 0xF651,
0xF652, 0xF653, 0xF654, 0xF655, 0xF656, 0xF657, 0xF658, 0xF659,
0xF65A, 0xF65B, 0xF65C, 0xF65D, 0xF65E, 0xF65F, 0xF660, 0xF661,
0xF662, 0xF663, 0xF664, 0xF665, 0xF666, 0xF667, 0xF668, 0xF669,
0xF66A, 0xF66B, 0xF66C, 0xF66D, 0xF66E, 0xF66F, 0xF670, 0xF671,
0xF672, 0xF673, 0xF674, 0xF675, 0xF676, 0xF677, 0xF678, 0xF679,
0xF67A, 0xF67B, 0xF67C, 0xF67D, 0xF67E, 0xF680, 0xF681, 0xF682,
0xF683, 0xF684, 0xF685, 0xF686, 0xF687, 0xF688, 0xF689, 0xF68A,
0xF68B, 0xF68C, 0xF68D, 0xF68E, 0xF68F, 0xF690, 0xF691, 0xF692,
0xF693, 0xF694, 0xF695, 0xF696, 0xF697, 0xF698, 0xF699, 0xF69A,
0xF69B, 0xF69C, 0xF69D, 0xF69E, 0xF69F, 0xF6A0, 0xF740, 0xF741,
0xF742, 0xF743, 0xF744, 0xF745, 0xF746, 0xF747, 0xF748, 0xF749,
0xF74A, 0xF74B, 0xF74C, 0xF74D, 0xF74E, 0xF74F, 0xF750, 0xF751,
0xF752, 0xF753, 0xF754, 0xF755, 0xF756, 0xF757, 0xF758, 0xF759,
0xF75A, 0xF75B, 0xF75C, 0xF75D, 0xF75E, 0xF75F, 0xF760, 0xF761,
0xF762, 0xF763, 0xF764, 0xF765, 0xF766, 0xF767, 0xF768, 0xF769,
0xF76A, 0xF76B, 0xF76C, 0xF76D, 0xF76E, 0xF76F, 0xF770, 0xF771,
0xF772, 0xF773, 0xF774, 0xF775, 0xF776, 0xF777, 0xF778, 0xF779,
0xF77A, 0xF77B, 0xF77C, 0xF77D, 0xF77E, 0xF780, 0xF781, 0xF782,
0xF783, 0xF784, 0xF785, 0xF786, 0xF787, 0xF788, 0xF789, 0xF78A,
0xF78B, 0xF78C, 0xF78D, 0xF78E, 0xF78F, 0xF790, 0xF791, 0xF792,
0xF793, 0xF794, 0xF795, 0xF796, 0xF797, 0xF798, 0xF799, 0xF79A,
0xF79B, 0xF79C, 0xF79D, 0xF79E, 0xF79F, 0xF7A0, 0xF840, 0xF841,
0xF842, 0xF843, 0xF844, 0xF845, 0xF846, 0xF847, 0xF848, 0xF849,
0xF84A, 0xF84B, 0xF84C, 0xF84D, 0xF84E, 0xF84F, 0xF850, 0xF851,
0xF852, 0xF853, 0xF854, 0xF855, 0xF856, 0xF857, 0xF858, 0xF859,
0xF85A, 0xF85B, 0xF85C, 0xF85D, 0xF85E, 0xF85F, 0xF860, 0xF861,
0xF862, 0xF863, 0xF864, 0xF865, 0xF866, 0xF867, 0xF868, 0xF869,
0xF86A, 0xF86B, 0xF86C, 0xF86D, 0xF86E, 0xF86F, 0xF870, 0xF871,
0xF872, 0xF873, 0xF874, 0xF875, 0xF876, 0xF877, 0xF878, 0xF879,
0xF87A, 0xF87B, 0xF87C, 0xF87D, 0xF87E, 0xF880, 0xF881, 0xF882,
0xF883, 0xF884, 0xF885, 0xF886, 0xF887, 0xF888, 0xF889, 0xF88A,
0xF88B, 0xF88C, 0xF88D, 0xF88E, 0xF88F, 0xF890, 0xF891, 0xF892,
0xF893, 0xF894, 0xF895, 0xF896, 0xF897, 0xF898, 0xF899, 0xF89A,
0xF89B, 0xF89C, 0xF89D, 0xF89E, 0xF89F, 0xF8A0, 0xF940, 0xF941,
0xF942, 0xF943, 0xF944, 0xF945, 0xF946, 0xF947, 0xF948, 0xF949,
0xF94A, 0xF94B, 0xF94C, 0xF94D, 0xF94E, 0xF94F, 0xF950, 0xF951,
0xF952, 0xF953, 0xF954, 0xF955, 0xF956, 0xF957, 0xF958, 0xF959,
0xF95A, 0xF95B, 0xF95C, 0xF95D, 0xF95E, 0xF95F, 0xF960, 0xF961,
0xF962, 0xF963, 0xF964, 0xF965, 0xF966, 0xF967, 0xF968, 0xF969,
0xF96A, 0xF96B, 0xF96C, 0xF96D, 0xF96E, 0xF96F, 0xF970, 0xF971,
0xF972, 0xF973, 0xF974, 0xF975, 0xF976, 0xF977, 0xF978, 0xF979,
0xF97A, 0xF97B, 0xF97C, 0xF97D, 0xF97E, 0xF980, 0xF981, 0xF982,
0xF983, 0xF984, 0xF985, 0xF986, 0xF987, 0xF988, 0xF989, 0xF98A,
0xF98B, 0xF98C, 0xF98D, 0xF98E, 0xF98F, 0xF990, 0xF991, 0xF992,
0xF993, 0xF994, 0xF995, 0xF996, 0xF997, 0xF998, 0xF999, 0xF99A,
0xF99B, 0xF99C, 0xF99D, 0xF99E, 0xF99F, 0xF9A0, 0xFA40, 0xFA41,
0xFA42, 0xFA43, 0xFA44, 0xFA45, 0xFA46, 0xFA47, 0xFA48, 0xFA49,
0xFA4A, 0xFA4B, 0xFA4C, 0xFA4D, 0xFA4E, 0xFA4F, 0xFA50, 0xFA51,
0xFA52, 0xFA53, 0xFA54, 0xFA55, 0xFA56, 0xFA57, 0xFA58, 0xFA59,
0xFA5A, 0xFA5B, 0xFA5C, 0xFA5D, 0xFA5E, 0xFA5F, 0xFA60, 0xFA61,
0xFA62, 0xFA63, 0xFA64, 0xFA65, 0xFA66, 0xFA67, 0xFA68, 0xFA69,
0xFA6A, 0xFA6B, 0xFA6C, 0xFA6D, 0xFA6E, 0xFA6F, 0xFA70, 0xFA71,
0xFA72, 0xFA73, 0xFA74, 0xFA75, 0xFA76, 0xFA77, 0xFA78, 0xFA79,
0xFA7A, 0xFA7B, 0xFA7C, 0xFA7D, 0xFA7E, 0xFA80, 0xFA81, 0xFA82,
0xFA83, 0xFA84, 0xFA85, 0xFA86, 0xFA87, 0xFA88, 0xFA89, 0xFA8A,
0xFA8B, 0xFA8C, 0xFA8D, 0xFA8E, 0xFA8F, 0xFA90, 0xFA91, 0xFA92,
0xFA93, 0xFA94, 0xFA95, 0xFA96, 0xFA97, 0xFA98, 0xFA99, 0xFA9A,
0xFA9B, 0xFA9C, 0xFA9D, 0xFA9E, 0xFA9F, 0xFAA0, 0xFB40, 0xFB41,
0xFB42, 0xFB43, 0xFB44, 0xFB45, 0xFB46, 0xFB47, 0xFB48, 0xFB49,
0xFB4A, 0xFB4B, 0xFB4C, 0xFB4D, 0xFB4E, 0xFB4F, 0xFB50, 0xFB51,
0xFB52, 0xFB53, 0xFB54, 0xFB55, 0xFB56, 0xFB57, 0xFB58, 0xFB59,
0xFB5A, 0xFB5B, 0xFB5C, 0xFB5D, 0xFB5E, 0xFB5F, 0xFB60, 0xFB61,
0xFB62, 0xFB63, 0xFB64, 0xFB65, 0xFB66, 0xFB67, 0xFB68, 0xFB69,
0xFB6A, 0xFB6B, 0xFB6C, 0xFB6D, 0xFB6E, 0xFB6F, 0xFB70, 0xFB71,
0xFB72, 0xFB73, 0xFB74, 0xFB75, 0xFB76, 0xFB77, 0xFB78, 0xFB79,
0xFB7A, 0xFB7B, 0xFB7C, 0xFB7D, 0xFB7E, 0xFB80, 0xFB81, 0xFB82,
0xFB83, 0xFB84, 0xFB85, 0xFB86, 0xFB87, 0xFB88, 0xFB89, 0xFB8A,
0xFB8B, 0xFB8C, 0xFB8D, 0xFB8E, 0xFB8F, 0xFB90, 0xFB91, 0xFB92,
0xFB93, 0xFB94, 0xFB95, 0xFB96, 0xFB97, 0xFB98, 0xFB99, 0xFB9A,
0xFB9B, 0xFB9C, 0xFB9D, 0xFB9E, 0xFB9F, 0xFBA0, 0xFC40, 0xFC41,
0xFC42, 0xFC43, 0xFC44, 0xFC45, 0xFC46, 0xFC47, 0xFC48, 0xFC49,
0xFC4A, 0xFC4B, 0xFC4C, 0xFC4D, 0xFC4E, 0xFC4F, 0xFC50, 0xFC51,
0xFC52, 0xFC53, 0xFC54, 0xFC55, 0xFC56, 0xFC57, 0xFC58, 0xFC59,
0xFC5A, 0xFC5B, 0xFC5C, 0xFC5D, 0xFC5E, 0xFC5F, 0xFC60, 0xFC61,
0xFC62, 0xFC63, 0xFC64, 0xFC65, 0xFC66, 0xFC67, 0xFC68, 0xFC69,
0xFC6A, 0xFC6B, 0xFC6C, 0xFC6D, 0xFC6E, 0xFC6F, 0xFC70, 0xFC71,
0xFC72, 0xFC73, 0xFC74, 0xFC75, 0xFC76, 0xFC77, 0xFC78, 0xFC79,
0xFC7A, 0xFC7B, 0xFC7C, 0xFC7D, 0xFC7E, 0xFC80, 0xFC81, 0xFC82,
0xFC83, 0xFC84, 0xFC85, 0xFC86, 0xFC87, 0xFC88, 0xFC89, 0xFC8A,
0xFC8B, 0xFC8C, 0xFC8D, 0xFC8E, 0xFC8F, 0xFC90, 0xFC91, 0xFC92,
0xFC93, 0xFC94, 0xFC95, 0xFC96, 0xFC97, 0xFC98, 0xFC99, 0xFC9A,
0xFC9B, 0xFC9C, 0xFC9D, 0xFC9E, 0xFC9F, 0xFCA0, 0xFD40, 0xFD41,
0xFD42, 0xFD43, 0xFD44, 0xFD45, 0xFD46, 0xFD47, 0xFD48, 0xFD49,
0xFD4A, 0xFD4B, 0xFD4C, 0xFD4D, 0xFD4E, 0xFD4F, 0xFD50, 0xFD51,
0xFD52, 0xFD53, 0xFD54, 0xFD55, 0xFD56, 0xFD57, 0xFD58, 0xFD59,
0xFD5A, 0xFD5B, 0xFD5C, 0xFD5D, 0xFD5E, 0xFD5F, 0xFD60, 0xFD61,
0xFD62, 0xFD63, 0xFD64, 0xFD65, 0xFD66, 0xFD67, 0xFD68, 0xFD69,
0xFD6A, 0xFD6B, 0xFD6C, 0xFD6D, 0xFD6E, 0xFD6F, 0xFD70, 0xFD71,
0xFD72, 0xFD73, 0xFD74, 0xFD75, 0xFD76, 0xFD77, 0xFD78, 0xFD79,
0xFD7A, 0xFD7B, 0xFD7C, 0xFD7D, 0xFD7E, 0xFD80, 0xFD81, 0xFD82,
0xFD83, 0xFD84, 0xFD85, 0xFD86, 0xFD87, 0xFD88, 0xFD89, 0xFD8A,
0xFD8B, 0xFD8C, 0xFD8D, 0xFD8E, 0xFD8F, 0xFD90, 0xFD91, 0xFD92,
0xFD93, 0xFD94, 0xFD95, 0xFD96, 0xFD97, 0xFD98, 0xFD99, 0xFD9A,
0xFD9B, 0xFD9C, 0xFD9D, 0xFD9E, 0xFD9F, 0xFDA0, 0xFE40, 0xFE41,
0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46, 0xFE47, 0xFE48, 0xFE49,
0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F, 0xA955, 0xA6F2,
0xA6F4, 0xA6F5, 0xA6E0, 0xA6E1, 0xA6F0, 0xA6F1, 0xA6E2, 0xA6E3,
0xA6EE, 0xA6EF, 0xA6E6, 0xA6E7, 0xA6E4, 0xA6E5, 0xA6E8, 0xA6E9,
0xA6EA, 0xA6EB, 0xA968, 0xA969, 0xA96A, 0xA96B, 0xA96C, 0xA96D,
0xA96E, 0xA96F, 0xA970, 0xA971, 0xA972, 0xA973, 0xA974, 0xA975,
0xA976, 0xA977, 0xA978, 0xA979, 0xA97A, 0xA97B, 0xA97C, 0xA97D,
0xA97E, 0xA980, 0xA981, 0xA982, 0xA983, 0xA984, 0xA985, 0xA986,
0xA987, 0xA988, 0xA956, 0xA957,
};
#endif /* ZUECI_EMBED_NO_TO_ECI */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Unicode values in multibyte order */
static const zueci_u16 zueci_gbk_mb_u[14352] = {
0x4E02, 0x4E04, 0x4E05, 0x4E06, 0x4E0F, 0x4E12, 0x4E17, 0x4E1F,
0x4E20, 0x4E21, 0x4E23, 0x4E26, 0x4E29, 0x4E2E, 0x4E2F, 0x4E31,
0x4E33, 0x4E35, 0x4E37, 0x4E3C, 0x4E40, 0x4E41, 0x4E42, 0x4E44,
0x4E46, 0x4E4A, 0x4E51, 0x4E55, 0x4E57, 0x4E5A, 0x4E5B, 0x4E62,
0x4E63, 0x4E64, 0x4E65, 0x4E67, 0x4E68, 0x4E6A, 0x4E6B, 0x4E6C,
0x4E6D, 0x4E6E, 0x4E6F, 0x4E72, 0x4E74, 0x4E75, 0x4E76, 0x4E77,
0x4E78, 0x4E79, 0x4E7A, 0x4E7B, 0x4E7C, 0x4E7D, 0x4E7F, 0x4E80,
0x4E81, 0x4E82, 0x4E83, 0x4E84, 0x4E85, 0x4E87, 0x4E8A, 0x4E90,
0x4E96, 0x4E97, 0x4E99, 0x4E9C, 0x4E9D, 0x4E9E, 0x4EA3, 0x4EAA,
0x4EAF, 0x4EB0, 0x4EB1, 0x4EB4, 0x4EB6, 0x4EB7, 0x4EB8, 0x4EB9,
0x4EBC, 0x4EBD, 0x4EBE, 0x4EC8, 0x4ECC, 0x4ECF, 0x4ED0, 0x4ED2,
0x4EDA, 0x4EDB, 0x4EDC, 0x4EE0, 0x4EE2, 0x4EE6, 0x4EE7, 0x4EE9,
0x4EED, 0x4EEE, 0x4EEF, 0x4EF1, 0x4EF4, 0x4EF8, 0x4EF9, 0x4EFA,
0x4EFC, 0x4EFE, 0x4F00, 0x4F02, 0x4F03, 0x4F04, 0x4F05, 0x4F06,
0x4F07, 0x4F08, 0x4F0B, 0x4F0C, 0x4F12, 0x4F13, 0x4F14, 0x4F15,
0x4F16, 0x4F1C, 0x4F1D, 0x4F21, 0x4F23, 0x4F28, 0x4F29, 0x4F2C,
0x4F2D, 0x4F2E, 0x4F31, 0x4F33, 0x4F35, 0x4F37, 0x4F39, 0x4F3B,
0x4F3E, 0x4F3F, 0x4F40, 0x4F41, 0x4F42, 0x4F44, 0x4F45, 0x4F47,
0x4F48, 0x4F49, 0x4F4A, 0x4F4B, 0x4F4C, 0x4F52, 0x4F54, 0x4F56,
0x4F61, 0x4F62, 0x4F66, 0x4F68, 0x4F6A, 0x4F6B, 0x4F6D, 0x4F6E,
0x4F71, 0x4F72, 0x4F75, 0x4F77, 0x4F78, 0x4F79, 0x4F7A, 0x4F7D,
0x4F80, 0x4F81, 0x4F82, 0x4F85, 0x4F86, 0x4F87, 0x4F8A, 0x4F8C,
0x4F8E, 0x4F90, 0x4F92, 0x4F93, 0x4F95, 0x4F96, 0x4F98, 0x4F99,
0x4F9A, 0x4F9C, 0x4F9E, 0x4F9F, 0x4FA1, 0x4FA2, 0x4FA4, 0x4FAB,
0x4FAD, 0x4FB0, 0x4FB1, 0x4FB2, 0x4FB3, 0x4FB4, 0x4FB6, 0x4FB7,
0x4FB8, 0x4FB9, 0x4FBA, 0x4FBB, 0x4FBC, 0x4FBD, 0x4FBE, 0x4FC0,
0x4FC1, 0x4FC2, 0x4FC6, 0x4FC7, 0x4FC8, 0x4FC9, 0x4FCB, 0x4FCC,
0x4FCD, 0x4FD2, 0x4FD3, 0x4FD4, 0x4FD5, 0x4FD6, 0x4FD9, 0x4FDB,
0x4FE0, 0x4FE2, 0x4FE4, 0x4FE5, 0x4FE7, 0x4FEB, 0x4FEC, 0x4FF0,
0x4FF2, 0x4FF4, 0x4FF5, 0x4FF6, 0x4FF7, 0x4FF9, 0x4FFB, 0x4FFC,
0x4FFD, 0x4FFF, 0x5000, 0x5001, 0x5002, 0x5003, 0x5004, 0x5005,
0x5006, 0x5007, 0x5008, 0x5009, 0x500A, 0x500B, 0x500E, 0x5010,
0x5011, 0x5013, 0x5015, 0x5016, 0x5017, 0x501B, 0x501D, 0x501E,
0x5020, 0x5022, 0x5023, 0x5024, 0x5027, 0x502B, 0x502F, 0x5030,
0x5031, 0x5032, 0x5033, 0x5034, 0x5035, 0x5036, 0x5037, 0x5038,
0x5039, 0x503B, 0x503D, 0x503F, 0x5040, 0x5041, 0x5042, 0x5044,
0x5045, 0x5046, 0x5049, 0x504A, 0x504B, 0x504D, 0x5050, 0x5051,
0x5052, 0x5053, 0x5054, 0x5056, 0x5057, 0x5058, 0x5059, 0x505B,
0x505D, 0x505E, 0x505F, 0x5060, 0x5061, 0x5062, 0x5063, 0x5064,
0x5066, 0x5067, 0x5068, 0x5069, 0x506A, 0x506B, 0x506D, 0x506E,
0x506F, 0x5070, 0x5071, 0x5072, 0x5073, 0x5074, 0x5075, 0x5078,
0x5079, 0x507A, 0x507C, 0x507D, 0x5081, 0x5082, 0x5083, 0x5084,
0x5086, 0x5087, 0x5089, 0x508A, 0x508B, 0x508C, 0x508E, 0x508F,
0x5090, 0x5091, 0x5092, 0x5093, 0x5094, 0x5095, 0x5096, 0x5097,
0x5098, 0x5099, 0x509A, 0x509B, 0x509C, 0x509D, 0x509E, 0x509F,
0x50A0, 0x50A1, 0x50A2, 0x50A4, 0x50A6, 0x50AA, 0x50AB, 0x50AD,
0x50AE, 0x50AF, 0x50B0, 0x50B1, 0x50B3, 0x50B4, 0x50B5, 0x50B6,
0x50B7, 0x50B8, 0x50B9, 0x50BC, 0x50BD, 0x50BE, 0x50BF, 0x50C0,
0x50C1, 0x50C2, 0x50C3, 0x50C4, 0x50C5, 0x50C6, 0x50C7, 0x50C8,
0x50C9, 0x50CA, 0x50CB, 0x50CC, 0x50CD, 0x50CE, 0x50D0, 0x50D1,
0x50D2, 0x50D3, 0x50D4, 0x50D5, 0x50D7, 0x50D8, 0x50D9, 0x50DB,
0x50DC, 0x50DD, 0x50DE, 0x50DF, 0x50E0, 0x50E1, 0x50E2, 0x50E3,
0x50E4, 0x50E5, 0x50E8, 0x50E9, 0x50EA, 0x50EB, 0x50EF, 0x50F0,
0x50F1, 0x50F2, 0x50F4, 0x50F6, 0x50F7, 0x50F8, 0x50F9, 0x50FA,
0x50FC, 0x50FD, 0x50FE, 0x50FF, 0x5100, 0x5101, 0x5102, 0x5103,
0x5104, 0x5105, 0x5108, 0x5109, 0x510A, 0x510C, 0x510D, 0x510E,
0x510F, 0x5110, 0x5111, 0x5113, 0x5114, 0x5115, 0x5116, 0x5117,
0x5118, 0x5119, 0x511A, 0x511B, 0x511C, 0x511D, 0x511E, 0x511F,
0x5120, 0x5122, 0x5123, 0x5124, 0x5125, 0x5126, 0x5127, 0x5128,
0x5129, 0x512A, 0x512B, 0x512C, 0x512D, 0x512E, 0x512F, 0x5130,
0x5131, 0x5132, 0x5133, 0x5134, 0x5135, 0x5136, 0x5137, 0x5138,
0x5139, 0x513A, 0x513B, 0x513C, 0x513D, 0x513E, 0x5142, 0x5147,
0x514A, 0x514C, 0x514E, 0x514F, 0x5150, 0x5152, 0x5153, 0x5157,
0x5158, 0x5159, 0x515B, 0x515D, 0x515E, 0x515F, 0x5160, 0x5161,
0x5163, 0x5164, 0x5166, 0x5167, 0x5169, 0x516A, 0x516F, 0x5172,
0x517A, 0x517E, 0x517F, 0x5183, 0x5184, 0x5186, 0x5187, 0x518A,
0x518B, 0x518E, 0x518F, 0x5190, 0x5191, 0x5193, 0x5194, 0x5198,
0x519A, 0x519D, 0x519E, 0x519F, 0x51A1, 0x51A3, 0x51A6, 0x51A7,
0x51A8, 0x51A9, 0x51AA, 0x51AD, 0x51AE, 0x51B4, 0x51B8, 0x51B9,
0x51BA, 0x51BE, 0x51BF, 0x51C1, 0x51C2, 0x51C3, 0x51C5, 0x51C8,
0x51CA, 0x51CD, 0x51CE, 0x51D0, 0x51D2, 0x51D3, 0x51D4, 0x51D5,
0x51D6, 0x51D7, 0x51D8, 0x51D9, 0x51DA, 0x51DC, 0x51DE, 0x51DF,
0x51E2, 0x51E3, 0x51E5, 0x51E6, 0x51E7, 0x51E8, 0x51E9, 0x51EA,
0x51EC, 0x51EE, 0x51F1, 0x51F2, 0x51F4, 0x51F7, 0x51FE, 0x5204,
0x5205, 0x5209, 0x520B, 0x520C, 0x520F, 0x5210, 0x5213, 0x5214,
0x5215, 0x521C, 0x521E, 0x521F, 0x5221, 0x5222, 0x5223, 0x5225,
0x5226, 0x5227, 0x522A, 0x522C, 0x522F, 0x5231, 0x5232, 0x5234,
0x5235, 0x523C, 0x523E, 0x5244, 0x5245, 0x5246, 0x5247, 0x5248,
0x5249, 0x524B, 0x524E, 0x524F, 0x5252, 0x5253, 0x5255, 0x5257,
0x5258, 0x5259, 0x525A, 0x525B, 0x525D, 0x525F, 0x5260, 0x5262,
0x5263, 0x5264, 0x5266, 0x5268, 0x526B, 0x526C, 0x526D, 0x526E,
0x5270, 0x5271, 0x5273, 0x5274, 0x5275, 0x5276, 0x5277, 0x5278,
0x5279, 0x527A, 0x527B, 0x527C, 0x527E, 0x5280, 0x5283, 0x5284,
0x5285, 0x5286, 0x5287, 0x5289, 0x528A, 0x528B, 0x528C, 0x528D,
0x528E, 0x528F, 0x5291, 0x5292, 0x5294, 0x5295, 0x5296, 0x5297,
0x5298, 0x5299, 0x529A, 0x529C, 0x52A4, 0x52A5, 0x52A6, 0x52A7,
0x52AE, 0x52AF, 0x52B0, 0x52B4, 0x52B5, 0x52B6, 0x52B7, 0x52B8,
0x52B9, 0x52BA, 0x52BB, 0x52BC, 0x52BD, 0x52C0, 0x52C1, 0x52C2,
0x52C4, 0x52C5, 0x52C6, 0x52C8, 0x52CA, 0x52CC, 0x52CD, 0x52CE,
0x52CF, 0x52D1, 0x52D3, 0x52D4, 0x52D5, 0x52D7, 0x52D9, 0x52DA,
0x52DB, 0x52DC, 0x52DD, 0x52DE, 0x52E0, 0x52E1, 0x52E2, 0x52E3,
0x52E5, 0x52E6, 0x52E7, 0x52E8, 0x52E9, 0x52EA, 0x52EB, 0x52EC,
0x52ED, 0x52EE, 0x52EF, 0x52F1, 0x52F2, 0x52F3, 0x52F4, 0x52F5,
0x52F6, 0x52F7, 0x52F8, 0x52FB, 0x52FC, 0x52FD, 0x5301, 0x5302,
0x5303, 0x5304, 0x5307, 0x5309, 0x530A, 0x530B, 0x530C, 0x530E,
0x5311, 0x5312, 0x5313, 0x5314, 0x5318, 0x531B, 0x531C, 0x531E,
0x531F, 0x5322, 0x5324, 0x5325, 0x5327, 0x5328, 0x5329, 0x532B,
0x532C, 0x532D, 0x532F, 0x5330, 0x5331, 0x5332, 0x5333, 0x5334,
0x5335, 0x5336, 0x5337, 0x5338, 0x533C, 0x533D, 0x5340, 0x5342,
0x5344, 0x5346, 0x534B, 0x534C, 0x534D, 0x5350, 0x5354, 0x5358,
0x5359, 0x535B, 0x535D, 0x5365, 0x5368, 0x536A, 0x536C, 0x536D,
0x5372, 0x5376, 0x5379, 0x537B, 0x537C, 0x537D, 0x537E, 0x5380,
0x5381, 0x5383, 0x5387, 0x5388, 0x538A, 0x538E, 0x538F, 0x5390,
0x5391, 0x5392, 0x5393, 0x5394, 0x5396, 0x5397, 0x5399, 0x539B,
0x539C, 0x539E, 0x53A0, 0x53A1, 0x53A4, 0x53A7, 0x53AA, 0x53AB,
0x53AC, 0x53AD, 0x53AF, 0x53B0, 0x53B1, 0x53B2, 0x53B3, 0x53B4,
0x53B5, 0x53B7, 0x53B8, 0x53B9, 0x53BA, 0x53BC, 0x53BD, 0x53BE,
0x53C0, 0x53C3, 0x53C4, 0x53C5, 0x53C6, 0x53C7, 0x53CE, 0x53CF,
0x53D0, 0x53D2, 0x53D3, 0x53D5, 0x53DA, 0x53DC, 0x53DD, 0x53DE,
0x53E1, 0x53E2, 0x53E7, 0x53F4, 0x53FA, 0x53FE, 0x53FF, 0x5400,
0x5402, 0x5405, 0x5407, 0x540B, 0x5414, 0x5418, 0x5419, 0x541A,
0x541C, 0x5422, 0x5424, 0x5425, 0x542A, 0x5430, 0x5433, 0x5436,
0x5437, 0x543A, 0x543D, 0x543F, 0x5441, 0x5442, 0x5444, 0x5445,
0x5447, 0x5449, 0x544C, 0x544D, 0x544E, 0x544F, 0x5451, 0x545A,
0x545D, 0x545E, 0x545F, 0x5460, 0x5461, 0x5463, 0x5465, 0x5467,
0x5469, 0x546A, 0x546B, 0x546C, 0x546D, 0x546E, 0x546F, 0x5470,
0x5474, 0x5479, 0x547A, 0x547E, 0x547F, 0x5481, 0x5483, 0x5485,
0x5487, 0x5488, 0x5489, 0x548A, 0x548D, 0x5491, 0x5493, 0x5497,
0x5498, 0x549C, 0x549E, 0x549F, 0x54A0, 0x54A1, 0x54A2, 0x54A5,
0x54AE, 0x54B0, 0x54B2, 0x54B5, 0x54B6, 0x54B7, 0x54B9, 0x54BA,
0x54BC, 0x54BE, 0x54C3, 0x54C5, 0x54CA, 0x54CB, 0x54D6, 0x54D8,
0x54DB, 0x54E0, 0x54E1, 0x54E2, 0x54E3, 0x54E4, 0x54EB, 0x54EC,
0x54EF, 0x54F0, 0x54F1, 0x54F4, 0x54F5, 0x54F6, 0x54F7, 0x54F8,
0x54F9, 0x54FB, 0x54FE, 0x5500, 0x5502, 0x5503, 0x5504, 0x5505,
0x5508, 0x550A, 0x550B, 0x550C, 0x550D, 0x550E, 0x5512, 0x5513,
0x5515, 0x5516, 0x5517, 0x5518, 0x5519, 0x551A, 0x551C, 0x551D,
0x551E, 0x551F, 0x5521, 0x5525, 0x5526, 0x5528, 0x5529, 0x552B,
0x552D, 0x5532, 0x5534, 0x5535, 0x5536, 0x5538, 0x5539, 0x553A,
0x553B, 0x553D, 0x5540, 0x5542, 0x5545, 0x5547, 0x5548, 0x554B,
0x554C, 0x554D, 0x554E, 0x554F, 0x5551, 0x5552, 0x5553, 0x5554,
0x5557, 0x5558, 0x5559, 0x555A, 0x555B, 0x555D, 0x555E, 0x555F,
0x5560, 0x5562, 0x5563, 0x5568, 0x5569, 0x556B, 0x556F, 0x5570,
0x5571, 0x5572, 0x5573, 0x5574, 0x5579, 0x557A, 0x557D, 0x557F,
0x5585, 0x5586, 0x558C, 0x558D, 0x558E, 0x5590, 0x5592, 0x5593,
0x5595, 0x5596, 0x5597, 0x559A, 0x559B, 0x559E, 0x55A0, 0x55A1,
0x55A2, 0x55A3, 0x55A4, 0x55A5, 0x55A6, 0x55A8, 0x55A9, 0x55AA,
0x55AB, 0x55AC, 0x55AD, 0x55AE, 0x55AF, 0x55B0, 0x55B2, 0x55B4,
0x55B6, 0x55B8, 0x55BA, 0x55BC, 0x55BF, 0x55C0, 0x55C1, 0x55C2,
0x55C3, 0x55C6, 0x55C7, 0x55C8, 0x55CA, 0x55CB, 0x55CE, 0x55CF,
0x55D0, 0x55D5, 0x55D7, 0x55D8, 0x55D9, 0x55DA, 0x55DB, 0x55DE,
0x55E0, 0x55E2, 0x55E7, 0x55E9, 0x55ED, 0x55EE, 0x55F0, 0x55F1,
0x55F4, 0x55F6, 0x55F8, 0x55F9, 0x55FA, 0x55FB, 0x55FC, 0x55FF,
0x5602, 0x5603, 0x5604, 0x5605, 0x5606, 0x5607, 0x560A, 0x560B,
0x560D, 0x5610, 0x5611, 0x5612, 0x5613, 0x5614, 0x5615, 0x5616,
0x5617, 0x5619, 0x561A, 0x561C, 0x561D, 0x5620, 0x5621, 0x5622,
0x5625, 0x5626, 0x5628, 0x5629, 0x562A, 0x562B, 0x562E, 0x562F,
0x5630, 0x5633, 0x5635, 0x5637, 0x5638, 0x563A, 0x563C, 0x563D,
0x563E, 0x5640, 0x5641, 0x5642, 0x5643, 0x5644, 0x5645, 0x5646,
0x5647, 0x5648, 0x5649, 0x564A, 0x564B, 0x564F, 0x5650, 0x5651,
0x5652, 0x5653, 0x5655, 0x5656, 0x565A, 0x565B, 0x565D, 0x565E,
0x565F, 0x5660, 0x5661, 0x5663, 0x5665, 0x5666, 0x5667, 0x566D,
0x566E, 0x566F, 0x5670, 0x5672, 0x5673, 0x5674, 0x5675, 0x5677,
0x5678, 0x5679, 0x567A, 0x567D, 0x567E, 0x567F, 0x5680, 0x5681,
0x5682, 0x5683, 0x5684, 0x5687, 0x5688, 0x5689, 0x568A, 0x568B,
0x568C, 0x568D, 0x5690, 0x5691, 0x5692, 0x5694, 0x5695, 0x5696,
0x5697, 0x5698, 0x5699, 0x569A, 0x569B, 0x569C, 0x569D, 0x569E,
0x569F, 0x56A0, 0x56A1, 0x56A2, 0x56A4, 0x56A5, 0x56A6, 0x56A7,
0x56A8, 0x56A9, 0x56AA, 0x56AB, 0x56AC, 0x56AD, 0x56AE, 0x56B0,
0x56B1, 0x56B2, 0x56B3, 0x56B4, 0x56B5, 0x56B6, 0x56B8, 0x56B9,
0x56BA, 0x56BB, 0x56BD, 0x56BE, 0x56BF, 0x56C0, 0x56C1, 0x56C2,
0x56C3, 0x56C4, 0x56C5, 0x56C6, 0x56C7, 0x56C8, 0x56C9, 0x56CB,
0x56CC, 0x56CD, 0x56CE, 0x56CF, 0x56D0, 0x56D1, 0x56D2, 0x56D3,
0x56D5, 0x56D6, 0x56D8, 0x56D9, 0x56DC, 0x56E3, 0x56E5, 0x56E6,
0x56E7, 0x56E8, 0x56E9, 0x56EA, 0x56EC, 0x56EE, 0x56EF, 0x56F2,
0x56F3, 0x56F6, 0x56F7, 0x56F8, 0x56FB, 0x56FC, 0x5700, 0x5701,
0x5702, 0x5705, 0x5707, 0x570B, 0x570C, 0x570D, 0x570E, 0x570F,
0x5710, 0x5711, 0x5712, 0x5713, 0x5714, 0x5715, 0x5716, 0x5717,
0x5718, 0x5719, 0x571A, 0x571B, 0x571D, 0x571E, 0x5720, 0x5721,
0x5722, 0x5724, 0x5725, 0x5726, 0x5727, 0x572B, 0x5731, 0x5732,
0x5734, 0x5735, 0x5736, 0x5737, 0x5738, 0x573C, 0x573D, 0x573F,
0x5741, 0x5743, 0x5744, 0x5745, 0x5746, 0x5748, 0x5749, 0x574B,
0x5752, 0x5753, 0x5754, 0x5755, 0x5756, 0x5758, 0x5759, 0x5762,
0x5763, 0x5765, 0x5767, 0x576C, 0x576E, 0x5770, 0x5771, 0x5772,
0x5774, 0x5775, 0x5778, 0x5779, 0x577A, 0x577D, 0x577E, 0x577F,
0x5780, 0x5781, 0x5787, 0x5788, 0x5789, 0x578A, 0x578D, 0x578E,
0x578F, 0x5790, 0x5791, 0x5794, 0x5795, 0x5796, 0x5797, 0x5798,
0x5799, 0x579A, 0x579C, 0x579D, 0x579E, 0x579F, 0x57A5, 0x57A8,
0x57AA, 0x57AC, 0x57AF, 0x57B0, 0x57B1, 0x57B3, 0x57B5, 0x57B6,
0x57B7, 0x57B9, 0x57BA, 0x57BB, 0x57BC, 0x57BD, 0x57BE, 0x57BF,
0x57C0, 0x57C1, 0x57C4, 0x57C5, 0x57C6, 0x57C7, 0x57C8, 0x57C9,
0x57CA, 0x57CC, 0x57CD, 0x57D0, 0x57D1, 0x57D3, 0x57D6, 0x57D7,
0x57DB, 0x57DC, 0x57DE, 0x57E1, 0x57E2, 0x57E3, 0x57E5, 0x57E6,
0x57E7, 0x57E8, 0x57E9, 0x57EA, 0x57EB, 0x57EC, 0x57EE, 0x57F0,
0x57F1, 0x57F2, 0x57F3, 0x57F5, 0x57F6, 0x57F7, 0x57FB, 0x57FC,
0x57FE, 0x57FF, 0x5801, 0x5803, 0x5804, 0x5805, 0x5808, 0x5809,
0x580A, 0x580C, 0x580E, 0x580F, 0x5810, 0x5812, 0x5813, 0x5814,
0x5816, 0x5817, 0x5818, 0x581A, 0x581B, 0x581C, 0x581D, 0x581F,
0x5822, 0x5823, 0x5825, 0x5826, 0x5827, 0x5828, 0x5829, 0x582B,
0x582C, 0x582D, 0x582E, 0x582F, 0x5831, 0x5832, 0x5833, 0x5834,
0x5836, 0x5837, 0x5838, 0x5839, 0x583A, 0x583B, 0x583C, 0x583D,
0x583E, 0x583F, 0x5840, 0x5841, 0x5842, 0x5843, 0x5845, 0x5846,
0x5847, 0x5848, 0x5849, 0x584A, 0x584B, 0x584E, 0x584F, 0x5850,
0x5852, 0x5853, 0x5855, 0x5856, 0x5857, 0x5859, 0x585A, 0x585B,
0x585C, 0x585D, 0x585F, 0x5860, 0x5861, 0x5862, 0x5863, 0x5864,
0x5866, 0x5867, 0x5868, 0x5869, 0x586A, 0x586D, 0x586E, 0x586F,
0x5870, 0x5871, 0x5872, 0x5873, 0x5874, 0x5875, 0x5876, 0x5877,
0x5878, 0x5879, 0x587A, 0x587B, 0x587C, 0x587D, 0x587F, 0x5882,
0x5884, 0x5886, 0x5887, 0x5888, 0x588A, 0x588B, 0x588C, 0x588D,
0x588E, 0x588F, 0x5890, 0x5891, 0x5894, 0x5895, 0x5896, 0x5897,
0x5898, 0x589B, 0x589C, 0x589D, 0x58A0, 0x58A1, 0x58A2, 0x58A3,
0x58A4, 0x58A5, 0x58A6, 0x58A7, 0x58AA, 0x58AB, 0x58AC, 0x58AD,
0x58AE, 0x58AF, 0x58B0, 0x58B1, 0x58B2, 0x58B3, 0x58B4, 0x58B5,
0x58B6, 0x58B7, 0x58B8, 0x58B9, 0x58BA, 0x58BB, 0x58BD, 0x58BE,
0x58BF, 0x58C0, 0x58C2, 0x58C3, 0x58C4, 0x58C6, 0x58C7, 0x58C8,
0x58C9, 0x58CA, 0x58CB, 0x58CC, 0x58CD, 0x58CE, 0x58CF, 0x58D0,
0x58D2, 0x58D3, 0x58D4, 0x58D6, 0x58D7, 0x58D8, 0x58D9, 0x58DA,
0x58DB, 0x58DC, 0x58DD, 0x58DE, 0x58DF, 0x58E0, 0x58E1, 0x58E2,
0x58E3, 0x58E5, 0x58E6, 0x58E7, 0x58E8, 0x58E9, 0x58EA, 0x58ED,
0x58EF, 0x58F1, 0x58F2, 0x58F4, 0x58F5, 0x58F7, 0x58F8, 0x58FA,
0x58FB, 0x58FC, 0x58FD, 0x58FE, 0x58FF, 0x5900, 0x5901, 0x5903,
0x5905, 0x5906, 0x5908, 0x5909, 0x590A, 0x590B, 0x590C, 0x590E,
0x5910, 0x5911, 0x5912, 0x5913, 0x5917, 0x5918, 0x591B, 0x591D,
0x591E, 0x5920, 0x5921, 0x5922, 0x5923, 0x5926, 0x5928, 0x592C,
0x5930, 0x5932, 0x5933, 0x5935, 0x5936, 0x593B, 0x593D, 0x593E,
0x593F, 0x5940, 0x5943, 0x5945, 0x5946, 0x594A, 0x594C, 0x594D,
0x5950, 0x5952, 0x5953, 0x5959, 0x595B, 0x595C, 0x595D, 0x595E,
0x595F, 0x5961, 0x5963, 0x5964, 0x5966, 0x5967, 0x5968, 0x5969,
0x596A, 0x596B, 0x596C, 0x596D, 0x596E, 0x596F, 0x5970, 0x5971,
0x5972, 0x5975, 0x5977, 0x597A, 0x597B, 0x597C, 0x597E, 0x597F,
0x5980, 0x5985, 0x5989, 0x598B, 0x598C, 0x598E, 0x598F, 0x5990,
0x5991, 0x5994, 0x5995, 0x5998, 0x599A, 0x599B, 0x599C, 0x599D,
0x599F, 0x59A0, 0x59A1, 0x59A2, 0x59A6, 0x59A7, 0x59AC, 0x59AD,
0x59B0, 0x59B1, 0x59B3, 0x59B4, 0x59B5, 0x59B6, 0x59B7, 0x59B8,
0x59BA, 0x59BC, 0x59BD, 0x59BF, 0x59C0, 0x59C1, 0x59C2, 0x59C3,
0x59C4, 0x59C5, 0x59C7, 0x59C8, 0x59C9, 0x59CC, 0x59CD, 0x59CE,
0x59CF, 0x59D5, 0x59D6, 0x59D9, 0x59DB, 0x59DE, 0x59DF, 0x59E0,
0x59E1, 0x59E2, 0x59E4, 0x59E6, 0x59E7, 0x59E9, 0x59EA, 0x59EB,
0x59ED, 0x59EE, 0x59EF, 0x59F0, 0x59F1, 0x59F2, 0x59F3, 0x59F4,
0x59F5, 0x59F6, 0x59F7, 0x59F8, 0x59FA, 0x59FC, 0x59FD, 0x59FE,
0x5A00, 0x5A02, 0x5A0A, 0x5A0B, 0x5A0D, 0x5A0E, 0x5A0F, 0x5A10,
0x5A12, 0x5A14, 0x5A15, 0x5A16, 0x5A17, 0x5A19, 0x5A1A, 0x5A1B,
0x5A1D, 0x5A1E, 0x5A21, 0x5A22, 0x5A24, 0x5A26, 0x5A27, 0x5A28,
0x5A2A, 0x5A2B, 0x5A2C, 0x5A2D, 0x5A2E, 0x5A2F, 0x5A30, 0x5A33,
0x5A35, 0x5A37, 0x5A38, 0x5A39, 0x5A3A, 0x5A3B, 0x5A3D, 0x5A3E,
0x5A3F, 0x5A41, 0x5A42, 0x5A43, 0x5A44, 0x5A45, 0x5A47, 0x5A48,
0x5A4B, 0x5A4C, 0x5A4D, 0x5A4E, 0x5A4F, 0x5A50, 0x5A51, 0x5A52,
0x5A53, 0x5A54, 0x5A56, 0x5A57, 0x5A58, 0x5A59, 0x5A5B, 0x5A5C,
0x5A5D, 0x5A5E, 0x5A5F, 0x5A60, 0x5A61, 0x5A63, 0x5A64, 0x5A65,
0x5A66, 0x5A68, 0x5A69, 0x5A6B, 0x5A6C, 0x5A6D, 0x5A6E, 0x5A6F,
0x5A70, 0x5A71, 0x5A72, 0x5A73, 0x5A78, 0x5A79, 0x5A7B, 0x5A7C,
0x5A7D, 0x5A7E, 0x5A80, 0x5A81, 0x5A82, 0x5A83, 0x5A84, 0x5A85,
0x5A86, 0x5A87, 0x5A88, 0x5A89, 0x5A8A, 0x5A8B, 0x5A8C, 0x5A8D,
0x5A8E, 0x5A8F, 0x5A90, 0x5A91, 0x5A93, 0x5A94, 0x5A95, 0x5A96,
0x5A97, 0x5A98, 0x5A99, 0x5A9C, 0x5A9D, 0x5A9E, 0x5A9F, 0x5AA0,
0x5AA1, 0x5AA2, 0x5AA3, 0x5AA4, 0x5AA5, 0x5AA6, 0x5AA7, 0x5AA8,
0x5AA9, 0x5AAB, 0x5AAC, 0x5AAD, 0x5AAE, 0x5AAF, 0x5AB0, 0x5AB1,
0x5AB4, 0x5AB6, 0x5AB7, 0x5AB9, 0x5ABA, 0x5ABB, 0x5ABC, 0x5ABD,
0x5ABF, 0x5AC0, 0x5AC3, 0x5AC4, 0x5AC5, 0x5AC6, 0x5AC7, 0x5AC8,
0x5ACA, 0x5ACB, 0x5ACD, 0x5ACE, 0x5ACF, 0x5AD0, 0x5AD1, 0x5AD3,
0x5AD5, 0x5AD7, 0x5AD9, 0x5ADA, 0x5ADB, 0x5ADD, 0x5ADE, 0x5ADF,
0x5AE2, 0x5AE4, 0x5AE5, 0x5AE7, 0x5AE8, 0x5AEA, 0x5AEC, 0x5AED,
0x5AEE, 0x5AEF, 0x5AF0, 0x5AF2, 0x5AF3, 0x5AF4, 0x5AF5, 0x5AF6,
0x5AF7, 0x5AF8, 0x5AF9, 0x5AFA, 0x5AFB, 0x5AFC, 0x5AFD, 0x5AFE,
0x5AFF, 0x5B00, 0x5B01, 0x5B02, 0x5B03, 0x5B04, 0x5B05, 0x5B06,
0x5B07, 0x5B08, 0x5B0A, 0x5B0B, 0x5B0C, 0x5B0D, 0x5B0E, 0x5B0F,
0x5B10, 0x5B11, 0x5B12, 0x5B13, 0x5B14, 0x5B15, 0x5B18, 0x5B19,
0x5B1A, 0x5B1B, 0x5B1C, 0x5B1D, 0x5B1E, 0x5B1F, 0x5B20, 0x5B21,
0x5B22, 0x5B23, 0x5B24, 0x5B25, 0x5B26, 0x5B27, 0x5B28, 0x5B29,
0x5B2A, 0x5B2B, 0x5B2C, 0x5B2D, 0x5B2E, 0x5B2F, 0x5B30, 0x5B31,
0x5B33, 0x5B35, 0x5B36, 0x5B38, 0x5B39, 0x5B3A, 0x5B3B, 0x5B3C,
0x5B3D, 0x5B3E, 0x5B3F, 0x5B41, 0x5B42, 0x5B43, 0x5B44, 0x5B45,
0x5B46, 0x5B47, 0x5B48, 0x5B49, 0x5B4A, 0x5B4B, 0x5B4C, 0x5B4D,
0x5B4E, 0x5B4F, 0x5B52, 0x5B56, 0x5B5E, 0x5B60, 0x5B61, 0x5B67,
0x5B68, 0x5B6B, 0x5B6D, 0x5B6E, 0x5B6F, 0x5B72, 0x5B74, 0x5B76,
0x5B77, 0x5B78, 0x5B79, 0x5B7B, 0x5B7C, 0x5B7E, 0x5B7F, 0x5B82,
0x5B86, 0x5B8A, 0x5B8D, 0x5B8E, 0x5B90, 0x5B91, 0x5B92, 0x5B94,
0x5B96, 0x5B9F, 0x5BA7, 0x5BA8, 0x5BA9, 0x5BAC, 0x5BAD, 0x5BAE,
0x5BAF, 0x5BB1, 0x5BB2, 0x5BB7, 0x5BBA, 0x5BBB, 0x5BBC, 0x5BC0,
0x5BC1, 0x5BC3, 0x5BC8, 0x5BC9, 0x5BCA, 0x5BCB, 0x5BCD, 0x5BCE,
0x5BCF, 0x5BD1, 0x5BD4, 0x5BD5, 0x5BD6, 0x5BD7, 0x5BD8, 0x5BD9,
0x5BDA, 0x5BDB, 0x5BDC, 0x5BE0, 0x5BE2, 0x5BE3, 0x5BE6, 0x5BE7,
0x5BE9, 0x5BEA, 0x5BEB, 0x5BEC, 0x5BED, 0x5BEF, 0x5BF1, 0x5BF2,
0x5BF3, 0x5BF4, 0x5BF5, 0x5BF6, 0x5BF7, 0x5BFD, 0x5BFE, 0x5C00,
0x5C02, 0x5C03, 0x5C05, 0x5C07, 0x5C08, 0x5C0B, 0x5C0C, 0x5C0D,
0x5C0E, 0x5C10, 0x5C12, 0x5C13, 0x5C17, 0x5C19, 0x5C1B, 0x5C1E,
0x5C1F, 0x5C20, 0x5C21, 0x5C23, 0x5C26, 0x5C28, 0x5C29, 0x5C2A,
0x5C2B, 0x5C2D, 0x5C2E, 0x5C2F, 0x5C30, 0x5C32, 0x5C33, 0x5C35,
0x5C36, 0x5C37, 0x5C43, 0x5C44, 0x5C46, 0x5C47, 0x5C4C, 0x5C4D,
0x5C52, 0x5C53, 0x5C54, 0x5C56, 0x5C57, 0x5C58, 0x5C5A, 0x5C5B,
0x5C5C, 0x5C5D, 0x5C5F, 0x5C62, 0x5C64, 0x5C67, 0x5C68, 0x5C69,
0x5C6A, 0x5C6B, 0x5C6C, 0x5C6D, 0x5C70, 0x5C72, 0x5C73, 0x5C74,
0x5C75, 0x5C76, 0x5C77, 0x5C78, 0x5C7B, 0x5C7C, 0x5C7D, 0x5C7E,
0x5C80, 0x5C83, 0x5C84, 0x5C85, 0x5C86, 0x5C87, 0x5C89, 0x5C8A,
0x5C8B, 0x5C8E, 0x5C8F, 0x5C92, 0x5C93, 0x5C95, 0x5C9D, 0x5C9E,
0x5C9F, 0x5CA0, 0x5CA1, 0x5CA4, 0x5CA5, 0x5CA6, 0x5CA7, 0x5CA8,
0x5CAA, 0x5CAE, 0x5CAF, 0x5CB0, 0x5CB2, 0x5CB4, 0x5CB6, 0x5CB9,
0x5CBA, 0x5CBB, 0x5CBC, 0x5CBE, 0x5CC0, 0x5CC2, 0x5CC3, 0x5CC5,
0x5CC6, 0x5CC7, 0x5CC8, 0x5CC9, 0x5CCA, 0x5CCC, 0x5CCD, 0x5CCE,
0x5CCF, 0x5CD0, 0x5CD1, 0x5CD3, 0x5CD4, 0x5CD5, 0x5CD6, 0x5CD7,
0x5CD8, 0x5CDA, 0x5CDB, 0x5CDC, 0x5CDD, 0x5CDE, 0x5CDF, 0x5CE0,
0x5CE2, 0x5CE3, 0x5CE7, 0x5CE9, 0x5CEB, 0x5CEC, 0x5CEE, 0x5CEF,
0x5CF1, 0x5CF2, 0x5CF3, 0x5CF4, 0x5CF5, 0x5CF6, 0x5CF7, 0x5CF8,
0x5CF9, 0x5CFA, 0x5CFC, 0x5CFD, 0x5CFE, 0x5CFF, 0x5D00, 0x5D01,
0x5D04, 0x5D05, 0x5D08, 0x5D09, 0x5D0A, 0x5D0B, 0x5D0C, 0x5D0D,
0x5D0F, 0x5D10, 0x5D11, 0x5D12, 0x5D13, 0x5D15, 0x5D17, 0x5D18,
0x5D19, 0x5D1A, 0x5D1C, 0x5D1D, 0x5D1F, 0x5D20, 0x5D21, 0x5D22,
0x5D23, 0x5D25, 0x5D28, 0x5D2A, 0x5D2B, 0x5D2C, 0x5D2F, 0x5D30,
0x5D31, 0x5D32, 0x5D33, 0x5D35, 0x5D36, 0x5D37, 0x5D38, 0x5D39,
0x5D3A, 0x5D3B, 0x5D3C, 0x5D3F, 0x5D40, 0x5D41, 0x5D42, 0x5D43,
0x5D44, 0x5D45, 0x5D46, 0x5D48, 0x5D49, 0x5D4D, 0x5D4E, 0x5D4F,
0x5D50, 0x5D51, 0x5D52, 0x5D53, 0x5D54, 0x5D55, 0x5D56, 0x5D57,
0x5D59, 0x5D5A, 0x5D5C, 0x5D5E, 0x5D5F, 0x5D60, 0x5D61, 0x5D62,
0x5D63, 0x5D64, 0x5D65, 0x5D66, 0x5D67, 0x5D68, 0x5D6A, 0x5D6D,
0x5D6E, 0x5D70, 0x5D71, 0x5D72, 0x5D73, 0x5D75, 0x5D76, 0x5D77,
0x5D78, 0x5D79, 0x5D7A, 0x5D7B, 0x5D7C, 0x5D7D, 0x5D7E, 0x5D7F,
0x5D80, 0x5D81, 0x5D83, 0x5D84, 0x5D85, 0x5D86, 0x5D87, 0x5D88,
0x5D89, 0x5D8A, 0x5D8B, 0x5D8C, 0x5D8D, 0x5D8E, 0x5D8F, 0x5D90,
0x5D91, 0x5D92, 0x5D93, 0x5D94, 0x5D95, 0x5D96, 0x5D97, 0x5D98,
0x5D9A, 0x5D9B, 0x5D9C, 0x5D9E, 0x5D9F, 0x5DA0, 0x5DA1, 0x5DA2,
0x5DA3, 0x5DA4, 0x5DA5, 0x5DA6, 0x5DA7, 0x5DA8, 0x5DA9, 0x5DAA,
0x5DAB, 0x5DAC, 0x5DAD, 0x5DAE, 0x5DAF, 0x5DB0, 0x5DB1, 0x5DB2,
0x5DB3, 0x5DB4, 0x5DB5, 0x5DB6, 0x5DB8, 0x5DB9, 0x5DBA, 0x5DBB,
0x5DBC, 0x5DBD, 0x5DBE, 0x5DBF, 0x5DC0, 0x5DC1, 0x5DC2, 0x5DC3,
0x5DC4, 0x5DC6, 0x5DC7, 0x5DC8, 0x5DC9, 0x5DCA, 0x5DCB, 0x5DCC,
0x5DCE, 0x5DCF, 0x5DD0, 0x5DD1, 0x5DD2, 0x5DD3, 0x5DD4, 0x5DD5,
0x5DD6, 0x5DD7, 0x5DD8, 0x5DD9, 0x5DDA, 0x5DDC, 0x5DDF, 0x5DE0,
0x5DE3, 0x5DE4, 0x5DEA, 0x5DEC, 0x5DED, 0x5DF0, 0x5DF5, 0x5DF6,
0x5DF8, 0x5DF9, 0x5DFA, 0x5DFB, 0x5DFC, 0x5DFF, 0x5E00, 0x5E04,
0x5E07, 0x5E09, 0x5E0A, 0x5E0B, 0x5E0D, 0x5E0E, 0x5E12, 0x5E13,
0x5E17, 0x5E1E, 0x5E1F, 0x5E20, 0x5E21, 0x5E22, 0x5E23, 0x5E24,
0x5E25, 0x5E28, 0x5E29, 0x5E2A, 0x5E2B, 0x5E2C, 0x5E2F, 0x5E30,
0x5E32, 0x5E33, 0x5E34, 0x5E35, 0x5E36, 0x5E39, 0x5E3A, 0x5E3E,
0x5E3F, 0x5E40, 0x5E41, 0x5E43, 0x5E46, 0x5E47, 0x5E48, 0x5E49,
0x5E4A, 0x5E4B, 0x5E4D, 0x5E4E, 0x5E4F, 0x5E50, 0x5E51, 0x5E52,
0x5E53, 0x5E56, 0x5E57, 0x5E58, 0x5E59, 0x5E5A, 0x5E5C, 0x5E5D,
0x5E5F, 0x5E60, 0x5E63, 0x5E64, 0x5E65, 0x5E66, 0x5E67, 0x5E68,
0x5E69, 0x5E6A, 0x5E6B, 0x5E6C, 0x5E6D, 0x5E6E, 0x5E6F, 0x5E70,
0x5E71, 0x5E75, 0x5E77, 0x5E79, 0x5E7E, 0x5E81, 0x5E82, 0x5E83,
0x5E85, 0x5E88, 0x5E89, 0x5E8C, 0x5E8D, 0x5E8E, 0x5E92, 0x5E98,
0x5E9B, 0x5E9D, 0x5EA1, 0x5EA2, 0x5EA3, 0x5EA4, 0x5EA8, 0x5EA9,
0x5EAA, 0x5EAB, 0x5EAC, 0x5EAE, 0x5EAF, 0x5EB0, 0x5EB1, 0x5EB2,
0x5EB4, 0x5EBA, 0x5EBB, 0x5EBC, 0x5EBD, 0x5EBF, 0x5EC0, 0x5EC1,
0x5EC2, 0x5EC3, 0x5EC4, 0x5EC5, 0x5EC6, 0x5EC7, 0x5EC8, 0x5ECB,
0x5ECC, 0x5ECD, 0x5ECE, 0x5ECF, 0x5ED0, 0x5ED4, 0x5ED5, 0x5ED7,
0x5ED8, 0x5ED9, 0x5EDA, 0x5EDC, 0x5EDD, 0x5EDE, 0x5EDF, 0x5EE0,
0x5EE1, 0x5EE2, 0x5EE3, 0x5EE4, 0x5EE5, 0x5EE6, 0x5EE7, 0x5EE9,
0x5EEB, 0x5EEC, 0x5EED, 0x5EEE, 0x5EEF, 0x5EF0, 0x5EF1, 0x5EF2,
0x5EF3, 0x5EF5, 0x5EF8, 0x5EF9, 0x5EFB, 0x5EFC, 0x5EFD, 0x5F05,
0x5F06, 0x5F07, 0x5F09, 0x5F0C, 0x5F0D, 0x5F0E, 0x5F10, 0x5F12,
0x5F14, 0x5F16, 0x5F19, 0x5F1A, 0x5F1C, 0x5F1D, 0x5F1E, 0x5F21,
0x5F22, 0x5F23, 0x5F24, 0x5F28, 0x5F2B, 0x5F2C, 0x5F2E, 0x5F30,
0x5F32, 0x5F33, 0x5F34, 0x5F35, 0x5F36, 0x5F37, 0x5F38, 0x5F3B,
0x5F3D, 0x5F3E, 0x5F3F, 0x5F41, 0x5F42, 0x5F43, 0x5F44, 0x5F45,
0x5F46, 0x5F47, 0x5F48, 0x5F49, 0x5F4A, 0x5F4B, 0x5F4C, 0x5F4D,
0x5F4E, 0x5F4F, 0x5F51, 0x5F54, 0x5F59, 0x5F5A, 0x5F5B, 0x5F5C,
0x5F5E, 0x5F5F, 0x5F60, 0x5F63, 0x5F65, 0x5F67, 0x5F68, 0x5F6B,
0x5F6E, 0x5F6F, 0x5F72, 0x5F74, 0x5F75, 0x5F76, 0x5F78, 0x5F7A,
0x5F7D, 0x5F7E, 0x5F7F, 0x5F83, 0x5F86, 0x5F8D, 0x5F8E, 0x5F8F,
0x5F91, 0x5F93, 0x5F94, 0x5F96, 0x5F9A, 0x5F9B, 0x5F9D, 0x5F9E,
0x5F9F, 0x5FA0, 0x5FA2, 0x5FA3, 0x5FA4, 0x5FA5, 0x5FA6, 0x5FA7,
0x5FA9, 0x5FAB, 0x5FAC, 0x5FAF, 0x5FB0, 0x5FB1, 0x5FB2, 0x5FB3,
0x5FB4, 0x5FB6, 0x5FB8, 0x5FB9, 0x5FBA, 0x5FBB, 0x5FBE, 0x5FBF,
0x5FC0, 0x5FC1, 0x5FC2, 0x5FC7, 0x5FC8, 0x5FCA, 0x5FCB, 0x5FCE,
0x5FD3, 0x5FD4, 0x5FD5, 0x5FDA, 0x5FDB, 0x5FDC, 0x5FDE, 0x5FDF,
0x5FE2, 0x5FE3, 0x5FE5, 0x5FE6, 0x5FE8, 0x5FE9, 0x5FEC, 0x5FEF,
0x5FF0, 0x5FF2, 0x5FF3, 0x5FF4, 0x5FF6, 0x5FF7, 0x5FF9, 0x5FFA,
0x5FFC, 0x6007, 0x6008, 0x6009, 0x600B, 0x600C, 0x6010, 0x6011,
0x6013, 0x6017, 0x6018, 0x601A, 0x601E, 0x601F, 0x6022, 0x6023,
0x6024, 0x602C, 0x602D, 0x602E, 0x6030, 0x6031, 0x6032, 0x6033,
0x6034, 0x6036, 0x6037, 0x6038, 0x6039, 0x603A, 0x603D, 0x603E,
0x6040, 0x6044, 0x6045, 0x6046, 0x6047, 0x6048, 0x6049, 0x604A,
0x604C, 0x604E, 0x604F, 0x6051, 0x6053, 0x6054, 0x6056, 0x6057,
0x6058, 0x605B, 0x605C, 0x605E, 0x605F, 0x6060, 0x6061, 0x6065,
0x6066, 0x606E, 0x6071, 0x6072, 0x6074, 0x6075, 0x6077, 0x607E,
0x6080, 0x6081, 0x6082, 0x6085, 0x6086, 0x6087, 0x6088, 0x608A,
0x608B, 0x608E, 0x608F, 0x6090, 0x6091, 0x6093, 0x6095, 0x6097,
0x6098, 0x6099, 0x609C, 0x609E, 0x60A1, 0x60A2, 0x60A4, 0x60A5,
0x60A7, 0x60A9, 0x60AA, 0x60AE, 0x60B0, 0x60B3, 0x60B5, 0x60B6,
0x60B7, 0x60B9, 0x60BA, 0x60BD, 0x60BE, 0x60BF, 0x60C0, 0x60C1,
0x60C2, 0x60C3, 0x60C4, 0x60C7, 0x60C8, 0x60C9, 0x60CC, 0x60CD,
0x60CE, 0x60CF, 0x60D0, 0x60D2, 0x60D3, 0x60D4, 0x60D6, 0x60D7,
0x60D9, 0x60DB, 0x60DE, 0x60E1, 0x60E2, 0x60E3, 0x60E4, 0x60E5,
0x60EA, 0x60F1, 0x60F2, 0x60F5, 0x60F7, 0x60F8, 0x60FB, 0x60FC,
0x60FD, 0x60FE, 0x60FF, 0x6102, 0x6103, 0x6104, 0x6105, 0x6107,
0x610A, 0x610B, 0x610C, 0x6110, 0x6111, 0x6112, 0x6113, 0x6114,
0x6116, 0x6117, 0x6118, 0x6119, 0x611B, 0x611C, 0x611D, 0x611E,
0x6121, 0x6122, 0x6125, 0x6128, 0x6129, 0x612A, 0x612C, 0x612D,
0x612E, 0x612F, 0x6130, 0x6131, 0x6132, 0x6133, 0x6134, 0x6135,
0x6136, 0x6137, 0x6138, 0x6139, 0x613A, 0x613B, 0x613C, 0x613D,
0x613E, 0x6140, 0x6141, 0x6142, 0x6143, 0x6144, 0x6145, 0x6146,
0x6147, 0x6149, 0x614B, 0x614D, 0x614F, 0x6150, 0x6152, 0x6153,
0x6154, 0x6156, 0x6157, 0x6158, 0x6159, 0x615A, 0x615B, 0x615C,
0x615E, 0x615F, 0x6160, 0x6161, 0x6163, 0x6164, 0x6165, 0x6166,
0x6169, 0x616A, 0x616B, 0x616C, 0x616D, 0x616E, 0x616F, 0x6171,
0x6172, 0x6173, 0x6174, 0x6176, 0x6178, 0x6179, 0x617A, 0x617B,
0x617C, 0x617D, 0x617E, 0x617F, 0x6180, 0x6181, 0x6182, 0x6183,
0x6184, 0x6185, 0x6186, 0x6187, 0x6188, 0x6189, 0x618A, 0x618C,
0x618D, 0x618F, 0x6190, 0x6191, 0x6192, 0x6193, 0x6195, 0x6196,
0x6197, 0x6198, 0x6199, 0x619A, 0x619B, 0x619C, 0x619E, 0x619F,
0x61A0, 0x61A1, 0x61A2, 0x61A3, 0x61A4, 0x61A5, 0x61A6, 0x61AA,
0x61AB, 0x61AD, 0x61AE, 0x61AF, 0x61B0, 0x61B1, 0x61B2, 0x61B3,
0x61B4, 0x61B5, 0x61B6, 0x61B8, 0x61B9, 0x61BA, 0x61BB, 0x61BC,
0x61BD, 0x61BF, 0x61C0, 0x61C1, 0x61C3, 0x61C4, 0x61C5, 0x61C6,
0x61C7, 0x61C9, 0x61CC, 0x61CD, 0x61CE, 0x61CF, 0x61D0, 0x61D3,
0x61D5, 0x61D6, 0x61D7, 0x61D8, 0x61D9, 0x61DA, 0x61DB, 0x61DC,
0x61DD, 0x61DE, 0x61DF, 0x61E0, 0x61E1, 0x61E2, 0x61E3, 0x61E4,
0x61E5, 0x61E7, 0x61E8, 0x61E9, 0x61EA, 0x61EB, 0x61EC, 0x61ED,
0x61EE, 0x61EF, 0x61F0, 0x61F1, 0x61F2, 0x61F3, 0x61F4, 0x61F6,
0x61F7, 0x61F8, 0x61F9, 0x61FA, 0x61FB, 0x61FC, 0x61FD, 0x61FE,
0x6200, 0x6201, 0x6202, 0x6203, 0x6204, 0x6205, 0x6207, 0x6209,
0x6213, 0x6214, 0x6219, 0x621C, 0x621D, 0x621E, 0x6220, 0x6223,
0x6226, 0x6227, 0x6228, 0x6229, 0x622B, 0x622D, 0x622F, 0x6230,
0x6231, 0x6232, 0x6235, 0x6236, 0x6238, 0x6239, 0x623A, 0x623B,
0x623C, 0x6242, 0x6244, 0x6245, 0x6246, 0x624A, 0x624F, 0x6250,
0x6255, 0x6256, 0x6257, 0x6259, 0x625A, 0x625C, 0x625D, 0x625E,
0x625F, 0x6260, 0x6261, 0x6262, 0x6264, 0x6265, 0x6268, 0x6271,
0x6272, 0x6274, 0x6275, 0x6277, 0x6278, 0x627A, 0x627B, 0x627D,
0x6281, 0x6282, 0x6283, 0x6285, 0x6286, 0x6287, 0x6288, 0x628B,
0x628C, 0x628D, 0x628E, 0x628F, 0x6290, 0x6294, 0x6299, 0x629C,
0x629D, 0x629E, 0x62A3, 0x62A6, 0x62A7, 0x62A9, 0x62AA, 0x62AD,
0x62AE, 0x62AF, 0x62B0, 0x62B2, 0x62B3, 0x62B4, 0x62B6, 0x62B7,
0x62B8, 0x62BA, 0x62BE, 0x62C0, 0x62C1, 0x62C3, 0x62CB, 0x62CF,
0x62D1, 0x62D5, 0x62DD, 0x62DE, 0x62E0, 0x62E1, 0x62E4, 0x62EA,
0x62EB, 0x62F0, 0x62F2, 0x62F5, 0x62F8, 0x62F9, 0x62FA, 0x62FB,
0x6300, 0x6303, 0x6304, 0x6305, 0x6306, 0x630A, 0x630B, 0x630C,
0x630D, 0x630F, 0x6310, 0x6312, 0x6313, 0x6314, 0x6315, 0x6317,
0x6318, 0x6319, 0x631C, 0x6326, 0x6327, 0x6329, 0x632C, 0x632D,
0x632E, 0x6330, 0x6331, 0x6333, 0x6334, 0x6335, 0x6336, 0x6337,
0x6338, 0x633B, 0x633C, 0x633E, 0x633F, 0x6340, 0x6341, 0x6344,
0x6347, 0x6348, 0x634A, 0x6351, 0x6352, 0x6353, 0x6354, 0x6356,
0x6357, 0x6358, 0x6359, 0x635A, 0x635B, 0x635C, 0x635D, 0x6360,
0x6364, 0x6365, 0x6366, 0x6368, 0x636A, 0x636B, 0x636C, 0x636F,
0x6370, 0x6372, 0x6373, 0x6374, 0x6375, 0x6378, 0x6379, 0x637C,
0x637D, 0x637E, 0x637F, 0x6381, 0x6383, 0x6384, 0x6385, 0x6386,
0x638B, 0x638D, 0x6391, 0x6393, 0x6394, 0x6395, 0x6397, 0x6399,
0x639A, 0x639B, 0x639C, 0x639D, 0x639E, 0x639F, 0x63A1, 0x63A4,
0x63A6, 0x63AB, 0x63AF, 0x63B1, 0x63B2, 0x63B5, 0x63B6, 0x63B9,
0x63BB, 0x63BD, 0x63BF, 0x63C0, 0x63C1, 0x63C2, 0x63C3, 0x63C5,
0x63C7, 0x63C8, 0x63CA, 0x63CB, 0x63CC, 0x63D1, 0x63D3, 0x63D4,
0x63D5, 0x63D7, 0x63D8, 0x63D9, 0x63DA, 0x63DB, 0x63DC, 0x63DD,
0x63DF, 0x63E2, 0x63E4, 0x63E5, 0x63E6, 0x63E7, 0x63E8, 0x63EB,
0x63EC, 0x63EE, 0x63EF, 0x63F0, 0x63F1, 0x63F3, 0x63F5, 0x63F7,
0x63F9, 0x63FA, 0x63FB, 0x63FC, 0x63FE, 0x6403, 0x6404, 0x6406,
0x6407, 0x6408, 0x6409, 0x640A, 0x640D, 0x640E, 0x6411, 0x6412,
0x6415, 0x6416, 0x6417, 0x6418, 0x6419, 0x641A, 0x641D, 0x641F,
0x6422, 0x6423, 0x6424, 0x6425, 0x6427, 0x6428, 0x6429, 0x642B,
0x642E, 0x642F, 0x6430, 0x6431, 0x6432, 0x6433, 0x6435, 0x6436,
0x6437, 0x6438, 0x6439, 0x643B, 0x643C, 0x643E, 0x6440, 0x6442,
0x6443, 0x6449, 0x644B, 0x644C, 0x644D, 0x644E, 0x644F, 0x6450,
0x6451, 0x6453, 0x6455, 0x6456, 0x6457, 0x6459, 0x645A, 0x645B,
0x645C, 0x645D, 0x645F, 0x6460, 0x6461, 0x6462, 0x6463, 0x6464,
0x6465, 0x6466, 0x6468, 0x646A, 0x646B, 0x646C, 0x646E, 0x646F,
0x6470, 0x6471, 0x6472, 0x6473, 0x6474, 0x6475, 0x6476, 0x6477,
0x647B, 0x647C, 0x647D, 0x647E, 0x647F, 0x6480, 0x6481, 0x6483,
0x6486, 0x6488, 0x6489, 0x648A, 0x648B, 0x648C, 0x648D, 0x648E,
0x648F, 0x6490, 0x6493, 0x6494, 0x6497, 0x6498, 0x649A, 0x649B,
0x649C, 0x649D, 0x649F, 0x64A0, 0x64A1, 0x64A2, 0x64A3, 0x64A5,
0x64A6, 0x64A7, 0x64A8, 0x64AA, 0x64AB, 0x64AF, 0x64B1, 0x64B2,
0x64B3, 0x64B4, 0x64B6, 0x64B9, 0x64BB, 0x64BD, 0x64BE, 0x64BF,
0x64C1, 0x64C3, 0x64C4, 0x64C6, 0x64C7, 0x64C8, 0x64C9, 0x64CA,
0x64CB, 0x64CC, 0x64CF, 0x64D1, 0x64D3, 0x64D4, 0x64D5, 0x64D6,
0x64D9, 0x64DA, 0x64DB, 0x64DC, 0x64DD, 0x64DF, 0x64E0, 0x64E1,
0x64E3, 0x64E5, 0x64E7, 0x64E8, 0x64E9, 0x64EA, 0x64EB, 0x64EC,
0x64ED, 0x64EE, 0x64EF, 0x64F0, 0x64F1, 0x64F2, 0x64F3, 0x64F4,
0x64F5, 0x64F6, 0x64F7, 0x64F8, 0x64F9, 0x64FA, 0x64FB, 0x64FC,
0x64FD, 0x64FE, 0x64FF, 0x6501, 0x6502, 0x6503, 0x6504, 0x6505,
0x6506, 0x6507, 0x6508, 0x650A, 0x650B, 0x650C, 0x650D, 0x650E,
0x650F, 0x6510, 0x6511, 0x6513, 0x6514, 0x6515, 0x6516, 0x6517,
0x6519, 0x651A, 0x651B, 0x651C, 0x651D, 0x651E, 0x651F, 0x6520,
0x6521, 0x6522, 0x6523, 0x6524, 0x6526, 0x6527, 0x6528, 0x6529,
0x652A, 0x652C, 0x652D, 0x6530, 0x6531, 0x6532, 0x6533, 0x6537,
0x653A, 0x653C, 0x653D, 0x6540, 0x6541, 0x6542, 0x6543, 0x6544,
0x6546, 0x6547, 0x654A, 0x654B, 0x654D, 0x654E, 0x6550, 0x6552,
0x6553, 0x6554, 0x6557, 0x6558, 0x655A, 0x655C, 0x655F, 0x6560,
0x6561, 0x6564, 0x6565, 0x6567, 0x6568, 0x6569, 0x656A, 0x656D,
0x656E, 0x656F, 0x6571, 0x6573, 0x6575, 0x6576, 0x6578, 0x6579,
0x657A, 0x657B, 0x657C, 0x657D, 0x657E, 0x657F, 0x6580, 0x6581,
0x6582, 0x6583, 0x6584, 0x6585, 0x6586, 0x6588, 0x6589, 0x658A,
0x658D, 0x658E, 0x658F, 0x6592, 0x6594, 0x6595, 0x6596, 0x6598,
0x659A, 0x659D, 0x659E, 0x65A0, 0x65A2, 0x65A3, 0x65A6, 0x65A8,
0x65AA, 0x65AC, 0x65AE, 0x65B1, 0x65B2, 0x65B3, 0x65B4, 0x65B5,
0x65B6, 0x65B7, 0x65B8, 0x65BA, 0x65BB, 0x65BE, 0x65BF, 0x65C0,
0x65C2, 0x65C7, 0x65C8, 0x65C9, 0x65CA, 0x65CD, 0x65D0, 0x65D1,
0x65D3, 0x65D4, 0x65D5, 0x65D8, 0x65D9, 0x65DA, 0x65DB, 0x65DC,
0x65DD, 0x65DE, 0x65DF, 0x65E1, 0x65E3, 0x65E4, 0x65EA, 0x65EB,
0x65F2, 0x65F3, 0x65F4, 0x65F5, 0x65F8, 0x65F9, 0x65FB, 0x65FC,
0x65FD, 0x65FE, 0x65FF, 0x6601, 0x6604, 0x6605, 0x6607, 0x6608,
0x6609, 0x660B, 0x660D, 0x6610, 0x6611, 0x6612, 0x6616, 0x6617,
0x6618, 0x661A, 0x661B, 0x661C, 0x661E, 0x6621, 0x6622, 0x6623,
0x6624, 0x6626, 0x6629, 0x662A, 0x662B, 0x662C, 0x662E, 0x6630,
0x6632, 0x6633, 0x6637, 0x6638, 0x6639, 0x663A, 0x663B, 0x663D,
0x663F, 0x6640, 0x6642, 0x6644, 0x6645, 0x6646, 0x6647, 0x6648,
0x6649, 0x664A, 0x664D, 0x664E, 0x6650, 0x6651, 0x6658, 0x6659,
0x665B, 0x665C, 0x665D, 0x665E, 0x6660, 0x6662, 0x6663, 0x6665,
0x6667, 0x6669, 0x666A, 0x666B, 0x666C, 0x666D, 0x6671, 0x6672,
0x6673, 0x6675, 0x6678, 0x6679, 0x667B, 0x667C, 0x667D, 0x667F,
0x6680, 0x6681, 0x6683, 0x6685, 0x6686, 0x6688, 0x6689, 0x668A,
0x668B, 0x668D, 0x668E, 0x668F, 0x6690, 0x6692, 0x6693, 0x6694,
0x6695, 0x6698, 0x6699, 0x669A, 0x669B, 0x669C, 0x669E, 0x669F,
0x66A0, 0x66A1, 0x66A2, 0x66A3, 0x66A4, 0x66A5, 0x66A6, 0x66A9,
0x66AA, 0x66AB, 0x66AC, 0x66AD, 0x66AF, 0x66B0, 0x66B1, 0x66B2,
0x66B3, 0x66B5, 0x66B6, 0x66B7, 0x66B8, 0x66BA, 0x66BB, 0x66BC,
0x66BD, 0x66BF, 0x66C0, 0x66C1, 0x66C2, 0x66C3, 0x66C4, 0x66C5,
0x66C6, 0x66C7, 0x66C8, 0x66C9, 0x66CA, 0x66CB, 0x66CC, 0x66CD,
0x66CE, 0x66CF, 0x66D0, 0x66D1, 0x66D2, 0x66D3, 0x66D4, 0x66D5,
0x66D6, 0x66D7, 0x66D8, 0x66DA, 0x66DE, 0x66DF, 0x66E0, 0x66E1,
0x66E2, 0x66E3, 0x66E4, 0x66E5, 0x66E7, 0x66E8, 0x66EA, 0x66EB,
0x66EC, 0x66ED, 0x66EE, 0x66EF, 0x66F1, 0x66F5, 0x66F6, 0x66F8,
0x66FA, 0x66FB, 0x66FD, 0x6701, 0x6702, 0x6703, 0x6704, 0x6705,
0x6706, 0x6707, 0x670C, 0x670E, 0x670F, 0x6711, 0x6712, 0x6713,
0x6716, 0x6718, 0x6719, 0x671A, 0x671C, 0x671E, 0x6720, 0x6721,
0x6722, 0x6723, 0x6724, 0x6725, 0x6727, 0x6729, 0x672E, 0x6730,
0x6732, 0x6733, 0x6736, 0x6737, 0x6738, 0x6739, 0x673B, 0x673C,
0x673E, 0x673F, 0x6741, 0x6744, 0x6745, 0x6747, 0x674A, 0x674B,
0x674D, 0x6752, 0x6754, 0x6755, 0x6757, 0x6758, 0x6759, 0x675A,
0x675B, 0x675D, 0x6762, 0x6763, 0x6764, 0x6766, 0x6767, 0x676B,
0x676C, 0x676E, 0x6771, 0x6774, 0x6776, 0x6778, 0x6779, 0x677A,
0x677B, 0x677D, 0x6780, 0x6782, 0x6783, 0x6785, 0x6786, 0x6788,
0x678A, 0x678C, 0x678D, 0x678E, 0x678F, 0x6791, 0x6792, 0x6793,
0x6794, 0x6796, 0x6799, 0x679B, 0x679F, 0x67A0, 0x67A1, 0x67A4,
0x67A6, 0x67A9, 0x67AC, 0x67AE, 0x67B1, 0x67B2, 0x67B4, 0x67B9,
0x67BA, 0x67BB, 0x67BC, 0x67BD, 0x67BE, 0x67BF, 0x67C0, 0x67C2,
0x67C5, 0x67C6, 0x67C7, 0x67C8, 0x67C9, 0x67CA, 0x67CB, 0x67CC,
0x67CD, 0x67CE, 0x67D5, 0x67D6, 0x67D7, 0x67DB, 0x67DF, 0x67E1,
0x67E3, 0x67E4, 0x67E6, 0x67E7, 0x67E8, 0x67EA, 0x67EB, 0x67ED,
0x67EE, 0x67F2, 0x67F5, 0x67F6, 0x67F7, 0x67F8, 0x67F9, 0x67FA,
0x67FB, 0x67FC, 0x67FE, 0x6801, 0x6802, 0x6803, 0x6804, 0x6806,
0x680D, 0x6810, 0x6812, 0x6814, 0x6815, 0x6818, 0x6819, 0x681A,
0x681B, 0x681C, 0x681E, 0x681F, 0x6820, 0x6822, 0x6823, 0x6824,
0x6825, 0x6826, 0x6827, 0x6828, 0x682B, 0x682C, 0x682D, 0x682E,
0x682F, 0x6830, 0x6831, 0x6834, 0x6835, 0x6836, 0x683A, 0x683B,
0x683F, 0x6847, 0x684B, 0x684D, 0x684F, 0x6852, 0x6856, 0x6857,
0x6858, 0x6859, 0x685A, 0x685B, 0x685C, 0x685D, 0x685E, 0x685F,
0x686A, 0x686C, 0x686D, 0x686E, 0x686F, 0x6870, 0x6871, 0x6872,
0x6873, 0x6875, 0x6878, 0x6879, 0x687A, 0x687B, 0x687C, 0x687D,
0x687E, 0x687F, 0x6880, 0x6882, 0x6884, 0x6887, 0x6888, 0x6889,
0x688A, 0x688B, 0x688C, 0x688D, 0x688E, 0x6890, 0x6891, 0x6892,
0x6894, 0x6895, 0x6896, 0x6898, 0x6899, 0x689A, 0x689B, 0x689C,
0x689D, 0x689E, 0x689F, 0x68A0, 0x68A1, 0x68A3, 0x68A4, 0x68A5,
0x68A9, 0x68AA, 0x68AB, 0x68AC, 0x68AE, 0x68B1, 0x68B2, 0x68B4,
0x68B6, 0x68B7, 0x68B8, 0x68B9, 0x68BA, 0x68BB, 0x68BC, 0x68BD,
0x68BE, 0x68BF, 0x68C1, 0x68C3, 0x68C4, 0x68C5, 0x68C6, 0x68C7,
0x68C8, 0x68CA, 0x68CC, 0x68CE, 0x68CF, 0x68D0, 0x68D1, 0x68D3,
0x68D4, 0x68D6, 0x68D7, 0x68D9, 0x68DB, 0x68DC, 0x68DD, 0x68DE,
0x68DF, 0x68E1, 0x68E2, 0x68E4, 0x68E5, 0x68E6, 0x68E7, 0x68E8,
0x68E9, 0x68EA, 0x68EB, 0x68EC, 0x68ED, 0x68EF, 0x68F2, 0x68F3,
0x68F4, 0x68F6, 0x68F7, 0x68F8, 0x68FB, 0x68FD, 0x68FE, 0x68FF,
0x6900, 0x6902, 0x6903, 0x6904, 0x6906, 0x6907, 0x6908, 0x6909,
0x690A, 0x690C, 0x690F, 0x6911, 0x6913, 0x6914, 0x6915, 0x6916,
0x6917, 0x6918, 0x6919, 0x691A, 0x691B, 0x691C, 0x691D, 0x691E,
0x6921, 0x6922, 0x6923, 0x6925, 0x6926, 0x6927, 0x6928, 0x6929,
0x692A, 0x692B, 0x692C, 0x692E, 0x692F, 0x6931, 0x6932, 0x6933,
0x6935, 0x6936, 0x6937, 0x6938, 0x693A, 0x693B, 0x693C, 0x693E,
0x6940, 0x6941, 0x6943, 0x6944, 0x6945, 0x6946, 0x6947, 0x6948,
0x6949, 0x694A, 0x694B, 0x694C, 0x694D, 0x694E, 0x694F, 0x6950,
0x6951, 0x6952, 0x6953, 0x6955, 0x6956, 0x6958, 0x6959, 0x695B,
0x695C, 0x695F, 0x6961, 0x6962, 0x6964, 0x6965, 0x6967, 0x6968,
0x6969, 0x696A, 0x696C, 0x696D, 0x696F, 0x6970, 0x6972, 0x6973,
0x6974, 0x6975, 0x6976, 0x697A, 0x697B, 0x697D, 0x697E, 0x697F,
0x6981, 0x6983, 0x6985, 0x698A, 0x698B, 0x698C, 0x698E, 0x698F,
0x6990, 0x6991, 0x6992, 0x6993, 0x6996, 0x6997, 0x6999, 0x699A,
0x699D, 0x699E, 0x699F, 0x69A0, 0x69A1, 0x69A2, 0x69A3, 0x69A4,
0x69A5, 0x69A6, 0x69A9, 0x69AA, 0x69AC, 0x69AE, 0x69AF, 0x69B0,
0x69B2, 0x69B3, 0x69B5, 0x69B6, 0x69B8, 0x69B9, 0x69BA, 0x69BC,
0x69BD, 0x69BE, 0x69BF, 0x69C0, 0x69C2, 0x69C3, 0x69C4, 0x69C5,
0x69C6, 0x69C7, 0x69C8, 0x69C9, 0x69CB, 0x69CD, 0x69CF, 0x69D1,
0x69D2, 0x69D3, 0x69D5, 0x69D6, 0x69D7, 0x69D8, 0x69D9, 0x69DA,
0x69DC, 0x69DD, 0x69DE, 0x69E1, 0x69E2, 0x69E3, 0x69E4, 0x69E5,
0x69E6, 0x69E7, 0x69E8, 0x69E9, 0x69EA, 0x69EB, 0x69EC, 0x69EE,
0x69EF, 0x69F0, 0x69F1, 0x69F3, 0x69F4, 0x69F5, 0x69F6, 0x69F7,
0x69F8, 0x69F9, 0x69FA, 0x69FB, 0x69FC, 0x69FE, 0x6A00, 0x6A01,
0x6A02, 0x6A03, 0x6A04, 0x6A05, 0x6A06, 0x6A07, 0x6A08, 0x6A09,
0x6A0B, 0x6A0C, 0x6A0D, 0x6A0E, 0x6A0F, 0x6A10, 0x6A11, 0x6A12,
0x6A13, 0x6A14, 0x6A15, 0x6A16, 0x6A19, 0x6A1A, 0x6A1B, 0x6A1C,
0x6A1D, 0x6A1E, 0x6A20, 0x6A22, 0x6A23, 0x6A24, 0x6A25, 0x6A26,
0x6A27, 0x6A29, 0x6A2B, 0x6A2C, 0x6A2D, 0x6A2E, 0x6A30, 0x6A32,
0x6A33, 0x6A34, 0x6A36, 0x6A37, 0x6A38, 0x6A39, 0x6A3A, 0x6A3B,
0x6A3C, 0x6A3F, 0x6A40, 0x6A41, 0x6A42, 0x6A43, 0x6A45, 0x6A46,
0x6A48, 0x6A49, 0x6A4A, 0x6A4B, 0x6A4C, 0x6A4D, 0x6A4E, 0x6A4F,
0x6A51, 0x6A52, 0x6A53, 0x6A54, 0x6A55, 0x6A56, 0x6A57, 0x6A5A,
0x6A5C, 0x6A5D, 0x6A5E, 0x6A5F, 0x6A60, 0x6A62, 0x6A63, 0x6A64,
0x6A66, 0x6A67, 0x6A68, 0x6A69, 0x6A6A, 0x6A6B, 0x6A6C, 0x6A6D,
0x6A6E, 0x6A6F, 0x6A70, 0x6A72, 0x6A73, 0x6A74, 0x6A75, 0x6A76,
0x6A77, 0x6A78, 0x6A7A, 0x6A7B, 0x6A7D, 0x6A7E, 0x6A7F, 0x6A81,
0x6A82, 0x6A83, 0x6A85, 0x6A86, 0x6A87, 0x6A88, 0x6A89, 0x6A8A,
0x6A8B, 0x6A8C, 0x6A8D, 0x6A8F, 0x6A92, 0x6A93, 0x6A94, 0x6A95,
0x6A96, 0x6A98, 0x6A99, 0x6A9A, 0x6A9B, 0x6A9C, 0x6A9D, 0x6A9E,
0x6A9F, 0x6AA1, 0x6AA2, 0x6AA3, 0x6AA4, 0x6AA5, 0x6AA6, 0x6AA7,
0x6AA8, 0x6AAA, 0x6AAD, 0x6AAE, 0x6AAF, 0x6AB0, 0x6AB1, 0x6AB2,
0x6AB3, 0x6AB4, 0x6AB5, 0x6AB6, 0x6AB7, 0x6AB8, 0x6AB9, 0x6ABA,
0x6ABB, 0x6ABC, 0x6ABD, 0x6ABE, 0x6ABF, 0x6AC0, 0x6AC1, 0x6AC2,
0x6AC3, 0x6AC4, 0x6AC5, 0x6AC6, 0x6AC7, 0x6AC8, 0x6AC9, 0x6ACA,
0x6ACB, 0x6ACC, 0x6ACD, 0x6ACE, 0x6ACF, 0x6AD0, 0x6AD1, 0x6AD2,
0x6AD3, 0x6AD4, 0x6AD5, 0x6AD6, 0x6AD7, 0x6AD8, 0x6AD9, 0x6ADA,
0x6ADB, 0x6ADC, 0x6ADD, 0x6ADE, 0x6ADF, 0x6AE0, 0x6AE1, 0x6AE2,
0x6AE3, 0x6AE4, 0x6AE5, 0x6AE6, 0x6AE7, 0x6AE8, 0x6AE9, 0x6AEA,
0x6AEB, 0x6AEC, 0x6AED, 0x6AEE, 0x6AEF, 0x6AF0, 0x6AF1, 0x6AF2,
0x6AF3, 0x6AF4, 0x6AF5, 0x6AF6, 0x6AF7, 0x6AF8, 0x6AF9, 0x6AFA,
0x6AFB, 0x6AFC, 0x6AFD, 0x6AFE, 0x6AFF, 0x6B00, 0x6B01, 0x6B02,
0x6B03, 0x6B04, 0x6B05, 0x6B06, 0x6B07, 0x6B08, 0x6B09, 0x6B0A,
0x6B0B, 0x6B0C, 0x6B0D, 0x6B0E, 0x6B0F, 0x6B10, 0x6B11, 0x6B12,
0x6B13, 0x6B14, 0x6B15, 0x6B16, 0x6B17, 0x6B18, 0x6B19, 0x6B1A,
0x6B1B, 0x6B1C, 0x6B1D, 0x6B1E, 0x6B1F, 0x6B25, 0x6B26, 0x6B28,
0x6B29, 0x6B2A, 0x6B2B, 0x6B2C, 0x6B2D, 0x6B2E, 0x6B2F, 0x6B30,
0x6B31, 0x6B33, 0x6B34, 0x6B35, 0x6B36, 0x6B38, 0x6B3B, 0x6B3C,
0x6B3D, 0x6B3F, 0x6B40, 0x6B41, 0x6B42, 0x6B44, 0x6B45, 0x6B48,
0x6B4A, 0x6B4B, 0x6B4D, 0x6B4E, 0x6B4F, 0x6B50, 0x6B51, 0x6B52,
0x6B53, 0x6B54, 0x6B55, 0x6B56, 0x6B57, 0x6B58, 0x6B5A, 0x6B5B,
0x6B5C, 0x6B5D, 0x6B5E, 0x6B5F, 0x6B60, 0x6B61, 0x6B68, 0x6B69,
0x6B6B, 0x6B6C, 0x6B6D, 0x6B6E, 0x6B6F, 0x6B70, 0x6B71, 0x6B72,
0x6B73, 0x6B74, 0x6B75, 0x6B76, 0x6B77, 0x6B78, 0x6B7A, 0x6B7D,
0x6B7E, 0x6B7F, 0x6B80, 0x6B85, 0x6B88, 0x6B8C, 0x6B8E, 0x6B8F,
0x6B90, 0x6B91, 0x6B94, 0x6B95, 0x6B97, 0x6B98, 0x6B99, 0x6B9C,
0x6B9D, 0x6B9E, 0x6B9F, 0x6BA0, 0x6BA2, 0x6BA3, 0x6BA4, 0x6BA5,
0x6BA6, 0x6BA7, 0x6BA8, 0x6BA9, 0x6BAB, 0x6BAC, 0x6BAD, 0x6BAE,
0x6BAF, 0x6BB0, 0x6BB1, 0x6BB2, 0x6BB6, 0x6BB8, 0x6BB9, 0x6BBA,
0x6BBB, 0x6BBC, 0x6BBD, 0x6BBE, 0x6BC0, 0x6BC3, 0x6BC4, 0x6BC6,
0x6BC7, 0x6BC8, 0x6BC9, 0x6BCA, 0x6BCC, 0x6BCE, 0x6BD0, 0x6BD1,
0x6BD8, 0x6BDA, 0x6BDC, 0x6BDD, 0x6BDE, 0x6BDF, 0x6BE0, 0x6BE2,
0x6BE3, 0x6BE4, 0x6BE5, 0x6BE6, 0x6BE7, 0x6BE8, 0x6BE9, 0x6BEC,
0x6BED, 0x6BEE, 0x6BF0, 0x6BF1, 0x6BF2, 0x6BF4, 0x6BF6, 0x6BF7,
0x6BF8, 0x6BFA, 0x6BFB, 0x6BFC, 0x6BFE, 0x6BFF, 0x6C00, 0x6C01,
0x6C02, 0x6C03, 0x6C04, 0x6C08, 0x6C09, 0x6C0A, 0x6C0B, 0x6C0C,
0x6C0E, 0x6C12, 0x6C17, 0x6C1C, 0x6C1D, 0x6C1E, 0x6C20, 0x6C23,
0x6C25, 0x6C2B, 0x6C2C, 0x6C2D, 0x6C31, 0x6C33, 0x6C36, 0x6C37,
0x6C39, 0x6C3A, 0x6C3B, 0x6C3C, 0x6C3E, 0x6C3F, 0x6C43, 0x6C44,
0x6C45, 0x6C48, 0x6C4B, 0x6C4C, 0x6C4D, 0x6C4E, 0x6C4F, 0x6C51,
0x6C52, 0x6C53, 0x6C56, 0x6C58, 0x6C59, 0x6C5A, 0x6C62, 0x6C63,
0x6C65, 0x6C66, 0x6C67, 0x6C6B, 0x6C6C, 0x6C6D, 0x6C6E, 0x6C6F,
0x6C71, 0x6C73, 0x6C75, 0x6C77, 0x6C78, 0x6C7A, 0x6C7B, 0x6C7C,
0x6C7F, 0x6C80, 0x6C84, 0x6C87, 0x6C8A, 0x6C8B, 0x6C8D, 0x6C8E,
0x6C91, 0x6C92, 0x6C95, 0x6C96, 0x6C97, 0x6C98, 0x6C9A, 0x6C9C,
0x6C9D, 0x6C9E, 0x6CA0, 0x6CA2, 0x6CA8, 0x6CAC, 0x6CAF, 0x6CB0,
0x6CB4, 0x6CB5, 0x6CB6, 0x6CB7, 0x6CBA, 0x6CC0, 0x6CC1, 0x6CC2,
0x6CC3, 0x6CC6, 0x6CC7, 0x6CC8, 0x6CCB, 0x6CCD, 0x6CCE, 0x6CCF,
0x6CD1, 0x6CD2, 0x6CD8, 0x6CD9, 0x6CDA, 0x6CDC, 0x6CDD, 0x6CDF,
0x6CE4, 0x6CE6, 0x6CE7, 0x6CE9, 0x6CEC, 0x6CED, 0x6CF2, 0x6CF4,
0x6CF9, 0x6CFF, 0x6D00, 0x6D02, 0x6D03, 0x6D05, 0x6D06, 0x6D08,
0x6D09, 0x6D0A, 0x6D0D, 0x6D0F, 0x6D10, 0x6D11, 0x6D13, 0x6D14,
0x6D15, 0x6D16, 0x6D18, 0x6D1C, 0x6D1D, 0x6D1F, 0x6D20, 0x6D21,
0x6D22, 0x6D23, 0x6D24, 0x6D26, 0x6D28, 0x6D29, 0x6D2C, 0x6D2D,
0x6D2F, 0x6D30, 0x6D34, 0x6D36, 0x6D37, 0x6D38, 0x6D3A, 0x6D3F,
0x6D40, 0x6D42, 0x6D44, 0x6D49, 0x6D4C, 0x6D50, 0x6D55, 0x6D56,
0x6D57, 0x6D58, 0x6D5B, 0x6D5D, 0x6D5F, 0x6D61, 0x6D62, 0x6D64,
0x6D65, 0x6D67, 0x6D68, 0x6D6B, 0x6D6C, 0x6D6D, 0x6D70, 0x6D71,
0x6D72, 0x6D73, 0x6D75, 0x6D76, 0x6D79, 0x6D7A, 0x6D7B, 0x6D7D,
0x6D7E, 0x6D7F, 0x6D80, 0x6D81, 0x6D83, 0x6D84, 0x6D86, 0x6D87,
0x6D8A, 0x6D8B, 0x6D8D, 0x6D8F, 0x6D90, 0x6D92, 0x6D96, 0x6D97,
0x6D98, 0x6D99, 0x6D9A, 0x6D9C, 0x6DA2, 0x6DA5, 0x6DAC, 0x6DAD,
0x6DB0, 0x6DB1, 0x6DB3, 0x6DB4, 0x6DB6, 0x6DB7, 0x6DB9, 0x6DBA,
0x6DBB, 0x6DBC, 0x6DBD, 0x6DBE, 0x6DC1, 0x6DC2, 0x6DC3, 0x6DC8,
0x6DC9, 0x6DCA, 0x6DCD, 0x6DCE, 0x6DCF, 0x6DD0, 0x6DD2, 0x6DD3,
0x6DD4, 0x6DD5, 0x6DD7, 0x6DDA, 0x6DDB, 0x6DDC, 0x6DDF, 0x6DE2,
0x6DE3, 0x6DE5, 0x6DE7, 0x6DE8, 0x6DE9, 0x6DEA, 0x6DED, 0x6DEF,
0x6DF0, 0x6DF2, 0x6DF4, 0x6DF5, 0x6DF6, 0x6DF8, 0x6DFA, 0x6DFD,
0x6DFE, 0x6DFF, 0x6E00, 0x6E01, 0x6E02, 0x6E03, 0x6E04, 0x6E06,
0x6E07, 0x6E08, 0x6E09, 0x6E0B, 0x6E0F, 0x6E12, 0x6E13, 0x6E15,
0x6E18, 0x6E19, 0x6E1B, 0x6E1C, 0x6E1E, 0x6E1F, 0x6E22, 0x6E26,
0x6E27, 0x6E28, 0x6E2A, 0x6E2C, 0x6E2E, 0x6E30, 0x6E31, 0x6E33,
0x6E35, 0x6E36, 0x6E37, 0x6E39, 0x6E3B, 0x6E3C, 0x6E3D, 0x6E3E,
0x6E3F, 0x6E40, 0x6E41, 0x6E42, 0x6E45, 0x6E46, 0x6E47, 0x6E48,
0x6E49, 0x6E4A, 0x6E4B, 0x6E4C, 0x6E4F, 0x6E50, 0x6E51, 0x6E52,
0x6E55, 0x6E57, 0x6E59, 0x6E5A, 0x6E5C, 0x6E5D, 0x6E5E, 0x6E60,
0x6E61, 0x6E62, 0x6E63, 0x6E64, 0x6E65, 0x6E66, 0x6E67, 0x6E68,
0x6E69, 0x6E6A, 0x6E6C, 0x6E6D, 0x6E6F, 0x6E70, 0x6E71, 0x6E72,
0x6E73, 0x6E74, 0x6E75, 0x6E76, 0x6E77, 0x6E78, 0x6E79, 0x6E7A,
0x6E7B, 0x6E7C, 0x6E7D, 0x6E80, 0x6E81, 0x6E82, 0x6E84, 0x6E87,
0x6E88, 0x6E8A, 0x6E8B, 0x6E8C, 0x6E8D, 0x6E8E, 0x6E91, 0x6E92,
0x6E93, 0x6E94, 0x6E95, 0x6E96, 0x6E97, 0x6E99, 0x6E9A, 0x6E9B,
0x6E9D, 0x6E9E, 0x6EA0, 0x6EA1, 0x6EA3, 0x6EA4, 0x6EA6, 0x6EA8,
0x6EA9, 0x6EAB, 0x6EAC, 0x6EAD, 0x6EAE, 0x6EB0, 0x6EB3, 0x6EB5,
0x6EB8, 0x6EB9, 0x6EBC, 0x6EBE, 0x6EBF, 0x6EC0, 0x6EC3, 0x6EC4,
0x6EC5, 0x6EC6, 0x6EC8, 0x6EC9, 0x6ECA, 0x6ECC, 0x6ECD, 0x6ECE,
0x6ED0, 0x6ED2, 0x6ED6, 0x6ED8, 0x6ED9, 0x6EDB, 0x6EDC, 0x6EDD,
0x6EE3, 0x6EE7, 0x6EEA, 0x6EEB, 0x6EEC, 0x6EED, 0x6EEE, 0x6EEF,
0x6EF0, 0x6EF1, 0x6EF2, 0x6EF3, 0x6EF5, 0x6EF6, 0x6EF7, 0x6EF8,
0x6EFA, 0x6EFB, 0x6EFC, 0x6EFD, 0x6EFE, 0x6EFF, 0x6F00, 0x6F01,
0x6F03, 0x6F04, 0x6F05, 0x6F07, 0x6F08, 0x6F0A, 0x6F0B, 0x6F0C,
0x6F0D, 0x6F0E, 0x6F10, 0x6F11, 0x6F12, 0x6F16, 0x6F17, 0x6F18,
0x6F19, 0x6F1A, 0x6F1B, 0x6F1C, 0x6F1D, 0x6F1E, 0x6F1F, 0x6F21,
0x6F22, 0x6F23, 0x6F25, 0x6F26, 0x6F27, 0x6F28, 0x6F2C, 0x6F2E,
0x6F30, 0x6F32, 0x6F34, 0x6F35, 0x6F37, 0x6F38, 0x6F39, 0x6F3A,
0x6F3B, 0x6F3C, 0x6F3D, 0x6F3F, 0x6F40, 0x6F41, 0x6F42, 0x6F43,
0x6F44, 0x6F45, 0x6F48, 0x6F49, 0x6F4A, 0x6F4C, 0x6F4E, 0x6F4F,
0x6F50, 0x6F51, 0x6F52, 0x6F53, 0x6F54, 0x6F55, 0x6F56, 0x6F57,
0x6F59, 0x6F5A, 0x6F5B, 0x6F5D, 0x6F5F, 0x6F60, 0x6F61, 0x6F63,
0x6F64, 0x6F65, 0x6F67, 0x6F68, 0x6F69, 0x6F6A, 0x6F6B, 0x6F6C,
0x6F6F, 0x6F70, 0x6F71, 0x6F73, 0x6F75, 0x6F76, 0x6F77, 0x6F79,
0x6F7B, 0x6F7D, 0x6F7E, 0x6F7F, 0x6F80, 0x6F81, 0x6F82, 0x6F83,
0x6F85, 0x6F86, 0x6F87, 0x6F8A, 0x6F8B, 0x6F8F, 0x6F90, 0x6F91,
0x6F92, 0x6F93, 0x6F94, 0x6F95, 0x6F96, 0x6F97, 0x6F98, 0x6F99,
0x6F9A, 0x6F9B, 0x6F9D, 0x6F9E, 0x6F9F, 0x6FA0, 0x6FA2, 0x6FA3,
0x6FA4, 0x6FA5, 0x6FA6, 0x6FA8, 0x6FA9, 0x6FAA, 0x6FAB, 0x6FAC,
0x6FAD, 0x6FAE, 0x6FAF, 0x6FB0, 0x6FB1, 0x6FB2, 0x6FB4, 0x6FB5,
0x6FB7, 0x6FB8, 0x6FBA, 0x6FBB, 0x6FBC, 0x6FBD, 0x6FBE, 0x6FBF,
0x6FC1, 0x6FC3, 0x6FC4, 0x6FC5, 0x6FC6, 0x6FC7, 0x6FC8, 0x6FCA,
0x6FCB, 0x6FCC, 0x6FCD, 0x6FCE, 0x6FCF, 0x6FD0, 0x6FD3, 0x6FD4,
0x6FD5, 0x6FD6, 0x6FD7, 0x6FD8, 0x6FD9, 0x6FDA, 0x6FDB, 0x6FDC,
0x6FDD, 0x6FDF, 0x6FE2, 0x6FE3, 0x6FE4, 0x6FE5, 0x6FE6, 0x6FE7,
0x6FE8, 0x6FE9, 0x6FEA, 0x6FEB, 0x6FEC, 0x6FED, 0x6FF0, 0x6FF1,
0x6FF2, 0x6FF3, 0x6FF4, 0x6FF5, 0x6FF6, 0x6FF7, 0x6FF8, 0x6FF9,
0x6FFA, 0x6FFB, 0x6FFC, 0x6FFD, 0x6FFE, 0x6FFF, 0x7000, 0x7001,
0x7002, 0x7003, 0x7004, 0x7005, 0x7006, 0x7007, 0x7008, 0x7009,
0x700A, 0x700B, 0x700C, 0x700D, 0x700E, 0x700F, 0x7010, 0x7012,
0x7013, 0x7014, 0x7015, 0x7016, 0x7017, 0x7018, 0x7019, 0x701C,
0x701D, 0x701E, 0x701F, 0x7020, 0x7021, 0x7022, 0x7024, 0x7025,
0x7026, 0x7027, 0x7028, 0x7029, 0x702A, 0x702B, 0x702C, 0x702D,
0x702E, 0x702F, 0x7030, 0x7031, 0x7032, 0x7033, 0x7034, 0x7036,
0x7037, 0x7038, 0x703A, 0x703B, 0x703C, 0x703D, 0x703E, 0x703F,
0x7040, 0x7041, 0x7042, 0x7043, 0x7044, 0x7045, 0x7046, 0x7047,
0x7048, 0x7049, 0x704A, 0x704B, 0x704D, 0x704E, 0x7050, 0x7051,
0x7052, 0x7053, 0x7054, 0x7055, 0x7056, 0x7057, 0x7058, 0x7059,
0x705A, 0x705B, 0x705C, 0x705D, 0x705F, 0x7060, 0x7061, 0x7062,
0x7063, 0x7064, 0x7065, 0x7066, 0x7067, 0x7068, 0x7069, 0x706A,
0x706E, 0x7071, 0x7072, 0x7073, 0x7074, 0x7077, 0x7079, 0x707A,
0x707B, 0x707D, 0x7081, 0x7082, 0x7083, 0x7084, 0x7086, 0x7087,
0x7088, 0x708B, 0x708C, 0x708D, 0x708F, 0x7090, 0x7091, 0x7093,
0x7097, 0x7098, 0x709A, 0x709B, 0x709E, 0x709F, 0x70A0, 0x70A1,
0x70A2, 0x70A3, 0x70A4, 0x70A5, 0x70A6, 0x70A7, 0x70A8, 0x70A9,
0x70AA, 0x70B0, 0x70B2, 0x70B4, 0x70B5, 0x70B6, 0x70BA, 0x70BE,
0x70BF, 0x70C4, 0x70C5, 0x70C6, 0x70C7, 0x70C9, 0x70CB, 0x70CC,
0x70CD, 0x70CE, 0x70CF, 0x70D0, 0x70D1, 0x70D2, 0x70D3, 0x70D4,
0x70D5, 0x70D6, 0x70D7, 0x70DA, 0x70DC, 0x70DD, 0x70DE, 0x70E0,
0x70E1, 0x70E2, 0x70E3, 0x70E5, 0x70EA, 0x70EE, 0x70F0, 0x70F1,
0x70F2, 0x70F3, 0x70F4, 0x70F5, 0x70F6, 0x70F8, 0x70FA, 0x70FB,
0x70FC, 0x70FE, 0x70FF, 0x7100, 0x7101, 0x7102, 0x7103, 0x7104,
0x7105, 0x7106, 0x7107, 0x7108, 0x710B, 0x710C, 0x710D, 0x710E,
0x710F, 0x7111, 0x7112, 0x7114, 0x7117, 0x711B, 0x711C, 0x711D,
0x711E, 0x711F, 0x7120, 0x7121, 0x7122, 0x7123, 0x7124, 0x7125,
0x7127, 0x7128, 0x7129, 0x712A, 0x712B, 0x712C, 0x712D, 0x712E,
0x7132, 0x7133, 0x7134, 0x7135, 0x7137, 0x7138, 0x7139, 0x713A,
0x713B, 0x713C, 0x713D, 0x713E, 0x713F, 0x7140, 0x7141, 0x7142,
0x7143, 0x7144, 0x7146, 0x7147, 0x7148, 0x7149, 0x714B, 0x714D,
0x714F, 0x7150, 0x7151, 0x7152, 0x7153, 0x7154, 0x7155, 0x7156,
0x7157, 0x7158, 0x7159, 0x715A, 0x715B, 0x715D, 0x715F, 0x7160,
0x7161, 0x7162, 0x7163, 0x7165, 0x7169, 0x716A, 0x716B, 0x716C,
0x716D, 0x716F, 0x7170, 0x7171, 0x7174, 0x7175, 0x7176, 0x7177,
0x7179, 0x717B, 0x717C, 0x717E, 0x717F, 0x7180, 0x7181, 0x7182,
0x7183, 0x7185, 0x7186, 0x7187, 0x7188, 0x7189, 0x718B, 0x718C,
0x718D, 0x718E, 0x7190, 0x7191, 0x7192, 0x7193, 0x7195, 0x7196,
0x7197, 0x719A, 0x719B, 0x719C, 0x719D, 0x719E, 0x71A1, 0x71A2,
0x71A3, 0x71A4, 0x71A5, 0x71A6, 0x71A7, 0x71A9, 0x71AA, 0x71AB,
0x71AD, 0x71AE, 0x71AF, 0x71B0, 0x71B1, 0x71B2, 0x71B4, 0x71B6,
0x71B7, 0x71B8, 0x71BA, 0x71BB, 0x71BC, 0x71BD, 0x71BE, 0x71BF,
0x71C0, 0x71C1, 0x71C2, 0x71C4, 0x71C5, 0x71C6, 0x71C7, 0x71C8,
0x71C9, 0x71CA, 0x71CB, 0x71CC, 0x71CD, 0x71CF, 0x71D0, 0x71D1,
0x71D2, 0x71D3, 0x71D6, 0x71D7, 0x71D8, 0x71D9, 0x71DA, 0x71DB,
0x71DC, 0x71DD, 0x71DE, 0x71DF, 0x71E1, 0x71E2, 0x71E3, 0x71E4,
0x71E6, 0x71E8, 0x71E9, 0x71EA, 0x71EB, 0x71EC, 0x71ED, 0x71EF,
0x71F0, 0x71F1, 0x71F2, 0x71F3, 0x71F4, 0x71F5, 0x71F6, 0x71F7,
0x71F8, 0x71FA, 0x71FB, 0x71FC, 0x71FD, 0x71FE, 0x71FF, 0x7200,
0x7201, 0x7202, 0x7203, 0x7204, 0x7205, 0x7207, 0x7208, 0x7209,
0x720A, 0x720B, 0x720C, 0x720D, 0x720E, 0x720F, 0x7210, 0x7211,
0x7212, 0x7213, 0x7214, 0x7215, 0x7216, 0x7217, 0x7218, 0x7219,
0x721A, 0x721B, 0x721C, 0x721E, 0x721F, 0x7220, 0x7221, 0x7222,
0x7223, 0x7224, 0x7225, 0x7226, 0x7227, 0x7229, 0x722B, 0x722D,
0x722E, 0x722F, 0x7232, 0x7233, 0x7234, 0x723A, 0x723C, 0x723E,
0x7240, 0x7241, 0x7242, 0x7243, 0x7244, 0x7245, 0x7246, 0x7249,
0x724A, 0x724B, 0x724E, 0x724F, 0x7250, 0x7251, 0x7253, 0x7254,
0x7255, 0x7257, 0x7258, 0x725A, 0x725C, 0x725E, 0x7260, 0x7263,
0x7264, 0x7265, 0x7268, 0x726A, 0x726B, 0x726C, 0x726D, 0x7270,
0x7271, 0x7273, 0x7274, 0x7276, 0x7277, 0x7278, 0x727B, 0x727C,
0x727D, 0x7282, 0x7283, 0x7285, 0x7286, 0x7287, 0x7288, 0x7289,
0x728C, 0x728E, 0x7290, 0x7291, 0x7293, 0x7294, 0x7295, 0x7296,
0x7297, 0x7298, 0x7299, 0x729A, 0x729B, 0x729C, 0x729D, 0x729E,
0x72A0, 0x72A1, 0x72A2, 0x72A3, 0x72A4, 0x72A5, 0x72A6, 0x72A7,
0x72A8, 0x72A9, 0x72AA, 0x72AB, 0x72AE, 0x72B1, 0x72B2, 0x72B3,
0x72B5, 0x72BA, 0x72BB, 0x72BC, 0x72BD, 0x72BE, 0x72BF, 0x72C0,
0x72C5, 0x72C6, 0x72C7, 0x72C9, 0x72CA, 0x72CB, 0x72CC, 0x72CF,
0x72D1, 0x72D3, 0x72D4, 0x72D5, 0x72D6, 0x72D8, 0x72DA, 0x72DB,
0x02CA, 0x02CB, 0x02D9, 0x2013, 0x2015, 0x2025, 0x2035, 0x2105,
0x2109, 0x2196, 0x2197, 0x2198, 0x2199, 0x2215, 0x221F, 0x2223,
0x2252, 0x2266, 0x2267, 0x22BF, 0x2550, 0x2551, 0x2552, 0x2553,
0x2554, 0x2555, 0x2556, 0x2557, 0x2558, 0x2559, 0x255A, 0x255B,
0x255C, 0x255D, 0x255E, 0x255F, 0x2560, 0x2561, 0x2562, 0x2563,
0x2564, 0x2565, 0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B,
0x256C, 0x256D, 0x256E, 0x256F, 0x2570, 0x2571, 0x2572, 0x2573,
0x2581, 0x2582, 0x2583, 0x2584, 0x2585, 0x2586, 0x2587, 0x2588,
0x2589, 0x258A, 0x258B, 0x258C, 0x258D, 0x258E, 0x258F, 0x2593,
0x2594, 0x2595, 0x25BC, 0x25BD, 0x25E2, 0x25E3, 0x25E4, 0x25E5,
0x2609, 0x2295, 0x3012, 0x301D, 0x301E, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x3021, 0x3022, 0x3023, 0x3024, 0x3025, 0x3026, 0x3027, 0x3028,
0x3029, 0x32A3, 0x338E, 0x338F, 0x339C, 0x339D, 0x339E, 0x33A1,
0x33C4, 0x33CE, 0x33D1, 0x33D2, 0x33D5, 0xFE30, 0xFFE2, 0xFFE4,
0x0000, 0x2121, 0x3231, 0x0000, 0x2010, 0x0000, 0x0000, 0x0000,
0x30FC, 0x309B, 0x309C, 0x30FD, 0x30FE, 0x3006, 0x309D, 0x309E,
0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F, 0xFE50,
0xFE51, 0xFE52, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE59, 0xFE5A,
0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F, 0xFE60, 0xFE61, 0xFE62,
0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE68, 0xFE69, 0xFE6A, 0xFE6B,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3007, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x72DC, 0x72DD, 0x72DF, 0x72E2, 0x72E3, 0x72E4, 0x72E5, 0x72E6,
0x72E7, 0x72EA, 0x72EB, 0x72F5, 0x72F6, 0x72F9, 0x72FD, 0x72FE,
0x72FF, 0x7300, 0x7302, 0x7304, 0x7305, 0x7306, 0x7307, 0x7308,
0x7309, 0x730B, 0x730C, 0x730D, 0x730F, 0x7310, 0x7311, 0x7312,
0x7314, 0x7318, 0x7319, 0x731A, 0x731F, 0x7320, 0x7323, 0x7324,
0x7326, 0x7327, 0x7328, 0x732D, 0x732F, 0x7330, 0x7332, 0x7333,
0x7335, 0x7336, 0x733A, 0x733B, 0x733C, 0x733D, 0x7340, 0x7341,
0x7342, 0x7343, 0x7344, 0x7345, 0x7346, 0x7347, 0x7348, 0x7349,
0x734A, 0x734B, 0x734C, 0x734E, 0x734F, 0x7351, 0x7353, 0x7354,
0x7355, 0x7356, 0x7358, 0x7359, 0x735A, 0x735B, 0x735C, 0x735D,
0x735E, 0x735F, 0x7361, 0x7362, 0x7363, 0x7364, 0x7365, 0x7366,
0x7367, 0x7368, 0x7369, 0x736A, 0x736B, 0x736E, 0x7370, 0x7371,
0x7372, 0x7373, 0x7374, 0x7375, 0x7376, 0x7377, 0x7378, 0x7379,
0x737A, 0x737B, 0x737C, 0x737D, 0x737F, 0x7380, 0x7381, 0x7382,
0x7383, 0x7385, 0x7386, 0x7388, 0x738A, 0x738C, 0x738D, 0x738F,
0x7390, 0x7392, 0x7393, 0x7394, 0x7395, 0x7397, 0x7398, 0x7399,
0x739A, 0x739C, 0x739D, 0x739E, 0x73A0, 0x73A1, 0x73A3, 0x73A4,
0x73A5, 0x73A6, 0x73A7, 0x73A8, 0x73AA, 0x73AC, 0x73AD, 0x73B1,
0x73B4, 0x73B5, 0x73B6, 0x73B8, 0x73B9, 0x73BC, 0x73BD, 0x73BE,
0x73BF, 0x73C1, 0x73C3, 0x73C4, 0x73C5, 0x73C6, 0x73C7, 0x73CB,
0x73CC, 0x73CE, 0x73D2, 0x73D3, 0x73D4, 0x73D5, 0x73D6, 0x73D7,
0x73D8, 0x73DA, 0x73DB, 0x73DC, 0x73DD, 0x73DF, 0x73E1, 0x73E2,
0x73E3, 0x73E4, 0x73E6, 0x73E8, 0x73EA, 0x73EB, 0x73EC, 0x73EE,
0x73EF, 0x73F0, 0x73F1, 0x73F3, 0x73F4, 0x73F5, 0x73F6, 0x73F7,
0x73F8, 0x73F9, 0x73FA, 0x73FB, 0x73FC, 0x73FD, 0x73FE, 0x73FF,
0x7400, 0x7401, 0x7402, 0x7404, 0x7407, 0x7408, 0x740B, 0x740C,
0x740D, 0x740E, 0x7411, 0x7412, 0x7413, 0x7414, 0x7415, 0x7416,
0x7417, 0x7418, 0x7419, 0x741C, 0x741D, 0x741E, 0x741F, 0x7420,
0x7421, 0x7423, 0x7424, 0x7427, 0x7429, 0x742B, 0x742D, 0x742F,
0x7431, 0x7432, 0x7437, 0x7438, 0x7439, 0x743A, 0x743B, 0x743D,
0x743E, 0x743F, 0x7440, 0x7442, 0x7443, 0x7444, 0x7445, 0x7446,
0x7447, 0x7448, 0x7449, 0x744A, 0x744B, 0x744C, 0x744D, 0x744E,
0x744F, 0x7450, 0x7451, 0x7452, 0x7453, 0x7454, 0x7456, 0x7458,
0x745D, 0x7460, 0x7461, 0x7462, 0x7463, 0x7464, 0x7465, 0x7466,
0x7467, 0x7468, 0x7469, 0x746A, 0x746B, 0x746C, 0x746E, 0x746F,
0x7471, 0x7472, 0x7473, 0x7474, 0x7475, 0x7478, 0x7479, 0x747A,
0x747B, 0x747C, 0x747D, 0x747F, 0x7482, 0x7484, 0x7485, 0x7486,
0x7488, 0x7489, 0x748A, 0x748C, 0x748D, 0x748F, 0x7491, 0x7492,
0x7493, 0x7494, 0x7495, 0x7496, 0x7497, 0x7498, 0x7499, 0x749A,
0x749B, 0x749D, 0x749F, 0x74A0, 0x74A1, 0x74A2, 0x74A3, 0x74A4,
0x74A5, 0x74A6, 0x74AA, 0x74AB, 0x74AC, 0x74AD, 0x74AE, 0x74AF,
0x74B0, 0x74B1, 0x74B2, 0x74B3, 0x74B4, 0x74B5, 0x74B6, 0x74B7,
0x74B8, 0x74B9, 0x74BB, 0x74BC, 0x74BD, 0x74BE, 0x74BF, 0x74C0,
0x74C1, 0x74C2, 0x74C3, 0x74C4, 0x74C5, 0x74C6, 0x74C7, 0x74C8,
0x74C9, 0x74CA, 0x74CB, 0x74CC, 0x74CD, 0x74CE, 0x74CF, 0x74D0,
0x74D1, 0x74D3, 0x74D4, 0x74D5, 0x74D6, 0x74D7, 0x74D8, 0x74D9,
0x74DA, 0x74DB, 0x74DD, 0x74DF, 0x74E1, 0x74E5, 0x74E7, 0x74E8,
0x74E9, 0x74EA, 0x74EB, 0x74EC, 0x74ED, 0x74F0, 0x74F1, 0x74F2,
0x74F3, 0x74F5, 0x74F8, 0x74F9, 0x74FA, 0x74FB, 0x74FC, 0x74FD,
0x74FE, 0x7500, 0x7501, 0x7502, 0x7503, 0x7505, 0x7506, 0x7507,
0x7508, 0x7509, 0x750A, 0x750B, 0x750C, 0x750E, 0x7510, 0x7512,
0x7514, 0x7515, 0x7516, 0x7517, 0x751B, 0x751D, 0x751E, 0x7520,
0x7521, 0x7522, 0x7523, 0x7524, 0x7526, 0x7527, 0x752A, 0x752E,
0x7534, 0x7536, 0x7539, 0x753C, 0x753D, 0x753F, 0x7541, 0x7542,
0x7543, 0x7544, 0x7546, 0x7547, 0x7549, 0x754A, 0x754D, 0x7550,
0x7551, 0x7552, 0x7553, 0x7555, 0x7556, 0x7557, 0x7558, 0x755D,
0x755E, 0x755F, 0x7560, 0x7561, 0x7562, 0x7563, 0x7564, 0x7567,
0x7568, 0x7569, 0x756B, 0x756C, 0x756D, 0x756E, 0x756F, 0x7570,
0x7571, 0x7573, 0x7575, 0x7576, 0x7577, 0x757A, 0x757B, 0x757C,
0x757D, 0x757E, 0x7580, 0x7581, 0x7582, 0x7584, 0x7585, 0x7587,
0x7588, 0x7589, 0x758A, 0x758C, 0x758D, 0x758E, 0x7590, 0x7593,
0x7595, 0x7598, 0x759B, 0x759C, 0x759E, 0x75A2, 0x75A6, 0x75A7,
0x75A8, 0x75A9, 0x75AA, 0x75AD, 0x75B6, 0x75B7, 0x75BA, 0x75BB,
0x75BF, 0x75C0, 0x75C1, 0x75C6, 0x75CB, 0x75CC, 0x75CE, 0x75CF,
0x75D0, 0x75D1, 0x75D3, 0x75D7, 0x75D9, 0x75DA, 0x75DC, 0x75DD,
0x75DF, 0x75E0, 0x75E1, 0x75E5, 0x75E9, 0x75EC, 0x75ED, 0x75EE,
0x75EF, 0x75F2, 0x75F3, 0x75F5, 0x75F6, 0x75F7, 0x75F8, 0x75FA,
0x75FB, 0x75FD, 0x75FE, 0x7602, 0x7604, 0x7606, 0x7607, 0x7608,
0x7609, 0x760B, 0x760D, 0x760E, 0x760F, 0x7611, 0x7612, 0x7613,
0x7614, 0x7616, 0x761A, 0x761C, 0x761D, 0x761E, 0x7621, 0x7623,
0x7627, 0x7628, 0x762C, 0x762E, 0x762F, 0x7631, 0x7632, 0x7636,
0x7637, 0x7639, 0x763A, 0x763B, 0x763D, 0x7641, 0x7642, 0x7644,
0x7645, 0x7646, 0x7647, 0x7648, 0x7649, 0x764A, 0x764B, 0x764E,
0x764F, 0x7650, 0x7651, 0x7652, 0x7653, 0x7655, 0x7657, 0x7658,
0x7659, 0x765A, 0x765B, 0x765D, 0x765F, 0x7660, 0x7661, 0x7662,
0x7664, 0x7665, 0x7666, 0x7667, 0x7668, 0x7669, 0x766A, 0x766C,
0x766D, 0x766E, 0x7670, 0x7671, 0x7672, 0x7673, 0x7674, 0x7675,
0x7676, 0x7677, 0x7679, 0x767A, 0x767C, 0x767F, 0x7680, 0x7681,
0x7683, 0x7685, 0x7689, 0x768A, 0x768C, 0x768D, 0x768F, 0x7690,
0x7692, 0x7694, 0x7695, 0x7697, 0x7698, 0x769A, 0x769B, 0x769C,
0x769D, 0x769E, 0x769F, 0x76A0, 0x76A1, 0x76A2, 0x76A3, 0x76A5,
0x76A6, 0x76A7, 0x76A8, 0x76A9, 0x76AA, 0x76AB, 0x76AC, 0x76AD,
0x76AF, 0x76B0, 0x76B3, 0x76B5, 0x76B6, 0x76B7, 0x76B8, 0x76B9,
0x76BA, 0x76BB, 0x76BC, 0x76BD, 0x76BE, 0x76C0, 0x76C1, 0x76C3,
0x76C4, 0x76C7, 0x76C9, 0x76CB, 0x76CC, 0x76D3, 0x76D5, 0x76D9,
0x76DA, 0x76DC, 0x76DD, 0x76DE, 0x76E0, 0x76E1, 0x76E2, 0x76E3,
0x76E4, 0x76E6, 0x76E7, 0x76E8, 0x76E9, 0x76EA, 0x76EB, 0x76EC,
0x76ED, 0x76F0, 0x76F3, 0x76F5, 0x76F6, 0x76F7, 0x76FA, 0x76FB,
0x76FD, 0x76FF, 0x7700, 0x7702, 0x7703, 0x7705, 0x7706, 0x770A,
0x770C, 0x770E, 0x770F, 0x7710, 0x7711, 0x7712, 0x7713, 0x7714,
0x7715, 0x7716, 0x7717, 0x7718, 0x771B, 0x771C, 0x771D, 0x771E,
0x7721, 0x7723, 0x7724, 0x7725, 0x7727, 0x772A, 0x772B, 0x772C,
0x772E, 0x7730, 0x7731, 0x7732, 0x7733, 0x7734, 0x7739, 0x773B,
0x773D, 0x773E, 0x773F, 0x7742, 0x7744, 0x7745, 0x7746, 0x7748,
0x7749, 0x774A, 0x774B, 0x774C, 0x774D, 0x774E, 0x774F, 0x7752,
0x7753, 0x7754, 0x7755, 0x7756, 0x7757, 0x7758, 0x7759, 0x775C,
0x775D, 0x775E, 0x775F, 0x7760, 0x7764, 0x7767, 0x7769, 0x776A,
0x776D, 0x776E, 0x776F, 0x7770, 0x7771, 0x7772, 0x7773, 0x7774,
0x7775, 0x7776, 0x7777, 0x7778, 0x777A, 0x777B, 0x777C, 0x7781,
0x7782, 0x7783, 0x7786, 0x7787, 0x7788, 0x7789, 0x778A, 0x778B,
0x778F, 0x7790, 0x7793, 0x7794, 0x7795, 0x7796, 0x7797, 0x7798,
0x7799, 0x779A, 0x779B, 0x779C, 0x779D, 0x779E, 0x77A1, 0x77A3,
0x77A4, 0x77A6, 0x77A8, 0x77AB, 0x77AD, 0x77AE, 0x77AF, 0x77B1,
0x77B2, 0x77B4, 0x77B6, 0x77B7, 0x77B8, 0x77B9, 0x77BA, 0x77BC,
0x77BE, 0x77C0, 0x77C1, 0x77C2, 0x77C3, 0x77C4, 0x77C5, 0x77C6,
0x77C7, 0x77C8, 0x77C9, 0x77CA, 0x77CB, 0x77CC, 0x77CE, 0x77CF,
0x77D0, 0x77D1, 0x77D2, 0x77D3, 0x77D4, 0x77D5, 0x77D6, 0x77D8,
0x77D9, 0x77DA, 0x77DD, 0x77DE, 0x77DF, 0x77E0, 0x77E1, 0x77E4,
0x77E6, 0x77E8, 0x77EA, 0x77EF, 0x77F0, 0x77F1, 0x77F2, 0x77F4,
0x77F5, 0x77F7, 0x77F9, 0x77FA, 0x77FB, 0x77FC, 0x7803, 0x7804,
0x7805, 0x7806, 0x7807, 0x7808, 0x780A, 0x780B, 0x780E, 0x780F,
0x7810, 0x7813, 0x7815, 0x7819, 0x781B, 0x781E, 0x7820, 0x7821,
0x7822, 0x7824, 0x7828, 0x782A, 0x782B, 0x782E, 0x782F, 0x7831,
0x7832, 0x7833, 0x7835, 0x7836, 0x783D, 0x783F, 0x7841, 0x7842,
0x7843, 0x7844, 0x7846, 0x7848, 0x7849, 0x784A, 0x784B, 0x784D,
0x784F, 0x7851, 0x7853, 0x7854, 0x7858, 0x7859, 0x785A, 0x785B,
0x785C, 0x785E, 0x785F, 0x7860, 0x7861, 0x7862, 0x7863, 0x7864,
0x7865, 0x7866, 0x7867, 0x7868, 0x7869, 0x786F, 0x7870, 0x7871,
0x7872, 0x7873, 0x7874, 0x7875, 0x7876, 0x7878, 0x7879, 0x787A,
0x787B, 0x787D, 0x787E, 0x787F, 0x7880, 0x7881, 0x7882, 0x7883,
0x7884, 0x7885, 0x7886, 0x7888, 0x788A, 0x788B, 0x788F, 0x7890,
0x7892, 0x7894, 0x7895, 0x7896, 0x7899, 0x789D, 0x789E, 0x78A0,
0x78A2, 0x78A4, 0x78A6, 0x78A8, 0x78A9, 0x78AA, 0x78AB, 0x78AC,
0x78AD, 0x78AE, 0x78AF, 0x78B5, 0x78B6, 0x78B7, 0x78B8, 0x78BA,
0x78BB, 0x78BC, 0x78BD, 0x78BF, 0x78C0, 0x78C2, 0x78C3, 0x78C4,
0x78C6, 0x78C7, 0x78C8, 0x78CC, 0x78CD, 0x78CE, 0x78CF, 0x78D1,
0x78D2, 0x78D3, 0x78D6, 0x78D7, 0x78D8, 0x78DA, 0x78DB, 0x78DC,
0x78DD, 0x78DE, 0x78DF, 0x78E0, 0x78E1, 0x78E2, 0x78E3, 0x78E4,
0x78E5, 0x78E6, 0x78E7, 0x78E9, 0x78EA, 0x78EB, 0x78ED, 0x78EE,
0x78EF, 0x78F0, 0x78F1, 0x78F3, 0x78F5, 0x78F6, 0x78F8, 0x78F9,
0x78FB, 0x78FC, 0x78FD, 0x78FE, 0x78FF, 0x7900, 0x7902, 0x7903,
0x7904, 0x7906, 0x7907, 0x7908, 0x7909, 0x790A, 0x790B, 0x790C,
0x790D, 0x790E, 0x790F, 0x7910, 0x7911, 0x7912, 0x7914, 0x7915,
0x7916, 0x7917, 0x7918, 0x7919, 0x791A, 0x791B, 0x791C, 0x791D,
0x791F, 0x7920, 0x7921, 0x7922, 0x7923, 0x7925, 0x7926, 0x7927,
0x7928, 0x7929, 0x792A, 0x792B, 0x792C, 0x792D, 0x792E, 0x792F,
0x7930, 0x7931, 0x7932, 0x7933, 0x7935, 0x7936, 0x7937, 0x7938,
0x7939, 0x793D, 0x793F, 0x7942, 0x7943, 0x7944, 0x7945, 0x7947,
0x794A, 0x794B, 0x794C, 0x794D, 0x794E, 0x794F, 0x7950, 0x7951,
0x7952, 0x7954, 0x7955, 0x7958, 0x7959, 0x7961, 0x7963, 0x7964,
0x7966, 0x7969, 0x796A, 0x796B, 0x796C, 0x796E, 0x7970, 0x7971,
0x7972, 0x7973, 0x7974, 0x7975, 0x7976, 0x7979, 0x797B, 0x797C,
0x797D, 0x797E, 0x797F, 0x7982, 0x7983, 0x7986, 0x7987, 0x7988,
0x7989, 0x798B, 0x798C, 0x798D, 0x798E, 0x7990, 0x7991, 0x7992,
0x7993, 0x7994, 0x7995, 0x7996, 0x7997, 0x7998, 0x7999, 0x799B,
0x799C, 0x799D, 0x799E, 0x799F, 0x79A0, 0x79A1, 0x79A2, 0x79A3,
0x79A4, 0x79A5, 0x79A6, 0x79A8, 0x79A9, 0x79AA, 0x79AB, 0x79AC,
0x79AD, 0x79AE, 0x79AF, 0x79B0, 0x79B1, 0x79B2, 0x79B4, 0x79B5,
0x79B6, 0x79B7, 0x79B8, 0x79BC, 0x79BF, 0x79C2, 0x79C4, 0x79C5,
0x79C7, 0x79C8, 0x79CA, 0x79CC, 0x79CE, 0x79CF, 0x79D0, 0x79D3,
0x79D4, 0x79D6, 0x79D7, 0x79D9, 0x79DA, 0x79DB, 0x79DC, 0x79DD,
0x79DE, 0x79E0, 0x79E1, 0x79E2, 0x79E5, 0x79E8, 0x79EA, 0x79EC,
0x79EE, 0x79F1, 0x79F2, 0x79F3, 0x79F4, 0x79F5, 0x79F6, 0x79F7,
0x79F9, 0x79FA, 0x79FC, 0x79FE, 0x79FF, 0x7A01, 0x7A04, 0x7A05,
0x7A07, 0x7A08, 0x7A09, 0x7A0A, 0x7A0C, 0x7A0F, 0x7A10, 0x7A11,
0x7A12, 0x7A13, 0x7A15, 0x7A16, 0x7A18, 0x7A19, 0x7A1B, 0x7A1C,
0x7A1D, 0x7A1F, 0x7A21, 0x7A22, 0x7A24, 0x7A25, 0x7A26, 0x7A27,
0x7A28, 0x7A29, 0x7A2A, 0x7A2B, 0x7A2C, 0x7A2D, 0x7A2E, 0x7A2F,
0x7A30, 0x7A31, 0x7A32, 0x7A34, 0x7A35, 0x7A36, 0x7A38, 0x7A3A,
0x7A3E, 0x7A40, 0x7A41, 0x7A42, 0x7A43, 0x7A44, 0x7A45, 0x7A47,
0x7A48, 0x7A49, 0x7A4A, 0x7A4B, 0x7A4C, 0x7A4D, 0x7A4E, 0x7A4F,
0x7A50, 0x7A52, 0x7A53, 0x7A54, 0x7A55, 0x7A56, 0x7A58, 0x7A59,
0x7A5A, 0x7A5B, 0x7A5C, 0x7A5D, 0x7A5E, 0x7A5F, 0x7A60, 0x7A61,
0x7A62, 0x7A63, 0x7A64, 0x7A65, 0x7A66, 0x7A67, 0x7A68, 0x7A69,
0x7A6A, 0x7A6B, 0x7A6C, 0x7A6D, 0x7A6E, 0x7A6F, 0x7A71, 0x7A72,
0x7A73, 0x7A75, 0x7A7B, 0x7A7C, 0x7A7D, 0x7A7E, 0x7A82, 0x7A85,
0x7A87, 0x7A89, 0x7A8A, 0x7A8B, 0x7A8C, 0x7A8E, 0x7A8F, 0x7A90,
0x7A93, 0x7A94, 0x7A99, 0x7A9A, 0x7A9B, 0x7A9E, 0x7AA1, 0x7AA2,
0x7AA3, 0x7AA4, 0x7AA7, 0x7AA9, 0x7AAA, 0x7AAB, 0x7AAE, 0x7AAF,
0x7AB0, 0x7AB1, 0x7AB2, 0x7AB4, 0x7AB5, 0x7AB6, 0x7AB7, 0x7AB8,
0x7AB9, 0x7ABA, 0x7ABB, 0x7ABC, 0x7ABD, 0x7ABE, 0x7AC0, 0x7AC1,
0x7AC2, 0x7AC3, 0x7AC4, 0x7AC5, 0x7AC6, 0x7AC7, 0x7AC8, 0x7AC9,
0x7ACA, 0x7ACC, 0x7ACD, 0x7ACE, 0x7ACF, 0x7AD0, 0x7AD1, 0x7AD2,
0x7AD3, 0x7AD4, 0x7AD5, 0x7AD7, 0x7AD8, 0x7ADA, 0x7ADB, 0x7ADC,
0x7ADD, 0x7AE1, 0x7AE2, 0x7AE4, 0x7AE7, 0x7AE8, 0x7AE9, 0x7AEA,
0x7AEB, 0x7AEC, 0x7AEE, 0x7AF0, 0x7AF1, 0x7AF2, 0x7AF3, 0x7AF4,
0x7AF5, 0x7AF6, 0x7AF7, 0x7AF8, 0x7AFB, 0x7AFC, 0x7AFE, 0x7B00,
0x7B01, 0x7B02, 0x7B05, 0x7B07, 0x7B09, 0x7B0C, 0x7B0D, 0x7B0E,
0x7B10, 0x7B12, 0x7B13, 0x7B16, 0x7B17, 0x7B18, 0x7B1A, 0x7B1C,
0x7B1D, 0x7B1F, 0x7B21, 0x7B22, 0x7B23, 0x7B27, 0x7B29, 0x7B2D,
0x7B2F, 0x7B30, 0x7B32, 0x7B34, 0x7B35, 0x7B36, 0x7B37, 0x7B39,
0x7B3B, 0x7B3D, 0x7B3F, 0x7B40, 0x7B41, 0x7B42, 0x7B43, 0x7B44,
0x7B46, 0x7B48, 0x7B4A, 0x7B4D, 0x7B4E, 0x7B53, 0x7B55, 0x7B57,
0x7B59, 0x7B5C, 0x7B5E, 0x7B5F, 0x7B61, 0x7B63, 0x7B64, 0x7B65,
0x7B66, 0x7B67, 0x7B68, 0x7B69, 0x7B6A, 0x7B6B, 0x7B6C, 0x7B6D,
0x7B6F, 0x7B70, 0x7B73, 0x7B74, 0x7B76, 0x7B78, 0x7B7A, 0x7B7C,
0x7B7D, 0x7B7F, 0x7B81, 0x7B82, 0x7B83, 0x7B84, 0x7B86, 0x7B87,
0x7B88, 0x7B89, 0x7B8A, 0x7B8B, 0x7B8C, 0x7B8E, 0x7B8F, 0x7B91,
0x7B92, 0x7B93, 0x7B96, 0x7B98, 0x7B99, 0x7B9A, 0x7B9B, 0x7B9E,
0x7B9F, 0x7BA0, 0x7BA3, 0x7BA4, 0x7BA5, 0x7BAE, 0x7BAF, 0x7BB0,
0x7BB2, 0x7BB3, 0x7BB5, 0x7BB6, 0x7BB7, 0x7BB9, 0x7BBA, 0x7BBB,
0x7BBC, 0x7BBD, 0x7BBE, 0x7BBF, 0x7BC0, 0x7BC2, 0x7BC3, 0x7BC4,
0x7BC5, 0x7BC8, 0x7BC9, 0x7BCA, 0x7BCB, 0x7BCD, 0x7BCE, 0x7BCF,
0x7BD0, 0x7BD2, 0x7BD4, 0x7BD5, 0x7BD6, 0x7BD7, 0x7BD8, 0x7BDB,
0x7BDC, 0x7BDE, 0x7BDF, 0x7BE0, 0x7BE2, 0x7BE3, 0x7BE4, 0x7BE7,
0x7BE8, 0x7BE9, 0x7BEB, 0x7BEC, 0x7BED, 0x7BEF, 0x7BF0, 0x7BF2,
0x7BF3, 0x7BF4, 0x7BF5, 0x7BF6, 0x7BF8, 0x7BF9, 0x7BFA, 0x7BFB,
0x7BFD, 0x7BFF, 0x7C00, 0x7C01, 0x7C02, 0x7C03, 0x7C04, 0x7C05,
0x7C06, 0x7C08, 0x7C09, 0x7C0A, 0x7C0D, 0x7C0E, 0x7C10, 0x7C11,
0x7C12, 0x7C13, 0x7C14, 0x7C15, 0x7C17, 0x7C18, 0x7C19, 0x7C1A,
0x7C1B, 0x7C1C, 0x7C1D, 0x7C1E, 0x7C20, 0x7C21, 0x7C22, 0x7C23,
0x7C24, 0x7C25, 0x7C28, 0x7C29, 0x7C2B, 0x7C2C, 0x7C2D, 0x7C2E,
0x7C2F, 0x7C30, 0x7C31, 0x7C32, 0x7C33, 0x7C34, 0x7C35, 0x7C36,
0x7C37, 0x7C39, 0x7C3A, 0x7C3B, 0x7C3C, 0x7C3D, 0x7C3E, 0x7C42,
0x7C43, 0x7C44, 0x7C45, 0x7C46, 0x7C47, 0x7C48, 0x7C49, 0x7C4A,
0x7C4B, 0x7C4C, 0x7C4E, 0x7C4F, 0x7C50, 0x7C51, 0x7C52, 0x7C53,
0x7C54, 0x7C55, 0x7C56, 0x7C57, 0x7C58, 0x7C59, 0x7C5A, 0x7C5B,
0x7C5C, 0x7C5D, 0x7C5E, 0x7C5F, 0x7C60, 0x7C61, 0x7C62, 0x7C63,
0x7C64, 0x7C65, 0x7C66, 0x7C67, 0x7C68, 0x7C69, 0x7C6A, 0x7C6B,
0x7C6C, 0x7C6D, 0x7C6E, 0x7C6F, 0x7C70, 0x7C71, 0x7C72, 0x7C75,
0x7C76, 0x7C77, 0x7C78, 0x7C79, 0x7C7A, 0x7C7E, 0x7C7F, 0x7C80,
0x7C81, 0x7C82, 0x7C83, 0x7C84, 0x7C85, 0x7C86, 0x7C87, 0x7C88,
0x7C8A, 0x7C8B, 0x7C8C, 0x7C8D, 0x7C8E, 0x7C8F, 0x7C90, 0x7C93,
0x7C94, 0x7C96, 0x7C99, 0x7C9A, 0x7C9B, 0x7CA0, 0x7CA1, 0x7CA3,
0x7CA6, 0x7CA7, 0x7CA8, 0x7CA9, 0x7CAB, 0x7CAC, 0x7CAD, 0x7CAF,
0x7CB0, 0x7CB4, 0x7CB5, 0x7CB6, 0x7CB7, 0x7CB8, 0x7CBA, 0x7CBB,
0x7CBF, 0x7CC0, 0x7CC2, 0x7CC3, 0x7CC4, 0x7CC6, 0x7CC9, 0x7CCB,
0x7CCE, 0x7CCF, 0x7CD0, 0x7CD1, 0x7CD2, 0x7CD3, 0x7CD4, 0x7CD8,
0x7CDA, 0x7CDB, 0x7CDD, 0x7CDE, 0x7CE1, 0x7CE2, 0x7CE3, 0x7CE4,
0x7CE5, 0x7CE6, 0x7CE7, 0x7CE9, 0x7CEA, 0x7CEB, 0x7CEC, 0x7CED,
0x7CEE, 0x7CF0, 0x7CF1, 0x7CF2, 0x7CF3, 0x7CF4, 0x7CF5, 0x7CF6,
0x7CF7, 0x7CF9, 0x7CFA, 0x7CFC, 0x7CFD, 0x7CFE, 0x7CFF, 0x7D00,
0x7D01, 0x7D02, 0x7D03, 0x7D04, 0x7D05, 0x7D06, 0x7D07, 0x7D08,
0x7D09, 0x7D0B, 0x7D0C, 0x7D0D, 0x7D0E, 0x7D0F, 0x7D10, 0x7D11,
0x7D12, 0x7D13, 0x7D14, 0x7D15, 0x7D16, 0x7D17, 0x7D18, 0x7D19,
0x7D1A, 0x7D1B, 0x7D1C, 0x7D1D, 0x7D1E, 0x7D1F, 0x7D21, 0x7D23,
0x7D24, 0x7D25, 0x7D26, 0x7D28, 0x7D29, 0x7D2A, 0x7D2C, 0x7D2D,
0x7D2E, 0x7D30, 0x7D31, 0x7D32, 0x7D33, 0x7D34, 0x7D35, 0x7D36,
0x7D37, 0x7D38, 0x7D39, 0x7D3A, 0x7D3B, 0x7D3C, 0x7D3D, 0x7D3E,
0x7D3F, 0x7D40, 0x7D41, 0x7D42, 0x7D43, 0x7D44, 0x7D45, 0x7D46,
0x7D47, 0x7D48, 0x7D49, 0x7D4A, 0x7D4B, 0x7D4C, 0x7D4D, 0x7D4E,
0x7D4F, 0x7D50, 0x7D51, 0x7D52, 0x7D53, 0x7D54, 0x7D55, 0x7D56,
0x7D57, 0x7D58, 0x7D59, 0x7D5A, 0x7D5B, 0x7D5C, 0x7D5D, 0x7D5E,
0x7D5F, 0x7D60, 0x7D61, 0x7D62, 0x7D63, 0x7D64, 0x7D65, 0x7D66,
0x7D67, 0x7D68, 0x7D69, 0x7D6A, 0x7D6B, 0x7D6C, 0x7D6D, 0x7D6F,
0x7D70, 0x7D71, 0x7D72, 0x7D73, 0x7D74, 0x7D75, 0x7D76, 0x7D78,
0x7D79, 0x7D7A, 0x7D7B, 0x7D7C, 0x7D7D, 0x7D7E, 0x7D7F, 0x7D80,
0x7D81, 0x7D82, 0x7D83, 0x7D84, 0x7D85, 0x7D86, 0x7D87, 0x7D88,
0x7D89, 0x7D8A, 0x7D8B, 0x7D8C, 0x7D8D, 0x7D8E, 0x7D8F, 0x7D90,
0x7D91, 0x7D92, 0x7D93, 0x7D94, 0x7D95, 0x7D96, 0x7D97, 0x7D98,
0x7D99, 0x7D9A, 0x7D9B, 0x7D9C, 0x7D9D, 0x7D9E, 0x7D9F, 0x7DA0,
0x7DA1, 0x7DA2, 0x7DA3, 0x7DA4, 0x7DA5, 0x7DA7, 0x7DA8, 0x7DA9,
0x7DAA, 0x7DAB, 0x7DAC, 0x7DAD, 0x7DAF, 0x7DB0, 0x7DB1, 0x7DB2,
0x7DB3, 0x7DB4, 0x7DB5, 0x7DB6, 0x7DB7, 0x7DB8, 0x7DB9, 0x7DBA,
0x7DBB, 0x7DBC, 0x7DBD, 0x7DBE, 0x7DBF, 0x7DC0, 0x7DC1, 0x7DC2,
0x7DC3, 0x7DC4, 0x7DC5, 0x7DC6, 0x7DC7, 0x7DC8, 0x7DC9, 0x7DCA,
0x7DCB, 0x7DCC, 0x7DCD, 0x7DCE, 0x7DCF, 0x7DD0, 0x7DD1, 0x7DD2,
0x7DD3, 0x7DD4, 0x7DD5, 0x7DD6, 0x7DD7, 0x7DD8, 0x7DD9, 0x7DDA,
0x7DDB, 0x7DDC, 0x7DDD, 0x7DDE, 0x7DDF, 0x7DE0, 0x7DE1, 0x7DE2,
0x7DE3, 0x7DE4, 0x7DE5, 0x7DE6, 0x7DE7, 0x7DE8, 0x7DE9, 0x7DEA,
0x7DEB, 0x7DEC, 0x7DED, 0x7DEE, 0x7DEF, 0x7DF0, 0x7DF1, 0x7DF2,
0x7DF3, 0x7DF4, 0x7DF5, 0x7DF6, 0x7DF7, 0x7DF8, 0x7DF9, 0x7DFA,
0x7DFB, 0x7DFC, 0x7DFD, 0x7DFE, 0x7DFF, 0x7E00, 0x7E01, 0x7E02,
0x7E03, 0x7E04, 0x7E05, 0x7E06, 0x7E07, 0x7E08, 0x7E09, 0x7E0A,
0x7E0B, 0x7E0C, 0x7E0D, 0x7E0E, 0x7E0F, 0x7E10, 0x7E11, 0x7E12,
0x7E13, 0x7E14, 0x7E15, 0x7E16, 0x7E17, 0x7E18, 0x7E19, 0x7E1A,
0x7E1B, 0x7E1C, 0x7E1D, 0x7E1E, 0x7E1F, 0x7E20, 0x7E21, 0x7E22,
0x7E23, 0x7E24, 0x7E25, 0x7E26, 0x7E27, 0x7E28, 0x7E29, 0x7E2A,
0x7E2B, 0x7E2C, 0x7E2D, 0x7E2E, 0x7E2F, 0x7E30, 0x7E31, 0x7E32,
0x7E33, 0x7E34, 0x7E35, 0x7E36, 0x7E37, 0x7E38, 0x7E39, 0x7E3A,
0x7E3C, 0x7E3D, 0x7E3E, 0x7E3F, 0x7E40, 0x7E42, 0x7E43, 0x7E44,
0x7E45, 0x7E46, 0x7E48, 0x7E49, 0x7E4A, 0x7E4B, 0x7E4C, 0x7E4D,
0x7E4E, 0x7E4F, 0x7E50, 0x7E51, 0x7E52, 0x7E53, 0x7E54, 0x7E55,
0x7E56, 0x7E57, 0x7E58, 0x7E59, 0x7E5A, 0x7E5B, 0x7E5C, 0x7E5D,
0x7E5E, 0x7E5F, 0x7E60, 0x7E61, 0x7E62, 0x7E63, 0x7E64, 0x7E65,
0x7E66, 0x7E67, 0x7E68, 0x7E69, 0x7E6A, 0x7E6B, 0x7E6C, 0x7E6D,
0x7E6E, 0x7E6F, 0x7E70, 0x7E71, 0x7E72, 0x7E73, 0x7E74, 0x7E75,
0x7E76, 0x7E77, 0x7E78, 0x7E79, 0x7E7A, 0x7E7B, 0x7E7C, 0x7E7D,
0x7E7E, 0x7E7F, 0x7E80, 0x7E81, 0x7E83, 0x7E84, 0x7E85, 0x7E86,
0x7E87, 0x7E88, 0x7E89, 0x7E8A, 0x7E8B, 0x7E8C, 0x7E8D, 0x7E8E,
0x7E8F, 0x7E90, 0x7E91, 0x7E92, 0x7E93, 0x7E94, 0x7E95, 0x7E96,
0x7E97, 0x7E98, 0x7E99, 0x7E9A, 0x7E9C, 0x7E9D, 0x7E9E, 0x7EAE,
0x7EB4, 0x7EBB, 0x7EBC, 0x7ED6, 0x7EE4, 0x7EEC, 0x7EF9, 0x7F0A,
0x7F10, 0x7F1E, 0x7F37, 0x7F39, 0x7F3B, 0x7F3C, 0x7F3D, 0x7F3E,
0x7F3F, 0x7F40, 0x7F41, 0x7F43, 0x7F46, 0x7F47, 0x7F48, 0x7F49,
0x7F4A, 0x7F4B, 0x7F4C, 0x7F4D, 0x7F4E, 0x7F4F, 0x7F52, 0x7F53,
0x7F56, 0x7F59, 0x7F5B, 0x7F5C, 0x7F5D, 0x7F5E, 0x7F60, 0x7F63,
0x7F64, 0x7F65, 0x7F66, 0x7F67, 0x7F6B, 0x7F6C, 0x7F6D, 0x7F6F,
0x7F70, 0x7F73, 0x7F75, 0x7F76, 0x7F77, 0x7F78, 0x7F7A, 0x7F7B,
0x7F7C, 0x7F7D, 0x7F7F, 0x7F80, 0x7F82, 0x7F83, 0x7F84, 0x7F85,
0x7F86, 0x7F87, 0x7F88, 0x7F89, 0x7F8B, 0x7F8D, 0x7F8F, 0x7F90,
0x7F91, 0x7F92, 0x7F93, 0x7F95, 0x7F96, 0x7F97, 0x7F98, 0x7F99,
0x7F9B, 0x7F9C, 0x7FA0, 0x7FA2, 0x7FA3, 0x7FA5, 0x7FA6, 0x7FA8,
0x7FA9, 0x7FAA, 0x7FAB, 0x7FAC, 0x7FAD, 0x7FAE, 0x7FB1, 0x7FB3,
0x7FB4, 0x7FB5, 0x7FB6, 0x7FB7, 0x7FBA, 0x7FBB, 0x7FBE, 0x7FC0,
0x7FC2, 0x7FC3, 0x7FC4, 0x7FC6, 0x7FC7, 0x7FC8, 0x7FC9, 0x7FCB,
0x7FCD, 0x7FCF, 0x7FD0, 0x7FD1, 0x7FD2, 0x7FD3, 0x7FD6, 0x7FD7,
0x7FD9, 0x7FDA, 0x7FDB, 0x7FDC, 0x7FDD, 0x7FDE, 0x7FE2, 0x7FE3,
0x7FE4, 0x7FE7, 0x7FE8, 0x7FEA, 0x7FEB, 0x7FEC, 0x7FED, 0x7FEF,
0x7FF2, 0x7FF4, 0x7FF5, 0x7FF6, 0x7FF7, 0x7FF8, 0x7FF9, 0x7FFA,
0x7FFD, 0x7FFE, 0x7FFF, 0x8002, 0x8007, 0x8008, 0x8009, 0x800A,
0x800E, 0x800F, 0x8011, 0x8013, 0x801A, 0x801B, 0x801D, 0x801E,
0x801F, 0x8021, 0x8023, 0x8024, 0x802B, 0x802C, 0x802D, 0x802E,
0x802F, 0x8030, 0x8032, 0x8034, 0x8039, 0x803A, 0x803C, 0x803E,
0x8040, 0x8041, 0x8044, 0x8045, 0x8047, 0x8048, 0x8049, 0x804E,
0x804F, 0x8050, 0x8051, 0x8053, 0x8055, 0x8056, 0x8057, 0x8059,
0x805B, 0x805C, 0x805D, 0x805E, 0x805F, 0x8060, 0x8061, 0x8062,
0x8063, 0x8064, 0x8065, 0x8066, 0x8067, 0x8068, 0x806B, 0x806C,
0x806D, 0x806E, 0x806F, 0x8070, 0x8072, 0x8073, 0x8074, 0x8075,
0x8076, 0x8077, 0x8078, 0x8079, 0x807A, 0x807B, 0x807C, 0x807D,
0x807E, 0x8081, 0x8082, 0x8085, 0x8088, 0x808A, 0x808D, 0x808E,
0x808F, 0x8090, 0x8091, 0x8092, 0x8094, 0x8095, 0x8097, 0x8099,
0x809E, 0x80A3, 0x80A6, 0x80A7, 0x80A8, 0x80AC, 0x80B0, 0x80B3,
0x80B5, 0x80B6, 0x80B8, 0x80B9, 0x80BB, 0x80C5, 0x80C7, 0x80C8,
0x80C9, 0x80CA, 0x80CB, 0x80CF, 0x80D0, 0x80D1, 0x80D2, 0x80D3,
0x80D4, 0x80D5, 0x80D8, 0x80DF, 0x80E0, 0x80E2, 0x80E3, 0x80E6,
0x80EE, 0x80F5, 0x80F7, 0x80F9, 0x80FB, 0x80FE, 0x80FF, 0x8100,
0x8101, 0x8103, 0x8104, 0x8105, 0x8107, 0x8108, 0x810B, 0x810C,
0x8115, 0x8117, 0x8119, 0x811B, 0x811C, 0x811D, 0x811F, 0x8120,
0x8121, 0x8122, 0x8123, 0x8124, 0x8125, 0x8126, 0x8127, 0x8128,
0x8129, 0x812A, 0x812B, 0x812D, 0x812E, 0x8130, 0x8133, 0x8134,
0x8135, 0x8137, 0x8139, 0x813A, 0x813B, 0x813C, 0x813D, 0x813F,
0x8140, 0x8141, 0x8142, 0x8143, 0x8144, 0x8145, 0x8147, 0x8149,
0x814D, 0x814E, 0x814F, 0x8152, 0x8156, 0x8157, 0x8158, 0x815B,
0x815C, 0x815D, 0x815E, 0x815F, 0x8161, 0x8162, 0x8163, 0x8164,
0x8166, 0x8168, 0x816A, 0x816B, 0x816C, 0x816F, 0x8172, 0x8173,
0x8175, 0x8176, 0x8177, 0x8178, 0x8181, 0x8183, 0x8184, 0x8185,
0x8186, 0x8187, 0x8189, 0x818B, 0x818C, 0x818D, 0x818E, 0x8190,
0x8192, 0x8193, 0x8194, 0x8195, 0x8196, 0x8197, 0x8199, 0x819A,
0x819E, 0x819F, 0x81A0, 0x81A1, 0x81A2, 0x81A4, 0x81A5, 0x81A7,
0x81A9, 0x81AB, 0x81AC, 0x81AD, 0x81AE, 0x81AF, 0x81B0, 0x81B1,
0x81B2, 0x81B4, 0x81B5, 0x81B6, 0x81B7, 0x81B8, 0x81B9, 0x81BC,
0x81BD, 0x81BE, 0x81BF, 0x81C4, 0x81C5, 0x81C7, 0x81C8, 0x81C9,
0x81CB, 0x81CD, 0x81CE, 0x81CF, 0x81D0, 0x81D1, 0x81D2, 0x81D3,
0x81D4, 0x81D5, 0x81D6, 0x81D7, 0x81D8, 0x81D9, 0x81DA, 0x81DB,
0x81DC, 0x81DD, 0x81DE, 0x81DF, 0x81E0, 0x81E1, 0x81E2, 0x81E4,
0x81E5, 0x81E6, 0x81E8, 0x81E9, 0x81EB, 0x81EE, 0x81EF, 0x81F0,
0x81F1, 0x81F2, 0x81F5, 0x81F6, 0x81F7, 0x81F8, 0x81F9, 0x81FA,
0x81FD, 0x81FF, 0x8203, 0x8207, 0x8208, 0x8209, 0x820A, 0x820B,
0x820E, 0x820F, 0x8211, 0x8213, 0x8215, 0x8216, 0x8217, 0x8218,
0x8219, 0x821A, 0x821D, 0x8220, 0x8224, 0x8225, 0x8226, 0x8227,
0x8229, 0x822E, 0x8232, 0x823A, 0x823C, 0x823D, 0x823F, 0x8240,
0x8241, 0x8242, 0x8243, 0x8245, 0x8246, 0x8248, 0x824A, 0x824C,
0x824D, 0x824E, 0x8250, 0x8251, 0x8252, 0x8253, 0x8254, 0x8255,
0x8256, 0x8257, 0x8259, 0x825B, 0x825C, 0x825D, 0x825E, 0x8260,
0x8261, 0x8262, 0x8263, 0x8264, 0x8265, 0x8266, 0x8267, 0x8269,
0x826A, 0x826B, 0x826C, 0x826D, 0x8271, 0x8275, 0x8276, 0x8277,
0x8278, 0x827B, 0x827C, 0x8280, 0x8281, 0x8283, 0x8285, 0x8286,
0x8287, 0x8289, 0x828C, 0x8290, 0x8293, 0x8294, 0x8295, 0x8296,
0x829A, 0x829B, 0x829E, 0x82A0, 0x82A2, 0x82A3, 0x82A7, 0x82B2,
0x82B5, 0x82B6, 0x82BA, 0x82BB, 0x82BC, 0x82BF, 0x82C0, 0x82C2,
0x82C3, 0x82C5, 0x82C6, 0x82C9, 0x82D0, 0x82D6, 0x82D9, 0x82DA,
0x82DD, 0x82E2, 0x82E7, 0x82E8, 0x82E9, 0x82EA, 0x82EC, 0x82ED,
0x82EE, 0x82F0, 0x82F2, 0x82F3, 0x82F5, 0x82F6, 0x82F8, 0x82FA,
0x82FC, 0x82FD, 0x82FE, 0x82FF, 0x8300, 0x830A, 0x830B, 0x830D,
0x8310, 0x8312, 0x8313, 0x8316, 0x8318, 0x8319, 0x831D, 0x831E,
0x831F, 0x8320, 0x8321, 0x8322, 0x8323, 0x8324, 0x8325, 0x8326,
0x8329, 0x832A, 0x832E, 0x8330, 0x8332, 0x8337, 0x833B, 0x833D,
0x833E, 0x833F, 0x8341, 0x8342, 0x8344, 0x8345, 0x8348, 0x834A,
0x834B, 0x834C, 0x834D, 0x834E, 0x8353, 0x8355, 0x8356, 0x8357,
0x8358, 0x8359, 0x835D, 0x8362, 0x8370, 0x8371, 0x8372, 0x8373,
0x8374, 0x8375, 0x8376, 0x8379, 0x837A, 0x837E, 0x837F, 0x8380,
0x8381, 0x8382, 0x8383, 0x8384, 0x8387, 0x8388, 0x838A, 0x838B,
0x838C, 0x838D, 0x838F, 0x8390, 0x8391, 0x8394, 0x8395, 0x8396,
0x8397, 0x8399, 0x839A, 0x839D, 0x839F, 0x83A1, 0x83A2, 0x83A3,
0x83A4, 0x83A5, 0x83A6, 0x83A7, 0x83AC, 0x83AD, 0x83AE, 0x83AF,
0x83B5, 0x83BB, 0x83BE, 0x83BF, 0x83C2, 0x83C3, 0x83C4, 0x83C6,
0x83C8, 0x83C9, 0x83CB, 0x83CD, 0x83CE, 0x83D0, 0x83D1, 0x83D2,
0x83D3, 0x83D5, 0x83D7, 0x83D9, 0x83DA, 0x83DB, 0x83DE, 0x83E2,
0x83E3, 0x83E4, 0x83E6, 0x83E7, 0x83E8, 0x83EB, 0x83EC, 0x83ED,
0x83EE, 0x83EF, 0x83F3, 0x83F4, 0x83F5, 0x83F6, 0x83F7, 0x83FA,
0x83FB, 0x83FC, 0x83FE, 0x83FF, 0x8400, 0x8402, 0x8405, 0x8407,
0x8408, 0x8409, 0x840A, 0x8410, 0x8412, 0x8413, 0x8414, 0x8415,
0x8416, 0x8417, 0x8419, 0x841A, 0x841B, 0x841E, 0x841F, 0x8420,
0x8421, 0x8422, 0x8423, 0x8429, 0x842A, 0x842B, 0x842C, 0x842D,
0x842E, 0x842F, 0x8430, 0x8432, 0x8433, 0x8434, 0x8435, 0x8436,
0x8437, 0x8439, 0x843A, 0x843B, 0x843E, 0x843F, 0x8440, 0x8441,
0x8442, 0x8443, 0x8444, 0x8445, 0x8447, 0x8448, 0x8449, 0x844A,
0x844B, 0x844C, 0x844D, 0x844E, 0x844F, 0x8450, 0x8452, 0x8453,
0x8454, 0x8455, 0x8456, 0x8458, 0x845D, 0x845E, 0x845F, 0x8460,
0x8462, 0x8464, 0x8465, 0x8466, 0x8467, 0x8468, 0x846A, 0x846E,
0x846F, 0x8470, 0x8472, 0x8474, 0x8477, 0x8479, 0x847B, 0x847C,
0x847D, 0x847E, 0x847F, 0x8480, 0x8481, 0x8483, 0x8484, 0x8485,
0x8486, 0x848A, 0x848D, 0x848F, 0x8490, 0x8491, 0x8492, 0x8493,
0x8494, 0x8495, 0x8496, 0x8498, 0x849A, 0x849B, 0x849D, 0x849E,
0x849F, 0x84A0, 0x84A2, 0x84A3, 0x84A4, 0x84A5, 0x84A6, 0x84A7,
0x84A8, 0x84A9, 0x84AA, 0x84AB, 0x84AC, 0x84AD, 0x84AE, 0x84B0,
0x84B1, 0x84B3, 0x84B5, 0x84B6, 0x84B7, 0x84BB, 0x84BC, 0x84BE,
0x84C0, 0x84C2, 0x84C3, 0x84C5, 0x84C6, 0x84C7, 0x84C8, 0x84CB,
0x84CC, 0x84CE, 0x84CF, 0x84D2, 0x84D4, 0x84D5, 0x84D7, 0x84D8,
0x84D9, 0x84DA, 0x84DB, 0x84DC, 0x84DE, 0x84E1, 0x84E2, 0x84E4,
0x84E7, 0x84E8, 0x84E9, 0x84EA, 0x84EB, 0x84ED, 0x84EE, 0x84EF,
0x84F1, 0x84F2, 0x84F3, 0x84F4, 0x84F5, 0x84F6, 0x84F7, 0x84F8,
0x84F9, 0x84FA, 0x84FB, 0x84FD, 0x84FE, 0x8500, 0x8501, 0x8502,
0x8503, 0x8504, 0x8505, 0x8506, 0x8507, 0x8508, 0x8509, 0x850A,
0x850B, 0x850D, 0x850E, 0x850F, 0x8510, 0x8512, 0x8514, 0x8515,
0x8516, 0x8518, 0x8519, 0x851B, 0x851C, 0x851D, 0x851E, 0x8520,
0x8522, 0x8523, 0x8524, 0x8525, 0x8526, 0x8527, 0x8528, 0x8529,
0x852A, 0x852D, 0x852E, 0x852F, 0x8530, 0x8531, 0x8532, 0x8533,
0x8534, 0x8535, 0x8536, 0x853E, 0x853F, 0x8540, 0x8541, 0x8542,
0x8544, 0x8545, 0x8546, 0x8547, 0x854B, 0x854C, 0x854D, 0x854E,
0x854F, 0x8550, 0x8551, 0x8552, 0x8553, 0x8554, 0x8555, 0x8557,
0x8558, 0x855A, 0x855B, 0x855C, 0x855D, 0x855F, 0x8560, 0x8561,
0x8562, 0x8563, 0x8565, 0x8566, 0x8567, 0x8569, 0x856A, 0x856B,
0x856C, 0x856D, 0x856E, 0x856F, 0x8570, 0x8571, 0x8573, 0x8575,
0x8576, 0x8577, 0x8578, 0x857C, 0x857D, 0x857F, 0x8580, 0x8581,
0x8582, 0x8583, 0x8586, 0x8588, 0x8589, 0x858A, 0x858B, 0x858C,
0x858D, 0x858E, 0x8590, 0x8591, 0x8592, 0x8593, 0x8594, 0x8595,
0x8596, 0x8597, 0x8598, 0x8599, 0x859A, 0x859D, 0x859E, 0x859F,
0x85A0, 0x85A1, 0x85A2, 0x85A3, 0x85A5, 0x85A6, 0x85A7, 0x85A9,
0x85AB, 0x85AC, 0x85AD, 0x85B1, 0x85B2, 0x85B3, 0x85B4, 0x85B5,
0x85B6, 0x85B8, 0x85BA, 0x85BB, 0x85BC, 0x85BD, 0x85BE, 0x85BF,
0x85C0, 0x85C2, 0x85C3, 0x85C4, 0x85C5, 0x85C6, 0x85C7, 0x85C8,
0x85CA, 0x85CB, 0x85CC, 0x85CD, 0x85CE, 0x85D1, 0x85D2, 0x85D4,
0x85D6, 0x85D7, 0x85D8, 0x85D9, 0x85DA, 0x85DB, 0x85DD, 0x85DE,
0x85DF, 0x85E0, 0x85E1, 0x85E2, 0x85E3, 0x85E5, 0x85E6, 0x85E7,
0x85E8, 0x85EA, 0x85EB, 0x85EC, 0x85ED, 0x85EE, 0x85EF, 0x85F0,
0x85F1, 0x85F2, 0x85F3, 0x85F4, 0x85F5, 0x85F6, 0x85F7, 0x85F8,
0x85F9, 0x85FA, 0x85FC, 0x85FD, 0x85FE, 0x8600, 0x8601, 0x8602,
0x8603, 0x8604, 0x8606, 0x8607, 0x8608, 0x8609, 0x860A, 0x860B,
0x860C, 0x860D, 0x860E, 0x860F, 0x8610, 0x8612, 0x8613, 0x8614,
0x8615, 0x8617, 0x8618, 0x8619, 0x861A, 0x861B, 0x861C, 0x861D,
0x861E, 0x861F, 0x8620, 0x8621, 0x8622, 0x8623, 0x8624, 0x8625,
0x8626, 0x8628, 0x862A, 0x862B, 0x862C, 0x862D, 0x862E, 0x862F,
0x8630, 0x8631, 0x8632, 0x8633, 0x8634, 0x8635, 0x8636, 0x8637,
0x8639, 0x863A, 0x863B, 0x863D, 0x863E, 0x863F, 0x8640, 0x8641,
0x8642, 0x8643, 0x8644, 0x8645, 0x8646, 0x8647, 0x8648, 0x8649,
0x864A, 0x864B, 0x864C, 0x8652, 0x8653, 0x8655, 0x8656, 0x8657,
0x8658, 0x8659, 0x865B, 0x865C, 0x865D, 0x865F, 0x8660, 0x8661,
0x8663, 0x8664, 0x8665, 0x8666, 0x8667, 0x8668, 0x8669, 0x866A,
0x866D, 0x866F, 0x8670, 0x8672, 0x8673, 0x8674, 0x8675, 0x8676,
0x8677, 0x8678, 0x8683, 0x8684, 0x8685, 0x8686, 0x8687, 0x8688,
0x8689, 0x868E, 0x868F, 0x8690, 0x8691, 0x8692, 0x8694, 0x8696,
0x8697, 0x8698, 0x8699, 0x869A, 0x869B, 0x869E, 0x869F, 0x86A0,
0x86A1, 0x86A2, 0x86A5, 0x86A6, 0x86AB, 0x86AD, 0x86AE, 0x86B2,
0x86B3, 0x86B7, 0x86B8, 0x86B9, 0x86BB, 0x86BC, 0x86BD, 0x86BE,
0x86BF, 0x86C1, 0x86C2, 0x86C3, 0x86C5, 0x86C8, 0x86CC, 0x86CD,
0x86D2, 0x86D3, 0x86D5, 0x86D6, 0x86D7, 0x86DA, 0x86DC, 0x86DD,
0x86E0, 0x86E1, 0x86E2, 0x86E3, 0x86E5, 0x86E6, 0x86E7, 0x86E8,
0x86EA, 0x86EB, 0x86EC, 0x86EF, 0x86F5, 0x86F6, 0x86F7, 0x86FA,
0x86FB, 0x86FC, 0x86FD, 0x86FF, 0x8701, 0x8704, 0x8705, 0x8706,
0x870B, 0x870C, 0x870E, 0x870F, 0x8710, 0x8711, 0x8714, 0x8716,
0x8719, 0x871B, 0x871D, 0x871F, 0x8720, 0x8724, 0x8726, 0x8727,
0x8728, 0x872A, 0x872B, 0x872C, 0x872D, 0x872F, 0x8730, 0x8732,
0x8733, 0x8735, 0x8736, 0x8738, 0x8739, 0x873A, 0x873C, 0x873D,
0x8740, 0x8741, 0x8742, 0x8743, 0x8744, 0x8745, 0x8746, 0x874A,
0x874B, 0x874D, 0x874F, 0x8750, 0x8751, 0x8752, 0x8754, 0x8755,
0x8756, 0x8758, 0x875A, 0x875B, 0x875C, 0x875D, 0x875E, 0x875F,
0x8761, 0x8762, 0x8766, 0x8767, 0x8768, 0x8769, 0x876A, 0x876B,
0x876C, 0x876D, 0x876F, 0x8771, 0x8772, 0x8773, 0x8775, 0x8777,
0x8778, 0x8779, 0x877A, 0x877F, 0x8780, 0x8781, 0x8784, 0x8786,
0x8787, 0x8789, 0x878A, 0x878C, 0x878E, 0x878F, 0x8790, 0x8791,
0x8792, 0x8794, 0x8795, 0x8796, 0x8798, 0x8799, 0x879A, 0x879B,
0x879C, 0x879D, 0x879E, 0x87A0, 0x87A1, 0x87A2, 0x87A3, 0x87A4,
0x87A5, 0x87A6, 0x87A7, 0x87A9, 0x87AA, 0x87AE, 0x87B0, 0x87B1,
0x87B2, 0x87B4, 0x87B6, 0x87B7, 0x87B8, 0x87B9, 0x87BB, 0x87BC,
0x87BE, 0x87BF, 0x87C1, 0x87C2, 0x87C3, 0x87C4, 0x87C5, 0x87C7,
0x87C8, 0x87C9, 0x87CC, 0x87CD, 0x87CE, 0x87CF, 0x87D0, 0x87D4,
0x87D5, 0x87D6, 0x87D7, 0x87D8, 0x87D9, 0x87DA, 0x87DC, 0x87DD,
0x87DE, 0x87DF, 0x87E1, 0x87E2, 0x87E3, 0x87E4, 0x87E6, 0x87E7,
0x87E8, 0x87E9, 0x87EB, 0x87EC, 0x87ED, 0x87EF, 0x87F0, 0x87F1,
0x87F2, 0x87F3, 0x87F4, 0x87F5, 0x87F6, 0x87F7, 0x87F8, 0x87FA,
0x87FB, 0x87FC, 0x87FD, 0x87FF, 0x8800, 0x8801, 0x8802, 0x8804,
0x8805, 0x8806, 0x8807, 0x8808, 0x8809, 0x880B, 0x880C, 0x880D,
0x880E, 0x880F, 0x8810, 0x8811, 0x8812, 0x8814, 0x8817, 0x8818,
0x8819, 0x881A, 0x881C, 0x881D, 0x881E, 0x881F, 0x8820, 0x8823,
0x8824, 0x8825, 0x8826, 0x8827, 0x8828, 0x8829, 0x882A, 0x882B,
0x882C, 0x882D, 0x882E, 0x882F, 0x8830, 0x8831, 0x8833, 0x8834,
0x8835, 0x8836, 0x8837, 0x8838, 0x883A, 0x883B, 0x883D, 0x883E,
0x883F, 0x8841, 0x8842, 0x8843, 0x8846, 0x8847, 0x8848, 0x8849,
0x884A, 0x884B, 0x884E, 0x884F, 0x8850, 0x8851, 0x8852, 0x8853,
0x8855, 0x8856, 0x8858, 0x885A, 0x885B, 0x885C, 0x885D, 0x885E,
0x885F, 0x8860, 0x8866, 0x8867, 0x886A, 0x886D, 0x886F, 0x8871,
0x8873, 0x8874, 0x8875, 0x8876, 0x8878, 0x8879, 0x887A, 0x887B,
0x887C, 0x8880, 0x8883, 0x8886, 0x8887, 0x8889, 0x888A, 0x888C,
0x888E, 0x888F, 0x8890, 0x8891, 0x8893, 0x8894, 0x8895, 0x8897,
0x8898, 0x8899, 0x889A, 0x889B, 0x889D, 0x889E, 0x889F, 0x88A0,
0x88A1, 0x88A3, 0x88A5, 0x88A6, 0x88A7, 0x88A8, 0x88A9, 0x88AA,
0x88AC, 0x88AE, 0x88AF, 0x88B0, 0x88B2, 0x88B3, 0x88B4, 0x88B5,
0x88B6, 0x88B8, 0x88B9, 0x88BA, 0x88BB, 0x88BD, 0x88BE, 0x88BF,
0x88C0, 0x88C3, 0x88C4, 0x88C7, 0x88C8, 0x88CA, 0x88CB, 0x88CC,
0x88CD, 0x88CF, 0x88D0, 0x88D1, 0x88D3, 0x88D6, 0x88D7, 0x88DA,
0x88DB, 0x88DC, 0x88DD, 0x88DE, 0x88E0, 0x88E1, 0x88E6, 0x88E7,
0x88E9, 0x88EA, 0x88EB, 0x88EC, 0x88ED, 0x88EE, 0x88EF, 0x88F2,
0x88F5, 0x88F6, 0x88F7, 0x88FA, 0x88FB, 0x88FD, 0x88FF, 0x8900,
0x8901, 0x8903, 0x8904, 0x8905, 0x8906, 0x8907, 0x8908, 0x8909,
0x890B, 0x890C, 0x890D, 0x890E, 0x890F, 0x8911, 0x8914, 0x8915,
0x8916, 0x8917, 0x8918, 0x891C, 0x891D, 0x891E, 0x891F, 0x8920,
0x8922, 0x8923, 0x8924, 0x8926, 0x8927, 0x8928, 0x8929, 0x892C,
0x892D, 0x892E, 0x892F, 0x8931, 0x8932, 0x8933, 0x8935, 0x8937,
0x8938, 0x8939, 0x893A, 0x893B, 0x893C, 0x893D, 0x893E, 0x893F,
0x8940, 0x8942, 0x8943, 0x8945, 0x8946, 0x8947, 0x8948, 0x8949,
0x894A, 0x894B, 0x894C, 0x894D, 0x894E, 0x894F, 0x8950, 0x8951,
0x8952, 0x8953, 0x8954, 0x8955, 0x8956, 0x8957, 0x8958, 0x8959,
0x895A, 0x895B, 0x895C, 0x895D, 0x8960, 0x8961, 0x8962, 0x8963,
0x8964, 0x8965, 0x8967, 0x8968, 0x8969, 0x896A, 0x896B, 0x896C,
0x896D, 0x896E, 0x896F, 0x8970, 0x8971, 0x8972, 0x8973, 0x8974,
0x8975, 0x8976, 0x8977, 0x8978, 0x8979, 0x897A, 0x897C, 0x897D,
0x897E, 0x8980, 0x8982, 0x8984, 0x8985, 0x8987, 0x8988, 0x8989,
0x898A, 0x898B, 0x898C, 0x898D, 0x898E, 0x898F, 0x8990, 0x8991,
0x8992, 0x8993, 0x8994, 0x8995, 0x8996, 0x8997, 0x8998, 0x8999,
0x899A, 0x899B, 0x899C, 0x899D, 0x899E, 0x899F, 0x89A0, 0x89A1,
0x89A2, 0x89A3, 0x89A4, 0x89A5, 0x89A6, 0x89A7, 0x89A8, 0x89A9,
0x89AA, 0x89AB, 0x89AC, 0x89AD, 0x89AE, 0x89AF, 0x89B0, 0x89B1,
0x89B2, 0x89B3, 0x89B4, 0x89B5, 0x89B6, 0x89B7, 0x89B8, 0x89B9,
0x89BA, 0x89BB, 0x89BC, 0x89BD, 0x89BE, 0x89BF, 0x89C0, 0x89C3,
0x89CD, 0x89D3, 0x89D4, 0x89D5, 0x89D7, 0x89D8, 0x89D9, 0x89DB,
0x89DD, 0x89DF, 0x89E0, 0x89E1, 0x89E2, 0x89E4, 0x89E7, 0x89E8,
0x89E9, 0x89EA, 0x89EC, 0x89ED, 0x89EE, 0x89F0, 0x89F1, 0x89F2,
0x89F4, 0x89F5, 0x89F6, 0x89F7, 0x89F8, 0x89F9, 0x89FA, 0x89FB,
0x89FC, 0x89FD, 0x89FE, 0x89FF, 0x8A01, 0x8A02, 0x8A03, 0x8A04,
0x8A05, 0x8A06, 0x8A08, 0x8A09, 0x8A0A, 0x8A0B, 0x8A0C, 0x8A0D,
0x8A0E, 0x8A0F, 0x8A10, 0x8A11, 0x8A12, 0x8A13, 0x8A14, 0x8A15,
0x8A16, 0x8A17, 0x8A18, 0x8A19, 0x8A1A, 0x8A1B, 0x8A1C, 0x8A1D,
0x8A1E, 0x8A1F, 0x8A20, 0x8A21, 0x8A22, 0x8A23, 0x8A24, 0x8A25,
0x8A26, 0x8A27, 0x8A28, 0x8A29, 0x8A2A, 0x8A2B, 0x8A2C, 0x8A2D,
0x8A2E, 0x8A2F, 0x8A30, 0x8A31, 0x8A32, 0x8A33, 0x8A34, 0x8A35,
0x8A36, 0x8A37, 0x8A38, 0x8A39, 0x8A3A, 0x8A3B, 0x8A3C, 0x8A3D,
0x8A3F, 0x8A40, 0x8A41, 0x8A42, 0x8A43, 0x8A44, 0x8A45, 0x8A46,
0x8A47, 0x8A49, 0x8A4A, 0x8A4B, 0x8A4C, 0x8A4D, 0x8A4E, 0x8A4F,
0x8A50, 0x8A51, 0x8A52, 0x8A53, 0x8A54, 0x8A55, 0x8A56, 0x8A57,
0x8A58, 0x8A59, 0x8A5A, 0x8A5B, 0x8A5C, 0x8A5D, 0x8A5E, 0x8A5F,
0x8A60, 0x8A61, 0x8A62, 0x8A63, 0x8A64, 0x8A65, 0x8A66, 0x8A67,
0x8A68, 0x8A69, 0x8A6A, 0x8A6B, 0x8A6C, 0x8A6D, 0x8A6E, 0x8A6F,
0x8A70, 0x8A71, 0x8A72, 0x8A73, 0x8A74, 0x8A75, 0x8A76, 0x8A77,
0x8A78, 0x8A7A, 0x8A7B, 0x8A7C, 0x8A7D, 0x8A7E, 0x8A7F, 0x8A80,
0x8A81, 0x8A82, 0x8A83, 0x8A84, 0x8A85, 0x8A86, 0x8A87, 0x8A88,
0x8A8B, 0x8A8C, 0x8A8D, 0x8A8E, 0x8A8F, 0x8A90, 0x8A91, 0x8A92,
0x8A94, 0x8A95, 0x8A96, 0x8A97, 0x8A98, 0x8A99, 0x8A9A, 0x8A9B,
0x8A9C, 0x8A9D, 0x8A9E, 0x8A9F, 0x8AA0, 0x8AA1, 0x8AA2, 0x8AA3,
0x8AA4, 0x8AA5, 0x8AA6, 0x8AA7, 0x8AA8, 0x8AA9, 0x8AAA, 0x8AAB,
0x8AAC, 0x8AAD, 0x8AAE, 0x8AAF, 0x8AB0, 0x8AB1, 0x8AB2, 0x8AB3,
0x8AB4, 0x8AB5, 0x8AB6, 0x8AB7, 0x8AB8, 0x8AB9, 0x8ABA, 0x8ABB,
0x8ABC, 0x8ABD, 0x8ABE, 0x8ABF, 0x8AC0, 0x8AC1, 0x8AC2, 0x8AC3,
0x8AC4, 0x8AC5, 0x8AC6, 0x8AC7, 0x8AC8, 0x8AC9, 0x8ACA, 0x8ACB,
0x8ACC, 0x8ACD, 0x8ACE, 0x8ACF, 0x8AD0, 0x8AD1, 0x8AD2, 0x8AD3,
0x8AD4, 0x8AD5, 0x8AD6, 0x8AD7, 0x8AD8, 0x8AD9, 0x8ADA, 0x8ADB,
0x8ADC, 0x8ADD, 0x8ADE, 0x8ADF, 0x8AE0, 0x8AE1, 0x8AE2, 0x8AE3,
0x8AE4, 0x8AE5, 0x8AE6, 0x8AE7, 0x8AE8, 0x8AE9, 0x8AEA, 0x8AEB,
0x8AEC, 0x8AED, 0x8AEE, 0x8AEF, 0x8AF0, 0x8AF1, 0x8AF2, 0x8AF3,
0x8AF4, 0x8AF5, 0x8AF6, 0x8AF7, 0x8AF8, 0x8AF9, 0x8AFA, 0x8AFB,
0x8AFC, 0x8AFD, 0x8AFE, 0x8AFF, 0x8B00, 0x8B01, 0x8B02, 0x8B03,
0x8B04, 0x8B05, 0x8B06, 0x8B08, 0x8B09, 0x8B0A, 0x8B0B, 0x8B0C,
0x8B0D, 0x8B0E, 0x8B0F, 0x8B10, 0x8B11, 0x8B12, 0x8B13, 0x8B14,
0x8B15, 0x8B16, 0x8B17, 0x8B18, 0x8B19, 0x8B1A, 0x8B1B, 0x8B1C,
0x8B1D, 0x8B1E, 0x8B1F, 0x8B20, 0x8B21, 0x8B22, 0x8B23, 0x8B24,
0x8B25, 0x8B27, 0x8B28, 0x8B29, 0x8B2A, 0x8B2B, 0x8B2C, 0x8B2D,
0x8B2E, 0x8B2F, 0x8B30, 0x8B31, 0x8B32, 0x8B33, 0x8B34, 0x8B35,
0x8B36, 0x8B37, 0x8B38, 0x8B39, 0x8B3A, 0x8B3B, 0x8B3C, 0x8B3D,
0x8B3E, 0x8B3F, 0x8B40, 0x8B41, 0x8B42, 0x8B43, 0x8B44, 0x8B45,
0x8B46, 0x8B47, 0x8B48, 0x8B49, 0x8B4A, 0x8B4B, 0x8B4C, 0x8B4D,
0x8B4E, 0x8B4F, 0x8B50, 0x8B51, 0x8B52, 0x8B53, 0x8B54, 0x8B55,
0x8B56, 0x8B57, 0x8B58, 0x8B59, 0x8B5A, 0x8B5B, 0x8B5C, 0x8B5D,
0x8B5E, 0x8B5F, 0x8B60, 0x8B61, 0x8B62, 0x8B63, 0x8B64, 0x8B65,
0x8B67, 0x8B68, 0x8B69, 0x8B6A, 0x8B6B, 0x8B6D, 0x8B6E, 0x8B6F,
0x8B70, 0x8B71, 0x8B72, 0x8B73, 0x8B74, 0x8B75, 0x8B76, 0x8B77,
0x8B78, 0x8B79, 0x8B7A, 0x8B7B, 0x8B7C, 0x8B7D, 0x8B7E, 0x8B7F,
0x8B80, 0x8B81, 0x8B82, 0x8B83, 0x8B84, 0x8B85, 0x8B86, 0x8B87,
0x8B88, 0x8B89, 0x8B8A, 0x8B8B, 0x8B8C, 0x8B8D, 0x8B8E, 0x8B8F,
0x8B90, 0x8B91, 0x8B92, 0x8B93, 0x8B94, 0x8B95, 0x8B96, 0x8B97,
0x8B98, 0x8B99, 0x8B9A, 0x8B9B, 0x8B9C, 0x8B9D, 0x8B9E, 0x8B9F,
0x8BAC, 0x8BB1, 0x8BBB, 0x8BC7, 0x8BD0, 0x8BEA, 0x8C09, 0x8C1E,
0x8C38, 0x8C39, 0x8C3A, 0x8C3B, 0x8C3C, 0x8C3D, 0x8C3E, 0x8C3F,
0x8C40, 0x8C42, 0x8C43, 0x8C44, 0x8C45, 0x8C48, 0x8C4A, 0x8C4B,
0x8C4D, 0x8C4E, 0x8C4F, 0x8C50, 0x8C51, 0x8C52, 0x8C53, 0x8C54,
0x8C56, 0x8C57, 0x8C58, 0x8C59, 0x8C5B, 0x8C5C, 0x8C5D, 0x8C5E,
0x8C5F, 0x8C60, 0x8C63, 0x8C64, 0x8C65, 0x8C66, 0x8C67, 0x8C68,
0x8C69, 0x8C6C, 0x8C6D, 0x8C6E, 0x8C6F, 0x8C70, 0x8C71, 0x8C72,
0x8C74, 0x8C75, 0x8C76, 0x8C77, 0x8C7B, 0x8C7C, 0x8C7D, 0x8C7E,
0x8C7F, 0x8C80, 0x8C81, 0x8C83, 0x8C84, 0x8C86, 0x8C87, 0x8C88,
0x8C8B, 0x8C8D, 0x8C8E, 0x8C8F, 0x8C90, 0x8C91, 0x8C92, 0x8C93,
0x8C95, 0x8C96, 0x8C97, 0x8C99, 0x8C9A, 0x8C9B, 0x8C9C, 0x8C9D,
0x8C9E, 0x8C9F, 0x8CA0, 0x8CA1, 0x8CA2, 0x8CA3, 0x8CA4, 0x8CA5,
0x8CA6, 0x8CA7, 0x8CA8, 0x8CA9, 0x8CAA, 0x8CAB, 0x8CAC, 0x8CAD,
0x8CAE, 0x8CAF, 0x8CB0, 0x8CB1, 0x8CB2, 0x8CB3, 0x8CB4, 0x8CB5,
0x8CB6, 0x8CB7, 0x8CB8, 0x8CB9, 0x8CBA, 0x8CBB, 0x8CBC, 0x8CBD,
0x8CBE, 0x8CBF, 0x8CC0, 0x8CC1, 0x8CC2, 0x8CC3, 0x8CC4, 0x8CC5,
0x8CC6, 0x8CC7, 0x8CC8, 0x8CC9, 0x8CCA, 0x8CCB, 0x8CCC, 0x8CCD,
0x8CCE, 0x8CCF, 0x8CD0, 0x8CD1, 0x8CD2, 0x8CD3, 0x8CD4, 0x8CD5,
0x8CD6, 0x8CD7, 0x8CD8, 0x8CD9, 0x8CDA, 0x8CDB, 0x8CDC, 0x8CDD,
0x8CDE, 0x8CDF, 0x8CE0, 0x8CE1, 0x8CE2, 0x8CE3, 0x8CE4, 0x8CE5,
0x8CE6, 0x8CE7, 0x8CE8, 0x8CE9, 0x8CEA, 0x8CEB, 0x8CEC, 0x8CED,
0x8CEE, 0x8CEF, 0x8CF0, 0x8CF1, 0x8CF2, 0x8CF3, 0x8CF4, 0x8CF5,
0x8CF6, 0x8CF7, 0x8CF8, 0x8CF9, 0x8CFA, 0x8CFB, 0x8CFC, 0x8CFD,
0x8CFE, 0x8CFF, 0x8D00, 0x8D01, 0x8D02, 0x8D03, 0x8D04, 0x8D05,
0x8D06, 0x8D07, 0x8D08, 0x8D09, 0x8D0A, 0x8D0B, 0x8D0C, 0x8D0D,
0x8D0E, 0x8D0F, 0x8D10, 0x8D11, 0x8D12, 0x8D13, 0x8D14, 0x8D15,
0x8D16, 0x8D17, 0x8D18, 0x8D19, 0x8D1A, 0x8D1B, 0x8D1C, 0x8D20,
0x8D51, 0x8D52, 0x8D57, 0x8D5F, 0x8D65, 0x8D68, 0x8D69, 0x8D6A,
0x8D6C, 0x8D6E, 0x8D6F, 0x8D71, 0x8D72, 0x8D78, 0x8D79, 0x8D7A,
0x8D7B, 0x8D7C, 0x8D7D, 0x8D7E, 0x8D7F, 0x8D80, 0x8D82, 0x8D83,
0x8D86, 0x8D87, 0x8D88, 0x8D89, 0x8D8C, 0x8D8D, 0x8D8E, 0x8D8F,
0x8D90, 0x8D92, 0x8D93, 0x8D95, 0x8D96, 0x8D97, 0x8D98, 0x8D99,
0x8D9A, 0x8D9B, 0x8D9C, 0x8D9D, 0x8D9E, 0x8DA0, 0x8DA1, 0x8DA2,
0x8DA4, 0x8DA5, 0x8DA6, 0x8DA7, 0x8DA8, 0x8DA9, 0x8DAA, 0x8DAB,
0x8DAC, 0x8DAD, 0x8DAE, 0x8DAF, 0x8DB0, 0x8DB2, 0x8DB6, 0x8DB7,
0x8DB9, 0x8DBB, 0x8DBD, 0x8DC0, 0x8DC1, 0x8DC2, 0x8DC5, 0x8DC7,
0x8DC8, 0x8DC9, 0x8DCA, 0x8DCD, 0x8DD0, 0x8DD2, 0x8DD3, 0x8DD4,
0x8DD5, 0x8DD8, 0x8DD9, 0x8DDC, 0x8DE0, 0x8DE1, 0x8DE2, 0x8DE5,
0x8DE6, 0x8DE7, 0x8DE9, 0x8DED, 0x8DEE, 0x8DF0, 0x8DF1, 0x8DF2,
0x8DF4, 0x8DF6, 0x8DFC, 0x8DFE, 0x8DFF, 0x8E00, 0x8E01, 0x8E02,
0x8E03, 0x8E04, 0x8E06, 0x8E07, 0x8E08, 0x8E0B, 0x8E0D, 0x8E0E,
0x8E10, 0x8E11, 0x8E12, 0x8E13, 0x8E15, 0x8E16, 0x8E17, 0x8E18,
0x8E19, 0x8E1A, 0x8E1B, 0x8E1C, 0x8E20, 0x8E21, 0x8E24, 0x8E25,
0x8E26, 0x8E27, 0x8E28, 0x8E2B, 0x8E2D, 0x8E30, 0x8E32, 0x8E33,
0x8E34, 0x8E36, 0x8E37, 0x8E38, 0x8E3B, 0x8E3C, 0x8E3E, 0x8E3F,
0x8E43, 0x8E45, 0x8E46, 0x8E4C, 0x8E4D, 0x8E4E, 0x8E4F, 0x8E50,
0x8E53, 0x8E54, 0x8E55, 0x8E56, 0x8E57, 0x8E58, 0x8E5A, 0x8E5B,
0x8E5C, 0x8E5D, 0x8E5E, 0x8E5F, 0x8E60, 0x8E61, 0x8E62, 0x8E63,
0x8E64, 0x8E65, 0x8E67, 0x8E68, 0x8E6A, 0x8E6B, 0x8E6E, 0x8E71,
0x8E73, 0x8E75, 0x8E77, 0x8E78, 0x8E79, 0x8E7A, 0x8E7B, 0x8E7D,
0x8E7E, 0x8E80, 0x8E82, 0x8E83, 0x8E84, 0x8E86, 0x8E88, 0x8E89,
0x8E8A, 0x8E8B, 0x8E8C, 0x8E8D, 0x8E8E, 0x8E91, 0x8E92, 0x8E93,
0x8E95, 0x8E96, 0x8E97, 0x8E98, 0x8E99, 0x8E9A, 0x8E9B, 0x8E9D,
0x8E9F, 0x8EA0, 0x8EA1, 0x8EA2, 0x8EA3, 0x8EA4, 0x8EA5, 0x8EA6,
0x8EA7, 0x8EA8, 0x8EA9, 0x8EAA, 0x8EAD, 0x8EAE, 0x8EB0, 0x8EB1,
0x8EB3, 0x8EB4, 0x8EB5, 0x8EB6, 0x8EB7, 0x8EB8, 0x8EB9, 0x8EBB,
0x8EBC, 0x8EBD, 0x8EBE, 0x8EBF, 0x8EC0, 0x8EC1, 0x8EC2, 0x8EC3,
0x8EC4, 0x8EC5, 0x8EC6, 0x8EC7, 0x8EC8, 0x8EC9, 0x8ECA, 0x8ECB,
0x8ECC, 0x8ECD, 0x8ECF, 0x8ED0, 0x8ED1, 0x8ED2, 0x8ED3, 0x8ED4,
0x8ED5, 0x8ED6, 0x8ED7, 0x8ED8, 0x8ED9, 0x8EDA, 0x8EDB, 0x8EDC,
0x8EDD, 0x8EDE, 0x8EDF, 0x8EE0, 0x8EE1, 0x8EE2, 0x8EE3, 0x8EE4,
0x8EE5, 0x8EE6, 0x8EE7, 0x8EE8, 0x8EE9, 0x8EEA, 0x8EEB, 0x8EEC,
0x8EED, 0x8EEE, 0x8EEF, 0x8EF0, 0x8EF1, 0x8EF2, 0x8EF3, 0x8EF4,
0x8EF5, 0x8EF6, 0x8EF7, 0x8EF8, 0x8EF9, 0x8EFA, 0x8EFB, 0x8EFC,
0x8EFD, 0x8EFE, 0x8EFF, 0x8F00, 0x8F01, 0x8F02, 0x8F03, 0x8F04,
0x8F05, 0x8F06, 0x8F07, 0x8F08, 0x8F09, 0x8F0A, 0x8F0B, 0x8F0C,
0x8F0D, 0x8F0E, 0x8F0F, 0x8F10, 0x8F11, 0x8F12, 0x8F13, 0x8F14,
0x8F15, 0x8F16, 0x8F17, 0x8F18, 0x8F19, 0x8F1A, 0x8F1B, 0x8F1C,
0x8F1D, 0x8F1E, 0x8F1F, 0x8F20, 0x8F21, 0x8F22, 0x8F23, 0x8F24,
0x8F25, 0x8F26, 0x8F27, 0x8F28, 0x8F29, 0x8F2A, 0x8F2B, 0x8F2C,
0x8F2D, 0x8F2E, 0x8F2F, 0x8F30, 0x8F31, 0x8F32, 0x8F33, 0x8F34,
0x8F35, 0x8F36, 0x8F37, 0x8F38, 0x8F39, 0x8F3A, 0x8F3B, 0x8F3C,
0x8F3D, 0x8F3E, 0x8F3F, 0x8F40, 0x8F41, 0x8F42, 0x8F43, 0x8F44,
0x8F45, 0x8F46, 0x8F47, 0x8F48, 0x8F49, 0x8F4A, 0x8F4B, 0x8F4C,
0x8F4D, 0x8F4E, 0x8F4F, 0x8F50, 0x8F51, 0x8F52, 0x8F53, 0x8F54,
0x8F55, 0x8F56, 0x8F57, 0x8F58, 0x8F59, 0x8F5A, 0x8F5B, 0x8F5C,
0x8F5D, 0x8F5E, 0x8F5F, 0x8F60, 0x8F61, 0x8F62, 0x8F63, 0x8F64,
0x8F65, 0x8F6A, 0x8F80, 0x8F8C, 0x8F92, 0x8F9D, 0x8FA0, 0x8FA1,
0x8FA2, 0x8FA4, 0x8FA5, 0x8FA6, 0x8FA7, 0x8FAA, 0x8FAC, 0x8FAD,
0x8FAE, 0x8FAF, 0x8FB2, 0x8FB3, 0x8FB4, 0x8FB5, 0x8FB7, 0x8FB8,
0x8FBA, 0x8FBB, 0x8FBC, 0x8FBF, 0x8FC0, 0x8FC3, 0x8FC6, 0x8FC9,
0x8FCA, 0x8FCB, 0x8FCC, 0x8FCD, 0x8FCF, 0x8FD2, 0x8FD6, 0x8FD7,
0x8FDA, 0x8FE0, 0x8FE1, 0x8FE3, 0x8FE7, 0x8FEC, 0x8FEF, 0x8FF1,
0x8FF2, 0x8FF4, 0x8FF5, 0x8FF6, 0x8FFA, 0x8FFB, 0x8FFC, 0x8FFE,
0x8FFF, 0x9007, 0x9008, 0x900C, 0x900E, 0x9013, 0x9015, 0x9018,
0x9019, 0x901C, 0x9023, 0x9024, 0x9025, 0x9027, 0x9028, 0x9029,
0x902A, 0x902B, 0x902C, 0x9030, 0x9031, 0x9032, 0x9033, 0x9034,
0x9037, 0x9039, 0x903A, 0x903D, 0x903F, 0x9040, 0x9043, 0x9045,
0x9046, 0x9048, 0x9049, 0x904A, 0x904B, 0x904C, 0x904E, 0x9054,
0x9055, 0x9056, 0x9059, 0x905A, 0x905C, 0x905D, 0x905E, 0x905F,
0x9060, 0x9061, 0x9064, 0x9066, 0x9067, 0x9069, 0x906A, 0x906B,
0x906C, 0x906F, 0x9070, 0x9071, 0x9072, 0x9073, 0x9076, 0x9077,
0x9078, 0x9079, 0x907A, 0x907B, 0x907C, 0x907E, 0x9081, 0x9084,
0x9085, 0x9086, 0x9087, 0x9089, 0x908A, 0x908C, 0x908D, 0x908E,
0x908F, 0x9090, 0x9092, 0x9094, 0x9096, 0x9098, 0x909A, 0x909C,
0x909E, 0x909F, 0x90A0, 0x90A4, 0x90A5, 0x90A7, 0x90A8, 0x90A9,
0x90AB, 0x90AD, 0x90B2, 0x90B7, 0x90BC, 0x90BD, 0x90BF, 0x90C0,
0x90C2, 0x90C3, 0x90C6, 0x90C8, 0x90C9, 0x90CB, 0x90CC, 0x90CD,
0x90D2, 0x90D4, 0x90D5, 0x90D6, 0x90D8, 0x90D9, 0x90DA, 0x90DE,
0x90DF, 0x90E0, 0x90E3, 0x90E4, 0x90E5, 0x90E9, 0x90EA, 0x90EC,
0x90EE, 0x90F0, 0x90F1, 0x90F2, 0x90F3, 0x90F5, 0x90F6, 0x90F7,
0x90F9, 0x90FA, 0x90FB, 0x90FC, 0x90FF, 0x9100, 0x9101, 0x9103,
0x9105, 0x9106, 0x9107, 0x9108, 0x9109, 0x910A, 0x910B, 0x910C,
0x910D, 0x910E, 0x910F, 0x9110, 0x9111, 0x9112, 0x9113, 0x9114,
0x9115, 0x9116, 0x9117, 0x9118, 0x911A, 0x911B, 0x911C, 0x911D,
0x911F, 0x9120, 0x9121, 0x9124, 0x9125, 0x9126, 0x9127, 0x9128,
0x9129, 0x912A, 0x912B, 0x912C, 0x912D, 0x912E, 0x9130, 0x9132,
0x9133, 0x9134, 0x9135, 0x9136, 0x9137, 0x9138, 0x913A, 0x913B,
0x913C, 0x913D, 0x913E, 0x913F, 0x9140, 0x9141, 0x9142, 0x9144,
0x9145, 0x9147, 0x9148, 0x9151, 0x9153, 0x9154, 0x9155, 0x9156,
0x9158, 0x9159, 0x915B, 0x915C, 0x915F, 0x9160, 0x9166, 0x9167,
0x9168, 0x916B, 0x916D, 0x9173, 0x917A, 0x917B, 0x917C, 0x9180,
0x9181, 0x9182, 0x9183, 0x9184, 0x9186, 0x9188, 0x918A, 0x918E,
0x918F, 0x9193, 0x9194, 0x9195, 0x9196, 0x9197, 0x9198, 0x9199,
0x919C, 0x919D, 0x919E, 0x919F, 0x91A0, 0x91A1, 0x91A4, 0x91A5,
0x91A6, 0x91A7, 0x91A8, 0x91A9, 0x91AB, 0x91AC, 0x91B0, 0x91B1,
0x91B2, 0x91B3, 0x91B6, 0x91B7, 0x91B8, 0x91B9, 0x91BB, 0x91BC,
0x91BD, 0x91BE, 0x91BF, 0x91C0, 0x91C1, 0x91C2, 0x91C3, 0x91C4,
0x91C5, 0x91C6, 0x91C8, 0x91CB, 0x91D0, 0x91D2, 0x91D3, 0x91D4,
0x91D5, 0x91D6, 0x91D7, 0x91D8, 0x91D9, 0x91DA, 0x91DB, 0x91DD,
0x91DE, 0x91DF, 0x91E0, 0x91E1, 0x91E2, 0x91E3, 0x91E4, 0x91E5,
0x91E6, 0x91E7, 0x91E8, 0x91E9, 0x91EA, 0x91EB, 0x91EC, 0x91ED,
0x91EE, 0x91EF, 0x91F0, 0x91F1, 0x91F2, 0x91F3, 0x91F4, 0x91F5,
0x91F6, 0x91F7, 0x91F8, 0x91F9, 0x91FA, 0x91FB, 0x91FC, 0x91FD,
0x91FE, 0x91FF, 0x9200, 0x9201, 0x9202, 0x9203, 0x9204, 0x9205,
0x9206, 0x9207, 0x9208, 0x9209, 0x920A, 0x920B, 0x920C, 0x920D,
0x920E, 0x920F, 0x9210, 0x9211, 0x9212, 0x9213, 0x9214, 0x9215,
0x9216, 0x9217, 0x9218, 0x9219, 0x921A, 0x921B, 0x921C, 0x921D,
0x921E, 0x921F, 0x9220, 0x9221, 0x9222, 0x9223, 0x9224, 0x9225,
0x9226, 0x9227, 0x9228, 0x9229, 0x922A, 0x922B, 0x922C, 0x922D,
0x922E, 0x922F, 0x9230, 0x9231, 0x9232, 0x9233, 0x9234, 0x9235,
0x9236, 0x9237, 0x9238, 0x9239, 0x923A, 0x923B, 0x923C, 0x923D,
0x923E, 0x923F, 0x9240, 0x9241, 0x9242, 0x9243, 0x9244, 0x9245,
0x9246, 0x9247, 0x9248, 0x9249, 0x924A, 0x924B, 0x924C, 0x924D,
0x924E, 0x924F, 0x9250, 0x9251, 0x9252, 0x9253, 0x9254, 0x9255,
0x9256, 0x9257, 0x9258, 0x9259, 0x925A, 0x925B, 0x925C, 0x925D,
0x925E, 0x925F, 0x9260, 0x9261, 0x9262, 0x9263, 0x9264, 0x9265,
0x9266, 0x9267, 0x9268, 0x9269, 0x926A, 0x926B, 0x926C, 0x926D,
0x926E, 0x926F, 0x9270, 0x9271, 0x9272, 0x9273, 0x9275, 0x9276,
0x9277, 0x9278, 0x9279, 0x927A, 0x927B, 0x927C, 0x927D, 0x927E,
0x927F, 0x9280, 0x9281, 0x9282, 0x9283, 0x9284, 0x9285, 0x9286,
0x9287, 0x9288, 0x9289, 0x928A, 0x928B, 0x928C, 0x928D, 0x928F,
0x9290, 0x9291, 0x9292, 0x9293, 0x9294, 0x9295, 0x9296, 0x9297,
0x9298, 0x9299, 0x929A, 0x929B, 0x929C, 0x929D, 0x929E, 0x929F,
0x92A0, 0x92A1, 0x92A2, 0x92A3, 0x92A4, 0x92A5, 0x92A6, 0x92A7,
0x92A8, 0x92A9, 0x92AA, 0x92AB, 0x92AC, 0x92AD, 0x92AF, 0x92B0,
0x92B1, 0x92B2, 0x92B3, 0x92B4, 0x92B5, 0x92B6, 0x92B7, 0x92B8,
0x92B9, 0x92BA, 0x92BB, 0x92BC, 0x92BD, 0x92BE, 0x92BF, 0x92C0,
0x92C1, 0x92C2, 0x92C3, 0x92C4, 0x92C5, 0x92C6, 0x92C7, 0x92C9,
0x92CA, 0x92CB, 0x92CC, 0x92CD, 0x92CE, 0x92CF, 0x92D0, 0x92D1,
0x92D2, 0x92D3, 0x92D4, 0x92D5, 0x92D6, 0x92D7, 0x92D8, 0x92D9,
0x92DA, 0x92DB, 0x92DC, 0x92DD, 0x92DE, 0x92DF, 0x92E0, 0x92E1,
0x92E2, 0x92E3, 0x92E4, 0x92E5, 0x92E6, 0x92E7, 0x92E8, 0x92E9,
0x92EA, 0x92EB, 0x92EC, 0x92ED, 0x92EE, 0x92EF, 0x92F0, 0x92F1,
0x92F2, 0x92F3, 0x92F4, 0x92F5, 0x92F6, 0x92F7, 0x92F8, 0x92F9,
0x92FA, 0x92FB, 0x92FC, 0x92FD, 0x92FE, 0x92FF, 0x9300, 0x9301,
0x9302, 0x9303, 0x9304, 0x9305, 0x9306, 0x9307, 0x9308, 0x9309,
0x930A, 0x930B, 0x930C, 0x930D, 0x930E, 0x930F, 0x9310, 0x9311,
0x9312, 0x9313, 0x9314, 0x9315, 0x9316, 0x9317, 0x9318, 0x9319,
0x931A, 0x931B, 0x931C, 0x931D, 0x931E, 0x931F, 0x9320, 0x9321,
0x9322, 0x9323, 0x9324, 0x9325, 0x9326, 0x9327, 0x9328, 0x9329,
0x932A, 0x932B, 0x932C, 0x932D, 0x932E, 0x932F, 0x9330, 0x9331,
0x9332, 0x9333, 0x9334, 0x9335, 0x9336, 0x9337, 0x9338, 0x9339,
0x933A, 0x933B, 0x933C, 0x933D, 0x933F, 0x9340, 0x9341, 0x9342,
0x9343, 0x9344, 0x9345, 0x9346, 0x9347, 0x9348, 0x9349, 0x934A,
0x934B, 0x934C, 0x934D, 0x934E, 0x934F, 0x9350, 0x9351, 0x9352,
0x9353, 0x9354, 0x9355, 0x9356, 0x9357, 0x9358, 0x9359, 0x935A,
0x935B, 0x935C, 0x935D, 0x935E, 0x935F, 0x9360, 0x9361, 0x9362,
0x9363, 0x9364, 0x9365, 0x9366, 0x9367, 0x9368, 0x9369, 0x936B,
0x936C, 0x936D, 0x936E, 0x936F, 0x9370, 0x9371, 0x9372, 0x9373,
0x9374, 0x9375, 0x9376, 0x9377, 0x9378, 0x9379, 0x937A, 0x937B,
0x937C, 0x937D, 0x937E, 0x937F, 0x9380, 0x9381, 0x9382, 0x9383,
0x9384, 0x9385, 0x9386, 0x9387, 0x9388, 0x9389, 0x938A, 0x938B,
0x938C, 0x938D, 0x938E, 0x9390, 0x9391, 0x9392, 0x9393, 0x9394,
0x9395, 0x9396, 0x9397, 0x9398, 0x9399, 0x939A, 0x939B, 0x939C,
0x939D, 0x939E, 0x939F, 0x93A0, 0x93A1, 0x93A2, 0x93A3, 0x93A4,
0x93A5, 0x93A6, 0x93A7, 0x93A8, 0x93A9, 0x93AA, 0x93AB, 0x93AC,
0x93AD, 0x93AE, 0x93AF, 0x93B0, 0x93B1, 0x93B2, 0x93B3, 0x93B4,
0x93B5, 0x93B6, 0x93B7, 0x93B8, 0x93B9, 0x93BA, 0x93BB, 0x93BC,
0x93BD, 0x93BE, 0x93BF, 0x93C0, 0x93C1, 0x93C2, 0x93C3, 0x93C4,
0x93C5, 0x93C6, 0x93C7, 0x93C8, 0x93C9, 0x93CB, 0x93CC, 0x93CD,
0x93CE, 0x93CF, 0x93D0, 0x93D1, 0x93D2, 0x93D3, 0x93D4, 0x93D5,
0x93D7, 0x93D8, 0x93D9, 0x93DA, 0x93DB, 0x93DC, 0x93DD, 0x93DE,
0x93DF, 0x93E0, 0x93E1, 0x93E2, 0x93E3, 0x93E4, 0x93E5, 0x93E6,
0x93E7, 0x93E8, 0x93E9, 0x93EA, 0x93EB, 0x93EC, 0x93ED, 0x93EE,
0x93EF, 0x93F0, 0x93F1, 0x93F2, 0x93F3, 0x93F4, 0x93F5, 0x93F6,
0x93F7, 0x93F8, 0x93F9, 0x93FA, 0x93FB, 0x93FC, 0x93FD, 0x93FE,
0x93FF, 0x9400, 0x9401, 0x9402, 0x9403, 0x9404, 0x9405, 0x9406,
0x9407, 0x9408, 0x9409, 0x940A, 0x940B, 0x940C, 0x940D, 0x940E,
0x940F, 0x9410, 0x9411, 0x9412, 0x9413, 0x9414, 0x9415, 0x9416,
0x9417, 0x9418, 0x9419, 0x941A, 0x941B, 0x941C, 0x941D, 0x941E,
0x941F, 0x9420, 0x9421, 0x9422, 0x9423, 0x9424, 0x9425, 0x9426,
0x9427, 0x9428, 0x9429, 0x942A, 0x942B, 0x942C, 0x942D, 0x942E,
0x942F, 0x9430, 0x9431, 0x9432, 0x9433, 0x9434, 0x9435, 0x9436,
0x9437, 0x9438, 0x9439, 0x943A, 0x943B, 0x943C, 0x943D, 0x943F,
0x9440, 0x9441, 0x9442, 0x9443, 0x9444, 0x9445, 0x9446, 0x9447,
0x9448, 0x9449, 0x944A, 0x944B, 0x944C, 0x944D, 0x944E, 0x944F,
0x9450, 0x9451, 0x9452, 0x9453, 0x9454, 0x9455, 0x9456, 0x9457,
0x9458, 0x9459, 0x945A, 0x945B, 0x945C, 0x945D, 0x945E, 0x945F,
0x9460, 0x9461, 0x9462, 0x9463, 0x9464, 0x9465, 0x9466, 0x9467,
0x9468, 0x9469, 0x946A, 0x946C, 0x946D, 0x946E, 0x946F, 0x9470,
0x9471, 0x9472, 0x9473, 0x9474, 0x9475, 0x9476, 0x9477, 0x9478,
0x9479, 0x947A, 0x947B, 0x947C, 0x947D, 0x947E, 0x947F, 0x9480,
0x9481, 0x9482, 0x9483, 0x9484, 0x9491, 0x9496, 0x9498, 0x94C7,
0x94CF, 0x94D3, 0x94D4, 0x94DA, 0x94E6, 0x94FB, 0x951C, 0x9520,
0x9527, 0x9533, 0x953D, 0x9543, 0x9548, 0x954B, 0x9555, 0x955A,
0x9560, 0x956E, 0x9574, 0x9575, 0x9577, 0x9578, 0x9579, 0x957A,
0x957B, 0x957C, 0x957D, 0x957E, 0x9580, 0x9581, 0x9582, 0x9583,
0x9584, 0x9585, 0x9586, 0x9587, 0x9588, 0x9589, 0x958A, 0x958B,
0x958C, 0x958D, 0x958E, 0x958F, 0x9590, 0x9591, 0x9592, 0x9593,
0x9594, 0x9595, 0x9596, 0x9597, 0x9598, 0x9599, 0x959A, 0x959B,
0x959C, 0x959D, 0x959E, 0x959F, 0x95A0, 0x95A1, 0x95A2, 0x95A3,
0x95A4, 0x95A5, 0x95A6, 0x95A7, 0x95A8, 0x95A9, 0x95AA, 0x95AB,
0x95AC, 0x95AD, 0x95AE, 0x95AF, 0x95B0, 0x95B1, 0x95B2, 0x95B3,
0x95B4, 0x95B5, 0x95B6, 0x95B7, 0x95B8, 0x95B9, 0x95BA, 0x95BB,
0x95BC, 0x95BD, 0x95BE, 0x95BF, 0x95C0, 0x95C1, 0x95C2, 0x95C3,
0x95C4, 0x95C5, 0x95C6, 0x95C7, 0x95C8, 0x95C9, 0x95CA, 0x95CB,
0x95CC, 0x95CD, 0x95CE, 0x95CF, 0x95D0, 0x95D1, 0x95D2, 0x95D3,
0x95D4, 0x95D5, 0x95D6, 0x95D7, 0x95D8, 0x95D9, 0x95DA, 0x95DB,
0x95DC, 0x95DD, 0x95DE, 0x95DF, 0x95E0, 0x95E1, 0x95E2, 0x95E3,
0x95E4, 0x95E5, 0x95E6, 0x95E7, 0x95EC, 0x95FF, 0x9607, 0x9613,
0x9618, 0x961B, 0x961E, 0x9620, 0x9623, 0x9624, 0x9625, 0x9626,
0x9627, 0x9628, 0x9629, 0x962B, 0x962C, 0x962D, 0x962F, 0x9630,
0x9637, 0x9638, 0x9639, 0x963A, 0x963E, 0x9641, 0x9643, 0x964A,
0x964E, 0x964F, 0x9651, 0x9652, 0x9653, 0x9656, 0x9657, 0x9658,
0x9659, 0x965A, 0x965C, 0x965D, 0x965E, 0x9660, 0x9663, 0x9665,
0x9666, 0x966B, 0x966D, 0x966E, 0x966F, 0x9670, 0x9671, 0x9673,
0x9678, 0x9679, 0x967A, 0x967B, 0x967C, 0x967D, 0x967E, 0x967F,
0x9680, 0x9681, 0x9682, 0x9683, 0x9684, 0x9687, 0x9689, 0x968A,
0x968C, 0x968E, 0x9691, 0x9692, 0x9693, 0x9695, 0x9696, 0x969A,
0x969B, 0x969D, 0x969E, 0x969F, 0x96A0, 0x96A1, 0x96A2, 0x96A3,
0x96A4, 0x96A5, 0x96A6, 0x96A8, 0x96A9, 0x96AA, 0x96AB, 0x96AC,
0x96AD, 0x96AE, 0x96AF, 0x96B1, 0x96B2, 0x96B4, 0x96B5, 0x96B7,
0x96B8, 0x96BA, 0x96BB, 0x96BF, 0x96C2, 0x96C3, 0x96C8, 0x96CA,
0x96CB, 0x96D0, 0x96D1, 0x96D3, 0x96D4, 0x96D6, 0x96D7, 0x96D8,
0x96D9, 0x96DA, 0x96DB, 0x96DC, 0x96DD, 0x96DE, 0x96DF, 0x96E1,
0x96E2, 0x96E3, 0x96E4, 0x96E5, 0x96E6, 0x96E7, 0x96EB, 0x96EC,
0x96ED, 0x96EE, 0x96F0, 0x96F1, 0x96F2, 0x96F4, 0x96F5, 0x96F8,
0x96FA, 0x96FB, 0x96FC, 0x96FD, 0x96FF, 0x9702, 0x9703, 0x9705,
0x970A, 0x970B, 0x970C, 0x9710, 0x9711, 0x9712, 0x9714, 0x9715,
0x9717, 0x9718, 0x9719, 0x971A, 0x971B, 0x971D, 0x971F, 0x9720,
0x9721, 0x9722, 0x9723, 0x9724, 0x9725, 0x9726, 0x9727, 0x9728,
0x9729, 0x972B, 0x972C, 0x972E, 0x972F, 0x9731, 0x9733, 0x9734,
0x9735, 0x9736, 0x9737, 0x973A, 0x973B, 0x973C, 0x973D, 0x973F,
0x9740, 0x9741, 0x9742, 0x9743, 0x9744, 0x9745, 0x9746, 0x9747,
0x9748, 0x9749, 0x974A, 0x974B, 0x974C, 0x974D, 0x974E, 0x974F,
0x9750, 0x9751, 0x9754, 0x9755, 0x9757, 0x9758, 0x975A, 0x975C,
0x975D, 0x975F, 0x9763, 0x9764, 0x9766, 0x9767, 0x9768, 0x976A,
0x976B, 0x976C, 0x976D, 0x976E, 0x976F, 0x9770, 0x9771, 0x9772,
0x9775, 0x9777, 0x9778, 0x9779, 0x977A, 0x977B, 0x977D, 0x977E,
0x977F, 0x9780, 0x9781, 0x9782, 0x9783, 0x9784, 0x9786, 0x9787,
0x9788, 0x9789, 0x978A, 0x978C, 0x978E, 0x978F, 0x9790, 0x9793,
0x9795, 0x9796, 0x9797, 0x9799, 0x979A, 0x979B, 0x979C, 0x979D,
0x979E, 0x979F, 0x97A1, 0x97A2, 0x97A4, 0x97A5, 0x97A6, 0x97A7,
0x97A8, 0x97A9, 0x97AA, 0x97AC, 0x97AE, 0x97B0, 0x97B1, 0x97B3,
0x97B5, 0x97B6, 0x97B7, 0x97B8, 0x97B9, 0x97BA, 0x97BB, 0x97BC,
0x97BD, 0x97BE, 0x97BF, 0x97C0, 0x97C1, 0x97C2, 0x97C3, 0x97C4,
0x97C5, 0x97C6, 0x97C7, 0x97C8, 0x97C9, 0x97CA, 0x97CB, 0x97CC,
0x97CD, 0x97CE, 0x97CF, 0x97D0, 0x97D1, 0x97D2, 0x97D3, 0x97D4,
0x97D5, 0x97D6, 0x97D7, 0x97D8, 0x97D9, 0x97DA, 0x97DB, 0x97DC,
0x97DD, 0x97DE, 0x97DF, 0x97E0, 0x97E1, 0x97E2, 0x97E3, 0x97E4,
0x97E5, 0x97E8, 0x97EE, 0x97EF, 0x97F0, 0x97F1, 0x97F2, 0x97F4,
0x97F7, 0x97F8, 0x97F9, 0x97FA, 0x97FB, 0x97FC, 0x97FD, 0x97FE,
0x97FF, 0x9800, 0x9801, 0x9802, 0x9803, 0x9804, 0x9805, 0x9806,
0x9807, 0x9808, 0x9809, 0x980A, 0x980B, 0x980C, 0x980D, 0x980E,
0x980F, 0x9810, 0x9811, 0x9812, 0x9813, 0x9814, 0x9815, 0x9816,
0x9817, 0x9818, 0x9819, 0x981A, 0x981B, 0x981C, 0x981D, 0x981E,
0x981F, 0x9820, 0x9821, 0x9822, 0x9823, 0x9824, 0x9825, 0x9826,
0x9827, 0x9828, 0x9829, 0x982A, 0x982B, 0x982C, 0x982D, 0x982E,
0x982F, 0x9830, 0x9831, 0x9832, 0x9833, 0x9834, 0x9835, 0x9836,
0x9837, 0x9838, 0x9839, 0x983A, 0x983B, 0x983C, 0x983D, 0x983E,
0x983F, 0x9840, 0x9841, 0x9842, 0x9843, 0x9844, 0x9845, 0x9846,
0x9847, 0x9848, 0x9849, 0x984A, 0x984B, 0x984C, 0x984D, 0x984E,
0x984F, 0x9850, 0x9851, 0x9852, 0x9853, 0x9854, 0x9855, 0x9856,
0x9857, 0x9858, 0x9859, 0x985A, 0x985B, 0x985C, 0x985D, 0x985E,
0x985F, 0x9860, 0x9861, 0x9862, 0x9863, 0x9864, 0x9865, 0x9866,
0x9867, 0x9868, 0x9869, 0x986A, 0x986B, 0x986C, 0x986D, 0x986E,
0x986F, 0x9870, 0x9871, 0x9872, 0x9873, 0x9874, 0x988B, 0x988E,
0x9892, 0x9895, 0x9899, 0x98A3, 0x98A8, 0x98A9, 0x98AA, 0x98AB,
0x98AC, 0x98AD, 0x98AE, 0x98AF, 0x98B0, 0x98B1, 0x98B2, 0x98B3,
0x98B4, 0x98B5, 0x98B6, 0x98B7, 0x98B8, 0x98B9, 0x98BA, 0x98BB,
0x98BC, 0x98BD, 0x98BE, 0x98BF, 0x98C0, 0x98C1, 0x98C2, 0x98C3,
0x98C4, 0x98C5, 0x98C6, 0x98C7, 0x98C8, 0x98C9, 0x98CA, 0x98CB,
0x98CC, 0x98CD, 0x98CF, 0x98D0, 0x98D4, 0x98D6, 0x98D7, 0x98DB,
0x98DC, 0x98DD, 0x98E0, 0x98E1, 0x98E2, 0x98E3, 0x98E4, 0x98E5,
0x98E6, 0x98E9, 0x98EA, 0x98EB, 0x98EC, 0x98ED, 0x98EE, 0x98EF,
0x98F0, 0x98F1, 0x98F2, 0x98F3, 0x98F4, 0x98F5, 0x98F6, 0x98F7,
0x98F8, 0x98F9, 0x98FA, 0x98FB, 0x98FC, 0x98FD, 0x98FE, 0x98FF,
0x9900, 0x9901, 0x9902, 0x9903, 0x9904, 0x9905, 0x9906, 0x9907,
0x9908, 0x9909, 0x990A, 0x990B, 0x990C, 0x990E, 0x990F, 0x9911,
0x9912, 0x9913, 0x9914, 0x9915, 0x9916, 0x9917, 0x9918, 0x9919,
0x991A, 0x991B, 0x991C, 0x991D, 0x991E, 0x991F, 0x9920, 0x9921,
0x9922, 0x9923, 0x9924, 0x9925, 0x9926, 0x9927, 0x9928, 0x9929,
0x992A, 0x992B, 0x992C, 0x992D, 0x992F, 0x9930, 0x9931, 0x9932,
0x9933, 0x9934, 0x9935, 0x9936, 0x9937, 0x9938, 0x9939, 0x993A,
0x993B, 0x993C, 0x993D, 0x993E, 0x993F, 0x9940, 0x9941, 0x9942,
0x9943, 0x9944, 0x9945, 0x9946, 0x9947, 0x9948, 0x9949, 0x994A,
0x994B, 0x994C, 0x994D, 0x994E, 0x994F, 0x9950, 0x9951, 0x9952,
0x9953, 0x9956, 0x9957, 0x9958, 0x9959, 0x995A, 0x995B, 0x995C,
0x995D, 0x995E, 0x995F, 0x9960, 0x9961, 0x9962, 0x9964, 0x9966,
0x9973, 0x9978, 0x9979, 0x997B, 0x997E, 0x9982, 0x9983, 0x9989,
0x998C, 0x998E, 0x999A, 0x999B, 0x999C, 0x999D, 0x999E, 0x999F,
0x99A0, 0x99A1, 0x99A2, 0x99A3, 0x99A4, 0x99A6, 0x99A7, 0x99A9,
0x99AA, 0x99AB, 0x99AC, 0x99AD, 0x99AE, 0x99AF, 0x99B0, 0x99B1,
0x99B2, 0x99B3, 0x99B4, 0x99B5, 0x99B6, 0x99B7, 0x99B8, 0x99B9,
0x99BA, 0x99BB, 0x99BC, 0x99BD, 0x99BE, 0x99BF, 0x99C0, 0x99C1,
0x99C2, 0x99C3, 0x99C4, 0x99C5, 0x99C6, 0x99C7, 0x99C8, 0x99C9,
0x99CA, 0x99CB, 0x99CC, 0x99CD, 0x99CE, 0x99CF, 0x99D0, 0x99D1,
0x99D2, 0x99D3, 0x99D4, 0x99D5, 0x99D6, 0x99D7, 0x99D8, 0x99D9,
0x99DA, 0x99DB, 0x99DC, 0x99DD, 0x99DE, 0x99DF, 0x99E0, 0x99E1,
0x99E2, 0x99E3, 0x99E4, 0x99E5, 0x99E6, 0x99E7, 0x99E8, 0x99E9,
0x99EA, 0x99EB, 0x99EC, 0x99ED, 0x99EE, 0x99EF, 0x99F0, 0x99F1,
0x99F2, 0x99F3, 0x99F4, 0x99F5, 0x99F6, 0x99F7, 0x99F8, 0x99F9,
0x99FA, 0x99FB, 0x99FC, 0x99FD, 0x99FE, 0x99FF, 0x9A00, 0x9A01,
0x9A02, 0x9A03, 0x9A04, 0x9A05, 0x9A06, 0x9A07, 0x9A08, 0x9A09,
0x9A0A, 0x9A0B, 0x9A0C, 0x9A0D, 0x9A0E, 0x9A0F, 0x9A10, 0x9A11,
0x9A12, 0x9A13, 0x9A14, 0x9A15, 0x9A16, 0x9A17, 0x9A18, 0x9A19,
0x9A1A, 0x9A1B, 0x9A1C, 0x9A1D, 0x9A1E, 0x9A1F, 0x9A20, 0x9A21,
0x9A22, 0x9A23, 0x9A24, 0x9A25, 0x9A26, 0x9A27, 0x9A28, 0x9A29,
0x9A2A, 0x9A2B, 0x9A2C, 0x9A2D, 0x9A2E, 0x9A2F, 0x9A30, 0x9A31,
0x9A32, 0x9A33, 0x9A34, 0x9A35, 0x9A36, 0x9A37, 0x9A38, 0x9A39,
0x9A3A, 0x9A3B, 0x9A3C, 0x9A3D, 0x9A3E, 0x9A3F, 0x9A40, 0x9A41,
0x9A42, 0x9A43, 0x9A44, 0x9A45, 0x9A46, 0x9A47, 0x9A48, 0x9A49,
0x9A4A, 0x9A4B, 0x9A4C, 0x9A4D, 0x9A4E, 0x9A4F, 0x9A50, 0x9A51,
0x9A52, 0x9A53, 0x9A54, 0x9A55, 0x9A56, 0x9A57, 0x9A58, 0x9A59,
0x9A5A, 0x9A5B, 0x9A5C, 0x9A5D, 0x9A5E, 0x9A5F, 0x9A60, 0x9A61,
0x9A62, 0x9A63, 0x9A64, 0x9A65, 0x9A66, 0x9A67, 0x9A68, 0x9A69,
0x9A6A, 0x9A6B, 0x9A72, 0x9A83, 0x9A89, 0x9A8D, 0x9A8E, 0x9A94,
0x9A95, 0x9A99, 0x9AA6, 0x9AA9, 0x9AAA, 0x9AAB, 0x9AAC, 0x9AAD,
0x9AAE, 0x9AAF, 0x9AB2, 0x9AB3, 0x9AB4, 0x9AB5, 0x9AB9, 0x9ABB,
0x9ABD, 0x9ABE, 0x9ABF, 0x9AC3, 0x9AC4, 0x9AC6, 0x9AC7, 0x9AC8,
0x9AC9, 0x9ACA, 0x9ACD, 0x9ACE, 0x9ACF, 0x9AD0, 0x9AD2, 0x9AD4,
0x9AD5, 0x9AD6, 0x9AD7, 0x9AD9, 0x9ADA, 0x9ADB, 0x9ADC, 0x9ADD,
0x9ADE, 0x9AE0, 0x9AE2, 0x9AE3, 0x9AE4, 0x9AE5, 0x9AE7, 0x9AE8,
0x9AE9, 0x9AEA, 0x9AEC, 0x9AEE, 0x9AF0, 0x9AF1, 0x9AF2, 0x9AF3,
0x9AF4, 0x9AF5, 0x9AF6, 0x9AF7, 0x9AF8, 0x9AFA, 0x9AFC, 0x9AFD,
0x9AFE, 0x9AFF, 0x9B00, 0x9B01, 0x9B02, 0x9B04, 0x9B05, 0x9B06,
0x9B07, 0x9B09, 0x9B0A, 0x9B0B, 0x9B0C, 0x9B0D, 0x9B0E, 0x9B10,
0x9B11, 0x9B12, 0x9B14, 0x9B15, 0x9B16, 0x9B17, 0x9B18, 0x9B19,
0x9B1A, 0x9B1B, 0x9B1C, 0x9B1D, 0x9B1E, 0x9B20, 0x9B21, 0x9B22,
0x9B24, 0x9B25, 0x9B26, 0x9B27, 0x9B28, 0x9B29, 0x9B2A, 0x9B2B,
0x9B2C, 0x9B2D, 0x9B2E, 0x9B30, 0x9B31, 0x9B33, 0x9B34, 0x9B35,
0x9B36, 0x9B37, 0x9B38, 0x9B39, 0x9B3A, 0x9B3D, 0x9B3E, 0x9B3F,
0x9B40, 0x9B46, 0x9B4A, 0x9B4B, 0x9B4C, 0x9B4E, 0x9B50, 0x9B52,
0x9B53, 0x9B55, 0x9B56, 0x9B57, 0x9B58, 0x9B59, 0x9B5A, 0x9B5B,
0x9B5C, 0x9B5D, 0x9B5E, 0x9B5F, 0x9B60, 0x9B61, 0x9B62, 0x9B63,
0x9B64, 0x9B65, 0x9B66, 0x9B67, 0x9B68, 0x9B69, 0x9B6A, 0x9B6B,
0x9B6C, 0x9B6D, 0x9B6E, 0x9B6F, 0x9B70, 0x9B71, 0x9B72, 0x9B73,
0x9B74, 0x9B75, 0x9B76, 0x9B77, 0x9B78, 0x9B79, 0x9B7A, 0x9B7B,
0x9B7C, 0x9B7D, 0x9B7E, 0x9B7F, 0x9B80, 0x9B81, 0x9B82, 0x9B83,
0x9B84, 0x9B85, 0x9B86, 0x9B87, 0x9B88, 0x9B89, 0x9B8A, 0x9B8B,
0x9B8C, 0x9B8D, 0x9B8E, 0x9B8F, 0x9B90, 0x9B91, 0x9B92, 0x9B93,
0x9B94, 0x9B95, 0x9B96, 0x9B97, 0x9B98, 0x9B99, 0x9B9A, 0x9B9B,
0x9B9C, 0x9B9D, 0x9B9E, 0x9B9F, 0x9BA0, 0x9BA1, 0x9BA2, 0x9BA3,
0x9BA4, 0x9BA5, 0x9BA6, 0x9BA7, 0x9BA8, 0x9BA9, 0x9BAA, 0x9BAB,
0x9BAC, 0x9BAD, 0x9BAE, 0x9BAF, 0x9BB0, 0x9BB1, 0x9BB2, 0x9BB3,
0x9BB4, 0x9BB5, 0x9BB6, 0x9BB7, 0x9BB8, 0x9BB9, 0x9BBA, 0x9BBB,
0x9BBC, 0x9BBD, 0x9BBE, 0x9BBF, 0x9BC0, 0x9BC1, 0x9BC2, 0x9BC3,
0x9BC4, 0x9BC5, 0x9BC6, 0x9BC7, 0x9BC8, 0x9BC9, 0x9BCA, 0x9BCB,
0x9BCC, 0x9BCD, 0x9BCE, 0x9BCF, 0x9BD0, 0x9BD1, 0x9BD2, 0x9BD3,
0x9BD4, 0x9BD5, 0x9BD6, 0x9BD7, 0x9BD8, 0x9BD9, 0x9BDA, 0x9BDB,
0x9BDC, 0x9BDD, 0x9BDE, 0x9BDF, 0x9BE0, 0x9BE1, 0x9BE2, 0x9BE3,
0x9BE4, 0x9BE5, 0x9BE6, 0x9BE7, 0x9BE8, 0x9BE9, 0x9BEA, 0x9BEB,
0x9BEC, 0x9BED, 0x9BEE, 0x9BEF, 0x9BF0, 0x9BF1, 0x9BF2, 0x9BF3,
0x9BF4, 0x9BF5, 0x9BF6, 0x9BF7, 0x9BF8, 0x9BF9, 0x9BFA, 0x9BFB,
0x9BFC, 0x9BFD, 0x9BFE, 0x9BFF, 0x9C00, 0x9C01, 0x9C02, 0x9C03,
0x9C04, 0x9C05, 0x9C06, 0x9C07, 0x9C08, 0x9C09, 0x9C0A, 0x9C0B,
0x9C0C, 0x9C0D, 0x9C0E, 0x9C0F, 0x9C10, 0x9C11, 0x9C12, 0x9C13,
0x9C14, 0x9C15, 0x9C16, 0x9C17, 0x9C18, 0x9C19, 0x9C1A, 0x9C1B,
0x9C1C, 0x9C1D, 0x9C1E, 0x9C1F, 0x9C20, 0x9C21, 0x9C22, 0x9C23,
0x9C24, 0x9C25, 0x9C26, 0x9C27, 0x9C28, 0x9C29, 0x9C2A, 0x9C2B,
0x9C2C, 0x9C2D, 0x9C2E, 0x9C2F, 0x9C30, 0x9C31, 0x9C32, 0x9C33,
0x9C34, 0x9C35, 0x9C36, 0x9C37, 0x9C38, 0x9C39, 0x9C3A, 0x9C3B,
0x9C3C, 0x9C3D, 0x9C3E, 0x9C3F, 0x9C40, 0x9C41, 0x9C42, 0x9C43,
0x9C44, 0x9C45, 0x9C46, 0x9C47, 0x9C48, 0x9C49, 0x9C4A, 0x9C4B,
0x9C4C, 0x9C4D, 0x9C4E, 0x9C4F, 0x9C50, 0x9C51, 0x9C52, 0x9C53,
0x9C54, 0x9C55, 0x9C56, 0x9C57, 0x9C58, 0x9C59, 0x9C5A, 0x9C5B,
0x9C5C, 0x9C5D, 0x9C5E, 0x9C5F, 0x9C60, 0x9C61, 0x9C62, 0x9C63,
0x9C64, 0x9C65, 0x9C66, 0x9C67, 0x9C68, 0x9C69, 0x9C6A, 0x9C6B,
0x9C6C, 0x9C6D, 0x9C6E, 0x9C6F, 0x9C70, 0x9C71, 0x9C72, 0x9C73,
0x9C74, 0x9C75, 0x9C76, 0x9C77, 0x9C78, 0x9C79, 0x9C7A, 0x9C7B,
0x9C7D, 0x9C7E, 0x9C80, 0x9C83, 0x9C84, 0x9C89, 0x9C8A, 0x9C8C,
0x9C8F, 0x9C93, 0x9C96, 0x9C97, 0x9C98, 0x9C99, 0x9C9D, 0x9CAA,
0x9CAC, 0x9CAF, 0x9CB9, 0x9CBE, 0x9CBF, 0x9CC0, 0x9CC1, 0x9CC2,
0x9CC8, 0x9CC9, 0x9CD1, 0x9CD2, 0x9CDA, 0x9CDB, 0x9CE0, 0x9CE1,
0x9CE3, 0x9CE4, 0x9CE5, 0x9CE6, 0x9CE7, 0x9CE8, 0x9CE9, 0x9CEA,
0x9CEB, 0x9CEC, 0x9CED, 0x9CEE, 0x9CEF, 0x9CF0, 0x9CF1, 0x9CF2,
0x9CF3, 0x9CF4, 0x9CF5, 0x9CF6, 0x9CF7, 0x9CF8, 0x9CF9, 0x9CFA,
0x9CFB, 0x9CFC, 0x9CFD, 0x9CFE, 0x9CFF, 0x9D00, 0x9D01, 0x9D02,
0x9D03, 0x9D04, 0x9D05, 0x9D06, 0x9D07, 0x9D08, 0x9D09, 0x9D0A,
0x9D0B, 0x9D0C, 0x9D0D, 0x9D0E, 0x9D0F, 0x9D10, 0x9D11, 0x9D12,
0x9D13, 0x9D14, 0x9D15, 0x9D16, 0x9D17, 0x9D18, 0x9D19, 0x9D1A,
0x9D1B, 0x9D1C, 0x9D1D, 0x9D1E, 0x9D1F, 0x9D20, 0x9D21, 0x9D22,
0x9D23, 0x9D24, 0x9D25, 0x9D26, 0x9D27, 0x9D28, 0x9D29, 0x9D2A,
0x9D2B, 0x9D2C, 0x9D2D, 0x9D2E, 0x9D2F, 0x9D30, 0x9D31, 0x9D32,
0x9D33, 0x9D34, 0x9D35, 0x9D36, 0x9D37, 0x9D38, 0x9D39, 0x9D3A,
0x9D3B, 0x9D3C, 0x9D3D, 0x9D3E, 0x9D3F, 0x9D40, 0x9D41, 0x9D42,
0x9D43, 0x9D44, 0x9D45, 0x9D46, 0x9D47, 0x9D48, 0x9D49, 0x9D4A,
0x9D4B, 0x9D4C, 0x9D4D, 0x9D4E, 0x9D4F, 0x9D50, 0x9D51, 0x9D52,
0x9D53, 0x9D54, 0x9D55, 0x9D56, 0x9D57, 0x9D58, 0x9D59, 0x9D5A,
0x9D5B, 0x9D5C, 0x9D5D, 0x9D5E, 0x9D5F, 0x9D60, 0x9D61, 0x9D62,
0x9D63, 0x9D64, 0x9D65, 0x9D66, 0x9D67, 0x9D68, 0x9D69, 0x9D6A,
0x9D6B, 0x9D6C, 0x9D6D, 0x9D6E, 0x9D6F, 0x9D70, 0x9D71, 0x9D72,
0x9D73, 0x9D74, 0x9D75, 0x9D76, 0x9D77, 0x9D78, 0x9D79, 0x9D7A,
0x9D7B, 0x9D7C, 0x9D7D, 0x9D7E, 0x9D7F, 0x9D80, 0x9D81, 0x9D82,
0x9D83, 0x9D84, 0x9D85, 0x9D86, 0x9D87, 0x9D88, 0x9D89, 0x9D8A,
0x9D8B, 0x9D8C, 0x9D8D, 0x9D8E, 0x9D8F, 0x9D90, 0x9D91, 0x9D92,
0x9D93, 0x9D94, 0x9D95, 0x9D96, 0x9D97, 0x9D98, 0x9D99, 0x9D9A,
0x9D9B, 0x9D9C, 0x9D9D, 0x9D9E, 0x9D9F, 0x9DA0, 0x9DA1, 0x9DA2,
0x9DA3, 0x9DA4, 0x9DA5, 0x9DA6, 0x9DA7, 0x9DA8, 0x9DA9, 0x9DAA,
0x9DAB, 0x9DAC, 0x9DAD, 0x9DAE, 0x9DAF, 0x9DB0, 0x9DB1, 0x9DB2,
0x9DB3, 0x9DB4, 0x9DB5, 0x9DB6, 0x9DB7, 0x9DB8, 0x9DB9, 0x9DBA,
0x9DBB, 0x9DBC, 0x9DBD, 0x9DBE, 0x9DBF, 0x9DC0, 0x9DC1, 0x9DC2,
0x9DC3, 0x9DC4, 0x9DC5, 0x9DC6, 0x9DC7, 0x9DC8, 0x9DC9, 0x9DCA,
0x9DCB, 0x9DCC, 0x9DCD, 0x9DCE, 0x9DCF, 0x9DD0, 0x9DD1, 0x9DD2,
0x9DD3, 0x9DD4, 0x9DD5, 0x9DD6, 0x9DD7, 0x9DD8, 0x9DD9, 0x9DDA,
0x9DDB, 0x9DDC, 0x9DDD, 0x9DDE, 0x9DDF, 0x9DE0, 0x9DE1, 0x9DE2,
0x9DE3, 0x9DE4, 0x9DE5, 0x9DE6, 0x9DE7, 0x9DE8, 0x9DE9, 0x9DEA,
0x9DEB, 0x9DEC, 0x9DED, 0x9DEE, 0x9DEF, 0x9DF0, 0x9DF1, 0x9DF2,
0x9DF3, 0x9DF4, 0x9DF5, 0x9DF6, 0x9DF7, 0x9DF8, 0x9DF9, 0x9DFA,
0x9DFB, 0x9DFC, 0x9DFD, 0x9DFE, 0x9DFF, 0x9E00, 0x9E01, 0x9E02,
0x9E03, 0x9E04, 0x9E05, 0x9E06, 0x9E07, 0x9E08, 0x9E09, 0x9E0A,
0x9E0B, 0x9E0C, 0x9E0D, 0x9E0E, 0x9E0F, 0x9E10, 0x9E11, 0x9E12,
0x9E13, 0x9E14, 0x9E15, 0x9E16, 0x9E17, 0x9E18, 0x9E19, 0x9E1A,
0x9E1B, 0x9E1C, 0x9E1D, 0x9E1E, 0x9E24, 0x9E27, 0x9E2E, 0x9E30,
0x9E34, 0x9E3B, 0x9E3C, 0x9E40, 0x9E4D, 0x9E50, 0x9E52, 0x9E53,
0x9E54, 0x9E56, 0x9E59, 0x9E5D, 0x9E5F, 0x9E60, 0x9E61, 0x9E62,
0x9E65, 0x9E6E, 0x9E6F, 0x9E72, 0x9E74, 0x9E75, 0x9E76, 0x9E77,
0x9E78, 0x9E79, 0x9E7A, 0x9E7B, 0x9E7C, 0x9E7D, 0x9E80, 0x9E81,
0x9E83, 0x9E84, 0x9E85, 0x9E86, 0x9E89, 0x9E8A, 0x9E8C, 0x9E8D,
0x9E8E, 0x9E8F, 0x9E90, 0x9E91, 0x9E94, 0x9E95, 0x9E96, 0x9E97,
0x9E98, 0x9E99, 0x9E9A, 0x9E9B, 0x9E9C, 0x9E9E, 0x9EA0, 0x9EA1,
0x9EA2, 0x9EA3, 0x9EA4, 0x9EA5, 0x9EA7, 0x9EA8, 0x9EA9, 0x9EAA,
0x9EAB, 0x9EAC, 0x9EAD, 0x9EAE, 0x9EAF, 0x9EB0, 0x9EB1, 0x9EB2,
0x9EB3, 0x9EB5, 0x9EB6, 0x9EB7, 0x9EB9, 0x9EBA, 0x9EBC, 0x9EBF,
0x9EC0, 0x9EC1, 0x9EC2, 0x9EC3, 0x9EC5, 0x9EC6, 0x9EC7, 0x9EC8,
0x9ECA, 0x9ECB, 0x9ECC, 0x9ED0, 0x9ED2, 0x9ED3, 0x9ED5, 0x9ED6,
0x9ED7, 0x9ED9, 0x9EDA, 0x9EDE, 0x9EE1, 0x9EE3, 0x9EE4, 0x9EE6,
0x9EE8, 0x9EEB, 0x9EEC, 0x9EED, 0x9EEE, 0x9EF0, 0x9EF1, 0x9EF2,
0x9EF3, 0x9EF4, 0x9EF5, 0x9EF6, 0x9EF7, 0x9EF8, 0x9EFA, 0x9EFD,
0x9EFF, 0x9F00, 0x9F01, 0x9F02, 0x9F03, 0x9F04, 0x9F05, 0x9F06,
0x9F07, 0x9F08, 0x9F09, 0x9F0A, 0x9F0C, 0x9F0F, 0x9F11, 0x9F12,
0x9F14, 0x9F15, 0x9F16, 0x9F18, 0x9F1A, 0x9F1B, 0x9F1C, 0x9F1D,
0x9F1E, 0x9F1F, 0x9F21, 0x9F23, 0x9F24, 0x9F25, 0x9F26, 0x9F27,
0x9F28, 0x9F29, 0x9F2A, 0x9F2B, 0x9F2D, 0x9F2E, 0x9F30, 0x9F31,
0x9F32, 0x9F33, 0x9F34, 0x9F35, 0x9F36, 0x9F38, 0x9F3A, 0x9F3C,
0x9F3F, 0x9F40, 0x9F41, 0x9F42, 0x9F43, 0x9F45, 0x9F46, 0x9F47,
0x9F48, 0x9F49, 0x9F4A, 0x9F4B, 0x9F4C, 0x9F4D, 0x9F4E, 0x9F4F,
0x9F52, 0x9F53, 0x9F54, 0x9F55, 0x9F56, 0x9F57, 0x9F58, 0x9F59,
0x9F5A, 0x9F5B, 0x9F5C, 0x9F5D, 0x9F5E, 0x9F5F, 0x9F60, 0x9F61,
0x9F62, 0x9F63, 0x9F64, 0x9F65, 0x9F66, 0x9F67, 0x9F68, 0x9F69,
0x9F6A, 0x9F6B, 0x9F6C, 0x9F6D, 0x9F6E, 0x9F6F, 0x9F70, 0x9F71,
0x9F72, 0x9F73, 0x9F74, 0x9F75, 0x9F76, 0x9F77, 0x9F78, 0x9F79,
0x9F7A, 0x9F7B, 0x9F7C, 0x9F7D, 0x9F7E, 0x9F81, 0x9F82, 0x9F8D,
0x9F8E, 0x9F8F, 0x9F90, 0x9F91, 0x9F92, 0x9F93, 0x9F94, 0x9F95,
0x9F96, 0x9F97, 0x9F98, 0x9F9C, 0x9F9D, 0x9F9E, 0x9FA1, 0x9FA2,
0x9FA3, 0x9FA4, 0x9FA5, 0xF92C, 0xF979, 0xF995, 0xF9E7, 0xF9F1,
0xFA0C, 0xFA0D, 0xFA0E, 0xFA0F, 0xFA11, 0xFA13, 0xFA14, 0xFA18,
0xFA1F, 0xFA20, 0xFA21, 0xFA23, 0xFA24, 0xFA27, 0xFA28, 0xFA29,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#ifndef ZUECI_EMBED_NO_TO_UTF8
/* Non-URO multibyte values in multibyte order */
static const zueci_u16 zueci_gbk_nonuro_mb[209] = {
0xA1A4, 0xA1AA, 0xA2A1, 0xA2A2, 0xA2A3, 0xA2A4, 0xA2A5, 0xA2A6,
0xA2A7, 0xA2A8, 0xA2A9, 0xA2AA, 0xA6E0, 0xA6E1, 0xA6E2, 0xA6E3,
0xA6E4, 0xA6E5, 0xA6E6, 0xA6E7, 0xA6E8, 0xA6E9, 0xA6EA, 0xA6EB,
0xA6EE, 0xA6EF, 0xA6F0, 0xA6F1, 0xA6F2, 0xA6F4, 0xA6F5, 0xA840,
0xA841, 0xA842, 0xA843, 0xA844, 0xA845, 0xA846, 0xA847, 0xA848,
0xA849, 0xA84A, 0xA84B, 0xA84C, 0xA84D, 0xA84E, 0xA84F, 0xA850,
0xA851, 0xA852, 0xA853, 0xA854, 0xA855, 0xA856, 0xA857, 0xA858,
0xA859, 0xA85A, 0xA85B, 0xA85C, 0xA85D, 0xA85E, 0xA85F, 0xA860,
0xA861, 0xA862, 0xA863, 0xA864, 0xA865, 0xA866, 0xA867, 0xA868,
0xA869, 0xA86A, 0xA86B, 0xA86C, 0xA86D, 0xA86E, 0xA86F, 0xA870,
0xA871, 0xA872, 0xA873, 0xA874, 0xA875, 0xA876, 0xA877, 0xA878,
0xA879, 0xA87A, 0xA87B, 0xA87C, 0xA87D, 0xA87E, 0xA880, 0xA881,
0xA882, 0xA883, 0xA884, 0xA885, 0xA886, 0xA887, 0xA888, 0xA889,
0xA88A, 0xA88B, 0xA88C, 0xA88D, 0xA88E, 0xA88F, 0xA890, 0xA891,
0xA892, 0xA893, 0xA894, 0xA895, 0xA8BB, 0xA8BD, 0xA8BE, 0xA8C0,
0xA940, 0xA941, 0xA942, 0xA943, 0xA944, 0xA945, 0xA946, 0xA947,
0xA948, 0xA949, 0xA94A, 0xA94B, 0xA94C, 0xA94D, 0xA94E, 0xA94F,
0xA950, 0xA951, 0xA952, 0xA953, 0xA954, 0xA955, 0xA956, 0xA957,
0xA959, 0xA95A, 0xA95C, 0xA960, 0xA961, 0xA962, 0xA963, 0xA964,
0xA965, 0xA966, 0xA967, 0xA968, 0xA969, 0xA96A, 0xA96B, 0xA96C,
0xA96D, 0xA96E, 0xA96F, 0xA970, 0xA971, 0xA972, 0xA973, 0xA974,
0xA975, 0xA976, 0xA977, 0xA978, 0xA979, 0xA97A, 0xA97B, 0xA97C,
0xA97D, 0xA97E, 0xA980, 0xA981, 0xA982, 0xA983, 0xA984, 0xA985,
0xA986, 0xA987, 0xA988, 0xA996, 0xFD9C, 0xFD9D, 0xFD9E, 0xFD9F,
0xFDA0, 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46,
0xFE47, 0xFE48, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E,
0xFE4F,
};
/* Non-URO Unicode values in multibyte order */
static const zueci_u16 zueci_gbk_nonuro_u[209] = {
0x00B7, 0x2014, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175,
0x2176, 0x2177, 0x2178, 0x2179, 0xFE35, 0xFE36, 0xFE39, 0xFE3A,
0xFE3F, 0xFE40, 0xFE3D, 0xFE3E, 0xFE41, 0xFE42, 0xFE43, 0xFE44,
0xFE3B, 0xFE3C, 0xFE37, 0xFE38, 0xFE31, 0xFE33, 0xFE34, 0x02CA,
0x02CB, 0x02D9, 0x2013, 0x2015, 0x2025, 0x2035, 0x2105, 0x2109,
0x2196, 0x2197, 0x2198, 0x2199, 0x2215, 0x221F, 0x2223, 0x2252,
0x2266, 0x2267, 0x22BF, 0x2550, 0x2551, 0x2552, 0x2553, 0x2554,
0x2555, 0x2556, 0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C,
0x255D, 0x255E, 0x255F, 0x2560, 0x2561, 0x2562, 0x2563, 0x2564,
0x2565, 0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C,
0x256D, 0x256E, 0x256F, 0x2570, 0x2571, 0x2572, 0x2573, 0x2581,
0x2582, 0x2583, 0x2584, 0x2585, 0x2586, 0x2587, 0x2588, 0x2589,
0x258A, 0x258B, 0x258C, 0x258D, 0x258E, 0x258F, 0x2593, 0x2594,
0x2595, 0x25BC, 0x25BD, 0x25E2, 0x25E3, 0x25E4, 0x25E5, 0x2609,
0x2295, 0x3012, 0x301D, 0x301E, 0x0251, 0x0144, 0x0148, 0x0261,
0x3021, 0x3022, 0x3023, 0x3024, 0x3025, 0x3026, 0x3027, 0x3028,
0x3029, 0x32A3, 0x338E, 0x338F, 0x339C, 0x339D, 0x339E, 0x33A1,
0x33C4, 0x33CE, 0x33D1, 0x33D2, 0x33D5, 0xFE30, 0xFFE2, 0xFFE4,
0x2121, 0x3231, 0x2010, 0x30FC, 0x309B, 0x309C, 0x30FD, 0x30FE,
0x3006, 0x309D, 0x309E, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D,
0xFE4E, 0xFE4F, 0xFE50, 0xFE51, 0xFE52, 0xFE54, 0xFE55, 0xFE56,
0xFE57, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F,
0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE68,
0xFE69, 0xFE6A, 0xFE6B, 0x3007, 0xF92C, 0xF979, 0xF995, 0xF9E7,
0xF9F1, 0xFA0C, 0xFA0D, 0xFA0E, 0xFA0F, 0xFA11, 0xFA13, 0xFA14,
0xFA18, 0xFA1F, 0xFA20, 0xFA21, 0xFA23, 0xFA24, 0xFA27, 0xFA28,
0xFA29,
};
#endif /* ZUECI_EMBED_NO_TO_UTF8 */
#endif /* ZUECI_GBK_H */
```
|
/content/code_sandbox/core/src/libzueci/zueci_gbk.h
|
objective-c
| 2016-04-12T22:33:06
| 2024-08-15T07:35:29
|
zxing-cpp
|
zxing-cpp/zxing-cpp
| 1,205
| 201,239
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.