move to my github.

30 files changed, 28350 insertions, 0 deletions

diff --git a/src/fqterm/3rdparty/dotnetstyle.cpp b/src/fqterm/3rdparty/dotnetstyle.cpp
new file mode 100644
index 0000000..d016ff2
--- /dev/null
+++ b/src/fqterm/3rdparty/dotnetstyle.cpp
@@ -0,0 +1,1274 @@
+/****************************************************************************
+**
+** Copyright (C) 2007-2007 Trolltech ASA. All rights reserved.
+**
+** This file is part of the DotNetStyle project on Trolltech Labs.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#ifdef USE_DOTNET_STYLE
+#include "dotnetstyle.h"
+#include <QStyleOption>
+#include <QPainter>
+#include <QMainWindow>
+#include <QDockWidget>
+#include <QDialogButtonBox>
+#include <QToolBar>
+#include <QDialog>
+#include <QLineEdit>
+#include <QComboBox>
+#include <QLibrary>
+#include <QStatusBar>
+#include <QApplication>
+#include <qt_windows.h>
+
+typedef bool (WINAPI *PtrIsAppThemed)();
+typedef HRESULT (WINAPI *PtrGetCurrentThemeName)(OUT LPWSTR pszThemeFileName, int cchMaxNameChars, OUT OPTIONAL LPWSTR pszColorBuff, int                   cchMaxColorChars, OUT OPTIONAL LPWSTR pszSizeBuff, int cchMaxSizeChars);
+
+static PtrIsAppThemed pIsAppThemed = 0;
+static PtrGetCurrentThemeName pGetCurrentThemeName = 0;
+
+static const int windowsItemFrame       =  2; // menu item frame width
+static const int windowsSepHeight       =  9; // separator item height
+static const int windowsItemHMargin     =  3; // menu item hor text margin
+static const int windowsItemVMargin     =  2; // menu item ver text margin
+static const int windowsArrowHMargin	=  6; // arrow horizontal margin
+static const int windowsRightBorder     = 15; // right border on windows
+
+class DotNetStylePrivate
+{
+public:
+    DotNetStylePrivate()
+    {
+        QLibrary themeLib("uxtheme");
+        themeLib.load();
+        if (themeLib.isLoaded()) {  //resolve uxtheme functions
+            pIsAppThemed            = (PtrIsAppThemed)themeLib.resolve("IsAppThemed");
+            pGetCurrentThemeName    = (PtrGetCurrentThemeName)themeLib.resolve("GetCurrentThemeName");
+        }
+    }
+    ~DotNetStylePrivate()
+    {}
+
+    enum InternalPalette {
+        Blue,
+        Silver,
+        Olive,
+        System,
+        Classic
+    };
+
+    void init();
+    QColor gradientDarkColor(const QStyleOption *option) const;
+    QColor gradientLightColor(const QStyleOption *option) const;
+    QColor highlightOutlineColor(const QStyleOption *option, bool act) const;
+    QColor shadowColor(const QStyleOption *option) const;
+    QBrush highlightBrush(const QStyleOption *option, bool act) const;
+    QBrush highlightMenuCheckBrush(const QStyleOption *option, bool act) const;
+    QLinearGradient toolbarGradient(const QStyleOption *option, QRect rect, Qt::Orientation orientaion) const;
+    QLinearGradient menuGradient(const QStyleOption *option, QRect rect, Qt::Orientation orientaion) const;
+    void updatePalette();
+
+    QColor menuSeparatorColor;
+    QColor menuBackgroundColor;
+    QColor menuFrameColor;
+    InternalPalette internalPalette;    //internal color theme
+    DotNetStyle::ColorTheme theme;    //external color theme
+    QPalette currentPal;                //used to detect system palette changes
+ };
+
+
+
+inline QColor DotNetStylePrivate::gradientDarkColor(const QStyleOption *option) const {
+    QColor color = option->palette.background().color();
+    switch (internalPalette) {
+    case Olive:
+        color = QColor(217, 217, 167);
+        break;
+    case Blue:
+        color = QColor(158, 190, 245);
+        break;
+    case Silver:
+        color = QColor(216, 216, 229);
+        break;
+    default:
+        break;
+    }
+    return color;
+}
+
+inline QColor DotNetStylePrivate::gradientLightColor(const QStyleOption *option) const {
+    QColor color = option->palette.background().color().lighter(106);
+    switch (internalPalette) {
+    case Olive:
+        color = QColor(241, 240, 227);
+        break;
+    case Blue:
+        color = QColor(196, 217, 249);
+        break;
+    case Silver:
+        color = QColor(242, 242, 247);
+        break;
+    case Classic:
+        color = option->palette.light().color().lighter(106);
+    default:
+        break;
+    }
+    return color;
+}
+
+inline QColor DotNetStylePrivate::shadowColor(const QStyleOption *option) const {
+    QColor color;
+    switch (internalPalette) {
+    case Blue:
+        color = QColor(59, 97, 156);
+        break;
+    case Silver:
+        color = QColor(124, 124, 148);
+        break;
+    case Olive:
+        color = QColor(96, 128, 88);
+        break;
+    case Classic:
+        color = option->palette.background().color();
+        break;
+    default:
+        color = option->palette.dark().color();
+        break;
+    }
+    return color;
+}
+
+inline QColor DotNetStylePrivate::highlightOutlineColor(const QStyleOption *option, bool act = false) const {
+    QColor color;
+    switch (internalPalette) {
+    case Blue:
+        color = QColor(0, 0, 128);
+        break;
+    case Silver:
+        color = QColor(75, 75, 111);
+        break;
+    case Olive:
+        color = QColor(63, 93, 56);
+        break;
+    default:
+        if (act)
+            return option->palette.highlight().color().darker(110);
+        else
+            return option->palette.highlight().color().lighter(110);
+        break;
+    }
+    return color;
+}
+
+QBrush DotNetStylePrivate::highlightBrush(const QStyleOption *option, bool act) const {
+    QBrush brush;
+    QColor highlight;
+    switch (internalPalette) {
+    case Silver:
+    case Olive:
+    case Blue:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+            brush = QColor(255, 238, 194);
+        } else {
+            QLinearGradient gradient(option->rect.topLeft(), option->rect.bottomLeft());
+            if (act) {
+                gradient.setColorAt(0, QColor(254, 149, 82));
+                gradient.setColorAt(1, QColor(255, 211, 142));
+            } else {
+                gradient.setColorAt(0, QColor(255, 252, 200));
+                gradient.setColorAt(1, QColor(255, 208, 145));
+            }
+            brush = gradient;
+        }
+        break;
+    default:
+        highlight = option->palette.highlight().color().lighter(120);
+        if (act)
+            highlight.setHsv(highlight.hue(), 70, 220);
+        else
+            highlight.setHsv(highlight.hue(), 40, 230);
+        brush = QBrush(highlight);
+        break;
+    }
+    return brush;
+}
+
+QBrush DotNetStylePrivate::highlightMenuCheckBrush(const QStyleOption *option, bool act) const {
+    QBrush brush;
+    QColor highlight;
+
+    switch (internalPalette) {
+    case Silver:
+    case Olive:
+    case Blue:
+        if (act)
+            brush = QColor(254, 128, 62);
+        else
+            brush = QColor(255, 192, 111);
+        break;
+    default:
+        highlight = option->palette.highlight().color().lighter(120);
+        if (act)
+            highlight.setHsv(highlight.hue(), 120, 180);
+        else {
+            highlight.setHsv(highlight.hue(), 30, 230);
+        }
+        highlight.setAlpha(170);
+        brush = highlight;
+        break;
+    }
+    return brush;
+}
+
+QLinearGradient DotNetStylePrivate::toolbarGradient(const QStyleOption *option, QRect rect, Qt::Orientation orientation= Qt::Vertical) const {
+    QLinearGradient gradient(rect.topLeft(), orientation == Qt::Vertical ? rect.topRight() : rect.bottomLeft());
+    QColor start, stop;
+    switch (internalPalette)
+    {
+        case Blue:
+            start = QColor(220, 235, 254);
+            stop = QColor(129, 169, 226);
+            gradient.setColorAt(0.3, start);
+            break;
+        case Silver:
+            start = QColor(242, 242, 249);
+            stop = QColor(153, 151, 181);
+            gradient.setColorAt(0.3, start);
+            break;
+        case Olive:
+            start = QColor(241, 245, 217);
+            stop = QColor(183, 198, 145);
+            gradient.setColorAt(0.0, start);
+            break;
+        default:
+            start = option->palette.light().color();
+            if (internalPalette == Classic)
+                start = start.lighter(130);
+            start.setAlpha(180);
+            stop = option->palette.button().color();
+            stop.setHsv(stop.hue(), qMin(stop.saturation()*2, 255), (stop.value()*2)/3);
+            stop.setAlpha(128);
+            if (internalPalette == Classic)
+                stop.setAlpha(0);
+            gradient.setColorAt(0.3, start);
+            break;
+    }
+    gradient.setColorAt(1, stop);
+    return gradient;
+}
+
+
+QLinearGradient DotNetStylePrivate::menuGradient(const QStyleOption *option, QRect rect, Qt::Orientation orientaion = Qt::Horizontal) const {
+
+    QColor start, stop;
+    QLinearGradient grad;
+    if (orientaion == Qt::Vertical) {
+        grad.setStart(rect.left(), rect.top());
+        grad.setFinalStop(rect.left(), rect.bottom());
+    } else {
+        grad.setStart(QPoint(rect.left(), 0));
+        grad.setFinalStop(QPoint(rect.left() + 24, 0));
+    }
+    switch (internalPalette)
+    {
+        case Blue:
+            start = QColor(220, 235, 254);
+            stop = QColor(129, 169, 226);
+            grad.setColorAt(0.3, start);
+            break;
+        case Olive:
+            start = QColor(246, 248, 224);
+            stop = QColor(186, 201, 148);
+            grad.setColorAt(0.0, start);
+            break;
+        case Silver:
+            start = QColor(215, 215, 226);
+            stop = QColor(138, 137, 166);
+            grad.setColorAt(0.4, start);
+            break;
+        default:
+            start = option->palette.brush(QPalette::Active, QPalette::Base).color();
+            stop = gradientDarkColor(option);
+            stop.setHsv(stop.hue(), qMin((int)(stop.saturation()*1.2), 255), (5*stop.value()/7));
+            if (internalPalette == Classic)
+                stop.setAlpha(120);
+            grad.setColorAt(0, start);
+            break;
+    }
+    grad.setColorAt(1, stop);
+    return grad;
+}
+
+
+
+/*!
+    \class DotNetStyle qtdotnetstyle.h
+    \brief The DotNetStyle class provides an alternative, modern look for Qt applications on Windows.
+
+    The GUI look is very similar to the style introduced in
+    Visual Studio 2005, Office 2003 as well as in .NET Windows
+    Forms (when the RenderMode is set to "Professional"
+    instead of "System"). It gives applications a modern
+    gradient appearance for tool bars and menus while
+    retaining the native look and feel for other widgets.
+
+    The style supports different color themes, which may be specified in
+    the constructor. The default is \c Standard color theme.
+
+    This is the textedit example running with the Standard style:
+    \img dotnetstyle.png
+
+    This is the textedit example running with the Office style:
+    \img dotnetstyle2.png
+
+    \sa QStyle, QWindowsVistaStyle, QWindowsXPStyle
+*/
+
+
+/*!
+    \enum DotNetStyle::ColorTheme
+
+    This enum describes the different color schemes supported by the style.
+
+    \value Standard Use gradients based on the operating system palette.
+    \value Office Use Microsoft Office 2003 style gradients.
+*/
+
+/*!
+    Constructs a DotNetStyle object which uses the default color
+    theme (\c Office).
+*/
+DotNetStyle::DotNetStyle()
+: QWindowsVistaStyle(), d(new DotNetStylePrivate())
+{
+    d->theme = Office;
+}
+
+
+/*!
+    Constructs a DotNetStyle object which uses the color theme \a
+    colortheme.
+*/
+DotNetStyle::DotNetStyle(ColorTheme colortheme)
+    : QWindowsVistaStyle(), d(new DotNetStylePrivate())
+{
+    d->theme = colortheme;
+}
+
+
+/*!
+    Destroys the DotNetStyle object.
+*/
+DotNetStyle::~DotNetStyle()
+{
+    delete d;
+}
+
+
+/*!
+ \reimp
+ */
+void DotNetStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
+                                    QPainter *painter, const QWidget *widget) const
+{
+    QColor gradientDark = d->gradientDarkColor(option);
+    QColor gradientLight = d->gradientLightColor(option);
+    QColor shadow = d->shadowColor(option);
+
+    QRect rect = option->rect;
+    switch (element) {
+    case PE_IndicatorDockWidgetResizeHandle:
+        break;
+    case PE_PanelLineEdit:
+        if (widget && qobject_cast<QToolBar*>(widget->parentWidget())) {
+            QRect rect = option->rect.adjusted(2, 1, -2, -2);
+            painter->save();
+            bool active = option->state & State_Active &&
+                            ((option->state & State_MouseOver)
+                            || (option->state & State_HasFocus));
+            QBrush editBrush = option->palette.brush(QPalette::Base);
+            painter->setPen(QPen(editBrush.color()));
+            painter->fillRect(rect, editBrush);
+
+            QRect re = option->rect ;
+            if (active) {
+                painter->setPen(d->highlightOutlineColor(option));
+                painter->drawRect(rect);
+            }
+            painter->restore();
+        } else {
+            if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+                QWindowsVistaStyle::drawPrimitive(element, option, painter, widget);
+            else
+                QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+        }
+    case PE_PanelButtonTool:
+        {
+            QStyleOption opt2 = *option;
+            if (widget)
+                if(QDockWidget *dw = qobject_cast<QDockWidget *>(widget->parentWidget())) {
+                    if (!dw->isFloating())
+                        opt2.palette.setBrush(QPalette::Button, Qt::transparent);
+                }
+            if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+                QWindowsVistaStyle::drawPrimitive(element, &opt2, painter, widget);
+            else
+                QWindowsXPStyle::drawPrimitive(element, &opt2, painter, widget);
+        }
+        break;
+    case PE_FrameMenu:
+        {
+            QPen pen = painter->pen();
+            QBrush brush = painter->brush();
+            if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar*>(option))
+            {
+                Qt::Orientation orientation =(toolbar->toolBarArea == Qt::RightToolBarArea ||
+                                              toolbar->toolBarArea == Qt::LeftToolBarArea) ? 
+                                              Qt::Vertical : Qt::Horizontal;
+                painter->setBrush(d->toolbarGradient(toolbar, toolbar->rect, orientation));
+            } else {
+                painter->setBrush(d->menuBackgroundColor);
+            }
+            painter->setPen(d->menuFrameColor);
+            painter->drawRect(option->rect.adjusted(0, 0, -1, -1));
+            painter->setPen(pen);
+            painter->setBrush(brush);
+        }
+        break;
+    case PE_Widget:
+        if (const QMainWindow *mw = qobject_cast<const QMainWindow *>(widget)) {
+            if (d->currentPal != qApp->palette()) //workaround for style polish on theme color change
+            {
+                d->currentPal = qApp->palette();
+                d->updatePalette();
+            }
+            painter->save();
+            QPoint begin = widget->geometry().topRight();
+            QPoint end = widget->geometry().topLeft() + QPoint(0, widget->geometry().height()/2);
+            begin = widget->mapFromGlobal(begin);
+            end = widget->mapFromGlobal(end);
+            QLinearGradient menubargradient(begin, end);
+            menubargradient.setColorAt(0, gradientLight);
+            if (d->internalPalette == DotNetStylePrivate::System)
+                menubargradient.setColorAt(0.3, gradientDark);
+            else
+                menubargradient.setColorAt(0.8, gradientDark);
+            menubargradient.setColorAt(1, gradientDark);
+            QRect windowRect = option->rect;
+            if (QStatusBar *statusBar = mw->findChild<QStatusBar*>()) {
+                windowRect.adjust(0, 0, 0, -statusBar->height());
+                painter->setPen(option->palette.background().color().lighter(106));
+                painter->drawLine(windowRect.bottomLeft() + QPoint(0, 1),
+                                    windowRect.bottomRight() + QPoint(0, 1));
+            }
+            painter->fillRect(windowRect, menubargradient);
+            painter->restore();
+        }
+        break;
+    case PE_IndicatorToolBarSeparator:
+        {
+            QRect rect = option->rect;
+            shadow.setAlpha(180);
+            painter->setPen(shadow);
+            const int margin = 3;
+            if (option->state & State_Horizontal) {
+                const int offset = rect.width()/2;
+                painter->drawLine(rect.bottomLeft().x() + offset,
+                            rect.bottomLeft().y() - margin,
+                            rect.topLeft().x() + offset,
+                            rect.topLeft().y() + margin);
+                painter->setPen(QPen(option->palette.background().color().light(110)));
+                painter->drawLine(rect.bottomLeft().x() + offset + 1,
+                            rect.bottomLeft().y() - margin,
+                            rect.topLeft().x() + offset + 1,
+                            rect.topLeft().y() + margin);
+            } else { //Draw vertical separator
+                const int offset = rect.height()/2;
+                painter->setPen(QPen(option->palette.background().color().dark(110)));
+                painter->drawLine(rect.topLeft().x() + margin ,
+                            rect.topLeft().y() + offset,
+                            rect.topRight().x() - margin,
+                            rect.topRight().y() + offset);
+                painter->setPen(QPen(option->palette.background().color().light(110)));
+                painter->drawLine(rect.topLeft().x() + margin ,
+                            rect.topLeft().y() + offset + 1,
+                            rect.topRight().x() - margin,
+                            rect.topRight().y() + offset + 1);
+            }
+        }
+        break;
+    case PE_IndicatorToolBarHandle:
+        painter->save();
+        {
+            QColor gripColor = shadow;
+            if (d->internalPalette != DotNetStylePrivate::System)
+                gripColor = shadow.darker(120);
+            if (option->state & State_Horizontal) {
+                for (int i = rect.height()/5; i <= 4*(rect.height()/5) ; i+=4) {
+                    int y = rect.topLeft().y() + i + 1;
+                    int x1 = rect.topLeft().x() + 3;
+                    painter->fillRect(x1 + 1, y, 2, 2, Qt::white);
+                    painter->fillRect(x1, y - 1, 2, 2, gripColor);
+                }
+            }
+            else { //vertical toolbar
+                for (int i = rect.width()/5; i <= 4*(rect.width()/5) ; i+=4) {
+                    int x = rect.topLeft().x() + i + 1;
+                    int y1 = rect.topLeft().y() + 3;
+                    painter->fillRect(x , y1 + 1, 2, 2, Qt::white);
+                    painter->fillRect(x - 1, y1, 2, 2, gripColor);
+                }
+            }
+        }
+        painter->restore();
+        break;
+    case PE_PanelMenuBar:
+        break;
+    default:
+        if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+            QWindowsVistaStyle::drawPrimitive(element, option, painter, widget);
+        else
+            QWindowsXPStyle::drawPrimitive(element, option, painter, widget);
+        break;
+    }
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::drawControl(ControlElement element, const QStyleOption *option,
+                                  QPainter *painter, const QWidget *widget) const
+{
+
+    QColor gradientDark = d->gradientDarkColor(option);
+    QColor gradientLight = d->gradientLightColor(option);
+    QColor shadow = d->shadowColor(option);
+    QRect rect = option->rect;
+
+    switch (element) {
+#ifndef QT_NO_MENU
+    case CE_MenuItem:
+        painter->save();
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+            int x, y, w, h;
+            QStyleOptionMenuItem mbiCopy = *menuitem;
+            painter->fillRect(rect, d->menuBackgroundColor);
+            painter->fillRect(QRect(0, rect.top(), 25, rect.bottom()), d->menuGradient(option, rect));
+            menuitem->rect.getRect(&x, &y, &w, &h);
+
+            int tab = menuitem->tabWidth;
+            bool dis = !(menuitem->state & State_Enabled);
+            bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable
+                            ? menuitem->checked : false;
+            bool act = menuitem->state & State_Selected;
+            
+            // windows always has a check column, regardless whether we have an icon or not
+            int checkcol = qMax(menuitem->maxIconWidth, 20);
+            if (menuitem->menuItemType == QStyleOptionMenuItem::Separator) {
+                int yoff = y-1 + h / 2;
+                painter->setPen(d->menuSeparatorColor);
+                painter->drawLine(x + 32, yoff, x + w + 6, yoff);
+                painter->restore();
+                return;
+            }
+
+            QRect vCheckRect = visualRect(option->direction, menuitem->rect,
+                                QRect(menuitem->rect.x(), menuitem->rect.y(), checkcol, menuitem->rect.height()));
+            vCheckRect.adjust(2, 0, 0, 0);
+
+            if (act) {
+                painter->setPen(d->highlightOutlineColor(option));
+                painter->setBrush(d->highlightBrush(option, false));
+                painter->drawRect(option->rect.adjusted(0, 0, -2, -2));
+            }
+
+            if (!menuitem->icon.isNull()) {
+                QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
+                if (act && !dis)
+                    mode = QIcon::Active;
+                QPixmap pixmap;
+                if (checked)
+                    pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode, QIcon::On);
+                else
+                    pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode);
+                int pixw = pixmap.width();
+                int pixh = pixmap.height();
+                QRect pmr(0, 0, pixw, pixh);
+                pmr.moveCenter(vCheckRect.center());
+                painter->setPen(menuitem->palette.text().color());
+                painter->drawPixmap(pmr.topLeft(), pixmap);
+            } else if (checked) {
+                painter->save();
+                painter->setPen(d->highlightOutlineColor(option, act));
+                painter->setBrush(d->highlightMenuCheckBrush(option, act));
+                painter->drawRect(vCheckRect.adjusted(-1, 1, 0, -3));
+                painter->restore();
+
+                QStyleOptionMenuItem newMi = *menuitem;
+                newMi.state = State_None;
+                if (!dis)
+                    newMi.state |= State_Enabled;
+                if (act)
+                    newMi.state |= State_On;
+                newMi.rect = visualRect(option->direction, menuitem->rect,
+                                        QRect(menuitem->rect.x() + windowsItemFrame, menuitem->rect.y() + windowsItemFrame,
+                                        checkcol - 2 * windowsItemFrame, menuitem->rect.height() - 2*windowsItemFrame));
+                drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, painter, widget);
+            }
+            painter->setPen(menuitem->palette.buttonText().color());
+
+            QColor discol;
+            if (dis) {
+                discol = menuitem->palette.text().color();
+                painter->setPen(discol);
+            }
+
+            int xm = windowsItemFrame + checkcol + windowsItemHMargin;
+            int xpos = menuitem->rect.x() + xm;
+            QRect textRect(xpos + 5, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
+            QRect vTextRect = visualRect(option->direction, menuitem->rect, textRect);
+            QString s = menuitem->text;
+
+            if (!s.isEmpty()) { // draw text
+                painter->save();
+                int t = s.indexOf(QLatin1Char('\t'));
+                int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
+                if (!styleHint(SH_UnderlineShortcut, menuitem, widget))
+                    text_flags |= Qt::TextHideMnemonic;
+                text_flags |= Qt::AlignLeft;
+                if (t >= 0) {
+                    QRect vShortcutRect = visualRect(option->direction, menuitem->rect,
+                    QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));
+                    if (dis && !act) {
+                        painter->setPen(discol);
+                    }
+                    painter->drawText(vShortcutRect, text_flags, s.mid(t + 1));
+                    s = s.left(t);
+                }
+                QFont font = menuitem->font;
+                if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)
+                    font.setBold(true);
+                painter->setFont(font);
+                if (dis && !act) {
+                    painter->setPen(discol);
+                }
+                painter->drawText(vTextRect, text_flags, s.left(t));
+                painter->restore();
+            }
+            if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
+                int dim = (h - 2 * windowsItemFrame) / 2;
+                PrimitiveElement arrow;
+                arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
+                xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;
+                QRect  vSubMenuRect = visualRect(option->direction, menuitem->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
+                QStyleOptionMenuItem newMI = *menuitem;
+                newMI.rect = vSubMenuRect;
+                newMI.state = dis ? State_None : State_Enabled;
+                drawPrimitive(arrow, &newMI, painter, widget);
+            }
+        }
+        painter->restore();
+        break;
+#endif // QT_NO_MENU
+
+        case CE_MenuEmptyArea:
+            {
+                painter->fillRect(option->rect, option->palette.base());
+                QLinearGradient grad(QPoint(rect.left() , 0), QPoint(rect.left() + 23, 0));
+                grad.setColorAt(0, gradientLight.light(110));
+                grad.setColorAt(1, gradientDark);
+                painter->fillRect(QRect(0, rect.top() + 2, 23, rect.bottom() - 3), grad);
+            }
+            break;
+        case CE_MenuBarItem:
+            if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+                QRect rect(QPoint(0, 0), widget->window()->size());
+                {
+                    if (widget->window())
+                        drawPrimitive(PE_Widget, option, painter, widget);
+                }
+                if (option->state & (QStyle::State_Sunken | QStyle::State_Selected))
+                {
+                    QColor highlight = shadow;
+                    painter->setPen(d->menuFrameColor);
+                    if (option->state & QStyle::State_Sunken) {
+
+                        if (d->internalPalette == DotNetStylePrivate::System)
+                            painter->setBrush(Qt::white);
+                        else
+                            painter->setBrush(d->menuGradient(option, option->rect, Qt::Vertical));
+
+                        painter->drawRect(option->rect.adjusted(0, 2, -1, 0));
+                        //draw shadow behind:
+                        QColor shade = Qt::black;
+                        shade.setAlpha(50);
+                        painter->setBrush(shade);
+                        painter->setPen(Qt::transparent);
+                        QRect shadowRect(option->rect.topRight() + QPoint(0, 4), option->rect.bottomRight() + QPoint(1,0));
+                        painter->drawRect(shadowRect);
+                    }
+                    else {
+                        painter->setPen(d->highlightOutlineColor(option));
+                        painter->setBrush(d->highlightBrush(option, false));
+                        painter->drawRect(option->rect.adjusted(0, 2, -2, -2));
+                    }
+                }
+                QStyleOptionMenuItem mbiCopy = *mbi;
+                QPalette pal = mbi->palette;
+                pal.setBrush(QPalette::All, QPalette::ButtonText, mbi->palette.text());
+                mbiCopy.palette = pal;
+                QCommonStyle::drawControl(element, &mbiCopy, painter, widget);
+        }
+            break;
+        case CE_MenuBarEmptyArea:
+            if (widget->window())
+                drawPrimitive(PE_Widget, option, painter, widget);
+            break;
+        case CE_DockWidgetTitle:
+            if (const QDockWidget *dockWidget = qobject_cast<const QDockWidget *>(widget)) {
+                painter->save();
+                if (d->internalPalette == DotNetStylePrivate::System) {
+                    painter->setBrush(option->palette.dark().color().light(130));
+                    painter->setPen(option->palette.dark().color());
+                } else if (d->internalPalette == DotNetStylePrivate::Classic) {
+                    painter->setBrush(option->palette.background().color().dark(108));
+                    painter->setPen(option->palette.dark().color());
+                } else {
+                    painter->setBrush(d->toolbarGradient(option, option->rect, Qt::Horizontal));
+                    QColor color = d->gradientDarkColor(option).darker(120);
+                    painter->setPen(color);
+                }
+                painter->drawRect(rect.adjusted(0, 2, -1, -3));
+
+                if (const QStyleOptionDockWidget *dwOpt = qstyleoption_cast<const QStyleOptionDockWidget *>(option)) {
+                    QRect titleRect = option->rect.adjusted(6, 2, 0, 0);
+                    int buttonMargin = 4;
+                    int mw = pixelMetric(QStyle::PM_DockWidgetTitleMargin, dwOpt, widget);
+                    if (dwOpt->closable) {
+                        QPixmap pm = standardIcon(QStyle::SP_TitleBarCloseButton, dwOpt, widget).pixmap(10, 10);
+                        titleRect.adjust(0, 0, -pm.size().width() - mw - buttonMargin, 0);
+                    }
+                    if (dwOpt->floatable) {
+                        QPixmap pm = standardIcon(QStyle::SP_TitleBarMaxButton, dwOpt, widget).pixmap(10, 10);
+                        titleRect.adjust(0, 0, -pm.size().width() - mw - buttonMargin, 0);
+                    }
+                    titleRect =  visualRect(option->direction, option->rect, titleRect);
+
+                    if (!dwOpt->title.isEmpty()) {
+                        QString titleText = painter->fontMetrics().elidedText(dwOpt->title, Qt::ElideRight, titleRect.width());
+                        drawItemText(painter, titleRect,
+                                    Qt::AlignLeft | Qt::AlignVCenter, dwOpt->palette,
+                                    dwOpt->state & State_Enabled, titleText,
+                                    QPalette::WindowText);
+                    }
+                    painter->restore();
+                }
+                break;
+            }
+        case CE_ToolBar:
+            if (const QStyleOptionToolBar *toolbar = qstyleoption_cast<const QStyleOptionToolBar*>(option)) {
+                painter->save();
+                rect.adjust(1, 0, 0, 0);
+
+                if (const QToolBar *tb =  qobject_cast<const QToolBar *>(widget)) {
+                    if (option->direction == Qt::LeftToRight)
+                        rect.setRight(tb->childrenRect().right() + 2);
+                    else
+                        rect.setLeft(tb->childrenRect().left() - 2);
+                }
+                Qt::Orientation gradientOrientation =(toolbar->toolBarArea == Qt::RightToolBarArea ||
+                                                       toolbar->toolBarArea == Qt::LeftToolBarArea) ? Qt::Vertical : Qt::Horizontal;
+                QLinearGradient gradient = d->toolbarGradient(toolbar, rect, gradientOrientation);
+                painter->setBrush(gradient);
+                painter->setPen(Qt::NoPen);
+
+                bool roundEdges = true;
+                if (widget && widget->parentWidget()) {
+                    if (const QToolBar *tb =  qobject_cast<const QToolBar *>(widget)) {
+                        if (!(tb->childrenRect().width() + 32 < widget->parentWidget()->geometry().width())) {
+                            roundEdges = false;
+                            rect.adjust(-1, 0, 0, 0);
+                        }
+                    }
+                }
+                if (roundEdges) {
+                    rect = rect.adjusted(1, 1, -1, 0);
+                    QRegion region = rect;
+                    region -= QRect(rect.left(), rect.bottom(), 2, 1);
+                    region -= QRect(rect.right() - 1, rect.bottom(), 2, 1);
+                    region -= QRect(rect.left(),  rect.bottom() - 1, 1, 1);
+                    region -= QRect(rect.right(), rect.bottom() - 1, 1, 1);
+                    region -= QRect(rect.left(), rect.top(), 2, 1);
+                    region -= QRect(rect.right() - 1, rect.top(), 2, 1);
+                    region -= QRect(rect.left(),  rect.top() + 1, 1, 1);
+                    region -= QRect(rect.right(), rect.top() + 1, 1, 1);
+                    painter->setClipRegion(region);
+
+                    painter->fillRect(rect, gradient);
+
+                    painter->setPen(QPen(shadow, 0));
+                    painter->drawLine(rect.bottomLeft() + QPoint(3,0), rect.bottomRight() - QPoint(2,0));
+                    painter->drawPoint(rect.bottomRight() - QPoint(1, 1));
+                    QColor alphashadow = shadow;
+                    alphashadow.setAlpha(128);
+                    painter->setPen(QPen(alphashadow, 0));
+                    painter->drawLine(rect.topRight() + QPoint(0, 2), rect.bottomRight() - QPoint(0, 2));
+                } else {
+                    painter->fillRect(rect, gradient);
+                }
+                painter->restore();
+            }
+            break;
+        default:
+            if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+                QWindowsVistaStyle::drawControl(element, option, painter, widget);
+            else
+                QWindowsXPStyle::drawControl(element, option, painter, widget);
+            break;
+    }
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                                         QPainter *painter, const QWidget *widget) const
+{
+    switch (control) {
+        case CC_ComboBox:
+            if (widget && qobject_cast<QToolBar *>(widget->parentWidget())) {
+                QColor highlightedOutlineColor = d->highlightOutlineColor(option);
+                if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option))
+                {
+                    bool active = cmb->state & State_Active &&
+                                    ((cmb->state & State_MouseOver)
+                                        || (cmb->state & State_On)
+                                        || (cmb->state & State_HasFocus));
+                    QRect editRect = QWindowsStyle::subControlRect(CC_ComboBox, cmb, SC_ComboBoxEditField, widget).adjusted(0, 0, 3, 1);
+                    QRect rect = option->rect.adjusted(1, 1, -3, -2);
+                    editRect.setLeft(rect.left());
+
+                    if (cmb->subControls & SC_ComboBoxEditField) {
+                        painter->save();
+                        QBrush editBrush = cmb->palette.brush(QPalette::Base);
+                        painter->setPen(QPen(editBrush.color()));
+                        painter->drawRect(rect);
+                        painter->fillRect(editRect, editBrush);
+
+                        if (active) {
+                            QColor highlight = highlightedOutlineColor;
+                            painter->setPen(highlight);
+                            painter->drawRect(rect);
+                        }
+                        painter->restore();
+                    }
+
+                    if (cmb->subControls & SC_ComboBoxArrow) {
+                        State flags = State_None;
+
+                        QRect ar = QWindowsStyle::subControlRect(CC_ComboBox, cmb, SC_ComboBoxArrow, widget).adjusted(1, 0, -1, 0);
+                        if (active) {
+                            painter->save();
+                            painter->fillRect(ar, d->highlightBrush(option, cmb->state & State_Sunken));
+                            painter->setPen(highlightedOutlineColor);
+                            painter->drawLine(ar.topLeft(), ar.bottomLeft());
+                            painter->restore();
+                        }
+                        ar.adjust(5, 5, -2, -2);
+                        if (option->state & State_Enabled)
+                            flags |= State_Enabled;
+                        QStyleOption arrowOpt(0);
+                        arrowOpt.rect = ar;
+                        arrowOpt.palette = cmb->palette;
+                        arrowOpt.state = flags;
+                        QWindowsStyle::drawPrimitive(PE_IndicatorArrowDown, &arrowOpt, painter, widget);
+                    }
+                }
+            } else {
+                if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+                    QWindowsVistaStyle::drawComplexControl(control, option, painter, widget);
+                else
+                    QWindowsXPStyle::drawComplexControl(control, option, painter, widget);
+            }
+            break;
+
+    case CC_ToolButton:
+        if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option))
+        {
+            QRect button;
+            button = subControlRect(control, toolbutton, SC_ToolButton, widget);
+            if ((widget && qobject_cast<QToolBar*>(widget->parentWidget())) && 
+                ((toolbutton->state & State_MouseOver && toolbutton->state & State_Enabled)
+                || toolbutton->state & State_On)) {
+                QLinearGradient menubargradient2(button.topLeft(), button.bottomLeft());
+
+                bool act = (toolbutton->state & State_Sunken) || (toolbutton->state & State_On);
+                painter->setPen(d->highlightOutlineColor(option, act));
+                painter->setBrush(d->highlightBrush(option, act));
+                painter->drawRect(button.adjusted(0, 0, -2, -1));
+
+                QStyleOptionComplex comp;
+                comp.init(widget);
+                comp.rect = button;
+                QStyleOptionToolButton label = *toolbutton;
+                int fw = pixelMetric(PM_DefaultFrameWidth, option, widget);
+                label.rect = button.adjusted(fw, fw, -fw, -fw);
+                label.features &= ~QStyleOptionToolButton::Arrow;
+                drawControl(CE_ToolButtonLabel, &label, painter, widget);
+
+                if (toolbutton->subControls & SC_ToolButtonMenu) {
+                    QStyleOption tool = *toolbutton;
+                    tool.rect = QWindowsStyle::subControlRect(control, toolbutton, SC_ToolButtonMenu, widget);
+                    painter->setPen(d->highlightOutlineColor(option, act));
+                    painter->setBrush(d->highlightBrush(option, toolbutton->activeSubControls & SC_ToolButtonMenu));
+                    painter->drawRect(tool.rect.adjusted(-2, 0, -1, -1));
+                    tool.rect.adjust(2, 3, -2, -2);
+                    drawPrimitive(PE_IndicatorArrowDown, &tool, painter, widget);
+                }
+            } else
+                if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+                    QWindowsVistaStyle::drawComplexControl(control, option, painter, widget);
+                else
+                    QWindowsXPStyle::drawComplexControl(control, option, painter, widget);
+        }
+        break;
+
+    default:
+        if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+            QWindowsVistaStyle::drawComplexControl(control, option, painter, widget);
+        else
+            QWindowsXPStyle::drawComplexControl(control, option, painter, widget);
+        break;
+    }
+}
+
+/*!
+ \reimp
+ */
+QSize DotNetStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
+                                        const QSize &size, const QWidget *widget) const
+{
+    QSize newSize;
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        newSize = QWindowsVistaStyle::sizeFromContents(type, option, size, widget);
+    else
+        newSize = QWindowsXPStyle::sizeFromContents(type, option, size, widget);
+
+    switch (type) {
+    case CT_LineEdit:
+        if (widget && qobject_cast<QToolBar*>(widget->parentWidget())) {
+            newSize = QWindowsStyle::sizeFromContents(type, option, size, widget);
+            newSize += QSize(0, 2);
+        }
+        break;
+    case CT_ComboBox:
+        if (widget && qobject_cast<QToolBar*>(widget->parentWidget())) {
+            newSize = QWindowsStyle::sizeFromContents(type, option, size, widget);
+            newSize += QSize(0, 2);
+        }
+        break;
+    case CT_MenuBarItem:
+        newSize += QSize(0, 1);
+        break;
+    case CT_MenuItem:
+        if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+            newSize = QWindowsStyle::sizeFromContents(type, option, size, widget);
+            if (menuitem->menuItemType == QStyleOptionMenuItem::Separator){
+                newSize.setHeight(2);
+            } else {
+                newSize.rwidth() += 10;
+                //ensure menu items have uniform height
+                if (newSize.height() < 22)
+                    newSize.setHeight(22);
+            }
+        }
+        break;
+    case CT_Menu:
+        //work around for a menu frame issue (same as xp style)
+        newSize = size;
+        newSize -= QSize(1,2);
+        break;
+    default:
+        break;
+    }
+    return newSize;
+}
+
+/*!
+ \reimp
+ */
+QRect DotNetStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
+{
+    QRect rect;
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        rect = QWindowsVistaStyle::subElementRect(element, option, widget);
+    else
+        rect = QWindowsXPStyle::subElementRect(element, option, widget);
+    if (element == SE_DockWidgetCloseButton || element == SE_DockWidgetFloatButton)
+        rect.translate(0, 1);
+    return rect;
+}
+
+/*!
+ \reimp
+ */
+QRect DotNetStyle::subControlRect(ComplexControl control, const QStyleOptionComplex *option,
+                                      SubControl subControl, const QWidget *widget) const
+{
+    QRect rect;
+    if (control == CC_ComboBox && widget && qobject_cast<QToolBar*>(widget->parentWidget()))
+        rect = QWindowsStyle::subControlRect(control, option, subControl, widget);
+    else if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        rect = QWindowsVistaStyle::subControlRect(control, option, subControl, widget);
+    else
+        rect = QWindowsXPStyle::subControlRect(control, option, subControl, widget);
+
+    return rect;
+}
+
+/*!
+ \reimp
+ */
+QStyle::SubControl DotNetStyle::hitTestComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                                                          const QPoint &pos, const QWidget *widget) const
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        return QWindowsVistaStyle::hitTestComplexControl(control, option, pos, widget);
+    else
+        return QWindowsXPStyle::hitTestComplexControl(control, option, pos, widget);
+}
+
+/*!
+ \reimp
+ */
+int DotNetStyle::pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const
+{
+    int retval = 0;
+
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        retval = QWindowsVistaStyle::pixelMetric(metric, option, widget);
+    else
+        retval = QWindowsXPStyle::pixelMetric(metric, option, widget);
+
+    switch (metric) {
+    case PM_ToolBarItemSpacing:
+        retval = 2;
+        break;
+    case PM_ToolBarIconSize:
+        retval = 16;
+        break;
+    case PM_MenuHMargin:
+        retval = 1;
+        break;
+    case PM_MenuVMargin:
+        retval = 1;
+        break;
+    case PM_MenuBarPanelWidth:
+        retval = 0;
+        break;
+    case PM_MenuPanelWidth:
+        retval = 1;
+        break;
+    case PM_DockWidgetTitleBarButtonMargin:
+        retval = 6;
+        break;
+    case PM_DefaultFrameWidth:
+    case PM_SpinBoxFrameWidth:
+        if (widget && qobject_cast<QToolBar*>(widget->parentWidget()))
+            retval = 2;
+        break;
+    case PM_ButtonShiftVertical:
+    case PM_ButtonShiftHorizontal:
+        if (widget && qobject_cast<QToolBar*>(widget->parentWidget()))
+            retval = 0;
+        break;
+    default:
+        break;
+    }
+    return retval;
+}
+
+/*!
+ \reimp
+ */
+QPalette DotNetStyle::standardPalette() const
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        return QWindowsVistaStyle::standardPalette();
+    else
+        return QWindowsXPStyle::standardPalette();
+}
+
+
+void DotNetStylePrivate::updatePalette()
+{
+    //Detect color palette
+    const int maxlength = 256;
+    WCHAR themeFileName[maxlength];
+    WCHAR themeColor[maxlength];
+    internalPalette = Classic;
+    if (pIsAppThemed && pIsAppThemed() && pGetCurrentThemeName(themeFileName, maxlength, themeColor, maxlength, NULL, 0) == S_OK) {
+        QString name = QString::fromUtf16((ushort *)themeFileName);
+        QString color = QString::fromUtf16((ushort *)themeColor);
+        if (theme == DotNetStyle::Standard) {
+            if (name.endsWith("Luna.msstyles")) {
+                if (color == "Metallic")
+                    internalPalette = Silver;
+                else
+                    internalPalette = System;
+            }
+        } else { //Office style
+            if (name.endsWith("Luna.msstyles")) {
+                if (color == "HomeStead")
+                    internalPalette = Olive;
+                else if (color == "Metallic")
+                    internalPalette = Silver;
+                else
+                    internalPalette = Blue;
+            } else if (name.endsWith("Aero.msstyles")) {
+                    internalPalette = Blue;
+            }
+        }
+    }
+
+    switch (internalPalette) {
+    case Blue:
+        menuSeparatorColor = QColor(106, 140, 203);
+        menuBackgroundColor = QColor(246, 246, 246);
+        menuFrameColor = QColor(0, 45, 150);
+        break;
+    case Silver:
+        menuSeparatorColor = QColor(110, 109, 143);
+        menuBackgroundColor = QColor(254, 250, 255);
+        menuFrameColor = QColor(124, 124, 148);
+        break;
+    case Olive:
+        menuSeparatorColor = QColor(96, 128, 88);
+        menuBackgroundColor = QColor(244, 244, 238);
+        menuFrameColor = QColor(117, 141, 94);
+        break;
+    default:
+        menuFrameColor = currentPal.dark().color().lighter(108);
+        menuSeparatorColor = currentPal.background().color().darker(110);
+        menuBackgroundColor = currentPal.light().color();
+        menuBackgroundColor.setHsv(
+            menuBackgroundColor.hue(),
+            3 * menuBackgroundColor.saturation()/8 ,
+            250);
+        break;
+    }
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::polish(QApplication *app)
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        QWindowsVistaStyle::polish(app);
+    else
+        QWindowsXPStyle::polish(app);
+    d->currentPal = app->palette();
+    d->updatePalette();
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::unpolish(QApplication *app)
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        QWindowsVistaStyle::unpolish(app);
+    else
+        QWindowsXPStyle::unpolish(app);
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::polish(QWidget *widget)
+{
+    if (qobject_cast<QMainWindow *>(widget))
+        widget->setAttribute(Qt::WA_StyledBackground);
+    else if (qobject_cast<QLineEdit*>(widget))
+        widget->setAttribute(Qt::WA_Hover);
+    else if (qobject_cast<QComboBox*>(widget))
+        widget->setAttribute(Qt::WA_Hover);
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        QWindowsVistaStyle::polish(widget);
+    else
+        QWindowsXPStyle::polish(widget);
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::unpolish(QWidget *widget)
+{
+    if (qobject_cast<QMainWindow *>(widget))
+        widget->setAttribute(Qt::WA_StyledBackground, false);
+    else if (qobject_cast<QLineEdit*>(widget))
+        widget->setAttribute(Qt::WA_Hover, false);
+    else if (qobject_cast<QComboBox*>(widget))
+        widget->setAttribute(Qt::WA_Hover, false);
+
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        QWindowsVistaStyle::unpolish(widget);
+    else
+        QWindowsXPStyle::unpolish(widget);
+}
+
+/*!
+ \reimp
+ */
+void DotNetStyle::polish(QPalette &pal)
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        QWindowsVistaStyle::polish(pal);
+    else
+        QWindowsXPStyle::polish(pal);
+}
+
+/*!
+ \reimp
+ */
+QPixmap DotNetStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
+                                      const QWidget *widget) const
+{
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        return QWindowsVistaStyle::standardPixmap(standardPixmap, opt, widget);
+    else
+        return QWindowsXPStyle::standardPixmap(standardPixmap, opt, widget);
+}
+
+/*!
+  \reimp
+*/
+int DotNetStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
+                               QStyleHintReturn *returnData) const
+{
+    int ret = 0;
+    if (QSysInfo::WindowsVersion >= QSysInfo::WV_VISTA && QSysInfo::WindowsVersion < QSysInfo::WV_NT_based)
+        ret =  QWindowsVistaStyle::styleHint(hint, option, widget, returnData);
+    else
+        ret = QWindowsXPStyle::styleHint(hint, option, widget, returnData);
+    return ret;
+}
+
+#endif //USE_DOTNET_STYLE
diff --git a/src/fqterm/3rdparty/dotnetstyle.h b/src/fqterm/3rdparty/dotnetstyle.h
new file mode 100644
index 0000000..16326b6
--- /dev/null
+++ b/src/fqterm/3rdparty/dotnetstyle.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2007-2007 Trolltech ASA. All rights reserved.
+**
+** This file is part of the DotNetStyle project on Trolltech Labs.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+
+#ifndef QTDOTNETSTYLE_H
+#define QTDOTNETSTYLE_H
+#ifdef USE_DOTNET_STYLE
+#include <QtGui/QWindowsVistastyle.h>
+
+class QLinearGradient;
+class QBrush;
+
+class DotNetStylePrivate;
+class DotNetStyle : public QWindowsVistaStyle
+{
+public:
+    enum ColorTheme {
+        Standard,
+        Office
+    };
+    DotNetStyle();
+
+    DotNetStyle(ColorTheme palette);
+
+    ~DotNetStyle();
+
+    void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
+                       QPainter *painter, const QWidget *widget = 0) const;
+    void drawControl(ControlElement element, const QStyleOption *option,
+                     QPainter *painter, const QWidget *widget) const;
+    void drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+                            QPainter *painter, const QWidget *widget) const;
+    QSize sizeFromContents(ContentsType type, const QStyleOption *option,
+                           const QSize &size, const QWidget *widget) const;
+
+    QRect subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const;
+    QRect subControlRect(ComplexControl cc, const QStyleOptionComplex *opt,
+                         SubControl sc, const QWidget *widget) const;
+
+    SubControl hitTestComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+				                    const QPoint &pos, const QWidget *widget = 0) const;
+
+    QPixmap standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt,
+                                    const QWidget *widget = 0) const;
+    int styleHint(StyleHint hint, const QStyleOption *option = 0, const QWidget *widget = 0,
+                  QStyleHintReturn *returnData = 0) const;
+    int pixelMetric(PixelMetric metric, const QStyleOption *option = 0, const QWidget *widget = 0) const;
+    void polish(QWidget *widget);
+    void unpolish(QWidget *widget);
+    void polish(QPalette &pal);
+    void polish(QApplication *app);
+    void unpolish(QApplication *app);
+    QPalette standardPalette() const;
+    DotNetStylePrivate *d;
+};
+#endif //USE_DOTNET_STYLE
+#endif
diff --git a/src/fqterm/3rdparty/qxtglobal.h b/src/fqterm/3rdparty/qxtglobal.h
new file mode 100644
index 0000000..575372d
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobal.h
@@ -0,0 +1,207 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtCore module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+
+#ifndef QXTGLOBAL_H
+#define QXTGLOBAL_H
+
+#include <QtGlobal>
+
+#define QXT_VERSION 0x000600
+#define QXT_VERSION_STR "0.6.0"
+
+//--------------------------global macros------------------------------
+
+#ifndef QXT_NO_MACROS
+
+#endif // QXT_NO_MACROS
+
+//--------------------------export macros------------------------------
+
+#define QXT_DLLEXPORT DO_NOT_USE_THIS_ANYMORE
+
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_CORE)
+#        define QXT_CORE_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_CORE_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_CORE_EXPORT
+#endif // BUILD_QXT_CORE
+ 
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_GUI)
+#        define QXT_GUI_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_GUI_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_GUI_EXPORT
+#endif // BUILD_QXT_GUI
+ 
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_NETWORK)
+#        define QXT_NETWORK_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_NETWORK_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_NETWORK_EXPORT
+#endif // BUILD_QXT_NETWORK
+ 
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_SQL)
+#        define QXT_SQL_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_SQL_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_SQL_EXPORT
+#endif // BUILD_QXT_SQL
+ 
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_WEB)
+#        define QXT_WEB_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_WEB_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_WEB_EXPORT
+#endif // BUILD_QXT_WEB
+ 
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_BERKELEY)
+#        define QXT_BERKELEY_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_BERKELEY_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_BERKELEY_EXPORT
+#endif // BUILD_QXT_BERKELEY
+
+#if !defined(QXT_STATIC)
+#    if defined(BUILD_QXT_ZEROCONF)
+#        define QXT_ZEROCONF_EXPORT Q_DECL_EXPORT
+#    else
+#        define QXT_ZEROCONF_EXPORT Q_DECL_IMPORT
+#    endif
+#else
+#    define QXT_ZEROCONF_EXPORT
+#endif // QXT_ZEROCONF_EXPORT
+
+#if defined BUILD_QXT_CORE || defined BUILD_QXT_GUI || defined  BUILD_QXT_SQL || defined BUILD_QXT_NETWORK || defined BUILD_QXT_WEB || defined BUILD_QXT_BERKELEY || defined BUILD_QXT_ZEROCONF
+#   define BUILD_QXT
+#endif
+
+QXT_CORE_EXPORT const char* qxtVersion();
+
+#ifndef QT_BEGIN_NAMESPACE
+#define QT_BEGIN_NAMESPACE
+#endif
+
+#ifndef QT_END_NAMESPACE
+#define QT_END_NAMESPACE
+#endif
+
+#ifndef QT_FORWARD_DECLARE_CLASS
+#define QT_FORWARD_DECLARE_CLASS(Class) class Class;
+#endif
+
+/****************************************************************************
+** This file is derived from code bearing the following notice:
+** The sole author of this file, Adam Higerd, has explicitly disclaimed all
+** copyright interest and protection for the content within. This file has
+** been placed in the public domain according to United States copyright
+** statute and case law. In jurisdictions where this public domain dedication
+** is not legally recognized, anyone who receives a copy of this file is
+** permitted to use, modify, duplicate, and redistribute this file, in whole
+** or in part, with no restrictions or conditions. In these jurisdictions,
+** this file shall be copyright (C) 2006-2008 by Adam Higerd.
+****************************************************************************/
+
+#define QXT_DECLARE_PRIVATE(PUB) friend class PUB##Private; QxtPrivateInterface<PUB, PUB##Private> qxt_d;
+#define QXT_DECLARE_PUBLIC(PUB) friend class PUB;
+#define QXT_INIT_PRIVATE(PUB) qxt_d.setPublic(this);
+#define QXT_D(PUB) PUB##Private& d = qxt_d()
+#define QXT_P(PUB) PUB& p = qxt_p()
+
+template <typename PUB>
+class QxtPrivate
+{
+public:
+    virtual ~QxtPrivate()
+    {}
+    inline void QXT_setPublic(PUB* pub)
+    {
+        qxt_p_ptr = pub;
+    }
+
+protected:
+    inline PUB& qxt_p()
+    {
+        return *qxt_p_ptr;
+    }
+    inline const PUB& qxt_p() const
+    {
+        return *qxt_p_ptr;
+    }
+
+private:
+    PUB* qxt_p_ptr;
+};
+
+template <typename PUB, typename PVT>
+class QxtPrivateInterface
+{
+    friend class QxtPrivate<PUB>;
+public:
+    QxtPrivateInterface()
+    {
+        pvt = new PVT;
+    }
+    ~QxtPrivateInterface()
+    {
+        delete pvt;
+    }
+
+    inline void setPublic(PUB* pub)
+    {
+        pvt->QXT_setPublic(pub);
+    }
+    inline PVT& operator()()
+    {
+        return *static_cast<PVT*>(pvt);
+    }
+    inline const PVT& operator()() const
+    {
+        return *static_cast<PVT*>(pvt);
+    }
+private:
+    QxtPrivateInterface(const QxtPrivateInterface&) { }
+    QxtPrivateInterface& operator=(const QxtPrivateInterface&) { }
+    QxtPrivate<PUB>* pvt;
+};
+
+#endif // QXT_GLOBAL
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut.cpp b/src/fqterm/3rdparty/qxtglobalshortcut.cpp
new file mode 100644
index 0000000..0d8f557
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut.cpp
@@ -0,0 +1,193 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#include "qxtglobalshortcut.h"
+#include "qxtglobalshortcut_p.h"
+#include <QAbstractEventDispatcher>
+#include <QtDebug>
+
+bool QxtGlobalShortcutPrivate::error = false;
+int QxtGlobalShortcutPrivate::ref = 0;
+QAbstractEventDispatcher::EventFilter QxtGlobalShortcutPrivate::prevEventFilter = 0;
+QHash<QPair<quint32, quint32>, QxtGlobalShortcut*> QxtGlobalShortcutPrivate::shortcuts;
+
+QxtGlobalShortcutPrivate::QxtGlobalShortcutPrivate() : enabled(true), key(Qt::Key(0)), mods(Qt::NoModifier)
+{
+    if (!ref++)
+        prevEventFilter = QAbstractEventDispatcher::instance()->setEventFilter(eventFilter);
+}
+
+QxtGlobalShortcutPrivate::~QxtGlobalShortcutPrivate()
+{
+    if (!--ref)
+        QAbstractEventDispatcher::instance()->setEventFilter(prevEventFilter);
+}
+
+bool QxtGlobalShortcutPrivate::setShortcut(const QKeySequence& shortcut)
+{
+    Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;
+    key = shortcut.isEmpty() ? Qt::Key(0) : Qt::Key((shortcut[0] ^ allMods) & shortcut[0]);
+    mods = shortcut.isEmpty() ? Qt::KeyboardModifiers(0) : Qt::KeyboardModifiers(shortcut[0] & allMods);
+    const quint32 nativeKey = nativeKeycode(key);
+    const quint32 nativeMods = nativeModifiers(mods);
+    const bool res = registerShortcut(nativeKey, nativeMods);
+    shortcuts.insert(qMakePair(nativeKey, nativeMods), &qxt_p());
+    if (!res)
+        qWarning() << "QxtGlobalShortcut failed to register:" << QKeySequence(key + mods).toString();
+    return res;
+}
+
+bool QxtGlobalShortcutPrivate::unsetShortcut()
+{
+    const quint32 nativeKey = nativeKeycode(key);
+    const quint32 nativeMods = nativeModifiers(mods);
+    const bool res = unregisterShortcut(nativeKey, nativeMods);
+    shortcuts.remove(qMakePair(nativeKey, nativeMods));
+    if (!res)
+        qWarning() << "QxtGlobalShortcut failed to unregister:" << QKeySequence(key + mods).toString();
+    key = Qt::Key(0);
+    mods = Qt::KeyboardModifiers(0);
+    return res;
+}
+
+void QxtGlobalShortcutPrivate::activateShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    QxtGlobalShortcut* shortcut = shortcuts.value(qMakePair(nativeKey, nativeMods));
+    if (shortcut && shortcut->isEnabled())
+        emit shortcut->activated();
+}
+
+/*!
+    \class QxtGlobalShortcut
+    \inmodule QxtGui
+    \brief The QxtGlobalShortcut class provides a global shortcut aka "hotkey".
+
+    A global shortcut triggers even if the application is not active. This
+    makes it easy to implement applications that react to certain shortcuts
+    still if some other application is active or if the application is for
+    example minimized to the system tray.
+
+    Example usage:
+    \code
+    QxtGlobalShortcut* shortcut = new QxtGlobalShortcut(window);
+    connect(shortcut, SIGNAL(activated()), window, SLOT(toggleVisibility()));
+    shortcut->setShortcut(QKeySequence("Ctrl+Shift+F12"));
+    \endcode
+
+    \bold {Note:} Since Qxt 0.6 QxtGlobalShortcut no more requires QxtApplication.
+ */
+
+/*!
+    \fn QxtGlobalShortcut::activated()
+
+    This signal is emitted when the user types the shortcut's key sequence.
+
+    \sa shortcut
+ */
+
+/*!
+    Constructs a new QxtGlobalShortcut with \a parent.
+ */
+QxtGlobalShortcut::QxtGlobalShortcut(QObject* parent)
+        : QObject(parent)
+{
+    QXT_INIT_PRIVATE(QxtGlobalShortcut);
+}
+
+/*!
+    Constructs a new QxtGlobalShortcut with \a shortcut and \a parent.
+ */
+QxtGlobalShortcut::QxtGlobalShortcut(const QKeySequence& shortcut, QObject* parent)
+        : QObject(parent)
+{
+    QXT_INIT_PRIVATE(QxtGlobalShortcut);
+    setShortcut(shortcut);
+}
+
+/*!
+    Destructs the QxtGlobalShortcut.
+ */
+QxtGlobalShortcut::~QxtGlobalShortcut()
+{
+    if (qxt_d().key != 0)
+        qxt_d().unsetShortcut();
+}
+
+/*!
+    \property QxtGlobalShortcut::shortcut
+    \brief the shortcut key sequence
+
+    \bold {Note:} Notice that corresponding key press and release events are not
+    delivered for registered global shortcuts even if they are disabled.
+    Also, comma separated key sequences are not supported.
+    Only the first part is used:
+
+    \code
+    qxtShortcut->setShortcut(QKeySequence("Ctrl+Alt+A,Ctrl+Alt+B"));
+    Q_ASSERT(qxtShortcut->shortcut() == QKeySequence("Ctrl+Alt+A"));
+    \endcode
+ */
+QKeySequence QxtGlobalShortcut::shortcut() const
+{
+    return QKeySequence(qxt_d().key | qxt_d().mods);
+}
+
+bool QxtGlobalShortcut::setShortcut(const QKeySequence& shortcut)
+{
+    if (qxt_d().key != 0)
+        qxt_d().unsetShortcut();
+    return qxt_d().setShortcut(shortcut);
+}
+
+/*!
+    \property QxtGlobalShortcut::enabled
+    \brief whether the shortcut is enabled
+
+    A disabled shortcut does not get activated.
+
+    The default value is \c true.
+
+    \sa setDisabled()
+ */
+bool QxtGlobalShortcut::isEnabled() const
+{
+    return qxt_d().enabled;
+}
+
+void QxtGlobalShortcut::setEnabled(bool enabled)
+{
+    qxt_d().enabled = enabled;
+}
+
+/*!
+    Sets the shortcut \a disabled.
+
+    \sa enabled
+ */
+void QxtGlobalShortcut::setDisabled(bool disabled)
+{
+    qxt_d().enabled = !disabled;
+}
+
+#include "qxtglobalshortcut.moc"
\ No newline at end of file
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut.h b/src/fqterm/3rdparty/qxtglobalshortcut.h
new file mode 100644
index 0000000..8a352b8
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#ifndef QXTGLOBALSHORTCUT_H
+#define QXTGLOBALSHORTCUT_H
+
+#include "qxtglobal.h"
+#include <QObject>
+#include <QKeySequence>
+class QxtGlobalShortcutPrivate;
+
+class QxtGlobalShortcut : public QObject
+{
+    Q_OBJECT
+    QXT_DECLARE_PRIVATE(QxtGlobalShortcut)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
+    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut)
+
+public:
+    explicit QxtGlobalShortcut(QObject* parent = 0);
+    explicit QxtGlobalShortcut(const QKeySequence& shortcut, QObject* parent = 0);
+    virtual ~QxtGlobalShortcut();
+
+    QKeySequence shortcut() const;
+    bool setShortcut(const QKeySequence& shortcut);
+
+    bool isEnabled() const;
+
+public Q_SLOTS:
+    void setEnabled(bool enabled = true);
+    void setDisabled(bool disabled = true);
+
+Q_SIGNALS:
+    void activated();
+};
+
+#endif // QXTGLOBALSHORTCUT_H
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut_mac.cpp b/src/fqterm/3rdparty/qxtglobalshortcut_mac.cpp
new file mode 100644
index 0000000..7bfbf00
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut_mac.cpp
@@ -0,0 +1,262 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#include <Carbon/Carbon.h>
+#include "qxtglobalshortcut_p.h"
+#include <QMap>
+#include <QHash>
+#include <QtDebug>
+#include <QApplication>
+
+typedef QPair<uint, uint> Identifier;
+static QMap<quint32, EventHotKeyRef> keyRefs;
+static QHash<Identifier, quint32> keyIDs;
+static quint32 hotKeySerial = 0;
+static bool qxt_mac_handler_installed = false;
+
+OSStatus qxt_mac_handle_hot_key(EventHandlerCallRef nextHandler, EventRef event, void* data)
+{
+    // pass event to the app event filter
+    Q_UNUSED(data);
+    qApp->macEventFilter(nextHandler, event);
+    return noErr;
+}
+
+bool QxtGlobalShortcutPrivate::eventFilter(void* message)
+//bool QxtGlobalShortcutPrivate::macEventFilter(EventHandlerCallRef caller, EventRef event)
+{
+    EventRef event = (EventRef) message;
+    if (GetEventClass(event) == kEventClassKeyboard && GetEventKind(event) == kEventHotKeyPressed)
+    {
+        EventHotKeyID keyID;
+        GetEventParameter(event, kEventParamDirectObject, typeEventHotKeyID, NULL, sizeof(keyID), NULL, &keyID);
+        Identifier id = keyIDs.key(keyID.id);
+        activateShortcut(id.second, id.first);
+    }
+    return false;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeModifiers(Qt::KeyboardModifiers modifiers)
+{
+    quint32 native = 0;
+    if (modifiers & Qt::ShiftModifier)
+        native |= shiftKeyBit;
+    if (modifiers & Qt::ControlModifier)
+        native |= cmdKey;
+    if (modifiers & Qt::AltModifier)
+        native |= optionKey;
+    if (modifiers & Qt::MetaModifier)
+        native |= controlKey;
+    if (modifiers & Qt::KeypadModifier)
+        native |= kEventKeyModifierNumLockMask;
+    return native;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeKeycode(Qt::Key key)
+{
+    UTF16Char ch;
+    // Constants found in NSEvent.h from AppKit.framework
+    switch (key)
+    {
+    case Qt::Key_Return:
+        return kVK_Return;
+    case Qt::Key_Enter:
+        return kVK_ANSI_KeypadEnter;
+    case Qt::Key_Tab:
+        return kVK_Tab;
+    case Qt::Key_Space:
+        return kVK_Space;
+    case Qt::Key_Backspace:
+        return kVK_Delete;
+    case Qt::Key_Control:
+        return kVK_Command;
+    case Qt::Key_Shift:
+        return kVK_Shift;
+    case Qt::Key_CapsLock:
+        return kVK_CapsLock;
+    case Qt::Key_Option:
+        return kVK_Option;
+    case Qt::Key_Meta:
+        return kVK_Control;
+    case Qt::Key_F17:
+        return kVK_F17;
+    case Qt::Key_VolumeUp:
+        return kVK_VolumeUp;
+    case Qt::Key_VolumeDown:
+        return kVK_VolumeDown;
+    case Qt::Key_F18:
+        return kVK_F18;
+    case Qt::Key_F19:
+        return kVK_F19;
+    case Qt::Key_F20:
+        return kVK_F20;
+    case Qt::Key_F5:
+        return kVK_F5;
+    case Qt::Key_F6:
+        return kVK_F6;
+    case Qt::Key_F7:
+        return kVK_F7;
+    case Qt::Key_F3:
+        return kVK_F3;
+    case Qt::Key_F8:
+        return kVK_F8;
+    case Qt::Key_F9:
+        return kVK_F9;
+    case Qt::Key_F11:
+        return kVK_F11;
+    case Qt::Key_F13:
+        return kVK_F13;
+    case Qt::Key_F16:
+        return kVK_F16;
+    case Qt::Key_F14:
+        return kVK_F14;
+    case Qt::Key_F10:
+        return kVK_F10;
+    case Qt::Key_F12:
+        return kVK_F12;
+    case Qt::Key_F15:
+        return kVK_F15;
+    case Qt::Key_Help:
+        return kVK_Help;
+    case Qt::Key_Home:
+        return kVK_Home;
+    case Qt::Key_PageUp:
+        return kVK_PageUp;
+    case Qt::Key_Delete:
+        return kVK_ForwardDelete;
+    case Qt::Key_F4:
+        return kVK_F4;
+    case Qt::Key_End:
+        return kVK_End;
+    case Qt::Key_F2:
+        return kVK_F2;
+    case Qt::Key_PageDown:
+        return kVK_PageDown;
+    case Qt::Key_F1:
+        return kVK_F1;
+    case Qt::Key_Left:
+        return kVK_LeftArrow;
+    case Qt::Key_Right:
+        return kVK_RightArrow;
+    case Qt::Key_Down:
+        return kVK_DownArrow;
+    case Qt::Key_Up:
+        return kVK_UpArrow;
+    default:
+        ;
+    }
+
+    if (key == Qt::Key_Escape)	ch = 27;
+    else if (key == Qt::Key_Return) ch = 13;
+    else if (key == Qt::Key_Enter) ch = 3;
+    else if (key == Qt::Key_Tab) ch = 9;
+    else ch = key;
+
+    CFDataRef currentLayoutData;
+    TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
+
+    if (currentKeyboard == NULL)
+        return 0;
+
+    currentLayoutData = (CFDataRef)TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
+    CFRelease(currentKeyboard);
+    if (currentLayoutData == NULL)
+        return 0;
+
+    UCKeyboardLayout* header = (UCKeyboardLayout*)CFDataGetBytePtr(currentLayoutData);
+    UCKeyboardTypeHeader* table = header->keyboardTypeList;
+
+    uint8_t *data = (uint8_t*)header;
+    // God, would a little documentation for this shit kill you...
+    for (quint32 i=0; i < header->keyboardTypeCount; i++)
+    {
+        UCKeyStateRecordsIndex* stateRec = 0;
+        if (table[i].keyStateRecordsIndexOffset != 0)
+        {
+            stateRec = reinterpret_cast<UCKeyStateRecordsIndex*>(data + table[i].keyStateRecordsIndexOffset);
+            if (stateRec->keyStateRecordsIndexFormat != kUCKeyStateRecordsIndexFormat) stateRec = 0;
+        }
+
+        UCKeyToCharTableIndex* charTable = reinterpret_cast<UCKeyToCharTableIndex*>(data + table[i].keyToCharTableIndexOffset);
+        if (charTable->keyToCharTableIndexFormat != kUCKeyToCharTableIndexFormat) continue;
+
+        for (quint32 j=0; j < charTable->keyToCharTableCount; j++)
+        {
+            UCKeyOutput* keyToChar = reinterpret_cast<UCKeyOutput*>(data + charTable->keyToCharTableOffsets[j]);
+            for (quint32 k=0; k < charTable->keyToCharTableSize; k++)
+            {
+                if (keyToChar[k] & kUCKeyOutputTestForIndexMask)
+                {
+                    long idx = keyToChar[k] & kUCKeyOutputGetIndexMask;
+                    if (stateRec && idx < stateRec->keyStateRecordCount)
+                    {
+                        UCKeyStateRecord* rec = reinterpret_cast<UCKeyStateRecord*>(data + stateRec->keyStateRecordOffsets[idx]);
+                        if (rec->stateZeroCharData == ch) return k;
+                    }
+                }
+                else if (!(keyToChar[k] & kUCKeyOutputSequenceIndexMask) && keyToChar[k] < 0xFFFE)
+                {
+                    if (keyToChar[k] == ch) return k;
+                }
+            } // for k
+        } // for j
+    } // for i
+
+    return 0;
+}
+
+bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    if (!qxt_mac_handler_installed)
+    {
+        EventTypeSpec t;
+        t.eventClass = kEventClassKeyboard;
+        t.eventKind = kEventHotKeyPressed;
+        InstallApplicationEventHandler(&qxt_mac_handle_hot_key, 1, &t, NULL, NULL);
+    }
+
+    EventHotKeyID keyID;
+    keyID.signature = 'cute';
+    keyID.id = ++hotKeySerial;
+
+    EventHotKeyRef ref = 0;
+    bool rv = !RegisterEventHotKey(nativeKey, nativeMods, keyID, GetApplicationEventTarget(), 0, &ref);
+    if (rv)
+    {
+        keyIDs.insert(Identifier(nativeMods, nativeKey), keyID.id);
+        keyRefs.insert(keyID.id, ref);
+    }
+    qDebug() << ref;
+    return rv;
+}
+
+bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    Identifier id(nativeMods, nativeKey);
+    if (!keyIDs.contains(id)) return false;
+
+    EventHotKeyRef ref = keyRefs.take(keyIDs[id]);
+    keyIDs.remove(id);
+    return !UnregisterEventHotKey(ref);
+}
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut_p.h b/src/fqterm/3rdparty/qxtglobalshortcut_p.h
new file mode 100644
index 0000000..4570396
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut_p.h
@@ -0,0 +1,63 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#ifndef QXTGLOBALSHORTCUT_P_H
+#define QXTGLOBALSHORTCUT_P_H
+
+#include "qxtglobalshortcut.h"
+#include <QAbstractEventDispatcher>
+#include <QKeySequence>
+#include <QHash>
+
+class QxtGlobalShortcutPrivate : public QxtPrivate<QxtGlobalShortcut>
+{
+public:
+    QXT_DECLARE_PUBLIC(QxtGlobalShortcut)
+    QxtGlobalShortcutPrivate();
+    ~QxtGlobalShortcutPrivate();
+
+    bool enabled;
+    Qt::Key key;
+    Qt::KeyboardModifiers mods;
+
+    bool setShortcut(const QKeySequence& shortcut);
+    bool unsetShortcut();
+
+    static bool error;
+    static int ref;
+    static QAbstractEventDispatcher::EventFilter prevEventFilter;
+    static bool eventFilter(void* message);
+
+private:
+    static quint32 nativeKeycode(Qt::Key keycode);
+    static quint32 nativeModifiers(Qt::KeyboardModifiers modifiers);
+
+    static bool registerShortcut(quint32 nativeKey, quint32 nativeMods);
+    static bool unregisterShortcut(quint32 nativeKey, quint32 nativeMods);
+    static void activateShortcut(quint32 nativeKey, quint32 nativeMods);
+
+    static QHash<QPair<quint32, quint32>, QxtGlobalShortcut*> shortcuts;
+};
+
+#endif // QXTGLOBALSHORTCUT_P_H
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut_win.cpp b/src/fqterm/3rdparty/qxtglobalshortcut_win.cpp
new file mode 100644
index 0000000..4099989
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut_win.cpp
@@ -0,0 +1,214 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#include "qxtglobalshortcut_p.h"
+#include <qt_windows.h>
+
+bool QxtGlobalShortcutPrivate::eventFilter(void* message)
+{
+    MSG* msg = static_cast<MSG*>(message);
+    if (msg->message == WM_HOTKEY)
+    {
+        const quint32 keycode = HIWORD(msg->lParam);
+        const quint32 modifiers = LOWORD(msg->lParam);
+        activateShortcut(keycode, modifiers);
+    }
+    return false;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeModifiers(Qt::KeyboardModifiers modifiers)
+{
+    // MOD_ALT, MOD_CONTROL, (MOD_KEYUP), MOD_SHIFT, MOD_WIN
+    quint32 native = 0;
+    if (modifiers & Qt::ShiftModifier)
+        native |= MOD_SHIFT;
+    if (modifiers & Qt::ControlModifier)
+        native |= MOD_CONTROL;
+    if (modifiers & Qt::AltModifier)
+        native |= MOD_ALT;
+    if (modifiers & Qt::MetaModifier)
+        native |= MOD_WIN;
+    // TODO: resolve these?
+    //if (modifiers & Qt::KeypadModifier)
+    //if (modifiers & Qt::GroupSwitchModifier)
+    return native;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeKeycode(Qt::Key key)
+{
+    switch (key)
+    {
+    case Qt::Key_Escape:
+        return VK_ESCAPE;
+    case Qt::Key_Tab:
+    case Qt::Key_Backtab:
+        return VK_TAB;
+    case Qt::Key_Backspace:
+        return VK_BACK;
+    case Qt::Key_Return:
+    case Qt::Key_Enter:
+        return VK_RETURN;
+    case Qt::Key_Insert:
+        return VK_INSERT;
+    case Qt::Key_Delete:
+        return VK_DELETE;
+    case Qt::Key_Pause:
+        return VK_PAUSE;
+    case Qt::Key_Print:
+        return VK_PRINT;
+    case Qt::Key_Clear:
+        return VK_CLEAR;
+    case Qt::Key_Home:
+        return VK_HOME;
+    case Qt::Key_End:
+        return VK_END;
+    case Qt::Key_Left:
+        return VK_LEFT;
+    case Qt::Key_Up:
+        return VK_UP;
+    case Qt::Key_Right:
+        return VK_RIGHT;
+    case Qt::Key_Down:
+        return VK_DOWN;
+    case Qt::Key_PageUp:
+        return VK_PRIOR;
+    case Qt::Key_PageDown:
+        return VK_NEXT;
+    case Qt::Key_F1:
+        return VK_F1;
+    case Qt::Key_F2:
+        return VK_F2;
+    case Qt::Key_F3:
+        return VK_F3;
+    case Qt::Key_F4:
+        return VK_F4;
+    case Qt::Key_F5:
+        return VK_F5;
+    case Qt::Key_F6:
+        return VK_F6;
+    case Qt::Key_F7:
+        return VK_F7;
+    case Qt::Key_F8:
+        return VK_F8;
+    case Qt::Key_F9:
+        return VK_F9;
+    case Qt::Key_F10:
+        return VK_F10;
+    case Qt::Key_F11:
+        return VK_F11;
+    case Qt::Key_F12:
+        return VK_F12;
+    case Qt::Key_F13:
+        return VK_F13;
+    case Qt::Key_F14:
+        return VK_F14;
+    case Qt::Key_F15:
+        return VK_F15;
+    case Qt::Key_F16:
+        return VK_F16;
+    case Qt::Key_F17:
+        return VK_F17;
+    case Qt::Key_F18:
+        return VK_F18;
+    case Qt::Key_F19:
+        return VK_F19;
+    case Qt::Key_F20:
+        return VK_F20;
+    case Qt::Key_F21:
+        return VK_F21;
+    case Qt::Key_F22:
+        return VK_F22;
+    case Qt::Key_F23:
+        return VK_F23;
+    case Qt::Key_F24:
+        return VK_F24;
+    case Qt::Key_Space:
+        return VK_SPACE;
+    case Qt::Key_Asterisk:
+        return VK_MULTIPLY;
+    case Qt::Key_Plus:
+        return VK_ADD;
+    case Qt::Key_Comma:
+        return VK_SEPARATOR;
+    case Qt::Key_Minus:
+        return VK_SUBTRACT;
+    case Qt::Key_Slash:
+        return VK_DIVIDE;
+
+        // numbers
+    case Qt::Key_0:
+    case Qt::Key_1:
+    case Qt::Key_2:
+    case Qt::Key_3:
+    case Qt::Key_4:
+    case Qt::Key_5:
+    case Qt::Key_6:
+    case Qt::Key_7:
+    case Qt::Key_8:
+    case Qt::Key_9:
+        return key;
+
+        // letters
+    case Qt::Key_A:
+    case Qt::Key_B:
+    case Qt::Key_C:
+    case Qt::Key_D:
+    case Qt::Key_E:
+    case Qt::Key_F:
+    case Qt::Key_G:
+    case Qt::Key_H:
+    case Qt::Key_I:
+    case Qt::Key_J:
+    case Qt::Key_K:
+    case Qt::Key_L:
+    case Qt::Key_M:
+    case Qt::Key_N:
+    case Qt::Key_O:
+    case Qt::Key_P:
+    case Qt::Key_Q:
+    case Qt::Key_R:
+    case Qt::Key_S:
+    case Qt::Key_T:
+    case Qt::Key_U:
+    case Qt::Key_V:
+    case Qt::Key_W:
+    case Qt::Key_X:
+    case Qt::Key_Y:
+    case Qt::Key_Z:
+        return key;
+
+    default:
+        return 0;
+    }
+}
+
+bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    return RegisterHotKey(0, nativeMods ^ nativeKey, nativeMods, nativeKey);
+}
+
+bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    return UnregisterHotKey(0, nativeMods ^ nativeKey);
+}
diff --git a/src/fqterm/3rdparty/qxtglobalshortcut_x11.cpp b/src/fqterm/3rdparty/qxtglobalshortcut_x11.cpp
new file mode 100644
index 0000000..2b2e6b7
--- /dev/null
+++ b/src/fqterm/3rdparty/qxtglobalshortcut_x11.cpp
@@ -0,0 +1,115 @@
+/****************************************************************************
+ **
+ ** Copyright (C) Qxt Foundation. Some rights reserved.
+ **
+ ** This file is part of the QxtGui module of the Qxt library.
+ **
+ ** This library is free software; you can redistribute it and/or modify it
+ ** under the terms of the Common Public License, version 1.0, as published
+ ** by IBM, and/or under the terms of the GNU Lesser General Public License,
+ ** version 2.1, as published by the Free Software Foundation.
+ **
+ ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
+ ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
+ ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
+ ** FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** You should have received a copy of the CPL and the LGPL along with this
+ ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
+ ** included with the source distribution for more information.
+ ** If you did not receive a copy of the licenses, contact the Qxt Foundation.
+ **
+ ** <http://libqxt.org>  <foundation@libqxt.org>
+ **
+ ****************************************************************************/
+#include "qxtglobalshortcut_p.h"
+#include <QX11Info>
+#include <X11/Xlib.h>
+
+static int (*original_x_errhandler)(Display* display, XErrorEvent* event);
+
+static int qxt_x_errhandler(Display* display, XErrorEvent *event)
+{
+    Q_UNUSED(display);
+    switch (event->error_code)
+    {
+        case BadAccess:
+        case BadValue:
+        case BadWindow:
+            if (event->request_code == 33 /* X_GrabKey */ ||
+                event->request_code == 34 /* X_UngrabKey */)
+            {
+                QxtGlobalShortcutPrivate::error = true;
+                //TODO:
+                //char errstr[256];
+                //XGetErrorText(dpy, err->error_code, errstr, 256);
+            }
+        default:
+            return 0;
+    }
+}
+
+bool QxtGlobalShortcutPrivate::eventFilter(void* message)
+{
+    XEvent* event = static_cast<XEvent*>(message);
+    if (event->type == KeyPress)
+    {
+        XKeyEvent* key = (XKeyEvent*) event;
+        activateShortcut(key->keycode, 
+            // Mod1Mask == Alt, Mod4Mask == Meta
+            key->state & (ShiftMask | ControlMask | Mod1Mask | Mod4Mask));
+    }
+    return false;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeModifiers(Qt::KeyboardModifiers modifiers)
+{
+    // ShiftMask, LockMask, ControlMask, Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, and Mod5Mask
+    quint32 native = 0;
+    if (modifiers & Qt::ShiftModifier)
+        native |= ShiftMask;
+    if (modifiers & Qt::ControlModifier)
+        native |= ControlMask;
+    if (modifiers & Qt::AltModifier)
+        native |= Mod1Mask;
+    // TODO: resolve these?
+    //if (modifiers & Qt::MetaModifier)
+    //if (modifiers & Qt::KeypadModifier)
+    //if (modifiers & Qt::GroupSwitchModifier)
+    return native;
+}
+
+quint32 QxtGlobalShortcutPrivate::nativeKeycode(Qt::Key key)
+{
+    Display* display = QX11Info::display();
+    return XKeysymToKeycode(display, XStringToKeysym(QKeySequence(key).toString().toLatin1().data()));
+}
+
+bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    Display* display = QX11Info::display();
+    Window window = QX11Info::appRootWindow();
+    Bool owner = True;
+    int pointer = GrabModeAsync;
+    int keyboard = GrabModeAsync;
+    error = false;
+    original_x_errhandler = XSetErrorHandler(qxt_x_errhandler);
+    XGrabKey(display, nativeKey, nativeMods, window, owner, pointer, keyboard);
+    XGrabKey(display, nativeKey, nativeMods | Mod2Mask, window, owner, pointer, keyboard); // allow numlock
+    XSync(display, False);
+    XSetErrorHandler(original_x_errhandler);
+    return !error;
+}
+
+bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)
+{
+    Display* display = QX11Info::display();
+    Window window = QX11Info::appRootWindow();
+    error = false;
+    original_x_errhandler = XSetErrorHandler(qxt_x_errhandler);
+    XUngrabKey(display, nativeKey, nativeMods, window);
+    XUngrabKey(display, nativeKey, nativeMods | Mod2Mask, window); // allow numlock
+    XSync(display, False);
+    XSetErrorHandler(original_x_errhandler);
+    return !error;
+}
diff --git a/src/fqterm/3rdparty/uaocodec.cpp b/src/fqterm/3rdparty/uaocodec.cpp
new file mode 100644
index 0000000..2e70b78
--- /dev/null
+++ b/src/fqterm/3rdparty/uaocodec.cpp
@@ -0,0 +1,15761 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "uaocodec.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_TEXTCODEC
+
+#define InRange(c, lower, upper)  (((c) >= (lower)) && ((c) <= (upper)))
+#define IsLatin(c)        ((c) < 0x80)
+#define IsFirstByte(c)        (InRange((c), 0x81, 0xFE))
+#define IsSecondByteRange1(c)        (InRange((c), 0x40, 0x7E))
+#define IsSecondByteRange2(c)        (InRange((c), 0xA1, 0xFE))
+#define IsSecondByte(c)        (IsSecondByteRange1(c) || IsSecondByteRange2(c))
+
+#define        QValidChar(u)        ((u) ? QChar((ushort)(u)) : QChar(QChar::ReplacementCharacter))
+
+
+int UAOCodec::_mibEnum()
+{
+    return 0;
+}
+
+QByteArray UAOCodec::_name()
+{
+    return "UAO";
+}
+
+/*
+ * ucs4 to big5hkscs convert routing
+ */
+
+typedef struct {
+    ushort index; /* index into big table */
+    ushort used;  /* bitmask of used entries */
+} Summary16;
+
+static const ushort big5_to_ucs[] = 
+{
+19991, 20002, 20012, 20053, 20066, 20106, 20144, 20203, 20205, 20220,
+20252, 20362, 20479, 20546, 20560, 20600, 20696, 20702, 20724, 20758,
+20810, 20817, 20836, 20842, 20869, 20880, 20893, 20902, 20904, 20905,
+20935, 20950, 20955, 20972, 20988, 21003, 21012, 21013, 21024, 21035,
+21049, 21071, 21105, 21136, 21138, 21140, 21148, 21167, 21173, 21200,
+21248, 21255, 21284, 21318, 21343, 21395, 21424, 21469, 21539, 21584,
+21585, 21642, 21661,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 21667, 21684, 21712,
+21795, 21823, 21836, 21843, 21853, 21868, 21918, 21929, 21996, 22005,
+22051, 22096, 22140, 22154, 22164, 22176, 22191, 22232, 22272, 22361,
+22373, 22399, 22405, 22409, 22433, 22444, 22452, 22464, 22472, 22483,
+22511, 22596, 22636, 22674, 22682, 22706, 22712, 22757, 22779, 22786,
+22795, 22800, 22808, 22811, 29836, 29837, 29849, 29851, 29860, 29876,
+29881, 29896, 29900, 29904, 29907, 30018, 30037, 30062, 30093, 30110,
+30172, 30252, 30287, 30289, 30323, 30324, 30373, 30425, 30478, 30479,
+30552, 30578, 30583, 30584, 30586, 30587, 30616, 30639, 30654, 30659,
+30661, 30667, 30685, 30694, 30708, 30750, 30781, 30786, 30788, 30795,
+30801, 21782, 22775, 38964, 33883, 28948, 33398, 35158, 40236, 40206,
+36527, 24674, 26214, 34510, 25785, 37772, 22107, 28485, 35532, 29001,
+24012, 34633, 39464, 31658, 36107, 39255, 23597, 32331, 38938, 20518,
+25458, 40568, 30783, 40633, 40634, 36046, 35715, 61305, 33931, 37284,
+31331, 25776, 24061, 24214, 32865, 26965, 31466, 28710, 26812, 31095,
+28060, 36841, 31074, 22178, 34687, 21093, 31108, 28300, 37271, 31622,
+38956, 26717, 20397, 34222,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 31725, 34635,
+20534, 26893, 27542, 24910, 20855, 30495, 20516, 32622, 30452, 27097,
+24803, 25334, 21599, 38788, 22092, 20677, 22040, 34398, 22834, 22875,
+22877, 22883, 22892, 22939, 22999, 23019, 23066, 23210, 23248, 23281,
+23350, 23497, 23539, 23571, 23580, 23582, 23635, 23705, 23708, 23738,
+23739, 23745, 23797, 23802, 23829, 23832, 23870, 23891, 23900, 23917,
+23923, 23924, 23948, 23952, 23993, 24016, 24019, 24135, 24164, 24271,
+24272, 24298, 24304, 24329, 24332, 24337, 24353, 24372, 24385, 24389,
+24401, 24412, 24422, 24451, 24560, 24650, 24672, 24715, 24742, 24798,
+24849, 24864, 24865, 24892, 24893, 24984, 25015, 25076, 25107, 25117,
+25118, 25143, 24186, 27664, 21454, 20267, 20302, 21556, 22257, 22766,
+22841, 22918, 23596, 20915, 20914, 28798, 35265, 35282, 36125, 36710,
+20122, 26469, 20177, 20004, 21327, 23626, 20872, 24213, 25269, 19996,
+20105, 29366, 31868, 32416, 21351, 36711, 37048, 38271, 38376, 20384,
+20387, 20822, 21017, 21170, 21364, 22850, 24069, 26594, 27769, 20026,
+32419, 32418, 32426, 32427, 32421, 32422, 32417, 32989, 33486, 35745,
+35746, 35747, 36126, 36127, 20891,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 36712,
+38377, 38886, 39029, 39118, 39134, 20457, 20204, 20261, 20010, 20262,
+20179, 20923, 21018, 21093, 21592, 23089, 23385, 23777, 23707, 23704,
+24072, 24211, 24452, 25375, 26102, 26187, 20070, 27902, 27971, 20044,
+29421, 29384, 20137, 30757, 31210, 32442, 32433, 32441, 32431, 32445,
+32432, 32423, 32429, 32435, 32440, 32439, 32961, 33033, 21005, 35760,
+35750, 35752, 35751, 35754, 35759, 35757, 35755, 23682, 36130, 36129,
+36713, 36715, 38025, 38024, 38026, 38027, 38378, 38453, 38485, 38473,
+39269, 39532, 39592, 20266, 20255, 20390, 20391, 21153, 21160, 21306,
+21442, 21713, 38382, 34900, 22269, 22362, 22441, 25191, 22815, 23044,
+22919, 19987, 23558, 23625, 23781, 23703, 24102, 24080, 24352, 24378,
+20174, 24469, 20932, 24581, 25195, 25346, 25194, 25249, 25379, 36133,
+21551, 26011, 26025, 26172, 21206, 24323, 26465, 26541, 26432, 27682,
+20937, 27973, 28170, 27882, 27814, 20928, 29301, 29424, 29616, 20135,
+27605, 24322, 20247, 32458, 32479, 32461, 32459, 32460, 32454, 32453,
+32452, 32456, 32449, 32450, 38069, 20064, 33626, 33550, 33682, 24196,
+33483, 22788, 26415, 34926, 35269, 35268,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+35775, 35766, 35776, 35767, 35768, 35774, 35772, 35769, 36137, 36131,
+36143, 36135, 36138, 36139, 36717, 36719, 36825, 36830, 36851, 38039,
+38035, 38031, 38034, 38381, 38472, 38470, 38452, 39030, 39031, 40060,
+40479, 21348, 40614, 22791, 20263, 20254, 20975, 21056, 21019, 21171,
+21195, 20007, 21333, 21727, 21796, 20052, 22260, 23591, 22330, 25253,
+22490, 22774, 23090, 23547, 23706, 24103, 24079, 21397, 21417, 24694,
+38391, 24812, 24699, 24700, 25315, 25381, 25442, 25196, 26531, 26635,
+26632, 38054, 27531, 22771, 27695, 27689, 28044, 20945, 28270, 28065,
+27748, 27979, 27985, 28067, 26080, 29369, 33487, 30011, 30153, 21457,
+30423, 30746, 31174, 31383, 31508, 31499, 32478, 32467, 32466, 32477,
+19997, 32476, 32473, 32474, 32470, 32475, 32899, 32958, 32960, 21326,
+33713, 33484, 34394, 35270, 35780, 35789, 35777, 35778, 35791, 35781,
+35784, 35787, 35785, 35786, 35779, 36142, 36148, 36144, 36155, 36146,
+36153, 36154, 36149, 20080, 36140, 36152, 36151, 36722, 36724, 36726,
+36827, 37038, 20065, 38046, 38062, 38041, 38048, 38055, 38045, 38052,
+38051, 38389, 38384, 24320, 38386, 38388, 38387,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 38431, 38454, 38451, 38887, 39033, 39034, 39035, 39274, 39277,
+39272, 39278, 39276, 20911, 39533, 20081, 20538, 20256, 20165, 20542,
+20260, 20588, 38130, 21183, 31215, 27719, 21527, 21596, 21595, 22253,
+22278, 28034, 22359, 22366, 22488, 33556, 22885, 22920, 29233, 24574,
+24582, 24698, 25439, 25250, 25443, 26500, 26198, 26197, 26104, 20250,
+19994, 26497, 26472, 26722, 26539, 23681, 27807, 28781, 28287, 28369,
+27815, 28902, 28860, 28800, 28949, 29239, 29422, 29502, 29682, 24403,
+30415, 30544, 30529, 38606, 30860, 33410, 31509, 31908, 32463, 32482,
+32465, 32485, 32486, 20041, 32673, 22307, 32928, 33050, 32959, 33041,
+33636, 33479, 21494, 33716, 34398, 34383, 21495, 34568, 34476, 34917,
+35013, 35815, 35813, 35814, 35797, 35799, 35800, 35801, 35811, 35802,
+35805, 35803, 35809, 35810, 35808, 35807, 36156, 36164, 36158, 36159,
+36160, 36161, 36162, 36165, 36739, 36733, 36732, 36734, 20892, 36816,
+36798, 36829, 36807, 37049, 38068, 38067, 38073, 38072, 38078, 38080,
+38085, 38057, 38082, 38083, 38089, 38091, 38044, 38093, 38079, 38086,
+38392, 38504, 38589, 30005, 39044, 39037, 39039, 39036,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 39041, 39042, 39282, 39284, 39281, 39280, 39536, 39534,
+39535, 40480, 20389, 20392, 21294, 21388, 23581, 21589, 21497, 21949,
+21863, 21716, 22242, 22270, 23576, 22443, 22545, 23551, 26790, 22842,
+22849, 22954, 23454, 23517, 23545, 23649, 23853, 23702, 24065, 24124,
+24443, 24577, 24815, 24696, 24813, 24808, 25602, 25524, 25530, 30021,
+33635, 26538, 28378, 28173, 27721, 28385, 28382, 28176, 28072, 28063,
+27818, 28180, 28183, 28068, 33639, 23572, 33638, 29425, 29712, 29595,
+30111, 30113, 30127, 30186, 23613, 30417, 30805, 31087, 31096, 31181,
+31216, 27964, 31389, 31546, 31581, 32509, 32510, 32508, 32496, 32491,
+32511, 32039, 32512, 32434, 32494, 32504, 32501, 32438, 32500, 32490,
+32513, 32502, 32602, 38395, 33669, 30422, 33642, 33485, 34432, 35829,
+35821, 35820, 35748, 35819, 35823, 35828, 35824, 35826, 35825, 35827,
+35822, 23486, 36168, 36170, 36213, 36214, 36741, 36740, 36731, 36828,
+36874, 36882, 38128, 38134, 38108, 38125, 38114, 38124, 38120, 38133,
+38115, 38402, 38394, 38397, 38401, 38400, 38469, 39047, 39046, 39122,
+39290, 39292, 39285, 39287, 39539, 32942, 39600, 40483, 40482,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 20964, 40784, 20159, 20202, 20215, 20396, 20393,
+20461, 21095, 21016, 21073, 21053, 21385, 21792, 22068, 21719, 22040,
+21943, 21880, 21501, 22687, 22367, 22368, 22549, 23092, 23157, 22953,
+23047, 23046, 23485, 23457, 20889, 23618, 23956, 24092, 24223, 21416,
+24217, 21422, 24191, 24377, 24198, 34385, 24551, 24578, 24751, 24814,
+24868, 24579, 25370, 25169, 25438, 25320, 25376, 25242, 25528, 25599,
+25932, 25968, 26242, 26165, 26679, 26729, 26530, 26631, 27004, 26728,
+20048, 26526, 27431, 27527, 27572, 27974, 27900, 27905, 27975, 28291,
+28070, 28071, 27988, 28909, 22870, 33721, 30126, 30353, 30385, 30424,
+30830, 30721, 31377, 31351, 32532, 32451, 32428, 32516, 32517, 32521,
+32534, 32536, 32447, 32526, 32531, 32525, 32514, 32520, 32519, 39554,
+32610, 33014, 32932, 33714, 33643, 33931, 34430, 34583, 21355, 35850,
+35845, 35848, 35846, 35806, 35831, 35832, 35838, 35839, 35844, 35843,
+35841, 35770, 35812, 35847, 35837, 35840, 31446, 36180, 36175, 36171,
+36145, 36134, 36172, 36132, 21334, 36176, 36136, 36179, 36341, 36745,
+36742, 36749, 36744, 36743, 36718, 36750, 36747, 36746, 36866, 36801,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 37051, 37073, 37011, 38156, 38161, 38144,
+38138, 38096, 38148, 38109, 38160, 38153, 38155, 38049, 38146, 38398,
+38405, 24041, 39049, 39052, 20859, 39295, 39297, 39548, 39547, 39543,
+39542, 39549, 39550, 39545, 39544, 39607, 38393, 40063, 40065, 40489,
+40486, 40632, 40831, 20454, 20647, 20394, 24130, 21058, 21544, 21725,
+22003, 22438, 22363, 22859, 34949, 23398, 23548, 23466, 20973, 24811,
+25044, 24518, 25112, 25317, 25377, 25374, 25454, 25523, 25321, 25441,
+25285, 25373, 21382, 26195, 26196, 26137, 26726, 27178, 26641, 26925,
+26725, 26426, 26721, 28096, 27987, 27901, 27978, 27811, 28582, 28177,
+28861, 28903, 28783, 28907, 28950, 29420, 29585, 29935, 30232, 21346,
+30610, 30742, 30875, 31215, 39062, 31267, 31397, 31491, 31579, 32546,
+32547, 33830, 32538, 21439, 32543, 32540, 32537, 32457, 33147, 20852,
+33329, 33633, 33831, 33436, 34434, 33828, 35044, 20146, 35278, 35867,
+35866, 35855, 35763, 35851, 35853, 35856, 35864, 35834, 35858, 35859,
+35773, 35861, 35865, 35852, 35862, 36182, 36752, 36753, 36755, 36751,
+21150, 36873, 36831, 36797, 36951, 37050, 38189, 38191, 38192, 38169,
+38065,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 38050, 38177, 24405, 38126, 38181,
+38182, 38175, 38178, 38193, 38414, 38543, 38505, 38745, 33148, 39050,
+39048, 39057, 39060, 22836, 39059, 39056, 39302, 39279, 39300, 39301,
+39559, 39560, 39558, 39608, 39612, 40077, 40501, 40490, 40495, 40493,
+40499, 40857, 40863, 20248, 20607, 20648, 21169, 21659, 21523, 21387,
+22489, 23156, 23252, 23351, 23604, 23654, 23679, 23896, 24110, 24357,
+24212, 24691, 25103, 20987, 25380, 25319, 25311, 25601, 25947, 27609,
+26279, 26723, 26816, 26727, 26633, 27183, 27539, 27617, 27870, 28392,
+27982, 28059, 28389, 28073, 28493, 33829, 28799, 28891, 28905, 22681,
+29406, 33719, 29615, 29815, 30184, 30103, 30699, 30970, 30710, 31699,
+31914, 38214, 31937, 32553, 32489, 32554, 32533, 32551, 32503, 32541,
+24635, 32437, 32555, 32420, 32549, 32358, 32550, 22768, 32874, 32852,
+32824, 33043, 32966, 33080, 33037, 20020, 20030, 33392, 34103, 34015,
+20111, 34684, 34632, 20149, 35099, 35274, 35868, 35876, 35878, 35762,
+35854, 35875, 35874, 35466, 35879, 36186, 36187, 36141, 36185, 36235,
+36758, 36759, 27586, 36757, 33286, 36824, 36808, 37213, 38208, 38209,
+38170, 38190,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 38194, 38149, 38180, 38202,
+38201, 38203, 38206, 38199, 38420, 38421, 38417, 38385, 38544, 38582,
+34429, 38889, 39063, 39123, 39563, 39567, 40092, 40091, 40084, 40081,
+40511, 40509, 28857, 25995, 19995, 22108, 22329, 22418, 23158, 25041,
+25193, 25527, 25200, 25781, 25670, 25822, 25783, 26029, 27103, 26588,
+27099, 26592, 27428, 24402, 27553, 27899, 28182, 28388, 28174, 28293,
+27983, 28908, 28952, 29367, 29454, 29934, 30112, 30545, 30784, 31036,
+31313, 31229, 31388, 31373, 31659, 31783, 31658, 31697, 31616, 31918,
+32455, 32558, 32469, 32557, 32483, 32559, 32728, 32844, 32834, 33040,
+33169, 26087, 33832, 34013, 33632, 34546, 34633, 35280, 35294, 35871,
+35880, 35884, 35882, 36184, 36434, 36857, 36344, 36527, 36716, 36761,
+36841, 21307, 37233, 38225, 38145, 38056, 38221, 38215, 38224, 38226,
+38217, 38422, 38383, 38423, 38425, 26434, 21452, 38607, 40481, 39069,
+39068, 39064, 39066, 39067, 39311, 39306, 39304, 39569, 39617, 40104,
+40100, 40107, 40103, 40515, 40517, 40516, 22404, 22364, 23456, 24222,
+24208, 24809, 24576, 25042, 25314, 26103, 27249, 26911, 27016, 27257,
+28487, 28625, 27813,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 28626, 27896, 28865,
+29261, 29322, 20861, 29549, 29626, 29756, 30068, 30250, 30861, 31095,
+31283, 31614, 33575, 32462, 32499, 32472, 32599, 32564, 33211, 33402,
+34222, 33647, 34433, 34631, 35014, 34948, 35889, 35782, 35885, 35890,
+35749, 35887, 36192, 36190, 36343, 36762, 36735, 36766, 36793, 38236,
+38237, 38238, 38142, 38231, 38232, 38230, 38233, 38197, 38210, 38143,
+37694, 20851, 38471, 38590, 38654, 38892, 38901, 31867, 39072, 39125,
+39314, 39313, 39579, 39575, 40120, 40115, 40109, 40119, 40529, 40521,
+40522, 40524, 40527, 20029, 40628, 21149, 21657, 22052, 20005, 23453,
+24748, 24527, 25318, 25600, 32999, 27015, 28572, 28491, 28809, 29649,
+30719, 30778, 30718, 30782, 31398, 31454, 31609, 31726, 36779, 32548,
+32487, 32578, 33002, 33328, 34108, 34106, 33446, 33529, 34164, 34461,
+35124, 35273, 35302, 35758, 35793, 35893, 36194, 36193, 36280, 37322,
+38047, 38105, 38152, 38416, 39128, 39286, 39269, 39582, 33150, 39578,
+40131, 40133, 20826, 40835, 40836, 20458, 21995, 21869, 22179, 23646,
+24807, 24913, 25668, 25658, 26003, 27185, 26639, 26818, 27516, 28866,
+29306, 38262, 29838, 30302,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 32544, 32493,
+20848, 34259, 34510, 35272, 35892, 25252, 35465, 36163, 36364, 36291,
+36347, 36720, 36777, 38256, 38253, 38081, 38107, 38094, 38255, 38220,
+21709, 39038, 39074, 39144, 39537, 39584, 34022, 39585, 39621, 40141,
+40143, 33722, 40548, 40542, 40839, 40840, 21870, 20456, 20645, 21587,
+23402, 24005, 23782, 24367, 25674, 26435, 27426, 28393, 29473, 21472,
+30270, 30307, 31548, 31809, 32843, 33039, 34989, 34924, 35835, 36174,
+36189, 36399, 36396, 36756, 37094, 38136, 37492, 38657, 38801, 32366,
+39076, 39556, 39553, 40150, 40098, 40148, 40151, 40551, 40485, 40761,
+40841, 40842, 40858, 24651, 25371, 25605, 29906, 31363, 32552, 33250,
+33821, 34506, 21464, 36902, 36923, 38259, 38084, 38757, 26174, 39181,
+24778, 39551, 39564, 39635, 39633, 40157, 40158, 40156, 40502, 22065,
+22365, 25597, 30251, 30315, 32641, 34453, 35753, 35863, 35894, 33395,
+36195, 37247, 38643, 28789, 38701, 39078, 39588, 39699, 39751, 40078,
+40560, 40557, 30839, 30416, 40140, 40844, 40843, 21381, 27012, 28286,
+31729, 31657, 34542, 35266, 36433, 34885, 38053, 39045, 39307, 39627,
+40649, 28390, 30633, 38218, 38831,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 39540,
+39589, 32518, 35872, 36495, 37245, 38075, 37550, 38179, 40132, 40072,
+40681, 20991, 40550, 39562, 40563, 40510, 38074, 20162, 34381, 27538,
+22439, 22395, 25099, 20451, 21037, 21389, 21593, 21370, 32424, 33543,
+38023, 38022, 21591, 24362, 31059, 32446, 37071, 38028, 21072, 21286,
+22261, 22445, 23045, 23741, 23811, 28062, 28172, 28867, 30502, 32448,
+32464, 33003, 38030, 38032, 38037, 38029, 38379, 22955, 23899, 24701,
+26720, 26536, 27817, 27976, 30066, 30743, 32471, 33757, 35271, 35765,
+35790, 35794, 36150, 36147, 36730, 36725, 36728, 36911, 37075, 37124,
+38059, 38060, 38043, 38063, 38061, 38058, 38390, 38503, 39032, 39275,
+40697, 20251, 20603, 20325, 21794, 22450, 24047, 24493, 28828, 33557,
+29426, 29614, 32488, 32480, 32481, 32671, 33645, 34545, 35795, 35798,
+35817, 35796, 35804, 36241, 36738, 36737, 37036, 38090, 38088, 38064,
+38066, 38070, 38157, 38092, 38077, 38076, 39043, 39040, 20971, 40702,
+20606, 21787, 23901, 24123, 24747, 24749, 24580, 25132, 25111, 25247,
+25248, 25532, 26724, 26473, 33637, 27986, 27812, 28829, 30386, 30720,
+32507, 32498, 32495, 32506, 33715, 35275,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+35830, 36167, 38129, 38098, 38097, 38101, 38111, 38123, 38127, 38122,
+38135, 38102, 38117, 39121, 21055, 21154, 21715, 21586, 23810, 23780,
+24209, 24870, 25378, 26912, 27637, 39053, 28061, 28514, 28064, 28375,
+29711, 29825, 30231, 32515, 32535, 32524, 32527, 32529, 33628, 33932,
+33553, 33473, 35833, 35836, 35842, 36181, 37112, 38162, 38103, 38141,
+38163, 38154, 38116, 38150, 38151, 38164, 38406, 38403, 38739, 39055,
+39293, 39541, 39552, 40066, 40488, 21714, 21717, 21721, 23250, 23748,
+24639, 27546, 27981, 28904, 29443, 29423, 30876, 31405, 32279, 32539,
+33927, 33640, 33929, 33630, 33720, 33431, 34547, 35816, 35857, 35860,
+35869, 37072, 38185, 38188, 38166, 38167, 38140, 38171, 38165, 38174,
+38036, 38415, 38408, 38409, 38410, 38412, 38413, 40498, 40497, 21724,
+24113, 24697, 25672, 58305, 27894, 29461, 29971, 30213, 30187, 30807,
+31654, 31578, 31976, 32545, 32807, 33631, 33718, 34544, 35042, 35279,
+35873, 35788, 35877, 36292, 38200, 38196, 38113, 38198, 38418, 39271,
+40082, 40085, 40504, 40505, 40506, 40832, 24636, 25669, 25784, 27898,
+30102, 32523, 32873, 33641, 34789, 34414, 35764,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 35881, 36188, 36157, 36760, 37021, 38227, 38112, 38204, 38223,
+34021, 38890, 39273, 39568, 39570, 39571, 38411, 40105, 40096, 40520,
+40513, 40518, 21411, 21590, 22406, 27104, 26638, 27655, 27895, 28486,
+31074, 32562, 32563, 32628, 33315, 34511, 34431, 35043, 35281, 35311,
+35886, 38235, 38239, 38250, 38214, 38121, 38891, 39073, 39312, 39618,
+40117, 40118, 40123, 40113, 40526, 40491, 40700, 21950, 25732, 26634,
+26533, 26636, 32561, 32845, 33551, 33480, 34162, 34548, 34686, 38132,
+38246, 38248, 38241, 38243, 38212, 38251, 38119, 38244, 38137, 38426,
+39071, 39316, 39546, 39581, 39583, 39576, 40535, 40538, 40540, 40838,
+40837, 20649, 23743, 30152, 25786, 27017, 28384, 30779, 31901, 32425,
+32556, 34105, 36166, 38257, 38396, 39129, 39586, 39574, 39580, 40101,
+40142, 40144, 40547, 40536, 40574, 20865, 23048, 28757, 25874, 30271,
+31656, 31860, 33339, 35276, 36345, 36318, 36729, 38228, 38252, 39587,
+39557, 40149, 40099, 40102, 40552, 40503, 40859, 26686, 26916, 34016,
+38624, 36723, 40159, 40095, 40553, 40556, 40554, 40555, 40519, 28751,
+31766, 35888, 39628, 31550, 31900, 32565, 33044, 36479,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 38247, 40090, 36273, 36508, 37246, 35891, 39070, 39079,
+39591, 40492, 25094, 38404, 40097, 40514, 31160, 25300, 36299, 29648,
+23467, 25296, 27585, 20943, 31108, 21525, 28508, 34972, 37095, 20857,
+25144, 25243, 25383, 25531, 25566, 25594, 25745, 25792, 25825, 25846,
+25861, 25909, 25934, 25963, 25992, 26073, 26142, 26171, 26175, 26180,
+26199, 26217, 26227, 26243, 26300, 26303, 26305, 26357, 26362, 26363,
+26382, 26390, 26423, 26468, 26470, 26534, 26535, 26537, 26619, 26621,
+26624, 26625, 26629, 26654, 26698, 26706, 26709, 26713, 26765, 26809,
+26831, 20616, 38184, 40087, 26914, 26918,   220, 58591, 58592,   252,
+58594, 58595,   220,   252, 26934, 26977, 33477, 33482, 33496, 33560,
+33562, 33571, 33606, 33627, 33634, 33644, 33646, 33692, 33695, 33717,
+33724, 33783, 33834, 33864, 33884, 33890, 33924, 33928, 34012, 34019,
+34104, 34138, 34199, 34219, 34241, 34323, 34326,  8715, 34581, 34672,
+34685, 34699, 34728, 34759, 34768, 34823, 34830, 34855, 34990,  8712,
+34997, 35007, 35045, 35061, 35100, 35101, 35191, 35303, 35383, 35500,
+35546, 35675, 35697, 35883, 35898, 35964, 35982, 36014, 36114,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 36169, 36173, 36209, 36360, 36410, 36464, 36505,
+36528, 36529, 36549, 36550, 36558, 36579, 36620, 36721, 36727, 36775,
+36847, 36878, 36921, 36965, 37001, 37086, 37141, 37334, 37339, 37342,
+37345, 37349, 37366, 37372, 37417, 37420, 65287, 37465, 37495, 37613,
+37690, 58701, 58702, 29227, 20866, 20886, 20023, 20843, 20799, 58709,
+58710, 26409, 27706, 21378, 30098, 32896, 34916, 19974, 58718, 58719,
+58720, 11927, 21241, 21269,  8225, 58725, 13316, 58727, 58728, 58729,
+58730, 58731, 20981, 58733, 23662, 58735, 22231, 20128, 20907, 11904,
+27079, 58741,  9550,  9688,  9689,  9794,  9654,  9668,  8597,  8252,
+  182,  8704,  8616,  8596,  8962, 58755, 58756, 20124, 24746, 22311,
+22258, 21307, 22769, 36920, 38560, 26628, 21942, 39365, 35585, 20870,
+32257, 24540, 27431, 27572, 26716, 22885, 31311, 20206, 20385, 30011,
+28784, 20250, 24724, 28023, 32117, 22730, 25040, 25313, 27579, 35226,
+23398, 27005, 21917, 28167, 58794, 24059, 38501, 21223, 23515, 28450,
+38306, 27475, 35251, 27671, 24112, 25135, 29344, 34384, 26087, 24613,
+25312, 25369, 34394, 23777, 25375, 29421, 37111, 38911, 26241, 21220,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 35641, 21306, 39366, 21234, 58824, 24452,
+33550, 24693, 25522, 28179, 32076, 34509, 36605, 32153, 40335, 25731,
+30476, 20537, 21091, 38522, 22287, 26908, 27177, 38997, 39443, 21427,
+21577, 23087, 35492, 24195, 28207, 37489, 21495, 22269, 40658, 31296,
+30741, 28168, 25998, 27507, 21092, 38609, 21442, 26719, 24808, 36059,
+27531, 27503, 20816, 36766, 28287, 23455, 20889, 33294, 25448, 37320,
+23551, 21454, 34886, 24467, 28171, 29539, 32294, 31899, 20966, 23558,
+31216, 28169, 28988, 22888, 26465, 29366, 20055, 27972, 21104, 30067,
+32260, 22732, 23330, 35698, 37304, 35302, 22065, 23517, 23613, 22259,
+31883, 37204, 31298, 38543, 39620, 26530, 25968, 25454, 28716, 22768,
+25993, 38745, 31363, 25666, 32118, 23554, 27973, 25126, 36341, 37549,
+28508, 36983, 36984, 32330, 31109, 30094, 22766, 20105, 33624, 25436,
+25407, 24035, 31379, 35013, 20711, 23652, 32207, 39442, 22679, 24974,
+34101, 36104, 33235, 23646, 32154, 22549, 23550, 24111, 28382, 28381,
+25246, 27810, 28655, 21336, 22022, 22243, 26029, 24382, 36933, 26172,
+37619, 24193, 24500, 32884, 25074, 22618, 36883, 37444, 28857, 36578,
+20253,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 38651, 28783, 24403, 20826, 30423,
+31282, 38360, 24499, 27602, 29420, 35501, 23626, 38627, 24336, 24745,
+33075, 25309, 24259, 22770, 26757, 21338, 34180, 40614, 32283, 30330,
+39658, 25244, 27996, 27996, 25935, 25975, 20398, 25173, 20175, 36794,
+22793, 27497, 33303, 31807, 21253, 23453, 25265, 27873, 32990, 30770,
+35914, 39165, 22696, 27598, 28288, 33032, 40665, 35379, 34220, 36493,
+19982, 35465, 25671, 27096, 35617, 26332, 26469, 38972, 20081, 35239,
+31452, 38534, 26053, 20001, 29471, 32209, 28057, 22593, 31036, 21169,
+25147, 38666, 40802, 26278, 27508, 24651, 32244, 37676, 28809, 21172,
+27004, 37682, 28286, 24357, 20096, 26365, 22985, 23437, 23947, 27179,
+26907, 21936, 31874, 36796, 27018, 21682, 40235, 38635, 26905, 25539,
+39364, 20967, 26626, 36795, 20685, 23776, 26627, 20970, 21250, 30834,
+30033, 30048, 22138, 37618, 22592, 26622, 20451, 26466, 31870, 21249,
+20452, 20453, 20969, 21498, 21720, 22222, 22310, 22327, 22328, 22408,
+22451, 22442, 22448, 22486, 22640, 22713, 22743, 23670, 23740, 23749,
+23742, 23926, 24342, 24634, 25525, 26433, 26467, 26529, 26810, 26917,
+26920, 27258,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 26915, 26913, 27006, 27009,
+27101, 27182, 27250, 27423, 27615, 28181, 29077, 29927, 29938, 29936,
+29937, 29944, 29957, 30057, 30314, 30836, 31437, 31439, 31445, 31443,
+31457, 31472, 31490, 31763, 31767, 31888, 31917, 31936, 31960, 32155,
+32261, 32359, 32387, 32400, 33188, 33373, 33826, 34009, 34352, 34475,
+34543, 34992, 35011, 35012, 35076, 59183, 36542, 36552, 36684, 36791,
+36826, 36903, 36950, 37685, 37691, 37817, 38282, 38294, 38777, 38790,
+38800, 39082, 39830, 39831, 39860, 39887, 39889, 39890, 39922, 39921,
+39984, 40007, 40026, 40176, 40262, 40292, 40363, 20036, 21583, 25368,
+39857, 40041, 40263, 40293, 39983, 40639, 20916, 21610, 26528, 39822,
+37032, 20914, 13869, 25285, 21189, 26545, 21709, 24658, 21441, 28913,
+22531, 21855, 37390, 30528, 29756, 29002, 28377, 21472, 29486, 35023,
+30861, 32675, 32171, 36394, 37979, 25452, 24487, 23557, 32827, 23791,
+14776, 29009, 36045, 38894, 22642, 23139, 32632, 23895, 24943, 27032,
+32137, 31918, 32179, 28545, 23290, 22715, 29269, 30286, 36653, 37561,
+40286, 40623, 32583, 40388, 36120, 20915, 34412, 21668, 21414, 21030,
+26422, 20001, 21364,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 24313, 21177, 21647,
+24312, 22956, 24625, 29248, 33047, 30267, 24333, 26187, 26280, 24932,
+25423, 28895, 27940, 31911, 31945, 21465, 25933, 22338, 29647, 32966,
+13649, 27445, 30849, 21452, 29483, 29482, 29641, 30026, 23033, 29124,
+29966, 32220, 39393, 35241, 28662, 14935, 25834, 15341, 27809, 28284,
+30055, 22633, 22633, 20996, 59338, 24967, 25658, 33263, 59342, 20917,
+20945, 27769, 22815, 36857, 39153, 25911, 33033, 34996, 14890, 36525,
+32663, 39440, 32037, 27336, 20876, 21031, 59360, 33050, 21408, 21410,
+27738, 27703, 33304, 21894, 24315, 20937, 30897, 37474, 21357, 20931,
+59374, 33905, 35207, 38765, 35728, 38563, 24316, 38583, 20814, 39952,
+26160, 37461, 30728, 37701, 37491, 37737, 59390, 59391, 59392, 59393,
+37343, 37338, 30804, 30822, 30856, 30902, 30919, 30930, 30935,  8491,
+ 8651, 30948, 30958, 30960, 30961, 30965, 31026, 31027, 31030, 31064,
+12307, 31065, 31089, 31102, 31107, 31110, 31111, 31121, 31129, 31135,
+31141, 31202, 31217, 31220, 31274, 31290, 31301, 31333, 31420, 31426,
+31433, 31451, 31465, 31486, 31500, 31527, 31529, 31554, 31555, 31573,
+31599, 31666, 27102, 27129,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 37238, 33114,
+33527, 21579, 33074, 32957, 33816, 37214, 37232, 37260, 33096, 59459,
+17462, 33113, 32927, 59463, 21833, 21537, 21722, 21554, 21945, 21652,
+59470, 30802, 30789, 30796, 59474, 33981, 33820, 33476, 59478, 33915,
+35629, 59481, 22347, 59483, 59484, 22341, 34766, 22112, 21994, 22139,
+32956, 59491, 30904, 27148, 21708, 31696, 31724, 31738, 31765, 31771,
+31797, 31812, 31853, 31886, 31928, 31939, 31974, 31981, 31987, 31989,
+31993, 59511, 31996, 32139, 32151, 32164, 32168, 32205, 32208, 32211,
+32229, 32253, 27154, 27170, 27184, 27190, 27237, 59527, 59528, 59529,
+59530, 59531, 59532, 59533, 59534, 27251, 27256, 59537, 59538, 27260,
+27305, 27306,  9450,  9312,  9313,  9314,  9315,  9316,  9317,  9318,
+ 9319,  9320,  9321,  9322,  9323,  9324,  9325,  9326,  9327,  9328,
+ 9329,  9330,  9331, 37700, 37805, 37830, 37861, 37914, 37921, 37950,
+37953, 37971, 37978, 38042, 38071, 38104, 38110, 38131, 38147, 38158,
+38159, 38168, 38173, 38186, 38187, 38207, 38213, 38222, 38242, 38245,
+38249, 38258, 38279, 38297, 38304, 38322, 38502, 38557, 38575, 38578,
+38707, 38715, 38733, 38735, 38737,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 38741,
+38756, 38763, 38769, 38802, 38834, 38898, 38973, 38996, 39077, 39107,
+39130, 39150, 39197, 39200, 39267, 39296, 39303, 39309, 39315, 39317,
+39356, 39368, 39410, 39606, 39641, 39646, 39695, 39753, 39794, 39811,
+39839, 39867, 39907, 39925, 39936, 39940, 39963,  9398,  9399,  9400,
+ 9401,  9402,  9403,  9404,  9405,  9406,  9407,  9408,  9409,  9410,
+ 9411,  9412,  9413,  9414,  9415,  9416,  9417,  9418,  9419,  9420,
+ 9421,  9422,  9423,  9424,  9425,  9426,  9427,  9428,  9429,  9430,
+ 9431,  9432,  9433,  9434,  9435,  9436,  9437,  9438,  9439,  9440,
+ 9441,  9442,  9443,  9444,  9445,  9446,  9447,  9448,  9449,   174,
+ 8482, 59697, 59698, 40054, 10102, 10103, 10104, 10105, 10106, 10107,
+10108, 10109, 10110, 10111, 40069, 40070, 40071, 40075, 40080, 40094,
+40110, 40112, 40114, 40116, 40122, 40124, 40125, 40134, 40135, 40138,
+40139, 40147, 40152, 40153, 40162, 40171, 40172, 40234, 40264, 40272,
+40314, 40390, 40523, 40533, 40539, 40561, 40618, 40637, 40644, 40674,
+40682, 40712, 40715, 40717, 40737, 40772, 40785, 40861, 64014, 64015,
+64017, 64019, 64020, 64024, 64031, 64032,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+64033, 64035, 64036, 64039, 64040, 64041, 19972, 20015, 20097, 20103,
+20131, 20151, 20156, 20216, 20264, 20265, 20279, 20290, 20293, 20299,
+20338, 20386, 20400, 20413, 20424, 20428, 20464, 20466, 20473, 20483,
+20488, 20532, 20539, 20568, 20582, 20609, 20624, 20668, 20688, 20703,
+20705, 20732, 20749, 20779, 20832, 20910, 20920, 20946, 20962, 20997,
+21044, 21052, 21081, 21096, 21113, 21156, 21196, 21287, 21314, 21341,
+21373, 21374, 21445, 21456, 21458, 21502, 21613, 21637, 21651, 21662,
+21689, 21731, 21743, 21773, 21784, 21797, 21800, 21803, 21831, 21881,
+21904, 21940, 21953, 21975, 21976, 22011, 20404, 22049,  8707, 22098,
+59852,  9787, 59854, 59855, 22109,  9332,  9333,  9334,  9335,  9336,
+ 9337,  9338,  9339,  9340,  9341,  9342,  9343,  9344,  9345,  9346,
+ 9347,  9348,  9349,  9350,  9351, 22113, 22153, 22155, 22174, 22177,
+22193, 22201, 22207, 22230, 22255, 22293, 22301, 22322, 22333, 22335,
+22339,  8660, 22398, 22410, 22413, 22416, 22428, 22459, 22462, 22468,
+22494, 22526, 22546, 22562, 22599, 22620, 22623, 22643, 22695, 22698,
+22704, 22709, 22710, 22731, 22736, 22752, 22789,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 22801, 22921, 22932, 22938, 22943, 22960, 22968, 22980, 23023,
+23024, 23032, 23042, 23051, 23053, 23058, 23073, 23076, 23079, 23082,
+23083, 23084, 23101, 23109, 23124, 23129, 23137, 23144, 23147, 23150,
+23153, 23161, 23166, 23169, 23170, 23174, 23176, 23185, 23193, 23200,
+23201, 23211, 23235, 23246, 23247, 23251, 23268, 23280, 23294, 23309,
+23313, 23317, 23327, 23339, 23361, 23364, 23366, 23370, 23375, 23400,
+23412, 23414, 23420, 23426, 23440,  9372,  9373,  9374,  9375,  9376,
+ 9377,  9378,  9379,  9380,  9381,  9382,  9383,  9384,  9385,  9386,
+ 9387,  9388,  9389,  9390,  9391,  9392,  9393,  9394,  9395,  9396,
+ 9397, 60009, 12850, 12849, 27307, 23446,  9352,  9353,  9354,  9355,
+ 9356,  9357,  9358,  9359,  9360,  9361,  9362,  9363,  9364,  9365,
+ 9366,  9367,  9368,  9369,  9370,  9371, 23509, 23511, 23587, 23685,
+23710, 23746, 23824, 23852, 23855, 23880, 23894, 23920, 23931, 23941,
+23972, 23979, 23990, 24001, 24023, 24073, 24136, 24210, 24253, 24334,
+24434, 24497, 24514, 24539, 24543, 24611, 24702, 24791, 24839, 24844,
+24857, 24866, 24912, 24928, 24961, 24981, 25017, 25024,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 25039, 25043, 25050, 25232, 25393,  8835, 25399, 25465,
+25483, 25537, 25570, 25574, 25595, 25598, 25607, 25650, 25656, 25659,
+25690, 25713, 25724, 25741, 25775, 25780, 25782, 25821, 25829, 25866,
+25873, 25887, 25951, 25965, 25990, 26037, 26046, 26065, 26068, 26083,
+26111, 26136, 26147, 26211, 26219, 26237, 26245, 26258, 26266, 26276,
+26285, 26291, 26294, 26317, 26318, 26370, 26380, 26393, 26436, 26475,
+26511, 26532, 26559, 26582, 26583,  8834, 26637, 26640, 26651, 26678,
+26695, 26710, 26756, 26760, 26813, 26819, 26821, 26882, 26883, 26889,
+26904, 26947, 26950, 26980, 26983, 26994, 27013, 27039, 27042, 27089,
+27093, 27094, 39457, 39462, 39471, 27329, 22975, 27105, 27139, 27162,
+27164, 27180, 27181, 27187, 27203, 27205, 27212, 27219, 27223, 27235,
+27252, 27266, 27274, 27279, 27289, 27303, 27313, 27317, 27326, 27337,
+27348, 27352, 27382, 27479, 27514, 27612, 27676, 27697, 27736, 27758,
+27765, 27775, 27823, 27851, 27871, 27903, 27906, 27909, 27910, 27942,
+27991, 27995, 28017, 28033, 28047, 28069, 28081, 28158, 28162, 28164,
+28175, 28184, 28202, 28240, 28249, 28314, 28341, 28344, 28379,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 28410, 28420, 28427, 28428, 28438, 28439, 28468,
+28477, 28502, 28537, 28554, 28573, 28575, 28603, 28606, 28627, 28633,
+28664, 28675, 28747, 28749, 28752, 28756, 28764, 28775, 28791, 28793,
+28811, 28815, 28832, 28835, 28837, 28838, 28839, 28868, 28876, 28880,
+28886,   618,   603,   230,   652,   593,   596,   650,   605,   601,
+  602,   604,   609,  7747,  7753,   330,  7739,   629,   240,   643,
+  658,   679,   676,   227, 60294, 60295,   623,   632,   647, 60299,
+  199,   339,   594, 65351,   715,   719, 65345, 65346, 65348, 65349,
+65350, 65352, 65353, 65354, 65355, 65356, 65357, 65358, 65359, 65360,
+65362, 65363, 65364, 65365, 65366, 65367, 65370, 28917, 12832, 12833,
+12834, 12835, 12836, 12837, 12838, 12839, 12840, 12841, 28926, 28933,
+28957, 28969, 28971, 28972, 28979, 28981, 28987, 28990, 28992, 29007,
+29035, 29045, 29047, 29052, 29054, 29068, 29070, 29073, 29078, 29090,
+29091, 29101, 29108, 29111, 29114, 29137, 29149, 29163, 29184, 29193,
+29198, 29199, 29206, 29207, 29220, 23204, 29230,  8838, 29271, 29276,
+29332, 29444, 29456, 29505, 29556, 29580, 29583, 29592, 29596, 29598,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 29607, 29610, 29653, 29665, 29666, 29668,
+29670, 29679, 29683,  8839, 29689, 29691, 29698, 29713, 29714, 29716,
+29717, 29719, 29721, 29724, 29726, 29727, 29751, 29752, 29753, 29763,
+29765, 29767, 29768, 29769, 29779, 29782, 29797, 29803, 29804, 29812,
+29818, 29826, 21378, 24191, 20008, 24186, 20886, 23424, 21353, 11911,
+60436, 21251,  9746, 33401, 17553, 11916, 11914, 20022, 60444, 21274,
+60446, 60447, 11925, 60449, 60450,  9492, 20058, 36790, 24308, 20872,
+20101, 60457, 20031, 60459, 60460, 20059, 21430, 36710, 32415, 35744,
+36125, 40479, 38376, 38021, 38429, 25164, 27701, 20155, 24516, 28780,
+11950, 21475, 27362, 39483, 39484, 39512, 39516, 39523,  9742,  8594,
+ 8592,  8593,  8595,  8680,  8678,  8679,  8681,  8680,  8678,  8679,
+ 8681,  9758,  9756,  9755,  9759, 12310, 12311,  9675, 10005, 10003,
+22267,  9789, 22813, 26189, 29221, 10025, 10017,  9786,  9785, 60515,
+60516, 60517, 60518, 60519, 23672,  9836,  9834, 23249, 23479, 23804,
+60526,  9993,  9986, 60529, 60530, 60531, 60532, 23765, 26478, 29793,
+29853, 32595, 34195, 10063, 60540, 60541, 23928, 24379, 60544,  9473,
+ 9475,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 60547, 60548, 60549, 60550, 60551,
+60552, 60553, 60554, 60555, 60556, 60557, 60558, 60559, 60560, 60561,
+39602, 39648, 39700, 39732, 39737, 39744, 39760, 39807,  9788, 32149,
+ 9729, 38708,  9730, 60575, 60576, 60577,  9992, 60579, 60580, 60581,
+60582, 60583, 60584, 60585,  8507,  8481, 26343, 28247, 60590, 29015,
+31178,  8470, 33132, 35577, 38998, 60597, 60598,  9760, 60600,  9828,
+ 9824,  9831,  9827,  9826,  9830,  9825,  9829, 60609, 60610, 27364,
+ 8478, 13250, 13272, 13217, 60616, 13221, 60618, 60619, 60620, 60621,
+60622,  9745, 39809, 39819, 39821, 39901, 39913, 39917, 39924, 39967,
+39968, 39974, 40019, 40029, 40059, 40204, 40214,  8626, 27397, 36073,
+36082, 36099, 36113, 36124, 36218, 36265, 36288, 36353, 36366, 36422,
+36456, 36465, 36478, 36480, 36534, 36537, 36540, 36547, 36580, 36589,
+36594, 36656, 36673, 36682, 36773, 36787, 36792, 36810, 36815, 36872,
+36915, 36919, 36964, 36972, 37289, 37302, 37316, 37370, 37384, 37395,
+37409, 37416, 37419, 37429, 37436, 37441, 37464, 37469, 37471, 37483,
+37486, 37505, 37508, 37513, 37519, 37553, 37562, 37567, 37588, 37595,
+37603, 37605,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 37611, 37612, 37620, 37622,
+37629, 37635, 37639, 37680, 37681, 37696, 37698, 37699, 37727, 37730,
+37734, 37736, 37747, 37748, 37752, 37757, 37761, 37764, 37766, 37767,
+37776, 37788, 37792, 37816, 37819, 37821, 37823, 37835, 37843, 37851,
+37856, 37872, 37873, 37875, 37876, 37889, 37892, 37896, 37911, 37915,
+37917, 37924, 37925, 37926, 37933, 37954, 37955, 37965, 37972, 37976,
+37989, 37991, 37996, 38009, 38011, 38264, 38277, 38310, 38314, 38486,
+38523, 38565, 38644, 38683, 38710, 38720, 38721, 38743, 38791, 38793,
+38811, 38833, 38845, 38848, 38850, 38866, 38880, 38932, 38933, 38947,
+38963, 39016, 39095, 39097, 39111, 39114, 39136, 39137, 39148, 39157,
+40225, 40244, 40249, 40265, 40270, 40301,  8759, 40302, 40316, 40323,
+40339, 40357,  8748, 40381, 27521, 27569, 40015, 40592, 40384, 60817,
+60818,  9775,  9776,  9783,  9779,  9780,  9781,  9778,  9782,  9777,
+40393, 40404, 40444, 40458, 40460, 40462, 40472, 40571, 40581, 40610,
+40620, 40625, 40641, 40646, 40647, 40689, 40696, 40743, 39182, 39193,
+39196, 39223, 39261, 39266, 39323, 39332, 39338, 39352, 39392, 39398,
+39413, 39455, 32254,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 32263, 32347, 32357,
+32364, 32567, 32576, 32577, 32585, 32594, 32655, 32659, 32692, 32733,
+32743, 32762, 32770, 32776, 32814, 32815, 32828, 32935, 33036, 33066,
+33076, 33090, 33110, 33156, 33189, 33252, 33364, 33381, 33403, 33415,
+33471, 33506, 33518, 33528, 33532, 33535, 33547, 33565, 33597, 33623,
+33681, 33708, 33741, 33773, 33797, 33812, 33814, 33825, 33838, 33854,
+33866, 33875, 33877, 33880, 33892, 33906, 33919, 33920, 33938, 33939,
+33942, 33955, 33982, 34014, 34017, 34018, 34020, 34040, 34051, 34053,
+34064, 34099,  8208, 34114, 34124, 34130, 34143, 34159, 34160, 34163,
+34262, 34272, 34286, 34300, 34317, 34319, 34324, 34344, 34370, 34373,
+34418, 34972, 23405, 33079, 60958, 39224, 21874, 21867, 60962, 13774,
+21873, 21946, 22001, 13778, 22000, 22021, 22050, 22061, 22083, 22046,
+22162, 31949, 21530, 21523, 21655, 26353, 30004, 21581, 22180, 22175,
+25811, 25390, 25592, 25886, 20088, 27626, 27698, 27709, 27746, 27826,
+28152, 28201, 28278, 28290, 28294, 28347, 28383, 28386, 28433, 28452,
+28532, 28561, 28597, 28659, 28661, 28859, 28864, 28943,  8706, 29013,
+29043, 29050, 61016, 21027,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 61018, 13393,
+61020, 36812, 61022, 61023,   192,   200,   204,   210,   217,   193,
+  205,   211,   218,   257,   275,   299,   333,   363,   470,   196,
+  203,   207,   214,   220,   198,   199,   209,   195,   213,   225,
+  233,   237,   243,   250,   472,   228,   235,   239,   246,   252,
+  230,   231,   241,   227,   245,   462,   283,   464,   466,   468,
+  474,   197,   201, 29064,   216,   208,  7922,   222,   223,   170,
+  161,   224,   232,   236,   242,   249,   476,   229, 29080, 29143,
+  248,   240,  7923,   254,   255,   186,   191,   226,   234,   238,
+  244,   251, 29173,   194,   202,   206,   212,   219,   184,   164,
+61110,   402, 12288, 65292, 12289, 12290, 65294,  8231, 65307, 65306,
+65311, 65281, 65072,  8230,  8229, 65104, 65105, 65106,   183, 65108,
+65109, 65110, 65111, 65372,  8211, 65073,  8212, 65075,  9588, 65076,
+65103, 65288, 65289, 65077, 65078, 65371, 65373, 65079, 65080, 12308,
+12309, 65081, 65082, 12304, 12305, 65083, 65084, 12298, 12299, 65085,
+65086, 12296, 12297, 65087, 65088, 12300, 12301, 65089, 65090, 12302,
+12303, 65091, 65092, 65113, 65114,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 65115,
+65116, 65117, 65118,  8216,  8217,  8220,  8221, 12317, 12318,  8245,
+ 8242, 65283, 65286, 65290,  8251,   167, 12291,  9675,  9679,  9651,
+ 9650,  9678,  9734,  9733,  9671,  9670,  9633,  9632,  9661,  9660,
+12963,  8453,   175, 65507, 65343,   717, 65097, 65098, 65101, 65102,
+65099, 65100, 65119, 65120, 65121, 65291, 65293,   215,   247,   177,
+ 8730, 65308, 65310, 65309,  8806,  8807,  8800,  8734,  8786,  8801,
+65122, 65123, 65124, 65125, 65126, 65374,  8745,  8746,  8869,  8736,
+ 8735,  8895, 13266, 13265,  8747,  8750,  8757,  8756,  9792,  9794,
+ 8853,  8857,  8593,  8595,  8592,  8594,  8598,  8599,  8601,  8600,
+ 8741,  8739, 65295, 65340,  8725, 65128, 65284, 65509, 12306, 65504,
+65505, 65285, 65312,  8451,  8457, 65129, 65130, 65131, 13269, 13212,
+13213, 13214, 13262, 13217, 13198, 13199, 13252,   176, 20825, 20827,
+20830, 20829, 20833, 20835, 21991, 29929, 31950,  9601,  9602,  9603,
+ 9604,  9605,  9606,  9607,  9608,  9615,  9614,  9613,  9612,  9611,
+ 9610,  9609,  9532,  9524,  9516,  9508,  9500,  9620,  9472,  9474,
+ 9621,  9484,  9488,  9492,  9496,  9581,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+ 9582,  9584,  9583,  9552,  9566,  9578,  9569,  9698,  9699,  9701,
+ 9700,  9585,  9586,  9587, 65296, 65297, 65298, 65299, 65300, 65301,
+65302, 65303, 65304, 65305,  8544,  8545,  8546,  8547,  8548,  8549,
+ 8550,  8551,  8552,  8553, 12321, 12322, 12323, 12324, 12325, 12326,
+12327, 12328, 12329, 21313, 21316, 21317, 65313, 65314, 65315, 65316,
+65317, 65318, 65319, 65320, 65321, 65322, 65323, 65324, 65325, 65326,
+65327, 65328, 65329, 65330, 65331, 65332, 65333, 65334, 65335, 65336,
+65337, 65338, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 65352,
+65353, 65354, 65355, 65356, 65357, 65358, 65359, 65360, 65361, 65362,
+65363, 65364, 65365, 65366, 65367, 65368, 65369, 65370,   913,   914,
+  915,   916,   917,   918,   919,   920,   921,   922,   923,   924,
+  925,   926,   927,   928,   929,   931,   932,   933,   934,   935,
+  936,   937,   945,   946,   947,   948,   949,   950,   951,   952,
+  953,   954,   955,   956,   957,   958,   959,   960,   961,   963,
+  964,   965,   966,   967,   968,   969, 12549, 12550, 12551, 12552,
+12553, 12554, 12555, 12556, 12557, 12558, 12559,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 12560, 12561, 12562, 12563, 12564, 12565, 12566, 12567, 12568,
+12569, 12570, 12571, 12572, 12573, 12574, 12575, 12576, 12577, 12578,
+12579, 12580, 12581, 12582, 12583, 12584, 12585,   729,   713,   714,
+  711,   715,  9216,  9217,  9218,  9219,  9220,  9221,  9222,  9223,
+ 9224,  9225,  9226,  9227,  9228,  9229,  9230,  9231,  9232,  9233,
+ 9234,  9235,  9236,  9237,  9238,  9239,  9240,  9241,  9242,  9243,
+ 9244,  9245,  9246,  9247,  9249,  8364, 63561, 63562, 63563, 63564,
+63565, 63566, 63567, 63568, 63569, 63570, 63571, 63572, 63573, 63574,
+63575, 63576, 63577, 63578, 63579, 63580, 63581, 63582, 63583, 63584,
+63585, 63586, 63587, 63588, 63589, 19968, 20057, 19969, 19971, 20035,
+20061, 20102, 20108, 20154, 20799, 20837, 20843, 20960, 20992, 20993,
+21147, 21269, 21313, 21340, 21448, 19977, 19979, 19976, 19978, 20011,
+20024, 20961, 20037, 20040, 20063, 20062, 20110, 20129, 20800, 20995,
+21242, 21315, 21449, 21475, 22303, 22763, 22805, 22823, 22899, 23376,
+23377, 23379, 23544, 23567, 23586, 23608, 23665, 24029, 24037, 24049,
+24050, 24051, 24062, 24178, 24318, 24331, 24339, 25165,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 19985, 19984, 19981, 20013, 20016, 20025, 20043, 23609,
+20104, 20113, 20117, 20114, 20116, 20130, 20161, 20160, 20163, 20166,
+20167, 20173, 20170, 20171, 20164, 20803, 20801, 20839, 20845, 20846,
+20844, 20887, 20982, 20998, 20999, 21000, 21243, 21246, 21247, 21270,
+21305, 21320, 21319, 21317, 21342, 21380, 21451, 21450, 21453, 22764,
+22825, 22827, 22826, 22829, 23380, 23569, 23588, 23610, 23663, 24052,
+24187, 24319, 24340, 24341, 24515, 25096, 25142, 25163, 25166, 25903,
+25991, 26007, 26020, 26041, 26085, 26352, 26376, 26408, 27424, 27490,
+27513, 27595, 27604, 27611, 27663, 27700, 28779, 29226, 29238, 29243,
+29255, 29273, 29275, 29356, 29579, 19993, 19990, 19989, 19988, 19992,
+20027, 20045, 20047, 20046, 20197, 20184, 20180, 20181, 20182, 20183,
+20195, 20196, 20185, 20190, 20805, 20804, 20873, 20874, 20908, 20985,
+20986, 20984, 21002, 21152, 21151, 21253, 21254, 21271, 21277, 20191,
+21322, 21321, 21345, 21344, 21359, 21358, 21435, 21487, 21476, 21491,
+21484, 21486, 21481, 21480, 21500, 21496, 21493, 21483, 21478, 21482,
+21490, 21489, 21488, 21477, 21485, 21499, 22235, 22234, 22806,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 22830, 22833, 22900, 22902, 23381, 23427, 23612,
+24040, 24039, 24038, 24066, 24067, 24179, 24188, 24321, 24344, 24343,
+24517, 25098, 25171, 25172, 25170, 25169, 26021, 26086, 26414, 26412,
+26410, 26411, 26413, 27491, 27597, 27665, 27664, 27704, 27713, 27712,
+27710, 29359, 29572, 29577, 29916, 29926, 29976, 29983, 29992, 29993,
+30000, 30001, 30002, 30003, 30091, 30333, 30382, 30399, 30446, 30683,
+30690, 30707, 31034, 31166, 31348, 31435, 19998, 19999, 20050, 20051,
+20073, 20121, 20132, 20134, 20133, 20223, 20233, 20249, 20234, 20245,
+20237, 20240, 20241, 20239, 20210, 20214, 20219, 20208, 20211, 20221,
+20225, 20235, 20809, 20807, 20806, 20808, 20840, 20849, 20877, 20912,
+21015, 21009, 21010, 21006, 21014, 21155, 21256, 21281, 21280, 21360,
+21361, 21513, 21519, 21516, 21514, 21520, 21505, 21515, 21508, 21521,
+21517, 21512, 21507, 21518, 21510, 21522, 22240, 22238, 22237, 22323,
+22320, 22312, 22317, 22316, 22319, 22313, 22809, 22810, 22839, 22840,
+22916, 22904, 22915, 22909, 22905, 22914, 22913, 23383, 23384, 23431,
+23432, 23429, 23433, 23546, 23574, 23673, 24030, 24070, 24182, 24180,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 24335, 24347, 24537, 24534, 25102, 25100,
+25101, 25104, 25187, 25179, 25176, 25910, 26089, 26088, 26092, 26093,
+26354, 26355, 26377, 26429, 26420, 26417, 26421, 27425, 27492, 27515,
+27670, 27741, 27735, 27737, 27743, 27744, 27728, 27733, 27745, 27739,
+27725, 27726, 28784, 29279, 29277, 30334, 31481, 31859, 31992, 32566,
+32650, 32701, 32769, 32771, 32780, 32786, 32819, 32895, 32905, 32907,
+32908, 33251, 33258, 33267, 33276, 33292, 33307, 33311, 33390, 33394,
+33406, 34411, 34880, 34892, 34915, 35199, 38433, 20018, 20136, 20301,
+20303, 20295, 20311, 20318, 20276, 20315, 20309, 20272, 20304, 20305,
+20285, 20282, 20280, 20291, 20308, 20284, 20294, 20323, 20316, 20320,
+20271, 20302, 20278, 20313, 20317, 20296, 20314, 20812, 20811, 20813,
+20853, 20918, 20919, 21029, 21028, 21033, 21034, 21032, 21163, 21161,
+21162, 21164, 21283, 21363, 21365, 21533, 21549, 21534, 21566, 21542,
+21582, 21543, 21574, 21571, 21555, 21576, 21570, 21531, 21545, 21578,
+21561, 21563, 21560, 21550, 21557, 21558, 21536, 21564, 21568, 21553,
+21547, 21535, 21548, 22250, 22256, 22244, 22251, 22346, 22353, 22336,
+22349,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 22343, 22350, 22334, 22352, 22351,
+22331, 22767, 22846, 22941, 22930, 22952, 22942, 22947, 22937, 22934,
+22925, 22948, 22931, 22922, 22949, 23389, 23388, 23386, 23387, 23436,
+23435, 23439, 23596, 23616, 23617, 23615, 23614, 23696, 23697, 23700,
+23692, 24043, 24076, 24207, 24199, 24202, 24311, 24324, 24351, 24420,
+24418, 24439, 24441, 24536, 24524, 24535, 24525, 24561, 24555, 24568,
+24554, 25106, 25105, 25220, 25239, 25238, 25216, 25206, 25225, 25197,
+25226, 25212, 25214, 25209, 25203, 25234, 25199, 25240, 25198, 25237,
+25235, 25233, 25222, 25913, 25915, 25912, 26097, 26356, 26463, 26446,
+26447, 26448, 26449, 26460, 26454, 26462, 26441, 26438, 26464, 26451,
+26455, 27493, 27599, 27714, 27742, 27801, 27777, 27784, 27785, 27781,
+27803, 27754, 27770, 27792, 27760, 27788, 27752, 27798, 27794, 27773,
+27779, 27762, 27774, 27764, 27782, 27766, 27789, 27796, 27800, 27778,
+28790, 28796, 28797, 28792, 29282, 29281, 29280, 29380, 29378, 29590,
+29996, 29995, 30007, 30008, 30338, 30447, 30691, 31169, 31168, 31167,
+31350, 31995, 32597, 32918, 32915, 32925, 32920, 32923, 32922, 32946,
+33391, 33426,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 33419, 33421, 35211, 35282,
+35328, 35895, 35910, 35925, 35997, 36196, 36208, 36275, 36523, 36554,
+36763, 36784, 36802, 36806, 36805, 36804, 24033, 37009, 37026, 37034,
+37030, 37027, 37193, 37318, 37324, 38450, 38446, 38449, 38442, 38444,
+20006, 20054, 20083, 20107, 20123, 20126, 20139, 20140, 20335, 20381,
+20365, 20339, 20351, 20332, 20379, 20363, 20358, 20355, 20336, 20341,
+20360, 20329, 20347, 20374, 20350, 20367, 20369, 20346, 20820, 20818,
+20821, 20841, 20855, 20854, 20856, 20925, 20989, 21051, 21048, 21047,
+21050, 21040, 21038, 21046, 21057, 21182, 21179, 21330, 21332, 21331,
+21329, 21350, 21367, 21368, 21369, 21462, 21460, 21463, 21619, 21621,
+21654, 21624, 21653, 21632, 21627, 21623, 21636, 21650, 21638, 21628,
+21648, 21617, 21622, 21644, 21658, 21602, 21608, 21643, 21629, 21646,
+22266, 22403, 22391, 22378, 22377, 22369, 22374, 22372, 22396, 22812,
+22857, 22855, 22856, 22852, 22868, 22974, 22971, 22996, 22969, 22958,
+22993, 22982, 22992, 22989, 22987, 22995, 22986, 22959, 22963, 22994,
+22981, 23391, 23396, 23395, 23447, 23450, 23448, 23452, 23449, 23451,
+23578, 23624, 23621,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 23622, 23735, 23713,
+23736, 23721, 23723, 23729, 23731, 24088, 24090, 24086, 24085, 24091,
+24081, 24184, 24218, 24215, 24220, 24213, 24214, 24310, 24358, 24359,
+24361, 24448, 24449, 24447, 24444, 24541, 24544, 24573, 24565, 24575,
+24591, 24596, 24623, 24629, 24598, 24618, 24597, 24609, 24615, 24617,
+24619, 24603, 25110, 25109, 25151, 25150, 25152, 25215, 25289, 25292,
+25284, 25279, 25282, 25273, 25298, 25307, 25259, 25299, 25300, 25291,
+25288, 25256, 25277, 25276, 25296, 25305, 25287, 25293, 25269, 25306,
+25265, 25304, 25302, 25303, 25286, 25260, 25294, 25918, 26023, 26044,
+26106, 26132, 26131, 26124, 26118, 26114, 26126, 26112, 26127, 26133,
+26122, 26119, 26381, 26379, 26477, 26507, 26517, 26481, 26524, 26483,
+26487, 26503, 26525, 26519, 26479, 26480, 26495, 26505, 26494, 26512,
+26485, 26522, 26515, 26492, 26474, 26482, 27427, 27494, 27495, 27519,
+27667, 27675, 27875, 27880, 27891, 27825, 27852, 27877, 27827, 27837,
+27838, 27836, 27874, 27819, 27861, 27859, 27832, 27844, 27833, 27841,
+27822, 27863, 27845, 27889, 27839, 27835, 27873, 27867, 27850, 27820,
+27887, 27868, 27862, 27872,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 28821, 28814,
+28818, 28810, 28825, 29228, 29229, 29240, 29256, 29287, 29289, 29376,
+29390, 29401, 29399, 29392, 29609, 29608, 29599, 29611, 29605, 30013,
+30109, 30105, 30106, 30340, 30402, 30450, 30452, 30693, 30717, 31038,
+31040, 31041, 31177, 31176, 31354, 31353, 31482, 31998, 32596, 32652,
+32651, 32773, 32954, 32933, 32930, 32945, 32929, 32939, 32937, 32948,
+32938, 32943, 33253, 33278, 33293, 33459, 33437, 33433, 33453, 33469,
+33439, 33465, 33457, 33452, 33445, 33455, 33464, 33443, 33456, 33470,
+33463, 34382, 34417, 21021, 34920, 36555, 36814, 36820, 36817, 37045,
+37048, 37041, 37046, 37319, 37329, 38263, 38272, 38428, 38464, 38463,
+38459, 38468, 38466, 38585, 38632, 38738, 38750, 20127, 20141, 20142,
+20449, 20405, 20399, 20415, 20448, 20433, 20431, 20445, 20419, 20406,
+20440, 20447, 20426, 20439, 20398, 20432, 20420, 20418, 20442, 20430,
+20446, 20407, 20823, 20882, 20881, 20896, 21070, 21059, 21066, 21069,
+21068, 21067, 21063, 21191, 21193, 21187, 21185, 21261, 21335, 21371,
+21402, 21467, 21676, 21696, 21672, 21710, 21705, 21688, 21670, 21683,
+21703, 21698, 21693, 21674, 21697,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 21700,
+21704, 21679, 21675, 21681, 21691, 21673, 21671, 21695, 22271, 22402,
+22411, 22432, 22435, 22434, 22478, 22446, 22419, 22869, 22865, 22863,
+22862, 22864, 23004, 23000, 23039, 23011, 23016, 23043, 23013, 23018,
+23002, 23014, 23041, 23035, 23401, 23459, 23462, 23460, 23458, 23461,
+23553, 23630, 23631, 23629, 23627, 23769, 23762, 24055, 24093, 24101,
+24095, 24189, 24224, 24230, 24314, 24328, 24365, 24421, 24456, 24453,
+24458, 24459, 24455, 24460, 24457, 24594, 24605, 24608, 24613, 24590,
+24616, 24653, 24688, 24680, 24674, 24646, 24643, 24684, 24683, 24682,
+24676, 25153, 25308, 25366, 25353, 25340, 25325, 25345, 25326, 25341,
+25351, 25329, 25335, 25327, 25324, 25342, 25332, 25361, 25346, 25919,
+25925, 26027, 26045, 26082, 26149, 26157, 26144, 26151, 26159, 26143,
+26152, 26161, 26148, 26359, 26623, 26579, 26609, 26580, 26576, 26604,
+26550, 26543, 26613, 26601, 26607, 26564, 26577, 26548, 26586, 26597,
+26552, 26575, 26590, 26611, 26544, 26585, 26594, 26589, 26578, 27498,
+27523, 27526, 27573, 27602, 27607, 27679, 27849, 27915, 27954, 27946,
+27969, 27941, 27916, 27953, 27934, 27927,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+27963, 27965, 27966, 27958, 27931, 27893, 27961, 27943, 27960, 27945,
+27950, 27957, 27918, 27947, 28843, 28858, 28851, 28844, 28847, 28845,
+28856, 28846, 28836, 29232, 29298, 29295, 29300, 29417, 29408, 29409,
+29623, 29642, 29627, 29618, 29645, 29632, 29619, 29978, 29997, 30031,
+30028, 30030, 30027, 30123, 30116, 30117, 30114, 30115, 30328, 30342,
+30343, 30344, 30408, 30406, 30403, 30405, 30465, 30457, 30456, 30473,
+30475, 30462, 30460, 30471, 30684, 30722, 30740, 30732, 30733, 31046,
+31049, 31048, 31047, 31161, 31162, 31185, 31186, 31179, 31359, 31361,
+31487, 31485, 31869, 32002, 32005, 32000, 32009, 32007, 32004, 32006,
+32568, 32654, 32703, 32772, 32784, 32781, 32785, 32822, 32982, 32997,
+32986, 32963, 32964, 32972, 32993, 32987, 32974, 32990, 32996, 32989,
+33268, 33314, 33511, 33539, 33541, 33507, 33499, 33510, 33540, 33509,
+33538, 33545, 33490, 33495, 33521, 33537, 33500, 33492, 33489, 33502,
+33491, 33503, 33519, 33542, 34384, 34425, 34427, 34426, 34893, 34923,
+35201, 35284, 35336, 35330, 35331, 35998, 36000, 36212, 36211, 36276,
+36557, 36556, 36848, 36838, 36834, 36842, 36837,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 36845, 36843, 36836, 36840, 37066, 37070, 37057, 37059, 37195,
+37194, 37325, 38274, 38480, 38475, 38476, 38477, 38754, 38761, 38859,
+38893, 38899, 38913, 39080, 39131, 39135, 39318, 39321, 20056, 20147,
+20492, 20493, 20515, 20463, 20518, 20517, 20472, 20521, 20502, 20486,
+20540, 20511, 20506, 20498, 20497, 20474, 20480, 20500, 20520, 20465,
+20513, 20491, 20505, 20504, 20467, 20462, 20525, 20522, 20478, 20523,
+20489, 20860, 20900, 20901, 20898, 20941, 20940, 20934, 20939, 21078,
+21084, 21076, 21083, 21085, 21290, 21375, 21407, 21405, 21471, 21736,
+21776, 21761, 21815, 21756, 21733, 21746, 21766, 21754, 21780, 21737,
+21741, 21729, 21769, 21742, 21738, 21734, 21799, 21767, 21757, 21775,
+22275, 22276, 22466, 22484, 22475, 22467, 22537, 22799, 22871, 22872,
+22874, 23057, 23064, 23068, 23071, 23067, 23059, 23020, 23072, 23075,
+23081, 23077, 23052, 23049, 23403, 23640, 23472, 23475, 23478, 23476,
+23470, 23477, 23481, 23480, 23556, 23633, 23637, 23632, 23789, 23805,
+23803, 23786, 23784, 23792, 23798, 23809, 23796, 24046, 24109, 24107,
+24235, 24237, 24231, 24369, 24466, 24465, 24464, 24665,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 24675, 24677, 24656, 24661, 24685, 24681, 24687, 24708,
+24735, 24730, 24717, 24724, 24716, 24709, 24726, 25159, 25331, 25352,
+25343, 25422, 25406, 25391, 25429, 25410, 25414, 25423, 25417, 25402,
+25424, 25405, 25386, 25387, 25384, 25421, 25420, 25928, 25929, 26009,
+26049, 26053, 26178, 26185, 26191, 26179, 26194, 26188, 26181, 26177,
+26360, 26388, 26389, 26391, 26657, 26680, 26696, 26694, 26707, 26681,
+26690, 26708, 26665, 26803, 26647, 26700, 26705, 26685, 26612, 26704,
+26688, 26684, 26691, 26666, 26693, 26643, 26648, 26689, 27530, 27529,
+27575, 27683, 27687, 27688, 27686, 27684, 27888, 28010, 28053, 28040,
+28039, 28006, 28024, 28023, 27993, 28051, 28012, 28041, 28014, 27994,
+28020, 28009, 28044, 28042, 28025, 28037, 28005, 28052, 28874, 28888,
+28900, 28889, 28872, 28879, 29241, 29305, 29436, 29433, 29437, 29432,
+29431, 29574, 29677, 29705, 29678, 29664, 29674, 29662, 30036, 30045,
+30044, 30042, 30041, 30142, 30149, 30151, 30130, 30131, 30141, 30140,
+30137, 30146, 30136, 30347, 30384, 30410, 30413, 30414, 30505, 30495,
+30496, 30504, 30697, 30768, 30759, 30776, 30749, 30772, 30775,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 30757, 30765, 30752, 30751, 30770, 31061, 31056,
+31072, 31071, 31062, 31070, 31069, 31063, 31066, 31204, 31203, 31207,
+31199, 31206, 31209, 31192, 31364, 31368, 31449, 31494, 31505, 31881,
+32033, 32023, 32011, 32010, 32032, 32034, 32020, 32016, 32021, 32026,
+32028, 32013, 32025, 32027, 32570, 32607, 32660, 32709, 32705, 32774,
+32792, 32789, 32793, 32791, 32829, 32831, 33009, 33026, 33008, 33029,
+33005, 33012, 33030, 33016, 33011, 33032, 33021, 33034, 33020, 33007,
+33261, 33260, 33280, 33296, 33322, 33323, 33320, 33324, 33467, 33579,
+33618, 33620, 33610, 33592, 33616, 33609, 33589, 33588, 33615, 33586,
+33593, 33590, 33559, 33600, 33585, 33576, 33603, 34388, 34442, 34474,
+34451, 34468, 34473, 34444, 34467, 34460, 34928, 34935, 34945, 34946,
+34941, 34937, 35352, 35344, 35342, 35340, 35349, 35338, 35351, 35347,
+35350, 35343, 35345, 35912, 35962, 35961, 36001, 36002, 36215, 36524,
+36562, 36564, 36559, 36785, 36865, 36870, 36855, 36864, 36858, 36852,
+36867, 36861, 36869, 36856, 37013, 37089, 37085, 37090, 37202, 37197,
+37196, 37336, 37341, 37335, 37340, 37337, 38275, 38498, 38499, 38497,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 38491, 38493, 38500, 38488, 38494, 38587,
+39138, 39340, 39592, 39640, 39717, 39730, 39740, 20094, 20602, 20605,
+20572, 20551, 20547, 20556, 20570, 20553, 20581, 20598, 20558, 20565,
+20597, 20596, 20599, 20559, 20495, 20591, 20589, 20828, 20885, 20976,
+21098, 21103, 21202, 21209, 21208, 21205, 21264, 21263, 21273, 21311,
+21312, 21310, 21443, 26364, 21830, 21866, 21862, 21828, 21854, 21857,
+21827, 21834, 21809, 21846, 21839, 21845, 21807, 21860, 21816, 21806,
+21852, 21804, 21859, 21811, 21825, 21847, 22280, 22283, 22281, 22495,
+22533, 22538, 22534, 22496, 22500, 22522, 22530, 22581, 22519, 22521,
+22816, 22882, 23094, 23105, 23113, 23142, 23146, 23104, 23100, 23138,
+23130, 23110, 23114, 23408, 23495, 23493, 23492, 23490, 23487, 23494,
+23561, 23560, 23559, 23648, 23644, 23645, 23815, 23814, 23822, 23835,
+23830, 23842, 23825, 23849, 23828, 23833, 23844, 23847, 23831, 24034,
+24120, 24118, 24115, 24119, 24247, 24248, 24246, 24245, 24254, 24373,
+24375, 24407, 24428, 24425, 24427, 24471, 24473, 24478, 24472, 24481,
+24480, 24476, 24703, 24739, 24713, 24736, 24744, 24779, 24756, 24806,
+24765,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 24773, 24763, 24757, 24796, 24764,
+24792, 24789, 24774, 24799, 24760, 24794, 24775, 25114, 25115, 25160,
+25504, 25511, 25458, 25494, 25506, 25509, 25463, 25447, 25496, 25514,
+25457, 25513, 25481, 25475, 25499, 25451, 25512, 25476, 25480, 25497,
+25505, 25516, 25490, 25487, 25472, 25467, 25449, 25448, 25466, 25949,
+25942, 25937, 25945, 25943, 21855, 25935, 25944, 25941, 25940, 26012,
+26011, 26028, 26063, 26059, 26060, 26062, 26205, 26202, 26212, 26216,
+26214, 26206, 26361, 21207, 26395, 26753, 26799, 26786, 26771, 26805,
+26751, 26742, 26801, 26791, 26775, 26800, 26755, 26820, 26797, 26758,
+26757, 26772, 26781, 26792, 26783, 26785, 26754, 27442, 27578, 27627,
+27628, 27691, 28046, 28092, 28147, 28121, 28082, 28129, 28108, 28132,
+28155, 28154, 28165, 28103, 28107, 28079, 28113, 28078, 28126, 28153,
+28088, 28151, 28149, 28101, 28114, 28186, 28085, 28122, 28139, 28120,
+28138, 28145, 28142, 28136, 28102, 28100, 28074, 28140, 28095, 28134,
+28921, 28937, 28938, 28925, 28911, 29245, 29309, 29313, 29468, 29467,
+29462, 29459, 29465, 29575, 29701, 29706, 29699, 29702, 29694, 29709,
+29920, 29942,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 29943, 29980, 29986, 30053,
+30054, 30050, 30064, 30095, 30164, 30165, 30133, 30154, 30157, 30350,
+30420, 30418, 30427, 30519, 30526, 30524, 30518, 30520, 30522, 30827,
+30787, 30798, 31077, 31080, 31085, 31227, 31378, 31381, 31520, 31528,
+31515, 31532, 31526, 31513, 31518, 31534, 31890, 31895, 31893, 32070,
+32067, 32113, 32046, 32057, 32060, 32064, 32048, 32051, 32068, 32047,
+32066, 32050, 32049, 32573, 32670, 32666, 32716, 32718, 32722, 32796,
+32842, 32838, 33071, 33046, 33059, 33067, 33065, 33072, 33060, 33282,
+33333, 33335, 33334, 33337, 33678, 33694, 33688, 33656, 33698, 33686,
+33725, 33707, 33682, 33674, 33683, 33673, 33696, 33655, 33659, 33660,
+33670, 33703, 34389, 24426, 34503, 34496, 34486, 34500, 34485, 34502,
+34507, 34481, 34479, 34505, 34899, 34974, 34952, 34987, 34962, 34966,
+34957, 34955, 35219, 35215, 35370, 35357, 35363, 35365, 35377, 35373,
+35359, 35355, 35362, 35913, 35930, 36009, 36012, 36011, 36008, 36010,
+36007, 36199, 36198, 36286, 36282, 36571, 36575, 36889, 36877, 36890,
+36887, 36899, 36895, 36893, 36880, 36885, 36894, 36896, 36879, 36898,
+36886, 36891, 36884,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 37096, 37101, 37117,
+37207, 37326, 37365, 37350, 37347, 37351, 37357, 37353, 38281, 38506,
+38517, 38515, 38520, 38512, 38516, 38518, 38519, 38508, 38592, 38634,
+38633, 31456, 31455, 38914, 38915, 39770, 40165, 40565, 40575, 40613,
+40635, 20642, 20621, 20613, 20633, 20625, 20608, 20630, 20632, 20634,
+26368, 20977, 21106, 21108, 21109, 21097, 21214, 21213, 21211, 21338,
+21413, 21883, 21888, 21927, 21884, 21898, 21917, 21912, 21890, 21916,
+21930, 21908, 21895, 21899, 21891, 21939, 21934, 21919, 21822, 21938,
+21914, 21947, 21932, 21937, 21886, 21897, 21931, 21913, 22285, 22575,
+22570, 22580, 22564, 22576, 22577, 22561, 22557, 22560, 22777, 22778,
+22880, 23159, 23194, 23167, 23186, 23195, 23207, 23411, 23409, 23506,
+23500, 23507, 23504, 23562, 23563, 23601, 23884, 23888, 23860, 23879,
+24061, 24133, 24125, 24128, 24131, 24190, 24266, 24257, 24258, 24260,
+24380, 24429, 24489, 24490, 24488, 24785, 24801, 24754, 24758, 24800,
+24860, 24867, 24826, 24853, 24816, 24827, 24820, 24936, 24817, 24846,
+24822, 24841, 24832, 24850, 25119, 25161, 25507, 25484, 25551, 25536,
+25577, 25545, 25542, 25549,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 25554, 25571,
+25552, 25569, 25558, 25581, 25582, 25462, 25588, 25578, 25563, 25682,
+25562, 25593, 25950, 25958, 25954, 25955, 26001, 26000, 26031, 26222,
+26224, 26228, 26230, 26223, 26257, 26234, 26238, 26231, 26366, 26367,
+26399, 26397, 26874, 26837, 26848, 26840, 26839, 26885, 26847, 26869,
+26862, 26855, 26873, 26834, 26866, 26851, 26827, 26829, 26893, 26898,
+26894, 26825, 26842, 26990, 26875, 27454, 27450, 27453, 27544, 27542,
+27580, 27631, 27694, 27695, 27692, 28207, 28216, 28244, 28193, 28210,
+28263, 28234, 28192, 28197, 28195, 28187, 28251, 28248, 28196, 28246,
+28270, 28205, 28198, 28271, 28212, 28237, 28218, 28204, 28227, 28189,
+28222, 28363, 28297, 28185, 28238, 28259, 28228, 28274, 28265, 28255,
+28953, 28954, 28966, 28976, 28961, 28982, 29038, 28956, 29260, 29316,
+29312, 29494, 29477, 29492, 29481, 29754, 29738, 29747, 29730, 29733,
+29749, 29750, 29748, 29743, 29723, 29734, 29736, 29989, 29990, 30059,
+30058, 30178, 30171, 30179, 30169, 30168, 30174, 30176, 30331, 30332,
+30358, 30355, 30388, 30428, 30543, 30701, 30813, 30828, 30831, 31245,
+31240, 31243, 31237, 31232, 31384,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 31383,
+31382, 31461, 31459, 31561, 31574, 31558, 31568, 31570, 31572, 31565,
+31563, 31567, 31569, 31903, 31909, 32094, 32080, 32104, 32085, 32043,
+32110, 32114, 32097, 32102, 32098, 32112, 32115, 21892, 32724, 32725,
+32779, 32850, 32901, 33109, 33108, 33099, 33105, 33102, 33081, 33094,
+33086, 33100, 33107, 33140, 33298, 33308, 33769, 33795, 33784, 33805,
+33760, 33733, 33803, 33729, 33775, 33777, 33780, 33879, 33802, 33776,
+33804, 33740, 33789, 33778, 33738, 33848, 33806, 33796, 33756, 33799,
+33748, 33759, 34395, 34527, 34521, 34541, 34516, 34523, 34532, 34512,
+34526, 34903, 35009, 35010, 34993, 35203, 35222, 35387, 35424, 35413,
+35422, 35388, 35393, 35412, 35419, 35408, 35398, 35380, 35386, 35382,
+35414, 35937, 35970, 36015, 36028, 36019, 36029, 36033, 36027, 36032,
+36020, 36023, 36022, 36031, 36024, 36234, 36229, 36225, 36302, 36317,
+36299, 36314, 36305, 36300, 36315, 36294, 36603, 36600, 36604, 36764,
+36910, 36917, 36913, 36920, 36914, 36918, 37122, 37109, 37129, 37118,
+37219, 37221, 37327, 37396, 37397, 37411, 37385, 37406, 37389, 37392,
+37383, 37393, 38292, 38287, 38283, 38289,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+38291, 38290, 38286, 38538, 38542, 38539, 38525, 38533, 38534, 38541,
+38514, 38532, 38593, 38597, 38596, 38598, 38599, 38639, 38642, 38860,
+38917, 38918, 38920, 39143, 39146, 39151, 39145, 39154, 39149, 39342,
+39341, 40643, 40653, 40657, 20098, 20653, 20661, 20658, 20659, 20677,
+20670, 20652, 20663, 20667, 20655, 20679, 21119, 21111, 21117, 21215,
+21222, 21220, 21218, 21219, 21295, 21983, 21992, 21971, 21990, 21966,
+21980, 21959, 21969, 21987, 21988, 21999, 21978, 21985, 21957, 21958,
+21989, 21961, 22290, 22291, 22622, 22609, 22616, 22615, 22618, 22612,
+22635, 22604, 22637, 22602, 22626, 22610, 22603, 22887, 23233, 23241,
+23244, 23230, 23229, 23228, 23219, 23234, 23218, 23913, 23919, 24140,
+24185, 24265, 24264, 24338, 24409, 24492, 24494, 24858, 24847, 24904,
+24863, 24819, 24859, 24825, 24833, 24840, 24910, 24908, 24900, 24909,
+24894, 24884, 24871, 24845, 24838, 24887, 25121, 25122, 25619, 25662,
+25630, 25642, 25645, 25661, 25644, 25615, 25628, 25620, 25613, 25654,
+25622, 25623, 25606, 25964, 26015, 26032, 26263, 26249, 26247, 26248,
+26262, 26244, 26264, 26253, 26371, 27028, 26989,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 26970, 26999, 26976, 26964, 26997, 26928, 27010, 26954, 26984,
+26987, 26974, 26963, 27001, 27014, 26973, 26979, 26971, 27463, 27506,
+27584, 27583, 27603, 27645, 28322, 28335, 28371, 28342, 28354, 28304,
+28317, 28359, 28357, 28325, 28312, 28348, 28346, 28331, 28369, 28310,
+28316, 28356, 28372, 28330, 28327, 28340, 29006, 29017, 29033, 29028,
+29001, 29031, 29020, 29036, 29030, 29004, 29029, 29022, 28998, 29032,
+29014, 29242, 29266, 29495, 29509, 29503, 29502, 29807, 29786, 29781,
+29791, 29790, 29761, 29759, 29785, 29787, 29788, 30070, 30072, 30208,
+30192, 30209, 30194, 30193, 30202, 30207, 30196, 30195, 30430, 30431,
+30555, 30571, 30566, 30558, 30563, 30585, 30570, 30572, 30556, 30565,
+30568, 30562, 30702, 30862, 30896, 30871, 30872, 30860, 30857, 30844,
+30865, 30867, 30847, 31098, 31103, 31105, 33836, 31165, 31260, 31258,
+31264, 31252, 31263, 31262, 31391, 31392, 31607, 31680, 31584, 31598,
+31591, 31921, 31923, 31925, 32147, 32121, 32145, 32129, 32143, 32091,
+32622, 32617, 32618, 32626, 32681, 32680, 32676, 32854, 32856, 32902,
+32900, 33137, 33136, 33144, 33125, 33134, 33139, 33131,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 33145, 33146, 33126, 33285, 33351, 33922, 33911, 33853,
+33841, 33909, 33894, 33899, 33865, 33900, 33883, 33852, 33845, 33889,
+33891, 33897, 33901, 33862, 34398, 34396, 34399, 34553, 34579, 34568,
+34567, 34560, 34558, 34555, 34562, 34563, 34566, 34570, 34905, 35039,
+35028, 35033, 35036, 35032, 35037, 35041, 35018, 35029, 35026, 35228,
+35299, 35435, 35442, 35443, 35430, 35433, 35440, 35463, 35452, 35427,
+35488, 35441, 35461, 35437, 35426, 35438, 35436, 35449, 35451, 35390,
+35432, 35938, 35978, 35977, 36042, 36039, 36040, 36036, 36018, 36035,
+36034, 36037, 36321, 36319, 36328, 36335, 36339, 36346, 36330, 36324,
+36326, 36530, 36611, 36617, 36606, 36618, 36767, 36786, 36939, 36938,
+36947, 36930, 36948, 36924, 36949, 36944, 36935, 36943, 36942, 36941,
+36945, 36926, 36929, 37138, 37143, 37228, 37226, 37225, 37321, 37431,
+37463, 37432, 37437, 37440, 37438, 37467, 37451, 37476, 37457, 37428,
+37449, 37453, 37445, 37433, 37439, 37466, 38296, 38552, 38548, 38549,
+38605, 38603, 38601, 38602, 38647, 38651, 38649, 38646, 38742, 38772,
+38774, 38928, 38929, 38931, 38922, 38930, 38924, 39164, 39156,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 39165, 39166, 39347, 39345, 39348, 39649, 40169,
+40578, 40718, 40723, 40736, 20711, 20718, 20709, 20694, 20717, 20698,
+20693, 20687, 20689, 20721, 20686, 20713, 20834, 20979, 21123, 21122,
+21297, 21421, 22014, 22016, 22043, 22039, 22013, 22036, 22022, 22025,
+22029, 22030, 22007, 22038, 22047, 22024, 22032, 22006, 22296, 22294,
+22645, 22654, 22659, 22675, 22666, 22649, 22661, 22653, 22781, 22821,
+22818, 22820, 22890, 22889, 23265, 23270, 23273, 23255, 23254, 23256,
+23267, 23413, 23518, 23527, 23521, 23525, 23526, 23528, 23522, 23524,
+23519, 23565, 23650, 23940, 23943, 24155, 24163, 24149, 24151, 24148,
+24275, 24278, 24330, 24390, 24432, 24505, 24903, 24895, 24907, 24951,
+24930, 24931, 24927, 24922, 24920, 24949, 25130, 25735, 25688, 25684,
+25764, 25720, 25695, 25722, 25681, 25703, 25652, 25709, 25723, 25970,
+26017, 26071, 26070, 26274, 26280, 26269, 27036, 27048, 27029, 27073,
+27054, 27091, 27083, 27035, 27063, 27067, 27051, 27060, 27088, 27085,
+27053, 27084, 27046, 27075, 27043, 27465, 27468, 27699, 28467, 28436,
+28414, 28435, 28404, 28457, 28478, 28448, 28460, 28431, 28418, 28450,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 28415, 28399, 28422, 28465, 28472, 28466,
+28451, 28437, 28459, 28463, 28552, 28458, 28396, 28417, 28402, 28364,
+28407, 29076, 29081, 29053, 29066, 29060, 29074, 29246, 29330, 29334,
+29508, 29520, 29796, 29795, 29802, 29808, 29805, 29956, 30097, 30247,
+30221, 30219, 30217, 30227, 30433, 30435, 30596, 30589, 30591, 30561,
+30913, 30879, 30887, 30899, 30889, 30883, 31118, 31119, 31117, 31278,
+31281, 31402, 31401, 31469, 31471, 31649, 31637, 31627, 31605, 31639,
+31645, 31636, 31631, 31672, 31623, 31620, 31929, 31933, 31934, 32187,
+32176, 32156, 32189, 32190, 32160, 32202, 32180, 32178, 32177, 32186,
+32162, 32191, 32181, 32184, 32173, 32210, 32199, 32172, 32624, 32736,
+32737, 32735, 32862, 32858, 32903, 33104, 33152, 33167, 33160, 33162,
+33151, 33154, 33255, 33274, 33287, 33300, 33310, 33355, 33993, 33983,
+33990, 33988, 33945, 33950, 33970, 33948, 33995, 33976, 33984, 34003,
+33936, 33980, 34001, 33994, 34623, 34588, 34619, 34594, 34597, 34612,
+34584, 34645, 34615, 34601, 35059, 35074, 35060, 35065, 35064, 35069,
+35048, 35098, 35055, 35494, 35468, 35486, 35491, 35469, 35489, 35475,
+35492,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 35498, 35493, 35496, 35480, 35473,
+35482, 35495, 35946, 35981, 35980, 36051, 36049, 36050, 36203, 36249,
+36245, 36348, 36628, 36626, 36629, 36627, 36771, 36960, 36952, 36956,
+36963, 36953, 36958, 36962, 36957, 36955, 37145, 37144, 37150, 37237,
+37240, 37239, 37236, 37496, 37504, 37509, 37528, 37526, 37499, 37523,
+37532, 37544, 37500, 37521, 38305, 38312, 38313, 38307, 38309, 38308,
+38553, 38556, 38555, 38604, 38610, 38656, 38780, 38789, 38902, 38935,
+38936, 39087, 39089, 39171, 39173, 39180, 39177, 39361, 39599, 39600,
+39654, 39745, 39746, 40180, 40182, 40179, 40636, 40763, 40778, 20740,
+20736, 20731, 20725, 20729, 20738, 20744, 20745, 20741, 20956, 21127,
+21128, 21129, 21133, 21130, 21232, 21426, 22062, 22075, 22073, 22066,
+22079, 22068, 22057, 22099, 22094, 22103, 22132, 22070, 22063, 22064,
+22656, 22687, 22686, 22707, 22684, 22702, 22697, 22694, 22893, 23305,
+23291, 23307, 23285, 23308, 23304, 23534, 23532, 23529, 23531, 23652,
+23653, 23965, 23956, 24162, 24159, 24161, 24290, 24282, 24287, 24285,
+24291, 24288, 24392, 24433, 24503, 24501, 24950, 24935, 24942, 24925,
+24917, 24962,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 24956, 24944, 24939, 24958,
+24999, 24976, 25003, 24974, 25004, 24986, 24996, 24980, 25006, 25134,
+25705, 25711, 25721, 25758, 25778, 25736, 25744, 25776, 25765, 25747,
+25749, 25769, 25746, 25774, 25773, 25771, 25754, 25772, 25753, 25762,
+25779, 25973, 25975, 25976, 26286, 26283, 26292, 26289, 27171, 27167,
+27112, 27137, 27166, 27161, 27133, 27169, 27155, 27146, 27123, 27138,
+27141, 27117, 27153, 27472, 27470, 27556, 27589, 27590, 28479, 28540,
+28548, 28497, 28518, 28500, 28550, 28525, 28507, 28536, 28526, 28558,
+28538, 28528, 28516, 28567, 28504, 28373, 28527, 28512, 28511, 29087,
+29100, 29105, 29096, 29270, 29339, 29518, 29527, 29801, 29835, 29827,
+29822, 29824, 30079, 30240, 30249, 30239, 30244, 30246, 30241, 30242,
+30362, 30394, 30436, 30606, 30599, 30604, 30609, 30603, 30923, 30917,
+30906, 30922, 30910, 30933, 30908, 30928, 31295, 31292, 31296, 31293,
+31287, 31291, 31407, 31406, 31661, 31665, 31684, 31668, 31686, 31687,
+31681, 31648, 31692, 31946, 32224, 32244, 32239, 32251, 32216, 32236,
+32221, 32232, 32227, 32218, 32222, 32233, 32158, 32217, 32242, 32249,
+32629, 32631, 32687,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 32745, 32806, 33179,
+33180, 33181, 33184, 33178, 33176, 34071, 34109, 34074, 34030, 34092,
+34093, 34067, 34065, 34083, 34081, 34068, 34028, 34085, 34047, 34054,
+34690, 34676, 34678, 34656, 34662, 34680, 34664, 34649, 34647, 34636,
+34643, 34907, 34909, 35088, 35079, 35090, 35091, 35093, 35082, 35516,
+35538, 35527, 35524, 35477, 35531, 35576, 35506, 35529, 35522, 35519,
+35504, 35542, 35533, 35510, 35513, 35547, 35916, 35918, 35948, 36064,
+36062, 36070, 36068, 36076, 36077, 36066, 36067, 36060, 36074, 36065,
+36205, 36255, 36259, 36395, 36368, 36381, 36386, 36367, 36393, 36383,
+36385, 36382, 36538, 36637, 36635, 36639, 36649, 36646, 36650, 36636,
+36638, 36645, 36969, 36974, 36968, 36973, 36983, 37168, 37165, 37159,
+37169, 37255, 37257, 37259, 37251, 37573, 37563, 37559, 37610, 37548,
+37604, 37569, 37555, 37564, 37586, 37575, 37616, 37554, 38317, 38321,
+38660, 38662, 38663, 38665, 38752, 38797, 38795, 38799, 38945, 38955,
+38940, 39091, 39178, 39187, 39186, 39192, 39389, 39376, 39391, 39387,
+39377, 39381, 39378, 39385, 39607, 39662, 39663, 39719, 39749, 39748,
+39799, 39791, 40198, 40201,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 40195, 40617,
+40638, 40654, 22696, 40786, 20754, 20760, 20756, 20752, 20757, 20864,
+20906, 20957, 21137, 21139, 21235, 22105, 22123, 22137, 22121, 22116,
+22136, 22122, 22120, 22117, 22129, 22127, 22124, 22114, 22134, 22721,
+22718, 22727, 22725, 22894, 23325, 23348, 23416, 23536, 23566, 24394,
+25010, 24977, 25001, 24970, 25037, 25014, 25022, 25034, 25032, 25136,
+25797, 25793, 25803, 25787, 25788, 25818, 25796, 25799, 25794, 25805,
+25791, 25810, 25812, 25790, 25972, 26310, 26313, 26297, 26308, 26311,
+26296, 27197, 27192, 27194, 27225, 27243, 27224, 27193, 27204, 27234,
+27233, 27211, 27207, 27189, 27231, 27208, 27481, 27511, 27653, 28610,
+28593, 28577, 28611, 28580, 28609, 28583, 28595, 28608, 28601, 28598,
+28582, 28576, 28596, 29118, 29129, 29136, 29138, 29128, 29141, 29113,
+29134, 29145, 29148, 29123, 29124, 29544, 29852, 29859, 29848, 29855,
+29854, 29922, 29964, 29965, 30260, 30264, 30266, 30439, 30437, 30624,
+30622, 30623, 30629, 30952, 30938, 30956, 30951, 31142, 31309, 31310,
+31302, 31308, 31307, 31418, 31705, 31761, 31689, 31716, 31707, 31713,
+31721, 31718, 31957, 31958, 32266,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 32273,
+32264, 32283, 32291, 32286, 32285, 32265, 32272, 32633, 32690, 32752,
+32753, 32750, 32808, 33203, 33193, 33192, 33275, 33288, 33368, 33369,
+34122, 34137, 34120, 34152, 34153, 34115, 34121, 34157, 34154, 34142,
+34691, 34719, 34718, 34722, 34701, 34913, 35114, 35122, 35109, 35115,
+35105, 35242, 35238, 35558, 35578, 35563, 35569, 35584, 35548, 35559,
+35566, 35582, 35585, 35586, 35575, 35565, 35571, 35574, 35580, 35947,
+35949, 35987, 36084, 36420, 36401, 36404, 36418, 36409, 36405, 36667,
+36655, 36664, 36659, 36776, 36774, 36981, 36980, 36984, 36978, 36988,
+36986, 37172, 37266, 37664, 37686, 37624, 37683, 37679, 37666, 37628,
+37675, 37636, 37658, 37648, 37670, 37665, 37653, 37678, 37657, 38331,
+38567, 38568, 38570, 38613, 38670, 38673, 38678, 38669, 38675, 38671,
+38747, 38748, 38758, 38808, 38960, 38968, 38971, 38967, 38957, 38969,
+38948, 39184, 39208, 39198, 39195, 39201, 39194, 39405, 39394, 39409,
+39608, 39612, 39675, 39661, 39720, 39825, 40213, 40227, 40230, 40232,
+40210, 40219, 40664, 40660, 40845, 40860, 20778, 20767, 20769, 20786,
+21237, 22158, 22144, 22160, 22149, 22151,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+22159, 22741, 22739, 22737, 22734, 23344, 23338, 23332, 23418, 23607,
+23656, 23996, 23994, 23997, 23992, 24171, 24396, 24509, 25033, 25026,
+25031, 25062, 25035, 25138, 25140, 25806, 25802, 25816, 25824, 25840,
+25830, 25836, 25841, 25826, 25837, 25986, 25987, 26329, 26326, 27264,
+27284, 27268, 27298, 27292, 27355, 27299, 27262, 27287, 27280, 27296,
+27484, 27566, 27610, 27656, 28632, 28657, 28639, 28640, 28635, 28644,
+28651, 28655, 28544, 28652, 28641, 28649, 28629, 28654, 28656, 29159,
+29151, 29166, 29158, 29157, 29165, 29164, 29172, 29152, 29237, 29254,
+29552, 29554, 29865, 29872, 29862, 29864, 30278, 30274, 30284, 30442,
+30643, 30634, 30640, 30636, 30631, 30637, 30703, 30967, 30970, 30964,
+30959, 30977, 31143, 31146, 31319, 31423, 31751, 31757, 31742, 31735,
+31756, 31712, 31968, 31964, 31966, 31970, 31967, 31961, 31965, 32302,
+32318, 32326, 32311, 32306, 32323, 32299, 32317, 32305, 32325, 32321,
+32308, 32313, 32328, 32309, 32319, 32303, 32580, 32755, 32764, 32881,
+32882, 32880, 32879, 32883, 33222, 33219, 33210, 33218, 33216, 33215,
+33213, 33225, 33214, 33256, 33289, 33393, 34218,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 34180, 34174, 34204, 34193, 34196, 34223, 34203, 34183, 34216,
+34186, 34407, 34752, 34769, 34739, 34770, 34758, 34731, 34747, 34746,
+34760, 34763, 35131, 35126, 35140, 35128, 35133, 35244, 35598, 35607,
+35609, 35611, 35594, 35616, 35613, 35588, 35600, 35905, 35903, 35955,
+36090, 36093, 36092, 36088, 36091, 36264, 36425, 36427, 36424, 36426,
+36676, 36670, 36674, 36677, 36671, 36991, 36989, 36996, 36993, 36994,
+36992, 37177, 37283, 37278, 37276, 37709, 37762, 37672, 37749, 37706,
+37733, 37707, 37656, 37758, 37740, 37723, 37744, 37722, 37716, 38346,
+38347, 38348, 38344, 38342, 38577, 38584, 38614, 38684, 38686, 38816,
+38867, 38982, 39094, 39221, 39425, 39423, 39854, 39851, 39850, 39853,
+40251, 40255, 40587, 40655, 40670, 40668, 40669, 40667, 40766, 40779,
+21474, 22165, 22190, 22745, 22744, 23352, 24413, 25059, 25139, 25844,
+25842, 25854, 25862, 25850, 25851, 25847, 26039, 26332, 26406, 27315,
+27308, 27331, 27323, 27320, 27330, 27310, 27311, 27487, 27512, 27567,
+28681, 28683, 28670, 28678, 28666, 28689, 28687, 29179, 29180, 29182,
+29176, 29559, 29557, 29863, 29887, 29973, 30294, 30296,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 30290, 30653, 30655, 30651, 30652, 30990, 31150, 31329,
+31330, 31328, 31428, 31429, 31787, 31783, 31786, 31774, 31779, 31777,
+31975, 32340, 32341, 32350, 32346, 32353, 32338, 32345, 32584, 32761,
+32763, 32887, 32886, 33229, 33231, 33290, 34255, 34217, 34253, 34256,
+34249, 34224, 34234, 34233, 34214, 34799, 34796, 34802, 34784, 35206,
+35250, 35316, 35624, 35641, 35628, 35627, 35920, 36101, 36441, 36451,
+36454, 36452, 36447, 36437, 36544, 36681, 36685, 36999, 36995, 37000,
+37291, 37292, 37328, 37780, 37770, 37782, 37794, 37811, 37806, 37804,
+37808, 37784, 37786, 37783, 38356, 38358, 38352, 38357, 38626, 38620,
+38617, 38619, 38622, 38692, 38819, 38822, 38829, 38905, 38989, 38991,
+38988, 38990, 38995, 39098, 39230, 39231, 39229, 39214, 39333, 39438,
+39617, 39683, 39686, 39759, 39758, 39757, 39882, 39881, 39933, 39880,
+39872, 40273, 40285, 40288, 40672, 40725, 40748, 20787, 22181, 22750,
+22751, 22754, 23541, 40848, 24300, 25074, 25079, 25078, 25077, 25856,
+25871, 26336, 26333, 27365, 27357, 27354, 27347, 28699, 28703, 28712,
+28698, 28701, 28693, 28696, 29190, 29197, 29272, 29346, 29560,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 29562, 29885, 29898, 29923, 30087, 30086, 30303,
+30305, 30663, 31001, 31153, 31339, 31337, 31806, 31807, 31800, 31805,
+31799, 31808, 32363, 32365, 32377, 32361, 32362, 32645, 32371, 32694,
+32697, 32696, 33240, 34281, 34269, 34282, 34261, 34276, 34277, 34295,
+34811, 34821, 34829, 34809, 34814, 35168, 35167, 35158, 35166, 35649,
+35676, 35672, 35657, 35674, 35662, 35663, 35654, 35673, 36104, 36106,
+36476, 36466, 36487, 36470, 36460, 36474, 36468, 36692, 36686, 36781,
+37002, 37003, 37297, 37294, 37857, 37841, 37855, 37827, 37832, 37852,
+37853, 37846, 37858, 37837, 37848, 37860, 37847, 37864, 38364, 38580,
+38627, 38698, 38695, 38753, 38876, 38907, 39006, 39000, 39003, 39100,
+39237, 39241, 39446, 39449, 39693, 39912, 39911, 39894, 39899, 40329,
+40289, 40306, 40298, 40300, 40594, 40599, 40595, 40628, 21240, 22184,
+22199, 22198, 22196, 22204, 22756, 23360, 23363, 23421, 23542, 24009,
+25080, 25082, 25880, 25876, 25881, 26342, 26407, 27372, 28734, 28720,
+28722, 29200, 29563, 29903, 30306, 30309, 31014, 31018, 31020, 31019,
+31431, 31478, 31820, 31811, 31821, 31983, 31984, 36782, 32381, 32380,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 32386, 32588, 32768, 33242, 33382, 34299,
+34297, 34321, 34298, 34310, 34315, 34311, 34314, 34836, 34837, 35172,
+35258, 35320, 35696, 35692, 35686, 35695, 35679, 35691, 36111, 36109,
+36489, 36481, 36485, 36482, 37300, 37323, 37912, 37891, 37885, 38369,
+38704, 39108, 39250, 39249, 39336, 39467, 39472, 39479, 39477, 39955,
+39949, 40569, 40629, 40680, 40751, 40799, 40803, 40801, 20791, 20792,
+22209, 22208, 22210, 22804, 23660, 24013, 25084, 25086, 25885, 25884,
+26005, 26345, 27387, 27396, 27386, 27570, 28748, 29211, 29351, 29910,
+29908, 30313, 30675, 31824, 32399, 32396, 32700, 34327, 34349, 34330,
+34851, 34850, 34849, 34847, 35178, 35180, 35261, 35700, 35703, 35709,
+36115, 36490, 36493, 36491, 36703, 36783, 37306, 37934, 37939, 37941,
+37946, 37944, 37938, 37931, 38370, 38712, 38713, 38706, 38911, 39015,
+39013, 39255, 39493, 39491, 39488, 39486, 39631, 39764, 39761, 39981,
+39973, 40367, 40372, 40386, 40376, 40605, 40687, 40729, 40796, 40806,
+40807, 20796, 20795, 22216, 22218, 22217, 23423, 24020, 24018, 24398,
+25087, 25892, 27402, 27489, 28753, 28760, 29568, 29924, 30090, 30318,
+30316,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 31155, 31840, 31839, 32894, 32893,
+33247, 35186, 35183, 35324, 35712, 36118, 36119, 36497, 36499, 36705,
+37192, 37956, 37969, 37970, 38717, 38718, 38851, 38849, 39019, 39253,
+39509, 39501, 39634, 39706, 40009, 39985, 39998, 39995, 40403, 40407,
+40756, 40812, 40810, 40852, 22220, 24022, 25088, 25891, 25899, 25898,
+26348, 27408, 29914, 31434, 31844, 31843, 31845, 32403, 32406, 32404,
+33250, 34360, 34367, 34865, 35722, 37008, 37007, 37987, 37984, 37988,
+38760, 39023, 39260, 39514, 39515, 39511, 39635, 39636, 39633, 40020,
+40023, 40022, 40421, 40607, 40692, 22225, 22761, 25900, 28766, 30321,
+30322, 30679, 32592, 32648, 34870, 34873, 34914, 35731, 35730, 35734,
+33399, 36123, 37312, 37994, 38722, 38728, 38724, 38854, 39024, 39519,
+39714, 39768, 40031, 40441, 40442, 40572, 40573, 40711, 40823, 40818,
+24307, 27414, 28771, 31852, 31854, 34875, 35264, 36513, 37313, 38002,
+38000, 39025, 39262, 39638, 39715, 40652, 28772, 30682, 35738, 38007,
+38857, 39522, 39525, 32412, 35740, 36522, 37317, 38013, 38014, 38012,
+40055, 40056, 40695, 35924, 38015, 40474, 29224, 39530, 39729, 40475,
+40478, 31858,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,  9312,  9313,  9314,  9315,
+ 9316,  9317,  9318,  9319,  9320,  9321,  9332,  9333,  9334,  9335,
+ 9336,  9337,  9338,  9339,  9340,  9341,  8560,  8561,  8562,  8563,
+ 8564,  8565,  8566,  8567,  8568,  8569, 20022, 20031, 20101, 20128,
+20866, 20886, 20907, 21241, 21304, 21353, 21430, 22794, 23424, 24027,
+24186, 24191, 24308, 24400, 24417, 25908, 26080, 30098, 30326, 36789,
+38582,   168,   710, 12541, 12542, 12445, 12446, 12291, 20189, 12293,
+12294, 12295, 12540, 65339, 65341, 10045, 12353, 12354, 12355, 12356,
+12357, 12358, 12359, 12360, 12361, 12362, 12363, 12364, 12365, 12366,
+12367, 12368, 12369, 12370, 12371, 12372, 12373, 12374, 12375, 12376,
+12377, 12378, 12379, 12380, 12381, 12382, 12383, 12384, 12385, 12386,
+12387, 12388, 12389, 12390, 12391, 12392, 12393, 12394, 12395, 12396,
+12397, 12398, 12399, 12400, 12401, 12402, 12403, 12404, 12405, 12406,
+12407, 12408, 12409, 12410, 12411, 12412, 12413, 12414, 12415, 12416,
+12417, 12418, 12419, 12420, 12421, 12422, 12423, 12424, 12425, 12426,
+12427, 12428, 12429, 12430, 12431, 12432, 12433, 12434, 12435, 12449,
+12450, 12451, 12452,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 12453, 12454, 12455,
+12456, 12457, 12458, 12459, 12460, 12461, 12462, 12463, 12464, 12465,
+12466, 12467, 12468, 12469, 12470, 12471, 12472, 12473, 12474, 12475,
+12476, 12477, 12478, 12479, 12480, 12481, 12482, 12483, 12484, 12485,
+12486, 12487, 12488, 12489, 12490, 12491, 12492, 12493, 12494, 12495,
+12496, 12497, 12498, 12499, 12500, 12501, 12502, 12503, 12504, 12505,
+12506, 12507, 12508, 12509, 12510, 12511, 12512, 12513, 12514, 12515,
+12516, 12517, 12518, 12519, 12520, 12521, 12522, 12523, 12524, 12525,
+12526, 12527, 12528, 12529, 12530, 12531, 12532, 12533, 12534,  1040,
+ 1041,  1042,  1043,  1044,  1045,  1025,  1046,  1047,  1048,  1049,
+ 1050,  1051,  1052,  1053,  1054,  1055,  1056,  1057,  1058,  1059,
+ 1060,  1061,  1062,  1063,  1064,  1065,  1066,  1067,  1068,  1069,
+ 1070,  1071,  1072,  1073,  1074,  1075,  1076,  1077,  1105,  1078,
+ 1079,  1080,  1081,  1082,  1083,  1084,  1085,  1086,  1087,  1088,
+ 1089,  1090,  1091,  1092,  1093,  1094,  1095,  1096,  1097,  1098,
+ 1099,  1100,  1101,  1102,  1103,  8679,  8632,  8633, 12751, 63462,
+20058, 63464, 20994, 17553,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 40880, 20872,
+40881, 63470, 63471, 63472, 63473, 63474, 63475, 63476, 63477, 63478,
+63479, 63480, 63481, 63482, 12443, 12444, 12436, 12535, 12536, 12537,
+12538, 12539, 65377, 65378, 65379, 65380, 65381, 65382, 65383, 65384,
+65385, 65386, 65387, 65388, 65389, 65390, 65391, 65392, 65393, 65394,
+65395, 65396, 65506, 65508, 65287, 65282, 12849,  8470,  8481, 65397,
+65398, 65399, 65400, 65401, 65402, 65403, 65404, 65405, 65406, 65407,
+65408, 65409, 65410, 65411, 65412, 65413, 65414, 65415, 65416, 65417,
+65418, 65419, 65420, 65421, 65422, 65423, 65424, 65425, 65426, 65427,
+65428, 65429, 65430, 65431, 65432, 65433, 65434, 65435, 65436, 65437,
+65438, 65439, 20034, 20060, 20981, 21274, 21378, 19975, 19980, 20039,
+20109, 22231, 64012, 23662, 24435, 19983, 20871, 19982, 20014, 20115,
+20162, 20169, 20168, 20888, 21244, 21356, 21433, 22304, 22787, 22828,
+23568, 24063, 26081, 27571, 27596, 27668, 29247, 20017, 20028, 20200,
+20188, 20201, 20193, 20189, 20186, 21004, 21276, 21324, 22306, 22307,
+22807, 22831, 23425, 23428, 23570, 23611, 23668, 23667, 24068, 24192,
+24194, 24521, 25097, 25168, 27669,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 27702,
+27715, 27711, 27707, 29358, 29360, 29578, 31160, 32906, 38430, 20238,
+20248, 20268, 20213, 20244, 20209, 20224, 20215, 20232, 20253, 20226,
+20229, 20258, 20243, 20228, 20212, 20242, 20913, 21011, 21001, 21008,
+21158, 21282, 21279, 21325, 21386, 21511, 22241, 22239, 22318, 22314,
+22324, 22844, 22912, 22908, 22917, 22907, 22910, 22903, 22911, 23382,
+23573, 23589, 23676, 23674, 23675, 23678, 24031, 24181, 24196, 24322,
+24346, 24436, 24533, 24532, 24527, 25180, 25182, 25188, 25185, 25190,
+25186, 25177, 25184, 25178, 25189, 26095, 26094, 26430, 26425, 26424,
+26427, 26426, 26431, 26428, 26419, 27672, 27718, 27730, 27740, 27727,
+27722, 27732, 27723, 27724, 28785, 29278, 29364, 29365, 29582, 29994,
+30335, 31349, 32593, 33400, 33404, 33408, 33405, 33407, 34381, 35198,
+37017, 37015, 37016, 37019, 37012, 38434, 38436, 38432, 38435, 20310,
+20283, 20322, 20297, 20307, 20324, 20286, 20327, 20306, 20319, 20289,
+20312, 20269, 20275, 20287, 20321, 20879, 20921, 21020, 21022, 21025,
+21165, 21166, 21257, 21347, 21362, 21390, 21391, 21552, 21559, 21546,
+21588, 21573, 21529, 21532, 21541, 21528,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+21565, 21583, 21569, 21544, 21540, 21575, 22254, 22247, 22245, 22337,
+22341, 22348, 22345, 22347, 22354, 22790, 22848, 22950, 22936, 22944,
+22935, 22926, 22946, 22928, 22927, 22951, 22945, 23438, 23442, 23592,
+23594, 23693, 23695, 23688, 23691, 23689, 23698, 23690, 23686, 23699,
+23701, 24032, 24074, 24078, 24203, 24201, 24204, 24200, 24205, 24325,
+24349, 24440, 24438, 24530, 24529, 24528, 24557, 24552, 24558, 24563,
+24545, 24548, 24547, 24570, 24559, 24567, 24571, 24576, 24564, 25146,
+25219, 25228, 25230, 25231, 25236, 25223, 25201, 25211, 25210, 25200,
+25217, 25224, 25207, 25213, 25202, 25204, 25911, 26096, 26100, 26099,
+26098, 26101, 26437, 26439, 26457, 26453, 26444, 26440, 26461, 26445,
+26458, 26443, 27600, 27673, 27674, 27768, 27751, 27755, 27780, 27787,
+27791, 27761, 27759, 27753, 27802, 27757, 27783, 27797, 27804, 27750,
+27763, 27749, 27771, 27790, 28788, 28794, 29283, 29375, 29373, 29379,
+29382, 29377, 29370, 29381, 29589, 29591, 29587, 29588, 29586, 30010,
+30009, 30100, 30101, 30337, 31037, 32820, 32917, 32921, 32912, 32914,
+32924, 33424, 33423, 33413, 33422, 33425, 33427,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 33418, 33411, 33412, 35960, 36809, 36799, 37023, 37025, 37029,
+37022, 37031, 37024, 38448, 38440, 38447, 38445, 20019, 20376, 20348,
+20357, 20349, 20352, 20359, 20342, 20340, 20361, 20356, 20343, 20300,
+20375, 20330, 20378, 20345, 20353, 20344, 20368, 20380, 20372, 20382,
+20370, 20354, 20373, 20331, 20334, 20894, 20924, 20926, 21045, 21042,
+21043, 21062, 21041, 21180, 21258, 21259, 21308, 21394, 21396, 21639,
+21631, 21633, 21649, 21634, 21640, 21611, 21626, 21630, 21605, 21612,
+21620, 21606, 21645, 21615, 21601, 21600, 21656, 21603, 21607, 21604,
+22263, 22265, 22383, 22386, 22381, 22379, 22385, 22384, 22390, 22400,
+22389, 22395, 22387, 22388, 22370, 22376, 22397, 22796, 22853, 22965,
+22970, 22991, 22990, 22962, 22988, 22977, 22966, 22972, 22979, 22998,
+22961, 22973, 22976, 22984, 22964, 22983, 23394, 23397, 23443, 23445,
+23620, 23623, 23726, 23716, 23712, 23733, 23727, 23720, 23724, 23711,
+23715, 23725, 23714, 23722, 23719, 23709, 23717, 23734, 23728, 23718,
+24087, 24084, 24089, 24360, 24354, 24355, 24356, 24404, 24450, 24446,
+24445, 24542, 24549, 24621, 24614, 24601, 24626, 24587,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 24628, 24586, 24599, 24627, 24602, 24606, 24620, 24610,
+24589, 24592, 24622, 24595, 24593, 24588, 24585, 24604, 25108, 25149,
+25261, 25268, 25297, 25278, 25258, 25270, 25290, 25262, 25267, 25263,
+25275, 25257, 25264, 25272, 25917, 26024, 26043, 26121, 26108, 26116,
+26130, 26120, 26107, 26115, 26123, 26125, 26117, 26109, 26129, 26128,
+26358, 26378, 26501, 26476, 26510, 26514, 26486, 26491, 26520, 26502,
+26500, 26484, 26509, 26508, 26490, 26527, 26513, 26521, 26499, 26493,
+26497, 26488, 26489, 26516, 27429, 27520, 27518, 27614, 27677, 27795,
+27884, 27883, 27886, 27865, 27830, 27860, 27821, 27879, 27831, 27856,
+27842, 27834, 27843, 27846, 27885, 27890, 27858, 27869, 27828, 27786,
+27805, 27776, 27870, 27840, 27952, 27853, 27847, 27824, 27897, 27855,
+27881, 27857, 28820, 28824, 28805, 28819, 28806, 28804, 28817, 28822,
+28802, 28826, 28803, 29290, 29398, 29387, 29400, 29385, 29404, 29394,
+29396, 29402, 29388, 29393, 29604, 29601, 29613, 29606, 29602, 29600,
+29612, 29597, 29917, 29928, 30015, 30016, 30014, 30092, 30104, 30383,
+30451, 30449, 30448, 30453, 30712, 30716, 30713, 30715, 30714,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 30711, 31042, 31039, 31173, 31352, 31355, 31483,
+31861, 31997, 32821, 32911, 32942, 32931, 32952, 32949, 32941, 33312,
+33440, 33472, 33451, 33434, 33432, 33435, 33461, 33447, 33454, 33468,
+33438, 33466, 33460, 33448, 33441, 33449, 33474, 33444, 33475, 33462,
+33442, 34416, 34415, 34413, 34414, 35926, 36818, 36811, 36819, 36813,
+36822, 36821, 36823, 37042, 37044, 37039, 37043, 37040, 38457, 38461,
+38460, 38458, 38467, 20429, 20421, 20435, 20402, 20425, 20427, 20417,
+20436, 20444, 20441, 20411, 20403, 20443, 20423, 20438, 20410, 20416,
+20409, 20460, 21060, 21065, 21184, 21186, 21309, 21372, 21399, 21398,
+21401, 21400, 21690, 21665, 21677, 21669, 21711, 21699, 33549, 21687,
+21678, 21718, 21686, 21701, 21702, 21664, 21616, 21692, 21666, 21694,
+21618, 21726, 21680, 22453, 22430, 22431, 22436, 22412, 22423, 22429,
+22427, 22420, 22424, 22415, 22425, 22437, 22426, 22421, 22772, 22797,
+22867, 23009, 23006, 23022, 23040, 23025, 23005, 23034, 23037, 23036,
+23030, 23012, 23026, 23031, 23003, 23017, 23027, 23029, 23008, 23038,
+23028, 23021, 23464, 23628, 23760, 23768, 23756, 23767, 23755, 23771,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 23774, 23770, 23753, 23751, 23754, 23766,
+23763, 23764, 23759, 23752, 23750, 23758, 23775, 23800, 24057, 24097,
+24098, 24099, 24096, 24100, 24240, 24228, 24226, 24219, 24227, 24229,
+24327, 24366, 24406, 24454, 24631, 24633, 24660, 24690, 24670, 24645,
+24659, 24647, 24649, 24667, 24652, 24640, 24642, 24671, 24612, 24644,
+24664, 24678, 24686, 25154, 25155, 25295, 25357, 25355, 25333, 25358,
+25347, 25323, 25337, 25359, 25356, 25336, 25334, 25344, 25363, 25364,
+25338, 25365, 25339, 25328, 25921, 25923, 26026, 26047, 26166, 26145,
+26162, 26165, 26140, 26150, 26146, 26163, 26155, 26170, 26141, 26164,
+26169, 26158, 26383, 26384, 26561, 26610, 26568, 26554, 26588, 26555,
+26616, 26584, 26560, 26551, 26565, 26603, 26596, 26591, 26549, 26573,
+26547, 26615, 26614, 26606, 26595, 26562, 26553, 26574, 26599, 26608,
+26546, 26620, 26566, 26605, 26572, 26542, 26598, 26587, 26618, 26569,
+26570, 26563, 26602, 26571, 27432, 27522, 27524, 27574, 27606, 27608,
+27616, 27680, 27681, 27944, 27956, 27949, 27935, 27964, 27967, 27922,
+27914, 27866, 27955, 27908, 27929, 27962, 27930, 27921, 27904, 27933,
+27970,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 27905, 27928, 27959, 27907, 27919,
+27968, 27911, 27936, 27948, 27912, 27938, 27913, 27920, 28855, 28831,
+28862, 28849, 28848, 28833, 28852, 28853, 28841, 29249, 29257, 29258,
+29292, 29296, 29299, 29294, 29386, 29412, 29416, 29419, 29407, 29418,
+29414, 29411, 29573, 29644, 29634, 29640, 29637, 29625, 29622, 29621,
+29620, 29675, 29631, 29639, 29630, 29635, 29638, 29624, 29643, 29932,
+29934, 29998, 30023, 30024, 30119, 30122, 30329, 30404, 30472, 30467,
+30468, 30469, 30474, 30455, 30459, 30458, 30695, 30696, 30726, 30737,
+30738, 30725, 30736, 30735, 30734, 30729, 30723, 30739, 31050, 31052,
+31051, 31045, 31044, 31189, 31181, 31183, 31190, 31182, 31360, 31358,
+31441, 31488, 31489, 31866, 31864, 31865, 31871, 31872, 31873, 32003,
+32008, 32001, 32600, 32657, 32653, 32702, 32775, 32782, 32783, 32788,
+32823, 32984, 32967, 32992, 32977, 32968, 32962, 32976, 32965, 32995,
+32985, 32988, 32970, 32981, 32969, 32975, 32983, 32998, 32973, 33279,
+33313, 33428, 33497, 33534, 33529, 33543, 33512, 33536, 33493, 33594,
+33515, 33494, 33524, 33516, 33505, 33522, 33525, 33548, 33531, 33526,
+33520, 33514,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 33508, 33504, 33530, 33523,
+33517, 34423, 34420, 34428, 34419, 34881, 34894, 34919, 34922, 34921,
+35283, 35332, 35335, 36210, 36835, 36833, 36846, 36832, 37105, 37053,
+37055, 37077, 37061, 37054, 37063, 37067, 37064, 37332, 37331, 38484,
+38479, 38481, 38483, 38474, 38478, 20510, 20485, 20487, 20499, 20514,
+20528, 20507, 20469, 20468, 20531, 20535, 20524, 20470, 20471, 20503,
+20508, 20512, 20519, 20533, 20527, 20529, 20494, 20826, 20884, 20883,
+20938, 20932, 20933, 20936, 20942, 21089, 21082, 21074, 21086, 21087,
+21077, 21090, 21197, 21262, 21406, 21798, 21730, 21783, 21778, 21735,
+21747, 21732, 21786, 21759, 21764, 21768, 21739, 21777, 21765, 21745,
+21770, 21755, 21751, 21752, 21728, 21774, 21763, 21771, 22273, 22274,
+22476, 22578, 22485, 22482, 22458, 22470, 22461, 22460, 22456, 22454,
+22463, 22471, 22480, 22457, 22465, 22798, 22858, 23065, 23062, 23085,
+23086, 23061, 23055, 23063, 23050, 23070, 23091, 23404, 23463, 23469,
+23468, 23555, 23638, 23636, 23788, 23807, 23790, 23793, 23799, 23808,
+23801, 24105, 24104, 24232, 24238, 24234, 24236, 24371, 24368, 24423,
+24669, 24666, 24679,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 24641, 24738, 24712,
+24704, 24722, 24705, 24733, 24707, 24725, 24731, 24727, 24711, 24732,
+24718, 25113, 25158, 25330, 25360, 25430, 25388, 25412, 25413, 25398,
+25411, 25572, 25401, 25419, 25418, 25404, 25385, 25409, 25396, 25432,
+25428, 25433, 25389, 25415, 25395, 25434, 25425, 25400, 25431, 25408,
+25416, 25930, 25926, 26054, 26051, 26052, 26050, 26186, 26207, 26183,
+26193, 26386, 26387, 26655, 26650, 26697, 26674, 26675, 26683, 26699,
+26703, 26646, 26673, 26652, 26677, 26667, 26669, 26671, 26702, 26692,
+26676, 26653, 26642, 26644, 26662, 26664, 26670, 26701, 26682, 26661,
+26656, 27436, 27439, 27437, 27441, 27444, 27501, 32898, 27528, 27622,
+27620, 27624, 27619, 27618, 27623, 27685, 28026, 28003, 28004, 28022,
+27917, 28001, 28050, 27992, 28002, 28013, 28015, 28049, 28045, 28143,
+28031, 28038, 27998, 28007, 28000, 28055, 28016, 28028, 27999, 28034,
+28056, 27951, 28008, 28043, 28030, 28032, 28036, 27926, 28035, 28027,
+28029, 28021, 28048, 28892, 28883, 28881, 28893, 28875, 32569, 28898,
+28887, 28882, 28894, 28896, 28884, 28877, 28869, 28870, 28871, 28890,
+28878, 28897, 29250, 29304,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 29303, 29302,
+29440, 29434, 29428, 29438, 29430, 29427, 29435, 29441, 29651, 29657,
+29669, 29654, 29628, 29671, 29667, 29673, 29660, 29650, 29659, 29652,
+29661, 29658, 29655, 29656, 29672, 29918, 29919, 29940, 29941, 29985,
+30043, 30047, 30128, 30145, 30139, 30148, 30144, 30143, 30134, 30138,
+30346, 30409, 30493, 30491, 30480, 30483, 30482, 30499, 30481, 30485,
+30489, 30490, 30498, 30503, 30755, 30764, 30754, 30773, 30767, 30760,
+30766, 30763, 30753, 30761, 30771, 30762, 30769, 31060, 31067, 31055,
+31068, 31059, 31058, 31057, 31211, 31212, 31200, 31214, 31213, 31210,
+31196, 31198, 31197, 31366, 31369, 31365, 31371, 31372, 31370, 31367,
+31448, 31504, 31492, 31507, 31493, 31503, 31496, 31498, 31502, 31497,
+31506, 31876, 31889, 31882, 31884, 31880, 31885, 31877, 32030, 32029,
+32017, 32014, 32024, 32022, 32019, 32031, 32018, 32015, 32012, 32604,
+32609, 32606, 32608, 32605, 32603, 32662, 32658, 32707, 32706, 32704,
+32790, 32830, 32825, 33018, 33010, 33017, 33013, 33025, 33019, 33024,
+33281, 33327, 33317, 33587, 33581, 33604, 33561, 33617, 33573, 33622,
+33599, 33601, 33574, 33564, 33570,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 33602,
+33614, 33563, 33578, 33544, 33596, 33613, 33558, 33572, 33568, 33591,
+33583, 33577, 33607, 33605, 33612, 33619, 33566, 33580, 33611, 33575,
+33608, 34387, 34386, 34466, 34472, 34454, 34445, 34449, 34462, 34439,
+34455, 34438, 34443, 34458, 34437, 34469, 34457, 34465, 34471, 34453,
+34456, 34446, 34461, 34448, 34452, 34883, 34884, 34925, 34933, 34934,
+34930, 34944, 34929, 34943, 34927, 34947, 34942, 34932, 34940, 35346,
+35911, 35927, 35963, 36004, 36003, 36214, 36216, 36277, 36279, 36278,
+36561, 36563, 36862, 36853, 36866, 36863, 36859, 36868, 36860, 36854,
+37078, 37088, 37081, 37082, 37091, 37087, 37093, 37080, 37083, 37079,
+37084, 37092, 37200, 37198, 37199, 37333, 37346, 37338, 38492, 38495,
+38588, 39139, 39647, 39727, 20095, 20592, 20586, 20577, 20574, 20576,
+20563, 20555, 20573, 20594, 20552, 20557, 20545, 20571, 20554, 20578,
+20501, 20549, 20575, 20585, 20587, 20579, 20580, 20550, 20544, 20590,
+20595, 20567, 20561, 20944, 21099, 21101, 21100, 21102, 21206, 21203,
+21293, 21404, 21877, 21878, 21820, 21837, 21840, 21812, 21802, 21841,
+21858, 21814, 21813, 21808, 21842, 21829,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+21772, 21810, 21861, 21838, 21817, 21832, 21805, 21819, 21824, 21835,
+22282, 22279, 22523, 22548, 22498, 22518, 22492, 22516, 22528, 22509,
+22525, 22536, 22520, 22539, 22515, 22479, 22535, 22510, 22499, 22514,
+22501, 22508, 22497, 22542, 22524, 22544, 22503, 22529, 22540, 22513,
+22505, 22512, 22541, 22532, 22876, 23136, 23128, 23125, 23143, 23134,
+23096, 23093, 23149, 23120, 23135, 23141, 23148, 23123, 23140, 23127,
+23107, 23133, 23122, 23108, 23131, 23112, 23182, 23102, 23117, 23097,
+23116, 23152, 23145, 23111, 23121, 23126, 23106, 23132, 23410, 23406,
+23489, 23488, 23641, 23838, 23819, 23837, 23834, 23840, 23820, 23848,
+23821, 23846, 23845, 23823, 23856, 23826, 23843, 23839, 23854, 24126,
+24116, 24241, 24244, 24249, 24242, 24243, 24374, 24376, 24475, 24470,
+24479, 24714, 24720, 24710, 24766, 24752, 24762, 24787, 24788, 24783,
+24804, 24793, 24797, 24776, 24753, 24795, 24759, 24778, 24767, 24771,
+24781, 24768, 25394, 25445, 25482, 25474, 25469, 25533, 25502, 25517,
+25501, 25495, 25515, 25486, 25455, 25479, 25488, 25454, 25519, 25461,
+25500, 25453, 25518, 25468, 25508, 25403, 25503,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 25464, 25477, 25473, 25489, 25485, 25456, 25939, 26061, 26213,
+26209, 26203, 26201, 26204, 26210, 26392, 26745, 26759, 26768, 26780,
+26733, 26734, 26798, 26795, 26966, 26735, 26787, 26796, 26793, 26741,
+26740, 26802, 26767, 26743, 26770, 26748, 26731, 26738, 26794, 26752,
+26737, 26750, 26779, 26774, 26763, 26784, 26761, 26788, 26744, 26747,
+26769, 26764, 26762, 26749, 27446, 27443, 27447, 27448, 27537, 27535,
+27533, 27534, 27532, 27690, 28096, 28075, 28084, 28083, 28276, 28076,
+28137, 28130, 28087, 28150, 28116, 28160, 28104, 28128, 28127, 28118,
+28094, 28133, 28124, 28125, 28123, 28148, 28106, 28093, 28141, 28144,
+28090, 28117, 28098, 28111, 28105, 28112, 28146, 28115, 28157, 28119,
+28109, 28131, 28091, 28922, 28941, 28919, 28951, 28916, 28940, 28912,
+28932, 28915, 28944, 28924, 28927, 28934, 28947, 28928, 28920, 28918,
+28939, 28930, 28942, 29310, 29307, 29308, 29311, 29469, 29463, 29447,
+29457, 29464, 29450, 29448, 29439, 29455, 29470, 29576, 29686, 29688,
+29685, 29700, 29697, 29693, 29703, 29696, 29690, 29692, 29695, 29708,
+29707, 29684, 29704, 30052, 30051, 30158, 30162, 30159,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 30155, 30156, 30161, 30160, 30351, 30345, 30419, 30521,
+30511, 30509, 30513, 30514, 30516, 30515, 30525, 30501, 30523, 30517,
+30792, 30802, 30793, 30797, 30794, 30796, 30758, 30789, 30800, 31076,
+31079, 31081, 31082, 31075, 31083, 31073, 31163, 31226, 31224, 31222,
+31223, 31375, 31380, 31376, 31541, 31559, 31540, 31525, 31536, 31522,
+31524, 31539, 31512, 31530, 31517, 31537, 31531, 31533, 31535, 31538,
+31544, 31514, 31523, 31892, 31896, 31894, 31907, 32053, 32061, 32056,
+32054, 32058, 32069, 32044, 32041, 32065, 32071, 32062, 32063, 32074,
+32059, 32040, 32611, 32661, 32668, 32669, 32667, 32714, 32715, 32717,
+32720, 32721, 32711, 32719, 32713, 32799, 32798, 32795, 32839, 32835,
+32840, 33048, 33061, 33049, 33051, 33069, 33055, 33068, 33054, 33057,
+33045, 33063, 33053, 33058, 33297, 33336, 33331, 33338, 33332, 33330,
+33396, 33680, 33699, 33704, 33677, 33658, 33651, 33700, 33652, 33679,
+33665, 33685, 33689, 33653, 33684, 33705, 33661, 33667, 33676, 33693,
+33691, 33706, 33675, 33662, 33701, 33711, 33672, 33687, 33712, 33663,
+33702, 33671, 33710, 33654, 33690, 34393, 34390, 34495, 34487,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 34498, 34497, 34501, 34490, 34480, 34504, 34489,
+34483, 34488, 34508, 34484, 34491, 34492, 34499, 34493, 34494, 34898,
+34953, 34965, 34984, 34978, 34986, 34970, 34961, 34977, 34975, 34968,
+34983, 34969, 34971, 34967, 34980, 34988, 34956, 34963, 34958, 35202,
+35286, 35289, 35285, 35376, 35367, 35372, 35358, 35897, 35899, 35932,
+35933, 35965, 36005, 36221, 36219, 36217, 36284, 36290, 36281, 36287,
+36289, 36568, 36574, 36573, 36572, 36567, 36576, 36577, 36900, 36875,
+36881, 36892, 36876, 36897, 37103, 37098, 37104, 37108, 37106, 37107,
+37076, 37099, 37100, 37097, 37206, 37208, 37210, 37203, 37205, 37356,
+37364, 37361, 37363, 37368, 37348, 37369, 37354, 37355, 37367, 37352,
+37358, 38266, 38278, 38280, 38524, 38509, 38507, 38513, 38511, 38591,
+38762, 38916, 39141, 39319, 20635, 20629, 20628, 20638, 20619, 20643,
+20611, 20620, 20622, 20637, 20584, 20636, 20626, 20610, 20615, 20831,
+20948, 21266, 21265, 21412, 21415, 21905, 21928, 21925, 21933, 21879,
+22085, 21922, 21907, 21896, 21903, 21941, 21889, 21923, 21906, 21924,
+21885, 21900, 21926, 21887, 21909, 21921, 21902, 22284, 22569, 22583,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 22553, 22558, 22567, 22563, 22568, 22517,
+22600, 22565, 22556, 22555, 22579, 22591, 22582, 22574, 22585, 22584,
+22573, 22572, 22587, 22881, 23215, 23188, 23199, 23162, 23202, 23198,
+23160, 23206, 23164, 23205, 23212, 23189, 23214, 23095, 23172, 23178,
+23191, 23171, 23179, 23209, 23163, 23165, 23180, 23196, 23183, 23187,
+23197, 23530, 23501, 23499, 23508, 23505, 23498, 23502, 23564, 23600,
+23863, 23875, 23915, 23873, 23883, 23871, 23861, 23889, 23886, 23893,
+23859, 23866, 23890, 23869, 23857, 23897, 23874, 23865, 23881, 23864,
+23868, 23858, 23862, 23872, 23877, 24132, 24129, 24408, 24486, 24485,
+24491, 24777, 24761, 24780, 24802, 24782, 24772, 24852, 24818, 24842,
+24854, 24837, 24821, 24851, 24824, 24828, 24830, 24769, 24835, 24856,
+24861, 24848, 24831, 24836, 24843, 25162, 25492, 25521, 25520, 25550,
+25573, 25576, 25583, 25539, 25757, 25587, 25546, 25568, 25590, 25557,
+25586, 25589, 25697, 25567, 25534, 25565, 25564, 25540, 25560, 25555,
+25538, 25543, 25548, 25547, 25544, 25584, 25559, 25561, 25906, 25959,
+25962, 25956, 25948, 25960, 25957, 25996, 26013, 26014, 26030, 26064,
+26066,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 26236, 26220, 26235, 26240, 26225,
+26233, 26218, 26226, 26369, 26892, 26835, 26884, 26844, 26922, 26860,
+26858, 26865, 26895, 26838, 26871, 26859, 26852, 26870, 26899, 26896,
+26867, 26849, 26887, 26828, 26888, 26992, 26804, 26897, 26863, 26822,
+26900, 26872, 26832, 26877, 26876, 26856, 26891, 26890, 26903, 26830,
+26824, 26845, 26846, 26854, 26868, 26833, 26886, 26836, 26857, 26901,
+26917, 26823, 27449, 27451, 27455, 27452, 27540, 27543, 27545, 27541,
+27581, 27632, 27634, 27635, 27696, 28156, 28230, 28231, 28191, 28233,
+28296, 28220, 28221, 28229, 28258, 28203, 28223, 28225, 28253, 28275,
+28188, 28211, 28235, 28224, 28241, 28219, 28163, 28206, 28254, 28264,
+28252, 28257, 28209, 28200, 28256, 28273, 28267, 28217, 28194, 28208,
+28243, 28261, 28199, 28280, 28260, 28279, 28245, 28281, 28242, 28262,
+28213, 28214, 28250, 28960, 28958, 28975, 28923, 28974, 28977, 28963,
+28965, 28962, 28978, 28959, 28968, 28986, 28955, 29259, 29274, 29320,
+29321, 29318, 29317, 29323, 29458, 29451, 29488, 29474, 29489, 29491,
+29479, 29490, 29485, 29478, 29475, 29493, 29452, 29742, 29740, 29744,
+29739, 29718,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 29722, 29729, 29741, 29745,
+29732, 29731, 29725, 29737, 29728, 29746, 29947, 29999, 30063, 30060,
+30183, 30170, 30177, 30182, 30173, 30175, 30180, 30167, 30357, 30354,
+30426, 30534, 30535, 30532, 30541, 30533, 30538, 30542, 30539, 30540,
+30686, 30700, 30816, 30820, 30821, 30812, 30829, 30833, 30826, 30830,
+30832, 30825, 30824, 30814, 30818, 31092, 31091, 31090, 31088, 31234,
+31242, 31235, 31244, 31236, 31385, 31462, 31460, 31562, 31547, 31556,
+31560, 31564, 31566, 31552, 31576, 31557, 31906, 31902, 31912, 31905,
+32088, 32111, 32099, 32083, 32086, 32103, 32106, 32079, 32109, 32092,
+32107, 32082, 32084, 32105, 32081, 32095, 32078, 32574, 32575, 32613,
+32614, 32674, 32672, 32673, 32727, 32849, 32847, 32848, 33022, 32980,
+33091, 33098, 33106, 33103, 33095, 33085, 33101, 33082, 33254, 33262,
+33271, 33272, 33273, 33284, 33340, 33341, 33343, 33397, 33595, 33743,
+33785, 33827, 33728, 33768, 33810, 33767, 33764, 33788, 33782, 33808,
+33734, 33736, 33771, 33763, 33727, 33793, 33757, 33765, 33752, 33791,
+33761, 33739, 33742, 33750, 33781, 33737, 33801, 33807, 33758, 33809,
+33798, 33730, 33779,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 33749, 33786, 33735,
+33745, 33770, 33811, 33731, 33772, 33774, 33732, 33787, 33751, 33762,
+33819, 33755, 33790, 34520, 34530, 34534, 34515, 34531, 34522, 34538,
+34525, 34539, 34524, 34540, 34537, 34519, 34536, 34513, 34888, 34902,
+34901, 35002, 35031, 35001, 35000, 35008, 35006, 34998, 35004, 34999,
+35005, 34994, 35073, 35017, 35221, 35224, 35223, 35293, 35290, 35291,
+35406, 35405, 35385, 35417, 35392, 35415, 35416, 35396, 35397, 35410,
+35400, 35409, 35402, 35404, 35407, 35935, 35969, 35968, 36026, 36030,
+36016, 36025, 36021, 36228, 36224, 36233, 36312, 36307, 36301, 36295,
+36310, 36316, 36303, 36309, 36313, 36296, 36311, 36293, 36591, 36599,
+36602, 36601, 36582, 36590, 36581, 36597, 36583, 36584, 36598, 36587,
+36593, 36588, 36596, 36585, 36909, 36916, 36911, 37126, 37164, 37124,
+37119, 37116, 37128, 37113, 37115, 37121, 37120, 37127, 37125, 37123,
+37217, 37220, 37215, 37218, 37216, 37377, 37386, 37413, 37379, 37402,
+37414, 37391, 37388, 37376, 37394, 37375, 37373, 37382, 37380, 37415,
+37378, 37404, 37412, 37401, 37399, 37381, 37398, 38267, 38285, 38284,
+38288, 38535, 38526, 38536,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 38537, 38531,
+38528, 38594, 38600, 38595, 38641, 38640, 38764, 38768, 38766, 38919,
+39081, 39147, 40166, 40697, 20099, 20100, 20150, 20669, 20671, 20678,
+20654, 20676, 20682, 20660, 20680, 20674, 20656, 20673, 20666, 20657,
+20683, 20681, 20662, 20664, 20951, 21114, 21112, 21115, 21116, 21955,
+21979, 21964, 21968, 21963, 21962, 21981, 21952, 21972, 21956, 21993,
+21951, 21970, 21901, 21967, 21973, 21986, 21974, 21960, 22002, 21965,
+21977, 21954, 22292, 22611, 22632, 22628, 22607, 22605, 22601, 22639,
+22613, 22606, 22621, 22617, 22629, 22619, 22589, 22627, 22641, 22780,
+23239, 23236, 23243, 23226, 23224, 23217, 23221, 23216, 23231, 23240,
+23227, 23238, 23223, 23232, 23242, 23220, 23222, 23245, 23225, 23184,
+23510, 23512, 23513, 23583, 23603, 23921, 23907, 23882, 23909, 23922,
+23916, 23902, 23912, 23911, 23906, 24048, 24143, 24142, 24138, 24141,
+24139, 24261, 24268, 24262, 24267, 24263, 24384, 24495, 24493, 24823,
+24905, 24906, 24875, 24901, 24886, 24882, 24878, 24902, 24879, 24911,
+24873, 24896, 25120, 37224, 25123, 25125, 25124, 25541, 25585, 25579,
+25616, 25618, 25609, 25632, 25636,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 25651,
+25667, 25631, 25621, 25624, 25657, 25655, 25634, 25635, 25612, 25638,
+25648, 25640, 25665, 25653, 25647, 25610, 25626, 25664, 25637, 25639,
+25611, 25575, 25627, 25646, 25633, 25614, 25967, 26002, 26067, 26246,
+26252, 26261, 26256, 26251, 26250, 26265, 26260, 26232, 26400, 26982,
+26975, 26936, 26958, 26978, 26993, 26943, 26949, 26986, 26937, 26946,
+26967, 26969, 27002, 26952, 26953, 26933, 26988, 26931, 26941, 26981,
+26864, 27000, 26932, 26985, 26944, 26991, 26948, 26998, 26968, 26945,
+26996, 26956, 26939, 26955, 26935, 26972, 26959, 26961, 26930, 26962,
+26927, 27003, 26940, 27462, 27461, 27459, 27458, 27464, 27457, 27547,
+64013, 27643, 27644, 27641, 27639, 27640, 28315, 28374, 28360, 28303,
+28352, 28319, 28307, 28308, 28320, 28337, 28345, 28358, 28370, 28349,
+28353, 28318, 28361, 28343, 28336, 28365, 28326, 28367, 28338, 28350,
+28355, 28380, 28376, 28313, 28306, 28302, 28301, 28324, 28321, 28351,
+28339, 28368, 28362, 28311, 28334, 28323, 28999, 29012, 29010, 29027,
+29024, 28993, 29021, 29026, 29042, 29048, 29034, 29025, 28994, 29016,
+28995, 29003, 29040, 29023, 29008, 29011,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+28996, 29005, 29018, 29263, 29325, 29324, 29329, 29328, 29326, 29500,
+29506, 29499, 29498, 29504, 29514, 29513, 29764, 29770, 29771, 29778,
+29777, 29783, 29760, 29775, 29776, 29774, 29762, 29766, 29773, 29780,
+29921, 29951, 29950, 29949, 29981, 30073, 30071, 27011, 30191, 30223,
+30211, 30199, 30206, 30204, 30201, 30200, 30224, 30203, 30198, 30189,
+30197, 30205, 30361, 30389, 30429, 30549, 30559, 30560, 30546, 30550,
+30554, 30569, 30567, 30548, 30553, 30573, 30688, 30855, 30874, 30868,
+30863, 30852, 30869, 30853, 30854, 30881, 30851, 30841, 30873, 30848,
+30870, 30843, 31100, 31106, 31101, 31097, 31249, 31256, 31257, 31250,
+31255, 31253, 31266, 31251, 31259, 31248, 31395, 31394, 31390, 31467,
+31590, 31588, 31597, 31604, 31593, 31602, 31589, 31603, 31601, 31600,
+31585, 31608, 31606, 31587, 31922, 31924, 31919, 32136, 32134, 32128,
+32141, 32127, 32133, 32122, 32142, 32123, 32131, 32124, 32140, 32148,
+32132, 32125, 32146, 32621, 32619, 32615, 32616, 32620, 32678, 32677,
+32679, 32731, 32732, 32801, 33124, 33120, 33143, 33116, 33129, 33115,
+33122, 33138, 26401, 33118, 33142, 33127, 33135,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 33092, 33121, 33309, 33353, 33348, 33344, 33346, 33349, 34033,
+33855, 33878, 33910, 33913, 33935, 33933, 33893, 33873, 33856, 33926,
+33895, 33840, 33869, 33917, 33882, 33881, 33908, 33907, 33885, 34055,
+33886, 33847, 33850, 33844, 33914, 33859, 33912, 33842, 33861, 33833,
+33753, 33867, 33839, 33858, 33837, 33887, 33904, 33849, 33870, 33868,
+33874, 33903, 33989, 33934, 33851, 33863, 33846, 33843, 33896, 33918,
+33860, 33835, 33888, 33876, 33902, 33872, 34571, 34564, 34551, 34572,
+34554, 34518, 34549, 34637, 34552, 34574, 34569, 34561, 34550, 34573,
+34565, 35030, 35019, 35021, 35022, 35038, 35035, 35034, 35020, 35024,
+35205, 35227, 35295, 35301, 35300, 35297, 35296, 35298, 35292, 35302,
+35446, 35462, 35455, 35425, 35391, 35447, 35458, 35460, 35445, 35459,
+35457, 35444, 35450, 35900, 35915, 35914, 35941, 35940, 35942, 35974,
+35972, 35973, 36044, 36200, 36201, 36241, 36236, 36238, 36239, 36237,
+36243, 36244, 36240, 36242, 36336, 36320, 36332, 36337, 36334, 36304,
+36329, 36323, 36322, 36327, 36338, 36331, 36340, 36614, 36607, 36609,
+36608, 36613, 36615, 36616, 36610, 36619, 36946, 36927,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 36932, 36937, 36925, 37136, 37133, 37135, 37137, 37142,
+37140, 37131, 37134, 37230, 37231, 37448, 37458, 37424, 37434, 37478,
+37427, 37477, 37470, 37507, 37422, 37450, 37446, 37485, 37484, 37455,
+37472, 37479, 37487, 37430, 37473, 37488, 37425, 37460, 37475, 37456,
+37490, 37454, 37459, 37452, 37462, 37426, 38303, 38300, 38302, 38299,
+38546, 38547, 38545, 38551, 38606, 38650, 38653, 38648, 38645, 38771,
+38775, 38776, 38770, 38927, 38925, 38926, 39084, 39158, 39161, 39343,
+39346, 39344, 39349, 39597, 39595, 39771, 40170, 40173, 40167, 40576,
+40701, 20710, 20692, 20695, 20712, 20723, 20699, 20714, 20701, 20708,
+20691, 20716, 20720, 20719, 20707, 20704, 20952, 21120, 21121, 21225,
+21227, 21296, 21420, 22055, 22037, 22028, 22034, 22012, 22031, 22044,
+22017, 22035, 22018, 22010, 22045, 22020, 22015, 22009, 22665, 22652,
+22672, 22680, 22662, 22657, 22655, 22644, 22667, 22650, 22663, 22673,
+22670, 22646, 22658, 22664, 22651, 22676, 22671, 22782, 22891, 23260,
+23278, 23269, 23253, 23274, 23258, 23277, 23275, 23283, 23266, 23264,
+23259, 23276, 23262, 23261, 23257, 23272, 23263, 23415, 23520,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 23523, 23651, 23938, 23936, 23933, 23942, 23930,
+23937, 23927, 23946, 23945, 23944, 23934, 23932, 23949, 23929, 23935,
+24152, 24153, 24147, 24280, 24273, 24279, 24270, 24284, 24277, 24281,
+24274, 24276, 24388, 24387, 24431, 24502, 24876, 24872, 24897, 24926,
+24945, 24947, 24914, 24915, 24946, 24940, 24960, 24948, 24916, 24954,
+24923, 24933, 24891, 24938, 24929, 24918, 25129, 25127, 25131, 25643,
+25677, 25691, 25693, 25716, 25718, 25714, 25715, 25725, 25717, 25702,
+25766, 25678, 25730, 25694, 25692, 25675, 25683, 25696, 25680, 25727,
+25663, 25708, 25707, 25689, 25701, 25719, 25971, 26016, 26273, 26272,
+26271, 26373, 26372, 26402, 27057, 27062, 27081, 27040, 27086, 27030,
+27056, 27052, 27068, 27025, 27033, 27022, 27047, 27021, 27049, 27070,
+27055, 27071, 27076, 27069, 27044, 27092, 27065, 27082, 27034, 27087,
+27059, 27027, 27050, 27041, 27038, 27097, 27031, 27024, 27074, 27061,
+27045, 27078, 27466, 27469, 27467, 27550, 27551, 27552, 27587, 27588,
+27646, 28366, 28405, 28401, 28419, 28453, 28408, 28471, 28411, 28462,
+28425, 28494, 28441, 28442, 28455, 28440, 28475, 28434, 28397, 28426,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 28470, 28531, 28409, 28398, 28461, 28480,
+28464, 28476, 28469, 28395, 28423, 28430, 28483, 28421, 28413, 28406,
+28473, 28444, 28412, 28474, 28447, 28429, 28446, 28424, 28449, 29063,
+29072, 29065, 29056, 29061, 29058, 29071, 29051, 29062, 29057, 29079,
+29252, 29267, 29335, 29333, 29331, 29507, 29517, 29521, 29516, 29794,
+29811, 29809, 29813, 29810, 29799, 29806, 29952, 29954, 29955, 30077,
+30096, 30230, 30216, 30220, 30229, 30225, 30218, 30228, 30392, 30593,
+30588, 30597, 30594, 30574, 30592, 30575, 30590, 30595, 30898, 30890,
+30900, 30893, 30888, 30846, 30891, 30878, 30885, 30880, 30892, 30882,
+30884, 31128, 31114, 31115, 31126, 31125, 31124, 31123, 31127, 31112,
+31122, 31120, 31275, 31306, 31280, 31279, 31272, 31270, 31400, 31403,
+31404, 31470, 31624, 31644, 31626, 31633, 31632, 31638, 31629, 31628,
+31643, 31630, 31621, 31640, 21124, 31641, 31652, 31618, 31931, 31935,
+31932, 31930, 32167, 32183, 32194, 32163, 32170, 32193, 32192, 32197,
+32157, 32206, 32196, 32198, 32203, 32204, 32175, 32185, 32150, 32188,
+32159, 32166, 32174, 32169, 32161, 32201, 32627, 32738, 32739, 32741,
+32734,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 32804, 32861, 32860, 33161, 33158,
+33155, 33159, 33165, 33164, 33163, 33301, 33943, 33956, 33953, 33951,
+33978, 33998, 33986, 33964, 33966, 33963, 33977, 33972, 33985, 33997,
+33962, 33946, 33969, 34000, 33949, 33959, 33979, 33954, 33940, 33991,
+33996, 33947, 33961, 33967, 33960, 34006, 33944, 33974, 33999, 33952,
+34007, 34004, 34002, 34011, 33968, 33937, 34401, 34611, 34595, 34600,
+34667, 34624, 34606, 34590, 34593, 34585, 34587, 34627, 34604, 34625,
+34622, 34630, 34592, 34610, 34602, 34605, 34620, 34578, 34618, 34609,
+34613, 34626, 34598, 34599, 34616, 34596, 34586, 34608, 34577, 35063,
+35047, 35057, 35058, 35066, 35070, 35054, 35068, 35062, 35067, 35056,
+35052, 35051, 35229, 35233, 35231, 35230, 35305, 35307, 35304, 35499,
+35481, 35467, 35474, 35471, 35478, 35901, 35944, 35945, 36053, 36047,
+36055, 36246, 36361, 36354, 36351, 36365, 36349, 36362, 36355, 36359,
+36358, 36357, 36350, 36352, 36356, 36624, 36625, 36622, 36621, 37155,
+37148, 37152, 37154, 37151, 37149, 37146, 37156, 37153, 37147, 37242,
+37234, 37241, 37235, 37541, 37540, 37494, 37531, 37498, 37536, 37524,
+37546, 37517,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 37542, 37530, 37547, 37497,
+37527, 37503, 37539, 37614, 37518, 37506, 37525, 37538, 37501, 37512,
+37537, 37514, 37510, 37516, 37529, 37543, 37502, 37511, 37545, 37533,
+37515, 37421, 38558, 38561, 38655, 38744, 38781, 38778, 38782, 38787,
+38784, 38786, 38779, 38788, 38785, 38783, 38862, 38861, 38934, 39085,
+39086, 39170, 39168, 39175, 39325, 39324, 39363, 39353, 39355, 39354,
+39362, 39357, 39367, 39601, 39651, 39655, 39742, 39743, 39776, 39777,
+39775, 40177, 40178, 40181, 40615, 20735, 20739, 20784, 20728, 20742,
+20743, 20726, 20734, 20747, 20748, 20733, 20746, 21131, 21132, 21233,
+21231, 22088, 22082, 22092, 22069, 22081, 22090, 22089, 22086, 22104,
+22106, 22080, 22067, 22077, 22060, 22078, 22072, 22058, 22074, 22298,
+22699, 22685, 22705, 22688, 22691, 22703, 22700, 22693, 22689, 22783,
+23295, 23284, 23293, 23287, 23286, 23299, 23288, 23298, 23289, 23297,
+23303, 23301, 23311, 23655, 23961, 23959, 23967, 23954, 23970, 23955,
+23957, 23968, 23964, 23969, 23962, 23966, 24169, 24157, 24160, 24156,
+32243, 24283, 24286, 24289, 24393, 24498, 24971, 24963, 24953, 25009,
+25008, 24994, 24969,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 24987, 24979, 25007,
+25005, 24991, 24978, 25002, 24993, 24973, 24934, 25011, 25133, 25710,
+25712, 25750, 25760, 25733, 25751, 25756, 25743, 25739, 25738, 25740,
+25763, 25759, 25704, 25777, 25752, 25974, 25978, 25977, 25979, 26034,
+26035, 26293, 26288, 26281, 26290, 26295, 26282, 26287, 27136, 27142,
+27159, 27109, 27128, 27157, 27121, 27108, 27168, 27135, 27116, 27106,
+27163, 27165, 27134, 27175, 27122, 27118, 27156, 27127, 27111, 27200,
+27144, 27110, 27131, 27149, 27132, 27115, 27145, 27140, 27160, 27173,
+27151, 27126, 27174, 27143, 27124, 27158, 27473, 27557, 27555, 27554,
+27558, 27649, 27648, 27647, 27650, 28481, 28454, 28542, 28551, 28614,
+28562, 28557, 28553, 28556, 28514, 28495, 28549, 28506, 28566, 28534,
+28524, 28546, 28501, 28530, 28498, 28496, 28503, 28564, 28563, 28509,
+28416, 28513, 28523, 28541, 28519, 28560, 28499, 28555, 28521, 28543,
+28565, 28515, 28535, 28522, 28539, 29106, 29103, 29083, 29104, 29088,
+29082, 29097, 29109, 29085, 29093, 29086, 29092, 29089, 29098, 29084,
+29095, 29107, 29336, 29338, 29528, 29522, 29534, 29535, 29536, 29533,
+29531, 29537, 29530, 29529,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 29538, 29831,
+29833, 29834, 29830, 29825, 29821, 29829, 29832, 29820, 29817, 29960,
+29959, 30078, 30245, 30238, 30233, 30237, 30236, 30243, 30234, 30248,
+30235, 30364, 30365, 30366, 30363, 30605, 30607, 30601, 30600, 30925,
+30907, 30927, 30924, 30929, 30926, 30932, 30920, 30915, 30916, 30921,
+31130, 31137, 31136, 31132, 31138, 31131, 27510, 31289, 31410, 31412,
+31411, 31671, 31691, 31678, 31660, 31694, 31663, 31673, 31690, 31669,
+31941, 31944, 31948, 31947, 32247, 32219, 32234, 32231, 32215, 32225,
+32259, 32250, 32230, 32246, 32241, 32240, 32238, 32223, 32630, 32684,
+32688, 32685, 32749, 32747, 32746, 32748, 32742, 32744, 32868, 32871,
+33187, 33183, 33182, 33173, 33186, 33177, 33175, 33302, 33359, 33363,
+33362, 33360, 33358, 33361, 34084, 34107, 34063, 34048, 34089, 34062,
+34057, 34061, 34079, 34058, 34087, 34076, 34043, 34091, 34042, 34056,
+34060, 34036, 34090, 34034, 34069, 34039, 34027, 34035, 34044, 34066,
+34026, 34025, 34070, 34046, 34088, 34077, 34094, 34050, 34045, 34078,
+34038, 34097, 34086, 34023, 34024, 34032, 34031, 34041, 34072, 34080,
+34096, 34059, 34073, 34095, 34402,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 34646,
+34659, 34660, 34679, 34785, 34675, 34648, 34644, 34651, 34642, 34657,
+34650, 34641, 34654, 34669, 34666, 34640, 34638, 34655, 34653, 34671,
+34668, 34682, 34670, 34652, 34661, 34639, 34683, 34677, 34658, 34663,
+34665, 34906, 35077, 35084, 35092, 35083, 35095, 35096, 35097, 35078,
+35094, 35089, 35086, 35081, 35234, 35236, 35235, 35309, 35312, 35308,
+35535, 35526, 35512, 35539, 35537, 35540, 35541, 35515, 35543, 35518,
+35520, 35525, 35544, 35523, 35514, 35517, 35545, 35902, 35917, 35983,
+36069, 36063, 36057, 36072, 36058, 36061, 36071, 36256, 36252, 36257,
+36251, 36384, 36387, 36389, 36388, 36398, 36373, 36379, 36374, 36369,
+36377, 36390, 36391, 36372, 36370, 36376, 36371, 36380, 36375, 36378,
+36652, 36644, 36632, 36634, 36640, 36643, 36630, 36631, 36979, 36976,
+36975, 36967, 36971, 37167, 37163, 37161, 37162, 37170, 37158, 37166,
+37253, 37254, 37258, 37249, 37250, 37252, 37248, 37584, 37571, 37572,
+37568, 37593, 37558, 37583, 37617, 37599, 37592, 37609, 37591, 37597,
+37580, 37615, 37570, 37608, 37578, 37576, 37582, 37606, 37581, 37589,
+37577, 37600, 37598, 37607, 37585, 37587,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+37557, 37601, 37574, 37556, 38268, 38316, 38315, 38318, 38320, 38564,
+38562, 38611, 38661, 38664, 38658, 38746, 38794, 38798, 38792, 38864,
+38863, 38942, 38941, 38950, 38953, 38952, 38944, 38939, 38951, 39090,
+39176, 39162, 39185, 39188, 39190, 39191, 39189, 39388, 39373, 39375,
+39379, 39380, 39374, 39369, 39382, 39384, 39371, 39383, 39372, 39603,
+39660, 39659, 39667, 39666, 39665, 39750, 39747, 39783, 39796, 39793,
+39782, 39798, 39797, 39792, 39784, 39780, 39788, 40188, 40186, 40189,
+40191, 40183, 40199, 40192, 40185, 40187, 40200, 40197, 40196, 40579,
+40659, 40719, 40720, 20764, 20755, 20759, 20762, 20753, 20958, 21300,
+21473, 22128, 22112, 22126, 22131, 22118, 22115, 22125, 22130, 22110,
+22135, 22300, 22299, 22728, 22717, 22729, 22719, 22714, 22722, 22716,
+22726, 23319, 23321, 23323, 23329, 23316, 23315, 23312, 23318, 23336,
+23322, 23328, 23326, 23535, 23980, 23985, 23977, 23975, 23989, 23984,
+23982, 23978, 23976, 23986, 23981, 23983, 23988, 24167, 24168, 24166,
+24175, 24297, 24295, 24294, 24296, 24293, 24395, 24508, 24989, 25000,
+24982, 25029, 25012, 25030, 25025, 25036, 25018,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 25023, 25016, 24972, 25815, 25814, 25808, 25807, 25801, 25789,
+25737, 25795, 25819, 25843, 25817, 25907, 25983, 25980, 26018, 26312,
+26302, 26304, 26314, 26315, 26319, 26301, 26299, 26298, 26316, 26403,
+27188, 27238, 27209, 27239, 27186, 27240, 27198, 27229, 27245, 27254,
+27227, 27217, 27176, 27226, 27195, 27199, 27201, 27242, 27236, 27216,
+27215, 27220, 27247, 27241, 27232, 27196, 27230, 27222, 27221, 27213,
+27214, 27206, 27477, 27476, 27478, 27559, 27562, 27563, 27592, 27591,
+27652, 27651, 27654, 28589, 28619, 28579, 28615, 28604, 28622, 28616,
+28510, 28612, 28605, 28574, 28618, 28584, 28676, 28581, 28590, 28602,
+28588, 28586, 28623, 28607, 28600, 28578, 28617, 28587, 28621, 28591,
+28594, 28592, 29125, 29122, 29119, 29112, 29142, 29120, 29121, 29131,
+29140, 29130, 29127, 29135, 29117, 29144, 29116, 29126, 29146, 29147,
+29341, 29342, 29545, 29542, 29543, 29548, 29541, 29547, 29546, 29823,
+29850, 29856, 29844, 29842, 29845, 29857, 29963, 30080, 30255, 30253,
+30257, 30269, 30259, 30268, 30261, 30258, 30256, 30395, 30438, 30618,
+30621, 30625, 30620, 30619, 30626, 30627, 30613, 30617,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 30615, 30941, 30953, 30949, 30954, 30942, 30947, 30939,
+30945, 30946, 30957, 30943, 30944, 31140, 31300, 31304, 31303, 31414,
+31416, 31413, 31409, 31415, 31710, 31715, 31719, 31709, 31701, 31717,
+31706, 31720, 31737, 31700, 31722, 31714, 31708, 31723, 31704, 31711,
+31954, 31956, 31959, 31952, 31953, 32274, 32289, 32279, 32268, 32287,
+32288, 32275, 32270, 32284, 32277, 32282, 32290, 32267, 32271, 32278,
+32269, 32276, 32293, 32292, 32579, 32635, 32636, 32634, 32689, 32751,
+32810, 32809, 32876, 33201, 33190, 33198, 33209, 33205, 33195, 33200,
+33196, 33204, 33202, 33207, 33191, 33266, 33365, 33366, 33367, 34134,
+34117, 34155, 34125, 34131, 34145, 34136, 34112, 34118, 34148, 34113,
+34146, 34116, 34129, 34119, 34147, 34110, 34139, 34161, 34126, 34158,
+34165, 34133, 34151, 34144, 34188, 34150, 34141, 34132, 34149, 34156,
+34403, 34405, 34404, 34715, 34703, 34711, 34707, 34706, 34696, 34689,
+34710, 34712, 34681, 34695, 34723, 34693, 34704, 34705, 34717, 34692,
+34708, 34716, 34714, 34697, 35102, 35110, 35120, 35117, 35118, 35111,
+35121, 35106, 35113, 35107, 35119, 35116, 35103, 35313, 35552,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 35554, 35570, 35572, 35573, 35549, 35604, 35556,
+35551, 35568, 35528, 35550, 35553, 35560, 35583, 35567, 35579, 35985,
+35986, 35984, 36085, 36078, 36081, 36080, 36083, 36204, 36206, 36261,
+36263, 36403, 36414, 36408, 36416, 36421, 36406, 36412, 36413, 36417,
+36400, 36415, 36541, 36662, 36654, 36661, 36658, 36665, 36663, 36660,
+36982, 36985, 36987, 36998, 37114, 37171, 37173, 37174, 37267, 37264,
+37265, 37261, 37263, 37671, 37662, 37640, 37663, 37638, 37647, 37754,
+37688, 37692, 37659, 37667, 37650, 37633, 37702, 37677, 37646, 37645,
+37579, 37661, 37626, 37669, 37651, 37625, 37623, 37684, 37634, 37668,
+37631, 37673, 37689, 37685, 37674, 37652, 37644, 37643, 37630, 37641,
+37632, 37627, 37654, 38332, 38349, 38334, 38329, 38330, 38326, 38335,
+38325, 38333, 38569, 38612, 38667, 38674, 38672, 38809, 38807, 38804,
+38896, 38904, 38965, 38959, 38962, 39204, 39199, 39207, 39209, 39326,
+39406, 39404, 39397, 39396, 39408, 39395, 39402, 39401, 39399, 39609,
+39615, 39604, 39611, 39670, 39674, 39673, 39671, 39731, 39808, 39813,
+39815, 39804, 39806, 39803, 39810, 39827, 39826, 39824, 39802, 39829,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 39805, 39816, 40229, 40215, 40224, 40222,
+40212, 40233, 40221, 40216, 40226, 40208, 40217, 40223, 40584, 40582,
+40583, 40622, 40621, 40661, 40662, 40698, 40722, 40765, 20774, 20773,
+20770, 20772, 20768, 20777, 21236, 22163, 22156, 22157, 22150, 22148,
+22147, 22142, 22146, 22143, 22145, 22742, 22740, 22735, 22738, 23341,
+23333, 23346, 23331, 23340, 23335, 23334, 23343, 23342, 23419, 23537,
+23538, 23991, 24172, 24170, 24510, 24507, 25027, 25013, 25020, 25063,
+25056, 25061, 25060, 25064, 25054, 25839, 25833, 25827, 25835, 25828,
+25832, 25985, 25984, 26038, 26074, 26322, 27277, 27286, 27265, 27301,
+27273, 27295, 27291, 27297, 27294, 27271, 27283, 27278, 27285, 27267,
+27304, 27300, 27281, 27263, 27302, 27290, 27269, 27276, 27282, 27483,
+27565, 27657, 28620, 28585, 28660, 28628, 28643, 28636, 28653, 28647,
+28646, 28638, 28658, 28637, 28642, 28648, 29153, 29169, 29160, 29170,
+29156, 29168, 29154, 29555, 29550, 29551, 29847, 29874, 29867, 29840,
+29866, 29869, 29873, 29861, 29871, 29968, 29969, 29970, 29967, 30084,
+30275, 30280, 30281, 30279, 30372, 30441, 30645, 30635, 30642, 30647,
+30646,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 30644, 30641, 30632, 30704, 30963,
+30973, 30978, 30971, 30972, 30962, 30981, 30969, 30974, 30980, 31147,
+31144, 31324, 31323, 31318, 31320, 31316, 31322, 31422, 31424, 31425,
+31749, 31759, 31730, 31744, 31743, 31739, 31758, 31732, 31755, 31731,
+31746, 31753, 31747, 31745, 31736, 31741, 31750, 31728, 31729, 31760,
+31754, 31976, 32301, 32316, 32322, 32307, 38984, 32312, 32298, 32329,
+32320, 32327, 32297, 32332, 32304, 32315, 32310, 32324, 32314, 32581,
+32639, 32638, 32637, 32756, 32754, 32812, 33211, 33220, 33228, 33226,
+33221, 33223, 33212, 33257, 33371, 33370, 33372, 34179, 34176, 34191,
+34215, 34197, 34208, 34187, 34211, 34171, 34212, 34202, 34206, 34167,
+34172, 34185, 34209, 34170, 34168, 34135, 34190, 34198, 34182, 34189,
+34201, 34205, 34177, 34210, 34178, 34184, 34181, 34169, 34166, 34200,
+34192, 34207, 34408, 34750, 34730, 34733, 34757, 34736, 34732, 34745,
+34741, 34748, 34734, 34761, 34755, 34754, 34764, 34743, 34735, 34756,
+34762, 34740, 34742, 34751, 34744, 34749, 34782, 34738, 35125, 35123,
+35132, 35134, 35137, 35154, 35127, 35138, 35245, 35247, 35246, 35314,
+35315, 35614,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 35608, 35606, 35601, 35589,
+35595, 35618, 35599, 35602, 35605, 35591, 35597, 35592, 35590, 35612,
+35603, 35610, 35919, 35952, 35954, 35953, 35951, 35989, 35988, 36089,
+36207, 36430, 36429, 36435, 36432, 36428, 36423, 36675, 36672, 36997,
+36990, 37176, 37274, 37282, 37275, 37273, 37279, 37281, 37277, 37280,
+37793, 37763, 37807, 37732, 37718, 37703, 37756, 37720, 37724, 37750,
+37705, 37712, 37713, 37728, 37741, 37775, 37708, 37738, 37753, 37719,
+37717, 37714, 37711, 37745, 37751, 37755, 37729, 37726, 37731, 37735,
+37760, 37710, 37721, 38343, 38336, 38345, 38339, 38341, 38327, 38574,
+38576, 38572, 38688, 38687, 38680, 38685, 38681, 38810, 38817, 38812,
+38814, 38813, 38869, 38868, 38897, 38977, 38980, 38986, 38985, 38981,
+38979, 39205, 39211, 39212, 39210, 39219, 39218, 39215, 39213, 39217,
+39216, 39320, 39331, 39329, 39426, 39418, 39412, 39415, 39417, 39416,
+39414, 39419, 39421, 39422, 39420, 39427, 39614, 39678, 39677, 39681,
+39676, 39752, 39834, 39848, 39838, 39835, 39846, 39841, 39845, 39844,
+39814, 39842, 39840, 39855, 40243, 40257, 40295, 40246, 40238, 40239,
+40241, 40248, 40240,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 40261, 40258, 40259,
+40254, 40247, 40256, 40253, 32757, 40237, 40586, 40585, 40589, 40624,
+40648, 40666, 40699, 40703, 40740, 40739, 40738, 40788, 40864, 20785,
+20781, 20782, 22168, 22172, 22167, 22170, 22173, 22169, 22896, 23356,
+23657, 23658, 24000, 24173, 24174, 25048, 25055, 25069, 25070, 25073,
+25066, 25072, 25067, 25046, 25065, 25855, 25860, 25853, 25848, 25857,
+25859, 25852, 26004, 26075, 26330, 26331, 26328, 27333, 27321, 27325,
+27361, 27334, 27322, 27318, 27319, 27335, 27316, 27309, 27486, 27593,
+27659, 28679, 28684, 28685, 28673, 28677, 28692, 28686, 28671, 28672,
+28667, 28710, 28668, 28663, 28682, 29185, 29183, 29177, 29187, 29181,
+29558, 29880, 29888, 29877, 29889, 29886, 29878, 29883, 29890, 29972,
+29971, 30300, 30308, 30297, 30288, 30291, 30295, 30298, 30374, 30397,
+30444, 30658, 30650, 30975, 30988, 30995, 30996, 30985, 30992, 30994,
+30993, 31149, 31148, 31327, 31772, 31785, 31769, 31776, 31775, 31789,
+31773, 31782, 31784, 31778, 31781, 31792, 32348, 32336, 32342, 32355,
+32344, 32354, 32351, 32337, 32352, 32343, 32339, 32693, 32691, 32759,
+32760, 32885, 33233, 33234,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 33232, 33375,
+33374, 34228, 34246, 34240, 34243, 34242, 34227, 34229, 34237, 34247,
+34244, 34239, 34251, 34254, 34248, 34245, 34225, 34230, 34258, 34340,
+34232, 34231, 34238, 34409, 34791, 34790, 34786, 34779, 34795, 34794,
+34789, 34783, 34803, 34788, 34772, 34780, 34771, 34797, 34776, 34787,
+34724, 34775, 34777, 34817, 34804, 34792, 34781, 35155, 35147, 35151,
+35148, 35142, 35152, 35153, 35145, 35626, 35623, 35619, 35635, 35632,
+35637, 35655, 35631, 35644, 35646, 35633, 35621, 35639, 35622, 35638,
+35630, 35620, 35643, 35645, 35642, 35906, 35957, 35993, 35992, 35991,
+36094, 36100, 36098, 36096, 36444, 36450, 36448, 36439, 36438, 36446,
+36453, 36455, 36443, 36442, 36449, 36445, 36457, 36436, 36678, 36679,
+36680, 36683, 37160, 37178, 37179, 37182, 37288, 37285, 37287, 37295,
+37290, 37813, 37772, 37778, 37815, 37787, 37789, 37769, 37799, 37774,
+37802, 37790, 37798, 37781, 37768, 37785, 37791, 37773, 37809, 37777,
+37810, 37796, 37800, 37812, 37795, 37797, 38354, 38355, 38353, 38579,
+38615, 38618, 24002, 38623, 38616, 38621, 38691, 38690, 38693, 38828,
+38830, 38824, 38827, 38820, 38826,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 38818,
+38821, 38871, 38873, 38870, 38872, 38906, 38992, 38993, 38994, 39096,
+39233, 39228, 39226, 39439, 39435, 39433, 39437, 39428, 39441, 39434,
+39429, 39431, 39430, 39616, 39644, 39688, 39684, 39685, 39721, 39733,
+39754, 39756, 39755, 39879, 39878, 39875, 39871, 39873, 39861, 39864,
+39891, 39862, 39876, 39865, 39869, 40284, 40275, 40271, 40266, 40283,
+40267, 40281, 40278, 40268, 40279, 40274, 40276, 40287, 40280, 40282,
+40590, 40588, 40671, 40705, 40704, 40726, 40741, 40747, 40746, 40745,
+40744, 40780, 40789, 20788, 20789, 21142, 21239, 21428, 22187, 22189,
+22182, 22183, 22186, 22188, 22746, 22749, 22747, 22802, 23357, 23358,
+23359, 24003, 24176, 24511, 25083, 25863, 25872, 25869, 25865, 25868,
+25870, 25988, 26078, 26077, 26334, 27367, 27360, 27340, 27345, 27353,
+27339, 27359, 27356, 27344, 27371, 27343, 27341, 27358, 27488, 27568,
+27660, 28697, 28711, 28704, 28694, 28715, 28705, 28706, 28707, 28713,
+28695, 28708, 28700, 28714, 29196, 29194, 29191, 29186, 29189, 29349,
+29350, 29348, 29347, 29345, 29899, 29893, 29879, 29891, 29974, 30304,
+30665, 30666, 30660, 30705, 31005, 31003,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+31009, 31004, 30999, 31006, 31152, 31335, 31336, 31795, 31804, 31801,
+31788, 31803, 31980, 31978, 32374, 32373, 32376, 32368, 32375, 32367,
+32378, 32370, 32372, 32360, 32587, 32586, 32643, 32646, 32695, 32765,
+32766, 32888, 33239, 33237, 33380, 33377, 33379, 34283, 34289, 34285,
+34265, 34273, 34280, 34266, 34263, 34284, 34290, 34296, 34264, 34271,
+34275, 34268, 34257, 34288, 34278, 34287, 34270, 34274, 34816, 34810,
+34819, 34806, 34807, 34825, 34828, 34827, 34822, 34812, 34824, 34815,
+34826, 34818, 35170, 35162, 35163, 35159, 35169, 35164, 35160, 35165,
+35161, 35208, 35255, 35254, 35318, 35664, 35656, 35658, 35648, 35667,
+35670, 35668, 35659, 35669, 35665, 35650, 35666, 35671, 35907, 35959,
+35958, 35994, 36102, 36103, 36105, 36268, 36266, 36269, 36267, 36461,
+36472, 36467, 36458, 36463, 36475, 36546, 36690, 36689, 36687, 36688,
+36691, 36788, 37184, 37183, 37296, 37293, 37854, 37831, 37839, 37826,
+37850, 37840, 37881, 37868, 37836, 37849, 37801, 37862, 37834, 37844,
+37870, 37859, 37845, 37828, 37838, 37824, 37842, 37863, 38269, 38362,
+38363, 38625, 38697, 38699, 38700, 38696, 38694,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 38835, 38839, 38838, 38877, 38878, 38879, 39004, 39001, 39005,
+38999, 39103, 39101, 39099, 39102, 39240, 39239, 39235, 39334, 39335,
+39450, 39445, 39461, 39453, 39460, 39451, 39458, 39456, 39463, 39459,
+39454, 39452, 39444, 39618, 39691, 39690, 39694, 39692, 39735, 39914,
+39915, 39904, 39902, 39908, 39910, 39906, 39920, 39892, 39895, 39916,
+39900, 39897, 39909, 39893, 39905, 39898, 40311, 40321, 40330, 40324,
+40328, 40305, 40320, 40312, 40326, 40331, 40332, 40317, 40299, 40308,
+40309, 40304, 40297, 40325, 40307, 40315, 40322, 40303, 40313, 40319,
+40327, 40296, 40596, 40593, 40640, 40700, 40749, 40768, 40769, 40781,
+40790, 40791, 40792, 21303, 22194, 22197, 22195, 22755, 23365, 24006,
+24007, 24302, 24303, 24512, 24513, 25081, 25879, 25878, 25877, 25875,
+26079, 26344, 26339, 26340, 27379, 27376, 27370, 27368, 27385, 27377,
+27374, 27375, 28732, 28725, 28719, 28727, 28724, 28721, 28738, 28728,
+28735, 28730, 28729, 28736, 28731, 28723, 28737, 29203, 29204, 29352,
+29565, 29564, 29882, 30379, 30378, 30398, 30445, 30668, 30670, 30671,
+30669, 30706, 31013, 31011, 31015, 31016, 31012, 31017,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 31154, 31342, 31340, 31341, 31479, 31817, 31816, 31818,
+31815, 31813, 31982, 32379, 32382, 32385, 32384, 32698, 32767, 32889,
+33243, 33241, 33291, 33384, 33385, 34338, 34303, 34305, 34302, 34331,
+34304, 34294, 34308, 34313, 34309, 34316, 34301, 34841, 34832, 34833,
+34839, 34835, 34838, 35171, 35174, 35257, 35319, 35680, 35690, 35677,
+35688, 35683, 35685, 35687, 35693, 36270, 36486, 36488, 36484, 36697,
+36694, 36695, 36693, 36696, 36698, 37005, 37187, 37185, 37303, 37301,
+37298, 37299, 37899, 37907, 37883, 37920, 37903, 37908, 37886, 37909,
+37904, 37928, 37913, 37901, 37877, 37888, 37879, 37895, 37902, 37910,
+37906, 37882, 37897, 37880, 37898, 37887, 37884, 37900, 37878, 37905,
+37894, 38366, 38368, 38367, 38702, 38703, 38841, 38843, 38909, 38910,
+39008, 39010, 39011, 39007, 39105, 39106, 39248, 39246, 39257, 39244,
+39243, 39251, 39474, 39476, 39473, 39468, 39466, 39478, 39465, 39470,
+39480, 39469, 39623, 39626, 39622, 39696, 39698, 39697, 39947, 39944,
+39927, 39941, 39954, 39928, 40000, 39943, 39950, 39942, 39959, 39956,
+39945, 40351, 40345, 40356, 40349, 40338, 40344, 40336, 40347,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0, 40352, 40340, 40348, 40362, 40343, 40353, 40346,
+40354, 40360, 40350, 40355, 40383, 40361, 40342, 40358, 40359, 40601,
+40603, 40602, 40677, 40676, 40679, 40678, 40752, 40750, 40795, 40800,
+40798, 40797, 40793, 40849, 20794, 20793, 21144, 21143, 22211, 22205,
+22206, 23368, 23367, 24011, 24015, 24305, 25085, 25883, 27394, 27388,
+27395, 27384, 27392, 28739, 28740, 28746, 28744, 28745, 28741, 28742,
+29213, 29210, 29209, 29566, 29975, 30314, 30672, 31021, 31025, 31023,
+31828, 31827, 31986, 32394, 32391, 32392, 32395, 32390, 32397, 32589,
+32699, 32816, 33245, 34328, 34346, 34342, 34335, 34339, 34332, 34329,
+34343, 34350, 34337, 34336, 34345, 34334, 34341, 34857, 34845, 34843,
+34848, 34852, 34844, 34859, 34890, 35181, 35177, 35182, 35179, 35322,
+35705, 35704, 35653, 35706, 35707, 36112, 36116, 36271, 36494, 36492,
+36702, 36699, 36701, 37190, 37188, 37189, 37305, 37951, 37947, 37942,
+37929, 37949, 37948, 37936, 37945, 37930, 37943, 37932, 37952, 37937,
+38373, 38372, 38371, 38709, 38714, 38847, 38881, 39012, 39113, 39110,
+39104, 39256, 39254, 39481, 39485, 39494, 39492, 39490, 39489, 39482,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0, 39487, 39629, 39701, 39703, 39704, 39702,
+39738, 39762, 39979, 39965, 39964, 39980, 39971, 39976, 39977, 39972,
+39969, 40375, 40374, 40380, 40385, 40391, 40394, 40399, 40382, 40389,
+40387, 40379, 40373, 40398, 40377, 40378, 40364, 40392, 40369, 40365,
+40396, 40371, 40397, 40370, 40570, 40604, 40683, 40686, 40685, 40731,
+40728, 40730, 40753, 40782, 40805, 40804, 40850, 20153, 22214, 22213,
+22219, 22897, 23371, 23372, 24021, 24017, 24306, 25889, 25888, 25894,
+25890, 27403, 27400, 27401, 27661, 28757, 28758, 28759, 28754, 29214,
+29215, 29353, 29567, 29912, 29909, 29913, 29911, 30317, 30381, 31029,
+31156, 31344, 31345, 31831, 31836, 31833, 31835, 31834, 31988, 31985,
+32401, 32591, 32647, 33246, 33387, 34356, 34357, 34355, 34348, 34354,
+34358, 34860, 34856, 34854, 34858, 34853, 35185, 35263, 35262, 35323,
+35710, 35716, 35714, 35718, 35717, 35711, 36117, 36501, 36500, 36506,
+36498, 36496, 36502, 36503, 36704, 36706, 37191, 37964, 37968, 37962,
+37963, 37967, 37959, 37957, 37960, 37961, 37958, 38719, 38883, 39018,
+39017, 39115, 39252, 39259, 39502, 39507, 39508, 39500, 39503, 39496,
+39498,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0, 39497, 39506, 39504, 39632, 39705,
+39723, 39739, 39766, 39765, 40006, 40008, 39999, 40004, 39993, 39987,
+40001, 39996, 39991, 39988, 39986, 39997, 39990, 40411, 40402, 40414,
+40410, 40395, 40400, 40412, 40401, 40415, 40425, 40409, 40408, 40406,
+40437, 40405, 40413, 40630, 40688, 40757, 40755, 40754, 40770, 40811,
+40853, 40866, 20797, 21145, 22760, 22759, 22898, 23373, 24024, 34863,
+24399, 25089, 25091, 25092, 25897, 25893, 26006, 26347, 27409, 27410,
+27407, 27594, 28763, 28762, 29218, 29570, 29569, 29571, 30320, 30676,
+31847, 31846, 32405, 33388, 34362, 34368, 34361, 34364, 34353, 34363,
+34366, 34864, 34866, 34862, 34867, 35190, 35188, 35187, 35326, 35724,
+35726, 35723, 35720, 35909, 36121, 36504, 36708, 36707, 37308, 37986,
+37973, 37981, 37975, 37982, 38852, 38853, 38912, 39510, 39513, 39710,
+39711, 39712, 40018, 40024, 40016, 40010, 40013, 40011, 40021, 40025,
+40012, 40014, 40443, 40439, 40431, 40419, 40427, 40440, 40420, 40438,
+40417, 40430, 40422, 40434, 40432, 40418, 40428, 40436, 40435, 40424,
+40429, 40642, 40656, 40690, 40691, 40710, 40732, 40760, 40759, 40758,
+40771, 40783,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0, 40817, 40816, 40814, 40815,
+22227, 22221, 23374, 23661, 25901, 26349, 26350, 27411, 28767, 28769,
+28765, 28768, 29219, 29915, 29925, 30677, 31032, 31159, 31158, 31850,
+32407, 32649, 33389, 34371, 34872, 34871, 34869, 34891, 35732, 35733,
+36510, 36511, 36512, 36509, 37310, 37309, 37314, 37995, 37992, 37993,
+38629, 38726, 38723, 38727, 38855, 38885, 39518, 39637, 39769, 40035,
+40039, 40038, 40034, 40030, 40032, 40450, 40446, 40455, 40451, 40454,
+40453, 40448, 40449, 40457, 40447, 40445, 40452, 40608, 40734, 40774,
+40820, 40821, 40822, 22228, 25902, 26040, 27416, 27417, 27415, 27418,
+28770, 29222, 29354, 30680, 30681, 31033, 31849, 31851, 31990, 32410,
+32408, 32411, 32409, 33248, 33249, 34374, 34375, 34376, 35193, 35194,
+35196, 35195, 35327, 35736, 35737, 36517, 36516, 36515, 37998, 37997,
+37999, 38001, 38003, 38729, 39026, 39263, 40040, 40046, 40045, 40459,
+40461, 40464, 40463, 40466, 40465, 40609, 40693, 40713, 40775, 40824,
+40827, 40826, 40825, 22302, 28774, 31855, 34876, 36274, 36518, 37315,
+38004, 38008, 38006, 38005, 39520, 40052, 40051, 40049, 40053, 40468,
+40467, 40694, 40714,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0, 40868, 28776, 28773,
+31991, 34410, 34878, 34877, 34879, 35742, 35996, 36521, 36553, 38731,
+39027, 39028, 39116, 39265, 39339, 39524, 39526, 39527, 39716, 40469,
+40471, 40776, 25095, 27422, 29223, 34380, 36520, 38018, 38016, 38017,
+39529, 39528, 39726, 40473, 29225, 34379, 35743, 38019, 40057, 40631,
+30325, 39531, 40058, 40477, 28777, 28778, 40612, 40830, 40777, 40856,
+30849, 37561, 35023, 22715, 24658, 31911, 23290,  9556,  9574,  9559,
+ 9568,  9580,  9571,  9562,  9577,  9565,  9554,  9572,  9557,  9566,
+ 9578,  9569,  9560,  9575,  9563,  9555,  9573,  9558,  9567,  9579,
+ 9570,  9561,  9576,  9564,  9553,  9552,  9581,  9582,  9584,  9583,
+ 9619, 57344, 57345, 57346, 57347, 57348, 57349, 57350, 57351, 57352,
+57353, 57354, 57355, 57356, 57357, 57358, 57359, 57360, 57361, 57362,
+57363, 57364, 57365, 57366, 57367, 57368, 57369, 57370, 57371, 57372,
+57373, 57374, 57375, 57376, 57377, 57378, 57379, 29234, 29244, 29286,
+29314, 29327, 29343, 29357, 29361, 29368, 29374, 29389, 29403, 29476,
+29487, 29496, 29497, 29629, 29646, 29681, 29814, 29858, 29953, 29977,
+29987, 30012, 30020, 30025,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0, 30029, 30061,
+30082, 30083, 30089, 30124, 30166, 30185, 30272, 30285, 30292, 30312,
+30336, 30339, 30352, 30391, 30393, 30477, 30494, 30531, 30744, 30748,
+30777, 30780, 30791, 30806, 30842, 30901, 30905, 30918, 30937, 30983,
+31024, 31028, 31035, 31104, 31133, 31171, 31201, 31238, 31246, 31299,
+31312, 31427, 31442, 31458, 31463, 31480, 31542, 31586, 31596, 31610,
+31611, 31642, 31646, 31647, 31650, 31655, 31734, 31762, 31764, 31823,
+31830, 31832, 31915, 31994, 32072, 32075, 32119, 32212, 32213, 32214,
+32228, 32333, 32349, 32383, 32393, 32398, 32402, 32468, 32497, 32530,
+32560, 32625, 32642, 32686, 32710, 32800, 32802, 32805, 32817, 32863,
+32872, 32940, 32951, 20890, 21526, 21524, 13535, 19581, 25283, 57508,
+57509, 57510, 21707, 57512, 21948, 32950, 20903, 57516, 57517, 57518,
+21779, 33318, 57521, 21790, 21982, 25529, 26776, 57526, 21762, 21865,
+30132, 25596, 40580, 37418, 57533, 57534, 57535, 35015, 24734, 22053,
+28997, 23282, 57541, 21135, 22095, 30611, 34694, 36397, 33206, 13822,
+29174, 57550, 34820, 37765, 57553, 57554, 30310, 57556, 40050, 57558,
+25294, 57560, 40598, 18825, 31955,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0, 36570,
+40619, 25831, 57567, 33450, 26471, 28018, 30982, 31172, 32590, 34798,
+57575, 33726, 34351, 35237, 17935, 57580, 39112, 39232, 39245, 39436,
+39639, 40600, 40742, 57588, 20227, 57590, 20281, 20274, 20395, 20566,
+57595, 20526, 20646, 20697, 20750, 20717, 20737, 20980, 21023, 21088,
+21079, 21146, 21201, 21216, 21217, 20947, 20959, 30022, 20990, 21298,
+21292, 21299, 21419, 21418, 40846, 21609, 21660, 21466, 27338, 21875,
+57625, 13782, 57627, 22033, 22093, 57630, 22100, 13811, 57633, 22342,
+22394, 22375, 22586, 22502, 22493, 22592, 57641, 22566, 22748, 22967,
+23001, 23584, 57647, 23761, 23785, 23878, 23950, 57652, 24053, 24075,
+24082, 24110, 24158, 57658, 24397, 31357, 23491, 31419, 57663, 57664,
+24484, 24506, 24508, 57668, 24695, 24740, 24755, 24829, 24880, 57674,
+24988, 24921, 24957, 24924, 25471, 25058, 28885, 25145, 25192, 25221,
+25218, 25254, 25301, 25444, 25397, 25744, 14940, 26184, 26215, 26398,
+26627, 26540, 26617, 26806, 26924, 26881, 26880, 26826, 26995, 27008,
+26942, 57706, 27058, 27072, 27018, 27130, 27113, 27314, 27218, 27293,
+27421, 27474, 27642, 15569, 27854, 28239,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+28089, 28484, 57723, 28634, 28801, 31180, 28980, 15820, 29046, 57730,
+57731, 29205, 29264, 29319, 29484, 29362, 29410, 29442, 29512, 29480,
+29519, 29553, 25989, 57744, 29789, 29800, 29982, 30035, 30074, 30369,
+30412, 30500, 30507, 16485, 30803, 30931, 30936, 40318, 30895, 57760,
+24898, 31145, 39994, 31188, 57765, 31277, 31294, 31305, 31453, 31450,
+30147, 30215, 30210, 57774, 30311, 30319, 22048, 35431, 40727, 31519,
+31634, 31651, 31695, 57784, 31740, 31810, 31825, 31837, 31856, 31870,
+31878, 31875, 31916, 31943, 31938, 57796, 31962, 57798, 32077, 32090,
+32245, 32295, 32366, 40597, 21107, 32797, 32866, 32867, 32870, 32859,
+32934, 33027, 40577, 33224, 57815, 36768, 33270, 33306, 57819, 34673,
+34729, 34700, 40606, 34753, 40476, 57826, 34774, 34805, 34831, 34840,
+34861, 34882, 34885, 39989, 34926, 34986, 34976, 25245, 35139, 35149,
+29042, 34910, 57843, 33533, 17591, 33488, 33669, 40194, 40809, 33824,
+57851, 34010, 33965, 17659, 34123, 57856, 34306, 34320, 25553, 35209,
+35210, 35220, 40005, 35260, 35454, 35401, 35596, 35651, 35713, 35660,
+57871, 36013, 36075, 36087, 36108, 36226, 36262,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0, 36308, 36392, 36431, 36471, 36469, 36519, 36633, 57885, 36700,
+40260, 37060, 37201, 57890, 37212, 37209, 37223, 37244, 37262, 37307,
+40616, 36950, 36940, 37374, 37474, 37566, 37739, 37742, 37818, 37927,
+38295, 38311, 57909, 38456, 57911, 38531, 38550, 38529, 38589, 38659,
+38689, 38705, 38751, 38815, 38836, 38840, 38842, 38846, 38856, 40639,
+38943, 38958, 40869, 38983, 38987, 39014, 39020, 39092, 40794, 39132,
+39142, 39234, 39225, 39227, 40787, 39242, 40773, 19326, 39386, 31432,
+39610, 39613, 40706, 39722, 57951, 39725, 39650, 39682, 39679, 19463,
+39689, 19460, 19515, 39823, 39837, 39856, 39948, 39957, 39946, 39935,
+39982, 33000, 33001, 33004, 33038, 27705, 20074, 38465, 22770, 31074,
+26658, 57978, 57979, 33031, 22487, 17642, 25653, 34100, 16607, 57986,
+26906, 39938, 30129, 33747, 29041, 27147, 57993, 27258, 39668, 57996,
+57997, 30649, 25904, 28054, 22071, 26405, 27179, 32093, 36961, 20120,
+31910, 31545, 58009, 22901, 14023, 28799, 58013, 28299, 58015, 58016,
+38749, 37584, 22356, 58020, 16089, 58022, 58023, 24985, 29792, 28991,
+31022, 23190, 37704, 26254, 20477, 37697, 13908, 23925,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    0,     0, 28702, 25979, 28813, 24269, 58039, 24743, 31408, 24419,
+58043, 29687, 58045, 29800, 30132, 58048, 39785,   189,  8531,  8532,
+  188,   190,  8533,  8534,  8535,  8536,  8537,  8538, 34450, 34464,
+34477, 34482, 34725, 34737,  8539,  8540,  8541,  8542, 34778, 34895,
+34912, 34951, 34959, 34960, 35046, 35071, 35072, 35108, 35143, 35156,
+35173, 35200, 35217, 35356, 35369, 35371, 35384, 35389,  8978, 35472,
+35476, 35484, 35497, 35503, 35508, 35562, 35615,  8240, 35647, 35661,
+35678, 35682, 35689, 35739, 35921, 35995, 35999, 36052, 36054, 33042,
+33073, 33078, 33119, 33133, 33149, 33171, 33194, 33208, 33217, 33321,
+33325, 33326, 33342, 33378, 33386, 33416
+};
+
+static const uchar ucs_to_big5[][2] =
+{
+    {'\x00','\x00'},{'\x00','\x01'},{'\x00','\x02'},{'\x00','\x03'},{'\x00','\x04'},
+    {'\x00','\x05'},{'\x00','\x06'},{'\x00','\x07'},{'\x00','\x08'},{'\x00','\x09'},
+    {'\x00','\x0a'},{'\x00','\x0b'},{'\x00','\x0c'},{'\x00','\x0d'},{'\x00','\x0e'},
+    {'\x00','\x0f'},{'\x00','\x10'},{'\x00','\x11'},{'\x00','\x12'},{'\x00','\x13'},
+    {'\x00','\x14'},{'\x00','\x15'},{'\x00','\x16'},{'\x00','\x17'},{'\x00','\x18'},
+    {'\x00','\x19'},{'\x00','\x1a'},{'\x00','\x1b'},{'\x00','\x1c'},{'\x00','\x1d'},
+    {'\x00','\x1e'},{'\x00','\x1f'},{'\x00','\x20'},{'\x00','\x21'},{'\x00','\x22'},
+    {'\x00','\x23'},{'\x00','\x24'},{'\x00','\x25'},{'\x00','\x26'},{'\x00','\x27'},
+    {'\x00','\x28'},{'\x00','\x29'},{'\x00','\x2a'},{'\x00','\x2b'},{'\x00','\x2c'},
+    {'\x00','\x2d'},{'\x00','\x2e'},{'\x00','\x2f'},{'\x00','\x30'},{'\x00','\x31'},
+    {'\x00','\x32'},{'\x00','\x33'},{'\x00','\x34'},{'\x00','\x35'},{'\x00','\x36'},
+    {'\x00','\x37'},{'\x00','\x38'},{'\x00','\x39'},{'\x00','\x3a'},{'\x00','\x3b'},
+    {'\x00','\x3c'},{'\x00','\x3d'},{'\x00','\x3e'},{'\x00','\x3f'},{'\x00','\x40'},
+    {'\x00','\x41'},{'\x00','\x42'},{'\x00','\x43'},{'\x00','\x44'},{'\x00','\x45'},
+    {'\x00','\x46'},{'\x00','\x47'},{'\x00','\x48'},{'\x00','\x49'},{'\x00','\x4a'},
+    {'\x00','\x4b'},{'\x00','\x4c'},{'\x00','\x4d'},{'\x00','\x4e'},{'\x00','\x4f'},
+    {'\x00','\x50'},{'\x00','\x51'},{'\x00','\x52'},{'\x00','\x53'},{'\x00','\x54'},
+    {'\x00','\x55'},{'\x00','\x56'},{'\x00','\x57'},{'\x00','\x58'},{'\x00','\x59'},
+    {'\x00','\x5a'},{'\x00','\x5b'},{'\x00','\x5c'},{'\x00','\x5d'},{'\x00','\x5e'},
+    {'\x00','\x5f'},{'\x00','\x60'},{'\x00','\x61'},{'\x00','\x62'},{'\x00','\x63'},
+    {'\x00','\x64'},{'\x00','\x65'},{'\x00','\x66'},{'\x00','\x67'},{'\x00','\x68'},
+    {'\x00','\x69'},{'\x00','\x6a'},{'\x00','\x6b'},{'\x00','\x6c'},{'\x00','\x6d'},
+    {'\x00','\x6e'},{'\x00','\x6f'},{'\x00','\x70'},{'\x00','\x71'},{'\x00','\x72'},
+    {'\x00','\x73'},{'\x00','\x74'},{'\x00','\x75'},{'\x00','\x76'},{'\x00','\x77'},
+    {'\x00','\x78'},{'\x00','\x79'},{'\x00','\x7a'},{'\x00','\x7b'},{'\x00','\x7c'},
+    {'\x00','\x7d'},{'\x00','\x7e'},{'\x00','\x7f'},{'\x00','\x80'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa0','\xdf'},{'\xa2','\x46'},{'\xa2','\x47'},{'\xa0','\xfc'},
+    {'\xa2','\x44'},{'\x7c','\x20'},{'\xa1','\xb1'},{'\xc6','\xd8'},{'\x63','\x20'},
+    {'\xa0','\xde'},{'\x00','\x00'},{'\x00','\x00'},{'\x2d','\x20'},{'\x97','\xfb'},
+    {'\xa1','\xc2'},{'\xa2','\x58'},{'\xa1','\xd3'},{'\x32','\x20'},{'\x33','\x20'},
+    {'\xa1','\xac'},{'\xa3','\x67'},{'\x91','\xf8'},{'\xa1','\x50'},{'\xa0','\xfb'},
+    {'\x31','\x20'},{'\xa0','\xee'},{'\x00','\x00'},{'\xfe','\xb3'},{'\xfe','\xb0'},
+    {'\xfe','\xb4'},{'\xa0','\xef'},{'\xa0','\xa7'},{'\xa0','\xac'},{'\xa0','\xf6'},
+    {'\xa0','\xbe'},{'\xa0','\xb6'},{'\xa0','\xd6'},{'\xa0','\xbb'},{'\xa0','\xbc'},
+    {'\xa0','\xa8'},{'\xa0','\xd7'},{'\xa0','\xf7'},{'\xa0','\xb7'},{'\xa0','\xa9'},
+    {'\xa0','\xad'},{'\xa0','\xf8'},{'\xa0','\xb8'},{'\xa0','\xda'},{'\xa0','\xbd'},
+    {'\xa0','\xaa'},{'\xa0','\xae'},{'\xa0','\xf9'},{'\xa0','\xbf'},{'\xa0','\xb9'},
+    {'\xa1','\xd1'},{'\xa0','\xd9'},{'\xa0','\xab'},{'\xa0','\xaf'},{'\xa0','\xfa'},
+    {'\xa0','\xba'},{'\x59','\x20'},{'\xa0','\xdc'},{'\xa0','\xdd'},{'\xa0','\xe0'},
+    {'\xa0','\xc0'},{'\xa0','\xf0'},{'\xa0','\xce'},{'\xa0','\xc6'},{'\xa0','\xe6'},
+    {'\xa0','\xcb'},{'\xa0','\xcc'},{'\xa0','\xe1'},{'\xa0','\xc1'},{'\xa0','\xf1'},
+    {'\xa0','\xc7'},{'\xa0','\xe2'},{'\xa0','\xc2'},{'\xa0','\xf2'},{'\xa0','\xc8'},
+    {'\xa0','\xea'},{'\xa0','\xcd'},{'\xa0','\xe3'},{'\xa0','\xc3'},{'\xa0','\xf3'},
+    {'\xa0','\xcf'},{'\xa0','\xc9'},{'\xa1','\xd2'},{'\xa0','\xe9'},{'\xa0','\xe4'},
+    {'\xa0','\xc4'},{'\xa0','\xf4'},{'\xa0','\xca'},{'\x79','\x20'},{'\xa0','\xec'},
+    {'\xa0','\xed'},{'\x00','\x00'},{'\xa0','\xb0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa0','\xb1'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xd1'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xb2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9b','\xd5'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xb3'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xe5'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xb4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xfe'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xd0'},{'\x00','\x00'},{'\xa0','\xd2'},
+    {'\x00','\x00'},{'\xa0','\xd3'},{'\x00','\x00'},{'\xa0','\xd4'},{'\x00','\x00'},
+    {'\xa0','\xb5'},{'\x00','\x00'},{'\xa0','\xc5'},{'\x00','\x00'},{'\xa0','\xd5'},
+    {'\x00','\x00'},{'\xa0','\xe5'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xcb'},{'\x9b','\xe6'},
+    {'\x00','\x00'},{'\x9b','\xcc'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9b','\xcf'},{'\x9b','\xd0'},{'\x9b','\xc8'},{'\x9b','\xd1'},
+    {'\x9b','\xce'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xc7'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xe0'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd7'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xe1'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xe2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9b','\xcd'},{'\x00','\x00'},{'\x9b','\xca'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xda'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9b','\xdc'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xdb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc6','\xd9'},{'\xa3','\xbe'},{'\x00','\x00'},{'\xa3','\xbc'},{'\xa3','\xbd'},
+    {'\xa3','\xbf'},{'\x00','\x00'},{'\xa1','\xc5'},{'\x00','\x00'},{'\x9b','\xe9'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa3','\xbb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa3','\x44'},{'\xa3','\x45'},
+    {'\xa3','\x46'},{'\xa3','\x47'},{'\xa3','\x48'},{'\xa3','\x49'},{'\xa3','\x4a'},
+    {'\xa3','\x4b'},{'\xa3','\x4c'},{'\xa3','\x4d'},{'\xa3','\x4e'},{'\xa3','\x4f'},
+    {'\xa3','\x50'},{'\xa3','\x51'},{'\xa3','\x52'},{'\xa3','\x53'},{'\xa3','\x54'},
+    {'\x00','\x00'},{'\xa3','\x55'},{'\xa3','\x56'},{'\xa3','\x57'},{'\xa3','\x58'},
+    {'\xa3','\x59'},{'\xa3','\x5a'},{'\xa3','\x5b'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa3','\x5c'},{'\xa3','\x5d'},{'\xa3','\x5e'},{'\xa3','\x5f'},{'\xa3','\x60'},
+    {'\xa3','\x61'},{'\xa3','\x62'},{'\xa3','\x63'},{'\xa3','\x64'},{'\xa3','\x65'},
+    {'\xa3','\x66'},{'\xa3','\x67'},{'\xa3','\x68'},{'\xa3','\x69'},{'\xa3','\x6a'},
+    {'\xa3','\x6b'},{'\xa3','\x6c'},{'\x00','\x00'},{'\xa3','\x6d'},{'\xa3','\x6e'},
+    {'\xa3','\x6f'},{'\xa3','\x70'},{'\xa3','\x71'},{'\xa3','\x72'},{'\xa3','\x73'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc7','\xf9'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc7','\xf3'},{'\xc7','\xf4'},{'\xc7','\xf5'},{'\xc7','\xf6'},{'\xc7','\xf7'},
+    {'\xc7','\xf8'},{'\xc7','\xfa'},{'\xc7','\xfb'},{'\xc7','\xfc'},{'\xc7','\xfd'},
+    {'\xc7','\xfe'},{'\xc8','\x40'},{'\xc8','\x41'},{'\xc8','\x42'},{'\xc8','\x43'},
+    {'\xc8','\x44'},{'\xc8','\x45'},{'\xc8','\x46'},{'\xc8','\x47'},{'\xc8','\x48'},
+    {'\xc8','\x49'},{'\xc8','\x4a'},{'\xc8','\x4b'},{'\xc8','\x4c'},{'\xc8','\x4d'},
+    {'\xc8','\x4e'},{'\xc8','\x4f'},{'\xc8','\x50'},{'\xc8','\x51'},{'\xc8','\x52'},
+    {'\xc8','\x53'},{'\xc8','\x54'},{'\xc8','\x55'},{'\xc8','\x56'},{'\xc8','\x57'},
+    {'\xc8','\x58'},{'\xc8','\x59'},{'\xc8','\x5a'},{'\xc8','\x5c'},{'\xc8','\x5d'},
+    {'\xc8','\x5e'},{'\xc8','\x5f'},{'\xc8','\x60'},{'\xc8','\x61'},{'\xc8','\x62'},
+    {'\xc8','\x63'},{'\xc8','\x64'},{'\xc8','\x65'},{'\xc8','\x66'},{'\xc8','\x67'},
+    {'\xc8','\x68'},{'\xc8','\x69'},{'\xc8','\x6a'},{'\xc8','\x6b'},{'\xc8','\x6c'},
+    {'\xc8','\x6d'},{'\xc8','\x6e'},{'\xc8','\x6f'},{'\xc8','\x70'},{'\xc8','\x71'},
+    {'\xc8','\x72'},{'\xc8','\x73'},{'\xc8','\x74'},{'\xc8','\x75'},{'\x00','\x00'},
+    {'\xc8','\x5b'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd6'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9b','\xd4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xdb'},{'\xa0','\xeb'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9f','\xec'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\x56'},{'\xa1','\x58'},{'\xa2','\x77'},{'\xa1','\xfc'},
+    {'\x00','\x00'},{'\xa1','\xa5'},{'\xa1','\xa6'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xa7'},{'\xa1','\xa8'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xcf'},
+    {'\x91','\xde'},{'\xa1','\x45'},{'\x00','\x00'},{'\xa3','\xbb'},{'\xa1','\x4c'},
+    {'\xa1','\x4b'},{'\xa1','\x45'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfe','\xe2'},{'\x00','\x00'},{'\xa1','\xac'},{'\xa1','\xb2'},{'\x00','\x00'},
+    {'\xa1','\xab'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xb0'},{'\x91','\xf7'},{'\x00','\x00'},{'\xa1','\xc3'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa3','\xe1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa2','\x4a'},{'\x00','\x00'},{'\xa1','\xc1'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x4b'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9d','\xcf'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xe2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9d','\xc9'},{'\x97','\xfc'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x96','\x52'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xc8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfe','\xb1'},{'\xfe','\xb2'},{'\xfe','\xb5'},{'\xfe','\xb6'},
+    {'\xfe','\xb7'},{'\xfe','\xb8'},{'\xfe','\xb9'},{'\xfe','\xba'},{'\xfe','\xc1'},
+    {'\xfe','\xc2'},{'\xfe','\xc3'},{'\xfe','\xc4'},{'\x00','\x00'},{'\xa2','\xb9'},
+    {'\xa2','\xba'},{'\xa2','\xbb'},{'\xa2','\xbc'},{'\xa2','\xbd'},{'\xa2','\xbe'},
+    {'\xa2','\xbf'},{'\xa2','\xc0'},{'\xa2','\xc1'},{'\xa2','\xc2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc6','\xb5'},{'\xc6','\xb6'},{'\xc6','\xb7'},{'\xc6','\xb8'},{'\xc6','\xb9'},
+    {'\xc6','\xba'},{'\xc6','\xbb'},{'\xc6','\xbc'},{'\xc6','\xbd'},{'\xc6','\xbe'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xf6'},{'\xa1','\xf4'},{'\xa1','\xf7'},
+    {'\xa1','\xf5'},{'\x91','\xfb'},{'\x91','\xf6'},{'\xa1','\xf8'},{'\xa1','\xf9'},
+    {'\xa1','\xfb'},{'\xa1','\xfa'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x91','\xfa'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9d','\xfd'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc8','\x77'},{'\xc8','\x78'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x96','\x53'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x99','\x65'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x4a'},{'\xc8','\x76'},
+    {'\x9d','\x49'},{'\x9d','\x4c'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\xf9'},
+    {'\x00','\x00'},{'\xa0','\x79'},{'\x98','\xf9'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xbe'},{'\x91','\x6b'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x91','\x5f'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa3','\x53'},
+    {'\x00','\x00'},{'\xa3','\x55'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa2','\x41'},{'\xa2','\x42'},{'\x00','\x00'},{'\xa2','\x58'},{'\x00','\x00'},
+    {'\xa1','\xd4'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xdb'},
+    {'\xa1','\xe8'},{'\xa1','\xe7'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xfd'},
+    {'\x00','\x00'},{'\xa1','\xfc'},{'\x00','\x00'},{'\xa3','\x4e'},{'\xa2','\xe4'},
+    {'\xa1','\xe4'},{'\xa1','\xe5'},{'\xa1','\xec'},{'\x9f','\x4c'},{'\x00','\x00'},
+    {'\xa1','\xed'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xef'},{'\xa1','\xee'},{'\xa1','\x47'},{'\x9f','\x46'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xdc'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xda'},{'\xa1','\xdd'},{'\x00','\x00'},{'\xa1','\xdd'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xd8'},{'\xa1','\xd9'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9a','\xe0'},
+    {'\x9a','\xa6'},{'\x00','\x00'},{'\x00','\x00'},{'\x9c','\x72'},{'\x9c','\xaa'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xf2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xf3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xe6'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xe9'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x91','\xfc'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\x5b'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfe','\xd9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa3','\xc0'},{'\xa3','\xc1'},{'\xa3','\xc2'},{'\xa3','\xc3'},
+    {'\xa3','\xc4'},{'\xa3','\xc5'},{'\xa3','\xc6'},{'\xa3','\xc7'},{'\xa3','\xc8'},
+    {'\xa3','\xc9'},{'\xa3','\xca'},{'\xa3','\xcb'},{'\xa3','\xcc'},{'\xa3','\xcd'},
+    {'\xa3','\xce'},{'\xa3','\xcf'},{'\xa3','\xd0'},{'\xa3','\xd1'},{'\xa3','\xd2'},
+    {'\xa3','\xd3'},{'\xa3','\xd4'},{'\xa3','\xd5'},{'\xa3','\xd6'},{'\xa3','\xd7'},
+    {'\xa3','\xd8'},{'\xa3','\xd9'},{'\xa3','\xda'},{'\xa3','\xdb'},{'\xa3','\xdc'},
+    {'\xa3','\xdd'},{'\xa3','\xde'},{'\xa3','\xdf'},{'\x00','\x00'},{'\xa3','\xe0'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xa1'},{'\xc6','\xa2'},{'\xc6','\xa3'},
+    {'\xc6','\xa4'},{'\xc6','\xa5'},{'\xc6','\xa6'},{'\xc6','\xa7'},{'\xc6','\xa8'},
+    {'\xc6','\xa9'},{'\xc6','\xaa'},{'\x97','\x4b'},{'\x97','\x4c'},{'\x97','\x4d'},
+    {'\x97','\x4e'},{'\x97','\x4f'},{'\x97','\x50'},{'\x97','\x51'},{'\x97','\x52'},
+    {'\x97','\x53'},{'\x97','\x54'},{'\xc6','\xab'},{'\xc6','\xac'},{'\xc6','\xad'},
+    {'\xc6','\xae'},{'\xc6','\xaf'},{'\xc6','\xb0'},{'\xc6','\xb1'},{'\xc6','\xb2'},
+    {'\xc6','\xb3'},{'\xc6','\xb4'},{'\x99','\x4b'},{'\x99','\x4c'},{'\x99','\x4d'},
+    {'\x99','\x4e'},{'\x99','\x4f'},{'\x99','\x50'},{'\x99','\x51'},{'\x99','\x52'},
+    {'\x99','\x53'},{'\x99','\x54'},{'\x9a','\x41'},{'\x9a','\x42'},{'\x9a','\x43'},
+    {'\x9a','\x44'},{'\x9a','\x45'},{'\x9a','\x46'},{'\x9a','\x47'},{'\x9a','\x48'},
+    {'\x9a','\x49'},{'\x9a','\x4a'},{'\x9a','\x4b'},{'\x9a','\x4c'},{'\x9a','\x4d'},
+    {'\x9a','\x4e'},{'\x9a','\x4f'},{'\x9a','\x50'},{'\x9a','\x51'},{'\x9a','\x52'},
+    {'\x9a','\x53'},{'\x9a','\x54'},{'\x99','\xe1'},{'\x99','\xe2'},{'\x99','\xe3'},
+    {'\x99','\xe4'},{'\x99','\xe5'},{'\x99','\xe6'},{'\x99','\xe7'},{'\x99','\xe8'},
+    {'\x99','\xe9'},{'\x99','\xea'},{'\x99','\xeb'},{'\x99','\xec'},{'\x99','\xed'},
+    {'\x99','\xee'},{'\x99','\xef'},{'\x99','\xf0'},{'\x99','\xf1'},{'\x99','\xf2'},
+    {'\x99','\xf3'},{'\x99','\xf4'},{'\x99','\xf5'},{'\x99','\xf6'},{'\x99','\xf7'},
+    {'\x99','\xf8'},{'\x99','\xf9'},{'\x99','\xfa'},{'\x97','\xc7'},{'\x97','\xc8'},
+    {'\x97','\xc9'},{'\x97','\xca'},{'\x97','\xcb'},{'\x97','\xcc'},{'\x97','\xcd'},
+    {'\x97','\xce'},{'\x97','\xcf'},{'\x97','\xd0'},{'\x97','\xd1'},{'\x97','\xd2'},
+    {'\x97','\xd3'},{'\x97','\xd4'},{'\x97','\xd5'},{'\x97','\xd6'},{'\x97','\xd7'},
+    {'\x97','\xd8'},{'\x97','\xd9'},{'\x97','\xda'},{'\x97','\xdb'},{'\x97','\xdc'},
+    {'\x97','\xdd'},{'\x97','\xde'},{'\x97','\xdf'},{'\x97','\xe0'},{'\x97','\xe1'},
+    {'\x97','\xe2'},{'\x97','\xe3'},{'\x97','\xe4'},{'\x97','\xe5'},{'\x97','\xe6'},
+    {'\x97','\xe7'},{'\x97','\xe8'},{'\x97','\xe9'},{'\x97','\xea'},{'\x97','\xeb'},
+    {'\x97','\xec'},{'\x97','\xed'},{'\x97','\xee'},{'\x97','\xef'},{'\x97','\xf0'},
+    {'\x97','\xf1'},{'\x97','\xf2'},{'\x97','\xf3'},{'\x97','\xf4'},{'\x97','\xf5'},
+    {'\x97','\xf6'},{'\x97','\xf7'},{'\x97','\xf8'},{'\x97','\xf9'},{'\x97','\xfa'},
+    {'\x97','\x40'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x77'},{'\x9d','\x7d'},{'\xa2','\x78'},
+    {'\x9d','\x7e'},{'\xa1','\x4c'},{'\xa1','\x4c'},{'\xa1','\x4a'},{'\xa1','\x4a'},
+    {'\xa1','\x4b'},{'\xa1','\x4b'},{'\xa1','\x55'},{'\xa1','\x55'},{'\xa2','\x7a'},
+    {'\xa2','\x7a'},{'\xa2','\x7a'},{'\xa2','\x7a'},{'\xa2','\x7b'},{'\xa2','\x7b'},
+    {'\xa2','\x7b'},{'\xa2','\x7b'},{'\xa2','\x7c'},{'\xa2','\x7c'},{'\xa2','\x7c'},
+    {'\xa2','\x7c'},{'\xa2','\x7d'},{'\xa2','\x7d'},{'\xa2','\x7d'},{'\xa2','\x7d'},
+    {'\xa2','\x75'},{'\xa2','\x75'},{'\xa2','\x75'},{'\xa2','\x75'},{'\xa2','\x75'},
+    {'\xa2','\x75'},{'\xa2','\x75'},{'\xa2','\x75'},{'\xa2','\x74'},{'\xa2','\x74'},
+    {'\xa2','\x74'},{'\xa2','\x74'},{'\xa2','\x74'},{'\xa2','\x74'},{'\xa2','\x74'},
+    {'\xa2','\x74'},{'\xa2','\x73'},{'\xa2','\x73'},{'\xa2','\x73'},{'\xa2','\x73'},
+    {'\xa2','\x73'},{'\xa2','\x73'},{'\xa2','\x73'},{'\xa2','\x73'},{'\xa2','\x72'},
+    {'\xa2','\x72'},{'\xa2','\x72'},{'\xa2','\x72'},{'\xa2','\x72'},{'\xa2','\x72'},
+    {'\xa2','\x72'},{'\xa2','\x72'},{'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},
+    {'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},
+    {'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},
+    {'\xa2','\x71'},{'\xa2','\x71'},{'\xa2','\x71'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x91','\xf0'},{'\x00','\x00'},{'\xf9','\xf9'},{'\xf9','\xf8'},{'\xf9','\xe6'},
+    {'\xf9','\xef'},{'\xf9','\xdd'},{'\xf9','\xe8'},{'\xf9','\xf1'},{'\xf9','\xdf'},
+    {'\xf9','\xec'},{'\xf9','\xf5'},{'\xf9','\xe3'},{'\xf9','\xee'},{'\xf9','\xf7'},
+    {'\xf9','\xe5'},{'\xf9','\xe9'},{'\xf9','\xf2'},{'\xf9','\xe0'},{'\xf9','\xeb'},
+    {'\xf9','\xf4'},{'\xf9','\xe2'},{'\xf9','\xe7'},{'\xf9','\xf0'},{'\xf9','\xde'},
+    {'\xf9','\xed'},{'\xf9','\xf6'},{'\xf9','\xe4'},{'\xf9','\xea'},{'\xf9','\xf3'},
+    {'\xf9','\xe1'},{'\xa2','\x7e'},{'\xa2','\xa1'},{'\xa2','\xa3'},{'\xa2','\xa2'},
+    {'\xa2','\xac'},{'\xa2','\xad'},{'\xa2','\xae'},{'\xa1','\x5a'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa2','\x62'},{'\xa2','\x63'},{'\xa2','\x64'},{'\xa2','\x65'},
+    {'\xa2','\x66'},{'\xa2','\x67'},{'\xa2','\x68'},{'\xa2','\x69'},{'\xa2','\x70'},
+    {'\xa2','\x6f'},{'\xa2','\x6e'},{'\xa2','\x6d'},{'\xa2','\x6c'},{'\xa2','\x6b'},
+    {'\xa2','\x6a'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xf9','\xfe'},
+    {'\xa2','\x76'},{'\xa2','\x79'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xbd'},{'\xa1','\xbc'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xb6'},{'\xa1','\xb5'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\xf4'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xbf'},{'\xa1','\xbe'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\xf5'},{'\x00','\x00'},
+    {'\xa1','\xbb'},{'\xa1','\xba'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa1','\xb3'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xb7'},{'\xa1','\xb4'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\xf1'},{'\x91','\xf2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa2','\xa8'},{'\xa2','\xa9'},
+    {'\xa2','\xab'},{'\xa2','\xaa'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xb3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xba'},
+    {'\x9d','\xbc'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xb9'},{'\xa1','\xb8'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xf3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x40'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9d','\xed'},{'\x9c','\xd1'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9d','\x4f'},{'\x9d','\x4e'},{'\x00','\x00'},{'\x9d','\x4d'},{'\x9d','\x50'},
+    {'\x9d','\xd5'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9f','\x55'},{'\x9f','\x56'},{'\x9f','\x5d'},{'\x9f','\x5b'},{'\x9f','\x58'},
+    {'\x9f','\x59'},{'\x9f','\x5a'},{'\x9f','\x5c'},{'\x9f','\x57'},{'\x00','\x00'},
+    {'\x9d','\x5e'},{'\x9d','\x5d'},{'\x98','\xfc'},{'\x9d','\xb8'},{'\x9d','\x57'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xf0'},{'\xa1','\xf2'},{'\xa1','\xf1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xd8'},
+    {'\x9d','\xdd'},{'\x9d','\xdb'},{'\x9d','\xda'},{'\x9d','\xd7'},{'\x9d','\xde'},
+    {'\x9d','\xdc'},{'\x9d','\xd9'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x66'},
+    {'\x00','\x00'},{'\x9d','\x65'},{'\xa2','\xea'},{'\x00','\x00'},{'\xa1','\xad'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9d','\x6c'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xc0'},{'\x9d','\x6b'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x55'},{'\x00','\x00'},
+    {'\x9d','\x54'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x5c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9d','\x5b'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc6','\xe6'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\x77'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x98','\x41'},{'\x98','\x42'},{'\x98','\x43'},
+    {'\x98','\x44'},{'\x98','\x45'},{'\x98','\x46'},{'\x98','\x47'},{'\x98','\x48'},
+    {'\x98','\x49'},{'\x98','\x4a'},{'\xc6','\xa1'},{'\xc6','\xa2'},{'\xc6','\xa3'},
+    {'\xc6','\xa4'},{'\xc6','\xa5'},{'\xc6','\xa6'},{'\xc6','\xa7'},{'\xc6','\xa8'},
+    {'\xc6','\xa9'},{'\xc6','\xaa'},{'\x98','\x41'},{'\x98','\x42'},{'\x98','\x43'},
+    {'\x98','\x44'},{'\x98','\x45'},{'\x98','\x46'},{'\x98','\x47'},{'\x98','\x48'},
+    {'\x98','\x49'},{'\x98','\x4a'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\xed'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9c','\xce'},{'\x00','\x00'},{'\x00','\x00'},{'\x9c','\xd5'},
+    {'\x00','\x00'},{'\x9c','\xd4'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9c','\xdb'},{'\x00','\x00'},{'\x91','\xdb'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x91','\xc9'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9c','\xf7'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xbf'},
+    {'\xc6','\xc0'},{'\x00','\x00'},{'\xc6','\xc1'},{'\x00','\x00'},{'\xc6','\xc2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xc3'},
+    {'\xc6','\xc4'},{'\xc6','\xc5'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc6','\xc6'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xc7'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xc8'},{'\x00','\x00'},{'\xc6','\xc9'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc6','\xca'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc6','\xcb'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xcc'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xcd'},{'\xc6','\xce'},
+    {'\xc6','\xcf'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd0'},
+    {'\xc6','\xd1'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc6','\xd4'},{'\xc6','\xd5'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd6'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd7'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa1','\x40'},{'\xa1','\x42'},
+    {'\xa1','\x43'},{'\xa1','\xb2'},{'\x00','\x00'},{'\xc6','\xe0'},{'\xc6','\xe1'},
+    {'\xc6','\xe2'},{'\xa1','\x71'},{'\xa1','\x72'},{'\xa1','\x6d'},{'\xa1','\x6e'},
+    {'\xa1','\x75'},{'\xa1','\x76'},{'\xa1','\x79'},{'\xa1','\x7a'},{'\xa1','\x69'},
+    {'\xa1','\x6a'},{'\xa2','\x45'},{'\x96','\x5d'},{'\xa1','\x65'},{'\xa1','\x66'},
+    {'\x9d','\x51'},{'\x9d','\x52'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xe3'},{'\xa1','\xa9'},{'\xa1','\xaa'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa2','\xc3'},{'\xa2','\xc4'},{'\xa2','\xc5'},{'\xa2','\xc6'},
+    {'\xa2','\xc7'},{'\xa2','\xc8'},{'\xa2','\xc9'},{'\xa2','\xca'},{'\xa2','\xcb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\xca'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa2','\xcc'},
+    {'\xa2','\xcd'},{'\xa2','\xce'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xe7'},{'\xc6','\xe8'},
+    {'\xc6','\xe9'},{'\xc6','\xea'},{'\xc6','\xeb'},{'\xc6','\xec'},{'\xc6','\xed'},
+    {'\xc6','\xee'},{'\xc6','\xef'},{'\xc6','\xf0'},{'\xc6','\xf1'},{'\xc6','\xf2'},
+    {'\xc6','\xf3'},{'\xc6','\xf4'},{'\xc6','\xf5'},{'\xc6','\xf6'},{'\xc6','\xf7'},
+    {'\xc6','\xf8'},{'\xc6','\xf9'},{'\xc6','\xfa'},{'\xc6','\xfb'},{'\xc6','\xfc'},
+    {'\xc6','\xfd'},{'\xc6','\xfe'},{'\xc7','\x40'},{'\xc7','\x41'},{'\xc7','\x42'},
+    {'\xc7','\x43'},{'\xc7','\x44'},{'\xc7','\x45'},{'\xc7','\x46'},{'\xc7','\x47'},
+    {'\xc7','\x48'},{'\xc7','\x49'},{'\xc7','\x4a'},{'\xc7','\x4b'},{'\xc7','\x4c'},
+    {'\xc7','\x4d'},{'\xc7','\x4e'},{'\xc7','\x4f'},{'\xc7','\x50'},{'\xc7','\x51'},
+    {'\xc7','\x52'},{'\xc7','\x53'},{'\xc7','\x54'},{'\xc7','\x55'},{'\xc7','\x56'},
+    {'\xc7','\x57'},{'\xc7','\x58'},{'\xc7','\x59'},{'\xc7','\x5a'},{'\xc7','\x5b'},
+    {'\xc7','\x5c'},{'\xc7','\x5d'},{'\xc7','\x5e'},{'\xc7','\x5f'},{'\xc7','\x60'},
+    {'\xc7','\x61'},{'\xc7','\x62'},{'\xc7','\x63'},{'\xc7','\x64'},{'\xc7','\x65'},
+    {'\xc7','\x66'},{'\xc7','\x67'},{'\xc7','\x68'},{'\xc7','\x69'},{'\xc7','\x6a'},
+    {'\xc7','\x6b'},{'\xc7','\x6c'},{'\xc7','\x6d'},{'\xc7','\x6e'},{'\xc7','\x6f'},
+    {'\xc7','\x70'},{'\xc7','\x71'},{'\xc7','\x72'},{'\xc7','\x73'},{'\xc7','\x74'},
+    {'\xc7','\x75'},{'\xc7','\x76'},{'\xc7','\x77'},{'\xc7','\x78'},{'\xc7','\x79'},
+    {'\xc7','\x7a'},{'\xc8','\xb3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc8','\xb1'},{'\xc8','\xb2'},
+    {'\xc6','\xdc'},{'\xc6','\xdd'},{'\x00','\x00'},{'\x00','\x00'},{'\xc7','\x7b'},
+    {'\xc7','\x7c'},{'\xc7','\x7d'},{'\xc7','\x7e'},{'\xc7','\xa1'},{'\xc7','\xa2'},
+    {'\xc7','\xa3'},{'\xc7','\xa4'},{'\xc7','\xa5'},{'\xc7','\xa6'},{'\xc7','\xa7'},
+    {'\xc7','\xa8'},{'\xc7','\xa9'},{'\xc7','\xaa'},{'\xc7','\xab'},{'\xc7','\xac'},
+    {'\xc7','\xad'},{'\xc7','\xae'},{'\xc7','\xaf'},{'\xc7','\xb0'},{'\xc7','\xb1'},
+    {'\xc7','\xb2'},{'\xc7','\xb3'},{'\xc7','\xb4'},{'\xc7','\xb5'},{'\xc7','\xb6'},
+    {'\xc7','\xb7'},{'\xc7','\xb8'},{'\xc7','\xb9'},{'\xc7','\xba'},{'\xc7','\xbb'},
+    {'\xc7','\xbc'},{'\xc7','\xbd'},{'\xc7','\xbe'},{'\xc7','\xbf'},{'\xc7','\xc0'},
+    {'\xc7','\xc1'},{'\xc7','\xc2'},{'\xc7','\xc3'},{'\xc7','\xc4'},{'\xc7','\xc5'},
+    {'\xc7','\xc6'},{'\xc7','\xc7'},{'\xc7','\xc8'},{'\xc7','\xc9'},{'\xc7','\xca'},
+    {'\xc7','\xcb'},{'\xc7','\xcc'},{'\xc7','\xcd'},{'\xc7','\xce'},{'\xc7','\xcf'},
+    {'\xc7','\xd0'},{'\xc7','\xd1'},{'\xc7','\xd2'},{'\xc7','\xd3'},{'\xc7','\xd4'},
+    {'\xc7','\xd5'},{'\xc7','\xd6'},{'\xc7','\xd7'},{'\xc7','\xd8'},{'\xc7','\xd9'},
+    {'\xc7','\xda'},{'\xc7','\xdb'},{'\xc7','\xdc'},{'\xc7','\xdd'},{'\xc7','\xde'},
+    {'\xc7','\xdf'},{'\xc7','\xe0'},{'\xc7','\xe1'},{'\xc7','\xe2'},{'\xc7','\xe3'},
+    {'\xc7','\xe4'},{'\xc7','\xe5'},{'\xc7','\xe6'},{'\xc7','\xe7'},{'\xc7','\xe8'},
+    {'\xc7','\xe9'},{'\xc7','\xea'},{'\xc7','\xeb'},{'\xc7','\xec'},{'\xc7','\xed'},
+    {'\xc7','\xee'},{'\xc7','\xef'},{'\xc7','\xf0'},{'\xc7','\xf1'},{'\xc7','\xf2'},
+    {'\xc8','\xb4'},{'\xc8','\xb5'},{'\xc8','\xb6'},{'\xc8','\xb7'},{'\xc8','\xb8'},
+    {'\xc6','\xe3'},{'\xc6','\xda'},{'\xc6','\xdb'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa3','\x74'},
+    {'\xa3','\x75'},{'\xa3','\x76'},{'\xa3','\x77'},{'\xa3','\x78'},{'\xa3','\x79'},
+    {'\xa3','\x7a'},{'\xa3','\x7b'},{'\xa3','\x7c'},{'\xa3','\x7d'},{'\xa3','\x7e'},
+    {'\xa3','\xa1'},{'\xa3','\xa2'},{'\xa3','\xa3'},{'\xa3','\xa4'},{'\xa3','\xa5'},
+    {'\xa3','\xa6'},{'\xa3','\xa7'},{'\xa3','\xa8'},{'\xa3','\xa9'},{'\xa3','\xaa'},
+    {'\xa3','\xab'},{'\xa3','\xac'},{'\xa3','\xad'},{'\xa3','\xae'},{'\xa3','\xaf'},
+    {'\xa3','\xb0'},{'\xa3','\xb1'},{'\xa3','\xb2'},{'\xa3','\xb3'},{'\xa3','\xb4'},
+    {'\xa3','\xb5'},{'\xa3','\xb6'},{'\xa3','\xb7'},{'\xa3','\xb8'},{'\xa3','\xb9'},
+    {'\xa3','\xba'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa4','\x40'},{'\xa4','\x47'},{'\xa4','\x54'},{'\xa5','\x7c'},{'\xa4','\x57'},
+    {'\xa4','\xa4'},{'\xa4','\x55'},{'\xa5','\xd2'},{'\xa4','\x41'},{'\xa4','\xfe'},
+    {'\xa4','\x42'},{'\xa4','\xd1'},{'\xa6','\x61'},{'\xa4','\x48'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc8','\x79'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9c','\x41'},{'\x9c','\x42'},{'\x9c','\x43'},
+    {'\x9c','\x44'},{'\x9c','\x45'},{'\x9c','\x46'},{'\x9c','\x47'},{'\x9c','\x48'},
+    {'\x9c','\x49'},{'\x9c','\x4a'},{'\xa4','\xeb'},{'\xa4','\xf5'},{'\xa4','\xf4'},
+    {'\xa4','\xec'},{'\xaa','\xf7'},{'\xa4','\x67'},{'\xa4','\xe9'},{'\x99','\xfd'},
+    {'\x99','\xfc'},{'\xaa','\xc0'},{'\xa6','\x57'},{'\xaf','\x53'},{'\xb0','\x5d'},
+    {'\xaf','\xac'},{'\xb3','\xd2'},{'\xa5','\x4e'},{'\xa9','\x49'},{'\xbe','\xc7'},
+    {'\xba','\xca'},{'\xa5','\xf8'},{'\xb8','\xea'},{'\xa8','\xf3'},{'\xb2','\xbd'},
+    {'\xa5','\xf0'},{'\xa6','\xdb'},{'\xa6','\xdc'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa4','\x40'},{'\xa4','\x47'},
+    {'\xa4','\x54'},{'\xa5','\x7c'},{'\xa4','\xad'},{'\xa4','\xbb'},{'\xa4','\x43'},
+    {'\xa4','\x4b'},{'\xa4','\x45'},{'\xa4','\x51'},{'\xa4','\xeb'},{'\xa4','\xf5'},
+    {'\xa4','\xf4'},{'\xa4','\xec'},{'\xaa','\xf7'},{'\xa4','\x67'},{'\xa4','\xe9'},
+    {'\xae','\xe8'},{'\xa6','\xb3'},{'\xaa','\xc0'},{'\xa6','\x57'},{'\xaf','\x53'},
+    {'\xb0','\x5d'},{'\xaf','\xac'},{'\xb3','\xd2'},{'\xaf','\xb5'},{'\xa8','\x6b'},
+    {'\xa4','\x6b'},{'\xbe','\x41'},{'\xc0','\x75'},{'\xa6','\x4c'},{'\xaa','\x60'},
+    {'\xb6','\xb5'},{'\xa5','\xf0'},{'\xbc','\x67'},{'\xa1','\xc0'},{'\xa4','\x57'},
+    {'\xa4','\xa4'},{'\xa4','\x55'},{'\xa5','\xaa'},{'\xa5','\x6b'},{'\xc2','\xe5'},
+    {'\xa9','\x76'},{'\xbe','\xc7'},{'\xba','\xca'},{'\xa5','\xf8'},{'\xb8','\xea'},
+    {'\xa8','\xf3'},{'\xa9','\x5d'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x48','\x67'},
+    {'\x00','\x00'},{'\x65','\x56'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x64','\x61'},{'\x41','\x55'},{'\x00','\x00'},{'\x6f','\x56'},{'\x70','\x63'},
+    {'\x64','\x6d'},{'\x00','\x00'},{'\x00','\x00'},{'\x49','\x55'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x70','\x41'},
+    {'\x6e','\x41'},{'\x00','\x00'},{'\x6d','\x41'},{'\x6b','\x41'},{'\x4b','\x42'},
+    {'\x4d','\x42'},{'\x47','\x42'},{'\x00','\x00'},{'\x00','\x00'},{'\x70','\x46'},
+    {'\x6e','\x46'},{'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x55'},{'\xa2','\x56'},
+    {'\x48','\x7a'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x66','\x6d'},
+    {'\x6e','\x6d'},{'\x00','\x00'},{'\xa2','\x50'},{'\xa2','\x51'},{'\xa2','\x52'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x54'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9d','\xe7'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x50','\x61'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x70','\x73'},{'\x6e','\x73'},{'\x00','\x00'},
+    {'\x6d','\x73'},{'\x70','\x56'},{'\x6e','\x56'},{'\x00','\x00'},{'\x6d','\x56'},
+    {'\x6b','\x56'},{'\x4d','\x56'},{'\x70','\x57'},{'\x6e','\x57'},{'\x00','\x00'},
+    {'\x6d','\x57'},{'\x6b','\x57'},{'\x4d','\x57'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9d','\xe3'},{'\x42','\x71'},{'\xa2','\x57'},{'\x63','\x64'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x64','\x42'},{'\x47','\x79'},{'\x68','\x61'},{'\x48','\x50'},
+    {'\x69','\x6e'},{'\x4b','\x4b'},{'\xa2','\x53'},{'\x6b','\x74'},{'\x6c','\x6d'},
+    {'\xa1','\xeb'},{'\xa1','\xea'},{'\x6c','\x78'},{'\x6d','\x62'},{'\xa2','\x4f'},
+    {'\x00','\x00'},{'\x50','\x48'},{'\x9d','\xe4'},{'\x00','\x00'},{'\x50','\x52'},
+    {'\x73','\x72'},{'\x53','\x76'},{'\x57','\x62'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x91','\xe0'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\xa2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfb','\x44'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x95','\xb8'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\x48'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\x4c'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfb','\xdf'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfb','\xe5'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfb','\x6f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x95','\x42'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x7d'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x67'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x95','\x5e'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x95','\xde'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x95','\xc7'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfc','\x61'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x95','\xc9'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfc','\x7c'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfc','\xa8'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x71'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfc','\xc2'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x4d'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x96','\xad'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9c','\xd3'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfd','\x5e'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x4a'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfd','\x67'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfb','\xb0'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfb','\x7d'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfd','\xe3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfd','\xf1'},{'\x00','\x00'},{'\x00','\x00'},{'\xfd','\xef'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfd','\xf2'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfb','\x45'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa4','\x40'},{'\xa4','\x42'},
+    {'\x00','\x00'},{'\xa4','\x43'},{'\x98','\xa7'},{'\x00','\x00'},{'\x91','\xd7'},
+    {'\xc9','\x45'},{'\xa4','\x56'},{'\xa4','\x54'},{'\xa4','\x57'},{'\xa4','\x55'},
+    {'\xc9','\x46'},{'\xa4','\xa3'},{'\xc9','\x4f'},{'\xc9','\x4d'},{'\xa4','\xa2'},
+    {'\xa4','\xa1'},{'\x00','\x00'},{'\x83','\xfd'},{'\xa5','\x42'},{'\xa5','\x41'},
+    {'\xa5','\x40'},{'\x81','\x40'},{'\xa5','\x43'},{'\xa4','\xfe'},{'\x85','\xd2'},
+    {'\x8a','\xbd'},{'\x83','\x5b'},{'\x85','\x46'},{'\xa5','\xe0'},{'\xa5','\xe1'},
+    {'\x00','\x00'},{'\x93','\xe5'},{'\x81','\x41'},{'\x00','\x00'},{'\x83','\x55'},
+    {'\x8b','\xf2'},{'\xa8','\xc3'},{'\x84','\xca'},{'\x9c','\xc9'},{'\x00','\x00'},
+    {'\x83','\xaa'},{'\xa4','\x58'},{'\x81','\x42'},{'\xa4','\xa4'},{'\xc9','\x50'},
+    {'\x98','\xa8'},{'\xa4','\xa5'},{'\xc9','\x63'},{'\xa6','\xea'},{'\xcb','\xb1'},
+    {'\x8a','\x5a'},{'\x00','\x00'},{'\xc6','\xbf'},{'\x91','\xcc'},{'\xa4','\x59'},
+    {'\xa4','\xa6'},{'\x83','\x6f'},{'\xa5','\x44'},{'\xc9','\x64'},{'\x8b','\xed'},
+    {'\x8a','\x5b'},{'\xc6','\xc0'},{'\x00','\x00'},{'\x00','\x00'},{'\xc9','\x40'},
+    {'\xa4','\x44'},{'\x94','\xf2'},{'\xa4','\x5b'},{'\x00','\x00'},{'\xc9','\x47'},
+    {'\xa4','\x5c'},{'\x85','\xf3'},{'\x00','\x00'},{'\xa4','\xa7'},{'\x83','\xbf'},
+    {'\xa5','\x45'},{'\xa5','\x47'},{'\xa5','\x46'},{'\x87','\xe4'},{'\x00','\x00'},
+    {'\xa5','\xe2'},{'\xa5','\xe3'},{'\x84','\xce'},{'\x81','\x43'},{'\xa8','\xc4'},
+    {'\x92','\xe9'},{'\xad','\xbc'},{'\xa4','\x41'},{'\x9c','\xdf'},{'\x9c','\xe8'},
+    {'\xc9','\x41'},{'\xa4','\x45'},{'\xa4','\x5e'},{'\xa4','\x5d'},{'\x84','\x74'},
+    {'\x85','\x70'},{'\x81','\x44'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x83','\xbc'},{'\x00','\x00'},{'\x00','\x00'},{'\xa5','\xe4'},{'\xfe','\x41'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x85','\x67'},{'\x85','\xaf'},{'\x00','\x00'},{'\xa8','\xc5'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\x61'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xb0','\xae'},
+    {'\xd4','\x4b'},{'\x93','\xfa'},{'\x98','\xa9'},{'\xb6','\xc3'},{'\xdc','\xb1'},
+    {'\xdc','\xb2'},{'\xc6','\xc1'},{'\xa4','\x46'},{'\x98','\xaa'},{'\xa4','\xa9'},
+    {'\x83','\x5c'},{'\x81','\x45'},{'\xa8','\xc6'},{'\xa4','\x47'},{'\xc9','\x48'},
+    {'\xa4','\x5f'},{'\x8a','\x5f'},{'\x00','\x00'},{'\xa4','\xaa'},{'\xa4','\xac'},
+    {'\xc9','\x51'},{'\xa4','\xad'},{'\xa4','\xab'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfe','\x62'},{'\xa5','\xe5'},{'\x83','\x52'},{'\xa8','\xc7'},{'\x92','\x40'},
+    {'\x00','\x00'},{'\xa8','\xc8'},{'\xab','\x45'},{'\xc6','\xc2'},{'\xa4','\x60'},
+    {'\xa4','\xae'},{'\x98','\xab'},{'\xa5','\xe6'},{'\xa5','\xe8'},{'\xa5','\xe7'},
+    {'\x84','\x64'},{'\xa6','\xeb'},{'\x83','\xc2'},{'\x00','\x00'},{'\xa8','\xc9'},
+    {'\xa8','\xca'},{'\xab','\x46'},{'\xab','\x47'},{'\x00','\x00'},{'\x81','\x46'},
+    {'\x00','\x00'},{'\x89','\x5d'},{'\xad','\xbd'},{'\x00','\x00'},{'\x8a','\x62'},
+    {'\xdc','\xb3'},{'\x98','\xac'},{'\x00','\x00'},{'\xf6','\xd6'},{'\xa4','\x48'},
+    {'\x9c','\xf4'},{'\x98','\xad'},{'\x00','\x00'},{'\x00','\x00'},{'\x87','\xa3'},
+    {'\xa4','\xb0'},{'\xa4','\xaf'},{'\xc9','\x52'},{'\xa4','\xb1'},{'\xa4','\xb7'},
+    {'\x85','\xb2'},{'\xa4','\xb2'},{'\xa4','\xb3'},{'\xc9','\x54'},{'\xc9','\x53'},
+    {'\xa4','\xb5'},{'\xa4','\xb6'},{'\x00','\x00'},{'\xa4','\xb4'},{'\x84','\x47'},
+    {'\x93','\xc2'},{'\x00','\x00'},{'\x83','\x54'},{'\x00','\x00'},{'\x83','\xac'},
+    {'\xa5','\x4a'},{'\xa5','\x4b'},{'\xa5','\x4c'},{'\xa5','\x4d'},{'\xa5','\x49'},
+    {'\xa5','\x50'},{'\xc9','\x6a'},{'\x00','\x00'},{'\xc9','\x66'},{'\xc9','\x69'},
+    {'\xa5','\x51'},{'\xa5','\x61'},{'\x00','\x00'},{'\xc9','\x68'},{'\x00','\x00'},
+    {'\xa5','\x4e'},{'\xa5','\x4f'},{'\xa5','\x48'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc9','\x65'},{'\xc9','\x67'},{'\x87','\xa4'},{'\x81','\x47'},{'\x83','\xa8'},
+    {'\x81','\x48'},{'\x92','\x54'},{'\x00','\x00'},{'\xa5','\xf5'},{'\xc9','\xb0'},
+    {'\xa5','\xf2'},{'\xa5','\xf6'},{'\xc9','\xba'},{'\xc9','\xae'},{'\xa5','\xf3'},
+    {'\xc9','\xb2'},{'\x98','\xae'},{'\x00','\x00'},{'\x00','\x00'},{'\xa5','\xf4'},
+    {'\x81','\x49'},{'\xa5','\xf7'},{'\x00','\x00'},{'\xa5','\xe9'},{'\xc9','\xb1'},
+    {'\xa5','\xf8'},{'\xc9','\xb5'},{'\xfb','\xba'},{'\xc9','\xb9'},{'\xc9','\xb6'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc9','\xb3'},{'\xa5','\xea'},{'\xa5','\xec'},
+    {'\xa5','\xf9'},{'\x00','\x00'},{'\xa5','\xee'},{'\xc9','\xab'},{'\xa5','\xf1'},
+    {'\xa5','\xef'},{'\xa5','\xf0'},{'\xc9','\xbb'},{'\xc9','\xb8'},{'\xc9','\xaf'},
+    {'\xa5','\xed'},{'\x00','\x00'},{'\x84','\x67'},{'\xc9','\xac'},{'\xa5','\xeb'},
+    {'\x85','\xd1'},{'\x8d','\xfd'},{'\x81','\x4a'},{'\xc9','\xb4'},{'\x84','\xc4'},
+    {'\x83','\xec'},{'\x85','\xb1'},{'\x00','\x00'},{'\xc9','\xb7'},{'\x00','\x00'},
+    {'\x85','\xb4'},{'\x83','\xa9'},{'\x83','\xab'},{'\x84','\xc3'},{'\x98','\xaf'},
+    {'\x98','\xb0'},{'\x83','\xeb'},{'\x83','\x43'},{'\xc9','\xad'},{'\xca','\x66'},
+    {'\x00','\x00'},{'\xa7','\x42'},{'\xa6','\xf4'},{'\x00','\x00'},{'\xfb','\xbd'},
+    {'\xca','\x67'},{'\xa6','\xf1'},{'\x00','\x00'},{'\xa7','\x44'},{'\x98','\xb1'},
+    {'\xa6','\xf9'},{'\xfb','\xbc'},{'\xa6','\xf8'},{'\xca','\x5b'},{'\xa6','\xfc'},
+    {'\xa6','\xf7'},{'\xca','\x60'},{'\xca','\x68'},{'\x00','\x00'},{'\xca','\x64'},
+    {'\x98','\xb2'},{'\xa6','\xfa'},{'\x00','\x00'},{'\x98','\xb3'},{'\xa6','\xfd'},
+    {'\xa6','\xee'},{'\xa7','\x47'},{'\xca','\x5d'},{'\x00','\x00'},{'\x98','\xb4'},
+    {'\xcb','\xbd'},{'\xa6','\xec'},{'\xa7','\x43'},{'\xa6','\xed'},{'\xa6','\xf5'},
+    {'\xa6','\xf6'},{'\xca','\x62'},{'\xca','\x5e'},{'\xa6','\xfb'},{'\xa6','\xf3'},
+    {'\xca','\x5a'},{'\xa6','\xef'},{'\xca','\x65'},{'\xa7','\x45'},{'\xa7','\x48'},
+    {'\xa6','\xf2'},{'\xa7','\x40'},{'\xa7','\x46'},{'\xa6','\xf0'},{'\xca','\x63'},
+    {'\xa7','\x41'},{'\xca','\x69'},{'\xca','\x5c'},{'\xa6','\xfe'},{'\xca','\x5f'},
+    {'\x8e','\x40'},{'\x00','\x00'},{'\xca','\x61'},{'\x00','\x00'},{'\xa8','\xd8'},
+    {'\xcb','\xbf'},{'\xcb','\xcb'},{'\xa8','\xd0'},{'\x00','\x00'},{'\xcb','\xcc'},
+    {'\xa8','\xcb'},{'\xa8','\xd5'},{'\x00','\x00'},{'\x98','\xb5'},{'\xa8','\xce'},
+    {'\xcb','\xb9'},{'\xa8','\xd6'},{'\xcb','\xb8'},{'\xcb','\xbc'},{'\xcb','\xc3'},
+    {'\xcb','\xc1'},{'\xa8','\xde'},{'\xa8','\xd9'},{'\xcb','\xb3'},{'\xcb','\xb5'},
+    {'\xa8','\xdb'},{'\xa8','\xcf'},{'\xcb','\xb6'},{'\xcb','\xc2'},{'\xcb','\xc9'},
+    {'\xa8','\xd4'},{'\xcb','\xbb'},{'\xcb','\xb4'},{'\xa8','\xd3'},{'\xcb','\xb7'},
+    {'\xa8','\xd7'},{'\xcb','\xba'},{'\x81','\x4b'},{'\xa8','\xd2'},{'\x00','\x00'},
+    {'\xa8','\xcd'},{'\x00','\x00'},{'\xa8','\xdc'},{'\xcb','\xc4'},{'\xa8','\xdd'},
+    {'\xcb','\xc8'},{'\x00','\x00'},{'\xcb','\xc6'},{'\xcb','\xca'},{'\xa8','\xda'},
+    {'\xcb','\xbe'},{'\xcb','\xb2'},{'\x00','\x00'},{'\xcb','\xc0'},{'\xa8','\xd1'},
+    {'\xcb','\xc5'},{'\xa8','\xcc'},{'\xcb','\xc7'},{'\x00','\x00'},{'\x83','\x65'},
+    {'\x92','\x55'},{'\x98','\xb6'},{'\x83','\x66'},{'\x00','\x00'},{'\x86','\xab'},
+    {'\x83','\xed'},{'\x83','\xee'},{'\x86','\xac'},{'\x87','\xa7'},{'\x88','\xca'},
+    {'\xfb','\xbe'},{'\x87','\xa6'},{'\x82','\x7d'},{'\xab','\x56'},{'\xab','\x4a'},
+    {'\x98','\xb7'},{'\x00','\x00'},{'\xcd','\xe0'},{'\xcd','\xe8'},{'\x98','\xf7'},
+    {'\xab','\x49'},{'\xab','\x51'},{'\xab','\x5d'},{'\x00','\x00'},{'\xcd','\xee'},
+    {'\xcd','\xec'},{'\xcd','\xe7'},{'\x00','\x00'},{'\x98','\xb8'},{'\x00','\x00'},
+    {'\xab','\x4b'},{'\xcd','\xed'},{'\xcd','\xe3'},{'\xab','\x59'},{'\xab','\x50'},
+    {'\xab','\x58'},{'\xcd','\xde'},{'\x00','\x00'},{'\xcd','\xea'},{'\x98','\xb9'},
+    {'\xcd','\xe1'},{'\xab','\x54'},{'\xcd','\xe2'},{'\x98','\xba'},{'\xcd','\xdd'},
+    {'\xab','\x5b'},{'\xab','\x4e'},{'\xab','\x57'},{'\xab','\x4d'},{'\x00','\x00'},
+    {'\xcd','\xdf'},{'\xcd','\xe4'},{'\x00','\x00'},{'\xcd','\xeb'},{'\xab','\x55'},
+    {'\xab','\x52'},{'\xcd','\xe6'},{'\xab','\x5a'},{'\xcd','\xe9'},{'\xcd','\xe5'},
+    {'\xab','\x4f'},{'\xab','\x5c'},{'\xab','\x53'},{'\xab','\x4c'},{'\xab','\x48'},
+    {'\x00','\x00'},{'\x8d','\xb9'},{'\x94','\x5f'},{'\x94','\x60'},{'\x88','\xc8'},
+    {'\x00','\x00'},{'\x8c','\xc8'},{'\x83','\xa7'},{'\x8c','\x6c'},{'\x00','\x00'},
+    {'\xcd','\xef'},{'\x87','\xa8'},{'\xad','\xd7'},{'\xad','\xc1'},{'\x98','\xbb'},
+    {'\xad','\xd1'},{'\x98','\xbc'},{'\xad','\xd6'},{'\xd0','\xd0'},{'\xd0','\xcf'},
+    {'\xd0','\xd4'},{'\xd0','\xd5'},{'\xad','\xc4'},{'\x98','\xbd'},{'\xad','\xcd'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfe','\x7b'},{'\xad','\xda'},{'\x81','\x4c'},
+    {'\xad','\xce'},{'\x00','\x00'},{'\x00','\x00'},{'\x98','\xbe'},{'\x00','\x00'},
+    {'\xd0','\xc9'},{'\xad','\xc7'},{'\xd0','\xca'},{'\x98','\xbf'},{'\xad','\xdc'},
+    {'\x00','\x00'},{'\xad','\xd3'},{'\xad','\xbe'},{'\xad','\xbf'},{'\xd0','\xdd'},
+    {'\xb0','\xbf'},{'\x00','\x00'},{'\xad','\xcc'},{'\xad','\xcb'},{'\xd0','\xcb'},
+    {'\xad','\xcf'},{'\xd4','\x5b'},{'\xad','\xc6'},{'\xd0','\xd6'},{'\xad','\xd5'},
+    {'\xad','\xd4'},{'\xad','\xca'},{'\xd0','\xce'},{'\xd0','\xd7'},{'\x00','\x00'},
+    {'\xd0','\xc8'},{'\xad','\xc9'},{'\xd0','\xd8'},{'\xad','\xd2'},{'\xd0','\xcc'},
+    {'\xad','\xc0'},{'\x82','\xa9'},{'\xad','\xc3'},{'\xad','\xc2'},{'\xd0','\xd9'},
+    {'\xad','\xd0'},{'\xad','\xc5'},{'\xad','\xd9'},{'\xad','\xdb'},{'\xd0','\xd3'},
+    {'\xad','\xd8'},{'\xfb','\xc1'},{'\xd0','\xdb'},{'\xd0','\xcd'},{'\xd0','\xdc'},
+    {'\x00','\x00'},{'\xd0','\xd1'},{'\x98','\xc0'},{'\xd0','\xda'},{'\x82','\xa3'},
+    {'\xd0','\xd2'},{'\x00','\x00'},{'\x92','\xb2'},{'\x85','\xb0'},{'\x98','\xc1'},
+    {'\xad','\xc8'},{'\x00','\x00'},{'\x85','\xb3'},{'\x00','\x00'},{'\xd4','\x63'},
+    {'\xd4','\x57'},{'\x81','\x4d'},{'\xb0','\xb3'},{'\x00','\x00'},{'\xd4','\x5c'},
+    {'\xd4','\x62'},{'\xb0','\xb2'},{'\xd4','\x55'},{'\xb0','\xb6'},{'\xd4','\x59'},
+    {'\xd4','\x52'},{'\xb0','\xb4'},{'\xd4','\x56'},{'\xb0','\xb9'},{'\xb0','\xbe'},
+    {'\x81','\x4e'},{'\xd4','\x67'},{'\x00','\x00'},{'\xd4','\x51'},{'\x00','\x00'},
+    {'\xb0','\xba'},{'\xfb','\xbf'},{'\xd4','\x66'},{'\x98','\xc2'},{'\x00','\x00'},
+    {'\xb0','\xb5'},{'\xd4','\x58'},{'\xb0','\xb1'},{'\xd4','\x53'},{'\xd4','\x4f'},
+    {'\xd4','\x5d'},{'\xd4','\x50'},{'\xd4','\x4e'},{'\xd4','\x5a'},{'\xd4','\x60'},
+    {'\xd4','\x61'},{'\xb0','\xb7'},{'\x98','\xc3'},{'\x00','\x00'},{'\xd8','\x5b'},
+    {'\xd4','\x5e'},{'\xd4','\x4d'},{'\xd4','\x5f'},{'\x85','\xb5'},{'\xb0','\xc1'},
+    {'\xd4','\x64'},{'\xb0','\xc0'},{'\xd4','\x4c'},{'\x00','\x00'},{'\xd4','\x54'},
+    {'\xd4','\x65'},{'\xb0','\xbc'},{'\xb0','\xbb'},{'\xb0','\xb8'},{'\xb0','\xbd'},
+    {'\x81','\x4f'},{'\x00','\x00'},{'\xb0','\xaf'},{'\x8d','\xfe'},{'\x00','\x00'},
+    {'\xb0','\xb0'},{'\x8e','\x65'},{'\x89','\xc8'},{'\xb3','\xc8'},{'\x98','\xc4'},
+    {'\xd8','\x5e'},{'\xd8','\x57'},{'\x00','\x00'},{'\xb3','\xc5'},{'\x00','\x00'},
+    {'\xd8','\x5f'},{'\x90','\xf0'},{'\x00','\x00'},{'\x00','\x00'},{'\xd8','\x55'},
+    {'\xd8','\x58'},{'\xb3','\xc4'},{'\xd8','\x59'},{'\x00','\x00'},{'\x98','\xc5'},
+    {'\xb3','\xc7'},{'\xd8','\x5d'},{'\x00','\x00'},{'\xd8','\x53'},{'\xd8','\x52'},
+    {'\xb3','\xc9'},{'\x00','\x00'},{'\xb3','\xca'},{'\xb3','\xc6'},{'\xb3','\xcb'},
+    {'\xd8','\x51'},{'\xd8','\x5c'},{'\xd8','\x5a'},{'\xd8','\x54'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb3','\xc3'},{'\xd8','\x56'},{'\x00','\x00'},
+    {'\x8c','\xc9'},{'\xfb','\xc2'},{'\x88','\xc9'},{'\x89','\xc9'},{'\x8f','\xfb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb6','\xca'},{'\xb6','\xc4'},{'\xdc','\xb7'},
+    {'\xb6','\xcd'},{'\xdc','\xbd'},{'\xdc','\xc0'},{'\xb6','\xc6'},{'\xb6','\xc7'},
+    {'\xdc','\xba'},{'\xb6','\xc5'},{'\xdc','\xc3'},{'\xb6','\xcb'},{'\xdc','\xc4'},
+    {'\x00','\x00'},{'\xdc','\xbf'},{'\xb6','\xcc'},{'\x98','\xc6'},{'\xdc','\xb4'},
+    {'\xb6','\xc9'},{'\xdc','\xb5'},{'\x00','\x00'},{'\xdc','\xbe'},{'\xdc','\xbc'},
+    {'\x00','\x00'},{'\xdc','\xb8'},{'\xb6','\xc8'},{'\xdc','\xb6'},{'\xb6','\xce'},
+    {'\xdc','\xbb'},{'\xdc','\xc2'},{'\xdc','\xb9'},{'\xdc','\xc1'},{'\x00','\x00'},
+    {'\x94','\x4f'},{'\xb9','\xb6'},{'\xb9','\xb3'},{'\x98','\xc7'},{'\xb9','\xb4'},
+    {'\x00','\x00'},{'\xe0','\xf9'},{'\xe0','\xf1'},{'\xb9','\xb2'},{'\xb9','\xaf'},
+    {'\xe0','\xf2'},{'\x81','\x50'},{'\xfb','\xc3'},{'\xb9','\xb1'},{'\xe0','\xf5'},
+    {'\x00','\x00'},{'\xe0','\xf7'},{'\x81','\x51'},{'\x98','\xc8'},{'\xe0','\xfe'},
+    {'\x98','\xc9'},{'\x00','\x00'},{'\xe0','\xfd'},{'\xe0','\xf8'},{'\xb9','\xae'},
+    {'\xe0','\xf0'},{'\xb9','\xac'},{'\xe0','\xf3'},{'\xb9','\xb7'},{'\xe0','\xf6'},
+    {'\x00','\x00'},{'\xe0','\xfa'},{'\xb9','\xb0'},{'\xb9','\xad'},{'\xe0','\xfc'},
+    {'\xe0','\xfb'},{'\xb9','\xb5'},{'\x00','\x00'},{'\xe0','\xf4'},{'\x81','\x52'},
+    {'\xbb','\xf8'},{'\xe4','\xec'},{'\x00','\x00'},{'\xe4','\xe9'},{'\xbb','\xf9'},
+    {'\x00','\x00'},{'\xbb','\xf7'},{'\x98','\xca'},{'\xe4','\xf0'},{'\xe4','\xed'},
+    {'\xe4','\xe6'},{'\xbb','\xf6'},{'\xfb','\xc6'},{'\xbb','\xfa'},{'\xe4','\xe7'},
+    {'\xbb','\xf5'},{'\xbb','\xfd'},{'\xe4','\xea'},{'\xe4','\xeb'},{'\xbb','\xfb'},
+    {'\xbb','\xfc'},{'\xe4','\xf1'},{'\xe4','\xee'},{'\xe4','\xef'},{'\x98','\xcb'},
+    {'\xfb','\xc4'},{'\x00','\x00'},{'\xbe','\xaa'},{'\xe8','\xf8'},{'\xbe','\xa7'},
+    {'\xe8','\xf5'},{'\xbe','\xa9'},{'\xbe','\xab'},{'\x81','\x53'},{'\xe8','\xf6'},
+    {'\xbe','\xa8'},{'\x00','\x00'},{'\xe8','\xf7'},{'\x00','\x00'},{'\xe8','\xf4'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc0','\x76'},{'\xec','\xbd'},{'\xc0','\x77'},
+    {'\xec','\xbb'},{'\x00','\x00'},{'\xec','\xbc'},{'\xec','\xba'},{'\xec','\xb9'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xec','\xbe'},{'\xc0','\x75'},{'\x98','\xcc'},
+    {'\x00','\x00'},{'\xef','\xb8'},{'\xef','\xb9'},{'\x00','\x00'},{'\xe4','\xe8'},
+    {'\xef','\xb7'},{'\xc0','\x78'},{'\xc3','\x5f'},{'\xf1','\xeb'},{'\xf1','\xec'},
+    {'\x00','\x00'},{'\xc4','\xd7'},{'\xc4','\xd8'},{'\xf5','\xc1'},{'\xf5','\xc0'},
+    {'\xc5','\x6c'},{'\xc5','\x6b'},{'\xf7','\xd0'},{'\x00','\x00'},{'\xa4','\x49'},
+    {'\xa4','\x61'},{'\xa4','\xb9'},{'\x00','\x00'},{'\xa4','\xb8'},{'\xa5','\x53'},
+    {'\xa5','\x52'},{'\xa5','\xfc'},{'\xa5','\xfb'},{'\xa5','\xfd'},{'\xa5','\xfa'},
+    {'\x81','\x54'},{'\xa7','\x4a'},{'\xa7','\x49'},{'\xa7','\x4b'},{'\x95','\xfc'},
+    {'\x00','\x00'},{'\x92','\xd1'},{'\x81','\x55'},{'\xa8','\xe0'},{'\x00','\x00'},
+    {'\xa8','\xdf'},{'\xa8','\xe1'},{'\x83','\x67'},{'\xab','\x5e'},{'\x00','\x00'},
+    {'\xa2','\x59'},{'\xd0','\xde'},{'\xa2','\x5a'},{'\xb0','\xc2'},{'\xa2','\x5c'},
+    {'\xa2','\x5b'},{'\xd8','\x60'},{'\x98','\xcd'},{'\xa2','\x5d'},{'\xb9','\xb8'},
+    {'\xa2','\x5e'},{'\x81','\x56'},{'\xa4','\x4a'},{'\x00','\x00'},{'\xa4','\xba'},
+    {'\xa5','\xfe'},{'\xa8','\xe2'},{'\x81','\x57'},{'\xa4','\x4b'},{'\xa4','\xbd'},
+    {'\xa4','\xbb'},{'\xa4','\xbc'},{'\x00','\x00'},{'\x8c','\xa3'},{'\xa6','\x40'},
+    {'\x00','\x00'},{'\x8b','\xd7'},{'\x89','\x55'},{'\xa7','\x4c'},{'\xa8','\xe4'},
+    {'\xa8','\xe3'},{'\xa8','\xe5'},{'\x90','\xbc'},{'\x00','\x00'},{'\x88','\xb5'},
+    {'\xad','\xdd'},{'\x8b','\xa6'},{'\x00','\x00'},{'\x00','\x00'},{'\xbe','\xac'},
+    {'\x90','\x54'},{'\xc6','\xc3'},{'\x00','\x00'},{'\x00','\x00'},{'\x81','\x58'},
+    {'\x92','\x4c'},{'\xc9','\x4e'},{'\x83','\x58'},{'\xa5','\x54'},{'\xa5','\x55'},
+    {'\x00','\x00'},{'\x95','\xe4'},{'\xa6','\x41'},{'\x00','\x00'},{'\xca','\x6a'},
+    {'\x81','\x59'},{'\xab','\x60'},{'\xab','\x5f'},{'\xd0','\xe0'},{'\xd0','\xdf'},
+    {'\xb0','\xc3'},{'\xc6','\xc4'},{'\xa4','\xbe'},{'\xc9','\x55'},{'\x87','\xc0'},
+    {'\xfb','\x41'},{'\x83','\x7e'},{'\x86','\x61'},{'\x81','\x5a'},{'\xcb','\xcd'},
+    {'\x00','\x00'},{'\xab','\x61'},{'\x00','\x00'},{'\xad','\xe0'},{'\x00','\x00'},
+    {'\xad','\xde'},{'\xad','\xdf'},{'\x81','\x5b'},{'\xfb','\x4e'},{'\x81','\x5c'},
+    {'\x81','\x5d'},{'\xbe','\xad'},{'\xc6','\xc5'},{'\xa5','\x56'},{'\x00','\x00'},
+    {'\x98','\xce'},{'\x85','\xad'},{'\xa6','\x42'},{'\xc9','\xbc'},{'\x83','\x4c'},
+    {'\x83','\x4b'},{'\x94','\xfb'},{'\x95','\xd5'},{'\xa7','\x4d'},{'\xa7','\x4e'},
+    {'\x98','\xcf'},{'\xca','\x6b'},{'\x00','\x00'},{'\x83','\xad'},{'\xcb','\xce'},
+    {'\xa8','\xe6'},{'\xcb','\xcf'},{'\x00','\x00'},{'\x84','\x60'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x95','\xf3'},{'\xd0','\xe2'},{'\xd0','\xe3'},{'\xad','\xe3'},
+    {'\x81','\x5e'},{'\xd0','\xe4'},{'\x84','\x5b'},{'\xd0','\xe1'},{'\xad','\xe4'},
+    {'\xad','\xe2'},{'\xad','\xe1'},{'\xd0','\xe5'},{'\x90','\xb6'},{'\xd4','\x68'},
+    {'\x84','\xee'},{'\x98','\xd0'},{'\xfb','\xcf'},{'\xd8','\x61'},{'\x00','\x00'},
+    {'\x81','\x5f'},{'\xdc','\xc5'},{'\xe1','\x40'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x81','\x60'},{'\xbb','\xfe'},{'\xbe','\xae'},{'\xe8','\xf9'},{'\xfb','\xd0'},
+    {'\xa4','\x4c'},{'\xa4','\x5a'},{'\x98','\xd1'},{'\x00','\x00'},{'\x87','\xa1'},
+    {'\x00','\x00'},{'\x92','\xe1'},{'\x94','\x4c'},{'\x00','\x00'},{'\x94','\x61'},
+    {'\x94','\x52'},{'\x8e','\x63'},{'\x81','\x61'},{'\x88','\xd7'},{'\x00','\x00'},
+    {'\x84','\xc5'},{'\xb0','\xc4'},{'\xb3','\xcd'},{'\x00','\x00'},{'\xb9','\xb9'},
+    {'\xfb','\xc7'},{'\xc9','\x42'},{'\xa4','\xbf'},{'\x00','\x00'},{'\xa5','\x59'},
+    {'\xa5','\x57'},{'\xa5','\x58'},{'\x89','\xdb'},{'\x81','\x62'},{'\xa8','\xe7'},
+    {'\xfb','\xd2'},{'\x8d','\xad'},{'\xa4','\x4d'},{'\xa4','\x4e'},{'\xc8','\x7d'},
+    {'\xa4','\x62'},{'\x95','\xcf'},{'\x98','\xd2'},{'\xa4','\xc0'},{'\xa4','\xc1'},
+    {'\xa4','\xc2'},{'\xc9','\xbe'},{'\xa5','\x5a'},{'\x81','\x63'},{'\xc9','\x6b'},
+    {'\x83','\xd2'},{'\xa6','\x46'},{'\x00','\x00'},{'\xc9','\xbf'},{'\xa6','\x44'},
+    {'\xa6','\x45'},{'\xc9','\xbd'},{'\x81','\x64'},{'\x81','\x65'},{'\xa6','\x47'},
+    {'\xa6','\x43'},{'\x87','\xaa'},{'\x83','\x68'},{'\x83','\xae'},{'\x84','\xc7'},
+    {'\xca','\x6c'},{'\xaa','\xec'},{'\xca','\x6d'},{'\xfb','\xc8'},{'\x81','\x66'},
+    {'\xca','\x6e'},{'\x00','\x00'},{'\xa0','\x7e'},{'\xa7','\x50'},{'\xa7','\x4f'},
+    {'\x95','\x7b'},{'\x95','\xe5'},{'\xa7','\x53'},{'\xa7','\x51'},{'\xa7','\x52'},
+    {'\x81','\x67'},{'\x00','\x00'},{'\x8d','\xba'},{'\xa8','\xed'},{'\x00','\x00'},
+    {'\xa8','\xec'},{'\xcb','\xd4'},{'\xcb','\xd1'},{'\xcb','\xd2'},{'\x98','\xd3'},
+    {'\xcb','\xd0'},{'\xa8','\xee'},{'\xa8','\xea'},{'\xa8','\xe9'},{'\x81','\x68'},
+    {'\xa8','\xeb'},{'\xa8','\xe8'},{'\x98','\xd4'},{'\x87','\xac'},{'\x00','\x00'},
+    {'\x8e','\xaf'},{'\x84','\xc6'},{'\xa8','\xef'},{'\x88','\xcc'},{'\xab','\x63'},
+    {'\xcd','\xf0'},{'\x00','\x00'},{'\xcb','\xd3'},{'\xab','\x68'},{'\x00','\x00'},
+    {'\xcd','\xf1'},{'\xab','\x64'},{'\xab','\x67'},{'\xab','\x66'},{'\xab','\x65'},
+    {'\xab','\x62'},{'\x81','\x69'},{'\x8d','\xc8'},{'\x87','\xab'},{'\xd0','\xe8'},
+    {'\x00','\x00'},{'\xad','\xe7'},{'\xd0','\xeb'},{'\xad','\xe5'},{'\xfb','\xca'},
+    {'\x00','\x00'},{'\x98','\xd5'},{'\xd0','\xe7'},{'\xad','\xe8'},{'\xad','\xe6'},
+    {'\xad','\xe9'},{'\xd0','\xe9'},{'\xd0','\xea'},{'\xfb','\xc9'},{'\xd0','\xe6'},
+    {'\xd0','\xec'},{'\x92','\xb3'},{'\x92','\xc9'},{'\x82','\x76'},{'\x00','\x00'},
+    {'\x87','\xa9'},{'\x98','\xd6'},{'\xb3','\xd1'},{'\xb0','\xc5'},{'\xd4','\x69'},
+    {'\xd4','\x6b'},{'\xd4','\x6a'},{'\xd4','\x6c'},{'\xb0','\xc6'},{'\x92','\xeb'},
+    {'\x81','\x6a'},{'\xb3','\xce'},{'\xfc','\xf5'},{'\xb3','\xcf'},{'\xb3','\xd0'},
+    {'\x00','\x00'},{'\xb6','\xd0'},{'\xdc','\xc7'},{'\x98','\xd7'},{'\xdc','\xc6'},
+    {'\xdc','\xc8'},{'\xdc','\xc9'},{'\xb6','\xd1'},{'\x00','\x00'},{'\xb6','\xcf'},
+    {'\xe1','\x41'},{'\xe1','\x42'},{'\xb9','\xbb'},{'\xb9','\xba'},{'\xe3','\x5a'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xbc','\x40'},{'\xbc','\x41'},{'\xbc','\x42'},
+    {'\xbc','\x44'},{'\xe4','\xf2'},{'\xe4','\xf3'},{'\xbc','\x43'},{'\x00','\x00'},
+    {'\xfb','\x69'},{'\x81','\x6b'},{'\xbe','\xaf'},{'\x81','\x6c'},{'\xbe','\xb0'},
+    {'\x81','\x6d'},{'\x00','\x00'},{'\xf1','\xed'},{'\xf5','\xc3'},{'\xf5','\xc2'},
+    {'\xf7','\xd1'},{'\xfb','\xcb'},{'\xa4','\x4f'},{'\x81','\x6e'},{'\x8b','\xef'},
+    {'\x89','\x74'},{'\xa5','\x5c'},{'\xa5','\x5b'},{'\x83','\xef'},{'\x8e','\xb0'},
+    {'\xa6','\x48'},{'\x98','\xd8'},{'\x00','\x00'},{'\xc9','\xc0'},{'\x00','\x00'},
+    {'\x83','\xf0'},{'\xa7','\x55'},{'\xa7','\x56'},{'\xa7','\x54'},{'\xa7','\x57'},
+    {'\xca','\x6f'},{'\xca','\x70'},{'\x81','\x6f'},{'\x00','\x00'},{'\x89','\xca'},
+    {'\x83','\x69'},{'\x84','\xc8'},{'\x93','\xf5'},{'\x81','\x70'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x95','\xa2'},{'\x00','\x00'},{'\xa8','\xf1'},
+    {'\xcb','\xd5'},{'\x00','\x00'},{'\xa8','\xf0'},{'\x85','\xb7'},{'\xcd','\xf2'},
+    {'\xab','\x6c'},{'\xcd','\xf3'},{'\xab','\x6b'},{'\x00','\x00'},{'\x95','\x44'},
+    {'\x00','\x00'},{'\xab','\x69'},{'\x00','\x00'},{'\xab','\x6a'},{'\x00','\x00'},
+    {'\x84','\xc9'},{'\x98','\xd9'},{'\xd0','\xed'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x81','\x71'},{'\xfb','\xcc'},{'\xb0','\xc7'},{'\xd4','\x6e'},{'\x00','\x00'},
+    {'\xb0','\xca'},{'\xd4','\x6d'},{'\xb1','\xe5'},{'\xb0','\xc9'},{'\xb0','\xc8'},
+    {'\x00','\x00'},{'\xb3','\xd4'},{'\x00','\x00'},{'\xb3','\xd3'},{'\xb3','\xd2'},
+    {'\xb6','\xd2'},{'\xfb','\xcd'},{'\xfb','\xce'},{'\xb6','\xd5'},{'\xb6','\xd6'},
+    {'\xb6','\xd4'},{'\x00','\x00'},{'\xb6','\xd3'},{'\x92','\x68'},{'\x00','\x00'},
+    {'\xe1','\x43'},{'\x00','\x00'},{'\xe1','\x44'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe4','\xf5'},{'\xbc','\x45'},{'\xe4','\xf4'},{'\x92','\xa4'},
+    {'\xbe','\xb1'},{'\xec','\xbf'},{'\xc0','\x79'},{'\x00','\x00'},{'\xf1','\xee'},
+    {'\xc4','\x55'},{'\xc6','\xc6'},{'\xa4','\x63'},{'\xa4','\xc3'},{'\xc9','\x56'},
+    {'\x00','\x00'},{'\xa4','\xc4'},{'\xa4','\xc5'},{'\x81','\x72'},{'\x94','\x5e'},
+    {'\x94','\x53'},{'\x9c','\xd0'},{'\x00','\x00'},{'\xa5','\x5d'},{'\xa5','\x5e'},
+    {'\x81','\x73'},{'\xa6','\x49'},{'\xca','\x71'},{'\xcb','\xd6'},{'\xcb','\xd7'},
+    {'\x00','\x00'},{'\xab','\x6d'},{'\xd0','\xee'},{'\xb0','\xcc'},{'\xb0','\xcb'},
+    {'\xd8','\x63'},{'\xd8','\x62'},{'\x00','\x00'},{'\x00','\x00'},{'\xa4','\x50'},
+    {'\xa4','\xc6'},{'\xa5','\x5f'},{'\x00','\x00'},{'\xb0','\xcd'},{'\xc9','\x43'},
+    {'\x00','\x00'},{'\xc9','\x6c'},{'\xa5','\x60'},{'\x00','\x00'},{'\xc9','\xc2'},
+    {'\xa6','\x4b'},{'\xa6','\x4a'},{'\xc9','\xc1'},{'\xa7','\x58'},{'\x81','\x74'},
+    {'\x00','\x00'},{'\x8d','\xc9'},{'\x98','\xda'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xad','\xea'},{'\x00','\x00'},{'\xfb','\xd4'},{'\xd4','\x6f'},{'\x86','\xad'},
+    {'\xb6','\xd7'},{'\xe1','\x45'},{'\xb9','\xbc'},{'\xfb','\xd3'},{'\xfb','\xd5'},
+    {'\xe8','\xfa'},{'\x00','\x00'},{'\x00','\x00'},{'\xf3','\xfd'},{'\xc6','\xc7'},
+    {'\xa4','\xc7'},{'\x83','\xf1'},{'\x8b','\x4b'},{'\xcb','\xd8'},{'\xcd','\xf4'},
+    {'\xb0','\xd0'},{'\xb0','\xce'},{'\xb0','\xcf'},{'\xa4','\x51'},{'\x98','\xdb'},
+    {'\xa4','\x64'},{'\xa2','\xcd'},{'\xa4','\xca'},{'\x81','\x75'},{'\xa4','\xc9'},
+    {'\xa4','\xc8'},{'\xa5','\x63'},{'\xa5','\x62'},{'\x00','\x00'},{'\xc9','\x6d'},
+    {'\xc9','\xc3'},{'\x85','\x4f'},{'\x83','\x56'},{'\x00','\x00'},{'\xa8','\xf5'},
+    {'\xa8','\xf2'},{'\xa8','\xf4'},{'\xa8','\xf3'},{'\x84','\xcb'},{'\x88','\x6f'},
+    {'\xab','\x6e'},{'\x93','\x6d'},{'\x00','\x00'},{'\xb3','\xd5'},{'\x00','\x00'},
+    {'\xa4','\x52'},{'\x98','\xdc'},{'\xa4','\xcb'},{'\x81','\x76'},{'\xa5','\x65'},
+    {'\xa5','\x64'},{'\x89','\x41'},{'\xca','\x72'},{'\x84','\xc0'},{'\x00','\x00'},
+    {'\xa8','\xf6'},{'\x83','\x60'},{'\x00','\x00'},{'\xc6','\xc8'},{'\x00','\x00'},
+    {'\x88','\x55'},{'\xc9','\x57'},{'\x95','\xf2'},{'\xa5','\x67'},{'\xa5','\x66'},
+    {'\xa6','\x4c'},{'\xa6','\x4d'},{'\xca','\x73'},{'\xa7','\x59'},{'\x83','\x6a'},
+    {'\xa7','\x5a'},{'\x00','\x00'},{'\xa8','\xf7'},{'\xa8','\xf8'},{'\xa8','\xf9'},
+    {'\x8d','\xbd'},{'\xab','\x6f'},{'\xcd','\xf5'},{'\x98','\xdd'},{'\x98','\xde'},
+    {'\xad','\xeb'},{'\x00','\x00'},{'\x00','\x00'},{'\xc9','\x44'},{'\x00','\x00'},
+    {'\xa4','\xcc'},{'\x8d','\x6d'},{'\x88','\xe5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x87','\xad'},{'\xc9','\xc4'},{'\x89','\xcd'},{'\x86','\xae'},{'\x8d','\xbb'},
+    {'\xca','\x74'},{'\xca','\x75'},{'\x00','\x00'},{'\x00','\x00'},{'\xcb','\xd9'},
+    {'\x81','\x77'},{'\xcb','\xda'},{'\x84','\xda'},{'\xcd','\xf7'},{'\xcd','\xf6'},
+    {'\xcd','\xf9'},{'\xcd','\xf8'},{'\xab','\x70'},{'\x00','\x00'},{'\xd4','\x70'},
+    {'\xad','\xed'},{'\xd0','\xef'},{'\xad','\xec'},{'\x95','\xe8'},{'\x00','\x00'},
+    {'\x95','\xe9'},{'\x8f','\xb6'},{'\xd8','\x64'},{'\xb3','\xd6'},{'\x95','\x7a'},
+    {'\xd8','\x65'},{'\x87','\xc5'},{'\x84','\xdb'},{'\xfb','\xd7'},{'\xfb','\xd6'},
+    {'\xe1','\x46'},{'\xb9','\xbd'},{'\x87','\xc7'},{'\x00','\x00'},{'\x81','\x78'},
+    {'\x00','\x00'},{'\xbc','\x46'},{'\x92','\xba'},{'\xf1','\xef'},{'\x00','\x00'},
+    {'\xc6','\xc9'},{'\x00','\x00'},{'\x00','\x00'},{'\xc9','\x58'},{'\x00','\x00'},
+    {'\xa5','\x68'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x89','\x4f'},
+    {'\x00','\x00'},{'\x95','\x48'},{'\x83','\xf2'},{'\xb0','\xd1'},{'\x00','\x00'},
+    {'\x98','\xdf'},{'\x00','\x00'},{'\x00','\x00'},{'\xa4','\x53'},{'\xa4','\x65'},
+    {'\xa4','\xce'},{'\xa4','\xcd'},{'\x8b','\x5a'},{'\xa4','\xcf'},{'\x83','\x42'},
+    {'\x00','\x00'},{'\x98','\xe0'},{'\x84','\xfa'},{'\x98','\xe1'},{'\x00','\x00'},
+    {'\xa8','\xfb'},{'\x00','\x00'},{'\xa8','\xfa'},{'\xa8','\xfc'},{'\x8d','\x40'},
+    {'\x95','\xb3'},{'\xfb','\xdb'},{'\xab','\x71'},{'\x00','\x00'},{'\x81','\x79'},
+    {'\x00','\x00'},{'\xad','\xee'},{'\x8c','\xd4'},{'\xe8','\xfb'},{'\xc2','\x4f'},
+    {'\xa4','\x66'},{'\xa5','\x6a'},{'\xa5','\x79'},{'\xa5','\x74'},{'\x00','\x00'},
+    {'\xa5','\x6f'},{'\xa5','\x6e'},{'\xa5','\x75'},{'\xa5','\x73'},{'\xa5','\x6c'},
+    {'\xa5','\x7a'},{'\xa5','\x6d'},{'\xa5','\x69'},{'\xa5','\x78'},{'\xa5','\x77'},
+    {'\xa5','\x76'},{'\xa5','\x6b'},{'\x00','\x00'},{'\xa5','\x72'},{'\x85','\xfc'},
+    {'\x86','\x41'},{'\xa5','\x71'},{'\x86','\xb1'},{'\x94','\x62'},{'\xa5','\x7b'},
+    {'\xa5','\x70'},{'\x87','\xb4'},{'\x98','\xe2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa6','\x53'},{'\x00','\x00'},{'\xa6','\x59'},{'\xa6','\x55'},{'\x00','\x00'},
+    {'\xa6','\x5b'},{'\xc9','\xc5'},{'\xa6','\x58'},{'\xa6','\x4e'},{'\xa6','\x51'},
+    {'\xa6','\x54'},{'\xa6','\x50'},{'\xa6','\x57'},{'\xa6','\x5a'},{'\xa6','\x4f'},
+    {'\xa6','\x52'},{'\xa6','\x56'},{'\xa6','\x5c'},{'\x89','\xcc'},{'\xfb','\x43'},
+    {'\x90','\xb8'},{'\xfb','\x42'},{'\x85','\xba'},{'\xca','\x7e'},{'\xca','\x7b'},
+    {'\xa0','\x55'},{'\xa7','\x67'},{'\xca','\x7c'},{'\xa7','\x5b'},{'\xa7','\x5d'},
+    {'\xa7','\x75'},{'\xa7','\x70'},{'\x96','\xb2'},{'\x00','\x00'},{'\x81','\x7a'},
+    {'\xca','\xa5'},{'\xca','\x7d'},{'\xa7','\x5f'},{'\xa7','\x61'},{'\xca','\xa4'},
+    {'\xa7','\x68'},{'\xca','\x78'},{'\xa7','\x74'},{'\xa7','\x76'},{'\xa7','\x5c'},
+    {'\xa7','\x6d'},{'\x84','\x51'},{'\xca','\x76'},{'\xa7','\x73'},{'\x96','\xb4'},
+    {'\xa7','\x64'},{'\x83','\x45'},{'\xa7','\x6e'},{'\xa7','\x6f'},{'\xca','\x77'},
+    {'\xa7','\x6c'},{'\xa7','\x6a'},{'\x00','\x00'},{'\xa7','\x6b'},{'\xa7','\x71'},
+    {'\xca','\xa1'},{'\xa7','\x5e'},{'\x00','\x00'},{'\xa7','\x72'},{'\xca','\xa3'},
+    {'\xa7','\x66'},{'\xa7','\x63'},{'\x00','\x00'},{'\xca','\x7a'},{'\xa7','\x62'},
+    {'\xca','\xa6'},{'\xa7','\x65'},{'\x92','\xbb'},{'\xa7','\x69'},{'\x96','\xa4'},
+    {'\x00','\x00'},{'\xa0','\x5a'},{'\xa7','\x60'},{'\xca','\xa2'},{'\x81','\x7b'},
+    {'\x81','\x7c'},{'\x8e','\xb2'},{'\x8c','\xca'},{'\xca','\x79'},{'\x86','\xb0'},
+    {'\x8f','\xb7'},{'\x8d','\xc2'},{'\x83','\xb0'},{'\x8d','\xbc'},{'\x00','\x00'},
+    {'\x85','\xbc'},{'\x85','\xbb'},{'\x00','\x00'},{'\x00','\x00'},{'\x82','\xaf'},
+    {'\xcb','\xeb'},{'\xcb','\xea'},{'\xa9','\x4f'},{'\xcb','\xed'},{'\xcb','\xef'},
+    {'\xcb','\xe4'},{'\xcb','\xe7'},{'\xcb','\xee'},{'\xa9','\x50'},{'\xfb','\xd9'},
+    {'\x94','\xfc'},{'\xcb','\xe1'},{'\xcb','\xe5'},{'\x98','\xe3'},{'\x00','\x00'},
+    {'\xcb','\xe9'},{'\xce','\x49'},{'\xa9','\x4b'},{'\xce','\x4d'},{'\xa8','\xfd'},
+    {'\xcb','\xe6'},{'\xa8','\xfe'},{'\xa9','\x4c'},{'\xa9','\x45'},{'\xa9','\x41'},
+    {'\x00','\x00'},{'\xcb','\xe2'},{'\xa9','\x44'},{'\xa9','\x49'},{'\xa9','\x52'},
+    {'\xcb','\xe3'},{'\xcb','\xdc'},{'\xa9','\x43'},{'\xcb','\xdd'},{'\xcb','\xdf'},
+    {'\x00','\x00'},{'\xa9','\x46'},{'\x98','\xe4'},{'\xa9','\x48'},{'\xcb','\xdb'},
+    {'\xcb','\xe0'},{'\x00','\x00'},{'\x81','\x7d'},{'\xa9','\x51'},{'\xa9','\x4d'},
+    {'\xcb','\xe8'},{'\xa9','\x53'},{'\x95','\xa3'},{'\xa9','\x4a'},{'\xcb','\xde'},
+    {'\xa9','\x47'},{'\x98','\xe5'},{'\x96','\xb6'},{'\xa9','\x42'},{'\xa9','\x40'},
+    {'\xa0','\x57'},{'\xcb','\xec'},{'\x8b','\xf0'},{'\xa9','\x4e'},{'\x89','\xcb'},
+    {'\xfb','\xda'},{'\x81','\x7e'},{'\x98','\xe6'},{'\x00','\x00'},{'\xce','\x48'},
+    {'\xcd','\xfb'},{'\xce','\x4b'},{'\x81','\xa1'},{'\x95','\x79'},{'\xcd','\xfd'},
+    {'\xab','\x78'},{'\xab','\xa8'},{'\xab','\x74'},{'\xab','\xa7'},{'\xab','\x7d'},
+    {'\xab','\xa4'},{'\xab','\x72'},{'\xcd','\xfc'},{'\xce','\x43'},{'\xab','\xa3'},
+    {'\xce','\x4f'},{'\xab','\xa5'},{'\x94','\x46'},{'\xab','\x79'},{'\x81','\xa2'},
+    {'\x00','\x00'},{'\xce','\x45'},{'\xce','\x42'},{'\xab','\x77'},{'\x98','\xe7'},
+    {'\xcd','\xfa'},{'\xab','\xa6'},{'\xce','\x4a'},{'\xab','\x7c'},{'\xce','\x4c'},
+    {'\xab','\xa9'},{'\xab','\x73'},{'\xab','\x7e'},{'\xab','\x7b'},{'\xce','\x40'},
+    {'\xab','\xa1'},{'\xce','\x46'},{'\xce','\x47'},{'\xab','\x7a'},{'\xab','\xa2'},
+    {'\xab','\x76'},{'\x00','\x00'},{'\xfb','\x4a'},{'\x96','\xcf'},{'\x8c','\xb7'},
+    {'\xab','\x75'},{'\xcd','\xfe'},{'\x81','\xa3'},{'\x83','\xf3'},{'\x8e','\xe2'},
+    {'\x8e','\xb1'},{'\x86','\xb4'},{'\x8e','\xe3'},{'\xce','\x44'},{'\x87','\xb0'},
+    {'\x94','\x63'},{'\x8e','\xe4'},{'\x96','\xb3'},{'\x00','\x00'},{'\x8f','\x4f'},
+    {'\x88','\xce'},{'\xce','\x4e'},{'\x84','\xcc'},{'\xd1','\x44'},{'\xad','\xfb'},
+    {'\xd0','\xf1'},{'\x98','\xe8'},{'\xd0','\xf6'},{'\xad','\xf4'},{'\xae','\x40'},
+    {'\xd0','\xf4'},{'\xad','\xef'},{'\xad','\xf9'},{'\xad','\xfe'},{'\xd0','\xfb'},
+    {'\x00','\x00'},{'\xad','\xfa'},{'\xad','\xfd'},{'\x98','\xe9'},{'\x00','\x00'},
+    {'\xd0','\xfe'},{'\xad','\xf5'},{'\xd0','\xf5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd1','\x42'},{'\xd1','\x43'},{'\x00','\x00'},{'\xad','\xf7'},
+    {'\xd1','\x41'},{'\xad','\xf3'},{'\xae','\x43'},{'\x00','\x00'},{'\xd0','\xf8'},
+    {'\x00','\x00'},{'\xad','\xf1'},{'\xfb','\x5a'},{'\xd1','\x46'},{'\xd0','\xf9'},
+    {'\xd0','\xfd'},{'\xad','\xf6'},{'\xae','\x42'},{'\xd0','\xfa'},{'\xad','\xfc'},
+    {'\xd1','\x40'},{'\xd1','\x47'},{'\xd4','\xa1'},{'\x98','\xea'},{'\xd1','\x45'},
+    {'\xae','\x44'},{'\xad','\xf0'},{'\xd0','\xfc'},{'\xd0','\xf3'},{'\xfb','\x52'},
+    {'\xad','\xf8'},{'\x00','\x00'},{'\x82','\x40'},{'\xd0','\xf2'},{'\x98','\xeb'},
+    {'\x00','\x00'},{'\xd0','\xf7'},{'\x8e','\x66'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfb','\x55'},{'\x00','\x00'},{'\x87','\xae'},{'\x00','\x00'},{'\x8e','\x41'},
+    {'\x81','\xa4'},{'\x84','\xcd'},{'\x98','\xec'},{'\xd0','\xf0'},{'\xae','\x41'},
+    {'\x98','\xed'},{'\x00','\x00'},{'\xd4','\x77'},{'\x98','\xee'},{'\xb0','\xe4'},
+    {'\xd4','\xa7'},{'\xb0','\xe2'},{'\xb0','\xdf'},{'\xd4','\x7c'},{'\xb0','\xdb'},
+    {'\xd4','\xa2'},{'\xb0','\xe6'},{'\xd4','\x76'},{'\xd4','\x7b'},{'\xd4','\x7a'},
+    {'\xad','\xf2'},{'\xb0','\xe1'},{'\xd4','\xa5'},{'\x00','\x00'},{'\xd4','\xa8'},
+    {'\xd4','\x73'},{'\x00','\x00'},{'\xb3','\xe8'},{'\x81','\xa5'},{'\xd4','\xa9'},
+    {'\xb0','\xe7'},{'\x00','\x00'},{'\xb0','\xd9'},{'\xb0','\xd6'},{'\xd4','\x7e'},
+    {'\xb0','\xd3'},{'\x98','\xef'},{'\xd4','\xa6'},{'\x96','\xb1'},{'\xb0','\xda'},
+    {'\xd4','\xaa'},{'\x81','\xa6'},{'\xd4','\x74'},{'\xd4','\xa4'},{'\xb0','\xdd'},
+    {'\xd4','\x75'},{'\xd4','\x78'},{'\xd4','\x7d'},{'\x81','\xa7'},{'\x00','\x00'},
+    {'\xb0','\xde'},{'\xb0','\xdc'},{'\xb0','\xe8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb0','\xe3'},{'\x81','\xa8'},{'\xb0','\xd7'},
+    {'\xb1','\xd2'},{'\x00','\x00'},{'\xb0','\xd8'},{'\xd4','\x79'},{'\xb0','\xe5'},
+    {'\xb0','\xe0'},{'\xd4','\xa3'},{'\xb0','\xd5'},{'\x86','\xb3'},{'\x00','\x00'},
+    {'\xfb','\x5b'},{'\xb0','\xd4'},{'\xa0','\x46'},{'\x81','\xa9'},{'\x8c','\x6e'},
+    {'\x8c','\xc7'},{'\x00','\x00'},{'\x00','\x00'},{'\xa0','\x49'},{'\xa0','\x45'},
+    {'\xfb','\xdd'},{'\x00','\x00'},{'\xd4','\x71'},{'\xd4','\x72'},{'\xd8','\x6a'},
+    {'\x87','\xb3'},{'\x98','\xf0'},{'\x00','\x00'},{'\xb3','\xd7'},{'\xb3','\xda'},
+    {'\xd8','\x75'},{'\xb3','\xee'},{'\xd8','\x78'},{'\xb3','\xd8'},{'\xd8','\x71'},
+    {'\xb3','\xde'},{'\xb3','\xe4'},{'\xb5','\xbd'},{'\x00','\x00'},{'\x95','\xed'},
+    {'\xb3','\xe2'},{'\xd8','\x6e'},{'\xb3','\xef'},{'\xb3','\xdb'},{'\xb3','\xe3'},
+    {'\xd8','\x76'},{'\xdc','\xd7'},{'\xd8','\x7b'},{'\xd8','\x6f'},{'\x98','\xf1'},
+    {'\xd8','\x66'},{'\xd8','\x73'},{'\xd8','\x6d'},{'\xb3','\xe1'},{'\xd8','\x79'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb3','\xdd'},{'\xb3','\xf1'},{'\xb3','\xea'},
+    {'\x00','\x00'},{'\xb3','\xdf'},{'\xb3','\xdc'},{'\x81','\xaa'},{'\xb3','\xe7'},
+    {'\x00','\x00'},{'\xd8','\x7a'},{'\xd8','\x6c'},{'\xd8','\x72'},{'\xd8','\x74'},
+    {'\xd8','\x68'},{'\xd8','\x77'},{'\xb3','\xd9'},{'\xd8','\x67'},{'\x81','\xab'},
+    {'\xb3','\xe0'},{'\xb3','\xf0'},{'\xb3','\xec'},{'\xd8','\x69'},{'\xb3','\xe6'},
+    {'\x00','\x00'},{'\x94','\x42'},{'\xb3','\xed'},{'\xb3','\xe9'},{'\xb3','\xe5'},
+    {'\x98','\xf2'},{'\xd8','\x70'},{'\x92','\x49'},{'\x87','\xb2'},{'\x00','\x00'},
+    {'\x96','\xb5'},{'\xa0','\x4a'},{'\xb3','\xeb'},{'\xfb','\x4c'},{'\x86','\xb2'},
+    {'\x8f','\xd9'},{'\xdc','\xd5'},{'\xdc','\xd1'},{'\x98','\xf3'},{'\xdc','\xe0'},
+    {'\xdc','\xca'},{'\xdc','\xd3'},{'\xb6','\xe5'},{'\xb6','\xe6'},{'\xb6','\xde'},
+    {'\xdc','\xdc'},{'\xb6','\xe8'},{'\xdc','\xcf'},{'\xdc','\xce'},{'\xdc','\xcc'},
+    {'\xdc','\xde'},{'\xb6','\xdc'},{'\xdc','\xd8'},{'\xdc','\xcd'},{'\xb6','\xdf'},
+    {'\xdc','\xd6'},{'\xb6','\xda'},{'\xdc','\xd2'},{'\xdc','\xd9'},{'\xdc','\xdb'},
+    {'\x98','\xf4'},{'\x98','\xf5'},{'\xdc','\xdf'},{'\xb6','\xe3'},{'\xdc','\xcb'},
+    {'\xb6','\xdd'},{'\xdc','\xd0'},{'\xfb','\x56'},{'\xb6','\xd8'},{'\x00','\x00'},
+    {'\xb6','\xe4'},{'\xdc','\xda'},{'\xb6','\xe0'},{'\xb6','\xe1'},{'\xb6','\xe7'},
+    {'\xb6','\xdb'},{'\xa2','\x5f'},{'\xb6','\xd9'},{'\xdc','\xd4'},{'\x96','\xc9'},
+    {'\x8c','\x6d'},{'\x81','\xac'},{'\x00','\x00'},{'\x00','\x00'},{'\xb6','\xe2'},
+    {'\xa0','\x4d'},{'\xa0','\x4b'},{'\xdc','\xdd'},{'\x88','\xcf'},{'\x00','\x00'},
+    {'\x81','\xad'},{'\xb9','\xcd'},{'\xb9','\xc8'},{'\x00','\x00'},{'\xe1','\x55'},
+    {'\xe1','\x51'},{'\x98','\xf6'},{'\xe1','\x4b'},{'\xb9','\xc2'},{'\xb9','\xbe'},
+    {'\xe1','\x54'},{'\xb9','\xbf'},{'\xe1','\x4e'},{'\xe1','\x50'},{'\x00','\x00'},
+    {'\xe1','\x53'},{'\xa0','\x4e'},{'\xb9','\xc4'},{'\x00','\x00'},{'\xb9','\xcb'},
+    {'\xb9','\xc5'},{'\x00','\x00'},{'\x00','\x00'},{'\xe1','\x49'},{'\xb9','\xc6'},
+    {'\xb9','\xc7'},{'\xe1','\x4c'},{'\xb9','\xcc'},{'\xfb','\xe1'},{'\xe1','\x4a'},
+    {'\xe1','\x4f'},{'\xb9','\xc3'},{'\xe1','\x48'},{'\xb9','\xc9'},{'\xb9','\xc1'},
+    {'\x82','\xb3'},{'\x00','\x00'},{'\x00','\x00'},{'\xb9','\xc0'},{'\xe1','\x4d'},
+    {'\xe1','\x52'},{'\xa0','\x52'},{'\xb9','\xca'},{'\xfc','\xd9'},{'\x98','\xf8'},
+    {'\xa0','\x4f'},{'\x81','\xae'},{'\x8b','\xf1'},{'\xfb','\x65'},{'\x00','\x00'},
+    {'\xe1','\x47'},{'\x00','\x00'},{'\xbc','\x4d'},{'\xe5','\x47'},{'\x00','\x00'},
+    {'\xe5','\x44'},{'\xa0','\x50'},{'\xbc','\x47'},{'\xbc','\x53'},{'\xbc','\x54'},
+    {'\x8d','\x51'},{'\xbc','\x4a'},{'\xe5','\x42'},{'\xbc','\x4c'},{'\xe4','\xf9'},
+    {'\xbc','\x52'},{'\xfe','\x5d'},{'\xe5','\x46'},{'\xbc','\x49'},{'\xe5','\x48'},
+    {'\xbc','\x48'},{'\x00','\x00'},{'\xe5','\x43'},{'\xe5','\x45'},{'\xbc','\x4b'},
+    {'\xe5','\x41'},{'\xe4','\xfa'},{'\xe4','\xf7'},{'\xa0','\x51'},{'\x00','\x00'},
+    {'\xd8','\x6b'},{'\xe4','\xfd'},{'\x00','\x00'},{'\xe4','\xf6'},{'\xe4','\xfc'},
+    {'\xe4','\xfb'},{'\x00','\x00'},{'\xe4','\xf8'},{'\xfb','\xe2'},{'\xbc','\x4f'},
+    {'\xfb','\x6a'},{'\x81','\xaf'},{'\x00','\x00'},{'\x98','\xfa'},{'\xbc','\x4e'},
+    {'\xfb','\xe4'},{'\x00','\x00'},{'\x00','\x00'},{'\xbc','\x50'},{'\xe4','\xfe'},
+    {'\xbe','\xb2'},{'\xe5','\x40'},{'\x82','\x4f'},{'\x8a','\xbe'},{'\x99','\x40'},
+    {'\xe9','\x45'},{'\x00','\x00'},{'\xe8','\xfd'},{'\x99','\x55'},{'\xbe','\xbe'},
+    {'\xe9','\x42'},{'\xbe','\xb6'},{'\xbe','\xba'},{'\xe9','\x41'},{'\x00','\x00'},
+    {'\xbe','\xb9'},{'\xbe','\xb5'},{'\xbe','\xb8'},{'\xbe','\xb3'},{'\xbe','\xbd'},
+    {'\xe9','\x43'},{'\xe8','\xfe'},{'\xbe','\xbc'},{'\xe8','\xfc'},{'\xbe','\xbb'},
+    {'\xe9','\x44'},{'\xe9','\x40'},{'\xbc','\x51'},{'\x00','\x00'},{'\xbe','\xbf'},
+    {'\xe9','\x46'},{'\xbe','\xb7'},{'\xbe','\xb4'},{'\x94','\x57'},{'\x96','\xca'},
+    {'\x81','\xb0'},{'\x00','\x00'},{'\xec','\xc6'},{'\xec','\xc8'},{'\xc0','\x7b'},
+    {'\xec','\xc9'},{'\xec','\xc7'},{'\xec','\xc5'},{'\xec','\xc4'},{'\xc0','\x7d'},
+    {'\xec','\xc3'},{'\xc0','\x7e'},{'\x00','\x00'},{'\x99','\x56'},{'\x81','\xb1'},
+    {'\x99','\x57'},{'\xec','\xc1'},{'\xec','\xc2'},{'\xc0','\x7a'},{'\xc0','\xa1'},
+    {'\xc0','\x7c'},{'\x00','\x00'},{'\xa0','\x53'},{'\xec','\xc0'},{'\x81','\xb2'},
+    {'\xc2','\x50'},{'\x00','\x00'},{'\xef','\xbc'},{'\xef','\xba'},{'\xef','\xbf'},
+    {'\xef','\xbd'},{'\x00','\x00'},{'\xef','\xbb'},{'\xef','\xbe'},{'\x99','\x58'},
+    {'\xa0','\x5c'},{'\x81','\xb3'},{'\x99','\x59'},{'\x82','\x74'},{'\x8c','\x6f'},
+    {'\xa0','\x5b'},{'\xc3','\x60'},{'\xf1','\xf2'},{'\xf1','\xf3'},{'\xc4','\x56'},
+    {'\x00','\x00'},{'\xf1','\xf4'},{'\xf1','\xf0'},{'\xf1','\xf5'},{'\xf1','\xf1'},
+    {'\xc2','\x51'},{'\x81','\xb4'},{'\x00','\x00'},{'\x99','\x5a'},{'\xf3','\xfe'},
+    {'\xf4','\x41'},{'\xc4','\x59'},{'\xf4','\x40'},{'\xc4','\x58'},{'\xc4','\x57'},
+    {'\x00','\x00'},{'\x99','\x5b'},{'\x00','\x00'},{'\x00','\x00'},{'\xc4','\x5a'},
+    {'\xf5','\xc5'},{'\xf5','\xc6'},{'\x99','\x5c'},{'\xc4','\xda'},{'\xc4','\xd9'},
+    {'\xc4','\xdb'},{'\xf5','\xc4'},{'\x00','\x00'},{'\xf6','\xd8'},{'\xf6','\xd7'},
+    {'\x00','\x00'},{'\xc5','\x6d'},{'\xc5','\x6f'},{'\xc5','\x6e'},{'\xf6','\xd9'},
+    {'\xc5','\xc8'},{'\xf8','\xa6'},{'\x94','\x64'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc5','\xf1'},{'\x00','\x00'},{'\xf8','\xa5'},{'\xf8','\xee'},{'\x00','\x00'},
+    {'\x99','\x5d'},{'\xc9','\x49'},{'\x81','\xb5'},{'\x00','\x00'},{'\xa5','\x7d'},
+    {'\xa5','\x7c'},{'\x00','\x00'},{'\xa6','\x5f'},{'\xa6','\x5e'},{'\xc9','\xc7'},
+    {'\xa6','\x5d'},{'\xc9','\xc6'},{'\x86','\xb5'},{'\x93','\x6f'},{'\xa7','\x79'},
+    {'\xca','\xa9'},{'\x00','\x00'},{'\xca','\xa8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa7','\x77'},{'\xa7','\x7a'},{'\x00','\x00'},{'\x85','\xbd'},{'\xca','\xa7'},
+    {'\x99','\x5e'},{'\xa7','\x78'},{'\x83','\x46'},{'\x92','\x43'},{'\x92','\xf6'},
+    {'\x84','\xcf'},{'\x8d','\xca'},{'\x00','\x00'},{'\xcb','\xf0'},{'\x00','\x00'},
+    {'\xcb','\xf1'},{'\xa9','\x54'},{'\x9d','\x56'},{'\x00','\x00'},{'\x83','\xf6'},
+    {'\x86','\xb6'},{'\xab','\xaa'},{'\x81','\xb6'},{'\xd1','\x48'},{'\xd1','\x49'},
+    {'\xae','\x45'},{'\xae','\x46'},{'\x00','\x00'},{'\x85','\xbe'},{'\xd4','\xac'},
+    {'\xb0','\xe9'},{'\xb0','\xeb'},{'\xd4','\xab'},{'\xb0','\xea'},{'\xd8','\x7c'},
+    {'\xb3','\xf2'},{'\x00','\x00'},{'\x92','\xb5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb6','\xe9'},{'\xb6','\xea'},{'\xdc','\xe1'},{'\x99','\x5f'},{'\xb9','\xcf'},
+    {'\x00','\x00'},{'\xb9','\xce'},{'\x00','\x00'},{'\xe5','\x49'},{'\xe9','\x48'},
+    {'\xe9','\x47'},{'\x99','\x60'},{'\xf9','\x6b'},{'\xa4','\x67'},{'\xc9','\x59'},
+    {'\x00','\x00'},{'\xc9','\x6e'},{'\xc9','\x6f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x94','\x65'},{'\x92','\x42'},{'\xa6','\x62'},{'\xa6','\x66'},{'\xc9','\xc9'},
+    {'\x00','\x00'},{'\xa6','\x64'},{'\xa6','\x63'},{'\xc9','\xc8'},{'\xa6','\x65'},
+    {'\xa6','\x61'},{'\x00','\x00'},{'\x99','\x61'},{'\xa6','\x60'},{'\xc9','\xca'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x94','\x66'},{'\x94','\x67'},{'\x8a','\xbf'},
+    {'\x84','\xd1'},{'\xa7','\xa6'},{'\x00','\x00'},{'\x99','\x62'},{'\xa7','\xa3'},
+    {'\x99','\x63'},{'\xa7','\x7d'},{'\xca','\xaa'},{'\x95','\xb5'},{'\x99','\x64'},
+    {'\x00','\x00'},{'\xca','\xab'},{'\xfb','\xe7'},{'\xa7','\xa1'},{'\x00','\x00'},
+    {'\xca','\xad'},{'\xa7','\x7b'},{'\xca','\xae'},{'\xca','\xac'},{'\xa7','\x7e'},
+    {'\xa7','\xa2'},{'\xa7','\xa5'},{'\xa7','\xa4'},{'\xa7','\x7c'},{'\xca','\xaf'},
+    {'\x00','\x00'},{'\xfe','\x6f'},{'\x00','\x00'},{'\x00','\x00'},{'\x85','\xc0'},
+    {'\x00','\x00'},{'\x81','\xb7'},{'\x83','\xf7'},{'\x88','\xd1'},{'\x8b','\x6f'},
+    {'\x8d','\x52'},{'\x85','\xc1'},{'\x87','\xb6'},{'\x87','\xb7'},{'\xa9','\x59'},
+    {'\xcb','\xfe'},{'\x00','\x00'},{'\xa9','\x5b'},{'\x81','\xb8'},{'\xa9','\x5a'},
+    {'\xfb','\xe9'},{'\xcc','\x40'},{'\xa9','\x58'},{'\xa9','\x57'},{'\xcb','\xf5'},
+    {'\x00','\x00'},{'\xcb','\xf4'},{'\x00','\x00'},{'\xcb','\xf2'},{'\xcb','\xf7'},
+    {'\xcb','\xf6'},{'\xcb','\xf3'},{'\xcb','\xfc'},{'\xcb','\xfd'},{'\xcb','\xfa'},
+    {'\xcb','\xf8'},{'\xa9','\x56'},{'\x00','\x00'},{'\x00','\x00'},{'\xfb','\xe8'},
+    {'\xcb','\xfb'},{'\xa9','\x5c'},{'\xcc','\x41'},{'\x99','\x66'},{'\x81','\xb9'},
+    {'\xcb','\xf9'},{'\x00','\x00'},{'\xab','\xab'},{'\xa9','\x55'},{'\x8b','\x6e'},
+    {'\x81','\xba'},{'\x8f','\xb8'},{'\x00','\x00'},{'\x94','\x68'},{'\x81','\xbb'},
+    {'\x99','\x67'},{'\xab','\xac'},{'\xce','\x54'},{'\x99','\x68'},{'\x00','\x00'},
+    {'\xce','\x5a'},{'\x99','\x69'},{'\x00','\x00'},{'\x8a','\xc0'},{'\xab','\xb2'},
+    {'\xce','\x58'},{'\xce','\x5e'},{'\x00','\x00'},{'\xce','\x55'},{'\xce','\x59'},
+    {'\xce','\x5b'},{'\xce','\x5d'},{'\xce','\x57'},{'\x99','\x6a'},{'\xce','\x56'},
+    {'\xce','\x51'},{'\xce','\x52'},{'\xab','\xad'},{'\x81','\xbc'},{'\xab','\xaf'},
+    {'\xab','\xae'},{'\xce','\x53'},{'\xce','\x5c'},{'\x88','\xd0'},{'\x8d','\xb6'},
+    {'\x00','\x00'},{'\x83','\xf8'},{'\x94','\x6a'},{'\x86','\xb8'},{'\x81','\xbd'},
+    {'\x8d','\xcb'},{'\xab','\xb1'},{'\x00','\x00'},{'\x94','\x6b'},{'\x00','\x00'},
+    {'\x8e','\x42'},{'\x94','\x69'},{'\x81','\xbe'},{'\xce','\x50'},{'\xd1','\x53'},
+    {'\x00','\x00'},{'\xd1','\x52'},{'\xd1','\x57'},{'\xd1','\x4e'},{'\x99','\x6b'},
+    {'\xd1','\x51'},{'\xd1','\x50'},{'\x99','\x6c'},{'\xd1','\x54'},{'\x81','\xbf'},
+    {'\xd1','\x58'},{'\xae','\x47'},{'\xae','\x4a'},{'\x99','\x6d'},{'\x00','\x00'},
+    {'\xd1','\x4f'},{'\xd1','\x55'},{'\x81','\xc0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xae','\x49'},{'\xd1','\x4a'},{'\x00','\x00'},{'\xab','\xb0'},{'\xd4','\xba'},
+    {'\xd1','\x56'},{'\x00','\x00'},{'\xd1','\x4d'},{'\x81','\xc1'},{'\xae','\x48'},
+    {'\xd1','\x4c'},{'\x94','\x6c'},{'\xfe','\x49'},{'\x85','\xc2'},{'\x89','\xce'},
+    {'\x84','\xd3'},{'\x00','\x00'},{'\xd4','\xb1'},{'\xfb','\xec'},{'\x99','\x6e'},
+    {'\xb0','\xec'},{'\xb0','\xf0'},{'\xd4','\xc1'},{'\xd4','\xaf'},{'\xd4','\xbd'},
+    {'\xb0','\xf1'},{'\xd4','\xbf'},{'\xfb','\xeb'},{'\xd4','\xc5'},{'\x00','\x00'},
+    {'\xd4','\xc9'},{'\x00','\x00'},{'\x00','\x00'},{'\xd4','\xc0'},{'\xd4','\xb4'},
+    {'\xd4','\xbc'},{'\x81','\xc2'},{'\xd4','\xca'},{'\xd4','\xc8'},{'\xd4','\xbe'},
+    {'\xd4','\xb9'},{'\xd4','\xb2'},{'\xd8','\xa6'},{'\xd4','\xb0'},{'\xb0','\xf5'},
+    {'\xd4','\xb7'},{'\xb0','\xf6'},{'\xb0','\xf2'},{'\xd4','\xad'},{'\xd4','\xc3'},
+    {'\xd4','\xb5'},{'\x99','\x6f'},{'\x00','\x00'},{'\xd4','\xb3'},{'\xd4','\xc6'},
+    {'\xb0','\xf3'},{'\x95','\x4a'},{'\xd4','\xcc'},{'\xb0','\xed'},{'\xb0','\xef'},
+    {'\xd4','\xbb'},{'\xd4','\xb6'},{'\xae','\x4b'},{'\xb0','\xee'},{'\xd4','\xb8'},
+    {'\xd4','\xc7'},{'\xd4','\xcb'},{'\xd4','\xc2'},{'\x00','\x00'},{'\xd4','\xc4'},
+    {'\x86','\xb9'},{'\x99','\x70'},{'\x00','\x00'},{'\xd4','\xae'},{'\x87','\xb8'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xd8','\xa1'},{'\x00','\x00'},
+    {'\xd8','\xaa'},{'\xd8','\xa9'},{'\xb3','\xfa'},{'\xd8','\xa2'},{'\x00','\x00'},
+    {'\xb3','\xfb'},{'\xb3','\xf9'},{'\x99','\x71'},{'\xd8','\xa4'},{'\xb3','\xf6'},
+    {'\xd8','\xa8'},{'\xfb','\xef'},{'\xd8','\xa3'},{'\xd8','\xa5'},{'\xd8','\x7d'},
+    {'\xb3','\xf4'},{'\x00','\x00'},{'\xd8','\xb2'},{'\xd8','\xb1'},{'\xd8','\xae'},
+    {'\xb3','\xf3'},{'\xb3','\xf7'},{'\xb3','\xf8'},{'\xd1','\x4b'},{'\xd8','\xab'},
+    {'\xb3','\xf5'},{'\xb0','\xf4'},{'\xd8','\xad'},{'\xd8','\x7e'},{'\xd8','\xb0'},
+    {'\xd8','\xaf'},{'\xfb','\xea'},{'\xd8','\xb3'},{'\x00','\x00'},{'\xdc','\xef'},
+    {'\x00','\x00'},{'\xd8','\xac'},{'\x94','\x59'},{'\x93','\xe9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x81','\xc3'},{'\x00','\x00'},{'\x00','\x00'},{'\x99','\x72'},
+    {'\xd8','\xa7'},{'\xdc','\xe7'},{'\xb6','\xf4'},{'\xb6','\xf7'},{'\xb6','\xf2'},
+    {'\xdc','\xe6'},{'\xdc','\xea'},{'\xdc','\xe5'},{'\x00','\x00'},{'\xb6','\xec'},
+    {'\xb6','\xf6'},{'\xdc','\xe2'},{'\xb6','\xf0'},{'\xdc','\xe9'},{'\x00','\x00'},
+    {'\xb6','\xee'},{'\xb6','\xed'},{'\xdc','\xec'},{'\xb6','\xef'},{'\xdc','\xee'},
+    {'\x99','\x73'},{'\xdc','\xeb'},{'\xb6','\xeb'},{'\x99','\x74'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xb6','\xf5'},{'\xdc','\xf0'},{'\xdc','\xe4'},{'\xdc','\xed'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xdc','\xe3'},{'\x95','\xcd'},{'\x00','\x00'},
+    {'\xb6','\xf1'},{'\x81','\xc4'},{'\xb6','\xf3'},{'\x00','\x00'},{'\xdc','\xe8'},
+    {'\x94','\x6d'},{'\xdc','\xf1'},{'\x95','\x62'},{'\x99','\x75'},{'\xe1','\x5d'},
+    {'\xb9','\xd0'},{'\xe1','\x63'},{'\x00','\x00'},{'\x00','\x00'},{'\xb9','\xd5'},
+    {'\xe1','\x5f'},{'\xe1','\x66'},{'\xe1','\x57'},{'\xb9','\xd7'},{'\xb9','\xd1'},
+    {'\xe1','\x5c'},{'\xbc','\x55'},{'\xe1','\x5b'},{'\xe1','\x64'},{'\xb9','\xd2'},
+    {'\x00','\x00'},{'\xb9','\xd6'},{'\xe1','\x5a'},{'\xe1','\x60'},{'\xe1','\x65'},
+    {'\xe1','\x56'},{'\xb9','\xd4'},{'\xe1','\x5e'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe1','\x62'},{'\xe1','\x68'},{'\xe1','\x58'},{'\xe1','\x61'},{'\x81','\xc5'},
+    {'\xb9','\xd3'},{'\xe1','\x67'},{'\x00','\x00'},{'\x00','\x00'},{'\x93','\x5e'},
+    {'\xe1','\x59'},{'\x89','\xf5'},{'\x81','\xc6'},{'\x00','\x00'},{'\xbc','\x59'},
+    {'\xe5','\x4b'},{'\xbc','\x57'},{'\xbc','\x56'},{'\xe5','\x4d'},{'\xe5','\x52'},
+    {'\x00','\x00'},{'\xe5','\x4e'},{'\x00','\x00'},{'\xe5','\x51'},{'\xbc','\x5c'},
+    {'\x99','\x76'},{'\xbe','\xa5'},{'\xbc','\x5b'},{'\x99','\x77'},{'\xe5','\x4a'},
+    {'\xe5','\x50'},{'\x00','\x00'},{'\xbc','\x5a'},{'\xe5','\x4f'},{'\x99','\x78'},
+    {'\xe5','\x4c'},{'\x81','\xc7'},{'\xbc','\x58'},{'\x00','\x00'},{'\x99','\x79'},
+    {'\x99','\x7a'},{'\x00','\x00'},{'\x81','\xc8'},{'\x94','\x6e'},{'\xe9','\x4d'},
+    {'\xf9','\xd9'},{'\xe9','\x4f'},{'\xe9','\x4a'},{'\xbe','\xc1'},{'\xe9','\x4c'},
+    {'\x00','\x00'},{'\xbe','\xc0'},{'\xe9','\x4e'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xbe','\xc3'},{'\xe9','\x50'},{'\xbe','\xc2'},{'\xe9','\x49'},{'\xe9','\x4b'},
+    {'\x92','\x5c'},{'\x99','\x7b'},{'\x92','\xee'},{'\x00','\x00'},{'\xc0','\xa5'},
+    {'\xec','\xcc'},{'\x99','\x7c'},{'\xc0','\xa4'},{'\xec','\xcd'},{'\xc0','\xa3'},
+    {'\xec','\xcb'},{'\xc0','\xa2'},{'\xec','\xca'},{'\x94','\x6f'},{'\xc2','\x53'},
+    {'\xc2','\x52'},{'\xf1','\xf6'},{'\xf1','\xf8'},{'\xfb','\xf0'},{'\xf1','\xf7'},
+    {'\xc3','\x61'},{'\xc3','\x62'},{'\x99','\x7d'},{'\x00','\x00'},{'\xc3','\x63'},
+    {'\xf4','\x42'},{'\xc4','\x5b'},{'\x81','\xc9'},{'\x00','\x00'},{'\xf7','\xd3'},
+    {'\xf7','\xd2'},{'\xc5','\xf2'},{'\x00','\x00'},{'\xa4','\x68'},{'\xa4','\xd0'},
+    {'\x00','\x00'},{'\x83','\x47'},{'\xa7','\xa7'},{'\x8a','\x52'},{'\x92','\x45'},
+    {'\x93','\xb3'},{'\x84','\xea'},{'\xce','\x5f'},{'\x00','\x00'},{'\x84','\xd4'},
+    {'\x82','\x41'},{'\x00','\x00'},{'\xb3','\xfc'},{'\xb3','\xfd'},{'\x81','\xca'},
+    {'\xdc','\xf2'},{'\xb9','\xd8'},{'\xe1','\x69'},{'\xe5','\x53'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x81','\xcb'},{'\xc9','\x5a'},{'\x84','\x7a'},{'\x99','\x7e'},
+    {'\xca','\xb0'},{'\x84','\xc2'},{'\x00','\x00'},{'\x93','\xc4'},{'\xc6','\xca'},
+    {'\x81','\xcc'},{'\xcc','\x42'},{'\xce','\x60'},{'\xd1','\x59'},{'\xae','\x4c'},
+    {'\x81','\xcd'},{'\x99','\xa1'},{'\xf1','\xf9'},{'\x00','\x00'},{'\xc4','\xdc'},
+    {'\xa4','\x69'},{'\xa5','\x7e'},{'\xc9','\x70'},{'\x81','\xce'},{'\xa6','\x67'},
+    {'\xa6','\x68'},{'\x81','\xcf'},{'\xa9','\x5d'},{'\x9d','\x58'},{'\x00','\x00'},
+    {'\x83','\xfa'},{'\xb0','\xf7'},{'\x00','\x00'},{'\xb9','\xda'},{'\x00','\x00'},
+    {'\xb9','\xdb'},{'\xb9','\xd9'},{'\x00','\x00'},{'\xa4','\x6a'},{'\x00','\x00'},
+    {'\xa4','\xd1'},{'\xa4','\xd3'},{'\xa4','\xd2'},{'\xc9','\x5b'},{'\xa4','\xd4'},
+    {'\xa5','\xa1'},{'\xc9','\x71'},{'\x00','\x00'},{'\xa5','\xa2'},{'\x82','\xb5'},
+    {'\x00','\x00'},{'\x89','\xb3'},{'\x00','\x00'},{'\x00','\x00'},{'\xa6','\x69'},
+    {'\xa6','\x6a'},{'\x83','\x48'},{'\x86','\xbc'},{'\x00','\x00'},{'\xc9','\xcb'},
+    {'\x00','\x00'},{'\xa7','\xa8'},{'\x00','\x00'},{'\xca','\xb1'},{'\x86','\xbd'},
+    {'\x83','\x6b'},{'\x00','\x00'},{'\xa9','\x61'},{'\xcc','\x43'},{'\x00','\x00'},
+    {'\xa9','\x5f'},{'\xa9','\x60'},{'\xa9','\x5e'},{'\xd1','\x5a'},{'\x88','\xd2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xab','\xb6'},{'\xab','\xb5'},{'\xab','\xb7'},
+    {'\xab','\xb4'},{'\x00','\x00'},{'\xce','\x61'},{'\xa9','\x62'},{'\xab','\xb3'},
+    {'\x87','\xf2'},{'\xae','\x4d'},{'\xae','\x4e'},{'\x00','\x00'},{'\xae','\x4f'},
+    {'\x82','\xb6'},{'\xd4','\xcd'},{'\x82','\xb7'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb3','\xfe'},{'\xd8','\xb4'},{'\xb0','\xf8'},{'\x82','\xb8'},{'\x00','\x00'},
+    {'\x85','\xc4'},{'\x00','\x00'},{'\xb6','\xf8'},{'\x92','\xe6'},{'\xb9','\xdd'},
+    {'\xb9','\xdc'},{'\xe1','\x6a'},{'\x82','\xb9'},{'\xbc','\x5d'},{'\xbe','\xc4'},
+    {'\x00','\x00'},{'\xef','\xc0'},{'\xf6','\xda'},{'\xf7','\xd4'},{'\xa4','\x6b'},
+    {'\xa5','\xa3'},{'\xfe','\x66'},{'\xa5','\xa4'},{'\xc9','\xd1'},{'\xa6','\x6c'},
+    {'\xa6','\x6f'},{'\x00','\x00'},{'\xc9','\xcf'},{'\xc9','\xcd'},{'\xa6','\x6e'},
+    {'\xc9','\xd0'},{'\xc9','\xd2'},{'\xc9','\xcc'},{'\xa6','\x71'},{'\xa6','\x70'},
+    {'\xa6','\x6d'},{'\xa6','\x6b'},{'\xc9','\xce'},{'\x83','\x49'},{'\x83','\xfc'},
+    {'\x85','\xc5'},{'\x99','\xa2'},{'\xa7','\xb3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xa7','\xb0'},{'\xca','\xb6'},{'\xca','\xb9'},{'\xca','\xb8'},{'\x00','\x00'},
+    {'\xa7','\xaa'},{'\xa7','\xb2'},{'\x99','\xa3'},{'\x00','\x00'},{'\xa7','\xaf'},
+    {'\xca','\xb5'},{'\xca','\xb3'},{'\xa7','\xae'},{'\x99','\xa4'},{'\x82','\xba'},
+    {'\x00','\x00'},{'\xa7','\xa9'},{'\xa7','\xac'},{'\x99','\xa5'},{'\xca','\xb4'},
+    {'\xca','\xbb'},{'\xca','\xb7'},{'\xa7','\xad'},{'\xa7','\xb1'},{'\xa7','\xb4'},
+    {'\xca','\xb2'},{'\xca','\xba'},{'\xa7','\xab'},{'\x87','\xbb'},{'\x86','\xbe'},
+    {'\x8d','\xdb'},{'\x95','\xa5'},{'\x00','\x00'},{'\xa9','\x67'},{'\xa9','\x6f'},
+    {'\x99','\xa6'},{'\xcc','\x4f'},{'\xcc','\x48'},{'\xa9','\x70'},{'\xcc','\x53'},
+    {'\xcc','\x44'},{'\xcc','\x4b'},{'\xfb','\xf1'},{'\x99','\xa7'},{'\xa9','\x66'},
+    {'\xcc','\x45'},{'\xa9','\x64'},{'\xcc','\x4c'},{'\xcc','\x50'},{'\xa9','\x63'},
+    {'\x9b','\x40'},{'\xcc','\x51'},{'\xcc','\x4a'},{'\x00','\x00'},{'\xcc','\x4d'},
+    {'\x99','\xa8'},{'\xa9','\x72'},{'\xa9','\x69'},{'\xcc','\x54'},{'\xcc','\x52'},
+    {'\x93','\xfc'},{'\xa9','\x6e'},{'\xa9','\x6c'},{'\xcc','\x49'},{'\xa9','\x6b'},
+    {'\xcc','\x47'},{'\xcc','\x46'},{'\xa9','\x6a'},{'\xa9','\x68'},{'\xa9','\x71'},
+    {'\xa9','\x6d'},{'\xa9','\x65'},{'\x00','\x00'},{'\xcc','\x4e'},{'\x82','\xbb'},
+    {'\xab','\xb9'},{'\xfb','\xf2'},{'\xab','\xc0'},{'\xce','\x6f'},{'\xab','\xb8'},
+    {'\xce','\x67'},{'\xce','\x63'},{'\x00','\x00'},{'\xce','\x73'},{'\xce','\x62'},
+    {'\x00','\x00'},{'\xab','\xbb'},{'\xce','\x6c'},{'\xab','\xbe'},{'\xab','\xc1'},
+    {'\x00','\x00'},{'\xab','\xbc'},{'\xce','\x70'},{'\xab','\xbf'},{'\x82','\xbc'},
+    {'\xae','\x56'},{'\xce','\x76'},{'\xce','\x64'},{'\x99','\xa9'},{'\x99','\xaa'},
+    {'\xce','\x66'},{'\xce','\x6d'},{'\xce','\x71'},{'\xce','\x75'},{'\xce','\x72'},
+    {'\xce','\x6b'},{'\xce','\x6e'},{'\x99','\xab'},{'\x95','\xc0'},{'\xce','\x68'},
+    {'\xab','\xc3'},{'\xce','\x6a'},{'\xce','\x69'},{'\xce','\x74'},{'\xab','\xba'},
+    {'\xce','\x65'},{'\xab','\xc2'},{'\x99','\xac'},{'\xab','\xbd'},{'\x83','\xfb'},
+    {'\x8d','\xcc'},{'\x87','\xbd'},{'\x87','\xbc'},{'\x90','\x55'},{'\xae','\x5c'},
+    {'\xd1','\x62'},{'\x99','\xad'},{'\xae','\x5b'},{'\x99','\xae'},{'\x00','\x00'},
+    {'\xd1','\x60'},{'\x00','\x00'},{'\xae','\x50'},{'\x99','\xaf'},{'\xae','\x55'},
+    {'\x00','\x00'},{'\xd1','\x5f'},{'\xd1','\x5c'},{'\xd1','\x61'},{'\xae','\x51'},
+    {'\xd1','\x5b'},{'\x82','\xbd'},{'\xae','\x54'},{'\xae','\x52'},{'\x00','\x00'},
+    {'\xd1','\x63'},{'\xae','\x53'},{'\xae','\x57'},{'\x99','\xb0'},{'\x00','\x00'},
+    {'\xae','\x58'},{'\x99','\xb1'},{'\xae','\x5a'},{'\x00','\x00'},{'\x99','\xb2'},
+    {'\x00','\x00'},{'\xae','\x59'},{'\x99','\xb3'},{'\x99','\xb4'},{'\x99','\xb5'},
+    {'\xd1','\x5d'},{'\xd1','\x5e'},{'\x92','\xbc'},{'\x00','\x00'},{'\x83','\xb1'},
+    {'\x84','\xd5'},{'\xd1','\x64'},{'\x87','\xb9'},{'\xd4','\xd4'},{'\xb0','\xf9'},
+    {'\xd8','\xc2'},{'\xd4','\xd3'},{'\xd4','\xe6'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb1','\x40'},{'\x99','\xb6'},{'\xd4','\xe4'},{'\x00','\x00'},{'\xb0','\xfe'},
+    {'\xb0','\xfa'},{'\xd4','\xed'},{'\xd4','\xdd'},{'\xd4','\xe0'},{'\x99','\xb7'},
+    {'\xb1','\x43'},{'\xd4','\xea'},{'\xd4','\xe2'},{'\xb0','\xfb'},{'\xb1','\x44'},
+    {'\x00','\x00'},{'\xd4','\xe7'},{'\xd4','\xe5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xd4','\xd6'},{'\xd4','\xeb'},{'\xd4','\xdf'},{'\xd4','\xda'},{'\x99','\xb8'},
+    {'\xd4','\xd0'},{'\xd4','\xec'},{'\xd4','\xdc'},{'\xd4','\xcf'},{'\x99','\xb9'},
+    {'\xb1','\x42'},{'\xd4','\xe1'},{'\xd4','\xee'},{'\xd4','\xde'},{'\xd4','\xd2'},
+    {'\xd4','\xd7'},{'\xd4','\xce'},{'\x99','\xba'},{'\xb1','\x41'},{'\x95','\x63'},
+    {'\xd4','\xdb'},{'\xd4','\xd8'},{'\xb0','\xfc'},{'\xd4','\xd1'},{'\x99','\xbb'},
+    {'\xd4','\xe9'},{'\xb0','\xfd'},{'\x99','\xbc'},{'\xd4','\xd9'},{'\xd4','\xd5'},
+    {'\x99','\xbd'},{'\x00','\x00'},{'\xd4','\xe8'},{'\x99','\xbe'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x89','\xcf'},{'\x87','\xba'},{'\x8a','\xc1'},{'\xb4','\x40'},
+    {'\xd8','\xbb'},{'\x99','\xbf'},{'\xd8','\xb8'},{'\xd8','\xc9'},{'\xd8','\xbd'},
+    {'\xd8','\xca'},{'\x99','\xc0'},{'\xb4','\x42'},{'\x00','\x00'},{'\x99','\xc1'},
+    {'\x99','\xc2'},{'\xd8','\xc6'},{'\xd8','\xc3'},{'\x00','\x00'},{'\x99','\xc3'},
+    {'\x00','\x00'},{'\x99','\xc4'},{'\x00','\x00'},{'\xd8','\xc4'},{'\xd8','\xc7'},
+    {'\xd8','\xcb'},{'\x00','\x00'},{'\xd4','\xe3'},{'\xd8','\xcd'},{'\xdd','\x47'},
+    {'\x99','\xc5'},{'\xb4','\x43'},{'\xd8','\xce'},{'\xd8','\xb6'},{'\xd8','\xc0'},
+    {'\xfe','\x78'},{'\xd8','\xc5'},{'\x00','\x00'},{'\x99','\xc6'},{'\xb4','\x41'},
+    {'\xb4','\x44'},{'\xd8','\xcc'},{'\xd8','\xcf'},{'\xd8','\xba'},{'\xd8','\xb7'},
+    {'\x99','\xc7'},{'\x99','\xc8'},{'\xd8','\xb9'},{'\x00','\x00'},{'\x9c','\x70'},
+    {'\xd8','\xbe'},{'\xd8','\xbc'},{'\xb4','\x45'},{'\x00','\x00'},{'\xd8','\xc8'},
+    {'\x82','\xbe'},{'\x99','\xc9'},{'\xd8','\xbf'},{'\x00','\x00'},{'\xd8','\xc1'},
+    {'\xd8','\xb5'},{'\xdc','\xfa'},{'\xdc','\xf8'},{'\xb7','\x42'},{'\xb7','\x40'},
+    {'\xdd','\x43'},{'\xdc','\xf9'},{'\xdd','\x44'},{'\xdd','\x40'},{'\xdc','\xf7'},
+    {'\xdd','\x46'},{'\xdc','\xf6'},{'\xdc','\xfd'},{'\xb6','\xfe'},{'\xb6','\xfd'},
+    {'\xb6','\xfc'},{'\xdc','\xfb'},{'\xdd','\x41'},{'\xb6','\xf9'},{'\xb7','\x41'},
+    {'\x99','\xca'},{'\xdc','\xf4'},{'\x00','\x00'},{'\xdc','\xfe'},{'\xdc','\xf3'},
+    {'\xdc','\xfc'},{'\xb6','\xfa'},{'\xdd','\x42'},{'\xdc','\xf5'},{'\xb6','\xfb'},
+    {'\xdd','\x45'},{'\x99','\xcb'},{'\x99','\xcc'},{'\x82','\xbf'},{'\x9d','\x67'},
+    {'\x8e','\xe5'},{'\x99','\xcd'},{'\x89','\xd0'},{'\xe1','\x6e'},{'\xb9','\xe2'},
+    {'\xb9','\xe1'},{'\xb9','\xe3'},{'\xe1','\x7a'},{'\xe1','\x70'},{'\xe1','\x76'},
+    {'\xe1','\x6b'},{'\xe1','\x79'},{'\xe1','\x78'},{'\xe1','\x7c'},{'\xe1','\x75'},
+    {'\xb9','\xde'},{'\xe1','\x74'},{'\xb9','\xe4'},{'\x99','\xce'},{'\xe1','\x6d'},
+    {'\xb9','\xdf'},{'\x00','\x00'},{'\xe1','\x7b'},{'\xb9','\xe0'},{'\xe1','\x6f'},
+    {'\xe1','\x72'},{'\xe1','\x77'},{'\xe1','\x71'},{'\xe1','\x6c'},{'\x00','\x00'},
+    {'\x99','\xcf'},{'\x82','\xc0'},{'\xfb','\x67'},{'\xe1','\x73'},{'\xe5','\x55'},
+    {'\xbc','\x61'},{'\xe5','\x58'},{'\xe5','\x57'},{'\xe5','\x5a'},{'\xe5','\x5c'},
+    {'\xf9','\xdc'},{'\xbc','\x5f'},{'\x00','\x00'},{'\xe5','\x56'},{'\x99','\xd0'},
+    {'\xe5','\x54'},{'\x00','\x00'},{'\xe5','\x5d'},{'\xe5','\x5b'},{'\xe5','\x59'},
+    {'\x00','\x00'},{'\xe5','\x5f'},{'\x00','\x00'},{'\xe5','\x5e'},{'\xbc','\x63'},
+    {'\xbc','\x5e'},{'\x00','\x00'},{'\xbc','\x60'},{'\xbc','\x62'},{'\x99','\xd1'},
+    {'\x00','\x00'},{'\xe5','\x60'},{'\xe9','\x57'},{'\x99','\xd2'},{'\x00','\x00'},
+    {'\xe9','\x56'},{'\xe9','\x55'},{'\x99','\xd3'},{'\xe9','\x58'},{'\xe9','\x51'},
+    {'\x00','\x00'},{'\xe9','\x52'},{'\xe9','\x5a'},{'\xe9','\x53'},{'\x00','\x00'},
+    {'\xbe','\xc5'},{'\xe9','\x5c'},{'\x99','\xd4'},{'\xe9','\x5b'},{'\xe9','\x54'},
+    {'\x92','\xef'},{'\xec','\xd1'},{'\xc0','\xa8'},{'\xec','\xcf'},{'\xec','\xd4'},
+    {'\xec','\xd3'},{'\xe9','\x59'},{'\x00','\x00'},{'\xc0','\xa7'},{'\x99','\xd5'},
+    {'\xec','\xd2'},{'\xec','\xce'},{'\xec','\xd6'},{'\xec','\xd5'},{'\xc0','\xa6'},
+    {'\x00','\x00'},{'\xec','\xd0'},{'\x00','\x00'},{'\xbe','\xc6'},{'\x00','\x00'},
+    {'\x82','\xc1'},{'\x89','\xd1'},{'\xc2','\x54'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xef','\xc1'},{'\xf1','\xfa'},{'\xf1','\xfb'},{'\xf1','\xfc'},
+    {'\xc4','\x5c'},{'\x99','\xd6'},{'\x00','\x00'},{'\xc4','\x5d'},{'\x99','\xd7'},
+    {'\xf4','\x43'},{'\x99','\xd8'},{'\xf5','\xc8'},{'\xf5','\xc7'},{'\x00','\x00'},
+    {'\x99','\xd9'},{'\xf6','\xdb'},{'\xf6','\xdc'},{'\xf7','\xd5'},{'\xf8','\xa7'},
+    {'\x99','\xda'},{'\xa4','\x6c'},{'\xa4','\x6d'},{'\x00','\x00'},{'\xa4','\x6e'},
+    {'\xa4','\xd5'},{'\xa5','\xa5'},{'\xc9','\xd3'},{'\xa6','\x72'},{'\xa6','\x73'},
+    {'\x83','\xb2'},{'\xa7','\xb7'},{'\xa7','\xb8'},{'\xa7','\xb6'},{'\xa7','\xb5'},
+    {'\x00','\x00'},{'\xa9','\x73'},{'\x00','\x00'},{'\x00','\x00'},{'\xcc','\x55'},
+    {'\xa9','\x75'},{'\xa9','\x74'},{'\xcc','\x56'},{'\x88','\xd4'},{'\x00','\x00'},
+    {'\x99','\xdb'},{'\xab','\xc4'},{'\x8c','\xcb'},{'\xae','\x5d'},{'\xd1','\x65'},
+    {'\xa0','\x41'},{'\xd4','\xf0'},{'\x00','\x00'},{'\xb1','\x45'},{'\xb4','\x47'},
+    {'\xd4','\xef'},{'\xb4','\x46'},{'\x99','\xdc'},{'\xb9','\xe5'},{'\x99','\xdd'},
+    {'\xe1','\x7d'},{'\xbe','\xc7'},{'\x00','\x00'},{'\xc0','\xa9'},{'\xec','\xd7'},
+    {'\x99','\xde'},{'\xc4','\x5e'},{'\x00','\x00'},{'\xc5','\x70'},{'\xc6','\xcb'},
+    {'\xc9','\x72'},{'\x99','\xdf'},{'\xa5','\xa6'},{'\xc9','\x73'},{'\xa6','\x76'},
+    {'\x00','\x00'},{'\xa6','\x74'},{'\xa6','\x75'},{'\xa6','\x77'},{'\x00','\x00'},
+    {'\xa7','\xba'},{'\xa7','\xb9'},{'\x93','\xfd'},{'\xca','\xbc'},{'\xa7','\xbb'},
+    {'\x99','\xe0'},{'\x00','\x00'},{'\xca','\xbd'},{'\xcc','\x57'},{'\x00','\x00'},
+    {'\xcc','\x58'},{'\x9a','\x40'},{'\xa9','\x76'},{'\xa9','\x78'},{'\xa9','\x7a'},
+    {'\xa9','\x77'},{'\xa9','\x7b'},{'\xa9','\x79'},{'\x8b','\xf3'},{'\x86','\xbf'},
+    {'\x92','\xd4'},{'\x8b','\x70'},{'\x87','\xbf'},{'\xab','\xc8'},{'\xab','\xc5'},
+    {'\xab','\xc7'},{'\xab','\xc9'},{'\xab','\xc6'},{'\xd1','\x66'},{'\xce','\x77'},
+    {'\x00','\x00'},{'\x88','\xd6'},{'\x90','\xb3'},{'\xd1','\x68'},{'\xd1','\x67'},
+    {'\xae','\x63'},{'\x00','\x00'},{'\xae','\x5f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xae','\x60'},{'\xae','\x62'},{'\xae','\x64'},{'\xae','\x61'},{'\x9d','\x68'},
+    {'\xae','\x66'},{'\xae','\x65'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x87','\xbe'},{'\x87','\x59'},{'\xb1','\x4a'},{'\xd4','\xf2'},{'\xd4','\xf1'},
+    {'\xb1','\x49'},{'\xfc','\x43'},{'\xb1','\x48'},{'\xb1','\x47'},{'\xb1','\x4b'},
+    {'\xb1','\x46'},{'\x00','\x00'},{'\x82','\xc2'},{'\xd8','\xd5'},{'\xd8','\xd2'},
+    {'\xb4','\x49'},{'\xd8','\xd1'},{'\xd8','\xd6'},{'\x00','\x00'},{'\xb4','\x4b'},
+    {'\xd8','\xd4'},{'\xb4','\x48'},{'\xb4','\x4a'},{'\xd8','\xd3'},{'\x9a','\x55'},
+    {'\xdd','\x48'},{'\x9a','\x56'},{'\xdd','\x49'},{'\xdd','\x4a'},{'\x00','\x00'},
+    {'\x92','\x69'},{'\x00','\x00'},{'\x86','\xc0'},{'\xb9','\xe6'},{'\xb9','\xee'},
+    {'\xe1','\x7e'},{'\xb9','\xe8'},{'\xb9','\xec'},{'\xe1','\xa1'},{'\xb9','\xed'},
+    {'\xb9','\xe9'},{'\xb9','\xea'},{'\xb9','\xe7'},{'\xb9','\xeb'},{'\xbc','\x66'},
+    {'\xd8','\xd0'},{'\xbc','\x67'},{'\xbc','\x65'},{'\x00','\x00'},{'\xbc','\x64'},
+    {'\xe9','\x5d'},{'\xbe','\xc8'},{'\xec','\xd8'},{'\xec','\xd9'},{'\x82','\xc3'},
+    {'\x00','\x00'},{'\xc3','\x64'},{'\xc4','\x5f'},{'\x00','\x00'},{'\xa4','\x6f'},
+    {'\x86','\xc1'},{'\xa6','\x78'},{'\x84','\xd6'},{'\x88','\xd5'},{'\x00','\x00'},
+    {'\x93','\x66'},{'\x86','\xba'},{'\x00','\x00'},{'\xab','\xca'},{'\x93','\x47'},
+    {'\xd1','\x69'},{'\xae','\x67'},{'\x95','\x5b'},{'\x92','\xe2'},{'\xb1','\x4e'},
+    {'\xb1','\x4d'},{'\xb1','\x4c'},{'\xb4','\x4c'},{'\xb4','\x4d'},{'\xd8','\xd7'},
+    {'\xb9','\xef'},{'\xbe','\xc9'},{'\xa4','\x70'},{'\xc9','\x5c'},{'\xa4','\xd6'},
+    {'\xc9','\x74'},{'\x82','\xc4'},{'\x86','\xe0'},{'\xc9','\xd4'},{'\xa6','\x79'},
+    {'\x00','\x00'},{'\x86','\xb7'},{'\x00','\x00'},{'\xa9','\x7c'},{'\x00','\x00'},
+    {'\x82','\xc5'},{'\x86','\xaf'},{'\x82','\xc6'},{'\xdd','\x4b'},{'\xfb','\xf3'},
+    {'\x00','\x00'},{'\xa4','\x71'},{'\x9a','\x57'},{'\xa4','\xd7'},{'\xc9','\xd5'},
+    {'\x00','\x00'},{'\x84','\xd0'},{'\xca','\xbe'},{'\x00','\x00'},{'\xca','\xbf'},
+    {'\x00','\x00'},{'\xa7','\xbc'},{'\x82','\x59'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xd8','\xd8'},{'\xb4','\x4e'},{'\x00','\x00'},{'\xdd','\x4c'},{'\x89','\xd2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc0','\xaa'},{'\xa4','\x72'},{'\xa4','\xa8'},
+    {'\xa4','\xd8'},{'\xc9','\x75'},{'\xa5','\xa7'},{'\x86','\xe9'},{'\xa7','\xc0'},
+    {'\xa7','\xbf'},{'\xa7','\xbd'},{'\xa7','\xbe'},{'\x87','\xc1'},{'\x00','\x00'},
+    {'\xcc','\x59'},{'\xa9','\x7e'},{'\xa9','\xa1'},{'\xcc','\x5a'},{'\xa9','\x7d'},
+    {'\x84','\x40'},{'\x83','\x57'},{'\xab','\xce'},{'\xce','\x78'},{'\xab','\xcd'},
+    {'\xab','\xcb'},{'\xab','\xcc'},{'\xae','\x6a'},{'\xae','\x68'},{'\x00','\x00'},
+    {'\x82','\xc7'},{'\xd1','\x6b'},{'\xae','\x69'},{'\xd1','\x6a'},{'\x00','\x00'},
+    {'\xae','\x5e'},{'\xd4','\xf3'},{'\x00','\x00'},{'\x00','\x00'},{'\xb1','\x50'},
+    {'\xb1','\x51'},{'\x8c','\x70'},{'\x00','\x00'},{'\xb1','\x4f'},{'\x86','\xc2'},
+    {'\xb9','\xf0'},{'\xe1','\xa2'},{'\xbc','\x68'},{'\xbc','\x69'},{'\x89','\xd3'},
+    {'\xe5','\x61'},{'\xc0','\xab'},{'\xef','\xc2'},{'\xef','\xc3'},{'\x00','\x00'},
+    {'\xc4','\xdd'},{'\xf8','\xa8'},{'\xc9','\x4b'},{'\xa4','\xd9'},{'\x00','\x00'},
+    {'\xa4','\x73'},{'\x00','\x00'},{'\xc9','\x77'},{'\xc9','\x76'},{'\x00','\x00'},
+    {'\x94','\x70'},{'\x00','\x00'},{'\x9d','\x64'},{'\xa6','\x7a'},{'\xc9','\xd7'},
+    {'\xc9','\xd8'},{'\xc9','\xd6'},{'\x00','\x00'},{'\xc9','\xd9'},{'\x89','\xd4'},
+    {'\x00','\x00'},{'\x85','\xd7'},{'\x83','\xdb'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9a','\x58'},{'\xca','\xc7'},{'\x00','\x00'},{'\xca','\xc2'},{'\xca','\xc4'},
+    {'\xca','\xc6'},{'\xca','\xc3'},{'\xa7','\xc4'},{'\xca','\xc0'},{'\x00','\x00'},
+    {'\xca','\xc1'},{'\xa7','\xc1'},{'\xa7','\xc2'},{'\xca','\xc5'},{'\xca','\xc8'},
+    {'\xa7','\xc3'},{'\xca','\xc9'},{'\x86','\xc4'},{'\x84','\x42'},{'\x83','\xb5'},
+    {'\x82','\xc8'},{'\x84','\xd7'},{'\x83','\xb4'},{'\x82','\xc9'},{'\xcc','\x68'},
+    {'\x9a','\x59'},{'\xcc','\x62'},{'\xcc','\x5d'},{'\xa9','\xa3'},{'\xcc','\x65'},
+    {'\xcc','\x63'},{'\xcc','\x5c'},{'\xcc','\x69'},{'\xcc','\x6c'},{'\xcc','\x67'},
+    {'\xcc','\x60'},{'\xa9','\xa5'},{'\xcc','\x66'},{'\xa9','\xa6'},{'\xcc','\x61'},
+    {'\xcc','\x64'},{'\xcc','\x5b'},{'\xcc','\x5f'},{'\xcc','\x6b'},{'\xa9','\xa7'},
+    {'\x00','\x00'},{'\xa9','\xa8'},{'\x00','\x00'},{'\xcc','\x5e'},{'\xcc','\x6a'},
+    {'\xa9','\xa2'},{'\xa9','\xa4'},{'\x00','\x00'},{'\x82','\xca'},{'\x82','\xcb'},
+    {'\x94','\x71'},{'\x8d','\xcd'},{'\x94','\x73'},{'\x8f','\xfc'},{'\x00','\x00'},
+    {'\x82','\xcc'},{'\x9a','\x5a'},{'\x00','\x00'},{'\x8e','\xe6'},{'\x94','\x72'},
+    {'\xce','\xab'},{'\xce','\xa4'},{'\xce','\xaa'},{'\xce','\xa3'},{'\xce','\xa5'},
+    {'\xce','\x7d'},{'\xce','\x7b'},{'\x00','\x00'},{'\xce','\xac'},{'\xce','\xa9'},
+    {'\xce','\x79'},{'\xfb','\xf5'},{'\xab','\xd0'},{'\xce','\xa7'},{'\xce','\xa8'},
+    {'\x9d','\x71'},{'\xce','\xa6'},{'\xce','\x7c'},{'\xce','\x7a'},{'\xab','\xcf'},
+    {'\xce','\xa2'},{'\xce','\x7e'},{'\x00','\x00'},{'\x00','\x00'},{'\xce','\xa1'},
+    {'\xce','\xad'},{'\x94','\x50'},{'\x83','\xb3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x8e','\xb4'},{'\x84','\x41'},{'\x8c','\xcd'},{'\x00','\x00'},{'\xae','\x6f'},
+    {'\xfb','\xf6'},{'\xae','\x6e'},{'\x00','\x00'},{'\xd1','\x6c'},{'\xae','\x6b'},
+    {'\xd1','\x6e'},{'\x95','\x5d'},{'\xae','\x70'},{'\xd1','\x6f'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xae','\x73'},{'\x82','\xcd'},{'\xae','\x71'},{'\xd1','\x70'},
+    {'\xce','\xae'},{'\xd1','\x72'},{'\x82','\xce'},{'\xae','\x6d'},{'\x9d','\x69'},
+    {'\xae','\x6c'},{'\x00','\x00'},{'\xd1','\x6d'},{'\xd1','\x71'},{'\xae','\x72'},
+    {'\x8e','\xb3'},{'\x8d','\xce'},{'\x00','\x00'},{'\x00','\x00'},{'\xb1','\x53'},
+    {'\xb1','\x52'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xd4','\xf5'},
+    {'\xd4','\xf9'},{'\xd4','\xfb'},{'\xb1','\x54'},{'\xd4','\xfe'},{'\x9a','\x5b'},
+    {'\xb1','\x58'},{'\xd5','\x41'},{'\x00','\x00'},{'\xb1','\x5a'},{'\x82','\xcf'},
+    {'\xb1','\x56'},{'\xb1','\x5e'},{'\x82','\xd0'},{'\xb1','\x5b'},{'\xd4','\xf7'},
+    {'\xb1','\x55'},{'\x00','\x00'},{'\xd4','\xf6'},{'\xd4','\xf4'},{'\xd5','\x43'},
+    {'\xd4','\xf8'},{'\x00','\x00'},{'\xb1','\x57'},{'\xd5','\x42'},{'\xb1','\x5c'},
+    {'\xd4','\xfd'},{'\xd4','\xfc'},{'\xb1','\x5d'},{'\xd4','\xfa'},{'\xb1','\x59'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9a','\x5c'},{'\x86','\xc3'},{'\xd5','\x44'},
+    {'\x9a','\x5d'},{'\xd5','\x40'},{'\xd8','\xe7'},{'\xd8','\xee'},{'\xd8','\xe3'},
+    {'\xb4','\x51'},{'\xd8','\xdf'},{'\xd8','\xef'},{'\xd8','\xd9'},{'\xd8','\xec'},
+    {'\xd8','\xea'},{'\xd8','\xe4'},{'\x00','\x00'},{'\xd8','\xed'},{'\xd8','\xe6'},
+    {'\x82','\xd1'},{'\xd8','\xde'},{'\xd8','\xf0'},{'\xd8','\xdc'},{'\xd8','\xe9'},
+    {'\xd8','\xda'},{'\x00','\x00'},{'\xd8','\xf1'},{'\xfb','\xf7'},{'\xb4','\x52'},
+    {'\x9a','\x5e'},{'\xd8','\xeb'},{'\xdd','\x4f'},{'\xd8','\xdd'},{'\xb4','\x4f'},
+    {'\x00','\x00'},{'\xd8','\xe1'},{'\x00','\x00'},{'\xb4','\x50'},{'\xd8','\xe0'},
+    {'\xd8','\xe5'},{'\x82','\xd2'},{'\x00','\x00'},{'\xd8','\xe2'},{'\x9a','\x5f'},
+    {'\x95','\x65'},{'\x89','\xd5'},{'\xd8','\xe8'},{'\x00','\x00'},{'\x8d','\xdc'},
+    {'\x82','\xd3'},{'\x8e','\x67'},{'\xdd','\x53'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xdd','\x56'},{'\xdd','\x4e'},{'\x00','\x00'},{'\xdd','\x50'},
+    {'\x00','\x00'},{'\xdd','\x55'},{'\xdd','\x54'},{'\xb7','\x43'},{'\x00','\x00'},
+    {'\xd8','\xdb'},{'\xdd','\x52'},{'\x82','\xd4'},{'\x00','\x00'},{'\xb7','\x44'},
+    {'\x9a','\x60'},{'\xdd','\x4d'},{'\xdd','\x51'},{'\x82','\xd5'},{'\x82','\xd6'},
+    {'\xfe','\x7e'},{'\x94','\x74'},{'\xe1','\xa9'},{'\x9d','\x7a'},{'\xe1','\xb0'},
+    {'\xe1','\xa7'},{'\x9a','\x61'},{'\xe1','\xae'},{'\xe1','\xa5'},{'\xe1','\xad'},
+    {'\xe1','\xb1'},{'\xe1','\xa4'},{'\xe1','\xa8'},{'\xe1','\xa3'},{'\x00','\x00'},
+    {'\xb9','\xf1'},{'\x9a','\x62'},{'\xe1','\xa6'},{'\xb9','\xf2'},{'\xe1','\xac'},
+    {'\xe1','\xab'},{'\xe1','\xaa'},{'\x93','\xfe'},{'\x82','\xd7'},{'\xe1','\xaf'},
+    {'\xfb','\xf8'},{'\x00','\x00'},{'\x82','\xd8'},{'\x00','\x00'},{'\xe5','\x65'},
+    {'\xe5','\x67'},{'\xbc','\x6b'},{'\xe5','\x68'},{'\x00','\x00'},{'\xe5','\x63'},
+    {'\x00','\x00'},{'\xe5','\x62'},{'\xe5','\x6c'},{'\x00','\x00'},{'\xe5','\x6a'},
+    {'\xbc','\x6a'},{'\xe5','\x6d'},{'\xe5','\x64'},{'\xe5','\x69'},{'\xe5','\x6b'},
+    {'\xe5','\x66'},{'\x00','\x00'},{'\x9a','\x63'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe9','\x61'},{'\xe9','\x66'},{'\xe9','\x60'},{'\xe9','\x65'},{'\x9a','\x64'},
+    {'\xe9','\x5e'},{'\xe9','\x68'},{'\xe9','\x64'},{'\xe9','\x69'},{'\xe9','\x63'},
+    {'\xe9','\x5f'},{'\xe9','\x67'},{'\x00','\x00'},{'\xe9','\x6a'},{'\xe9','\x62'},
+    {'\x9a','\x65'},{'\xec','\xda'},{'\xc0','\xaf'},{'\x82','\xd9'},{'\xc0','\xad'},
+    {'\x00','\x00'},{'\xc0','\xac'},{'\xc0','\xae'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xef','\xc4'},{'\x9a','\x66'},{'\xf1','\x72'},{'\xf1','\xfd'},{'\x00','\x00'},
+    {'\x8c','\xcc'},{'\xf4','\x44'},{'\xf4','\x45'},{'\x00','\x00'},{'\xc4','\x60'},
+    {'\x00','\x00'},{'\xf5','\xc9'},{'\x82','\x53'},{'\xc4','\xde'},{'\x00','\x00'},
+    {'\xf5','\xca'},{'\x82','\xda'},{'\xf6','\xde'},{'\xc5','\x72'},{'\x82','\xdb'},
+    {'\xc5','\x71'},{'\xf6','\xdd'},{'\xc5','\xc9'},{'\x9a','\x67'},{'\xf7','\xd6'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xcc'},{'\x00','\x00'},{'\xa4','\x74'},
+    {'\xa6','\x7b'},{'\xc9','\xda'},{'\xca','\xca'},{'\xa8','\xb5'},{'\xb1','\x5f'},
+    {'\x93','\x57'},{'\x00','\x00'},{'\xa4','\x75'},{'\xa5','\xaa'},{'\xa5','\xa9'},
+    {'\xa5','\xa8'},{'\x88','\xb2'},{'\x00','\x00'},{'\xa7','\xc5'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xae','\x74'},{'\x8e','\x43'},{'\xdd','\x57'},{'\xa4','\x76'},
+    {'\xa4','\x77'},{'\xa4','\x78'},{'\xa4','\xda'},{'\xfb','\xfa'},{'\x00','\x00'},
+    {'\xab','\xd1'},{'\x00','\x00'},{'\xce','\xaf'},{'\x00','\x00'},{'\x92','\x66'},
+    {'\x00','\x00'},{'\xb4','\x53'},{'\xa4','\x79'},{'\xc9','\x5d'},{'\x00','\x00'},
+    {'\x86','\xc5'},{'\xa5','\xab'},{'\xa5','\xac'},{'\xc9','\x78'},{'\x83','\x6c'},
+    {'\xa6','\x7c'},{'\x00','\x00'},{'\x83','\xb6'},{'\x9a','\x68'},{'\xca','\xcb'},
+    {'\xfb','\xfb'},{'\xa7','\xc6'},{'\x00','\x00'},{'\xca','\xcc'},{'\x84','\xd9'},
+    {'\x84','\x44'},{'\xa9','\xae'},{'\xfb','\xfc'},{'\x00','\x00'},{'\xcc','\x6e'},
+    {'\xa9','\xac'},{'\xa9','\xab'},{'\xcc','\x6d'},{'\xa9','\xa9'},{'\xcc','\x6f'},
+    {'\xa9','\xaa'},{'\xa9','\xad'},{'\x87','\xc3'},{'\xab','\xd2'},{'\x00','\x00'},
+    {'\xab','\xd4'},{'\xce','\xb3'},{'\xce','\xb0'},{'\xce','\xb1'},{'\xce','\xb2'},
+    {'\xce','\xb4'},{'\xab','\xd3'},{'\x84','\x43'},{'\x84','\xd8'},{'\xd1','\x74'},
+    {'\xd1','\x73'},{'\x00','\x00'},{'\xae','\x76'},{'\x00','\x00'},{'\xae','\x75'},
+    {'\x89','\xd6'},{'\x93','\x67'},{'\x92','\x6f'},{'\x8f','\x50'},{'\x00','\x00'},
+    {'\xb1','\x62'},{'\xd5','\x46'},{'\x00','\x00'},{'\xb1','\x61'},{'\xb1','\x63'},
+    {'\xb1','\x60'},{'\x00','\x00'},{'\x00','\x00'},{'\x8e','\x68'},{'\x86','\xc6'},
+    {'\xb4','\x55'},{'\xd5','\x45'},{'\x00','\x00'},{'\xb4','\x56'},{'\xd8','\xf3'},
+    {'\x88','\xcb'},{'\xb4','\x57'},{'\xd8','\xf2'},{'\xb4','\x54'},{'\x00','\x00'},
+    {'\x82','\xdc'},{'\x9a','\x69'},{'\x00','\x00'},{'\xdd','\x5a'},{'\xdd','\x5c'},
+    {'\xb7','\x45'},{'\xdd','\x5b'},{'\xdd','\x59'},{'\xdd','\x58'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xe1','\xb4'},{'\xb9','\xf7'},{'\xb9','\xf5'},
+    {'\x00','\x00'},{'\xb9','\xf6'},{'\xe1','\xb2'},{'\xe1','\xb3'},{'\x00','\x00'},
+    {'\xb9','\xf3'},{'\xe5','\x71'},{'\xe5','\x6f'},{'\xfb','\xfe'},{'\xbc','\x6d'},
+    {'\xe5','\x70'},{'\xbc','\x6e'},{'\xbc','\x6c'},{'\xb9','\xf4'},{'\x82','\xdd'},
+    {'\x00','\x00'},{'\xe9','\x6d'},{'\xe9','\x6b'},{'\xe9','\x6c'},{'\xe5','\x6e'},
+    {'\xec','\xdc'},{'\xc0','\xb0'},{'\xec','\xdb'},{'\xef','\xc5'},{'\xef','\xc6'},
+    {'\xe9','\x6e'},{'\xf1','\xfe'},{'\x00','\x00'},{'\xa4','\x7a'},{'\xa5','\xad'},
+    {'\xa6','\x7e'},{'\xc9','\xdb'},{'\xa6','\x7d'},{'\x00','\x00'},{'\xa9','\xaf'},
+    {'\xb7','\x46'},{'\xc6','\xcd'},{'\xa4','\xdb'},{'\xa5','\xae'},{'\xab','\xd5'},
+    {'\xb4','\x58'},{'\xc6','\xce'},{'\xc9','\x79'},{'\x93','\x75'},{'\xc9','\x7a'},
+    {'\x92','\xbe'},{'\xc9','\xdc'},{'\x00','\x00'},{'\x87','\xca'},{'\xa7','\xc8'},
+    {'\xca','\xd0'},{'\xca','\xce'},{'\xa7','\xc9'},{'\xca','\xcd'},{'\xca','\xcf'},
+    {'\xca','\xd1'},{'\x00','\x00'},{'\xa7','\xc7'},{'\x8b','\x72'},{'\x8e','\xb5'},
+    {'\x9a','\x6a'},{'\x83','\xb7'},{'\x89','\xd8'},{'\xa9','\xb3'},{'\xa9','\xb4'},
+    {'\xa9','\xb1'},{'\x00','\x00'},{'\x87','\xc6'},{'\xa9','\xb0'},{'\xce','\xb8'},
+    {'\xa9','\xb2'},{'\x00','\x00'},{'\x8b','\x71'},{'\x87','\xc4'},{'\xab','\xd6'},
+    {'\x00','\x00'},{'\xce','\xb7'},{'\xce','\xb9'},{'\xce','\xb6'},{'\xce','\xba'},
+    {'\xab','\xd7'},{'\xae','\x79'},{'\xd1','\x75'},{'\x00','\x00'},{'\xd1','\x77'},
+    {'\xae','\x77'},{'\xd1','\x78'},{'\xae','\x78'},{'\xd1','\x76'},{'\x00','\x00'},
+    {'\xce','\xb5'},{'\xd5','\x47'},{'\xd5','\x4a'},{'\xd5','\x4b'},{'\xd5','\x48'},
+    {'\xb1','\x67'},{'\xb1','\x66'},{'\xb1','\x64'},{'\xb1','\x65'},{'\xd5','\x49'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9a','\x6b'},{'\xb1','\x68'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb4','\x5a'},{'\xb4','\x5b'},{'\x93','\xb2'},
+    {'\xb4','\x5c'},{'\xdd','\x5d'},{'\xdd','\x5f'},{'\xdd','\x61'},{'\xb7','\x48'},
+    {'\xb7','\x47'},{'\xb4','\x59'},{'\xdd','\x60'},{'\xdd','\x5e'},{'\xfe','\xa4'},
+    {'\xe1','\xb8'},{'\x82','\xde'},{'\x82','\xdf'},{'\xe1','\xb6'},{'\xe1','\xbc'},
+    {'\xb9','\xf8'},{'\xe1','\xbd'},{'\xe1','\xba'},{'\xb9','\xf9'},{'\xe1','\xb7'},
+    {'\xe1','\xb5'},{'\xe1','\xbb'},{'\xbc','\x70'},{'\xe5','\x73'},{'\xe1','\xb9'},
+    {'\xbc','\x72'},{'\xe5','\x74'},{'\xbc','\x71'},{'\xbc','\x74'},{'\xe5','\x75'},
+    {'\xbc','\x6f'},{'\xbc','\x73'},{'\x00','\x00'},{'\xe9','\x73'},{'\xe9','\x71'},
+    {'\xe9','\x70'},{'\xe9','\x72'},{'\xe9','\x6f'},{'\x82','\xe0'},{'\x00','\x00'},
+    {'\xc3','\x66'},{'\x00','\x00'},{'\xf4','\x46'},{'\xf4','\x47'},{'\x82','\xe1'},
+    {'\xf5','\xcb'},{'\xf6','\xdf'},{'\xc6','\x55'},{'\xc6','\xcf'},{'\x00','\x00'},
+    {'\xa9','\xb5'},{'\xa7','\xca'},{'\x95','\xa4'},{'\x95','\xa1'},{'\xab','\xd8'},
+    {'\x95','\xee'},{'\x95','\xfa'},{'\x00','\x00'},{'\xa4','\x7b'},{'\xa4','\xdc'},
+    {'\x85','\x7b'},{'\xa5','\xaf'},{'\xc9','\xdd'},{'\x84','\x56'},{'\xa7','\xcb'},
+    {'\xca','\xd2'},{'\x00','\x00'},{'\xce','\xbb'},{'\xab','\xd9'},{'\x82','\xe2'},
+    {'\xb9','\xfa'},{'\xa4','\x7c'},{'\x82','\xe3'},{'\x95','\xaa'},{'\x9a','\x6c'},
+    {'\xa6','\xa1'},{'\x93','\xae'},{'\x82','\xe4'},{'\xb7','\x49'},{'\xa4','\x7d'},
+    {'\xa4','\xdd'},{'\xa4','\xde'},{'\x94','\x75'},{'\xa5','\xb1'},{'\xa5','\xb0'},
+    {'\x00','\x00'},{'\xc9','\xde'},{'\xa6','\xa2'},{'\x00','\x00'},{'\xca','\xd3'},
+    {'\x00','\x00'},{'\xa7','\xcc'},{'\x84','\x45'},{'\x82','\xe5'},{'\xcc','\x71'},
+    {'\xcc','\x72'},{'\xcc','\x73'},{'\x93','\xf9'},{'\xa9','\xb6'},{'\xa9','\xb7'},
+    {'\xcc','\x70'},{'\xa9','\xb8'},{'\x8d','\xc3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xab','\xda'},{'\xce','\xbc'},{'\x8c','\xce'},{'\xd1','\x7a'},{'\xae','\x7a'},
+    {'\x00','\x00'},{'\xd1','\x79'},{'\x82','\xe6'},{'\xb1','\x69'},{'\xd5','\x4c'},
+    {'\xb1','\x6a'},{'\xd5','\x4d'},{'\x87','\xc9'},{'\x84','\x46'},{'\x9d','\x7b'},
+    {'\xb4','\x5d'},{'\x00','\x00'},{'\x93','\x71'},{'\x00','\x00'},{'\xdd','\x62'},
+    {'\x82','\xe7'},{'\x00','\x00'},{'\xe1','\xbf'},{'\xe1','\xbe'},{'\x82','\xe8'},
+    {'\xb9','\xfb'},{'\x00','\x00'},{'\xbc','\x75'},{'\xe5','\x76'},{'\xbe','\xca'},
+    {'\xe9','\x74'},{'\xc0','\xb1'},{'\xfc','\x41'},{'\xc5','\x73'},{'\xf7','\xd8'},
+    {'\xc6','\xd0'},{'\x82','\xe9'},{'\x8a','\xd0'},{'\x85','\xe5'},{'\xcc','\x74'},
+    {'\x89','\xa3'},{'\xce','\xbd'},{'\xb1','\x6b'},{'\xd8','\xf4'},{'\xb7','\x4a'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x82','\xea'},{'\xc2','\x55'},{'\xc2','\x55'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\xd1'},{'\xa7','\xce'},{'\xfe','\xa8'},
+    {'\xa7','\xcd'},{'\xab','\xdb'},{'\x82','\xeb'},{'\xd1','\x7b'},{'\x00','\x00'},
+    {'\xb1','\x6d'},{'\xb3','\x43'},{'\xb1','\x6e'},{'\xb1','\x6c'},{'\xb4','\x5e'},
+    {'\x00','\x00'},{'\xe1','\xc0'},{'\xb9','\xfc'},{'\xbc','\x76'},{'\x9a','\x6d'},
+    {'\xc9','\x4c'},{'\xc9','\xdf'},{'\x00','\x00'},{'\xca','\xd5'},{'\xa7','\xcf'},
+    {'\xca','\xd4'},{'\xa7','\xd0'},{'\x00','\x00'},{'\x86','\xc7'},{'\xa9','\xbc'},
+    {'\xcc','\x77'},{'\xcc','\x76'},{'\xa9','\xbb'},{'\xa9','\xb9'},{'\xa9','\xba'},
+    {'\xcc','\x75'},{'\x82','\xec'},{'\x92','\xa6'},{'\xab','\xdd'},{'\xce','\xbe'},
+    {'\xab','\xe0'},{'\xab','\xdc'},{'\xab','\xe2'},{'\xab','\xde'},{'\xab','\xdf'},
+    {'\xab','\xe1'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xae','\x7d'},
+    {'\xae','\x7c'},{'\xae','\x7b'},{'\x92','\xdc'},{'\x00','\x00'},{'\x84','\x48'},
+    {'\xd5','\x4f'},{'\xb1','\x6f'},{'\xb1','\x72'},{'\xb1','\x70'},{'\x00','\x00'},
+    {'\xd5','\x4e'},{'\xb1','\x75'},{'\x00','\x00'},{'\xb1','\x71'},{'\xd5','\x50'},
+    {'\xb1','\x74'},{'\xb1','\x73'},{'\x00','\x00'},{'\x00','\x00'},{'\xfc','\x47'},
+    {'\xd8','\xf6'},{'\xd8','\xf5'},{'\x95','\x5a'},{'\xb4','\x61'},{'\xb4','\x5f'},
+    {'\xb4','\x60'},{'\xd8','\xf7'},{'\xb7','\x4b'},{'\xdd','\x64'},{'\xb7','\x4c'},
+    {'\xdd','\x63'},{'\x00','\x00'},{'\x9a','\x6e'},{'\xe5','\x77'},{'\x93','\xa8'},
+    {'\x93','\x76'},{'\xbc','\x78'},{'\xe1','\xc1'},{'\xbc','\x77'},{'\x00','\x00'},
+    {'\xb9','\xfd'},{'\xfc','\x48'},{'\xec','\xde'},{'\xe9','\x75'},{'\xc0','\xb2'},
+    {'\xec','\xdd'},{'\xf2','\x40'},{'\xf4','\x48'},{'\xf4','\x49'},{'\x9a','\x6f'},
+    {'\xa4','\xdf'},{'\x9c','\xf5'},{'\xa5','\xb2'},{'\x88','\xda'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc9','\x7b'},{'\x00','\x00'},{'\x00','\x00'},{'\xa7','\xd2'},
+    {'\xa7','\xd4'},{'\x00','\x00'},{'\xc9','\xe2'},{'\xca','\xd8'},{'\xca','\xd7'},
+    {'\xca','\xd6'},{'\x00','\x00'},{'\xc9','\xe1'},{'\xc9','\xe0'},{'\xa6','\xa4'},
+    {'\xa7','\xd3'},{'\xa7','\xd1'},{'\xa6','\xa3'},{'\x00','\x00'},{'\x9a','\x70'},
+    {'\x92','\x4e'},{'\xa9','\xbd'},{'\xcc','\x78'},{'\x9a','\x71'},{'\xa9','\xbe'},
+    {'\xca','\xdd'},{'\x00','\x00'},{'\xca','\xdf'},{'\xca','\xde'},{'\xcc','\x79'},
+    {'\x00','\x00'},{'\x87','\xcc'},{'\xca','\xda'},{'\x00','\x00'},{'\xa7','\xd8'},
+    {'\xa7','\xd6'},{'\x00','\x00'},{'\xca','\xd9'},{'\xca','\xdb'},{'\xca','\xe1'},
+    {'\x82','\xed'},{'\xa7','\xd5'},{'\x00','\x00'},{'\xca','\xdc'},{'\xca','\xe5'},
+    {'\xa9','\xc0'},{'\x00','\x00'},{'\xca','\xe2'},{'\xa7','\xd7'},{'\x00','\x00'},
+    {'\xca','\xe0'},{'\xca','\xe3'},{'\x00','\x00'},{'\xa9','\xbf'},{'\x85','\xc7'},
+    {'\xa9','\xc1'},{'\xca','\xe4'},{'\x86','\xc8'},{'\x87','\xcd'},{'\x87','\xd1'},
+    {'\x8e','\x6b'},{'\x84','\x4a'},{'\x85','\xc8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xcc','\xaf'},{'\xcc','\xa2'},{'\xcc','\x7e'},{'\xcc','\xae'},{'\xcc','\xa9'},
+    {'\xab','\xe7'},{'\xa9','\xc2'},{'\xcc','\xaa'},{'\xcc','\xad'},{'\xab','\xe3'},
+    {'\xcc','\xac'},{'\xa9','\xc3'},{'\xa9','\xc8'},{'\xa9','\xc6'},{'\xcc','\xa3'},
+    {'\x00','\x00'},{'\xcc','\x7c'},{'\xcc','\xa5'},{'\xa9','\xcd'},{'\xcc','\xb0'},
+    {'\xab','\xe4'},{'\xcc','\xa6'},{'\x00','\x00'},{'\xab','\xe5'},{'\xa9','\xc9'},
+    {'\xcc','\xa8'},{'\x9a','\x72'},{'\xce','\xcd'},{'\xab','\xe6'},{'\xcc','\x7b'},
+    {'\xa9','\xca'},{'\xab','\xe8'},{'\xa9','\xcb'},{'\xa9','\xc7'},{'\xa9','\xcc'},
+    {'\xcc','\xa7'},{'\xcc','\x7a'},{'\xcc','\xab'},{'\xa9','\xc4'},{'\x00','\x00'},
+    {'\x95','\xa6'},{'\xcc','\x7d'},{'\xcc','\xa4'},{'\xcc','\xa1'},{'\xa9','\xc5'},
+    {'\x00','\x00'},{'\xce','\xbf'},{'\x00','\x00'},{'\xce','\xc0'},{'\x94','\x76'},
+    {'\x8a','\x4b'},{'\x8f','\x74'},{'\x00','\x00'},{'\x00','\x00'},{'\x8e','\xe7'},
+    {'\xce','\xca'},{'\xd1','\xa1'},{'\xce','\xcb'},{'\xab','\xee'},{'\xce','\xce'},
+    {'\xce','\xc4'},{'\xab','\xed'},{'\xce','\xc6'},{'\x00','\x00'},{'\xce','\xc7'},
+    {'\x82','\xee'},{'\x8c','\xf6'},{'\xce','\xc9'},{'\xab','\xe9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xae','\xa3'},{'\x00','\x00'},{'\xf9','\xda'},{'\xce','\xc5'},
+    {'\xce','\xc1'},{'\xae','\xa4'},{'\x00','\x00'},{'\x00','\x00'},{'\xce','\xcf'},
+    {'\xae','\x7e'},{'\xd1','\x7d'},{'\xce','\xc8'},{'\x00','\x00'},{'\xd1','\x7c'},
+    {'\xce','\xc3'},{'\xce','\xcc'},{'\x82','\xef'},{'\x00','\x00'},{'\xab','\xec'},
+    {'\xae','\xa1'},{'\xab','\xf2'},{'\xae','\xa2'},{'\xce','\xd0'},{'\xd1','\x7e'},
+    {'\xab','\xeb'},{'\xae','\xa6'},{'\xab','\xf1'},{'\xab','\xf0'},{'\xab','\xef'},
+    {'\xae','\xa5'},{'\xce','\xd1'},{'\xae','\xa7'},{'\xab','\xea'},{'\x00','\x00'},
+    {'\xce','\xc2'},{'\x89','\xd9'},{'\x00','\x00'},{'\x92','\xa8'},{'\x84','\xdc'},
+    {'\xfc','\x4b'},{'\x86','\xca'},{'\x8f','\x51'},{'\x85','\xc9'},{'\x84','\xdf'},
+    {'\x84','\xe0'},{'\x8d','\xdd'},{'\x9a','\x73'},{'\xb1','\x76'},{'\xd1','\xa4'},
+    {'\xd1','\xa6'},{'\x00','\x00'},{'\xd1','\xa8'},{'\xae','\xa8'},{'\xae','\xae'},
+    {'\xd5','\x53'},{'\xd1','\xac'},{'\xd1','\xa3'},{'\xb1','\x78'},{'\xd5','\x51'},
+    {'\x82','\xf0'},{'\xae','\xad'},{'\xae','\xab'},{'\xd1','\xae'},{'\x00','\x00'},
+    {'\xd5','\x52'},{'\x00','\x00'},{'\xd1','\xa5'},{'\x00','\x00'},{'\xae','\xac'},
+    {'\xd1','\xa9'},{'\xae','\xaf'},{'\xd1','\xab'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xae','\xaa'},{'\xd1','\xaa'},{'\xd1','\xad'},{'\xd1','\xa7'},{'\xfb','\x64'},
+    {'\xae','\xa9'},{'\xb1','\x79'},{'\x00','\x00'},{'\xd1','\xa2'},{'\xb1','\x77'},
+    {'\xfc','\x4c'},{'\x00','\x00'},{'\x82','\xf1'},{'\xfe','\xa6'},{'\xb1','\x7a'},
+    {'\x93','\xaf'},{'\x92','\x41'},{'\x8e','\x69'},{'\x8b','\xf4'},{'\x8e','\x6a'},
+    {'\x00','\x00'},{'\x87','\xce'},{'\xd5','\x55'},{'\xd5','\x5e'},{'\xb4','\x64'},
+    {'\xfc','\x4d'},{'\xb1','\x7c'},{'\xb1','\xa3'},{'\xb4','\x65'},{'\xd5','\x60'},
+    {'\xb1','\xaa'},{'\xd8','\xf9'},{'\xd5','\x56'},{'\xb1','\xa2'},{'\xb1','\xa5'},
+    {'\xb1','\x7e'},{'\xd5','\x54'},{'\xd5','\x62'},{'\xd5','\x65'},{'\xd9','\x49'},
+    {'\x00','\x00'},{'\xd5','\x63'},{'\xd8','\xfd'},{'\xb1','\xa1'},{'\xb1','\xa8'},
+    {'\xb1','\xac'},{'\xd5','\x5d'},{'\xd8','\xf8'},{'\xd5','\x61'},{'\xb1','\x7b'},
+    {'\xd8','\xfa'},{'\xd5','\x64'},{'\xd8','\xfc'},{'\xd5','\x59'},{'\x00','\x00'},
+    {'\xb4','\x62'},{'\x00','\x00'},{'\xd5','\x57'},{'\xd5','\x58'},{'\xb1','\xa7'},
+    {'\x00','\x00'},{'\x9a','\x74'},{'\xb1','\xa6'},{'\xd5','\x5b'},{'\xb1','\xab'},
+    {'\xd5','\x5f'},{'\xb1','\xa4'},{'\xd5','\x5c'},{'\x82','\xf2'},{'\xb1','\xa9'},
+    {'\xb4','\x66'},{'\xb4','\x63'},{'\xd8','\xfb'},{'\x82','\xad'},{'\xd5','\x5a'},
+    {'\x00','\x00'},{'\xb1','\x7d'},{'\x8c','\x71'},{'\x86','\xcc'},{'\x8b','\x73'},
+    {'\x00','\x00'},{'\x88','\xd8'},{'\x84','\xde'},{'\x86','\xcb'},{'\x87','\xcf'},
+    {'\x86','\xc9'},{'\xb4','\x6b'},{'\xb4','\x6f'},{'\xd9','\x40'},{'\xb7','\x51'},
+    {'\xb4','\x6d'},{'\xd9','\x44'},{'\xb4','\x71'},{'\xdd','\x65'},{'\xd9','\x46'},
+    {'\xb7','\x53'},{'\xb4','\x69'},{'\xb4','\x6c'},{'\xd9','\x47'},{'\xfc','\x4e'},
+    {'\xd9','\x48'},{'\xd9','\x4e'},{'\xb4','\x73'},{'\xb7','\x54'},{'\x00','\x00'},
+    {'\xd9','\x4a'},{'\xd9','\x4f'},{'\xd9','\x43'},{'\xb7','\x5e'},{'\x9a','\x75'},
+    {'\xb7','\x55'},{'\xb4','\x72'},{'\xd9','\x41'},{'\xd9','\x50'},{'\x9a','\x76'},
+    {'\xb7','\x5d'},{'\xb4','\x70'},{'\xb7','\x4e'},{'\xd9','\x4d'},{'\x82','\xf3'},
+    {'\xb4','\x74'},{'\xd9','\x45'},{'\xd8','\xfe'},{'\xb4','\x6a'},{'\xd9','\x42'},
+    {'\x00','\x00'},{'\xd9','\x4b'},{'\x9a','\x77'},{'\xb7','\x4d'},{'\xb7','\x52'},
+    {'\xb4','\x67'},{'\xd9','\x4c'},{'\x00','\x00'},{'\xb7','\x50'},{'\x82','\xf4'},
+    {'\x82','\xf5'},{'\x9a','\x78'},{'\xb4','\x68'},{'\x87','\xd0'},{'\x00','\x00'},
+    {'\x8e','\xb6'},{'\xb7','\x5c'},{'\xe1','\xc3'},{'\xdd','\x70'},{'\x00','\x00'},
+    {'\xdd','\x68'},{'\xe1','\xc2'},{'\x00','\x00'},{'\xdd','\x6c'},{'\xdd','\x6e'},
+    {'\xfc','\x4f'},{'\x00','\x00'},{'\xdd','\x6b'},{'\x00','\x00'},{'\xb7','\x5b'},
+    {'\x00','\x00'},{'\xdd','\x6a'},{'\xb7','\x5f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe1','\xd2'},{'\x82','\xf6'},{'\x82','\xf7'},{'\xb7','\x5a'},
+    {'\xba','\x40'},{'\xdd','\x71'},{'\xe1','\xc4'},{'\xfc','\xc9'},{'\x00','\x00'},
+    {'\xb7','\x58'},{'\xdd','\x69'},{'\xdd','\x6d'},{'\xb9','\xfe'},{'\xb7','\x4f'},
+    {'\xdd','\x66'},{'\xdd','\x67'},{'\xba','\x41'},{'\xb7','\x57'},{'\xb7','\x59'},
+    {'\xb7','\x56'},{'\xdd','\x6f'},{'\x9a','\x79'},{'\x8c','\x72'},{'\xe1','\xc8'},
+    {'\xe1','\xc9'},{'\xe1','\xce'},{'\xbc','\x7d'},{'\xe1','\xd5'},{'\x00','\x00'},
+    {'\xba','\x47'},{'\xfc','\x52'},{'\xba','\x46'},{'\xe1','\xd0'},{'\xfc','\x54'},
+    {'\xbc','\x7c'},{'\xe1','\xc5'},{'\xba','\x45'},{'\x9a','\x7a'},{'\xe1','\xd4'},
+    {'\xba','\x43'},{'\xba','\x44'},{'\x95','\xad'},{'\xe1','\xd1'},{'\xe5','\xaa'},
+    {'\xbc','\x7a'},{'\xb4','\x6e'},{'\x00','\x00'},{'\xe1','\xd3'},{'\xbc','\xa3'},
+    {'\xe1','\xcb'},{'\x00','\x00'},{'\xbc','\x7b'},{'\x95','\x66'},{'\xbc','\xa2'},
+    {'\xe1','\xc6'},{'\xe1','\xca'},{'\xe1','\xc7'},{'\xe1','\xcd'},{'\xba','\x48'},
+    {'\xbc','\x79'},{'\xba','\x42'},{'\x00','\x00'},{'\xe5','\x7a'},{'\xe1','\xcf'},
+    {'\x00','\x00'},{'\xbc','\xa1'},{'\xfc','\x53'},{'\xbc','\xa4'},{'\x00','\x00'},
+    {'\xe1','\xcc'},{'\x9a','\x7b'},{'\xbc','\x7e'},{'\xe5','\x79'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x95','\xd1'},{'\x00','\x00'},{'\xe5','\x7e'},
+    {'\xbe','\xce'},{'\xe5','\x78'},{'\xe9','\xa3'},{'\xe5','\xa9'},{'\xbc','\xa8'},
+    {'\x00','\x00'},{'\xbc','\xa6'},{'\xbe','\xcc'},{'\xe5','\xa6'},{'\xe5','\xa2'},
+    {'\xbc','\xac'},{'\x9a','\x7c'},{'\xe9','\x78'},{'\x00','\x00'},{'\x82','\xf8'},
+    {'\xfe','\x74'},{'\xbc','\xaa'},{'\xe5','\xa1'},{'\xfc','\x51'},{'\xe9','\x76'},
+    {'\x00','\x00'},{'\xe5','\xa5'},{'\x00','\x00'},{'\xe5','\xa8'},{'\xe5','\x7d'},
+    {'\x00','\x00'},{'\xbc','\xab'},{'\x00','\x00'},{'\x00','\x00'},{'\xbc','\xa5'},
+    {'\xe9','\x77'},{'\xbe','\xcd'},{'\xe5','\xa7'},{'\xbc','\xa7'},{'\xbc','\xa9'},
+    {'\xe5','\xa4'},{'\xbc','\xad'},{'\xe5','\xa3'},{'\xe5','\x7c'},{'\xe5','\x7b'},
+    {'\xbe','\xcb'},{'\xe5','\xab'},{'\xe9','\x7a'},{'\xec','\xe0'},{'\xbe','\xd0'},
+    {'\x82','\xf9'},{'\xe9','\xa2'},{'\x9a','\x7d'},{'\xe9','\x7e'},{'\x00','\x00'},
+    {'\xec','\xe1'},{'\x00','\x00'},{'\xbe','\xd1'},{'\xe9','\xa1'},{'\x9a','\x7e'},
+    {'\xe9','\x7c'},{'\xc0','\xb4'},{'\xec','\xdf'},{'\x00','\x00'},{'\xe9','\x79'},
+    {'\xe9','\x7b'},{'\xc0','\xb5'},{'\xbe','\xd3'},{'\xc0','\xb3'},{'\xbe','\xd2'},
+    {'\xc0','\xb7'},{'\xe9','\x7d'},{'\xbe','\xcf'},{'\x00','\x00'},{'\x9a','\xa1'},
+    {'\x92','\x5d'},{'\x8a','\xc2'},{'\x8b','\x75'},{'\x9a','\xa2'},{'\x88','\xd9'},
+    {'\x00','\x00'},{'\xef','\xcf'},{'\x00','\x00'},{'\xef','\xc7'},{'\x00','\x00'},
+    {'\x9a','\xa3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xec','\xe7'},
+    {'\xef','\xc8'},{'\xec','\xe3'},{'\x00','\x00'},{'\xfc','\x56'},{'\xc2','\x56'},
+    {'\xec','\xe5'},{'\xec','\xe4'},{'\xc0','\xb6'},{'\xec','\xe2'},{'\xec','\xe6'},
+    {'\xef','\xd0'},{'\xef','\xcc'},{'\xef','\xce'},{'\x00','\x00'},{'\xef','\xc9'},
+    {'\xef','\xca'},{'\x00','\x00'},{'\xef','\xcd'},{'\xef','\xcb'},{'\xc3','\x67'},
+    {'\x00','\x00'},{'\x82','\xfa'},{'\xc3','\x6a'},{'\xc3','\x69'},{'\xc3','\x68'},
+    {'\xc4','\x61'},{'\xf4','\x4a'},{'\xc4','\x62'},{'\xf2','\x41'},{'\xc4','\xdf'},
+    {'\xf5','\xcc'},{'\xc4','\xe0'},{'\xc5','\x74'},{'\xc5','\xca'},{'\xf7','\xd9'},
+    {'\x00','\x00'},{'\xf7','\xda'},{'\xf7','\xdb'},{'\x00','\x00'},{'\x90','\xab'},
+    {'\xf9','\xba'},{'\xa4','\xe0'},{'\xc9','\x7c'},{'\xa5','\xb3'},{'\x8d','\xb8'},
+    {'\xa6','\xa6'},{'\xa6','\xa7'},{'\xa6','\xa5'},{'\x89','\xda'},{'\xa6','\xa8'},
+    {'\xa7','\xda'},{'\xa7','\xd9'},{'\x82','\xfb'},{'\xcc','\xb1'},{'\xa9','\xcf'},
+    {'\xa9','\xce'},{'\x8e','\x6d'},{'\x88','\xdb'},{'\xd1','\xaf'},{'\xb1','\xad'},
+    {'\xb1','\xae'},{'\x00','\x00'},{'\x82','\xfc'},{'\x82','\xfd'},{'\xb4','\x75'},
+    {'\xdd','\x72'},{'\xb7','\x60'},{'\xb7','\x61'},{'\xdd','\x74'},{'\xdd','\x76'},
+    {'\xdd','\x75'},{'\x93','\x49'},{'\xe1','\xd7'},{'\x00','\x00'},{'\xe1','\xd6'},
+    {'\xba','\x49'},{'\xe1','\xd8'},{'\x8e','\x6c'},{'\xe5','\xac'},{'\xbc','\xae'},
+    {'\x92','\x70'},{'\xbe','\xd4'},{'\x00','\x00'},{'\xc0','\xb8'},{'\xc2','\x57'},
+    {'\xc0','\xb9'},{'\x00','\x00'},{'\xa4','\xe1'},{'\x82','\xfe'},{'\x90','\xbd'},
+    {'\xfc','\x58'},{'\xca','\xe6'},{'\x93','\xec'},{'\x00','\x00'},{'\xcc','\xb2'},
+    {'\xa9','\xd1'},{'\xa9','\xd0'},{'\xa9','\xd2'},{'\xab','\xf3'},{'\xce','\xd2'},
+    {'\xce','\xd3'},{'\x00','\x00'},{'\x00','\x00'},{'\xd1','\xb0'},{'\xae','\xb0'},
+    {'\xb1','\xaf'},{'\xb4','\x76'},{'\xd9','\x51'},{'\xa4','\xe2'},{'\x9c','\xf2'},
+    {'\xa4','\x7e'},{'\xa4','\xe3'},{'\x00','\x00'},{'\xc9','\x7d'},{'\xa5','\xb7'},
+    {'\xa5','\xb6'},{'\xa5','\xb4'},{'\xa5','\xb5'},{'\x93','\xc1'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa6','\xab'},{'\xc9','\xe9'},{'\xc9','\xeb'},{'\xa6','\xaa'},
+    {'\xc9','\xe3'},{'\x00','\x00'},{'\xc9','\xe4'},{'\x00','\x00'},{'\xc9','\xea'},
+    {'\xc9','\xe6'},{'\xc9','\xe8'},{'\xa6','\xa9'},{'\xc9','\xe5'},{'\xc9','\xec'},
+    {'\xc9','\xe7'},{'\x83','\xf9'},{'\xfc','\x59'},{'\x8a','\xc3'},{'\x84','\x4d'},
+    {'\x84','\x4b'},{'\x84','\xe4'},{'\xa7','\xe1'},{'\xa7','\xea'},{'\xa7','\xe8'},
+    {'\xca','\xf0'},{'\xca','\xed'},{'\xca','\xf5'},{'\xa7','\xe6'},{'\xca','\xf6'},
+    {'\x00','\x00'},{'\xa7','\xdf'},{'\xca','\xf3'},{'\x00','\x00'},{'\xa7','\xe5'},
+    {'\xca','\xef'},{'\xca','\xee'},{'\xa7','\xe3'},{'\xca','\xf4'},{'\xa7','\xe4'},
+    {'\xa9','\xd3'},{'\xa7','\xde'},{'\xca','\xf1'},{'\xfc','\x5b'},{'\xca','\xe7'},
+    {'\xa7','\xdb'},{'\xfc','\x5a'},{'\xa7','\xee'},{'\xca','\xec'},{'\xca','\xf2'},
+    {'\xa7','\xe0'},{'\xa7','\xe2'},{'\x00','\x00'},{'\xca','\xe8'},{'\x00','\x00'},
+    {'\xca','\xe9'},{'\xca','\xea'},{'\x9a','\xa4'},{'\xa7','\xed'},{'\xa7','\xe7'},
+    {'\xa7','\xec'},{'\xca','\xeb'},{'\xa7','\xeb'},{'\xa7','\xdd'},{'\xa7','\xdc'},
+    {'\xa7','\xe9'},{'\x00','\x00'},{'\x87','\xd7'},{'\x90','\xbe'},{'\x93','\xbb'},
+    {'\xfd','\x57'},{'\x93','\x6a'},{'\x8e','\x6e'},{'\x8e','\x6f'},{'\x84','\x4e'},
+    {'\x85','\xcb'},{'\x00','\x00'},{'\x8c','\xa8'},{'\x84','\xd2'},{'\xfc','\x5c'},
+    {'\x00','\x00'},{'\xa9','\xe1'},{'\xcc','\xbe'},{'\xcc','\xb7'},{'\xa9','\xdc'},
+    {'\xa9','\xef'},{'\xcc','\xb3'},{'\xcc','\xba'},{'\xcc','\xbc'},{'\xcc','\xbf'},
+    {'\xa9','\xea'},{'\x00','\x00'},{'\xcc','\xbb'},{'\xcc','\xb4'},{'\xa9','\xe8'},
+    {'\xcc','\xb8'},{'\x00','\x00'},{'\xcc','\xc0'},{'\xa9','\xd9'},{'\x00','\x00'},
+    {'\xcc','\xbd'},{'\xa9','\xe3'},{'\xa9','\xe2'},{'\xcc','\xb6'},{'\xa9','\xd7'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa9','\xd8'},{'\xfb','\x46'},{'\xa9','\xd6'},
+    {'\x88','\xe3'},{'\xa9','\xee'},{'\xa9','\xe6'},{'\xa9','\xe0'},{'\xa9','\xd4'},
+    {'\xcc','\xb9'},{'\xa9','\xdf'},{'\xa9','\xd5'},{'\xa9','\xe7'},{'\xa9','\xf0'},
+    {'\xce','\xd4'},{'\xa9','\xe4'},{'\xcc','\xb5'},{'\xa9','\xda'},{'\xa9','\xdd'},
+    {'\xa9','\xde'},{'\xfc','\x5d'},{'\xa9','\xec'},{'\xa9','\xed'},{'\xa9','\xeb'},
+    {'\xa9','\xe5'},{'\xa9','\xe9'},{'\xa9','\xdb'},{'\xab','\xf4'},{'\x93','\xb1'},
+    {'\x00','\x00'},{'\x89','\xde'},{'\x92','\x75'},{'\x92','\x5e'},{'\x8b','\x76'},
+    {'\x84','\xe1'},{'\x00','\x00'},{'\x88','\xdc'},{'\x8b','\xf6'},{'\x89','\xdd'},
+    {'\x87','\xd5'},{'\x88','\xe1'},{'\x00','\x00'},{'\xce','\xda'},{'\xac','\x41'},
+    {'\xab','\xf8'},{'\xab','\xfa'},{'\xac','\x40'},{'\xce','\xe6'},{'\xab','\xfd'},
+    {'\xd1','\xb1'},{'\xae','\xb1'},{'\xac','\x43'},{'\xce','\xd7'},{'\xce','\xdf'},
+    {'\xab','\xfe'},{'\xce','\xde'},{'\xce','\xdb'},{'\xce','\xe3'},{'\xce','\xe5'},
+    {'\xab','\xf7'},{'\xab','\xfb'},{'\xac','\x42'},{'\xae','\xb3'},{'\xce','\xe0'},
+    {'\xab','\xf9'},{'\xac','\x45'},{'\xce','\xd9'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xab','\xfc'},{'\xae','\xb2'},{'\xab','\xf6'},{'\x00','\x00'},
+    {'\xce','\xd6'},{'\xce','\xdd'},{'\xce','\xd5'},{'\xce','\xd8'},{'\xce','\xdc'},
+    {'\xd1','\xb2'},{'\xac','\x44'},{'\x00','\x00'},{'\xce','\xe1'},{'\xce','\xe2'},
+    {'\xce','\xe4'},{'\xab','\xf5'},{'\x00','\x00'},{'\x94','\xf4'},{'\x92','\x76'},
+    {'\x87','\xd2'},{'\x8c','\xf7'},{'\x00','\x00'},{'\x88','\xe4'},{'\x88','\xde'},
+    {'\x83','\xb9'},{'\x87','\xd6'},{'\x88','\xdd'},{'\x8e','\xb7'},{'\x84','\x4f'},
+    {'\x89','\xdc'},{'\x84','\xe2'},{'\x00','\x00'},{'\x90','\xbf'},{'\xae','\xc1'},
+    {'\xd1','\xbe'},{'\xae','\xbf'},{'\xae','\xc0'},{'\xd1','\xb4'},{'\xd1','\xc4'},
+    {'\xa0','\x5e'},{'\xae','\xb6'},{'\x00','\x00'},{'\x9a','\xa5'},{'\xd5','\x66'},
+    {'\xd1','\xc6'},{'\xd1','\xc0'},{'\xfc','\x5f'},{'\xd1','\xb7'},{'\x9a','\xa7'},
+    {'\xd1','\xc9'},{'\xd1','\xba'},{'\xae','\xbc'},{'\xd5','\x7d'},{'\xd1','\xbd'},
+    {'\xae','\xbe'},{'\xae','\xb5'},{'\x93','\x56'},{'\xd1','\xcb'},{'\xd1','\xbf'},
+    {'\xae','\xb8'},{'\xd1','\xb8'},{'\xd1','\xb5'},{'\xd1','\xb6'},{'\xae','\xb9'},
+    {'\xd1','\xc5'},{'\xd1','\xcc'},{'\xae','\xbb'},{'\xd1','\xbc'},{'\xd1','\xbb'},
+    {'\xae','\xc3'},{'\xae','\xc2'},{'\xae','\xb4'},{'\xae','\xba'},{'\xae','\xbd'},
+    {'\xd1','\xc8'},{'\x00','\x00'},{'\x00','\x00'},{'\xd1','\xc2'},{'\xae','\xb7'},
+    {'\xd1','\xb3'},{'\xd1','\xca'},{'\xd1','\xc1'},{'\xd1','\xc3'},{'\xd1','\xc7'},
+    {'\x00','\x00'},{'\x93','\x55'},{'\x00','\x00'},{'\x87','\xd4'},{'\x85','\xca'},
+    {'\x00','\x00'},{'\x88','\xe2'},{'\x84','\xe3'},{'\x85','\xcc'},{'\xfc','\x5e'},
+    {'\xd5','\x67'},{'\x00','\x00'},{'\xb1','\xb7'},{'\xb1','\xcb'},{'\xb1','\xca'},
+    {'\x00','\x00'},{'\xb1','\xbf'},{'\x95','\x59'},{'\xd5','\x79'},{'\xd5','\x75'},
+    {'\xd5','\x72'},{'\xd5','\xa6'},{'\xb1','\xba'},{'\xb1','\xb2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd5','\x77'},{'\xb4','\xa8'},{'\xb1','\xb6'},{'\xd5','\xa1'},
+    {'\x9a','\xa8'},{'\xb1','\xcc'},{'\xb1','\xc9'},{'\xd5','\x7b'},{'\xd5','\x6a'},
+    {'\x00','\x00'},{'\xfc','\x55'},{'\xb1','\xc8'},{'\xd5','\xa3'},{'\xd5','\x69'},
+    {'\xb1','\xbd'},{'\xb1','\xc1'},{'\xd5','\xa2'},{'\x00','\x00'},{'\xd5','\x73'},
+    {'\xb1','\xc2'},{'\xb1','\xbc'},{'\xd5','\x68'},{'\x9a','\xa9'},{'\xb4','\x78'},
+    {'\xd5','\xa5'},{'\xd5','\x71'},{'\xb1','\xc7'},{'\xd5','\x74'},{'\xd5','\xa4'},
+    {'\xb1','\xc6'},{'\x00','\x00'},{'\xd9','\x52'},{'\x00','\x00'},{'\xb1','\xb3'},
+    {'\xd5','\x6f'},{'\xb1','\xb8'},{'\xb1','\xc3'},{'\x00','\x00'},{'\xb1','\xbe'},
+    {'\xd5','\x78'},{'\xd5','\x6e'},{'\xd5','\x6c'},{'\xd5','\x7e'},{'\xb1','\xb0'},
+    {'\xb1','\xc4'},{'\xb1','\xb4'},{'\xb4','\x77'},{'\xd5','\x7c'},{'\xb1','\xb5'},
+    {'\x00','\x00'},{'\xb1','\xb1'},{'\xb1','\xc0'},{'\xb1','\xbb'},{'\xb1','\xb9'},
+    {'\xd5','\x70'},{'\xb1','\xc5'},{'\xd5','\x6d'},{'\xd5','\x7a'},{'\xd5','\x76'},
+    {'\xd9','\x54'},{'\xd9','\x53'},{'\x92','\xa9'},{'\x88','\xe0'},{'\x86','\xce'},
+    {'\x94','\x77'},{'\x00','\x00'},{'\x8a','\xc4'},{'\x87','\xd8'},{'\xfb','\x57'},
+    {'\x86','\xcf'},{'\x90','\xc0'},{'\x8e','\x70'},{'\xd5','\x6b'},{'\xd9','\x64'},
+    {'\x00','\x00'},{'\xb4','\x7a'},{'\x9a','\xaa'},{'\xd9','\x6a'},{'\xd9','\x59'},
+    {'\xd9','\x67'},{'\xdd','\x77'},{'\xb4','\x7d'},{'\xd9','\x6b'},{'\xd9','\x6e'},
+    {'\xb4','\x7c'},{'\xd9','\x5c'},{'\xd9','\x6d'},{'\xd9','\x6c'},{'\xb4','\x7e'},
+    {'\xd9','\x55'},{'\xb4','\x79'},{'\xb4','\xa3'},{'\xfd','\x6c'},{'\xb4','\xa1'},
+    {'\xd9','\x69'},{'\x00','\x00'},{'\xd9','\x5f'},{'\xb4','\xa5'},{'\xd9','\x70'},
+    {'\xd9','\x68'},{'\xd9','\x71'},{'\xb4','\xad'},{'\xb4','\xab'},{'\xd9','\x66'},
+    {'\xd9','\x65'},{'\x90','\xc1'},{'\xd9','\x63'},{'\xd9','\x5d'},{'\xb4','\xa4'},
+    {'\x9a','\xab'},{'\xb4','\xa2'},{'\xd1','\xb9'},{'\xd9','\x56'},{'\x9a','\xac'},
+    {'\xdd','\xb7'},{'\xd9','\x57'},{'\xb4','\x7b'},{'\xb4','\xaa'},{'\xdd','\x79'},
+    {'\x00','\x00'},{'\xb4','\xa6'},{'\xb4','\xa7'},{'\xd9','\x58'},{'\xd9','\x6f'},
+    {'\xdd','\x78'},{'\xd9','\x60'},{'\xd9','\x5b'},{'\xb4','\xa9'},{'\xd9','\x61'},
+    {'\xd9','\x5e'},{'\x00','\x00'},{'\xa0','\x5f'},{'\xb4','\xae'},{'\x90','\xc2'},
+    {'\x9a','\xad'},{'\xfb','\x5d'},{'\x8d','\x53'},{'\x9a','\xae'},{'\x87','\xd9'},
+    {'\x8b','\xf7'},{'\x89','\xdf'},{'\x86','\xcd'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x8c','\xf8'},{'\xb7','\x70'},{'\x9a','\xaf'},{'\x00','\x00'},{'\xdd','\x7c'},
+    {'\xdd','\xb1'},{'\xdd','\xb6'},{'\xdd','\xaa'},{'\xb7','\x6c'},{'\xdd','\xbb'},
+    {'\xb7','\x69'},{'\xdd','\x7a'},{'\x00','\x00'},{'\xdd','\x7b'},{'\xb7','\x62'},
+    {'\xb7','\x6b'},{'\xdd','\xa4'},{'\xb7','\x6e'},{'\xb7','\x6f'},{'\xdd','\xa5'},
+    {'\x00','\x00'},{'\xdd','\xb2'},{'\xdd','\xb8'},{'\xb7','\x6a'},{'\x00','\x00'},
+    {'\xb7','\x64'},{'\xdd','\xa3'},{'\xdd','\x7d'},{'\xdd','\xba'},{'\xdd','\xa8'},
+    {'\xdd','\xa9'},{'\xdd','\x7e'},{'\xdd','\xb4'},{'\xdd','\xab'},{'\xdd','\xb5'},
+    {'\xdd','\xad'},{'\x00','\x00'},{'\xb7','\x65'},{'\xe1','\xd9'},{'\xb7','\x68'},
+    {'\xb7','\x66'},{'\xdd','\xb9'},{'\xdd','\xb0'},{'\xdd','\xac'},{'\x00','\x00'},
+    {'\x9a','\xb0'},{'\xdd','\xa1'},{'\xba','\x53'},{'\xdd','\xaf'},{'\xb7','\x6d'},
+    {'\xdd','\xa7'},{'\x9a','\xb1'},{'\xdd','\xa6'},{'\x8c','\x74'},{'\x9a','\xb2'},
+    {'\x00','\x00'},{'\xb7','\x67'},{'\xb7','\x63'},{'\xe1','\xee'},{'\xdd','\xb3'},
+    {'\xdd','\xae'},{'\x93','\x45'},{'\xdd','\xa2'},{'\x8c','\x73'},{'\x8f','\x75'},
+    {'\x8a','\xc7'},{'\x93','\xda'},{'\x8f','\x52'},{'\x00','\x00'},{'\x8c','\xcf'},
+    {'\xe1','\xe9'},{'\x00','\x00'},{'\xe1','\xda'},{'\xe1','\xe5'},{'\x00','\x00'},
+    {'\xe1','\xec'},{'\xba','\x51'},{'\xb4','\xac'},{'\xe1','\xea'},{'\xba','\x4c'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xba','\x4b'},{'\xe1','\xf1'},
+    {'\x9a','\xb3'},{'\xe1','\xdb'},{'\xe1','\xe8'},{'\xe1','\xdc'},{'\xe1','\xe7'},
+    {'\xba','\x4f'},{'\xe1','\xeb'},{'\xd9','\x62'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe1','\xf2'},{'\xe1','\xe3'},{'\xba','\x52'},{'\xe5','\xba'},
+    {'\xbc','\xaf'},{'\x00','\x00'},{'\xe1','\xf0'},{'\xe1','\xef'},{'\xba','\x54'},
+    {'\xe5','\xad'},{'\xbc','\xb0'},{'\xe5','\xae'},{'\x9a','\xb4'},{'\xe1','\xdf'},
+    {'\xe1','\xe0'},{'\xe1','\xdd'},{'\xe1','\xe2'},{'\xe1','\xde'},{'\xe1','\xf3'},
+    {'\xba','\x4e'},{'\xbc','\xb1'},{'\xba','\x50'},{'\xba','\x55'},{'\x9a','\xb5'},
+    {'\xe1','\xe1'},{'\x00','\x00'},{'\xe1','\xed'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe1','\xe6'},{'\x92','\xb0'},{'\x8f','\xda'},{'\xe5','\xb1'},{'\x00','\x00'},
+    {'\xba','\x4a'},{'\xbc','\xb4'},{'\xe9','\xaa'},{'\xe5','\xb6'},{'\xe5','\xb5'},
+    {'\xe5','\xb7'},{'\x9a','\xb6'},{'\x00','\x00'},{'\xe5','\xb4'},{'\xbc','\xb5'},
+    {'\x90','\xc3'},{'\xbc','\xbb'},{'\xbc','\xb8'},{'\x00','\x00'},{'\xbc','\xb9'},
+    {'\xe5','\xaf'},{'\xe5','\xb2'},{'\xe5','\xbc'},{'\xbc','\xc1'},{'\xbc','\xbf'},
+    {'\x00','\x00'},{'\xe5','\xb3'},{'\xd9','\x5a'},{'\xbc','\xb2'},{'\xe5','\xb9'},
+    {'\xe5','\xb0'},{'\x00','\x00'},{'\xbc','\xc2'},{'\xe5','\xb8'},{'\xba','\x4d'},
+    {'\xbc','\xb7'},{'\xe1','\xe4'},{'\x00','\x00'},{'\x00','\x00'},{'\xbc','\xba'},
+    {'\x00','\x00'},{'\xbc','\xbe'},{'\xbc','\xc0'},{'\xbc','\xbd'},{'\xbc','\xbc'},
+    {'\x9a','\xb7'},{'\xbc','\xb6'},{'\xe5','\xbb'},{'\xbc','\xb3'},{'\xbc','\xc3'},
+    {'\x9a','\xb8'},{'\x8a','\xc6'},{'\x9a','\xb9'},{'\x8a','\xc9'},{'\x8f','\x76'},
+    {'\x82','\x4d'},{'\x8f','\xfe'},{'\xbe','\xd8'},{'\xbe','\xd9'},{'\xe9','\xa9'},
+    {'\xbe','\xe2'},{'\xbe','\xdf'},{'\x90','\xc4'},{'\xbe','\xd6'},{'\xbe','\xdd'},
+    {'\xe9','\xab'},{'\xbe','\xdb'},{'\xbe','\xd5'},{'\x00','\x00'},{'\xbe','\xdc'},
+    {'\x00','\x00'},{'\xe9','\xa8'},{'\xc0','\xbb'},{'\xbe','\xd7'},{'\x00','\x00'},
+    {'\xbe','\xde'},{'\xc0','\xba'},{'\xe9','\xa7'},{'\xe9','\xa6'},{'\x00','\x00'},
+    {'\xbe','\xe0'},{'\xa0','\x5d'},{'\xbe','\xe1'},{'\x00','\x00'},{'\xe9','\xa5'},
+    {'\xe9','\xa4'},{'\xc0','\xbc'},{'\xe9','\xae'},{'\xbe','\xda'},{'\xe9','\xac'},
+    {'\x00','\x00'},{'\x9a','\xba'},{'\x8a','\xc8'},{'\x00','\x00'},{'\xc0','\xbd'},
+    {'\x90','\xc5'},{'\xc0','\xc2'},{'\xec','\xea'},{'\xec','\xec'},{'\x9a','\xbb'},
+    {'\xc0','\xbf'},{'\xfb','\xa3'},{'\xec','\xed'},{'\xec','\xe9'},{'\x95','\xc8'},
+    {'\xec','\xeb'},{'\xc0','\xc0'},{'\xc0','\xc3'},{'\x00','\x00'},{'\xec','\xe8'},
+    {'\xc0','\xbe'},{'\xc0','\xc1'},{'\xc2','\x59'},{'\xe9','\xad'},{'\xc2','\x58'},
+    {'\x00','\x00'},{'\x90','\xc6'},{'\xc2','\x5e'},{'\xef','\xd4'},{'\x00','\x00'},
+    {'\xc2','\x5c'},{'\xc2','\x5d'},{'\xef','\xd7'},{'\xef','\xd3'},{'\xc2','\x5a'},
+    {'\xef','\xd1'},{'\xc3','\x6b'},{'\xef','\xd5'},{'\x00','\x00'},{'\xef','\xd6'},
+    {'\xef','\xd2'},{'\x90','\xc7'},{'\xc2','\x5b'},{'\xf2','\x42'},{'\x00','\x00'},
+    {'\xf2','\x45'},{'\x9a','\xbc'},{'\x00','\x00'},{'\xf2','\x46'},{'\xf2','\x44'},
+    {'\xf2','\x47'},{'\xc3','\x6c'},{'\xf2','\x43'},{'\x9a','\xbd'},{'\x90','\x57'},
+    {'\xf4','\x4e'},{'\xc4','\x64'},{'\xf4','\x4d'},{'\xf4','\x4c'},{'\xf4','\x4b'},
+    {'\xc4','\x63'},{'\xc4','\x65'},{'\x00','\x00'},{'\xf5','\xcd'},{'\xc4','\xe2'},
+    {'\xc4','\xe1'},{'\xa0','\x60'},{'\x9a','\xbe'},{'\xf6','\xe1'},{'\xf6','\xe0'},
+    {'\xf6','\xe3'},{'\xc5','\xcb'},{'\xc5','\x75'},{'\xf7','\xdd'},{'\xf6','\xe2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf7','\xdc'},{'\xc5','\xcd'},{'\xc5','\xcc'},
+    {'\xc5','\xf3'},{'\xf8','\xa9'},{'\xf8','\xef'},{'\xa4','\xe4'},{'\xfe','\x5b'},
+    {'\x00','\x00'},{'\xd9','\x72'},{'\xe9','\xaf'},{'\xc6','\xd2'},{'\x90','\xc8'},
+    {'\xa6','\xac'},{'\xca','\xf7'},{'\xa7','\xf1'},{'\xa7','\xef'},{'\x00','\x00'},
+    {'\xa7','\xf0'},{'\x00','\x00'},{'\xcc','\xc1'},{'\xa9','\xf1'},{'\xac','\x46'},
+    {'\x00','\x00'},{'\xce','\xe7'},{'\x00','\x00'},{'\xce','\xe8'},{'\x00','\x00'},
+    {'\xac','\x47'},{'\xd1','\xce'},{'\x00','\x00'},{'\xae','\xc4'},{'\xae','\xc5'},
+    {'\xd1','\xcd'},{'\x00','\x00'},{'\x87','\xda'},{'\x95','\xb4'},{'\x90','\xc9'},
+    {'\xb1','\xd3'},{'\x00','\x00'},{'\xb1','\xcf'},{'\x00','\x00'},{'\xd5','\xa7'},
+    {'\xb1','\xd6'},{'\xb1','\xd5'},{'\xb1','\xce'},{'\xb1','\xd1'},{'\xb1','\xd4'},
+    {'\xb1','\xd0'},{'\x00','\x00'},{'\x89','\xe0'},{'\xd9','\x76'},{'\xb1','\xcd'},
+    {'\xb4','\xaf'},{'\x9a','\xbf'},{'\x00','\x00'},{'\x00','\x00'},{'\xb4','\xb1'},
+    {'\xb4','\xb2'},{'\xd9','\x75'},{'\xd9','\x78'},{'\xb4','\xb0'},{'\xd9','\x73'},
+    {'\xd9','\x77'},{'\x00','\x00'},{'\xd9','\x74'},{'\x90','\xca'},{'\xb7','\x71'},
+    {'\x9a','\xc0'},{'\x00','\x00'},{'\xdd','\xbc'},{'\x87','\xdb'},{'\x00','\x00'},
+    {'\xba','\x56'},{'\xe1','\xf4'},{'\xbe','\xe3'},{'\xbc','\xc4'},{'\xe5','\xbd'},
+    {'\xbc','\xc5'},{'\xbc','\xc6'},{'\xe5','\xbf'},{'\xe5','\xbe'},{'\xe5','\xc0'},
+    {'\xe9','\xb1'},{'\x00','\x00'},{'\x00','\x00'},{'\xe9','\xb0'},{'\xec','\xef'},
+    {'\xec','\xee'},{'\xc0','\xc4'},{'\xc0','\xc5'},{'\xf2','\x48'},{'\xfc','\xb7'},
+    {'\x9a','\xc1'},{'\xa4','\xe5'},{'\x90','\xcb'},{'\x93','\x42'},{'\x00','\x00'},
+    {'\x8a','\xbc'},{'\xd9','\x79'},{'\x00','\x00'},{'\x92','\xc7'},{'\x00','\x00'},
+    {'\xb4','\xb4'},{'\xb4','\xb3'},{'\xdd','\xbd'},{'\x8c','\x75'},{'\xef','\xd8'},
+    {'\xc4','\xe3'},{'\xf7','\xde'},{'\xa4','\xe6'},{'\x00','\x00'},{'\xae','\xc6'},
+    {'\x00','\x00'},{'\xb1','\xd8'},{'\xb1','\xd7'},{'\xd9','\x7a'},{'\xd9','\x7b'},
+    {'\xb7','\x72'},{'\xe1','\xf5'},{'\xba','\x57'},{'\xe9','\xb2'},{'\x00','\x00'},
+    {'\xa4','\xe7'},{'\xa5','\xb8'},{'\x00','\x00'},{'\xa9','\xf2'},{'\xcc','\xc2'},
+    {'\x84','\x53'},{'\xce','\xe9'},{'\xac','\x48'},{'\xb1','\xd9'},{'\x8a','\xca'},
+    {'\xd9','\x7c'},{'\xb4','\xb5'},{'\xb7','\x73'},{'\x00','\x00'},{'\xe5','\xc1'},
+    {'\xe5','\xc2'},{'\x00','\x00'},{'\x9a','\xc2'},{'\xec','\xf0'},{'\xc2','\x5f'},
+    {'\xf8','\xf0'},{'\xa4','\xe8'},{'\x00','\x00'},{'\xcc','\xc3'},{'\xa9','\xf3'},
+    {'\xac','\x49'},{'\x9a','\xc3'},{'\xce','\xea'},{'\x00','\x00'},{'\xae','\xc7'},
+    {'\xd1','\xd2'},{'\xd1','\xd0'},{'\xd1','\xd1'},{'\xae','\xc8'},{'\xd1','\xcf'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xb1','\xdb'},
+    {'\xb1','\xdc'},{'\xd5','\xa8'},{'\xb1','\xdd'},{'\xb1','\xda'},{'\xd9','\x7d'},
+    {'\x9a','\xc4'},{'\xd9','\x7e'},{'\xdd','\xbe'},{'\x9a','\xc5'},{'\x00','\x00'},
+    {'\xba','\x59'},{'\xba','\x58'},{'\x00','\x00'},{'\x90','\xcc'},{'\xec','\xf1'},
+    {'\xef','\xd9'},{'\x00','\x00'},{'\xf2','\x4a'},{'\xf2','\x49'},{'\xf4','\x4f'},
+    {'\xc6','\xd3'},{'\xc9','\x5e'},{'\xac','\x4a'},{'\x9a','\xc6'},{'\x00','\x00'},
+    {'\xa4','\xe9'},{'\xa5','\xb9'},{'\x8a','\xf6'},{'\xa6','\xae'},{'\xa6','\xad'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa6','\xaf'},{'\xa6','\xb0'},{'\xc9','\xee'},
+    {'\xc9','\xed'},{'\xca','\xf8'},{'\xa7','\xf2'},{'\xca','\xfb'},{'\xca','\xfa'},
+    {'\xca','\xf9'},{'\xca','\xfc'},{'\x83','\xba'},{'\x8b','\x77'},{'\x85','\xd0'},
+    {'\x00','\x00'},{'\xa9','\xf4'},{'\xcc','\xc9'},{'\xcc','\xc5'},{'\xcc','\xce'},
+    {'\x00','\x00'},{'\x9a','\xc7'},{'\xa9','\xfb'},{'\x00','\x00'},{'\xa9','\xf9'},
+    {'\xcc','\xca'},{'\xcc','\xc6'},{'\xcc','\xcd'},{'\xa9','\xf8'},{'\xaa','\x40'},
+    {'\xcc','\xc8'},{'\xcc','\xc4'},{'\xa9','\xfe'},{'\xcc','\xcb'},{'\xa9','\xf7'},
+    {'\xcc','\xcc'},{'\xa9','\xfa'},{'\xa9','\xfc'},{'\xcc','\xd0'},{'\xcc','\xcf'},
+    {'\xcc','\xc7'},{'\xa9','\xf6'},{'\xa9','\xf5'},{'\xa9','\xfd'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9a','\xc8'},{'\x88','\xe8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xce','\xef'},{'\xce','\xf5'},{'\x90','\xcd'},{'\xac','\x50'},{'\xac','\x4d'},
+    {'\xce','\xec'},{'\xce','\xf1'},{'\x9a','\xc9'},{'\xac','\x53'},{'\xac','\x4b'},
+    {'\xce','\xf0'},{'\xac','\x4e'},{'\xac','\x51'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xce','\xf3'},{'\x00','\x00'},{'\xac','\x4c'},{'\xce','\xf8'},{'\xac','\x4f'},
+    {'\x95','\xfe'},{'\xac','\x52'},{'\xce','\xed'},{'\xce','\xf2'},{'\xce','\xf6'},
+    {'\xce','\xee'},{'\xce','\xeb'},{'\x00','\x00'},{'\x00','\x00'},{'\xce','\xf7'},
+    {'\xce','\xf4'},{'\x90','\xce'},{'\x84','\x54'},{'\x00','\x00'},{'\x8d','\x46'},
+    {'\x90','\xcf'},{'\x00','\x00'},{'\xae','\xd0'},{'\xae','\xc9'},{'\xae','\xcc'},
+    {'\x90','\xd0'},{'\xae','\xcf'},{'\x00','\x00'},{'\xd1','\xd5'},{'\xfc','\x62'},
+    {'\xae','\xca'},{'\xd1','\xd3'},{'\x83','\xbb'},{'\xae','\xce'},{'\x9d','\x59'},
+    {'\x00','\x00'},{'\xae','\xcb'},{'\x00','\x00'},{'\xd1','\xd6'},{'\xae','\xcd'},
+    {'\x88','\xe6'},{'\x88','\xe7'},{'\x85','\xcf'},{'\x85','\xce'},{'\x90','\xd1'},
+    {'\x00','\x00'},{'\xd5','\xac'},{'\xb1','\xdf'},{'\xd5','\xab'},{'\xd5','\xad'},
+    {'\xb1','\xde'},{'\xb1','\xe3'},{'\xd1','\xd4'},{'\x00','\x00'},{'\xd5','\xaa'},
+    {'\xd5','\xae'},{'\x9a','\xca'},{'\xb1','\xe0'},{'\xd5','\xa9'},{'\xb1','\xe2'},
+    {'\xfc','\x63'},{'\xb1','\xe1'},{'\x90','\xd2'},{'\xd9','\xa7'},{'\x9a','\xcb'},
+    {'\xd9','\xa2'},{'\x00','\x00'},{'\xb4','\xb6'},{'\xb4','\xba'},{'\xb4','\xb7'},
+    {'\xd9','\xa5'},{'\xd9','\xa8'},{'\x90','\xd3'},{'\xb4','\xb8'},{'\x00','\x00'},
+    {'\xb4','\xb9'},{'\xb4','\xbe'},{'\xdd','\xc7'},{'\xd9','\xa6'},{'\xb4','\xbc'},
+    {'\xd9','\xa3'},{'\xd9','\xa1'},{'\x9a','\xcc'},{'\xb4','\xbd'},{'\x00','\x00'},
+    {'\xd9','\xa4'},{'\x92','\x7d'},{'\x87','\xdc'},{'\x90','\xd4'},{'\xb7','\x79'},
+    {'\x9a','\xcd'},{'\xdd','\xbf'},{'\xb7','\x76'},{'\xb7','\x77'},{'\xb7','\x75'},
+    {'\xdd','\xc4'},{'\xdd','\xc3'},{'\xdd','\xc0'},{'\xb7','\x7b'},{'\xfe','\x7a'},
+    {'\x00','\x00'},{'\xdd','\xc2'},{'\xb4','\xbb'},{'\x9a','\xce'},{'\x00','\x00'},
+    {'\xdd','\xc6'},{'\xdd','\xc1'},{'\xb7','\x78'},{'\xb7','\x74'},{'\xb7','\x7a'},
+    {'\xdd','\xc5'},{'\x9a','\xcf'},{'\x00','\x00'},{'\x00','\x00'},{'\xba','\x5c'},
+    {'\x00','\x00'},{'\xe1','\xf8'},{'\xe1','\xf7'},{'\xe1','\xf6'},{'\xba','\x5a'},
+    {'\x00','\x00'},{'\x9a','\xd0'},{'\x00','\x00'},{'\x93','\xef'},{'\x89','\xe2'},
+    {'\xba','\x5b'},{'\xe5','\xc5'},{'\xe5','\xc8'},{'\xbc','\xc8'},{'\x00','\x00'},
+    {'\x9a','\xd1'},{'\xbc','\xc7'},{'\xe5','\xc9'},{'\xe5','\xc4'},{'\xbc','\xca'},
+    {'\xe5','\xc6'},{'\x9a','\xd2'},{'\xbc','\xc9'},{'\xe5','\xc3'},{'\x9a','\xd3'},
+    {'\xe5','\xc7'},{'\xbe','\xe9'},{'\xbe','\xe6'},{'\xe9','\xbb'},{'\xe9','\xba'},
+    {'\x90','\xd5'},{'\xe9','\xb9'},{'\xe9','\xb4'},{'\x90','\xd6'},{'\xe9','\xb5'},
+    {'\x90','\xd7'},{'\x00','\x00'},{'\x00','\x00'},{'\xbe','\xe7'},{'\x00','\x00'},
+    {'\xbe','\xe4'},{'\xbe','\xe8'},{'\xe9','\xb3'},{'\xbe','\xe5'},{'\xe9','\xb6'},
+    {'\xe9','\xb7'},{'\xe9','\xbc'},{'\x9a','\xd4'},{'\x9a','\xd5'},{'\xe9','\xb8'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xec','\xf2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc0','\xc7'},{'\x00','\x00'},{'\xef','\xdc'},{'\xc0','\xc6'},
+    {'\xef','\xda'},{'\xef','\xdb'},{'\xc2','\x60'},{'\xc3','\x6e'},{'\xf2','\x4b'},
+    {'\x00','\x00'},{'\xc3','\x6d'},{'\x00','\x00'},{'\x00','\x00'},{'\xf4','\x51'},
+    {'\xf4','\x52'},{'\x00','\x00'},{'\xc4','\x66'},{'\x9d','\xca'},{'\xf4','\x50'},
+    {'\xc4','\xe4'},{'\x00','\x00'},{'\xf7','\xdf'},{'\xc5','\xce'},{'\xf8','\xaa'},
+    {'\xf8','\xab'},{'\x00','\x00'},{'\xa4','\xea'},{'\xa0','\x58'},{'\xa6','\xb1'},
+    {'\xa6','\xb2'},{'\xa7','\xf3'},{'\x90','\xd8'},{'\xcc','\xd1'},{'\xac','\x54'},
+    {'\xae','\xd1'},{'\xb1','\xe4'},{'\x90','\xd9'},{'\x90','\xda'},{'\xb0','\xd2'},
+    {'\x93','\xfb'},{'\xb4','\xbf'},{'\xb4','\xc0'},{'\xb3','\xcc'},{'\xd9','\xa9'},
+    {'\x9a','\xd6'},{'\xb7','\x7c'},{'\xe1','\xfa'},{'\xe1','\xf9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa4','\xeb'},{'\xa6','\xb3'},{'\xcc','\xd2'},{'\xaa','\x42'},
+    {'\x9a','\xd7'},{'\xaa','\x41'},{'\x90','\xdb'},{'\xce','\xf9'},{'\xce','\xfa'},
+    {'\x00','\x00'},{'\xd1','\xd7'},{'\xd1','\xd8'},{'\xae','\xd2'},{'\xae','\xd3'},
+    {'\x90','\xdc'},{'\xae','\xd4'},{'\xd5','\xaf'},{'\x9a','\xd8'},{'\x00','\x00'},
+    {'\xb1','\xe6'},{'\x00','\x00'},{'\xb4','\xc2'},{'\xfc','\x64'},{'\xb4','\xc1'},
+    {'\xdd','\xc8'},{'\xdf','\x7a'},{'\xe1','\xfb'},{'\xe9','\xbd'},{'\x00','\x00'},
+    {'\xfe','\x5e'},{'\xc2','\x61'},{'\xc4','\x67'},{'\xa4','\xec'},{'\x91','\xd1'},
+    {'\xa5','\xbc'},{'\xa5','\xbd'},{'\xa5','\xbb'},{'\xa5','\xbe'},{'\xa5','\xba'},
+    {'\x84','\x7b'},{'\x00','\x00'},{'\xa6','\xb6'},{'\x00','\x00'},{'\xc9','\xf6'},
+    {'\xa6','\xb5'},{'\xa6','\xb7'},{'\x95','\x7c'},{'\x90','\xdd'},{'\xc9','\xf1'},
+    {'\xc9','\xf0'},{'\xc9','\xf3'},{'\xc9','\xf2'},{'\xc9','\xf5'},{'\xa6','\xb4'},
+    {'\xc9','\xef'},{'\xc9','\xf4'},{'\x84','\x59'},{'\x94','\x78'},{'\x8b','\x59'},
+    {'\x8c','\xd0'},{'\x9a','\xd9'},{'\xca','\xfd'},{'\xa7','\xfd'},{'\xca','\xfe'},
+    {'\xcb','\x43'},{'\xa7','\xfc'},{'\x00','\x00'},{'\xcb','\x47'},{'\xcb','\x42'},
+    {'\xcb','\x45'},{'\xa7','\xf5'},{'\xa7','\xf6'},{'\xa7','\xf7'},{'\xa7','\xf8'},
+    {'\x00','\x00'},{'\xa8','\x40'},{'\x00','\x00'},{'\xcb','\x41'},{'\xa7','\xfa'},
+    {'\xa8','\x41'},{'\x00','\x00'},{'\xcb','\x40'},{'\xcb','\x46'},{'\x00','\x00'},
+    {'\xa7','\xf9'},{'\xcb','\x44'},{'\xa7','\xfb'},{'\xa7','\xf4'},{'\xa7','\xfe'},
+    {'\x84','\x57'},{'\x94','\x5c'},{'\x94','\x79'},{'\x90','\xde'},{'\x83','\x53'},
+    {'\x90','\xdf'},{'\xfb','\xa6'},{'\x85','\xd4'},{'\x8e','\x72'},{'\xaa','\x57'},
+    {'\x9a','\xda'},{'\xcc','\xd4'},{'\xaa','\x43'},{'\x9d','\x72'},{'\xaa','\x4d'},
+    {'\xaa','\x4e'},{'\xaa','\x46'},{'\xaa','\x58'},{'\xaa','\x48'},{'\xcc','\xdc'},
+    {'\xaa','\x53'},{'\xcc','\xd7'},{'\xaa','\x49'},{'\xcc','\xe6'},{'\xcc','\xe7'},
+    {'\xcc','\xdf'},{'\xcc','\xd8'},{'\xaa','\x56'},{'\xcc','\xe4'},{'\xaa','\x51'},
+    {'\xaa','\x4f'},{'\x00','\x00'},{'\xcc','\xe5'},{'\x00','\x00'},{'\xcc','\xe3'},
+    {'\xcc','\xdb'},{'\xcc','\xd3'},{'\xcc','\xda'},{'\xaa','\x4a'},{'\x00','\x00'},
+    {'\xaa','\x50'},{'\x00','\x00'},{'\xaa','\x44'},{'\xcc','\xde'},{'\xcc','\xdd'},
+    {'\xcc','\xd5'},{'\x9a','\xdb'},{'\xaa','\x52'},{'\xcc','\xe1'},{'\xcc','\xd6'},
+    {'\xaa','\x55'},{'\xcc','\xe8'},{'\xaa','\x45'},{'\x00','\x00'},{'\xaa','\x4c'},
+    {'\xcc','\xd9'},{'\xcc','\xe2'},{'\xaa','\x54'},{'\x00','\x00'},{'\xaa','\x47'},
+    {'\xaa','\x4b'},{'\x87','\xe5'},{'\xcc','\xe0'},{'\x94','\xfd'},{'\x94','\x7a'},
+    {'\x87','\xe0'},{'\x84','\xe5'},{'\x9a','\xdc'},{'\x8f','\xdc'},{'\x90','\xe0'},
+    {'\x90','\xe1'},{'\x8d','\xdf'},{'\x90','\xe2'},{'\x86','\xd2'},{'\x85','\xd6'},
+    {'\xfc','\x66'},{'\x84','\x58'},{'\xcf','\x5b'},{'\xac','\x5c'},{'\xac','\x69'},
+    {'\x95','\x45'},{'\xcf','\x56'},{'\xcf','\x4c'},{'\xac','\x62'},{'\xcf','\x4a'},
+    {'\xac','\x5b'},{'\xcf','\x45'},{'\xac','\x65'},{'\xcf','\x52'},{'\xce','\xfe'},
+    {'\xcf','\x41'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9a','\xdd'},
+    {'\xcf','\x44'},{'\xce','\xfb'},{'\xcf','\x51'},{'\xcf','\x61'},{'\xac','\x60'},
+    {'\xcf','\x46'},{'\xcf','\x58'},{'\x00','\x00'},{'\xce','\xfd'},{'\xcf','\x5f'},
+    {'\xcf','\x60'},{'\xcf','\x63'},{'\xcf','\x5a'},{'\xcf','\x4b'},{'\xcf','\x53'},
+    {'\xac','\x66'},{'\xac','\x59'},{'\xac','\x61'},{'\xac','\x6d'},{'\xac','\x56'},
+    {'\xac','\x58'},{'\x00','\x00'},{'\x9a','\xde'},{'\x9a','\xdf'},{'\xcf','\x43'},
+    {'\xac','\x6a'},{'\xac','\x63'},{'\xcf','\x5d'},{'\xcf','\x40'},{'\xac','\x6c'},
+    {'\xac','\x67'},{'\xcf','\x49'},{'\x8a','\xce'},{'\x00','\x00'},{'\xac','\x6b'},
+    {'\xcf','\x50'},{'\xcf','\x48'},{'\xac','\x64'},{'\xcf','\x5c'},{'\xcf','\x54'},
+    {'\x00','\x00'},{'\xac','\x5e'},{'\xcf','\x62'},{'\xcf','\x47'},{'\xac','\x5a'},
+    {'\xcf','\x59'},{'\xcf','\x4f'},{'\xac','\x5f'},{'\xcf','\x55'},{'\xac','\x57'},
+    {'\xce','\xfc'},{'\xac','\x68'},{'\xae','\xe3'},{'\xac','\x5d'},{'\xcf','\x4e'},
+    {'\xcf','\x4d'},{'\xcf','\x42'},{'\xfc','\x67'},{'\xcf','\x5e'},{'\x90','\xe3'},
+    {'\xcf','\x57'},{'\x90','\xe4'},{'\x94','\x5a'},{'\xac','\x55'},{'\x90','\xe5'},
+    {'\x90','\xe6'},{'\x94','\x4d'},{'\x94','\x51'},{'\x92','\x48'},{'\x90','\xe7'},
+    {'\x00','\x00'},{'\x87','\xe1'},{'\x84','\xe7'},{'\x89','\xe6'},{'\x8f','\xdb'},
+    {'\x84','\xe6'},{'\x8f','\xdd'},{'\x9a','\xe1'},{'\x8f','\xba'},{'\x8c','\x77'},
+    {'\x9a','\xe2'},{'\x88','\xeb'},{'\xd1','\xec'},{'\xae','\xea'},{'\xd1','\xed'},
+    {'\x00','\x00'},{'\xd1','\xe1'},{'\xae','\xdf'},{'\xae','\xeb'},{'\x00','\x00'},
+    {'\xd1','\xda'},{'\x9a','\xe3'},{'\xd1','\xe3'},{'\xd1','\xeb'},{'\x90','\xe8'},
+    {'\xd1','\xd9'},{'\xd1','\xf4'},{'\xae','\xd5'},{'\xfe','\x45'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd1','\xf3'},{'\xd1','\xee'},{'\x00','\x00'},{'\xd1','\xef'},
+    {'\xae','\xdd'},{'\xae','\xe8'},{'\xd1','\xe5'},{'\x00','\x00'},{'\xd1','\xe6'},
+    {'\xd1','\xf0'},{'\xd1','\xe7'},{'\x00','\x00'},{'\xd1','\xe2'},{'\xd1','\xdc'},
+    {'\xd1','\xdd'},{'\xd1','\xea'},{'\xd1','\xe4'},{'\x9a','\xe4'},{'\x87','\xde'},
+    {'\xae','\xd6'},{'\xae','\xda'},{'\xd1','\xf2'},{'\xd1','\xde'},{'\xae','\xe6'},
+    {'\xae','\xe2'},{'\x90','\x6a'},{'\x00','\x00'},{'\xae','\xe5'},{'\xae','\xec'},
+    {'\xae','\xdb'},{'\xae','\xe7'},{'\xd1','\xe9'},{'\xae','\xe9'},{'\xae','\xd8'},
+    {'\x9a','\xe5'},{'\xae','\xd7'},{'\xd1','\xdb'},{'\x90','\xe9'},{'\xd1','\xdf'},
+    {'\xae','\xe0'},{'\xd1','\xf1'},{'\xd1','\xe8'},{'\xd1','\xe0'},{'\xae','\xe4'},
+    {'\xae','\xe1'},{'\x90','\xea'},{'\xae','\xd9'},{'\xae','\xdc'},{'\x90','\xeb'},
+    {'\x9a','\xe6'},{'\x00','\x00'},{'\x00','\x00'},{'\x90','\xec'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x92','\x51'},{'\x82','\x7c'},{'\x00','\x00'},{'\x92','\xcc'},
+    {'\x8d','\xde'},{'\x88','\xef'},{'\x85','\xd5'},{'\x89','\xe3'},{'\x8e','\x71'},
+    {'\x88','\xed'},{'\x88','\xe9'},{'\x89','\xe5'},{'\x87','\xe3'},{'\x87','\xdf'},
+    {'\x00','\x00'},{'\xd5','\xc4'},{'\x00','\x00'},{'\xd5','\xb4'},{'\xd5','\xb5'},
+    {'\xd5','\xb9'},{'\x00','\x00'},{'\xd5','\xc8'},{'\xd5','\xc5'},{'\x00','\x00'},
+    {'\xd5','\xbe'},{'\xd5','\xbd'},{'\xb1','\xed'},{'\xd5','\xc1'},{'\xd5','\xd0'},
+    {'\xd5','\xb0'},{'\x00','\x00'},{'\xd5','\xd1'},{'\xd5','\xc3'},{'\xd5','\xd5'},
+    {'\xd5','\xc9'},{'\xb1','\xec'},{'\xd5','\xc7'},{'\xb1','\xe7'},{'\xb1','\xfc'},
+    {'\xb1','\xf2'},{'\x9a','\xe7'},{'\xb1','\xf6'},{'\xb1','\xf5'},{'\xd5','\xb1'},
+    {'\x9a','\xe8'},{'\xd5','\xce'},{'\xd5','\xd4'},{'\xd5','\xcc'},{'\xd5','\xd3'},
+    {'\x90','\xed'},{'\x00','\x00'},{'\xd5','\xc0'},{'\xd5','\xb2'},{'\xd5','\xd2'},
+    {'\xd5','\xc2'},{'\xb1','\xea'},{'\xb1','\xf7'},{'\x00','\x00'},{'\xd5','\xcb'},
+    {'\xb1','\xf0'},{'\xfb','\x58'},{'\x00','\x00'},{'\x00','\x00'},{'\xd5','\xca'},
+    {'\xd5','\xb3'},{'\xb1','\xf8'},{'\x00','\x00'},{'\xb1','\xfa'},{'\xd5','\xcd'},
+    {'\xb1','\xfb'},{'\xb1','\xe9'},{'\xd5','\xba'},{'\xd5','\xcf'},{'\x00','\x00'},
+    {'\x86','\xbb'},{'\xb1','\xef'},{'\xb1','\xf9'},{'\xd5','\xbc'},{'\xd5','\xc6'},
+    {'\xd5','\xb7'},{'\xd5','\xbb'},{'\xb1','\xf4'},{'\xd5','\xb6'},{'\xb1','\xe8'},
+    {'\xb1','\xf1'},{'\xb1','\xee'},{'\xd5','\xbf'},{'\xae','\xde'},{'\xd9','\xc0'},
+    {'\xb1','\xeb'},{'\xfc','\x68'},{'\x00','\x00'},{'\x00','\x00'},{'\x90','\xee'},
+    {'\x94','\x7b'},{'\x00','\x00'},{'\x82','\x6f'},{'\x9a','\xe9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x89','\xe4'},{'\x00','\x00'},{'\x8c','\x78'},{'\x9a','\xea'},
+    {'\xb1','\xf3'},{'\x9a','\xeb'},{'\xd9','\xc3'},{'\xd9','\xd9'},{'\xd9','\xce'},
+    {'\xb4','\xd6'},{'\xfc','\x6c'},{'\xb4','\xd1'},{'\xd9','\xbd'},{'\xb4','\xd2'},
+    {'\xd9','\xcd'},{'\x90','\xef'},{'\xd9','\xc6'},{'\xd9','\xd3'},{'\xb4','\xce'},
+    {'\xd9','\xab'},{'\xd9','\xd5'},{'\xb4','\xc4'},{'\xd9','\xb3'},{'\xb4','\xc7'},
+    {'\xb4','\xc6'},{'\x00','\x00'},{'\xb4','\xd7'},{'\x00','\x00'},{'\xd9','\xad'},
+    {'\xd9','\xcf'},{'\xd9','\xd0'},{'\xb4','\xc9'},{'\xb4','\xc5'},{'\xd9','\xbb'},
+    {'\x00','\x00'},{'\xb4','\xd0'},{'\xd9','\xb6'},{'\x00','\x00'},{'\xd9','\xd1'},
+    {'\xb4','\xcc'},{'\xd9','\xc9'},{'\xd9','\xd6'},{'\xd9','\xb0'},{'\xd9','\xb5'},
+    {'\xd9','\xaf'},{'\x00','\x00'},{'\xb4','\xcb'},{'\xd9','\xc2'},{'\xdd','\xde'},
+    {'\xd9','\xb1'},{'\xb4','\xcf'},{'\xd9','\xba'},{'\xd9','\xd2'},{'\xb4','\xca'},
+    {'\xd9','\xb7'},{'\xd9','\xb4'},{'\xd9','\xc5'},{'\xb4','\xcd'},{'\xb4','\xc3'},
+    {'\xb4','\xd9'},{'\xd9','\xc8'},{'\xd9','\xc7'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xfc','\x6b'},{'\xfc','\x6a'},{'\x9a','\xec'},{'\x9a','\xed'},{'\xd9','\xac'},
+    {'\xb4','\xc8'},{'\xd9','\xd4'},{'\xd9','\xbc'},{'\xd9','\xbe'},{'\x9a','\xee'},
+    {'\xd9','\xcb'},{'\xd9','\xca'},{'\xd9','\xaa'},{'\xb4','\xd3'},{'\xb4','\xd5'},
+    {'\xd9','\xb2'},{'\xd9','\xb9'},{'\xd9','\xc1'},{'\xb4','\xd4'},{'\xd9','\xb8'},
+    {'\xd9','\xc4'},{'\xd9','\xd7'},{'\x00','\x00'},{'\xd9','\xcc'},{'\x9a','\xef'},
+    {'\x94','\x49'},{'\xfe','\x4f'},{'\x94','\x41'},{'\x92','\xb6'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8b','\x79'},{'\x8e','\xb8'},{'\x94','\xa2'},{'\x90','\xf3'},
+    {'\x94','\xa1'},{'\x90','\x6b'},{'\xd9','\xd8'},{'\x90','\xf4'},{'\x00','\x00'},
+    {'\x94','\x7d'},{'\x00','\x00'},{'\xd9','\xae'},{'\x00','\x00'},{'\xfc','\x69'},
+    {'\x88','\xec'},{'\x00','\x00'},{'\xdd','\xf2'},{'\xb7','\xa6'},{'\x00','\x00'},
+    {'\xdd','\xf0'},{'\xdd','\xdb'},{'\xdd','\xe0'},{'\xdd','\xd9'},{'\x90','\xfd'},
+    {'\xdd','\xec'},{'\xdd','\xcb'},{'\xdd','\xd2'},{'\x00','\x00'},{'\xdd','\xea'},
+    {'\xdd','\xf4'},{'\xdd','\xdc'},{'\xfc','\x6f'},{'\xdd','\xcf'},{'\xdd','\xe2'},
+    {'\xdd','\xe7'},{'\xdd','\xd3'},{'\x9a','\xf0'},{'\xdd','\xe4'},{'\xdd','\xd0'},
+    {'\x9a','\xf1'},{'\x00','\x00'},{'\xdd','\xd7'},{'\xdd','\xd8'},{'\xb7','\xa8'},
+    {'\xdd','\xeb'},{'\xdd','\xe9'},{'\x00','\x00'},{'\xdd','\xcc'},{'\xdd','\xee'},
+    {'\x00','\x00'},{'\xdd','\xef'},{'\xdd','\xf1'},{'\xb7','\xac'},{'\xb7','\xa4'},
+    {'\x82','\x6c'},{'\xd5','\xb8'},{'\xdd','\xd4'},{'\xdd','\xe6'},{'\xdd','\xd5'},
+    {'\xb7','\xa1'},{'\xb7','\xb1'},{'\xdd','\xed'},{'\xb7','\xaf'},{'\xb7','\xab'},
+    {'\xdd','\xca'},{'\xb7','\xa3'},{'\x90','\xfe'},{'\xdd','\xcd'},{'\xb7','\xb0'},
+    {'\x9a','\xf2'},{'\xdd','\xdd'},{'\xdd','\xc9'},{'\x9a','\xf3'},{'\xb7','\xa9'},
+    {'\xdd','\xe1'},{'\xdd','\xd1'},{'\xb7','\xaa'},{'\xdd','\xda'},{'\xb7','\x7e'},
+    {'\xb4','\xd8'},{'\xdd','\xe3'},{'\xd9','\xbf'},{'\xdd','\xce'},{'\x9a','\xf4'},
+    {'\xfc','\x6d'},{'\xdd','\xe8'},{'\xb7','\xa5'},{'\xdd','\xe5'},{'\xb7','\xa2'},
+    {'\xdd','\xdf'},{'\xb7','\xad'},{'\xdd','\xd6'},{'\xdd','\xf3'},{'\x87','\xe2'},
+    {'\x92','\x62'},{'\x94','\xa3'},{'\x00','\x00'},{'\xfc','\x6e'},{'\x94','\xa4'},
+    {'\xb7','\xa7'},{'\xde','\xc6'},{'\x8d','\x6e'},{'\x9a','\xf5'},{'\xb7','\xae'},
+    {'\x8b','\xf9'},{'\x8b','\x7a'},{'\x90','\x40'},{'\x94','\x45'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe2','\x4a'},{'\xe2','\x48'},{'\x00','\x00'},{'\xe2','\x5e'},
+    {'\xe2','\x46'},{'\x00','\x00'},{'\xe2','\x58'},{'\xb7','\x7d'},{'\xba','\x5f'},
+    {'\xe2','\x42'},{'\xe2','\x5d'},{'\x95','\x67'},{'\xe2','\x47'},{'\xe2','\x55'},
+    {'\xba','\x64'},{'\xba','\x5d'},{'\x00','\x00'},{'\xe2','\x5b'},{'\x9a','\xf6'},
+    {'\xe2','\x40'},{'\xe2','\x5a'},{'\x9a','\xf7'},{'\xba','\x6f'},{'\xe2','\x51'},
+    {'\xe2','\x61'},{'\xba','\x6d'},{'\xe2','\x49'},{'\xba','\x5e'},{'\xe2','\x4b'},
+    {'\xe2','\x59'},{'\xba','\x67'},{'\xe2','\x44'},{'\xba','\x6b'},{'\xba','\x61'},
+    {'\xe2','\x4d'},{'\xe2','\x43'},{'\xe1','\xfc'},{'\xfc','\x71'},{'\xe2','\x57'},
+    {'\xba','\x68'},{'\xe2','\x60'},{'\xe1','\xfd'},{'\xba','\x65'},{'\x00','\x00'},
+    {'\xe2','\x53'},{'\x00','\x00'},{'\xba','\x66'},{'\xe2','\x45'},{'\xe2','\x50'},
+    {'\xe2','\x4c'},{'\xe2','\x4e'},{'\xfc','\x72'},{'\xba','\x60'},{'\xe2','\x5f'},
+    {'\xba','\x6e'},{'\xe2','\x4f'},{'\x00','\x00'},{'\xe2','\x62'},{'\x91','\xee'},
+    {'\x00','\x00'},{'\xe1','\xfe'},{'\xe2','\x54'},{'\xba','\x63'},{'\xba','\x6c'},
+    {'\xba','\x6a'},{'\xe2','\x41'},{'\xe2','\x56'},{'\xba','\x69'},{'\x9a','\xf8'},
+    {'\x00','\x00'},{'\xba','\x62'},{'\xe2','\x52'},{'\x9a','\xf9'},{'\x9a','\xfa'},
+    {'\x00','\x00'},{'\x93','\xdb'},{'\xe2','\x5c'},{'\x00','\x00'},{'\x8a','\xcd'},
+    {'\x00','\x00'},{'\x94','\xa5'},{'\x96','\x7d'},{'\x8a','\xcb'},{'\x8f','\xb9'},
+    {'\x9b','\x41'},{'\xe5','\xd5'},{'\x00','\x00'},{'\xe5','\xd1'},{'\xe5','\xcd'},
+    {'\xe5','\xe1'},{'\xe5','\xde'},{'\xbc','\xcd'},{'\xfc','\x75'},{'\x00','\x00'},
+    {'\xe5','\xe5'},{'\xe5','\xd4'},{'\xbc','\xd8'},{'\xe5','\xdb'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe5','\xd0'},{'\xe5','\xda'},{'\xbc','\xd5'},{'\xe5','\xee'},
+    {'\x00','\x00'},{'\xe5','\xeb'},{'\xe5','\xdd'},{'\xe5','\xce'},{'\x96','\x7e'},
+    {'\xfc','\x74'},{'\xe5','\xe2'},{'\xe5','\xe4'},{'\xbc','\xd1'},{'\xe5','\xd8'},
+    {'\xe5','\xd3'},{'\xe5','\xca'},{'\xbc','\xce'},{'\xbc','\xd6'},{'\x9b','\x42'},
+    {'\xe5','\xe7'},{'\xbc','\xd7'},{'\xe5','\xcb'},{'\xe5','\xed'},{'\xe5','\xe0'},
+    {'\xe5','\xe6'},{'\xbc','\xd4'},{'\xfe','\x54'},{'\x96','\xce'},{'\xe5','\xe3'},
+    {'\x00','\x00'},{'\xe5','\xea'},{'\x00','\x00'},{'\xbc','\xd9'},{'\x96','\xeb'},
+    {'\xbc','\xd3'},{'\xe5','\xdc'},{'\xe5','\xcf'},{'\xe5','\xef'},{'\xe5','\xcc'},
+    {'\xe5','\xe8'},{'\xbc','\xd0'},{'\x9b','\x43'},{'\xe5','\xd6'},{'\x9b','\x44'},
+    {'\xe5','\xd7'},{'\xbc','\xcf'},{'\xbc','\xcc'},{'\xe5','\xd2'},{'\xbc','\xd2'},
+    {'\x96','\xec'},{'\xbc','\xcb'},{'\x00','\x00'},{'\xe5','\xe9'},{'\xe5','\xec'},
+    {'\xe5','\xd9'},{'\xe9','\xca'},{'\x92','\xb7'},{'\x88','\xea'},{'\x94','\x40'},
+    {'\x9b','\x45'},{'\x9b','\x46'},{'\x94','\xa6'},{'\x89','\xe7'},{'\x96','\xed'},
+    {'\x8c','\x76'},{'\xe9','\xc2'},{'\x9b','\x47'},{'\xe9','\xbe'},{'\xbe','\xf6'},
+    {'\x96','\xee'},{'\x00','\x00'},{'\xbe','\xeb'},{'\xbe','\xf0'},{'\xbe','\xec'},
+    {'\xe9','\xcc'},{'\xe9','\xd7'},{'\xbe','\xea'},{'\xe9','\xc4'},{'\xe9','\xcd'},
+    {'\xe5','\xdf'},{'\xe9','\xce'},{'\x00','\x00'},{'\x9b','\x48'},{'\xbe','\xf1'},
+    {'\x9b','\x49'},{'\xe9','\xdd'},{'\xbe','\xf5'},{'\xbe','\xf8'},{'\xe9','\xc0'},
+    {'\x00','\x00'},{'\xbe','\xf4'},{'\x9b','\x4a'},{'\xe9','\xdb'},{'\xe9','\xdc'},
+    {'\xe9','\xd2'},{'\xe9','\xd1'},{'\xe9','\xc9'},{'\xfc','\x77'},{'\x9b','\x4b'},
+    {'\xe9','\xd3'},{'\xe9','\xda'},{'\xe9','\xd9'},{'\x9b','\x4c'},{'\xbe','\xef'},
+    {'\xbe','\xed'},{'\xe9','\xcb'},{'\xe9','\xc8'},{'\x00','\x00'},{'\xe9','\xc5'},
+    {'\xe9','\xd8'},{'\xbe','\xf7'},{'\xe9','\xd6'},{'\xbe','\xf3'},{'\xbe','\xf2'},
+    {'\x9b','\x4d'},{'\xe9','\xd0'},{'\x96','\xef'},{'\xe9','\xbf'},{'\xe9','\xc1'},
+    {'\xe9','\xc3'},{'\xe9','\xd5'},{'\xe9','\xcf'},{'\xbe','\xee'},{'\x00','\x00'},
+    {'\xe9','\xc6'},{'\x00','\x00'},{'\xe9','\xd4'},{'\x00','\x00'},{'\x8b','\x78'},
+    {'\x94','\xa7'},{'\x96','\xf8'},{'\x9b','\x4e'},{'\x00','\x00'},{'\xe9','\xc7'},
+    {'\x00','\x00'},{'\x96','\xf9'},{'\x8b','\x7b'},{'\x94','\x7e'},{'\x00','\x00'},
+    {'\x96','\xfc'},{'\x00','\x00'},{'\xc0','\xcf'},{'\xed','\x45'},{'\xc0','\xc8'},
+    {'\xec','\xf5'},{'\x9b','\x4f'},{'\xed','\x41'},{'\xc0','\xca'},{'\xed','\x48'},
+    {'\x00','\x00'},{'\xec','\xfc'},{'\x00','\x00'},{'\xec','\xf7'},{'\x9b','\x50'},
+    {'\x00','\x00'},{'\xed','\x49'},{'\xec','\xf3'},{'\xec','\xfe'},{'\x9b','\x51'},
+    {'\xc0','\xd1'},{'\xed','\x44'},{'\xed','\x4a'},{'\xec','\xfd'},{'\xc0','\xc9'},
+    {'\xed','\x40'},{'\xec','\xf4'},{'\xc0','\xd0'},{'\x00','\x00'},{'\x9b','\x52'},
+    {'\xed','\x47'},{'\xec','\xf9'},{'\xc0','\xcc'},{'\xfc','\x78'},{'\xec','\xfb'},
+    {'\xec','\xf8'},{'\xc0','\xd2'},{'\xec','\xfa'},{'\xc0','\xcb'},{'\xc0','\xce'},
+    {'\xed','\x43'},{'\xec','\xf6'},{'\xed','\x46'},{'\x9b','\x53'},{'\xed','\x42'},
+    {'\x96','\xfd'},{'\x96','\xfe'},{'\x99','\xfe'},{'\xc2','\x63'},{'\xef','\xe7'},
+    {'\xc2','\x68'},{'\xc2','\x69'},{'\x00','\x00'},{'\x9b','\x54'},{'\xfc','\x76'},
+    {'\xc2','\x62'},{'\xef','\xe6'},{'\x9b','\x55'},{'\xef','\xe3'},{'\xef','\xe4'},
+    {'\xc2','\x66'},{'\xef','\xde'},{'\xef','\xe2'},{'\xc2','\x65'},{'\x00','\x00'},
+    {'\xef','\xdf'},{'\x9b','\x56'},{'\x00','\x00'},{'\x00','\x00'},{'\x9a','\xfe'},
+    {'\xc2','\x67'},{'\xc2','\x64'},{'\x00','\x00'},{'\xef','\xdd'},{'\xef','\xe1'},
+    {'\xef','\xe5'},{'\x95','\xe3'},{'\x9b','\x57'},{'\xfb','\xdc'},{'\xf2','\x51'},
+    {'\xf2','\x4e'},{'\xf2','\x57'},{'\x00','\x00'},{'\xf2','\x56'},{'\xf2','\x54'},
+    {'\xf2','\x4f'},{'\x00','\x00'},{'\xc3','\x72'},{'\x9b','\x58'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9b','\x59'},{'\xf2','\x50'},{'\xc3','\x71'},
+    {'\xc0','\xcd'},{'\xf2','\x53'},{'\xc3','\x70'},{'\xf2','\x58'},{'\xf2','\x52'},
+    {'\xf2','\x4d'},{'\xef','\xe0'},{'\x9c','\xf9'},{'\x00','\x00'},{'\x9d','\xe1'},
+    {'\xc3','\x6f'},{'\x00','\x00'},{'\xf2','\x4c'},{'\xf4','\x56'},{'\x00','\x00'},
+    {'\xf4','\x55'},{'\xf2','\x55'},{'\xc4','\x68'},{'\x00','\x00'},{'\xf4','\x59'},
+    {'\xf4','\x5a'},{'\xf4','\x54'},{'\xf4','\x58'},{'\x00','\x00'},{'\xf4','\x53'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9b','\x5a'},{'\x00','\x00'},{'\xf5','\xd1'},
+    {'\xf4','\x57'},{'\xc4','\xe7'},{'\xc4','\xe5'},{'\xf5','\xcf'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf5','\xd2'},{'\x00','\x00'},{'\xf5','\xce'},
+    {'\xf5','\xd0'},{'\xc4','\xe6'},{'\x9d','\xfe'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf6','\xe5'},{'\xf6','\xe6'},{'\xc5','\x76'},{'\xf6','\xe4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf7','\xe2'},{'\xc5','\xcf'},{'\xf7','\xe0'},
+    {'\xf7','\xe1'},{'\xf8','\xac'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\x56'},
+    {'\xf8','\xf3'},{'\xf8','\xf1'},{'\xf8','\xf2'},{'\xf8','\xf4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfc','\x79'},{'\xf9','\xbb'},{'\x94','\xa8'},{'\xa4','\xed'},
+    {'\xa6','\xb8'},{'\x8c','\xd1'},{'\xaa','\x59'},{'\x8a','\xcf'},{'\xcc','\xe9'},
+    {'\x00','\x00'},{'\x87','\xe6'},{'\xcf','\x64'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd1','\xf5'},{'\xd1','\xf7'},{'\x00','\x00'},{'\xd1','\xf6'},
+    {'\x00','\x00'},{'\xd1','\xf8'},{'\xb1','\xfd'},{'\xd5','\xd7'},{'\xd1','\xf9'},
+    {'\x95','\xb9'},{'\xd5','\xd6'},{'\xd5','\xd8'},{'\xd5','\xd9'},{'\xd9','\xda'},
+    {'\xb4','\xdb'},{'\xd9','\xdb'},{'\xd9','\xdd'},{'\xb4','\xdc'},{'\xb4','\xda'},
+    {'\xd9','\xdc'},{'\x00','\x00'},{'\xdd','\xfa'},{'\xdd','\xf8'},{'\xdd','\xf7'},
+    {'\x00','\x00'},{'\xdd','\xf6'},{'\xdd','\xf5'},{'\xb7','\xb2'},{'\xdd','\xf9'},
+    {'\xba','\x70'},{'\xe2','\x63'},{'\xe2','\x65'},{'\xba','\x71'},{'\xe2','\x64'},
+    {'\xbc','\xdb'},{'\x00','\x00'},{'\xbc','\xda'},{'\xe5','\xf0'},{'\xfc','\x7a'},
+    {'\x92','\x6c'},{'\xe9','\xdf'},{'\xe9','\xde'},{'\xe9','\xe0'},{'\x9b','\x5b'},
+    {'\x00','\x00'},{'\xbe','\xf9'},{'\x00','\x00'},{'\xed','\x4b'},{'\xc0','\xd3'},
+    {'\x00','\x00'},{'\xef','\xe8'},{'\xc2','\x6a'},{'\xf2','\x59'},{'\xc5','\x77'},
+    {'\xa4','\xee'},{'\xa5','\xbf'},{'\xa6','\xb9'},{'\xa8','\x42'},{'\xaa','\x5a'},
+    {'\xaa','\x5b'},{'\x00','\x00'},{'\x93','\xc5'},{'\xac','\x6e'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd1','\xfa'},{'\x00','\x00'},{'\x92','\xd0'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xb7','\xb3'},{'\x92','\xc8'},{'\x93','\xf0'},{'\x00','\x00'},
+    {'\xe6','\xd1'},{'\xbe','\xfa'},{'\xc2','\x6b'},{'\xa4','\xef'},{'\x9b','\x5c'},
+    {'\xa6','\xba'},{'\x8c','\x79'},{'\x00','\x00'},{'\xcc','\xeb'},{'\xaa','\x5c'},
+    {'\xcc','\xea'},{'\x9f','\x4e'},{'\xcf','\x65'},{'\xac','\x6f'},{'\xcf','\x66'},
+    {'\x00','\x00'},{'\xac','\x70'},{'\x87','\xe7'},{'\xd1','\xfc'},{'\xae','\xee'},
+    {'\xae','\xed'},{'\x92','\xcf'},{'\xd5','\xde'},{'\xd5','\xdc'},{'\xd5','\xdd'},
+    {'\xd5','\xdb'},{'\x00','\x00'},{'\xd5','\xda'},{'\x8d','\xb5'},{'\x89','\xe8'},
+    {'\xd9','\xde'},{'\xd9','\xe1'},{'\xb4','\xde'},{'\xd9','\xdf'},{'\xb4','\xdd'},
+    {'\xd9','\xe0'},{'\x8e','\xe8'},{'\xdd','\xfb'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe2','\x66'},{'\xe2','\x67'},{'\xe2','\x68'},{'\x8a','\xd1'},{'\xe5','\xf3'},
+    {'\xe5','\xf2'},{'\xbc','\xdc'},{'\xe5','\xf1'},{'\xe5','\xf4'},{'\xe9','\xe1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xe9','\xe2'},{'\xe9','\xe3'},{'\x00','\x00'},
+    {'\xed','\x4c'},{'\xc0','\xd4'},{'\xc2','\x6c'},{'\xf2','\x5a'},{'\x9f','\x4f'},
+    {'\xc4','\xe8'},{'\xc9','\x5f'},{'\x87','\xe8'},{'\xac','\x71'},{'\xcf','\x67'},
+    {'\xae','\xef'},{'\x00','\x00'},{'\x00','\x00'},{'\xb1','\xfe'},{'\x92','\x5f'},
+    {'\xb4','\xdf'},{'\xd9','\xe2'},{'\x00','\x00'},{'\xb7','\xb5'},{'\xb7','\xb4'},
+    {'\x90','\xb5'},{'\x8a','\x75'},{'\xe2','\x69'},{'\xe2','\x6a'},{'\xbc','\xdd'},
+    {'\xbc','\xde'},{'\xe9','\xe5'},{'\xe9','\xe4'},{'\xef','\xe9'},{'\xf7','\xe3'},
+    {'\xa4','\xf0'},{'\xc9','\x60'},{'\xa5','\xc0'},{'\x93','\xd1'},{'\xa8','\x43'},
+    {'\xcb','\x48'},{'\x00','\x00'},{'\xac','\x72'},{'\xb7','\xb6'},{'\xa4','\xf1'},
+    {'\x84','\x65'},{'\xcf','\x68'},{'\xac','\x73'},{'\xcf','\x69'},{'\x89','\xe1'},
+    {'\xc0','\xd5'},{'\xa4','\xf2'},{'\x9b','\x5d'},{'\x00','\x00'},{'\xcc','\xec'},
+    {'\x94','\xa9'},{'\xcf','\x6a'},{'\x89','\xe9'},{'\xd2','\x42'},{'\xd2','\x41'},
+    {'\xd1','\xfe'},{'\x00','\x00'},{'\xd1','\xfd'},{'\xd2','\x43'},{'\xd2','\x40'},
+    {'\x00','\x00'},{'\xa0','\x62'},{'\xb2','\x40'},{'\xb2','\x41'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xb4','\xe0'},{'\xd9','\xe3'},{'\x00','\x00'},{'\xd9','\xe4'},
+    {'\xd9','\xe5'},{'\x00','\x00'},{'\x8e','\xb9'},{'\x00','\x00'},{'\xde','\x41'},
+    {'\xde','\x42'},{'\xde','\x40'},{'\xfc','\x7b'},{'\xdd','\xfd'},{'\xdd','\xfe'},
+    {'\xb7','\xb7'},{'\xe2','\x6b'},{'\xe5','\xf7'},{'\xe5','\xf6'},{'\xe5','\xf5'},
+    {'\xe5','\xf8'},{'\xe9','\xe7'},{'\xe9','\xe6'},{'\xbe','\xfb'},{'\xe9','\xe8'},
+    {'\x8f','\xbb'},{'\xc0','\xd6'},{'\xed','\x4d'},{'\x00','\x00'},{'\xef','\xea'},
+    {'\xf2','\x5b'},{'\xf6','\xe7'},{'\x00','\x00'},{'\xa4','\xf3'},{'\xa5','\xc2'},
+    {'\xa5','\xc1'},{'\x00','\x00'},{'\xaa','\x5d'},{'\xc9','\x61'},{'\xc9','\x7e'},
+    {'\xa6','\xbb'},{'\x92','\x6e'},{'\xc9','\xf7'},{'\xcb','\x49'},{'\xcb','\x4a'},
+    {'\xaa','\x5e'},{'\x9b','\x5e'},{'\xcc','\xed'},{'\x00','\x00'},{'\xac','\x74'},
+    {'\xcf','\x6b'},{'\xcf','\x6c'},{'\x84','\x5a'},{'\xae','\xf0'},{'\xae','\xf4'},
+    {'\xd2','\x44'},{'\xae','\xf3'},{'\xae','\xf1'},{'\xae','\xf2'},{'\x84','\xec'},
+    {'\xd5','\xdf'},{'\xb2','\x42'},{'\xb4','\xe3'},{'\x00','\x00'},{'\xb4','\xe1'},
+    {'\xb4','\xe2'},{'\xd9','\xe6'},{'\x9b','\x5f'},{'\xa0','\x63'},{'\xba','\x72'},
+    {'\xa4','\xf4'},{'\x9c','\xf3'},{'\xc9','\xa1'},{'\x95','\xeb'},{'\xa5','\xc3'},
+    {'\xfe','\x40'},{'\x91','\xd2'},{'\xc9','\xa4'},{'\x00','\x00'},{'\xa0','\x64'},
+    {'\xa5','\xc6'},{'\xc9','\xa3'},{'\xa5','\xc5'},{'\xa5','\xc4'},{'\xa8','\x44'},
+    {'\xc9','\xa2'},{'\x00','\x00'},{'\x00','\x00'},{'\xc9','\xf8'},{'\x85','\xb9'},
+    {'\x00','\x00'},{'\x86','\xd5'},{'\xc9','\xfc'},{'\xc9','\xfe'},{'\xca','\x40'},
+    {'\xa6','\xc5'},{'\xa6','\xc6'},{'\xc9','\xfb'},{'\xa6','\xc1'},{'\x00','\x00'},
+    {'\xc9','\xf9'},{'\x00','\x00'},{'\xc9','\xfd'},{'\xa6','\xc2'},{'\x00','\x00'},
+    {'\xa6','\xbd'},{'\x9b','\x60'},{'\xa6','\xbe'},{'\x95','\xea'},{'\xa6','\xc4'},
+    {'\xc9','\xfa'},{'\xa6','\xbc'},{'\xa8','\x45'},{'\xa6','\xbf'},{'\xa6','\xc0'},
+    {'\xa6','\xc3'},{'\xa0','\x65'},{'\x00','\x00'},{'\x84','\xf1'},{'\xcb','\x5b'},
+    {'\xcb','\x59'},{'\xcb','\x4c'},{'\xa8','\x51'},{'\xcb','\x53'},{'\xa8','\x4c'},
+    {'\xcb','\x4d'},{'\x00','\x00'},{'\xcb','\x55'},{'\x9b','\x61'},{'\xcb','\x52'},
+    {'\xa8','\x4f'},{'\xcb','\x51'},{'\xa8','\x56'},{'\xcb','\x5a'},{'\xa8','\x58'},
+    {'\x9b','\x62'},{'\xa8','\x5a'},{'\x00','\x00'},{'\xcb','\x4b'},{'\x83','\x6e'},
+    {'\xa8','\x4d'},{'\xcb','\x5c'},{'\x00','\x00'},{'\xa8','\x54'},{'\xa8','\x57'},
+    {'\x9b','\x63'},{'\xcd','\x45'},{'\xa8','\x47'},{'\xa8','\x5e'},{'\xa8','\x55'},
+    {'\xcb','\x4e'},{'\xa8','\x4a'},{'\xa8','\x59'},{'\xcb','\x56'},{'\xa8','\x48'},
+    {'\xa8','\x49'},{'\xcd','\x43'},{'\xcb','\x4f'},{'\xa8','\x50'},{'\xa8','\x5b'},
+    {'\xcb','\x5d'},{'\xcb','\x50'},{'\xa8','\x4e'},{'\x00','\x00'},{'\xa8','\x53'},
+    {'\xcc','\xee'},{'\xa8','\x5c'},{'\xcb','\x57'},{'\xa8','\x52'},{'\x00','\x00'},
+    {'\xa8','\x5d'},{'\xa8','\x46'},{'\xcb','\x54'},{'\xa8','\x4b'},{'\xcb','\x58'},
+    {'\xcd','\x44'},{'\x00','\x00'},{'\x85','\xd8'},{'\x00','\x00'},{'\x95','\xca'},
+    {'\x93','\x6b'},{'\x88','\xf4'},{'\x8e','\x75'},{'\x8b','\x7e'},{'\x84','\x5f'},
+    {'\x85','\xdc'},{'\x00','\x00'},{'\x8d','\xe0'},{'\x86','\xdb'},{'\xaa','\x6a'},
+    {'\xaa','\x7a'},{'\xcc','\xf5'},{'\xaa','\x71'},{'\x9b','\x64'},{'\xcd','\x4b'},
+    {'\xaa','\x62'},{'\xa0','\x66'},{'\xaa','\x65'},{'\xcd','\x42'},{'\x00','\x00'},
+    {'\xcc','\xf3'},{'\xcc','\xf7'},{'\xaa','\x6d'},{'\xaa','\x6f'},{'\xcc','\xfa'},
+    {'\xaa','\x76'},{'\xaa','\x68'},{'\xaa','\x66'},{'\xaa','\x67'},{'\xaa','\x75'},
+    {'\xcd','\x47'},{'\xaa','\x70'},{'\xcc','\xf9'},{'\xcc','\xfb'},{'\xaa','\x6e'},
+    {'\xaa','\x73'},{'\xcc','\xfc'},{'\xcd','\x4a'},{'\x00','\x00'},{'\xac','\x75'},
+    {'\xaa','\x79'},{'\x9b','\x65'},{'\xaa','\x63'},{'\xcd','\x49'},{'\xfc','\x7d'},
+    {'\xcd','\x4d'},{'\xcc','\xf8'},{'\xcd','\x4f'},{'\xcd','\x40'},{'\xaa','\x6c'},
+    {'\xcc','\xf4'},{'\xaa','\x6b'},{'\xaa','\x7d'},{'\xaa','\x72'},{'\x00','\x00'},
+    {'\xcc','\xf2'},{'\xcf','\x75'},{'\xaa','\x78'},{'\xaa','\x7c'},{'\xcd','\x41'},
+    {'\xcd','\x46'},{'\x9b','\x66'},{'\xaa','\x7e'},{'\xaa','\x77'},{'\xaa','\x69'},
+    {'\xaa','\x5f'},{'\x00','\x00'},{'\xaa','\x64'},{'\x00','\x00'},{'\xcc','\xf6'},
+    {'\xaa','\x60'},{'\xcd','\x4e'},{'\x84','\x5e'},{'\xcc','\xf0'},{'\xcc','\xef'},
+    {'\xcc','\xfd'},{'\xcc','\xf1'},{'\xaa','\x7b'},{'\xae','\xf5'},{'\xaa','\x74'},
+    {'\xcc','\xfe'},{'\xaa','\x61'},{'\x00','\x00'},{'\xac','\xa6'},{'\x8f','\x54'},
+    {'\x8f','\xbc'},{'\x8b','\xa2'},{'\xcd','\x4c'},{'\x8f','\x77'},{'\x8a','\xd2'},
+    {'\x87','\xea'},{'\x88','\xf2'},{'\x83','\xbd'},{'\x9b','\x67'},{'\xcf','\x7c'},
+    {'\xcf','\xa1'},{'\x9b','\x68'},{'\xcf','\xa4'},{'\xcf','\x77'},{'\x9b','\x69'},
+    {'\x9b','\x6a'},{'\xcf','\xa7'},{'\xcf','\xaa'},{'\xcf','\xac'},{'\xcf','\x74'},
+    {'\xac','\x76'},{'\xac','\x7b'},{'\xd2','\x49'},{'\xac','\xad'},{'\xcf','\xa5'},
+    {'\xcf','\xad'},{'\xcf','\x7b'},{'\xcf','\x73'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd2','\x64'},{'\xac','\x7e'},{'\xcf','\xa2'},{'\xcf','\x78'},
+    {'\xcf','\x7a'},{'\xac','\xa5'},{'\x00','\x00'},{'\xcf','\x7d'},{'\xac','\x7d'},
+    {'\xcf','\x70'},{'\xcf','\xa8'},{'\x00','\x00'},{'\xcf','\xab'},{'\x00','\x00'},
+    {'\x95','\xb0'},{'\xac','\x7a'},{'\x9b','\x6b'},{'\xac','\xa8'},{'\xcf','\x6d'},
+    {'\xac','\xaa'},{'\xac','\x78'},{'\xac','\xae'},{'\xcf','\xa9'},{'\xcf','\x6f'},
+    {'\xac','\xab'},{'\xd2','\x5e'},{'\xcd','\x48'},{'\xac','\x7c'},{'\xac','\x77'},
+    {'\xcf','\x76'},{'\xcf','\x6e'},{'\xac','\xac'},{'\xac','\xa4'},{'\xcf','\xa3'},
+    {'\xac','\xa9'},{'\xac','\xa7'},{'\xcf','\x79'},{'\xac','\xa1'},{'\xcf','\x71'},
+    {'\xac','\xa2'},{'\xac','\xa3'},{'\xcf','\x72'},{'\xcf','\xa6'},{'\xac','\x79'},
+    {'\xcf','\x7e'},{'\x83','\xbe'},{'\x92','\xea'},{'\x93','\x48'},{'\x87','\xe9'},
+    {'\x87','\xec'},{'\x8d','\xe1'},{'\x00','\x00'},{'\x88','\xf3'},{'\x84','\xf2'},
+    {'\x00','\x00'},{'\x8e','\xe9'},{'\x89','\xec'},{'\x8a','\xd7'},{'\x00','\x00'},
+    {'\x84','\xf3'},{'\x8e','\x74'},{'\x88','\xf1'},{'\x87','\xf0'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x9b','\x6c'},{'\xd2','\x4c'},{'\xae','\xfd'},{'\xaf','\x43'},
+    {'\x9b','\x6d'},{'\x93','\xbd'},{'\x00','\x00'},{'\xd2','\x55'},{'\xd2','\x5b'},
+    {'\xd2','\x57'},{'\xd2','\x4a'},{'\xd2','\x4d'},{'\xd2','\x46'},{'\xd2','\x47'},
+    {'\xaf','\x4a'},{'\xae','\xfa'},{'\xd2','\x56'},{'\xd2','\x5f'},{'\xaf','\x45'},
+    {'\xae','\xf6'},{'\x00','\x00'},{'\xaf','\x40'},{'\xd2','\x4e'},{'\xaf','\x42'},
+    {'\xd2','\x4f'},{'\xd2','\x59'},{'\x9b','\x6e'},{'\xfb','\xa7'},{'\x00','\x00'},
+    {'\xaf','\x44'},{'\xd2','\x68'},{'\xd2','\x48'},{'\xae','\xfc'},{'\xae','\xfb'},
+    {'\xaf','\x48'},{'\xd2','\x45'},{'\xd2','\x66'},{'\xd2','\x5a'},{'\xd2','\x67'},
+    {'\xd2','\x61'},{'\xd2','\x53'},{'\xd2','\x62'},{'\x9b','\x6f'},{'\xd2','\x5c'},
+    {'\xd2','\x65'},{'\xd2','\x63'},{'\xaf','\x49'},{'\xd2','\x54'},{'\xae','\xf9'},
+    {'\xae','\xf8'},{'\xaf','\x41'},{'\xaf','\x47'},{'\xd2','\x60'},{'\xaf','\x46'},
+    {'\xd2','\x51'},{'\xb2','\x43'},{'\x9b','\x70'},{'\xd2','\x69'},{'\xd2','\x50'},
+    {'\xd2','\x4b'},{'\xae','\xfe'},{'\xaf','\x4b'},{'\xae','\xf7'},{'\xfe','\x5c'},
+    {'\xd2','\x58'},{'\xd2','\x5d'},{'\x93','\xe8'},{'\x00','\x00'},{'\x89','\xed'},
+    {'\x82','\x71'},{'\x8e','\xbb'},{'\x8d','\xcf'},{'\x86','\xda'},{'\x8e','\xbd'},
+    {'\x84','\xf0'},{'\x00','\x00'},{'\x84','\xf4'},{'\x86','\xde'},{'\x9b','\x71'},
+    {'\x87','\xee'},{'\x87','\xef'},{'\x86','\xd9'},{'\x89','\xef'},{'\xb2','\x65'},
+    {'\xd5','\xe1'},{'\xd5','\xe5'},{'\x00','\x00'},{'\xb2','\x52'},{'\xb2','\x50'},
+    {'\x00','\x00'},{'\x9b','\x72'},{'\xb2','\x47'},{'\xd5','\xe3'},{'\xd5','\xe2'},
+    {'\xb2','\x5b'},{'\x00','\x00'},{'\xd5','\xe8'},{'\xb2','\x55'},{'\xfc','\xa1'},
+    {'\xd5','\xfa'},{'\xd6','\x47'},{'\xb2','\x44'},{'\xd5','\xf7'},{'\xd5','\xf0'},
+    {'\xb2','\x67'},{'\xd5','\xe0'},{'\x00','\x00'},{'\xd5','\xfc'},{'\x00','\x00'},
+    {'\xb2','\x64'},{'\xb2','\x58'},{'\xb2','\x63'},{'\xb2','\x4e'},{'\xd5','\xec'},
+    {'\xd5','\xfe'},{'\xd5','\xf6'},{'\xb2','\x4f'},{'\xb2','\x49'},{'\xd6','\x45'},
+    {'\x00','\x00'},{'\xd5','\xfd'},{'\xd6','\x40'},{'\xb2','\x51'},{'\xb2','\x59'},
+    {'\xd6','\x42'},{'\xd5','\xea'},{'\xd5','\xfb'},{'\xd5','\xef'},{'\xd6','\x44'},
+    {'\xb2','\x5e'},{'\xb2','\x46'},{'\xb2','\x5c'},{'\xd5','\xf4'},{'\xd5','\xf2'},
+    {'\xd5','\xf3'},{'\xb2','\x53'},{'\xd5','\xee'},{'\xd5','\xed'},{'\xb2','\x48'},
+    {'\xd5','\xe7'},{'\xd6','\x46'},{'\xb2','\x4a'},{'\xd5','\xf1'},{'\xb2','\x68'},
+    {'\x00','\x00'},{'\xb2','\x62'},{'\xd5','\xe6'},{'\xb2','\x5f'},{'\xb2','\x5d'},
+    {'\xb2','\x66'},{'\xd5','\xf8'},{'\xb2','\x61'},{'\xd2','\x52'},{'\xd5','\xf9'},
+    {'\xb2','\x60'},{'\xd6','\x41'},{'\xb2','\x45'},{'\xd5','\xf5'},{'\xb2','\x57'},
+    {'\xd5','\xe9'},{'\xb2','\x56'},{'\xa0','\x67'},{'\xb2','\x54'},{'\xb2','\x4c'},
+    {'\xb2','\x4b'},{'\xd9','\xe7'},{'\xd6','\x43'},{'\x9b','\x73'},{'\x00','\x00'},
+    {'\xd5','\xeb'},{'\x00','\x00'},{'\x9b','\x74'},{'\xd9','\xfc'},{'\x9b','\x75'},
+    {'\xb2','\x4d'},{'\x00','\x00'},{'\x92','\x64'},{'\x92','\xc6'},{'\x92','\xe4'},
+    {'\x84','\x5d'},{'\x92','\xdd'},{'\x8d','\xd0'},{'\x86','\xd4'},{'\x8a','\xd5'},
+    {'\x9b','\x76'},{'\x86','\xd8'},{'\x88','\xf6'},{'\x00','\x00'},{'\x92','\xaa'},
+    {'\x86','\xdc'},{'\x94','\xaa'},{'\x8a','\xd3'},{'\x86','\xdd'},{'\x9b','\x77'},
+    {'\xb5','\x41'},{'\xb2','\x5a'},{'\xb4','\xee'},{'\xd9','\xf6'},{'\xb4','\xfc'},
+    {'\x00','\x00'},{'\xd9','\xea'},{'\xb4','\xeb'},{'\xb4','\xe7'},{'\xda','\x49'},
+    {'\xb4','\xed'},{'\xb4','\xf1'},{'\xb4','\xec'},{'\xb4','\xf5'},{'\xda','\x4d'},
+    {'\xda','\x44'},{'\xa0','\x68'},{'\x9b','\x78'},{'\xd9','\xf1'},{'\xb4','\xfa'},
+    {'\xb4','\xf4'},{'\xd9','\xfd'},{'\xb4','\xe4'},{'\xda','\x4a'},{'\xda','\x43'},
+    {'\xb4','\xe8'},{'\xd9','\xf7'},{'\xb4','\xf7'},{'\xda','\x55'},{'\xda','\x56'},
+    {'\x00','\x00'},{'\xb4','\xe5'},{'\xda','\x48'},{'\xb4','\xf9'},{'\xd9','\xfb'},
+    {'\xd9','\xed'},{'\xd9','\xee'},{'\xb4','\xfd'},{'\xd9','\xf2'},{'\xd9','\xf9'},
+    {'\xd9','\xf3'},{'\x00','\x00'},{'\xb4','\xfb'},{'\xb5','\x44'},{'\xd9','\xef'},
+    {'\xd9','\xe8'},{'\xd9','\xe9'},{'\x00','\x00'},{'\xd9','\xeb'},{'\xb4','\xea'},
+    {'\xd9','\xf8'},{'\x00','\x00'},{'\xb4','\xf8'},{'\xb5','\x42'},{'\xfc','\x7e'},
+    {'\x9b','\x79'},{'\xd9','\xfa'},{'\xda','\x53'},{'\xda','\x4b'},{'\xb4','\xe6'},
+    {'\xda','\x51'},{'\xb4','\xf2'},{'\x9d','\xcb'},{'\xb4','\xf0'},{'\x9b','\x7a'},
+    {'\xda','\x57'},{'\xb4','\xef'},{'\xda','\x41'},{'\xd9','\xf4'},{'\xd9','\xfe'},
+    {'\xb5','\x47'},{'\xda','\x45'},{'\xda','\x42'},{'\xd9','\xf0'},{'\xb5','\x43'},
+    {'\xda','\x4f'},{'\xda','\x4c'},{'\xda','\x54'},{'\xb4','\xe9'},{'\xda','\x40'},
+    {'\xb5','\x46'},{'\x00','\x00'},{'\xda','\x47'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb4','\xf3'},{'\xb4','\xf6'},{'\x00','\x00'},{'\xda','\x46'},{'\xb5','\x45'},
+    {'\xd9','\xf5'},{'\xd5','\xe4'},{'\x00','\x00'},{'\xa0','\x69'},{'\xda','\x50'},
+    {'\xda','\x4e'},{'\xda','\x52'},{'\x00','\x00'},{'\x00','\x00'},{'\x95','\xcb'},
+    {'\x00','\x00'},{'\x8d','\x6f'},{'\x85','\xda'},{'\x93','\xd2'},{'\x00','\x00'},
+    {'\xa0','\x6a'},{'\x87','\xed'},{'\x00','\x00'},{'\x8a','\xd6'},{'\xa0','\x6b'},
+    {'\x00','\x00'},{'\xd9','\xec'},{'\xb5','\x40'},{'\x00','\x00'},{'\xfe','\x6a'},
+    {'\x82','\x78'},{'\xde','\x61'},{'\xde','\x60'},{'\xde','\x46'},{'\xb7','\xbd'},
+    {'\x00','\x00'},{'\xde','\x5f'},{'\xde','\x49'},{'\xde','\x4a'},{'\x00','\x00'},
+    {'\xb7','\xc7'},{'\xde','\x68'},{'\xb7','\xc2'},{'\xde','\x5e'},{'\x9b','\x7b'},
+    {'\xde','\x43'},{'\xb7','\xc8'},{'\xb7','\xbe'},{'\xde','\x52'},{'\xde','\x48'},
+    {'\xde','\x4b'},{'\xde','\x63'},{'\xb7','\xb8'},{'\xde','\x6a'},{'\xde','\x62'},
+    {'\xb7','\xc1'},{'\xde','\x57'},{'\xb7','\xcc'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb7','\xcb'},{'\xb7','\xc5'},{'\x00','\x00'},{'\x00','\x00'},{'\xde','\x69'},
+    {'\xb7','\xb9'},{'\xde','\x55'},{'\xde','\x4c'},{'\xde','\x59'},{'\xde','\x65'},
+    {'\xb7','\xcd'},{'\x9b','\x7c'},{'\xb7','\xbb'},{'\xde','\x54'},{'\x9b','\x7d'},
+    {'\xde','\x4d'},{'\xb7','\xc4'},{'\xa0','\x6c'},{'\xb7','\xc3'},{'\xde','\x50'},
+    {'\xde','\x5a'},{'\xde','\x64'},{'\xde','\x47'},{'\xde','\x51'},{'\xb7','\xbc'},
+    {'\xde','\x5b'},{'\xb7','\xc9'},{'\xb7','\xc0'},{'\xde','\x4e'},{'\xb7','\xbf'},
+    {'\xde','\x45'},{'\xde','\x53'},{'\xde','\x67'},{'\xb4','\xfe'},{'\xba','\xb0'},
+    {'\xde','\x56'},{'\xe2','\x6c'},{'\xde','\x58'},{'\xde','\x66'},{'\xb7','\xc6'},
+    {'\xde','\x4f'},{'\xb7','\xba'},{'\xb7','\xca'},{'\xbc','\xf0'},{'\xde','\x44'},
+    {'\x8e','\xbe'},{'\xde','\x5d'},{'\x95','\x50'},{'\x86','\xd3'},{'\x9b','\x7e'},
+    {'\xde','\x5c'},{'\x93','\x69'},{'\x86','\xd7'},{'\xa0','\x6d'},{'\x90','\x41'},
+    {'\x86','\xd6'},{'\xa0','\x6e'},{'\x00','\x00'},{'\x8a','\xd4'},{'\x89','\xee'},
+    {'\x8d','\x7b'},{'\x00','\x00'},{'\x89','\xeb'},{'\x8c','\xd2'},{'\x00','\x00'},
+    {'\xe2','\xaa'},{'\xba','\xad'},{'\xe2','\x7d'},{'\xe2','\xa4'},{'\xba','\xa2'},
+    {'\x00','\x00'},{'\xe2','\x6e'},{'\xba','\xaf'},{'\x00','\x00'},{'\xba','\x77'},
+    {'\xe2','\x6d'},{'\xe2','\xb0'},{'\xba','\xb1'},{'\xe2','\x71'},{'\xe2','\xa3'},
+    {'\x9b','\xa1'},{'\xe2','\x73'},{'\xe2','\xb3'},{'\xe2','\xaf'},{'\xba','\x75'},
+    {'\xba','\xa1'},{'\xe6','\x53'},{'\xba','\xae'},{'\xba','\x7d'},{'\xe2','\x6f'},
+    {'\x9b','\xa2'},{'\xe2','\xae'},{'\xba','\xa3'},{'\xe2','\xab'},{'\xe2','\xb8'},
+    {'\xe2','\x75'},{'\xe2','\x7e'},{'\x9b','\xa3'},{'\x9b','\xa4'},{'\xe2','\xb6'},
+    {'\xe2','\xac'},{'\xba','\x7c'},{'\x00','\x00'},{'\xa0','\x6f'},{'\xe2','\x7c'},
+    {'\xba','\x76'},{'\xba','\x74'},{'\xba','\xa8'},{'\x9b','\xa5'},{'\x9b','\xa6'},
+    {'\xe2','\x7a'},{'\xe2','\x77'},{'\xe2','\x78'},{'\x00','\x00'},{'\xe2','\xb2'},
+    {'\x00','\x00'},{'\xe2','\xb7'},{'\xe2','\xb5'},{'\xba','\x7a'},{'\xe2','\xb9'},
+    {'\xba','\x7e'},{'\xba','\xa7'},{'\xa0','\x70'},{'\xe2','\x70'},{'\xe5','\xfa'},
+    {'\xe2','\x79'},{'\x00','\x00'},{'\xba','\x78'},{'\xba','\xac'},{'\xba','\xa9'},
+    {'\xba','\x7b'},{'\xe2','\xa5'},{'\xe2','\x74'},{'\xba','\xaa'},{'\xe2','\xa7'},
+    {'\xba','\xa4'},{'\xba','\xa6'},{'\xba','\x73'},{'\x9b','\xa7'},{'\xe2','\xa9'},
+    {'\xe2','\xa1'},{'\xe2','\x72'},{'\xba','\xa5'},{'\xe2','\xb1'},{'\xe2','\xb4'},
+    {'\xe2','\x7b'},{'\xe2','\xa8'},{'\x9b','\xa8'},{'\xba','\x79'},{'\xbc','\xdf'},
+    {'\xe2','\xa6'},{'\xe5','\xf9'},{'\x00','\x00'},{'\xe2','\xad'},{'\xfc','\xa2'},
+    {'\x82','\x50'},{'\x8f','\xbd'},{'\x8b','\x7c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8b','\xfb'},{'\x00','\x00'},{'\x89','\xf0'},{'\xe2','\x76'},
+    {'\xe6','\x44'},{'\xe6','\x4e'},{'\xbc','\xe2'},{'\xe6','\x4d'},{'\xe6','\x59'},
+    {'\xbc','\xe4'},{'\xe6','\x4b'},{'\x9b','\xa9'},{'\xe6','\x4f'},{'\xbc','\xef'},
+    {'\x00','\x00'},{'\xe6','\x46'},{'\xbc','\xe7'},{'\x90','\xb9'},{'\xe6','\x52'},
+    {'\xe9','\xf0'},{'\xbc','\xf3'},{'\xbc','\xf2'},{'\xe6','\x54'},{'\xe6','\x43'},
+    {'\xe6','\x5e'},{'\xbc','\xed'},{'\x00','\x00'},{'\xbc','\xe3'},{'\xe6','\x57'},
+    {'\x00','\x00'},{'\xe6','\x5b'},{'\xe6','\x60'},{'\xe6','\x55'},{'\xe6','\x49'},
+    {'\xbc','\xe6'},{'\xbc','\xe9'},{'\xbc','\xf1'},{'\xbc','\xec'},{'\x00','\x00'},
+    {'\xe6','\x4c'},{'\xe2','\xa2'},{'\xa0','\x71'},{'\x00','\x00'},{'\xe6','\x48'},
+    {'\xe6','\x5f'},{'\xbc','\xe8'},{'\x9b','\xaa'},{'\xbc','\xeb'},{'\xe6','\x61'},
+    {'\xbc','\xe0'},{'\xe6','\x56'},{'\xe5','\xfb'},{'\xe6','\x5c'},{'\xc0','\xdf'},
+    {'\x95','\x6b'},{'\xe6','\x4a'},{'\x00','\x00'},{'\xbc','\xe1'},{'\xe6','\x45'},
+    {'\xbc','\xe5'},{'\xe5','\xfc'},{'\xba','\xab'},{'\xe6','\x41'},{'\x9b','\xab'},
+    {'\xe6','\x5a'},{'\xe6','\x42'},{'\xe6','\x40'},{'\xbc','\xea'},{'\x00','\x00'},
+    {'\xe6','\x58'},{'\xa0','\x72'},{'\xe5','\xfe'},{'\xe6','\x51'},{'\xe6','\x50'},
+    {'\xe6','\x5d'},{'\xe6','\x47'},{'\xbc','\xee'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x8b','\xfa'},{'\x9b','\xac'},{'\xe9','\xf3'},
+    {'\x9b','\xad'},{'\xbf','\x49'},{'\xbe','\xfe'},{'\xea','\x40'},{'\xe9','\xeb'},
+    {'\xbf','\x41'},{'\xe9','\xf7'},{'\xbf','\x48'},{'\xbf','\x43'},{'\xe9','\xf5'},
+    {'\xed','\x4f'},{'\xe9','\xfb'},{'\xea','\x42'},{'\xe9','\xfa'},{'\xe9','\xe9'},
+    {'\xe9','\xf8'},{'\xea','\x44'},{'\xea','\x46'},{'\xbe','\xfd'},{'\xea','\x45'},
+    {'\xbf','\x44'},{'\xbf','\x4a'},{'\xa0','\x73'},{'\xbf','\x47'},{'\x00','\x00'},
+    {'\xe9','\xfe'},{'\xbf','\x46'},{'\xe9','\xf9'},{'\x9b','\xae'},{'\xe9','\xed'},
+    {'\xe9','\xf2'},{'\x9b','\xaf'},{'\xe9','\xfd'},{'\xbf','\x45'},{'\xbf','\x42'},
+    {'\xbe','\xfc'},{'\xbf','\x40'},{'\xe9','\xf1'},{'\x00','\x00'},{'\xe5','\xfd'},
+    {'\xe9','\xec'},{'\xe9','\xef'},{'\xea','\x41'},{'\xe9','\xf4'},{'\xe9','\xea'},
+    {'\xed','\x4e'},{'\xea','\x43'},{'\xe9','\xee'},{'\xe9','\xfc'},{'\x00','\x00'},
+    {'\x8b','\x7d'},{'\x8b','\xa1'},{'\x9b','\xb0'},{'\xed','\x51'},{'\xc0','\xe3'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc0','\xd7'},{'\x9b','\xb1'},{'\xfc','\xa4'},
+    {'\xc0','\xdb'},{'\xed','\x53'},{'\xed','\x59'},{'\xed','\x57'},{'\xc0','\xd9'},
+    {'\xc0','\xda'},{'\xc0','\xe1'},{'\xed','\x5a'},{'\xed','\x52'},{'\xc0','\xdc'},
+    {'\x00','\x00'},{'\xed','\x56'},{'\xed','\x55'},{'\xed','\x5b'},{'\xc0','\xe2'},
+    {'\x00','\x00'},{'\xc0','\xdd'},{'\xc0','\xe0'},{'\xed','\x54'},{'\xc0','\xe4'},
+    {'\xc0','\xde'},{'\xc0','\xe5'},{'\xc0','\xd8'},{'\xed','\x58'},{'\xa0','\x74'},
+    {'\xed','\x50'},{'\xa0','\x75'},{'\x95','\xc6'},{'\xef','\xf7'},{'\x9b','\xb2'},
+    {'\x00','\x00'},{'\xc2','\x71'},{'\xef','\xf4'},{'\xef','\xf6'},{'\x00','\x00'},
+    {'\xc2','\x6f'},{'\xef','\xf2'},{'\xef','\xf3'},{'\xef','\xee'},{'\x00','\x00'},
+    {'\x9b','\xb3'},{'\xe9','\xf6'},{'\xef','\xef'},{'\xc2','\x70'},{'\xef','\xeb'},
+    {'\x00','\x00'},{'\xc2','\x6d'},{'\xef','\xf8'},{'\xc2','\x6e'},{'\xef','\xec'},
+    {'\xef','\xed'},{'\xef','\xf1'},{'\xc2','\x73'},{'\x00','\x00'},{'\xc2','\x72'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xef','\xf0'},{'\xc3','\x78'},{'\xf2','\x5f'},
+    {'\xf2','\x65'},{'\xc3','\x79'},{'\xf2','\x5c'},{'\xc3','\x76'},{'\xc3','\x73'},
+    {'\xf2','\x67'},{'\xc3','\x77'},{'\xfe','\xa1'},{'\xc3','\x74'},{'\xf2','\x5e'},
+    {'\xf2','\x61'},{'\xf2','\x62'},{'\xf2','\x63'},{'\xf2','\x66'},{'\x00','\x00'},
+    {'\xef','\xf5'},{'\xf2','\x5d'},{'\xc3','\x75'},{'\xf2','\x64'},{'\xf2','\x68'},
+    {'\xf2','\x60'},{'\x93','\x40'},{'\x00','\x00'},{'\x00','\x00'},{'\xf4','\x5d'},
+    {'\xc4','\x6a'},{'\xf4','\x60'},{'\xc4','\x6b'},{'\xf4','\x68'},{'\xf4','\x5f'},
+    {'\xf4','\x5c'},{'\x00','\x00'},{'\xf4','\x5e'},{'\xf4','\x62'},{'\xf4','\x65'},
+    {'\xf4','\x64'},{'\xf4','\x67'},{'\xf4','\x5b'},{'\x00','\x00'},{'\xc4','\x69'},
+    {'\xf4','\x63'},{'\xf4','\x66'},{'\xf4','\x69'},{'\xf4','\x61'},{'\xf5','\xd3'},
+    {'\xf5','\xd4'},{'\xf5','\xd8'},{'\xf5','\xd9'},{'\x00','\x00'},{'\xf5','\xd6'},
+    {'\xf5','\xd7'},{'\xf5','\xd5'},{'\x9b','\xb4'},{'\xc4','\xe9'},{'\x9b','\xb5'},
+    {'\x00','\x00'},{'\x90','\x76'},{'\x9b','\xb6'},{'\xc5','\x78'},{'\xf6','\xeb'},
+    {'\x00','\x00'},{'\x9b','\xb7'},{'\xf6','\xe8'},{'\xf6','\xe9'},{'\xf6','\xea'},
+    {'\xc5','\x79'},{'\x00','\x00'},{'\xf7','\xe5'},{'\xf7','\xe4'},{'\x9b','\xb8'},
+    {'\xf8','\xaf'},{'\xc5','\xf4'},{'\xf8','\xad'},{'\xf8','\xb0'},{'\xf8','\xae'},
+    {'\xf8','\xf5'},{'\xc6','\x57'},{'\xc6','\x65'},{'\xf9','\xa3'},{'\xf9','\x6c'},
+    {'\x9b','\xb9'},{'\xf9','\xa2'},{'\xf9','\xd0'},{'\xf9','\xd1'},{'\xa4','\xf5'},
+    {'\x9c','\xf6'},{'\x85','\xd9'},{'\x00','\x00'},{'\x88','\xf9'},{'\xa6','\xc7'},
+    {'\xca','\x41'},{'\x00','\x00'},{'\x00','\x00'},{'\xcb','\x5e'},{'\x8d','\x5f'},
+    {'\xa8','\x5f'},{'\x9b','\xba'},{'\xa8','\x62'},{'\x9b','\xbb'},{'\xcb','\x5f'},
+    {'\x00','\x00'},{'\xa8','\x60'},{'\xa8','\x61'},{'\x83','\x4d'},{'\x89','\xf2'},
+    {'\x85','\xdf'},{'\xfc','\xa5'},{'\xcd','\x58'},{'\xcd','\x5a'},{'\xcd','\x55'},
+    {'\xcd','\x52'},{'\xcd','\x54'},{'\x00','\x00'},{'\x00','\x00'},{'\x93','\xf4'},
+    {'\xaa','\xa4'},{'\x9b','\xbc'},{'\x00','\x00'},{'\xfe','\xa3'},{'\xaa','\xa2'},
+    {'\x9b','\xbd'},{'\x00','\x00'},{'\xcd','\x56'},{'\xaa','\xa3'},{'\xcd','\x53'},
+    {'\xcd','\x50'},{'\xaa','\xa1'},{'\xcd','\x57'},{'\x00','\x00'},{'\xcd','\x51'},
+    {'\xaa','\xa5'},{'\xcd','\x59'},{'\x00','\x00'},{'\x8e','\x45'},{'\x8e','\x76'},
+    {'\x00','\x00'},{'\xcf','\xaf'},{'\x9b','\xbe'},{'\xcf','\xb3'},{'\x00','\x00'},
+    {'\x9b','\xbf'},{'\xac','\xb7'},{'\x9b','\xc0'},{'\x9b','\xc1'},{'\x9b','\xc2'},
+    {'\x00','\x00'},{'\xcf','\xb6'},{'\x00','\x00'},{'\xac','\xaf'},{'\xac','\xb2'},
+    {'\xac','\xb4'},{'\xac','\xb6'},{'\xac','\xb3'},{'\xcf','\xb2'},{'\xcf','\xb1'},
+    {'\x00','\x00'},{'\xac','\xb1'},{'\xcf','\xb4'},{'\xcf','\xb5'},{'\x00','\x00'},
+    {'\xcf','\xae'},{'\xac','\xb5'},{'\x8a','\xbb'},{'\xac','\xb0'},{'\xa0','\x76'},
+    {'\x85','\xde'},{'\x88','\xf7'},{'\xcf','\xb0'},{'\x00','\x00'},{'\xa0','\x77'},
+    {'\x8b','\xa3'},{'\x8c','\x7a'},{'\x8d','\xd1'},{'\x9b','\xc3'},{'\xd2','\x77'},
+    {'\xd2','\x78'},{'\xd2','\x79'},{'\xaf','\x50'},{'\x00','\x00'},{'\xaf','\x4c'},
+    {'\xd2','\x6e'},{'\x9b','\xc4'},{'\xd2','\x76'},{'\xd2','\x7b'},{'\xaf','\x51'},
+    {'\x9b','\xc5'},{'\xd2','\x6c'},{'\xd2','\x72'},{'\xd2','\x6b'},{'\xd2','\x75'},
+    {'\xfc','\x57'},{'\x9b','\xc6'},{'\xd2','\x71'},{'\xaf','\x4d'},{'\xaf','\x4f'},
+    {'\xd2','\x7a'},{'\x89','\xf3'},{'\xd2','\x6a'},{'\xd2','\x6d'},{'\xd2','\x73'},
+    {'\x95','\xaf'},{'\xd2','\x74'},{'\xd2','\x7c'},{'\xd2','\x70'},{'\x00','\x00'},
+    {'\xaf','\x4e'},{'\x00','\x00'},{'\x85','\xdd'},{'\x88','\xf8'},{'\x8e','\xea'},
+    {'\x89','\xf4'},{'\x00','\x00'},{'\x88','\xfa'},{'\x8a','\xd8'},{'\x87','\xf1'},
+    {'\x00','\x00'},{'\xb2','\x6d'},{'\xd6','\x4e'},{'\x95','\x49'},{'\x00','\x00'},
+    {'\xd6','\x50'},{'\xd6','\x4c'},{'\x9c','\x40'},{'\xd6','\x58'},{'\xd6','\x4a'},
+    {'\xd6','\x57'},{'\xb2','\x69'},{'\xd6','\x48'},{'\xda','\x5b'},{'\xd6','\x52'},
+    {'\xb2','\x6c'},{'\x9c','\x4b'},{'\xd6','\x53'},{'\xd6','\x56'},{'\x00','\x00'},
+    {'\xd6','\x5a'},{'\x00','\x00'},{'\xd6','\x4f'},{'\x9c','\x4c'},{'\xd6','\x54'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb2','\x6a'},{'\xb2','\x6b'},{'\xd6','\x59'},
+    {'\xd6','\x4d'},{'\xd6','\x49'},{'\xd6','\x5b'},{'\xa0','\x78'},{'\xd6','\x51'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xd6','\x55'},{'\x82','\x44'},{'\x85','\xe0'},
+    {'\x88','\xfb'},{'\xd6','\x4b'},{'\x8a','\xd9'},{'\xb5','\x48'},{'\xb5','\x49'},
+    {'\xda','\x65'},{'\xb5','\x4f'},{'\x9c','\x4d'},{'\xda','\x59'},{'\xda','\x62'},
+    {'\xda','\x58'},{'\xb5','\x4c'},{'\xda','\x60'},{'\xda','\x5e'},{'\x00','\x00'},
+    {'\xda','\x5f'},{'\xb5','\x4a'},{'\x00','\x00'},{'\xda','\x63'},{'\x9c','\x4e'},
+    {'\x00','\x00'},{'\x9c','\x4f'},{'\x9c','\x50'},{'\x00','\x00'},{'\xda','\x5c'},
+    {'\xda','\x5a'},{'\xb5','\x4b'},{'\xda','\x5d'},{'\xda','\x61'},{'\x9c','\x51'},
+    {'\xfc','\xa7'},{'\x9c','\x52'},{'\xb5','\x4d'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xda','\x64'},{'\x9c','\x53'},{'\x92','\xe5'},{'\x00','\x00'},
+    {'\x9c','\x54'},{'\xfe','\x76'},{'\x9c','\x55'},{'\xde','\x70'},{'\xde','\x77'},
+    {'\xde','\x79'},{'\xde','\xa1'},{'\xfb','\x66'},{'\xb7','\xda'},{'\xde','\x6b'},
+    {'\x00','\x00'},{'\xb7','\xd2'},{'\x95','\x4f'},{'\xde','\x7a'},{'\xb7','\xd7'},
+    {'\xde','\xa2'},{'\xb7','\xce'},{'\x9c','\x56'},{'\xde','\x7d'},{'\x95','\x5f'},
+    {'\xde','\x6d'},{'\xde','\x7e'},{'\xde','\x6c'},{'\xa0','\x7a'},{'\xb7','\xdc'},
+    {'\x9d','\xcd'},{'\xde','\x78'},{'\xb7','\xcf'},{'\xde','\xa3'},{'\x00','\x00'},
+    {'\xb7','\xd4'},{'\xde','\x71'},{'\xb7','\xd9'},{'\xde','\x7c'},{'\xde','\x6f'},
+    {'\xde','\x76'},{'\xde','\x72'},{'\xde','\x6e'},{'\xb7','\xd1'},{'\xb7','\xd8'},
+    {'\xb7','\xd6'},{'\xb7','\xd3'},{'\xb7','\xdb'},{'\xb7','\xd0'},{'\xde','\x75'},
+    {'\x9c','\x57'},{'\xb7','\xd5'},{'\x00','\x00'},{'\xb5','\x4e'},{'\x00','\x00'},
+    {'\xde','\x7b'},{'\xfe','\x53'},{'\xde','\x73'},{'\xa0','\x7b'},{'\x00','\x00'},
+    {'\x9c','\x58'},{'\xfc','\xa9'},{'\x9c','\x59'},{'\xde','\x74'},{'\x00','\x00'},
+    {'\xa0','\x7c'},{'\xe2','\xc1'},{'\x9c','\x5a'},{'\xba','\xb4'},{'\x9c','\x5b'},
+    {'\x00','\x00'},{'\xe2','\xbd'},{'\xe2','\xc3'},{'\xe2','\xbf'},{'\x00','\x00'},
+    {'\xba','\xb6'},{'\xe2','\xbe'},{'\xe2','\xc2'},{'\xe2','\xba'},{'\xa0','\xd8'},
+    {'\xe2','\xbc'},{'\xba','\xb5'},{'\x00','\x00'},{'\x9c','\x5c'},{'\x00','\x00'},
+    {'\x9c','\x5d'},{'\xe2','\xc0'},{'\xe2','\xbb'},{'\x9c','\x5e'},{'\xba','\xb7'},
+    {'\x00','\x00'},{'\xba','\xb2'},{'\x94','\xab'},{'\x9c','\x5f'},{'\xe2','\xc4'},
+    {'\xa0','\xe7'},{'\xba','\xb3'},{'\xe6','\x67'},{'\xe6','\x64'},{'\xe6','\x70'},
+    {'\xe6','\x6a'},{'\xe6','\x6c'},{'\xbc','\xf4'},{'\xe6','\x66'},{'\xe6','\x6e'},
+    {'\x9c','\x60'},{'\x9c','\x61'},{'\xe6','\x6d'},{'\xe6','\x6b'},{'\x00','\x00'},
+    {'\xe6','\x71'},{'\xbc','\xf7'},{'\xe6','\x68'},{'\xe6','\x6f'},{'\x00','\x00'},
+    {'\xbc','\xf5'},{'\x9c','\x62'},{'\x00','\x00'},{'\xe6','\x63'},{'\xe6','\x65'},
+    {'\xbc','\xf6'},{'\xe6','\x62'},{'\xe6','\x72'},{'\x9c','\x63'},{'\xe6','\x69'},
+    {'\x00','\x00'},{'\x9c','\x64'},{'\xea','\x4a'},{'\xbf','\x51'},{'\x9c','\x65'},
+    {'\x00','\x00'},{'\xea','\x55'},{'\xea','\x53'},{'\xbf','\x4b'},{'\xea','\x49'},
+    {'\xea','\x4c'},{'\xea','\x4d'},{'\xea','\x48'},{'\xbf','\x55'},{'\xbf','\x56'},
+    {'\xea','\x47'},{'\xea','\x56'},{'\xea','\x51'},{'\xbf','\x4f'},{'\xbf','\x4c'},
+    {'\xea','\x50'},{'\xea','\x4e'},{'\x00','\x00'},{'\x00','\x00'},{'\xbf','\x52'},
+    {'\xea','\x52'},{'\xbf','\x4d'},{'\x9c','\x66'},{'\xbf','\x4e'},{'\x00','\x00'},
+    {'\xea','\x4f'},{'\xbf','\x50'},{'\xea','\x4b'},{'\xa0','\xe8'},{'\xea','\x54'},
+    {'\xbf','\x53'},{'\xea','\x57'},{'\xea','\x58'},{'\xbf','\x54'},{'\x9c','\x67'},
+    {'\x00','\x00'},{'\xc0','\xe7'},{'\xc0','\xee'},{'\xed','\x5c'},{'\xed','\x62'},
+    {'\x00','\x00'},{'\xed','\x60'},{'\xc0','\xea'},{'\xc0','\xe9'},{'\xc0','\xe6'},
+    {'\xed','\x5e'},{'\x00','\x00'},{'\x00','\x00'},{'\x9c','\x68'},{'\xc0','\xec'},
+    {'\xc0','\xeb'},{'\xc0','\xe8'},{'\x00','\x00'},{'\xed','\x61'},{'\xed','\x5d'},
+    {'\xed','\x5f'},{'\x00','\x00'},{'\xc0','\xed'},{'\xa0','\xf5'},{'\xfb','\x70'},
+    {'\x00','\x00'},{'\xc2','\x77'},{'\xef','\xfb'},{'\x00','\x00'},{'\xc2','\x74'},
+    {'\xc2','\x75'},{'\xef','\xfd'},{'\xc2','\x76'},{'\xef','\xfa'},{'\x9c','\x69'},
+    {'\xef','\xf9'},{'\xf2','\x6c'},{'\xef','\xfc'},{'\x00','\x00'},{'\xf2','\x6d'},
+    {'\xc3','\x7a'},{'\xf2','\x6b'},{'\x00','\x00'},{'\x9c','\x6a'},{'\xf2','\x6a'},
+    {'\x00','\x00'},{'\xf2','\x69'},{'\xc3','\x7b'},{'\x9c','\x6b'},{'\x9c','\x6c'},
+    {'\xc4','\x6c'},{'\x00','\x00'},{'\x00','\x00'},{'\xf4','\x6a'},{'\xf4','\x6b'},
+    {'\xfc','\xac'},{'\x9c','\x6d'},{'\x9c','\x6e'},{'\x00','\x00'},{'\xf5','\xdc'},
+    {'\xf5','\xdb'},{'\xc4','\xea'},{'\x00','\x00'},{'\xf5','\xda'},{'\xf6','\xec'},
+    {'\xf6','\xed'},{'\x00','\x00'},{'\x00','\x00'},{'\xf7','\xe6'},{'\xf8','\xb1'},
+    {'\x9c','\x6f'},{'\x9d','\x5a'},{'\xf8','\xf6'},{'\xf9','\xbc'},{'\xc6','\x79'},
+    {'\xf9','\xc6'},{'\xa4','\xf6'},{'\x91','\xc9'},{'\xaa','\xa6'},{'\xaa','\xa7'},
+    {'\x9c','\x71'},{'\x00','\x00'},{'\xac','\xb8'},{'\x85','\xc6'},{'\xfa','\x64'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc0','\xef'},{'\xa4','\xf7'},{'\x85','\xe1'},
+    {'\xaa','\xa8'},{'\xaf','\x52'},{'\xb7','\xdd'},{'\xa4','\xf8'},{'\xfa','\x65'},
+    {'\xb2','\x6e'},{'\xba','\xb8'},{'\xc9','\x62'},{'\x95','\xa7'},{'\xcf','\xb7'},
+    {'\xd2','\x7d'},{'\x00','\x00'},{'\xe2','\xc5'},{'\x00','\x00'},{'\xc0','\xf0'},
+    {'\xa4','\xf9'},{'\xaa','\xa9'},{'\xcf','\xb8'},{'\xcf','\xb9'},{'\xda','\x66'},
+    {'\xb5','\x50'},{'\x8b','\xa4'},{'\x00','\x00'},{'\xde','\xa4'},{'\xfc','\xad'},
+    {'\x00','\x00'},{'\xb7','\xde'},{'\xe2','\xc6'},{'\x00','\x00'},{'\x95','\x6e'},
+    {'\xbc','\xf8'},{'\x9c','\x73'},{'\xc3','\x7c'},{'\xa4','\xfa'},{'\xda','\x67'},
+    {'\xa4','\xfb'},{'\x9c','\x74'},{'\xa6','\xc9'},{'\xca','\x42'},{'\xa6','\xc8'},
+    {'\xa8','\x65'},{'\xa8','\x64'},{'\xa8','\x63'},{'\xcb','\x60'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfa','\x66'},{'\xaa','\xaa'},{'\x00','\x00'},{'\xaa','\xab'},
+    {'\xcd','\x5b'},{'\x00','\x00'},{'\xcf','\xba'},{'\x00','\x00'},{'\xcf','\xbd'},
+    {'\xac','\xba'},{'\xcf','\xbb'},{'\x00','\x00'},{'\xac','\xb9'},{'\xcf','\xbc'},
+    {'\xac','\xbb'},{'\x84','\x61'},{'\xd2','\xa2'},{'\xd2','\xa1'},{'\xd2','\x7e'},
+    {'\xaf','\x53'},{'\x8c','\x7b'},{'\xd6','\x5d'},{'\xd6','\x5e'},{'\xb2','\x6f'},
+    {'\xd6','\x5c'},{'\xd6','\x5f'},{'\xb5','\x52'},{'\xb2','\x70'},{'\xfa','\x67'},
+    {'\x00','\x00'},{'\xb5','\x51'},{'\xda','\x6b'},{'\xda','\x6a'},{'\xfc','\xae'},
+    {'\xda','\x68'},{'\xda','\x69'},{'\x8b','\xa5'},{'\xda','\x6c'},{'\xde','\xa6'},
+    {'\xde','\xa5'},{'\xde','\xa9'},{'\xfa','\x68'},{'\xde','\xa8'},{'\xde','\xa7'},
+    {'\xba','\xb9'},{'\xe2','\xc9'},{'\x9c','\x75'},{'\xe2','\xc8'},{'\xba','\xba'},
+    {'\xe2','\xc7'},{'\xe6','\x73'},{'\x00','\x00'},{'\xe6','\x74'},{'\xbc','\xf9'},
+    {'\x00','\x00'},{'\xea','\x59'},{'\xea','\x5a'},{'\xfa','\x69'},{'\x92','\x71'},
+    {'\xf2','\x72'},{'\xc3','\x7d'},{'\xf2','\x71'},{'\xf2','\x70'},{'\xf2','\x6e'},
+    {'\xf2','\x6f'},{'\xc4','\xeb'},{'\xf4','\x6c'},{'\xf6','\xee'},{'\xf8','\xf7'},
+    {'\x00','\x00'},{'\xa4','\xfc'},{'\xfa','\x6a'},{'\xc9','\xa5'},{'\xa5','\xc7'},
+    {'\xc9','\xa6'},{'\xfa','\x6b'},{'\xfc','\xb0'},{'\x00','\x00'},{'\xca','\x43'},
+    {'\xca','\x44'},{'\x83','\x5d'},{'\x8a','\xda'},{'\xfa','\x6c'},{'\x84','\xf6'},
+    {'\xcb','\x66'},{'\x00','\x00'},{'\x00','\x00'},{'\xcb','\x62'},{'\xfa','\x6d'},
+    {'\xcb','\x61'},{'\xaa','\xac'},{'\xcb','\x65'},{'\xa8','\x67'},{'\xcb','\x63'},
+    {'\xa8','\x66'},{'\xcb','\x67'},{'\xcb','\x64'},{'\x00','\x00'},{'\x83','\xc1'},
+    {'\xcd','\x5f'},{'\xcf','\xbe'},{'\xcd','\x5d'},{'\xcd','\x64'},{'\xfa','\x6e'},
+    {'\xaa','\xad'},{'\x00','\x00'},{'\xaa','\xb0'},{'\xcd','\x65'},{'\xcd','\x61'},
+    {'\x00','\x00'},{'\xcd','\x62'},{'\x00','\x00'},{'\xcd','\x5c'},{'\xaa','\xaf'},
+    {'\xcd','\x5e'},{'\xaa','\xae'},{'\xcd','\x63'},{'\xfa','\x6f'},{'\xcd','\x60'},
+    {'\x00','\x00'},{'\x89','\xf6'},{'\xcf','\xc2'},{'\xac','\xbd'},{'\xac','\xbe'},
+    {'\xfc','\xb1'},{'\xcf','\xc5'},{'\xcf','\xbf'},{'\x00','\x00'},{'\xcf','\xc4'},
+    {'\x00','\x00'},{'\xcf','\xc0'},{'\xac','\xbc'},{'\xcf','\xc3'},{'\xcf','\xc1'},
+    {'\x88','\xfc'},{'\x83','\xc0'},{'\x85','\xe2'},{'\x8e','\xec'},{'\x84','\x62'},
+    {'\x86','\xe2'},{'\x8e','\x47'},{'\xd2','\xa8'},{'\xd2','\xa5'},{'\x00','\x00'},
+    {'\xd2','\xa7'},{'\xaf','\x58'},{'\xaf','\x57'},{'\xaf','\x55'},{'\xd2','\xa4'},
+    {'\xd2','\xa9'},{'\xaf','\x54'},{'\xaf','\x56'},{'\xd2','\xa6'},{'\xd6','\x67'},
+    {'\xd2','\xa3'},{'\xd2','\xaa'},{'\xfc','\xb2'},{'\x8e','\xeb'},{'\x9c','\x76'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xd6','\x62'},{'\xd6','\x66'},{'\x00','\x00'},
+    {'\xd6','\x65'},{'\xda','\x6e'},{'\xda','\x79'},{'\x00','\x00'},{'\x8a','\xdb'},
+    {'\xd6','\x68'},{'\x9c','\x77'},{'\xd6','\x63'},{'\xda','\x6d'},{'\xb2','\x74'},
+    {'\x00','\x00'},{'\x8f','\x55'},{'\xb2','\x73'},{'\xd6','\x61'},{'\xd6','\x64'},
+    {'\xb2','\x75'},{'\x00','\x00'},{'\xb2','\x72'},{'\xb2','\x71'},{'\xd6','\x60'},
+    {'\xd6','\x69'},{'\x93','\xe6'},{'\x00','\x00'},{'\x8c','\xd3'},{'\xda','\x70'},
+    {'\xda','\x77'},{'\xfa','\x70'},{'\xb5','\x54'},{'\xda','\x76'},{'\xda','\x73'},
+    {'\xfc','\xb4'},{'\xb5','\x56'},{'\x95','\xbd'},{'\x95','\xbc'},{'\xfc','\xaf'},
+    {'\xda','\x75'},{'\x95','\x52'},{'\xfa','\x71'},{'\xda','\x6f'},{'\xda','\x71'},
+    {'\xda','\x74'},{'\xda','\x72'},{'\xb5','\x55'},{'\xda','\x78'},{'\xb5','\x53'},
+    {'\xb7','\xdf'},{'\xfa','\x72'},{'\xfa','\x73'},{'\xde','\xad'},{'\xde','\xac'},
+    {'\xde','\xaa'},{'\x00','\x00'},{'\xb7','\xe2'},{'\xb7','\xe1'},{'\xde','\xae'},
+    {'\x9c','\x78'},{'\xde','\xab'},{'\xe2','\xca'},{'\xba','\xbb'},{'\xb7','\xe0'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xfc','\xb3'},{'\xde','\xb0'},{'\xde','\xaf'},
+    {'\x00','\x00'},{'\xe2','\xcd'},{'\xe2','\xcb'},{'\xbc','\xfa'},{'\xfc','\xb5'},
+    {'\xba','\xbc'},{'\xe2','\xcc'},{'\xe6','\x76'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xbc','\xfb'},{'\xe6','\x75'},{'\xe6','\x7e'},
+    {'\xe6','\x7d'},{'\xe6','\x7b'},{'\x00','\x00'},{'\xe6','\x7a'},{'\xe6','\x77'},
+    {'\xe6','\x78'},{'\xe6','\x79'},{'\xe6','\x7c'},{'\xe6','\xa1'},{'\x92','\xde'},
+    {'\x00','\x00'},{'\xea','\x5f'},{'\xea','\x5c'},{'\xea','\x5d'},{'\xbf','\x57'},
+    {'\xea','\x5b'},{'\xea','\x61'},{'\xea','\x60'},{'\xea','\x5e'},{'\x8b','\xa7'},
+    {'\xed','\x64'},{'\xed','\x65'},{'\xc0','\xf1'},{'\xfc','\xb6'},{'\xc0','\xf2'},
+    {'\xed','\x63'},{'\x9c','\x79'},{'\xc2','\x79'},{'\xef','\xfe'},{'\xc2','\x78'},
+    {'\xc3','\x7e'},{'\x00','\x00'},{'\xc3','\xa1'},{'\xc4','\x6d'},{'\xf4','\x6e'},
+    {'\xf4','\x6d'},{'\xf5','\xdd'},{'\xf6','\xef'},{'\xc5','\x7a'},{'\xf7','\xe8'},
+    {'\xf7','\xe7'},{'\xf7','\xe9'},{'\xa5','\xc8'},{'\xcf','\xc6'},{'\xaf','\x59'},
+    {'\xb2','\x76'},{'\xd6','\x6a'},{'\xa5','\xc9'},{'\xc9','\xa7'},{'\xa4','\xfd'},
+    {'\x9c','\x7a'},{'\x00','\x00'},{'\xca','\x45'},{'\x9c','\x7b'},{'\x00','\x00'},
+    {'\x88','\xfd'},{'\xcb','\x6c'},{'\xcb','\x6a'},{'\xcb','\x6b'},{'\xcb','\x68'},
+    {'\xa8','\x68'},{'\xcb','\x69'},{'\x9c','\x7c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x86','\xe4'},{'\x9c','\x7d'},{'\xcd','\x6d'},{'\x9c','\x7e'},{'\xaa','\xb3'},
+    {'\xcd','\x6b'},{'\xcd','\x67'},{'\xcd','\x6a'},{'\x00','\x00'},{'\xcd','\x66'},
+    {'\xaa','\xb5'},{'\xcd','\x69'},{'\x9c','\xa1'},{'\xaa','\xb2'},{'\xaa','\xb1'},
+    {'\x9c','\xa2'},{'\xaa','\xb4'},{'\xcd','\x6c'},{'\xcd','\x68'},{'\x8e','\x48'},
+    {'\x89','\xf8'},{'\x84','\x63'},{'\x00','\x00'},{'\xac','\xc2'},{'\xac','\xc5'},
+    {'\xcf','\xce'},{'\xcf','\xcd'},{'\xcf','\xcc'},{'\xac','\xbf'},{'\xcf','\xd5'},
+    {'\xcf','\xcb'},{'\x8b','\xa8'},{'\xac','\xc1'},{'\xd2','\xaf'},{'\xfa','\x74'},
+    {'\xcf','\xd2'},{'\xcf','\xd0'},{'\xac','\xc4'},{'\x00','\x00'},{'\xcf','\xc8'},
+    {'\xcf','\xd3'},{'\x00','\x00'},{'\xcf','\xca'},{'\xcf','\xd4'},{'\xcf','\xd1'},
+    {'\xcf','\xc9'},{'\x95','\xbe'},{'\xac','\xc0'},{'\xcf','\xd6'},{'\xcf','\xc7'},
+    {'\xac','\xc3'},{'\xfa','\x75'},{'\x95','\xb6'},{'\x90','\xb2'},{'\x8b','\xfd'},
+    {'\xd2','\xb4'},{'\xd2','\xab'},{'\xd2','\xb6'},{'\x9c','\xa3'},{'\xd2','\xae'},
+    {'\xd2','\xb9'},{'\xd2','\xba'},{'\xd2','\xac'},{'\xd2','\xb8'},{'\xd2','\xb5'},
+    {'\xd2','\xb3'},{'\xd2','\xb7'},{'\xaf','\x5f'},{'\x00','\x00'},{'\xaf','\x5d'},
+    {'\x9c','\xa4'},{'\x9c','\xa5'},{'\xd2','\xb1'},{'\x9c','\xa6'},{'\xd2','\xad'},
+    {'\x9c','\xa7'},{'\xd2','\xb0'},{'\xd2','\xbb'},{'\xd2','\xb2'},{'\xaf','\x5e'},
+    {'\xcf','\xcf'},{'\x00','\x00'},{'\xaf','\x5a'},{'\xaf','\x5c'},{'\x9c','\xa8'},
+    {'\x00','\x00'},{'\xfa','\x76'},{'\x85','\xe4'},{'\x9c','\xa9'},{'\xd6','\x78'},
+    {'\xd6','\x6d'},{'\xd6','\x6b'},{'\xfe','\xaa'},{'\xd6','\x6c'},{'\x9c','\xab'},
+    {'\xd6','\x73'},{'\x9c','\xac'},{'\xd6','\x74'},{'\xd6','\x70'},{'\xb2','\x7b'},
+    {'\xd6','\x75'},{'\xd6','\x72'},{'\xd6','\x6f'},{'\x9c','\xad'},{'\xb2','\x79'},
+    {'\xd6','\x6e'},{'\xb2','\x77'},{'\xb2','\x7a'},{'\xd6','\x71'},{'\xd6','\x79'},
+    {'\xaf','\x5b'},{'\xb2','\x78'},{'\xd6','\x77'},{'\xd6','\x76'},{'\xb2','\x7c'},
+    {'\x00','\x00'},{'\x8e','\xbf'},{'\x86','\xe3'},{'\x9c','\xae'},{'\x9c','\xaf'},
+    {'\x00','\x00'},{'\x9c','\xb0'},{'\x9c','\xb1'},{'\xda','\x7e'},{'\x9c','\xb2'},
+    {'\x00','\x00'},{'\x9c','\xb3'},{'\xda','\xa1'},{'\xb5','\x60'},{'\x9c','\xb4'},
+    {'\xda','\xa7'},{'\x9c','\xb5'},{'\x9c','\xb6'},{'\xda','\xa9'},{'\xda','\xa2'},
+    {'\xb5','\x5a'},{'\xda','\xa6'},{'\xda','\xa5'},{'\xb5','\x5b'},{'\xb5','\x61'},
+    {'\x00','\x00'},{'\xb5','\x62'},{'\xda','\xa8'},{'\xb5','\x58'},{'\xda','\x7d'},
+    {'\xda','\x7b'},{'\xda','\xa3'},{'\xda','\x7a'},{'\xb5','\x5f'},{'\xda','\x7c'},
+    {'\xda','\xa4'},{'\xda','\xaa'},{'\xb5','\x59'},{'\xb5','\x5e'},{'\xb5','\x5c'},
+    {'\xb5','\x5d'},{'\x9c','\xb7'},{'\x9c','\xb8'},{'\x9c','\xb9'},{'\xb5','\x57'},
+    {'\x00','\x00'},{'\x8b','\xa9'},{'\x00','\x00'},{'\x00','\x00'},{'\xb7','\xe9'},
+    {'\xde','\xb7'},{'\xb7','\xe8'},{'\xde','\xbb'},{'\x9c','\xba'},{'\xde','\xb1'},
+    {'\x9c','\xbb'},{'\xde','\xbc'},{'\x9c','\xbc'},{'\x9c','\xbd'},{'\x9c','\xbe'},
+    {'\xde','\xb2'},{'\xde','\xb3'},{'\x00','\x00'},{'\xde','\xbd'},{'\xde','\xba'},
+    {'\xde','\xb8'},{'\xde','\xb9'},{'\xde','\xb5'},{'\xde','\xb4'},{'\x9c','\xbf'},
+    {'\xde','\xbe'},{'\xb7','\xe5'},{'\x9c','\xc0'},{'\xde','\xb6'},{'\x00','\x00'},
+    {'\xb7','\xea'},{'\xb7','\xe4'},{'\xb7','\xeb'},{'\xb7','\xec'},{'\xfc','\xb9'},
+    {'\xb7','\xe7'},{'\xb7','\xe6'},{'\xfe','\x75'},{'\x9d','\x73'},{'\xe2','\xce'},
+    {'\xba','\xbe'},{'\xba','\xbd'},{'\x9c','\xc1'},{'\x00','\x00'},{'\xe2','\xd3'},
+    {'\xfe','\xac'},{'\xbc','\xfc'},{'\xba','\xbf'},{'\x9c','\xc2'},{'\x9c','\xc3'},
+    {'\xba','\xc1'},{'\xe2','\xd4'},{'\xb7','\xe3'},{'\xba','\xc0'},{'\xe2','\xd0'},
+    {'\xe2','\xd2'},{'\xe2','\xcf'},{'\x9c','\xc4'},{'\xe2','\xd1'},{'\xfa','\x77'},
+    {'\x89','\xf9'},{'\x00','\x00'},{'\xe6','\xab'},{'\x9c','\xc5'},{'\x00','\x00'},
+    {'\xe6','\xaa'},{'\xe6','\xa7'},{'\xbd','\x40'},{'\xea','\x62'},{'\xbd','\x41'},
+    {'\xe6','\xa6'},{'\x9c','\xc6'},{'\xbc','\xfe'},{'\x00','\x00'},{'\xe6','\xa8'},
+    {'\xe6','\xa5'},{'\xe6','\xa2'},{'\xe6','\xa9'},{'\xe6','\xa3'},{'\xe6','\xa4'},
+    {'\xbc','\xfd'},{'\x81','\xd0'},{'\x81','\xd1'},{'\x8c','\x7d'},{'\x00','\x00'},
+    {'\xed','\x69'},{'\x00','\x00'},{'\xea','\x66'},{'\x00','\x00'},{'\xea','\x65'},
+    {'\xea','\x67'},{'\x00','\x00'},{'\xed','\x66'},{'\xbf','\x5a'},{'\x81','\xd2'},
+    {'\xea','\x63'},{'\x81','\xd3'},{'\xbf','\x58'},{'\x9d','\x74'},{'\xbf','\x5c'},
+    {'\xbf','\x5b'},{'\xea','\x64'},{'\xea','\x68'},{'\xfa','\x78'},{'\xbf','\x59'},
+    {'\x81','\xd4'},{'\xed','\x6d'},{'\xc0','\xf5'},{'\xc2','\x7a'},{'\xc0','\xf6'},
+    {'\xc0','\xf3'},{'\xed','\x6a'},{'\xed','\x68'},{'\x00','\x00'},{'\xed','\x6b'},
+    {'\x00','\x00'},{'\xed','\x6e'},{'\xc0','\xf4'},{'\xed','\x6c'},{'\xed','\x67'},
+    {'\x00','\x00'},{'\x81','\xd5'},{'\xf0','\x42'},{'\xf0','\x45'},{'\xf2','\x75'},
+    {'\xf0','\x40'},{'\x81','\xd6'},{'\xf4','\x6f'},{'\xf0','\x46'},{'\x00','\x00'},
+    {'\xc3','\xa2'},{'\xf0','\x44'},{'\xc2','\x7b'},{'\xf0','\x41'},{'\xf0','\x43'},
+    {'\xf0','\x47'},{'\xf2','\x76'},{'\x00','\x00'},{'\xf2','\x74'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x81','\xd7'},{'\x00','\x00'},{'\xc3','\xa3'},{'\xf2','\x73'},
+    {'\x81','\xd8'},{'\x00','\x00'},{'\x00','\x00'},{'\xc4','\x6e'},{'\x81','\xd9'},
+    {'\x00','\x00'},{'\x8c','\xf9'},{'\x81','\xda'},{'\xc4','\xed'},{'\xf6','\xf1'},
+    {'\xc4','\xec'},{'\xf6','\xf3'},{'\xf6','\xf0'},{'\xf6','\xf2'},{'\xc5','\xd0'},
+    {'\xf8','\xb2'},{'\xa5','\xca'},{'\xcd','\x6e'},{'\xd2','\xbc'},{'\xd2','\xbd'},
+    {'\xb2','\x7d'},{'\xde','\xbf'},{'\xbf','\x5d'},{'\xc3','\xa4'},{'\xc5','\x7b'},
+    {'\xf8','\xb3'},{'\xa5','\xcb'},{'\x94','\xac'},{'\xcd','\x6f'},{'\xa2','\x60'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xcf','\xd7'},{'\x00','\x00'},{'\xcf','\xd8'},
+    {'\x88','\xfe'},{'\x94','\xae'},{'\x94','\xaf'},{'\x94','\xad'},{'\x00','\x00'},
+    {'\xd2','\xbe'},{'\xd2','\xbf'},{'\xb2','\x7e'},{'\xb2','\xa1'},{'\x94','\xb0'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xda','\xab'},{'\x00','\x00'},{'\xde','\xc2'},
+    {'\xde','\xc1'},{'\xde','\xc0'},{'\xe2','\xd5'},{'\xfa','\x79'},{'\xe2','\xd6'},
+    {'\xe2','\xd7'},{'\xba','\xc2'},{'\x94','\xb1'},{'\x00','\x00'},{'\xe6','\xad'},
+    {'\xe6','\xac'},{'\x00','\x00'},{'\x00','\x00'},{'\xea','\x69'},{'\xbf','\x5e'},
+    {'\xbf','\x5f'},{'\x95','\xc2'},{'\xed','\x72'},{'\xed','\x6f'},{'\xed','\x70'},
+    {'\xed','\x71'},{'\xf0','\x49'},{'\xf0','\x48'},{'\xc2','\x7c'},{'\xf2','\x77'},
+    {'\xf5','\xde'},{'\xa5','\xcc'},{'\xfa','\x7a'},{'\xac','\xc6'},{'\x00','\x00'},
+    {'\xb2','\xa2'},{'\xde','\xc3'},{'\xfc','\xbb'},{'\xa5','\xcd'},{'\x00','\x00'},
+    {'\xd2','\xc0'},{'\xb2','\xa3'},{'\xfa','\x7b'},{'\x00','\x00'},{'\xb5','\x63'},
+    {'\xb5','\x64'},{'\x00','\x00'},{'\xa5','\xce'},{'\xa5','\xcf'},{'\xca','\x46'},
+    {'\xa8','\x6a'},{'\xa8','\x69'},{'\xac','\xc7'},{'\xcf','\xd9'},{'\xda','\xac'},
+    {'\xa5','\xd0'},{'\xa5','\xd1'},{'\xa5','\xd2'},{'\xa5','\xd3'},{'\xa0','\x59'},
+    {'\x86','\x7a'},{'\x00','\x00'},{'\xa8','\x6b'},{'\xa8','\x6c'},{'\xcb','\x6e'},
+    {'\xcb','\x6d'},{'\x84','\xf8'},{'\xfa','\x7c'},{'\xaa','\xb6'},{'\xcd','\x72'},
+    {'\xcd','\x70'},{'\xcd','\x71'},{'\x00','\x00'},{'\x81','\xdb'},{'\x00','\x00'},
+    {'\xfa','\x7d'},{'\x86','\xd0'},{'\xfb','\xd1'},{'\xcf','\xda'},{'\xcf','\xdb'},
+    {'\xfa','\x7e'},{'\x95','\xbf'},{'\xac','\xcb'},{'\xac','\xc9'},{'\xfa','\xa1'},
+    {'\xac','\xca'},{'\xac','\xc8'},{'\x00','\x00'},{'\x94','\x55'},{'\x00','\x00'},
+    {'\xfc','\xbc'},{'\xaf','\x60'},{'\x81','\xdc'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xaf','\x64'},{'\xaf','\x63'},{'\xd2','\xc1'},{'\xaf','\x62'},
+    {'\xaf','\x61'},{'\x00','\x00'},{'\xd2','\xc2'},{'\x94','\x56'},{'\x00','\x00'},
+    {'\xb2','\xa6'},{'\xd6','\x7b'},{'\xd6','\x7a'},{'\xb2','\xa4'},{'\xb2','\xa5'},
+    {'\x95','\xcc'},{'\x00','\x00'},{'\x94','\xb2'},{'\xb5','\x66'},{'\xb5','\x65'},
+    {'\xda','\xae'},{'\xfa','\xa2'},{'\x81','\xdd'},{'\xda','\xad'},{'\xb2','\xa7'},
+    {'\x00','\x00'},{'\x8d','\xe2'},{'\x92','\xec'},{'\x8b','\xaa'},{'\x00','\x00'},
+    {'\xb7','\xed'},{'\xde','\xc5'},{'\xb7','\xee'},{'\xde','\xc4'},{'\xfc','\xbd'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xe2','\xd8'},{'\xe6','\xae'},{'\xbd','\x42'},
+    {'\xea','\x6a'},{'\x00','\x00'},{'\xfa','\xa3'},{'\xfa','\xa4'},{'\xed','\x73'},
+    {'\x00','\x00'},{'\xc3','\xa6'},{'\xc3','\xa5'},{'\x00','\x00'},{'\xfa','\xa5'},
+    {'\xc5','\x7c'},{'\xa5','\xd4'},{'\xcd','\x73'},{'\x81','\xde'},{'\x93','\x51'},
+    {'\xb2','\xa8'},{'\xe2','\xd9'},{'\xba','\xc3'},{'\xc6','\xd4'},{'\x00','\x00'},
+    {'\xcb','\x6f'},{'\xcb','\x70'},{'\x8f','\x78'},{'\x89','\xfb'},{'\xcd','\x74'},
+    {'\xaa','\xb8'},{'\xaa','\xb9'},{'\x00','\x00'},{'\x00','\x00'},{'\xaa','\xb7'},
+    {'\x81','\xdf'},{'\x86','\xe5'},{'\x8a','\xdd'},{'\x86','\xe6'},{'\xac','\xcf'},
+    {'\xac','\xd0'},{'\xac','\xcd'},{'\xac','\xce'},{'\x00','\x00'},{'\xcf','\xdc'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xcf','\xdd'},{'\xac','\xcc'},{'\xfa','\xa6'},
+    {'\x00','\x00'},{'\x87','\xf4'},{'\x86','\xe7'},{'\xd2','\xc3'},{'\xfe','\x51'},
+    {'\xaf','\x68'},{'\xaf','\x69'},{'\xfb','\x5c'},{'\xb2','\xab'},{'\xd2','\xc9'},
+    {'\x00','\x00'},{'\xaf','\x6e'},{'\xaf','\x6c'},{'\xd2','\xca'},{'\xd2','\xc5'},
+    {'\xaf','\x6b'},{'\xaf','\x6a'},{'\xaf','\x65'},{'\xd2','\xc8'},{'\xd2','\xc7'},
+    {'\xd2','\xc4'},{'\xaf','\x6d'},{'\xfc','\xd3'},{'\xd2','\xc6'},{'\xaf','\x66'},
+    {'\x00','\x00'},{'\xaf','\x67'},{'\x8f','\xfd'},{'\x84','\xf9'},{'\xb2','\xac'},
+    {'\xd6','\xa1'},{'\xd6','\xa2'},{'\xb2','\xad'},{'\xd6','\x7c'},{'\xd6','\x7e'},
+    {'\xd6','\xa4'},{'\xd6','\xa3'},{'\xd6','\x7d'},{'\x00','\x00'},{'\xb2','\xa9'},
+    {'\xb2','\xaa'},{'\xfa','\xa7'},{'\xda','\xb6'},{'\xb5','\x6b'},{'\xb5','\x6a'},
+    {'\xda','\xb0'},{'\xb5','\x68'},{'\x81','\xe0'},{'\xda','\xb3'},{'\xb5','\x6c'},
+    {'\xda','\xb4'},{'\xb5','\x6d'},{'\xda','\xb1'},{'\xb5','\x67'},{'\xb5','\x69'},
+    {'\xda','\xb5'},{'\x00','\x00'},{'\xda','\xb2'},{'\xda','\xaf'},{'\x89','\xfa'},
+    {'\xfa','\xa8'},{'\x86','\xe8'},{'\x8f','\x58'},{'\x00','\x00'},{'\xde','\xd2'},
+    {'\x00','\x00'},{'\xde','\xc7'},{'\xb7','\xf0'},{'\xb7','\xf3'},{'\xb7','\xf2'},
+    {'\xb7','\xf7'},{'\xb7','\xf6'},{'\xde','\xd3'},{'\xde','\xd1'},{'\xde','\xca'},
+    {'\xde','\xce'},{'\xde','\xcd'},{'\xb7','\xf4'},{'\xde','\xd0'},{'\xde','\xcc'},
+    {'\xde','\xd4'},{'\xde','\xcb'},{'\xb7','\xf5'},{'\xb7','\xef'},{'\xb7','\xf1'},
+    {'\xfc','\xd5'},{'\xde','\xc9'},{'\x00','\x00'},{'\x8f','\x57'},{'\x00','\x00'},
+    {'\xfc','\xd4'},{'\xe2','\xdb'},{'\xba','\xc7'},{'\xe2','\xdf'},{'\xba','\xc6'},
+    {'\xe2','\xdc'},{'\xba','\xc5'},{'\x00','\x00'},{'\xde','\xc8'},{'\xde','\xcf'},
+    {'\xe2','\xde'},{'\x00','\x00'},{'\xba','\xc8'},{'\xe2','\xe0'},{'\xe2','\xdd'},
+    {'\xe2','\xda'},{'\x8e','\xc1'},{'\x89','\x40'},{'\xe6','\xb1'},{'\xe6','\xb5'},
+    {'\xe6','\xb7'},{'\xe6','\xb3'},{'\xe6','\xb2'},{'\xe6','\xb0'},{'\xbd','\x45'},
+    {'\xbd','\x43'},{'\xbd','\x48'},{'\xbd','\x49'},{'\xe6','\xb4'},{'\xbd','\x46'},
+    {'\xe6','\xaf'},{'\xbd','\x47'},{'\xba','\xc4'},{'\xe6','\xb6'},{'\xbd','\x44'},
+    {'\x8b','\xab'},{'\x8d','\x54'},{'\x81','\xe1'},{'\xea','\x6c'},{'\x00','\x00'},
+    {'\xea','\x6b'},{'\xea','\x73'},{'\xea','\x6d'},{'\xea','\x72'},{'\xea','\x6f'},
+    {'\xbf','\x60'},{'\xea','\x71'},{'\x00','\x00'},{'\x00','\x00'},{'\xbf','\x61'},
+    {'\x00','\x00'},{'\xbf','\x62'},{'\x95','\xa9'},{'\xea','\x70'},{'\xea','\x6e'},
+    {'\x8c','\xd5'},{'\x90','\x58'},{'\xfa','\xa9'},{'\x00','\x00'},{'\xc0','\xf8'},
+    {'\xed','\x74'},{'\x00','\x00'},{'\x00','\x00'},{'\xc0','\xf7'},{'\xed','\x77'},
+    {'\xed','\x75'},{'\xed','\x76'},{'\x00','\x00'},{'\x00','\x00'},{'\xc0','\xf9'},
+    {'\xfa','\xaa'},{'\x95','\x6f'},{'\x81','\xe2'},{'\xf0','\x4d'},{'\x81','\xe3'},
+    {'\xc2','\xa1'},{'\xf0','\x4e'},{'\xfa','\xab'},{'\x00','\x00'},{'\xc2','\x7d'},
+    {'\xf0','\x4f'},{'\xc2','\x7e'},{'\xf0','\x4c'},{'\xf0','\x50'},{'\x00','\x00'},
+    {'\xf0','\x4a'},{'\x00','\x00'},{'\x8c','\x7e'},{'\xc3','\xa7'},{'\xf2','\x78'},
+    {'\xc3','\xa8'},{'\xc4','\x6f'},{'\x8c','\xd6'},{'\xf0','\x4b'},{'\xc4','\x70'},
+    {'\xfb','\x76'},{'\xfc','\xd7'},{'\xfa','\xac'},{'\xc4','\xee'},{'\xf5','\xdf'},
+    {'\x8d','\x55'},{'\xc5','\x7e'},{'\xf6','\xf4'},{'\xc5','\x7d'},{'\xfc','\xd8'},
+    {'\xf7','\xea'},{'\xc5','\xf5'},{'\xc5','\xf6'},{'\x81','\xe4'},{'\x81','\xe5'},
+    {'\xf9','\xcc'},{'\xc6','\xd5'},{'\x00','\x00'},{'\xac','\xd1'},{'\xcf','\xde'},
+    {'\x93','\xb9'},{'\xb5','\x6e'},{'\xb5','\x6f'},{'\xa5','\xd5'},{'\xa6','\xca'},
+    {'\xca','\x47'},{'\xfa','\xad'},{'\xcb','\x71'},{'\xa8','\x6d'},{'\xfa','\xae'},
+    {'\xaa','\xba'},{'\x00','\x00'},{'\xac','\xd2'},{'\xac','\xd3'},{'\xac','\xd4'},
+    {'\xd6','\xa6'},{'\xd2','\xcb'},{'\xaf','\x6f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb2','\xae'},{'\xd6','\xa5'},{'\xfa','\xaf'},{'\x87','\xf5'},{'\xda','\xb8'},
+    {'\xb5','\x71'},{'\x00','\x00'},{'\xda','\xb7'},{'\xb5','\x70'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xde','\xd5'},{'\xbd','\x4a'},{'\xe6','\xbb'},{'\xe6','\xb8'},
+    {'\xe6','\xb9'},{'\xe6','\xba'},{'\x00','\x00'},{'\x00','\x00'},{'\xfc','\xbe'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xed','\x78'},{'\x81','\xe6'},{'\xf0','\x51'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xf4','\x71'},{'\xf4','\x70'},
+    {'\x00','\x00'},{'\xf6','\xf5'},{'\xa5','\xd6'},{'\xcd','\x75'},{'\xaf','\x70'},
+    {'\x87','\xf6'},{'\x8e','\x77'},{'\x00','\x00'},{'\xb5','\x72'},{'\xde','\xd6'},
+    {'\x00','\x00'},{'\xfa','\xb0'},{'\xe2','\xe1'},{'\xfa','\xb1'},{'\xbd','\x4b'},
+    {'\xea','\x74'},{'\x00','\x00'},{'\xf0','\x52'},{'\xf4','\x72'},{'\xa5','\xd7'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xaa','\xbb'},{'\xac','\xd7'},{'\xcf','\xdf'},
+    {'\xac','\xd8'},{'\xac','\xd6'},{'\x00','\x00'},{'\xac','\xd5'},{'\xd2','\xcc'},
+    {'\xaf','\x71'},{'\x00','\x00'},{'\xfc','\xbf'},{'\xaf','\x72'},{'\xaf','\x73'},
+    {'\x85','\xe6'},{'\x8d','\x69'},{'\x86','\xea'},{'\xb2','\xb0'},{'\xd6','\xa7'},
+    {'\xb2','\xaf'},{'\x00','\x00'},{'\x87','\x49'},{'\x84','\xfb'},{'\x87','\xf7'},
+    {'\x81','\xe7'},{'\xda','\xb9'},{'\xb2','\xb1'},{'\xb5','\x73'},{'\xde','\xd7'},
+    {'\xb7','\xf8'},{'\xb7','\xf9'},{'\x00','\x00'},{'\xba','\xc9'},{'\x00','\x00'},
+    {'\xba','\xca'},{'\xbd','\x4c'},{'\xbf','\x64'},{'\xea','\x75'},{'\xbf','\x63'},
+    {'\x00','\x00'},{'\xed','\x79'},{'\xc0','\xfa'},{'\x00','\x00'},{'\xf0','\x53'},
+    {'\xf4','\x73'},{'\xa5','\xd8'},{'\xa8','\x6e'},{'\xcd','\x78'},{'\xcd','\x77'},
+    {'\xaa','\xbc'},{'\xcd','\x76'},{'\xaa','\xbd'},{'\xcd','\x79'},{'\x00','\x00'},
+    {'\xcf','\xe5'},{'\xac','\xdb'},{'\xac','\xda'},{'\xcf','\xe7'},{'\xcf','\xe6'},
+    {'\xac','\xdf'},{'\x00','\x00'},{'\xac','\xde'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xac','\xd9'},{'\x00','\x00'},{'\xcf','\xe1'},{'\xcf','\xe2'},{'\xcf','\xe3'},
+    {'\x00','\x00'},{'\xac','\xe0'},{'\xcf','\xe0'},{'\xac','\xdc'},{'\xcf','\xe4'},
+    {'\xac','\xdd'},{'\x92','\xb1'},{'\xfa','\xb2'},{'\x81','\xe8'},{'\x81','\xe9'},
+    {'\xd2','\xcf'},{'\xd2','\xd3'},{'\xd2','\xd1'},{'\xd2','\xd0'},{'\x00','\x00'},
+    {'\xd2','\xd4'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xd2','\xd5'},
+    {'\xd2','\xd6'},{'\xd2','\xce'},{'\x00','\x00'},{'\xd2','\xcd'},{'\xfa','\xb3'},
+    {'\xaf','\x75'},{'\xaf','\x76'},{'\x00','\x00'},{'\xd2','\xd7'},{'\xd2','\xd2'},
+    {'\xfc','\xc0'},{'\xd6','\xb0'},{'\x8d','\xd2'},{'\xd2','\xd8'},{'\xaf','\x77'},
+    {'\xaf','\x74'},{'\x00','\x00'},{'\xfc','\xc1'},{'\x00','\x00'},{'\xd6','\xaa'},
+    {'\x00','\x00'},{'\xd6','\xa9'},{'\x00','\x00'},{'\xd6','\xab'},{'\xd6','\xac'},
+    {'\xd6','\xae'},{'\xd6','\xad'},{'\xd6','\xb2'},{'\xb2','\xb5'},{'\xb2','\xb2'},
+    {'\xb2','\xb6'},{'\xd6','\xa8'},{'\xb2','\xb7'},{'\xd6','\xb1'},{'\xb2','\xb4'},
+    {'\xd6','\xaf'},{'\xb2','\xb3'},{'\x00','\x00'},{'\x95','\x4d'},{'\x85','\xe8'},
+    {'\x00','\x00'},{'\xfa','\xb4'},{'\xda','\xbc'},{'\xda','\xbe'},{'\xda','\xba'},
+    {'\xda','\xbb'},{'\x00','\x00'},{'\x00','\x00'},{'\xda','\xbf'},{'\xda','\xc1'},
+    {'\xda','\xc2'},{'\xda','\xbd'},{'\xda','\xc0'},{'\xb5','\x74'},{'\x85','\xe7'},
+    {'\x8a','\xde'},{'\xde','\xdb'},{'\x00','\x00'},{'\xde','\xe0'},{'\xde','\xd8'},
+    {'\xde','\xdc'},{'\x00','\x00'},{'\x81','\xea'},{'\xde','\xe1'},{'\xde','\xdd'},
+    {'\xb7','\xfa'},{'\xb8','\x43'},{'\x00','\x00'},{'\xb7','\xfd'},{'\xde','\xd9'},
+    {'\xde','\xda'},{'\xba','\xce'},{'\xb8','\x46'},{'\xb7','\xfe'},{'\x00','\x00'},
+    {'\xb8','\x44'},{'\xb7','\xfc'},{'\xde','\xdf'},{'\xb8','\x45'},{'\xde','\xde'},
+    {'\xb8','\x41'},{'\xb7','\xfb'},{'\xb8','\x42'},{'\xde','\xe2'},{'\xe2','\xe6'},
+    {'\xe2','\xe8'},{'\x00','\x00'},{'\x00','\x00'},{'\x81','\xeb'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x81','\xec'},{'\x81','\xed'},
+    {'\xb8','\x40'},{'\x81','\xee'},{'\x81','\xef'},{'\xe2','\xe3'},{'\xba','\xcc'},
+    {'\xe2','\xe9'},{'\xba','\xcd'},{'\xe2','\xe7'},{'\xe2','\xe2'},{'\xe2','\xe5'},
+    {'\xe2','\xea'},{'\xba','\xcb'},{'\xe2','\xe4'},{'\x00','\x00'},{'\xbd','\x4e'},
+    {'\xe6','\xbf'},{'\xe6','\xbe'},{'\x00','\x00'},{'\xbd','\x51'},{'\xbd','\x4f'},
+    {'\xe6','\xbc'},{'\xbd','\x4d'},{'\xe6','\xbd'},{'\x00','\x00'},{'\xbd','\x50'},
+    {'\x89','\x42'},{'\xfb','\x6b'},{'\x00','\x00'},{'\xea','\x7d'},{'\x00','\x00'},
+    {'\xea','\xa1'},{'\x81','\xf0'},{'\xea','\x7e'},{'\xea','\x76'},{'\xea','\x7a'},
+    {'\xea','\x79'},{'\xea','\x77'},{'\xbf','\x66'},{'\xbf','\x67'},{'\xbf','\x65'},
+    {'\xea','\x78'},{'\xea','\x7b'},{'\xea','\x7c'},{'\x00','\x00'},{'\xbf','\x68'},
+    {'\x00','\x00'},{'\xc1','\x40'},{'\xed','\xa3'},{'\x8d','\x7c'},{'\xc0','\xfc'},
+    {'\xed','\x7b'},{'\xc0','\xfe'},{'\xc1','\x41'},{'\x00','\x00'},{'\x81','\xf1'},
+    {'\xc0','\xfd'},{'\xed','\xa2'},{'\xed','\x7c'},{'\xc0','\xfb'},{'\xed','\xa1'},
+    {'\xed','\x7a'},{'\xed','\x7e'},{'\xed','\x7d'},{'\x00','\x00'},{'\xfe','\x5a'},
+    {'\xf0','\x55'},{'\xc2','\xa4'},{'\xc2','\xa5'},{'\xc2','\xa2'},{'\x81','\xf2'},
+    {'\xc2','\xa3'},{'\x00','\x00'},{'\x00','\x00'},{'\xf0','\x54'},{'\x81','\xf3'},
+    {'\xf2','\x7b'},{'\x81','\xf4'},{'\x00','\x00'},{'\xc3','\xa9'},{'\x00','\x00'},
+    {'\xf2','\x79'},{'\xf2','\x7a'},{'\x81','\xf5'},{'\xf4','\x74'},{'\xf4','\x77'},
+    {'\xf4','\x75'},{'\xf4','\x76'},{'\xf5','\xe0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc4','\xef'},{'\xf7','\xeb'},{'\xf8','\xb4'},{'\x00','\x00'},{'\xc5','\xf7'},
+    {'\xf8','\xf8'},{'\xf8','\xf9'},{'\xc6','\x66'},{'\xa5','\xd9'},{'\xac','\xe1'},
+    {'\x81','\xf6'},{'\xda','\xc3'},{'\x00','\x00'},{'\xde','\xe3'},{'\x00','\x00'},
+    {'\xa5','\xda'},{'\xa8','\x6f'},{'\x00','\x00'},{'\xaa','\xbe'},{'\x81','\xf7'},
+    {'\xcf','\xe8'},{'\xcf','\xe9'},{'\xaf','\x78'},{'\x00','\x00'},{'\x89','\xfc'},
+    {'\xda','\xc4'},{'\xb5','\x75'},{'\xb8','\x47'},{'\xc1','\x42'},{'\xed','\xa4'},
+    {'\xf2','\x7c'},{'\xf4','\x78'},{'\xa5','\xdb'},{'\x81','\xf8'},{'\x00','\x00'},
+    {'\x89','\xfe'},{'\xcd','\xa1'},{'\xcd','\x7a'},{'\xcd','\x7c'},{'\xcd','\x7e'},
+    {'\xcd','\x7d'},{'\xcd','\x7b'},{'\xaa','\xbf'},{'\x8c','\x41'},{'\x8b','\xfe'},
+    {'\x8e','\x78'},{'\x87','\xf9'},{'\xac','\xe2'},{'\xcf','\xf2'},{'\x00','\x00'},
+    {'\xcf','\xed'},{'\xcf','\xea'},{'\x00','\x00'},{'\x96','\x41'},{'\xcf','\xf1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xac','\xe4'},{'\xac','\xe5'},{'\xcf','\xf0'},
+    {'\xcf','\xef'},{'\xcf','\xee'},{'\xcf','\xeb'},{'\xcf','\xec'},{'\xcf','\xf3'},
+    {'\xac','\xe3'},{'\x92','\xc5'},{'\x89','\x43'},{'\x8d','\xe3'},{'\xfa','\xb5'},
+    {'\x00','\x00'},{'\x84','\xfc'},{'\x00','\x00'},{'\xfa','\xb6'},{'\xaf','\x7c'},
+    {'\x81','\xf9'},{'\xaf','\xa4'},{'\xaf','\xa3'},{'\xd2','\xe1'},{'\xd2','\xdb'},
+    {'\xd2','\xd9'},{'\x00','\x00'},{'\xaf','\xa1'},{'\xd6','\xb9'},{'\xaf','\x7a'},
+    {'\xd2','\xde'},{'\xd2','\xe2'},{'\xd2','\xe4'},{'\xd2','\xe0'},{'\xd2','\xda'},
+    {'\xaf','\xa2'},{'\xd2','\xdf'},{'\xd2','\xdd'},{'\xaf','\x79'},{'\xd2','\xe5'},
+    {'\xaf','\xa5'},{'\xd2','\xe3'},{'\xaf','\x7d'},{'\xd2','\xdc'},{'\x00','\x00'},
+    {'\xaf','\x7e'},{'\xaf','\x7b'},{'\xfa','\xb7'},{'\x8c','\x40'},{'\x90','\x42'},
+    {'\xfa','\xb8'},{'\x81','\xfa'},{'\x8c','\x42'},{'\x82','\x5f'},{'\x8a','\xdf'},
+    {'\x00','\x00'},{'\x81','\xfb'},{'\xb2','\xb9'},{'\x81','\xfc'},{'\xd6','\xba'},
+    {'\x00','\x00'},{'\xfa','\xb9'},{'\xd6','\xb3'},{'\xd6','\xb5'},{'\xd6','\xb7'},
+    {'\x81','\xfd'},{'\xd6','\xb8'},{'\xd6','\xb6'},{'\xb2','\xba'},{'\x00','\x00'},
+    {'\xd6','\xbb'},{'\x81','\xfe'},{'\xd6','\xb4'},{'\xfc','\xc3'},{'\x96','\x4b'},
+    {'\x86','\xeb'},{'\xfa','\xba'},{'\x8f','\x59'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xda','\xc8'},{'\xb5','\x76'},{'\xda','\xd0'},
+    {'\x00','\x00'},{'\xda','\xc5'},{'\x00','\x00'},{'\xda','\xd1'},{'\x00','\x00'},
+    {'\xda','\xc6'},{'\xda','\xc7'},{'\x96','\x4c'},{'\x00','\x00'},{'\xda','\xcf'},
+    {'\xda','\xce'},{'\xda','\xcb'},{'\xb2','\xb8'},{'\xb5','\x77'},{'\xda','\xc9'},
+    {'\xda','\xcc'},{'\xb5','\x78'},{'\xda','\xcd'},{'\xda','\xca'},{'\x94','\x54'},
+    {'\x00','\x00'},{'\x94','\xb4'},{'\x00','\x00'},{'\x00','\x00'},{'\x8d','\x68'},
+    {'\x00','\x00'},{'\xde','\xee'},{'\xfa','\xbb'},{'\xde','\xf2'},{'\xb8','\x4e'},
+    {'\x00','\x00'},{'\xe2','\xf0'},{'\xb8','\x51'},{'\xde','\xf0'},{'\xf9','\xd6'},
+    {'\x00','\x00'},{'\xde','\xed'},{'\xde','\xe8'},{'\xde','\xea'},{'\xde','\xeb'},
+    {'\xde','\xe4'},{'\x96','\x4d'},{'\xb8','\x4d'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb8','\x4c'},{'\x8b','\xac'},{'\xb8','\x48'},{'\xde','\xe7'},{'\x00','\x00'},
+    {'\xb8','\x4f'},{'\x00','\x00'},{'\xb8','\x50'},{'\xde','\xe6'},{'\xde','\xe9'},
+    {'\xde','\xf1'},{'\xb8','\x4a'},{'\xb8','\x4b'},{'\xde','\xef'},{'\xde','\xe5'},
+    {'\x89','\x44'},{'\x8e','\xed'},{'\x00','\x00'},{'\xe2','\xf2'},{'\xba','\xd0'},
+    {'\xe2','\xf4'},{'\xde','\xec'},{'\xe2','\xf6'},{'\xba','\xd4'},{'\xe2','\xf7'},
+    {'\xe2','\xf3'},{'\x00','\x00'},{'\xba','\xd1'},{'\xe2','\xef'},{'\xba','\xd3'},
+    {'\xe2','\xec'},{'\xe2','\xf1'},{'\xe2','\xf5'},{'\xe2','\xee'},{'\x00','\x00'},
+    {'\xfc','\xc7'},{'\xb8','\x49'},{'\x95','\xf0'},{'\xe2','\xeb'},{'\xba','\xd2'},
+    {'\xe2','\xed'},{'\xfa','\xbc'},{'\x96','\x4e'},{'\x00','\x00'},{'\x96','\xcd'},
+    {'\xfa','\xbd'},{'\xbd','\x54'},{'\xe6','\xc1'},{'\xbd','\x58'},{'\x00','\x00'},
+    {'\xbd','\x56'},{'\x00','\x00'},{'\x00','\x00'},{'\xba','\xcf'},{'\x00','\x00'},
+    {'\xe6','\xc8'},{'\xe6','\xc9'},{'\xbd','\x53'},{'\xfa','\xbe'},{'\x96','\x4f'},
+    {'\xe6','\xc7'},{'\xe6','\xca'},{'\xbd','\x55'},{'\xbd','\x52'},{'\xe6','\xc3'},
+    {'\xe6','\xc0'},{'\xe6','\xc5'},{'\xe6','\xc2'},{'\xbd','\x59'},{'\xe6','\xc4'},
+    {'\x96','\x50'},{'\xfc','\xc4'},{'\xe6','\xc6'},{'\xbd','\x57'},{'\x00','\x00'},
+    {'\x96','\x51'},{'\xfc','\xc5'},{'\xfa','\xbf'},{'\xbf','\x6a'},{'\xea','\xa8'},
+    {'\x00','\x00'},{'\xea','\xa2'},{'\xea','\xa6'},{'\xea','\xac'},{'\xea','\xad'},
+    {'\xea','\xa9'},{'\xea','\xaa'},{'\xea','\xa7'},{'\x96','\x54'},{'\xea','\xa4'},
+    {'\x00','\x00'},{'\xbf','\x6c'},{'\xbf','\x69'},{'\xea','\xa3'},{'\xea','\xa5'},
+    {'\x00','\x00'},{'\xbf','\x6b'},{'\xea','\xab'},{'\x96','\x55'},{'\xc1','\x46'},
+    {'\x96','\x56'},{'\x96','\x57'},{'\xed','\xaa'},{'\xed','\xa5'},{'\xc1','\x45'},
+    {'\x96','\x58'},{'\x00','\x00'},{'\xc1','\x43'},{'\x00','\x00'},{'\xed','\xac'},
+    {'\xc1','\x44'},{'\xed','\xa8'},{'\xed','\xa9'},{'\xed','\xa6'},{'\xed','\xad'},
+    {'\xf0','\x56'},{'\x00','\x00'},{'\xc1','\x47'},{'\xed','\xa7'},{'\x00','\x00'},
+    {'\xed','\xae'},{'\xed','\xab'},{'\xfb','\xa8'},{'\xfa','\xc0'},{'\x00','\x00'},
+    {'\xf0','\x5a'},{'\x00','\x00'},{'\x00','\x00'},{'\xf0','\x57'},{'\x00','\x00'},
+    {'\xc2','\xa6'},{'\x00','\x00'},{'\xf0','\x5b'},{'\xf0','\x5d'},{'\xf0','\x5c'},
+    {'\xf0','\x58'},{'\xf0','\x59'},{'\x00','\x00'},{'\x00','\x00'},{'\xf2','\xa3'},
+    {'\x00','\x00'},{'\xc3','\xaa'},{'\x00','\x00'},{'\xf2','\x7e'},{'\xf2','\xa2'},
+    {'\xf2','\x7d'},{'\xf2','\xa4'},{'\x00','\x00'},{'\x00','\x00'},{'\xf2','\xa1'},
+    {'\x00','\x00'},{'\xf4','\x7a'},{'\xf4','\x7d'},{'\xf4','\x79'},{'\xc4','\x71'},
+    {'\xf4','\x7b'},{'\xf4','\x7c'},{'\xf4','\x7e'},{'\xc4','\x72'},{'\xc4','\x74'},
+    {'\xc4','\x73'},{'\xf5','\xe1'},{'\xfe','\x77'},{'\xf5','\xe3'},{'\xfa','\xc1'},
+    {'\xf5','\xe2'},{'\x96','\x59'},{'\x96','\x5a'},{'\xfa','\xc2'},{'\xf6','\xf6'},
+    {'\x96','\x5b'},{'\x00','\x00'},{'\xf8','\xb5'},{'\xf8','\xfa'},{'\xa5','\xdc'},
+    {'\xfa','\xc3'},{'\x8a','\xe0'},{'\xcb','\x72'},{'\xaa','\xc0'},{'\xcd','\xa3'},
+    {'\xaa','\xc1'},{'\xaa','\xc2'},{'\xcd','\xa2'},{'\x00','\x00'},{'\xcf','\xf8'},
+    {'\xcf','\xf7'},{'\xac','\xe6'},{'\xac','\xe9'},{'\xac','\xe8'},{'\xac','\xe7'},
+    {'\xcf','\xf4'},{'\xcf','\xf6'},{'\xcf','\xf5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xd2','\xe8'},{'\xaf','\xa7'},{'\xd2','\xec'},{'\xd2','\xeb'},{'\xd2','\xea'},
+    {'\xd2','\xe6'},{'\xaf','\xa6'},{'\xaf','\xaa'},{'\xaf','\xad'},{'\x96','\x5c'},
+    {'\x96','\x5e'},{'\xaf','\xae'},{'\xd2','\xe7'},{'\xd2','\xe9'},{'\xaf','\xac'},
+    {'\xaf','\xab'},{'\xaf','\xa9'},{'\xaf','\xa8'},{'\xd6','\xc2'},{'\x8f','\xbe'},
+    {'\xd6','\xc0'},{'\xd6','\xbc'},{'\xb2','\xbb'},{'\x00','\x00'},{'\xd6','\xbd'},
+    {'\xb2','\xbc'},{'\xd6','\xbe'},{'\xd6','\xbf'},{'\xd6','\xc1'},{'\x00','\x00'},
+    {'\xb2','\xbd'},{'\x00','\x00'},{'\x86','\xec'},{'\xda','\xd5'},{'\x96','\x5f'},
+    {'\xda','\xd4'},{'\xda','\xd3'},{'\xda','\xd2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x82','\x70'},{'\x86','\xed'},{'\xde','\xf6'},{'\xb8','\x52'},{'\x00','\x00'},
+    {'\xde','\xf3'},{'\xde','\xf5'},{'\x96','\x60'},{'\xb8','\x53'},{'\xfa','\xc4'},
+    {'\xb8','\x54'},{'\xde','\xf4'},{'\x96','\x61'},{'\x82','\x77'},{'\x93','\x50'},
+    {'\x96','\x62'},{'\x96','\x63'},{'\xe3','\x41'},{'\x00','\x00'},{'\xe2','\xf9'},
+    {'\xe2','\xfa'},{'\x00','\x00'},{'\xba','\xd7'},{'\xba','\xd5'},{'\xba','\xd6'},
+    {'\xe3','\x43'},{'\x96','\x64'},{'\xe3','\x42'},{'\xe2','\xfe'},{'\xe2','\xfd'},
+    {'\xe2','\xfc'},{'\xe2','\xfb'},{'\xe3','\x40'},{'\xe2','\xf8'},{'\x96','\x65'},
+    {'\xe6','\xcb'},{'\xe6','\xd0'},{'\xe6','\xce'},{'\xfa','\xc5'},{'\x00','\x00'},
+    {'\x96','\x66'},{'\xe6','\xcd'},{'\xe6','\xcc'},{'\xe6','\xcf'},{'\x00','\x00'},
+    {'\xea','\xae'},{'\x96','\x67'},{'\xbf','\x6d'},{'\xc1','\x48'},{'\xed','\xb0'},
+    {'\xfc','\xca'},{'\xc1','\x49'},{'\xed','\xaf'},{'\xf0','\x5f'},{'\xf0','\x5e'},
+    {'\xc2','\xa7'},{'\x00','\x00'},{'\xf2','\xa5'},{'\xc3','\xab'},{'\xf4','\xa1'},
+    {'\xc5','\xa1'},{'\xf6','\xf7'},{'\x00','\x00'},{'\xf8','\xb7'},{'\xf8','\xb6'},
+    {'\xc9','\xa8'},{'\xac','\xea'},{'\xac','\xeb'},{'\xd6','\xc3'},{'\x00','\x00'},
+    {'\xb8','\x56'},{'\xa5','\xdd'},{'\xa8','\x72'},{'\xa8','\x71'},{'\xa8','\x70'},
+    {'\x00','\x00'},{'\xfa','\xc6'},{'\xfb','\xa9'},{'\xcd','\xa4'},{'\x84','\xfd'},
+    {'\x00','\x00'},{'\xaa','\xc4'},{'\xaa','\xc3'},{'\x9d','\xce'},{'\xac','\xee'},
+    {'\xfc','\xa6'},{'\xcf','\xfa'},{'\xcf','\xfd'},{'\xcf','\xfb'},{'\x00','\x00'},
+    {'\xac','\xec'},{'\xac','\xed'},{'\x00','\x00'},{'\xfc','\xcc'},{'\xcf','\xf9'},
+    {'\xcf','\xfc'},{'\x00','\x00'},{'\xaf','\xb5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd2','\xf3'},{'\xd2','\xf5'},{'\xd2','\xf4'},{'\xaf','\xb2'},
+    {'\xd2','\xef'},{'\xfa','\xc7'},{'\x96','\x68'},{'\xaf','\xb0'},{'\xaf','\xaf'},
+    {'\x00','\x00'},{'\xaf','\xb3'},{'\xaf','\xb1'},{'\x00','\x00'},{'\xaf','\xb4'},
+    {'\xd2','\xf2'},{'\xd2','\xed'},{'\xd2','\xee'},{'\xd2','\xf1'},{'\xd2','\xf0'},
+    {'\x85','\xb8'},{'\x86','\xef'},{'\x96','\x69'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x96','\x6a'},{'\x00','\x00'},{'\xd6','\xc6'},{'\xd6','\xc7'},{'\xd6','\xc5'},
+    {'\x00','\x00'},{'\xd6','\xc4'},{'\xb2','\xbe'},{'\x00','\x00'},{'\x8a','\xe2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb5','\x7d'},{'\x00','\x00'},{'\xda','\xd6'},
+    {'\xda','\xd8'},{'\xda','\xda'},{'\xb5','\x7c'},{'\xfa','\xc8'},{'\x00','\x00'},
+    {'\xb5','\x7a'},{'\x00','\x00'},{'\xda','\xd7'},{'\xb5','\x7b'},{'\xda','\xd9'},
+    {'\xb5','\x79'},{'\xfa','\xc9'},{'\x00','\x00'},{'\xdf','\x41'},{'\xde','\xf7'},
+    {'\xde','\xfa'},{'\xde','\xfe'},{'\xb8','\x5a'},{'\xde','\xfc'},{'\x00','\x00'},
+    {'\xde','\xfb'},{'\xde','\xf8'},{'\xde','\xf9'},{'\xb8','\x58'},{'\xdf','\x40'},
+    {'\xb8','\x57'},{'\x00','\x00'},{'\xb8','\x5c'},{'\xb8','\x5b'},{'\xb8','\x59'},
+    {'\x00','\x00'},{'\xde','\xfd'},{'\x89','\x47'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe3','\x49'},{'\x00','\x00'},{'\xe3','\x48'},{'\x00','\x00'},{'\x96','\x6b'},
+    {'\xe3','\x44'},{'\x00','\x00'},{'\xfc','\xce'},{'\xba','\xd8'},{'\xe3','\x47'},
+    {'\xe3','\x46'},{'\xba','\xd9'},{'\x93','\xa6'},{'\x8b','\xae'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xbd','\x5e'},{'\x00','\x00'},{'\xe6','\xd2'},
+    {'\x96','\x6c'},{'\xbd','\x5f'},{'\xbd','\x5b'},{'\xbd','\x5d'},{'\xfc','\xcf'},
+    {'\xbd','\x5a'},{'\xbd','\x5c'},{'\x00','\x00'},{'\x92','\xf9'},{'\xfa','\xca'},
+    {'\xea','\xaf'},{'\x96','\x6d'},{'\xbf','\x70'},{'\xea','\xb1'},{'\xea','\xb0'},
+    {'\xfc','\xd0'},{'\xe3','\x45'},{'\xbf','\x72'},{'\xbf','\x71'},{'\xbf','\x6e'},
+    {'\xbf','\x6f'},{'\x92','\x53'},{'\xfa','\xcb'},{'\x8a','\xe1'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xed','\xb5'},{'\x00','\x00'},{'\xed','\xb3'},{'\xc1','\x4a'},
+    {'\xed','\xb4'},{'\x00','\x00'},{'\xed','\xb6'},{'\xed','\xb2'},{'\xed','\xb1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf0','\x60'},{'\xc2','\xaa'},{'\xc2','\xa8'},
+    {'\xc2','\xa9'},{'\x82','\x67'},{'\x00','\x00'},{'\x96','\x6e'},{'\x00','\x00'},
+    {'\xf2','\xa6'},{'\xf2','\xa7'},{'\xc3','\xad'},{'\x00','\x00'},{'\xc3','\xac'},
+    {'\xf4','\xa3'},{'\xf4','\xa4'},{'\xf4','\xa2'},{'\x00','\x00'},{'\xf6','\xf8'},
+    {'\xf6','\xf9'},{'\x00','\x00'},{'\x00','\x00'},{'\xa5','\xde'},{'\xca','\x48'},
+    {'\xa8','\x73'},{'\x87','\xfb'},{'\xcd','\xa5'},{'\xaa','\xc6'},{'\xaa','\xc5'},
+    {'\xcd','\xa6'},{'\x00','\x00'},{'\xfc','\x42'},{'\xd0','\x40'},{'\xac','\xef'},
+    {'\xcf','\xfe'},{'\xac','\xf0'},{'\x00','\x00'},{'\x8c','\xfa'},{'\xaf','\xb6'},
+    {'\xd2','\xf8'},{'\xd2','\xf6'},{'\xd2','\xfc'},{'\xaf','\xb7'},{'\xd2','\xf7'},
+    {'\xd2','\xfb'},{'\xd2','\xf9'},{'\xd2','\xfa'},{'\x8a','\xe4'},{'\x00','\x00'},
+    {'\xd6','\xc8'},{'\xd6','\xca'},{'\x87','\xfa'},{'\xb2','\xbf'},{'\x93','\x58'},
+    {'\xd6','\xc9'},{'\xb2','\xc0'},{'\xb5','\xa2'},{'\xb5','\xa1'},{'\xb5','\x7e'},
+    {'\xda','\xdb'},{'\x00','\x00'},{'\x00','\x00'},{'\x8a','\xe3'},{'\x86','\xf1'},
+    {'\xdf','\x44'},{'\xb8','\x5d'},{'\xb8','\x5e'},{'\x00','\x00'},{'\xdf','\x43'},
+    {'\xdf','\x42'},{'\x00','\x00'},{'\x89','\x48'},{'\x8c','\x43'},{'\x00','\x00'},
+    {'\xe3','\x4a'},{'\xba','\xdb'},{'\xba','\xda'},{'\xe3','\x4b'},{'\xe3','\x4c'},
+    {'\x8e','\xee'},{'\xbd','\x61'},{'\xbd','\x60'},{'\xfe','\xa7'},{'\xea','\xb5'},
+    {'\xe6','\xd3'},{'\xe6','\xd5'},{'\xe6','\xd4'},{'\xea','\xb4'},{'\xea','\xb2'},
+    {'\xea','\xb6'},{'\xea','\xb3'},{'\x00','\x00'},{'\xbf','\x73'},{'\xfc','\x44'},
+    {'\x96','\x6f'},{'\x00','\x00'},{'\xed','\xb7'},{'\xc1','\x4b'},{'\xed','\xb8'},
+    {'\xed','\xb9'},{'\x96','\x70'},{'\xfa','\xcc'},{'\xc2','\xab'},{'\xc2','\xac'},
+    {'\x00','\x00'},{'\xc4','\x75'},{'\xfd','\xe5'},{'\x96','\x71'},{'\xc5','\xd1'},
+    {'\xa5','\xdf'},{'\x00','\x00'},{'\x94','\xb5'},{'\x00','\x00'},{'\x94','\xb6'},
+    {'\x00','\x00'},{'\xd0','\x41'},{'\xfa','\xcd'},{'\x94','\xb8'},{'\x00','\x00'},
+    {'\x94','\xb7'},{'\x88','\x67'},{'\x00','\x00'},{'\xd2','\xfd'},{'\xaf','\xb8'},
+    {'\xfc','\xd2'},{'\x96','\x72'},{'\x93','\xe2'},{'\xfc','\xd1'},{'\x8c','\x44'},
+    {'\xb3','\xba'},{'\xb3','\xb9'},{'\x94','\xb9'},{'\xfa','\xce'},{'\xb5','\xa4'},
+    {'\xda','\xdd'},{'\xb5','\xa3'},{'\xda','\xdc'},{'\xfa','\xcf'},{'\x00','\x00'},
+    {'\x96','\x73'},{'\x82','\x6d'},{'\xdf','\x45'},{'\x00','\x00'},{'\xba','\xdc'},
+    {'\xe3','\x4d'},{'\xba','\xdd'},{'\x94','\xba'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc4','\x76'},{'\xf4','\xa5'},
+    {'\xfa','\xd0'},{'\xa6','\xcb'},{'\xaa','\xc7'},{'\xcd','\xa7'},{'\x00','\x00'},
+    {'\xac','\xf2'},{'\x96','\x74'},{'\xac','\xf1'},{'\xd0','\x42'},{'\xd0','\x43'},
+    {'\x94','\xbb'},{'\x89','\x49'},{'\xd3','\x40'},{'\xd3','\x42'},{'\xaf','\xb9'},
+    {'\x00','\x00'},{'\xd3','\x44'},{'\xd3','\x47'},{'\xd3','\x45'},{'\x85','\x41'},
+    {'\x96','\x75'},{'\x00','\x00'},{'\xd3','\x46'},{'\xd3','\x43'},{'\xd2','\xfe'},
+    {'\xaf','\xba'},{'\xd3','\x48'},{'\xd3','\x41'},{'\x85','\x40'},{'\x85','\xec'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xd6','\xd3'},{'\xb2','\xc6'},{'\xd6','\xdc'},
+    {'\xb2','\xc3'},{'\x00','\x00'},{'\xd6','\xd5'},{'\xb2','\xc7'},{'\xfc','\xdc'},
+    {'\xb2','\xc1'},{'\x00','\x00'},{'\xd6','\xd0'},{'\xd6','\xdd'},{'\xd6','\xd1'},
+    {'\xd6','\xce'},{'\xb2','\xc5'},{'\x96','\x76'},{'\xb2','\xc2'},{'\x96','\x77'},
+    {'\xd6','\xd4'},{'\xd6','\xd7'},{'\xb2','\xc4'},{'\xd6','\xd8'},{'\xb2','\xc8'},
+    {'\xd6','\xd9'},{'\xd6','\xcf'},{'\xd6','\xd6'},{'\xd6','\xda'},{'\xd6','\xd2'},
+    {'\xd6','\xcd'},{'\xd6','\xcb'},{'\xfa','\xd1'},{'\x00','\x00'},{'\xd6','\xdb'},
+    {'\xfe','\x64'},{'\x86','\xf2'},{'\xda','\xdf'},{'\x8c','\xd7'},{'\x00','\x00'},
+    {'\x90','\x7a'},{'\x00','\x00'},{'\xda','\xe4'},{'\x00','\x00'},{'\x96','\x78'},
+    {'\x96','\x79'},{'\xda','\xe0'},{'\xda','\xe6'},{'\xb5','\xa7'},{'\xd6','\xcc'},
+    {'\xda','\xe1'},{'\xb5','\xa5'},{'\xda','\xde'},{'\xb5','\xac'},{'\xda','\xe2'},
+    {'\xb5','\xab'},{'\xda','\xe3'},{'\xb5','\xad'},{'\xb5','\xa8'},{'\xb5','\xae'},
+    {'\xb5','\xa9'},{'\x00','\x00'},{'\xb5','\xaa'},{'\x96','\x7a'},{'\xb5','\xa6'},
+    {'\x00','\x00'},{'\xda','\xe5'},{'\x00','\x00'},{'\x8f','\x5b'},{'\x89','\x4a'},
+    {'\x00','\x00'},{'\x86','\xf3'},{'\x00','\x00'},{'\x00','\x00'},{'\xb8','\x61'},
+    {'\xdf','\x50'},{'\xfa','\xd2'},{'\xdf','\x53'},{'\xdf','\x47'},{'\xdf','\x4c'},
+    {'\xdf','\x46'},{'\xb8','\x63'},{'\x00','\x00'},{'\xdf','\x4a'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xfa','\xd3'},{'\xdf','\x48'},{'\xb8','\x62'},{'\x96','\x7b'},
+    {'\xdf','\x4f'},{'\xdf','\x4e'},{'\xdf','\x4b'},{'\xdf','\x4d'},{'\xdf','\x49'},
+    {'\xba','\xe1'},{'\xdf','\x52'},{'\xb8','\x5f'},{'\xdf','\x51'},{'\x8c','\x45'},
+    {'\xfa','\xd4'},{'\xfa','\xd5'},{'\x00','\x00'},{'\x00','\x00'},{'\x8b','\xaf'},
+    {'\x00','\x00'},{'\x8a','\xe9'},{'\x00','\x00'},{'\xe3','\x5d'},{'\x00','\x00'},
+    {'\xba','\xe8'},{'\xe3','\x58'},{'\x82','\x7a'},{'\xba','\xe7'},{'\xe3','\x4e'},
+    {'\x00','\x00'},{'\xe3','\x50'},{'\xba','\xe0'},{'\xe3','\x55'},{'\xe3','\x54'},
+    {'\xe3','\x57'},{'\xba','\xe5'},{'\xe3','\x52'},{'\xe3','\x51'},{'\xfc','\xdd'},
+    {'\x00','\x00'},{'\xba','\xe4'},{'\xba','\xdf'},{'\xe3','\x53'},{'\xba','\xe2'},
+    {'\xe3','\x59'},{'\xe3','\x5b'},{'\xfa','\xd6'},{'\xe3','\x56'},{'\xe3','\x4f'},
+    {'\xba','\xe3'},{'\xfa','\xd7'},{'\xfa','\xd8'},{'\xbd','\x69'},{'\xba','\xde'},
+    {'\xfa','\xd9'},{'\xfc','\xde'},{'\xe3','\x5c'},{'\x00','\x00'},{'\x8f','\x5a'},
+    {'\xfa','\xda'},{'\x90','\x59'},{'\x8d','\x71'},{'\x8a','\xe7'},{'\x8a','\xe5'},
+    {'\xe6','\xd9'},{'\xbd','\x62'},{'\x00','\x00'},{'\xe6','\xdb'},{'\x00','\x00'},
+    {'\xbd','\x63'},{'\x96','\x7c'},{'\x00','\x00'},{'\xbd','\x65'},{'\xe6','\xde'},
+    {'\x00','\x00'},{'\xe6','\xd6'},{'\xba','\xe6'},{'\xe6','\xdc'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xe6','\xd8'},{'\x00','\x00'},
+    {'\xb8','\x60'},{'\xbd','\x68'},{'\x00','\x00'},{'\x00','\x00'},{'\xbd','\x64'},
+    {'\x00','\x00'},{'\xbd','\x66'},{'\xbd','\x67'},{'\x00','\x00'},{'\xbf','\x76'},
+    {'\xe6','\xdd'},{'\xe6','\xd7'},{'\xbd','\x6a'},{'\x00','\x00'},{'\xe6','\xda'},
+    {'\xfc','\xdf'},{'\x96','\xd0'},{'\x8a','\xe8'},{'\x00','\x00'},{'\x8a','\x40'},
+    {'\xea','\xc0'},{'\xea','\xbb'},{'\x00','\x00'},{'\x00','\x00'},{'\xea','\xc5'},
+    {'\xbf','\x74'},{'\xea','\xbd'},{'\xbf','\x78'},{'\xea','\xc3'},{'\xea','\xba'},
+    {'\xea','\xb7'},{'\xea','\xc6'},{'\xc1','\x51'},{'\xbf','\x79'},{'\xea','\xc2'},
+    {'\xea','\xb8'},{'\xbf','\x77'},{'\xea','\xbc'},{'\xbf','\x7b'},{'\xea','\xb9'},
+    {'\xea','\xbe'},{'\xbf','\x7a'},{'\xea','\xc1'},{'\xea','\xc4'},{'\x96','\xd1'},
+    {'\x82','\xa1'},{'\x8c','\x46'},{'\x00','\x00'},{'\xed','\xcb'},{'\xed','\xcc'},
+    {'\xed','\xbc'},{'\xed','\xc3'},{'\xed','\xc1'},{'\x00','\x00'},{'\xfa','\xdb'},
+    {'\xc1','\x4f'},{'\xed','\xc8'},{'\xea','\xbf'},{'\x96','\xd2'},{'\xed','\xbf'},
+    {'\xfc','\xe1'},{'\xed','\xc9'},{'\xc1','\x4e'},{'\xed','\xbe'},{'\xed','\xbd'},
+    {'\xed','\xc7'},{'\xed','\xc4'},{'\xed','\xc6'},{'\x00','\x00'},{'\xed','\xba'},
+    {'\xed','\xca'},{'\xc1','\x4c'},{'\x00','\x00'},{'\xed','\xc5'},{'\xed','\xce'},
+    {'\xed','\xc2'},{'\xc1','\x50'},{'\xc1','\x4d'},{'\xed','\xc0'},{'\xed','\xbb'},
+    {'\xed','\xcd'},{'\xbf','\x75'},{'\xfa','\xdc'},{'\x94','\xbc'},{'\xfa','\xdd'},
+    {'\x96','\xd3'},{'\x90','\x77'},{'\x94','\xbd'},{'\x00','\x00'},{'\xf0','\x63'},
+    {'\x00','\x00'},{'\x96','\xd4'},{'\xf0','\x61'},{'\xf0','\x67'},{'\xc2','\xb0'},
+    {'\xf0','\x65'},{'\xf0','\x64'},{'\xc2','\xb2'},{'\xf0','\x6a'},{'\xc2','\xb1'},
+    {'\x00','\x00'},{'\xf0','\x6b'},{'\xf0','\x68'},{'\xc2','\xae'},{'\xf0','\x69'},
+    {'\xf0','\x62'},{'\xc2','\xaf'},{'\xc2','\xad'},{'\xf2','\xab'},{'\xf0','\x66'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf0','\x6c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf2','\xa8'},{'\x00','\x00'},{'\x96','\xd5'},{'\x00','\x00'},{'\xc3','\xb2'},
+    {'\xc3','\xb0'},{'\xf2','\xaa'},{'\x00','\x00'},{'\xf2','\xac'},{'\xf2','\xa9'},
+    {'\xc3','\xb1'},{'\xc3','\xae'},{'\xc3','\xaf'},{'\xc3','\xb3'},{'\x8c','\xd8'},
+    {'\xfc','\xe2'},{'\xc4','\x78'},{'\x96','\xd6'},{'\xf4','\xaa'},{'\x00','\x00'},
+    {'\xf4','\xa9'},{'\xf4','\xa7'},{'\xf4','\xa6'},{'\xf4','\xa8'},{'\x00','\x00'},
+    {'\xc4','\x77'},{'\xc4','\x79'},{'\x00','\x00'},{'\xfa','\xde'},{'\xc4','\xf0'},
+    {'\xfc','\xe3'},{'\x00','\x00'},{'\xf5','\xe5'},{'\xf5','\xe4'},{'\x00','\x00'},
+    {'\xfa','\xdf'},{'\xf6','\xfa'},{'\xfa','\xe0'},{'\xf6','\xfc'},{'\xf6','\xfe'},
+    {'\xf6','\xfd'},{'\xf6','\xfb'},{'\xfc','\xe4'},{'\x00','\x00'},{'\xc5','\xa3'},
+    {'\xc5','\xa2'},{'\x00','\x00'},{'\x00','\x00'},{'\xc5','\xd3'},{'\xc5','\xd2'},
+    {'\xc5','\xd4'},{'\xf7','\xed'},{'\xf7','\xec'},{'\x00','\x00'},{'\xf8','\xfb'},
+    {'\xf8','\xb8'},{'\xf8','\xfc'},{'\xc6','\x58'},{'\x96','\xd7'},{'\xc6','\x59'},
+    {'\xf9','\x6d'},{'\xfc','\xe5'},{'\x00','\x00'},{'\xc6','\x7e'},{'\xa6','\xcc'},
+    {'\x90','\x5a'},{'\xcd','\xa8'},{'\x00','\x00'},{'\x00','\x00'},{'\xd0','\x45'},
+    {'\xd0','\x46'},{'\xd0','\x44'},{'\x8b','\xdd'},{'\x83','\x5e'},{'\xac','\xf3'},
+    {'\xfc','\xe6'},{'\xd0','\x47'},{'\xd0','\x48'},{'\xd0','\x49'},{'\x94','\x43'},
+    {'\xfc','\xe8'},{'\xd3','\x49'},{'\xd3','\x4f'},{'\xfc','\xe7'},{'\x00','\x00'},
+    {'\xd3','\x4d'},{'\xaf','\xbb'},{'\xd3','\x4b'},{'\x92','\xf7'},{'\xd3','\x4c'},
+    {'\xd3','\x4e'},{'\x96','\xd8'},{'\x00','\x00'},{'\x94','\xbe'},{'\xd3','\x4a'},
+    {'\xb2','\xc9'},{'\x00','\x00'},{'\xd6','\xde'},{'\xb2','\xcb'},{'\xd6','\xe0'},
+    {'\xb2','\xca'},{'\xd6','\xdf'},{'\x00','\x00'},{'\x00','\x00'},{'\x92','\xe0'},
+    {'\x90','\x7b'},{'\x90','\x43'},{'\xda','\xe8'},{'\xb5','\xaf'},{'\x00','\x00'},
+    {'\xda','\xea'},{'\xda','\xe7'},{'\xd6','\xe1'},{'\x85','\xed'},{'\xb5','\xb0'},
+    {'\xfe','\x63'},{'\xf9','\xdb'},{'\xda','\xe9'},{'\x00','\x00'},{'\x8a','\x41'},
+    {'\xfa','\xe1'},{'\xfc','\xe9'},{'\x94','\xbf'},{'\x8a','\xea'},{'\xdf','\x56'},
+    {'\x00','\x00'},{'\xb8','\x64'},{'\xdf','\x54'},{'\xb8','\x65'},{'\xdf','\x55'},
+    {'\xb8','\x66'},{'\x00','\x00'},{'\x00','\x00'},{'\x96','\xd9'},{'\xba','\xe9'},
+    {'\xe3','\x61'},{'\xe3','\x5e'},{'\xe3','\x60'},{'\xba','\xea'},{'\xba','\xeb'},
+    {'\xe3','\x5f'},{'\x94','\xc0'},{'\x8a','\x43'},{'\xfc','\xeb'},{'\x96','\xda'},
+    {'\x00','\x00'},{'\xe6','\xdf'},{'\x00','\x00'},{'\xfc','\xea'},{'\xe6','\xe0'},
+    {'\x95','\xb2'},{'\xbd','\x6b'},{'\xe6','\xe2'},{'\xe6','\xe1'},{'\xa0','\x54'},
+    {'\xa2','\x61'},{'\x00','\x00'},{'\xea','\xca'},{'\xea','\xcb'},{'\xea','\xc7'},
+    {'\xfb','\x7e'},{'\xea','\xc8'},{'\xbf','\x7c'},{'\xbf','\x7d'},{'\xea','\xc9'},
+    {'\x94','\xc1'},{'\xc1','\x57'},{'\xfc','\xed'},{'\x00','\x00'},{'\xc1','\x53'},
+    {'\xc1','\x58'},{'\xc1','\x54'},{'\xc1','\x56'},{'\xc1','\x52'},{'\x00','\x00'},
+    {'\xc1','\x55'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x96','\xdb'},
+    {'\xc2','\xb3'},{'\xed','\xcf'},{'\x00','\x00'},{'\xf2','\xae'},{'\x00','\x00'},
+    {'\xf2','\xad'},{'\x96','\xdc'},{'\xf4','\xab'},{'\xc4','\x7a'},{'\xc4','\x7b'},
+    {'\xf7','\x41'},{'\xf5','\xe6'},{'\x96','\xdd'},{'\xf7','\x40'},{'\x96','\xde'},
+    {'\xf8','\xfd'},{'\xf9','\xa4'},{'\xa6','\xcd'},{'\x96','\xdf'},{'\xfa','\xe2'},
+    {'\xa8','\x74'},{'\x96','\xe1'},{'\xcd','\xa9'},{'\xaa','\xc8'},{'\x00','\x00'},
+    {'\xac','\xf6'},{'\xd0','\x4c'},{'\xac','\xf4'},{'\xd0','\x4a'},{'\xac','\xf9'},
+    {'\xac','\xf5'},{'\xac','\xfa'},{'\xac','\xf8'},{'\xd0','\x4b'},{'\xac','\xf7'},
+    {'\xaf','\xbf'},{'\xaf','\xbe'},{'\xd3','\x5a'},{'\xaf','\xc7'},{'\xd3','\x53'},
+    {'\xd3','\x59'},{'\xaf','\xc3'},{'\xd3','\x52'},{'\xd3','\x58'},{'\xd3','\x56'},
+    {'\xaf','\xc2'},{'\xaf','\xc4'},{'\xd3','\x55'},{'\xaf','\xbd'},{'\xd3','\x54'},
+    {'\xaf','\xc8'},{'\xaf','\xc5'},{'\xaf','\xc9'},{'\xaf','\xc6'},{'\xd3','\x51'},
+    {'\xd3','\x50'},{'\xd3','\x57'},{'\xaf','\xc0'},{'\xaf','\xbc'},{'\xaf','\xc1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x95','\xe2'},{'\x00','\x00'},{'\x86','\xfa'},
+    {'\xd6','\xf0'},{'\xd6','\xe9'},{'\x00','\x00'},{'\xb5','\xb5'},{'\xd6','\xe8'},
+    {'\x00','\x00'},{'\xb2','\xcf'},{'\xb2','\xd6'},{'\xb2','\xd3'},{'\xb2','\xd9'},
+    {'\xb2','\xd8'},{'\xb2','\xd4'},{'\x00','\x00'},{'\xd6','\xe2'},{'\xd6','\xe5'},
+    {'\x00','\x00'},{'\xd6','\xe4'},{'\xb2','\xd0'},{'\xd6','\xe6'},{'\xd6','\xef'},
+    {'\xb2','\xd1'},{'\xd6','\xe3'},{'\xd6','\xec'},{'\xd6','\xed'},{'\xb2','\xd2'},
+    {'\xd6','\xea'},{'\xb2','\xd7'},{'\xb2','\xcd'},{'\xb2','\xd5'},{'\xd6','\xe7'},
+    {'\xb2','\xcc'},{'\xd6','\xeb'},{'\xfa','\xe3'},{'\x00','\x00'},{'\xd6','\xee'},
+    {'\xfa','\xe4'},{'\x92','\xab'},{'\xfc','\xef'},{'\xda','\xfb'},{'\xda','\xf2'},
+    {'\xb5','\xb2'},{'\xda','\xf9'},{'\xda','\xf6'},{'\xda','\xee'},{'\xda','\xf7'},
+    {'\xb5','\xb4'},{'\xda','\xef'},{'\x00','\x00'},{'\xda','\xeb'},{'\x00','\x00'},
+    {'\xfc','\xf0'},{'\xb8','\x6c'},{'\xda','\xf4'},{'\xfe','\x60'},{'\xb5','\xb1'},
+    {'\xda','\xfa'},{'\x00','\x00'},{'\xb5','\xb8'},{'\xb5','\xba'},{'\xda','\xed'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb5','\xb9'},{'\xda','\xf0'},{'\xb5','\xb3'},
+    {'\xda','\xf8'},{'\xda','\xf1'},{'\xda','\xf5'},{'\x00','\x00'},{'\xda','\xf3'},
+    {'\xb5','\xb6'},{'\xda','\xec'},{'\xb5','\xbb'},{'\xb2','\xce'},{'\xb5','\xb7'},
+    {'\xb5','\xbc'},{'\x00','\x00'},{'\x92','\x5b'},{'\x93','\x46'},{'\xfa','\xe5'},
+    {'\x00','\x00'},{'\xb8','\x68'},{'\xdf','\x5d'},{'\xdf','\x5f'},{'\xdf','\x61'},
+    {'\xdf','\x65'},{'\x00','\x00'},{'\xdf','\x5b'},{'\xdf','\x59'},{'\xb8','\x6a'},
+    {'\x00','\x00'},{'\xdf','\x60'},{'\xdf','\x64'},{'\xdf','\x5c'},{'\xdf','\x58'},
+    {'\x00','\x00'},{'\xdf','\x57'},{'\x95','\x68'},{'\x00','\x00'},{'\x96','\xe2'},
+    {'\xdf','\x62'},{'\xdf','\x5a'},{'\xdf','\x5e'},{'\xb8','\x6b'},{'\x00','\x00'},
+    {'\xb8','\x69'},{'\xdf','\x66'},{'\xb8','\x67'},{'\xdf','\x63'},{'\x9d','\xb9'},
+    {'\xe3','\x72'},{'\x96','\xe3'},{'\x00','\x00'},{'\x92','\xae'},{'\x93','\x64'},
+    {'\x94','\xc2'},{'\xba','\xee'},{'\xe3','\x6a'},{'\xbd','\x78'},{'\xe3','\x74'},
+    {'\xba','\xf1'},{'\xe3','\x78'},{'\xba','\xf7'},{'\xe3','\x65'},{'\x96','\xe4'},
+    {'\x00','\x00'},{'\xe3','\x75'},{'\xe3','\x62'},{'\x96','\xe5'},{'\xe3','\x77'},
+    {'\xe3','\x66'},{'\x95','\x56'},{'\xba','\xfe'},{'\xba','\xfb'},{'\xe3','\x76'},
+    {'\xe3','\x70'},{'\xba','\xed'},{'\xba','\xf5'},{'\xba','\xf4'},{'\x95','\x6a'},
+    {'\xba','\xf3'},{'\xba','\xf9'},{'\x00','\x00'},{'\xe3','\x63'},{'\xba','\xfa'},
+    {'\xe3','\x71'},{'\xba','\xf6'},{'\xba','\xec'},{'\xe3','\x73'},{'\xba','\xef'},
+    {'\xba','\xf0'},{'\xba','\xf8'},{'\xe3','\x68'},{'\xe3','\x67'},{'\xe3','\x64'},
+    {'\x00','\x00'},{'\xe3','\x6c'},{'\xe3','\x69'},{'\xe3','\x6d'},{'\xba','\xfd'},
+    {'\x00','\x00'},{'\xe3','\x79'},{'\xba','\xf2'},{'\xe3','\x6e'},{'\xe3','\x6f'},
+    {'\x96','\xe6'},{'\xe3','\x6b'},{'\x93','\x5c'},{'\x96','\xe7'},{'\x93','\xe7'},
+    {'\xba','\xfc'},{'\x96','\xe8'},{'\xfa','\xe6'},{'\xfa','\xe7'},{'\xfa','\xe8'},
+    {'\xe6','\xe7'},{'\xbd','\x70'},{'\xbd','\x79'},{'\xbd','\x75'},{'\xe6','\xe4'},
+    {'\x95','\xc3'},{'\xbd','\x72'},{'\xbd','\x76'},{'\xe6','\xf0'},{'\xbd','\x6c'},
+    {'\xe6','\xe8'},{'\x00','\x00'},{'\xbd','\x74'},{'\xfa','\xe9'},{'\x96','\xe9'},
+    {'\xe6','\xeb'},{'\xe6','\xe6'},{'\xbd','\x73'},{'\xbd','\x77'},{'\xe6','\xe5'},
+    {'\x00','\x00'},{'\xbd','\x71'},{'\x00','\x00'},{'\xe6','\xef'},{'\xbd','\x6e'},
+    {'\xe6','\xee'},{'\xe6','\xed'},{'\xbd','\x7a'},{'\xe5','\x72'},{'\xbd','\x6d'},
+    {'\xfc','\xf1'},{'\xe6','\xec'},{'\xe6','\xe3'},{'\x00','\x00'},{'\xbd','\x7b'},
+    {'\xe6','\xea'},{'\xbd','\x6f'},{'\x00','\x00'},{'\x96','\xea'},{'\x9f','\x7e'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x92','\x4d'},{'\x00','\x00'},{'\xe6','\xe9'},
+    {'\x92','\xed'},{'\x94','\xc3'},{'\x00','\x00'},{'\x9f','\xa1'},{'\xbf','\xa2'},
+    {'\xbf','\xa7'},{'\xbf','\x7e'},{'\xea','\xd8'},{'\xea','\xcf'},{'\xea','\xdb'},
+    {'\xea','\xd3'},{'\xea','\xd9'},{'\xbf','\xa8'},{'\xbf','\xa1'},{'\xea','\xcc'},
+    {'\xea','\xd2'},{'\xea','\xdc'},{'\xea','\xd5'},{'\xea','\xda'},{'\xea','\xce'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xea','\xd6'},{'\xbf','\xa3'},{'\xea','\xd4'},
+    {'\xbf','\xa6'},{'\xbf','\xa5'},{'\xea','\xd0'},{'\xea','\xd1'},{'\xea','\xcd'},
+    {'\xea','\xd7'},{'\xbf','\xa4'},{'\xea','\xde'},{'\xea','\xdd'},{'\x92','\xdf'},
+    {'\xfc','\xf2'},{'\x00','\x00'},{'\xed','\xda'},{'\xed','\xd6'},{'\xc1','\x5f'},
+    {'\x00','\x00'},{'\xed','\xd0'},{'\xc1','\x59'},{'\xc1','\x69'},{'\xed','\xdc'},
+    {'\xc1','\x61'},{'\xc1','\x5d'},{'\xed','\xd3'},{'\xc1','\x64'},{'\xc1','\x67'},
+    {'\xed','\xde'},{'\xc1','\x5c'},{'\xed','\xd5'},{'\xc1','\x65'},{'\xed','\xe0'},
+    {'\xed','\xdd'},{'\xed','\xd1'},{'\xc1','\x60'},{'\xc1','\x5a'},{'\xc1','\x68'},
+    {'\xed','\xd8'},{'\xc1','\x63'},{'\xed','\xd2'},{'\xc1','\x5e'},{'\xed','\xdf'},
+    {'\xc1','\x62'},{'\xc1','\x5b'},{'\xed','\xd9'},{'\xc1','\x66'},{'\xed','\xd7'},
+    {'\x93','\x4f'},{'\x82','\x5a'},{'\xed','\xdb'},{'\xfa','\xea'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xf0','\x6e'},{'\xf0','\x74'},{'\xc2','\xb9'},{'\xf0','\x77'},
+    {'\xc2','\xb4'},{'\xc2','\xb5'},{'\xf0','\x6f'},{'\xf0','\x76'},{'\xf0','\x71'},
+    {'\xc2','\xba'},{'\xc2','\xb7'},{'\x9f','\xa2'},{'\xf0','\x6d'},{'\xfa','\xeb'},
+    {'\xc2','\xb6'},{'\xf0','\x73'},{'\xf0','\x75'},{'\xc2','\xb8'},{'\xf0','\x72'},
+    {'\xf0','\x70'},{'\x00','\x00'},{'\x9f','\xa3'},{'\x8a','\x50'},{'\x94','\xc4'},
+    {'\xf2','\xb8'},{'\xc3','\xb7'},{'\xc3','\xb8'},{'\xc3','\xb4'},{'\x9f','\xa4'},
+    {'\xc3','\xb5'},{'\x8c','\xe8'},{'\xf2','\xb4'},{'\xf2','\xb2'},{'\x00','\x00'},
+    {'\xf2','\xb6'},{'\xc3','\xba'},{'\xf2','\xb7'},{'\xf2','\xb0'},{'\xf2','\xaf'},
+    {'\xf2','\xb3'},{'\xf2','\xb1'},{'\xc3','\xb6'},{'\xf2','\xb5'},{'\xf4','\xac'},
+    {'\xc4','\x7e'},{'\xc4','\x7d'},{'\xf4','\xad'},{'\xfa','\xec'},{'\xf4','\xaf'},
+    {'\xf4','\xae'},{'\xc4','\xa1'},{'\x94','\xc5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf5','\xeb'},{'\xf5','\xe8'},{'\xf5','\xe9'},{'\xfa','\xed'},{'\xf5','\xe7'},
+    {'\xf5','\xea'},{'\xc4','\xf2'},{'\xf5','\xec'},{'\xfa','\xee'},{'\xc4','\xf1'},
+    {'\x94','\xc6'},{'\xf7','\x42'},{'\xfa','\xef'},{'\xc5','\xd5'},{'\xc5','\xd7'},
+    {'\xf7','\xee'},{'\xc5','\xd6'},{'\xf8','\xb9'},{'\xf9','\x40'},{'\xf9','\x42'},
+    {'\xf8','\xfe'},{'\xf9','\x41'},{'\xc6','\x6c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9c','\xeb'},{'\x83','\x5f'},{'\x83','\x76'},{'\x83','\x71'},{'\x83','\x70'},
+    {'\x8a','\x4e'},{'\x83','\x74'},{'\x83','\x75'},{'\x83','\xcb'},{'\x8d','\xbe'},
+    {'\x90','\x44'},{'\x83','\x72'},{'\x83','\x73'},{'\x87','\xfe'},{'\x83','\xcc'},
+    {'\x00','\x00'},{'\x83','\xc8'},{'\x83','\xca'},{'\x83','\xc6'},{'\x86','\xfc'},
+    {'\x83','\xcd'},{'\x00','\x00'},{'\x8a','\x4c'},{'\x87','\x41'},{'\x83','\xcf'},
+    {'\x83','\xce'},{'\x83','\xc7'},{'\x83','\xc5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x83','\xc9'},{'\x8d','\xc5'},{'\x88','\x45'},{'\x8d','\xd3'},{'\x84','\x71'},
+    {'\x84','\x72'},{'\x87','\xfd'},{'\x84','\x6f'},{'\x84','\x6e'},{'\x84','\x6d'},
+    {'\x8a','\xeb'},{'\x84','\x70'},{'\x89','\x53'},{'\x84','\x68'},{'\x84','\x6b'},
+    {'\x84','\x6c'},{'\x84','\x6a'},{'\x8b','\xb1'},{'\x85','\xee'},{'\x8d','\xd4'},
+    {'\x85','\xf0'},{'\x85','\x44'},{'\x85','\x43'},{'\xfa','\xf0'},{'\x8a','\xed'},
+    {'\x85','\x4a'},{'\x8d','\xe4'},{'\x8b','\xb3'},{'\x85','\x48'},{'\x85','\x49'},
+    {'\x85','\x4b'},{'\x85','\x47'},{'\x85','\x45'},{'\x85','\x42'},{'\x84','\x69'},
+    {'\x8e','\x4a'},{'\x8e','\x4b'},{'\x85','\xef'},{'\x8a','\xef'},{'\x00','\x00'},
+    {'\x85','\xf1'},{'\x85','\xf2'},{'\x8c','\x49'},{'\x8e','\x49'},{'\x8a','\x45'},
+    {'\x87','\x43'},{'\x86','\xf8'},{'\x00','\x00'},{'\x8c','\xa2'},{'\x86','\xfd'},
+    {'\x8e','\x7b'},{'\x86','\xf7'},{'\xfa','\xf1'},{'\x8e','\x7a'},{'\x8b','\xb2'},
+    {'\x87','\x42'},{'\x87','\x40'},{'\x87','\x45'},{'\x8a','\x49'},{'\x86','\xfe'},
+    {'\x00','\x00'},{'\x8e','\x7c'},{'\x8e','\x79'},{'\x86','\xf6'},{'\x86','\xf4'},
+    {'\x86','\xf5'},{'\x86','\xf9'},{'\x86','\xfb'},{'\x87','\x44'},{'\x88','\x49'},
+    {'\x8e','\xc2'},{'\x88','\x40'},{'\x88','\x41'},{'\x8d','\xa3'},{'\x88','\x4b'},
+    {'\x88','\x4a'},{'\x88','\x42'},{'\x00','\x00'},{'\x8f','\x79'},{'\x8e','\xc4'},
+    {'\x88','\x48'},{'\x88','\x46'},{'\x8e','\xc5'},{'\x00','\x00'},{'\x8e','\xc6'},
+    {'\xfa','\xf2'},{'\x88','\x47'},{'\x87','\xfc'},{'\x8a','\x47'},{'\x88','\x43'},
+    {'\x8e','\xc3'},{'\x88','\x44'},{'\x89','\x52'},{'\x89','\x4e'},{'\x8e','\xf0'},
+    {'\x89','\x51'},{'\x8a','\x4a'},{'\x00','\x00'},{'\x89','\x50'},{'\x8c','\xa1'},
+    {'\x8f','\x5d'},{'\x89','\x4b'},{'\x89','\x4c'},{'\x8c','\x48'},{'\x8a','\x4f'},
+    {'\x8a','\x51'},{'\x8a','\x48'},{'\x8c','\xfb'},{'\x8a','\x44'},{'\x8a','\x46'},
+    {'\x8a','\x4d'},{'\x90','\x45'},{'\x8a','\xee'},{'\x8a','\xec'},{'\x8a','\xf0'},
+    {'\xfa','\xf3'},{'\x8f','\xde'},{'\x8f','\xbf'},{'\x8f','\xc0'},{'\x8b','\xb5'},
+    {'\x90','\x7c'},{'\xa6','\xce'},{'\x9f','\xa5'},{'\xac','\xfb'},{'\xd2','\x6f'},
+    {'\xaf','\xca'},{'\x00','\x00'},{'\x00','\x00'},{'\xb2','\xda'},{'\xda','\xfc'},
+    {'\xda','\xfd'},{'\x9f','\xa6'},{'\x9f','\xa7'},{'\x8c','\x4a'},{'\xea','\xdf'},
+    {'\xc1','\x6a'},{'\xed','\xe1'},{'\x00','\x00'},{'\x95','\x74'},{'\xc2','\xbb'},
+    {'\x9f','\xa8'},{'\xf2','\xba'},{'\xf2','\xb9'},{'\xc4','\xa2'},{'\xf5','\xed'},
+    {'\xfb','\xaa'},{'\xf7','\x43'},{'\xc5','\xf8'},{'\xca','\x49'},{'\x9f','\xa9'},
+    {'\x9d','\x75'},{'\xaa','\xc9'},{'\xa8','\x75'},{'\x00','\x00'},{'\x8b','\xb4'},
+    {'\xd0','\x4d'},{'\x00','\x00'},{'\x87','\x46'},{'\xd3','\x60'},{'\xd3','\x5b'},
+    {'\xd3','\x5f'},{'\xd3','\x5d'},{'\xaf','\xcb'},{'\xd3','\x5e'},{'\xd3','\x5c'},
+    {'\x88','\x4d'},{'\xd6','\xf1'},{'\x00','\x00'},{'\xda','\xfe'},{'\xdb','\x40'},
+    {'\xdf','\x69'},{'\xdf','\x6a'},{'\xb8','\x6e'},{'\xb8','\x6f'},{'\xdf','\x68'},
+    {'\xdf','\x6b'},{'\xdf','\x67'},{'\xb8','\x6d'},{'\x00','\x00'},{'\xbb','\x40'},
+    {'\xfa','\xf4'},{'\xb8','\x70'},{'\xe3','\x7a'},{'\x8f','\xc1'},{'\xbd','\x7c'},
+    {'\xe6','\xf1'},{'\xbd','\x7d'},{'\x95','\x64'},{'\xbf','\xa9'},{'\xea','\xe2'},
+    {'\xea','\xe0'},{'\xea','\xe1'},{'\xed','\xe4'},{'\xed','\xe3'},{'\xed','\xe2'},
+    {'\x00','\x00'},{'\x8d','\x56'},{'\xfa','\xf5'},{'\xf2','\xbb'},{'\x00','\x00'},
+    {'\xc3','\xb9'},{'\xf2','\xbc'},{'\xf7','\x44'},{'\xc5','\xf9'},{'\xf8','\xba'},
+    {'\xa6','\xcf'},{'\xaa','\xcb'},{'\xaa','\xca'},{'\xd0','\x4f'},{'\xac','\xfc'},
+    {'\x9f','\xaa'},{'\x00','\x00'},{'\xd0','\x4e'},{'\xd3','\x62'},{'\x9f','\xab'},
+    {'\xaf','\xcc'},{'\xd6','\xf2'},{'\xd3','\x61'},{'\x95','\xe0'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xb2','\xdc'},{'\xd6','\xf5'},{'\xd6','\xf3'},{'\xd6','\xf4'},
+    {'\xb2','\xdb'},{'\x8e','\x4c'},{'\xdb','\x42'},{'\xdb','\x43'},{'\xdb','\x41'},
+    {'\x95','\x55'},{'\xb8','\x73'},{'\xdf','\x6d'},{'\xdf','\x6c'},{'\xdf','\x6e'},
+    {'\xb8','\x72'},{'\xb8','\x71'},{'\x00','\x00'},{'\x00','\x00'},{'\xe6','\xf2'},
+    {'\xe6','\xf4'},{'\xfa','\xf6'},{'\xbd','\x7e'},{'\xe6','\xf3'},{'\xea','\xe3'},
+    {'\xbf','\xaa'},{'\xf0','\x79'},{'\x9f','\xac'},{'\xf0','\x78'},{'\xc3','\xbb'},
+    {'\xf2','\xbd'},{'\xc3','\xbd'},{'\xc3','\xbc'},{'\xf4','\xb0'},{'\xf5','\xee'},
+    {'\xc4','\xf3'},{'\xa6','\xd0'},{'\xd0','\x50'},{'\xac','\xfd'},{'\xd3','\x65'},
+    {'\xaf','\xce'},{'\xd3','\x64'},{'\xd3','\x63'},{'\x00','\x00'},{'\xaf','\xcd'},
+    {'\xfa','\xf7'},{'\xd6','\xfb'},{'\x00','\x00'},{'\xd6','\xfd'},{'\xd6','\xf6'},
+    {'\xd6','\xf7'},{'\xb2','\xdd'},{'\xd6','\xf8'},{'\xb2','\xde'},{'\xd6','\xfc'},
+    {'\xd6','\xf9'},{'\xd6','\xfa'},{'\xb2','\xdf'},{'\x00','\x00'},{'\xb5','\xbe'},
+    {'\xb5','\xbf'},{'\x00','\x00'},{'\xdb','\x44'},{'\x8a','\xf1'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xdf','\x6f'},{'\xdf','\x70'},{'\x9f','\xad'},{'\xe3','\x7e'},
+    {'\xbb','\x43'},{'\xbb','\x41'},{'\xbb','\x42'},{'\xe3','\x7b'},{'\xe3','\x7c'},
+    {'\x00','\x00'},{'\xe3','\x7d'},{'\xe6','\xf9'},{'\x9f','\xae'},{'\xe6','\xfa'},
+    {'\xbd','\xa1'},{'\xe6','\xf7'},{'\xe6','\xf6'},{'\xe6','\xf8'},{'\xe6','\xf5'},
+    {'\xbf','\xad'},{'\xea','\xe4'},{'\xbf','\xab'},{'\xbf','\xac'},{'\xed','\xe6'},
+    {'\xc1','\x6b'},{'\xed','\xe5'},{'\xef','\xa8'},{'\x00','\x00'},{'\xf0','\x7a'},
+    {'\xf0','\x7b'},{'\xc2','\xbc'},{'\x9f','\xaf'},{'\xc2','\xbd'},{'\xc1','\x6c'},
+    {'\xf2','\xbe'},{'\xf2','\xbf'},{'\xf4','\xb1'},{'\xc4','\xa3'},{'\xa6','\xd1'},
+    {'\x9f','\xb0'},{'\xa6','\xd2'},{'\xac','\xfe'},{'\xaa','\xcc'},{'\xaf','\xcf'},
+    {'\xd0','\x51'},{'\x9f','\xb1'},{'\x00','\x00'},{'\x00','\x00'},{'\xb5','\xc0'},
+    {'\xa6','\xd3'},{'\xad','\x41'},{'\xd0','\x52'},{'\xd0','\x53'},{'\xad','\x40'},
+    {'\xad','\x42'},{'\xa6','\xd4'},{'\x00','\x00'},{'\xd0','\x54'},{'\xaf','\xd1'},
+    {'\xd3','\x66'},{'\xaf','\xd3'},{'\xaf','\xd0'},{'\xaf','\xd2'},{'\x00','\x00'},
+    {'\xd7','\x41'},{'\xb2','\xe0'},{'\xfc','\xf6'},{'\xd7','\x40'},{'\xd6','\xfe'},
+    {'\xfa','\xf8'},{'\xdf','\x71'},{'\xfa','\xf9'},{'\x00','\x00'},{'\xe3','\xa1'},
+    {'\xfa','\xfa'},{'\xbd','\xa2'},{'\x8f','\x5e'},{'\xbf','\xae'},{'\xea','\xe6'},
+    {'\xea','\xe5'},{'\x00','\x00'},{'\xed','\xe7'},{'\x00','\x00'},{'\x9f','\xb2'},
+    {'\x9f','\xb3'},{'\xf5','\xef'},{'\xfa','\xfb'},{'\x00','\x00'},{'\xa6','\xd5'},
+    {'\xcb','\x73'},{'\xcd','\xaa'},{'\xad','\x43'},{'\xd0','\x55'},{'\x8a','\x55'},
+    {'\xd3','\x68'},{'\x00','\x00'},{'\x95','\x5c'},{'\x9f','\xb4'},{'\xaf','\xd4'},
+    {'\xd3','\x67'},{'\xaf','\xd5'},{'\x00','\x00'},{'\x00','\x00'},{'\x8a','\xf3'},
+    {'\xd7','\x43'},{'\x00','\x00'},{'\x00','\x00'},{'\xb2','\xe2'},{'\xd7','\x42'},
+    {'\xd7','\x44'},{'\x00','\x00'},{'\xb2','\xe1'},{'\x8c','\xd9'},{'\x8a','\xf2'},
+    {'\x8f','\xdf'},{'\x00','\x00'},{'\xdb','\x46'},{'\xdb','\x47'},{'\xdb','\x45'},
+    {'\xb5','\xc1'},{'\x00','\x00'},{'\x8a','\x54'},{'\x00','\x00'},{'\xb8','\x74'},
+    {'\x00','\x00'},{'\xb8','\x75'},{'\x00','\x00'},{'\xbb','\x45'},{'\xfc','\xfa'},
+    {'\xe3','\xa3'},{'\xe3','\xa2'},{'\xbb','\x44'},{'\xfa','\xfc'},{'\x00','\x00'},
+    {'\x82','\x6b'},{'\xfc','\xf7'},{'\xfc','\xf8'},{'\xe6','\xfb'},{'\x00','\x00'},
+    {'\xfc','\xf9'},{'\xe6','\xfc'},{'\xfa','\xfd'},{'\x8f','\x7a'},{'\x8a','\x53'},
+    {'\x00','\x00'},{'\xea','\xe7'},{'\x00','\x00'},{'\x00','\x00'},{'\xc1','\x70'},
+    {'\xc1','\x6f'},{'\xc1','\x6d'},{'\xc1','\x6e'},{'\xc1','\x71'},{'\x93','\x77'},
+    {'\xf0','\x7c'},{'\xc2','\xbf'},{'\xc2','\xbe'},{'\xf2','\xc0'},{'\xf4','\xb2'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc5','\xa5'},{'\xc5','\xa4'},
+    {'\xa6','\xd6'},{'\x91','\xd5'},{'\x00','\x00'},{'\xd1','\xfb'},{'\x85','\x4c'},
+    {'\xb8','\x77'},{'\xb5','\xc2'},{'\xb8','\x76'},{'\xbb','\x46'},{'\x00','\x00'},
+    {'\xa6','\xd7'},{'\xc9','\xa9'},{'\xa6','\xd8'},{'\xa6','\xd9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xcd','\xab'},{'\xcb','\x76'},{'\x00','\x00'},{'\xcb','\x77'},
+    {'\xa8','\x77'},{'\x00','\x00'},{'\xcb','\x74'},{'\xa8','\x76'},{'\x00','\x00'},
+    {'\xa8','\x79'},{'\xcb','\x75'},{'\xa8','\x7b'},{'\xa8','\x7a'},{'\xcb','\x78'},
+    {'\xa8','\x78'},{'\x00','\x00'},{'\x96','\xaf'},{'\x85','\xf6'},{'\xaa','\xd1'},
+    {'\xaa','\xcf'},{'\xcd','\xad'},{'\x88','\x4f'},{'\xaa','\xce'},{'\xfc','\xfb'},
+    {'\x9f','\xb5'},{'\x00','\x00'},{'\xaa','\xd3'},{'\xaa','\xd5'},{'\xaa','\xd2'},
+    {'\xfa','\xfe'},{'\xcd','\xb0'},{'\xcd','\xac'},{'\xaa','\xd6'},{'\x00','\x00'},
+    {'\xaa','\xd0'},{'\xa8','\x7c'},{'\x00','\x00'},{'\xaa','\xd4'},{'\xcd','\xaf'},
+    {'\xfb','\x4d'},{'\xfb','\x40'},{'\xcd','\xae'},{'\x00','\x00'},{'\xaa','\xcd'},
+    {'\x00','\x00'},{'\x96','\xcb'},{'\x96','\xa6'},{'\x85','\x4d'},{'\x85','\xf8'},
+    {'\x85','\x4e'},{'\x83','\xd0'},{'\xd0','\x5b'},{'\xad','\x47'},{'\xad','\x48'},
+    {'\xd0','\x5d'},{'\x8a','\x57'},{'\xd0','\x57'},{'\xd0','\x5a'},{'\xd0','\x63'},
+    {'\xd0','\x61'},{'\x00','\x00'},{'\xad','\x49'},{'\xd0','\x67'},{'\xad','\x4c'},
+    {'\xd0','\x64'},{'\xd0','\x5c'},{'\xd0','\x59'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xdb','\x49'},{'\xd0','\x62'},{'\xad','\x44'},{'\xd0','\x65'},{'\xd0','\x56'},
+    {'\xd0','\x5f'},{'\xad','\x46'},{'\xad','\x4b'},{'\xd0','\x60'},{'\xad','\x4f'},
+    {'\xad','\x4d'},{'\x00','\x00'},{'\xd0','\x58'},{'\xad','\x4a'},{'\x00','\x00'},
+    {'\xd0','\x5e'},{'\xad','\x4e'},{'\xad','\x45'},{'\xd0','\x66'},{'\x8b','\xf8'},
+    {'\xfd','\xfb'},{'\xfd','\xfc'},{'\x8c','\x4b'},{'\x8d','\xd5'},{'\xfd','\xfd'},
+    {'\xaf','\xda'},{'\x00','\x00'},{'\xaf','\xe3'},{'\xaf','\xd8'},{'\xaf','\xd6'},
+    {'\xd3','\x6a'},{'\xaf','\xde'},{'\xaf','\xdb'},{'\xd3','\x6c'},{'\x88','\x4e'},
+    {'\x00','\x00'},{'\xaf','\xdd'},{'\xd3','\x6b'},{'\xd3','\x69'},{'\xd3','\x6e'},
+    {'\xaf','\xe2'},{'\xaf','\xe0'},{'\xdb','\x48'},{'\x00','\x00'},{'\xd3','\x6f'},
+    {'\xd3','\x6d'},{'\xaf','\xd7'},{'\xfc','\xfc'},{'\x00','\x00'},{'\xaf','\xd9'},
+    {'\xaf','\xdc'},{'\xfe','\x48'},{'\xaf','\xdf'},{'\x83','\xd1'},{'\xaf','\xe1'},
+    {'\x00','\x00'},{'\x9f','\xb6'},{'\x8a','\x59'},{'\xfd','\xfe'},{'\x8c','\xda'},
+    {'\x8a','\xf4'},{'\x85','\xf9'},{'\xfe','\xee'},{'\x8a','\x56'},{'\x90','\x7d'},
+    {'\xd7','\x4e'},{'\xb2','\xe4'},{'\x95','\xa8'},{'\xd7','\x45'},{'\xd7','\x47'},
+    {'\x85','\xf7'},{'\xd7','\x48'},{'\x00','\x00'},{'\xd7','\x50'},{'\xd7','\x4c'},
+    {'\xd7','\x4a'},{'\x00','\x00'},{'\xd7','\x4d'},{'\xd7','\x51'},{'\xb2','\xe5'},
+    {'\xb2','\xe9'},{'\xd7','\x46'},{'\x00','\x00'},{'\xd7','\x4f'},{'\x00','\x00'},
+    {'\xb2','\xe7'},{'\x9f','\xb7'},{'\xb2','\xe6'},{'\xd7','\x4b'},{'\xd7','\x49'},
+    {'\x00','\x00'},{'\xb2','\xe3'},{'\xb2','\xe8'},{'\xfe','\xef'},{'\x96','\xa5'},
+    {'\x93','\xb0'},{'\x9f','\xb8'},{'\x00','\x00'},{'\xfe','\xf0'},{'\xa0','\x42'},
+    {'\x8a','\x58'},{'\xb5','\xc8'},{'\xdb','\x51'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xdb','\x4f'},{'\xb5','\xca'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x9f','\xb9'},{'\xdb','\x4a'},{'\xdf','\xa1'},{'\x00','\x00'},{'\xb5','\xc9'},
+    {'\xdb','\x4e'},{'\x96','\xab'},{'\x00','\x00'},{'\xdb','\x4b'},{'\xb5','\xc5'},
+    {'\xb5','\xcb'},{'\xdb','\x50'},{'\xb5','\xc7'},{'\xdb','\x4d'},{'\xbb','\x47'},
+    {'\xb5','\xc6'},{'\xdb','\x4c'},{'\xb5','\xcc'},{'\xb5','\xc4'},{'\xb5','\xc3'},
+    {'\x9f','\xba'},{'\x00','\x00'},{'\x00','\x00'},{'\x96','\xae'},{'\x96','\xa2'},
+    {'\xdf','\x77'},{'\xdf','\x75'},{'\x00','\x00'},{'\xdf','\x7b'},{'\xfe','\xf1'},
+    {'\xdf','\x73'},{'\xdf','\xa2'},{'\xdf','\x78'},{'\x00','\x00'},{'\xdf','\x72'},
+    {'\xb8','\x7b'},{'\xb8','\xa3'},{'\xdf','\x7d'},{'\x00','\x00'},{'\xdf','\x76'},
+    {'\x00','\x00'},{'\xb8','\x7e'},{'\x9d','\xd0'},{'\xfe','\xf2'},{'\xb8','\x7c'},
+    {'\xdf','\x7e'},{'\xb8','\x79'},{'\xb8','\x78'},{'\xdf','\x79'},{'\xb8','\x7d'},
+    {'\xb5','\xcd'},{'\x00','\x00'},{'\xdf','\x7c'},{'\xdf','\x74'},{'\xb8','\x7a'},
+    {'\xb8','\xa1'},{'\xb8','\xa2'},{'\x89','\x54'},{'\x89','\xae'},{'\xfe','\xf3'},
+    {'\x8c','\x65'},{'\xbb','\x4c'},{'\xbb','\x48'},{'\x00','\x00'},{'\xbb','\x4d'},
+    {'\xe3','\xa6'},{'\x9f','\xbb'},{'\x00','\x00'},{'\xe3','\xa5'},{'\xe3','\xa7'},
+    {'\xbb','\x4a'},{'\xe3','\xa4'},{'\xbb','\x4b'},{'\xe3','\xaa'},{'\xe3','\xa9'},
+    {'\xe3','\xa8'},{'\x00','\x00'},{'\xbb','\x49'},{'\x00','\x00'},{'\x8a','\xf5'},
+    {'\x00','\x00'},{'\xfe','\xf4'},{'\x00','\x00'},{'\xe7','\x41'},{'\x00','\x00'},
+    {'\xe7','\x44'},{'\xbd','\xa8'},{'\xe7','\x43'},{'\xbd','\xa7'},{'\xbd','\xa3'},
+    {'\xbd','\xa4'},{'\xbd','\xa5'},{'\xe7','\x40'},{'\xe6','\xfe'},{'\xbd','\xa6'},
+    {'\x00','\x00'},{'\xe7','\x42'},{'\xe6','\xfd'},{'\x94','\xc7'},{'\x9f','\xbc'},
+    {'\xea','\xe9'},{'\xea','\xf3'},{'\xbf','\xb1'},{'\xbf','\xb0'},{'\xfe','\xf5'},
+    {'\xea','\xed'},{'\xea','\xef'},{'\x00','\x00'},{'\xea','\xea'},{'\x00','\x00'},
+    {'\xea','\xee'},{'\xea','\xe8'},{'\xea','\xf1'},{'\xbf','\xaf'},{'\xea','\xf0'},
+    {'\xea','\xec'},{'\xfb','\x6e'},{'\xea','\xf2'},{'\xfe','\xf6'},{'\xea','\xeb'},
+    {'\xc1','\x74'},{'\xed','\xe8'},{'\xed','\xee'},{'\xc1','\x78'},{'\xc1','\x7a'},
+    {'\xc1','\x77'},{'\xc1','\x76'},{'\xfe','\xf7'},{'\xc1','\x75'},{'\xc1','\x73'},
+    {'\xed','\xe9'},{'\xed','\xec'},{'\xc1','\x72'},{'\xed','\xed'},{'\xfc','\xfe'},
+    {'\xc1','\x79'},{'\xed','\xeb'},{'\x00','\x00'},{'\xed','\xea'},{'\xc2','\xc0'},
+    {'\x00','\x00'},{'\xc2','\xc1'},{'\xf0','\xa1'},{'\xf0','\x7d'},{'\xf0','\x7e'},
+    {'\x93','\x62'},{'\x00','\x00'},{'\xf2','\xc2'},{'\x00','\x00'},{'\xf2','\xc1'},
+    {'\xc3','\xbe'},{'\xf4','\xb4'},{'\xc4','\xa4'},{'\xf4','\xb3'},{'\x00','\x00'},
+    {'\xf5','\xf0'},{'\xf7','\x45'},{'\xc5','\xa6'},{'\xf9','\x43'},{'\xf9','\x44'},
+    {'\xc5','\xd8'},{'\xa6','\xda'},{'\x9f','\xbd'},{'\xaa','\xd7'},{'\xdb','\x52'},
+    {'\xbb','\x4e'},{'\xc1','\x7b'},{'\xed','\xef'},{'\xa6','\xdb'},{'\x00','\x00'},
+    {'\xaf','\xe5'},{'\xaf','\xe4'},{'\xdb','\x53'},{'\x95','\xd3'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xea','\xf4'},{'\xa6','\xdc'},{'\xad','\x50'},{'\x00','\x00'},
+    {'\xfd','\x42'},{'\xdb','\x54'},{'\xdb','\x55'},{'\xdb','\x56'},{'\xbb','\x4f'},
+    {'\xbf','\xb2'},{'\xa6','\xdd'},{'\x00','\x00'},{'\xaa','\xd8'},{'\xd0','\x68'},
+    {'\xaf','\xe6'},{'\xd3','\x70'},{'\xb2','\xea'},{'\x00','\x00'},{'\xdb','\x57'},
+    {'\xb8','\xa4'},{'\x8a','\x77'},{'\xbb','\x50'},{'\xbf','\xb3'},{'\xc1','\x7c'},
+    {'\xc2','\xc2'},{'\xf4','\xb5'},{'\xa6','\xde'},{'\xaa','\xd9'},{'\x92','\xd6'},
+    {'\x00','\x00'},{'\xaf','\xe7'},{'\xd7','\x52'},{'\xb5','\xce'},{'\x00','\x00'},
+    {'\xbb','\x51'},{'\xe3','\xab'},{'\xe7','\x45'},{'\x93','\xc6'},{'\x95','\xec'},
+    {'\x00','\x00'},{'\xfd','\x43'},{'\xa6','\xdf'},{'\xb5','\xcf'},{'\xdf','\xa3'},
+    {'\xbb','\x52'},{'\xa6','\xe0'},{'\xcd','\xb1'},{'\xd0','\x69'},{'\xad','\x51'},
+    {'\x8f','\xc2'},{'\x00','\x00'},{'\xd3','\x72'},{'\xfb','\x53'},{'\x00','\x00'},
+    {'\xaf','\xea'},{'\xfe','\xf8'},{'\xaf','\xe8'},{'\xaf','\xe9'},{'\xaf','\xeb'},
+    {'\xfe','\xf9'},{'\xfe','\xfa'},{'\xd3','\x71'},{'\x8c','\x4c'},{'\x89','\x56'},
+    {'\xd7','\x57'},{'\xd7','\x54'},{'\xd7','\x56'},{'\xb2','\xeb'},{'\xb2','\xed'},
+    {'\xb2','\xec'},{'\xd7','\x53'},{'\xb2','\xee'},{'\xd7','\x55'},{'\x90','\x5b'},
+    {'\xdb','\x58'},{'\xdb','\x59'},{'\xfe','\xfb'},{'\xdb','\x5a'},{'\xdf','\xa6'},
+    {'\x00','\x00'},{'\xdf','\xa7'},{'\x00','\x00'},{'\xdf','\xa5'},{'\xdf','\xa8'},
+    {'\x00','\x00'},{'\xb8','\xa5'},{'\x00','\x00'},{'\xdf','\xa4'},{'\x00','\x00'},
+    {'\xbb','\x53'},{'\x00','\x00'},{'\x00','\x00'},{'\xe7','\x4a'},{'\xe7','\x46'},
+    {'\xe7','\x49'},{'\xe7','\x4b'},{'\xe7','\x48'},{'\xe7','\x47'},{'\x9f','\xbe'},
+    {'\xea','\xf5'},{'\xea','\xf6'},{'\xea','\xf7'},{'\xbf','\xb4'},{'\xbf','\xb5'},
+    {'\xed','\xf1'},{'\xed','\xf0'},{'\xed','\xf2'},{'\x94','\xc8'},{'\xf0','\xa3'},
+    {'\xf0','\xa2'},{'\x00','\x00'},{'\xf2','\xc4'},{'\xfe','\xfc'},{'\xf2','\xc5'},
+    {'\xf2','\xc3'},{'\x9f','\xbf'},{'\xc4','\xa5'},{'\x00','\x00'},{'\xf4','\xb6'},
+    {'\xf4','\xb7'},{'\xfe','\xfd'},{'\xf7','\x46'},{'\xf7','\xef'},{'\xf8','\xbb'},
+    {'\xa6','\xe1'},{'\xa8','\x7d'},{'\x8a','\x5c'},{'\xc1','\x7d'},{'\xa6','\xe2'},
+    {'\x8d','\x5b'},{'\xd7','\x58'},{'\xdb','\x5b'},{'\x82','\x45'},{'\xc6','\x41'},
+    {'\xca','\x4a'},{'\x9c','\xd2'},{'\x8b','\xb7'},{'\x9f','\xc0'},{'\xca','\x4b'},
+    {'\xca','\x4d'},{'\xa6','\xe3'},{'\xca','\x4e'},{'\xca','\x4c'},{'\x00','\x00'},
+    {'\x85','\xeb'},{'\xcb','\xa2'},{'\xcb','\xa3'},{'\xcb','\x7b'},{'\x00','\x00'},
+    {'\x9f','\xc1'},{'\xfe','\xfe'},{'\x00','\x00'},{'\xcb','\xa1'},{'\xa8','\xa1'},
+    {'\x00','\x00'},{'\xa8','\xa2'},{'\xcb','\x7c'},{'\xcb','\x7a'},{'\xcb','\x79'},
+    {'\xcb','\x7d'},{'\xa8','\x7e'},{'\xcb','\x7e'},{'\xd0','\x6a'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8e','\xf6'},{'\xcd','\xb6'},{'\xaa','\xdc'},{'\xcd','\xb5'},
+    {'\xcd','\xb7'},{'\x89','\x59'},{'\xaa','\xdb'},{'\xcd','\xbc'},{'\xaa','\xdf'},
+    {'\xcd','\xb2'},{'\xcd','\xc0'},{'\xcd','\xc6'},{'\xaa','\xe6'},{'\xcd','\xc3'},
+    {'\xaa','\xe3'},{'\x8c','\x4f'},{'\xcd','\xb9'},{'\xcd','\xbf'},{'\xcd','\xc1'},
+    {'\xfb','\xa5'},{'\xcd','\xb4'},{'\xaa','\xe2'},{'\xaa','\xdd'},{'\xcd','\xba'},
+    {'\xaa','\xe4'},{'\xaa','\xe7'},{'\xaa','\xe1'},{'\x00','\x00'},{'\xaa','\xda'},
+    {'\xcd','\xbe'},{'\xcd','\xb8'},{'\xcd','\xc5'},{'\xaa','\xe9'},{'\xaa','\xe5'},
+    {'\xaa','\xe0'},{'\xcd','\xbd'},{'\xaf','\xec'},{'\xcd','\xbb'},{'\xaa','\xde'},
+    {'\xaa','\xe8'},{'\x9f','\xc2'},{'\xcd','\xb3'},{'\x8e','\xca'},{'\xcd','\xc2'},
+    {'\xcd','\xc4'},{'\x96','\xbe'},{'\x91','\x40'},{'\x00','\x00'},{'\x85','\xfb'},
+    {'\x8f','\xe1'},{'\x00','\x00'},{'\x91','\x41'},{'\x84','\x79'},{'\x85','\x51'},
+    {'\x87','\x4b'},{'\x83','\x78'},{'\x84','\xf7'},{'\xfd','\x5f'},{'\xad','\x62'},
+    {'\xad','\x5c'},{'\xad','\x64'},{'\xad','\x61'},{'\xd0','\x71'},{'\xd0','\x74'},
+    {'\xad','\x5d'},{'\x91','\x42'},{'\xd0','\x6b'},{'\x00','\x00'},{'\xad','\x56'},
+    {'\xad','\x60'},{'\x00','\x00'},{'\xad','\x63'},{'\xad','\x65'},{'\xd0','\xa2'},
+    {'\xd0','\x77'},{'\x9f','\xc3'},{'\xad','\x55'},{'\xd0','\xa1'},{'\xad','\x59'},
+    {'\xad','\x57'},{'\xad','\x52'},{'\xd0','\x6f'},{'\x00','\x00'},{'\xd0','\x7e'},
+    {'\xd0','\x73'},{'\xd0','\x76'},{'\xd0','\xa5'},{'\x9f','\xc4'},{'\xad','\x66'},
+    {'\xd0','\x7d'},{'\xad','\x5e'},{'\xd0','\x78'},{'\xd0','\xa4'},{'\xd0','\x75'},
+    {'\xd0','\x79'},{'\xd0','\x7c'},{'\x96','\xa3'},{'\x9f','\xc5'},{'\xd0','\x6d'},
+    {'\xd0','\xa3'},{'\xd0','\x7b'},{'\x9f','\xc6'},{'\xfd','\x5d'},{'\xd0','\x6c'},
+    {'\x9f','\xc7'},{'\xd0','\x70'},{'\xad','\x5f'},{'\xad','\x5a'},{'\xad','\x53'},
+    {'\xad','\x58'},{'\xad','\x54'},{'\xad','\x67'},{'\xd0','\x6e'},{'\xd3','\xa5'},
+    {'\xad','\x5b'},{'\x00','\x00'},{'\x9f','\xc8'},{'\xd0','\x7a'},{'\xce','\x41'},
+    {'\x92','\xa7'},{'\x8f','\xe0'},{'\x00','\x00'},{'\x8e','\xc9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x85','\xc3'},{'\x8e','\x46'},{'\xd3','\xa8'},{'\xaf','\xfa'},
+    {'\x91','\x43'},{'\xd3','\x76'},{'\x91','\x44'},{'\xd3','\xa3'},{'\xd3','\x7d'},
+    {'\x9f','\xc9'},{'\xd3','\xb2'},{'\x00','\x00'},{'\xd3','\xaa'},{'\x00','\x00'},
+    {'\xd3','\x7e'},{'\x91','\x45'},{'\xd3','\xa9'},{'\xd3','\x78'},{'\xd3','\x7c'},
+    {'\xd3','\xb5'},{'\xaf','\xfd'},{'\xd3','\xad'},{'\xd3','\xa4'},{'\xaf','\xed'},
+    {'\xd3','\xb3'},{'\xd3','\x74'},{'\x00','\x00'},{'\xd3','\xac'},{'\x00','\x00'},
+    {'\xaf','\xfc'},{'\xaf','\xf7'},{'\xd3','\x73'},{'\xaf','\xf5'},{'\xaf','\xf4'},
+    {'\xaf','\xf9'},{'\xd3','\xab'},{'\xaf','\xf1'},{'\xaf','\xf8'},{'\xd0','\x72'},
+    {'\xdb','\x5c'},{'\xd3','\xa6'},{'\x9f','\xca'},{'\x00','\x00'},{'\xd3','\x7a'},
+    {'\xaf','\xfb'},{'\xd3','\x7b'},{'\xd3','\xa1'},{'\xaf','\xfe'},{'\xd3','\x75'},
+    {'\xd3','\xaf'},{'\x91','\x46'},{'\xd3','\xae'},{'\xd3','\xb6'},{'\xaf','\xf3'},
+    {'\xaf','\xf0'},{'\xd3','\xb4'},{'\xd3','\xb0'},{'\xd3','\xa7'},{'\xd3','\xa2'},
+    {'\xaf','\xf6'},{'\xaf','\xf2'},{'\xd3','\x77'},{'\xaf','\xee'},{'\xd3','\xb1'},
+    {'\xaf','\xef'},{'\x00','\x00'},{'\xd3','\x79'},{'\x9f','\xcb'},{'\x93','\x54'},
+    {'\x00','\x00'},{'\x84','\x75'},{'\x91','\x47'},{'\x8e','\xc7'},{'\x00','\x00'},
+    {'\x8e','\xf4'},{'\x8f','\x5f'},{'\x8a','\xf9'},{'\x89','\x57'},{'\x91','\x48'},
+    {'\x86','\xd1'},{'\x85','\xfa'},{'\x8e','\x73'},{'\x86','\xe1'},{'\x86','\xdf'},
+    {'\x8e','\xf2'},{'\x8f','\x7b'},{'\x87','\x4a'},{'\x88','\x51'},{'\x91','\x49'},
+    {'\x8e','\x4d'},{'\x91','\x4a'},{'\x8b','\xb9'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd7','\x5e'},{'\xd7','\x60'},{'\xd7','\x65'},{'\xd7','\x79'},
+    {'\xb2','\xfc'},{'\xb2','\xf2'},{'\x00','\x00'},{'\xd7','\x5d'},{'\xb2','\xfd'},
+    {'\xb2','\xfe'},{'\xd7','\x68'},{'\xd7','\x6f'},{'\xd7','\x75'},{'\x00','\x00'},
+    {'\xd7','\x62'},{'\x00','\x00'},{'\xd7','\x69'},{'\x00','\x00'},{'\x87','\x48'},
+    {'\xb3','\x40'},{'\xd7','\x77'},{'\xd7','\x72'},{'\xb2','\xfa'},{'\xb2','\xf8'},
+    {'\xd7','\x6e'},{'\xd7','\x6a'},{'\xd7','\x5c'},{'\xb2','\xef'},{'\xd7','\x61'},
+    {'\xd7','\x59'},{'\x9f','\xcc'},{'\xb2','\xf7'},{'\xb2','\xf9'},{'\xd7','\x66'},
+    {'\xd7','\x63'},{'\xb2','\xf4'},{'\xd7','\x73'},{'\xb2','\xf1'},{'\xd7','\x64'},
+    {'\xd7','\x7a'},{'\xd7','\x6c'},{'\x91','\x4b'},{'\xd7','\x6b'},{'\xb2','\xf0'},
+    {'\x91','\x4c'},{'\xb2','\xfb'},{'\x00','\x00'},{'\xb2','\xf3'},{'\xd7','\x5a'},
+    {'\xd7','\x5f'},{'\xd7','\x70'},{'\xd7','\x76'},{'\xb3','\x41'},{'\xd7','\x5b'},
+    {'\xd7','\x67'},{'\xd7','\x6d'},{'\xb2','\xf6'},{'\x9f','\xcd'},{'\x00','\x00'},
+    {'\xd7','\x78'},{'\xd7','\x71'},{'\xd7','\x74'},{'\x85','\x50'},{'\x88','\x50'},
+    {'\x8e','\x7d'},{'\x85','\xfd'},{'\x91','\x4d'},{'\x8f','\x60'},{'\x89','\xf7'},
+    {'\x8e','\xf5'},{'\x87','\xf3'},{'\x8c','\xc2'},{'\x00','\x00'},{'\x91','\x4e'},
+    {'\xb2','\xf5'},{'\xfb','\xad'},{'\xdb','\x6c'},{'\xdb','\x60'},{'\xb5','\xd7'},
+    {'\xdb','\x7d'},{'\xdb','\xa7'},{'\xdb','\xaa'},{'\xb5','\xd5'},{'\xdb','\x68'},
+    {'\xdb','\xa3'},{'\xdb','\x69'},{'\xdb','\x77'},{'\xb5','\xe2'},{'\xdb','\x73'},
+    {'\xb5','\xdf'},{'\x9f','\xce'},{'\xdb','\x74'},{'\xdb','\x5d'},{'\x00','\x00'},
+    {'\xdb','\xa4'},{'\x00','\x00'},{'\xfe','\x52'},{'\xb5','\xe8'},{'\xdb','\xa1'},
+    {'\xdb','\x75'},{'\xdb','\xac'},{'\xdb','\x70'},{'\xdf','\xc8'},{'\x00','\x00'},
+    {'\xdb','\xaf'},{'\xb5','\xe6'},{'\xdb','\x6e'},{'\xdb','\x7a'},{'\xb5','\xe9'},
+    {'\xb5','\xd4'},{'\xdb','\x72'},{'\xdb','\xad'},{'\xdb','\x6b'},{'\xdb','\x64'},
+    {'\xdb','\x6f'},{'\x00','\x00'},{'\xdb','\x63'},{'\xdb','\x61'},{'\xb5','\xd0'},
+    {'\xdb','\xa5'},{'\xdb','\x6a'},{'\xdb','\xa8'},{'\x9f','\xcf'},{'\xdb','\xa9'},
+    {'\xb5','\xd8'},{'\xb5','\xdd'},{'\xb5','\xd9'},{'\xb5','\xe1'},{'\xdb','\x7e'},
+    {'\xb5','\xda'},{'\xdb','\x76'},{'\xdb','\x66'},{'\x91','\x4f'},{'\xb5','\xd2'},
+    {'\xdb','\x5e'},{'\xdb','\xa2'},{'\xdb','\xab'},{'\xdb','\x65'},{'\xb5','\xe0'},
+    {'\xdb','\xb0'},{'\xdb','\x71'},{'\x00','\x00'},{'\xdb','\x6d'},{'\x00','\x00'},
+    {'\xb5','\xd1'},{'\xb5','\xe5'},{'\x9f','\xd0'},{'\xdb','\x7c'},{'\xb5','\xe7'},
+    {'\x00','\x00'},{'\xdb','\x78'},{'\xb5','\xdc'},{'\xb5','\xd6'},{'\xb5','\xde'},
+    {'\xb5','\xd3'},{'\xb5','\xe4'},{'\xdb','\x79'},{'\xdb','\x67'},{'\xdb','\x7b'},
+    {'\xdb','\x62'},{'\xdb','\xa6'},{'\x9f','\xd1'},{'\x00','\x00'},{'\x9f','\xd2'},
+    {'\x00','\x00'},{'\x96','\xa7'},{'\x00','\x00'},{'\x00','\x00'},{'\xdb','\xae'},
+    {'\x96','\xbd'},{'\x8c','\xfd'},{'\x00','\x00'},{'\x00','\x00'},{'\xfd','\x63'},
+    {'\x9f','\xd3'},{'\x94','\xc9'},{'\xdb','\x5f'},{'\x89','\x5b'},{'\x89','\xf1'},
+    {'\x89','\x4d'},{'\x89','\x58'},{'\x8a','\xf7'},{'\xdf','\xc7'},{'\x91','\x50'},
+    {'\xdf','\xdd'},{'\xb8','\x55'},{'\xdf','\xcc'},{'\x9f','\xd4'},{'\xdf','\xca'},
+    {'\xdf','\xb5'},{'\xb8','\xa9'},{'\xdf','\xc5'},{'\xdf','\xd9'},{'\xdf','\xc1'},
+    {'\xb8','\xb1'},{'\xdf','\xd8'},{'\xdf','\xbf'},{'\xb5','\xe3'},{'\xdf','\xcf'},
+    {'\xdf','\xc0'},{'\xdf','\xd6'},{'\xb8','\xb0'},{'\xb8','\xa8'},{'\x9f','\xd5'},
+    {'\xdf','\xaa'},{'\xdf','\xb2'},{'\x00','\x00'},{'\xdf','\xcb'},{'\xdf','\xc3'},
+    {'\xdf','\xdc'},{'\xdf','\xc6'},{'\xb8','\xb6'},{'\xdf','\xd7'},{'\x91','\x51'},
+    {'\xb8','\xad'},{'\x9f','\xd6'},{'\xdf','\xc9'},{'\xdf','\xd1'},{'\xdf','\xb6'},
+    {'\xdf','\xd0'},{'\x00','\x00'},{'\xdf','\xe1'},{'\xdf','\xb1'},{'\xdf','\xd2'},
+    {'\x9f','\xd7'},{'\xdf','\xdf'},{'\x9f','\xd8'},{'\xdf','\xab'},{'\xb5','\xdb'},
+    {'\x9f','\xd9'},{'\xdf','\xb9'},{'\xdf','\xb8'},{'\xb8','\xaf'},{'\x91','\x52'},
+    {'\xdf','\xbc'},{'\xdf','\xbe'},{'\xdf','\xcd'},{'\xdf','\xde'},{'\xb8','\xb2'},
+    {'\x91','\x53'},{'\xb8','\xb3'},{'\x9f','\xda'},{'\xdf','\xb0'},{'\xb8','\xab'},
+    {'\xdf','\xb4'},{'\xdf','\xda'},{'\xb8','\xb4'},{'\x00','\x00'},{'\xb8','\xac'},
+    {'\xb8','\xae'},{'\xb8','\xb5'},{'\xdf','\xe0'},{'\xdf','\xd3'},{'\xdf','\xce'},
+    {'\x95','\xf5'},{'\x9f','\xdb'},{'\xdf','\xbb'},{'\xdf','\xba'},{'\xb8','\xaa'},
+    {'\xdf','\xac'},{'\xb8','\xa7'},{'\xdf','\xc4'},{'\xdf','\xad'},{'\xdf','\xc2'},
+    {'\x96','\xc0'},{'\x00','\x00'},{'\xdf','\xb7'},{'\xdf','\xdb'},{'\x9f','\xdc'},
+    {'\x9f','\xdd'},{'\x00','\x00'},{'\xb8','\xa6'},{'\x00','\x00'},{'\x91','\x54'},
+    {'\x00','\x00'},{'\xdf','\xb3'},{'\x8e','\xf1'},{'\x91','\x55'},{'\x8e','\xf3'},
+    {'\x00','\x00'},{'\x88','\x52'},{'\x8e','\xc8'},{'\xdf','\xaf'},{'\xdf','\xd5'},
+    {'\xdf','\xae'},{'\xbb','\x60'},{'\xe3','\xd3'},{'\x9f','\xde'},{'\x9f','\xdf'},
+    {'\xe3','\xc2'},{'\x00','\x00'},{'\x9f','\xe0'},{'\xe3','\xac'},{'\xe3','\xca'},
+    {'\xbb','\x58'},{'\xe3','\xbb'},{'\xe3','\xc5'},{'\xbb','\x5b'},{'\xe3','\xbe'},
+    {'\xbb','\x59'},{'\xe3','\xaf'},{'\xe3','\xcd'},{'\xe3','\xae'},{'\xe3','\xc1'},
+    {'\x9f','\xe1'},{'\xe3','\xad'},{'\x00','\x00'},{'\x00','\x00'},{'\xe3','\xbf'},
+    {'\xe3','\xc8'},{'\xe3','\xc6'},{'\xe3','\xba'},{'\xe3','\xb5'},{'\xe3','\xb3'},
+    {'\xfd','\x66'},{'\xe3','\xb4'},{'\xe3','\xc7'},{'\xe3','\xd2'},{'\xe3','\xbc'},
+    {'\xbb','\x5a'},{'\x00','\x00'},{'\xe3','\xb7'},{'\x00','\x00'},{'\xe3','\xcb'},
+    {'\x00','\x00'},{'\xbb','\x5d'},{'\xe3','\xb6'},{'\xe3','\xb0'},{'\xe3','\xc0'},
+    {'\xbb','\x61'},{'\x96','\xbc'},{'\x9f','\xe2'},{'\xbb','\x55'},{'\xbb','\x5e'},
+    {'\xe3','\xb8'},{'\xe3','\xb2'},{'\x00','\x00'},{'\xbb','\x57'},{'\xdf','\xd4'},
+    {'\xbb','\x56'},{'\xe3','\xc3'},{'\x00','\x00'},{'\xbb','\x54'},{'\xbb','\x63'},
+    {'\xbb','\x5c'},{'\xe3','\xc4'},{'\xe3','\xb9'},{'\xe3','\xb1'},{'\xe3','\xcc'},
+    {'\xe3','\xbd'},{'\xbb','\x62'},{'\xe3','\xd0'},{'\xbb','\x5f'},{'\xe3','\xcf'},
+    {'\x00','\x00'},{'\xe3','\xc9'},{'\xe3','\xce'},{'\x00','\x00'},{'\x94','\xca'},
+    {'\xfd','\x65'},{'\xe3','\xd1'},{'\x91','\x56'},{'\x8a','\xf8'},{'\x9f','\xe3'},
+    {'\x8a','\x5e'},{'\x90','\x6c'},{'\x9f','\xe4'},{'\x9f','\xe5'},{'\x91','\x57'},
+    {'\x9f','\xe6'},{'\x8f','\xaa'},{'\x8c','\xbd'},{'\xe7','\x73'},{'\xe7','\x74'},
+    {'\xe7','\x67'},{'\xe7','\x66'},{'\xe7','\x62'},{'\xbd','\xb4'},{'\x00','\x00'},
+    {'\xbd','\xac'},{'\xe7','\x76'},{'\xe7','\x75'},{'\xdf','\xa9'},{'\xe7','\x5f'},
+    {'\xe7','\x63'},{'\xe7','\x5d'},{'\x00','\x00'},{'\xe7','\x70'},{'\xe7','\x61'},
+    {'\x9f','\xe7'},{'\xe7','\x77'},{'\xe7','\x5a'},{'\xe7','\x58'},{'\xe7','\x64'},
+    {'\xe7','\x6e'},{'\xe7','\x69'},{'\xbd','\xb6'},{'\xe7','\x4f'},{'\x00','\x00'},
+    {'\xe7','\x6d'},{'\x9f','\xe8'},{'\x00','\x00'},{'\x9f','\xe9'},{'\xbd','\xb7'},
+    {'\xdf','\xbd'},{'\xe7','\x5b'},{'\xe7','\x52'},{'\xe7','\x55'},{'\xe7','\x7b'},
+    {'\xe7','\x5c'},{'\xe7','\x53'},{'\xe7','\x51'},{'\xe7','\x4e'},{'\x9f','\xea'},
+    {'\xbd','\xb0'},{'\xe7','\x65'},{'\xbd','\xaf'},{'\xbd','\xb3'},{'\xe7','\x60'},
+    {'\xe7','\x68'},{'\xbd','\xa9'},{'\xe7','\x78'},{'\xe7','\x7c'},{'\xbd','\xab'},
+    {'\x00','\x00'},{'\xe7','\x57'},{'\xe7','\x6b'},{'\xe7','\x6f'},{'\xe7','\x54'},
+    {'\xe7','\x79'},{'\xbd','\xb2'},{'\x00','\x00'},{'\xbd','\xb1'},{'\xe7','\x4c'},
+    {'\xbd','\xb5'},{'\xe7','\x72'},{'\xe7','\x56'},{'\xe7','\x6a'},{'\xe7','\x50'},
+    {'\xe7','\x5e'},{'\xe7','\x59'},{'\xbd','\xad'},{'\xbd','\xae'},{'\xe7','\x6c'},
+    {'\xe7','\x7d'},{'\xe7','\x7a'},{'\xe7','\x71'},{'\x00','\x00'},{'\x9f','\xeb'},
+    {'\xfe','\x4c'},{'\x93','\x60'},{'\x00','\x00'},{'\x8a','\x5d'},{'\x91','\x58'},
+    {'\x90','\x46'},{'\x8c','\x4e'},{'\xe7','\x4d'},{'\x8c','\x4d'},{'\xbd','\xaa'},
+    {'\xeb','\x49'},{'\x00','\x00'},{'\xeb','\x40'},{'\xeb','\x43'},{'\x9f','\xed'},
+    {'\xbf','\xbb'},{'\xeb','\x45'},{'\xea','\xf9'},{'\xeb','\x41'},{'\xeb','\x47'},
+    {'\xbf','\xb8'},{'\xbf','\xbc'},{'\xbf','\xb6'},{'\xfd','\x68'},{'\x9f','\xee'},
+    {'\xea','\xfb'},{'\xeb','\x4c'},{'\x00','\x00'},{'\x00','\x00'},{'\xeb','\x46'},
+    {'\x9f','\xef'},{'\xea','\xfc'},{'\xeb','\x55'},{'\xeb','\x4f'},{'\xea','\xf8'},
+    {'\xee','\x46'},{'\xea','\xfe'},{'\xbf','\xb7'},{'\x91','\x59'},{'\xeb','\x4a'},
+    {'\x00','\x00'},{'\xeb','\x54'},{'\xbf','\xbf'},{'\x9f','\xf0'},{'\xeb','\x51'},
+    {'\xea','\xfd'},{'\xeb','\x44'},{'\xeb','\x48'},{'\xeb','\x42'},{'\xeb','\x56'},
+    {'\xeb','\x53'},{'\xeb','\x50'},{'\xbf','\xb9'},{'\xbf','\xba'},{'\xbf','\xbe'},
+    {'\xea','\xfa'},{'\xeb','\x57'},{'\xbf','\xbd'},{'\xeb','\x4d'},{'\x9f','\xf1'},
+    {'\x9f','\xf2'},{'\xeb','\x4b'},{'\x8f','\xe2'},{'\x9f','\xf3'},{'\x8c','\x51'},
+    {'\xeb','\x4e'},{'\xee','\x53'},{'\xee','\x40'},{'\xee','\x45'},{'\xee','\x52'},
+    {'\xee','\x44'},{'\xed','\xfb'},{'\xee','\x41'},{'\x00','\x00'},{'\xc1','\xa2'},
+    {'\x00','\x00'},{'\xed','\xf4'},{'\xee','\x4d'},{'\xee','\x4f'},{'\xed','\xf3'},
+    {'\xc1','\xa1'},{'\xee','\x51'},{'\xee','\x49'},{'\xc1','\xa8'},{'\xee','\x50'},
+    {'\xee','\x42'},{'\xc1','\xaa'},{'\xed','\xf9'},{'\xeb','\x52'},{'\xee','\x4a'},
+    {'\xee','\x47'},{'\xed','\xf5'},{'\xee','\x55'},{'\xc1','\xa4'},{'\x00','\x00'},
+    {'\x9d','\x76'},{'\xc1','\xa5'},{'\xed','\xf7'},{'\xee','\x48'},{'\x91','\x5a'},
+    {'\xee','\x54'},{'\xee','\x4b'},{'\xed','\xfd'},{'\xc1','\xa7'},{'\xc1','\xa3'},
+    {'\xee','\x4c'},{'\xed','\xfe'},{'\xee','\x56'},{'\xed','\xf8'},{'\xee','\x43'},
+    {'\xee','\x4e'},{'\xed','\xfa'},{'\xed','\xfc'},{'\x00','\x00'},{'\xc2','\xcb'},
+    {'\xed','\xf6'},{'\xc1','\xa9'},{'\xc2','\xc4'},{'\xc1','\x7e'},{'\x91','\x5b'},
+    {'\x93','\xd6'},{'\x00','\x00'},{'\x82','\x7e'},{'\xc1','\xa6'},{'\xc2','\xc8'},
+    {'\xf0','\xb3'},{'\x00','\x00'},{'\xf0','\xa9'},{'\xf0','\xa4'},{'\xf0','\xaa'},
+    {'\xf0','\xb4'},{'\xf0','\xb8'},{'\xf0','\xb7'},{'\xc2','\xca'},{'\xc2','\xc9'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf0','\xab'},{'\xf0','\xb9'},{'\xf0','\xae'},
+    {'\xf0','\xa6'},{'\x91','\x5c'},{'\xf0','\xa8'},{'\xf0','\xa7'},{'\xf0','\xad'},
+    {'\xf0','\xb2'},{'\xf0','\xa5'},{'\xf0','\xac'},{'\xf0','\xb1'},{'\xc2','\xc7'},
+    {'\x00','\x00'},{'\xf0','\xaf'},{'\x00','\x00'},{'\xc2','\xc5'},{'\xf0','\xb0'},
+    {'\xc2','\xc3'},{'\xc2','\xc6'},{'\xf2','\xd5'},{'\xf0','\xb5'},{'\x8c','\xa4'},
+    {'\x00','\x00'},{'\xc3','\xc2'},{'\x9f','\xf4'},{'\xf2','\xcd'},{'\xf2','\xd1'},
+    {'\xf2','\xc9'},{'\xf2','\xcc'},{'\x00','\x00'},{'\xf2','\xd4'},{'\xc3','\xc0'},
+    {'\xf2','\xd9'},{'\xf2','\xd2'},{'\x9f','\xf5'},{'\xf2','\xca'},{'\xf2','\xda'},
+    {'\xf2','\xd3'},{'\xc3','\xc3'},{'\xc3','\xc4'},{'\xf2','\xd7'},{'\x00','\x00'},
+    {'\xf2','\xcb'},{'\xc3','\xbf'},{'\xc3','\xc1'},{'\xf2','\xc6'},{'\xf2','\xce'},
+    {'\xf2','\xc8'},{'\x9f','\xf6'},{'\xf2','\xd8'},{'\xf2','\xd6'},{'\xf2','\xc7'},
+    {'\xf2','\xcf'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xf4','\xbe'},
+    {'\xc3','\xc5'},{'\xf2','\xd0'},{'\xc4','\xa7'},{'\xc4','\xa9'},{'\xc4','\xa6'},
+    {'\x9f','\xf7'},{'\xf4','\xc3'},{'\xf4','\xbb'},{'\xf4','\xb9'},{'\xf4','\xbd'},
+    {'\xf4','\xba'},{'\xfd','\x6a'},{'\x00','\x00'},{'\xf4','\xbf'},{'\xf4','\xc1'},
+    {'\xc4','\xaa'},{'\xc4','\xac'},{'\x00','\x00'},{'\xf4','\xc0'},{'\xc4','\xad'},
+    {'\xc4','\xab'},{'\xf4','\xc2'},{'\x9f','\xf8'},{'\x00','\x00'},{'\x9f','\xf9'},
+    {'\xfd','\x6b'},{'\xc4','\xa8'},{'\x00','\x00'},{'\x91','\x5d'},{'\x9f','\xfa'},
+    {'\x00','\x00'},{'\x91','\x5e'},{'\xc4','\xf4'},{'\xf5','\xf1'},{'\xf5','\xf7'},
+    {'\xc4','\xf6'},{'\xf4','\xbc'},{'\xf5','\xf6'},{'\x00','\x00'},{'\xf5','\xfd'},
+    {'\xf5','\xf4'},{'\xf5','\xfb'},{'\xf5','\xfa'},{'\xf4','\xb8'},{'\xf5','\xf5'},
+    {'\xf0','\xb6'},{'\xf5','\xfe'},{'\xf5','\xf3'},{'\xf5','\xf8'},{'\x9f','\xfb'},
+    {'\xf5','\xfc'},{'\xf5','\xf2'},{'\x00','\x00'},{'\xf7','\x4a'},{'\xc4','\xf5'},
+    {'\xf5','\xf9'},{'\xfb','\xae'},{'\x94','\xcb'},{'\xf7','\xf4'},{'\xf7','\x4b'},
+    {'\xf7','\x49'},{'\xf7','\x47'},{'\xf7','\x48'},{'\xf7','\x4c'},{'\x00','\x00'},
+    {'\xc5','\xd9'},{'\xf7','\xf2'},{'\xf7','\xf0'},{'\xf7','\xf5'},{'\xf7','\xf3'},
+    {'\x00','\x00'},{'\xf7','\xf6'},{'\xc5','\xda'},{'\xf7','\xf1'},{'\x00','\x00'},
+    {'\x9f','\xfc'},{'\xf8','\xbc'},{'\x00','\x00'},{'\x9f','\xfd'},{'\xf9','\x45'},
+    {'\xf9','\x46'},{'\xf9','\x47'},{'\x00','\x00'},{'\x00','\x00'},{'\xf9','\xc7'},
+    {'\xf9','\xbd'},{'\xca','\x4f'},{'\xaa','\xea'},{'\x86','\x40'},{'\xad','\x68'},
+    {'\x87','\xcb'},{'\xd3','\xb8'},{'\xd3','\xb7'},{'\xb0','\x40'},{'\xb3','\x42'},
+    {'\xd7','\x7c'},{'\x00','\x00'},{'\x00','\x00'},{'\xd7','\x7b'},{'\x85','\x52'},
+    {'\xb5','\xea'},{'\xb8','\xb8'},{'\x00','\x00'},{'\xb8','\xb7'},{'\xb8','\xb9'},
+    {'\x00','\x00'},{'\xe3','\xd4'},{'\xe7','\x7e'},{'\xeb','\x58'},{'\xeb','\x5a'},
+    {'\xeb','\x59'},{'\x00','\x00'},{'\xc1','\xab'},{'\xee','\x57'},{'\xf0','\xba'},
+    {'\xf9','\xa5'},{'\xa6','\xe4'},{'\x95','\x78'},{'\xcd','\xc9'},{'\xcd','\xca'},
+    {'\xcd','\xc8'},{'\xcd','\xc7'},{'\xaa','\xeb'},{'\x9f','\xfe'},{'\xd0','\xa9'},
+    {'\xd0','\xa7'},{'\x00','\x00'},{'\x00','\x00'},{'\xd0','\xa6'},{'\x00','\x00'},
+    {'\xad','\x69'},{'\xad','\x6b'},{'\xad','\x6a'},{'\xd0','\xa8'},{'\x8a','\xaf'},
+    {'\x88','\x53'},{'\x8f','\xc4'},{'\x87','\x4c'},{'\x8b','\xba'},{'\x89','\x5a'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xd3','\xc4'},{'\xd3','\xc1'},{'\xd3','\xbf'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb0','\x41'},{'\xd3','\xc2'},{'\xb0','\x46'},
+    {'\xd3','\xbc'},{'\xd3','\xcb'},{'\x00','\x00'},{'\xd3','\xcd'},{'\xd3','\xbd'},
+    {'\xfe','\xbb'},{'\xb0','\x43'},{'\xd3','\xce'},{'\xd3','\xc9'},{'\xd3','\xbb'},
+    {'\xd3','\xc0'},{'\xd3','\xca'},{'\xd3','\xc6'},{'\xd3','\xc3'},{'\x00','\x00'},
+    {'\xb0','\x48'},{'\xd3','\xcc'},{'\xd3','\xbe'},{'\x00','\x00'},{'\xfe','\xbc'},
+    {'\xd3','\xc7'},{'\xd3','\xb9'},{'\xb0','\x47'},{'\xb0','\x44'},{'\xd3','\xc5'},
+    {'\x00','\x00'},{'\xd3','\xc8'},{'\xd3','\xba'},{'\xb0','\x45'},{'\xb0','\x42'},
+    {'\x94','\xcc'},{'\x86','\x43'},{'\xfe','\xbd'},{'\x00','\x00'},{'\xb3','\x4c'},
+    {'\xd7','\xa5'},{'\xb3','\x4b'},{'\xfe','\xbe'},{'\xd7','\xa8'},{'\xd7','\xab'},
+    {'\xb3','\x48'},{'\xb3','\x46'},{'\xd7','\x7e'},{'\xd7','\xa9'},{'\xd7','\xa7'},
+    {'\xd7','\xa4'},{'\xd7','\xac'},{'\xd7','\xad'},{'\xd7','\xaf'},{'\xd7','\xb0'},
+    {'\xd7','\x7d'},{'\xb3','\x45'},{'\xd7','\xa2'},{'\xd7','\xa1'},{'\xd7','\xae'},
+    {'\xb3','\x47'},{'\xd7','\xa3'},{'\xb3','\x49'},{'\xb3','\x44'},{'\xd7','\xa6'},
+    {'\xb3','\x4d'},{'\x8c','\xfe'},{'\xb3','\x4a'},{'\xd7','\xaa'},{'\x92','\xac'},
+    {'\x82','\x4c'},{'\x8f','\xc3'},{'\xb5','\xf1'},{'\xdb','\xbf'},{'\x00','\x00'},
+    {'\xdb','\xb4'},{'\xb5','\xee'},{'\x00','\x00'},{'\xdf','\xe7'},{'\xdb','\xbd'},
+    {'\xdb','\xb1'},{'\xb5','\xec'},{'\xdb','\xb6'},{'\xb5','\xef'},{'\xdb','\xba'},
+    {'\xdb','\xb8'},{'\xb5','\xf2'},{'\xb5','\xeb'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xdb','\xb2'},{'\xdb','\xb5'},{'\xb5','\xf0'},{'\x00','\x00'},{'\xdb','\xb3'},
+    {'\x00','\x00'},{'\xdb','\xbe'},{'\xdb','\xbc'},{'\xdb','\xb7'},{'\xdb','\xb9'},
+    {'\xdb','\xbb'},{'\xb5','\xed'},{'\x8d','\x72'},{'\x94','\xcd'},{'\x8f','\x61'},
+    {'\x8e','\x4e'},{'\x8a','\xfa'},{'\x8e','\xf7'},{'\x8f','\xe3'},{'\xdf','\xe8'},
+    {'\xdf','\xee'},{'\xdf','\xe4'},{'\xdf','\xea'},{'\xb8','\xba'},{'\xdf','\xe6'},
+    {'\xb8','\xc0'},{'\x00','\x00'},{'\x00','\x00'},{'\xb8','\xbf'},{'\x00','\x00'},
+    {'\xb8','\xbe'},{'\xdf','\xed'},{'\xb8','\xc1'},{'\xb8','\xc2'},{'\xdf','\xe3'},
+    {'\xdf','\xf0'},{'\xb8','\xc3'},{'\xb8','\xbd'},{'\xb8','\xbc'},{'\xdf','\xec'},
+    {'\xb8','\xc4'},{'\xdf','\xe2'},{'\xdf','\xe5'},{'\xdf','\xef'},{'\xdf','\xeb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xe3','\xf4'},{'\xe3','\xe9'},{'\xb8','\xbb'},
+    {'\x00','\x00'},{'\x91','\x60'},{'\x00','\x00'},{'\x88','\x54'},{'\xbb','\x6a'},
+    {'\xe3','\xdd'},{'\xe3','\xf2'},{'\xe3','\xde'},{'\xbb','\x65'},{'\x00','\x00'},
+    {'\xe3','\xdb'},{'\x00','\x00'},{'\xe3','\xe4'},{'\xe3','\xdc'},{'\xbb','\x67'},
+    {'\xe3','\xd6'},{'\xe3','\xf1'},{'\xbb','\x68'},{'\xe3','\xee'},{'\xe3','\xef'},
+    {'\xe3','\xd7'},{'\xbb','\x6d'},{'\xe3','\xe6'},{'\x00','\x00'},{'\xe3','\xe0'},
+    {'\xe3','\xe7'},{'\xe3','\xda'},{'\x00','\x00'},{'\xe3','\xf3'},{'\xe3','\xeb'},
+    {'\xe3','\xe5'},{'\xe3','\xd5'},{'\xbb','\x69'},{'\xe3','\xec'},{'\x00','\x00'},
+    {'\xbb','\x6c'},{'\xe3','\xf0'},{'\x00','\x00'},{'\xe3','\xea'},{'\xbb','\x66'},
+    {'\xe3','\xe8'},{'\x00','\x00'},{'\xe3','\xe2'},{'\xbb','\x64'},{'\xe3','\xd9'},
+    {'\xe3','\xe1'},{'\xe3','\xed'},{'\xe3','\xdf'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe3','\xe3'},{'\x8b','\xbb'},{'\x8a','\x61'},{'\x8a','\xfb'},{'\x00','\x00'},
+    {'\x82','\xa2'},{'\xbd','\xc1'},{'\xdf','\xe9'},{'\xe7','\xb2'},{'\xe7','\xbb'},
+    {'\xe7','\xb1'},{'\xe7','\xad'},{'\xe7','\xaa'},{'\xbd','\xc2'},{'\xe7','\xa8'},
+    {'\xbb','\x6b'},{'\xe7','\xa1'},{'\xbd','\xc0'},{'\xe7','\xa7'},{'\xbd','\xbf'},
+    {'\xe7','\xac'},{'\xe7','\xa9'},{'\xe7','\xb9'},{'\xe7','\xb4'},{'\xe7','\xae'},
+    {'\xe7','\xb3'},{'\xbd','\xbb'},{'\xe7','\xab'},{'\xe7','\xbe'},{'\xe7','\xa2'},
+    {'\xe7','\xa3'},{'\xe7','\xba'},{'\xbd','\xbc'},{'\xe7','\xbf'},{'\xbd','\xbe'},
+    {'\xe7','\xc0'},{'\xe7','\xb0'},{'\xe3','\xd8'},{'\xe7','\xb6'},{'\xe7','\xaf'},
+    {'\xe7','\xb8'},{'\xe7','\xb5'},{'\x91','\x61'},{'\xfd','\x45'},{'\x00','\x00'},
+    {'\xe7','\xa6'},{'\xbd','\xb9'},{'\xe7','\xbd'},{'\xbd','\xba'},{'\xe7','\xa4'},
+    {'\xbd','\xbd'},{'\xeb','\x64'},{'\xe7','\xb7'},{'\xe7','\xbc'},{'\x8a','\x60'},
+    {'\x91','\x62'},{'\x8f','\xe4'},{'\x82','\x75'},{'\x00','\x00'},{'\xeb','\x61'},
+    {'\xbd','\xb8'},{'\xbf','\xc0'},{'\xeb','\x6b'},{'\xeb','\x67'},{'\xfb','\x6c'},
+    {'\xeb','\x65'},{'\xeb','\x60'},{'\xeb','\x6f'},{'\x00','\x00'},{'\x91','\x63'},
+    {'\xfd','\x47'},{'\xbf','\xc4'},{'\x00','\x00'},{'\xeb','\x5c'},{'\xeb','\x68'},
+    {'\xeb','\x69'},{'\xeb','\x5f'},{'\xeb','\x5e'},{'\xeb','\x6c'},{'\x00','\x00'},
+    {'\xeb','\x62'},{'\xeb','\x5d'},{'\xeb','\x63'},{'\x00','\x00'},{'\xeb','\x6e'},
+    {'\xeb','\x5b'},{'\xeb','\x6d'},{'\xeb','\x6a'},{'\xbf','\xc2'},{'\xbf','\xc1'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xbf','\xc3'},{'\xeb','\x66'},{'\xf0','\xcb'},
+    {'\xfe','\xbf'},{'\x00','\x00'},{'\x00','\x00'},{'\x91','\x64'},{'\xfd','\x46'},
+    {'\xee','\x59'},{'\xc1','\xb1'},{'\xee','\x5d'},{'\xee','\x5a'},{'\xee','\x61'},
+    {'\xee','\x67'},{'\xee','\x5c'},{'\xfe','\xc0'},{'\xee','\x70'},{'\xc1','\xae'},
+    {'\xee','\x6a'},{'\xee','\x5f'},{'\xee','\x6b'},{'\xee','\x66'},{'\xee','\x6d'},
+    {'\xee','\x5e'},{'\xc1','\xb3'},{'\xc1','\xb2'},{'\xee','\x60'},{'\xee','\x6e'},
+    {'\xee','\x58'},{'\xee','\x6c'},{'\xc1','\xac'},{'\xfd','\x49'},{'\xee','\x64'},
+    {'\xee','\x63'},{'\xee','\x68'},{'\xee','\x5b'},{'\xc1','\xb0'},{'\x91','\x65'},
+    {'\xc1','\xb4'},{'\xee','\x62'},{'\xee','\x69'},{'\xc1','\xb5'},{'\xee','\x65'},
+    {'\x00','\x00'},{'\x96','\xc7'},{'\x00','\x00'},{'\x91','\x66'},{'\xc1','\xad'},
+    {'\xc1','\xaf'},{'\xf0','\xc7'},{'\xf0','\xc5'},{'\x00','\x00'},{'\xfd','\x4c'},
+    {'\xf0','\xcc'},{'\xf0','\xc9'},{'\xf0','\xcd'},{'\xfe','\xc5'},{'\xf0','\xbe'},
+    {'\xf0','\xc6'},{'\xf0','\xd1'},{'\xee','\x6f'},{'\xf0','\xc2'},{'\xc2','\xcf'},
+    {'\xe7','\xa5'},{'\xf0','\xbd'},{'\xf0','\xca'},{'\xf0','\xc4'},{'\xf0','\xc1'},
+    {'\xf0','\xbc'},{'\xf0','\xbb'},{'\xf0','\xd0'},{'\x00','\x00'},{'\xf0','\xc0'},
+    {'\xf0','\xbf'},{'\xc2','\xcd'},{'\xf0','\xc8'},{'\xfb','\xab'},{'\xc2','\xcc'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc2','\xce'},{'\xf0','\xc3'},{'\xf0','\xcf'},
+    {'\xfd','\x4d'},{'\xf2','\xde'},{'\xf2','\xdf'},{'\x00','\x00'},{'\xc3','\xc9'},
+    {'\xf2','\xdc'},{'\xc3','\xc6'},{'\xf2','\xe4'},{'\x00','\x00'},{'\xc3','\xca'},
+    {'\xf2','\xe6'},{'\xf2','\xdb'},{'\xf0','\xce'},{'\xf2','\xe8'},{'\xf2','\xdd'},
+    {'\xfb','\x72'},{'\xc3','\xc7'},{'\xf2','\xe3'},{'\x91','\x67'},{'\xf2','\xe5'},
+    {'\xf2','\xe0'},{'\xf2','\xe7'},{'\xf2','\xe2'},{'\xf2','\xe1'},{'\xc3','\xc8'},
+    {'\x91','\x68'},{'\xfd','\x4e'},{'\xf4','\xc5'},{'\xf4','\xc6'},{'\x00','\x00'},
+    {'\xf4','\xc8'},{'\xc4','\xae'},{'\xc4','\xaf'},{'\xf4','\xc9'},{'\xf4','\xc7'},
+    {'\xfd','\x4f'},{'\xf4','\xc4'},{'\x00','\x00'},{'\xf6','\x42'},{'\xf6','\x45'},
+    {'\xf6','\x41'},{'\x00','\x00'},{'\xc4','\xfa'},{'\xf6','\x43'},{'\xc4','\xf9'},
+    {'\xc4','\xf8'},{'\xc4','\xf7'},{'\xf6','\x44'},{'\xf7','\x51'},{'\xf7','\x4f'},
+    {'\x91','\x69'},{'\xf7','\x4e'},{'\xf6','\x40'},{'\xf7','\x50'},{'\xf6','\x46'},
+    {'\xf7','\x4d'},{'\xfd','\x50'},{'\xf7','\xf9'},{'\xf7','\xd7'},{'\xf7','\xf7'},
+    {'\xc5','\xdb'},{'\xf7','\xf8'},{'\xf7','\xfa'},{'\x00','\x00'},{'\xf8','\xbf'},
+    {'\xc5','\xfa'},{'\xf8','\xbe'},{'\xf8','\xbd'},{'\xc5','\xfb'},{'\x00','\x00'},
+    {'\xc6','\x5a'},{'\xf9','\x6e'},{'\xf9','\xa7'},{'\xf9','\xa6'},{'\xf9','\xa8'},
+    {'\xa6','\xe5'},{'\xd0','\xaa'},{'\xfd','\x51'},{'\xd3','\xcf'},{'\xd3','\xd0'},
+    {'\x8d','\x75'},{'\x92','\xdb'},{'\x00','\x00'},{'\xdb','\xc0'},{'\x00','\x00'},
+    {'\xf6','\x47'},{'\xf8','\xc0'},{'\xa6','\xe6'},{'\xad','\x6c'},{'\xd0','\xab'},
+    {'\xfe','\xc6'},{'\x00','\x00'},{'\x00','\x00'},{'\xd7','\xb1'},{'\xb3','\x4e'},
+    {'\x83','\xf5'},{'\xdb','\xc2'},{'\xdb','\xc1'},{'\xb5','\xf3'},{'\x00','\x00'},
+    {'\xb8','\xc5'},{'\xe7','\xc1'},{'\xbd','\xc3'},{'\x00','\x00'},{'\xbd','\xc4'},
+    {'\xfd','\x5b'},{'\x00','\x00'},{'\xfe','\xc7'},{'\xbf','\xc5'},{'\xc5','\xfc'},
+    {'\xa6','\xe7'},{'\x91','\xd6'},{'\x86','\x44'},{'\x00','\x00'},{'\xd0','\xac'},
+    {'\xaa','\xed'},{'\xd0','\xae'},{'\xd0','\xad'},{'\xad','\x6d'},{'\x8c','\xdc'},
+    {'\xd3','\xd1'},{'\x84','\x7c'},{'\xd3','\xd8'},{'\xb0','\x49'},{'\xd3','\xd6'},
+    {'\xd3','\xd4'},{'\x00','\x00'},{'\xd3','\xdb'},{'\xd3','\xd2'},{'\xd3','\xd3'},
+    {'\xb0','\x4a'},{'\x00','\x00'},{'\xb0','\x4e'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xd3','\xdc'},{'\xb0','\x4d'},{'\xd3','\xda'},{'\xd3','\xd7'},{'\xd3','\xd5'},
+    {'\xb0','\x4b'},{'\xb0','\x4c'},{'\xd3','\xd9'},{'\x8b','\xbd'},{'\x88','\xd3'},
+    {'\x00','\x00'},{'\xfe','\xc8'},{'\xb3','\x50'},{'\xd7','\xb2'},{'\x00','\x00'},
+    {'\xb3','\x55'},{'\xd7','\xc2'},{'\xb3','\x54'},{'\xd7','\xc4'},{'\xfe','\xc9'},
+    {'\xfe','\xca'},{'\xd7','\xb8'},{'\xb3','\x52'},{'\xd7','\xc3'},{'\x00','\x00'},
+    {'\xd7','\xb3'},{'\xb3','\x53'},{'\xd7','\xbf'},{'\xd7','\xbb'},{'\xd7','\xbd'},
+    {'\xd7','\xb7'},{'\xd7','\xbe'},{'\x90','\xba'},{'\x00','\x00'},{'\xb3','\x4f'},
+    {'\xd7','\xba'},{'\xfd','\x56'},{'\xd7','\xb9'},{'\xd7','\xb5'},{'\x00','\x00'},
+    {'\xd7','\xc0'},{'\x00','\x00'},{'\x00','\x00'},{'\xd7','\xbc'},{'\xd7','\xb4'},
+    {'\x00','\x00'},{'\xd7','\xb6'},{'\xb3','\x51'},{'\xd7','\xc1'},{'\x8c','\xdb'},
+    {'\x91','\x6a'},{'\x00','\x00'},{'\x94','\xce'},{'\xb5','\xf6'},{'\xdb','\xcd'},
+    {'\x00','\x00'},{'\x95','\xdd'},{'\x91','\x6c'},{'\xdb','\xc9'},{'\xdb','\xcb'},
+    {'\xdb','\xc6'},{'\xdb','\xc5'},{'\xdb','\xc3'},{'\x00','\x00'},{'\xdb','\xca'},
+    {'\xdb','\xcc'},{'\xdb','\xc8'},{'\x91','\x6d'},{'\xdb','\xc7'},{'\xb5','\xf4'},
+    {'\xb5','\xf5'},{'\x94','\xcf'},{'\x94','\xd0'},{'\x86','\x45'},{'\x8b','\xbc'},
+    {'\xfb','\x63'},{'\x00','\x00'},{'\xdb','\xcf'},{'\xb8','\xcd'},{'\xdf','\xf2'},
+    {'\xdf','\xf8'},{'\xdf','\xf3'},{'\xdf','\xf4'},{'\xf9','\xd8'},{'\xdf','\xf9'},
+    {'\x00','\x00'},{'\xb8','\xcf'},{'\x00','\x00'},{'\xb8','\xc7'},{'\xb8','\xce'},
+    {'\xdf','\xf1'},{'\xdb','\xc4'},{'\xb8','\xca'},{'\xb8','\xc8'},{'\xdf','\xf7'},
+    {'\xdf','\xf6'},{'\xb8','\xc9'},{'\xb8','\xcb'},{'\xdf','\xf5'},{'\xb8','\xc6'},
+    {'\x00','\x00'},{'\xb8','\xcc'},{'\x8f','\x62'},{'\x8f','\xc5'},{'\x89','\x5c'},
+    {'\x91','\x6e'},{'\xfe','\xcb'},{'\xe3','\xf6'},{'\xbb','\x74'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe4','\x42'},{'\xe4','\x41'},{'\x00','\x00'},{'\xe3','\xfb'},
+    {'\xbb','\x76'},{'\xe4','\x40'},{'\xe3','\xf7'},{'\xe3','\xf8'},{'\xbb','\x6e'},
+    {'\xbb','\x70'},{'\x91','\x6f'},{'\xe3','\xfd'},{'\xe3','\xf5'},{'\xbb','\x72'},
+    {'\xbb','\x71'},{'\xe3','\xf9'},{'\xe3','\xfe'},{'\xe3','\xfc'},{'\xbb','\x73'},
+    {'\xe3','\xfa'},{'\xfe','\xcc'},{'\xfe','\xcd'},{'\xdb','\xce'},{'\xbb','\x6f'},
+    {'\x00','\x00'},{'\x94','\xd1'},{'\xe7','\xc2'},{'\xe7','\xc9'},{'\xbd','\xc6'},
+    {'\x00','\x00'},{'\xe7','\xcd'},{'\xbd','\xca'},{'\xe7','\xc5'},{'\xe7','\xc3'},
+    {'\x00','\x00'},{'\xe7','\xcc'},{'\x00','\x00'},{'\xbd','\xc5'},{'\xe7','\xcb'},
+    {'\xbd','\xc7'},{'\xbd','\xc8'},{'\xe7','\xc4'},{'\xbd','\xc9'},{'\xe7','\xca'},
+    {'\xe7','\xc6'},{'\xe7','\xc7'},{'\xe7','\xc8'},{'\xbb','\x75'},{'\x8a','\x63'},
+    {'\x91','\x70'},{'\x91','\x71'},{'\xeb','\x70'},{'\xeb','\x7c'},{'\x00','\x00'},
+    {'\xbf','\xca'},{'\xeb','\x77'},{'\xeb','\x79'},{'\xfe','\xce'},{'\xbf','\xc8'},
+    {'\xeb','\x71'},{'\xeb','\x75'},{'\x00','\x00'},{'\xeb','\x78'},{'\xbf','\xc6'},
+    {'\xbf','\xc9'},{'\xeb','\x7b'},{'\xeb','\x73'},{'\xeb','\x74'},{'\xeb','\x7a'},
+    {'\xeb','\x72'},{'\xeb','\x76'},{'\xbf','\xc7'},{'\xee','\x72'},{'\x8c','\x53'},
+    {'\xee','\x71'},{'\xc1','\xb7'},{'\xee','\x77'},{'\xc1','\xb9'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc1','\xb6'},{'\xee','\x73'},{'\xc1','\xba'},{'\xee','\x74'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xee','\x75'},{'\xee','\x78'},{'\xfd','\x58'},
+    {'\xc1','\xb8'},{'\x00','\x00'},{'\xf0','\xd6'},{'\xfe','\xcf'},{'\x00','\x00'},
+    {'\xf0','\xd9'},{'\x00','\x00'},{'\xf0','\xd3'},{'\xf0','\xd5'},{'\xfd','\x59'},
+    {'\x00','\x00'},{'\xf0','\xd4'},{'\xf0','\xd7'},{'\xf0','\xd8'},{'\xee','\x76'},
+    {'\xf0','\xd2'},{'\xfe','\xd0'},{'\x00','\x00'},{'\xc3','\xcd'},{'\xf2','\xec'},
+    {'\xf2','\xef'},{'\xf2','\xf1'},{'\xf2','\xea'},{'\xf2','\xeb'},{'\xf2','\xee'},
+    {'\xf2','\xf0'},{'\xc3','\xce'},{'\xc3','\xcc'},{'\xc3','\xcb'},{'\xf2','\xed'},
+    {'\xf2','\xe9'},{'\xf4','\xca'},{'\xc4','\xb0'},{'\xfe','\xd1'},{'\xf4','\xcb'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf6','\x49'},{'\xc4','\xfb'},{'\xf6','\x4b'},
+    {'\xc4','\xfc'},{'\xf6','\x48'},{'\xf6','\x4a'},{'\xc5','\xa8'},{'\x00','\x00'},
+    {'\xf7','\x52'},{'\xc5','\xa7'},{'\xf7','\xfd'},{'\xf7','\xfc'},{'\x00','\x00'},
+    {'\xf7','\xfb'},{'\x91','\x72'},{'\x00','\x00'},{'\xf9','\x48'},{'\xf9','\x49'},
+    {'\xf9','\x4b'},{'\xf9','\x4a'},{'\x00','\x00'},{'\xca','\x50'},{'\xa6','\xe8'},
+    {'\xfe','\xd2'},{'\xad','\x6e'},{'\xd7','\xc5'},{'\xb5','\xf7'},{'\x00','\x00'},
+    {'\xdf','\xfa'},{'\xc2','\xd0'},{'\x95','\xf6'},{'\xf2','\xf2'},{'\xfd','\x6d'},
+    {'\xfd','\x6e'},{'\xa8','\xa3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb3','\x57'},{'\x00','\x00'},{'\xfe','\xd3'},{'\x00','\x00'},{'\xb3','\x56'},
+    {'\xfd','\x6f'},{'\xdb','\xd0'},{'\xb5','\xf8'},{'\xdb','\xd2'},{'\xdb','\xd1'},
+    {'\x00','\x00'},{'\x92','\x60'},{'\xdf','\xfb'},{'\xb8','\xd0'},{'\xe4','\x43'},
+    {'\xe4','\x46'},{'\xe4','\x45'},{'\x00','\x00'},{'\xe4','\x44'},{'\xe7','\xce'},
+    {'\xe7','\xd0'},{'\xe7','\xcf'},{'\xfb','\xaf'},{'\xbf','\xcc'},{'\x93','\xe1'},
+    {'\x00','\x00'},{'\x95','\xc5'},{'\xbf','\xcb'},{'\x00','\x00'},{'\xc1','\xbb'},
+    {'\xee','\x79'},{'\xee','\x7b'},{'\xee','\x7a'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc2','\xd1'},{'\x92','\x6d'},{'\x00','\x00'},{'\x00','\x00'},{'\xf2','\xf4'},
+    {'\xf2','\xf3'},{'\x00','\x00'},{'\xf4','\xcc'},{'\xc4','\xb1'},{'\x00','\x00'},
+    {'\xfd','\x71'},{'\xc4','\xfd'},{'\xf7','\x54'},{'\xf7','\x53'},{'\xc6','\x5b'},
+    {'\x83','\x4e'},{'\x8d','\x73'},{'\x00','\x00'},{'\x84','\x7e'},{'\x84','\x7d'},
+    {'\x85','\x53'},{'\x8d','\xe6'},{'\x8c','\xa6'},{'\x8c','\x54'},{'\x8a','\x64'},
+    {'\x8e','\x7e'},{'\x90','\x5c'},{'\x00','\x00'},{'\x89','\x5e'},{'\x8f','\x63'},
+    {'\x8a','\xfc'},{'\x8f','\xc6'},{'\xa8','\xa4'},{'\xd0','\xaf'},{'\xad','\x6f'},
+    {'\xd7','\xc8'},{'\xd7','\xc6'},{'\x00','\x00'},{'\x00','\x00'},{'\xd7','\xc7'},
+    {'\xdb','\xd4'},{'\xdb','\xd5'},{'\xe0','\x43'},{'\xdb','\xd3'},{'\x8a','\xfd'},
+    {'\xdf','\xfc'},{'\xe0','\x41'},{'\xe0','\x40'},{'\xe0','\x42'},{'\xb8','\xd1'},
+    {'\xdf','\xfe'},{'\xdf','\xfd'},{'\xe0','\x44'},{'\x91','\x73'},{'\xe4','\x49'},
+    {'\xe4','\x47'},{'\x00','\x00'},{'\xe4','\x48'},{'\xe7','\xd3'},{'\xe7','\xd1'},
+    {'\x00','\x00'},{'\x8f','\xc7'},{'\xe7','\xd2'},{'\xeb','\x7d'},{'\xee','\x7c'},
+    {'\xee','\x7d'},{'\xc2','\xd2'},{'\x00','\x00'},{'\xf2','\xf5'},{'\xf4','\xcd'},
+    {'\xc4','\xb2'},{'\x00','\x00'},{'\xf6','\x4c'},{'\xf7','\x55'},{'\xc5','\xa9'},
+    {'\x00','\x00'},{'\xf7','\xfe'},{'\xf9','\x4c'},{'\xa8','\xa5'},{'\x00','\x00'},
+    {'\xad','\x71'},{'\xad','\x72'},{'\xd0','\xb0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xd0','\xb1'},{'\xad','\x70'},{'\x00','\x00'},{'\xb0','\x54'},{'\x00','\x00'},
+    {'\xb0','\x52'},{'\x00','\x00'},{'\xb0','\x51'},{'\xb0','\x58'},{'\xb0','\x50'},
+    {'\xb0','\x59'},{'\xd3','\xdd'},{'\xb0','\x56'},{'\x00','\x00'},{'\xb0','\x53'},
+    {'\xb0','\x57'},{'\xb0','\x55'},{'\xb0','\x4f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb3','\x5f'},{'\xfe','\xd4'},{'\xb3','\x59'},{'\xd7','\xcc'},{'\xb3','\x5e'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb3','\x60'},{'\xb3','\x5a'},{'\x00','\x00'},
+    {'\xb3','\x5b'},{'\x00','\x00'},{'\xd7','\xca'},{'\x00','\x00'},{'\xfe','\xd5'},
+    {'\xb3','\x58'},{'\xfe','\xd6'},{'\xd7','\xcb'},{'\xb3','\x5d'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd7','\xc9'},{'\xb3','\x5c'},{'\x00','\x00'},{'\x93','\xd5'},
+    {'\xb6','\x44'},{'\x00','\x00'},{'\xb6','\x46'},{'\x91','\x74'},{'\xfe','\xd7'},
+    {'\xdb','\xd8'},{'\xb6','\x45'},{'\xb5','\xf9'},{'\xb5','\xfd'},{'\xfe','\xd8'},
+    {'\xb8','\xe4'},{'\xe0','\x49'},{'\xdb','\xda'},{'\xb5','\xfe'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xdb','\xdd'},{'\xdb','\xde'},{'\xb6','\x43'},{'\x00','\x00'},
+    {'\xdb','\xe0'},{'\xfd','\x73'},{'\xdb','\xe2'},{'\x00','\x00'},{'\xdb','\xe3'},
+    {'\xdb','\xd7'},{'\xdb','\xd6'},{'\xdb','\xe4'},{'\xb6','\x42'},{'\xdb','\xe1'},
+    {'\xdb','\xdf'},{'\x00','\x00'},{'\xb6','\x40'},{'\xb5','\xfb'},{'\xb6','\x47'},
+    {'\xdb','\xdb'},{'\xdb','\xdc'},{'\xdb','\xd9'},{'\x00','\x00'},{'\xb6','\x41'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb5','\xfc'},{'\x00','\x00'},{'\xb5','\xfa'},
+    {'\xe0','\x48'},{'\xb8','\xdf'},{'\xb8','\xda'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb8','\xd5'},{'\xfc','\xda'},{'\xb8','\xe5'},{'\xb8','\xd6'},{'\x00','\x00'},
+    {'\xb8','\xd2'},{'\xb8','\xe1'},{'\xb8','\xde'},{'\xb8','\xe0'},{'\x00','\x00'},
+    {'\xb8','\xd7'},{'\xb8','\xdc'},{'\xb8','\xd3'},{'\xb8','\xd4'},{'\xe0','\x50'},
+    {'\xe0','\x4d'},{'\xe0','\x45'},{'\xe0','\x4a'},{'\x00','\x00'},{'\xb8','\xe2'},
+    {'\xe0','\x51'},{'\xb8','\xe3'},{'\xb8','\xd9'},{'\x00','\x00'},{'\xfd','\x72'},
+    {'\xe0','\x47'},{'\x00','\x00'},{'\xe0','\x4f'},{'\xe0','\x4b'},{'\xe0','\x4e'},
+    {'\xe0','\x4c'},{'\xb8','\xdd'},{'\xe0','\x46'},{'\xb8','\xd8'},{'\x00','\x00'},
+    {'\x8c','\xa9'},{'\x8a','\x6c'},{'\xe4','\x4c'},{'\xbb','\x78'},{'\xbb','\x7b'},
+    {'\x00','\x00'},{'\xe4','\x4e'},{'\xfe','\xda'},{'\xbb','\xa5'},{'\xe4','\x4d'},
+    {'\xbb','\x7d'},{'\xfe','\xdb'},{'\xbd','\xcf'},{'\xe4','\x4f'},{'\x00','\x00'},
+    {'\xbb','\xa4'},{'\xe4','\x4b'},{'\xbb','\xa6'},{'\x00','\x00'},{'\xfe','\xdc'},
+    {'\x00','\x00'},{'\xbb','\x79'},{'\x00','\x00'},{'\xb8','\xdb'},{'\xbb','\x7c'},
+    {'\x00','\x00'},{'\xbb','\x7a'},{'\xbb','\x7e'},{'\xbb','\xa2'},{'\xbb','\x77'},
+    {'\xbb','\xa7'},{'\xbb','\xa3'},{'\xfe','\xdd'},{'\xbb','\xa1'},{'\xe4','\x4a'},
+    {'\x91','\x75'},{'\x93','\xab'},{'\x00','\x00'},{'\xfe','\xde'},{'\xbd','\xd6'},
+    {'\x00','\x00'},{'\xbd','\xd2'},{'\x00','\x00'},{'\xfe','\xdf'},{'\x00','\x00'},
+    {'\xbd','\xd9'},{'\x00','\x00'},{'\xe7','\xd6'},{'\xbd','\xda'},{'\xe7','\xe2'},
+    {'\xe7','\xdb'},{'\xbd','\xcb'},{'\xe7','\xe3'},{'\xe7','\xdd'},{'\xbd','\xd5'},
+    {'\xe7','\xde'},{'\x00','\x00'},{'\xbd','\xd4'},{'\xe7','\xe1'},{'\xbd','\xce'},
+    {'\xe7','\xdf'},{'\xe7','\xd5'},{'\xbd','\xcd'},{'\xeb','\xaa'},{'\xbd','\xd3'},
+    {'\x00','\x00'},{'\xbd','\xd0'},{'\x82','\x51'},{'\xbd','\xd8'},{'\x00','\x00'},
+    {'\xe7','\xd4'},{'\x00','\x00'},{'\xe7','\xd8'},{'\xbd','\xcc'},{'\xe7','\xd7'},
+    {'\xe7','\xd9'},{'\xe7','\xda'},{'\xbd','\xd7'},{'\xe7','\xdc'},{'\xe7','\xe0'},
+    {'\xe7','\xe4'},{'\x91','\x76'},{'\xbd','\xdb'},{'\xbf','\xd2'},{'\xeb','\xa5'},
+    {'\xeb','\xab'},{'\xeb','\xa8'},{'\xeb','\x7e'},{'\xeb','\xac'},{'\xeb','\xa1'},
+    {'\x00','\x00'},{'\xeb','\xa7'},{'\x00','\x00'},{'\xbf','\xcd'},{'\xbf','\xd3'},
+    {'\xeb','\xad'},{'\x00','\x00'},{'\xfe','\xe0'},{'\xbf','\xcf'},{'\x00','\x00'},
+    {'\xbf','\xd9'},{'\xbf','\xd4'},{'\xeb','\xaf'},{'\xeb','\xa9'},{'\xbf','\xd0'},
+    {'\xeb','\xa2'},{'\xbf','\xda'},{'\xeb','\xa3'},{'\xeb','\xa4'},{'\xbf','\xdb'},
+    {'\xbf','\xd8'},{'\xbd','\xd1'},{'\x9d','\xd1'},{'\xbf','\xce'},{'\xeb','\xb0'},
+    {'\xbf','\xdc'},{'\x00','\x00'},{'\xbf','\xd5'},{'\xeb','\xae'},{'\xbf','\xd1'},
+    {'\xbf','\xd6'},{'\xbf','\xd7'},{'\x00','\x00'},{'\xc1','\xc3'},{'\xee','\xa4'},
+    {'\xee','\xad'},{'\xee','\xaa'},{'\xee','\xac'},{'\x00','\x00'},{'\xc1','\xc0'},
+    {'\xee','\xa5'},{'\xfd','\x74'},{'\xee','\xab'},{'\xc1','\xbc'},{'\xee','\xa7'},
+    {'\xc1','\xc4'},{'\xee','\xa3'},{'\xee','\xa8'},{'\xee','\xaf'},{'\xeb','\xa6'},
+    {'\xee','\xa9'},{'\xee','\xa2'},{'\xc1','\xbd'},{'\xee','\xa1'},{'\xc1','\xbe'},
+    {'\xee','\xb0'},{'\xc1','\xbf'},{'\xee','\xae'},{'\xc1','\xc2'},{'\xee','\x7e'},
+    {'\xfe','\xe1'},{'\xc1','\xc1'},{'\x93','\xdc'},{'\xee','\xa6'},{'\xf0','\xdc'},
+    {'\xf0','\xea'},{'\xf0','\xe5'},{'\xf0','\xe7'},{'\xf0','\xdb'},{'\xc2','\xd3'},
+    {'\x00','\x00'},{'\xf0','\xda'},{'\xc2','\xd6'},{'\xc2','\xd5'},{'\x96','\xc1'},
+    {'\xf0','\xe9'},{'\xf0','\xe1'},{'\xf0','\xde'},{'\xf0','\xe4'},{'\x00','\x00'},
+    {'\xf0','\xdd'},{'\x00','\x00'},{'\xf0','\xdf'},{'\xf0','\xe8'},{'\xf0','\xe6'},
+    {'\x00','\x00'},{'\xc2','\xd4'},{'\xf0','\xed'},{'\xf0','\xeb'},{'\xf0','\xe2'},
+    {'\xf0','\xec'},{'\xf0','\xe3'},{'\xfe','\xe3'},{'\xf2','\xf9'},{'\xc3','\xcf'},
+    {'\xf3','\x41'},{'\xfd','\x75'},{'\x00','\x00'},{'\xf6','\x4f'},{'\xc3','\xd6'},
+    {'\xf0','\xe0'},{'\xf2','\xf7'},{'\xc3','\xd2'},{'\xf2','\xf8'},{'\xf2','\xfd'},
+    {'\xfd','\x77'},{'\xfe','\xe4'},{'\xc3','\xd4'},{'\xc3','\xd5'},{'\xf2','\xf6'},
+    {'\xf3','\x40'},{'\xf3','\x42'},{'\xf2','\xfa'},{'\xf2','\xfc'},{'\xf2','\xfe'},
+    {'\xf2','\xfb'},{'\xf3','\x43'},{'\xc3','\xd1'},{'\xc3','\xd7'},{'\xc3','\xd3'},
+    {'\x91','\x77'},{'\xc3','\xd0'},{'\xf4','\xd0'},{'\xfe','\xe5'},{'\xc4','\xb7'},
+    {'\xf4','\xce'},{'\x00','\x00'},{'\xfe','\xe6'},{'\xf4','\xd2'},{'\x00','\x00'},
+    {'\xf4','\xd3'},{'\xc4','\xb5'},{'\xf4','\xd4'},{'\xf4','\xd1'},{'\xfe','\xe7'},
+    {'\xf4','\xcf'},{'\xc4','\xb8'},{'\xc4','\xb4'},{'\xf4','\xd5'},{'\x00','\x00'},
+    {'\xc4','\xb6'},{'\xc4','\xb3'},{'\x91','\x78'},{'\x92','\xf0'},{'\x00','\x00'},
+    {'\xc4','\xfe'},{'\x00','\x00'},{'\x00','\x00'},{'\xc5','\x40'},{'\xf6','\x4e'},
+    {'\xf6','\x4d'},{'\xf6','\x50'},{'\xf6','\x51'},{'\x00','\x00'},{'\xc5','\x41'},
+    {'\xf7','\x56'},{'\xf7','\x5b'},{'\xc5','\xaa'},{'\xfd','\x76'},{'\xf7','\x58'},
+    {'\x82','\x63'},{'\xf7','\x57'},{'\xf7','\x5a'},{'\xf7','\x59'},{'\x00','\x00'},
+    {'\xf8','\x43'},{'\x00','\x00'},{'\xc5','\xdc'},{'\xf8','\x42'},{'\xf8','\x40'},
+    {'\x00','\x00'},{'\xf8','\x41'},{'\x00','\x00'},{'\x95','\xf8'},{'\x00','\x00'},
+    {'\xc5','\xfe'},{'\xc5','\xfd'},{'\xf8','\xc1'},{'\xf8','\xc2'},{'\xc6','\x40'},
+    {'\x00','\x00'},{'\xf9','\x4d'},{'\xf9','\x4e'},{'\xc6','\x67'},{'\xfe','\xe8'},
+    {'\xc6','\x6d'},{'\x00','\x00'},{'\xf9','\xa9'},{'\xf9','\xc8'},{'\x9c','\xec'},
+    {'\x83','\x79'},{'\x83','\x7a'},{'\x83','\x7b'},{'\x87','\x50'},{'\x8b','\xc2'},
+    {'\x83','\xd4'},{'\x83','\xd6'},{'\x83','\xd5'},{'\x8d','\x58'},{'\x83','\xd7'},
+    {'\x83','\xda'},{'\x00','\x00'},{'\x83','\xd9'},{'\x8c','\x56'},{'\x83','\xd8'},
+    {'\x83','\xd3'},{'\x00','\x00'},{'\x8a','\x68'},{'\x89','\x62'},{'\x8f','\x7e'},
+    {'\x8d','\xe7'},{'\x84','\xa2'},{'\x84','\xa4'},{'\x84','\xa5'},{'\x84','\xa8'},
+    {'\x88','\x62'},{'\x00','\x00'},{'\x84','\xa7'},{'\x89','\x6a'},{'\x84','\xa6'},
+    {'\x84','\xa1'},{'\x84','\xa3'},{'\x85','\x56'},{'\x85','\x57'},{'\x85','\x5e'},
+    {'\x85','\x54'},{'\x85','\x59'},{'\x8b','\xbf'},{'\x00','\x00'},{'\x85','\x5a'},
+    {'\x85','\x5c'},{'\x85','\x5d'},{'\x85','\x5b'},{'\x8f','\x65'},{'\x85','\x55'},
+    {'\x8d','\xe8'},{'\x85','\x58'},{'\x00','\x00'},{'\x8c','\x57'},{'\x8d','\xe9'},
+    {'\x8e','\x4f'},{'\x8e','\x52'},{'\x86','\x49'},{'\x8e','\x50'},{'\x86','\x4a'},
+    {'\x86','\x4b'},{'\x86','\x4c'},{'\x86','\x4e'},{'\x86','\x50'},{'\x8e','\x53'},
+    {'\x86','\x4f'},{'\x88','\x5a'},{'\x86','\x54'},{'\x86','\x53'},{'\x86','\x51'},
+    {'\x86','\x52'},{'\x86','\x4d'},{'\x88','\x63'},{'\x86','\x47'},{'\x86','\x48'},
+    {'\x86','\x46'},{'\x8e','\xf8'},{'\x8e','\x51'},{'\x00','\x00'},{'\x87','\x51'},
+    {'\x87','\x4f'},{'\x87','\x4e'},{'\x87','\x58'},{'\x87','\x52'},{'\x87','\x54'},
+    {'\x87','\x56'},{'\x87','\x55'},{'\x87','\x57'},{'\x87','\x53'},{'\x87','\x4d'},
+    {'\x8e','\xa1'},{'\x88','\x5b'},{'\x88','\x5c'},{'\x8e','\xcb'},{'\x89','\x67'},
+    {'\x8c','\xdd'},{'\x8e','\xcc'},{'\x88','\x65'},{'\x88','\x5d'},{'\x88','\x5e'},
+    {'\x88','\x66'},{'\x88','\x61'},{'\x8e','\xcd'},{'\x88','\x60'},{'\x88','\x5f'},
+    {'\x88','\x57'},{'\x88','\x59'},{'\x88','\x64'},{'\x88','\x58'},{'\x00','\x00'},
+    {'\x88','\x56'},{'\x89','\x63'},{'\x89','\x6d'},{'\x89','\x64'},{'\x8a','\x69'},
+    {'\x89','\x61'},{'\x89','\x65'},{'\x8e','\xf9'},{'\x89','\x68'},{'\x89','\x69'},
+    {'\x8e','\xfa'},{'\x89','\x6b'},{'\x89','\x6e'},{'\x8d','\x59'},{'\x89','\x66'},
+    {'\x89','\x6c'},{'\x89','\x60'},{'\x89','\x5f'},{'\x8a','\x65'},{'\x8e','\xfb'},
+    {'\x00','\x00'},{'\x8a','\xfe'},{'\x8d','\xa4'},{'\x8f','\x64'},{'\x8a','\x6b'},
+    {'\x8a','\x6a'},{'\x8a','\x66'},{'\x8f','\x66'},{'\x8a','\x67'},{'\x8a','\x6d'},
+    {'\x8b','\x40'},{'\x8f','\xa1'},{'\x8b','\x42'},{'\x91','\x79'},{'\x8b','\x41'},
+    {'\x8b','\xc0'},{'\x8f','\xc8'},{'\x8b','\xc3'},{'\x90','\x78'},{'\x8b','\xbe'},
+    {'\x8b','\xc1'},{'\x90','\xa6'},{'\x8c','\xa7'},{'\x8c','\x58'},{'\x8d','\x5a'},
+    {'\xa8','\xa6'},{'\x00','\x00'},{'\xd7','\xcd'},{'\x91','\x7a'},{'\xd7','\xce'},
+    {'\xe0','\x52'},{'\xe4','\x50'},{'\xe7','\xe5'},{'\xc1','\xc6'},{'\x00','\x00'},
+    {'\xc1','\xc5'},{'\xf0','\xee'},{'\xf3','\x44'},{'\x00','\x00'},{'\xf8','\x44'},
+    {'\xa8','\xa7'},{'\xd3','\xde'},{'\xb0','\x5a'},{'\xb3','\x61'},{'\xe0','\x54'},
+    {'\xe0','\x53'},{'\xbd','\xdc'},{'\xe7','\xe6'},{'\xbd','\xdd'},{'\xee','\xb1'},
+    {'\xc2','\xd7'},{'\xfe','\xe9'},{'\x00','\x00'},{'\x00','\x00'},{'\xc6','\x76'},
+    {'\xa8','\xa8'},{'\xcd','\xcb'},{'\xd3','\xdf'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb3','\x62'},{'\x00','\x00'},{'\xd7','\xcf'},{'\xd7','\xd0'},{'\x00','\x00'},
+    {'\xdb','\xe5'},{'\x00','\x00'},{'\xb6','\x48'},{'\xb8','\xe6'},{'\x00','\x00'},
+    {'\xe0','\x56'},{'\xe0','\x55'},{'\xe0','\x57'},{'\x00','\x00'},{'\xe4','\x51'},
+    {'\xe4','\x52'},{'\xbb','\xa8'},{'\xbf','\xdd'},{'\xbd','\xde'},{'\xbf','\xde'},
+    {'\x00','\x00'},{'\xee','\xb5'},{'\xee','\xb2'},{'\xee','\xb4'},{'\xee','\xb3'},
+    {'\xc1','\xc7'},{'\x00','\x00'},{'\xf0','\xef'},{'\xf3','\x46'},{'\xf3','\x45'},
+    {'\xcb','\xa4'},{'\xb0','\x5c'},{'\xb0','\x5b'},{'\xd3','\xe0'},{'\x91','\x7b'},
+    {'\xd7','\xd1'},{'\x00','\x00'},{'\x00','\x00'},{'\xdb','\xe7'},{'\xdb','\xe6'},
+    {'\xb6','\x49'},{'\x00','\x00'},{'\xe0','\x59'},{'\xe0','\x5a'},{'\xe0','\x58'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xb8','\xe8'},{'\xb8','\xe7'},{'\x00','\x00'},
+    {'\xbb','\xaa'},{'\xbb','\xa9'},{'\x91','\x7c'},{'\xe7','\xe7'},{'\xeb','\xb3'},
+    {'\xeb','\xb1'},{'\xeb','\xb2'},{'\xbf','\xdf'},{'\xee','\xb7'},{'\xee','\xb6'},
+    {'\x00','\x00'},{'\xf0','\xf2'},{'\xf0','\xf1'},{'\xf0','\xf0'},{'\xf3','\x47'},
+    {'\xfe','\xea'},{'\xf9','\xaa'},{'\xa8','\xa9'},{'\xad','\x73'},{'\xfe','\xeb'},
+    {'\xad','\x74'},{'\xb0','\x5d'},{'\xb0','\x5e'},{'\xd3','\xe2'},{'\xd3','\xe1'},
+    {'\xd7','\xd2'},{'\x00','\x00'},{'\xb3','\x68'},{'\xb3','\x66'},{'\xb3','\x63'},
+    {'\xb3','\x67'},{'\xb3','\x65'},{'\xb3','\x64'},{'\xfd','\x79'},{'\x91','\x7d'},
+    {'\xb6','\x4a'},{'\xdb','\xea'},{'\x00','\x00'},{'\xb8','\xed'},{'\xb6','\x4c'},
+    {'\xb6','\x51'},{'\xdb','\xec'},{'\xb6','\x53'},{'\xb6','\x52'},{'\xb6','\x55'},
+    {'\xdb','\xeb'},{'\xdb','\xe8'},{'\xb6','\x4f'},{'\xb6','\x4b'},{'\xb6','\x4d'},
+    {'\xdb','\xe9'},{'\xb6','\x54'},{'\xb6','\x50'},{'\xb6','\x4e'},{'\xb8','\xef'},
+    {'\xb8','\xee'},{'\xb8','\xec'},{'\xb8','\xf0'},{'\x00','\x00'},{'\xb8','\xea'},
+    {'\xb8','\xeb'},{'\x00','\x00'},{'\xb8','\xe9'},{'\x00','\x00'},{'\xe0','\x5b'},
+    {'\x95','\x60'},{'\x82','\x62'},{'\xe4','\x54'},{'\x00','\x00'},{'\xbb','\xac'},
+    {'\xbb','\xad'},{'\xbb','\xab'},{'\xfe','\xec'},{'\xe4','\x53'},{'\xfe','\xed'},
+    {'\xe4','\x55'},{'\x00','\x00'},{'\xe7','\xea'},{'\xe7','\xec'},{'\x92','\xce'},
+    {'\xbd','\xe7'},{'\xe7','\xed'},{'\xbd','\xe0'},{'\xe7','\xe9'},{'\xbd','\xdf'},
+    {'\xbd','\xe9'},{'\xbd','\xe5'},{'\xbd','\xe6'},{'\xbd','\xe2'},{'\xe7','\xe8'},
+    {'\xbd','\xe1'},{'\xe7','\xee'},{'\xe7','\xeb'},{'\x9e','\x40'},{'\xbd','\xe8'},
+    {'\xfd','\x7a'},{'\xbd','\xe3'},{'\xbd','\xe4'},{'\xeb','\xb5'},{'\x00','\x00'},
+    {'\xeb','\xb7'},{'\xeb','\xb6'},{'\x9e','\x41'},{'\xeb','\xb8'},{'\xbf','\xe0'},
+    {'\xeb','\xb4'},{'\x00','\x00'},{'\xfd','\x7b'},{'\xc1','\xcb'},{'\xee','\xb8'},
+    {'\xc1','\xc8'},{'\xc1','\xcc'},{'\xc1','\xca'},{'\xc1','\xc9'},{'\xf0','\xf3'},
+    {'\x00','\x00'},{'\xf0','\xf6'},{'\x00','\x00'},{'\xf0','\xf5'},{'\x9e','\x42'},
+    {'\xf0','\xf4'},{'\xc2','\xd8'},{'\xf3','\x48'},{'\xf3','\x49'},{'\xc3','\xd8'},
+    {'\xf3','\x4a'},{'\xc3','\xd9'},{'\x82','\x57'},{'\xfd','\x7c'},{'\xc4','\xba'},
+    {'\x00','\x00'},{'\xc4','\xb9'},{'\xf6','\x52'},{'\x9e','\x43'},{'\x91','\x7e'},
+    {'\xc5','\x42'},{'\xf6','\x53'},{'\xf7','\x5c'},{'\xc5','\xab'},{'\xc5','\xac'},
+    {'\x95','\x76'},{'\xf8','\x45'},{'\x00','\x00'},{'\xc6','\x42'},{'\x9e','\x44'},
+    {'\x83','\x50'},{'\x83','\x7c'},{'\x83','\x7d'},{'\x00','\x00'},{'\x83','\xdd'},
+    {'\x83','\xdc'},{'\x84','\xaa'},{'\x88','\x6e'},{'\x84','\x50'},{'\x88','\x6c'},
+    {'\x84','\xac'},{'\x88','\x71'},{'\x84','\xa9'},{'\x84','\xad'},{'\x84','\xae'},
+    {'\x85','\x68'},{'\x8a','\x70'},{'\x85','\x5f'},{'\x84','\xab'},{'\x85','\x61'},
+    {'\x88','\x6b'},{'\x85','\x63'},{'\x8d','\xeb'},{'\x85','\x60'},{'\x85','\x66'},
+    {'\x8d','\xea'},{'\x85','\x6a'},{'\x85','\x69'},{'\x85','\x64'},{'\x85','\x65'},
+    {'\x85','\x62'},{'\x86','\x55'},{'\x8f','\xa3'},{'\x86','\x57'},{'\x86','\x58'},
+    {'\x86','\x59'},{'\x86','\x5a'},{'\x86','\x5b'},{'\x8c','\xaa'},{'\x86','\x56'},
+    {'\x86','\x5c'},{'\x90','\x47'},{'\x8e','\xa2'},{'\x87','\x5a'},{'\x91','\xa1'},
+    {'\x87','\x5b'},{'\x88','\x6a'},{'\x88','\x6d'},{'\x91','\xa2'},{'\x8c','\xde'},
+    {'\x88','\x69'},{'\x88','\x70'},{'\x00','\x00'},{'\x00','\x00'},{'\x88','\x72'},
+    {'\x88','\x68'},{'\x8e','\xce'},{'\x89','\x6f'},{'\x00','\x00'},{'\x8b','\x43'},
+    {'\x8a','\x71'},{'\x8a','\x6e'},{'\x8a','\x6f'},{'\x8f','\xa2'},{'\x8c','\xdf'},
+    {'\x8b','\xc5'},{'\x00','\x00'},{'\x8b','\xc4'},{'\x8c','\x5a'},{'\x8c','\x59'},
+    {'\x8d','\x5c'},{'\xa8','\xaa'},{'\x00','\x00'},{'\xb3','\x6a'},{'\xb3','\x69'},
+    {'\xe0','\x5c'},{'\xe0','\x5d'},{'\x00','\x00'},{'\xbb','\xae'},{'\xeb','\xb9'},
+    {'\xbd','\xea'},{'\xeb','\xba'},{'\xee','\xb9'},{'\xa8','\xab'},{'\x91','\xa3'},
+    {'\xd0','\xb2'},{'\xad','\x76'},{'\xad','\x75'},{'\x87','\x5c'},{'\xd3','\xe3'},
+    {'\xb0','\x5f'},{'\xd3','\xe4'},{'\xd7','\xd5'},{'\x9e','\x45'},{'\xd7','\xd4'},
+    {'\x00','\x00'},{'\xd7','\xd3'},{'\x00','\x00'},{'\x00','\x00'},{'\xdb','\xee'},
+    {'\xb6','\x58'},{'\xfd','\x7d'},{'\x00','\x00'},{'\xdb','\xed'},{'\xb6','\x57'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xdb','\xef'},{'\xb6','\x56'},
+    {'\x8a','\x72'},{'\xe0','\x5f'},{'\xe0','\x62'},{'\xe0','\x60'},{'\xe0','\x61'},
+    {'\xe0','\x65'},{'\xe0','\x5e'},{'\xe0','\x66'},{'\xe0','\x63'},{'\xe0','\x64'},
+    {'\xbb','\xb0'},{'\xe4','\x56'},{'\x00','\x00'},{'\x00','\x00'},{'\xbb','\xaf'},
+    {'\x00','\x00'},{'\xe7','\xf2'},{'\xe7','\xf0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xbd','\xeb'},{'\xe7','\xef'},{'\xe7','\xf1'},{'\x00','\x00'},{'\xbd','\xec'},
+    {'\x00','\x00'},{'\xeb','\xbb'},{'\xfd','\x7e'},{'\xeb','\xbc'},{'\xc1','\xcd'},
+    {'\x9e','\x46'},{'\xf3','\x4c'},{'\xf3','\x4e'},{'\xf3','\x4b'},{'\xf3','\x4d'},
+    {'\xf4','\xd6'},{'\xf6','\x54'},{'\x00','\x00'},{'\x90','\xa3'},{'\xf9','\x6f'},
+    {'\xa8','\xac'},{'\xad','\x77'},{'\xd3','\xe5'},{'\xd3','\xe7'},{'\xd3','\xe6'},
+    {'\x8c','\x5b'},{'\xd7','\xd8'},{'\xb3','\x6c'},{'\x00','\x00'},{'\xd7','\xd6'},
+    {'\x00','\x00'},{'\xb3','\x6b'},{'\xd7','\xd9'},{'\x9e','\x47'},{'\xd7','\xda'},
+    {'\xd7','\xd7'},{'\x8c','\xac'},{'\x8f','\x67'},{'\xdb','\xfb'},{'\xb6','\x60'},
+    {'\xdb','\xf3'},{'\xdb','\xf9'},{'\x00','\x00'},{'\x00','\x00'},{'\xb6','\x5b'},
+    {'\xb6','\x5e'},{'\xdb','\xf2'},{'\xb6','\x59'},{'\xdb','\xf6'},{'\xe0','\x6c'},
+    {'\xb6','\x5d'},{'\x00','\x00'},{'\xdb','\xf1'},{'\xfd','\xa1'},{'\xdb','\xf7'},
+    {'\xdb','\xf4'},{'\xdb','\xfa'},{'\xdb','\xf0'},{'\xdb','\xf8'},{'\xb6','\x5c'},
+    {'\xb6','\x5f'},{'\xdb','\xf5'},{'\xb6','\x5a'},{'\x90','\x5e'},{'\xb8','\xf2'},
+    {'\xe0','\x68'},{'\xb8','\xf1'},{'\xe0','\x6f'},{'\xe0','\x6e'},{'\xb8','\xf8'},
+    {'\x00','\x00'},{'\xb8','\xf9'},{'\xe0','\x70'},{'\xb8','\xf3'},{'\xe0','\x6d'},
+    {'\xb8','\xf7'},{'\xe0','\x72'},{'\xe0','\x69'},{'\x00','\x00'},{'\xe0','\x6b'},
+    {'\xb8','\xf4'},{'\xe0','\x67'},{'\xe0','\x6a'},{'\xe0','\x71'},{'\xb8','\xf5'},
+    {'\xe0','\x73'},{'\x88','\x73'},{'\x00','\x00'},{'\x8b','\xc6'},{'\x8b','\x46'},
+    {'\x90','\x5d'},{'\xb8','\xf6'},{'\x8c','\xad'},{'\xbb','\xb1'},{'\xe4','\x5b'},
+    {'\xe4','\x61'},{'\xe4','\x59'},{'\xe4','\x62'},{'\x9e','\x48'},{'\xe4','\x58'},
+    {'\xe4','\x5d'},{'\xe4','\x63'},{'\xe4','\x60'},{'\xe4','\x5f'},{'\xe4','\x5e'},
+    {'\x91','\xa4'},{'\xe4','\x57'},{'\xe4','\x5c'},{'\x00','\x00'},{'\x8c','\xab'},
+    {'\xe4','\x5a'},{'\x9e','\x49'},{'\xbd','\xf1'},{'\xbd','\xee'},{'\xe7','\xfb'},
+    {'\xe8','\x41'},{'\xe8','\x43'},{'\xe8','\x40'},{'\xe7','\xf8'},{'\xe7','\xfa'},
+    {'\xe8','\x45'},{'\xe8','\x42'},{'\xe7','\xfc'},{'\xe8','\x46'},{'\xe7','\xf9'},
+    {'\xe8','\x44'},{'\xbd','\xef'},{'\xbd','\xf5'},{'\xbd','\xf3'},{'\xe7','\xf3'},
+    {'\xbd','\xf4'},{'\xbd','\xf0'},{'\xe7','\xf4'},{'\xe7','\xf6'},{'\xe7','\xf5'},
+    {'\xe7','\xfd'},{'\xe7','\xfe'},{'\xfd','\xa2'},{'\xbd','\xf2'},{'\x95','\x57'},
+    {'\xbd','\xed'},{'\x8c','\xe1'},{'\xfb','\x6d'},{'\xe7','\xf7'},{'\x8c','\xe0'},
+    {'\xeb','\xc6'},{'\xbf','\xe2'},{'\x00','\x00'},{'\xeb','\xbd'},{'\xbf','\xe3'},
+    {'\xbf','\xe6'},{'\xeb','\xc2'},{'\x00','\x00'},{'\xeb','\xbf'},{'\xbf','\xe5'},
+    {'\x91','\xa5'},{'\x00','\x00'},{'\xeb','\xc3'},{'\xeb','\xc4'},{'\xeb','\xbe'},
+    {'\xeb','\xc7'},{'\xeb','\xc0'},{'\xeb','\xc5'},{'\xbf','\xe4'},{'\x00','\x00'},
+    {'\xbf','\xe1'},{'\xeb','\xc1'},{'\x9e','\x4a'},{'\xee','\xbf'},{'\xc1','\xd0'},
+    {'\xc1','\xce'},{'\xc1','\xd1'},{'\xc1','\xcf'},{'\xee','\xbe'},{'\xee','\xbb'},
+    {'\xee','\xba'},{'\xfd','\xa3'},{'\xee','\xbd'},{'\x8d','\x74'},{'\x8b','\x44'},
+    {'\xee','\xbc'},{'\xf1','\x45'},{'\xc2','\xde'},{'\xf0','\xfb'},{'\xf0','\xfa'},
+    {'\x00','\x00'},{'\xc2','\xd9'},{'\xf1','\x41'},{'\xf1','\x40'},{'\xf0','\xf7'},
+    {'\xf1','\x43'},{'\xf0','\xfc'},{'\xc2','\xdd'},{'\xf0','\xf9'},{'\xf1','\x42'},
+    {'\xf0','\xf8'},{'\xc2','\xda'},{'\xc2','\xdc'},{'\xf0','\xfd'},{'\xc2','\xdb'},
+    {'\xf0','\xfe'},{'\x9e','\x4b'},{'\xf1','\x44'},{'\xf3','\x52'},{'\x00','\x00'},
+    {'\xc3','\xde'},{'\xf3','\x4f'},{'\x00','\x00'},{'\xf3','\x53'},{'\x91','\xa6'},
+    {'\x9e','\x4c'},{'\xc3','\xdb'},{'\xf3','\x51'},{'\xc3','\xe0'},{'\xfd','\xa5'},
+    {'\xc3','\xdd'},{'\xfd','\xa4'},{'\xf3','\x50'},{'\x00','\x00'},{'\xc3','\xdf'},
+    {'\xf3','\x54'},{'\xc3','\xda'},{'\x00','\x00'},{'\x9e','\x4d'},{'\x90','\x7e'},
+    {'\x9e','\x4e'},{'\xc4','\xbc'},{'\xc4','\xbe'},{'\x00','\x00'},{'\xf4','\xd9'},
+    {'\xc4','\xbd'},{'\xf4','\xd7'},{'\xc3','\xdc'},{'\xf4','\xd8'},{'\xc4','\xbb'},
+    {'\xc5','\x43'},{'\xc5','\x45'},{'\xf6','\x56'},{'\xc5','\x44'},{'\xf6','\x55'},
+    {'\x8d','\xa5'},{'\xf7','\x61'},{'\xc5','\xad'},{'\xf7','\x60'},{'\xc5','\xae'},
+    {'\xf7','\x5e'},{'\xf7','\x5d'},{'\xf7','\x62'},{'\xf7','\x63'},{'\xf8','\x46'},
+    {'\x91','\xa7'},{'\xf7','\x5f'},{'\x00','\x00'},{'\x90','\xa4'},{'\xf8','\xc6'},
+    {'\xf8','\xc3'},{'\xf8','\xc4'},{'\xf8','\xc5'},{'\xc6','\x5c'},{'\x00','\x00'},
+    {'\xf9','\x51'},{'\xf9','\x50'},{'\xf9','\x4f'},{'\xf9','\x70'},{'\xfd','\xa6'},
+    {'\xf9','\xbe'},{'\xf9','\xab'},{'\xc6','\x6e'},{'\xa8','\xad'},{'\xb0','\x60'},
+    {'\x95','\xdf'},{'\x00','\x00'},{'\x82','\x49'},{'\x91','\xa8'},{'\x91','\xa9'},
+    {'\xb8','\xfa'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9e','\x4f'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9e','\x50'},{'\xbd','\xf6'},{'\x00','\x00'},
+    {'\x9e','\x51'},{'\xeb','\xc8'},{'\x94','\xd3'},{'\x00','\x00'},{'\xc2','\xdf'},
+    {'\x00','\x00'},{'\xf3','\x55'},{'\x9e','\x52'},{'\x00','\x00'},{'\x91','\xaa'},
+    {'\x91','\xab'},{'\x00','\x00'},{'\x94','\xd4'},{'\xf9','\xac'},{'\xa8','\xae'},
+    {'\xaa','\xee'},{'\xad','\x79'},{'\xad','\x78'},{'\x91','\xac'},{'\xb0','\x63'},
+    {'\x00','\x00'},{'\xd3','\xe8'},{'\xb0','\x61'},{'\xd3','\xe9'},{'\xb0','\x62'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xd7','\xdf'},{'\xd7','\xdb'},{'\x00','\x00'},
+    {'\xfb','\xa1'},{'\xb3','\x6d'},{'\xd7','\xde'},{'\xd7','\xdd'},{'\xd7','\xdc'},
+    {'\xb3','\x6e'},{'\xd7','\xe0'},{'\xd7','\xe1'},{'\x93','\x7d'},{'\x91','\xad'},
+    {'\x9e','\x53'},{'\xdc','\x43'},{'\xdc','\x41'},{'\xdc','\x45'},{'\xdc','\x46'},
+    {'\xdc','\x4c'},{'\x00','\x00'},{'\xdc','\x48'},{'\xdc','\x4a'},{'\x9e','\x54'},
+    {'\xdc','\x42'},{'\xdb','\xfc'},{'\x00','\x00'},{'\xdc','\x49'},{'\x9e','\x55'},
+    {'\x00','\x00'},{'\xdc','\x4b'},{'\xdc','\x44'},{'\xdc','\x47'},{'\xdb','\xfd'},
+    {'\xb6','\x62'},{'\xdc','\x40'},{'\xdb','\xfe'},{'\xb6','\x61'},{'\xb6','\x63'},
+    {'\x92','\xad'},{'\xb8','\xfd'},{'\xe0','\x75'},{'\xe0','\x77'},{'\xe0','\x76'},
+    {'\xe0','\x7b'},{'\xb8','\xfb'},{'\x00','\x00'},{'\xe0','\x78'},{'\xe0','\x74'},
+    {'\xe0','\x79'},{'\xe0','\x7a'},{'\xb8','\xfc'},{'\xb8','\xfe'},{'\xe0','\x7c'},
+    {'\x91','\xae'},{'\xe4','\x67'},{'\xe4','\x66'},{'\x00','\x00'},{'\xe4','\x64'},
+    {'\xe4','\x65'},{'\xbb','\xb3'},{'\xbb','\xb5'},{'\xbb','\xb2'},{'\xbb','\xb4'},
+    {'\xe8','\x4d'},{'\xe8','\x4e'},{'\xe8','\x49'},{'\xfd','\xa7'},{'\xe8','\x4a'},
+    {'\xbd','\xf8'},{'\xbd','\xfd'},{'\xbd','\xf7'},{'\xbd','\xfe'},{'\xbd','\xf9'},
+    {'\xe8','\x4b'},{'\x00','\x00'},{'\x00','\x00'},{'\xe8','\x4c'},{'\xe8','\x48'},
+    {'\xbe','\x40'},{'\xbd','\xfb'},{'\x00','\x00'},{'\x00','\x00'},{'\xbd','\xfa'},
+    {'\xbd','\xfc'},{'\x00','\x00'},{'\xe8','\x47'},{'\x95','\x70'},{'\xeb','\xca'},
+    {'\xbf','\xe8'},{'\x9e','\x56'},{'\x00','\x00'},{'\xeb','\xcc'},{'\xbf','\xea'},
+    {'\xeb','\xcf'},{'\xeb','\xcb'},{'\xeb','\xc9'},{'\xeb','\xce'},{'\xbf','\xe9'},
+    {'\xeb','\xcd'},{'\x00','\x00'},{'\xbf','\xe7'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc1','\xd3'},{'\xc1','\xd6'},{'\xee','\xc1'},{'\x9e','\x57'},{'\xc1','\xd4'},
+    {'\xee','\xc0'},{'\xc1','\xd2'},{'\xc1','\xd5'},{'\xf1','\x46'},{'\xf1','\x47'},
+    {'\xf1','\x48'},{'\xc2','\xe0'},{'\x9e','\x58'},{'\xf1','\x49'},{'\x94','\xd5'},
+    {'\xc2','\xe1'},{'\xc3','\xe2'},{'\xf3','\x58'},{'\xf3','\x59'},{'\xf3','\x57'},
+    {'\xf3','\x56'},{'\xf3','\x5a'},{'\xc3','\xe1'},{'\xf4','\xdd'},{'\xf4','\xdb'},
+    {'\xf4','\xdc'},{'\xf4','\xde'},{'\xf4','\xda'},{'\xf4','\xdf'},{'\xf6','\x58'},
+    {'\xfd','\xa9'},{'\xf6','\x59'},{'\xf6','\x57'},{'\xc5','\x46'},{'\xf7','\x64'},
+    {'\xc5','\xaf'},{'\xf7','\x65'},{'\xf8','\x48'},{'\xf8','\x47'},{'\x00','\x00'},
+    {'\x83','\x51'},{'\x83','\x61'},{'\x83','\xa1'},{'\x83','\xde'},{'\x00','\x00'},
+    {'\x83','\xdf'},{'\x8b','\x48'},{'\x84','\xaf'},{'\x88','\x79'},{'\x84','\xb0'},
+    {'\x8c','\xae'},{'\x91','\xaf'},{'\x85','\x6b'},{'\x90','\x6e'},{'\x85','\x6c'},
+    {'\x8d','\xed'},{'\x85','\x6d'},{'\x91','\xb0'},{'\x8d','\xee'},{'\x90','\x5f'},
+    {'\x8d','\xec'},{'\x87','\x60'},{'\x86','\x5f'},{'\x86','\x5e'},{'\x86','\x60'},
+    {'\x8b','\xc8'},{'\x00','\x00'},{'\x8e','\x56'},{'\x8e','\x55'},{'\x86','\x5d'},
+    {'\x87','\x5f'},{'\x87','\x5e'},{'\x88','\x75'},{'\x88','\x78'},{'\x88','\x77'},
+    {'\x88','\x74'},{'\x88','\x7c'},{'\x88','\x7b'},{'\x00','\x00'},{'\x88','\x76'},
+    {'\x88','\x7a'},{'\x89','\x73'},{'\x89','\x70'},{'\x89','\x71'},{'\x00','\x00'},
+    {'\x89','\x72'},{'\x8c','\xe2'},{'\x8a','\x76'},{'\x8a','\x73'},{'\x8a','\x74'},
+    {'\x8f','\xa4'},{'\x8b','\x49'},{'\x8b','\xc7'},{'\xa8','\xaf'},{'\xb6','\x64'},
+    {'\x00','\x00'},{'\x8b','\xc9'},{'\xb9','\x40'},{'\xfd','\x41'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xbb','\xb6'},{'\x00','\x00'},{'\x9e','\x59'},{'\xbf','\xec'},
+    {'\x91','\xb1'},{'\xbf','\xeb'},{'\x8c','\xaf'},{'\x00','\x00'},{'\x8c','\x47'},
+    {'\x00','\x00'},{'\xc3','\xe3'},{'\xc4','\x7c'},{'\xc5','\x47'},{'\xa8','\xb0'},
+    {'\xb0','\x64'},{'\xb9','\x41'},{'\x9e','\x5a'},{'\xf3','\x5b'},{'\xc6','\xd6'},
+    {'\x9c','\xe0'},{'\x94','\xd6'},{'\x9e','\x5b'},{'\x8b','\xca'},{'\x93','\xc3'},
+    {'\x94','\x4e'},{'\x94','\x44'},{'\x89','\x77'},{'\x86','\x63'},{'\xcb','\xa6'},
+    {'\x00','\x00'},{'\x88','\x7e'},{'\xa8','\xb1'},{'\x00','\x00'},{'\xa8','\xb4'},
+    {'\xa8','\xb3'},{'\xa8','\xb2'},{'\x86','\x65'},{'\x8a','\x79'},{'\xcb','\xa5'},
+    {'\x9e','\x5c'},{'\xcd','\xcd'},{'\xa0','\xa4'},{'\xcd','\xcf'},{'\xaa','\xef'},
+    {'\x9e','\x5d'},{'\x86','\x62'},{'\xaa','\xf1'},{'\xcd','\xcc'},{'\xcd','\xce'},
+    {'\xaa','\xf0'},{'\xcd','\xd1'},{'\xcd','\xd0'},{'\xcd','\xd2'},{'\x8a','\x78'},
+    {'\x84','\xb1'},{'\x94','\xd7'},{'\x85','\x6e'},{'\x87','\x61'},{'\x86','\x64'},
+    {'\x84','\xb2'},{'\x89','\x76'},{'\xd0','\xb6'},{'\xd0','\xb4'},{'\xad','\x7c'},
+    {'\xd0','\xb3'},{'\xad','\xa3'},{'\xad','\x7e'},{'\xad','\x7b'},{'\x00','\x00'},
+    {'\xad','\xa4'},{'\x8b','\x4a'},{'\xad','\x7d'},{'\xad','\xa2'},{'\x00','\x00'},
+    {'\xad','\xa1'},{'\xd0','\xb5'},{'\x91','\xb2'},{'\xad','\x7a'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x84','\xb3'},{'\xb0','\x6a'},{'\xd3','\xeb'},{'\xd3','\xf1'},
+    {'\xb0','\x67'},{'\xb0','\x6e'},{'\x95','\xd9'},{'\xb0','\x69'},{'\xd3','\xee'},
+    {'\xd3','\xf0'},{'\xb0','\x6c'},{'\xd3','\xea'},{'\xd3','\xed'},{'\xb0','\x68'},
+    {'\xb0','\x65'},{'\xd3','\xec'},{'\xb0','\x6b'},{'\xd3','\xef'},{'\xb0','\x6d'},
+    {'\xb0','\x66'},{'\x00','\x00'},{'\x9e','\x5e'},{'\x89','\x75'},{'\x87','\x62'},
+    {'\xd7','\xe3'},{'\xd7','\xe6'},{'\xb3','\x70'},{'\x91','\xb3'},{'\xb3','\x7a'},
+    {'\xb3','\x76'},{'\xd7','\xe4'},{'\x87','\x63'},{'\x93','\x7a'},{'\xb3','\x7e'},
+    {'\xb3','\x77'},{'\xb3','\x7c'},{'\xb3','\x72'},{'\x00','\x00'},{'\xb3','\x6f'},
+    {'\xb3','\x71'},{'\xb3','\x7d'},{'\xd7','\xe5'},{'\xb3','\x75'},{'\xb3','\x78'},
+    {'\xb3','\x74'},{'\xb3','\x79'},{'\xd7','\xe7'},{'\xb3','\x7b'},{'\xb3','\x73'},
+    {'\xd7','\xe2'},{'\x00','\x00'},{'\x8d','\x41'},{'\x94','\xd8'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xdc','\x4d'},
+    {'\xb6','\x65'},{'\xdc','\x4f'},{'\x00','\x00'},{'\xb6','\x67'},{'\xb6','\x69'},
+    {'\x9e','\x5f'},{'\xdc','\x4e'},{'\xb6','\x66'},{'\xb6','\x6a'},{'\x9e','\x60'},
+    {'\xb6','\x68'},{'\x91','\xb4'},{'\x00','\x00'},{'\x8d','\x42'},{'\xb9','\x47'},
+    {'\xe0','\xa3'},{'\xb9','\x4f'},{'\xe0','\x7e'},{'\x00','\x00'},{'\xb9','\x50'},
+    {'\xb9','\x45'},{'\x00','\x00'},{'\xe0','\xa1'},{'\x93','\x72'},{'\x00','\x00'},
+    {'\xb9','\x4a'},{'\x00','\x00'},{'\xe0','\xa2'},{'\xb9','\x43'},{'\xb9','\x42'},
+    {'\xfd','\xb6'},{'\xb9','\x4d'},{'\xb9','\x4c'},{'\xb9','\x4b'},{'\xb9','\x49'},
+    {'\xb9','\x4e'},{'\xe0','\x7d'},{'\xb9','\x44'},{'\xb9','\x46'},{'\xb9','\x48'},
+    {'\xfd','\xb5'},{'\x89','\x78'},{'\xbb','\xb8'},{'\xbb','\xbb'},{'\x00','\x00'},
+    {'\xbb','\xbf'},{'\xbb','\xb9'},{'\xbb','\xbe'},{'\xbb','\xbc'},{'\x00','\x00'},
+    {'\xbb','\xb7'},{'\xfe','\x61'},{'\xbb','\xbd'},{'\xbb','\xba'},{'\x9e','\x61'},
+    {'\x91','\xb5'},{'\x00','\x00'},{'\xe8','\x52'},{'\xbe','\x43'},{'\xbe','\x41'},
+    {'\x00','\x00'},{'\xe8','\x53'},{'\x9e','\x62'},{'\xbe','\x44'},{'\xbe','\x42'},
+    {'\xe8','\x51'},{'\xe8','\x50'},{'\x00','\x00'},{'\xbf','\xf0'},{'\xe8','\x4f'},
+    {'\xbf','\xee'},{'\xbf','\xed'},{'\xeb','\xd0'},{'\xbe','\x45'},{'\xbf','\xef'},
+    {'\xeb','\xd1'},{'\xbf','\xf2'},{'\xeb','\xd2'},{'\xbf','\xf1'},{'\xc1','\xd8'},
+    {'\xee','\xc3'},{'\xc1','\xd7'},{'\xc1','\xdc'},{'\xc1','\xda'},{'\xc1','\xdb'},
+    {'\xc2','\xe3'},{'\xc1','\xd9'},{'\xee','\xc2'},{'\xeb','\xd3'},{'\xc2','\xe2'},
+    {'\xc2','\xe4'},{'\x91','\xb6'},{'\xc3','\xe4'},{'\xc3','\xe5'},{'\x00','\x00'},
+    {'\xf4','\xe0'},{'\x00','\x00'},{'\xc5','\xde'},{'\xc5','\xdd'},{'\xa8','\xb6'},
+    {'\x00','\x00'},{'\x88','\xa3'},{'\xca','\x55'},{'\xb0','\x6f'},{'\x00','\x00'},
+    {'\xca','\x52'},{'\xca','\x53'},{'\xca','\x51'},{'\x00','\x00'},{'\xca','\x54'},
+    {'\x00','\x00'},{'\x8f','\xa5'},{'\xcb','\xaa'},{'\xcb','\xa7'},{'\xcb','\xac'},
+    {'\xcb','\xa8'},{'\xa8','\xb7'},{'\xa8','\xba'},{'\x00','\x00'},{'\xcb','\xa9'},
+    {'\xa8','\xb9'},{'\xcb','\xab'},{'\x95','\x40'},{'\x00','\x00'},{'\xa8','\xb8'},
+    {'\x00','\x00'},{'\x8e','\x57'},{'\x00','\x00'},{'\x85','\x6f'},{'\xcd','\xd5'},
+    {'\xcd','\xd7'},{'\xaa','\xf4'},{'\xcd','\xd3'},{'\xcd','\xd6'},{'\xcd','\xd4'},
+    {'\xaa','\xf2'},{'\xaa','\xf5'},{'\x00','\x00'},{'\xaa','\xf3'},{'\x86','\x66'},
+    {'\x89','\x79'},{'\x88','\xa1'},{'\x00','\x00'},{'\xd0','\xb8'},{'\xd0','\xbc'},
+    {'\xd0','\xb9'},{'\x00','\x00'},{'\xad','\xa7'},{'\x00','\x00'},{'\xad','\xa8'},
+    {'\xfd','\xab'},{'\xd0','\xbb'},{'\x00','\x00'},{'\xd0','\xbd'},{'\xd0','\xbf'},
+    {'\x00','\x00'},{'\xad','\xa5'},{'\xd0','\xbe'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xad','\xa6'},{'\x8d','\xc6'},{'\x8e','\xfc'},{'\x88','\xa2'},{'\x00','\x00'},
+    {'\x8d','\xf0'},{'\xd7','\xee'},{'\xd0','\xba'},{'\xd3','\xf2'},{'\xd3','\xfb'},
+    {'\xd3','\xf9'},{'\xd3','\xf4'},{'\xd3','\xf5'},{'\xd3','\xfa'},{'\xd3','\xfc'},
+    {'\xb0','\x71'},{'\x91','\xb7'},{'\xd3','\xf7'},{'\xd3','\xf3'},{'\xb0','\x70'},
+    {'\xb0','\x72'},{'\xd3','\xf6'},{'\xd3','\xfd'},{'\xd3','\xf8'},{'\x8c','\xe3'},
+    {'\x90','\xbb'},{'\xb3','\xa1'},{'\xd7','\xf1'},{'\xd7','\xe9'},{'\xd7','\xef'},
+    {'\xd7','\xf0'},{'\xb3','\xa2'},{'\x00','\x00'},{'\xd7','\xe8'},{'\xd7','\xea'},
+    {'\xd0','\xb7'},{'\xd7','\xec'},{'\xd7','\xed'},{'\xd7','\xeb'},{'\xb6','\x6c'},
+    {'\x00','\x00'},{'\x92','\x7b'},{'\x8e','\xcf'},{'\xdc','\x56'},{'\xeb','\xd4'},
+    {'\xdc','\x57'},{'\xdc','\x54'},{'\xb3','\xa3'},{'\xb6','\x6e'},{'\xdc','\x53'},
+    {'\xdc','\x59'},{'\xdc','\x58'},{'\xb6','\x6b'},{'\xdc','\x5c'},{'\xdc','\x52'},
+    {'\xdc','\x5b'},{'\xdc','\x50'},{'\xdc','\x5a'},{'\xdc','\x55'},{'\xb6','\x6d'},
+    {'\x00','\x00'},{'\xe0','\xaa'},{'\x00','\x00'},{'\xe0','\xa5'},{'\xe0','\xab'},
+    {'\xe0','\xa6'},{'\xe0','\xa4'},{'\xe0','\xa7'},{'\xb9','\x51'},{'\x00','\x00'},
+    {'\xe0','\xa9'},{'\x91','\xb8'},{'\xe0','\xa8'},{'\xb9','\x52'},{'\xbb','\xc1'},
+    {'\xbb','\xc0'},{'\xe4','\x6e'},{'\xe4','\x71'},{'\xe4','\x69'},{'\xe4','\x6d'},
+    {'\xbb','\xc2'},{'\xe4','\x6c'},{'\xe4','\x6a'},{'\xe4','\x70'},{'\xe4','\x6b'},
+    {'\xe4','\x68'},{'\xe4','\x6f'},{'\x00','\x00'},{'\xe8','\x59'},{'\xbe','\x48'},
+    {'\xf1','\x4a'},{'\xe8','\x56'},{'\xe8','\x57'},{'\xe8','\x55'},{'\xdc','\x51'},
+    {'\xbe','\x47'},{'\xe8','\x5a'},{'\xe8','\x54'},{'\xbe','\x46'},{'\xbe','\x49'},
+    {'\xe8','\x58'},{'\xeb','\xd5'},{'\xbf','\xf3'},{'\xeb','\xd6'},{'\xeb','\xd7'},
+    {'\x00','\x00'},{'\xee','\xc4'},{'\xc1','\xdd'},{'\xf1','\x4b'},{'\xf1','\x4c'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xf1','\x4d'},{'\xf3','\x5d'},{'\xf3','\x5c'},
+    {'\xf4','\xe2'},{'\x00','\x00'},{'\xf4','\xe1'},{'\xf6','\x5b'},{'\xf6','\x5c'},
+    {'\xf6','\x5a'},{'\xf7','\x66'},{'\xc5','\xb0'},{'\xa8','\xbb'},{'\xad','\xaa'},
+    {'\xad','\xa9'},{'\xb0','\x75'},{'\xb0','\x74'},{'\xd4','\x40'},{'\xd4','\x41'},
+    {'\xd3','\xfe'},{'\xfd','\xac'},{'\xb0','\x73'},{'\xd7','\xf5'},{'\x92','\xf8'},
+    {'\xd7','\xf6'},{'\xd7','\xf2'},{'\xb3','\xa4'},{'\xd7','\xf3'},{'\xfd','\xaf'},
+    {'\xd7','\xf4'},{'\x00','\x00'},{'\xfd','\xae'},{'\x8a','\x7a'},{'\x96','\xa8'},
+    {'\xdc','\x5f'},{'\xdc','\x61'},{'\xdc','\x5d'},{'\xdc','\x60'},{'\xb6','\x6f'},
+    {'\xdc','\x5e'},{'\xb6','\x70'},{'\x00','\x00'},{'\xfd','\xb0'},{'\xdd','\x73'},
+    {'\xb9','\x55'},{'\xb9','\x54'},{'\x00','\x00'},{'\xb9','\x53'},{'\x00','\x00'},
+    {'\xe0','\xac'},{'\xe0','\xad'},{'\x96','\xa9'},{'\x8b','\x4c'},{'\xe4','\x73'},
+    {'\xe4','\x75'},{'\xbb','\xc6'},{'\xbb','\xc3'},{'\x96','\xa1'},{'\xbb','\xc5'},
+    {'\xbb','\xc4'},{'\xe4','\x74'},{'\xe4','\x72'},{'\x00','\x00'},{'\xfd','\xb1'},
+    {'\x8d','\xa6'},{'\x90','\xa5'},{'\x8d','\x5d'},{'\xe8','\x61'},{'\xe8','\x5e'},
+    {'\xe8','\x5f'},{'\xbe','\x4d'},{'\xe8','\x60'},{'\xe8','\x5b'},{'\xe8','\x5c'},
+    {'\xbe','\x4a'},{'\x00','\x00'},{'\xbe','\x4b'},{'\xe8','\x5d'},{'\xbe','\x4c'},
+    {'\x96','\xaa'},{'\xeb','\xdb'},{'\xfd','\xb2'},{'\xeb','\xdc'},{'\xeb','\xd9'},
+    {'\xeb','\xda'},{'\xbf','\xf4'},{'\xeb','\xd8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x82','\x79'},{'\x00','\x00'},{'\xee','\xc8'},{'\xee','\xc5'},
+    {'\xee','\xc7'},{'\xc1','\xe0'},{'\xee','\xcb'},{'\xc1','\xdf'},{'\xee','\xc9'},
+    {'\xee','\xcc'},{'\xee','\xca'},{'\xee','\xc6'},{'\xc1','\xde'},{'\x82','\x66'},
+    {'\xf1','\x4f'},{'\x00','\x00'},{'\xf1','\x50'},{'\xf1','\x4e'},{'\x9e','\x63'},
+    {'\xf1','\x52'},{'\xc2','\xe5'},{'\xc2','\xe6'},{'\xf3','\x5f'},{'\xc3','\xe7'},
+    {'\xf1','\x51'},{'\xf3','\x5e'},{'\xc3','\xe6'},{'\xf4','\xe5'},{'\xf4','\xe6'},
+    {'\xc4','\xbf'},{'\xf4','\xe4'},{'\x9e','\x64'},{'\xf4','\xe3'},{'\x92','\xf1'},
+    {'\xf6','\x5d'},{'\xc5','\x48'},{'\xfd','\xb3'},{'\xf8','\x49'},{'\xf8','\xc8'},
+    {'\xf8','\xc7'},{'\x00','\x00'},{'\xc6','\x43'},{'\xc6','\x5d'},{'\xf8','\xc9'},
+    {'\xf9','\x71'},{'\x9e','\x65'},{'\xc6','\x6f'},{'\xa8','\xbc'},{'\xaa','\xf6'},
+    {'\x92','\xd8'},{'\xb9','\x56'},{'\x8c','\x5c'},{'\xc4','\xc0'},{'\xa8','\xbd'},
+    {'\xad','\xab'},{'\xb3','\xa5'},{'\xb6','\x71'},{'\xc2','\xe7'},{'\xaa','\xf7'},
+    {'\x00','\x00'},{'\xd0','\xc1'},{'\xd0','\xc0'},{'\xd4','\x42'},{'\x91','\xb9'},
+    {'\xb0','\x78'},{'\xb0','\x76'},{'\xb0','\x7a'},{'\xd4','\x44'},{'\x91','\xba'},
+    {'\xb0','\x79'},{'\xb0','\x77'},{'\x91','\xbb'},{'\x96','\x49'},{'\x00','\x00'},
+    {'\x91','\xbc'},{'\xd4','\x43'},{'\xb3','\xa8'},{'\xd7','\xfc'},{'\x91','\xbd'},
+    {'\xb3','\xa7'},{'\xb3','\xa9'},{'\xd8','\x42'},{'\xb3','\xab'},{'\xd7','\xfe'},
+    {'\xd8','\x40'},{'\xd7','\xf7'},{'\xb3','\xaa'},{'\xd8','\x43'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xd7','\xf9'},{'\x00','\x00'},{'\xd7','\xfa'},{'\xd7','\xf8'},
+    {'\xb3','\xa6'},{'\x91','\xbe'},{'\xd8','\x41'},{'\xd7','\xfb'},{'\xd7','\xfd'},
+    {'\x9e','\x66'},{'\x00','\x00'},{'\x91','\xbf'},{'\xdc','\x6d'},{'\xfd','\xb7'},
+    {'\xdc','\x6c'},{'\xdc','\x6a'},{'\xdc','\x62'},{'\xdc','\x71'},{'\xdc','\x65'},
+    {'\xdc','\x6f'},{'\xdc','\x76'},{'\xdc','\x6e'},{'\xb6','\x79'},{'\x9e','\x67'},
+    {'\xb6','\x75'},{'\xdc','\x63'},{'\x00','\x00'},{'\xdc','\x69'},{'\xb6','\x77'},
+    {'\x95','\x4c'},{'\xdc','\x68'},{'\xb6','\x78'},{'\xb6','\x7a'},{'\xdc','\x6b'},
+    {'\x9e','\x68'},{'\xb6','\x72'},{'\xb6','\x73'},{'\xdc','\x77'},{'\xdc','\x75'},
+    {'\x00','\x00'},{'\xdc','\x74'},{'\xdc','\x66'},{'\x00','\x00'},{'\xdc','\x72'},
+    {'\x00','\x00'},{'\xb6','\x76'},{'\x00','\x00'},{'\x00','\x00'},{'\x9e','\x69'},
+    {'\x00','\x00'},{'\xb6','\x74'},{'\xdc','\x73'},{'\xdc','\x64'},{'\xdc','\x67'},
+    {'\xdc','\x70'},{'\x9e','\x6a'},{'\x91','\xc0'},{'\xfb','\x5f'},{'\x9e','\x6b'},
+    {'\x91','\xc1'},{'\xe4','\xba'},{'\xe0','\xb7'},{'\x00','\x00'},{'\xe0','\xb0'},
+    {'\xe0','\xc3'},{'\xe0','\xcc'},{'\xe0','\xb3'},{'\xb9','\x61'},{'\x9e','\x6c'},
+    {'\xe0','\xc0'},{'\xb9','\x57'},{'\xb9','\x59'},{'\xb9','\x65'},{'\xe0','\xb1'},
+    {'\x00','\x00'},{'\x9e','\x6d'},{'\xb9','\x5a'},{'\xb9','\x5c'},{'\xb9','\x66'},
+    {'\xb9','\x5b'},{'\x9e','\x6e'},{'\x00','\x00'},{'\x00','\x00'},{'\x93','\x7b'},
+    {'\xb9','\x64'},{'\xe0','\xb9'},{'\x00','\x00'},{'\xe0','\xae'},{'\xb9','\x62'},
+    {'\xe0','\xb8'},{'\xb9','\x5e'},{'\xe0','\xca'},{'\xb9','\x63'},{'\xe0','\xc8'},
+    {'\xe0','\xbc'},{'\xe0','\xc6'},{'\xb9','\x60'},{'\xe0','\xaf'},{'\xe0','\xc9'},
+    {'\xe0','\xc4'},{'\x96','\x40'},{'\xe0','\xcb'},{'\xb9','\x58'},{'\x9e','\x6f'},
+    {'\x91','\xc3'},{'\xb9','\x67'},{'\xb9','\x5d'},{'\x00','\x00'},{'\x9e','\x70'},
+    {'\xe0','\xb5'},{'\x9e','\x71'},{'\xe0','\xbd'},{'\xe0','\xc1'},{'\x95','\xf1'},
+    {'\xe0','\xc5'},{'\xb9','\x5f'},{'\xe0','\xb4'},{'\xe0','\xb2'},{'\xe0','\xbe'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x9e','\x72'},{'\xe0','\xbb'},
+    {'\xe0','\xba'},{'\x9e','\x73'},{'\xe0','\xbf'},{'\xe0','\xc2'},{'\x92','\xc0'},
+    {'\xe0','\xc7'},{'\x96','\x43'},{'\x8c','\xe5'},{'\x00','\x00'},{'\xe4','\x78'},
+    {'\x91','\xc4'},{'\xbb','\xc7'},{'\xe4','\xa4'},{'\xe4','\x7a'},{'\xbb','\xcc'},
+    {'\xbb','\xd0'},{'\xe4','\xad'},{'\xe4','\xb5'},{'\xe4','\xa6'},{'\xbb','\xc8'},
+    {'\x9e','\x74'},{'\xe4','\xaa'},{'\xe0','\xb6'},{'\x9e','\x75'},{'\xbb','\xc9'},
+    {'\xe4','\xb1'},{'\xe4','\xb6'},{'\xe4','\xae'},{'\x9e','\x76'},{'\xe4','\xb0'},
+    {'\xe4','\xb9'},{'\xe4','\xb2'},{'\xe4','\x7e'},{'\xe4','\xa9'},{'\x9e','\x77'},
+    {'\x00','\x00'},{'\xbb','\xd1'},{'\x00','\x00'},{'\xbb','\xcd'},{'\xe4','\x7c'},
+    {'\xe4','\xab'},{'\xbb','\xcb'},{'\xe4','\xa5'},{'\xbb','\xca'},{'\xe4','\xb3'},
+    {'\xe4','\xa2'},{'\xe4','\x79'},{'\xbb','\xce'},{'\xe4','\xb8'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe4','\x7b'},{'\xe4','\xaf'},{'\xe4','\xac'},{'\xe4','\xa7'},
+    {'\xe4','\x77'},{'\xe4','\x76'},{'\xe4','\xa1'},{'\xe4','\xb4'},{'\xbb','\xcf'},
+    {'\xe4','\xb7'},{'\xe4','\x7d'},{'\xe4','\xa3'},{'\xbe','\x52'},{'\x93','\x4b'},
+    {'\x8d','\xa8'},{'\x00','\x00'},{'\x00','\x00'},{'\x9e','\x78'},{'\xbe','\x5a'},
+    {'\xbe','\x55'},{'\xe8','\xa4'},{'\xe8','\xa1'},{'\xe8','\x67'},{'\xbe','\x50'},
+    {'\x00','\x00'},{'\xf9','\xd7'},{'\x9e','\x79'},{'\xbe','\x4f'},{'\xbe','\x56'},
+    {'\x00','\x00'},{'\xfd','\xb9'},{'\x9e','\x7a'},{'\xe8','\x65'},{'\xbe','\x54'},
+    {'\xe8','\x71'},{'\xe8','\x63'},{'\xe8','\x64'},{'\xbe','\x4e'},{'\xe8','\xa3'},
+    {'\xbe','\x58'},{'\xe8','\x74'},{'\xe8','\x79'},{'\xe8','\x73'},{'\xeb','\xee'},
+    {'\xe8','\x6f'},{'\xe8','\x77'},{'\xe8','\x75'},{'\xe8','\x68'},{'\xe8','\x62'},
+    {'\xe8','\x7d'},{'\xbe','\x57'},{'\xe8','\x7e'},{'\x9e','\x7b'},{'\xe8','\x78'},
+    {'\x00','\x00'},{'\xe8','\x6d'},{'\xe8','\x6b'},{'\xe8','\x66'},{'\x00','\x00'},
+    {'\x9e','\x7c'},{'\x00','\x00'},{'\xe8','\x6e'},{'\xe8','\x7b'},{'\xe8','\x6a'},
+    {'\xe8','\x7a'},{'\xe8','\xa2'},{'\x00','\x00'},{'\x9e','\x7d'},{'\xbe','\x53'},
+    {'\x9e','\x7e'},{'\xe8','\x76'},{'\xe8','\x7c'},{'\xe8','\x72'},{'\xe8','\x6c'},
+    {'\xbe','\x51'},{'\x9e','\xa1'},{'\x9e','\xa2'},{'\x91','\xc5'},{'\xe4','\xa8'},
+    {'\xe8','\x70'},{'\xbe','\x59'},{'\xe8','\x69'},{'\x94','\x58'},{'\x93','\x74'},
+    {'\x9e','\xa3'},{'\x00','\x00'},{'\x9e','\xa4'},{'\xeb','\xf4'},{'\xbf','\xf7'},
+    {'\xeb','\xf3'},{'\xeb','\xf0'},{'\xec','\x44'},{'\xbf','\xfb'},{'\x9e','\xa5'},
+    {'\xec','\x41'},{'\xeb','\xf8'},{'\xec','\x43'},{'\xeb','\xe9'},{'\xeb','\xf6'},
+    {'\x9e','\xa6'},{'\xbf','\xfd'},{'\x00','\x00'},{'\xeb','\xe1'},{'\x9e','\xa7'},
+    {'\xeb','\xdf'},{'\xec','\x42'},{'\x00','\x00'},{'\xec','\x40'},{'\xeb','\xfe'},
+    {'\xeb','\xed'},{'\xeb','\xec'},{'\xeb','\xe2'},{'\xc0','\x40'},{'\x00','\x00'},
+    {'\xeb','\xe8'},{'\xeb','\xf2'},{'\xeb','\xfd'},{'\xc0','\x43'},{'\xec','\x45'},
+    {'\x00','\x00'},{'\xc1','\xe8'},{'\xc0','\x45'},{'\xbf','\xfe'},{'\xeb','\xe6'},
+    {'\x00','\x00'},{'\xeb','\xef'},{'\xeb','\xde'},{'\xeb','\xe0'},{'\xbf','\xf5'},
+    {'\xc0','\x42'},{'\xbf','\xfa'},{'\xeb','\xe7'},{'\xeb','\xf7'},{'\xeb','\xf1'},
+    {'\xc0','\x41'},{'\xeb','\xdd'},{'\xc1','\xe3'},{'\xeb','\xf9'},{'\xeb','\xfc'},
+    {'\xbf','\xfc'},{'\x93','\xf3'},{'\xeb','\xeb'},{'\xc0','\x44'},{'\xbf','\xf9'},
+    {'\x9e','\xa8'},{'\x9e','\xa9'},{'\x93','\xf7'},{'\xbf','\xf8'},{'\xeb','\xf5'},
+    {'\xeb','\xfb'},{'\xbf','\xf6'},{'\x00','\x00'},{'\xeb','\xe4'},{'\xeb','\xfa'},
+    {'\x91','\xc6'},{'\x94','\xdb'},{'\xeb','\xe5'},{'\x00','\x00'},{'\x8b','\xd6'},
+    {'\x00','\x00'},{'\x9e','\xaa'},{'\xfe','\x7c'},{'\x9e','\xab'},{'\x9e','\xac'},
+    {'\x97','\x55'},{'\x96','\x42'},{'\xeb','\xea'},{'\xee','\xd2'},{'\xfe','\x79'},
+    {'\xee','\xd7'},{'\xc1','\xe5'},{'\xc1','\xe7'},{'\xee','\xdd'},{'\xc1','\xe1'},
+    {'\xee','\xec'},{'\xee','\xe3'},{'\xee','\xd8'},{'\xee','\xd9'},{'\xee','\xe2'},
+    {'\x00','\x00'},{'\xc1','\xee'},{'\xee','\xe1'},{'\xee','\xd1'},{'\xee','\xe0'},
+    {'\xee','\xd4'},{'\xee','\xed'},{'\xc1','\xed'},{'\xc1','\xeb'},{'\xee','\xd5'},
+    {'\x00','\x00'},{'\xee','\xe8'},{'\x9e','\xad'},{'\xee','\xda'},{'\xee','\xe7'},
+    {'\x9e','\xae'},{'\xee','\xe9'},{'\xee','\xd0'},{'\xc1','\xe6'},{'\x9e','\xaf'},
+    {'\xee','\xea'},{'\x9e','\xb0'},{'\x96','\x44'},{'\xee','\xde'},{'\xfd','\xba'},
+    {'\xc1','\xea'},{'\xee','\xdb'},{'\xfd','\xbb'},{'\x00','\x00'},{'\xc1','\xec'},
+    {'\xee','\xe4'},{'\x00','\x00'},{'\x9e','\xb1'},{'\x9e','\xb2'},{'\xc1','\xe4'},
+    {'\xee','\xd6'},{'\xee','\xe5'},{'\x9e','\xb3'},{'\xee','\xdf'},{'\xeb','\xe3'},
+    {'\xee','\xe6'},{'\xee','\xd3'},{'\x9e','\xb4'},{'\xc1','\xe9'},{'\x00','\x00'},
+    {'\xee','\xeb'},{'\x9e','\xb5'},{'\xc1','\xe2'},{'\xee','\xce'},{'\x9e','\xb6'},
+    {'\xfb','\x73'},{'\x9e','\xb7'},{'\x9e','\xb8'},{'\xf1','\x60'},{'\xf1','\x59'},
+    {'\xc2','\xe9'},{'\x00','\x00'},{'\xf1','\x54'},{'\xf1','\x63'},{'\xf1','\x5b'},
+    {'\xee','\xdc'},{'\x9e','\xb9'},{'\xf1','\x65'},{'\xf1','\x55'},{'\x00','\x00'},
+    {'\xc2','\xe8'},{'\xf1','\x5f'},{'\xc2','\xea'},{'\xc2','\xf2'},{'\xc2','\xf0'},
+    {'\xf1','\x61'},{'\xc2','\xf1'},{'\xf1','\x57'},{'\x9e','\xba'},{'\xf1','\x58'},
+    {'\xf1','\x5d'},{'\xf1','\x62'},{'\x9e','\xbb'},{'\xee','\xcd'},{'\xc2','\xeb'},
+    {'\xf1','\x6a'},{'\xf1','\x67'},{'\xf1','\x6b'},{'\xf1','\x5e'},{'\xf1','\x5a'},
+    {'\xf1','\x68'},{'\xf3','\x6a'},{'\xf1','\x5c'},{'\x00','\x00'},{'\xc2','\xee'},
+    {'\x97','\x56'},{'\xc2','\xed'},{'\xee','\xcf'},{'\xc2','\xef'},{'\xf1','\x64'},
+    {'\xf1','\x66'},{'\xc2','\xec'},{'\xf1','\x69'},{'\xf1','\x53'},{'\x00','\x00'},
+    {'\xf1','\x56'},{'\x9e','\xbc'},{'\x94','\xdc'},{'\xfd','\xbc'},{'\x9e','\xbd'},
+    {'\x00','\x00'},{'\x9e','\xbe'},{'\x00','\x00'},{'\x9e','\xbf'},{'\xf3','\x73'},
+    {'\x00','\x00'},{'\xf3','\x63'},{'\xc3','\xeb'},{'\xf3','\x71'},{'\x00','\x00'},
+    {'\x97','\x57'},{'\xf3','\x61'},{'\xc3','\xec'},{'\x00','\x00'},{'\xf3','\x6c'},
+    {'\x9e','\xc0'},{'\xf3','\x68'},{'\xc3','\xf1'},{'\xf3','\x72'},{'\xf3','\x62'},
+    {'\xf3','\x65'},{'\xc3','\xe9'},{'\xf3','\x74'},{'\x9e','\xc1'},{'\xf3','\x6d'},
+    {'\xf3','\x70'},{'\xc3','\xef'},{'\xc3','\xf4'},{'\xc3','\xf2'},{'\xf3','\x69'},
+    {'\xf3','\x64'},{'\x9e','\xc2'},{'\xc3','\xed'},{'\xc3','\xee'},{'\xf3','\x60'},
+    {'\xc3','\xea'},{'\x9e','\xc3'},{'\xc3','\xe8'},{'\xc3','\xf0'},{'\xf3','\x6f'},
+    {'\xc3','\xf3'},{'\x97','\x58'},{'\xf3','\x6b'},{'\xf3','\x75'},{'\xc3','\xf5'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xf3','\x67'},{'\x00','\x00'},
+    {'\xf3','\x6e'},{'\x00','\x00'},{'\x9e','\xc4'},{'\x9e','\xc5'},{'\x00','\x00'},
+    {'\x9e','\xc6'},{'\x9e','\xc7'},{'\xf4','\xf3'},{'\xf5','\x42'},{'\xf4','\xf5'},
+    {'\xf4','\xfc'},{'\xf3','\x66'},{'\xf4','\xfa'},{'\xf4','\xe9'},{'\xf5','\x40'},
+    {'\xc4','\xc3'},{'\xf4','\xed'},{'\xf4','\xfe'},{'\xf4','\xf4'},{'\x9e','\xc8'},
+    {'\x00','\x00'},{'\xc4','\xc2'},{'\x9e','\xc9'},{'\x00','\x00'},{'\xf5','\x44'},
+    {'\xf4','\xf6'},{'\x9e','\xca'},{'\xf4','\xfb'},{'\xf4','\xfd'},{'\xf4','\xe7'},
+    {'\xf5','\x41'},{'\xf4','\xf2'},{'\xf4','\xf7'},{'\xf4','\xeb'},{'\xf4','\xef'},
+    {'\xf5','\x43'},{'\xf4','\xf9'},{'\xf4','\xe8'},{'\xf4','\xec'},{'\xf4','\xee'},
+    {'\xf4','\xf8'},{'\x9e','\xcb'},{'\xc4','\xc1'},{'\xf4','\xf1'},{'\x97','\x59'},
+    {'\x9e','\xcc'},{'\x00','\x00'},{'\x9e','\xcd'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf4','\xea'},{'\x97','\x5a'},{'\x00','\x00'},{'\x00','\x00'},{'\x9e','\xce'},
+    {'\x9e','\xcf'},{'\x9e','\xd0'},{'\xfd','\xbd'},{'\xf4','\xf0'},{'\xf6','\x61'},
+    {'\xf6','\x66'},{'\xc5','\x4f'},{'\xf6','\x68'},{'\x9e','\xd1'},{'\xc5','\x49'},
+    {'\x00','\x00'},{'\xf6','\x64'},{'\xf6','\x6a'},{'\xc5','\x4e'},{'\xc5','\x4a'},
+    {'\x00','\x00'},{'\xc5','\x4b'},{'\xf6','\x60'},{'\xf6','\x67'},{'\xc5','\x4d'},
+    {'\xf6','\x65'},{'\xc5','\x4c'},{'\xf6','\x5f'},{'\xf6','\x63'},{'\xf6','\x62'},
+    {'\x97','\x5b'},{'\xf6','\x5e'},{'\xf6','\x69'},{'\x97','\x5c'},{'\x9e','\xd2'},
+    {'\x9e','\xd3'},{'\xc5','\xb1'},{'\xf7','\x6d'},{'\xf7','\x70'},{'\xf7','\x6c'},
+    {'\xf7','\x6e'},{'\xf7','\x6f'},{'\xf7','\x69'},{'\xf7','\x6a'},{'\xf7','\x67'},
+    {'\x9e','\xd4'},{'\x00','\x00'},{'\xf7','\x6b'},{'\xf7','\x68'},{'\xc5','\xb2'},
+    {'\xc5','\xb3'},{'\x97','\x5d'},{'\x9e','\xd5'},{'\xf8','\x4b'},{'\x00','\x00'},
+    {'\xf8','\x4d'},{'\x9e','\xd6'},{'\x00','\x00'},{'\x97','\x5e'},{'\x95','\x58'},
+    {'\x00','\x00'},{'\xf8','\x4c'},{'\xf8','\x4e'},{'\x00','\x00'},{'\xc5','\xe0'},
+    {'\x00','\x00'},{'\xf8','\x4a'},{'\xc5','\xdf'},{'\xc5','\xe1'},{'\x9e','\xd7'},
+    {'\x00','\x00'},{'\x9e','\xd8'},{'\xf8','\xcb'},{'\xf8','\xcc'},{'\xc6','\x44'},
+    {'\xf8','\xca'},{'\x9e','\xd9'},{'\xf9','\x53'},{'\xf9','\x52'},{'\xf9','\x54'},
+    {'\xc6','\x5f'},{'\xf9','\x55'},{'\xc6','\x5e'},{'\xf9','\x56'},{'\xf9','\x72'},
+    {'\xf9','\x75'},{'\xf9','\x74'},{'\xc6','\x68'},{'\xf9','\x73'},{'\x9e','\xda'},
+    {'\x00','\x00'},{'\x9e','\xdb'},{'\xc6','\x72'},{'\xc6','\x70'},{'\xc6','\x71'},
+    {'\xc6','\x77'},{'\xf9','\xc0'},{'\xf9','\xc1'},{'\xf9','\xbf'},{'\xf9','\xc9'},
+    {'\x00','\x00'},{'\x9c','\xf0'},{'\x8d','\xc1'},{'\x8d','\xc0'},{'\x83','\xe1'},
+    {'\x83','\xe0'},{'\x83','\xe2'},{'\x83','\xe3'},{'\x8d','\xc7'},{'\x8d','\xd9'},
+    {'\x8d','\xd6'},{'\x84','\xb6'},{'\x8d','\xd7'},{'\x00','\x00'},{'\x84','\xb7'},
+    {'\x84','\xb5'},{'\x8f','\x46'},{'\x8d','\xd8'},{'\x00','\x00'},{'\x84','\xb4'},
+    {'\x00','\x00'},{'\x85','\x73'},{'\x97','\x5f'},{'\x8d','\xf4'},{'\x86','\x73'},
+    {'\x85','\x76'},{'\x85','\x71'},{'\x8c','\x5d'},{'\x85','\x74'},{'\x88','\xae'},
+    {'\x89','\xa1'},{'\x85','\x78'},{'\x85','\x77'},{'\x8d','\x76'},{'\x84','\xe8'},
+    {'\x85','\x75'},{'\x8b','\x4f'},{'\x86','\x6e'},{'\x8d','\xf7'},{'\x8d','\xf2'},
+    {'\x8d','\xf3'},{'\x8d','\xf6'},{'\x85','\x72'},{'\x8d','\xf5'},{'\x8e','\x5a'},
+    {'\x89','\x7e'},{'\x8e','\x5b'},{'\x86','\x68'},{'\x86','\x67'},{'\x84','\x73'},
+    {'\x8e','\x5c'},{'\x97','\x60'},{'\x86','\x6a'},{'\x86','\x69'},{'\x8d','\xb2'},
+    {'\x8d','\xa7'},{'\x8e','\x60'},{'\x8e','\x5f'},{'\x86','\x6b'},{'\x86','\x75'},
+    {'\x86','\x6c'},{'\x8c','\xb2'},{'\x86','\x6f'},{'\x86','\x70'},{'\x8d','\x44'},
+    {'\x86','\x6d'},{'\x86','\x76'},{'\x00','\x00'},{'\x8e','\x59'},{'\x86','\x71'},
+    {'\x8e','\x58'},{'\x86','\x72'},{'\x8e','\x5e'},{'\x86','\x74'},{'\x8c','\xb4'},
+    {'\x00','\x00'},{'\x88','\xa8'},{'\x8e','\xa5'},{'\x8e','\xa4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8e','\xa6'},{'\x8e','\xac'},{'\x8e','\xd1'},{'\x97','\x61'},
+    {'\x8c','\x5e'},{'\x00','\x00'},{'\x8c','\xb3'},{'\x87','\x66'},{'\x88','\xaa'},
+    {'\x97','\x62'},{'\x8e','\xa7'},{'\x8f','\xa7'},{'\x8f','\x6a'},{'\x87','\x68'},
+    {'\x87','\x6c'},{'\x8e','\xd5'},{'\x8e','\xad'},{'\x00','\x00'},{'\x8f','\xec'},
+    {'\x87','\x6a'},{'\x8f','\xcd'},{'\x8e','\xaa'},{'\x8e','\xa8'},{'\x87','\x69'},
+    {'\x87','\x67'},{'\x89','\xa4'},{'\x8e','\xa9'},{'\x87','\x64'},{'\x8e','\xa3'},
+    {'\x85','\xb6'},{'\x97','\x63'},{'\x8f','\xe5'},{'\x87','\x6b'},{'\x87','\x65'},
+    {'\x8e','\xab'},{'\x8c','\xe4'},{'\x8f','\xee'},{'\x88','\xa7'},{'\x00','\x00'},
+    {'\x8f','\x42'},{'\x8e','\xd2'},{'\x8b','\xce'},{'\x8b','\xd5'},{'\x88','\xa6'},
+    {'\x8b','\x4e'},{'\x88','\xaf'},{'\x97','\x64'},{'\x88','\xa9'},{'\x8a','\xa2'},
+    {'\x8e','\xd6'},{'\x8e','\xd7'},{'\x8c','\x5f'},{'\x88','\xac'},{'\x8e','\xd4'},
+    {'\x88','\xad'},{'\x88','\xa4'},{'\x8e','\x5d'},{'\x97','\x65'},{'\x97','\x66'},
+    {'\x88','\xab'},{'\x88','\xa5'},{'\x8e','\xd0'},{'\x8e','\xd3'},{'\x8e','\xd8'},
+    {'\x8f','\x44'},{'\x8f','\x40'},{'\x8f','\x41'},{'\x97','\x67'},{'\x89','\x7d'},
+    {'\x8a','\x7d'},{'\x8f','\x43'},{'\x00','\x00'},{'\x97','\x68'},{'\x8f','\x45'},
+    {'\x89','\xa7'},{'\x00','\x00'},{'\x89','\xa2'},{'\x89','\xa8'},{'\x8d','\xa9'},
+    {'\x8a','\xa3'},{'\x89','\xa5'},{'\x89','\xa6'},{'\x00','\x00'},{'\x90','\xf1'},
+    {'\x8e','\xfd'},{'\x97','\x69'},{'\x97','\x6a'},{'\x8e','\xfe'},{'\x89','\x7a'},
+    {'\x8a','\x7e'},{'\x89','\x7b'},{'\x89','\x7c'},{'\x89','\xa9'},{'\x8a','\xa1'},
+    {'\x00','\x00'},{'\x8f','\x69'},{'\x8b','\xd3'},{'\x8f','\x6b'},{'\x8a','\xa8'},
+    {'\x8f','\x68'},{'\x8a','\xa5'},{'\x8a','\xa4'},{'\x8a','\xa6'},{'\x8f','\xa8'},
+    {'\x00','\x00'},{'\x8a','\xa7'},{'\x97','\x6b'},{'\x8a','\x7b'},{'\x8a','\x7c'},
+    {'\x8b','\xd4'},{'\x00','\x00'},{'\x8f','\xea'},{'\x97','\x6c'},{'\x8a','\x42'},
+    {'\x8b','\x51'},{'\x00','\x00'},{'\x8b','\x54'},{'\x8d','\x7d'},{'\x00','\x00'},
+    {'\x8c','\xb6'},{'\x8b','\x50'},{'\x97','\x6d'},{'\x8f','\xa9'},{'\x8b','\x52'},
+    {'\x8b','\x4d'},{'\x8b','\x53'},{'\x8f','\xa6'},{'\x90','\x60'},{'\x00','\x00'},
+    {'\x8b','\xd1'},{'\x8b','\xcf'},{'\x8b','\xd0'},{'\x8b','\xd2'},{'\x00','\x00'},
+    {'\x8f','\xc9'},{'\x8b','\xcb'},{'\x8b','\xcc'},{'\x8b','\xcd'},{'\x8f','\xca'},
+    {'\x00','\x00'},{'\x8f','\xe8'},{'\x97','\x6e'},{'\x8f','\xe9'},{'\x8f','\xed'},
+    {'\x97','\x6f'},{'\x8f','\xe6'},{'\x90','\xa1'},{'\x8f','\xe7'},{'\x97','\x70'},
+    {'\x8f','\xcb'},{'\x8f','\xeb'},{'\x90','\x61'},{'\x8c','\xb1'},{'\x00','\x00'},
+    {'\x8c','\xb5'},{'\x8c','\xb0'},{'\x90','\x48'},{'\x97','\x71'},{'\x8d','\x43'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x8c','\x7c'},{'\xaa','\xf8'},{'\x9e','\xdc'},
+    {'\x00','\x00'},{'\xd8','\x44'},{'\xdc','\x78'},{'\xe8','\xa5'},{'\xf3','\x76'},
+    {'\x00','\x00'},{'\x83','\x63'},{'\xaa','\xf9'},{'\x00','\x00'},{'\xad','\xac'},
+    {'\xb0','\x7b'},{'\x00','\x00'},{'\x9e','\xdd'},{'\xd8','\x45'},{'\x97','\x72'},
+    {'\xd8','\x46'},{'\xb3','\xac'},{'\x94','\xdd'},{'\xb6','\x7d'},{'\xdc','\x7a'},
+    {'\xdc','\x79'},{'\xb6','\xa3'},{'\xb6','\x7c'},{'\xdc','\x7b'},{'\xb6','\x7e'},
+    {'\xb6','\xa2'},{'\xb6','\xa1'},{'\xb6','\x7b'},{'\x00','\x00'},{'\x94','\xde'},
+    {'\xfd','\xbe'},{'\xb9','\x68'},{'\x97','\x73'},{'\x00','\x00'},{'\xe0','\xd0'},
+    {'\xe0','\xce'},{'\x00','\x00'},{'\xe0','\xcf'},{'\xe0','\xcd'},{'\x97','\x74'},
+    {'\xbb','\xd2'},{'\x92','\x6b'},{'\xbb','\xd5'},{'\xbb','\xd7'},{'\xbb','\xd6'},
+    {'\x9e','\xde'},{'\xfd','\xbf'},{'\xbb','\xd3'},{'\xbb','\xd4'},{'\x9e','\xdf'},
+    {'\xe8','\xa7'},{'\xe8','\xa6'},{'\xbe','\x5b'},{'\xe8','\xa8'},{'\x00','\x00'},
+    {'\xe8','\xa9'},{'\xbe','\x5c'},{'\x97','\x75'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xec','\x4d'},{'\xec','\x4b'},{'\xee','\xf3'},{'\x00','\x00'},{'\xec','\x49'},
+    {'\xec','\x4a'},{'\xc0','\x46'},{'\xec','\x46'},{'\xec','\x4e'},{'\xec','\x48'},
+    {'\xec','\x4c'},{'\xee','\xef'},{'\x00','\x00'},{'\x00','\x00'},{'\xee','\xf1'},
+    {'\x00','\x00'},{'\xee','\xf2'},{'\xc1','\xf3'},{'\xee','\xee'},{'\xc1','\xf2'},
+    {'\xee','\xf0'},{'\xc1','\xef'},{'\xc1','\xf0'},{'\xc1','\xf1'},{'\xec','\x47'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc2','\xf5'},{'\xf1','\x6e'},{'\xf1','\x6c'},
+    {'\xf1','\x6d'},{'\xc2','\xf3'},{'\xc2','\xf6'},{'\xc2','\xf4'},{'\x00','\x00'},
+    {'\x93','\xa7'},{'\x00','\x00'},{'\xf3','\x77'},{'\xf3','\x78'},{'\xc3','\xf6'},
+    {'\x00','\x00'},{'\xf5','\x45'},{'\xf5','\x47'},{'\xf5','\x46'},{'\xc4','\xc4'},
+    {'\xc5','\x50'},{'\xf6','\x6d'},{'\xf6','\x6c'},{'\xf6','\x6b'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x83','\x64'},{'\x83','\xa2'},{'\x83','\xe4'},{'\x8d','\xda'},
+    {'\x00','\x00'},{'\x84','\xb8'},{'\x83','\xf4'},{'\x8b','\x56'},{'\x85','\x7a'},
+    {'\x8a','\xac'},{'\x85','\x7c'},{'\x85','\x7e'},{'\x85','\x7d'},{'\x85','\x79'},
+    {'\x8d','\xf8'},{'\x84','\xdd'},{'\x86','\x77'},{'\x88','\xc1'},{'\x87','\x6e'},
+    {'\x87','\x47'},{'\x90','\x49'},{'\x87','\x6f'},{'\x88','\xb0'},{'\x00','\x00'},
+    {'\x87','\x71'},{'\x87','\x70'},{'\x87','\x6d'},{'\x8e','\xda'},{'\x90','\xac'},
+    {'\x88','\xb1'},{'\x8e','\xd9'},{'\x00','\x00'},{'\x8f','\x48'},{'\x8f','\x49'},
+    {'\x8f','\x4a'},{'\x8f','\xb0'},{'\x8f','\x4b'},{'\x8f','\x4c'},{'\x89','\xaa'},
+    {'\x8f','\x47'},{'\x8c','\x60'},{'\x8a','\xab'},{'\x8f','\x6c'},{'\x00','\x00'},
+    {'\x8a','\xa9'},{'\x8a','\xaa'},{'\x8b','\x55'},{'\x8b','\x57'},{'\x00','\x00'},
+    {'\x8b','\x58'},{'\x8f','\xef'},{'\x00','\x00'},{'\xaa','\xfa'},{'\x9c','\xf1'},
+    {'\xc9','\xaa'},{'\x85','\xa1'},{'\xca','\x58'},{'\xa6','\xe9'},{'\xca','\x56'},
+    {'\xca','\x59'},{'\xca','\x57'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xcb','\xae'},{'\x00','\x00'},{'\xa8','\xc1'},{'\x00','\x00'},{'\xa8','\xc2'},
+    {'\xcb','\xb0'},{'\xa8','\xbf'},{'\xcb','\xaf'},{'\xcb','\xad'},{'\xa8','\xc0'},
+    {'\xa8','\xbe'},{'\x85','\xa3'},{'\x84','\xbb'},{'\x83','\xe5'},{'\x85','\xa2'},
+    {'\x00','\x00'},{'\xfd','\xc1'},{'\xcd','\xd8'},{'\xcd','\xdb'},{'\xaa','\xfd'},
+    {'\xcd','\xda'},{'\xcd','\xd9'},{'\x00','\x00'},{'\xaa','\xfc'},{'\xaa','\xfb'},
+    {'\xfe','\x42'},{'\xab','\x40'},{'\xcd','\xdc'},{'\xaa','\xfe'},{'\x87','\x72'},
+    {'\x84','\xba'},{'\x8b','\xd8'},{'\x84','\xb9'},{'\x83','\xe7'},{'\xd0','\xc6'},
+    {'\xad','\xae'},{'\xad','\xaf'},{'\xad','\xb0'},{'\xd0','\xc7'},{'\xd0','\xc3'},
+    {'\xad','\xad'},{'\xd0','\xc4'},{'\x00','\x00'},{'\xd0','\xc5'},{'\xd0','\xc2'},
+    {'\x83','\xe6'},{'\x9e','\xe0'},{'\x00','\x00'},{'\xb0','\xa4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xb0','\xa1'},{'\xd4','\x45'},{'\xb0','\xa2'},{'\xb0','\xa5'},
+    {'\xd4','\x46'},{'\x00','\x00'},{'\xb0','\x7e'},{'\xb0','\x7c'},{'\xb0','\x7d'},
+    {'\xb0','\xa3'},{'\x92','\x67'},{'\x97','\x76'},{'\x8d','\xf9'},{'\x86','\x78'},
+    {'\x89','\xac'},{'\xb3','\xad'},{'\xd8','\x49'},{'\xb3','\xb5'},{'\xd8','\x48'},
+    {'\x00','\x00'},{'\xd8','\x4b'},{'\xb3','\xb1'},{'\xd8','\x4a'},{'\xb6','\xab'},
+    {'\xb3','\xaf'},{'\xb3','\xb2'},{'\xb3','\xae'},{'\xb3','\xb3'},{'\xb3','\xb4'},
+    {'\xb3','\xb0'},{'\x00','\x00'},{'\x92','\xb4'},{'\x9e','\xe1'},{'\xd8','\x47'},
+    {'\xb6','\xa7'},{'\xdc','\x7d'},{'\x00','\x00'},{'\xdc','\xa3'},{'\xfd','\xc5'},
+    {'\x00','\x00'},{'\xdc','\xa2'},{'\xb6','\xac'},{'\xb6','\xa8'},{'\xb6','\xa9'},
+    {'\xdc','\x7c'},{'\xdc','\x7e'},{'\xdc','\xa1'},{'\xb6','\xa4'},{'\xb6','\xa6'},
+    {'\x00','\x00'},{'\xb6','\xaa'},{'\xb6','\xa5'},{'\x92','\xfa'},{'\x8a','\xad'},
+    {'\xe0','\xd3'},{'\xe0','\xd1'},{'\xe0','\xd2'},{'\xb9','\x6a'},{'\xb9','\x6b'},
+    {'\xfd','\xc4'},{'\xe0','\xd4'},{'\xb9','\x69'},{'\xbb','\xd8'},{'\x00','\x00'},
+    {'\xbb','\xda'},{'\xbb','\xd9'},{'\x97','\x77'},{'\xe4','\xbb'},{'\x00','\x00'},
+    {'\x92','\x47'},{'\xe4','\xbc'},{'\xe8','\xab'},{'\x95','\xf9'},{'\xe8','\xaa'},
+    {'\x9e','\xe2'},{'\x00','\x00'},{'\xc0','\x47'},{'\xc0','\x48'},{'\xec','\x4f'},
+    {'\xc0','\x49'},{'\x00','\x00'},{'\xee','\xf6'},{'\x00','\x00'},{'\xee','\xf4'},
+    {'\x97','\x78'},{'\xee','\xf5'},{'\xc1','\xf4'},{'\x97','\x79'},{'\xf1','\x6f'},
+    {'\xc3','\xf7'},{'\x00','\x00'},{'\xc6','\xd7'},{'\x95','\xfb'},{'\xc1','\xf5'},
+    {'\xab','\x41'},{'\x00','\x00'},{'\xb0','\xa6'},{'\xd4','\x47'},{'\x86','\x79'},
+    {'\x8b','\xd9'},{'\xd8','\x4c'},{'\xb3','\xb6'},{'\xb6','\xad'},{'\xdc','\xa4'},
+    {'\xdc','\xa6'},{'\xb6','\xaf'},{'\xb6','\xae'},{'\xb6','\xb0'},{'\xb6','\xb1'},
+    {'\xdc','\xa5'},{'\xb9','\x6e'},{'\xb9','\x6f'},{'\xb9','\x6d'},{'\xbb','\xdb'},
+    {'\xb9','\x6c'},{'\xe0','\xd5'},{'\x8b','\x5b'},{'\x00','\x00'},{'\x92','\xca'},
+    {'\xbb','\xdc'},{'\xe8','\xac'},{'\xec','\x50'},{'\xc0','\x4a'},{'\xc1','\xf6'},
+    {'\xf1','\x70'},{'\xf1','\x74'},{'\xc2','\xf9'},{'\xf1','\x71'},{'\xc2','\xfa'},
+    {'\xc2','\xf8'},{'\xf1','\x75'},{'\xc2','\xfb'},{'\xf1','\x73'},{'\x90','\x6d'},
+    {'\xf3','\x79'},{'\xc2','\xf7'},{'\xc3','\xf8'},{'\x00','\x00'},{'\xf8','\xcd'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xab','\x42'},{'\xb3','\xb8'},{'\xb3','\xb7'},
+    {'\x94','\x48'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xb6','\xb2'},
+    {'\xdc','\xa8'},{'\xdc','\xa7'},{'\xb6','\xb3'},{'\x8d','\x5e'},{'\x9e','\xe3'},
+    {'\xe0','\xd9'},{'\xb9','\x73'},{'\xb9','\x70'},{'\xe0','\xd8'},{'\xb9','\x72'},
+    {'\xe0','\xd6'},{'\xb9','\x71'},{'\x00','\x00'},{'\xe0','\xd7'},{'\x8b','\xda'},
+    {'\xe4','\xbd'},{'\xbb','\xdd'},{'\x8c','\xe6'},{'\xe8','\xaf'},{'\xfd','\xc7'},
+    {'\xbe','\x5d'},{'\xe8','\xad'},{'\xbe','\x5e'},{'\xbe','\x5f'},{'\xe8','\xae'},
+    {'\xbe','\x60'},{'\x93','\xed'},{'\xec','\x51'},{'\x00','\x00'},{'\xc0','\x4e'},
+    {'\xc0','\x4b'},{'\xc0','\x50'},{'\xec','\x53'},{'\xc0','\x4c'},{'\xec','\x52'},
+    {'\xc0','\x4f'},{'\x00','\x00'},{'\x00','\x00'},{'\xc0','\x4d'},{'\x00','\x00'},
+    {'\xee','\xf9'},{'\xee','\xfb'},{'\x00','\x00'},{'\x9e','\xe4'},{'\xc1','\xf7'},
+    {'\xee','\xfa'},{'\xc1','\xf8'},{'\xee','\xf8'},{'\xee','\xf7'},{'\xfd','\xc8'},
+    {'\xf1','\x77'},{'\xf1','\x76'},{'\xc2','\xfc'},{'\xf1','\x78'},{'\xf3','\x7e'},
+    {'\xc3','\xfa'},{'\xf3','\x7d'},{'\xf3','\x7a'},{'\xc3','\xf9'},{'\xf3','\x7b'},
+    {'\xf3','\x7c'},{'\x8d','\x60'},{'\xf5','\x48'},{'\xf5','\x49'},{'\xc4','\xc5'},
+    {'\xfd','\xc9'},{'\xc5','\x53'},{'\x97','\x7a'},{'\x9d','\xbb'},{'\xf6','\x6e'},
+    {'\x9e','\xe5'},{'\x00','\x00'},{'\xc5','\x51'},{'\xc5','\x52'},{'\xf6','\x6f'},
+    {'\x97','\x7b'},{'\x00','\x00'},{'\xc5','\xb4'},{'\xc5','\xb5'},{'\xf7','\x71'},
+    {'\x9e','\xe6'},{'\x9e','\xe7'},{'\xc6','\x45'},{'\xf8','\xcf'},{'\xc6','\x47'},
+    {'\x00','\x00'},{'\xf8','\xce'},{'\xf8','\xd0'},{'\xc6','\x46'},{'\xf9','\x57'},
+    {'\x00','\x00'},{'\xf9','\xad'},{'\x00','\x00'},{'\x97','\x7c'},{'\x00','\x00'},
+    {'\x97','\x7d'},{'\x00','\x00'},{'\x97','\x7e'},{'\xab','\x43'},{'\x8e','\xdb'},
+    {'\x00','\x00'},{'\x97','\xa1'},{'\xb9','\x74'},{'\x9e','\xe8'},{'\xe4','\xbe'},
+    {'\x93','\x43'},{'\xe8','\xb0'},{'\xc0','\x51'},{'\xc0','\x52'},{'\xfe','\x6d'},
+    {'\xab','\x44'},{'\xfd','\xca'},{'\xbe','\x61'},{'\xc3','\xfb'},{'\xad','\xb1'},
+    {'\x00','\x00'},{'\x97','\xa2'},{'\x8d','\x45'},{'\xc0','\x53'},{'\x00','\x00'},
+    {'\xc5','\xe2'},{'\xad','\xb2'},{'\xd8','\x4d'},{'\x97','\xa3'},{'\xdc','\xa9'},
+    {'\x95','\xf7'},{'\xdc','\xab'},{'\x00','\x00'},{'\xdc','\xaa'},{'\x97','\xa4'},
+    {'\xe0','\xdd'},{'\xe0','\xda'},{'\xb9','\x75'},{'\x00','\x00'},{'\xb9','\x76'},
+    {'\xe0','\xdb'},{'\xe0','\xdc'},{'\x94','\xdf'},{'\xe4','\xc0'},{'\xe4','\xc5'},
+    {'\xbb','\xde'},{'\xe4','\xbf'},{'\xe4','\xc1'},{'\xe4','\xc8'},{'\xe4','\xc3'},
+    {'\xe4','\xc7'},{'\xe4','\xc4'},{'\xe4','\xc2'},{'\xe4','\xc6'},{'\xbb','\xdf'},
+    {'\x94','\xe0'},{'\x9e','\xe9'},{'\xe8','\xb3'},{'\x9e','\xea'},{'\xe8','\xb1'},
+    {'\xbe','\x63'},{'\x00','\x00'},{'\xbe','\x62'},{'\xe8','\xb2'},{'\xbe','\x64'},
+    {'\x94','\xe1'},{'\x8c','\xe7'},{'\x97','\xa5'},{'\x00','\x00'},{'\xec','\x56'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xec','\x55'},{'\xc0','\x54'},{'\xec','\x54'},
+    {'\xee','\xfc'},{'\x9e','\xeb'},{'\xee','\xfe'},{'\xef','\x41'},{'\xef','\x40'},
+    {'\xfd','\xcb'},{'\xc1','\xf9'},{'\xee','\xfd'},{'\xf1','\xa1'},{'\xc2','\xfd'},
+    {'\xf1','\x7d'},{'\xf1','\xa2'},{'\xc2','\xfe'},{'\x00','\x00'},{'\xf1','\x7b'},
+    {'\x00','\x00'},{'\xf1','\x7e'},{'\xf1','\x7c'},{'\xf1','\x79'},{'\xc3','\x40'},
+    {'\xf1','\x7a'},{'\x8d','\x7e'},{'\x00','\x00'},{'\x9e','\xec'},{'\x97','\xa6'},
+    {'\xf3','\xa1'},{'\xfd','\xcc'},{'\x00','\x00'},{'\xf3','\xa3'},{'\xf3','\xa2'},
+    {'\xfd','\xcd'},{'\xf5','\x4a'},{'\xfd','\xce'},{'\xf5','\x4b'},{'\x00','\x00'},
+    {'\x9e','\xed'},{'\xfd','\xcf'},{'\xf6','\x70'},{'\x9e','\xee'},{'\xc5','\xb7'},
+    {'\x9e','\xef'},{'\xc5','\xb6'},{'\xf8','\x4f'},{'\xf8','\x50'},{'\xc6','\x48'},
+    {'\xf8','\xd1'},{'\xfd','\xd0'},{'\xc6','\x69'},{'\x00','\x00'},{'\xad','\xb3'},
+    {'\xb6','\xb4'},{'\xe4','\xca'},{'\xe4','\xc9'},{'\xe8','\xb5'},{'\xe8','\xb4'},
+    {'\x00','\x00'},{'\x9e','\xf0'},{'\xc1','\xfa'},{'\xef','\x43'},{'\xef','\x42'},
+    {'\xf1','\xa5'},{'\xf1','\xa3'},{'\xf1','\xa6'},{'\xf1','\xa4'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xc3','\xfc'},{'\xf3','\xa4'},{'\xf3','\xa5'},{'\xf3','\xa6'},
+    {'\x9e','\xf1'},{'\xf6','\x71'},{'\x00','\x00'},{'\xf7','\x72'},{'\x00','\x00'},
+    {'\xf8','\xd2'},{'\x83','\xa3'},{'\x85','\xa4'},{'\x00','\x00'},{'\x8a','\xb0'},
+    {'\x8f','\xab'},{'\x8f','\xce'},{'\x8b','\xdb'},{'\xad','\xb4'},{'\x95','\x61'},
+    {'\x00','\x00'},{'\xec','\x57'},{'\xef','\x44'},{'\x97','\xa7'},{'\xad','\xb5'},
+    {'\x00','\x00'},{'\x8b','\xdc'},{'\xbb','\xe0'},{'\x00','\x00'},{'\xec','\x58'},
+    {'\xc3','\x41'},{'\xf1','\xa7'},{'\xc3','\xfd'},{'\x00','\x00'},{'\xf5','\x4c'},
+    {'\xf5','\x4d'},{'\xc5','\x54'},{'\xf8','\x51'},{'\xad','\xb6'},{'\xb3','\xbb'},
+    {'\xb3','\xbc'},{'\xd8','\x4e'},{'\xb6','\xb5'},{'\xb6','\xb6'},{'\xdc','\xac'},
+    {'\xb6','\xb7'},{'\x00','\x00'},{'\xb9','\x7a'},{'\x00','\x00'},{'\xb9','\x7c'},
+    {'\xe0','\xdf'},{'\xe0','\xe0'},{'\xe0','\xde'},{'\xb9','\x77'},{'\xb9','\x78'},
+    {'\xb9','\x7b'},{'\xb9','\x79'},{'\x9e','\xf2'},{'\x9e','\xf3'},{'\xe4','\xcb'},
+    {'\xbb','\xe1'},{'\xbb','\xe2'},{'\x00','\x00'},{'\x82','\x5b'},{'\xe8','\xbc'},
+    {'\xbe','\x67'},{'\xe8','\xb7'},{'\xe8','\xb6'},{'\xfd','\xd2'},{'\xe8','\xbb'},
+    {'\xbe','\x65'},{'\x00','\x00'},{'\x9e','\xf4'},{'\xc0','\x5b'},{'\x00','\x00'},
+    {'\xe8','\xb8'},{'\xe8','\xbd'},{'\xe8','\xba'},{'\xe8','\xb9'},{'\x00','\x00'},
+    {'\xbe','\x66'},{'\x82','\x7b'},{'\xc0','\x59'},{'\xfd','\xd3'},{'\xec','\x5a'},
+    {'\xc0','\x55'},{'\x00','\x00'},{'\xec','\x5b'},{'\x9e','\xf5'},{'\x82','\x42'},
+    {'\xec','\x59'},{'\x00','\x00'},{'\xc0','\x58'},{'\xc0','\x56'},{'\xc0','\x5a'},
+    {'\x00','\x00'},{'\xc0','\x57'},{'\x93','\xdf'},{'\x97','\xa8'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xef','\x45'},{'\x00','\x00'},{'\xef','\x4a'},
+    {'\xef','\x46'},{'\xef','\x49'},{'\xc1','\xfb'},{'\xfd','\xd5'},{'\xed','\xd4'},
+    {'\xef','\x48'},{'\xef','\x47'},{'\xfd','\xd6'},{'\xc3','\x44'},{'\xc3','\x42'},
+    {'\xc3','\x45'},{'\xc3','\x43'},{'\xf1','\xa8'},{'\xf1','\xa9'},{'\xf1','\xaa'},
+    {'\xc3','\x46'},{'\x97','\xa9'},{'\x92','\xb8'},{'\x9d','\xd2'},{'\xf3','\xaa'},
+    {'\xc4','\x40'},{'\xf3','\xa8'},{'\x00','\x00'},{'\xc4','\x41'},{'\xf3','\xa7'},
+    {'\xf3','\xa9'},{'\xc3','\xfe'},{'\xf5','\x51'},{'\xf5','\x4e'},{'\x00','\x00'},
+    {'\xf5','\x4f'},{'\xf5','\x50'},{'\xf6','\x72'},{'\xc5','\x56'},{'\xfd','\xd7'},
+    {'\xc5','\x55'},{'\x9e','\xf6'},{'\xf7','\x74'},{'\xf7','\x73'},{'\xc5','\xb8'},
+    {'\xfd','\xd8'},{'\x00','\x00'},{'\x00','\x00'},{'\xc5','\xe3'},{'\xc6','\x49'},
+    {'\xc6','\x60'},{'\xf9','\x58'},{'\xf9','\xae'},{'\xf9','\xaf'},{'\x83','\xa4'},
+    {'\x84','\xbc'},{'\x84','\xbd'},{'\x8d','\xfa'},{'\x85','\xa5'},{'\x85','\xa6'},
+    {'\x85','\xa7'},{'\x86','\x7e'},{'\x86','\x7c'},{'\x8c','\xb8'},{'\x86','\x7d'},
+    {'\x8e','\x62'},{'\x86','\xa1'},{'\x86','\xa2'},{'\x8e','\x61'},{'\x86','\x7b'},
+    {'\x8d','\x77'},{'\x87','\x74'},{'\x87','\x73'},{'\x89','\xb0'},{'\x88','\xb3'},
+    {'\x89','\xaf'},{'\x00','\x00'},{'\x88','\xb4'},{'\x8e','\xba'},{'\x00','\x00'},
+    {'\x8e','\xdc'},{'\x89','\xb5'},{'\x89','\xb1'},{'\x00','\x00'},{'\x89','\xb4'},
+    {'\x89','\xb2'},{'\x00','\x00'},{'\x89','\x46'},{'\x8a','\xb1'},{'\x8b','\x5f'},
+    {'\x00','\x00'},{'\x8b','\x60'},{'\x8b','\x61'},{'\x8b','\x5e'},{'\x8b','\x5d'},
+    {'\x90','\xa7'},{'\x8f','\xf0'},{'\x8b','\xde'},{'\x8f','\xcf'},{'\x8c','\xb9'},
+    {'\x00','\x00'},{'\x8c','\xe9'},{'\x97','\xaa'},{'\x8d','\x61'},{'\x90','\xa8'},
+    {'\xad','\xb7'},{'\xdc','\xad'},{'\x94','\xe2'},{'\x00','\x00'},{'\xe0','\xe1'},
+    {'\xe4','\xcc'},{'\xe4','\xcd'},{'\xbb','\xe3'},{'\x00','\x00'},{'\xbb','\xe4'},
+    {'\xe8','\xbe'},{'\xbe','\x68'},{'\xfd','\xd9'},{'\x00','\x00'},{'\xc1','\xfc'},
+    {'\x9e','\xf7'},{'\xf1','\xab'},{'\x9e','\xf8'},{'\xc3','\x47'},{'\xf3','\xad'},
+    {'\xc4','\x42'},{'\xf3','\xac'},{'\xf3','\xae'},{'\xf3','\xab'},{'\xf6','\x75'},
+    {'\xf5','\x52'},{'\xf5','\x53'},{'\x97','\xab'},{'\xc4','\xc6'},{'\x00','\x00'},
+    {'\xf6','\x74'},{'\x9e','\xf9'},{'\xfb','\xb2'},{'\xf6','\x73'},{'\x9e','\xfa'},
+    {'\xf7','\x75'},{'\xf9','\xb0'},{'\x00','\x00'},{'\x83','\xa5'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8e','\xae'},{'\x87','\x75'},{'\x8a','\xb2'},{'\x00','\x00'},
+    {'\x8b','\xdf'},{'\x00','\x00'},{'\x00','\x00'},{'\x8c','\x61'},{'\x90','\x4a'},
+    {'\x97','\xac'},{'\xad','\xb8'},{'\xfd','\xdb'},{'\x00','\x00'},{'\x83','\xa6'},
+    {'\xad','\xb9'},{'\x9e','\xfb'},{'\x9e','\xfc'},{'\xb0','\xa7'},{'\xd4','\x48'},
+    {'\x00','\x00'},{'\xd8','\x4f'},{'\xfd','\xdc'},{'\xb6','\xb8'},{'\x8c','\xba'},
+    {'\xb6','\xbb'},{'\xb6','\xb9'},{'\xdc','\xae'},{'\x9e','\xfd'},{'\xb6','\xbd'},
+    {'\x97','\xad'},{'\xb6','\xba'},{'\x00','\x00'},{'\x95','\xda'},{'\xb6','\xbc'},
+    {'\x00','\x00'},{'\xb9','\x7e'},{'\x9e','\xfe'},{'\xe0','\xe2'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xe0','\xe3'},{'\xe8','\xc0'},{'\x00','\x00'},{'\xb9','\x7d'},
+    {'\xb9','\xa1'},{'\xb9','\xa2'},{'\x00','\x00'},{'\xe4','\xcf'},{'\x00','\x00'},
+    {'\xe4','\xce'},{'\xbb','\xe5'},{'\x00','\x00'},{'\xbb','\xe6'},{'\x00','\x00'},
+    {'\xe4','\xd0'},{'\xe8','\xbf'},{'\xbb','\xe8'},{'\xbe','\x69'},{'\x00','\x00'},
+    {'\xbb','\xe7'},{'\x8d','\x47'},{'\x9f','\x70'},{'\x00','\x00'},{'\xc0','\x5c'},
+    {'\xe8','\xc1'},{'\xbe','\x6b'},{'\xbe','\x6a'},{'\xe8','\xc2'},{'\xe8','\xc5'},
+    {'\xe8','\xc3'},{'\xe8','\xc4'},{'\xbe','\x6c'},{'\x9f','\x71'},{'\xc0','\x61'},
+    {'\xc0','\x5f'},{'\x9f','\x72'},{'\x97','\xae'},{'\xc0','\x5e'},{'\xec','\x5d'},
+    {'\x97','\xaf'},{'\xc0','\x60'},{'\x00','\x00'},{'\x00','\x00'},{'\xec','\x5c'},
+    {'\xef','\x4b'},{'\x00','\x00'},{'\xec','\x5e'},{'\xc0','\x5d'},{'\xec','\x5f'},
+    {'\xef','\x4e'},{'\xef','\x4c'},{'\xef','\x4d'},{'\xef','\x52'},{'\xc3','\x4b'},
+    {'\xef','\x51'},{'\xef','\x54'},{'\xef','\x53'},{'\xef','\x50'},{'\xef','\x4f'},
+    {'\x00','\x00'},{'\xc1','\xfd'},{'\x00','\x00'},{'\x9f','\x73'},{'\xa0','\x44'},
+    {'\xfd','\xde'},{'\xf1','\xae'},{'\xfd','\xdf'},{'\xf1','\xad'},{'\xc3','\x4a'},
+    {'\xc3','\x48'},{'\xc3','\x49'},{'\xfb','\xb3'},{'\xf1','\xac'},{'\xfd','\xdd'},
+    {'\xf3','\xb1'},{'\x00','\x00'},{'\xc4','\x43'},{'\x00','\x00'},{'\xf3','\xb0'},
+    {'\xf3','\xaf'},{'\xc4','\x44'},{'\xfd','\xe1'},{'\xf5','\x58'},{'\xf5','\x57'},
+    {'\xfb','\xb4'},{'\xf5','\x55'},{'\x00','\x00'},{'\xf5','\x54'},{'\xc4','\xc8'},
+    {'\xc4','\xc7'},{'\xf5','\x59'},{'\xf7','\x76'},{'\xc5','\xb9'},{'\xf6','\x77'},
+    {'\xc5','\x57'},{'\xf6','\x76'},{'\xf5','\x56'},{'\x00','\x00'},{'\xf7','\x77'},
+    {'\xc5','\xe4'},{'\x9f','\x74'},{'\xc6','\x61'},{'\xf9','\x59'},{'\x00','\x00'},
+    {'\xf9','\xb1'},{'\x9f','\x75'},{'\x97','\xb0'},{'\x00','\x00'},{'\x83','\xe8'},
+    {'\x00','\x00'},{'\x8f','\x6d'},{'\x85','\xaa'},{'\x8f','\xac'},{'\x85','\xa8'},
+    {'\x8d','\xfb'},{'\x85','\xac'},{'\x85','\xa9'},{'\x85','\xab'},{'\x89','\xb7'},
+    {'\x86','\xa6'},{'\x86','\xa5'},{'\x86','\xa3'},{'\x00','\x00'},{'\x86','\xa4'},
+    {'\x87','\x78'},{'\x8c','\x62'},{'\x87','\x79'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x87','\x76'},{'\x00','\x00'},{'\x87','\x77'},{'\x8e','\xdd'},{'\x00','\x00'},
+    {'\x88','\xb6'},{'\x97','\xb1'},{'\x88','\xb7'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x89','\xb8'},{'\x89','\xb9'},{'\x89','\xb6'},{'\x97','\xb2'},{'\x8b','\x64'},
+    {'\x00','\x00'},{'\x8b','\x63'},{'\x8d','\x78'},{'\x00','\x00'},{'\x97','\xb3'},
+    {'\x00','\x00'},{'\x8b','\x62'},{'\x8f','\xd0'},{'\x8b','\xe1'},{'\x8b','\xe0'},
+    {'\x97','\xb4'},{'\x8f','\xf1'},{'\x97','\xb5'},{'\xad','\xba'},{'\xd8','\x50'},
+    {'\xef','\x55'},{'\xad','\xbb'},{'\x00','\x00'},{'\x9f','\x76'},{'\xe4','\xd2'},
+    {'\xe4','\xd1'},{'\xec','\x60'},{'\x00','\x00'},{'\x00','\x00'},{'\xef','\x57'},
+    {'\x00','\x00'},{'\xef','\x56'},{'\x9f','\x77'},{'\xc3','\x4c'},{'\xf3','\xb2'},
+    {'\xf3','\xb3'},{'\xc4','\xc9'},{'\x00','\x00'},{'\x9f','\x78'},{'\xf9','\xb2'},
+    {'\xb0','\xa8'},{'\xb6','\xbf'},{'\xb6','\xbe'},{'\xe0','\xe4'},{'\xe0','\xe6'},
+    {'\xb9','\xa4'},{'\xe0','\xe5'},{'\xb9','\xa3'},{'\xb9','\xa5'},{'\xe0','\xe7'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x9f','\x79'},{'\xe4','\xd4'},{'\xe4','\xd6'},
+    {'\xe4','\xd5'},{'\x97','\xb6'},{'\xe4','\xd8'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xbb','\xe9'},{'\xe4','\xd7'},{'\xe4','\xd3'},{'\x94','\x4b'},
+    {'\x92','\x4a'},{'\x92','\xa3'},{'\xe4','\xd9'},{'\x97','\xb7'},{'\xe8','\xcc'},
+    {'\x00','\x00'},{'\xe8','\xcf'},{'\xe8','\xd1'},{'\xe8','\xc7'},{'\xe8','\xcb'},
+    {'\xe8','\xc8'},{'\xbe','\x6e'},{'\xbe','\x71'},{'\xbe','\x73'},{'\xe8','\xc9'},
+    {'\xe8','\xca'},{'\xbe','\x72'},{'\xe8','\xcd'},{'\xe8','\xd0'},{'\xe8','\xce'},
+    {'\xbe','\x74'},{'\xfd','\xe4'},{'\xbe','\x70'},{'\xe8','\xc6'},{'\xbe','\x6d'},
+    {'\x00','\x00'},{'\xbe','\x6f'},{'\x9f','\x7a'},{'\x95','\xc4'},{'\xc0','\x63'},
+    {'\xec','\x66'},{'\xec','\x64'},{'\xec','\x63'},{'\x9f','\x7b'},{'\xec','\x69'},
+    {'\x00','\x00'},{'\xec','\x68'},{'\xec','\x67'},{'\x00','\x00'},{'\xec','\x62'},
+    {'\xc0','\x62'},{'\xec','\x61'},{'\x00','\x00'},{'\xec','\x65'},{'\xc0','\x64'},
+    {'\x97','\xb8'},{'\x00','\x00'},{'\xef','\x5a'},{'\x9f','\x7c'},{'\xef','\x5e'},
+    {'\xef','\x5b'},{'\xef','\x5d'},{'\xef','\x5c'},{'\xef','\x59'},{'\xef','\x5f'},
+    {'\xef','\x62'},{'\xef','\x60'},{'\xef','\x61'},{'\xc2','\x40'},{'\x00','\x00'},
+    {'\xc1','\xfe'},{'\xef','\x58'},{'\xef','\x63'},{'\xf1','\xb3'},{'\xf1','\xb6'},
+    {'\xf1','\xb8'},{'\xf1','\xb7'},{'\x00','\x00'},{'\xf1','\xb1'},{'\xf1','\xb5'},
+    {'\xf1','\xb0'},{'\xfb','\xb5'},{'\xf1','\xb2'},{'\xc3','\x4d'},{'\xf1','\xaf'},
+    {'\x95','\xe1'},{'\xf1','\xb4'},{'\x93','\x5d'},{'\x92','\xb9'},{'\xf3','\xc0'},
+    {'\xf3','\xb5'},{'\xc4','\x45'},{'\x00','\x00'},{'\x00','\x00'},{'\xc4','\x46'},
+    {'\xf3','\xb4'},{'\xf3','\xb9'},{'\xf3','\xbf'},{'\xf3','\xb7'},{'\xf3','\xbe'},
+    {'\x9f','\x7d'},{'\xf3','\xbb'},{'\x9a','\xfb'},{'\xf3','\xba'},{'\xf3','\xbd'},
+    {'\xf3','\xb8'},{'\xf3','\xb6'},{'\x9a','\xfc'},{'\xf3','\xbc'},{'\x82','\x55'},
+    {'\xf5','\x60'},{'\xf5','\x5e'},{'\xc4','\xca'},{'\xf5','\x5d'},{'\xf5','\x63'},
+    {'\xf5','\x61'},{'\x9a','\xfd'},{'\xc4','\xcb'},{'\xf5','\x5c'},{'\xf5','\x5a'},
+    {'\x00','\x00'},{'\xf5','\x5b'},{'\xc4','\xcd'},{'\xf5','\x5f'},{'\xc4','\xcc'},
+    {'\xf5','\x62'},{'\xf6','\x78'},{'\xf6','\x7e'},{'\x9c','\xfa'},{'\x9c','\xfb'},
+    {'\xf6','\x79'},{'\xc5','\x5b'},{'\xf6','\xa1'},{'\xc5','\x5a'},{'\xf6','\x7d'},
+    {'\xf6','\x7c'},{'\xc5','\x59'},{'\xf6','\x7b'},{'\xc5','\x58'},{'\xf6','\x7a'},
+    {'\x00','\x00'},{'\xf7','\x7d'},{'\xf7','\xa1'},{'\xf7','\x7e'},{'\x00','\x00'},
+    {'\xf7','\x7b'},{'\xc5','\xbb'},{'\xf7','\x78'},{'\xf7','\x7c'},{'\xf7','\xa3'},
+    {'\x00','\x00'},{'\xf7','\xa2'},{'\xf7','\x79'},{'\xf7','\x7a'},{'\xc5','\xba'},
+    {'\xf8','\x52'},{'\xc5','\xe7'},{'\x9c','\xfc'},{'\xf8','\x53'},{'\xc5','\xe5'},
+    {'\xc5','\xe6'},{'\x9c','\xfd'},{'\x00','\x00'},{'\xf8','\xd3'},{'\xc6','\x4a'},
+    {'\xf9','\x76'},{'\x00','\x00'},{'\xc6','\x6a'},{'\x9c','\xfe'},{'\xf9','\xb3'},
+    {'\xc6','\x6b'},{'\xf9','\xb4'},{'\xf9','\xb5'},{'\xf9','\xc3'},{'\xf9','\xc2'},
+    {'\xc6','\x7a'},{'\xf9','\xcd'},{'\x83','\xe9'},{'\x85','\xae'},{'\x86','\xa8'},
+    {'\x86','\xa9'},{'\x86','\xa7'},{'\x8c','\xbb'},{'\x00','\x00'},{'\x87','\x7a'},
+    {'\x8d','\xa1'},{'\x8e','\xde'},{'\x88','\xbb'},{'\x88','\xba'},{'\x88','\xbf'},
+    {'\x88','\xbe'},{'\x8f','\xf2'},{'\x88','\xb9'},{'\x88','\xb8'},{'\x88','\xbc'},
+    {'\x88','\xbd'},{'\x8d','\x49'},{'\x8e','\xdf'},{'\x8c','\xeb'},{'\x88','\x4c'},
+    {'\x00','\x00'},{'\x8c','\xea'},{'\x90','\x63'},{'\x89','\xbc'},{'\x89','\xba'},
+    {'\x89','\xbb'},{'\x00','\x00'},{'\x8d','\xaf'},{'\x8a','\xb3'},{'\x8d','\x4a'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x8a','\xb4'},{'\x8f','\xad'},{'\x8b','\x65'},
+    {'\x8f','\xae'},{'\x8f','\xaf'},{'\x00','\x00'},{'\x00','\x00'},{'\x90','\x4c'},
+    {'\x8b','\xe3'},{'\x8f','\xf5'},{'\x00','\x00'},{'\x8c','\x66'},{'\x8b','\xe2'},
+    {'\x90','\x4d'},{'\x8f','\xf3'},{'\x8c','\x64'},{'\x8f','\xf4'},{'\x8c','\xbc'},
+    {'\x8c','\xbe'},{'\x90','\x4b'},{'\x90','\x62'},{'\x8d','\x62'},{'\x8d','\xa2'},
+    {'\x00','\x00'},{'\x90','\xa9'},{'\xb0','\xa9'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe0','\xe9'},{'\x00','\x00'},{'\xe0','\xe8'},{'\x00','\x00'},{'\xbb','\xea'},
+    {'\xbb','\xeb'},{'\xe4','\xda'},{'\x9d','\xb0'},{'\xe8','\xd2'},{'\xec','\x6c'},
+    {'\x00','\x00'},{'\x97','\xb9'},{'\xbe','\x75'},{'\xc0','\x65'},{'\xec','\x6a'},
+    {'\xfd','\xe6'},{'\xec','\x6d'},{'\xc0','\x66'},{'\xfd','\xe7'},{'\xef','\x64'},
+    {'\xec','\x6b'},{'\xf1','\xb9'},{'\xc3','\x4e'},{'\xf3','\xc1'},{'\x00','\x00'},
+    {'\x92','\xfb'},{'\x8c','\xbf'},{'\xf5','\x66'},{'\xf5','\x64'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xf5','\x65'},{'\x8d','\x79'},{'\x90','\x79'},{'\xf6','\xa2'},
+    {'\x00','\x00'},{'\xc5','\x5c'},{'\xf7','\xa4'},{'\xc5','\xea'},{'\xc5','\xbc'},
+    {'\xc5','\xe8'},{'\xc5','\xe9'},{'\xf8','\xd4'},{'\xc6','\x62'},{'\xfb','\xb6'},
+    {'\xb0','\xaa'},{'\x97','\xba'},{'\x00','\x00'},{'\x00','\x00'},{'\xf1','\xba'},
+    {'\x00','\x00'},{'\x97','\xbb'},{'\xd4','\x49'},{'\x9d','\xb1'},{'\xb9','\xa6'},
+    {'\xfd','\xec'},{'\xe4','\xdb'},{'\x00','\x00'},{'\x00','\x00'},{'\xbb','\xec'},
+    {'\xe4','\xdc'},{'\x00','\x00'},{'\x00','\x00'},{'\x93','\xba'},{'\xe8','\xd4'},
+    {'\xe8','\xd3'},{'\xc0','\x68'},{'\xbe','\x76'},{'\xbe','\x77'},{'\x00','\x00'},
+    {'\xe8','\xd7'},{'\xe8','\xd6'},{'\xe8','\xd5'},{'\xfe','\x57'},{'\x00','\x00'},
+    {'\xec','\x6e'},{'\xec','\x71'},{'\x00','\x00'},{'\xec','\x70'},{'\xec','\x6f'},
+    {'\xc0','\x67'},{'\xef','\x68'},{'\xef','\x66'},{'\xef','\x65'},{'\xfd','\xee'},
+    {'\x00','\x00'},{'\xef','\x67'},{'\xfd','\xed'},{'\xc3','\x4f'},{'\xf1','\xbc'},
+    {'\xf1','\xbd'},{'\xc3','\x50'},{'\x00','\x00'},{'\xf1','\xbb'},{'\xfd','\xf0'},
+    {'\xf3','\xc3'},{'\xf3','\xc2'},{'\xf3','\xc5'},{'\xc4','\x47'},{'\xf3','\xc4'},
+    {'\x97','\xbc'},{'\xf5','\x67'},{'\xf5','\x69'},{'\xf5','\x68'},{'\x8d','\x63'},
+    {'\x9d','\xb2'},{'\xf6','\xa3'},{'\xf6','\xa6'},{'\xf6','\xa4'},{'\xf6','\xa5'},
+    {'\xf7','\xa5'},{'\xc5','\xbd'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf8','\x54'},{'\xf8','\x55'},{'\xf8','\x56'},{'\x00','\x00'},{'\xc6','\x4b'},
+    {'\xc6','\x63'},{'\xf9','\xb6'},{'\xb0','\xab'},{'\x00','\x00'},{'\xbe','\x78'},
+    {'\xc0','\x69'},{'\xf1','\xbe'},{'\xfd','\xe9'},{'\xf7','\xa6'},{'\x00','\x00'},
+    {'\xfd','\xeb'},{'\xf9','\xc4'},{'\xd4','\x4a'},{'\x00','\x00'},{'\xc6','\x7b'},
+    {'\xb0','\xac'},{'\xec','\x72'},{'\x9d','\xb3'},{'\xf1','\xbf'},{'\x00','\x00'},
+    {'\xf3','\xc6'},{'\x00','\x00'},{'\x9d','\xb4'},{'\xf6','\xa7'},{'\xf7','\xa7'},
+    {'\xb0','\xad'},{'\x00','\x00'},{'\xe4','\xdd'},{'\xe4','\xde'},{'\x9d','\xb5'},
+    {'\xbb','\xed'},{'\xbb','\xee'},{'\xe8','\xd9'},{'\xbe','\x7a'},{'\xbe','\x79'},
+    {'\xe8','\xd8'},{'\x8d','\x64'},{'\xef','\x69'},{'\x97','\xbd'},{'\xf1','\xc0'},
+    {'\xf1','\xc2'},{'\xf1','\xc1'},{'\xc3','\x53'},{'\xc3','\x52'},{'\xc3','\x51'},
+    {'\x9d','\xb6'},{'\xc5','\x5e'},{'\xf6','\xa8'},{'\x00','\x00'},{'\xc5','\x5d'},
+    {'\xf7','\xa9'},{'\xf7','\xa8'},{'\x00','\x00'},{'\xc6','\x4c'},{'\xf8','\xd5'},
+    {'\xb3','\xbd'},{'\xe0','\xea'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe4','\xe1'},{'\xe4','\xdf'},{'\xe4','\xe0'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xe8','\xe2'},{'\x00','\x00'},{'\xe8','\xdd'},{'\xe8','\xda'},{'\xe8','\xe1'},
+    {'\xfe','\xaf'},{'\x00','\x00'},{'\x00','\x00'},{'\xe8','\xe3'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xbe','\x7c'},{'\xe8','\xe0'},{'\xe8','\xdc'},{'\x97','\xbe'},
+    {'\x00','\x00'},{'\xe8','\xdb'},{'\xe8','\xdf'},{'\xe8','\xde'},{'\xbe','\x7b'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xec','\x7d'},{'\xec','\x78'},{'\xec','\x76'},
+    {'\xec','\xa1'},{'\xec','\x77'},{'\x9d','\xb7'},{'\xec','\x73'},{'\x9d','\xee'},
+    {'\xec','\x79'},{'\x97','\xbf'},{'\x00','\x00'},{'\xec','\x74'},{'\xef','\x72'},
+    {'\xec','\x75'},{'\xec','\xa2'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xef'},
+    {'\x00','\x00'},{'\x9d','\xf0'},{'\x94','\xfe'},{'\xfd','\xf3'},{'\xec','\x7c'},
+    {'\xc0','\x6a'},{'\xec','\x7b'},{'\xec','\x7a'},{'\x00','\x00'},{'\xec','\x7e'},
+    {'\x94','\xe3'},{'\x94','\xe4'},{'\x00','\x00'},{'\x00','\x00'},{'\xef','\x6a'},
+    {'\xef','\x6d'},{'\x00','\x00'},{'\xfd','\xf4'},{'\xef','\x6c'},{'\x97','\xc0'},
+    {'\xef','\x74'},{'\xef','\x6f'},{'\xef','\x73'},{'\x00','\x00'},{'\xef','\x71'},
+    {'\xef','\x70'},{'\xef','\x6e'},{'\x00','\x00'},{'\xef','\x6b'},{'\x00','\x00'},
+    {'\xc2','\x43'},{'\xc2','\x42'},{'\x00','\x00'},{'\xc2','\x44'},{'\xc2','\x41'},
+    {'\xef','\x75'},{'\xfd','\xf5'},{'\x94','\xf5'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x94','\xe5'},{'\xf1','\xc8'},{'\xf1','\xcb'},{'\x00','\x00'},{'\xf1','\xc9'},
+    {'\xf1','\xcd'},{'\x00','\x00'},{'\x97','\xc1'},{'\x00','\x00'},{'\xf1','\xce'},
+    {'\x00','\x00'},{'\xf1','\xc6'},{'\xc3','\x58'},{'\xf1','\xc7'},{'\x00','\x00'},
+    {'\xf1','\xc5'},{'\xf1','\xcc'},{'\x00','\x00'},{'\xf1','\xc4'},{'\xf1','\xc3'},
+    {'\xc3','\x57'},{'\xc3','\x55'},{'\xc3','\x54'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x94','\xe6'},{'\x00','\x00'},{'\x94','\xe7'},
+    {'\x94','\xe8'},{'\xf1','\xca'},{'\xf3','\xcf'},{'\xf3','\xd5'},{'\xc4','\x4a'},
+    {'\xf3','\xd0'},{'\x00','\x00'},{'\xf3','\xd3'},{'\xf3','\xd7'},{'\xc4','\x4b'},
+    {'\xf3','\xd2'},{'\x9d','\xf1'},{'\xf3','\xca'},{'\x00','\x00'},{'\xf3','\xc9'},
+    {'\xf3','\xd6'},{'\xf3','\xcd'},{'\x97','\xc2'},{'\xf3','\xcb'},{'\xf3','\xd4'},
+    {'\xf3','\xcc'},{'\xc4','\x49'},{'\xc4','\x48'},{'\x9d','\xf2'},{'\xf3','\xc7'},
+    {'\xf3','\xc8'},{'\xf3','\xd1'},{'\x9d','\xf3'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf3','\xce'},{'\x94','\xea'},{'\x94','\xe9'},{'\x00','\x00'},{'\x9d','\xf4'},
+    {'\x97','\xc3'},{'\x00','\x00'},{'\xf5','\x6c'},{'\xf5','\x6f'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xc3','\x56'},{'\x00','\x00'},
+    {'\xfd','\xf9'},{'\x97','\xc4'},{'\x00','\x00'},{'\xfe','\x50'},{'\x00','\x00'},
+    {'\x97','\xc5'},{'\xf5','\x6d'},{'\xf5','\x73'},{'\xf5','\x71'},{'\xf5','\x6b'},
+    {'\xf5','\x76'},{'\xfd','\xf8'},{'\xf5','\x6a'},{'\xfd','\xf6'},{'\xc4','\xcf'},
+    {'\xf5','\x72'},{'\x00','\x00'},{'\x95','\xfd'},{'\x00','\x00'},{'\xf5','\x6e'},
+    {'\xc4','\xce'},{'\xf5','\x75'},{'\xfd','\xf7'},{'\x00','\x00'},{'\xf5','\x74'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x97','\xc6'},{'\xf6','\xab'},
+    {'\xf6','\xaa'},{'\x00','\x00'},{'\x9d','\xf5'},{'\x9d','\xf6'},{'\xf6','\xb1'},
+    {'\x00','\x00'},{'\xf6','\xad'},{'\xf6','\xb0'},{'\xc5','\x60'},{'\x9d','\xf7'},
+    {'\x00','\x00'},{'\xf6','\xae'},{'\xf6','\xaf'},{'\x00','\x00'},{'\xf6','\xa9'},
+    {'\xf6','\xac'},{'\xc5','\x5f'},{'\xfd','\xfa'},{'\x94','\xf9'},{'\x94','\xeb'},
+    {'\xc5','\xbf'},{'\xf7','\xb4'},{'\xf7','\xaf'},{'\xf7','\xb3'},{'\xfd','\x53'},
+    {'\xf7','\xb6'},{'\xf7','\xb2'},{'\x00','\x00'},{'\xf7','\xae'},{'\xfc','\xcb'},
+    {'\xc5','\xc1'},{'\xf7','\xb1'},{'\xf7','\xb5'},{'\xc5','\xc0'},{'\xf7','\xac'},
+    {'\xf5','\x70'},{'\xf7','\xb0'},{'\x00','\x00'},{'\x00','\x00'},{'\xf7','\xad'},
+    {'\xfd','\x70'},{'\xf7','\xaa'},{'\x94','\xec'},{'\xf7','\xab'},{'\xc5','\xbe'},
+    {'\xf8','\x5a'},{'\xf8','\x5c'},{'\xf8','\x5f'},{'\xf8','\x5b'},{'\xf8','\x60'},
+    {'\x9f','\x50'},{'\xf8','\x59'},{'\x00','\x00'},{'\xf8','\x57'},{'\x9d','\xf8'},
+    {'\xc5','\xeb'},{'\xf8','\x5d'},{'\xc5','\xed'},{'\xc5','\xec'},{'\xf8','\x58'},
+    {'\xf8','\x5e'},{'\x94','\xed'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xf9'},
+    {'\xf8','\xda'},{'\xc6','\x4d'},{'\xf8','\xdb'},{'\x00','\x00'},{'\xf8','\xd9'},
+    {'\xf8','\xd6'},{'\x00','\x00'},{'\x00','\x00'},{'\xf8','\xd8'},{'\xf8','\xd7'},
+    {'\xf9','\x5a'},{'\x94','\xf6'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf9','\x5c'},{'\xf9','\x5b'},{'\x00','\x00'},{'\x00','\x00'},{'\xf9','\x79'},
+    {'\xfb','\x78'},{'\xf9','\x78'},{'\xf9','\x77'},{'\xf9','\x7a'},{'\x98','\x40'},
+    {'\xc6','\x73'},{'\xc6','\x74'},{'\xf9','\xca'},{'\xf9','\xce'},{'\x9d','\xfa'},
+    {'\x84','\xbe'},{'\x00','\x00'},{'\x00','\x00'},{'\x88','\xc2'},{'\x00','\x00'},
+    {'\x88','\xc3'},{'\x8e','\xe0'},{'\x00','\x00'},{'\x00','\x00'},{'\x98','\x4b'},
+    {'\x98','\x4c'},{'\x98','\x4d'},{'\x8d','\xab'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x98','\x4e'},{'\x00','\x00'},{'\x89','\xbf'},{'\x8d','\x65'},{'\x00','\x00'},
+    {'\x98','\x4f'},{'\x8a','\xb8'},{'\x8f','\x6e'},{'\x00','\x00'},{'\x8a','\xb7'},
+    {'\x8f','\x6f'},{'\x00','\x00'},{'\x90','\xf2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x90','\xa2'},{'\x8a','\xb6'},{'\x8a','\xb5'},{'\x00','\x00'},{'\x98','\x50'},
+    {'\x90','\x70'},{'\x8f','\xb2'},{'\x90','\xad'},{'\x8c','\xed'},{'\x90','\x65'},
+    {'\x8b','\x68'},{'\x90','\x4e'},{'\x90','\x66'},{'\x8b','\x6a'},{'\x8b','\x67'},
+    {'\x8f','\xb1'},{'\x00','\x00'},{'\x8b','\x69'},{'\x00','\x00'},{'\x8b','\xe6'},
+    {'\x98','\x51'},{'\x00','\x00'},{'\x98','\x52'},{'\x8f','\xd5'},{'\x98','\x53'},
+    {'\x8b','\xe5'},{'\x98','\x54'},{'\x8f','\xd2'},{'\x8f','\xd3'},{'\x8b','\xe7'},
+    {'\x8b','\xe4'},{'\x00','\x00'},{'\x98','\x55'},{'\x8f','\xd4'},{'\x98','\x56'},
+    {'\x98','\x57'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8c','\x67'},{'\x8d','\xaa'},{'\x8c','\x68'},{'\x98','\x58'},
+    {'\x98','\x59'},{'\x00','\x00'},{'\x00','\x00'},{'\x98','\x5a'},{'\x98','\x5b'},
+    {'\x8d','\x6a'},{'\x8c','\xc0'},{'\x90','\x4f'},{'\x8c','\xc1'},{'\x90','\x50'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x98','\x5c'},{'\x8c','\xee'},{'\x90','\x64'},
+    {'\x8c','\xec'},{'\x8c','\xef'},{'\x98','\x5d'},{'\x98','\x5e'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x8d','\x4f'},{'\x8d','\x4d'},{'\x8d','\x4e'},{'\x90','\x6f'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x98','\x5f'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xb3','\xbe'},{'\xdc','\xaf'},{'\xe0','\xed'},{'\x00','\x00'},{'\xb9','\xa7'},
+    {'\xe0','\xeb'},{'\x98','\x60'},{'\x98','\x61'},{'\xe0','\xec'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x94','\xee'},{'\xe4','\xe2'},{'\xe4','\xe3'},{'\xbb','\xf1'},
+    {'\xbb','\xef'},{'\xe4','\xe4'},{'\xbb','\xf0'},{'\xe8','\xe8'},{'\x00','\x00'},
+    {'\xe8','\xeb'},{'\xe8','\xe5'},{'\xe8','\xec'},{'\xe8','\xe4'},{'\xe8','\xe6'},
+    {'\x00','\x00'},{'\xe8','\xe7'},{'\xe8','\xea'},{'\x00','\x00'},{'\xfd','\x61'},
+    {'\xbe','\xa1'},{'\xe8','\xef'},{'\xe8','\xee'},{'\xbe','\x7d'},{'\xe8','\xe9'},
+    {'\xe8','\xed'},{'\xbe','\x7e'},{'\x00','\x00'},{'\x00','\x00'},{'\x9d','\xfb'},
+    {'\x00','\x00'},{'\x82','\x48'},{'\x00','\x00'},{'\xec','\xac'},{'\x00','\x00'},
+    {'\xc0','\x6f'},{'\x00','\x00'},{'\xec','\xa7'},{'\xc0','\x6b'},{'\x9d','\xfc'},
+    {'\xec','\xa4'},{'\xec','\xaa'},{'\xec','\xad'},{'\x00','\x00'},{'\xc0','\x70'},
+    {'\x00','\x00'},{'\xec','\xa9'},{'\xec','\xa6'},{'\xec','\xae'},{'\xec','\xa5'},
+    {'\x9f','\x40'},{'\xec','\xab'},{'\xc0','\x6c'},{'\x00','\x00'},{'\xec','\xa3'},
+    {'\xc0','\x6d'},{'\x00','\x00'},{'\xc0','\x6e'},{'\xec','\xa8'},{'\x98','\x62'},
+    {'\x94','\x47'},{'\x82','\x47'},{'\xef','\xa9'},{'\xef','\x7a'},{'\xef','\x7b'},
+    {'\xef','\x7e'},{'\xef','\x7c'},{'\x00','\x00'},{'\xef','\x76'},{'\x9f','\x41'},
+    {'\x00','\x00'},{'\xef','\x79'},{'\xef','\xa5'},{'\xef','\x7d'},{'\x9f','\x42'},
+    {'\x00','\x00'},{'\xc2','\x45'},{'\x00','\x00'},{'\xef','\xa7'},{'\xef','\xa4'},
+    {'\xc2','\x46'},{'\xef','\xa6'},{'\xef','\x77'},{'\xef','\xa2'},{'\xef','\xa3'},
+    {'\xfd','\xaa'},{'\xef','\xa1'},{'\x94','\xef'},{'\x94','\xf7'},{'\x98','\x63'},
+    {'\x9f','\x43'},{'\xf1','\xd2'},{'\xf1','\xd4'},{'\xf1','\xd7'},{'\x00','\x00'},
+    {'\x9f','\x44'},{'\xf1','\xd1'},{'\x98','\x64'},{'\xc3','\x59'},{'\xf1','\xd9'},
+    {'\xf1','\xd0'},{'\xf1','\xda'},{'\x00','\x00'},{'\xf1','\xd6'},{'\xf1','\xd8'},
+    {'\xf1','\xdc'},{'\xf1','\xd5'},{'\xf1','\xdd'},{'\xf1','\xd3'},{'\xf1','\xcf'},
+    {'\xc3','\x5a'},{'\x95','\x72'},{'\xf1','\xdb'},{'\xc3','\x5b'},{'\xc4','\x4d'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x94','\xf0'},{'\x94','\xf8'},{'\x00','\x00'},
+    {'\xef','\x78'},{'\xf3','\xf1'},{'\xf3','\xe8'},{'\xc4','\x4f'},{'\xf3','\xe4'},
+    {'\xc4','\x50'},{'\x9f','\x45'},{'\x9f','\x47'},{'\xf3','\xed'},{'\xf3','\xe7'},
+    {'\xf3','\xdd'},{'\xc4','\x4e'},{'\xf3','\xea'},{'\xf3','\xe5'},{'\xf3','\xe6'},
+    {'\x00','\x00'},{'\xf3','\xd8'},{'\xf3','\xdf'},{'\xf3','\xee'},{'\x98','\x65'},
+    {'\xf3','\xeb'},{'\x9f','\x48'},{'\xf3','\xe3'},{'\xfc','\xc6'},{'\xf3','\xef'},
+    {'\xf3','\xde'},{'\xf3','\xd9'},{'\xf3','\xec'},{'\x9f','\x49'},{'\xf3','\xdb'},
+    {'\xf3','\xe9'},{'\xf3','\xe0'},{'\xf3','\xf0'},{'\xf3','\xdc'},{'\xc4','\x4c'},
+    {'\xf3','\xda'},{'\xf3','\xe1'},{'\xf3','\xe2'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x92','\xaf'},{'\xf5','\x7d'},{'\x00','\x00'},{'\xf5','\x7b'},{'\x9f','\x4a'},
+    {'\xf5','\xa2'},{'\x00','\x00'},{'\xf5','\xae'},{'\xf5','\xa5'},{'\xf5','\x7c'},
+    {'\xf5','\x78'},{'\xf5','\xa7'},{'\xf5','\x7e'},{'\xf5','\xa3'},{'\xf5','\x7a'},
+    {'\xf5','\xaa'},{'\xf5','\x77'},{'\xf5','\xa1'},{'\xf5','\xa6'},{'\xf5','\xa8'},
+    {'\xf5','\xab'},{'\xf5','\x79'},{'\x9f','\x4b'},{'\xf5','\xaf'},{'\xf5','\xb0'},
+    {'\xf5','\xa9'},{'\xf5','\xad'},{'\xf5','\xa4'},{'\x94','\xf1'},{'\xf6','\xc1'},
+    {'\xf6','\xc4'},{'\x00','\x00'},{'\xc5','\x61'},{'\x00','\x00'},{'\xf6','\xc3'},
+    {'\xf6','\xc8'},{'\xf6','\xc6'},{'\xc5','\x62'},{'\xf6','\xbd'},{'\xf6','\xb3'},
+    {'\xf6','\xb2'},{'\xc5','\x64'},{'\xf6','\xbf'},{'\xf6','\xc0'},{'\xf6','\xbc'},
+    {'\xf6','\xb4'},{'\x9f','\x4d'},{'\xf6','\xb9'},{'\xf5','\xac'},{'\x9f','\x52'},
+    {'\xf6','\xb5'},{'\xc5','\x63'},{'\xf6','\xbb'},{'\x95','\x75'},{'\xf6','\xba'},
+    {'\x98','\x66'},{'\xf6','\xb6'},{'\xf6','\xc2'},{'\x9f','\x5e'},{'\xf6','\xb7'},
+    {'\xf7','\xbb'},{'\xf6','\xc5'},{'\xf6','\xc7'},{'\xf6','\xbe'},{'\xf6','\xb8'},
+    {'\xf7','\xbc'},{'\xf7','\xbe'},{'\xf7','\xb8'},{'\xc5','\xc2'},{'\x9f','\x5f'},
+    {'\xf7','\xc5'},{'\xf7','\xc3'},{'\xc5','\xc3'},{'\xf7','\xc2'},{'\xf7','\xc1'},
+    {'\xf7','\xba'},{'\xf7','\xb7'},{'\xf7','\xbd'},{'\xf7','\xc6'},{'\xf7','\xb9'},
+    {'\xf7','\xbf'},{'\x00','\x00'},{'\xf8','\x69'},{'\xf8','\x6e'},{'\xf8','\x64'},
+    {'\xf8','\x67'},{'\xc5','\xee'},{'\xf8','\x6b'},{'\x00','\x00'},{'\xf8','\x72'},
+    {'\xf7','\xc0'},{'\x00','\x00'},{'\xf8','\x65'},{'\xf8','\x6f'},{'\xf8','\x73'},
+    {'\xf8','\x6a'},{'\xf8','\x63'},{'\xf8','\x6d'},{'\x00','\x00'},{'\xf8','\x6c'},
+    {'\xf8','\x71'},{'\xf8','\x70'},{'\xf7','\xc4'},{'\xf8','\x68'},{'\xf8','\x62'},
+    {'\xf8','\x66'},{'\xc6','\x4e'},{'\xc6','\x4f'},{'\xf8','\x61'},{'\x9f','\x60'},
+    {'\xf8','\xe6'},{'\xf8','\xdd'},{'\xf8','\xe5'},{'\xf8','\xe2'},{'\xf8','\xe3'},
+    {'\xf8','\xdc'},{'\xf8','\xdf'},{'\xf8','\xe7'},{'\xf8','\xe1'},{'\xf8','\xe0'},
+    {'\xf8','\xde'},{'\x00','\x00'},{'\xf8','\xe4'},{'\x9f','\x61'},{'\xf9','\x5d'},
+    {'\x9f','\x62'},{'\xf9','\x5e'},{'\x9f','\x63'},{'\xf9','\x60'},{'\xf9','\x5f'},
+    {'\xf9','\x62'},{'\xf9','\x61'},{'\xf9','\x7c'},{'\xf9','\x7b'},{'\xf9','\xb7'},
+    {'\x00','\x00'},{'\xf9','\xb8'},{'\x9f','\x64'},{'\xf9','\xc5'},{'\xc6','\x78'},
+    {'\xc6','\x7c'},{'\xfd','\x4a'},{'\xf9','\xcf'},{'\xc6','\x7d'},{'\x84','\xbf'},
+    {'\x86','\xaa'},{'\x8b','\x5c'},{'\x87','\x7e'},{'\x87','\x7d'},{'\x00','\x00'},
+    {'\x8c','\xf1'},{'\x88','\xc5'},{'\x00','\x00'},{'\x8e','\xe1'},{'\x88','\xc4'},
+    {'\x89','\xc1'},{'\x8f','\xd7'},{'\x90','\xaa'},{'\x89','\xc3'},{'\x00','\x00'},
+    {'\x89','\xc2'},{'\x00','\x00'},{'\x8f','\x4e'},{'\x8f','\x4d'},{'\x89','\xc4'},
+    {'\x00','\x00'},{'\x89','\xc0'},{'\x8d','\x50'},{'\x90','\x68'},{'\x8f','\x70'},
+    {'\x8f','\x71'},{'\x8f','\x72'},{'\x00','\x00'},{'\x00','\x00'},{'\x8a','\xba'},
+    {'\x8d','\xb1'},{'\x8a','\xb9'},{'\x00','\x00'},{'\x8f','\xb4'},{'\x90','\xae'},
+    {'\x8b','\x6b'},{'\x8b','\x6d'},{'\x8b','\x6c'},{'\x8f','\xb5'},{'\x90','\x75'},
+    {'\x8f','\xb3'},{'\x8b','\xe9'},{'\x8b','\xea'},{'\x98','\x67'},{'\x8b','\xeb'},
+    {'\x00','\x00'},{'\x8f','\xd6'},{'\x8b','\xec'},{'\x00','\x00'},{'\x8b','\xe8'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x98','\x68'},{'\x00','\x00'},
+    {'\x8f','\xf6'},{'\x90','\x52'},{'\x00','\x00'},{'\x8f','\xf7'},{'\x98','\x69'},
+    {'\x8f','\xf8'},{'\x00','\x00'},{'\x8c','\xc4'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x90','\x51'},{'\x8c','\xc3'},{'\x00','\x00'},
+    {'\x8d','\xae'},{'\x8c','\xf0'},{'\x90','\x67'},{'\x90','\x71'},{'\x90','\x73'},
+    {'\x90','\x74'},{'\x90','\x72'},{'\x8d','\x67'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x8d','\x66'},{'\x98','\x6a'},{'\x00','\x00'},{'\x8d','\xb0'},{'\x00','\x00'},
+    {'\xb3','\xbf'},{'\x00','\x00'},{'\x00','\x00'},{'\x82','\x5e'},{'\xc4','\xd0'},
+    {'\xf6','\xc9'},{'\x9f','\x65'},{'\xc6','\x50'},{'\xc6','\x51'},{'\x90','\x53'},
+    {'\xb3','\xc0'},{'\xe0','\xee'},{'\xfc','\xfd'},{'\xb9','\xa8'},{'\xe8','\xf0'},
+    {'\xfb','\x5e'},{'\x9f','\x66'},{'\xec','\xb0'},{'\xec','\xb1'},{'\xec','\xaf'},
+    {'\xef','\xab'},{'\xef','\xaa'},{'\xc2','\x47'},{'\xf1','\xdf'},{'\xef','\xac'},
+    {'\xf1','\xde'},{'\x00','\x00'},{'\x9f','\x51'},{'\xf3','\xf3'},{'\xc4','\x51'},
+    {'\xc4','\x53'},{'\xf3','\xf2'},{'\xfc','\xf4'},{'\xfb','\x7c'},{'\xc4','\x52'},
+    {'\xfb','\xb7'},{'\xf5','\xb1'},{'\xf5','\xb3'},{'\xf5','\xb2'},{'\xf6','\xca'},
+    {'\xc5','\x65'},{'\xfd','\x48'},{'\xc5','\xef'},{'\xf8','\xe8'},{'\xf9','\x63'},
+    {'\x9f','\x67'},{'\x00','\x00'},{'\xf9','\xd2'},{'\xb3','\xc1'},{'\x84','\xc1'},
+    {'\xe4','\xe5'},{'\xfd','\xb4'},{'\xbe','\xa2'},{'\x98','\x6b'},{'\xfb','\xa2'},
+    {'\x9f','\x68'},{'\xec','\xb3'},{'\xec','\xb2'},{'\x95','\x73'},{'\xef','\xad'},
+    {'\x9f','\x69'},{'\x00','\x00'},{'\x00','\x00'},{'\xc4','\x54'},{'\xc4','\xd1'},
+    {'\xf7','\xc7'},{'\xf9','\xcb'},{'\x88','\xc6'},{'\x82','\x60'},{'\x82','\x61'},
+    {'\xb3','\xc2'},{'\xbb','\xf2'},{'\x98','\x6c'},{'\xbe','\xa3'},{'\x94','\xfa'},
+    {'\xf3','\xf4'},{'\x9f','\x6a'},{'\xf8','\x74'},{'\xb6','\xc0'},{'\x98','\x6d'},
+    {'\x00','\x00'},{'\x9f','\x6b'},{'\x9f','\x6c'},{'\xef','\xae'},{'\x8d','\x7a'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc6','\x64'},{'\xb6','\xc1'},{'\xbe','\xa4'},
+    {'\xc2','\x48'},{'\xf8','\x75'},{'\xb6','\xc2'},{'\x92','\xc3'},{'\xe8','\xf1'},
+    {'\xc0','\x72'},{'\xec','\xb4'},{'\xec','\xb5'},{'\x00','\x00'},{'\xc0','\x71'},
+    {'\x93','\xd4'},{'\xef','\xaf'},{'\xc2','\x4c'},{'\xc2','\x4a'},{'\xc2','\x4b'},
+    {'\xc2','\x49'},{'\xf1','\xe0'},{'\xc3','\x5c'},{'\x00','\x00'},{'\x98','\x6e'},
+    {'\x00','\x00'},{'\xf5','\xb5'},{'\xf5','\xb4'},{'\xf5','\xb7'},{'\xf5','\xb6'},
+    {'\xc4','\xd2'},{'\x8d','\xac'},{'\x98','\x6f'},{'\xf6','\xcb'},{'\x00','\x00'},
+    {'\xf6','\xcd'},{'\xf6','\xcc'},{'\xc5','\x66'},{'\xf7','\xc8'},{'\x9f','\x6d'},
+    {'\xf8','\x76'},{'\xf8','\x77'},{'\xc5','\xf0'},{'\xf9','\x64'},{'\xf9','\x7d'},
+    {'\xc6','\x75'},{'\x9f','\x6e'},{'\xdc','\xb0'},{'\xec','\xb6'},{'\xef','\xb0'},
+    {'\xf3','\xf5'},{'\xe0','\xef'},{'\x8e','\x64'},{'\xef','\xb1'},{'\xf1','\xe2'},
+    {'\xf1','\xe1'},{'\xfd','\xe8'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf8','\x78'},{'\xc6','\x52'},{'\x98','\x70'},{'\xf9','\x65'},{'\xf9','\x7e'},
+    {'\x98','\x71'},{'\x00','\x00'},{'\x98','\x72'},{'\xb9','\xa9'},{'\xe8','\xf2'},
+    {'\xe8','\xf3'},{'\x00','\x00'},{'\xec','\xb7'},{'\xb9','\xaa'},{'\x00','\x00'},
+    {'\xc3','\x5d'},{'\xf1','\xe3'},{'\xfc','\xdb'},{'\xf6','\xcf'},{'\xc5','\x67'},
+    {'\xf6','\xd0'},{'\xf6','\xce'},{'\xf8','\x79'},{'\x00','\x00'},{'\xf8','\xe9'},
+    {'\x00','\x00'},{'\xb9','\xab'},{'\x98','\x73'},{'\xef','\xb4'},{'\xef','\xb3'},
+    {'\xef','\xb2'},{'\xf1','\xe4'},{'\xfb','\xb8'},{'\x9f','\x6f'},{'\xf1','\xe8'},
+    {'\xf1','\xe7'},{'\xf1','\xe6'},{'\xf1','\xe5'},{'\xc3','\x5e'},{'\xf3','\xf6'},
+    {'\xf5','\xb9'},{'\xc4','\xd3'},{'\xf5','\xb8'},{'\xf6','\xd1'},{'\xf7','\xcb'},
+    {'\xf7','\xca'},{'\xc5','\xc4'},{'\xf7','\xc9'},{'\xf8','\x7c'},{'\xf8','\x7b'},
+    {'\xf8','\x7a'},{'\x8c','\xf2'},{'\x00','\x00'},{'\xbb','\xf3'},{'\x00','\x00'},
+    {'\xec','\xb8'},{'\xc2','\x4d'},{'\x00','\x00'},{'\xf3','\xf7'},{'\xf3','\xf8'},
+    {'\xf7','\xcc'},{'\xf8','\x7d'},{'\x98','\x74'},{'\xfd','\xe2'},{'\xf8','\xea'},
+    {'\xf9','\x66'},{'\xf9','\xb9'},{'\xf9','\xd4'},{'\xbb','\xf4'},{'\xc2','\x4e'},
+    {'\xf1','\xe9'},{'\xf3','\xf9'},{'\xf6','\xd2'},{'\xf8','\x7e'},{'\x87','\xa2'},
+    {'\x98','\x75'},{'\xbe','\xa6'},{'\xfd','\xe0'},{'\xef','\xb5'},{'\xf1','\xea'},
+    {'\xf3','\xfa'},{'\xf3','\xfb'},{'\xf3','\xfc'},{'\xf5','\xbe'},{'\xfd','\xda'},
+    {'\xf5','\xba'},{'\xc5','\x68'},{'\xf5','\xbd'},{'\xf5','\xbc'},{'\xc4','\xd4'},
+    {'\xf5','\xbb'},{'\xc4','\xd6'},{'\x93','\xee'},{'\xc4','\xd5'},{'\xf6','\xd4'},
+    {'\xf6','\xd3'},{'\xc5','\x69'},{'\xc5','\x6a'},{'\x00','\x00'},{'\xfd','\x62'},
+    {'\xc5','\xc6'},{'\xf7','\xcd'},{'\xc5','\xc5'},{'\x00','\x00'},{'\xf8','\xa3'},
+    {'\xf8','\xa4'},{'\xf8','\xa2'},{'\xf8','\xa1'},{'\xc6','\x54'},{'\x00','\x00'},
+    {'\xf8','\xeb'},{'\xf8','\xec'},{'\xf8','\xed'},{'\xc6','\x53'},{'\xf9','\x67'},
+    {'\xf9','\x6a'},{'\xf9','\x69'},{'\xf9','\x68'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xf9','\xd3'},{'\x88','\xc7'},{'\x8f','\x73'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x8c','\x6a'},{'\x8c','\x6b'},{'\x8f','\xfa'},{'\x8f','\xf9'},{'\x8c','\xc5'},
+    {'\x8c','\xc6'},{'\x8c','\xf3'},{'\x8c','\xf4'},{'\x8d','\x6c'},{'\x8d','\x6b'},
+    {'\xc0','\x73'},{'\xfb','\xd8'},{'\x00','\x00'},{'\xc3','\x65'},{'\xf5','\xbf'},
+    {'\xf6','\xd5'},{'\x00','\x00'},{'\xc5','\xc7'},{'\xf7','\xce'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xf9','\xd5'},{'\x89','\xc5'},{'\x8c','\xf5'},{'\x90','\x69'},
+    {'\xc0','\x74'},{'\x98','\x76'},{'\x00','\x00'},{'\x89','\xc6'},{'\xef','\xb6'},
+    {'\x00','\x00'},{'\xf7','\xcf'},{'\x00','\x00'},{'\xf9','\xa1'},{'\xfd','\xd4'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\xc8','\xa1'},{'\xc8','\xa3'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xfa','\x40'},
+    {'\xfa','\x41'},{'\xfa','\x42'},{'\xfa','\x43'},{'\xfa','\x44'},{'\xfa','\x45'},
+    {'\xfa','\x46'},{'\xfa','\x47'},{'\xfa','\x48'},{'\xfa','\x49'},{'\xfa','\x4a'},
+    {'\xfa','\x4b'},{'\xfa','\x4c'},{'\xfa','\x4d'},{'\xfa','\x4e'},{'\xfa','\x4f'},
+    {'\xfa','\x50'},{'\xfa','\x51'},{'\xfa','\x52'},{'\xfa','\x53'},{'\xfa','\x54'},
+    {'\xfa','\x55'},{'\xfa','\x56'},{'\xfa','\x57'},{'\xfa','\x58'},{'\xfa','\x59'},
+    {'\xfa','\x5a'},{'\xfa','\x5b'},{'\xfa','\x5c'},{'\xfa','\x5d'},{'\xfa','\x5e'},
+    {'\xfa','\x5f'},{'\xfa','\x60'},{'\xfa','\x61'},{'\xfa','\x62'},{'\xfa','\x63'},
+    {'\xfa','\x64'},{'\xfa','\x65'},{'\xfa','\x66'},{'\xfa','\x67'},{'\xfa','\x68'},
+    {'\xfa','\x69'},{'\xfa','\x6a'},{'\xfa','\x6b'},{'\xfa','\x6c'},{'\xfa','\x6d'},
+    {'\xfa','\x6e'},{'\xfa','\x6f'},{'\xfa','\x70'},{'\xfa','\x71'},{'\xfa','\x72'},
+    {'\xfa','\x73'},{'\xfa','\x74'},{'\xfa','\x75'},{'\xfa','\x76'},{'\xfa','\x77'},
+    {'\xfa','\x78'},{'\xfa','\x79'},{'\xfa','\x7a'},{'\xfa','\x7b'},{'\xfa','\x7c'},
+    {'\xfa','\x7d'},{'\xfa','\x7e'},{'\xfa','\xa1'},{'\xfa','\xa2'},{'\xfa','\xa3'},
+    {'\xfa','\xa4'},{'\xfa','\xa5'},{'\xfa','\xa6'},{'\xfa','\xa7'},{'\xfa','\xa8'},
+    {'\xfa','\xa9'},{'\xfa','\xaa'},{'\xfa','\xab'},{'\xfa','\xac'},{'\xfa','\xad'},
+    {'\xfa','\xae'},{'\xfa','\xaf'},{'\xfa','\xb0'},{'\xfa','\xb1'},{'\xfa','\xb2'},
+    {'\xfa','\xb3'},{'\xfa','\xb4'},{'\xfa','\xb5'},{'\xfa','\xb6'},{'\xfa','\xb7'},
+    {'\xfa','\xb8'},{'\xfa','\xb9'},{'\xfa','\xba'},{'\xfa','\xbb'},{'\xfa','\xbc'},
+    {'\xfa','\xbd'},{'\xfa','\xbe'},{'\xfa','\xbf'},{'\xfa','\xc0'},{'\xfa','\xc1'},
+    {'\xfa','\xc2'},{'\xfa','\xc3'},{'\xfa','\xc4'},{'\xfa','\xc5'},{'\xfa','\xc6'},
+    {'\xfa','\xc7'},{'\xfa','\xc8'},{'\xfa','\xc9'},{'\xfa','\xca'},{'\xfa','\xcb'},
+    {'\xfa','\xcc'},{'\xfa','\xcd'},{'\xfa','\xce'},{'\xfa','\xcf'},{'\xfa','\xd0'},
+    {'\xfa','\xd1'},{'\xfa','\xd2'},{'\xfa','\xd3'},{'\xfa','\xd4'},{'\xfa','\xd5'},
+    {'\xfa','\xd6'},{'\xfa','\xd7'},{'\xfa','\xd8'},{'\xfa','\xd9'},{'\xfa','\xda'},
+    {'\xfa','\xdb'},{'\xfa','\xdc'},{'\xfa','\xdd'},{'\xfa','\xde'},{'\xfa','\xdf'},
+    {'\xfa','\xe0'},{'\xfa','\xe1'},{'\xfa','\xe2'},{'\xfa','\xe3'},{'\xfa','\xe4'},
+    {'\xfa','\xe5'},{'\xfa','\xe6'},{'\xfa','\xe7'},{'\xfa','\xe8'},{'\xfa','\xe9'},
+    {'\xfa','\xea'},{'\xfa','\xeb'},{'\xfa','\xec'},{'\xfa','\xed'},{'\xfa','\xee'},
+    {'\xfa','\xef'},{'\xfa','\xf0'},{'\xfa','\xf1'},{'\xfa','\xf2'},{'\xfa','\xf3'},
+    {'\xfa','\xf4'},{'\xfa','\xf5'},{'\xfa','\xf6'},{'\xfa','\xf7'},{'\xfa','\xf8'},
+    {'\xfa','\xf9'},{'\xfa','\xfa'},{'\xfa','\xfb'},{'\xfa','\xfc'},{'\xfa','\xfd'},
+    {'\xfa','\xfe'},{'\xfb','\x40'},{'\xfb','\x41'},{'\xfb','\x42'},{'\xfb','\x43'},
+    {'\xfb','\x44'},{'\xfb','\x45'},{'\xfb','\x46'},{'\xfb','\x47'},{'\xfb','\x48'},
+    {'\xfb','\x49'},{'\xfb','\x4a'},{'\xfb','\x4b'},{'\xfb','\x4c'},{'\xfb','\x4d'},
+    {'\xfb','\x4e'},{'\xfb','\x4f'},{'\xfb','\x50'},{'\xfb','\x51'},{'\xfb','\x52'},
+    {'\xfb','\x53'},{'\xfb','\x54'},{'\xfb','\x55'},{'\xfb','\x56'},{'\xfb','\x57'},
+    {'\xfb','\x58'},{'\xfb','\x59'},{'\xfb','\x5a'},{'\xfb','\x5b'},{'\xfb','\x5c'},
+    {'\xfb','\x5d'},{'\xfb','\x5e'},{'\xfb','\x5f'},{'\xfb','\x60'},{'\xfb','\x61'},
+    {'\xfb','\x62'},{'\xfb','\x63'},{'\xfb','\x64'},{'\xfb','\x65'},{'\xfb','\x66'},
+    {'\xfb','\x67'},{'\xfb','\x68'},{'\xfb','\x69'},{'\xfb','\x6a'},{'\xfb','\x6b'},
+    {'\xfb','\x6c'},{'\xfb','\x6d'},{'\xfb','\x6e'},{'\xfb','\x6f'},{'\xfb','\x70'},
+    {'\xfb','\x71'},{'\xfb','\x72'},{'\xfb','\x73'},{'\xfb','\x74'},{'\xfb','\x75'},
+    {'\xfb','\x76'},{'\xfb','\x77'},{'\xfb','\x78'},{'\xfb','\x79'},{'\xfb','\x7a'},
+    {'\xfb','\x7b'},{'\xfb','\x7c'},{'\xfb','\x7d'},{'\xfb','\x7e'},{'\xfb','\xa1'},
+    {'\xfb','\xa2'},{'\xfb','\xa3'},{'\xfb','\xa4'},{'\xfb','\xa5'},{'\xfb','\xa6'},
+    {'\xfb','\xa7'},{'\xfb','\xa8'},{'\xfb','\xa9'},{'\xfb','\xaa'},{'\xfb','\xab'},
+    {'\xfb','\xac'},{'\xfb','\xad'},{'\xfb','\xae'},{'\xfb','\xaf'},{'\xfb','\xb0'},
+    {'\xfb','\xb1'},{'\xfb','\xb2'},{'\xfb','\xb3'},{'\xfb','\xb4'},{'\xfb','\xb5'},
+    {'\xfb','\xb6'},{'\xfb','\xb7'},{'\xfb','\xb8'},{'\xfb','\xb9'},{'\xfb','\xba'},
+    {'\xfb','\xbb'},{'\xfb','\xbc'},{'\xfb','\xbd'},{'\xfb','\xbe'},{'\xfb','\xbf'},
+    {'\xfb','\xc0'},{'\xfb','\xc1'},{'\xfb','\xc2'},{'\xfb','\xc3'},{'\xfb','\xc4'},
+    {'\xfb','\xc5'},{'\xfb','\xc6'},{'\xfb','\xc7'},{'\xfb','\xc8'},{'\xfb','\xc9'},
+    {'\xfb','\xca'},{'\xfb','\xcb'},{'\xfb','\xcc'},{'\xfb','\xcd'},{'\xfb','\xce'},
+    {'\xfb','\xcf'},{'\xfb','\xd0'},{'\xfb','\xd1'},{'\xfb','\xd2'},{'\xfb','\xd3'},
+    {'\xfb','\xd4'},{'\xfb','\xd5'},{'\xfb','\xd6'},{'\xfb','\xd7'},{'\xfb','\xd8'},
+    {'\xfb','\xd9'},{'\xfb','\xda'},{'\xfb','\xdb'},{'\xfb','\xdc'},{'\xfb','\xdd'},
+    {'\xfb','\xde'},{'\xfb','\xdf'},{'\xfb','\xe0'},{'\xfb','\xe1'},{'\xfb','\xe2'},
+    {'\xfb','\xe3'},{'\xfb','\xe4'},{'\xfb','\xe5'},{'\xfb','\xe6'},{'\xfb','\xe7'},
+    {'\xfb','\xe8'},{'\xfb','\xe9'},{'\xfb','\xea'},{'\xfb','\xeb'},{'\xfb','\xec'},
+    {'\xfb','\xed'},{'\xfb','\xee'},{'\xfb','\xef'},{'\xfb','\xf0'},{'\xfb','\xf1'},
+    {'\xfb','\xf2'},{'\xfb','\xf3'},{'\xfb','\xf4'},{'\xfb','\xf5'},{'\xfb','\xf6'},
+    {'\xfb','\xf7'},{'\xfb','\xf8'},{'\xfb','\xf9'},{'\xfb','\xfa'},{'\xfb','\xfb'},
+    {'\xfb','\xfc'},{'\xfb','\xfd'},{'\xfb','\xfe'},{'\xfc','\x40'},{'\xfc','\x41'},
+    {'\xfc','\x42'},{'\xfc','\x43'},{'\xfc','\x44'},{'\xfc','\x45'},{'\xfc','\x46'},
+    {'\xfc','\x47'},{'\xfc','\x48'},{'\xfc','\x49'},{'\xfc','\x4a'},{'\xfc','\x4b'},
+    {'\xfc','\x4c'},{'\xfc','\x4d'},{'\xfc','\x4e'},{'\xfc','\x4f'},{'\xfc','\x50'},
+    {'\xfc','\x51'},{'\xfc','\x52'},{'\xfc','\x53'},{'\xfc','\x54'},{'\xfc','\x55'},
+    {'\xfc','\x56'},{'\xfc','\x57'},{'\xfc','\x58'},{'\xfc','\x59'},{'\xfc','\x5a'},
+    {'\xfc','\x5b'},{'\xfc','\x5c'},{'\xfc','\x5d'},{'\xfc','\x5e'},{'\xfc','\x5f'},
+    {'\xfc','\x60'},{'\xfc','\x61'},{'\xfc','\x62'},{'\xfc','\x63'},{'\xfc','\x64'},
+    {'\xfc','\x65'},{'\xfc','\x66'},{'\xfc','\x67'},{'\xfc','\x68'},{'\xfc','\x69'},
+    {'\xfc','\x6a'},{'\xfc','\x6b'},{'\xfc','\x6c'},{'\xfc','\x6d'},{'\xfc','\x6e'},
+    {'\xfc','\x6f'},{'\xfc','\x70'},{'\xfc','\x71'},{'\xfc','\x72'},{'\xfc','\x73'},
+    {'\xfc','\x74'},{'\xfc','\x75'},{'\xfc','\x76'},{'\xfc','\x77'},{'\xfc','\x78'},
+    {'\xfc','\x79'},{'\xfc','\x7a'},{'\xfc','\x7b'},{'\xfc','\x7c'},{'\xfc','\x7d'},
+    {'\xfc','\x7e'},{'\xfc','\xa1'},{'\xfc','\xa2'},{'\xfc','\xa3'},{'\xfc','\xa4'},
+    {'\xfc','\xa5'},{'\xfc','\xa6'},{'\xfc','\xa7'},{'\xfc','\xa8'},{'\xfc','\xa9'},
+    {'\xfc','\xaa'},{'\xfc','\xab'},{'\xfc','\xac'},{'\xfc','\xad'},{'\xfc','\xae'},
+    {'\xfc','\xaf'},{'\xfc','\xb0'},{'\xfc','\xb1'},{'\xfc','\xb2'},{'\xfc','\xb3'},
+    {'\xfc','\xb4'},{'\xfc','\xb5'},{'\xfc','\xb6'},{'\xfc','\xb7'},{'\xfc','\xb8'},
+    {'\xfc','\xb9'},{'\xfc','\xba'},{'\xfc','\xbb'},{'\xfc','\xbc'},{'\xfc','\xbd'},
+    {'\xfc','\xbe'},{'\xfc','\xbf'},{'\xfc','\xc0'},{'\xfc','\xc1'},{'\xfc','\xc2'},
+    {'\xfc','\xc3'},{'\xfc','\xc4'},{'\xfc','\xc5'},{'\xfc','\xc6'},{'\xfc','\xc7'},
+    {'\xfc','\xc8'},{'\xfc','\xc9'},{'\xfc','\xca'},{'\xfc','\xcb'},{'\xfc','\xcc'},
+    {'\xfc','\xcd'},{'\xfc','\xce'},{'\xfc','\xcf'},{'\xfc','\xd0'},{'\xfc','\xd1'},
+    {'\xfc','\xd2'},{'\xfc','\xd3'},{'\xfc','\xd4'},{'\xfc','\xd5'},{'\xfc','\xd6'},
+    {'\xfc','\xd7'},{'\xfc','\xd8'},{'\xfc','\xd9'},{'\xfc','\xda'},{'\xfc','\xdb'},
+    {'\xfc','\xdc'},{'\xfc','\xdd'},{'\xfc','\xde'},{'\xfc','\xdf'},{'\xfc','\xe0'},
+    {'\xfc','\xe1'},{'\xfc','\xe2'},{'\xfc','\xe3'},{'\xfc','\xe4'},{'\xfc','\xe5'},
+    {'\xfc','\xe6'},{'\xfc','\xe7'},{'\xfc','\xe8'},{'\xfc','\xe9'},{'\xfc','\xea'},
+    {'\xfc','\xeb'},{'\xfc','\xec'},{'\xfc','\xed'},{'\xfc','\xee'},{'\xfc','\xef'},
+    {'\xfc','\xf0'},{'\xfc','\xf1'},{'\xfc','\xf2'},{'\xfc','\xf3'},{'\xfc','\xf4'},
+    {'\xfc','\xf5'},{'\xfc','\xf6'},{'\xfc','\xf7'},{'\xfc','\xf8'},{'\xfc','\xf9'},
+    {'\xfc','\xfa'},{'\xfc','\xfb'},{'\xfc','\xfc'},{'\xfc','\xfd'},{'\xfc','\xfe'},
+    {'\xfd','\x40'},{'\xfd','\x41'},{'\xfd','\x42'},{'\xfd','\x43'},{'\xfd','\x44'},
+    {'\xfd','\x45'},{'\xfd','\x46'},{'\xfd','\x47'},{'\xfd','\x48'},{'\xfd','\x49'},
+    {'\xfd','\x4a'},{'\xfd','\x4b'},{'\xfd','\x4c'},{'\xfd','\x4d'},{'\xfd','\x4e'},
+    {'\xfd','\x4f'},{'\xfd','\x50'},{'\xfd','\x51'},{'\xfd','\x52'},{'\xfd','\x53'},
+    {'\xfd','\x54'},{'\xfd','\x55'},{'\xfd','\x56'},{'\xfd','\x57'},{'\xfd','\x58'},
+    {'\xfd','\x59'},{'\xfd','\x5a'},{'\xfd','\x5b'},{'\xfd','\x5c'},{'\xfd','\x5d'},
+    {'\xfd','\x5e'},{'\xfd','\x5f'},{'\xfd','\x60'},{'\xfd','\x61'},{'\xfd','\x62'},
+    {'\xfd','\x63'},{'\xfd','\x64'},{'\xfd','\x65'},{'\xfd','\x66'},{'\xfd','\x67'},
+    {'\xfd','\x68'},{'\xfd','\x69'},{'\xfd','\x6a'},{'\xfd','\x6b'},{'\xfd','\x6c'},
+    {'\xfd','\x6d'},{'\xfd','\x6e'},{'\xfd','\x6f'},{'\xfd','\x70'},{'\xfd','\x71'},
+    {'\xfd','\x72'},{'\xfd','\x73'},{'\xfd','\x74'},{'\xfd','\x75'},{'\xfd','\x76'},
+    {'\xfd','\x77'},{'\xfd','\x78'},{'\xfd','\x79'},{'\xfd','\x7a'},{'\xfd','\x7b'},
+    {'\xfd','\x7c'},{'\xfd','\x7d'},{'\xfd','\x7e'},{'\xfd','\xa1'},{'\xfd','\xa2'},
+    {'\xfd','\xa3'},{'\xfd','\xa4'},{'\xfd','\xa5'},{'\xfd','\xa6'},{'\xfd','\xa7'},
+    {'\xfd','\xa8'},{'\xfd','\xa9'},{'\xfd','\xaa'},{'\xfd','\xab'},{'\xfd','\xac'},
+    {'\xfd','\xad'},{'\xfd','\xae'},{'\xfd','\xaf'},{'\xfd','\xb0'},{'\xfd','\xb1'},
+    {'\xfd','\xb2'},{'\xfd','\xb3'},{'\xfd','\xb4'},{'\xfd','\xb5'},{'\xfd','\xb6'},
+    {'\xfd','\xb7'},{'\xfd','\xb8'},{'\xfd','\xb9'},{'\xfd','\xba'},{'\xfd','\xbb'},
+    {'\xfd','\xbc'},{'\xfd','\xbd'},{'\xfd','\xbe'},{'\xfd','\xbf'},{'\xfd','\xc0'},
+    {'\xfd','\xc1'},{'\xfd','\xc2'},{'\xfd','\xc3'},{'\xfd','\xc4'},{'\xfd','\xc5'},
+    {'\xfd','\xc6'},{'\xfd','\xc7'},{'\xfd','\xc8'},{'\xfd','\xc9'},{'\xfd','\xca'},
+    {'\xfd','\xcb'},{'\xfd','\xcc'},{'\xfd','\xcd'},{'\xfd','\xce'},{'\xfd','\xcf'},
+    {'\xfd','\xd0'},{'\xfd','\xd1'},{'\xfd','\xd2'},{'\xfd','\xd3'},{'\xfd','\xd4'},
+    {'\xfd','\xd5'},{'\xfd','\xd6'},{'\xfd','\xd7'},{'\xfd','\xd8'},{'\xfd','\xd9'},
+    {'\xfd','\xda'},{'\xfd','\xdb'},{'\xfd','\xdc'},{'\xfd','\xdd'},{'\xfd','\xde'},
+    {'\xfd','\xdf'},{'\xfd','\xe0'},{'\xfd','\xe1'},{'\xfd','\xe2'},{'\xfd','\xe3'},
+    {'\xfd','\xe4'},{'\xfd','\xe5'},{'\xfd','\xe6'},{'\xfd','\xe7'},{'\xfd','\xe8'},
+    {'\xfd','\xe9'},{'\xfd','\xea'},{'\xfd','\xeb'},{'\xfd','\xec'},{'\xfd','\xed'},
+    {'\xfd','\xee'},{'\xfd','\xef'},{'\xfd','\xf0'},{'\xfd','\xf1'},{'\xfd','\xf2'},
+    {'\xfd','\xf3'},{'\xfd','\xf4'},{'\xfd','\xf5'},{'\xfd','\xf6'},{'\xfd','\xf7'},
+    {'\xfd','\xf8'},{'\xfd','\xf9'},{'\xfd','\xfa'},{'\xfd','\xfb'},{'\xfd','\xfc'},
+    {'\xfd','\xfd'},{'\xfd','\xfe'},{'\xfe','\x40'},{'\xfe','\x41'},{'\xfe','\x42'},
+    {'\xfe','\x43'},{'\xfe','\x44'},{'\xfe','\x45'},{'\xfe','\x46'},{'\xfe','\x47'},
+    {'\xfe','\x48'},{'\xfe','\x49'},{'\xfe','\x4a'},{'\xfe','\x4b'},{'\xfe','\x4c'},
+    {'\xfe','\x4d'},{'\xfe','\x4e'},{'\xfe','\x4f'},{'\xfe','\x50'},{'\xfe','\x51'},
+    {'\xfe','\x52'},{'\xfe','\x53'},{'\xfe','\x54'},{'\xfe','\x55'},{'\xfe','\x56'},
+    {'\xfe','\x57'},{'\xfe','\x58'},{'\xfe','\x59'},{'\xfe','\x5a'},{'\xfe','\x5b'},
+    {'\xfe','\x5c'},{'\xfe','\x5d'},{'\xfe','\x5e'},{'\xfe','\x5f'},{'\xfe','\x60'},
+    {'\xfe','\x61'},{'\xfe','\x62'},{'\xfe','\x63'},{'\xfe','\x64'},{'\xfe','\x65'},
+    {'\xfe','\x66'},{'\xfe','\x67'},{'\xfe','\x68'},{'\xfe','\x69'},{'\xfe','\x6a'},
+    {'\xfe','\x6b'},{'\xfe','\x6c'},{'\xfe','\x6d'},{'\xfe','\x6e'},{'\xfe','\x6f'},
+    {'\xfe','\x70'},{'\xfe','\x71'},{'\xfe','\x72'},{'\xfe','\x73'},{'\xfe','\x74'},
+    {'\xfe','\x75'},{'\xfe','\x76'},{'\xfe','\x77'},{'\xfe','\x78'},{'\xfe','\x79'},
+    {'\xfe','\x7a'},{'\xfe','\x7b'},{'\xfe','\x7c'},{'\xfe','\x7d'},{'\xfe','\x7e'},
+    {'\xfe','\xa1'},{'\xfe','\xa2'},{'\xfe','\xa3'},{'\xfe','\xa4'},{'\xfe','\xa5'},
+    {'\xfe','\xa6'},{'\xfe','\xa7'},{'\xfe','\xa8'},{'\xfe','\xa9'},{'\xfe','\xaa'},
+    {'\xfe','\xab'},{'\xfe','\xac'},{'\xfe','\xad'},{'\xfe','\xae'},{'\xfe','\xaf'},
+    {'\xfe','\xb0'},{'\xfe','\xb1'},{'\xfe','\xb2'},{'\xfe','\xb3'},{'\xfe','\xb4'},
+    {'\xfe','\xb5'},{'\xfe','\xb6'},{'\xfe','\xb7'},{'\xfe','\xb8'},{'\xfe','\xb9'},
+    {'\xfe','\xba'},{'\xfe','\xbb'},{'\xfe','\xbc'},{'\xfe','\xbd'},{'\xfe','\xbe'},
+    {'\xfe','\xbf'},{'\xfe','\xc0'},{'\xfe','\xc1'},{'\xfe','\xc2'},{'\xfe','\xc3'},
+    {'\xfe','\xc4'},{'\xfe','\xc5'},{'\xfe','\xc6'},{'\xfe','\xc7'},{'\xfe','\xc8'},
+    {'\xfe','\xc9'},{'\xfe','\xca'},{'\xfe','\xcb'},{'\xfe','\xcc'},{'\xfe','\xcd'},
+    {'\xfe','\xce'},{'\xfe','\xcf'},{'\xfe','\xd0'},{'\xfe','\xd1'},{'\xfe','\xd2'},
+    {'\xfe','\xd3'},{'\xfe','\xd4'},{'\xfe','\xd5'},{'\xfe','\xd6'},{'\xfe','\xd7'},
+    {'\xfe','\xd8'},{'\xfe','\xd9'},{'\xfe','\xda'},{'\xfe','\xdb'},{'\xfe','\xdc'},
+    {'\xfe','\xdd'},{'\xfe','\xde'},{'\xfe','\xdf'},{'\xfe','\xe0'},{'\xfe','\xe1'},
+    {'\xfe','\xe2'},{'\xfe','\xe3'},{'\xfe','\xe4'},{'\xfe','\xe5'},{'\xfe','\xe6'},
+    {'\xfe','\xe7'},{'\xfe','\xe8'},{'\xfe','\xe9'},{'\xfe','\xea'},{'\xfe','\xeb'},
+    {'\xfe','\xec'},{'\xfe','\xed'},{'\xfe','\xee'},{'\xfe','\xef'},{'\xfe','\xf0'},
+    {'\xfe','\xf1'},{'\xfe','\xf2'},{'\xfe','\xf3'},{'\xfe','\xf4'},{'\xfe','\xf5'},
+    {'\xfe','\xf6'},{'\xfe','\xf7'},{'\xfe','\xf8'},{'\xfe','\xf9'},{'\xfe','\xfa'},
+    {'\xfe','\xfb'},{'\xfe','\xfc'},{'\xfe','\xfd'},{'\xfe','\xfe'},{'\x8e','\x40'},
+    {'\x8e','\x41'},{'\x8e','\x42'},{'\x8e','\x43'},{'\x8e','\x44'},{'\x8e','\x45'},
+    {'\x8e','\x46'},{'\x8e','\x47'},{'\x8e','\x48'},{'\x8e','\x49'},{'\x8e','\x4a'},
+    {'\x8e','\x4b'},{'\x8e','\x4c'},{'\x8e','\x4d'},{'\x8e','\x4e'},{'\x8e','\x4f'},
+    {'\x8e','\x50'},{'\x8e','\x51'},{'\x8e','\x52'},{'\x8e','\x53'},{'\x8e','\x54'},
+    {'\x8e','\x55'},{'\x8e','\x56'},{'\x8e','\x57'},{'\x8e','\x58'},{'\x8e','\x59'},
+    {'\x8e','\x5a'},{'\x8e','\x5b'},{'\x8e','\x5c'},{'\x8e','\x5d'},{'\x8e','\x5e'},
+    {'\x8e','\x5f'},{'\x8e','\x60'},{'\x8e','\x61'},{'\x8e','\x62'},{'\x8e','\x63'},
+    {'\x8e','\x64'},{'\x8e','\x65'},{'\x8e','\x66'},{'\x8e','\x67'},{'\x8e','\x68'},
+    {'\x8e','\x69'},{'\x8e','\x6a'},{'\x8e','\x6b'},{'\x8e','\x6c'},{'\x8e','\x6d'},
+    {'\x8e','\x6e'},{'\x8e','\x6f'},{'\x8e','\x70'},{'\x8e','\x71'},{'\x8e','\x72'},
+    {'\x8e','\x73'},{'\x8e','\x74'},{'\x8e','\x75'},{'\x8e','\x76'},{'\x8e','\x77'},
+    {'\x8e','\x78'},{'\x8e','\x79'},{'\x8e','\x7a'},{'\x8e','\x7b'},{'\x8e','\x7c'},
+    {'\x8e','\x7d'},{'\x8e','\x7e'},{'\x8e','\xa1'},{'\x8e','\xa2'},{'\x8e','\xa3'},
+    {'\x8e','\xa4'},{'\x8e','\xa5'},{'\x8e','\xa6'},{'\x8e','\xa7'},{'\x8e','\xa8'},
+    {'\x8e','\xa9'},{'\x8e','\xaa'},{'\x8e','\xab'},{'\x8e','\xac'},{'\x8e','\xad'},
+    {'\x8e','\xae'},{'\x8e','\xaf'},{'\x8e','\xb0'},{'\x8e','\xb1'},{'\x8e','\xb2'},
+    {'\x8e','\xb3'},{'\x8e','\xb4'},{'\x8e','\xb5'},{'\x8e','\xb6'},{'\x8e','\xb7'},
+    {'\x8e','\xb8'},{'\x8e','\xb9'},{'\x8e','\xba'},{'\x8e','\xbb'},{'\x8e','\xbc'},
+    {'\x8e','\xbd'},{'\x8e','\xbe'},{'\x8e','\xbf'},{'\x8e','\xc0'},{'\x8e','\xc1'},
+    {'\x8e','\xc2'},{'\x8e','\xc3'},{'\x8e','\xc4'},{'\x8e','\xc5'},{'\x8e','\xc6'},
+    {'\x8e','\xc7'},{'\x8e','\xc8'},{'\x8e','\xc9'},{'\x8e','\xca'},{'\x8e','\xcb'},
+    {'\x8e','\xcc'},{'\x8e','\xcd'},{'\x8e','\xce'},{'\x8e','\xcf'},{'\x8e','\xd0'},
+    {'\x8e','\xd1'},{'\x8e','\xd2'},{'\x8e','\xd3'},{'\x8e','\xd4'},{'\x8e','\xd5'},
+    {'\x8e','\xd6'},{'\x8e','\xd7'},{'\x8e','\xd8'},{'\x8e','\xd9'},{'\x8e','\xda'},
+    {'\x8e','\xdb'},{'\x8e','\xdc'},{'\x8e','\xdd'},{'\x8e','\xde'},{'\x8e','\xdf'},
+    {'\x8e','\xe0'},{'\x8e','\xe1'},{'\x8e','\xe2'},{'\x8e','\xe3'},{'\x8e','\xe4'},
+    {'\x8e','\xe5'},{'\x8e','\xe6'},{'\x8e','\xe7'},{'\x8e','\xe8'},{'\x8e','\xe9'},
+    {'\x8e','\xea'},{'\x8e','\xeb'},{'\x8e','\xec'},{'\x8e','\xed'},{'\x8e','\xee'},
+    {'\x8e','\xef'},{'\x8e','\xf0'},{'\x8e','\xf1'},{'\x8e','\xf2'},{'\x8e','\xf3'},
+    {'\x8e','\xf4'},{'\x8e','\xf5'},{'\x8e','\xf6'},{'\x8e','\xf7'},{'\x8e','\xf8'},
+    {'\x8e','\xf9'},{'\x8e','\xfa'},{'\x8e','\xfb'},{'\x8e','\xfc'},{'\x8e','\xfd'},
+    {'\x8e','\xfe'},{'\x8f','\x40'},{'\x8f','\x41'},{'\x8f','\x42'},{'\x8f','\x43'},
+    {'\x8f','\x44'},{'\x8f','\x45'},{'\x8f','\x46'},{'\x8f','\x47'},{'\x8f','\x48'},
+    {'\x8f','\x49'},{'\x8f','\x4a'},{'\x8f','\x4b'},{'\x8f','\x4c'},{'\x8f','\x4d'},
+    {'\x8f','\x4e'},{'\x8f','\x4f'},{'\x8f','\x50'},{'\x8f','\x51'},{'\x8f','\x52'},
+    {'\x8f','\x53'},{'\x8f','\x54'},{'\x8f','\x55'},{'\x8f','\x56'},{'\x8f','\x57'},
+    {'\x8f','\x58'},{'\x8f','\x59'},{'\x8f','\x5a'},{'\x8f','\x5b'},{'\x8f','\x5c'},
+    {'\x8f','\x5d'},{'\x8f','\x5e'},{'\x8f','\x5f'},{'\x8f','\x60'},{'\x8f','\x61'},
+    {'\x8f','\x62'},{'\x8f','\x63'},{'\x8f','\x64'},{'\x8f','\x65'},{'\x8f','\x66'},
+    {'\x8f','\x67'},{'\x8f','\x68'},{'\x8f','\x69'},{'\x8f','\x6a'},{'\x8f','\x6b'},
+    {'\x8f','\x6c'},{'\x8f','\x6d'},{'\x8f','\x6e'},{'\x8f','\x6f'},{'\x8f','\x70'},
+    {'\x8f','\x71'},{'\x8f','\x72'},{'\x8f','\x73'},{'\x8f','\x74'},{'\x8f','\x75'},
+    {'\x8f','\x76'},{'\x8f','\x77'},{'\x8f','\x78'},{'\x8f','\x79'},{'\x8f','\x7a'},
+    {'\x8f','\x7b'},{'\x8f','\x7c'},{'\x8f','\x7d'},{'\x8f','\x7e'},{'\x8f','\xa1'},
+    {'\x8f','\xa2'},{'\x8f','\xa3'},{'\x8f','\xa4'},{'\x8f','\xa5'},{'\x8f','\xa6'},
+    {'\x8f','\xa7'},{'\x8f','\xa8'},{'\x8f','\xa9'},{'\x8f','\xaa'},{'\x8f','\xab'},
+    {'\x8f','\xac'},{'\x8f','\xad'},{'\x8f','\xae'},{'\x8f','\xaf'},{'\x8f','\xb0'},
+    {'\x8f','\xb1'},{'\x8f','\xb2'},{'\x8f','\xb3'},{'\x8f','\xb4'},{'\x8f','\xb5'},
+    {'\x8f','\xb6'},{'\x8f','\xb7'},{'\x8f','\xb8'},{'\x8f','\xb9'},{'\x8f','\xba'},
+    {'\x8f','\xbb'},{'\x8f','\xbc'},{'\x8f','\xbd'},{'\x8f','\xbe'},{'\x8f','\xbf'},
+    {'\x8f','\xc0'},{'\x8f','\xc1'},{'\x8f','\xc2'},{'\x8f','\xc3'},{'\x8f','\xc4'},
+    {'\x8f','\xc5'},{'\x8f','\xc6'},{'\x8f','\xc7'},{'\x8f','\xc8'},{'\x8f','\xc9'},
+    {'\x8f','\xca'},{'\x8f','\xcb'},{'\x8f','\xcc'},{'\x8f','\xcd'},{'\x8f','\xce'},
+    {'\x8f','\xcf'},{'\x8f','\xd0'},{'\x8f','\xd1'},{'\x8f','\xd2'},{'\x8f','\xd3'},
+    {'\x8f','\xd4'},{'\x8f','\xd5'},{'\x8f','\xd6'},{'\x8f','\xd7'},{'\x8f','\xd8'},
+    {'\x8f','\xd9'},{'\x8f','\xda'},{'\x8f','\xdb'},{'\x8f','\xdc'},{'\x8f','\xdd'},
+    {'\x8f','\xde'},{'\x8f','\xdf'},{'\x8f','\xe0'},{'\x8f','\xe1'},{'\x8f','\xe2'},
+    {'\x8f','\xe3'},{'\x8f','\xe4'},{'\x8f','\xe5'},{'\x8f','\xe6'},{'\x8f','\xe7'},
+    {'\x8f','\xe8'},{'\x8f','\xe9'},{'\x8f','\xea'},{'\x8f','\xeb'},{'\x8f','\xec'},
+    {'\x8f','\xed'},{'\x8f','\xee'},{'\x8f','\xef'},{'\x8f','\xf0'},{'\x8f','\xf1'},
+    {'\x8f','\xf2'},{'\x8f','\xf3'},{'\x8f','\xf4'},{'\x8f','\xf5'},{'\x8f','\xf6'},
+    {'\x8f','\xf7'},{'\x8f','\xf8'},{'\x8f','\xf9'},{'\x8f','\xfa'},{'\x8f','\xfb'},
+    {'\x8f','\xfc'},{'\x8f','\xfd'},{'\x8f','\xfe'},{'\x90','\x40'},{'\x90','\x41'},
+    {'\x90','\x42'},{'\x90','\x43'},{'\x90','\x44'},{'\x90','\x45'},{'\x90','\x46'},
+    {'\x90','\x47'},{'\x90','\x48'},{'\x90','\x49'},{'\x90','\x4a'},{'\x90','\x4b'},
+    {'\x90','\x4c'},{'\x90','\x4d'},{'\x90','\x4e'},{'\x90','\x4f'},{'\x90','\x50'},
+    {'\x90','\x51'},{'\x90','\x52'},{'\x90','\x53'},{'\x90','\x54'},{'\x90','\x55'},
+    {'\x90','\x56'},{'\x90','\x57'},{'\x90','\x58'},{'\x90','\x59'},{'\x90','\x5a'},
+    {'\x90','\x5b'},{'\x90','\x5c'},{'\x90','\x5d'},{'\x90','\x5e'},{'\x90','\x5f'},
+    {'\x90','\x60'},{'\x90','\x61'},{'\x90','\x62'},{'\x90','\x63'},{'\x90','\x64'},
+    {'\x90','\x65'},{'\x90','\x66'},{'\x90','\x67'},{'\x90','\x68'},{'\x90','\x69'},
+    {'\x90','\x6a'},{'\x90','\x6b'},{'\x90','\x6c'},{'\x90','\x6d'},{'\x90','\x6e'},
+    {'\x90','\x6f'},{'\x90','\x70'},{'\x90','\x71'},{'\x90','\x72'},{'\x90','\x73'},
+    {'\x90','\x74'},{'\x90','\x75'},{'\x90','\x76'},{'\x90','\x77'},{'\x90','\x78'},
+    {'\x90','\x79'},{'\x90','\x7a'},{'\x90','\x7b'},{'\x90','\x7c'},{'\x90','\x7d'},
+    {'\x90','\x7e'},{'\x90','\xa1'},{'\x90','\xa2'},{'\x90','\xa3'},{'\x90','\xa4'},
+    {'\x90','\xa5'},{'\x90','\xa6'},{'\x90','\xa7'},{'\x90','\xa8'},{'\x90','\xa9'},
+    {'\x90','\xaa'},{'\x90','\xab'},{'\x90','\xac'},{'\x90','\xad'},{'\x90','\xae'},
+    {'\x90','\xaf'},{'\x90','\xb0'},{'\x90','\xb1'},{'\x90','\xb2'},{'\x90','\xb3'},
+    {'\x90','\xb4'},{'\x90','\xb5'},{'\x90','\xb6'},{'\x90','\xb7'},{'\x90','\xb8'},
+    {'\x90','\xb9'},{'\x90','\xba'},{'\x90','\xbb'},{'\x90','\xbc'},{'\x90','\xbd'},
+    {'\x90','\xbe'},{'\x90','\xbf'},{'\x90','\xc0'},{'\x90','\xc1'},{'\x90','\xc2'},
+    {'\x90','\xc3'},{'\x90','\xc4'},{'\x90','\xc5'},{'\x90','\xc6'},{'\x90','\xc7'},
+    {'\x90','\xc8'},{'\x90','\xc9'},{'\x90','\xca'},{'\x90','\xcb'},{'\x90','\xcc'},
+    {'\x90','\xcd'},{'\x90','\xce'},{'\x90','\xcf'},{'\x90','\xd0'},{'\x90','\xd1'},
+    {'\x90','\xd2'},{'\x90','\xd3'},{'\x90','\xd4'},{'\x90','\xd5'},{'\x90','\xd6'},
+    {'\x90','\xd7'},{'\x90','\xd8'},{'\x90','\xd9'},{'\x90','\xda'},{'\x90','\xdb'},
+    {'\x90','\xdc'},{'\x90','\xdd'},{'\x90','\xde'},{'\x90','\xdf'},{'\x90','\xe0'},
+    {'\x90','\xe1'},{'\x90','\xe2'},{'\x90','\xe3'},{'\x90','\xe4'},{'\x90','\xe5'},
+    {'\x90','\xe6'},{'\x90','\xe7'},{'\x90','\xe8'},{'\x90','\xe9'},{'\x90','\xea'},
+    {'\x90','\xeb'},{'\x90','\xec'},{'\x90','\xed'},{'\x90','\xee'},{'\x90','\xef'},
+    {'\x90','\xf0'},{'\x90','\xf1'},{'\x90','\xf2'},{'\x90','\xf3'},{'\x90','\xf4'},
+    {'\x90','\xf5'},{'\x90','\xf6'},{'\x90','\xf7'},{'\x90','\xf8'},{'\x90','\xf9'},
+    {'\x90','\xfa'},{'\x90','\xfb'},{'\x90','\xfc'},{'\x90','\xfd'},{'\x90','\xfe'},
+    {'\x91','\x40'},{'\x91','\x41'},{'\x91','\x42'},{'\x91','\x43'},{'\x91','\x44'},
+    {'\x91','\x45'},{'\x91','\x46'},{'\x91','\x47'},{'\x91','\x48'},{'\x91','\x49'},
+    {'\x91','\x4a'},{'\x91','\x4b'},{'\x91','\x4c'},{'\x91','\x4d'},{'\x91','\x4e'},
+    {'\x91','\x4f'},{'\x91','\x50'},{'\x91','\x51'},{'\x91','\x52'},{'\x91','\x53'},
+    {'\x91','\x54'},{'\x91','\x55'},{'\x91','\x56'},{'\x91','\x57'},{'\x91','\x58'},
+    {'\x91','\x59'},{'\x91','\x5a'},{'\x91','\x5b'},{'\x91','\x5c'},{'\x91','\x5d'},
+    {'\x91','\x5e'},{'\x91','\x5f'},{'\x91','\x60'},{'\x91','\x61'},{'\x91','\x62'},
+    {'\x91','\x63'},{'\x91','\x64'},{'\x91','\x65'},{'\x91','\x66'},{'\x91','\x67'},
+    {'\x91','\x68'},{'\x91','\x69'},{'\x91','\x6a'},{'\x91','\x6b'},{'\x91','\x6c'},
+    {'\x91','\x6d'},{'\x91','\x6e'},{'\x91','\x6f'},{'\x91','\x70'},{'\x91','\x71'},
+    {'\x91','\x72'},{'\x91','\x73'},{'\x91','\x74'},{'\x91','\x75'},{'\x91','\x76'},
+    {'\x91','\x77'},{'\x91','\x78'},{'\x91','\x79'},{'\x91','\x7a'},{'\x91','\x7b'},
+    {'\x91','\x7c'},{'\x91','\x7d'},{'\x91','\x7e'},{'\x91','\xa1'},{'\x91','\xa2'},
+    {'\x91','\xa3'},{'\x91','\xa4'},{'\x91','\xa5'},{'\x91','\xa6'},{'\x91','\xa7'},
+    {'\x91','\xa8'},{'\x91','\xa9'},{'\x91','\xaa'},{'\x91','\xab'},{'\x91','\xac'},
+    {'\x91','\xad'},{'\x91','\xae'},{'\x91','\xaf'},{'\x91','\xb0'},{'\x91','\xb1'},
+    {'\x91','\xb2'},{'\x91','\xb3'},{'\x91','\xb4'},{'\x91','\xb5'},{'\x91','\xb6'},
+    {'\x91','\xb7'},{'\x91','\xb8'},{'\x91','\xb9'},{'\x91','\xba'},{'\x91','\xbb'},
+    {'\x91','\xbc'},{'\x91','\xbd'},{'\x91','\xbe'},{'\x91','\xbf'},{'\x91','\xc0'},
+    {'\x91','\xc1'},{'\x91','\xc2'},{'\x91','\xc3'},{'\x91','\xc4'},{'\x91','\xc5'},
+    {'\x91','\xc6'},{'\x91','\xc7'},{'\x91','\xc8'},{'\x91','\xc9'},{'\x91','\xca'},
+    {'\x91','\xcb'},{'\x91','\xcc'},{'\x91','\xcd'},{'\x91','\xce'},{'\x91','\xcf'},
+    {'\x91','\xd0'},{'\x91','\xd1'},{'\x91','\xd2'},{'\x91','\xd3'},{'\x91','\xd4'},
+    {'\x91','\xd5'},{'\x91','\xd6'},{'\x91','\xd7'},{'\x91','\xd8'},{'\x91','\xd9'},
+    {'\x91','\xda'},{'\x91','\xdb'},{'\x91','\xdc'},{'\x91','\xdd'},{'\x91','\xde'},
+    {'\x91','\xdf'},{'\x91','\xe0'},{'\x91','\xe1'},{'\x91','\xe2'},{'\x91','\xe3'},
+    {'\x91','\xe4'},{'\x91','\xe5'},{'\x91','\xe6'},{'\x91','\xe7'},{'\x91','\xe8'},
+    {'\x91','\xe9'},{'\x91','\xea'},{'\x91','\xeb'},{'\x91','\xec'},{'\x91','\xed'},
+    {'\x91','\xee'},{'\x91','\xef'},{'\x91','\xf0'},{'\x91','\xf1'},{'\x91','\xf2'},
+    {'\x91','\xf3'},{'\x91','\xf4'},{'\x91','\xf5'},{'\x91','\xf6'},{'\x91','\xf7'},
+    {'\x91','\xf8'},{'\x91','\xf9'},{'\x91','\xfa'},{'\x91','\xfb'},{'\x91','\xfc'},
+    {'\x91','\xfd'},{'\x91','\xfe'},{'\x92','\x40'},{'\x92','\x41'},{'\x92','\x42'},
+    {'\x92','\x43'},{'\x92','\x44'},{'\x92','\x45'},{'\x92','\x46'},{'\x92','\x47'},
+    {'\x92','\x48'},{'\x92','\x49'},{'\x92','\x4a'},{'\x92','\x4b'},{'\x92','\x4c'},
+    {'\x92','\x4d'},{'\x92','\x4e'},{'\x92','\x4f'},{'\x92','\x50'},{'\x92','\x51'},
+    {'\x92','\x52'},{'\x92','\x53'},{'\x92','\x54'},{'\x92','\x55'},{'\x92','\x56'},
+    {'\x92','\x57'},{'\x92','\x58'},{'\x92','\x59'},{'\x92','\x5a'},{'\x92','\x5b'},
+    {'\x92','\x5c'},{'\x92','\x5d'},{'\x92','\x5e'},{'\x92','\x5f'},{'\x92','\x60'},
+    {'\x92','\x61'},{'\x92','\x62'},{'\x92','\x63'},{'\x92','\x64'},{'\x92','\x65'},
+    {'\x92','\x66'},{'\x92','\x67'},{'\x92','\x68'},{'\x92','\x69'},{'\x92','\x6a'},
+    {'\x92','\x6b'},{'\x92','\x6c'},{'\x92','\x6d'},{'\x92','\x6e'},{'\x92','\x6f'},
+    {'\x92','\x70'},{'\x92','\x71'},{'\x92','\x72'},{'\x92','\x73'},{'\x92','\x74'},
+    {'\x92','\x75'},{'\x92','\x76'},{'\x92','\x77'},{'\x92','\x78'},{'\x92','\x79'},
+    {'\x92','\x7a'},{'\x92','\x7b'},{'\x92','\x7c'},{'\x92','\x7d'},{'\x92','\x7e'},
+    {'\x92','\xa1'},{'\x92','\xa2'},{'\x92','\xa3'},{'\x92','\xa4'},{'\x92','\xa5'},
+    {'\x92','\xa6'},{'\x92','\xa7'},{'\x92','\xa8'},{'\x92','\xa9'},{'\x92','\xaa'},
+    {'\x92','\xab'},{'\x92','\xac'},{'\x92','\xad'},{'\x92','\xae'},{'\x92','\xaf'},
+    {'\x92','\xb0'},{'\x92','\xb1'},{'\x92','\xb2'},{'\x92','\xb3'},{'\x92','\xb4'},
+    {'\x92','\xb5'},{'\x92','\xb6'},{'\x92','\xb7'},{'\x92','\xb8'},{'\x92','\xb9'},
+    {'\x92','\xba'},{'\x92','\xbb'},{'\x92','\xbc'},{'\x92','\xbd'},{'\x92','\xbe'},
+    {'\x92','\xbf'},{'\x92','\xc0'},{'\x92','\xc1'},{'\x92','\xc2'},{'\x92','\xc3'},
+    {'\x92','\xc4'},{'\x92','\xc5'},{'\x92','\xc6'},{'\x92','\xc7'},{'\x92','\xc8'},
+    {'\x92','\xc9'},{'\x92','\xca'},{'\x92','\xcb'},{'\x92','\xcc'},{'\x92','\xcd'},
+    {'\x92','\xce'},{'\x92','\xcf'},{'\x92','\xd0'},{'\x92','\xd1'},{'\x92','\xd2'},
+    {'\x92','\xd3'},{'\x92','\xd4'},{'\x92','\xd5'},{'\x92','\xd6'},{'\x92','\xd7'},
+    {'\x92','\xd8'},{'\x92','\xd9'},{'\x92','\xda'},{'\x92','\xdb'},{'\x92','\xdc'},
+    {'\x92','\xdd'},{'\x92','\xde'},{'\x92','\xdf'},{'\x92','\xe0'},{'\x92','\xe1'},
+    {'\x92','\xe2'},{'\x92','\xe3'},{'\x92','\xe4'},{'\x92','\xe5'},{'\x92','\xe6'},
+    {'\x92','\xe7'},{'\x92','\xe8'},{'\x92','\xe9'},{'\x92','\xea'},{'\x92','\xeb'},
+    {'\x92','\xec'},{'\x92','\xed'},{'\x92','\xee'},{'\x92','\xef'},{'\x92','\xf0'},
+    {'\x92','\xf1'},{'\x92','\xf2'},{'\x92','\xf3'},{'\x92','\xf4'},{'\x92','\xf5'},
+    {'\x92','\xf6'},{'\x92','\xf7'},{'\x92','\xf8'},{'\x92','\xf9'},{'\x92','\xfa'},
+    {'\x92','\xfb'},{'\x92','\xfc'},{'\x92','\xfd'},{'\x92','\xfe'},{'\x93','\x40'},
+    {'\x93','\x41'},{'\x93','\x42'},{'\x93','\x43'},{'\x93','\x44'},{'\x93','\x45'},
+    {'\x93','\x46'},{'\x93','\x47'},{'\x93','\x48'},{'\x93','\x49'},{'\x93','\x4a'},
+    {'\x93','\x4b'},{'\x93','\x4c'},{'\x93','\x4d'},{'\x93','\x4e'},{'\x93','\x4f'},
+    {'\x93','\x50'},{'\x93','\x51'},{'\x93','\x52'},{'\x93','\x53'},{'\x93','\x54'},
+    {'\x93','\x55'},{'\x93','\x56'},{'\x93','\x57'},{'\x93','\x58'},{'\x93','\x59'},
+    {'\x93','\x5a'},{'\x93','\x5b'},{'\x93','\x5c'},{'\x93','\x5d'},{'\x93','\x5e'},
+    {'\x93','\x5f'},{'\x93','\x60'},{'\x93','\x61'},{'\x93','\x62'},{'\x93','\x63'},
+    {'\x93','\x64'},{'\x93','\x65'},{'\x93','\x66'},{'\x93','\x67'},{'\x93','\x68'},
+    {'\x93','\x69'},{'\x93','\x6a'},{'\x93','\x6b'},{'\x93','\x6c'},{'\x93','\x6d'},
+    {'\x93','\x6e'},{'\x93','\x6f'},{'\x93','\x70'},{'\x93','\x71'},{'\x93','\x72'},
+    {'\x93','\x73'},{'\x93','\x74'},{'\x93','\x75'},{'\x93','\x76'},{'\x93','\x77'},
+    {'\x93','\x78'},{'\x93','\x79'},{'\x93','\x7a'},{'\x93','\x7b'},{'\x93','\x7c'},
+    {'\x93','\x7d'},{'\x93','\x7e'},{'\x93','\xa1'},{'\x93','\xa2'},{'\x93','\xa3'},
+    {'\x93','\xa4'},{'\x93','\xa5'},{'\x93','\xa6'},{'\x93','\xa7'},{'\x93','\xa8'},
+    {'\x93','\xa9'},{'\x93','\xaa'},{'\x93','\xab'},{'\x93','\xac'},{'\x93','\xad'},
+    {'\x93','\xae'},{'\x93','\xaf'},{'\x93','\xb0'},{'\x93','\xb1'},{'\x93','\xb2'},
+    {'\x93','\xb3'},{'\x93','\xb4'},{'\x93','\xb5'},{'\x93','\xb6'},{'\x93','\xb7'},
+    {'\x93','\xb8'},{'\x93','\xb9'},{'\x93','\xba'},{'\x93','\xbb'},{'\x93','\xbc'},
+    {'\x93','\xbd'},{'\x93','\xbe'},{'\x93','\xbf'},{'\x93','\xc0'},{'\x93','\xc1'},
+    {'\x93','\xc2'},{'\x93','\xc3'},{'\x93','\xc4'},{'\x93','\xc5'},{'\x93','\xc6'},
+    {'\x93','\xc7'},{'\x93','\xc8'},{'\x93','\xc9'},{'\x93','\xca'},{'\x93','\xcb'},
+    {'\x93','\xcc'},{'\x93','\xcd'},{'\x93','\xce'},{'\x93','\xcf'},{'\x93','\xd0'},
+    {'\x93','\xd1'},{'\x93','\xd2'},{'\x93','\xd3'},{'\x93','\xd4'},{'\x93','\xd5'},
+    {'\x93','\xd6'},{'\x93','\xd7'},{'\x93','\xd8'},{'\x93','\xd9'},{'\x93','\xda'},
+    {'\x93','\xdb'},{'\x93','\xdc'},{'\x93','\xdd'},{'\x93','\xde'},{'\x93','\xdf'},
+    {'\x93','\xe0'},{'\x93','\xe1'},{'\x93','\xe2'},{'\x93','\xe3'},{'\x93','\xe4'},
+    {'\x93','\xe5'},{'\x93','\xe6'},{'\x93','\xe7'},{'\x93','\xe8'},{'\x93','\xe9'},
+    {'\x93','\xea'},{'\x93','\xeb'},{'\x93','\xec'},{'\x93','\xed'},{'\x93','\xee'},
+    {'\x93','\xef'},{'\x93','\xf0'},{'\x93','\xf1'},{'\x93','\xf2'},{'\x93','\xf3'},
+    {'\x93','\xf4'},{'\x93','\xf5'},{'\x93','\xf6'},{'\x93','\xf7'},{'\x93','\xf8'},
+    {'\x93','\xf9'},{'\x93','\xfa'},{'\x93','\xfb'},{'\x93','\xfc'},{'\x93','\xfd'},
+    {'\x93','\xfe'},{'\x94','\x40'},{'\x94','\x41'},{'\x94','\x42'},{'\x94','\x43'},
+    {'\x94','\x44'},{'\x94','\x45'},{'\x94','\x46'},{'\x94','\x47'},{'\x94','\x48'},
+    {'\x94','\x49'},{'\x94','\x4a'},{'\x94','\x4b'},{'\x94','\x4c'},{'\x94','\x4d'},
+    {'\x94','\x4e'},{'\x94','\x4f'},{'\x94','\x50'},{'\x94','\x51'},{'\x94','\x52'},
+    {'\x94','\x53'},{'\x94','\x54'},{'\x94','\x55'},{'\x94','\x56'},{'\x94','\x57'},
+    {'\x94','\x58'},{'\x94','\x59'},{'\x94','\x5a'},{'\x94','\x5b'},{'\x94','\x5c'},
+    {'\x94','\x5d'},{'\x94','\x5e'},{'\x94','\x5f'},{'\x94','\x60'},{'\x94','\x61'},
+    {'\x94','\x62'},{'\x94','\x63'},{'\x94','\x64'},{'\x94','\x65'},{'\x94','\x66'},
+    {'\x94','\x67'},{'\x94','\x68'},{'\x94','\x69'},{'\x94','\x6a'},{'\x94','\x6b'},
+    {'\x94','\x6c'},{'\x94','\x6d'},{'\x94','\x6e'},{'\x94','\x6f'},{'\x94','\x70'},
+    {'\x94','\x71'},{'\x94','\x72'},{'\x94','\x73'},{'\x94','\x74'},{'\x94','\x75'},
+    {'\x94','\x76'},{'\x94','\x77'},{'\x94','\x78'},{'\x94','\x79'},{'\x94','\x7a'},
+    {'\x94','\x7b'},{'\x94','\x7c'},{'\x94','\x7d'},{'\x94','\x7e'},{'\x94','\xa1'},
+    {'\x94','\xa2'},{'\x94','\xa3'},{'\x94','\xa4'},{'\x94','\xa5'},{'\x94','\xa6'},
+    {'\x94','\xa7'},{'\x94','\xa8'},{'\x94','\xa9'},{'\x94','\xaa'},{'\x94','\xab'},
+    {'\x94','\xac'},{'\x94','\xad'},{'\x94','\xae'},{'\x94','\xaf'},{'\x94','\xb0'},
+    {'\x94','\xb1'},{'\x94','\xb2'},{'\x94','\xb3'},{'\x94','\xb4'},{'\x94','\xb5'},
+    {'\x94','\xb6'},{'\x94','\xb7'},{'\x94','\xb8'},{'\x94','\xb9'},{'\x94','\xba'},
+    {'\x94','\xbb'},{'\x94','\xbc'},{'\x94','\xbd'},{'\x94','\xbe'},{'\x94','\xbf'},
+    {'\x94','\xc0'},{'\x94','\xc1'},{'\x94','\xc2'},{'\x94','\xc3'},{'\x94','\xc4'},
+    {'\x94','\xc5'},{'\x94','\xc6'},{'\x94','\xc7'},{'\x94','\xc8'},{'\x94','\xc9'},
+    {'\x94','\xca'},{'\x94','\xcb'},{'\x94','\xcc'},{'\x94','\xcd'},{'\x94','\xce'},
+    {'\x94','\xcf'},{'\x94','\xd0'},{'\x94','\xd1'},{'\x94','\xd2'},{'\x94','\xd3'},
+    {'\x94','\xd4'},{'\x94','\xd5'},{'\x94','\xd6'},{'\x94','\xd7'},{'\x94','\xd8'},
+    {'\x94','\xd9'},{'\x94','\xda'},{'\x94','\xdb'},{'\x94','\xdc'},{'\x94','\xdd'},
+    {'\x94','\xde'},{'\x94','\xdf'},{'\x94','\xe0'},{'\x94','\xe1'},{'\x94','\xe2'},
+    {'\x94','\xe3'},{'\x94','\xe4'},{'\x94','\xe5'},{'\x94','\xe6'},{'\x94','\xe7'},
+    {'\x94','\xe8'},{'\x94','\xe9'},{'\x94','\xea'},{'\x94','\xeb'},{'\x94','\xec'},
+    {'\x94','\xed'},{'\x94','\xee'},{'\x94','\xef'},{'\x94','\xf0'},{'\x94','\xf1'},
+    {'\x94','\xf2'},{'\x94','\xf3'},{'\x94','\xf4'},{'\x94','\xf5'},{'\x94','\xf6'},
+    {'\x94','\xf7'},{'\x94','\xf8'},{'\x94','\xf9'},{'\x94','\xfa'},{'\x94','\xfb'},
+    {'\x94','\xfc'},{'\x94','\xfd'},{'\x94','\xfe'},{'\x95','\x40'},{'\x95','\x41'},
+    {'\x95','\x42'},{'\x95','\x43'},{'\x95','\x44'},{'\x95','\x45'},{'\x95','\x46'},
+    {'\x95','\x47'},{'\x95','\x48'},{'\x95','\x49'},{'\x95','\x4a'},{'\x95','\x4b'},
+    {'\x95','\x4c'},{'\x95','\x4d'},{'\x95','\x4e'},{'\x95','\x4f'},{'\x95','\x50'},
+    {'\x95','\x51'},{'\x95','\x52'},{'\x95','\x53'},{'\x95','\x54'},{'\x95','\x55'},
+    {'\x95','\x56'},{'\x95','\x57'},{'\x95','\x58'},{'\x95','\x59'},{'\x95','\x5a'},
+    {'\x95','\x5b'},{'\x95','\x5c'},{'\x95','\x5d'},{'\x95','\x5e'},{'\x95','\x5f'},
+    {'\x95','\x60'},{'\x95','\x61'},{'\x95','\x62'},{'\x95','\x63'},{'\x95','\x64'},
+    {'\x95','\x65'},{'\x95','\x66'},{'\x95','\x67'},{'\x95','\x68'},{'\x95','\x69'},
+    {'\x95','\x6a'},{'\x95','\x6b'},{'\x95','\x6c'},{'\x95','\x6d'},{'\x95','\x6e'},
+    {'\x95','\x6f'},{'\x95','\x70'},{'\x95','\x71'},{'\x95','\x72'},{'\x95','\x73'},
+    {'\x95','\x74'},{'\x95','\x75'},{'\x95','\x76'},{'\x95','\x77'},{'\x95','\x78'},
+    {'\x95','\x79'},{'\x95','\x7a'},{'\x95','\x7b'},{'\x95','\x7c'},{'\x95','\x7d'},
+    {'\x95','\x7e'},{'\x95','\xa1'},{'\x95','\xa2'},{'\x95','\xa3'},{'\x95','\xa4'},
+    {'\x95','\xa5'},{'\x95','\xa6'},{'\x95','\xa7'},{'\x95','\xa8'},{'\x95','\xa9'},
+    {'\x95','\xaa'},{'\x95','\xab'},{'\x95','\xac'},{'\x95','\xad'},{'\x95','\xae'},
+    {'\x95','\xaf'},{'\x95','\xb0'},{'\x95','\xb1'},{'\x95','\xb2'},{'\x95','\xb3'},
+    {'\x95','\xb4'},{'\x95','\xb5'},{'\x95','\xb6'},{'\x95','\xb7'},{'\x95','\xb8'},
+    {'\x95','\xb9'},{'\x95','\xba'},{'\x95','\xbb'},{'\x95','\xbc'},{'\x95','\xbd'},
+    {'\x95','\xbe'},{'\x95','\xbf'},{'\x95','\xc0'},{'\x95','\xc1'},{'\x95','\xc2'},
+    {'\x95','\xc3'},{'\x95','\xc4'},{'\x95','\xc5'},{'\x95','\xc6'},{'\x95','\xc7'},
+    {'\x95','\xc8'},{'\x95','\xc9'},{'\x95','\xca'},{'\x95','\xcb'},{'\x95','\xcc'},
+    {'\x95','\xcd'},{'\x95','\xce'},{'\x95','\xcf'},{'\x95','\xd0'},{'\x95','\xd1'},
+    {'\x95','\xd2'},{'\x95','\xd3'},{'\x95','\xd4'},{'\x95','\xd5'},{'\x95','\xd6'},
+    {'\x95','\xd7'},{'\x95','\xd8'},{'\x95','\xd9'},{'\x95','\xda'},{'\x95','\xdb'},
+    {'\x95','\xdc'},{'\x95','\xdd'},{'\x95','\xde'},{'\x95','\xdf'},{'\x95','\xe0'},
+    {'\x95','\xe1'},{'\x95','\xe2'},{'\x95','\xe3'},{'\x95','\xe4'},{'\x95','\xe5'},
+    {'\x95','\xe6'},{'\x95','\xe7'},{'\x95','\xe8'},{'\x95','\xe9'},{'\x95','\xea'},
+    {'\x95','\xeb'},{'\x95','\xec'},{'\x95','\xed'},{'\x95','\xee'},{'\x95','\xef'},
+    {'\x95','\xf0'},{'\x95','\xf1'},{'\x95','\xf2'},{'\x95','\xf3'},{'\x95','\xf4'},
+    {'\x95','\xf5'},{'\x95','\xf6'},{'\x95','\xf7'},{'\x95','\xf8'},{'\x95','\xf9'},
+    {'\x95','\xfa'},{'\x95','\xfb'},{'\x95','\xfc'},{'\x95','\xfd'},{'\x95','\xfe'},
+    {'\x96','\x40'},{'\x96','\x41'},{'\x96','\x42'},{'\x96','\x43'},{'\x96','\x44'},
+    {'\x96','\x45'},{'\x96','\x46'},{'\x96','\x47'},{'\x96','\x48'},{'\x96','\x49'},
+    {'\x96','\x4a'},{'\x96','\x4b'},{'\x96','\x4c'},{'\x96','\x4d'},{'\x96','\x4e'},
+    {'\x96','\x4f'},{'\x96','\x50'},{'\x96','\x51'},{'\x96','\x52'},{'\x96','\x53'},
+    {'\x96','\x54'},{'\x96','\x55'},{'\x96','\x56'},{'\x96','\x57'},{'\x96','\x58'},
+    {'\x96','\x59'},{'\x96','\x5a'},{'\x96','\x5b'},{'\x96','\x5c'},{'\x96','\x5d'},
+    {'\x96','\x5e'},{'\x96','\x5f'},{'\x96','\x60'},{'\x96','\x61'},{'\x96','\x62'},
+    {'\x96','\x63'},{'\x96','\x64'},{'\x96','\x65'},{'\x96','\x66'},{'\x96','\x67'},
+    {'\x96','\x68'},{'\x96','\x69'},{'\x96','\x6a'},{'\x96','\x6b'},{'\x96','\x6c'},
+    {'\x96','\x6d'},{'\x96','\x6e'},{'\x96','\x6f'},{'\x96','\x70'},{'\x96','\x71'},
+    {'\x96','\x72'},{'\x96','\x73'},{'\x96','\x74'},{'\x96','\x75'},{'\x96','\x76'},
+    {'\x96','\x77'},{'\x96','\x78'},{'\x96','\x79'},{'\x96','\x7a'},{'\x96','\x7b'},
+    {'\x96','\x7c'},{'\x96','\x7d'},{'\x96','\x7e'},{'\x96','\xa1'},{'\x96','\xa2'},
+    {'\x96','\xa3'},{'\x96','\xa4'},{'\x96','\xa5'},{'\x96','\xa6'},{'\x96','\xa7'},
+    {'\x96','\xa8'},{'\x96','\xa9'},{'\x96','\xaa'},{'\x96','\xab'},{'\x96','\xac'},
+    {'\x96','\xad'},{'\x96','\xae'},{'\x96','\xaf'},{'\x96','\xb0'},{'\x96','\xb1'},
+    {'\x96','\xb2'},{'\x96','\xb3'},{'\x96','\xb4'},{'\x96','\xb5'},{'\x96','\xb6'},
+    {'\x96','\xb7'},{'\x96','\xb8'},{'\x96','\xb9'},{'\x96','\xba'},{'\x96','\xbb'},
+    {'\x96','\xbc'},{'\x96','\xbd'},{'\x96','\xbe'},{'\x96','\xbf'},{'\x96','\xc0'},
+    {'\x96','\xc1'},{'\x96','\xc2'},{'\x96','\xc3'},{'\x96','\xc4'},{'\x96','\xc5'},
+    {'\x96','\xc6'},{'\x96','\xc7'},{'\x96','\xc8'},{'\x96','\xc9'},{'\x96','\xca'},
+    {'\x96','\xcb'},{'\x96','\xcc'},{'\x96','\xcd'},{'\x96','\xce'},{'\x96','\xcf'},
+    {'\x96','\xd0'},{'\x96','\xd1'},{'\x96','\xd2'},{'\x96','\xd3'},{'\x96','\xd4'},
+    {'\x96','\xd5'},{'\x96','\xd6'},{'\x96','\xd7'},{'\x96','\xd8'},{'\x96','\xd9'},
+    {'\x96','\xda'},{'\x96','\xdb'},{'\x96','\xdc'},{'\x96','\xdd'},{'\x96','\xde'},
+    {'\x96','\xdf'},{'\x96','\xe0'},{'\x96','\xe1'},{'\x96','\xe2'},{'\x96','\xe3'},
+    {'\x96','\xe4'},{'\x96','\xe5'},{'\x96','\xe6'},{'\x96','\xe7'},{'\x96','\xe8'},
+    {'\x96','\xe9'},{'\x96','\xea'},{'\x96','\xeb'},{'\x96','\xec'},{'\x96','\xed'},
+    {'\x96','\xee'},{'\x96','\xef'},{'\x96','\xf0'},{'\x96','\xf1'},{'\x96','\xf2'},
+    {'\x96','\xf3'},{'\x96','\xf4'},{'\x96','\xf5'},{'\x96','\xf6'},{'\x96','\xf7'},
+    {'\x96','\xf8'},{'\x96','\xf9'},{'\x96','\xfa'},{'\x96','\xfb'},{'\x96','\xfc'},
+    {'\x96','\xfd'},{'\x96','\xfe'},{'\x97','\x40'},{'\x97','\x41'},{'\x97','\x42'},
+    {'\x97','\x43'},{'\x97','\x44'},{'\x97','\x45'},{'\x97','\x46'},{'\x97','\x47'},
+    {'\x97','\x48'},{'\x97','\x49'},{'\x97','\x4a'},{'\x97','\x4b'},{'\x97','\x4c'},
+    {'\x97','\x4d'},{'\x97','\x4e'},{'\x97','\x4f'},{'\x97','\x50'},{'\x97','\x51'},
+    {'\x97','\x52'},{'\x97','\x53'},{'\x97','\x54'},{'\x97','\x55'},{'\x97','\x56'},
+    {'\x97','\x57'},{'\x97','\x58'},{'\x97','\x59'},{'\x97','\x5a'},{'\x97','\x5b'},
+    {'\x97','\x5c'},{'\x97','\x5d'},{'\x97','\x5e'},{'\x97','\x5f'},{'\x97','\x60'},
+    {'\x97','\x61'},{'\x97','\x62'},{'\x97','\x63'},{'\x97','\x64'},{'\x97','\x65'},
+    {'\x97','\x66'},{'\x97','\x67'},{'\x97','\x68'},{'\x97','\x69'},{'\x97','\x6a'},
+    {'\x97','\x6b'},{'\x97','\x6c'},{'\x97','\x6d'},{'\x97','\x6e'},{'\x97','\x6f'},
+    {'\x97','\x70'},{'\x97','\x71'},{'\x97','\x72'},{'\x97','\x73'},{'\x97','\x74'},
+    {'\x97','\x75'},{'\x97','\x76'},{'\x97','\x77'},{'\x97','\x78'},{'\x97','\x79'},
+    {'\x97','\x7a'},{'\x97','\x7b'},{'\x97','\x7c'},{'\x97','\x7d'},{'\x97','\x7e'},
+    {'\x97','\xa1'},{'\x97','\xa2'},{'\x97','\xa3'},{'\x97','\xa4'},{'\x97','\xa5'},
+    {'\x97','\xa6'},{'\x97','\xa7'},{'\x97','\xa8'},{'\x97','\xa9'},{'\x97','\xaa'},
+    {'\x97','\xab'},{'\x97','\xac'},{'\x97','\xad'},{'\x97','\xae'},{'\x97','\xaf'},
+    {'\x97','\xb0'},{'\x97','\xb1'},{'\x97','\xb2'},{'\x97','\xb3'},{'\x97','\xb4'},
+    {'\x97','\xb5'},{'\x97','\xb6'},{'\x97','\xb7'},{'\x97','\xb8'},{'\x97','\xb9'},
+    {'\x97','\xba'},{'\x97','\xbb'},{'\x97','\xbc'},{'\x97','\xbd'},{'\x97','\xbe'},
+    {'\x97','\xbf'},{'\x97','\xc0'},{'\x97','\xc1'},{'\x97','\xc2'},{'\x97','\xc3'},
+    {'\x97','\xc4'},{'\x97','\xc5'},{'\x97','\xc6'},{'\x97','\xc7'},{'\x97','\xc8'},
+    {'\x97','\xc9'},{'\x97','\xca'},{'\x97','\xcb'},{'\x97','\xcc'},{'\x97','\xcd'},
+    {'\x97','\xce'},{'\x97','\xcf'},{'\x97','\xd0'},{'\x97','\xd1'},{'\x97','\xd2'},
+    {'\x97','\xd3'},{'\x97','\xd4'},{'\x97','\xd5'},{'\x97','\xd6'},{'\x97','\xd7'},
+    {'\x97','\xd8'},{'\x97','\xd9'},{'\x97','\xda'},{'\x97','\xdb'},{'\x97','\xdc'},
+    {'\x97','\xdd'},{'\x97','\xde'},{'\x97','\xdf'},{'\x97','\xe0'},{'\x97','\xe1'},
+    {'\x97','\xe2'},{'\x97','\xe3'},{'\x97','\xe4'},{'\x97','\xe5'},{'\x97','\xe6'},
+    {'\x97','\xe7'},{'\x97','\xe8'},{'\x97','\xe9'},{'\x97','\xea'},{'\x97','\xeb'},
+    {'\x97','\xec'},{'\x97','\xed'},{'\x97','\xee'},{'\x97','\xef'},{'\x97','\xf0'},
+    {'\x97','\xf1'},{'\x97','\xf2'},{'\x97','\xf3'},{'\x97','\xf4'},{'\x97','\xf5'},
+    {'\x97','\xf6'},{'\x97','\xf7'},{'\x97','\xf8'},{'\x97','\xf9'},{'\x97','\xfa'},
+    {'\x97','\xfb'},{'\x97','\xfc'},{'\x97','\xfd'},{'\x97','\xfe'},{'\x98','\x40'},
+    {'\x98','\x41'},{'\x98','\x42'},{'\x98','\x43'},{'\x98','\x44'},{'\x98','\x45'},
+    {'\x98','\x46'},{'\x98','\x47'},{'\x98','\x48'},{'\x98','\x49'},{'\x98','\x4a'},
+    {'\x98','\x4b'},{'\x98','\x4c'},{'\x98','\x4d'},{'\x98','\x4e'},{'\x98','\x4f'},
+    {'\x98','\x50'},{'\x98','\x51'},{'\x98','\x52'},{'\x98','\x53'},{'\x98','\x54'},
+    {'\x98','\x55'},{'\x98','\x56'},{'\x98','\x57'},{'\x98','\x58'},{'\x98','\x59'},
+    {'\x98','\x5a'},{'\x98','\x5b'},{'\x98','\x5c'},{'\x98','\x5d'},{'\x98','\x5e'},
+    {'\x98','\x5f'},{'\x98','\x60'},{'\x98','\x61'},{'\x98','\x62'},{'\x98','\x63'},
+    {'\x98','\x64'},{'\x98','\x65'},{'\x98','\x66'},{'\x98','\x67'},{'\x98','\x68'},
+    {'\x98','\x69'},{'\x98','\x6a'},{'\x98','\x6b'},{'\x98','\x6c'},{'\x98','\x6d'},
+    {'\x98','\x6e'},{'\x98','\x6f'},{'\x98','\x70'},{'\x98','\x71'},{'\x98','\x72'},
+    {'\x98','\x73'},{'\x98','\x74'},{'\x98','\x75'},{'\x98','\x76'},{'\x98','\x77'},
+    {'\x98','\x78'},{'\x98','\x79'},{'\x98','\x7a'},{'\x98','\x7b'},{'\x98','\x7c'},
+    {'\x98','\x7d'},{'\x98','\x7e'},{'\x98','\xa1'},{'\x98','\xa2'},{'\x98','\xa3'},
+    {'\x98','\xa4'},{'\x98','\xa5'},{'\x98','\xa6'},{'\x98','\xa7'},{'\x98','\xa8'},
+    {'\x98','\xa9'},{'\x98','\xaa'},{'\x98','\xab'},{'\x98','\xac'},{'\x98','\xad'},
+    {'\x98','\xae'},{'\x98','\xaf'},{'\x98','\xb0'},{'\x98','\xb1'},{'\x98','\xb2'},
+    {'\x98','\xb3'},{'\x98','\xb4'},{'\x98','\xb5'},{'\x98','\xb6'},{'\x98','\xb7'},
+    {'\x98','\xb8'},{'\x98','\xb9'},{'\x98','\xba'},{'\x98','\xbb'},{'\x98','\xbc'},
+    {'\x98','\xbd'},{'\x98','\xbe'},{'\x98','\xbf'},{'\x98','\xc0'},{'\x98','\xc1'},
+    {'\x98','\xc2'},{'\x98','\xc3'},{'\x98','\xc4'},{'\x98','\xc5'},{'\x98','\xc6'},
+    {'\x98','\xc7'},{'\x98','\xc8'},{'\x98','\xc9'},{'\x98','\xca'},{'\x98','\xcb'},
+    {'\x98','\xcc'},{'\x98','\xcd'},{'\x98','\xce'},{'\x98','\xcf'},{'\x98','\xd0'},
+    {'\x98','\xd1'},{'\x98','\xd2'},{'\x98','\xd3'},{'\x98','\xd4'},{'\x98','\xd5'},
+    {'\x98','\xd6'},{'\x98','\xd7'},{'\x98','\xd8'},{'\x98','\xd9'},{'\x98','\xda'},
+    {'\x98','\xdb'},{'\x98','\xdc'},{'\x98','\xdd'},{'\x98','\xde'},{'\x98','\xdf'},
+    {'\x98','\xe0'},{'\x98','\xe1'},{'\x98','\xe2'},{'\x98','\xe3'},{'\x98','\xe4'},
+    {'\x98','\xe5'},{'\x98','\xe6'},{'\x98','\xe7'},{'\x98','\xe8'},{'\x98','\xe9'},
+    {'\x98','\xea'},{'\x98','\xeb'},{'\x98','\xec'},{'\x98','\xed'},{'\x98','\xee'},
+    {'\x98','\xef'},{'\x98','\xf0'},{'\x98','\xf1'},{'\x98','\xf2'},{'\x98','\xf3'},
+    {'\x98','\xf4'},{'\x98','\xf5'},{'\x98','\xf6'},{'\x98','\xf7'},{'\x98','\xf8'},
+    {'\x98','\xf9'},{'\x98','\xfa'},{'\x98','\xfb'},{'\x98','\xfc'},{'\x98','\xfd'},
+    {'\x98','\xfe'},{'\x99','\x40'},{'\x99','\x41'},{'\x99','\x42'},{'\x99','\x43'},
+    {'\x99','\x44'},{'\x99','\x45'},{'\x99','\x46'},{'\x99','\x47'},{'\x99','\x48'},
+    {'\x99','\x49'},{'\x99','\x4a'},{'\x99','\x4b'},{'\x99','\x4c'},{'\x99','\x4d'},
+    {'\x99','\x4e'},{'\x99','\x4f'},{'\x99','\x50'},{'\x99','\x51'},{'\x99','\x52'},
+    {'\x99','\x53'},{'\x99','\x54'},{'\x99','\x55'},{'\x99','\x56'},{'\x99','\x57'},
+    {'\x99','\x58'},{'\x99','\x59'},{'\x99','\x5a'},{'\x99','\x5b'},{'\x99','\x5c'},
+    {'\x99','\x5d'},{'\x99','\x5e'},{'\x99','\x5f'},{'\x99','\x60'},{'\x99','\x61'},
+    {'\x99','\x62'},{'\x99','\x63'},{'\x99','\x64'},{'\x99','\x65'},{'\x99','\x66'},
+    {'\x99','\x67'},{'\x99','\x68'},{'\x99','\x69'},{'\x99','\x6a'},{'\x99','\x6b'},
+    {'\x99','\x6c'},{'\x99','\x6d'},{'\x99','\x6e'},{'\x99','\x6f'},{'\x99','\x70'},
+    {'\x99','\x71'},{'\x99','\x72'},{'\x99','\x73'},{'\x99','\x74'},{'\x99','\x75'},
+    {'\x99','\x76'},{'\x99','\x77'},{'\x99','\x78'},{'\x99','\x79'},{'\x99','\x7a'},
+    {'\x99','\x7b'},{'\x99','\x7c'},{'\x99','\x7d'},{'\x99','\x7e'},{'\x99','\xa1'},
+    {'\x99','\xa2'},{'\x99','\xa3'},{'\x99','\xa4'},{'\x99','\xa5'},{'\x99','\xa6'},
+    {'\x99','\xa7'},{'\x99','\xa8'},{'\x99','\xa9'},{'\x99','\xaa'},{'\x99','\xab'},
+    {'\x99','\xac'},{'\x99','\xad'},{'\x99','\xae'},{'\x99','\xaf'},{'\x99','\xb0'},
+    {'\x99','\xb1'},{'\x99','\xb2'},{'\x99','\xb3'},{'\x99','\xb4'},{'\x99','\xb5'},
+    {'\x99','\xb6'},{'\x99','\xb7'},{'\x99','\xb8'},{'\x99','\xb9'},{'\x99','\xba'},
+    {'\x99','\xbb'},{'\x99','\xbc'},{'\x99','\xbd'},{'\x99','\xbe'},{'\x99','\xbf'},
+    {'\x99','\xc0'},{'\x99','\xc1'},{'\x99','\xc2'},{'\x99','\xc3'},{'\x99','\xc4'},
+    {'\x99','\xc5'},{'\x99','\xc6'},{'\x99','\xc7'},{'\x99','\xc8'},{'\x99','\xc9'},
+    {'\x99','\xca'},{'\x99','\xcb'},{'\x99','\xcc'},{'\x99','\xcd'},{'\x99','\xce'},
+    {'\x99','\xcf'},{'\x99','\xd0'},{'\x99','\xd1'},{'\x99','\xd2'},{'\x99','\xd3'},
+    {'\x99','\xd4'},{'\x99','\xd5'},{'\x99','\xd6'},{'\x99','\xd7'},{'\x99','\xd8'},
+    {'\x99','\xd9'},{'\x99','\xda'},{'\x99','\xdb'},{'\x99','\xdc'},{'\x99','\xdd'},
+    {'\x99','\xde'},{'\x99','\xdf'},{'\x99','\xe0'},{'\x99','\xe1'},{'\x99','\xe2'},
+    {'\x99','\xe3'},{'\x99','\xe4'},{'\x99','\xe5'},{'\x99','\xe6'},{'\x99','\xe7'},
+    {'\x99','\xe8'},{'\x99','\xe9'},{'\x99','\xea'},{'\x99','\xeb'},{'\x99','\xec'},
+    {'\x99','\xed'},{'\x99','\xee'},{'\x99','\xef'},{'\x99','\xf0'},{'\x99','\xf1'},
+    {'\x99','\xf2'},{'\x99','\xf3'},{'\x99','\xf4'},{'\x99','\xf5'},{'\x99','\xf6'},
+    {'\x99','\xf7'},{'\x99','\xf8'},{'\x99','\xf9'},{'\x99','\xfa'},{'\x99','\xfb'},
+    {'\x99','\xfc'},{'\x99','\xfd'},{'\x99','\xfe'},{'\x9a','\x40'},{'\x9a','\x41'},
+    {'\x9a','\x42'},{'\x9a','\x43'},{'\x9a','\x44'},{'\x9a','\x45'},{'\x9a','\x46'},
+    {'\x9a','\x47'},{'\x9a','\x48'},{'\x9a','\x49'},{'\x9a','\x4a'},{'\x9a','\x4b'},
+    {'\x9a','\x4c'},{'\x9a','\x4d'},{'\x9a','\x4e'},{'\x9a','\x4f'},{'\x9a','\x50'},
+    {'\x9a','\x51'},{'\x9a','\x52'},{'\x9a','\x53'},{'\x9a','\x54'},{'\x9a','\x55'},
+    {'\x9a','\x56'},{'\x9a','\x57'},{'\x9a','\x58'},{'\x9a','\x59'},{'\x9a','\x5a'},
+    {'\x9a','\x5b'},{'\x9a','\x5c'},{'\x9a','\x5d'},{'\x9a','\x5e'},{'\x9a','\x5f'},
+    {'\x9a','\x60'},{'\x9a','\x61'},{'\x9a','\x62'},{'\x9a','\x63'},{'\x9a','\x64'},
+    {'\x9a','\x65'},{'\x9a','\x66'},{'\x9a','\x67'},{'\x9a','\x68'},{'\x9a','\x69'},
+    {'\x9a','\x6a'},{'\x9a','\x6b'},{'\x9a','\x6c'},{'\x9a','\x6d'},{'\x9a','\x6e'},
+    {'\x9a','\x6f'},{'\x9a','\x70'},{'\x9a','\x71'},{'\x9a','\x72'},{'\x9a','\x73'},
+    {'\x9a','\x74'},{'\x9a','\x75'},{'\x9a','\x76'},{'\x9a','\x77'},{'\x9a','\x78'},
+    {'\x9a','\x79'},{'\x9a','\x7a'},{'\x9a','\x7b'},{'\x9a','\x7c'},{'\x9a','\x7d'},
+    {'\x9a','\x7e'},{'\x9a','\xa1'},{'\x9a','\xa2'},{'\x9a','\xa3'},{'\x9a','\xa4'},
+    {'\x9a','\xa5'},{'\x9a','\xa6'},{'\x9a','\xa7'},{'\x9a','\xa8'},{'\x9a','\xa9'},
+    {'\x9a','\xaa'},{'\x9a','\xab'},{'\x9a','\xac'},{'\x9a','\xad'},{'\x9a','\xae'},
+    {'\x9a','\xaf'},{'\x9a','\xb0'},{'\x9a','\xb1'},{'\x9a','\xb2'},{'\x9a','\xb3'},
+    {'\x9a','\xb4'},{'\x9a','\xb5'},{'\x9a','\xb6'},{'\x9a','\xb7'},{'\x9a','\xb8'},
+    {'\x9a','\xb9'},{'\x9a','\xba'},{'\x9a','\xbb'},{'\x9a','\xbc'},{'\x9a','\xbd'},
+    {'\x9a','\xbe'},{'\x9a','\xbf'},{'\x9a','\xc0'},{'\x9a','\xc1'},{'\x9a','\xc2'},
+    {'\x9a','\xc3'},{'\x9a','\xc4'},{'\x9a','\xc5'},{'\x9a','\xc6'},{'\x9a','\xc7'},
+    {'\x9a','\xc8'},{'\x9a','\xc9'},{'\x9a','\xca'},{'\x9a','\xcb'},{'\x9a','\xcc'},
+    {'\x9a','\xcd'},{'\x9a','\xce'},{'\x9a','\xcf'},{'\x9a','\xd0'},{'\x9a','\xd1'},
+    {'\x9a','\xd2'},{'\x9a','\xd3'},{'\x9a','\xd4'},{'\x9a','\xd5'},{'\x9a','\xd6'},
+    {'\x9a','\xd7'},{'\x9a','\xd8'},{'\x9a','\xd9'},{'\x9a','\xda'},{'\x9a','\xdb'},
+    {'\x9a','\xdc'},{'\x9a','\xdd'},{'\x9a','\xde'},{'\x9a','\xdf'},{'\x9a','\xe0'},
+    {'\x9a','\xe1'},{'\x9a','\xe2'},{'\x9a','\xe3'},{'\x9a','\xe4'},{'\x9a','\xe5'},
+    {'\x9a','\xe6'},{'\x9a','\xe7'},{'\x9a','\xe8'},{'\x9a','\xe9'},{'\x9a','\xea'},
+    {'\x9a','\xeb'},{'\x9a','\xec'},{'\x9a','\xed'},{'\x9a','\xee'},{'\x9a','\xef'},
+    {'\x9a','\xf0'},{'\x9a','\xf1'},{'\x9a','\xf2'},{'\x9a','\xf3'},{'\x9a','\xf4'},
+    {'\x9a','\xf5'},{'\x9a','\xf6'},{'\x9a','\xf7'},{'\x9a','\xf8'},{'\x9a','\xf9'},
+    {'\x9a','\xfa'},{'\x9a','\xfb'},{'\x9a','\xfc'},{'\x9a','\xfd'},{'\x9a','\xfe'},
+    {'\x9b','\x40'},{'\x9b','\x41'},{'\x9b','\x42'},{'\x9b','\x43'},{'\x9b','\x44'},
+    {'\x9b','\x45'},{'\x9b','\x46'},{'\x9b','\x47'},{'\x9b','\x48'},{'\x9b','\x49'},
+    {'\x9b','\x4a'},{'\x9b','\x4b'},{'\x9b','\x4c'},{'\x9b','\x4d'},{'\x9b','\x4e'},
+    {'\x9b','\x4f'},{'\x9b','\x50'},{'\x9b','\x51'},{'\x9b','\x52'},{'\x9b','\x53'},
+    {'\x9b','\x54'},{'\x9b','\x55'},{'\x9b','\x56'},{'\x9b','\x57'},{'\x9b','\x58'},
+    {'\x9b','\x59'},{'\x9b','\x5a'},{'\x9b','\x5b'},{'\x9b','\x5c'},{'\x9b','\x5d'},
+    {'\x9b','\x5e'},{'\x9b','\x5f'},{'\x9b','\x60'},{'\x9b','\x61'},{'\x9b','\x62'},
+    {'\x9b','\x63'},{'\x9b','\x64'},{'\x9b','\x65'},{'\x9b','\x66'},{'\x9b','\x67'},
+    {'\x9b','\x68'},{'\x9b','\x69'},{'\x9b','\x6a'},{'\x9b','\x6b'},{'\x9b','\x6c'},
+    {'\x9b','\x6d'},{'\x9b','\x6e'},{'\x9b','\x6f'},{'\x9b','\x70'},{'\x9b','\x71'},
+    {'\x9b','\x72'},{'\x9b','\x73'},{'\x9b','\x74'},{'\x9b','\x75'},{'\x9b','\x76'},
+    {'\x9b','\x77'},{'\x9b','\x78'},{'\x9b','\x79'},{'\x9b','\x7a'},{'\x9b','\x7b'},
+    {'\x9b','\x7c'},{'\x9b','\x7d'},{'\x9b','\x7e'},{'\x9b','\xa1'},{'\x9b','\xa2'},
+    {'\x9b','\xa3'},{'\x9b','\xa4'},{'\x9b','\xa5'},{'\x9b','\xa6'},{'\x9b','\xa7'},
+    {'\x9b','\xa8'},{'\x9b','\xa9'},{'\x9b','\xaa'},{'\x9b','\xab'},{'\x9b','\xac'},
+    {'\x9b','\xad'},{'\x9b','\xae'},{'\x9b','\xaf'},{'\x9b','\xb0'},{'\x9b','\xb1'},
+    {'\x9b','\xb2'},{'\x9b','\xb3'},{'\x9b','\xb4'},{'\x9b','\xb5'},{'\x9b','\xb6'},
+    {'\x9b','\xb7'},{'\x9b','\xb8'},{'\x9b','\xb9'},{'\x9b','\xba'},{'\x9b','\xbb'},
+    {'\x9b','\xbc'},{'\x9b','\xbd'},{'\x9b','\xbe'},{'\x9b','\xbf'},{'\x9b','\xc0'},
+    {'\x9b','\xc1'},{'\x9b','\xc2'},{'\x9b','\xc3'},{'\x9b','\xc4'},{'\x9b','\xc5'},
+    {'\x9b','\xc6'},{'\x9b','\xc7'},{'\x9b','\xc8'},{'\x9b','\xc9'},{'\x9b','\xca'},
+    {'\x9b','\xcb'},{'\x9b','\xcc'},{'\x9b','\xcd'},{'\x9b','\xce'},{'\x9b','\xcf'},
+    {'\x9b','\xd0'},{'\x9b','\xd1'},{'\x9b','\xd2'},{'\x9b','\xd3'},{'\x9b','\xd4'},
+    {'\x9b','\xd5'},{'\x9b','\xd6'},{'\x9b','\xd7'},{'\x9b','\xd8'},{'\x9b','\xd9'},
+    {'\x9b','\xda'},{'\x9b','\xdb'},{'\x9b','\xdc'},{'\x9b','\xdd'},{'\x9b','\xde'},
+    {'\x9b','\xdf'},{'\x9b','\xe0'},{'\x9b','\xe1'},{'\x9b','\xe2'},{'\x9b','\xe3'},
+    {'\x9b','\xe4'},{'\x9b','\xe5'},{'\x9b','\xe6'},{'\x9b','\xe7'},{'\x9b','\xe8'},
+    {'\x9b','\xe9'},{'\x9b','\xea'},{'\x9b','\xeb'},{'\x9b','\xec'},{'\x9b','\xed'},
+    {'\x9b','\xee'},{'\x9b','\xef'},{'\x9b','\xf0'},{'\x9b','\xf1'},{'\x9b','\xf2'},
+    {'\x9b','\xf3'},{'\x9b','\xf4'},{'\x9b','\xf5'},{'\x9b','\xf6'},{'\x9b','\xf7'},
+    {'\x9b','\xf8'},{'\x9b','\xf9'},{'\x9b','\xfa'},{'\x9b','\xfb'},{'\x9b','\xfc'},
+    {'\x9b','\xfd'},{'\x9b','\xfe'},{'\x9c','\x40'},{'\x9c','\x41'},{'\x9c','\x42'},
+    {'\x9c','\x43'},{'\x9c','\x44'},{'\x9c','\x45'},{'\x9c','\x46'},{'\x9c','\x47'},
+    {'\x9c','\x48'},{'\x9c','\x49'},{'\x9c','\x4a'},{'\x9c','\x4b'},{'\x9c','\x4c'},
+    {'\x9c','\x4d'},{'\x9c','\x4e'},{'\x9c','\x4f'},{'\x9c','\x50'},{'\x9c','\x51'},
+    {'\x9c','\x52'},{'\x9c','\x53'},{'\x9c','\x54'},{'\x9c','\x55'},{'\x9c','\x56'},
+    {'\x9c','\x57'},{'\x9c','\x58'},{'\x9c','\x59'},{'\x9c','\x5a'},{'\x9c','\x5b'},
+    {'\x9c','\x5c'},{'\x9c','\x5d'},{'\x9c','\x5e'},{'\x9c','\x5f'},{'\x9c','\x60'},
+    {'\x9c','\x61'},{'\x9c','\x62'},{'\x9c','\x63'},{'\x9c','\x64'},{'\x9c','\x65'},
+    {'\x9c','\x66'},{'\x9c','\x67'},{'\x9c','\x68'},{'\x9c','\x69'},{'\x9c','\x6a'},
+    {'\x9c','\x6b'},{'\x9c','\x6c'},{'\x9c','\x6d'},{'\x9c','\x6e'},{'\x9c','\x6f'},
+    {'\x9c','\x70'},{'\x9c','\x71'},{'\x9c','\x72'},{'\x9c','\x73'},{'\x9c','\x74'},
+    {'\x9c','\x75'},{'\x9c','\x76'},{'\x9c','\x77'},{'\x9c','\x78'},{'\x9c','\x79'},
+    {'\x9c','\x7a'},{'\x9c','\x7b'},{'\x9c','\x7c'},{'\x9c','\x7d'},{'\x9c','\x7e'},
+    {'\x9c','\xa1'},{'\x9c','\xa2'},{'\x9c','\xa3'},{'\x9c','\xa4'},{'\x9c','\xa5'},
+    {'\x9c','\xa6'},{'\x9c','\xa7'},{'\x9c','\xa8'},{'\x9c','\xa9'},{'\x9c','\xaa'},
+    {'\x9c','\xab'},{'\x9c','\xac'},{'\x9c','\xad'},{'\x9c','\xae'},{'\x9c','\xaf'},
+    {'\x9c','\xb0'},{'\x9c','\xb1'},{'\x9c','\xb2'},{'\x9c','\xb3'},{'\x9c','\xb4'},
+    {'\x9c','\xb5'},{'\x9c','\xb6'},{'\x9c','\xb7'},{'\x9c','\xb8'},{'\x9c','\xb9'},
+    {'\x9c','\xba'},{'\x9c','\xbb'},{'\x9c','\xbc'},{'\x9c','\xbd'},{'\x9c','\xbe'},
+    {'\x9c','\xbf'},{'\x9c','\xc0'},{'\x9c','\xc1'},{'\x9c','\xc2'},{'\x9c','\xc3'},
+    {'\x9c','\xc4'},{'\x9c','\xc5'},{'\x9c','\xc6'},{'\x9c','\xc7'},{'\x9c','\xc8'},
+    {'\x9c','\xc9'},{'\x9c','\xca'},{'\x9c','\xcb'},{'\x9c','\xcc'},{'\x9c','\xcd'},
+    {'\x9c','\xce'},{'\x9c','\xcf'},{'\x9c','\xd0'},{'\x9c','\xd1'},{'\x9c','\xd2'},
+    {'\x9c','\xd3'},{'\x9c','\xd4'},{'\x9c','\xd5'},{'\x9c','\xd6'},{'\x9c','\xd7'},
+    {'\x9c','\xd8'},{'\x9c','\xd9'},{'\x9c','\xda'},{'\x9c','\xdb'},{'\x9c','\xdc'},
+    {'\x9c','\xdd'},{'\x9c','\xde'},{'\x9c','\xdf'},{'\x9c','\xe0'},{'\x9c','\xe1'},
+    {'\x9c','\xe2'},{'\x9c','\xe3'},{'\x9c','\xe4'},{'\x9c','\xe5'},{'\x9c','\xe6'},
+    {'\x9c','\xe7'},{'\x9c','\xe8'},{'\x9c','\xe9'},{'\x9c','\xea'},{'\x9c','\xeb'},
+    {'\x9c','\xec'},{'\x9c','\xed'},{'\x9c','\xee'},{'\x9c','\xef'},{'\x9c','\xf0'},
+    {'\x9c','\xf1'},{'\x9c','\xf2'},{'\x9c','\xf3'},{'\x9c','\xf4'},{'\x9c','\xf5'},
+    {'\x9c','\xf6'},{'\x9c','\xf7'},{'\x9c','\xf8'},{'\x9c','\xf9'},{'\x9c','\xfa'},
+    {'\x9c','\xfb'},{'\x9c','\xfc'},{'\x9c','\xfd'},{'\x9c','\xfe'},{'\x9d','\x40'},
+    {'\x9d','\x41'},{'\x9d','\x42'},{'\x9d','\x43'},{'\x9d','\x44'},{'\x9d','\x45'},
+    {'\x9d','\x46'},{'\x9d','\x47'},{'\x9d','\x48'},{'\x9d','\x49'},{'\x9d','\x4a'},
+    {'\x9d','\x4b'},{'\x9d','\x4c'},{'\x9d','\x4d'},{'\x9d','\x4e'},{'\x9d','\x4f'},
+    {'\x9d','\x50'},{'\x9d','\x51'},{'\x9d','\x52'},{'\x9d','\x53'},{'\x9d','\x54'},
+    {'\x9d','\x55'},{'\x9d','\x56'},{'\x9d','\x57'},{'\x9d','\x58'},{'\x9d','\x59'},
+    {'\x9d','\x5a'},{'\x9d','\x5b'},{'\x9d','\x5c'},{'\x9d','\x5d'},{'\x9d','\x5e'},
+    {'\x9d','\x5f'},{'\x9d','\x60'},{'\x9d','\x61'},{'\x9d','\x62'},{'\x9d','\x63'},
+    {'\x9d','\x64'},{'\x9d','\x65'},{'\x9d','\x66'},{'\x9d','\x67'},{'\x9d','\x68'},
+    {'\x9d','\x69'},{'\x9d','\x6a'},{'\x9d','\x6b'},{'\x9d','\x6c'},{'\x9d','\x6d'},
+    {'\x9d','\x6e'},{'\x9d','\x6f'},{'\x9d','\x70'},{'\x9d','\x71'},{'\x9d','\x72'},
+    {'\x9d','\x73'},{'\x9d','\x74'},{'\x9d','\x75'},{'\x9d','\x76'},{'\x9d','\x77'},
+    {'\x9d','\x78'},{'\x9d','\x79'},{'\x9d','\x7a'},{'\x9d','\x7b'},{'\x9d','\x7c'},
+    {'\x9d','\x7d'},{'\x9d','\x7e'},{'\x9d','\xa1'},{'\x9d','\xa2'},{'\x9d','\xa3'},
+    {'\x9d','\xa4'},{'\x9d','\xa5'},{'\x9d','\xa6'},{'\x9d','\xa7'},{'\x9d','\xa8'},
+    {'\x9d','\xa9'},{'\x9d','\xaa'},{'\x9d','\xab'},{'\x9d','\xac'},{'\x9d','\xad'},
+    {'\x9d','\xae'},{'\x9d','\xaf'},{'\x9d','\xb0'},{'\x9d','\xb1'},{'\x9d','\xb2'},
+    {'\x9d','\xb3'},{'\x9d','\xb4'},{'\x9d','\xb5'},{'\x9d','\xb6'},{'\x9d','\xb7'},
+    {'\x9d','\xb8'},{'\x9d','\xb9'},{'\x9d','\xba'},{'\x9d','\xbb'},{'\x9d','\xbc'},
+    {'\x9d','\xbd'},{'\x9d','\xbe'},{'\x9d','\xbf'},{'\x9d','\xc0'},{'\x9d','\xc1'},
+    {'\x9d','\xc2'},{'\x9d','\xc3'},{'\x9d','\xc4'},{'\x9d','\xc5'},{'\x9d','\xc6'},
+    {'\x9d','\xc7'},{'\x9d','\xc8'},{'\x9d','\xc9'},{'\x9d','\xca'},{'\x9d','\xcb'},
+    {'\x9d','\xcc'},{'\x9d','\xcd'},{'\x9d','\xce'},{'\x9d','\xcf'},{'\x9d','\xd0'},
+    {'\x9d','\xd1'},{'\x9d','\xd2'},{'\x9d','\xd3'},{'\x9d','\xd4'},{'\x9d','\xd5'},
+    {'\x9d','\xd6'},{'\x9d','\xd7'},{'\x9d','\xd8'},{'\x9d','\xd9'},{'\x9d','\xda'},
+    {'\x9d','\xdb'},{'\x9d','\xdc'},{'\x9d','\xdd'},{'\x9d','\xde'},{'\x9d','\xdf'},
+    {'\x9d','\xe0'},{'\x9d','\xe1'},{'\x9d','\xe2'},{'\x9d','\xe3'},{'\x9d','\xe4'},
+    {'\x9d','\xe5'},{'\x9d','\xe6'},{'\x9d','\xe7'},{'\x9d','\xe8'},{'\x9d','\xe9'},
+    {'\x9d','\xea'},{'\x9d','\xeb'},{'\x9d','\xec'},{'\x9d','\xed'},{'\x9d','\xee'},
+    {'\x9d','\xef'},{'\x9d','\xf0'},{'\x9d','\xf1'},{'\x9d','\xf2'},{'\x9d','\xf3'},
+    {'\x9d','\xf4'},{'\x9d','\xf5'},{'\x9d','\xf6'},{'\x9d','\xf7'},{'\x9d','\xf8'},
+    {'\x9d','\xf9'},{'\x9d','\xfa'},{'\x9d','\xfb'},{'\x9d','\xfc'},{'\x9d','\xfd'},
+    {'\x9d','\xfe'},{'\x9e','\x40'},{'\x9e','\x41'},{'\x9e','\x42'},{'\x9e','\x43'},
+    {'\x9e','\x44'},{'\x9e','\x45'},{'\x9e','\x46'},{'\x9e','\x47'},{'\x9e','\x48'},
+    {'\x9e','\x49'},{'\x9e','\x4a'},{'\x9e','\x4b'},{'\x9e','\x4c'},{'\x9e','\x4d'},
+    {'\x9e','\x4e'},{'\x9e','\x4f'},{'\x9e','\x50'},{'\x9e','\x51'},{'\x9e','\x52'},
+    {'\x9e','\x53'},{'\x9e','\x54'},{'\x9e','\x55'},{'\x9e','\x56'},{'\x9e','\x57'},
+    {'\x9e','\x58'},{'\x9e','\x59'},{'\x9e','\x5a'},{'\x9e','\x5b'},{'\x9e','\x5c'},
+    {'\x9e','\x5d'},{'\x9e','\x5e'},{'\x9e','\x5f'},{'\x9e','\x60'},{'\x9e','\x61'},
+    {'\x9e','\x62'},{'\x9e','\x63'},{'\x9e','\x64'},{'\x9e','\x65'},{'\x9e','\x66'},
+    {'\x9e','\x67'},{'\x9e','\x68'},{'\x9e','\x69'},{'\x9e','\x6a'},{'\x9e','\x6b'},
+    {'\x9e','\x6c'},{'\x9e','\x6d'},{'\x9e','\x6e'},{'\x9e','\x6f'},{'\x9e','\x70'},
+    {'\x9e','\x71'},{'\x9e','\x72'},{'\x9e','\x73'},{'\x9e','\x74'},{'\x9e','\x75'},
+    {'\x9e','\x76'},{'\x9e','\x77'},{'\x9e','\x78'},{'\x9e','\x79'},{'\x9e','\x7a'},
+    {'\x9e','\x7b'},{'\x9e','\x7c'},{'\x9e','\x7d'},{'\x9e','\x7e'},{'\x9e','\xa1'},
+    {'\x9e','\xa2'},{'\x9e','\xa3'},{'\x9e','\xa4'},{'\x9e','\xa5'},{'\x9e','\xa6'},
+    {'\x9e','\xa7'},{'\x9e','\xa8'},{'\x9e','\xa9'},{'\x9e','\xaa'},{'\x9e','\xab'},
+    {'\x9e','\xac'},{'\x9e','\xad'},{'\x9e','\xae'},{'\x9e','\xaf'},{'\x9e','\xb0'},
+    {'\x9e','\xb1'},{'\x9e','\xb2'},{'\x9e','\xb3'},{'\x9e','\xb4'},{'\x9e','\xb5'},
+    {'\x9e','\xb6'},{'\x9e','\xb7'},{'\x9e','\xb8'},{'\x9e','\xb9'},{'\x9e','\xba'},
+    {'\x9e','\xbb'},{'\x9e','\xbc'},{'\x9e','\xbd'},{'\x9e','\xbe'},{'\x9e','\xbf'},
+    {'\x9e','\xc0'},{'\x9e','\xc1'},{'\x9e','\xc2'},{'\x9e','\xc3'},{'\x9e','\xc4'},
+    {'\x9e','\xc5'},{'\x9e','\xc6'},{'\x9e','\xc7'},{'\x9e','\xc8'},{'\x9e','\xc9'},
+    {'\x9e','\xca'},{'\x9e','\xcb'},{'\x9e','\xcc'},{'\x9e','\xcd'},{'\x9e','\xce'},
+    {'\x9e','\xcf'},{'\x9e','\xd0'},{'\x9e','\xd1'},{'\x9e','\xd2'},{'\x9e','\xd3'},
+    {'\x9e','\xd4'},{'\x9e','\xd5'},{'\x9e','\xd6'},{'\x9e','\xd7'},{'\x9e','\xd8'},
+    {'\x9e','\xd9'},{'\x9e','\xda'},{'\x9e','\xdb'},{'\x9e','\xdc'},{'\x9e','\xdd'},
+    {'\x9e','\xde'},{'\x9e','\xdf'},{'\x9e','\xe0'},{'\x9e','\xe1'},{'\x9e','\xe2'},
+    {'\x9e','\xe3'},{'\x9e','\xe4'},{'\x9e','\xe5'},{'\x9e','\xe6'},{'\x9e','\xe7'},
+    {'\x9e','\xe8'},{'\x9e','\xe9'},{'\x9e','\xea'},{'\x9e','\xeb'},{'\x9e','\xec'},
+    {'\x9e','\xed'},{'\x9e','\xee'},{'\x9e','\xef'},{'\x9e','\xf0'},{'\x9e','\xf1'},
+    {'\x9e','\xf2'},{'\x9e','\xf3'},{'\x9e','\xf4'},{'\x9e','\xf5'},{'\x9e','\xf6'},
+    {'\x9e','\xf7'},{'\x9e','\xf8'},{'\x9e','\xf9'},{'\x9e','\xfa'},{'\x9e','\xfb'},
+    {'\x9e','\xfc'},{'\x9e','\xfd'},{'\x9e','\xfe'},{'\x9f','\x40'},{'\x9f','\x41'},
+    {'\x9f','\x42'},{'\x9f','\x43'},{'\x9f','\x44'},{'\x9f','\x45'},{'\x9f','\x46'},
+    {'\x9f','\x47'},{'\x9f','\x48'},{'\x9f','\x49'},{'\x9f','\x4a'},{'\x9f','\x4b'},
+    {'\x9f','\x4c'},{'\x9f','\x4d'},{'\x9f','\x4e'},{'\x9f','\x4f'},{'\x9f','\x50'},
+    {'\x9f','\x51'},{'\x9f','\x52'},{'\x9f','\x53'},{'\x9f','\x54'},{'\x9f','\x55'},
+    {'\x9f','\x56'},{'\x9f','\x57'},{'\x9f','\x58'},{'\x9f','\x59'},{'\x9f','\x5a'},
+    {'\x9f','\x5b'},{'\x9f','\x5c'},{'\x9f','\x5d'},{'\x9f','\x5e'},{'\x9f','\x5f'},
+    {'\x9f','\x60'},{'\x9f','\x61'},{'\x9f','\x62'},{'\x9f','\x63'},{'\x9f','\x64'},
+    {'\x9f','\x65'},{'\x9f','\x66'},{'\x9f','\x67'},{'\x9f','\x68'},{'\x9f','\x69'},
+    {'\x9f','\x6a'},{'\x9f','\x6b'},{'\x9f','\x6c'},{'\x9f','\x6d'},{'\x9f','\x6e'},
+    {'\x9f','\x6f'},{'\x9f','\x70'},{'\x9f','\x71'},{'\x9f','\x72'},{'\x9f','\x73'},
+    {'\x9f','\x74'},{'\x9f','\x75'},{'\x9f','\x76'},{'\x9f','\x77'},{'\x9f','\x78'},
+    {'\x9f','\x79'},{'\x9f','\x7a'},{'\x9f','\x7b'},{'\x9f','\x7c'},{'\x9f','\x7d'},
+    {'\x9f','\x7e'},{'\x9f','\xa1'},{'\x9f','\xa2'},{'\x9f','\xa3'},{'\x9f','\xa4'},
+    {'\x9f','\xa5'},{'\x9f','\xa6'},{'\x9f','\xa7'},{'\x9f','\xa8'},{'\x9f','\xa9'},
+    {'\x9f','\xaa'},{'\x9f','\xab'},{'\x9f','\xac'},{'\x9f','\xad'},{'\x9f','\xae'},
+    {'\x9f','\xaf'},{'\x9f','\xb0'},{'\x9f','\xb1'},{'\x9f','\xb2'},{'\x9f','\xb3'},
+    {'\x9f','\xb4'},{'\x9f','\xb5'},{'\x9f','\xb6'},{'\x9f','\xb7'},{'\x9f','\xb8'},
+    {'\x9f','\xb9'},{'\x9f','\xba'},{'\x9f','\xbb'},{'\x9f','\xbc'},{'\x9f','\xbd'},
+    {'\x9f','\xbe'},{'\x9f','\xbf'},{'\x9f','\xc0'},{'\x9f','\xc1'},{'\x9f','\xc2'},
+    {'\x9f','\xc3'},{'\x9f','\xc4'},{'\x9f','\xc5'},{'\x9f','\xc6'},{'\x9f','\xc7'},
+    {'\x9f','\xc8'},{'\x9f','\xc9'},{'\x9f','\xca'},{'\x9f','\xcb'},{'\x9f','\xcc'},
+    {'\x9f','\xcd'},{'\x9f','\xce'},{'\x9f','\xcf'},{'\x9f','\xd0'},{'\x9f','\xd1'},
+    {'\x9f','\xd2'},{'\x9f','\xd3'},{'\x9f','\xd4'},{'\x9f','\xd5'},{'\x9f','\xd6'},
+    {'\x9f','\xd7'},{'\x9f','\xd8'},{'\x9f','\xd9'},{'\x9f','\xda'},{'\x9f','\xdb'},
+    {'\x9f','\xdc'},{'\x9f','\xdd'},{'\x9f','\xde'},{'\x9f','\xdf'},{'\x9f','\xe0'},
+    {'\x9f','\xe1'},{'\x9f','\xe2'},{'\x9f','\xe3'},{'\x9f','\xe4'},{'\x9f','\xe5'},
+    {'\x9f','\xe6'},{'\x9f','\xe7'},{'\x9f','\xe8'},{'\x9f','\xe9'},{'\x9f','\xea'},
+    {'\x9f','\xeb'},{'\x9f','\xec'},{'\x9f','\xed'},{'\x9f','\xee'},{'\x9f','\xef'},
+    {'\x9f','\xf0'},{'\x9f','\xf1'},{'\x9f','\xf2'},{'\x9f','\xf3'},{'\x9f','\xf4'},
+    {'\x9f','\xf5'},{'\x9f','\xf6'},{'\x9f','\xf7'},{'\x9f','\xf8'},{'\x9f','\xf9'},
+    {'\x9f','\xfa'},{'\x9f','\xfb'},{'\x9f','\xfc'},{'\x9f','\xfd'},{'\x9f','\xfe'},
+    {'\xa0','\x40'},{'\xa0','\x41'},{'\xa0','\x42'},{'\xa0','\x43'},{'\xa0','\x44'},
+    {'\xa0','\x45'},{'\xa0','\x46'},{'\xa0','\x47'},{'\xa0','\x48'},{'\xa0','\x49'},
+    {'\xa0','\x4a'},{'\xa0','\x4b'},{'\xa0','\x4c'},{'\xa0','\x4d'},{'\xa0','\x4e'},
+    {'\xa0','\x4f'},{'\xa0','\x50'},{'\xa0','\x51'},{'\xa0','\x52'},{'\xa0','\x53'},
+    {'\xa0','\x54'},{'\xa0','\x55'},{'\xa0','\x56'},{'\xa0','\x57'},{'\xa0','\x58'},
+    {'\xa0','\x59'},{'\xa0','\x5a'},{'\xa0','\x5b'},{'\xa0','\x5c'},{'\xa0','\x5d'},
+    {'\xa0','\x5e'},{'\xa0','\x5f'},{'\xa0','\x60'},{'\xa0','\x61'},{'\xa0','\x62'},
+    {'\xa0','\x63'},{'\xa0','\x64'},{'\xa0','\x65'},{'\xa0','\x66'},{'\xa0','\x67'},
+    {'\xa0','\x68'},{'\xa0','\x69'},{'\xa0','\x6a'},{'\xa0','\x6b'},{'\xa0','\x6c'},
+    {'\xa0','\x6d'},{'\xa0','\x6e'},{'\xa0','\x6f'},{'\xa0','\x70'},{'\xa0','\x71'},
+    {'\xa0','\x72'},{'\xa0','\x73'},{'\xa0','\x74'},{'\xa0','\x75'},{'\xa0','\x76'},
+    {'\xa0','\x77'},{'\xa0','\x78'},{'\xa0','\x79'},{'\xa0','\x7a'},{'\xa0','\x7b'},
+    {'\xa0','\x7c'},{'\xa0','\x7d'},{'\xa0','\x7e'},{'\xa0','\xa1'},{'\xa0','\xa2'},
+    {'\xa0','\xa3'},{'\xa0','\xa4'},{'\xa0','\xa5'},{'\xa0','\xa6'},{'\xa0','\xa7'},
+    {'\xa0','\xa8'},{'\xa0','\xa9'},{'\xa0','\xaa'},{'\xa0','\xab'},{'\xa0','\xac'},
+    {'\xa0','\xad'},{'\xa0','\xae'},{'\xa0','\xaf'},{'\xa0','\xb0'},{'\xa0','\xb1'},
+    {'\xa0','\xb2'},{'\xa0','\xb3'},{'\xa0','\xb4'},{'\xa0','\xb5'},{'\xa0','\xb6'},
+    {'\xa0','\xb7'},{'\xa0','\xb8'},{'\xa0','\xb9'},{'\xa0','\xba'},{'\xa0','\xbb'},
+    {'\xa0','\xbc'},{'\xa0','\xbd'},{'\xa0','\xbe'},{'\xa0','\xbf'},{'\xa0','\xc0'},
+    {'\xa0','\xc1'},{'\xa0','\xc2'},{'\xa0','\xc3'},{'\xa0','\xc4'},{'\xa0','\xc5'},
+    {'\xa0','\xc6'},{'\xa0','\xc7'},{'\xa0','\xc8'},{'\xa0','\xc9'},{'\xa0','\xca'},
+    {'\xa0','\xcb'},{'\xa0','\xcc'},{'\xa0','\xcd'},{'\xa0','\xce'},{'\xa0','\xcf'},
+    {'\xa0','\xd0'},{'\xa0','\xd1'},{'\xa0','\xd2'},{'\xa0','\xd3'},{'\xa0','\xd4'},
+    {'\xa0','\xd5'},{'\xa0','\xd6'},{'\xa0','\xd7'},{'\xa0','\xd8'},{'\xa0','\xd9'},
+    {'\xa0','\xda'},{'\xa0','\xdb'},{'\xa0','\xdc'},{'\xa0','\xdd'},{'\xa0','\xde'},
+    {'\xa0','\xdf'},{'\xa0','\xe0'},{'\xa0','\xe1'},{'\xa0','\xe2'},{'\xa0','\xe3'},
+    {'\xa0','\xe4'},{'\xa0','\xe5'},{'\xa0','\xe6'},{'\xa0','\xe7'},{'\xa0','\xe8'},
+    {'\xa0','\xe9'},{'\xa0','\xea'},{'\xa0','\xeb'},{'\xa0','\xec'},{'\xa0','\xed'},
+    {'\xa0','\xee'},{'\xa0','\xef'},{'\xa0','\xf0'},{'\xa0','\xf1'},{'\xa0','\xf2'},
+    {'\xa0','\xf3'},{'\xa0','\xf4'},{'\xa0','\xf5'},{'\xa0','\xf6'},{'\xa0','\xf7'},
+    {'\xa0','\xf8'},{'\xa0','\xf9'},{'\xa0','\xfa'},{'\xa0','\xfb'},{'\xa0','\xfc'},
+    {'\xa0','\xfd'},{'\xa0','\xfe'},{'\x81','\x40'},{'\x81','\x41'},{'\x81','\x42'},
+    {'\x81','\x43'},{'\x81','\x44'},{'\x81','\x45'},{'\x81','\x46'},{'\x81','\x47'},
+    {'\x81','\x48'},{'\x81','\x49'},{'\x81','\x4a'},{'\x81','\x4b'},{'\x81','\x4c'},
+    {'\x81','\x4d'},{'\x81','\x4e'},{'\x81','\x4f'},{'\x81','\x50'},{'\x81','\x51'},
+    {'\x81','\x52'},{'\x81','\x53'},{'\x81','\x54'},{'\x81','\x55'},{'\x81','\x56'},
+    {'\x81','\x57'},{'\x81','\x58'},{'\x81','\x59'},{'\x81','\x5a'},{'\x81','\x5b'},
+    {'\x81','\x5c'},{'\x81','\x5d'},{'\x81','\x5e'},{'\x81','\x5f'},{'\x81','\x60'},
+    {'\x81','\x61'},{'\x81','\x62'},{'\x81','\x63'},{'\x81','\x64'},{'\x81','\x65'},
+    {'\x81','\x66'},{'\x81','\x67'},{'\x81','\x68'},{'\x81','\x69'},{'\x81','\x6a'},
+    {'\x81','\x6b'},{'\x81','\x6c'},{'\x81','\x6d'},{'\x81','\x6e'},{'\x81','\x6f'},
+    {'\x81','\x70'},{'\x81','\x71'},{'\x81','\x72'},{'\x81','\x73'},{'\x81','\x74'},
+    {'\x81','\x75'},{'\x81','\x76'},{'\x81','\x77'},{'\x81','\x78'},{'\x81','\x79'},
+    {'\x81','\x7a'},{'\x81','\x7b'},{'\x81','\x7c'},{'\x81','\x7d'},{'\x81','\x7e'},
+    {'\x81','\xa1'},{'\x81','\xa2'},{'\x81','\xa3'},{'\x81','\xa4'},{'\x81','\xa5'},
+    {'\x81','\xa6'},{'\x81','\xa7'},{'\x81','\xa8'},{'\x81','\xa9'},{'\x81','\xaa'},
+    {'\x81','\xab'},{'\x81','\xac'},{'\x81','\xad'},{'\x81','\xae'},{'\x81','\xaf'},
+    {'\x81','\xb0'},{'\x81','\xb1'},{'\x81','\xb2'},{'\x81','\xb3'},{'\x81','\xb4'},
+    {'\x81','\xb5'},{'\x81','\xb6'},{'\x81','\xb7'},{'\x81','\xb8'},{'\x81','\xb9'},
+    {'\x81','\xba'},{'\x81','\xbb'},{'\x81','\xbc'},{'\x81','\xbd'},{'\x81','\xbe'},
+    {'\x81','\xbf'},{'\x81','\xc0'},{'\x81','\xc1'},{'\x81','\xc2'},{'\x81','\xc3'},
+    {'\x81','\xc4'},{'\x81','\xc5'},{'\x81','\xc6'},{'\x81','\xc7'},{'\x81','\xc8'},
+    {'\x81','\xc9'},{'\x81','\xca'},{'\x81','\xcb'},{'\x81','\xcc'},{'\x81','\xcd'},
+    {'\x81','\xce'},{'\x81','\xcf'},{'\x81','\xd0'},{'\x81','\xd1'},{'\x81','\xd2'},
+    {'\x81','\xd3'},{'\x81','\xd4'},{'\x81','\xd5'},{'\x81','\xd6'},{'\x81','\xd7'},
+    {'\x81','\xd8'},{'\x81','\xd9'},{'\x81','\xda'},{'\x81','\xdb'},{'\x81','\xdc'},
+    {'\x81','\xdd'},{'\x81','\xde'},{'\x81','\xdf'},{'\x81','\xe0'},{'\x81','\xe1'},
+    {'\x81','\xe2'},{'\x81','\xe3'},{'\x81','\xe4'},{'\x81','\xe5'},{'\x81','\xe6'},
+    {'\x81','\xe7'},{'\x81','\xe8'},{'\x81','\xe9'},{'\x81','\xea'},{'\x81','\xeb'},
+    {'\x81','\xec'},{'\x81','\xed'},{'\x81','\xee'},{'\x81','\xef'},{'\x81','\xf0'},
+    {'\x81','\xf1'},{'\x81','\xf2'},{'\x81','\xf3'},{'\x81','\xf4'},{'\x81','\xf5'},
+    {'\x81','\xf6'},{'\x81','\xf7'},{'\x81','\xf8'},{'\x81','\xf9'},{'\x81','\xfa'},
+    {'\x81','\xfb'},{'\x81','\xfc'},{'\x81','\xfd'},{'\x81','\xfe'},{'\x82','\x40'},
+    {'\x82','\x41'},{'\x82','\x42'},{'\x82','\x43'},{'\x82','\x44'},{'\x82','\x45'},
+    {'\x82','\x46'},{'\x82','\x47'},{'\x82','\x48'},{'\x82','\x49'},{'\x82','\x4a'},
+    {'\x82','\x4b'},{'\x82','\x4c'},{'\x82','\x4d'},{'\x82','\x4e'},{'\x82','\x4f'},
+    {'\x82','\x50'},{'\x82','\x51'},{'\x82','\x52'},{'\x82','\x53'},{'\x82','\x54'},
+    {'\x82','\x55'},{'\x82','\x56'},{'\x82','\x57'},{'\x82','\x58'},{'\x82','\x59'},
+    {'\x82','\x5a'},{'\x82','\x5b'},{'\x82','\x5c'},{'\x82','\x5d'},{'\x82','\x5e'},
+    {'\x82','\x5f'},{'\x82','\x60'},{'\x82','\x61'},{'\x82','\x62'},{'\x82','\x63'},
+    {'\x82','\x64'},{'\x82','\x65'},{'\x82','\x66'},{'\x82','\x67'},{'\x82','\x68'},
+    {'\x82','\x69'},{'\x82','\x6a'},{'\x82','\x6b'},{'\x82','\x6c'},{'\x82','\x6d'},
+    {'\x82','\x6e'},{'\x82','\x6f'},{'\x82','\x70'},{'\x82','\x71'},{'\x82','\x72'},
+    {'\x82','\x73'},{'\x82','\x74'},{'\x82','\x75'},{'\x82','\x76'},{'\x82','\x77'},
+    {'\x82','\x78'},{'\x82','\x79'},{'\x82','\x7a'},{'\x82','\x7b'},{'\x82','\x7c'},
+    {'\x82','\x7d'},{'\x82','\x7e'},{'\x82','\xa1'},{'\x82','\xa2'},{'\x82','\xa3'},
+    {'\x82','\xa4'},{'\x82','\xa5'},{'\x82','\xa6'},{'\x82','\xa7'},{'\x82','\xa8'},
+    {'\x82','\xa9'},{'\x82','\xaa'},{'\x82','\xab'},{'\x82','\xac'},{'\x82','\xad'},
+    {'\x82','\xae'},{'\x82','\xaf'},{'\x82','\xb0'},{'\x82','\xb1'},{'\x82','\xb2'},
+    {'\x82','\xb3'},{'\x82','\xb4'},{'\x82','\xb5'},{'\x82','\xb6'},{'\x82','\xb7'},
+    {'\x82','\xb8'},{'\x82','\xb9'},{'\x82','\xba'},{'\x82','\xbb'},{'\x82','\xbc'},
+    {'\x82','\xbd'},{'\x82','\xbe'},{'\x82','\xbf'},{'\x82','\xc0'},{'\x82','\xc1'},
+    {'\x82','\xc2'},{'\x82','\xc3'},{'\x82','\xc4'},{'\x82','\xc5'},{'\x82','\xc6'},
+    {'\x82','\xc7'},{'\x82','\xc8'},{'\x82','\xc9'},{'\x82','\xca'},{'\x82','\xcb'},
+    {'\x82','\xcc'},{'\x82','\xcd'},{'\x82','\xce'},{'\x82','\xcf'},{'\x82','\xd0'},
+    {'\x82','\xd1'},{'\x82','\xd2'},{'\x82','\xd3'},{'\x82','\xd4'},{'\x82','\xd5'},
+    {'\x82','\xd6'},{'\x82','\xd7'},{'\x82','\xd8'},{'\x82','\xd9'},{'\x82','\xda'},
+    {'\x82','\xdb'},{'\x82','\xdc'},{'\x82','\xdd'},{'\x82','\xde'},{'\x82','\xdf'},
+    {'\x82','\xe0'},{'\x82','\xe1'},{'\x82','\xe2'},{'\x82','\xe3'},{'\x82','\xe4'},
+    {'\x82','\xe5'},{'\x82','\xe6'},{'\x82','\xe7'},{'\x82','\xe8'},{'\x82','\xe9'},
+    {'\x82','\xea'},{'\x82','\xeb'},{'\x82','\xec'},{'\x82','\xed'},{'\x82','\xee'},
+    {'\x82','\xef'},{'\x82','\xf0'},{'\x82','\xf1'},{'\x82','\xf2'},{'\x82','\xf3'},
+    {'\x82','\xf4'},{'\x82','\xf5'},{'\x82','\xf6'},{'\x82','\xf7'},{'\x82','\xf8'},
+    {'\x82','\xf9'},{'\x82','\xfa'},{'\x82','\xfb'},{'\x82','\xfc'},{'\x82','\xfd'},
+    {'\x82','\xfe'},{'\x83','\x40'},{'\x83','\x41'},{'\x83','\x42'},{'\x83','\x43'},
+    {'\x83','\x44'},{'\x83','\x45'},{'\x83','\x46'},{'\x83','\x47'},{'\x83','\x48'},
+    {'\x83','\x49'},{'\x83','\x4a'},{'\x83','\x4b'},{'\x83','\x4c'},{'\x83','\x4d'},
+    {'\x83','\x4e'},{'\x83','\x4f'},{'\x83','\x50'},{'\x83','\x51'},{'\x83','\x52'},
+    {'\x83','\x53'},{'\x83','\x54'},{'\x83','\x55'},{'\x83','\x56'},{'\x83','\x57'},
+    {'\x83','\x58'},{'\x83','\x59'},{'\x83','\x5a'},{'\x83','\x5b'},{'\x83','\x5c'},
+    {'\x83','\x5d'},{'\x83','\x5e'},{'\x83','\x5f'},{'\x83','\x60'},{'\x83','\x61'},
+    {'\x83','\x62'},{'\x83','\x63'},{'\x83','\x64'},{'\x83','\x65'},{'\x83','\x66'},
+    {'\x83','\x67'},{'\x83','\x68'},{'\x83','\x69'},{'\x83','\x6a'},{'\x83','\x6b'},
+    {'\x83','\x6c'},{'\x83','\x6d'},{'\x83','\x6e'},{'\x83','\x6f'},{'\x83','\x70'},
+    {'\x83','\x71'},{'\x83','\x72'},{'\x83','\x73'},{'\x83','\x74'},{'\x83','\x75'},
+    {'\x83','\x76'},{'\x83','\x77'},{'\x83','\x78'},{'\x83','\x79'},{'\x83','\x7a'},
+    {'\x83','\x7b'},{'\x83','\x7c'},{'\x83','\x7d'},{'\x83','\x7e'},{'\x83','\xa1'},
+    {'\x83','\xa2'},{'\x83','\xa3'},{'\x83','\xa4'},{'\x83','\xa5'},{'\x83','\xa6'},
+    {'\x83','\xa7'},{'\x83','\xa8'},{'\x83','\xa9'},{'\x83','\xaa'},{'\x83','\xab'},
+    {'\x83','\xac'},{'\x83','\xad'},{'\x83','\xae'},{'\x83','\xaf'},{'\x83','\xb0'},
+    {'\x83','\xb1'},{'\x83','\xb2'},{'\x83','\xb3'},{'\x83','\xb4'},{'\x83','\xb5'},
+    {'\x83','\xb6'},{'\x83','\xb7'},{'\x83','\xb8'},{'\x83','\xb9'},{'\x83','\xba'},
+    {'\x83','\xbb'},{'\x83','\xbc'},{'\x83','\xbd'},{'\x83','\xbe'},{'\x83','\xbf'},
+    {'\x83','\xc0'},{'\x83','\xc1'},{'\x83','\xc2'},{'\x83','\xc3'},{'\x83','\xc4'},
+    {'\x83','\xc5'},{'\x83','\xc6'},{'\x83','\xc7'},{'\x83','\xc8'},{'\x83','\xc9'},
+    {'\x83','\xca'},{'\x83','\xcb'},{'\x83','\xcc'},{'\x83','\xcd'},{'\x83','\xce'},
+    {'\x83','\xcf'},{'\x83','\xd0'},{'\x83','\xd1'},{'\x83','\xd2'},{'\x83','\xd3'},
+    {'\x83','\xd4'},{'\x83','\xd5'},{'\x83','\xd6'},{'\x83','\xd7'},{'\x83','\xd8'},
+    {'\x83','\xd9'},{'\x83','\xda'},{'\x83','\xdb'},{'\x83','\xdc'},{'\x83','\xdd'},
+    {'\x83','\xde'},{'\x83','\xdf'},{'\x83','\xe0'},{'\x83','\xe1'},{'\x83','\xe2'},
+    {'\x83','\xe3'},{'\x83','\xe4'},{'\x83','\xe5'},{'\x83','\xe6'},{'\x83','\xe7'},
+    {'\x83','\xe8'},{'\x83','\xe9'},{'\x83','\xea'},{'\x83','\xeb'},{'\x83','\xec'},
+    {'\x83','\xed'},{'\x83','\xee'},{'\x83','\xef'},{'\x83','\xf0'},{'\x83','\xf1'},
+    {'\x83','\xf2'},{'\x83','\xf3'},{'\x83','\xf4'},{'\x83','\xf5'},{'\x83','\xf6'},
+    {'\x83','\xf7'},{'\x83','\xf8'},{'\x83','\xf9'},{'\x83','\xfa'},{'\x83','\xfb'},
+    {'\x83','\xfc'},{'\x83','\xfd'},{'\x83','\xfe'},{'\x84','\x40'},{'\x84','\x41'},
+    {'\x84','\x42'},{'\x84','\x43'},{'\x84','\x44'},{'\x84','\x45'},{'\x84','\x46'},
+    {'\x84','\x47'},{'\x84','\x48'},{'\x84','\x49'},{'\x84','\x4a'},{'\x84','\x4b'},
+    {'\x84','\x4c'},{'\x84','\x4d'},{'\x84','\x4e'},{'\x84','\x4f'},{'\x84','\x50'},
+    {'\x84','\x51'},{'\x84','\x52'},{'\x84','\x53'},{'\x84','\x54'},{'\x84','\x55'},
+    {'\x84','\x56'},{'\x84','\x57'},{'\x84','\x58'},{'\x84','\x59'},{'\x84','\x5a'},
+    {'\x84','\x5b'},{'\x84','\x5c'},{'\x84','\x5d'},{'\x84','\x5e'},{'\x84','\x5f'},
+    {'\x84','\x60'},{'\x84','\x61'},{'\x84','\x62'},{'\x84','\x63'},{'\x84','\x64'},
+    {'\x84','\x65'},{'\x84','\x66'},{'\x84','\x67'},{'\x84','\x68'},{'\x84','\x69'},
+    {'\x84','\x6a'},{'\x84','\x6b'},{'\x84','\x6c'},{'\x84','\x6d'},{'\x84','\x6e'},
+    {'\x84','\x6f'},{'\x84','\x70'},{'\x84','\x71'},{'\x84','\x72'},{'\x84','\x73'},
+    {'\x84','\x74'},{'\x84','\x75'},{'\x84','\x76'},{'\x84','\x77'},{'\x84','\x78'},
+    {'\x84','\x79'},{'\x84','\x7a'},{'\x84','\x7b'},{'\x84','\x7c'},{'\x84','\x7d'},
+    {'\x84','\x7e'},{'\x84','\xa1'},{'\x84','\xa2'},{'\x84','\xa3'},{'\x84','\xa4'},
+    {'\x84','\xa5'},{'\x84','\xa6'},{'\x84','\xa7'},{'\x84','\xa8'},{'\x84','\xa9'},
+    {'\x84','\xaa'},{'\x84','\xab'},{'\x84','\xac'},{'\x84','\xad'},{'\x84','\xae'},
+    {'\x84','\xaf'},{'\x84','\xb0'},{'\x84','\xb1'},{'\x84','\xb2'},{'\x84','\xb3'},
+    {'\x84','\xb4'},{'\x84','\xb5'},{'\x84','\xb6'},{'\x84','\xb7'},{'\x84','\xb8'},
+    {'\x84','\xb9'},{'\x84','\xba'},{'\x84','\xbb'},{'\x84','\xbc'},{'\x84','\xbd'},
+    {'\x84','\xbe'},{'\x84','\xbf'},{'\x84','\xc0'},{'\x84','\xc1'},{'\x84','\xc2'},
+    {'\x84','\xc3'},{'\x84','\xc4'},{'\x84','\xc5'},{'\x84','\xc6'},{'\x84','\xc7'},
+    {'\x84','\xc8'},{'\x84','\xc9'},{'\x84','\xca'},{'\x84','\xcb'},{'\x84','\xcc'},
+    {'\x84','\xcd'},{'\x84','\xce'},{'\x84','\xcf'},{'\x84','\xd0'},{'\x84','\xd1'},
+    {'\x84','\xd2'},{'\x84','\xd3'},{'\x84','\xd4'},{'\x84','\xd5'},{'\x84','\xd6'},
+    {'\x84','\xd7'},{'\x84','\xd8'},{'\x84','\xd9'},{'\x84','\xda'},{'\x84','\xdb'},
+    {'\x84','\xdc'},{'\x84','\xdd'},{'\x84','\xde'},{'\x84','\xdf'},{'\x84','\xe0'},
+    {'\x84','\xe1'},{'\x84','\xe2'},{'\x84','\xe3'},{'\x84','\xe4'},{'\x84','\xe5'},
+    {'\x84','\xe6'},{'\x84','\xe7'},{'\x84','\xe8'},{'\x84','\xe9'},{'\x84','\xea'},
+    {'\x84','\xeb'},{'\x84','\xec'},{'\x84','\xed'},{'\x84','\xee'},{'\x84','\xef'},
+    {'\x84','\xf0'},{'\x84','\xf1'},{'\x84','\xf2'},{'\x84','\xf3'},{'\x84','\xf4'},
+    {'\x84','\xf5'},{'\x84','\xf6'},{'\x84','\xf7'},{'\x84','\xf8'},{'\x84','\xf9'},
+    {'\x84','\xfa'},{'\x84','\xfb'},{'\x84','\xfc'},{'\x84','\xfd'},{'\x84','\xfe'},
+    {'\x85','\x40'},{'\x85','\x41'},{'\x85','\x42'},{'\x85','\x43'},{'\x85','\x44'},
+    {'\x85','\x45'},{'\x85','\x46'},{'\x85','\x47'},{'\x85','\x48'},{'\x85','\x49'},
+    {'\x85','\x4a'},{'\x85','\x4b'},{'\x85','\x4c'},{'\x85','\x4d'},{'\x85','\x4e'},
+    {'\x85','\x4f'},{'\x85','\x50'},{'\x85','\x51'},{'\x85','\x52'},{'\x85','\x53'},
+    {'\x85','\x54'},{'\x85','\x55'},{'\x85','\x56'},{'\x85','\x57'},{'\x85','\x58'},
+    {'\x85','\x59'},{'\x85','\x5a'},{'\x85','\x5b'},{'\x85','\x5c'},{'\x85','\x5d'},
+    {'\x85','\x5e'},{'\x85','\x5f'},{'\x85','\x60'},{'\x85','\x61'},{'\x85','\x62'},
+    {'\x85','\x63'},{'\x85','\x64'},{'\x85','\x65'},{'\x85','\x66'},{'\x85','\x67'},
+    {'\x85','\x68'},{'\x85','\x69'},{'\x85','\x6a'},{'\x85','\x6b'},{'\x85','\x6c'},
+    {'\x85','\x6d'},{'\x85','\x6e'},{'\x85','\x6f'},{'\x85','\x70'},{'\x85','\x71'},
+    {'\x85','\x72'},{'\x85','\x73'},{'\x85','\x74'},{'\x85','\x75'},{'\x85','\x76'},
+    {'\x85','\x77'},{'\x85','\x78'},{'\x85','\x79'},{'\x85','\x7a'},{'\x85','\x7b'},
+    {'\x85','\x7c'},{'\x85','\x7d'},{'\x85','\x7e'},{'\x85','\xa1'},{'\x85','\xa2'},
+    {'\x85','\xa3'},{'\x85','\xa4'},{'\x85','\xa5'},{'\x85','\xa6'},{'\x85','\xa7'},
+    {'\x85','\xa8'},{'\x85','\xa9'},{'\x85','\xaa'},{'\x85','\xab'},{'\x85','\xac'},
+    {'\x85','\xad'},{'\x85','\xae'},{'\x85','\xaf'},{'\x85','\xb0'},{'\x85','\xb1'},
+    {'\x85','\xb2'},{'\x85','\xb3'},{'\x85','\xb4'},{'\x85','\xb5'},{'\x85','\xb6'},
+    {'\x85','\xb7'},{'\x85','\xb8'},{'\x85','\xb9'},{'\x85','\xba'},{'\x85','\xbb'},
+    {'\x85','\xbc'},{'\x85','\xbd'},{'\x85','\xbe'},{'\x85','\xbf'},{'\x85','\xc0'},
+    {'\x85','\xc1'},{'\x85','\xc2'},{'\x85','\xc3'},{'\x85','\xc4'},{'\x85','\xc5'},
+    {'\x85','\xc6'},{'\x85','\xc7'},{'\x85','\xc8'},{'\x85','\xc9'},{'\x85','\xca'},
+    {'\x85','\xcb'},{'\x85','\xcc'},{'\x85','\xcd'},{'\x85','\xce'},{'\x85','\xcf'},
+    {'\x85','\xd0'},{'\x85','\xd1'},{'\x85','\xd2'},{'\x85','\xd3'},{'\x85','\xd4'},
+    {'\x85','\xd5'},{'\x85','\xd6'},{'\x85','\xd7'},{'\x85','\xd8'},{'\x85','\xd9'},
+    {'\x85','\xda'},{'\x85','\xdb'},{'\x85','\xdc'},{'\x85','\xdd'},{'\x85','\xde'},
+    {'\x85','\xdf'},{'\x85','\xe0'},{'\x85','\xe1'},{'\x85','\xe2'},{'\x85','\xe3'},
+    {'\x85','\xe4'},{'\x85','\xe5'},{'\x85','\xe6'},{'\x85','\xe7'},{'\x85','\xe8'},
+    {'\x85','\xe9'},{'\x85','\xea'},{'\x85','\xeb'},{'\x85','\xec'},{'\x85','\xed'},
+    {'\x85','\xee'},{'\x85','\xef'},{'\x85','\xf0'},{'\x85','\xf1'},{'\x85','\xf2'},
+    {'\x85','\xf3'},{'\x85','\xf4'},{'\x85','\xf5'},{'\x85','\xf6'},{'\x85','\xf7'},
+    {'\x85','\xf8'},{'\x85','\xf9'},{'\x85','\xfa'},{'\x85','\xfb'},{'\x85','\xfc'},
+    {'\x85','\xfd'},{'\x85','\xfe'},{'\x86','\x40'},{'\x86','\x41'},{'\x86','\x42'},
+    {'\x86','\x43'},{'\x86','\x44'},{'\x86','\x45'},{'\x86','\x46'},{'\x86','\x47'},
+    {'\x86','\x48'},{'\x86','\x49'},{'\x86','\x4a'},{'\x86','\x4b'},{'\x86','\x4c'},
+    {'\x86','\x4d'},{'\x86','\x4e'},{'\x86','\x4f'},{'\x86','\x50'},{'\x86','\x51'},
+    {'\x86','\x52'},{'\x86','\x53'},{'\x86','\x54'},{'\x86','\x55'},{'\x86','\x56'},
+    {'\x86','\x57'},{'\x86','\x58'},{'\x86','\x59'},{'\x86','\x5a'},{'\x86','\x5b'},
+    {'\x86','\x5c'},{'\x86','\x5d'},{'\x86','\x5e'},{'\x86','\x5f'},{'\x86','\x60'},
+    {'\x86','\x61'},{'\x86','\x62'},{'\x86','\x63'},{'\x86','\x64'},{'\x86','\x65'},
+    {'\x86','\x66'},{'\x86','\x67'},{'\x86','\x68'},{'\x86','\x69'},{'\x86','\x6a'},
+    {'\x86','\x6b'},{'\x86','\x6c'},{'\x86','\x6d'},{'\x86','\x6e'},{'\x86','\x6f'},
+    {'\x86','\x70'},{'\x86','\x71'},{'\x86','\x72'},{'\x86','\x73'},{'\x86','\x74'},
+    {'\x86','\x75'},{'\x86','\x76'},{'\x86','\x77'},{'\x86','\x78'},{'\x86','\x79'},
+    {'\x86','\x7a'},{'\x86','\x7b'},{'\x86','\x7c'},{'\x86','\x7d'},{'\x86','\x7e'},
+    {'\x86','\xa1'},{'\x86','\xa2'},{'\x86','\xa3'},{'\x86','\xa4'},{'\x86','\xa5'},
+    {'\x86','\xa6'},{'\x86','\xa7'},{'\x86','\xa8'},{'\x86','\xa9'},{'\x86','\xaa'},
+    {'\x86','\xab'},{'\x86','\xac'},{'\x86','\xad'},{'\x86','\xae'},{'\x86','\xaf'},
+    {'\x86','\xb0'},{'\x86','\xb1'},{'\x86','\xb2'},{'\x86','\xb3'},{'\x86','\xb4'},
+    {'\x86','\xb5'},{'\x86','\xb6'},{'\x86','\xb7'},{'\x86','\xb8'},{'\x86','\xb9'},
+    {'\x86','\xba'},{'\x86','\xbb'},{'\x86','\xbc'},{'\x86','\xbd'},{'\x86','\xbe'},
+    {'\x86','\xbf'},{'\x86','\xc0'},{'\x86','\xc1'},{'\x86','\xc2'},{'\x86','\xc3'},
+    {'\x86','\xc4'},{'\x86','\xc5'},{'\x86','\xc6'},{'\x86','\xc7'},{'\x86','\xc8'},
+    {'\x86','\xc9'},{'\x86','\xca'},{'\x86','\xcb'},{'\x86','\xcc'},{'\x86','\xcd'},
+    {'\x86','\xce'},{'\x86','\xcf'},{'\x86','\xd0'},{'\x86','\xd1'},{'\x86','\xd2'},
+    {'\x86','\xd3'},{'\x86','\xd4'},{'\x86','\xd5'},{'\x86','\xd6'},{'\x86','\xd7'},
+    {'\x86','\xd8'},{'\x86','\xd9'},{'\x86','\xda'},{'\x86','\xdb'},{'\x86','\xdc'},
+    {'\x86','\xdd'},{'\x86','\xde'},{'\x86','\xdf'},{'\x86','\xe0'},{'\x86','\xe1'},
+    {'\x86','\xe2'},{'\x86','\xe3'},{'\x86','\xe4'},{'\x86','\xe5'},{'\x86','\xe6'},
+    {'\x86','\xe7'},{'\x86','\xe8'},{'\x86','\xe9'},{'\x86','\xea'},{'\x86','\xeb'},
+    {'\x86','\xec'},{'\x86','\xed'},{'\x86','\xee'},{'\x86','\xef'},{'\x86','\xf0'},
+    {'\x86','\xf1'},{'\x86','\xf2'},{'\x86','\xf3'},{'\x86','\xf4'},{'\x86','\xf5'},
+    {'\x86','\xf6'},{'\x86','\xf7'},{'\x86','\xf8'},{'\x86','\xf9'},{'\x86','\xfa'},
+    {'\x86','\xfb'},{'\x86','\xfc'},{'\x86','\xfd'},{'\x86','\xfe'},{'\x87','\x40'},
+    {'\x87','\x41'},{'\x87','\x42'},{'\x87','\x43'},{'\x87','\x44'},{'\x87','\x45'},
+    {'\x87','\x46'},{'\x87','\x47'},{'\x87','\x48'},{'\x87','\x49'},{'\x87','\x4a'},
+    {'\x87','\x4b'},{'\x87','\x4c'},{'\x87','\x4d'},{'\x87','\x4e'},{'\x87','\x4f'},
+    {'\x87','\x50'},{'\x87','\x51'},{'\x87','\x52'},{'\x87','\x53'},{'\x87','\x54'},
+    {'\x87','\x55'},{'\x87','\x56'},{'\x87','\x57'},{'\x87','\x58'},{'\x87','\x59'},
+    {'\x87','\x5a'},{'\x87','\x5b'},{'\x87','\x5c'},{'\x87','\x5d'},{'\x87','\x5e'},
+    {'\x87','\x5f'},{'\x87','\x60'},{'\x87','\x61'},{'\x87','\x62'},{'\x87','\x63'},
+    {'\x87','\x64'},{'\x87','\x65'},{'\x87','\x66'},{'\x87','\x67'},{'\x87','\x68'},
+    {'\x87','\x69'},{'\x87','\x6a'},{'\x87','\x6b'},{'\x87','\x6c'},{'\x87','\x6d'},
+    {'\x87','\x6e'},{'\x87','\x6f'},{'\x87','\x70'},{'\x87','\x71'},{'\x87','\x72'},
+    {'\x87','\x73'},{'\x87','\x74'},{'\x87','\x75'},{'\x87','\x76'},{'\x87','\x77'},
+    {'\x87','\x78'},{'\x87','\x79'},{'\x87','\x7a'},{'\x87','\x7b'},{'\x87','\x7c'},
+    {'\x87','\x7d'},{'\x87','\x7e'},{'\x87','\xa1'},{'\x87','\xa2'},{'\x87','\xa3'},
+    {'\x87','\xa4'},{'\x87','\xa5'},{'\x87','\xa6'},{'\x87','\xa7'},{'\x87','\xa8'},
+    {'\x87','\xa9'},{'\x87','\xaa'},{'\x87','\xab'},{'\x87','\xac'},{'\x87','\xad'},
+    {'\x87','\xae'},{'\x87','\xaf'},{'\x87','\xb0'},{'\x87','\xb1'},{'\x87','\xb2'},
+    {'\x87','\xb3'},{'\x87','\xb4'},{'\x87','\xb5'},{'\x87','\xb6'},{'\x87','\xb7'},
+    {'\x87','\xb8'},{'\x87','\xb9'},{'\x87','\xba'},{'\x87','\xbb'},{'\x87','\xbc'},
+    {'\x87','\xbd'},{'\x87','\xbe'},{'\x87','\xbf'},{'\x87','\xc0'},{'\x87','\xc1'},
+    {'\x87','\xc2'},{'\x87','\xc3'},{'\x87','\xc4'},{'\x87','\xc5'},{'\x87','\xc6'},
+    {'\x87','\xc7'},{'\x87','\xc8'},{'\x87','\xc9'},{'\x87','\xca'},{'\x87','\xcb'},
+    {'\x87','\xcc'},{'\x87','\xcd'},{'\x87','\xce'},{'\x87','\xcf'},{'\x87','\xd0'},
+    {'\x87','\xd1'},{'\x87','\xd2'},{'\x87','\xd3'},{'\x87','\xd4'},{'\x87','\xd5'},
+    {'\x87','\xd6'},{'\x87','\xd7'},{'\x87','\xd8'},{'\x87','\xd9'},{'\x87','\xda'},
+    {'\x87','\xdb'},{'\x87','\xdc'},{'\x87','\xdd'},{'\x87','\xde'},{'\x87','\xdf'},
+    {'\x87','\xe0'},{'\x87','\xe1'},{'\x87','\xe2'},{'\x87','\xe3'},{'\x87','\xe4'},
+    {'\x87','\xe5'},{'\x87','\xe6'},{'\x87','\xe7'},{'\x87','\xe8'},{'\x87','\xe9'},
+    {'\x87','\xea'},{'\x87','\xeb'},{'\x87','\xec'},{'\x87','\xed'},{'\x87','\xee'},
+    {'\x87','\xef'},{'\x87','\xf0'},{'\x87','\xf1'},{'\x87','\xf2'},{'\x87','\xf3'},
+    {'\x87','\xf4'},{'\x87','\xf5'},{'\x87','\xf6'},{'\x87','\xf7'},{'\x87','\xf8'},
+    {'\x87','\xf9'},{'\x87','\xfa'},{'\x87','\xfb'},{'\x87','\xfc'},{'\x87','\xfd'},
+    {'\x87','\xfe'},{'\x88','\x40'},{'\x88','\x41'},{'\x88','\x42'},{'\x88','\x43'},
+    {'\x88','\x44'},{'\x88','\x45'},{'\x88','\x46'},{'\x88','\x47'},{'\x88','\x48'},
+    {'\x88','\x49'},{'\x88','\x4a'},{'\x88','\x4b'},{'\x88','\x4c'},{'\x88','\x4d'},
+    {'\x88','\x4e'},{'\x88','\x4f'},{'\x88','\x50'},{'\x88','\x51'},{'\x88','\x52'},
+    {'\x88','\x53'},{'\x88','\x54'},{'\x88','\x55'},{'\x88','\x56'},{'\x88','\x57'},
+    {'\x88','\x58'},{'\x88','\x59'},{'\x88','\x5a'},{'\x88','\x5b'},{'\x88','\x5c'},
+    {'\x88','\x5d'},{'\x88','\x5e'},{'\x88','\x5f'},{'\x88','\x60'},{'\x88','\x61'},
+    {'\x88','\x62'},{'\x88','\x63'},{'\x88','\x64'},{'\x88','\x65'},{'\x88','\x66'},
+    {'\x88','\x67'},{'\x88','\x68'},{'\x88','\x69'},{'\x88','\x6a'},{'\x88','\x6b'},
+    {'\x88','\x6c'},{'\x88','\x6d'},{'\x88','\x6e'},{'\x88','\x6f'},{'\x88','\x70'},
+    {'\x88','\x71'},{'\x88','\x72'},{'\x88','\x73'},{'\x88','\x74'},{'\x88','\x75'},
+    {'\x88','\x76'},{'\x88','\x77'},{'\x88','\x78'},{'\x88','\x79'},{'\x88','\x7a'},
+    {'\x88','\x7b'},{'\x88','\x7c'},{'\x88','\x7d'},{'\x88','\x7e'},{'\x88','\xa1'},
+    {'\x88','\xa2'},{'\x88','\xa3'},{'\x88','\xa4'},{'\x88','\xa5'},{'\x88','\xa6'},
+    {'\x88','\xa7'},{'\x88','\xa8'},{'\x88','\xa9'},{'\x88','\xaa'},{'\x88','\xab'},
+    {'\x88','\xac'},{'\x88','\xad'},{'\x88','\xae'},{'\x88','\xaf'},{'\x88','\xb0'},
+    {'\x88','\xb1'},{'\x88','\xb2'},{'\x88','\xb3'},{'\x88','\xb4'},{'\x88','\xb5'},
+    {'\x88','\xb6'},{'\x88','\xb7'},{'\x88','\xb8'},{'\x88','\xb9'},{'\x88','\xba'},
+    {'\x88','\xbb'},{'\x88','\xbc'},{'\x88','\xbd'},{'\x88','\xbe'},{'\x88','\xbf'},
+    {'\x88','\xc0'},{'\x88','\xc1'},{'\x88','\xc2'},{'\x88','\xc3'},{'\x88','\xc4'},
+    {'\x88','\xc5'},{'\x88','\xc6'},{'\x88','\xc7'},{'\x88','\xc8'},{'\x88','\xc9'},
+    {'\x88','\xca'},{'\x88','\xcb'},{'\x88','\xcc'},{'\x88','\xcd'},{'\x88','\xce'},
+    {'\x88','\xcf'},{'\x88','\xd0'},{'\x88','\xd1'},{'\x88','\xd2'},{'\x88','\xd3'},
+    {'\x88','\xd4'},{'\x88','\xd5'},{'\x88','\xd6'},{'\x88','\xd7'},{'\x88','\xd8'},
+    {'\x88','\xd9'},{'\x88','\xda'},{'\x88','\xdb'},{'\x88','\xdc'},{'\x88','\xdd'},
+    {'\x88','\xde'},{'\x88','\xdf'},{'\x88','\xe0'},{'\x88','\xe1'},{'\x88','\xe2'},
+    {'\x88','\xe3'},{'\x88','\xe4'},{'\x88','\xe5'},{'\x88','\xe6'},{'\x88','\xe7'},
+    {'\x88','\xe8'},{'\x88','\xe9'},{'\x88','\xea'},{'\x88','\xeb'},{'\x88','\xec'},
+    {'\x88','\xed'},{'\x88','\xee'},{'\x88','\xef'},{'\x88','\xf0'},{'\x88','\xf1'},
+    {'\x88','\xf2'},{'\x88','\xf3'},{'\x88','\xf4'},{'\x88','\xf5'},{'\x88','\xf6'},
+    {'\x88','\xf7'},{'\x88','\xf8'},{'\x88','\xf9'},{'\x88','\xfa'},{'\x88','\xfb'},
+    {'\x88','\xfc'},{'\x88','\xfd'},{'\x88','\xfe'},{'\x89','\x40'},{'\x89','\x41'},
+    {'\x89','\x42'},{'\x89','\x43'},{'\x89','\x44'},{'\x89','\x45'},{'\x89','\x46'},
+    {'\x89','\x47'},{'\x89','\x48'},{'\x89','\x49'},{'\x89','\x4a'},{'\x89','\x4b'},
+    {'\x89','\x4c'},{'\x89','\x4d'},{'\x89','\x4e'},{'\x89','\x4f'},{'\x89','\x50'},
+    {'\x89','\x51'},{'\x89','\x52'},{'\x89','\x53'},{'\x89','\x54'},{'\x89','\x55'},
+    {'\x89','\x56'},{'\x89','\x57'},{'\x89','\x58'},{'\x89','\x59'},{'\x89','\x5a'},
+    {'\x89','\x5b'},{'\x89','\x5c'},{'\x89','\x5d'},{'\x89','\x5e'},{'\x89','\x5f'},
+    {'\x89','\x60'},{'\x89','\x61'},{'\x89','\x62'},{'\x89','\x63'},{'\x89','\x64'},
+    {'\x89','\x65'},{'\x89','\x66'},{'\x89','\x67'},{'\x89','\x68'},{'\x89','\x69'},
+    {'\x89','\x6a'},{'\x89','\x6b'},{'\x89','\x6c'},{'\x89','\x6d'},{'\x89','\x6e'},
+    {'\x89','\x6f'},{'\x89','\x70'},{'\x89','\x71'},{'\x89','\x72'},{'\x89','\x73'},
+    {'\x89','\x74'},{'\x89','\x75'},{'\x89','\x76'},{'\x89','\x77'},{'\x89','\x78'},
+    {'\x89','\x79'},{'\x89','\x7a'},{'\x89','\x7b'},{'\x89','\x7c'},{'\x89','\x7d'},
+    {'\x89','\x7e'},{'\x89','\xa1'},{'\x89','\xa2'},{'\x89','\xa3'},{'\x89','\xa4'},
+    {'\x89','\xa5'},{'\x89','\xa6'},{'\x89','\xa7'},{'\x89','\xa8'},{'\x89','\xa9'},
+    {'\x89','\xaa'},{'\x89','\xab'},{'\x89','\xac'},{'\x89','\xad'},{'\x89','\xae'},
+    {'\x89','\xaf'},{'\x89','\xb0'},{'\x89','\xb1'},{'\x89','\xb2'},{'\x89','\xb3'},
+    {'\x89','\xb4'},{'\x89','\xb5'},{'\x89','\xb6'},{'\x89','\xb7'},{'\x89','\xb8'},
+    {'\x89','\xb9'},{'\x89','\xba'},{'\x89','\xbb'},{'\x89','\xbc'},{'\x89','\xbd'},
+    {'\x89','\xbe'},{'\x89','\xbf'},{'\x89','\xc0'},{'\x89','\xc1'},{'\x89','\xc2'},
+    {'\x89','\xc3'},{'\x89','\xc4'},{'\x89','\xc5'},{'\x89','\xc6'},{'\x89','\xc7'},
+    {'\x89','\xc8'},{'\x89','\xc9'},{'\x89','\xca'},{'\x89','\xcb'},{'\x89','\xcc'},
+    {'\x89','\xcd'},{'\x89','\xce'},{'\x89','\xcf'},{'\x89','\xd0'},{'\x89','\xd1'},
+    {'\x89','\xd2'},{'\x89','\xd3'},{'\x89','\xd4'},{'\x89','\xd5'},{'\x89','\xd6'},
+    {'\x89','\xd7'},{'\x89','\xd8'},{'\x89','\xd9'},{'\x89','\xda'},{'\x89','\xdb'},
+    {'\x89','\xdc'},{'\x89','\xdd'},{'\x89','\xde'},{'\x89','\xdf'},{'\x89','\xe0'},
+    {'\x89','\xe1'},{'\x89','\xe2'},{'\x89','\xe3'},{'\x89','\xe4'},{'\x89','\xe5'},
+    {'\x89','\xe6'},{'\x89','\xe7'},{'\x89','\xe8'},{'\x89','\xe9'},{'\x89','\xea'},
+    {'\x89','\xeb'},{'\x89','\xec'},{'\x89','\xed'},{'\x89','\xee'},{'\x89','\xef'},
+    {'\x89','\xf0'},{'\x89','\xf1'},{'\x89','\xf2'},{'\x89','\xf3'},{'\x89','\xf4'},
+    {'\x89','\xf5'},{'\x89','\xf6'},{'\x89','\xf7'},{'\x89','\xf8'},{'\x89','\xf9'},
+    {'\x89','\xfa'},{'\x89','\xfb'},{'\x89','\xfc'},{'\x89','\xfd'},{'\x89','\xfe'},
+    {'\x8a','\x40'},{'\x8a','\x41'},{'\x8a','\x42'},{'\x8a','\x43'},{'\x8a','\x44'},
+    {'\x8a','\x45'},{'\x8a','\x46'},{'\x8a','\x47'},{'\x8a','\x48'},{'\x8a','\x49'},
+    {'\x8a','\x4a'},{'\x8a','\x4b'},{'\x8a','\x4c'},{'\x8a','\x4d'},{'\x8a','\x4e'},
+    {'\x8a','\x4f'},{'\x8a','\x50'},{'\x8a','\x51'},{'\x8a','\x52'},{'\x8a','\x53'},
+    {'\x8a','\x54'},{'\x8a','\x55'},{'\x8a','\x56'},{'\x8a','\x57'},{'\x8a','\x58'},
+    {'\x8a','\x59'},{'\x8a','\x5a'},{'\x8a','\x5b'},{'\x8a','\x5c'},{'\x8a','\x5d'},
+    {'\x8a','\x5e'},{'\x8a','\x5f'},{'\x8a','\x60'},{'\x8a','\x61'},{'\x8a','\x62'},
+    {'\x8a','\x63'},{'\x8a','\x64'},{'\x8a','\x65'},{'\x8a','\x66'},{'\x8a','\x67'},
+    {'\x8a','\x68'},{'\x8a','\x69'},{'\x8a','\x6a'},{'\x8a','\x6b'},{'\x8a','\x6c'},
+    {'\x8a','\x6d'},{'\x8a','\x6e'},{'\x8a','\x6f'},{'\x8a','\x70'},{'\x8a','\x71'},
+    {'\x8a','\x72'},{'\x8a','\x73'},{'\x8a','\x74'},{'\x8a','\x75'},{'\x8a','\x76'},
+    {'\x8a','\x77'},{'\x8a','\x78'},{'\x8a','\x79'},{'\x8a','\x7a'},{'\x8a','\x7b'},
+    {'\x8a','\x7c'},{'\x8a','\x7d'},{'\x8a','\x7e'},{'\x8a','\xa1'},{'\x8a','\xa2'},
+    {'\x8a','\xa3'},{'\x8a','\xa4'},{'\x8a','\xa5'},{'\x8a','\xa6'},{'\x8a','\xa7'},
+    {'\x8a','\xa8'},{'\x8a','\xa9'},{'\x8a','\xaa'},{'\x8a','\xab'},{'\x8a','\xac'},
+    {'\x8a','\xad'},{'\x8a','\xae'},{'\x8a','\xaf'},{'\x8a','\xb0'},{'\x8a','\xb1'},
+    {'\x8a','\xb2'},{'\x8a','\xb3'},{'\x8a','\xb4'},{'\x8a','\xb5'},{'\x8a','\xb6'},
+    {'\x8a','\xb7'},{'\x8a','\xb8'},{'\x8a','\xb9'},{'\x8a','\xba'},{'\x8a','\xbb'},
+    {'\x8a','\xbc'},{'\x8a','\xbd'},{'\x8a','\xbe'},{'\x8a','\xbf'},{'\x8a','\xc0'},
+    {'\x8a','\xc1'},{'\x8a','\xc2'},{'\x8a','\xc3'},{'\x8a','\xc4'},{'\x8a','\xc5'},
+    {'\x8a','\xc6'},{'\x8a','\xc7'},{'\x8a','\xc8'},{'\x8a','\xc9'},{'\x8a','\xca'},
+    {'\x8a','\xcb'},{'\x8a','\xcc'},{'\x8a','\xcd'},{'\x8a','\xce'},{'\x8a','\xcf'},
+    {'\x8a','\xd0'},{'\x8a','\xd1'},{'\x8a','\xd2'},{'\x8a','\xd3'},{'\x8a','\xd4'},
+    {'\x8a','\xd5'},{'\x8a','\xd6'},{'\x8a','\xd7'},{'\x8a','\xd8'},{'\x8a','\xd9'},
+    {'\x8a','\xda'},{'\x8a','\xdb'},{'\x8a','\xdc'},{'\x8a','\xdd'},{'\x8a','\xde'},
+    {'\x8a','\xdf'},{'\x8a','\xe0'},{'\x8a','\xe1'},{'\x8a','\xe2'},{'\x8a','\xe3'},
+    {'\x8a','\xe4'},{'\x8a','\xe5'},{'\x8a','\xe6'},{'\x8a','\xe7'},{'\x8a','\xe8'},
+    {'\x8a','\xe9'},{'\x8a','\xea'},{'\x8a','\xeb'},{'\x8a','\xec'},{'\x8a','\xed'},
+    {'\x8a','\xee'},{'\x8a','\xef'},{'\x8a','\xf0'},{'\x8a','\xf1'},{'\x8a','\xf2'},
+    {'\x8a','\xf3'},{'\x8a','\xf4'},{'\x8a','\xf5'},{'\x8a','\xf6'},{'\x8a','\xf7'},
+    {'\x8a','\xf8'},{'\x8a','\xf9'},{'\x8a','\xfa'},{'\x8a','\xfb'},{'\x8a','\xfc'},
+    {'\x8a','\xfd'},{'\x8a','\xfe'},{'\x8b','\x40'},{'\x8b','\x41'},{'\x8b','\x42'},
+    {'\x8b','\x43'},{'\x8b','\x44'},{'\x8b','\x45'},{'\x8b','\x46'},{'\x8b','\x47'},
+    {'\x8b','\x48'},{'\x8b','\x49'},{'\x8b','\x4a'},{'\x8b','\x4b'},{'\x8b','\x4c'},
+    {'\x8b','\x4d'},{'\x8b','\x4e'},{'\x8b','\x4f'},{'\x8b','\x50'},{'\x8b','\x51'},
+    {'\x8b','\x52'},{'\x8b','\x53'},{'\x8b','\x54'},{'\x8b','\x55'},{'\x8b','\x56'},
+    {'\x8b','\x57'},{'\x8b','\x58'},{'\x8b','\x59'},{'\x8b','\x5a'},{'\x8b','\x5b'},
+    {'\x8b','\x5c'},{'\x8b','\x5d'},{'\x8b','\x5e'},{'\x8b','\x5f'},{'\x8b','\x60'},
+    {'\x8b','\x61'},{'\x8b','\x62'},{'\x8b','\x63'},{'\x8b','\x64'},{'\x8b','\x65'},
+    {'\x8b','\x66'},{'\x8b','\x67'},{'\x8b','\x68'},{'\x8b','\x69'},{'\x8b','\x6a'},
+    {'\x8b','\x6b'},{'\x8b','\x6c'},{'\x8b','\x6d'},{'\x8b','\x6e'},{'\x8b','\x6f'},
+    {'\x8b','\x70'},{'\x8b','\x71'},{'\x8b','\x72'},{'\x8b','\x73'},{'\x8b','\x74'},
+    {'\x8b','\x75'},{'\x8b','\x76'},{'\x8b','\x77'},{'\x8b','\x78'},{'\x8b','\x79'},
+    {'\x8b','\x7a'},{'\x8b','\x7b'},{'\x8b','\x7c'},{'\x8b','\x7d'},{'\x8b','\x7e'},
+    {'\x8b','\xa1'},{'\x8b','\xa2'},{'\x8b','\xa3'},{'\x8b','\xa4'},{'\x8b','\xa5'},
+    {'\x8b','\xa6'},{'\x8b','\xa7'},{'\x8b','\xa8'},{'\x8b','\xa9'},{'\x8b','\xaa'},
+    {'\x8b','\xab'},{'\x8b','\xac'},{'\x8b','\xad'},{'\x8b','\xae'},{'\x8b','\xaf'},
+    {'\x8b','\xb0'},{'\x8b','\xb1'},{'\x8b','\xb2'},{'\x8b','\xb3'},{'\x8b','\xb4'},
+    {'\x8b','\xb5'},{'\x8b','\xb6'},{'\x8b','\xb7'},{'\x8b','\xb8'},{'\x8b','\xb9'},
+    {'\x8b','\xba'},{'\x8b','\xbb'},{'\x8b','\xbc'},{'\x8b','\xbd'},{'\x8b','\xbe'},
+    {'\x8b','\xbf'},{'\x8b','\xc0'},{'\x8b','\xc1'},{'\x8b','\xc2'},{'\x8b','\xc3'},
+    {'\x8b','\xc4'},{'\x8b','\xc5'},{'\x8b','\xc6'},{'\x8b','\xc7'},{'\x8b','\xc8'},
+    {'\x8b','\xc9'},{'\x8b','\xca'},{'\x8b','\xcb'},{'\x8b','\xcc'},{'\x8b','\xcd'},
+    {'\x8b','\xce'},{'\x8b','\xcf'},{'\x8b','\xd0'},{'\x8b','\xd1'},{'\x8b','\xd2'},
+    {'\x8b','\xd3'},{'\x8b','\xd4'},{'\x8b','\xd5'},{'\x8b','\xd6'},{'\x8b','\xd7'},
+    {'\x8b','\xd8'},{'\x8b','\xd9'},{'\x8b','\xda'},{'\x8b','\xdb'},{'\x8b','\xdc'},
+    {'\x8b','\xdd'},{'\x8b','\xde'},{'\x8b','\xdf'},{'\x8b','\xe0'},{'\x8b','\xe1'},
+    {'\x8b','\xe2'},{'\x8b','\xe3'},{'\x8b','\xe4'},{'\x8b','\xe5'},{'\x8b','\xe6'},
+    {'\x8b','\xe7'},{'\x8b','\xe8'},{'\x8b','\xe9'},{'\x8b','\xea'},{'\x8b','\xeb'},
+    {'\x8b','\xec'},{'\x8b','\xed'},{'\x8b','\xee'},{'\x8b','\xef'},{'\x8b','\xf0'},
+    {'\x8b','\xf1'},{'\x8b','\xf2'},{'\x8b','\xf3'},{'\x8b','\xf4'},{'\x8b','\xf5'},
+    {'\x8b','\xf6'},{'\x8b','\xf7'},{'\x8b','\xf8'},{'\x8b','\xf9'},{'\x8b','\xfa'},
+    {'\x8b','\xfb'},{'\x8b','\xfc'},{'\x8b','\xfd'},{'\x8b','\xfe'},{'\x8c','\x40'},
+    {'\x8c','\x41'},{'\x8c','\x42'},{'\x8c','\x43'},{'\x8c','\x44'},{'\x8c','\x45'},
+    {'\x8c','\x46'},{'\x8c','\x47'},{'\x8c','\x48'},{'\x8c','\x49'},{'\x8c','\x4a'},
+    {'\x8c','\x4b'},{'\x8c','\x4c'},{'\x8c','\x4d'},{'\x8c','\x4e'},{'\x8c','\x4f'},
+    {'\x8c','\x50'},{'\x8c','\x51'},{'\x8c','\x52'},{'\x8c','\x53'},{'\x8c','\x54'},
+    {'\x8c','\x55'},{'\x8c','\x56'},{'\x8c','\x57'},{'\x8c','\x58'},{'\x8c','\x59'},
+    {'\x8c','\x5a'},{'\x8c','\x5b'},{'\x8c','\x5c'},{'\x8c','\x5d'},{'\x8c','\x5e'},
+    {'\x8c','\x5f'},{'\x8c','\x60'},{'\x8c','\x61'},{'\x8c','\x62'},{'\x8c','\x63'},
+    {'\x8c','\x64'},{'\x8c','\x65'},{'\x8c','\x66'},{'\x8c','\x67'},{'\x8c','\x68'},
+    {'\x8c','\x69'},{'\x8c','\x6a'},{'\x8c','\x6b'},{'\x8c','\x6c'},{'\x8c','\x6d'},
+    {'\x8c','\x6e'},{'\x8c','\x6f'},{'\x8c','\x70'},{'\x8c','\x71'},{'\x8c','\x72'},
+    {'\x8c','\x73'},{'\x8c','\x74'},{'\x8c','\x75'},{'\x8c','\x76'},{'\x8c','\x77'},
+    {'\x8c','\x78'},{'\x8c','\x79'},{'\x8c','\x7a'},{'\x8c','\x7b'},{'\x8c','\x7c'},
+    {'\x8c','\x7d'},{'\x8c','\x7e'},{'\x8c','\xa1'},{'\x8c','\xa2'},{'\x8c','\xa3'},
+    {'\x8c','\xa4'},{'\x8c','\xa5'},{'\x8c','\xa6'},{'\x8c','\xa7'},{'\x8c','\xa8'},
+    {'\x8c','\xa9'},{'\x8c','\xaa'},{'\x8c','\xab'},{'\x8c','\xac'},{'\x8c','\xad'},
+    {'\x8c','\xae'},{'\x8c','\xaf'},{'\x8c','\xb0'},{'\x8c','\xb1'},{'\x8c','\xb2'},
+    {'\x8c','\xb3'},{'\x8c','\xb4'},{'\x8c','\xb5'},{'\x8c','\xb6'},{'\x8c','\xb7'},
+    {'\x8c','\xb8'},{'\x8c','\xb9'},{'\x8c','\xba'},{'\x8c','\xbb'},{'\x8c','\xbc'},
+    {'\x8c','\xbd'},{'\x8c','\xbe'},{'\x8c','\xbf'},{'\x8c','\xc0'},{'\x8c','\xc1'},
+    {'\x8c','\xc2'},{'\x8c','\xc3'},{'\x8c','\xc4'},{'\x8c','\xc5'},{'\x8c','\xc6'},
+    {'\x8c','\xc7'},{'\x8c','\xc8'},{'\x8c','\xc9'},{'\x8c','\xca'},{'\x8c','\xcb'},
+    {'\x8c','\xcc'},{'\x8c','\xcd'},{'\x8c','\xce'},{'\x8c','\xcf'},{'\x8c','\xd0'},
+    {'\x8c','\xd1'},{'\x8c','\xd2'},{'\x8c','\xd3'},{'\x8c','\xd4'},{'\x8c','\xd5'},
+    {'\x8c','\xd6'},{'\x8c','\xd7'},{'\x8c','\xd8'},{'\x8c','\xd9'},{'\x8c','\xda'},
+    {'\x8c','\xdb'},{'\x8c','\xdc'},{'\x8c','\xdd'},{'\x8c','\xde'},{'\x8c','\xdf'},
+    {'\x8c','\xe0'},{'\x8c','\xe1'},{'\x8c','\xe2'},{'\x8c','\xe3'},{'\x8c','\xe4'},
+    {'\x8c','\xe5'},{'\x8c','\xe6'},{'\x8c','\xe7'},{'\x8c','\xe8'},{'\x8c','\xe9'},
+    {'\x8c','\xea'},{'\x8c','\xeb'},{'\x8c','\xec'},{'\x8c','\xed'},{'\x8c','\xee'},
+    {'\x8c','\xef'},{'\x8c','\xf0'},{'\x8c','\xf1'},{'\x8c','\xf2'},{'\x8c','\xf3'},
+    {'\x8c','\xf4'},{'\x8c','\xf5'},{'\x8c','\xf6'},{'\x8c','\xf7'},{'\x8c','\xf8'},
+    {'\x8c','\xf9'},{'\x8c','\xfa'},{'\x8c','\xfb'},{'\x8c','\xfc'},{'\x8c','\xfd'},
+    {'\x8c','\xfe'},{'\x8d','\x40'},{'\x8d','\x41'},{'\x8d','\x42'},{'\x8d','\x43'},
+    {'\x8d','\x44'},{'\x8d','\x45'},{'\x8d','\x46'},{'\x8d','\x47'},{'\x8d','\x48'},
+    {'\x8d','\x49'},{'\x8d','\x4a'},{'\x8d','\x4b'},{'\x8d','\x4c'},{'\x8d','\x4d'},
+    {'\x8d','\x4e'},{'\x8d','\x4f'},{'\x8d','\x50'},{'\x8d','\x51'},{'\x8d','\x52'},
+    {'\x8d','\x53'},{'\x8d','\x54'},{'\x8d','\x55'},{'\x8d','\x56'},{'\x8d','\x57'},
+    {'\x8d','\x58'},{'\x8d','\x59'},{'\x8d','\x5a'},{'\x8d','\x5b'},{'\x8d','\x5c'},
+    {'\x8d','\x5d'},{'\x8d','\x5e'},{'\x8d','\x5f'},{'\x8d','\x60'},{'\x8d','\x61'},
+    {'\x8d','\x62'},{'\x8d','\x63'},{'\x8d','\x64'},{'\x8d','\x65'},{'\x8d','\x66'},
+    {'\x8d','\x67'},{'\x8d','\x68'},{'\x8d','\x69'},{'\x8d','\x6a'},{'\x8d','\x6b'},
+    {'\x8d','\x6c'},{'\x8d','\x6d'},{'\x8d','\x6e'},{'\x8d','\x6f'},{'\x8d','\x70'},
+    {'\x8d','\x71'},{'\x8d','\x72'},{'\x8d','\x73'},{'\x8d','\x74'},{'\x8d','\x75'},
+    {'\x8d','\x76'},{'\x8d','\x77'},{'\x8d','\x78'},{'\x8d','\x79'},{'\x8d','\x7a'},
+    {'\x8d','\x7b'},{'\x8d','\x7c'},{'\x8d','\x7d'},{'\x8d','\x7e'},{'\x8d','\xa1'},
+    {'\x8d','\xa2'},{'\x8d','\xa3'},{'\x8d','\xa4'},{'\x8d','\xa5'},{'\x8d','\xa6'},
+    {'\x8d','\xa7'},{'\x8d','\xa8'},{'\x8d','\xa9'},{'\x8d','\xaa'},{'\x8d','\xab'},
+    {'\x8d','\xac'},{'\x8d','\xad'},{'\x8d','\xae'},{'\x8d','\xaf'},{'\x8d','\xb0'},
+    {'\x8d','\xb1'},{'\x8d','\xb2'},{'\x8d','\xb3'},{'\x8d','\xb4'},{'\x8d','\xb5'},
+    {'\x8d','\xb6'},{'\x8d','\xb7'},{'\x8d','\xb8'},{'\x8d','\xb9'},{'\x8d','\xba'},
+    {'\x8d','\xbb'},{'\x8d','\xbc'},{'\x8d','\xbd'},{'\x8d','\xbe'},{'\x8d','\xbf'},
+    {'\x8d','\xc0'},{'\x8d','\xc1'},{'\x8d','\xc2'},{'\x8d','\xc3'},{'\x8d','\xc4'},
+    {'\x8d','\xc5'},{'\x8d','\xc6'},{'\x8d','\xc7'},{'\x8d','\xc8'},{'\x8d','\xc9'},
+    {'\x8d','\xca'},{'\x8d','\xcb'},{'\x8d','\xcc'},{'\x8d','\xcd'},{'\x8d','\xce'},
+    {'\x8d','\xcf'},{'\x8d','\xd0'},{'\x8d','\xd1'},{'\x8d','\xd2'},{'\x8d','\xd3'},
+    {'\x8d','\xd4'},{'\x8d','\xd5'},{'\x8d','\xd6'},{'\x8d','\xd7'},{'\x8d','\xd8'},
+    {'\x8d','\xd9'},{'\x8d','\xda'},{'\x8d','\xdb'},{'\x8d','\xdc'},{'\x8d','\xdd'},
+    {'\x8d','\xde'},{'\x8d','\xdf'},{'\x8d','\xe0'},{'\x8d','\xe1'},{'\x8d','\xe2'},
+    {'\x8d','\xe3'},{'\x8d','\xe4'},{'\x8d','\xe5'},{'\x8d','\xe6'},{'\x8d','\xe7'},
+    {'\x8d','\xe8'},{'\x8d','\xe9'},{'\x8d','\xea'},{'\x8d','\xeb'},{'\x8d','\xec'},
+    {'\x8d','\xed'},{'\x8d','\xee'},{'\x8d','\xef'},{'\x8d','\xf0'},{'\x8d','\xf1'},
+    {'\x8d','\xf2'},{'\x8d','\xf3'},{'\x8d','\xf4'},{'\x8d','\xf5'},{'\x8d','\xf6'},
+    {'\x8d','\xf7'},{'\x8d','\xf8'},{'\x8d','\xf9'},{'\x8d','\xfa'},{'\x8d','\xfb'},
+    {'\x8d','\xfc'},{'\x8d','\xfd'},{'\x8d','\xfe'},{'\xc6','\xa1'},{'\xc6','\xa2'},
+    {'\xc6','\xa3'},{'\xc6','\xa4'},{'\xc6','\xa5'},{'\xc6','\xa6'},{'\xc6','\xa7'},
+    {'\xc6','\xa8'},{'\xc6','\xa9'},{'\xc6','\xaa'},{'\xc6','\xab'},{'\xc6','\xac'},
+    {'\xc6','\xad'},{'\xc6','\xae'},{'\xc6','\xaf'},{'\xc6','\xb0'},{'\xc6','\xb1'},
+    {'\xc6','\xb2'},{'\xc6','\xb3'},{'\xc6','\xb4'},{'\xc6','\xb5'},{'\xc6','\xb6'},
+    {'\xc6','\xb7'},{'\xc6','\xb8'},{'\xc6','\xb9'},{'\xc6','\xba'},{'\xc6','\xbb'},
+    {'\xc6','\xbc'},{'\xc6','\xbd'},{'\xc6','\xbe'},{'\xc6','\xbf'},{'\xc6','\xc0'},
+    {'\xc6','\xc1'},{'\xc6','\xc2'},{'\xc6','\xc3'},{'\xc6','\xc4'},{'\xc6','\xc5'},
+    {'\xc6','\xc6'},{'\xc6','\xc7'},{'\xc6','\xc8'},{'\xc6','\xc9'},{'\xc6','\xca'},
+    {'\xc6','\xcb'},{'\xc6','\xcc'},{'\xc6','\xcd'},{'\xc6','\xce'},{'\xc6','\xcf'},
+    {'\xc6','\xd0'},{'\xc6','\xd1'},{'\xc6','\xd2'},{'\xc6','\xd3'},{'\xc6','\xd4'},
+    {'\xc6','\xd5'},{'\xc6','\xd6'},{'\xc6','\xd7'},{'\xc6','\xd8'},{'\xc6','\xd9'},
+    {'\xc6','\xda'},{'\xc6','\xdb'},{'\xc6','\xdc'},{'\xc6','\xdd'},{'\xc6','\xde'},
+    {'\xc6','\xdf'},{'\xc6','\xe0'},{'\xc6','\xe1'},{'\xc6','\xe2'},{'\xc6','\xe3'},
+    {'\xc6','\xe4'},{'\xc6','\xe5'},{'\xc6','\xe6'},{'\xc6','\xe7'},{'\xc6','\xe8'},
+    {'\xc6','\xe9'},{'\xc6','\xea'},{'\xc6','\xeb'},{'\xc6','\xec'},{'\xc6','\xed'},
+    {'\xc6','\xee'},{'\xc6','\xef'},{'\xc6','\xf0'},{'\xc6','\xf1'},{'\xc6','\xf2'},
+    {'\xc6','\xf3'},{'\xc6','\xf4'},{'\xc6','\xf5'},{'\xc6','\xf6'},{'\xc6','\xf7'},
+    {'\xc6','\xf8'},{'\xc6','\xf9'},{'\xc6','\xfa'},{'\xc6','\xfb'},{'\xc6','\xfc'},
+    {'\xc6','\xfd'},{'\xc6','\xfe'},{'\xc7','\x40'},{'\xc7','\x41'},{'\xc7','\x42'},
+    {'\xc7','\x43'},{'\xc7','\x44'},{'\xc7','\x45'},{'\xc7','\x46'},{'\xc7','\x47'},
+    {'\xc7','\x48'},{'\xc7','\x49'},{'\xc7','\x4a'},{'\xc7','\x4b'},{'\xc7','\x4c'},
+    {'\xc7','\x4d'},{'\xc7','\x4e'},{'\xc7','\x4f'},{'\xc7','\x50'},{'\xc7','\x51'},
+    {'\xc7','\x52'},{'\xc7','\x53'},{'\xc7','\x54'},{'\xc7','\x55'},{'\xc7','\x56'},
+    {'\xc7','\x57'},{'\xc7','\x58'},{'\xc7','\x59'},{'\xc7','\x5a'},{'\xc7','\x5b'},
+    {'\xc7','\x5c'},{'\xc7','\x5d'},{'\xc7','\x5e'},{'\xc7','\x5f'},{'\xc7','\x60'},
+    {'\xc7','\x61'},{'\xc7','\x62'},{'\xc7','\x63'},{'\xc7','\x64'},{'\xc7','\x65'},
+    {'\xc7','\x66'},{'\xc7','\x67'},{'\xc7','\x68'},{'\xc7','\x69'},{'\xc7','\x6a'},
+    {'\xc7','\x6b'},{'\xc7','\x6c'},{'\xc7','\x6d'},{'\xc7','\x6e'},{'\xc7','\x6f'},
+    {'\xc7','\x70'},{'\xc7','\x71'},{'\xc7','\x72'},{'\xc7','\x73'},{'\xc7','\x74'},
+    {'\xc7','\x75'},{'\xc7','\x76'},{'\xc7','\x77'},{'\xc7','\x78'},{'\xc7','\x79'},
+    {'\xc7','\x7a'},{'\xc7','\x7b'},{'\xc7','\x7c'},{'\xc7','\x7d'},{'\xc7','\x7e'},
+    {'\xc7','\xa1'},{'\xc7','\xa2'},{'\xc7','\xa3'},{'\xc7','\xa4'},{'\xc7','\xa5'},
+    {'\xc7','\xa6'},{'\xc7','\xa7'},{'\xc7','\xa8'},{'\xc7','\xa9'},{'\xc7','\xaa'},
+    {'\xc7','\xab'},{'\xc7','\xac'},{'\xc7','\xad'},{'\xc7','\xae'},{'\xc7','\xaf'},
+    {'\xc7','\xb0'},{'\xc7','\xb1'},{'\xc7','\xb2'},{'\xc7','\xb3'},{'\xc7','\xb4'},
+    {'\xc7','\xb5'},{'\xc7','\xb6'},{'\xc7','\xb7'},{'\xc7','\xb8'},{'\xc7','\xb9'},
+    {'\xc7','\xba'},{'\xc7','\xbb'},{'\xc7','\xbc'},{'\xc7','\xbd'},{'\xc7','\xbe'},
+    {'\xc7','\xbf'},{'\xc7','\xc0'},{'\xc7','\xc1'},{'\xc7','\xc2'},{'\xc7','\xc3'},
+    {'\xc7','\xc4'},{'\xc7','\xc5'},{'\xc7','\xc6'},{'\xc7','\xc7'},{'\xc7','\xc8'},
+    {'\xc7','\xc9'},{'\xc7','\xca'},{'\xc7','\xcb'},{'\xc7','\xcc'},{'\xc7','\xcd'},
+    {'\xc7','\xce'},{'\xc7','\xcf'},{'\xc7','\xd0'},{'\xc7','\xd1'},{'\xc7','\xd2'},
+    {'\xc7','\xd3'},{'\xc7','\xd4'},{'\xc7','\xd5'},{'\xc7','\xd6'},{'\xc7','\xd7'},
+    {'\xc7','\xd8'},{'\xc7','\xd9'},{'\xc7','\xda'},{'\xc7','\xdb'},{'\xc7','\xdc'},
+    {'\xc7','\xdd'},{'\xc7','\xde'},{'\xc7','\xdf'},{'\xc7','\xe0'},{'\xc7','\xe1'},
+    {'\xc7','\xe2'},{'\xc7','\xe3'},{'\xc7','\xe4'},{'\xc7','\xe5'},{'\xc7','\xe6'},
+    {'\xc7','\xe7'},{'\xc7','\xe8'},{'\xc7','\xe9'},{'\xc7','\xea'},{'\xc7','\xeb'},
+    {'\xc7','\xec'},{'\xc7','\xed'},{'\xc7','\xee'},{'\xc7','\xef'},{'\xc7','\xf0'},
+    {'\xc7','\xf1'},{'\xc7','\xf2'},{'\xc7','\xf3'},{'\xc7','\xf4'},{'\xc7','\xf5'},
+    {'\xc7','\xf6'},{'\xc7','\xf7'},{'\xc7','\xf8'},{'\xc7','\xf9'},{'\xc7','\xfa'},
+    {'\xc7','\xfb'},{'\xc7','\xfc'},{'\xc7','\xfd'},{'\xc7','\xfe'},{'\xc8','\x40'},
+    {'\xc8','\x41'},{'\xc8','\x42'},{'\xc8','\x43'},{'\xc8','\x44'},{'\xc8','\x45'},
+    {'\xc8','\x46'},{'\xc8','\x47'},{'\xc8','\x48'},{'\xc8','\x49'},{'\xc8','\x4a'},
+    {'\xc8','\x4b'},{'\xc8','\x4c'},{'\xc8','\x4d'},{'\xc8','\x4e'},{'\xc8','\x4f'},
+    {'\xc8','\x50'},{'\xc8','\x51'},{'\xc8','\x52'},{'\xc8','\x53'},{'\xc8','\x54'},
+    {'\xc8','\x55'},{'\xc8','\x56'},{'\xc8','\x57'},{'\xc8','\x58'},{'\xc8','\x59'},
+    {'\xc8','\x5a'},{'\xc8','\x5b'},{'\xc8','\x5c'},{'\xc8','\x5d'},{'\xc8','\x5e'},
+    {'\xc8','\x5f'},{'\xc8','\x60'},{'\xc8','\x61'},{'\xc8','\x62'},{'\xc8','\x63'},
+    {'\xc8','\x64'},{'\xc8','\x65'},{'\xc8','\x66'},{'\xc8','\x67'},{'\xc8','\x68'},
+    {'\xc8','\x69'},{'\xc8','\x6a'},{'\xc8','\x6b'},{'\xc8','\x6c'},{'\xc8','\x6d'},
+    {'\xc8','\x6e'},{'\xc8','\x6f'},{'\xc8','\x70'},{'\xc8','\x71'},{'\xc8','\x72'},
+    {'\xc8','\x73'},{'\xc8','\x74'},{'\xc8','\x75'},{'\xc8','\x76'},{'\xc8','\x77'},
+    {'\xc8','\x78'},{'\xc8','\x79'},{'\xc8','\x7a'},{'\xc8','\x7b'},{'\xc8','\x7c'},
+    {'\xc8','\x7d'},{'\xc8','\x7e'},{'\xc8','\xa1'},{'\xc8','\xa2'},{'\xc8','\xa3'},
+    {'\xc8','\xa4'},{'\xc8','\xa5'},{'\xc8','\xa6'},{'\xc8','\xa7'},{'\xc8','\xa8'},
+    {'\xc8','\xa9'},{'\xc8','\xaa'},{'\xc8','\xab'},{'\xc8','\xac'},{'\xc8','\xad'},
+    {'\xc8','\xae'},{'\xc8','\xaf'},{'\xc8','\xb0'},{'\xc8','\xb1'},{'\xc8','\xb2'},
+    {'\xc8','\xb3'},{'\xc8','\xb4'},{'\xc8','\xb5'},{'\xc8','\xb6'},{'\xc8','\xb7'},
+    {'\xc8','\xb8'},{'\xc8','\xb9'},{'\xc8','\xba'},{'\xc8','\xbb'},{'\xc8','\xbc'},
+    {'\xc8','\xbd'},{'\xc8','\xbe'},{'\xc8','\xbf'},{'\xc8','\xc0'},{'\xc8','\xc1'},
+    {'\xc8','\xc2'},{'\xc8','\xc3'},{'\xc8','\xc4'},{'\xc8','\xc5'},{'\xc8','\xc6'},
+    {'\xc8','\xc7'},{'\xc8','\xc8'},{'\xc8','\xc9'},{'\xc8','\xca'},{'\xc8','\xcb'},
+    {'\xc8','\xcc'},{'\xc8','\xcd'},{'\xc8','\xce'},{'\xc8','\xcf'},{'\xc8','\xd0'},
+    {'\xc8','\xd1'},{'\xc8','\xd2'},{'\xc8','\xd3'},{'\xc8','\xd4'},{'\xc8','\xd5'},
+    {'\xc8','\xd6'},{'\xc8','\xd7'},{'\xc8','\xd8'},{'\xc8','\xd9'},{'\xc8','\xda'},
+    {'\xc8','\xdb'},{'\xc8','\xdc'},{'\xc8','\xdd'},{'\xc8','\xde'},{'\xc8','\xdf'},
+    {'\xc8','\xe0'},{'\xc8','\xe1'},{'\xc8','\xe2'},{'\xc8','\xe3'},{'\xc8','\xe4'},
+    {'\xc8','\xe5'},{'\xc8','\xe6'},{'\xc8','\xe7'},{'\xc8','\xe8'},{'\xc8','\xe9'},
+    {'\xc8','\xea'},{'\xc8','\xeb'},{'\xc8','\xec'},{'\xc8','\xed'},{'\xc8','\xee'},
+    {'\xc8','\xef'},{'\xc8','\xf0'},{'\xc8','\xf1'},{'\xc8','\xf2'},{'\xc8','\xf3'},
+    {'\xc8','\xf4'},{'\xc8','\xf5'},{'\xc8','\xf6'},{'\xc8','\xf7'},{'\xc8','\xf8'},
+    {'\xc8','\xf9'},{'\xc8','\xfa'},{'\xc8','\xfb'},{'\xc8','\xfc'},{'\xc8','\xfd'},
+    {'\xc8','\xfe'},{'\xa3','\xe2'},{'\xa3','\xe3'},{'\xa3','\xe4'},{'\xa3','\xe5'},
+    {'\xa3','\xe6'},{'\xa3','\xe7'},{'\xa3','\xe8'},{'\xa3','\xe9'},{'\xa3','\xea'},
+    {'\xa3','\xeb'},{'\xa3','\xec'},{'\xa3','\xed'},{'\xa3','\xee'},{'\xa3','\xef'},
+    {'\xa3','\xf0'},{'\xa3','\xf1'},{'\xa3','\xf2'},{'\xa3','\xf3'},{'\xa3','\xf4'},
+    {'\xa3','\xf5'},{'\xa3','\xf6'},{'\xa3','\xf7'},{'\xa3','\xf8'},{'\xa3','\xf9'},
+    {'\xa3','\xfa'},{'\xa3','\xfb'},{'\xa3','\xfc'},{'\xa3','\xfd'},{'\xa3','\xfe'},
+    {'\xc6','\xde'},{'\xc6','\xdf'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\xff'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xb0','\x5a'},
+    {'\xa7','\xf3'},{'\xa8','\xae'},{'\xb8','\xeb'},{'\xb7','\xc6'},{'\xa6','\xea'},
+    {'\xa5','\x79'},{'\xc0','\x74'},{'\xc0','\x74'},{'\xab','\xb4'},{'\xaa','\xf7'},
+    {'\xb3','\xe2'},{'\xa9','\x60'},{'\xc3','\x69'},{'\xc4','\xee'},{'\xc3','\xb9'},
+    {'\xc5','\xda'},{'\xc1','\xb3'},{'\xbb','\x72'},{'\xc5','\xde'},{'\xbc','\xd6'},
+    {'\xac','\xa5'},{'\xaf','\x4f'},{'\xaf','\x5f'},{'\xb8','\xa8'},{'\xb9','\x54'},
+    {'\xc0','\x64'},{'\xb6','\xc3'},{'\xa7','\x5a'},{'\xc4','\xe6'},{'\xc4','\xea'},
+    {'\xc4','\xf5'},{'\xc6','\x7d'},{'\xb4','\x50'},{'\xc0','\xdd'},{'\xc2','\xc5'},
+    {'\xc4','\xb0'},{'\xa9','\xd4'},{'\xc3','\xbe'},{'\xc4','\xfa'},{'\xb4','\x59'},
+    {'\xae','\xd4'},{'\xae','\xf6'},{'\xaf','\x54'},{'\xad','\xa6'},{'\xa8','\xd3'},
+    {'\xa7','\x4e'},{'\xb3','\xd2'},{'\xbe','\xdb'},{'\xc3','\x72'},{'\xc4','\x6c'},
+    {'\xbf','\x63'},{'\xa6','\xd1'},{'\xc4','\xaa'},{'\xb8','\xb8'},{'\xb8','\xf4'},
+    {'\xc5','\x53'},{'\xbe','\x7c'},{'\xc6','\x4f'},{'\xb8','\x4c'},{'\xb8','\x53'},
+    {'\xba','\xf1'},{'\xdb','\x77'},{'\xbf','\xfd'},{'\xb3','\xc0'},{'\xbd','\xd7'},
+    {'\xc3','\x62'},{'\xa7','\xcb'},{'\xc5','\xa2'},{'\xc5','\xa4'},{'\xa8','\x63'},
+    {'\xbd','\x55'},{'\xb8','\xef'},{'\xb9','\x70'},{'\xc2','\x53'},{'\xb9','\xf0'},
+    {'\xbc','\xd3'},{'\xb2','\x5c'},{'\xba','\x7c'},{'\xb2','\xd6'},{'\xc1','\x5c'},
+    {'\xad','\xae'},{'\xb0','\xc7'},{'\xa6','\xd8'},{'\xbb','\xfe'},{'\xad','\xe2'},
+    {'\xb8','\x57'},{'\xba','\xf0'},{'\xb5','\xd9'},{'\xb3','\xae'},{'\xc5','\xaa'},
+    {'\xce','\xd4'},{'\xbc','\xd6'},{'\xbf','\xd5'},{'\xa4','\xa6'},{'\xb9','\xe7'},
+    {'\xab','\xe3'},{'\xb2','\x76'},{'\xb2','\xa7'},{'\xa5','\x5f'},{'\xed','\xa8'},
+    {'\xab','\x4b'},{'\xb4','\x5f'},{'\xa4','\xa3'},{'\xaa','\x63'},{'\xbc','\xc6'},
+    {'\xaf','\xc1'},{'\xb0','\xd1'},{'\xb6','\xeb'},{'\xac','\xd9'},{'\xb8','\xad'},
+    {'\xbb','\xa1'},{'\xb1','\xfe'},{'\xa8','\xb0'},{'\xa8','\x48'},{'\xac','\x42'},
+    {'\xad','\x59'},{'\xb1','\xb0'},{'\xb2','\xa4'},{'\xab','\x47'},{'\xa8','\xe2'},
+    {'\x84','\x5b'},{'\xb1','\xe7'},{'\xc2','\xb3'},{'\xa8','\x7d'},{'\xbd','\xcc'},
+    {'\xb6','\x71'},{'\xc0','\x79'},{'\xa7','\x66'},{'\xa4','\x6b'},{'\xc3','\x66'},
+    {'\xae','\xc8'},{'\xc2','\x6f'},{'\xc4','\x72'},{'\xbe','\x5b'},{'\xc6','\x7a'},
+    {'\xc4','\x52'},{'\xbe','\xa4'},{'\xa4','\x4f'},{'\xbe','\xe4'},{'\xbe','\xfa'},
+    {'\xf7','\x65'},{'\xa6','\x7e'},{'\xbc','\xa6'},{'\xc5','\xca'},{'\xbc','\xbf'},
+    {'\xba','\xa7'},{'\xb7','\xd2'},{'\xe6','\xa3'},{'\x9d','\xce'},{'\xbd','\x6d'},
+    {'\xc1','\x70'},{'\xbd','\xfb'},{'\xbd','\xac'},{'\xb3','\x73'},{'\xc1','\xe5'},
+    {'\xa6','\x43'},{'\xa6','\x48'},{'\xab','\x7c'},{'\xaf','\x50'},{'\xb5','\xf5'},
+    {'\xbb','\xa1'},{'\xb7','\x47'},{'\xa9','\xc0'},{'\xb1','\xc9'},{'\xc0','\xd4'},
+    {'\xc3','\xae'},{'\xc2','\x79'},{'\xa5','\x4f'},{'\xcb','\xf1'},{'\xb9','\xe7'},
+    {'\xc0','\xad'},{'\xcc','\xb0'},{'\xac','\xc2'},{'\xbc','\xfc'},{'\xb2','\xdc'},
+    {'\xb2','\xe2'},{'\xb9','\x61'},{'\xb9','\x73'},{'\xc6','\x46'},{'\xbb','\xe2'},
+    {'\xa8','\xd2'},{'\xc2','\xa7'},{'\xc4','\xbf'},{'\xc1','\xf5'},{'\xb4','\x63'},
+    {'\xa4','\x46'},{'\xb9','\xb1'},{'\xbc','\x64'},{'\xa7','\xbf'},{'\xae','\xc6'},
+    {'\xbc','\xd6'},{'\xbf','\x52'},{'\xc0','\xf8'},{'\xe7','\x64'},{'\xbf','\xf1'},
+    {'\xc0','\x73'},{'\xb7','\x77'},{'\xa8','\xbf'},{'\xbc','\x42'},{'\xcc','\xd8'},
+    {'\xac','\x68'},{'\xac','\x79'},{'\xb7','\xc8'},{'\xaf','\x5b'},{'\xaf','\x64'},
+    {'\xb2','\xb8'},{'\xaf','\xc3'},{'\xc3','\xfe'},{'\xa4','\xbb'},{'\xbc','\xae'},
+    {'\xb3','\xb0'},{'\xad','\xdb'},{'\xb1','\x5b'},{'\xb2','\x5f'},{'\xbd','\xfc'},
+    {'\xab','\xdf'},{'\xb7','\x58'},{'\xae','\xdf'},{'\xb2','\x76'},{'\xb6','\xa9'},
+    {'\xa7','\x51'},{'\xa6','\x4f'},{'\xbc','\x69'},{'\xa9','\xf6'},{'\xa7','\xf5'},
+    {'\xb1','\xf9'},{'\xaa','\x64'},{'\xb2','\x7a'},{'\xb5','\x67'},{'\xbf','\xa9'},
+    {'\xf9','\xd8'},{'\xb8','\xcc'},{'\xa8','\xbd'},{'\xc2','\xf7'},{'\xb0','\xce'},
+    {'\xb7','\xc4'},{'\xa7','\x5b'},{'\xbf','\x4d'},{'\xbf','\x5a'},{'\xc4','\xa9'},
+    {'\x95','\xf9'},{'\xc5','\xec'},{'\xc5','\xef'},{'\xaa','\x4c'},{'\xb2','\x4f'},
+    {'\xc1','\x7b'},{'\xa5','\xdf'},{'\xb2','\xc1'},{'\xb2','\xc9'},{'\xaa','\xac'},
+    {'\xaa','\xa5'},{'\xc3','\xd1'},{'\xa4','\xb0'},{'\xaf','\xf9'},{'\xa8','\xeb'},
+    {'\xa4','\xc1'},{'\xab','\xd7'},{'\xa9','\xdd'},{'\xbf','\x7d'},{'\xa6','\x76'},
+    {'\xac','\x7d'},{'\xbc','\xc9'},{'\xbf','\xe7'},{'\xa6','\xe6'},{'\xad','\xb0'},
+    {'\xa8','\xa3'},{'\xb9','\xf8'},{'\xc9','\x4a'},{'\xdd','\xfc'},{'\x98','\x77'},
+    {'\x98','\x78'},{'\xb6','\xef'},{'\x98','\x79'},{'\xb4','\xb8'},{'\x98','\x7a'},
+    {'\x98','\x7b'},{'\xe8','\xf9'},{'\x95','\xbd'},{'\xaf','\x71'},{'\x98','\x7c'},
+    {'\xaf','\xab'},{'\xb2','\xbb'},{'\xba','\xd6'},{'\xb9','\x74'},{'\xba','\xeb'},
+    {'\xa6','\xd0'},{'\x98','\x7d'},{'\x98','\x7e'},{'\x98','\xa1'},{'\xbd','\xd1'},
+    {'\x98','\xa2'},{'\x98','\xa3'},{'\xb6','\x68'},{'\xb3','\xa3'},{'\x98','\xa4'},
+    {'\x98','\xa5'},{'\x98','\xa6'},{'\xb6','\xba'},{'\xb9','\x7d'},{'\xc0','\x5d'},
+    {'\xc5','\x62'},{'\x00','\x00'},{'\x00','\x00'},{'\xab','\x56'},{'\xb9','\xac'},
+    {'\xa7','\x4b'},{'\xab','\x6a'},{'\xb6','\xd4'},{'\xa8','\xf5'},{'\xb3','\xdc'},
+    {'\xb9','\xc4'},{'\xbe','\xb9'},{'\x94','\x59'},{'\xbe','\xa5'},{'\xbc','\x68'},
+    {'\xc9','\x4b'},{'\xae','\xac'},{'\xb4','\x6e'},{'\xbc','\xa8'},{'\xc3','\x67'},
+    {'\xb1','\xd3'},{'\xac','\x4a'},{'\xb4','\xbb'},{'\xb1','\xf6'},{'\xae','\xfc'},
+    {'\xb2','\x5a'},{'\xba','\x7e'},{'\xb5','\x4e'},{'\x9c','\x70'},{'\xb5','\x5a'},
+    {'\xb8','\x4f'},{'\xaa','\xc0'},{'\xac','\xe7'},{'\xac','\xe8'},{'\xaf','\xa7'},
+    {'\xaf','\xaa'},{'\xaf','\xac'},{'\xba','\xd7'},{'\xba','\xd5'},{'\xbd','\x5c'},
+    {'\xac','\xf0'},{'\xb8','\x60'},{'\xbd','\x6d'},{'\xbf','\xa7'},{'\xc1','\x63'},
+    {'\xb8','\x70'},{'\xaa','\xcc'},{'\xaf','\xe4'},{'\x9c','\xd2'},{'\x9c','\xd2'},
+    {'\xb5','\xdb'},{'\xbd','\xc5'},{'\xb5','\xf8'},{'\xbf','\xd6'},{'\xc2','\xd4'},
+    {'\xbb','\xab'},{'\xc3','\xd8'},{'\x9c','\xe0'},{'\xb6','\x68'},{'\xc3','\xf8'},
+    {'\xc5','\x54'},{'\xc0','\x57'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\x4a'},{'\xa1','\x57'},{'\x00','\x00'},
+    {'\xa1','\x59'},{'\xa1','\x5b'},{'\xa1','\x5f'},{'\xa1','\x60'},{'\xa1','\x63'},
+    {'\xa1','\x64'},{'\xa1','\x67'},{'\xa1','\x68'},{'\xa1','\x6b'},{'\xa1','\x6c'},
+    {'\xa1','\x6f'},{'\xa1','\x70'},{'\xa1','\x73'},{'\xa1','\x74'},{'\xa1','\x77'},
+    {'\xa1','\x78'},{'\xa1','\x7b'},{'\xa1','\x7c'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa1','\xc6'},{'\xa1','\xc7'},{'\xa1','\xca'},
+    {'\xa1','\xcb'},{'\xa1','\xc8'},{'\xa1','\xc9'},{'\xa1','\x5c'},{'\xa1','\x4d'},
+    {'\xa1','\x4e'},{'\xa1','\x4f'},{'\x00','\x00'},{'\xa1','\x51'},{'\xa1','\x52'},
+    {'\xa1','\x53'},{'\xa1','\x54'},{'\x00','\x00'},{'\xa1','\x7d'},{'\xa1','\x7e'},
+    {'\xa1','\xa1'},{'\xa1','\xa2'},{'\xa1','\xa3'},{'\xa1','\xa4'},{'\xa1','\xcc'},
+    {'\xa1','\xcd'},{'\xa1','\xce'},{'\xa1','\xde'},{'\xa1','\xdf'},{'\xa1','\xe0'},
+    {'\xa1','\xe1'},{'\xa1','\xe2'},{'\x00','\x00'},{'\xa2','\x42'},{'\xa2','\x4c'},
+    {'\xa2','\x4d'},{'\xa2','\x4e'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\xa1','\x49'},{'\xc8','\xd0'},{'\xa1','\xad'},{'\xa2','\x43'},
+    {'\xa2','\x48'},{'\xa1','\xae'},{'\x91','\xc2'},{'\xa1','\x5d'},{'\xa1','\x5e'},
+    {'\xa1','\xaf'},{'\xa1','\xcf'},{'\xa1','\x41'},{'\xa1','\xd0'},{'\xa1','\x44'},
+    {'\xa1','\xfe'},{'\xa2','\xaf'},{'\xa2','\xb0'},{'\xa2','\xb1'},{'\xa2','\xb2'},
+    {'\xa2','\xb3'},{'\xa2','\xb4'},{'\xa2','\xb5'},{'\xa2','\xb6'},{'\xa2','\xb7'},
+    {'\xa2','\xb8'},{'\xa1','\x47'},{'\xa1','\x46'},{'\xa1','\xd5'},{'\xa1','\xd7'},
+    {'\xa1','\xd6'},{'\xa1','\x48'},{'\xa2','\x49'},{'\xa2','\xcf'},{'\xa2','\xd0'},
+    {'\xa2','\xd1'},{'\xa2','\xd2'},{'\xa2','\xd3'},{'\xa2','\xd4'},{'\xa2','\xd5'},
+    {'\xa2','\xd6'},{'\xa2','\xd7'},{'\xa2','\xd8'},{'\xa2','\xd9'},{'\xa2','\xda'},
+    {'\xa2','\xdb'},{'\xa2','\xdc'},{'\xa2','\xdd'},{'\xa2','\xde'},{'\xa2','\xdf'},
+    {'\xa2','\xe0'},{'\xa2','\xe1'},{'\xa2','\xe2'},{'\xa2','\xe3'},{'\xa2','\xe4'},
+    {'\xa2','\xe5'},{'\xa2','\xe6'},{'\xa2','\xe7'},{'\xa2','\xe8'},{'\xc6','\xe4'},
+    {'\xa2','\x40'},{'\xc6','\xe5'},{'\x5e','\x20'},{'\xa1','\xc4'},{'\xa1','\xab'},
+    {'\xa2','\xe9'},{'\xa2','\xea'},{'\xa2','\xeb'},{'\xa2','\xec'},{'\xa2','\xed'},
+    {'\xa2','\xee'},{'\xa2','\xef'},{'\xa2','\xf0'},{'\xa2','\xf1'},{'\xa2','\xf2'},
+    {'\xa2','\xf3'},{'\xa2','\xf4'},{'\xa2','\xf5'},{'\xa2','\xf6'},{'\xa2','\xf7'},
+    {'\xa2','\xf8'},{'\xa2','\xf9'},{'\xa2','\xfa'},{'\xa2','\xfb'},{'\xa2','\xfc'},
+    {'\xa2','\xfd'},{'\xa2','\xfe'},{'\xa3','\x40'},{'\xa3','\x41'},{'\xa3','\x42'},
+    {'\xa3','\x43'},{'\xa1','\x61'},{'\xa1','\x55'},{'\xa1','\x62'},{'\xa1','\xe3'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xc8','\xb9'},{'\xc8','\xba'},{'\xc8','\xbb'},
+    {'\xc8','\xbc'},{'\xc8','\xbd'},{'\xc8','\xbe'},{'\xc8','\xbf'},{'\xc8','\xc0'},
+    {'\xc8','\xc1'},{'\xc8','\xc2'},{'\xc8','\xc3'},{'\xc8','\xc4'},{'\xc8','\xc5'},
+    {'\xc8','\xc6'},{'\xc8','\xc7'},{'\xc8','\xc8'},{'\xc8','\xc9'},{'\xc8','\xca'},
+    {'\xc8','\xcb'},{'\xc8','\xcc'},{'\xc8','\xd4'},{'\xc8','\xd5'},{'\xc8','\xd6'},
+    {'\xc8','\xd7'},{'\xc8','\xd8'},{'\xc8','\xd9'},{'\xc8','\xda'},{'\xc8','\xdb'},
+    {'\xc8','\xdc'},{'\xc8','\xdd'},{'\xc8','\xde'},{'\xc8','\xdf'},{'\xc8','\xe0'},
+    {'\xc8','\xe1'},{'\xc8','\xe2'},{'\xc8','\xe3'},{'\xc8','\xe4'},{'\xc8','\xe5'},
+    {'\xc8','\xe6'},{'\xc8','\xe7'},{'\xc8','\xe8'},{'\xc8','\xe9'},{'\xc8','\xea'},
+    {'\xc8','\xeb'},{'\xc8','\xec'},{'\xc8','\xed'},{'\xc8','\xee'},{'\xc8','\xef'},
+    {'\xc8','\xf0'},{'\xc8','\xf1'},{'\xc8','\xf2'},{'\xc8','\xf3'},{'\xc8','\xf4'},
+    {'\xc8','\xf5'},{'\xc8','\xf6'},{'\xc8','\xf7'},{'\xc8','\xf8'},{'\xc8','\xf9'},
+    {'\xc8','\xfa'},{'\xc8','\xfb'},{'\xc8','\xfc'},{'\xc8','\xfd'},{'\xc8','\xfe'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x46'},
+    {'\xa2','\x47'},{'\xc8','\xcd'},{'\xa1','\xc3'},{'\xc8','\xce'},{'\xa2','\x44'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\xa2','\x78'},{'\xa1','\xf6'},{'\xa1','\xf4'},
+    {'\xa1','\xf7'},{'\xa1','\xf5'},{'\xa1','\xbd'},{'\xa1','\xb3'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},{'\x00','\x00'},
+    {'\x00','\x00'}
+};
+
+static int qt_Big5ToUnicode(const uchar *s, uint *pwc)
+{
+    uchar c1 = s[0];
+    int idx;
+    ushort wc = 0xfffd;
+
+    if ((c1 >= 0x81 && c1 <= 0xfe)) {
+        uchar c2 = s[1];
+
+        if (c2 < 0x40 || c2 > 0xfe 
+                || (idx = ((c1 - 0x81) * 191) + (c2 - 0x40),
+                    (wc = big5_to_ucs[idx]) == 0))
+            return 0;
+        else {
+            *pwc = (uint) wc;
+            return 2;
+        }
+
+    } else if (c1 < 0x80) {
+        *pwc = (uint) c1;
+        return 1;
+    }
+    return 0;
+}
+
+static int qt_UnicodeToBig5(uint wc, uchar *r)
+{
+    const Summary16 *summary = NULL;
+    const uchar * c;
+    if (wc < 0x80) {
+        r[0] = (uchar) wc;
+        return 1;
+    }
+    else {
+        if (wc >= 0 && wc <= 65535){
+            c = ucs_to_big5[wc];
+            if (c [0] == '\0')
+                return 0;
+            if (c [1] != 0) {
+                r[0] = c[0];
+                r[1] = c[1];
+                return 2;
+            } else {  // (c [1] == 0)
+                r[0] = c[0];
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+QString UAOCodec::convertToUnicode(const char* chars, int len, ConverterState *state) const
+{
+    QChar replacement = QChar::ReplacementCharacter;
+    uchar buf[2] = {0};
+    int nbuf = 0;
+    if (state) {
+        if (state->flags & ConvertInvalidToNull)
+            replacement = QChar::Null;
+        nbuf = state->remainingChars;
+        buf[0] = state->state_data[0];
+        buf[1] = state->state_data[1];
+    }
+    int invalid = 0;
+
+    //qDebug("UAOCodec::toUnicode(const char* chars = \"%s\", int len = %d)", chars, len);
+    QString result;
+    for (int i=0; i<len; i++) {
+        uchar ch = chars[i];
+        switch (nbuf) {
+        case 0:
+            if (IsLatin(ch)) {
+                // ASCII
+                result += QLatin1Char(ch);
+            } else if (IsFirstByte(ch)) {
+                // Big5-ETen
+                buf[0] = ch;
+                nbuf = 1;
+            } else {
+                // Invalid
+                result += replacement;
+                ++invalid;
+            }
+            break;
+        case 1:
+            if (IsSecondByte(ch)) {
+                // Big5-ETen
+                uint u;
+                buf[1] = ch;
+                if (qt_Big5ToUnicode(buf, &u) == 2)
+                    result += QValidChar(u);
+                else {
+                    // Error
+                    result += replacement;
+                    ++invalid;
+                }
+            } else {
+                // Error
+                result += replacement;
+                ++invalid;
+            }
+            nbuf = 0;
+            break;
+        }
+    }
+    if (state) {
+        state->remainingChars = nbuf;
+        state->state_data[0] = buf[0];
+        state->state_data[1] = buf[1];
+        state->invalidChars += invalid;
+    }
+    return result;
+}
+
+QByteArray UAOCodec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
+{
+    char replacement = '?';
+    if (state) {
+        if (state->flags & ConvertInvalidToNull)
+            replacement = 0;
+    }
+
+    int invalid = 0;
+
+    int rlen = 2*len + 1;
+    QByteArray rstr;
+    rstr.resize(rlen);
+
+    uchar* cursor = (uchar*)rstr.data();
+    for (int i=0; i<len; i++) {
+        ushort ch = uc[i].unicode();
+        uchar c[2];
+        if (ch < 0x80) {
+            // ASCII
+            *cursor++ = ch;
+        } else if (qt_UnicodeToBig5(ch, c) == 2 && c[0] >= 0xa1 && c[0] <= 0xf9) {
+            *cursor++ = c[0];
+            *cursor++ = c[1];
+        } else {
+            *cursor++ = replacement;
+            ++invalid;
+        }
+    }
+    rstr.resize(cursor - (uchar*)rstr.constData());
+
+    if (state) {
+        state->invalidChars += invalid;
+    }
+    return rstr;
+}
+
+QList<QByteArray> UAOCodec::_aliases()
+{
+    QList<QByteArray> aliases;
+    aliases += "Unicode-at-on";
+    return aliases;
+}
+
+/* ====================================================================== */
+#endif // QT_NO_TEXTCODEC
+
+QT_END_NAMESPACE
diff --git a/src/fqterm/3rdparty/uaocodec.h b/src/fqterm/3rdparty/uaocodec.h
new file mode 100644
index 0000000..9984250
--- /dev/null
+++ b/src/fqterm/3rdparty/uaocodec.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// Most of the code here was originally written by UAO project (http://uao.cpatch.org/)
+// Ported to Qt by hooey <hephooey@gmail.com> (from uao-051123-src.tar.gz)
+
+#ifndef UAOCODEC_H
+#define UAOCODEC_H
+
+#include <QtCore/qtextcodec.h>
+#include <QtCore/qlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class UAOCodec : public QTextCodec {
+public:
+    static QByteArray _name();
+    static QList<QByteArray> _aliases();
+    static int _mibEnum();
+
+    QByteArray name() const { return _name(); }
+    QList<QByteArray> aliases() const { return _aliases(); }
+    int mibEnum() const { return _mibEnum(); }
+
+    QString convertToUnicode(const char *, int, ConverterState *) const;
+    QByteArray convertFromUnicode(const QChar *, int, ConverterState *) const;
+};
+
+QT_END_NAMESPACE
+
+#endif // UAOCODEC_H
diff --git a/src/fqterm/CMakeLists.txt b/src/fqterm/CMakeLists.txt
new file mode 100644
index 0000000..a93cdaf
--- /dev/null
+++ b/src/fqterm/CMakeLists.txt
@@ -0,0 +1,83 @@
+set(fqterm_SRCS
+  fqterm_app.h
+  fqterm_autoupdate.h
+  fqterm_frame.h
+  fqterm_screen.h
+  fqterm_window.h
+  fqterm_wndmgr.h
+  fqterm_autoupdate.cpp
+  fqterm_app.cpp
+  fqterm_frame.cpp
+  fqterm_screen.cpp
+  fqterm_window.cpp
+  fqterm_wndmgr.cpp
+  fqterm_python.h
+  fqterm_python.cpp
+  fqterm_scriptengine.h
+  fqterm_scriptengine.cpp
+)
+
+
+IF(WIN32)
+  set(global_shortcut_impl_SRCS 3rdparty/qxtglobalshortcut_win.cpp)
+ELSE(WIN32)
+  IF(APPLE)
+    set(global_shortcut_impl_SRCS 3rdparty/qxtglobalshortcut_mac.cpp)
+  ELSE(APPLE)
+    set(global_shortcut_impl_SRCS 3rdparty/qxtglobalshortcut_x11.cpp)
+  ENDIF(APPLE)
+ENDIF(WIN32)
+
+  
+
+set(3rdparty_SRCS
+  3rdparty/dotnetstyle.cpp
+  3rdparty/dotnetstyle.h
+  3rdparty/qxtglobalshortcut.cpp
+  3rdparty/qxtglobalshortcut.h
+  3rdparty/qxtglobalshortcut_p.h
+  3rdparty/qxtglobal.h
+  3rdparty/uaocodec.h
+  3rdparty/uaocodec.cpp
+  ${global_shortcut_impl_SRCS}
+)
+
+qt4_automoc(${fqterm_SRCS}
+            ${3rdparty_SRCS}
+)
+
+qt4_create_translation(fqterm_qm_file
+  ${fqterm_SRCS}
+  ${CMAKE_SOURCE_DIR}/res/dict/fqterm_zh_CN.ts
+)
+
+include_directories(
+  ${QT_INCLUDE_DIR}
+  ${QT_QTCORE_INCLUDE_DIR}
+  ${QT_QTGUI_INCLUDE_DIR}
+  ${QT_QTNETWORK_INCLUDE_DIR}
+  ${QT_QTSCRIPT_INCLUDE_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}/../common
+  ${CMAKE_CURRENT_SOURCE_DIR}/../protocol
+  ${CMAKE_CURRENT_SOURCE_DIR}/../terminal
+  ${CMAKE_CURRENT_SOURCE_DIR}/../utilities
+  ${CMAKE_CURRENT_SOURCE_DIR}/../unite
+  ${CMAKE_CURRENT_SOURCE_DIR}/../ui
+  ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty
+  ${CMAKE_CURRENT_BINARY_DIR}/../ui
+  ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_library(fqterm_main
+  ${fqterm_SRCS}
+  ${3rdparty_SRCS}
+)
+
+add_dependencies(fqterm_main
+  fqterm_common
+  fqterm_terminal
+  fqterm_protocol
+  fqterm_ui
+  fqterm_utilities
+  fqterm_unite
+)
diff --git a/src/fqterm/fqterm.rc b/src/fqterm/fqterm.rc
new file mode 100644
index 0000000..88394ab
--- /dev/null
+++ b/src/fqterm/fqterm.rc
diff --git a/src/fqterm/fqterm_app.cpp b/src/fqterm/fqterm_app.cpp
new file mode 100644
index 0000000..393355a
--- /dev/null
+++ b/src/fqterm/fqterm_app.cpp
@@ -0,0 +1,38 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#include "fqterm_app.h"
+
+namespace FQTerm {
+
+FQTermApplication::FQTermApplication( int & argc, char ** argv ) : QApplication(argc, argv)
+{
+
+}
+
+void FQTermApplication::commitData( QSessionManager & manager )
+{
+  emit saveData();
+}
+
+
+} //namespace FQTerm
+
+#include "fqterm_app.moc"
\ No newline at end of file
diff --git a/src/fqterm/fqterm_app.h b/src/fqterm/fqterm_app.h
new file mode 100644
index 0000000..ee0778a
--- /dev/null
+++ b/src/fqterm/fqterm_app.h
@@ -0,0 +1,41 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_APP
+#define FQTERM_APP
+#include <QApplication>
+#include <QObject>
+namespace FQTerm {
+
+class FQTermApplication : public QApplication {
+  Q_OBJECT;
+public:
+  FQTermApplication(int & argc, char ** argv);
+protected:
+  virtual void commitData(QSessionManager & manager);
+signals:
+  void saveData();
+protected slots:
+    void mainWindowDestroyed(QObject* obj) {quit();}
+};
+
+} //namespace FQTerm
+
+#endif
\ No newline at end of file
diff --git a/src/fqterm/fqterm_autoupdate.cpp b/src/fqterm/fqterm_autoupdate.cpp
new file mode 100644
index 0000000..0f49c38
--- /dev/null
+++ b/src/fqterm/fqterm_autoupdate.cpp
@@ -0,0 +1,178 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#include "fqterm_autoupdate.h"
+#include "fqterm_config.h"
+#include "fqterm_trace.h"
+#include "fqterm_param.h"
+
+#include <QDesktopServices>
+#include <QFile>
+#include <QHttp>
+#include <QMessageBox>
+#include <QString>
+#include <QUrl>
+
+namespace FQTerm {
+
+////////////////////////////////////////////////
+static int versionCompare(QString lhs, QString rhs) {
+  //0 -- lhs == rhs, -1 -- lhs > rhs, 1 -- lhs < rhs
+  
+  int versionEnd = lhs.indexOf('-');
+  if (versionEnd != -1) {
+    lhs = lhs.mid(0, versionEnd);
+  }
+  versionEnd = rhs.indexOf('-');
+  if (versionEnd != -1) {
+    rhs = rhs.mid(0, versionEnd);
+  }
+  QStringList lhsList = lhs.split(".");
+  QStringList rhsList = rhs.split(".");
+  if (lhsList.size() != 3 || rhsList.size() != 3) {
+    return 0; //something is wrong
+  }
+  for (int i = 0; i < 3; ++i) {
+    if (lhsList[i].toInt() < rhsList[i].toInt()) {
+      return 1;
+    }
+    else if (lhsList[i].toInt() > rhsList[i].toInt()) {
+      return -1;
+    }
+  }
+  return 0;
+}
+///////////////////////////////////////////////
+
+void FQTermAutoUpdater::checkUpdate() {
+  QString fileName = FQTermPref::getInstance()->poolDir_ + "VersionInfo";
+  if (QFile::exists(fileName)) {
+    QFile::remove(fileName);
+  }
+  versionInfoFile_ = new QFile(fileName, this);
+  if (!versionInfoFile_->open(QIODevice::WriteOnly)) {
+    delete versionInfoFile_;
+    return;
+  }
+  FQ_VERIFY(connect(updateChecker_, SIGNAL(requestFinished(int, bool)),
+    this, SLOT(checkRequestFinished(int, bool))));
+  FQ_VERIFY(connect(updateChecker_, SIGNAL(done(bool)),
+    this, SLOT(httpDone(bool))));
+
+  const QString versionInfoURL = "http://fqterm.googlecode.com/svn/trunk/VersionInfo";
+  QUrl url(versionInfoURL);
+  QHttp::ConnectionMode mode = url.scheme().toLower() == "https" ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp;
+  updateChecker_->setHost(url.host(), mode, url.port() == -1 ? 0 : url.port());
+  if (!url.userName().isEmpty())
+    updateChecker_->setUser(url.userName(), url.password());
+  checkRequestId_ =  updateChecker_->get(url.path(), versionInfoFile_);
+}
+
+QString FQTermAutoUpdater::getNewestVersion() {
+#if defined(WIN32)
+  const QString platform = "FQWin";
+#elif defined(__unix__) && !defined(__APPLE__)
+  const QString platform = "FQLinux";
+#else
+  const QString platform = "FQMac";
+#endif
+  FQTermConfig versionInfo(FQTermPref::getInstance()->poolDir_ + "VersionInfo");
+  QString ver = versionInfo.getItemValue(platform, "version");
+  if (ver.isEmpty()) {
+    return FQTERM_VERSION_STRING;
+  }
+  return ver;
+}
+
+void FQTermAutoUpdater::promptUpdate() {
+  const QString updateURL = "http://code.google.com/p/fqterm/downloads/list";
+  QMessageBox msgBox(QMessageBox::Information, tr("FQTerm Update Notifier"), 
+    tr("FQTerm update available.\nPress OK to visit our download list,\nDiscard for a future prompt,\nIgnore for no more notification."),
+    QMessageBox::Ok | QMessageBox::Discard | QMessageBox::Ignore);
+  switch (msgBox.exec()) {
+   case QMessageBox::Ok:
+     QDesktopServices::openUrl(updateURL);
+     break;
+   case QMessageBox::Discard:
+     break;
+   case QMessageBox::Ignore:
+     config_->setItemValue("global", "newestversion", getNewestVersion());
+     config_->setItemValue("global", "updateprompt", "0");
+     break;
+  } 
+}
+
+void FQTermAutoUpdater::checkRequestFinished(int requestId, bool error){
+  
+  if (checkDone_ || requestId != checkRequestId_) {
+    return;
+  }
+  if (!error) {
+    checkDone_ = true;
+  }
+}
+
+void FQTermAutoUpdater::httpDone(bool err)  {
+  if (!err) {
+    versionInfoFile_->flush();
+    if (checkDone_) {
+      QString newestVersionRecorded = config_->getItemValue("global", "newestversion");
+      if (newestVersionRecorded.isEmpty()) {
+        newestVersionRecorded = FQTERM_VERSION_STRING;
+        config_->setItemValue("global", "newestversion", newestVersionRecorded);
+      }
+      QString newestVersionReleased = getNewestVersion();
+
+      QString updatePrompt = config_->getItemValue("global", "updateprompt");
+      if (updatePrompt == "0") {
+        //if newest version > recorded version, still prompt.
+        if (versionCompare(newestVersionRecorded, newestVersionReleased) > 0) {
+          config_->setItemValue("global", "updateprompt", "1");
+          promptUpdate();
+        }
+      }
+      else {
+        config_->setItemValue("global", "updateprompt", "1");
+        //if newest version > version in use, prompt.
+        if (versionCompare(FQTERM_VERSION_STRING, newestVersionReleased) > 0) {
+          promptUpdate();
+        }
+      }
+    }
+  }
+  deleteLater();
+}
+
+FQTermAutoUpdater::FQTermAutoUpdater(QObject* parent, FQTermConfig* config) 
+: QObject(parent),
+  config_(config),
+  versionInfoFile_(0),
+  checkDone_(false) {
+  updateChecker_ = new QHttp(this);
+}
+
+FQTermAutoUpdater::~FQTermAutoUpdater()
+{
+
+}
+
+} //FQTerm namespace
+
+#include "fqterm_autoupdate.moc"
diff --git a/src/fqterm/fqterm_autoupdate.h b/src/fqterm/fqterm_autoupdate.h
new file mode 100644
index 0000000..0ad8aaf
--- /dev/null
+++ b/src/fqterm/fqterm_autoupdate.h
@@ -0,0 +1,61 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_AUTO_UPDATE_H
+#define FQTERM_AUTO_UPDATE_H
+
+#include <QObject>
+
+class QHttp;
+class QFile;
+class QString;
+
+namespace FQTerm {
+
+class FQTermConfig;
+
+class FQTermAutoUpdater : public QObject{
+
+  Q_OBJECT;
+
+public:
+  FQTermAutoUpdater(QObject* parent, FQTermConfig* config);
+  ~FQTermAutoUpdater();
+
+  void checkUpdate();
+
+protected slots:
+  void checkRequestFinished(int requestId, bool error);
+  void httpDone(bool err);
+
+private:
+  QString getNewestVersion();
+  void promptUpdate();
+
+  FQTermConfig* config_;
+  QHttp * updateChecker_;
+  QFile * versionInfoFile_;
+  int checkRequestId_;
+  bool checkDone_;
+};
+
+} //namespace FQTerm
+
+#endif
diff --git a/src/fqterm/fqterm_frame.cpp b/src/fqterm/fqterm_frame.cpp
new file mode 100644
index 0000000..b50eff9
--- /dev/null
+++ b/src/fqterm/fqterm_frame.cpp
@@ -0,0 +1,2162 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#if !defined(WIN32)
+#include <unistd.h>
+#endif
+
+#if defined(__linux__) || defined(__GLIBC__)
+#include <QLocale>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <QDesktopServices>
+#include <QDir>
+#include <QFontComboBox>
+#include <QFontDialog>
+#include <QInputDialog>
+#include <QKeySequence>
+#include <QList>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QMenuBar>
+#include <QMessageBox>
+#include <QSignalMapper>
+#include <QStatusBar>
+#include <QStyleFactory>
+#include <QTime>
+#include <QDate>
+#include <QSizePolicy>
+#include <QTimer>
+#include <QToolBar>
+#include <QTranslator>
+#include <QWindowStateChangeEvent>
+
+#include "aboutdialog.h"
+#include "addrdialog.h"
+#include "common.h"
+#include "keydialog.h"
+#include "prefdialog.h"
+#include "fqterm.h"
+
+#include "fqterm_path.h"
+#include "fqterm_autoupdate.h"
+#include "fqterm_config.h"
+#include "fqterm_frame.h"
+#include "fqterm_param.h"
+#include "fqterm_session.h"
+#include "fqterm_screen.h"
+#include "fqterm_time_label.h"
+#include "fqterm_tool_button.h"
+#include "fqterm_window.h"
+#include "fqterm_wndmgr.h"
+#include "imageviewer.h"
+#include "quickdialog.h"
+#include "statusBar.h"
+#include "sitemanager.h"
+#include "fqterm_shortcuthelper.h"
+#include "fqterm_mini_server.h"
+#include "shortcutdialog.h"
+#include "schemadialog.h"
+#include "fqterm_ip_location.h"
+#include "iplookup.h"
+#include "defineescape.h"
+#include "uaocodec.h"
+
+#ifdef USE_DOTNET_STYLE
+#include "dotnetstyle.h"
+#endif //USE_DOTNET_STYLE
+
+#ifdef USE_GLOBAL_HOTKEY
+#include "qxtglobalshortcut.h"
+#endif //USE_GLOBAL_HOTKEY
+
+#ifdef HAVE_PYTHON

+#include <Python.h>

+#include "fqterm_python.h"

+#endif //HAVE_PYTHON
+
+namespace FQTerm {
+
+
+const QString FQTermFrame::qmPrefix[FQTermFrame::translatedModule] =
+{"fqterm_", "ui_", "protocol_", "common_"};
+const QString FQTermFrame::qmPostfix = ".qm";
+
+//constructor
+FQTermFrame::FQTermFrame()
+    : QMainWindow(0), 
+      tray_(0),
+      trayMenu_(0), 
+#ifdef HAVE_PYTHON
+      pythonHelper_(0),
+#endif
+#ifdef USE_GLOBAL_HOTKEY
+      globalHotkey_(0),
+#endif //USE_GLOBAL_HOTKEY
+      shortcutHelper_(0)
+{
+  setAttribute(Qt::WA_DeleteOnClose);
+
+/*#ifndef __APPLE__
+  setWindowFlags(Qt::CustomizeWindowHint);
+#endif*/
+  uaoCodec_ = new UAOCodec;
+  
+  config_ = new FQTermConfig(getPath(USER_CONFIG) + "fqterm.cfg");
+
+  initTranslator();
+  shortcutHelper_ = new FQTermShortcutHelper(config_, this);
+
+#ifdef IMAGE_USE_PICFLOW
+  imageViewer_ = new FQTermImageFlow(config_, NULL, Qt::Window);
+#else
+  imageViewer_ = new FQTermImageOrigin(config_, NULL, Qt::Window);
+#endif
+
+
+  //create the window manager to deal with the window-tab-icon pairs
+  windowManager_ = new FQTermWndMgr(this);
+  setCentralWidget(windowManager_);
+
+  //set menubar
+  addMainMenu();
+  FQ_VERIFY(connect(this, SIGNAL(changeLanguage()),
+                    this, SLOT(recreateMenu())));
+
+  //initialize all settings
+  //This should be done before add main tool, since some status of tool will depend on setting
+  iniSetting();
+  FQTermConfig* conf = new FQTermConfig(getPath(USER_CONFIG) + "address.cfg");
+  checkHelpExists(conf);
+  delete conf;
+  //setup toolbar
+  addMainTool();
+
+  // add the custom defined key
+  // and load toolbar position
+  updateKeyToolBar();
+  loadToolBarPosition();
+  enableMenuToolBar(false);
+
+  // FIXME: !!!create a horizonal layout to hold the tabbar,the reason
+  //of why not put the tabbar directly on the status bar is when no
+  //tab in the tabbar,the statusbar display a horizonal line,ugly.
+  //perhaps there is some function in statusbar to solve this.
+  QWidget *hb = new QWidget(statusBar());
+  hb->setObjectName("taskbar");
+  QHBoxLayout *hbLayout = new QHBoxLayout(hb);
+  hbLayout->setMargin(0);
+  hbLayout->setObjectName("tasklayout");
+  statusBar()->addWidget(hb);
+  //create a tabbar in the hbox
+  hbLayout->addWidget(windowManager_->tabBar());
+
+  windowMapper_ = new QSignalMapper(this);
+  FQ_VERIFY(connect(windowMapper_, SIGNAL(mapped(int)),
+    windowManager_, SLOT(activateTheWindow(int))));
+  initAdditionalActions();
+
+  //create a progress bar to notify the download process
+  statusBar_ = new FQTerm::StatusBar(statusBar(), "mainStatusBar");
+  statusBar()->addWidget(statusBar_, 0);
+
+  installEventFilter(this);
+
+  QDate lastCheckDate = QDate::fromString(config_->getItemValue("global", "lastcheckupdate"));
+  QDate currentDate = QDate::currentDate();
+  if (!lastCheckDate.isValid() || lastCheckDate.daysTo(currentDate) >= 31) {
+    FQTermAutoUpdater* autoUpdater =
+      new FQTermAutoUpdater(this, config_);
+    autoUpdater->checkUpdate();  
+    config_->setItemValue("global", "lastcheckupdate", currentDate.toString());
+  }
+
+  serverThread_ = new FQTermMiniServerThread();
+  if (FQTermPref::getInstance()->runServer_)
+    serverThread_->start();
+#ifdef HAVE_PYTHON
+  pythonHelper_ = new FQTermPythonHelper;
+#endif
+#ifdef USE_GLOBAL_HOTKEY
+  globalHotkey_ = new QxtGlobalShortcut(shortcutHelper_->getAction(FQTermShortcutHelper::GLOBAL_SHOW_FQTERM)->shortcut(), this);
+  FQ_VERIFY(connect(shortcutHelper_->getAction(FQTermShortcutHelper::GLOBAL_SHOW_FQTERM), SIGNAL(changed()),
+                    this, SLOT(globalHotkeyChanged())));
+  FQ_VERIFY(connect(globalHotkey_, SIGNAL(activated()),
+    this, SLOT(globalHotkeyTriggered())));
+#endif //USE_GLOBAL_HOTKEY
+}
+
+//destructor
+FQTermFrame::~FQTermFrame() {
+#ifdef USE_GLOBAL_HOTKEY
+  delete globalHotkey_;
+#endif //USE_GLOBAL_HOTKEY
+#ifdef HAVE_PYTHON
+  delete pythonHelper_;
+#endif //HAVE_PYTHON
+  clearTranslator();
+  delete imageViewer_;
+  delete shortcutHelper_;
+  delete config_;
+  delete uaoCodec_;
+  delete windowManager_;
+  FQTermIPLocation::Destroy();
+  serverThread_->quit();
+  serverThread_->wait(1000);
+  delete serverThread_;
+  
+}
+
+//initialize setting from fqterm.cfg
+void FQTermFrame::iniSetting() {
+  QString strTmp;
+
+  strTmp = config_->getItemValue("global", "fullscreen");
+  if (strTmp == "1") {
+    getAction(FQTermShortcutHelper::FULLSCREEN)->setChecked(true);
+    showFullScreen();
+  } else {
+    //window size
+    strTmp = config_->getItemValue("global", "max");
+    if (strTmp == "1") {
+      showMaximized();
+    } else {
+      QString size = config_->getItemValue("global", "size");
+      if (size != "") {
+        int x, y, cx, cy;
+        sscanf(size.toLatin1(), "%d %d %d %d", &x, &y, &cx, &cy);
+        resize(QSize(cx, cy));
+        move(QPoint(x, y));
+      }
+    }
+  }
+
+  theme_ = config_->getItemValue("global", "theme");
+  QStyle *style;
+#ifdef USE_DOTNET_STYLE
+  //javaboy@newsmth.org
+  if (theme_ == "Office")
+    style = new DotNetStyle(DotNetStyle::Office);
+  else
+#endif //USE_DOTNET_STYLE
+    style = QStyleFactory::create(theme_);
+  if (style) {
+    qApp->setStyle(style);
+  }
+
+  //language
+  updateLanguageMenu();
+
+  //TODO: 
+  getAction(FQTermShortcutHelper::COLORCTL_NO)->setChecked(true);
+  FQTermPref::getInstance()->escapeString_ = config_->getItemValue("global", "escstr");
+  if (FQTermPref::getInstance()->escapeString_ == "") {
+    getAction(FQTermShortcutHelper::COLORCTL_NO)->setChecked(true);
+    getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+  } else if (FQTermPref::getInstance()->escapeString_ == "^[^[[") {
+    getAction(FQTermShortcutHelper::COLORCTL_SMTH)->setChecked(true);
+    getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+  } else if (FQTermPref::getInstance()->escapeString_ == "^u[") {
+    getAction(FQTermShortcutHelper::COLORCTL_PTT)->setChecked(true);
+    getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+  } else {
+    QAction *pAction = getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM);
+    QString transStrEsc;
+    transEscapeStr(transStrEsc, FQTermPref::getInstance()->escapeString_);
+    pAction->setText(transStrEsc);
+    pAction->setVisible(true);
+    pAction->setChecked(true);
+  }
+
+  strTmp = config_->getItemValue("global", "vscrollpos");
+  if (strTmp == "0") {
+    FQTermPref::getInstance()->termScrollBarPosition_ = 0;
+    getAction(FQTermShortcutHelper::SCROLLBAR_HIDDEN)->setChecked(true);
+  } else if (strTmp == "1") {
+    FQTermPref::getInstance()->termScrollBarPosition_ = 1;
+    getAction(FQTermShortcutHelper::SCROLLBAR_LEFT)->setChecked(true);
+  } else {
+    FQTermPref::getInstance()->termScrollBarPosition_ = 2;
+    getAction(FQTermShortcutHelper::SCROLLBAR_RIGHT)->setChecked(true);
+  }
+  strTmp = config_->getItemValue("global", "switchbar");
+  isTabBarShown_ = (strTmp != "0");
+  getAction(FQTermShortcutHelper::SWITCHBAR)->setChecked(isTabBarShown_);
+  if (isTabBarShown_) {
+    statusBar()->show();
+  } else {
+    statusBar()->hide();
+  }
+
+  //read sub-window setting.
+  strTmp = config_->getItemValue("global", "subwindowmax");
+  windowManager_->setSubWindowMax((strTmp != "0"));
+
+
+  strTmp = config_->getItemValue("global", "subwindowsize");
+  if (strTmp != "") {
+    //FIXME: In case of sub window size not saved properly.
+    int w, h;
+    sscanf(strTmp.toLatin1(), "%d %d", &w, &h);
+    windowManager_->setSubWindowSize(QSize(w, h));
+  } else {
+    //Magic Number. Initialize Window Size to Avoid Errors.
+    windowManager_->setSubWindowSize(QSize(640, 480));
+  }
+
+  FQTermPref::getInstance()->isBossColor_ = false;
+
+  loadPref();
+
+  setUseDock(FQTermPref::getInstance()->openMinimizeToTray_);
+
+  if (FQTermPref::getInstance()->useStyleSheet_) {
+    loadStyleSheetFromFile(FQTermPref::getInstance()->styleSheetFile_);
+  }
+
+  strTmp = config_->getItemValue("global", "runserver");
+  FQTermPref::getInstance()->runServer_ = (strTmp != "0");
+}
+
+void FQTermFrame::loadPref() {
+  QString strTmp;
+  
+  strTmp = config_->getItemValue("preference", "displayoffset");
+  FQTermPref::getInstance()->displayOffset_ = strTmp.toInt();
+  strTmp = config_->getItemValue("preference", "vsetting");
+  FQTermPref::getInstance()->vsetting_ = strTmp.toInt();
+  strTmp = config_->getItemValue("preference", "xim");
+  FQTermPref::getInstance()->imeEncodingID_ = strTmp.toInt();
+  strTmp = config_->getItemValue("preference", "wordwrap");
+  FQTermPref::getInstance()->widthToWrapWord_ = strTmp.toInt();
+  //  strTmp = conf->getItemValue("preference", "smartww");
+  //  m_pref.bSmartWW = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "wheel");
+  FQTermPref::getInstance()->isWheelSupported_ = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "url");
+  FQTermPref::getInstance()->openUrlCheck_ = (strTmp != "0");
+  //  strTmp = conf->getItemValue("preference", "logmsg");
+  //  m_pref.bLogMsg = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "blinktab");
+  FQTermPref::getInstance()->openTabBlinking_ = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "warn");
+  FQTermPref::getInstance()->openWarnOnClose_ = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "beep");
+  FQTermPref::getInstance()->openBeep_ = strTmp.toInt();
+  FQTermPref::getInstance()->beepSoundFileName_ = config_->getItemValue("preference", "wavefile");
+  strTmp = config_->getItemValue("preference", "http");
+  FQTermPref::getInstance()->httpBrowser_ = strTmp;
+  //  m_pref.strHttp = strTmp;
+  strTmp = config_->getItemValue("preference", "antialias");
+  FQTermPref::getInstance()->openAntiAlias_ = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "enq");
+  FQTermPref::getInstance()->replyENQ_ = (strTmp != "0");
+  strTmp = config_->getItemValue("preference", "tray");
+  if (strTmp.isEmpty()) {
+#if defined(__APPLE__) || defined(__linux__) || defined(__GLIBC__)
+    FQTermPref::getInstance()->openMinimizeToTray_ = false;
+#else
+    FQTermPref::getInstance()->openMinimizeToTray_ = true;    
+#endif
+  } else {
+    FQTermPref::getInstance()->openMinimizeToTray_ = (strTmp != "0");
+  }
+  strTmp = config_->getItemValue("preference", "playmethod");
+  FQTermPref::getInstance()->beepMethodID_ = strTmp.toInt();
+  strTmp = config_->getItemValue("preference", "externalplayer");
+  FQTermPref::getInstance()->beepPlayerName_ = strTmp;
+
+  strTmp = config_->getItemValue("preference", "clearpool");
+  FQTermPref::getInstance()->needClearZmodemPoolOnClose_ = (strTmp == "1");
+  strTmp = config_->getItemValue("preference", "pool");
+  FQTermPref::getInstance()->poolDir_ = strTmp.isEmpty() ?
+                               getPath(USER_CONFIG) + "pool/": strTmp;
+  if (FQTermPref::getInstance()->poolDir_.right(1) != "/") {
+    FQTermPref::getInstance()->poolDir_.append('/');
+  }
+  strTmp = config_->getItemValue("preference", "zmodem");
+  FQTermPref::getInstance()->zmodemDir_ = strTmp.isEmpty() ?
+                           getPath(USER_CONFIG) + "zmodem/": strTmp;
+  if (FQTermPref::getInstance()->zmodemDir_.right(1) != "/") {
+    FQTermPref::getInstance()->zmodemDir_.append('/');
+  }
+  strTmp = config_->getItemValue("preference", "image");
+  FQTermPref::getInstance()->imageViewerName_ = strTmp;
+  strTmp = config_->getItemValue("preference", "qssfile");
+  FQTermPref::getInstance()->styleSheetFile_ = strTmp;
+  FQTermPref::getInstance()->useStyleSheet_ = !strTmp.isEmpty();
+
+  strTmp = config_->getItemValue("preference", "editor");
+  FQTermPref::getInstance()->externalEditor_ = strTmp;
+
+  //FIXME: duplicated strings.
+  strTmp = config_->getItemValue("preference", "searchengine");
+  if (strTmp == "google") {
+    getAction(FQTermShortcutHelper::SEARCH_GOOGLE)->setChecked(true);
+  } else if (strTmp == "baidu") {
+    getAction(FQTermShortcutHelper::SEARCH_BAIDU)->setChecked(true);
+  } else if (strTmp == "bing") {
+    getAction(FQTermShortcutHelper::SEARCH_BING)->setChecked(true);
+  } else if (strTmp == "yahoo") {
+    getAction(FQTermShortcutHelper::SEARCH_YAHOO)->setChecked(true);
+  } else if (strTmp == "custom") {
+    getAction(FQTermShortcutHelper::SEARCH_CUSTOM)->setChecked(true);
+  } else {
+    getAction(FQTermShortcutHelper::SEARCH_GOOGLE)->setChecked(true);
+    strTmp = "google";
+  }
+  FQTermPref::getInstance()->searchEngine_ = strTmp;
+
+  strTmp = config_->getItemValue("preference", "editorarg");
+  FQTermPref::getInstance()->externalEditorArg_ = strTmp;
+ 
+  strTmp = config_->getItemValue("preference", "asciienhance");
+  FQTermPref::getInstance()->isAnsciiEnhance_ = (strTmp == "1");
+}
+
+//save current setting to fqterm.cfg
+void FQTermFrame::saveSetting() {
+  QString strTmp;
+  //save font
+  config_->setItemValue("global", "font", qApp->font().family());
+  strTmp.setNum(QFontInfo(qApp->font()).pointSize());
+  config_->setItemValue("global", "pointsize", strTmp);
+  strTmp.setNum(QFontInfo(qApp->font()).pixelSize());
+  config_->setItemValue("global", "pixelsize", strTmp);
+
+  //save window position and size
+  if (isMaximized()) {
+    config_->setItemValue("global", "max", "1");
+  } else {
+    strTmp = QString("%1 %2 %3 %4").arg(x()).arg(y()).arg(width()).arg(height());
+    // 		cstrTmp.sprintf("%d %d %d %d",x(),y(),width(),height());
+    config_->setItemValue("global", "size", strTmp);
+    config_->setItemValue("global", "max", "0");
+  }
+
+  if (windowState() & Qt::WindowFullScreen) {
+    config_->setItemValue("global", "fullscreen", "1");
+  } else {
+    config_->setItemValue("global", "fullscreen", "0");
+  }
+
+  // cstrTmp.setNum(theme);
+  config_->setItemValue("global", "theme", theme_);
+
+  config_->setItemValue("global", "escstr", FQTermPref::getInstance()->escapeString_);
+
+  strTmp.setNum(FQTermPref::getInstance()->termScrollBarPosition_);
+  config_->setItemValue("global", "vscrollpos", strTmp);
+
+  config_->setItemValue("global", "switchbar", isTabBarShown_ ? "1" : "0");
+
+  //save subwindow setting
+  config_->setItemValue("global", "subwindowmax", windowManager_->getSubWindowMax() ? "1" : "0");
+  int w = windowManager_->getSubWindowSize().width();
+  int h = windowManager_->getSubWindowSize().height();
+
+  strTmp = QString("%1 %2").arg(w).arg(h);
+  config_->setItemValue("global", "subwindowsize", strTmp);
+
+  //Save toolbarstate.
+  QByteArray state = saveState().toHex();
+  strTmp = QString(state);
+  config_->setItemValue("global", "toolbarstate", strTmp);
+
+  config_->setItemValue("global", "runserver", FQTermPref::getInstance()->runServer_ ? "1" : "0");
+
+  config_->save(getPath(USER_CONFIG) + "fqterm.cfg");
+}
+
+void FQTermFrame::initAdditionalActions()
+{
+  
+#if defined(__APPLE__)
+  QString opt(tr("Ctrl"));
+#else
+  QString opt(tr("Alt"));  
+#endif
+  
+  for (int i = 1; i <= 10; ++i) {
+    QAction *idAction = new QAction(this);
+    QString shortcut(opt);
+    shortcut += "+" + QString("").setNum(i % 10);
+    idAction->setShortcut(shortcut);
+    connect(idAction, SIGNAL(triggered()), windowMapper_, SLOT(map()));
+    windowMapper_->setMapping(idAction, i - 1);
+    addAction(idAction);
+  }
+
+  FQTERM_ADDACTION(windowManager_, NEXTWINDOW, windowManager_, activateNextWindow);
+  FQTERM_ADDACTION(windowManager_, PREVWINDOW, windowManager_, activatePrevWindow);
+
+}
+
+//addressbook
+void FQTermFrame::addressBook() {
+  siteDialog siteManager(this, false);
+  if (siteManager.exec() == 1) {
+    newWindow(siteManager.currentParameter(), siteManager.currentSiteIndex());
+  }
+}
+
+//quicklogin
+void FQTermFrame::quickLogin() {
+  quickDialog quick(config_, this);
+  FQTermConfig *pConf = new FQTermConfig(getPath(USER_CONFIG) + "address.cfg");
+
+  loadAddress(pConf, -1, quick.param_);
+  delete pConf;
+
+  if (quick.exec() == 1) {
+    newWindow(quick.param_);
+  }
+}
+
+void FQTermFrame::exitFQTerm() {  
+  if (!clearUp()) return;
+  deleteLater();
+}
+
+void FQTermFrame::newWindow(const FQTermParam &param, int index) {
+  QIcon *icon = new QIcon(QPixmap(getPath(RESOURCE) + "pic/tabpad.png"));
+  FQTermWindow* window = windowManager_->newWindow(param, config_, icon, index);
+
+  updateFontCombo();
+  FQ_VERIFY(connect(window->getScreen(), SIGNAL(termFontChange(bool,QFont)), this, SLOT(termFontChange(bool,QFont))));
+
+  window->connectHost();
+}
+
+
+void FQTermFrame::aboutFQTerm() {
+  aboutDialog about(this);
+  about.exec();
+}
+
+//slot Help->Homepage
+void FQTermFrame::homepage() {
+  const QString &httpBrowser = FQTermPref::getInstance()->httpBrowser_;
+  const QString homeUrl = "http://code.google.com/p/fqterm";
+
+  if (httpBrowser.isNull() || httpBrowser.isEmpty()) {
+	QDesktopServices::openUrl(homeUrl);
+  } else {
+	  runProgram(httpBrowser, homeUrl);
+  }
+}
+
+//slot Windows menu aboutToShow
+void FQTermFrame::windowsMenuAboutToShow() {
+  menuWindows_->clear();
+  FQTERM_ADDACTION(menuWindows_, CASCADEWINDOWS, windowManager_, cascade);
+  FQTERM_ADDACTION(menuWindows_, TILEWINDOWS, windowManager_, tile);
+  if (windowManager_->count() == 0) {
+    getAction(FQTermShortcutHelper::CASCADEWINDOWS)->setEnabled(false);
+    getAction(FQTermShortcutHelper::TILEWINDOWS)->setEnabled(false);
+  }
+  menuWindows_->addSeparator();
+
+#ifdef Q_OS_MACX
+  // used to dock the program
+  if (isHidden()) {
+    menuWindows_->addAction(tr("Main Window"), this, SLOT(trayShow()));
+  }
+#endif
+
+  for (int i = 0; i < int(windowManager_->count()); ++i) {
+    QAction *idAction = menuWindows_->addAction(windowManager_->subWindowList().at(i)->windowTitle());
+    idAction->setCheckable(true);
+    idAction->setChecked(windowManager_->activeWindow() == windowManager_->nthWindow(i));
+    connect(idAction, SIGNAL(triggered()), windowMapper_, SLOT(map()));
+    windowMapper_->setMapping(idAction, i);
+  }
+}
+
+void FQTermFrame::reloadConfig() {
+  config_->load(getPath(USER_CONFIG) + "fqterm.cfg");
+}
+
+void FQTermFrame::popupConnectMenu() {
+  menuConnect_->clear();
+  menuConnect_->addAction(tr("Quick Login"), this, SLOT(quickLogin()));
+  menuConnect_->addSeparator();
+  
+  FQTermConfig conf(getPath(USER_CONFIG) + "address.cfg");
+
+  QStringList listName;
+  loadNameList(&conf, listName);
+
+  for (int i = 0; i < listName.count(); i++) {
+    QAction *idAction = menuConnect_->addAction(listName[i], this, SLOT
+                                                (connectMenuActivated()));
+    idAction->setData(i);
+    if (i < 10) {
+#ifdef __APPLE__
+      QString shortCut(tr("Ctrl+Meta"));
+#else
+      QString shortCut(tr("Ctrl+Alt"));
+#endif
+      shortCut += "+" + QString("").setNum((i + 1)% 10);
+      idAction->setShortcut(shortCut);
+    }
+  }
+
+  int lastIndex = config_->getItemValue("global", "lastaddrindex").toInt();
+  if (lastIndex < 0 || lastIndex >= listName.count())
+    lastIndex = 0;
+  if (listName.count() > 0)
+  {    
+    menuConnect_->addSeparator();
+    QAction *idAction = menuConnect_->addAction(listName[lastIndex], this, SLOT
+      (connectMenuActivated()));
+    idAction->setData(LAST_ADDRESS_INDEX);
+#ifdef __APPLE__
+    QString shortCut(tr("Ctrl+Meta"));
+#else
+    QString shortCut(tr("Ctrl+Alt"));
+#endif
+    shortCut += "+" + QString("-");
+    idAction->setShortcut(shortCut);
+
+  }
+}
+
+void FQTermFrame::connectMenuActivated() {
+  FQTermConfig *pConf = new FQTermConfig(getPath(USER_CONFIG) + "address.cfg");
+  int id = static_cast < QAction * > (sender())->data().toInt();
+  if (id == LAST_ADDRESS_INDEX)
+  {
+    id = config_->getItemValue("global", "lastaddrindex").toInt();
+  }
+  
+  FQTermParam param;
+
+  // FIXME: don't know the relation with id and param setted by setItemParameter
+  if (loadAddress(pConf, id, param)) {
+    newWindow(param, id);
+  }
+  delete pConf;
+}
+
+
+bool FQTermFrame::eventFilter(QObject *o, QEvent *e) {
+  return false;
+}
+
+void FQTermFrame::closeEvent(QCloseEvent *clse) {
+  if (FQTermPref::getInstance()->openMinimizeToTray_ &&
+	windowManager_->count() > 0) {
+    trayHide();
+    clse->ignore();
+    return ;
+  }
+  if (!clearUp())
+  {
+    clse->ignore();
+    return;
+  }
+
+  clse->accept();
+
+  deleteLater();
+}
+
+void FQTermFrame::langEnglish() {
+  installTranslator("en_US");
+}
+
+void FQTermFrame::connectIt() {
+  if (windowManager_->activeWindow() == NULL) {
+    FQTermParam param;
+    FQTermConfig *pConf = new FQTermConfig(getPath(USER_CONFIG) + "address.cfg");
+
+    loadAddress(pConf, -1, param);
+    delete pConf;
+    newWindow(param);
+  } else if (!windowManager_->activeWindow()->isConnected()) {
+    windowManager_->activeWindow()->getSession()->reconnect();
+  }
+}
+
+void FQTermFrame::disconnect() {
+  FQTermWindow* aw = windowManager_->activeWindow();
+  if (aw) {
+    aw->disconnect();
+  }
+}
+
+void FQTermFrame::copy() {
+  windowManager_->activeWindow()->copy();
+}
+
+void FQTermFrame::paste() {
+  windowManager_->activeWindow()->paste();
+}
+
+void FQTermFrame::searchIt()
+{
+  windowManager_->activeWindow()->searchIt();
+}
+
+void FQTermFrame::shareIt()
+{
+  windowManager_->activeWindow()->shareIt();
+}
+
+void FQTermFrame::externalEditor() {
+  windowManager_->activeWindow()->externalEditor();
+}
+
+void FQTermFrame::fastPost() {
+  windowManager_->activeWindow()->fastPost();
+}
+
+void FQTermFrame::copyRect() {
+  windowManager_->activeWindow()->getSession()->param().isRectSelect_
+      = !windowManager_->activeWindow()->getSession()->param().isRectSelect_;
+
+  getAction(FQTermShortcutHelper::RECTANGLESELECTION)->setChecked(
+      windowManager_->activeWindow()->getSession()->param().isRectSelect_);
+}
+
+void FQTermFrame::copyColor() {
+  windowManager_->activeWindow()->getSession()->param().isColorCopy_
+      = !windowManager_->activeWindow()->getSession()->param().isColorCopy_;
+
+  getAction(FQTermShortcutHelper::COPYWITHCOLOR)->setChecked(
+      windowManager_->activeWindow()->getSession()->param().isColorCopy_);
+}
+
+void FQTermFrame::copyArticle() {
+  windowManager_->activeWindow()->copyArticle();
+}
+
+void FQTermFrame::autoCopy() {
+  windowManager_->activeWindow()->getSession()->param().isAutoCopy_
+      = !windowManager_->activeWindow()->getSession()->param().isAutoCopy_;
+
+  getAction(FQTermShortcutHelper::AUTOCOPYSELECTION)->setChecked(
+      windowManager_->activeWindow()->getSession()->param().isAutoCopy_);
+}
+
+void FQTermFrame::wordWrap() {
+  windowManager_->activeWindow()->getSession()->param().isAutoWrap_
+      = !windowManager_->activeWindow()->getSession()->param().isAutoWrap_;
+
+  getAction(FQTermShortcutHelper::PASTEWORDWRAP)->setChecked(
+      windowManager_->activeWindow()->getSession()->param().isAutoWrap_);
+}
+
+void FQTermFrame::noEsc() {
+  FQTermPref::getInstance()->escapeString_ = "";
+  getAction(FQTermShortcutHelper::COLORCTL_NO)->setChecked(true);
+  getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+}
+
+void FQTermFrame::escEsc() {
+  FQTermPref::getInstance()->escapeString_ = "^[^[[";
+  getAction(FQTermShortcutHelper::COLORCTL_SMTH)->setChecked(true);
+  getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+}
+
+void FQTermFrame::uEsc() {
+  FQTermPref::getInstance()->escapeString_ = "^u[";
+  getAction(FQTermShortcutHelper::COLORCTL_PTT)->setChecked(true);
+  getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM)->setVisible(false);
+}
+
+void FQTermFrame::oldCustomEsc() {
+}
+
+void FQTermFrame::customEsc() {
+  QString strEsc(FQTermPref::getInstance()->escapeString_);
+  DefineEscapeDialog defineEscapeDialog_(strEsc, this);
+  if (defineEscapeDialog_.exec() == 1)
+  {
+    FQTermPref::getInstance()->escapeString_ = strEsc;
+    QAction *pAction = getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM);
+    if (strEsc != QString("") && strEsc != QString("^[^[[") && strEsc != QString("^u["))
+    {
+      QString transStrEsc;
+      transEscapeStr(transStrEsc, strEsc);
+      pAction->setText(transStrEsc);
+      pAction->setVisible(true);
+      pAction->setChecked(true);
+    }
+    else
+    {
+      pAction->setVisible(false);
+    }
+  }
+}
+
+bool FQTermFrame::isDelimiterExistedBefore(const QString& str,
+                                           const std::vector<QString>& existingDelimiters) {
+  for (std::vector<QString>::const_iterator cit = existingDelimiters.begin();
+       cit != existingDelimiters.end();
+       ++cit)
+  {
+    if (str.right(cit->length()) == *cit)
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+int FQTermFrame::isDelimiterExistedAfter(const QString& str,
+                                         const std::vector<QString>& existingDelimiters) {
+  for (std::vector<QString>::const_iterator cit = existingDelimiters.begin();
+       cit != existingDelimiters.end();
+       ++cit)
+  {
+    if (str.left(cit->length()) == *cit)
+    {
+      return cit->length();
+    }
+  }
+  return 0;
+}
+
+bool FQTermFrame::uppercaseCharFollowingCtrl(QString& str,
+                                             int& i,
+                                             const QString& after) {
+  if (after == QString("Ctrl") &&
+      str[i] > 'a' - 1 &&
+      str[i] < 'z' - 1)
+  {
+    str[i] = str[i].toUpper();
+    ++i;
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+
+void FQTermFrame::replaceEscapeString(QString& str,
+                                      const QString& before,
+                                      const QString& after,
+                                      const QString& delimiter,
+                                      const std::vector<QString> *existingDelimiters /* = NULL */) {
+  bool preMatched = false;
+  int i = 0;
+  while (i < str.length())
+  {
+    bool matched = true;
+    for (int j = 0; j < before.length(); ++j)
+    {
+      if (str[i + j] != before[j])
+      {
+        matched = false;
+        break;
+      }
+    }// end of for
+    if (matched)
+    {
+      if (i == 0)
+      {
+        // the matched string is the head of the string
+        str = after + delimiter + str.right(str.length() - before.length());
+        i = after.length() + delimiter.length();
+        bool changed = uppercaseCharFollowingCtrl(str, i, after);
+        preMatched = !changed;
+      }
+      else if (i == str.length() - before.length())
+      {
+        // the matched string is the tail of the string
+        if (existingDelimiters != NULL &&
+            isDelimiterExistedBefore(str.left(i), *existingDelimiters))
+        {
+          preMatched = true;
+        }
+
+        if (preMatched)
+        {
+          str = str.left(i) + after;
+        }
+        else
+        {
+          str = str.left(i) + delimiter + after;
+        }
+        break;
+      }
+      else
+      {
+        // the matched string is at the middle of the string
+        if (existingDelimiters != NULL &&
+            isDelimiterExistedBefore(str.left(i), *existingDelimiters))
+        {
+          preMatched = true;
+        }
+
+        if (preMatched)
+        {
+          str = str.left(i) + after + delimiter + str.right(str.length() - i - before.length());
+          i += after.length() + delimiter.length();
+        }
+        else
+        {
+          str = str.left(i) + delimiter + after + delimiter + str.right(str.length() - i - before.length());
+          i += after.length() + 2 * delimiter.length();
+        }
+        bool changed = uppercaseCharFollowingCtrl(str, i, after);
+        preMatched = !changed;
+      }
+      if (preMatched)
+      {
+        int len;
+        if (existingDelimiters != NULL &&
+            (len = isDelimiterExistedAfter(str.right(str.length() - i), *existingDelimiters)) != 0)
+        {
+          str = str.left(i) + str.right(str.length() - i - len);
+        }
+      }
+    }
+    else
+    {
+      preMatched = false;
+      ++i;
+    }
+  }// end of while
+}
+
+void FQTermFrame::transEscapeStr(QString& target, const QString& source) {
+  const QChar cSpecial(17);
+  target = source;
+  replaceEscapeString(target, QString("^["), QString("ESC"), QString(cSpecial));
+  std::vector<QString> existingDelimiters;
+  existingDelimiters.push_back(QString(cSpecial));
+  replaceEscapeString(target, QString("^"), QString("Ctrl"), QString("+"), &existingDelimiters);
+  target.replace(cSpecial, QChar(' '));
+}
+
+void FQTermFrame::setColor() {
+  windowManager_->activeWindow()->setColor();
+}
+
+void FQTermFrame::refreshScreen() {
+  windowManager_->activeWindow()->forcedRepaintScreen();
+}
+
+void FQTermFrame::uiFont() {
+  bool ok;
+  QFont font = QFontDialog::getFont(&ok, qApp->font());
+
+  if (FQTermPref::getInstance()->openAntiAlias_) {
+    font.setStyleStrategy(QFont::PreferAntialias);
+  }
+
+  if (ok == true) {
+   qApp->setFont(font);
+   //refresh style sheet
+   if (FQTermPref::getInstance()->useStyleSheet_) {
+     refreshStyleSheet();
+   }
+   imageViewer_->adjustItemSize();
+  }
+}
+
+void FQTermFrame::fullscreen() {
+
+
+  if (!(windowState() & Qt::WindowFullScreen)) {
+    menuBar()->hide();
+    toolBarMdiTools_->hide();
+    toolBarMdiConnectTools_->hide();
+    toolBarSetupKeys_->hide();
+    toolBarFonts_->hide();
+    hideScroll();
+    showSwitchBar();
+    showFullScreen();
+  } else {
+    menuBar()->show();
+    toolBarMdiTools_->show();
+    toolBarMdiConnectTools_->show();
+    toolBarSetupKeys_->show();
+    toolBarFonts_->show();
+    emit updateScroll();
+    showSwitchBar();
+    showNormal();
+  }
+
+}
+
+void FQTermFrame::bosscolor() {
+  FQTermPref::getInstance()->isBossColor_ = !FQTermPref::getInstance()->isBossColor_;
+  emit bossColor();
+  getAction(FQTermShortcutHelper::BOSSCOLOR)->setChecked(FQTermPref::getInstance()->isBossColor_);
+}
+
+
+void FQTermFrame::toggleServer(bool on) {
+  FQTermPref::getInstance()->runServer_ = on;
+  if (on) {
+    serverThread_->start();
+  } else {
+    serverThread_->quit();
+    serverThread_->wait(1000);
+  }
+}
+
+void FQTermFrame::themesMenuAboutToShow() {
+  QVector<QChar> vectorShortcutKeys;
+  menuThemes_->clear();
+  QStringList styles = QStyleFactory::keys();
+  for (QStringList::ConstIterator it = styles.begin();
+       it != styles.end(); it++) {
+    QString strTheme = *it;
+    for (int i = 0; i < strTheme.length(); ++i)
+    {
+      if (vectorShortcutKeys.indexOf(strTheme.at(i)) == -1)
+      {
+        vectorShortcutKeys.append(strTheme.at(i));
+        strTheme.insert(i, QChar('&'));
+        break;
+      }
+    }
+    insertThemeItem(strTheme);
+  }
+#ifdef USE_DOTNET_STYLE
+  insertThemeItem("Office");  //javaboy@newsmth.org
+#endif //USE_DOTNET_STYLE
+}
+
+void FQTermFrame::themesMenuActivated() {
+  theme_ = ((QAction*)QObject::sender())->text().remove(QChar('&'));
+  QStyle *style;
+#ifdef USE_DOTNET_STYLE
+  //javaboy@newsmth.org
+  if (theme_ == "Office")
+    style = new DotNetStyle(DotNetStyle::Office);
+  else
+#endif //USE_DOTNET_STYLE
+    style = QStyleFactory::create(theme_);
+  if (style) {
+    qApp->setStyle(style);
+  }
+}
+
+
+
+void FQTermFrame::hideScroll() {
+  FQTermPref::getInstance()->termScrollBarPosition_ = 0;
+  emit updateScroll();
+}
+
+void FQTermFrame::leftScroll() {
+  FQTermPref::getInstance()->termScrollBarPosition_ = 1;
+  emit updateScroll();
+}
+
+void FQTermFrame::rightScroll() {
+  FQTermPref::getInstance()->termScrollBarPosition_ = 2;
+  emit updateScroll();
+}
+
+void FQTermFrame::setSE(const QString& se) {
+  FQTermPref::getInstance()->searchEngine_ = se;
+  config_->setItemValue("preference", "searchengine", se);
+}
+
+void FQTermFrame::setSEGoogle() {
+  setSE("google");
+}
+void FQTermFrame::setSEBaidu(){
+  setSE("baidu");
+}
+void FQTermFrame::setSEYahoo() {
+  setSE("yahoo");
+}
+void FQTermFrame::setSEBing() {
+  setSE("bing");
+}
+void FQTermFrame::setSECustom(){
+  setSE("custom");
+}
+
+void FQTermFrame::showSwitchBar() {
+  isTabBarShown_ = !isTabBarShown_;
+  getAction(FQTermShortcutHelper::SWITCHBAR)->setChecked(isTabBarShown_);
+
+  if (isTabBarShown_) {
+    statusBar()->show();
+  } else {
+    statusBar()->hide();
+  }
+}
+
+void FQTermFrame::setting() {
+  windowManager_->activeWindow()->setting();
+  updateMenuToolBar();
+}
+
+void FQTermFrame::saveSessionSetting() {
+  windowManager_->activeWindow()->saveSetting(false);
+}
+
+void FQTermFrame::defaultSetting() {
+  FQTermConfig *pConf = new FQTermConfig(getPath(USER_CONFIG) + "address.cfg");
+  FQTermParam tmpParam;
+ 
+  if (pConf->hasSection("default")) {
+    loadAddress(pConf, -1, tmpParam);
+  }
+
+  addrDialog set(this, tmpParam, addrDialog::SAVE);
+
+  if (set.exec() == 2) {
+    saveAddress(pConf, -1, set.param());
+    pConf->save(getPath(USER_CONFIG) + "address.cfg");
+  }
+
+  delete pConf;
+}
+
+void FQTermFrame::preference() {
+  prefDialog pref(config_, this);
+  bool styleSheetUsed = FQTermPref::getInstance()->useStyleSheet_;
+
+  if (pref.exec() == 1) {
+    //TODO: refactor
+    loadPref();
+    setUseDock(FQTermPref::getInstance()->openMinimizeToTray_);
+    if (FQTermPref::getInstance()->useStyleSheet_) {
+      loadStyleSheetFromFile(FQTermPref::getInstance()->styleSheetFile_);
+    }
+    else if (styleSheetUsed) {
+      clearStyleSheet();
+    }
+  }
+  emit fontAntiAliasing(FQTermPref::getInstance()->openAntiAlias_);
+}
+
+void FQTermFrame::shortcutSetting() {
+  int act = windowManager_->activeWindowIndex();
+  FQTermShortcutDialog fsd(shortcutHelper_, this);
+  fsd.exec();
+  windowManager_->activateTheWindow(act);
+}
+
+void FQTermFrame::keySetup() {
+  keyDialog keyDlg(config_, this);
+  if (keyDlg.exec() == 1) {
+    updateKeyToolBar();
+  }
+}
+
+
+void FQTermFrame::ipLookup() {
+  IPLookupDialog ipLookupDialog_(this);
+  ipLookupDialog_.exec();
+}
+
+void FQTermFrame::antiIdle() {
+  windowManager_->activeWindow()->toggleAntiIdle();
+  getAction(FQTermShortcutHelper::ANTIIDLE)->setChecked(
+      windowManager_->activeWindow()->getSession()->isAntiIdle());
+}
+
+void FQTermFrame::autoReply() {
+  windowManager_->activeWindow()->toggleAutoReply();
+  getAction(FQTermShortcutHelper::AUTOREPLY)->setChecked(
+      windowManager_->activeWindow()->getSession()->isAutoReply());
+}
+
+void FQTermFrame::viewMessages() {
+  windowManager_->activeWindow()->viewMessages();
+}
+
+void FQTermFrame::enableMouse() {
+  windowManager_->activeWindow()->getSession()->param().isSupportMouse_
+      = !windowManager_->activeWindow()->getSession()->param().isSupportMouse_;
+  getAction(FQTermShortcutHelper::MOUSESUPPORT)->setChecked(
+      windowManager_->activeWindow()->getSession()->param().isSupportMouse_);
+}
+
+void FQTermFrame::viewImages(QString filename, bool raiseViewer) {
+  if (filename.isEmpty()) {
+    filename = FQTermPref::getInstance()->poolDir_;
+  }
+
+  if (raiseViewer) {
+    imageViewer_->scrollTo(filename);
+    if (imageViewer_->isHidden()) {
+      imageViewer_->resize(size() * 3 / 4 + QSize(1,1));
+      imageViewer_->show();
+    }
+    clearFocus();
+    imageViewer_->raise();
+    imageViewer_->activateWindow();
+  } else {
+    imageViewer_->updateImage(filename);
+  }
+}
+
+void FQTermFrame::viewImages() {
+  viewImages(FQTermPref::getInstance()->poolDir_, true);
+}
+
+void FQTermFrame::beep() {
+  windowManager_->activeWindow()->getSession()->param().isBeep_ =
+      !windowManager_->activeWindow()->getSession()->param().isBeep_;
+  getAction(FQTermShortcutHelper::BEEP)->setChecked(windowManager_->activeWindow()->getSession()->param().isBeep_);
+}
+
+void FQTermFrame::reconnect() {
+  FQTermWindow * qtw = windowManager_->activeWindow();
+  if (qtw){
+    qtw->toggleAutoReconnect();
+  }
+}
+
+
+void FQTermFrame::delayedRunScript() {
+  windowManager_->activeWindow()->runScript();
+}
+
+
+void FQTermFrame::runScript() {
+  QTimer::singleShot(1, this, SLOT(delayedRunScript()));
+}
+
+void FQTermFrame::stopScript() {
+  windowManager_->activeWindow()->stopScript();
+}
+
+
+void FQTermFrame::runPyScript() {
+#ifdef HAVE_PYTHON
+  windowManager_->activeWindow()->runPythonScript();
+#endif //HAVE_PYTHON
+}
+
+bool FQTermFrame::event(QEvent *e) {
+
+  static bool shown = false;
+  if (e->type() == QEvent::WindowStateChange) {
+    if ((((QWindowStateChangeEvent*)(e))->oldState() & Qt::WindowMinimized)
+         && !(windowState() & Qt::WindowMinimized)) {
+      shown = true;
+    }
+    if (!(windowState() & Qt::WindowMinimized))
+    {
+      config_->setItemValue("global", "max", (windowState() & Qt::WindowMaximized) ? "1" : "0");
+      config_->setItemValue("global", "fullscreen", (windowState() & Qt::WindowFullScreen) ? "1" : "0");
+    }
+  }
+  if (e->type() == QEvent::Paint && shown) {
+    shown = false;
+    qApp->setActiveWindow(NULL);
+    qApp->setActiveWindow(this);
+  }
+
+  bool res = this->QMainWindow::event(e);
+
+  if (e->type() == QEvent::HoverMove
+      || e->type() == QEvent::MouseMove
+      || e->type() == QEvent::Move) {
+    if (res) {
+      FQ_TRACE("frameEvent", 10) << "Accept event: " << e->type()
+                                 << " " << getEventName(e->type()) << ".";
+    } else {
+      FQ_TRACE("frameEvent", 10) << "Ignore event: " << e->type()
+                                 << " " << getEventName(e->type()) << ".";
+    }
+  } else {
+    if (res) {
+      FQ_TRACE("frameEvent", 9) << "Accept event: " << e->type()
+                                << " " << getEventName(e->type()) << ".";
+    } else {
+      FQ_TRACE("frameEvent", 9) << "Ignore event: " << e->type()
+                                << " " << getEventName(e->type()) << ".";
+    }
+  }
+
+  return res;
+}
+
+void FQTermFrame::keyClicked(int id) {
+  if (windowManager_->activeWindow() == NULL) {
+    return ;
+  }
+
+  QString strItem = QString("key%1").arg(id);
+  QString strTmp = config_->getItemValue("key", strItem);
+
+  if (strTmp[0] == '0') { // key
+    windowManager_->activeWindow()->externInput(strTmp.mid(1));
+  } else if (strTmp[0] == '1') { // script
+    QString scriptFile = strTmp.mid(1).trimmed();
+#ifdef HAVE_PYTHON
+    if (scriptFile.endsWith(".py", Qt::CaseInsensitive))
+      windowManager_->activeWindow()->runPythonScriptFile(scriptFile);
+    else
+#endif
+      windowManager_->activeWindow()->runScript(scriptFile.toAscii());
+  } else if (strTmp[0] == '2') { // program
+    runProgram(strTmp.mid(1));
+  }
+}
+
+void FQTermFrame::addMainTool() {
+  // the main toolbar
+  toolBarMdiTools_ = addToolBar("Main ToolBar");
+  toolBarMdiTools_->setObjectName("Main ToolBar");
+
+  connectButton_ = new QToolButton(toolBarMdiTools_);
+  connectButton_->setIcon(QPixmap(getPath(RESOURCE) + "pic/connect.png"));
+
+  toolBarMdiTools_->addWidget(connectButton_);
+  menuConnect_ = new QMenu(this);
+  //FIXME: autoupdate menu
+  FQ_VERIFY(connect(menuConnect_, SIGNAL(aboutToShow()),
+                    this, SLOT(popupConnectMenu())));
+  connectButton_->setMenu(menuConnect_);
+  connectButton_->setPopupMode(QToolButton::InstantPopup);
+
+  toolBarMdiTools_->addAction(getAction(FQTermShortcutHelper::QUICKLOGIN));
+
+  serverButton_ = new QToolButton(toolBarMdiTools_);
+  serverButton_->setCheckable(true);
+  serverButton_->setIcon(QPixmap(getPath(RESOURCE) + "pic/fqterm_32x32.png"));
+  serverButton_->setChecked(FQTermPref::getInstance()->runServer_);
+  FQ_VERIFY(connect(serverButton_, SIGNAL(toggled(bool)), this, SLOT(toggleServer(bool))));
+  toolBarMdiTools_->addWidget(serverButton_);
+  // custom define
+  toolBarSetupKeys_ = addToolBar("Custom Key");
+  toolBarSetupKeys_->setObjectName("Custom Key");
+
+  // the toolbar
+  toolBarMdiConnectTools_ = addToolBar("BBS operations");
+  toolBarMdiConnectTools_->setObjectName("BBS operations");
+  FQTERM_ADDACTION(toolBarMdiConnectTools_, DISCONNECT, this, disconnect);
+  getAction(FQTermShortcutHelper::DISCONNECT)->setEnabled(false);
+  toolBarMdiConnectTools_->addSeparator();
+
+  //Font Tool Bar
+  toolBarFonts_ = addToolBar("Font ToolBar");
+  toolBarFonts_->setObjectName("Font ToolBar");
+
+  
+
+  // Edit (5)
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::COPY));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::PASTE));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::COPYWITHCOLOR));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::RECTANGLESELECTION));
+  toolBarMdiConnectTools_->addSeparator();
+
+  //Font
+  fontButton_ = new QToolButton(toolBarFonts_);
+  QAction* dummyAction = new QAction(QPixmap(getPath(RESOURCE) + "pic/change_fonts.png"),
+    tr("Set Terminal Fonts"), fontButton_);
+  fontButton_->setDefaultAction(dummyAction);
+  toolBarFonts_->addWidget(fontButton_);
+  fontButton_->setMenu(menuFont_);
+  fontButton_->setPopupMode(QToolButton::InstantPopup);
+
+  toolBarFonts_->addSeparator();
+  englishFontCombo_ = new QFontComboBox(toolBarFonts_);
+  otherFontCombo_ = new QFontComboBox(toolBarFonts_);
+  QLabel *englishFontLabel = new QLabel(toolBarFonts_);
+  englishFontLabel->setPixmap(QPixmap(getPath(RESOURCE) + "pic/english_font.png"));
+  toolBarFonts_->addWidget(englishFontLabel);
+  toolBarFonts_->addWidget(englishFontCombo_);
+  toolBarFonts_->addSeparator();
+  QLabel *otherFontLabel = new QLabel(toolBarFonts_);
+  otherFontLabel->setPixmap(QPixmap(getPath(RESOURCE) + "pic/other_font.png"));
+  toolBarFonts_->addWidget(otherFontLabel);
+  toolBarFonts_->addWidget(otherFontCombo_);
+  FQ_VERIFY(connect(englishFontCombo_, SIGNAL(currentFontChanged(const QFont&)),
+    this, SLOT(comboFontChanged(const QFont&))));
+  FQ_VERIFY(connect(otherFontCombo_, SIGNAL(currentFontChanged(const QFont&)),
+    this, SLOT(comboFontChanged(const QFont&))));
+
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::COLORSETTING));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::ANSICOLOR));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::REFRESHSCREEN));
+  toolBarMdiConnectTools_->addSeparator();
+
+  // Option
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::CURRENTSETTING));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::SAVESETTING));
+  toolBarMdiConnectTools_->addSeparator();
+
+  // Spec (5)
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::COPYARTICLE));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::ANTIIDLE));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::AUTOREPLY));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::VIEWMESSAGE));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::IMAGEVIEWER));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::MOUSESUPPORT));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::BEEP));
+  toolBarMdiConnectTools_->addAction(getAction(FQTermShortcutHelper::AUTORECONNECT));
+
+  //call popupConnectMenu() to enable the shortcuts
+  popupConnectMenu(); 
+
+  
+}
+
+
+QAction* FQTermFrame::getAction(int shortcut) {
+  if (!shortcutHelper_)
+    return NULL;
+  return shortcutHelper_->getAction(shortcut);
+}
+
+
+
+void FQTermFrame::addMainMenu() {
+  menuMain_ = menuBar(); 
+
+  //File Menu
+  menuFile_ = menuMain_->addMenu(tr("&File"));
+
+  FQTERM_ADDACTION(menuFile_, CONNECT, this, connectIt);
+  FQTERM_ADDACTION(menuFile_, DISCONNECT, this, disconnect);
+  menuFile_->addSeparator();
+  FQTERM_ADDACTION(menuFile_, ADDRESSBOOK, this, addressBook);
+  FQTERM_ADDACTION(menuFile_, QUICKLOGIN, this, quickLogin);
+  menuFile_->addSeparator();
+  FQTERM_ADDACTION(menuFile_, EXIT, this, exitFQTerm);
+  getAction(FQTermShortcutHelper::EXIT)->setMenuRole(QAction::QuitRole);
+
+  //Edit Menu
+  QMenu *edit = menuMain_->addMenu(tr("&Edit"));
+
+  FQTERM_ADDACTION(edit, COPY, this, copy);
+  FQTERM_ADDACTION(edit, PASTE, this, paste);
+  edit->addSeparator();
+  FQTERM_ADDACTION(edit, COPYWITHCOLOR, this, copyColor);
+  FQTERM_ADDACTION(edit, RECTANGLESELECTION, this, copyRect);
+  FQTERM_ADDACTION(edit, AUTOCOPYSELECTION, this, autoCopy);
+  FQTERM_ADDACTION(edit, PASTEWORDWRAP, this, wordWrap);
+  edit->addSeparator();
+  FQTERM_ADDACTION(edit, SEARCHIT, this, searchIt);
+  FQTERM_ADDACTION(edit, WEIBOSHARE, this, shareIt);
+  edit->addSeparator();
+  FQTERM_ADDACTION(edit, EXTERNALEDITOR, this, externalEditor);
+  edit->addSeparator();
+  FQTERM_ADDACTION(edit, FASTPOST, this, fastPost);
+  edit->addSeparator();
+
+  QMenu *escapeMenu = edit->addMenu(tr("Control sequence in clipboar&d"));
+  escapeGroup = new QActionGroup(this);
+  FQTERM_ADDACTION(escapeMenu, COLORCTL_NO,this, noEsc);
+  escapeGroup->addAction(getAction(FQTermShortcutHelper::COLORCTL_NO));
+  FQTERM_ADDACTION(escapeMenu, COLORCTL_SMTH,this, escEsc);
+  escapeGroup->addAction(getAction(FQTermShortcutHelper::COLORCTL_SMTH));
+  FQTERM_ADDACTION(escapeMenu, COLORCTL_PTT,this, uEsc);
+  escapeGroup->addAction(getAction(FQTermShortcutHelper::COLORCTL_PTT));
+  FQTERM_ADDACTION(escapeMenu, COLORCTL_OLD_CUSTOM,this, oldCustomEsc);
+  escapeGroup->addAction(getAction(FQTermShortcutHelper::COLORCTL_OLD_CUSTOM));
+  FQTERM_ADDACTION(escapeMenu, COLORCTL_CUSTOM,this, customEsc);
+  escapeGroup->addAction(getAction(FQTermShortcutHelper::COLORCTL_CUSTOM));
+
+  //View menu
+  QMenu *view = menuMain_->addMenu(tr("&View"));
+
+  menuFont_ = view->addMenu(tr("&Font"));
+  menuFont_->setIcon(QPixmap(getPath(RESOURCE) + "pic/change_fonts.png"));
+  view->addMenu(menuFont_);
+  FQTERM_ADDACTION(menuFont_, OTHERFONT, this, setFont);
+  getAction(FQTermShortcutHelper::OTHERFONT)->setData(0);
+  FQTERM_ADDACTION(menuFont_, ENGLISHFONT, this, setFont);
+  getAction(FQTermShortcutHelper::ENGLISHFONT)->setData(1);
+  FQTERM_ADDACTION(view, COLORSETTING, this, setColor);
+  FQTERM_ADDACTION(view, ANSICOLOR, this, toggleAnsiColor);
+  FQTERM_ADDACTION(view, REFRESHSCREEN, this, refreshScreen);
+  view->addSeparator();
+
+  //language menu
+  languageGroup = new QActionGroup(view);
+  languageGroup->setExclusive(true);
+  if (installerList_.isEmpty()) {
+    FQ_TRACE("frame", 0)
+        << "No language menu because of lack of translation files";
+  } else {
+    menuLanguage_ = view->addMenu(tr("&Language"));
+    FQTERM_ADDACTION(menuLanguage_, LANGUAGE_ENGLISH, this, langEnglish);
+    languageGroup->addAction(getAction(FQTermShortcutHelper::LANGUAGE_ENGLISH));
+
+    foreach(TranslatorInstaller* installer, installerList_) {
+      QAction* action = menuLanguage_->addAction(
+          installer->languageName(), installer, SLOT(installTranslator()));
+      action->setCheckable(true);
+      languageGroup->addAction(action);
+    }
+
+  } 
+
+  FQTERM_ADDACTION(view, UIFONT, this, uiFont);
+
+  menuThemes_ = view->addMenu(tr("&Themes"));
+  FQ_VERIFY(connect(menuThemes_, SIGNAL(aboutToShow()), this, SLOT(themesMenuAboutToShow())));
+
+  FQTERM_ADDACTION(view, FULLSCREEN, this, fullscreen);
+  FQTERM_ADDACTION(view, BOSSCOLOR, this, bosscolor);
+
+  view->addSeparator();
+
+  QMenu *scrollMenu = view->addMenu(tr("&ScrollBar"));  
+  scrollGroup = new QActionGroup(this);
+  FQTERM_ADDACTION(scrollMenu, SCROLLBAR_HIDDEN,this, hideScroll);
+  scrollGroup->addAction(getAction(FQTermShortcutHelper::SCROLLBAR_HIDDEN));
+  FQTERM_ADDACTION(scrollMenu, SCROLLBAR_RIGHT,this, rightScroll);
+  scrollGroup->addAction(getAction(FQTermShortcutHelper::SCROLLBAR_RIGHT));
+  FQTERM_ADDACTION(scrollMenu, SCROLLBAR_LEFT,this, leftScroll);
+  scrollGroup->addAction(getAction(FQTermShortcutHelper::SCROLLBAR_LEFT));
+
+  FQTERM_ADDACTION(view, SWITCHBAR, this, showSwitchBar);
+  // Option Menu
+  QMenu *option = menuMain_->addMenu(tr("&Option"));
+
+  FQTERM_ADDACTION(option, CURRENTSETTING, this, setting);
+  FQTERM_ADDACTION(option, SAVESETTING, this, saveSessionSetting);
+  option->addSeparator();
+  FQTERM_ADDACTION(option, DEFAULTSETTING, this, defaultSetting);
+#ifdef Q_OS_MAC
+  FQTERM_ADDACTION(menuFile_, PREFERENCE, this, preference);
+#else
+  FQTERM_ADDACTION(option, PREFERENCE, this, preference);
+#endif
+  getAction(FQTermShortcutHelper::PREFERENCE)->setMenuRole(QAction::PreferencesRole);
+  FQTERM_ADDACTION(option, SHORTCUTSETTING, this, shortcutSetting);
+  option->addSeparator();
+  FQTERM_ADDACTION(option, EDITSCHEMA, this, editSchema);
+  option->addSeparator();
+
+  QMenu *searchEngineMenu = option->addMenu(tr("Searc&h Engine"));
+  searchEngineGroup = new QActionGroup(this);
+  FQTERM_ADDACTION(searchEngineMenu, SEARCH_GOOGLE,this, setSEGoogle);
+  searchEngineGroup->addAction(getAction(FQTermShortcutHelper::SEARCH_GOOGLE));
+  FQTERM_ADDACTION(searchEngineMenu, SEARCH_BAIDU,this, setSEBaidu);
+  searchEngineGroup->addAction(getAction(FQTermShortcutHelper::SEARCH_BAIDU));
+  FQTERM_ADDACTION(searchEngineMenu, SEARCH_BING,this, setSEBing);
+  searchEngineGroup->addAction(getAction(FQTermShortcutHelper::SEARCH_BING));
+  FQTERM_ADDACTION(searchEngineMenu, SEARCH_YAHOO,this, setSEYahoo);
+  searchEngineGroup->addAction(getAction(FQTermShortcutHelper::SEARCH_YAHOO));
+  FQTERM_ADDACTION(searchEngineMenu, SEARCH_CUSTOM,this, setSECustom);
+  searchEngineGroup->addAction(getAction(FQTermShortcutHelper::SEARCH_CUSTOM));
+
+  // Special
+  QMenu *spec = menuMain_->addMenu(tr("&Special"));
+  FQTERM_ADDACTION(spec, COPYARTICLE, this, copyArticle);
+  FQTERM_ADDACTION(spec, ANTIIDLE, this, antiIdle);
+  FQTERM_ADDACTION(spec, AUTOREPLY, this, autoReply);
+  FQTERM_ADDACTION(spec, VIEWMESSAGE, this, viewMessages);
+  FQTERM_ADDACTION(spec, BEEP, this, beep);
+  FQTERM_ADDACTION(spec, MOUSESUPPORT, this, enableMouse);
+  FQTERM_ADDACTION(spec, IMAGEVIEWER, this, viewImages);
+  FQTERM_ADDACTION(spec, IPLOOKUP, this, ipLookup);
+
+  //Script
+  QMenu *script = menuMain_->addMenu(tr("Scrip&t"));
+  FQTERM_ADDACTION(script, RUNSCRIPT, this, runScript);
+  FQTERM_ADDACTION(script, STOPSCRIPT, this, stopScript);
+#ifdef HAVE_PYTHON
+  script->addSeparator();
+  FQTERM_ADDACTION(script, RUNPYTHONSCRIPT, this, runPyScript);
+#endif //HAVE_PYTHON
+
+  //Window menu
+  menuWindows_ = menuMain_->addMenu(tr("&Windows"));
+  FQ_VERIFY(connect(menuWindows_, SIGNAL(aboutToShow()),this, SLOT(windowsMenuAboutToShow())));
+  menuMain_->addSeparator();
+
+  //Help menu
+  QMenu *help = menuMain_->addMenu(tr("&Help"));
+  FQTERM_ADDACTION(help, ABOUT, this, aboutFQTerm);
+  getAction(FQTermShortcutHelper::ABOUT)->setMenuRole(QAction::AboutRole);
+  FQTERM_ADDACTION(help, HOMEPAGE, this, homepage);
+}
+
+void FQTermFrame::updateMenuToolBar() {
+  FQTermWindow *window = windowManager_->activeWindow();
+
+  if (window == NULL) {
+    return ;
+  }
+
+  // update menu
+  getAction(FQTermShortcutHelper::DISCONNECT)->setEnabled(window->isConnected());
+  getAction(FQTermShortcutHelper::COPYWITHCOLOR)->setChecked(window->getSession()->param().isColorCopy_);
+  getAction(FQTermShortcutHelper::RECTANGLESELECTION)->setChecked(window->getSession()->param().isRectSelect_);
+  getAction(FQTermShortcutHelper::AUTOCOPYSELECTION)->setChecked(window->getSession()->param().isAutoCopy_);
+  getAction(FQTermShortcutHelper::PASTEWORDWRAP)->setChecked(window->getSession()->param().isAutoWrap_);
+  getAction(FQTermShortcutHelper::FULLSCREEN)->setChecked(windowState() & Qt::WindowFullScreen);
+  getAction(FQTermShortcutHelper::ANSICOLOR)->setChecked(window->getSession()->param().isAnsiColor_);
+  getAction(FQTermShortcutHelper::ANTIIDLE)->setChecked(window->getSession()->isAntiIdle());
+  getAction(FQTermShortcutHelper::AUTOREPLY)->setChecked(window->getSession()->isAutoReply());
+  getAction(FQTermShortcutHelper::BEEP)->setChecked(window->getSession()->param().isBeep_);
+  getAction(FQTermShortcutHelper::MOUSESUPPORT)->setChecked(window->getSession()->param().isSupportMouse_);
+  getAction(FQTermShortcutHelper::AUTORECONNECT)->setChecked(window->getSession()->param().isAutoReconnect_);
+
+  updateFontCombo();
+}
+
+void FQTermFrame::updateFontCombo() {
+  FQTermWindow *window = windowManager_->activeWindow();
+
+  if (window == NULL) {
+    return ;
+  }
+  englishFontCombo_->blockSignals(true);
+  otherFontCombo_->blockSignals(true);
+  englishFontCombo_->setCurrentFont(window->getScreen()->termFont(true));
+  otherFontCombo_->setCurrentFont(window->getScreen()->termFont(false));
+  englishFontCombo_->blockSignals(false);
+  otherFontCombo_->blockSignals(false);
+}
+
+void FQTermFrame::termFontChange(bool isEnglish, QFont font) {
+  updateFontCombo();
+}
+
+void FQTermFrame::comboFontChanged(const QFont & font) {
+
+  FQTermWindow *window = windowManager_->activeWindow();
+
+  if (window == NULL) {
+    return ;
+  }
+  
+  window->getScreen()->blockSignals(true);
+
+  bool isEnglish = (sender() == (QObject*)englishFontCombo_);
+
+  QString& fontName = isEnglish?
+    window->getSession()->param().englishFontName_:window->getSession()->param().otherFontName_;
+  int& fontSize = isEnglish?
+    window->getSession()->param().englishFontSize_:window->getSession()->param().otherFontSize_;
+  QFontComboBox* combo = isEnglish ? englishFontCombo_ : otherFontCombo_;
+
+  QFont f(combo->currentFont().family(), window->getScreen()->termFont(true).pointSize());
+
+  window->getScreen()->setTermFont(isEnglish, f);
+
+  fontName = f.family();
+  fontSize = f.pointSize();
+
+  window->getScreen()->blockSignals(false);
+
+  window->forcedRepaintScreen();
+}
+
+void FQTermFrame::enableMenuToolBar(bool enable) {
+  getAction(FQTermShortcutHelper::DISCONNECT)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::COPY)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::PASTE)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::COPYWITHCOLOR)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::RECTANGLESELECTION)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::AUTOCOPYSELECTION)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::PASTEWORDWRAP)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::ANSICOLOR)->setEnabled(enable);
+
+  fontButton_->setEnabled(enable);
+  englishFontCombo_->setEnabled(enable);
+  otherFontCombo_->setEnabled(enable);
+  menuFont_->setEnabled(enable);
+
+  getAction(FQTermShortcutHelper::COLORSETTING)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::REFRESHSCREEN)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::CURRENTSETTING)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::SAVESETTING)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::COPYARTICLE)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::ANTIIDLE)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::AUTOREPLY)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::VIEWMESSAGE)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::BEEP)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::MOUSESUPPORT)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::RUNSCRIPT)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::STOPSCRIPT)->setEnabled(enable);
+#ifdef HAVE_PYTHON
+  getAction(FQTermShortcutHelper::RUNPYTHONSCRIPT)->setEnabled(enable);
+#endif 
+  getAction(FQTermShortcutHelper::SEARCHIT)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::WEIBOSHARE)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::EXTERNALEDITOR)->setEnabled(enable);
+  getAction(FQTermShortcutHelper::FASTPOST)->setEnabled(enable);
+}
+
+void FQTermFrame::updateKeyToolBar() {
+  toolBarSetupKeys_->clear();
+  toolBarSetupKeys_->addAction(QPixmap(getPath(RESOURCE) + "pic/setup_shortcuts.png"),
+                               tr("Key Setup"), this, SLOT(keySetup()));
+
+  QString strItem, strTmp;
+  strTmp = config_->getItemValue("key", "num");
+  int num = strTmp.toInt();
+
+  for (int i = 0; i < num; i++) {
+    strItem = QString("name%1").arg(i);
+    strTmp = config_->getItemValue("key", strItem);
+    FQTermToolButton *button =
+        new FQTermToolButton(toolBarSetupKeys_, i, strTmp);
+    button->setText(strTmp);
+    strItem = QString("key%1").arg(i);
+    strTmp = (config_->getItemValue("key", strItem));
+    //TODO: add tool tip here
+    // 		QToolTip::add( button, strTmp.mid(1) );
+    // 		button->addToolTip(strTmp.mid(1));
+
+    strTmp = config_->getItemValue("key", QString("shortcut%1").arg(i));
+    if (!strTmp.isEmpty()) {
+      QAction *act = new QAction(button);
+      act->setShortcut(strTmp);
+      button->addAction(act);
+      FQ_VERIFY(connect(act, SIGNAL(triggered()), button, SLOT(slotClicked())));
+    }
+
+    FQ_VERIFY(connect(button, SIGNAL(buttonClicked(int)),
+                      this, SLOT(keyClicked(int))));
+    toolBarSetupKeys_->addWidget(button);
+  }
+
+
+
+}
+
+
+void FQTermFrame::popupFocusIn(FQTermWindow*) {
+  // bring to font
+  if (isHidden()) {
+    show();
+  }
+  if (isMinimized()) {
+    if (isMaximized()) {
+      showMaximized();
+    } else {
+      showNormal();
+    }
+  }
+  raise();
+  activateWindow();
+}
+
+void FQTermFrame::insertThemeItem(const QString& themeitem) {
+  QAction *idAction;
+
+  idAction = menuThemes_->addAction(themeitem,
+                                    this, SLOT(themesMenuActivated()));
+  idAction->setCheckable(true);
+  idAction->setChecked(themeitem == theme_);
+}
+
+void FQTermFrame::setUseDock(bool use) {
+  if (use == false) {
+    if (tray_) {
+      tray_->hide();
+      delete tray_;
+      tray_ = 0;
+      //delete menuTray_;
+      //menuTray_ = 0;
+    }
+    return ;
+  }
+
+  if (tray_ || !QSystemTrayIcon::isSystemTrayAvailable()) {
+    return ;
+  }
+
+  trayMenu_ = new QMenu;
+  FQ_VERIFY(connect(trayMenu_, SIGNAL(aboutToShow()), SLOT(buildTrayMenu())));
+
+  tray_ = new QSystemTrayIcon(this);
+  tray_->setIcon(QPixmap(getPath(RESOURCE) + "pic/fqterm_tray.png"));
+  tray_->setContextMenu(trayMenu_);
+  FQ_VERIFY(connect(tray_, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
+                    SLOT(trayActived(QSystemTrayIcon::ActivationReason))));
+  tray_->show();
+}
+
+void FQTermFrame::buildTrayMenu() {
+  if (!trayMenu_) {
+    return ;
+  }
+  trayMenu_->clear();
+
+  if (isHidden()) {
+    trayMenu_->addAction(tr("Show"), this, SLOT(trayShow()));
+  } else {
+    trayMenu_->addAction(tr("Hide"), this, SLOT(trayHide()));
+  }
+  trayMenu_->addSeparator();
+  trayMenu_->addAction(tr("About"), this, SLOT(aboutFQTerm()));
+  trayMenu_->addAction(tr("Exit"), this, SLOT(exitFQTerm()));
+}
+
+void FQTermFrame::trayActived(QSystemTrayIcon::ActivationReason reason) {
+  if (reason == QSystemTrayIcon::Context) {
+    return ;
+  }
+  if (!isVisible()) {
+    trayShow();
+  } else {
+    trayHide();
+  }
+}
+
+void FQTermFrame::trayShow() {
+  show();
+  // bring to font
+  if (isHidden()) {
+    show();
+  }
+  if (isMinimized()) {
+    if (isMaximized()) {
+      showMaximized();
+    } else {
+#ifdef Q_OS_MACX
+      showMaximized();
+#else
+      showNormal();
+#endif
+    }
+  }
+  raise();
+  activateWindow();
+  FQTermWindow* window = windowManager_->activeWindow();
+  if (window) {
+    window->forcedRepaintScreen();
+    if (!window->isMaximized()) {
+      windowManager_->refreshAllExcept(window);
+    }
+  }
+}
+
+void FQTermFrame::trayHide() {
+  static bool showTip = true;
+  QString str = config_->getItemValue("global", "traytipshown");
+  if (str == "1") {
+    showTip = false;
+  }
+  hide();
+  if (showTip && tray_) {
+    tray_->showMessage(tr("FQTerm"),
+                      tr("FQTerm will keep running in the system tray.\n"
+                         "To terminate the program, "
+                         "choose exit in the tray menu."));
+    showTip = false;
+    config_->setItemValue("global", "traytipshown", "1");
+  }
+}
+
+void FQTermFrame::buzz(FQTermWindow* window) {
+  if (windowManager_->activeWindow() == window)
+     return;
+  int xp = x();
+  int yp = y();
+  QTime t;
+
+  t.start();
+  for (int i = 32; i > 0;) {
+    if (t.elapsed() >= 1) {
+      int delta = i >> 2;
+      int dir = i &3;
+      int dx = ((dir == 1) || (dir == 2)) ? delta : -delta;
+      int dy = (dir < 2) ? delta : -delta;
+      move(xp + dx, yp + dy);
+      t.restart();
+      i--;
+    }
+  }
+  move(xp, yp);
+}
+
+
+//--------------------------
+//recreate the main menu
+//--------------------------
+void
+FQTermFrame::recreateMenu() {
+
+  if (shortcutHelper_) {
+    shortcutHelper_->retranslateActions();
+  }
+  menuBar()->clear();
+  delete escapeGroup;
+  delete languageGroup;
+  addMainMenu();
+  updateLanguageMenu();
+
+  QString strTmp = QString(saveState().toHex());
+  config_->setItemValue("global", "toolbarstate", strTmp);
+  config_->save(getPath(USER_CONFIG) + "fqterm.cfg");
+
+  delete toolBarMdiTools_;
+  delete toolBarSetupKeys_;
+  delete toolBarMdiConnectTools_;
+  delete toolBarFonts_;
+  delete menuConnect_; 
+  addMainTool();
+  updateKeyToolBar();
+  loadToolBarPosition();
+  if (!windowManager_->activeWindow()) {
+    enableMenuToolBar(false);
+  } else {
+    enableMenuToolBar(true);
+    updateMenuToolBar();
+  }
+  if (FQTermPref::getInstance()->useStyleSheet_) {
+    refreshStyleSheet();
+  }
+}
+
+void FQTermFrame::installTranslator(const QString& lang) {
+  config_->setItemValue("global", "language", lang);
+  config_->save(getPath(USER_CONFIG) + "fqterm.cfg");
+
+  for (int i = 0; i < translatedModule; ++i) {
+    if (translator[i] != 0) {
+      qApp->removeTranslator(translator[i]);
+      delete translator[i];
+      translator[i] = 0;
+    }
+  }
+
+  if (lang != "en_US" && !lang.isEmpty()) {
+    for (int i = 0; i < translatedModule; ++i) {
+      QString dict =
+          getPath(RESOURCE) + "dict/" + qmPrefix[i] + lang + qmPostfix;
+      translator[i] = new QTranslator(0);
+      translator[i]->load(dict);
+      qApp->installTranslator(translator[i]);
+    }
+  }
+
+  emit changeLanguage();
+}
+
+void FQTermFrame::initTranslator() {
+  QString dict_path = getPath(RESOURCE) + "dict/";
+  QDir dictDir(dict_path);
+  QStringList langList;
+
+  for (int i = 0; i < translatedModule; ++i) {
+    translator[i] = 0;
+    QStringList filter;
+    filter << qmPrefix[i] + "*" + qmPostfix;
+    dictDir.setNameFilters(filter);
+    QFileInfoList list = dictDir.entryInfoList();
+
+    FQ_TRACE("translator", 3) << "Found " << list.size()
+                              <<  "  " << qmPostfix
+                              << " file(s) under path "
+                              << dict_path;
+    
+    foreach(QFileInfo info, list){
+      QString language = info.fileName();
+      language = language.mid(
+          qmPrefix[i].length(),
+          language.length() - qmPrefix[i].length() - qmPostfix.length());
+
+      FQ_TRACE("translator", 3) << "Check file " << info.fileName();
+
+      if (!langList.contains(language)) {
+        langList << language;
+        installerList_.append(new TranslatorInstaller(language, this));
+        FQ_TRACE("translator", 3) << "Found translations for " << language;
+      } else {
+        FQ_TRACE("translator", 3) << "Language " << language
+                                  << " is already registered.";
+      }
+    }
+  }
+
+  if (installerList_.empty()) {
+    FQ_TRACE("translator", 0) << "No translations found.";
+  }
+  
+  QString lang = config_->getItemValue("global", "language");
+  if (!langList.contains(lang)) {
+    lang = QLocale::system().name();
+  }
+#if defined(__linux__) || defined(__GLIBC__)
+  if (QLocale::system().language() == QLocale::English)
+    lang = QLocale::system().name();
+#endif
+  installTranslator(lang);
+}
+
+
+void FQTermFrame::clearTranslator() {
+  foreach(TranslatorInstaller* installer, installerList_){
+    delete installer;
+  }
+}
+
+void FQTermFrame::updateLanguageMenu() {
+  QString strTmp = config_->getItemValue("global", "language");
+  int i = 0;
+  foreach(TranslatorInstaller* installer, installerList_){
+    if (installer->languageFormalName() == strTmp) {
+      languageGroup->actions().at(i + 1)->setChecked(true);
+      break;
+    }
+    ++i;
+  }
+  if (!installerList_.isEmpty() &&
+      (strTmp == "en_US" || i == installerList_.size())) {
+    languageGroup->actions().at(0)->setChecked(true);
+  }
+}
+
+void FQTermFrame::setFont() {
+  bool isEnglish = (QAction*)(sender()) == getAction(FQTermShortcutHelper::ENGLISHFONT);
+  windowManager_->activeWindow()->setFont(isEnglish);
+}
+
+void FQTermFrame::refreshStyleSheet()
+{
+  qApp->setStyleSheet(qApp->styleSheet());
+}
+void FQTermFrame::loadStyleSheetFromFile( const QString qssFile )
+{
+  QFile file(qssFile);
+  file.open(QIODevice::ReadOnly);
+  QString qss = file.readAll();
+  qApp->setStyleSheet(qss);
+  file.close();
+}
+
+void FQTermFrame::clearStyleSheet() {
+  qApp->setStyleSheet("");
+}
+
+void FQTermFrame::loadToolBarPosition()
+{
+  //load toolbar setting
+  QString strTmp = config_->getItemValue("global", "toolbarstate");
+  if (!strTmp.isEmpty())
+  {
+    restoreState(QByteArray::fromHex(strTmp.toAscii()));
+  } else {
+    addToolBar(Qt::TopToolBarArea, toolBarMdiConnectTools_);
+    insertToolBar(toolBarMdiConnectTools_,toolBarSetupKeys_);
+    insertToolBar(toolBarSetupKeys_, toolBarMdiTools_);
+    insertToolBar(toolBarMdiTools_, toolBarFonts_);
+  }
+}
+
+void FQTermFrame::toggleAnsiColor() {
+  windowManager_->activeWindow()->getSession()->param().isAnsiColor_
+    = !windowManager_->activeWindow()->getSession()->param().isAnsiColor_;
+  getAction(FQTermShortcutHelper::ANSICOLOR)->setChecked(
+    windowManager_->activeWindow()->getSession()->param().isAnsiColor_);
+  refreshScreen();
+}
+
+bool FQTermFrame::clearUp() {
+  if (!windowManager_->closeAllWindow())
+      return false;
+
+  saveSetting();
+  // clear zmodem and pool if needed
+  if (FQTermPref::getInstance()->needClearZmodemPoolOnClose_) {
+    clearDir(FQTermPref::getInstance()->zmodemDir_);
+    clearDir(FQTermPref::getInstance()->poolDir_);
+    clearDir(FQTermPref::getInstance()->poolDir_ + "shadow-cache/");
+  }
+
+  setUseDock(false);
+
+  return true;
+}
+
+void FQTermFrame::editSchema() {
+
+  schemaDialog schema(this);
+  FQ_VERIFY(connect(&schema, SIGNAL(schemaEdited()),
+                  this, SLOT(schemaUpdated())));
+  schema.exec();
+}
+
+void FQTermFrame::schemaUpdated() {
+  for (int i = 0; i < windowManager_->count(); ++i) {
+    windowManager_->nthWindow(i)->getScreen()->setSchema();
+    windowManager_->nthWindow(i)->forcedRepaintScreen();
+  }
+}
+
+
+void FQTermFrame::globalHotkeyTriggered() {
+  if (isActiveWindow() && !isMinimized() && isVisible())
+  {
+    showMinimized();
+    return;
+  }
+  show();
+  if (config_->getItemValue("global", "fullscreen") == "1")
+    showFullScreen();
+  else if (config_->getItemValue("global", "max") == "1")
+    showMaximized();
+  else 
+    showNormal();
+  raise();
+  activateWindow();
+}
+
+void FQTermFrame::globalHotkeyChanged()
+{
+#ifdef USE_GLOBAL_HOTKEY
+  globalHotkey_->setShortcut(shortcutHelper_->getAction(FQTermShortcutHelper::GLOBAL_SHOW_FQTERM)->shortcut());
+#endif //USE_GLOBAL_HOTKEY
+}
+
+
+
+TranslatorInstaller::TranslatorInstaller(const QString& language,
+                                         FQTermFrame* frame)
+    : language_(language),
+      frame_(frame) {
+  FQTermConfig conf(getPath(USER_CONFIG) + "language.cfg");
+
+  languageName_ = conf.getItemValue("Name", language_);
+  if (languageName_.isEmpty()){
+    languageName_ = QLocale::languageToString(QLocale(language_).language());
+    if (languageName_ == "C") {
+      languageName_ = "Unknown Language";
+    }
+  }
+}
+
+QString TranslatorInstaller::languageName() {
+  return languageName_;
+}
+
+void TranslatorInstaller::installTranslator() {
+  frame_->installTranslator(language_);
+}
+
+QString TranslatorInstaller::languageFormalName() {
+  return language_;
+}
+
+}  // namespace FQTerm
+
+#include "fqterm_frame.moc"
diff --git a/src/fqterm/fqterm_frame.h b/src/fqterm/fqterm_frame.h
new file mode 100644
index 0000000..8adaf49
--- /dev/null
+++ b/src/fqterm/fqterm_frame.h
@@ -0,0 +1,326 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_FRAME_H
+#define FQTERM_FRAME_H
+
+#include <QMainWindow>
+#include <QSystemTrayIcon>
+#include <QMenuBar>
+
+#include <vector>
+
+class QWidget;
+class QLineEdit;
+class QToolButton;
+class QMdiArea;
+class QSignalMapper;
+class QTabBar;
+class QFontDialog;
+class QActionGroup;
+class QString;
+class QFontComboBox;
+class UAOCodec;
+
+#ifdef USE_GLOBAL_HOTKEY
+class QxtGlobalShortcut;
+#endif //USE_GLOBAL_HOTKEY
+
+namespace FQTerm {
+
+class IPLookupDialog;
+class DefineEscapeDialog;
+class FQTermImage;
+class FQTermParam;
+class FQTermConfig;
+class FQTermWndMgr;
+class FQTermWindow;
+class StatusBar;
+class FQTermTimeLabel;
+class TranslatorInstaller;
+class FQTermMiniServerThread;
+class FQTermShortcutHelper;
+
+#ifdef HAVE_PYTHON
+class FQTermPythonHelper;
+#endif //HAVE_PYTHON
+
+class FQTermFrame: public QMainWindow {
+  Q_OBJECT;
+ public:
+  FQTermFrame();
+  ~FQTermFrame();
+
+  void updateMenuToolBar();
+  void enableMenuToolBar(bool);
+
+  void popupFocusIn(FQTermWindow*);
+
+  void viewImages(QString filename, bool raiseViewer);
+  void buzz(FQTermWindow* window = NULL);
+  void installTranslator(const QString& lang);
+  FQTermConfig * config() const { return config_; }
+
+  static const int translatedModule = 4;
+  static const QString qmPrefix[translatedModule];
+  static const QString qmPostfix;
+
+ signals:
+  void bossColor();
+  void updateScroll();
+  void changeLanguage();
+  void fontAntiAliasing(bool);
+
+ protected slots:
+  
+  bool event(QEvent *event);
+
+  void viewImages();
+  bool clearUp();
+
+  // Menu
+  void recreateMenu();
+  void addressBook();
+  void quickLogin();
+  void exitFQTerm();
+
+  void aboutFQTerm();
+  void langEnglish();
+  void defaultSetting();
+  void preference();
+  void shortcutSetting();
+  void runScript();
+  void delayedRunScript(); // to avoid activate recursion guard
+  void stopScript();
+  void runPyScript();
+  void homepage();
+
+  void toggleAnsiColor();
+
+  // Toolbar
+  void keyClicked(int);
+
+  void connectIt();
+  void disconnect();
+  void copy();
+  void paste();
+  void searchIt();
+  void shareIt();
+  void externalEditor();
+  void fastPost();
+  void copyRect();
+  void copyColor();
+  void copyArticle();
+  void autoCopy();
+  void wordWrap();
+  void noEsc();
+  void escEsc();
+  void uEsc();
+  void oldCustomEsc();
+  void customEsc();
+  void hideScroll();
+  void leftScroll();
+  void rightScroll();
+  void setSEGoogle();
+  void setSEBaidu();
+  void setSEYahoo();
+  void setSEBing();
+  void setSECustom();
+  void showSwitchBar();
+  void setFont();
+  void setColor();
+  void refreshScreen();
+  void fullscreen();
+  void bosscolor();
+  void toggleServer(bool on);
+  void uiFont();
+  void antiIdle();
+  void autoReply();
+  void setting();
+  void saveSessionSetting();
+  void viewMessages();
+  void enableMouse();
+  void beep();
+  void reconnect();
+  void keySetup();
+  void ipLookup();
+  void termFontChange(bool isEnglish, QFont font);
+  void comboFontChanged(const QFont & font);
+
+  void themesMenuAboutToShow();
+  void themesMenuActivated();
+  void windowsMenuAboutToShow();
+  void connectMenuActivated();
+  void popupConnectMenu();
+  void trayActived(QSystemTrayIcon::ActivationReason);
+ 
+  //void trayClicked(const QPoint &, int);
+  //void trayDoubleClicked();
+  void trayHide();
+  void trayShow();
+  void buildTrayMenu();
+
+  void reloadConfig();
+
+  void saveSetting();
+  void schemaUpdated();
+  void editSchema();
+ private:
+
+  FQTermWndMgr *windowManager_;
+  // image viewer
+  FQTermImage *imageViewer_;
+
+  FQTermTimeLabel *labelTime_;
+
+  QString theme_;
+
+  QActionGroup *escapeGroup;
+  QActionGroup *languageGroup;
+  QActionGroup *scrollGroup;
+  QActionGroup *searchEngineGroup;
+  QMenu *menuWindows_;
+  QMenu *menuThemes_;
+  QMenu *menuFont_;
+  QMenu *menuFile_;
+  QMenu *menuLanguage_;
+  QMenu *menuConnect_;
+  QSignalMapper* windowMapper_;
+
+  FQTerm::StatusBar *statusBar_;
+
+  QToolButton *serverButton_;
+  QToolButton *connectButton_; 
+  QToolButton *fontButton_;
+  QFontComboBox *englishFontCombo_;
+  QFontComboBox *otherFontCombo_;
+
+  QMenuBar *menuMain_;
+  QToolBar *toolBarMdiConnectTools_;
+  QToolBar *toolBarMdiTools_;
+  QToolBar *toolBarSetupKeys_;
+  QToolBar *toolBarFonts_;
+
+  bool isTabBarShown_;
+
+  QSystemTrayIcon *tray_;
+
+  QMenu *trayMenu_;
+
+  QTranslator * translator[translatedModule];
+  QList<TranslatorInstaller*> installerList_;
+
+  FQTermConfig * config_;
+  FQTermShortcutHelper * shortcutHelper_;
+  QAction* getAction(int shortcut);
+  FQTermMiniServerThread* serverThread_;
+
+  UAOCodec* uaoCodec_;
+
+private:
+  void newWindow(const FQTermParam &param, int index = -1);
+
+  void closeEvent(QCloseEvent*);
+  void selectStyleMenu(int, int);
+  void iniSetting();
+  void loadPref();
+
+  void addMainMenu();
+  void addMainTool();
+
+  void setSE(const QString& se);
+
+  void updateKeyToolBar();
+  void updateFontCombo();
+
+  void loadToolBarPosition();
+
+  bool eventFilter(QObject *, QEvent*);
+
+  void insertThemeItem(const QString&);
+  void setUseDock(bool);
+
+  void initAdditionalActions();
+
+  void initTranslator();
+  void clearTranslator();
+  void connector();
+  void updateLanguageMenu();
+
+  void loadStyleSheetFromFile(const QString qssFile);
+  void refreshStyleSheet();
+  void clearStyleSheet();
+
+  bool isDelimiterExistedBefore(const QString& str,
+                                const std::vector<QString>& existingDelimiters);
+  int isDelimiterExistedAfter(const QString& str,
+                              const std::vector<QString>& existingDelimiters);
+  bool uppercaseCharFollowingCtrl(QString& str,
+                                  int& i,
+                                  const QString& after);
+  void replaceEscapeString(QString& str,
+                           const QString& before,
+                           const QString& after,
+                           const QString& delimiter,
+                           const std::vector<QString> *existingDelimiters = NULL);
+  void transEscapeStr(QString& target, const QString& source);
+
+#ifdef HAVE_PYTHON
+public:
+  FQTermPythonHelper* getPythonHelper() {
+    return pythonHelper_;
+  }
+
+  //protected slots:
+private:
+  FQTermPythonHelper* pythonHelper_;
+#endif //HAVE_PYTHON
+
+#ifdef USE_GLOBAL_HOTKEY
+  QxtGlobalShortcut* globalHotkey_;
+#endif //USE_GLOBAL_HOTKEY

+private slots:
+  void globalHotkeyTriggered();
+  void globalHotkeyChanged();
+};
+
+class TranslatorInstaller : public QObject
+{
+  Q_OBJECT;
+
+public:
+  TranslatorInstaller(const QString& language, FQTermFrame* frame);
+
+  QString languageName();
+  QString languageFormalName();
+public slots:
+  void installTranslator();
+
+protected:
+  QString language_;
+  FQTermFrame* frame_;
+
+  QString languageName_;
+};
+
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_FRAME_H
diff --git a/src/fqterm/fqterm_python.cpp b/src/fqterm/fqterm_python.cpp
new file mode 100644
index 0000000..68b9385
--- /dev/null
+++ b/src/fqterm/fqterm_python.cpp
@@ -0,0 +1,826 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+

+
+
+#include <QCustomEvent>
+#include <QTextStream>
+#include <QApplication>
+#include <QDir>
+#include <QFile>
+#include <QByteArray>
+#include <QMutex>
+#include <QThread>
+#include "fqterm.h"
+#ifdef HAVE_PYTHON

+#include <Python.h>

+#endif
+class SleeperThread : public QThread
+{
+public:
+  static void msleep(unsigned long msecs)
+  {
+    QThread::msleep(msecs);
+  }
+};
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_PYTHON
+
+#include "fqterm_window.h"
+#include "fqterm_buffer.h"
+#include "fqterm_text_line.h"
+#include "fqterm_param.h"
+#include "fqterm_session.h"
+#include "fqterm_python.h"
+#include "fqterm_path.h"
+#include "common.h"
+namespace FQTerm {
+
+/* **************************************************************************
+ *
+ *				Pythons Embedding
+ *
+ * ***************************************************************************/
+
+QString getException() {
+  PyObject *pType = NULL,  *pValue = NULL,  *pTb = NULL,  *pName,  *pTraceback;
+
+  PyErr_Fetch(&pType, &pValue, &pTb);
+
+  pName = PyString_FromString("traceback");
+  pTraceback = PyImport_Import(pName);
+  Py_DECREF(pName);
+
+  if (pTraceback == NULL) {
+    return "General Error in Python Callback";
+  }
+
+  pName = PyString_FromString("format_exception");
+  PyObject *pRes = PyObject_CallMethodObjArgs(pTraceback, pName, pType, pValue,
+                                              pTb, NULL);
+  Py_DECREF(pName);
+
+  Py_DECREF(pTraceback);
+
+  Py_XDECREF(pType);
+  Py_XDECREF(pValue);
+  Py_XDECREF(pTb);
+
+  if (pRes == NULL) {
+    return "General Error in Python Callback";
+  }
+
+  pName = PyString_FromString("string");
+  PyObject *pString = PyImport_Import(pName);
+  Py_DECREF(pName);
+
+  if (pString == NULL) {
+    return "General Error in Python Callback";
+  }
+
+  pName = PyString_FromString("join");
+  PyObject *pErr = PyObject_CallMethodObjArgs(pString, pName, pRes, NULL);
+  Py_DECREF(pName);
+
+  Py_DECREF(pString);
+  Py_DECREF(pRes);
+
+  if (pErr == NULL) {
+    return "General Error in Python Callback";
+  }
+
+  QString str(PyString_AsString(pErr));
+  Py_DECREF(pErr);
+
+  return str;
+}
+
+QString getErrOutputFile(FQTermWindow *lp) {
+  // file name
+  QString str2;
+  str2.setNum(long(lp));
+  str2 += ".err";
+  // path
+  return getPath(USER_CONFIG) + str2;
+}
+
+// copy current artcle for back compatible use only
+// for new coder please use getArticle
+static PyObject *fqterm_copyArticle(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  FQTermWindow *termWindow_ = (FQTermWindow*)lp;
+
+  QStringList strList;
+  QString strArticle;
+  QReadWriteLock& bufferLock = termWindow_->getSession()->getBufferLock();
+  QReadLocker locker(&bufferLock);
+  while (1) {
+    // check it there is duplicated string
+    // it starts from the end in the range of one screen height
+    // so this is a non-greedy match
+    QString strTemp;
+    termWindow_->getSession()->getBuffer()->getTextLineInTerm(0)->getAllPlainText(strTemp);
+    strTemp = strTemp.trimmed();
+    int i = 0;
+    int start = 0;
+    for (QStringList::Iterator it = strList.end();
+         it != strList.begin() &&  i < termWindow_->getSession()->getBuffer()->getNumRows() - 1;  // not exceeeding the last screen
+		 --it, i++) {
+      if (*it != strTemp) {
+        continue;
+      }
+      QStringList::Iterator it2 = it;
+      bool dup = true;
+      // match more to see if its duplicated
+      for (int j = 0; j <= i; j++, it2++) {
+        QString str1;
+        termWindow_->getSession()->getBuffer()->getTextLineInTerm(j)->getAllPlainText(str1);
+        if (*it2 != str1.trimmed()) {
+          dup = false;
+          break;
+        }
+      }
+      if (dup) {
+        // set the start point
+        start = i + 1;
+        break;
+      }
+    }
+    // add new lines
+    for (i = start; i < termWindow_->getSession()->getBuffer()->getNumRows() - 1; i++) {
+      QString tmp;
+      termWindow_->getSession()->getBuffer()->getTextLineInTerm(i)->getAllPlainText(tmp);
+      strList += tmp.trimmed();
+    }
+
+    // the end of article
+    QString testEnd;
+    termWindow_->getSession()->getBuffer()->getTextLineInTerm(termWindow_->getSession()->getBuffer()->getNumRows() - 1)->getAllPlainText(testEnd);
+    if (testEnd.indexOf("%") == -1) {
+      break;
+    }
+    // continue
+    termWindow_->writeString_ts(" ");
+
+    // TODO: fixme
+    if (!termWindow_->getSession()->getWaitCondition().wait(&bufferLock, 10000)) {
+    //  // timeout
+      break;
+    }
+  }
+#if defined(_OS_WIN32_) || defined(Q_OS_WIN32)
+  strArticle = strList.join("\r\n");
+#else
+  strArticle = strList.join("\n");
+#endif
+
+  PyObject *py_text = PyString_FromString(strArticle.toUtf8());
+
+  Py_INCREF(py_text);
+  return py_text;
+}
+
+static PyObject *fqterm_getArticle(PyObject *, PyObject *args) {
+  long lp;
+  int timeout;
+  int succeed = 1;
+
+  if (!PyArg_ParseTuple(args, "li", &lp, &timeout)) {
+    return NULL;
+  }
+  FQTermWindow *termWindow_ = (FQTermWindow*)lp;
+
+  QStringList strList;
+  QString strArticle;
+  QReadWriteLock& bufferLock = termWindow_->getSession()->getBufferLock();
+  while (!bufferLock.tryLockForRead()) {}
+  while (1) {
+    // check it there is duplicated string
+    // it starts from the end in the range of one screen height
+    // so this is a non-greedy match
+    QString strTemp;
+    termWindow_->getSession()->getBuffer()->getTextLineInTerm(0)->getAllPlainText(strTemp);
+    strTemp = strTemp.trimmed();
+
+    int i = 0;
+    int start = 0;
+    for (QStringList::Iterator it = strList.end();
+         it != strList.begin() && i < termWindow_->getSession()->getBuffer()->getNumRows() - 1;  // not exceeeding the last screen
+         --it, i++) {
+      if (it == strList.end() || *it != strTemp) {
+        continue;
+      }
+      QStringList::Iterator it2 = it;
+      bool dup = true;
+      // match more to see if its duplicated
+      for (int j = 0; j <= i && it2 != strList.end(); j++, it2++) {
+        QString str1;
+        termWindow_->getSession()->getBuffer()->getTextLineInTerm(j)->getAllPlainText(str1);
+        if (*it2 != str1.trimmed()) {
+          dup = false;
+          break;
+        }
+      }
+      if (dup) {
+        // set the start point
+        start = i + 1;
+        break;
+      }
+    }
+    // add new lines
+    for (i = start; i < termWindow_->getSession()->getBuffer()->getNumRows() - 1; i++) {
+      QString tmp;
+      termWindow_->getSession()->getBuffer()->getTextLineInTerm(i)->getAllPlainText(tmp);
+      strList += tmp.trimmed();
+    }
+
+    // the end of article
+    QString testEnd;
+    termWindow_->getSession()->getBuffer()->getTextLineInTerm(termWindow_->getSession()->getBuffer()->getNumRows() - 1)->getAllPlainText(testEnd);
+    if (testEnd.indexOf("%") == -1) {
+      break;
+    }
+    // continue
+    termWindow_->writeString_ts(" ");
+
+    // TODO: fixme
+    if (!termWindow_->getSession()->getWaitCondition().wait(&bufferLock, timeout)) { // timeout
+    	succeed = 0;
+    	break;
+    }
+  }
+  bufferLock.unlock();
+  if (succeed)
+    strArticle = strList.join(OS_NEW_LINE);
+
+  PyObject *py_res = Py_BuildValue("si", (const char*)strArticle.toUtf8().data(),
+                                   succeed);
+
+  Py_INCREF(py_res);
+
+  return py_res;
+
+}
+
+static PyObject *fqterm_formatError(PyObject *, PyObject *args) {
+  long lp;
+
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  QString strErr;
+  QString filename = getErrOutputFile((FQTermWindow*)lp);
+
+  QDir d;
+  if (d.exists(filename)) {
+    QFile file(filename);
+    file.open(QIODevice::ReadOnly);
+    QTextStream is(&file);
+    while (!is.atEnd()) {
+      strErr += is.readLine(); // line of text excluding '\n'
+      strErr += '\n';
+    }
+    file.close();
+    d.remove(filename);
+  }
+
+  if (!strErr.isEmpty()) {
+    ((FQTermWindow*)lp)->getPythonErrorMessage() = strErr;
+    // TODO: fixme
+    //qApp->postEvent((FQTermWindow*)lp, new QCustomEvent(PYE_ERROR));
+  } else {
+    // TODO: fixme
+    //qApp->postEvent((FQTermWindow*)lp, new QCustomEvent(PYE_FINISH));
+  }
+
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// caret x
+static PyObject *fqterm_caretX(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+  int x = ((FQTermWindow*)lp)->getSession()->getBuffer()->getCaretColumn();
+  PyObject *py_x = Py_BuildValue("i", x);
+  Py_INCREF(py_x);
+  return py_x;
+}
+
+// caret y
+static PyObject *fqterm_caretY(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+  int y = ((FQTermWindow*)lp)->getSession()->getBuffer()->getCaretRow();
+  PyObject *py_y = Py_BuildValue("i", y);
+  Py_INCREF(py_y);
+  return py_y;
+
+}
+
+// columns
+static PyObject *fqterm_columns(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  int numColumns = ((FQTermWindow*)lp)->getSession()->getBuffer()->getNumColumns();
+  PyObject *py_columns = Py_BuildValue("i", numColumns);
+
+  Py_INCREF(py_columns);
+  return py_columns;
+
+}
+
+// rows
+static PyObject *fqterm_rows(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  int rows = ((FQTermWindow*)lp)->getSession()->getBuffer()->getNumRows();
+  PyObject *py_rows = Py_BuildValue("i", rows);
+
+  Py_INCREF(py_rows);
+  return py_rows;
+}
+
+// sned string to server
+static PyObject *fqterm_sendString(PyObject *, PyObject *args) {
+  char *pstr;
+  long lp;
+
+  if (!PyArg_ParseTuple(args, "ls", &lp, &pstr)) {
+    return NULL;
+  }
+
+  ((FQTermWindow*)lp)->writeRawString_ts(U82U(pstr));
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// input should be utf8.
+// same as above except parsing string first "\n" "^p" etc
+static PyObject *fqterm_sendParsedString(PyObject *, PyObject *args) {
+  char *pstr;
+  long lp;
+  int len;
+
+  if (!PyArg_ParseTuple(args, "ls", &lp, &pstr)) {
+    return NULL;
+  }
+  len = strlen(pstr);
+
+  ((FQTermWindow*)lp)->writeString_ts(U82U(pstr));
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// get text at line
+static PyObject *fqterm_getText(PyObject *, PyObject *args) {
+  long lp;
+  int numRows;
+  if (!PyArg_ParseTuple(args, "li", &lp, &numRows)) {
+    return NULL;
+  }
+  QString str;
+  if (numRows < ((FQTermWindow*)lp)->getSession()->getBuffer()->getNumRows())
+    ((FQTermWindow*)lp)->getSession()->getBuffer()->getTextLineInTerm(numRows)->getAllPlainText(str);
+
+  PyObject *py_text = PyString_FromString(U2U8(str));
+
+  Py_INCREF(py_text);
+  return py_text;
+}
+
+// get text with attributes
+static PyObject *fqterm_getAttrText(PyObject *, PyObject *args) {
+  long lp;
+  int numRows;
+  if (!PyArg_ParseTuple(args, "li", &lp, &numRows)) {
+    return NULL;
+  }
+  
+  QString str;
+  if (numRows < ((FQTermWindow*)lp)->getSession()->getBuffer()->getNumRows())
+    ((FQTermWindow*)lp)->getSession()->getBuffer()->getTextLineInTerm(numRows)->getAllAnsiText(str);
+
+  PyObject *py_text = PyString_FromString(U2U8(str));
+
+  Py_INCREF(py_text);
+  return py_text;
+}
+
+// is host connected
+static PyObject *fqterm_isConnected(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  bool connected = ((FQTermWindow*)lp)->isConnected();
+  PyObject *py_connected = Py_BuildValue("i", connected ? 1 : 0);
+
+  Py_INCREF(py_connected);
+  return py_connected;
+}
+
+// disconnect from host
+static PyObject *fqterm_disconnect(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  ((FQTermWindow*)lp)->disconnect();
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// reconnect to host
+static PyObject *fqterm_reconnect(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  ((FQTermWindow*)lp)->getSession()->reconnect();
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// bbs encoding 0-GBK 1-BIG5
+//FIXME: UTF8 and HKSCS
+static PyObject *fqterm_getBBSCodec(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_codec = PyString_FromString(((FQTermWindow*)lp)
+                                           ->getSession()->param().serverEncodingID_ == 0 ? "GBK" : "Big5");
+  Py_INCREF(py_codec);
+
+  return py_codec;
+}
+
+// host address
+static PyObject *fqterm_getAddress(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_addr = PyString_FromString(((FQTermWindow*)lp)
+                                          ->getSession()->param().hostAddress_.toLocal8Bit());
+  Py_INCREF(py_addr);
+  return py_addr;
+}
+
+// host port number
+static PyObject *fqterm_getPort(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_port = Py_BuildValue("i", ((FQTermWindow*)lp)->getSession()->param().port_);
+  Py_INCREF(py_port);
+  return py_port;
+}
+
+// connection protocol 0-telnet 1-SSH1 2-SSH2
+static PyObject *fqterm_getProtocol(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_port = Py_BuildValue("i", ((FQTermWindow*)lp)
+                                    ->getSession()->param().protocolType_);
+  Py_INCREF(py_port);
+  return py_port;
+}
+
+// key to reply msg
+static PyObject *fqterm_getReplyKey(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_key = PyString_FromString(((FQTermWindow*)lp)
+                                         ->getSession()->param().replyKeyCombination_.toLocal8Bit());
+  Py_INCREF(py_key);
+  return py_key;
+}
+
+// url under mouse
+static PyObject *fqterm_getURL(PyObject *, PyObject *args) {
+  long lp;
+  if (!PyArg_ParseTuple(args, "l", &lp)) {
+    return NULL;
+  }
+
+  PyObject *py_url = PyString_FromString(((FQTermWindow*)lp)->getSession()->getUrl().toUtf8().constData());
+  Py_INCREF(py_url);
+  return py_url;
+}
+
+// preview image link
+static PyObject *fqterm_previewImage(PyObject *, PyObject *args) {
+  long lp;
+  char *url;
+  if (!PyArg_ParseTuple(args, "ls", &lp, &url)) {
+    return NULL;
+  }
+
+  ((FQTermWindow*)lp)->getHttpHelper(url, true);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+}
+
+// convert string from UTF8 to specified encoding
+static PyObject *fqterm_fromUTF8(PyObject *, PyObject *args) {
+  char *str,  *enc;
+  if (!PyArg_ParseTuple(args, "ss", &str, &enc)) {
+    return NULL;
+  }
+  QTextCodec *encodec = QTextCodec::codecForName(enc);
+  QTextCodec *utf8 = QTextCodec::codecForName("utf8");
+
+  PyObject *py_str = PyString_FromString(encodec->fromUnicode(utf8->toUnicode
+                                                              (str)));
+  Py_INCREF(py_str);
+  return py_str;
+}
+
+// convert string from specified encoding to UTF8
+static PyObject *fqterm_toUTF8(PyObject *, PyObject *args) {
+  char *str,  *enc;
+  if (!PyArg_ParseTuple(args, "ss", &str, &enc)) {
+    return NULL;
+  }
+  QTextCodec *encodec = QTextCodec::codecForName(enc);
+  QTextCodec *utf8 = QTextCodec::codecForName("utf8");
+
+  PyObject *py_str = PyString_FromString(utf8->fromUnicode(encodec->toUnicode
+                                                           (str)));
+  Py_INCREF(py_str);
+  return py_str;
+}
+
+static PyObject *fqterm_wait(PyObject *, PyObject *args) {
+  long t;
+  if (!PyArg_ParseTuple(args, "l", &t)) {
+    return NULL;
+  }
+  SleeperThread::msleep(t);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+PyMethodDef fqterm_methods[] =  {
+  {
+    "formatError", (PyCFunction)fqterm_formatError, METH_VARARGS,
+	"get the traceback info"
+  }
+
+  ,
+
+  {
+    "getArticle", (PyCFunction)fqterm_getArticle, METH_VARARGS,
+	"copy current article"
+  }
+
+  ,
+
+  {
+    "copyArticle", (PyCFunction)fqterm_copyArticle, METH_VARARGS,
+	"copy current article (obsolete)"
+  }
+
+  ,
+
+  {
+    "getText", (PyCFunction)fqterm_getText, METH_VARARGS, "get text at line#"
+  }
+
+  ,
+
+  {
+    "getAttrText", (PyCFunction)fqterm_getAttrText, METH_VARARGS,
+	"get attr text at line#"
+  }
+
+  ,
+
+  {
+    "sendString", (PyCFunction)fqterm_sendString, METH_VARARGS,
+	"send string to server"
+  }
+
+  ,
+
+  {
+    "sendParsedString", (PyCFunction)fqterm_sendParsedString, METH_VARARGS,
+	"send string with escape"
+  }
+
+  ,
+
+  {
+    "caretX", (PyCFunction)fqterm_caretX, METH_VARARGS, "caret x"
+  }
+
+  ,
+
+  {
+    "caretY", (PyCFunction)fqterm_caretY, METH_VARARGS, "caret y"
+  }
+
+  ,
+
+  {
+    "columns", (PyCFunction)fqterm_columns, METH_VARARGS, "screen width"
+  }
+
+  ,
+
+  {
+    "rows", (PyCFunction)fqterm_rows, METH_VARARGS, "screen height"
+  }
+
+  ,
+
+  {
+    "isConnected", (PyCFunction)fqterm_isConnected, METH_VARARGS,
+	"connected to server or not"
+  }
+
+  ,
+
+  {
+    "disconnect", (PyCFunction)fqterm_disconnect, METH_VARARGS,
+	"disconnect from server"
+  }
+
+  ,
+
+  {
+    "reconnect", (PyCFunction)fqterm_reconnect, METH_VARARGS, "reconnect"
+  }
+
+  ,
+
+  {
+    "getBBSCodec", (PyCFunction)fqterm_getBBSCodec, METH_VARARGS,
+	"get the bbs encoding, GBK or Big5"
+  }
+
+  ,
+
+  {
+    "getAddress", (PyCFunction)fqterm_getAddress, METH_VARARGS,
+	"get the bbs address"
+  }
+
+  ,
+
+  {
+    "getPort", (PyCFunction)fqterm_getPort, METH_VARARGS, "get the bbs port number"
+  }
+
+  ,
+
+  {
+    "getProtocol", (PyCFunction)fqterm_getProtocol, METH_VARARGS,
+	"get the bbs protocol, 0/1/2 TELNET/SSH1/SSH2"
+  }
+
+  ,
+
+  {
+    "getReplyKey", (PyCFunction)fqterm_getReplyKey, METH_VARARGS,
+	"get the key to reply messages"
+  }
+
+  ,
+
+  {
+    "getURL", (PyCFunction)fqterm_getURL, METH_VARARGS,
+	"get the url string under mouse"
+  }
+
+  ,
+
+  {
+    "previewImage", (PyCFunction)fqterm_previewImage, METH_VARARGS,
+	"preview the image link"
+  }
+
+  ,
+
+  {
+    "fromUTF8", (PyCFunction)fqterm_fromUTF8, METH_VARARGS,
+	"decode from utf8 to string in specified codec"
+  }
+
+  ,
+
+  {
+    "toUTF8", (PyCFunction)fqterm_toUTF8, METH_VARARGS,
+	"decode from string in specified codec to utf8"
+  }
+
+  ,
+
+  {
+    "wait", (PyCFunction)fqterm_wait, METH_VARARGS,
+      "wait for x ms"
+  }
+
+  ,
+
+  {
+    NULL, (PyCFunction)NULL, 0, NULL
+  }
+};
+
+
+
+FQTermPythonHelper::FQTermPythonHelper() 
+	: mainThreadState_(NULL) {
+
+    // initialize Python
+    Py_Initialize();
+	// initialize thread support
+	PyEval_InitThreads();
+	// save a pointer to the main PyThreadState object
+	mainThreadState_ = PyThreadState_Get();
+    // add path
+    PyRun_SimpleString("import sys\n");
+    QString pathCmd;
+    pathCmd = "sys.path.insert(0,'";
+    pathCmd += getPath(RESOURCE)+"script')";
+    PyRun_SimpleString(fq_strdup(pathCmd.toUtf8().data()));
+    
+    Py_InitModule4("fqterm", fqterm_methods,
+			NULL,(PyObject*)NULL,PYTHON_API_VERSION);
+    // release the lock
+    PyEval_ReleaseLock();
+}
+
+FQTermPythonHelper::~FQTermPythonHelper() {
+    // shut down the interpreter
+    PyInterpreterState * mainInterpreterState = mainThreadState_->interp;
+    // create a thread state object for this thread
+    PyThreadState * myThreadState = PyThreadState_New(mainInterpreterState);
+    PyThreadState_Swap(myThreadState);
+    PyEval_AcquireLock();
+    Py_Finalize();
+}
+  
+}  // namespace FQTerm
+
+#endif //HAVE_PYTHON
\ No newline at end of file
diff --git a/src/fqterm/fqterm_python.h b/src/fqterm/fqterm_python.h
new file mode 100644
index 0000000..bad6b04
--- /dev/null
+++ b/src/fqterm/fqterm_python.h
@@ -0,0 +1,51 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_PYTHON_H
+#define FQTERM_PYTHON_H
+
+#ifdef HAVE_PYTHON
+#include "fqterm.h"
+
+namespace FQTerm {
+
+class FQTermWindow;
+extern QString getException();
+extern QString getErrOutputFile(FQTermWindow*);
+extern PyMethodDef fqterm_methods[];
+
+class FQTermPythonHelper
+{
+public:
+  FQTermPythonHelper();
+  ~FQTermPythonHelper();
+  PyThreadState* getPyThreadState() {
+    return mainThreadState_;
+  }
+private:
+  PyThreadState * mainThreadState_;
+};
+
+}  // namespace FQTerm
+
+#endif  // HAVE_PYTHON
+
+#endif  // FQTERM_PYTHON_H
+
diff --git a/src/fqterm/fqterm_screen.cpp b/src/fqterm/fqterm_screen.cpp
new file mode 100644
index 0000000..339e666
--- /dev/null
+++ b/src/fqterm/fqterm_screen.cpp
@@ -0,0 +1,1868 @@
+/****************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <QApplication>
+#include <QPainter>
+#include <QScrollBar>
+#include <QShortcut>
+#include <QTextCharFormat>
+#include <QTimer>
+#include <QWheelEvent>
+#include <QKeySequence>
+#include <QRegion>
+#include <QPolygon>
+
+#include "fqterm_buffer.h"
+#include "fqterm_config.h"
+#include "fqterm_convert.h"
+#include "fqterm_frame.h"
+#include "fqterm_param.h"
+#include "fqterm_screen.h"
+#include "fqterm_session.h"
+#include "fqterm_text_line.h"
+#include "fqterm_window.h"
+#include "fqterm_wndmgr.h"
+#ifdef HAVE_PYTHON
+#include <Python.h>
+#endif //HAVE_PYTHON
+namespace FQTerm {
+/* ------------------------------------------------------------------------ */
+/*                                                                          */
+/*                            Constructor/Destructor                        */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+FQTermScreen::FQTermScreen(QWidget *parent, FQTermSession *session)
+    : QWidget(parent),
+      scrollBarWidth_(15),
+      termBuffer_(session->getBuffer()),
+      cnLetterSpacing_(0.0),
+      spLetterSpacing_(0.0),
+      enLetterSpacing_(0.0),
+      cnFixedPitch_(false),
+      enFixedPitch_(false),
+      hasBackground_(false),
+      backgroundRenderOption_(0),
+      backgroundCoverage_(0),
+      backgroundAlpha_(0),
+      backgroundUseAlpha_(false) {
+  termWindow_ = (FQTermWindow*)parent;
+  session_ = session;
+  param_ = &session->param();
+  paintState_ = System;
+  isCursorShown_ = true;
+  is_light_background_mode_ = false;
+
+  setFocusPolicy(Qt::ClickFocus);
+  setAttribute(Qt::WA_InputMethodEnabled, true);
+  setMouseTracking(true);
+
+  setSchema();
+
+  initFontMetrics();
+
+  FQ_VERIFY(connect(termBuffer_, SIGNAL(bufferSizeChanged()),
+                    this, SLOT(bufferSizeChanged())));
+
+  FQ_VERIFY(connect(termBuffer_, SIGNAL(termSizeChanged(int, int)),
+                    this, SLOT(termSizeChanged(int, int))));
+
+  blinkTimer_ = new QTimer(this);
+  FQ_VERIFY(connect(blinkTimer_, SIGNAL(timeout()), this, SLOT(blinkEvent())));
+
+  cursorTimer_ = new QTimer(this);
+  FQ_VERIFY(connect(cursorTimer_, SIGNAL(timeout()),
+                    this, SLOT(cursorEvent())));
+
+  // the scrollbar
+  scrollBar_ = new QScrollBar(this);
+  scrollBar_->setCursor(Qt::ArrowCursor);
+  bufferStart_ = 0;
+  bufferEnd_ = termBuffer_->getNumRows() - 1;
+  areLinesBlink_ = new bool[bufferEnd_ - bufferStart_ + 1];
+  scrollBar_->setRange(0, 0);
+  scrollBar_->setSingleStep(1);
+  scrollBar_->setPageStep(termBuffer_->getNumRows());
+  scrollBar_->setValue(0);
+  updateScrollBar();
+  FQ_VERIFY(connect(scrollBar_, SIGNAL(valueChanged(int)),
+                    this, SLOT(scrollChanged(int))));
+
+  gotoPrevPage_ = new QShortcut(QKeySequence(tr("Shift+PageUp")),
+                                this, SLOT(prevPage()));
+  gotoNextPage_ = new QShortcut(QKeySequence(tr("Shift+PageDown")),
+                                this, SLOT(nextPage()));
+  gotoPrevLine_ = new QShortcut(QKeySequence(tr("Shift+Up")),
+                                this, SLOT(prevLine()));
+  gotoNextLine_ = new QShortcut(QKeySequence(tr("Shift+Down")),
+                                this, SLOT(nextLine()));
+
+  setAttribute(Qt::WA_OpaquePaintEvent, true);
+
+  // init variable
+  isBlinkScreen_ = false;
+  isBlinkCursor_ = true;
+
+
+  preedit_line_ = new PreeditLine(this, colors_);
+
+  tmp_im_query_ = new QString();
+}
+
+FQTermScreen::~FQTermScreen() {
+  delete [] areLinesBlink_;
+  delete blinkTimer_;
+  delete cursorTimer_;
+  //delete m_pCanvas;
+  //delete m_inputContent;
+
+  delete preedit_line_;
+
+  delete tmp_im_query_;
+}
+
+bool FQTermScreen::event(QEvent *e) {
+  switch(e->type()) {
+    case QEvent::KeyPress:
+    {
+      // forward all key press events to parant (FQTermWindow).
+      return false;
+    }
+  }
+  return this->QWidget::event(e);
+}
+
+// focus event received
+void FQTermScreen::focusInEvent(QFocusEvent*) {
+
+  gotoPrevPage_->setEnabled(true);
+  gotoNextPage_->setEnabled(true);
+  gotoPrevLine_->setEnabled(true);
+  gotoNextLine_->setEnabled(true);
+
+}
+
+// focus out
+void FQTermScreen::focusOutEvent(QFocusEvent*) {
+  gotoPrevPage_->setEnabled(false);
+  gotoNextPage_->setEnabled(false);
+  gotoPrevLine_->setEnabled(false);
+  gotoNextLine_->setEnabled(false);
+}
+
+void FQTermScreen::resizeEvent(QResizeEvent*) {
+  syncBufferAndScreen();
+}
+
+void FQTermScreen::syncBufferAndScreen() {
+  updateScrollBar();
+  updateBackgroundPixmap();
+
+  if (param_->isFontAutoFit_ == 1) {
+    updateFont();
+  } else if (param_->isFontAutoFit_ == 0) { //adjust column/row
+    int cx = clientRectangle_.width() / charWidth_;
+    int cy = clientRectangle_.height() / charHeight_;
+    if (param_->hostType_ == 0) {
+      if (cx < 80) cx = 80;
+      if (cy < 24) cy = 24;
+    } else {
+      if (cx < 10) cx = 10;
+      if (cy < 10) cy = 10;
+    }
+    session_->setTermSize(cx, cy);
+    //session_->writeStr("\0x5f");
+  } else {
+    session_->setTermSize(param_->numColumns_, param_->numRows_);
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+/*	                                                                        */
+/* 	                         Mouse                                          */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+void FQTermScreen::enterEvent(QEvent *e) {
+  QApplication::sendEvent(termWindow_, e);
+}
+
+void FQTermScreen::leaveEvent(QEvent *e) {
+  QApplication::sendEvent(termWindow_, e);
+}
+
+void FQTermScreen::mousePressEvent(QMouseEvent *me) {
+  
+  termWindow_->mousePressEvent(me);
+  setFocus();
+}
+
+void FQTermScreen::mouseMoveEvent(QMouseEvent *me) {
+#ifdef Q_OS_MACX
+  termWindow_->mouseMoveEvent(me);
+#else
+  termWindow_->mouseMoveEvent(me);
+  //QApplication::sendEvent(m_pWindow, me);
+#endif
+}
+
+void FQTermScreen::mouseReleaseEvent(QMouseEvent *me) {
+  termWindow_->mouseReleaseEvent(me);
+  //QApplication::sendEvent(m_pWindow, me);
+}
+
+void FQTermScreen::wheelEvent(QWheelEvent *we) {
+  if (FQTermPref::getInstance()->isWheelSupported_) {
+    QApplication::sendEvent(termWindow_, we);
+  } else {
+    QApplication::sendEvent(scrollBar_, we);
+  }
+}
+
+
+/* ------------------------------------------------------------------------ */
+/*	                                                                        */
+/* 	                                Font                                    */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+void FQTermScreen::initFontMetrics() {
+  //issue 98
+  if (param_->isFontAutoFit_ == 1) {
+    englishFont_ = new QFont(param_->englishFontName_);
+    nonEnglishFont_ = new QFont(param_->otherFontName_);
+
+    updateFont();
+  } else {
+    englishFont_ = new QFont(param_->englishFontName_, qMax(8, param_->englishFontSize_));
+    nonEnglishFont_ = new QFont(param_->otherFontName_, qMax(8, param_->otherFontSize_));
+
+    setFontMetrics();
+  }
+
+  englishFont_->setWeight(QFont::Normal);;
+  nonEnglishFont_->setWeight(QFont::Normal);
+
+  // m_pFont->setStyleHint(QFont::System,
+  //  m_pWindow->m_pFrame->m_pref.bAA ?
+  //    QFont::PreferAntialias : QFont::NoAntialias);
+  updateFixedPitchInfo();
+}
+
+void FQTermScreen::updateFont() {
+  int nPixelSize;
+  int nIniSize =
+      qMax(8, qMin(clientRectangle_.height() / termBuffer_->getNumRows(),
+                   clientRectangle_.width() *2 / termBuffer_->getNumColumns()));
+    //FIXME: WTF????
+  for (nPixelSize = nIniSize - 3; nPixelSize <= nIniSize + 3; nPixelSize++) {
+    englishFont_->setPixelSize(nPixelSize);
+    nonEnglishFont_->setPixelSize(nPixelSize);
+
+    setFontMetrics();
+    if ((termBuffer_->getNumRows() *charHeight_) > clientRectangle_.height() ||
+        (termBuffer_->getNumColumns() *charWidth_) > clientRectangle_.width()) {
+      while (nPixelSize > 5) {
+        nPixelSize--;
+        englishFont_->setPixelSize(nPixelSize);
+        nonEnglishFont_->setPixelSize(nPixelSize);
+
+        setFontMetrics();
+        //changed by dp to get larger font...
+        if ((termBuffer_->getNumRows()*charHeight_) <= clientRectangle_.height()
+            && (termBuffer_->getNumColumns() *charWidth_) <=
+            clientRectangle_.width()) {
+          break;
+        }
+      }
+      break;
+    }
+  }
+  
+  englishFont_->setWeight(QFont::Normal);
+  nonEnglishFont_->setWeight(QFont::Normal);
+  setFontAntiAliasing(FQTermPref::getInstance()->openAntiAlias_);
+}
+
+void FQTermScreen::setFontMetrics() {
+  
+  QFontMetrics nonEnglishFM(*nonEnglishFont_);
+  QFontMetrics englishFM(*englishFont_);
+
+  // FIXME: find a typical character for the current language.
+  int cn = nonEnglishFM.width(QChar(0x4e2D));
+  int en = englishFM.width('W');
+  
+  int pix_size = nonEnglishFont_->pixelSize();
+  while (cn % 2 && pix_size > 10) {
+    nonEnglishFont_->setPixelSize(--pix_size);
+    nonEnglishFM = QFontMetrics(*nonEnglishFont_);
+    cn = nonEnglishFM.width(QChar(0x4e2D));
+  }
+  
+  pix_size = englishFont_->pixelSize();
+  while (2 * en > cn + 1 && pix_size > 5) {
+	  --pix_size;
+	  englishFont_->setPixelSize(pix_size);
+	  englishFM = QFontMetrics(*englishFont_);
+	  en = englishFM.width('W');
+/*    
+#ifndef __APPLE__
+    //FIXME: correctly draw chars with left/right bearing.
+    if ( - englishFM.leftBearing('W') - englishFM.rightBearing('W') > 0) {
+      en +=  - englishFM.leftBearing('W') - englishFM.rightBearing('W');
+    }
+#endif
+*/
+  }
+  
+  charWidth_ = qMax(float(cn) / 2 , float(en));
+
+  charHeight_ = qMax(englishFM.height(), nonEnglishFM.height());
+  charHeight_ += param_->lineSpacing_;
+  //charWidth_ = ceil(qMax(charWidth_, charHeight_ * param_->charRatio_ / 100));
+  charWidth_ += param_->charSpacing_;
+
+  cnLetterSpacing_ = qMax(charWidth_ * 2 - cn, 0.0);
+  enLetterSpacing_ = qMax(charWidth_ - en, 0.0);
+  
+  spLetterSpacing_ = qMax(charWidth_ - englishFM.width(' '), 0.0);
+
+  fontAscent_ = qMax(englishFM.ascent(), nonEnglishFM.ascent());
+  fontDescent_ = qMax(englishFM.descent(), nonEnglishFM.descent());
+
+  FQ_TRACE("font", 4) << "\nNon-English font:"
+                      << "\nheight: " << nonEnglishFM.height()
+                      << "\nascent: " << nonEnglishFM.ascent()
+                      << "\ndescent: " << nonEnglishFM.descent();
+                      
+
+  FQ_TRACE("font", 4) << "\nEnglish font:"
+                      << "\nheight: " << englishFM.height()
+                      << "\nascent: " << englishFM.ascent()
+                      << "\ndescent: " << englishFM.descent();
+                      
+  updateFixedPitchInfo();
+}
+
+/* ------------------------------------------------------------------------ */
+/*	                                                                        */
+/* 	                               Colors                                   */
+/*	                                                                        */
+/* ------------------------------------------------------------------------ */
+void FQTermScreen::setSchema() {
+  // the default color table
+  colors_[0] = Qt::black;
+  colors_[1] = Qt::darkRed;
+  colors_[2] = Qt::darkGreen;
+  colors_[3] = Qt::darkYellow;
+  colors_[4] = Qt::darkBlue;
+  colors_[5] = Qt::darkMagenta;
+  colors_[6] = Qt::darkCyan;
+  colors_[7] = Qt::darkGray;
+  colors_[8] = Qt::gray;
+  colors_[9] = Qt::red;
+  colors_[10] = Qt::green;
+  colors_[11] = Qt::yellow;
+  colors_[12] = Qt::blue;
+  colors_[13] = Qt::magenta;
+  colors_[14] = Qt::cyan;
+  colors_[15] = Qt::white;
+
+  
+  hasBackground_ = false;
+  // if we have schema defined
+  if (QFile::exists(param_->schemaFileName_)) {
+    FQTermConfig *pConf = new FQTermConfig(param_->schemaFileName_);
+    for (int i = 0; i < 16; ++i) {
+      colors_[i].setNamedColor(pConf->getItemValue("color", QString("color%1").arg(i)));
+    }
+    originBackgroundPixmap_ = QPixmap(pConf->getItemValue("image", "name"));
+    //0 -- none 1 -- image
+    hasBackground_ = pConf->getItemValue("background", "type").toInt() ? 1 : 0;
+    backgroundRenderOption_ = pConf->getItemValue("image", "render").toInt();
+    backgroundCoverage_ = pConf->getItemValue("image", "cover").toInt();
+    backgroundUseAlpha_ = pConf->getItemValue("image", "usealpha").toInt();
+    backgroundAlpha_ = pConf->getItemValue("image", "alpha").toInt();
+
+    delete pConf;
+  }
+
+  // override schema using user defined Fg/Bg color
+  colors_[0] = param_->backgroundColor_;
+  colors_[7] = param_->foregroundColor_;
+}
+
+/* ------------------------------------------------------------------------ */
+/*	                                                                        */
+/*                  	Scrollbar                                           */
+/*                                                                          */
+/* ------------------------------------------------------------------------*/
+void FQTermScreen::prevPage() {
+  scrollLine(-termBuffer_->getNumRows());
+  setPaintState(NewData);
+  update();
+}
+
+void FQTermScreen::nextPage() {
+  scrollLine(termBuffer_->getNumRows());
+  setPaintState(NewData);
+  update();
+}
+
+void FQTermScreen::prevLine() {
+  scrollLine(-1);
+  setPaintState(NewData);
+  update();
+}
+
+void FQTermScreen::nextLine() {
+  scrollLine(1);
+  setPaintState(NewData);
+  update();
+}
+
+void FQTermScreen::scrollLine(int delta) {
+  bufferStart_ += delta;
+
+  if (bufferStart_ < 0) {
+    bufferStart_ = 0;
+    return ;
+  }
+  if (bufferStart_ > termBuffer_->getNumLines() - termBuffer_->getNumRows()) {
+    bufferStart_ = termBuffer_->getNumLines() - termBuffer_->getNumRows();
+    return ;
+  }
+
+  scrollBar_->setValue(bufferStart_);
+  bufferEnd_ = bufferStart_ + termBuffer_->getNumRows() - 1;
+
+  // notify session
+  session_->setScreenStart(bufferStart_);
+
+  for (int i = bufferStart_; i <= bufferEnd_; i++) {
+    session_->setLineAllChanged(i);
+  }
+}
+
+void FQTermScreen::scrollChanged(int value) {
+  if (bufferStart_ == value) {
+    return ;
+  }
+
+  if (value < 0) {
+    value = 0;
+  }
+  if (value > termBuffer_->getNumLines() - termBuffer_->getNumRows()) {
+    value = termBuffer_->getNumLines() - termBuffer_->getNumRows();
+  }
+
+  bufferStart_ = value;
+  bufferEnd_ = value + termBuffer_->getNumRows() - 1;
+
+  // notify session
+  session_->setScreenStart(bufferStart_);
+
+  for (int i = bufferStart_; i <= bufferEnd_; i++) {
+    //termBuffer_->at(i)->setChanged(-1, -1);
+    session_->setLineAllChanged(i);
+  }
+
+  setPaintState(NewData);
+  update();
+}
+
+void FQTermScreen::updateScrollBar() {
+  int numLeftPixels = 0; // ߾
+  int numUpPixels = 0; // ϱ߾
+
+  switch (FQTermPref::getInstance()->termScrollBarPosition_) {
+    case 0:
+      scrollBar_->hide();
+      clientRectangle_ = QRect(numLeftPixels, numUpPixels,
+                               rect().width() - numLeftPixels,
+                               rect().height() - numUpPixels);
+      break;
+    case 1:
+      // LEFT
+      scrollBar_->setGeometry(0, 0, scrollBarWidth_, rect().height());
+      scrollBar_->show();
+      clientRectangle_ = QRect(scrollBarWidth_ + numLeftPixels, numUpPixels,
+                               rect().width() - scrollBarWidth_ - numLeftPixels,
+                               rect().height() - numUpPixels);
+      break;
+    case 2:
+      // RIGHT
+      scrollBar_->setGeometry(rect().width() - scrollBarWidth_, 0,
+                              scrollBarWidth_, rect().height());
+      scrollBar_->show();
+      clientRectangle_ = QRect(numLeftPixels, numUpPixels,
+                               rect().width() - scrollBarWidth_ - numLeftPixels,
+                               rect().height() - numUpPixels);
+      break;
+  }
+  setPaintState(Repaint);
+  update();
+}
+
+void FQTermScreen::bufferSizeChanged() {
+  FQ_VERIFY(disconnect(scrollBar_, SIGNAL(valueChanged(int)),
+                       this, SLOT(scrollChanged(int))));
+  scrollBar_->setRange(0, termBuffer_->getNumLines() - termBuffer_->getNumRows());
+  scrollBar_->setSingleStep(1);
+  scrollBar_->setPageStep(termBuffer_->getNumRows());
+
+  // FIXME: should not always move scroll bar to the bottom when
+  // buffer size is changed.
+  scrollBar_->setValue(termBuffer_->getNumLines() - termBuffer_->getNumRows());
+
+  bufferStart_ = scrollBar_->value();
+  bufferEnd_ = scrollBar_->value() + termBuffer_->getNumRows() - 1;
+
+  // notify session
+  session_->setScreenStart(bufferStart_);
+
+  FQ_VERIFY(connect(scrollBar_, SIGNAL(valueChanged(int)),
+                    this, SLOT(scrollChanged(int))));
+
+  delete [] areLinesBlink_;
+  areLinesBlink_ = new bool[bufferEnd_ - bufferStart_ + 1];
+
+  scrollLine(0);
+}
+
+void FQTermScreen::termSizeChanged(int column, int row) {
+  FQ_TRACE("term", 3) << "The term size is changed to " << column << "x" << row;
+  syncBufferAndScreen();
+  bufferSizeChanged();
+  this->setPaintState(Repaint);
+  this->repaint();
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                          */
+/* 	                          Display	                                    */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+//set pixmap background
+
+void FQTermScreen::updateBackgroundPixmap() {
+  if (!hasBackground_)
+    return;
+  
+  switch (backgroundRenderOption_) {
+    case 0:
+      //tile
+      {
+      backgroundPixmap_ = QPixmap(clientRectangle_.size());
+      QPainter painter(&backgroundPixmap_);
+      painter.drawTiledPixmap(backgroundPixmap_.rect(), originBackgroundPixmap_);
+      }
+      break;
+    case 1:
+      //center
+      {
+      backgroundPixmap_ = QPixmap(clientRectangle_.size());
+      backgroundPixmap_.fill(colors_[0]);
+      QPainter painter(&backgroundPixmap_);
+      int x = (backgroundPixmap_.size() - originBackgroundPixmap_.size()).width() / 2;
+      int y = (backgroundPixmap_.size() - originBackgroundPixmap_.size()).height() / 2;
+      painter.drawPixmap(x, y, originBackgroundPixmap_);
+      }
+      break;
+    case 2:
+      //stretch
+      backgroundPixmap_ = originBackgroundPixmap_.scaled(clientRectangle_.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+      break;
+  }
+  /*
+  hasBackground_ = false;
+  backgroundPixmap_ = pixmap;
+  backgroundPixmapType_ = nType;
+  QPalette palette;
+
+  switch (nType) {
+    case 0:
+      // none
+      palette.setColor(backgroundRole(), colors_[0]);
+      setPalette(palette);
+      break;
+    case 1:
+      //{ // transparent{}
+      break;
+    case 2:
+      // tile
+      if (!pixmap.isNull())
+        palette.setBrush(backgroundRole(), QBrush(pixmap));
+      setPalette(palette);
+      // 				updateBackgroundPixmap( pixmap );
+      hasBackground_ = true;
+      break;
+      //}
+    case 3:
+      // center
+      if (!pixmap.isNull()) {
+        QPixmap pxmBg = QPixmap(size());
+        QPainter painter(&pxmBg);
+        pxmBg.fill(colors_[0]);
+        painter.drawPixmap((size().width() - pixmap.width()) / 2,
+                           (size().height() - pixmap.height()) / 2,
+                           pixmap.width(), pixmap.height(), pixmap);
+        palette.setBrush(backgroundRole(), QBrush(pxmBg));
+        setPalette(palette);
+        // 				updateBackgroundPixmap(pxmBg);
+        hasBackground_ = true;
+        break;
+      }
+    case 4:
+      // stretch
+      if (!pixmap.isNull()) {
+        float sx = (float)size().width() / pixmap.width();
+        float sy = (float)size().height() / pixmap.height();
+        QMatrix matrix;
+        matrix.scale(sx, sy);
+        palette.setBrush(backgroundRole(), QBrush(pixmap.transformed(matrix)));
+        setPalette(palette);
+        // 				updateBackgroundPixmap(pixmap.transformed( matrix ));
+        hasBackground_ = true;
+        break;
+      }
+    default:
+      palette.setColor(backgroundRole(), colors_[0]);
+      setPalette(palette);
+      // 			setBackgroundColor( m_color[0] );
+
+  }
+  */
+}
+
+void FQTermScreen::cursorEvent() {
+  if (isBlinkCursor_) {
+    setPaintState(Cursor);
+    isCursorShown_ = !isCursorShown_;
+    update();
+  }
+}
+
+void FQTermScreen::blinkEvent() {
+  if (hasBlinkText_) {
+    isBlinkScreen_ = !isBlinkScreen_;
+    setPaintState(Blink);
+    update();
+  }
+}
+
+void FQTermScreen::paintEvent(QPaintEvent *pe) {
+  FQ_TRACE("screen", 8) << "paintEvent " << pe->rect().x() << "," << pe->rect().y() << " " 
+      << pe->rect().width() << "x"  << pe->rect().height();
+  QPainter painter(this);
+  painter.setRenderHint(QPainter::Antialiasing, FQTermPref::getInstance()->openAntiAlias_);
+  painter.setRenderHint(QPainter::TextAntialiasing, FQTermPref::getInstance()->openAntiAlias_);
+  if (paintState_ == System) {
+    repaintScreen(pe, painter);
+    return;
+  }
+
+  if (testPaintState(Repaint)) {
+      FQ_TRACE("screen", 8) << "paintEvent " << "repaint";
+      repaintScreen(pe, painter);
+      clearPaintState(Repaint);
+  }
+
+  if (testPaintState(NewData)) {
+      if (termBuffer_->isLightBackgroundMode() != is_light_background_mode_) {
+            FQ_TRACE("screen", 8) << "paintEvent " << "new data repaint";
+        is_light_background_mode_ = termBuffer_->isLightBackgroundMode();
+        if (is_light_background_mode_) {
+          colors_[0] = param_->foregroundColor_;
+          colors_[7] = param_->backgroundColor_;
+        } else {
+          colors_[0] = param_->backgroundColor_;
+          colors_[7] = param_->foregroundColor_;
+        }
+        repaintScreen(pe, painter);
+      } else {      
+            FQ_TRACE("screen", 8) << "paintEvent " << "new data refresh";
+        refreshScreen(painter);
+      }
+
+      clearPaintState(NewData);
+  }
+
+  if (testPaintState(Blink)) {
+    FQ_TRACE("screen", 8) << "paintEvent " << "blink";
+      blinkScreen(painter);
+      clearPaintState(Blink);
+  }
+
+  if (testPaintState(Cursor)) {
+    FQ_TRACE("screen", 8) << "paintEvent " << "cursor";
+      updateCursor(painter);
+      clearPaintState(Cursor);
+  }
+
+  if (testPaintState(Widget)) {
+      updateWidgetRect(painter);
+      clearPaintState(Widget);
+  }
+}
+
+void FQTermScreen::blinkScreen(QPainter &painter) {
+  painter.setBackground(QBrush(colors_[0]));
+
+  for (int index = bufferStart_; index <= bufferEnd_; index++) {
+    if (areLinesBlink_[index - bufferStart_]) {
+      const FQTermTextLine *pTextLine = termBuffer_->getTextLineInBuffer(index);
+      uint linelength = pTextLine->getWidth();
+      const unsigned char *attr = pTextLine->getAttributes();
+      for (uint i = 0; i < linelength; ++i) {
+        if (GETBLINK(attr[i])) {
+          int startx = i;
+          while (i < linelength && GETBLINK(attr[i])) {
+            ++i;
+          }
+          drawLine(painter, index, startx, i, false);
+        }
+      }
+    }
+  }
+}
+
+void FQTermScreen::updateCursor(QPainter &painter) {
+  if (termBuffer_->getCaretColumn() >= termBuffer_->getNumColumns()) {
+    // we only allow the cursor located beyond the terminal screen temporarily.
+    // just ignore this.
+    return;
+  }
+
+  bool isCursorShown = isCursorShown_;
+  if (FQTermPref::getInstance()->isBossColor_) {
+    isCursorShown = true;
+  }
+
+  if (termBuffer_->getCaretLine() <= bufferEnd_
+      && termBuffer_->getCaretLine() >= bufferStart_) {
+
+    if (!isCursorShown) {
+      const FQTermTextLine *pTextLine
+          = termBuffer_->getTextLineInBuffer(termBuffer_->getCaretLine());
+      if ((int)pTextLine->getWidth() > termBuffer_->getCaretColumn()) {
+        int startx = pTextLine->getCellBegin(termBuffer_->getCaretColumn());
+        int endx = pTextLine->getCellEnd(termBuffer_->getCaretColumn() + 1);
+        if ((int)pTextLine->getWidth() > endx) {
+          endx = pTextLine->getCellEnd(endx + 1);
+        }
+        drawLine(painter, termBuffer_->getCaretLine(), startx, endx,
+                 termBuffer_->getCaretLine());
+      } else {
+        //painter.fillRect(mapToRect(termBuffer_->getCaretColumn(), termBuffer_->getCaretLine(), 1, 1),colors_[0]);
+        drawBackground(painter, mapToRect(termBuffer_->getCaretColumn(),termBuffer_->getCaretLine(), 1, 1), 0);
+      }
+      return;
+    }
+
+    QPoint pt = mapToPixel(QPoint(termBuffer_->getCaretColumn(),
+                                  termBuffer_->getCaretLine()));
+    switch (param_->cursorType_) {
+      case 0:
+        // block
+        {
+          int x = termBuffer_->getCaretColumn();
+          int y = termBuffer_->getCaretLine();
+          const FQTermTextLine *pTextLine = termBuffer_->getTextLineInBuffer(y);
+          if ((int)pTextLine->getWidth() > x) {
+
+            int startx = pTextLine->getCellBegin(x);
+            int endx = pTextLine->getCellEnd(x + 1);
+
+            drawLine(painter, termBuffer_->getCaretLine(), startx, endx,
+                     termBuffer_->getCaretLine());
+
+            QRect rect = mapToRect(startx, termBuffer_->getCaretLine(), 1, 1);
+            rect.translate(0, 0);
+            painter.fillRect(rect, colors_[7]);
+          } else {
+            QRect rect = mapToRect(termBuffer_->getCaretColumn(),
+                                   termBuffer_->getCaretLine(), 1, 1);
+            rect.translate(0, 0);
+            painter.fillRect(rect,
+                             colors_[7]);
+          }
+        }
+        break;
+      case 1:
+        // underline
+        painter.fillRect(pt.x(), pt.y() + 9 * charHeight_ / 10, charWidth_,
+                         charHeight_ / 10, colors_[7]);
+        break;
+      case 2:
+        // I type
+        painter.fillRect(pt.x(), pt.y() + 1, charWidth_ / 5, charHeight_ - 1,
+                         colors_[7]);
+        break;
+      default:
+        painter.fillRect(pt.x(), pt.y()+1,
+                         charWidth_, charHeight_ - 1, colors_[7]);
+    }
+  }
+}
+
+
+// refresh the screen when
+//	1. received new contents form server
+//	2. scrolled by user
+void FQTermScreen::refreshScreen(QPainter &painter) {
+  FQ_FUNC_TIMER("screen_paint", 5);
+
+  if (cursorTimer_->isActive()) {
+    cursorTimer_->stop();
+  }
+
+  if (blinkTimer_->isActive()) {
+    blinkTimer_->stop();
+  }
+
+  hasBlinkText_ = false;
+  isCursorShown_ = true;
+
+  for (int index = bufferStart_; index <= bufferEnd_; index++) {
+
+    FQ_VERIFY(index < termBuffer_->getNumLines());
+
+    const FQTermTextLine *pTextLine = termBuffer_->getTextLineInBuffer(index);
+
+    if (pTextLine->hasBlink()) {
+      hasBlinkText_ = true;
+      areLinesBlink_[index - bufferStart_] = true;
+    } else {
+      areLinesBlink_[index - bufferStart_] = false;
+    }
+
+    unsigned int startx, endx;
+    if (!pTextLine->getDirtyCells(startx, endx)) {
+      continue;
+    }
+
+    /*
+      Finally get around this for pku & ytht, don't know why some weird things
+      happened when only erase and draw the changed part.
+    */
+    startx = pTextLine->getCellBegin(startx);
+
+    int len = -1;
+    if ((int)endx != -1) {
+      len = endx - startx;
+    } else {
+      len = pTextLine->getMaxCellCount() - startx;
+    }
+
+    QRect rect = mapToRect(startx, index, len, 1);
+    
+    //painter.fillRect(rect ,QBrush(colors_[0]));
+    drawBackground(painter, rect, 0);
+    
+    drawLine(painter, index, startx, endx);
+
+    session_->clearLineChanged(index);
+  }
+
+  updateMicroFocus();
+  if (termWindow_->isConnected()) {
+    updateCursor(painter);
+  }
+ 
+
+  if (termWindow_->isConnected()) {
+    cursorTimer_->start(1000);
+  }
+
+  if (hasBlinkText_) {
+    blinkTimer_->start(1000);
+  }
+}
+
+void FQTermScreen::repaintScreen(QPaintEvent *pe, QPainter &painter) {
+  FQ_FUNC_TIMER("screen_paint", 5);
+
+  //painter.setBackground(QBrush(colors_[0]));
+
+  FQ_TRACE("screen", 5) << "Client area: " << pe->rect().width()
+                        << "x" << pe->rect().height();
+
+  QRect rect = pe->rect().intersect(clientRectangle_);
+  //painter.eraseRect(rect);
+  drawBackground(painter, rect, 0);
+  QPoint tlPoint = mapToChar(QPoint(rect.left(), rect.top()));
+
+  QPoint brPoint = mapToChar(QPoint(rect.right(), rect.bottom()));
+
+  for (int y = tlPoint.y(); y <= brPoint.y(); y++) {
+    drawLine(painter, y);
+  }
+  if (termWindow_->getUrlStartPoint() != termWindow_->getUrlEndPoint()) {
+    drawUnderLine(painter, termWindow_->getUrlStartPoint(), termWindow_->getUrlEndPoint());
+  }
+
+
+}
+
+/////////////////////////////////////////////////
+//TODO: change to a more powerful function
+FQTermScreen::TextRenderingType FQTermScreen::charRenderingType(const QChar& c) {
+  if (c == ' ') return HalfAndSpace;
+  if (c.unicode() > 0x7f && c.unicode() <= 0x2dff) {
+    return FullAndAlign;
+  } else if (c.unicode() > 0x2dff) {
+    if (cnFixedPitch_)
+        return FullNotAlign;
+    else
+        return FullAndAlign;
+  }
+  return HalfAndAlign;
+}
+
+static bool isColorBlock(const QChar& c) {
+  if (!FQTermPref::getInstance()->isAnsciiEnhance_) return false;
+  return ((c.unicode() >= 0x2581 && c.unicode() <= 0x258f) || 
+          (c.unicode() >= 0x25e2 && c.unicode() <= 0x25e5));
+}
+
+/////////////////////////////////////////////////
+// draw a line with the specialAtter if given.
+// modified by hooey to draw part of the line.
+void FQTermScreen::drawLine(QPainter &painter, int index, int startx, int endx,
+                            bool complete) {
+  FQ_ASSERT(index < termBuffer_->getNumLines());
+
+  const FQTermTextLine *pTextLine = termBuffer_->getTextLineInBuffer(index);
+  const unsigned char *color = pTextLine->getColors();
+  const unsigned char *attr = pTextLine->getAttributes();
+
+  uint linelength = pTextLine->getWidth();
+  bool isSessionSelected = session_->isSelectedMenu(index);
+  bool isTransparent = isSessionSelected && param_->menuType_ == 2;
+
+  menuRect_ = QRect();
+  QString cstrText;
+
+  if (startx < 0) {
+    startx = 0;
+  }
+
+  if (endx > (long)linelength || endx < 0) {
+    endx = linelength;
+  }
+
+  if (complete == true && isSessionSelected) {
+    menuRect_ = drawMenuSelect(painter, index);
+    startx = 0;
+    endx = linelength;
+  }
+
+  startx = pTextLine->getCellBegin(startx);
+  endx = pTextLine->getCellEnd(endx);
+
+  bool isMonoSpace = true;
+  if (!cnFixedPitch_
+    || !enFixedPitch_) {
+    isMonoSpace = false;
+  }
+  
+
+  
+  for (unsigned i = startx; (long)i < endx;) {
+    startx = i;
+    unsigned char tempcp = color[i];
+    unsigned char tempea = attr[i];
+    unsigned cell_begin = pTextLine->getCellBegin(startx);  
+    unsigned cell_end = pTextLine->getCellEnd(cell_begin + 1);
+    TextRenderingType temprt;
+    cstrText.clear();
+    pTextLine->getPlainText(cell_begin, cell_end, cstrText);
+    temprt = charRenderingType(cstrText[0]);
+    bool color_block = isColorBlock(cstrText[0]);
+
+    bool bSelected = termBuffer_->isSelected(
+        QPoint(i, index), param_->isRectSelect_);
+
+    // get str of the same attribute
+    while ((long)i < endx && tempcp == color[i] && tempea == attr[i] &&
+            bSelected == termBuffer_->isSelected(
+              QPoint(i, index), param_->isRectSelect_)) {
+      unsigned cellBegin = pTextLine->getCellBegin(i);
+      unsigned cellEnd = pTextLine->getCellEnd(cellBegin + 1);
+      cstrText.clear();
+      pTextLine->getPlainText(cellBegin, cellEnd, cstrText);
+      if (temprt != charRenderingType(cstrText[0])) {
+        break;
+      }
+      bool colorBlock = isColorBlock(cstrText[0]);
+      if (cell_end != cellEnd && colorBlock || color_block && !colorBlock) {
+        break;
+      }
+      ++i;
+    }
+  
+    cell_end = pTextLine->getCellEnd(i);
+    cstrText.clear();
+    pTextLine->getPlainText(cell_begin, cell_end, cstrText);
+
+    unsigned j = i;
+    if (j > 0 &&  pTextLine->getCellBegin(j) == pTextLine->getCellBegin(j - 1) 
+      && *(pTextLine->getColors() + j) != *(pTextLine->getColors() + j - 1)) {
+        j++;
+    } 
+    for (; j < cell_end; ++j) {
+      cstrText.append((QChar)URC);
+    }
+
+    int text_width = cell_end - cell_begin;
+
+    bool draw_half_begin_char = false;
+
+    if (startx > 0 &&  pTextLine->getCellBegin(startx) == pTextLine->getCellBegin(startx - 1) 
+      && *(pTextLine->getColors() + startx) != *(pTextLine->getColors() + startx - 1)) {
+//#if defined(WIN32)
+      draw_half_begin_char = true;
+//#else
+//	startx++;
+//#endif
+    }
+
+    painter.setFont((temprt == HalfAndAlign || temprt == HalfAndSpace)?*englishFont_:*nonEnglishFont_);
+    if (isMonoSpace && temprt != FullAndAlign) {
+      QFont& font = (temprt == HalfAndAlign || temprt == HalfAndSpace)?*englishFont_:*nonEnglishFont_;
+      if (temprt == HalfAndAlign) {
+        font.setLetterSpacing(QFont::AbsoluteSpacing, enLetterSpacing_);
+      } else if (temprt == HalfAndSpace) {
+        font.setLetterSpacing(QFont::AbsoluteSpacing, spLetterSpacing_);
+      } else {
+        font.setLetterSpacing(QFont::AbsoluteSpacing, cnLetterSpacing_);
+      }
+      painter.setFont(font);
+      if (draw_half_begin_char) {
+        text_width--;
+        draw_half_begin_char = false;
+      }
+      drawStr(painter, cstrText, startx, index, text_width,
+              tempcp, tempea, isTransparent, bSelected);
+      font.setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    } else if (temprt == FullNotAlign) {
+      nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, cnLetterSpacing_);
+      painter.setFont(*nonEnglishFont_);
+      if (draw_half_begin_char) {
+        text_width--;
+        draw_half_begin_char = false;
+      }
+      drawStr(painter, cstrText, startx, index, text_width,
+        tempcp, tempea, isTransparent, bSelected);
+      nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    } else if (temprt == HalfAndSpace) {
+      englishFont_->setLetterSpacing(QFont::AbsoluteSpacing, spLetterSpacing_);
+      painter.setFont(*englishFont_);
+      if (draw_half_begin_char) {
+        text_width--;
+        draw_half_begin_char = false;
+      }
+      drawStr(painter, cstrText, startx, index, text_width,
+        tempcp, tempea, isTransparent, bSelected);
+      englishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    }else {
+      englishFont_->setLetterSpacing(QFont::AbsoluteSpacing, enLetterSpacing_);
+      nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, cnLetterSpacing_);
+      if (temprt == HalfAndAlign)
+        painter.setFont(*englishFont_);
+      else if (temprt == FullAndAlign)
+        painter.setFont(*nonEnglishFont_);
+      // Draw Characters one by one to fix the variable-width font
+      // display problem.
+      int offset = 0;
+      for (uint j = 0; (long)j < cstrText.length(); ++j) {
+        // TODO_UTF16: wrong character width here.
+        if (temprt == HalfAndAlign) {
+          drawStr(painter, (QString)cstrText.at(j),
+                  startx + offset, index, 1,
+                  tempcp, tempea,
+                  isTransparent, bSelected);
+          offset++;
+        } else if (temprt == FullAndAlign){
+          
+
+          int w = 2;
+          if (draw_half_begin_char) {
+            w--;
+          }
+          drawStr(painter, (QString)cstrText.at(j),
+                  startx + offset, index, w,
+                  tempcp, tempea,
+                  isTransparent, bSelected);
+          if (draw_half_begin_char) {
+            draw_half_begin_char = false;
+            offset--;
+          }
+          offset += 2;
+          
+        }
+      }
+      nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+      englishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    }
+  }
+}
+//
+// draw functions
+void FQTermScreen::drawStr(QPainter &painter, const QString &str,
+                           int x, int y, int length,
+                           unsigned char color, unsigned char attr,
+                           bool transparent, bool selected) {
+  unsigned char cp = color;
+  unsigned char ea = attr;
+
+  // test bold mask or always highlighted
+  if (GETBRIGHT(ea) || param_->isAlwaysHighlight_) {
+    cp |= SET_FG_HIGHLIGHT(1);
+  }
+  
+  // use 8-15 color
+  // test dim mask
+  if (GETDIM(ea)) {
+  }
+  
+  // test underline mask
+  if (GETUNDERLINE(ea)) {
+    QFont font = painter.font();
+    font.setUnderline(true);
+    painter.setFont(font);
+  } else {
+    QFont font = painter.font();
+    font.setUnderline(false);
+    painter.setFont(font);
+  }
+  // test blink mask
+  if (GETBLINK(ea)){}
+  // test rapidblink mask
+  if (GETRAPIDBLINK(ea)){}
+  // test reverse mask
+  if (GETREVERSE(ea)) {
+    cp = GET_INVERSE_COLOR(cp);
+  }
+
+  if (selected) {
+    cp = GET_INVERSE_COLOR(cp);
+  }
+
+  // test invisible mask
+  if (GETINVISIBLE(ea)) {
+  }
+
+
+
+  int pen_color_index = GETFG(cp);
+  if (!param_->isAnsiColor_) {
+    if (GETBG(cp) != 0) {
+      pen_color_index = 0;
+    } else {
+      pen_color_index = 7;
+    }
+  }
+  painter.setPen(colors_[pen_color_index]);
+
+  int brush_color_index = GETBG(cp);
+  if (!param_->isAnsiColor_) {
+    if (GETBG(cp) != 0) {
+      brush_color_index = 7;
+    } else {
+      brush_color_index = 0;
+    }
+  }
+
+
+  QBrush brush(colors_[brush_color_index]);
+
+  // black on white without attr
+  if (FQTermPref::getInstance()->isBossColor_) {
+    painter.setPen(Qt::black);
+    brush = QBrush(Qt::white);
+  }
+
+  QPoint pt = mapToPixel(QPoint(x, y));
+  QRect rcErase = mapToRect(x, y, length, 1);
+
+  if (!menuRect_.intersects(rcErase)){
+    if (x == 0) {
+      rcErase.setLeft(rcErase.left() - 1);
+    }
+    //painter.fillRect(rcErase, brush);
+    drawBackground(painter, rcErase, brush_color_index);
+    if (x == 0) {
+      rcErase.setLeft(rcErase.left() + 1);
+    }
+  } else {
+    QRect rcKeep = menuRect_.intersected(rcErase);
+    rcKeep.setY(rcErase.y());
+    rcKeep.setHeight(rcErase.height());
+    if (rcErase.left() < rcKeep.left()) {
+      QPoint point = rcKeep.bottomLeft();
+      point.setX(point.x() + 1);
+      point.setY(point.y() + 1);
+      painter.fillRect(QRect(rcErase.topLeft(), point),
+                       brush);
+    }
+    if (rcKeep.right() < rcErase.right()) {
+      QPoint point = rcErase.bottomRight();
+      point.setX(point.x() + 1);
+      point.setY(point.y() + 1);
+
+      painter.fillRect(QRect(rcKeep.topRight(), point),
+                       brush);
+    }
+  }
+
+  if (!(isBlinkScreen_ && GETBLINK(attr))) {
+    FQ_TRACE("draw_text", 10) << "draw text: " << str;
+    
+    QFontMetrics qm = painter.fontMetrics();
+    int font_height = qm.height();
+    int expected_font_height = rcErase.height();
+    int height_gap = expected_font_height - font_height;
+    int offset = (height_gap + 1)/2; 
+    int ascent = qm.ascent() + offset; 
+
+//#if defined(WIN32)
+    int verticalAlign = Qt::AlignVCenter;
+    switch(param_->alignMode_) {
+      case 0:
+        verticalAlign = Qt::AlignVCenter;
+        break;
+      case 1:
+        verticalAlign = Qt::AlignBottom;
+        break;
+      case 2:
+        verticalAlign = Qt::AlignTop;
+        break;
+    }
+    if (length > 2 || !isColorBlock(str[0])) {
+      painter.drawText(rcErase, Qt::AlignRight | verticalAlign, str);
+    } else {
+      //here length == 1 or == 2, isColorBlock == true, ensured in drawLine.
+      //when length == 1, we are drawing the second half of the block,
+      //otherwise the whole block.
+      //(c.unicode() >= 0x2581 && c.unicode() <= 0x258f)
+      //7 rectangles from shorter to taller (1/8 - 7/8 on the bottom)
+      //1 rectangle full
+      //7 rectangles from thicker to thinner (7/8 - 1/8 on the left)
+      //(c.unicode() >= 0x25e2 && c.unicode() <= 0x25e5)
+      //4 triangles bottom-right, bottom-left, top-left, top-right
+      QPolygon bound = rcErase;
+      QPolygon toDraw;
+      QRect rcFull = mapToRect(x, y, 2, 1);
+      rcFull.setBottom(rcFull.bottom() + 1);
+      rcFull.setRight(rcFull.right() + 1);
+      int unic = str[0].unicode();
+      if (unic >= 0x2581 && unic <= 0x2588) {
+        toDraw = QRect(rcFull.left(), rcFull.top() - rcFull.height() * (unic - 0x2581 + 1 - 8) / 8, rcFull.width(), rcFull.height() * (unic - 0x2581 + 1) / 8);
+      } else if (unic > 0x2588 && unic <= 0x258f) {
+        toDraw = QRect(rcFull.left(), rcFull.top(), rcFull.width() * (8 - unic + 0x2589 - 1) / 8, rcFull.height());
+      } else { //triangles
+        QVector<QPoint> points;
+        points.push_back(rcFull.topLeft());
+        points.push_back(rcFull.topRight());
+        points.push_back(rcFull.bottomRight());
+        points.push_back(rcFull.bottomLeft());
+        points.remove(unic - 0x25e2);
+        toDraw = points;
+      }
+      QBrush oldBrush = painter.brush();
+      painter.setBrush(colors_[pen_color_index]);
+      QPen oldPen = painter.pen();
+      painter.setPen(Qt::transparent);
+      painter.drawConvexPolygon(toDraw.intersected(bound));
+      painter.setBrush(oldBrush);
+      painter.setPen(oldPen);
+    }
+//#else
+//    painter.drawText(pt.x(), pt.y() + ascent, str);
+//#endif
+  }
+}
+
+
+void FQTermScreen::eraseRect(QPainter &, int, int, int, int, short){
+  FQ_VERIFY(false);
+}
+
+void FQTermScreen::bossColor() {
+  if (FQTermPref::getInstance()->isBossColor_) {
+    colors_[0] = Qt::white;
+    colors_[7] = Qt::black;
+    QPalette palette;
+    palette.setColor(backgroundRole(), Qt::white);
+    setPalette(palette);
+
+  } else {
+    colors_[0] = param_->backgroundColor_;
+    colors_[7] = param_->foregroundColor_;
+  }
+
+
+  setPaintState(Repaint);
+  update();
+}
+
+QRect FQTermScreen::drawMenuSelect(QPainter &painter, int index) {
+  QRect rcSelect, rcMenu, rcInter;
+  // 	FIXME: what is this for
+/*
+  if (termBuffer_->isSelected(index)) {
+    bool is_rect_sel = param_->isRectSelect_;
+    rcSelect = mapToRect(termBuffer_->getSelectRect(index, is_rect_sel));
+    if (FQTermPref::getInstance()->isBossColor_) {
+      painter.fillRect(rcSelect, QBrush(colors_[0]));
+    } else {
+      painter.fillRect(rcSelect, QBrush(colors_[7]));
+    }
+  }
+*/
+  if (session_->isSelectedMenu(index)) {
+    rcMenu = mapToRect(session_->getMenuRect());
+    // 		m_pBand->setGeometry(rcMenu);
+    // 		m_pBand->show();
+    switch (param_->menuType_) {
+      case 0:
+        // underline
+        painter.fillRect(rcMenu.x(), rcMenu.y() + 10 * charHeight_ / 11,
+                         rcMenu.width(), charHeight_ / 11, colors_[7]);
+        break;
+      case 2:
+        painter.fillRect(rcMenu, QBrush(FQTermPref::getInstance()->isBossColor_?colors_[0]:param_->menuColor_));
+        break;
+    }
+  }
+  return rcMenu;
+}
+
+/* ------------------------------------------------------------------------ */
+/*	                                                                        */
+/* 	                            Auxilluary	                                */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+QSize FQTermScreen::getScreenSize() const
+{
+  return QSize(termBuffer_->getNumColumns() * charWidth_, termBuffer_->getNumRows() * charHeight_);
+}
+
+QPoint FQTermScreen::mapToPixel(const QPoint &point) {
+  int dx = (getScreenSize().width() - clientRectangle_.width()) * FQTermPref::getInstance()->displayOffset_ / 100;
+  int dy = getVerticalSetting();
+  QPoint pt = clientRectangle_.topLeft();
+  pt.setX(pt.x() - dx);
+  pt.setY(pt.y() - dy);
+  QPoint pxlPoint;
+
+  pxlPoint.setX(point.x() *charWidth_ + pt.x());
+  pxlPoint.setY((point.y() - bufferStart_) *charHeight_ + pt.y());
+
+  return pxlPoint;
+}
+// mapToChar: get a position in the window and return the
+// corresponding char position
+QPoint FQTermScreen::mapToChar(const QPoint &point) {
+  int dx = (getScreenSize().width() - clientRectangle_.width()) * FQTermPref::getInstance()->displayOffset_ / 100;
+  int dy = getVerticalSetting();
+  QPoint pt = clientRectangle_.topLeft();
+  pt.setX(pt.x() - dx);
+  pt.setY(pt.y() - dy);
+  QPoint chPoint;
+  chPoint.setX(qMin(qMax(0, int((point.x() - pt.x()) / charWidth_)),
+                    termBuffer_->getNumColumns() - 1));
+  chPoint.setY(qMin(qMax(0, int((point.y() - pt.y()) / charHeight_) + bufferStart_),
+                    bufferEnd_));
+
+  //FIXME add bound check
+  return chPoint;
+}
+
+QRect FQTermScreen::mapToRect(int x, int y, int width, int height) {
+  QPoint pt = mapToPixel(QPoint(x, y));
+
+  if (width == -1) {
+	// to the end
+    return QRect(pt.x(), pt.y(), getScreenSize().width(), charHeight_ *height);
+  } else {
+    return QRect(pt.x(), pt.y(), width *charWidth_, charHeight_ *height);
+  }
+}
+
+QRect FQTermScreen::mapToRect(const QRect &rect) {
+  return mapToRect(rect.x(), rect.y(), rect.width(), rect.height());
+}
+
+// from KImageEffect::fade
+QImage &FQTermScreen::fade(QImage &img, float val, const QColor &color) {
+  if (img.width() == 0 || img.height() == 0) {
+    return img; 
+  }
+
+  // We don't handle bitmaps
+  if (img.depth() == 1) {
+    return img;
+  }
+
+  unsigned char tbl[256];
+  for (int i = 0; i < 256; i++) {
+    tbl[i] = (int)(val *i + 0.5);
+  }
+
+  int red = color.red();
+  int green = color.green();
+  int blue = color.blue();
+
+  QRgb col;
+  int r, g, b, cr, cg, cb;
+
+  if (img.depth() <= 8) {
+    // pseudo color
+    for (int i = 0; i < img.numColors(); i++) {
+      col = img.color(i);
+      cr = qRed(col);
+      cg = qGreen(col);
+      cb = qBlue(col);
+      if (cr > red) {
+        r = cr - tbl[cr - red];
+      } else {
+        r = cr + tbl[red - cr];
+      }
+      if (cg > green) {
+        g = cg - tbl[cg - green];
+      } else {
+        g = cg + tbl[green - cg];
+      }
+      if (cb > blue) {
+        b = cb - tbl[cb - blue];
+      } else {
+        b = cb + tbl[blue - cb];
+      }
+      img.setColor(i, qRgba(r, g, b, qAlpha(col)));
+    }
+  } else {
+    // truecolor
+    for (int y = 0; y < img.height(); y++) {
+      QRgb *data = (QRgb*)img.scanLine(y);
+      for (int x = 0; x < img.width(); x++) {
+        col =  *data;
+        cr = qRed(col);
+        cg = qGreen(col);
+        cb = qBlue(col);
+        if (cr > red) {
+          r = cr - tbl[cr - red];
+        } else {
+          r = cr + tbl[red - cr];
+        }
+        if (cg > green) {
+          g = cg - tbl[cg - green];
+        } else {
+          g = cg + tbl[green - cg];
+        }
+        if (cb > blue) {
+          b = cb - tbl[cb - blue];
+        } else {
+          b = cb + tbl[blue - cb];
+        }
+        *data++ = qRgba(r, g, b, qAlpha(col));
+      }
+    }
+  }
+
+  return img;
+}
+
+void FQTermScreen::inputMethodEvent(QInputMethodEvent *e) {
+  FQ_TRACE("ime", 5) << "Preedit: " << e->preeditString();
+  FQ_TRACE("ime", 5) << "Commit: " << e->commitString();
+
+  FQ_TRACE("ime", 8) << "Replace: " << e->replacementStart()
+                     << ", " << e->replacementLength();
+
+  if (e->preeditString().size() > 0) {
+    nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    preedit_line_->setPreeditText(e, nonEnglishFont_);
+    nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+    QPoint pt = mapToPixel(QPoint(termBuffer_->getCaretColumn(),
+                                  termBuffer_->getCaretLine()));
+    preedit_line_->move(pt);
+    preedit_line_->show();
+    preedit_line_->update();
+  } else {
+    preedit_line_->hide();
+  }
+  
+  if (e->commitString().size() > 0) {
+    emit inputEvent(e->commitString());
+  }
+}
+
+QVariant FQTermScreen::inputMethodQuery(Qt::InputMethodQuery property) const {
+  FQ_TRACE("ime", 5) << "Query: " << property;
+
+  int row = termBuffer_->getCaretRow();
+  int col = termBuffer_->getCaretColumn();
+
+  switch (property) {
+    case Qt::ImMicroFocus:
+      // Here we must use (column + 1, row + 1) as the result,
+      // otherwise MS Pinyin or GPY won't work well.
+      return QVariant(
+          QRect((termBuffer_->getCaretColumn()) * charWidth_ 
+                + (preedit_line_->isVisible() ?
+                   preedit_line_->getCaretOffset() : 0),
+                (termBuffer_->getCaretRow()) * charHeight_,
+                charWidth_, charHeight_));
+    case Qt::ImFont:
+    {
+	nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+	QVariant var(*nonEnglishFont_);
+	nonEnglishFont_->setLetterSpacing(QFont::AbsoluteSpacing, 0.0);
+	return var;
+    }
+    case Qt::ImCurrentSelection:
+      return QVariant(QString());
+    case Qt::ImCursorPosition:
+    case Qt::ImSurroundingText:
+      {
+        tmp_im_query_->clear();
+        const FQTermTextLine *line = termBuffer_->getTextLineInTerm(row);
+        line->getPlainText(0, line->getCellEnd(col), *tmp_im_query_);
+
+        // TODO_UTF16: here only BMP is considered.
+        if (Qt::ImCursorPosition) {
+          return QVariant(tmp_im_query_->size());
+        } else {
+          tmp_im_query_->clear();
+          line->getPlainText(0, line->getWidth(), *tmp_im_query_);
+          return QVariant(QString(*tmp_im_query_));
+        }
+      }
+      break;
+    default:
+      return QVariant();
+  }
+}
+
+void FQTermScreen::updateFixedPitchInfo() {
+  QFont cnFont(*nonEnglishFont_);
+  QFont enFont(*englishFont_);
+  int cnPixelSize = nonEnglishFont_->pixelSize() <= 5 ? 12 : nonEnglishFont_->pixelSize();
+  int enPixelSize = englishFont_->pixelSize() <= 5 ? 12 : englishFont_->pixelSize();
+  cnFont.setPixelSize(cnPixelSize);
+  enFont.setPixelSize(enPixelSize);
+  QString cnTestString = QString::fromUtf8("\xe5\x9c\xb0\xe6\x96\xb9\xe6\x94\xbf\xe5\xba\x9c");
+  cnFixedPitch_ = (QFontMetrics(cnFont).width(cnTestString) == 
+    cnTestString.length() * QFontMetrics(cnFont).width(cnTestString.at(0)));
+  QString enTestString = QString::fromUtf8("www.newsmth.net");
+  enFixedPitch_ = QFontInfo(enFont).fixedPitch() &&
+                  (QFontMetrics(enFont).width(enTestString) == enTestString.length() * QFontMetrics(enFont).width(enTestString.at(0)));
+                  
+    FQ_TRACE("font", 10) << "\nenglish: " << enFixedPitch_ 
+                      << "\n chinese: " << cnFixedPitch_;
+  
+}
+
+void FQTermScreen::setTermFont(bool isEnglish, const QFont& font)
+{
+  QFont *&pFont = isEnglish?englishFont_:nonEnglishFont_;
+  delete pFont;
+  if (param_->isFontAutoFit_ == 1) {
+    pFont = new QFont(font.family());
+    pFont->setKerning(false);
+  } else {
+    pFont = new QFont(font);
+    pFont->setKerning(false);    
+    setFontMetrics();
+  }
+  updateFixedPitchInfo();
+  emit termFontChange(isEnglish, font);
+}
+
+QFont FQTermScreen::termFont(bool isEnglish) {
+  return isEnglish?(*englishFont_):(*nonEnglishFont_);
+}
+
+void FQTermScreen::drawUnderLine(QPainter &painter, const QPoint& startPoint, const QPoint& endPoint) {
+  if (startPoint.y() == endPoint.y()) {
+    drawSingleUnderLine(painter, startPoint, endPoint);
+  } else {
+    drawSingleUnderLine(painter, startPoint, QPoint(termBuffer_->getNumColumns(), startPoint.y()));
+    drawSingleUnderLine(painter, QPoint(0, endPoint.y()), endPoint);
+    for (int i = startPoint.y() + 1; i < endPoint.y(); ++i) {
+      drawSingleUnderLine(painter, QPoint(0, i), QPoint(termBuffer_->getNumColumns(), i));
+    }
+  }
+}
+
+void FQTermScreen::drawSingleUnderLine(QPainter &painter, const QPoint& startPoint, const QPoint& endPoint) {
+  FQ_VERIFY(startPoint.y() == endPoint.y());
+  QPoint realStart = mapToPixel(startPoint);
+  QPoint realEnd = mapToPixel(endPoint);
+  painter.fillRect(realStart.x(), realStart.y() + 10 * charHeight_ / 11,
+    realEnd.x() - realStart.x(), charHeight_ / 11, FQTermPref::getInstance()->isBossColor_?colors_[0]:param_->menuColor_);
+}
+
+void FQTermScreen::setFontAntiAliasing( bool on /*= true*/ ) {
+  englishFont_->setStyleStrategy(on?QFont::PreferAntialias:QFont::NoAntialias);
+  nonEnglishFont_->setStyleStrategy(on?QFont::PreferAntialias:QFont::NoAntialias);
+}
+
+void FQTermScreen::widgetHideAt(const QRect& rect){
+  widgetRect_ = rect;
+  setPaintState(Widget);
+  update();
+}
+
+void FQTermScreen::updateWidgetRect(QPainter& painter) {
+
+  
+
+  QRect rect = widgetRect_.intersect(clientRectangle_);
+  if (rect.isEmpty())
+    return;
+  drawBackground(painter, rect, 0);
+
+  QPoint tlPoint = mapToChar(QPoint(rect.left(), rect.top()));
+
+  QPoint brPoint = mapToChar(QPoint(rect.right(), rect.bottom()));
+
+  for (int y = tlPoint.y(); y <= brPoint.y(); y++) {
+    const FQTermTextLine *pTextLine = termBuffer_->getTextLineInBuffer(y);
+    int startx = qMin(tlPoint.x(),int(pTextLine->getWidth()));
+    int endx = qMin(brPoint.x(), int(pTextLine->getWidth()));
+    startx = pTextLine->getCellBegin(startx);
+    endx = pTextLine->getCellEnd(endx);
+    drawLine(painter, y, startx, endx);
+  }
+  widgetRect_ = QRect();
+}
+
+void FQTermScreen::drawBackgroundPixmap(QPainter& painter, const QRect& rect) {
+  if (!hasBackground_ ||
+      FQTermPref::getInstance()->isBossColor_ ||
+      backgroundPixmap_.isNull()) {
+      return;
+  }
+  if (backgroundCoverage_ == 1) { //Only padding, we do not draw screen background.
+    QRegion clip = rect;
+    QRect screenRect = mapToRect(0, termBuffer_->getNumLines() - termBuffer_->getNumRows(), termBuffer_->getNumColumns(), termBuffer_->getNumRows());
+    clip -= screenRect;
+    QVector<QRect> rects = clip.rects();
+    foreach(QRect r, rects) {
+      painter.drawPixmap(r, backgroundPixmap_, r);
+    }
+    return;
+  }
+  painter.drawPixmap(rect, backgroundPixmap_, rect);
+}
+
+int FQTermScreen::getVerticalSetting() const {
+  int dy = -1;
+  switch (FQTermPref::getInstance()->vsetting_)
+  {
+  case 0:
+    {
+      // Top
+      dy = 0;
+      break;
+    }
+  case 1:
+    {
+      // Middle
+      dy = (getScreenSize().height() - clientRectangle_.height()) / 2;
+      break;
+    }
+  case 2:
+    {
+      // Bottom
+      dy = (getScreenSize().height() - clientRectangle_.height());
+      break;
+    }
+  default:
+    {
+      // The logic should never get here
+      break;
+    }
+  }
+  return dy;
+}
+
+void FQTermScreen::drawBackground(QPainter& painter, const QRect& rect, int colorIndex) {
+  
+  if (FQTermPref::getInstance()->isBossColor_) {
+    painter.fillRect(rect, Qt::white);
+    return;
+  }
+  if (hasBackground_ && !backgroundPixmap_.isNull()) {
+    if (colorIndex == 0 || (backgroundCoverage_ != 1 && backgroundUseAlpha_))
+      drawBackgroundPixmap(painter, rect);
+    if (backgroundCoverage_ == 1) { //Background only padding, we draw screen background.
+      QRegion clip = rect;
+      QRect screenRect = mapToRect(0, termBuffer_->getNumLines() - termBuffer_->getNumRows(), termBuffer_->getNumColumns(), termBuffer_->getNumRows());
+      clip &= screenRect;
+      QVector<QRect> rects = clip.rects();
+      foreach(QRect r, rects) {
+        painter.fillRect(r, colors_[colorIndex]);
+      }
+    } else {
+      if (backgroundUseAlpha_)
+        painter.setOpacity(double(backgroundAlpha_) / 100);
+      if (colorIndex != 0 || backgroundUseAlpha_)
+        painter.fillRect(rect, colors_[colorIndex]);
+      painter.setOpacity(1.0);
+    }
+    return;
+  }
+  painter.fillRect(rect, colors_[colorIndex]);
+}
+PreeditLine::PreeditLine(QWidget *parent,const QColor *colors)
+    : QWidget(parent),
+      pixmap_(new QPixmap()),
+      colors_(colors) {
+  //setFocusPolicy(Qt::NoFocus);
+  hide();
+}
+
+PreeditLine::~PreeditLine() {
+  delete pixmap_;
+}
+
+void PreeditLine::setPreeditText(QInputMethodEvent *e, const QFont *font) {
+  QString text = e->preeditString();
+
+  const QColor &white_color = colors_[7];
+  const QColor &black_color = colors_[0];
+
+  // MS Pinyin will add a white space '\u3000' in the end. Remove it.
+  text = text.trimmed();
+
+  QFontMetrics fm(*font);
+  QRect textRect = fm.boundingRect(text);
+
+  int width = textRect.width();
+  int height = textRect.height();
+
+  delete pixmap_;
+  pixmap_ = new QPixmap(width, height + 1); // add one pixel to shadow
+                                            // the original cursor on
+                                            // screen.
+  this->resize(width, height + 1);
+
+  QPainter painter(pixmap_);
+  painter.fillRect(textRect, QBrush(black_color));
+
+  painter.setFont(*font);
+  painter.setBackgroundMode(Qt::OpaqueMode);
+
+  // Parse attributes of the input method event.
+  for (int i = 0; i < e->attributes().size(); ++i) {
+    const QInputMethodEvent::Attribute &a = e->attributes().at(i);
+    switch(a.type) {
+      case QInputMethodEvent::Cursor:
+        FQ_TRACE("ime", 10) << "Cursor: " << a.start << ", " << a.length;
+        {
+          painter.setPen(white_color);
+      
+          int caret_begin = fm.boundingRect(text.left(a.start)).right();
+
+          painter.drawLine(caret_begin, 0, caret_begin, height);
+          painter.drawLine(caret_begin + 1, 0, caret_begin + 1, height);
+
+          caret_offset_ = caret_begin;
+        }
+        break;
+      case QInputMethodEvent::TextFormat:
+        {
+          if (a.start + a.length > text.size()) {
+            // index over flow. ignore it.
+            break;
+          }
+
+          const QString &sub_text = text.mid(a.start, a.length);
+
+          int x = fm.boundingRect(text.left(a.start)).width();
+
+          QTextCharFormat f =
+              qvariant_cast<QTextFormat>(a.value).toCharFormat();
+
+          // Hack here.
+          // If the background() is of style Qt::SolidPattern,
+          // we consider this segment of text is highlighted.
+          // Otherwise it's normal preedit text.
+          if (f.background().style() == Qt::SolidPattern) {
+            QBrush bg(white_color);
+            bg.setStyle(Qt::SolidPattern);
+
+            painter.setBackground(bg);
+            painter.setPen(black_color);
+          } else {
+            QBrush bg(black_color);
+            bg.setStyle(Qt::SolidPattern);
+
+            painter.setBackground(bg);
+            painter.setPen(white_color);
+          }
+
+          // Draw the text;
+          painter.drawText(x, fm.ascent(), sub_text);
+
+          FQ_TRACE("ime", 10) << "Sub-text: " << sub_text;
+          FQ_TRACE("ime", 10) << "Format: " << a.start << ", " << a.length;
+          FQ_TRACE("ime", 10) << "Background: " << f.background();
+          FQ_TRACE("ime", 10) << "Pen: " << f.textOutline(); 
+        }
+        break;
+      case QInputMethodEvent::Language:
+        FQ_TRACE("ime", 10) << "Language: " << a.start << ", " << a.length;
+        break;
+      case QInputMethodEvent::Ruby:
+        FQ_TRACE("ime", 10) << "Ruby: " << a.start << ", " << a.length;
+        break;
+    }
+  }
+
+  // Draw a line under the preedit text.
+  QPen pen(white_color);
+  pen.setStyle(Qt::DashLine);
+  painter.setPen(pen);
+  painter.drawLine(0, height - 1, width, height - 1);
+}
+
+void PreeditLine::paintEvent(QPaintEvent *e) {
+  QWidget::paintEvent(e);
+  QPainter p(this);
+  p.drawPixmap(QPointF(0, 0), *pixmap_, e->rect());
+}
+
+}  // namespace FQTerm
+
+#include "fqterm_screen.moc"
diff --git a/src/fqterm/fqterm_screen.h b/src/fqterm/fqterm_screen.h
new file mode 100644
index 0000000..5c65142
--- /dev/null
+++ b/src/fqterm/fqterm_screen.h
@@ -0,0 +1,281 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_SCREEN_H
+#define FQTERM_SCREEN_H
+
+#include <QWidget>
+#include <QVector>
+#include <QList>
+#include "fqterm_param.h"
+#include "fqterm_convert.h"
+
+class QTextCodec;
+class QColor;
+class QPainter;
+class QInputMethodEvent;
+class QPixmap;
+class QScrollBar;
+class QShortcut;
+
+namespace FQTerm {
+
+class FQTermWindow;
+class FQTermBuffer;
+class FQTermSession;
+class FQTermParam;
+
+class PreeditLine: public QWidget {
+public:
+  PreeditLine(QWidget *parent,const QColor *colors);
+  ~PreeditLine();
+  
+  void setPreeditText(QInputMethodEvent *e, const QFont *font);
+
+  void paintEvent(QPaintEvent * event);
+
+  int getCaretOffset() const {return caret_offset_;}
+
+private:
+  QPixmap *pixmap_;
+  int caret_offset_;
+
+  const QColor *colors_;
+};
+
+class FQTermScreen: public QWidget {
+  Q_OBJECT;
+ public:
+
+  enum PaintState {
+     System = 0, Repaint = 1, NewData = 2, Blink = 4, Cursor = 8, Widget = 16
+  };
+  enum MouseState {
+    Enter, Press, Move, Release, Leave
+  };
+
+  FQTermScreen(QWidget *parent, FQTermSession *session);
+  ~FQTermScreen();
+
+  void setSchema();
+  void setTermFont(bool isEnglish, const QFont& font);
+
+  QFont termFont(bool isEnglish);
+
+
+  void setPaintState(PaintState ps) {
+    paintState_ |= ps;
+  }
+
+  void clearPaintState(PaintState ps) {
+    paintState_ &= ~ps;
+  }
+
+  bool testPaintState(PaintState ps) {
+    return paintState_ & ps;
+  }
+
+
+  /*void clearPaintState() {
+      paintState_ = None;
+  }*/
+  // Buffer cell coordinate to screen pixel.
+  int getBufferStart() {return bufferStart_;}
+  QPoint mapToPixel(const QPoint &);
+
+  // Screen pixel coordinate to buffer cell coordinate.
+  QPoint mapToChar(const QPoint &);
+
+  // Buffer cell coordinate to screen pixel.
+  QRect mapToRect(int x, int y, int width, int height);
+  QRect mapToRect(const QRect &);
+ private:
+  int paintState_;
+  void updateWidgetRect(QPainter& painter);
+  void refreshScreen(QPainter &painter);
+  void blinkScreen(QPainter &painter);
+  void updateCursor(QPainter &painter);
+  void repaintScreen(QPaintEvent *pe, QPainter &painter);
+  void syncBufferAndScreen();
+  void updateBackgroundPixmap();
+  void drawBackground(QPainter& painter, const QRect& rect, int colorIndex);
+  void drawBackgroundPixmap(QPainter& painter, const QRect& rect);
+  int getVerticalSetting() const;
+
+ signals:
+  // 0 - enter  1 - press  2 - move  3 - release 4 - leave
+  void mouseAction(int, QMouseEvent*);
+  void inputEvent(const QString&);
+  void termFontChange(bool isEnglish, QFont font);
+
+ public slots:
+  void bufferSizeChanged();
+  void termSizeChanged(int column, int row);
+  void bossColor();
+  void updateScrollBar();
+  void setFontAntiAliasing(bool on = true);
+  void widgetHideAt(const QRect& rect);
+
+
+ protected:
+  void initFontMetrics();
+
+  bool event(QEvent *e);
+
+  void resizeEvent(QResizeEvent*);
+  void focusInEvent(QFocusEvent*);
+  void focusOutEvent(QFocusEvent*);
+
+  void paintEvent(QPaintEvent*);
+
+  // mouse
+  void enterEvent(QEvent*);
+  void leaveEvent(QEvent*);
+  void mousePressEvent(QMouseEvent*);
+  void mouseMoveEvent(QMouseEvent*);
+  void mouseReleaseEvent(QMouseEvent*);
+  void wheelEvent(QWheelEvent*);
+
+  // display
+  void eraseRect(QPainter &, int, int, int, int, short);
+  void drawStr(QPainter &painter, const QString &str, 
+               int x, int y, int length,
+               unsigned char color, unsigned char attr,
+               bool transparent, bool selected = false);
+  void drawLine(QPainter &, int index, int startx = -1, int endx = -1, 
+                bool complete = true);
+  void drawCaret(QPainter &, bool);
+  QRect drawMenuSelect(QPainter &, int);
+  void drawUnderLine(QPainter &, const QPoint& startPoint, const QPoint& endPoint);
+  
+  // auxiluary
+  int getPosX(int xChar) {
+    return xChar *charWidth_;
+  }
+  int getPosY(int yLine) {
+    return yLine *charHeight_;
+  }
+
+  //screen size, in pixel.
+  QSize getScreenSize() const;
+
+
+
+  void updateFont();
+  void setFontMetrics();
+
+  QImage &fade(QImage &, float, const QColor &);
+
+  void inputMethodEvent(QInputMethodEvent *e);
+  QVariant inputMethodQuery(Qt::InputMethodQuery property)const;
+
+
+ protected slots:
+  void blinkEvent();
+  void cursorEvent();
+  void scrollChanged(int);
+  void prevPage();
+  void nextPage();
+  void prevLine();
+  void nextLine();
+  void scrollLine(int);
+ protected:
+   void drawSingleUnderLine(QPainter &, const QPoint& startPoint, const QPoint& endPoint);
+
+  QRect clientRectangle_; // the display area
+  QRect menuRect_;
+  QRect widgetRect_; //we need to redraw this rect since a widget just disappeared.
+
+  int scrollBarWidth_;
+
+  QScrollBar *scrollBar_;
+
+  QTimer *blinkTimer_;
+  QTimer *cursorTimer_;
+
+  bool isBlinkScreen_;
+  bool isBlinkCursor_;
+  bool hasBlinkText_;
+
+  FQTermWindow *termWindow_;
+  FQTermSession *session_;
+  const FQTermBuffer *termBuffer_;
+  FQTermParam *param_;
+
+  bool is_light_background_mode_;
+
+  QColor colors_[16];
+  QFont *englishFont_;
+  QFont *nonEnglishFont_;
+
+  double fontAscent_, fontDescent_;
+  double charWidth_, charHeight_;
+  double cnLetterSpacing_;
+  double enLetterSpacing_;
+  double spLetterSpacing_;
+
+  void updateFixedPitchInfo();
+  bool cnFixedPitch_;
+  bool enFixedPitch_;
+  int lineSpacing_; // for future
+
+  bool *areLinesBlink_;
+  bool isCursorShown_;
+
+  // background
+  bool hasBackground_;
+  QPixmap backgroundPixmap_;
+  QPixmap originBackgroundPixmap_;
+  //0 -- tile 1 -- center 2 -- stretch
+  int backgroundRenderOption_;
+  //0 -- Whole screen, 1 -- Only padding
+  int backgroundCoverage_;
+  bool backgroundUseAlpha_;
+  int backgroundAlpha_;
+  
+
+  // the range of the buffer's lines to be displayed
+  int bufferStart_;
+  int bufferEnd_;
+
+  QShortcut *gotoPrevPage_;
+  QShortcut *gotoNextPage_;
+  QShortcut *gotoPrevLine_;
+  QShortcut *gotoNextLine_;
+
+  FQTermConvert encodingConverter_;
+
+  PreeditLine *preedit_line_;
+  
+  QString *tmp_im_query_;
+
+  //TODO: change to bit field
+  enum TextRenderingType{
+    HalfAndAlign, FullAndAlign, FullNotAlign, HalfAndSpace
+  };
+  TextRenderingType charRenderingType(const QChar& c);
+
+  friend class FQTermWindow;
+  // for test only
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_SCREEN_H
diff --git a/src/fqterm/fqterm_scriptengine.cpp b/src/fqterm/fqterm_scriptengine.cpp
new file mode 100644
index 0000000..efab413
--- /dev/null
+++ b/src/fqterm/fqterm_scriptengine.cpp
@@ -0,0 +1,488 @@
+/***************************************************************************
+*   fqterm, a terminal emulator for both BBS and *nix.                    *
+*   Copyright (C) 2008 fqterm development group.                          *
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+*   This program is distributed in the hope that it will be useful,       *
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+*   GNU General Public License for more details.                          *
+*                                                                         *
+*   You should have received a copy of the GNU General Public License     *
+*   along with this program; if not, write to the                         *
+*   Free Software Foundation, Inc.,                                       *
+*   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+***************************************************************************/
+

+
+
+#include "fqterm_scriptengine.h"
+#include "fqterm_window.h"
+#include "fqterm_screen.h"
+#include "fqterm_session.h"
+#include "fqterm_buffer.h"
+#include "common.h"
+#include "fqterm_path.h"
+
+#ifdef HAVE_PYTHON

+#include <Python.h>

+#endif
+
+#include <QString>
+#include <QDir>
+#include <QMessageBox>
+#include <QTime>
+#include <QTimer>
+#include <QFile>
+#include <QPoint>
+#include <QCursor>
+#include <QFileInfo>
+#include <QScriptContext>
+#include <QScriptContextInfo>
+namespace FQTerm {
+
+
+template <typename Tp>
+QScriptValue qScriptValueFromQObject(QScriptEngine *engine, Tp &qobject) {
+  return engine->newQObject(qobject);
+}
+
+template <typename Tp>
+void qScriptValueToQObject(const QScriptValue &value, Tp &qobject) {   
+  qobject = qobject_cast<Tp>(value.toQObject());
+}
+
+template <typename Tp>
+int qScriptRegisterQObjectMetaType(
+  QScriptEngine *engine, const QScriptValue &prototype = QScriptValue()
+  ) {
+    return qScriptRegisterMetaType<Tp>(engine, qScriptValueFromQObject,
+      qScriptValueToQObject, prototype);
+}
+
+
+FQTermScriptEngine::FQTermScriptEngine(FQTermWindow* parent) 
+: QObject(parent),
+  window_(parent),
+  engine_(NULL),
+  articleCopyThread_(NULL),
+  timerIDCount_(0) {
+  FQ_VERIFY(window_);
+  session_ = window_->getSession();
+  buffer_ = window_->getSession()->getBuffer();
+  screen_ = window_->getScreen();
+  articleCopyThread_ = new ArticleCopyThread(*session_, session_->getWaitCondition(), session_->getBufferLock());
+  FQ_VERIFY(connect(articleCopyThread_, SIGNAL(articleCopied(int, const QString)),
+    this, SLOT(articleCopied(int, const QString))));
+  engine_ = new QScriptEngine();
+  engine_->globalObject().setProperty(
+    "fq_session", engine_->newQObject(session_));
+  engine_->globalObject().setProperty(
+    "fq_window", engine_->newQObject(window_));
+  engine_->globalObject().setProperty(
+    "fq_buffer", engine_->newQObject(buffer_));
+  engine_->globalObject().setProperty(
+    "fq_screen", engine_->newQObject(screen_));
+  engine_->globalObject().setProperty(
+    "fqterm", engine_->newQObject(this));
+}
+
+FQTermScriptEngine::~FQTermScriptEngine() {
+  engine_->abortEvaluation();
+  delete engine_;
+}
+
+void FQTermScriptEngine::runScript( const QString& filename ) {
+  QFile file(filename);
+  if (!file.open(QIODevice::ReadOnly)) {
+    FQ_TRACE("script", 0) << "Unable to open the script file: " << filename;
+    QMessageBox::warning(window_, tr("FQTerm"),
+      tr("Unable to open the script file\n") + filename,
+      QMessageBox::Close);
+    return;
+  }
+
+  QString script = QString::fromUtf8(file.readAll());
+  QFileInfo fileInfo(filename);
+  QScriptValue result = engine_->evaluate(script, fileInfo.absoluteFilePath());
+  if (engine_->hasUncaughtException()) {
+    int line = engine_->uncaughtExceptionLineNumber();
+    FQ_TRACE("script", 0) << "uncaught exception at line " << line
+      << ":" << result.toString();
+    QMessageBox::warning(window_, tr("FQTerm"),
+      tr("uncaught exception at line ") + QString::number(line)
+      + ":\n" + result.toString(),
+      QMessageBox::Close);
+  }
+}
+
+void FQTermScriptEngine::stopScript() {
+  //all loops should be stopped here.
+  articleCopied_ = true;
+  engine_->abortEvaluation();
+}
+
+void FQTermScriptEngine::msgBox( const QString& msg ) {
+  QMessageBox::warning(window_, tr("FQTerm"),
+    msg,
+    QMessageBox::Close);
+}
+
+int FQTermScriptEngine::caretX() {
+  return buffer_->getCaretColumn();
+}
+
+int FQTermScriptEngine::caretY() {
+  return buffer_->getCaretRow();
+}
+
+int FQTermScriptEngine::columns() {
+  return buffer_->getNumColumns();
+}
+
+int FQTermScriptEngine::rows() {
+  return buffer_->getNumRows();
+}
+
+void FQTermScriptEngine::sendString(const QString& str) {
+  window_->writeRawString(str);
+}
+
+void FQTermScriptEngine::sendParsedString( const QString& str ){
+  window_->externInput(str);
+}
+
+QString FQTermScriptEngine::getText(int row) {
+  QString str;
+  if (row < rows())
+    buffer_->getTextLineInTerm(row)->getAllPlainText(str);
+  return str;
+}
+
+QString FQTermScriptEngine::getAttrText(int row) {
+  QString str;
+  if (row < rows())
+    buffer_->getTextLineInTerm(row)->getAllAnsiText(str);
+  return str;
+}
+
+bool FQTermScriptEngine::isConnected() {
+  return window_->isConnected();
+}
+
+void FQTermScriptEngine::disconnect() {
+  window_->disconnect();
+}
+
+void FQTermScriptEngine::reconnect() {
+  session_->reconnect();
+}
+
+//FIXME: UTF8 and HKSCS
+QString FQTermScriptEngine::getBBSCodec() {
+  return session_->param().serverEncodingID_ == 0 ? "GBK" : "Big5";
+}
+
+QString FQTermScriptEngine::getAddress() {
+  return session_->param().hostAddress_;
+}
+
+int FQTermScriptEngine::getPort() {
+  return session_->param().port_;
+}
+// connection protocol 0-telnet 1-SSH1 2-SSH2
+int FQTermScriptEngine::getProtocol() {
+  return session_->param().protocolType_;
+}
+
+QString FQTermScriptEngine::getReplyKey() {
+  return session_->param().replyKeyCombination_;
+}
+
+QString FQTermScriptEngine::getURL() {
+  return session_->getUrl();
+}
+
+QString FQTermScriptEngine::getIP() {
+  return session_->getIP();
+}
+
+void FQTermScriptEngine::previewImage(const QString& url) {
+  window_->getHttpHelper(url, true);
+}
+
+void FQTermScriptEngine::sleep(int ms) {
+  int originInterval = engine_->processEventsInterval();
+  engine_->setProcessEventsInterval(1);
+  QString busy_wait = "var start = new Date().getTime();\n"
+                      "while(true) {if(new Date().getTime() - start > " + QString("%1").arg(ms) + ") break;}\n";
+  engine_->evaluate(busy_wait);
+  engine_->setProcessEventsInterval(originInterval);
+}
+
+//TODO: flags
+void FQTermScriptEngine::articleCopied(int state, const QString content) {
+  if (state == DAE_FINISH) {
+    articleCopied_ = true;
+    articleText_ = content;
+  } else /*if (state == DAE_TIMEOUT)*/ {
+    articleCopied_ = true;
+    articleText_ = "";
+  }
+}
+
+QString FQTermScriptEngine::copyArticle() {
+  articleCopied_ = false;
+  articleText_ = "";
+  articleCopyThread_->wait();
+  articleCopyThread_->start();
+  while(!articleCopied_) {
+    sleep(200);
+  }
+  return articleText_;
+}
+
+void FQTermScriptEngine::finalizeScript() { 
+  engine_->setProcessEventsInterval(-1);
+  stopScript();
+  setParent(NULL);
+  //TODO: safe?
+  deleteLater();
+}
+
+void FQTermScriptEngine::writeFile( const QString& filename, const QString& str ) {
+  QFile file(filename);
+  file.open(QIODevice::WriteOnly);
+  file.write(U2U8(str));
+  file.close();
+}
+
+QString FQTermScriptEngine::readFile( const QString& filename ) {
+  QFile file(filename);
+  file.open(QIODevice::ReadOnly);
+  QString str = U82U(file.readAll());
+  file.close();
+  return str;
+}
+
+void FQTermScriptEngine::appendFile( const QString& filename, const QString& str ) {
+  QFile file(filename);
+  file.open(QIODevice::WriteOnly | QIODevice::Append);
+  file.write(U2U8(str));
+  file.close();
+}
+
+QStringList FQTermScriptEngine::readFolder( const QString& path ) {
+  return QDir(path).entryList(QDir::Files | QDir::NoSymLinks | QDir::NoDotAndDotDot | QDir::Readable);
+}
+
+QString FQTermScriptEngine::platform() {
+#if defined(WIN32)
+  return "Win";
+#elif defined(__unix__) && !defined(__APPLE__)
+  return "Linux";
+#else
+  return "Mac";
+#endif
+}
+
+bool FQTermScriptEngine::makePath( const QString& path ){
+  return QDir().mkpath(path);
+}
+
+QString FQTermScriptEngine::newLine() {
+  return OS_NEW_LINE;
+}
+
+void FQTermScriptEngine::openUrl(const QString & url) {
+  window_->openUrlImpl(url);
+}
+
+QString FQTermScriptEngine::getSelect(bool color_copy) {
+  return buffer_->getTextSelected(
+    session_->param().isRectSelect_,
+    color_copy,
+    window_->parseString((const char*)session_->param().escapeString_.toLatin1()));
+}
+
+QList<int> FQTermScriptEngine::mapToChar(int screenX, int screenY) {
+  QPoint charP(screen_->mapToChar(QPoint(screenX, screenY)));
+  QList<int> result;
+  result << charP.x() << charP.y() - screen_->getBufferStart();
+  return result;
+}
+
+int FQTermScriptEngine::charX(int screen_x) {
+  return screen_->mapToChar(QPoint(screen_x, 0)).x();
+}
+
+int FQTermScriptEngine::charY(int screen_y) {
+  return screen_->mapToChar(QPoint(0, screen_y)).y() - screen_->getBufferStart();
+}
+
+QString FQTermScriptEngine::getTextAt( int row, int column, int len ) {
+  if (column < 0 || column >= columns() ||
+      row < 0 || row >= rows()) 
+      return "";
+  if (column + len > columns() || len < 0) {
+    len = columns() - column;
+  }
+  QString result;
+  buffer_->getTextLineInTerm(row)->getPlainText(column, column + len, result);
+  return result;
+}
+
+QString FQTermScriptEngine::getAttrTextAt( int row, int column, int len ) {
+  if (column < 0 || column >= columns() ||
+    row < 0 || row >= rows()) 
+    return "";
+  if (column + len > columns() || len < 0) {
+    len = columns() - column;
+  }
+  QString result;
+  buffer_->getTextLineInTerm(row)->getAnsiText(column, column + len, result);
+  return result;
+}
+
+QString FQTermScriptEngine::getFullTextAt(int row, int column, int len) {
+  return  getTextAt(row, buffer_->getTextLineInTerm(row)->getCellBegin(column), len);
+}
+
+QString FQTermScriptEngine::getFullAttrText(int row, int column, int len) {
+  return  getAttrTextAt(row, buffer_->getTextLineInTerm(row)->getCellBegin(column), len);
+}
+
+int FQTermScriptEngine::mouseSX() {
+  return screen_->mapFromGlobal(QCursor::pos()).x();
+}
+
+int FQTermScriptEngine::mouseSY() {
+  return screen_->mapFromGlobal(QCursor::pos()).y();
+}
+
+int FQTermScriptEngine::screenX( int char_x ){
+  return screen_->mapToPixel(QPoint(char_x, 0)).x();
+}
+
+int FQTermScriptEngine::screenY( int char_y ){
+  return screen_->mapToPixel(QPoint(0, char_y + screen_->getBufferStart())).y();
+}
+
+bool FQTermScriptEngine::scriptCallback( const QString& func, const QScriptValueList& args ) {
+  QScriptValue f = engine_->globalObject().property("fqterm").property(func);
+  if (f.isFunction()) {
+    QScriptValue res = f.call(QScriptValue(), args);
+    if (!engine_->hasUncaughtException() && res.isBool()) {
+      return res.toBool();
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+bool FQTermScriptEngine::importFile( const QString& filename ) {
+  QFileInfo fileInfo(filename);
+  if (!fileInfo.isAbsolute()) {
+    //first search current running path.
+    if (engine_->currentContext() && engine_->currentContext()->parentContext()) {
+      QString runningFile = QScriptContextInfo(engine_->currentContext()->parentContext()).fileName();
+      if (!runningFile.isEmpty()) {
+        QFileInfo current(runningFile);
+        fileInfo = QFileInfo(current.absolutePath() + '/' + filename);
+      }
+    }
+    //then look in script folder.
+    if (!fileInfo.exists()) {
+      fileInfo = QFileInfo(getPath(RESOURCE) + "script/" + filename);
+    }
+  } 
+  if (!fileInfo.exists()) {
+    return false;
+  }
+  fileInfo.makeAbsolute();
+  runScript(fileInfo.absoluteFilePath());
+  return true;
+}
+
+int FQTermScriptEngine::setInterval(int ms, const QScriptValue& func) {
+  return createTimer(ms, func, false);
+}
+
+
+void FQTermScriptEngine::clearInterval(int id) {
+  destroyTimer(id);
+}
+
+void FQTermScriptEngine::serverRedraw() {
+  sendParsedString("^L");
+}
+
+void FQTermScriptEngine::clientRedraw() {
+  window_->refreshScreen();
+}
+
+void FQTermScriptEngine::setMenuRect(int row, int column, int len) {
+  if (column < 0 || column >= columns() ||
+    row < 0 || row >= rows()) 
+    return ;
+  if (column + len > columns() || len < 0) {
+    len = columns() - column;
+  }
+  row += screen_->getBufferStart();
+  session_->setMenuRect(row, column, len);
+}
+
+int FQTermScriptEngine::setTimeout(int ms, const QScriptValue& func) {
+  return createTimer(ms, func, true);
+}
+
+void FQTermScriptEngine::clearTimeout(int id) {
+  destroyTimer(id);
+}
+
+int FQTermScriptEngine::createTimer(int ms, const QScriptValue& func, bool singleShot) {
+  QTimer* timer = new QTimer(this);
+  timer->setInterval(ms);
+  timer->setSingleShot(singleShot);
+  int id = timerIDCount_++;
+  if (timerTable_.find(id) != timerTable_.end()) {
+    //actually impossible!
+    destroyTimer(id);
+  }
+  timerTable_[id] = timer;
+  bool res = qScriptConnect(timer, SIGNAL(timeout()), QScriptValue(), func);
+  timer->start();
+  return id;
+}
+
+void FQTermScriptEngine::destroyTimer(int id) {
+  if (timerTable_.find(id) != timerTable_.end()) {
+    timerTable_[id]->stop();
+    delete timerTable_[id];
+    timerTable_.erase(id);
+  }
+}
+
+int FQTermScriptEngine::getUIEventInterval() {
+  return engine_->processEventsInterval();
+}
+
+void FQTermScriptEngine::setUIEventInterval(int ms) {
+  engine_->setProcessEventsInterval(ms);
+}
+
+bool FQTermScriptEngine::isAntiIdle() {
+  return session_->isAntiIdle();
+}
+
+bool FQTermScriptEngine::isAutoReply() {
+  return session_->isAutoReply();
+}
+} // namespace FQTerm
+
+#include "fqterm_scriptengine.moc"
\ No newline at end of file
diff --git a/src/fqterm/fqterm_scriptengine.h b/src/fqterm/fqterm_scriptengine.h
new file mode 100644
index 0000000..70ca5cd
--- /dev/null
+++ b/src/fqterm/fqterm_scriptengine.h
@@ -0,0 +1,147 @@
+/***************************************************************************
+*   fqterm, a terminal emulator for both BBS and *nix.                    *
+*   Copyright (C) 2008 fqterm development group.                          *
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+*   This program is distributed in the hope that it will be useful,       *
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+*   GNU General Public License for more details.                          *
+*                                                                         *
+*   You should have received a copy of the GNU General Public License     *
+*   along with this program; if not, write to the                         *
+*   Free Software Foundation, Inc.,                                       *
+*   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+***************************************************************************/
+
+#ifndef FQTERM_SCRIPTENGINE_H
+#define FQTERM_SCRIPTENGINE_H
+
+#include "fqterm.h"
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QScriptEngine>
+#include <QScriptValue>
+#include <QList>
+#include <map>
+class QString;
+class QTimer;
+namespace FQTerm {
+class FQTermWindow;
+class FQTermSession;
+class FQTermScreen;
+class FQTermBuffer;
+class ArticleCopyThread;
+class FQTermScriptEngine : public QObject {
+  Q_OBJECT;
+public:
+  FQTermScriptEngine(FQTermWindow* parent);
+  ~FQTermScriptEngine();
+  QScriptEngine* getQtEngine() {return engine_;}
+  void runScript(const QString& filename);
+  void stopScript();
+  void finalizeScript();
+
+public:
+  bool scriptCallback(const QString& func, const QScriptValueList& args);
+public slots: //script apis
+  //ui functions.
+  void msgBox(const QString& msg);
+
+  //bbs ui functions
+  int caretX();
+  int caretY();
+  QString getText(int row);
+  QString getTextAt(int row, int column, int len);
+  //if we get from a column that contains the second part
+  //of a character with width == 2, we could still get it.
+  QString getFullTextAt(int row, int column, int len);
+  QString getAttrText(int row);
+  QString getAttrTextAt(int row, int column, int len);
+  QString getFullAttrText(int row, int column, int len);
+  void sendString(const QString& str);
+  void sendParsedString(const QString& str);
+  void serverRedraw();
+  void clientRedraw();
+  int columns();
+  int rows();
+  bool isConnected();
+  void disconnect();
+  void reconnect();
+  QString getBBSCodec();
+  QString getAddress();
+  int getPort();
+  int getProtocol();
+  QString getReplyKey();
+  QString getURL();
+  QString getIP();
+  void previewImage(const QString& url);
+  void sleep(int ms);
+  QString copyArticle();
+  void openUrl(const QString & url);
+  QString getSelect(bool color_copy);
+  QList<int> mapToChar(int screenX, int screenY);
+  //next 2 functions are map screen to char for x, y.
+  int charX(int screen_x);
+  int charY(int screen_y);
+  int screenX(int char_x);
+  int screenY(int char_y);
+  //mouse position is given in screen coordinate.
+  int mouseX() {return charX(mouseSX());}
+  int mouseY() {return charY(mouseSY());}
+
+  int mouseSX();
+  int mouseSY();
+
+  void setMenuRect(int row, int col, int len);
+
+  bool importFile(const QString& filename);
+
+  bool isAntiIdle();
+  bool isAutoReply();
+  //auxiliary functions.
+  //should be move to some other class.
+  //qt script provides so poor extensions to js.
+  void writeFile(const QString& filename, const QString& str);
+  void appendFile(const QString& filename, const QString& str);
+  QString readFile(const QString& filename);
+  QStringList readFolder(const QString& path);
+  QString platform();
+  bool makePath(const QString& path);
+  QString newLine();
+
+  //Timer
+  int setInterval(int ms, const QScriptValue& func);
+  void clearInterval(int id);
+  int setTimeout(int ms, const QScriptValue& func);
+  void clearTimeout(int id);
+
+  int getUIEventInterval();
+  void setUIEventInterval(int ms);
+private:
+  int createTimer(int ms, const QScriptValue& func, bool singleShot);
+  void destroyTimer(int id);
+
+private slots:
+  void articleCopied(int state, const QString content);
+private:
+  QScriptEngine* engine_;
+  FQTermWindow* window_;
+  FQTermSession* session_;
+  FQTermScreen* screen_;
+  FQTermBuffer* buffer_;
+  ArticleCopyThread* articleCopyThread_;
+  bool articleCopied_;
+  QString articleText_;
+  std::map<int, QTimer*> timerTable_;
+  int timerIDCount_;
+};
+
+
+}//namespace FQTerm
+#endif //FQTERM_SCRIPTENGINE_H
\ No newline at end of file
diff --git a/src/fqterm/fqterm_window.cpp b/src/fqterm/fqterm_window.cpp
new file mode 100644
index 0000000..bb2c867
--- /dev/null
+++ b/src/fqterm/fqterm_window.cpp
@@ -0,0 +1,2531 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include <QClipboard>
+#include <QDesktopServices>
+#include <QDialog>
+#include <QFileDialog>
+#include <QFontDialog>
+#include <QFontMetrics>
+#include <QInputDialog>
+#include <QImageReader>
+#include <QMenu>
+#include <QMessageBox>
+#include <QStatusBar>
+#include <QTextEdit>
+#include <QTimer>
+#include <QUrl>
+#include <QtScript/QScriptValue>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QTemporaryFile>
+#include <QRegExp>
+#include <QNetworkProxy>
+#include "addrdialog.h"
+#include "articledialog.h"
+#include "msgdialog.h"
+#include "osdmessage.h"
+#include "popwidget.h"
+#include "progressBar.h"
+#include "common.h"
+#include "fqterm_buffer.h"
+#include "fqterm_canvas.h"
+#include "fqterm_config.h"
+#include "fqterm_convert.h"
+#include "fqterm_filedialog.h"
+#include "fqterm_frame.h"
+#include "fqterm_http.h"
+#include "fqterm_ip_location.h"
+#include "fqterm_param.h"
+#include "fqterm_path.h"
+#include "fqterm_screen.h"
+#include "fqterm_session.h"
+#include "fqterm_sound.h"
+#include "fqterm_window.h"
+#include "fqterm_wndmgr.h"
+#include "imageviewer.h"
+#include "sshlogindialog.h"
+#include "statusBar.h"
+#include "zmodemdialog.h"
+#ifdef HAVE_PYTHON

+#include <Python.h>

+#include "fqterm_python.h"

+#endif //HAVE_PYTHON
+#include "fqterm_scriptengine.h"
+
+
+namespace FQTerm {
+
+char FQTermWindow::directions_[][5] =  {
+  // 4
+  "\x1b[1~",  // 0 HOME
+  "\x1b[4~",  // 1 END
+  "\x1b[5~",  // 2 PAGE UP
+  "\x1b[6~",  // 3 PAGE DOWN
+  // 3
+  "\x1b[A",  // 4 UP
+  "\x1b[B",  // 5 DOWN
+  "\x1b[D",  // 6 LEFT
+  "\x1b[C" // 7 RIGHT
+};
+
+class FAQ: public QObject {
+  Q_OBJECT;
+ public slots:
+  FAQ() {a = 100;}
+
+  int get() {return a;}
+  
+ private:
+  int a;
+};
+
+
+//constructor
+FQTermWindow::FQTermWindow(FQTermConfig *config, FQTermFrame *frame, FQTermParam param,
+                           int addressIndex, QWidget *parent,
+                           const char *name, Qt::WFlags wflags)
+    : QMainWindow(parent, wflags),
+      frame_(frame),
+      isSelecting_(false),
+      addressIndex_(addressIndex),
+      sound_(NULL),
+      isMouseClicked_(false),
+      blinkStatus_(true),
+      isUrlUnderLined_(false),
+#ifdef HAVE_PYTHON
+      // the system wide script
+      pythonScriptLoaded_(false),
+      // python thread module
+      pModule(NULL),
+      pDict(NULL),
+#endif
+      script_engine_(NULL),
+      externalEditor_(NULL) {
+  // isMouseX11_ = false;
+  session_ = new FQTermSession(config, param);
+  screen_ = new FQTermScreen(this, session_);
+
+  config_ = config;
+  zmodemDialog_ = new zmodemDialog(this);
+
+  externalEditor_ = new FQTermExternalEditor(this);
+
+  pageViewMessage_ = new PageViewMessage(this);
+  tabBlinkTimer_ = new QTimer;
+
+  setWindowIcon(QIcon("noicon"));
+  setWindowTitle(param.name_);
+  setMouseTracking(true);
+  setFocusProxy(screen_);
+  setCentralWidget(screen_);
+  addMenu();
+  setStatusBar(NULL);
+
+
+  FQ_VERIFY(connect(pageViewMessage_, SIGNAL(hideAt(const QRect&)),
+     screen_, SLOT(widgetHideAt(const QRect&))));
+
+  FQ_VERIFY(connect(frame_, SIGNAL(bossColor()),
+    screen_, SLOT(bossColor())));
+
+  FQ_VERIFY(connect(frame_, SIGNAL(fontAntiAliasing(bool)),
+    screen_, SLOT(setFontAntiAliasing(bool))));
+
+  FQ_VERIFY(connect(frame_, SIGNAL(changeLanguage()),
+                    this, SLOT(recreateMenu())));
+  FQ_VERIFY(connect(frame_, SIGNAL(bossColor()),
+                    screen_, SLOT(bossColor())));
+  FQ_VERIFY(connect(frame_, SIGNAL(updateScroll()),
+                    screen_, SLOT(updateScrollBar())));
+
+  FQ_VERIFY(connect(screen_, SIGNAL(inputEvent(const QString&)),
+                    session_, SLOT(handleInput(const QString&))));
+
+  FQ_VERIFY(connect(session_, SIGNAL(zmodemStateChanged(int, int, const char*)),
+                    this, SLOT(ZmodemState(int, int, const char *))));
+  FQ_VERIFY(connect(zmodemDialog_, SIGNAL(canceled()),
+                    session_, SLOT(cancelZmodem())));
+  FQ_VERIFY(connect(session_, SIGNAL(connectionClosed()),
+                    this, SLOT(connectionClosed())));
+  FQ_VERIFY(connect(session_, SIGNAL(startAlert()), this, SLOT(startBlink())));
+  FQ_VERIFY(connect(session_, SIGNAL(stopAlert()), this, SLOT(stopBlink())));
+  // FQ_VERIFY(connect(session_->decoder_, SIGNAL(mouseMode(bool)),
+  //                   this, SLOT(setMouseMode(bool))));
+  FQ_VERIFY(connect(session_, SIGNAL(articleCopied(int, const QString)),
+                    this, SLOT(articleCopied(int, const QString))));
+  FQ_VERIFY(connect(session_, SIGNAL(requestUserPwd(QString*, QString*, bool*)),
+                    this, SLOT(requestUserPwd(QString *, QString *, bool *))));
+  //connect telnet signal to slots
+  // QVERIFY(connect(session_->telnet_, SIGNAL(readyRead(int)),
+  //                 this, SLOT(readReady(int))));
+  FQ_VERIFY(connect(session_, SIGNAL(sessionUpdated()),
+                    this, SLOT(sessionUpdated())));
+  FQ_VERIFY(connect(session_, SIGNAL(bellReceived()), this, SLOT(beep())));
+  FQ_VERIFY(connect(session_, SIGNAL(onTitleSet(const QString&)), this, SLOT(onTitleSet(const QString&))));
+
+  FQ_VERIFY(connect(session_, SIGNAL(messageAutoReplied()),
+                    this, SLOT(messageAutoReplied())));
+  FQ_VERIFY(connect(session_, SIGNAL(telnetStateChanged(int)),
+                    this, SLOT(TelnetState(int))));
+  FQ_VERIFY(connect(session_, SIGNAL(errorMessage(QString)),
+                    this, SLOT(showSessionErrorMessage(QString))));
+
+  FQ_VERIFY(connect(tabBlinkTimer_, SIGNAL(timeout()), this, SLOT(blinkTab())));
+
+  FQ_VERIFY(connect(externalEditor_, SIGNAL(done(const QString&)), this, SLOT(externalEditorDone(const QString&))));
+
+  FQ_VERIFY(connect(this, SIGNAL(writeStringSignal(const QString&)), this, SLOT(writeString(const QString&)), Qt::QueuedConnection));
+  FQ_VERIFY(connect(this, SIGNAL(writeRawStringSignal(const QString&)), this, SLOT(writeRawString(const QString&)), Qt::QueuedConnection));
+
+#if defined(WIN32)
+  popWindow_ = new popWidget(this, frame_);
+#else
+  popWindow_ = new popWidget(this);
+#endif
+
+  const QString &resource_dir = getPath(RESOURCE);
+
+  cursors_[FQTermSession::kHome] = QCursor(
+      QPixmap(resource_dir + "cursor/home.xpm"));
+  cursors_[FQTermSession::kEnd] = QCursor(
+      QPixmap(resource_dir + "cursor/end.xpm"));
+  cursors_[FQTermSession::kPageUp] = QCursor(
+      QPixmap(resource_dir + "cursor/pageup.xpm"));
+  cursors_[FQTermSession::kPageDown] = QCursor(
+      QPixmap(resource_dir + "cursor/pagedown.xpm"));
+  cursors_[FQTermSession::kUp] = QCursor(
+      QPixmap(resource_dir + "cursor/prev.xpm"));
+  cursors_[FQTermSession::kDown] = QCursor(
+      QPixmap(resource_dir + "cursor/next.xpm"));
+  cursors_[FQTermSession::kLeft] = QCursor(
+      QPixmap(resource_dir + "cursor/exit.xpm"), 0, 10);
+  cursors_[FQTermSession::kRight] = QCursor(
+      QPixmap(resource_dir + "cursor/hand.xpm"));
+  cursors_[FQTermSession::kNormal] = Qt::ArrowCursor;
+
+  script_engine_ = new FQTermScriptEngine(this);
+  if  (session_->param().isAutoLoadScript_
+       && !session_->param().autoLoadedScriptFileName_.isEmpty()) {
+    const QString &filename = session_->param().autoLoadedScriptFileName_;
+#ifdef HAVE_PYTHON
+    if (filename.trimmed().endsWith(".py", Qt::CaseInsensitive)){
+      initPython(filename);
+    } else {
+      initPython("");
+#endif
+      runScript(filename);    
+#ifdef HAVE_PYTHON
+    }
+  } else {
+    initPython("");
+#endif //HAVE_PYTHON
+  }
+  session_->setScriptListener(this);
+}
+
+FQTermWindow::~FQTermWindow() {
+#ifdef HAVE_PYTHON
+  finalizePython();
+#endif //HAVE_PYTHON
+  script_engine_->finalizeScript();
+  //  delete telnet_;
+  delete session_;
+  delete popWindow_;
+  delete tabBlinkTimer_;
+  delete menu_;
+  delete urlMenu_;
+  delete screen_;
+  delete pageViewMessage_;
+  //delete script_engine_;
+}
+
+void FQTermWindow::addMenu() {
+  urlMenu_ = new QMenu(screen_);
+  urlMenu_->addAction(tr("Preview image"), this, SLOT(previewLink()));
+  urlMenu_->addAction(tr("Open link"), this, SLOT(openLink()));
+  urlMenu_->addAction(tr("Save As..."), this, SLOT(saveLink()));
+  urlMenu_->addAction(tr("Copy link address"), this, SLOT(copyLink()));
+  urlMenu_->addSeparator();
+  urlMenu_->addAction(tr("Share Selected Text and URL!"), this, SLOT(shareIt()));
+  const QString &resource_dir = getPath(RESOURCE);
+
+  menu_ = new QMenu(screen_);
+#if defined(__APPLE__)
+  // Please note that on MacOSX Qt::CTRL corresponds to Command key (apple key),
+  // while Qt::Meta corresponds to Ctrl key.
+  QKeySequence copy_shortcut(tr("Ctrl+C"));
+  QKeySequence paste_shortcut(tr("Ctrl+V"));
+#else
+  QKeySequence copy_shortcut(tr("Ctrl+Insert"));
+  QKeySequence paste_shortcut(tr("Shift+Insert"));
+#endif
+  menu_->addAction(QPixmap(resource_dir + "pic/copy.png"), tr("Copy"),
+                   this, SLOT(copy()), copy_shortcut);
+  menu_->addAction(QPixmap(resource_dir + "pic/paste.png"), tr("Paste"),
+                   this, SLOT(paste()), paste_shortcut);
+
+  menu_->addAction(QPixmap(resource_dir+"pic/get_article_fulltext.png"), tr("Copy Article"),
+                   this, SLOT(copyArticle()));
+  menu_->addSeparator();
+
+  QMenu *fontMenu = new QMenu(menu_);
+  fontMenu->setTitle(tr("Font"));
+  fontMenu->setIcon(QPixmap(resource_dir + "pic/change_fonts.png"));
+  for (int i = 0; i < 2; ++i) {
+    QAction *act = fontMenu->addAction(
+        FQTermParam::getLanguageName(bool(i)) + tr(" Font"),
+        this, SLOT(setFont()));
+    act->setData(i);
+  }
+  menu_->addMenu(fontMenu);
+
+  menu_->addAction(QPixmap(resource_dir + "pic/ansi_color.png"), tr("Color"),
+                   this, SLOT(setColor()));
+  menu_->addSeparator();
+  menu_->addAction(QPixmap(resource_dir + "pic/preferences.png"), tr("Setting"),
+                   this, SLOT(setting()));
+  menu_->addSeparator();
+  menu_->addAction(tr("Open Selected As Url"), this, SLOT(openAsUrl()));
+  menu_->addAction(tr("Search Selected Text!"), this, SLOT(searchIt()));
+  menu_->addAction(tr("Share Selected Text and URL!"), this, SLOT(shareIt()));
+}
+
+void FQTermWindow::recreateMenu() {
+  delete urlMenu_;
+  delete menu_;
+  addMenu();
+}
+
+//close event received
+void FQTermWindow::closeEvent(QCloseEvent *clse) {
+  bool toClose = true;
+  if (isConnected() && FQTermPref::getInstance()->openWarnOnClose_) {
+    QMessageBox mb(tr("FQTerm"),
+                   tr("Still connected, do you really want to exit?"),
+                   QMessageBox::Warning, QMessageBox::Yes|QMessageBox::Default,
+                   QMessageBox::No | QMessageBox::Escape, 0, this);
+    if (mb.exec() != QMessageBox::Yes) {
+      toClose = false;
+    }
+  }
+  if (toClose) {
+    session_->close();
+  } else {
+    clse->ignore();
+    return;
+  }
+  //We no longer save setting on close from r1036.
+  //saveSetting();
+}
+
+void FQTermWindow::blinkTab() {
+  emit blinkTheTab(this, blinkStatus_);
+  blinkStatus_ = !blinkStatus_;
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           Mouse & Key                                    */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+void FQTermWindow::enterEvent(QEvent*){}
+
+void FQTermWindow::leaveEvent(QEvent*) {
+  // TODO: code below doesn't work
+  // QPoint temp(0, 0);
+  // session_->setSelect(temp, temp, session_->isRectangleCopy_);
+  // QApplication::postEvent(screen_, new QPaintEvent(QRect(0, 0, 0, 0));
+  // &paintEvent);
+}
+
+void FQTermWindow::changeEvent(QEvent *e) {
+  if (e->type() == QEvent::WindowStateChange) {
+    QWindowStateChangeEvent *event = (QWindowStateChangeEvent*)(e);
+    Qt::WindowStates oldState = event->oldState();
+    if (!isMaximized()) {
+      emit refreshOthers(this);
+    }
+    if ( (oldState & Qt::WindowMinimized && !isMinimized()) ||
+         (!(oldState & Qt::WindowActive) && isActiveWindow())) {
+      forcedRepaintScreen();
+    }
+    if (oldState & Qt::WindowMaximized || isMaximized()) {
+      emit resizeSignal(this);
+    }
+  }
+}
+
+void FQTermWindow::resizeEvent(QResizeEvent *qResizeEvent)
+{
+  emit resizeSignal(this);
+}
+
+bool FQTermWindow::event(QEvent *qevent) {
+  bool res = false;
+  QKeyEvent *keyEvent;
+  switch(qevent->type()) {
+#ifdef __linux__ 
+    case QEvent::ShortcutOverride:    
+       keyEvent = (QKeyEvent *)(qevent);   
+       if(keyEvent->key() == Qt::Key_W &&    
+          keyEvent->modifiers() == Qt::ControlModifier) {    
+         keyEvent->accept();   
+         res = true;   
+       }   
+       break;
+#endif
+    case QEvent::KeyPress:
+      keyEvent = (QKeyEvent *)(qevent);
+      if (keyEvent->key() == Qt::Key_Tab ||
+          keyEvent->key() == Qt::Key_Backtab) {
+        // Key_Tab and Key_Backtab are special, if we don't process them here,
+        // the default behavoir is to move focus. see QWidget::event.
+        keyPressEvent(keyEvent);
+        keyEvent->accept();
+        res = true;
+      }
+      break;
+    default:
+      break;
+  }
+
+  res = res || QMainWindow::event(qevent);
+
+  if (qevent->type() == QEvent::HoverMove
+      || qevent->type() == QEvent::MouseMove
+      || qevent->type() == QEvent::Move) {
+    if (res) {
+      FQ_TRACE("wndEvent", 10) << "Accept event: " << qevent->type()
+                               << " " << getEventName(qevent->type()) << ".";
+    } else {
+      FQ_TRACE("wndEvent", 10) << "Ignore event: " << qevent->type()
+                               << " " << getEventName(qevent->type()) << ".";
+    }
+  } else {
+    if (res) {
+      FQ_TRACE("wndEvent", 9) << "Accept event: " << qevent->type()
+                              << " " << getEventName(qevent->type()) << ".";
+    } else {
+      FQ_TRACE("wndEvent", 9) << "Ignore event: " << qevent->type()
+                              << " " << getEventName(qevent->type()) << ".";
+    }
+  }
+  return res;
+}
+
+void FQTermWindow::mouseDoubleClickEvent(QMouseEvent *mouseevent) {
+  if (scriptMouseEvent(mouseevent))
+    return;
+}
+
+void FQTermWindow::mousePressEvent(QMouseEvent *mouseevent) {
+  if (scriptMouseEvent(mouseevent))
+    return;
+  // stop  the tab blinking
+  stopBlink();
+
+  // Left Button for selecting
+  if (mouseevent->button() & Qt::LeftButton && !(mouseevent->modifiers())) {
+    startSelecting(mouseevent->pos());
+  }
+
+  // Right Button
+  if ((mouseevent->button() & Qt::RightButton)) {
+    if (mouseevent->modifiers() & Qt::ControlModifier) {
+      // on Url
+      if (!session_->getUrl().isEmpty()) {
+        previewLink();
+      }
+      return ;
+    }
+
+#ifdef __APPLE__
+    bool additional_modifier = (mouseevent->modifiers() & !Qt::MetaModifier);
+#else
+    bool additional_modifier = mouseevent->modifiers();
+#endif
+
+    if (!(additional_modifier)) {
+      // on Url
+      if (!session_->getUrl().isEmpty()) {
+        urlMenu_->popup(mouseevent->globalPos());
+      } else {
+        menu_->popup(mouseevent->globalPos());
+      }
+      return ;
+    }
+  }
+  // Middle Button for paste
+  if (mouseevent->button() &Qt::MidButton && !(mouseevent->modifiers())) {
+    if (isConnected())
+      // on Url
+      if (!session_->getUrl().isEmpty()) {
+        previewLink();
+      } else {
+        pasteHelper(false);
+      }
+    return ;
+  }
+
+  // If it is a click, there should be a press event and a release event.
+  isMouseClicked_ = true;
+
+  // xterm mouse event
+  //session_->sendMouseState(0, me->button(), me->state(), me->pos());
+}
+
+
+void FQTermWindow::mouseMoveEvent(QMouseEvent *mouseevent) {
+  bool mouseEventConsumed = scriptMouseEvent(mouseevent);
+  QPoint position = mouseevent->pos();
+  if (!mouseEventConsumed)
+  {
+
+    // selecting by leftbutton
+    if ((mouseevent->buttons() &Qt::LeftButton) && isSelecting_) {
+      onSelecting(position);
+    }
+  }
+  if (!(session_->param().isSupportMouse_ && isConnected())) {
+    return;
+  }
+
+  setCursorPosition(position);
+  setCursorType(position);
+
+
+  if (!mouseEventConsumed)
+  {
+    if (!isUrlUnderLined_ && session_->urlStartPoint() != session_->urlEndPoint()) {
+      isUrlUnderLined_ = true;
+      urlStartPoint_ = session_->urlStartPoint();
+      urlEndPoint_ = session_->urlEndPoint();
+	    clientRect_ = QRect(QPoint(0, urlStartPoint_.y()), QSize(session_->getBuffer()->getNumColumns(), urlEndPoint_.y() - urlStartPoint_.y() + 1));
+	    repaintScreen();
+	  
+    } else if (isUrlUnderLined_ && (session_->urlStartPoint() != urlStartPoint_ || session_->urlEndPoint() != urlEndPoint_)) {
+      clientRect_ = QRect(QPoint(0, urlStartPoint_.y()), QSize(session_->getBuffer()->getNumColumns(), urlEndPoint_.y() - urlStartPoint_.y() + 1));
+      urlStartPoint_ = QPoint();
+      urlEndPoint_ = QPoint();
+	    repaintScreen();
+	    isUrlUnderLined_ = false;
+
+    }
+  }
+}
+
+static bool isSupportedImage(const QString &name) {
+  static QList<QByteArray> image_formats =
+      QImageReader::supportedImageFormats();
+
+  return image_formats.contains(name.section(".", -1).toLower().toUtf8());
+}
+
+void FQTermWindow::mouseReleaseEvent(QMouseEvent *mouseevent) {
+  if (scriptMouseEvent(mouseevent))
+    return;
+  if (!isMouseClicked_) {
+    return ;
+  }
+  isMouseClicked_ = false;
+  // other than Left Button ignored
+  if (!(mouseevent->button() & Qt::LeftButton) ||
+      (mouseevent->modifiers() & Qt::KeyboardModifierMask)) {
+    // no local mouse event
+    //session_->sendMouseState(3, me->button(), me->state(), me->pos());
+    return ;
+  }
+
+  // Left Button for selecting
+  QPoint currentMouseCell = screen_->mapToChar(mouseevent->pos());
+  if (currentMouseCell != lastMouseCell_ && isSelecting_) {
+    finishSelecting(mouseevent->pos());
+    return ;
+  }
+  isSelecting_ = false;
+
+  if (!session_->param().isSupportMouse_ || !isConnected()) {
+    return ;
+  }
+
+  // url
+  QString url = session_->getUrl();
+  if (!url.isEmpty()) {
+    if (isSupportedImage(url)) {
+      previewLink();      
+    } else {
+      openUrl(url);
+    }
+    return ;
+  }
+
+  processLClick(currentMouseCell);
+}
+
+void FQTermWindow::wheelEvent(QWheelEvent *wheelevent) {
+  if (scriptWheelEvent(wheelevent)) return;
+  int j = wheelevent->delta() > 0 ? 4 : 5;
+  if (!(wheelevent->modifiers())) {
+    if (FQTermPref::getInstance()->isWheelSupported_ && isConnected()) {
+      session_->writeStr(directions_[j]);
+    }
+    return ;
+  }
+  //session_->sendMouseState(j, Qt::NoButton, we->state(), we->pos());
+}
+
+//keyboard input event
+void FQTermWindow::keyPressEvent(QKeyEvent *keyevent) {
+  if (keyevent->isAutoRepeat() && !session_->getBuffer()->isAutoRepeatMode()) {
+    FQ_TRACE("sendkey", 5)
+        << "The terminal is set to not allow repeated key events.";
+    keyevent->accept();
+    return;
+  }
+  if (scriptKeyEvent(keyevent))
+    return;
+
+  keyevent->accept();
+
+  if (!isConnected()) {
+    if (keyevent->key() == Qt::Key_Return || keyevent->key() == Qt::Key_Enter) {
+      session_->reconnect();
+    }
+    return ;
+  }
+
+  // stop  the tab blinking
+  stopBlink();
+  if (!session_->readyForInput()) {
+    return;
+  }
+  // message replying
+  session_->leaveIdle();
+
+  Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
+  int key = keyevent->key();
+  sendKey(key, modifier, keyevent->text());
+}
+/*
+void FQTermWindow::focusInEvent (QFocusEvent *event) {
+  QMainWindow::focusInEvent(event);
+  screen_->setFocus(Qt::OtherFocusReason);
+}
+*/
+
+//connect slot
+void FQTermWindow::connectHost() {
+  pageViewMessage_->display(tr("Not connected"), screen_->mapToPixel(QPoint(1, 1)));
+  session_->setProxy(session_->param().proxyType_,
+                     session_->param().isAuthentation_,
+                     session_->param().proxyHostName_,
+                     session_->param().proxyPort_,
+                     session_->param().proxyUserName_,
+                     session_->param().proxyPassword_);
+  session_->connectHost(session_->param().hostAddress_, session_->param().port_);
+  config_->setItemValue("global", "lastaddrindex", QString("%1").arg(addressIndex_));
+}
+
+bool FQTermWindow::isConnected() {
+  return session_->isConnected();
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           Telnet State                                   */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+void FQTermWindow::sessionUpdated() {
+  refreshScreen();
+  //send a mouse move event to make mouse-related change
+  QMouseEvent* me = new QMouseEvent(
+      QEvent::MouseMove, mapFromGlobal(QCursor::pos()),
+      QCursor::pos(), Qt::NoButton, Qt::NoButton, Qt::NoModifier);
+  QApplication::postEvent(this, me);
+}
+
+void FQTermWindow::requestUserPwd(QString *user, QString *pwd, bool *isOK) {
+  SSHLoginDialog login(user, pwd, this);
+  *isOK = (login.exec() == QDialog::Accepted);
+}
+
+void FQTermWindow::ZmodemState(int type, int value, const char *status) {
+  QString strMsg;
+  //to be completed
+  switch (type) {
+    case RcvByteCount:
+    case SndByteCount:
+      zmodemDialog_->setProgress(value);
+      return;
+    case RcvTimeout:
+      /* receiver did not respond, aborting */
+      strMsg = QString(tr("Time out!"));
+      break;
+    case SndTimeout:
+      /* value is # of consecutive send timeouts */
+      strMsg = QString(tr("Time out after trying %1 times")).arg(value);
+      break;
+    case RmtCancel:
+      /* remote end has cancelled */
+      strMsg = QString(tr("Canceled by remote peer %1")).arg(status);
+      break;
+    case ProtocolErr:
+      /* protocol error has occurred, val=hdr */
+      strMsg = QString(
+          tr("Unhandled header %1 at state %2")).arg(value).arg(status);
+      break;
+    case RemoteMessage:
+      /* message from remote end */
+      strMsg = QString(tr("Msg from remote peer: %1")).arg(status);
+      break;
+    case DataErr:
+      /* data error, val=error count */
+      strMsg = QString(tr("Data errors %1")).arg(value);
+      break;
+    case FileErr:
+      /* error writing file, val=errno */
+      strMsg = QString(tr("Falied to write file"));
+      break;
+    case FileBegin:
+      /* file transfer begins, str=name */
+      FQ_TRACE("window", 1) << "Starting file " << status;
+      zmodemDialog_->setFileInfo(session_->bbs2unicode(status), value);
+      zmodemDialog_->setProgress(0);
+      zmodemDialog_->clearErrorLog();
+      zmodemDialog_->show();
+      zmodemDialog_->setModal(true);
+      return;
+    case FileEnd:
+      /* file transfer ends, str=name */
+      zmodemDialog_->hide();
+      return;
+    case FileSkip:
+      /* file being skipped, str=name */
+      strMsg = QString(tr("Skipping file %1")).arg(status);
+      break;
+  }
+  zmodemDialog_->addErrorLog(strMsg);
+}
+
+// telnet state slot
+void FQTermWindow::TelnetState(int state) {
+  switch (state) {
+    case TSRESOLVING:
+      pageViewMessage_->display(tr("Resolving host name"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSHOSTFOUND:
+      pageViewMessage_->display(tr("Host found"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSHOSTNOTFOUND:
+      pageViewMessage_->display(tr("Host not found"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSCONNECTING:
+      pageViewMessage_->display(tr("Connecting..."), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSHOSTCONNECTED:
+      pageViewMessage_->display(tr("Connected"), screen_->mapToPixel(QPoint(1, 1)));
+      frame_->updateMenuToolBar();
+      break;
+    case TSPROXYCONNECTED:
+      pageViewMessage_->display(tr("Connected to proxy"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSPROXYAUTH:
+      pageViewMessage_->display(tr("Proxy authentation"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSPROXYFAIL:
+      pageViewMessage_->display(tr("Proxy failed"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSREFUSED:
+      pageViewMessage_->display(tr("Connection refused"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSREADERROR:
+      pageViewMessage_->display(tr("Error when reading from server"), screen_->mapToPixel(QPoint(1, 1)), 
+                                PageViewMessage::Error);
+      break;
+    case TSCLOSED:
+      pageViewMessage_->display(tr("Connection closed"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSCLOSEFINISH:
+      pageViewMessage_->display(tr("Connection close finished"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSCONNECTVIAPROXY:
+      pageViewMessage_->display(tr("Connect to host via proxy"), screen_->mapToPixel(QPoint(1, 1)));
+      break;
+    case TSEGETHOSTBYNAME:
+      pageViewMessage_->display(
+          tr("Error in gethostbyname"), screen_->mapToPixel(QPoint(1, 1)), PageViewMessage::Error);
+      break;
+    case TSEINIWINSOCK:
+      pageViewMessage_->display(
+          tr("Error in startup winsock"), screen_->mapToPixel(QPoint(1, 1)), PageViewMessage::Error);
+      break;
+    case TSERROR:
+      pageViewMessage_->display(
+          tr("Error in connection"), screen_->mapToPixel(QPoint(1, 1)), PageViewMessage::Error);
+      break;
+    case TSPROXYERROR:
+      pageViewMessage_->display(tr("Error in proxy"), screen_->mapToPixel(QPoint(1, 1)), PageViewMessage::Error);
+      break;
+    case TSWRITED:
+      break;
+  }
+}
+
+void FQTermWindow::showSessionErrorMessage(QString reason) {
+  if (reason == tr("User Cancel")) {
+    return;
+  }
+  QMessageBox::critical(this, tr("Session error"), reason);
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           UI Slots                                       */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+
+void FQTermWindow::copy() {
+  QClipboard *clipboard = QApplication::clipboard();
+
+  QString selected_text = session_->getBuffer()->getTextSelected(
+      session_->param().isRectSelect_,
+      session_->param().isColorCopy_,
+      parseString((const char*)session_->param().escapeString_.toLatin1()));
+
+  QByteArray cstrText = session_->unicode2bbs(selected_text);
+
+  // TODO_UTF16: avoid this replacement.
+  if (!FQTermPref::getInstance()->escapeString_.isEmpty()) {
+    cstrText.replace(
+      parseString((const char*)session_->param().escapeString_.toLatin1()),
+      parseString(FQTermPref::getInstance()->escapeString_.toLatin1()));
+  }
+  selected_text = session_->bbs2unicode(cstrText);
+
+  // TODO_UTF16: there are three modes: Clipboard, Selection, FindBuffer.
+  clipboard->setText(selected_text, QClipboard::Clipboard);
+  clipboard->setText(selected_text, QClipboard::Selection);
+}
+
+void FQTermWindow::paste() {
+  pasteHelper(true);
+}
+
+void FQTermWindow::writePasting(const QString& content)
+{
+  QByteArray cstrText = session_->unicode2bbs(content);
+
+  // TODO_UTF16: avoid this replacement.
+  if (!FQTermPref::getInstance()->escapeString_.isEmpty()) {
+    cstrText.replace(
+      parseString(FQTermPref::getInstance()->escapeString_.toLatin1()),
+      parseString((const char*)session_->param().escapeString_.toLatin1()));
+  }
+
+  if (session_->param().isAutoWrap_) {
+    // convert to unicode for word wrap
+    QString strText;
+    strText = session_->bbs2unicode(cstrText);
+    // insert '\n' as needed
+    for (uint i = 0; (long)i < strText.length(); i++) {
+      uint j = i;
+      uint k = 0, l = 0;
+      while ((long)j < strText.length() && strText.at(j) != QChar('\n')) {
+        if (FQTermPref::getInstance()->widthToWrapWord_ - (l - k) >= 0
+          && FQTermPref::getInstance()->widthToWrapWord_ - (l - k) < 2) {
+            strText.insert(j, QChar('\n'));
+            k = l;
+            j++;
+            break;
+        }
+        // double byte or not
+        if (strText.at(j).row() == '\0') {
+          l++;
+        } else {
+          l += 2;
+        }
+        j++;
+      }
+      i = j;
+    }
+
+    cstrText = session_->unicode2bbs(strText);
+  }
+
+  session_->write(cstrText, cstrText.length());
+}
+
+void FQTermWindow::pasteHelper(bool clip) {
+  if (!isConnected()) {
+    return ;
+  }
+
+  // TODO_UTF16: there are three modes: Clipboard, Selection, FindBuffer.
+  QClipboard *clipboard = QApplication::clipboard();
+
+  // TODO_UTF16: what's the termFrame_->clipboardEncodingID_?
+  /*
+  if (termFrame_->clipboardEncodingID_ == 0) {
+  if (clip) {
+  cstrText = U2G(clipboard->text(QClipboard::Clipboard));
+  }
+  else {
+  cstrText = U2G(clipboard->text(QClipboard::Selection));
+  }
+
+  if (session_->param().serverEncodingID_ == 1) {
+  char *str = encodingConverter_.G2B(cstrText, cstrText.length());
+  cstrText = str;
+  delete [] str;
+  }
+  } else {
+  if (clip) {
+  cstrText = U2B(clipboard->text(QClipboard::Clipboard));
+  } else {
+  cstrText = U2B(clipboard->text(QClipboard::Selection));
+  }
+
+  if (session_->param().serverEncodingID_ == 0) {
+  char *str = encodingConverter_.B2G(cstrText, cstrText.length());
+  cstrText = str;
+  delete [] str;
+  }
+  }
+  */
+
+  QString clipStr;
+
+  if (clip) {
+    clipStr = clipboard->text(QClipboard::Clipboard);
+  } else {
+    clipStr = clipboard->text(QClipboard::Selection);
+  }
+
+  writePasting(clipStr);
+}
+
+void FQTermWindow::openAsUrl() {
+  QString selected_text = session_->getBuffer()->getTextSelected(
+    session_->param().isRectSelect_,
+    session_->param().isColorCopy_,
+    parseString((const char*)session_->param().escapeString_.toLatin1()));
+  openUrl(selected_text);
+}
+
+void FQTermWindow::searchIt()
+{
+  script_engine_->runScript(getPath(RESOURCE) + "script/search.js");
+  QScriptValueList qvl;
+  qvl << FQTermPref::getInstance()->searchEngine_;
+  if (!script_engine_->scriptCallback("searchSelected", qvl)) {
+    //fall back to google.
+    QString selected_text = session_->getBuffer()->getTextSelected(
+      session_->param().isRectSelect_,
+      session_->param().isColorCopy_,
+      parseString((const char*)session_->param().escapeString_.toLatin1()));
+    QString searchUrl = "http://www.google.com/search?client=fqterm&rls=en&q=" + selected_text + "&sourceid=fqterm";
+    QByteArray url = QUrl(searchUrl).toEncoded();
+    openUrlImpl(url);
+  }
+}
+
+void FQTermWindow::shareIt()
+{
+  script_engine_->runScript(getPath(RESOURCE) + "script/weiboshare.js");
+}
+
+void FQTermWindow::fastPost()
+{
+  QClipboard *clipboard = QApplication::clipboard();
+  QString clipStr = clipboard->text(QClipboard::Clipboard);
+  QString lineEnd("\n");
+  QString postTitle = clipStr.left(clipStr.indexOf(lineEnd));
+
+  sendParsedString("^p");
+  writeRawString(postTitle);
+  writeRawString(QString("\n\n"));
+  writePasting(clipStr);
+  sendParsedString("^W\n");
+}
+
+
+void FQTermWindow::externalEditor() {
+  externalEditor_->start();
+}
+
+
+void FQTermWindow::externalEditorDone(const QString& str) {
+  QByteArray rawStr = session_->unicode2bbs_smart(str);
+  session_->write(rawStr, rawStr.length());
+}
+
+
+void FQTermWindow::copyArticle() {
+  if (!isConnected()) {
+    return ;
+  }
+
+  session_->copyArticle();
+}
+
+void FQTermWindow::setColor() {
+  addrDialog set(this, session_->param());
+
+  set.setCurrentTabIndex(addrDialog::Display);
+  int res = set.exec();
+  if (res != 0) {
+    updateSetting(set.param());
+    if (res == 2)
+      saveSetting(false);
+  }
+
+}
+
+void FQTermWindow::disconnect() {
+  session_->close();
+
+  connectionClosed();
+}
+
+void FQTermWindow::showIP(bool show) {
+  pageViewMessage_->hide();
+  if (!show) {
+    return;
+  }
+  QString country, city;
+  QString url = session_->getIP();
+  FQTermIPLocation *ipLocation = FQTermIPLocation::getInstance();
+
+  QRect screenRect = screen_->rect();
+  QPoint messagePos;
+  QRect globalIPRectangle = QRect(screen_->mapToRect(ipRectangle_));
+  QFontMetrics fm(qApp->font());
+  int charHeight = fm.height();
+
+  int midLine = (screenRect.top() + screenRect.bottom()) / 2;
+  int ipMidLine = (globalIPRectangle.top() + globalIPRectangle.bottom()) / 2;
+  if (ipMidLine < midLine) {
+    // "There is Plenty of Room at the Bottom." -- Feyman, 1959
+    messagePos.setY(globalIPRectangle.bottom() + 0.618 * charHeight);
+  } else {
+    messagePos.setY(globalIPRectangle.top()
+                    - 0.618 * charHeight
+                    - pageViewMessage_->size().height());
+  }
+
+  QString displayText;
+  if (ipLocation == NULL) {
+    displayText = tr("IP database file does NOT exist");
+  } else if (!ipLocation->getLocation(url, country, city)) {
+    displayText = tr("Invalid IP");
+  } else {
+    displayText = country + " " + city;
+  }
+
+  QRect messageSize(pageViewMessage_->displayCheck(displayText,
+                                                   PageViewMessage::Info));
+  PageViewMessage::Alignment ali;
+  if (messageSize.width() + globalIPRectangle.left() >= screenRect.right()) {
+    //"But There is No Room at the Right" -- Curvelet, 2007
+    messagePos.setX(globalIPRectangle.right());
+    ali = PageViewMessage::TopRight;
+  } else {
+    messagePos.setX(globalIPRectangle.left());
+    ali = PageViewMessage::TopLeft;
+  }
+
+  pageViewMessage_->display(
+      displayText,
+      PageViewMessage::Info,
+      0, messagePos, ali);
+}
+
+void FQTermWindow::runScript() {
+  // get the previous dir
+  QStringList fileList;
+  FQTermFileDialog fileDialog(config_);
+
+  fileList = fileDialog.getOpenNames("Choose a Javascript file", "JavaScript File (*.js)");
+
+  if (!fileList.isEmpty() && fileList.count() == 1) {
+    runScript(fileList.at(0));
+  }
+}
+
+void FQTermWindow::stopScript() {
+  script_engine_->stopScript();
+}
+
+void FQTermWindow::viewMessages() {
+  msgDialog msg(this);
+
+  QByteArray dlgSize =
+//      frame_->config()->getItemValue("global", "msgdialog").toLatin1();
+    config_->getItemValue("global", "msgdialog").toLatin1();
+  const char *dsize = dlgSize.constData();
+  if (!dlgSize.isEmpty()) {
+    int x, y, cx, cy;
+    sscanf(dsize, "%d %d %d %d", &x, &y, &cx, &cy);
+    msg.resize(QSize(cx, cy));
+    msg.move(QPoint(x, y));
+  } else {
+    msg.resize(QSize(300, 500));
+    msg.move(QPoint(20,20));
+  }
+
+  msg.setMessageText(allMessages_);
+  msg.exec();
+
+  QString strSize = QString("%1 %2 %3 %4").arg(msg.x()).arg(msg.y()).arg
+                    (msg.width()).arg(msg.height());
+//  frame_->config()->setItemValue("global", "msgdialog", strSize);
+    config_->setItemValue("global", "msgdialog", strSize);
+}
+
+void FQTermWindow::setting() {
+  addrDialog set(this, session_->param());
+  int res = set.exec();
+  if (res != 0) {
+    updateSetting(set.param());
+    if (res == 2)
+      saveSetting(false);
+  }
+}
+
+void FQTermWindow::toggleAntiIdle() {
+  session_->setAntiIdle(!session_->isAntiIdle());
+}
+
+void FQTermWindow::toggleAutoReply() {
+  session_->setAutoReply(!session_->isAutoReply());
+}
+
+void FQTermWindow::toggleAutoReconnect() {
+  session_->setAutoReconnect(!session_->param().isAutoReconnect_);
+}
+
+void FQTermWindow::connectionClosed() {
+  stopBlink();
+
+  pageViewMessage_->display(tr("Connection closed"), screen_->mapToPixel(QPoint(1, 1)));
+
+  frame_->updateMenuToolBar();
+
+  setCursor(cursors_[FQTermSession::kNormal]);
+
+  refreshScreen();
+
+  if (!getSession()->param().isAutoReconnect_ && getSession()->param().isAutoCloseWin_) {
+    emit(connectionClosed(this));
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           Events                                         */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+void FQTermWindow::articleCopied(int e, const QString content) {
+  if (e == DAE_FINISH) {
+//    articleDialog article(frame_->config(), this);
+    articleDialog article(config_, this);
+
+    // Fix focus-losing bug.
+    // dsize should be a pointer to a non-temprary object.
+    QByteArray dlgSize =
+//        frame_->config()->getItemValue("global", "articledialog").toLatin1();
+      config_->getItemValue("global", "articledialog").toLatin1();
+
+    const char *dsize = dlgSize.constData();
+
+    if (!dlgSize.isEmpty()) {
+      int x, y, cx, cy;
+      sscanf(dsize, "%d %d %d %d", &x, &y, &cx, &cy);
+      article.resize(QSize(cx, cy));
+      article.move(QPoint(x, y));
+    } else {
+      article.resize(QSize(300, 500));
+      article.move(20,20);
+    }
+    article.articleText_ = content;
+
+    article.ui_.textBrowser->setPlainText(article.articleText_);
+    article.exec();
+    QString strSize = QString("%1 %2 %3 %4").arg(article.x()).arg(article.y())
+                      .arg(article.width()).arg(article.height());
+//    frame_->config()->setItemValue("global", "articledialog", strSize);
+    config_->setItemValue("global", "articledialog", strSize);
+  } else if (e == DAE_TIMEOUT) {
+    QMessageBox::warning(this, "timeout", "download article timeout, aborted");
+#ifdef HAVE_PYTHON
+  } else if (e == PYE_ERROR) {
+    QMessageBox::warning(this, "Python script error", pythonErrorMessage_);
+  } else if (e == PYE_FINISH) {
+    QMessageBox::information(this, "Python script finished",
+                             "Python script file executed successfully");
+#endif //HAVE_PYTHON          
+  }
+}
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           Aux Func                                       */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+QByteArray FQTermWindow::parseString(const QByteArray &cstr, int *len) {
+  QByteArray parsed = "";
+
+  if (len != 0) {
+    *len = 0;
+  }
+
+  for (uint i = 0; (long)i < cstr.length(); i++) {
+    if (cstr.at(i) == '^') {
+      i++;
+      if ((long)i < cstr.length()) {
+        parsed += FQTERM_CTRL(cstr.at(i));
+        if (len != 0) {
+          *len =  *len + 1;
+        }
+      }
+    } else if (cstr.at(i) == '\\') {
+        i++;
+        if ((long)i < cstr.length()) {
+          if (cstr.at(i) == 'n') {
+            parsed += CHAR_CR;
+          } else if (cstr.at(i) == 'r') {
+            parsed += CHAR_LF;
+          } else if (cstr.at(i) == 't') {
+            parsed += CHAR_TAB;
+          }
+          if (len != 0) {
+            *len =  *len + 1;
+          }
+        }
+      } else {
+        parsed += cstr.at(i);
+        if (len != 0) {
+          *len =  *len + 1;
+        }
+      }
+  }
+
+  return parsed;
+}
+
+void FQTermWindow::messageAutoReplied() {
+  pageViewMessage_->display("You have messages", PageViewMessage::Info, 0);
+}
+
+void FQTermWindow::saveSetting(bool ask /* = true*/) {
+  if (addressIndex_ == -1) {
+    return ;
+  }
+
+  //save these options silently
+  FQTermConfig pConf(getPath(USER_CONFIG) + "address.cfg");
+  FQTermParam param;
+  loadAddress(&pConf, addressIndex_, param);
+  param.isAutoCopy_ = session_->param().isAutoCopy_;
+  param.isAutoWrap_ = session_->param().isAutoWrap_;
+  param.isRectSelect_ = session_->param().isRectSelect_;
+  param.isColorCopy_ = session_->param().isColorCopy_;
+  saveAddress(&pConf, addressIndex_, param);
+  pConf.save(getPath(USER_CONFIG) + "address.cfg");
+
+  if (param == session_->param()) {
+    return;
+  }
+  
+  QMessageBox mb("FQTerm", "Setting changed do you want to save it?",
+                 QMessageBox::Warning, QMessageBox::Yes | QMessageBox::Default,
+                 QMessageBox::No | QMessageBox::Escape, 0, this);
+  if (!ask || mb.exec() == QMessageBox::Yes) {
+    saveAddress(&pConf, addressIndex_, session_->param());
+    pConf.save(getPath(USER_CONFIG) + "address.cfg");
+  }
+}
+
+int FQTermWindow::externInput(const QByteArray &cstrText) {
+  QByteArray cstrParsed = parseString(cstrText);
+  return session_->write(cstrParsed, cstrParsed.length());
+}
+
+int FQTermWindow::externInput(const QString &cstrText) {
+  return externInput(session_->unicode2bbs_smart(cstrText));
+}
+
+int FQTermWindow::writeRawString(const QString& str) {
+  QByteArray rawStr = session_->unicode2bbs_smart(str);
+  return session_->write(rawStr, rawStr.length());
+}
+
+void FQTermWindow::sendParsedString(const char *str) {
+  int length;
+  QByteArray cstr = parseString(str, &length);
+  session_->write(cstr, length);
+}
+
+
+bool FQTermWindow::postQtScriptCallback(const QString& func, const QScriptValueList & args) {
+  return script_engine_->scriptCallback(func, args);
+}
+
+#ifdef HAVE_PYTHON
+bool FQTermWindow::postPythonCallback( const QString& func, PyObject* pArgs )
+{
+  return pythonCallback(func, pArgs);
+}
+#endif //HAVE_PYTHON
+
+// void FQTermWindow::setMouseMode(bool on) {
+//   isMouseX11_ = on;
+// }
+
+//  /* 0-left 1-middle 2-right 3-relsase 4/5-wheel
+//   *
+//   */
+//  //void FQTermWindow::sendMouseState( int num,
+//  //    Qt::ButtonState btnstate, Qt::ButtonState keystate, const QPoint& pt )
+//  void FQTermWindow::sendMouseState(int num, Qt::KeyboardModifier btnstate,
+//                           Qt::KeyboardModifier keystate, const QPoint &pt) {
+//    /*
+//      if(!m_bMouseX11)
+//      return;
+//
+//      QPoint ptc = screen_->mapToChar(pt);
+//
+//      if(btnstate&Qt::LeftButton)
+//      num = num==0?0:num;
+//      else if(btnstate&Qt::MidButton)
+//      num = num==0?1:num;
+//      else if(btnstate&Qt::RightButton)
+//      num = num==0?2:num;
+//
+//      int state = 0;
+//      if(keystate&Qt::ShiftModifier)
+//      state |= 0x04;
+//      if(keystate&Qt::MetaModifier)
+//      state |= 0x08;
+//      if(keystate&Qt::ControlModifier)
+//      state |= 0x10;
+//
+//      // normal buttons are passed as 0x20 + button,
+//      // mouse wheel (buttons 4,5) as 0x5c + button
+//      if(num>3) num += 0x3c;
+//
+//      char mouse[10];
+//      sprintf(mouse, "\033[M%c%c%c",
+//      num+state+0x20,
+//      ptc.x()+1+0x20,
+//      ptc.y()+1+0x20);
+//      m_pTelnet->write( mouse, strlen(mouse) );
+//    */
+//  }
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           Python Func                                    */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+#ifdef HAVE_PYTHON
+
+
+void FQTermWindow::runPythonScript() {
+  QStringList fileList;
+  FQTermFileDialog fileDialog(config_);
+
+  fileList = fileDialog.getOpenNames("Choose a Python file", "Python File (*.py)");
+
+  if (!fileList.isEmpty() && fileList.count() == 1) {
+    runPythonScriptFile(fileList.at(0));
+  }
+}
+
+void FQTermWindow::runPythonScriptFile(const QString& file) {
+  QString str(QString("%1").arg(long(this)));
+	char* lp = fq_strdup(str.toUtf8().data());
+	char *argv[2]={lp,NULL};
+    // get the global python thread lock
+    PyEval_AcquireLock();
+    
+    PyInterpreterState * mainInterpreterState = frame_->getPythonHelper()->getPyThreadState()->interp;
+
+    // create a thread state object for this thread
+    PyThreadState * myThreadState = PyThreadState_New(mainInterpreterState);
+    PyThreadState_Swap(myThreadState);
+
+
+    PySys_SetArgv(1, argv);
+
+    runPythonFile(file);
+
+    //Clean up this thread's python interpreter reference
+    PyThreadState_Swap(NULL);
+    PyThreadState_Clear(myThreadState);
+    PyThreadState_Delete(myThreadState);
+    PyEval_ReleaseLock(); 
+    free((void*)lp);
+}
+
+bool FQTermWindow::pythonCallback(const QString & func, PyObject* pArgs) {
+	if(!pythonScriptLoaded_) {
+		Py_DECREF(pArgs);
+		return false;
+	};
+	
+	bool done = false;
+	// get the global lock
+  PyEval_AcquireLock();
+	// get a reference to the PyInterpreterState
+      
+	//Python thread references
+      
+	PyInterpreterState * mainInterpreterState = frame_->getPythonHelper()->getPyThreadState()->interp;
+	// create a thread state object for this thread
+	PyThreadState * myThreadState = PyThreadState_New(mainInterpreterState);
+	PyThreadState_Swap(myThreadState);
+    
+	PyObject *pF = PyString_FromString(func.toUtf8());
+	PyObject *pFunc = PyDict_GetItem(pDict, pF);
+ 	Py_DECREF(pF);
+
+	if (pFunc && PyCallable_Check(pFunc)) 
+	{
+		PyObject *pValue = PyObject_CallObject(pFunc, pArgs);
+		Py_DECREF(pArgs);
+		if (pValue != NULL) 
+		{
+      if (PyBool_Check(pValue) && pValue == Py_True)
+			  done = true;
+			Py_DECREF(pValue);
+		}
+		else 
+		{
+			//QMessageBox::warning(this,"Python script error", getException());
+      printf("%p: Python script error\n", this, getException().toUtf8().data());
+		}
+  }
+	else 
+	{
+		PyErr_Print();
+		printf("Cannot find python %s callback function\n", func.toUtf8().data());
+	}
+      
+	// swap my thread state out of the interpreter
+	PyThreadState_Swap(NULL);
+	// clear out any cruft from thread state object
+	PyThreadState_Clear(myThreadState);
+   // delete my thread state object
+	PyThreadState_Delete(myThreadState);
+	// release the lock
+	PyEval_ReleaseLock();
+
+	if (func == "autoReply")
+		startBlink();
+
+	return done;
+}
+
+
+int FQTermWindow::runPythonFile( const QString& file )
+{
+  QString buffer("def work_thread():\n"
+                 "\ttry:\n\t\texecfile('");
+  buffer += QString(file).replace("\\", "\\\\");
+
+  /* Have to do it like this. PyRun_SimpleFile requires you to pass a
+   * stdio file pointer, but Vim and the Python DLL are compiled with
+   * different options under Windows, meaning that stdio pointers aren't
+   * compatible between the two. Yuk.
+   *
+   * Put the string "execfile('file')" into buffer. But, we need to
+   * escape any backslashes or single quotes in the file name, so that
+   * Python won't mangle the file name.
+ * ---- kafa
+   */
+  
+  /* Put in the terminating "')" and a null */
+  buffer += "',{})\n\0";
+
+  buffer += QString("\texcept:\n"
+      "\t\texc, val, tb = sys.exc_info()\n"
+      "\t\tlines = traceback.format_exception(exc, val, tb)\n"
+      "\t\terr = string.join(lines)\n"
+      "\t\tprint err\n"
+      "\t\tf=open('%1','w')\n"
+      "\t\tf.write(err)\n"
+      "\t\tf.close()\n").arg(getErrOutputFile(this));
+
+  buffer += QString("\t\tfqterm.formatError(%1)\n").arg((long)this);
+  buffer += "\t\texit\n";
+
+  /* Execute the file */
+	PyRun_SimpleString("import thread,string,sys,traceback,fqterm");
+	PyRun_SimpleString(buffer.toUtf8());
+	PyRun_SimpleString(	"thread.start_new_thread(work_thread,())\n");
+
+	return 0;
+}
+
+void FQTermWindow::initPython(const QString& file) {
+
+	// get the global python thread lock
+  PyEval_AcquireLock();
+
+  // get a reference to the PyInterpreterState
+  PyInterpreterState * mainInterpreterState = frame_->getPythonHelper()->getPyThreadState()->interp;
+
+
+
+  // create a thread state object for this thread
+  PyThreadState * myThreadState = PyThreadState_New(mainInterpreterState);
+  PyThreadState_Swap(myThreadState);
+  
+  Py_InitModule4("fqterm", fqterm_methods,
+    NULL,(PyObject*)NULL,PYTHON_API_VERSION);
+    
+	PyImport_AddModule("fqterm");
+
+	if(!file.isEmpty() )
+	{
+    QFileInfo info(file);
+    PyRun_SimpleString("import sys"); 
+    PyRun_SimpleString(QString("sys.path.append(\"%1/\")").arg(info.absolutePath()).toUtf8().data()); 
+		PyObject *pName = PyString_FromString(info.baseName().toUtf8().data());
+		pModule = PyImport_Import(pName);
+    //PyErr_Print();
+		Py_DECREF(pName);
+		if (pModule != NULL) 
+			  pDict = PyModule_GetDict(pModule);
+		else
+		{
+			//printf("Failed to PyImport_Import\n");
+		}
+
+		if(pDict != NULL )
+			pythonScriptLoaded_ = true;
+		else
+		{
+			//printf("Failed to PyModule_GetDict\n");
+		}
+	}
+	
+    //Clean up this thread's python interpreter reference
+    PyThreadState_Swap(NULL);
+    PyThreadState_Clear(myThreadState);
+    PyThreadState_Delete(myThreadState);
+    PyEval_ReleaseLock();
+    
+}
+
+void FQTermWindow::finalizePython()
+{
+  // get the global python thread lock
+	PyEval_AcquireLock();
+
+	// get a reference to the PyInterpreterState
+	PyInterpreterState * mainInterpreterState = frame_->getPythonHelper()->getPyThreadState()->interp;
+      
+	// create a thread state object for this thread
+	PyThreadState * myThreadState = PyThreadState_New(mainInterpreterState);
+	PyThreadState_Swap(myThreadState);
+      
+	//Displose of current python module so we can reload in constructor.
+	if(pModule!=NULL)
+		Py_DECREF(pModule);
+
+	//Clean up this thread's python interpreter reference
+	PyThreadState_Swap(NULL);
+	PyThreadState_Clear(myThreadState);
+	PyThreadState_Delete(myThreadState);
+	PyEval_ReleaseLock();
+}
+
+#endif //HAVE_PYTHON
+
+/* ------------------------------------------------------------------------ */
+/*                                                                         */
+/*                           HTTP Func                                      */
+/*                                                                          */
+/* ------------------------------------------------------------------------ */
+
+void FQTermWindow::openLink() {
+  QString url = session_->getUrl();
+  if (!url.isEmpty()) {
+	openUrlImpl(url);
+  }
+}
+
+void FQTermWindow::saveLink() {
+  QString url = session_->getUrl();
+  if (!url.isEmpty())
+    getHttpHelper(url, false);
+}
+
+void FQTermWindow::openUrl(QString url)
+{
+  QString caption = tr("URL Dialog");
+  QString strUrl = url;
+  QTextEdit *textEdit = new QTextEdit();
+  textEdit->setPlainText(strUrl);
+  //textEdit->setFocus();
+  textEdit->setTabChangesFocus(true);
+  textEdit->moveCursor(QTextCursor::End);
+  
+
+  QPushButton *okButton = new QPushButton(tr("&Open URL"));
+  QPushButton *cancelButton = new QPushButton(tr("&Cancel"));
+//  okButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+//  cancelButton->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+  
+
+  QGridLayout *layout = new QGridLayout;
+  layout->addWidget(textEdit, 0, 0, 1, -1);
+  layout->addWidget(okButton, 1, 3);
+  layout->addWidget(cancelButton, 1, 4);
+
+  QDialog dlg(this);
+
+  QFontMetrics fm(qApp->font());
+  
+
+  connect(okButton, SIGNAL(pressed()), &dlg, SLOT(accept()));
+  connect(cancelButton, SIGNAL(pressed()), &dlg, SLOT(reject()));
+
+  
+  dlg.setWindowTitle(caption);
+  dlg.setLayout(layout);
+  dlg.resize(fm.width(QString(30, 'W')), fm.height() * (fm.width(strUrl) / fm.width(QString(30, 'W')) + 5));
+  textEdit->clearFocus();
+  okButton->setFocus(Qt::TabFocusReason);
+  if (dlg.exec()) {
+	  openUrlImpl(textEdit->toPlainText());
+  }
+}
+
+
+void FQTermWindow::openUrlImpl(QString url)
+{
+    const QString &httpBrowser = FQTermPref::getInstance()->httpBrowser_;
+    if (httpBrowser.isNull() || httpBrowser.isEmpty()) {
+#if QT_VERSION >= 0x040400
+	    QDesktopServices::openUrl(QUrl::fromEncoded(url.toLocal8Bit()));
+#else
+      QDesktopServices::openUrl(url);
+#endif
+    } else {
+	    runProgram(httpBrowser, url);
+    }
+}
+
+
+void FQTermWindow::previewLink() {
+  getHttpHelper(session_->getUrl(), true);
+}
+
+void FQTermWindow::copyLink() {
+  QString strUrl;
+  strUrl = session_->bbs2unicode(session_->getUrl().toLatin1());
+
+  QClipboard *clipboard = QApplication::clipboard();
+
+  clipboard->setText(strUrl, QClipboard::Selection);
+  clipboard->setText(strUrl, QClipboard::Clipboard);
+}
+
+void FQTermWindow::getHttpHelper(const QString &url, bool preview) {
+
+  const QString &strPool = FQTermPref::getInstance()->poolDir_;
+
+  FQTermHttp *http = new FQTermHttp(config_, this, strPool, session_->param().serverEncodingID_);
+  if (getSession()->param().proxyType_ != 0) {
+    QString host = getSession()->param().proxyHostName_;
+    int port = getSession()->param().proxyPort_;
+    bool auth = getSession()->param().isAuthentation_;
+    QString user = auth ? getSession()->param().proxyUserName_ : QString();
+    QString pass = auth ? getSession()->param().proxyPassword_ : QString();
+    switch (getSession()->param().proxyType_)
+    {
+    case 1:
+    case 2:
+      //no support in qt.
+      FQ_TRACE("network", 0) << "proxy type not supported by qt, download will not use proxy.";
+      break;
+    case 3:
+      http->setProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, host, port, user, pass));
+      break;
+    case 4:
+      http->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, host, port, user, pass));
+      break;
+    }
+  }
+  FQTerm::StatusBar::instance()->newProgressOperation(http).setDescription(tr("Waiting header...")).setAbortSlot(http, SLOT(cancel())).setMaximum(100);
+  FQTerm::StatusBar::instance()->resetMainText();
+  FQTerm::StatusBar::instance()->setProgress(http, 0);
+
+  FQ_VERIFY(connect(http, SIGNAL(headerReceived(FQTermHttp *, const QString &)),
+                    this, SLOT(startHttpDownload(FQTermHttp*,const QString&))));
+
+  FQ_VERIFY(connect(http,SIGNAL(done(QObject*)),this,SLOT(httpDone(QObject*))));
+
+  FQ_VERIFY(connect(http, SIGNAL(message(const QString &)),
+                    pageViewMessage_, SLOT(showText(const QString &))));
+
+  FQ_VERIFY(connect(http, SIGNAL(done(QObject*)),
+                    FQTerm::StatusBar::instance(),
+                    SLOT(endProgressOperation(QObject*))));
+
+  FQ_VERIFY(connect(http, SIGNAL(percent(int)),
+                    FQTerm::StatusBar::instance(), SLOT(setProgress(int))));
+
+  FQ_VERIFY(connect(http, SIGNAL(previewImage(const QString &, bool, bool)),
+                    this, SLOT(httpPreviewImage(const QString &, bool, bool))));
+
+
+  http->getLink(url, preview);
+}
+
+void FQTermWindow::startHttpDownload(
+    FQTermHttp *pHttp, const QString &filedesp) {
+  FQTerm::StatusBar::instance()->newProgressOperation(pHttp).setDescription
+      (filedesp).setAbortSlot(pHttp, SLOT(cancel())).setMaximum(100);
+
+  FQTerm::StatusBar::instance()->resetMainText();
+}
+
+void FQTermWindow::httpDone(QObject *pHttp) {
+  pHttp->deleteLater();
+}
+
+void FQTermWindow::httpPreviewImage(const QString &filename, bool raiseViewer, bool done) 
+{
+  if (config_->getItemValue("preference", "image").isEmpty() || done) {
+    previewImage(filename, raiseViewer);
+  }
+}
+
+void FQTermWindow::previewImage(const QString &filename, bool raiseViewer) {
+//  QString strViewer = frame_->config()->getItemValue("preference", "image");
+  QString strViewer = config_->getItemValue("preference", "image");
+
+  if (strViewer.isEmpty()) {
+    frame_->viewImages(filename, raiseViewer);
+  } else if(raiseViewer) {
+    runProgram(strViewer, filename);
+  }
+
+}
+
+void FQTermWindow::beep() {
+  if (session_->param().isBeep_) {
+    if (session_->param().isBuzz_) {
+      frame_->buzz(this);
+    }
+    if (FQTermPref::getInstance()->beepSoundFileName_.isEmpty() ||
+      FQTermPref::getInstance()->openBeep_ == 3) {
+      qApp->beep();
+    }
+    else {
+      sound_ = NULL;
+
+      switch (FQTermPref::getInstance()->beepMethodID_) {
+        case 0:
+          sound_ =
+              new FQTermSystemSound(FQTermPref::getInstance()->beepSoundFileName_);
+          break;
+        case 1:
+          sound_ =
+              new FQTermExternalSound(FQTermPref::getInstance()->beepPlayerName_,
+                FQTermPref::getInstance()->beepSoundFileName_);
+          break;
+      }
+
+      if (sound_) {
+        sound_->start();
+      }
+    }
+  }
+
+  QString strMsg = session_->getMessage();
+  if (!strMsg.isEmpty()) {
+    allMessages_ += strMsg + "\n\n";
+  }
+
+  session_->setSendingMessage();
+}
+
+
+void FQTermWindow::onTitleSet(const QString& title) {
+  setWindowTitle(title);
+}
+
+
+void FQTermWindow::startBlink() {
+  if (FQTermPref::getInstance()->openTabBlinking_) {
+    if (!tabBlinkTimer_->isActive()) {
+      tabBlinkTimer_->start(500);
+    }
+  }
+}
+
+void FQTermWindow::stopBlink() {
+  if (tabBlinkTimer_->isActive()) {
+    tabBlinkTimer_->stop();
+    emit blinkTheTab(this, TRUE);
+  }
+}
+
+void FQTermWindow::setCursorType(const QPoint& mousePosition) {
+  QRect rcOld;
+  bool isUrl = false;
+  if (FQTermPref::getInstance()->openUrlCheck_) {
+    showIP(session_->isIP(ipRectangle_, rcOld));
+    if (session_->isUrl(urlRectangle_, rcOld)) {
+      setCursor(Qt::PointingHandCursor);
+      isUrl = true;
+    }
+  }
+  if (!isUrl) {
+    FQTermSession::CursorType cursorType =
+        session_->getCursorType(screen_->mapToChar(mousePosition));
+    setCursor(cursors_[cursorType]);
+  }
+}
+
+void FQTermWindow::setCursorPosition(const QPoint& mousePosition) {
+  // set cursor pos, repaint if state changed
+  QRect rc;
+  if (session_->setCursorPos(screen_->mapToChar(mousePosition), rc)) {
+    screen_->repaint(screen_->mapToRect(rc));
+
+    //re-check whether the cursor is still on the selected rectangle -- dp
+    QPoint localPos = mapFromGlobal(QCursor::pos()); //local.
+    if (!session_->getMenuRect().contains(screen_->mapToChar(localPos)))
+    {
+      QRect dummyRect;
+      rc = session_->getMenuRect();
+      session_->setCursorPos(screen_->mapToChar(localPos), dummyRect);
+      screen_->repaint(screen_->mapToRect(rc));
+      //restore the state.
+      session_->setCursorPos(screen_->mapToChar(mousePosition), dummyRect); 
+    }
+  }
+}
+
+void FQTermWindow::refreshScreen() {
+  screen_->setPaintState(FQTermScreen::NewData);
+  screen_->update();
+}
+
+void FQTermWindow::repaintScreen() {
+
+  screen_->setPaintState(FQTermScreen::Repaint);
+  if (clientRect_ != QRect()) {
+    screen_->repaint(screen_->mapToRect(clientRect_));
+  } else {
+    screen_->repaint();
+  }
+  clientRect_ = QRect();
+//  screen_->update(clientRect_);
+}
+
+void FQTermWindow::enterMenuItem() {
+  char cr = CHAR_CR;
+  QRect rc = session_->getMenuRect();
+  FQTermSession::PageState ps = session_->getPageState();
+  switch (ps) {
+    case FQTermSession::Menu:
+    case FQTermSession::MailMenu:
+    case FQTermSession::TOP10:
+      if (!rc.isEmpty()) {
+        char cMenu = session_->getMenuChar();
+        session_->write(&cMenu, 1);
+        session_->write(&cr, 1);
+      }
+      break;
+    case FQTermSession::ArticleList:
+    case FQTermSession::BoardList:
+    case FQTermSession::FriendMailList:
+    case FQTermSession::EliteArticleList:
+      if (!rc.isEmpty()) {
+        int n = rc.y() - session_->getBuffer()->getCaretLine();
+        // scroll lines
+        int cursorType = n>0?FQTermSession::kDown:FQTermSession::kUp;
+        n = qAbs(n);
+        while (n) {
+          session_->write(directions_[cursorType], 4);
+          n--;
+        }
+      }
+      session_->write(&cr, 1);
+      break;
+    default:
+      // TODO: process other PageState.
+      break;
+  }
+}
+
+void FQTermWindow::processLClick(const QPoint& cellClicked) {
+  int cursorType = session_->getCursorType(cellClicked);
+  switch(cursorType)
+  {
+    case FQTermSession::kHome:
+    case FQTermSession::kEnd:
+    case FQTermSession::kPageUp:
+    case FQTermSession::kPageDown:
+      session_->writeStr(directions_[cursorType]);
+      break;
+    case FQTermSession::kUp:
+    case FQTermSession::kDown:
+    case FQTermSession::kLeft:
+      session_->writeStr(directions_[cursorType]);
+      break;
+    case FQTermSession::kRight:  //Hand
+      enterMenuItem();
+      break;
+    case FQTermSession::kNormal:
+      char cr = CHAR_CR;
+      session_->write(&cr, 1);
+      break;
+  }
+}
+
+void FQTermWindow::startSelecting(const QPoint& mousePosition) {
+  // clear the selected before
+  session_->clearSelect();
+  sessionUpdated();
+
+  // set the selecting flag
+  isSelecting_ = true;
+  lastMouseCell_ = screen_->mapToChar(mousePosition);
+}
+
+void FQTermWindow::onSelecting(const QPoint& mousePosition) {
+  if (mousePosition.y() < childrenRect().top()) {
+    screen_->scrollLine(-1);
+  }
+  if (mousePosition.y() > childrenRect().bottom()) {
+    screen_->scrollLine(1);
+  }
+
+  QPoint curMouseCell = screen_->mapToChar(mousePosition);
+  session_->setSelect(lastMouseCell_, curMouseCell);
+  sessionUpdated();
+}
+
+void FQTermWindow::finishSelecting(const QPoint& mousePosition) {
+  QPoint currentMouseCell = screen_->mapToChar(mousePosition);
+  session_->setSelect(currentMouseCell, lastMouseCell_);
+  refreshScreen();
+  if (session_->param().isAutoCopy_) {
+    copy();
+  }
+  isSelecting_ = false;
+}
+
+void FQTermWindow::sendKey(const int keyCode, const Qt::KeyboardModifiers modifier,
+                           const QString &t) {
+  if (keyCode == Qt::Key_Shift || keyCode == Qt::Key_Control
+      || keyCode == Qt::Key_Meta || keyCode == Qt::Key_Alt) {
+    return;
+  } 
+  
+  int key = keyCode;
+  QString text = t;
+  
+#ifdef __APPLE__
+  // On Mac, pressing Command Key (Apple Key) will set the ControlModifier flag.
+  bool alt_on = ((modifier & Qt::ControlModifier) || (modifier & Qt::AltModifier));
+  bool ctrl_on = (modifier & Qt::MetaModifier);
+#else
+  bool alt_on = ((modifier & Qt::MetaModifier) || (modifier & Qt::AltModifier));
+  bool ctrl_on = (modifier & Qt::ControlModifier);
+#endif
+  bool shift_on = (modifier & Qt::ShiftModifier);
+  
+#ifdef __APPLE__
+  // Bullshit! Qt4.4.0 on Mac generates weird key evnets.
+  // fix them here.
+
+  if (ctrl_on) {
+    static const char char_map[][2] = {
+      {'@', '\x00'}, {'A', '\x01'}, {'B', '\x02'}, {'C', '\x03'}, {'D', '\x04'},
+      {'E', '\x05'}, {'F', '\x06'}, {'G', '\x07'}, {'H', '\x08'}, {'J', '\x0a'},
+      {'K', '\x0b'}, {'L', '\x0c'}, {'N', '\x0e'}, {'O', '\x0f'}, {'P', '\x10'},
+      {'Q', '\x11'}, {'R', '\x12'}, {'S', '\x13'}, {'T', '\x14'}, {'U', '\x15'},
+      {'V', '\x16'}, {'W', '\x17'}, {'X', '\x18'}, {'Y', '\x19'}, {'Z', '\x1a'},
+      {'\\', '\x1c'}, {']', '\x1d'}, {'^', '\x1e'}, {'_', '\x1f'}
+    };
+
+    const int num = sizeof(char_map)/2;
+
+    int expected_key = key;
+        
+    for (int i = 0; i < num; ++i) {
+      const char *c = char_map[i];
+      if (c[0] == key) {
+        expected_key = c[1];
+        break;
+      }
+    }
+   
+    if (expected_key != key) {
+      FQ_TRACE("sendkey", 5) << "translate the key code from "
+                             << (int)key << "(" << (char)key << ")"
+                             << " to "
+                             << (int)expected_key
+                             << "(" << (char)expected_key << ")"
+                             << ", and change the text appropriately." ;
+      key = expected_key;
+      text.clear();
+      text.append((char) expected_key);
+    }
+  }
+
+  if (!ctrl_on && alt_on && !shift_on) {
+    if (text.size() == 0 && 0 <= key && key <= 128) {
+      FQ_TRACE("sendkey", 5)
+          << "add appropriate text according to the key code.";
+      text.append((char)key);
+    }
+  }
+  
+  if (!ctrl_on && alt_on && shift_on) {
+    // fix the key code when both shift key and meta/alt key are pressed.
+    static const char char_map[][2] = {
+      {'`', '~'}, {'1', '!'}, {'2', '@'}, {'3', '#'}, {'4', '$'},
+      {'5', '%'}, {'6', '^'}, {'7', '&'}, {'8', '*'}, {'9', '('}, 
+      {'0', ')'}, {'-', '_'}, {'=', '+'}, {'[', '{'}, {']', '}'}, 
+      {'\\', '|'}, {';', ':'}, {'\'', '"'}, {',', '<'},{'.', '>'},
+      {'/', '?'}
+    };
+    const int num = sizeof(char_map)/2;
+
+    int expected_key = key;
+        
+    for (int i = 0; i < num; ++i) {
+      const char *c = char_map[i];
+      if (c[0] == key) {
+        expected_key = c[1];
+        break;
+      }
+    }
+
+    if (expected_key != key) {
+      FQ_TRACE("sendkey", 5) << "translate the key code from "
+                             << (int)key << "(" << (char)key << ")"
+                             << " to "
+                             << (int)expected_key
+                             << "(" << (char)expected_key << ")";
+      key = expected_key;
+    }
+        
+    if (text.size() == 0) {
+      text.append(key);
+    } else {
+      text[0] = key;
+    }
+    FQ_TRACE("sendkey", 5)
+        << "set the text for this key event as the keycode.";
+  }      
+#endif
+
+  FQ_TRACE("sendkey", 5) << "(alt " << (alt_on? " on": "off")
+                         << ", ctrl " << (ctrl_on? " on": "off")
+                         << ", shift " << (shift_on? " on": "off") << ")"
+                         << " key: " << key
+                         << " text: " << (text.size() == 0 ? "NULL" : text)
+                         << " (in hex: "
+                         << dumpHexString << text.toStdString()
+                         << dumpNormalString << ")";
+  
+  if (session_->getBuffer()->isAnsiMode()) {
+    if (session_->getBuffer()->isCursorMode()) {
+      switch(key) {
+        case Qt::Key_Up:
+          session_->writeStr("\x1bOA");
+          return;
+        case Qt::Key_Down:
+          session_->writeStr("\x1bOB");
+          return;
+        case Qt::Key_Left:
+          session_->writeStr("\x1bOD");
+          return;
+        case Qt::Key_Right:
+          session_->writeStr("\x1bOC");
+          return;
+      }
+    } else {
+      switch(key) {
+        case Qt::Key_Up:
+          session_->writeStr("\x1b[A");
+          return;
+        case Qt::Key_Down:
+          session_->writeStr("\x1b[B");
+          return;
+        case Qt::Key_Left:
+          session_->writeStr("\x1b[D");
+          return;
+        case Qt::Key_Right:
+          session_->writeStr("\x1b[C");
+          return;
+      }
+    }
+  } else {
+    // VT52 mode
+    switch(key) {
+      case Qt::Key_Up:
+        // Do NOT change the parameter to "\x1bA".
+        session_->writeStr("\x1b" "A");
+        return;
+      case Qt::Key_Down:
+        // Do NOT change the parameter to "\x1bB".        
+        session_->writeStr("\x1b" "B");
+        return;
+      case Qt::Key_Left:
+        // Do NOT change the parameter to "\x1bD".        
+        session_->writeStr("\x1b" "D");
+        return;
+      case Qt::Key_Right:
+        // Do NOT change the parameter to "\x1bC".        
+        session_->writeStr("\x1b" "C");
+        return;
+    }
+  }
+
+  if (!session_->getBuffer()->isNumericMode() &&
+      (modifier & Qt::KeypadModifier)) {
+    switch(key) {
+      case Qt::Key_0:
+      case Qt::Key_1:
+      case Qt::Key_2:
+      case Qt::Key_3:
+      case Qt::Key_4:
+      case Qt::Key_5:
+      case Qt::Key_6:
+      case Qt::Key_7:
+      case Qt::Key_8:
+      case Qt::Key_9:
+        {
+          char tmp[] = "\x1bOp";
+          tmp[2] = 'p' + key - Qt::Key_0;
+          session_->writeStr(tmp);
+        }
+        return;
+      case Qt::Key_Plus:
+        session_->writeStr("\x1bOl");
+        return;
+      case Qt::Key_Minus:
+        session_->writeStr("\x1bOm");
+        return;
+      case Qt::Key_Period:
+        session_->writeStr("\x1bOn");
+        return;
+      case Qt::Key_Asterisk:
+        session_->writeStr("\x1bOM");
+        return;
+    }
+  }
+
+  switch (key) {
+    case Qt::Key_Home:
+      session_->writeStr(directions_[0]);
+      return;
+    case Qt::Key_End:
+      session_->writeStr(directions_[1]);
+      return;
+    case Qt::Key_PageUp:
+      session_->writeStr(directions_[2]);
+      return;
+    case Qt::Key_PageDown:
+      session_->writeStr(directions_[3]);
+      return;
+    case Qt::Key_Up:
+      session_->writeStr(directions_[4]);
+      return;
+    case Qt::Key_Down:
+      session_->writeStr(directions_[5]);
+      return;
+    case Qt::Key_Left:
+      session_->writeStr(directions_[6]);
+      return;
+    case Qt::Key_Right:
+      session_->writeStr(directions_[7]);
+      return;
+    case Qt::Key_F1:
+      session_->writeStr("\x1b[11~");
+      return;
+    case Qt::Key_F2:
+      session_->writeStr("\x1b[12~");
+      return;
+    case Qt::Key_F3:
+      session_->writeStr("\x1b[13~");
+      return;
+    case Qt::Key_F4:
+      session_->writeStr("\x1b[14~");
+      return;
+    case Qt::Key_F5:
+      session_->writeStr("\x1b[15~");
+      return;
+    case Qt::Key_F6:
+      session_->writeStr("\x1b[17~");
+      return;
+    case Qt::Key_F7:
+      session_->writeStr("\x1b[18~");
+      return;
+    case Qt::Key_F8:
+      session_->writeStr("\x1b[19~");
+      return;
+    case Qt::Key_F9:
+      session_->writeStr("\x1b[20~");
+      return;
+    case Qt::Key_F10:
+      session_->writeStr("\x1b[21~");
+      return;
+    case Qt::Key_F11:
+      session_->writeStr("\x1b[23~");
+      return;
+    case Qt::Key_F12:
+      session_->writeStr("\x1b[24~");
+      return;
+  }
+  
+  if (text.length() > 0) {
+    if (alt_on) {
+      // Use ESC to emulate Alt-XX key.
+      session_->writeStr("\x1b");
+    }
+
+    if (ctrl_on) {
+      switch(key) {
+        case Qt::Key_At:     // Ctrl-@
+        case Qt::Key_Space:  // Ctrl-SPACE
+          // send NULL
+          session_->write("\x0", 1);
+          return;
+        case Qt::Key_AsciiCircum:  // Ctrl-^
+        case Qt::Key_AsciiTilde:   // Ctrl-~
+        case Qt::Key_QuoteLeft:    // Ctrl-`
+          // send RS
+          session_->write("\x1e", 1);
+          return;
+        case Qt::Key_Underscore: // Ctrl-_
+        case Qt::Key_Question:   // Ctrl-?
+          // send US
+          session_->write("\x1f", 1);            
+          return;
+      }
+    }
+    
+    if (key == Qt::Key_Backspace) {
+      if (shift_on) {
+        session_->writeStr("\x1b[3~");
+      } else {
+        if (session_->param().backspaceType_ ==  0)
+          session_->writeStr("\x08");
+        else
+          session_->writeStr("\x7f");
+      }
+      return;
+    }
+    
+    if (key == Qt::Key_Delete) {
+      if (shift_on) {
+        if (session_->param().backspaceType_ ==  0)
+          session_->writeStr("\x08");
+        else
+          session_->writeStr("\x7f");
+      } else {
+        session_->writeStr("\x1b[3~");
+      }
+      return;
+    }
+
+    if (key == Qt::Key_Return) {
+      if (session_->getBuffer()->isNewLineMode()) {
+        session_->write("\r\n", 2);
+      } else {
+        session_->write("\r", 1);
+      }
+      return;
+    }
+    
+    QByteArray cstrTmp = session_->unicode2bbs_smart(text);
+    session_->write(cstrTmp, cstrTmp.length());
+  }
+  return;
+}
+
+void FQTermWindow::forcedRepaintScreen() {
+  QResizeEvent *re = new QResizeEvent(screen_->size(), screen_->size());
+  QApplication::postEvent(screen_, re);
+}
+
+void FQTermWindow::updateSetting(const FQTermParam& param) {
+  session_->updateSetting(param);
+  screen_->setTermFont(true,
+                       QFont(param.englishFontName_,
+                             param.englishFontSize_));
+  screen_->setTermFont(false,
+                       QFont(param.otherFontName_,
+                             param.otherFontSize_));
+  screen_->setSchema();
+
+  setWindowTitle(param.name_);
+
+  forcedRepaintScreen();
+}
+
+void FQTermWindow::setFont()
+{
+  bool isEnglish =
+       ((QAction*)(sender()))->data().toBool();
+  setFont(isEnglish);
+}
+
+void FQTermWindow::setFont(bool isEnglish) {
+  bool ok;
+  QString& fontName = isEnglish?session_->param().englishFontName_:session_->param().otherFontName_;
+  int& fontSize = isEnglish?session_->param().englishFontSize_:session_->param().otherFontSize_;
+  QFont font(fontName, fontSize);
+  font = QFontDialog::getFont(&ok, font, this, tr("Font Selector")
+#ifdef __APPLE__
+, QFontDialog::DontUseNativeDialog
+#endif
+  );
+  if (ok == true) {
+    if (FQTermPref::getInstance()->openAntiAlias_) {
+      font.setStyleStrategy(QFont::PreferAntialias);
+    }
+    screen_->setTermFont(isEnglish, font);
+    fontName = font.family();
+    fontSize = font.pointSize();
+    forcedRepaintScreen();
+  }
+}
+
+
+void FQTermWindow::runScript(const QString &filename) {
+  script_engine_->runScript(filename);
+}
+
+//-----------
+static int translateQtModifiers(Qt::KeyboardModifiers modifiers) {
+  int state = 0;
+  if (modifiers &Qt::AltModifier) {
+    state |= SBS_ALT;
+  }
+  if (modifiers &Qt::ControlModifier) {
+    state |= SBS_CTRL;
+  }
+  if (modifiers &Qt::ShiftModifier) {
+    state |= SBS_SHIFT;
+  }
+  return state;
+}
+
+static int translateQtButton(Qt::MouseButtons btnstate) {
+  int state = 0;
+  if(btnstate&Qt::LeftButton)
+    state |= SBS_LEFT_BUTTON;
+  if(btnstate&Qt::RightButton)
+    state |= SBS_RIGHT_BUTTON;
+  if(btnstate&Qt::MidButton)
+    state |= SBS_MID_BUTTON;
+  return state;
+}
+
+bool FQTermWindow::scriptKeyEvent( QKeyEvent *keyevent ){
+  bool res = false;
+  int state = 0;
+  state |= translateQtModifiers(keyevent->modifiers());
+
+  res = postScriptCallback(SFN_KEY_EVENT
+#ifdef HAVE_PYTHON
+                           ,Py_BuildValue("liii", this, SKET_KEY_PRESS, state, keyevent->key())
+#endif //HAVE_PYTHON
+                           ,QScriptValueList() << SKET_KEY_PRESS << state << keyevent->key());
+  return res;
+}
+
+bool FQTermWindow::scriptMouseEvent(QMouseEvent *mouseevent){
+  int type = SMET_UNKOWN;
+  switch (mouseevent->type())
+  {
+  case QEvent::MouseButtonPress:
+    type = SMET_MOUSE_PRESS;
+    break;
+  case QEvent::MouseButtonRelease:
+    type = SMET_MOUSE_RELEASE;
+    break;
+  case QEvent::MouseButtonDblClick:
+    type = SMET_MOUSE_DBCLICK;
+    break; 
+  case QEvent::MouseMove:
+    type = SMET_MOUSE_MOVE;
+    break;
+  }
+
+  int delta = 0;
+  int state=0;
+
+  state |= translateQtButton(mouseevent->button());
+  state |= translateQtModifiers(mouseevent->modifiers());
+
+  QPoint ptc = screen_->mapToChar(mouseevent->pos());
+  ptc.setY(ptc.y() - screen_->getBufferStart());
+  int res = postScriptCallback(SFN_MOUSE_EVENT
+#ifdef HAVE_PYTHON
+                               ,Py_BuildValue("liiiii", this, type, state, ptc.x(), ptc.y(),delta)
+#endif //HAVE_PYTHON
+                               ,QScriptValueList() << type << state << ptc.x() << ptc.y() << delta);
+  return res;
+}
+
+bool FQTermWindow::scriptWheelEvent( QWheelEvent *wheelevent ) {
+  int type = SMET_WHEEL;
+  int delta = 0;
+  int state=0;
+  state |= translateQtModifiers(wheelevent->modifiers());
+  QPoint ptc = screen_->mapToChar(wheelevent->pos());
+  ptc.setY(ptc.y() - screen_->getBufferStart());
+  int res = postScriptCallback(SFN_MOUSE_EVENT
+#ifdef HAVE_PYTHON
+                               ,Py_BuildValue("liiiii", this, type, state, ptc.x(), ptc.y(),wheelevent->delta())
+#endif //HAVE_PYTHON
+                               ,QScriptValueList() << type << state << ptc.x() << ptc.y() << wheelevent->delta());
+  return res;
+}
+
+const QString FQTermExternalEditor::textEditName_ =  "external editor input";
+
+FQTermExternalEditor::FQTermExternalEditor(QWidget* parent) 
+: QObject(parent),
+  editorProcess_(NULL),
+  started_(false) {
+  editorProcess_ = new QProcess(this);
+  FQ_VERIFY(connect(editorProcess_, SIGNAL(stateChanged(QProcess::ProcessState)), 
+                    this, SLOT(stateChanged(QProcess::ProcessState))));
+  clearTempFileContent();
+}  
+
+FQTermExternalEditor::~FQTermExternalEditor() {
+  editorProcess_->kill();
+  QFile::remove(getTempFilename());
+  delete editorProcess_;
+}
+
+void FQTermExternalEditor::execDialog() {
+  QDialog *dialog = new QDialog((QWidget *)parent());
+  QGridLayout *layout = new QGridLayout(dialog);
+  QTextEdit *text = new QTextEdit(dialog);
+  text->setObjectName(textEditName_);
+  layout->addWidget(text);
+  QBoxLayout  *rowLayout = new QBoxLayout(QBoxLayout::LeftToRight, dialog);
+  layout->addLayout(rowLayout, 1, 0, Qt::AlignHCenter);
+  QPushButton *ok = new QPushButton(tr("OK"), dialog);
+  QPushButton *cancel = new QPushButton(tr("Cancel"), dialog);
+  rowLayout->addWidget(ok);
+  rowLayout->addWidget(cancel);
+  FQ_VERIFY(connect(ok, SIGNAL(clicked()),
+    dialog, SLOT(accept())));
+  FQ_VERIFY(connect(cancel, SIGNAL(clicked()),
+    dialog, SLOT(reject())));
+  FQ_VERIFY(connect(dialog, SIGNAL(accepted()),
+    this, SLOT(readDialogData())));
+  FQ_VERIFY(connect(dialog, SIGNAL(rejected()),
+    this, SLOT(closeDialog())));
+  dialog->setModal(true);
+  dialog->exec();
+}
+
+void FQTermExternalEditor::readDialogData() {
+  QDialog *dialog = (QDialog*)sender();
+  QTextEdit* edit = (QTextEdit*)dialog->findChild<QTextEdit*>(textEditName_);
+  if (edit) {
+    emit done(edit->toPlainText());
+  }
+  closeDialog();
+}
+
+void FQTermExternalEditor::closeDialog() {
+  sender()->deleteLater();
+}
+
+void FQTermExternalEditor::start() {
+  if (FQTermPref::getInstance()->externalEditor_.isEmpty()) {
+    execDialog();
+    return;
+  }
+  if (started_)
+    return;
+  started_ = true;
+  if (FQTermPref::getInstance()->externalEditorArg_.isEmpty()) {
+    editorProcess_->start(FQTermPref::getInstance()->externalEditor_, QStringList() << getTempFilename());
+  } else {
+    FQ_TRACE("editor", 5) << FQTermPref::getInstance()->externalEditorArg_.arg(getTempFilename());
+    editorProcess_->start(FQTermPref::getInstance()->externalEditor_ + " " + FQTermPref::getInstance()->externalEditorArg_.arg(getTempFilename()));
+  }
+}
+
+
+QString FQTermExternalEditor::getTempFilename() {
+  return getPath(USER_CONFIG) + "tmp_do_not_use.txt";
+}
+
+void FQTermExternalEditor::clearTempFileContent() {
+  QFile file(getTempFilename());
+  file.open(QIODevice::Truncate | QIODevice::WriteOnly);
+  file.write("\xEF\xBB\xBF");
+  file.flush();
+  file.close();
+}
+
+void FQTermExternalEditor::stateChanged( QProcess::ProcessState state ) {
+  //FQ_TRACE("editor", 0) << "stateChanged: " << state << editorProcess_->readAllStandardOutput() << editorProcess_->readAllStandardError();
+  if (!started_ || state != QProcess::NotRunning)
+    return;
+  QFile file(getTempFilename());
+  file.open(QIODevice::ReadOnly);
+  QString result = U82U(file.readAll());
+  file.close();
+#if !defined(WIN32) && !defined(__APPLE__) 
+  if (result.endsWith(OS_NEW_LINE)) {
+    result.resize(result.size() - 1);
+  }
+#endif
+  emit done(result);
+  clearTempFileContent();
+  started_ = false;
+}
+} // namespace FQTerm
+#include "fqterm_window.moc"
diff --git a/src/fqterm/fqterm_window.h b/src/fqterm/fqterm_window.h
new file mode 100644
index 0000000..011bf86
--- /dev/null
+++ b/src/fqterm/fqterm_window.h
@@ -0,0 +1,345 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_WINDOW_H
+#define FQTERM_WINDOW_H
+
+#include <QMainWindow>
+#include <QCursor>
+#include <QString>
+#include <QProcess>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "fqterm_param.h"
+#include "fqterm_config.h"
+#include "fqterm_convert.h"
+#include "fqterm_session.h"
+
+class QCloseEvent;
+class QEvent;
+class QKeyEvent;
+class QMouseEvent;
+class QMouseEvent; 
+class QProgressBar;
+class QWheelEvent;
+
+namespace FQTerm {
+
+//class QProgressDialog;
+class PageViewMessage;
+class FQTermConfig;
+class FQTermImage;
+class FQTermFrame;
+class FQTermHttp;
+class FQTermScreen;
+class FQTermSession;
+class FQTermSound;
+class FQTermWindow;
+class popWidget;
+class zmodemDialog;
+class FQTermScriptEngine;
+
+class FQTermExternalEditor : public QObject {
+  Q_OBJECT;
+public:
+  FQTermExternalEditor(QWidget* parent);
+  ~FQTermExternalEditor();
+  void start();
+signals:
+  void done(const QString&);
+public slots:
+  void stateChanged(QProcess::ProcessState state);
+protected slots:
+  void readDialogData();
+  void closeDialog();
+private:
+  void execDialog();
+  QString getTempFilename();
+  void clearTempFileContent();
+  
+  static const QString textEditName_;
+  bool started_;
+  QProcess* editorProcess_;
+};
+
+class FQTermWindow : public QMainWindow,
+                      public FQTermScriptEventListener {
+  friend class FQTermScreen;
+
+  Q_OBJECT;
+ public:
+  FQTermWindow(FQTermConfig *, FQTermFrame *frame, FQTermParam param, int addr = -1, QWidget
+              *parent = 0, const char *name = 0, Qt::WFlags wflags = Qt::Window);
+  ~FQTermWindow();
+
+  void connectHost();
+  bool isConnected();
+
+  void disconnect();
+  //redraw the dirty lines
+  void refreshScreen();
+  //repaint a dirty rectangle.
+  void repaintScreen();
+  //force a repaint by sending a resize event
+  void forcedRepaintScreen();
+  void viewMessages();
+  void toggleAutoReply();
+  void toggleAntiIdle();
+  void toggleAutoReconnect();
+  void setFont(bool isEnglish);
+  void saveSetting(bool ask = true);
+
+  void runScript(const QString & filename);
+  int externInput(const QByteArray &);
+  int externInput(const QString &);
+  void getHttpHelper(const QString &, bool);
+
+  void openUrl(QString url);
+  void openUrlImpl(QString url);
+
+  FQTermSession * getSession() const { return session_; }
+  FQTermScreen * getScreen() const {return screen_;}
+  QPoint getUrlStartPoint() const { return urlStartPoint_; }
+  QPoint getUrlEndPoint() const { return urlEndPoint_; }
+
+  //FQTermScriptEventListener
+private:
+  virtual bool postQtScriptCallback(const QString& func, const QScriptValueList & args = QScriptValueList());
+#ifdef HAVE_PYTHON
+  virtual bool postPythonCallback(const QString& func, PyObject* pArgs);
+#endif //HAVE_PYTHON
+
+public:
+  virtual long windowID() {return long(this);}
+  //end FQTermScriptEventListener
+
+signals:
+  void resizeSignal(FQTermWindow*);
+  void refreshOthers(FQTermWindow*);
+  void blinkTheTab(FQTermWindow*, bool);
+  void connectionClosed(FQTermWindow*);
+ public slots:
+  // ui
+  void copy();
+  void paste();
+  void openAsUrl();
+  void searchIt();
+  void shareIt();
+  void externalEditor();
+  void fastPost();
+  void copyArticle();
+  void setting();
+  void setColor();
+  void runScript();
+  void stopScript();
+  
+  void sendParsedString(const char*);
+  void showIP(bool show = true);
+
+  void beep();
+  void startBlink();
+  void stopBlink();
+  void onTitleSet(const QString& title);
+
+  void connectionClosed();
+
+  void messageAutoReplied();
+
+  void pasteHelper(bool);
+
+  QByteArray parseString(const QByteArray &, int *len = 0);
+
+  //  void sendMouseState(int, Qt::KeyboardModifier, Qt::KeyboardModifier, const
+  //                    QPoint &);
+
+
+ protected slots:
+  void setFont();
+  void recreateMenu();
+  
+  //refresh screen & reset cursor position
+  void sessionUpdated();
+
+  void requestUserPwd(QString *userName, QString *password, bool *isOK);
+
+  void TelnetState(int);
+  void ZmodemState(int, int, const char *);
+  void showSessionErrorMessage(QString);
+
+  void blinkTab();
+
+  void externalEditorDone(const QString& str);
+
+  //http menu
+  void previewLink();
+  void saveLink();
+  void openLink();
+  void copyLink();
+  void previewImage(const QString &filename, bool raiseViewer);
+  void httpPreviewImage(const QString &filename, bool raiseViewer, bool done);
+  void startHttpDownload(FQTermHttp *, const QString &filedesp);
+
+  void httpDone(QObject*);
+ 
+  // decode
+  // void setMouseMode(bool);
+  void articleCopied(int e, const QString content);
+
+
+ protected:
+  bool event(QEvent*);
+
+  void resizeEvent(QResizeEvent *);
+  void mouseDoubleClickEvent(QMouseEvent*);
+  void mouseMoveEvent(QMouseEvent*);
+  void mousePressEvent(QMouseEvent*);
+  void mouseReleaseEvent(QMouseEvent*);
+  void wheelEvent(QWheelEvent*);
+  void enterEvent(QEvent*);
+  void leaveEvent(QEvent*);
+  void changeEvent(QEvent*);
+  void closeEvent(QCloseEvent*);
+  void keyPressEvent(QKeyEvent*);
+  //void focusInEvent (QFocusEvent *);
+
+ private:
+  FQTermFrame *frame_;
+  FQTermScreen *screen_;
+  FQTermSession *session_;
+  QString allMessages_;
+  // before calling repaintScreen(), pls
+  // fill this rectangle.
+  QRect clientRect_;
+  QPoint urlEndPoint_;
+  QPoint urlStartPoint_;
+
+  QMenu *menu_;
+  QMenu *urlMenu_;
+
+  static char directions_[][5];
+  QCursor cursors_[9];
+
+  FQTermConvert encodingConverter_;
+
+  // mouse select
+  QPoint lastMouseCell_;
+  bool isSelecting_;
+
+  // address setting
+  int addressIndex_;
+
+  // url rect
+  QRect urlRectangle_;
+
+  //ip rect
+  QRect ipRectangle_;
+ 
+  // play sound
+  FQTermSound *sound_;
+
+
+  FQTermConfig *config_;
+  zmodemDialog *zmodemDialog_;
+
+  //osd
+  PageViewMessage *pageViewMessage_;
+
+  popWidget *popWindow_;
+  QTimer *tabBlinkTimer_;
+
+  bool isMouseClicked_;
+  bool blinkStatus_;
+
+  bool isUrlUnderLined_;
+
+  FQTermScriptEngine *script_engine_;  
+  FQTermExternalEditor *externalEditor_;
+ private:
+  void addMenu();
+
+  void setCursorPosition(const QPoint& mousePosition);
+  //set cursor type according to the content
+  //show ip location info if openUrlCheck is set
+  void setCursorType(const QPoint& mousePosition);
+
+
+  void enterMenuItem();
+  void processLClick(const QPoint& cellClicked);
+
+  void startSelecting(const QPoint& mousePosition);
+  void onSelecting(const QPoint& mousePosition);
+  void finishSelecting(const QPoint& mousePosition);
+
+  void updateSetting(const FQTermParam& param);
+
+  void sendKey(const int key, const Qt::KeyboardModifiers modifier,
+               const QString &text);
+
+  bool scriptKeyEvent(QKeyEvent *keyevent);
+  bool scriptMouseEvent(QMouseEvent *mouseevent);
+  bool scriptWheelEvent(QWheelEvent *wheelevent);
+
+  void writePasting(const QString& content);
+
+
+signals: 
+  //these 2 signals are connected to corresponding slots to 
+  //make write thread safe.
+  int writeStringSignal(const QString& str);
+  int writeRawStringSignal(const QString& str);
+public slots:
+  //for script
+  int writeString(const QString& str) {return externInput(str);}
+  int writeRawString(const QString& str);
+public:
+  void writeString_ts(const QString& str) {emit writeStringSignal(str);}
+  void writeRawString_ts(const QString& str) {emit writeRawStringSignal(str);}
+
+
+    
+//python support
+#ifdef HAVE_PYTHON
+public:
+  QString getPythonErrorMessage() {
+    return pythonErrorMessage_;
+  }
+  void runPythonScript();
+  void runPythonScriptFile(const QString&);
+  
+protected:
+	bool pythonCallback(const QString &, PyObject*);
+	int runPythonFile(const QString& file);
+  void initPython(const QString& file);
+  void finalizePython();
+  //void sendMouseState(int, ButtonState, ButtonState, const QPoint&);
+private:
+	PyObject *pModule, *pDict;
+  bool pythonScriptLoaded_;
+  QString pythonErrorMessage_;
+#endif
+
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_WINDOW_H
+
diff --git a/src/fqterm/fqterm_wndmgr.cpp b/src/fqterm/fqterm_wndmgr.cpp
new file mode 100644
index 0000000..0e90b1c
--- /dev/null
+++ b/src/fqterm/fqterm_wndmgr.cpp
@@ -0,0 +1,381 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+/////////////////////////////////////////////////////////////////
+//TODO: This class has too many overlap with MDI Area.
+//It should inherit the QMdiArea...
+/////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+
+#include <QApplication>
+#include <QEvent>
+#include <QKeyEvent>
+#include <QIcon>
+#include <QKeySequence>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QTabBar>
+#include <QMouseEvent>
+#include <QMenu>
+#include <QMessageBox>
+#include <QToolButton>
+#include "fqterm_frame.h"
+#include "fqterm_path.h"
+#include "fqterm_screen.h"
+#include "fqterm_trace.h"
+#include "fqterm_window.h"
+#include "fqterm_wndmgr.h"
+#ifdef HAVE_PYTHON

+#include <Python.h>

+#endif //HAVE_PYTHON
+namespace FQTerm {
+
+//constructor
+FQTermWndMgr::FQTermWndMgr(QWidget *parent, const char *name)
+    : QMdiArea(parent),
+      subWindowMax_(true),
+      subWindowSize_(640, 480),
+      tabBar_(NULL)
+ {
+  tabBar_ = new FQTermTabBar(this);
+  tabBar_->setShape(QTabBar::RoundedSouth);
+  FQ_VERIFY(connect(tabBar_, SIGNAL(currentChanged(int)),
+    this, SLOT(activateTheWindow(int))));
+  FQ_VERIFY(connect(tabBar_, SIGNAL(rightClicked(int,const QPoint&)),
+    this, SLOT(onTabRightClicked(int,const QPoint&))));
+  FQ_VERIFY(connect(tabBar_, SIGNAL(doubleClicked(int,const QPoint&)),
+    this, SLOT(onTabDoubleClicked(int,const QPoint&))));
+  setObjectName(name);
+  termFrame_ = (FQTermFrame*)parent;
+  isAfterRemoved_ = false;
+}
+
+//destructor
+FQTermWndMgr::~FQTermWndMgr(){}
+
+
+//remove window-tab-iconset
+bool FQTermWndMgr::closeWindow(FQTermWindow *mw) {
+  FQ_FUNC_TRACE("wndmgr", 3);
+  QMdiSubWindow* subWindow = FQToMDI(mw);
+  if (subWindow) {
+    return subWindow->close();
+  }
+  return false;
+}
+
+bool FQTermWndMgr::closeAllWindow() {
+  FQ_FUNC_TRACE("wndmgr", 3);
+
+  bool anyConnected = false;
+
+  for (int i = 0; i < subWindowList().size(); ++i) {
+    FQTermWindow * window = (FQTermWindow *)(subWindowList()[i]->widget());
+    if (window->isConnected()) {
+      anyConnected = true;
+      break;
+    }
+  }
+
+  bool warn = FQTermPref::getInstance()->openWarnOnClose_;
+  if (anyConnected && warn) {
+    QMessageBox mb(tr("FQTerm"),
+      tr("Still connected, do you really want to exit?"),
+      QMessageBox::Warning, QMessageBox::Yes|QMessageBox::Default,
+      QMessageBox::No | QMessageBox::Escape, 0, this);
+    if (mb.exec() != QMessageBox::Yes) {
+      return false;
+    }
+  }
+  FQTermPref::getInstance()->openWarnOnClose_ = false;
+  while (count() > 0) {
+    bool closed = subWindowList().at(0)->close();
+    if (!closed) {
+      FQTermPref::getInstance()->openWarnOnClose_ = warn;
+      return false;
+    }
+  }
+  FQTermPref::getInstance()->openWarnOnClose_ = warn;
+  return true;
+}
+
+
+
+//active the window when switch the tab
+void FQTermWndMgr::activateTheWindow(int n) {
+  FQ_FUNC_TRACE("wndmgr", 3);
+
+  if (n < 0 || n >= count() || subWindowList().at(n) == activeSubWindow())
+    return;
+
+  QMdiSubWindow *subWindow = subWindowList().at(n);
+
+  // Fix the refresh bug by send PaintEvent to session screen.
+  //subWindow->setFocus();
+  setActiveSubWindow(subWindow);
+  
+}
+
+//blink the tab when message come in
+void FQTermWndMgr::blinkTheTab(FQTermWindow *mw, bool bVisible) {
+  FQ_FUNC_TRACE("wndmgr", 10);
+  static QIcon a_icon(getPath(RESOURCE) + "pic/tabpad.png");
+  static QIcon b_icon(getPath(RESOURCE) + "pic/transp.png");
+
+  //find where it is
+  QMdiSubWindow* subWindow = FQToMDI(mw);
+  if (!subWindow)
+    return;
+  int n = subWindowList().indexOf(subWindow);
+  QIcon *icon = icons_.at(n);
+  //FIXME: QIcon::Automatic
+  if (bVisible) {
+    icon->addFile(getPath(RESOURCE) + "pic/tabpad.png");
+
+    tabBar_->setTabIcon(n, a_icon);
+  } else {
+    //,QIcon::Automatic);
+    icon->addFile(getPath(RESOURCE) + "pic/transp.png");
+    tabBar_->setTabIcon(n, b_icon);
+  }
+  //,QIcon::Automatic);
+
+
+  
+
+  tabBar_->update();
+}
+
+//return the number of connected window
+int FQTermWndMgr::count() {
+  return subWindowList().count();
+}
+
+FQTermWindow *FQTermWndMgr::activeWindow() {
+  return MDIToFQ(activeSubWindow());
+}
+
+
+bool FQTermWndMgr::afterRemove() {
+  if (isAfterRemoved_) {
+    isAfterRemoved_ = false;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void FQTermWndMgr::refreshAllExcept(FQTermWindow *termWindow) {
+  for (int i = 0; i < subWindowList().count(); ++i) {
+    FQTermWindow * window = (FQTermWindow *)(subWindowList()[i]->widget());
+    if (window != termWindow) {
+      window->repaintScreen();
+    }
+  }
+}
+
+
+FQTermWindow* FQTermWndMgr::newWindow( const FQTermParam &param, FQTermConfig* config, QIcon* icon, int index /*= -1*/ )
+{
+  FQTermWindow *window = new FQTermWindow(config, termFrame_, param, index, this, 0);
+  //add window-tab-icon to window manager
+
+
+  QMdiSubWindow* subWindow = addSubWindow(window);
+  subWindow->setAttribute(Qt::WA_OpaquePaintEvent);
+  subWindow->setAttribute(Qt::WA_DeleteOnClose);
+
+  icons_.append(icon);
+  if (count() == 1) {
+    termFrame_->enableMenuToolBar(true);
+  }
+  //if no this call, the tab wont display untill you resize the window
+  int idx = tabBar_->addTab(*icon, window->windowTitle());
+  tabBar_->updateGeometry();
+  tabBar_->update();
+
+  subWindow->resize(subWindowSize_);
+  if (subWindowMax_) {
+    subWindow->setWindowFlags(Qt::SubWindow | Qt::CustomizeWindowHint | Qt::WindowMinMaxButtonsHint);
+    subWindow->showMaximized();
+  } else {
+    subWindow->setWindowFlags(Qt::SubWindow | (Qt::CustomizeWindowHint
+      | Qt::WindowMinMaxButtonsHint
+      | Qt::WindowSystemMenuHint));
+    subWindow->show();
+  }
+  tabBar_->setTabData(idx, qVariantFromValue((QObject*)window));
+  FQ_VERIFY(connect(window, SIGNAL(destroyed(QObject*)), 
+    this ,SLOT(onSubWindowClosed(QObject*))));
+  FQ_VERIFY(connect(window, SIGNAL(resizeSignal(FQTermWindow*)),
+		    this, SLOT(subWindowResized(FQTermWindow*))));
+  FQ_VERIFY(connect(this, SIGNAL(subWindowActivated(QMdiSubWindow*)),
+        this, SLOT(onSubWindowActivated(QMdiSubWindow*))));
+  FQ_VERIFY(connect(window, SIGNAL(blinkTheTab(FQTermWindow*, bool)),
+       this, SLOT(blinkTheTab(FQTermWindow*, bool))));
+  FQ_VERIFY(connect(window, SIGNAL(refreshOthers(FQTermWindow*)),
+       this, SLOT(refreshAllExcept(FQTermWindow*))));
+  FQ_VERIFY(connect(window, SIGNAL(connectionClosed(FQTermWindow*)),
+    this, SLOT(closeWindow(FQTermWindow*)), Qt::QueuedConnection));
+  return window;
+}
+
+void FQTermWndMgr::onSubWindowClosed(QObject* obj) {
+
+  for (int i = 0; i < tabBar_->count(); ++i) {
+    if (tabBar_->tabData(i) == qVariantFromValue(obj)) {
+      if (count() == 0) {
+        termFrame_->enableMenuToolBar(false);
+      }
+      if (i == tabBar_->currentIndex())
+        isAfterRemoved_ = true;
+      tabBar_->removeTab(i);
+      icons_.removeAt(i);
+    }
+  }
+
+}
+
+//---------------------------
+//record subwindows' size 
+//---------------------------
+void
+FQTermWndMgr::subWindowResized(FQTermWindow *mw) {
+  QMdiSubWindow* subWindow = FQToMDI(mw);
+  if (!subWindow)
+    return;
+  Qt::WindowFlags wfs = subWindow->windowFlags();
+
+  if (!(subWindowMax_ = subWindow->isMaximized())){
+    if (!subWindow->isMinimized()) {
+      subWindowSize_ = subWindow->frameSize();
+    }
+    subWindow->setWindowFlags(wfs | Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint);
+  }
+  else {
+    subWindow->setWindowFlags(wfs & ~Qt::WindowSystemMenuHint);
+  }
+
+}
+
+void FQTermWndMgr::cascade() {
+  QSize oldSize = subWindowSize_;
+  cascadeSubWindows();
+  foreach(QMdiSubWindow* subWindow, subWindowList()) {
+    if (subWindow) {
+      subWindow->resize(oldSize);
+    }
+  }
+}
+
+void FQTermWndMgr::tile() {
+  tileSubWindows();
+}
+
+void FQTermWndMgr::activateNextWindow() {
+  activateTheWindow((activeWindowIndex() + 1) % count());
+}
+
+void FQTermWndMgr::activatePrevWindow() {
+  activateTheWindow((activeWindowIndex() - 1 + count()) % count());
+}
+
+FQTermWindow * FQTermWndMgr::nthWindow(int n) {
+  return (FQTermWindow *)(subWindowList()[n]->widget());
+}
+
+void FQTermWndMgr::onSubWindowActivated(QMdiSubWindow * subWindow) {
+  int n = subWindowList().indexOf(subWindow);
+  if (n == -1)
+    return;
+  FQTermWindow* mw = MDIToFQ(subWindow);
+  if (mw->isMaximized() &&
+    afterRemove()) {
+      mw->showNormal();
+      mw->showMaximized();
+  }
+  if (tabBar_->currentIndex() != n) {
+    FQ_VERIFY(disconnect(this, SIGNAL(subWindowActivated(QMdiSubWindow*)),
+      this, SLOT(onSubWindowActivated(QMdiSubWindow*))));
+    tabBar_->setCurrentIndex(n);
+    FQ_VERIFY(connect(this, SIGNAL(subWindowActivated(QMdiSubWindow*)),
+      this, SLOT(onSubWindowActivated(QMdiSubWindow*))));
+  }
+  termFrame_->updateMenuToolBar();
+}
+
+void FQTermWndMgr::onTabRightClicked(int index, const QPoint& p) {
+  QMenu* menu = FQToMDI(nthWindow(index))->systemMenu();
+  menu->popup(p);
+}
+
+void FQTermWndMgr::onTabDoubleClicked(int index, const QPoint& p) {
+  closeWindow(nthWindow(index));
+}
+
+FQTermWindow* FQTermWndMgr::MDIToFQ( QMdiSubWindow* subWindow )
+{
+  if (!subWindowList().contains(subWindow))
+    return NULL;
+  return (FQTermWindow*)subWindow->widget();
+}
+
+QMdiSubWindow* FQTermWndMgr::FQToMDI( FQTermWindow* window )
+{
+  for (int i = 0; i < subWindowList().count(); ++i) {
+    if ((FQTermWindow*)(subWindowList()[i]->widget()) == window) {
+      return subWindowList()[i];
+    }
+  } 
+  return NULL;
+}
+ 
+int FQTermWndMgr::FQToIndex( FQTermWindow* window )
+{
+  return subWindowList().indexOf(FQToMDI(window));
+}
+
+bool FQTermWndMgr::event( QEvent* e ) {
+  if (e->type() == QEvent::ShortcutOverride) {
+    QKeyEvent* ke = (QKeyEvent*)e;
+    if (ke->key() == Qt::Key_W && ke->modifiers() == Qt::ControlModifier) {
+      ke->accept();
+      return true;
+    }
+  }
+  return QMdiArea::event(e);
+}
+void FQTermTabBar::mouseReleaseEvent( QMouseEvent * me ) {
+  int index = tabAt(me->pos());
+  if (index != -1 && me->button() == Qt::RightButton && me->modifiers() == Qt::NoModifier) {
+    emit rightClicked(index, mapToGlobal(me->pos()));
+  }
+}
+
+void FQTermTabBar::mouseDoubleClickEvent( QMouseEvent * me ) {
+  int index = tabAt(me->pos());
+  if (index != -1 && me->button() == Qt::LeftButton && me->modifiers() == Qt::NoModifier) {
+    emit doubleClicked(index, mapToGlobal(me->pos()));
+  }
+}
+}  // namespace FQTerm
+
+#include "fqterm_wndmgr.moc"
diff --git a/src/fqterm/fqterm_wndmgr.h b/src/fqterm/fqterm_wndmgr.h
new file mode 100644
index 0000000..5038d8f
--- /dev/null
+++ b/src/fqterm/fqterm_wndmgr.h
@@ -0,0 +1,115 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#ifndef FQTERM_WND_MGR_H
+#define FQTERM_WND_MGR_H
+
+#include <QString>
+#include <QList>
+#include <map>
+#include <utility>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QTabBar>
+
+class QEvent;
+class QIcon;
+class QSize;
+class FQTermConfig;
+namespace FQTerm {
+
+class FQTermWindow;
+class FQTermFrame;
+
+class FQTermTabBar : public QTabBar {
+  Q_OBJECT;
+public:
+  FQTermTabBar(QWidget *parent = 0) : QTabBar(parent) {}
+protected:
+  virtual void mouseReleaseEvent(QMouseEvent * me);
+  virtual void mouseDoubleClickEvent(QMouseEvent * me);
+signals:
+  void rightClicked(int index, const QPoint& p);
+  void doubleClicked(int index, const QPoint& p);
+};
+
+class FQTermWndMgr: public QMdiArea {
+  Q_OBJECT;
+ public:
+  FQTermWndMgr(QWidget *parent = 0, const char *name = 0);
+  ~FQTermWndMgr();
+
+  QTabBar* tabBar() {return tabBar_;}
+  
+  FQTermWindow* newWindow(const FQTermParam &param, FQTermConfig* config, QIcon* icon, int index = -1);
+  bool closeAllWindow();
+
+
+
+  FQTermWindow *activeWindow();
+  int activeWindowIndex() {
+    return FQToIndex(activeWindow());
+  }
+  FQTermWindow *nthWindow(int n);
+  int count();
+
+  //sub-window position & size
+
+  bool getSubWindowMax() const { return subWindowMax_; }
+  void setSubWindowMax(bool val) { subWindowMax_ = val; }
+  QSize getSubWindowSize() const { return subWindowSize_; }
+  void setSubWindowSize(QSize val) { subWindowSize_ = val; }
+
+ public slots:
+   bool closeWindow(FQTermWindow *mw);
+   void onSubWindowClosed(QObject* obj);
+   //record subwindows' size changes
+   void subWindowResized(FQTermWindow *);
+   void activateTheWindow(int n);
+   void activateNextWindow();
+   void activatePrevWindow();
+   void refreshAllExcept(FQTermWindow *mw);
+   void blinkTheTab(FQTermWindow *mw, bool bVisible);
+   void cascade();
+   void tile();
+
+protected:
+
+  QList<QIcon *> icons_;
+  FQTermFrame *termFrame_;
+  bool isAfterRemoved_;
+  QSize subWindowSize_;
+  bool subWindowMax_;
+  FQTermTabBar* tabBar_;
+
+  FQTermWindow* MDIToFQ(QMdiSubWindow* subWindow);
+  QMdiSubWindow* FQToMDI(FQTermWindow* window);
+  int FQToIndex(FQTermWindow* window);
+  bool afterRemove();
+  bool event(QEvent* e);
+protected slots:
+  void onSubWindowActivated(QMdiSubWindow * subWindow);
+  void onTabRightClicked(int index, const QPoint& p);
+  void onTabDoubleClicked(int index, const QPoint& p);
+};
+
+}  // namespace FQTerm
+
+#endif  // FQTERM_WND_MGR_H
diff --git a/src/fqterm/main.cpp b/src/fqterm/main.cpp
new file mode 100644
index 0000000..40969fd
--- /dev/null
+++ b/src/fqterm/main.cpp
@@ -0,0 +1,135 @@
+/***************************************************************************
+ *   fqterm, a terminal emulator for both BBS and *nix.                    *
+ *   Copyright (C) 2008 fqterm development group.                          *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.               *
+ ***************************************************************************/
+
+#include <stdlib.h>
+
+#if defined(WIN32)
+#include <windows.h>
+#include <shellapi.h>
+#else
+#include <sys/stat.h>
+#include <errno.h>
+#include <locale.h>
+#endif
+
+#if defined(FQTERM_USE_STATIC_QT)
+  // You can change the definition of FQTERM_USE_STATIC_QT in 
+  // fqterm/CMakeLists.txt.{linux, macos, win32}.
+
+  // static link Qt4 plugins.
+  void loadNecessaryQtPlugins() {}
+  #include <QtPlugin>
+  Q_IMPORT_PLUGIN(qkrcodecs)
+  Q_IMPORT_PLUGIN(qcncodecs)
+  Q_IMPORT_PLUGIN(qjpcodecs)
+  Q_IMPORT_PLUGIN(qtwcodecs)
+  Q_IMPORT_PLUGIN(qjpeg)
+  Q_IMPORT_PLUGIN(qgif)
+  Q_IMPORT_PLUGIN(qmng)
+#else
+  // dynamic link Qt4 plugins.
+  #include <QPluginLoader>
+  void loadNecessaryQtPlugins() {
+    static QPluginLoader qkrcodecsLoader( "qkrcodecs" );
+    static QPluginLoader qcncodecsLoader( "qcncodecs" );
+    static QPluginLoader qjpcodecsLoader( "qjpcodecs" );
+    static QPluginLoader qtwcodecsLoader( "qtwcodecs" );
+    static QPluginLoader qjpegLoader("qjpeg");
+    static QPluginLoader qgifLoader("qgif");
+    static QPluginLoader qmngLoader("qmng");
+   
+    qkrcodecsLoader.load();
+    qcncodecsLoader.load();
+    qjpcodecsLoader.load();
+    qtwcodecsLoader.load();
+    qjpegLoader.load();
+    qgifLoader.load();
+    qmngLoader.load();
+  }
+#endif
+
+#include <QApplication>
+#include <QTranslator>
+#include <QFontDatabase>
+#include <QTextCodec>
+
+#include "fqterm.h"
+#include "fqterm_app.h"
+#include "fqterm_frame.h"
+#include "fqterm_path.h"
+#include "fqterm_trace.h"
+#include "fqterm_config.h"
+#include "fqterm_param.h"
+#include "fqterm_text_line.h"
+
+
+
+
+int main(int argc, char **argv) {
+#if defined(WIN32)
+#else
+  QApplication::setGraphicsSystem("raster");
+#endif
+  FQTerm::FQTermApplication a(argc, argv);
+  // Set trace categories and level.
+  FQTerm::setMaxTraceLevel(1);
+  for (int i = 1; i < argc; ++i) {
+    QString str(argv[i]);
+    bool ok;
+    int max_level = str.toInt(&ok, 0); 
+
+    if (ok) {
+      FQTerm::setMaxTraceLevel(max_level);
+    } else {
+      FQTerm::addAllowedCategory(argv[i]);
+    }
+  }
+
+  using namespace FQTerm;
+
+  loadNecessaryQtPlugins();
+
+  // char buf[] = "\xc8\xb8";
+  // QString ucs2 = QTextCodec::codecForName("Big5")->toUnicode(buf);
+  // QVector<uint> ucs4 = ucs2.toUcs4(); 
+  // QByteArray utf8 = ucs2.toUtf8();
+  // const char *utf8c = utf8.constData();
+
+  // FQ_TRACE("text", 0) << "\n" << dumpHexString << std::string(buf, sizeof(buf) - 1)
+  //                     << dumpNormalString << " \n-->"
+  //                     << dumpNormalString << "\nucs4 " << ucs4.size() << " " << ucs4[0]
+  //                     << dumpNormalString << "\nucs2 " << ucs2.size() << " " << ucs2.at(0).unicode()
+  //                     << dumpNormalString << "\nutf8   " << dumpHexString << utf8c;
+  //return 0;
+  
+  if (!iniSettings()) {
+    return -1;
+  }
+
+  FQTermFrame *mw = new FQTermFrame();
+  mw->setWindowTitle("FQTerm " + QString(FQTERM_VERSION_STRING));
+  mw->setWindowIcon(QPixmap(getPath(RESOURCE) + "pic/fqterm.png"));
+  mw->show();
+  a.setQuitOnLastWindowClosed(false);
+  FQ_VERIFY(a.connect(mw, SIGNAL(destroyed(QObject*)), &a, SLOT(mainWindowDestroyed(QObject*)), Qt::QueuedConnection));
+  FQ_VERIFY(a.connect(&a, SIGNAL(saveData()), mw, SLOT(saveSetting())));
+  int res = a.exec();
+  return res;
+}