intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029
author: Devtools Arcadia <arcadia-devtools@yandex-team.ru> 2022-02-07 18:08:42 +0300
committer: Devtools Arcadia <arcadia-devtools@mous.vla.yp-c.yandex.net> 2022-02-07 18:08:42 +0300
commit: 1110808a9d39d4b808aef724c861a2e1a38d2a69 (patch)
tree: e26c9fed0de5d9873cce7e00bc214573dc2195b7 /library/cpp/charset
download: ydb-1110808a9d39d4b808aef724c861a2e1a38d2a69.tar.gz
22 files changed, 22242 insertions, 0 deletions
diff --git a/library/cpp/charset/README.md b/library/cpp/charset/README.md
new file mode 100644
index 0000000000..9a257e3b4d
--- /dev/null
+++ b/library/cpp/charset/README.md
@@ -0,0 +1,10 @@
+Здесь представлены функции и enum'ы для работы с кодировками.
+
+Наиболее полезные конструкции этой библиотеки:
+1. [`enum ECharset`](https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/charset/doccodes.h) - перечень кодировок, которые умеет определять [детектор кодировок](https://a.yandex-team.ru/arc/trunk/arcadia/kernel/recshell/recshell.h?rev=8268697#L56).
+2. [Функция](https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/charset/recyr.hh?rev=r6888372#L137) `inline TString Recode(ECharset from, ECharset to, const TString& in)` для преобразования кодировок.
+3. [Функция](https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/charset/wide.h?rev=r6888372#L277) `inline TUtf16String UTF8ToWide(const char* text, size_t len, const CodePage& cp)`, пытающаяся построить широкую строку из UTF-8, а если не получается - с помощью кодировки `cp`.
+
+3. [Класс `TCiString`](https://a.yandex-team.ru/arc/trunk/arcadia/library/cpp/charset/ci_string.h) - аналог `TString`, но использующий case-insensitive-компаратор и хеш и поддерживающий разные кодировки.
+
+В комплекте есть ещё много функций для работы со старой однобайтной Yandex-кодировкой. Не рекомендуется к использованию. Для преобразования из UTF-8 в `TUtf16String` и для работы с Unicode используйте функции из [arcadia/util/charset](https://a.yandex-team.ru/arc/trunk/arcadia/util/charset).
diff --git a/library/cpp/charset/ci_string.cpp b/library/cpp/charset/ci_string.cpp
new file mode 100644
index 0000000000..634b05ec68
--- /dev/null
+++ b/library/cpp/charset/ci_string.cpp
@@ -0,0 +1,42 @@
+#include "ci_string.h"
+#include "wide.h"
+
+int TCiString::compare(const TCiString& s1, const TCiString& s2, const CodePage& cp) {
+    return cp.stricmp(s1.data(), s2.data());
+}
+
+int TCiString::compare(const char* p, const TCiString& s2, const CodePage& cp) {
+    return cp.stricmp(p, s2.data());
+}
+
+int TCiString::compare(const TCiString& s1, const char* p, const CodePage& cp) {
+    return cp.stricmp(s1.data(), p);
+}
+
+int TCiString::compare(const TStringBuf& p1, const TStringBuf& p2, const CodePage& cp) {
+    int rv = cp.strnicmp(p1.data(), p2.data(), Min(p1.size(), p2.size()));
+    return rv ? rv : p1.size() < p2.size() ? -1 : p1.size() == p2.size() ? 0 : 1;
+}
+
+bool TCiString::is_prefix(const TStringBuf& what, const TStringBuf& of, const CodePage& cp) {
+    size_t len = what.size();
+    return len <= of.size() && cp.strnicmp(what.data(), of.data(), len) == 0;
+}
+
+bool TCiString::is_suffix(const TStringBuf& what, const TStringBuf& of, const CodePage& cp) {
+    size_t len = what.size();
+    size_t slen = of.size();
+    return (len <= slen) && (0 == cp.strnicmp(what.data(), of.data() + slen - len, len));
+}
+
+size_t TCiString::hashVal(const char* s, size_t len, const CodePage& cp) {
+    size_t h = len;
+    for (; /* (*s) && */ len--; ++s)
+        h = 5 * h + cp.ToLower(*s);
+    return h;
+}
+
+template <>
+void Out<TCiString>(IOutputStream& o, const TCiString& p) {
+    o.Write(p.data(), p.size());
+}
diff --git a/library/cpp/charset/ci_string.h b/library/cpp/charset/ci_string.h
new file mode 100644
index 0000000000..edf24c1b6f
--- /dev/null
+++ b/library/cpp/charset/ci_string.h
@@ -0,0 +1,280 @@
+#pragma once
+
+#include "codepage.h"
+
+#include <util/generic/string.h>
+#include <util/str_stl.h>
+
+// Same as TString but uses CASE INSENSITIVE comparator and hash. Use with care.
+class TCiString: public TString {
+public:
+    TCiString() {
+    }
+
+    TCiString(const TString& s)
+        : TString(s)
+    {
+    }
+
+    TCiString(const TString& s, size_t pos, size_t n)
+        : TString(s, pos, n)
+    {
+    }
+
+    TCiString(const char* pc)
+        : TString(pc)
+    {
+    }
+
+    TCiString(const char* pc, size_t n)
+        : TString(pc, n)
+    {
+    }
+
+    TCiString(const char* pc, size_t pos, size_t n)
+        : TString(pc, pos, n)
+    {
+    }
+
+    TCiString(size_t n, char c)
+        : TString(n, c)
+    {
+    }
+
+    TCiString(const TUninitialized& uninitialized)
+        : TString(uninitialized)
+    {
+    }
+
+    TCiString(const char* b, const char* e)
+        : TString(b, e)
+    {
+    }
+
+    explicit TCiString(const TStringBuf& s)
+        : TString(s)
+    {
+    }
+
+    // ~~~ Comparison ~~~ : FAMILY0(int, compare)
+    static int compare(const TCiString& s1, const TCiString& s2, const CodePage& cp = csYandex);
+    static int compare(const char* p, const TCiString& s2, const CodePage& cp = csYandex);
+    static int compare(const TCiString& s1, const char* p, const CodePage& cp = csYandex);
+    static int compare(const TStringBuf& p1, const TStringBuf& p2, const CodePage& cp = csYandex);
+
+    // TODO: implement properly in TString via enum ECaseSensitivity
+    static bool is_prefix(const TStringBuf& what, const TStringBuf& of, const CodePage& cp = csYandex);
+    static bool is_suffix(const TStringBuf& what, const TStringBuf& of, const CodePage& cp = csYandex);
+
+    bool StartsWith(const TStringBuf& s, const CodePage& cp = csYandex) const {
+        return is_prefix(s, *this, cp);
+    }
+
+    bool EndsWith(const TStringBuf& s, const CodePage& cp = csYandex) const {
+        return is_suffix(s, *this, cp);
+    }
+
+    friend bool operator==(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) == 0;
+    }
+
+    friend bool operator==(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) == 0;
+    }
+
+    friend bool operator==(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) == 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator==(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) {
+        return TCiString::compare(s, pc) == 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator==(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) {
+        return TCiString::compare(pc, s) == 0;
+    }
+
+    friend bool operator!=(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) != 0;
+    }
+
+    friend bool operator!=(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) != 0;
+    }
+
+    friend bool operator!=(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) != 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator!=(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) {
+        return TCiString::compare(s, pc) != 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator!=(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) {
+        return TCiString::compare(pc, s) != 0;
+    }
+
+    friend bool operator<(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) < 0;
+    }
+
+    friend bool operator<(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) < 0;
+    }
+
+    friend bool operator<(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) < 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator<(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) {
+        return TCiString::compare(s, pc) < 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator<(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) {
+        return TCiString::compare(pc, s) < 0;
+    }
+
+    friend bool operator<=(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) <= 0;
+    }
+
+    friend bool operator<=(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) <= 0;
+    }
+
+    friend bool operator<=(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) <= 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator<=(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) {
+        return TCiString::compare(s, pc) <= 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator<=(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) {
+        return TCiString::compare(pc, s) <= 0;
+    }
+
+    friend bool operator>(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) > 0;
+    }
+
+    friend bool operator>(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) > 0;
+    }
+
+    friend bool operator>(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) > 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator>(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) noexcept {
+        return TCiString::compare(s, pc) > 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator>(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) noexcept {
+        return TCiString::compare(pc, s) > 0;
+    }
+
+    friend bool operator>=(const TCiString& s1, const TCiString& s2) {
+        return TCiString::compare(s1, s2) >= 0;
+    }
+
+    friend bool operator>=(const TCiString& s, const char* pc) {
+        return TCiString::compare(s, pc) >= 0;
+    }
+
+    friend bool operator>=(const char* pc, const TCiString& s) {
+        return TCiString::compare(pc, s) >= 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator>=(const TCiString& s, const TStringBase<TDerived2, TChar, TTraits2>& pc) {
+        return TCiString::compare(s, pc) >= 0;
+    }
+
+    template <typename TDerived2, typename TTraits2>
+    friend bool operator>=(const TStringBase<TDerived2, TChar, TTraits2>& pc, const TCiString& s) {
+        return TCiString::compare(pc, s) >= 0;
+    }
+
+    static size_t hashVal(const char* pc, size_t len, const CodePage& cp = csYandex);
+
+    size_t hash() const {
+        return TCiString::hashVal(data(), length());
+    }
+};
+
+struct ci_hash {
+    inline size_t operator()(const char* s) const {
+        return TCiString::hashVal(s, strlen(s));
+    }
+    inline size_t operator()(const TStringBuf& s) const {
+        return TCiString::hashVal(s.data(), s.size());
+    }
+};
+
+struct ci_hash32 { // not the same as ci_hash under 64-bit
+    inline ui32 operator()(const char* s) const {
+        return (ui32)TCiString::hashVal(s, strlen(s));
+    }
+};
+
+//template <class T> struct hash;
+
+template <>
+struct hash<TCiString>: public ci_hash {
+};
+
+template <class T>
+struct TCIHash {
+};
+
+template <>
+struct TCIHash<const char*> {
+    inline size_t operator()(const TStringBuf& s) const {
+        return TCiString::hashVal(s.data(), s.size());
+    }
+};
+
+template <>
+struct TCIHash<TStringBuf> {
+    inline size_t operator()(const TStringBuf& s) const {
+        return TCiString::hashVal(s.data(), s.size());
+    }
+};
+
+template <>
+struct TCIHash<TString> {
+    inline size_t operator()(const TString& s) const {
+        return TCiString::hashVal(s.data(), s.size());
+    }
+};
+
+struct ci_less {
+    inline bool operator()(const char* x, const char* y) const {
+        return csYandex.stricmp(x, y) < 0;
+    }
+};
+
+struct ci_equal_to {
+    inline bool operator()(const char* x, const char* y) const {
+        return csYandex.stricmp(x, y) == 0;
+    }
+    // this implementation is not suitable for strings with zero characters inside, sorry
+    bool operator()(const TStringBuf& x, const TStringBuf& y) const {
+        return x.size() == y.size() && csYandex.strnicmp(x.data(), y.data(), y.size()) == 0;
+    }
+};
+
+template <>
+struct TEqualTo<TCiString>: public ci_equal_to {
+};
diff --git a/library/cpp/charset/ci_string_ut.cpp b/library/cpp/charset/ci_string_ut.cpp
new file mode 100644
index 0000000000..3d2a53d5fe
--- /dev/null
+++ b/library/cpp/charset/ci_string_ut.cpp
@@ -0,0 +1,23 @@
+#include "ci_string.h"
+
+#include <util/generic/hash.h>
+#include <util/generic/string_ut.h>
+
+class TCaseStringTest: public TTestBase, private TStringTestImpl<TCiString, TTestData<char>> {
+public:
+    void TestSpecial() {
+        TCiString ss = Data._0123456(); // type 'TCiString' is used as is
+        size_t hash_val = ComputeHash(ss);
+        UNIT_ASSERT(hash_val == 1489244);
+    }
+
+public:
+    UNIT_TEST_SUITE(TCaseStringTest);
+    UNIT_TEST(TestOperators);
+    UNIT_TEST(TestOperatorsCI);
+
+    UNIT_TEST(TestSpecial);
+    UNIT_TEST_SUITE_END();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TCaseStringTest);
diff --git a/library/cpp/charset/codepage.cpp b/library/cpp/charset/codepage.cpp
new file mode 100644
index 0000000000..0431bef31b
--- /dev/null
+++ b/library/cpp/charset/codepage.cpp
@@ -0,0 +1,511 @@
+#include "ci_string.h"
+#include "wide.h"
+#include "recyr.hh"
+#include "codepage.h"
+
+#include <util/string/cast.h>
+#include <util/string/subst.h>
+#include <util/string/util.h>
+#include <util/system/hi_lo.h>
+#include <util/system/yassert.h>
+#include <util/generic/hash.h>
+#include <util/generic/string.h>
+#include <util/generic/vector.h>
+#include <util/generic/hash_set.h>
+#include <util/generic/singleton.h>
+#include <util/generic/yexception.h>
+#include <util/memory/pool.h>
+
+#include <cstring>
+
+#include <ctype.h>
+
+using namespace NCodepagePrivate;
+
+void Recoder::Create(const CodePage& source, const CodePage& target) {
+    const Encoder* wideTarget = &EncoderByCharset(target.CPEnum);
+    Create(source, wideTarget);
+}
+void Recoder::Create(const CodePage& page, wchar32 (*mapfunc)(wchar32)) {
+    const Encoder* widePage = &EncoderByCharset(page.CPEnum);
+    Create(page, widePage, mapfunc);
+}
+
+template <class T, class T1>
+static inline T1 Apply(T b, T e, T1 to, const Recoder& mapper) {
+    while (b != e) {
+        *to++ = mapper.Table[(unsigned char)*b++];
+    }
+
+    return to;
+}
+
+template <class T, class T1>
+static inline T1 Apply(T b, T1 to, const Recoder& mapper) {
+    while (*b != 0) {
+        *to++ = mapper.Table[(unsigned char)*b++];
+    }
+
+    return to;
+}
+
+char* CodePage::ToLower(const char* b, const char* e, char* to) const {
+    return Apply(b, e, to, TCodePageData::rcdr_to_lower[CPEnum]);
+}
+char* CodePage::ToLower(const char* b, char* to) const {
+    return Apply(b, to, TCodePageData::rcdr_to_lower[CPEnum]);
+}
+
+char* CodePage::ToUpper(const char* b, const char* e, char* to) const {
+    return Apply(b, e, to, TCodePageData::rcdr_to_upper[CPEnum]);
+}
+char* CodePage::ToUpper(const char* b, char* to) const {
+    return Apply(b, to, TCodePageData::rcdr_to_upper[CPEnum]);
+}
+
+int CodePage::stricmp(const char* dst, const char* src) const {
+    unsigned char f, l;
+    do {
+        f = ToLower(*dst++);
+        l = ToLower(*src++);
+    } while (f && (f == l));
+    return f - l;
+}
+
+int CodePage::strnicmp(const char* dst, const char* src, size_t len) const {
+    unsigned char f, l;
+    if (len) {
+        do {
+            f = ToLower(*dst++);
+            l = ToLower(*src++);
+        } while (--len && f && (f == l));
+        return f - l;
+    }
+    return 0;
+}
+
+static const CodePage UNSUPPORTED_CODEPAGE = {
+    CODES_UNSUPPORTED,
+    {
+        "unsupported",
+    },
+    {},
+    nullptr,
+};
+
+static const CodePage UNKNOWN_CODEPAGE = {
+    CODES_UNKNOWN,
+    {
+        "unknown",
+    },
+    {},
+    nullptr,
+};
+
+void NCodepagePrivate::TCodepagesMap::SetData(const CodePage* cp) {
+    Y_ASSERT(cp);
+    int code = static_cast<int>(cp->CPEnum) + DataShift;
+
+    Y_ASSERT(code >= 0 && code < DataSize);
+    Y_ASSERT(Data[code] == nullptr);
+
+    Data[code] = cp;
+}
+
+NCodepagePrivate::TCodepagesMap::TCodepagesMap() {
+    memset(Data, 0, sizeof(const CodePage*) * DataSize);
+    SetData(&UNSUPPORTED_CODEPAGE);
+    SetData(&UNKNOWN_CODEPAGE);
+
+    for (size_t i = 0; i != CODES_MAX; ++i) {
+        SetData(TCodePageData::AllCodePages[i]);
+    }
+}
+
+const NCodepagePrivate::TCodepagesMap& NCodepagePrivate::TCodepagesMap::Instance() {
+    return *Singleton<NCodepagePrivate::TCodepagesMap>();
+}
+
+class TCodePageHash {
+private:
+    using TData = THashMap<TStringBuf, ECharset, ci_hash, ci_equal_to>;
+
+    TData Data;
+    TMemoryPool Pool;
+
+private:
+    inline void AddNameWithCheck(const TString& name, ECharset code) {
+        if (Data.find(name.c_str()) == Data.end()) {
+            Data.insert(TData::value_type(Pool.Append(name.data(), name.size() + 1), code));
+        } else {
+            Y_ASSERT(Data.find(name.c_str())->second == code);
+        }
+    }
+
+    inline void AddName(const TString& name, ECharset code) {
+        AddNameWithCheck(name, code);
+
+        TString temp = name;
+        RemoveAll(temp, '-');
+        RemoveAll(temp, '_');
+        AddNameWithCheck(temp, code);
+
+        temp = name;
+        SubstGlobal(temp, '-', '_');
+        AddNameWithCheck(temp, code);
+
+        temp = name;
+        SubstGlobal(temp, '_', '-');
+        AddNameWithCheck(temp, code);
+    }
+
+public:
+    inline TCodePageHash()
+        : Pool(20 * 1024) /* Currently used: 17KB. */
+    {
+        TString xPrefix = "x-";
+        const char* name;
+
+        for (size_t i = 0; i != CODES_MAX; ++i) {
+            ECharset e = static_cast<ECharset>(i);
+            const CodePage* page = Singleton<NCodepagePrivate::TCodepagesMap>()->GetPrivate(e);
+
+            AddName(ToString(static_cast<int>(i)), e);
+
+            for (size_t j = 0; (name = page->Names[j]) != nullptr && name[0]; ++j) {
+                AddName(name, e);
+
+                AddName(xPrefix + name, e);
+            }
+        }
+    }
+
+    inline ECharset CharsetByName(TStringBuf name) {
+        if (!name)
+            return CODES_UNKNOWN;
+
+        TData::const_iterator it = Data.find(name);
+        if (it == Data.end())
+            return CODES_UNKNOWN;
+
+        return it->second;
+    }
+};
+
+ECharset CharsetByName(TStringBuf name) {
+    return Singleton<TCodePageHash>()->CharsetByName(name);
+}
+
+ECharset CharsetByNameOrDie(TStringBuf name) {
+    ECharset result = CharsetByName(name);
+    if (result == CODES_UNKNOWN)
+        ythrow yexception() << "CharsetByNameOrDie: unknown charset '" << name << "'";
+    return result;
+}
+
+template <typename TxChar>
+static inline RECODE_RESULT utf8_read_rune_from_unknown_plane(TxChar& rune, size_t& rune_len, const TxChar* s, const TxChar* end) {
+    if ((*s & 0xFF00) != 0xF000) {
+        rune_len = 1;
+        rune = *s;
+        return RECODE_OK;
+    }
+
+    rune_len = 0;
+
+    size_t _len = UTF8RuneLen((unsigned char)(*s));
+    if (s + _len > end)
+        return RECODE_EOINPUT; //[EOINPUT]
+    if (_len == 0)
+        return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in first byte
+
+    wchar32 _rune = (ui8)(*s++); //[00000000 0XXXXXXX]
+    if (_len > 1) {
+        _rune &= UTF8LeadByteMask(_len);
+        wchar32 ch = *s++;
+        if ((ch & 0xFFC0) != 0xF080)
+            return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in second byte
+        _rune <<= 6;
+        _rune |= ch & 0x3F; //[00000XXX XXYYYYYY]
+        if (_len > 2) {
+            ch = *s++;
+            if ((ch & 0xFFC0) != 0xF080)
+                return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in third byte
+            _rune <<= 6;
+            _rune |= ch & 0x3F; //[XXXXYYYY YYZZZZZZ]
+            if (_len > 3) {
+                ch = *s;
+                if ((ch & 0xFFC0) != 0xF080)
+                    return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in fourth byte
+                _rune <<= 6;
+                _rune |= ch & 0x3F; //[XXXYY YYYYZZZZ ZZQQQQQQ]
+            }
+        }
+    }
+    rune_len = _len;
+    if (_rune > Max<TxChar>())
+        rune = ' '; // maybe put sequence
+    else
+        rune = TxChar(_rune);
+    return RECODE_OK;
+}
+
+template <typename TxChar>
+void DoDecodeUnknownPlane(TxChar* str, TxChar*& ee, const ECharset enc) {
+    TxChar* e = ee;
+    if (SingleByteCodepage(enc)) {
+        const CodePage* cp = CodePageByCharset(enc);
+        for (TxChar* s = str; s < e; s++) {
+            if (Hi8(Lo16(*s)) == 0xF0)
+                *s = (TxChar)cp->unicode[Lo8(Lo16(*s))]; // NOT mb compliant
+        }
+    } else if (enc == CODES_UTF8) {
+        TxChar* s;
+        TxChar* d;
+
+        for (s = d = str; s < e;) {
+            size_t l = 0;
+
+            if (utf8_read_rune_from_unknown_plane(*d, l, s, e) == RECODE_OK) {
+                d++, s += l;
+            } else {
+                *d++ = BROKEN_RUNE;
+                ++s;
+            }
+        }
+        e = d;
+    } else if (enc == CODES_UNKNOWN) {
+        for (TxChar* s = str; s < e; s++) {
+            if (Hi8(Lo16(*s)) == 0xF0)
+                *s = Lo8(Lo16(*s));
+        }
+    } else {
+        Y_ASSERT(!SingleByteCodepage(enc));
+
+        TxChar* s = str;
+        TxChar* d = str;
+
+        TVector<char> buf;
+
+        size_t read = 0;
+        size_t written = 0;
+        for (; s < e; ++s) {
+            if (Hi8(Lo16(*s)) == 0xF0) {
+                buf.push_back(Lo8(Lo16(*s)));
+            } else {
+                if (!buf.empty()) {
+                    if (RecodeToUnicode(enc, buf.data(), d, buf.size(), e - d, read, written) == RECODE_OK) {
+                        Y_ASSERT(read == buf.size());
+                        d += written;
+                    } else { // just copying broken symbols
+                        Y_ASSERT(buf.size() <= static_cast<size_t>(e - d));
+                        Copy(buf.data(), buf.size(), d);
+                        d += buf.size();
+                    }
+                    buf.clear();
+                }
+                *d++ = *s;
+            }
+        }
+    }
+    ee = e;
+}
+
+void DecodeUnknownPlane(wchar16* str, wchar16*& ee, const ECharset enc) {
+    DoDecodeUnknownPlane(str, ee, enc);
+}
+void DecodeUnknownPlane(wchar32* str, wchar32*& ee, const ECharset enc) {
+    DoDecodeUnknownPlane(str, ee, enc);
+}
+
+namespace {
+    class THashSetType: public THashSet<TString> {
+    public:
+        inline void Add(const TString& s) {
+            insert(s);
+        }
+
+        inline bool Has(const TString& s) const noexcept {
+            return find(s) != end();
+        }
+    };
+}
+
+class TWindowsPrefixesHashSet: public THashSetType {
+public:
+    inline TWindowsPrefixesHashSet() {
+        Add("win");
+        Add("wincp");
+        Add("window");
+        Add("windowcp");
+        Add("windows");
+        Add("windowscp");
+        Add("ansi");
+        Add("ansicp");
+    }
+};
+
+class TCpPrefixesHashSet: public THashSetType {
+public:
+    inline TCpPrefixesHashSet() {
+        Add("microsoft");
+        Add("microsoftcp");
+        Add("cp");
+    }
+};
+
+class TIsoPrefixesHashSet: public THashSetType {
+public:
+    inline TIsoPrefixesHashSet() {
+        Add("iso");
+        Add("isolatin");
+        Add("latin");
+    }
+};
+
+class TLatinToIsoHash: public THashMap<const char*, TString, ci_hash, ci_equal_to> {
+public:
+    inline TLatinToIsoHash() {
+        insert(value_type("latin1", "iso-8859-1"));
+        insert(value_type("latin2", "iso-8859-2"));
+        insert(value_type("latin3", "iso-8859-3"));
+        insert(value_type("latin4", "iso-8859-4"));
+        insert(value_type("latin5", "iso-8859-9"));
+        insert(value_type("latin6", "iso-8859-10"));
+        insert(value_type("latin7", "iso-8859-13"));
+        insert(value_type("latin8", "iso-8859-14"));
+        insert(value_type("latin9", "iso-8859-15"));
+        insert(value_type("latin10", "iso-8859-16"));
+    }
+};
+
+static inline void NormalizeEncodingPrefixes(TString& enc) {
+    size_t preflen = enc.find_first_of("0123456789");
+    if (preflen == TString::npos)
+        return;
+
+    TString prefix = enc.substr(0, preflen);
+    for (size_t i = 0; i < prefix.length(); ++i) {
+        if (prefix[i] == '-') {
+            prefix.remove(i--);
+        }
+    }
+
+    if (Singleton<TWindowsPrefixesHashSet>()->Has(prefix)) {
+        enc.remove(0, preflen);
+        enc.prepend("windows-");
+        return;
+    }
+
+    if (Singleton<TCpPrefixesHashSet>()->Has(prefix)) {
+        if (enc.length() > preflen + 3 && !strncmp(enc.c_str() + preflen, "125", 3) && isdigit(enc[preflen + 3])) {
+            enc.remove(0, preflen);
+            enc.prepend("windows-");
+            return;
+        }
+        enc.remove(0, preflen);
+        enc.prepend("cp");
+        return;
+    }
+
+    if (Singleton<TIsoPrefixesHashSet>()->Has(prefix)) {
+        if (enc.length() == preflen + 1 || enc.length() == preflen + 2) {
+            TString enccopy = enc.substr(preflen);
+            enccopy.prepend("latin");
+            const TLatinToIsoHash* latinhash = Singleton<TLatinToIsoHash>();
+            TLatinToIsoHash::const_iterator it = latinhash->find(enccopy.data());
+            if (it != latinhash->end())
+                enc.assign(it->second);
+            return;
+        } else if (enc.length() > preflen + 5 && enc[preflen] == '8') {
+            enc.remove(0, preflen);
+            enc.prepend("iso-");
+            return;
+        }
+    }
+}
+
+class TEncodingNamesHashSet: public THashSetType {
+public:
+    TEncodingNamesHashSet() {
+        Add("iso-8859-1");
+        Add("iso-8859-2");
+        Add("iso-8859-3");
+        Add("iso-8859-4");
+        Add("iso-8859-5");
+        Add("iso-8859-6");
+        Add("iso-8859-7");
+        Add("iso-8859-8");
+        Add("iso-8859-8-i");
+        Add("iso-8859-9");
+        Add("iso-8859-10");
+        Add("iso-8859-11");
+        Add("iso-8859-12");
+        Add("iso-8859-13");
+        Add("iso-8859-14");
+        Add("iso-8859-15");
+        Add("windows-1250");
+        Add("windows-1251");
+        Add("windows-1252");
+        Add("windows-1253");
+        Add("windows-1254");
+        Add("windows-1255");
+        Add("windows-1256");
+        Add("windows-1257");
+        Add("windows-1258");
+        Add("windows-874");
+        Add("iso-2022-jp");
+        Add("euc-jp");
+        Add("shift-jis");
+        Add("shiftjis");
+        Add("iso-2022-kr");
+        Add("euc-kr");
+        Add("gb-2312");
+        Add("gb2312");
+        Add("gb-18030");
+        Add("gb18030");
+        Add("gbk");
+        Add("big5");
+        Add("tis-620");
+        Add("tis620");
+    }
+};
+
+ECharset EncodingHintByName(const char* encname) {
+    if (!encname)
+        return CODES_UNKNOWN; // safety check
+
+    // Common trouble: spurious "charset=" in the encoding name
+    if (!strnicmp(encname, "charset=", 8)) {
+        encname += 8;
+    }
+
+    // Strip everything up to the first alphanumeric, and after the last one
+    while (*encname && !isalnum(*encname))
+        ++encname;
+
+    if (!*encname)
+        return CODES_UNKNOWN;
+
+    const char* lastpos = encname + strlen(encname) - 1;
+    while (lastpos > encname && !isalnum(*lastpos))
+        --lastpos;
+
+    // Do some normalization
+    TString enc(encname, lastpos - encname + 1);
+    enc.to_lower();
+    for (char* p = enc.begin(); p != enc.end(); ++p) {
+        if (*p == ' ' || *p == '=' || *p == '_')
+            *p = '-';
+    }
+
+    NormalizeEncodingPrefixes(enc);
+
+    ECharset hint = CharsetByName(enc.c_str());
+    if (hint != CODES_UNKNOWN)
+        return hint;
+
+    if (Singleton<TEncodingNamesHashSet>()->Has(enc))
+        return CODES_UNSUPPORTED;
+    return CODES_UNKNOWN;
+}
diff --git a/library/cpp/charset/codepage.h b/library/cpp/charset/codepage.h
new file mode 100644
index 0000000000..30a02a4610
--- /dev/null
+++ b/library/cpp/charset/codepage.h
@@ -0,0 +1,324 @@
+#pragma once
+
+#include "doccodes.h"
+
+#include <util/charset/recode_result.h>
+#include <util/charset/unidata.h> // all wchar32 functions
+#include <util/charset/utf8.h>
+#include <util/generic/string.h>
+#include <util/generic/ylimits.h>
+#include <util/generic/yexception.h>
+#include <util/system/yassert.h>
+#include <util/system/defaults.h>
+
+#include <cctype>
+
+struct CodePage;
+struct Recoder;
+struct Encoder;
+
+/*****************************************************************\
+*                    struct CodePage                              *
+\*****************************************************************/
+struct CodePage {
+    ECharset CPEnum;       // int MIBEnum;
+    const char* Names[30]; // name[0] -- preferred mime-name
+    wchar32 unicode[256];
+    const char* DefaultChar; //[CCL_NUM]
+
+    bool IsLower(unsigned char ch) const {
+        return ::IsLower(unicode[ch]);
+    }
+    bool IsUpper(unsigned char ch) const {
+        return ::IsUpper(unicode[ch]);
+    }
+    bool IsAlpha(unsigned char ch) const {
+        return ::IsAlpha(unicode[ch]);
+    }
+    bool IsDigit(unsigned char ch) const {
+        return ::IsDigit(unicode[ch]);
+    }
+    bool IsXdigit(unsigned char ch) const {
+        return ::IsXdigit(unicode[ch]);
+    }
+    bool IsAlnum(unsigned char ch) const {
+        return ::IsAlnum(unicode[ch]);
+    }
+    bool IsSpace(unsigned char ch) const {
+        return ::IsSpace(unicode[ch]);
+    }
+    bool IsPunct(unsigned char ch) const {
+        return ::IsPunct(unicode[ch]);
+    }
+    bool IsCntrl(unsigned char ch) const {
+        return ::IsCntrl(unicode[ch]);
+    }
+    bool IsGraph(unsigned char ch) const {
+        return ::IsGraph(unicode[ch]);
+    }
+    bool IsPrint(unsigned char ch) const {
+        return ::IsPrint(unicode[ch]);
+    }
+    bool IsComposed(unsigned char ch) const {
+        return ::IsComposed(unicode[ch]);
+    }
+
+    // return pointer to char after the last char
+    char* ToLower(const char* begin, const char* end, char* to) const;
+    char* ToLower(const char* begin, char* to) const;
+
+    // return pointer to char after the last char
+    char* ToUpper(const char* begin, const char* end, char* to) const;
+    char* ToUpper(const char* begin, char* to) const;
+
+    int stricmp(const char* s1, const char* s2) const;
+    int strnicmp(const char* s1, const char* s2, size_t len) const;
+
+    inline unsigned char ToUpper(unsigned char ch) const;
+    inline unsigned char ToLower(unsigned char ch) const;
+    inline unsigned char ToTitle(unsigned char ch) const;
+
+    inline int ToDigit(unsigned char ch) const {
+        return ::ToDigit(unicode[ch]);
+    }
+
+    static void Initialize();
+
+    inline bool SingleByteCodepage() const {
+        return DefaultChar != nullptr;
+    }
+    inline bool NativeCodepage() const {
+        return SingleByteCodepage() || CPEnum == CODES_UTF8;
+    }
+};
+
+class TCodePageHash;
+
+namespace NCodepagePrivate {
+    class TCodepagesMap {
+    private:
+        static const int DataShift = 2;
+        static const int DataSize = CODES_MAX + DataShift;
+        const CodePage* Data[DataSize];
+
+    private:
+        inline const CodePage* GetPrivate(ECharset e) const {
+            Y_ASSERT(e + DataShift >= 0 && e + DataShift < DataSize);
+            return Data[e + DataShift];
+        }
+
+        void SetData(const CodePage* cp);
+
+    public:
+        TCodepagesMap();
+
+        inline const CodePage* Get(ECharset e) const {
+            const CodePage* res = GetPrivate(e);
+            if (!res->SingleByteCodepage()) {
+                ythrow yexception() << "CodePage (" << (int)e << ") structure can only be used for single byte encodings";
+            }
+
+            return res;
+        }
+
+        inline bool SingleByteCodepage(ECharset e) const {
+            return GetPrivate(e)->SingleByteCodepage();
+        }
+        inline bool NativeCodepage(ECharset e) const {
+            return GetPrivate(e)->NativeCodepage();
+        }
+        inline const char* NameByCharset(ECharset e) const {
+            return GetPrivate(e)->Names[0];
+        }
+
+        static const TCodepagesMap& Instance();
+
+        friend class ::TCodePageHash;
+    };
+
+    inline bool NativeCodepage(ECharset e) {
+        return ::NCodepagePrivate::TCodepagesMap::Instance().NativeCodepage(e);
+    }
+}
+
+inline bool SingleByteCodepage(ECharset e) {
+    return ::NCodepagePrivate::TCodepagesMap::Instance().SingleByteCodepage(e);
+}
+
+inline bool ValidCodepage(ECharset e) {
+    return e >= 0 && e < CODES_MAX;
+}
+
+inline const CodePage* CodePageByCharset(ECharset e) {
+    return ::NCodepagePrivate::TCodepagesMap::Instance().Get(e);
+}
+
+ECharset CharsetByName(TStringBuf name);
+
+// Same as CharsetByName, but throws yexception() if name is invalid
+ECharset CharsetByNameOrDie(TStringBuf name);
+
+inline ECharset CharsetByCodePage(const CodePage* CP) {
+    return CP->CPEnum;
+}
+
+inline const char* NameByCharset(ECharset e) {
+    return ::NCodepagePrivate::TCodepagesMap::Instance().NameByCharset(e);
+}
+
+inline const char* NameByCharsetSafe(ECharset e) {
+    if (CODES_UNKNOWN < e && e < CODES_MAX)
+        return ::NCodepagePrivate::TCodepagesMap::Instance().NameByCharset(e);
+    else
+        ythrow yexception() << "unknown encoding: " << (int)e;
+}
+
+inline const char* NameByCodePage(const CodePage* CP) {
+    return CP->Names[0];
+}
+
+inline const CodePage* CodePageByName(const char* name) {
+    ECharset code = CharsetByName(name);
+    if (code == CODES_UNKNOWN)
+        return nullptr;
+
+    return CodePageByCharset(code);
+}
+
+ECharset EncodingHintByName(const char* name);
+
+/*****************************************************************\
+*                    struct Encoder                               *
+\*****************************************************************/
+struct Encoder {
+    char* Table[256];
+    const char* DefaultChar;
+
+    inline char Code(wchar32 ch) const {
+        if (ch > 0xFFFF)
+            return 0;
+        return (unsigned char)Table[(ch >> 8) & 255][ch & 255];
+    }
+
+    inline char Tr(wchar32 ch) const {
+        char code = Code(ch);
+        if (code == 0 && ch != 0)
+            code = DefaultChar[NUnicode::CharType(ch)];
+        Y_ASSERT(code != 0 || ch == 0);
+        return code;
+    }
+
+    inline unsigned char operator[](wchar32 ch) const {
+        return Tr(ch);
+    }
+
+    void Tr(const wchar32* in, char* out, size_t len) const;
+    void Tr(const wchar32* in, char* out) const;
+    char* DefaultPlane;
+};
+
+/*****************************************************************\
+*                    struct Recoder                               *
+\*****************************************************************/
+struct Recoder {
+    unsigned char Table[257];
+
+    void Create(const CodePage& source, const CodePage& target);
+    void Create(const CodePage& source, const Encoder* wideTarget);
+
+    void Create(const CodePage& page, wchar32 (*mapper)(wchar32));
+    void Create(const CodePage& page, const Encoder* widePage, wchar32 (*mapper)(wchar32));
+
+    inline unsigned char Tr(unsigned char c) const {
+        return Table[c];
+    }
+    inline unsigned char operator[](unsigned char c) const {
+        return Table[c];
+    }
+    void Tr(const char* in, char* out, size_t len) const;
+    void Tr(const char* in, char* out) const;
+    void Tr(char* in_out, size_t len) const;
+    void Tr(char* in_out) const;
+};
+
+extern const struct Encoder& WideCharToYandex;
+
+const Encoder& EncoderByCharset(ECharset enc);
+
+namespace NCodepagePrivate {
+    class TCodePageData {
+    private:
+        static const CodePage* const AllCodePages[];
+
+        static const Recoder rcdr_to_yandex[];
+        static const Recoder rcdr_from_yandex[];
+        static const Recoder rcdr_to_lower[];
+        static const Recoder rcdr_to_upper[];
+        static const Recoder rcdr_to_title[];
+
+        static const Encoder* const EncodeTo[];
+
+        friend struct ::CodePage;
+        friend class TCodepagesMap;
+        friend RECODE_RESULT _recodeToYandex(ECharset, const char*, char*, size_t, size_t, size_t&, size_t&);
+        friend RECODE_RESULT _recodeFromYandex(ECharset, const char*, char*, size_t, size_t, size_t&, size_t&);
+        friend const Encoder& ::EncoderByCharset(ECharset enc);
+    };
+}
+
+inline const Encoder& EncoderByCharset(ECharset enc) {
+    if (!SingleByteCodepage(enc)) {
+        ythrow yexception() << "Encoder structure can only be used for single byte encodings";
+    }
+
+    return *NCodepagePrivate::TCodePageData::EncodeTo[enc];
+}
+
+inline unsigned char CodePage::ToUpper(unsigned char ch) const {
+    return NCodepagePrivate::TCodePageData::rcdr_to_upper[CPEnum].Table[ch];
+}
+inline unsigned char CodePage::ToLower(unsigned char ch) const {
+    return NCodepagePrivate::TCodePageData::rcdr_to_lower[CPEnum].Table[ch];
+}
+inline unsigned char CodePage::ToTitle(unsigned char ch) const {
+    return NCodepagePrivate::TCodePageData::rcdr_to_title[CPEnum].Table[ch];
+}
+
+extern const CodePage& csYandex;
+
+/// these functions change (lowers) [end] position in case of utf-8
+/// null character is NOT assumed or written at [*end]
+void DecodeUnknownPlane(wchar16* start, wchar16*& end, const ECharset enc4unk);
+void DecodeUnknownPlane(wchar32* start, wchar32*& end, const ECharset enc4unk);
+
+inline void ToLower(char* s, size_t n, const CodePage& cp = csYandex) {
+    char* const e = s + n;
+    for (; s != e; ++s)
+        *s = cp.ToLower(*s);
+}
+
+inline void ToUpper(char* s, size_t n, const CodePage& cp = csYandex) {
+    char* const e = s + n;
+    for (; s != e; ++s)
+        *s = cp.ToUpper(*s);
+}
+
+inline TString ToLower(TString s, const CodePage& cp, size_t pos = 0, size_t n = TString::npos) {
+    s.Transform([&cp](size_t, char c) { return cp.ToLower(c); }, pos, n);
+    return s;
+}
+
+inline TString ToUpper(TString s, const CodePage& cp, size_t pos = 0, size_t n = TString::npos) {
+    s.Transform([&cp](size_t, char c) { return cp.ToUpper(c); }, pos, n);
+    return s;
+}
+
+inline TString ToTitle(TString s, const CodePage& cp, size_t pos = 0, size_t n = TString::npos) {
+    s.Transform(
+        [pos, &cp](size_t i, char c) {
+            return i == pos ? cp.ToTitle(c) : cp.ToLower(c);
+        },
+        pos,
+        n);
+    return s;
+}
diff --git a/library/cpp/charset/codepage_ut.cpp b/library/cpp/charset/codepage_ut.cpp
new file mode 100644
index 0000000000..c3ac3ac478
--- /dev/null
+++ b/library/cpp/charset/codepage_ut.cpp
@@ -0,0 +1,424 @@
+#include "codepage.h"
+#include "recyr.hh"
+#include "wide.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/charset/utf8.h>
+#include <util/system/yassert.h>
+
+#if defined(_MSC_VER)
+#pragma warning(disable : 4309) /*truncation of constant value*/
+#endif
+
+namespace {
+    const char yandexUpperCase[] =
+        "\x81\x82\x83\x84\x85\x86\x87"
+        "\x8E"
+        "\xA1\xA2\xA3\xA4\xA5\xA6"
+        "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
+        "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF"
+        "\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF";
+
+    const char yandexLowerCase[] =
+        "\x91\x92\x93\x94\x95\x96\x97"
+        "\x9E"
+        "\xB1\xB2\xB3\xB4\xB5\xB6"
+        "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF"
+        "\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF"
+        "\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF";
+}
+
+class TCodepageTest: public TTestBase {
+private:
+    UNIT_TEST_SUITE(TCodepageTest);
+    UNIT_TEST(TestUTF);
+    UNIT_TEST(TestUTFFromUnknownPlane);
+    UNIT_TEST(TestBrokenMultibyte);
+    UNIT_TEST(TestSurrogatePairs);
+    UNIT_TEST(TestEncodingHints);
+    UNIT_TEST(TestToLower);
+    UNIT_TEST(TestToUpper);
+    UNIT_TEST(TestUpperLower);
+    UNIT_TEST(TestBrokenRune);
+    UNIT_TEST(TestCanEncode);
+    UNIT_TEST_SUITE_END();
+
+public:
+    void TestUTF();
+    void TestUTFFromUnknownPlane();
+    void TestBrokenMultibyte();
+    void TestSurrogatePairs();
+    void TestEncodingHints();
+    void TestToLower();
+    void TestToUpper();
+
+    void TestCanEncode();
+
+    inline void TestUpperLower() {
+        const CodePage* cp = CodePageByCharset(CODES_ASCII);
+        char tmp[100];
+
+        TStringBuf s = "abcde";
+
+        TStringBuf upper(tmp, cp->ToUpper(s.begin(), s.end(), tmp));
+        UNIT_ASSERT_VALUES_EQUAL(upper, TStringBuf("ABCDE"));
+
+        TStringBuf lower(tmp, cp->ToLower(upper.begin(), upper.end(), tmp));
+        UNIT_ASSERT_VALUES_EQUAL(lower, TStringBuf("abcde"));
+    }
+
+    void TestBrokenRune() {
+        UNIT_ASSERT_VALUES_EQUAL(BROKEN_RUNE, 0xFFFDu);
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TCodepageTest);
+
+void TCodepageTest::TestUTF() {
+    for (wchar32 i = 0; i <= 0x10FFFF; i++) {
+        unsigned char buffer[32];
+        Zero(buffer);
+        size_t rune_len;
+        size_t ref_len = 0;
+
+        if (i < 0x80)
+            ref_len = 1;
+        else if (i < 0x800)
+            ref_len = 2;
+        else if (i < 0x10000)
+            ref_len = 3;
+        else
+            ref_len = 4;
+
+        RECODE_RESULT res = SafeWriteUTF8Char(i, rune_len, buffer, buffer + 32);
+        UNIT_ASSERT(res == RECODE_OK);
+        UNIT_ASSERT(rune_len == ref_len);
+
+        res = SafeWriteUTF8Char(i, rune_len, buffer, buffer + ref_len - 1);
+        UNIT_ASSERT(res == RECODE_EOOUTPUT);
+
+        wchar32 rune;
+        res = SafeReadUTF8Char(rune, rune_len, buffer, buffer + 32);
+        UNIT_ASSERT(res == RECODE_OK);
+        UNIT_ASSERT(rune == i);
+        UNIT_ASSERT(rune_len == ref_len);
+
+        res = SafeReadUTF8Char(rune, rune_len, buffer, buffer + ref_len - 1);
+        UNIT_ASSERT(res == RECODE_EOINPUT);
+
+        if (ref_len > 1) {
+            res = SafeReadUTF8Char(rune, rune_len, buffer + 1, buffer + ref_len);
+            UNIT_ASSERT(res == RECODE_BROKENSYMBOL);
+
+            buffer[1] |= 0xC0;
+            res = SafeReadUTF8Char(rune, rune_len, buffer, buffer + ref_len);
+            UNIT_ASSERT(res == RECODE_BROKENSYMBOL);
+
+            buffer[1] &= 0x3F;
+            res = SafeReadUTF8Char(rune, rune_len, buffer, buffer + ref_len);
+            UNIT_ASSERT(res == RECODE_BROKENSYMBOL);
+        }
+    }
+    const char* badStrings[] = {
+        "\xfe",
+        "\xff",
+        "\xcc\xc0",
+        "\xf4\x90\x80\x80",
+        //overlong:
+        "\xfe\xfe\xff\xff",
+        "\xc0\xaf",
+        "\xe0\x80\xaf",
+        "\xf0\x80\x80\xaf",
+        "\xf8\x80\x80\x80\xaf",
+        "\xfc\x80\x80\x80\x80\xaf",
+        "\xc1\xbf",
+        "\xe0\x9f\xbf",
+        "\xf0\x8f\xbf\xbf",
+        "\xf8\x87\xbf\xbf\xbf",
+        "\xfc\x83\xbf\xbf\xbf\xbf",
+        "\xc0\x80",
+        "\xe0\x80\x80",
+        "\xf0\x80\x80\x80",
+        "\xf8\x80\x80\x80\x80",
+        "\xfc\x80\x80\x80\x80\x80",
+        //UTF-16 surrogate (not covered):
+        //"\xed\xa0\x80",
+        //"\xed\xad\xbf",
+        //"\xed\xae\x80",
+        //"\xed\xaf\xbf",
+        //"\xed\xb0\x80",
+        //"\xed\xbe\x80",
+        //"\xed\xbf\xbf",
+    };
+    for (size_t i = 0; i < Y_ARRAY_SIZE(badStrings); ++i) {
+        wchar32 rune;
+        const ui8* p = (const ui8*)badStrings[i];
+        size_t len;
+        RECODE_RESULT res = SafeReadUTF8Char(rune, len, p, p + strlen(badStrings[i]));
+        UNIT_ASSERT(res == RECODE_BROKENSYMBOL);
+    }
+}
+
+void TCodepageTest::TestBrokenMultibyte() {
+    const ECharset cp = CODES_EUC_JP;
+
+    const char sampletext[] = {'\xe3'};
+    wchar32 recodeResult[100];
+
+    size_t nwritten = 0;
+    size_t nread = 0;
+
+    RECODE_RESULT res = RecodeToUnicode(cp, sampletext, recodeResult, Y_ARRAY_SIZE(sampletext), Y_ARRAY_SIZE(recodeResult), nread, nwritten);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(nread == 1);
+    UNIT_ASSERT(nwritten == 0);
+
+    const char bigSample[] = {'\xC3', '\x87', '\xC3', '\x8E', '\xC2', '\xB0', '\xC3', '\x85', '\xC3', '\x85', '\xC3', '\xB8'};
+    res = RecodeToUnicode(cp, bigSample, recodeResult, Y_ARRAY_SIZE(bigSample), Y_ARRAY_SIZE(recodeResult), nread, nwritten);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(nread == Y_ARRAY_SIZE(bigSample));
+}
+
+void TCodepageTest::TestUTFFromUnknownPlane() {
+    static const wchar32 sampletext[] = {0x61, 0x62, 0x63, 0x20,
+                                         0x430, 0x431, 0x432, 0x20,
+                                         0x1001, 0x1002, 0x1003, 0x20,
+                                         0x10001, 0x10002, 0x10003};
+
+    static const size_t BUFFER_SIZE = 1024;
+    char bytebuffer[BUFFER_SIZE];
+
+    size_t readchars = 0;
+    size_t writtenbytes = 0;
+    size_t samplelen = Y_ARRAY_SIZE(sampletext);
+
+    RECODE_RESULT res = RecodeFromUnicode(CODES_UTF8, sampletext, bytebuffer, samplelen, BUFFER_SIZE, readchars, writtenbytes);
+
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(samplelen == readchars);
+
+    size_t writtenbytes2 = 0;
+    char bytebuffer2[BUFFER_SIZE];
+    for (size_t i = 0; i != samplelen; ++i) {
+        size_t nwr = 0;
+        const int res = RecodeFromUnicode(CODES_UTF8, sampletext[i], bytebuffer2 + writtenbytes2, BUFFER_SIZE - writtenbytes2, nwr);
+        UNIT_ASSERT_VALUES_EQUAL(res, int(RECODE_OK));
+        writtenbytes2 += nwr;
+        UNIT_ASSERT(BUFFER_SIZE > writtenbytes2);
+    }
+    UNIT_ASSERT_VALUES_EQUAL(TStringBuf(bytebuffer, writtenbytes), TStringBuf(bytebuffer2, writtenbytes2));
+
+    wchar32 charbuffer[BUFFER_SIZE];
+    size_t readbytes = 0;
+    size_t writtenchars = 0;
+
+    res = RecodeToUnicode(CODES_UNKNOWNPLANE, bytebuffer, charbuffer, writtenbytes, BUFFER_SIZE, readbytes, writtenchars);
+
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(readbytes == writtenbytes);
+
+    wchar32* charbufferend = charbuffer + writtenchars;
+    DecodeUnknownPlane(charbuffer, charbufferend, CODES_UTF8);
+
+    UNIT_ASSERT(charbufferend == charbuffer + samplelen);
+    for (size_t i = 0; i < samplelen; ++i)
+        UNIT_ASSERT(sampletext[i] == charbuffer[i]);
+
+    // Now, concatenate the thing with an explicit character and retest
+    res = RecodeToUnicode(CODES_UNKNOWNPLANE, bytebuffer, charbuffer, writtenbytes, BUFFER_SIZE, readbytes, writtenchars);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(readbytes == writtenbytes);
+
+    charbuffer[writtenchars] = 0x1234;
+
+    size_t morewrittenchars = 0;
+    res = RecodeToUnicode(CODES_UNKNOWNPLANE, bytebuffer, charbuffer + writtenchars + 1, writtenbytes, BUFFER_SIZE, readbytes, morewrittenchars);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(readbytes == writtenbytes);
+    UNIT_ASSERT(writtenchars == morewrittenchars);
+
+    charbuffer[2 * writtenchars + 1] = 0x5678;
+
+    charbufferend = charbuffer + 2 * writtenchars + 2;
+    DecodeUnknownPlane(charbuffer, charbufferend, CODES_UTF8);
+
+    UNIT_ASSERT(charbufferend == charbuffer + 2 * samplelen + 2);
+    for (size_t i = 0; i < samplelen; ++i) {
+        UNIT_ASSERT(sampletext[i] == charbuffer[i]);
+        UNIT_ASSERT(sampletext[i] == charbuffer[samplelen + 1 + i]);
+    }
+    UNIT_ASSERT(0x1234 == charbuffer[samplelen]);
+    UNIT_ASSERT(0x5678 == charbuffer[2 * samplelen + 1]);
+
+    // test TChar version
+    // bytebuffer of len writtenbytes contains sampletext of len samplelen chars in utf8
+    TUtf16String wtr = CharToWide(TStringBuf(bytebuffer, writtenbytes), CODES_UNKNOWNPLANE);
+    TChar* strend = wtr.begin() + wtr.size();
+    DecodeUnknownPlane(wtr.begin(), strend, CODES_UTF8);
+    wtr.resize(strend - wtr.data(), 'Q');
+    UNIT_ASSERT_VALUES_EQUAL(wtr.size(), samplelen);
+    for (size_t i = 0; i < wtr.size(); ++i) {
+        if (sampletext[i] >= 0x10000) {
+            UNIT_ASSERT_VALUES_EQUAL(wtr[i], ' ');
+        } else {
+            UNIT_ASSERT_VALUES_EQUAL(wtr[i], sampletext[i]);
+        }
+    }
+}
+
+static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize) {
+    size_t sSize = strlen(str);
+    size_t wSize = sSize * 2;
+    TArrayHolder<wchar16> w(new wchar16[wSize]);
+
+    size_t read = 0;
+    size_t written = 0;
+    RECODE_RESULT res = RecodeToUnicode(CODES_UTF8, str, w.Get(), sSize, wSize, read, written);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(read == sSize);
+    UNIT_ASSERT(written == wideSize);
+    UNIT_ASSERT(!memcmp(w.Get(), wide, wideSize));
+
+    TArrayHolder<char> s(new char[sSize]);
+    res = RecodeFromUnicode(CODES_UTF8, w.Get(), s.Get(), wideSize, sSize, read, written);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(read == wideSize);
+    UNIT_ASSERT(written == sSize);
+    UNIT_ASSERT(!memcmp(s.Get(), str, sSize));
+}
+
+void TCodepageTest::TestSurrogatePairs() {
+    const char* utf8NonBMP = "\xf4\x80\x89\x84\xf4\x80\x89\x87\xf4\x80\x88\xba";
+    wchar16 wNonBMPDummy[] = {0xDBC0, 0xDE44, 0xDBC0, 0xDE47, 0xDBC0, 0xDE3A};
+    TestSurrogates(utf8NonBMP, wNonBMPDummy, Y_ARRAY_SIZE(wNonBMPDummy));
+
+    const char* utf8NonBMP2 = "ab\xf4\x80\x89\x87n";
+    wchar16 wNonBMPDummy2[] = {'a', 'b', 0xDBC0, 0xDE47, 'n'};
+    TestSurrogates(utf8NonBMP2, wNonBMPDummy2, Y_ARRAY_SIZE(wNonBMPDummy2));
+}
+
+void TCodepageTest::TestEncodingHints() {
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("windows-1251"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("Windows1251"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("WIN1251"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("window-cp1251"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("!!!CP1251???"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("'ansi-cp1251;'"));
+    UNIT_ASSERT(CODES_WIN == EncodingHintByName("charset=Microsoft-CP1251;"));
+
+    UNIT_ASSERT(CODES_ISO_EAST == EncodingHintByName("iso-8859-2"));
+    UNIT_ASSERT(CODES_ISO_EAST == EncodingHintByName("iso-2"));
+    UNIT_ASSERT(CODES_ISO_EAST == EncodingHintByName("iso-latin-2"));
+    UNIT_ASSERT(CODES_ISO_EAST == EncodingHintByName("charset=\"Latin2\";"));
+
+    UNIT_ASSERT(CODES_UNKNOWN == EncodingHintByName("widow1251"));
+    UNIT_ASSERT(CODES_UNKNOWN == EncodingHintByName("default"));
+    UNIT_ASSERT(CODES_UNKNOWN == EncodingHintByName("$phpcharset"));
+
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("ShiftJIS"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("Shift_JIS"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("Big5"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("euc-kr"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("EUC-JP"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("charset='Shift_JIS';;"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("ISO-2022-KR"));
+    UNIT_ASSERT(CODES_UNSUPPORTED != EncodingHintByName("ISO-2022-jp"));
+}
+
+void TCodepageTest::TestToLower() {
+    TTempBuf buf;
+    char* data = buf.Data();
+    const size_t n = Y_ARRAY_SIZE(yandexUpperCase); // including NTS
+    memcpy(data, yandexUpperCase, n);
+    ToLower(data, n - 1);
+    UNIT_ASSERT(strcmp(data, yandexLowerCase) == 0);
+}
+
+void TCodepageTest::TestToUpper() {
+    TTempBuf buf;
+    char* data = buf.Data();
+    const size_t n = Y_ARRAY_SIZE(yandexLowerCase); // including NTS
+    memcpy(data, yandexLowerCase, n);
+    ToUpper(data, n - 1);
+    UNIT_ASSERT(strcmp(data, yandexUpperCase) == 0);
+}
+
+static void TestCanEncodeEmpty() {
+    TWtringBuf empty;
+    UNIT_ASSERT(CanBeEncoded(empty, CODES_WIN));
+    UNIT_ASSERT(CanBeEncoded(empty, CODES_YANDEX));
+    UNIT_ASSERT(CanBeEncoded(empty, CODES_UTF8));
+}
+
+static void TestCanEncodeEach(const TWtringBuf& text, ECharset encoding, bool expectedResult) {
+    // char by char
+    for (size_t i = 0; i < text.size(); ++i) {
+        if (CanBeEncoded(text.SubStr(i, 1), encoding) != expectedResult)
+            ythrow yexception() << "assertion failed: encoding " << NameByCharset(encoding)
+                                << " on '" << text.SubStr(i, 1) << "' (expected " << expectedResult << ")";
+    }
+    // whole text
+    UNIT_ASSERT_EQUAL(CanBeEncoded(text, encoding), expectedResult);
+}
+
+void TCodepageTest::TestCanEncode() {
+    TestCanEncodeEmpty();
+
+    const TUtf16String lat = u"AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
+    TestCanEncodeEach(lat, CODES_WIN, true);
+    TestCanEncodeEach(lat, CODES_YANDEX, true);
+    TestCanEncodeEach(lat, CODES_UTF8, true);
+
+    const TUtf16String rus = u"АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя";
+    TestCanEncodeEach(rus, CODES_WIN, true);
+    TestCanEncodeEach(rus, CODES_YANDEX, true);
+    TestCanEncodeEach(rus, CODES_UTF8, true);
+
+    const TUtf16String ukr = u"ҐґЄєІіЇї";
+    TestCanEncodeEach(ukr, CODES_WIN, true);
+    TestCanEncodeEach(ukr, CODES_YANDEX, true);
+    TestCanEncodeEach(ukr, CODES_UTF8, true);
+
+    const TUtf16String pol = u"ĄĆĘŁŃÓŚŹŻąćęłńóśźż";
+    TestCanEncodeEach(pol, CODES_WIN, false);
+    TestCanEncodeEach(pol, CODES_YANDEX, true);
+    TestCanEncodeEach(pol, CODES_UTF_16BE, true);
+
+    const TUtf16String ger = u"ÄäÖöÜüß";
+    TestCanEncodeEach(ger, CODES_WIN, false);
+    TestCanEncodeEach(ger, CODES_YANDEX, true);
+    TestCanEncodeEach(ger, CODES_UTF_16LE, true);
+
+    const TUtf16String fra1 = u"éàèùâêîôûëïç"; // supported in yandex cp
+    const TUtf16String fra2 = u"ÉÀÈÙÂÊÎÔÛËÏŸÿÇ";
+    const TUtf16String fra3 = u"ÆæŒœ";
+    TestCanEncodeEach(fra1 + fra2 + fra3, CODES_WIN, false);
+    TestCanEncodeEach(fra1, CODES_YANDEX, true);
+    TestCanEncodeEach(fra2 + fra3, CODES_YANDEX, false);
+    TestCanEncodeEach(fra1 + fra2 + fra3, CODES_UTF8, true);
+
+    const TUtf16String kaz = u"ӘәҒғҚқҢңӨөҰұҮүҺһ";
+    TestCanEncodeEach(kaz, CODES_WIN, false);
+    TestCanEncodeEach(kaz, CODES_YANDEX, false);
+    TestCanEncodeEach(kaz, CODES_UTF8, true);
+    TestCanEncodeEach(kaz, CODES_KAZWIN, true);
+
+    const TUtf16String tur1 = u"ĞİŞğş";
+    const TUtf16String tur = tur1 + u"ı";
+    TestCanEncodeEach(tur, CODES_WIN, false);
+    TestCanEncodeEach(tur, CODES_YANDEX, false);
+    TestCanEncodeEach(tur, CODES_UTF8, true);
+
+    const TUtf16String chi = u"新隶体新隸體";
+    TestCanEncodeEach(chi, CODES_WIN, false);
+    TestCanEncodeEach(chi, CODES_YANDEX, false);
+    TestCanEncodeEach(chi, CODES_UTF8, true);
+    TestCanEncodeEach(chi, CODES_UTF_16LE, true);
+
+    const TUtf16String jap = u"漢字仮字交じり文";
+    TestCanEncodeEach(jap, CODES_WIN, false);
+    TestCanEncodeEach(jap, CODES_YANDEX, false);
+    TestCanEncodeEach(jap, CODES_UTF8, true);
+    TestCanEncodeEach(jap, CODES_UTF_16BE, true);
+}
diff --git a/library/cpp/charset/cp_encrec.cpp b/library/cpp/charset/cp_encrec.cpp
new file mode 100644
index 0000000000..1334afaa90
--- /dev/null
+++ b/library/cpp/charset/cp_encrec.cpp
@@ -0,0 +1,54 @@
+#include "codepage.h"
+
+#include <util/string/cast.h>
+#include <util/stream/output.h>
+
+void Encoder::Tr(const wchar32* in, char* out, size_t len) const {
+    while (len--)
+        *out++ = Tr(*in++);
+}
+
+void Encoder::Tr(const wchar32* in, char* out) const {
+    do {
+        *out++ = Tr(*in);
+    } while (*in++);
+}
+
+void Recoder::Create(const CodePage& source, const Encoder* wideTarget) {
+    for (size_t i = 0; i != 256; ++i) {
+        Table[i] = wideTarget->Tr(source.unicode[i]);
+        Y_ASSERT(Table[i] != 0 || i == 0);
+    }
+}
+
+void Recoder::Create(const CodePage& page, const Encoder* widePage, wchar32 (*mapfunc)(wchar32)) {
+    for (size_t i = 0; i != 256; ++i) {
+        char c = widePage->Code((*mapfunc)(page.unicode[i]));
+        Table[i] = (c == 0 && i != 0) ? (unsigned char)i : (unsigned char)c;
+    }
+}
+
+void Recoder::Tr(const char* in, char* out, size_t len) const {
+    while (len--)
+        *out++ = Table[(unsigned char)*in++];
+}
+
+void Recoder::Tr(const char* in, char* out) const {
+    do {
+        *out++ = Table[(unsigned char)*in];
+    } while (*in++);
+}
+
+void Recoder::Tr(char* in_out, size_t len) const {
+    while (len--) {
+        *in_out = Table[(unsigned char)*in_out];
+        in_out++;
+    }
+}
+
+void Recoder::Tr(char* in_out) const {
+    // assuming that '\0' <--> '\0'
+    do {
+        *in_out = Table[(unsigned char)*in_out];
+    } while (*in_out++);
+}
diff --git a/library/cpp/charset/doccodes.cpp b/library/cpp/charset/doccodes.cpp
new file mode 100644
index 0000000000..1fc17a3275
--- /dev/null
+++ b/library/cpp/charset/doccodes.cpp
@@ -0,0 +1 @@
+#include "doccodes.h"
diff --git a/library/cpp/charset/doccodes.h b/library/cpp/charset/doccodes.h
new file mode 100644
index 0000000000..75c87adf9e
--- /dev/null
+++ b/library/cpp/charset/doccodes.h
@@ -0,0 +1,129 @@
+#pragma once
+
+enum ECharset {
+    CODES_UNSUPPORTED = -2, // valid but unsupported encoding
+    CODES_UNKNOWN = -1,     // invalid or unspecified encoding
+    CODES_WIN,              // [ 0] WINDOWS_1251     Windows
+    CODES_KOI8,             // [ 1] KOI8_U           Koi8-u
+    CODES_ALT,              // [ 2] IBM_866          MS DOS, alternative
+    CODES_MAC,              // [ 3] MAC_CYRILLIC     Macintosh
+    CODES_MAIN,             // [ 4] ISO_LATIN_CYRILLIC Main
+    CODES_ASCII,            // [ 5] WINDOWS_1252     Latin 1
+    CODES_RESERVED_3,       // reserved code: use it for new encodings before adding them to the end of the list
+    CODES_WIN_EAST,         // [ 7] WINDOWS_1250     WIN PL
+    CODES_ISO_EAST,         // [ 8] ISO_8859_2       ISO PL
+    // our superset of subset of windows-1251
+    CODES_YANDEX,   // [ 9] YANDEX
+    CODES_UTF_16BE, // [10] UTF_16BE
+    CODES_UTF_16LE, // [11] UTF_16LE
+    // missing standard codepages
+    CODES_IBM855,       // [12] IBM_855
+    CODES_UTF8,         // [13] UTF8
+    CODES_UNKNOWNPLANE, // [14] Unrecognized characters are mapped into the PUA: U+F000..U+F0FF
+
+    CODES_KAZWIN,       // [15] WINDOWS_1251_K   Kazakh version of Windows-1251
+    CODES_TATWIN,       // [16] WINDOWS_1251_T   Tatarian version of Windows-1251
+    CODES_ARMSCII,      // [17] Armenian ASCII
+    CODES_GEO_ITA,      // [18] Academy of Sciences Georgian
+    CODES_GEO_PS,       // [19] Georgian Parliament
+    CODES_ISO_8859_3,   // [20] Latin-3: Turkish, Maltese and Esperanto
+    CODES_ISO_8859_4,   // [21] Latin-4: Estonian, Latvian, Lithuanian, Greenlandic, Sami
+    CODES_ISO_8859_6,   // [22] Latin/Arabic: Arabic
+    CODES_ISO_8859_7,   // [23] Latin/Greek: Greek
+    CODES_ISO_8859_8,   // [24] Latin/Hebrew: Hebrew
+    CODES_ISO_8859_9,   // [25] Latin-5 or Turkish: Turkish
+    CODES_ISO_8859_13,  // [26] Latin-7 or Baltic Rim: Baltic languages
+    CODES_ISO_8859_15,  // [27] Latin-9: Western European languages
+    CODES_ISO_8859_16,  // [28] Latin-10: South-Eastern European languages
+    CODES_WINDOWS_1253, // [29] for Greek
+    CODES_WINDOWS_1254, // [30] for Turkish
+    CODES_WINDOWS_1255, // [31] for Hebrew
+    CODES_WINDOWS_1256, // [32] for Arabic
+    CODES_WINDOWS_1257, // [33] for Estonian, Latvian and Lithuanian
+
+    // these codes are all the other 8bit codes known by libiconv
+    // they follow in alphanumeric order
+    CODES_CP1046,
+    CODES_CP1124,
+    CODES_CP1125,
+    CODES_CP1129,
+    CODES_CP1131,
+    CODES_CP1133,
+    CODES_CP1161, // [40]
+    CODES_CP1162,
+    CODES_CP1163,
+    CODES_CP1258,
+    CODES_CP437,
+    CODES_CP737,
+    CODES_CP775,
+    CODES_CP850,
+    CODES_CP852,
+    CODES_CP853,
+    CODES_CP856, // [50]
+    CODES_CP857,
+    CODES_CP858,
+    CODES_CP860,
+    CODES_CP861,
+    CODES_CP862,
+    CODES_CP863,
+    CODES_CP864,
+    CODES_CP865,
+    CODES_CP869,
+    CODES_CP874, // [60]
+    CODES_CP922,
+    CODES_HP_ROMAN8,
+    CODES_ISO646_CN,
+    CODES_ISO646_JP,
+    CODES_ISO8859_10,
+    CODES_ISO8859_11,
+    CODES_ISO8859_14,
+    CODES_JISX0201,
+    CODES_KOI8_T,
+    CODES_MAC_ARABIC, // [70]
+    CODES_MAC_CENTRALEUROPE,
+    CODES_MAC_CROATIAN,
+    CODES_MAC_GREEK,
+    CODES_MAC_HEBREW,
+    CODES_MAC_ICELAND,
+    CODES_MAC_ROMANIA,
+    CODES_MAC_ROMAN,
+    CODES_MAC_THAI,
+    CODES_MAC_TURKISH,
+    CODES_RESERVED_2, // [80] reserved code: use it for new encodings before adding them to the end of the list
+    CODES_MULELAO,
+    CODES_NEXTSTEP,
+    CODES_PT154,
+    CODES_RISCOS_LATIN1,
+    CODES_RK1048,
+    CODES_TCVN,
+    CODES_TDS565,
+    CODES_TIS620,
+    CODES_VISCII,
+
+    // libiconv multibyte codepages
+    CODES_BIG5, // [90]
+    CODES_BIG5_HKSCS,
+    CODES_BIG5_HKSCS_1999,
+    CODES_BIG5_HKSCS_2001,
+    CODES_CP932,
+    CODES_CP936,
+    CODES_CP949,
+    CODES_CP950,
+    CODES_EUC_CN,
+    CODES_EUC_JP,
+    CODES_EUC_KR, // [100]
+    CODES_EUC_TW,
+    CODES_GB18030,
+    CODES_GBK,
+    CODES_HZ,
+    CODES_ISO_2022_CN,
+    CODES_ISO_2022_CN_EXT,
+    CODES_ISO_2022_JP,
+    CODES_ISO_2022_JP_1,
+    CODES_ISO_2022_JP_2,
+    CODES_ISO_2022_KR, // [110]
+    CODES_JOHAB,
+    CODES_SHIFT_JIS,
+
+    CODES_MAX
+};
diff --git a/library/cpp/charset/generated/cp_data.cpp b/library/cpp/charset/generated/cp_data.cpp
new file mode 100644
index 0000000000..202362c596
--- /dev/null
+++ b/library/cpp/charset/generated/cp_data.cpp
@@ -0,0 +1,3788 @@
+#include <library/cpp/charset/codepage.h>
+
+extern const char defchars[][DEFCHAR_BUF];
+
+static const CodePage CODES_ALT_CODE_PAGE = {
+    CODES_ALT,
+    {"IBM866", "csIBM866", "cp866", "866", "dos-866", "alt", "windows-866",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+        0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+        0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ARMSCII_CODE_PAGE = {
+    CODES_ARMSCII,
+    {"armscii",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x0530, 0x0587, 0x0589, 0x0029, 0x0028, 0x00BB, 0x00AB,
+        0x2014, 0x002E, 0x055D, 0x002C, 0x002D, 0x058A, 0x2026, 0x055C,
+        0x055B, 0x055E, 0x0531, 0x0561, 0x0532, 0x0562, 0x0533, 0x0563,
+        0x0534, 0x0564, 0x0535, 0x0565, 0x0536, 0x0566, 0x0537, 0x0567,
+        0x0538, 0x0568, 0x0539, 0x0569, 0x053A, 0x056A, 0x053B, 0x056B,
+        0x053C, 0x056C, 0x053D, 0x056D, 0x053E, 0x056E, 0x053F, 0x056F,
+        0x0540, 0x0570, 0x0541, 0x0571, 0x0542, 0x0572, 0x0543, 0x0573,
+        0x0544, 0x0574, 0x0545, 0x0575, 0x0546, 0x0576, 0x0547, 0x0577,
+        0x0548, 0x0578, 0x0549, 0x0579, 0x054A, 0x057A, 0x054B, 0x057B,
+        0x054C, 0x057C, 0x054D, 0x057D, 0x054E, 0x057E, 0x054F, 0x057F,
+        0x0550, 0x0580, 0x0551, 0x0581, 0x0552, 0x0582, 0x0553, 0x0583,
+        0x0554, 0x0584, 0x0555, 0x0585, 0x0556, 0x0586, 0x055A, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from armscii.txt
+
+static const CodePage CODES_ASCII_CODE_PAGE = {
+    CODES_ASCII,
+    {"windows-1252", "cp1252", "1252", "US-ASCII", "ASCII", "csASCII", "ANSI_X3.4-1968", "ANSI_X3.4-1986", "IBM367", "cp367", "367", "iso-ir-100", "IBM819", "cp819", "819", "latin1", "l1", "ISOLatin1", "csISOLatin1", "ISO-8859-1", "ISO_8859-1", "ISO_8859-1:1987", "iso-ir-6", "iso_646.irv:1991", "ISO646-US", "US",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0x017D, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0x017E, 0x0178,
+        0x00A0, 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,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_BIG5_CODE_PAGE = {
+    CODES_BIG5,
+    {"BIG5", "BIGFIVE", "CN-BIG5", "CSBIG5",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_BIG5_HKSCS_CODE_PAGE = {
+    CODES_BIG5_HKSCS,
+    {"BIG5-HKSCS", "BIG5-HKSCS:2004",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_BIG5_HKSCS_1999_CODE_PAGE = {
+    CODES_BIG5_HKSCS_1999,
+    {"BIG5-HKSCS:1999",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_BIG5_HKSCS_2001_CODE_PAGE = {
+    CODES_BIG5_HKSCS_2001,
+    {"BIG5-HKSCS:2001",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_CP1046_CODE_PAGE = {
+    CODES_CP1046,
+    {"CP1046", "windows-1046",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFE88, 0x00D7, 0x00F7, 0xF8F6, 0xF8F5, 0xF8F4, 0xF8F7, 0xFE71,
+        0x0088, 0x25A0, 0x2502, 0x2500, 0x2510, 0x250C, 0x2514, 0x2518,
+        0xFE79, 0xFE7B, 0xFE7D, 0xFE7F, 0xFE77, 0xFE8A, 0xFEF0, 0xFEF3,
+        0xFEF2, 0xFECE, 0xFECF, 0xFED0, 0xFEF6, 0xFEF8, 0xFEFA, 0xFEFC,
+        0x00A0, 0xF8FA, 0xF8F9, 0xF8F8, 0x00A4, 0xF8FB, 0xFE8B, 0xFE91,
+        0xFE97, 0xFE9B, 0xFE9F, 0xFEA3, 0x060C, 0x00AD, 0xFEA7, 0xFEB3,
+        0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667,
+        0x0668, 0x0669, 0xFEB7, 0x061B, 0xFEBB, 0xFEBF, 0xFECA, 0x061F,
+        0xFECB, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+        0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
+        0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
+        0xFEC7, 0x0639, 0x063A, 0xFECC, 0xFE82, 0xFE84, 0xFE8E, 0xFED3,
+        0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
+        0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
+        0x0650, 0x0651, 0x0652, 0xFED7, 0xFEDB, 0xFEDF, 0xF8FC, 0xFEF5,
+        0xFEF7, 0xFEF9, 0xFEFB, 0xFEE3, 0xFEE7, 0xFEEC, 0xFEE9, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from cp1046.txt
+
+static const CodePage CODES_CP1124_CODE_PAGE = {
+    CODES_CP1124,
+    {"CP1124", "windows-1124",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0401, 0x0402, 0x0490, 0x0404, 0x0405, 0x0406, 0x0407,
+        0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 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,
+        0x2116, 0x0451, 0x0452, 0x0491, 0x0454, 0x0455, 0x0456, 0x0457,
+        0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F,
+    },
+    defchars[0],
+}; // generated from cp1124.txt
+
+static const CodePage CODES_CP1125_CODE_PAGE = {
+    CODES_CP1125,
+    {"CP1125", "windows-1125",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+        0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+        0x0401, 0x0451, 0x0490, 0x0491, 0x0404, 0x0454, 0x0406, 0x0456,
+        0x0407, 0x0457, 0x00B7, 0x221A, 0x2116, 0x00A4, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from cp1125.txt
+
+static const CodePage CODES_CP1129_CODE_PAGE = {
+    CODES_CP1129,
+    {"CP1129", "windows-1129",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+        0x0153, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0178, 0x00B5, 0x00B6, 0x00B7,
+        0x0152, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+        0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
+        0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
+        0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF,
+    },
+    defchars[0],
+}; // generated from cp1129.txt
+
+static const CodePage CODES_CP1131_CODE_PAGE = {
+    CODES_CP1131,
+    {"CP1131", "windows-1131",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+        0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+        0x0401, 0x0451, 0x0404, 0x0454, 0x0407, 0x0457, 0x040E, 0x045E,
+        0x0406, 0x0456, 0x00B7, 0x00A4, 0x0490, 0x0491, 0x2219, 0x00A0,
+    },
+    defchars[0],
+}; // generated from cp1131.txt
+
+static const CodePage CODES_CP1133_CODE_PAGE = {
+    CODES_CP1133,
+    {"CP1133", "IBM-CP1133", "windows-1133",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0E81, 0x0E82, 0x0E84, 0x0E87, 0x0E88, 0x0EAA, 0x0E8A,
+        0x0E8D, 0x0E94, 0x0E95, 0x0E96, 0x0E97, 0x0E99, 0x0E9A, 0x0E9B,
+        0x0E9C, 0x0E9D, 0x0E9E, 0x0E9F, 0x0EA1, 0x0EA2, 0x0EA3, 0x0EA5,
+        0x0EA7, 0x0EAB, 0x0EAD, 0x0EAE, 0xFFFD, 0xFFFD, 0xFFFD, 0x0EAF,
+        0x0EB0, 0x0EB2, 0x0EB3, 0x0EB4, 0x0EB5, 0x0EB6, 0x0EB7, 0x0EB8,
+        0x0EB9, 0x0EBC, 0x0EB1, 0x0EBB, 0x0EBD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x0EC0, 0x0EC1, 0x0EC2, 0x0EC3, 0x0EC4, 0x0EC8, 0x0EC9, 0x0ECA,
+        0x0ECB, 0x0ECC, 0x0ECD, 0x0EC6, 0xFFFD, 0x0EDC, 0x0EDD, 0x20AD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x0ED0, 0x0ED1, 0x0ED2, 0x0ED3, 0x0ED4, 0x0ED5, 0x0ED6, 0x0ED7,
+        0x0ED8, 0x0ED9, 0xFFFD, 0xFFFD, 0x00A2, 0x00AC, 0x00A6, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from cp1133.txt
+
+static const CodePage CODES_CP1161_CODE_PAGE = {
+    CODES_CP1161,
+    {"CP1161", "windows-1161",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x0E48, 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, 0x0E49, 0x0E4A, 0x0E4B, 0x20AC, 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, 0x00A2, 0x00AC, 0x00A6, 0x00A0,
+    },
+    defchars[0],
+}; // generated from cp1161.txt
+
+static const CodePage CODES_CP1162_CODE_PAGE = {
+    CODES_CP1162,
+    {"CP1162", "windows-1162",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0x0081, 0x0082, 0x0083, 0x0084, 0x2026, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from cp1162.txt
+
+static const CodePage CODES_CP1163_CODE_PAGE = {
+    CODES_CP1163,
+    {"CP1163", "windows-1163",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x00A6, 0x00A7,
+        0x0153, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0178, 0x00B5, 0x00B6, 0x00B7,
+        0x0152, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+        0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
+        0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
+        0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF,
+    },
+    defchars[0],
+}; // generated from cp1163.txt
+
+static const CodePage CODES_CP1258_CODE_PAGE = {
+    CODES_CP1258,
+    {"CP1258", "windows-1258",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0xFFFD, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0xFFFD, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
+        0x00A0, 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, 0x0102, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x0300, 0x00CD, 0x00CE, 0x00CF,
+        0x0110, 0x00D1, 0x0309, 0x00D3, 0x00D4, 0x01A0, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x01AF, 0x0303, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0301, 0x00ED, 0x00EE, 0x00EF,
+        0x0111, 0x00F1, 0x0323, 0x00F3, 0x00F4, 0x01A1, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x01B0, 0x20AB, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP437_CODE_PAGE = {
+    CODES_CP437,
+    {"CP437", "windows-437",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP737_CODE_PAGE = {
+    CODES_CP737,
+    {"CP737", "windows-737",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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, 0x03C2, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03C9, 0x03AC, 0x03AD, 0x03AE, 0x03CA, 0x03AF, 0x03CC, 0x03CD,
+        0x03CB, 0x03CE, 0x0386, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E,
+        0x038F, 0x00B1, 0x2265, 0x2264, 0x03AA, 0x03AB, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP775_CODE_PAGE = {
+    CODES_CP775,
+    {"CP775", "windows-775",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0106, 0x00FC, 0x00E9, 0x0101, 0x00E4, 0x0123, 0x00E5, 0x0107,
+        0x0142, 0x0113, 0x0156, 0x0157, 0x012B, 0x0179, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x014D, 0x00F6, 0x0122, 0x00A2, 0x015A,
+        0x015B, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x00A4,
+        0x0100, 0x012A, 0x00F3, 0x017B, 0x017C, 0x017A, 0x201D, 0x00A6,
+        0x00A9, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x0141, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0104, 0x010C, 0x0118,
+        0x0116, 0x2563, 0x2551, 0x2557, 0x255D, 0x012E, 0x0160, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0172, 0x016A,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x017D,
+        0x0105, 0x010D, 0x0119, 0x0117, 0x012F, 0x0161, 0x0173, 0x016B,
+        0x017E, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x00D3, 0x00DF, 0x014C, 0x0143, 0x00F5, 0x00D5, 0x00B5, 0x0144,
+        0x0136, 0x0137, 0x013B, 0x013C, 0x0146, 0x0112, 0x0145, 0x2019,
+        0x00AD, 0x00B1, 0x201C, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x201E,
+        0x00B0, 0x2219, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP850_CODE_PAGE = {
+    CODES_CP850,
+    {"CP850", "IBM850", "850", "CSPC850MULTILINGUAL", "windows-850",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+        0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
+        0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+        0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
+        0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+        0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP852_CODE_PAGE = {
+    CODES_CP852,
+    {"CP852", "windows-852",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x016F, 0x0107, 0x00E7,
+        0x0142, 0x00EB, 0x0150, 0x0151, 0x00EE, 0x0179, 0x00C4, 0x0106,
+        0x00C9, 0x0139, 0x013A, 0x00F4, 0x00F6, 0x013D, 0x013E, 0x015A,
+        0x015B, 0x00D6, 0x00DC, 0x0164, 0x0165, 0x0141, 0x00D7, 0x010D,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x0104, 0x0105, 0x017D, 0x017E,
+        0x0118, 0x0119, 0x00AC, 0x017A, 0x010C, 0x015F, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x011A,
+        0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x0102, 0x0103,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0x0111, 0x0110, 0x010E, 0x00CB, 0x010F, 0x0147, 0x00CD, 0x00CE,
+        0x011B, 0x2518, 0x250C, 0x2588, 0x2584, 0x0162, 0x016E, 0x2580,
+        0x00D3, 0x00DF, 0x00D4, 0x0143, 0x0144, 0x0148, 0x0160, 0x0161,
+        0x0154, 0x00DA, 0x0155, 0x0170, 0x00FD, 0x00DD, 0x0163, 0x00B4,
+        0x00AD, 0x02DD, 0x02DB, 0x02C7, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x02D9, 0x0171, 0x0158, 0x0159, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP853_CODE_PAGE = {
+    CODES_CP853,
+    {"CP853", "windows-853",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x0109, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x0108,
+        0x00C9, 0x010B, 0x010A, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x0130, 0x00D6, 0x00DC, 0x011D, 0x00A3, 0x011C, 0x00D7, 0x0135,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
+        0x0124, 0x0125, 0xFFFD, 0x00BD, 0x0134, 0x015F, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+        0x015E, 0x2563, 0x2551, 0x2557, 0x255D, 0x017B, 0x017C, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x015C, 0x015D,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0xFFFD, 0xFFFD, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
+        0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0xFFFD, 0x00CC, 0x2580,
+        0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x0120, 0x0121, 0x00B5, 0x0126,
+        0x0127, 0x00DA, 0x00DB, 0x00D9, 0x016C, 0x016D, 0xFFFD, 0x00B4,
+        0x00AD, 0xFFFD, 0x2113, 0x0149, 0x02D8, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x02D9, 0xFFFD, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from cp853.txt
+
+static const CodePage CODES_CP856_CODE_PAGE = {
+    CODES_CP856,
+    {"CP856", "windows-856",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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, 0xFFFD, 0x00A3, 0xFFFD, 0x00D7, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0xFFFD, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0xFFFD, 0xFFFD,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0xFFFD, 0x2580,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00B5, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00AF, 0x00B4,
+        0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP857_CODE_PAGE = {
+    CODES_CP857,
+    {"CP857", "windows-857",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x0131, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x0130, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x015E, 0x015F,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x011E, 0x011F,
+        0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+        0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0x00BA, 0x00AA, 0x00CA, 0x00CB, 0x00C8, 0xFFFD, 0x00CD, 0x00CE,
+        0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+        0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0xFFFD,
+        0x00D7, 0x00DA, 0x00DB, 0x00D9, 0x00EC, 0x00FF, 0x00AF, 0x00B4,
+        0x00AD, 0x00B1, 0xFFFD, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP858_CODE_PAGE = {
+    CODES_CP858,
+    {"CP858", "windows-858",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
+        0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x20AC, 0x00CD, 0x00CE,
+        0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
+        0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
+        0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
+        0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
+        0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from cp858.txt
+
+static const CodePage CODES_CP860_CODE_PAGE = {
+    CODES_CP860,
+    {"CP860", "windows-860",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E3, 0x00E0, 0x00C1, 0x00E7,
+        0x00EA, 0x00CA, 0x00E8, 0x00CD, 0x00D4, 0x00EC, 0x00C3, 0x00C2,
+        0x00C9, 0x00C0, 0x00C8, 0x00F4, 0x00F5, 0x00F2, 0x00DA, 0x00F9,
+        0x00CC, 0x00D5, 0x00DC, 0x00A2, 0x00A3, 0x00D9, 0x20A7, 0x00D3,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x00D2, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP861_CODE_PAGE = {
+    CODES_CP861,
+    {"CP861", "windows-861",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00D0, 0x00F0, 0x00DE, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00FE, 0x00FB, 0x00DD,
+        0x00FD, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x20A7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00C1, 0x00CD, 0x00D3, 0x00DA,
+        0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP862_CODE_PAGE = {
+    CODES_CP862,
+    {"CP862", "IBM862", "862", "CSPC862LATINHEBREW", "windows-862",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP863_CODE_PAGE = {
+    CODES_CP863,
+    {"CP863", "windows-863",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00C2, 0x00E0, 0x00B6, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x2017, 0x00C0, 0x00A7,
+        0x00C9, 0x00C8, 0x00CA, 0x00F4, 0x00CB, 0x00CF, 0x00FB, 0x00F9,
+        0x00A4, 0x00D4, 0x00DC, 0x00A2, 0x00A3, 0x00D9, 0x00DB, 0x0192,
+        0x00A6, 0x00B4, 0x00F3, 0x00FA, 0x00A8, 0x00B8, 0x00B3, 0x00AF,
+        0x00CE, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00BE, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP864_CODE_PAGE = {
+    CODES_CP864,
+    {"CP864", "windows-864",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x066A, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00B0, 0x00B7, 0x2219, 0x221A, 0x2592, 0x2500, 0x2502, 0x253C,
+        0x2524, 0x252C, 0x251C, 0x2534, 0x2510, 0x250C, 0x2514, 0x2518,
+        0x03B2, 0x221E, 0x03C6, 0x00B1, 0x00BD, 0x00BC, 0x2248, 0x00AB,
+        0x00BB, 0xFEF7, 0xFEF8, 0xFFFD, 0xFFFD, 0xFEFB, 0xFEFC, 0xFFFD,
+        0x00A0, 0x00AD, 0xFE82, 0x00A3, 0x00A4, 0xFE84, 0xFFFD, 0xFFFD,
+        0xFE8E, 0xFE8F, 0xFE95, 0xFE99, 0x060C, 0xFE9D, 0xFEA1, 0xFEA5,
+        0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667,
+        0x0668, 0x0669, 0xFED1, 0x061B, 0xFEB1, 0xFEB5, 0xFEB9, 0x061F,
+        0x00A2, 0xFE80, 0xFE81, 0xFE83, 0xFE85, 0xFECA, 0xFE8B, 0xFE8D,
+        0xFE91, 0xFE93, 0xFE97, 0xFE9B, 0xFE9F, 0xFEA3, 0xFEA7, 0xFEA9,
+        0xFEAB, 0xFEAD, 0xFEAF, 0xFEB3, 0xFEB7, 0xFEBB, 0xFEBF, 0xFEC1,
+        0xFEC5, 0xFECB, 0xFECF, 0x00A6, 0x00AC, 0x00F7, 0x00D7, 0xFEC9,
+        0x0640, 0xFED3, 0xFED7, 0xFEDB, 0xFEDF, 0xFEE3, 0xFEE7, 0xFEEB,
+        0xFEED, 0xFEEF, 0xFEF3, 0xFEBD, 0xFECC, 0xFECE, 0xFECD, 0xFEE1,
+        0xFE7D, 0x0651, 0xFEE5, 0xFEE9, 0xFEEC, 0xFEF0, 0xFEF2, 0xFED0,
+        0xFED5, 0xFEF5, 0xFEF6, 0xFEDD, 0xFED9, 0xFEF1, 0x25A0, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP865_CODE_PAGE = {
+    CODES_CP865,
+    {"CP865", "windows-865",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+        0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+        0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x20A7, 0x0192,
+        0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+        0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00A4,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+        0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+        0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+        0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+        0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+        0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+        0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP869_CODE_PAGE = {
+    CODES_CP869,
+    {"CP869", "windows-869",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0386, 0xFFFD,
+        0x00B7, 0x00AC, 0x00A6, 0x2018, 0x2019, 0x0388, 0x2015, 0x0389,
+        0x038A, 0x03AA, 0x038C, 0xFFFD, 0xFFFD, 0x038E, 0x03AB, 0x00A9,
+        0x038F, 0x00B2, 0x00B3, 0x03AC, 0x00A3, 0x03AD, 0x03AE, 0x03AF,
+        0x03CA, 0x0390, 0x03CC, 0x03CD, 0x0391, 0x0392, 0x0393, 0x0394,
+        0x0395, 0x0396, 0x0397, 0x00BD, 0x0398, 0x0399, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x039A, 0x039B, 0x039C,
+        0x039D, 0x2563, 0x2551, 0x2557, 0x255D, 0x039E, 0x039F, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x03A0, 0x03A1,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x03A3,
+        0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03B1, 0x03B2,
+        0x03B3, 0x2518, 0x250C, 0x2588, 0x2584, 0x03B4, 0x03B5, 0x2580,
+        0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD,
+        0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C2, 0x03C4, 0x0384,
+        0x00AD, 0x00B1, 0x03C5, 0x03C6, 0x03C7, 0x00A7, 0x03C8, 0x0385,
+        0x00B0, 0x00A8, 0x03C9, 0x03CB, 0x03B0, 0x03CE, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP874_CODE_PAGE = {
+    CODES_CP874,
+    {"CP874", "windows-874",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2026, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x00A0, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_CP922_CODE_PAGE = {
+    CODES_CP922,
+    {"CP922", "windows-922",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x203E,
+        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,
+        0x0160, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x017D, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x0161, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x017E, 0x00FF,
+    },
+    defchars[0],
+}; // generated from cp922.txt
+
+static const CodePage CODES_CP932_CODE_PAGE = {
+    CODES_CP932,
+    {"CP932",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_CP936_CODE_PAGE = {
+    CODES_CP936,
+    {"CP936",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_CP949_CODE_PAGE = {
+    CODES_CP949,
+    {"CP949", "UHC",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_CP950_CODE_PAGE = {
+    CODES_CP950,
+    {"CP950",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_EUC_CN_CODE_PAGE = {
+    CODES_EUC_CN,
+    {"EUC-CN", "CN-GB", "GB2312", "CSGB2312",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_EUC_JP_CODE_PAGE = {
+    CODES_EUC_JP,
+    {"EUC-JP", "EXTENDED_UNIX_CODE_PACKED_FORMAT_FOR_JAPANESE", "CSEUCPKDFMTJAPANESE",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_EUC_KR_CODE_PAGE = {
+    CODES_EUC_KR,
+    {"EUC-KR", "ISO-IR-149", "KOREAN", "KSC_5601", "KS_C_5601-1987", "KS_C_5601-1989", "CSEUCKR", "CSKSC56011987",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_EUC_TW_CODE_PAGE = {
+    CODES_EUC_TW,
+    {"EUC-TW", "CSEUCTW",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_GB18030_CODE_PAGE = {
+    CODES_GB18030,
+    {"GB18030",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_GBK_CODE_PAGE = {
+    CODES_GBK,
+    {"GBK",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_GEO_ITA_CODE_PAGE = {
+    CODES_GEO_ITA,
+    {"geo-ita",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x009E, 0x0178,
+        0x00A0, 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,
+        0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7,
+        0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF,
+        0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7,
+        0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF,
+        0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+    },
+    defchars[0],
+}; // generated from geo-ita.txt
+
+static const CodePage CODES_GEO_PS_CODE_PAGE = {
+    CODES_GEO_PS,
+    {"geo-ps",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x009E, 0x0178,
+        0x00A0, 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,
+        0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10F1,
+        0x10D7, 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10F2, 0x10DD,
+        0x10DE, 0x10DF, 0x10E0, 0x10E1, 0x10E2, 0x10F3, 0x10E3, 0x10E4,
+        0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC,
+        0x10ED, 0x10EE, 0x10F4, 0x10EF, 0x10F0, 0x10F5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+    },
+    defchars[0],
+}; // generated from geo-ps.txt
+
+static const CodePage CODES_HP_ROMAN8_CODE_PAGE = {
+    CODES_HP_ROMAN8,
+    {"HP_ROMAN8", "HP-ROMAN8", "ROMAN8", "R8", "CSHPROMAN8",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x00C0, 0x00C2, 0x00C8, 0x00CA, 0x00CB, 0x00CE, 0x00CF,
+        0x00B4, 0x02CB, 0x02C6, 0x00A8, 0x02DC, 0x00D9, 0x00DB, 0x20A4,
+        0x00AF, 0x00DD, 0x00FD, 0x00B0, 0x00C7, 0x00E7, 0x00D1, 0x00F1,
+        0x00A1, 0x00BF, 0x00A4, 0x00A3, 0x00A5, 0x00A7, 0x0192, 0x00A2,
+        0x00E2, 0x00EA, 0x00F4, 0x00FB, 0x00E1, 0x00E9, 0x00F3, 0x00FA,
+        0x00E0, 0x00E8, 0x00F2, 0x00F9, 0x00E4, 0x00EB, 0x00F6, 0x00FC,
+        0x00C5, 0x00EE, 0x00D8, 0x00C6, 0x00E5, 0x00ED, 0x00F8, 0x00E6,
+        0x00C4, 0x00EC, 0x00D6, 0x00DC, 0x00C9, 0x00EF, 0x00DF, 0x00D4,
+        0x00C1, 0x00C3, 0x00E3, 0x00D0, 0x00F0, 0x00CD, 0x00CC, 0x00D3,
+        0x00D2, 0x00D5, 0x00F5, 0x0160, 0x0161, 0x00DA, 0x0178, 0x00FF,
+        0x00DE, 0x00FE, 0x00B7, 0x00B5, 0x00B6, 0x00BE, 0x2014, 0x00BC,
+        0x00BD, 0x00AA, 0x00BA, 0x00AB, 0x25A0, 0x00BB, 0x00B1, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from hp_roman8.txt
+
+static const CodePage CODES_HZ_CODE_PAGE = {
+    CODES_HZ,
+    {"HZ", "HZ-GB-2312",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_IBM855_CODE_PAGE = {
+    CODES_IBM855,
+    {"IBM855", "csIBM855", "cp855", "855", "dos-855", "windows-855",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0452, 0x0402, 0x0453, 0x0403, 0x0451, 0x0401, 0x0454, 0x0404,
+        0x0455, 0x0405, 0x0456, 0x0406, 0x0457, 0x0407, 0x0458, 0x0408,
+        0x0459, 0x0409, 0x045A, 0x040A, 0x045B, 0x040B, 0x045C, 0x040C,
+        0x045E, 0x040E, 0x045F, 0x040F, 0x044E, 0x042E, 0x044A, 0x042A,
+        0x0430, 0x0410, 0x0431, 0x0411, 0x0446, 0x0426, 0x0434, 0x0414,
+        0x0435, 0x0415, 0x0444, 0x0424, 0x0433, 0x0413, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x0445, 0x0425, 0x0438,
+        0x0418, 0x2563, 0x2551, 0x2557, 0x255D, 0x0439, 0x0419, 0x2510,
+        0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x043A, 0x041A,
+        0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
+        0x043B, 0x041B, 0x043C, 0x041C, 0x043D, 0x041D, 0x043E, 0x041E,
+        0x043F, 0x2518, 0x250C, 0x2588, 0x2584, 0x041F, 0x044F, 0x2580,
+        0x042F, 0x0440, 0x0420, 0x0441, 0x0421, 0x0442, 0x0422, 0x0443,
+        0x0423, 0x0436, 0x0416, 0x0432, 0x0412, 0x044C, 0x042C, 0x2116,
+        0x00AD, 0x044B, 0x042B, 0x0437, 0x0417, 0x0448, 0x0428, 0x044D,
+        0x042D, 0x0449, 0x0429, 0x0447, 0x0427, 0x00A7, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO646_CN_CODE_PAGE = {
+    CODES_ISO646_CN,
+    {"ISO646_CN", "GB_1988-80", "ISO646-CN", "ISO-IR-57", "CN", "CSISO57GB1988",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x00A5, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x203E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from iso646_cn.txt
+
+static const CodePage CODES_ISO646_JP_CODE_PAGE = {
+    CODES_ISO646_JP,
+    {"ISO646_JP", "JIS_C6220-1969-RO", "ISO646-JP", "ISO-IR-14", "JP", "CSISO14JISC6220RO",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x00A5, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x203E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from iso646_jp.txt
+
+static const CodePage CODES_ISO8859_10_CODE_PAGE = {
+    CODES_ISO8859_10,
+    {"ISO8859_10", "ISO-8859-10", "ISO_8859-10", "ISO_8859-10:1992", "ISO-IR-157", "LATIN6", "L6", "CSISOLATIN6", "ISO8859-10",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7,
+        0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
+        0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7,
+        0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B,
+        0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
+        0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
+        0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168,
+        0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
+        0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
+        0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169,
+        0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO8859_11_CODE_PAGE = {
+    CODES_ISO8859_11,
+    {"ISO8859_11", "ISO-8859-11", "ISO_8859-11", "ISO8859-11",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO8859_14_CODE_PAGE = {
+    CODES_ISO8859_14,
+    {"ISO8859_14", "ISO-8859-14", "ISO_8859-14", "ISO_8859-14:1998", "ISO-IR-199", "LATIN8", "L8", "ISO-CELTIC", "ISO8859-14",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7,
+        0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178,
+        0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56,
+        0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61,
+        0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+        0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_2022_CN_CODE_PAGE = {
+    CODES_ISO_2022_CN,
+    {"ISO-2022-CN", "CSISO2022CN",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_2022_CN_EXT_CODE_PAGE = {
+    CODES_ISO_2022_CN_EXT,
+    {"ISO-2022-CN-EXT",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_2022_JP_CODE_PAGE = {
+    CODES_ISO_2022_JP,
+    {"ISO-2022-JP", "CPISO2022JP",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_2022_JP_1_CODE_PAGE = {
+    CODES_ISO_2022_JP_1,
+    {"ISO-2022-JP-1",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_2022_JP_2_CODE_PAGE = {
+    CODES_ISO_2022_JP_2,
+    {"ISO-2022-JP-2", "CPISO2022JP2",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_2022_KR_CODE_PAGE = {
+    CODES_ISO_2022_KR,
+    {"ISO-2022-KR", "CSISO2022KR",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_ISO_8859_13_CODE_PAGE = {
+    CODES_ISO_8859_13,
+    {"iso-8859-13",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7,
+        0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7,
+        0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
+        0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
+        0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
+        0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
+        0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
+        0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
+        0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
+        0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
+        0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_15_CODE_PAGE = {
+    CODES_ISO_8859_15,
+    {"iso-8859-15",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7,
+        0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7,
+        0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 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,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_16_CODE_PAGE = {
+    CODES_ISO_8859_16,
+    {"iso-8859-16",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0104, 0x0105, 0x0141, 0x20AC, 0x201E, 0x0160, 0x00A7,
+        0x0161, 0x00A9, 0x0218, 0x00AB, 0x0179, 0x00AD, 0x017A, 0x017B,
+        0x00B0, 0x00B1, 0x010C, 0x0142, 0x017D, 0x201D, 0x00B6, 0x00B7,
+        0x017E, 0x010D, 0x0219, 0x00BB, 0x0152, 0x0153, 0x0178, 0x017C,
+        0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0106, 0x00C6, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+        0x0110, 0x0143, 0x00D2, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x015A,
+        0x0170, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0118, 0x021A, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x0107, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x0111, 0x0144, 0x00F2, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x015B,
+        0x0171, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0119, 0x021B, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_3_CODE_PAGE = {
+    CODES_ISO_8859_3,
+    {"iso-8859-3",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0xFFFD, 0x0124, 0x00A7,
+        0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0xFFFD, 0x017B,
+        0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
+        0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0xFFFD, 0x017C,
+        0x00C0, 0x00C1, 0x00C2, 0xFFFD, 0x00C4, 0x010A, 0x0108, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+        0xFFFD, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7,
+        0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0xFFFD, 0x00E4, 0x010B, 0x0109, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0xFFFD, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7,
+        0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_4_CODE_PAGE = {
+    CODES_ISO_8859_4,
+    {"iso-8859-4",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7,
+        0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
+        0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7,
+        0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
+        0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
+        0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
+        0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+        0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
+        0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
+        0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
+        0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_6_CODE_PAGE = {
+    CODES_ISO_8859_6,
+    {"iso-8859-6", "cp708",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x2502, 0x2524, 0x00E9, 0x00E2, 0x2561, 0x00E0, 0x2562, 0x00E7,
+        0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x2556, 0x2555, 0x2563,
+        0x2551, 0x2557, 0x255D, 0x00F4, 0x255C, 0x255B, 0x00FB, 0x00F9,
+        0x2510, 0x2514, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x2534, 0x252C, 0x251C, 0x00A4, 0x2500, 0x253C, 0x255E,
+        0x255F, 0x255A, 0x2554, 0x2569, 0x060C, 0x2566, 0x00AB, 0x00BB,
+        0x2591, 0x2592, 0x2593, 0x2560, 0x2550, 0x256C, 0x2567, 0x2568,
+        0x2564, 0x2565, 0x2559, 0x061B, 0x2558, 0x2552, 0x2553, 0x061F,
+        0x256B, 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, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+        0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
+        0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
+        0x0650, 0x0651, 0x0652, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x256A, 0x2518, 0x250C, 0x00B5, 0x00A3, 0x25A0, 0x00A0,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_7_CODE_PAGE = {
+    CODES_ISO_8859_7,
+    {"iso-8859-7",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x2018, 0x2019, 0x00A3, 0x20AC, 0x20AF, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x037A, 0x00AB, 0x00AC, 0x00AD, 0xFFFD, 0x2015,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7,
+        0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
+        0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+        0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
+        0x03A0, 0x03A1, 0xFFFD, 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, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_8_CODE_PAGE = {
+    CODES_ISO_8859_8,
+    {"iso-8859-8", "iso-8859-8-i",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+        0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2017,
+        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, 0xFFFD, 0xFFFD, 0x200E, 0x200F, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_8859_9_CODE_PAGE = {
+    CODES_ISO_8859_9,
+    {"iso-8859-9",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 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,
+        0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_ISO_EAST_CODE_PAGE = {
+    CODES_ISO_EAST,
+    {"iso-2", "iso_8859-2", "iso-8859-2", "iso-east", "ISO8859_2", "ISO_8859-2:1987", "ISO-IR-101", "LATIN2", "L2", "CSISOLATIN2", "ISO8859-2",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
+        0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
+        0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
+        0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
+        0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
+        0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
+        0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
+        0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
+        0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
+        0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
+        0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
+        0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_JISX0201_CODE_PAGE = {
+    CODES_JISX0201,
+    {"JISX0201", "JIS_X0201", "JISX0201-1976", "X0201", "CSHALFWIDTHKATAKANA",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x00A5, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x203E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 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,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from jisx0201.txt
+
+static const CodePage CODES_JOHAB_CODE_PAGE = {
+    CODES_JOHAB,
+    {"JOHAB", "CP1361",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_KAZWIN_CODE_PAGE = {
+    CODES_KAZWIN,
+    {"windows-1251-k", "cp1251k", "1251k", "kazwin",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x04B0, 0x0492, 0x201A, 0x0493, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x20AC, 0x2030, 0x04E8, 0x2039, 0x04A2, 0x049A, 0x04BA, 0x04AE,
+        0x04B1, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x0098, 0x2122, 0x04E9, 0x203A, 0x04A3, 0x049B, 0x04BB, 0x04AF,
+        0x00A0, 0x040E, 0x045E, 0x0496, 0x00A4, 0x04B2, 0x00A6, 0x00A7,
+        0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+        0x00B0, 0x00B1, 0x0406, 0x0456, 0x04B3, 0x00B5, 0x00B6, 0x00B7,
+        0x0451, 0x2116, 0x0454, 0x00BB, 0x0497, 0x04D8, 0x04D9, 0x0457,
+        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,
+    },
+    defchars[0],
+}; // generated from cp1251-kaz.txt
+
+static const CodePage CODES_KOI8_CODE_PAGE = {
+    CODES_KOI8,
+    {"KOI8-U", "csKOI8R", "KOI8-RU", "csKOI8RU", "KOI8-R", "csKOI8U", "koi",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
+        0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
+        0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248,
+        0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
+        0x2550, 0x2551, 0x2552, 0x0451, 0x0454, 0x2554, 0x0456, 0x0457,
+        0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x0491, 0x255D, 0x255E,
+        0x255F, 0x2560, 0x2561, 0x0401, 0x0404, 0x2563, 0x0406, 0x0407,
+        0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x0490, 0x256C, 0x00A9,
+        0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
+        0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
+        0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
+        0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
+        0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
+        0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
+        0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
+        0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_KOI8_T_CODE_PAGE = {
+    CODES_KOI8_T,
+    {"KOI8_T", "KOI8-T",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x049B, 0x0493, 0x201A, 0x0492, 0x201E, 0x2026, 0x2020, 0x2021,
+        0xFFFD, 0x2030, 0x04B3, 0x2039, 0x04B2, 0x04B7, 0x04B6, 0xFFFD,
+        0x049A, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x04EF, 0x04EE, 0x0451, 0x00A4, 0x04E3, 0x00A6, 0x00A7,
+        0xFFFD, 0xFFFD, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0xFFFD,
+        0x00B0, 0x00B1, 0x00B2, 0x0401, 0xFFFD, 0x04E2, 0x00B6, 0x00B7,
+        0xFFFD, 0x2116, 0xFFFD, 0x00BB, 0xFFFD, 0xFFFD, 0xFFFD, 0x00A9,
+        0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
+        0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
+        0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
+        0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
+        0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
+        0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
+        0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
+        0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A,
+    },
+    defchars[0],
+}; // generated from koi8_t.txt
+
+static const CodePage CODES_MAC_CODE_PAGE = {
+    CODES_MAC,
+    {"MacCyrillic", "MacRussian", "mac", "windows-10007", "MAC_UKRAINE", "MACUKRAINE", "windows-10017",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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,
+        0x2020, 0x00B0, 0x0490, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x0406,
+        0x00AE, 0x00A9, 0x2122, 0x0402, 0x0452, 0x2260, 0x0403, 0x0453,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x0456, 0x00B5, 0x0491, 0x0408,
+        0x0404, 0x0454, 0x0407, 0x0457, 0x0409, 0x0459, 0x040A, 0x045A,
+        0x0458, 0x0405, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x040B, 0x045B, 0x040C, 0x045C, 0x0455,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x201E,
+        0x040E, 0x045E, 0x040F, 0x045F, 0x2116, 0x0401, 0x0451, 0x044F,
+        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, 0x20AC,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_ARABIC_CODE_PAGE = {
+    CODES_MAC_ARABIC,
+    {"MAC_ARABIC", "MACARABIC", "windows-10004",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00A0, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x06BA, 0x00AB, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x2026, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00BB, 0x00F4, 0x00F6, 0x00F7, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x066A, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x060C, 0x002D, 0x002E, 0x002F,
+        0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667,
+        0x0668, 0x0669, 0x003A, 0x061B, 0x003C, 0x003D, 0x003E, 0x061F,
+        0x274A, 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, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
+        0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
+        0x0650, 0x0651, 0x0652, 0x067E, 0x0679, 0x0686, 0x06D5, 0x06A4,
+        0x06AF, 0x0688, 0x0691, 0x007B, 0x007C, 0x007D, 0x0698, 0x06D2,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_CENTRALEUROPE_CODE_PAGE = {
+    CODES_MAC_CENTRALEUROPE,
+    {"MAC_CENTRALEUROPE", "MACCENTRALEUROPE", "windows-10029",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x0100, 0x0101, 0x00C9, 0x0104, 0x00D6, 0x00DC, 0x00E1,
+        0x0105, 0x010C, 0x00E4, 0x010D, 0x0106, 0x0107, 0x00E9, 0x0179,
+        0x017A, 0x010E, 0x00ED, 0x010F, 0x0112, 0x0113, 0x0116, 0x00F3,
+        0x0117, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x011A, 0x011B, 0x00FC,
+        0x2020, 0x00B0, 0x0118, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x00A9, 0x2122, 0x0119, 0x00A8, 0x2260, 0x0123, 0x012E,
+        0x012F, 0x012A, 0x2264, 0x2265, 0x012B, 0x0136, 0x2202, 0x2211,
+        0x0142, 0x013B, 0x013C, 0x013D, 0x013E, 0x0139, 0x013A, 0x0145,
+        0x0146, 0x0143, 0x00AC, 0x221A, 0x0144, 0x0147, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x0148, 0x0150, 0x00D5, 0x0151, 0x014C,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0x014D, 0x0154, 0x0155, 0x0158, 0x2039, 0x203A, 0x0159, 0x0156,
+        0x0157, 0x0160, 0x201A, 0x201E, 0x0161, 0x015A, 0x015B, 0x00C1,
+        0x0164, 0x0165, 0x00CD, 0x017D, 0x017E, 0x016A, 0x00D3, 0x00D4,
+        0x016B, 0x016E, 0x00DA, 0x016F, 0x0170, 0x0171, 0x0172, 0x0173,
+        0x00DD, 0x00FD, 0x0137, 0x017B, 0x0141, 0x017C, 0x0122, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_CROATIAN_CODE_PAGE = {
+    CODES_MAC_CROATIAN,
+    {"MAC_CROATIAN", "MACCROATIAN", "windows-10082",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x0160, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x017D, 0x00D8,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x2206, 0x00B5, 0x2202, 0x2211,
+        0x220F, 0x0161, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x017E, 0x00F8,
+        0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x0106, 0x00AB,
+        0x010C, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
+        0x0110, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0xF8FF, 0x00A9, 0x2044, 0x20AC, 0x2039, 0x203A, 0x00C6, 0x00BB,
+        0x2013, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x0107, 0x00C1,
+        0x010D, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
+        0x0111, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
+        0x00AF, 0x03C0, 0x00CB, 0x02DA, 0x00B8, 0x00CA, 0x00E6, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_GREEK_CODE_PAGE = {
+    CODES_MAC_GREEK,
+    {"MAC_GREEK", "MACGREEK", "windows-10006",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00B9, 0x00B2, 0x00C9, 0x00B3, 0x00D6, 0x00DC, 0x0385,
+        0x00E0, 0x00E2, 0x00E4, 0x0384, 0x00A8, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00A3, 0x2122, 0x00EE, 0x00EF, 0x2022, 0x00BD,
+        0x2030, 0x00F4, 0x00F6, 0x00A6, 0x20AC, 0x00F9, 0x00FB, 0x00FC,
+        0x2020, 0x0393, 0x0394, 0x0398, 0x039B, 0x039E, 0x03A0, 0x00DF,
+        0x00AE, 0x00A9, 0x03A3, 0x03AA, 0x00A7, 0x2260, 0x00B0, 0x00B7,
+        0x0391, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x0392, 0x0395, 0x0396,
+        0x0397, 0x0399, 0x039A, 0x039C, 0x03A6, 0x03AB, 0x03A8, 0x03A9,
+        0x03AC, 0x039D, 0x00AC, 0x039F, 0x03A1, 0x2248, 0x03A4, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x03A5, 0x03A7, 0x0386, 0x0388, 0x0153,
+        0x2013, 0x2015, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x0389,
+        0x038A, 0x038C, 0x038E, 0x03AD, 0x03AE, 0x03AF, 0x03CC, 0x038F,
+        0x03CD, 0x03B1, 0x03B2, 0x03C8, 0x03B4, 0x03B5, 0x03C6, 0x03B3,
+        0x03B7, 0x03B9, 0x03BE, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BF,
+        0x03C0, 0x03CE, 0x03C1, 0x03C3, 0x03C4, 0x03B8, 0x03C9, 0x03C2,
+        0x03C7, 0x03C5, 0x03B6, 0x03CA, 0x03CB, 0x0390, 0x03B0, 0x00AD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_HEBREW_CODE_PAGE = {
+    CODES_MAC_HEBREW,
+    {"MAC_HEBREW", "MACHEBREW", "windows-10005",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0xFB1F, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x20AA, 0x0027,
+        0x0029, 0x0028, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x05DC, 0x201E, 0xF89B, 0xF89C, 0xF89D, 0xF89E, 0x05BC, 0xFB4B,
+        0xFB35, 0x2026, 0x00A0, 0x05B8, 0x05B7, 0x05B5, 0x05B6, 0x05B4,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0xFB2A, 0xFB2B,
+        0x05BF, 0x05B0, 0x05B2, 0x05B1, 0x05BB, 0x05B9, 0x05B8, 0x05B3,
+        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, 0x007D, 0x005D, 0x007B, 0x005B, 0x007C,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_ICELAND_CODE_PAGE = {
+    CODES_MAC_ICELAND,
+    {"MAC_ICELAND", "MACICELAND", "windows-10079",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x00DD, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
+        0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8,
+        0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0x00FF, 0x0178, 0x2044, 0x20AC, 0x00D0, 0x00F0, 0x00DE, 0x00FE,
+        0x00FD, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
+        0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
+        0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
+        0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_ROMAN_CODE_PAGE = {
+    CODES_MAC_ROMAN,
+    {"MAC_ROMAN", "MACROMAN", "MACINTOSH", "CSMACINTOSH", "windows-10000",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
+        0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8,
+        0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02,
+        0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
+        0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
+        0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
+        0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_ROMANIA_CODE_PAGE = {
+    CODES_MAC_ROMANIA,
+    {"MAC_ROMANIA", "MACROMANIA", "windows-10010",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x0102, 0x0218,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
+        0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x0103, 0x0219,
+        0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0x021A, 0x021B,
+        0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
+        0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
+        0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
+        0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_THAI_CODE_PAGE = {
+    CODES_MAC_THAI,
+    {"MAC_THAI", "MACTHAI", "windows-10021",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00AB, 0x00BB, 0x2026, 0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C,
+        0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x201C, 0x201D, 0x0E4D,
+        0xFFFD, 0x2022, 0x0E31, 0x0E47, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
+        0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x2018, 0x2019, 0xFFFD,
+        0x00A0, 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, 0x2060, 0x200B, 0x2013, 0x2014, 0x0E3F,
+        0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
+        0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x2122, 0x0E4F,
+        0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
+        0x0E58, 0x0E59, 0x00AE, 0x00A9, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAC_TURKISH_CODE_PAGE = {
+    CODES_MAC_TURKISH,
+    {"MAC_TURKISH", "MACTURKISH", "windows-10081",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
+        0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
+        0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
+        0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
+        0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
+        0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
+        0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8,
+        0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
+        0x00FF, 0x0178, 0x011E, 0x011F, 0x0130, 0x0131, 0x015E, 0x015F,
+        0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
+        0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
+        0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0xF8A0, 0x02C6, 0x02DC,
+        0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MAIN_CODE_PAGE = {
+    CODES_MAIN,
+    {"ISO-8859-5", "ISOLatinCyrillic", "csISOLatinCyrillic", "iso-ir-144", "cyrillic", "ISO_8859-5", "ISO_8859-5:1988", "iso", "ISO8859_5", "ISO8859-5",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
+        0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 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,
+        0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
+        0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_MULELAO_CODE_PAGE = {
+    CODES_MULELAO,
+    {"MULELAO", "MULELAO-1",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+        0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F,
+        0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+        0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F,
+        0x00A0, 0x0E81, 0x0E82, 0xFFFD, 0x0E84, 0xFFFD, 0xFFFD, 0x0E87,
+        0x0E88, 0xFFFD, 0x0E8A, 0xFFFD, 0xFFFD, 0x0E8D, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0E94, 0x0E95, 0x0E96, 0x0E97,
+        0xFFFD, 0x0E99, 0x0E9A, 0x0E9B, 0x0E9C, 0x0E9D, 0x0E9E, 0x0E9F,
+        0xFFFD, 0x0EA1, 0x0EA2, 0x0EA3, 0xFFFD, 0x0EA5, 0xFFFD, 0x0EA7,
+        0xFFFD, 0xFFFD, 0x0EAA, 0x0EAB, 0xFFFD, 0x0EAD, 0x0EAE, 0x0EAF,
+        0x0EB0, 0x0EB1, 0x0EB2, 0x0EB3, 0x0EB4, 0x0EB5, 0x0EB6, 0x0EB7,
+        0x0EB8, 0x0EB9, 0xFFFD, 0x0EBB, 0x0EBC, 0x0EBD, 0xFFFD, 0xFFFD,
+        0x0EC0, 0x0EC1, 0x0EC2, 0x0EC3, 0x0EC4, 0xFFFD, 0x0EC6, 0xFFFD,
+        0x0EC8, 0x0EC9, 0x0ECA, 0x0ECB, 0x0ECC, 0x0ECD, 0xFFFD, 0xFFFD,
+        0x0ED0, 0x0ED1, 0x0ED2, 0x0ED3, 0x0ED4, 0x0ED5, 0x0ED6, 0x0ED7,
+        0x0ED8, 0x0ED9, 0xFFFD, 0xFFFD, 0x0EDC, 0x0EDD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from mulelao.txt
+
+static const CodePage CODES_NEXTSTEP_CODE_PAGE = {
+    CODES_NEXTSTEP,
+    {"NEXTSTEP",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00A0, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C7,
+        0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
+        0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D9,
+        0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00B5, 0x00D7, 0x00F7,
+        0x00A9, 0x00A1, 0x00A2, 0x00A3, 0x2044, 0x00A5, 0x0192, 0x00A7,
+        0x00A4, 0x2019, 0x201C, 0x00AB, 0x2039, 0x203A, 0xFB01, 0xFB02,
+        0x00AE, 0x2013, 0x2020, 0x2021, 0x00B7, 0x00A6, 0x00B6, 0x2022,
+        0x201A, 0x201E, 0x201D, 0x00BB, 0x2026, 0x2030, 0x00AC, 0x00BF,
+        0x00B9, 0x02CB, 0x00B4, 0x02C6, 0x02DC, 0x00AF, 0x02D8, 0x02D9,
+        0x00A8, 0x00B2, 0x02DA, 0x00B8, 0x00B3, 0x02DD, 0x02DB, 0x02C7,
+        0x2014, 0x00B1, 0x00BC, 0x00BD, 0x00BE, 0x00E0, 0x00E1, 0x00E2,
+        0x00E3, 0x00E4, 0x00E5, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB,
+        0x00EC, 0x00C6, 0x00ED, 0x00AA, 0x00EE, 0x00EF, 0x00F0, 0x00F1,
+        0x0141, 0x00D8, 0x0152, 0x00BA, 0x00F2, 0x00F3, 0x00F4, 0x00F5,
+        0x00F6, 0x00E6, 0x00F9, 0x00FA, 0x00FB, 0x0131, 0x00FC, 0x00FD,
+        0x0142, 0x00F8, 0x0153, 0x00DF, 0x00FE, 0x00FF, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_PT154_CODE_PAGE = {
+    CODES_PT154,
+    {"PT154", "PTCP154", "CP154", "CYRILLIC-ASIAN", "CSPTCP154",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0496, 0x0492, 0x04EE, 0x0493, 0x201E, 0x2026, 0x04B6, 0x04AE,
+        0x04B2, 0x04AF, 0x04A0, 0x04E2, 0x04A2, 0x049A, 0x04BA, 0x04B8,
+        0x0497, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x04B3, 0x04B7, 0x04A1, 0x04E3, 0x04A3, 0x049B, 0x04BB, 0x04B9,
+        0x00A0, 0x040E, 0x045E, 0x0408, 0x04E8, 0x0498, 0x04B0, 0x00A7,
+        0x0401, 0x00A9, 0x04D8, 0x00AB, 0x00AC, 0x04EF, 0x00AE, 0x049C,
+        0x00B0, 0x04B1, 0x0406, 0x0456, 0x0499, 0x04E9, 0x00B6, 0x00B7,
+        0x0451, 0x2116, 0x04D9, 0x00BB, 0x0458, 0x04AA, 0x04AB, 0x049D,
+        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,
+    },
+    defchars[0],
+}; // generated from pt154.txt
+
+static const CodePage CODES_RESERVED_2_CODE_PAGE = {
+    CODES_RESERVED_2,
+    {"reserved2",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        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,
+        0x2020, 0x00B0, 0x0490, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x0406,
+        0x00AE, 0x00A9, 0x2122, 0x0402, 0x0452, 0x2260, 0x0403, 0x0453,
+        0x221E, 0x00B1, 0x2264, 0x2265, 0x0456, 0x00B5, 0x0491, 0x0408,
+        0x0404, 0x0454, 0x0407, 0x0457, 0x0409, 0x0459, 0x040A, 0x045A,
+        0x0458, 0x0405, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
+        0x00BB, 0x2026, 0x00A0, 0x040B, 0x045B, 0x040C, 0x045C, 0x0455,
+        0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x201E,
+        0x040E, 0x045E, 0x040F, 0x045F, 0x2116, 0x0401, 0x0451, 0x044F,
+        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, 0x20AC,
+    },
+    defchars[0],
+}; // generated from reserved.txt
+
+static const CodePage CODES_RESERVED_3_CODE_PAGE = {
+    CODES_RESERVED_3,
+    {"reserved3",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from reserved.txt
+
+static const CodePage CODES_RISCOS_LATIN1_CODE_PAGE = {
+    CODES_RISCOS_LATIN1,
+    {"RISCOS-LATIN1", "RISCOS_LATIN1",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x221A, 0x0174, 0x0175, 0x0083, 0x2573, 0x0176, 0x0177, 0x0087,
+        0x21E6, 0x21E8, 0x21E9, 0x21E7, 0x2026, 0x2122, 0x2030, 0x2022,
+        0x2018, 0x2019, 0x2039, 0x203A, 0x201C, 0x201D, 0x201E, 0x2013,
+        0x2014, 0x2212, 0x0152, 0x0153, 0x2020, 0x2021, 0xFB01, 0xFB02,
+        0x00A0, 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,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF,
+    },
+    defchars[0],
+}; // generated from riscos_latin1.txt
+
+static const CodePage CODES_RK1048_CODE_PAGE = {
+    CODES_RK1048,
+    {"RK1048", "STRK1048-2002", "KZ-1048", "CSKZ1048",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x049A, 0x04BA, 0x040F,
+        0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x049B, 0x04BB, 0x045F,
+        0x00A0, 0x04B0, 0x04B1, 0x04D8, 0x00A4, 0x04E8, 0x00A6, 0x00A7,
+        0x0401, 0x00A9, 0x0492, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x04AE,
+        0x00B0, 0x00B1, 0x0406, 0x0456, 0x04E9, 0x00B5, 0x00B6, 0x00B7,
+        0x0451, 0x2116, 0x0493, 0x00BB, 0x04D9, 0x04A2, 0x04A3, 0x04AF,
+        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,
+    },
+    defchars[0],
+}; // generated from rk1048.txt
+
+static const CodePage CODES_SHIFT_JIS_CODE_PAGE = {
+    CODES_SHIFT_JIS,
+    {"SHIFT_JIS", "MS_KANJI", "SJIS", "CSSHIFTJIS",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_TATWIN_CODE_PAGE = {
+    CODES_TATWIN,
+    {"windows-1251-t", "cp1251t", "1251t", "tatwin",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x04D8, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x20AC, 0x2030, 0x04E8, 0x2039, 0x04AE, 0x0496, 0x04A2, 0x04BA,
+        0x04D9, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x0098, 0x2122, 0x04E9, 0x203A, 0x04AF, 0x0497, 0x04A3, 0x04BB,
+        0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
+        0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+        0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
+        0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+        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,
+    },
+    defchars[0],
+}; // generated from cp1251-tat.txt
+
+static const CodePage CODES_TCVN_CODE_PAGE = {
+    CODES_TCVN,
+    {"TCVN", "TCVN-5712", "TCVN5712-1", "TCVN5712-1:1993",},
+    {
+        0x0000, 0x00DA, 0x1EE4, 0x0003, 0x1EEA, 0x1EEC, 0x1EEE, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x1EE8, 0x1EF0, 0x1EF2, 0x1EF6, 0x1EF8, 0x00DD, 0x1EF4,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x00C0, 0x1EA2, 0x00C3, 0x00C1, 0x1EA0, 0x1EB6, 0x1EAC, 0x00C8,
+        0x1EBA, 0x1EBC, 0x00C9, 0x1EB8, 0x1EC6, 0x00CC, 0x1EC8, 0x0128,
+        0x00CD, 0x1ECA, 0x00D2, 0x1ECE, 0x00D5, 0x00D3, 0x1ECC, 0x1ED8,
+        0x1EDC, 0x1EDE, 0x1EE0, 0x1EDA, 0x1EE2, 0x00D9, 0x1EE6, 0x0168,
+        0x00A0, 0x0102, 0x00C2, 0x00CA, 0x00D4, 0x01A0, 0x01AF, 0x0110,
+        0x0103, 0x00E2, 0x00EA, 0x00F4, 0x01A1, 0x01B0, 0x0111, 0x1EB0,
+        0x0300, 0x0309, 0x0303, 0x0301, 0x0323, 0x00E0, 0x1EA3, 0x00E3,
+        0x00E1, 0x1EA1, 0x1EB2, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EAF, 0x1EB4,
+        0x1EAE, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EA4, 0x1EC0, 0x1EB7, 0x1EA7,
+        0x1EA9, 0x1EAB, 0x1EA5, 0x1EAD, 0x00E8, 0x1EC2, 0x1EBB, 0x1EBD,
+        0x00E9, 0x1EB9, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EBF, 0x1EC7, 0x00EC,
+        0x1EC9, 0x1EC4, 0x1EBE, 0x1ED2, 0x0129, 0x00ED, 0x1ECB, 0x00F2,
+        0x1ED4, 0x1ECF, 0x00F5, 0x00F3, 0x1ECD, 0x1ED3, 0x1ED5, 0x1ED7,
+        0x1ED1, 0x1ED9, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EDB, 0x1EE3, 0x00F9,
+        0x1ED6, 0x1EE7, 0x0169, 0x00FA, 0x1EE5, 0x1EEB, 0x1EED, 0x1EEF,
+        0x1EE9, 0x1EF1, 0x1EF3, 0x1EF7, 0x1EF9, 0x00FD, 0x1EF5, 0x1ED0,
+    },
+    defchars[0],
+}; // generated from tcvn.txt
+
+static const CodePage CODES_TDS565_CODE_PAGE = {
+    CODES_TDS565,
+    {"TDS565",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x00C7, 0x0044, 0x0045, 0x00C4, 0x0046,
+        0x0047, 0x0048, 0x0049, 0x004A, 0x017D, 0x004B, 0x004C, 0x004D,
+        0x004E, 0x0147, 0x004F, 0x00D6, 0x0050, 0x0052, 0x0053, 0x015E,
+        0x0054, 0x0055, 0x00DC, 0x0057, 0x0059, 0x00DD, 0x005A, 0x005F,
+        0x2116, 0x0061, 0x0062, 0x00E7, 0x0064, 0x0065, 0x00E4, 0x0066,
+        0x0067, 0x0068, 0x0069, 0x006A, 0x017E, 0x006B, 0x006C, 0x006D,
+        0x006E, 0x0148, 0x006F, 0x00F6, 0x0070, 0x0072, 0x0073, 0x015F,
+        0x0074, 0x0075, 0x00FC, 0x0077, 0x0079, 0x00FD, 0x007A, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from tds565.txt
+
+static const CodePage CODES_TIS620_CODE_PAGE = {
+    CODES_TIS620,
+    {"TIS620", "TIS-620", "TIS620-0", "TIS620.2529-1", "TIS620.2533-0", "TIS620.2533-1", "ISO-IR-166",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 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, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from tis620.txt
+
+static const CodePage CODES_UNKNOWNPLANE_CODE_PAGE = {
+    CODES_UNKNOWNPLANE,
+    {"unknownplane", "unknown-plane",},
+    {
+        0x0000, 0xF001, 0xF002, 0xF003, 0xF004, 0xF005, 0xF006, 0xF007,
+        0xF008, 0xF009, 0xF00A, 0xF00B, 0xF00C, 0xF00D, 0xF00E, 0xF00F,
+        0xF010, 0xF011, 0xF012, 0xF013, 0xF014, 0xF015, 0xF016, 0xF017,
+        0xF018, 0xF019, 0xF01A, 0xF01B, 0xF01C, 0xF01D, 0xF01E, 0xF01F,
+        0xF020, 0xF021, 0xF022, 0xF023, 0xF024, 0xF025, 0xF026, 0xF027,
+        0xF028, 0xF029, 0xF02A, 0xF02B, 0xF02C, 0xF02D, 0xF02E, 0xF02F,
+        0xF030, 0xF031, 0xF032, 0xF033, 0xF034, 0xF035, 0xF036, 0xF037,
+        0xF038, 0xF039, 0xF03A, 0xF03B, 0xF03C, 0xF03D, 0xF03E, 0xF03F,
+        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, 0xF07F,
+        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, 0xF0A1, 0xF0A2, 0xF0A3, 0xF0A4, 0xF0A5, 0xF0A6, 0xF0A7,
+        0xF0A8, 0xF0A9, 0xF0AA, 0xF0AB, 0xF0AC, 0xF0AD, 0xF0AE, 0xF0AF,
+        0xF0B0, 0xF0B1, 0xF0B2, 0xF0B3, 0xF0B4, 0xF0B5, 0xF0B6, 0xF0B7,
+        0xF0B8, 0xF0B9, 0xF0BA, 0xF0BB, 0xF0BC, 0xF0BD, 0xF0BE, 0xF0BF,
+        0xF0C0, 0xF0C1, 0xF0C2, 0xF0C3, 0xF0C4, 0xF0C5, 0xF0C6, 0xF0C7,
+        0xF0C8, 0xF0C9, 0xF0CA, 0xF0CB, 0xF0CC, 0xF0CD, 0xF0CE, 0xF0CF,
+        0xF0D0, 0xF0D1, 0xF0D2, 0xF0D3, 0xF0D4, 0xF0D5, 0xF0D6, 0xF0D7,
+        0xF0D8, 0xF0D9, 0xF0DA, 0xF0DB, 0xF0DC, 0xF0DD, 0xF0DE, 0xF0DF,
+        0xF0E0, 0xF0E1, 0xF0E2, 0xF0E3, 0xF0E4, 0xF0E5, 0xF0E6, 0xF0E7,
+        0xF0E8, 0xF0E9, 0xF0EA, 0xF0EB, 0xF0EC, 0xF0ED, 0xF0EE, 0xF0EF,
+        0xF0F0, 0xF0F1, 0xF0F2, 0xF0F3, 0xF0F4, 0xF0F5, 0xF0F6, 0xF0F7,
+        0xF0F8, 0xF0F9, 0xF0FA, 0xF0FB, 0xF0FC, 0xF0FD, 0xF0FE, 0xF0FF,
+    },
+    defchars[0],
+}; // generated from unknown.txt
+
+static const CodePage CODES_UTF8_CODE_PAGE = {
+    CODES_UTF8,
+    {"utf-8",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_UTF_16BE_CODE_PAGE = {
+    CODES_UTF_16BE,
+    {"UTF-16BE",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_UTF_16LE_CODE_PAGE = {
+    CODES_UTF_16LE,
+    {"UTF-16LE", "UTF-16",},
+    {},
+    nullptr,
+}; // generated from multibyte.txt
+
+static const CodePage CODES_VISCII_CODE_PAGE = {
+    CODES_VISCII,
+    {"VISCII", "VISCII1.1-1", "CSVISCII",},
+    {
+        0x0000, 0x0001, 0x1EB2, 0x0003, 0x0004, 0x1EB4, 0x1EAA, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x1EF6, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x1EF8, 0x001A, 0x001B, 0x001C, 0x001D, 0x1EF4, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x1EA0, 0x1EAE, 0x1EB0, 0x1EB6, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAC,
+        0x1EBC, 0x1EB8, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1ED0,
+        0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EE2, 0x1EDA, 0x1EDC, 0x1EDE,
+        0x1ECA, 0x1ECE, 0x1ECC, 0x1EC8, 0x1EE6, 0x0168, 0x1EE4, 0x1EF2,
+        0x00D5, 0x1EAF, 0x1EB1, 0x1EB7, 0x1EA5, 0x1EA7, 0x1EA9, 0x1EAD,
+        0x1EBD, 0x1EB9, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1ED1,
+        0x1ED3, 0x1ED5, 0x1ED7, 0x1EE0, 0x01A0, 0x1ED9, 0x1EDD, 0x1EDF,
+        0x1ECB, 0x1EF0, 0x1EE8, 0x1EEA, 0x1EEC, 0x01A1, 0x1EDB, 0x01AF,
+        0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x1EA2, 0x0102, 0x1EB3, 0x1EB5,
+        0x00C8, 0x00C9, 0x00CA, 0x1EBA, 0x00CC, 0x00CD, 0x0128, 0x1EF3,
+        0x0110, 0x1EE9, 0x00D2, 0x00D3, 0x00D4, 0x1EA1, 0x1EF7, 0x1EEB,
+        0x1EED, 0x00D9, 0x00DA, 0x1EF9, 0x1EF5, 0x00DD, 0x1EE1, 0x01B0,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x1EA3, 0x0103, 0x1EEF, 0x1EAB,
+        0x00E8, 0x00E9, 0x00EA, 0x1EBB, 0x00EC, 0x00ED, 0x0129, 0x1EC9,
+        0x0111, 0x1EF1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x1ECF, 0x1ECD,
+        0x1EE5, 0x00F9, 0x00FA, 0x0169, 0x1EE7, 0x00FD, 0x1EE3, 0x1EEE,
+    },
+    defchars[0],
+}; // generated from viscii.txt
+
+static const CodePage CODES_WIN_CODE_PAGE = {
+    CODES_WIN,
+    {"windows-1251", "cp1251", "1251", "win",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
+        0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
+        0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,
+        0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+        0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7,
+        0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+        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,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WINDOWS_1253_CODE_PAGE = {
+    CODES_WINDOWS_1253,
+    {"windows-1253",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0xFFFD, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x00A0, 0x0385, 0x0386, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x2015,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x00B5, 0x00B6, 0x00B7,
+        0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
+        0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+        0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
+        0x03A0, 0x03A1, 0xFFFD, 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, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WINDOWS_1254_CODE_PAGE = {
+    CODES_WINDOWS_1254,
+    {"windows-1254",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFD, 0xFFFD, 0x0178,
+        0x00A0, 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,
+        0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+        0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
+        0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
+        0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
+        0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WINDOWS_1255_CODE_PAGE = {
+    CODES_WINDOWS_1255,
+    {"windows-1255",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x02DC, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+        0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
+        0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
+        0x05B8, 0x05B9, 0xFFFD, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
+        0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
+        0x05F4, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+        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, 0xFFFD, 0xFFFD, 0x200E, 0x200F, 0xFFFD,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WINDOWS_1256_CODE_PAGE = {
+    CODES_WINDOWS_1256,
+    {"windows-1256",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0x067E, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+        0x02C6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
+        0x06AF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0x06A9, 0x2122, 0x0691, 0x203A, 0x0153, 0x200C, 0x200D, 0x06BA,
+        0x00A0, 0x060C, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x06BE, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+        0x00B8, 0x00B9, 0x061B, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x061F,
+        0x06C1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+        0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
+        0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00D7,
+        0x0637, 0x0638, 0x0639, 0x063A, 0x0640, 0x0641, 0x0642, 0x0643,
+        0x00E0, 0x0644, 0x00E2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00E7,
+        0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x0649, 0x064A, 0x00EE, 0x00EF,
+        0x064B, 0x064C, 0x064D, 0x064E, 0x00F4, 0x064F, 0x0650, 0x00F7,
+        0x0651, 0x00F9, 0x0652, 0x00FB, 0x00FC, 0x200E, 0x200F, 0x06D2,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WINDOWS_1257_CODE_PAGE = {
+    CODES_WINDOWS_1257,
+    {"windows-1257",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0xFFFD, 0x201E, 0x2026, 0x2020, 0x2021,
+        0xFFFD, 0x2030, 0xFFFD, 0x2039, 0xFFFD, 0x00A8, 0x02C7, 0x00B8,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0xFFFD, 0x203A, 0xFFFD, 0x00AF, 0x02DB, 0xFFFD,
+        0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0xFFFD, 0x00A6, 0x00A7,
+        0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
+        0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+        0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
+        0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
+        0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
+        0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
+        0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
+        0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
+        0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
+        0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
+        0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x02D9,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_WIN_EAST_CODE_PAGE = {
+    CODES_WIN_EAST,
+    {"windows-1250", "cp1250", "1250", "win-east",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x20AC, 0xFFFD, 0x201A, 0xFFFD, 0x201E, 0x2026, 0x2020, 0x2021,
+        0xFFFD, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179,
+        0xFFFD, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+        0xFFFD, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A,
+        0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7,
+        0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B,
+        0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+        0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C,
+        0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
+        0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
+        0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
+        0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
+        0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
+        0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
+        0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
+        0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
+    },
+    defchars[0],
+}; // generated from listing.txt
+
+static const CodePage CODES_YANDEX_CODE_PAGE = {
+    CODES_YANDEX,
+    {"yandex",},
+    {
+        0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+        0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
+        0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
+        0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
+        0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+        0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+        0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+        0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+        0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+        0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+        0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+        0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+        0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+        0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+        0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+        0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
+        0x0301, 0x00C4, 0x00D6, 0x00DC, 0x0104, 0x0106, 0x0118, 0x0141,
+        0x00E0, 0x00E2, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x0490, 0x00AD,
+        0x00DF, 0x00E4, 0x00F6, 0x00FC, 0x0105, 0x0107, 0x0119, 0x0142,
+        0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F9, 0x00FB, 0x0491, 0x92CF,
+        0x00A0, 0x0143, 0x00D3, 0x015A, 0x017B, 0x0179, 0x046C, 0x00A7,
+        0x0401, 0x0462, 0x0472, 0x0474, 0x040E, 0x0406, 0x0404, 0x0407,
+        0x00B0, 0x0144, 0x00F3, 0x015B, 0x017C, 0x017A, 0x046D, 0x2116,
+        0x0451, 0x0463, 0x0473, 0x0475, 0x045E, 0x0456, 0x0454, 0x0457,
+        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,
+    },
+    defchars[1],
+}; // generated from yandex.txt
+
+const char defchars[][DEFCHAR_BUF] = {
+    {"\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"}, // generated from ascii_dc.txt
+    {"\077\xA6\xB6\xA6\055\xB6\x9F\x9F\x9F\x9F\x9F\x9F\x9F\200\200\200\071\130\077\071\040\040\n\n\x1A\x1A\x1A\x1A\x1A\x1A\x1A\077\077\055\055\050\042\051\042\042\042\137\052\042\056\055\055\075\055\044\140\xB0\047\047\047\047\047"}, // generated from yandex_dc.txt
+};
+
+const CodePage* const NCodepagePrivate::TCodePageData::AllCodePages[] = {
+    &CODES_ALT_CODE_PAGE,
+    &CODES_ARMSCII_CODE_PAGE,
+    &CODES_ASCII_CODE_PAGE,
+    &CODES_BIG5_CODE_PAGE,
+    &CODES_BIG5_HKSCS_CODE_PAGE,
+    &CODES_BIG5_HKSCS_1999_CODE_PAGE,
+    &CODES_BIG5_HKSCS_2001_CODE_PAGE,
+    &CODES_CP1046_CODE_PAGE,
+    &CODES_CP1124_CODE_PAGE,
+    &CODES_CP1125_CODE_PAGE,
+    &CODES_CP1129_CODE_PAGE,
+    &CODES_CP1131_CODE_PAGE,
+    &CODES_CP1133_CODE_PAGE,
+    &CODES_CP1161_CODE_PAGE,
+    &CODES_CP1162_CODE_PAGE,
+    &CODES_CP1163_CODE_PAGE,
+    &CODES_CP1258_CODE_PAGE,
+    &CODES_CP437_CODE_PAGE,
+    &CODES_CP737_CODE_PAGE,
+    &CODES_CP775_CODE_PAGE,
+    &CODES_CP850_CODE_PAGE,
+    &CODES_CP852_CODE_PAGE,
+    &CODES_CP853_CODE_PAGE,
+    &CODES_CP856_CODE_PAGE,
+    &CODES_CP857_CODE_PAGE,
+    &CODES_CP858_CODE_PAGE,
+    &CODES_CP860_CODE_PAGE,
+    &CODES_CP861_CODE_PAGE,
+    &CODES_CP862_CODE_PAGE,
+    &CODES_CP863_CODE_PAGE,
+    &CODES_CP864_CODE_PAGE,
+    &CODES_CP865_CODE_PAGE,
+    &CODES_CP869_CODE_PAGE,
+    &CODES_CP874_CODE_PAGE,
+    &CODES_CP922_CODE_PAGE,
+    &CODES_CP932_CODE_PAGE,
+    &CODES_CP936_CODE_PAGE,
+    &CODES_CP949_CODE_PAGE,
+    &CODES_CP950_CODE_PAGE,
+    &CODES_EUC_CN_CODE_PAGE,
+    &CODES_EUC_JP_CODE_PAGE,
+    &CODES_EUC_KR_CODE_PAGE,
+    &CODES_EUC_TW_CODE_PAGE,
+    &CODES_GB18030_CODE_PAGE,
+    &CODES_GBK_CODE_PAGE,
+    &CODES_GEO_ITA_CODE_PAGE,
+    &CODES_GEO_PS_CODE_PAGE,
+    &CODES_HP_ROMAN8_CODE_PAGE,
+    &CODES_HZ_CODE_PAGE,
+    &CODES_IBM855_CODE_PAGE,
+    &CODES_ISO646_CN_CODE_PAGE,
+    &CODES_ISO646_JP_CODE_PAGE,
+    &CODES_ISO8859_10_CODE_PAGE,
+    &CODES_ISO8859_11_CODE_PAGE,
+    &CODES_ISO8859_14_CODE_PAGE,
+    &CODES_ISO_2022_CN_CODE_PAGE,
+    &CODES_ISO_2022_CN_EXT_CODE_PAGE,
+    &CODES_ISO_2022_JP_CODE_PAGE,
+    &CODES_ISO_2022_JP_1_CODE_PAGE,
+    &CODES_ISO_2022_JP_2_CODE_PAGE,
+    &CODES_ISO_2022_KR_CODE_PAGE,
+    &CODES_ISO_8859_13_CODE_PAGE,
+    &CODES_ISO_8859_15_CODE_PAGE,
+    &CODES_ISO_8859_16_CODE_PAGE,
+    &CODES_ISO_8859_3_CODE_PAGE,
+    &CODES_ISO_8859_4_CODE_PAGE,
+    &CODES_ISO_8859_6_CODE_PAGE,
+    &CODES_ISO_8859_7_CODE_PAGE,
+    &CODES_ISO_8859_8_CODE_PAGE,
+    &CODES_ISO_8859_9_CODE_PAGE,
+    &CODES_ISO_EAST_CODE_PAGE,
+    &CODES_JISX0201_CODE_PAGE,
+    &CODES_JOHAB_CODE_PAGE,
+    &CODES_KAZWIN_CODE_PAGE,
+    &CODES_KOI8_CODE_PAGE,
+    &CODES_KOI8_T_CODE_PAGE,
+    &CODES_MAC_CODE_PAGE,
+    &CODES_MAC_ARABIC_CODE_PAGE,
+    &CODES_MAC_CENTRALEUROPE_CODE_PAGE,
+    &CODES_MAC_CROATIAN_CODE_PAGE,
+    &CODES_MAC_GREEK_CODE_PAGE,
+    &CODES_MAC_HEBREW_CODE_PAGE,
+    &CODES_MAC_ICELAND_CODE_PAGE,
+    &CODES_MAC_ROMAN_CODE_PAGE,
+    &CODES_MAC_ROMANIA_CODE_PAGE,
+    &CODES_MAC_THAI_CODE_PAGE,
+    &CODES_MAC_TURKISH_CODE_PAGE,
+    &CODES_MAIN_CODE_PAGE,
+    &CODES_MULELAO_CODE_PAGE,
+    &CODES_NEXTSTEP_CODE_PAGE,
+    &CODES_PT154_CODE_PAGE,
+    &CODES_RESERVED_2_CODE_PAGE,
+    &CODES_RESERVED_3_CODE_PAGE,
+    &CODES_RISCOS_LATIN1_CODE_PAGE,
+    &CODES_RK1048_CODE_PAGE,
+    &CODES_SHIFT_JIS_CODE_PAGE,
+    &CODES_TATWIN_CODE_PAGE,
+    &CODES_TCVN_CODE_PAGE,
+    &CODES_TDS565_CODE_PAGE,
+    &CODES_TIS620_CODE_PAGE,
+    &CODES_UNKNOWNPLANE_CODE_PAGE,
+    &CODES_UTF8_CODE_PAGE,
+    &CODES_UTF_16BE_CODE_PAGE,
+    &CODES_UTF_16LE_CODE_PAGE,
+    &CODES_VISCII_CODE_PAGE,
+    &CODES_WIN_CODE_PAGE,
+    &CODES_WINDOWS_1253_CODE_PAGE,
+    &CODES_WINDOWS_1254_CODE_PAGE,
+    &CODES_WINDOWS_1255_CODE_PAGE,
+    &CODES_WINDOWS_1256_CODE_PAGE,
+    &CODES_WINDOWS_1257_CODE_PAGE,
+    &CODES_WIN_EAST_CODE_PAGE,
+    &CODES_YANDEX_CODE_PAGE,
+};
+
+const CodePage& csYandex = CODES_YANDEX_CODE_PAGE;
diff --git a/library/cpp/charset/generated/encrec_data.cpp b/library/cpp/charset/generated/encrec_data.cpp
new file mode 100644
index 0000000000..c1a8579dac
--- /dev/null
+++ b/library/cpp/charset/generated/encrec_data.cpp
@@ -0,0 +1,15082 @@
+#include <library/cpp/charset/codepage.h>
+#include <library/cpp/charset/wide.h>
+
+extern const char defchars[][DEFCHAR_BUF];
+static const char PP_00[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P00 (char*)PP_00
+static const char PP_01[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\244\000\246\247\000\251\000\253\254\255\256\000\260\261\000\000"
+    "\000\265\266\267\000\000\000\273\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P01 (char*)PP_01
+static const char PP_02[257] =
+    "\000\250\200\201\252\275\262\257\243\212\214\216\215\000\241\217\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\000\270\220\203\272\276\263\277\274\232"
+    "\234\236\235\000\242\237\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\245\264\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P02 (char*)PP_02
+static const char PP_03[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\210\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P03 (char*)PP_03
+static const char PP_04[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\271\000\000\000\000\000\000\000\000\000\000\000\231\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P04 (char*)PP_04
+static const char PP_05[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\232\000"
+    "\000\000\000\000\000\000\000\277\000\000\000\000\000\000\234\000\235\000"
+    "\000\000\000\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000"
+    "\000\000\000\000";
+#define P05 (char*)PP_05
+static const char PP_06[257] =
+    "\000\263\000\000\264\000\266\267\000\000\000\000\000\000\000\000\341\342"
+    "\367\347\344\345\366\372\351\352\353\354\355\356\357\360\362\363\364\365"
+    "\346\350\343\376\373\375\377\371\370\374\340\361\301\302\327\307\304\305"
+    "\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336"
+    "\333\335\337\331\330\334\300\321\000\243\000\000\244\000\246\247\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\275\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P06 (char*)PP_06
+static const char PP_07[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\225\226\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\227\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\230\231\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P07 (char*)PP_07
+static const char PP_08[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\233\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P08 (char*)PP_08
+static const char PP_09[257] =
+    "\200\000\201\000\000\000\000\000\000\000\000\000\202\000\000\000\203\000"
+    "\000\000\204\000\000\000\205\000\000\000\206\000\000\000\000\000\000\000"
+    "\207\000\000\000\000\000\000\000\210\000\000\000\000\000\000\000\211\000"
+    "\000\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\240\241\242\000\245\000\000\250\251\252"
+    "\253\254\000\256\257\260\261\262\000\265\000\000\270\271\272\273\274\000"
+    "\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\213\000\000\000\214\000\000\000\215\000\000\000\216\000\000\000"
+    "\217\220\221\222\000\000\000\000\000\000\000\000\000\000\000\000\224\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P09 (char*)PP_09
+static const char PP_10[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\375\000\000\000\000\000\000\000\000\000\000\000\370\000\000\000"
+    "\000\000\000\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P10 (char*)PP_10
+static const char PP_11[257] =
+    "\000\360\000\000\362\000\000\364\000\000\000\000\000\000\366\000\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223"
+    "\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245"
+    "\246\247\250\251\252\253\254\255\256\257\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\000\361\000\000\363\000\000\365\000\000"
+    "\000\000\000\000\367\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P11 (char*)PP_11
+static const char PP_12[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\374\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P12 (char*)PP_12
+static const char PP_13[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\371\373\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P13 (char*)PP_13
+static const char PP_14[257] =
+    "\304\000\263\000\000\000\000\000\000\000\000\000\332\000\000\000\277\000"
+    "\000\000\300\000\000\000\331\000\000\000\303\000\000\000\000\000\000\000"
+    "\264\000\000\000\000\000\000\000\302\000\000\000\000\000\000\000\301\000"
+    "\000\000\000\000\000\000\305\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\315\272\325\326\311\270\267\273\324\323"
+    "\310\276\275\274\306\307\314\265\266\271\321\322\313\317\320\312\330\327"
+    "\316\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\337\000\000\000\334\000\000\000\333\000\000\000\335\000\000\000"
+    "\336\260\261\262\000\000\000\000\000\000\000\000\000\000\000\000\376\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P14 (char*)PP_14
+static const char PP_15[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\000"
+    "\000\243\000\000\000\244\000\251\000\307\302\000\250\000\241\261\000\000"
+    "\000\265\246\000\000\000\000\310\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\326\000\000\000\000"
+    "\000\000\000\000";
+#define P15 (char*)PP_15
+static const char PP_16[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\304\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P16 (char*)PP_16
+static const char PP_17[257] =
+    "\000\335\253\256\270\301\247\272\267\274\276\313\315\000\330\332\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223"
+    "\224\225\226\227\230\231\232\233\234\235\236\237\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\337\000\336\254\257\271\317\264\273\300\275"
+    "\277\314\316\000\331\333\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\242\266\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P17 (char*)PP_17
+static const char PP_18[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\000\000\322\323\327\000\240\000\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\377\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P18 (char*)PP_18
+static const char PP_19[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\334\000\000\000\000\000\000\000\000\000\000\000\252\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P19 (char*)PP_19
+static const char PP_20[257] =
+    "\000\000\000\000\000\000\306\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\303\000\000\000\260\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\255\000\000\000\262\263\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P20 (char*)PP_20
+static const char PP_21[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\000\000\000\375\000\000\000\000\000\255\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P21 (char*)PP_21
+static const char PP_22[257] =
+    "\000\241\242\243\244\245\246\247\250\251\252\253\254\000\256\257\260\261"
+    "\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\000\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\000\376\377\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P22 (char*)PP_22
+static const char PP_23[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\360\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P23 (char*)PP_23
+static const char PP_24[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P24 (char*)PP_24
+static const char PP_25[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\212\232\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\216"
+    "\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P25 (char*)PP_25
+static const char PP_26[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\210\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\230\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P26 (char*)PP_26
+static const char PP_27[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P27 (char*)PP_27
+static const char PP_28[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\231\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P28 (char*)PP_28
+static const char PP_29[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P29 (char*)PP_29
+static const char PP_30[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\244\000\246\247\250\251\000\253\254\255\256\000\260\261\000\000"
+    "\264\265\266\267\270\000\000\273\000\000\000\000\000\301\302\000\304\000"
+    "\000\307\000\311\000\313\000\315\316\000\000\000\000\323\324\000\326\327"
+    "\000\000\332\000\334\335\000\337\000\341\342\000\344\000\000\347\000\351"
+    "\000\353\000\355\356\000\000\000\000\363\364\000\366\367\000\000\372\000"
+    "\374\375\000\000";
+#define P30 (char*)PP_30
+static const char PP_31[257] =
+    "\000\000\303\343\245\271\306\346\000\000\000\000\310\350\317\357\320\360"
+    "\000\000\000\000\000\000\312\352\314\354\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\305\345\000\000\274\276\000\000\243\263\321\361\000\000\322"
+    "\362\000\000\000\000\000\000\000\325\365\000\000\300\340\000\000\330\370"
+    "\214\234\000\000\252\272\212\232\336\376\215\235\000\000\000\000\000\000"
+    "\000\000\331\371\333\373\000\000\000\000\000\000\000\217\237\257\277\216"
+    "\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P31 (char*)PP_31
+static const char PP_32[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\242\377\000\262\000\275\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P32 (char*)PP_32
+static const char PP_33[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\244\000\000\247\250\000\000\000\000\255\000\000\260\000\000\000"
+    "\264\000\000\000\270\000\000\000\000\000\000\000\000\301\302\000\304\000"
+    "\000\307\000\311\000\313\000\315\316\000\000\000\000\323\324\000\326\327"
+    "\000\000\332\000\334\335\000\337\000\341\342\000\344\000\000\347\000\351"
+    "\000\353\000\355\356\000\000\000\000\363\364\000\366\367\000\000\372\000"
+    "\374\375\000\000";
+#define P33 (char*)PP_33
+static const char PP_34[257] =
+    "\000\000\303\343\241\261\306\346\000\000\000\000\310\350\317\357\320\360"
+    "\000\000\000\000\000\000\312\352\314\354\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\305\345\000\000\245\265\000\000\243\263\321\361\000\000\322"
+    "\362\000\000\000\000\000\000\000\325\365\000\000\300\340\000\000\330\370"
+    "\246\266\000\000\252\272\251\271\336\376\253\273\000\000\000\000\000\000"
+    "\000\000\331\371\333\373\000\000\000\000\000\000\000\254\274\257\277\256"
+    "\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P34 (char*)PP_34
+static const char PP_35[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\267\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\242\377\000\262\000\275\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P35 (char*)PP_35
+static const char PP_36[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\000\000\000\247\000\000\141\000\000\217\000\000\260\000\062\063"
+    "\000\000\000\000\000\061\157\000\061\061\063\000\101\101\101\101\201\101"
+    "\000\103\105\105\105\105\111\111\111\111\000\116\117\242\117\117\202\000"
+    "\000\125\125\125\203\131\000\220\210\141\211\141\221\141\000\212\213\214"
+    "\215\230\151\151\231\232\000\156\157\262\233\157\222\000\000\234\165\235"
+    "\223\171\000\171";
+#define P36 (char*)PP_36
+static const char PP_37[257] =
+    "\101\141\101\141\204\224\205\225\103\143\103\143\103\143\104\144\000\000"
+    "\105\145\105\145\105\145\206\226\105\145\107\147\107\147\107\147\107\147"
+    "\110\150\000\000\111\151\111\151\111\151\111\151\111\000\111\151\112\152"
+    "\113\153\000\114\154\114\154\114\154\114\154\207\227\241\261\116\156\116"
+    "\156\000\000\000\117\157\117\157\117\157\000\000\122\162\122\162\122\162"
+    "\243\263\123\163\123\163\123\163\124\164\124\164\000\000\125\165\125\165"
+    "\125\165\125\165\125\165\125\165\127\167\131\171\131\245\265\244\264\132"
+    "\172\163\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\117\157"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\125\165\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\104\104"
+    "\144\114\114\154\116\116\156\101\141\111\151\117\157\125\165\125\165\125"
+    "\165\125\165\125\165\000\101\141\101\141\000\000\000\000\107\147\113\153"
+    "\117\157\117\157\000\000\152\104\104\144\107\147\000\000\116\156\101\141"
+    "\000\000\000\000";
+#define P37 (char*)PP_37
+static const char PP_38[257] =
+    "\101\141\101\141\105\145\105\145\111\151\111\151\117\157\117\157\122\162"
+    "\122\162\125\165\125\165\123\163\124\164\000\000\110\150\000\000\000\000"
+    "\000\000\101\141\105\145\117\157\117\157\117\157\117\157\131\171\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\150\000\152\162"
+    "\000\000\000\167\171\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\154\163\170\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P38 (char*)PP_38
+static const char PP_39[257] =
+    "\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P39 (char*)PP_39
+static const char PP_40[257] =
+    "\305\250\000\303\256\000\255\257\000\000\000\000\312\310\254\000\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\345\270\000\343\276\000\275\277\000\000"
+    "\000\000\352\350\274\000\000\000\251\271\000\000\000\000\000\000\000\000"
+    "\246\266\000\000\000\000\252\272\253\273\253\273\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\216\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\306\346\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\300\340\300\340\000\000\305\345"
+    "\000\000\000\000\306\346\307\347\000\000\310\350\310\350\316\356\000\000"
+    "\000\000\335\375\323\363\323\363\323\363\327\367\000\000\333\373\000\000"
+    "\000\000\000\000";
+#define P40 (char*)PP_40
+static const char PP_41[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\101\000\102\000\104\105\000\107\110\111"
+    "\112\113\114\115\116\000\117\000\120\122\124\125\127\141\000\000\000\142"
+    "\144\145\000\000\000\147\000\153\155\000\157\000\000\000\160\164\165\000"
+    "\000\166\000\000\000\000\000\000\151\162\165\166\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\355\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\143\000\000\000\146\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P41 (char*)PP_41
+static const char PP_42[257] =
+    "\101\141\102\142\102\142\102\142\103\143\104\144\104\144\104\144\104\144"
+    "\104\144\105\145\105\145\105\145\105\145\105\145\106\146\107\147\110\150"
+    "\110\150\110\150\110\150\110\150\111\151\111\151\113\153\113\153\113\153"
+    "\114\154\114\154\114\154\114\154\115\155\115\155\115\155\116\156\116\156"
+    "\116\156\116\156\117\157\117\157\117\157\117\157\120\160\120\160\122\162"
+    "\122\162\122\162\122\162\123\163\123\163\123\163\123\163\123\163\124\164"
+    "\124\164\124\164\124\164\125\165\125\165\125\165\125\165\125\165\126\166"
+    "\126\166\127\167\127\167\127\167\127\167\127\167\130\170\130\170\131\171"
+    "\132\172\132\172\132\172\150\164\167\171\141\163\000\000\000\000\101\141"
+    "\101\141\101\141\101\141\101\141\101\141\101\141\101\141\101\141\101\141"
+    "\101\141\101\141\105\145\105\145\105\145\105\145\105\145\105\145\105\145"
+    "\105\145\111\151\111\151\117\157\117\157\117\157\117\157\117\157\117\157"
+    "\117\157\117\157\117\157\117\157\117\157\117\157\125\165\125\165\125\165"
+    "\125\165\125\165\125\165\125\165\131\171\131\171\131\171\131\171\000\000"
+    "\000\000\000\000";
+#define P42 (char*)PP_42
+static const char PP_43[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\060\151\000\000\064\065\066\067\070\071\000\000\000\000"
+    "\000\156\060\061\062\063\064\065\066\067\070\071\000\000\000\000\000\000"
+    "\141\145\157\170\000\150\153\154\155\156\160\163\164\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P43 (char*)PP_43
+static const char PP_44[257] =
+    "\000\000\103\000\000\000\000\000\000\000\147\110\110\110\150\000\111\111"
+    "\114\154\000\116\267\000\000\120\121\122\122\122\000\000\000\000\000\000"
+    "\132\000\000\000\132\000\113\101\102\103\000\145\105\106\000\115\157\000"
+    "\000\000\000\151\000\000\000\000\000\000\000\000\000\000\000\104\144\145"
+    "\151\152\000\000\000\000\000\000\061\061\061\061\062\061\062\063\064\061"
+    "\065\061\063\065\067\061\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\060\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P44 (char*)PP_44
+static const char PP_45[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\061\062\063\064\065\066\067\070\071\061\061\061"
+    "\061\061\061\061\061\061\061\062\061\062\063\064\065\066\067\070\071\061"
+    "\061\061\061\061\061\061\061\061\061\062\061\062\063\064\065\066\067\070"
+    "\071\061\061\061\061\061\061\061\061\061\061\062\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\060\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P45 (char*)PP_45
+static const char PP_46[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\152\126"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P46 (char*)PP_46
+static const char PP_47[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\062\062\062\062\062\062\062\062\062"
+    "\063\063\063\063\063\063\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\063\063\063"
+    "\063\064\064\064\064\064\064\064\064\064\064\065\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P47 (char*)PP_47
+static const char PP_48[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P48 (char*)PP_48
+static const char PP_49[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\372\374\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P49 (char*)PP_49
+static const char PP_50[257] =
+    "\146\146\146\146\146\163\163\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P50 (char*)PP_50
+static const char PP_51[257] =
+    "\000\000\042\000\000\000\000\047\000\000\000\000\000\000\000\000\060\061"
+    "\062\063\064\065\066\067\070\071\000\000\000\000\000\000\000\101\102\103"
+    "\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125"
+    "\126\127\130\131\132\000\000\000\000\000\000\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P51 (char*)PP_51
+static const char PP_52[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\317\000\000\375\000\000\000\256\000\360\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\257\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P52 (char*)PP_52
+static const char PP_53[257] =
+    "\000\205\201\203\207\211\213\215\217\221\223\225\227\000\231\233\241\243"
+    "\354\255\247\251\352\364\270\276\307\321\323\325\327\335\342\344\346\350"
+    "\253\266\245\374\366\372\237\362\356\370\235\340\240\242\353\254\246\250"
+    "\351\363\267\275\306\320\322\324\326\330\341\343\345\347\252\265\244\373"
+    "\365\371\236\361\355\367\234\336\000\204\200\202\206\210\212\214\216\220"
+    "\222\224\226\000\230\232\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P53 (char*)PP_53
+static const char PP_54[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\357\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P54 (char*)PP_54
+static const char PP_55[257] =
+    "\304\000\263\000\000\000\000\000\000\000\000\000\332\000\000\000\277\000"
+    "\000\000\300\000\000\000\331\000\000\000\303\000\000\000\000\000\000\000"
+    "\264\000\000\000\000\000\000\000\302\000\000\000\000\000\000\000\301\000"
+    "\000\000\000\000\000\000\305\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\315\272\000\000\311\000\000\273\000\000"
+    "\310\000\000\274\000\000\314\000\000\271\000\000\313\000\000\312\000\000"
+    "\316\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\337\000\000\000\334\000\000\000\333\000\000\000\000\000\000\000"
+    "\000\260\261\262\000\000\000\000\000\000\000\000\000\000\000\000\376\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P55 (char*)PP_55
+static const char PP_56[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P56 (char*)PP_56
+static const char PP_57[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\230\000\000\000\000\000\000\000\240\000"
+    "\000\000\244\000\246\247\000\251\000\253\254\255\256\000\260\261\000\000"
+    "\000\265\266\267\000\000\000\273\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P57 (char*)PP_57
+static const char PP_58[257] =
+    "\000\250\000\000\252\000\262\257\000\000\000\000\000\000\241\000\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\000\270\000\000\272\000\263\277\000\000"
+    "\000\000\000\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\201\203\000\000\243\274\000\000\215\235\000\000\000\000\000\000"
+    "\214\234\000\000\000\000\000\000\000\000\000\000\217\237\200\220\245\264"
+    "\000\000\000\000\000\000\216\236\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\275\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\232"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P58 (char*)PP_58
+static const char PP_59[257] =
+    "\000\250\000\201\252\275\262\257\243\000\000\000\000\000\241\000\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\000\270\000\203\272\276\263\277\274\000"
+    "\000\000\000\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\245\264\000\000\000\000\215\235\000\000\000\000\000\000\000\000\000\000"
+    "\216\236\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000"
+    "\000\000\000\000\000\000\217\237\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\200\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\232"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P59 (char*)PP_59
+static const char PP_60[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\247\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\246\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P60 (char*)PP_60
+static const char PP_61[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\241\262\264\266\270\272"
+    "\274\276\300\302\304\306\310\312\314\316\320\322\324\326\330\332\334\336"
+    "\340\342\344\346\350\352\354\356\360\362\364\366\370\372\374\000\000\000"
+    "\376\260\257\252\261\000\000\263\265\267\271\273\275\277\301\303\305\307"
+    "\311\313\315\317\321\323\325\327\331\333\335\337\341\343\345\347\351\353"
+    "\355\357\361\363\365\367\371\373\375\242\000\243\255\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P61 (char*)PP_61
+static const char PP_62[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\250\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\256\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P62 (char*)PP_62
+static const char PP_63[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\000\000\000\000\000\000\000\000\000\000\000\215\216\217"
+    "\220\000\000\000\000\000\000\000\000\000\000\000\000\235\236\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P63 (char*)PP_63
+static const char PP_64[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\212\232\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P64 (char*)PP_64
+static const char PP_65[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\300\301\302\303\304\305\306\307"
+    "\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331"
+    "\332\333\334\335\336\337\340\341\342\343\344\345\346\000\000\000\000\000"
+    "\000\000\000\000";
+#define P65 (char*)PP_65
+static const char PP_66[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P66 (char*)PP_66
+static const char PP_67[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\000\000\000\000\000\000\000\000\000\000\000\215\216\217"
+    "\220\000\000\000\000\000\000\000\000\000\000\000\000\235\236\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P67 (char*)PP_67
+static const char PP_68[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\300\301\302\303\304\305\306\310"
+    "\311\312\313\314\315\317\320\321\322\323\324\326\327\330\331\332\333\334"
+    "\335\336\337\340\341\343\344\307\316\325\342\345\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P68 (char*)PP_68
+static const char PP_69[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\243\244\000\000\247\250\000\000\000\000\255\000\000\260\000\262\263"
+    "\264\265\000\267\270\000\000\000\000\275\000\000\300\301\302\000\304\000"
+    "\000\307\310\311\312\313\314\315\316\317\000\321\322\323\324\000\326\327"
+    "\000\331\332\333\334\000\000\337\340\341\342\000\344\000\000\347\350\351"
+    "\352\353\354\355\356\357\000\361\362\363\364\000\366\367\000\371\372\373"
+    "\374\000\000\000";
+#define P69 (char*)PP_69
+static const char PP_70[257] =
+    "\000\000\000\000\000\000\000\000\306\346\305\345\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\330\370\253\273\325\365\000\000"
+    "\246\266\241\261\000\000\000\000\000\000\000\000\251\271\000\000\254\274"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\336\376\252\272\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\335\375\000\000\000\000\000\000\000\000\000\000\000\000\000\257\277\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P70 (char*)PP_70
+static const char PP_71[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\242\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P71 (char*)PP_71
+static const char PP_72[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\244\000\000\247\250\000\000\000\000\255\000\257\260\000\000\000"
+    "\264\000\000\000\270\000\000\000\000\000\000\000\000\301\302\303\304\305"
+    "\306\000\000\311\000\313\000\315\316\000\000\000\000\000\324\325\326\327"
+    "\330\000\332\333\334\000\000\337\000\341\342\343\344\345\346\000\000\351"
+    "\000\353\000\355\356\000\000\000\000\000\364\365\366\367\370\000\372\373"
+    "\374\000\000\000";
+#define P72 (char*)PP_72
+static const char PP_73[257] =
+    "\300\340\000\000\241\261\000\000\000\000\000\000\310\350\000\000\320\360"
+    "\252\272\000\000\314\354\312\352\000\000\000\000\000\000\000\000\253\273"
+    "\000\000\000\000\245\265\317\357\000\000\307\347\000\000\000\000\000\000"
+    "\323\363\242\000\000\246\266\000\000\000\000\000\000\000\000\321\361\000"
+    "\000\000\275\277\322\362\000\000\000\000\000\000\000\000\243\263\000\000"
+    "\000\000\000\000\000\000\251\271\000\000\000\000\254\274\335\375\336\376"
+    "\000\000\000\000\000\000\331\371\000\000\000\000\000\000\000\000\000\256"
+    "\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P73 (char*)PP_73
+static const char PP_74[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\267\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\377\000\262\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P74 (char*)PP_74
+static const char PP_75[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\232\233\234\235\236\237\240\000"
+    "\000\375\244\000\000\000\000\000\000\256\000\000\000\000\000\000\000\000"
+    "\000\374\000\000\000\000\000\257\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\205\000\203\000\000\000\000\207\212\202"
+    "\210\211\000\000\214\213\000\000\000\000\223\000\000\000\000\227\000\226"
+    "\000\000\000\000";
+#define P75 (char*)PP_75
+static const char PP_76[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\273\000\000\000\277\000\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P76 (char*)PP_76
+static const char PP_77[257] =
+    "\245\000\200\000\000\000\000\000\000\000\000\000\373\000\000\000\230\000"
+    "\000\000\231\000\000\000\372\000\000\000\243\000\000\000\000\000\000\000"
+    "\201\000\000\000\000\000\000\000\242\000\000\000\000\000\000\000\241\000"
+    "\000\000\000\000\000\000\246\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\264\220\275\276\252\216\215\221\274\272"
+    "\251\225\224\222\247\250\263\204\206\217\270\271\255\266\267\253\371\300"
+    "\265\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\337\000\000\000\334\000\000\000\333\000\000\000\335\000\000\000"
+    "\336\260\261\262\000\000\000\000\000\000\000\000\000\000\000\000\376\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P77 (char*)PP_77
+static const char PP_78[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\243\000\000\246\247\250\251\000\253\254\255\000\000\260\261\262\263"
+    "\000\000\000\267\000\000\000\273\000\275\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P78 (char*)PP_78
+static const char PP_79[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\252\000\000\000"
+    "\000\000\000\000\000\000\264\265\266\000\270\271\272\000\274\000\276\277"
+    "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321"
+    "\000\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343"
+    "\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365"
+    "\366\367\370\371\372\373\374\375\376\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P79 (char*)PP_79
+static const char PP_80[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\257\000\000\241\242\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\244\000\000\245\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P80 (char*)PP_80
+static const char PP_81[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\242\243\244\245\246\247\250\251\000\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\000\273\274\275\276\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\252"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\272\000\000\000\000"
+    "\000\000\000\000";
+#define P81 (char*)PP_81
+static const char PP_82[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P82 (char*)PP_82
+static const char PP_83[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\376\000\000"
+    "\000\000\000\000\000\337\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P83 (char*)PP_83
+static const char PP_84[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\000\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\000\000\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\000\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\000\000\377";
+#define P84 (char*)PP_84
+static const char PP_85[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\320\360\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\335\375\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\336\376\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P85 (char*)PP_85
+static const char PP_86[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\242\243\244\000\246\247\000\251\000\253\254\255\256\000\260\261\262\263"
+    "\000\265\266\267\000\271\000\273\274\275\276\000\000\000\000\000\304\305"
+    "\257\000\000\311\000\000\000\000\000\000\000\000\000\323\000\325\326\327"
+    "\250\000\000\000\334\000\000\337\000\000\000\000\344\345\277\000\000\351"
+    "\000\000\000\000\000\000\000\000\000\363\000\365\366\367\270\000\000\000"
+    "\374\000\000\000";
+#define P86 (char*)PP_86
+static const char PP_87[257] =
+    "\302\342\000\000\300\340\303\343\000\000\000\000\310\350\000\000\000\000"
+    "\307\347\000\000\313\353\306\346\000\000\000\000\000\000\000\000\314\354"
+    "\000\000\000\000\000\000\316\356\000\000\301\341\000\000\000\000\000\000"
+    "\315\355\000\000\000\317\357\000\000\000\000\331\371\321\361\322\362\000"
+    "\000\000\000\000\324\364\000\000\000\000\000\000\000\000\252\272\000\000"
+    "\332\372\000\000\000\000\320\360\000\000\000\000\000\000\000\000\333\373"
+    "\000\000\000\000\000\000\330\370\000\000\000\000\000\312\352\335\375\336"
+    "\376\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P87 (char*)PP_87
+static const char PP_88[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\377\000\000\264\241\245\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P88 (char*)PP_88
+static const char PP_89[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\000\245\000\247\000\251\252\253\254\255\256\257\260\261\262\263"
+    "\000\265\266\267\000\271\272\273\000\000\000\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P89 (char*)PP_89
+static const char PP_90[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\274\275\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\246\250\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\276\000\000\000\000\264"
+    "\270\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P90 (char*)PP_90
+static const char PP_91[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\244\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P91 (char*)PP_91
+static const char PP_92[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\000\000\000\247\000\251\000\253\000\255\000\000\260\261\000\000"
+    "\000\000\266\267\000\000\000\273\000\000\000\000\300\301\302\000\304\000"
+    "\306\307\310\311\312\313\314\315\316\317\000\000\322\323\324\000\326\000"
+    "\000\331\332\333\334\000\000\337\340\341\342\000\344\000\346\347\350\351"
+    "\352\353\354\355\356\357\000\000\362\363\364\000\366\000\000\371\372\373"
+    "\374\000\000\377";
+#define P92 (char*)PP_92
+static const char PP_93[257] =
+    "\000\000\303\343\241\242\305\345\000\000\000\000\262\271\000\000\320\360"
+    "\000\000\000\000\000\000\335\375\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\243\263\321\361\000\000\000"
+    "\000\000\000\000\000\000\000\000\325\365\274\275\000\000\000\000\000\000"
+    "\327\367\000\000\000\000\246\250\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\330\370\000\000\000\000\000\000\276\254\256\257\277\264"
+    "\270\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P93 (char*)PP_93
+static const char PP_94[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\252\272\336\376\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P94 (char*)PP_94
+static const char PP_95[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\265\245\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\244\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P95 (char*)PP_95
+static const char PP_96[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\243\244\245\246\247\250\251\000\253\254\255\256\000\260\261\262\263"
+    "\000\265\266\267\000\000\000\273\000\275\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P96 (char*)PP_96
+static const char PP_97[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P97 (char*)PP_97
+static const char PP_98[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\264\241\242\000\270\271\272\000\274\000\276\277"
+    "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321"
+    "\000\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343"
+    "\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365"
+    "\366\367\370\371\372\373\374\375\376\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P98 (char*)PP_98
+static const char PP_99[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\257\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P99 (char*)PP_99
+static const char PP_100[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\000\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\000\000\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\000\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\000\000\377";
+#define P100 (char*)PP_100
+static const char PP_101[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\320\360\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\335\375\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000\000\000"
+    "\000\000\000\000\336\376\212\232\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P101 (char*)PP_101
+static const char PP_102[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\241"
+    "\242\243\000\245\246\247\250\251\000\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\000\273\274\275\276\277\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\252"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\272\000\000\000\000"
+    "\000\000\000\000";
+#define P102 (char*)PP_102
+static const char PP_103[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\300\301\302\303"
+    "\304\305\306\307\310\311\000\313\314\315\316\317\320\321\322\323\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\000\000\000\000\000\324\325\326\327\330\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P103 (char*)PP_103
+static const char PP_104[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\375\376\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\244\000\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P104 (char*)PP_104
+static const char PP_105[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\242\243\244\245\246\247\250\251\000\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\000\273\274\275\276\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\327"
+    "\000\000\000\000\000\000\000\000\340\000\342\000\000\000\000\347\350\351"
+    "\352\353\000\000\356\357\000\000\000\000\364\000\000\367\000\371\000\373"
+    "\374\000\000\000";
+#define P105 (char*)PP_105
+static const char PP_106[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P106 (char*)PP_106
+static const char PP_107[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\210\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P107 (char*)PP_107
+static const char PP_108[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\272\000\000\000\277\000\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\330\331\332\333\000\000\000\000\000\334\335\336\337\341\343\344\345"
+    "\346\354\355\360\361\362\363\365\366\370\372\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\000\000\000"
+    "\201\000\000\000\000\000\000\000\215\000\217\000\000\000\000\000\000\000"
+    "\000\232\000\000\000\000\000\000\216\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\230\000\000\000\000\000\220\000\000\000\000"
+    "\000\000\000\000\000\000\237\000\000\000\252\000\000\300\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\377\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P108 (char*)PP_108
+static const char PP_109[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\235\236\375\376\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P109 (char*)PP_109
+static const char PP_110[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\242\243\244\000\246\247\215\251\000\253\254\255\256\235\260\261\262\263"
+    "\264\265\266\267\217\271\000\273\274\275\276\000\000\000\000\000\304\305"
+    "\257\000\000\311\000\000\000\000\000\000\000\000\000\323\000\325\326\327"
+    "\250\000\000\000\334\000\000\337\000\000\000\000\344\345\277\000\000\351"
+    "\000\000\000\000\000\000\000\000\000\363\000\365\366\367\270\000\000\000"
+    "\374\000\000\000";
+#define P110 (char*)PP_110
+static const char PP_111[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\216\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\377\000\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P111 (char*)PP_111
+static const char PP_112[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\210\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\244\000\000\000\000\000\000\000\000\255\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\201"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\000\000"
+    "\000\000\000\000";
+#define P112 (char*)PP_112
+static const char PP_113[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\273\000\000\000\277\000\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\000\331\332\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\260\261\262\263\264\265\266\267\270\271\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P113 (char*)PP_113
+static const char PP_114[257] =
+    "\213\000\212\000\000\000\000\000\000\000\000\000\215\000\000\000\214\000"
+    "\000\000\216\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\211\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P114 (char*)PP_114
+static const char PP_115[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\205\204\203\206\243\242\241\245"
+    "\366\000\000\000";
+#define P115 (char*)PP_115
+static const char PP_116[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\207\000\000\000\000\000\224\000\220\000\221\000\222"
+    "\000\223\000\000\334\000\335\000\000\000\200\000\225\246\000\000\336\000"
+    "\000\247\000\000\000\000\000\250\000\000\000\251\000\000\000\252\000\000"
+    "\000\253\000\000\000\256\000\000\000\000\000\000\000\000\000\000\000\257"
+    "\000\000\000\272\000\000\000\274\000\000\000\275\000\000\000\000\000\000"
+    "\000\330\000\000\276\300\333\000\231\232\233\000\000\337\000\000\000\363"
+    "\000\000\000\364\000\000\000\365\000\000\000\373\000\000\000\374\000\376"
+    "\000\000\375\000\000\000\226\000\230\227\000\367\234\370\235\371\236\372"
+    "\237\000\000\000";
+#define P116 (char*)PP_116
+static const char PP_117[257] =
+    "\000\241\242\000\244\245\246\247\250\251\252\253\254\000\256\257\260\261"
+    "\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\000\361\362\000\364\365\366\367\370\371"
+    "\372\373\374\000\376\377\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\243\363\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P117 (char*)PP_117
+static const char PP_118[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\375\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P118 (char*)PP_118
+static const char PP_119[257] =
+    "\000\360\000\000\364\000\366\370\000\000\000\000\000\000\000\000\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223"
+    "\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245"
+    "\246\247\250\251\252\253\254\255\256\257\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\000\361\000\000\365\000\367\371\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\362\363\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P119 (char*)PP_119
+static const char PP_120[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\373\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P120 (char*)PP_120
+static const char PP_121[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\000\251\252\253\254\255\256\257\260\261\262\263"
+    "\000\265\266\267\000\271\272\273\274\275\276\277\300\301\302\000\304\305"
+    "\306\307\310\311\312\313\000\315\316\317\000\321\000\323\324\000\326\327"
+    "\330\331\332\333\334\000\000\337\340\341\342\000\344\345\346\347\350\351"
+    "\352\353\000\355\356\357\000\361\000\363\364\000\366\367\370\371\372\373"
+    "\374\000\000\377";
+#define P121 (char*)PP_121
+static const char PP_122[257] =
+    "\000\000\303\343\000\000\000\000\000\000\000\000\000\000\000\000\320\360"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\270\250\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\264\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\325\365"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\335\375\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P122 (char*)PP_122
+static const char PP_123[257] =
+    "\314\354\000\336\000\000\000\000\000\322\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\362"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P123 (char*)PP_123
+static const char PP_124[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\376\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P124 (char*)PP_124
+static const char PP_125[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\373\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P125 (char*)PP_125
+static const char PP_126[257] =
+    "\000\360\000\000\362\000\370\364\000\000\000\000\000\000\366\000\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223"
+    "\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245"
+    "\246\247\250\251\252\253\254\255\256\257\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\000\361\000\000\363\000\371\365\000\000"
+    "\000\000\000\000\367\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\374\375\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P126 (char*)PP_126
+static const char PP_127[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\376\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P127 (char*)PP_127
+static const char PP_128[257] =
+    "\304\000\263\000\000\000\000\000\000\000\000\000\332\000\000\000\277\000"
+    "\000\000\300\000\000\000\331\000\000\000\303\000\000\000\000\000\000\000"
+    "\264\000\000\000\000\000\000\000\302\000\000\000\000\000\000\000\301\000"
+    "\000\000\000\000\000\000\305\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\315\272\325\326\311\270\267\273\324\323"
+    "\310\276\275\274\306\307\314\265\266\271\321\322\313\317\320\312\330\327"
+    "\316\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\337\000\000\000\334\000\000\000\333\000\000\000\335\000\000\000"
+    "\336\260\261\262\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P128 (char*)PP_128
+static const char PP_129[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\374\000\000\000\376\000\000\000\000\000\375\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P129 (char*)PP_129
+static const char PP_130[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\241\242\000\243\000\000\244\245\000\247\000\000\250\000\000"
+    "\000\000\000\000\251\252\253\254\000\255\256\257\260\261\262\263\000\264"
+    "\265\266\000\267\000\270\000\000\246\271\000\272\273\277\300\312\301\302"
+    "\303\304\305\306\307\310\000\313\311\314\000\000\320\321\322\323\324\000"
+    "\333\000\325\326\327\330\331\332\000\000\360\361\362\363\364\365\366\367"
+    "\370\371\000\000\335\336\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P130 (char*)PP_130
+static const char PP_131[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\337\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P131 (char*)PP_131
+static const char PP_132[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\374\000\000\000\376\000\000\000\000\000\375\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P132 (char*)PP_132
+static const char PP_133[257] =
+    "\000\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261"
+    "\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\000\000\000\000\337\340\341\342\343\344\345\346\347"
+    "\240\333\334\335\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P133 (char*)PP_133
+static const char PP_134[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\336\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P134 (char*)PP_134
+static const char PP_135[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\201\202\203\204\000\206\207\210\211\212\213\214\215\216\217"
+    "\220\000\000\000\000\000\000\000\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P135 (char*)PP_135
+static const char PP_136[257] =
+    "\000\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261"
+    "\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\000\000\000\000\337\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P136 (char*)PP_136
+static const char PP_137[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\000\000\223\224\000\000\000\000\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P137 (char*)PP_137
+static const char PP_138[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\000\245\246\247\000\251\252\253\254\255\256\257\260\261\262\263"
+    "\000\265\266\267\000\271\272\273\274\275\276\277\300\301\302\000\304\305"
+    "\306\307\310\311\312\313\000\315\316\317\000\321\000\323\324\000\326\327"
+    "\330\331\332\333\334\000\000\337\340\341\342\000\344\345\346\347\350\351"
+    "\352\353\000\355\356\357\000\361\000\363\364\000\366\367\370\371\372\373"
+    "\374\000\000\377";
+#define P138 (char*)PP_138
+static const char PP_139[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\376\244\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P139 (char*)PP_139
+static const char PP_140[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\000\304\305"
+    "\306\307\310\311\312\313\000\315\316\317\000\321\000\323\324\000\326\327"
+    "\330\331\332\333\334\000\000\337\340\341\342\000\344\345\346\347\350\351"
+    "\352\353\000\355\356\357\000\361\000\363\364\000\366\367\370\371\372\373"
+    "\374\000\000\377";
+#define P140 (char*)PP_140
+static const char PP_141[257] =
+    "\000\000\303\343\000\000\000\000\000\000\000\000\000\000\000\000\320\360"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\214\234\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\325\365"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\335\375\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P141 (char*)PP_141
+static const char PP_142[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\202\000\223\224\204\000\206\207\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\211\000\000\000\000\000"
+    "\000\000\000\213\233\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\376\200\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P142 (char*)PP_142
+static const char PP_143[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\233\234\000\235\000\000\000\000\246\256\252\000\000\000\370\361\375\000"
+    "\000\346\000\372\000\000\247\257\254\253\000\250\000\000\000\000\216\217"
+    "\222\200\000\220\000\000\000\000\000\000\000\245\000\000\000\000\231\000"
+    "\000\000\000\000\232\000\000\341\205\240\203\000\204\206\221\207\212\202"
+    "\210\211\215\241\214\213\000\244\225\242\223\000\224\366\000\227\243\226"
+    "\201\000\000\230";
+#define P143 (char*)PP_143
+static const char PP_144[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P144 (char*)PP_144
+static const char PP_145[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\342\000\000\000\000\351\000\000\000\000\000\000\000\000\000"
+    "\000\344\000\000\350\000\000\352\000\000\000\000\000\000\000\340\000\000"
+    "\353\356\000\000\000\000\000\000\000\000\000\000\343\000\000\345\347\000"
+    "\355\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P145 (char*)PP_145
+static const char PP_146[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\374\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\236\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P146 (char*)PP_146
+static const char PP_147[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\371\373\000\000\000\354\000\000\000\000\000"
+    "\000\000\000\000\000\357\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\367\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\360\000\000\363\362\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P147 (char*)PP_147
+static const char PP_148[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\251\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\364\365\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P148 (char*)PP_148
+static const char PP_149[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\370\361\375\000"
+    "\000\000\000\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\366\000\000\000\000"
+    "\000\000\000\000";
+#define P149 (char*)PP_149
+static const char PP_150[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\352\000\353\354\355\000\356\000\357\360"
+    "\000\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220"
+    "\000\221\222\223\224\225\226\227\364\365\341\342\343\345\000\230\231\232"
+    "\233\234\235\236\237\240\241\242\243\244\245\246\247\250\252\251\253\254"
+    "\255\256\257\340\344\350\346\347\351\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P150 (char*)PP_150
+static const char PP_151[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\374\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P151 (char*)PP_151
+static const char PP_152[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\371\373\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\367\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\363\362\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P152 (char*)PP_152
+static const char PP_153[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\226\234\237\000\247\365\000\250\000\256\252\360\251\000\370\361\375\374"
+    "\000\346\364\372\000\373\000\257\254\253\363\000\000\000\000\000\216\217"
+    "\222\000\000\220\000\000\000\000\000\000\000\000\000\340\000\345\231\236"
+    "\235\000\000\000\232\000\000\341\000\000\000\000\204\206\221\000\000\202"
+    "\000\000\000\000\000\000\000\000\000\242\000\344\224\366\233\000\000\000"
+    "\201\000\000\000";
+#define P153 (char*)PP_153
+static const char PP_154[257] =
+    "\240\203\000\000\265\320\200\207\000\000\000\000\266\321\000\000\000\000"
+    "\355\211\000\000\270\323\267\322\000\000\000\000\000\000\000\000\225\205"
+    "\000\000\000\000\000\000\241\214\000\000\275\324\000\000\000\000\000\000"
+    "\350\351\000\000\000\352\353\000\000\000\000\255\210\343\347\356\354\000"
+    "\000\000\000\000\342\223\000\000\000\000\000\000\000\000\212\213\000\000"
+    "\227\230\000\000\000\000\276\325\000\000\000\000\000\000\000\000\307\327"
+    "\000\000\000\000\000\000\306\326\000\000\000\000\000\215\245\243\244\317"
+    "\330\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P154 (char*)PP_154
+static const char PP_155[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\357\000\000\362\246\367\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P155 (char*)PP_155
+static const char PP_156[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\371\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P156 (char*)PP_156
+static const char PP_157[257] =
+    "\304\000\263\000\000\000\000\000\000\000\000\000\332\000\000\000\277\000"
+    "\000\000\300\000\000\000\331\000\000\000\303\000\000\000\000\000\000\000"
+    "\264\000\000\000\000\000\000\000\302\000\000\000\000\000\000\000\301\000"
+    "\000\000\000\000\000\000\305\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\315\272\000\000\311\000\000\273\000\000"
+    "\310\000\000\274\000\000\314\000\000\271\000\000\313\000\000\312\000\000"
+    "\316\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\337\000\000\000\334\000\000\000\333\000\000\000\335\000\000\000"
+    "\336\260\261\262\000\000\000\000\000\000\000\000\000\000\000\000\376\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P157 (char*)PP_157
+static const char PP_158[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\275\234\317\276\335\365\371\270\246\256\252\360\251\356\370\361\375\374"
+    "\357\346\364\372\367\373\247\257\254\253\363\250\267\265\266\307\216\217"
+    "\222\200\324\220\322\323\336\326\327\330\321\245\343\340\342\345\231\236"
+    "\235\353\351\352\232\355\350\341\205\240\203\306\204\206\221\207\212\202"
+    "\210\211\215\241\214\213\320\244\225\242\223\344\224\366\233\227\243\226"
+    "\201\354\347\230";
+#define P158 (char*)PP_158
+static const char PP_159[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\325\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P159 (char*)PP_159
+static const char PP_160[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\362\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P160 (char*)PP_160
+static const char PP_161[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\000\317\000\000\365\371\000\000\256\252\360\000\000\370\000\000\000"
+    "\357\000\000\000\367\000\000\257\000\000\000\000\000\265\266\000\216\000"
+    "\000\200\000\220\000\323\000\326\327\000\000\000\000\340\342\000\231\236"
+    "\000\000\351\000\232\355\000\341\000\240\203\000\204\000\000\207\000\202"
+    "\000\211\000\241\214\000\000\000\000\242\223\000\224\366\000\000\243\000"
+    "\201\354\000\000";
+#define P161 (char*)PP_161
+static const char PP_162[257] =
+    "\000\000\306\307\244\245\217\206\000\000\000\000\254\237\322\324\321\320"
+    "\000\000\000\000\000\000\250\251\267\330\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\221\222\000\000\225\226\000\000\235\210\343\344\000\000\325"
+    "\345\000\000\000\000\000\000\000\212\213\000\000\350\352\000\000\374\375"
+    "\227\230\000\000\270\255\346\347\335\356\233\234\000\000\000\000\000\000"
+    "\000\000\336\205\353\373\000\000\000\000\000\000\000\215\253\275\276\246"
+    "\247\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P162 (char*)PP_162
+static const char PP_163[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\363\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\364\372\000\362\000\361\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P163 (char*)PP_163
+static const char PP_164[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\234\317\000\000\365\371\000\000\256\000\360\000\000\370\000\375\374"
+    "\357\346\000\000\367\000\000\257\000\253\000\000\267\265\266\000\216\000"
+    "\000\200\324\220\322\323\336\326\327\330\000\245\343\340\342\000\231\236"
+    "\000\353\351\352\232\000\000\341\205\240\203\000\204\000\000\207\212\202"
+    "\210\211\215\241\214\213\000\244\225\242\223\000\224\366\000\227\243\226"
+    "\201\000\000\000";
+#define P164 (char*)PP_164
+static const char PP_165[257] =
+    "\000\000\000\000\000\000\000\000\217\206\222\221\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\235\233\246\247\344\345\000\000"
+    "\250\251\347\350\000\000\000\000\000\000\000\000\230\325\000\000\254\237"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\363\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\306\307\270\255\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\354\355\000\000\000\000\000\000\000\000\000\000\000\000\000\275\276\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P165 (char*)PP_165
+static const char PP_166[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\364\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P166 (char*)PP_166
+static const char PP_167[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\362\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P167 (char*)PP_167
+static const char PP_168[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\275\234\317\276\335\365\371\270\000\256\252\360\251\356\370\361\375\374"
+    "\357\346\364\372\367\373\000\257\254\253\363\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\236"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\366\000\000\000\000"
+    "\000\000\000\000";
+#define P168 (char*)PP_168
+static const char PP_169[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\200\201\202\203\204\205\206\207"
+    "\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231"
+    "\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P169 (char*)PP_169
+static const char PP_170[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\275\234\317\276\335\365\371\270\321\256\252\360\251\356\370\361\375\374"
+    "\357\346\364\372\367\373\320\257\254\253\363\250\267\265\266\307\216\217"
+    "\222\200\324\220\322\323\336\326\327\330\000\245\343\340\342\345\231\350"
+    "\235\353\351\352\232\000\000\341\205\240\203\306\204\206\221\207\212\202"
+    "\210\211\354\241\214\213\000\244\225\242\223\344\224\366\233\227\243\226"
+    "\201\000\000\355";
+#define P170 (char*)PP_170
+static const char PP_171[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\246\247\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\230\215\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\236\237\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P171 (char*)PP_171
+static const char PP_172[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\362\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\325\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P172 (char*)PP_172
+static const char PP_173[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\233\234\000\000\000\000\000\000\246\256\252\000\000\000\370\361\375\000"
+    "\000\346\000\372\000\000\247\257\254\253\000\250\221\206\217\216\000\000"
+    "\000\200\222\220\211\000\230\213\000\000\000\245\251\237\214\231\000\000"
+    "\000\235\226\000\232\000\000\341\205\240\203\204\000\000\000\207\212\202"
+    "\210\000\215\241\000\000\000\244\225\242\223\224\000\366\000\227\243\000"
+    "\201\000\000\000";
+#define P173 (char*)PP_173
+static const char PP_174[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\364\365\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P174 (char*)PP_174
+static const char PP_175[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\000\234\000\000\000\000\000\000\000\256\252\000\000\000\370\361\375\000"
+    "\000\346\000\372\000\000\000\257\254\253\000\250\000\244\000\000\216\217"
+    "\222\200\000\220\000\000\000\245\000\000\213\000\000\246\000\000\231\000"
+    "\235\000\247\000\232\227\215\341\205\240\203\000\204\206\221\207\212\202"
+    "\210\211\000\241\000\000\214\000\000\242\223\000\224\366\233\000\243\226"
+    "\201\230\225\000";
+#define P175 (char*)PP_175
+static const char PP_176[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\233\234\000\235\000\000\000\000\246\256\252\000\000\000\370\361\375\000"
+    "\000\346\000\372\000\000\247\257\254\253\000\250\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\341\000\240\000\000\000\000\000\000\000\000"
+    "\000\000\000\241\000\000\000\244\000\242\000\000\000\366\000\000\243\000"
+    "\000\000\000\000";
+#define P176 (char*)PP_176
+static const char PP_177[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\233\234\230\000\240\217\244\000\000\256\252\000\000\247\370\361\375\246"
+    "\241\346\206\372\245\000\000\257\254\253\255\000\216\000\204\000\000\000"
+    "\000\200\221\220\222\224\000\000\250\225\000\000\000\000\231\000\000\000"
+    "\000\235\000\236\232\000\000\341\205\000\203\000\000\000\000\207\212\202"
+    "\210\211\000\000\214\213\000\000\000\242\223\000\000\366\000\227\243\226"
+    "\201\000\000\000";
+#define P177 (char*)PP_177
+static const char PP_178[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\215\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\374\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P178 (char*)PP_178
+static const char PP_179[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\000\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\300\243\244\000\333\000\000\000\000\227\334\241\000\000\200\223\000\000"
+    "\000\000\000\201\000\000\000\230\225\224\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\336"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\335\000\000\000\000"
+    "\000\000\000\000";
+#define P179 (char*)PP_179
+static const char PP_180[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\220\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\222\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P180 (char*)PP_180
+static const char PP_181[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\273\000\000\000\277\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\340\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\361\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\260\261\262\263\264\265\266\267\270\271\045\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P181 (char*)PP_181
+static const char PP_182[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\202\203\000\000\000\221\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\226\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P182 (char*)PP_182
+static const char PP_183[257] =
+    "\205\000\206\000\000\000\000\000\000\000\000\000\215\000\000\000\214\000"
+    "\000\000\216\000\000\000\217\000\000\000\212\000\000\000\000\000\000\000"
+    "\210\000\000\000\000\000\000\000\211\000\000\000\000\000\000\000\213\000"
+    "\000\000\000\000\000\000\207\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\204\000\000\000\000\000\000\000\000\000\000\000\000\000\376\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P183 (char*)PP_183
+static const char PP_184[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\360"
+    "\000\000\301\302\242\303\245\304\000\000\000\000\000\306\000\307\250\251"
+    "\000\310\000\311\000\252\000\312\000\253\000\313\000\255\000\314\000\256"
+    "\000\315\000\257\000\316\000\317\000\320\000\321\000\322\000\274\000\323"
+    "\000\275\000\324\000\276\000\325\000\353\000\326\000\327\000\000\000\330"
+    "\000\000\000\337\305\331\354\356\355\332\367\272\000\341\000\370\000\342"
+    "\000\374\000\343\000\373\000\344\000\357\000\345\000\362\000\346\000\363"
+    "\000\347\364\350\000\351\365\375\366\352\000\371\372\231\232\000\000\235"
+    "\236\000\000\000";
+#define P184 (char*)PP_184
+static const char PP_185[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\255"
+    "\000\234\257\000\000\000\000\000\246\256\252\000\000\000\370\361\375\000"
+    "\000\346\000\372\000\000\247\000\254\253\000\250\000\000\000\000\216\217"
+    "\222\200\000\220\000\000\000\000\000\000\000\245\000\000\000\000\231\000"
+    "\235\000\000\000\232\000\000\341\205\240\203\000\204\206\221\207\212\202"
+    "\210\211\215\241\214\213\000\244\225\242\223\000\224\366\233\227\243\226"
+    "\201\000\000\230";
+#define P185 (char*)PP_185
+static const char PP_186[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\377\000"
+    "\000\234\000\000\212\365\371\227\000\256\211\360\000\000\370\361\231\232"
+    "\000\000\000\210\000\000\000\257\000\253\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P186 (char*)PP_186
+static const char PP_187[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\357\367\206\000\215\217\220\000\222\000\225\230"
+    "\241\244\245\246\247\250\251\252\254\255\265\266\267\270\275\276\306\307"
+    "\000\317\320\321\322\323\324\325\221\226\233\235\236\237\374\326\327\330"
+    "\335\336\340\341\342\343\344\345\346\347\350\351\352\353\355\354\356\362"
+    "\363\364\366\372\240\373\242\243\375\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P187 (char*)PP_187
+static const char PP_188[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\216\000\000\213\214\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P188 (char*)PP_188
+static const char PP_189[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P189 (char*)PP_189
+static const char PP_190[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\000\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\000\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\000\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\000\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\000\377";
+#define P190 (char*)PP_190
+static const char PP_191[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\320\360\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\336"
+    "\376\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P191 (char*)PP_191
+static const char PP_192[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\257\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P192 (char*)PP_192
+static const char PP_193[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\270"
+    "\277\273\272\274\000\275\253\000\371\373\000\000\000\260\263\376\000\000"
+    "\250\363\364\362\000\000\372\375\367\370\365\271\241\340\242\341\330\320"
+    "\323\264\243\334\244\245\346\345\246\247\343\266\350\347\337\351\332\000"
+    "\322\255\355\256\333\261\360\336\310\304\300\342\314\324\327\265\311\305"
+    "\301\315\331\325\321\335\344\267\312\306\302\352\316\000\326\313\307\303"
+    "\317\262\361\357";
+#define P193 (char*)PP_193
+static const char PP_194[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\353\354\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\356\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P194 (char*)PP_194
+static const char PP_195[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\252\000\000\000\000\251\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\254\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P195 (char*)PP_195
+static const char PP_196[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\366\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\257\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P196 (char*)PP_196
+static const char PP_197[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\374\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P197 (char*)PP_197
+static const char PP_198[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\000\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\000\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\044\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P198 (char*)PP_198
+static const char PP_199[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\176\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P199 (char*)PP_199
+static const char PP_200[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\000\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\000\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P200 (char*)PP_200
+static const char PP_201[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\000\000\000\247\000\000\000\000\000\255\000\000\260\000\000\000"
+    "\000\000\000\267\000\000\000\000\000\000\000\000\000\301\302\303\304\305"
+    "\306\000\000\311\000\313\000\315\316\317\320\000\000\323\324\325\326\000"
+    "\330\000\332\333\334\335\336\337\000\341\342\343\344\345\346\000\000\351"
+    "\000\353\000\355\356\357\360\000\000\363\364\365\366\000\370\000\372\373"
+    "\374\375\376\000";
+#define P201 (char*)PP_201
+static const char PP_202[257] =
+    "\300\340\000\000\241\261\000\000\000\000\000\000\310\350\000\000\251\271"
+    "\242\262\000\000\314\354\312\352\000\000\000\000\000\000\000\000\243\263"
+    "\000\000\000\000\245\265\244\264\000\000\307\347\000\000\000\000\000\000"
+    "\246\266\377\000\000\250\270\000\000\000\000\000\000\000\000\321\361\000"
+    "\000\000\257\277\322\362\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\252\272\000\000\000\000\253\273\327\367\256\276"
+    "\000\000\000\000\000\000\331\371\000\000\000\000\000\000\000\000\000\254"
+    "\274\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P202 (char*)PP_202
+static const char PP_203[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\275\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P203 (char*)PP_203
+static const char PP_204[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P204 (char*)PP_204
+static const char PP_205[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\000"
+    "\000\243\000\000\000\247\000\251\000\000\000\255\256\000\000\000\000\000"
+    "\000\000\266\000\000\000\000\000\000\000\000\000\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\000\321\322\323\324\325\326\000"
+    "\330\331\332\333\334\335\000\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\000\361\362\363\364\365\366\000\370\371\372\373"
+    "\374\375\000\377";
+#define P205 (char*)PP_205
+static const char PP_206[257] =
+    "\000\000\000\000\000\000\000\000\000\000\244\245\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\262\263\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\320\360\336\376\257\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P206 (char*)PP_206
+static const char PP_207[257] =
+    "\000\000\241\242\000\000\000\000\000\000\246\253\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\260\261\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\264\265\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\267\271\000\000"
+    "\000\000\000\000\000\000\273\277\000\000\000\000\000\000\000\000\327\367"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\250\270\252\272\275\276\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\254\274\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P207 (char*)PP_207
+static const char PP_208[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\241\242\243\244\245\246\247\250\251\252\253"
+    "\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275"
+    "\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P208 (char*)PP_208
+static const char PP_209[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\244\000\246\247\000\277\000\253\254\255\256\000\260\261\262\000"
+    "\000\000\266\267\000\000\000\273\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P209 (char*)PP_209
+static const char PP_210[257] =
+    "\000\263\000\000\000\000\000\000\000\000\000\000\000\000\000\000\341\342"
+    "\367\347\344\345\366\372\351\352\353\354\355\356\357\360\362\363\364\365"
+    "\346\350\343\376\373\375\377\371\370\374\340\361\301\302\327\307\304\305"
+    "\326\332\311\312\313\314\315\316\317\320\322\323\324\325\306\310\303\336"
+    "\333\335\337\331\330\334\300\321\000\243\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\203\201\000\000\000\000\000\000\220\200\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\214\212"
+    "\000\000\216\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\265\245\000\000\000\000\000\000"
+    "\000\000\000\000\242\241\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P210 (char*)PP_210
+static const char PP_211[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\201\000"
+    "\000\000\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\230\000\000\000\000\000\000\000\000\200\000"
+    "\000\202\000\203\000\000\000\000\000\000\000\204\000\000\000\000\205\000"
+    "\000\000\000\000\206\000\000\000\210\207\211\000\212\000\000\215\217\216"
+    "\220\221\000\222\224\225\000\226\000\227\231\000\232\233\000\235\234\236"
+    "\237\000\000\000";
+#define P211 (char*)PP_211
+static const char PP_212[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\273\000\000\000\277\000\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\260\261\262\263\264\265\266\267\270\271\245\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\364\000\000\000\000"
+    "\363\000\000\000\000\000\000\000\365\000\371\000\000\000\000\000\000\000"
+    "\000\372\000\000\000\000\000\000\376\000\000\000\000\000\000\000\000\000"
+    "\000\000\367\000\000\000\000\000\000\000\000\000\000\370\000\000\000\000"
+    "\000\000\000\000\000\000\213\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\377\000\000\366\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P212 (char*)PP_212
+static const char PP_213[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\223\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P213 (char*)PP_213
+static const char PP_214[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\300\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P214 (char*)PP_214
+static const char PP_215[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\000"
+    "\000\243\000\000\000\244\254\251\000\307\302\000\250\000\241\000\000\000"
+    "\000\000\246\000\000\000\000\310\000\000\000\000\000\347\000\000\200\000"
+    "\000\000\000\203\000\000\000\352\000\000\000\000\000\356\357\315\205\000"
+    "\000\000\362\000\206\370\000\247\000\207\000\000\212\000\000\000\000\216"
+    "\000\000\000\222\000\000\000\000\000\227\231\233\232\326\000\000\234\000"
+    "\237\371\000\000";
+#define P215 (char*)PP_215
+static const char PP_216[257] =
+    "\201\202\000\000\204\210\214\215\000\000\000\000\211\213\221\223\000\000"
+    "\224\225\000\000\226\230\242\253\235\236\000\000\000\000\000\000\376\256"
+    "\000\000\000\000\000\000\261\264\000\000\257\260\000\000\000\000\000\000"
+    "\265\372\000\275\276\271\272\273\274\000\000\374\270\301\304\277\300\305"
+    "\313\000\000\000\317\330\000\000\314\316\000\000\331\332\337\340\333\336"
+    "\345\346\000\000\000\000\341\344\000\000\350\351\000\000\000\000\355\360"
+    "\000\000\361\363\364\365\366\367\000\000\000\000\000\217\220\373\375\353"
+    "\354\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P216 (char*)PP_216
+static const char PP_217[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P217 (char*)PP_217
+static const char PP_218[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\342\000\322\323\343\000\240\000\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\334\335\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P218 (char*)PP_218
+static const char PP_219[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\252\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P219 (char*)PP_219
+static const char PP_220[257] =
+    "\000\000\266\000\000\000\306\000\000\000\000\000\000\000\000\000\000\267"
+    "\000\000\000\000\000\000\000\000\303\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\255\000\000\000\262\263\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P220 (char*)PP_220
+static const char PP_221[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\327\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P221 (char*)PP_221
+static const char PP_222[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\301"
+    "\242\243\000\000\000\244\254\331\273\307\302\000\250\370\241\261\000\000"
+    "\253\265\246\341\374\000\274\337\000\000\000\300\313\347\345\314\200\201"
+    "\336\202\351\203\375\372\355\352\353\354\000\204\361\356\357\315\205\000"
+    "\257\364\362\363\206\000\000\247\210\207\211\213\212\214\376\215\217\216"
+    "\220\221\223\222\224\225\000\226\230\227\231\233\232\326\277\235\234\236"
+    "\237\000\000\000";
+#define P222 (char*)PP_222
+static const char PP_223[257] =
+    "\000\000\000\000\000\000\306\346\000\000\000\000\310\350\000\000\320\360"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\365\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\316\317\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\251\271\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\256"
+    "\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\304\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P223 (char*)PP_223
+static const char PP_224[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\366\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\373\000\367\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P224 (char*)PP_224
+static const char PP_225[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\275\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\371\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P225 (char*)PP_225
+static const char PP_226[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\340\321\000\000\000\324\325\342\000\322\323\343\000\240\000\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\344\000\000\000\000\000"
+    "\000\000\000\334\335\000\000\000\000\000\000\000\000\000\332\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\333\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P226 (char*)PP_226
+static const char PP_227[257] =
+    "\000\000\266\000\000\000\264\000\000\000\000\000\000\000\000\270\000\267"
+    "\000\000\000\000\000\000\000\000\303\000\000\000\260\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\272\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\255\000\000\000\262\263\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P227 (char*)PP_227
+static const char PP_228[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\330";
+#define P228 (char*)PP_228
+static const char PP_229[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\000"
+    "\000\222\000\264\233\254\214\251\000\307\302\377\250\000\256\261\202\204"
+    "\000\000\000\257\000\201\000\310\000\227\000\000\000\000\000\000\200\000"
+    "\000\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\205\000"
+    "\000\000\000\000\206\000\000\247\210\000\211\000\212\000\000\215\217\216"
+    "\220\221\000\000\224\225\000\000\000\000\231\000\232\326\000\235\000\236"
+    "\237\000\000\000";
+#define P229 (char*)PP_229
+static const char PP_230[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\317\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P230 (char*)PP_230
+static const char PP_231[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\213\207\315\000\316\327\330\000\331\000\332\337"
+    "\375\260\265\241\242\266\267\270\243\271\272\244\273\301\245\303\246\304"
+    "\000\252\306\313\274\314\276\277\253\275\300\333\334\335\376\341\342\347"
+    "\344\345\372\350\365\351\353\354\355\356\352\357\360\362\367\363\364\371"
+    "\346\370\343\366\373\374\336\340\361\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P231 (char*)PP_231
+static const char PP_232[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\000\321\000\000\324\325\000\000\322\323\000\000\240\000\226\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\230\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\234\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P232 (char*)PP_232
+static const char PP_233[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P233 (char*)PP_233
+static const char PP_234[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\255\000\000\000\262\263\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P234 (char*)PP_234
+static const char PP_235[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\000"
+    "\000\202\000\203\000\000\000\000\000\000\000\204\000\000\000\000\205\000"
+    "\000\000\000\000\206\000\000\000\210\207\211\213\212\214\000\215\217\216"
+    "\220\221\223\222\224\225\000\226\230\227\231\233\232\000\000\235\234\236"
+    "\237\000\000\000";
+#define P235 (char*)PP_235
+static const char PP_236[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\331\333\332\337"
+    "\317\315\316\314\313\335\000\334\306\000\000\330\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\300\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P236 (char*)PP_236
+static const char PP_237[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\000\000\322\323\301\000\000\000\000\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\246\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P237 (char*)PP_237
+static const char PP_238[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\302\303\304\305\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P238 (char*)PP_238
+static const char PP_239[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\201\000\000\000\000"
+    "\000\000\000\000\000\000\326\327\000\000\000\000\000\000\000\000\000\310"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\307\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P239 (char*)PP_239
+static const char PP_240[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\301"
+    "\242\243\000\264\000\244\254\251\273\307\302\000\250\370\241\261\000\000"
+    "\253\265\246\341\374\000\274\310\000\000\000\300\313\347\345\314\200\201"
+    "\256\202\351\203\346\350\355\352\353\354\334\204\361\356\357\315\205\000"
+    "\257\364\362\363\206\240\336\247\210\207\211\213\212\214\276\215\217\216"
+    "\220\221\223\222\224\225\335\226\230\227\231\233\232\326\277\235\234\236"
+    "\237\340\337\330";
+#define P240 (char*)PP_240
+static const char PP_241[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\365\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\316\317\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\331\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\304\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P241 (char*)PP_241
+static const char PP_242[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\366\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\371\372\373\376\367\375\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P242 (char*)PP_242
+static const char PP_243[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\275\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\271\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P243 (char*)PP_243
+static const char PP_244[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\342\000\322\323\343\000\000\000\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\344\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\332\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\333\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P244 (char*)PP_244
+static const char PP_245[257] =
+    "\000\000\266\000\000\000\306\000\000\000\000\000\000\000\000\270\000\267"
+    "\000\000\000\000\000\000\000\000\303\000\000\000\260\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\272\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\305\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\255\000\000\000\262\263\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P245 (char*)PP_245
+static const char PP_246[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\360";
+#define P246 (char*)PP_246
+static const char PP_247[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\301"
+    "\242\243\000\264\000\244\254\251\273\307\302\000\250\370\241\261\000\000"
+    "\253\265\246\341\374\000\274\310\000\000\000\300\313\347\345\314\200\201"
+    "\000\202\351\203\346\350\355\352\353\354\000\204\361\356\357\315\205\000"
+    "\000\364\362\363\206\000\000\247\210\207\211\213\212\214\000\215\217\216"
+    "\220\221\223\222\224\225\000\226\230\227\231\233\232\326\000\235\234\236"
+    "\237\000\000\330";
+#define P247 (char*)PP_247
+static const char PP_248[257] =
+    "\000\000\256\276\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\365\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\316\317\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\331\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\304\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P248 (char*)PP_248
+static const char PP_249[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\257\277\336\337\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\366\377\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\371\372\373\376\367\375\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P249 (char*)PP_249
+static const char PP_250[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\342\000\322\323\343\000\240\340\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\344\000\000\000\000\000"
+    "\000\000\000\334\335\000\000\000\000\000\000\000\000\000\332\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\333\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P250 (char*)PP_250
+static const char PP_251[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\312\301"
+    "\242\243\000\264\000\244\254\251\273\307\302\000\250\370\241\261\000\000"
+    "\253\265\246\341\374\000\274\310\000\000\000\300\313\347\345\314\200\201"
+    "\256\202\351\203\346\350\355\352\353\354\000\204\361\356\357\315\205\000"
+    "\257\364\362\363\206\000\000\247\210\207\211\213\212\214\276\215\217\216"
+    "\220\221\223\222\224\225\000\226\230\227\231\233\232\326\277\235\234\236"
+    "\237\000\000\330";
+#define P251 (char*)PP_251
+static const char PP_252[257] =
+    "\000\336\337\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P252 (char*)PP_252
+static const char PP_253[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\000\000\000\000\000\373\000\200\000\000\372\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\201\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P253 (char*)PP_253
+static const char PP_254[257] =
+    "\000\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261"
+    "\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\222\322\323\224\225"
+    "\226\227\330\331\332\000\000\000\000\337\340\341\342\343\344\345\346\223"
+    "\203\204\205\206\207\217\000\357\360\361\362\363\364\365\366\367\370\371"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P254 (char*)PP_254
+static const char PP_255[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\334\000\000\000\000\000\000"
+    "\000\335\336\000\000\000\235\236\000\000\215\216\000\000\000\000\221\000"
+    "\000\000\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\333\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P255 (char*)PP_255
+static const char PP_256[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\356\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P256 (char*)PP_256
+static const char PP_257[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\332\333\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\334\335\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\316\317\000\000\000\000\000\000"
+    "\000\000\000\000\336\337\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\331\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\304\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P257 (char*)PP_257
+static const char PP_258[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\320\321\000\000\000\324\325\342\000\322\323\343\000\240\340\245\000"
+    "\000\000\311\000\000\000\000\000\000\000\000\000\344\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P258 (char*)PP_258
+static const char PP_259[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\365\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\360";
+#define P259 (char*)PP_259
+static const char PP_260[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\241\242\000\244\000\000\247\250\000\252\000\000\255\000\000"
+    "\000\000\000\000\264\265\266\267\000\271\272\273\274\275\276\277\000\301"
+    "\302\303\000\305\000\307\000\000\312\313\000\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\000\333\334\335\000\000\340\341\342\343\344\000"
+    "\346\000\350\351\352\353\354\355\000\000\360\361\362\363\364\365\366\367"
+    "\370\371\000\000\374\375\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P260 (char*)PP_260
+static const char PP_261[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\241"
+    "\242\243\250\245\265\247\310\240\343\253\276\000\260\305\000\321\311\314"
+    "\302\235\266\264\313\300\353\273\322\323\324\277\201\202\203\204\205\206"
+    "\341\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\236"
+    "\351\227\230\231\232\233\234\373\325\326\327\330\331\332\361\333\334\335"
+    "\336\337\340\342\344\345\346\347\354\355\356\357\360\237\371\362\363\364"
+    "\366\367\374\375";
+#define P261 (char*)PP_261
+static const char PP_262[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\365\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\350\370\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\352\372\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P262 (char*)PP_262
+static const char PP_263[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\303\317\000\000\000\301\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\306\307\312\316\304\315\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P263 (char*)PP_263
+static const char PP_264[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\261\320\000\000\000\000\251\270\000\252\272\271\000\262\263\267\000"
+    "\000\000\274\000\000\000\000\000\000\000\000\000\275\000\000\000\000\000"
+    "\000\000\000\254\255\000\000\000\000\000\000\000\000\000\244\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P264 (char*)PP_264
+static const char PP_265[257] =
+    "\000\256\257\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P265 (char*)PP_265
+static const char PP_266[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\000\000\000\247\000\251\000\253\254\000\256\000\260\000\000\000"
+    "\000\000\266\267\000\000\000\273\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P266 (char*)PP_266
+static const char PP_267[257] =
+    "\000\250\000\000\000\000\262\000\243\000\000\000\000\000\241\000\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\000\270\000\000\000\000\263\000\274\000"
+    "\000\000\000\000\242\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\201\203\000\000\200\220\245\264\215\235\257\277\000\000\212\232"
+    "\214\234\000\000\000\000\000\000\275\276\000\000\207\211\246\261\210\230"
+    "\000\000\206\231\217\237\216\236\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\252\272\000\000\000\000\000\000\000\000\213\233\000\000\000\000\244\265"
+    "\000\000\000\000\202\255\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P267 (char*)PP_267
+static const char PP_268[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\226\227\000\000\000\221\222\000\000\223\224\204\000\000\000\225\000"
+    "\000\000\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P268 (char*)PP_268
+static const char PP_269[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\271\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P269 (char*)PP_269
+static const char PP_270[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\203\000\000\000\207\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377";
+#define P270 (char*)PP_270
+static const char PP_271[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\232\233\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\201\202\205\206\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P271 (char*)PP_271
+static const char PP_272[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\227\230\000\000\000\220\221\000\000\224\225\226\000\234\235\217\000"
+    "\000\000\214\000\000\000\000\000\000\000\000\000\216\000\000\000\000\000"
+    "\000\000\000\222\223\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P272 (char*)PP_272
+static const char PP_273[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\215\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\210\213\211\212"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P273 (char*)PP_273
+static const char PP_274[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\231\000\000\000\000\000\000\000\200\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P274 (char*)PP_274
+static const char PP_275[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\204\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P275 (char*)PP_275
+static const char PP_276[257] =
+    "\000\236\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P276 (char*)PP_276
+static const char PP_277[257] =
+    "\000\250\200\201\000\000\262\000\000\212\214\000\000\000\000\217\300\301"
+    "\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\000\270\220\203\000\000\263\000\000\232"
+    "\234\000\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\252\272\000\000\000\000\000\000\215\235\000\000\000\000\000\000"
+    "\275\276\000\000\000\000\000\000\000\000\000\000\257\277\241\242\000\000"
+    "\000\000\000\000\000\000\216\236\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\243\274\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245\264"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P277 (char*)PP_277
+static const char PP_278[257] =
+    "\000\000\000\003\000\000\000\007\010\011\012\013\014\015\016\017\020\000"
+    "\000\000\000\000\000\000\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\200\203\242\202\000\000"
+    "\000\000\207\212\243\000\215\220\000\000\000\000\222\225\244\224\000\000"
+    "\000\235\001\000\000\026\000\000\265\270\251\267\000\000\000\000\314\320"
+    "\252\000\327\335\000\000\000\000\337\343\253\342\000\000\000\357\363\000"
+    "\000\375\000\000";
+#define P278 (char*)PP_278
+static const char PP_279[257] =
+    "\000\000\241\250\000\000\000\000\000\000\000\000\000\000\000\000\247\256"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\217\334\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\362\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245\254"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\246\255\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P279 (char*)PP_279
+static const char PP_280[257] =
+    "\260\263\000\262\000\000\000\000\000\261\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\264"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P280 (char*)PP_280
+static const char PP_281[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\204\271"
+    "\201\266\304\312\301\307\302\310\303\311\206\313\300\276\257\273\272\274"
+    "\277\275\205\306\213\321\210\316\211\317\332\325\305\322\315\323\331\324"
+    "\214\326\216\330\221\336\226\344\223\341\377\350\333\345\340\346\360\347"
+    "\227\351\233\355\230\352\231\353\232\354\234\356\002\364\236\361\021\370"
+    "\004\365\005\366\006\367\022\371\023\372\027\376\024\373\025\374\000\000"
+    "\000\000\000\000";
+#define P281 (char*)PP_281
+static const char PP_282[257] =
+    "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\000\104\105\107\110"
+    "\111\112\113\115\116\117\120\122\124\000\125\126\130\131\000\133\000\134"
+    "\136\000\000\000\000\137\000\141\142\000\144\145\147\150\151\152\153\155"
+    "\156\157\160\162\164\000\165\166\170\171\000\173\000\174\176\000\000\000"
+    "\000\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\106\000"
+    "\000\103\000\000\000\000\000\000\000\000\000\000\000\000\000\000\123\000"
+    "\000\000\000\000\132\135\000\000\000\000\000\000\146\000\000\143\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\163\000\000\000\000\000"
+    "\172\175\000\000";
+#define P282 (char*)PP_282
+static const char PP_283[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\121"
+    "\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\127\167\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\114"
+    "\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P283 (char*)PP_283
+static const char PP_284[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\140\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P284 (char*)PP_284
+static const char PP_285[257] =
+    "\000\001\000\003\004\000\000\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\000\025\026\027\030\000\032\033\034\035\000\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\300\301\302\303\000\000"
+    "\000\000\310\311\312\000\314\315\000\000\000\000\322\323\324\240\000\000"
+    "\000\331\332\000\000\335\000\000\340\341\342\343\000\000\000\000\350\351"
+    "\352\000\354\355\000\000\000\000\362\363\364\365\000\000\000\371\372\000"
+    "\000\375\000\000";
+#define P285 (char*)PP_285
+static const char PP_286[257] =
+    "\000\000\305\345\000\000\000\000\000\000\000\000\000\000\000\000\320\360"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\316\356\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\235\373\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\264\275"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\277\337\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000";
+#define P286 (char*)PP_286
+static const char PP_287[257] =
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
+    "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\200\325"
+    "\304\344\204\244\205\245\206\246\006\347\207\247\201\241\202\242\002\306"
+    "\005\307\203\243\211\251\313\353\210\250\212\252\213\253\214\254\215\255"
+    "\216\256\233\357\230\270\232\367\231\366\217\257\220\260\221\261\222\262"
+    "\223\265\225\276\226\266\227\267\263\336\224\376\236\370\234\374\272\321"
+    "\273\327\274\330\377\346\271\361\237\317\036\334\024\326\031\333\000\000"
+    "\000\000\000\000";
+#define P287 (char*)PP_287
+
+static const Encoder encoder_00 = { //windows-1251
+    {
+        P01, P00, P00, P00, P02, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P03, P04, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_01 = { //KOI8-U
+    {
+        P05, P00, P00, P00, P06, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P07, P08, P00, P09, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_02 = { //IBM866
+    {
+        P10, P00, P00, P00, P11, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P12, P13, P00, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_03 = { //MacCyrillic
+    {
+        P15, P16, P00, P00, P17, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P18, P19, P20, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_04 = { //ISO-8859-5
+    {
+        P21, P00, P00, P00, P22, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P23, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_05 = { //windows-1252
+    {
+        P24, P25, P26, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P27, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_06 = { //reserved3
+    {
+        P29, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_07 = { //windows-1250
+    {
+        P30, P31, P32, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P27, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_08 = { //iso-2
+    {
+        P33, P34, P35, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_09 = { //yandex
+    {
+        P36, P37, P38, P39, P40, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P41, P42, P00,
+        P43, P44, P00, P00, P45, P00, P00, P00,
+        P00, P00, P00, P00, P46, P00, P00, P00,
+        P00, P00, P47, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P48, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P49, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P50, P00, P00, P00, P51,
+    },
+    defchars[1],
+    P00,
+};
+
+static const Encoder encoder_12 = { //IBM855
+    {
+        P52, P00, P00, P00, P53, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P54, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_14 = { //unknownplane
+    {
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P56, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_15 = { //windows-1251-k
+    {
+        P57, P00, P00, P00, P58, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P03, P04, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_16 = { //windows-1251-t
+    {
+        P57, P00, P00, P00, P59, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P03, P04, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_17 = { //armscii
+    {
+        P60, P00, P00, P00, P00, P61, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P62, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_18 = { //geo-ita
+    {
+        P63, P64, P26, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P65, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P66, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_19 = { //geo-ps
+    {
+        P67, P64, P26, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P68, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P66, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_20 = { //iso-8859-3
+    {
+        P69, P70, P71, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_21 = { //iso-8859-4
+    {
+        P72, P73, P74, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_22 = { //iso-8859-6
+    {
+        P75, P00, P00, P00, P00, P00, P76, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P77, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_23 = { //iso-8859-7
+    {
+        P78, P00, P00, P79, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P80, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_24 = { //iso-8859-8
+    {
+        P81, P00, P00, P00, P00, P82, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P83, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_25 = { //iso-8859-9
+    {
+        P84, P85, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_26 = { //iso-8859-13
+    {
+        P86, P87, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P88, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_27 = { //iso-8859-15
+    {
+        P89, P90, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P91, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_28 = { //iso-8859-16
+    {
+        P92, P93, P94, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P95, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_29 = { //windows-1253
+    {
+        P96, P97, P00, P98, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P99, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_30 = { //windows-1254
+    {
+        P100, P101, P26, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P27, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_31 = { //windows-1255
+    {
+        P102, P97, P26, P00, P00, P103, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P104, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_32 = { //windows-1256
+    {
+        P105, P106, P107, P00, P00, P00, P108, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P109, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_33 = { //windows-1257
+    {
+        P110, P87, P111, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P27, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_34 = { //CP1046
+    {
+        P112, P00, P00, P00, P00, P00, P113, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P114, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P115, P00, P00, P00, P00, P00, P116, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_35 = { //CP1124
+    {
+        P21, P00, P00, P00, P117, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P23, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_36 = { //CP1125
+    {
+        P118, P00, P00, P00, P119, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P12, P120, P00, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_37 = { //CP1129
+    {
+        P121, P122, P00, P123, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P124, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_38 = { //CP1131
+    {
+        P125, P00, P00, P00, P126, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P127, P00, P00, P128, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_39 = { //CP1133
+    {
+        P129, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P130, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P131, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_40 = { //CP1161
+    {
+        P132, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P133, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P134, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_41 = { //CP1162
+    {
+        P135, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P136, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P137, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_42 = { //CP1163
+    {
+        P138, P122, P00, P123, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P139, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_43 = { //CP1258
+    {
+        P140, P141, P26, P123, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P142, P28, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_44 = { //CP437
+    {
+        P143, P144, P00, P145, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P146, P00, P147, P148, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_45 = { //CP737
+    {
+        P149, P00, P00, P150, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P151, P00, P152, P00, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_46 = { //CP775
+    {
+        P153, P154, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P155, P00, P156, P00, P00, P157, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_47 = { //CP850
+    {
+        P158, P159, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P160, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_48 = { //CP852
+    {
+        P161, P162, P163, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_49 = { //CP853
+    {
+        P164, P165, P166, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P167, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_50 = { //CP856
+    {
+        P168, P00, P00, P00, P00, P169, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P160, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_51 = { //CP857
+    {
+        P170, P171, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_52 = { //CP858
+    {
+        P158, P144, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P172, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_53 = { //CP860
+    {
+        P173, P00, P00, P145, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P146, P00, P147, P174, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_54 = { //CP861
+    {
+        P175, P144, P00, P145, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P146, P00, P147, P148, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_55 = { //CP862
+    {
+        P176, P144, P00, P145, P00, P169, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P146, P00, P147, P148, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_56 = { //CP863
+    {
+        P177, P144, P00, P145, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P178, P00, P147, P148, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_57 = { //CP864
+    {
+        P179, P00, P00, P180, P00, P00, P181, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P182, P00, P00, P183, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P184, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_58 = { //CP865
+    {
+        P185, P144, P00, P145, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P146, P00, P147, P148, P00, P14, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_59 = { //CP869
+    {
+        P186, P00, P00, P187, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P188, P00, P00, P00, P00, P55, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_60 = { //CP874
+    {
+        P189, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P136, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P137, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_61 = { //CP922
+    {
+        P190, P191, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P192, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_62 = { //HP_ROMAN8
+    {
+        P193, P194, P195, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P196, P00, P00, P00, P00, P197, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_63 = { //ISO646_CN
+    {
+        P198, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P199, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_64 = { //ISO646_JP
+    {
+        P200, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P199, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_65 = { //ISO8859_10
+    {
+        P201, P202, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P203, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_66 = { //ISO8859_11
+    {
+        P204, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P136, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_67 = { //ISO8859_14
+    {
+        P205, P206, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P207, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_68 = { //JISX0201
+    {
+        P200, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P199, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P208,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_69 = { //KOI8_T
+    {
+        P209, P00, P00, P00, P210, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P66, P04, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_70 = { //MAC_ARABIC
+    {
+        P211, P00, P00, P00, P00, P00, P212, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P213, P00, P00, P00, P00, P00, P00, P214,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_71 = { //MAC_CENTRALEUROPE
+    {
+        P215, P216, P217, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P218, P219, P220, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_72 = { //MAC_CROATIAN
+    {
+        P222, P223, P224, P225, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P226, P219, P227, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P228, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_73 = { //MAC_GREEK
+    {
+        P229, P230, P00, P231, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P232, P233, P234, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_74 = { //MAC_HEBREW
+    {
+        P235, P00, P00, P00, P00, P236, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P237, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P238, P00, P00, P239, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_75 = { //MAC_ICELAND
+    {
+        P240, P241, P242, P243, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P244, P219, P245, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P246, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_76 = { //MAC_ROMANIA
+    {
+        P247, P248, P249, P243, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P250, P219, P245, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P246, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_77 = { //MAC_ROMAN
+    {
+        P251, P241, P242, P243, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P250, P219, P245, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P246, P00, P00, P252, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_78 = { //MAC_THAI
+    {
+        P253, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P254, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P255, P256, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_79 = { //MAC_TURKISH
+    {
+        P251, P257, P242, P243, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P258, P219, P245, P00, P00, P221, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P259, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_80 = { //reserved2
+    {
+        P15, P16, P00, P00, P17, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P18, P19, P20, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_81 = { //MULELAO
+    {
+        P204, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P260, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_82 = { //NEXTSTEP
+    {
+        P261, P262, P263, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P264, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P265, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_83 = { //PT154
+    {
+        P266, P00, P00, P00, P267, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P268, P269, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_84 = { //RISCOS-LATIN1
+    {
+        P270, P271, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P272, P273, P274, P00, P00, P275, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P276, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_85 = { //RK1048
+    {
+        P01, P00, P00, P00, P277, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P03, P04, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_86 = { //TCVN
+    {
+        P278, P279, P00, P280, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P281, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_87 = { //TDS565
+    {
+        P282, P283, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P284, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_88 = { //TIS620
+    {
+        P29, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P136, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+static const Encoder encoder_89 = { //VISCII
+    {
+        P285, P286, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P287, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+        P00, P00, P00, P00, P00, P00, P00, P00,
+    },
+    defchars[0],
+    P00,
+};
+
+const Encoder* const NCodepagePrivate::TCodePageData::EncodeTo[] = {
+    &encoder_00,
+    &encoder_01,
+    &encoder_02,
+    &encoder_03,
+    &encoder_04,
+    &encoder_05,
+    &encoder_06,
+    &encoder_07,
+    &encoder_08,
+    &encoder_09,
+    nullptr,
+    nullptr,
+    &encoder_12,
+    nullptr,
+    &encoder_14,
+    &encoder_15,
+    &encoder_16,
+    &encoder_17,
+    &encoder_18,
+    &encoder_19,
+    &encoder_20,
+    &encoder_21,
+    &encoder_22,
+    &encoder_23,
+    &encoder_24,
+    &encoder_25,
+    &encoder_26,
+    &encoder_27,
+    &encoder_28,
+    &encoder_29,
+    &encoder_30,
+    &encoder_31,
+    &encoder_32,
+    &encoder_33,
+    &encoder_34,
+    &encoder_35,
+    &encoder_36,
+    &encoder_37,
+    &encoder_38,
+    &encoder_39,
+    &encoder_40,
+    &encoder_41,
+    &encoder_42,
+    &encoder_43,
+    &encoder_44,
+    &encoder_45,
+    &encoder_46,
+    &encoder_47,
+    &encoder_48,
+    &encoder_49,
+    &encoder_50,
+    &encoder_51,
+    &encoder_52,
+    &encoder_53,
+    &encoder_54,
+    &encoder_55,
+    &encoder_56,
+    &encoder_57,
+    &encoder_58,
+    &encoder_59,
+    &encoder_60,
+    &encoder_61,
+    &encoder_62,
+    &encoder_63,
+    &encoder_64,
+    &encoder_65,
+    &encoder_66,
+    &encoder_67,
+    &encoder_68,
+    &encoder_69,
+    &encoder_70,
+    &encoder_71,
+    &encoder_72,
+    &encoder_73,
+    &encoder_74,
+    &encoder_75,
+    &encoder_76,
+    &encoder_77,
+    &encoder_78,
+    &encoder_79,
+    &encoder_80,
+    &encoder_81,
+    &encoder_82,
+    &encoder_83,
+    &encoder_84,
+    &encoder_85,
+    &encoder_86,
+    &encoder_87,
+    &encoder_88,
+    &encoder_89,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+};
+
+const struct Encoder &WideCharToYandex = encoder_09;
+
+const Recoder NCodepagePrivate::TCodePageData::rcdr_to_yandex[] = {
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\303\047\343\042\056\052\052\044\052\246\042\246\312\246\246"
+    "\266\047\047\042\042\052\055\055\260\260\266\042\266\352\266\266\240\254"
+    "\274\246\044\216\260\247\250\260\256\042\075\217\260\257\260\075\255\275"
+    "\236\266\052\055\270\267\276\042\266\246\266\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\075\260\075\075\075\075\075\240\075\260\062\055\075\260\260"
+    "\260\270\276\260\275\277\260\260\260\260\260\236\260\260\260\260\260\250"
+    "\256\260\255\257\260\260\260\260\260\216\260\260\376\340\341\366\344\345"
+    "\364\343\365\350\351\352\353\354\355\356\357\377\360\361\362\363\346\342"
+    "\374\373\347\370\375\371\367\372\336\300\301\326\304\305\324\303\325\310"
+    "\311\312\313\314\315\316\317\337\320\321\322\323\306\302\334\333\307\330"
+    "\335\331\327\332"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341"
+    "\342\343\344\345\346\347\350\351\352\353\354\355\356\357\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\375\376\377\250\270\256\276\257\277\254\274\260\075\055\075"
+    "\267\044\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\052\260"
+    "\216\044\247\052\052\255\260\260\260\246\266\075\303\343\075\075\075\075"
+    "\275\266\236\246\256\276\257\277\246\266\246\266\266\246\075\075\266\075"
+    "\075\042\042\056\240\246\266\312\352\266\055\055\042\042\047\047\075\042"
+    "\254\274\246\266\267\250\270\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\044"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\250"
+    "\246\303\256\246\255\257\246\246\246\246\312\217\254\246\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\375\376\377\267\270\266\343\276\266\275\277\266\266\266\266"
+    "\352\247\274\266"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\266\042\056\052\052\266\052\123\042\246\260\132\260"
+    "\260\047\047\042\042\052\055\055\140\260\163\042\266\260\172\131\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\246\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\131\246\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\266\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\266\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\260\042\056\052\052\260\052\123\042\243\124\132\245"
+    "\260\047\047\042\042\052\055\055\260\260\163\042\263\164\172\265\240\055"
+    "\140\207\044\204\260\247\140\260\123\042\075\217\260\244\260\075\140\227"
+    "\140\266\052\055\140\224\163\042\114\140\154\264\122\101\101\101\201\114"
+    "\205\103\103\105\206\105\105\111\111\104\246\241\116\242\117\117\202\075"
+    "\122\125\125\125\203\131\124\220\162\141\211\141\221\154\225\212\143\214"
+    "\226\230\145\151\231\144\266\261\156\262\233\157\222\075\162\165\165\165"
+    "\223\171\164\140"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\204"
+    "\140\207\044\114\243\247\140\123\123\124\245\217\132\244\260\224\140\227"
+    "\140\154\263\055\140\163\163\164\265\140\172\264\122\101\101\101\201\114"
+    "\205\103\103\105\206\105\105\111\111\104\246\241\116\242\117\117\202\075"
+    "\122\125\125\125\203\131\124\220\162\141\211\141\221\154\225\212\143\214"
+    "\226\230\145\151\231\144\266\261\156\262\233\157\222\075\162\165\165\165"
+    "\223\171\164\140"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\266\246\343\303\270\250\276\256\266\246\275\255\277\257\266\246"
+    "\266\246\266\246\266\246\352\312\274\254\266\246\376\336\372\332\340\300"
+    "\341\301\366\326\344\304\345\305\364\324\343\303\042\042\260\260\260\260"
+    "\260\365\325\350\310\260\260\260\260\351\311\260\260\260\260\260\260\260"
+    "\352\312\260\260\260\260\260\260\260\044\353\313\354\314\355\315\356\316"
+    "\357\260\260\260\260\317\377\260\337\360\320\361\321\362\322\363\323\346"
+    "\306\342\302\374\334\267\217\373\333\347\307\370\330\375\335\371\331\367"
+    "\327\247\260\240"},},
+{{},},
+{{"\000\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\246\047\266\042\056\052\052\044\052\246\042\246\246\246\246"
+    "\266\047\047\042\042\052\055\055\032\260\266\042\266\266\266\266\240\254"
+    "\274\246\044\246\260\247\250\260\256\042\075\217\260\257\260\075\255\275"
+    "\266\266\052\055\270\267\276\042\266\246\266\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\303\047\343\042\056\052\052\044\052\246\042\246\246\246\246"
+    "\266\047\047\042\042\052\055\055\032\260\266\042\266\266\266\266\240\254"
+    "\274\246\044\216\260\247\250\260\256\042\075\217\260\257\260\075\255\275"
+    "\236\266\052\055\270\267\276\042\266\246\266\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\077"
+    "\266\056\051\050\042\042\055\056\052\054\055\055\056\052\052\052\246\266"
+    "\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266"
+    "\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266"
+    "\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266"
+    "\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266\246\266"
+    "\246\266\052\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\047\266\042\056\052\052\266\052\123\042\246\032\032\032"
+    "\032\047\047\042\042\052\055\055\140\260\163\042\266\032\032\131\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\212\213\214"
+    "\215\230\151\151\231\232\266\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\266\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\047\266\042\056\052\052\266\052\123\042\246\032\032\032"
+    "\032\047\047\042\042\052\055\055\140\260\163\042\266\032\032\131\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\266\212\213\214"
+    "\215\230\151\151\231\232\266\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\266\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\246"
+    "\140\044\044\260\110\247\140\111\123\107\112\217\260\244\260\266\062\063"
+    "\140\266\150\055\140\266\163\147\152\061\260\264\101\101\101\260\201\103"
+    "\103\103\105\105\105\105\111\111\111\111\260\116\117\242\117\107\202\075"
+    "\107\125\125\125\203\125\123\220\210\141\211\260\221\143\143\212\213\214"
+    "\215\230\151\151\231\232\260\156\157\262\233\147\222\075\147\234\165\235"
+    "\223\165\163\140"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\204"
+    "\266\122\044\111\114\247\140\123\105\107\246\217\132\140\260\224\140\162"
+    "\140\151\154\055\140\163\145\147\266\246\172\266\101\101\101\101\201\101"
+    "\246\111\103\105\206\105\105\111\111\111\246\116\117\113\117\117\202\075"
+    "\246\125\125\125\203\125\125\220\141\141\211\141\221\141\266\151\143\214"
+    "\226\230\145\151\231\151\266\156\157\153\233\157\222\075\266\165\165\235"
+    "\223\165\165\140"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\214\211\260\210\260\212\215\230\213\232\231\260\260\260"
+    "\260\260\260\233\260\260\235\234\260\260\032\032\032\032\032\032\240\260"
+    "\260\260\044\260\260\260\260\260\260\260\056\260\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\056\260\260\260\056\260\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\260\260\260\260\260\055\237\237\237\237\237\237\237\237\237"
+    "\237\200\200\200\200\200\200\200\200\260\260\260\260\260\260\260\260\260"
+    "\266\044\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\047"
+    "\047\044\044\044\260\247\140\260\055\042\075\217\260\055\260\075\062\063"
+    "\140\140\246\055\246\246\246\042\246\061\246\246\266\246\246\246\246\246"
+    "\246\246\246\246\246\246\246\246\246\246\246\246\260\246\246\246\246\246"
+    "\246\246\246\246\266\266\266\266\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\260"
+    "\044\044\044\044\260\247\140\260\075\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\075\042\061\061\063\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\052\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\260"
+    "\260\032\032\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\107\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\111\123\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\147\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\266\163\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\042"
+    "\044\044\044\042\260\247\246\260\122\042\075\217\260\246\260\075\062\063"
+    "\042\266\052\055\266\061\162\042\061\061\063\266\204\111\101\205\201\101"
+    "\206\105\103\105\245\105\107\113\111\114\123\241\116\242\117\117\202\075"
+    "\125\207\243\125\203\244\132\220\224\151\141\225\221\141\226\145\143\214"
+    "\265\145\147\153\151\154\163\261\156\262\157\157\222\075\165\227\263\165"
+    "\223\264\172\047"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\052"
+    "\044\044\044\044\123\247\163\260\141\042\075\217\260\140\260\075\062\063"
+    "\132\266\052\055\172\061\157\042\246\266\131\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\246\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\131\246\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\266\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\266\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\204"
+    "\224\207\044\042\123\247\163\260\123\042\245\217\265\244\260\075\103\227"
+    "\132\042\052\055\172\143\163\042\246\266\131\264\101\101\101\101\201\205"
+    "\246\103\105\105\105\105\111\111\111\111\246\241\117\242\117\117\202\243"
+    "\125\125\125\125\203\206\124\220\210\141\211\141\221\225\266\212\213\214"
+    "\215\230\151\151\231\232\266\261\157\262\233\157\222\263\165\234\165\235"
+    "\223\226\164\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\266\042\056\052\052\260\052\260\042\260\260\260\260"
+    "\260\047\047\042\042\052\055\055\260\260\260\042\260\260\260\260\240\140"
+    "\246\044\044\044\260\247\140\260\260\042\075\217\260\055\260\075\062\063"
+    "\140\266\052\055\246\246\246\042\246\061\246\246\266\246\246\246\246\246"
+    "\246\246\246\246\246\246\246\246\246\246\246\246\260\246\246\246\246\246"
+    "\246\246\246\246\266\266\266\266\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\266\042\056\052\052\266\052\123\042\246\260\260\260"
+    "\260\047\047\042\042\052\055\055\140\260\163\042\266\260\260\131\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\107\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\111\123\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\147\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\266\163\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\266\042\056\052\052\266\052\260\042\260\260\260\260"
+    "\260\047\047\042\042\052\055\055\140\260\260\042\260\260\260\260\240\052"
+    "\044\044\044\044\260\247\140\260\075\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\075\042\061\061\063\052\200\200\200\200\200\200"
+    "\200\200\200\200\260\200\200\200\055\200\052\200\200\052\237\237\237\052"
+    "\052\260\260\260\260\260\260\260\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\260"
+    "\260\032\032\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\237\047\266\042\056\052\052\266\052\237\042\246\237\237\237"
+    "\237\047\047\042\042\052\055\055\237\260\237\042\266\032\032\237\240\056"
+    "\044\044\044\044\260\247\140\260\237\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\056\042\061\061\063\056\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\075"
+    "\237\237\237\237\055\237\237\237\210\237\211\237\237\237\237\212\213\214"
+    "\215\230\237\237\231\232\200\200\200\200\233\200\200\075\200\234\200\235"
+    "\223\032\032\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\260\042\056\052\052\260\052\260\042\260\140\055\140"
+    "\260\047\047\042\042\052\055\055\260\260\260\042\260\140\140\260\240\260"
+    "\044\044\044\260\260\247\246\260\122\042\075\217\260\246\260\075\062\063"
+    "\140\266\052\055\266\061\162\042\061\061\063\266\204\111\101\205\201\101"
+    "\206\105\103\105\245\105\107\113\111\114\123\241\116\242\117\117\202\075"
+    "\125\207\243\125\203\244\132\220\224\151\141\225\221\141\226\145\143\214"
+    "\265\145\147\153\151\154\163\261\156\262\157\157\222\075\165\227\263\165"
+    "\223\264\172\140"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\237\075\075\077\077\077\077\237\032\260\260\260\260\260\260\260"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\240\077"
+    "\077\077\044\077\237\237\237\237\237\237\056\217\237\237\071\071\071\071"
+    "\071\071\071\071\071\071\237\056\237\237\237\056\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\055\237\237\237\237\237\237\237\237\237"
+    "\237\200\200\200\200\200\200\200\200\237\237\237\077\237\237\237\237\237"
+    "\237\237\237\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\250"
+    "\246\216\256\246\255\257\246\246\246\246\312\217\254\246\300\301\302\303"
+    "\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325"
+    "\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347"
+    "\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\375\376\377\267\270\266\236\276\266\275\277\266\266\266\266"
+    "\352\247\274\266"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341"
+    "\342\343\344\345\346\347\350\351\352\353\354\355\356\357\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\375\376\377\250\270\216\236\256\276\255\275\257\277\055\075"
+    "\267\044\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\052"
+    "\044\044\044\044\260\247\266\260\141\042\075\217\260\140\260\075\062\063"
+    "\131\266\052\055\246\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\200\111\111\111\246\116\200\242\117\117\202\075"
+    "\246\125\125\125\203\125\200\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\200\151\231\232\266\156\200\262\233\157\222\075\266\234\165\235"
+    "\223\165\044\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341"
+    "\342\343\344\345\346\347\350\351\352\353\354\355\356\357\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\360\361\362\363\364\365\366\367\370\371"
+    "\372\373\374\375\376\377\250\270\256\276\257\277\254\274\255\275\055\044"
+    "\216\236\075\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\260\260\260\237\237\237\237\200\200\200"
+    "\200\200\200\200\200\200\237\260\260\260\237\237\237\237\237\200\200\200"
+    "\200\200\200\055\260\237\237\044\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\071\071\071\071\071\071\071\071\071\071\260\260"
+    "\044\075\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\200\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\200\200\200\044\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\200\052\071\071\071\071\071\071\071\071\071\071\052\052"
+    "\044\075\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\032\032\032\032\056\032\032\032\032\032\032\032\032\032\032"
+    "\032\047\047\042\042\052\055\055\032\032\032\032\032\032\032\032\240\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\260\260\260\260\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\200\052\071\071\071\071\071\071\071\071\071\071\052\052"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\052"
+    "\044\044\044\044\260\247\266\260\141\042\075\217\260\140\260\075\062\063"
+    "\131\266\052\055\246\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\200\111\111\111\246\116\200\242\117\117\202\075"
+    "\246\125\125\125\203\125\200\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\200\151\231\232\266\156\200\262\233\157\222\075\266\234\165\235"
+    "\223\165\044\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\047\266\042\056\052\052\266\052\260\042\246\260\260\260"
+    "\260\047\047\042\042\052\055\055\140\260\260\042\266\260\260\131\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\200\111\111\111\246\116\200\242\117\117\202\075"
+    "\246\125\125\125\203\125\200\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\200\151\231\232\266\156\200\262\233\157\222\075\266\234\165\235"
+    "\223\165\044\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\232\231\151\201\101"
+    "\105\266\246\233\222\157\235\234\171\202\203\044\044\044\044\266\141\151"
+    "\262\165\156\116\141\157\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\246\246\246\246\246\246\246\246\246\246\246\246\246\246\246"
+    "\246\246\246\246\246\246\246\246\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\266\266\266\266\266\266\266\266\266\266\266\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\266\266\266\266\266\266\266\266\266"
+    "\246\246\246\246\246\246\246\075\075\075\246\246\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\205\223\214\141\221\147\141\225\227\145\122\162\151\245\201\101"
+    "\105\266\246\157\222\107\044\243\263\202\203\266\044\246\075\044\101\111"
+    "\262\244\264\265\042\260\260\260\075\061\061\207\042\042\260\260\260\260"
+    "\260\204\103\206\105\260\260\260\260\111\123\260\260\260\260\260\260\260"
+    "\125\125\260\260\260\260\260\260\260\132\224\143\226\145\151\163\165\165"
+    "\172\260\260\260\260\260\260\260\242\220\117\241\157\117\266\261\113\153"
+    "\114\154\156\105\116\047\217\075\042\063\052\247\075\042\260\075\055\061"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\232\231\151\201\101"
+    "\105\266\246\233\222\157\235\234\171\202\203\266\044\246\075\266\141\151"
+    "\262\165\156\116\141\157\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\101\101\101\260\260\260\260\260\044\044\260\260\260\260\260\260\260"
+    "\141\101\260\260\260\260\260\260\260\044\266\246\105\105\105\266\111\111"
+    "\111\260\260\260\260\260\111\260\242\220\117\117\157\117\266\266\246\125"
+    "\125\125\171\131\140\140\217\075\052\063\052\247\075\140\260\140\055\061"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\165\225\212\227\230\117\157\231\245\201\205"
+    "\105\114\154\233\222\114\154\243\263\202\203\124\164\207\075\143\141\151"
+    "\262\165\204\224\132\172\206\226\075\265\103\163\042\042\260\260\260\260"
+    "\260\101\101\105\123\260\260\260\260\244\264\260\260\260\260\260\260\260"
+    "\101\141\260\260\260\260\260\260\260\044\266\246\104\105\144\116\111\111"
+    "\145\260\260\260\260\124\125\260\242\220\117\241\261\156\123\163\122\125"
+    "\162\125\171\131\164\140\217\140\140\055\140\247\075\140\260\140\140\165"
+    "\122\162\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\143\212\215\230\213\232\231\151\201\103"
+    "\105\143\103\233\222\157\235\234\111\202\203\147\044\107\075\152\141\151"
+    "\262\165\156\116\107\147\110\150\260\061\112\163\042\042\260\260\260\260"
+    "\260\101\101\101\123\260\260\260\260\244\264\260\260\260\260\260\260\260"
+    "\123\163\260\260\260\260\260\260\260\044\260\260\105\105\105\266\111\111"
+    "\111\260\260\260\260\260\111\260\242\220\117\117\107\147\266\246\266\125"
+    "\125\125\125\165\260\140\217\260\154\266\140\247\075\140\260\140\140\260"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\260\044\260\075\260\260\260"
+    "\260\260\260\260\260\260\260\260\075\061\061\260\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\044\044\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\044\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\266\260\260\260"
+    "\260\260\260\260\140\140\217\075\052\063\052\247\075\140\260\140\055\061"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\232\231\266\201\101"
+    "\105\266\246\233\222\157\235\234\111\202\203\266\044\246\123\163\141\151"
+    "\262\165\156\116\107\147\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\101\101\101\260\260\260\260\260\044\044\260\260\260\260\260\260\260"
+    "\141\101\260\260\260\260\260\260\260\044\157\141\105\105\105\260\111\111"
+    "\111\260\260\260\260\260\111\260\242\220\117\117\157\117\266\260\075\125"
+    "\125\125\151\171\140\140\217\075\260\063\052\247\075\140\260\140\055\061"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\232\231\151\201\101"
+    "\105\266\246\233\222\157\235\234\171\202\203\266\044\246\075\266\141\151"
+    "\262\165\156\116\141\157\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\101\101\101\260\260\260\260\260\044\044\260\260\260\260\260\260\260"
+    "\141\101\260\260\260\260\260\260\260\044\266\246\105\105\105\044\111\111"
+    "\111\260\260\260\260\260\111\260\242\220\117\117\157\117\266\266\246\125"
+    "\125\125\171\131\140\140\217\075\052\063\052\247\075\140\260\140\055\061"
+    "\063\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\141\210\101\212\215\105\213\111\117\151\101\101"
+    "\105\101\105\233\157\157\125\234\111\117\203\044\044\125\044\242\141\151"
+    "\262\165\156\116\141\157\052\117\075\061\061\052\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\246\266\246\201\101"
+    "\105\266\246\233\222\266\235\131\171\202\203\266\044\246\044\266\141\151"
+    "\262\165\101\111\242\125\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\044\044\044\044\266\141\151"
+    "\262\165\156\116\141\157\052\260\075\061\061\052\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\101\210\052\212\215\230\213\232\231\052\101\247"
+    "\105\105\105\233\105\111\235\234\044\117\203\044\044\125\125\266\260\140"
+    "\262\165\140\140\063\140\111\260\075\061\061\063\042\042\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\052\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\055\075\075\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\266\075\266\075\061\061\075\042\042\237\237\260\260\237\237\260\240\217"
+    "\237\044\044\237\260\260\237\237\237\237\056\237\237\237\071\071\071\071"
+    "\071\071\071\071\071\071\237\056\237\237\237\056\044\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\260\075\075\075\237\055\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\200\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\103\223\214\211\221\210\141\212\215\230\213\232\231\151\201\101"
+    "\105\266\246\233\222\157\235\234\171\202\203\266\044\246\044\266\141\151"
+    "\262\165\156\116\141\157\052\260\075\061\061\052\042\044\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\266\220\246\266\246\266\266\266\246\246"
+    "\246\266\075\266\266\075\075\075\075\075\075\075\075\075\260\075\055\075"
+    "\156\062\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\246\260\055\075\260\047\047\246\055\246"
+    "\246\246\246\260\260\246\246\260\246\062\063\266\044\266\266\266\266\266"
+    "\266\266\246\246\246\246\246\246\246\061\246\246\042\042\260\260\260\260"
+    "\260\246\246\246\246\260\260\260\260\246\246\260\260\260\260\260\260\260"
+    "\246\246\260\260\260\260\260\260\260\246\246\246\246\246\246\246\266\266"
+    "\266\260\260\260\260\266\266\260\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\266\266\140\217\075\266\266\266\247\266\140\260\140\266\266"
+    "\266\266\260\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\044\260\260\260\260\056\260\260\260\260\260\260\260\260\260\260"
+    "\260\047\047\042\042\052\055\055\260\260\260\260\260\260\260\260\240\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\260\260\260\260\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\200\052\071\071\071\071\071\071\071\071\071\071\052\052"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\052\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\123\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\131\132\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\163\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\172\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\101"
+    "\101\105\105\105\111\111\140\266\266\140\140\125\125\044\140\131\171\260"
+    "\103\212\116\156\052\052\044\044\044\247\266\044\211\215\233\235\141\214"
+    "\262\165\210\213\157\234\221\230\222\223\101\231\246\246\141\151\266\266"
+    "\201\151\202\203\105\232\220\117\101\101\141\246\266\111\111\242\117\117"
+    "\157\123\163\125\131\171\246\266\055\266\052\063\055\061\061\141\157\042"
+    "\260\042\075\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\052\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\044\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\052\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\204"
+    "\105\107\111\111\113\247\114\246\123\246\132\217\125\246\260\224\145\147"
+    "\151\151\153\055\154\266\163\266\172\055\165\266\101\101\101\101\201\101"
+    "\246\111\103\105\206\105\105\111\111\111\246\116\117\242\117\117\202\125"
+    "\246\125\125\125\203\131\246\220\141\141\211\141\221\141\266\151\143\214"
+    "\226\230\145\151\231\232\266\156\157\262\233\157\222\165\266\165\165\235"
+    "\223\171\266\266"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\260\260\260\260\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\200\052\071\071\071\071\071\071\071\071\071\071\052\052"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\102"
+    "\142\044\103\143\104\247\127\260\127\144\131\217\260\131\106\146\107\147"
+    "\115\155\052\120\167\160\167\123\171\127\167\163\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\127\116\117\242\117\117\202\124"
+    "\246\125\125\125\203\131\131\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\167\156\157\262\233\157\222\164\266\234\165\235"
+    "\223\171\171\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\044\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\052\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\056"
+    "\042\042\056\055\237\237\237\237\237\237\237\237\237\237\055\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\055\055\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\266\266\047\246\042\056\052\052\260\052\266\042\246\266\246\260"
+    "\246\047\047\042\042\052\055\055\260\260\260\042\260\260\260\260\260\363"
+    "\323\270\044\350\260\247\260\260\260\042\075\217\260\260\260\075\062\250"
+    "\260\310\052\055\260\267\260\042\260\260\260\260\376\340\341\366\344\345"
+    "\364\343\365\350\351\352\353\354\355\356\357\377\360\361\362\363\346\342"
+    "\374\373\347\370\375\371\367\372\336\300\301\326\304\305\324\303\325\310"
+    "\311\312\313\314\315\316\317\337\320\321\322\323\306\302\334\333\307\330"
+    "\335\331\327\332"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\240\103\105\116\202\203\141\210\211\221\237\042\212\214\213"
+    "\215\230\151\056\231\232\156\262\042\233\222\075\165\234\235\223\040\041"
+    "\042\043\044\052\046\047\050\051\052\053\056\055\056\057\071\071\071\071"
+    "\071\071\071\071\071\071\072\056\074\075\076\056\260\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\133\134\135\136\137\055\237\237\237\237\237\237\237\237\237"
+    "\237\200\200\200\200\200\200\200\200\237\237\237\237\237\237\237\237\173"
+    "\174\175\237\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\141\105\204\202\203\141\224\103\221\143\205\225\214\245"
+    "\265\104\151\144\105\145\105\262\145\233\222\157\165\105\145\223\052\260"
+    "\206\044\247\052\052\220\260\260\260\226\140\075\147\111\151\111\075\075"
+    "\151\113\075\075\227\114\154\114\154\114\154\116\156\241\075\075\261\116"
+    "\075\042\042\056\240\156\117\117\157\117\055\055\042\042\047\047\075\260"
+    "\157\122\162\122\042\042\162\122\162\123\047\042\163\243\263\101\124\164"
+    "\111\132\172\125\242\117\165\125\125\165\125\165\125\165\131\171\153\244"
+    "\207\264\107\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\052\260"
+    "\044\044\247\052\052\220\260\123\260\140\140\075\132\246\075\075\075\075"
+    "\075\266\075\075\075\163\075\141\157\246\172\266\052\052\075\075\266\075"
+    "\205\042\103\056\240\101\101\117\246\266\246\055\042\042\047\047\075\260"
+    "\077\260\075\044\042\042\246\042\055\055\047\042\052\101\225\101\143\105"
+    "\111\111\111\111\242\117\266\117\125\125\125\266\266\140\140\266\105\140"
+    "\140\105\266\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\061\062\105\063\202\203\140\210\211\221\140\140\212\214\213"
+    "\215\230\044\260\231\232\052\061\052\233\222\260\044\234\235\223\052\246"
+    "\246\246\246\246\246\220\260\260\246\246\247\075\260\055\246\075\075\075"
+    "\044\246\246\246\246\246\246\246\246\246\246\246\266\246\075\246\246\075"
+    "\246\042\042\056\240\246\246\246\246\266\055\055\042\042\047\047\075\246"
+    "\246\246\246\266\266\266\266\246\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266\266"
+    "\266\266\266\217"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\237\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\040\041"
+    "\042\043\044\045\044\047\051\050\052\053\054\055\056\057\060\061\062\063"
+    "\064\065\066\067\070\071\072\073\074\075\076\077\237\042\077\077\077\077"
+    "\200\237\237\056\240\200\200\200\200\200\055\055\042\042\047\047\237\237"
+    "\200\200\200\200\200\200\200\200\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\175"
+    "\135\173\133\174"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\131\260"
+    "\044\044\247\052\052\220\260\260\260\140\140\075\246\246\075\075\075\075"
+    "\044\266\075\075\075\266\075\141\157\246\266\266\052\052\075\075\266\075"
+    "\075\042\042\056\240\101\101\117\246\266\055\055\042\042\047\047\075\260"
+    "\171\131\075\044\246\266\246\266\171\055\047\042\052\101\105\101\105\105"
+    "\111\111\111\111\242\117\077\117\125\125\125\266\266\140\140\140\140\140"
+    "\140\140\140\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\052\260"
+    "\044\044\247\052\052\220\260\260\260\140\140\075\101\123\075\075\075\075"
+    "\044\266\075\075\075\266\075\141\157\246\141\163\052\052\075\075\266\075"
+    "\075\042\042\056\240\101\101\117\246\266\055\055\042\042\047\047\075\260"
+    "\171\131\075\044\042\042\124\164\052\055\047\042\052\101\105\101\105\105"
+    "\111\111\111\111\242\117\077\117\125\125\125\266\266\140\140\140\140\140"
+    "\140\140\140\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\052\260"
+    "\044\044\247\052\052\220\260\260\260\140\140\075\246\246\075\075\075\075"
+    "\044\266\075\075\075\266\075\141\157\246\266\266\052\052\075\075\266\075"
+    "\075\042\042\056\240\101\101\117\246\266\055\055\042\042\047\047\075\260"
+    "\171\131\075\044\042\042\146\146\052\055\047\042\052\101\105\101\105\105"
+    "\111\111\111\111\242\117\077\117\125\125\125\266\266\140\140\140\140\140"
+    "\140\140\140\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\042\042\056\200\200\200\200\200\200\200\200\200\200\042\042\200"
+    "\260\052\200\200\200\200\200\200\200\200\200\200\200\047\047\260\240\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\032\040\055\055\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\260\052\071\071\071\071\071\071\071\071\071\071\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\201\101\103\105\116\202\203\141\210\211\221\141\141\212\214\213"
+    "\215\230\151\151\231\232\156\262\157\233\222\157\165\234\235\223\052\260"
+    "\044\044\247\052\052\220\260\260\260\140\140\075\246\246\075\075\075\075"
+    "\044\266\075\075\075\266\075\141\157\246\266\266\052\052\075\075\266\075"
+    "\075\042\042\056\240\101\101\117\246\266\055\055\042\042\047\047\075\260"
+    "\171\131\107\147\111\266\123\163\052\055\047\042\052\101\105\101\105\105"
+    "\111\111\111\111\242\117\077\117\125\125\125\077\266\140\140\140\140\140"
+    "\140\140\140\055"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
+    "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\052\260"
+    "\216\044\247\052\052\255\260\260\260\246\266\075\303\343\075\075\075\075"
+    "\275\266\236\246\256\276\257\277\246\266\246\266\266\246\075\075\266\075"
+    "\075\042\042\056\240\246\266\312\352\266\055\055\042\042\047\047\075\042"
+    "\254\274\246\266\267\250\270\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\044"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032"
+    "\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\032\240\237"
+    "\237\260\237\260\260\237\237\260\237\260\260\237\260\260\260\260\260\260"
+    "\237\237\237\237\260\237\237\237\237\237\237\237\260\237\237\237\260\237"
+    "\260\237\260\260\237\237\260\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\260\200\200\237\260\260\237\237\237\237\237\260\055\260\200\200"
+    "\200\200\200\200\260\260\071\071\071\071\071\071\071\071\071\071\260\260"
+    "\237\237\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\240\101\101\101\101\201\101\103\105\105\105\105\111\111\111\111"
+    "\246\116\117\242\117\117\202\125\125\125\203\131\246\266\075\075\260\052"
+    "\044\044\075\044\266\247\044\047\042\042\042\042\146\146\260\055\052\052"
+    "\055\260\052\052\047\042\042\042\056\052\075\052\061\266\140\266\140\140"
+    "\140\140\140\062\140\140\063\140\140\055\055\075\061\061\063\210\141\211"
+    "\141\221\141\212\213\214\215\230\151\246\151\141\231\232\266\156\207\246"
+    "\246\157\157\262\233\157\222\266\234\165\235\266\223\171\227\266\266\220"
+    "\266\171\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\246\323\266\042\056\246\246\246\266\246\310\246\246\246\246"
+    "\266\047\047\042\042\052\055\055\266\266\266\350\266\266\266\266\240\254"
+    "\274\246\246\246\246\247\250\260\246\042\075\363\260\246\260\266\255\275"
+    "\266\266\052\055\270\267\266\042\266\246\266\266\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\075\127\167\032\260\131\171\032\260\260\260\260\056\260\052\052"
+    "\047\047\042\042\042\042\042\055\055\055\246\266\052\052\146\146\240\052"
+    "\044\044\044\044\260\247\140\260\141\042\075\217\260\140\260\075\062\063"
+    "\140\266\052\055\140\061\157\042\061\061\063\052\101\101\101\101\201\101"
+    "\246\103\105\105\105\105\111\111\111\111\246\116\117\242\117\117\202\075"
+    "\246\125\125\125\203\131\246\220\210\141\211\141\221\141\266\212\213\214"
+    "\215\230\151\151\231\232\266\156\157\262\233\157\222\075\266\234\165\235"
+    "\223\171\266\171"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\246\303\047\343\042\056\052\052\044\052\246\042\246\246\246\246"
+    "\266\047\047\042\042\052\055\055\260\260\266\042\266\266\266\266\240\246"
+    "\266\246\044\246\260\247\250\260\246\042\075\217\260\246\260\075\255\275"
+    "\266\266\052\055\270\267\266\042\266\246\266\266\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\125\125\003\125\125\125\007\010\011\012\013\014\015\016\017\020\125"
+    "\125\131\131\131\131\131\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\101\101\101\101\101\101\101\105\105\105\105\105\105\111\111\111"
+    "\111\111\117\117\117\242\117\117\117\117\117\117\117\125\125\125\240\101"
+    "\101\105\117\117\125\246\141\211\215\233\157\165\266\101\200\200\200\200"
+    "\200\210\141\141\141\141\101\141\141\141\141\101\101\101\101\101\101\105"
+    "\141\141\141\141\141\141\213\105\145\145\214\145\145\145\145\145\145\151"
+    "\151\105\105\117\151\151\151\157\117\157\157\262\157\157\157\157\157\157"
+    "\157\157\157\157\157\234\117\165\165\165\165\165\165\165\165\165\171\171"
+    "\171\171\171\117"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\201\106"
+    "\107\110\111\112\132\113\114\115\116\116\117\202\120\122\123\123\124\125"
+    "\203\127\131\131\132\137\267\141\142\212\144\145\221\146\147\150\151\152"
+    "\172\153\154\155\156\156\157\222\160\162\163\163\164\165\223\167\171\171"
+    "\172\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260"
+    "\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\260\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
+    "\237\237\237\237\237\237\237\237\237\237\237\200\237\237\200\200\200\200"
+    "\200\200\200\260\260\260\260\044\237\237\237\237\237\237\055\200\200\200"
+    "\200\200\200\200\200\052\071\071\071\071\071\071\071\071\071\071\052\052"
+    "\260\260\260\260"},},
+{{"\000\001\101\003\004\101\101\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\131\025\026\027\030\131\032\033\034\035\131\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\101\101\101\101\101\101\101\101\105\105\105\105\105\105\105\117"
+    "\117\117\117\117\117\117\117\117\111\117\117\111\125\125\125\131\117\141"
+    "\141\141\141\141\141\141\145\145\145\145\145\145\145\157\157\157\157\117"
+    "\117\157\157\157\151\125\125\125\125\157\157\125\101\101\101\101\101\101"
+    "\141\141\105\105\105\105\111\111\111\171\246\165\117\242\117\141\171\165"
+    "\165\125\125\171\171\131\157\165\210\141\211\141\141\141\165\141\213\214"
+    "\215\145\151\151\151\151\266\165\157\262\233\157\157\157\165\234\165\165"
+    "\165\171\157\125"},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+};
+
+const Recoder NCodepagePrivate::TCodePageData::rcdr_from_yandex[] = {
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\245\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\264\077\240\077"
+    "\077\077\077\077\077\247\250\077\077\077\241\262\252\257\260\077\077\077"
+    "\077\077\077\271\270\077\077\077\242\263\272\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\275\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255\077\232\077"
+    "\077\077\077\077\077\077\263\077\077\077\077\266\264\267\234\077\077\077"
+    "\077\077\077\077\243\077\077\077\077\246\244\247\341\342\367\347\344\345"
+    "\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376"
+    "\373\375\377\371\370\374\340\361\301\302\327\307\304\305\326\332\311\312"
+    "\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\337\331"
+    "\330\334\300\321"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\077\360\077\077\077\366\077\362\364\370\077\077\077"
+    "\077\077\077\374\361\077\077\077\367\077\363\365\200\201\202\203\204\205"
+    "\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227"
+    "\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251"
+    "\252\253\254\255\256\257\340\341\342\343\344\345\346\347\350\351\352\353"
+    "\354\355\356\357"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\266\077\312\077"
+    "\077\077\077\077\077\244\335\077\077\077\330\247\270\272\241\077\077\077"
+    "\077\077\077\334\336\077\077\077\331\264\271\273\200\201\202\203\204\205"
+    "\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227"
+    "\230\231\232\233\234\235\236\237\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\375\241\077\077\077\256\246\244\247\077\077\077\077"
+    "\077\077\077\360\361\077\077\077\376\366\364\367\260\261\262\263\264\265"
+    "\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307"
+    "\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331"
+    "\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353"
+    "\354\355\356\357"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\245\306\312\243\077\342\347\077\351\077\077\255"
+    "\337\344\366\374\271\346\352\263\353\356\077\364\077\077\077\077\240\321"
+    "\323\214\257\217\077\247\077\077\077\077\077\077\077\077\260\361\363\234"
+    "\277\237\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\241\306\312\243\077\342\347\077\351\077\077\255"
+    "\337\344\366\374\261\346\352\263\353\356\077\364\077\077\077\077\240\321"
+    "\323\246\257\254\077\247\077\077\077\077\077\077\077\077\260\361\363\266"
+    "\277\274\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\360"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\375\205\077\077\077\231\213\207\215\077\077\077\077"
+    "\077\077\077\357\204\077\077\077\230\212\206\214\241\243\354\255\247\251"
+    "\352\364\270\276\307\321\323\325\327\335\342\344\346\350\253\266\245\374"
+    "\366\372\237\362\356\370\235\340\240\242\353\254\246\250\351\363\267\275"
+    "\306\320\322\324\326\330\341\343\345\347\252\265\244\373\365\371\236\361"
+    "\355\367\234\336"},},
+{{},},
+{{"\000\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\250\077\077\077\241\262\252\257\260\077\077\077"
+    "\077\077\077\271\270\077\077\077\242\263\272\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\245\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\264\077\240\077"
+    "\077\077\077\077\077\247\250\077\077\077\241\262\252\257\260\077\077\077"
+    "\077\077\077\271\270\077\077\077\242\263\272\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\347\350\351\352\077\255"
+    "\077\077\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\347\350\351\352\077\255"
+    "\077\077\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\257\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\277\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\241\077\312\077\077\342\077\077\351\077\077\255"
+    "\337\344\366\374\261\077\352\077\353\356\077\364\077\373\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\077\077\077\077\077\077\077\077\211\214\213\223\227\226\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\300\303\306\331\077\077\077\077\351\077\077\255"
+    "\337\344\366\374\340\343\346\371\077\077\077\077\077\077\077\077\240\321"
+    "\323\332\335\312\077\247\077\077\077\077\077\077\077\077\260\361\363\372"
+    "\375\352\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\241\305\335\243\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\242\345\375\263\353\356\357\364\371\373\077\077\240\321"
+    "\323\327\257\254\077\247\077\077\077\077\077\077\077\077\260\361\363\367"
+    "\277\256\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\077\077\077\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\077\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\300\303\306\331\077\077\077\077\351\077\077\255"
+    "\337\344\366\374\340\343\346\371\077\077\077\077\077\077\077\077\240\321"
+    "\323\332\335\312\077\247\077\077\077\077\077\077\077\077\260\361\363\372"
+    "\375\352\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\243\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\363\077\240\077"
+    "\077\077\077\077\077\375\241\077\077\077\256\246\244\247\077\077\077\077"
+    "\077\077\077\360\361\077\077\077\376\366\364\367\260\261\262\263\264\265"
+    "\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307"
+    "\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331"
+    "\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353"
+    "\354\355\356\357"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\362\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\363\077\377\077"
+    "\077\077\077\077\077\077\360\077\077\077\077\366\364\370\077\077\077\077"
+    "\077\077\077\374\361\077\077\077\077\367\365\371\200\201\202\203\204\205"
+    "\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227"
+    "\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251"
+    "\252\253\254\255\256\257\340\341\342\343\344\345\346\347\350\351\352\353"
+    "\354\355\356\357"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\354\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\374\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\375\077\377\077"
+    "\077\077\077\077\077\077\360\077\077\077\366\370\362\364\077\077\077\077"
+    "\077\077\077\077\361\077\077\077\367\371\363\365\200\201\202\203\204\205"
+    "\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227"
+    "\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251"
+    "\252\253\254\255\256\257\340\341\342\343\344\345\346\347\350\351\352\353"
+    "\354\355\356\357"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\354\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\354\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\265\200\267\255\077\077\077\077\202\077\077\360"
+    "\341\204\224\201\320\207\322\210\077\077\077\077\077\077\077\077\377\343"
+    "\340\227\243\215\077\365\077\077\077\077\077\077\077\077\370\347\242\230"
+    "\244\245\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\360"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\340\077\077\077\077\365\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\244\217\250\235\077\203\207\077\202\077\077\360"
+    "\341\204\224\201\245\206\251\210\211\214\077\223\077\077\077\077\377\343"
+    "\340\227\275\215\077\365\077\077\077\077\077\077\077\077\370\344\242\230"
+    "\276\253\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\360"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\340\077\275\077\077\365\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\276\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\360"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\365\077\077\077\077\077\077\077\077\370\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\360"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\340\077\077\077\077\365\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\360"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\340\077\077\077\077\365\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\232\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\341\077\077\201\077\077\077\077\077\077\077\223\227\077\077\077\377\077"
+    "\237\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\341\204\224\201\077\077\077\077\211\077\077\223\077\226\077\077\377\077"
+    "\246\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\341\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\232\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\341\077\077\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\077\077\077\077\077\217\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\077\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\241"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\200\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\216\231\232\077\077\077\077\205\203\207\212\202\210\077\077"
+    "\341\204\224\201\077\077\077\077\211\214\213\223\227\226\077\077\377\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\370\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\360"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\377\077"
+    "\077\077\077\077\077\365\077\077\077\077\077\077\077\077\370\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\330\332\333\077\077\077\077\310\300\265\311\305\301\077\077"
+    "\336\314\316\317\077\077\077\077\315\321\335\302\313\303\077\077\240\077"
+    "\347\077\077\077\077\275\077\077\077\077\077\077\077\077\263\077\306\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\077\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\077\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\077\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\077\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\241\077\312\077\077\342\077\077\351\077\077\255"
+    "\337\344\366\374\261\077\352\077\353\356\357\364\077\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\077\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\077\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\077\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\247\263\077\077\077\077\077\077\077\260\077\077\077"
+    "\077\077\077\271\243\077\077\077\077\077\077\077\341\342\367\347\344\345"
+    "\366\372\351\352\353\354\355\356\357\360\362\363\364\365\346\350\343\376"
+    "\373\375\377\371\370\374\340\361\301\302\327\307\304\305\326\332\311\312"
+    "\313\314\315\316\317\320\322\323\324\325\306\310\303\336\333\335\337\331"
+    "\330\334\300\321"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\077\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\201\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\204\214\242\374\077\077\077\077\216\077\077\077"
+    "\247\212\232\237\210\215\253\270\077\077\077\231\077\077\077\077\312\301"
+    "\356\345\373\217\077\244\077\077\077\077\077\077\077\077\241\304\227\346"
+    "\375\220\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\306\077\077\210\211\215\217\216\220\077\077"
+    "\247\212\232\237\077\346\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\356\077\077\077\077\244\077\077\077\077\077\077\077\077\241\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\377"
+    "\247\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\077\077\077\077\077\254\077\077\077\077\077\077\077\077\256\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\077\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\247\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\356\077\077\077\077\244\077\077\077\077\077\077\077\077\241\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\247\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\356\077\077\077\077\244\077\077\077\077\077\077\077\077\241\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\247\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\356\077\077\077\077\244\077\077\077\077\077\077\077\077\241\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\200\205\206\077\077\077\077\210\211\215\217\216\220\077\077"
+    "\247\212\232\237\077\077\077\077\221\224\225\231\235\236\077\077\312\077"
+    "\356\077\077\077\077\244\077\077\077\077\077\077\077\077\241\077\227\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\242\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\266\077\312\077"
+    "\077\077\077\077\077\244\335\077\077\077\330\247\270\272\241\077\077\077"
+    "\077\077\077\334\336\077\077\077\331\264\271\273\200\201\202\203\204\205"
+    "\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227"
+    "\230\231\232\233\234\235\236\237\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\205\226\232\077\077\077\350\325\327\333\334\335\336\077\077"
+    "\373\331\360\366\077\077\077\370\337\344\345\356\362\364\077\077\200\077"
+    "\223\077\077\077\077\247\077\077\077\077\077\077\077\077\077\077\355\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\250\077\077\077\241\262\077\077\260\077\077\077"
+    "\077\077\077\271\270\077\077\077\242\263\077\077\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\304\326\334\077\077\077\077\340\342\347\350\351\352\077\255"
+    "\337\344\366\374\077\077\077\077\353\356\357\364\371\373\077\077\240\077"
+    "\323\077\077\077\077\247\077\077\077\077\077\077\077\077\260\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\255"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\240\077"
+    "\077\077\077\077\077\247\250\077\077\077\077\262\077\077\260\077\077\077"
+    "\077\077\077\271\270\077\077\077\077\263\077\077\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\077\077\003\077\077\077\007\010\011\012\013\014\015\016\017\020\077"
+    "\077\077\077\077\077\077\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\263\077\077\077\077\077\077\077\265\251\077\314\320\252\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\253\357\077\077\077\240\077"
+    "\225\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\343\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\077\104\105\107\110"
+    "\111\112\113\115\116\117\120\122\124\077\125\126\130\131\077\133\077\134"
+    "\136\077\077\077\077\137\077\141\142\077\144\145\147\150\151\152\153\155"
+    "\156\157\160\162\164\077\165\166\170\171\077\173\077\174\176\077\077\077"
+    "\077\177\077\106\123\132\077\077\077\077\077\077\143\077\077\077\077\077"
+    "\077\146\163\172\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\140\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{"\000\001\077\003\004\077\077\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\077\025\026\027\030\077\032\033\034\035\077\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\077\077\077\077\077\077\077\077\340\342\077\350\351\352\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\364\371\077\077\077\077\077"
+    "\323\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\363\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077\077"
+    "\077\077\077\077"},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+};
+
+const Recoder NCodepagePrivate::TCodePageData::rcdr_to_lower[] = {
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\232\213\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\274\244\264\246\247\270\251\272\253\254\255\256\277\260\261\263\263"
+    "\264\265\266\267\270\271\272\273\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\243"
+    "\244\265\246\247\270\271\272\273\274\255\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
+    "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\361\361\363\363\365\365\367\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
+    "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\337\240\241"
+    "\266\243\244\245\246\264\250\251\252\254\254\255\257\257\260\261\262\263"
+    "\264\265\266\300\271\271\273\273\275\275\277\277\300\317\302\303\304\305"
+    "\306\307\310\311\312\314\314\316\316\317\320\321\322\323\324\325\326\327"
+    "\331\331\333\333\334\336\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\361"
+    "\362\363\364\365\366\367\370\371\372\373\374\255\376\377\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\232\213\234\215\236\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\377\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\232\213\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\263\244\271\246\247\250\251\272\253\254\255\256\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\276\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\261"
+    "\242\263\244\265\266\247\250\271\272\273\274\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\221\222\223\224\225\226\227\210\211\212\213\214\215\236\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\261"
+    "\262\263\264\265\266\247\270\271\272\273\274\275\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\200\202\202\204\204\206\206\210\210\212\212\214\214\216\216"
+    "\220\220\222\222\224\224\226\226\230\230\232\232\234\234\236\236\240\240"
+    "\242\242\244\244\246\246\250\250\252\252\254\254\256\257\260\261\262\263"
+    "\264\265\265\267\267\271\272\273\274\275\275\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\320\322\322\324\324\326\326"
+    "\330\331\332\333\334\330\336\337\336\341\341\343\343\345\345\347\347\351"
+    "\351\353\353\355\355\357\360\361\361\363\363\365\365\367\367\371\371\373"
+    "\373\375\376\377"},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\232\213\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\274\244\264\246\247\270\251\272\253\254\255\256\277\260\261\263\263"
+    "\264\265\266\267\270\271\272\273\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\232\213\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\274\244\264\246\247\270\251\272\253\254\255\256\277\260\261\263\263"
+    "\264\265\266\267\270\271\272\273\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\051\050\246\247\250\056\252\054\055\255\256\257\260\261\263\263"
+    "\265\265\267\267\271\271\273\273\275\275\277\277\301\301\303\303\305\305"
+    "\307\307\311\311\313\313\315\315\317\317\321\321\323\323\325\325\327\327"
+    "\331\331\333\333\335\335\337\337\341\341\343\343\345\345\347\347\351\351"
+    "\353\353\355\355\357\357\361\361\363\363\365\365\367\367\371\371\373\373"
+    "\375\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\232\213\234\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\377\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\232\213\234\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\377\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\261"
+    "\242\243\244\245\266\247\250\151\272\273\274\255\256\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\303\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\320\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\261"
+    "\242\263\244\265\266\247\250\271\272\273\274\255\276\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\277\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\334\267\335\336\337\273\374\275\375\376\300\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\322\363\364\365\366\367"
+    "\370\371\372\373\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\151\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\272\253\254\255\256\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\250\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\270\265\266\267\270\271\272\273\275\275\377\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\263\244\245\250\247\250\251\272\253\256\255\256\277\260\261\271\263"
+    "\270\265\266\267\270\271\272\273\275\275\377\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\334\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\335\336\337\273\374\275\375\376\300\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\322\363\364\365\366\367"
+    "\370\371\372\373\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\232\213\234\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\377\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\151\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\234\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\272\253\254\255\256\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\361"
+    "\362\363\364\365\366\367\370\371\372\373\374\255\376\377\320\321\322\323"
+    "\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
+    "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\361\361\363\363\365\365\367\367\371\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\377\265\266\267\250\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\314\355\356\357\360\361\322\363\364\365\366\327"
+    "\370\371\372\373\374\375\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
+    "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\361\361\363\363\365\365\367\367\371\371\372\373"
+    "\375\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\240\333"
+    "\334\335\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\377\265\266\267\250\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\314\355\356\357\360\361\322\363\364\365\366\327"
+    "\370\371\372\373\374\375\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\234\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\377\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\314\355\356\357\360\361\322\363\364\365\366\327"
+    "\370\371\372\373\374\375\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\230\224\201\233\234\235\236\237\240\241"
+    "\242\243\244\244\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247"
+    "\250\251\253\254\255\256\257\340\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\341\342\343\345\346\347\351\361\362\363\344\350\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\213\213\214\245\204\206"
+    "\202\221\221\223\224\205\226\230\230\224\201\233\234\233\236\237\203\214"
+    "\242\244\244\245\246\247\250\251\252\253\254\210\256\257\260\261\262\263"
+    "\264\320\321\322\323\271\272\273\274\324\325\277\300\301\302\303\304\305"
+    "\326\327\310\311\312\313\314\315\316\330\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\242\341\223\347\344\344\346\347\351\351"
+    "\353\353\354\211\354\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\230\224\201\233\234\233\236\237\240\241"
+    "\242\243\244\244\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\240\203\205\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\320\210\211\212\325\241\214"
+    "\213\331\332\333\334\335\215\337\242\341\223\225\344\344\346\347\347\243"
+    "\226\227\354\354\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\213\213\214\253\204\206"
+    "\202\222\222\223\224\226\226\230\230\224\201\234\234\210\236\237\240\241"
+    "\242\243\245\245\247\247\251\251\252\253\237\255\256\257\260\261\262\263"
+    "\264\240\203\330\255\271\272\273\274\276\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\320\320\324\211\324\345\241\214"
+    "\330\331\332\333\334\356\205\337\242\341\223\344\344\345\347\347\352\243"
+    "\352\373\354\354\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\375\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\151\224\201\233\234\233\236\237\240\241"
+    "\242\243\244\244\247\247\251\251\252\253\237\255\256\257\260\261\262\263"
+    "\264\240\203\205\255\271\272\273\274\276\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\320\321\210\211\212\325\241\214"
+    "\213\331\332\333\334\335\215\337\242\341\223\225\345\345\346\350\350\243"
+    "\226\227\355\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\151\224\201\233\234\233\237\237\240\241"
+    "\242\243\244\244\247\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\240\203\205\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\321\210\211\212\325\241\214"
+    "\213\331\332\333\334\335\354\337\242\341\223\225\344\344\346\347\350\243"
+    "\226\227\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\230\224\201\233\234\233\236\237\240\241"
+    "\242\243\244\244\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\240\203\205\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\320\210\211\212\325\241\214"
+    "\213\331\332\333\334\335\215\337\242\341\223\225\344\344\346\347\347\243"
+    "\226\227\354\354\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\240\207\210\210\212\241\223\215\204\203"
+    "\202\205\212\223\224\225\243\227\215\224\201\233\234\227\236\242\240\241"
+    "\242\243\244\244\246\247\250\225\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\214\214\225\204\206"
+    "\202\221\221\223\224\225\226\230\230\224\201\233\234\233\236\237\240\241"
+    "\242\243\240\241\242\243\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\244\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\203\205\206\207\210\211\212\213\214\215\205\217"
+    "\202\212\210\223\211\213\226\227\230\223\201\233\234\227\226\237\240\241"
+    "\242\243\244\245\246\247\214\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\207\201\202\203\204\205\206\207\210\211\212\213\214\215\204\206"
+    "\202\221\221\223\224\225\226\227\230\224\201\233\234\233\236\237\240\241"
+    "\242\243\244\244\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\355\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\233\207\210\211\212\213\214\235\216\236"
+    "\237\240\242\223\224\243\373\227\375\231\232\233\234\235\236\237\240\241"
+    "\242\243\326\327\330\335\336\340\341\253\342\343\256\257\260\261\262\263"
+    "\264\344\345\346\347\271\272\273\274\350\351\277\300\301\302\303\304\305"
+    "\352\353\310\311\312\313\314\315\316\354\356\362\363\364\366\372\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\310"
+    "\300\311\301\315\321\335\250\251\252\253\254\313\303\257\260\262\262\263"
+    "\265\265\267\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\324\321\326\327\324\325\326\327"
+    "\314\331\316\317\305\335\336\302\304\342\342\344\344\325\331\306\312\352"
+    "\352\354\354\307\357\357\361\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\261"
+    "\262\263\264\265\266\247\270\271\272\273\274\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\243\245\245\253\247\270\251\272\253\274\255\256\377\261\261\263\263"
+    "\265\265\266\271\270\271\272\277\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\212\215\215\217"
+    "\200\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\243"
+    "\264\245\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\201\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\040\041"
+    "\042\043\044\245\046\047\050\051\052\053\254\055\056\057\260\261\262\263"
+    "\264\265\266\267\270\271\072\273\074\075\076\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\133\134\135\136\137\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\173"
+    "\174\175\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\202\202\216\210\232\237\207\210\213\212\213\215\215\216\220"
+    "\220\223\222\223\225\225\230\227\230\231\232\233\234\236\236\237\240\241"
+    "\253\243\244\245\246\247\250\251\252\253\254\255\256\260\260\264\262\263"
+    "\264\372\266\267\270\272\272\274\274\276\276\300\300\304\302\303\304\313"
+    "\306\307\310\311\312\313\316\233\316\330\320\321\322\323\324\325\326\327"
+    "\330\332\332\336\334\335\336\340\340\344\342\343\344\346\346\207\351\351"
+    "\222\354\354\360\227\231\360\363\234\363\365\365\367\367\371\371\372\375"
+    "\270\375\256\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\214\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\271\252\253\254\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\346\307\350\311\312\210\213\233\317\317\360\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\376\337\340\341\342\343\344\211\346\207\350\217"
+    "\222\224\225\223\227\231\360\230\234\236\235\365\366\367\370\371\221\373"
+    "\374\220\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\201\202\216\204\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\347"
+    "\344\365\354\352\360\247\250\251\363\373\254\255\256\257\341\261\262\263"
+    "\264\342\345\372\350\351\353\355\346\374\343\366\300\356\302\357\362\305"
+    "\364\307\310\311\312\371\370\300\333\317\320\321\322\323\324\325\326\334"
+    "\335\336\340\333\334\335\336\361\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\201\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\040\041"
+    "\042\043\044\045\246\047\051\050\052\053\054\055\056\057\060\061\062\063"
+    "\064\065\066\067\070\071\072\073\074\075\076\077\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\313\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\300\355\356\357\360\361\362\363\364\365\366\367\370\371\372\175"
+    "\135\173\133\174"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\214\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\340\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\210\213\233\317\317\320\321\322\323\324\325\326\327"
+    "\330\330\332\333\335\335\337\337\340\341\342\343\344\211\220\207\221\217"
+    "\222\224\225\223\227\231\360\230\234\236\235\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\214\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\210\213\233\317\317\320\321\322\323\324\325\326\327"
+    "\330\330\332\333\334\335\337\337\340\341\342\343\344\211\220\207\221\217"
+    "\222\224\225\223\227\231\360\230\234\236\235\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\214\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\210\213\233\317\317\320\321\322\323\324\325\326\327"
+    "\330\330\332\333\334\335\336\337\340\341\342\343\344\211\220\207\221\217"
+    "\222\224\225\223\227\231\360\230\234\236\235\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\203\204\205\206\207\215\216\217"
+    "\220\221\222\223\224\225\226\227\203\204\205\206\207\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\222\322\323\224\225\226\227"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\223\203\204"
+    "\205\206\207\217\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\212\214\215\216\226\232\237\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\276\277\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\210\213\233\317\317\320\321\322\323\324\325\326\327"
+    "\330\330\333\333\151\335\337\337\340\341\342\343\344\211\220\207\221\217"
+    "\222\224\225\223\227\231\360\230\234\236\235\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
+    "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\337\240\241"
+    "\266\243\244\245\246\264\250\251\252\254\254\255\257\257\260\261\262\263"
+    "\264\265\266\300\271\271\273\273\275\275\277\277\300\317\302\303\304\305"
+    "\306\307\310\311\312\314\314\316\316\317\320\321\322\323\324\325\326\327"
+    "\331\331\333\333\334\336\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\325\326\327\330\331\332\333\334\335\336\337\340\342\344\345"
+    "\346\347\354\355\356\357\360\362\363\364\366\367\374\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\361\342\343\344\345\346\347\370\371"
+    "\372\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\220\203\255\203\204\205\231\211\230\211\232\233\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\274\265\264\261\247\270\251\272\253\254\255\256\277\260\261\263\263"
+    "\264\265\266\267\270\271\272\273\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\202\202\203\204\206\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\233\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\327"
+    "\370\371\372\373\374\375\376\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\232\213\234\235\236\237"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\274\244\264\246\247\270\251\272\253\254\255\256\277\260\261\263\263"
+    "\264\265\266\267\270\271\272\273\274\276\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\363\364\003\365\366\367\007\010\011\012\013\014\015\016\017\020\370"
+    "\371\372\373\374\375\376\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\265\266\267\270\271\306\313\314\316\317\320\321\326\327\330\334"
+    "\335\336\337\341\342\343\344\351\352\353\354\355\356\357\361\362\240\250"
+    "\251\252\253\254\255\256\250\251\252\253\254\255\256\273\260\261\262\263"
+    "\264\265\266\267\270\271\274\273\274\275\276\275\276\307\310\311\312\322"
+    "\306\307\310\311\312\313\314\323\316\317\320\321\322\323\324\325\326\327"
+    "\330\324\325\345\334\335\336\337\346\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\347\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\350"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\173\174\175\176\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\306\003\004\307\347\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\326\025\026\027\030\333\032\033\034\035\334\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\141\142\143\144\145\146\147"
+    "\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171"
+    "\172\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\325\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
+    "\260\261\262\265\376\276\266\267\270\366\367\357\374\373\370\317\365\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\336"
+    "\275\265\266\267\270\361\321\327\330\275\276\337\340\341\342\343\344\345"
+    "\306\307\350\351\352\353\354\355\356\317\360\321\362\363\364\325\326\327"
+    "\330\371\372\333\334\375\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\346"},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+};
+
+const Recoder NCodepagePrivate::TCodePageData::rcdr_to_upper[] = {
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\263\264\245\266\267\250\251\252\253\254\275\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\253\255\256\256\260\261\262\263"
+    "\247\265\242\267\270\270\272\272\274\274\276\276\267\301\302\303\304\305"
+    "\306\307\310\311\312\313\313\315\315\301\320\321\322\323\324\325\326\327"
+    "\330\330\332\332\334\335\335\237\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233"
+    "\234\235\236\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\260\261\262\263\264\265\266\267"
+    "\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\241\242\243\244\245\246\247\250\251\252\253"
+    "\254\375\256\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\216\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\243"
+    "\264\265\266\267\270\245\252\273\274\275\274\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\243"
+    "\264\245\246\267\270\251\252\253\254\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\101\101\103\105\105\105\216\217"
+    "\220\201\202\203\204\205\206\207\105\111\111\117\125\125\216\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\242\243"
+    "\244\245\246\267\250\251\252\253\254\255\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\201\201\203\203\205\205\207\207\211\211\213\213\215\215\217\217"
+    "\221\221\223\223\225\225\227\227\231\231\233\233\235\235\237\237\241\241"
+    "\243\243\245\245\247\247\251\251\253\253\255\255\256\257\260\261\262\263"
+    "\264\266\266\270\270\271\272\273\274\276\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\323\323\325\325\327\327"
+    "\335\331\332\333\334\335\340\337\340\342\342\344\344\346\346\350\350\352"
+    "\352\354\354\356\356\357\360\362\362\364\364\366\366\370\370\372\372\374"
+    "\374\375\376\377"},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\051\050\246\247\250\056\252\054\055\255\256\257\260\261\262\262"
+    "\264\264\266\266\270\270\272\272\274\274\276\276\300\300\302\302\304\304"
+    "\306\306\310\310\312\312\314\314\316\316\320\320\322\322\324\324\326\326"
+    "\330\330\332\332\334\334\336\336\340\340\342\342\344\344\346\346\350\350"
+    "\352\352\354\354\356\356\360\360\362\362\364\364\366\366\370\370\372\372"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\263"
+    "\264\265\246\267\270\111\252\253\254\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\343\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\243"
+    "\264\245\246\267\270\251\252\253\254\275\256\275\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\266\270\271\272\340\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\323\323\324\325\326\327\330\331\332\333"
+    "\274\276\277\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\111\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\250\271\252\273\274\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\246\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\264\271\272\273\274\274\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\276"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\241\243\244\245\246\247\246\251\252\253\254\255\254\257\260\261\262\243"
+    "\264\265\266\267\264\262\252\273\274\274\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\276"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\314\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\242\270\271\272\340\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\323\323\324\325\326\327\330\331\332\333"
+    "\274\276\277\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\111\336\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\250\271\252\273\274\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\260\261\262\263\264\265\266\267"
+    "\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\241\242\243\244\245\246\247\250\251\252\253"
+    "\254\375\256\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\370\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\264"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\370\372\373"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\240\333"
+    "\334\335\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\264"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\214\215\216\217"
+    "\220\222\222\223\231\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\221\222\223\224\225\226\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\227\352\353\354\364\355\356\357\365\360"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\240\216\225\217\200\255\355\212\212\241\215\216\217"
+    "\220\222\222\342\231\225\226\227\227\231\232\235\234\235\236\237\240\241"
+    "\340\243\243\215\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\265\266\267\270\275\276\306\307"
+    "\317\331\332\333\334\335\336\337\340\341\342\343\345\345\346\343\350\350"
+    "\352\352\356\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\237\265\326"
+    "\340\351\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\322\323\324\111\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\350\350\351"
+    "\352\353\355\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\336\217\200\235\323\212\212\327\215\216\217"
+    "\220\221\221\342\231\225\225\227\227\231\232\233\233\235\236\254\265\326"
+    "\340\351\244\244\246\246\250\250\252\215\254\270\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\275\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\321\321\322\323\322\325\326\327"
+    "\267\331\332\333\334\335\336\337\340\341\342\343\343\325\346\346\350\351"
+    "\350\353\355\355\335\357\360\361\362\363\364\365\366\367\370\371\372\353"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\254\265\326"
+    "\340\351\245\245\246\246\250\250\252\253\254\270\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\275\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\321\322\323\324\111\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\347\351"
+    "\352\353\354\354\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\111\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\236\265\326"
+    "\340\351\245\245\246\246\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\350\351"
+    "\352\353\336\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\237\265\326"
+    "\340\351\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\350\350\351"
+    "\352\353\355\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\217\216\221\206\200\211\211\222\213\214\230\216\217"
+    "\220\221\222\214\231\251\226\235\230\231\232\233\234\235\236\237\206\213"
+    "\237\226\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\213\215\216\217"
+    "\220\222\222\223\231\215\226\227\227\231\232\235\234\235\236\237\244\245"
+    "\246\247\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\204\204\216\206\200\222\224\221\225\250\215\216\217"
+    "\220\221\222\231\224\225\236\235\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\214\215\216\217"
+    "\220\222\222\223\231\225\226\227\230\231\232\235\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\206\234\215\217\220\221\241"
+    "\222\225\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\244\245"
+    "\246\331\332\333\334\247\250\337\251\252\254\255\265\266\267\270\275\276"
+    "\306\307\317\317\320\357\360\361\321\322\323\365\324\367\370\371\325\226"
+    "\374\230\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\261\263"
+    "\264\264\266\266\270\271\272\273\274\275\276\277\242\244\337\256\340\334"
+    "\347\355\241\243\350\255\330\245\332\333\320\246\322\323\320\345\322\323"
+    "\330\346\332\333\334\247\336\337\340\341\341\343\343\345\346\347\350\351"
+    "\351\353\353\355\356\356\360\360\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\242\243"
+    "\244\245\246\267\250\251\252\253\254\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\241\243\244\244\246\247\250\251\252\246\254\255\256\257\260\260\262\262"
+    "\264\264\266\267\250\267\252\273\254\275\275\273\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\214\213\214\216\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\263\244\265\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\202\203\217"
+    "\220\221\222\223\224\225\204\227\230\231\205\233\234\235\236\206\040\041"
+    "\042\043\044\245\046\047\050\051\052\053\254\055\056\057\260\261\262\263"
+    "\264\265\266\267\270\271\072\273\074\075\076\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\133\134\135\136\137\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\173"
+    "\174\175\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\201\203\204\205\206\347\204\211\200\211\214\214\203\217"
+    "\217\221\352\221\224\224\226\356\226\357\205\315\362\235\235\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\242\254\255\376\257\257\261\262\263"
+    "\261\265\266\267\374\271\271\273\273\275\275\277\277\301\302\303\301\305"
+    "\306\307\310\311\312\305\314\315\314\317\320\321\322\323\324\325\326\327"
+    "\317\331\331\333\334\335\333\337\337\341\342\343\341\345\345\347\350\350"
+    "\352\353\353\355\356\357\355\361\362\361\364\364\366\366\370\370\265\373"
+    "\374\373\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\375\372\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\251\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\306\347\310\351"
+    "\352\353\354\355\356\357\320\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\215\203\217"
+    "\220\221\222\223\224\225\226\227\230\231\205\233\234\235\236\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\315\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\316\327\330\331\337\332\260\265\276\242\266\274\241\270\271"
+    "\245\272\244\273\301\303\246\337\304\252\306\243\277\252\314\313\267\253"
+    "\275\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\202\203\217"
+    "\220\221\222\223\224\225\204\227\230\231\205\233\234\235\236\206\040\041"
+    "\042\043\044\045\246\047\051\050\052\053\054\055\056\057\060\061\062\063"
+    "\064\065\066\067\070\071\072\073\074\075\076\077\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\313\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\300\355\356\357\360\361\362\363\364\365\366\367\370\371\372\175"
+    "\135\173\133\174"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\334\336\336\240\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\335\336\336\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\203\204\205\206\207\215\216\217"
+    "\220\221\222\223\224\225\226\227\203\204\205\206\207\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\222\322\323\224\225\226\227"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\223\203\204"
+    "\205\206\207\217\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\332\334\111\336\336\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\253\255\256\256\260\261\262\263"
+    "\247\265\242\267\270\270\272\272\274\274\276\276\267\301\302\303\304\305"
+    "\306\307\310\311\312\313\313\315\315\301\320\321\322\323\324\325\326\327"
+    "\330\330\332\332\334\335\335\237\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233"
+    "\234\235\236\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\201\202\203"
+    "\204\205\206\207\210\211\212\213\214\341\215\343\216\217\220\221\350\351"
+    "\352\353\222\223\224\225\226\341\227\230\231\111\232\233\350\351\352\373"
+    "\234\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\207\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\210\206\212\213\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\202\256\257\260\246\262\262"
+    "\245\244\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\201\203\204\205\205\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\232\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\241\242\243\244\245\246\247\257\260\261\262\263"
+    "\264\200\201\202\203\204\272\257\272\277\300\277\300\301\302\303\304\305"
+    "\205\301\302\303\304\206\207\315\210\211\212\213\305\315\331\332\214\215"
+    "\216\331\332\333\217\220\221\222\340\223\224\225\226\333\340\360\377\227"
+    "\230\231\232\233\234\235\360\236\237\001\002\004\005\006\021\022\023\024"
+    "\025\026\027\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135"
+    "\136\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\263"
+    "\264\223\226\227\230\271\272\273\274\264\225\277\300\301\302\303\304\305"
+    "\002\005\310\311\312\313\314\315\316\237\320\272\322\323\324\200\024\273"
+    "\274\331\332\031\036\335\263\277\300\301\302\303\304\305\377\006\310\311"
+    "\312\313\314\315\316\233\320\271\322\323\324\240\231\232\236\331\332\235"
+    "\234\335\224\377"},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+};
+
+const Recoder NCodepagePrivate::TCodePageData::rcdr_to_title[] = {
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\263\264\245\266\267\250\251\252\253\254\275\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\253\255\256\256\260\261\262\263"
+    "\247\265\242\267\270\270\272\272\274\274\276\276\267\301\302\303\304\305"
+    "\306\307\310\311\312\313\313\315\315\301\320\321\322\323\324\325\326\327"
+    "\330\330\332\332\334\335\335\237\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233"
+    "\234\235\236\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\260\261\262\263\264\265\266\267"
+    "\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\241\242\243\244\245\246\247\250\251\252\253"
+    "\254\375\256\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\216\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\243"
+    "\264\265\266\267\270\245\252\273\274\275\274\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\243"
+    "\264\245\246\267\270\251\252\253\254\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\101\101\103\105\105\105\216\217"
+    "\220\201\202\203\204\205\206\207\105\111\111\117\125\125\216\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\242\243"
+    "\244\245\246\267\250\251\252\253\254\255\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\201\201\203\203\205\205\207\207\211\211\213\213\215\215\217\217"
+    "\221\221\223\223\225\225\227\227\231\231\233\233\235\235\237\237\241\241"
+    "\243\243\245\245\247\247\251\251\253\253\255\255\256\257\260\261\262\263"
+    "\264\266\266\270\270\271\272\273\274\276\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\323\323\325\325\327\327"
+    "\335\331\332\333\334\335\340\337\340\342\342\344\344\346\346\350\350\352"
+    "\352\354\354\356\356\357\360\362\362\364\364\366\366\370\370\372\372\374"
+    "\374\375\376\377"},},
+{{},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153"
+    "\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\051\050\246\247\250\056\252\054\055\255\256\257\260\261\262\262"
+    "\264\264\266\266\270\270\272\272\274\274\276\276\300\300\302\302\304\304"
+    "\306\306\310\310\312\312\314\314\316\316\320\320\322\322\324\324\326\326"
+    "\330\330\332\332\334\334\336\336\340\340\342\342\344\344\346\346\350\350"
+    "\352\352\354\354\356\356\360\360\362\362\364\364\366\366\370\370\372\372"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\263"
+    "\264\265\246\267\270\111\252\253\254\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\343\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\262\243"
+    "\264\245\246\267\270\251\252\253\254\275\256\275\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\240"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\266\270\271\272\340\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\323\323\324\325\326\327\330\331\332\333"
+    "\274\276\277\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\111\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\250\271\252\273\274\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\246\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\264\271\272\273\274\274\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\276"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\241\243\244\245\246\247\246\251\252\253\254\255\254\257\260\261\262\243"
+    "\264\265\266\267\264\262\252\273\274\274\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\276"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\314\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\242\270\271\272\340\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\323\323\324\325\326\327\330\331\332\333"
+    "\274\276\277\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\212\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\111\336\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\250\271\252\273\274\275\276\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\260\261\262\263\264\265\266\267"
+    "\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\360\241\242\243\244\245\246\247\250\251\252\253"
+    "\254\375\256\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\370\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\264"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\200\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\220\221\222\223\224\225\226\227\230\231"
+    "\232\233\234\235\236\237\360\360\362\362\364\364\366\366\370\370\372\373"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\240\333"
+    "\334\335\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\270\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\264"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\214\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\354\315\316\317\320\321\362\323\324\325\326\367\330\331\332\333"
+    "\334\335\376\237"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\214\215\216\217"
+    "\220\222\222\223\231\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\221\222\223\224\225\226\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\227\352\353\354\364\355\356\357\365\360"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\240\216\225\217\200\255\355\212\212\241\215\216\217"
+    "\220\222\222\342\231\225\226\227\227\231\232\235\234\235\236\237\240\241"
+    "\340\243\243\215\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\265\266\267\270\275\276\306\307"
+    "\317\331\332\333\334\335\336\337\340\341\342\343\345\345\346\343\350\350"
+    "\352\352\356\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\237\265\326"
+    "\340\351\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\322\323\324\111\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\350\350\351"
+    "\352\353\355\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\336\217\200\235\323\212\212\327\215\216\217"
+    "\220\221\221\342\231\225\225\227\227\231\232\233\233\235\236\254\265\326"
+    "\340\351\244\244\246\246\250\250\252\215\254\270\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\275\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\321\321\322\323\322\325\326\327"
+    "\267\331\332\333\334\335\336\337\340\341\342\343\343\325\346\346\350\351"
+    "\350\353\355\355\335\357\360\361\362\363\364\365\366\367\370\371\372\353"
+    "\374\374\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\254\265\326"
+    "\340\351\245\245\246\246\250\250\252\253\254\270\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\275\277\300\301\302\303\304\305"
+    "\306\306\310\311\312\313\314\315\316\317\320\321\322\323\324\111\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\347\351"
+    "\352\353\354\354\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\111\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\236\265\326"
+    "\340\351\245\245\246\246\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\347\350\351"
+    "\352\353\336\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\266\216\267\217\200\322\323\324\330\327\336\216\217"
+    "\220\222\222\342\231\343\352\353\230\231\232\235\234\235\236\237\265\326"
+    "\340\351\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\307\307\310\311\312\313\314\315\316\317\321\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\345\345\346\350\350\351"
+    "\352\353\355\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\217\216\221\206\200\211\211\222\213\214\230\216\217"
+    "\220\221\222\214\231\251\226\235\230\231\232\233\234\235\236\237\206\213"
+    "\237\226\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\213\215\216\217"
+    "\220\222\222\223\231\215\226\227\227\231\232\235\234\235\236\237\244\245"
+    "\246\247\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\204\204\216\206\200\222\224\221\225\250\215\216\217"
+    "\220\221\222\231\224\225\236\235\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\232\220\203\216\205\217\200\210\211\212\213\214\215\216\217"
+    "\220\222\222\223\231\225\226\227\230\231\232\235\234\235\236\237\240\241"
+    "\242\243\245\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\344\346\347\350\351"
+    "\352\353\354\350\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\206\234\215\217\220\221\241"
+    "\222\225\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\244\245"
+    "\246\331\332\333\334\247\250\337\251\252\254\255\265\266\267\270\275\276"
+    "\306\307\317\317\320\357\360\361\321\322\323\365\324\367\370\371\325\226"
+    "\374\230\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\261\263"
+    "\264\264\266\266\270\271\272\273\274\275\276\277\242\244\337\256\340\334"
+    "\347\355\241\243\350\255\330\245\332\333\320\246\322\323\320\345\322\323"
+    "\330\346\332\333\334\247\336\337\340\341\341\343\343\345\346\347\350\351"
+    "\351\353\353\355\356\356\360\360\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\241\242\243"
+    "\244\245\246\267\250\251\252\253\254\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\241\243\244\244\246\247\250\251\252\246\254\255\256\257\260\260\262\262"
+    "\264\264\266\267\250\267\252\273\254\275\275\273\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\257"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\220\203\202\203\204\205\206\207\210\211\214\213\214\216\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\242"
+    "\242\263\244\265\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\340\341\342\343\344\345"
+    "\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367"
+    "\370\371\372\373\374\375\376\377\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\202\203\217"
+    "\220\221\222\223\224\225\204\227\230\231\205\233\234\235\236\206\040\041"
+    "\042\043\044\245\046\047\050\051\052\053\254\055\056\057\260\261\262\263"
+    "\264\265\266\267\270\271\072\273\074\075\076\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\133\134\135\136\137\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\173"
+    "\174\175\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\201\203\204\205\206\347\204\211\200\211\214\214\203\217"
+    "\217\221\352\221\224\224\226\356\226\357\205\315\362\235\235\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\242\254\255\376\257\257\261\262\263"
+    "\261\265\266\267\374\271\271\273\273\275\275\277\277\301\302\303\301\305"
+    "\306\307\310\311\312\305\314\315\314\317\320\321\322\323\324\325\326\327"
+    "\317\331\331\333\334\335\333\337\337\341\342\343\341\345\345\347\350\350"
+    "\352\353\353\355\356\357\355\361\362\361\364\364\366\366\370\370\265\373"
+    "\374\373\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\375\372\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\251\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\306\347\310\351"
+    "\352\353\354\355\356\357\320\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\215\203\217"
+    "\220\221\222\223\224\225\226\227\230\231\205\233\234\235\236\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\315\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\316\327\330\331\337\332\260\265\276\242\266\274\241\270\271"
+    "\245\272\244\273\301\303\246\337\304\252\306\243\277\252\314\313\267\253"
+    "\275\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\200\213\214\202\203\217"
+    "\220\221\222\223\224\225\204\227\230\231\205\233\234\235\236\206\040\041"
+    "\042\043\044\045\246\047\051\050\052\053\054\055\056\057\060\061\062\063"
+    "\064\065\066\067\070\071\072\073\074\075\076\077\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\313\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\300\355\356\357\360\361\362\363\364\365\366\367\370\371\372\175"
+    "\135\173\133\174"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\334\336\336\240\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\335\336\336\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\111\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\203\204\205\206\207\215\216\217"
+    "\220\221\222\223\224\225\226\227\203\204\205\206\207\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\222\322\323\224\225\226\227"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\223\203\204"
+    "\205\206\207\217\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\347\313\345\200\314\201\202\203\351"
+    "\346\350\352\355\353\354\204\356\361\357\205\315\362\364\363\206\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\256\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\316\320\321\322\323\324\325\326\327"
+    "\331\331\332\332\334\111\336\336\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\253\255\256\256\260\261\262\263"
+    "\247\265\242\267\270\270\272\272\274\274\276\276\267\301\302\303\304\305"
+    "\306\307\310\311\312\313\313\315\315\301\320\321\322\323\324\325\326\327"
+    "\330\330\332\332\334\335\335\237\200\201\202\203\204\205\206\207\210\211"
+    "\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233"
+    "\234\235\236\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\201\202\203"
+    "\204\205\206\207\210\211\212\213\214\341\215\343\216\217\220\221\350\351"
+    "\352\353\222\223\224\225\226\341\227\230\231\111\232\233\350\351\352\373"
+    "\234\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\207\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\210\206\212\213\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\202\256\257\260\246\262\262"
+    "\245\244\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\201\203\204\205\205\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\232\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\367\330\331\332\333"
+    "\334\335\336\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\201\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\200\221\222\223\224\225\226\227\230\231\212\233\214\215\216\217\240\241"
+    "\241\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\262"
+    "\245\265\266\267\250\271\252\273\243\275\275\257\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\300\301\302\303\304\305\306\307\310\311"
+    "\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333"
+    "\334\335\336\337"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\241\242\243\244\245\246\247\257\260\261\262\263"
+    "\264\200\201\202\203\204\272\257\272\277\300\277\300\301\302\303\304\305"
+    "\205\301\302\303\304\206\207\315\210\211\212\213\305\315\331\332\214\215"
+    "\216\331\332\333\217\220\221\222\340\223\224\225\226\333\340\360\377\227"
+    "\230\231\232\233\234\235\360\236\237\001\002\004\005\006\021\022\023\024"
+    "\025\026\027\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135"
+    "\136\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241"
+    "\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263"
+    "\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305"
+    "\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327"
+    "\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351"
+    "\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373"
+    "\374\375\376\377"},},
+{{"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021"
+    "\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043"
+    "\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065"
+    "\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107"
+    "\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131"
+    "\132\133\134\135\136\137\140\101\102\103\104\105\106\107\110\111\112\113"
+    "\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\173\174\175"
+    "\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
+    "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\201"
+    "\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\263"
+    "\264\223\226\227\230\271\272\273\274\264\225\277\300\301\302\303\304\305"
+    "\002\005\310\311\312\313\314\315\316\237\320\272\322\323\324\200\024\273"
+    "\274\331\332\031\036\335\263\277\300\301\302\303\304\305\377\006\310\311"
+    "\312\313\314\315\316\233\320\271\322\323\324\240\231\232\236\331\332\235"
+    "\234\335\224\377"},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+{{},},
+};
+
diff --git a/library/cpp/charset/iconv.cpp b/library/cpp/charset/iconv.cpp
new file mode 100644
index 0000000000..df43471470
--- /dev/null
+++ b/library/cpp/charset/iconv.cpp
@@ -0,0 +1,94 @@
+#include "iconv.h"
+
+#include <contrib/libs/libiconv/iconv.h>
+
+using namespace NICONVPrivate;
+
+TDescriptor::TDescriptor(const char* from, const char* to)
+    : Descriptor_(libiconv_open(to, from))
+    , From_(from)
+    , To_(to)
+{
+    if (!Invalid()) {
+        int temp = 1;
+
+        libiconvctl(Descriptor_, ICONV_SET_DISCARD_ILSEQ, &temp);
+    }
+}
+
+TDescriptor::~TDescriptor() {
+    if (!Invalid()) {
+        libiconv_close(Descriptor_);
+    }
+}
+
+size_t NICONVPrivate::RecodeImpl(const TDescriptor& descriptor, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+    Y_ASSERT(!descriptor.Invalid());
+    Y_ASSERT(in);
+    Y_ASSERT(out);
+
+    char* inPtr = const_cast<char*>(in);
+    char* outPtr = out;
+    size_t inSizeMod = inSize;
+    size_t outSizeMod = outSize;
+    size_t res = libiconv(descriptor.Get(), &inPtr, &inSizeMod, &outPtr, &outSizeMod);
+
+    read = inSize - inSizeMod;
+    written = outSize - outSizeMod;
+
+    return res;
+}
+
+void NICONVPrivate::DoRecode(const TDescriptor& descriptor, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+    if (descriptor.Invalid()) {
+        ythrow yexception() << "Can not convert from " << descriptor.From() << " to " << descriptor.To();
+    }
+
+    size_t res = RecodeImpl(descriptor, in, out, inSize, outSize, read, written);
+
+    if (res == static_cast<size_t>(-1)) {
+        switch (errno) {
+            case EILSEQ:
+                read = inSize;
+                break;
+
+            case EINVAL:
+                read = inSize;
+                break;
+
+            case E2BIG:
+                ythrow yexception() << "Iconv error: output buffer is too small";
+
+            default:
+                ythrow yexception() << "Unknown iconv error";
+        }
+    }
+}
+
+RECODE_RESULT NICONVPrivate::DoRecodeNoThrow(const TDescriptor& descriptor, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+    if (descriptor.Invalid()) {
+        return RECODE_ERROR;
+    }
+
+    size_t res = RecodeImpl(descriptor, in, out, inSize, outSize, read, written);
+
+    if (res == static_cast<size_t>(-1)) {
+        switch (errno) {
+            case EILSEQ:
+                read = inSize;
+                break;
+
+            case EINVAL:
+                read = inSize;
+                break;
+
+            case E2BIG:
+                return RECODE_EOOUTPUT;
+
+            default:
+                return RECODE_ERROR;
+        }
+    }
+
+    return RECODE_OK;
+}
diff --git a/library/cpp/charset/iconv.h b/library/cpp/charset/iconv.h
new file mode 100644
index 0000000000..ac13539347
--- /dev/null
+++ b/library/cpp/charset/iconv.h
@@ -0,0 +1,136 @@
+#pragma once
+
+#include "codepage.h"
+
+#include <util/generic/noncopyable.h>
+
+// WARNING: Do not use this functions - use functions from wide.h or recyr.hh instead.
+
+namespace NICONVPrivate {
+    inline const char* CharsetName(ECharset code) {
+        return NameByCharset(code);
+    }
+
+    inline const char* CharsetName(const char* code) {
+        return code;
+    }
+
+    template <int size>
+    inline const char* UnicodeNameBySize();
+
+    template <>
+    inline const char* UnicodeNameBySize<1>() {
+        return "UTF-8";
+    }
+
+    template <>
+    inline const char* UnicodeNameBySize<2>() {
+        return "UTF-16LE";
+    }
+
+    template <>
+    inline const char* UnicodeNameBySize<4>() {
+        return "UCS-4LE";
+    }
+
+    template <class C>
+    inline const char* UnicodeName() {
+        return UnicodeNameBySize<sizeof(C)>();
+    }
+
+    class TDescriptor : NNonCopyable::TNonCopyable {
+    private:
+        void* Descriptor_;
+        const char* From_;
+        const char* To_;
+
+    public:
+        template <class TFrom, class TTo>
+        inline TDescriptor(TFrom from, TTo to)
+            : TDescriptor(CharsetName(from), CharsetName(to))
+        {
+        }
+
+        TDescriptor(const char* from, const char* to);
+
+        ~TDescriptor();
+
+        inline void* Get() const {
+            return Descriptor_;
+        }
+
+        inline bool Invalid() const {
+            return Descriptor_ == (void*)(-1);
+        }
+
+        inline const char* From() const noexcept {
+            return From_;
+        }
+
+        inline const char* To() const noexcept {
+            return To_;
+        }
+    };
+
+    template <class TFrom, class TTo>
+    inline bool CanConvert(TFrom from, TTo to) {
+        TDescriptor descriptor(from, to);
+
+        return !descriptor.Invalid();
+    }
+
+    size_t RecodeImpl(const TDescriptor& descriptor, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written);
+    void DoRecode(const TDescriptor& descriptor, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written);
+
+    template <class TFrom, class TTo>
+    inline void Recode(TFrom from, TTo to, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        TDescriptor descriptor(from, to);
+
+        DoRecode(descriptor, in, out, inSize, outSize, read, written);
+    }
+
+    template <class TCharType>
+    inline void RecodeToUnicode(ECharset from, const char* in, TCharType* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        const size_t charSize = sizeof(TCharType);
+
+        Recode(from, UnicodeName<TCharType>(), in, reinterpret_cast<char*>(out), inSize, outSize * charSize, read, written);
+        written /= charSize;
+    }
+
+    template <class TCharType>
+    inline void RecodeFromUnicode(ECharset to, const TCharType* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        const size_t charSize = sizeof(TCharType);
+
+        Recode(UnicodeName<TCharType>(), to, reinterpret_cast<const char*>(in), out, inSize * charSize, outSize, read, written);
+        read /= charSize;
+    }
+
+    RECODE_RESULT DoRecodeNoThrow(const TDescriptor& d, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written);
+
+    template <class TFrom, class TTo>
+    inline RECODE_RESULT RecodeNoThrow(TFrom from, TTo to, const char* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        TDescriptor descriptor(from, to);
+
+        return DoRecodeNoThrow(descriptor, in, out, inSize, outSize, read, written);
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT RecodeToUnicodeNoThrow(ECharset from, const char* in, TCharType* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        const size_t charSize = sizeof(TCharType);
+
+        RECODE_RESULT res = RecodeNoThrow(from, UnicodeName<TCharType>(), in, reinterpret_cast<char*>(out), inSize, outSize * charSize, read, written);
+        written /= charSize;
+
+        return res;
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT RecodeFromUnicodeNoThrow(ECharset to, const TCharType* in, char* out, size_t inSize, size_t outSize, size_t& read, size_t& written) {
+        const size_t charSize = sizeof(TCharType);
+
+        RECODE_RESULT res = RecodeNoThrow(UnicodeName<TCharType>(), to, reinterpret_cast<const char*>(in), out, inSize * charSize, outSize, read, written);
+        read /= charSize;
+
+        return res;
+    }
+}
diff --git a/library/cpp/charset/iconv_ut.cpp b/library/cpp/charset/iconv_ut.cpp
new file mode 100644
index 0000000000..e8c56f6d49
--- /dev/null
+++ b/library/cpp/charset/iconv_ut.cpp
@@ -0,0 +1,87 @@
+#include "wide.h"
+#include "recyr.hh"
+#include "codepage.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+static void TestIconv(const TString& utf8, const TString& other, ECharset enc) {
+    TUtf16String wide0 = CharToWide(utf8, CODES_UTF8);
+    TUtf16String wide1 = CharToWide(other, enc);
+
+    UNIT_ASSERT(wide0 == wide1);
+
+    TString temp = WideToUTF8(wide0);
+    UNIT_ASSERT(temp == utf8);
+
+    temp = WideToChar(wide0, enc);
+    UNIT_ASSERT(temp == other);
+
+    temp = Recode(enc, CODES_UTF8, other);
+    UNIT_ASSERT(temp == utf8);
+
+    temp = Recode(CODES_UTF8, enc, utf8);
+    UNIT_ASSERT(temp == other);
+
+    size_t read = 0;
+    size_t written = 0;
+
+    RECODE_RESULT res = RecodeToUnicode(enc, other.c_str(), wide1.begin(), other.size(), wide1.size(), read, written);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(read == other.size());
+    UNIT_ASSERT(written == wide1.size());
+    UNIT_ASSERT(wide0 == wide1);
+
+    res = RecodeFromUnicode(enc, wide0.c_str(), temp.begin(), wide0.size(), temp.size(), read, written);
+    UNIT_ASSERT(res == RECODE_OK);
+    UNIT_ASSERT(read == wide0.size());
+    UNIT_ASSERT(written == other.size());
+    UNIT_ASSERT(temp == other);
+}
+
+class TIconvTest: public TTestBase {
+    static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize) {
+        size_t sSize = strlen(str);
+        size_t wSize = sSize * 2;
+        TArrayHolder<wchar16> w(new wchar16[wSize]);
+
+        size_t read = 0;
+        size_t written = 0;
+        NICONVPrivate::RecodeToUnicode(CODES_UTF8, str, w.Get(), sSize, wSize, read, written);
+        UNIT_ASSERT(read == sSize);
+        UNIT_ASSERT(written == wideSize);
+        UNIT_ASSERT(!memcmp(w.Get(), wide, wideSize));
+
+        TArrayHolder<char> s(new char[sSize]);
+        NICONVPrivate::RecodeFromUnicode(CODES_UTF8, w.Get(), s.Get(), wideSize, sSize, read, written);
+        UNIT_ASSERT(read == wideSize);
+        UNIT_ASSERT(written == sSize);
+        UNIT_ASSERT(!memcmp(s.Get(), str, sSize));
+    }
+
+private:
+    UNIT_TEST_SUITE(TIconvTest);
+    UNIT_TEST(TestBig5);
+    UNIT_TEST(TestSurrogatePairs);
+    UNIT_TEST_SUITE_END();
+
+public:
+    void TestBig5() {
+        UNIT_ASSERT(!NCodepagePrivate::NativeCodepage(CODES_BIG5));
+        const char* UTF8 = "\xe5\xad\xb8\xe7\x94\x9f\xe7\xb8\xbd\xe4\xba\xba\xe6\x95\xb8\xe6\x99\xae\xe9\x80\x9a\xe7\x8f\xad";
+        const char* BIG5 = "\xbe\xc7\xa5\xcd\xc1\x60\xa4\x48\xbc\xc6\xb4\xb6\xb3\x71\xaf\x5a";
+
+        TestIconv(UTF8, BIG5, CODES_BIG5);
+    }
+
+    void TestSurrogatePairs() {
+        const char* utf8NonBMP = "\xf4\x80\x89\x84\xf4\x80\x89\x87\xf4\x80\x88\xba";
+        wchar16 wNonBMPDummy[] = {0xDBC0, 0xDE44, 0xDBC0, 0xDE47, 0xDBC0, 0xDE3A};
+        TestSurrogates(utf8NonBMP, wNonBMPDummy, Y_ARRAY_SIZE(wNonBMPDummy));
+
+        const char* utf8NonBMP2 = "ab\xf4\x80\x89\x87n";
+        wchar16 wNonBMPDummy2[] = {'a', 'b', 0xDBC0, 0xDE47, 'n'};
+        TestSurrogates(utf8NonBMP2, wNonBMPDummy2, Y_ARRAY_SIZE(wNonBMPDummy2));
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TIconvTest);
diff --git a/library/cpp/charset/recyr.hh b/library/cpp/charset/recyr.hh
new file mode 100644
index 0000000000..5ec8734bcf
--- /dev/null
+++ b/library/cpp/charset/recyr.hh
@@ -0,0 +1,164 @@
+#pragma once
+
+#include <cstdlib>
+
+#include <util/charset/recode_result.h>
+#include <util/generic/ptr.h>
+#include <util/generic/yexception.h>
+
+#include "codepage.h"
+#include "doccodes.h"
+#include "iconv.h"
+#include "recyr_int.hh"
+
+///////////////////////////////////////////////////////////////////////////////////////
+//     input buf -> output buf                                                       //
+///////////////////////////////////////////////////////////////////////////////////////
+template <class TCharType>
+inline RECODE_RESULT RecodeToUnicode(ECharset from, const char* in, TCharType* out, size_t inSize, size_t outSize, size_t& inRead, size_t& outWritten) {
+    static_assert(sizeof(TCharType) > 1, "expect wide character type");
+
+    return NCodepagePrivate::_recodeToUnicode(from, in, out, inSize, outSize, inRead, outWritten);
+}
+
+template <class TCharType>
+inline RECODE_RESULT RecodeFromUnicode(ECharset to, const TCharType* in, char* out, size_t inSize, size_t outSize, size_t& inRead, size_t& outWritten) {
+    static_assert(sizeof(TCharType) > 1, "expect wide character type");
+
+    return NCodepagePrivate::_recodeFromUnicode(to, in, out, inSize, outSize, inRead, outWritten);
+}
+
+inline RECODE_RESULT RecodeFromUnicode(ECharset to, wchar32 rune, char* out, size_t outSize, size_t& outWritten) {
+    return NCodepagePrivate::_recodeFromUnicode(to, rune, out, outSize, outWritten);
+}
+
+template <class TCharType>
+inline RECODE_RESULT RecodeToUnicode(ECharset from, const char* in, TCharType* out, size_t inSize, size_t outSize) {
+    size_t inRead = 0;
+    size_t outWritten = 0;
+    return RecodeToUnicode(from, in, out, inSize, outSize, inRead, outWritten);
+}
+
+template <class TCharType>
+inline RECODE_RESULT RecodeFromUnicode(ECharset to, const TCharType* in, char* out, size_t inSize, size_t outSize) {
+    size_t inRead = 0;
+    size_t outWritten = 0;
+    return RecodeFromUnicode(to, in, out, inSize, outSize, inRead, outWritten);
+}
+
+inline RECODE_RESULT RecodeFromUnicode(ECharset theEncoding, const wchar16* chars, size_t length,
+                                       char* bytes, size_t size, size_t* read = nullptr, size_t* written = nullptr) {
+    size_t w = 0, r = 0;
+    RECODE_RESULT rc = ::RecodeFromUnicode(theEncoding, chars, bytes, length, size, r, w);
+    if (read)
+        *read = r;
+    if (written)
+        *written = w;
+    return rc;
+}
+
+inline RECODE_RESULT Recode(ECharset from, ECharset to, const char* in, char* out, size_t inSize, size_t outSize, size_t& inRead, size_t& outWritten) {
+    inRead = 0;
+    outWritten = 0;
+
+    if (!ValidCodepage(to) || !ValidCodepage(from))
+        return RECODE_ERROR;
+
+    if (to == from)
+        return NCodepagePrivate::_recodeCopy(in, out, inSize, outSize, inRead, outWritten);
+
+    if (NCodepagePrivate::NativeCodepage(from) && NCodepagePrivate::NativeCodepage(to)) {
+        if (from == CODES_UTF8)
+            return NCodepagePrivate::_recodeFromUTF8(to, in, out, inSize, outSize, inRead, outWritten);
+        if (to == CODES_UTF8)
+            return NCodepagePrivate::_recodeToUTF8(from, in, out, inSize, outSize, inRead, outWritten);
+        if (from == CODES_YANDEX)
+            return NCodepagePrivate::_recodeFromYandex(to, in, out, inSize, outSize, inRead, outWritten);
+        if (to == CODES_YANDEX)
+            return NCodepagePrivate::_recodeToYandex(from, in, out, inSize, outSize, inRead, outWritten);
+    } else if (NICONVPrivate::CanConvert(from, to)) {
+        return NICONVPrivate::RecodeNoThrow(from, to, in, out, inSize, outSize, inRead, outWritten);
+    }
+
+    size_t wideSize = inSize * 3;
+    TArrayHolder<wchar16> wide(new wchar16[wideSize]);
+
+    size_t wideRead = 0;
+    size_t wideWritten = 0;
+
+    RECODE_RESULT res = RecodeToUnicode(from, in, wide.Get(), inSize, wideSize, inRead, wideWritten);
+    if (res != RECODE_OK)
+        return res;
+
+    res = RecodeFromUnicode(to, wide.Get(), out, wideWritten, outSize, wideRead, outWritten);
+
+    return res;
+}
+
+inline RECODE_RESULT Recode(ECharset from, ECharset to, const char* in, char* out, size_t inSize, size_t outSize) {
+    size_t inRead = 0;
+    size_t outWritten = 0;
+    return Recode(from, to, in, out, inSize, outSize, inRead, outWritten);
+}
+
+/**
+ * Recode from one charset to another; throw an exception if conversion failed
+ * @param[in] from the source character set
+ * @param[in] to the target character set
+ * @param[in] in    the input string buffer
+ * @param[out] out  the output string object if conversion was successful
+ * @return false if conversion was not attempted (charsets were the same),
+ *         true if successful
+ */
+inline bool Recode(ECharset from, ECharset to, const TStringBuf& in, TString& out) {
+    if (to == from)
+        return false;
+
+    const size_t inSize = in.length();
+    const size_t outSize = SingleByteCodepage(to) ? inSize : 3 * inSize;
+    out.clear(); // so we don't copy stuff around when resizing
+    out.ReserveAndResize(outSize);
+
+    size_t inRead = 0;
+    size_t outWritten = 0;
+    const RECODE_RESULT res = Recode(from, to, in.data(), out.begin(), inSize, outSize, inRead, outWritten);
+    Y_ENSURE(RECODE_OK == res, "Recode failed. ");
+    if (outWritten > outSize)
+        ythrow yexception() << "Recode overrun the buffer: size="
+                            << outSize << " need=" << outWritten;
+
+    out.remove(outWritten);
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+//     TString -> TString                                                              //
+///////////////////////////////////////////////////////////////////////////////////////
+inline TString Recode(ECharset from, ECharset to, const TString& in) {
+    TString out;
+    return to != from && Recode(from, to, in, out) ? out : in;
+}
+inline TString RecodeToYandex(ECharset from, const TString& in) {
+    return Recode(from, CODES_YANDEX, in);
+}
+inline TString RecodeFromYandex(ECharset to, const TString& in) {
+    return Recode(CODES_YANDEX, to, in);
+}
+
+inline TString RecodeToHTMLEntities(ECharset from, const TString& in) {
+    RECODE_RESULT res;
+    size_t outWritten, inRead;
+    TString out;
+    out.resize(in.length() * (4 + 4));
+    res = NCodepagePrivate::_recodeToHTMLEntities(from, in.c_str(), out.begin(), in.length(), out.length(), inRead, outWritten);
+    if (res == RECODE_EOOUTPUT) { //input contains many 8-byte characters?
+        out.resize(in.length() * (4 + 8));
+        res = NCodepagePrivate::_recodeToHTMLEntities(from, in.c_str(), out.begin(), in.length(), out.length(), inRead, outWritten);
+    }
+    if (res != RECODE_OK) {
+        ythrow yexception() << "Recode to HTML entities failed";
+    }
+
+    out.resize(outWritten - 1);
+    return out;
+}
diff --git a/library/cpp/charset/recyr_int.hh b/library/cpp/charset/recyr_int.hh
new file mode 100644
index 0000000000..353af53305
--- /dev/null
+++ b/library/cpp/charset/recyr_int.hh
@@ -0,0 +1,336 @@
+#pragma once
+
+#include <util/charset/recode_result.h>
+#include <util/charset/utf8.h>
+#include <util/generic/ptr.h>
+#include <util/generic/string.h>
+#include <util/system/defaults.h>
+
+#include "codepage.h"
+#include "doccodes.h"
+#include "iconv.h"
+#include "wide.h"
+
+namespace NCodepagePrivate {
+    inline RECODE_RESULT _recodeCopy(const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        in_readed = in_size;
+        RECODE_RESULT res = RECODE_OK;
+        if (in_readed > out_size) {
+            res = RECODE_EOOUTPUT;
+            in_readed = out_size;
+        }
+        if (in != out)
+            memcpy(out, in, in_readed);
+        out_writed = in_readed;
+        return res;
+    }
+
+    inline RECODE_RESULT _recodeToUTF8(ECharset From, const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (From == CODES_UTF8)
+            return _recodeCopy(in, out, in_size, out_size, in_readed, out_writed);
+        const CodePage* cp = CodePageByCharset(From);
+
+        const unsigned char* in_start = (const unsigned char*)in;
+        const unsigned char* in_end = in_start + in_size;
+        const unsigned char* out_start = (unsigned char*)out;
+        const unsigned char* out_end = out_start + out_size;
+
+        size_t rune_len;
+        RECODE_RESULT res = RECODE_OK;
+        while ((unsigned char*)in < in_end && res == RECODE_OK) {
+            res = SafeWriteUTF8Char(cp->unicode[(unsigned char)(*in++)], rune_len, (unsigned char*)out, out_end);
+            out += rune_len;
+        }
+        in_readed = (unsigned char*)in - in_start;
+        out_writed = (unsigned char*)out - out_start;
+        return res;
+    }
+
+    inline RECODE_RESULT _recodeFromUTF8(ECharset to, const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (to == CODES_UTF8)
+            return _recodeCopy(in, out, in_size, out_size, in_readed, out_writed);
+        Y_ASSERT(CODES_UNKNOWN < to && to < CODES_MAX);
+        const Encoder* enc = &EncoderByCharset(to);
+
+        const unsigned char* in_start = (const unsigned char*)in;
+        const unsigned char* in_end = in_start + in_size;
+        const unsigned char* out_start = (unsigned char*)out;
+        const unsigned char* out_end = out_start + out_size;
+
+        wchar32 rune;
+        size_t rune_len;
+        RECODE_RESULT res = RECODE_OK;
+        while ((const unsigned char*)in < in_end && (res == RECODE_OK || res == RECODE_BROKENSYMBOL)) {
+            res = SafeReadUTF8Char(rune, rune_len, (const unsigned char*)in, in_end);
+            if (res == RECODE_BROKENSYMBOL)
+                rune_len = 1;
+            if (res != RECODE_EOINPUT)
+                *out++ = enc->Tr(rune);
+            in += rune_len;
+            if (res == RECODE_OK && (const unsigned char*)in < in_end && (unsigned char*)out >= out_end)
+                res = RECODE_EOOUTPUT;
+        }
+        in_readed = (unsigned char*)in - in_start;
+        out_writed = (unsigned char*)out - out_start;
+        return res;
+    }
+
+    inline RECODE_RESULT _recodeToYandex(ECharset From, const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (From == CODES_YANDEX)
+            return _recodeCopy(in, out, in_size, out_size, in_readed, out_writed);
+        if (From == CODES_UTF8)
+            return _recodeFromUTF8(CODES_YANDEX, in, out, in_size, out_size, in_readed, out_writed);
+        in_readed = (out_size > in_size) ? in_size : out_size;
+        const Recoder& rcdr = NCodepagePrivate::TCodePageData::rcdr_to_yandex[From];
+        rcdr.Tr(in, out, in_readed);
+        out_writed = in_readed;
+        if (out_size < in_size)
+            return RECODE_EOOUTPUT;
+        return RECODE_OK;
+    }
+    inline RECODE_RESULT _recodeFromYandex(ECharset To, const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (To == CODES_YANDEX)
+            return _recodeCopy(in, out, in_size, out_size, in_readed, out_writed);
+        if (To == CODES_UTF8)
+            return _recodeToUTF8(CODES_YANDEX, in, out, in_size, out_size, in_readed, out_writed);
+        in_readed = (out_size > in_size) ? in_size : out_size;
+        const Recoder& rcdr = NCodepagePrivate::TCodePageData::rcdr_from_yandex[To];
+        rcdr.Tr(in, out, in_readed);
+        out_writed = in_readed;
+        if (out_size < in_size)
+            return RECODE_EOOUTPUT;
+        return RECODE_OK;
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeUTF8ToUnicode(const char* in, TCharType* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        const unsigned char* inp = (const unsigned char*)in;
+        const unsigned char* in_end = inp + in_size;
+        TCharType* outp = out;
+        const TCharType* out_end = outp + out_size;
+        size_t rune_len;
+        wchar32 rune;
+        RECODE_RESULT res = RECODE_OK;
+        while ((res == RECODE_OK || res == RECODE_BROKENSYMBOL) && inp < in_end && outp < out_end) {
+            res = SafeReadUTF8Char(rune, rune_len, inp, in_end);
+            if (res == RECODE_BROKENSYMBOL)
+                rune_len = 1;
+            if (res == RECODE_OK || res == RECODE_BROKENSYMBOL) {
+                if (!WriteSymbol(rune, outp, out_end)) {
+                    break;
+                }
+                inp += rune_len;
+            }
+        }
+        in_readed = inp - (const unsigned char*)in;
+        out_writed = outp - out;
+
+        if ((res == RECODE_OK || res == RECODE_BROKENSYMBOL) && in_readed != in_size)
+            return RECODE_EOOUTPUT;
+
+        return res;
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeSBToUnicode(ECharset From, const char* in, TCharType* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        const CodePage* cp = CodePageByCharset(From);
+        const unsigned char* inp = (const unsigned char*)in;
+        const unsigned char* in_end = inp + in_size;
+        TCharType* outp = out;
+        const TCharType* out_end = outp + out_size;
+        while (inp < in_end && outp < out_end)
+            *outp++ = static_cast<TCharType>(cp->unicode[*inp++]);
+        in_readed = inp - (const unsigned char*)in;
+        out_writed = outp - out;
+        if (in_readed != in_size)
+            return RECODE_EOOUTPUT;
+        return RECODE_OK;
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeUnicodeToUTF8Impl(const TCharType* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        const TCharType* inp = in;
+        const TCharType* in_end = in + in_size;
+        unsigned char* outp = (unsigned char*)out;
+        const unsigned char* out_end = outp + out_size;
+        size_t rune_len;
+        wchar32 rune;
+        RECODE_RESULT res = RECODE_OK;
+
+        while ((res == RECODE_OK || res == RECODE_BROKENSYMBOL) && inp != in_end) {
+            rune = ReadSymbolAndAdvance(inp, in_end);
+            res = SafeWriteUTF8Char(rune, rune_len, outp, out_end);
+            if (outp >= out_end && (res == RECODE_OK || res == RECODE_BROKENSYMBOL))
+                res = RECODE_EOOUTPUT;
+            outp += rune_len;
+        }
+        in_readed = inp - in;
+        out_writed = outp - (const unsigned char*)out;
+        return res;
+    }
+
+    inline RECODE_RESULT _recodeUnicodeToUTF8(wchar32 rune, char* out, size_t out_size, size_t& nwritten) {
+        return SafeWriteUTF8Char(rune, nwritten, (unsigned char*)out, out_size);
+    }
+
+    template <class TCharType, int Size = sizeof(TCharType)>
+    struct TCharTypeSwitch;
+
+    template <class TCharType>
+    struct TCharTypeSwitch<TCharType, 2> {
+        using TRealCharType = wchar16;
+    };
+
+    template <class TCharType>
+    struct TCharTypeSwitch<TCharType, 4> {
+        using TRealCharType = wchar32;
+    };
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeUnicodeToUTF8(const TCharType* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        static_assert(sizeof(TCharType) > 1, "expect some wide type");
+
+        using TRealCharType = typename TCharTypeSwitch<TCharType>::TRealCharType;
+
+        return _recodeUnicodeToUTF8Impl(reinterpret_cast<const TRealCharType*>(in), out, in_size, out_size, in_readed, out_writed);
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeUnicodeToSB(ECharset To, const TCharType* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        const TCharType* inp = in;
+        const TCharType* in_end = in + in_size;
+        const char* out_begin = out;
+        const char* out_end = out + out_size;
+
+        const Encoder* enc = &EncoderByCharset(To);
+        while (inp != in_end && out != out_end) {
+            *out++ = enc->Tr(ReadSymbolAndAdvance(inp, in_end));
+        }
+
+        in_readed = inp - in;
+        out_writed = out - out_begin;
+
+        if (in_readed != in_size)
+            return RECODE_EOOUTPUT;
+
+        return RECODE_OK;
+    }
+
+    inline RECODE_RESULT _recodeUnicodeToSB(ECharset To, wchar32 rune, char* out, size_t out_size, size_t& nwritten) {
+        if (0 == out_size)
+            return RECODE_EOOUTPUT;
+        *out = EncoderByCharset(To).Tr(rune);
+        nwritten = 1;
+        return RECODE_OK;
+    }
+
+    inline RECODE_RESULT _rune2hex(wchar32 in, char* out, size_t out_size, size_t& out_writed) {
+        static const char hex_digs[] = "0123456789ABCDEF";
+        out_writed = 0;
+        RECODE_RESULT res = RECODE_OK;
+        for (int i = 7; i >= 0; i--) {
+            unsigned char h = (unsigned char)(in >> (i * 4) & 0x0F);
+            if (h || i == 0) {
+                if (out_writed + 1 >= out_size) {
+                    res = RECODE_EOOUTPUT;
+                    break;
+                }
+                out[out_writed++] = hex_digs[h];
+            }
+        }
+        return res;
+    }
+
+    inline RECODE_RESULT _recodeUnicodeToHTMLEntities(const wchar32* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        const wchar32* in_end = in + in_size;
+        const char* out_beg = out;
+        const wchar32* in_beg = in;
+        RECODE_RESULT res = RECODE_OK;
+
+        const char* out_end = out + out_size - 1;
+        while (in < in_end && out < out_end) {
+            if (*in < 0x80 && *in != '<' && *in != '&' && *in != '>') { //ascii
+                *out++ = char(*in & 0x00FF);
+            } else { //entity
+                char* ent = out;
+                size_t ent_writed;
+                if (ent > out_end - 6) {
+                    res = RECODE_EOOUTPUT;
+                    break;
+                }
+                memcpy(ent, "&#x", 3);
+                ent += 3;
+                res = _rune2hex(*in, ent, out_end - 1 - ent, ent_writed);
+                if (res != RECODE_OK)
+                    break;
+                ent += ent_writed;
+                *ent++ = ';';
+                out = ent;
+            }
+            in++;
+        }
+        *out++ = '\x00';
+        out_writed = out - out_beg;
+        in_readed = in - in_beg;
+        return res;
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeToUnicode(ECharset From, const char* in, TCharType* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (!ValidCodepage(From))
+            return RECODE_ERROR;
+
+        if (!NCodepagePrivate::NativeCodepage(From))
+            return NICONVPrivate::RecodeToUnicodeNoThrow(From, in, out, in_size, out_size, in_readed, out_writed);
+
+        if (From == CODES_UTF8)
+            return _recodeUTF8ToUnicode(in, out, in_size, out_size, in_readed, out_writed);
+
+        return _recodeSBToUnicode(From, in, out, in_size, out_size, in_readed, out_writed);
+    }
+
+    template <class TCharType>
+    inline RECODE_RESULT _recodeFromUnicode(ECharset To, const TCharType* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        if (!ValidCodepage(To))
+            return RECODE_ERROR;
+
+        if (!NCodepagePrivate::NativeCodepage(To))
+            return NICONVPrivate::RecodeFromUnicodeNoThrow(To, in, out, in_size, out_size, in_readed, out_writed);
+
+        if (To == CODES_UTF8)
+            return NCodepagePrivate::_recodeUnicodeToUTF8(in, out, in_size, out_size, in_readed, out_writed);
+
+        return NCodepagePrivate::_recodeUnicodeToSB(To, in, out, in_size, out_size, in_readed, out_writed);
+    }
+
+    inline RECODE_RESULT _recodeFromUnicode(ECharset To, wchar32 rune, char* out, size_t out_size, size_t& nwritten) {
+        if (!ValidCodepage(To))
+            return RECODE_ERROR;
+
+        if (!NCodepagePrivate::NativeCodepage(To)) {
+            size_t nread = 0;
+            return NICONVPrivate::RecodeFromUnicodeNoThrow(To, &rune, out, 1, out_size, nread, nwritten);
+        }
+
+        if (To == CODES_UTF8)
+            return NCodepagePrivate::_recodeUnicodeToUTF8(rune, out, out_size, nwritten);
+
+        return NCodepagePrivate::_recodeUnicodeToSB(To, rune, out, out_size, nwritten);
+    }
+
+    inline RECODE_RESULT _recodeToHTMLEntities(ECharset From, const char* in, char* out, size_t in_size, size_t out_size, size_t& in_readed, size_t& out_writed) {
+        TArrayHolder<wchar32> bufHolder(new wchar32[in_size]);
+        wchar32* buf = bufHolder.Get();
+        size_t unicode_size;
+        RECODE_RESULT res1, res2;
+
+        //first pass - to unicode
+        res1 = _recodeToUnicode(From, in, buf, in_size, in_size, in_readed, unicode_size);
+
+        //second pass - to entities
+        res2 = _recodeUnicodeToHTMLEntities(buf, out, in_size, out_size, in_readed, out_writed);
+
+        return (res2 != RECODE_OK) ? res2 : res1;
+    }
+
+}
diff --git a/library/cpp/charset/ut/ya.make b/library/cpp/charset/ut/ya.make
new file mode 100644
index 0000000000..1f9934c712
--- /dev/null
+++ b/library/cpp/charset/ut/ya.make
@@ -0,0 +1,12 @@
+UNITTEST_FOR(library/cpp/charset)
+
+OWNER(alzobnin)
+
+SRCS(
+    ci_string_ut.cpp
+    codepage_ut.cpp
+    iconv_ut.cpp
+    wide_ut.cpp
+)
+
+END()
diff --git a/library/cpp/charset/wide.cpp b/library/cpp/charset/wide.cpp
new file mode 100644
index 0000000000..d12b293817
--- /dev/null
+++ b/library/cpp/charset/wide.cpp
@@ -0,0 +1,18 @@
+#include "wide.h"
+
+bool CanBeEncoded(TWtringBuf text, ECharset encoding) {
+    const size_t LEN = 16;
+    const size_t BUFSIZE = LEN * 4;
+    char encodeBuf[BUFSIZE];
+    wchar16 decodeBuf[BUFSIZE];
+
+    while (!text.empty()) {
+        TWtringBuf src = text.NextTokAt(LEN);
+        TStringBuf encoded = NDetail::NBaseOps::Recode(src, encodeBuf, encoding);
+        TWtringBuf decoded = NDetail::NBaseOps::Recode(encoded, decodeBuf, encoding);
+        if (decoded != src)
+            return false;
+    }
+
+    return true;
+}
diff --git a/library/cpp/charset/wide.h b/library/cpp/charset/wide.h
new file mode 100644
index 0000000000..32d30e849e
--- /dev/null
+++ b/library/cpp/charset/wide.h
@@ -0,0 +1,306 @@
+#pragma once
+
+#include "codepage.h"
+#include "iconv.h"
+
+#include <util/charset/recode_result.h>
+#include <util/charset/unidata.h>
+#include <util/charset/utf8.h>
+#include <util/charset/wide.h>
+#include <util/generic/string.h>
+#include <util/generic/algorithm.h>
+#include <util/generic/yexception.h>
+#include <util/memory/tempbuf.h>
+#include <util/system/yassert.h>
+
+//! converts text from unicode to yandex codepage
+//! @attention destination buffer must be long enough to fit all characters of the text
+//! @note @c dest buffer must fit at least @c len number of characters
+template <typename TCharType>
+inline size_t WideToChar(const TCharType* text, size_t len, char* dest, ECharset enc) {
+    Y_ASSERT(SingleByteCodepage(enc));
+
+    const char* start = dest;
+
+    const Encoder* const encoder = &EncoderByCharset(enc);
+    const TCharType* const last = text + len;
+    for (const TCharType* cur = text; cur != last; ++dest) {
+        *dest = encoder->Tr(ReadSymbolAndAdvance(cur, last));
+    }
+
+    return dest - start;
+}
+
+//! converts text to unicode using a codepage object
+//! @attention destination buffer must be long enough to fit all characters of the text
+//! @note @c dest buffer must fit at least @c len number of characters;
+//!       if you need convert zero terminated string you should determine length of the
+//!       string using the @c strlen function and pass as the @c len parameter;
+//!       it does not make sense to create an additional version of this function because
+//!       it will call to @c strlen anyway in order to allocate destination buffer
+template <typename TCharType>
+inline void CharToWide(const char* text, size_t len, TCharType* dest, const CodePage& cp) {
+    const unsigned char* cur = reinterpret_cast<const unsigned char*>(text);
+    const unsigned char* const last = cur + len;
+    for (; cur != last; ++cur, ++dest) {
+        *dest = static_cast<TCharType>(cp.unicode[*cur]); // static_cast is safe as no 1char codepage contains non-BMP symbols
+    }
+}
+
+namespace NDetail {
+    namespace NBaseOps {
+        // Template interface base recoding drivers, do not perform any memory management,
+        // do not care about buffer size, so supplied @dst
+        // should have enough room for the result (with proper reserve for the worst case)
+
+        // Depending on template params, perform conversion of single-byte/multi-byte/utf8 string to/from wide string.
+
+        template <typename TCharType>
+        inline TBasicStringBuf<TCharType> RecodeSingleByteChar(const TStringBuf src, TCharType* dst, const CodePage& cp) {
+            Y_ASSERT(cp.SingleByteCodepage());
+            ::CharToWide(src.data(), src.size(), dst, cp);
+            return TBasicStringBuf<TCharType>(dst, src.size());
+        }
+
+        template <typename TCharType>
+        inline TStringBuf RecodeSingleByteChar(const TBasicStringBuf<TCharType> src, char* dst, const CodePage& cp) {
+            Y_ASSERT(cp.SingleByteCodepage());
+            ::WideToChar(src.data(), src.size(), dst, cp.CPEnum);
+            return TStringBuf(dst, src.size());
+        }
+
+        template <typename TCharType>
+        inline TBasicStringBuf<TCharType> RecodeMultiByteChar(const TStringBuf src, TCharType* dst, ECharset encoding) {
+            Y_ASSERT(!NCodepagePrivate::NativeCodepage(encoding));
+            size_t read = 0;
+            size_t written = 0;
+            ::NICONVPrivate::RecodeToUnicode(encoding, src.data(), dst, src.size(), src.size(), read, written);
+            return TBasicStringBuf<TCharType>(dst, written);
+        }
+
+        template <typename TCharType>
+        inline TStringBuf RecodeMultiByteChar(const TBasicStringBuf<TCharType> src, char* dst, ECharset encoding) {
+            Y_ASSERT(!NCodepagePrivate::NativeCodepage(encoding));
+            size_t read = 0;
+            size_t written = 0;
+            ::NICONVPrivate::RecodeFromUnicode(encoding, src.data(), dst, src.size(), src.size() * 3, read, written);
+            return TStringBuf(dst, written);
+        }
+
+        template <typename TCharType>
+        inline TBasicStringBuf<TCharType> RecodeUtf8(const TStringBuf src, TCharType* dst) {
+            size_t len = 0;
+            if (!::UTF8ToWide(src.data(), src.size(), dst, len))
+                ythrow yexception() << "Invalid UTF8: \"" << src.SubStr(0, 50) << (src.size() > 50 ? "...\"" : "\"");
+            return TBasicStringBuf<TCharType>(dst, len);
+        }
+
+        template <typename TCharType>
+        inline TStringBuf RecodeUtf8(const TBasicStringBuf<TCharType> src, char* dst) {
+            size_t len = 0;
+            ::WideToUTF8(src.data(), src.size(), dst, len);
+            return TStringBuf(dst, len);
+        }
+
+        // Select one of re-coding methods from above, based on provided @encoding
+
+        template <typename TCharFrom, typename TCharTo>
+        TBasicStringBuf<TCharTo> Recode(const TBasicStringBuf<TCharFrom> src, TCharTo* dst, ECharset encoding) {
+            if (encoding == CODES_UTF8)
+                return RecodeUtf8(src, dst);
+            else if (SingleByteCodepage(encoding))
+                return RecodeSingleByteChar(src, dst, *CodePageByCharset(encoding));
+            else
+                return RecodeMultiByteChar(src, dst, encoding);
+        }
+
+    }
+
+    template <typename TCharFrom>
+    struct TRecodeTraits;
+
+    template <>
+    struct TRecodeTraits<char> {
+        using TCharTo = wchar16;
+        using TStringBufTo = TWtringBuf;
+        using TStringTo = TUtf16String;
+        enum { ReserveSize = 4 }; // How many TCharFrom characters we should reserve for one TCharTo character in worst case
+                                  // Here an unicode character can be converted up to 4 bytes of UTF8
+    };
+
+    template <>
+    struct TRecodeTraits<wchar16> {
+        using TCharTo = char;
+        using TStringBufTo = TStringBuf;
+        using TStringTo = TString;
+        enum { ReserveSize = 2 }; // possible surrogate pairs ?
+    };
+
+    // Operations with destination buffer where recoded string will be written
+    template <typename TResult>
+    struct TRecodeResultOps {
+        // default implementation will work with TString and TUtf16String - 99% of usage
+        using TResultChar = typename TResult::char_type;
+
+        static inline size_t Size(const TResult& dst) {
+            return dst.size();
+        }
+
+        static inline TResultChar* Reserve(TResult& dst, size_t len) {
+            dst.ReserveAndResize(len);
+            return dst.begin();
+        }
+
+        static inline void Truncate(TResult& dst, size_t len) {
+            dst.resize(len);
+        }
+    };
+
+    // Main template interface for recoding in both directions
+
+    template <typename TCharFrom, typename TResult>
+    typename TRecodeTraits<TCharFrom>::TStringBufTo Recode(const TBasicStringBuf<TCharFrom> src, TResult& dst, ECharset encoding) {
+        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo;
+        // make enough room for re-coded string
+        TCharTo* dstbuf = TRecodeResultOps<TResult>::Reserve(dst, src.size() * TRecodeTraits<TCharTo>::ReserveSize);
+        // do re-coding
+        TBasicStringBuf<TCharTo> res = NBaseOps::Recode(src, dstbuf, encoding);
+        // truncate result back to proper size
+        TRecodeResultOps<TResult>::Truncate(dst, res.size());
+        return res;
+    }
+
+    // appending version of Recode()
+    template <typename TCharFrom, typename TResult>
+    typename TRecodeTraits<TCharFrom>::TStringBufTo RecodeAppend(const TBasicStringBuf<TCharFrom> src, TResult& dst, ECharset encoding) {
+        using TCharTo = typename TRecodeTraits<TCharFrom>::TCharTo;
+        size_t dstOrigSize = TRecodeResultOps<TResult>::Size(dst);
+        TCharTo* dstbuf = TRecodeResultOps<TResult>::Reserve(dst, dstOrigSize + src.size() * TRecodeTraits<TCharTo>::ReserveSize);
+        TBasicStringBuf<TCharTo> appended = NBaseOps::Recode(src, dstbuf + dstOrigSize, encoding);
+        size_t dstFinalSize = dstOrigSize + appended.size();
+        TRecodeResultOps<TResult>::Truncate(dst, dstFinalSize);
+        return TBasicStringBuf<TCharTo>(dstbuf, dstFinalSize);
+    }
+
+    // special implementation for robust utf8 functions
+    template <typename TResult>
+    TWtringBuf RecodeUTF8Robust(const TStringBuf src, TResult& dst) {
+        // make enough room for re-coded string
+        wchar16* dstbuf = TRecodeResultOps<TResult>::Reserve(dst, src.size() * TRecodeTraits<wchar16>::ReserveSize);
+
+        // do re-coding
+        size_t written = 0;
+        UTF8ToWide<true>(src.data(), src.size(), dstbuf, written);
+
+        // truncate result back to proper size
+        TRecodeResultOps<TResult>::Truncate(dst, written);
+        return TWtringBuf(dstbuf, written);
+    }
+
+    template <typename TCharFrom>
+    inline typename TRecodeTraits<TCharFrom>::TStringTo Recode(const TBasicStringBuf<TCharFrom> src, ECharset encoding) {
+        typename TRecodeTraits<TCharFrom>::TStringTo res;
+        Recode<TCharFrom>(src, res, encoding);
+        return res;
+    }
+}
+
+// Write result into @dst. Return string-buffer pointing to re-coded content of @dst.
+
+template <bool robust>
+inline TWtringBuf CharToWide(const TStringBuf src, TUtf16String& dst, ECharset encoding) {
+    if (robust && CODES_UTF8 == encoding)
+        return ::NDetail::RecodeUTF8Robust(src, dst);
+    return ::NDetail::Recode<char>(src, dst, encoding);
+}
+
+inline TWtringBuf CharToWide(const TStringBuf src, TUtf16String& dst, ECharset encoding) {
+    return ::NDetail::Recode<char>(src, dst, encoding);
+}
+
+inline TStringBuf WideToChar(const TWtringBuf src, TString& dst, ECharset encoding) {
+    return ::NDetail::Recode<wchar16>(src, dst, encoding);
+}
+
+//! calls either to @c WideToUTF8 or @c WideToChar depending on the encoding type
+inline TString WideToChar(const wchar16* text, size_t len, ECharset enc) {
+    if (NCodepagePrivate::NativeCodepage(enc)) {
+        if (enc == CODES_UTF8)
+            return WideToUTF8(text, len);
+
+        TString s = TString::Uninitialized(len);
+        s.remove(WideToChar(text, len, s.begin(), enc));
+
+        return s;
+    }
+
+    TString s = TString::Uninitialized(len * 3);
+
+    size_t read = 0;
+    size_t written = 0;
+    NICONVPrivate::RecodeFromUnicode(enc, text, s.begin(), len, s.size(), read, written);
+    s.remove(written);
+
+    return s;
+}
+
+inline TUtf16String CharToWide(const char* text, size_t len, const CodePage& cp) {
+    TUtf16String w = TUtf16String::Uninitialized(len);
+    CharToWide(text, len, w.begin(), cp);
+    return w;
+}
+
+//! calls either to @c UTF8ToWide or @c CharToWide depending on the encoding type
+template <bool robust>
+inline TUtf16String CharToWide(const char* text, size_t len, ECharset enc) {
+    if (NCodepagePrivate::NativeCodepage(enc)) {
+        if (enc == CODES_UTF8)
+            return UTF8ToWide<robust>(text, len);
+
+        return CharToWide(text, len, *CodePageByCharset(enc));
+    }
+
+    TUtf16String w = TUtf16String::Uninitialized(len * 2);
+
+    size_t read = 0;
+    size_t written = 0;
+    NICONVPrivate::RecodeToUnicode(enc, text, w.begin(), len, len, read, written);
+    w.remove(written);
+
+    return w;
+}
+
+//! converts text from UTF8 to unicode, if conversion fails it uses codepage to convert the text
+//! @param text     text to be converted
+//! @param len      length of the text in characters
+//! @param cp       a codepage that is used in case of failed conversion from UTF8
+inline TUtf16String UTF8ToWide(const char* text, size_t len, const CodePage& cp) {
+    TUtf16String w = TUtf16String::Uninitialized(len);
+    size_t written = 0;
+    if (UTF8ToWide(text, len, w.begin(), written))
+        w.remove(written);
+    else
+        CharToWide(text, len, w.begin(), cp);
+    return w;
+}
+
+inline TString WideToChar(const TWtringBuf w, ECharset enc) {
+    return WideToChar(w.data(), w.size(), enc);
+}
+
+inline TUtf16String CharToWide(const TStringBuf s, ECharset enc) {
+    return CharToWide<false>(s.data(), s.size(), enc);
+}
+
+template <bool robust>
+inline TUtf16String CharToWide(const TStringBuf s, ECharset enc) {
+    return CharToWide<robust>(s.data(), s.size(), enc);
+}
+
+inline TUtf16String CharToWide(const TStringBuf s, const CodePage& cp) {
+    return CharToWide(s.data(), s.size(), cp);
+}
+
+// true if @text can be fully encoded to specified @encoding,
+// with possibility to recover exact original text after decoding
+bool CanBeEncoded(TWtringBuf text, ECharset encoding);
diff --git a/library/cpp/charset/wide_ut.cpp b/library/cpp/charset/wide_ut.cpp
new file mode 100644
index 0000000000..78947d51ba
--- /dev/null
+++ b/library/cpp/charset/wide_ut.cpp
@@ -0,0 +1,399 @@
+#include "wide.h"
+#include "codepage.h"
+#include "recyr.hh"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/charset/utf8.h>
+#include <util/digest/numeric.h>
+#include <util/generic/hash_set.h>
+
+#include <algorithm>
+
+namespace {
+    //! three UTF8 encoded russian letters (A, B, V)
+    const char yandexCyrillicAlphabet[] =
+        "\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF"  // A - P
+        "\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF"  // R - YA
+        "\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF"  // a - p
+        "\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"; // r - ya
+    const wchar16 wideCyrillicAlphabet[] = {
+        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, 0x00};
+    const char utf8CyrillicAlphabet[] =
+        "\xd0\x90\xd0\x91\xd0\x92\xd0\x93\xd0\x94\xd0\x95\xd0\x96\xd0\x97"
+        "\xd0\x98\xd0\x99\xd0\x9a\xd0\x9b\xd0\x9c\xd0\x9d\xd0\x9e\xd0\x9f"
+        "\xd0\xa0\xd0\xa1\xd0\xa2\xd0\xa3\xd0\xa4\xd0\xa5\xd0\xa6\xd0\xa7"
+        "\xd0\xa8\xd0\xa9\xd0\xaa\xd0\xab\xd0\xac\xd0\xad\xd0\xae\xd0\xaf"
+        "\xd0\xb0\xd0\xb1\xd0\xb2\xd0\xb3\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb7"
+        "\xd0\xb8\xd0\xb9\xd0\xba\xd0\xbb\xd0\xbc\xd0\xbd\xd0\xbe\xd0\xbf"
+        "\xd1\x80\xd1\x81\xd1\x82\xd1\x83\xd1\x84\xd1\x85\xd1\x86\xd1\x87"
+        "\xd1\x88\xd1\x89\xd1\x8a\xd1\x8b\xd1\x8c\xd1\x8d\xd1\x8e\xd1\x8f";
+
+    TString CreateYandexText() {
+        const int len = 256;
+        char text[len] = {0};
+        for (int i = 0; i < len; ++i) {
+            text[i] = static_cast<char>(i);
+        }
+        return TString(text, len);
+    }
+
+    TUtf16String CreateUnicodeText() {
+        const int len = 256;
+        wchar16 text[len] = {
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x00 - 0x0F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x10 - 0x1F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x20 - 0x2F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x30 - 0x3F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x40 - 0x4F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x50 - 0x5F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x60 - 0x6F
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 0x70 - 0x7F
+
+            0x0301, 0x00C4, 0x00D6, 0x00DC, 0x0104, 0x0106, 0x0118, 0x0141, 0x00E0, 0x00E2, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x0490, 0x00AD, // 0x80 - 0x8F
+            0x00DF, 0x00E4, 0x00F6, 0x00FC, 0x0105, 0x0107, 0x0119, 0x0142, 0x00EB, 0x00EE, 0x00EF, 0x00F4, 0x00F9, 0x00FB, 0x0491, 0x92CF, // 0x90 - 0x9F
+            0x00A0, 0x0143, 0x00D3, 0x015A, 0x017B, 0x0179, 0x046C, 0x00A7, 0x0401, 0x0462, 0x0472, 0x0474, 0x040E, 0x0406, 0x0404, 0x0407, // 0xA0 - 0xAF
+            0x00B0, 0x0144, 0x00F3, 0x015B, 0x017C, 0x017A, 0x046D, 0x2116, 0x0451, 0x0463, 0x0473, 0x0475, 0x045E, 0x0456, 0x0454, 0x0457  // 0xB0 - 0xBF
+        };
+        for (int i = 0; i < len; ++i) {
+            if (i <= 0x7F) { // ASCII characters without 0x7 and 0x1B
+                text[i] = static_cast<wchar16>(i);
+            } else if (i >= 0xC0 && i <= 0xFF) {            // russian characters (without YO and yo)
+                text[i] = static_cast<wchar16>(i + 0x0350); // 0x0410 - 0x044F
+            }
+        }
+        return TUtf16String(text, len);
+    }
+
+    TString CreateUTF8Text() {
+        char text[] = {
+            '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
+            '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f',
+            '\x20', '\x21', '\x22', '\x23', '\x24', '\x25', '\x26', '\x27', '\x28', '\x29', '\x2a', '\x2b', '\x2c', '\x2d', '\x2e', '\x2f',
+            '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39', '\x3a', '\x3b', '\x3c', '\x3d', '\x3e', '\x3f',
+            '\x40', '\x41', '\x42', '\x43', '\x44', '\x45', '\x46', '\x47', '\x48', '\x49', '\x4a', '\x4b', '\x4c', '\x4d', '\x4e', '\x4f',
+            '\x50', '\x51', '\x52', '\x53', '\x54', '\x55', '\x56', '\x57', '\x58', '\x59', '\x5a', '\x5b', '\x5c', '\x5d', '\x5e', '\x5f',
+            '\x60', '\x61', '\x62', '\x63', '\x64', '\x65', '\x66', '\x67', '\x68', '\x69', '\x6a', '\x6b', '\x6c', '\x6d', '\x6e', '\x6f',
+            '\x70', '\x71', '\x72', '\x73', '\x74', '\x75', '\x76', '\x77', '\x78', '\x79', '\x7a', '\x7b', '\x7c', '\x7d', '\x7e', '\x7f',
+            '\xcc', '\x81', '\xc3', '\x84', '\xc3', '\x96', '\xc3', '\x9c', '\xc4', '\x84', '\xc4', '\x86', '\xc4', '\x98', '\xc5', '\x81',
+            '\xc3', '\xa0', '\xc3', '\xa2', '\xc3', '\xa7', '\xc3', '\xa8', '\xc3', '\xa9', '\xc3', '\xaa', '\xd2', '\x90', '\xc2', '\xad',
+            '\xc3', '\x9f', '\xc3', '\xa4', '\xc3', '\xb6', '\xc3', '\xbc', '\xc4', '\x85', '\xc4', '\x87', '\xc4', '\x99', '\xc5', '\x82',
+            '\xc3', '\xab', '\xc3', '\xae', '\xc3', '\xaf', '\xc3', '\xb4', '\xc3', '\xb9', '\xc3', '\xbb', '\xd2', '\x91', '\xe9', '\x8b',
+            '\x8f', '\xc2', '\xa0', '\xc5', '\x83', '\xc3', '\x93', '\xc5', '\x9a', '\xc5', '\xbb', '\xc5', '\xb9', '\xd1', '\xac', '\xc2',
+            '\xa7', '\xd0', '\x81', '\xd1', '\xa2', '\xd1', '\xb2', '\xd1', '\xb4', '\xd0', '\x8e', '\xd0', '\x86', '\xd0', '\x84', '\xd0',
+            '\x87', '\xc2', '\xb0', '\xc5', '\x84', '\xc3', '\xb3', '\xc5', '\x9b', '\xc5', '\xbc', '\xc5', '\xba', '\xd1', '\xad', '\xe2',
+            '\x84', '\x96', '\xd1', '\x91', '\xd1', '\xa3', '\xd1', '\xb3', '\xd1', '\xb5', '\xd1', '\x9e', '\xd1', '\x96', '\xd1', '\x94',
+            '\xd1', '\x97', '\xd0', '\x90', '\xd0', '\x91', '\xd0', '\x92', '\xd0', '\x93', '\xd0', '\x94', '\xd0', '\x95', '\xd0', '\x96',
+            '\xd0', '\x97', '\xd0', '\x98', '\xd0', '\x99', '\xd0', '\x9a', '\xd0', '\x9b', '\xd0', '\x9c', '\xd0', '\x9d', '\xd0', '\x9e',
+            '\xd0', '\x9f', '\xd0', '\xa0', '\xd0', '\xa1', '\xd0', '\xa2', '\xd0', '\xa3', '\xd0', '\xa4', '\xd0', '\xa5', '\xd0', '\xa6',
+            '\xd0', '\xa7', '\xd0', '\xa8', '\xd0', '\xa9', '\xd0', '\xaa', '\xd0', '\xab', '\xd0', '\xac', '\xd0', '\xad', '\xd0', '\xae',
+            '\xd0', '\xaf', '\xd0', '\xb0', '\xd0', '\xb1', '\xd0', '\xb2', '\xd0', '\xb3', '\xd0', '\xb4', '\xd0', '\xb5', '\xd0', '\xb6',
+            '\xd0', '\xb7', '\xd0', '\xb8', '\xd0', '\xb9', '\xd0', '\xba', '\xd0', '\xbb', '\xd0', '\xbc', '\xd0', '\xbd', '\xd0', '\xbe',
+            '\xd0', '\xbf', '\xd1', '\x80', '\xd1', '\x81', '\xd1', '\x82', '\xd1', '\x83', '\xd1', '\x84', '\xd1', '\x85', '\xd1', '\x86',
+            '\xd1', '\x87', '\xd1', '\x88', '\xd1', '\x89', '\xd1', '\x8a', '\xd1', '\x8b', '\xd1', '\x8c', '\xd1', '\x8d', '\xd1', '\x8e',
+            '\xd1', '\x8f'};
+        return TString(text, Y_ARRAY_SIZE(text));
+    }
+
+    //! use this function to dump UTF8 text into a file in case of any changes
+    //    void DumpUTF8Text() {
+    //        TString s = WideToUTF8(UnicodeText);
+    //        std::ofstream f("utf8.txt");
+    //        f << std::hex;
+    //        for (int i = 0; i < (int)s.size(); ++i) {
+    //            f << "0x" << std::setw(2) << std::setfill('0') << (int)(ui8)s[i] << ", ";
+    //            if ((i + 1) % 16 == 0)
+    //                f << std::endl;
+    //        }
+    //    }
+
+}
+
+//! this unit tests ensure validity of Yandex-Unicode and UTF8-Unicode conversions
+//! @note only those conversions are verified because they are used in index
+class TConversionTest: public TTestBase {
+private:
+    //! @note every of the text can have zeros in the middle
+    const TString YandexText;
+    const TUtf16String UnicodeText;
+    const TString UTF8Text;
+
+private:
+    UNIT_TEST_SUITE(TConversionTest);
+    UNIT_TEST(TestCharToWide);
+    UNIT_TEST(TestWideToChar);
+    UNIT_TEST(TestYandexEncoding);
+    UNIT_TEST(TestRecodeIntoString);
+    UNIT_TEST(TestRecodeAppend);
+    UNIT_TEST(TestRecode);
+    UNIT_TEST(TestUnicodeLimit);
+    UNIT_TEST_SUITE_END();
+
+public:
+    TConversionTest()
+        : YandexText(CreateYandexText())
+        , UnicodeText(CreateUnicodeText())
+        , UTF8Text(CreateUTF8Text())
+    {
+    }
+
+    void TestCharToWide();
+    void TestWideToChar();
+    void TestYandexEncoding();
+    void TestRecodeIntoString();
+    void TestRecodeAppend();
+    void TestRecode();
+    void TestUnicodeLimit();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TConversionTest);
+
+// test conversions (char -> wchar32), (wchar32 -> char) and (wchar32 -> wchar16)
+#define TEST_WCHAR32(sbuf, wbuf, enc)                                                                                                 \
+    do {                                                                                                                              \
+        /* convert char to wchar32 */                                                                                                 \
+        TTempBuf tmpbuf1(sbuf.length() * sizeof(wchar32));                                                                            \
+        const TBasicStringBuf<wchar32> s4buf = NDetail::NBaseOps::Recode<char>(sbuf, reinterpret_cast<wchar32*>(tmpbuf1.Data()), enc); \
+                                                                                                                                      \
+        /* convert wchar32 to char */                                                                                                 \
+        TTempBuf tmpbuf2(s4buf.length() * 4);                                                                                         \
+        const TStringBuf s1buf = NDetail::NBaseOps::Recode(s4buf, tmpbuf2.Data(), enc);                                               \
+                                                                                                                                      \
+        /* convert wchar32 to wchar16 */                                                                                              \
+        const TUtf16String wstr2 = UTF32ToWide(s4buf.data(), s4buf.length());                                                         \
+                                                                                                                                      \
+        /* test conversions */                                                                                                        \
+        UNIT_ASSERT_VALUES_EQUAL(sbuf, s1buf);                                                                                        \
+        UNIT_ASSERT_VALUES_EQUAL(wbuf, wstr2);                                                                                        \
+    } while (false)
+
+void TConversionTest::TestCharToWide() {
+    TUtf16String w = CharToWide(YandexText, CODES_YANDEX);
+
+    UNIT_ASSERT(w.size() == 256);
+    UNIT_ASSERT(w.size() == UnicodeText.size());
+
+    for (int i = 0; i < 256; ++i) {
+        UNIT_ASSERT_VALUES_EQUAL(w[i], UnicodeText[i]);
+    }
+}
+
+void TConversionTest::TestWideToChar() {
+    TString s = WideToChar(UnicodeText, CODES_YANDEX);
+
+    UNIT_ASSERT(s.size() == 256);
+    UNIT_ASSERT(s.size() == YandexText.size());
+
+    for (int i = 0; i < 256; ++i) {
+        UNIT_ASSERT_VALUES_EQUAL(s[i], YandexText[i]);
+    }
+}
+
+static void TestSurrogates(const char* str, const wchar16* wide, size_t wideSize, ECharset enc) {
+    TUtf16String w = UTF8ToWide(str);
+
+    UNIT_ASSERT(w.size() == wideSize);
+    UNIT_ASSERT(!memcmp(w.c_str(), wide, wideSize));
+
+    TString s = WideToChar(w, enc);
+
+    UNIT_ASSERT(s == str);
+}
+
+void TConversionTest::TestYandexEncoding() {
+    TUtf16String w = UTF8ToWide(utf8CyrillicAlphabet, strlen(utf8CyrillicAlphabet), csYandex);
+    UNIT_ASSERT(w == wideCyrillicAlphabet);
+    w = UTF8ToWide(yandexCyrillicAlphabet, strlen(yandexCyrillicAlphabet), csYandex);
+    UNIT_ASSERT(w == wideCyrillicAlphabet);
+
+    const char* utf8NonBMP2 = "ab\xf4\x80\x89\x87n";
+    wchar16 wNonBMPDummy2[] = {'a', 'b', 0xDBC0, 0xDE47, 'n'};
+    TestSurrogates(utf8NonBMP2, wNonBMPDummy2, Y_ARRAY_SIZE(wNonBMPDummy2), CODES_UTF8);
+
+    {
+        const char* yandexNonBMP2 = "ab?n";
+        UNIT_ASSERT(yandexNonBMP2 == WideToChar(wNonBMPDummy2, Y_ARRAY_SIZE(wNonBMPDummy2), CODES_YANDEX));
+
+        TString temp;
+        temp.resize(Y_ARRAY_SIZE(wNonBMPDummy2));
+        size_t read = 0;
+        size_t written = 0;
+        RecodeFromUnicode(CODES_YANDEX, wNonBMPDummy2, temp.begin(), Y_ARRAY_SIZE(wNonBMPDummy2), temp.size(), read, written);
+        temp.remove(written);
+
+        UNIT_ASSERT(yandexNonBMP2 == temp);
+    }
+}
+
+void TConversionTest::TestRecodeIntoString() {
+    TString sYandex(UnicodeText.size() * 4, 'x');
+    const char* sdata = sYandex.data();
+    TStringBuf sres = NDetail::Recode<wchar16>(UnicodeText, sYandex, CODES_YANDEX);
+    UNIT_ASSERT(sYandex == YandexText); // same content
+    UNIT_ASSERT(sYandex.data() == sdata);     // reserved buffer reused
+    UNIT_ASSERT(sYandex.data() == sres.data());     // same buffer
+    UNIT_ASSERT(sYandex.size() == sres.size());     // same size
+    TEST_WCHAR32(sYandex, UnicodeText, CODES_YANDEX);
+
+    TUtf16String sUnicode;
+    sUnicode.reserve(YandexText.size() * 4);
+    const wchar16* wdata = sUnicode.data();
+    TWtringBuf wres = NDetail::Recode<char>(YandexText, sUnicode, CODES_YANDEX);
+    UNIT_ASSERT(sUnicode == UnicodeText); // same content
+    UNIT_ASSERT(sUnicode.data() == wdata);      // reserved buffer reused
+    UNIT_ASSERT(sUnicode.data() == wres.data());      // same buffer
+    UNIT_ASSERT(sUnicode.size() == wres.size());      // same size
+
+    TString sUtf8 = " ";
+    size_t scap = sUtf8.capacity();
+    sres = NDetail::Recode<wchar16>(UnicodeText, sUtf8, CODES_UTF8);
+    UNIT_ASSERT(sUtf8 == UTF8Text);       // same content
+    UNIT_ASSERT(sUtf8.capacity() > scap); // increased buffer capacity (supplied was too small)
+    UNIT_ASSERT(sUtf8.data() == sres.data());         // same buffer
+    UNIT_ASSERT(sUtf8.size() == sres.size());         // same size
+    TEST_WCHAR32(sUtf8, UnicodeText, CODES_UTF8);
+
+    sUnicode.clear();
+    wdata = sUnicode.data();
+    TUtf16String copy = sUnicode; // increase ref-counter
+    wres = NDetail::Recode<char>(UTF8Text, sUnicode, CODES_UTF8);
+    UNIT_ASSERT(sUnicode == UnicodeText); // same content
+#ifndef TSTRING_IS_STD_STRING
+    UNIT_ASSERT(sUnicode.data() != wdata);      // re-allocated (shared buffer supplied)
+    UNIT_ASSERT(sUnicode.data() == wres.data());      // same buffer
+#endif
+    UNIT_ASSERT(sUnicode.size() == wres.size());      // same content
+}
+
+static TString GenerateJunk(size_t seed) {
+    TString res;
+    size_t hash = NumericHash(seed);
+    size_t size = hash % 1024;
+    res.reserve(size);
+    for (size_t i = 0; i < size; ++i)
+        res += static_cast<char>(NumericHash(hash + i) % 256);
+    return res;
+}
+
+void TConversionTest::TestRecodeAppend() {
+    {
+        TString s1, s2;
+        NDetail::RecodeAppend<wchar16>(TUtf16String(), s1, CODES_YANDEX);
+        UNIT_ASSERT(s1.empty());
+
+        NDetail::RecodeAppend<wchar16>(UnicodeText, s1, CODES_WIN);
+        s2 += WideToChar(UnicodeText, CODES_WIN);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<wchar16>(UnicodeText, s1, CODES_YANDEX);
+        s2 += WideToChar(UnicodeText, CODES_YANDEX);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<wchar16>(TUtf16String(), s1, CODES_YANDEX);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<wchar16>(UnicodeText, s1, CODES_UTF8);
+        s2 += WideToUTF8(UnicodeText);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        for (size_t i = 0; i < 100; ++i) {
+            TUtf16String junk = CharToWide(GenerateJunk(i), CODES_YANDEX);
+            NDetail::RecodeAppend<wchar16>(junk, s1, CODES_UTF8);
+            s2 += WideToUTF8(junk);
+            UNIT_ASSERT_EQUAL(s1, s2);
+        }
+    }
+
+    {
+        TUtf16String s1, s2;
+        NDetail::RecodeAppend<char>(TString(), s1, CODES_YANDEX);
+        UNIT_ASSERT(s1.empty());
+
+        NDetail::RecodeAppend<char>(YandexText, s1, CODES_WIN);
+        s2 += CharToWide(YandexText, CODES_WIN);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<char>(YandexText, s1, CODES_YANDEX);
+        s2 += CharToWide(YandexText, CODES_YANDEX);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<char>(TString(), s1, CODES_YANDEX);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        NDetail::RecodeAppend<char>(UTF8Text, s1, CODES_UTF8);
+        s2 += UTF8ToWide(UTF8Text);
+        UNIT_ASSERT_EQUAL(s1, s2);
+
+        for (size_t i = 0; i < 100; ++i) {
+            TString junk = GenerateJunk(i);
+            NDetail::RecodeAppend<char>(junk, s1, CODES_YANDEX);
+            s2 += CharToWide(junk, CODES_YANDEX);
+            UNIT_ASSERT_EQUAL(s1, s2);
+        }
+    }
+}
+
+template <>
+void Out<RECODE_RESULT>(IOutputStream& out, RECODE_RESULT val) {
+    out << int(val);
+}
+
+void TConversionTest::TestRecode() {
+    for (int c = 0; c != CODES_MAX; ++c) {
+        ECharset enc = static_cast<ECharset>(c);
+        if (!SingleByteCodepage(enc))
+            continue;
+
+        using THash = THashSet<char>;
+        THash hash;
+
+        for (int i = 0; i != 256; ++i) {
+            char ch = static_cast<char>(i);
+
+            wchar32 wch;
+            size_t read = 0;
+            size_t written = 0;
+            RECODE_RESULT res = RECODE_ERROR;
+
+            res = RecodeToUnicode(enc, &ch, &wch, 1, 1, read, written);
+            UNIT_ASSERT(res == RECODE_OK);
+            if (wch == BROKEN_RUNE)
+                continue;
+
+            char rch = 0;
+            res = RecodeFromUnicode(enc, &wch, &rch, 1, 1, read, written);
+            UNIT_ASSERT(res == RECODE_OK);
+
+            char rch2 = 0;
+            UNIT_ASSERT_VALUES_EQUAL(RECODE_OK, RecodeFromUnicode(enc, wch, &rch2, 1, written));
+            UNIT_ASSERT_VALUES_EQUAL(size_t(1), written);
+            UNIT_ASSERT_VALUES_EQUAL(rch2, rch);
+
+            if (hash.contains(rch)) { // there are some stupid encodings with duplicate characters
+                continue;
+            } else {
+                hash.insert(rch);
+            }
+
+            UNIT_ASSERT(ch == rch);
+        }
+    }
+}
+
+void TConversionTest::TestUnicodeLimit() {
+    for (int i = 0; i != CODES_MAX; ++i) {
+        ECharset code = static_cast<ECharset>(i);
+        if (!SingleByteCodepage(code))
+            continue;
+
+        const CodePage* page = CodePageByCharset(code);
+        Y_ASSERT(page);
+
+        for (int c = 0; c < 256; ++c) {
+            UNIT_ASSERT(page->unicode[c] < 1 << 16);
+        }
+    }
+}
diff --git a/library/cpp/charset/ya.make b/library/cpp/charset/ya.make
new file mode 100644
index 0000000000..7565566bf0
--- /dev/null
+++ b/library/cpp/charset/ya.make
@@ -0,0 +1,22 @@
+LIBRARY()
+
+OWNER(alzobnin)
+
+SRCS(
+    generated/cp_data.cpp
+    generated/encrec_data.cpp
+    codepage.cpp
+    cp_encrec.cpp
+    doccodes.cpp
+    iconv.cpp
+    recyr.hh
+    recyr_int.hh
+    ci_string.cpp
+    wide.cpp
+)
+
+PEERDIR(
+    contrib/libs/libiconv
+)
+
+END()
author	Devtools Arcadia <arcadia-devtools@yandex-team.ru>	2022-02-07 18:08:42 +0300
committer	Devtools Arcadia <arcadia-devtools@mous.vla.yp-c.yandex.net>	2022-02-07 18:08:42 +0300
commit	1110808a9d39d4b808aef724c861a2e1a38d2a69 (patch)
tree	e26c9fed0de5d9873cce7e00bc214573dc2195b7 /library/cpp/charset
download	ydb-1110808a9d39d4b808aef724c861a2e1a38d2a69.tar.gz