text
stringlengths 8
6.88M
|
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
//constant initialization
const ll MOD=998244353;
const ll maxn=1e6+10;
const ll INF=1e18;
//variables used for the current problem
int n,k,cnt[maxn];
vector<vector<int>> a;
ll ans;
ll fastpow(ll x, ll y){
ll res = 1;
while (y>0){
if (y&1) res = (res*x)%MOD;
y>>=1;
x = (x*x)%MOD;
}
return res;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
a.resize(n);
for (int i=0;i<n;++i){
cin >> k;
a[i].resize(k);
for (int &j : a[i]) {
cin >> j; ++cnt[j];
}
}
const ll invN = fastpow(n,MOD-2);
for (int i=0;i<n;++i){
const ll inv_ai=fastpow(a[i].size(),MOD-2);
for (const int &j : a[i]){
ans = (ans +((invN*inv_ai)%MOD)*(invN*cnt[j]%MOD))%MOD;
}
}
cout << ans;
return 0;
}
|
//
// Created by wqy on 20-1-9.
//
#include "ProverifConst.h"
|
#include <libbig/big.hpp>
#include "util.hpp"
#include <iostream>
#include <algorithm>
#include "buffer.hpp"
using namespace libbig;
bool Big::Load(const std::string& name)
{
if(m_stream.is_open())
m_stream.close();
m_stream.open(name,std::ios::in| std::ios::binary);
//check if archive exists
if (m_stream.fail())
return false;
m_mutex.lock();
//check if it's a big archive
std::string magic;
for (int i = 0; i < 4; ++i)
magic += m_stream.get();
if (magic == std::string("BIGF"))
m_version = CC;
else if (magic == std::string("BIG4"))
m_version = BFME;
else
return false;
m_size = read<uint32_t>(m_stream);
m_numEntries = reverse(read<uint32_t>(m_stream));
uint32_t first = reverse(read<uint32_t>(m_stream));
m_entries.clear();
for (auto i = 0; i < m_numEntries; i++)
{
Entry e;
e.Offset = reverse(read<uint32_t>(m_stream));
e.Size = reverse(read<uint32_t>(m_stream));
auto Name = readString(m_stream);
std::replace(Name.begin(),Name.end(),'\\','/');
std::transform(Name.begin(),Name.end(),Name.begin(),::tolower);
m_entries[Name] = e;
}
m_mutex.unlock();
return true;
}
bool Big::Write(const std::string& name)
{
return false;
}
uint8_t* Big::GetBinary(const std::string& entry, uint32_t& size)
{
size = 0;
std::string Name = entry;
std::replace(Name.begin(),Name.end(),'\\','/');
std::transform(Name.begin(),Name.end(),Name.begin(),::tolower);
auto it = m_entries.find(Name);
if (it == m_entries.end())
return nullptr;
m_mutex.lock();
Entry e = it->second;
uint8_t* buffer = new uint8_t[e.Size];
m_stream.seekg(e.Offset, std::ios::beg);
m_stream.read(reinterpret_cast<char*>(buffer), e.Size);
size = e.Size;
m_mutex.unlock();
return buffer;
}
std::string Big::GetText(const std::string& entry)
{
std::string Name = entry;
std::replace(Name.begin(),Name.end(),'\\','/');
std::transform(Name.begin(),Name.end(),Name.begin(),::tolower);
auto it = m_entries.find(Name);
if (it == m_entries.end())
return std::string();
m_mutex.lock();
Entry e = it->second;
std::string buffer;
buffer.resize(e.Size);
m_stream.seekg(e.Offset, std::ios::beg);
m_stream.read(const_cast<char*>(buffer.data()), e.Size);
m_mutex.unlock();
return buffer;
}
Big::Entry Big::GetInfo(const std::string& entry)
{
std::string Name = entry;
std::replace(Name.begin(),Name.end(),'\\','/');
std::transform(Name.begin(),Name.end(),Name.begin(),::tolower);
auto it = m_entries.find(Name);
if (it == m_entries.end())
return Entry();
return it->second;
}
void Big::AddEntry(const std::string & entry, const std::string & text, bool overwrite)
{
}
void Big::AddEntry(const std::string & entry, const uint8_t * data, uint32_t size, bool overwrite)
{
}
std::vector<std::string> Big::ListEntries()
{
std::vector<std::string> entries;
for (const auto& e : m_entries)
{
entries.push_back(e.first);
}
return entries;
}
|
#include <iostream>
int main(){
int n;
std::cout << "Enter number of elements: ";
std::cin >> n;
int a[n];
std::cout << "Start entering numbers" << '\n';
for (int i=0;i<n;i++){
std::cin >> a[i];
}
std::cout <<'\n';
int temp;
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (a[j]<a[i]){
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
std::cout << "Sorted" << '\n';
for (int i=0;i<n;i++){
std::cout<<a[i]<<" ";
}
std::cout <<'\n';
return 0;
}
|
//**************************************************************************
//**
//** See jlquake.txt for copyright info.
//**
//** 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 3
//** 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
//** included (gnu.txt) GNU General Public License for more details.
//**
//**************************************************************************
#include "local.h"
#include "../../common/file_formats/tag.h"
#include "../wolfmp/local.h"
#include "../et/local.h"
#include "../public.h"
#include "../../common/Common.h"
#include "../../common/common_defs.h"
#include "../../common/strings.h"
#include "../../common/command_buffer.h"
#include "../../common/huffman.h"
#include "../../common/event_queue.h"
#include "../../common/system.h"
#include "../../common/endian.h"
#define HEARTBEAT_MSEC 300 * 1000
#define Q3HEARTBEAT_GAME "QuakeArena-1"
#define WSMHEARTBEAT_GAME "Wolfenstein-1"
#define WMHEARTBEAT_DEAD "WolfFlatline-1"
#define ETHEARTBEAT_GAME "EnemyTerritory-1"
#define ETHEARTBEAT_DEAD "ETFlatline-1" // NERVE - SMF
Cvar* svt3_gametype;
Cvar* svt3_pure;
Cvar* svt3_padPackets; // add nop bytes to messages
Cvar* svt3_maxRate;
Cvar* svt3_dl_maxRate;
Cvar* svt3_mapname;
Cvar* svt3_timeout; // seconds without any message
Cvar* svt3_zombietime; // seconds to sink messages after disconnect
Cvar* svt3_allowDownload;
Cvar* svet_wwwFallbackURL; // URL to send to if an http/ftp fails or is refused client side
Cvar* svet_wwwDownload; // server does a www dl redirect
Cvar* svet_wwwBaseURL; // base URL for redirect
// tell clients to perform their downloads while disconnected from the server
// this gets you a better throughput, but you loose the ability to control the download usage
Cvar* svet_wwwDlDisconnected;
Cvar* svt3_lanForceRate; // dedicated 1 (LAN) server forces local client rates to 99999 (bug #491)
Cvar* svwm_showAverageBPS; // NERVE - SMF - net debugging
Cvar* svet_tempbanmessage;
Cvar* svwm_onlyVisibleClients;
Cvar* svq3_strictAuth;
Cvar* svet_fullmsg;
Cvar* svt3_reconnectlimit; // minimum seconds between connect messages
Cvar* svt3_minPing;
Cvar* svt3_maxPing;
Cvar* svt3_privatePassword; // password for the privateClient slots
Cvar* svt3_privateClients; // number of clients reserved for password
Cvar* svt3_floodProtect;
Cvar* svt3_reloading;
Cvar* svt3_master[ Q3MAX_MASTER_SERVERS ]; // master server ip address
Cvar* svt3_gameskill;
Cvar* svt3_allowAnonymous;
Cvar* svt3_friendlyFire; // NERVE - SMF
Cvar* svt3_maxlives; // NERVE - SMF
Cvar* svwm_tourney; // NERVE - SMF
Cvar* svet_needpass;
Cvar* svt3_rconPassword; // password for remote server commands
Cvar* svt3_fps; // time rate for running non-clients
Cvar* svt3_killserver; // menu system can set to 1 to shut server down
// Converts newlines to "\n" so a line prints nicer
static const char* SVT3_ExpandNewlines( const char* in ) {
static char string[ 1024 ];
int l = 0;
while ( *in && l < ( int )sizeof ( string ) - 3 ) {
if ( *in == '\n' ) {
string[ l++ ] = '\\';
string[ l++ ] = 'n';
} else {
// NERVE - SMF - HACK - strip out localization tokens before string command is displayed in syscon window
if ( GGameType & ( GAME_WolfMP | GAME_ET ) &&
( !String::NCmp( in, "[lon]", 5 ) || !String::NCmp( in, "[lof]", 5 ) ) ) {
in += 5;
continue;
}
string[ l++ ] = *in;
}
in++;
}
string[ l ] = 0;
return string;
}
// The given command will be transmitted to the client, and is guaranteed to
// not have future snapshot_t executed before it is executed
void SVT3_AddServerCommand( client_t* client, const char* cmd ) {
client->q3_reliableSequence++;
// if we would be losing an old command that hasn't been acknowledged,
// we must drop the connection
// we check == instead of >= so a broadcast print added by SVT3_DropClient()
// doesn't cause a recursive drop client
int maxReliableCommands = GGameType & GAME_Quake3 ? MAX_RELIABLE_COMMANDS_Q3 : MAX_RELIABLE_COMMANDS_WOLF;
if ( client->q3_reliableSequence - client->q3_reliableAcknowledge == maxReliableCommands + 1 ) {
common->Printf( "===== pending server commands =====\n" );
int i;
for ( i = client->q3_reliableAcknowledge + 1; i <= client->q3_reliableSequence; i++ ) {
common->Printf( "cmd %5d: %s\n", i, SVT3_GetReliableCommand( client, i & ( maxReliableCommands - 1 ) ) );
}
common->Printf( "cmd %5d: %s\n", i, cmd );
SVT3_DropClient( client, "Server command overflow" );
return;
}
int index = client->q3_reliableSequence & ( maxReliableCommands - 1 );
SVT3_AddReliableCommand( client, index, cmd );
}
// Sends a reliable command string to be interpreted by
// the client game module: "cp", "print", "chat", etc
// A NULL client will broadcast to all clients
void SVT3_SendServerCommand( client_t* cl, const char* fmt, ... ) {
va_list argptr;
byte message[ MAX_MSGLEN ];
va_start( argptr,fmt );
Q_vsnprintf( ( char* )message, sizeof ( message ), fmt, argptr );
va_end( argptr );
// do not forward server command messages that would be too big to clients
// ( q3infoboom / q3msgboom stuff )
if ( GGameType & ( GAME_WolfMP | GAME_ET ) && String::Length( ( char* )message ) > 1022 ) {
return;
}
if ( cl != NULL ) {
SVT3_AddServerCommand( cl, ( char* )message );
return;
}
// hack to echo broadcast prints to console
if ( com_dedicated->integer && !String::NCmp( ( char* )message, "print", 5 ) ) {
common->Printf( "broadcast: %s\n", SVT3_ExpandNewlines( ( char* )message ) );
}
// send the data to all relevent clients
client_t* client = svs.clients;
for ( int j = 0; j < sv_maxclients->integer; j++, client++ ) {
if ( client->state < CS_PRIMED ) {
continue;
}
// Ridah, don't need to send messages to AI
if ( client->q3_entity && client->q3_entity->GetSvFlagCastAI() ) {
continue;
}
if ( GGameType & GAME_ET && client->q3_entity && client->q3_entity->GetSvFlags() & Q3SVF_BOT ) {
continue;
}
SVT3_AddServerCommand( client, ( char* )message );
}
}
int SVET_LoadTag( const char* mod_name ) {
for ( int i = 0; i < sv.et_num_tagheaders; i++ ) {
if ( !String::ICmp( mod_name, sv.et_tagHeadersExt[ i ].filename ) ) {
return i + 1;
}
}
unsigned char* buffer;
FS_ReadFile( mod_name, ( void** )&buffer );
if ( !buffer ) {
return 0;
}
tagHeader_t* pinmodel = ( tagHeader_t* )buffer;
int version = LittleLong( pinmodel->version );
if ( version != TAG_VERSION ) {
common->Printf( S_COLOR_YELLOW "WARNING: SVET_LoadTag: %s has wrong version (%i should be %i)\n", mod_name, version, TAG_VERSION );
FS_FreeFile( buffer );
return 0;
}
if ( sv.et_num_tagheaders >= MAX_TAG_FILES_ET ) {
common->Error( "MAX_TAG_FILES_ET reached\n" );
FS_FreeFile( buffer );
return 0;
}
#define LL( x ) x = LittleLong( x )
LL( pinmodel->ident );
LL( pinmodel->numTags );
LL( pinmodel->ofsEnd );
LL( pinmodel->version );
#undef LL
String::NCpyZ( sv.et_tagHeadersExt[ sv.et_num_tagheaders ].filename, mod_name, MAX_QPATH );
sv.et_tagHeadersExt[ sv.et_num_tagheaders ].start = sv.et_num_tags;
sv.et_tagHeadersExt[ sv.et_num_tagheaders ].count = pinmodel->numTags;
if ( sv.et_num_tags + pinmodel->numTags >= MAX_SERVER_TAGS_ET ) {
common->Error( "MAX_SERVER_TAGS_ET reached\n" );
FS_FreeFile( buffer );
return 0;
}
// swap all the tags
md3Tag_t* tag = &sv.et_tags[ sv.et_num_tags ];
sv.et_num_tags += pinmodel->numTags;
md3Tag_t* readTag = ( md3Tag_t* )( buffer + sizeof ( tagHeader_t ) );
for ( int i = 0; i < pinmodel->numTags; i++, tag++, readTag++ ) {
for ( int j = 0; j < 3; j++ ) {
tag->origin[ j ] = LittleFloat( readTag->origin[ j ] );
tag->axis[ 0 ][ j ] = LittleFloat( readTag->axis[ 0 ][ j ] );
tag->axis[ 1 ][ j ] = LittleFloat( readTag->axis[ 1 ][ j ] );
tag->axis[ 2 ][ j ] = LittleFloat( readTag->axis[ 2 ][ j ] );
}
String::NCpyZ( tag->name, readTag->name, 64 );
}
FS_FreeFile( buffer );
return ++sv.et_num_tagheaders;
}
// Updates the cl->ping variables
static void SVT3_CalcPings() {
for ( int i = 0; i < sv_maxclients->integer; i++ ) {
client_t* cl = &svs.clients[ i ];
if ( cl->state != CS_ACTIVE ) {
cl->ping = 999;
continue;
}
if ( !cl->q3_entity ) {
cl->ping = 999;
continue;
}
if ( cl->q3_entity->GetSvFlags() & Q3SVF_BOT ) {
cl->ping = 0;
continue;
}
int total = 0;
int count = 0;
for ( int j = 0; j < PACKET_BACKUP_Q3; j++ ) {
if ( cl->q3_frames[ j ].messageAcked <= 0 ) {
continue;
}
int delta = cl->q3_frames[ j ].messageAcked - cl->q3_frames[ j ].messageSent;
count++;
total += delta;
}
if ( !count ) {
cl->ping = 999;
} else {
cl->ping = total / count;
if ( cl->ping > 999 ) {
cl->ping = 999;
}
}
// let the game dll know about the ping
idPlayerState3* ps = SVT3_GameClientNum( i );
ps->SetPing( cl->ping );
}
}
// If a packet has not been received from a client for timeout->integer
// seconds, drop the conneciton. Server time is used instead of
// realtime to avoid dropping the local client while debugging.
// When a client is normally dropped, the client_t goes into a zombie state
// for a few seconds to make sure any final reliable message gets resent
// if necessary
static void SVT3_CheckTimeouts() {
int droppoint = svs.q3_time - 1000 * svt3_timeout->integer;
int zombiepoint = svs.q3_time - 1000 * svt3_zombietime->integer;
client_t* cl = svs.clients;
for ( int i = 0; i < sv_maxclients->integer; i++,cl++ ) {
// message times may be wrong across a changelevel
if ( cl->q3_lastPacketTime > svs.q3_time ) {
cl->q3_lastPacketTime = svs.q3_time;
}
if ( cl->state == CS_ZOMBIE &&
cl->q3_lastPacketTime < zombiepoint ) {
// using the client id cause the cl->name is empty at this point
common->DPrintf( "Going from CS_ZOMBIE to CS_FREE for client %d\n", i );
cl->state = CS_FREE; // can now be reused
continue;
}
// Ridah, AI's don't time out
if ( !( GGameType & GAME_WolfSP ) || ( cl->q3_entity && !cl->q3_entity->GetSvFlagCastAI() ) ) {
if ( cl->state >= CS_CONNECTED && cl->q3_lastPacketTime < droppoint ) {
// wait several frames so a debugger session doesn't
// cause a timeout
if ( ++cl->q3_timeoutCount > 5 ) {
SVT3_DropClient( cl, "timed out" );
cl->state = CS_FREE; // don't bother with zombie state
}
} else {
cl->q3_timeoutCount = 0;
}
}
}
}
static bool SVT3_CheckPaused() {
if ( !cl_paused->integer ) {
return false;
}
// only pause if there is just a single client connected
int count = 0;
client_t* cl = svs.clients;
for ( int i = 0; i < sv_maxclients->integer; i++,cl++ ) {
if ( cl->state >= CS_CONNECTED && cl->netchan.remoteAddress.type != NA_BOT ) {
count++;
}
}
if ( count > 1 ) {
// don't pause
if ( sv_paused->integer ) {
Cvar_Set( "sv_paused", "0" );
}
return false;
}
if ( !sv_paused->integer ) {
Cvar_Set( "sv_paused", "1" );
}
return true;
}
//returns true if valid challenge
//returns false if m4d h4x0rz
static bool SVET_VerifyChallenge( const char* challenge ) {
if ( !challenge ) {
return false;
}
int j = String::Length( challenge );
if ( j > 64 ) {
return false;
}
for ( int i = 0; i < j; i++ ) {
if ( challenge[ i ] == '\\' ||
challenge[ i ] == '/' ||
challenge[ i ] == '%' ||
challenge[ i ] == ';' ||
challenge[ i ] == '"' ||
challenge[ i ] < 32 || // non-ascii
challenge[ i ] > 126 // non-ascii
) {
return false;
}
}
return true;
}
// NERVE - SMF - Send serverinfo cvars, etc to master servers when
// game complete. Useful for tracking global player stats.
static void SVT3C_GameCompleteStatus( netadr_t from ) {
char player[ 1024 ];
char status[ MAX_MSGLEN_WOLF ];
int i;
client_t* cl;
int statusLength;
int playerLength;
char infostring[ MAX_INFO_STRING_Q3 ];
// ignore if we are in single player
if ( GGameType & GAME_WolfMP && Cvar_VariableValue( "g_gametype" ) == Q3GT_SINGLE_PLAYER ) {
return;
}
if ( GGameType & GAME_ET && SVET_GameIsSinglePlayer() ) {
return;
}
//bani - bugtraq 12534
if ( GGameType & GAME_ET && !SVET_VerifyChallenge( Cmd_Argv( 1 ) ) ) {
return;
}
String::Cpy( infostring, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE, MAX_INFO_STRING_Q3 ) );
// echo back the parameter to status. so master servers can use it as a challenge
// to prevent timed spoofed reply packets that add ghost servers
Info_SetValueForKey( infostring, "challenge", Cmd_Argv( 1 ), MAX_INFO_STRING_Q3 );
status[ 0 ] = 0;
statusLength = 0;
for ( i = 0; i < sv_maxclients->integer; i++ ) {
cl = &svs.clients[ i ];
if ( cl->state >= CS_CONNECTED ) {
idPlayerState3* ps = SVT3_GameClientNum( i );
String::Sprintf( player, sizeof ( player ), "%i %i \"%s\"\n", ps->GetPersistantScore(), cl->ping, cl->name );
playerLength = String::Length( player );
if ( statusLength + playerLength >= ( int )sizeof ( status ) ) {
break; // can't hold any more
}
String::Cpy( status + statusLength, player );
statusLength += playerLength;
}
}
NET_OutOfBandPrint( NS_SERVER, from, "gameCompleteStatus\n%s\n%s", infostring, status );
}
// Responds with all the info that qplug or qspy can see about the server
// and all connected players. Used for getting detailed information after
// the simple info query.
static void SVT3C_Status( netadr_t from ) {
// ignore if we are in single player
if ( !( GGameType & GAME_ET ) && Cvar_VariableValue( "g_gametype" ) == Q3GT_SINGLE_PLAYER ) {
return;
}
if ( GGameType & GAME_ET && SVET_GameIsSinglePlayer() ) {
return;
}
//bani - bugtraq 12534
if ( GGameType & GAME_ET && !SVET_VerifyChallenge( Cmd_Argv( 1 ) ) ) {
return;
}
char infostring[ MAX_INFO_STRING_Q3 ];
String::Cpy( infostring, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE, MAX_INFO_STRING_Q3 ) );
// echo back the parameter to status. so master servers can use it as a challenge
// to prevent timed spoofed reply packets that add ghost servers
Info_SetValueForKey( infostring, "challenge", Cmd_Argv( 1 ), MAX_INFO_STRING_Q3 );
char status[ MAX_MSGLEN ];
status[ 0 ] = 0;
int statusLength = 0;
for ( int i = 0; i < sv_maxclients->integer; i++ ) {
client_t* cl = &svs.clients[ i ];
if ( cl->state >= CS_CONNECTED ) {
idPlayerState3* ps = SVT3_GameClientNum( i );
char player[ 1024 ];
String::Sprintf( player, sizeof ( player ), "%i %i \"%s\"\n",
ps->GetPersistantScore(), cl->ping, cl->name );
int playerLength = String::Length( player );
if ( statusLength + playerLength >= ( GGameType & GAME_Quake3 ? MAX_MSGLEN_Q3 : MAX_MSGLEN_WOLF ) ) {
break; // can't hold any more
}
String::Cpy( status + statusLength, player );
statusLength += playerLength;
}
}
NET_OutOfBandPrint( NS_SERVER, from, "statusResponse\n%s\n%s", infostring, status );
}
// Responds with a short info message that should be enough to determine
// if a user is interested in a server to do a full status
static void SVT3C_Info( netadr_t from ) {
// ignore if we are in single player
if ( !( GGameType & GAME_ET ) && Cvar_VariableValue( "g_gametype" ) == Q3GT_SINGLE_PLAYER ) {
return;
}
if ( GGameType & GAME_Quake3 && Cvar_VariableValue( "ui_singlePlayerActive" ) ) {
return;
}
if ( GGameType & GAME_ET && SVET_GameIsSinglePlayer() ) {
return;
}
//bani - bugtraq 12534
if ( GGameType & GAME_ET && !SVET_VerifyChallenge( Cmd_Argv( 1 ) ) ) {
return;
}
// don't count privateclients
int count = 0;
for ( int i = svt3_privateClients->integer; i < sv_maxclients->integer; i++ ) {
if ( svs.clients[ i ].state >= CS_CONNECTED ) {
count++;
}
}
char infostring[ MAX_INFO_STRING_Q3 ];
infostring[ 0 ] = 0;
// echo back the parameter to status. so servers can use it as a challenge
// to prevent timed spoofed reply packets that add ghost servers
Info_SetValueForKey( infostring, "challenge", Cmd_Argv( 1 ), MAX_INFO_STRING_Q3 );
if ( GGameType & GAME_Quake3 ) {
Info_SetValueForKey( infostring, "protocol", va( "%i", Q3PROTOCOL_VERSION ), MAX_INFO_STRING_Q3 );
} else if ( GGameType & GAME_WolfSP ) {
Info_SetValueForKey( infostring, "protocol", va( "%i", WSPROTOCOL_VERSION ), MAX_INFO_STRING_Q3 );
} else if ( GGameType & GAME_WolfMP ) {
Info_SetValueForKey( infostring, "protocol", va( "%i", WMPROTOCOL_VERSION ), MAX_INFO_STRING_Q3 );
} else {
Info_SetValueForKey( infostring, "protocol", va( "%i", ETPROTOCOL_VERSION ), MAX_INFO_STRING_Q3 );
}
Info_SetValueForKey( infostring, "hostname", sv_hostname->string, MAX_INFO_STRING_Q3 );
if ( GGameType & GAME_ET ) {
Info_SetValueForKey( infostring, "serverload", va( "%i", svs.et_serverLoad ), MAX_INFO_STRING_Q3 );
}
Info_SetValueForKey( infostring, "mapname", svt3_mapname->string, MAX_INFO_STRING_Q3 );
Info_SetValueForKey( infostring, "clients", va( "%i", count ), MAX_INFO_STRING_Q3 );
Info_SetValueForKey( infostring, "sv_maxclients",
va( "%i", sv_maxclients->integer - svt3_privateClients->integer ), MAX_INFO_STRING_Q3 );
if ( GGameType & GAME_ET ) {
Info_SetValueForKey( infostring, "gametype", Cvar_VariableString( "g_gametype" ), MAX_INFO_STRING_Q3 );
} else {
Info_SetValueForKey( infostring, "gametype", va( "%i", svt3_gametype->integer ), MAX_INFO_STRING_Q3 );
}
Info_SetValueForKey( infostring, "pure", va( "%i", svt3_pure->integer ), MAX_INFO_STRING_Q3 );
if ( svt3_minPing->integer ) {
Info_SetValueForKey( infostring, "minPing", va( "%i", svt3_minPing->integer ), MAX_INFO_STRING_Q3 );
}
if ( svt3_maxPing->integer ) {
Info_SetValueForKey( infostring, "maxPing", va( "%i", svt3_maxPing->integer ), MAX_INFO_STRING_Q3 );
}
const char* gamedir = Cvar_VariableString( "fs_game" );
if ( *gamedir ) {
Info_SetValueForKey( infostring, "game", gamedir, MAX_INFO_STRING_Q3 );
}
if ( !( GGameType & GAME_Quake3 ) ) {
Info_SetValueForKey( infostring, "sv_allowAnonymous", va( "%i", svt3_allowAnonymous->integer ), MAX_INFO_STRING_Q3 );
}
if ( GGameType & ( GAME_WolfSP | GAME_WolfMP ) ) {
// Rafael gameskill
Info_SetValueForKey( infostring, "gameskill", va( "%i", svt3_gameskill->integer ), MAX_INFO_STRING_Q3 );
// done
}
if ( GGameType & ( GAME_WolfMP | GAME_ET ) ) {
Info_SetValueForKey( infostring, "friendlyFire", va( "%i", svt3_friendlyFire->integer ), MAX_INFO_STRING_Q3 ); // NERVE - SMF
Info_SetValueForKey( infostring, "maxlives", va( "%i", svt3_maxlives->integer ? 1 : 0 ), MAX_INFO_STRING_Q3 ); // NERVE - SMF
}
if ( GGameType & GAME_WolfMP ) {
Info_SetValueForKey( infostring, "tourney", va( "%i", svwm_tourney->integer ), MAX_INFO_STRING_Q3 ); // NERVE - SMF
Info_SetValueForKey( infostring, "gamename", WMGAMENAME_STRING, MAX_INFO_STRING_Q3 ); // Arnout: to be able to filter out Quake servers
}
if ( GGameType & GAME_ET ) {
Info_SetValueForKey( infostring, "needpass", va( "%i", svet_needpass->integer ? 1 : 0 ), MAX_INFO_STRING_Q3 );
Info_SetValueForKey( infostring, "gamename", ETGAMENAME_STRING, MAX_INFO_STRING_Q3 ); // Arnout: to be able to filter out Quake servers
}
if ( GGameType & ( GAME_WolfMP | GAME_ET ) ) {
// TTimo
const char* antilag = Cvar_VariableString( "g_antilag" );
if ( antilag ) {
Info_SetValueForKey( infostring, "g_antilag", antilag, MAX_INFO_STRING_Q3 );
}
}
if ( GGameType & GAME_ET ) {
const char* weaprestrict = Cvar_VariableString( "g_heavyWeaponRestriction" );
if ( weaprestrict ) {
Info_SetValueForKey( infostring, "weaprestrict", weaprestrict, MAX_INFO_STRING_Q3 );
}
const char* balancedteams = Cvar_VariableString( "g_balancedteams" );
if ( balancedteams ) {
Info_SetValueForKey( infostring, "balancedteams", balancedteams, MAX_INFO_STRING_Q3 );
}
}
NET_OutOfBandPrint( NS_SERVER, from, "infoResponse\n%s", infostring );
}
static void SVT3_FlushRedirect( char* outputbuf ) {
NET_OutOfBandPrint( NS_SERVER, svs.redirectAddress, "print\n%s", outputbuf );
}
// An rcon packet arrived from the network.
// Shift down the remaining args
// Redirect all printfs
static void SVT3C_RemoteCommand( netadr_t from, QMsg* msg ) {
static unsigned int lasttime = 0;
unsigned int time = Com_Milliseconds();
if ( time < ( lasttime + 500 ) ) {
return;
}
lasttime = time;
bool valid;
if ( !String::Length( svt3_rconPassword->string ) ||
String::Cmp( Cmd_Argv( 1 ), svt3_rconPassword->string ) ) {
valid = false;
common->Printf( "Bad rcon from %s:\n%s\n", SOCK_AdrToString( from ), Cmd_Argv( 2 ) );
} else {
valid = true;
common->Printf( "Rcon from %s:\n%s\n", SOCK_AdrToString( from ), Cmd_Argv( 2 ) );
}
// start redirecting all print outputs to the packet
svs.redirectAddress = from;
// TTimo - scaled down to accumulate, but not overflow anything network wise, print wise etc.
// (OOB messages are the bottleneck here)
enum { SV_OUTPUTBUF_LENGTH = 1024 - 16 };
char sv_outputbuf[ SV_OUTPUTBUF_LENGTH ];
Com_BeginRedirect( sv_outputbuf, SV_OUTPUTBUF_LENGTH, SVT3_FlushRedirect );
if ( !String::Length( svt3_rconPassword->string ) ) {
common->Printf( "No rconpassword set on the server.\n" );
} else if ( !valid ) {
common->Printf( "Bad rconpassword.\n" );
} else {
char remaining[ 1024 ];
remaining[ 0 ] = 0;
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543
// get the command directly, "rcon <pass> <command>" to avoid quoting issues
// extract the command by walking
// since the cmd formatting can fuckup (amount of spaces), using a dumb step by step parsing
char* cmd_aux = Cmd_Cmd();
cmd_aux += 4;
while ( cmd_aux[ 0 ] == ' ' ) {
cmd_aux++;
}
while ( cmd_aux[ 0 ] && cmd_aux[ 0 ] != ' ' ) { // password
cmd_aux++;
}
while ( cmd_aux[ 0 ] == ' ' ) {
cmd_aux++;
}
String::Cat( remaining, sizeof ( remaining ), cmd_aux );
Cmd_ExecuteString( remaining );
}
Com_EndRedirect();
}
// A connectionless packet has four leading 0xff
// characters to distinguish it from a game channel.
// Clients that are in the game can still send
// connectionless packets.
static void SVT3_ConnectionlessPacket( netadr_t from, QMsg* msg ) {
msg->BeginReadingOOB();
msg->ReadLong(); // skip the -1 marker
if ( !( GGameType & GAME_WolfSP ) && !String::NCmp( "connect", ( char* )&msg->_data[ 4 ], 7 ) ) {
Huff_Decompress( msg, 12 );
}
const char* s = msg->ReadStringLine();
Cmd_TokenizeString( s );
const char* c = Cmd_Argv( 0 );
common->DPrintf( "SV packet %s : %s\n", SOCK_AdrToString( from ), c );
if ( !String::ICmp( c, "getstatus" ) ) {
SVT3C_Status( from );
} else if ( !String::ICmp( c, "getinfo" ) ) {
SVT3C_Info( from );
} else if ( !String::ICmp( c, "getchallenge" ) ) {
SVT3_GetChallenge( from );
} else if ( !String::ICmp( c, "connect" ) ) {
SVT3_DirectConnect( from );
} else if ( !( GGameType & GAME_ET ) && !String::ICmp( c, "ipAuthorize" ) ) {
SVT3_AuthorizeIpPacket( from );
} else if ( !String::ICmp( c, "rcon" ) ) {
SVT3C_RemoteCommand( from, msg );
} else if ( !String::ICmp( c, "disconnect" ) ) {
// if a client starts up a local server, we may see some spurious
// server disconnect messages when their new server sees our final
// sequenced messages to the old client
} else {
common->DPrintf( "bad connectionless packet from %s:\n%s\n",
SOCK_AdrToString( from ), s );
}
}
/*
==============================================================================
MASTER SERVER FUNCTIONS
==============================================================================
*/
// Send a message to the masters every few minutes to
// let it know we are alive, and log information.
// We will also have a heartbeat sent when a server
// changes from empty to non-empty, and full to non-full,
// but not on every player enter or exit.
static void SVT3_MasterHeartbeat( const char* hbname ) {
static netadr_t adr[ Q3MAX_MASTER_SERVERS ];
if ( GGameType & GAME_ET && SVET_GameIsSinglePlayer() ) {
return; // no heartbeats for SP
}
// "dedicated 1" is for lan play, "dedicated 2" is for inet public play
if ( !com_dedicated || com_dedicated->integer != 2 ) {
return; // only dedicated servers send heartbeats
}
// if not time yet, don't send anything
if ( svs.q3_time < svs.q3_nextHeartbeatTime ) {
return;
}
svs.q3_nextHeartbeatTime = svs.q3_time + HEARTBEAT_MSEC;
// send to group masters
for ( int i = 0; i < Q3MAX_MASTER_SERVERS; i++ ) {
if ( !svt3_master[ i ]->string[ 0 ] ) {
continue;
}
// see if we haven't already resolved the name
// resolving usually causes hitches on win95, so only
// do it when needed
if ( svt3_master[ i ]->modified ) {
svt3_master[ i ]->modified = false;
common->Printf( "Resolving %s\n", svt3_master[ i ]->string );
if ( !SOCK_StringToAdr( svt3_master[ i ]->string, &adr[ i ], Q3PORT_MASTER ) ) {
// if the address failed to resolve, clear it
// so we don't take repeated dns hits
common->Printf( "Couldn't resolve address: %s\n", svt3_master[ i ]->string );
Cvar_Set( svt3_master[ i ]->name, "" );
svt3_master[ i ]->modified = false;
continue;
}
common->Printf( "%s resolved to %s\n", svt3_master[ i ]->string, SOCK_AdrToString( adr[ i ] ) );
}
common->Printf( "Sending heartbeat to %s\n", svt3_master[ i ]->string );
// this command should be changed if the server info / status format
// ever incompatably changes
NET_OutOfBandPrint( NS_SERVER, adr[ i ], "heartbeat %s\n", hbname );
}
}
// NERVE - SMF - Sends gameCompleteStatus messages to all master servers
void SVT3_MasterGameCompleteStatus() {
static netadr_t adr[ Q3MAX_MASTER_SERVERS ];
if ( GGameType & GAME_ET && SVET_GameIsSinglePlayer() ) {
return; // no master game status for SP
}
// "dedicated 1" is for lan play, "dedicated 2" is for inet public play
if ( !com_dedicated || com_dedicated->integer != 2 ) {
return; // only dedicated servers send master game status
}
// send to group masters
for ( int i = 0; i < Q3MAX_MASTER_SERVERS; i++ ) {
if ( !svt3_master[ i ]->string[ 0 ] ) {
continue;
}
// see if we haven't already resolved the name
// resolving usually causes hitches on win95, so only
// do it when needed
if ( svt3_master[ i ]->modified ) {
svt3_master[ i ]->modified = false;
common->Printf( "Resolving %s\n", svt3_master[ i ]->string );
if ( !SOCK_StringToAdr( svt3_master[ i ]->string, &adr[ i ], Q3PORT_MASTER ) ) {
// if the address failed to resolve, clear it
// so we don't take repeated dns hits
common->Printf( "Couldn't resolve address: %s\n", svt3_master[ i ]->string );
Cvar_Set( svt3_master[ i ]->name, "" );
svt3_master[ i ]->modified = false;
continue;
}
common->Printf( "%s resolved to %s\n", svt3_master[ i ]->string, SOCK_AdrToString( adr[ i ] ) );
}
common->Printf( "Sending gameCompleteStatus to %s\n", svt3_master[ i ]->string );
// this command should be changed if the server info / status format
// ever incompatably changes
SVT3C_GameCompleteStatus( adr[ i ] );
}
}
// Informs all masters that this server is going down
void SVT3_MasterShutdown() {
const char* hbname = GGameType & GAME_Quake3 ? Q3HEARTBEAT_GAME :
GGameType & GAME_WolfSP ? WSMHEARTBEAT_GAME :
GGameType & GAME_WolfMP ? WMHEARTBEAT_DEAD : ETHEARTBEAT_DEAD; // NERVE - SMF - changed to flatline
// send a hearbeat right now
svs.q3_nextHeartbeatTime = -9999;
SVT3_MasterHeartbeat( hbname );
if ( !( GGameType & ( GAME_WolfMP | GAME_ET ) ) ) {
// send it again to minimize chance of drops
svs.q3_nextHeartbeatTime = -9999;
SVT3_MasterHeartbeat( hbname );
}
// when the master tries to poll the server, it won't respond, so
// it will be removed from the list
}
void SVT3_PacketEvent( netadr_t from, QMsg* msg ) {
// check for connectionless packet (0xffffffff) first
if ( msg->cursize >= 4 && *( int* )msg->_data == -1 ) {
SVT3_ConnectionlessPacket( from, msg );
return;
}
// read the qport out of the message so we can fix up
// stupid address translating routers
msg->BeginReadingOOB();
msg->ReadLong(); // sequence number
int qport = msg->ReadShort() & 0xffff;
// find which client the message is from
client_t* cl = svs.clients;
for ( int i = 0; i < sv_maxclients->integer; i++,cl++ ) {
if ( cl->state == CS_FREE ) {
continue;
}
if ( !SOCK_CompareBaseAdr( from, cl->netchan.remoteAddress ) ) {
continue;
}
// it is possible to have multiple clients from a single IP
// address, so they are differentiated by the qport variable
if ( cl->netchan.qport != qport ) {
continue;
}
// the IP port can't be used to differentiate them, because
// some address translating routers periodically change UDP
// port assignments
if ( cl->netchan.remoteAddress.port != from.port ) {
common->Printf( "SVT3_PacketEvent: fixing up a translated port\n" );
cl->netchan.remoteAddress.port = from.port;
}
// make sure it is a valid, in sequence packet
if ( SVT3_Netchan_Process( cl, msg ) ) {
// zombie clients still need to do the Netchan_Process
// to make sure they don't need to retransmit the final
// reliable message, but they don't do any other processing
if ( cl->state != CS_ZOMBIE ) {
cl->q3_lastPacketTime = svs.q3_time; // don't timeout
SVT3_ExecuteClientMessage( cl, msg );
}
}
return;
}
// if we received a sequenced packet from an address we don't recognize,
// send an out of band disconnect packet to it
NET_OutOfBandPrint( NS_SERVER, from, "disconnect" );
}
// Player movement occurs as a result of packet events, which
// happen before SVT3_Frame is called
void SVT3_Frame( int msec ) {
// the menu kills the server with this cvar
if ( svt3_killserver->integer ) {
SVT3_Shutdown( "Server was killed.\n" );
Cvar_Set( "sv_killserver", "0" );
return;
}
if ( !com_sv_running->integer ) {
return;
}
// allow pause if only the local client is connected
if ( SVT3_CheckPaused() ) {
return;
}
int frameStartTime = 0;
if ( com_dedicated->integer ) {
frameStartTime = Sys_Milliseconds();
}
// if it isn't time for the next frame, do nothing
if ( svt3_fps->integer < 1 ) {
Cvar_Set( "sv_fps", "10" );
}
int frameMsec = 1000 / svt3_fps->integer;
sv.q3_timeResidual += msec;
if ( !com_dedicated->integer ) {
SVT3_BotFrame( svs.q3_time + sv.q3_timeResidual );
}
if ( com_dedicated->integer && sv.q3_timeResidual < frameMsec ) {
// NET_Sleep will give the OS time slices until either get a packet
// or time enough for a server frame has gone by
NET_Sleep( frameMsec - sv.q3_timeResidual );
return;
}
// if time is about to hit the 32nd bit, kick all clients
// and clear sv.time, rather
// than checking for negative time wraparound everywhere.
// 2giga-milliseconds = 23 days, so it won't be too often
if ( svs.q3_time > 0x70000000 ) {
char mapname[ MAX_QPATH ];
String::NCpyZ( mapname, svt3_mapname->string, MAX_QPATH );
SVT3_Shutdown( "Restarting server due to time wrapping" );
// TTimo
// show_bug.cgi?id=388
// there won't be a map_restart if you have shut down the server
// since it doesn't restart a non-running server
// instead, re-run the current map
Cbuf_AddText( va( "map %s\n", mapname ) );
return;
}
// this can happen considerably earlier when lots of clients play and the map doesn't change
if ( svs.q3_nextSnapshotEntities >= 0x7FFFFFFE - svs.q3_numSnapshotEntities ) {
char mapname[ MAX_QPATH ];
String::NCpyZ( mapname, svt3_mapname->string, MAX_QPATH );
SVT3_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
// TTimo see above
Cbuf_AddText( va( "map %s\n", mapname ) );
return;
}
if ( sv.q3_restartTime && svs.q3_time >= sv.q3_restartTime ) {
sv.q3_restartTime = 0;
Cbuf_AddText( "map_restart 0\n" );
return;
}
// update infostrings if anything has been changed
if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
SVT3_SetConfigstring( Q3CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE, MAX_INFO_STRING_Q3 ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO;
}
if ( cvar_modifiedFlags & CVAR_SERVERINFO_NOUPDATE ) {
SVT3_SetConfigstringNoUpdate( Q3CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO | CVAR_SERVERINFO_NOUPDATE, MAX_INFO_STRING_Q3 ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO_NOUPDATE;
}
if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
SVT3_SetConfigstring( Q3CS_SYSTEMINFO, Cvar_InfoString( CVAR_SYSTEMINFO, BIG_INFO_STRING ) );
cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
}
// NERVE - SMF
if ( GGameType & ( GAME_WolfMP | GAME_ET ) && cvar_modifiedFlags & CVAR_WOLFINFO ) {
SVT3_SetConfigstring( GGameType & GAME_ET ? ETCS_WOLFINFO : WMCS_WOLFINFO, Cvar_InfoString( CVAR_WOLFINFO, MAX_INFO_STRING_Q3 ) );
cvar_modifiedFlags &= ~CVAR_WOLFINFO;
}
int startTime;
if ( com_speeds->integer ) {
startTime = Sys_Milliseconds();
} else {
startTime = 0; // quite a compiler warning
}
// update ping based on the all received frames
SVT3_CalcPings();
if ( com_dedicated->integer ) {
SVT3_BotFrame( svs.q3_time );
}
// run the game simulation in chunks
while ( sv.q3_timeResidual >= frameMsec ) {
sv.q3_timeResidual -= frameMsec;
svs.q3_time += frameMsec;
// let everything in the world think and move
SVT3_GameRunFrame( svs.q3_time );
}
if ( com_speeds->integer ) {
t3time_game = Sys_Milliseconds() - startTime;
}
// check timeouts
SVT3_CheckTimeouts();
// send messages back to the clients
SVT3_SendClientMessages();
// send a heartbeat to the master if needed
SVT3_MasterHeartbeat( GGameType & GAME_Quake3 ? Q3HEARTBEAT_GAME :
GGameType & GAME_ET ? ETHEARTBEAT_GAME : WSMHEARTBEAT_GAME );
if ( GGameType & GAME_ET && com_dedicated->integer ) {
int frameEndTime = Sys_Milliseconds();
svs.et_totalFrameTime += ( frameEndTime - frameStartTime );
svs.et_currentFrameIndex++;
if ( svs.et_currentFrameIndex == ETSERVER_PERFORMANCECOUNTER_FRAMES ) {
int averageFrameTime;
averageFrameTime = svs.et_totalFrameTime / ETSERVER_PERFORMANCECOUNTER_FRAMES;
svs.et_sampleTimes[ svs.et_currentSampleIndex % SERVER_PERFORMANCECOUNTER_SAMPLES ] = averageFrameTime;
svs.et_currentSampleIndex++;
if ( svs.et_currentSampleIndex > SERVER_PERFORMANCECOUNTER_SAMPLES ) {
int totalTime = 0;
for ( int i = 0; i < SERVER_PERFORMANCECOUNTER_SAMPLES; i++ ) {
totalTime += svs.et_sampleTimes[ i ];
}
if ( !totalTime ) {
totalTime = 1;
}
averageFrameTime = totalTime / SERVER_PERFORMANCECOUNTER_SAMPLES;
svs.et_serverLoad = ( averageFrameTime / ( float )frameMsec ) * 100;
}
svs.et_totalFrameTime = 0;
svs.et_currentFrameIndex = 0;
}
} else {
svs.et_serverLoad = -1;
}
}
|
/*
* Spi.h
*
* Created: 17.06.2015 16:09:04
* Author: User
*/
#include <avr/io.h>
#include "Gpio.h"
#ifndef __SPI_H__
#define __SPI_H__
class Spi
{
//variables
public:
enum div {div4 , div16 , div64 , div128};
enum role {Slave , Master};
enum SpiPin {CS = 2 , MOSI,MISO,SCK};
protected:
private:
Gpio pin;
// static unsigned char SPCR_reg;
//functions
public:
Spi(div d=div4 , role r=Master);
unsigned char transfer (unsigned char data);
unsigned char transfer_byte (unsigned char data);
void CS_SET ();
void CS_CLEAR ();
protected:
private:
}; //Spi
#endif //__SPI_H__
|
/*
* Person.h
*
* Created on: Aug 25, 2016
* Author: Istvan
*/
#ifndef PERSON_H_
#define PERSON_H_
#include <iostream>
#include <string>
using namespace std;
struct Person{
string firstName;
string lastName;
Person();
Person(string firstName, string lastName);
Person(string fullName);
void print();
void setPerson(string firstName, string lastName);
void setPerson(string s);//Gets the last word of a full name and makes it a last name
string getPerson(); // returns last name, first name
};
#endif /* PERSON_H_ */
|
#include "../../include/offline/configuration.h"
namespace keyword_suggestion {
Configuration::Configuration(const std::string &config) {
FILE *path;
char prefix[kPathSize] = {0}, index[1024] = {0}, content[1024] = {0};
std::string config_path;
getcwd(prefix, kPathSize);
for (int i = strlen(prefix) - 1; prefix[i] != '/'; --i) {
prefix[i] = '\0';
}
prefix[strlen(prefix) - 1] = '\0';
path_prefix_ = static_cast<std::string>(prefix);
config_path = path_prefix_ + "/conf/" + config + ".conf";
path = fopen(config_path.c_str(), "rb");
while (fscanf(path, "%s%s", index, content) != EOF) {
config_[static_cast<std::string>(index)] = content;
}
fclose(path);
}
std::string Configuration::GetPath(const std::string &config) {
return path_prefix_ + config_.find(config)->second;
}
std::string Configuration::GetIp(std::string config) {
char buffer[kPathSize] = {0};
::strcpy(buffer, config.c_str());
if (::strcmp(buffer, "deafult_ip")) {
struct passwd *pwd = getpwuid(getuid());
config = static_cast<std::string>(pwd->pw_name) + "_ip";
}
return config_.find(config)->second;
}
int Configuration::GetPort(std::string config) {
char buffer[kPathSize] = {0};
::strcpy(buffer, config.c_str());
if (::strcmp(buffer, "deafult_port")) {
struct passwd *pwd = getpwuid(getuid());
config = static_cast<std::string>(pwd->pw_name) + "_port";
}
return atoi(config_.find(config)->second.c_str());
}
} // namespace keyword_suggestion
|
#pragma once
#include "MyMatrixTypes.h"
#include "Circuit.h"
#include <math.h>
#include <vector>
#include <ctime>
class Simulation : public Circuit
{
public:
//Default Constructor
//Simulation();
//Constructor with samplerate and vcc as arguement
Simulation(double _sampleRate, double _vcc);
//Default Destructor
~Simulation();
//process the buffer of data where vcc is set to the system VCC (default 9v)
//Eigen::VectorXd processBuffer(Eigen::VectorXd inputBuffer);
//Buffer to store the output vector of the simulation to send to the audio channel
//Eigen::VectorXd outputBuffer;
//Set the sampleRate
void setSimSampleRate(double _sampleRate);
//Takes the current sample as an arguement along with vcc and processes it, returning the new data.
//channelData is used as the name to be implemented with JUCE API channelData variable name
void processSample(float* channelData, double _vcc);
//Gets the system to a steady state ready for processing
void getSteadyState();
EIGEN_MAKE_ALIGNED_OPERATOR_NEW //Aligns all the Eigen Members in the class to avoid memory allocation errors... see https://eigen.tuxfamily.org/dox/group__TopicUnalignedArrayAssert.html & https://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html
private:
//Initialise vcc etc.
void initialiseSimValues();
//Buffer size in samples, defaulted to...??
int bufferSize;
/* Input */
//VCC voltage
double vcc; //steady state voltage
double durfade; //duration of the faded power up
int hanWin; //length in samples of the hanning window for voltage ramping, used in the get steady state phase
double steadyStatePeriodFactor; //Factor which controls the size of the window window used to reach steady state (where window size in samples = hanWin*steadyStateFactor)
Eigen::VectorXd win; //hanning window
Eigen::VectorXd vccv; //power up voltage used in initial setup
double maxIterations;
double maxSubIterations;
//Specified tolerance in nonlinear voltage vd
double tol;
//tol^2, used for end conditions of the NR solver
double tols;
/*Simulation Preparations*/
double nrms; //newton rhapson solver value
int iteration; //number of iterations per sample
int subIterationTotal; //total number of subiterations occuring in a sample
int subIterCounter; //used in the damped newton iterations to determine sub iterations per iteration
Eigen::Vector3d stateSpaceVector; //(MATLAB - x)
Eigen::Vector3d stateSpaceVectorMem; //memorised state vector, 3x1 vector (MATLAB - xz)
Eigen::Vector4d nonLinVoltageVector; //discrete nonlinear voltage vector. 4x1 vector (MATLAB - vd)
Eigen::Vector4d nonLinVoltageVectorMem; //memorised nonlinear voltage vector, 4x1 vector (MATLAB - vdz)
Eigen::Vector4d nonLinVoltageVectorPrev; //previous value --- MATLAB = vd0
Eigen::Vector4d nonLinVoltageVectorNew; //new vd vector -- MATLAB = vdnew
Eigen::Vector2d inputVector; //input vector, 2x1 vector (MATLAB - u)
Eigen::Vector4d nonLinSolverInput; //input vector used in calculation of the nonlinear equation (MATLAB - pd)
Eigen::Vector4d nonLinTransistorFunction; //MATLAB - f
Eigen::Matrix4d nonLinTransistorFunctionAltered; //Matlab - fd
Eigen::Vector4d nodalDKNonlinearG; //the nonlinear function from the Nodal DK method (i.e. g = p + K*f - v) (MATLAB - g)
Eigen::Vector4d nodalDKNonlinearGNew; //Matlab - gnew
Eigen::Vector4d nodalDKNonlinearGtemp; //Matlab (used as temp value for gnew = M*vdnew + IS*(exp(vdnew/VT) - 1) - pd;)
Eigen::Matrix4d nodalDKNonlinearGAltered; //MATLAB - gd
Eigen::Vector4d nonLinearCurrent; //the nonlinear currents through the transistor (i.e. i = f(v)) .... f and i basically have the same purpose so there is redundancy. (MATLAB - i)
Eigen::Vector4d newtonStep; //the newston Step, used in simulation, MATLAB - STEP
Eigen::Vector4d newtonStepTemp; //temp term used in simulation, adjusted step which works to keep max subiterations within the limit MATLAB - STP
Eigen::Vector4d calcTemp; //temporary term used in simulation calculation (MATLAB - TERM)
//initialise and zero all the simulation paramaters and vectors
void initialiseSimulationParameters();
//Eigen::Vector2d outputVector;
double output; //output of the model (MATLAB - y)
};
|
#ifndef APPEARANCE_H
#define APPEARANCE_H
#include <string>
#include <iostream>
#include <CGFappearance.h>
#include "Texture.h"
using namespace std;
class Appearance: public CGFappearance {
protected:
string appearance_id;
string textureref;
bool hasText;
public:
Appearance(string appearance_id, float shininess, float * ambient, float * diffuse, float * specular);
string getId();
void setText(string text);
string getTextReference();
Texture * getTexture();
void setHasText();
bool getHasText();
float * getAmbient();
float * getDiffuse();
float * getSpecular();
};
#endif
|
#include<stdio.h>
#include<malloc.h>
struct node{
int data;
struct node *next;
};
int push(struct node **,int);
int main(){
struct node *Head;
push(&Head,23);
push(&Head,12);
push(&Head,44);
push(&Head,32);
push(&Head,91);
printf("-------------------------------");
printf("\n%d",Head->next->data);
//insertAtFront(&Head,)
}
int push(struct node **head,int new_data){
struct node *temp=*head;
if(head==NULL){
struct node *temp=(struct node *)malloc(sizeof(struct node));
temp->data=new_data;
temp->next= *head;
*head=temp;
}
printf("%d\n",temp->data);
// printf("%d",*head->data);
//}
// int insertAtFront(struct node *Head,int key){
//struct node *
}
|
#ifndef BINARYHEAP_H
#define BINARYHEAP_H
#include <cstddef>
#include <vector>
#include "Node.h"
class BinaryHeap {
public:
BinaryHeap();
BinaryHeap(const BinaryHeap& h);
~BinaryHeap();
static BinaryHeap setUnion(BinaryHeap h1, BinaryHeap h2);
static BinaryHeap setIntersection(BinaryHeap h1, BinaryHeap h2);
void add(int val);
void remove(int val);
bool exists(int val);
void printTree();
std::vector<int> asVector();
Node* root;
Node* last_inserted;
int count;
private:
Node* find(int val, Node* node);
void swap(Node* n1, Node* n2);
void percolateUp(Node* n);
void percolateDown(Node* n);
Node* removeLast();
Node* max(Node* n1, Node* n2);
};
#endif
|
#ifndef GAMEDATA_H
#define GAMEDATA_H
#include <fstream>
#include <string>
class gamedata {
private: std::string m_sPlayerName;
private: int m_nDollarsCarried;
public: std::string sPlayerName (
) const;
public: int nDollarsCarried (
) const;
public: gamedata (
const std::string&,
const int&
);
public: gamedata (
std::ifstream&
);
public: void set_sPlayerName (
const std::string&
);
public: void set_nDollarsCarried (
int
);
};
void write (
const gamedata&,
std::ofstream&
);
#endif
|
#include "Event.hpp"
namespace rpg2kLib
{
namespace structure
{
Instruction::Instruction()
: code_(-1)
{
}
Instruction::Instruction(StreamReader& s)
{
code_ = s.getBER();
nest_ = s.getBER();
Binary b;
s.get(b);
stringArgument_ = static_cast< RPG2kString >(b);
int argNum = s.getBER();
argument_.resize(argNum, VAR_DEF_VAL);
for(int i = 0; i < argNum; i++) argument_[i] = s.getBER();
}
Instruction::Instruction(Instruction const& src)
: code_(src.code_), nest_(src.nest_)
, stringArgument_(src.stringArgument_), argument_(src.argument_)
{
}
Instruction::~Instruction()
{
}
uint Instruction::serializedSize() const
{
uint ret =
getBERSize(code_) + getBERSize(nest_) +
getBERSize( stringArgument_.size() ) + stringArgument_.size() +
getBERSize( argument_.size() );
for(uint i = 0; i < argument_.size(); i++) ret += getBERSize(argument_[i]);
return ret;
}
void Instruction::serialize(StreamWriter& s) const
{
s.add( serializedSize() );
s.setBER(code_);
s.setBER(nest_);
s.setBER( stringArgument_.size() ); s.write(stringArgument_);
s.setBER( argument_.size() );
for(uint i = 0; i < argument_.size(); i++) s.setBER(argument_[i]);
}
Event::Event(/* uint length, */ Binary const& b)
{
StreamReader s(b);
init(s);
}
Event::Event(Element& e, Descriptor const& info)
{
}
Event::Event(Element& e, Descriptor const& info, Binary const& b)
{
StreamReader s(b);
init(s);
}
Event::Event(Event const& src)
: data_(src.data_), label_(src.label_)
{
}
Event::Event(Element& e, Descriptor const& info, StreamReader& s)
{
init(s);
}
void Event::init(StreamReader& s)
{
while( !s.eof() ) {
Instruction inst(s);
// check if it's label
if(inst.code() == 12110) {
label_.insert( std::map< uint, uint >::value_type(inst[0], data_.size() - 1) );
}
data_.push_back(inst);
}
if( !s.eof() ) throw std::runtime_error("Didn't end with eof");
}
Event::~Event()
{
}
uint Event::serializedSize() const
{
uint ret = 0;
for(uint i = 0; i < data_.size(); i++) ret += data_[i].serializedSize();
return ret;
}
uint Event::serializedSize(uint offset) const
{
uint ret = 0;
for(uint i = offset; i < data_.size(); i++) ret += data_[i].serializedSize();
return ret;
}
void Event::serialize(StreamWriter& s) const
{
s.add( serializedSize() );
for(uint i = 0; i < data_.size(); i++) data_[i].serialize(s);
}
void Event::resize(uint size)
{
data_.resize(size);
}
} // namespace structure
} // namespace rpg2kLib
|
#include "CTaskManager.h"
#include <stdio.h>
using namespace Util;
CTaskManager::CTaskManager()
{
}
bool CTaskManager::start(ITask* pTask)
{
pthread_t tid = 0;
pTask->onStart();
pthread_create(&tid, NULL, (TaskFunction)handleTask, (void*)pTask);
}
void CTaskManager::stop(ITask* pTask)
{
pTask->onStop();
}
void CTaskManager::handleTask(ITask* pTask)
{
pTask->onService();
}
|
//
// CombineSelector.hpp
// DDCSSParser
//
// Created by 1m0nster on 2018/8/7.
// Copyright © 2018 1m0nster. All rights reserved.
//
#ifndef CombineSelector_hpp
#define CombineSelector_hpp
#include <stdio.h>
#include <iostream>
#include <list>
#include "Selector.hpp"
namespace future {
class CombineSelector: public Selector {
public:
enum CombineType {
InstanceSibling,
NormalSibling,
InstanceInherical,
NormalInherical,
NoCombine
};
public:
CombineSelector()
{
m_selectorType = Selector::CombineSelector;
m_combineType = NoCombine;
}
~CombineSelector();
void initialInstanceSiblingList(Selector* head, Selector* sibling);
void initialNormalSiblingList(Selector* head, Selector* sibling);
void initialInstanceInhericalList(Selector* root, Selector* child);
void initialNormalInhericalList(Selector* root, Selector* child);
bool isBaseSelector();
int weight();
Selector* getBefore();
Selector* getAfter();
CombineType getCombineType();
inline std::list<Selector *> getInstanceSiblingList()
{
return m_instanceSiblingList;
}
inline std::list<Selector *> getNormalSiblingList()
{
return m_normalSiblingList;
}
inline std::list<Selector *> getInstanceInhericalList()
{
return m_instanceInhericalList;
}
inline std::list<Selector *> getNormalInhericalList()
{
return m_normalInhericalList;
}
virtual std::string description();
private:
std::list<Selector *> m_instanceSiblingList;
std::list<Selector *> m_normalSiblingList;
std::list<Selector *> m_instanceInhericalList;
std::list<Selector *> m_normalInhericalList;
CombineType m_combineType;
};
}
#endif /* CombineSelector_hpp */
|
/*
ID: khurana2
PROG: milk2
LANG: C++
*/
#include <algorithm>
#include <fstream>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
typedef pair<unsigned long, unsigned long>Interval;
bool mycomp(const Interval &a, const Interval &b)
{
return (a.first <= b.first);
}
int main()
{
unsigned short n, i;
unsigned long current_start, current_end, current_dur;
unsigned long best_dur;
unsigned long gap, best_gap;
vector<Interval>intervals;
vector<Interval>::const_iterator it;
ifstream fin("milk2.in");
ofstream fout("milk2.out");
Interval instance;
fin >> n;
for (i = 0; i < n; ++i) {
fin >> instance.first >> instance.second;
intervals.push_back(instance);
}
sort(intervals.begin(), intervals.end(), mycomp);
it = intervals.begin();
current_start = it->first;
current_end = it->second;
current_dur = current_end - current_start;
//best_start = current_start;
//best_end = current_end;
best_dur = current_dur;
gap = 0;
best_gap = 0;
++it;
for (; it != intervals.end(); ++it) {
if (it->first <= current_end) {
// Overlapping
if (it->second > current_end) {
current_end = it->second;
current_dur = current_end - current_start;
}
} else {
gap = it->first - current_end;
if (gap > best_gap)
best_gap = gap;
current_start = it->first;
current_end = it->second;
current_dur = current_end - current_start;
}
if (current_dur > best_dur) {
//best_start = current_start;
//best_end = current_end;
best_dur = current_dur;
}
}
//cout << "(" << best_start << "," << best_end << ") " << best_dur << endl;
//cout << best_gap << endl;
fout << best_dur << " " << best_gap << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include "GLSLProgram.h"
#include "GLTools.h"
// Standard window width
const int WINDOW_WIDTH = 640;
// Standard window height
const int WINDOW_HEIGHT = 480;
// GLUT window id/handle
int glutID = 0;
cg::GLSLProgram program;
glm::mat4x4 view;
glm::mat4x4 projection;
float zNear = 0.1f;
float zFar = 100.0f;
/*
Struct to hold data for object rendering.
*/
class Object
{
public:
inline Object ()
: vao(0),
positionBuffer(0),
colorBuffer(0),
indexBuffer(0)
{}
inline ~Object () { // GL context must exist on destruction
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &indexBuffer);
glDeleteBuffers(1, &colorBuffer);
glDeleteBuffers(1, &positionBuffer);
}
GLuint vao; // vertex-array-object ID
GLuint positionBuffer; // ID of vertex-buffer: position
GLuint colorBuffer; // ID of vertex-buffer: color
GLuint indexBuffer; // ID of index-buffer
glm::mat4x4 model; // model matrix
};
Object triangle;
Object quad;
void renderTriangle()
{
// Create mvp.
glm::mat4x4 mvp = projection * view * triangle.model;
// Bind the shader program and set uniform(s).
program.use();
program.setUniform("mvp", mvp);
// Bind vertex array object so we can render the 1 triangle.
glBindVertexArray(triangle.vao);
glDrawArrays(GL_TRIANGLES, 0, 3); // offset, size
glBindVertexArray(0);
}
void renderQuad()
{
// Create mvp.
glm::mat4x4 mvp = projection * view * quad.model;
// Bind the shader program and set uniform(s).
program.use();
program.setUniform("mvp", mvp);
// Bind vertex array object so we can render the 1 triangle.
glBindVertexArray(quad.vao);
glDrawArrays(GL_TRIANGLES, 0, 6); // offset, size
glBindVertexArray(0);
}
void initTriangle()
{
// Construct triangle. These vectors can go out of scope after we have send all data to the graphics card.
const std::vector<glm::vec3> vertices = { glm::vec3(-1.0f, 1.0f, 0.0f), glm::vec3(1.0f, -1.0f, 0.0f), glm::vec3(1.0f, 1.0f, 0.0f) };
const std::vector<glm::vec3> colors = { glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f) };
// no indices
GLuint programId = program.getHandle();
GLuint pos;
// Step 0: Create vertex array object.
glGenVertexArrays(1, &triangle.vao);
glBindVertexArray(triangle.vao);
// Step 1: Create vertex buffer object for position attribute and bind it to the associated "shader attribute".
glGenBuffers(1, &triangle.positionBuffer);
glBindBuffer(GL_ARRAY_BUFFER, triangle.positionBuffer);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
// Bind it to position.
pos = glGetAttribLocation(programId, "position");
glEnableVertexAttribArray(pos);
glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Step 2: Create vertex buffer object for color attribute and bind it to...
glGenBuffers(1, &triangle.colorBuffer);
glBindBuffer(GL_ARRAY_BUFFER, triangle.colorBuffer);
glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), colors.data(), GL_STATIC_DRAW);
// Bind it to color.
pos = glGetAttribLocation(programId, "color");
glEnableVertexAttribArray(pos);
glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
// no Step 3
// Unbind vertex array object (back to default).
glBindVertexArray(0);
// Modify model matrix.
triangle.model = glm::translate(glm::mat4(1.0f), glm::vec3(-1.25f, 0.0f, 0.0f));
}
void initQuad()
{
// Construct triangle. These vectors can go out of scope after we have send all data to the graphics card.
// 6 vertices
const std::vector<glm::vec3> vertices = { { -1.0f, 1.0f, 0.0f }, { -1.0, -1.0, 0.0 }, { 1.0f, -1.0f, 0.0f },
{ -1.0f, 1.0f, 0.0f }, { 1.0f, -1.0f, 0.0f }, { 1.0f, 1.0f, 0.0f } };
const std::vector<glm::vec3> colors = { { 1.0f, 0.0f, 0.0f }, { 0.0f, 1.0, 1.0f }, { 0.0f, 1.0f, 0.0f },
{ 1.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, { 0.0f, 0.0f, 1.0f } };
// no indices
GLuint programId = program.getHandle();
GLuint pos;
// Step 0: Create vertex array object.
glGenVertexArrays(1, &quad.vao);
glBindVertexArray(quad.vao);
// Step 1: Create vertex buffer object for position attribute and bind it to the associated "shader attribute".
glGenBuffers(1, &quad.positionBuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad.positionBuffer);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
// Bind it to position.
pos = glGetAttribLocation(programId, "position");
glEnableVertexAttribArray(pos);
glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Step 2: Create vertex buffer object for color attribute and bind it to...
glGenBuffers(1, &quad.colorBuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad.colorBuffer);
glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), colors.data(), GL_STATIC_DRAW);
// Bind it to color.
pos = glGetAttribLocation(programId, "color");
glEnableVertexAttribArray(pos);
glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, 0);
// no Step 3
// Unbind vertex array object (back to default).
glBindVertexArray(0);
// Modify model matrix.
quad.model = glm::translate(glm::mat4(1.0f), glm::vec3(1.25f, 0.0f, 0.0f));
}
/*
Initialization. Should return true if everything is ok and false if something went wrong.
*/
bool init()
{
// OpenGL: Set "background" color and enable depth testing.
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
// Construct view matrix.
glm::vec3 eye(0.0f, 0.0f, 4.0f);
glm::vec3 center(0.0f, 0.0f, 0.0f);
glm::vec3 up(0.0f, 1.0f, 0.0f);
view = glm::lookAt(eye, center, up);
// Create a shader program and set light direction.
if (!program.compileShaderFromFile("shader/simple.vert", cg::GLSLShader::VERTEX))
{
std::cerr << program.log();
return false;
}
if (!program.compileShaderFromFile("shader/simple.frag", cg::GLSLShader::FRAGMENT))
{
std::cerr << program.log();
return false;
}
if (!program.link())
{
std::cerr << program.log();
return false;
}
// Create objects.
initTriangle();
initQuad();
return true;
}
/*
Rendering.
*/
void render()
{
glClear(GL_COLOR_BUFFER_BIT);
renderTriangle();
renderQuad();
}
void glutDisplay ()
{
render();
glutSwapBuffers();
}
/*
Resize callback.
*/
void glutResize (int width, int height)
{
// Division by zero is bad... mkay!
height = height < 1 ? 1 : height;
glViewport(0, 0, width, height);
// Construct projection matrix.
projection = glm::perspective(45.0f, (float) width / height, zNear, zFar);
}
/*
Callback for char input.
*/
void glutKeyboard (unsigned char keycode, int x, int y)
{
switch (keycode)
{
case 27: // ESC
glutDestroyWindow ( glutID );
return;
case '+':
// do something
break;
case '-':
// do something
break;
case 'x':
// do something
break;
case 'y':
// do something
break;
case 'z':
// do something
break;
}
glutPostRedisplay();
}
int main(int argc, char** argv)
{
// GLUT: Initialize freeglut library (window toolkit).
glutInitWindowSize (WINDOW_WIDTH, WINDOW_HEIGHT);
glutInitWindowPosition(40,40);
glutInit(&argc, argv);
// GLUT: Create a window and opengl context (version 4.4 core profile).
glutInitContextVersion(4, 4);
glutInitContextFlags (GLUT_FORWARD_COMPATIBLE | GLUT_DEBUG);
glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
glutCreateWindow("Aufgabenblatt 01.0");
glutID = glutGetWindow();
// GLEW: Load opengl extensions
//glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
return -1;
}
#if _DEBUG
if (glDebugMessageCallback) {
std::cout << "Register OpenGL debug callback " << std::endl;
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(cg::glErrorVerboseCallback, nullptr);
glDebugMessageControl(GL_DONT_CARE,
GL_DONT_CARE,
GL_DONT_CARE,
0,
nullptr,
true); // get all debug messages
} else {
std::cout << "glDebugMessageCallback not available" << std::endl;
}
#endif
// GLUT: Set callbacks for events.
glutReshapeFunc(glutResize);
glutDisplayFunc(glutDisplay);
glutIdleFunc (glutDisplay); // repaint when idle
glutKeyboardFunc(glutKeyboard);
// Init VAO.
bool result = init();
if (!result) {
return -2;
}
// GLUT: Loop until the user closes the window
// rendering & event polling
glutMainLoop ();
// Cleanup in destructors:
// Objects will be released in ~Object
// Shader program will be released in ~GLSLProgram
return 0;
}
|
#include "if_else_detector.h"
using namespace std;
vector<int> detect_if_else(ParseTreeNode *program_node) {
// sanity checks
assert(program_node);
assert(program_node->type == PROGRAM_NODE);
vector<int> nested_levels;
// stores the nesting level of the rudimentary if-else block
vector<ParseTreeNode*> root_if_nodes = find_root_if_nodes(program_node);
// find all root-if nodes in the code
// for all root-if nodes in the program, count the nested levels
for (ParseTreeNode *temp : root_if_nodes) {
int count = count_if_children(temp);
nested_levels.push_back(count);
}
// return result
return nested_levels;
}
vector<ParseTreeNode*> find_root_if_nodes(ParseTreeNode *start) {
// sanity checks
assert(start);
assert(start->type == BLOCK_STMT_NODE || start->type == PROGRAM_NODE);
vector<ParseTreeNode*> root_ifs;
ParseTreeNode *temp;
for (int i = 0; i < start->num_children; i++) {
temp = start->children[i];
if (temp->type == BRANCH_STMT_ELSE_NODE
|| temp->type == BRANCH_STMT_NO_ELSE_NODE)
{
// if this is a if-statment, push its address to root_ifs
root_ifs.push_back(temp);
} else if (temp->type == FUNC_DEF_NODE) {
// else if it is a func_def node, recurse to find the root if-statement
// nodes in its block
vector<ParseTreeNode*> func_def_root_ifs = find_root_if_nodes(temp->children[0]);
// insert values of func_def_root_ifs into root_ifs
root_ifs.reserve(root_ifs.size() + func_def_root_ifs.size());
root_ifs.insert( root_ifs.end(),
func_def_root_ifs.begin(),
func_def_root_ifs.end());
}
}
return root_ifs;
}
int count_if_children(ParseTreeNode *if_node) {
// sanity checks
assert(if_node);
assert(if_node->type == BRANCH_STMT_ELSE_NODE
|| if_node->type == BRANCH_STMT_NO_ELSE_NODE);
queue<std::pair<ParseTreeNode *, int>> if_node_queue;
// queue containing pairs of
// ParseTreeNode and the depth of that node relative to @if_node
ParseTreeNode *temp = if_node;
int depth = 0;
std::pair<ParseTreeNode*, int> queue_pair = std::make_pair(temp, depth);
if_node_queue.push(queue_pair);
int max_depth = -1;
while (!if_node_queue.empty())
{
// for convenience and readability
queue_pair = if_node_queue.front(); if_node_queue.pop();
temp = queue_pair.first;
depth = queue_pair.second;
if (max_depth < depth) max_depth = depth;
// for-loop to process block nodes of if-statement node
for (int i = 0; i < temp->num_children-1; i++)
{
ParseTreeNode* block_node = temp->children[i];
// sanity check
assert(block_node->type == BLOCK_STMT_NODE);
// for-loop to process statements inside each block
for (int j = 0; j < block_node->num_children; j++)
{
ParseTreeNode *child = block_node->children[j];
assert(child);
if (child->type == BRANCH_STMT_ELSE_NODE
|| child->type == BRANCH_STMT_NO_ELSE_NODE)
{
// push the paring if it is an if else node and increment the depth
if_node_queue.push(std::make_pair(child, depth+1));
}
}
}
}
return max_depth;
}
|
//
// Created by Twometer on 20/12/2019.
//
#ifndef GAMEOFLIFE_OPENGL_POSTPROC_H
#define GAMEOFLIFE_OPENGL_POSTPROC_H
#include "../gl/Fbo.h"
class Postproc {
private:
static GLuint vao;
public:
static void initialize();
static void start();
static void stop();
static void copy(Fbo *src, Fbo *dst);
};
#endif //GAMEOFLIFE_OPENGL_POSTPROC_H
|
#ifndef __CALCULATOR__
#define __CALCULATOR__
#include <fstream>
#include <string>
#include "cell.h"
class calculator
{
public:
int num_core;
int npool;
int ndiag;
int calculator_type; // 1: qe, 2: vasp
std::string exe;
std::string mpi_launcher;
void read_from_in(std::ifstream& in);
void write_input(std::ifstream& in, cell& c_new);
void write_qe_in(std::ifstream& in, cell& c_new);
void write_vasp_in(std::ifstream& in, cell& c_new);
void call(int if_test);
};
#endif
|
//
// Created by 梁栋 on 2019-01-07.
//
#include <iostream>
#include <sstream>
using namespace std;
class Solution {
public:
int reverse(int x){
int res = 0;
while(x != 0){
if(res * 10 / 10 != res){
return 0;
}
res = res * 10 + x % 10;
x /= 10;
}
return res;
}
int reverse_v2(int x) {
if(x == 0){
return x;
}
stringstream ss;
ss<<x;
string x_str;
ss>>x_str;
string res_str = "";
bool neg_flag = false;
if(x_str[0] == '-'){
neg_flag = true;
x_str = x_str.substr(1, x_str.length()-1);
}
int start_pos = x_str.length()-1;
for(;start_pos >=0; start_pos--){
if(x_str[start_pos] != '0'){
break;
}
}
int non_zero_pos = start_pos;
for(;start_pos>=0;start_pos--){
res_str += x_str[start_pos];
}
// cout<<"res_str is "<<res_str<<endl;
stringstream sss;
sss<<res_str;
long long int res;
sss>>res;
// cout<<"res is "<<res<<endl;
if(neg_flag){
res *= -1;
}
int boundary = 1 << 31;
if(res > boundary-1 or res < -boundary){
return 0;
}
return res;
}
};
class ReverseInteger {
public:
void static test(){
int x = -1234;
Solution solution = Solution();
int res = solution.reverse(x);
cout<<res<<endl;
//PINALSIGYAHRPI
//PINALSIGYAHRPI
}
};
|
#pragma once
#include "../JuceLibraryCode/JuceHeader.h"
class FaustStrings_AP
{
public:
FaustStrings_AP()
{
};
~FaustStrings_AP() {};
String baseName = "/SliderSoniFinal/";
String tradSoniToggle =
baseName + "Traditional";
String tradSoniChoice = baseName +
"Mapping_Tabs/Sonification_Types/Traditional_Strategies/Choice_Traditional";
String SonificationNames[20] =
{
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_1", // T - Pitch
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_2", // T - Tempo
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_3", // T - Synchronicity
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_4", // T - Harmonicity
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_5", // T - Brightness
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_6", // M - Pitch (Degree)
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_7", // M - Tempo
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_8", // M - Synchronicity
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_9", // M - Harmonicity
"Mapping_Tabs/Sonification_Types/AP_Values/Soni_10", // M - Brightness
};
};
|
/**
* Copyright (c) William Niemiec.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <iostream>
namespace wniemiec { namespace io { namespace cpp {
/**
* Responsible for console input.
*/
class InputConsolex
{
//-------------------------------------------------------------------------
// Methods
//-------------------------------------------------------------------------
public:
std::string read_line();
};
}}}
|
//
// Created by Lars on 31/03/2018.
//
#ifndef SIDESCROLLER_MAP_H
#define SIDESCROLLER_MAP_H
#include "Game.h"
#include "TextureManager.h"
class Map {
public:
Map();
~Map();
void LoadMap(int arr[20][25]);
void DrawMap();
private:
int tex_size = 32;
int tex_scalar = 2;
SDL_Rect src, dest;
TextureManager *dirtTex, *grassTex, *waterTex;
// SDL_Texture* dirt;
// SDL_Texture* grass;
// SDL_Texture* water;
int map[20][25];
};
#endif //SIDESCROLLER_MAP_H
|
#ifndef __itkTPGACLevelSetImageFilter_h
#define __itkTPGACLevelSetImageFilter_h
#include "itkGeodesicActiveContourLevelSetImageFilter.h"
namespace itk {
template <class TInputImage, class TFeatureImage, class TOutputPixelType = float >
class ITK_EXPORT TPGACLevelSetImageFilter : public GeodesicActiveContourLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType>
{
public:
/** Standard class typedefs */
typedef TPGACLevelSetImageFilter Self;
typedef GeodesicActiveContourLevelSetImageFilter<TInputImage, TFeatureImage, TOutputPixelType> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
typedef TInputImage ImageType;
typedef typename ImageType::IndexType IndexType;
typedef typename Superclass::TimeStepType TimeStepType;
/** Inherited typedef from the superclass. */
typedef typename Superclass::ValueType ValueType;
typedef typename Superclass::OutputImageType OutputImageType;
typedef typename Superclass::FeatureImageType FeatureImageType;
/** Method for creation through the object factory */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(TPGACLevelSetImageFilter, GeodesicActiveContourLevelSetImageFilter);
protected:
~TPGACLevelSetImageFilter() {}
TPGACLevelSetImageFilter();
virtual void PrintSelf(std::ostream &os, Indent indent) const;
TPGACLevelSetImageFilter(const Self &); // purposely not implemented
void operator=(const Self&); //purposely not implemented
/** Overridden from the parent class to indroduce a constraint on
* * surface flow under certain conditions. */
inline virtual ValueType CalculateUpdateValue(const IndexType &idx, const TimeStepType &dt, const ValueType &value, const ValueType &change);
};
template <class TInputImage, class TFeatureImage, class TOutputType>
TPGACLevelSetImageFilter< TInputImage, TFeatureImage, TOutputType>
::TPGACLevelSetImageFilter()
: GeodesicActiveContourLevelSetImageFilter<TInputImage, TFeatureImage, TOutputType>()
{
// call parent constructor
}
template <class TInputImage, class TFeatureImage, class TOutputType>
void TPGACLevelSetImageFilter<TInputImage, TFeatureImage, TOutputType>
::PrintSelf(std::ostream &os, Indent indent) const
{
Superclass::PrintSelf(os, indent);
}
// 6-neighbour table (including centre voxel, i.e. voxel 13)
static int nbh6Table[27][6] = {
{1, 3, 9, -1, -1, -1}, // 0
{0, 2, 4, 10, -1, -1}, // 1
{1, 5, 11, -1, -1, -1}, // 2
{0, 4, 6, 12, -1, -1}, // 3
{1, 3, 5, 7, 13, -1}, // 4
{2, 4, 8, 14, -1, -1}, // 5
{3, 7, 15, -1, -1, -1}, // 6
{4, 6, 8, 16, -1, -1}, // 7
{5, 7, 17, -1, -1, -1}, // 8
{0, 10, 12, 18, -1, -1}, // 9
{1, 9, 11, 13, 19, -1}, // 10
{2, 10, 14, 20, -1, -1}, // 11
{3, 9, 13, 15, 21, -1}, // 12
{4, 10, 12, 14, 16, 22}, // 13
{5, 11, 13, 17, 23, -1}, // 14
{6, 12, 16, 24, -1, -1}, // 15
{7, 13, 15, 17, 25, -1}, // 16
{8, 14, 16, 26, -1, -1}, // 17
{9, 19, 21, -1, -1, -1}, // 18
{10, 18, 20, 22, -1, -1}, // 19
{11, 19, 23, -1, -1, -1}, // 20
{12, 18, 22, 24, -1, -1}, // 21
{13, 19, 21, 23, 25, -1}, // 22
{14, 20, 22, 26, -1, -1}, // 23
{15, 21, 25, -1, -1, -1}, // 24
{16, 22, 24, 26, -1, -1}, // 25
{17, 23, 25, -1, -1, -1} // 26
};
// generated by gen26neighbourTable.py
// includes the centre voxel
static int nbh26Table[27][26] = {
{1, 3, 4, 9, 10, 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 0
{0, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14, -1, -1,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1
{1, 4, 5, 10, 11, 13, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 2
{0, 1, 4, 6, 7, 9, 10, 12, 13, 15, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 3
{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 4
{1, 2, 4, 7, 8, 10, 11, 13, 14, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 5
{3, 4, 7, 12, 13, 15, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 6
{3, 4, 5, 6, 8, 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 7
{4, 5, 7, 13, 14, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 8
{0, 1, 3, 4, 10, 12, 13, 18, 19, 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 9
{0, 1, 2, 3, 4, 5, 9, 11, 12, 13, 14, 18, 19, 20, 21, 22, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 10
{1, 2, 4, 5, 10, 13, 14, 19, 20, 22, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 11
{0, 1, 3, 4, 6, 7, 9, 10, 13, 15, 16, 18, 19, 21, 22, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 12
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}, // 13
{1, 2, 4, 5, 7, 8, 10, 11, 13, 16, 17, 19, 20, 22, 23, 25, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 14
{3, 4, 6, 7, 12, 13, 16, 21, 22, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 15
{3, 4, 5, 6, 7, 8, 12, 13, 14, 15, 17, 21, 22, 23, 24, 25, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 16
{4, 5, 7, 8, 13, 14, 16, 22, 23, 25, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 17
{9, 10, 12, 13, 19, 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 18
{9, 10, 11, 12, 13, 14, 18, 20, 21, 22, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19
{10, 11, 13, 14, 19, 22, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 20
{9, 10, 12, 13, 15, 16, 18, 19, 22, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 21
{9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 22
{10, 11, 13, 14, 16, 17, 19, 20, 22, 25, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 23
{12, 13, 15, 16, 21, 22, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 24
{12, 13, 14, 15, 16, 17, 21, 22, 23, 24, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 25
{13, 14, 16, 17, 22, 23, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1} // 26
};
/**
* Checks if the centre'th element of srcNbh is on. If it is,
* activate that element in dstNbh and also i0 to i3 if they are
* active in srcNbh. This is used during the recursive 6 connectivity
* determination.
*/
static inline void fillLocal6Neighbours(int *srcNbh, int *dstNbh, int centre, int i0, int i1, int i2, int i3)
{
if (srcNbh[centre])
{
dstNbh[centre] = 1;
if (srcNbh[i0])
dstNbh[i0] = 1;
if (srcNbh[i1])
dstNbh[i1] = 1;
if (srcNbh[i2])
dstNbh[i2] = 1;
if (srcNbh[i3])
dstNbh[i3] = 1;
}
}
/**
* The idx'th voxel in nbh is ALREADY labeled. This checks for
* existing 6-neighbours and gives them label curlabel.
*/
static void label6Neighbours(int *nbh, int *nbhlabels, int *nbhv, int curlabel, int idx)
{
// needs good initial value
int nbhIdx = 0;
// 6 neighbours max (also in the lookup table)
for (int i = 0; i < 6 && nbhIdx >= 0; i++)
{
nbhIdx = nbh6Table[idx][i];
// valid nbh index and the voxel exists and it hasn't been labeled
// yet
if (nbhIdx >= 0 && nbh[nbhIdx] && nbhlabels[nbhIdx] == 0)
{
// then label it
nbhlabels[nbhIdx] = curlabel;
// and record that it has been labeled, but needs to recursed
// we only do this if V doesn't have a value yet
if (nbhv[nbhIdx] == 0)
nbhv[nbhIdx] = 1;
}
}
}
/**
* The idx'th voxel in nbh is ALREADY labeled. This checks for
* existing 26-neighbours and gives them label curlabel.
*/
static void label26Neighbours(int *nbh, int *nbhlabels, int *nbhv, int curlabel, int idx)
{
// needs good initial value
int nbhIdx = 0;
// 26 neighbours max (also in the lookup table)
for (int i = 0; i < 26 && nbhIdx >= 0; i++)
{
nbhIdx = nbh26Table[idx][i];
// valid nbh index and the voxel exists and it hasn't been labeled
// yet
if (nbhIdx >= 0 && nbh[nbhIdx] && nbhlabels[nbhIdx] == 0)
{
// then label it
nbhlabels[nbhIdx] = curlabel;
// and record that it has been labeled, but needs to recursed
// we only do this if V doesn't have a value yet
if (nbhv[nbhIdx] == 0)
nbhv[nbhIdx] = 1;
}
}
}
static inline int connectedComponents(int *nbh, int *nbhLabels, void (*labelNeighboursFunc)(int *, int *, int *, int, int) )
{
// create and init V struct
int nbhV[27];
memset(nbhV, 0, 27 * sizeof(int));
int curlabel = 1, assignedlabel = 0;
for (int i = 0; i < 27; i++)
{
// is there a voxel at this position, and has it not been labeled yet?
if (nbh[i] && nbhLabels[i] == 0)
{
// ON voxel not labeled yet
nbhLabels[i] = curlabel;
// this is to keep track of how many labels we've actually USED
assignedlabel = curlabel;
// mark it as being labeled
nbhV[i] = 1;
// now recurse through n26v finding ALL voxels of curlabel
// we continue doing this until there are no 1s, i.e. only
// 2s (neighbours examined) and 0s (no connected labels)
int onesFound;
do
{
onesFound = 0;
for (int j = 0; j < 27; j++)
{
if (nbhV[j] == 1)
{
onesFound = 1;
// this will label 6-neighbours and also flag the fact
// that they're labeled by setting a '1' in n26v
// neighbours that are already 2 will be left alone
labelNeighboursFunc(nbh, nbhLabels, nbhV, curlabel, j);
// now all neighbours of voxel j have also been labeled
nbhV[j] = 2;
}
} // for (int j = 0 ...
}
while (onesFound);
// if we find the next unlabeled thing, it has to be a new
// component by definition
curlabel++;
} // if (n26nbh[i] && n26labels[i] == 0) ...
} // for (int i = 0; i < 27 ...
return assignedlabel;
}
// you could also use epsilon from the levelset function
#define TPGAC_EPSILON 1e-5;
template <class TInputImage, class TFeatureImage, class TOutputType>
typename TPGACLevelSetImageFilter< TInputImage, TFeatureImage, TOutputType>::ValueType
TPGACLevelSetImageFilter<TInputImage, TFeatureImage, TOutputType>
::CalculateUpdateValue(const IndexType &idx, const TimeStepType &dt, const ValueType &value, const ValueType &change)
{
// * calculate new value
// * if new value has the same sign as current value, make the
// change
// * ELSE:
// * extract 3x3x3 neighbourhood of the current voxel
// * calculate N^2_6(x,X) and N^1_26(x,X')
// * count connected components (bail if more than 1)
// * if both 1, then x is simple point, allow change
// * if not (or bailed) x is not simple point
// * newValue = epsilon * sign(value) (epsilon small and positive)
ValueType temp_value = value + dt * change;
// sign is the same, we can return what we have
if (temp_value * value >= 0)
{
return temp_value;
}
// create a 3x3x3 nbh iterator over the output image
Size<3> radius = {1,1,1};
NeighborhoodIterator<OutputImageType>
nbhIterator(radius, this->GetOutput(),
this->GetOutput()->GetRequestedRegion());
// move the 3x3x3 nbh iterator over the current voxel
nbhIterator.SetLocation(idx);
// offset of centre pixel
//#define c 13
// transfer nbh to our interior/exterior nbh
int ieNbh[27];
for (int i = 0; i < 27; i++)
{
if (nbhIterator.GetPixel(i) >= 0)
{
// interior / inside / foreground
ieNbh[i] = 1;
}
else
{
// exterior / outside / background
ieNbh[i] = 0;
}
}
// N^2_6 == n26
// N^1_26 == n126
// now calculate N^2_6(interior) - we do this as straight-forward as
// possible for speed reasons
// first allocate and clear the nbh array
int n26nbh[27];
memset(n26nbh, 0, 27 * sizeof(int));
// if (ieNbh[4])
// {
// n26nbh[4] = 1;
// if (ieNbh[1]) n26nbh[1] = 1;
// if (ieNbh[3]) n26nbh[3] = 1;
// if (ieNbh[5]) n26nbh[5] = 1;
// if (ieNbh[7]) n26nbh[7] = 1;
// }
// then check the 6-neighbours of 4, i.e. 1, 3, 5, 7, but NOT the
// center voxel itself... that's explicitly excluded
fillLocal6Neighbours(ieNbh, n26nbh, 4, 1, 3, 5, 7);
fillLocal6Neighbours(ieNbh, n26nbh, 10, 1, 9, 11, 19);
fillLocal6Neighbours(ieNbh, n26nbh, 12, 3, 9, 15, 21);
fillLocal6Neighbours(ieNbh, n26nbh, 14, 5, 11, 17, 23);
fillLocal6Neighbours(ieNbh, n26nbh, 16, 7, 15, 17, 25);
fillLocal6Neighbours(ieNbh, n26nbh, 22, 19, 21, 23, 25);
// we should have a complete n^2_6(x,X) now...
// now determine number of connected components using
// fast method described in borgefors1997
int n26labels[27];
memset(n26labels, 0, 27 * sizeof(int));
int ncc6 = connectedComponents( n26nbh, n26labels, label6Neighbours);
if (ncc6 != 1)
{
// already T6(x,X) != 1, so we bail with epsilon * sign of old
// value... this saves us from the 26-neighbourhood background check
if (value < 0)
{
return -1 * TPGAC_EPSILON;
}
else
{
return TPGAC_EPSILON;
}
}
int n126nbh[27];
memset(n126nbh, 0, 27 * sizeof(int));
// we just invert ieNbh, because we're going to check the background
for (int i = 0; i < 27; i++)
{
n126nbh[i] = ! ieNbh[i];
}
// the centre voxel is NEVER used
n126nbh[13] = 0;
int n126labels[27];
memset(n126labels, 0, 27 * sizeof(int));
int ncc26 = connectedComponents(n126nbh, n126labels, label26Neighbours);
if (ncc26 != 1)
{
// T26(x,X') != 1, so we bail with epsilon * sign of old
// value...
if (value < 0)
{
return -1 * TPGAC_EPSILON;
}
else
{
return TPGAC_EPSILON;
}
}
// this means the voxel that is to be added is simple... we can just
// return the new value
return temp_value;
}
} // end namespace itk
//#if ITK_MANUAL_INSTANTIATION
//#include "itkTPGACLevelSetImageFilter.txx"
//#endif
#endif
|
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include "headers.h"
#include "treapNode.h"
QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE
class MainWindow : public QMainWindow {
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
void graphic(TreapNode<ul>*, bool) ;
public slots:
void onFileOpenButtonClicked();
void onTreapDrawingButtonClicked();
void onStepTreapDrawingButtonClicked();
void onTreapSplitingButtonClicked();
private:
Ui::MainWindow *ui;
void treePainter(TreapNode<ul> *, int, int, int, int, QPen &, QBrush &, QFont &, int);
void setUpUI();
void createTreap();
QPushButton *fileOpen;
QPushButton *drawingTreap;
QPushButton *stepDrawingTreap;
QPushButton *splitTreap;
QCheckBox *stepSwitch;
QGraphicsView *mainGraphicsView;
QGraphicsScene *mainGraphicsScene;
QPen pen;
QColor color;
QBrush brush;
QFont font;
QLineEdit *inputLine;
QLineEdit *splitKeyInput;
QLineEdit *slpitError;
QLabel *inputExprLabel;
QLabel *splitElLabel;
TreapNode<ul>* workingTreap;
bool isDrawing{false};
};
#endif // MAINWINDOW_H
|
#ifndef PERSONALINFOSTRUCT_H
#define PERSONALINFOSTRUCT_H
#include <QString>
#include <QDate>
#include <QByteArray>
#include <QPixmap>
class PersonalInfoStruct
{
public:
PersonalInfoStruct();
PersonalInfoStruct(
int id,
QString name,
QString mark,
QString sex,
QDate birthday,
QString mail,
QString mood,
QByteArray headImageByte);
//这是重载运算符
bool operator ==(PersonalInfoStruct &another);
PersonalInfoStruct& operator =(PersonalInfoStruct &another);
qint32 userID;
QString nickname;
QString mark;
QString sex;
QDate birthday;
QString mail;
QString mood;
QByteArray headImageByte;
QPixmap headImagePixmap;
};
#endif // PERSONALINFOSTRUCT_H
|
/*
* scout_interface.hpp
*
* Created on: Jul 08, 2021 12:02
* Description: Scout-specific interface
*
* Copyright (c) 2021 Weston Robot Pte. Ltd.
*/
#ifndef SCOUT_INTERFACE_HPP
#define SCOUT_INTERFACE_HPP
#include <string>
#include "ugv_sdk/details/interface/agilex_message.h"
#include "ugv_sdk/details/interface/robot_common_interface.hpp"
namespace westonrobot {
struct ScoutCoreState {
AgxMsgTimeStamp time_stamp;
SystemStateMessage system_state;
MotionStateMessage motion_state;
LightStateMessage light_state;
RcStateMessage rc_state;
};
struct ScoutActuatorState {
AgxMsgTimeStamp time_stamp;
// actuator state
// - for v2 robots only
ActuatorHSStateMessage actuator_hs_state[4];
ActuatorLSStateMessage actuator_ls_state[4];
// - for v1 robots only
ActuatorStateMessageV1 actuator_state[4];
};
struct ScoutInterface {
virtual ~ScoutInterface() = default;
virtual void Connect(std::string uart_name, uint32_t baudrate){
// use derived version
};
virtual void SetMotionCommand(double linear_vel, double angular_vel) = 0;
virtual void SetLightCommand(LightMode f_mode, uint8_t f_value,
LightMode r_mode, uint8_t r_value) = 0;
// get robot state
virtual ScoutCoreState GetRobotState() = 0;
virtual ScoutActuatorState GetActuatorState() = 0;
};
struct ScoutOmniInterface {
virtual ~ScoutOmniInterface() = default;
virtual void SetMotionCommand(double linear_vel, double angular_vel,
double lateral_velocity) = 0;
};
} // namespace westonrobot
#endif /* SCOUT_INTERFACE_HPP */
|
#include <iostream>
#include "QueueClass.h"
int main()
{
int testNum = 1;
QueueNode<int> testNode = QueueNode<int>(&testNum);
std::cout << testNode.value << std::endl;
QueueNode<int>* testNodePtr = &testNode;
std::cout << testNodePtr->value << std::endl;
Queue<int> myQueue;
std::cout << "A"<< std::endl;
int num1 = 1;
myQueue.enqueue(&num1);
std::cout << "B"<< std::endl;
int num2 = 2;
myQueue.enqueue(&num2);
std::cout << "C"<< std::endl;
int num3 = 3;
myQueue.enqueue(&num3);
std::cout << "C2"<< std::endl;
int num4 = 4;
myQueue.enqueue(&num4);
std::cout << "C3"<< std::endl;
int* val1 = myQueue.dequeue();
int* val2 = myQueue.dequeue();
int* val3 = myQueue.dequeue();
int* val4 = myQueue.dequeue();
int* val5 = myQueue.dequeue();
// std::cout << "Queue: " << *val1 << std::endl;
std::cout << "Queue: " << ((val1 == nullptr)?-1:*val1) << " " <<
((val2 == nullptr)?-1:*val2) << " " <<
((val3 == nullptr)?-1:*val3) << " " <<
((val4 == nullptr)?-1:*val4) << " " <<
((val5 == nullptr)?-1:*val5) << " " << std::endl;
// std::cout << "Queue: " << (int) *val1 << " " << (int) *val2 << " " << (int) *val3 << " " << (int) *val4 << " " << (int) *val5 << std::endl;
}
|
#include<iostream>
using namespace std;
int number[100];
int a, b, c;
int count_jump;
void check_position();
int jump_where();
int main() {
count_jump = 0;
cin >> a >> b >> c;
while (1) {
int jump_position = jump_where();
if (jump_position == 0)
break;
else if (jump_position == 1)
c = a + 1;
else if (jump_position == 2)
a = c - 1;
count_jump++;
check_position();
}
cout << count_jump;
}
void check_position() {
int big, mid, small;
if (a > b && a > c) {
big = a;
small = ((b < c) ? b : c);
if (small == b)
mid = c;
else mid = b;
}
else if (b > c) {
big = b;
small = ((a < c) ? a : c);
if (small == c)
mid = a;
else mid = c;
}
else {
big = c;
small = ((a < b) ? a : b);
if (small == a)
mid = b;
else mid = a;
}
a = small;
b = mid;
c = big;
}
int jump_where() {
int left = abs(a - b);
int right = abs(b - c);
if (left == 1 && right == 1) // 뛸 공간이 없음
return 0;
if (left <= right) // b c 사이로 a가 뜀
return 2;
else // a b 사이로 c가 뜀
return 1;
}
|
/*
* Copyright (C) 2007-2015 Frank Mertens.
*
* Use of this source is governed by a BSD-style license that can be
* found in the LICENSE file.
*
*/
#include <flux/Dir>
#include <flux/File>
#include <flux/DirWalker>
namespace flux {
Ref<DirWalker> DirWalker::open(String path)
{
return new DirWalker(path);
}
Ref<DirWalker> DirWalker::tryOpen(String path)
{
Ref<Dir> dir = Dir::tryOpen(path);
Ref<DirWalker> walker;
if (dir) walker = new DirWalker(path, dir);
return walker;
}
DirWalker::DirWalker(String path, Dir *dir):
maxDepth_(-1),
ignoreHidden_(false),
followSymlink_(false),
deleteOrder_(false),
depth_(0),
dir_(dir)
{
if (!dir_) dir_ = Dir::open(path);
}
bool DirWalker::read(String *path, bool *isDir)
{
if (child_) {
if (child_->read(path, isDir))
return true;
if (deleteOrder_) {
*path = child_->dir_->path();
if (isDir) *isDir = true;
child_ = 0;
return true;
}
child_ = 0;
}
String name;
while (dir_->read(&name)) {
if (name == "" || name == "." || name == "..") continue;
if (ignoreHidden_) if (name->at(0) == '.') continue;
String h = dir_->path(name);
child_ = tryOpen(h);
bool d = child_;
if (child_) {
if (depth_ != maxDepth_) {
if (!followSymlink_ && File::readlink(h) != "") {
child_ = 0;
}
else {
child_->maxDepth_ = maxDepth_;
child_->followSymlink_ = followSymlink_;
child_->deleteOrder_ = deleteOrder_;
child_->depth_ = depth_ + 1;
if (deleteOrder_)
return read(path, isDir);
}
}
else {
child_ = 0;
}
}
*path = h;
if (isDir) *isDir = d;
return true;
}
return false;
}
} // namespace flux
|
#pragma once
#include <string>
#include "pybind11/pybind11.h"
#include "drake/bindings/pydrake/documentation_pybind.h"
#include "drake/bindings/pydrake/pydrake_pybind.h"
#include "drake/common/type_safe_index.h"
namespace drake {
namespace pydrake {
/// Binds a TypeSafeIndex instantiation.
template <typename Type>
auto BindTypeSafeIndex(py::module m, const std::string& name,
const std::string& class_doc = "") {
py::class_<Type> cls(m, name.c_str(), class_doc.c_str());
cls
.def(py::init<int>(),
pydrake_doc.drake.TypeSafeIndex.ctor.doc_2)
.def("__int__", &Type::operator int)
.def("__eq__", [](const Type* self, const Type* other) {
return *self == *other;
}, py::is_operator())
.def("__eq__", [](const Type* self, int other) {
return *self == other;
}, py::is_operator())
// TODO(eric.cousineau): Add more operators.
.def("is_valid", &Type::is_valid,
pydrake_doc.drake.TypeSafeIndex.is_valid.doc);
return cls;
}
} // namespace pydrake
} // namespace drake
|
#ifndef IMAGE_H_INCLUDE
#define IMAGE_H_INCLUDE
/*
*read a pgm file and parse the pgm format and return the min, avg, max pixel value
*
*/
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <vector>
#include <stdio.h>
#include <cctype>
#include <string>
#include <math.h>
using namespace std;
class Image{
public:
/* public Base Image Methods*/
int parseImage(const string& inputFile, string type);
int readHeader(ifstream& istr, int headerValueCount, int isFirstLine, string type);
/*ASCII PGM file*/
int readP2Pixels(ifstream& istr);
int scaleP2Image(ofstream& ofs);
/*Binary PGM file*/
int readP5Pixels(ifstream& istr);
int scaleP5Image(ofstream& ofs);
/*ASCII PPM file*/
int readP3Pixels(ifstream& istr);
/*Binary PPm file*/
int readP6Pixels(ifstream& istr);
int writeFileWithTypeAndOfs(const string& type,ofstream& ofs);
/*Edges of Image*/
int EdgesCalculator();
/*PPM to PGM
precondition: a PPM image read in and no format error
*/
int PPM2PGM();
unsigned int width=0;
unsigned int height=0;
unsigned int upperLimit=0;
unsigned int maxPixel=0;
unsigned int minPixel=0;
vector<unsigned int> resultVector={};
vector<unsigned int> pixels={};
vector<unsigned int> PPMpixels={};
vector<vector<unsigned int>> pixelValues={};
private:
/*Edge calculation*/
vector<vector<int>> IHorizontal={};
vector<vector<int>> IVertical={};
vector<vector<unsigned int>> E={};
/*Helper Methods*/
int pixelsOneToTwoDimension();
int pixelsTwoToOneDimension();
};
/*non-class helper methods*/
int edgeValueCalculator(const vector<vector<unsigned int>>& pixelValues, int x,int y,int direction);
int theNumberOfDigitInLine(string str);
bool findExtralIllegalCharFromTheRestOfFile(ifstream& sReader);
string newLineAfterSkipEmptyLines(ifstream& sReader);
int parseALineOfPiexlsToVector(const unsigned int& width,const unsigned int& pixelValueLimit,const string& str,vector<unsigned int>& pixels);
bool checkIllegalChar(const string& str);
int parsePixelValueUpperLimit(const string& str,unsigned int &upperLimit);
int parseHeightAndWidth(const string& str,unsigned int &height,unsigned int &width);
string newLineAfterSkipEmptyAndCommentedLines(ifstream& sReader);
bool p2Validator(const string& str);
bool firstLineWhitespaceValidator(const string& str);
int warning(const string& warningMsg);
int formatError(const string& msg);
#endif // IMAGE_H_INCLUDE
|
class Solution
{
public:
ListNode *removeNthFromEnd(ListNode *head, int n)
{
ListNode **d = &head, *p = head;
while (n--) p = p->next;
while (p != NULL)
{
p = p->next;
d = &((*d)->next);
}
p = (*d)->next;
delete *d;
*d = p;
return head;
}
};
|
#include <Arduino.h>
#include <vector>
#include <WiFi.h>
#include <Wire.h>
#include "SPI.h"
#include "Adafruit_GFX.h" //for matrix led
#include "Adafruit_LEDBackpack.h"
#include "KB_initBoard.h"
#include "KB_music.h"
#include "KB_LDR.h"
#include "KB_LM73.h"
#include "KB_ht16k33.h"
#include "MCP7941x.h"
#include "Kalman.h"
#include "TFT_eSPI.h" //for matrix led
TFT_eSPI tft = TFT_eSPI();
MCP7941x rtc = MCP7941x();
Kalman mpu;
KB_board board = KB_board();
KB_music music = KB_music();
KB_LDR ldr = KB_LDR();
KB_LM73 lm73 = KB_LM73();
KB_8x16Matrix matrix = KB_8x16Matrix();
typedef int Number;
typedef int Boolean;
using namespace std;
std::vector<uint16_t> img1;
std::vector<uint16_t> img2;
std::vector<uint16_t> img3;
std::vector<uint16_t> img4;
std::vector<uint16_t> img5;
void setup() {
board.begin();
music.begin();
lm73.begin();
matrix.displayBegin();
ldr.begin();
mpu.begin();
tft.setmode(1);
img1 = (std::vector<uint16_t>{
0x820, 0x1041, 0x1061, 0x820, 0x1041, 0x1862, 0x820, 0x821, 0x862,
0x841, 0x841, 0x820, 0x820, 0x1061, 0x820, 0x820, 0x800, 0x820,
0x820, 0x821, 0x841, 0x1041, 0x820, 0x1021, 0x1040, 0x820, 0x821,
0x21, 0x862, 0x20, 0x841, 0x0, 0x821, 0x1041, 0x800, 0x1882,
0x1041, 0x28a4, 0x1882, 0x1861, 0x6054, 0x6965, 0x28e3, 0x1063, 0x844,
0x23, 0x844, 0x865, 0x46, 0x46, 0x46, 0x867, 0x1088, 0x1069,
0x18ca, 0x18cb, 0x210b, 0x392b, 0x498c, 0x59ed, 0x518c, 0x496b, 0x51ac,
0x498c, 0x416c, 0x394c, 0x396e, 0x394f, 0x4191, 0x49d2, 0x49b1, 0x49d2,
0x3950, 0x3992, 0x2172, 0x973, 0x198, 0x9b9, 0x199, 0x9b9, 0x9d9,
0x9b9, 0x9b9, 0x9b9, 0x9b9, 0x197, 0x176, 0x155, 0x135, 0x134,
0x111, 0x152, 0x153, 0x157, 0x178, 0x198, 0x176, 0x136, 0x135,
0x134, 0x952, 0x1931, 0x210f, 0x210f, 0x1910, 0x1151, 0x1972, 0x1110,
0x1931, 0x8f0, 0xf2, 0x112, 0xf3, 0xf3, 0xf3, 0xf3, 0x113,
0x112, 0xf0, 0x18cf, 0x290f, 0x290e, 0x30ed, 0x30ec, 0x310c, 0x310b,
0x310b, 0x310b, 0x392b, 0x30ea, 0x310a, 0x312a, 0x312b, 0x392b, 0x390a,
0x30ea, 0x390a, 0x392a, 0x392a, 0x390a, 0x30e9, 0x390a, 0x30e9, 0x38e9,
0x412b, 0x30e9, 0x30c9, 0x38e9, 0x38e9, 0x390a, 0x390a, 0x30c9, 0x3909,
0x38e9, 0x3909, 0x3909, 0x38e9, 0x4109, 0x38e9, 0x28a8, 0x1041, 0x841,
0x841, 0x0, 0x841, 0x1041, 0x1041, 0x820, 0x0, 0x821, 0x0,
0x800, 0x820, 0x840, 0x820, 0x0, 0x820, 0x20, 0x841, 0x820,
0x821, 0x820, 0x800, 0x820, 0x820, 0x840, 0x840, 0x841, 0x21,
0x0, 0x0, 0x821, 0x1061, 0x1861, 0x1041, 0x1882, 0x1042, 0x1842,
0x1862, 0x28a4, 0xf557, 0x3083, 0x1020, 0x844, 0x844, 0x44, 0x44,
0x887, 0x25, 0x46, 0x47, 0x48, 0x10a9, 0x18aa, 0x18aa, 0x18cb,
0x108a, 0x18ab, 0x392d, 0x496c, 0x498c, 0x494b, 0x498d, 0x418d, 0x416d,
0x416f, 0x416f, 0x314f, 0x3991, 0x49f3, 0x49b2, 0x41b1, 0x3991, 0x3172,
0x11b3, 0x1b5, 0x9d9, 0x198, 0x9d9, 0x9b9, 0x9da, 0x9b9, 0x9b9,
0x9d9, 0x9b9, 0x197, 0x197, 0x176, 0x155, 0x114, 0x113, 0x155,
0x198, 0x199, 0x9b9, 0x177, 0x135, 0x155, 0x155, 0x114, 0x932,
0x10f0, 0x2130, 0x210f, 0x2130, 0x10cf, 0x18ef, 0x212f, 0x10ce, 0x1151,
0x113, 0x134, 0x134, 0x114, 0x113, 0xf3, 0x113, 0xf2, 0x931,
0x1930, 0x210f, 0x312e, 0x392d, 0x394d, 0x392c, 0x390c, 0x392c, 0x392b,
0x396c, 0x310a, 0x30ea, 0x394b, 0x390a, 0x390a, 0x392b, 0x390a, 0x412b,
0x410a, 0x412a, 0x412a, 0x410a, 0x38ea, 0x410a, 0x38e9, 0x410a, 0x494a,
0x38e9, 0x390a, 0x390a, 0x38e9, 0x38e9, 0x38e9, 0x3929, 0x3909, 0x3909,
0x392a, 0x3909, 0x30e9, 0x390a, 0x30c8, 0x820, 0x820, 0x841, 0x0,
0x800, 0x800, 0x821, 0x1041, 0x821, 0x820, 0x800, 0x1041, 0x820,
0x0, 0x820, 0x820, 0x820, 0x841, 0x20c3, 0x1861, 0x820, 0x1041,
0x800, 0x1041, 0x1061, 0x841, 0x18c2, 0x20, 0x821, 0x20, 0x821,
0x1882, 0x1021, 0x1041, 0x1883, 0x1862, 0x2083, 0x1862, 0x20a3, 0x2846,
0xfe07, 0x2082, 0x18a3, 0x864, 0x844, 0x43, 0x44, 0x886, 0x46,
0x66, 0x67, 0x88, 0x8a, 0x10ab, 0x10ab, 0x18cb, 0x18ab, 0x18ac,
0x310d, 0x392e, 0x414d, 0x498e, 0x396d, 0x418f, 0x396f, 0x3970, 0x3171,
0x2972, 0x39d4, 0x31d4, 0x2972, 0x2951, 0x2131, 0x2152, 0x994, 0x197,
0x1b8, 0x176, 0x177, 0x9d9, 0x9da, 0x9b9, 0x9d9, 0x9d9, 0x9b9,
0x1b7, 0x195, 0x155, 0x156, 0x156, 0x157, 0x198, 0x199, 0x9d9,
0x9b8, 0x197, 0x135, 0x155, 0x176, 0x134, 0x132, 0x8f1, 0x2952,
0x210f, 0x212f, 0x2930, 0x292f, 0x18ee, 0x18ee, 0x10ef, 0x112, 0x113,
0x114, 0x114, 0x113, 0xf3, 0x112, 0xd1, 0x8d1, 0x1910, 0x2950,
0x210e, 0x28ed, 0x392d, 0x28cc, 0x28cb, 0x30eb, 0x392b, 0x392c, 0x496d,
0x30ea, 0x310a, 0x392b, 0x414b, 0x496c, 0x390b, 0x410a, 0x412a, 0x38ea,
0x410a, 0x410a, 0x410a, 0x412a, 0x410a, 0x38e9, 0x38c9, 0x38e9, 0x38e9,
0x38e9, 0x390a, 0x30c9, 0x38e9, 0x390a, 0x3908, 0x3909, 0x38e9, 0x3909,
0x3909, 0x38e9, 0x30e9, 0x841, 0x820, 0x820, 0x820, 0x800, 0x0,
0x821, 0x820, 0x821, 0x820, 0x0, 0x841, 0x820, 0x800, 0x0,
0x800, 0x821, 0x20c3, 0x1021, 0x820, 0x820, 0x821, 0x800, 0x821,
0x1061, 0x841, 0x820, 0x20, 0x20, 0x800, 0x821, 0x801, 0x1021,
0x1862, 0x1021, 0x1863, 0x2063, 0x2043, 0x2883, 0x3811, 0xb2e4, 0x1862,
0x1063, 0x24, 0x44, 0x43, 0x888, 0x867, 0x1067, 0x847, 0x47,
0x88, 0x89, 0xab, 0x8ab, 0x18ab, 0x188b, 0x10cb, 0x18ed, 0x292e,
0x394f, 0x312e, 0x398f, 0x3970, 0x394f, 0x2952, 0x2173, 0x1975, 0x155,
0x1153, 0x1193, 0x1132, 0x2193, 0x1932, 0x196, 0x197, 0x121a, 0x198,
0x9b8, 0x9d9, 0x9b9, 0x9b9, 0x9b9, 0x9d9, 0x177, 0x176, 0x134,
0x155, 0x179, 0x99a, 0x9ba, 0x11fa, 0x9ba, 0x9b9, 0x9b9, 0x197,
0x155, 0x155, 0x156, 0x155, 0x133, 0x153, 0x1971, 0x192f, 0x212f,
0x18ce, 0x210e, 0x18cd, 0x18ee, 0x212f, 0x8f0, 0x113, 0x114, 0x114,
0xf4, 0xf3, 0xf2, 0x112, 0x8f1, 0x10f0, 0x1910, 0x210f, 0x28ed,
0x28ed, 0x310d, 0x28cb, 0x30ec, 0x310b, 0x394c, 0x394b, 0x394b, 0x412b,
0x390b, 0x412c, 0x412b, 0x410b, 0x38ea, 0x410a, 0x390a, 0x410a, 0x412a,
0x410a, 0x412b, 0x38e9, 0x4109, 0x38c9, 0x410a, 0x412a, 0x410a, 0x38e9,
0x38e9, 0x390a, 0x30e9, 0x38e9, 0x3909, 0x38e9, 0x38c9, 0x390a, 0x38e9,
0x38e9, 0x821, 0x800, 0x821, 0x821, 0x0, 0x821, 0x1062, 0x841,
0x820, 0x840, 0x820, 0x840, 0x800, 0x820, 0x841, 0x800, 0x1061,
0x820, 0x820, 0x841, 0x840, 0x821, 0x1041, 0x1041, 0x821, 0x800,
0x0, 0x20, 0x821, 0x1083, 0x821, 0x1882, 0x1882, 0x1042, 0x1863,
0x1863, 0x1842, 0x1862, 0x2043, 0x6893, 0x3903, 0x1883, 0x1084, 0x24,
0x865, 0x44, 0x47, 0x867, 0x846, 0x867, 0x868, 0x108a, 0x8cb,
0x8ab, 0x88a, 0x10ab, 0x10ab, 0x18ab, 0x212e, 0x190f, 0x2930, 0x2971,
0x2992, 0x2951, 0x2972, 0x2153, 0x2151, 0x175, 0x9d8, 0x9d8, 0x154,
0x932, 0x952, 0x177, 0x197, 0x197, 0x9d8, 0x198, 0x9b9, 0x177,
0x9b9, 0x9b9, 0x9b9, 0x1b8, 0x997, 0x155, 0x134, 0x1b8, 0x9b9,
0x11fb, 0x11da, 0x11da, 0x9ba, 0x9b9, 0x9b9, 0x156, 0x135, 0x175,
0x134, 0x153, 0x153, 0x932, 0x1932, 0x1930, 0x190e, 0x20ee, 0x290d,
0x210d, 0x20ed, 0x210e, 0x1910, 0x112, 0xf3, 0x114, 0xf4, 0xf3,
0xf3, 0xf2, 0x112, 0x111, 0x10f0, 0x2930, 0x292e, 0x312d, 0x312d,
0x30ec, 0x310c, 0x392c, 0x310b, 0x392c, 0x30ea, 0x392b, 0x412b, 0x392b,
0x390b, 0x392b, 0x390b, 0x412b, 0x412b, 0x412a, 0x412a, 0x410a, 0x38ea,
0x410a, 0x412a, 0x412a, 0x38c9, 0x390a, 0x410a, 0x4109, 0x38e9, 0x390a,
0x3909, 0x3909, 0x392a, 0x38e9, 0x390a, 0x412b, 0x38e9, 0x30c9, 0x841,
0x1041, 0x821, 0x800, 0x821, 0x20a3, 0x821, 0x0, 0x820, 0x841,
0x800, 0x800, 0x800, 0x820, 0x820, 0x820, 0x800, 0x820, 0x1041,
0x800, 0x820, 0x820, 0x1061, 0x841, 0x0, 0x20, 0x20, 0x1062,
0x1082, 0x841, 0x1082, 0x1862, 0x1883, 0x1842, 0x1863, 0x1021, 0x1842,
0x1842, 0x2886, 0xff13, 0x1882, 0x2083, 0x824, 0x845, 0x44, 0x24,
0x67, 0x66, 0x66, 0x46, 0x18ca, 0x20cb, 0x20ed, 0x88b, 0x6a,
0x8b, 0x8ac, 0x210e, 0x1950, 0xf0, 0x111, 0x132, 0x113, 0x1952,
0x1b7, 0x994, 0x2131, 0x196, 0x121a, 0x9f9, 0x177, 0x176, 0x176,
0x1b8, 0x198, 0x1b8, 0x11fa, 0x1b8, 0x197, 0x198, 0x9d9, 0x9b9,
0x198, 0x1b7, 0x155, 0x154, 0x154, 0x178, 0x9ba, 0x9ba, 0x11da,
0x11da, 0x11ba, 0x9b9, 0x9b9, 0x176, 0x176, 0x175, 0x134, 0x912,
0x112, 0x132, 0x912, 0x1930, 0x18ee, 0x292f, 0x290d, 0x314d, 0x292d,
0x290d, 0x18ef, 0x132, 0x113, 0x113, 0x113, 0x113, 0x113, 0xf3,
0xf2, 0xf1, 0x18f0, 0x20f0, 0x20ee, 0x3990, 0x394e, 0x30ec, 0x30eb,
0x390c, 0x392c, 0x390b, 0x390b, 0x412c, 0x390b, 0x414c, 0x390a, 0x390b,
0x412b, 0x412b, 0x40ea, 0x414b, 0x412a, 0x390a, 0x410a, 0x38e9, 0x412a,
0x412a, 0x38e9, 0x412a, 0x38c9, 0x38e9, 0x38e9, 0x38e9, 0x38c9, 0x38ea,
0x3909, 0x38e9, 0x38c9, 0x30c9, 0x38ea, 0x30ea, 0x800, 0x821, 0x820,
0x821, 0x821, 0x1062, 0x821, 0x820, 0x820, 0x861, 0x820, 0x800,
0x840, 0x820, 0x800, 0x820, 0x820, 0x821, 0x1041, 0x821, 0x841,
0x820, 0x0, 0x20, 0x41, 0x20, 0x0, 0x1082, 0x10a3, 0x841,
0x1882, 0x1062, 0x1062, 0x1883, 0x1883, 0x1862, 0x1841, 0x2063, 0x3069,
0xe4a3, 0x1862, 0x2084, 0x24, 0x24, 0x44, 0x845, 0x867, 0x46,
0x46, 0x10a8, 0x20ca, 0x20eb, 0x210d, 0x8cb, 0x8ab, 0xac, 0x8ed,
0x10ee, 0x930, 0x112, 0x132, 0x153, 0x154, 0x198, 0x11f9, 0x974,
0x154, 0x9f9, 0x121a, 0x11f9, 0x121a, 0x197, 0x197, 0x9d9, 0x198,
0x11fa, 0x11fa, 0x11da, 0x9da, 0x9da, 0x11fa, 0x9da, 0x9da, 0x197,
0x155, 0x113, 0x155, 0x9d9, 0x999, 0x9ba, 0x99a, 0x11da, 0x999,
0x9b9, 0x9b9, 0x197, 0x196, 0x135, 0x154, 0x153, 0x132, 0x173,
0x1132, 0x1110, 0x212f, 0x290e, 0x28ec, 0x290c, 0x290c, 0x290d, 0x20ef,
0x1131, 0x132, 0x112, 0x113, 0x113, 0xf3, 0xf2, 0xf2, 0xf1,
0x111, 0x1910, 0x2930, 0x312e, 0x396e, 0x390d, 0x392d, 0x392c, 0x390b,
0x390b, 0x414c, 0x390b, 0x390b, 0x30cb, 0x412b, 0x416c, 0x410b, 0x410b,
0x492b, 0x410a, 0x390a, 0x410a, 0x412a, 0x38c9, 0x38e9, 0x414a, 0x4109,
0x410a, 0x38e9, 0x38e9, 0x414b, 0x412a, 0x38ea, 0x390a, 0x38ea, 0x38c9,
0x30e9, 0x38e9, 0x30c9, 0x30c9, 0x821, 0x1061, 0x821, 0x821, 0x800,
0x821, 0x800, 0x800, 0x820, 0x820, 0x820, 0x820, 0x820, 0x1041,
0x821, 0x820, 0x20, 0x841, 0x0, 0x841, 0x821, 0x840, 0x820,
0x21, 0x21, 0x21, 0x18e4, 0x1083, 0x821, 0x1042, 0x1042, 0x1042,
0x1062, 0x20e4, 0x1062, 0x1041, 0x1862, 0x2063, 0x3812, 0x6962, 0x1862,
0x1864, 0x44, 0x24, 0x24, 0x67, 0x887, 0x866, 0x846, 0x1088,
0x20ca, 0x314d, 0x18cb, 0xab, 0xab, 0xac, 0x8ce, 0x1150, 0x110,
0x133, 0x132, 0x112, 0x156, 0x11fa, 0x1a7b, 0x195, 0x9f8, 0x1a3a,
0x9fa, 0x177, 0x121a, 0x176, 0x9b8, 0x9d9, 0x1b8, 0x198, 0x11da,
0x11fb, 0x121b, 0x121b, 0x121b, 0x1a3b, 0x11fa, 0x176, 0x174, 0x132,
0x176, 0x9fa, 0x11ba, 0x9b9, 0x9b9, 0x9b9, 0x198, 0x9b9, 0x198,
0x197, 0x176, 0x175, 0x174, 0x153, 0x132, 0x131, 0x1911, 0x1930,
0x2970, 0x210e, 0x28ed, 0x314e, 0x292d, 0x292e, 0x290f, 0x1911, 0x973,
0xf2, 0x113, 0x113, 0xf2, 0xf2, 0x112, 0xf1, 0x131, 0x2151,
0x290f, 0x314e, 0x312d, 0x394d, 0x412c, 0x392c, 0x390b, 0x390b, 0x38eb,
0x412c, 0x390b, 0x390b, 0x390b, 0x392b, 0x414b, 0x38ca, 0x412b, 0x38ea,
0x412a, 0x410a, 0x38e9, 0x38e9, 0x38c9, 0x412a, 0x3909, 0x392a, 0x390a,
0x412b, 0x410a, 0x390a, 0x38ea, 0x30c9, 0x392a, 0x390a, 0x412a, 0x38ea,
0x3909, 0x30c9, 0x841, 0x841, 0x820, 0x0, 0x821, 0x820, 0x1041,
0x800, 0x800, 0x820, 0x800, 0x800, 0x1021, 0x1021, 0x1041, 0x841,
0x0, 0x800, 0x841, 0x821, 0x0, 0x0, 0x20, 0x0, 0x41,
0x2145, 0x882, 0x10a3, 0x842, 0x1042, 0x1022, 0x1863, 0x1883, 0x20a3,
0x1862, 0x1882, 0x1862, 0x2083, 0xb3ba, 0x3082, 0x1082, 0x843, 0x44,
0x24, 0x24, 0x68, 0x867, 0x1887, 0x1887, 0x1088, 0x290b, 0x292d,
0x10aa, 0x88b, 0xac, 0xce, 0x910, 0x1992, 0x132, 0x133, 0x132,
0x132, 0x176, 0x1219, 0x229c, 0x197, 0x1a3b, 0x1a5b, 0x1a3b, 0x177,
0x1a5b, 0x197, 0x9d8, 0x11fa, 0x9b9, 0x121a, 0x1a3c, 0x1a1b, 0x1a1b,
0x121b, 0x11fb, 0x121b, 0x121a, 0x9b8, 0x174, 0x154, 0x175, 0x9b9,
0x11fa, 0x11da, 0x11fa, 0x9d9, 0x9b9, 0x198, 0x178, 0x177, 0x176,
0x154, 0x953, 0x8d1, 0x10f1, 0x1910, 0x1910, 0x10cf, 0x2130, 0x212e,
0x290e, 0x290d, 0x290d, 0x20ec, 0x314f, 0x2151, 0x1111, 0x112, 0x112,
0x113, 0x112, 0xf1, 0xf2, 0x112, 0x131, 0x2110, 0x312f, 0x310e,
0x392d, 0x30ec, 0x416d, 0x394c, 0x412c, 0x392c, 0x412c, 0x412c, 0x412c,
0x414c, 0x390b, 0x392b, 0x412b, 0x410b, 0x412b, 0x494b, 0x412a, 0x412a,
0x412b, 0x410a, 0x412a, 0x410a, 0x412a, 0x3909, 0x38e9, 0x412a, 0x38ea,
0x390a, 0x410a, 0x410a, 0x390a, 0x410a, 0x38e9, 0x38ea, 0x390a, 0x38ea,
0x0, 0x820, 0x801, 0x800, 0x821, 0x820, 0x0, 0x820, 0x0,
0x820, 0x820, 0x1041, 0x821, 0x821, 0x821, 0x821, 0x821, 0x0,
0x821, 0x821, 0x1062, 0x21, 0x20, 0x20, 0x8a2, 0x1945, 0x10c3,
0x10a3, 0x1083, 0x1042, 0x1022, 0x1883, 0x1863, 0x1022, 0x1842, 0x1862,
0x1842, 0x3065, 0xfeb1, 0x2883, 0x1862, 0x24, 0x45, 0x865, 0x45,
0x847, 0x1067, 0x1087, 0x867, 0x18c9, 0x210c, 0x8aa, 0x8aa, 0x10cb,
0x10ac, 0xef, 0x1971, 0x1192, 0x112, 0x112, 0x132, 0x153, 0x176,
0x1b8, 0x9d8, 0x1b8, 0x227c, 0x1a5c, 0x9d9, 0x9f9, 0x121a, 0x176,
0x1b8, 0x9b9, 0x1a3b, 0x1a3b, 0x121b, 0x1a3c, 0x225c, 0x1a3b, 0x1a5b,
0x1a3b, 0x9d9, 0x197, 0x175, 0x1195, 0x974, 0x198, 0x9da, 0x11fa,
0x11da, 0x178, 0x199, 0x198, 0x177, 0x177, 0x176, 0x154, 0x932,
0x20f1, 0x2110, 0x1930, 0x1951, 0x1131, 0x190f, 0x210e, 0x290e, 0x290e,
0x290d, 0x312e, 0x290e, 0x290f, 0x2930, 0x2151, 0x132, 0x112, 0x112,
0xf1, 0xf2, 0x112, 0x132, 0x2110, 0x310f, 0x394f, 0x392e, 0x38ec,
0x392c, 0x392c, 0x414c, 0x414c, 0x392c, 0x412c, 0x412c, 0x390b, 0x414c,
0x412b, 0x410b, 0x410b, 0x412b, 0x412b, 0x494b, 0x410a, 0x494b, 0x412a,
0x410a, 0x390a, 0x3909, 0x38e9, 0x38e9, 0x410a, 0x38e9, 0x412b, 0x38ea,
0x38e9, 0x38e9, 0x38c9, 0x412a, 0x38e9, 0x38ea, 0x494b, 0x820, 0x820,
0x820, 0x0, 0x821, 0x1061, 0x0, 0x820, 0x820, 0x0, 0x820,
0x1041, 0x821, 0x821, 0x800, 0x1882, 0x1041, 0x800, 0x821, 0x821,
0x821, 0x0, 0x861, 0x8c3, 0x8e4, 0xa3, 0xa3, 0x10e4, 0x18c4,
0x822, 0x1042, 0x1883, 0x20c4, 0x1042, 0x1882, 0x1862, 0x28a4, 0x302e,
0xd487, 0x28c3, 0x1884, 0x884, 0x44, 0x44, 0x867, 0x68, 0x1088,
0x1087, 0x1067, 0x10c9, 0x18eb, 0x88a, 0x8aa, 0x108a, 0x10cc, 0x10ef,
0x972, 0x112, 0x113, 0x112, 0x133, 0x134, 0x176, 0x1b8, 0x198,
0x197, 0x1a5b, 0x1a5c, 0x1a5c, 0x22bd, 0x197, 0x175, 0x197, 0x9b9,
0x1a3b, 0x121b, 0x121b, 0x1a3c, 0x1a3c, 0x1a3b, 0x1a3b, 0x123b, 0x9fa,
0x9d8, 0x198, 0x175, 0x975, 0x196, 0x1b9, 0x11da, 0x11da, 0x199,
0x199, 0x177, 0x197, 0x176, 0x156, 0x175, 0x932, 0x1911, 0x2130,
0x1931, 0x8f0, 0x1971, 0x18ef, 0x294f, 0x290e, 0x20cc, 0x312d, 0x392e,
0x312d, 0x310e, 0x3150, 0x3992, 0x10f0, 0x1152, 0x131, 0x111, 0x112,
0x111, 0x131, 0x1951, 0x2930, 0x312e, 0x310e, 0x30ed, 0x414e, 0x412d,
0x414d, 0x496d, 0x390c, 0x390b, 0x412b, 0x412b, 0x414c, 0x414c, 0x414c,
0x412b, 0x494c, 0x494b, 0x412a, 0x412b, 0x412a, 0x410a, 0x494a, 0x410a,
0x494b, 0x412a, 0x494b, 0x390a, 0x38e9, 0x390a, 0x412a, 0x38e9, 0x390a,
0x38e9, 0x410a, 0x38e9, 0x412b, 0x390a, 0x820, 0x841, 0x820, 0x820,
0x820, 0x0, 0x0, 0x0, 0x800, 0x1041, 0x800, 0x820, 0x820,
0x1021, 0x800, 0x1882, 0x821, 0x821, 0x821, 0x820, 0x0, 0x21,
0x883, 0xa3, 0x904, 0x62, 0x8c4, 0x883, 0x1062, 0x1063, 0x1043,
0x1863, 0x1042, 0x1042, 0x1862, 0x1862, 0x1862, 0x4016, 0x5906, 0x28c3,
0x1864, 0x824, 0x44, 0x44, 0x48, 0x88, 0x10a8, 0x18a8, 0x1088,
0x869, 0x8ab, 0xaa, 0x88a, 0x88b, 0x8ac, 0x1971, 0x112, 0x113,
0x133, 0x112, 0x113, 0x134, 0x198, 0x11fa, 0x1a5b, 0x11fa, 0x1a5c,
0x229d, 0x229d, 0x229c, 0x176, 0x196, 0x9f9, 0x11fa, 0x1a5c, 0x1a5c,
0x227d, 0x225d, 0x1a5c, 0x1a5c, 0x121b, 0x9d9, 0x198, 0x9d9, 0x9d9,
0x9b7, 0x176, 0x1b8, 0x11fa, 0x11da, 0x9b9, 0x9b9, 0x1b8, 0x1b8,
0x198, 0x176, 0x176, 0x155, 0x153, 0x1932, 0x1152, 0x951, 0x1931,
0x190f, 0x210e, 0x292e, 0x312e, 0x290d, 0x310d, 0x394d, 0x312d, 0x312e,
0x3991, 0x3151, 0x2972, 0x18f0, 0x2111, 0x1910, 0x8f1, 0xf1, 0x152,
0x8f1, 0x2910, 0x310f, 0x394f, 0x392d, 0x390d, 0x414e, 0x49ae, 0x412c,
0x390c, 0x414c, 0x414c, 0x412c, 0x414c, 0x412b, 0x496c, 0x494c, 0x494c,
0x412a, 0x410a, 0x412a, 0x3088, 0x412a, 0x412a, 0x390a, 0x410a, 0x412a,
0x410a, 0x412a, 0x38e9, 0x38e9, 0x412a, 0x4109, 0x412a, 0x414a, 0x38e9,
0x390a, 0x410a, 0x390a, 0x1041, 0x800, 0x840, 0x820, 0x820, 0x841,
0x820, 0x820, 0x800, 0x820, 0x1021, 0x800, 0x800, 0x841, 0x821,
0x21, 0x821, 0x841, 0x20, 0x0, 0x0, 0x1083, 0x10e4, 0x8c3,
0x10e4, 0x8e4, 0x8e4, 0x883, 0x863, 0x20a4, 0x1884, 0x1042, 0x1862,
0x1862, 0x1041, 0x28a4, 0x30a4, 0xb47c, 0x2085, 0x20a3, 0x844, 0x865,
0x845, 0x24, 0x27, 0x867, 0x18a8, 0x1067, 0x1888, 0x18aa, 0x10ab,
0x8eb, 0x8a, 0xab, 0x8cd, 0x1192, 0x153, 0x133, 0x113, 0x133,
0x133, 0x155, 0x1b8, 0x229c, 0x1a3b, 0x1a3b, 0x2add, 0x2abd, 0x2a9d,
0x1a3b, 0x1d8, 0x196, 0x9f8, 0x1a3b, 0x1a3b, 0x1a3c, 0x1a5c, 0x225c,
0x1a5c, 0x1a3c, 0x1a3b, 0x123b, 0x123b, 0x121b, 0x9f9, 0x1b8, 0x197,
0x9d9, 0x9b9, 0x9da, 0x199, 0x198, 0x9f9, 0x198, 0x197, 0x197,
0x176, 0x176, 0x134, 0x153, 0x133, 0x1952, 0x2171, 0x210f, 0x20ee,
0x312e, 0x290d, 0x310d, 0x394e, 0x312d, 0x392e, 0x312f, 0x3150, 0x2910,
0x2951, 0x3151, 0x2930, 0x2130, 0x911, 0x112, 0x112, 0x2112, 0x20ef,
0x290f, 0x394f, 0x312e, 0x392e, 0x392d, 0x414d, 0x496e, 0x412d, 0x390c,
0x494d, 0x414c, 0x412c, 0x494c, 0x412b, 0x412b, 0x496c, 0x412b, 0x494b,
0x494b, 0x412a, 0x412a, 0x492b, 0x412a, 0x38e9, 0x412a, 0x40e9, 0x410a,
0x38c9, 0x38e9, 0x4109, 0x4109, 0x3909, 0x390a, 0x38ea, 0x390a, 0x390a,
0x390a, 0x800, 0x820, 0x820, 0x820, 0x820, 0x820, 0x800, 0x800,
0x820, 0x821, 0x821, 0x821, 0x821, 0x2104, 0x821, 0x20, 0x21,
0x0, 0x821, 0x862, 0x41, 0x10e5, 0x82, 0xa3, 0xc3, 0x925,
0xe4, 0x83, 0x1084, 0x20c5, 0x1883, 0x1062, 0x1042, 0x1042, 0x1842,
0x2084, 0x4069, 0xffbe, 0x28c4, 0x18a2, 0x845, 0x865, 0x44, 0x44,
0x68, 0x867, 0x18a8, 0x18a8, 0x18a9, 0x18eb, 0x10aa, 0xca, 0xab,
0x8ab, 0x10e, 0x111, 0x133, 0x133, 0x133, 0x133, 0x155, 0x176,
0x121a, 0x227c, 0x227c, 0x2abd, 0x32fe, 0x331f, 0x2add, 0x121b, 0x196,
0x176, 0x198, 0x1a3b, 0x1a3b, 0x227d, 0x2abe, 0x227d, 0x1a3c, 0x1a5c,
0x1a3b, 0x121b, 0x121b, 0x331e, 0x121a, 0x9d9, 0x1b8, 0x9fa, 0x11fa,
0x9da, 0x9d9, 0x198, 0x197, 0x1b7, 0x196, 0x176, 0x176, 0x154,
0x1195, 0x133, 0x912, 0x1911, 0x2130, 0x292f, 0x20cd, 0x290d, 0x312e,
0x310e, 0x310e, 0x310e, 0x312f, 0x2950, 0x2951, 0x2131, 0x2111, 0x2910,
0x2951, 0x1912, 0x112, 0x112, 0x112, 0x1910, 0x2110, 0x294f, 0x292f,
0x396f, 0x414f, 0x416f, 0x416e, 0x392d, 0x412d, 0x390d, 0x412d, 0x410c,
0x414d, 0x412c, 0x412c, 0x414c, 0x412b, 0x494b, 0x38ea, 0x412a, 0x412a,
0x494b, 0x410a, 0x412a, 0x494b, 0x492a, 0x496b, 0x412a, 0x38e9, 0x494a,
0x410a, 0x414a, 0x3909, 0x412a, 0x3909, 0x30c9, 0x410a, 0x410a, 0x820,
0x820, 0x820, 0x800, 0x800, 0x800, 0x800, 0x800, 0x820, 0x820,
0x1020, 0x820, 0x0, 0x841, 0x1041, 0x820, 0x820, 0x840, 0x821,
0x841, 0x1905, 0x884, 0x62, 0x8e4, 0x19a7, 0xe3, 0x8c4, 0x18a5,
0x1043, 0x1023, 0x1042, 0x1842, 0x1022, 0x2083, 0x2083, 0x28c5, 0x4054,
0xbd17, 0x20a3, 0x1882, 0x1046, 0x845, 0x45, 0x65, 0x867, 0x10a8,
0x18a8, 0x18a8, 0x18a9, 0x18aa, 0x108a, 0xaa, 0xcb, 0xac, 0xee,
0x132, 0x132, 0x133, 0x133, 0x133, 0x177, 0x199, 0x227c, 0x2add,
0x2abd, 0x32fe, 0x331e, 0x32fe, 0x2ade, 0x121a, 0x196, 0x196, 0x1b8,
0x121b, 0x1a5c, 0x227d, 0x227d, 0x1a3c, 0x227d, 0x1a5c, 0x11fb, 0x11fa,
0x121b, 0x1a3b, 0x11fa, 0x9b9, 0x9da, 0x11fa, 0x9da, 0x9b9, 0x9d9,
0x1b8, 0x197, 0x1b7, 0x1b7, 0x196, 0x175, 0x912, 0x1111, 0x1951,
0x1930, 0x1910, 0x290f, 0x28ce, 0x294f, 0x312f, 0x290e, 0x2950, 0x2130,
0x2951, 0x2972, 0x2152, 0x2132, 0x2111, 0x2111, 0x1911, 0x1112, 0x112,
0xf2, 0x132, 0x1132, 0x2132, 0x2971, 0x292f, 0x312f, 0x310e, 0x392e,
0x392e, 0x416e, 0x392d, 0x30ec, 0x498e, 0x412d, 0x412d, 0x390c, 0x412d,
0x412b, 0x494c, 0x414b, 0x412b, 0x494b, 0x412a, 0x412a, 0x492b, 0x492a,
0x496b, 0x4109, 0x38e9, 0x412a, 0x412a, 0x410a, 0x410a, 0x412a, 0x38e9,
0x4109, 0x412a, 0x412a, 0x412a, 0x390a, 0x496b, 0x820, 0x820, 0x820,
0x820, 0x1041, 0x1041, 0x821, 0x0, 0x1021, 0x800, 0x1041, 0x821,
0x821, 0x821, 0x821, 0x0, 0x20, 0x20, 0x841, 0x884, 0x8e4,
0x8e4, 0x63, 0x926, 0x146, 0x125, 0x105, 0x2927, 0x1063, 0x1043,
0x1062, 0x1001, 0x1042, 0x1863, 0x1842, 0x2063, 0x287d, 0x4110, 0x1863,
0x1884, 0x845, 0x44, 0x44, 0x47, 0x47, 0x87, 0x1087, 0x20c8,
0x1888, 0x18aa, 0x20aa, 0x10aa, 0x8a, 0xcc, 0xef, 0x112, 0x132,
0x132, 0x133, 0x134, 0x11f9, 0x1a3a, 0x229c, 0x2add, 0x32fd, 0x3b5e,
0x3b5e, 0x32fe, 0x22bd, 0x9f9, 0x1b8, 0x197, 0x9f9, 0x1a3b, 0x1a3b,
0x227d, 0x1a5c, 0x227d, 0x1a5c, 0x11fb, 0x121b, 0x121b, 0x121a, 0x121a,
0x9d9, 0x9fa, 0x11fa, 0x9fa, 0x9fa, 0x9d8, 0x9b8, 0x9f9, 0x197,
0x1b7, 0x196, 0x155, 0x975, 0x1932, 0x1111, 0x1951, 0x212f, 0x212e,
0x210e, 0x292f, 0x212e, 0x212f, 0x1910, 0x1931, 0x933, 0x954, 0x113,
0x932, 0x2152, 0x2152, 0x1931, 0x1132, 0x113, 0x113, 0xf2, 0xf1,
0x1932, 0x1911, 0x2931, 0x3150, 0x3150, 0x3110, 0x4170, 0x394f, 0x394e,
0x396e, 0x416f, 0x392d, 0x414e, 0x414d, 0x38eb, 0x492c, 0x38eb, 0x414c,
0x494c, 0x492b, 0x494b, 0x410a, 0x492b, 0x410a, 0x494b, 0x412a, 0x492a,
0x494b, 0x412a, 0x410a, 0x40e9, 0x412a, 0x412a, 0x412a, 0x412a, 0x38e9,
0x410a, 0x38ea, 0x410a, 0x38e9, 0x841, 0x800, 0x820, 0x0, 0x801,
0x820, 0x800, 0x1082, 0x0, 0x0, 0x821, 0x41, 0x821, 0x841,
0x800, 0x841, 0x841, 0x862, 0x8a4, 0xe5, 0xa3, 0x1146, 0x146,
0x186, 0x187, 0x167, 0x147, 0x884, 0x1084, 0x1863, 0x1062, 0x1042,
0x1863, 0x1042, 0x1842, 0x1842, 0x72ba, 0x28a6, 0x1862, 0x1064, 0x845,
0x44, 0x45, 0x47, 0x888, 0x867, 0x30e9, 0x20a9, 0x310b, 0x28ca,
0x18aa, 0x10aa, 0x8ab, 0x8ad, 0xce, 0x132, 0x132, 0x133, 0x133,
0x177, 0x121a, 0x1a7b, 0x3b5f, 0x3b3e, 0x3b7e, 0x437f, 0x3b5e, 0x331e,
0x229c, 0x1b6, 0x9d8, 0x9d9, 0x121a, 0x1a3b, 0x1a3c, 0x1a5c, 0x227d,
0x229d, 0x1a5c, 0x1a3b, 0x1a3b, 0x1a3b, 0x1a3b, 0x123a, 0x9f9, 0x9d9,
0x9d9, 0x9d9, 0x9d9, 0x1b8, 0x9d8, 0x1d8, 0x1b7, 0x198, 0x176,
0x175, 0x134, 0x1152, 0x2151, 0x2130, 0x212f, 0x294f, 0x290e, 0x292e,
0x292f, 0x210f, 0x1910, 0x1111, 0x112, 0x174, 0x153, 0x132, 0x18f0,
0x2972, 0x1952, 0x112, 0x154, 0x133, 0x133, 0x132, 0x1932, 0x2131,
0x3171, 0x3150, 0x3150, 0x28ee, 0x3150, 0x290e, 0x314f, 0x394e, 0x310d,
0x416e, 0x414e, 0x412d, 0x30cb, 0x410c, 0x496d, 0x412c, 0x494c, 0x494c,
0x410b, 0x412b, 0x494b, 0x494b, 0x492b, 0x412b, 0x40ea, 0x412a, 0x412a,
0x412a, 0x410a, 0x494a, 0x496b, 0x412a, 0x4109, 0x492b, 0x492b, 0x494b,
0x412a, 0x412b, 0x800, 0x800, 0x821, 0x800, 0x1041, 0x1041, 0x800,
0x1062, 0x821, 0x821, 0x1042, 0x821, 0x1041, 0x821, 0x821, 0x841,
0x862, 0x18a4, 0x883, 0x926, 0xa4, 0xe5, 0x186, 0x146, 0x146,
0x187, 0xe6, 0x884, 0x18a4, 0x1083, 0x1062, 0x1042, 0x1863, 0x1022,
0x1883, 0x28a6, 0xffdf, 0x1863, 0x1041, 0x65, 0x865, 0x65, 0x66,
0x88, 0x1088, 0x20c9, 0x28e9, 0x20c9, 0x310b, 0x20a9, 0x20ea, 0x28eb,
0x10eb, 0x8ac, 0xce, 0x112, 0x132, 0x133, 0x154, 0x1b8, 0x123a,
0x32fd, 0x331d, 0x43bf, 0x439e, 0x3b5e, 0x3b3e, 0x32fe, 0x1a5c, 0x9d9,
0x121a, 0x9f9, 0x123b, 0x1a5c, 0x1a5c, 0x227d, 0x229d, 0x229d, 0x227d,
0x1a3c, 0x1a3c, 0x1a3b, 0x1a5b, 0x1a3b, 0x11f9, 0x9f9, 0x9d9, 0x9d9,
0x9d9, 0x9f9, 0x9d8, 0x9d8, 0x9d8, 0x197, 0x176, 0x174, 0x1152,
0x2951, 0x2930, 0x292f, 0x290e, 0x316f, 0x292f, 0x210f, 0x2130, 0x2151,
0x1911, 0x1153, 0x133, 0x134, 0x1174, 0x1153, 0x1912, 0x1932, 0x1132,
0x133, 0x113, 0x112, 0xf1, 0x1153, 0x2132, 0x2932, 0x2930, 0x2910,
0x3992, 0x2930, 0x3150, 0x314f, 0x3970, 0x392f, 0x49af, 0x390d, 0x414e,
0x496e, 0x414d, 0x496e, 0x412d, 0x496d, 0x412c, 0x390b, 0x496d, 0x494c,
0x38ea, 0x492b, 0x410a, 0x412a, 0x412a, 0x412a, 0x412a, 0x518c, 0x412a,
0x410a, 0x4109, 0x494b, 0x412b, 0x410a, 0x410a, 0x410a, 0x390a, 0x412b,
0x800, 0x820, 0x820, 0x800, 0x821, 0x800, 0x1062, 0x820, 0x0,
0x821, 0x821, 0x1062, 0x1882, 0x821, 0x1021, 0x1022, 0x1083, 0x10c4,
0x1125, 0xc4, 0x906, 0x167, 0x166, 0x126, 0x9c9, 0x1a9, 0x927,
0x864, 0x1083, 0x1042, 0x1062, 0x1862, 0x1042, 0x20a3, 0x1883, 0x2010,
0xde5a, 0x2083, 0x18a4, 0x25, 0x45, 0x44, 0x8c8, 0x88, 0x10a8,
0x20c8, 0x28e9, 0x28c9, 0x30eb, 0x312b, 0x290b, 0x314c, 0x290b, 0x18cd,
0x8ce, 0xcf, 0x132, 0x133, 0x175, 0x11f9, 0x1a3a, 0x229c, 0x2add,
0x333e, 0x439f, 0x3b7f, 0x331e, 0x2abd, 0x227c, 0x1a5c, 0x1a5b, 0x1a5b,
0x1a5c, 0x227c, 0x2abd, 0x2abd, 0x2a9d, 0x229d, 0x1a3c, 0x1a3c, 0x227c,
0x1a3b, 0x1a5b, 0x123b, 0x121a, 0x9f9, 0x9f9, 0x9f9, 0x9f9, 0x9f9,
0x9d8, 0x9f9, 0x1b7, 0x176, 0x195, 0x112, 0x1952, 0x2930, 0x3150,
0x210e, 0x292e, 0x28ee, 0x2930, 0x2131, 0x1952, 0x1153, 0x912, 0x154,
0x134, 0x134, 0x174, 0x133, 0x133, 0x8f2, 0x1153, 0x1132, 0x1133,
0x112, 0x1153, 0x1932, 0x1932, 0x2151, 0x2971, 0x2931, 0x20ef, 0x3171,
0x3190, 0x3150, 0x394f, 0x394f, 0x414f, 0x4990, 0x498f, 0x412e, 0x390d,
0x494e, 0x412d, 0x414d, 0x392c, 0x414c, 0x494c, 0x412b, 0x494c, 0x412b,
0x494b, 0x412b, 0x412b, 0x410a, 0x412a, 0x494b, 0x410a, 0x412a, 0x494b,
0x412b, 0x38ea, 0x38ea, 0x494b, 0x412b, 0x390a, 0x494b, 0x820, 0x801,
0x821, 0x1062, 0x820, 0x821, 0x821, 0x821, 0x821, 0x1062, 0x1062,
0x841, 0x800, 0x1041, 0x2041, 0x1882, 0x18e5, 0x62, 0x883, 0x8a3,
0x146, 0x187, 0x166, 0x9ea, 0x1a9, 0x1c9, 0xe6, 0x1084, 0x1083,
0x1021, 0x1022, 0x1021, 0x1042, 0x1842, 0x1041, 0x2039, 0x6a71, 0x18a3,
0x1064, 0x846, 0x45, 0x25, 0x868, 0x88, 0x888, 0x3109, 0x28c8,
0x30ea, 0x312b, 0x392b, 0x28ea, 0x290b, 0x20eb, 0x18ec, 0x192f, 0x8ef,
0x152, 0x133, 0x155, 0x9d8, 0x1a3a, 0x1a5b, 0x229c, 0x331e, 0x3b7e,
0x331e, 0x2add, 0x1a5c, 0x229c, 0x229d, 0x227c, 0x22bd, 0x229d, 0x2abe,
0x2abd, 0x2ade, 0x2abe, 0x227d, 0x227d, 0x1a5c, 0x225c, 0x1a5b, 0x1a3b,
0x1a5b, 0x121a, 0x1219, 0x11f9, 0x9d9, 0x9d9, 0x9d8, 0x9d8, 0x9b8,
0x197, 0x196, 0x174, 0x1132, 0x2152, 0x292f, 0x314f, 0x292e, 0x314f,
0x292f, 0x2931, 0x1952, 0x953, 0x154, 0x155, 0x155, 0x135, 0x155,
0x134, 0x133, 0x133, 0x133, 0x1174, 0x1112, 0x1133, 0x133, 0x153,
0x1953, 0x1932, 0x2951, 0x2111, 0x2110, 0x3172, 0x2930, 0x3110, 0x310f,
0x3950, 0x394f, 0x414f, 0x392e, 0x392e, 0x416e, 0x392e, 0x390d, 0x412d,
0x412d, 0x414d, 0x392c, 0x414c, 0x494c, 0x494c, 0x496d, 0x494c, 0x412b,
0x410a, 0x494b, 0x412b, 0x410b, 0x410a, 0x38ea, 0x410a, 0x412b, 0x414b,
0x414b, 0x414b, 0x492b, 0x410b, 0x412b, 0x820, 0x821, 0x821, 0x1041,
0x821, 0x821, 0x801, 0x841, 0x821, 0x821, 0x1082, 0x1041, 0x1041,
0x1040, 0x28c4, 0x20e5, 0x862, 0x1105, 0x863, 0x8c5, 0x125, 0x187,
0x187, 0x1a9, 0x22b, 0x1e9, 0xa5, 0x843, 0x1062, 0x1022, 0x1883,
0x1042, 0x1042, 0x1883, 0x1062, 0x30dd, 0x3049, 0x1883, 0x845, 0x45,
0x45, 0x46, 0x10a9, 0x10a9, 0x18a8, 0x28c8, 0x28c9, 0x418c, 0x416d,
0x392c, 0x310b, 0x20ea, 0x18aa, 0x10cc, 0x10ef, 0x910, 0x153, 0x133,
0x154, 0x197, 0x9b8, 0x9f9, 0x121a, 0x2afd, 0x3b3f, 0x32fe, 0x2add,
0x2abd, 0x229c, 0x2add, 0x229d, 0x2add, 0x227c, 0x2abd, 0x2abd, 0x2abe,
0x227d, 0x229d, 0x227d, 0x227c, 0x225c, 0x227c, 0x1a5c, 0x123b, 0x1a5b,
0x1a3b, 0x11fa, 0x11fa, 0x9d8, 0x9d8, 0x1b8, 0x1b7, 0x196, 0x153,
0x1973, 0x1952, 0x2172, 0x210f, 0x294e, 0x316f, 0x292e, 0x2930, 0x2131,
0x1993, 0x174, 0x155, 0x155, 0x155, 0x155, 0x134, 0x155, 0x134,
0x134, 0x134, 0x113, 0x913, 0x113, 0x133, 0x954, 0x1953, 0x2172,
0x2151, 0x2972, 0x2151, 0x2931, 0x3152, 0x28cf, 0x3150, 0x3150, 0x312e,
0x394f, 0x4150, 0x4990, 0x392e, 0x416f, 0x414e, 0x412e, 0x414e, 0x414e,
0x412d, 0x414d, 0x412c, 0x494d, 0x492c, 0x410b, 0x412b, 0x414b, 0x494c,
0x412b, 0x496c, 0x412b, 0x496c, 0x38eb, 0x412b, 0x390b, 0x392b, 0x392b,
0x390b, 0x412b, 0x410b, 0x821, 0x1041, 0x821, 0x1041, 0x841, 0x1062,
0x821, 0x1041, 0x841, 0x841, 0x820, 0x820, 0x1061, 0x821, 0x882,
0x863, 0x883, 0xc4, 0x8a4, 0x146, 0x1a8, 0x146, 0x1c8, 0x22b,
0x28b, 0x1e9, 0x8c5, 0x843, 0x862, 0x1041, 0x1042, 0x1042, 0x18a3,
0x1883, 0x1061, 0xa41b, 0x2885, 0x1882, 0x10a6, 0x45, 0x65, 0x887,
0x18e9, 0x18a9, 0x18a9, 0x396b, 0x392b, 0x312b, 0x312b, 0x310b, 0x28eb,
0x20ca, 0x20eb, 0x190e, 0x112f, 0x930, 0x132, 0x112, 0x154, 0x175,
0x196, 0x177, 0x9b9, 0x227c, 0x32fe, 0x3b3f, 0x32fe, 0x1a5c, 0x22bc,
0x2adc, 0x227c, 0x2add, 0x229c, 0x32fe, 0x2abd, 0x2ade, 0x2abe, 0x227d,
0x227d, 0x227d, 0x227c, 0x1a5c, 0x227c, 0x1a3b, 0x1a3a, 0x121a, 0x123a,
0x11f9, 0x9f9, 0x1d8, 0x177, 0x176, 0x196, 0x1973, 0x29b3, 0x2131,
0x2951, 0x292f, 0x294f, 0x292e, 0x294f, 0x2970, 0x1910, 0x1153, 0x995,
0x155, 0x155, 0x175, 0x155, 0x134, 0x134, 0x154, 0x134, 0x134,
0x975, 0x134, 0x954, 0x974, 0x1133, 0x1953, 0x2172, 0x2972, 0x2131,
0x3172, 0x3151, 0x2910, 0x3172, 0x3151, 0x290f, 0x392f, 0x394f, 0x394f,
0x392e, 0x390e, 0x392e, 0x416f, 0x392e, 0x416e, 0x390d, 0x498e, 0x412d,
0x410c, 0x494c, 0x492c, 0x412c, 0x496c, 0x412b, 0x414c, 0x410b, 0x494c,
0x414b, 0x414b, 0x410b, 0x414b, 0x412b, 0x412b, 0x414b, 0x412c, 0x412b,
0x392b, 0x18a3, 0x1041, 0x1062, 0x1041, 0x1062, 0x0, 0x0, 0x1062,
0x821, 0x1062, 0x20, 0x820, 0x821, 0x842, 0x1084, 0x863, 0x106,
0x63, 0xe5, 0x147, 0x167, 0x167, 0x1ca, 0x24c, 0x2ac, 0x1a9,
0xa5, 0x10a4, 0x20e4, 0x1042, 0x822, 0x1022, 0x1062, 0x841, 0x1885,
0xff7b, 0x1883, 0x1083, 0x86, 0x66, 0x866, 0x1088, 0x18ea, 0x10a9,
0x20c9, 0x20c8, 0x414b, 0x310b, 0x290b, 0x292b, 0x20eb, 0x20eb, 0x18cb,
0x930, 0x1972, 0x1151, 0x152, 0x132, 0x154, 0x175, 0x155, 0x176,
0x197, 0x1a3b, 0x2ade, 0x2abd, 0x32fe, 0x2abd, 0x22bc, 0x22bc, 0x1a5c,
0x2abd, 0x2abd, 0x2add, 0x331e, 0x2abd, 0x229d, 0x2abd, 0x1a5c, 0x227d,
0x225c, 0x1a5c, 0x1a5c, 0x1a5b, 0x1a3b, 0x1a3b, 0x121b, 0x9d9, 0x1b8,
0x9d8, 0x1d8, 0x1b7, 0x19b5, 0x31b4, 0x41d3, 0x3991, 0x2950, 0x294f,
0x3970, 0x290e, 0x292e, 0x294f, 0x1910, 0xf2, 0x175, 0x155, 0x155,
0x134, 0x154, 0x154, 0x134, 0x134, 0x154, 0x174, 0x154, 0x133,
0x11b5, 0x933, 0x1174, 0x1152, 0x1911, 0x1911, 0x2131, 0x2910, 0x3151,
0x3151, 0x2931, 0x3171, 0x3150, 0x314f, 0x290e, 0x394f, 0x392f, 0x414f,
0x392e, 0x392e, 0x394e, 0x416e, 0x416e, 0x414e, 0x392d, 0x414d, 0x392c,
0x496d, 0x494c, 0x496c, 0x496c, 0x414c, 0x414b, 0x414c, 0x392c, 0x414c,
0x412c, 0x38eb, 0x412c, 0x38eb, 0x412c, 0x38eb, 0x412c, 0x410c, 0x821,
0x1862, 0x1041, 0x1062, 0x821, 0x841, 0x841, 0x1062, 0x18c3, 0x0,
0x1061, 0x821, 0x1062, 0x10a4, 0x8c5, 0x863, 0x10e5, 0xc5, 0x126,
0x147, 0x1a8, 0x1e9, 0x22b, 0x2ad, 0xb2e, 0x168, 0xc6, 0x1063,
0x1062, 0x1063, 0x1042, 0x1042, 0x1862, 0x841, 0x2887, 0xe544, 0x1882,
0x1084, 0x886, 0x65, 0x866, 0x18a9, 0x10ca, 0x1089, 0x20c9, 0x390a,
0x498d, 0x392b, 0x310b, 0x312c, 0x28eb, 0x290c, 0x212d, 0x2152, 0x21b4,
0x932, 0x153, 0x154, 0x195, 0x175, 0x154, 0x176, 0x1b8, 0x1a7c,
0x333e, 0x2add, 0x2abd, 0x2add, 0x22bc, 0x1a7b, 0x22bd, 0x229c, 0x32fe,
0x333e, 0x331e, 0x2ade, 0x229d, 0x2abe, 0x229d, 0x229d, 0x227d, 0x1a7c,
0x1a5c, 0x1a5c, 0x1a3b, 0x123b, 0x11fa, 0x9f9, 0x1d7, 0x1b7, 0x1b8,
0x197, 0x975, 0x2993, 0x3992, 0x3991, 0x3150, 0x316f, 0x294f, 0x316f,
0x290e, 0x290f, 0x3151, 0x154, 0x175, 0x155, 0x135, 0x1175, 0x954,
0x134, 0x154, 0x133, 0x953, 0x1954, 0x1133, 0x933, 0x974, 0x1154,
0x1112, 0x1953, 0x2173, 0x3193, 0x2972, 0x3151, 0x3172, 0x3151, 0x3171,
0x290f, 0x41b1, 0x3950, 0x394f, 0x392f, 0x392e, 0x392e, 0x394e, 0x414f,
0x416f, 0x414e, 0x392e, 0x414e, 0x414e, 0x412d, 0x498e, 0x494e, 0x412c,
0x496d, 0x496d, 0x498d, 0x390b, 0x390c, 0x416d, 0x414d, 0x38eb, 0x390c,
0x38ec, 0x390c, 0x412d, 0x414d, 0x392c, 0x392c, 0x1882, 0x1022, 0x1022,
0x1882, 0x801, 0x841, 0x841, 0x820, 0x820, 0x0, 0x0, 0x821,
0x862, 0x10c5, 0x10c5, 0x10c5, 0x84, 0x147, 0x147, 0x147, 0x1a8,
0x20a, 0x2ad, 0x2ee, 0x2ed, 0x189, 0xa5, 0x842, 0x821, 0x1042,
0x1042, 0x1863, 0x1883, 0x820, 0x2041, 0x7a00, 0x1882, 0x844, 0x25,
0x65, 0x10a9, 0x20ca, 0x18eb, 0x869, 0x392b, 0x414a, 0x51ac, 0x392b,
0x392c, 0x394c, 0x392c, 0x20cb, 0x18ee, 0x2174, 0x131, 0x153, 0x153,
0x155, 0x176, 0x155, 0x154, 0x176, 0x9b8, 0x2afd, 0x32fe, 0x2add,
0x22bc, 0x229c, 0x227b, 0x227c, 0x229c, 0x22bd, 0x331e, 0x32fe, 0x3b3e,
0x2add, 0x2ade, 0x229d, 0x2abd, 0x229d, 0x227d, 0x227d, 0x227c, 0x1a5c,
0x1a3b, 0x1a3b, 0x11fa, 0x9d9, 0x197, 0x196, 0x1b7, 0x197, 0x995,
0x2174, 0x3992, 0x3971, 0x290e, 0x314f, 0x314f, 0x292f, 0x292f, 0x294f,
0x3171, 0x174, 0x9d6, 0x175, 0x155, 0x954, 0x954, 0x974, 0x954,
0x1154, 0x1994, 0x913, 0x2194, 0x1113, 0x2154, 0x1913, 0x1933, 0x1111,
0x2173, 0x2972, 0x2931, 0x3131, 0x3151, 0x3150, 0x3950, 0x310f, 0x394f,
0x394f, 0x416f, 0x49af, 0x414e, 0x416f, 0x416e, 0x416e, 0x392d, 0x414e,
0x414e, 0x414e, 0x414e, 0x414d, 0x414d, 0x412d, 0x494e, 0x494d, 0x412c,
0x414d, 0x392c, 0x412d, 0x49cf, 0x390c, 0x38ec, 0x390d, 0x390d, 0x390d,
0x390d, 0x412e, 0x392d, 0x414e, 0x820, 0x1041, 0x1042, 0x821, 0x821,
0x1062, 0x801, 0x0, 0x820, 0x1062, 0x0, 0x862, 0x1083, 0x1106,
0x8e5, 0x63, 0xe5, 0x968, 0x106, 0x147, 0x1ea, 0x24b, 0x30f,
0x350, 0x2ac, 0x169, 0x63, 0x862, 0x1083, 0x1042, 0x842, 0x1062,
0x821, 0x840, 0x5964, 0x30c0, 0x1042, 0x865, 0x65, 0x65, 0x18ea,
0x10a9, 0x18aa, 0x18ea, 0x49ed, 0x51cd, 0x49ad, 0x416c, 0x416c, 0x394c,
0x314d, 0x210d, 0x2151, 0x19b4, 0x131, 0x153, 0x133, 0x196, 0x176,
0x176, 0x176, 0x197, 0x121a, 0x2abc, 0x2afd, 0x32fe, 0x229c, 0x1a7c,
0x227c, 0x229c, 0x229c, 0x22bd, 0x331e, 0x2abd, 0x437f, 0x2abd, 0x2abe,
0x229d, 0x229d, 0x229d, 0x1a5c, 0x227c, 0x227c, 0x1a3b, 0x1a5c, 0x121b,
0x123b, 0x9d9, 0x9d9, 0x1b8, 0x1d8, 0x1b7, 0x11f7, 0x29b4, 0x3992,
0x3970, 0x3990, 0x314f, 0x3970, 0x3170, 0x3170, 0x2930, 0x2951, 0x1195,
0x195, 0x155, 0x155, 0x174, 0x154, 0x174, 0x954, 0x1154, 0x1974,
0x1994, 0x933, 0x1174, 0x1153, 0x953, 0x933, 0x2174, 0x2132, 0x3152,
0x39b3, 0x3171, 0x3150, 0x4191, 0x4170, 0x4170, 0x4990, 0x496f, 0x414e,
0x414e, 0x496e, 0x412d, 0x414e, 0x414d, 0x414e, 0x496e, 0x496f, 0x414e,
0x498f, 0x392d, 0x410d, 0x412d, 0x414e, 0x412d, 0x412e, 0x416e, 0x414d,
0x412e, 0x392e, 0x310c, 0x394e, 0x390d, 0x30ed, 0x312e, 0x312e, 0x30ed,
0x310d, 0x310d, 0x841, 0x821, 0x820, 0x821, 0x821, 0x801, 0x801,
0x821, 0x1021, 0x0, 0x842, 0x2106, 0x862, 0x63, 0xa3, 0x8c5,
0x906, 0x106, 0x126, 0x167, 0x1a9, 0xb0e, 0x30f, 0x330, 0x32e,
0x189, 0x84, 0x1063, 0x1063, 0x1063, 0x1042, 0x1042, 0x20, 0x1061,
0x8047, 0x2083, 0x1063, 0x865, 0x65, 0x45, 0x210a, 0x1089, 0x18cb,
0x18cb, 0x18a9, 0x310a, 0x310b, 0x414d, 0x414d, 0x418e, 0x396e, 0x294e,
0x29f5, 0x131, 0x111, 0x133, 0x175, 0x176, 0x1b7, 0x197, 0x1b8,
0x9d8, 0x1219, 0x229c, 0x2add, 0x331e, 0x2add, 0x331e, 0x2add, 0x2abd,
0x1a5b, 0x229c, 0x229d, 0x2abd, 0x331e, 0x2ade, 0x2abe, 0x1a5c, 0x1a3c,
0x227c, 0x1a5c, 0x227d, 0x227c, 0x1a5c, 0x1a5b, 0x1a3b, 0x9fa, 0x9f9,
0x9d9, 0x9f9, 0x197, 0x1b7, 0x1195, 0x2152, 0x3191, 0x41b1, 0x3970,
0x292f, 0x2930, 0x2930, 0x3171, 0x2931, 0x2173, 0x1995, 0x954, 0x175,
0x175, 0x975, 0x19b5, 0x1974, 0x2174, 0x21b5, 0x1974, 0x2174, 0x913,
0x974, 0x1194, 0x974, 0x1194, 0x1933, 0x2152, 0x3172, 0x3151, 0x3150,
0x312f, 0x49d2, 0x4970, 0x59f1, 0x496f, 0x496f, 0x496f, 0x498f, 0x51af,
0x496e, 0x51ae, 0x498e, 0x414e, 0x496f, 0x496e, 0x414e, 0x496f, 0x496e,
0x414e, 0x414e, 0x412e, 0x412e, 0x412e, 0x414e, 0x394e, 0x390d, 0x392d,
0x310d, 0x312d, 0x312e, 0x28ed, 0x28cd, 0x28cd, 0x30ed, 0x30ed, 0x310d,
0x841, 0x821, 0x841, 0x20, 0x821, 0x0, 0x821, 0x0, 0x0,
0x21, 0x862, 0x884, 0x22, 0x8a4, 0x8a4, 0x126, 0x106, 0xe5,
0xe5, 0x20a, 0x26b, 0x30e, 0x350, 0x350, 0x34f, 0x128, 0x84,
0x1083, 0x842, 0x822, 0x1883, 0x1082, 0x20, 0x1041, 0xdd5c, 0x1863,
0x1884, 0x865, 0x45, 0x26, 0x20ea, 0x18ca, 0xa9, 0x10eb, 0x18eb,
0x290b, 0x310b, 0x396d, 0x394e, 0x392d, 0x394e, 0x2150, 0x19b3, 0x131,
0x132, 0x154, 0x196, 0x1d7, 0x1d7, 0x1d8, 0xa19, 0xa18, 0x123a,
0x1a7b, 0x32fd, 0x32fd, 0x3b5e, 0x437f, 0x2afd, 0x229c, 0x1a5b, 0x123b,
0x1a7c, 0x229d, 0x32fe, 0x32fe, 0x229d, 0x1a5c, 0x227d, 0x2a9d, 0x229d,
0x1a7c, 0x227d, 0x227c, 0x1a3b, 0x123b, 0x11fa, 0x9f9, 0x9f9, 0x9d9,
0x9d8, 0x197, 0x21f7, 0x2194, 0x3991, 0x3970, 0x3970, 0x3971, 0x3172,
0x2951, 0x2131, 0x1973, 0x974, 0x19d6, 0x19b6, 0x174, 0x11b5, 0x1154,
0x1974, 0x2174, 0x2174, 0x2194, 0x2995, 0x2194, 0x1974, 0x1195, 0x934,
0x974, 0x1194, 0x1133, 0x31b4, 0x39b2, 0x3151, 0x3971, 0x49d2, 0x49b1,
0x498f, 0x51d0, 0x51af, 0x59b0, 0x51b0, 0x59d0, 0x518e, 0x518e, 0x51af,
0x496e, 0x518f, 0x51af, 0x496e, 0x414e, 0x498f, 0x414e, 0x496f, 0x496f,
0x414e, 0x392e, 0x412f, 0x392e, 0x412e, 0x414e, 0x392e, 0x310d, 0x396f,
0x290e, 0x290e, 0x310e, 0x312e, 0x28cd, 0x392e, 0x30ed, 0x821, 0x821,
0x1062, 0x821, 0x841, 0x0, 0x821, 0x821, 0x21, 0x822, 0x863,
0x1906, 0x10e5, 0x63, 0x8c6, 0xe6, 0xe6, 0x105, 0x127, 0x1aa,
0x2ce, 0x2ce, 0x371, 0x32f, 0x3d1, 0xe9, 0xa5, 0x864, 0x863,
0x1062, 0x1883, 0x1063, 0x40, 0x1042, 0xfef6, 0x1882, 0x1084, 0x865,
0x865, 0x46, 0x292c, 0x10ca, 0x8cb, 0x8eb, 0x18ea, 0x312b, 0x312b,
0x394e, 0x398f, 0x41b1, 0x3970, 0x2171, 0x110, 0x951, 0x132, 0x154,
0x196, 0x1b7, 0x1d8, 0xa18, 0xa19, 0x218, 0x1219, 0x22bc, 0x331e,
0x3b5e, 0x3b5e, 0x3b3e, 0x229c, 0x1a5b, 0x121a, 0x121a, 0x123b, 0x229d,
0x2abd, 0x2add, 0x229d, 0x2abd, 0x2abd, 0x227c, 0x229d, 0x227c, 0x229d,
0x227c, 0x1a5b, 0x121a, 0x121a, 0x121a, 0x9f9, 0x9f9, 0x1d8, 0x1d7,
0x11b5, 0x2173, 0x3992, 0x3991, 0x3971, 0x3192, 0x2992, 0x2993, 0x1993,
0x2237, 0x174, 0x975, 0x974, 0x954, 0x974, 0x1995, 0x1995, 0x1994,
0x1973, 0x29b4, 0x2153, 0x2153, 0x1954, 0x933, 0x132, 0x973, 0x912,
0x1954, 0x2153, 0x3172, 0x3171, 0x3971, 0x4170, 0x4990, 0x4990, 0x51d1,
0x59d0, 0x59b0, 0x516f, 0x518e, 0x59ae, 0x518d, 0x51ae, 0x496d, 0x494d,
0x496e, 0x496e, 0x498f, 0x498f, 0x496f, 0x496f, 0x496f, 0x414e, 0x394e,
0x416f, 0x414f, 0x390e, 0x416f, 0x392e, 0x312e, 0x394f, 0x312f, 0x290e,
0x392e, 0x310e, 0x310d, 0x390d, 0x416f, 0x821, 0x821, 0x841, 0x821,
0x820, 0x840, 0x821, 0x820, 0x1083, 0x18e5, 0x63, 0x863, 0x843,
0x883, 0xe6, 0x106, 0xc5, 0x107, 0x189, 0x24d, 0x2ef, 0x30f,
0x330, 0x473, 0xc54, 0x108, 0x8c6, 0x884, 0x1063, 0x10a4, 0x10a4,
0x841, 0x841, 0x1025, 0xf630, 0x1883, 0x1064, 0x866, 0x865, 0x210a,
0x292b, 0x18ca, 0x10cb, 0x110c, 0x290b, 0x312c, 0x312c, 0x396f, 0x2970,
0x39d2, 0x2991, 0x29b3, 0x1152, 0x911, 0x132, 0x154, 0x196, 0x1b7,
0x1d8, 0x1f8, 0x1d7, 0x1f9, 0x1239, 0x229c, 0x3b3e, 0x3b5e, 0x333e,
0x331e, 0x1a5b, 0x1a5b, 0x123a, 0x121a, 0x1a7b, 0x32fd, 0x32fe, 0x2ade,
0x32fe, 0x2abd, 0x2abd, 0x2abd, 0x229d, 0x227d, 0x227c, 0x229d, 0x1a3b,
0x1a3b, 0x1a3b, 0x9f9, 0x9d9, 0x9d9, 0x9d8, 0x1d7, 0x21b5, 0x2993,
0x3993, 0x3992, 0x39b3, 0x3193, 0x2193, 0x29d5, 0x974, 0x995, 0x195,
0x995, 0x975, 0x1195, 0x1996, 0x21b6, 0x2175, 0x29b5, 0x2995, 0x2994,
0x2973, 0x2973, 0x2193, 0x1973, 0x1993, 0x1153, 0x1933, 0x1974, 0x2132,
0x2952, 0x39d3, 0x3991, 0x4191, 0x4170, 0x49b0, 0x51b0, 0x51b0, 0x51d0,
0x59b0, 0x59cf, 0x59cf, 0x61ef, 0x51ce, 0x518d, 0x59ce, 0x518e, 0x498f,
0x498f, 0x496e, 0x414f, 0x498f, 0x414f, 0x414f, 0x392e, 0x414f, 0x414f,
0x412f, 0x390e, 0x392f, 0x392f, 0x290e, 0x290e, 0x314f, 0x312f, 0x312e,
0x30ed, 0x392e, 0x30cc, 0x821, 0x800, 0x821, 0x18a2, 0x0, 0x0,
0x840, 0x820, 0x842, 0x1, 0x22, 0x1064, 0x863, 0xa5, 0x107,
0x927, 0x927, 0x128, 0x1ec, 0x2af, 0x2af, 0x351, 0x310, 0xcb5,
0x412, 0x109, 0x85, 0x84, 0x883, 0x883, 0x1083, 0x40, 0x881,
0x1028, 0xb3e8, 0x1082, 0x5224, 0x66, 0x46, 0x290a, 0x290b, 0x18ca,
0x10cb, 0x18ec, 0x18cb, 0x290c, 0x314d, 0x312f, 0x292f, 0x3171, 0x31d3,
0x2992, 0x110, 0x152, 0x153, 0x154, 0x196, 0x1b6, 0x1d7, 0x9f7,
0x1b6, 0x1f7, 0x125a, 0x2abc, 0x333e, 0x331e, 0x331e, 0x331d, 0x1a7b,
0x229c, 0x1a7b, 0x123a, 0x1a5b, 0x32fe, 0x2add, 0x32fe, 0x2abd, 0x227c,
0x2ade, 0x2abd, 0x229d, 0x229d, 0x227c, 0x1a5b, 0x121b, 0x123b, 0x121a,
0x121a, 0x9d9, 0x9d9, 0x9d8, 0x9d6, 0x29d5, 0x3193, 0x2952, 0x3192,
0x2952, 0x2993, 0x2152, 0x2173, 0x995, 0x11d6, 0x975, 0x995, 0x1155,
0x1174, 0x21b6, 0x2175, 0x2195, 0x2174, 0x2994, 0x3194, 0x2993, 0x29b3,
0x2972, 0x2152, 0x3193, 0x2993, 0x2152, 0x1933, 0x2173, 0x2972, 0x3172,
0x4192, 0x4171, 0x4991, 0x51b1, 0x4991, 0x51b1, 0x51b0, 0x59f1, 0x59cf,
0x59ae, 0x59ce, 0x59ae, 0x59ae, 0x59af, 0x59af, 0x492d, 0x59b0, 0x494e,
0x414e, 0x4990, 0x494f, 0x496f, 0x414e, 0x390e, 0x414f, 0x392e, 0x310e,
0x414f, 0x310e, 0x312f, 0x290f, 0x290f, 0x28ee, 0x30ed, 0x312e, 0x312e,
0x310e, 0x0, 0x1081, 0x840, 0x0, 0x0, 0x821, 0x821, 0x841,
0x842, 0x10c4, 0x42, 0x10a3, 0x83, 0xa5, 0xe6, 0xe6, 0xa5,
0x18a, 0x26e, 0x2af, 0x2cf, 0x310, 0x3b3, 0x1496, 0x372, 0x109,
0xa5, 0xa4, 0x84, 0x8e5, 0x1105, 0x81, 0x8c2, 0x831, 0x61cb,
0x10a3, 0xd7de, 0x87, 0x66, 0x290a, 0x290b, 0x18ea, 0x190c, 0x190d,
0x212d, 0x292d, 0x312e, 0x314f, 0x292f, 0x2950, 0x2171, 0x2192, 0x1951,
0x1952, 0x173, 0x174, 0x196, 0x1d7, 0x1b6, 0x1b5, 0x195, 0x1d6,
0x1239, 0x1a7b, 0x331d, 0x32fd, 0x3b5f, 0x227b, 0x229c, 0x227b, 0x2abc,
0x227b, 0x229c, 0x2abd, 0x2abd, 0x229d, 0x227c, 0x1a5c, 0x2add, 0x2abd,
0x229d, 0x227c, 0x227c, 0x227c, 0x1a5b, 0x121a, 0x121a, 0x9f9, 0x9f9,
0x9f9, 0x11d7, 0x29b6, 0x2993, 0x3193, 0x3193, 0x31b4, 0x31d4, 0x29b4,
0x2154, 0x1974, 0x11b5, 0x19b6, 0x1996, 0x1975, 0x1174, 0x1995, 0x21b5,
0x2195, 0x1974, 0x1953, 0x29b5, 0x39b5, 0x39b4, 0x39b3, 0x3193, 0x3193,
0x3173, 0x39d4, 0x2973, 0x2973, 0x2173, 0x2993, 0x2931, 0x3172, 0x3151,
0x3992, 0x49b2, 0x4971, 0x414f, 0x4970, 0x51b0, 0x51ae, 0x59cf, 0x59cf,
0x518e, 0x59af, 0x59af, 0x59af, 0x59d0, 0x516e, 0x59f0, 0x51af, 0x5190,
0x412e, 0x496f, 0x498f, 0x494e, 0x496e, 0x414e, 0x416f, 0x392f, 0x392f,
0x310f, 0x290f, 0x28ee, 0x28ee, 0x394f, 0x394f, 0x310e, 0x390e, 0x821,
0x800, 0x0, 0x821, 0x0, 0x20, 0x862, 0x1, 0x22, 0x22,
0x884, 0x842, 0xa7, 0x168, 0xe6, 0xe6, 0x128, 0x18a, 0x26e,
0x2af, 0x310, 0x2af, 0x1476, 0x3558, 0x24f, 0x108, 0x106, 0xe5,
0xe5, 0x125, 0x145, 0x164, 0xe3, 0x1019, 0x38ec, 0x10c4, 0x8a6,
0xa6, 0x66, 0x312b, 0x314b, 0x210b, 0x10ec, 0x190d, 0x294e, 0x292e,
0x292e, 0x3190, 0x2990, 0x214f, 0x2970, 0x2151, 0x2172, 0x1192, 0x153,
0x194, 0x1b6, 0x1d7, 0x9f6, 0x19d6, 0x974, 0x9d6, 0xa18, 0x125a,
0x32fd, 0x3b3e, 0x3b3e, 0x331e, 0x32fd, 0x2add, 0x2add, 0x2add, 0x227c,
0x32fe, 0x2abd, 0x227c, 0x22bd, 0x2ade, 0x2abd, 0x32fe, 0x227c, 0x229c,
0x2abd, 0x1a7c, 0x1a5b, 0x1a5a, 0x123a, 0x9f9, 0x9f9, 0xa19, 0x21f6,
0x31b5, 0x3193, 0x39d4, 0x2993, 0x2993, 0x29b3, 0x2194, 0x21b5, 0x1995,
0x19b6, 0x954, 0x1175, 0x1996, 0x1175, 0x954, 0x1195, 0x11b5, 0x995,
0x21b5, 0x29b4, 0x31b4, 0x39d4, 0x3993, 0x3993, 0x3173, 0x2953, 0x3193,
0x2973, 0x2993, 0x2993, 0x31b3, 0x39b3, 0x3993, 0x3993, 0x3152, 0x49b2,
0x4170, 0x4991, 0x51b1, 0x51b0, 0x51b0, 0x59f0, 0x51cf, 0x59af, 0x59af,
0x59af, 0x59af, 0x6210, 0x518e, 0x494e, 0x516e, 0x496e, 0x494e, 0x498f,
0x494f, 0x496f, 0x496f, 0x392e, 0x414f, 0x414f, 0x392f, 0x392f, 0x3130,
0x290f, 0x290f, 0x312f, 0x290e, 0x312f, 0x310e, 0x800, 0x0, 0x0,
0x0, 0x1082, 0x841, 0x863, 0x2147, 0x10c4, 0x822, 0x62, 0x8e5,
0xe6, 0x169, 0xe6, 0xa5, 0x16a, 0x22e, 0x26f, 0x311, 0x2d0,
0x2f1, 0x2458, 0x3d59, 0x270, 0x5739, 0x55be, 0x45da, 0x4ddc, 0x4cfd,
0x64fe, 0xe7ff, 0x38d, 0x2899, 0x18c7, 0x818, 0x26b, 0x86, 0x87,
0x312b, 0x316c, 0x18ca, 0x10ec, 0x190e, 0x294f, 0x292e, 0x314f, 0x3150,
0x3150, 0x292f, 0x294f, 0x2992, 0x2151, 0x1131, 0x112, 0x174, 0x1d6,
0x1d6, 0x9d6, 0x29f6, 0x21d5, 0x11d6, 0x9f8, 0x123a, 0x331d, 0x331e,
0x3b5e, 0x3b5f, 0x3b5e, 0x331e, 0x32fd, 0x22bc, 0x2add, 0x32fd, 0x2abd,
0x1a5b, 0x2abd, 0x2abd, 0x2ade, 0x2ade, 0x229d, 0x229c, 0x22bc, 0x227b,
0x1a7b, 0x1a5a, 0x1a5a, 0x1219, 0x9f9, 0x9f7, 0x31f6, 0x31d4, 0x3193,
0x3173, 0x31b3, 0x31b4, 0x31b4, 0x2994, 0x29f6, 0x19b6, 0x19f6, 0x29f7,
0x19b5, 0x21d6, 0x21b5, 0x19b6, 0x175, 0x195, 0x175, 0x995, 0x31f5,
0x39b3, 0x49f5, 0x41f4, 0x39b3, 0x3993, 0x3173, 0x2993, 0x31d4, 0x2152,
0x3194, 0x3173, 0x3173, 0x3193, 0x3172, 0x3972, 0x49b3, 0x49b2, 0x4971,
0x4970, 0x496f, 0x51b0, 0x518f, 0x59d0, 0x51af, 0x59d0, 0x518f, 0x59af,
0x59d0, 0x516e, 0x518f, 0x59b0, 0x518f, 0x59d0, 0x518f, 0x51b0, 0x51b0,
0x496f, 0x51b0, 0x416f, 0x414f, 0x4170, 0x392e, 0x3930, 0x3930, 0x4191,
0x28ee, 0x312f, 0x312f, 0x312f, 0x821, 0x0, 0x20, 0x800, 0x821,
0x20c4, 0x1083, 0x883, 0x63, 0x843, 0x843, 0x907, 0x148, 0x127,
0xc6, 0xe7, 0x18b, 0xab0, 0x2d2, 0x353, 0x311, 0x355, 0x2c9a,
0x4d1b, 0xdb, 0x6ddc, 0x75bf, 0x19dd, 0x11bd, 0x8e3f, 0xb7be, 0xdfff,
0xcffd, 0xad, 0x105, 0xc5, 0x65, 0x86, 0x10c8, 0x314b, 0x314c,
0x20eb, 0x20ec, 0x294f, 0x294e, 0x316f, 0x3170, 0x292f, 0x3190, 0x314f,
0x2950, 0x31b2, 0x2171, 0x8ef, 0x111, 0x194, 0x1f7, 0x217, 0x2216,
0x21f6, 0x21d5, 0x19f7, 0x1d7, 0x125a, 0x333d, 0x3b3e, 0x3b5e, 0x43bf,
0x4bdf, 0x3b5e, 0x333e, 0x2adc, 0x2add, 0x22bc, 0x2add, 0x2abd, 0x225c,
0x229d, 0x2ade, 0x32fe, 0x2abd, 0x2add, 0x2abc, 0x229c, 0x1a7b, 0x1a5a,
0x123a, 0x1239, 0xa18, 0x9f7, 0x31d6, 0x31b4, 0x39b3, 0x3993, 0x3193,
0x31b4, 0x29b4, 0x2174, 0x21d6, 0x19d6, 0x19d6, 0x21d6, 0x21b6, 0x1974,
0x29b5, 0x1975, 0x975, 0x155, 0x175, 0x954, 0x2994, 0x41d4, 0x41d4,
0x41f4, 0x4a15, 0x3172, 0x41f4, 0x39b4, 0x3193, 0x3193, 0x2132, 0x3193,
0x39b4, 0x3173, 0x41d4, 0x3993, 0x3991, 0x49b2, 0x4171, 0x4970, 0x4990,
0x4990, 0x59b0, 0x5190, 0x59d1, 0x59d1, 0x59d0, 0x59b0, 0x59af, 0x518f,
0x59b0, 0x51b0, 0x518f, 0x494e, 0x51b0, 0x498f, 0x496f, 0x518f, 0x498f,
0x496f, 0x392e, 0x414f, 0x414f, 0x394f, 0x392f, 0x312f, 0x314f, 0x20ce,
0x314f, 0x290e, 0x0, 0x0, 0x820, 0x800, 0x1062, 0x863, 0x843,
0x883, 0x42, 0x42, 0x44, 0xc6, 0xe6, 0xc7, 0x86, 0x22c,
0x18c, 0x271, 0x2f3, 0x2b2, 0x2d3, 0x2f3, 0x1bf8, 0x337d, 0xc6bf,
0xdfdf, 0xcfbf, 0xbebf, 0xc6ff, 0xd7df, 0xdfbf, 0xaf5f, 0xa79d, 0x287,
0x14d, 0xed, 0x87, 0x87, 0x212b, 0x316c, 0x312b, 0x314c, 0x294d,
0x294f, 0x314e, 0x312e, 0x314f, 0x3170, 0x3170, 0x294f, 0x2970, 0x2971,
0x2991, 0x18ed, 0x150, 0x1d6, 0xa17, 0x217, 0x21f6, 0x21f6, 0x21d6,
0x2a38, 0x1d7, 0x1a9b, 0x331d, 0x3b3e, 0x331e, 0x43bf, 0x43bf, 0x3b5e,
0x331e, 0x2adc, 0x22bc, 0x229c, 0x2abd, 0x2ade, 0x229c, 0x1a5c, 0x229d,
0x229c, 0x229c, 0x229c, 0x2add, 0x22bc, 0x227b, 0x1a7b, 0x1a7b, 0x125a,
0xa19, 0x9f7, 0x29d5, 0x31b4, 0x39d3, 0x39f4, 0x39d4, 0x31d5, 0x2a16,
0x21f6, 0x11d5, 0x954, 0x2217, 0x21d6, 0x19b6, 0x19b5, 0x1175, 0x11b6,
0x155, 0x156, 0x156, 0x155, 0x174, 0x31b5, 0x49f5, 0x41b4, 0x41b4,
0x41d3, 0x2972, 0x2973, 0x2973, 0x31b4, 0x2973, 0x2153, 0x2993, 0x2972,
0x3173, 0x3972, 0x3972, 0x4192, 0x4191, 0x4171, 0x49d1, 0x4990, 0x59f2,
0x51b0, 0x4990, 0x5190, 0x5191, 0x4990, 0x5190, 0x51b0, 0x51af, 0x518f,
0x496f, 0x518f, 0x518f, 0x5190, 0x5190, 0x516f, 0x496f, 0x5190, 0x496f,
0x498f, 0x412e, 0x390e, 0x38ee, 0x392f, 0x3970, 0x3150, 0x312f, 0x290e,
0x0, 0x800, 0x1041, 0x800, 0x821, 0x18a7, 0x843, 0x1083, 0x42,
0x10c5, 0xe7, 0x127, 0xc5, 0x108, 0x109, 0xe8, 0x250, 0x271,
0x313, 0x2b2, 0x314, 0x2b2, 0xb57, 0x2ade, 0xc6df, 0xd79f, 0xcf5f,
0x195d, 0x29dc, 0xcfbf, 0xcfdf, 0xc79f, 0xcfff, 0x908, 0x130, 0x10f,
0x16e, 0x14c, 0x1ad, 0x314b, 0x290b, 0x316e, 0x212d, 0x292e, 0x316f,
0x290d, 0x314f, 0x294f, 0x3170, 0x3190, 0x2950, 0x2992, 0x3191, 0x210d,
0x172, 0x1d6, 0xa58, 0xa38, 0x2a37, 0x21d5, 0x2216, 0x2217, 0xa17,
0x22bb, 0x331d, 0x333e, 0x3b7f, 0x437e, 0x437e, 0x3b7f, 0x3b3e, 0x2afd,
0x22bc, 0x22bd, 0x227c, 0x227c, 0x1a5c, 0x1a3b, 0x227c, 0x229c, 0x1a7c,
0x22bc, 0x227c, 0x229c, 0x1a7b, 0x1a7b, 0x1a5a, 0x123a, 0x1218, 0x1a17,
0x29d5, 0x31f5, 0x39d5, 0x31d5, 0x39d5, 0x31d6, 0x19d5, 0x11b5, 0x11b6,
0x19d6, 0x11b6, 0x1975, 0x21d6, 0x21d6, 0x21d6, 0x11b6, 0x196, 0x176,
0x156, 0x156, 0x175, 0x19b6, 0x31b5, 0x39d5, 0x39b4, 0x39b4, 0x31b4,
0x2994, 0x31d5, 0x2194, 0x1953, 0x2173, 0x2953, 0x2973, 0x3193, 0x3972,
0x41b4, 0x4192, 0x4192, 0x4192, 0x4992, 0x41b1, 0x4170, 0x4991, 0x4991,
0x49b1, 0x4170, 0x4170, 0x4991, 0x4950, 0x4990, 0x4970, 0x51b0, 0x5190,
0x59d1, 0x59b0, 0x5190, 0x494e, 0x5190, 0x518f, 0x494e, 0x494f, 0x498f,
0x412f, 0x412f, 0x38ee, 0x392e, 0x310e, 0x3950, 0x312f, 0x0, 0x0,
0x821, 0x821, 0x18a5, 0x8e8, 0x43, 0x1083, 0x42, 0xa6, 0xc6,
0xa5, 0xe6, 0xc6, 0x18b, 0x14b, 0x271, 0x270, 0x2f3, 0x291,
0x250, 0x2d3, 0xb16, 0x4c5f, 0x111f, 0x3afb, 0xaf9f, 0x97df, 0x8f9e,
0x86dc, 0x86bd, 0x771b, 0xbffc, 0x30a8, 0xd4, 0xef, 0x191, 0x12b,
0xeb, 0x292d, 0x292d, 0x316e, 0x296e, 0x294e, 0x318f, 0x316e, 0x31b0,
0x314f, 0x314f, 0x3170, 0x3171, 0x3172, 0x3992, 0x210c, 0x173, 0x217,
0xa58, 0x19f7, 0x21f6, 0x2a16, 0x2a57, 0x1a37, 0x1238, 0x1abb, 0x333e,
0x3b5e, 0x3b5e, 0x3b7e, 0x439f, 0x3b7f, 0x331e, 0x32fd, 0x22bc, 0x229c,
0x1a5b, 0x1a5b, 0x9d9, 0x11fa, 0x227c, 0x229c, 0x1a7b, 0x227b, 0x22bc,
0x1a5b, 0x1a5b, 0x1a5b, 0x123a, 0x123a, 0x9f8, 0x21f6, 0x21d6, 0x21b5,
0x31f6, 0x29b5, 0x31d5, 0x3216, 0x19d6, 0x11b6, 0x19b6, 0x1996, 0x21b6,
0x21b5, 0x2195, 0x21b6, 0x19d6, 0x975, 0x196, 0x156, 0x176, 0x175,
0x155, 0x134, 0x2175, 0x2994, 0x2973, 0x31d5, 0x2994, 0x29b4, 0x1953,
0x2194, 0x29b5, 0x2173, 0x2153, 0x2953, 0x2132, 0x3173, 0x3152, 0x3972,
0x3993, 0x3152, 0x4193, 0x3951, 0x3950, 0x4171, 0x4151, 0x4191, 0x3951,
0x3971, 0x4171, 0x3930, 0x4150, 0x49b1, 0x4990, 0x51b1, 0x5190, 0x5190,
0x518f, 0x516f, 0x494f, 0x496f, 0x51b0, 0x498f, 0x498f, 0x392e, 0x414f,
0x30cd, 0x390e, 0x392f, 0x310e, 0x396f, 0x0, 0x800, 0x821, 0x842,
0x22, 0x9aa, 0x43, 0x843, 0x863, 0xc7, 0xe7, 0xa5, 0xe5,
0xe8, 0x109, 0x230, 0x270, 0x2d3, 0x2d2, 0x2b2, 0x2b0, 0x334,
0x2c1a, 0x54ff, 0x217e, 0x4bff, 0x86de, 0x2ade, 0x10c, 0xed, 0x12d,
0x14c, 0x10e, 0x5926, 0x91, 0xb2, 0x110, 0xac, 0x114f, 0x2130,
0x2130, 0x2990, 0x3190, 0x318f, 0x316e, 0x316e, 0x294f, 0x3170, 0x3970,
0x3170, 0x3191, 0x3171, 0x3151, 0x212d, 0x9f4, 0x238, 0x22da, 0x2a57,
0x3257, 0x3216, 0x2257, 0x1258, 0x127a, 0x2adc, 0x331d, 0x3b5e, 0x3b3e,
0x43bf, 0x439f, 0x4bbf, 0x3b3e, 0x2afd, 0x1a7b, 0x125a, 0x125a, 0x1239,
0x1d8, 0x9f9, 0x229c, 0x2abd, 0x1a7b, 0x229c, 0x229c, 0x1a5b, 0x1a3a,
0x123a, 0x123a, 0xa18, 0x1238, 0x2217, 0x21d6, 0x21f7, 0x29d6, 0x31f6,
0x31d5, 0x31f6, 0x19d6, 0x11d6, 0x9b6, 0x19d6, 0x19d6, 0x2195, 0x21b6,
0x21d6, 0x2a37, 0x1b5, 0x195, 0x176, 0x176, 0x176, 0x156, 0x155,
0x1175, 0x2174, 0x2994, 0x2194, 0x2174, 0x2194, 0x1953, 0x1953, 0x2153,
0x2153, 0x2994, 0x1932, 0x2973, 0x2953, 0x2953, 0x2973, 0x2932, 0x3172,
0x3172, 0x3952, 0x4193, 0x41b2, 0x3951, 0x3992, 0x3951, 0x3971, 0x3971,
0x3130, 0x4171, 0x4971, 0x4991, 0x4991, 0x5191, 0x5170, 0x496f, 0x494f,
0x496f, 0x5190, 0x498f, 0x414e, 0x49b0, 0x414f, 0x414f, 0x416f, 0x392f,
0x390e, 0x392e, 0x394f, 0x821, 0x821, 0x800, 0x18e6, 0x844, 0x43,
0x884, 0x843, 0x44, 0xe7, 0xe7, 0xa5, 0xc5, 0x18b, 0x16c,
0x250, 0x251, 0x2f4, 0x291, 0x2f2, 0x270, 0x2f2, 0x343a, 0x4cde,
0xcedf, 0xefff, 0xf7fe, 0xd7bf, 0xcf9f, 0xdfff, 0xdfdf, 0xe7ff, 0xe7bf,
0xcebe, 0xa5dd, 0x427c, 0x111a, 0x8d9, 0x111a, 0x10b8, 0x111b, 0x191f,
0x2951, 0x3170, 0x316e, 0x318f, 0x3170, 0x3970, 0x3990, 0x3170, 0x3991,
0x3191, 0x2991, 0x110d, 0x1f5, 0x1258, 0x2ab9, 0x2a57, 0x3216, 0x2a16,
0x2278, 0x1279, 0x1abb, 0x333d, 0x3b5e, 0x3b5e, 0x3b5e, 0x3b5e, 0x439e,
0x439e, 0x3b5f, 0x2afd, 0x1a9b, 0x1a7b, 0xa19, 0x1f8, 0x1b7, 0x1b7,
0x1a7c, 0x2abd, 0x227c, 0x227c, 0x1a3b, 0x1a5b, 0x1a3b, 0x123b, 0x125a,
0x1a79, 0x1238, 0x29f7, 0x21d6, 0x19d6, 0x21b6, 0x31f6, 0x31f6, 0x21f7,
0x1218, 0x9d6, 0x11b6, 0x11d6, 0x1175, 0x19b6, 0x2a37, 0x19d6, 0x11b6,
0x195, 0x176, 0x196, 0x176, 0x155, 0x156, 0x175, 0x155, 0x1995,
0x21b4, 0x2194, 0x1953, 0x2154, 0x1933, 0x1953, 0x2153, 0x2173, 0x2974,
0x3194, 0x2952, 0x2153, 0x1932, 0x2194, 0x2152, 0x2152, 0x2152, 0x2952,
0x2932, 0x3152, 0x3172, 0x3172, 0x3992, 0x2930, 0x3151, 0x3992, 0x3951,
0x4171, 0x4171, 0x4171, 0x4991, 0x4991, 0x4971, 0x4970, 0x4970, 0x4970,
0x496f, 0x496f, 0x414e, 0x4990, 0x4990, 0x414f, 0x412f, 0x394f, 0x394f,
0x392f, 0x821, 0x1042, 0x821, 0x63, 0x64, 0x63, 0x842, 0x42,
0x84, 0x129, 0xc5, 0xc5, 0xa6, 0x128, 0x1ee, 0x230, 0x2b3,
0x2f3, 0x271, 0x270, 0x290, 0x2d3, 0x44dc, 0x3c1c, 0x96ff, 0xd7bf,
0xdfde, 0x8f3f, 0x7eff, 0x7eff, 0x7f1f, 0x7f3f, 0x7f3f, 0x873f, 0x875f,
0x877f, 0x875f, 0xe7ff, 0xf7ff, 0xefff, 0xe7ff, 0x18ff, 0x2973, 0x3190,
0x316e, 0x296f, 0x316f, 0x39b0, 0x3970, 0x39b1, 0x31b1, 0x31d2, 0x194f,
0x1971, 0x21d4, 0x1ab9, 0x2258, 0x2a37, 0x2a36, 0x3ab9, 0x1258, 0x1a9a,
0x2afc, 0x32fd, 0x3b7e, 0x437f, 0x3b5e, 0x3b7e, 0x439e, 0x333e, 0x3b7e,
0x2afc, 0x125a, 0x123a, 0x1d7, 0x1d6, 0x195, 0x1b7, 0x229c, 0x229c,
0x229c, 0x1a7c, 0x1a7b, 0x1a5b, 0x1a3b, 0x121a, 0x123a, 0x11f7, 0x19f7,
0x2a38, 0x4299, 0x29f6, 0x3216, 0x29b4, 0x3216, 0x19d6, 0x9f7, 0x9f7,
0x1d7, 0x1b6, 0x11b6, 0x196, 0x11b6, 0x19d6, 0x11d7, 0x1b6, 0x196,
0x176, 0x175, 0x176, 0x176, 0x155, 0x175, 0x995, 0x2195, 0x2995,
0x2994, 0x29b5, 0x2974, 0x2194, 0x2174, 0x3a16, 0x2173, 0x2173, 0x2173,
0x1953, 0x1112, 0x1973, 0x1932, 0x1112, 0x1952, 0x2152, 0x2131, 0x2152,
0x2152, 0x2131, 0x2110, 0x2911, 0x3172, 0x3151, 0x2910, 0x3151, 0x3151,
0x3151, 0x3950, 0x4150, 0x4171, 0x3950, 0x4170, 0x4150, 0x4970, 0x4990,
0x498f, 0x414f, 0x414f, 0x414f, 0x390e, 0x394f, 0x394f, 0x394f, 0x21,
0x822, 0x1063, 0x884, 0x864, 0x8a4, 0x43, 0x65, 0x865, 0x127,
0xa6, 0x86, 0xe8, 0xc8, 0x250, 0x24f, 0x2d2, 0x271, 0x2b0,
0x2b0, 0x2b0, 0x313, 0x453b, 0x6dff, 0xb79f, 0xc77f, 0xe7ff, 0xd7ff,
0xe7ff, 0xefff, 0xf7ff, 0xf7ff, 0xefdf, 0xf7ff, 0xf7ff, 0xefff, 0xefbf,
0xffff, 0xffff, 0xf7ff, 0xffff, 0x19bc, 0x119d, 0x119c, 0x978, 0x998,
0x9b6, 0x41d1, 0x41b1, 0x3970, 0x39b2, 0x31b2, 0x194f, 0x1951, 0x31d4,
0x1a58, 0x2ada, 0x2a98, 0x3278, 0x2a58, 0x22ba, 0x1259, 0x2afc, 0x333d,
0x3b7e, 0x43bf, 0x43be, 0x437e, 0x3b7e, 0x335e, 0x2b1d, 0x22db, 0x1279,
0xa38, 0x1d7, 0x195, 0x195, 0x9f8, 0x229c, 0x2add, 0x229c, 0x227c,
0x1a7c, 0x121a, 0x1a7b, 0x123a, 0x123a, 0xa18, 0x2259, 0x21f7, 0x3a37,
0x39f5, 0x39f5, 0x31f6, 0x2216, 0x1a38, 0x9f8, 0x1b7, 0x1b7, 0x1b7,
0x9f7, 0x9d6, 0x11b6, 0x1196, 0x11b6, 0x175, 0x196, 0x156, 0x175,
0x195, 0x195, 0x155, 0x175, 0x9b6, 0x19b5, 0x2194, 0x2994, 0x2994,
0x2994, 0x2174, 0x2174, 0x2154, 0x1953, 0x1932, 0x1933, 0x2174, 0x1932,
0x1932, 0x1952, 0x1952, 0x1993, 0x1952, 0x2152, 0x2972, 0x2111, 0x2972,
0x2131, 0x2952, 0x2931, 0x3172, 0x3172, 0x3151, 0x2931, 0x3151, 0x2910,
0x3150, 0x3971, 0x310f, 0x3930, 0x3950, 0x4150, 0x392f, 0x4991, 0x394e,
0x310e, 0x392e, 0x416f, 0x310d, 0x312e, 0x314e, 0x1082, 0x863, 0x843,
0x8a5, 0x23, 0x843, 0x863, 0x86, 0xe7, 0xa6, 0xa6, 0x109,
0x9ac, 0x1ce, 0x270, 0x24f, 0x2d1, 0x24f, 0x28f, 0x24e, 0x28f,
0xbd4, 0x453b, 0x33fb, 0x765f, 0x765f, 0xe7df, 0xcfdf, 0x963e, 0x7dbc,
0x5c59, 0x753c, 0x6478, 0x95fc, 0xa63d, 0xa63e, 0xa69f, 0xefff, 0xefdf,
0xe7fe, 0xe7bf, 0x3b7d, 0x5d3d, 0x659d, 0x869e, 0xb73f, 0xbf7f, 0x41d1,
0x3990, 0x41b1, 0x41d3, 0x31b2, 0x192e, 0x2191, 0x4235, 0x29f7, 0x2279,
0x2afa, 0x2278, 0x1a99, 0x1a9a, 0x1aba, 0x2afc, 0x3b5e, 0x439f, 0x439e,
0x43bf, 0x3b5d, 0x335d, 0x335e, 0x2b1d, 0x1abb, 0xa59, 0xa18, 0x1d7,
0x1d6, 0x1d7, 0x1a7a, 0x22bc, 0x2abc, 0x229c, 0x227c, 0x227c, 0x1a5b,
0x1a5b, 0x1a5b, 0x123a, 0xa18, 0x2258, 0x2217, 0x4278, 0x4a56, 0x41f5,
0x4216, 0x3259, 0x1d7, 0x1d7, 0x1d7, 0x9f8, 0x1d7, 0x1b7, 0x1d7,
0x9b6, 0x9b6, 0x11f7, 0x196, 0x196, 0x196, 0x1b6, 0x195, 0x175,
0x155, 0x155, 0x9b6, 0x954, 0x21b5, 0x31d5, 0x31b4, 0x2953, 0x29b5,
0x2995, 0x2154, 0x1974, 0x1994, 0x1953, 0x2174, 0x2173, 0x1973, 0x1953,
0x2993, 0x2993, 0x2132, 0x3193, 0x2931, 0x39b3, 0x2972, 0x2111, 0x2931,
0x2952, 0x2931, 0x3152, 0x2931, 0x2910, 0x3131, 0x2930, 0x2930, 0x3951,
0x3971, 0x3110, 0x310f, 0x3150, 0x310f, 0x3930, 0x4170, 0x414f, 0x416f,
0x394f, 0x394e, 0x392e, 0x392e, 0x10a4, 0x843, 0x1084, 0x863, 0x10a4,
0x842, 0x864, 0x85, 0xe7, 0xa6, 0x85, 0x14a, 0xa5, 0x271,
0x250, 0x250, 0x26f, 0x22f, 0x28f, 0x26e, 0x24e, 0x353, 0x4e3b,
0x353, 0x3c9d, 0x1bd9, 0x2cb9, 0x2556, 0x16a, 0x16a, 0x18c, 0x18e,
0x18e, 0x1f0, 0x1b1, 0xa58, 0x121b, 0xdc, 0x10df, 0x109d, 0x10dd,
0x1b7, 0x1b1, 0x1a11, 0x21af, 0x298f, 0x2970, 0x3990, 0x41b0, 0x41b2,
0x41f2, 0x31b1, 0x210d, 0x2992, 0x3a14, 0x3237, 0x2279, 0x2ada, 0x1a99,
0x1ab9, 0x22db, 0x1aba, 0x2afc, 0x3b5d, 0x439e, 0x439e, 0x4bff, 0x437e,
0x335d, 0x333d, 0x2b1c, 0x1aba, 0x1238, 0x1217, 0x1b5, 0x1d7, 0xa19,
0x123a, 0x2abc, 0x2add, 0x2add, 0x229c, 0x227c, 0x1a7b, 0x1a7b, 0x125a,
0x125a, 0x1239, 0x1a18, 0x19f7, 0x3a58, 0x4a56, 0x4a16, 0x4237, 0x2a17,
0x196, 0x1f7, 0x1f8, 0x1d7, 0x1d7, 0x1d7, 0x1b7, 0x196, 0x1b6,
0x175, 0x176, 0x176, 0x196, 0x196, 0x1b6, 0x175, 0x996, 0x975,
0x975, 0x154, 0x1975, 0x2174, 0x2994, 0x2173, 0x2174, 0x2195, 0x2195,
0x1974, 0x2994, 0x2994, 0x2173, 0x2994, 0x2173, 0x2153, 0x2952, 0x3994,
0x3152, 0x3993, 0x3172, 0x3152, 0x2911, 0x2931, 0x3152, 0x3172, 0x2931,
0x3152, 0x2931, 0x2931, 0x2931, 0x3151, 0x3151, 0x3131, 0x3131, 0x3151,
0x3150, 0x3150, 0x310f, 0x3950, 0x390f, 0x3950, 0x396f, 0x394f, 0x394f,
0x390f, 0x392f, 0x1042, 0x863, 0x843, 0x22, 0x1083, 0x23, 0x85,
0xc7, 0x24, 0xa6, 0xa6, 0x1ab, 0xc7, 0x291, 0x271, 0x290,
0x22f, 0x22e, 0x26e, 0x24d, 0x24d, 0x1496, 0x56fa, 0x2d0, 0x54fe,
0x65be, 0x2c5a, 0x6efe, 0x9d7, 0x1f6, 0x1f7, 0x1b6, 0x9d5, 0xa16,
0x9f5, 0x214, 0x234, 0x1f2, 0x191, 0x193, 0x193, 0x1f4, 0x39af,
0x49af, 0x49f0, 0x316e, 0x294e, 0x41b0, 0x4190, 0x41d1, 0x41d2, 0x3190,
0x212e, 0x31d4, 0x3a15, 0x4277, 0x22d9, 0x2afb, 0x1a99, 0x22da, 0x22da,
0x22fb, 0x2b1c, 0x3b7e, 0x43bf, 0x4bdf, 0x4bff, 0x43be, 0x3b5d, 0x2b1c,
0x22fb, 0x2299, 0x2238, 0x1a16, 0x1217, 0x1239, 0x125a, 0x229c, 0x2abc,
0x2afd, 0x2abc, 0x229c, 0x22bc, 0x229b, 0x1a9b, 0x1a7a, 0x1a7b, 0x1a5a,
0x1a38, 0x2a9a, 0x1a18, 0x5257, 0x4a57, 0x4a78, 0x2a17, 0x1a18, 0x9f7,
0xa18, 0x1d7, 0x1d7, 0x1b7, 0x1d7, 0x1d7, 0x195, 0x195, 0x196,
0x196, 0x176, 0x196, 0x196, 0x175, 0x155, 0x175, 0x175, 0x154,
0x954, 0x1974, 0x2995, 0x29b5, 0x2194, 0x1153, 0x1994, 0x1953, 0x1912,
0x31b4, 0x39d4, 0x3173, 0x2973, 0x2952, 0x2111, 0x3993, 0x3973, 0x41b4,
0x3973, 0x3152, 0x3172, 0x2951, 0x3172, 0x3152, 0x3972, 0x3972, 0x3172,
0x3131, 0x3131, 0x3151, 0x3972, 0x3110, 0x3130, 0x3131, 0x290f, 0x3150,
0x3150, 0x3130, 0x3150, 0x3150, 0x312f, 0x314f, 0x314f, 0x312f, 0x30ee,
0x1063, 0x842, 0x42, 0x43, 0x842, 0x885, 0x85, 0xa6, 0x85,
0x85, 0xc8, 0x109, 0x1ed, 0x1ee, 0x20f, 0x290, 0x22e, 0x22d,
0x22c, 0x22c, 0x2cf, 0x454, 0x4eb9, 0x24b5, 0x97de, 0x8fff, 0xdfff,
0x8fbc, 0x3710, 0x370e, 0x370f, 0x3f51, 0x4751, 0x4f54, 0x5755, 0x7f9a,
0xb7dd, 0xffbf, 0x4c1d, 0x20d, 0x298d, 0x318d, 0x49ae, 0x49ce, 0x49ae,
0x314e, 0x296e, 0x41b0, 0x49f1, 0x49f2, 0x41f2, 0x39b0, 0x294f, 0x3a15,
0x39f4, 0x4298, 0x32b8, 0x437c, 0x2a99, 0x2ada, 0x22fa, 0x2b1c, 0x2afc,
0x3b7e, 0x43be, 0x4bde, 0x543f, 0x4bdf, 0x3b5d, 0x333d, 0x2b1c, 0x2299,
0x3237, 0x2a16, 0x9d6, 0x125a, 0x1a5a, 0x229c, 0x2add, 0x2abc, 0x2adc,
0x22bc, 0x229b, 0x1a7b, 0x22bb, 0x1a9b, 0x125a, 0x1239, 0x1239, 0x1a9b,
0xa18, 0x1218, 0x3257, 0x31f7, 0x19f7, 0x1b7, 0x9f8, 0x197, 0x9f8,
0x197, 0x1b7, 0x1d8, 0x196, 0x1b6, 0x996, 0x195, 0x176, 0x196,
0x175, 0x175, 0x175, 0x155, 0x175, 0x155, 0x155, 0x19d6, 0x1174,
0x1994, 0x1994, 0x2194, 0x1933, 0x1974, 0x1953, 0x2994, 0x2973, 0x2973,
0x2973, 0x2952, 0x3173, 0x41b4, 0x3173, 0x3993, 0x3172, 0x3973, 0x3973,
0x3152, 0x3172, 0x3152, 0x3973, 0x3152, 0x2951, 0x3172, 0x3151, 0x3151,
0x3151, 0x3951, 0x3972, 0x3150, 0x3971, 0x3971, 0x3150, 0x3130, 0x290f,
0x290f, 0x2930, 0x3950, 0x312f, 0x314f, 0x312f, 0x312f, 0x823, 0x842,
0x21, 0x862, 0x863, 0x8c6, 0x65, 0x64, 0x84, 0x63, 0x12a,
0xe9, 0x22f, 0x1ee, 0x250, 0x250, 0x20d, 0xaf1, 0x20c, 0x1ca,
0x310, 0x2517, 0x3e57, 0x97de, 0xefff, 0x9fff, 0xe7ff, 0xa7fd, 0x7ff5,
0x7ff4, 0x77f4, 0x77f3, 0x77f3, 0x6ff2, 0x87f7, 0xdfff, 0xe7ff, 0xa7de,
0xa7bf, 0x30f, 0xa4d, 0x41ee, 0x498d, 0x51ef, 0x59ef, 0x316e, 0x398f,
0x49f1, 0x49b0, 0x5212, 0x49f3, 0x3170, 0x2970, 0x4256, 0x3a35, 0x4a77,
0x3a97, 0x3b3a, 0x3b1a, 0x2afa, 0x2afa, 0x2b1c, 0x2b1c, 0x335d, 0x4bde,
0x4bfe, 0x5c5f, 0x4bde, 0x3b7d, 0x333d, 0x22fc, 0x22bb, 0x3217, 0x2a16,
0x1218, 0x22bb, 0x22bc, 0x2add, 0x2adc, 0x333e, 0x2afc, 0x22dc, 0x1a9b,
0x1a7a, 0x125a, 0x1239, 0x125a, 0x1239, 0xa19, 0x1239, 0x1239, 0x1259,
0xa18, 0x9b6, 0x1218, 0x1d8, 0x1d8, 0x1b8, 0x9d8, 0x1b8, 0x1b7,
0x1b8, 0x9f8, 0x1d7, 0x1b6, 0x996, 0x196, 0x196, 0x196, 0x196,
0x996, 0x11b6, 0x155, 0x995, 0x175, 0x154, 0x154, 0x134, 0x1995,
0x1954, 0x1954, 0x29b5, 0x2174, 0x1912, 0x2973, 0x3193, 0x3173, 0x31b4,
0x2993, 0x2992, 0x3172, 0x3172, 0x3173, 0x3972, 0x3152, 0x2931, 0x2952,
0x2972, 0x3151, 0x3131, 0x3972, 0x41b2, 0x4192, 0x3951, 0x3972, 0x3130,
0x3951, 0x3971, 0x4191, 0x3150, 0x3130, 0x3130, 0x3130, 0x3130, 0x290f,
0x3971, 0x3950, 0x28ee, 0x3150, 0x3130, 0x843, 0x843, 0x842, 0x42,
0x864, 0x65, 0xe6, 0x63, 0xa5, 0xc6, 0x1ee, 0x1cd, 0x1ef,
0x22f, 0x2d2, 0x24f, 0x1cc, 0x1ec, 0x1ec, 0x1eb, 0x332, 0x2d18,
0x4679, 0x97ff, 0x97ff, 0x97ff, 0x87fd, 0x5fd5, 0x5fd4, 0x57d2, 0x57f1,
0x5ff1, 0x5ff1, 0x6ff2, 0xbffc, 0xf7ff, 0xcffe, 0xa7fe, 0xafbf, 0x30f,
0x222c, 0xb0d, 0x3acf, 0x426e, 0x49ce, 0x318e, 0x31d0, 0x49d1, 0x5a12,
0x51f2, 0x4a13, 0x39f3, 0x2150, 0x3a14, 0x3a14, 0x4a97, 0x4276, 0x431a,
0x32d9, 0x2ab9, 0x2b1b, 0x22fb, 0x337d, 0x3b7d, 0x43be, 0x543f, 0x4c1e,
0x43dd, 0x3b5c, 0x333d, 0x2b1c, 0x22db, 0x3a99, 0x3257, 0x1a58, 0x1a9b,
0x22bb, 0x2abc, 0x32fd, 0x2afd, 0x2afc, 0x22bb, 0x1a9a, 0x1239, 0x125a,
0x125a, 0x1239, 0x1239, 0xa19, 0xa19, 0xa19, 0x1239, 0xa19, 0x9f9,
0x9f9, 0x9f9, 0x9f9, 0x1d8, 0x9d8, 0x9f9, 0x1b8, 0x1b7, 0x1b7,
0x1b6, 0x1b6, 0x196, 0x196, 0x996, 0x11b6, 0x154, 0x196, 0x196,
0x155, 0x9b6, 0x174, 0x154, 0x154, 0x995, 0x995, 0x194, 0x974,
0x1994, 0x1933, 0x1933, 0x2173, 0x2953, 0x2132, 0x2973, 0x2972, 0x2952,
0x3173, 0x39b3, 0x39b3, 0x3192, 0x2951, 0x39b3, 0x3993, 0x3151, 0x3992,
0x3151, 0x3951, 0x3151, 0x4192, 0x3951, 0x3951, 0x4171, 0x3950, 0x4192,
0x3150, 0x3951, 0x3150, 0x3950, 0x3971, 0x290f, 0x3110, 0x28ef, 0x290f,
0x3150, 0x312f, 0x290f, 0x1083, 0x21, 0x10a3, 0x842, 0x24, 0x66,
0x65, 0x63, 0x863, 0xc9, 0xea, 0x12a, 0x1ef, 0x20f, 0x2d2,
0x20e, 0x1cc, 0x16b, 0x18a, 0x24e, 0x333, 0x34d9, 0x3d98, 0x1394,
0x773f, 0x86fd, 0xaf5d, 0x7dbc, 0x6d5b, 0x54ba, 0x655b, 0x6d9a, 0x75db,
0x65db, 0x871d, 0xafdf, 0xa7df, 0x871d, 0xc79f, 0x3b1, 0x2ed, 0x34e,
0x3b90, 0x49ed, 0x51ee, 0x316e, 0x39d0, 0x5a11, 0x6233, 0x5a34, 0x5235,
0x4234, 0x39f4, 0x4256, 0x4a35, 0x4a97, 0x4a97, 0x4b5b, 0x4b9d, 0x331b,
0x331b, 0x2b3c, 0x335d, 0x3b7d, 0x4bde, 0x4bfe, 0x543f, 0x43dd, 0x3b9d,
0x335d, 0x335d, 0x22db, 0x2a99, 0x3299, 0x22da, 0x22dc, 0x2adc, 0x2add,
0x32fd, 0x331d, 0x22dc, 0x1259, 0x1a9b, 0x1239, 0x1238, 0xa19, 0x1239,
0xa19, 0xa19, 0xa19, 0x125a, 0xa19, 0xa19, 0x9f9, 0x9d9, 0x9f9,
0x9d8, 0x1d8, 0x1b8, 0x1b8, 0x1b7, 0x1b7, 0x1b7, 0x9b7, 0x9b6,
0x9b6, 0x9b6, 0x175, 0x995, 0x19b6, 0x19b5, 0x1995, 0x975, 0x975,
0x995, 0x154, 0x174, 0x133, 0x974, 0x174, 0x994, 0x1194, 0x2194,
0x1994, 0x1153, 0x2174, 0x2194, 0x2173, 0x2973, 0x3993, 0x3173, 0x3152,
0x3993, 0x39b3, 0x3172, 0x3172, 0x41b3, 0x3992, 0x3151, 0x3151, 0x3952,
0x3951, 0x3971, 0x4192, 0x4171, 0x4151, 0x4151, 0x3950, 0x4191, 0x3130,
0x3150, 0x3150, 0x3150, 0x2930, 0x290f, 0x3150, 0x3150, 0x3990, 0x312f,
0x28ef, 0x821, 0x863, 0x21, 0x822, 0x64, 0xa6, 0x85, 0x63,
0x87, 0x18c, 0xc9, 0x14c, 0x1cf, 0x210, 0x1cf, 0x1ce, 0x1ad,
0x1cd, 0x18b, 0x24f, 0x2d4, 0x345b, 0x2459, 0x20f, 0x6e1f, 0xa6be,
0x65de, 0x14f, 0x92c, 0xca, 0x12b, 0x12c, 0x12c, 0x12f, 0x12f,
0xa74, 0xa36, 0x1299, 0xaf5, 0x2ef, 0x226e, 0x31ed, 0x5a0f, 0x5a0f,
0x59ef, 0x398f, 0x3170, 0x6253, 0x5a33, 0x5a75, 0x4a56, 0x31f4, 0x3a14,
0x4ab7, 0x4a96, 0x5276, 0x4a97, 0x331a, 0x32fa, 0x331b, 0x3b9d, 0x3b9d,
0x3b9d, 0x43be, 0x4bde, 0x4c1f, 0x4bfe, 0x4bde, 0x43bd, 0x333c, 0x331c,
0x22bb, 0x2259, 0x3b1b, 0x2b1c, 0x22bb, 0x22bb, 0x2afd, 0x2afd, 0x2afd,
0x1a9b, 0x1a7a, 0x1238, 0x9f7, 0xa17, 0xa38, 0xa18, 0xa39, 0x9f8,
0xa19, 0x125a, 0x9d8, 0x9f9, 0x9f9, 0x9f9, 0x121a, 0x9d8, 0x9d8,
0x9d8, 0x1b8, 0x9d8, 0x1b7, 0x1b7, 0x1b6, 0x9b6, 0x995, 0x19f7,
0x11d6, 0x19b6, 0x1955, 0x29b6, 0x2195, 0x1995, 0x995, 0x995, 0x154,
0x954, 0x974, 0x974, 0x954, 0x1995, 0x1153, 0x1974, 0x1974, 0x1173,
0x973, 0x1153, 0x1953, 0x2994, 0x2933, 0x2112, 0x3993, 0x39b3, 0x3972,
0x3172, 0x3172, 0x3992, 0x3993, 0x3972, 0x3172, 0x2930, 0x3171, 0x3991,
0x41b2, 0x3991, 0x41b2, 0x3991, 0x3971, 0x3971, 0x3971, 0x3971, 0x3130,
0x3150, 0x292f, 0x312f, 0x3970, 0x3130, 0x3971, 0x3130, 0x290f, 0x862,
0x842, 0x21, 0x863, 0x864, 0x8a6, 0x44, 0x43, 0xea, 0x12b,
0x12b, 0x16e, 0x1af, 0x211, 0x1f0, 0x18e, 0x18c, 0x1ed, 0xe8,
0x2b2, 0x1338, 0x445c, 0x2c3a, 0x176, 0x75df, 0x3b17, 0xffff, 0x4138,
0x597c, 0x515f, 0x513e, 0x40ff, 0x38ff, 0x38da, 0xe75f, 0xffff, 0x18df,
0x18df, 0x116f, 0x298e, 0x41ad, 0x51cf, 0x51cf, 0x5a2f, 0x59ef, 0x398f,
0x4190, 0x5a13, 0x5a54, 0x42f9, 0x4297, 0x31b3, 0x31d3, 0x4255, 0x5297,
0x52b7, 0x4ab7, 0x3b3b, 0x32fa, 0x439d, 0x3b5d, 0x3b7d, 0x43be, 0x3b9d,
0x4bfe, 0x4c1f, 0x4bde, 0x3b9d, 0x3b9d, 0x2b1c, 0x333d, 0x22db, 0x2afc,
0x22bb, 0x2adc, 0x2afc, 0x2afc, 0x2add, 0x2afd, 0x2afc, 0x22bb, 0xa17,
0x9f6, 0x9b6, 0x11d6, 0xa38, 0x1239, 0x9f8, 0x9f8, 0xa19, 0xa19,
0x9f9, 0x9f9, 0x9f9, 0x9f9, 0x9d9, 0x9d8, 0x1219, 0x1b8, 0x1b8,
0x1d8, 0x1b7, 0x1b7, 0x1b6, 0x11d7, 0x19b6, 0x11b5, 0x11b5, 0x11b6,
0x9b5, 0x9b5, 0x21b6, 0x19b5, 0x974, 0x974, 0x954, 0x1195, 0x154,
0x954, 0x1154, 0x2174, 0x2174, 0x2995, 0x1953, 0x1953, 0x1133, 0x1953,
0x1933, 0x2174, 0x2953, 0x3193, 0x3173, 0x3172, 0x3152, 0x39b3, 0x3151,
0x2931, 0x3172, 0x3172, 0x3151, 0x3151, 0x39b2, 0x3971, 0x4192, 0x3130,
0x3951, 0x3971, 0x4192, 0x3150, 0x3971, 0x3130, 0x28ef, 0x3150, 0x3991,
0x3150, 0x310f, 0x3130, 0x290f, 0x290f, 0x2930, 0x842, 0x841, 0x862,
0x863, 0xa6, 0x64, 0x44, 0x63, 0x1ad, 0x109, 0x14d, 0x16d,
0x1f0, 0x1d0, 0x14c, 0x18e, 0x10a, 0x1ac, 0x16b, 0x2b4, 0x239a,
0x3bfc, 0x337e, 0x7d3e, 0xd75f, 0x9d5e, 0xf7ff, 0x10ff, 0x18df, 0x18df,
0x18df, 0x10df, 0x18df, 0x18ff, 0x10fe, 0x18df, 0xefbf, 0x20de, 0x1911,
0x4190, 0x51ef, 0x51ce, 0x51ef, 0x51cf, 0x5a30, 0x41af, 0x41d1, 0x5a54,
0x4a54, 0x539b, 0x3236, 0x39d3, 0x4255, 0x4255, 0x5ab7, 0x5297, 0x4ab7,
0x3b5b, 0x32f9, 0x439d, 0x331b, 0x3b9d, 0x43de, 0x43be, 0x543f, 0x541e,
0x43de, 0x3b7d, 0x439e, 0x3b7d, 0x3b7e, 0x2b1c, 0x22bb, 0x335d, 0x2afc,
0x333d, 0x2adc, 0x2add, 0x2add, 0x22bb, 0x1a59, 0x2a17, 0x29f6, 0x21f6,
0x19d6, 0x1d7, 0x1f8, 0xa39, 0xa19, 0x123a, 0xa19, 0x123a, 0x1219,
0x121a, 0x9f9, 0x121a, 0x9d9, 0x9d9, 0x9d9, 0x9d8, 0x1d8, 0x1b7,
0x1b7, 0x9f8, 0x9b6, 0x19d6, 0x11b6, 0x11b6, 0x2217, 0x175, 0x19f6,
0x1174, 0x21f6, 0x1995, 0x11b5, 0x974, 0x995, 0x11b5, 0x21d6, 0x1994,
0x1954, 0x1954, 0x1974, 0x2174, 0x2194, 0x1153, 0x1953, 0x1933, 0x2153,
0x1952, 0x2173, 0x2993, 0x2972, 0x2972, 0x2952, 0x3172, 0x3192, 0x3193,
0x3151, 0x3172, 0x3992, 0x3972, 0x3931, 0x4192, 0x3972, 0x3951, 0x4171,
0x49b3, 0x3130, 0x3971, 0x3150, 0x3130, 0x3950, 0x3910, 0x3950, 0x3130,
0x3130, 0x2930, 0x292f, 0x20ce, 0x862, 0x21, 0x843, 0x843, 0xc6,
0x63, 0x863, 0x64, 0x1ae, 0x10b, 0x14d, 0x18e, 0x1d0, 0x1af,
0xa8, 0x18c, 0x16c, 0x16b, 0x18c, 0x274, 0x2b9a, 0x4c3e, 0x32df,
0xae3f, 0x957f, 0x74fe, 0xf7fe, 0x18ff, 0x18bf, 0x18df, 0x18df, 0x18df,
0x18df, 0x215d, 0xe77f, 0x18ff, 0xad5d, 0x18fd, 0x835, 0x3913, 0x498f,
0x49cf, 0x59ef, 0x5a10, 0x5a31, 0x418e, 0x3991, 0x5a75, 0x4276, 0x64be,
0x435a, 0x31b2, 0x4296, 0x4a96, 0x5ab7, 0x6318, 0x5af8, 0x3af9, 0x3b3b,
0x439d, 0x439d, 0x43de, 0x4bde, 0x43de, 0x545f, 0x4c1e, 0x439d, 0x43be,
0x333c, 0x333c, 0x3b7d, 0x2afb, 0x22db, 0x333d, 0x3b9e, 0x333d, 0x2afc,
0x2adc, 0x22bb, 0x22bb, 0x2a58, 0x2a16, 0x29d5, 0x29f6, 0x21f6, 0xa19,
0xa19, 0xa18, 0xa19, 0x123a, 0x123a, 0x121a, 0x121a, 0x9d9, 0x9d9,
0x9d9, 0x9d9, 0x198, 0x9b9, 0x9d8, 0x197, 0x1d7, 0x197, 0x9d7,
0x9b6, 0x11f6, 0x1175, 0x11b6, 0x975, 0x975, 0x1175, 0x19b5, 0x19d5,
0x21d6, 0x1195, 0x154, 0x974, 0x1174, 0x2175, 0x1974, 0x21b5, 0x1974,
0x1974, 0x2174, 0x1973, 0x1953, 0x21b4, 0x1133, 0x29b4, 0x1932, 0x2173,
0x3173, 0x2972, 0x2152, 0x2993, 0x3172, 0x2972, 0x2972, 0x2972, 0x3172,
0x3172, 0x3992, 0x4192, 0x3951, 0x4192, 0x4172, 0x4172, 0x3971, 0x3971,
0x2910, 0x3191, 0x3971, 0x3930, 0x30ef, 0x3950, 0x290f, 0x310f, 0x292f,
0x290f, 0x292f, 0x21, 0x882, 0x863, 0x885, 0x884, 0x863, 0x822,
0x42, 0x14b, 0x10b, 0x12c, 0x16e, 0x1b0, 0x16e, 0x10b, 0x16c,
0x16b, 0x14a, 0x1cd, 0x233, 0x2b9a, 0x3bbc, 0x2b1e, 0x53ff, 0x5cbf,
0xb73f, 0xdedf, 0x10de, 0x10de, 0x10df, 0x18ff, 0x18ff, 0x18ff, 0x18ff,
0x18ff, 0x10ff, 0x8cbc, 0x10ff, 0x28b8, 0x4914, 0x5190, 0x59f0, 0x59cf,
0x5a10, 0x59f1, 0x49f0, 0x3991, 0x5a96, 0x437b, 0x543d, 0x4bdc, 0x4276,
0x3a56, 0x4256, 0x62d8, 0x5ad7, 0x5af7, 0x4b1a, 0x4b7c, 0x4c1e, 0x4bde,
0x43de, 0x4bfe, 0x4bdd, 0x545e, 0x545f, 0x4c1e, 0x335c, 0x3b7d, 0x3b9e,
0x331c, 0x335c, 0x331c, 0x333c, 0x333c, 0x333d, 0x2adc, 0x22bb, 0x1a59,
0x2a99, 0x29f6, 0x3216, 0x29d4, 0x29d5, 0x11d5, 0x239, 0x1239, 0x9f8,
0x1d8, 0x123a, 0x1219, 0xa19, 0x9f9, 0x9d9, 0x1b9, 0x9d9, 0x9f9,
0x1b8, 0x1b8, 0x9f9, 0x9d8, 0x9d7, 0x196, 0x9d7, 0x9d6, 0x995,
0x175, 0x195, 0x175, 0x955, 0x19b6, 0x1154, 0x21b5, 0x21d6, 0x1995,
0x1195, 0x1174, 0x1994, 0x1994, 0x1133, 0x1974, 0x1953, 0x31f5, 0x2153,
0x2194, 0x1933, 0x2153, 0x1932, 0x1112, 0x1112, 0x2112, 0x2973, 0x2973,
0x2131, 0x2952, 0x2131, 0x2931, 0x2972, 0x3172, 0x3172, 0x3172, 0x3971,
0x3151, 0x4192, 0x4151, 0x3910, 0x3951, 0x3951, 0x3151, 0x3171, 0x3130,
0x3971, 0x3150, 0x310f, 0x290f, 0x310f, 0x390f, 0x30ee, 0x310f, 0x312f,
0x21, 0x864, 0x22, 0x8a5, 0x63, 0x43, 0x63, 0xc8, 0xea,
0x10b, 0x12b, 0x12c, 0x1f0, 0x16d, 0x1cf, 0x12b, 0x14b, 0x129,
0x1ad, 0xa96, 0x2b7a, 0x43dd, 0x1b9a, 0x225f, 0x4b9f, 0xefff, 0xef7f,
0x5bbd, 0x3a9b, 0x29da, 0x193c, 0x191b, 0x2197, 0xc69f, 0xefff, 0xf7ff,
0xf7df, 0x57, 0x2931, 0x41d0, 0x59cf, 0x5a10, 0x59ef, 0x59ef, 0x5a11,
0x49af, 0x292f, 0x52d7, 0x42d7, 0x2255, 0x2277, 0x3277, 0x4b39, 0x52b7,
0x62f7, 0x52b7, 0x5b18, 0x535b, 0x4b3b, 0x543e, 0x543e, 0x43dd, 0x4c1e,
0x5c7f, 0x545e, 0x545e, 0x43bd, 0x43bd, 0x3b7d, 0x3b7d, 0x333c, 0x2adb,
0x335c, 0x3b7d, 0x333c, 0x2b1c, 0x2b1c, 0x22db, 0x2259, 0x4278, 0x4236,
0x4235, 0x3a15, 0x3215, 0x19f5, 0xa18, 0x125a, 0xa19, 0x1219, 0x9f9,
0x123a, 0x9f9, 0x9f9, 0x9fa, 0x121a, 0x9d9, 0x9d9, 0x9f9, 0x9d9,
0x9d8, 0x1b8, 0x1b7, 0x9b7, 0x11b7, 0x155, 0x9b6, 0x11f7, 0x995,
0x955, 0x11d6, 0x11d6, 0x1174, 0x21b5, 0x21b5, 0x1995, 0x1995, 0x1994,
0x21b5, 0x1933, 0x1974, 0x29b5, 0x2154, 0x2174, 0x1153, 0x1912, 0x2174,
0x1932, 0x1112, 0x2193, 0x2173, 0x2993, 0x2132, 0x2973, 0x2973, 0x2993,
0x2972, 0x3192, 0x3172, 0x3172, 0x3152, 0x3193, 0x39b3, 0x2931, 0x4172,
0x4172, 0x3971, 0x41b2, 0x41b2, 0x3971, 0x3130, 0x3951, 0x3971, 0x3150,
0x3150, 0x3150, 0x3130, 0x314f, 0x312f, 0x314f, 0x28ee, 0x841, 0x1085,
0x42, 0x65, 0x44, 0x22, 0x65, 0xe9, 0x10b, 0x14c, 0x18e,
0x16d, 0x18e, 0x14c, 0x18d, 0x18c, 0x14a, 0x12a, 0x252, 0x1338,
0x2bbb, 0x3bdd, 0x1a7c, 0x20fc, 0x9cfd, 0x4a58, 0x18be, 0x14, 0x10,
0x2f, 0x10, 0xf, 0x4d, 0x4b, 0x4a, 0x2b, 0x3994, 0x3150,
0x396e, 0x61ef, 0x622f, 0x6230, 0x5a10, 0x59ef, 0x6252, 0x51d0, 0x296f,
0x4ad7, 0x3234, 0x3992, 0x2215, 0x32d8, 0x537a, 0x4ad8, 0x6318, 0x6359,
0x5b39, 0x533a, 0x4b5c, 0x4bdd, 0x649f, 0x5c5f, 0x543e, 0x5c5e, 0x649f,
0x541e, 0x541e, 0x4bfe, 0x3b9d, 0x335d, 0x3b7d, 0x3b7d, 0x3b7d, 0x3b7c,
0x3b5d, 0x2afb, 0x22ba, 0x2ada, 0x3258, 0x4a98, 0x4215, 0x39f5, 0x39f4,
0x39d5, 0x2216, 0xa18, 0x1259, 0xa19, 0x123a, 0x123a, 0x123a, 0x9f9,
0x9f9, 0x9fa, 0x9fa, 0x9d9, 0x9d9, 0x9f9, 0x9d9, 0x1d8, 0x9f9,
0x9f8, 0x11d7, 0x19d7, 0x11b6, 0x19b6, 0x1196, 0x21d7, 0x955, 0x1195,
0x1975, 0x21b6, 0x1974, 0x1174, 0x21b5, 0x2174, 0x29b5, 0x2174, 0x2174,
0x2995, 0x2994, 0x2154, 0x2194, 0x2174, 0x2174, 0x1953, 0x2174, 0x2173,
0x2994, 0x2952, 0x2173, 0x2993, 0x2152, 0x2952, 0x2952, 0x2111, 0x2931,
0x2952, 0x2972, 0x2951, 0x3152, 0x3193, 0x3172, 0x3151, 0x3971, 0x3991,
0x3991, 0x3150, 0x3951, 0x3951, 0x41b2, 0x3971, 0x310f, 0x3150, 0x3150,
0x3991, 0x290f, 0x3970, 0x3950, 0x3150, 0x821, 0x884, 0x863, 0x8a4,
0x863, 0x23, 0xa7, 0xc7, 0xe9, 0x12b, 0x18c, 0x1ae, 0x16d,
0x18d, 0x12b, 0x16b, 0x10a, 0x14b, 0x231, 0x1b78, 0x23b8, 0x4c7d,
0x11b, 0x869f, 0x9f7f, 0x6dff, 0x115b, 0x5afc, 0xf7ff, 0x6b78, 0x20fb,
0x18dc, 0x52, 0xe8, 0x2127, 0x864, 0x30ca, 0x49ad, 0x49ae, 0x622f,
0x620f, 0x7271, 0x5a10, 0x6231, 0x6252, 0x49af, 0x3190, 0x4ad7, 0x4214,
0x3190, 0x3a36, 0x32d8, 0x5bdc, 0x637a, 0x6359, 0x6b7a, 0x6359, 0x537a,
0x539c, 0x4bfd, 0x545e, 0x5c9f, 0x64bf, 0x64bf, 0x649f, 0x5c7e, 0x543e,
0x43bd, 0x43bd, 0x3b7d, 0x3b5d, 0x333c, 0x3b5c, 0x3b7c, 0x331b, 0x2ab9,
0x32b9, 0x42d9, 0x4a77, 0x4a35, 0x5235, 0x49f5, 0x39b3, 0x31b4, 0x21f6,
0x1219, 0x1259, 0xa19, 0x121a, 0x1239, 0x1219, 0x121a, 0x11fa, 0x9da,
0x9fa, 0x9b9, 0x1b8, 0x198, 0x9d9, 0x1d8, 0x1b7, 0x196, 0x11b7,
0x19b6, 0x19d7, 0x19b6, 0x11b6, 0x21d7, 0x1975, 0x21b6, 0x29f7, 0x21b5,
0x21b5, 0x21d5, 0x29b5, 0x2995, 0x2194, 0x2174, 0x1933, 0x2174, 0x29b5,
0x2154, 0x2974, 0x1953, 0x2174, 0x1953, 0x2974, 0x1912, 0x2152, 0x2152,
0x2152, 0x2152, 0x2172, 0x1952, 0x2152, 0x2111, 0x3173, 0x2952, 0x3193,
0x2931, 0x3172, 0x3151, 0x2951, 0x3171, 0x3991, 0x4171, 0x4171, 0x4171,
0x4992, 0x4191, 0x3971, 0x3971, 0x3150, 0x3130, 0x3150, 0x3950, 0x312f,
0x30ef, 0x310f, 0x3950, 0x862, 0x883, 0x1083, 0x18e5, 0x842, 0x44,
0xc8, 0xa8, 0x10a, 0x12b, 0x18d, 0x1ae, 0x16c, 0x1ae, 0x10a,
0x18b, 0x14a, 0x18d, 0x22f, 0x1c38, 0x395, 0x351a, 0x7f3f, 0xd7ff,
0xd7df, 0x9fff, 0x7ffc, 0x87fb, 0x8ffc, 0x97de, 0x8fff, 0x649f, 0x111e,
0x168, 0x9c7, 0x83, 0x1044, 0x5a2f, 0x418d, 0x7a90, 0x7a90, 0x6210,
0x6231, 0x6231, 0x6251, 0x51f0, 0x41d1, 0x4ab6, 0x39f3, 0x314e, 0x3a15,
0x4319, 0x7cdf, 0x6bdb, 0x6bba, 0x6bbb, 0x5b39, 0x5bfc, 0x53fd, 0x4bdd,
0x649e, 0x5c5e, 0x647f, 0x6cdf, 0x649e, 0x649e, 0x649f, 0x4bfe, 0x439d,
0x439e, 0x333c, 0x32fb, 0x4b9d, 0x439d, 0x435c, 0x4b5c, 0x4afa, 0x52b9,
0x5297, 0x5a76, 0x5255, 0x5235, 0x41f4, 0x4236, 0x31f6, 0x1a59, 0xa18,
0xa19, 0x123a, 0x1219, 0x9f9, 0x123a, 0x121a, 0x11fa, 0x9d9, 0x9fa,
0x9f9, 0x121a, 0x9d9, 0x1b8, 0x197, 0x9d7, 0x1a18, 0x21f7, 0x19b6,
0x19d6, 0x19d6, 0x21d6, 0x29f7, 0x21b6, 0x21b5, 0x21d5, 0x21b5, 0x29b5,
0x29b5, 0x2995, 0x31b5, 0x2994, 0x2994, 0x31b5, 0x2995, 0x2154, 0x2153,
0x2174, 0x29b5, 0x2994, 0x2174, 0x2994, 0x2173, 0x2173, 0x2152, 0x2172,
0x2152, 0x2992, 0x2972, 0x2952, 0x3172, 0x2952, 0x2951, 0x3172, 0x2952,
0x3152, 0x3172, 0x3972, 0x3992, 0x4191, 0x4171, 0x49b2, 0x4171, 0x3950,
0x3130, 0x4191, 0x3130, 0x3970, 0x4191, 0x3970, 0x3930, 0x3930, 0x3970,
0x30ce, 0x883, 0x22, 0x843, 0x883, 0x863, 0x65, 0xc8, 0xc8,
0xe8, 0x96d, 0x18d, 0x18e, 0x10b, 0x1ad, 0x109, 0x14a, 0x108,
0x20e, 0x24f, 0x1457, 0xc76, 0x2db7, 0x8fff, 0xc7ff, 0xbfff, 0xa7ff,
0x8ffc, 0x8ffc, 0xe7ff, 0xf7ff, 0xd7ff, 0x8f5d, 0x649f, 0x1a8, 0x227,
0x145, 0xa3, 0x520e, 0x49ce, 0x7ad1, 0x82b0, 0x5a11, 0x51d0, 0x6a71,
0x7ab2, 0x5210, 0x4a34, 0x4ad6, 0x4212, 0x398f, 0x4256, 0x4b39, 0x7cfe,
0x747d, 0x73fb, 0x741c, 0x6bbb, 0x53bb, 0x5c1d, 0x53fc, 0x6cdf, 0x647f,
0x6cdf, 0x5c7e, 0x6cdf, 0x6cff, 0x5c7e, 0x545f, 0x3b9d, 0x3b9d, 0x3b9d,
0x437c, 0x4b9d, 0x437c, 0x3b1b, 0x42fa, 0x52d9, 0x5ab7, 0x5a77, 0x5a76,
0x5a96, 0x5235, 0x4a34, 0x4a36, 0x3a38, 0x1a59, 0x1a59, 0x1a7a, 0x1239,
0x123a, 0x123b, 0x9da, 0x11fa, 0x9fa, 0x9d9, 0x9d9, 0x1b8, 0x1b8,
0x1b8, 0x1d8, 0x1d8, 0x196, 0x11d7, 0x1196, 0x19d6, 0x19d6, 0x11b5,
0x1995, 0x21b5, 0x2216, 0x19b5, 0x31f6, 0x21b5, 0x2194, 0x3195, 0x29b5,
0x29b5, 0x2994, 0x31b5, 0x2174, 0x2174, 0x2174, 0x2154, 0x2994, 0x1932,
0x2994, 0x2173, 0x2153, 0x2173, 0x1932, 0x31b4, 0x2953, 0x2973, 0x2972,
0x2151, 0x2152, 0x2152, 0x29b3, 0x2972, 0x2952, 0x2931, 0x2931, 0x3152,
0x2931, 0x3992, 0x3971, 0x4192, 0x4192, 0x3951, 0x3110, 0x3950, 0x3971,
0x4171, 0x3950, 0x3950, 0x4170, 0x3950, 0x3970, 0x3950, 0x3930, 0x862,
0x43, 0x63, 0x22, 0x822, 0x45, 0x10a, 0x109, 0x14b, 0x16c,
0x16c, 0x14b, 0x10b, 0x12b, 0x109, 0x14a, 0xe8, 0x1ac, 0x332,
0x415, 0x1d18, 0x3e77, 0x67f9, 0x8ffe, 0x8ffe, 0x8fdd, 0x67ba, 0x77fb,
0xc7fe, 0xdfff, 0x8ffe, 0xbfdf, 0x32de, 0x209, 0x184, 0x1c6, 0x145,
0x8a6, 0x498d, 0x726f, 0x826f, 0x6231, 0x6a71, 0x7291, 0x7251, 0x5a52,
0x5254, 0x4a75, 0x41b0, 0x3990, 0x4297, 0x42d8, 0x853e, 0x7cbc, 0x7c3c,
0x745d, 0x63db, 0x63fc, 0x5c1d, 0x53fd, 0x6cdf, 0x6cff, 0x64bf, 0x649e,
0x753f, 0x649e, 0x5c5e, 0x4c1e, 0x4c1e, 0x43bd, 0x439d, 0x3b5c, 0x5bfe,
0x4b9c, 0x4b5c, 0x4b1a, 0x62f8, 0x62b7, 0x62d7, 0x5a76, 0x5a76, 0x5a96,
0x4a36, 0x4216, 0x3a16, 0x9d6, 0x1239, 0x1239, 0x1a7a, 0x123a, 0x121a,
0x121a, 0x11fa, 0x11fa, 0x9fa, 0x9d9, 0x1d9, 0x9d9, 0x9d9, 0x1b8,
0x1b8, 0x1b7, 0x9b7, 0x19d7, 0x19d6, 0x21f7, 0x21b6, 0x21b6, 0x21d6,
0x21d6, 0x29f6, 0x2194, 0x29d5, 0x29b5, 0x29b5, 0x31d5, 0x29b4, 0x29b4,
0x2994, 0x29b4, 0x2153, 0x29b5, 0x2994, 0x2974, 0x2994, 0x2173, 0x2173,
0x2173, 0x1932, 0x1993, 0x2973, 0x2952, 0x2152, 0x2132, 0x2972, 0x2972,
0x2131, 0x2932, 0x2152, 0x2932, 0x2972, 0x2952, 0x3131, 0x3972, 0x3971,
0x41b2, 0x3971, 0x41b2, 0x3951, 0x3971, 0x3110, 0x41d2, 0x3950, 0x3150,
0x314f, 0x312f, 0x3950, 0x312f, 0x3930, 0x310f, 0x862, 0x863, 0x42,
0x863, 0x22, 0x44, 0x16b, 0xe9, 0x16b, 0x14b, 0x1ad, 0x129,
0x16b, 0x18c, 0x14a, 0x129, 0x108, 0x22d, 0xb95, 0x3b3, 0x495,
0x4ef8, 0x144f, 0x7ffa, 0xd7ff, 0xefff, 0xe7ff, 0xd7ff, 0xe7ff, 0xefff,
0xefff, 0xf7ff, 0x10fc, 0x1e8, 0x268, 0x206, 0x144, 0x62, 0x51ee,
0x828f, 0x9af1, 0x82f1, 0x724f, 0x7ab1, 0x7ab2, 0x7293, 0x4a34, 0x5295,
0x41af, 0x39b1, 0x2a36, 0x7cde, 0x643d, 0x8d5e, 0x7c9d, 0x7c9d, 0x6c3d,
0x6c3d, 0x645e, 0x6c9e, 0x6c9e, 0x649e, 0x6cdf, 0x6cdf, 0x6cde, 0x64bf,
0x543e, 0x43dd, 0x4c1e, 0x43be, 0x439d, 0x437d, 0x4b7c, 0x53dd, 0x535b,
0x5b5b, 0x6319, 0x62d7, 0x62b7, 0x5a96, 0x62b7, 0x5a97, 0x5297, 0x4277,
0x3a58, 0x2a39, 0x1238, 0x229b, 0x1239, 0x1a5b, 0x123a, 0x1a3b, 0x11fa,
0x9da, 0x9d9, 0x9da, 0x9d9, 0x1b8, 0x9d9, 0x1b8, 0x1b8, 0x1b8,
0x997, 0x19f7, 0x19f7, 0x2217, 0x19b6, 0x19f6, 0x19b5, 0x29f6, 0x21b5,
0x31d5, 0x2994, 0x31d5, 0x31d5, 0x31b4, 0x3194, 0x31d5, 0x2994, 0x31b4,
0x2173, 0x2994, 0x2994, 0x29b4, 0x2153, 0x2132, 0x2993, 0x2172, 0x29b4,
0x2993, 0x2172, 0x2993, 0x2172, 0x2952, 0x2952, 0x2972, 0x2972, 0x2952,
0x2131, 0x2972, 0x2131, 0x3152, 0x3131, 0x3992, 0x4192, 0x3951, 0x3971,
0x3971, 0x3971, 0x3930, 0x3971, 0x3171, 0x3130, 0x3950, 0x3950, 0x4150,
0x4191, 0x314f, 0x312f, 0x3970, 0x883, 0x863, 0x864, 0x842, 0x843,
0x8a8, 0x18b, 0xc9, 0x18c, 0x14a, 0x1ee, 0x14a, 0x1ed, 0x16a,
0x16b, 0x169, 0x107, 0x22d, 0xbd5, 0x3f4, 0xcd5, 0x4676, 0x4ed8,
0x87fc, 0xaf7f, 0xaf7f, 0x9f5e, 0x969d, 0x9e9f, 0xb71f, 0xdfbf, 0xffdf,
0x999, 0x186, 0x185, 0x104, 0x41, 0x822, 0x6250, 0x8b31, 0x9b71,
0x9af0, 0x8af1, 0x82d1, 0x82f4, 0x7293, 0x4a33, 0x5a75, 0x418f, 0x41cf,
0x643d, 0x855f, 0x6c7d, 0x8d5e, 0x7cbe, 0x84de, 0x747d, 0x6c5d, 0x6c9e,
0x74df, 0x7cff, 0x74ff, 0x6cff, 0x64be, 0x6cff, 0x545e, 0x545e, 0x5c7f,
0x545f, 0x4bde, 0x4bbe, 0x437d, 0x53dd, 0x5bbd, 0x537b, 0x5b5b, 0x633a,
0x5ab7, 0x62f8, 0x5a97, 0x5a97, 0x5277, 0x52b9, 0x3a37, 0x3a79, 0x2a9a,
0x1a9a, 0x9f9, 0x1a5a, 0x1a3a, 0x123a, 0x11fa, 0x11fa, 0x11fa, 0x9fa,
0x9d9, 0x9d9, 0x9d9, 0x9d9, 0x9d8, 0x9d8, 0x198, 0x9d7, 0x2218,
0x21f7, 0x995, 0x1195, 0x19b6, 0x21b5, 0x2195, 0x29d5, 0x2153, 0x31f6,
0x31d5, 0x3194, 0x39b5, 0x39b5, 0x39b5, 0x3994, 0x31b4, 0x2193, 0x29d4,
0x2973, 0x29b4, 0x1932, 0x2973, 0x2973, 0x2973, 0x29b4, 0x2993, 0x2172,
0x2993, 0x2172, 0x2972, 0x2972, 0x2952, 0x2973, 0x1931, 0x1951, 0x2151,
0x2952, 0x3172, 0x3152, 0x3972, 0x4192, 0x4172, 0x4172, 0x3931, 0x4151,
0x3930, 0x3971, 0x3130, 0x3971, 0x3130, 0x3930, 0x4151, 0x390f, 0x4191,
0x4170, 0x312f, 0x843, 0x863, 0x863, 0x842, 0x86, 0xc9, 0x14a,
0xe8, 0x16b, 0x16b, 0x16b, 0x129, 0x16a, 0x129, 0x149, 0x108,
0x108, 0x1cd, 0x3b4, 0x3b3, 0x3f2, 0x3e78, 0x87fd, 0x8fff, 0x97ff,
0xa7be, 0x87ff, 0x87ff, 0x97ff, 0xbfdf, 0x9fde, 0x11fa, 0x22ba, 0x166,
0x145, 0xc3, 0x21, 0x2886, 0x5a0f, 0x82b0, 0x9b50, 0x9b30, 0x9b11,
0x92f1, 0x7ab3, 0x6273, 0x4a33, 0x6295, 0x49cf, 0x498f, 0x8d9f, 0x4b9b,
0x853f, 0x959f, 0x84fe, 0x851f, 0x7cde, 0x6c5d, 0x6cbe, 0x74de, 0x74fe,
0x751f, 0x649e, 0x649f, 0x5c7e, 0x545e, 0x545e, 0x5c5f, 0x541e, 0x541f,
0x4bde, 0x437d, 0x4b9c, 0x539c, 0x4b3b, 0x5b7b, 0x5b19, 0x6319, 0x5297,
0x52d9, 0x4ab8, 0x4ab8, 0x4ad9, 0x3a79, 0x3a79, 0x32db, 0x2adb, 0x1a7a,
0x1a5a, 0x11f9, 0x123a, 0x121b, 0x11fb, 0x11fa, 0x9da, 0x9fa, 0x9d9,
0x9da, 0x9d9, 0x9d8, 0x9d9, 0x1b8, 0x1d8, 0x9b6, 0x19d6, 0x1995,
0x21d7, 0x1975, 0x29d6, 0x29b5, 0x2174, 0x29b5, 0x29b5, 0x31f5, 0x29b4,
0x39d5, 0x39b4, 0x39b4, 0x3994, 0x3193, 0x31b4, 0x3194, 0x2973, 0x1932,
0x29b4, 0x2994, 0x2153, 0x2153, 0x2993, 0x2173, 0x1932, 0x2132, 0x2972,
0x2132, 0x2132, 0x2952, 0x1911, 0x2972, 0x2132, 0x2152, 0x2952, 0x2952,
0x2952, 0x3152, 0x3952, 0x3951, 0x4992, 0x3930, 0x3951, 0x4171, 0x3971,
0x3971, 0x3950, 0x3130, 0x3971, 0x3950, 0x3930, 0x3950, 0x4150, 0x312f,
0x1083, 0x1083, 0x842, 0x842, 0x66, 0x109, 0x109, 0x129, 0x129,
0x14a, 0x16c, 0x12a, 0x14a, 0xa7, 0x107, 0x128, 0xe7, 0xa2f,
0x394, 0x3b3, 0x330, 0x3e57, 0x87fe, 0x8fff, 0x97ff, 0x8fbf, 0x87ff,
0x8fdf, 0xd7df, 0xefdf, 0xbfff, 0x8fff, 0x2b3c, 0x208, 0x1e8, 0x208,
0xc3, 0x728f, 0x622f, 0x8ad1, 0xa370, 0xa391, 0x9b30, 0x9b11, 0x8af2,
0x5a73, 0x5253, 0x6294, 0x49ce, 0x49ae, 0x95bf, 0x3ad9, 0x959f, 0x957e,
0x851e, 0x957f, 0x851f, 0x749e, 0x7cde, 0x853e, 0x7d3f, 0x649e, 0x6cbf,
0x751f, 0x649f, 0x543e, 0x545f, 0x541e, 0x541f, 0x4bde, 0x4bdf, 0x3b5c,
0x4bde, 0x539d, 0x4b3b, 0x4b3a, 0x533a, 0x52f9, 0x5b1a, 0x4ad9, 0x4ada,
0x3a99, 0x3279, 0x32ba, 0x32bb, 0x2a9b, 0x227a, 0x1a5a, 0x1239, 0x123a,
0x11fa, 0x11fa, 0x11fb, 0x11fa, 0x11fa, 0x9da, 0x9fa, 0x9b9, 0x198,
0x1b8, 0x198, 0x1b8, 0x1b8, 0x196, 0x19f7, 0x1175, 0x21d6, 0x21d6,
0x29d6, 0x29b5, 0x2995, 0x29b5, 0x29b4, 0x29d4, 0x31d5, 0x3193, 0x39b4,
0x41d4, 0x39d4, 0x3994, 0x3994, 0x3194, 0x29b4, 0x2993, 0x2173, 0x2973,
0x2153, 0x29b4, 0x2173, 0x2173, 0x2993, 0x1931, 0x2993, 0x2111, 0x2131,
0x2132, 0x2132, 0x2152, 0x2152, 0x2111, 0x2152, 0x2952, 0x2952, 0x3152,
0x3152, 0x3952, 0x4172, 0x4172, 0x3951, 0x3971, 0x3971, 0x3130, 0x3110,
0x3991, 0x3150, 0x3971, 0x4170, 0x3970, 0x314f, 0x314f, 0x22, 0x822,
0x862, 0x842, 0xc6, 0xe8, 0x109, 0x109, 0x109, 0x18b, 0x129,
0x18a, 0x129, 0xe8, 0xe7, 0x108, 0x149, 0x2b1, 0x333, 0xbf4,
0xc54, 0x4677, 0xb90, 0x6ffd, 0x9f7d, 0x6f7e, 0x5f1e, 0x673e, 0x97df,
0xa7ff, 0x8fdf, 0x87bf, 0x2adc, 0x209, 0x126, 0x2a9, 0x1a7, 0x82f0,
0x6a70, 0x8b11, 0xabf1, 0xabb0, 0x9b50, 0x9b31, 0x82b1, 0x6252, 0x6273,
0x6ab5, 0x5a0f, 0x49ce, 0x7cdd, 0x5b3a, 0x95bf, 0x9dbf, 0x9dbf, 0x8d3f,
0x851f, 0x74be, 0x7cde, 0x857f, 0x74fe, 0x751f, 0x74ff, 0x64bf, 0x647f,
0x545f, 0x545e, 0x5c7e, 0x4bfe, 0x4bde, 0x4bde, 0x3b5d, 0x3b5c, 0x3afb,
0x537d, 0x4b1a, 0x533b, 0x531a, 0x4afa, 0x42da, 0x42fb, 0x3adb, 0x2279,
0x1a38, 0x1259, 0x229b, 0x229b, 0x1a7a, 0x1a5a, 0x123a, 0x1a3b, 0x121b,
0x11fa, 0x11fa, 0x9da, 0x9da, 0x9d9, 0x9d9, 0x9d9, 0x1b8, 0x9d8,
0x1b8, 0x1b7, 0x9d7, 0x11b6, 0x19b6, 0x995, 0x19b6, 0x29d6, 0x31f6,
0x2995, 0x29b5, 0x39d5, 0x31d5, 0x2994, 0x3194, 0x39b4, 0x41d4, 0x3994,
0x3994, 0x39b4, 0x3193, 0x2973, 0x2994, 0x2173, 0x2974, 0x2973, 0x2153,
0x2152, 0x2993, 0x29b3, 0x2152, 0x2152, 0x2152, 0x2993, 0x2152, 0x2952,
0x2172, 0x2152, 0x2152, 0x2131, 0x2152, 0x2972, 0x2111, 0x2931, 0x3152,
0x3992, 0x3992, 0x3971, 0x3991, 0x3150, 0x3130, 0x3130, 0x3150, 0x3971,
0x4171, 0x4171, 0x3950, 0x312f, 0x3970, 0x842, 0x862, 0x842, 0x864,
0xc6, 0x109, 0x109, 0x109, 0x12a, 0x129, 0x109, 0x96b, 0x129,
0x108, 0x108, 0xc7, 0x20d, 0x2b2, 0x354, 0x3b3, 0x330, 0x3e77,
0xb2a, 0x1aa, 0xefbf, 0xa6df, 0x6dbe, 0x75fd, 0x867f, 0x873d, 0x7f1e,
0x3a56, 0xa18, 0x229, 0x249, 0x166, 0x2946, 0x8b70, 0x5a4f, 0x8b11,
0xb411, 0xabd0, 0xa3b0, 0xa391, 0x82d1, 0x72d4, 0x5ab4, 0x6274, 0x6251,
0x51af, 0x853e, 0x7cde, 0x95df, 0x9ddf, 0x9dbf, 0x8d5f, 0x851f, 0x7cff,
0x74de, 0x6cbd, 0x74de, 0x6cdf, 0x6cdf, 0x649f, 0x5c5f, 0x5c5f, 0x545f,
0x5c7f, 0x543f, 0x4bfe, 0x4bff, 0x3b9d, 0x335c, 0x3b3b, 0x435c, 0x3afa,
0x539c, 0x4b1b, 0x3afa, 0x2a99, 0x32fb, 0x32fb, 0x1a79, 0x22fb, 0x22bb,
0x1a9b, 0x125a, 0x1a7b, 0x1a5a, 0x1a3b, 0x121a, 0x121b, 0x121b, 0x11fb,
0x9da, 0x9da, 0x11fa, 0x9d9, 0x1b9, 0x9d9, 0x9f9, 0x1b8, 0x1b8,
0x1f7, 0x2a18, 0x21f6, 0x11b6, 0x19b6, 0x29f7, 0x29b5, 0x31f6, 0x39d6,
0x31d5, 0x31f5, 0x31d5, 0x3194, 0x41d5, 0x41f4, 0x39b4, 0x39b4, 0x3993,
0x3193, 0x39d4, 0x3193, 0x2973, 0x2153, 0x2953, 0x2133, 0x2193, 0x1993,
0x2173, 0x2973, 0x2973, 0x2993, 0x2111, 0x18f1, 0x2952, 0x1931, 0x2152,
0x2152, 0x2152, 0x2131, 0x1911, 0x2972, 0x2111, 0x2951, 0x2951, 0x3131,
0x3972, 0x3971, 0x3992, 0x3150, 0x20ef, 0x3150, 0x3971, 0x312f, 0x4150,
0x4150, 0x4991, 0x3950, 0x863, 0x841, 0x842, 0x86, 0x65, 0x109,
0xc8, 0xc7, 0x16a, 0xc7, 0x108, 0x128, 0x928, 0x108, 0xa6,
0x128, 0x20e, 0x2d1, 0x2b2, 0x353, 0xbd4, 0x2535, 0x32a, 0x167,
0x20b, 0x1ed, 0x1ed, 0x1ed, 0x20d, 0x1d0, 0x97a, 0x119d, 0x1a9,
0x186, 0x1a6, 0x82, 0x842, 0x9b4f, 0x626f, 0x9331, 0xabd0, 0xabf0,
0xabd0, 0xa351, 0x82d2, 0x72b3, 0x41f1, 0x72f6, 0x6272, 0x51f0, 0x747d,
0x9e1f, 0xa61e, 0xa61f, 0xa61f, 0x8d7f, 0x8d3f, 0x7cdf, 0x74fe, 0x74de,
0x7d1f, 0x6cdf, 0x649e, 0x5c5e, 0x5c5f, 0x541f, 0x5c7f, 0x543e, 0x541f,
0x43de, 0x43be, 0x439e, 0x335c, 0x3b7c, 0x333b, 0x433c, 0x4b5c, 0x433c,
0x3b3c, 0x2ada, 0x2aba, 0x22bb, 0x22dc, 0x22dc, 0x1a9b, 0x22dc, 0x22bb,
0x1a7b, 0x1a5a, 0x123a, 0x123a, 0x11fa, 0x11fa, 0x9da, 0x11fa, 0x9fa,
0x9da, 0x9b9, 0x1b8, 0x1b9, 0x1b8, 0x1b8, 0x1b8, 0x197, 0x19b7,
0x1996, 0x11d6, 0x2217, 0x21b6, 0x31f6, 0x31f6, 0x39f5, 0x2973, 0x29d4,
0x31b4, 0x39d4, 0x3193, 0x39b4, 0x39d4, 0x41d4, 0x3173, 0x39b4, 0x3193,
0x31b4, 0x2973, 0x2993, 0x2172, 0x2993, 0x2993, 0x2172, 0x2993, 0x3193,
0x2952, 0x31b4, 0x2952, 0x2973, 0x2152, 0x2172, 0x2132, 0x2152, 0x2152,
0x2131, 0x1911, 0x2993, 0x2131, 0x2931, 0x2910, 0x3151, 0x2910, 0x3151,
0x3151, 0x3131, 0x3951, 0x3150, 0x4191, 0x3950, 0x4191, 0x4150, 0x4170,
0x3970, 0x863, 0x842, 0x822, 0x10a6, 0x66, 0xe7, 0xe7, 0xe7,
0x18b, 0xa7, 0xa8, 0xc7, 0xe8, 0x108, 0xe7, 0xc7, 0x1ec,
0x290, 0x290, 0x2cf, 0x414, 0x14b5, 0x34c, 0x10e6, 0x8e4, 0x8e2,
0x1924, 0x8c2, 0x903, 0x1185, 0x904, 0x82, 0x2101, 0x18e2, 0x18e1,
0x841, 0x821, 0x9b4f, 0x726f, 0xabd1, 0xabd0, 0xb410, 0xabd0, 0xabd1,
0x7291, 0x6272, 0x41d1, 0x72d5, 0x72d5, 0x5a74, 0x6bfc, 0x9dff, 0xae5f,
0xa61f, 0x9dbf, 0x957f, 0x851e, 0x7cfe, 0x6cbe, 0x7d3f, 0x74ff, 0x6cff,
0x6cdf, 0x649f, 0x5c5f, 0x4bde, 0x5c5f, 0x543f, 0x4bde, 0x4bdf, 0x43be,
0x43de, 0x3b7d, 0x4bbf, 0x331c, 0x3b3c, 0x4b9d, 0x3b3c, 0x3b7c, 0x2b3c,
0x2b1c, 0x22db, 0x22bb, 0x22dc, 0x22bc, 0x22bb, 0x1a9b, 0x1a7b, 0x1a7b,
0x1a9b, 0x123a, 0x1a3b, 0x123b, 0x121b, 0x11fa, 0x9da, 0x9da, 0x121a,
0x9d9, 0x1b9, 0x1b8, 0x1b8, 0x1b8, 0x197, 0x1b6, 0x996, 0x11b6,
0x21f7, 0x21d6, 0x29b5, 0x31b5, 0x31d5, 0x31d5, 0x31d5, 0x31b4, 0x39d5,
0x31b4, 0x39b4, 0x3993, 0x41d4, 0x3172, 0x39d4, 0x3193, 0x3193, 0x2993,
0x2973, 0x2152, 0x2993, 0x2173, 0x2973, 0x2173, 0x2152, 0x2132, 0x2132,
0x2972, 0x2152, 0x2993, 0x1952, 0x1931, 0x2132, 0x1931, 0x2111, 0x2152,
0x2152, 0x29b3, 0x2972, 0x2910, 0x2951, 0x3151, 0x2930, 0x3151, 0x3192,
0x3131, 0x3150, 0x3971, 0x3950, 0x3130, 0x3950, 0x30ee, 0x3950, 0x1,
0x21, 0x21, 0xe6, 0xc6, 0xc7, 0xc7, 0xc7, 0x14a, 0x86,
0x108, 0x86, 0x107, 0xc6, 0xa6, 0x14b, 0x12a, 0x24f, 0x2d0,
0x2cf, 0x3b2, 0x454, 0x106, 0x10e6, 0x61, 0x10a2, 0x18c2, 0x18e3,
0x10a2, 0x1081, 0x10a2, 0x18c2, 0x20e1, 0x3143, 0x2923, 0x1061, 0x1062,
0xa38e, 0x82af, 0xabd0, 0xb410, 0xb3ef, 0xb411, 0xa390, 0x6a50, 0x72b3,
0x51f0, 0x7af5, 0x72d5, 0x5a74, 0x745d, 0xa61f, 0xae7f, 0xa63f, 0x9ddf,
0x959f, 0x853e, 0x853f, 0x74de, 0x74df, 0x74fe, 0x751f, 0x751f, 0x649f,
0x543f, 0x543f, 0x541f, 0x543f, 0x4bff, 0x43be, 0x43be, 0x439e, 0x3b7d,
0x333c, 0x333c, 0x335c, 0x2b1c, 0x335c, 0x2b3d, 0x2afc, 0x2afc, 0x331d,
0x22bb, 0x22bc, 0x22bb, 0x1a9b, 0x22bc, 0x1a7b, 0x1a7b, 0x1a5b, 0x123a,
0x1a5b, 0x121b, 0x11fb, 0x9da, 0x9da, 0x9da, 0x9d9, 0x9d9, 0x1b9,
0x1b8, 0x1b8, 0x1b8, 0x1b7, 0x1b7, 0x1217, 0x11b6, 0x21d7, 0x21d7,
0x21d6, 0x29d6, 0x31f6, 0x31d5, 0x31f5, 0x31b4, 0x31b4, 0x39f5, 0x41d4,
0x41d4, 0x4a15, 0x39b3, 0x39b3, 0x39b4, 0x3173, 0x2952, 0x2953, 0x2132,
0x2993, 0x2152, 0x2172, 0x29b3, 0x2193, 0x1931, 0x2993, 0x2952, 0x29b3,
0x1952, 0x1131, 0x1111, 0x1111, 0x1931, 0x1932, 0x1952, 0x1931, 0x2152,
0x2951, 0x3172, 0x2951, 0x2931, 0x3172, 0x3171, 0x39b2, 0x3171, 0x3171,
0x3951, 0x3951, 0x3950, 0x3950, 0x3950, 0x3950, 0x842, 0x842, 0x1063,
0x65, 0x8a6, 0x8a6, 0xa6, 0xa6, 0xe8, 0x86, 0xa7, 0x85,
0xc7, 0xc6, 0xa6, 0x129, 0x16a, 0xa90, 0x290, 0x1ed, 0x372,
0x412, 0x926, 0x2147, 0x881, 0x860, 0x18c1, 0x20e3, 0x1061, 0x1061,
0x1081, 0x1061, 0x3122, 0x20e2, 0x28e2, 0x18a1, 0x20c3, 0xabce, 0x82ef,
0xabd0, 0xbc50, 0xc450, 0xbc50, 0xabd0, 0x7ad1, 0x7ad2, 0x51f0, 0x8b56,
0x7b15, 0x62f7, 0x747c, 0xa5ff, 0xae5f, 0x9e1f, 0x9dff, 0x9dbf, 0x8d3f,
0x7d1f, 0x7d1f, 0x6cbe, 0x6cde, 0x7d5f, 0x7d1f, 0x64bf, 0x5c5f, 0x543f,
0x543f, 0x4bfe, 0x43be, 0x43be, 0x439e, 0x43be, 0x439e, 0x3b5d, 0x3b5d,
0x335d, 0x331c, 0x2b1c, 0x22db, 0x2adc, 0x2afc, 0x2adc, 0x22dc, 0x2b1d,
0x22dc, 0x22bb, 0x229b, 0x2adc, 0x1a5a, 0x1a5b, 0x1a5b, 0x1a3b, 0x11fa,
0x11fa, 0x121b, 0x9da, 0x9fa, 0x9d9, 0x9d9, 0x1b9, 0x198, 0x1b8,
0x1b8, 0x1b7, 0x1b7, 0x155, 0x11b6, 0x2238, 0x21b6, 0x29d6, 0x2195,
0x2994, 0x31d5, 0x31d5, 0x31b5, 0x31b4, 0x3173, 0x3173, 0x39d4, 0x41d4,
0x3173, 0x41f4, 0x41d4, 0x39b4, 0x2953, 0x2152, 0x2973, 0x2993, 0x2132,
0x2152, 0x2152, 0x2973, 0x2152, 0x2152, 0x2152, 0x2152, 0x1952, 0x2152,
0x1931, 0x2173, 0x1952, 0x1111, 0x2993, 0x2131, 0x2131, 0x2952, 0x18f0,
0x2151, 0x2131, 0x2931, 0x2951, 0x2951, 0x3151, 0x2910, 0x2930, 0x3130,
0x3150, 0x3970, 0x3970, 0x3950, 0x862, 0x842, 0x863, 0x10c6, 0x1086,
0x87, 0x65, 0x8e6, 0x86, 0xa7, 0x8c7, 0x65, 0x8a6, 0xc6,
0x107, 0x129, 0x16a, 0x1cd, 0x20d, 0x24d, 0x2f0, 0x370, 0x147,
0x1906, 0x21, 0x1081, 0x20e2, 0x20c2, 0x18a1, 0x840, 0x840, 0x1040,
0x20a0, 0x18c0, 0x20c1, 0x20c2, 0x1061, 0xbc0f, 0x930e, 0xbc31, 0xc450,
0xc44f, 0xc470, 0xabd0, 0x9353, 0x7ab1, 0x51d0, 0x8b35, 0x8315, 0x6317,
0x84de, 0x9ddf, 0xa63f, 0xa63f, 0x9ddf, 0x95bf, 0x955f, 0x8d5f, 0x74ff,
0x74ff, 0x7d1f, 0x855f, 0x7d5f, 0x64bf, 0x5c5f, 0x541e, 0x545f, 0x4bfe,
0x4bde, 0x43be, 0x439d, 0x3b5d, 0x4bdf, 0x3b7e, 0x3b5d, 0x3b7e, 0x331c,
0x2b1d, 0x2afc, 0x2adc, 0x2afc, 0x2afd, 0x22bc, 0x2add, 0x22dc, 0x229b,
0x22bb, 0x22bc, 0x1a7b, 0x1a5a, 0x123a, 0x121a, 0x121a, 0x121b, 0x121b,
0x121a, 0x9b9, 0x9d9, 0x1b9, 0x1b9, 0x1b8, 0x9d8, 0x198, 0x1b8,
0x1b7, 0x1b7, 0x9b6, 0x11b6, 0x19b6, 0x21d7, 0x29f7, 0x2995, 0x31d5,
0x31d5, 0x31d5, 0x2973, 0x39d5, 0x3194, 0x39b4, 0x31b4, 0x39d4, 0x39b4,
0x39b4, 0x3193, 0x3193, 0x3194, 0x3173, 0x2952, 0x2153, 0x2152, 0x2972,
0x2132, 0x2132, 0x2152, 0x2132, 0x2173, 0x2193, 0x1952, 0x1952, 0x2152,
0x1932, 0x1111, 0x2172, 0x2132, 0x2131, 0x2131, 0x2951, 0x2992, 0x2111,
0x2931, 0x2931, 0x3172, 0x2951, 0x2930, 0x2930, 0x2930, 0x3110, 0x3950,
0x292f, 0x3130, 0x822, 0x1063, 0x10a4, 0x8a6, 0x86, 0xa6, 0x885,
0xc7, 0x86, 0x86, 0x8c6, 0x865, 0x1907, 0xa5, 0xc8, 0x16a,
0x18b, 0x20d, 0x1cc, 0x22d, 0x28d, 0x310, 0x988, 0x1906, 0x841,
0x860, 0x20c2, 0x18a1, 0x840, 0x1060, 0x1081, 0x1881, 0x41a3, 0x3962,
0x3122, 0x20c2, 0x28e3, 0xcc50, 0xb3b0, 0xbc10, 0xccb0, 0xcc8f, 0xc490,
0xbc51, 0xa392, 0x8b33, 0x5a30, 0x8b35, 0x9396, 0x7357, 0x7cdd, 0x9dbf,
0xa5ff, 0xa63f, 0x9dff, 0x95bf, 0x957f, 0x855f, 0x853f, 0x6cbe, 0x6cde,
0x751f, 0x6cff, 0x64bf, 0x5c5f, 0x5c5f, 0x543e, 0x4bfe, 0x43de, 0x4bff,
0x4bdf, 0x439e, 0x3b7d, 0x3b7e, 0x333d, 0x333d, 0x335d, 0x2b1d, 0x333d,
0x22bc, 0x2afd, 0x2afd, 0x22bc, 0x22bc, 0x2adc, 0x22bc, 0x1a9b, 0x229b,
0x1a7b, 0x229b, 0x1a5a, 0x123a, 0x121a, 0x11fa, 0x9da, 0x9da, 0x9fa,
0x198, 0x9d9, 0x9d9, 0x1b8, 0x9d8, 0x198, 0x197, 0x1d7, 0x1b7,
0x11f7, 0x996, 0x11b6, 0x1195, 0x19b5, 0x21b5, 0x29b5, 0x29b5, 0x31d5,
0x29b5, 0x31d5, 0x39f5, 0x39b4, 0x39d4, 0x41b4, 0x3993, 0x41d4, 0x3173,
0x3193, 0x3193, 0x2973, 0x2973, 0x2953, 0x2973, 0x18f1, 0x2973, 0x2131,
0x2132, 0x2973, 0x29b3, 0x1932, 0x2152, 0x1932, 0x2152, 0x1932, 0x2152,
0x1931, 0x1911, 0x2132, 0x2131, 0x2993, 0x2131, 0x3152, 0x2931, 0x2931,
0x2931, 0x3172, 0x2931, 0x2930, 0x3130, 0x3151, 0x3150, 0x2930, 0x2950,
0x1042, 0x862, 0x10c6, 0x65, 0x85, 0xc6, 0x885, 0xa7, 0x45,
0x85, 0xe6, 0x8e6, 0x8a5, 0x18e7, 0xa5, 0x18a, 0x1cb, 0x1cc,
0x1cb, 0x24c, 0x24c, 0x2ee, 0x147, 0x10c6, 0x10a2, 0x1060, 0x18a1,
0x1881, 0x840, 0x1060, 0x1061, 0x1060, 0x49a3, 0x28c1, 0x20a0, 0x1060,
0x1861, 0x822a, 0xbc0f, 0xb3f0, 0xcc6f, 0xcc8f, 0xc470, 0xbc51, 0xabd2,
0x6a70, 0x59ee, 0x8b54, 0x8b95, 0x83f9, 0x84dd, 0x9ddf, 0xa5ff, 0x9dff,
0xa61f, 0x8d7e, 0x95bf, 0x853e, 0x7d1f, 0x74de, 0x7d3f, 0x6cde, 0x6cff,
0x5c5e, 0x5c9f, 0x543f, 0x4bfd, 0x43bd, 0x4bde, 0x4bde, 0x439d, 0x439e,
0x439e, 0x439e, 0x3b7e, 0x335d, 0x333d, 0x2afc, 0x2afc, 0x22bb, 0x2add,
0x22bc, 0x22bc, 0x22bc, 0x22bc, 0x229b, 0x22bb, 0x1a9b, 0x1a9b, 0x1a5a,
0x1a5a, 0x121a, 0x125a, 0x123a, 0x11fa, 0x9fa, 0x9d9, 0x9b9, 0x1b9,
0x1b8, 0x198, 0x1b9, 0x1b8, 0x1b8, 0x1d7, 0x9d7, 0x1b6, 0x9b6,
0x9b6, 0x9b5, 0x1195, 0x3a78, 0x1974, 0x2194, 0x2194, 0x2994, 0x29b4,
0x2994, 0x39d5, 0x3193, 0x41d4, 0x39b3, 0x39b3, 0x31b3, 0x3193, 0x3193,
0x3173, 0x2132, 0x1912, 0x2152, 0x2173, 0x2152, 0x18f1, 0x1931, 0x2152,
0x2152, 0x1152, 0x1932, 0x1911, 0x1911, 0x2193, 0x1932, 0x2131, 0x2131,
0x2111, 0x2972, 0x2152, 0x31b3, 0x2131, 0x2951, 0x2111, 0x2971, 0x2992,
0x1951, 0x2130, 0x2951, 0x2951, 0x2930, 0x3151, 0x18ce, 0x21, 0x843,
0x64, 0xa6, 0xa6, 0xa6, 0xa6, 0x8a6, 0x886, 0x65, 0xc7,
0x64, 0x8a5, 0x8a4, 0xa6, 0x129, 0xa0c, 0x20c, 0x1ca, 0x24c,
0x24c, 0xacf, 0x927, 0x10a5, 0x20, 0x1081, 0x18a1, 0x1080, 0x1060,
0x1081, 0x1060, 0x1060, 0x3962, 0x3963, 0x30e2, 0x20a1, 0x1881, 0x2043,
0xc44e, 0xc44f, 0xcc90, 0xd4b0, 0xccb0, 0xc471, 0x9331, 0x620e, 0x5a0d,
0x82f4, 0x9bd6, 0x9418, 0x847b, 0xa5ff, 0x9ddf, 0xa63f, 0x9dff, 0x8d9f,
0x8d9f, 0x8d7f, 0x7cfe, 0x7d1f, 0x7d1f, 0x751f, 0x64be, 0x64bf, 0x5c7f,
0x5c7f, 0x543f, 0x541f, 0x4bde, 0x43bd, 0x4bff, 0x3b5d, 0x3b7d, 0x3b7d,
0x3b5d, 0x333d, 0x333d, 0x331d, 0x331d, 0x2afd, 0x22dc, 0x22bc, 0x229b,
0x22bc, 0x22bc, 0x22bc, 0x229b, 0x1a9b, 0x1a7a, 0x229b, 0x1a7b, 0x1a5b,
0x121a, 0x123a, 0x121a, 0x121a, 0x9d9, 0x9d9, 0x1b8, 0x9d8, 0x1b9,
0x1b8, 0x1b8, 0x9d8, 0x1b7, 0x1b7, 0x9b7, 0x195, 0x995, 0x21d6,
0x1995, 0x29d6, 0x21b5, 0x2174, 0x2974, 0x2994, 0x29b4, 0x31d5, 0x31b4,
0x39f4, 0x39d4, 0x39d4, 0x31b3, 0x3173, 0x3994, 0x3994, 0x3193, 0x3173,
0x2132, 0x2132, 0x2152, 0x2153, 0x18f1, 0x2112, 0x2153, 0x1932, 0x1932,
0x1932, 0x1952, 0x2132, 0x2152, 0x2152, 0x2132, 0x2152, 0x2152, 0x2152,
0x2131, 0x1911, 0x2152, 0x2131, 0x2131, 0x2110, 0x2972, 0x2130, 0x1910,
0x2130, 0x2931, 0x2950, 0x2910, 0x2930, 0x1083, 0x843, 0x864, 0x10c6,
0xa6, 0x8e7, 0x65, 0x8a6, 0x10a6, 0xa5, 0x8a5, 0x864, 0x10c5,
0x84, 0xc6, 0x128, 0x18b, 0x16a, 0x189, 0x1c9, 0x22c, 0x22c,
0x8c5, 0x18c5, 0x840, 0x1061, 0x1881, 0x1880, 0x840, 0x18c2, 0x18a1,
0x1040, 0x3942, 0x30e1, 0x3963, 0x28a1, 0x1881, 0x1861, 0xcc4e, 0xd48f,
0xd4af, 0xd4d0, 0xdcf1, 0xbc50, 0x8310, 0x622e, 0x59ed, 0x8315, 0xa3d5,
0x9376, 0x8c3b, 0x9ddf, 0x9dff, 0x9e1f, 0x9ddf, 0x9ddf, 0x8d7f, 0x8d7f,
0x7d1f, 0x7d1f, 0x7d1f, 0x751f, 0x6cdf, 0x5c5f, 0x5c5f, 0x5c5f, 0x4c1e,
0x4bfe, 0x4bbd, 0x53de, 0x3b7d, 0x3b7d, 0x3b7d, 0x439e, 0x3b7e, 0x331d,
0x333d, 0x2b1d, 0x331d, 0x2afd, 0x2add, 0x22bc, 0x2afc, 0x22bc, 0x22bc,
0x22bc, 0x1a7b, 0x2afc, 0x1a9b, 0x1a9b, 0x127a, 0x1a5a, 0x125a, 0x123a,
0x123a, 0x121a, 0x9f9, 0x9d9, 0x9d9, 0x9d9, 0x9f8, 0x1b8, 0x1b8,
0x1b8, 0x1b7, 0x1b7, 0x1b7, 0x9d6, 0x9d6, 0x1196, 0x11b5, 0x9b5,
0x1195, 0x2194, 0x21b5, 0x2174, 0x2994, 0x2973, 0x39b5, 0x3194, 0x3193,
0x39b3, 0x3993, 0x3192, 0x3993, 0x2972, 0x2952, 0x2973, 0x2973, 0x3194,
0x2973, 0x2132, 0x2152, 0x2131, 0x2152, 0x2132, 0x2173, 0x1952, 0x1911,
0x1932, 0x1931, 0x2131, 0x2132, 0x2152, 0x10f0, 0x2192, 0x1911, 0x2131,
0x2131, 0x2172, 0x2151, 0x2972, 0x2951, 0x2951, 0x2951, 0x3151, 0x3130,
0x3171, 0x3970, 0x292f, 0x842, 0x10a4, 0x864, 0x10a6, 0x1928, 0x10a6,
0x10e7, 0x885, 0x844, 0x10c6, 0x10a5, 0x863, 0x1084, 0x10a5, 0x65,
0x929, 0x16b, 0x148, 0x147, 0x1a9, 0xa6e, 0x20b, 0x10e6, 0x842,
0x820, 0x1061, 0x1861, 0x1040, 0x20c2, 0x1060, 0x840, 0x1060, 0x4163,
0x28c0, 0x4163, 0x20a0, 0x1881, 0x1881, 0xa30b, 0xd4af, 0xd48e, 0xd4d0,
0xccb0, 0xcc90, 0x8af0, 0x6a4e, 0x620d, 0x62b4, 0xabf5, 0xa417, 0x9c7b,
0x9dbf, 0x9dff, 0x9dff, 0x95bf, 0x8d9f, 0x8d9f, 0x855f, 0x7d1f, 0x74ff,
0x74de, 0x751f, 0x5c7f, 0x5c5f, 0x5c5f, 0x541e, 0x545e, 0x53fe, 0x53dd,
0x53bd, 0x4bbd, 0x43be, 0x331c, 0x3b5d, 0x3b5d, 0x2adb, 0x333e, 0x333d,
0x331d, 0x331d, 0x2afd, 0x2add, 0x2adc, 0x22bc, 0x22bc, 0x1a9b, 0x1a9b,
0x1a9b, 0x1a7a, 0x125a, 0x1239, 0x1219, 0x121a, 0xa19, 0x9f9, 0x9fa,
0x9f9, 0x9f9, 0x9d9, 0x9d9, 0x1b9, 0x1b8, 0x198, 0x1b8, 0x1b8,
0x9f8, 0x1b7, 0x9b6, 0x9b6, 0x996, 0x995, 0x975, 0x995, 0x1975,
0x2175, 0x29b5, 0x21b4, 0x29b5, 0x31d5, 0x31b4, 0x3193, 0x39b4, 0x3173,
0x3193, 0x3193, 0x3193, 0x3173, 0x3173, 0x3173, 0x2952, 0x2973, 0x2132,
0x2952, 0x1911, 0x2132, 0x2132, 0x2932, 0x2153, 0x1932, 0x2152, 0x1932,
0x2152, 0x1911, 0x2152, 0x2972, 0x2131, 0x1911, 0x2151, 0x2111, 0x2932,
0x20f0, 0x2931, 0x2931, 0x2130, 0x2911, 0x3130, 0x3150, 0x3150, 0x3130,
0x310f, 0x821, 0x884, 0x10c6, 0x865, 0x886, 0x10c6, 0x10c5, 0x884,
0x884, 0x8c7, 0x10c4, 0x10a5, 0x1084, 0x884, 0x8a5, 0x66, 0x149,
0x148, 0x148, 0x189, 0xa6d, 0x1ca, 0x18c6, 0x18c4, 0x820, 0x1040,
0x18a1, 0x18a1, 0x1061, 0x1060, 0x840, 0x1881, 0x3901, 0x3901, 0x3901,
0x41a3, 0x1060, 0x2081, 0x48a4, 0xd48f, 0xdcae, 0xdcaf, 0xcc8f, 0xd4d0,
0x8aee, 0x724e, 0x6a2d, 0x5212, 0xa3f5, 0xac36, 0x945a, 0x953e, 0xa61f,
0xa5ff, 0x95bf, 0x8d9f, 0x8d7f, 0x8d7f, 0x6cbe, 0x7d1f, 0x6cbe, 0x74ff,
0x64bf, 0x5c5f, 0x5c5f, 0x541e, 0x541e, 0x5c1e, 0x5c1e, 0x53bd, 0x5c1e,
0x3b3c, 0x43be, 0x3b7c, 0x3b5d, 0x3b7d, 0x333d, 0x333d, 0x2b1d, 0x331d,
0x2afc, 0x22bc, 0x22bc, 0x22bc, 0x1a9b, 0x1a7b, 0x1a7b, 0x1a7b, 0x1a5b,
0x1a5a, 0x1a7a, 0x1a5a, 0x125a, 0x123a, 0x1219, 0x123a, 0x9f9, 0x9f9,
0x9d9, 0x9d9, 0x9d9, 0x198, 0x1b8, 0x1b8, 0x1b7, 0x1d7, 0x1b7,
0x196, 0x196, 0x176, 0x196, 0x1b6, 0x195, 0x1175, 0x21b5, 0x29b5,
0x2194, 0x2994, 0x3194, 0x31b4, 0x31b3, 0x39b4, 0x3993, 0x3193, 0x3173,
0x2973, 0x2973, 0x2952, 0x2952, 0x2953, 0x3173, 0x2973, 0x2973, 0x2952,
0x2152, 0x2172, 0x2152, 0x2152, 0x1911, 0x2193, 0x1952, 0x1911, 0x18f1,
0x1931, 0x1931, 0x1931, 0x1911, 0x1931, 0x2131, 0x20f0, 0x2111, 0x2972,
0x2131, 0x3192, 0x2931, 0x3151, 0x3971, 0x3951, 0x3130, 0x3150, 0x1063,
0x1084, 0x823, 0x864, 0x885, 0x10e6, 0x8c6, 0x864, 0x1083, 0x8c6,
0x84, 0x10c5, 0x1084, 0x10a5, 0x8c6, 0x18a, 0x129, 0x108, 0xe7,
0x127, 0x22d, 0x1ca, 0x18a6, 0x20e5, 0x1081, 0x1881, 0x20a2, 0x20c2,
0x1881, 0x1881, 0x1060, 0x18a1, 0x4142, 0x3901, 0x28e1, 0x3921, 0x1860,
0x1040, 0x2843, 0xdcac, 0xdcce, 0xdcef, 0xdcd0, 0xdd11, 0x932e, 0x7a8e,
0x59cc, 0x6232, 0xb457, 0xb457, 0xa4fc, 0x951d, 0xa63f, 0x959e, 0x9dff,
0x8d9f, 0x8d7f, 0x8d7f, 0x855f, 0x74ff, 0x74ff, 0x6cdf, 0x543d, 0x5c5f,
0x5c5f, 0x545f, 0x543f, 0x5c5f, 0x5bfd, 0x5bfe, 0x4b9c, 0x4b9d, 0x4b9d,
0x439d, 0x333c, 0x333c, 0x3b7e, 0x331d, 0x331d, 0x333d, 0x2afd, 0x2adc,
0x22bc, 0x22bc, 0x22bc, 0x1a9b, 0x1a7b, 0x22bc, 0x1a7a, 0x1a5a, 0x1a7a,
0x125a, 0x1a5a, 0x123a, 0x123a, 0x1219, 0x1219, 0x9f9, 0x9f9, 0x1b8,
0x1b8, 0x198, 0x1b8, 0x197, 0x1b7, 0x196, 0x1b7, 0x9d7, 0x196,
0x1b6, 0x175, 0x195, 0x1b6, 0x11b6, 0x19b5, 0x2995, 0x29b5, 0x31b4,
0x3194, 0x31b4, 0x31b3, 0x39b4, 0x3993, 0x31b3, 0x2972, 0x3173, 0x3173,
0x2932, 0x2932, 0x3173, 0x2972, 0x3152, 0x2931, 0x2932, 0x31b4, 0x2132,
0x2973, 0x2152, 0x2152, 0x2152, 0x2152, 0x2952, 0x2132, 0x2973, 0x2131,
0x2131, 0x2131, 0x1911, 0x2131, 0x2131, 0x2151, 0x2151, 0x2151, 0x2131,
0x2931, 0x2931, 0x3151, 0x3171, 0x2910, 0x2930, 0x842, 0x863, 0x2,
0x1084, 0x823, 0x885, 0x8a6, 0x863, 0x863, 0x10c5, 0x1084, 0x10a5,
0x10a4, 0x10a6, 0x8c6, 0x108, 0x149, 0x169, 0xe5, 0xe5, 0x20c,
0x989, 0x2168, 0x1882, 0x1040, 0x1060, 0x820, 0x820, 0x1881, 0x1061,
0x1060, 0x1040, 0x4142, 0x4982, 0x3122, 0x4183, 0x28c1, 0x20a1, 0x30e4,
0xdcee, 0xdcae, 0xdcce, 0xdcce, 0xdd10, 0xc492, 0x7a8e, 0x51cc, 0x51ce,
0xac15, 0xb456, 0xa4db, 0xa5bf, 0xae3f, 0xa61f, 0x95bf, 0x8d9f, 0x857f,
0x857f, 0x7d1f, 0x74fe, 0x74fe, 0x6cff, 0x5c7e, 0x647f, 0x5c7f, 0x543f,
0x4bfd, 0x53fd, 0x5bfe, 0x5c1e, 0x4b7c, 0x5bfe, 0x3afb, 0x4b7d, 0x4bfe,
0x335c, 0x331d, 0x331d, 0x2afd, 0x2afc, 0x2afd, 0x2adc, 0x22bc, 0x22bc,
0x229c, 0x22bc, 0x1a7b, 0x229c, 0x1a7b, 0x1a9b, 0x1a9b, 0x1a5a, 0x123a,
0x123a, 0x123a, 0xa19, 0xa19, 0x9f9, 0x9f9, 0x9d8, 0x9d9, 0x9d8,
0x1b8, 0x1b8, 0x1b7, 0x1b7, 0x196, 0x1b7, 0x176, 0x196, 0x196,
0x1b6, 0x195, 0x995, 0x1174, 0x1995, 0x1974, 0x1953, 0x2994, 0x2994,
0x2973, 0x31d4, 0x2973, 0x3193, 0x3173, 0x3194, 0x2953, 0x3173, 0x2952,
0x2993, 0x2952, 0x2972, 0x3193, 0x2972, 0x2952, 0x2132, 0x2152, 0x2152,
0x2131, 0x1131, 0x2152, 0x2132, 0x2952, 0x2932, 0x2131, 0x2151, 0x2131,
0x2152, 0x2151, 0x1931, 0x1951, 0x2131, 0x2110, 0x20d0, 0x2110, 0x2911,
0x2910, 0x2930, 0x2910, 0x290f, 0x822, 0x1083, 0x1064, 0x1085, 0x10a5,
0x44, 0x18e7, 0x10a4, 0x863, 0x8e5, 0x843, 0x10c5, 0x10a4, 0x18c4,
0x906, 0x84, 0x107, 0x127, 0xa6, 0xc6, 0x1ec, 0x9a9, 0x2147,
0x1062, 0x860, 0x1881, 0x1881, 0x20c2, 0x20c2, 0x1080, 0x840, 0x1881,
0x2060, 0x4181, 0x28c1, 0x3121, 0x28a0, 0x2081, 0x28a2, 0x3044, 0xdcac,
0xdccd, 0xdcce, 0xe530, 0xd530, 0x8af0, 0x59ed, 0x59ee, 0xc497, 0xc4b6,
0xb4da, 0xa5df, 0xa63f, 0x9ddf, 0x959f, 0x857f, 0x7d5f, 0x857f, 0x74ff,
0x74ff, 0x751f, 0x6cdf, 0x64bf, 0x543f, 0x543f, 0x5c3f, 0x5c5f, 0x53fd,
0x5c1e, 0x641f, 0x539d, 0x641e, 0x539d, 0x4b5c, 0x539d, 0x437d, 0x2b1c,
0x333d, 0x2b1d, 0x2afd, 0x2add, 0x331d, 0x2afd, 0x1a7b, 0x229c, 0x229b,
0x22bc, 0x1a9b, 0x1a9b, 0x1a7a, 0x1a7b, 0x1259, 0x1a5a, 0x1a5a, 0x1219,
0x121a, 0x9f9, 0x9f9, 0x9f9, 0x9f9, 0x9d9, 0x1b8, 0x1b8, 0x198,
0x197, 0x1b7, 0x197, 0x1b6, 0x196, 0x196, 0x1b6, 0x196, 0x196,
0x195, 0x995, 0x1174, 0x1974, 0x21d5, 0x21d5, 0x29d5, 0x2152, 0x31b4,
0x2973, 0x2993, 0x2952, 0x3173, 0x2932, 0x2932, 0x2973, 0x2993, 0x2932,
0x2972, 0x2972, 0x3193, 0x2111, 0x2131, 0x2131, 0x2152, 0x2151, 0x2132,
0x2952, 0x2111, 0x2132, 0x2131, 0x1931, 0x1951, 0x1931, 0x2131, 0x2131,
0x2131, 0x2131, 0x2972, 0x2131, 0x2110, 0x2931, 0x2951, 0x2951, 0x20f0,
0x2910, 0x2910});
img2 = (std::vector<uint16_t>{
0x20ee, 0x20ce, 0x20ce, 0x28ee, 0x28ee, 0x28ce, 0x28ce, 0x28ce, 0x28ae,
0x28ce, 0x28ae, 0x28ad, 0x288d, 0x286d, 0x286d, 0x286d, 0x206c, 0x206d,
0x204d, 0x284c, 0x282c, 0x200c, 0x280c, 0x280d, 0x280d, 0x280d, 0x280c,
0x280c, 0x280c, 0x280b, 0x280b, 0x280b, 0x280b, 0x280a, 0x300a, 0x380a,
0x3809, 0x400a, 0x480a, 0x500a, 0x580b, 0x600c, 0x680c, 0x700c, 0x780d,
0x880d, 0x900e, 0x800d, 0x800d, 0x800d, 0x700d, 0x680c, 0x580c, 0x580c,
0x500b, 0x500b, 0x500b, 0x480b, 0x480c, 0x500d, 0x480d, 0x480d, 0x480e,
0x480f, 0x480f, 0x400f, 0x400f, 0x4010, 0x4010, 0x4010, 0x4010, 0x4051,
0x4891, 0x48b2, 0x48f1, 0x48f1, 0x50f2, 0x5152, 0x5192, 0x59f3, 0x59f3,
0x5a33, 0x5a53, 0x5a73, 0x5a12, 0x6233, 0x6293, 0x6293, 0x6a93, 0x6b13,
0x6373, 0x6394, 0x63b3, 0x6bd4, 0x63d3, 0x5bf3, 0x5bf3, 0x53f3, 0x5bf3,
0x4bf3, 0x4c13, 0x33d2, 0x2391, 0x1350, 0x1b91, 0x1391, 0xb91, 0x370,
0x370, 0x350, 0x350, 0x350, 0x1390, 0x2391, 0x1b90, 0x1370, 0x1b90,
0x13af, 0x1390, 0x3d0, 0x411, 0x431, 0x431, 0x431, 0x431, 0x451,
0x471, 0x4b2, 0x4b2, 0x492, 0x492, 0x492, 0x492, 0x491, 0x451,
0x470, 0x491, 0x491, 0x4b1, 0x4b1, 0x4d1, 0x4d1, 0x511, 0x511,
0x532, 0x551, 0x552, 0x572, 0x592, 0x592, 0x5b2, 0x5f2, 0x5f3,
0x5f3, 0x612, 0x612, 0x632, 0x632, 0x632, 0x633, 0x194d, 0x2a10,
0x20ee, 0x210e, 0x20ee, 0x20ee, 0x20ee, 0x28ee, 0x20ce, 0x20ae, 0x28ce,
0x28ce, 0x28ae, 0x288e, 0x286e, 0x286d, 0x286d, 0x204d, 0x204d, 0x284d,
0x282c, 0x200c, 0x200c, 0x280c, 0x280c, 0x280c, 0x280c, 0x280c, 0x280c,
0x280c, 0x200b, 0x200b, 0x200b, 0x280b, 0x280a, 0x300a, 0x3809, 0x3809,
0x4009, 0x4809, 0x500a, 0x500a, 0x500b, 0x600a, 0x680a, 0x700b, 0x700c,
0x700c, 0x700c, 0x700c, 0x680c, 0x600b, 0x580b, 0x580c, 0x580b, 0x500b,
0x500b, 0x500b, 0x500c, 0x500c, 0x480c, 0x480d, 0x480d, 0x480e, 0x480e,
0x400f, 0x400f, 0x400f, 0x4010, 0x4010, 0x4010, 0x4031, 0x4851, 0x4871,
0x4891, 0x48d2, 0x48d1, 0x5112, 0x5152, 0x5993, 0x59b3, 0x5a13, 0x6273,
0x5ab3, 0x62b3, 0x62b3, 0x62f4, 0x62d4, 0x6af4, 0x6b54, 0x6373, 0x6394,
0x6394, 0x6bd4, 0x6bd4, 0x6bd4, 0x6bd4, 0x73d4, 0x72d3, 0x6c15, 0x4bf3,
0x4bf3, 0x33f2, 0x33d2, 0x2bd2, 0x23b1, 0x1bb1, 0xb91, 0x391, 0x390,
0x370, 0x390, 0x370, 0x350, 0x390, 0x370, 0x370, 0x370, 0x3b0,
0x3b0, 0x3d0, 0x3f1, 0x411, 0x431, 0x431, 0x451, 0x471, 0x471,
0x492, 0x492, 0x492, 0x4b2, 0x492, 0x491, 0x450, 0x471, 0x490,
0x4b1, 0x4b0, 0x4d1, 0x4f1, 0x511, 0x531, 0x531, 0x551, 0x552,
0x572, 0x592, 0x5b2, 0x5d2, 0x5d2, 0x5f3, 0x613, 0x613, 0x612,
0x633, 0x633, 0x633, 0x653, 0x5d2, 0x288d, 0x206d, 0x192e, 0x3250,
0x292f, 0x20ee, 0x28ee, 0x28ee, 0x28ee, 0x28ee, 0x28ce, 0x28ce, 0x28ce,
0x28ae, 0x288e, 0x286e, 0x286d, 0x286e, 0x284d, 0x202d, 0x200c, 0x200c,
0x200c, 0x280d, 0x280d, 0x280d, 0x280d, 0x280c, 0x280c, 0x280b, 0x200b,
0x280b, 0x280a, 0x280a, 0x2809, 0x3009, 0x3008, 0x3808, 0x4008, 0x4808,
0x5009, 0x5809, 0x5809, 0x6009, 0x700a, 0x700a, 0x780a, 0x780b, 0x800c,
0x800c, 0x780b, 0x800b, 0x880b, 0x880c, 0x800b, 0x780b, 0x780b, 0x780b,
0x680b, 0x580b, 0x500b, 0x500b, 0x500b, 0x500c, 0x500c, 0x480d, 0x480d,
0x480e, 0x480f, 0x480f, 0x500f, 0x5010, 0x5010, 0x5031, 0x4831, 0x5071,
0x58b1, 0x58d2, 0x58f2, 0x6132, 0x5973, 0x59b2, 0x6233, 0x59f3, 0x6213,
0x6293, 0x6ab4, 0x6a94, 0x6af4, 0x6b14, 0x6af4, 0x6af4, 0x6b54, 0x6b94,
0x6bd4, 0x6bf4, 0x6c14, 0x6c14, 0x6bf3, 0x5bf3, 0x4bf2, 0x3c12, 0x2bd2,
0x23b2, 0x23d1, 0x23b1, 0x1b91, 0xb91, 0x390, 0x370, 0x390, 0x390,
0x390, 0x3b0, 0x38f, 0x390, 0x3b0, 0x3b0, 0x3d0, 0x3f0, 0x411,
0x431, 0x452, 0x451, 0x492, 0x4b2, 0x4b2, 0x4b2, 0x4b2, 0x492,
0x4d2, 0x4f3, 0x4d2, 0x4d2, 0x491, 0x490, 0x4b1, 0x4d1, 0x4f1,
0x511, 0x531, 0x551, 0x551, 0x551, 0x571, 0x592, 0x5b2, 0x5d2,
0x5d2, 0x5f2, 0x5f3, 0x5f3, 0x612, 0x632, 0x632, 0x633, 0x633,
0x5f2, 0x4f1, 0x450, 0x290f, 0x288e, 0x208d, 0x286d, 0x292f, 0x3ab1,
0x292f, 0x28ae, 0x310f, 0x28ef, 0x288e, 0x28cf, 0x28ae, 0x286d, 0x288e,
0x288e, 0x284e, 0x202c, 0x202d, 0x282d, 0x200c, 0x200c, 0x200b, 0x200b,
0x200b, 0x280c, 0x200c, 0x200c, 0x200b, 0x280b, 0x280b, 0x280a, 0x2809,
0x2809, 0x3009, 0x3008, 0x3807, 0x4008, 0x4007, 0x4808, 0x5007, 0x5808,
0x5808, 0x6008, 0x6809, 0x7009, 0x700a, 0x700a, 0x800a, 0x880b, 0x800a,
0x780a, 0x780b, 0x800b, 0x780a, 0x680a, 0x600a, 0x600a, 0x580a, 0x580b,
0x500b, 0x580b, 0x500b, 0x580b, 0x500b, 0x500c, 0x500d, 0x480d, 0x500e,
0x500f, 0x5010, 0x5010, 0x5010, 0x5810, 0x5811, 0x5872, 0x58b2, 0x58d2,
0x6133, 0x6153, 0x61b3, 0x6213, 0x6233, 0x6233, 0x6253, 0x6a94, 0x6ad4,
0x6ad4, 0x6af4, 0x6af4, 0x6b14, 0x7334, 0x7374, 0x7394, 0x73b4, 0x63f4,
0x5c13, 0x6414, 0xc295, 0xda15, 0xd255, 0xca74, 0xca74, 0xc295, 0xba94,
0xbad4, 0xbab4, 0xb2d4, 0xaaf4, 0xa2d4, 0x9af4, 0x9334, 0x8b33, 0x8334,
0x7b33, 0x7bb3, 0x1c11, 0x3b0, 0x3d0, 0x3f1, 0x431, 0xc52, 0x1471,
0x1471, 0x1cb2, 0x1cb2, 0x1cd2, 0x4f3, 0x4d2, 0x4b2, 0x4f2, 0x4f2,
0x513, 0x4f2, 0x4d1, 0x4b1, 0x4d1, 0x4f2, 0x4f1, 0x531, 0x552,
0x552, 0x572, 0x592, 0x5b2, 0x5b2, 0x5d2, 0x5f3, 0x5f2, 0x613,
0x613, 0x612, 0x632, 0x633, 0x633, 0x5f2, 0x511, 0x451, 0x34f,
0x24e, 0x4b72, 0x4ad2, 0x3110, 0x288f, 0x286e, 0x204d, 0x28ee, 0x4291,
0x28cf, 0x286f, 0x202e, 0x280d, 0x200d, 0x280d, 0x200c, 0x280c, 0x200c,
0x200c, 0x280c, 0x280b, 0x280b, 0x280b, 0x280b, 0x280b, 0x300c, 0x300b,
0x300c, 0x280d, 0x300e, 0x300d, 0x300d, 0x300d, 0x300c, 0x300c, 0x300b,
0x380b, 0x380b, 0x380a, 0x400a, 0x400a, 0x4809, 0x500a, 0x5009, 0x580a,
0x600a, 0x680a, 0x680a, 0x700b, 0x780c, 0x800d, 0x780d, 0x700c, 0x700c,
0x780d, 0x680c, 0x680b, 0x680c, 0x700c, 0x700c, 0x700d, 0x700d, 0x680d,
0x680d, 0x600d, 0x600d, 0x580e, 0x580e, 0x500f, 0x500f, 0x500f, 0x5010,
0x5010, 0x5811, 0x6031, 0x6051, 0x5871, 0x58f2, 0x6132, 0x6173, 0x6173,
0x61b3, 0x6233, 0x6273, 0x6a93, 0x6a94, 0x62b3, 0x6af4, 0x6af4, 0x6b34,
0x7394, 0x7394, 0x73b5, 0x73b4, 0x73b4, 0x7414, 0x6c34, 0x6434, 0x5453,
0x5413, 0x4c13, 0x4412, 0x3c12, 0x3412, 0x3c12, 0x3412, 0x23f1, 0x1bf1,
0xbb1, 0x3b1, 0x370, 0x390, 0x3b0, 0x3f0, 0x3d0, 0x3f0, 0x411,
0x411, 0x452, 0x451, 0x471, 0x451, 0xc71, 0x24b2, 0x2cd2, 0x2cb2,
0x3513, 0x4533, 0x4d33, 0x3512, 0x4553, 0x4d33, 0x2d33, 0x512, 0x533,
0x512, 0x4f1, 0x511, 0x511, 0x552, 0x572, 0x592, 0x5b2, 0x5b2,
0x5d2, 0x5f2, 0x5f3, 0x612, 0x632, 0x632, 0x632, 0x653, 0x653,
0x653, 0x612, 0x531, 0x470, 0x36f, 0xa4e, 0x118d, 0x10ed, 0x4392,
0x5393, 0x5bb3, 0x7bd6, 0x38ef, 0x2850, 0x204d, 0x280f, 0x204d, 0x62d4,
0x3930, 0x30f0, 0x30b0, 0x308f, 0x308f, 0x30b0, 0x30f0, 0x30b0, 0x3090,
0x282f, 0x280e, 0x302f, 0x300f, 0x300f, 0x3010, 0x300f, 0x300f, 0x380f,
0x380f, 0x300f, 0x300e, 0x380e, 0x380d, 0x380d, 0x380d, 0x380d, 0x400d,
0x480d, 0x480c, 0x500c, 0x500c, 0x500b, 0x580b, 0x600c, 0x600b, 0x680b,
0x700c, 0x780c, 0x800d, 0x800d, 0x800d, 0x800d, 0x800d, 0x800e, 0x700d,
0x700d, 0x700d, 0x700d, 0x700d, 0x680d, 0x680d, 0x600d, 0x580e, 0x580d,
0x580e, 0x580e, 0x580f, 0x580f, 0x5810, 0x600f, 0x6010, 0x6010, 0x6010,
0x6031, 0x6051, 0x68b2, 0x60d2, 0x6112, 0x6153, 0x6193, 0x61b3, 0x6213,
0x6273, 0x6a93, 0x6ab4, 0x6af4, 0x6af4, 0x6b14, 0x7334, 0x7334, 0x7394,
0x7bd4, 0x7b94, 0x7bb4, 0x7bf5, 0x7c14, 0x7c74, 0x7494, 0x6cb4, 0x5c73,
0x5453, 0x5493, 0x4c52, 0x4c53, 0x3c52, 0x2c11, 0x2c32, 0x2c32, 0x2c72,
0x6d16, 0x6cf5, 0x6515, 0x6514, 0x64f4, 0x34b2, 0x1c71, 0x1c71, 0x1471,
0x1cd2, 0x24d2, 0x3cd2, 0x54f3, 0x5d33, 0x5d33, 0x5d74, 0x6d54, 0xc516,
0xd516, 0xdd16, 0xdd97, 0xd5b7, 0xbe58, 0x553, 0x553, 0x553, 0x552,
0x552, 0x572, 0x592, 0x5b2, 0x5b2, 0x5d2, 0x5f2, 0x5f3, 0x5f3,
0x612, 0x632, 0x633, 0x653, 0x653, 0x653, 0x613, 0x551, 0x470,
0x38f, 0x24d, 0x118d, 0x18ed, 0x188b, 0x188b, 0x3352, 0x4372, 0x53b3,
0x6394, 0x6b94, 0x72d5, 0x308f, 0x3010, 0x280f, 0x280e, 0x202e, 0x6a95,
0x38f0, 0x3070, 0x3070, 0x3070, 0x306f, 0x3090, 0x3890, 0x3830, 0x300f,
0x300f, 0x300f, 0x3010, 0x380f, 0x400f, 0x400f, 0x380f, 0x380e, 0x380e,
0x380e, 0x380d, 0x400e, 0x400e, 0x480e, 0x480d, 0x500d, 0x580e, 0x580d,
0x580d, 0x580d, 0x600c, 0x600b, 0x680c, 0x700c, 0x700c, 0x700c, 0x780d,
0x880d, 0x900e, 0x900e, 0x800e, 0x900e, 0x980f, 0x800e, 0x780d, 0x780d,
0x780e, 0x800e, 0x800e, 0x780e, 0x700d, 0x700e, 0x680e, 0x680e, 0x680e,
0x600e, 0x600f, 0x600f, 0x600f, 0x6010, 0x6810, 0x6810, 0x6831, 0x6871,
0x68b2, 0x68d2, 0x7112, 0x6912, 0x6972, 0x6993, 0x69b3, 0x69f3, 0x6a34,
0x6a54, 0x6a74, 0x6a94, 0x72b4, 0x7ad4, 0x7b14, 0x7314, 0x7b34, 0x7b14,
0x8314, 0x8355, 0x8395, 0x8b95, 0xd274, 0xda75, 0xda95, 0xdab5, 0xd2b5,
0xd2b5, 0xd2d5, 0xcaf5, 0xcb14, 0xc2f4, 0xbb34, 0x9bf5, 0x8c55, 0x8475,
0x8475, 0x8515, 0x6d34, 0x24b2, 0x24b2, 0x1c91, 0x2491, 0x2cd2, 0x2cd3,
0x4513, 0x5d33, 0x6553, 0x6d54, 0x7d74, 0x8574, 0x8595, 0x8595, 0x8594,
0x7d94, 0x6d74, 0x5553, 0x2574, 0xd73, 0x5b4, 0x5d4, 0x5b3, 0x5b3,
0x5b3, 0x5d3, 0x5f3, 0x5f3, 0x613, 0x633, 0x653, 0x653, 0x653,
0x6b4, 0x694, 0x653, 0x531, 0x491, 0x38f, 0x24d, 0x198e, 0x18ec,
0x18ab, 0x188a, 0x188b, 0x188b, 0x3332, 0x3352, 0x4372, 0x5393, 0x5b94,
0x6b54, 0x72d3, 0x8275, 0x4050, 0x3810, 0x300f, 0x300f, 0x300e, 0x7a76,
0x3850, 0x3010, 0x400f, 0x400f, 0x400f, 0x480f, 0x480f, 0x500e, 0x500d,
0x500e, 0x500d, 0x500d, 0x500d, 0x580d, 0x580c, 0x580b, 0x600c, 0x500d,
0x480d, 0x480d, 0x480d, 0x480d, 0x500d, 0x500d, 0x500d, 0x580c, 0x580b,
0x580b, 0x600b, 0x680b, 0x680b, 0x700b, 0x780b, 0x800c, 0x880d, 0x880d,
0x880d, 0x800d, 0x880d, 0x900d, 0x800d, 0x800d, 0x800d, 0x800e, 0x800e,
0x800e, 0x800e, 0x700d, 0x700d, 0x680d, 0x680d, 0x680e, 0x680e, 0x680e,
0x680f, 0x680f, 0x680f, 0x6810, 0x6810, 0x6810, 0x6831, 0x7051, 0x68b2,
0x70f2, 0x7132, 0x6953, 0x6993, 0x6993, 0x69b3, 0x69f3, 0x6a34, 0x7213,
0x7a54, 0x7a53, 0x7a94, 0x72d4, 0x7ab4, 0x7ad5, 0x7b34, 0x8355, 0x8375,
0x8395, 0x8b95, 0x8b94, 0x9395, 0x93f5, 0x8c55, 0x7454, 0x7c74, 0x7454,
0x6453, 0x5412, 0x4412, 0x3c31, 0x33f1, 0x2c12, 0x3c11, 0x4c72, 0x3c51,
0x3472, 0x2471, 0x1c72, 0x1c92, 0x1491, 0xc91, 0x14b2, 0x24f3, 0x2d13,
0x4513, 0x7594, 0xc516, 0xccf6, 0xcd36, 0xdd56, 0xe557, 0xe577, 0xe597,
0xe5d8, 0xde18, 0xc677, 0x1dd4, 0x5d3, 0x5d3, 0x5f3, 0x613, 0x613,
0x613, 0x633, 0x653, 0x653, 0x653, 0x653, 0x673, 0x674, 0x552,
0x450, 0x36f, 0xa4e, 0x116d, 0x18ec, 0x18ac, 0x188b, 0x18ab, 0x18ab,
0x10ab, 0x18cc, 0x3312, 0x3b32, 0x4372, 0x4b73, 0x5b93, 0x6394, 0x6b14,
0x72b4, 0x8a94, 0x9a94, 0x5030, 0x5830, 0x4810, 0x480f, 0x400e, 0x9ab8,
0x480f, 0x4010, 0x4010, 0x400f, 0x400f, 0x4811, 0x4810, 0x5010, 0x500f,
0x480f, 0x480f, 0x480f, 0x500f, 0x500f, 0x500e, 0x580e, 0x500e, 0x500d,
0x500d, 0x500d, 0x580d, 0x580d, 0x580d, 0x600d, 0x600c, 0x600c, 0x600b,
0x680b, 0x680a, 0x700b, 0x780c, 0x800c, 0x900d, 0x980e, 0x900d, 0x880d,
0x900e, 0xa00e, 0x900d, 0x880d, 0x900d, 0x880e, 0x900e, 0x880e, 0x880e,
0x880d, 0x780d, 0x780d, 0x700d, 0x700d, 0x700e, 0x700e, 0x700e, 0x700f,
0x780f, 0x7810, 0x7010, 0x7810, 0x7811, 0x7811, 0x7872, 0x78d2, 0x7912,
0x8152, 0x7992, 0x79b3, 0x79b3, 0x79f3, 0x79f3, 0x7a13, 0x7a33, 0x8233,
0x8a74, 0x8a94, 0x9294, 0x92d4, 0x8af4, 0x8b55, 0x8b75, 0x8b75, 0xbaf5,
0xcab4, 0xc2b4, 0xbad4, 0xb2f4, 0xb314, 0xb354, 0xb355, 0xb334, 0xb3b5,
0xa3b5, 0x7cb5, 0x7cb6, 0x7cb5, 0x74d5, 0x64d4, 0x3492, 0x2c71, 0x2c91,
0x2c92, 0x2492, 0x1cb2, 0x1cb2, 0x2cd3, 0x4533, 0x4d13, 0x5d53, 0x6d53,
0x7db4, 0x85b4, 0x7db4, 0x85b4, 0x85d5, 0x7dd5, 0x85d4, 0x75f5, 0x5df5,
0x1df5, 0x614, 0x614, 0x634, 0x634, 0x633, 0x613, 0x633, 0x653,
0x653, 0x653, 0x653, 0x653, 0x531, 0x470, 0x36f, 0x22e, 0x118d,
0x18cc, 0x188c, 0x18ab, 0x18ab, 0x18ab, 0x18ac, 0x18cd, 0x18ec, 0x18ed,
0x3312, 0x3b12, 0x4332, 0x4b73, 0x5373, 0x5b73, 0x6b53, 0x6b14, 0x7294,
0x8a94, 0x9274, 0xb2d4, 0x9152, 0x7011, 0x600f, 0x600f, 0x580e, 0xbaf7,
0x6011, 0x5810, 0x580f, 0x600f, 0x600f, 0x600f, 0x6810, 0x680f, 0x600f,
0x580e, 0x600e, 0x680e, 0x600e, 0x600e, 0x600e, 0x680d, 0x680d, 0x680d,
0x680d, 0x680d, 0x700d, 0x700d, 0x680d, 0x700c, 0x700c, 0x700c, 0x780c,
0x780c, 0x880c, 0x900d, 0xa80e, 0xb80f, 0xb00f, 0xa00f, 0xb80f, 0xc810,
0xa80f, 0xa00f, 0xa810, 0xb00f, 0xb010, 0xa00f, 0xa00f, 0x980f, 0x900e,
0x880e, 0x880e, 0x800e, 0x800e, 0x800f, 0x780f, 0x800f, 0x780f, 0x8010,
0x8010, 0x8811, 0x8811, 0x8851, 0x8891, 0x8912, 0x8932, 0x9172, 0x8992,
0x91b3, 0x91f4, 0x89f3, 0x9213, 0x9213, 0xa233, 0xaa53, 0xb274, 0xc294,
0xc274, 0xb294, 0xa2d4, 0x9af4, 0x9b14, 0x9b35, 0xa335, 0xa374, 0x9b94,
0xa3b5, 0x9c15, 0x9c55, 0x9c76, 0x9c95, 0x94b5, 0x94d6, 0x6cb4, 0x6cd4,
0x6cf4, 0x6cf4, 0x5cd3, 0x5d14, 0x54d3, 0x4cf3, 0x4d13, 0x4cf3, 0x3d13,
0x3d13, 0x4512, 0x4d13, 0x6d54, 0x75b5, 0x85d5, 0x8dd5, 0x95f5, 0x95d5,
0xa616, 0xa616, 0xa615, 0xa636, 0x9615, 0x8e35, 0x6e35, 0x3635, 0x655,
0x634, 0x654, 0x654, 0x674, 0x694, 0x694, 0x674, 0x694, 0x673,
0x552, 0x490, 0x36f, 0xa2e, 0x116d, 0x10ec, 0x18ac, 0x188b, 0x18ac,
0x18ac, 0x18ac, 0x18ed, 0x18ed, 0x190d, 0x118e, 0xa4f, 0x3ad1, 0x3af2,
0x4312, 0x4b32, 0x5353, 0x5b53, 0x6313, 0x6b34, 0x6ab4, 0x7a94, 0x8254,
0x9a73, 0xb2b5, 0xc2b4, 0xc215, 0x9031, 0x8010, 0x800f, 0x8810, 0xd2b8,
0x7831, 0x7810, 0x8810, 0x8810, 0x8811, 0x9010, 0x8810, 0x8010, 0x780f,
0x780f, 0x780f, 0x780e, 0x800f, 0x800f, 0x800f, 0x800f, 0x880f, 0x880f,
0x880f, 0x880f, 0x880f, 0x880f, 0x880e, 0x880e, 0x880d, 0x900d, 0x980d,
0xa00e, 0xb80f, 0xc00f, 0xb00f, 0xb00f, 0xb80f, 0xc810, 0xb00f, 0xa00f,
0xa80f, 0xa80f, 0xa80f, 0xa00f, 0xa00f, 0x980f, 0x900f, 0x900e, 0x880e,
0x880e, 0x880e, 0x880f, 0x880f, 0x900f, 0x900f, 0x900f, 0x9810, 0x9811,
0x9811, 0x9811, 0x9031, 0x98b1, 0x98d1, 0xa112, 0xa172, 0x9992, 0x99d3,
0x99d3, 0x99f3, 0x99f3, 0xa9f3, 0xba13, 0xca34, 0xda14, 0xd9d4, 0xc2b4,
0xb2f4, 0xa2d4, 0x9af4, 0x9b35, 0x9355, 0x9375, 0x93b5, 0x93f5, 0x9455,
0x8c95, 0x8cb5, 0x9495, 0x94d5, 0xb3d5, 0xbbb5, 0xbb94, 0xb3d4, 0xac14,
0x7514, 0x6514, 0x5d13, 0x5d33, 0x5513, 0x4d13, 0x4513, 0x4d13, 0x4d33,
0x5553, 0xc4f6, 0xdd56, 0xe577, 0xe597, 0xe5b7, 0x8db4, 0x8dd5, 0x85b4,
0x85d4, 0x75d4, 0x7e15, 0x8656, 0x6e55, 0x2e95, 0x675, 0x695, 0x695,
0x695, 0x694, 0x694, 0x6b4, 0x673, 0x572, 0x450, 0x32f, 0xa0e,
0x194d, 0x10cc, 0x18ab, 0x18ac, 0x18ac, 0x18ac, 0x18cc, 0x18ed, 0x190d,
0x114d, 0x120f, 0x1270, 0x1270, 0x1270, 0x42b2, 0x42d2, 0x42d1, 0x4af2,
0x5313, 0x5b13, 0x5af3, 0x62d4, 0x6a93, 0x7294, 0x7a53, 0x8a54, 0xa2b4,
0xb294, 0xc294, 0xd2f5, 0xe296, 0xa831, 0xa812, 0xa811, 0xa010, 0xead8,
0xa011, 0xa011, 0x9811, 0xa010, 0x9810, 0xa011, 0xa011, 0x9811, 0x900f,
0x900f, 0x9010, 0x9010, 0x9810, 0xa010, 0x9810, 0x9810, 0x9810, 0x9810,
0x980f, 0x980f, 0x900f, 0x900f, 0x900e, 0x900e, 0x980e, 0xa00e, 0xb80e,
0xc80f, 0xb80f, 0xb80f, 0xc00f, 0xd010, 0xb80f, 0xb00f, 0xb00f, 0xb010,
0xb00f, 0xa80e, 0xa80e, 0xa00f, 0xa00e, 0x980e, 0x900e, 0x980e, 0x980e,
0x980e, 0xa00f, 0xa010, 0xa010, 0xa010, 0xa811, 0xa811, 0xb011, 0xa811,
0xa811, 0xa832, 0xa872, 0xa8d3, 0xa8f2, 0xa172, 0xa193, 0xa1d3, 0x99d3,
0x99f3, 0xa213, 0xaa53, 0xaa53, 0xb273, 0xb294, 0xb2d4, 0xaaf4, 0xa314,
0xa314, 0x9b35, 0x9334, 0x9354, 0x8b95, 0x8bd5, 0x9415, 0x9435, 0x8c75,
0x8c95, 0x8cd5, 0x84d5, 0x94f5, 0x9515, 0x9576, 0x8555, 0x7d35, 0x7534,
0x6d54, 0x6534, 0x5d13, 0x5d33, 0x5553, 0x5d33, 0x5533, 0x95f6, 0xb617,
0xc617, 0xd5f7, 0xbe17, 0x9dd5, 0xa615, 0xae36, 0xb656, 0xb656, 0xc697,
0xbe97, 0xbeb7, 0xa677, 0x76d7, 0x16b6, 0x695, 0x6b5, 0x6b4, 0x6b4,
0x694, 0x572, 0x491, 0x34f, 0xa0d, 0x114d, 0x18ed, 0x18ac, 0x18ac,
0x18cd, 0x18cd, 0x18ed, 0x190d, 0x192d, 0x118e, 0x1a71, 0x1290, 0x124f,
0x124f, 0x1270, 0x1270, 0x3a31, 0x4272, 0x4a72, 0x4a92, 0x4a92, 0x52b2,
0x6293, 0x6273, 0x6253, 0x6a13, 0x7213, 0x8213, 0x9254, 0xa253, 0xb294,
0xcab4, 0xd294, 0xe2b5, 0xf2f6, 0xc031, 0xc813, 0xc012, 0xc012, 0xf2b9,
0xb831, 0xc032, 0xc012, 0xc012, 0xc011, 0xc012, 0xb812, 0xb011, 0xa810,
0xa810, 0xa810, 0xa810, 0xa810, 0xa810, 0xa810, 0xa810, 0xa010, 0xa010,
0xa00f, 0xa00f, 0xa00e, 0xa00e, 0xa00e, 0xa80e, 0xb80e, 0xc80e, 0xc00e,
0xb80e, 0xc80f, 0xd00f, 0xc00f, 0xb80f, 0xc00f, 0xc00f, 0xb80f, 0xb00f,
0xb00f, 0xa80f, 0xa00e, 0xa00e, 0xa00e, 0xa00f, 0xa00f, 0xa00e, 0xa80f,
0xa810, 0xa810, 0xb010, 0xb011, 0xb011, 0xb012, 0xb012, 0xb012, 0xb012,
0xb092, 0xb0f2, 0xb112, 0xb173, 0xb1b3, 0xa9d3, 0xa9f3, 0xb213, 0xb233,
0xba54, 0xba54, 0xba74, 0xba94, 0xb2b4, 0xb2d4, 0xaaf4, 0xc2d4, 0xdab5,
0xdad5, 0xdaf5, 0xdaf5, 0xd335, 0xd316, 0xd336, 0xcb55, 0xc3b5, 0xcbb6,
0xc3b5, 0xc3b5, 0xb3f6, 0x9c95, 0x7d34, 0x7d34, 0x7534, 0x7534, 0x7554,
0x6d54, 0x6d54, 0x6d74, 0x7d34, 0xbd57, 0xc577, 0xcd57, 0xd597, 0xadf6,
0x95d4, 0x9df5, 0xae16, 0xae16, 0xb636, 0xc677, 0xbe76, 0xbe77, 0xbe97,
0xa696, 0x76b7, 0x1ed6, 0x6d6, 0x6d5, 0x6b5, 0x592, 0x490, 0x32f,
0xa0e, 0x192e, 0x18cd, 0x18cd, 0x18ed, 0x18ed, 0x18ee, 0x18ee, 0x190e,
0x114d, 0x122f, 0x12b0, 0x12d0, 0x12b0, 0x1a50, 0x1a70, 0x1270, 0x1a70,
0x1291, 0x4171, 0x41b1, 0x49d1, 0x49f2, 0x51f2, 0x51f2, 0x5213, 0x59f3,
0x59f3, 0x61d3, 0x69b3, 0x79f3, 0x8a13, 0x9a33, 0xaa33, 0xba74, 0xca74,
0xda95, 0xe2b5, 0xead6, 0xf2f7, 0xc812, 0xd812, 0xd812, 0xd812, 0xfa78,
0xd013, 0xc812, 0xd012, 0xc812, 0xd013, 0xd013, 0xd013, 0xc812, 0xc812,
0xc811, 0xc011, 0xc011, 0xc011, 0xc011, 0xb810, 0xb810, 0xb810, 0xb810,
0xb80f, 0xb00f, 0xb00e, 0xb80e, 0xc80e, 0xd00e, 0xc80e, 0xc00d, 0xd00e,
0xe00f, 0xc80e, 0xc00e, 0xc80f, 0xc00f, 0xc00f, 0xb80f, 0xb80f, 0xb00f,
0xa80e, 0xa80e, 0xa00e, 0xa00e, 0xa80e, 0xa80e, 0xa80f, 0xb010, 0xb010,
0xb011, 0xb011, 0xb011, 0xb812, 0xb812, 0xb812, 0xb812, 0xb893, 0xb8d2,
0xb933, 0xb953, 0xb973, 0xb1b3, 0xb1b3, 0xb1f3, 0xba33, 0xc254, 0xc274,
0xca94, 0xc274, 0xc294, 0xbad4, 0xb2d4, 0xe2b5, 0xeab5, 0xe2b5, 0xe2b6,
0xe2b5, 0xe2d5, 0xe2f6, 0xe316, 0xdb75, 0xc3d5, 0xc3b5, 0xc3d5, 0xbbf5,
0xac35, 0x9cf5, 0x9535, 0x9555, 0x9555, 0x9d56, 0x9556, 0x9555, 0x8d35,
0x8555, 0xa575, 0xa596, 0xbdd7, 0xc5d7, 0xed77, 0xedb7, 0xedd7, 0xf5f8,
0xf618, 0xe658, 0xee78, 0xee98, 0xf6d8, 0xf6d9, 0xf6f9, 0xef19, 0xcf38,
0x46f7, 0x6f6, 0x5b3, 0x4b1, 0x30f, 0x11ee, 0x194e, 0x18ce, 0x18ce,
0x18ee, 0x190e, 0x190e, 0x192e, 0x194e, 0x11ce, 0x1ab1, 0x1ab0, 0x1ab0,
0x1ab1, 0x1ab0, 0x1ab0, 0x1ab1, 0x1250, 0x1a90, 0x1a91, 0x1290, 0x3890,
0x38b0, 0x38d0, 0x40f1, 0x4111, 0x4932, 0x4932, 0x5152, 0x5972, 0x6153,
0x6953, 0x7193, 0x8172, 0x99d3, 0xa213, 0xba33, 0xca54, 0xd275, 0xda54,
0xead6, 0xf2b6, 0xf2f7, 0xf336, 0xd031, 0xe814, 0xe832, 0xe813, 0xfab9,
0xe013, 0xe013, 0xd813, 0xd812, 0xd812, 0xd812, 0xd812, 0xe032, 0xd811,
0xd811, 0xd811, 0xd811, 0xd811, 0xd811, 0xd811, 0xd811, 0xd011, 0xd010,
0xd010, 0xd810, 0xe010, 0xe810, 0xe00f, 0xd80f, 0xe80e, 0xf80f, 0xe00f,
0xe00f, 0xe00f, 0xe010, 0xe00f, 0xd80f, 0xd80f, 0xd00f, 0xd00f, 0xd00e,
0xd00e, 0xd00f, 0xd00f, 0xd010, 0xd010, 0xd011, 0xd011, 0xd011, 0xd812,
0xd812, 0xd813, 0xd813, 0xd813, 0xd813, 0xd894, 0xe114, 0xd954, 0xd994,
0xd9d4, 0xd9f4, 0xda14, 0xda14, 0xda54, 0xda55, 0xda75, 0xdab5, 0xdab5,
0xd2d4, 0xd2f5, 0xd2f5, 0xf295, 0xf2b5, 0xf295, 0xf2b5, 0xf2d6, 0xeaf5,
0xeaf6, 0xeb15, 0xd3f6, 0xbc76, 0xc435, 0xcc56, 0xcc56, 0xbc96, 0xb496,
0xacd6, 0xad16, 0xc3d4, 0xc3d4, 0xc435, 0xbc76, 0xbcb6, 0xbcd6, 0xccf6,
0xcd37, 0xd597, 0xddd7, 0xddd7, 0xe5d7, 0xe617, 0xee18, 0xf658, 0xf678,
0xf698, 0xfeb9, 0xfed9, 0xff19, 0xff1a, 0xf759, 0xdf5a, 0xdf3, 0x4d2,
0x32f, 0x220f, 0x212f, 0x20cf, 0x28cf, 0x28ef, 0x210f, 0x212f, 0x216f,
0x118f, 0x1a50, 0x22d1, 0x2311, 0x22d1, 0x22b1, 0x2291, 0x2291, 0x22b1,
0x22d1, 0x2291, 0x1a70, 0x1ab1, 0x1ab1, 0x1a91, 0x300f, 0x300f, 0x300f,
0x3810, 0x4030, 0x4871, 0x4891, 0x4891, 0x58d2, 0x58d2, 0x60f2, 0x7132,
0x7932, 0x9172, 0xa193, 0xb1d3, 0xc1f4, 0xd234, 0xda34, 0xea55, 0xeab5,
0xf2b6, 0xfaf6, 0xfb16, 0xfb36, 0xe174, 0xf014, 0xf032, 0xf013, 0xfa98,
0xe033, 0xe834, 0xe813, 0xe813, 0xe813, 0xe813, 0xe813, 0xe812, 0xe812,
0xe812, 0xe812, 0xe811, 0xe811, 0xe811, 0xe811, 0xe811, 0xe011, 0xe811,
0xf011, 0xf011, 0xf010, 0xe810, 0xf010, 0xf810, 0xf010, 0xf00f, 0xf010,
0xf010, 0xf010, 0xe810, 0xe810, 0xe810, 0xe810, 0xe810, 0xe80f, 0xe80f,
0xe810, 0xe810, 0xe811, 0xe811, 0xe811, 0xe812, 0xe812, 0xe812, 0xe813,
0xe813, 0xe813, 0xe834, 0xe8b4, 0xe914, 0xe974, 0xe974, 0xf1b5, 0xe9b4,
0xe9d4, 0xe9d5, 0xf1f5, 0xe9f5, 0xf235, 0xf255, 0xfab6, 0xfaf6, 0xf316,
0xf336, 0xf356, 0xf396, 0xeb76, 0xebb6, 0xf416, 0xf417, 0xec16, 0xf477,
0xf456, 0xec76, 0xf476, 0xec96, 0xe4b6, 0xdcd6, 0xdcb6, 0xdcf6, 0xd4f6,
0xd517, 0xd557, 0xcd57, 0xcd98, 0xcdd7, 0xd5f8, 0xd5f7, 0xd618, 0xd618,
0xde18, 0xe639, 0xee58, 0xee99, 0xf6b9, 0xf6b9, 0xf6b9, 0xf6d9, 0xfef9,
0xff19, 0xff39, 0xff5a, 0xce36, 0x7db4, 0x6c55, 0x4971, 0x284f, 0x280e,
0x300e, 0x300f, 0x3070, 0x3130, 0x2990, 0x21d0, 0x32f2, 0x3331, 0x2af1,
0x2ad1, 0x2b11, 0x2af1, 0x2ab0, 0x2ab1, 0x2ab1, 0x22b1, 0x2ab1, 0x2a91,
0x1a50, 0x22b1, 0x22b1, 0x1a91, 0x300d, 0x300e, 0x300e, 0x380f, 0x4010,
0x4810, 0x4810, 0x5010, 0x5831, 0x5831, 0x6872, 0x6871, 0x78d1, 0x88f1,
0x9932, 0xa952, 0xc193, 0xc9b3, 0xd9f4, 0xe214, 0xea55, 0xf275, 0xf2b6,
0xf2d5, 0xfb16, 0xfb36, 0xfb75, 0xfb38, 0xf053, 0xf813, 0xf813, 0xf217,
0xe832, 0xf012, 0xf813, 0xf012, 0xf812, 0xf812, 0xf812, 0xf811, 0xf811,
0xf811, 0xf811, 0xf811, 0xf810, 0xf810, 0xf811, 0xf811, 0xf811, 0xf811,
0xf811, 0xf810, 0xf810, 0xf810, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f,
0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f,
0xf810, 0xf810, 0xf811, 0xf811, 0xf812, 0xf812, 0xf812, 0xf813, 0xf013,
0xf033, 0xf0b4, 0xf114, 0xf974, 0xf9d5, 0xfa15, 0xfa35, 0xfa56, 0xfa55,
0xf255, 0xfa95, 0xfad6, 0xfb16, 0xfb36, 0xfb56, 0xfb76, 0xfb76, 0xfb97,
0xfbb7, 0xfbd7, 0xfbf7, 0xfc17, 0xfc37, 0xfc98, 0xfb96, 0xfbb6, 0xfbd6,
0xfbf7, 0xfc78, 0xfc97, 0xfc98, 0xf4b7, 0xf3f6, 0xf416, 0xf436, 0xec36,
0xec56, 0xec76, 0xe4b7, 0xe4f6, 0xe598, 0xe5b8, 0xe5d8, 0xedd8, 0xedf8,
0xf618, 0xf658, 0xfe79, 0xfe99, 0xfed9, 0xfefa, 0xff19, 0xff1a, 0xf5d8,
0xf517, 0xe2b5, 0xb051, 0x8810, 0x780e, 0x882f, 0x700f, 0x500f, 0x3811,
0x38f1, 0x4272, 0x4332, 0x4352, 0x4332, 0x3af2, 0x3b13, 0x32f2, 0x32f1,
0x32d1, 0x32b1, 0x32b1, 0x2a91, 0x2ab1, 0x2ab1, 0x2a91, 0x2250, 0x2291,
0x2290, 0x2290, 0x300b, 0x380c, 0x380c, 0x400d, 0x400e, 0x480e, 0x480f,
0x500f, 0x5810, 0x6010, 0x6810, 0x7011, 0x7831, 0x8851, 0x9071, 0xa8d2,
0xb8f3, 0xc933, 0xd153, 0xe194, 0xe9d5, 0xf215, 0xf235, 0xf295, 0xfad5,
0xfaf5, 0xfb35, 0xfb56, 0xfb96, 0xfbb7, 0xe933, 0xf8b4, 0xf833, 0xfa16,
0xe872, 0xf812, 0xf812, 0xf811, 0xf811, 0xf812, 0xf812, 0xf812, 0xf812,
0xf811, 0xf812, 0xf811, 0xf811, 0xf811, 0xf811, 0xf811, 0xf810, 0xf810,
0xf810, 0xf811, 0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf810,
0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf811, 0xf811,
0xf811, 0xf812, 0xf812, 0xf812, 0xf812, 0xf813, 0xf013, 0xf873, 0xf974,
0xf994, 0xf9f4, 0xfa15, 0xfa15, 0xfa95, 0xfab5, 0xfa95, 0xfab5, 0xfaf5,
0xfb15, 0xfb35, 0xfb76, 0xfb76, 0xfb96, 0xfb76, 0xfb96, 0xfb96, 0xfbb6,
0xfbb6, 0xfbd6, 0xfbd6, 0xfbd6, 0xfc37, 0xfc17, 0xfc77, 0xfc77, 0xfc98,
0xfc78, 0xfc77, 0xfc97, 0xfc98, 0xfcb8, 0xfcd8, 0xfcd8, 0xfcf8, 0xfd18,
0xfd39, 0xfd38, 0xfd59, 0xfd58, 0xfd98, 0xfdb9, 0xfdd9, 0xfe19, 0xfe39,
0xfe59, 0xfe79, 0xfeb9, 0xfeb9, 0xfcd7, 0xfb16, 0xf934, 0xf032, 0xe810,
0xd80f, 0xe831, 0xd011, 0xb011, 0x8010, 0x5851, 0x6b35, 0x5b74, 0x5353,
0x5353, 0x4b12, 0x4b12, 0x4312, 0x4312, 0x42f2, 0x42f2, 0x3af1, 0x3ab2,
0x3ab2, 0x3291, 0x2a91, 0x2a71, 0x2a91, 0x2230, 0x2a71, 0x2a91, 0x2270,
0x3808, 0x4009, 0x4009, 0x480a, 0x480b, 0x500c, 0x500d, 0x580e, 0x580e,
0x600e, 0x680f, 0x700f, 0x7810, 0x8811, 0x9811, 0xa012, 0xb012, 0xc053,
0xc873, 0xd8d4, 0xe134, 0xe975, 0xf1b5, 0xf215, 0xfa75, 0xfab5, 0xfaf6,
0xfb36, 0xfb56, 0xfb96, 0xfbd6, 0xfbd6, 0xf213, 0xf8d3, 0xf811, 0xfa97,
0xf031, 0xf812, 0xf813, 0xf812, 0xf812, 0xf812, 0xf812, 0xf811, 0xf811,
0xf811, 0xf811, 0xf811, 0xf811, 0xf811, 0xf810, 0xf811, 0xf810, 0xf810,
0xf80f, 0xf80e, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f,
0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf810,
0xf810, 0xf811, 0xf811, 0xf812, 0xf811, 0xf933, 0xf9b4, 0xfa14, 0xfa34,
0xfa74, 0xfa94, 0xfab5, 0xfad5, 0xfaf5, 0xfaf5, 0xfb35, 0xfb75, 0xfb96,
0xfbb6, 0xfbd6, 0xfbf6, 0xfc16, 0xfc16, 0xfc36, 0xfc56, 0xfc76, 0xfc77,
0xf3b4, 0xf394, 0xfc35, 0xfc55, 0xfc56, 0xfc76, 0xfc76, 0xfc96, 0xfc96,
0xfcb7, 0xfcb7, 0xf496, 0xfc76, 0xfc97, 0xf4b6, 0xfd37, 0xfd58, 0xfd78,
0xfd58, 0xfd78, 0xfdb8, 0xfdb8, 0xfdd8, 0xfdf8, 0xfe39, 0xfe59, 0xfe59,
0xfc35, 0xfa91, 0xf8ef, 0xf80d, 0xf80a, 0xf80a, 0xf80c, 0xf80f, 0xf812,
0xd812, 0x9872, 0x6254, 0x6b13, 0x6354, 0x5af3, 0x5b13, 0x5313, 0x52d2,
0x5313, 0x5312, 0x4af2, 0x4ad2, 0x4ad2, 0x42b2, 0x3ad2, 0x3a91, 0x3a71,
0x3291, 0x3271, 0x3291, 0x2a10, 0x2a70, 0x2a70, 0x2a71, 0x4806, 0x4807,
0x5008, 0x5008, 0x5009, 0x500a, 0x500a, 0x580b, 0x580c, 0x600d, 0x680d,
0x700e, 0x780f, 0x8810, 0x9810, 0xa011, 0xb012, 0xb812, 0xc813, 0xd814,
0xd813, 0xe074, 0xe8f4, 0xe974, 0xf1d5, 0xfa35, 0xfa75, 0xfab5, 0xfaf5,
0xfb35, 0xfb96, 0xfbb6, 0xfbf5, 0xfbb6, 0xf1b1, 0xf8f2, 0xf810, 0xfb58,
0xe851, 0xf812, 0xf811, 0xf810, 0xf810, 0xf80e, 0xf80d, 0xf80d, 0xf810,
0xf810, 0xf810, 0xf810, 0xf810, 0xf810, 0xf80f, 0xf80f, 0xf80e, 0xf80e,
0xf80f, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e,
0xf80e, 0xf80e, 0xf80e, 0xf80f, 0xf80f, 0xf80f, 0xf810, 0xf810, 0xf811,
0xf811, 0xf811, 0xf051, 0xf912, 0xf952, 0xf9d3, 0xfa33, 0xfa94, 0xfad4,
0xfb14, 0xfb34, 0xfb34, 0xfb74, 0xfb94, 0xfbb5, 0xfbd4, 0xfbf5, 0xfbf4,
0xf394, 0xf3b4, 0xfbd4, 0xfbd4, 0xf3d4, 0xf414, 0xf434, 0xf3f3, 0xfc34,
0xf454, 0xfc54, 0xfc54, 0xfc54, 0xfc75, 0xfcd6, 0xfcd6, 0xfcf6, 0xfcb6,
0xfcb6, 0xfcb6, 0xfc96, 0xfcb6, 0xfcb6, 0xfcd7, 0xfd37, 0xfd17, 0xfd17,
0xfd17, 0xfd77, 0xfdd7, 0xfe37, 0xfe37, 0xfc32, 0xfa2e, 0xf88c, 0xf807,
0xf803, 0xf804, 0xf807, 0xf80b, 0xf02f, 0xf012, 0xb0d2, 0x7993, 0x61d3,
0x5a13, 0x6253, 0x6293, 0x6293, 0x62b3, 0x5ad3, 0x5af3, 0x5ad3, 0x52d3,
0x4a72, 0x52b3, 0x4a92, 0x4272, 0x42b2, 0x4251, 0x4292, 0x3a71, 0x3a71,
0x3a71, 0x3210, 0x2a50, 0x2a50, 0x2a71, 0x5005, 0x5006, 0x5006, 0x5807,
0x5808, 0x5808, 0x6009, 0x6009, 0x600a, 0x680b, 0x680c, 0x700c, 0x780d,
0x800e, 0x900f, 0x9810, 0xa811, 0xb812, 0xc812, 0xd013, 0xd813, 0xd813,
0xe013, 0xe874, 0xf0d4, 0xf974, 0xf9d5, 0xfa14, 0xfa95, 0xfad5, 0xfb15,
0xfb75, 0xfbb5, 0xfbd5, 0xfbf6, 0xfbf5, 0xfa72, 0xf972, 0xf050, 0xfb37,
0xf111, 0xf00f, 0xf80f, 0xf80f, 0xf80e, 0xf80d, 0xf80c, 0xf80e, 0xf80f,
0xf810, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80d, 0xf80d, 0xf80d,
0xf80d, 0xf80d, 0xf80c, 0xf80c, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d,
0xf80c, 0xf80c, 0xf80d, 0xf80d, 0xf80d, 0xf80e, 0xf80e, 0xf82f, 0xf8f1,
0xf991, 0xf9d2, 0xfa52, 0xfa92, 0xfab3, 0xfaf3, 0xfb33, 0xfb34, 0xfb33,
0xfb74, 0xfb94, 0xfbb4, 0xfbf4, 0xfc13, 0xfc33, 0xfc74, 0xfc74, 0xfc94,
0xfcd4, 0xfcf5, 0xfd15, 0xfd15, 0xfd35, 0xfd35, 0xfd35, 0xfd35, 0xfd14,
0xfd14, 0xfd14, 0xfcf4, 0xfcf4, 0xfcb4, 0xfc33, 0xfc13, 0xfc13, 0xfc14,
0xfbd3, 0xfbf4, 0xfbb3, 0xf331, 0xfb71, 0xfb91, 0xfbd0, 0xfc6f, 0xfdcf,
0xfe31, 0xfc6f, 0xf9aa, 0xf049, 0xf803, 0xf800, 0xf800, 0xf803, 0xf806,
0xf80b, 0xf02f, 0xb152, 0x9993, 0x91b3, 0x89b4, 0x6173, 0x6193, 0x61d3,
0x6213, 0x6233, 0x6273, 0x62b3, 0x5ab3, 0x5272, 0x4a52, 0x5272, 0x4a92,
0x4a71, 0x4252, 0x4a92, 0x4271, 0x4272, 0x3a51, 0x3a51, 0x3a71, 0x31f1,
0x3231, 0x3230, 0x2a50, 0x5805, 0x5805, 0x6005, 0x6005, 0x6806, 0x6807,
0x6807, 0x6808, 0x6808, 0x7009, 0x7009, 0x780b, 0x780b, 0x800c, 0x900d,
0x980e, 0xa00f, 0xb010, 0xb811, 0xc812, 0xd012, 0xd812, 0xe013, 0xe813,
0xe813, 0xf013, 0xf894, 0xf975, 0xf9d5, 0xfa54, 0xfa95, 0xfad5, 0xfb35,
0xfb95, 0xfbd5, 0xfbd5, 0xfc15, 0xfc15, 0xf252, 0xf9b1, 0xf8f0, 0xf2b2,
0xf0f0, 0xf851, 0xf810, 0xf80f, 0xf80f, 0xf80f, 0xf80f, 0xf80e, 0xf80f,
0xf80f, 0xf80e, 0xf80e, 0xf80d, 0xf80d, 0xf80d, 0xf80c, 0xf80c, 0xf80b,
0xf80b, 0xf80b, 0xf80a, 0xf80a, 0xf80a, 0xf80b, 0xf80a, 0xf80a, 0xf80a,
0xf80a, 0xf80a, 0xf80b, 0xf80c, 0xf80d, 0xf80d, 0xf82e, 0xf90f, 0xf96f,
0xf9d0, 0xfa51, 0xfa91, 0xfad1, 0xfb12, 0xfb31, 0xfb72, 0xfb72, 0xfb71,
0xfb91, 0xfbf1, 0xfc11, 0xfbf1, 0xfbd0, 0xfbd0, 0xfbf0, 0xfbcf, 0xfbcf,
0xfc0f, 0xfc2f, 0xfc4f, 0xfc90, 0xfcb0, 0xfcb0, 0xfcb0, 0xfcd1, 0xfcd1,
0xfc91, 0xfc71, 0xfc51, 0xfc31, 0xfc11, 0xfbf1, 0xfbd1, 0xfbd1, 0xfaee,
0xfaee, 0xfb0e, 0xfb6d, 0xfbcc, 0xfc4c, 0xfd0c, 0xfc2c, 0xf8e9, 0xf807,
0xf801, 0xf800, 0xf800, 0xf801, 0xf803, 0xf808, 0xe031, 0xd113, 0xb993,
0xb193, 0xa152, 0x9952, 0x8152, 0x7173, 0x6973, 0x6173, 0x61b3, 0x61d3,
0x59f3, 0x5a13, 0x51f3, 0x51f3, 0x51f2, 0x4a12, 0x5252, 0x4a52, 0x4a52,
0x4a71, 0x4a51, 0x4272, 0x4251, 0x4271, 0x4272, 0x39f1, 0x3a11, 0x3a31,
0x2a30, 0x5805, 0x6005, 0x6005, 0x6805, 0x6806, 0x6806, 0x6807, 0x7007,
0x7007, 0x7007, 0x7808, 0x7809, 0x8009, 0x800a, 0x880b, 0x900c, 0x980d,
0xa00e, 0xa80f, 0xb010, 0xc010, 0xc811, 0xd811, 0xe012, 0xe813, 0xe813,
0xf013, 0xf813, 0xf873, 0xf934, 0xf9f4, 0xfa34, 0xfa94, 0xfb14, 0xfb54,
0xfb95, 0xfbd4, 0xfbf4, 0xfbf3, 0xfbf3, 0xfbb3, 0xf96f, 0xf84e, 0xf96f,
0xe92f, 0xf82f, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80d, 0xf80d,
0xf80e, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80b, 0xf80b, 0xf809, 0xf809,
0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf80a,
0xf80a, 0xf80a, 0xf80c, 0xf80d, 0xf80d, 0xf88e, 0xf90e, 0xf9af, 0xfa30,
0xfa50, 0xfa71, 0xfa91, 0xfab1, 0xfa70, 0xfa70, 0xfa90, 0xfad0, 0xfb0f,
0xfb4e, 0xfb6d, 0xfb8e, 0xfbce, 0xfbee, 0xfc0e, 0xfc2e, 0xfc8e, 0xfc6e,
0xfcce, 0xfd0e, 0xfd0e, 0xfd0e, 0xfd0e, 0xfd0e, 0xfd0e, 0xfc6d, 0xfbec,
0xfbac, 0xf34b, 0xf2ec, 0xf2cb, 0xf2cc, 0xf2eb, 0xf2cb, 0xf2eb, 0xf34b,
0xfbea, 0xfc8c, 0xfb6b, 0xf026, 0xf804, 0xf800, 0xf000, 0xf800, 0xf800,
0xf803, 0xf80b, 0xf012, 0xe013, 0xd914, 0xc913, 0xb913, 0xb153, 0xa132,
0x9912, 0x8933, 0x7992, 0x7173, 0x6953, 0x6173, 0x5953, 0x5952, 0x5152,
0x5172, 0x51b2, 0x51d2, 0x49f2, 0x49f2, 0x4a12, 0x4a12, 0x4a52, 0x4a32,
0x4231, 0x4252, 0x4251, 0x4251, 0x39d0, 0x39f0, 0x3231, 0x3271, 0x5804,
0x6005, 0x6805, 0x6805, 0x7005, 0x6805, 0x7006, 0x7006, 0x7007, 0x7807,
0x7807, 0x8007, 0x8008, 0x8809, 0x9009, 0x900a, 0x980b, 0xa00c, 0xa80c,
0xb00d, 0xb80e, 0xc00f, 0xc810, 0xd010, 0xe011, 0xe812, 0xe812, 0xf012,
0xf812, 0xf813, 0xf873, 0xf954, 0xf9d4, 0xfa74, 0xfab4, 0xfb14, 0xfb54,
0xfb73, 0xfbb3, 0xfbd3, 0xfbd3, 0xfbb2, 0xfb92, 0xf88e, 0xf80c, 0xe06a,
0xf86e, 0xf80c, 0xf80b, 0xf80c, 0xf80b, 0xf80a, 0xf80a, 0xf80b, 0xf80a,
0xf809, 0xf80b, 0xf80b, 0xf80a, 0xf809, 0xf808, 0xf807, 0xf807, 0xf807,
0xf807, 0xf807, 0xf807, 0xf807, 0xf807, 0xf807, 0xf807, 0xf807, 0xf808,
0xf809, 0xf80a, 0xf80b, 0xf80b, 0xf80c, 0xf02c, 0xf8ee, 0xf98f, 0xf9cf,
0xfa2f, 0xfa6f, 0xf1ed, 0xf22e, 0xea0d, 0xf24d, 0xfaad, 0xfb0c, 0xfbad,
0xfbed, 0xfbed, 0xfbed, 0xfc0d, 0xfc0c, 0xfbcc, 0xfc0b, 0xfc2b, 0xfc0b,
0xfc2b, 0xfc4b, 0xfc6b, 0xfc6c, 0xfc0b, 0xfbcb, 0xfbeb, 0xfb8b, 0xfb2b,
0xfacb, 0xfaeb, 0xfaea, 0xfaaa, 0xfacb, 0xf2ca, 0xf3a9, 0xfc0b, 0xd020,
0xb800, 0x9820, 0x8000, 0xc000, 0xf800, 0xf801, 0xf80c, 0xf811, 0xf013,
0xe813, 0xe013, 0xd894, 0xd0d3, 0xc0d2, 0xb913, 0xa8d2, 0xa8f2, 0x90f3,
0x8193, 0x7172, 0x7153, 0x6132, 0x6132, 0x5912, 0x5932, 0x5932, 0x5993,
0x51b2, 0x49b2, 0x49d2, 0x49f2, 0x49f2, 0x4a32, 0x4212, 0x4211, 0x4a32,
0x4212, 0x4212, 0x39b0, 0x39d1, 0x3a52, 0x3251, 0x5804, 0x6004, 0x6004,
0x6805, 0x7005, 0x7005, 0x7006, 0x7806, 0x7806, 0x7806, 0x8006, 0x8807,
0x8807, 0x9008, 0x9008, 0x9809, 0x9809, 0xa00a, 0xa80a, 0xb00b, 0xb00b,
0xb80c, 0xc00d, 0xc80e, 0xd00f, 0xd810, 0xe811, 0xf011, 0xf811, 0xf812,
0xf812, 0xf812, 0xf832, 0xf933, 0xf9b3, 0xfa33, 0xfab3, 0xfaf3, 0xfb53,
0xfb73, 0xfb72, 0xfb72, 0xfb51, 0xfb30, 0xfad0, 0xf0ec, 0xf80a, 0xe828,
0xe84b, 0xf80c, 0xf80a, 0xf80b, 0xf80b, 0xf80b, 0xf809, 0xf809, 0xf80a,
0xf808, 0xf808, 0xf807, 0xf807, 0xf805, 0xf805, 0xf804, 0xf802, 0xf803,
0xf803, 0xf803, 0xf803, 0xf804, 0xf805, 0xf804, 0xf806, 0xf807, 0xf808,
0xf809, 0xf80a, 0xf80a, 0xf80b, 0xf80d, 0xf82d, 0xf8cf, 0xf8ee, 0xf98f,
0xf9af, 0xf9ef, 0xfa0f, 0xfa2e, 0xfa4d, 0xfa6d, 0xfa4c, 0xfa2c, 0xfa4c,
0xfa6c, 0xfa6b, 0xfa8c, 0xfa8b, 0xfacb, 0xfacc, 0xfacb, 0xfaab, 0xfa8b,
0xfa6b, 0xfa2b, 0xfa0b, 0xf9cc, 0xf96b, 0xf8ab, 0xf86b, 0xf00a, 0xf029,
0xf048, 0xf807, 0xf027, 0xe0e7, 0x3800, 0x3000, 0x3000, 0x2800, 0x3000,
0x7000, 0xe001, 0xf80d, 0xf811, 0xf812, 0xf813, 0xf013, 0xe813, 0xe013,
0xd814, 0xd874, 0xc893, 0xb8d3, 0xb8d3, 0xa8b2, 0x98b1, 0x8173, 0x7952,
0x7153, 0x6952, 0x6153, 0x6133, 0x5953, 0x5932, 0x5172, 0x51d2, 0x51b2,
0x4992, 0x4992, 0x49b2, 0x49f2, 0x41d1, 0x41d1, 0x49d1, 0x41d1, 0x49f1,
0x39b0, 0x39d1, 0x3a32, 0x3a51, 0x5804, 0x6004, 0x6004, 0x6805, 0x6805,
0x7005, 0x7005, 0x7805, 0x7806, 0x8006, 0x8006, 0x8806, 0x9007, 0x9007,
0x9808, 0x9808, 0xa008, 0xa009, 0xa809, 0xb009, 0xb00a, 0xb80a, 0xb80b,
0xc80b, 0xc80c, 0xd00d, 0xd80d, 0xe00e, 0xe80f, 0xf810, 0xf811, 0xf811,
0xf812, 0xf812, 0xf831, 0xf8f2, 0xf9b2, 0xfa32, 0xfa92, 0xfad1, 0xfb11,
0xfb31, 0xfb10, 0xfb10, 0xfad0, 0xfaaf, 0xfa0f, 0xf0ab, 0xf829, 0xf008,
0xf82c, 0xf809, 0xf808, 0xf80b, 0xf806, 0xf808, 0xf80a, 0xf809, 0xf809,
0xf809, 0xf809, 0xf808, 0xf807, 0xf808, 0xf806, 0xf805, 0xf804, 0xf803,
0xf803, 0xf804, 0xf804, 0xf803, 0xf804, 0xf806, 0xf809, 0xf809, 0xf809,
0xf80a, 0xf80b, 0xf80d, 0xf80e, 0xf80d, 0xf80e, 0xf00d, 0xf80d, 0xf80e,
0xf80e, 0xf80e, 0xf8ee, 0xf92d, 0xf92c, 0xf92d, 0xf90d, 0xf90d, 0xf8ec,
0xf90c, 0xf90c, 0xf8ec, 0xf88c, 0xf88c, 0xf82c, 0xf80b, 0xf80b, 0xf80b,
0xf80b, 0xf80a, 0xf80a, 0xf809, 0xf808, 0xf806, 0xf003, 0xf801, 0xc042,
0x3800, 0x2800, 0x2000, 0x2000, 0x2820, 0x3000, 0x7802, 0xf80e, 0xf810,
0xf811, 0xf812, 0xf812, 0xf812, 0xf813, 0xf013, 0xe013, 0xd814, 0xd014,
0xc874, 0xc073, 0xb852, 0xa872, 0x9871, 0x8953, 0x8173, 0x7932, 0x7153,
0x6132, 0x6132, 0x5932, 0x5932, 0x5132, 0x5192, 0x51b2, 0x4972, 0x4991,
0x4992, 0x49d1, 0x4191, 0x41d1, 0x4191, 0x4171, 0x41d1, 0x39b1, 0x39f1,
0x3a31, 0x3a31, 0x5804, 0x6004, 0x6004, 0x6804, 0x6805, 0x7005, 0x7805,
0x7805, 0x7806, 0x8006, 0x8006, 0x8806, 0x9007, 0x9807, 0xa008, 0xa008,
0xa808, 0xb009, 0xb009, 0xb008, 0xb809, 0xc009, 0xc009, 0xc80a, 0xd00a,
0xd00b, 0xd80b, 0xe00c, 0xe00c, 0xe80d, 0xf00e, 0xf80f, 0xf810, 0xf810,
0xf810, 0xf811, 0xf810, 0xf8b1, 0xf971, 0xf9f1, 0xfa51, 0xfa70, 0xfa90,
0xfab0, 0xfab0, 0xfa6f, 0xfa2f, 0xf9cf, 0xf98f, 0xf90f, 0xf806, 0xe844,
0xfa32, 0xfa32, 0xf9f1, 0xf9d1, 0xf9d1, 0xf190, 0xf94f, 0xf10f, 0xf0ef,
0xf08e, 0xf06d, 0xf82c, 0xf82c, 0xf80b, 0xf80a, 0xf80a, 0xf809, 0xf809,
0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf80a, 0xf80a, 0xf80b, 0xf80c,
0xf80d, 0xf80d, 0xf80e, 0xf80d, 0xf00d, 0xf80d, 0xf80e, 0xf80e, 0xf80d,
0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d,
0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80b, 0xf80b,
0xf80a, 0xf80a, 0xf809, 0xf807, 0xb863, 0x4000, 0x2800, 0x2800, 0x2800,
0x2800, 0x3000, 0xa045, 0xf80e, 0xf80e, 0xf810, 0xf810, 0xf871, 0xf872,
0xf812, 0xf812, 0xf012, 0xe813, 0xe813, 0xe014, 0xd013, 0xc874, 0xc033,
0xb012, 0xb032, 0x9831, 0x8932, 0x8153, 0x7953, 0x7132, 0x6933, 0x6132,
0x5932, 0x5912, 0x5132, 0x51b2, 0x5192, 0x4932, 0x4991, 0x4972, 0x4171,
0x4171, 0x41d1, 0x4191, 0x4151, 0x41b1, 0x3991, 0x39d1, 0x4211, 0x3a32,
0x5804, 0x6004, 0x6804, 0x7004, 0x7005, 0x7005, 0x7805, 0x7806, 0x8006,
0x8806, 0x8806, 0x9807, 0xa007, 0xa007, 0xa808, 0xa808, 0xb009, 0xb809,
0xb809, 0xc009, 0xc009, 0xc809, 0xc809, 0xd00a, 0xd00a, 0xd80a, 0xd80a,
0xd80a, 0xe00a, 0xe80b, 0xe80b, 0xf00c, 0xf80d, 0xf80e, 0xf80f, 0xf80f,
0xf80f, 0xf80f, 0xf80f, 0xf82f, 0xf890, 0xf94f, 0xf9af, 0xf9ef, 0xf9ef,
0xf9cf, 0xf98f, 0xf96e, 0xf96e, 0xf9b0, 0xf80c, 0xf045, 0xa000, 0xf82b,
0xf803, 0xf807, 0xf808, 0xf80a, 0xf80a, 0xf809, 0xf809, 0xf809, 0xf808,
0xf807, 0xf806, 0xf806, 0xf805, 0xf805, 0xf804, 0xf804, 0xf804, 0xf803,
0xf803, 0xf803, 0xf803, 0xf804, 0xf805, 0xf806, 0xf808, 0xf809, 0xf80b,
0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80c,
0xf80c, 0xf80c, 0xf80b, 0xf80b, 0xf82b, 0xf80b, 0xf80b, 0xf80b, 0xf80b,
0xf80b, 0xf80b, 0xf80a, 0xf82a, 0xf82a, 0xf02a, 0xf809, 0xf829, 0xf029,
0xe046, 0x9800, 0x5820, 0x3800, 0x3800, 0x3000, 0x3800, 0xc866, 0xf80a,
0xf80d, 0xf80e, 0xf80f, 0xf830, 0xf831, 0xf831, 0xf832, 0xf812, 0xf812,
0xf813, 0xe813, 0xe813, 0xe014, 0xd813, 0xc812, 0xc013, 0xb812, 0xb011,
0xa011, 0x8932, 0x8953, 0x7932, 0x7132, 0x6932, 0x6112, 0x6112, 0x58d2,
0x5112, 0x5152, 0x4951, 0x40b1, 0x4932, 0x4131, 0x4151, 0x4171, 0x49d1,
0x4191, 0x4191, 0x41b1, 0x3970, 0x39b1, 0x41f1, 0x3a11, 0x6004, 0x6004,
0x6804, 0x7005, 0x7805, 0x7805, 0x8005, 0x8005, 0x8806, 0x9006, 0x9007,
0xa007, 0xa807, 0xb008, 0xb008, 0xb808, 0xc009, 0xc009, 0xc009, 0xc809,
0xc809, 0xd009, 0xd009, 0xd00a, 0xd80a, 0xd80a, 0xd80a, 0xe00a, 0xe00a,
0xe80b, 0xe80b, 0xe80b, 0xe80b, 0xf00b, 0xf80b, 0xf80c, 0xf80c, 0xf80d,
0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf86e, 0xf8ce, 0xf8ef, 0xf8ee,
0xf8ee, 0xf96e, 0xf9af, 0xf80e, 0xf80c, 0xf808, 0xfb30, 0x9000, 0xd16b,
0xf070, 0xf8f1, 0xf0f0, 0xe84f, 0xf8b1, 0xf02f, 0xf850, 0xf870, 0xf030,
0xf030, 0xf82f, 0xf82e, 0xf9af, 0xfacf, 0xf9d0, 0xf80f, 0xf82f, 0xf84f,
0xf890, 0xf8f0, 0xf92f, 0xf94f, 0xf98f, 0xfa2f, 0xfa2e, 0xfa50, 0xfa6f,
0xfa8e, 0xf28d, 0xfaed, 0xfb4d, 0xfb0d, 0xfb0d, 0xfb0c, 0xfb0c, 0xfb0c,
0xfb0b, 0xfb2b, 0xfb0b, 0xfb0b, 0xfb2b, 0xf32a, 0xfb2a, 0xf309, 0xfac9,
0xfaa9, 0xfa69, 0xfa29, 0xf1a8, 0xf088, 0xf028, 0x9802, 0x5800, 0x3800,
0x2800, 0x2000, 0x6000, 0xe025, 0xf805, 0xf809, 0xf80a, 0xf80d, 0xf80f,
0xf80f, 0xf810, 0xf851, 0xf811, 0xf812, 0xf812, 0xf812, 0xf012, 0xe813,
0xe014, 0xe014, 0xd813, 0xd013, 0xc013, 0xb812, 0xb012, 0xa012, 0x7890,
0x8912, 0x8133, 0x7932, 0x68f2, 0x60f2, 0x60d2, 0x5892, 0x50f2, 0x5132,
0x4952, 0x48d1, 0x48f2, 0x4111, 0x4151, 0x4171, 0x49b1, 0x4151, 0x4171,
0x4171, 0x3971, 0x3991, 0x39d1, 0x39f0, 0x6004, 0x6804, 0x6804, 0x7805,
0x7805, 0x7805, 0x8005, 0x8806, 0x9006, 0x9006, 0x9807, 0xa807, 0xa808,
0xb008, 0xb808, 0xc008, 0xc009, 0xc009, 0xc809, 0xc809, 0xc80a, 0xd00a,
0xd00a, 0xd80a, 0xd80a, 0xd80a, 0xe00a, 0xd80a, 0xe00a, 0xe00a, 0xe00b,
0xe00b, 0xe00a, 0xe00a, 0xe80a, 0xe809, 0xf00a, 0xf80a, 0xf80a, 0xf80b,
0xf80b, 0xf80b, 0xf80c, 0xf80c, 0xf80c, 0xf80d, 0xf80c, 0xf80d, 0xf80d,
0xf8ef, 0xf80c, 0xf80a, 0xe804, 0xfb0f, 0x5800, 0xb12a, 0xf810, 0xf810,
0xf810, 0xf810, 0xf810, 0xf810, 0xf850, 0xf830, 0xf810, 0xf810, 0xf80f,
0xf86e, 0xf94f, 0xf9ef, 0xfa2f, 0xf94f, 0xf88f, 0xf80e, 0xf80e, 0xf80e,
0xf86e, 0xf92f, 0xf94f, 0xf96e, 0xf9ee, 0xf9ae, 0xf9ce, 0xfa0e, 0xfa2e,
0xfa6d, 0xfacd, 0xfaed, 0xfacd, 0xfacd, 0xfaed, 0xfacc, 0xfaec, 0xfaec,
0xfacb, 0xfaeb, 0xfb0b, 0xfb0b, 0xfb2b, 0xfb0b, 0xfb0b, 0xfaeb, 0xfacb,
0xfa8a, 0xfa4b, 0xf9ea, 0xf92a, 0xb022, 0x9000, 0x5800, 0xa824, 0xf806,
0xf808, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80e, 0xf80f, 0xf80f, 0xf810,
0xf871, 0xf832, 0xf812, 0xf811, 0xf812, 0xf012, 0xe813, 0xe013, 0xe013,
0xd813, 0xd013, 0xc813, 0xb812, 0xb012, 0xa012, 0x8071, 0x8912, 0x8112,
0x7912, 0x70f2, 0x60f2, 0x5891, 0x60d2, 0x50d2, 0x48d1, 0x4912, 0x48d1,
0x48d1, 0x4131, 0x4971, 0x4971, 0x49b1, 0x4971, 0x4171, 0x4171, 0x3970,
0x3970, 0x39b1, 0x39d1, 0x6804, 0x6804, 0x7004, 0x8005, 0x7805, 0x8005,
0x8805, 0x9006, 0x9006, 0xa007, 0xa807, 0xa808, 0xb808, 0xb809, 0xc009,
0xc009, 0xc809, 0xc80a, 0xc80a, 0xd00a, 0xd00a, 0xd00a, 0xd00a, 0xd00a,
0xd00b, 0xd80b, 0xd80b, 0xd80b, 0xd80b, 0xd80b, 0xd80c, 0xd80b, 0xd80b,
0xd80b, 0xe00a, 0xd808, 0xe008, 0xe007, 0xe807, 0xf006, 0xf006, 0xf806,
0xf806, 0xf806, 0xf808, 0xf808, 0xf809, 0xf809, 0xf80c, 0xf80e, 0xf80a,
0xf805, 0xd801, 0xfb2e, 0x4800, 0xa929, 0xf80e, 0xf80e, 0xf80e, 0xf80e,
0xf80e, 0xf80e, 0xf88e, 0xf8af, 0xf80e, 0xf84d, 0xf8cd, 0xf92d, 0xf96d,
0xf9cd, 0xf9ee, 0xf9ae, 0xf94d, 0xf90d, 0xf86d, 0xf8cc, 0xf94c, 0xf96c,
0xf98c, 0xf9ec, 0xfa2c, 0xfa2c, 0xfa2c, 0xfa4c, 0xfa8b, 0xfa8c, 0xfacc,
0xfaec, 0xfaec, 0xfacc, 0xfaec, 0xfaeb, 0xfb0b, 0xfb0b, 0xfb0b, 0xfb0b,
0xfb2b, 0xfb4a, 0xfb4a, 0xfb2a, 0xfb2a, 0xfb0a, 0xfaea, 0xfaaa, 0xfa8a,
0xfa4b, 0xf9ea, 0xc841, 0xf047, 0xf807, 0xf808, 0xf808, 0xf808, 0xf808,
0xf808, 0xf80a, 0xf80b, 0xf80e, 0xf80f, 0xf80f, 0xf810, 0xf871, 0xf831,
0xf812, 0xf811, 0xf812, 0xf812, 0xf013, 0xe813, 0xe013, 0xd813, 0xd013,
0xc813, 0xc012, 0xb012, 0xa012, 0x90b2, 0x8912, 0x80f2, 0x78f2, 0x70d2,
0x68f2, 0x60b2, 0x60b2, 0x5091, 0x48d1, 0x48f2, 0x40b1, 0x4091, 0x4111,
0x4151, 0x4151, 0x4971, 0x4171, 0x4171, 0x4191, 0x3950, 0x3170, 0x3991,
0x41f1, 0x7004, 0x6804, 0x7805, 0x8005, 0x8005, 0x8805, 0x9006, 0x9006,
0x9806, 0xa007, 0xa808, 0xb808, 0xb808, 0xc009, 0xc009, 0xc809, 0xc80a,
0xd00a, 0xc80a, 0xd00a, 0xd00a, 0xd00a, 0xd00b, 0xd00b, 0xd00c, 0xd00b,
0xd80c, 0xd00c, 0xd00d, 0xd00d, 0xd00d, 0xd00d, 0xd00c, 0xd00c, 0xd80b,
0xd008, 0xd007, 0xd806, 0xd805, 0xd804, 0xd804, 0xe002, 0xe000, 0xe000,
0xe800, 0xf000, 0xf801, 0xf804, 0xf809, 0xf80c, 0xf805, 0xe800, 0xc000,
0xfb2e, 0x4800, 0xa909, 0xf80c, 0xf80d, 0xf80d, 0xf80d, 0xf82d, 0xf80d,
0xf8ce, 0xf90d, 0xf88d, 0xf90d, 0xf94d, 0xf96c, 0xf98c, 0xf9ec, 0xfa0c,
0xf9cc, 0xf9ac, 0xf9ac, 0xf94c, 0xf96c, 0xf9ab, 0xf9ab, 0xf9cb, 0xfa2b,
0xfa6b, 0xfa6b, 0xfa8b, 0xfaca, 0xfaeb, 0xfb0a, 0xfb0a, 0xfb2b, 0xfb4b,
0xfb0b, 0xfb0a, 0xfb4a, 0xfb4a, 0xfb4a, 0xfb2a, 0xfb2a, 0xfb6a, 0xfb6a,
0xfb6a, 0xfb6a, 0xfb6a, 0xfb4a, 0xfb09, 0xfaca, 0xfaaa, 0xfaa9, 0xfaa9,
0xe061, 0xf809, 0xf807, 0xf808, 0xf808, 0xf809, 0xf808, 0xf808, 0xf80a,
0xf80b, 0xf80e, 0xf80f, 0xf80f, 0xf811, 0xf871, 0xf832, 0xf812, 0xf811,
0xf812, 0xf813, 0xf013, 0xe813, 0xe013, 0xd813, 0xd013, 0xc813, 0xb812,
0xb812, 0xa012, 0x8871, 0x88d2, 0x78b1, 0x70d2, 0x68b1, 0x68d2, 0x60d2,
0x58b2, 0x58b2, 0x4891, 0x48b1, 0x40b1, 0x40b1, 0x4112, 0x4151, 0x4171,
0x4991, 0x4991, 0x4191, 0x4171, 0x3130, 0x3991, 0x3170, 0x3990, 0x7004,
0x7004, 0x8005, 0x8005, 0x8005, 0x9006, 0x9006, 0x9806, 0xa007, 0xa807,
0xb008, 0xb808, 0xc008, 0xc009, 0xc809, 0xc809, 0xc80a, 0xd00b, 0xd00a,
0xd00b, 0xd00b, 0xd00b, 0xd00c, 0xd00c, 0xd00c, 0xd00d, 0xd00d, 0xc80d,
0xc80d, 0xc80e, 0xc00e, 0xc80e, 0xc00d, 0xc80d, 0xd00c, 0xc809, 0xd008,
0xd006, 0xd006, 0xd004, 0xd002, 0xd001, 0xd000, 0xd000, 0xd000, 0xd000,
0xe000, 0xf000, 0xf806, 0xf80c, 0xe801, 0xd000, 0xb000, 0xfb0d, 0x4800,
0xb149, 0xf80b, 0xf02b, 0xf8ac, 0xf8ec, 0xf94c, 0xf94c, 0xf96c, 0xf98c,
0xf98d, 0xf98c, 0xf9ac, 0xf9ec, 0xf9ec, 0xfa2c, 0xfa6d, 0xfa4c, 0xfa4c,
0xfa0b, 0xf9eb, 0xf9eb, 0xfa0b, 0xfa2b, 0xfa2a, 0xfa8b, 0xfaeb, 0xfaea,
0xfb0a, 0xfb4a, 0xfb6a, 0xfb6a, 0xfb8a, 0xfb8a, 0xfba9, 0xfb8a, 0xfb8a,
0xfb89, 0xfb8a, 0xfb8a, 0xfb6a, 0xfb89, 0xfba9, 0xfbc9, 0xfba9, 0xfb89,
0xfb89, 0xfb69, 0xfb69, 0xfb49, 0xfb29, 0xfb29, 0xfb49, 0xe8a1, 0xf82a,
0xf808, 0xf808, 0xf808, 0xf809, 0xf808, 0xf809, 0xf80a, 0xf80b, 0xf80d,
0xf80e, 0xf810, 0xf810, 0xf810, 0xf812, 0xf812, 0xf811, 0xf812, 0xf812,
0xf012, 0xe813, 0xe013, 0xd813, 0xd013, 0xc813, 0xb812, 0xb812, 0xa811,
0x8851, 0x88b2, 0x8091, 0x78d2, 0x70f2, 0x70d2, 0x68d2, 0x60d2, 0x58d2,
0x4891, 0x4892, 0x48b2, 0x48b1, 0x48d1, 0x4111, 0x4151, 0x4151, 0x4151,
0x4151, 0x4130, 0x3110, 0x3970, 0x3970, 0x39b1, 0x7004, 0x7804, 0x8005,
0x8805, 0x8805, 0x9006, 0x9005, 0xa007, 0xa007, 0xa807, 0xb808, 0xc008,
0xc009, 0xc809, 0xc809, 0xc80a, 0xc80a, 0xd00b, 0xd00b, 0xd00a, 0xd80b,
0xd00b, 0xd00c, 0xd00b, 0xd00c, 0xc80c, 0xd00c, 0xc80c, 0xc00d, 0xc00d,
0xc00e, 0xc00e, 0xc00d, 0xc00c, 0xc00c, 0xc008, 0xc007, 0xc806, 0xc806,
0xc804, 0xc801, 0xc800, 0xc800, 0xc000, 0xc000, 0xc800, 0xd000, 0xe000,
0xf803, 0xf80b, 0xe000, 0xc800, 0xa800, 0xfb2c, 0x4800, 0xb189, 0xf84b,
0xf96b, 0xf98c, 0xf9ec, 0xfa2c, 0xf9ec, 0xf9ec, 0xfa0c, 0xfa4c, 0xfa4c,
0xfa2c, 0xfa2d, 0xfa4d, 0xfaac, 0xfacc, 0xfacb, 0xfaeb, 0xfaab, 0xfa8b,
0xfa6b, 0xfaab, 0xfa8b, 0xfaab, 0xfaeb, 0xfb4b, 0xfb6b, 0xfb8a, 0xfbaa,
0xfbca, 0xfbe9, 0xfbe9, 0xfc2a, 0xfc29, 0xfbe9, 0xfbca, 0xfbc9, 0xfbc9,
0xfba9, 0xfbc9, 0xfbc9, 0xfbc9, 0xfbe9, 0xfbe9, 0xfbe9, 0xfbe9, 0xfbc9,
0xfba9, 0xfb89, 0xfb69, 0xfb88, 0xfbc8, 0xe0a1, 0xf82a, 0xf808, 0xf808,
0xf808, 0xf808, 0xf808, 0xf808, 0xf80a, 0xf80c, 0xf80e, 0xf80e, 0xf810,
0xf810, 0xf811, 0xf811, 0xf812, 0xf811, 0xf812, 0xf812, 0xf013, 0xe813,
0xe013, 0xd813, 0xd013, 0xc813, 0xb812, 0xb812, 0xa812, 0x8831, 0x90b2,
0x8051, 0x78b2, 0x70f2, 0x70f2, 0x60b2, 0x60b2, 0x58b2, 0x5091, 0x4892,
0x4891, 0x48d1, 0x40d1, 0x40b1, 0x4151, 0x4151, 0x4151, 0x3911, 0x4150,
0x30f0, 0x3970, 0x3970, 0x3990, 0x7804, 0x8004, 0x8805, 0x8805, 0x9005,
0x9005, 0xa006, 0xa807, 0xb007, 0xb808, 0xb808, 0xc008, 0xc009, 0xc809,
0xd009, 0xd00a, 0xd00b, 0xd00b, 0xd00a, 0xd00b, 0xd80b, 0xd00b, 0xd00c,
0xd00b, 0xc80b, 0xc80b, 0xc80b, 0xc80b, 0xc00c, 0xc00c, 0xc00c, 0xc00c,
0xb80c, 0xc00b, 0xc00a, 0xb808, 0xc007, 0xc806, 0xc005, 0xc004, 0xc002,
0xc000, 0xc000, 0xb800, 0xb800, 0xc000, 0xc800, 0xd800, 0xf803, 0xf80b,
0xd800, 0xc000, 0xa800, 0xfb4c, 0x4800, 0x8803, 0xf94b, 0xfa2c, 0xf9ec,
0xfa6c, 0xfa8b, 0xfa6c, 0xfa2c, 0xfa6c, 0xfacc, 0xfacc, 0xfa6c, 0xfa2c,
0xfaac, 0xfb0c, 0xfb4c, 0xfb2b, 0xfb4b, 0xfb2b, 0xfa8b, 0xfaab, 0xfaab,
0xfacb, 0xfaea, 0xfb4a, 0xfb6a, 0xfbaa, 0xfbca, 0xfbe9, 0xfc09, 0xfc29,
0xfc29, 0xfc29, 0xfc49, 0xfbe9, 0xfba9, 0xfbca, 0xfbc9, 0xfbc9, 0xfbe9,
0xfc09, 0xfc08, 0xfc28, 0xfc28, 0xfc08, 0xfc08, 0xfbe8, 0xfbc8, 0xfbc9,
0xfb89, 0xfba8, 0xfbe7, 0xe8c1, 0xf809, 0xf808, 0xf809, 0xf808, 0xf808,
0xf808, 0xf809, 0xf80a, 0xf80c, 0xf80d, 0xf80f, 0xf810, 0xf810, 0xf811,
0xf811, 0xf812, 0xf811, 0xf812, 0xf812, 0xf012, 0xe812, 0xe013, 0xd813,
0xd013, 0xc813, 0xb812, 0xb812, 0xa812, 0x9051, 0x8892, 0x8051, 0x78b2,
0x70f2, 0x70f2, 0x68d2, 0x60b2, 0x5891, 0x4871, 0x4871, 0x4891, 0x48d1,
0x40d1, 0x40b1, 0x4131, 0x4131, 0x4151, 0x3910, 0x4131, 0x3110, 0x3971,
0x3950, 0x3970, 0x8004, 0x8004, 0x8805, 0x8805, 0x9805, 0x9005, 0xa807,
0xb007, 0xb807, 0xc008, 0xc008, 0xc808, 0xc809, 0xc809, 0xd009, 0xd809,
0xd00a, 0xd00a, 0xd00a, 0xd80b, 0xd80b, 0xd80b, 0xc80b, 0xd00b, 0xc80b,
0xc80b, 0xc00b, 0xc00a, 0xc80b, 0xc00b, 0xb80b, 0xb80b, 0xb80a, 0xb809,
0xc009, 0xb806, 0xc007, 0xc006, 0xc005, 0xc003, 0xc002, 0xc000, 0xb800,
0xb800, 0xb800, 0xc000, 0xc800, 0xd800, 0xf803, 0xf80b, 0xd800, 0xc000,
0xa800, 0xfb8c, 0x4800, 0x8802, 0xfa6b, 0xfa6b, 0xfa0c, 0xfa8c, 0xfacb,
0xfa8c, 0xfa2c, 0xfa6c, 0xfb0c, 0xfaec, 0xfa6c, 0xfa4c, 0xfaac, 0xfb4c,
0xfb4b, 0xfb2b, 0xfb2b, 0xfb4b, 0xfaab, 0xfaab, 0xfaab, 0xfacb, 0xfb2b,
0xfb8b, 0xfb8a, 0xfbca, 0xfc0a, 0xfc49, 0xfc49, 0xfc69, 0xfc49, 0xfc29,
0xfc49, 0xfc09, 0xfbc9, 0xfbc9, 0xfbc9, 0xfbc9, 0xfbe9, 0xfc28, 0xfc48,
0xfc48, 0xfc67, 0xfc47, 0xfc28, 0xfc08, 0xfbe8, 0xfbc8, 0xfba8, 0xfba8,
0xfbe7, 0xe8c1, 0xf809, 0xf808, 0xf809, 0xf809, 0xf808, 0xf808, 0xf809,
0xf80a, 0xf80c, 0xf80e, 0xf80f, 0xf80f, 0xf810, 0xf811, 0xf811, 0xf812,
0xf811, 0xf812, 0xf812, 0xf012, 0xe812, 0xe013, 0xd812, 0xd013, 0xc813,
0xc012, 0xb012, 0xa812, 0x9031, 0x8892, 0x8051, 0x78b2, 0x78d2, 0x70f2,
0x68b2, 0x6091, 0x5891, 0x4871, 0x4871, 0x4051, 0x48f2, 0x40b1, 0x38b1,
0x4131, 0x4131, 0x3910, 0x3910, 0x4131, 0x30f0, 0x3971, 0x3990, 0x3991,
0x8004, 0x8805, 0x8805, 0x9005, 0x9805, 0x9806, 0xa806, 0xb007, 0xb807,
0xc008, 0xc808, 0xc808, 0xc808, 0xc809, 0xd009, 0xd809, 0xd00a, 0xd00a,
0xd00a, 0xd80a, 0xd80a, 0xd80a, 0xd00a, 0xc80a, 0xc80a, 0xc00a, 0xc00a,
0xb80a, 0xd00b, 0xb80a, 0xb80a, 0xb80a, 0xb009, 0xb809, 0xb808, 0xb806,
0xb806, 0xb805, 0xc005, 0xb803, 0xc002, 0xc000, 0xb800, 0xb800, 0xb800,
0xc000, 0xc000, 0xd800, 0xf803, 0xf80b, 0xd800, 0xc000, 0xb000, 0xfb8c,
0x4800, 0x8802, 0xfaab, 0xfa6b, 0xfa2c, 0xfa8c, 0xfacb, 0xfaac, 0xfa0c,
0xfa6c, 0xfacc, 0xfb0c, 0xfa6b, 0xfa4c, 0xfacc, 0xfb2b, 0xfb2c, 0xfb2b,
0xfb2b, 0xfb2b, 0xfa8b, 0xfacb, 0xfb0b, 0xfb0b, 0xfb4b, 0xfb8a, 0xfbaa,
0xfbca, 0xfc2a, 0xfc49, 0xfc49, 0xfc68, 0xfc68, 0xfc48, 0xfc49, 0xfbe9,
0xfbc9, 0xfc09, 0xfc09, 0xfbe9, 0xfc09, 0xfc48, 0xfc68, 0xfc68, 0xfc67,
0xfc67, 0xfc28, 0xfc28, 0xfc08, 0xfbe8, 0xfbe8, 0xfbe8, 0xfc07, 0xe8c1,
0xf82a, 0xf808, 0xf809, 0xf809, 0xf809, 0xf808, 0xf809, 0xf80a, 0xf80b,
0xf80e, 0xf80f, 0xf810, 0xf810, 0xf811, 0xf811, 0xf811, 0xf811, 0xf812,
0xf812, 0xf012, 0xe812, 0xe012, 0xd812, 0xd013, 0xc813, 0xc012, 0xb812,
0xa812, 0x9051, 0x8891, 0x8091, 0x78b2, 0x7091, 0x70d2, 0x68b2, 0x5851,
0x5871, 0x4851, 0x4851, 0x4891, 0x48f2, 0x40b1, 0x40d1, 0x4111, 0x38f0,
0x38f1, 0x3910, 0x4130, 0x30f0, 0x4171, 0x3991, 0x3951, 0x8004, 0x8005,
0x8805, 0x9005, 0x9805, 0xa006, 0xa806, 0xb007, 0xb807, 0xc008, 0xc808,
0xc808, 0xd008, 0xd009, 0xd809, 0xd80a, 0xd80a, 0xd00a, 0xd00a, 0xe00a,
0xe00a, 0xd80a, 0xd00a, 0xc80a, 0xc80a, 0xc80a, 0xc00a, 0xc00a, 0xd02a,
0xb80a, 0xb80a, 0xb00a, 0xa809, 0xb008, 0xb007, 0xb007, 0xb806, 0xb805,
0xb804, 0xb802, 0xb801, 0xb800, 0xb000, 0xb800, 0xb800, 0xc000, 0xc000,
0xd800, 0xf803, 0xf80b, 0xd800, 0xc800, 0xb000, 0xfbcc, 0x5000, 0x8802,
0xfacb, 0xfaac, 0xfa6c, 0xfa8c, 0xfacb, 0xfaab, 0xfa4c, 0xfaac, 0xfacc,
0xfaec, 0xfaab, 0xfaac, 0xfacb, 0xfb2b, 0xfb2b, 0xfb2b, 0xfb4b, 0xfb4b,
0xfb0b, 0xfb0b, 0xfb4b, 0xfb2b, 0xfb4b, 0xfb8a, 0xfbca, 0xfbea, 0xfc29,
0xfc49, 0xfc69, 0xfc68, 0xfc68, 0xfc68, 0xfc48, 0xfc09, 0xfc09, 0xfc28,
0xfc29, 0xfbe9, 0xfc09, 0xfc48, 0xfc67, 0xfc67, 0xfc67, 0xfc67, 0xfc47,
0xfc27, 0xfc28, 0xfc08, 0xfbe8, 0xfbe8, 0xfc06, 0xe0a1, 0xf829, 0xf808,
0xf808, 0xf80a, 0xf809, 0xf808, 0xf809, 0xf80a, 0xf80b, 0xf80e, 0xf80f,
0xf810, 0xf810, 0xf811, 0xf812, 0xf812, 0xf811, 0xf812, 0xf812, 0xf012,
0xe812, 0xe013, 0xd812, 0xd012, 0xd013, 0xc012, 0xb812, 0xa812, 0x9031,
0x8851, 0x8091, 0x80d2, 0x78b2, 0x70b2, 0x6891, 0x6051, 0x5051, 0x4811,
0x4871, 0x4892, 0x48d1, 0x48b1, 0x40d1, 0x40f1, 0x40f1, 0x38f1, 0x4111,
0x3930, 0x30f0, 0x3950, 0x3950, 0x3930, 0x8005, 0x8805, 0x9805, 0x9805,
0x9806, 0xa806, 0xb007, 0xb807, 0xc007, 0xc808, 0xc808, 0xd008, 0xd009,
0xd809, 0xd809, 0xd80a, 0xd80a, 0xd80a, 0xd00a, 0xd80a, 0xe00a, 0xd80a,
0xd80a, 0xd00a, 0xc80a, 0xc809, 0xc00a, 0xc009, 0xd00a, 0xc00a, 0xb809,
0xb809, 0xa808, 0xb007, 0xb007, 0xb006, 0xb805, 0xb805, 0xb804, 0xb802,
0xb801, 0xb800, 0xb000, 0xb000, 0xb800, 0xc000, 0xc000, 0xd800, 0xf802,
0xf80c, 0xe000, 0xc800, 0xb800, 0xfbcc, 0x5800, 0xa065, 0xfaed, 0xfa8b,
0xfa8b, 0xfa8b, 0xfaab, 0xfaac, 0xfa8b, 0xfaab, 0xfaab, 0xfaeb, 0xfaac,
0xfacb, 0xfaeb, 0xfb0b, 0xfb2b, 0xfb2b, 0xfb6b, 0xfb6b, 0xfb2b, 0xfb0b,
0xfb4b, 0xfb2a, 0xfb4b, 0xfb8a, 0xfbca, 0xfbea, 0xfc29, 0xfc29, 0xfc49,
0xfc68, 0xfc68, 0xfc67, 0xfc68, 0xfc28, 0xfc28, 0xfc48, 0xfc28, 0xfc09,
0xfc08, 0xfc47, 0xfc47, 0xfc67, 0xfc67, 0xfc47, 0xfc47, 0xfc47, 0xfc28,
0xfc08, 0xfc08, 0xfc08, 0xfc07, 0xe8a1, 0xf809, 0xf808, 0xf808, 0xf809,
0xf809, 0xf808, 0xf809, 0xf80a, 0xf80b, 0xf80e, 0xf80f, 0xf80f, 0xf810,
0xf811, 0xf811, 0xf812, 0xf811, 0xf812, 0xf812, 0xf012, 0xe813, 0xe013,
0xd812, 0xd012, 0xc813, 0xc012, 0xb812, 0xa812, 0xa0b2, 0x9051, 0x8071,
0x7871, 0x7071, 0x6871, 0x6051, 0x5831, 0x5051, 0x4831, 0x4891, 0x48d2,
0x48d2, 0x48f1, 0x40d1, 0x40f1, 0x38d1, 0x4111, 0x38d0, 0x4111, 0x30d0,
0x3951, 0x3930, 0x3110, 0x8805, 0x8805, 0x9005, 0x9805, 0x9805, 0xa006,
0xb007, 0xb807, 0xc008, 0xc808, 0xc809, 0xd009, 0xd009, 0xd809, 0xd809,
0xe00a, 0xd80a, 0xd80a, 0xd009, 0xe00a, 0xe00a, 0xd80a, 0xd80a, 0xd00a,
0xc80a, 0xc809, 0xc80a, 0xc009, 0xd00a, 0xc009, 0xb809, 0xb809, 0xa808,
0xb007, 0xb007, 0xb006, 0xb805, 0xb804, 0xb804, 0xb802, 0xb801, 0xb800,
0xb000, 0xb000, 0xb800, 0xc000, 0xc000, 0xd800, 0xf802, 0xf80c, 0xe000,
0xd000, 0xc000, 0xfbec, 0x5800, 0xc1ca, 0xfa6c, 0xfa4c, 0xfa8b, 0xfa6c,
0xfaab, 0xfaab, 0xfacb, 0xfacb, 0xfacc, 0xfb0b, 0xfacb, 0xfb0b, 0xfaeb,
0xfb0b, 0xfb2b, 0xfb4b, 0xfb8a, 0xfb6b, 0xfb4b, 0xfb2b, 0xfb6a, 0xfb4b,
0xfb4b, 0xfbcb, 0xfbca, 0xfc0a, 0xfc29, 0xfc69, 0xfc49, 0xfc69, 0xfc68,
0xfc87, 0xfc68, 0xfc49, 0xfc48, 0xfc68, 0xfc48, 0xfc29, 0xfc28, 0xfc47,
0xfc87, 0xfc67, 0xfc67, 0xfc67, 0xfc47, 0xfc67, 0xfc68, 0xfc48, 0xfc28,
0xfc08, 0xfc07, 0xe8a1, 0xf809, 0xf808, 0xf809, 0xf809, 0xf809, 0xf809,
0xf80a, 0xf80b, 0xf80c, 0xf80e, 0xf80f, 0xf810, 0xf810, 0xf811, 0xf811,
0xf812, 0xf812, 0xf812, 0xf812, 0xf012, 0xe812, 0xe012, 0xd812, 0xd012,
0xc813, 0xc012, 0xb812, 0xa812, 0x9871, 0x9071, 0x8871, 0x7831, 0x7872,
0x7071, 0x6871, 0x6051, 0x5051, 0x4851, 0x4891, 0x48b2, 0x48b1, 0x48f1,
0x40d1, 0x40f1, 0x38d0, 0x4110, 0x3911, 0x4131, 0x30cf, 0x3950, 0x3930,
0x3110, 0x8805, 0x9005, 0x9805, 0x9806, 0x9806, 0xa806, 0xb007, 0xb807,
0xc008, 0xc808, 0xd008, 0xd009, 0xd009, 0xd809, 0xd809, 0xd80a, 0xd80a,
0xd80a, 0xd80a, 0xe00a, 0xe80a, 0xd80a, 0xd80a, 0xd00a, 0xd00a, 0xc80a,
0xc80a, 0xc009, 0xd00a, 0xc009, 0xb809, 0xb809, 0xb008, 0xb007, 0xb007,
0xb006, 0xb805, 0xb804, 0xb803, 0xc002, 0xb801, 0xb800, 0xb800, 0xb800,
0xb800, 0xc000, 0xc800, 0xd800, 0xf802, 0xf82c, 0xe000, 0xd000, 0xc000,
0xfc0c, 0x5800, 0xb928, 0xf9ab, 0xfa2b, 0xfa6b, 0xfa4b, 0xfa8b, 0xfaab,
0xfacc, 0xfaab, 0xfacb, 0xfaeb, 0xfaeb, 0xfb0b, 0xfaeb, 0xfb2b, 0xfb2b,
0xfb2b, 0xfb6b, 0xfbab, 0xfb4b, 0xfb4a, 0xfb6a, 0xfb4a, 0xfb4b, 0xfb6a,
0xfbca, 0xfbea, 0xfc29, 0xfc29, 0xfc69, 0xfc69, 0xfc68, 0xfc88, 0xfc87,
0xfc48, 0xfc48, 0xfc68, 0xfc48, 0xfc29, 0xfc28, 0xfc47, 0xfc67, 0xfc67,
0xfc67, 0xfc67, 0xfc47, 0xfc47, 0xfc48, 0xfc28, 0xfc08, 0xfbe8, 0xfc07,
0xe8a1, 0xf809, 0xf808, 0xf808, 0xf80a, 0xf809, 0xf809, 0xf809, 0xf80b,
0xf80c, 0xf80e, 0xf80f, 0xf810, 0xf810, 0xf811, 0xf811, 0xf812, 0xf811,
0xf812, 0xf812, 0xf012, 0xe812, 0xe012, 0xd812, 0xd012, 0xd013, 0xc012,
0xb812, 0xa812, 0x9871, 0x9091, 0x8011, 0x7851, 0x7051, 0x7071, 0x6871,
0x5851, 0x5071, 0x5071, 0x5092, 0x4871, 0x4091, 0x48f1, 0x40d1, 0x40f1,
0x4111, 0x4131, 0x38f1, 0x4131, 0x30d0, 0x3931, 0x3110, 0x3110, 0x8805,
0x9005, 0x9806, 0x9806, 0xa006, 0xa806, 0xb007, 0xb807, 0xc808, 0xc808,
0xd009, 0xd009, 0xd809, 0xd809, 0xe00a, 0xe00a, 0xd80a, 0xd80a, 0xe00b,
0xe80b, 0xe00b, 0xd80a, 0xd80a, 0xd80a, 0xd00a, 0xc80a, 0xc80a, 0xc80a,
0xd80a, 0xc009, 0xb809, 0xb80a, 0xb008, 0xb008, 0xb808, 0xb806, 0xc005,
0xc004, 0xc004, 0xc002, 0xc001, 0xc000, 0xc000, 0xc000, 0xc000, 0xc800,
0xc800, 0xe000, 0xf802, 0xf88c, 0xe800, 0xd800, 0xc800, 0xfc0c, 0x5800,
0xb148, 0xf8ab, 0xf9eb, 0xf9eb, 0xfa2b, 0xfa6b, 0xfa6b, 0xfa6b, 0xfa6b,
0xfaac, 0xfaab, 0xfacc, 0xfaac, 0xfacb, 0xfb0b, 0xfaeb, 0xfb0b, 0xfb4b,
0xfb6b, 0xfb2b, 0xfb4b, 0xfb4b, 0xfb2b, 0xfb4b, 0xfb6a, 0xfbca, 0xfc0a,
0xfc0a, 0xfc2a, 0xfc69, 0xfc89, 0xfc69, 0xfc68, 0xfc88, 0xfc68, 0xfc48,
0xfc68, 0xfc48, 0xfc28, 0xfc48, 0xfc68, 0xfc47, 0xfc67, 0xfc87, 0xfc67,
0xfc47, 0xfc48, 0xfc28, 0xfc28, 0xfc08, 0xfbe8, 0xfbe7, 0xe8a1, 0xf809,
0xf808, 0xf808, 0xf80a, 0xf80a, 0xf80a, 0xf80a, 0xf80b, 0xf80c, 0xf80e,
0xf80f, 0xf80f, 0xf810, 0xf811, 0xf811, 0xf811, 0xf811, 0xf812, 0xf812,
0xf012, 0xe812, 0xe012, 0xd812, 0xd012, 0xd013, 0xc012, 0xb812, 0xa812,
0x9872, 0x9092, 0x8011, 0x7831, 0x7071, 0x7092, 0x6871, 0x5010, 0x5071,
0x4851, 0x4871, 0x4051, 0x4891, 0x4912, 0x40d1, 0x4111, 0x4111, 0x4110,
0x4131, 0x4951, 0x30d0, 0x3931, 0x3930, 0x3950, 0x8805, 0x9005, 0x9805,
0xa006, 0xa806, 0xa806, 0xb807, 0xc008, 0xc808, 0xd008, 0xd009, 0xd809,
0xd809, 0xd80a, 0xe00a, 0xd80a, 0xe00b, 0xd80a, 0xe00b, 0xe80b, 0xe80b,
0xd80b, 0xe00b, 0xd80b, 0xd00b, 0xd00b, 0xd00a, 0xc80a, 0xd80b, 0xc00a,
0xc00a, 0xb80a, 0xb009, 0xb808, 0xc008, 0xc007, 0xc806, 0xc005, 0xc004,
0xc002, 0xc800, 0xc800, 0xc800, 0xc000, 0xc800, 0xd000, 0xd000, 0xe000,
0xf803, 0xf8ed, 0xe800, 0xe000, 0xd000, 0xfc6d, 0x5800, 0xb968, 0xf809,
0xf8eb, 0xf96b, 0xf9ac, 0xfa0b, 0xfa2b, 0xfa0c, 0xfa2c, 0xfa6c, 0xfa4b,
0xfa6c, 0xfa6b, 0xfa8c, 0xfacb, 0xfacb, 0xfaeb, 0xfb0b, 0xfaeb, 0xfacb,
0xfb0b, 0xfb2b, 0xfb0b, 0xfb2b, 0xfb6b, 0xfbca, 0xfbca, 0xfbea, 0xfc0a,
0xfc49, 0xfc49, 0xfc49, 0xfc49, 0xfc49, 0xfc49, 0xfc49, 0xfc68, 0xfc48,
0xfc29, 0xfc48, 0xfc48, 0xfc68, 0xfc67, 0xfc67, 0xfc47, 0xfc48, 0xfc48,
0xfc28, 0xfc08, 0xfbe8, 0xfbe8, 0xfbe8, 0xe080, 0xf809, 0xf809, 0xf809,
0xf80c, 0xf80b, 0xf80a, 0xf80a, 0xf80b, 0xf80c, 0xf80e, 0xf80f, 0xf80f,
0xf810, 0xf811, 0xf811, 0xf811, 0xf812, 0xf812, 0xf812, 0xf012, 0xf012,
0xe013, 0xd812, 0xd012, 0xd013, 0xc012, 0xc012, 0xa812, 0x9851, 0x9091,
0x8071, 0x7871, 0x6851, 0x70b2, 0x6071, 0x5831, 0x5071, 0x4871, 0x4872,
0x4871, 0x4891, 0x5132, 0x40f1, 0x4111, 0x38f0, 0x4111, 0x4131, 0x4151,
0x3910, 0x3971, 0x3950, 0x41b1, 0x8805, 0x9005, 0x9805, 0xa806, 0xa806,
0xb007, 0xb807, 0xc008, 0xc808, 0xd008, 0xd008, 0xd80a, 0xd80a, 0xd80a,
0xe00b, 0xe00b, 0xe00b, 0xe00b, 0xe00b, 0xe80b, 0xe80b, 0xe00b, 0xe00b,
0xd80b, 0xd80c, 0xd00b, 0xd00c, 0xd00c, 0xd80c, 0xc80b, 0xc00b, 0xc00b,
0xb80a, 0xc009, 0xc009, 0xc007, 0xd007, 0xc805, 0xc805, 0xd003, 0xc802,
0xd000, 0xd000, 0xc800, 0xd000, 0xd000, 0xd800, 0xe800, 0xf804, 0xf94e,
0xf001, 0xe000, 0xd000, 0xfc4d, 0x6000, 0xb968, 0xf80a, 0xf88b, 0xf94b,
0xf9ab, 0xf9eb, 0xf9eb, 0xfa0c, 0xfa4c, 0xfa4c, 0xfa4c, 0xfa6c, 0xfa6c,
0xfa8c, 0xfaab, 0xfaab, 0xfacb, 0xfaeb, 0xfb2b, 0xfaeb, 0xfb0b, 0xfb0b,
0xfb0b, 0xfb2a, 0xfb6b, 0xfbaa, 0xfbca, 0xfbea, 0xfc0a, 0xfc09, 0xfc29,
0xfc29, 0xfc49, 0xfc89, 0xfc88, 0xfc68, 0xfc68, 0xfc48, 0xfc49, 0xfc48,
0xfc48, 0xfc68, 0xfc67, 0xfc67, 0xfc48, 0xfc48, 0xfc28, 0xfc09, 0xfbe8,
0xfbe8, 0xfbe9, 0xfc08, 0xe8a0, 0xf809, 0xf809, 0xf809, 0xf80c, 0xf80b,
0xf809, 0xf80a, 0xf80b, 0xf80c, 0xf80e, 0xf80f, 0xf80f, 0xf810, 0xf811,
0xf811, 0xf812, 0xf812, 0xf812, 0xf812, 0xf012, 0xe812, 0xe013, 0xd812,
0xd012, 0xd013, 0xc013, 0xb812, 0xa812, 0x9011, 0x8851, 0x8031, 0x7831,
0x7071, 0x6891, 0x6891, 0x5831, 0x5071, 0x4871, 0x4891, 0x4892, 0x4891,
0x40d1, 0x40f1, 0x40f1, 0x40f1, 0x38f1, 0x4151, 0x4971, 0x3930, 0x41b1,
0x4191, 0x41b1, 0x8805, 0x8805, 0xa006, 0xa806, 0xa807, 0xb007, 0xc007,
0xc008, 0xd008, 0xd809, 0xd809, 0xd809, 0xd80a, 0xe00a, 0xe00b, 0xe00b,
0xe00c, 0xe00b, 0xe80c, 0xe80c, 0xe80c, 0xe80c, 0xe00c, 0xe00c, 0xe00d,
0xd00d, 0xd80d, 0xd80c, 0xe00d, 0xc80c, 0xc80d, 0xc80d, 0xc00b, 0xc80b,
0xd00b, 0xd00a, 0xd80a, 0xd007, 0xd807, 0xd806, 0xd804, 0xd801, 0xd800,
0xd800, 0xd800, 0xe000, 0xe800, 0xf000, 0xf805, 0xf98e, 0xf001, 0xe000,
0xd801, 0xfc4d, 0x6800, 0xb968, 0xf80a, 0xf88b, 0xf92b, 0xf9cc, 0xf9ec,
0xf9cb, 0xfa0b, 0xfa2c, 0xfa6c, 0xfa4c, 0xfa4c, 0xfa4c, 0xfa8b, 0xfaac,
0xfa8b, 0xfaab, 0xfaeb, 0xfb2b, 0xfaeb, 0xfb0b, 0xfb0b, 0xfaea, 0xfb2a,
0xfb4b, 0xfb8a, 0xfb8b, 0xfbca, 0xfbea, 0xfc0a, 0xfc2a, 0xfc49, 0xfc49,
0xfc89, 0xfca9, 0xfc88, 0xfca8, 0xfc68, 0xfc68, 0xfc48, 0xfc48, 0xfc48,
0xfc68, 0xfc88, 0xfc67, 0xfc48, 0xfc29, 0xfc29, 0xfbe9, 0xfbe9, 0xfbe9,
0xfc08, 0xe880, 0xf80a, 0xf80a, 0xf80a, 0xf80b, 0xf80a, 0xf809, 0xf80b,
0xf80b, 0xf80b, 0xf80e, 0xf80f, 0xf80f, 0xf810, 0xf811, 0xf811, 0xf812,
0xf811, 0xf812, 0xf812, 0xf012, 0xe813, 0xe013, 0xd812, 0xd013, 0xd013,
0xc812, 0xb812, 0xa812, 0x9011, 0x8851, 0x8031, 0x7031, 0x7091, 0x70d2,
0x6892, 0x6071, 0x5051, 0x4871, 0x50b2, 0x4871, 0x4891, 0x48f1, 0x40f1,
0x40f1, 0x4111, 0x38f0, 0x4171, 0x4991, 0x3971, 0x41d1, 0x41b1, 0x41d1,
0x8805, 0x8805, 0x9806, 0xa806, 0xb007, 0xb007, 0xc007, 0xc007, 0xd008,
0xd809, 0xd80a, 0xd80a, 0xe00a, 0xe00b, 0xe80b, 0xe80c, 0xe80c, 0xe80c,
0xe80c, 0xf00c, 0xf00d, 0xe80d, 0xe80d, 0xe00d, 0xe00d, 0xd80e, 0xe00e,
0xd80e, 0xe00e, 0xd00f, 0xc80f, 0xd00f, 0xc80e, 0xd00e, 0xd80e, 0xd80d,
0xe80d, 0xe00b, 0xe80b, 0xe809, 0xe807, 0xe806, 0xe804, 0xe803, 0xf001,
0xe800, 0xf000, 0xf801, 0xf807, 0xf9ce, 0xf803, 0xe800, 0xe002, 0xfc4e,
0x7000, 0xc169, 0xf80b, 0xf80b, 0xf88c, 0xf94c, 0xf98c, 0xf9cc, 0xf9cc,
0xfa0c, 0xf9ec, 0xf9ec, 0xfa0c, 0xfa0c, 0xfa2c, 0xfa2c, 0xfa6b, 0xfa8b,
0xfaab, 0xfaca, 0xfaaa, 0xfa8a, 0xfacb, 0xfaab, 0xfacb, 0xfb0b, 0xfb6b,
0xfb4b, 0xfb6b, 0xfbab, 0xfbeb, 0xfc2a, 0xfc4a, 0xfc49, 0xfc89, 0xfc69,
0xfc69, 0xfca9, 0xfc88, 0xfc48, 0xfc48, 0xfc48, 0xfc48, 0xfc68, 0xfc68,
0xfc67, 0xfc48, 0xfc28, 0xfc08, 0xfbc9, 0xfbc9, 0xfbc9, 0xfc09, 0xe0a0,
0xf80a, 0xf80a, 0xf80a, 0xf80b, 0xf80a, 0xf80a, 0xf80b, 0xf80b, 0xf80b,
0xf80e, 0xf80f, 0xf810, 0xf810, 0xf831, 0xf811, 0xf812, 0xf812, 0xf812,
0xf812, 0xf012, 0xe813, 0xe013, 0xd813, 0xd013, 0xd013, 0xc812, 0xb812,
0xa811, 0x9051, 0x8851, 0x8031, 0x7031, 0x70d2, 0x70d2, 0x6091, 0x6092,
0x5031, 0x5071, 0x4891, 0x4871, 0x4891, 0x48d1, 0x4912, 0x38d1, 0x40f1,
0x4110, 0x4171, 0x4191, 0x3930, 0x41d1, 0x41d1, 0x41b1, 0x8805, 0x9806,
0x9806, 0xa807, 0xb007, 0xb007, 0xc008, 0xc808, 0xd009, 0xd809, 0xe00a,
0xe00a, 0xe00b, 0xe80c, 0xe80c, 0xe80c, 0xe80d, 0xe80d, 0xf00d, 0xf00d,
0xf00e, 0xf00e, 0xe80e, 0xe80f, 0xe80f, 0xe010, 0xe010, 0xe010, 0xe811,
0xd811, 0xd811, 0xd811, 0xd010, 0xe010, 0xe810, 0xe810, 0xf010, 0xf00f,
0xf80e, 0xf80d, 0xf80c, 0xf80b, 0xf80a, 0xf809, 0xf807, 0xf807, 0xf806,
0xf807, 0xf80a, 0xfa0f, 0xf808, 0xf004, 0xe804, 0xfc4f, 0x7800, 0xc94a,
0xf80d, 0xf80c, 0xf88c, 0xf90c, 0xf94c, 0xf98c, 0xf9ad, 0xf9ad, 0xf9ec,
0xf9ed, 0xf9ec, 0xf9ec, 0xfa0c, 0xf9ac, 0xf9ab, 0xf9eb, 0xfa4b, 0xfaab,
0xfa8b, 0xfa6b, 0xfaab, 0xfa8b, 0xfa8b, 0xfacb, 0xfb2b, 0xfb2b, 0xfb2b,
0xfb6b, 0xfb8b, 0xfbca, 0xfc0a, 0xfc49, 0xfc49, 0xfc49, 0xfc49, 0xfc89,
0xfc88, 0xfc88, 0xfc69, 0xfc68, 0xfc68, 0xfc68, 0xfc69, 0xfc48, 0xfc49,
0xfc09, 0xfbe9, 0xfbc9, 0xfbc9, 0xfbc9, 0xfc08, 0xe080, 0xf84b, 0xf80a,
0xf80a, 0xf80b, 0xf80a, 0xf80a, 0xf80b, 0xf80c, 0xf80c, 0xf80e, 0xf80f,
0xf810, 0xf810, 0xf851, 0xf811, 0xf812, 0xf812, 0xf812, 0xf812, 0xf013,
0xe813, 0xe013, 0xe013, 0xd013, 0xd013, 0xc012, 0xb812, 0xa812, 0x9091,
0x8871, 0x8011, 0x7071, 0x70f2, 0x70d2, 0x6891, 0x6092, 0x5851, 0x5071,
0x5092, 0x4871, 0x4891, 0x40d1, 0x40f1, 0x40f1, 0x38d1, 0x4131, 0x4171,
0x4191, 0x3971, 0x41b1, 0x41b1, 0x41b1, 0x9006, 0x9806, 0xa007, 0xb007,
0xb008, 0xb008, 0xc008, 0xc809, 0xd009, 0xd80a, 0xe00a, 0xe00b, 0xe80c,
0xe80c, 0xf00d, 0xf00d, 0xf00e, 0xf00e, 0xf00e, 0xf00e, 0xf00f, 0xf010,
0xf010, 0xf010, 0xe810, 0xe011, 0xe811, 0xe812, 0xe812, 0xe012, 0xe012,
0xe012, 0xe812, 0xe812, 0xf011, 0xf811, 0xf811, 0xf810, 0xf810, 0xf810,
0xf80f, 0xf80f, 0xf80f, 0xf80e, 0xf80d, 0xf80d, 0xf80c, 0xf80c, 0xf80d,
0xfab0, 0xf80b, 0xf809, 0xf808, 0xfc6f, 0x9000, 0xd14a, 0xf80e, 0xf88d,
0xf88d, 0xf82d, 0xf8ee, 0xf90d, 0xf92d, 0xf8ed, 0xf92d, 0xf96d, 0xf96d,
0xf90c, 0xf90d, 0xf12b, 0xe8aa, 0xf96b, 0xf18a, 0xf9cb, 0xf9ab, 0xfa0b,
0xfa0b, 0xfa2c, 0xfa8c, 0xfacc, 0xfaac, 0xfacc, 0xfb2c, 0xfb2c, 0xfb4b,
0xfb6a, 0xfb6a, 0xf3ca, 0xfc2a, 0xfc4a, 0xfc4a, 0xfc69, 0xfc69, 0xfc69,
0xfc69, 0xfc69, 0xfc69, 0xfc49, 0xfc49, 0xfc29, 0xfc29, 0xfc09, 0xfc09,
0xfbe9, 0xfbc9, 0xfbc9, 0xfc08, 0xe880, 0xf80a, 0xf80b, 0xf80b, 0xf80b,
0xf80a, 0xf80a, 0xf80b, 0xf80b, 0xf80c, 0xf80e, 0xf80f, 0xf810, 0xf810,
0xf851, 0xf811, 0xf812, 0xf811, 0xf812, 0xf813, 0xf013, 0xe813, 0xe013,
0xd813, 0xd813, 0xd013, 0xc012, 0xb812, 0xa812, 0x90d2, 0x88b2, 0x7811,
0x7071, 0x70d2, 0x70f2, 0x68d2, 0x60b2, 0x5031, 0x4851, 0x4891, 0x4891,
0x4892, 0x48b1, 0x48f1, 0x40d1, 0x40f1, 0x4151, 0x4151, 0x4171, 0x3950,
0x41d1, 0x41d1, 0x39b1, 0x9806, 0x9807, 0xa007, 0xb008, 0xc008, 0xc009,
0xc809, 0xd00a, 0xd80a, 0xe00b, 0xe00c, 0xe80c, 0xe80d, 0xf00d, 0xf00e,
0xf00f, 0xf00f, 0xf00f, 0xf010, 0xf810, 0xf811, 0xf811, 0xf011, 0xf012,
0xf011, 0xf012, 0xf012, 0xf012, 0xf012, 0xf012, 0xf012, 0xf012, 0xf012,
0xf812, 0xf812, 0xf811, 0xf812, 0xf811, 0xf811, 0xf811, 0xf811, 0xf811,
0xf810, 0xf810, 0xf80f, 0xf80f, 0xf80e, 0xf80e, 0xf86d, 0xfb2f, 0xf80d,
0xf80d, 0xf80c, 0xfc6f, 0xa800, 0xd98a, 0xf08f, 0xf90e, 0xf8ee, 0xf80f,
0xf82e, 0xf8ee, 0xf92e, 0xf8ef, 0xf8cf, 0xf92e, 0xf94e, 0xf16d, 0xf88e,
0xf00e, 0xe86c, 0xf98c, 0xf9ec, 0xf94d, 0xf94c, 0xf9ac, 0xf9cc, 0xf12b,
0xf14e, 0xf9ce, 0xfa8e, 0xfa4d, 0xfa2e, 0xfa4e, 0xfa6d, 0xfaec, 0xfbec,
0xfc8c, 0xfc2b, 0xfc0c, 0xfc4b, 0xfc6b, 0xfc6a, 0xfc6a, 0xfc6a, 0xfc69,
0xfc69, 0xfc49, 0xfc29, 0xfc49, 0xfc29, 0xfc29, 0xfc29, 0xfbe9, 0xfbc9,
0xfbc9, 0xfc08, 0xe080, 0xf84b, 0xf80b, 0xf80a, 0xf80b, 0xf80a, 0xf80a,
0xf80b, 0xf80b, 0xf80c, 0xf80e, 0xf8cf, 0xf82f, 0xf810, 0xf851, 0xf852,
0xf812, 0xf812, 0xf812, 0xf813, 0xf013, 0xe813, 0xe013, 0xe013, 0xd813,
0xd013, 0xc012, 0xb812, 0xb012, 0x9112, 0x90f2, 0x7851, 0x78b2, 0x70b1,
0x68b2, 0x68f2, 0x60b2, 0x5051, 0x4871, 0x48b1, 0x48d2, 0x48d2, 0x48d1,
0x4912, 0x4111, 0x4111, 0x4151, 0x4171, 0x4191, 0x4191, 0x41f1, 0x41d1,
0x41d1, 0x9807, 0xa008, 0xa808, 0xc009, 0xc00a, 0xc80a, 0xc80b, 0xd00b,
0xd80c, 0xe00d, 0xe80d, 0xe80e, 0xf00f, 0xf00f, 0xf010, 0xf010, 0xf011,
0xf011, 0xf011, 0xf811, 0xf811, 0xf812, 0xf012, 0xf812, 0xf012, 0xf012,
0xf012, 0xf812, 0xf813, 0xf813, 0xf813, 0xf813, 0xf813, 0xf812, 0xf832,
0xf892, 0xf8b2, 0xf913, 0xf953, 0xf972, 0xf992, 0xf9b2, 0xf9d1, 0xf9d1,
0xf9b0, 0xf9b0, 0xf9af, 0xf9af, 0xfa0e, 0xfb90, 0xf8ee, 0xf80d, 0xf80d,
0xfcb0, 0xb800, 0xe98b, 0xf950, 0xf930, 0xf970, 0xf870, 0xf80f, 0xf8cf,
0xf950, 0xf90f, 0xf90f, 0xf90f, 0xf96f, 0xf94e, 0xf8ae, 0xf86f, 0xf8ce,
0xf98d, 0xf9ed, 0xf98d, 0xf90e, 0xf94d, 0xf9cd, 0xf9ce, 0xf98f, 0xfa4f,
0xfacf, 0xfaaf, 0xfa4f, 0xfaaf, 0xface, 0xfb2d, 0xfbad, 0xfc6d, 0xfc6d,
0xfc2c, 0xfc6c, 0xfcac, 0xfc8c, 0xfc8b, 0xfc8b, 0xfcab, 0xfc8b, 0xfc8b,
0xfc6a, 0xfc4a, 0xfc2a, 0xfc2a, 0xfc0a, 0xfbe9, 0xfbc9, 0xfbe9, 0xfc08,
0xe080, 0xf88b, 0xf80b, 0xf80a, 0xf80b, 0xf80a, 0xf80a, 0xf80a, 0xf80b,
0xf80c, 0xf82f, 0xf890, 0xf890, 0xf870, 0xf872, 0xf852, 0xf812, 0xf812,
0xf812, 0xf813, 0xe813, 0xe013, 0xe013, 0xd814, 0xd013, 0xd013, 0xc013,
0xb812, 0xb052, 0x9932, 0x9112, 0x80d2, 0x78f2, 0x70d2, 0x68d2, 0x68f2,
0x60d2, 0x5071, 0x50b1, 0x48d1, 0x48b1, 0x48f2, 0x4932, 0x40f1, 0x4131,
0x4131, 0x4991, 0x4191, 0x4191, 0x4191, 0x4a32, 0x41d1, 0x39d1, 0xa809,
0xa80a, 0xb00a, 0xc00b, 0xc80c, 0xc80c, 0xd00d, 0xd80d, 0xd80e, 0xe00e,
0xe00f, 0xe810, 0xe810, 0xe811, 0xf011, 0xf011, 0xf012, 0xf012, 0xf012,
0xf012, 0xf012, 0xf812, 0xf812, 0xf012, 0xf813, 0xf813, 0xf813, 0xf813,
0xf813, 0xf853, 0xf893, 0xf8f4, 0xf934, 0xf973, 0xf9d4, 0xfa14, 0xfa34,
0xfa53, 0xfa93, 0xfab3, 0xfab2, 0xfad2, 0xfad1, 0xfad1, 0xfad0, 0xfad0,
0xfaaf, 0xfaaf, 0xfaae, 0xfc10, 0xfa2f, 0xf92e, 0xf00d, 0xfcb0, 0xc800,
0xe9cb, 0xfa71, 0xfa31, 0xfa31, 0xf9b0, 0xf9f1, 0xf9f1, 0xf970, 0xf930,
0xf92f, 0xf8af, 0xf82e, 0xf80d, 0xf84e, 0xf82d, 0xf82d, 0xf8ed, 0xf94d,
0xf8ed, 0xf84d, 0xf88d, 0xf94d, 0xf9ae, 0xfa0f, 0xfa8f, 0xfacf, 0xfaaf,
0xfacf, 0xfaee, 0xfb0e, 0xfb4d, 0xfbad, 0xfc0d, 0xfc6d, 0xfc2d, 0xfc6c,
0xfc8c, 0xfc8c, 0xfc8c, 0xfc8b, 0xfcac, 0xfc6b, 0xfc8b, 0xfc8b, 0xfc4a,
0xfc2a, 0xfc2a, 0xfbea, 0xfbca, 0xfbca, 0xfbca, 0xfc09, 0xe060, 0xf86b,
0xf80b, 0xf80a, 0xf80a, 0xf80a, 0xf80a, 0xf80a, 0xf80c, 0xf80c, 0xf80e,
0xf80f, 0xf8d0, 0xf890, 0xf871, 0xf852, 0xf812, 0xf812, 0xf813, 0xf813,
0xe813, 0xe013, 0xe013, 0xd814, 0xc813, 0xc813, 0xc013, 0xb812, 0xa872,
0x9132, 0x8953, 0x80f2, 0x7932, 0x68f2, 0x68f2, 0x60f2, 0x58f2, 0x5091,
0x50f2, 0x48f1, 0x48f1, 0x4912, 0x5172, 0x4111, 0x4151, 0x4191, 0x49d2,
0x41b1, 0x4191, 0x4191, 0x4212, 0x41f1, 0x41f1, 0xb00b, 0xb00c, 0xb80c,
0xc80d, 0xd00d, 0xd00e, 0xd00f, 0xd80f, 0xd810, 0xe010, 0xe011, 0xe811,
0xe811, 0xe812, 0xe812, 0xe812, 0xe812, 0xf012, 0xf012, 0xf012, 0xf013,
0xf013, 0xf813, 0xf813, 0xf833, 0xf854, 0xf8d4, 0xf8f4, 0xf974, 0xf994,
0xf9d4, 0xfa14, 0xfa14, 0xfa54, 0xfab4, 0xfad4, 0xfad4, 0xfb14, 0xfb34,
0xfb53, 0xfb72, 0xfb72, 0xfb71, 0xfb91, 0xfb70, 0xfb6f, 0xfb6e, 0xfb4e,
0xfb4d, 0xfc6f, 0xfa6e, 0xf9ce, 0xf02d, 0xfcd0, 0xd801, 0xe98a, 0xfa10,
0xf210, 0xfa51, 0xfa31, 0xfa31, 0xf9f0, 0xf96f, 0xf14f, 0xf90f, 0xf8ae,
0xf80e, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf00c, 0xf80c, 0xf80c,
0xf80c, 0xf84c, 0xf98e, 0xfa0e, 0xfa6e, 0xface, 0xfaef, 0xface, 0xface,
0xfaee, 0xfb2d, 0xfb6d, 0xfbcc, 0xfc2c, 0xfc4c, 0xfc8c, 0xfcac, 0xfcac,
0xfcac, 0xfc8b, 0xfc8b, 0xfc8b, 0xfc8b, 0xfc6a, 0xfc6a, 0xfc4a, 0xfc0a,
0xfbea, 0xfbca, 0xfbca, 0xfba9, 0xfbe8, 0xe060, 0xf82b, 0xf80a, 0xf80b,
0xfe65, 0xe9ca, 0xf809, 0xf02a, 0xf80b, 0xf80c, 0xf86e, 0xf8cf, 0xf8d0,
0xf8f0, 0xf8b1, 0xf872, 0xf812, 0xf812, 0xf813, 0xf813, 0xe813, 0xe014,
0xe014, 0xd013, 0xd073, 0xc833, 0xc053, 0xb893, 0xa052, 0x9152, 0x8952,
0x8152, 0x7132, 0x6912, 0x6112, 0x6112, 0x6132, 0x50d2, 0x5112, 0x4912,
0x4912, 0x4952, 0x4992, 0x4972, 0x4171, 0x49f2, 0x49f2, 0x41d1, 0x4191,
0x41b1, 0x41f1, 0x41f1, 0x41f1, 0xb80d, 0xb80e, 0xc00f, 0xc80f, 0xc80f,
0xd010, 0xd010, 0xd010, 0xd011, 0xd811, 0xe012, 0xe012, 0xe012, 0xe813,
0xe813, 0xe813, 0xe813, 0xe813, 0xf013, 0xf013, 0xf013, 0xf013, 0xf074,
0xf8d4, 0xf934, 0xf954, 0xf9b5, 0xf9d5, 0xfa15, 0xfa35, 0xfa75, 0xfa95,
0xfab5, 0xfaf4, 0xfb34, 0xfb54, 0xfb74, 0xfb94, 0xfbb3, 0xfbd3, 0xfbd2,
0xfbd1, 0xfbf0, 0xfbf0, 0xfbef, 0xfbef, 0xfbee, 0xfbed, 0xfbed, 0xfccf,
0xfa8e, 0xf9ee, 0xf02c, 0xfcf0, 0xd000, 0xe9ca, 0xfa50, 0xfa51, 0xfa71,
0xfa50, 0xfa10, 0xf9f0, 0xf9f0, 0xf9b0, 0xf950, 0xf8af, 0xf84e, 0xf80d,
0xf80d, 0xf80d, 0xf80d, 0xf80e, 0xf80e, 0xf82d, 0xf88d, 0xf8ad, 0xf90d,
0xf9ae, 0xfa2e, 0xfa6f, 0xfacf, 0xfacf, 0xfacf, 0xface, 0xface, 0xfaed,
0xfb4d, 0xfbcd, 0xfc2d, 0xfc6c, 0xfc8d, 0xfcac, 0xfc8c, 0xfc8c, 0xfc6c,
0xfc6b, 0xfc6b, 0xfcaa, 0xfc8a, 0xfc6a, 0xfc2a, 0xfc2a, 0xfc0a, 0xfbea,
0xfbca, 0xfbc9, 0xfc09, 0xe080, 0xf9cd, 0xf80a, 0xf80a, 0xfe47, 0xc282,
0x9000, 0x7800, 0xd848, 0xf80b, 0xf80e, 0xf8f0, 0xf910, 0xf910, 0xf8f1,
0xf8b2, 0xf852, 0xf812, 0xf812, 0xf813, 0xe813, 0xe814, 0xe014, 0xd814,
0xc813, 0xc053, 0xb072, 0xb8d3, 0xa0d2, 0x8952, 0x8993, 0x8193, 0x7172,
0x6952, 0x6132, 0x6132, 0x6153, 0x5152, 0x5172, 0x4911, 0x48f2, 0x4952,
0x49b2, 0x49d2, 0x4191, 0x4a11, 0x4a11, 0x4a11, 0x41b1, 0x41d1, 0x4a52,
0x4211, 0x41f1, 0xc00f, 0xc010, 0xc010, 0xc810, 0xc811, 0xd011, 0xd012,
0xd012, 0xd012, 0xd012, 0xd812, 0xe012, 0xe013, 0xe013, 0xe013, 0xe013,
0xe813, 0xe814, 0xe834, 0xf074, 0xf0b3, 0xf114, 0xf154, 0xf995, 0xf9d5,
0xf9f5, 0xfa55, 0xfa55, 0xfa95, 0xfab5, 0xfad5, 0xfb15, 0xfb15, 0xfb55,
0xfb95, 0xfb94, 0xfbd4, 0xfbf4, 0xfc14, 0xfc13, 0xfc32, 0xfc31, 0xfc30,
0xfc4f, 0xfc6f, 0xfc6e, 0xfc6d, 0xfc2d, 0xfc0c, 0xfcef, 0xfa6c, 0xf96c,
0xf029, 0xfccd, 0xc000, 0xe1e9, 0xf9ab, 0xf9ac, 0xf9cc, 0xf9ec, 0xf9ac,
0xf9ac, 0xf96b, 0xf92b, 0xf8ea, 0xf82a, 0xf80a, 0xf80a, 0xf809, 0xf809,
0xf809, 0xf808, 0xf80a, 0xf80a, 0xf88a, 0xf92a, 0xf9cb, 0xf9cb, 0xfa2b,
0xfa8b, 0xfacb, 0xfacb, 0xfacb, 0xfaeb, 0xfaeb, 0xfb4b, 0xfbeb, 0xfc2b,
0xfc2b, 0xfc4a, 0xfc8a, 0xfc8a, 0xfc89, 0xfc6a, 0xfc8a, 0xfc89, 0xfc89,
0xfca9, 0xfca9, 0xfc89, 0xfc48, 0xfc49, 0xfc09, 0xfc29, 0xfc09, 0xfc09,
0xfc29, 0xe0a0, 0xfa0d, 0xf08b, 0xf90c, 0xfd65, 0xe243, 0xe841, 0x7800,
0x4000, 0xf024, 0xf801, 0xf808, 0xf8f0, 0xf930, 0xf911, 0xf8b2, 0xf852,
0xf812, 0xf813, 0xf813, 0xe813, 0xe013, 0xe014, 0xd874, 0xc8b3, 0xc0f3,
0xb913, 0xb113, 0xa0f2, 0x8972, 0x8193, 0x7993, 0x7193, 0x6173, 0x6153,
0x6173, 0x5973, 0x5993, 0x5192, 0x4952, 0x4932, 0x5192, 0x49d2, 0x5212,
0x49f2, 0x4a32, 0x4211, 0x4211, 0x41d1, 0x41f1, 0x4a52, 0x4211, 0x4211,
0xc011, 0xc011, 0xc812, 0xc812, 0xc812, 0xd012, 0xd013, 0xd013, 0xd013,
0xd013, 0xd813, 0xd813, 0xd813, 0xe014, 0xe013, 0xe014, 0xe874, 0xe8b4,
0xe934, 0xe934, 0xf194, 0xf1d5, 0xf1f5, 0xfa15, 0xfa35, 0xfa75, 0xfa95,
0xfab5, 0xfad5, 0xfb15, 0xfb35, 0xfb75, 0xfb75, 0xfb95, 0xfbd5, 0xfbf5,
0xfc15, 0xfc34, 0xfc54, 0xfc53, 0xfc52, 0xfc71, 0xfc70, 0xfc6f, 0xfc8f,
0xfc6e, 0xfc8e, 0xfc0e, 0xfa8b, 0xf2ac, 0xfa8e, 0xf8ac, 0xf82b, 0xf10c,
0xf809, 0xf00a, 0xf80b, 0xf80b, 0xf80a, 0xf80a, 0xf80a, 0xf80a, 0xf809,
0xf808, 0xf807, 0xf805, 0xf805, 0xf805, 0xf805, 0xf805, 0xf805, 0xf805,
0xf805, 0xf805, 0xf806, 0xf808, 0xf808, 0xf80a, 0xf8ca, 0xf1cb, 0xfa8c,
0xfacb, 0xfb2b, 0xfb6b, 0xfb8b, 0xfbab, 0xfbeb, 0xfc4b, 0xfc8a, 0xfca9,
0xfca8, 0xfca8, 0xfcc7, 0xfd07, 0xfd07, 0xfd26, 0xfdc6, 0xfde4, 0xfdc3,
0xfdc2, 0xfdc4, 0xfdc3, 0xfde2, 0xfde2, 0xfde2, 0xfda3, 0xfd84, 0xfd45,
0xfce6, 0xfca6, 0xfca6, 0xfd63, 0xa283, 0x9000, 0x8800, 0x5000, 0xf042,
0xf800, 0xf800, 0xf800, 0xf000, 0xf029, 0xf890, 0xf892, 0xf812, 0xf813,
0xf013, 0xe834, 0xe834, 0xd853, 0xd0f3, 0xc913, 0xb933, 0xb0f2, 0xa0d2,
0x9912, 0x8172, 0x7972, 0x7993, 0x71b3, 0x6193, 0x61b3, 0x61b3, 0x5992,
0x59d3, 0x51b2, 0x5192, 0x4952, 0x49d2, 0x4a12, 0x4a32, 0x4a32, 0x4a72,
0x4a31, 0x4a52, 0x4a31, 0x4231, 0x4272, 0x3a31, 0x4252, 0xc012, 0xc012,
0xc012, 0xc012, 0xc813, 0xc812, 0xc813, 0xc813, 0xc813, 0xd013, 0xd013,
0xd014, 0xd813, 0xd854, 0xe0b4, 0xe0f4, 0xe934, 0xe954, 0xe974, 0xf1b5,
0xf1d5, 0xf215, 0xf235, 0xfa55, 0xfa95, 0xfab5, 0xfad5, 0xfaf5, 0xfb15,
0xfb55, 0xfb55, 0xfb95, 0xfbb5, 0xfbd5, 0xfbf5, 0xfc15, 0xfc35, 0xfc54,
0xfc74, 0xfc93, 0xfc92, 0xfc71, 0xfc91, 0xfc8f, 0xfcaf, 0xfacc, 0xfa4c,
0xfb6f, 0xf22d, 0xfa2e, 0xf92e, 0xf8ed, 0xf84b, 0xf8ad, 0xf80b, 0xf80b,
0xf80c, 0xf80c, 0xf80c, 0xf80c, 0xf80b, 0xf80b, 0xf80a, 0xf80a, 0xf809,
0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf808, 0xf809, 0xf809, 0xf809,
0xf80a, 0xf80b, 0xf88b, 0xf94c, 0xf9ec, 0xfa6d, 0xfacd, 0xfb2d, 0xfb4c,
0xfbac, 0xfbec, 0xfc0d, 0xfc4c, 0xfcab, 0xfccb, 0xfcaa, 0xfcea, 0xfce9,
0xfce9, 0xfce8, 0xfd08, 0xfd28, 0xfd67, 0xfd87, 0xfd87, 0xfdc7, 0xfda6,
0xfda6, 0xfd85, 0xfd85, 0xfd86, 0xfd46, 0xfd07, 0xfcc7, 0xfca8, 0xfc88,
0xfc88, 0xfd47, 0xfc86, 0xfca7, 0xfb47, 0xf0c4, 0xf001, 0xe000, 0xe000,
0xf800, 0xf800, 0xf800, 0xf800, 0xf804, 0xf80a, 0xf812, 0xf014, 0xe854,
0xe915, 0xe0d4, 0xd134, 0xb973, 0xb173, 0xa973, 0xa153, 0x9152, 0x8193,
0x7972, 0x7193, 0x6172, 0x61d3, 0x61f3, 0x5a13, 0x59f3, 0x59f3, 0x59f2,
0x51d2, 0x4992, 0x49f2, 0x5272, 0x5272, 0x4a32, 0x4a52, 0x4a72, 0x4a51,
0x4a51, 0x4231, 0x4272, 0x3a51, 0x3a71, 0xb812, 0xb012, 0xb012, 0xb812,
0xb812, 0xc012, 0xb812, 0xb812, 0xc853, 0xc053, 0xc8d3, 0xc8f3, 0xd113,
0xd113, 0xd954, 0xe195, 0xe995, 0xf1d5, 0xe9d5, 0xf215, 0xf235, 0xf255,
0xf295, 0xfa95, 0xfad5, 0xfaf6, 0xfaf5, 0xfb15, 0xfb55, 0xfb76, 0xfb76,
0xfbb6, 0xfbd6, 0xfbf6, 0xfc15, 0xfc35, 0xfc55, 0xfc74, 0xfc94, 0xfc93,
0xfcb3, 0xfc92, 0xfbf0, 0xfa6d, 0xf24d, 0xfb30, 0xfa2f, 0xfa10, 0xf9af,
0xf98f, 0xf86e, 0xf82d, 0xf88d, 0xf8ce, 0xf80c, 0xf82c, 0xf80d, 0xf80c,
0xf80c, 0xf80c, 0xf80c, 0xf80b, 0xf80a, 0xf80a, 0xf809, 0xf809, 0xf809,
0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf80a, 0xf80b, 0xf80b,
0xf8eb, 0xf98c, 0xfa0c, 0xfa8d, 0xfacd, 0xfb0d, 0xfb4e, 0xfb6d, 0xf32d,
0xfb2d, 0xfb6d, 0xfbcd, 0xfc2c, 0xfc8c, 0xfced, 0xfd0d, 0xfd0d, 0xfd0c,
0xfd2c, 0xf4ab, 0xfccb, 0xfcca, 0xfcca, 0xfd4b, 0xfd4b, 0xfd6b, 0xfd6b,
0xfd6b, 0xfd0a, 0xfcaa, 0xfcaa, 0xfc4a, 0xfc0b, 0xfc0b, 0xfc0b, 0xfcca,
0xfc4a, 0xfc69, 0xfca8, 0xfd67, 0xfd67, 0xfa69, 0xf824, 0xf000, 0xe000,
0xf000, 0xf800, 0xf800, 0xf800, 0xf803, 0xf806, 0xf00d, 0xe8b4, 0xd8f3,
0xd173, 0xb1d3, 0xb1b3, 0xa193, 0x9993, 0x8972, 0x7993, 0x71b3, 0x71b3,
0x69d3, 0x6213, 0x5a33, 0x6233, 0x5212, 0x5a33, 0x5212, 0x5232, 0x5232,
0x5252, 0x5272, 0x5292, 0x4a52, 0x4a72, 0x4a72, 0x4a71, 0x4a72, 0x3a11,
0x4292, 0x3a51, 0x3ab1, 0xa011, 0xa011, 0xa832, 0xa852, 0xa872, 0xa8b2,
0xb0d3, 0xb0f2, 0xb0f2, 0xb933, 0xc153, 0xc974, 0xd174, 0xd194, 0xd9b4,
0xe1d4, 0xe215, 0xea15, 0xf235, 0xf255, 0xf276, 0xf296, 0xfad6, 0xfad6,
0xfaf5, 0xfb16, 0xfb36, 0xfb35, 0xfb76, 0xfb96, 0xfbb6, 0xfbd6, 0xfbd6,
0xfc16, 0xfc35, 0xfc55, 0xfc55, 0xfc74, 0xfc94, 0xfcb4, 0xf2f0, 0xfa50,
0xfad0, 0xfa4f, 0xf9d1, 0xf9d0, 0xf970, 0xf930, 0xf8ef, 0xf8cf, 0xf80e,
0xf80e, 0xf80e, 0xf80d, 0xf80d, 0xf80c, 0xf80d, 0xf80c, 0xf80c, 0xf80b,
0xf80b, 0xf80a, 0xf80a, 0xf809, 0xf809, 0xf809, 0xf808, 0xf808, 0xf808,
0xf808, 0xf808, 0xf809, 0xf80b, 0xf80b, 0xf80c, 0xf80d, 0xf8ad, 0xf92d,
0xfa0e, 0xfa90, 0xfaf0, 0xfb10, 0xfb50, 0xfb50, 0xfb90, 0xfb90, 0xfbb0,
0xfbf0, 0xfc2f, 0xfc4f, 0xfc4f, 0xfc6f, 0xfc6f, 0xfc8f, 0xfcaf, 0xfccf,
0xfccf, 0xfccf, 0xfcef, 0xfcef, 0xfcef, 0xfcef, 0xfcef, 0xfcef, 0xfcef,
0xfc4e, 0xfc4e, 0xfc0e, 0xfbee, 0xfbce, 0xfbee, 0xfc4e, 0xfc4e, 0xfc6e,
0xfc8c, 0xfd4d, 0xfdc9, 0xfdaa, 0xfdeb, 0xfb88, 0xfa08, 0xf805, 0xf000,
0xf000, 0xf800, 0xf800, 0xf801, 0xf804, 0xf806, 0xf80a, 0xf02f, 0xc973,
0xa192, 0x99b3, 0x8992, 0x8993, 0x79f3, 0x71f4, 0x69f3, 0x6a34, 0x6273,
0x6293, 0x62b3, 0x62b3, 0x5a93, 0x5a93, 0x52b2, 0x4a72, 0x5272, 0x52b2,
0x4ab2, 0x4ab2, 0x4a92, 0x4a92, 0x4271, 0x4292, 0x3a51, 0x3a92, 0x3a91,
0x3a91, 0x8871, 0x88d2, 0x88d2, 0x88f2, 0x9932, 0x9112, 0x9932, 0xa172,
0xa993, 0xa992, 0xb9b3, 0xc1b3, 0xc9d4, 0xd1d4, 0xd1f4, 0xda34, 0xe235,
0xea55, 0xea75, 0xea75, 0xf2b6, 0xf2d6, 0xfaf6, 0xfaf6, 0xfb16, 0xfb36,
0xfb56, 0xfb76, 0xfb96, 0xfbb6, 0xfbd6, 0xfbf6, 0xfbd6, 0xfc16, 0xfc35,
0xfc55, 0xfc75, 0xeb12, 0xfa92, 0xf271, 0xfbb4, 0xf251, 0xfa32, 0xf9d1,
0xf992, 0xf951, 0xf8d1, 0xf80f, 0xf810, 0xf830, 0xf80f, 0xf80e, 0xf80e,
0xf80e, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80c, 0xf80c, 0xf80b, 0xf80b,
0xf80b, 0xf80a, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf809, 0xf80a,
0xf80b, 0xf80c, 0xf80d, 0xf80e, 0xf80f, 0xf8af, 0xf970, 0xf9f1, 0xfa72,
0xfab2, 0xfaf2, 0xfaf2, 0xfb32, 0xfb52, 0xfb73, 0xfb93, 0xfbb3, 0xfbf3,
0xfc12, 0xfbf2, 0xfbf2, 0xfbf2, 0xfbf2, 0xfc12, 0xfc32, 0xfc32, 0xfc32,
0xfc32, 0xfc32, 0xfc92, 0xfc92, 0xfcb3, 0xfcb3, 0xfcd3, 0xfcd3, 0xfcd3,
0xfc72, 0xfc32, 0xfc12, 0xfc12, 0xf412, 0xfc12, 0xfbd2, 0xfbd1, 0xfc90,
0xfd50, 0xfdef, 0xfe2e, 0xfe4e, 0xfe0f, 0xfcee, 0xf9ca, 0xf807, 0xf802,
0xf000, 0xf000, 0xf800, 0xf802, 0xf805, 0xf808, 0xf80b, 0xf80f, 0xe852,
0x9953, 0x8193, 0x7214, 0x6a34, 0x6a13, 0x6a94, 0x6af4, 0x6313, 0x6313,
0x6313, 0x62f3, 0x5ab3, 0x52d3, 0x4a92, 0x4a72, 0x4ad2, 0x4af2, 0x4ad2,
0x42d2, 0x4af2, 0x42b2, 0x4292, 0x3a51, 0x3a92, 0x3291, 0x32b1, 0x78f2,
0x7912, 0x8132, 0x7952, 0x8193, 0x8972, 0x9193, 0x9193, 0x99b3, 0xa1d3,
0xa9d3, 0xb9f3, 0xc1f3, 0xca34, 0xca54, 0xd254, 0xe275, 0xea95, 0xeab5,
0xeab6, 0xf2f6, 0xf2f6, 0xfaf6, 0xfb16, 0xfb36, 0xfb56, 0xfb76, 0xfb96,
0xfb96, 0xfbb6, 0xfbd6, 0xfbd6, 0xfbd6, 0xfbf5, 0xfbd6, 0xfa53, 0xfa13,
0xea11, 0xf1d2, 0xf992, 0xf8f1, 0xf0d1, 0xf870, 0xf850, 0xf80f, 0xf810,
0xf811, 0xf810, 0xf810, 0xf810, 0xf810, 0xf80f, 0xf80e, 0xf80e, 0xf80d,
0xf80d, 0xf80c, 0xf80c, 0xf80c, 0xf80b, 0xf80a, 0xf80b, 0xf80b, 0xf80a,
0xf809, 0xf809, 0xf809, 0xf808, 0xf809, 0xf80a, 0xf80b, 0xf80c, 0xf80d,
0xf80e, 0xf80f, 0xf810, 0xf810, 0xf8b1, 0xf952, 0xf9d3, 0xf9f3, 0xfa73,
0xfab3, 0xfaf4, 0xfb14, 0xfb34, 0xfb54, 0xfb74, 0xfb94, 0xfbb4, 0xfbb4,
0xfb93, 0xfb93, 0xfb94, 0xfbb3, 0xfbd4, 0xfbd4, 0xfbd4, 0xfc75, 0xfc76,
0xfc95, 0xfc96, 0xfcf7, 0xfcf6, 0xfcf7, 0xfcf6, 0xfcd6, 0xfcd6, 0xfc55,
0xfc15, 0xfc15, 0xfc35, 0xfc15, 0xfc14, 0xfc14, 0xfc96, 0xfcf7, 0xfd16,
0xfd16, 0xfd76, 0xfdb6, 0xfe57, 0xfe16, 0xfdf7, 0xf9ee, 0xf809, 0xf804,
0xe800, 0xe800, 0xf000, 0xf804, 0xf808, 0xf80c, 0xf810, 0xe812, 0xd012,
0x90d2, 0x6a14, 0x6a73, 0x6b14, 0x6333, 0x6353, 0x6333, 0x5b53, 0x5b33,
0x5af3, 0x52f3, 0x52d3, 0x4ab2, 0x4af2, 0x4b12, 0x4312, 0x3af2, 0x4312,
0x3ad2, 0x3ab2, 0x3251, 0x32b2, 0x32b1, 0x32b1, 0x6932, 0x6952, 0x6972,
0x7193, 0x79d3, 0x79b3, 0x89d3, 0x89d3, 0x91f3, 0x99f3, 0xa213, 0xb253,
0xba54, 0xc254, 0xca74, 0xda95, 0xe295, 0xe2b5, 0xead6, 0xf2d6, 0xf2f6,
0xf316, 0xfb16, 0xfb56, 0xfb56, 0xfb56, 0xfb56, 0xfb96, 0xfbb6, 0xfbb7,
0xfbb6, 0xfbf6, 0xf294, 0xf9d3, 0xf1b3, 0xfab6, 0xf132, 0xf113, 0xf8f3,
0xf8b2, 0xf812, 0xf813, 0xf812, 0xf812, 0xf812, 0xf812, 0xf811, 0xf811,
0xf811, 0xf811, 0xf811, 0xf810, 0xf80f, 0xf810, 0xf80f, 0xf80e, 0xf80e,
0xf80e, 0xf80e, 0xf80d, 0xf80d, 0xf80d, 0xf80d, 0xf80c, 0xf80b, 0xf80b,
0xf80c, 0xf80c, 0xf80c, 0xf80d, 0xf80e, 0xf80e, 0xf80f, 0xf810, 0xf811,
0xf812, 0xf812, 0xf8d3, 0xf953, 0xf9f4, 0xfa34, 0xfa74, 0xfa95, 0xfab5,
0xfaf5, 0xfb15, 0xfb15, 0xfb55, 0xfb95, 0xfbd6, 0xfbd6, 0xfbd6, 0xfbd6,
0xfc16, 0xfc37, 0xfc56, 0xfc56, 0xfcb7, 0xfc77, 0xfb54, 0xf334, 0xf354,
0xf395, 0xfc37, 0xfbd6, 0xfbf6, 0xfbf6, 0xfc17, 0xfc16, 0xfc17, 0xfc17,
0xfbd5, 0xfc16, 0xfcd7, 0xfd37, 0xfd58, 0xfd78, 0xfd78, 0xfd98, 0xfdb8,
0xfdf8, 0xfe58, 0xfe38, 0xfe38, 0xf639, 0xfe5a, 0xfb33, 0xf8f0, 0xf82c,
0xf007, 0xe005, 0xe806, 0xf009, 0xf00e, 0xe010, 0xc011, 0x9811, 0x7010,
0x5030, 0x51b2, 0x5b33, 0x5b93, 0x5b53, 0x5373, 0x5333, 0x5333, 0x4b13,
0x4b12, 0x42f2, 0x42f2, 0x42f2, 0x4312, 0x3af2, 0x3af2, 0x32d1, 0x32d1,
0x2a50, 0x32b1, 0x2ab1, 0x32b1, 0x61b3, 0x61b3, 0x61d3, 0x61b3, 0x69f3,
0x7213, 0x7a13, 0x8214, 0x8213, 0x9233, 0xa254, 0xb274, 0xba74, 0xc294,
0xcab4, 0xd294, 0xe2b5, 0xe2d5, 0xead5, 0xf2f6, 0xf2f6, 0xf316, 0xfb36,
0xfb36, 0xfb56, 0xfb56, 0xfb76, 0xfb76, 0xfbb6, 0xfb36, 0xf973, 0xf934,
0xf0d3, 0xfa36, 0xf873, 0xf8d4, 0xf832, 0xf833, 0xf833, 0xf812, 0xf812,
0xf812, 0xf812, 0xf812, 0xf812, 0xf811, 0xf811, 0xf811, 0xf811, 0xf811,
0xf810, 0xf810, 0xf80f, 0xf810, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf80e,
0xf80e, 0xf80d, 0xf80c, 0xf80b, 0xf80b, 0xf80b, 0xf80b, 0xf80b, 0xf80c,
0xf80d, 0xf80e, 0xf80f, 0xf810, 0xf811, 0xf811, 0xf811, 0xf812, 0xf812,
0xf813, 0xf853, 0xf935, 0xf974, 0xf9b4, 0xf9f4, 0xfa35, 0xfa55, 0xf254,
0xf255, 0xfab5, 0xfaf5, 0xfb36, 0xfb56, 0xfb56, 0xfb76, 0xfb96, 0xfb96,
0xfbb6, 0xfbd7, 0xfbb6, 0xfb36, 0xfb36, 0xfb96, 0xfbb7, 0xfbb6, 0xfbb7,
0xfbf7, 0xfc17, 0xfbf7, 0xfc17, 0xfc37, 0xfc98, 0xfcb8, 0xfcf8, 0xfd39,
0xfd58, 0xfd58, 0xfd79, 0xfd78, 0xfd78, 0xfd98, 0xfdd8, 0xfe18, 0xfe38,
0xfe39, 0xfe59, 0xfe59, 0xfeb9, 0xfeda, 0xfefb, 0xf4b7, 0xf9f5, 0xe832,
0xe00f, 0xc80c, 0xc00c, 0xb82e, 0xa00f, 0x800f, 0x600f, 0x4010, 0x3870,
0x3951, 0x31b0, 0x3270, 0x4b53, 0x4352, 0x4b33, 0x4b12, 0x4312, 0x42f2,
0x3b12, 0x3b32, 0x3312, 0x3312, 0x3312, 0x32f1, 0x32f1, 0x2a50, 0x2ab1,
0x2290, 0x2ad1, 0x6273, 0x6273, 0x6293, 0x6293, 0x6a54, 0x7254, 0x7253,
0x8254, 0x8a34, 0x9274, 0x9a74, 0xaa94, 0xb294, 0xba94, 0xcab4, 0xd2d5,
0xe2d5, 0xe2d5, 0xeaf5, 0xeb16, 0xf316, 0xf336, 0xfb36, 0xfb36, 0xfb56,
0xfb57, 0xfb97, 0xe914, 0xf894, 0xf874, 0xe154, 0xe853, 0xf013, 0xf854,
0xf813, 0xf813, 0xf813, 0xf813, 0xf812, 0xf812, 0xf812, 0xf812, 0xf812,
0xf811, 0xf811, 0xf811, 0xf811, 0xf811, 0xf811, 0xf811, 0xf810, 0xf80f,
0xf80f, 0xf810, 0xf00d, 0xf80d, 0xf80e, 0xf80e, 0xf80e, 0xf80e, 0xf00d,
0xf00e, 0xe80d, 0xe80d, 0xe80d, 0xe80d, 0xf00e, 0xf00f, 0xf00f, 0xf010,
0xf010, 0xf010, 0xe811, 0xf012, 0xe812, 0xe812, 0xe813, 0xe813, 0xf074,
0xf115, 0xe934, 0xf194, 0xe9b4, 0xf1d5, 0xf1f5, 0xf215, 0xfa56, 0xf275,
0xf2b5, 0xfad5, 0xfaf6, 0xf2f6, 0xf315, 0xfb16, 0xfb56, 0xfb76, 0xfb97,
0xf396, 0xf396, 0xf3d6, 0xfb96, 0xf356, 0xf376, 0xf396, 0xf3f6, 0xfc97,
0xf497, 0xec97, 0xe4b6, 0xe4d6, 0xe4f6, 0xed37, 0xe557, 0xe577, 0xed77,
0xf597, 0xf5b7, 0xf5d7, 0xf5f8, 0xf5f8, 0xfe18, 0xfe18, 0xfe59, 0xfe78,
0xfe99, 0xfed9, 0xfed9, 0xfefa, 0xff3a, 0xff3a, 0xee98, 0xe517, 0xbab4,
0x8030, 0x500e, 0x400c, 0x500e, 0x400e, 0x300f, 0x302f, 0x3110, 0x3170,
0x2190, 0x218f, 0x19af, 0x2250, 0x32f2, 0x3b12, 0x3312, 0x2b11, 0x3332,
0x2af1, 0x2af1, 0x2b11, 0x32d1, 0x2ab1, 0x2250, 0x22b0, 0x22b0, 0x22b0,
0x6313, 0x6333, 0x62f3, 0x62f3, 0x6ab4, 0x6a94, 0x7274, 0x7a74, 0x8254,
0x9274, 0x9a94, 0xa294, 0xb2b4, 0xbab4, 0xcab4, 0xd2d4, 0xdaf5, 0xe2f5,
0xeb16, 0xf316, 0xf316, 0xf316, 0xfb56, 0xfb57, 0xe974, 0xe834, 0xe813,
0xe813, 0xf9f7, 0xe813, 0xe813, 0xf013, 0xf013, 0xf013, 0xf013, 0xf013,
0xf013, 0xf013, 0xf012, 0xf012, 0xf812, 0xf812, 0xf811, 0xf012, 0xf011,
0xf011, 0xf011, 0xf010, 0xf810, 0xf810, 0xf00f, 0xe00d, 0xf00e, 0xf80f,
0xe80d, 0xe80e, 0xe80e, 0xe80e, 0xe80e, 0xe00e, 0xe00d, 0xe00d, 0xd80d,
0xd00c, 0xd00c, 0xd00c, 0xd00d, 0xd00e, 0xd00e, 0xd00f, 0xd810, 0xd810,
0xd811, 0xd812, 0xd812, 0xd812, 0xd813, 0xd814, 0xd834, 0xe0b4, 0xe114,
0xd934, 0xe174, 0xe1b4, 0xe1f5, 0xe1f5, 0xda15, 0xe235, 0xea55, 0xf275,
0xf295, 0xea95, 0xead6, 0xf2b6, 0xf2d6, 0xf2f6, 0xeb16, 0xeb16, 0xeaf5,
0xeb16, 0xeb15, 0xeb35, 0xe396, 0xe3b5, 0xe3d6, 0xe3d5, 0xdbf6, 0xd3f5,
0xd436, 0xcc56, 0xcc96, 0xd4b6, 0xd4f7, 0xd4f7, 0xd516, 0xe536, 0xed77,
0xf597, 0xf5b8, 0xfdd8, 0xfdf8, 0xfe19, 0xfe18, 0xfe38, 0xfe58, 0xfe78,
0xfe99, 0xfed9, 0xfefa, 0xff1a, 0xff3a, 0xff3a, 0xef59, 0x5552, 0x1c11,
0x32d3, 0x290f, 0x288e, 0x204e, 0x202e, 0x28af, 0x28ef, 0x214f, 0x214f,
0x196f, 0x196f, 0x19af, 0x11af, 0x1a2f, 0x2af1, 0x2311, 0x22f1, 0x2311,
0x2af1, 0x2290, 0x2270, 0x2270, 0x1ab0, 0x1ab0, 0x1ad0, 0x6354, 0x6353,
0x6354, 0x6b54, 0x6b14, 0x72f4, 0x72b4, 0x7a94, 0x8294, 0x8a94, 0x9a94,
0xa294, 0xb2d4, 0xc2d4, 0xcad4, 0xd2f4, 0xdaf5, 0xe2f5, 0xeb15, 0xeb16,
0xf316, 0xe9f5, 0xe014, 0xe013, 0xe013, 0xe956, 0xd032, 0xe014, 0xd813,
0xe013, 0xe013, 0xe013, 0xe013, 0xe012, 0xe013, 0xe012, 0xe012, 0xe012,
0xe012, 0xe012, 0xe011, 0xd811, 0xd811, 0xd010, 0xc810, 0xc00f, 0xc00f,
0xc00f, 0xd00f, 0xd80f, 0xc00e, 0xb80d, 0xc80e, 0xe80f, 0xc00e, 0xc80e,
0xc80e, 0xc80e, 0xc80e, 0xc00e, 0xc00d, 0xb80c, 0xb00c, 0xa80b, 0xb00c,
0xb00c, 0xb00d, 0xb00d, 0xb00e, 0xb00e, 0xb00f, 0xb810, 0xc011, 0xc011,
0xb811, 0xc012, 0xc012, 0xc012, 0xc093, 0xc913, 0xc153, 0xc193, 0xc1b3,
0xc1f3, 0xc213, 0xc214, 0xc254, 0xca34, 0xd254, 0xda95, 0xdab5, 0xd2b5,
0xd2d5, 0xdab5, 0xf235, 0xea76, 0xf275, 0xf295, 0xeab6, 0xeab5, 0xe2b6,
0xe2b5, 0xc355, 0xa395, 0x9bf5, 0x9bf5, 0xa435, 0xa4d6, 0x9cf6, 0x9d16,
0xa557, 0xa435, 0xb435, 0xb496, 0xc4d6, 0xc516, 0xd556, 0xdd37, 0xed77,
0xed77, 0xedb7, 0xfdd8, 0xf5d8, 0xf5d8, 0xf5f8, 0xf618, 0xf618, 0xf658,
0xf678, 0xfe99, 0xfeb9, 0xfed9, 0xfef9, 0xd738, 0x4f57, 0x5f4, 0x3f0,
0x28e, 0x11af, 0x18ee, 0x18ad, 0x18ce, 0x18ce, 0x20ee, 0x190e, 0x192f,
0x194f, 0x194f, 0x196e, 0x196e, 0x118e, 0x1a0f, 0x1ad1, 0x1ad0, 0x1ab0,
0x2290, 0x1a70, 0x1ad0, 0x1ab0, 0x1ab0, 0x5b94, 0x6394, 0x6394, 0x6374,
0x6b54, 0x6b14, 0x72f4, 0x72b4, 0x7ab4, 0x92d5, 0x92b4, 0xa2d4, 0xb2d4,
0xc2d4, 0xcad4, 0xd2f5, 0xe316, 0xe2d5, 0xfb18, 0xc032, 0xd013, 0xd013,
0xd013, 0xf238, 0xc832, 0xd013, 0xd013, 0xd013, 0xd013, 0xd013, 0xd813,
0xd813, 0xd013, 0xd012, 0xd013, 0xd812, 0xd812, 0xd812, 0xd812, 0xd012,
0xc811, 0xc811, 0xc010, 0xb810, 0xb810, 0xb00f, 0xa80e, 0xb00d, 0xc00e,
0xd00f, 0xb00d, 0xa00c, 0xb80d, 0xe00f, 0xb00d, 0xb00e, 0xb00e, 0xb00d,
0xb00d, 0xa80c, 0xa00c, 0x980b, 0x900b, 0x880a, 0x880b, 0x880c, 0x880c,
0x880d, 0x880e, 0x880e, 0x900f, 0x9810, 0xa010, 0xa011, 0x9811, 0xa011,
0x9831, 0xa0b2, 0x98b1, 0xa0f2, 0xa132, 0xa1b3, 0x99d3, 0x99f3, 0xa213,
0x9a33, 0xa274, 0xaa74, 0xc294, 0xcab4, 0xcaf5, 0xc2d4, 0xbaf4, 0xc335,
0xd2f5, 0xdaf5, 0xd315, 0xd315, 0xd335, 0xcb35, 0xcb35, 0xcb55, 0xc375,
0xb395, 0xa415, 0xa476, 0xacb7, 0xacf6, 0x9515, 0x8d75, 0x8575, 0x9575,
0x8d95, 0x9595, 0xa5b6, 0xbdd6, 0xcdb7, 0xe496, 0xecb6, 0xf517, 0xfd78,
0xfdd8, 0xe5d7, 0xe618, 0xedf8, 0xee38, 0xee58, 0xee78, 0xee98, 0xf698,
0xfed9, 0xfed9, 0xfef9, 0xdf18, 0x5f37, 0xf16, 0x6f5, 0x654, 0x4f1,
0x36f, 0xa0e, 0x194e, 0x18cd, 0x18ac, 0x18cd, 0x18cd, 0x18ee, 0x190e,
0x190e, 0x194e, 0x112e, 0x194e, 0x194e, 0x118e, 0x120f, 0x1a70, 0x1270,
0x1ab0, 0x12b0, 0x12b0, 0x5b93, 0x5bb3, 0x63b3, 0x6b94, 0x7374, 0x7334,
0x7314, 0x72d4, 0x7ab4, 0x92b4, 0x9ab4, 0xa2d4, 0xb2d4, 0xc2d4, 0xcad4,
0xdaf6, 0xb931, 0xb012, 0xb812, 0xc013, 0xc052, 0xa810, 0xb812, 0xb812,
0xb832, 0xc012, 0xc012, 0xc012, 0xc012, 0xc012, 0xc812, 0xc812, 0xc812,
0xd012, 0xd012, 0xd012, 0xd012, 0xc812, 0xc811, 0xc811, 0xc811, 0xc010,
0xb810, 0xb010, 0xb00f, 0xa80f, 0xa00e, 0xa80e, 0xb80e, 0xc80f, 0xb00d,
0xa00d, 0xb00e, 0xd810, 0xb00d, 0xa00d, 0xa80e, 0xa80d, 0xa80d, 0xa00d,
0x900c, 0x880c, 0x800b, 0x800a, 0x780b, 0x780c, 0x800c, 0x800d, 0x800e,
0x800e, 0x800f, 0x800f, 0x8810, 0x8810, 0x8831, 0x8010, 0x8891, 0x88f2,
0x9132, 0x9173, 0x9193, 0x89b3, 0x89d3, 0x89d3, 0x89d3, 0x8a13, 0x9233,
0x9a73, 0xb2d4, 0xb2d3, 0xbaf4, 0xbaf4, 0xbb14, 0xbb14, 0xb334, 0xb355,
0xb355, 0xa354, 0xa395, 0x9bf5, 0x9c95, 0x9cf6, 0x9d16, 0x9d15, 0xa4d6,
0xa536, 0xa536, 0x9d56, 0x8d55, 0x8554, 0x8575, 0x8575, 0x8575, 0x8d95,
0x9db6, 0xb5d6, 0xc5d7, 0xcdb7, 0xdd76, 0xe597, 0xedb7, 0xedd7, 0xedd8,
0xde18, 0xde38, 0xe638, 0xe678, 0xe698, 0xee99, 0xee99, 0xf6b9, 0xf6d9,
0xf6f9, 0xcef8, 0x56d7, 0x6d6, 0x6d5, 0x6f5, 0x6d5, 0x694, 0x531,
0x3d0, 0x24e, 0x116d, 0x18ed, 0x10ac, 0x18ac, 0x18ac, 0x18cd, 0x18cd,
0x18ed, 0x190d, 0x192d, 0x192d, 0x194e, 0x194d, 0x116d, 0x11ef, 0x1290,
0xab0, 0x53b3, 0x53b3, 0x5bd4, 0x63b4, 0x6bb4, 0x7374, 0x7354, 0x7314,
0x7ab4, 0x92d4, 0xa2b4, 0xb2f4, 0xc2f5, 0xcad6, 0x8850, 0x9832, 0x9812,
0x9831, 0xc9d6, 0x8830, 0x8811, 0x9811, 0xa011, 0xa812, 0xb012, 0xb012,
0xa811, 0xa811, 0xb011, 0xb012, 0xb811, 0xb011, 0xb011, 0xb811, 0xb811,
0xb811, 0xb011, 0xb011, 0xb010, 0xa810, 0xa810, 0xa80f, 0xa00f, 0x900d,
0x900d, 0x880c, 0x880b, 0x900b, 0xa80c, 0xc00d, 0x980c, 0x880b, 0x980c,
0xc80e, 0x980b, 0x880b, 0x980c, 0x980c, 0x980c, 0x880b, 0x800b, 0x800b,
0x700b, 0x700a, 0x700b, 0x700b, 0x700b, 0x700c, 0x700d, 0x680d, 0x700e,
0x700e, 0x7810, 0x7810, 0x7811, 0x7872, 0x78b2, 0x78d1, 0x7932, 0x8152,
0x8193, 0x79b3, 0x7993, 0x79d3, 0x79d3, 0x81f3, 0x89f3, 0x9233, 0xaa74,
0xca74, 0xba73, 0xb2b4, 0xaaf4, 0xa314, 0xa314, 0xa314, 0xa334, 0x9b55,
0x9b95, 0x93b5, 0x9456, 0x8cd5, 0x8cd5, 0x8cf5, 0x7cd4, 0xa394, 0xab94,
0x9bb4, 0x9434, 0x9cd5, 0x6cf4, 0x6514, 0x6d34, 0x6d54, 0x7554, 0x8595,
0x8db5, 0xadd6, 0xbe17, 0xd5f7, 0xf537, 0xfd37, 0xfd57, 0xfd58, 0xf598,
0xde18, 0xde38, 0xe658, 0xe658, 0xee58, 0xee99, 0xf6b9, 0xf6d9, 0xc6d7,
0x2eb6, 0x6b5, 0x6d5, 0x6d5, 0x6b4, 0x6d4, 0x6f5, 0x6d5, 0x571,
0x450, 0x2ce, 0x11ee, 0x190d, 0x18cc, 0x18ac, 0x18ac, 0x18ac, 0x18cd,
0x18ed, 0x190d, 0x190d, 0x192d, 0x190d, 0x192d, 0x194d, 0x116d, 0x53b3,
0x53b3, 0x5bd3, 0x63b4, 0x6bb4, 0x7394, 0x7314, 0x7ad4, 0x8ab4, 0x9ab4,
0xbb35, 0x78f1, 0x7011, 0x7031, 0x7810, 0x700f, 0x9174, 0x6030, 0x7010,
0x7811, 0x8010, 0x8011, 0x8811, 0x9011, 0x8010, 0x9010, 0x9810, 0x9811,
0xa811, 0xb011, 0xb011, 0xb011, 0xb011, 0xb811, 0xb811, 0xb011, 0xa810,
0xa010, 0xa010, 0xa00f, 0x980e, 0x980e, 0x900e, 0x880d, 0x800b, 0x800b,
0x800a, 0x880b, 0xa00d, 0xb00d, 0x900c, 0x800c, 0x900c, 0xb80e, 0x900c,
0x880b, 0x900b, 0x900b, 0x880a, 0x800a, 0x780a, 0x780b, 0x700b, 0x680a,
0x680a, 0x600a, 0x600b, 0x600c, 0x680c, 0x680d, 0x680e, 0x6810, 0x7010,
0x7010, 0x6831, 0x6891, 0x68d2, 0x6912, 0x6933, 0x7172, 0x7173, 0x7193,
0x71d3, 0x71d3, 0x71f3, 0x7a13, 0x7a34, 0x8a53, 0xaa73, 0xb2b4, 0xbab4,
0xb2d4, 0xa2d4, 0xa2f4, 0xa314, 0xa2f4, 0xbad5, 0xbad4, 0xb2d5, 0xb315,
0xab15, 0xab75, 0xa3b5, 0xa3d5, 0xa3f5, 0xa415, 0x7cd4, 0x6cb4, 0x64b4,
0x64d3, 0x5cd3, 0x5cd3, 0x5cf3, 0x6d34, 0x7554, 0x8d75, 0xa5d6, 0xb5d6,
0xbdd6, 0xbdf6, 0xd5b7, 0xddb7, 0xd5d7, 0xd5f7, 0xddf8, 0xd618, 0xd638,
0xd657, 0xde18, 0xe618, 0xe658, 0xee78, 0xeeb9, 0xb697, 0x1675, 0x695,
0x6b5, 0x6b4, 0x6b4, 0x6b4, 0x6d4, 0x6d5, 0x6d4, 0x6d4, 0x5f3,
0x4b1, 0x36f, 0x22e, 0x196d, 0x18cc, 0x18ac, 0x188c, 0x18ac, 0x18ac,
0x18cc, 0x18cd, 0x18ed, 0x18ed, 0x190d, 0x192d, 0x4bb3, 0x53b3, 0x5bd3,
0x6bd4, 0x7394, 0x7334, 0x7af4, 0x82b5, 0x6991, 0x5051, 0x5011, 0x5010,
0x5811, 0x7994, 0x5070, 0x5031, 0x6031, 0x6810, 0x6810, 0x6810, 0x7010,
0x7010, 0x7810, 0x8810, 0x8810, 0x9010, 0x9010, 0x9810, 0x9811, 0x9810,
0x9810, 0xa010, 0xa011, 0xa010, 0xa010, 0xa010, 0xa00f, 0x980f, 0x900f,
0x880e, 0x800d, 0x780b, 0x780b, 0x780b, 0x700a, 0x700a, 0x700a, 0x780b,
0x900c, 0x980c, 0x800b, 0x780b, 0x800b, 0xa80d, 0x880b, 0x800b, 0x880b,
0x800b, 0x800b, 0x800b, 0x700b, 0x700b, 0x680b, 0x600b, 0x600b, 0x600c,
0x600d, 0x600d, 0x600e, 0x600e, 0x600f, 0x6010, 0x6810, 0x6810, 0x6071,
0x6092, 0x60f2, 0x6112, 0x6932, 0x6952, 0x6993, 0x71b3, 0x69d3, 0x69f3,
0x7234, 0x7254, 0x7a53, 0x8254, 0x9a73, 0xaab4, 0xaad4, 0xaaf4, 0xa2d4,
0x9af4, 0x9315, 0x9335, 0xc294, 0xd275, 0xd295, 0xcab5, 0xcab5, 0xc2d4,
0xc2d4, 0xbaf4, 0xbb14, 0xb314, 0xa333, 0x6cd4, 0x5cb3, 0x5cb3, 0x5cb3,
0x54d3, 0x54b2, 0x5cd3, 0x6d13, 0x7555, 0x9596, 0x9dd6, 0xb5d6, 0xc5d7,
0xd597, 0xdd97, 0xd5b7, 0xdd97, 0xdd97, 0xe597, 0xe5b7, 0xe5d7, 0xddf8,
0xde18, 0xe618, 0xe618, 0xee58, 0xce97, 0x3676, 0x676, 0x695, 0x6b5,
0x694, 0x6b4, 0x6b4, 0x6b4, 0x6b4, 0x6b4, 0x6d4, 0x6d4, 0x653,
0x532, 0x3f0, 0x28e, 0x11cd, 0x190d, 0x18ac, 0x18ab, 0x188b, 0x10ab,
0x18ab, 0x18cc, 0x18cd, 0x18ed, 0x4392, 0x53b3, 0x63b3, 0x73b4, 0x7374,
0x7b16, 0x40f1, 0x3870, 0x3850, 0x3810, 0x300f, 0x7275, 0x40d2, 0x4091,
0x4871, 0x4851, 0x5030, 0x5010, 0x5810, 0x5810, 0x6810, 0x7810, 0x8010,
0x8810, 0x8810, 0x9010, 0x9010, 0x9810, 0xa010, 0xa010, 0xa010, 0x900f,
0x900f, 0x9810, 0x900f, 0x900e, 0x880e, 0x800d, 0x780d, 0x780c, 0x780c,
0x780b, 0x700a, 0x700a, 0x700a, 0x6809, 0x680a, 0x700b, 0x800b, 0x900c,
0x780b, 0x700a, 0x780a, 0x980c, 0x800b, 0x780a, 0x800b, 0x800b, 0x780b,
0x700b, 0x700b, 0x600b, 0x580b, 0x580c, 0x580c, 0x580d, 0x580d, 0x580e,
0x580f, 0x580f, 0x580f, 0x5810, 0x6011, 0x5831, 0x6051, 0x6072, 0x60d2,
0x6112, 0x6112, 0x6953, 0x6173, 0x6193, 0x61b3, 0x69f3, 0x61f3, 0x6a14,
0x7234, 0x7a33, 0x8a74, 0x92b4, 0x92b4, 0x9ab4, 0x92d4, 0x82f4, 0x8b15,
0x8b15, 0x9ad4, 0xca95, 0xd295, 0xca95, 0xcab5, 0xcad4, 0xc2f4, 0xb314,
0xb314, 0xab14, 0xa354, 0x9374, 0x8c15, 0x8bd4, 0x8c35, 0x8c34, 0x8cf5,
0x54d3, 0x54d3, 0x6d34, 0x8d95, 0x9d96, 0xadd6, 0xbdd6, 0xcdb7, 0xcd97,
0xcdd7, 0xcdf7, 0xdd77, 0xdd77, 0xdd97, 0xe5b7, 0xe5b7, 0xedd8, 0xedd8,
0xe618, 0xe617, 0xbe56, 0x3e76, 0x675, 0x634, 0x654, 0x674, 0x674,
0x673, 0x673, 0x693, 0x694, 0x6b4, 0x6b4, 0x6d5, 0x3797, 0x6b4,
0x592, 0x491, 0x30f, 0xa0e, 0x116d, 0x18ec, 0x18ac, 0x188b, 0x188b,
0x188b, 0x18ab, 0x53d3, 0x63d3, 0x73d5, 0x4211, 0x3950, 0x38f1, 0x38d0,
0x30b0, 0x4170, 0x41b0, 0x3931, 0x38d0, 0x38b0, 0x3890, 0x3850, 0x4051,
0x4010, 0x4010, 0x4010, 0x480f, 0x480f, 0x5010, 0x5010, 0x5810, 0x580f,
0x600f, 0x600f, 0x680f, 0x700e, 0x780e, 0x780e, 0x780e, 0x780e, 0x780d,
0x780d, 0x780d, 0x700c, 0x700c, 0x700b, 0x680a, 0x680a, 0x6009, 0x6008,
0x6009, 0x6009, 0x6009, 0x6009, 0x680a, 0x780b, 0x800b, 0x700a, 0x6809,
0x700a, 0x900c, 0x780a, 0x6809, 0x780a, 0x700a, 0x700b, 0x680a, 0x680a,
0x580a, 0x580b, 0x500b, 0x500c, 0x500d, 0x500d, 0x580e, 0x500f, 0x500f,
0x500f, 0x5810, 0x5810, 0x5811, 0x5851, 0x5871, 0x58b2, 0x58d2, 0x58f2,
0x6112, 0x6193, 0x61d3, 0x6213, 0x6233, 0x6253, 0x6a33, 0x6a34, 0x7254,
0x7294, 0x8274, 0x8a94, 0x8a94, 0x8ab4, 0x82f4, 0x82f4, 0x8314, 0x8355,
0x8334, 0x8375, 0x8bd5, 0x8414, 0x7c54, 0x6c74, 0x6474, 0x5c53, 0x5453,
0x4452, 0x3c32, 0x4452, 0x6c13, 0x6c34, 0x7495, 0x7d16, 0x7536, 0x3cf3,
0x44b2, 0x54f2, 0x6533, 0x7554, 0x8574, 0xb5d6, 0xc5f6, 0xb5d6, 0xadd6,
0x9df5, 0xb5f6, 0xdd76, 0xe556, 0xed77, 0xed97, 0xf598, 0xde17, 0xae36,
0x5e15, 0x614, 0x614, 0x613, 0x613, 0x613, 0x613, 0x633, 0x633,
0x633, 0x653, 0x653, 0x673, 0x693, 0x6d5, 0x6d4, 0x6d4, 0x6d4,
0x5f3, 0x4d1, 0x3af, 0x24d, 0x11ad, 0x190d, 0x18ab, 0x188b, 0x18aa,
0x5333, 0x31b0, 0x3150, 0x3110, 0x30d0, 0x290f, 0x62f4, 0x3170, 0x30ef,
0x38b0, 0x3890, 0x3850, 0x3830, 0x3810, 0x4010, 0x4010, 0x4810, 0x480f,
0x480f, 0x480e, 0x500e, 0x500e, 0x500e, 0x580e, 0x580e, 0x600e, 0x600e,
0x580d, 0x600d, 0x600d, 0x600d, 0x600c, 0x600c, 0x600b, 0x600b, 0x600b,
0x600a, 0x600a, 0x6009, 0x5809, 0x5809, 0x5808, 0x5808, 0x5808, 0x5808,
0x5808, 0x5809, 0x6009, 0x7009, 0x780b, 0x680a, 0x600a, 0x680a, 0x780a,
0x6809, 0x6808, 0x6809, 0x6808, 0x6808, 0x6009, 0x600a, 0x580a, 0x580a,
0x500a, 0x500a, 0x500b, 0x500d, 0x480e, 0x500f, 0x500f, 0x5010, 0x5010,
0x5010, 0x5031, 0x5051, 0x5871, 0x58d2, 0x5912, 0x5932, 0x5972, 0x61b3,
0x61f3, 0x6213, 0x6273, 0x6ab3, 0x6a93, 0x6a54, 0x6a94, 0x7294, 0x7a74,
0x7a94, 0x7ab4, 0x7ab4, 0x7b35, 0x7b74, 0x7b94, 0x7b94, 0x7bd5, 0x7414,
0x7c14, 0x7c34, 0x7453, 0x6454, 0x6454, 0x5c54, 0x5433, 0x4412, 0x3c32,
0x3412, 0x2bf1, 0x3412, 0x3c12, 0x3c12, 0x2c11, 0x3c52, 0x4c92, 0x5d13,
0x6514, 0x6d34, 0x7554, 0x8d75, 0x95b5, 0x95b5, 0x8db5, 0x85b5, 0x95b5,
0xa5d6, 0x7d74, 0x85b5, 0x8dd5, 0x9dd6, 0xa5d5, 0x5d73, 0x1d94, 0x593,
0x593, 0x5b3, 0x5b2, 0x5b2, 0x5b2, 0x5f2, 0x5f3, 0x613, 0x612,
0x613, 0x633, 0x633, 0x694, 0x693, 0x693, 0x6b4, 0x693, 0x6f5,
0x633, 0x552, 0x3ef, 0x2ad, 0x11ee, 0x192d, 0x18cc, 0x292f, 0x210f,
0x310f, 0x31d0, 0x2a30, 0x316f, 0x3150, 0x3150, 0x3150, 0x310f, 0x30cf,
0x30cf, 0x30af, 0x308f, 0x306f, 0x304f, 0x302f, 0x300f, 0x300f, 0x300f,
0x380f, 0x380e, 0x380e, 0x400e, 0x400d, 0x480c, 0x480c, 0x400c, 0x400b,
0x400b, 0x400a, 0x480a, 0x4009, 0x4009, 0x4809, 0x4808, 0x4808, 0x5007,
0x5007, 0x5008, 0x5007, 0x5007, 0x5007, 0x5007, 0x5807, 0x5007, 0x5007,
0x5807, 0x6008, 0x6008, 0x6007, 0x6007, 0x6008, 0x6808, 0x6008, 0x6008,
0x6008, 0x5808, 0x5808, 0x5808, 0x5008, 0x5008, 0x5008, 0x4809, 0x4809,
0x480b, 0x480b, 0x480d, 0x480e, 0x400e, 0x480f, 0x480f, 0x4810, 0x5010,
0x5031, 0x5051, 0x5091, 0x50b2, 0x50f1, 0x5952, 0x5992, 0x59b2, 0x59b2,
0x5a13, 0x6233, 0x6233, 0x6213, 0x6a33, 0x7233, 0x7294, 0x72d4, 0x7314,
0x72f4, 0x7354, 0x7394, 0x73b4, 0x73d4, 0x7bb5, 0xa294, 0xaa74, 0xaa94,
0xa273, 0x9ad3, 0x9af4, 0x9314, 0x9314, 0x8b34, 0x8354, 0x7b94, 0x73b4,
0x6bb5, 0x63d4, 0x6414, 0x6c15, 0x6c14, 0x6c54, 0x3c73, 0x2c51, 0x3c92,
0x54f3, 0x5d13, 0x6513, 0x6513, 0x6513, 0x5d13, 0x4d12, 0x44f3, 0x4533,
0x4533, 0x4533, 0x2cf2, 0x6553, 0x4d53, 0x513, 0x4d2, 0x4b1, 0x4f1,
0x511, 0x532, 0x571, 0x572, 0x592, 0x592, 0x5b2, 0x5d2, 0x5f3,
0x5f2, 0x612, 0x632, 0x632, 0x652, 0x633, 0x653, 0x653, 0x653,
0x652, 0x5b2, 0x471, 0x34f, 0x24d, 0x210e, 0x3af3, 0x21af, 0x290e,
0x292f, 0x314f, 0x3150, 0x3150, 0x310f, 0x30ef, 0x38f0, 0x30cf, 0x30af,
0x30af, 0x306f, 0x306f, 0x306f, 0x304f, 0x302f, 0x300e, 0x300e, 0x300e,
0x300e, 0x300e, 0x300d, 0x300c, 0x380c, 0x380c, 0x380c, 0x300b, 0x300a,
0x380a, 0x3809, 0x3809, 0x3809, 0x3808, 0x3807, 0x4007, 0x4008, 0x4008,
0x4008, 0x4008, 0x4807, 0x4807, 0x4807, 0x5008, 0x5008, 0x5008, 0x5808,
0x6008, 0x5808, 0x5008, 0x5808, 0x5808, 0x5808, 0x5808, 0x5808, 0x5809,
0x6009, 0x580a, 0x580a, 0x580a, 0x500b, 0x480c, 0x480c, 0x400d, 0x400e,
0x400e, 0x400f, 0x400f, 0x4810, 0x4810, 0x4830, 0x4851, 0x4871, 0x5071,
0x50d1, 0x50f2, 0x5132, 0x5972, 0x5992, 0x59b2, 0x59f2, 0x5a52, 0x6293,
0x6293, 0x6293, 0x62b4, 0x6293, 0x62b3, 0x6ab3, 0x6af4, 0x6b13, 0x6b74,
0x73b4, 0x6bd4, 0x6bf4, 0x6c14, 0x6413, 0x6434, 0x6c34, 0x6434, 0x5433,
0x4412, 0x3412, 0x23d1, 0x1b91, 0xb90, 0x370, 0x370, 0x370, 0x370,
0x370, 0x390, 0x3b0, 0x3d1, 0x411, 0x430, 0xc31, 0xc51, 0x1c92,
0x2491, 0x2cb2, 0x24d2, 0x2cb2, 0x24b2, 0x14d2, 0x14f2, 0x1d13, 0x1cf3,
0x4d2, 0x4d2, 0x513, 0x512, 0x4b1, 0x4b1, 0x4d1, 0x511, 0x511,
0x532, 0x552, 0x572, 0x572, 0x592, 0x592, 0x5d2, 0x5f2, 0x5f3,
0x613, 0x612, 0x632, 0x633, 0x633, 0x632, 0x652, 0x653, 0x673,
0x653, 0x612, 0x511, 0x29b0, 0x294f, 0x294f, 0x292f, 0x292f, 0x292f,
0x3970, 0x312f, 0x30ef, 0x28ce, 0x28cf, 0x30af, 0x30ae, 0x30af, 0x286e,
0x306f, 0x282e, 0x300e, 0x280d, 0x280e, 0x280d, 0x300d, 0x300d, 0x300d,
0x300c, 0x300b, 0x300b, 0x300b, 0x300b, 0x300a, 0x300a, 0x3009, 0x3009,
0x3008, 0x3007, 0x3007, 0x3807, 0x3807, 0x3807, 0x4007, 0x4007, 0x4008,
0x4808, 0x4808, 0x4808, 0x5008, 0x5008, 0x5008, 0x5008, 0x5808, 0x5008,
0x5007, 0x5007, 0x5808, 0x5807, 0x5807, 0x5808, 0x5008, 0x5008, 0x5009,
0x5009, 0x480a, 0x480b, 0x480c, 0x400d, 0x400d, 0x400e, 0x400e, 0x380f,
0x400f, 0x4010, 0x4811, 0x4830, 0x4851, 0x4871, 0x4891, 0x48f1, 0x5112,
0x5952, 0x5972, 0x59b3, 0x59d2, 0x5233, 0x5a73, 0x6293, 0x6293, 0x6273,
0x6273, 0x6273, 0x6a94, 0x6a93, 0x6ad4, 0x6af4, 0x6b34, 0x6b74, 0x6bb4,
0x6bd4, 0x6bf4, 0x6b34, 0x6b74, 0x6bf4, 0x6bf4, 0x5c14, 0x4bf3, 0x3bd2,
0x2bd2, 0x1bb2, 0xb91, 0x371, 0x370, 0x370, 0x370, 0x4c75, 0x5c75,
0x6475, 0x64b5, 0x64f5, 0x6516, 0x4cf5, 0x472, 0x1c51, 0x2492, 0x1471,
0x1492, 0x1471, 0x1471, 0x491, 0x4b2, 0x4b2, 0x4d2, 0x4f3, 0x4d2,
0x4d2, 0x4b2, 0x491, 0x491, 0x4b1, 0x4d1, 0x4f1, 0x511, 0x511,
0x531, 0x552, 0x572, 0x572, 0x5b2, 0x5b2, 0x5d2, 0x5f3, 0x612,
0x612, 0x612, 0x633, 0x633, 0x632, 0x632, 0x653, 0x633, 0x653,
0x633, 0x28ee, 0x292f, 0x292f, 0x292f, 0x312f, 0x310f, 0x290f, 0x28ef,
0x28ef, 0x30ef, 0x28cf, 0x30cf, 0x30af, 0x30af, 0x30af, 0x284e, 0x282e,
0x280d, 0x280d, 0x280d, 0x280d, 0x300d, 0x300d, 0x300c, 0x300c, 0x300c,
0x280c, 0x280c, 0x300b, 0x300a, 0x300a, 0x3009, 0x3008, 0x3007, 0x3807,
0x3807, 0x4007, 0x4007, 0x4008, 0x4008, 0x4009, 0x4008, 0x4808, 0x4808,
0x4808, 0x5008, 0x5008, 0x5008, 0x5808, 0x5808, 0x5807, 0x5007, 0x5007,
0x5808, 0x5007, 0x5007, 0x5008, 0x5008, 0x5009, 0x500a, 0x500a, 0x480b,
0x480c, 0x480c, 0x400d, 0x400d, 0x400e, 0x400e, 0x400f, 0x400f, 0x4010,
0x4810, 0x4830, 0x4871, 0x4891, 0x48b1, 0x5112, 0x5132, 0x5172, 0x5972,
0x5992, 0x59b2, 0x5a12, 0x5a53, 0x5a53, 0x5a53, 0x6273, 0x6293, 0x6293,
0x6273, 0x6273, 0x6af4, 0x6b14, 0x6b74, 0x6bb4, 0x6bd4, 0x6bf4, 0x6c14,
0x6413, 0x5c13, 0x53f3, 0x4bf3, 0x43f3, 0x3bf2, 0x33d2, 0x2391, 0x1bb1,
0x1bb1, 0x391, 0x370, 0x370, 0x370, 0x370, 0x4474, 0x5454, 0x5c54,
0x6495, 0x6c75, 0x6c95, 0x7c95, 0x3472, 0x3492, 0x1c72, 0x1471, 0x1c92,
0x1491, 0x471, 0x492, 0x492, 0x4b2, 0x4b2, 0x4b2, 0x4d2, 0x4d2,
0x491, 0x471, 0x490, 0x4b0, 0x4b1, 0x4d1, 0x4f1, 0x511, 0x531,
0x551, 0x552, 0x572, 0x592, 0x5b2, 0x5d2, 0x5d2, 0x5f2, 0x5f2,
0x613, 0x613, 0x613, 0x613, 0x632, 0x632, 0x633, 0x633, 0x292f,
0x290e, 0x28ee, 0x290f, 0x290e, 0x28ee, 0x28ee, 0x28ce, 0x28cf, 0x28ce,
0x288e, 0x28ae, 0x288e, 0x286e, 0x282d, 0x280d, 0x280d, 0x280d, 0x280c,
0x280c, 0x280c, 0x280c, 0x280b, 0x280b, 0x280b, 0x280b, 0x280b, 0x2809,
0x2809, 0x2809, 0x2808, 0x3008, 0x3008, 0x3008, 0x3007, 0x3807, 0x4008,
0x4007, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4808, 0x4808, 0x5008,
0x5008, 0x5808, 0x5808, 0x5808, 0x5008, 0x5008, 0x5007, 0x5008, 0x5008,
0x5008, 0x5009, 0x5009, 0x500a, 0x480b, 0x480b, 0x480b, 0x480d, 0x400d,
0x400d, 0x380e, 0x400f, 0x400f, 0x400f, 0x4010, 0x4010, 0x4831, 0x4851,
0x4891, 0x4891, 0x48b1, 0x48f2, 0x5152, 0x5192, 0x5192, 0x59f2, 0x5a13,
0x5a13, 0x5a53, 0x62b3, 0x62b4, 0x5af3, 0x6333, 0x6b34, 0x62f3, 0x62f3,
0x6af3, 0x6b34, 0x6353, 0x63b4, 0x63d4, 0x63d3, 0x63d4, 0x53f4, 0x4bd2,
0x43d3, 0x3bd3, 0x3bd2, 0x33b2, 0x2bb2, 0x1b91, 0x1370, 0xb70, 0x350,
0x350, 0x350, 0x370, 0x370, 0xb71, 0x3bf2, 0x33f2, 0x33d2, 0x3c12,
0x4433, 0x3451, 0x1c31, 0xc31, 0x431, 0x410, 0x431, 0x1472, 0xc71,
0x471, 0x471, 0x492, 0x492, 0x492, 0x492, 0x492, 0x471, 0x450,
0x470, 0x471, 0x491, 0x4b1, 0x4b1, 0x4d1, 0x511, 0x511, 0x551,
0x552, 0x572, 0x592, 0x5b2, 0x5b2, 0x5d3, 0x5d2, 0x5f3, 0x5f2,
0x5f3, 0x5f3, 0x612, 0x613, 0x632, 0x633, 0x292e, 0x292f, 0x290e,
0x28ee, 0x28ee, 0x28ce, 0x28ae, 0x28ce, 0x28ce, 0x28ae, 0x28ae, 0x286e,
0x284d, 0x282d, 0x282c, 0x282d, 0x280c, 0x280c, 0x280c, 0x280c, 0x280b,
0x200b, 0x200a, 0x280a, 0x280a, 0x280a, 0x280a, 0x2809, 0x2808, 0x2808,
0x2808, 0x2807, 0x3007, 0x3007, 0x3006, 0x3007, 0x3007, 0x3807, 0x4008,
0x4008, 0x4008, 0x4008, 0x4808, 0x4808, 0x4808, 0x5008, 0x5007, 0x5007,
0x5808, 0x5008, 0x5008, 0x5008, 0x5007, 0x5008, 0x5008, 0x5008, 0x5008,
0x4809, 0x480a, 0x480a, 0x480b, 0x480b, 0x400c, 0x380d, 0x380d, 0x380e,
0x380f, 0x380f, 0x4010, 0x4010, 0x4010, 0x4030, 0x4050, 0x4871, 0x4891,
0x48d1, 0x4912, 0x5152, 0x4972, 0x51d2, 0x59f2, 0x5a33, 0x5a53, 0x5a93,
0x5ad3, 0x5ab3, 0x6273, 0x6293, 0x62f3, 0x62f3, 0x62f3, 0x62d3, 0x6ab3,
0x6af3, 0x6373, 0x5bb3, 0x5bd3, 0x63d4, 0x5bd3, 0x4bd3, 0x4bd3, 0x43d2,
0x3bb2, 0x33b2, 0x2b91, 0x2bd2, 0x23b1, 0x1b91, 0xb70, 0x350, 0x350,
0x370, 0x370, 0x390, 0x390, 0x390, 0x390, 0x3b0, 0xbd1, 0x13d1,
0x2432, 0x1bf1, 0xc11, 0x411, 0x411, 0x411, 0x411, 0x431, 0x451,
0x451, 0x471, 0x472, 0x452, 0x451, 0x430, 0x451, 0x451, 0x471,
0x491, 0x490, 0x491, 0x4b1, 0x4d1, 0x4d1, 0x4f1, 0x511, 0x531,
0x552, 0x572, 0x572, 0x572, 0x592, 0x5b2, 0x5b2, 0x5d2, 0x5f3,
0x5f2, 0x613, 0x612, 0x612, 0x28ee, 0x28ee, 0x28ee, 0x28ad, 0x20ad,
0x20ad, 0x28ce, 0x28ad, 0x288d, 0x286d, 0x286d, 0x286d, 0x284c, 0x282c,
0x202c, 0x282c, 0x280c, 0x280b, 0x280b, 0x200b, 0x200a, 0x200a, 0x200a,
0x200a, 0x2009, 0x2009, 0x2009, 0x2008, 0x2008, 0x2007, 0x2807, 0x2807,
0x2806, 0x2807, 0x2806, 0x3006, 0x3007, 0x3007, 0x3807, 0x3807, 0x4007,
0x4007, 0x4008, 0x4808, 0x4808, 0x4808, 0x5008, 0x5008, 0x5008, 0x5008,
0x4808, 0x4807, 0x4807, 0x4808, 0x4808, 0x4809, 0x4809, 0x4809, 0x480a,
0x480a, 0x400b, 0x400b, 0x380c, 0x400d, 0x380d, 0x380e, 0x380e, 0x4010,
0x3810, 0x4010, 0x4050, 0x4050, 0x48b1, 0x48d1, 0x4911, 0x4932, 0x4972,
0x51d2, 0x51f2, 0x5212, 0x5212, 0x5a53, 0x5a93, 0x5ab3, 0x5ab3, 0x5ab3,
0x5ab3, 0x5a93, 0x5ab3, 0x62d3, 0x6293, 0x6294, 0x6af3, 0x5b73, 0x5b93,
0x5b93, 0x5bb3, 0x5bd4, 0x53b3, 0x53f3, 0x43b2, 0x43b2, 0x3bd2, 0x3bd2,
0x2bb1, 0x2391, 0x1371, 0x1350, 0x350, 0x350, 0x350, 0x350, 0x370,
0x370, 0x370, 0x390, 0x390, 0x390, 0x3d1, 0x3b0, 0x3d0, 0x3f1,
0x3f1, 0x411, 0x3f1, 0x411, 0x432, 0x432, 0x452, 0x452, 0x472,
0x472, 0x472, 0x451, 0x430, 0x431, 0x431, 0x450, 0x470, 0x470,
0x491, 0x4d1, 0x4f1, 0x4f1, 0x4f1, 0x511, 0x511, 0x511, 0x531,
0x552, 0x552, 0x572, 0x572, 0x592, 0x592, 0x5b2, 0x5d2, 0x5d3,
0x5d2, 0x5f3});
img3 = (std::vector<uint16_t>{
0xa8a8, 0xa8a8, 0xa8a7, 0xa8c7, 0xa8c7, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8,
0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xb0e8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8c8, 0xb8c8,
0xb8c9, 0xb8c9, 0xb8c9, 0xb8c9, 0xb8c9, 0xc0c9, 0xc0c9, 0xc0a9, 0xc0aa,
0xc0aa, 0xc0aa, 0xc0aa, 0xc0aa, 0xc0aa, 0xc0aa, 0x8153, 0x8173, 0x8173,
0x8173, 0x8173, 0x8173, 0x8973, 0x8973, 0x8993, 0x8993, 0x8993, 0x8993,
0x8993, 0x8994, 0x8994, 0x8994, 0x91b4, 0x89d4, 0x89d4, 0x89d4, 0x91d4,
0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4,
0x91d4, 0x91d4, 0x91d4, 0x91d4, 0x91d5, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d5, 0x89d5, 0x89d5, 0x89d5, 0x81d4, 0x81d5, 0x81d5, 0x81d5,
0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x5995, 0x52b7,
0x441a, 0x443a, 0x443a, 0x447a, 0x447a, 0x447a, 0x3c9b, 0x3cbb, 0x3cdb,
0x3cfb, 0x457c, 0x457c, 0x457d, 0x459d, 0x459d, 0x45bd, 0x3dbd, 0x3ddd,
0x3ddd, 0x3ddd, 0x3dfd, 0x3dfd, 0x3e1e, 0x3e1e, 0x3e1e, 0x3e3e, 0x363e,
0x365e, 0x365e, 0x365e, 0x367e, 0x367e, 0x367e, 0x369e, 0x369e, 0x369f,
0x2e9f, 0x36bf, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf,
0x2edf, 0x2edf, 0x2eff, 0x2eff, 0x2eff, 0x2eff, 0x2eff, 0xa8a8, 0xa8a7,
0xa8c7, 0xa8c7, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xa8c7, 0xa8c8, 0xa8c8,
0xa8c8, 0xb0e8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e9, 0xb8e9, 0xb8e9,
0xb8c9, 0xb8c9, 0xb8c9, 0xc0c9, 0xc0c9, 0xc0c9, 0xc0ca, 0xc0ca, 0xc0aa,
0xc0aa, 0xc0aa, 0xc0aa, 0xc0aa, 0xc0aa, 0x8152, 0x8173, 0x8173, 0x8173,
0x8173, 0x8173, 0x8173, 0x8173, 0x8993, 0x8993, 0x8993, 0x8993, 0x8993,
0x8993, 0x89b4, 0x89b4, 0x89b4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x91d4, 0x91d4, 0x91d4, 0x91d4,
0x91d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d5, 0x89d5, 0x89d5,
0x89d4, 0x89d4, 0x89d5, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x81d5,
0x81d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x4b17,
0x443a, 0x443a, 0x445a, 0x447a, 0x449a, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cdb,
0x3cfb, 0x3cfb, 0x3d3c, 0x459d, 0x459d, 0x3dbd, 0x3dbd, 0x3ddd, 0x3ddd,
0x3ddd, 0x3ddd, 0x3dfd, 0x3e1e, 0x3e1e, 0x3e1e, 0x363e, 0x363e, 0x365e,
0x365e, 0x365e, 0x367e, 0x367e, 0x367e, 0x367e, 0x369e, 0x2e9f, 0x369f,
0x36bf, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf,
0x2edf, 0x2eff, 0x2eff, 0x2eff, 0x2eff, 0xa8a7, 0xa8c7, 0xa8c7, 0xa8c7,
0xa8c8, 0xa8c8, 0xa8c8, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xb0c8, 0xb0c8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e9, 0xb8e9,
0xb8e9, 0xc0c9, 0xc0e9, 0xc0c9, 0xc0c9, 0xc0ca, 0xc0aa, 0xc0ca, 0xc0aa,
0xc0aa, 0xc0aa, 0xc8aa, 0xc0aa, 0xb8cc, 0x8173, 0x8173, 0x8173, 0x8173,
0x8173, 0x8173, 0x8173, 0x8173, 0x8993, 0x8993, 0x8993, 0x8994, 0x8993,
0x89b3, 0x8994, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d5, 0x89d5, 0x89d5, 0x89d4, 0x89d4, 0x89d5,
0x81d4, 0x81d4, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x4b78,
0x445a, 0x445a, 0x447a, 0x449a, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cdb, 0x3cfb,
0x3d1b, 0x351c, 0x3d3c, 0x355c, 0x355c, 0x3dbd, 0x3ddd, 0x3ddd, 0x3dfd,
0x3dfd, 0x3dfd, 0x3e1e, 0x3e1e, 0x3e1e, 0x363e, 0x363e, 0x363e, 0x365e,
0x365e, 0x365e, 0x367e, 0x367e, 0x369e, 0x369e, 0x2e9e, 0x369e, 0x36bf,
0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf,
0x2eff, 0x2eff, 0x2eff, 0xa8a7, 0xa8c7, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8,
0xa8c7, 0xa8c8, 0xa8c8, 0xa8c7, 0xb0c8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e9, 0xc0e9, 0xc0e9, 0xc0e9,
0xc0c9, 0xc0c9, 0xc0c9, 0xc0c9, 0xc0ca, 0xc0ca, 0xc0ca, 0xc0aa, 0xc0aa,
0xc0aa, 0xc8aa, 0xc8aa, 0xc0ab, 0x7953, 0x8173, 0x8173, 0x8173, 0x8173,
0x8193, 0x8173, 0x8173, 0x8993, 0x8993, 0x8993, 0x8993, 0x8994, 0x8994,
0x8994, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d5,
0x89d4, 0x89d5, 0x89d5, 0x89d4, 0x89d4, 0x89d4, 0x89d5, 0x81d4, 0x81d4,
0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71d5, 0x71b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x5995, 0x4bd9,
0x445a, 0x447a, 0x3c9a, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cfb, 0x3cfb, 0x3d1b,
0x351c, 0x3d3c, 0x355c, 0x355c, 0x357c, 0x357c, 0x359c, 0x3ddd, 0x3dfd,
0x3dfd, 0x3e1e, 0x3e1e, 0x3e1e, 0x363e, 0x363e, 0x363e, 0x365e, 0x365e,
0x365e, 0x367e, 0x367e, 0x367e, 0x369e, 0x2e9f, 0x369f, 0x2ebf, 0x2ebf,
0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf,
0x2eff, 0xa8c7, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xa8c7, 0xa8c8, 0xa8c8,
0xb0c8, 0xb0c8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xb8e8, 0xb8e9, 0xb8e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9,
0xc0e9, 0xc0ca, 0xc0ca, 0xc0ca, 0xc0ca, 0xc0ca, 0xc0aa, 0xc0aa, 0xc8aa,
0xc8aa, 0xc8aa, 0xc8ab, 0x7953, 0x7953, 0x8173, 0x8173, 0x8173, 0x8173,
0x8173, 0x8193, 0x8193, 0x8193, 0x8193, 0x8993, 0x8993, 0x8994, 0x89b4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d5,
0x89d4, 0x89d4, 0x89d4, 0x89d5, 0x89d5, 0x81d4, 0x81d4, 0x81d5, 0x81d5,
0x81d5, 0x81d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x71d5, 0x71b5, 0x71b5, 0x71d5, 0x51b5, 0x51b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x443a,
0x3c7a, 0x3c9a, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cdb, 0x3cfb, 0x3d1b, 0x351c,
0x353c, 0x353c, 0x355c, 0x357c, 0x357c, 0x359c, 0x35bd, 0x35bd, 0x35dd,
0x35fe, 0x3e1e, 0x3e1e, 0x363e, 0x363e, 0x363e, 0x365e, 0x365e, 0x365e,
0x367e, 0x367e, 0x367e, 0x369e, 0x2e9e, 0x369f, 0x2e9f, 0x2ebf, 0x2ebf,
0x2ebf, 0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2eff, 0xa8c7,
0xa8c7, 0xa8c8, 0xa8c8, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xb0c8, 0xb0c8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0e9, 0xc0ea,
0xc0c9, 0xc8ca, 0xc0ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8aa, 0xc8ab,
0xc8ab, 0xc8ab, 0xb8ad, 0x7953, 0x7973, 0x8173, 0x8173, 0x8173, 0x8173,
0x8173, 0x8193, 0x8193, 0x8193, 0x8193, 0x8994, 0x8994, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d5,
0x89d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d5, 0x81d5, 0x81d5, 0x81d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71d5, 0x71b5,
0x71b5, 0x71d5, 0x71b5, 0x71d5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x445a,
0x3c7a, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cdb, 0x3cfb, 0x3d1b, 0x351c, 0x353c,
0x353c, 0x355c, 0x357c, 0x357c, 0x359d, 0x359d, 0x35bd, 0x35dd, 0x35dd,
0x2ddd, 0x2dfd, 0x361e, 0x361e, 0x363e, 0x365e, 0x365e, 0x365e, 0x365e,
0x367e, 0x367e, 0x369e, 0x2e9e, 0x369f, 0x2e9f, 0x2ebf, 0x2ebf, 0x2ebf,
0x2ebf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0x2edf, 0xa8c7, 0xa8c8, 0xa8c8,
0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xb0c8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xb908, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xc0e9, 0xc0e9,
0xc109, 0xc109, 0xc0e9, 0xc109, 0xc0e9, 0xc0e9, 0xc8e9, 0xc8ea, 0xc8ca,
0xc8ea, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8ab, 0xc8ab, 0xc8ab, 0xc8ab,
0xc8ab, 0xc8ab, 0x7973, 0x7973, 0x7973, 0x7973, 0x8173, 0x8173, 0x8173,
0x8173, 0x8193, 0x8194, 0x8194, 0x8194, 0x8194, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4,
0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x89d5, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d5, 0x81d5, 0x81d5, 0x79d4, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71b5, 0x71b5, 0x71d5, 0x71d5,
0x71d5, 0x71b5, 0x71b5, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x3c7b,
0x3c9b, 0x3c9b, 0x3cbb, 0x3cdb, 0x3cfb, 0x3cfb, 0x351c, 0x353c, 0x353c,
0x355c, 0x357c, 0x357c, 0x359d, 0x359d, 0x35bd, 0x35bd, 0x35dd, 0x35dd,
0x2dfd, 0x2e1d, 0x2e1e, 0x2e3e, 0x363e, 0x365e, 0x365e, 0x365e, 0x367e,
0x367e, 0x369e, 0x2e9e, 0x369f, 0x2e9f, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf,
0x2edf, 0x2edf, 0x2edf, 0x2edf, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c7, 0xa8c8,
0xa8c8, 0xb0c8, 0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb8e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb908, 0xb908,
0xb908, 0xb908, 0xb8e8, 0xb908, 0xc108, 0xc108, 0xc109, 0xc109, 0xc109,
0xc109, 0xc109, 0xc0e9, 0xc0e9, 0xc8e9, 0xc8e9, 0xc8ea, 0xc8ea, 0xc8ca,
0xc8ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8ab, 0xc8ab, 0xc8ab, 0xc8ab,
0xc8ab, 0x7953, 0x7973, 0x7973, 0x7973, 0x8173, 0x8173, 0x8173, 0x8193,
0x8193, 0x8193, 0x8193, 0x8194, 0x81b4, 0x81b4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x89d4, 0x89d4, 0x89d4, 0x89d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d5,
0x81d5, 0x81d5, 0x79d4, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x71d5, 0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71b5, 0x71b5,
0x71b5, 0x71b5, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195,
0x5195, 0x5195, 0x5195, 0x5195, 0x51b5, 0x51b5, 0x5195, 0x51b5, 0x34bb,
0x3cbb, 0x3cbb, 0x3cdb, 0x3cfb, 0x34fc, 0x351c, 0x353c, 0x353c, 0x355c,
0x357c, 0x357c, 0x359d, 0x359d, 0x2dbd, 0x35dd, 0x35dd, 0x2ddd, 0x2dfd,
0x2dfd, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x367e, 0x367e,
0x367e, 0x369e, 0x2e9f, 0x2e9f, 0x2ebf, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf,
0x2edf, 0x2edf, 0xa8c8, 0xa8c7, 0xa8c8, 0xa8c8, 0xa8c8, 0xb0c8, 0xb0c8,
0xb0c8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908,
0xc108, 0xb908, 0xc108, 0xc108, 0xc109, 0xc109, 0xc109, 0xc109, 0xc109,
0xc109, 0xc109, 0xc909, 0xc8e9, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ca,
0xc8ca, 0xc8ca, 0xc8ca, 0xc8ca, 0xc8cb, 0xc8cb, 0xc8ab, 0xc8ab, 0xc8ab,
0xa8ed, 0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x8173, 0x8193, 0x8193,
0x8193, 0x8193, 0x8193, 0x81b4, 0x81b4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d5, 0x81d5, 0x81d5, 0x81d4,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x69d5,
0x69b5, 0x51b5, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195,
0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x3c9b,
0x3cbb, 0x34db, 0x34fb, 0x34fc, 0x351b, 0x353c, 0x353c, 0x355c, 0x357c,
0x357c, 0x359d, 0x359d, 0x35bd, 0x35dd, 0x35dd, 0x2ddd, 0x2dfd, 0x2dfd,
0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e7e, 0x2e7e, 0x2e7e,
0x369e, 0x2e9f, 0x2e9f, 0x2ebf, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0x2edf,
0xb0c8, 0xb0e8, 0xb0c8, 0xb0e8, 0xa8c7, 0xb0c8, 0xb0c8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb8e8,
0xb8e8, 0xb8e8, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108,
0xc108, 0xc108, 0xc108, 0xc109, 0xc108, 0xc109, 0xc109, 0xc109, 0xc909,
0xc909, 0xc909, 0xc909, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea,
0xc8ca, 0xc8ca, 0xc8cb, 0xc8ca, 0xc8ab, 0xc8ab, 0xc8ab, 0xc8ab, 0xc8ab,
0x7973, 0x7953, 0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x8193,
0x8193, 0x8194, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81b4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81b4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d5, 0x81d5, 0x81d5, 0x81d5, 0x79d4, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71b5, 0x71b5, 0x71d5,
0x71d5, 0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x69d5, 0x69b5, 0x69b5, 0x69b5,
0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195,
0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x5195, 0x3cdb,
0x2cdb, 0x34db, 0x34fc, 0x351b, 0x353c, 0x353c, 0x355c, 0x357c, 0x357c,
0x359c, 0x359d, 0x2dbd, 0x2dbd, 0x35dd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d,
0x2e1e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e5e, 0x2e7e, 0x2e7e, 0x2e7e,
0x2e9e, 0x2e9e, 0x2e9f, 0x2ebf, 0x2ebf, 0x2ebf, 0x2edf, 0xb0e7, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb8e8, 0xb908, 0xb8e8, 0xb8e8,
0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc108,
0xc108, 0xc109, 0xc109, 0xc109, 0xc909, 0xc909, 0xc909, 0xc909, 0xc909,
0xc909, 0xc90a, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ea, 0xc8ca,
0xc8ca, 0xc8cb, 0xc8cb, 0xc8ab, 0xc8ab, 0xc8ab, 0xc88b, 0xc88b, 0x7973,
0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7993, 0x7993, 0x7993,
0x81b3, 0x81b4, 0x81b4, 0x81d4, 0x81d4, 0x81b4, 0x81b4, 0x81b4, 0x81b4,
0x81b4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x71b5, 0x71b5, 0x71b5, 0x71d5, 0x71b5, 0x71b5,
0x71b5, 0x71b5, 0x69d5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x5195,
0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x34db,
0x34fb, 0x34fb, 0x351b, 0x353c, 0x353c, 0x355c, 0x357c, 0x357c, 0x359c,
0x359d, 0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e3e,
0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e5e, 0x2e7e, 0x2e7e, 0x2e9e, 0x2e9e,
0x2e9e, 0x269e, 0x2ebf, 0x2ebf, 0x2edf, 0xb0e8, 0xb0e7, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8,
0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908,
0xb908, 0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc108,
0xc928, 0xc929, 0xc909, 0xc909, 0xc909, 0xc909, 0xc909, 0xc909, 0xc909,
0xc909, 0xc90a, 0xc90a, 0xd0ea, 0xd0ea, 0xd0ea, 0xc8ea, 0xc8cb, 0xd0ca,
0xd0cb, 0xc8cb, 0xd0ab, 0xc8ab, 0xc8ab, 0xc8ab, 0xc88b, 0x990f, 0x7973,
0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7993, 0x7993, 0x81b4,
0x81b4, 0x81b4, 0x81d4, 0x81b4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5,
0x71d5, 0x71b5, 0x71d5, 0x71d5, 0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x69b5,
0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x5195, 0x5195, 0x49b5, 0x34db,
0x34fb, 0x351b, 0x353c, 0x353c, 0x355c, 0x355c, 0x357c, 0x359c, 0x359d,
0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1e, 0x2e3e,
0x2e3e, 0x2e5e, 0x2e5e, 0x2e5e, 0x2e7e, 0x2e7e, 0x2e7e, 0x2e9e, 0x2e9e,
0x2e9e, 0x2ebf, 0x2ebf, 0xb0e7, 0xb0e7, 0xb0e7, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb8e8,
0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908,
0xc108, 0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc128, 0xc929, 0xc929,
0xc929, 0xc929, 0xc929, 0xc909, 0xc909, 0xc909, 0xc909, 0xc909, 0xc90a,
0xc90a, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0cb, 0xd0cb,
0xd0cb, 0xc8ab, 0xc8ab, 0xc8ab, 0xc8ab, 0xc88b, 0xc88b, 0x7953, 0x7973,
0x7973, 0x7973, 0x7973, 0x7973, 0x7973, 0x7994, 0x7994, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81b4, 0x81b4, 0x81b4, 0x81d4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x81d4, 0x79d4, 0x79d4, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71d5, 0x71d5, 0x71d5,
0x71d5, 0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x69b5, 0x69b5, 0x69b5,
0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x5195, 0x5195, 0x5195,
0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x5195,
0x5195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x34fb,
0x34fc, 0x351c, 0x353c, 0x355c, 0x355c, 0x357c, 0x357c, 0x359d, 0x2dbd,
0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0x2e3e, 0x2e3e,
0x2e3e, 0x2e5e, 0x2e5e, 0x2e7e, 0x267e, 0x2e7e, 0x2e9e, 0x2e9e, 0x2e9e,
0x2ebf, 0xb107, 0xb108, 0xb108, 0xb108, 0xb108, 0xb0e8, 0xb0e8, 0xb0e8,
0xb0e8, 0xb0e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb908, 0xb908,
0xb908, 0xc108, 0xc108, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108, 0xc108,
0xc108, 0xc128, 0xc128, 0xc128, 0xc128, 0xc929, 0xc929, 0xc929, 0xc929,
0xc929, 0xc929, 0xc929, 0xc909, 0xc929, 0xd10a, 0xd10a, 0xd10a, 0xd10a,
0xd10a, 0xd10a, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0cb, 0xd0cb, 0xd0cb,
0xd0cb, 0xd0ab, 0xc8ab, 0xc8ab, 0xc88b, 0xd08c, 0x7173, 0x7173, 0x7173,
0x7973, 0x7973, 0x7973, 0x7973, 0x7993, 0x81b4, 0x81d4, 0x81d4, 0x81b4,
0x81d4, 0x81b4, 0x81b4, 0x81d4, 0x81d4, 0x81b4, 0x81d4, 0x81d4, 0x81d4,
0x81d4, 0x81d4, 0x79d4, 0x79d4, 0x79d4, 0x79d4, 0x79d4, 0x79d5, 0x79d5,
0x79d5, 0x79d5, 0x79d5, 0x79d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71b5,
0x71b5, 0x71b5, 0x71b5, 0x71b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x49b5, 0x4995, 0x351c,
0x351c, 0x353c, 0x353c, 0x355c, 0x357c, 0x359c, 0x359d, 0x2dbd, 0x2dbd,
0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e3e,
0x2e5e, 0x2e5e, 0x2e7e, 0x2e7e, 0x2e9e, 0x2e9e, 0x2e9e, 0x2e9e, 0xb107,
0xb107, 0xb107, 0xb108, 0xb108, 0xb0e8, 0xb0e8, 0xb108, 0xb8e8, 0xb8e8,
0xb8e8, 0xb8e8, 0xb8e8, 0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108,
0xc108, 0xc108, 0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc108, 0xc128,
0xc128, 0xc128, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929,
0xd129, 0xd129, 0xd109, 0xd129, 0xd129, 0xd10a, 0xd10a, 0xd10a, 0xd10a,
0xd10a, 0xd0ea, 0xd0ea, 0xd0ea, 0xd0ca, 0xd0eb, 0xd0cb, 0xd0cb, 0xd0cb,
0xd0ab, 0xc8ab, 0xc88b, 0xc88b, 0xc88b, 0x8951, 0x7173, 0x7173, 0x7973,
0x7973, 0x7973, 0x7973, 0x7974, 0x81b4, 0x81b4, 0x81b4, 0x81b4, 0x81b4,
0x81b4, 0x81b4, 0x81b4, 0x81d4, 0x81b4, 0x79b4, 0x81d4, 0x81d4, 0x81d4,
0x79d4, 0x79d4, 0x79d4, 0x79d4, 0x79d5, 0x79d4, 0x79d5, 0x79d5, 0x79d5,
0x79d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71b5, 0x71b5,
0x71b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x49b5, 0x4995, 0x49b5, 0x49b5, 0x49b5, 0x4995, 0x4995, 0x49b5, 0x351c,
0x353c, 0x353c, 0x355c, 0x357c, 0x357c, 0x359d, 0x2dbd, 0x2dbd, 0x2ddd,
0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e,
0x2e5e, 0x2e7e, 0x2e7e, 0x2e9e, 0x2e9e, 0x2e9e, 0xb908, 0xb908, 0xb908,
0xb908, 0xb908, 0xb908, 0xb108, 0xb908, 0xb908, 0xb908, 0xb908, 0xb8e8,
0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc108,
0xc108, 0xc108, 0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc128, 0xc929,
0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xd129, 0xd129,
0xd129, 0xd129, 0xd12a, 0xd12a, 0xd10a, 0xd10a, 0xd10a, 0xd10a, 0xd10a,
0xd0ea, 0xd0ea, 0xd0ea, 0xd0eb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0ab,
0xd0ab, 0xc88b, 0xc88b, 0xc88c, 0xc88b, 0x7973, 0x7173, 0x7173, 0x7173,
0x7173, 0x7173, 0x7993, 0x79b4, 0x79b4, 0x81b4, 0x79b4, 0x79d4, 0x79d4,
0x79b4, 0x79b4, 0x79b4, 0x81d4, 0x79d4, 0x79d4, 0x79d4, 0x79d4, 0x79b4,
0x79d4, 0x79d4, 0x79d4, 0x79d4, 0x79d5, 0x79b5, 0x79d5, 0x79d5, 0x71d5,
0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71b5, 0x71b5, 0x71b5, 0x69b5, 0x69b5,
0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x49b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4995, 0x4995, 0x4995, 0x49b5,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x41b5, 0x353c,
0x353c, 0x355c, 0x2d7c, 0x357c, 0x359c, 0x359d, 0x2dbd, 0x2dbd, 0x2ddd,
0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e,
0x267e, 0x2e7e, 0x269e, 0x2e9e, 0xb908, 0xb928, 0xb908, 0xb908, 0xb908,
0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908,
0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc108,
0xc108, 0xc108, 0xc128, 0xc128, 0xc128, 0xc129, 0xc929, 0xc929, 0xc929,
0xc929, 0xc929, 0xc929, 0xd149, 0xd149, 0xd129, 0xd129, 0xd129, 0xd129,
0xd129, 0xd12a, 0xd12a, 0xd10a, 0xd10a, 0xd10a, 0xd10a, 0xd10a, 0xd10b,
0xd10a, 0xd0ea, 0xd0eb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab,
0xd0ab, 0xc88b, 0xc88b, 0xc88c, 0x7173, 0x7173, 0x7173, 0x7173, 0x7173,
0x7173, 0x79b4, 0x79b4, 0x81b4, 0x79d4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79d4, 0x79d4, 0x79d4, 0x79b4, 0x79b4, 0x79d4,
0x79d4, 0x79d5, 0x79b5, 0x79d5, 0x79d5, 0x71d5, 0x71d5, 0x71b5, 0x71d5,
0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5,
0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x59b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x49b5, 0x49b5, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x49b5, 0x49b5, 0x353c,
0x355c, 0x2d7c, 0x357c, 0x2d9c, 0x2d9d, 0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd,
0x2dfe, 0x2e1d, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e7e,
0x2e7e, 0x2e9e, 0xb928, 0xb927, 0xb928, 0xb928, 0xb908, 0xb908, 0xb908,
0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108, 0xc108,
0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc128, 0xc128, 0xc108, 0xc108,
0xc128, 0xc128, 0xc128, 0xc929, 0xc929, 0xc929, 0xc929, 0xc949, 0xc929,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd129, 0xd129, 0xd12a, 0xd12a,
0xd129, 0xd12a, 0xd12a, 0xd92a, 0xd10a, 0xd10a, 0xd10a, 0xd10a, 0xd0eb,
0xd0ea, 0xd0eb, 0xd0eb, 0xd0eb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab, 0xd0ab,
0xc88b, 0xc88b, 0xc88c, 0x7972, 0x7173, 0x7173, 0x7173, 0x7173, 0x7174,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79d4, 0x79d4, 0x79d5,
0x79d5, 0x79d5, 0x71b5, 0x71b5, 0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71d5,
0x71d5, 0x69d5, 0x69d5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5,
0x59b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x41f5, 0x355c,
0x2d7c, 0x357d, 0x2d9c, 0x2d9d, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd,
0x2dfd, 0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e7e, 0x267e,
0xb927, 0xb928, 0xb928, 0xb928, 0xb928, 0xb928, 0xb928, 0xb928, 0xb928,
0xb908, 0xb908, 0xb908, 0xb908, 0xc108, 0xc108, 0xc108, 0xc108, 0xc108,
0xc128, 0xc128, 0xc128, 0xc128, 0xc929, 0xc108, 0xc108, 0xc128, 0xc128,
0xc928, 0xc928, 0xc929, 0xc929, 0xc929, 0xc949, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd129, 0xd129, 0xd12a, 0xd12a,
0xd12a, 0xd12a, 0xd92a, 0xd92a, 0xd92a, 0xd90a, 0xd10b, 0xd10b, 0xd0eb,
0xd0eb, 0xd0eb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab, 0xd0ab, 0xc88b,
0xc88b, 0xc88c, 0xc86c, 0x7953, 0x7173, 0x7173, 0x7174, 0x7193, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79d4, 0x79b4, 0x79b4, 0x71b4, 0x71b4, 0x71d4,
0x71b5, 0x71b5, 0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x69d5,
0x69d5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x49b5,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4a36, 0x2d7c,
0x2d7c, 0x2d9d, 0x2d9d, 0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2e1d,
0x2e1d, 0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0x2e7e, 0xb947, 0xb928,
0xb928, 0xb927, 0xb927, 0xb928, 0xb908, 0xb928, 0xb928, 0xb928, 0xb928,
0xb928, 0xc108, 0xc128, 0xc108, 0xc108, 0xc108, 0xc128, 0xc128, 0xc128,
0xc128, 0xc929, 0xc929, 0xc928, 0xc128, 0xc128, 0xc128, 0xc929, 0xc929,
0xc929, 0xc929, 0xc929, 0xc949, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd129, 0xd92a, 0xd92a, 0xd92a,
0xd92a, 0xd92a, 0xd92a, 0xd90a, 0xd90b, 0xd90b, 0xd8eb, 0xd0eb, 0xd0eb,
0xd0eb, 0xd0cb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab, 0xd0ac, 0xd0ac, 0xc88b,
0xc88c, 0xc88b, 0x7173, 0x7173, 0x7173, 0x7173, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71d4, 0x71b5, 0x71d5,
0x71b5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x71d5, 0x69d5, 0x69b5, 0x69b5,
0x69d5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4195, 0x4995, 0x4195, 0x4195, 0x3af7, 0x2d7c,
0x2d9d, 0x2d9d, 0x2dbd, 0x2ddd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d,
0x2e3e, 0x2e3e, 0x2e3e, 0x2e5e, 0x2e5e, 0xc147, 0xc147, 0xc147, 0xc147,
0xb928, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128,
0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc929, 0xc929,
0xc929, 0xc929, 0xc128, 0xc128, 0xc128, 0xc929, 0xc929, 0xc929, 0xc929,
0xc949, 0xc949, 0xd149, 0xd129, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd949, 0xd949, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd92a, 0xd92a,
0xd92a, 0xd92a, 0xd92a, 0xd90a, 0xd90b, 0xd90b, 0xd8eb, 0xd0eb, 0xd0eb,
0xd0cb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab, 0xd0ac, 0xc88b, 0xc88b, 0xc88c,
0xc88c, 0x7153, 0x7173, 0x7174, 0x7173, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b5, 0x71b5, 0x71b5, 0x71d5, 0x71d5,
0x71d5, 0x71d5, 0x71d5, 0x69d5, 0x69d5, 0x69b5, 0x69b5, 0x69d5, 0x69b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4995, 0x3bd9, 0x2d9d,
0x2d9d, 0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d,
0x2e3e, 0x2e3e, 0x2e5e, 0xc147, 0xc147, 0xc147, 0xc148, 0xc148, 0xc128,
0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128,
0xc128, 0xc128, 0xc128, 0xc128, 0xc928, 0xc929, 0xc929, 0xc929, 0xc929,
0xc949, 0xc128, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xc929, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd94a,
0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd92a, 0xd92a, 0xd92a,
0xd92a, 0xd92b, 0xd90a, 0xd90b, 0xd90b, 0xd0eb, 0xd0eb, 0xd0eb, 0xd0cb,
0xd0cb, 0xd0cb, 0xd0ab, 0xd0ac, 0xd0ab, 0xc88b, 0xc88b, 0xc88c, 0xc86c,
0xc86c, 0x6954, 0x7174, 0x7193, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x71b4, 0x79b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b5, 0x71b5, 0x71b5, 0x71d5, 0x71b5, 0x71b5, 0x71b5,
0x71b5, 0x69d5, 0x69d5, 0x69b5, 0x69d5, 0x69b5, 0x69b5, 0x69b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x349b, 0x2d9d,
0x2dbd, 0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0x2e3e,
0x2e3e, 0xc167, 0xc167, 0xc147, 0xc148, 0xc148, 0xc148, 0xc148, 0xc148,
0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128, 0xc128,
0xc128, 0xc128, 0xc928, 0xc929, 0xc929, 0xc929, 0xc949, 0xc949, 0xd129,
0xc929, 0xc929, 0xc929, 0xc929, 0xc949, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd949, 0xd949, 0xd94a, 0xd94a,
0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd92a, 0xd92a, 0xd92a,
0xd92b, 0xd90b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd0eb, 0xd8cb, 0xd0cb,
0xd0ab, 0xd0ab, 0xd0ab, 0xd0ab, 0xd08c, 0xc88b, 0xc88c, 0xc86c, 0xd06c,
0x6974, 0x6973, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4, 0x79b4,
0x79b4, 0x79b4, 0x79b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71d4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b5, 0x71b5, 0x71b5, 0x69b5, 0x69d5,
0x69b5, 0x69b5, 0x69d5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x2d1c, 0x2dbd,
0x2dbd, 0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0x2e3e, 0xc167,
0xc168, 0xc148, 0xc148, 0xc148, 0xc147, 0xc148, 0xc148, 0xc148, 0xc148,
0xc148, 0xc148, 0xc128, 0xc128, 0xc148, 0xc928, 0xc928, 0xc928, 0xc929,
0xc948, 0xc929, 0xc948, 0xc949, 0xc949, 0xd149, 0xd149, 0xc929, 0xc929,
0xc929, 0xc949, 0xc949, 0xc929, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd949, 0xd94a, 0xd94a, 0xd949, 0xd949, 0xd96a, 0xd94a, 0xd94a,
0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd92a, 0xd92a, 0xd92a, 0xd92b,
0xd92b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8eb, 0xd8cb, 0xd0cb, 0xd0cb,
0xd0ab, 0xd0ab, 0xd0ac, 0xd08c, 0xd08c, 0xc88c, 0xc86b, 0xc86c, 0x6973,
0x6974, 0x79b4, 0x79b3, 0x79b4, 0x79b4, 0x79b4, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b5, 0x71b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5,
0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x2d9d, 0x2dbd,
0x2ddd, 0x2ddd, 0x2dfd, 0x2dfd, 0x2e1d, 0x2e1d, 0xc167, 0xc167, 0xc167,
0xc168, 0xc168, 0xc168, 0xc148, 0xc148, 0xc148, 0xc148, 0xc948, 0xc148,
0xc148, 0xc148, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc949,
0xc949, 0xc949, 0xd149, 0xd149, 0xd149, 0xd149, 0xc929, 0xc929, 0xc949,
0xc929, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd169, 0xd149, 0xd949,
0xd949, 0xd949, 0xd949, 0xd96a, 0xd96a, 0xd96a, 0xd94a, 0xd94a, 0xd94a,
0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd94b, 0xd92a, 0xd92a, 0xd92b, 0xd90b,
0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8eb, 0xd8cb, 0xd0cb, 0xd0cb, 0xd0ab,
0xd0ab, 0xd0ac, 0xd08c, 0xd08c, 0xd08c, 0xc88c, 0xc86c, 0xd04c, 0x71b4,
0x79b3, 0x79b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b5, 0x71b4, 0x71b4,
0x69b4, 0x69b4, 0x69b4, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5,
0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x4195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x41b6, 0x2d7c, 0x2ddd,
0x2ddd, 0x2ddd, 0x2dfd, 0x2e1d, 0xc987, 0xc167, 0xc967, 0xc168, 0xc167,
0xc968, 0xc968, 0xc968, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948,
0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc949, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xc929, 0xc949, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd949, 0xd949,
0xd949, 0xd96a, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xd94a,
0xe14a, 0xe14a, 0xe14a, 0xd94b, 0xe12b, 0xe12b, 0xd92b, 0xd90b, 0xd90b,
0xd90b, 0xd8eb, 0xd8eb, 0xd8eb, 0xd8cb, 0xd0cb, 0xd0cb, 0xd0ab, 0xd0ab,
0xd0ab, 0xd08c, 0xd08c, 0xc88c, 0xc88c, 0xc86c, 0xc86c, 0x69d4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x61b5,
0x61d5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x2ddd, 0x2ddd,
0x2ddd, 0x2dfd, 0xc987, 0xc987, 0xc967, 0xc967, 0xc967, 0xc968, 0xc968,
0xc968, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948,
0xc948, 0xc948, 0xc948, 0xc948, 0xc949, 0xd148, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xc929, 0xc949, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd949, 0xd949, 0xd949, 0xd949, 0xd949, 0xd96a,
0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14a, 0xe14a, 0xe14a,
0xe14b, 0xe14b, 0xe14b, 0xe12b, 0xe12b, 0xe10b, 0xd90b, 0xd90b, 0xd90b,
0xd8eb, 0xd8eb, 0xd8eb, 0xd8cb, 0xd8cb, 0xd0cb, 0xd0ab, 0xd0ac, 0xd0ac,
0xd08c, 0xd08c, 0xd08c, 0xc86c, 0xc86c, 0xc88b, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x69b4, 0x71b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b5, 0x69b5,
0x69b5, 0x69b5, 0x69b5, 0x61b5, 0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x5195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4175, 0x2dfd, 0x2ddd,
0xc987, 0xc987, 0xc987, 0xc987, 0xc987, 0xc967, 0xc967, 0xc968, 0xc968,
0xc968, 0xc968, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948, 0xc948,
0xc948, 0xc948, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xc929, 0xc929, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd949, 0xd949, 0xd949, 0xd969, 0xd949, 0xd96a, 0xd96a, 0xd96a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14a, 0xe14a,
0xe14a, 0xe12b, 0xe14b, 0xe12b, 0xe10b, 0xd92b, 0xd90b, 0xd90b, 0xd90b,
0xd8eb, 0xd8eb, 0xd8cb, 0xd8cb, 0xd0cb, 0xd0ab, 0xd0ac, 0xd0ac, 0xd08c,
0xd08c, 0xd08c, 0xc86c, 0xc86c, 0xa92f, 0xb10f, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b5, 0x69b5, 0x69b5, 0x69b5,
0x69b5, 0x61b5, 0x61b5, 0x61b5, 0x61d5, 0x61b5, 0x61b5, 0x61b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4196, 0xc987, 0xc987,
0xc987, 0xc987, 0xc987, 0xc987, 0xc968, 0xc968, 0xc968, 0xc968, 0xc968,
0xc968, 0xc968, 0xc968, 0xc968, 0xc968, 0xc968, 0xc968, 0xc968, 0xd168,
0xd168, 0xd148, 0xd148, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd949,
0xd94a, 0xd949, 0xd96a, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14b, 0xe14b,
0xe12b, 0xe12b, 0xe12b, 0xe12b, 0xe10b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb,
0xd8eb, 0xd8cb, 0xd8cb, 0xd0cb, 0xd0ab, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c,
0xd08c, 0xc86c, 0xc86c, 0xb10f, 0xb10f, 0x71b4, 0x71b4, 0x7194, 0x71b4,
0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xc9a7, 0xc9a7, 0xc987, 0xc9a8,
0xc987, 0xc988, 0xc987, 0xc987, 0xc988, 0xc968, 0xc968, 0xc968, 0xc968,
0xc968, 0xc968, 0xd168, 0xc968, 0xc968, 0xd168, 0xd168, 0xd169, 0xd169,
0xd169, 0xd169, 0xd149, 0xd169, 0xd149, 0xd169, 0xd169, 0xd949, 0xd149,
0xd149, 0xd149, 0xd149, 0xd149, 0xd149, 0xd949, 0xd949, 0xd94a, 0xd949,
0xd96a, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14a, 0xe14b, 0xe14b, 0xe12b,
0xe14b, 0xe12b, 0xe12b, 0xe10b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8eb,
0xd8cc, 0xd8cb, 0xd0cb, 0xd0ab, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xd08c,
0xd08c, 0xc86c, 0xb10f, 0xb10f, 0x71b4, 0x7194, 0x71b4, 0x71b4, 0x71b4,
0x71b4, 0x71b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x61b4, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xd1a7, 0xc9a7, 0xc987, 0xc987, 0xd1a8, 0xc988,
0xc988, 0xc988, 0xc988, 0xc968, 0xc968, 0xc968, 0xc968, 0xc968, 0xd168,
0xd168, 0xd168, 0xd168, 0xd168, 0xd168, 0xd168, 0xd168, 0xd169, 0xd169,
0xd169, 0xd169, 0xd169, 0xd169, 0xd169, 0xd969, 0xd969, 0xd149, 0xd149,
0xd149, 0xd149, 0xd149, 0xd949, 0xd949, 0xd94a, 0xd94a, 0xd96a, 0xd96a,
0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14b, 0xe14b, 0xe14b, 0xe14b, 0xe12b,
0xe12b, 0xe12b, 0xe10b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8eb, 0xd8cc,
0xd8cb, 0xd8cb, 0xd0ab, 0xd0ac, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xd08c,
0xa92f, 0xb10f, 0xb10f, 0xa90f, 0x71b4, 0x71b4, 0x71b4, 0x71b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x61b4, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xfca6, 0xd1c7, 0xd1a7, 0xd1a7, 0xd1a7, 0xd1a7, 0xd1a7, 0xc988,
0xc988, 0xd188, 0xd188, 0xc988, 0xc988, 0xd188, 0xd168, 0xd168, 0xd168,
0xd168, 0xd168, 0xd168, 0xd168, 0xd169, 0xd169, 0xd169, 0xd169, 0xd169,
0xd969, 0xd969, 0xd969, 0xd969, 0xd969, 0xd949, 0xd149, 0xd149, 0xd149,
0xd149, 0xd949, 0xd94a, 0xd94a, 0xd94a, 0xd94a, 0xd96a, 0xd96a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe14a, 0xe16a, 0xe16a, 0xe16b, 0xe14b, 0xe14b, 0xe14b, 0xe12b, 0xe12b,
0xe12b, 0xe12b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8eb, 0xd8cc, 0xd8cb,
0xd8cb, 0xd0ac, 0xd0ac, 0xd0ac, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xb12f,
0xb10f, 0xb10f, 0xb10f, 0x7194, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x61b4, 0x61b5,
0x61b5, 0x61b4, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xfca6,
0xfca6, 0xd1a7, 0xd1a7, 0xd1a7, 0xd1a8, 0xd1a8, 0xd1a8, 0xd188, 0xd188,
0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188,
0xd168, 0xd168, 0xd189, 0xd169, 0xd169, 0xd969, 0xd969, 0xd969, 0xd969,
0xd969, 0xd969, 0xd969, 0xd969, 0xd149, 0xd149, 0xd149, 0xd949, 0xd949,
0xd94a, 0xd94a, 0xd94a, 0xd96a, 0xd94a, 0xd96a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe96b, 0xe16b, 0xe14b, 0xe14b, 0xe14b, 0xe14b, 0xe12b, 0xe12b, 0xe12b,
0xe10b, 0xd90b, 0xd90b, 0xd8eb, 0xd8eb, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cb,
0xd0cb, 0xd0ac, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xc88d, 0xb12f, 0xb10f,
0xb10f, 0xb10f, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x6994, 0x61b4, 0x61b4, 0x61b5, 0x61b4,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x4995, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xfca6, 0xfca6, 0xf4c5,
0xd1c7, 0xd1a7, 0xd1a7, 0xd1a7, 0xd1a8, 0xd1a8, 0xd1a8, 0xd188, 0xd1a8,
0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188,
0xd189, 0xd989, 0xd169, 0xd989, 0xd969, 0xd969, 0xd969, 0xd969, 0xd969,
0xd969, 0xd969, 0xd969, 0xd169, 0xd149, 0xd149, 0xd949, 0xd94a, 0xd94a,
0xd96a, 0xd96a, 0xd94a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe98a, 0xe96a, 0xe96a, 0xe96b,
0xe16b, 0xe14b, 0xe94b, 0xe94b, 0xe14b, 0xe12b, 0xe12b, 0xe12b, 0xe10b,
0xe10b, 0xe10b, 0xd90b, 0xd8eb, 0xd8ec, 0xd8ec, 0xd8cb, 0xd8cb, 0xd0ac,
0xd0ac, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xb12f, 0xb12f, 0xb10f, 0xb10f,
0xb0ef, 0xa90f, 0x69b4, 0x6994, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x69b4,
0x69b4, 0x69b4, 0x61b4, 0x61b4, 0x61b4, 0x61b4, 0x61b4, 0x61b5, 0x61b5,
0x61b5, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xfca6, 0xfca6, 0xfca6, 0xf4a6, 0xd1c7,
0xd1c7, 0xd1c8, 0xd1c8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd188, 0xd188, 0xd188,
0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd188, 0xd989,
0xd989, 0xd989, 0xd989, 0xd969, 0xd969, 0xd969, 0xd969, 0xd969, 0xd969,
0xd96a, 0xd949, 0xd149, 0xd949, 0xd949, 0xd96a, 0xd94a, 0xd96a, 0xd949,
0xd94a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96a, 0xe96a, 0xe96b, 0xe16b,
0xe14b, 0xe94b, 0xe94b, 0xe12b, 0xe12b, 0xe12b, 0xe12b, 0xe12b, 0xe12b,
0xd90b, 0xd90b, 0xd8eb, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac,
0xd0ac, 0xd0ac, 0xd08c, 0xd08c, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef,
0xb0ef, 0x69b4, 0x69b4, 0x69b4, 0x69b4, 0x6994, 0x69b4, 0x69b4, 0x69b4,
0x61b4, 0x61b4, 0x61b4, 0x61b4, 0x61b4, 0x61b5, 0x61b5, 0x61b5, 0x61b5,
0x61b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x51b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0xfca6, 0xfca6, 0xfca6, 0xfcc6, 0xfc86, 0xd1c7, 0xd1a7,
0xd1a8, 0xd1a8, 0xd1a7, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd188,
0xd188, 0xd188, 0xd988, 0xd988, 0xd988, 0xd989, 0xd989, 0xd989, 0xd989,
0xd989, 0xd989, 0xd989, 0xd989, 0xd969, 0xd969, 0xd969, 0xd969, 0xe169,
0xd149, 0xd949, 0xd94a, 0xd96a, 0xd94a, 0xd94a, 0xd94a, 0xd96a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe96b, 0xe96a, 0xe96b, 0xe96b, 0xe96a, 0xe96b, 0xe96b, 0xe16b, 0xe94b,
0xe94b, 0xe94b, 0xe14b, 0xe14b, 0xe12b, 0xe12b, 0xe10b, 0xe10b, 0xd90b,
0xd90b, 0xd8eb, 0xd8eb, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac,
0xd08c, 0xd08c, 0xc0cd, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef,
0x6994, 0x69b4, 0x69b4, 0x6994, 0x69b4, 0x69b4, 0x69b4, 0x61b4, 0x61b4,
0x61b4, 0x6194, 0x61b4, 0x61b5, 0x61b5, 0x61b5, 0x59b5, 0x61b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195,
0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0xfca6, 0xfca6, 0xfca6, 0xfcc6, 0xfcc6, 0xf3c5, 0xd1c7, 0xd1c7, 0xd1c7,
0xd1c8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8,
0xd988, 0xd988, 0xd988, 0xd988, 0xd989, 0xd989, 0xd989, 0xd989, 0xd989,
0xd989, 0xd989, 0xd989, 0xd989, 0xd989, 0xe169, 0xe169, 0xe169, 0xd949,
0xd949, 0xd96a, 0xd94a, 0xd94a, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96a, 0xe96a,
0xe96a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe14b, 0xe14b, 0xe12b, 0xe12b, 0xe10b, 0xe10b, 0xe10b, 0xd90b,
0xe0ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac, 0xd08c,
0xd08c, 0xb12f, 0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef, 0xa910,
0x6994, 0x6994, 0x6994, 0x69b4, 0x61b4, 0x6194, 0x61b4, 0x61b4, 0x6194,
0x61b4, 0x61b5, 0x61b5, 0x61b4, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x5195, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x41b5, 0x41b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xfca6, 0xfca6,
0xf4a6, 0xfcc6, 0xfcc6, 0xfcc6, 0xda68, 0xd1c7, 0xd1c7, 0xd1c7, 0xd1c7,
0xd1a8, 0xd1a8, 0xd1a8, 0xd1a8, 0xd9a8, 0xd1a8, 0xd1a8, 0xd9a8, 0xd9a8,
0xd9a8, 0xd9a9, 0xd988, 0xd988, 0xd989, 0xd989, 0xd989, 0xd989, 0xd989,
0xd989, 0xe189, 0xe189, 0xe189, 0xe189, 0xe18a, 0xd96a, 0xd969, 0xd949,
0xd949, 0xd96a, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96a, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b,
0xe14b, 0xe12b, 0xe12b, 0xe12b, 0xe10b, 0xe10b, 0xe10b, 0xe0eb, 0xd8eb,
0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac, 0xd08c, 0xd08c,
0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef, 0xb0ef, 0x6994,
0x69b4, 0x69b4, 0x6194, 0x6194, 0x6194, 0x61b4, 0x61b4, 0x61b4, 0x6194,
0x61b5, 0x61b4, 0x59b4, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5, 0x59b5,
0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x51b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x41b5, 0x41b5, 0x41b5, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xfca6, 0xfca6, 0xfcc6, 0xfcc6,
0xfcc6, 0xfcc6, 0xfcc6, 0xd9e7, 0xd1c7, 0xd1c7, 0xd1c7, 0xd9c8, 0xd9c8,
0xd9c8, 0xd1a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8,
0xd9a8, 0xd9a9, 0xd989, 0xd989, 0xd9a9, 0xd989, 0xd989, 0xd989, 0xe189,
0xe189, 0xe189, 0xe189, 0xe18a, 0xe18a, 0xd969, 0xd969, 0xd949, 0xd96a,
0xd96a, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe14b,
0xe12b, 0xe12b, 0xe12c, 0xe12b, 0xe10b, 0xe10b, 0xe10b, 0xd8eb, 0xd8ec,
0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac, 0xd0ac, 0xb90e, 0xb12f,
0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef, 0xb0ee, 0x61b4, 0x6194,
0x6194, 0x6194, 0x6194, 0x61b4, 0x6194, 0x61b4, 0x6194, 0x61b4, 0x59b4,
0x59b4, 0x59b5, 0x59b4, 0x59b4, 0x59b5, 0x59b5, 0x5995, 0x59b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195,
0x4195, 0x41b5, 0x41b5, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xf4a5, 0xfca6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6,
0xf4c6, 0xfce5, 0xd9c8, 0xd1c7, 0xd9c7, 0xd9c7, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8,
0xd9a8, 0xd9a9, 0xd9a9, 0xd989, 0xd989, 0xe1a9, 0xe189, 0xe189, 0xe189,
0xe189, 0xe18a, 0xe189, 0xe18a, 0xd969, 0xd969, 0xd96a, 0xd96a, 0xd96a,
0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe96a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe92b, 0xe92b,
0xe12b, 0xe10b, 0xe10b, 0xe10b, 0xe10c, 0xe10b, 0xe0ec, 0xd8ec, 0xd8ec,
0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac, 0xd0ac, 0xb12f, 0xb12f, 0xb12f,
0xb10f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef, 0xb0ee, 0x9131, 0x6194, 0x6194,
0x6194, 0x6194, 0x6194, 0x6194, 0x61b4, 0x5994, 0x5994, 0x59b4, 0x59b4,
0x59b4, 0x59b5, 0x59b5, 0x59b5, 0x51b5, 0x51b5, 0x51b5, 0x5195, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x4195, 0x41b5, 0x41b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xf4a5, 0xf4a6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6,
0xfce6, 0xd9c8, 0xd9c7, 0xd9c7, 0xd9c7, 0xd9c7, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9c8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a8,
0xd989, 0xe1a9, 0xd989, 0xe189, 0xe189, 0xe189, 0xe189, 0xe189, 0xe189,
0xe189, 0xe18a, 0xd969, 0xd969, 0xd96a, 0xd96a, 0xd96a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96a,
0xe96a, 0xe96a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe92b, 0xe12b,
0xe10b, 0xe10b, 0xe10b, 0xe10c, 0xe10b, 0xd8eb, 0xd8ec, 0xd8cc, 0xd8cc,
0xd8cc, 0xd8cc, 0xd0ac, 0xd0ac, 0xd0ac, 0xb12f, 0xb12f, 0xb12f, 0xb10f,
0xb10f, 0xb10f, 0xb0ef, 0xb0ef, 0xb0ef, 0xb8ce, 0x6194, 0x6194, 0x6194,
0x6194, 0x6194, 0x5994, 0x5994, 0x5994, 0x5994, 0x59b4, 0x59b4, 0x5994,
0x5995, 0x59b5, 0x51b5, 0x51b5, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x4195, 0x4195, 0x4195, 0x41b5, 0x41b5, 0x41b5, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xf485,
0xf4a5, 0xf4a6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfcc6, 0xfce6, 0xfce6,
0xd9e7, 0xd9e8, 0xd9c7, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9c8, 0xd9c8, 0xd9a8, 0xd9a8, 0xd9a8, 0xd9a9, 0xd9a9, 0xd9a9, 0xe1a9,
0xe1a9, 0xe189, 0xe189, 0xe189, 0xe189, 0xe189, 0xe189, 0xe18a, 0xe18a,
0xe18a, 0xd969, 0xd969, 0xd96a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96a, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe92b, 0xe12b, 0xe12b,
0xe12b, 0xe10b, 0xe10c, 0xe10c, 0xe0ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc,
0xd8cc, 0xd0ac, 0xd0ac, 0xb14f, 0xb12f, 0xb12f, 0xb12f, 0xb10f, 0xb10f,
0xb10f, 0xb0ef, 0xb0ef, 0xb0ef, 0xb0cf, 0x61b4, 0x6194, 0x6194, 0x6194,
0x6194, 0x5994, 0x5994, 0x5994, 0x59b4, 0x59b4, 0x5994, 0x5995, 0x59b5,
0x5995, 0x51b5, 0x51b5, 0x5195, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5,
0x49b5, 0x49b5, 0x4995, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4195, 0x4195,
0x4195, 0x41b5, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xf485, 0xf485, 0xf4a6,
0xfcc6, 0xfcc6, 0xf4c6, 0xfcc6, 0xfcc6, 0xfce6, 0xfce6, 0xfce6, 0xd9e7,
0xd9e8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9c8, 0xd9c8, 0xd9c8, 0xd9a9, 0xd9a9, 0xd9a9, 0xd9a9, 0xe1a9, 0xe1a9,
0xe189, 0xe1a9, 0xe189, 0xe189, 0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xd969, 0xd96a, 0xd969, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe92b, 0xe12b, 0xe12c, 0xe10b,
0xe10b, 0xe10c, 0xe10c, 0xe0ec, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc,
0xd0ac, 0xd0ac, 0xb12f, 0xb12f, 0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb10f,
0xb0ef, 0xb0ef, 0xb0ef, 0xb8ce, 0x8172, 0x6194, 0x6194, 0x6194, 0x5994,
0x5994, 0x5994, 0x5994, 0x5994, 0x5994, 0x5995, 0x5994, 0x51b5, 0x5195,
0x51b5, 0x5195, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5,
0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4995, 0x4195, 0x4195, 0x41b5, 0x41b5,
0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xf465, 0xf485, 0xf4a5, 0xf4a6, 0xfcc6,
0xf4c6, 0xfcc6, 0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xd1e8, 0xd9e7,
0xd9e8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9c8, 0xd9a9, 0xd9a9, 0xd9a9, 0xd9a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9,
0xe1a9, 0xe1a9, 0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xd969, 0xd969,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b,
0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe92b, 0xe12b, 0xe12c, 0xe10c, 0xe10b,
0xe10c, 0xe10c, 0xe0ec, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac,
0xd8ac, 0xb12f, 0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef,
0xb0ef, 0xb8ce, 0xb0ce, 0xb0ce, 0x6194, 0x5994, 0x5994, 0x5994, 0x5994,
0x5994, 0x5994, 0x5994, 0x5995, 0x5994, 0x5194, 0x5195, 0x51b5, 0x51b5,
0x5195, 0x5195, 0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x49b5, 0x4995, 0x49b5, 0x4195, 0x4195, 0x41b5, 0x41b5, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0xf465, 0xf485, 0xf485, 0xf4a5, 0xfcc6, 0xf4c6, 0xfcc6,
0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xd9e7, 0xd9e7, 0xd9c8,
0xd9c8, 0xd9e8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8,
0xd9c8, 0xe1c8, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9,
0xe1a9, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xd989, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b,
0xe94b, 0xe92b, 0xe92b, 0xe92c, 0xe12c, 0xe12c, 0xe10c, 0xe10b, 0xe10c,
0xe0ec, 0xe0ec, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0ac, 0xb14f,
0xb14f, 0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb10f, 0xb0ef, 0xb0ef,
0xb8ce, 0xb8ce, 0xb8ce, 0x6174, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994,
0x5994, 0x5994, 0x5994, 0x5194, 0x5195, 0x51b5, 0x5195, 0x51b5, 0x5195,
0x51b5, 0x51b5, 0x51b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5,
0x4195, 0x4195, 0x4195, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0xf444, 0xf465, 0xf485, 0xf485, 0xf4a6, 0xf4c6, 0xf4c6, 0xfce6, 0xfce6,
0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xf506, 0xd9e8, 0xd9e8, 0xd9e8, 0xd9e8,
0xd9e8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xd9c8, 0xe1c8, 0xe1c8, 0xe1c8,
0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa,
0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xd96a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe14a, 0xe16a, 0xe16b, 0xe16b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b,
0xe94b, 0xe94c, 0xe92c, 0xe12c, 0xe12c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec,
0xe0ec, 0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd8ac, 0xb14f, 0xb14f,
0xb12f, 0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb8ef, 0xb0ef, 0xb8ee, 0xb8ce,
0xb8ce, 0xb8ce, 0x7172, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994,
0x5994, 0x5194, 0x5195, 0x5195, 0x5195, 0x5195, 0x51b5, 0x51b5, 0x5195,
0x4995, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x49b5, 0x4995, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xec44, 0xf444,
0xf465, 0xf485, 0xf485, 0xf4a6, 0xf4c6, 0xfce6, 0xfce6, 0xfce6, 0xfce6,
0xfce6, 0xfce6, 0xfd06, 0xfce7, 0xd9e8, 0xd9e8, 0xd9e8, 0xd9e8, 0xd9c8,
0xd9c8, 0xd9c8, 0xd9c8, 0xe1c8, 0xe1c8, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1c9,
0xe1c9, 0xe1a9, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa,
0xe1aa, 0xe9aa, 0xe98a, 0xe169, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe92c, 0xe12c, 0xe12c, 0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec,
0xd8ec, 0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xd0cd, 0xb14f, 0xb14f, 0xb12f,
0xb12f, 0xb10f, 0xb10f, 0xb10f, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce,
0xb8ce, 0xb8cd, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994, 0x5994,
0x5194, 0x5195, 0x5195, 0x5195, 0x5195, 0x51b5, 0x5195, 0x4995, 0x49b5,
0x49b5, 0x4995, 0x4995, 0x49b5, 0x4995, 0x4195, 0x4195, 0x41b5, 0x41b5,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xec24, 0xf445, 0xf465, 0xf485,
0xf485, 0xf4a5, 0xf4c6, 0xf4c6, 0xfce6, 0xfce6, 0xfce6, 0xfce6, 0xfd06,
0xfd06, 0xfd06, 0xf486, 0xda07, 0xd9e8, 0xd9e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1c8, 0xe1c8, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9,
0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe9aa,
0xe9aa, 0xe98a, 0xe169, 0xe16a, 0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16b, 0xe16b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96c, 0xe94b, 0xe94b, 0xe94c, 0xe94b, 0xe94b, 0xe94c,
0xe92c, 0xe12c, 0xe12c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xe0ec,
0xd8ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xb930, 0xb12f, 0xb12f, 0xb12f, 0xb12f,
0xb10f, 0xb10f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ee, 0xb8ce, 0xb0ce,
0xb8ae, 0x5994, 0x5994, 0x5994, 0x5994, 0x5194, 0x5194, 0x5195, 0x5194,
0x5195, 0x5195, 0x5195, 0x5195, 0x5195, 0x4995, 0x4995, 0x49b5, 0x4995,
0x4995, 0x49b5, 0x49b5, 0x4195, 0x4195, 0x41b5, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xec24, 0xec24, 0xf444, 0xf465, 0xf485, 0xf4a5,
0xf4a5, 0xf4c6, 0xf4e6, 0xfce6, 0xfce6, 0xfce6, 0xfd06, 0xfd06, 0xfd06,
0xfd06, 0xe327, 0xd9e7, 0xd9e8, 0xd9e8, 0xd9e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1c8, 0xe1c8, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1a9, 0xe1a9,
0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe9aa, 0xe9aa, 0xe9aa, 0xe98a,
0xe18a, 0xd98a, 0xe18a, 0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16a, 0xe16a, 0xe96b, 0xe16b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96c, 0xe96c, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94b, 0xe94c, 0xe92c,
0xe12c, 0xe12c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xd8ec, 0xd8ec,
0xd8cc, 0xd8cc, 0xd8cc, 0xb150, 0xb14f, 0xb12f, 0xb92f, 0xb92f, 0xb92f,
0xb10f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae,
0x6973, 0x5994, 0x5994, 0x5194, 0x5194, 0x5194, 0x5195, 0x5195, 0x5194,
0x5195, 0x5195, 0x5195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x49b5, 0x49b5, 0x4195, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xec04, 0xec24, 0xf444, 0xec64, 0xf465, 0xf485, 0xf4a5, 0xf4c6,
0xf4c6, 0xfce6, 0xfce6, 0xfce6, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd06,
0xe208, 0xd9e7, 0xd9e8, 0xd9e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1c8, 0xe1c8, 0xe1c8, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1a9, 0xe1c9, 0xe1c9,
0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe98a, 0xe9aa, 0xe18a,
0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96c, 0xe96c, 0xe96c,
0xe96c, 0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe92b, 0xe94c, 0xe92c, 0xe12c,
0xe12c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xd8ec, 0xd8cc, 0xd8cc,
0xd8cc, 0xc8ee, 0xb14f, 0xb14f, 0xb12f, 0xb92f, 0xb92f, 0xb92f, 0xb90f,
0xb90f, 0xb8ef, 0xb8ef, 0xb8ef, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb0cf,
0x5994, 0x5994, 0x5194, 0x5194, 0x5195, 0x5194, 0x5194, 0x5195, 0x5195,
0x49b5, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195,
0x4195, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xebe3,
0xec04, 0xec24, 0xec44, 0xf465, 0xf465, 0xf485, 0xf4a5, 0xf4c6, 0xf4c6,
0xfce6, 0xfce6, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xd9e7,
0xe208, 0xd9e7, 0xd9e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1c8, 0xe1c9, 0xe1c8, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1a9,
0xe1a9, 0xe9a9, 0xe1a9, 0xe9aa, 0xe9aa, 0xe9aa, 0xe9aa, 0xe18a, 0xe18a,
0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16b, 0xe96b, 0xe96b,
0xe96b, 0xe16b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96c, 0xe96c, 0xe96b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe12c,
0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xd8cc, 0xd8cc, 0xd8cc,
0xb150, 0xb14f, 0xb14f, 0xb12f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f,
0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0x5993,
0x5194, 0x5194, 0x5194, 0x5194, 0x5194, 0x5195, 0x5195, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x41b5,
0x4196, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xebe3, 0xec03, 0xec04,
0xec24, 0xf444, 0xf465, 0xf485, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xfce6,
0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd26, 0xe207, 0xe208,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1c9,
0xe1c9, 0xe1c8, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1a9, 0xe1a9,
0xe9a9, 0xe9aa, 0xe9a9, 0xe9aa, 0xe9aa, 0xe18a, 0xe18a, 0xe18a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe18a, 0xe16a, 0xe16a, 0xe16b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96c, 0xe96c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe10c, 0xe10c,
0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xe0ec, 0xd8cc, 0xd8cc, 0xd8cc, 0xb950,
0xb14f, 0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef,
0xb8ef, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0x51b3, 0x5194,
0x5194, 0x5194, 0x5194, 0x5195, 0x5195, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x41b5, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xe3c3, 0xebe3, 0xec04, 0xec04, 0xec24,
0xf444, 0xf465, 0xf485, 0xf4a5, 0xf4a6, 0xf4c6, 0xfce6, 0xf4e6, 0xfd06,
0xfd06, 0xfd06, 0xfd06, 0xfd06, 0xfd26, 0xfd26, 0xe207, 0xe208, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1c8,
0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9a9,
0xe9aa, 0xe9aa, 0xe9aa, 0xe9aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16b, 0xe16b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96c, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe96c, 0xe94c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe10c, 0xe10c, 0xe10c,
0xe10c, 0xe0ec, 0xe0ec, 0xe0ec, 0xe0ec, 0xd8cc, 0xb92f, 0xb950, 0xb950,
0xb12f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ef,
0xb8ef, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb0ce, 0x5194, 0x5194,
0x5194, 0x5194, 0x5195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995,
0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0xe3a3, 0xe3c3, 0xebe3, 0xec04, 0xec24, 0xec44, 0xec64,
0xf465, 0xf485, 0xf4a5, 0xf4c6, 0xf4c6, 0xfce6, 0xfd06, 0xfd06, 0xfd06,
0xfd06, 0xfd26, 0xfd26, 0xfd26, 0xfd27, 0xe207, 0xe208, 0xe208, 0xe208,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1c9,
0xe1c9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9a9, 0xe9a9,
0xe9aa, 0xe9aa, 0xe9aa, 0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a,
0xe16a, 0xe16a, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b,
0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe96c, 0xe96c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe10c, 0xe10c, 0xe10c, 0xe10c,
0xe0ec, 0xe0ec, 0xe0ec, 0xd8cc, 0xd8cc, 0xb150, 0xb950, 0xb94f, 0xb92f,
0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ef, 0xb8ef,
0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb0ae, 0x5994, 0x5194, 0x5194,
0x5195, 0x4995, 0x4994, 0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0xe3a3, 0xe3a3, 0xebc3, 0xebe3, 0xec04, 0xec24, 0xec44, 0xec64, 0xf465,
0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xf4e6, 0xfd06, 0xfd06, 0xfd06, 0xfd26,
0xfd26, 0xfd26, 0xfd27, 0xfd46, 0xe208, 0xe207, 0xe207, 0xe208, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1c9, 0xe1c9, 0xe1e9,
0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9a9, 0xe9aa, 0xe9aa,
0xe9aa, 0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a,
0xe16a, 0xe96a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b,
0xe94b, 0xe94b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec,
0xe0ec, 0xe0ec, 0xd8cc, 0xd8cc, 0xb950, 0xb950, 0xb94f, 0xb92f, 0xb92f,
0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ef, 0xb8cf, 0xb8ce,
0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb8ae, 0x5194, 0x5194, 0x5195, 0x4994,
0x4995, 0x4994, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xe3a3, 0xe3a3,
0xe3c3, 0xebc3, 0xebe3, 0xec04, 0xec24, 0xec44, 0xf465, 0xf485, 0xf4a5,
0xf4a5, 0xf4c6, 0xfce6, 0xfd06, 0xfd06, 0xfd06, 0xfd26, 0xfd26, 0xfd26,
0xfd27, 0xfd26, 0xfd27, 0xe208, 0xe207, 0xe208, 0xe208, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1c9,
0xe1c9, 0xe9c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9aa, 0xe9aa, 0xe9aa,
0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe16b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b,
0xe94b, 0xe94b, 0xe94b, 0xe96b, 0xe96b, 0xe94b, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe94c,
0xe92c, 0xe92c, 0xe92c, 0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec,
0xe0ec, 0xe0ec, 0xb16f, 0xb950, 0xb950, 0xb94f, 0xb92f, 0xb92f, 0xb92f,
0xb90f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce,
0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb0af, 0x4994, 0x4994, 0x4994, 0x4994,
0x4995, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4995, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x41b5, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xe3a3, 0xe3c3, 0xe3c3, 0xe3c3,
0xebc3, 0xebe3, 0xec04, 0xec24, 0xec44, 0xf465, 0xf485, 0xf4a5, 0xf4c6,
0xf4c6, 0xf506, 0xfd06, 0xfd06, 0xfd26, 0xfd26, 0xfd26, 0xfd27, 0xfd26,
0xfd26, 0xfd27, 0xe207, 0xe208, 0xe207, 0xe208, 0xe208, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1c9, 0xe1c9,
0xe9c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9a9, 0xe9aa, 0xe9aa, 0xe9aa, 0xe18a,
0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a, 0xe16a, 0xe16a, 0xe16a, 0xe16a,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe94b, 0xe96b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe94c, 0xe92c,
0xe92c, 0xe92c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe10c, 0xe0ec, 0xe0ec,
0xd8cc, 0xb950, 0xb950, 0xb950, 0xb92f, 0xb94f, 0xb92f, 0xb92f, 0xb90f,
0xb90f, 0xb90f, 0xb8ef, 0xb8ee, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae,
0xb8ae, 0xb8ae, 0xb88e, 0xb88e, 0x5194, 0x4994, 0x4994, 0x4995, 0x4994,
0x4994, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xe3a3, 0xe3a3, 0xe3c3, 0xe3c3, 0xebc3, 0xebe3,
0xec04, 0xec24, 0xec24, 0xec44, 0xf465, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6,
0xfd06, 0xfd06, 0xfd26, 0xfd26, 0xfd26, 0xfd27, 0xfd26, 0xfd26, 0xfd47,
0xfd47, 0xe207, 0xe208, 0xe207, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9,
0xe9c9, 0xe9a9, 0xe9a9, 0xe9a9, 0xe9aa, 0xe9aa, 0xe1aa, 0xe18a, 0xe18a,
0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a, 0xe16a, 0xe16b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94b,
0xe94c, 0xe94c, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xd8ec,
0xb970, 0xb950, 0xb950, 0xb94f, 0xb94f, 0xb92f, 0xb92f, 0xb90f, 0xb90f,
0xb90f, 0xb8ef, 0xb8ee, 0xb8ee, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae,
0xb8ae, 0xb88e, 0xb88d, 0x4994, 0x4994, 0x4994, 0x4994, 0x4994, 0x4994,
0x4995, 0x4195, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x41b5, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xe363, 0xe3a3, 0xe3a3, 0xe3c3, 0xe3c3, 0xe3e3, 0xebe3, 0xec04,
0xec24, 0xec44, 0xec64, 0xf465, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xfd06,
0xfd06, 0xfd26, 0xfd26, 0xfd27, 0xfd26, 0xfd26, 0xfd47, 0xfd47, 0xfd27,
0xe207, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1e9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9,
0xe9a9, 0xe9a9, 0xe9a9, 0xe9aa, 0xe9aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe18a, 0xe18a, 0xe16a, 0xe16a, 0xe16b, 0xe96b, 0xe96b, 0xe16b,
0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe10c, 0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xe0ec, 0xe0ec, 0xb970, 0xb970,
0xb950, 0xb950, 0xb950, 0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f,
0xb8ef, 0xb8ee, 0xb8ee, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae,
0xb88e, 0xb88e, 0xb88e, 0x4994, 0x4994, 0x4994, 0x4994, 0x4995, 0x4995,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xa0a9,
0xa0a9, 0xe3a2, 0xe3a3, 0xe3c3, 0xe3c3, 0xebc3, 0xebe3, 0xec04, 0xec24,
0xec44, 0xec64, 0xf465, 0xf485, 0xf4c6, 0xf4c6, 0xf4e6, 0xf506, 0xfd26,
0xfd27, 0xfd27, 0xfd26, 0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xf407, 0xe207,
0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8,
0xe1e8, 0xe1e8, 0xe1e9, 0xe1e9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9a9,
0xe9a9, 0xe9a9, 0xe9aa, 0xe9aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe18a, 0xe96b, 0xe16a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94b, 0xe94b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe10c,
0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xe0ec, 0xe0ec, 0xb970, 0xb950, 0xb950,
0xb950, 0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb8ef,
0xb8ee, 0xb8ee, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb88e,
0xb88e, 0xc06e, 0x5194, 0x4994, 0x4994, 0x4994, 0x4995, 0x4995, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xa0a9, 0xa0a9, 0xa0a9,
0xe3a3, 0xe3a3, 0xe3a3, 0xe3c3, 0xe3c3, 0xebe3, 0xec04, 0xec24, 0xec44,
0xf465, 0xf485, 0xf4a5, 0xf4c6, 0xf4e5, 0xf506, 0xfd06, 0xfd27, 0xfd26,
0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xe287, 0xe207, 0xe208,
0xe208, 0xe208, 0xe208, 0xe1e8, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe9e8,
0xe1e9, 0xe9e9, 0xe1c9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9c9,
0xe9a9, 0xe9aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe96a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe90c, 0xe90c, 0xe10c,
0xe10c, 0xe10c, 0xe0ec, 0xe0ec, 0xe0ec, 0xb970, 0xb950, 0xb950, 0xb94f,
0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ee,
0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb8ae, 0xb88e,
0xb88d, 0x4994, 0x4994, 0x4994, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xa0a9, 0xa8c9, 0xa0a9, 0xa0a8, 0xd2a4,
0xe3a3, 0xe3a3, 0xe3c3, 0xebc3, 0xec03, 0xec04, 0xec24, 0xec44, 0xf465,
0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xf506, 0xfd06, 0xfd26, 0xfd26, 0xfd47,
0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xe247, 0xe207, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9,
0xe9e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9a9, 0xe9ca, 0xe9aa,
0xe9aa, 0xe1aa, 0xe189, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b,
0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe90c, 0xe90c, 0xe10c, 0xe10c,
0xe0ec, 0xe0ec, 0xe0ec, 0xb970, 0xb970, 0xb950, 0xb94f, 0xb94f, 0xb92f,
0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ee, 0xb8ee,
0xb8ce, 0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb8ae, 0xb88e, 0xb88d,
0xa8ce, 0x4994, 0x4994, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x41b5, 0xa8c9, 0xa8c9, 0xa8c9, 0xa8c9, 0xa0a9, 0xa0a8, 0xe383,
0xe3a3, 0xe3c3, 0xe3e3, 0xec03, 0xec24, 0xec44, 0xec44, 0xf465, 0xf485,
0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xfd26, 0xfd26, 0xfd47, 0xfd47, 0xfd47,
0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xe228, 0xe207, 0xe208, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1e9,
0xe1e9, 0xe1c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9ca, 0xe9a9, 0xe1a9,
0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe16a, 0xe98a,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c,
0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe90c, 0xe90c, 0xe10c, 0xe10c, 0xe0ec,
0xe0ec, 0xe0ec, 0xb970, 0xb970, 0xb950, 0xb950, 0xb94f, 0xb92f, 0xb92f,
0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ee, 0xb8ee, 0xb8ce,
0xb8ce, 0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb88e, 0xb88d, 0xb88d, 0xb88d,
0x4195, 0x4995, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0xa8c8, 0xa8c9, 0xa8c9, 0xa8c9, 0xa8c9, 0xa0a9, 0xa0a9, 0xe3a2, 0xe3a3,
0xe3c3, 0xebe3, 0xec04, 0xec24, 0xec44, 0xec64, 0xf485, 0xf4a5, 0xf4a5,
0xf4e6, 0xf4e6, 0xfd06, 0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd47,
0xfd47, 0xfd67, 0xfd67, 0xe207, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe9e9, 0xe1c9,
0xe1c9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe9ca, 0xe9a9, 0xe1aa, 0xe1aa,
0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xe18a, 0xe98a, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b,
0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92d, 0xe92c, 0xe92c, 0xe90c, 0xe90c, 0xe90d, 0xe10c, 0xe0ec, 0xe0ec,
0xd90e, 0xb970, 0xb950, 0xb950, 0xb94f, 0xb94f, 0xb92f, 0xb92f, 0xb92f,
0xb90f, 0xb90f, 0xb90f, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce,
0xb8ce, 0xb8ae, 0xb8ae, 0xb8ae, 0xb88e, 0xb88d, 0xb88d, 0xb86d, 0x4975,
0x4994, 0x4995, 0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xa8e9, 0xa8c9,
0xa8c9, 0xa8c9, 0xa8c8, 0xa8c9, 0xa8c9, 0xa8c9, 0xa908, 0xe3a3, 0xe3c3,
0xebe3, 0xec04, 0xec24, 0xec44, 0xec64, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6,
0xf506, 0xfd06, 0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd67,
0xfd67, 0xfd67, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208,
0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e8, 0xe9e9, 0xe9e9, 0xe1e9, 0xe9e9,
0xe9e9, 0xe1c9, 0xe9c9, 0xe9a9, 0xe9ca, 0xe9c9, 0xe1a9, 0xe1a9, 0xe1aa,
0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xe98b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe90c, 0xe90c, 0xe90c, 0xe90d, 0xe10d, 0xe0ec, 0xe0ec, 0xb950,
0xb970, 0xb950, 0xb950, 0xb94f, 0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb90f,
0xb90f, 0xb8ef, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xb8ce, 0xb8ce,
0xb8ae, 0xb8ae, 0xb88e, 0xb88e, 0xb88d, 0xb88d, 0xb86d, 0xa8ae, 0x4994,
0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xb0e8, 0xb0e8, 0xa8e8, 0xa8e9,
0xa8e9, 0xa8c9, 0xa8c8, 0xa8c9, 0xa8c9, 0xa8c9, 0xe3c3, 0xe3c3, 0xe3e3,
0xec04, 0xec24, 0xec44, 0xec65, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xf506,
0xfd26, 0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xfd47, 0xfd67, 0xfd67, 0xfd67,
0xfd67, 0xe207, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208,
0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe1e9, 0xe1e9, 0xe9e9, 0xe9e9, 0xe1c9,
0xe9c9, 0xe9c9, 0xe9c9, 0xe9ca, 0xe1aa, 0xe1a9, 0xe1aa, 0xe18a, 0xe18a,
0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xe98a, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94b, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c,
0xe92c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe90c, 0xe90c, 0xe90d, 0xe90d, 0xe0ec, 0xe0ec, 0xb970, 0xb970,
0xb950, 0xb950, 0xb94f, 0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f,
0xb8ef, 0xb8ef, 0xb8ef, 0xb8ee, 0xb8ce, 0xb8ce, 0xc0ce, 0xc0ae, 0xb8ae,
0xb8ae, 0xb88e, 0xb88e, 0xb88e, 0xc08d, 0xb86d, 0xc04e, 0x5174, 0x4995,
0x4995, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xb108, 0xb108, 0xb0e8, 0xb0e9, 0xb0e8, 0xb0e9,
0xa8e9, 0xa8c9, 0xa8c8, 0xa8c9, 0xa8c9, 0xe3c3, 0xe3c3, 0xe3e3, 0xec24,
0xec24, 0xec44, 0xf465, 0xf485, 0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xfd26,
0xfd26, 0xfd47, 0xfd47, 0xfd47, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd67,
0xe228, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208,
0xe1e8, 0xe1e8, 0xe9e8, 0xe1e9, 0xe1e9, 0xe9e9, 0xe9e9, 0xe9e9, 0xe9c9,
0xe9c9, 0xe9c9, 0xe9ca, 0xe1a9, 0xe1a9, 0xe1a9, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe18a, 0xe98a, 0xe98a, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94b, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe90c, 0xe92c,
0xe90d, 0xe90c, 0xe90c, 0xe0ec, 0xe0ed, 0xc14f, 0xb970, 0xb970, 0xb950,
0xb950, 0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f,
0xb8ef, 0xb8ee, 0xb8ee, 0xb8ce, 0xb8ce, 0xc0ce, 0xb8ce, 0xb8ae, 0xb8ae,
0xb88d, 0xb88d, 0xb88d, 0xb88d, 0xb86d, 0xc06d, 0x4994, 0x4995, 0x4995,
0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xb108, 0xb108, 0xb108, 0xb108, 0xb108, 0xb108, 0xb0e8, 0xa8e8,
0xb0e9, 0xa8c9, 0xa8c9, 0xa8c9, 0xa8e7, 0xe3e3, 0xec03, 0xec24, 0xec44,
0xec44, 0xf485, 0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xf506, 0xfd26, 0xfd26,
0xfd47, 0xfd47, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd47, 0xe228,
0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8,
0xe1e8, 0xe9e8, 0xe1e9, 0xe1e9, 0xe9e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9,
0xe9c9, 0xe9a9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe98a, 0xe98a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe94b, 0xe94b, 0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe90d,
0xe90c, 0xe90d, 0xe90d, 0xe10d, 0xb970, 0xb970, 0xb970, 0xb950, 0xb950,
0xb94f, 0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f, 0xb8ef,
0xc0ee, 0xb8ee, 0xb8ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xb8ae, 0xb8ae, 0xb8ae,
0xb88d, 0xb88d, 0xb88d, 0xc06d, 0xb88d, 0xa0af, 0x4995, 0x4995, 0x4195,
0x4195, 0x4995, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xb928,
0xb928, 0xb928, 0xb108, 0xb108, 0xb108, 0xb108, 0xb108, 0xb0e8, 0xb0e9,
0xa8e8, 0xa8e9, 0xa8c9, 0xa8c9, 0xe3e4, 0xec03, 0xec24, 0xec44, 0xec64,
0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xf506, 0xfd26, 0xfd27, 0xfd47, 0xfd67,
0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd47, 0xe227, 0xe228,
0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8,
0xe1e8, 0xe9e8, 0xe1e9, 0xe9e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe9c9,
0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe18a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b,
0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c,
0xe92c, 0xe92c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe90d, 0xe92d, 0xe90d, 0xe90d,
0xe90d, 0xe90d, 0xe8ec, 0xb970, 0xb970, 0xb970, 0xb950, 0xb950, 0xb94f,
0xb92f, 0xb92f, 0xb92f, 0xb92f, 0xb90f, 0xb90f, 0xb90f, 0xb8ee, 0xc0ef,
0xc0ce, 0xb8ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xb8ae, 0xc08d, 0xb88d,
0xc08d, 0xb88d, 0xc06d, 0xc06d, 0xb86e, 0x4194, 0x4995, 0x4995, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xb948, 0xb928, 0xb928,
0xb928, 0xb928, 0xb929, 0xb108, 0xb108, 0xb108, 0xb108, 0xb108, 0xb0e8,
0xb0e8, 0xa8e9, 0xa8e9, 0xe365, 0xec04, 0xec24, 0xec44, 0xec64, 0xf485,
0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xfd26, 0xfd26, 0xfd47, 0xfd67, 0xfd67,
0xfd67, 0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xfd87, 0xe228, 0xe228, 0xe228,
0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe9e8,
0xe9e8, 0xe1e9, 0xe1e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe9c9, 0xe1a9,
0xe1a9, 0xe1a9, 0xe1aa, 0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe18a,
0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe96b, 0xe94b,
0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe90d, 0xe92d, 0xe90d, 0xe90d, 0xe90d,
0xe8ed, 0xb990, 0xb970, 0xb970, 0xb970, 0xb950, 0xb94f, 0xb950, 0xb92f,
0xb92f, 0xb92f, 0xc10f, 0xc10f, 0xc10f, 0xc10f, 0xc0ee, 0xc0ef, 0xc0ee,
0xc0ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xb8ae, 0xc08d, 0xc08d, 0xc08d,
0xb88d, 0xc06d, 0xb86d, 0xc06d, 0x4974, 0x4995, 0x4995, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x41b5, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xb948, 0xb948, 0xb948, 0xb948, 0xb928,
0xb928, 0xb928, 0xb928, 0xb928, 0xb108, 0xb108, 0xb108, 0xb108, 0xb0e8,
0xb0e8, 0xb0e9, 0xb0e9, 0xec04, 0xec24, 0xec44, 0xec65, 0xf485, 0xf4a5,
0xf4c5, 0xf4e6, 0xf506, 0xfd26, 0xfd47, 0xfd67, 0xfd67, 0xfd67, 0xfd67,
0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xf4c7, 0xe227, 0xe227, 0xe228, 0xe208,
0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe1e8, 0xe9e8,
0xe1e9, 0xe9e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe1c9, 0xe1a9, 0xe1a9,
0xe1aa, 0xe1aa, 0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xe98b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe92d, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe90d, 0xe8ed, 0xe8ed, 0xe8ed,
0xb970, 0xb970, 0xb970, 0xb970, 0xb950, 0xb94f, 0xb94f, 0xb92f, 0xb92f,
0xb92f, 0xc10f, 0xc10f, 0xc10f, 0xc10f, 0xc0ee, 0xc0ee, 0xc0ee, 0xc0ce,
0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08d, 0xc08d, 0xc08d, 0xc06d,
0xc06d, 0xc06d, 0xb88d, 0x8111, 0x4994, 0x4995, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0xc168, 0xc168, 0xb948, 0xb948, 0xb948, 0xb948, 0xb928,
0xb928, 0xb928, 0xb928, 0xb928, 0xb108, 0xb108, 0xb108, 0xb108, 0xb108,
0xb0e8, 0xb0e9, 0xec03, 0xec24, 0xec44, 0xec65, 0xf485, 0xf4c5, 0xf4e6,
0xf506, 0xf506, 0xfd26, 0xfd47, 0xfd67, 0xfd67, 0xfd67, 0xfd67, 0xfd87,
0xfd87, 0xfd87, 0xfd87, 0xeb47, 0xe227, 0xe227, 0xe227, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe9e8, 0xe9e8, 0xe1e9,
0xe1e9, 0xe9e9, 0xe9e9, 0xe9c9, 0xe9c9, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9,
0xe1aa, 0xe1aa, 0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe18a, 0xe98a, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94c, 0xe94b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe8ed, 0xe8ed, 0xb970,
0xb970, 0xb950, 0xb950, 0xb950, 0xb950, 0xb94f, 0xb92f, 0xb92f, 0xc12f,
0xc10f, 0xc10f, 0xc10f, 0xc0ef, 0xc0ee, 0xc0ee, 0xc0ee, 0xc0ce, 0xc0ce,
0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08d, 0xc08d, 0xc08d, 0xc06d, 0xc06d,
0xc06d, 0xc06d, 0xb86c, 0x4975, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948, 0xb948, 0xb948, 0xb948,
0xb948, 0xb928, 0xb928, 0xb928, 0xb928, 0xb108, 0xb108, 0xb108, 0xb108,
0xb108, 0xc1e7, 0xec24, 0xec44, 0xf485, 0xf4a5, 0xf4c6, 0xf4e6, 0xf506,
0xf526, 0xfd46, 0xfd47, 0xfd67, 0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xfd87,
0xfd87, 0xfd87, 0xea28, 0xe227, 0xe227, 0xe227, 0xe208, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe9e8, 0xe1e9, 0xe9e9,
0xe9e9, 0xe9e9, 0xe1c9, 0xe9c9, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa,
0xe1aa, 0xe1aa, 0xe1aa, 0xe18a, 0xe18a, 0xe98a, 0xe98b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe8ed, 0xb970, 0xb970, 0xb970,
0xb950, 0xb950, 0xb950, 0xb950, 0xb94f, 0xc14f, 0xb92f, 0xc12f, 0xc10f,
0xc10f, 0xc10f, 0xc0ef, 0xc0ee, 0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce, 0xc0ce,
0xc0ae, 0xc0ae, 0xc0ae, 0xc08d, 0xc08d, 0xc08d, 0xc06d, 0xc08d, 0xc06d,
0xc06d, 0xc04d, 0x4194, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xc188, 0xc188,
0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948, 0xb948, 0xb948,
0xb928, 0xb928, 0xb928, 0xb928, 0xb928, 0xb928, 0xb108, 0xb108, 0xb108,
0xb0e8, 0xec25, 0xec64, 0xec85, 0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xf526,
0xfd26, 0xfd67, 0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87,
0xfd87, 0xe227, 0xe227, 0xe227, 0xe228, 0xe228, 0xe228, 0xe208, 0xe208,
0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e8, 0xe9e8, 0xe1e9, 0xe9e9, 0xe9e9,
0xe9e9, 0xe9c9, 0xe9c9, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe1aa,
0xe1aa, 0xe98a, 0xe18a, 0xe98a, 0xe98a, 0xe98a, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe94c, 0xe94c, 0xe94b, 0xe94c, 0xe94c, 0xe94c,
0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe8ed, 0xb990, 0xb970, 0xb970, 0xb970,
0xb950, 0xb950, 0xb94f, 0xc14f, 0xc14f, 0xc12f, 0xc12f, 0xc10f, 0xc10f,
0xc10f, 0xc0ef, 0xc0ee, 0xc0ee, 0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce, 0xc0ae,
0xc0ae, 0xc0ae, 0xc08e, 0xc08d, 0xc08d, 0xc06d, 0xc06d, 0xc06d, 0xc06d,
0xc04d, 0x7132, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xc9a8, 0xc188, 0xc188, 0xc188,
0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948, 0xb948, 0xb948,
0xb948, 0xb948, 0xb928, 0xb928, 0xb928, 0xb928, 0xb929, 0xb108, 0xb108,
0xec25, 0xec64, 0xec85, 0xf4a5, 0xf4c5, 0xf4e6, 0xf506, 0xf526, 0xf547,
0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfda7,
0xe207, 0xe227, 0xe227, 0xe227, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208,
0xe208, 0xe1e8, 0xe1e8, 0xe9e8, 0xe9e8, 0xe1e8, 0xe9e9, 0xe9e9, 0xe9e9,
0xe9e9, 0xe1c9, 0xe1c9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe1a9, 0xe1aa, 0xe1aa,
0xe98a, 0xe18a, 0xe98a, 0xe98a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe92c, 0xe92c, 0xe94c, 0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe90d,
0xe90d, 0xe90d, 0xe90d, 0xe8ed, 0xb970, 0xb970, 0xb970, 0xb970, 0xb950,
0xb950, 0xc150, 0xc14f, 0xc12f, 0xc12f, 0xb92f, 0xc12f, 0xc10f, 0xc10f,
0xc0ef, 0xc0ee, 0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae,
0xc0ae, 0xc08d, 0xc08d, 0xc08d, 0xc08d, 0xc06d, 0xc06d, 0xc06d, 0xc04d,
0xb86d, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0xc9a8, 0xc9a8, 0xc9a8, 0xc987, 0xc187, 0xc188,
0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948, 0xb948,
0xb948, 0xb928, 0xb948, 0xb928, 0xb928, 0xb928, 0xb928, 0xb108, 0xb128,
0xec64, 0xec85, 0xf4a5, 0xf4e6, 0xf506, 0xf506, 0xfd26, 0xf546, 0xfd67,
0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfda7, 0xda27,
0xe227, 0xe227, 0xe227, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208,
0xe208, 0xe1e8, 0xe1e8, 0xe9e8, 0xe1e8, 0xe1e9, 0xe9e9, 0xe9e9, 0xe9c9,
0xe1c9, 0xe1c9, 0xe1c9, 0xe1a9, 0xe1aa, 0xe1aa, 0xe1aa, 0xe1aa, 0xe98a,
0xe18a, 0xe98a, 0xe98a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe96b, 0xe96b, 0xe94b, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c,
0xe92c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe90d, 0xe90d, 0xe90d,
0xe90d, 0xe90d, 0xb991, 0xb970, 0xb970, 0xb970, 0xb950, 0xb950, 0xb950,
0xb950, 0xc14f, 0xc12f, 0xc12f, 0xc12f, 0xc10f, 0xc10f, 0xc10f, 0xc0ef,
0xc0ee, 0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc0ae,
0xc08d, 0xc08d, 0xc08d, 0xc06d, 0xc06d, 0xc06d, 0xc06d, 0xc04d, 0xc04c,
0x4196, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0xc9a7, 0xc9a8, 0xc9a8, 0xc9a7, 0xc9a8, 0xc9a8, 0xc987, 0xc188,
0xc188, 0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948,
0xb948, 0xb948, 0xb928, 0xb948, 0xb928, 0xb928, 0xb928, 0xb928, 0xec84,
0xf485, 0xf4c5, 0xf4e6, 0xf506, 0xf526, 0xf526, 0xfd47, 0xfd67, 0xfd87,
0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfda7, 0xfda7, 0xe228, 0xe227,
0xe227, 0xe227, 0xe227, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe9e8,
0xe1e8, 0xe1e8, 0xe9e8, 0xe9e8, 0xe1e9, 0xe9e9, 0xe9e9, 0xe1c9, 0xe1c9,
0xe1c9, 0xe1a9, 0xe1a9, 0xe1aa, 0xe1a9, 0xe1aa, 0xe1aa, 0xe98a, 0xe98a,
0xe18a, 0xe98a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c,
0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d,
0xe10d, 0xc170, 0xb970, 0xb970, 0xb970, 0xb950, 0xb950, 0xc150, 0xc150,
0xc12f, 0xc12f, 0xc12f, 0xc12f, 0xc10f, 0xc10f, 0xc10f, 0xc0ef, 0xc0ee,
0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08d,
0xc08d, 0xc08d, 0xc06d, 0xc06d, 0xc06d, 0xc06d, 0xc04d, 0xc04d, 0x5953,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xc9c7,
0xc9a8, 0xc9a8, 0xc9a7, 0xc9a8, 0xc9a7, 0xc9a8, 0xc9a8, 0xc9a8, 0xc187,
0xc188, 0xc188, 0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xb948,
0xb948, 0xb948, 0xb948, 0xb948, 0xb928, 0xb928, 0xb948, 0xec45, 0xf4a5,
0xf4c5, 0xf4e6, 0xf506, 0xf526, 0xfd47, 0xfd67, 0xfd87, 0xfd87, 0xfd87,
0xfd87, 0xfd87, 0xfd87, 0xfda7, 0xfda7, 0xfda8, 0xe227, 0xe227, 0xe227,
0xe227, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8,
0xe208, 0xe9e8, 0xe1e9, 0xe1e9, 0xe9e9, 0xe9e9, 0xe1c9, 0xe1c9, 0xe1c9,
0xe1a9, 0xe1a9, 0xe1aa, 0xe1aa, 0xe1aa, 0xe1aa, 0xe98a, 0xe18a, 0xe18a,
0xe98a, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92c,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d,
0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xd92e,
0xb970, 0xb970, 0xb970, 0xb970, 0xb950, 0xc150, 0xc150, 0xc150, 0xc12f,
0xc12f, 0xc12f, 0xc12f, 0xc10f, 0xc10f, 0xc10f, 0xc0ef, 0xc0ee, 0xc0ee,
0xc0ce, 0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08e, 0xc08d, 0xc08d,
0xc08d, 0xc06d, 0xc06d, 0xc06d, 0xc06d, 0xc04d, 0xc04d, 0xb84d, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0xd1c7, 0xc9c7, 0xc9c7,
0xc9c7, 0xc9c7, 0xc9c7, 0xc9a7, 0xc9a7, 0xc9a8, 0xc9a8, 0xc9a8, 0xc987,
0xc188, 0xc188, 0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168,
0xb948, 0xb948, 0xb948, 0xb928, 0xb928, 0xb928, 0xb929, 0xf4a5, 0xf4c5,
0xf4e6, 0xf506, 0xfd26, 0xfd47, 0xfd67, 0xfd67, 0xfd87, 0xfd87, 0xfd87,
0xfd87, 0xfda7, 0xfda7, 0xfda7, 0xfda7, 0xe227, 0xe227, 0xe227, 0xe227,
0xe227, 0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8,
0xe9e8, 0xe9e9, 0xe1e9, 0xe9e9, 0xe1e9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9,
0xe1a9, 0xe1aa, 0xe1aa, 0xe1aa, 0xe1aa, 0xe98a, 0xe18a, 0xe98a, 0xe98a,
0xe98b, 0xe98b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96c, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92c, 0xe92c, 0xe92d,
0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe92d, 0xe90d, 0xe90d, 0xe90d,
0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xb970, 0xb970,
0xb970, 0xb970, 0xb970, 0xc150, 0xc150, 0xc150, 0xc150, 0xc12f, 0xc12f,
0xc12f, 0xc10f, 0xc10f, 0xc10f, 0xc10f, 0xc0ef, 0xc0ee, 0xc0ce, 0xc0ce,
0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08d, 0xc08e, 0xc08d, 0xc08d,
0xc06d, 0xc06d, 0xc06d, 0xc06d, 0xc04d, 0xc04d, 0xc04c, 0x4974, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0xd1e7, 0xd1e7, 0xd1c7, 0xd1c7, 0xd1c7,
0xd1c7, 0xd1c7, 0xc9c7, 0xc9c7, 0xc9a8, 0xc9a8, 0xc9a8, 0xc9a8, 0xc9a8,
0xc987, 0xc188, 0xc188, 0xc188, 0xc168, 0xc168, 0xc168, 0xc168, 0xc168,
0xc168, 0xb948, 0xb948, 0xb948, 0xb948, 0xb948, 0xeca5, 0xf4e5, 0xf4e6,
0xfd26, 0xf526, 0xf566, 0xfd67, 0xfd87, 0xfd87, 0xfd87, 0xfd87, 0xfda7,
0xfda7, 0xfda7, 0xfda7, 0xfda7, 0xe227, 0xe227, 0xe227, 0xe227, 0xe227,
0xe228, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe208, 0xe1e8, 0xe1e9,
0xe9e8, 0xe1e9, 0xe1e9, 0xe1e9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1c9, 0xe1a9,
0xe1aa, 0xe1aa, 0xe9aa, 0xe1aa, 0xe98a, 0xe98a, 0xe98a, 0xe98a, 0xe98b,
0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe96b, 0xe94b, 0xe94b, 0xe94c,
0xe94c, 0xe94c, 0xe94c, 0xe94c, 0xe92c, 0xe92c, 0xe92d, 0xe92d, 0xe92d,
0xe92d, 0xe92d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d,
0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe90d, 0xe10d, 0xc170, 0xb970, 0xb970,
0xb970, 0xc170, 0xb950, 0xc150, 0xc150, 0xc150, 0xc12f, 0xc12f, 0xc12f,
0xc10f, 0xc10f, 0xc10f, 0xc10f, 0xc0ef, 0xc0ee, 0xc0ce, 0xc0ce, 0xc0ce,
0xc0ce, 0xc0ae, 0xc0ae, 0xc0ae, 0xc08d, 0xc08d, 0xc08d, 0xc08d, 0xc06d,
0xc06d, 0xc06d, 0xc06d, 0xc04d, 0xc04d, 0xc04c, 0x4994, 0x4195, 0x4195,
0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195, 0x4195,
0x4195, 0x4195});
img4 = (std::vector<uint16_t>{
0x2415, 0x2415, 0x2415, 0x2415, 0x23f5, 0x23d4, 0x23d4, 0x23d4, 0x23d4,
0x23d4, 0x23d3, 0x19cb, 0x19ab, 0x19ab, 0x19ab, 0x1b93, 0x1b93, 0x1b73,
0x1b73, 0x1b73, 0x1b72, 0x1b52, 0x1b52, 0x1b52, 0x1332, 0x1b31, 0x198b,
0x198b, 0x198a, 0x198a, 0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a,
0x196a, 0x198a, 0x198a, 0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x194a,
0x194a, 0x1169, 0x926e, 0xb2f1, 0xd394, 0xd394, 0xecb7, 0xecd7, 0xd394,
0xd394, 0xcb93, 0xecd7, 0xecd7, 0xecb7, 0xd394, 0xcbb4, 0x49ab, 0x194a,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1929, 0x1929, 0x1929, 0x1929, 0x194a, 0x52ab,
0x1149, 0x1149, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1109, 0x29cb, 0x29ab, 0x1109, 0x1109, 0x1109,
0x1109, 0x1109, 0x1109, 0x1109, 0x20e6, 0xc2e5, 0x1109, 0x1108, 0x1108,
0x1108, 0x1109, 0x1109, 0x294b, 0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f,
0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f, 0x4a4f, 0x2435, 0x2435,
0x2415, 0x2415, 0x2415, 0x2bf5, 0x23d5, 0x23d5, 0x23d4, 0x23b4, 0x23b4,
0x11cb, 0x19ab, 0x19ab, 0x19ab, 0x11ac, 0x2393, 0x1b73, 0x1b93, 0x1b73,
0x1b72, 0x1b52, 0x1b52, 0x1b52, 0x1b52, 0x1a8f, 0x198b, 0x198b, 0x198a,
0x198a, 0x198a, 0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a,
0x196a, 0x198a, 0x196a, 0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x116a, 0x196a, 0x5a4e,
0xb2f1, 0xb311, 0xd3b4, 0xcb94, 0xecb7, 0xecb8, 0xd3b4, 0xd3b4, 0xcbb3,
0xf4d8, 0xecd7, 0xecd7, 0xd394, 0xd394, 0x8a2e, 0x194a, 0x194a, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1149, 0x1149, 0x1149, 0x1149,
0x1949, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0xaddb, 0xb5db, 0xaddb, 0x1108, 0x1109, 0x1109, 0x1109, 0x1109,
0x1109, 0x1109, 0x1908, 0x2107, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109,
0x10e9, 0x190a, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x2415, 0x2435, 0x2435, 0x2415,
0x2415, 0x23f5, 0x2bf5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0xa6e, 0x11ab,
0x19ac, 0x19ac, 0x19ac, 0x198c, 0x1b72, 0x1b72, 0x1b73, 0x1b72, 0x1b72,
0x1352, 0x1b52, 0x2311, 0x198b, 0x198b, 0x198b, 0x198b, 0x198a, 0x198a,
0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x198a,
0x198a, 0x196a, 0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a,
0x196a, 0x196a, 0x116a, 0x1969, 0x196a, 0x196a, 0x826e, 0xb2f1, 0xcbb4,
0xd3b4, 0xd394, 0xf4d8, 0xecb8, 0xd394, 0xd3b4, 0xd394, 0xd394, 0xd394,
0xd394, 0xd394, 0xd394, 0xcb94, 0x194a, 0x194a, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x29cb,
0xaddb, 0xb5fb, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109,
0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1108, 0x1108, 0x10c8,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0x524f, 0x524f, 0x33f4, 0x2435, 0x2435, 0x2415, 0x2415, 0x23f5,
0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23b4, 0x1bb4, 0x11cc, 0x19ac, 0x19ac,
0x19ac, 0x198b, 0x19ab, 0x11cb, 0x12ae, 0x1b72, 0x1b52, 0x1b51, 0x11ab,
0x19aa, 0x198b, 0x198b, 0x198b, 0x198b, 0x198a, 0x198a, 0x198a, 0x198a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x198a, 0x198a, 0x196a,
0x198a, 0x198a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a,
0x61a6, 0x1948, 0x196a, 0x196a, 0x822e, 0xef9f, 0xcf1e, 0xae5b, 0x7453,
0x7412, 0xecd8, 0xf4b8, 0xd394, 0xd394, 0xd394, 0xd394, 0xd394, 0xec77,
0xec98, 0xd394, 0x1128, 0x194a, 0x194a, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1929, 0x1949, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109,
0x1109, 0x1109, 0x1109, 0x1109, 0x1108, 0x1108, 0x18e9, 0x524f, 0x524f,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0xa4e, 0x2435, 0x2435, 0x2415, 0x2415, 0x1c15, 0x23f5, 0x23d5,
0x23d5, 0x23d4, 0x23d4, 0x23b4, 0x11cc, 0x11cc, 0x19ac, 0x19ac, 0x19ab,
0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x118b, 0x11ab, 0x118b, 0x198b,
0x198b, 0x198b, 0x198b, 0x198b, 0x198a, 0x198a, 0x198a, 0x198a, 0x198a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x198a, 0x198a, 0x198a, 0x198a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0xbb08, 0x198a,
0x196a, 0xcf3e, 0xcf5e, 0xcf5d, 0xffff, 0xffff, 0x7474, 0x7474, 0xcb74,
0xf4d9, 0xecf8, 0xecd8, 0xe477, 0xd3b4, 0xd3b4, 0xecb8, 0xecb7, 0xd394,
0x522d, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a,
0x192a, 0x192a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x190a, 0x1929, 0x1109, 0x1109,
0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109, 0x1109,
0x1109, 0x1109, 0x1108, 0x1108, 0x294b, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x11ac,
0x2c35, 0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23d5, 0x23d5, 0x23d4,
0x23d4, 0x23b4, 0x2bd4, 0x11cc, 0x11ab, 0x19ac, 0x19ab, 0x19ab, 0x19ab,
0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x118b, 0x198b, 0x198b,
0x198a, 0x8a04, 0x8a04, 0x196b, 0x198a, 0x198a, 0x198a, 0x196a, 0x196a,
0x198a, 0x198a, 0x196a, 0x196a, 0x198a, 0x198a, 0x198a, 0x198a, 0x196a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0xa5f9, 0xcf3f, 0xd75e,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7ff, 0xecd8, 0xd3b4, 0xcb94,
0xec97, 0xecb8, 0xecb8, 0xd3b4, 0xecb7, 0xd3b4, 0xcb94, 0x626e, 0x194a,
0x1949, 0x326d, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1929, 0x1929, 0x6d36, 0x21cb, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x18e9, 0x18e9, 0x420d, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x11cc, 0x2436, 0x2436,
0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4,
0x23b4, 0x11ac, 0x19ac, 0x19ac, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab,
0x19ab, 0x19ab, 0x198b, 0x8225, 0x8a25, 0x8a45, 0x198b, 0x218a, 0x9204,
0x2189, 0x198b, 0x198a, 0x198a, 0x198a, 0x198a, 0x118a, 0x118a, 0x118a,
0x74d6, 0x118a, 0x198b, 0x198b, 0x198b, 0x198b, 0x196b, 0x196b, 0x196b,
0x196b, 0x196b, 0x198a, 0xcf5e, 0xcf5e, 0xef9e, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xa5f9, 0xd394, 0xd3b4, 0xd3b4, 0xd3b4, 0xd394,
0xecb8, 0xd3b4, 0xd394, 0xd394, 0xd394, 0x41cb, 0x194a, 0x1949, 0x74f7,
0x1149, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1929, 0x1929,
0x7517, 0x1149, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0xbac5, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x18e9, 0x18e9,
0x526f, 0x5270, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f,
0x526f, 0x526f, 0x526f, 0x526f, 0x11cc, 0x2436, 0x2435, 0x2435, 0x2415,
0x2415, 0x2415, 0x23f5, 0x23d5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x1bd3,
0x11cc, 0x11ac, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab,
0x2189, 0x8a24, 0x8a24, 0x8a24, 0x198b, 0x198b, 0x198a, 0x198a, 0x198b,
0x198a, 0x198a, 0x198a, 0x198a, 0x118a, 0x11aa, 0x98a, 0x6d37, 0x118a,
0x198b, 0x198b, 0x198b, 0x196b, 0x198b, 0x198b, 0x196a, 0x196a, 0xd71d,
0xcf7e, 0xcf5e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffdf, 0xe75e, 0xd394, 0xd394, 0xd394, 0xdbf5, 0xcbb4, 0xecd8, 0xd3d4,
0xd394, 0xd394, 0xd394, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x1929, 0x1929, 0x1929, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1109, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x526f, 0x5270,
0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f, 0x526f,
0x526f, 0x526f, 0x11cc, 0x2c36, 0x2436, 0x2436, 0x2435, 0x2415, 0x2415,
0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23b4, 0x1ab, 0x11ab,
0x11ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x2989, 0x8a23,
0x8a23, 0x7a45, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198a,
0x198a, 0x198a, 0x118a, 0x118a, 0x118a, 0x118a, 0x118b, 0x196b, 0x196b,
0x196b, 0x198b, 0x196b, 0x196b, 0x116a, 0xcf5e, 0xcf5e, 0xdf5e, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xefbe, 0xd394,
0xd394, 0xd394, 0xd3b4, 0xe436, 0xecd8, 0xe497, 0xd3b4, 0xd394, 0xd394,
0x8a2d, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1109, 0x5270, 0x5250, 0x5250, 0x5250,
0xfffe, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250,
0x11ec, 0x2c55, 0x2436, 0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5,
0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23b4, 0x1bb4, 0x11ac, 0x11cb, 0x19ab,
0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x11ab, 0x2189, 0x198b,
0x11ab, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b,
0x198b, 0x198b, 0x118a, 0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x198b,
0x196a, 0x1928, 0xcf5e, 0xcf5f, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x9e1b, 0xb2f1, 0xbb12, 0xcb94,
0xd394, 0xd3b4, 0xd394, 0xd394, 0xd394, 0xd394, 0xd373, 0x316a, 0x1949,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1149, 0x192a,
0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x526f, 0x5270, 0x5270, 0x5270, 0xffdd, 0x9cd6,
0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x11cc, 0x2331,
0x2436, 0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5,
0x23d4, 0x23d4, 0x23b4, 0x1bd4, 0x1bd3, 0x11cb, 0x11cb, 0x19ab, 0x19ab,
0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x11ab, 0x11ab, 0x11ab, 0x198b,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b,
0x198b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x198b, 0xf7ff, 0xcf5e,
0xd75d, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xcedc, 0x9af1, 0xb2f1, 0xb2f1, 0xb2f1, 0xcb94, 0xd394,
0xd394, 0xd394, 0xd394, 0xcb94, 0x622e, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1149, 0x192a, 0x192a, 0x192a,
0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x524f, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270,
0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x11cc, 0x21ad, 0x2312, 0x2c16,
0x2435, 0x2415, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x2bf5, 0x23d5, 0x23d4,
0x23d4, 0x23d4, 0x1bb3, 0x23b3, 0x11cc, 0x11ab, 0x19ab, 0x19ab, 0x198b,
0x198b, 0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x198b, 0x198b, 0x198b, 0x198b,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x196b,
0x196b, 0x196b, 0x196b, 0x116a, 0xd75e, 0xcf5f, 0xdf5d, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7453,
0x7453, 0x1189, 0x826f, 0x9a6f, 0xaaf1, 0xaaf1, 0xaaf1, 0xaaf1, 0x9a8f,
0x824e, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x192a, 0x192a, 0x192a, 0x192a,
0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0xc2e6,
0x20e8, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5270,
0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270,
0x5270, 0x5250, 0x5a51, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x19cc, 0x11ec,
0x23f4, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x23d5, 0x23d4, 0x23d4, 0x23d4,
0x1bb3, 0x1bb4, 0x23b4, 0x11cc, 0x19ac, 0x19ac, 0x198b, 0x198b, 0x198b,
0x198b, 0x198b, 0x198b, 0x198b, 0x5b51, 0x4ace, 0x198a, 0x198b, 0x198a,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x196b, 0x198b,
0x198a, 0xcf3e, 0xcf5e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7473, 0x7453, 0x1169, 0x118a,
0x116a, 0x196a, 0x1949, 0x2929, 0x2129, 0x1149, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x1949, 0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x20e9, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x18e9, 0x5270, 0x5a70, 0x5a70,
0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70,
0x5a70, 0x11ec, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x19cc, 0x19cc, 0x11cb,
0x2331, 0x1c15, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4,
0x1bb4, 0x2bb3, 0x19cb, 0x19ac, 0x19ac, 0x19ac, 0x198b, 0x198b, 0x198b,
0x198b, 0x19ab, 0xffff, 0xffff, 0xffff, 0xffff, 0x2168, 0x198a, 0x198b,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198a, 0xcebc, 0xcf5d, 0xcf5f,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0x7411, 0x7454, 0x42ce, 0x196a, 0x196a, 0x196a, 0x196a,
0x194a, 0x194a, 0x196a, 0x116a, 0x116a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949,
0x1949, 0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x18e8, 0x18e9, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70,
0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x11cc,
0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cb, 0x11eb, 0x9ec,
0x2bd5, 0x23f4, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x23b4, 0x1bb4, 0x2394,
0x120d, 0x11cc, 0x19ac, 0x19ac, 0x19ac, 0x198b, 0x19ac, 0x19ac, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7ff, 0x218a, 0x198a,
0x198b, 0x198b, 0x198b, 0xefff, 0xd75e, 0xcf3e, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xf7ff, 0x9e3b, 0x118a, 0x116a, 0x196a, 0x196a, 0x118a, 0x196a, 0x194a,
0x196a, 0x116a, 0x116a, 0x116a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x114a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1949, 0x1949, 0x1149, 0x7517, 0x7cf6, 0x194a,
0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949,
0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x190a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x18e9, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x11cc, 0x19cc, 0x19cc,
0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cb, 0x11cc, 0x11cc, 0x2bd3,
0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23b4, 0x1bb4, 0x23b4, 0x2394, 0x198b,
0x19ac, 0x19ac, 0x19ab, 0x19ab, 0x19aa, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xefbf, 0x198a,
0xe7bf, 0xd75f, 0xe75e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7ff, 0x9e3c, 0x116a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x116a,
0x116a, 0x116a, 0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1949, 0x1949, 0x948, 0x6d36, 0x7536, 0x32ae, 0x194a, 0x194a,
0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1929,
0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929, 0x1129,
0x736e, 0x9cb3, 0x9c93, 0x9cb3, 0x734f, 0x1909, 0x1909, 0x1909, 0x1929,
0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x18e8, 0x18e9,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x11cc, 0x11ec, 0x19cc, 0x11cc, 0x11cc,
0x11cc, 0x11cc, 0x19cc, 0x11cb, 0x11cc, 0x11cc, 0x11cc, 0x23d3, 0x23d5,
0x23d5, 0x23d4, 0x23d4, 0x1bb4, 0x23b4, 0x23b4, 0x126e, 0x19cc, 0x19ac,
0x19ab, 0x19ab, 0x11ab, 0xffff, 0xcf1e, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xd73c, 0xd75f, 0xcf5f, 0xe7df,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffdf, 0x9e3c, 0x118a, 0x116a, 0x196a, 0x196a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x194a, 0x116a, 0x116a,
0x116a, 0x194a, 0x194a, 0x194a, 0x114a, 0xa2e, 0xa6f, 0xa4e, 0xa4e,
0x194b, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949,
0x1949, 0x1149, 0x6d36, 0x6d37, 0x1149, 0x194a, 0x194a, 0x1929, 0x1929,
0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x192a, 0x192a,
0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1909, 0x7b4d, 0xa4b3, 0xa4b3,
0xa4b3, 0xa4b3, 0xa493, 0xa493, 0x2108, 0x1909, 0x1929, 0x1929, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x18e8, 0x18e9, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a70, 0x11cc, 0x11ec, 0x11ec, 0x11cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11cb, 0x23f5, 0x23d4, 0x23d4,
0x23d4, 0x1bb4, 0x1bb4, 0x23b4, 0x2394, 0x11ac, 0x11ab, 0x19ab, 0x19ab,
0x19ab, 0xffff, 0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xcefd, 0x7454, 0xcf1e, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xa63c, 0x6414, 0x118a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a,
0x118a, 0x118a, 0x118a, 0x196a, 0x196a, 0x196a, 0x116a, 0x116a, 0x196a,
0x114a, 0x26d, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0xa4e, 0x24e,
0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0x1949, 0x1949,
0x194a, 0x1929, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a,
0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1929, 0x734e, 0x9c52, 0xa493, 0xa493, 0xa493, 0xac93,
0xa493, 0xa493, 0xa493, 0x2106, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x18e9, 0x18e9, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a70, 0x5a70, 0x5a70,
0x11cc, 0x11ec, 0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x11cb, 0xa0d, 0x23d4, 0x23d4, 0x23d4, 0x23b4,
0x23b4, 0x23b4, 0x23b4, 0x11cc, 0x19ac, 0x19ab, 0x19ab, 0x19ab, 0xf7ff,
0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7c73,
0x7454, 0x7454, 0x84f5, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7ff, 0xa63c, 0xa5fc,
0x118a, 0x118a, 0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x118a, 0x118a,
0x118a, 0x116a, 0x194a, 0x194a, 0x196a, 0x114b, 0xa4d, 0xa4e, 0xa6e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0x118b,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1907, 0x8bd0, 0xa493, 0xa493, 0xb4d4, 0xacb3, 0xbcd4, 0xbcd4, 0xa493,
0xa4b3, 0xa493, 0x18e9, 0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x194a, 0x7d37, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x5a70, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a70, 0x5a70, 0x5a70, 0x11cc, 0x11ec,
0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x11cc, 0x11ec, 0x23f4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4,
0x1bb4, 0x2b72, 0x11cc, 0x19ab, 0x19ab, 0x19ab, 0x8cb4, 0xdf5e, 0xcf3d,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7474, 0x7454, 0x7454, 0x7454,
0x7454, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xa65c, 0xa63c, 0x198a, 0x198a, 0x196a,
0x196a, 0x196a, 0x196a, 0x196a, 0x196a, 0x118a, 0x118a, 0x118a, 0x118a,
0x196a, 0x196a, 0x196a, 0x124e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0x11ab, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x190a, 0x7390, 0x8bf0,
0xa4b3, 0x9c93, 0xc4d3, 0xa4b3, 0xa493, 0xa492, 0xc4f4, 0xa493, 0xa493,
0x734e, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a70, 0x5a70, 0x5a70, 0x11cc, 0x11ec, 0x11ec, 0x11ec,
0x11ec, 0x11cc, 0x11cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11cc,
0x11cc, 0x2b94, 0x23d4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b3, 0x2393,
0x11cb, 0x11ab, 0x19cb, 0x19ab, 0x19aa, 0xffff, 0xcf3e, 0xffdf, 0xffff,
0xffff, 0xefff, 0xf7ff, 0x7453, 0x7454, 0x7454, 0x7454, 0x7454, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xefdf, 0xa65c, 0x9e1c, 0x118a, 0x198b, 0x198b, 0x196b, 0x196b, 0x196b,
0x196b, 0x196b, 0x196a, 0x116a, 0x116a, 0x116a, 0x116a, 0x196b, 0x196a,
0xa6d, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e, 0x96a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x1129, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x192a, 0x734e, 0x8c11, 0x8bf0, 0xac93,
0xa492, 0xa4b3, 0xa4b3, 0xa492, 0xc4d3, 0xa493, 0xa493, 0x734e, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x18e9, 0x18e9, 0x5a90,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a90, 0x11cc, 0x11cc, 0x11cc, 0x11ec, 0x11ec, 0x19ec,
0x2a0c, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11cc, 0x19cc, 0x11ed,
0x23d4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b4, 0x23b3, 0x11cb, 0x11ab,
0x11ab, 0x19ab, 0x19ab, 0xffff, 0xcf5e, 0xcf3e, 0xcf3e, 0xcf3e, 0xdf9f,
0x7453, 0x7454, 0x7454, 0x7454, 0x7454, 0x7454, 0xc69a, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xe79f, 0x9e3c, 0xa61c,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x196b, 0x196b, 0x196b, 0x196b,
0x196b, 0x116a, 0x116a, 0x116a, 0x116a, 0x118a, 0x1a4e, 0xa8e, 0xa6e,
0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0x26e, 0xa4e, 0x124d, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949,
0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1929, 0x4a4c, 0x8bf0, 0x8c11, 0xa493, 0xa4b3, 0xa4b3,
0xa492, 0xc4d4, 0xa472, 0xa493, 0xa4b3, 0x7b6f, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x210a, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a90, 0x11cc, 0x11cc, 0x11cc, 0x11ec, 0x11ec, 0x11ec, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11cc, 0x11ec, 0x11cc, 0x23d5, 0x23d4,
0x23d4, 0x23d4, 0x1bb4, 0x1bb3, 0x1bb4, 0x2b93, 0x11ab, 0x11ab, 0x1a2c,
0x19ab, 0xffff, 0xcf3e, 0xcf3e, 0xd75e, 0xdf5d, 0xcf3e, 0x7473, 0x7454,
0x7454, 0x7454, 0x7454, 0x7453, 0x7454, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xc6dd, 0x9e3c, 0xa63d, 0x198a, 0x198a, 0x198b,
0x198b, 0x198b, 0x198b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x116a,
0x116a, 0x7537, 0x6d36, 0x9ab, 0xa6e, 0xa8e, 0xa6e, 0xa6e, 0xa6e,
0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa6e, 0xa4e, 0x124e, 0x124d, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1929,
0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1909, 0x734e, 0x8bf0, 0x8bd1, 0x8bf0, 0xa4b3, 0xbcf4, 0xa493,
0xa493, 0x9c72, 0x734e, 0x2128, 0x1909, 0x1909, 0x1909, 0x1909, 0x1129,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x18e9, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a90, 0x11ec,
0x11cc, 0x11cc, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x11cc, 0x11cb, 0x11cb, 0x23f5, 0x23d5, 0x23d4, 0x23d4,
0x1bb4, 0x1bb4, 0x2394, 0x2394, 0x11cb, 0x19cb, 0x7516, 0x19ab, 0xffff,
0xcf1e, 0xe77e, 0xcf3e, 0xcf5e, 0xffff, 0x7454, 0x7453, 0x7454, 0x7454,
0x7454, 0x7453, 0x7473, 0x8473, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xae3b, 0x9e3c, 0x9e1c, 0x118a, 0x198a, 0x196b, 0x198b, 0x198b, 0x198b,
0x198b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196a, 0x196a, 0x6cf6,
0x6d36, 0x126f, 0xa6e, 0xa6e, 0xa6e, 0xa6f, 0xa6f, 0xa6e, 0xa6e,
0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x26e,
0x124e, 0x124e, 0x192a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929,
0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0x192a, 0x192a,
0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929,
0x1949, 0x7b4e, 0x734e, 0x8bf1, 0x8c10, 0x8bf0, 0xbcf4, 0xb4f4, 0x7b4e,
0x52ad, 0x190a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x18e9, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x5a91, 0x5a91, 0x6290, 0x338e, 0x11ec, 0x11cc,
0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cb, 0x19cb, 0x23d4, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4,
0x1bb4, 0x1bb4, 0x19cc, 0x11cb, 0x19cb, 0x19cb, 0x7413, 0xffff, 0xcf5f,
0xcf5f, 0xffff, 0xffff, 0x7454, 0x7454, 0x7454, 0x7454, 0x7454, 0x7454,
0x7473, 0x7453, 0xf7df, 0xffff, 0xffff, 0xffff, 0xa63c, 0xa63c, 0x9e1c,
0x118a, 0x118b, 0x118b, 0x196b, 0x196b, 0x198b, 0x198b, 0x198b, 0x198b,
0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196b, 0x196a, 0x122d, 0x126f,
0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e,
0x11ec, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929,
0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0x192a, 0x192a, 0x192a, 0x192a,
0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929, 0x1909,
0x2128, 0x734e, 0x7b4e, 0x7b4e, 0x734d, 0x732e, 0x1909, 0x190a, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x18e9, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x33ad, 0x338e, 0x11cc, 0x11cc, 0x11cc,
0x11ec, 0x11ec, 0x11ec, 0x11cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cb,
0x11cb, 0x23f4, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x1bb4, 0x1bb4, 0x23b4,
0x19cc, 0x11ac, 0x19ab, 0x19cb, 0xf7fe, 0xcf5e, 0xcf5f, 0xffff, 0xffff,
0xffff, 0x7433, 0x7453, 0x7454, 0x7454, 0x7454, 0x7454, 0x7453, 0x7453,
0x7453, 0xf7ff, 0xffff, 0x9e3c, 0xa63c, 0x9e1c, 0x12f1, 0x196b, 0x196b,
0x196b, 0x196b, 0x196b, 0x198b, 0x198b, 0x198a, 0x118a, 0x118a, 0x196b,
0x196b, 0x196b, 0x196b, 0x196b, 0x114a, 0xa8e, 0xa6f, 0xa6f, 0xa6f,
0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e, 0x124e, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x192a,
0x192a, 0x192a, 0x1909, 0x190a, 0x190a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x338e, 0x338e, 0x228d, 0x11ec, 0x11cc, 0x11ec, 0x11ec,
0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cb, 0x9ec, 0x23f5,
0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4, 0x19cb, 0x11ab,
0x19cb, 0xffff, 0xcf5e, 0xcf5e, 0xefdf, 0xffff, 0xffff, 0xffff, 0xf7ff,
0x7454, 0x7454, 0x7454, 0x7454, 0x7454, 0x7453, 0x7453, 0x7453, 0xc71e,
0x6c54, 0xa63c, 0x8e1c, 0x12d0, 0x12d0, 0x12d0, 0x196b, 0x118b, 0x196b,
0x196b, 0x196b, 0x196b, 0x198a, 0x6d37, 0x7537, 0x196b, 0x196b, 0x196b,
0x196b, 0x196b, 0x11cc, 0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e, 0x124e, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1929, 0x1129, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1109, 0x5a90, 0x6291, 0x6291,
0x6291, 0x6291, 0x5ab0, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x338e, 0x33ae, 0x33ae, 0x11ec, 0x11cc, 0x11ec, 0x11ec, 0x11ec, 0x11ec,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x2414, 0x23f5, 0x23f5, 0x23f5,
0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4, 0x19cc, 0x11ab, 0x11ab, 0xdf5e,
0xcf3e, 0xcf5e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7454, 0x7454,
0x7454, 0x7454, 0x7454, 0x7473, 0x7473, 0xcf3e, 0xa63a, 0x7cd5, 0x3331,
0x1af1, 0x12d1, 0x12d1, 0xad0, 0x12cf, 0x116b, 0x196b, 0x196b, 0x196b,
0x196b, 0x198a, 0x198a, 0x196a, 0x196a, 0x196b, 0x196b, 0x196b, 0x196b,
0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x114a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x2109, 0x6291, 0x6291, 0x6291, 0x7536,
0x6d17, 0x7517, 0x6291, 0x6291, 0x6291, 0x6291, 0x62b1, 0x338e, 0x33ae,
0x33ae, 0x33ae, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x19cc,
0x11cc, 0x11cc, 0x19ec, 0x23f5, 0x23f5, 0x23f5, 0x23f5, 0x23d5, 0x23d4,
0x23d4, 0x23d4, 0x23b4, 0x19cb, 0x11ab, 0x11aa, 0xd73e, 0xcf5e, 0xd73d,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7474, 0x7454, 0x7474,
0x7474, 0xcf3f, 0xcf3f, 0xf7ff, 0xa61b, 0x198b, 0x1ad1, 0x1af1, 0x1af1,
0x2a8e, 0x6267, 0x12d0, 0x12cf, 0x196b, 0x196b, 0x196b, 0x196b, 0x196a,
0x196b, 0x198b, 0x198b, 0x198b, 0x196b, 0x196a, 0x198a, 0x126f, 0xa8f,
0xa8f, 0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e,
0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa6e, 0x124e, 0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1149,
0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x18e9, 0x6291, 0x6291, 0x6291, 0x6557, 0x6d16, 0x6d16,
0x6291, 0x6291, 0x6291, 0x6291, 0x62b1, 0x33ad, 0x33ae, 0x33ae, 0x33ae,
0x2aed, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11cc, 0x11cc,
0xa4e, 0x1c15, 0x23f5, 0x23f5, 0x23f5, 0x23f5, 0x23d4, 0x23b4, 0x23d4,
0x23d4, 0x19cc, 0x19ac, 0x20, 0xd73e, 0xcf3e, 0xf7ff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0x7432, 0x7454, 0x7474, 0xcf3f, 0xcf5f,
0xffff, 0xffff, 0x9e3c, 0x198b, 0x198b, 0x1af1, 0x1af1, 0x6a67, 0x8a24,
0x12d0, 0x12d0, 0x1a8f, 0x196b, 0x196b, 0x196b, 0x196a, 0x196b, 0x198b,
0x198b, 0x198b, 0x196b, 0x196b, 0x196b, 0xa8f, 0xa8f, 0xa8f, 0xa8f,
0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e,
0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0x124e,
0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1129, 0x1949, 0x192a,
0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x6291, 0x6291, 0x6291, 0x6290, 0x5ab1, 0x62b1, 0x6291, 0x6291,
0x6291, 0x6291, 0x62b1, 0x5d0f, 0x338e, 0x338e, 0x338e, 0x33ad, 0x11ec,
0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11cc, 0x2415, 0x2415,
0x1c15, 0x23f5, 0x23f5, 0x23f5, 0x23d2, 0xecaf, 0xf4cf, 0xecef, 0xecee,
0xecce, 0x60, 0xd73e, 0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xa5d8, 0xcf3f, 0xcf5f, 0xdf5e, 0xffff, 0xffff,
0x9e3c, 0x198b, 0x198b, 0x198b, 0x12f1, 0x1ad0, 0x22ef, 0x12d0, 0x12d0,
0x12b0, 0x1a8f, 0x118b, 0x196b, 0x196b, 0x196b, 0x198b, 0x198b, 0x198b,
0x198b, 0x196b, 0x122d, 0x128f, 0xa8f, 0xa8f, 0xa8f, 0xa6f, 0xa6f,
0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0xa6e, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1929, 0x192a, 0x192a,
0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x6291,
0x6291, 0x6291, 0x62b1, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x62b1, 0x5d30, 0x54b1, 0x338e, 0x338e, 0x33ad, 0x338d, 0x11ec, 0x11ec,
0x11ec, 0x11ec, 0x11ec, 0x19ec, 0x2435, 0x2415, 0x2415, 0x2415, 0x23f5,
0x23f5, 0xdd31, 0xecef, 0xf4cf, 0xfccf, 0xff34, 0xff33, 0xff53, 0x40,
0xefff, 0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xcf3e, 0xcf3f, 0xcf3e, 0xcf3e, 0xffff, 0xffff, 0xf7ff, 0x9e1b, 0x198b,
0x198b, 0x11ab, 0x222e, 0x12f0, 0x12f0, 0x12d0, 0x12d0, 0x12d0, 0x1ad0,
0x1a8f, 0x118b, 0x196b, 0x196b, 0x198b, 0x198b, 0x198b, 0x198b, 0x196b,
0x126f, 0x128f, 0x128f, 0xa8f, 0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa6e, 0xa6e, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a,
0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1129, 0x1909, 0x2108, 0x1908, 0x1909, 0x18e9, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x5d0f,
0x5d0f, 0x338d, 0x338e, 0x33ad, 0x338e, 0x120a, 0x11ec, 0x11ec, 0x11ec,
0x11ed, 0x2435, 0x2435, 0x2435, 0x2415, 0x2415, 0x1c14, 0xf4ef, 0xf4cf,
0xf4ef, 0xf4cf, 0xff33, 0xff33, 0xff33, 0xff33, 0xb5d0, 0xce99, 0xcf5e,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7ff, 0xcf5e, 0xcf3e, 0xcf3e,
0xcf3f, 0xf7ff, 0xffff, 0xffff, 0xae1a, 0x5bd3, 0x198b, 0x198b, 0x198a,
0x198b, 0x12f0, 0x12f0, 0x12d0, 0x12d0, 0x12d0, 0x1ad0, 0x1ab0, 0x12af,
0x196b, 0x196b, 0x196b, 0x198b, 0x198b, 0x198b, 0x198b, 0x128f, 0x128f,
0x128f, 0xa8f, 0xa8f, 0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa2c, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x2129, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x1129, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909,
0x1909, 0x1909, 0x1929, 0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929,
0x4147, 0xbae6, 0xb306, 0x1129, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x5d0f, 0x5d0f, 0x5d0f,
0x338e, 0x33ad, 0x338d, 0x338d, 0x11ec, 0x11ec, 0x20d, 0x2456, 0x2436,
0x2436, 0x2435, 0x2415, 0x2415, 0xd511, 0xf4cf, 0xf4cf, 0xecee, 0xff34,
0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xf776, 0xd73d, 0xffff, 0xffff,
0xffff, 0xffff, 0xd75d, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf5e, 0xcf3d, 0xffff,
0xffff, 0xffff, 0x9e3c, 0x226f, 0x118b, 0x198a, 0x198a, 0x198b, 0x1a8f,
0x12f0, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x1ad0, 0x12b0, 0x12af, 0x118b,
0x196a, 0x196b, 0x198b, 0x198b, 0x196b, 0x128f, 0x128f, 0x128f, 0x128f,
0xa8f, 0xa8f, 0xa6f, 0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x26e,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0xbae5,
0x1149, 0x192a, 0x1149, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1929,
0x1929, 0x1949, 0x74b6, 0x7537, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929, 0x1109, 0xbac6,
0xbae6, 0x7247, 0x5a91, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x5d0f, 0x5d0f, 0x5d0f, 0x33cc, 0x338d,
0x338e, 0x338e, 0x33b0, 0x2476, 0x2c56, 0x2c56, 0x2c56, 0x2436, 0x2c15,
0x2c15, 0xe4f0, 0xf4ce, 0xf4cf, 0xf4ee, 0xff33, 0xff33, 0xff33, 0xff33,
0xff33, 0xff33, 0xff33, 0x20, 0xffff, 0xffff, 0xffff, 0xffff, 0xcf3e,
0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf5e, 0xffff, 0xffff, 0xffff, 0xffff,
0x9e3c, 0x1310, 0x1311, 0x12f1, 0x11ac, 0x198b, 0x19ab, 0x12d1, 0x12f0,
0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12b0, 0x12b0, 0x12b0, 0x126e, 0x198b,
0x196b, 0x196b, 0x196b, 0x1a8f, 0x128f, 0x128f, 0x128f, 0x128f, 0xa8f,
0xa6f, 0xa6e, 0xa6e, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e,
0xa6e, 0xa6e, 0xa4e, 0xa4e, 0x24e, 0xa6e, 0x116b, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0xbae6,
0x2129, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949,
0x1149, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1929, 0x1929,
0x1929, 0x328d, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x2108, 0xc2c6, 0x8205,
0x5ab0, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x338d, 0x338e, 0x338e,
0x33ae, 0x2c57, 0x2c56, 0x2c56, 0x2c56, 0x2c36, 0x2c35, 0xecee, 0xfcaf,
0xf4ef, 0xfed3, 0xff34, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33,
0xff33, 0x41, 0x20, 0xffff, 0xffff, 0xcf5f, 0xcf5e, 0xcf3e, 0xcf3e,
0xcf3e, 0xcf3e, 0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff, 0xa63c, 0x1311,
0x1311, 0x1311, 0x12f0, 0x198b, 0x2969, 0x8a24, 0x12f0, 0x12f0, 0x12d0,
0x12d0, 0x12d0, 0x12b0, 0x12b0, 0x12b0, 0x12b0, 0x12af, 0x11ed, 0x198b,
0x118b, 0x128f, 0x128f, 0x128f, 0x128f, 0x128f, 0xa8f, 0xa6f, 0x126e,
0xa6e, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa6e,
0xa4e, 0xa4e, 0xa4e, 0x116b, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x116a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1929, 0x1949,
0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1929, 0x963b, 0xaefe, 0xaefd,
0x1129, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1929, 0x1909, 0x112a, 0x1909, 0x5ab0, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5cf0, 0x33ae, 0x33ae, 0x33ad, 0x33af,
0x2c76, 0x2c56, 0x3435, 0xd534, 0xecef, 0xdcf1, 0xc4f2, 0xf4ee, 0xe50e,
0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff34, 0x840,
0x21, 0x21c8, 0xffff, 0xd73e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xa63c, 0x1b31, 0x1b11, 0x1311,
0x12f0, 0x1b10, 0x2169, 0x6aa8, 0x12f0, 0x12d0, 0x12d0, 0x12d0, 0x12d0,
0x12d0, 0x12b0, 0x12b0, 0x12af, 0x12b0, 0xaaf, 0xaaf, 0x12af, 0x12af,
0x128f, 0x128f, 0x128f, 0x128f, 0x128f, 0x128e, 0x128e, 0x1a4c, 0x4bb1,
0xc6bb, 0xd77e, 0xc71d, 0x6474, 0x122d, 0xa4e, 0xa6e, 0xa6e, 0xa6e,
0x116a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x61e6, 0x1949, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929,
0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1929, 0x192a,
0x1909, 0x1909, 0x44b6, 0x5d7a, 0x5d9a, 0x12f0, 0x659a, 0xa6be, 0x4b91,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1929, 0x7d18, 0x6d37, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x524f, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x33ad, 0x338e, 0x33ae, 0x33ae, 0x2c76, 0x2456,
0x2455, 0x2c56, 0x2456, 0x2435, 0x43f3, 0xf5f0, 0xff33, 0xff33, 0xff33,
0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33, 0xff34, 0x41, 0x41,
0x21ac, 0xd75e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xffff, 0xffff,
0xffff, 0xffff, 0xb6bc, 0x95db, 0x1b11, 0x1b11, 0x1b11, 0x12f0, 0x1b10,
0x198b, 0x11ab, 0x1af0, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12b0, 0x12b0,
0x12b0, 0x12af, 0x12af, 0x12af, 0x12af, 0xaaf, 0x128f, 0x12af, 0x128f,
0x1a4e, 0xefff, 0xefbe, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf79f, 0xf7bf, 0xf7df, 0x196a, 0x196a,
0x194a, 0x194a, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0xbb07, 0x192a, 0x3967, 0xbac7, 0x1949, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1929, 0x192a, 0x1909, 0x1909,
0xc6fd, 0x230e, 0x5d7a, 0x4cd7, 0x5d59, 0x5d7a, 0x6559, 0xa6fd, 0x969,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1129, 0x1129, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0xc2e7, 0x292a, 0x6a6f, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d10, 0x338e, 0x33ae, 0x33ad, 0x338e, 0x2c76, 0x2c56, 0x2456,
0x2436, 0x2435, 0xecee, 0xff34, 0xff33, 0xff33, 0xff33, 0xff33, 0xe52e,
0xff33, 0xff33, 0xff53, 0xfeb2, 0xecef, 0x2189, 0x19ab, 0x11cb, 0x118a,
0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf5e, 0xffff, 0xffff, 0xffff, 0xffff,
0xa63c, 0x2310, 0x1b11, 0x1b11, 0x1b11, 0x1af1, 0x11ac, 0x198b, 0x198b,
0x12f1, 0x1ad1, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12b0,
0x12b0, 0x12af, 0x12af, 0x12af, 0x1aaf, 0xdfdf, 0xf7bf, 0xefbf, 0xefbf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xefde, 0xcefd, 0xbebc,
0xb69c, 0xb67c, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0xbae6, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x2128, 0xc528, 0xbd0a, 0x2127, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x1949, 0x1949, 0x1149, 0x1949, 0x1929, 0x1909, 0x8556, 0xbe7c,
0xb63a, 0x5d99, 0x130f, 0x65ba, 0x5d9a, 0x5d9a, 0x4c95, 0xb71f, 0x1149,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929,
0x1929, 0x1909, 0x1909, 0x1909, 0x1929, 0x1929, 0x1909, 0x1909, 0x1109,
0xb2e6, 0xbae5, 0xbae5, 0x5a91, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291,
0x6291, 0x6291, 0x6291, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x33ad, 0x338e, 0x33ae, 0x2bae, 0x3475, 0x2c56, 0x2c56, 0x2436, 0x4412,
0xed0e, 0xff33, 0xff33, 0xff33, 0xff33, 0xff53, 0xeccf, 0xff33, 0xed90,
0xeccf, 0xecce, 0x1189, 0x19cc, 0x19cc, 0x19cb, 0x19cb, 0xcf3e, 0xcf3e,
0xcf3e, 0xcf3e, 0xd75e, 0xffff, 0xffff, 0xffff, 0xffff, 0xa65c, 0x1b31,
0x1b31, 0x1b11, 0x1b11, 0x11ac, 0x198b, 0x198b, 0x11cb, 0x7a46, 0x8a25,
0x12f0, 0x12d0, 0x12d0, 0x12d0, 0x12d0, 0x12b0, 0x12b0, 0x12af, 0x12af,
0xab0, 0xb6bb, 0xbebc, 0xb6bb, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xe7bf, 0xb67b, 0xbebc,
0xbebc, 0x1128, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x2106, 0x194a, 0x194a, 0x1929, 0xc4e8,
0xc4e8, 0xc4e8, 0xc4e7, 0xb529, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949,
0x1949, 0x22ce, 0x4c96, 0x7579, 0xa6df, 0x8537, 0xbe5c, 0xdf7e, 0xbe5b,
0x4bb0, 0x659a, 0x23b3, 0x659a, 0x5d7a, 0x5518, 0x96dd, 0x12cd, 0x1929,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x3126, 0x9a04,
0x7a6a, 0x5a91, 0x6291, 0x6291, 0x6291, 0x6291, 0x6291, 0x5a91, 0x5a91,
0x6290, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d10, 0x5d10, 0x338e,
0x338e, 0x33ae, 0x33ae, 0x2c56, 0x2c37, 0x43d2, 0xecef, 0xff33, 0xff33,
0xff33, 0xff33, 0xff33, 0xdced, 0xf4cf, 0xf4ee, 0x19cb, 0x11cb, 0x11cb,
0x11cb, 0x11cc, 0x19cc, 0x19cc, 0x19cc, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e,
0xf7bf, 0xffff, 0xffff, 0xffff, 0xffff, 0xa65c, 0x1b31, 0x1b11, 0x1b11,
0x11ab, 0x198b, 0x198b, 0x198b, 0x19ab, 0x8226, 0x8a24, 0x12d1, 0x12d0,
0x12d0, 0x12d0, 0x12b0, 0x12b0, 0x12b0, 0x12b0, 0x22d0, 0xb6bc, 0xb69c,
0xbebc, 0xb69b, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xe7df, 0xb69c, 0xb6bc,
0xae3a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929,
0x194a, 0x194a, 0x9267, 0x4966, 0x1949, 0x8be8, 0xc4e8, 0xc4e8, 0xc4e8,
0xc4e8, 0xc4e8, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1149, 0x114a,
0x6599, 0x6579, 0x657a, 0xa5fa, 0xbe7b, 0xef9e, 0xbe7b, 0xbebc, 0x1929,
0x2330, 0x5d9a, 0x657a, 0x1b10, 0x6d79, 0x224c, 0x1929, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1929, 0x1129, 0x1909, 0x1909, 0x1909, 0x1909, 0x5a91, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a90, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x338c, 0x338e, 0x33ae,
0x33ad, 0x3c11, 0xfcce, 0xe52e, 0xff33, 0xff33, 0xff33, 0xff33, 0xff33,
0xff33, 0x836e, 0xecef, 0x29ab, 0x11cb, 0x11cc, 0x11cc, 0x11cc, 0x11cc,
0x19cc, 0x11cc, 0x19cc, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xa61c, 0x1331, 0x118b, 0x198b, 0x198b, 0x198b,
0x198b, 0x198b, 0x198b, 0x19ab, 0x1b10, 0x12f0, 0xad0, 0x12d0, 0x12d0,
0x12d0, 0x1ab0, 0x12b0, 0xaebd, 0xb69b, 0xb6bc, 0xb6bc, 0xb6bc, 0xbebb,
0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xe7bf, 0xb6bb, 0xbebc, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0xb2e5, 0x3147, 0x194a,
0x1149, 0x1949, 0x1949, 0x93a7, 0xc507, 0xc4e8, 0xc4e8, 0xc4e8, 0xbce8,
0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1149, 0x1109, 0x6599,
0x7dd9, 0x8557, 0xbe7c, 0xe7be, 0xbe7c, 0xcf3e, 0x1929, 0x1129, 0x1129,
0x22ee, 0x1129, 0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x5a91, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a90, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d10, 0x338e, 0x33ae, 0xeccf, 0xff13,
0xff33, 0xff33, 0xff13, 0xff33, 0xff33, 0xff33, 0xff33, 0xf610, 0x19ed,
0x21c9, 0x19ac, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc, 0x11cc,
0x19cc, 0xc6fd, 0xcf3e, 0xcf3e, 0xcf3e, 0xffff, 0xffff, 0xffff, 0xffff,
0xcf3d, 0xae3d, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b,
0x198b, 0x198b, 0x11ab, 0x1af1, 0x8a25, 0x12d0, 0x12d0, 0x12d0, 0x1aaf,
0xb6fd, 0xbe9c, 0xb6bb, 0xb6bc, 0xb6bc, 0xdf5e, 0xefbf, 0xf79f, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefdf,
0xc6db, 0x9d96, 0x9d96, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x7cb5, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194b, 0x194a, 0x194a, 0x194a, 0x1949, 0x194a,
0x1949, 0x1949, 0x9386, 0x9384, 0xbcc9, 0x9385, 0x2987, 0x194a, 0x194a,
0x1929, 0x1949, 0x1949, 0x1949, 0x1149, 0x1929, 0x11cb, 0xc77f, 0xbebc,
0xbe7b, 0xbe7b, 0xbe7b, 0xd77f, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x18e9, 0x5a91, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a90, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d2f, 0x5d0f, 0x5d0f, 0x3c0d, 0xbcf2, 0xf692, 0xff54, 0xf631, 0xf50e,
0xed0e, 0xed8f, 0xf631, 0xf590, 0xecae, 0x11eb, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11aa,
0xcf3e, 0xcf3e, 0xcf3e, 0xefdf, 0xffff, 0xffff, 0xffff, 0xa63b, 0x222d,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x19ab,
0x19ab, 0x198a, 0x3aad, 0x12d0, 0x12d0, 0x12d0, 0xa69d, 0xb6bb, 0xb6bb,
0xb69c, 0xb69b, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0x9d97, 0xefdf, 0xefdf, 0xcf1d,
0x9598, 0x536f, 0x5350, 0x534f, 0xa5f8, 0xefdf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xefbf, 0xf7bf, 0xefbf, 0x192a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x112a, 0xbae6, 0x20e6, 0x1949, 0x1949,
0x192a, 0x2947, 0x4988, 0x194a, 0x1949, 0x194a, 0x194a, 0x194a, 0x1949,
0x1949, 0x1949, 0x1949, 0x1929, 0x1149, 0x1a6d, 0x8dda, 0xc6dd, 0xbe7b,
0xbe7b, 0xd79f, 0x1929, 0x1929, 0x1929, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x18e9, 0x5a91, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a90, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f,
0x5d2f, 0x5d2f, 0xf4ee, 0xed6f, 0xd4d0, 0x338e, 0x2c56, 0x2c36, 0x2436,
0x2c36, 0x2435, 0x11ec, 0x11ec, 0x11cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cb, 0xcf3e, 0xcf3e,
0xcf3e, 0xd73e, 0xffff, 0xffff, 0xffff, 0xa63c, 0x19cb, 0x19ab, 0x19ab,
0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x198b, 0x2989, 0x8a25, 0x198b,
0x198b, 0x12d0, 0x12d0, 0x5433, 0xb69c, 0xbebc, 0xbebb, 0xe7bf, 0xefbf,
0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf,
0xf7bf, 0xefbf, 0x9d97, 0xefdf, 0xefdf, 0xcedb, 0x4b4f, 0x5370, 0x5370,
0x4b70, 0x5370, 0x5370, 0x536f, 0xdf7e, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xf7bf, 0xf7bf, 0xefbf, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x114a, 0x8246, 0x7248, 0x1949, 0x1949, 0x1949, 0x1949,
0x1149, 0x1149, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x1949, 0x1949, 0x22cf, 0x6579, 0x5d59, 0x1310, 0x8e1b,
0x19eb, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5a91,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a70,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f, 0x5d2f, 0x5d0f,
0xed0f, 0xe4f0, 0x33ae, 0x33ae, 0x2c56, 0x2c56, 0x2456, 0x2436, 0x2436,
0x11ec, 0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19ec, 0xcf3e, 0xcf3e, 0xcf3e, 0xcf3e,
0xffff, 0xffff, 0xffff, 0xa63c, 0x11cb, 0x19ac, 0x19ac, 0x19ac, 0x198b,
0x198b, 0x198b, 0x198b, 0x19ac, 0x19ab, 0x3967, 0x19ab, 0x198b, 0x11ab,
0x12d0, 0xbebb, 0xb6bb, 0xbebb, 0xefdf, 0xa5b7, 0x6c12, 0x5370, 0x5bd0,
0x9db7, 0x9d76, 0xe7bf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf,
0xa5b7, 0xefbf, 0xefbf, 0x9db7, 0x5370, 0x5370, 0x5370, 0x4b70, 0x5370,
0x5370, 0x5370, 0x536f, 0xe7bf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xefff, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x114a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929,
0x1949, 0x1949, 0x1129, 0x949, 0x1129, 0x1909, 0x1929, 0x1909, 0x192a,
0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a70, 0x5a70, 0x5a70, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d2f, 0x554f, 0x5d2f, 0x652f, 0xf4cf, 0xf4f0, 0x33ad,
0x338e, 0x33ae, 0x2bad, 0x2c56, 0x2456, 0x2456, 0x2435, 0x11ec, 0x11ec,
0x11ec, 0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x19cc, 0x19cc, 0x11cb, 0xcf5e, 0xcf3e, 0xcf3e, 0xcf3e, 0xdf3d, 0xffff,
0xae3b, 0xa61c, 0x11cb, 0x19ac, 0x19ac, 0x19ac, 0x198b, 0x198b, 0x198b,
0x198b, 0x19ab, 0x19aa, 0x8a24, 0x19ab, 0x198b, 0x118b, 0xb6bc, 0xb6bc,
0xb6bc, 0xb69b, 0x9557, 0x5370, 0x4b70, 0x4b70, 0x4b70, 0x9597, 0xefbf,
0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefdf, 0xefbf,
0xefbf, 0x9d97, 0x5390, 0x4b70, 0x4b70, 0x4b70, 0x5370, 0x5370, 0x5370,
0x5370, 0x9dd8, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf,
0x8cd5, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949,
0x1949, 0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909,
0x1909, 0x1909, 0x192a, 0x8a6a, 0xb306, 0x2907, 0x190a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a70, 0x5a70, 0x5a70, 0x5d0f, 0x5d0f, 0x5d0f, 0x5530,
0xbd2f, 0xecee, 0xeccf, 0xf4af, 0xa50f, 0x5d0f, 0x4cae, 0x33ae, 0x33ae,
0x2bae, 0x2c56, 0x2c56, 0x2456, 0x2455, 0x120d, 0x19cc, 0x11ec, 0x11ec,
0x11ec, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc,
0x11cc, 0xcf3f, 0xcf3e, 0xcf3e, 0xcf5e, 0xcf5e, 0xa61c, 0xa63c, 0x19cb,
0x11ab, 0x11ab, 0x198b, 0x19ac, 0x198b, 0x198b, 0x198b, 0x198b, 0x19ab,
0x19ab, 0x19ab, 0x19ab, 0x19ab, 0x9597, 0xb6bc, 0xb6bc, 0xb6bb, 0x9598,
0x5390, 0x5370, 0x4b70, 0x4b70, 0x4b6f, 0x9d96, 0xefdf, 0xefbf, 0xe7bf,
0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xe79f,
0x9db8, 0x9598, 0x5370, 0x5390, 0x4b70, 0x4b70, 0x4b70, 0x536f, 0x9d96,
0xf7bf, 0xf7bf, 0xefbf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x1948, 0x114a, 0x194a, 0x194a, 0x194a, 0xaae7, 0xa2e7, 0x1949, 0x194a,
0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1929,
0x7a06, 0xbae6, 0xbac6, 0xbae5, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x212b, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5d0f, 0x5d0f, 0x5d0f, 0xe510, 0xecd0, 0x5550,
0x5d2f, 0x5d30, 0x5d10, 0x5d0f, 0x5d2f, 0x33ad, 0x33ae, 0x33ad, 0x2bae,
0x2456, 0x2456, 0x2456, 0x2c36, 0x11ec, 0x11ec, 0x11ec, 0x11ec, 0x11cc,
0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x11cc, 0x2a4c,
0xcf3e, 0xcf3e, 0xcf5f, 0x9e1b, 0x4330, 0x11cb, 0x11cb, 0x11ab, 0x11cb,
0x11cb, 0x6d37, 0x4b71, 0x198b, 0x198b, 0x198b, 0x19ab, 0x19ab, 0x430f,
0x9d97, 0x9dd8, 0xb69b, 0xb6bc, 0xb6bc, 0xb6bb, 0x5370, 0x5370, 0x5370,
0x4b70, 0x4b70, 0x95b8, 0xefbf, 0x9d96, 0xefdf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0x9d97, 0x9d97,
0x9d97, 0x9db7, 0x9db7, 0x9d98, 0x9d98, 0x9db7, 0xe7df, 0xefbf, 0xefbf,
0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xefdf, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x114a, 0x194a, 0x194a, 0x194a, 0xc2c6, 0xbae6,
0x194a, 0x194a, 0x194a, 0x114a, 0x1928, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1929, 0x1949, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929,
0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1929, 0x9224, 0xbae5,
0xbac6, 0xbae7, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x39ee,
0x5a70, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5d0f, 0x5d30, 0xecf0, 0x650e, 0x554f, 0x5d2f, 0x5d2f, 0x5d0f,
0x5d2f, 0x5d2f, 0x5d2f, 0x4c6e, 0x33ae, 0x338d, 0x338d, 0x2c56, 0x2456,
0x2456, 0x2435, 0x2c15, 0x11ed, 0x11ed, 0x120e, 0x2b93, 0x23f4, 0x23f4,
0x23d4, 0x23b4, 0x23d4, 0x2b93, 0x11cc, 0x19cc, 0x19cb, 0xcf3f, 0xc71f,
0xa63c, 0x220c, 0x11cb, 0x11cb, 0x11ab, 0x11ab, 0x11cb, 0x11cb, 0x7517,
0x11ca, 0x198b, 0x198b, 0x19ab, 0x9db8, 0x9db8, 0x9db7, 0x9db7, 0x9db8,
0xb69c, 0xb69c, 0xb69c, 0x9db8, 0x5370, 0x5370, 0x5370, 0x536f, 0x9dd8,
0xd73d, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xefbf, 0x9d97, 0x9d97, 0x9d97,
0x9d97, 0x9db7, 0x9d97, 0xcf1c, 0xefdf, 0xdf9e, 0xefbf, 0xf7bf, 0xf7bf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x1949, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0xab08, 0xf718, 0xffff, 0xf7bf,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949,
0x1149, 0x1169, 0x1949, 0x1929, 0x1929, 0x1929, 0x1929, 0x1929, 0x192a,
0x192a, 0x192a, 0x192a, 0x192a, 0x112a, 0x4987, 0x8a44, 0x9223, 0x3967,
0x1929, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5a70, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5d10,
0xcd10, 0x5d0f, 0x5d2f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f,
0x5d2f, 0x5d10, 0x33ae, 0x338e, 0x338e, 0x33f2, 0x2c56, 0x2436, 0x2436,
0x2436, 0x2416, 0x2415, 0x1c15, 0x1c15, 0x23f5, 0x23d5, 0x23d5, 0x23d4,
0x23d4, 0x23b4, 0x1b94, 0x2351, 0x11cb, 0xa63c, 0x6435, 0x19cb, 0x19cc,
0x11cb, 0x11cb, 0x11ab, 0x11ab, 0x11cb, 0x11cb, 0x11ab, 0x19ab, 0x19ab,
0x19ab, 0x198b, 0x19aa, 0x9db7, 0x9db7, 0x9db7, 0x9db8, 0xb69c, 0xb69c,
0x9db7, 0x9db7, 0x5390, 0x6c72, 0x9db7, 0x9d96, 0xefdf, 0xefbf, 0xefbf,
0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf,
0xefbf, 0x9d96, 0xefbf, 0xefbf, 0xefbe, 0xefdf, 0xefdf, 0xefbf, 0xefdf,
0xefbf, 0xefdf, 0xefdf, 0xbebc, 0xefbf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0xf7bf, 0x9db7, 0xadd7, 0xffff, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0x1929, 0x7516,
0x7d17, 0x1929, 0x1929, 0x1929, 0x1929, 0x1949, 0x1929, 0x192a, 0x192a,
0x192a, 0x192a, 0x1929, 0x1929, 0x192a, 0x190a, 0x190a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x5291, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a70, 0x6d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x3c0d, 0x33ae, 0x33ae, 0x2bad, 0x2c56, 0x2c36, 0x2c36, 0x2c36, 0x2436,
0x2c36, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4,
0x1bd4, 0x1bd3, 0x23b3, 0x19cc, 0x19cc, 0x19cc, 0x19cc, 0x19cb, 0x19cb,
0x19cb, 0x11ab, 0x11ab, 0x11ab, 0x11ab, 0x19cb, 0x19ab, 0x19ab, 0x19ab,
0x11cb, 0x9db7, 0x9db7, 0x9db7, 0xae5a, 0xb69c, 0xb67b, 0xbe9b, 0x9d97,
0xbe9b, 0xb69b, 0xdfbf, 0xa5b7, 0xc6bb, 0x9d76, 0xadd7, 0xefbf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefdf, 0xe7bf,
0xa5b7, 0xefdf, 0xefdf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xefbf,
0xbe9b, 0xd75d, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x192a, 0xffdf, 0x21ca, 0x1949, 0x1929, 0x1949, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0x1149, 0x1949, 0x1149, 0x1929,
0x1929, 0x1929, 0x1929, 0x1949, 0x1129, 0x192a, 0x192a, 0x192a, 0x192a,
0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x5a70, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71, 0x5a71,
0x5a71, 0x5a70, 0x5a70, 0x5a70, 0x5d2f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d10, 0x33ae,
0x33ae, 0x33ae, 0x2c56, 0x2c36, 0x2c36, 0x2c36, 0x2436, 0x2436, 0x2415,
0x2415, 0x2415, 0x2bf5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bd4,
0x1bb3, 0x23b3, 0x11cc, 0x19cc, 0x19cc, 0x19cb, 0x19cb, 0x19cb, 0x11ab,
0x11ab, 0x11ab, 0x11ab, 0x11ab, 0x19ab, 0x19ab, 0x19cb, 0x19ab, 0x9db7,
0x9db7, 0x9d97, 0xb69c, 0xb69c, 0xae5b, 0xbe9c, 0x9db8, 0xb67b, 0xbe9b,
0xefdf, 0xefbf, 0xefbf, 0xefdf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xefff, 0x9db7,
0xa596, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf,
0x9d36, 0x194a, 0x1949, 0x1949, 0x114a, 0x194a, 0x2149, 0x8432, 0xef9e,
0x94d5, 0x1949, 0x1969, 0x1949, 0x1949, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x1949, 0x1949, 0x1149, 0x1949, 0x1929, 0x1929, 0x1929,
0x1929, 0x1949, 0x1949, 0x1949, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0xab08, 0x190a, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70,
0x5a70, 0x5a70, 0x7592, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d2f, 0x6510, 0x5d30, 0x5d10, 0x5d0f, 0x33ad, 0x33ae, 0x338e,
0x2bae, 0x2c56, 0x2c36, 0x2c36, 0x2c36, 0x2436, 0x2436, 0x2415, 0x1c15,
0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x1bd4, 0x1bb4, 0x1bb4,
0x2394, 0x11cb, 0x19cc, 0x19cc, 0x19cc, 0x19cb, 0x19cb, 0x11ab, 0x11ab,
0x11ab, 0x11ab, 0x19cb, 0x19cb, 0x19cb, 0x19ab, 0x9db8, 0x9db7, 0x9d97,
0xb69c, 0xb69c, 0xb69c, 0xae5a, 0x9db8, 0xb69b, 0xae3a, 0xb618, 0xef9f,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xffff, 0xe77e,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xbd09,
0xd588, 0xcdac, 0xb5d8, 0x1949, 0x194a, 0x1968, 0x9ae9, 0x1929, 0x1949,
0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0x1929, 0x1929, 0x1929, 0x1909,
0x424f, 0x5290, 0x5270, 0x4a6f, 0x1929, 0x1909, 0x192a, 0x192a, 0x1909,
0x1909, 0x1909, 0x1929, 0x3126, 0xbb05, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x5a70, 0x5a70,
0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5a70, 0x5270, 0x5270,
0x95f7, 0x5d0f, 0x5d10, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f,
0x7574, 0x95f7, 0x95f7, 0x95f7, 0x64f0, 0x33ae, 0x338e, 0x3b8e, 0x2c56,
0x2c36, 0x2c36, 0x2c36, 0x2436, 0x2436, 0x2415, 0x2415, 0x23f5, 0x23f5,
0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x2394, 0x2393, 0x2393,
0x11cc, 0x11cb, 0x19cc, 0x19cb, 0x19cb, 0x11ab, 0x11ab, 0x11ab, 0x11ab,
0x11cb, 0x19cb, 0x19cb, 0x19ab, 0x198b, 0x9578, 0x9d98, 0xb69c, 0xb69c,
0xb69c, 0xae19, 0xae3a, 0xb69c, 0xb6bc, 0xefdf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xe7bf, 0xefbf, 0xefbf, 0xefbf, 0x95b6, 0xefbe, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xcd28, 0xddc9, 0xf669,
0xe68c, 0xefdf, 0x194a, 0x41a6, 0xc2c6, 0xaae6, 0x1949, 0x194a, 0x194a,
0x194a, 0x194a, 0x1929, 0x1929, 0x194a, 0x526f, 0x5270, 0x5270, 0x526f,
0x526f, 0x526f, 0x526f, 0x5a70, 0x31cc, 0x1929, 0x1909, 0x1909, 0x1909,
0x1929, 0x1149, 0x1909, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5270, 0x5a50, 0x5a50, 0x5a50,
0x5a50, 0x5a50, 0x5a50, 0x5a50, 0x5270, 0x5270, 0x5270, 0x95f7, 0x64f0,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x85b5, 0x8df7, 0x95f7,
0x95f7, 0x95f7, 0x8df7, 0x33ae, 0x338e, 0x33ae, 0x3453, 0x2c36, 0x2c36,
0x2c36, 0x2436, 0x2436, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x23d5, 0x23d5,
0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4, 0x1b93, 0x2393, 0x2372, 0x19cc,
0x19cc, 0x19cc, 0x19cb, 0x19cb, 0x19cb, 0x11ab, 0x11ab, 0x11ab, 0x11ab,
0x19ab, 0x19ab, 0x19ab, 0x198c, 0xa5da, 0xb69c, 0xb69c, 0xb69c, 0xbebc,
0xae5a, 0xae5a, 0xb6bc, 0xb6dc, 0xe7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xbe9b,
0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0x1929, 0x194a, 0x9d76, 0xffff, 0xffff,
0xffff, 0xffff, 0xffff, 0xfffe, 0xc508, 0xdda9, 0xe609, 0xede9, 0xffff,
0x194a, 0x1949, 0x7a46, 0x1969, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x1929, 0x192a, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270, 0x5270,
0x5270, 0x526f, 0x5270, 0x5270, 0x210a, 0x1909, 0x1909, 0x1929, 0xb2e8,
0xc2e6, 0x7249, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x214a, 0x5270, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250,
0x5250, 0x5250, 0x5270, 0x5270, 0x5270, 0x95f7, 0x9618, 0x5d10, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x85d5, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x9618, 0x338e, 0x338e, 0x33ae, 0x2c36, 0x2c36, 0x2c36, 0x2c36,
0x2436, 0x2415, 0x2415, 0x2415, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4,
0x23d4, 0x1bd4, 0x1bb4, 0x23b4, 0x2394, 0x2373, 0x2b73, 0x11cc, 0x19cc,
0x19cb, 0x19cb, 0x19cb, 0x11ab, 0x11ab, 0x11ab, 0x11ab, 0x11ab, 0x19ab,
0x19ab, 0x19ab, 0x21cb, 0xbe9c, 0xb69c, 0xb69c, 0xb6bc, 0x9dd8, 0x95b7,
0xb6bc, 0xb6bb, 0xb69b, 0xbe9b, 0xefdf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xefbf, 0xcefc, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xefbf, 0xdf5e, 0x9d97, 0xefdf, 0xefbf, 0xefbf, 0xb69b, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0x6390, 0x1929, 0xa575, 0xffff, 0xffff, 0xffff, 0xffff,
0xffff, 0xffff, 0xb4a7, 0xc528, 0xd589, 0xd568, 0xffdf, 0x1949, 0x1949,
0x1949, 0x194a, 0xbac6, 0x61c7, 0x194a, 0x194a, 0x194a, 0x192a, 0x524f,
0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x5250,
0x524f, 0x526f, 0x524f, 0x1909, 0xb2c5, 0x190a, 0xbae6, 0xc2e6, 0xbae6,
0x190a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929,
0x524f, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250,
0x5250, 0x5250, 0x526f, 0x95f7, 0x95f7, 0x8df6, 0x5d2f, 0x5d0f, 0x5d2f,
0x8e16, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x33ae, 0x33ae, 0x33ae, 0x2c56, 0x2c56, 0x2c36, 0x2c36, 0x2c36, 0x2436,
0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4,
0x1bb4, 0x23b4, 0x2394, 0x2393, 0x2393, 0x2392, 0x19cc, 0x19cc, 0x19cb,
0x19cb, 0x19cb, 0x11ab, 0x11ab, 0x11ab, 0x11ab, 0x19ab, 0x19ab, 0x19ab,
0x198b, 0xb69c, 0xb69c, 0xb69c, 0xb6bc, 0xbebc, 0xb69c, 0xb69c, 0xb69c,
0xb69c, 0xb6bc, 0xb69c, 0xc6bc, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf,
0xefbf, 0xe7bf, 0xb639, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefdf, 0x9db7, 0x9d97,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xbe7a, 0xefbf, 0xcedb, 0xefbf, 0xffff,
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0xfffd, 0xa469, 0xef58, 0xf7ff, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949,
0x9265, 0x194a, 0x194a, 0x194a, 0x194a, 0x524f, 0x524f, 0x524f, 0x524f,
0x524f, 0x524f, 0x5270, 0x524f, 0x294b, 0x1929, 0x1929, 0x1909, 0x192a,
0x192a, 0x524f, 0x9aea, 0x1149, 0x3926, 0xc2c6, 0x8226, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5250, 0x5250,
0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250,
0x524f, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x8df7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x43ce, 0x338e,
0x33ae, 0x2c12, 0x2c56, 0x2c36, 0x2436, 0x2436, 0x2436, 0x2415, 0x2415,
0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4,
0x23b4, 0x2393, 0x2393, 0x1b93, 0x1b72, 0xa2e, 0x11cb, 0x19cc, 0x11cc,
0x11cc, 0x11cb, 0x11cb, 0x19cb, 0x19cc, 0x9ab, 0x22d0, 0x1b11, 0x5495,
0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb69c,
0xb69c, 0xb6bc, 0xb6bb, 0xb6bb, 0xefdf, 0xefbf, 0xf7bf, 0xefbf, 0xefbf,
0x9d97, 0xefdf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0x9d96, 0x9db7, 0xefdf, 0xdf5d, 0xefbf,
0xefbf, 0xefbf, 0xefdf, 0xefdf, 0xefbf, 0xefdf, 0xa576, 0x9d96, 0xe75d,
0xffff, 0xffff, 0xffff, 0xf7ff, 0xa597, 0xffff, 0xffff, 0xbe39, 0xa5b7,
0x29ca, 0x1949, 0x194a, 0x194a, 0x1949, 0x1949, 0x194a, 0x194a, 0x194a,
0x194a, 0x192a, 0x526f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f, 0x524f,
0x4a4f, 0x192a, 0x1929, 0x1929, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a,
0x192a, 0x1929, 0x1929, 0x1929, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x5250, 0x5250, 0x5250, 0x5250,
0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x524f, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x8e18, 0x338e, 0x338e, 0x338e,
0x2c56, 0x2c56, 0x2c36, 0x2c36, 0x2436, 0x2415, 0x2415, 0x2415, 0x23f5,
0x2bf5, 0x23d5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b4, 0x2393,
0x1b93, 0x1b93, 0x1b93, 0x1b92, 0x1b72, 0x1b72, 0x1b72, 0x1b52, 0x1352,
0x1b32, 0x1352, 0x1331, 0x1b32, 0x1b32, 0x1b11, 0x1b0f, 0xb69c, 0xb69c,
0xb69c, 0xb69c, 0xb6bc, 0x95b8, 0xbebc, 0xb6bc, 0xbebc, 0xb6bc, 0xb6bc,
0xb6bc, 0xb69c, 0xb69b, 0xefbf, 0xefbf, 0xefdf, 0xefbf, 0x9db7, 0x9d96,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf,
0xefbf, 0xefdf, 0x9d97, 0xefdf, 0xefbf, 0xefdf, 0xadd7, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xa597, 0xefbf, 0xf7df, 0x1149, 0x1149, 0x7454,
0x9d98, 0x9d98, 0x9d98, 0xffff, 0xffff, 0x7517, 0x194a, 0x194a, 0x194a,
0x3147, 0xbae6, 0x8268, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x114a,
0x524f, 0x524f, 0x522f, 0x524f, 0x5250, 0x524f, 0x5270, 0x1929, 0x1929,
0x1929, 0x1949, 0x1149, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x192a,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x524f, 0x5250, 0x5250, 0x5250, 0x5250, 0x5250,
0x5250, 0x5250, 0x5250, 0x5250, 0x5250, 0x524f, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x33ae, 0x338e, 0x338e, 0x2c56, 0x2c56,
0x2c36, 0x2c36, 0x2c36, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5,
0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x23d4, 0x23b4, 0x23b3, 0x2393, 0x2393,
0x1b93, 0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1352, 0x1b52, 0x1b32,
0x1332, 0x1b32, 0x1b32, 0x1b11, 0x1311, 0xb69c, 0xb69c, 0xb69c, 0xb69c,
0xb6bc, 0xb6bc, 0xb6bc, 0xb69b, 0x9db7, 0xbebc, 0xb6bc, 0xb69b, 0x9db8,
0x9db7, 0x9596, 0x9db6, 0xadf7, 0xefbf, 0xa597, 0xbe5a, 0xf7bf, 0xf7bf,
0xefbf, 0xf7bf, 0xf7bf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xd73d,
0x9d55, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xcefc, 0xa597, 0x9d97,
0xb639, 0xa5b7, 0xefbf, 0xd75e, 0x196a, 0x196a, 0x196a, 0x196a, 0x114a,
0x114a, 0xffff, 0xffff, 0x1149, 0x194a, 0x194a, 0x194a, 0x2128, 0xc2e5,
0xbae5, 0x4966, 0x194a, 0x194a, 0x194a, 0x194a, 0x4a4e, 0xa2e9, 0xbae5,
0x4a4f, 0x4a4f, 0x524f, 0x4a4f, 0x1949, 0x1929, 0x1929, 0x1929, 0x1949,
0x1949, 0x1949, 0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929,
0x4a4f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f,
0x522f, 0x522f, 0x522f, 0x4a4f, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x7d95, 0x338e, 0x338e, 0x3433, 0x2c56, 0x2c36, 0x2c36,
0x2c36, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23d4,
0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b3, 0x2393, 0x2393, 0x1b93, 0x1b93,
0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1352, 0x1b52, 0x1b32, 0x1b32, 0x1b32,
0x1b32, 0x1b11, 0x12f0, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xb6bc, 0xb6bc,
0xb6bc, 0xb69b, 0x9db8, 0xb6bc, 0xb69b, 0xb69b, 0xb69b, 0xb69b, 0xf7bf,
0xefbf, 0xefdf, 0xefbf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0x9d96, 0x9d76,
0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xa596, 0xefdf, 0xefbf,
0xefbf, 0xefbf, 0xe7bf, 0x9db7, 0x5390, 0x4b70, 0x4b90, 0x8d56, 0xae18,
0x9d96, 0x9d78, 0xa5d8, 0x8d16, 0x198a, 0x114a, 0x114a, 0x114a, 0x9d76,
0xffff, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x7a26, 0xbae5, 0x8247,
0x1949, 0x194a, 0x194a, 0x194a, 0x4a4f, 0xaae7, 0xacb0, 0xa578, 0xadf8,
0xefdf, 0xefbf, 0x192a, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949,
0x1929, 0x192a, 0x192a, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1929, 0x524f, 0x522f,
0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f,
0x522f, 0x4a4f, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f8, 0x338e, 0x338e, 0x33ae, 0x2c56, 0x2c36, 0x2c36, 0x2436, 0x2435,
0x2415, 0x2415, 0x2415, 0x23f5, 0x23d5, 0x23d5, 0x23d5, 0x23d4, 0x23d4,
0x23d4, 0x1bb4, 0x1bb4, 0x2393, 0x2393, 0x2393, 0x1b93, 0x1b73, 0x1b73,
0x1b73, 0x1b52, 0x1352, 0x1352, 0x1b32, 0x1b32, 0x1332, 0x1b12, 0x1b11,
0x2311, 0xb6bc, 0xb69c, 0xb69c, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc, 0x9dd8,
0xb67b, 0xb69b, 0xb6bc, 0xbebc, 0x9db7, 0x9598, 0x9db7, 0x9db7, 0x9db6,
0x9d97, 0xa5b7, 0xefdf, 0xefdf, 0xefbf, 0xefbf, 0xefdf, 0xefbf, 0xf7bf,
0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xa5b7, 0xefbf, 0xefbf, 0xefbf, 0xefdf,
0x9d97, 0x536f, 0x5370, 0x4b70, 0x4b70, 0x536f, 0xefbf, 0xefbe, 0x24e,
0x122f, 0x98b, 0x196a, 0x1128, 0x42cf, 0x84f6, 0x9d98, 0x9d97, 0x9d76,
0x9d97, 0xa598, 0xa598, 0x9d97, 0x9db7, 0x9d97, 0xa598, 0x9d57, 0xefbf,
0xefdf, 0xf7bf, 0xefbf, 0xefdf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefdf, 0x1929, 0x1929, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0xb2c6,
0x2128, 0x1929, 0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x1909, 0x1909, 0x192a, 0x420e, 0x4a4f, 0x522f, 0x522f, 0x522f,
0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x522f, 0x4a4f,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f8, 0x338e,
0x338e, 0x33ae, 0x2c56, 0x2c56, 0x2c36, 0x2c36, 0x2436, 0x2415, 0x2415,
0x2415, 0x2415, 0x23f5, 0x2bd5, 0x23f5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4,
0x1bb4, 0x1b93, 0x2393, 0x2393, 0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b73,
0x1352, 0x1352, 0x1b52, 0x1b32, 0x1331, 0x1b31, 0x1b31, 0x1b11, 0x6cf7,
0xb69c, 0xb69c, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc, 0x9db8, 0xb6bc, 0xbebc,
0xbebb, 0x9597, 0x536f, 0x5370, 0x5370, 0x5370, 0x4b50, 0x536f, 0x9db7,
0x9db7, 0xdf7e, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf,
0xefbf, 0xefbf, 0xae18, 0xefbf, 0xefbf, 0xefbf, 0xa5b7, 0x9db8, 0x5370,
0x5370, 0x5370, 0x4b6f, 0x9d97, 0xefbf, 0xefbe, 0xa4e, 0xa4e, 0x124e,
0x118a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0xadd8, 0x9d98, 0x194a,
0x194a, 0x1969, 0x1949, 0x194a, 0x192a, 0xefdf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x1929,
0x1929, 0x1929, 0x1149, 0x20e6, 0x192a, 0x114a, 0xbae5, 0x9ae8, 0x1929,
0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909,
0x1909, 0x192a, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f,
0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x6d14, 0x338e, 0x33ae,
0x2c56, 0x2c56, 0x2c56, 0x2c36, 0x2436, 0x2435, 0x2435, 0x2415, 0x2415,
0x23f5, 0x23f5, 0x23f5, 0x23f4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b4,
0x2394, 0x2393, 0x2393, 0x1b73, 0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1352,
0x1b52, 0x1b52, 0x1351, 0x1b31, 0x1b31, 0x1b12, 0x1af1, 0xb69c, 0xb69c,
0xb69c, 0xbebc, 0x95b8, 0xbebc, 0x9d97, 0xb69b, 0xbebc, 0x9dd8, 0x4b4f,
0x5370, 0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x5370, 0x9db7, 0x9d97,
0xefbf, 0xefbf, 0xefbf, 0xa596, 0xd73d, 0xefbf, 0xf7bf, 0xefbf, 0xefbf,
0xefdf, 0xefbf, 0xefbf, 0xefbf, 0x9d97, 0x5350, 0x5370, 0x5370, 0x5370,
0x5390, 0xefdf, 0xefdf, 0xefff, 0xa6e, 0xa6e, 0x124e, 0x124e, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x196a, 0x1949, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0x1929, 0x1929, 0x1929,
0x194a, 0xbae5, 0x1949, 0x1949, 0x1929, 0x114a, 0x1929, 0x192a, 0x192a,
0x192a, 0x192a, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x1909, 0x39ed,
0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f,
0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x338e, 0x338e, 0x33af, 0x2c56,
0x2c56, 0x2c36, 0x2436, 0x2435, 0x2435, 0x2415, 0x2415, 0x2415, 0x23f5,
0x23f5, 0x23f4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4, 0x1bb4, 0x2393,
0x2393, 0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1352, 0x1352,
0x1b51, 0x1b51, 0x1b31, 0x1b31, 0x1b11, 0xbebc, 0xb69c, 0xb69c, 0xb69b,
0x9dd8, 0xb6bc, 0x9db8, 0xb69b, 0xbebc, 0x9db8, 0x5370, 0x4b70, 0x4b70,
0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x4b6f, 0x9db8, 0xefbf, 0xefbf,
0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0x9d76, 0x9d96,
0xbe5a, 0xc69b, 0x9db7, 0x536f, 0x5370, 0x5370, 0x4b70, 0x7cb4, 0xefbf,
0xefbf, 0xa4d, 0xa6e, 0xa6e, 0x122e, 0x124e, 0x122d, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x192a, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x194a, 0x194a, 0x1929, 0x1949, 0x1929,
0x114b, 0x1949, 0x1149, 0x1149, 0x192a, 0x192a, 0x190a, 0x39a6, 0x59e6,
0x5204, 0x5206, 0x2967, 0x2109, 0x192a, 0x1909, 0x4a2f, 0x4a2f, 0x4a2f,
0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f, 0x4a2f,
0x4a2f, 0x4a2f, 0x4a2f, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x9617, 0x2bae, 0x338e, 0x33ae, 0x2c56, 0x2c56, 0x2c36,
0x2c56, 0x2435, 0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23f4,
0x23d4, 0x23d4, 0x23d4, 0x23b4, 0x1bb4, 0x2394, 0x2394, 0x2393, 0x1b93,
0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b53, 0x1b52, 0x1b52, 0x1b52, 0x1b32,
0x1b32, 0x1b12, 0x1b11, 0x43f3, 0xb6bb, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc,
0x9db8, 0xb6bc, 0xbebc, 0xb69b, 0x5370, 0x4b70, 0x4b70, 0x4b70, 0x4b70,
0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x534f, 0xd6fc, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0x9db7,
0x9597, 0x5370, 0x5370, 0x5370, 0x536f, 0xdf5d, 0xefbf, 0xefbf, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0x124e, 0x122e, 0x114a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0x1127,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xc6bc, 0x194a, 0x194a, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949,
0x1149, 0x1149, 0x1149, 0x59c5, 0xed8c, 0xed8c, 0xc40a, 0xc40a, 0xc40a,
0xc40a, 0xc40a, 0x59e4, 0x4a30, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f,
0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f,
0x4a2e, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x8df7, 0x338d, 0x338e, 0x33ce, 0x2c77, 0x2c56, 0x2c36, 0x2c56, 0x2436,
0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23f4, 0x23d4, 0x23d4,
0x23d4, 0x23b4, 0x1bb4, 0x2394, 0x1bb4, 0x2393, 0x1b93, 0x1b93, 0x1b73,
0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1b52, 0x1b52, 0x1b32, 0x1332, 0x1b32,
0x1b12, 0x1b12, 0xb69c, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc, 0xa5f9, 0xb69b,
0x9db8, 0xb69b, 0x9dd8, 0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x4b70, 0x4b70,
0x4b70, 0x4b70, 0x536f, 0xdf3d, 0xefbf, 0xdf5d, 0x9db6, 0x9dd7, 0xefbf,
0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x9db8, 0x536f, 0x5370,
0x4b70, 0x5370, 0x9d77, 0xefbf, 0xefdf, 0xa2d, 0x24e, 0xa4e, 0xa4e,
0xa4e, 0x122e, 0x122e, 0x124d, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1929, 0xbe3a, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xef9f, 0x1929,
0x194a, 0x194a, 0x1929, 0x1949, 0x1949, 0x1949, 0x1949, 0x1149, 0x1949,
0x59e5, 0xc40a, 0xc42b, 0xed8c, 0xc40a, 0xc40a, 0xc40a, 0xc40a, 0xc40a,
0xbc2b, 0x6203, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f,
0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a2e, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x9e18,
0x33ae, 0x33ae, 0x3434, 0x2c56, 0x2c56, 0x2c56, 0x2436, 0x2435, 0x2435,
0x2435, 0x2415, 0x23f5, 0x23f5, 0x23f4, 0x23f4, 0x23d4, 0x23d4, 0x23d4,
0x1bb4, 0x1bb4, 0x23b4, 0x2393, 0x2393, 0x1b93, 0x1b73, 0x1b73, 0x1b73,
0x1b73, 0x1b52, 0x1b52, 0x1b52, 0x1b52, 0x1332, 0x1b31, 0x1b31, 0x1b11,
0x2b31, 0xb69c, 0xb6bc, 0xb6bc, 0xbebc, 0xb69b, 0x9dd8, 0xbebc, 0xb69b,
0xb69b, 0x9577, 0x5370, 0x4b70, 0x5370, 0x5370, 0x5370, 0x4b70, 0x4b90,
0x9598, 0xefbf, 0xefbf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xf7bf, 0xefbf,
0xefbf, 0xefdf, 0xefbf, 0xa577, 0xa597, 0x536f, 0x7473, 0x9db7, 0x9d96,
0xefbf, 0xefbf, 0xe7be, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0x124e, 0x124e, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xa5b7, 0x9db7, 0x4a2f, 0x4a2e, 0x4a0f, 0x420e, 0x194a, 0x194a,
0x194a, 0x1949, 0x1949, 0x1949, 0x1949, 0x1949, 0x1148, 0xc40b, 0xc40a,
0xc42b, 0xed8d, 0xc40a, 0xc40a, 0xedac, 0xed8c, 0xc40a, 0xbc2a, 0xbc0b,
0x5a05, 0x4a0e, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f,
0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0f, 0x4a0e, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x33ae, 0x33ae,
0x33af, 0x2c56, 0x2c56, 0x2c56, 0x2436, 0x2435, 0x2435, 0x2435, 0x2415,
0x2415, 0x23f5, 0x23f4, 0x23f4, 0x23f4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4,
0x23b4, 0x2393, 0x2393, 0x2393, 0x1b73, 0x1b73, 0x1b73, 0x1b73, 0x1b52,
0x1352, 0x1352, 0x1b52, 0x1b32, 0x1331, 0x1b31, 0x1b11, 0x1af1, 0xb69c,
0xb6bc, 0xb6bc, 0x9db8, 0x9df8, 0x95b8, 0xae5a, 0xb6bb, 0xb6bb, 0xb69b,
0xdf9f, 0x84f5, 0x5350, 0x5350, 0x5370, 0x7453, 0x9db7, 0xe7bf, 0xefbf,
0xf7bf, 0xf79f, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefdf,
0x9db7, 0x9d97, 0x9d97, 0x9d97, 0x9d96, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0x24e, 0xa6f, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e, 0x124e,
0x98b, 0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a,
0x1949, 0x1949, 0x194a, 0x194a, 0xefbf, 0xefbf, 0xefdf, 0xa5b7, 0x9db7,
0x9d97, 0x420f, 0x4a0e, 0x420e, 0x4a0f, 0x422e, 0x192a, 0x194a, 0x1949,
0x1949, 0x1949, 0x1949, 0x1949, 0x49a7, 0xc40a, 0xc40a, 0xc44b, 0xc42b,
0xc40a, 0xc40a, 0xed8c, 0xbc2a, 0xbc2a, 0xbc2a, 0xbc0b, 0x61e5, 0x4a0f,
0x420e, 0x4a0e, 0x420e, 0x420e, 0x420e, 0x420e, 0x4a0e, 0x4a0e, 0x420e,
0x420e, 0x4a0f, 0x4a0f, 0x420f, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x338d, 0x33ae, 0x33ae, 0x2c56,
0x2c56, 0x2c56, 0x2436, 0x2436, 0x2436, 0x2435, 0x2415, 0x2415, 0x2415,
0x23f5, 0x23f5, 0x23f5, 0x23d4, 0x23d4, 0x1bd4, 0x1bb4, 0x1bb4, 0x23b4,
0x2393, 0x2393, 0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1b52, 0x1b52,
0x1b52, 0x1b32, 0x1b51, 0x1b31, 0x1b31, 0x1b11, 0x1b11, 0xbebb, 0xbebc,
0xb69b, 0xb6bb, 0xb69b, 0x9598, 0x9dd8, 0xb6bb, 0xb6bb, 0xb6bb, 0xb6bc,
0xc6dc, 0xefbf, 0xefbf, 0xefdf, 0xdf9f, 0xefdf, 0xefbf, 0xbe59, 0xefbf,
0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0x124e, 0x124d, 0x124d, 0x114a,
0x114a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x196a, 0xa597,
0xcefd, 0x320c, 0xefdf, 0xefdf, 0xa5b7, 0x9db7, 0x9d97, 0x9db7, 0x422f,
0x420f, 0x420f, 0x420f, 0x422e, 0x420e, 0x192a, 0x194a, 0x1949, 0x1949,
0x1949, 0x1949, 0x59e5, 0xc40a, 0xed8d, 0xc429, 0xc40a, 0xc40a, 0xc40a,
0xed8d, 0xedac, 0xed8c, 0xc429, 0xbc2b, 0x7286, 0x520a, 0x420f, 0x420f,
0x420f, 0x420f, 0x420f, 0x420f, 0x420f, 0x420f, 0x420f, 0x420f, 0x41ef,
0x41ef, 0x41ef, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x85d5, 0x5d2f, 0x6511, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x43ef, 0x33ae, 0x33ae, 0x2c76, 0x2c56, 0x2c56,
0x2c56, 0x2c56, 0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5,
0x23d5, 0x23d5, 0x23d4, 0x23b4, 0x1bd4, 0x1bb4, 0x2394, 0x2393, 0x2393,
0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1b52, 0x1b52, 0x1b52,
0x1b51, 0x1b31, 0x1b31, 0x1b11, 0x1b11, 0x1b10, 0xb69c, 0xbebc, 0xb6bc,
0xb69b, 0xb69b, 0x9db8, 0x9597, 0x9db8, 0x95b8, 0x9597, 0xb69b, 0xb6bc,
0xb6bc, 0xb6bc, 0xb6bb, 0xcedb, 0x9db7, 0xefdf, 0xf7bf, 0xf7bf, 0xf7bf,
0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xb659, 0xe7be, 0xefbf, 0x9d96, 0xe7bf,
0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefdf, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa6e, 0xa4e, 0x124e, 0x124e, 0x114a, 0x114a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949, 0x194a, 0x9d97, 0x9d97,
0x9d96, 0x9d97, 0x9d97, 0x9d97, 0x9d97, 0x9db7, 0xa599, 0x420e, 0x41ef,
0x41ef, 0x420f, 0x41ee, 0x420e, 0x296b, 0x1929, 0x1949, 0x1949, 0x1949,
0x59c4, 0xc42a, 0xed8c, 0xed8c, 0xc40a, 0xc40a, 0xc40a, 0xc42a, 0xc42a,
0xc42b, 0xd4ca, 0x9307, 0x82c6, 0x5a05, 0x41ee, 0x41ef, 0x41ef, 0x41ef,
0x41ef, 0x41ef, 0x41ef, 0x41ef, 0x41ef, 0x41ef, 0x41ef, 0x41ef, 0x41ef,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x5d2f, 0x5d0f, 0x5d2f, 0x5d0f, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x9618, 0x33ae, 0x33ae, 0x3496, 0x2c77, 0x2c76, 0x2c56, 0x2c56,
0x2435, 0x2435, 0x2415, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x2bf5, 0x23d4,
0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x23b4, 0x2393, 0x2393, 0x2393, 0x1b93,
0x1b73, 0x1b73, 0x1b73, 0x1b72, 0x1352, 0x1352, 0x1b52, 0x1b32, 0x1332,
0x1b32, 0x1b12, 0x1b11, 0x1b12, 0x1af0, 0xb6bb, 0xb6bc, 0xb6bc, 0xb6bc,
0xb6bc, 0xb6bc, 0xb6bb, 0xb6bb, 0xb6bb, 0xbebc, 0x9d98, 0xb6bb, 0xbebc,
0xb69b, 0xefdf, 0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf,
0xefbf, 0xefbf, 0xefdf, 0xefbf, 0x9d96, 0x9d96, 0xefbf, 0xefbf, 0xefbf,
0xefbf, 0xefbf, 0xefbf, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa6e, 0xa6e, 0x124e, 0x124e, 0x116a, 0x114a, 0x114a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x1949, 0x1949, 0x194a, 0x9d97, 0x9d97, 0x9d97,
0x9d97, 0x9d97, 0x9d97, 0x9db7, 0x9d97, 0x420f, 0x41ef, 0x41ef, 0x41ee,
0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x31cc, 0x194a, 0x1929, 0x2946, 0xc42a,
0xc40a, 0xed8d, 0xed8d, 0xed8d, 0xed6c, 0xe52c, 0xc42a, 0xed8e, 0xedae,
0x82c6, 0x82a6, 0x59e5, 0x41ee, 0x41ef, 0x41ce, 0x41ce, 0x41ce, 0x41ef,
0x41ef, 0x41ef, 0x41ce, 0x41ce, 0x41ef, 0x41ef, 0x41ef, 0x64f0, 0x95d7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x9617, 0x5d30,
0x5d0f, 0x5d2f, 0x5d0f, 0x5d10, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x9618,
0x33ae, 0x33ae, 0x33d1, 0x2c77, 0x2c76, 0x2c56, 0x2c56, 0x2436, 0x2435,
0x2415, 0x2415, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d4, 0x23d4,
0x23d4, 0x1bd4, 0x1bb4, 0x23b3, 0x2393, 0x2393, 0x1b93, 0x1b93, 0x1b73,
0x1b73, 0x1b72, 0x1b52, 0x1b52, 0x1b52, 0x1b32, 0x1332, 0x1b32, 0x1b32,
0x1b11, 0x1b11, 0x9db7, 0x9db7, 0x95b8, 0xb6bc, 0xb6bc, 0xb69c, 0xb69c,
0xb69c, 0xb69c, 0xb69c, 0xb6bc, 0x9d98, 0x9d97, 0xb69c, 0xb6bc, 0xefdf,
0xefbf, 0xefbf, 0xf7bf, 0xf7bf, 0xf7bf, 0xf7bf, 0xefbf, 0xefbf, 0xefbf,
0xefdf, 0xbe5a, 0xa5b7, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf,
0xf7be, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0x124e, 0x124e, 0x116a, 0x116a, 0x116a, 0x194a, 0x194a, 0x194a, 0x194a,
0x194a, 0x1949, 0x1949, 0x194a, 0x322c, 0x9d97, 0x9d97, 0x9d98, 0x9d98,
0x9db7, 0x9db7, 0x9db7, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x41ee,
0x41ee, 0x41ee, 0x39ee, 0x39ee, 0x39ce, 0x41cf, 0xbbe9, 0xc40a, 0xc40a,
0xc40a, 0xc40a, 0xc40a, 0xc429, 0xbc2a, 0xc42a, 0xbc2b, 0x82c6, 0x7aa7,
0x59e5, 0x41ee, 0x41ce, 0x41ce, 0x41ce, 0x41ee, 0x41ce, 0x41ce, 0x41ce,
0x41ce, 0x41ce, 0x39ce, 0x39ce, 0x41ce, 0x5d0f, 0x8e37, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x5d10, 0x5d30, 0x5d0f, 0x5d2f,
0x5d10, 0x5d0f, 0x6510, 0x95f7, 0x95f7, 0x95f7, 0x95d7, 0x338e, 0x33ae,
0x2bae, 0x2c77, 0x2c76, 0x2c56, 0x2c56, 0x2436, 0x2436, 0x2435, 0x2435,
0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x1bb4,
0x1bb4, 0x23b4, 0x2394, 0x2393, 0x1b93, 0x2373, 0x1b93, 0x1b73, 0x1b72,
0x1b52, 0x1b52, 0x1b52, 0x1b32, 0x1332, 0x1332, 0x1b32, 0x1b11, 0x1b12,
0x9db7, 0x9db7, 0x9db8, 0x9db8, 0xb69b, 0xb69c, 0xb69c, 0xb69c, 0xb69c,
0xb69c, 0xb69c, 0x9db7, 0x9db7, 0xb69c, 0xb6bb, 0xb69c, 0xbebb, 0xefbf,
0xf7bf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0xa5d8,
0xefbf, 0xefdf, 0xefbf, 0xefbf, 0xefbf, 0xefbf, 0x4370, 0xa6e, 0xa6e,
0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa6e, 0x122e,
0x11cc, 0x116a, 0x116a, 0x116a, 0x194a, 0x194a, 0x194a, 0x194a, 0x1949,
0x1949, 0x196a, 0xa5b7, 0xa578, 0xa598, 0x9d78, 0xa598, 0x9d17, 0x7c34,
0x5b52, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x41ee, 0x39ee,
0x39ee, 0x39ee, 0x39ee, 0x420f, 0x59e6, 0xbc0a, 0xc40a, 0xc40a, 0xc40a,
0xc40a, 0xc42a, 0xbc2a, 0xbc2a, 0x82c6, 0x7ac6, 0x61e4, 0x49ec, 0x39ee,
0x39ee, 0x39ee, 0x39ee, 0x41ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee,
0x39ee, 0x41ee, 0x39ee, 0x5d2f, 0x5d0f, 0x8df6, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x95f7, 0x95d7, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f, 0x5d2f,
0x5d2f, 0x9617, 0x95f7, 0x95f7, 0x95f7, 0x3bae, 0x338e, 0x338e, 0x2c77,
0x2c76, 0x2c56, 0x2c56, 0x2c56, 0x2436, 0x2435, 0x2435, 0x2415, 0x2415,
0x23f5, 0x2bf5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x1bb4,
0x23b4, 0x2393, 0x2393, 0x1b73, 0x1b73, 0x1b73, 0x1b72, 0x1b52, 0x1b52,
0x1b52, 0x1b52, 0x1b32, 0x1332, 0x1b32, 0x1b11, 0x1b11, 0x8db9, 0x9db7,
0x9db7, 0x9597, 0x9db8, 0x9597, 0xb69c, 0xb69c, 0xb69c, 0xb69c, 0xbebc,
0x9db8, 0xb67b, 0xb69c, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bb,
0xb6bb, 0xbe9b, 0xc6bc, 0xc6bb, 0xc6bb, 0xbebc, 0xbebc, 0xb69b, 0xb6bc,
0xb69b, 0xbebb, 0x2a6d, 0xa4e, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x124e, 0x1a0e, 0x196a,
0x116a, 0x116a, 0x114a, 0x194a, 0x194a, 0x194a, 0x1949, 0x1949, 0x1949,
0x41ed, 0x39ed, 0x41ed, 0x41ed, 0x39ed, 0x39ed, 0x39ed, 0x39ce, 0x39ce,
0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee,
0x39ee, 0x39ed, 0x39ee, 0x6a25, 0xbc0a, 0xc42b, 0xc42b, 0xbc2b, 0xbc2b,
0x92e7, 0x82a6, 0x82c7, 0x7aa7, 0x59e5, 0x41ee, 0x39ee, 0x39ee, 0x39ee,
0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee, 0x39ee,
0x39ee, 0x5d2f, 0x5d2f, 0x6510, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7,
0x95f7, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f, 0x5d2f, 0x5d2f, 0x5d10,
0x95f7, 0x95f7, 0x95f7, 0x8df7, 0x338e, 0x338e, 0x2c76, 0x2c76, 0x2c76,
0x2c56, 0x2c56, 0x2436, 0x2435, 0x2435, 0x2415, 0x2415, 0x2415, 0x23f5,
0x2bf5, 0x23d5, 0x23d4, 0x23d4, 0x23d4, 0x23d4, 0x1bb4, 0x2394, 0x2393,
0x2393, 0x1b93, 0x1b73, 0x1b73, 0x1b73, 0x1b72, 0x1b52, 0x1352, 0x1352,
0x1b32, 0x1b32, 0x1b32, 0x1b11, 0x1b11, 0x1b11, 0x1acf, 0x9d97, 0x9d97,
0x9d97, 0x9d97, 0x9db8, 0x9db7, 0x9dd7, 0xbebc, 0xb69c, 0xb69c, 0xb69c,
0xb69c, 0xb69c, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bb, 0xb6bc, 0xb6bc, 0xb6bc,
0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb69c, 0xb6bd, 0xb6bc, 0xb6bc, 0x128f,
0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x1a2e, 0x1149, 0x929, 0x114a,
0x114a, 0x114a, 0x194a, 0x194a, 0x1949, 0x1949, 0x1949, 0x29ac, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x59e5, 0x7aa7, 0x7aa7, 0x82a6, 0x82a6, 0x82c7, 0x82a7,
0x61e4, 0x51e7, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x5d2f,
0x5d2f, 0x5d0f, 0x6d11, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x95f7, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f, 0x95f7, 0x95f7,
0x95f7, 0x9618, 0x338e, 0x338e, 0x3477, 0x2c76, 0x2c56, 0x2c56, 0x2c56,
0x2436, 0x2436, 0x2435, 0x2435, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x23d5,
0x23d4, 0x23d4, 0x23d4, 0x23b4, 0x1bb4, 0x23b4, 0x2394, 0x2393, 0x1b93,
0x1b93, 0x1b73, 0x1b73, 0x1b72, 0x1b52, 0x1b52, 0x1b52, 0x1b52, 0x1b32,
0x1332, 0x1b32, 0x1b12, 0x1b11, 0x1b11, 0x1311, 0x9df9, 0x9db7, 0x9d97,
0x9d97, 0x9db7, 0x9db7, 0x9db7, 0x12cf, 0x1acf, 0xb6dc, 0xb6bc, 0xb6bc,
0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc, 0xb6bc,
0xb6bc, 0xaedc, 0x1a6e, 0x126f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f,
0xa6e, 0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0xa4e, 0xa4e, 0x124e, 0x7516, 0x7516, 0x74d6, 0x116a, 0x116a,
0x194a, 0x194a, 0x1949, 0x1949, 0x196a, 0x194a, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x31ce, 0x39cd, 0x41ca, 0x49e9, 0x41ea, 0x41cd, 0x31ce, 0x39cd,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x8574, 0x95f7, 0x95f7, 0x95f7, 0x8df6, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x8df6, 0x95f7, 0x95f7, 0x95f8,
0x338e, 0x338e, 0x3475, 0x2c77, 0x2c76, 0x2c56, 0x2c56, 0x2c56, 0x2436,
0x2436, 0x2435, 0x2415, 0x2415, 0x23f5, 0x23f5, 0x23d5, 0x23d5, 0x23f4,
0x23d4, 0x23d4, 0x1bb4, 0x1bb4, 0x2394, 0x2393, 0x2393, 0x1b93, 0x1b93,
0x1b73, 0x1b73, 0x1b73, 0x1b52, 0x1b52, 0x1b52, 0x1b52, 0x1332, 0x1b32,
0x1b12, 0x1b12, 0x1b11, 0x1311, 0x1311, 0x12f1, 0x1af0, 0x1af0, 0x1af0,
0x12f0, 0x12d0, 0x124d, 0x1af0, 0x12d0, 0x12b0, 0x1ab0, 0x12b0, 0x22cf,
0xa65c, 0xb6dc, 0xb69c, 0xb69c, 0xaebc, 0x9e3b, 0x124d, 0xa6f, 0xa8f,
0xa8f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e,
0xa6e, 0xa6e, 0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e,
0xa4e, 0x122e, 0x7537, 0x6d37, 0x74b6, 0x116a, 0x116a, 0x194a, 0x194a,
0x194a, 0x194a, 0x194a, 0x194a, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ae, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x39ce,
0x39ce, 0x39ce, 0x39ce, 0x39ce, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d2f, 0x5d2f,
0x7553, 0x95f7, 0x95f7, 0x5d30, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f, 0x5d0f,
0x5d0f, 0x5d2f, 0x5d2f, 0x5d30, 0x95f7, 0x95f7, 0x9618, 0x33ae, 0x33ae,
0x2bd0, 0x2c77, 0x2c76, 0x2c56, 0x2c56, 0x2c56, 0x2436, 0x2435, 0x2435,
0x2415, 0x2415, 0x2415, 0x23f5, 0x2bf5, 0x23f4, 0x23f4, 0x23d4, 0x23d4,
0x1bd4, 0x1bd4, 0x23b4, 0x2394, 0x2393, 0x2393, 0x1b93, 0x1b73, 0x1b73,
0x1b73, 0x1b52, 0x1352, 0x1352, 0x1b52, 0x1b32, 0x1b32, 0x1b12, 0x1b12,
0x1b11, 0x1311, 0x1311, 0x12f1, 0x12f1, 0x12f1, 0x12f0, 0x12f0, 0x12f0,
0x19cc, 0x11cc, 0x12d0, 0x1ab0, 0x1ab0, 0x12b0, 0x12b0, 0x12af, 0x12af,
0xaaf, 0x12af, 0x128f, 0x128f, 0x128f, 0x128f, 0x128f, 0xa8f, 0xa6f,
0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6f, 0xa6e, 0xa6e, 0xa6e,
0xa6e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0xa4e, 0x120d,
0x1169, 0x1169, 0x196a, 0x116a, 0x116a, 0x116a, 0x194a, 0x194a, 0x194a,
0x194a, 0x194a, 0x39cd, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad,
0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad,
0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x39ae, 0x39ae, 0x31ad,
0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad,
0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad, 0x31ad,
0x31ad, 0x31ad});
img5 = (std::vector<uint16_t>{
0x1a4e, 0x222e, 0x1a0d, 0x19cc, 0x1a6f, 0x2290, 0x1988, 0x1948, 0x1948,
0x1968, 0x1168, 0x1127, 0x8a5, 0x8a5, 0x1968, 0x907, 0x1ab0, 0x20a8,
0x1127, 0x10e6, 0x2045, 0x78ec, 0x78ec, 0x30a7, 0x1a8e, 0x33f5, 0x2b32,
0x2b12, 0x19cb, 0x19ab, 0x21ed, 0x21ac, 0x31cd, 0x39cc, 0x5a0c, 0x7a6d,
0x822c, 0x79a9, 0x58c5, 0x78e5, 0xa0c6, 0xb0a5, 0x9864, 0xc884, 0xb844,
0xb824, 0x9824, 0x7022, 0x6022, 0x5822, 0x6022, 0x5822, 0x5001, 0x4801,
0x5021, 0x5021, 0x5021, 0x4801, 0x4801, 0x5021, 0x5821, 0x5802, 0x6822,
0x6822, 0x6022, 0x6802, 0x7802, 0x9023, 0xa024, 0xa844, 0xc044, 0xc844,
0xd063, 0xd043, 0xd842, 0xd862, 0xd862, 0xe062, 0xe8a2, 0xe902, 0xe963,
0xe983, 0xf1e4, 0xe9a2, 0xe983, 0xe9c3, 0xe142, 0xc062, 0xd0c1, 0xe142,
0xf204, 0xfa65, 0xea03, 0xe9c3, 0xe9c3, 0xfa85, 0xf224, 0xf2a6, 0xf2a6,
0xfbc9, 0xfba8, 0xfbc9, 0xf2e6, 0xfba9, 0xfbaa, 0xeb68, 0xf389, 0xf2e6,
0xe284, 0xeac5, 0xf388, 0xfba9, 0xf2e5, 0xe2e5, 0xeae3, 0xf307, 0xf327,
0xe307, 0xea84, 0xf347, 0xfb47, 0xf2e5, 0xe223, 0xe244, 0xda24, 0xca04,
0xc205, 0xaa27, 0x8a29, 0x7b0e, 0x5310, 0x4b92, 0x3b93, 0x33b4, 0x2b53,
0x2b94, 0x2b94, 0x22d1, 0x19ca, 0x19ca, 0x19aa, 0x21ca, 0x1a2d, 0x22b0,
0x22d1, 0x2333, 0x3394, 0x33f5, 0x3c56, 0x3c96, 0x3496, 0x3d38, 0x45f9,
0x4e9a, 0x4617, 0x4dd5, 0x44f0, 0x3c2c, 0x3ba9, 0x742a, 0x22f2, 0x1a90,
0x2ab0, 0x1a2e, 0x1a0c, 0x226f, 0x2290, 0x11aa, 0x1148, 0x10e6, 0x1127,
0x1989, 0x1148, 0x1106, 0x8a4, 0x18a5, 0x1168, 0x10c6, 0x3067, 0xb12c,
0x1189, 0x10e6, 0x1864, 0x60aa, 0x40a8, 0x1085, 0x4454, 0x3c56, 0x3394,
0x3b73, 0x220c, 0x19aa, 0x21ed, 0x29ed, 0x31ac, 0x49cc, 0x726e, 0x7a2c,
0x81eb, 0x7927, 0x8907, 0x6063, 0xb8c5, 0xc0a4, 0xa064, 0xa844, 0xc065,
0xb824, 0x8023, 0x6822, 0x6022, 0x5822, 0x6022, 0x6022, 0x5802, 0x5001,
0x5022, 0x5822, 0x5001, 0x5021, 0x5001, 0x5001, 0x5821, 0x6002, 0x6802,
0x7823, 0x7843, 0x8844, 0x9024, 0xa024, 0xa865, 0xa824, 0xb844, 0xc044,
0xd043, 0xd863, 0xe8a2, 0xe8e2, 0xe8c2, 0xf143, 0xe943, 0xe943, 0xe942,
0xe962, 0xe123, 0xb842, 0xd0a2, 0xe0e1, 0xe983, 0xe9c3, 0xf1e3, 0xe9c3,
0xe142, 0xe9c3, 0xf204, 0xf224, 0xf265, 0xf286, 0xfb67, 0xf3c8, 0xf2a6,
0xeaa5, 0xeb07, 0xeb8a, 0xeb27, 0xeb48, 0xe2a4, 0xea83, 0xeb06, 0xf389,
0xf306, 0xea84, 0xfb68, 0xe2a3, 0xf3ca, 0xf368, 0xf348, 0xea64, 0xf346,
0xf305, 0xea43, 0xd9c3, 0xfb27, 0xd245, 0xc225, 0xaa27, 0x8a4a, 0x72ce,
0x4aaf, 0x3b31, 0x3394, 0x33b4, 0x2b73, 0x33d4, 0x33b4, 0x2312, 0x1a0c,
0x1a0c, 0x19aa, 0x19cb, 0x1a2e, 0x22d1, 0x22d1, 0x2312, 0x2b93, 0x2bb4,
0x33f5, 0x3415, 0x3c96, 0x3cf7, 0x3537, 0x461a, 0x4619, 0x4e79, 0x4e16,
0x4d53, 0x3bc9, 0x5c29, 0x8449, 0x8bc8, 0x2353, 0x2b74, 0x2313, 0x22af,
0x226f, 0x19ec, 0x1a2d, 0x226f, 0x224e, 0x1169, 0x1147, 0x1127, 0x1989,
0x1968, 0x1148, 0x8c5, 0x864, 0x4888, 0x1907, 0x198a, 0x78cb, 0x30a8,
0x1a0e, 0x1127, 0x8a4, 0x4088, 0x1084, 0x10a6, 0x3d38, 0x3c76, 0x2b53,
0x1a8f, 0x19cb, 0x21cc, 0x21ed, 0x29cd, 0x420d, 0x622d, 0x724c, 0x7a0b,
0x7948, 0x70c5, 0x90a5, 0xb0c5, 0xc085, 0xa864, 0xc044, 0x9024, 0xd044,
0xa825, 0x6822, 0x6822, 0x6822, 0x6822, 0x6802, 0x6822, 0x5822, 0x5802,
0x5822, 0x5822, 0x5822, 0x5021, 0x5021, 0x5021, 0x5822, 0x6022, 0x6822,
0x7022, 0x8023, 0x9823, 0xa845, 0xa844, 0xb844, 0xc044, 0xc843, 0xd042,
0xd842, 0xd862, 0xd861, 0xe882, 0xd881, 0xd8a2, 0xc063, 0xa843, 0xd882,
0xe0e2, 0xe942, 0xfa04, 0xf1a3, 0xe902, 0xe922, 0xe962, 0xf1e3, 0xf1e3,
0xf224, 0xf224, 0xf307, 0xfba8, 0xfc0a, 0xfae6, 0xf306, 0xfb68, 0xeb69,
0xeb89, 0xfbca, 0xf368, 0xda43, 0xeaa5, 0xf369, 0xf2c6, 0xeaa5, 0xeae5,
0xeae5, 0xf3eb, 0xf368, 0xf2c5, 0xea84, 0xfb66, 0xea85, 0xe224, 0xda24,
0xd224, 0xc226, 0xaa27, 0x8a4b, 0x5a4c, 0x426e, 0x3b52, 0x2b73, 0x2b73,
0x2b74, 0x2b93, 0x3435, 0x2b33, 0x22b0, 0x224f, 0x19aa, 0x19cb, 0x222d,
0x22f1, 0x1ad1, 0x2353, 0x2b94, 0x33d5, 0x3c15, 0x33f5, 0x3436, 0x3496,
0x3d38, 0x3d78, 0x4e1a, 0x4639, 0x4e59, 0x45f7, 0x448f, 0x440b, 0x43c8,
0x43c9, 0x3ba9, 0x5be9, 0x3393, 0x2b31, 0x2b53, 0x2b94, 0x22d1, 0x11ed,
0x19ec, 0x19ec, 0x2290, 0x2290, 0x19aa, 0x1148, 0x1106, 0x1948, 0x1168,
0x1168, 0x1948, 0x8c4, 0x40a8, 0x3068, 0x2887, 0x118a, 0x8a5, 0x2270,
0x10a5, 0x10e6, 0x10c5, 0x1865, 0x28a6, 0x8a5, 0x1129, 0x33f4, 0x2333,
0x118a, 0x220d, 0x21cc, 0x29cc, 0x298c, 0x5a2d, 0x724d, 0x720b, 0x7168,
0x6906, 0xb147, 0x6063, 0xc8a4, 0xc064, 0xa044, 0xc045, 0xa824, 0xb825,
0x8844, 0x7023, 0x6822, 0x6822, 0x7022, 0x7022, 0x6022, 0x5801, 0x5822,
0x5822, 0x5822, 0x5822, 0x5001, 0x5842, 0x5802, 0x5822, 0x6022, 0x6822,
0x7022, 0x7822, 0x8823, 0xa044, 0xb065, 0xb844, 0xc044, 0xb844, 0xb024,
0xa844, 0x9043, 0x9843, 0xc863, 0xd061, 0xe0a2, 0xe922, 0xf1a3, 0xf163,
0xd881, 0xd881, 0xf163, 0xf1c3, 0xe9a3, 0xf204, 0xf204, 0xea04, 0xfb48,
0xf326, 0xfbaa, 0xfaa6, 0xea64, 0xf307, 0xf38a, 0xfc2c, 0xeb48, 0xf326,
0xeaa4, 0xf3aa, 0xf2e6, 0xeaa5, 0xf284, 0xfbe9, 0xf366, 0xf3ca, 0xf348,
0xf2c5, 0xf2a4, 0xf325, 0xea64, 0xd1c3, 0xe2a6, 0xc226, 0xaa28, 0x8a6b,
0x5a2c, 0x3a6f, 0x32f1, 0x3373, 0x2b73, 0x2b94, 0x33f5, 0x3435, 0x2b94,
0x3394, 0x3332, 0x1989, 0x19ab, 0x1a0d, 0x2b12, 0x22f1, 0x2b73, 0x33b4,
0x2bb4, 0x2b94, 0x2bb4, 0x33f5, 0x2c35, 0x34b6, 0x3d58, 0x45d9, 0x45f9,
0x4e3a, 0x4638, 0x4db4, 0x4552, 0x44af, 0x4531, 0x44f0, 0x4d94, 0x45d6,
0x3d95, 0x3cd7, 0x3415, 0x33b5, 0x2b53, 0x33b4, 0x2b32, 0x2270, 0x224e,
0x19cb, 0x224e, 0x226f, 0x226f, 0x1989, 0x1968, 0x10e6, 0x1989, 0x1168,
0x1168, 0x1148, 0x10a4, 0x28a6, 0x2086, 0x38c8, 0x2168, 0x1969, 0x68ec,
0x222e, 0x40c9, 0x1084, 0x863, 0x1885, 0x1065, 0x8a5, 0x2b53, 0x1a4d,
0x19cb, 0x220d, 0x29cd, 0x31ed, 0x41ed, 0x624d, 0x722c, 0x71a9, 0x6106,
0x70e5, 0x98e5, 0xc8e4, 0xc883, 0xc864, 0xb024, 0x9004, 0xc844, 0xb845,
0x7002, 0x6842, 0x6802, 0x7002, 0x7823, 0x6822, 0x6823, 0x5822, 0x5842,
0x5801, 0x5821, 0x5821, 0x6022, 0x6042, 0x6802, 0x7022, 0x7802, 0x8803,
0x9023, 0x9023, 0x9044, 0x9844, 0xb065, 0xb064, 0xc864, 0xd843, 0xe062,
0xe081, 0xe0a2, 0xf143, 0xe902, 0xe0a2, 0xc042, 0xc863, 0xe102, 0xf1c4,
0xf1c3, 0xf1c3, 0xfa25, 0xfa24, 0xfa65, 0xf326, 0xf325, 0xf2a6, 0xf265,
0xfac6, 0xf327, 0xebaa, 0xf368, 0xf2e6, 0xeb06, 0xf347, 0xeb27, 0xf328,
0xf2a5, 0xf2a5, 0xfb68, 0xfb47, 0xf327, 0xf306, 0xf264, 0xfb26, 0xeac4,
0xe265, 0xc9a4, 0xc205, 0xa9e7, 0x824a, 0x5a6d, 0x322e, 0x2ad0, 0x2b73,
0x2b93, 0x2bb4, 0x2bb3, 0x3415, 0x33f5, 0x3bf5, 0x2bb3, 0x19aa, 0x19ca,
0x222d, 0x22b0, 0x2312, 0x2312, 0x2bb4, 0x33d4, 0x33b5, 0x33b4, 0x33b4,
0x3415, 0x3496, 0x34d7, 0x3d78, 0x45d9, 0x45f9, 0x3df9, 0x467a, 0x4659,
0x4659, 0x4659, 0x3df7, 0x3dd8, 0x45da, 0x45d9, 0x45b9, 0x45d9, 0x3476,
0x3cf7, 0x3cb7, 0x3c77, 0x2332, 0x2b73, 0x33d5, 0x1a90, 0x1a4f, 0x222e,
0x19ec, 0x228f, 0x2290, 0x1a0c, 0x1168, 0x1968, 0x198a, 0x118a, 0x1189,
0x1989, 0x10e6, 0x1024, 0x1064, 0x1063, 0x2866, 0x1128, 0x10a6, 0x3312,
0x1a0e, 0x19ab, 0x40a8, 0x4089, 0x3888, 0x20a6, 0x2b32, 0x2b33, 0x21cb,
0x2a2d, 0x21ed, 0x29cd, 0x39ed, 0x5a2d, 0x6a2c, 0x69aa, 0x7148, 0x6084,
0xc925, 0x9064, 0xd8a3, 0xc844, 0xb024, 0xc045, 0x9024, 0xc045, 0xa045,
0x5801, 0x7823, 0x7823, 0x7823, 0x7823, 0x6822, 0x6001, 0x5822, 0x5822,
0x5821, 0x5821, 0x6022, 0x6822, 0x7002, 0x8023, 0x9044, 0x9844, 0xa044,
0xb045, 0xb844, 0xc064, 0xc843, 0xd042, 0xe062, 0xe881, 0xd882, 0xd062,
0xc063, 0xa864, 0xb064, 0xd861, 0xe922, 0xf1a3, 0xf1c4, 0xf1c3, 0xfa24,
0xf244, 0xf2c6, 0xf326, 0xfb88, 0xfa44, 0xfa45, 0xfac6, 0xfb28, 0xe2e7,
0xfbaa, 0xf2a5, 0xf328, 0xf3ca, 0xf368, 0xf348, 0xea43, 0xeac5, 0xeb28,
0xeae6, 0xf307, 0xf306, 0xea83, 0xf346, 0xe264, 0xda45, 0xc205, 0xb227,
0x8a4a, 0x626d, 0x322e, 0x2ab0, 0x2b12, 0x2b53, 0x2b94, 0x33f4, 0x33d4,
0x3435, 0x2b93, 0x3497, 0x19aa, 0x198a, 0x222d, 0x1a4f, 0x1ab0, 0x2312,
0x33b5, 0x2b94, 0x33f5, 0x33f5, 0x33d4, 0x33f4, 0x3cb7, 0x3496, 0x34f7,
0x3d98, 0x45d9, 0x461a, 0x4619, 0x3dd8, 0x4619, 0x463a, 0x4e7a, 0x3cf7,
0x34d6, 0x3cf7, 0x34d6, 0x3476, 0x3415, 0x3476, 0x3cb7, 0x3455, 0x34f7,
0x4518, 0x3415, 0x2b73, 0x2bb4, 0x33f5, 0x2333, 0x22b0, 0x226f, 0x222e,
0x1a0d, 0x226f, 0x22b1, 0x19aa, 0x19aa, 0x222d, 0x19ec, 0x19ca, 0x1989,
0x1989, 0x1045, 0x10a5, 0x864, 0x864, 0x2886, 0x10c7, 0x224d, 0x1a4f,
0x1a4e, 0x1a2d, 0x10c7, 0x30a8, 0x1085, 0x22f2, 0x2b32, 0x19aa, 0x19cb,
0x220d, 0x29ed, 0x39ed, 0x522d, 0x6a0c, 0x71eb, 0x7968, 0x8927, 0xc104,
0x8864, 0xe0c2, 0xd063, 0xd064, 0xb025, 0xa845, 0xa824, 0xb825, 0x8823,
0x6802, 0x8003, 0x8003, 0x7823, 0x7823, 0x6822, 0x6822, 0x6021, 0x5822,
0x5821, 0x5821, 0x6822, 0x6022, 0x7002, 0x8843, 0x9044, 0xa024, 0x9803,
0xb844, 0xb865, 0xa844, 0xa024, 0x9043, 0x8822, 0xa843, 0xc063, 0xd862,
0xe0a1, 0xe923, 0xf183, 0xf1a3, 0xfa04, 0xf1e4, 0xf224, 0xfb06, 0xfb46,
0xfb48, 0xe9e3, 0xf244, 0xf285, 0xf2a6, 0xfb49, 0xf369, 0xf2c6, 0xfbcb,
0xfcae, 0xf389, 0xf2e6, 0xe223, 0xea84, 0xf3ea, 0xeaa5, 0xf2e5, 0xea84,
0xf305, 0xfb66, 0xeaa5, 0xc1c5, 0xc2c8, 0x9229, 0x6a8d, 0x3a0d, 0x2a6f,
0x2b12, 0x2b53, 0x2b94, 0x2bd4, 0x33d4, 0x2c15, 0x2b93, 0x3c96, 0x2b31,
0x19aa, 0x19eb, 0x1a4e, 0x22b0, 0x2312, 0x2bb4, 0x2bb4, 0x33f4, 0x2bb4,
0x3c35, 0x3415, 0x3496, 0x3476, 0x3455, 0x3d99, 0x3537, 0x3d78, 0x3db9,
0x3db9, 0x45d9, 0x3df9, 0x3d99, 0x3455, 0x3c36, 0x3c56, 0x2b93, 0x2332,
0x2b52, 0x33f5, 0x3c96, 0x3cf7, 0x3476, 0x3c97, 0x3c97, 0x3d18, 0x3d17,
0x3456, 0x3435, 0x33f5, 0x3436, 0x33d4, 0x22d1, 0x1a90, 0x226e, 0x1a0d,
0x226f, 0x1a90, 0x2270, 0x198a, 0x1989, 0x1989, 0x19aa, 0x1989, 0x21cb,
0x1127, 0x50ca, 0x10c5, 0x884, 0x1085, 0x1064, 0x18c7, 0x1a0c, 0x224e,
0x19ec, 0x19ec, 0x226e, 0x2b32, 0x2b53, 0x118a, 0x21ec, 0x19cb, 0x220d,
0x220e, 0x29cd, 0x41ed, 0x622d, 0x6a0c, 0x79a9, 0x9147, 0x98e5, 0xc8c4,
0xc883, 0xd842, 0xd063, 0xb844, 0xb824, 0x8023, 0xb845, 0xb045, 0x7002,
0x7823, 0x9044, 0x8823, 0x8043, 0x8043, 0x7822, 0x7022, 0x7043, 0x5801,
0x6822, 0x6022, 0x6822, 0x6001, 0x6802, 0x7022, 0x7802, 0x8043, 0x8843,
0x9003, 0xa845, 0xa824, 0xc044, 0xc862, 0xe082, 0xe8a1, 0xf123, 0xf163,
0xf9c4, 0xf1c3, 0xf1e4, 0xfaa5, 0xf305, 0xfb46, 0xfac7, 0xfa24, 0xf244,
0xfac6, 0xfb48, 0xf2e7, 0xf307, 0xea84, 0xf3aa, 0xf40b, 0xf327, 0xfb06,
0xea23, 0xf2e7, 0xf368, 0xe264, 0xea84, 0xf284, 0xf345, 0xeac5, 0xda44,
0xa965, 0xa268, 0x7a8c, 0x39ec, 0x2a2e, 0x2af1, 0x2b33, 0x2b73, 0x33d4,
0x3c15, 0x2bb4, 0x33f5, 0x33d4, 0x3cd7, 0x19a9, 0x19ca, 0x224e, 0x22b0,
0x2b12, 0x2b94, 0x33d4, 0x2bd4, 0x3c15, 0x3415, 0x3415, 0x3c96, 0x3cd7,
0x3435, 0x45d9, 0x3d37, 0x3db9, 0x3d98, 0x3db9, 0x3d98, 0x4dfa, 0x34f7,
0x2b93, 0x2b53, 0x2b73, 0x22f1, 0x22b1, 0x22d1, 0x2b52, 0x33f4, 0x33f4,
0x3415, 0x3c97, 0x2c15, 0x3cb6, 0x3456, 0x3497, 0x3496, 0x4558, 0x3cb7,
0x3476, 0x2bb4, 0x3455, 0x3456, 0x2b53, 0x22b1, 0x226f, 0x1a2e, 0x224e,
0x22b0, 0x1ab1, 0x224e, 0x19aa, 0x19aa, 0x19a9, 0x1169, 0x198a, 0x1989,
0x2886, 0x10c5, 0x3353, 0x33d4, 0x19eb, 0x1107, 0x18a5, 0x19cb, 0x226e,
0x1a2e, 0x224e, 0x1a0c, 0x19ab, 0x19aa, 0x19aa, 0x19cb, 0x224f, 0x222f,
0x2a2f, 0x3a2e, 0x5a2c, 0x6a0c, 0x79a9, 0x9147, 0x6884, 0xd143, 0xa864,
0xe0c2, 0xe084, 0xc844, 0xb845, 0xb044, 0x9824, 0xb845, 0xa045, 0x7022,
0x7002, 0x9044, 0x8823, 0x9044, 0x9044, 0x8823, 0x8823, 0x8023, 0x7022,
0x7022, 0x7022, 0x7802, 0x8023, 0x8823, 0x9043, 0x9844, 0xb065, 0xb824,
0xc864, 0xd862, 0xe882, 0xf103, 0xf122, 0xe923, 0xe963, 0xf9e4, 0xea03,
0xfb05, 0xfb25, 0xf2c6, 0xf224, 0xf204, 0xf204, 0xf265, 0xf2e7, 0xfb48,
0xf2e7, 0xea85, 0xfc4c, 0xfc0b, 0xf2e6, 0xfae6, 0xe203, 0xf306, 0xeb89,
0xeaa4, 0xf2a5, 0xea63, 0xfb86, 0xe264, 0xd225, 0x9986, 0x824a, 0x4a0c,
0x2a2e, 0x2a8f, 0x2312, 0x2352, 0x33d4, 0x3415, 0x2bb4, 0x3415, 0x2b93,
0x3cf8, 0x122d, 0x1189, 0x220d, 0x226f, 0x22b0, 0x2312, 0x33b4, 0x33d4,
0x3415, 0x3435, 0x3476, 0x3476, 0x3cd7, 0x3415, 0x3cf7, 0x3d38, 0x45b9,
0x45b9, 0x3d58, 0x45b9, 0x3d99, 0x3517, 0x2b93, 0x22b1, 0x1ad1, 0x228f,
0x226e, 0x1a4e, 0x1ab0, 0x2b94, 0x2b93, 0x2b93, 0x2bb4, 0x33b4, 0x2312,
0x3c16, 0x3c96, 0x34d7, 0x3cb7, 0x3c97, 0x3cf7, 0x3d18, 0x4559, 0x2c35,
0x3435, 0x3435, 0x3c76, 0x33f5, 0x22b1, 0x22b1, 0x1a2e, 0x1a2d, 0x226f,
0x1a6f, 0x22d1, 0x19ec, 0x19aa, 0x19aa, 0x1189, 0x19ca, 0x19aa, 0x885,
0x19ec, 0x34b6, 0x45d9, 0x4edb, 0x4e9a, 0x220c, 0x10a6, 0x19ec, 0x1a4e,
0x22d2, 0x224f, 0x19ec, 0x198a, 0x19cb, 0x19eb, 0x224f, 0x226f, 0x224f,
0x322e, 0x4a0c, 0x6a0c, 0x79c9, 0x9967, 0x8106, 0xc903, 0xb0a4, 0xe923,
0xd063, 0xc844, 0xc024, 0xb824, 0x9824, 0xa824, 0xa024, 0x9023, 0x7843,
0x8823, 0xa023, 0x9844, 0x9844, 0x9844, 0x9844, 0x9824, 0x9803, 0x9844,
0x9844, 0x9844, 0xa023, 0xa844, 0xb045, 0xc044, 0xc843, 0xd863, 0xe882,
0xf0e2, 0xf0c2, 0xf163, 0xf163, 0xfa24, 0xf2a5, 0xf2e5, 0xfb27, 0xe9e4,
0xe9a2, 0xf1e3, 0xf224, 0xf285, 0xf2c6, 0xfae7, 0xeaa4, 0xfb68, 0xfc0c,
0xf307, 0xea43, 0xea43, 0xe203, 0xfb27, 0xeb8a, 0xf2e6, 0xfae5, 0xf305,
0xf366, 0xe225, 0xca26, 0x91e7, 0x6a8d, 0x320e, 0x226f, 0x1a90, 0x2312,
0x2b73, 0x33d4, 0x33f5, 0x33b4, 0x3435, 0x3415, 0x3cb6, 0x1989, 0x19aa,
0x1a2e, 0x1a6f, 0x22f2, 0x2b74, 0x33b4, 0x33b4, 0x3415, 0x3456, 0x3456,
0x3cf7, 0x3d18, 0x2b93, 0x3d38, 0x3d98, 0x45b9, 0x3d78, 0x3d98, 0x45d9,
0x4578, 0x33d4, 0x1a2e, 0x2290, 0x1a0d, 0x19aa, 0x19cb, 0x1a6f, 0x22f2,
0x2312, 0x2313, 0x2b53, 0x1a6f, 0x1a4e, 0x2270, 0x2290, 0x2b73, 0x2b94,
0x33f4, 0x3cd7, 0x3cf7, 0x3496, 0x3d18, 0x34b6, 0x3517, 0x3cd7, 0x3c56,
0x2bd4, 0x3415, 0x3c76, 0x2b53, 0x22d1, 0x22b0, 0x226f, 0x1a2e, 0x1a90,
0x22d1, 0x2290, 0x19aa, 0x19aa, 0x1989, 0x19ca, 0x19aa, 0x10c6, 0x34b6,
0x4f1b, 0x56fa, 0x56b7, 0x3e36, 0x4efa, 0x232f, 0x8a6, 0x1a0c, 0x22b1,
0x22b1, 0x222e, 0x19aa, 0x19aa, 0x19cb, 0x1a2e, 0x224f, 0x2270, 0x324f,
0x420c, 0x724e, 0x79ea, 0xa187, 0x9106, 0xd985, 0xd924, 0xe903, 0xd8a2,
0xd043, 0xc864, 0xc045, 0xb844, 0x9024, 0xa845, 0x9823, 0x9064, 0x8023,
0x9043, 0xb064, 0xa845, 0xa024, 0xa044, 0xa845, 0xa845, 0xb045, 0xb844,
0xb844, 0xc844, 0xc843, 0xd043, 0xd842, 0xe862, 0xe881, 0xf0c2, 0xf143,
0xf1e4, 0xfaa4, 0xf2a4, 0xfae6, 0xf1c4, 0xf1c4, 0xf1a3, 0xe982, 0xf203,
0xfaa5, 0xea64, 0xf2c6, 0xf264, 0xf2e6, 0xf389, 0xfb06, 0xf2a5, 0xea43,
0xea24, 0xeac5, 0xf40c, 0xf2c5, 0xf2c5, 0xf345, 0xf305, 0xd204, 0xa9e6,
0x8aab, 0x4a4d, 0x2a4f, 0x2290, 0x22d1, 0x2b53, 0x33f5, 0x33d4, 0x2bb4,
0x2bb4, 0x2bf4, 0x4d58, 0x226e, 0x1189, 0x19cb, 0x224f, 0x228f, 0x2b53,
0x2b94, 0x33b4, 0x2b73, 0x33f5, 0x3455, 0x3c97, 0x3cf7, 0x3cb7, 0x3435,
0x3d58, 0x3db9, 0x4599, 0x3d58, 0x3dd9, 0x3538, 0x3c96, 0x228f, 0x224e,
0x19cb, 0x19aa, 0x19aa, 0x1a0d, 0x2290, 0x22b0, 0x224f, 0x1a2e, 0x220c,
0x19cb, 0x19cb, 0x19aa, 0x19ec, 0x19ec, 0x2313, 0x2332, 0x3bf5, 0x3415,
0x3cd7, 0x3517, 0x3496, 0x3cf8, 0x34b6, 0x4579, 0x4518, 0x3c96, 0x4497,
0x3c76, 0x3c76, 0x2b93, 0x1ab1, 0x1ab0, 0x226f, 0x1a4e, 0x1a4e, 0x1a6f,
0x22d1, 0x19ec, 0x19aa, 0x19aa, 0x19eb, 0x1989, 0x1127, 0x3537, 0x56d9,
0x55b2, 0x4cad, 0x54ef, 0x5591, 0x5697, 0x1a2b, 0x1107, 0x1a6f, 0x1a4f,
0x1a2d, 0x11aa, 0x19ca, 0x19ec, 0x222d, 0x224f, 0x2a91, 0x3290, 0x41ec,
0x6a0d, 0x79ea, 0xa9c8, 0xa946, 0xb8e4, 0xe143, 0xc083, 0xf1a4, 0xc043,
0xc843, 0xc844, 0xb064, 0xa844, 0xa044, 0xa845, 0xa044, 0x9023, 0x8823,
0xa063, 0xb863, 0xb864, 0xb024, 0xb845, 0xc044, 0xb844, 0xb844, 0xc824,
0xd063, 0xd863, 0xe062, 0xe8a2, 0xe922, 0xf203, 0xf263, 0xf2c4, 0xf265,
0xfa05, 0xf163, 0xf183, 0xe983, 0xe9a3, 0xe9c3, 0xf224, 0xfae6, 0xf2a5,
0xf264, 0xda44, 0xf307, 0xfb06, 0xf284, 0xfac6, 0xe1e3, 0xeac5, 0xfc6e,
0xf2a4, 0xe263, 0xf386, 0xda24, 0xca46, 0x91c8, 0x8b6e, 0x320d, 0x226f,
0x22b1, 0x2312, 0x2b74, 0x2b93, 0x33b4, 0x33b4, 0x3435, 0x2b93, 0x34b6,
0x1948, 0x198a, 0x19ec, 0x1a2e, 0x2312, 0x2b73, 0x2b93, 0x2353, 0x33f4,
0x3c56, 0x3415, 0x3496, 0x3cf7, 0x3c35, 0x3d58, 0x3d17, 0x3d78, 0x45da,
0x461a, 0x3d78, 0x34f7, 0x2b73, 0x1a0d, 0x19cb, 0x1989, 0x1169, 0x19cb,
0x222e, 0x1a2d, 0x198a, 0x19aa, 0x198a, 0x19aa, 0x1989, 0x19aa, 0x19cb,
0x19aa, 0x19cb, 0x22b0, 0x2374, 0x33d5, 0x2313, 0x2332, 0x33f5, 0x3c76,
0x3d17, 0x34d7, 0x4518, 0x34b6, 0x34f7, 0x3d38, 0x2c15, 0x3c76, 0x3415,
0x3c76, 0x3c56, 0x2312, 0x22b0, 0x22b0, 0x228f, 0x1a0d, 0x22b0, 0x2af2,
0x1a4e, 0x19cb, 0x1989, 0x19aa, 0x1148, 0x8c6, 0x3d58, 0x5e56, 0x64cb,
0x6c8b, 0x5636, 0x652d, 0x546d, 0x5f7b, 0x1928, 0x1a2e, 0x2290, 0x226e,
0x19aa, 0x198a, 0x19cb, 0x1a0d, 0x2290, 0x2ab0, 0x3290, 0x41ec, 0x622c,
0x822b, 0xb1c8, 0xb945, 0x8884, 0xe1c4, 0xb883, 0xf1a3, 0xc843, 0xc863,
0xc864, 0xc044, 0xb045, 0xa844, 0xa003, 0xa844, 0xa024, 0x9844, 0x9043,
0x9022, 0xc082, 0xd8c2, 0xd0a2, 0xe0e2, 0xd8e2, 0xd0a1, 0xe102, 0xe162,
0xf1e3, 0xf223, 0xfaa4, 0xf244, 0xf143, 0xf122, 0xe902, 0xf143, 0xe0c1,
0xf1a4, 0xf1a3, 0xe9c3, 0xfa85, 0xfaa5, 0xf264, 0xf284, 0xfb89, 0xf369,
0xf2a4, 0xfaa5, 0xf264, 0xe1c3, 0xfb06, 0xfc8e, 0xf2c5, 0xf2c5, 0xfbe7,
0xd205, 0xb227, 0x7a0a, 0x628d, 0x322e, 0x228f, 0x22d1, 0x2b74, 0x33d5,
0x2b94, 0x2b94, 0x33f5, 0x33f4, 0x2352, 0x33b4, 0x1988, 0x19aa, 0x19ec,
0x1a4f, 0x2312, 0x2b94, 0x2b94, 0x2b73, 0x3436, 0x3c35, 0x2c55, 0x3cf7,
0x34b6, 0x2393, 0x3d38, 0x4558, 0x45b9, 0x3578, 0x461a, 0x34f7, 0x3cb7,
0x22b0, 0x19aa, 0x19a9, 0x1989, 0x21eb, 0x19ab, 0x19aa, 0x19aa, 0x19a9,
0x19aa, 0x1989, 0x1989, 0x1989, 0x19cb, 0x19cb, 0x226e, 0x2b74, 0x3476,
0x3d78, 0x19aa, 0x2b73, 0x33d5, 0x2b73, 0x2333, 0x33f5, 0x3c76, 0x3cf7,
0x34d7, 0x34b7, 0x3cf8, 0x3d18, 0x3d38, 0x3c96, 0x3cb7, 0x3415, 0x3c97,
0x3496, 0x33b5, 0x1ab1, 0x22b1, 0x2290, 0x1a4f, 0x22b0, 0x22d1, 0x22f1,
0x19cc, 0x19aa, 0x19aa, 0x1127, 0x1969, 0x3dd9, 0x4e14, 0x7ccc, 0xac48,
0x4db3, 0x4e78, 0x9d4d, 0x4dd5, 0x226d, 0x19aa, 0x1a70, 0x224f, 0x19ca,
0x1169, 0x19cb, 0x226f, 0x226f, 0x22b1, 0x3ab0, 0x41ed, 0x6a2c, 0x8a4c,
0xa9c7, 0xb945, 0x98a2, 0xd963, 0xd0e3, 0xe983, 0xd882, 0xc843, 0xc843,
0xc843, 0xc044, 0xb844, 0xa003, 0xb045, 0xb024, 0xa844, 0xa845, 0xa865,
0xa844, 0xa823, 0xb843, 0xb823, 0xc863, 0xd863, 0xe062, 0xe862, 0xe882,
0xf0a3, 0xe862, 0xe062, 0xe061, 0xe8a1, 0xf123, 0xe963, 0xf1c4, 0xf204,
0xf244, 0xea23, 0xea23, 0xfac5, 0xfba9, 0xfb47, 0xea23, 0xea43, 0xe1e3,
0xd9a2, 0xf2e5, 0xf3cb, 0xea43, 0xf366, 0xfbe9, 0xca67, 0xa248, 0x6a2c,
0x39eb, 0x2a2e, 0x2270, 0x22f1, 0x2b73, 0x2b94, 0x2b94, 0x33b4, 0x33f5,
0x33d4, 0x2b74, 0x224e, 0x1128, 0x19aa, 0x222e, 0x2290, 0x3394, 0x2b73,
0x2353, 0x2bb4, 0x3415, 0x33f4, 0x3455, 0x3496, 0x4518, 0x2c14, 0x4558,
0x3d58, 0x3d98, 0x4e5b, 0x3d37, 0x3d18, 0x3415, 0x1a4e, 0x19cb, 0x1989,
0x19cb, 0x19aa, 0x19aa, 0x1989, 0x19a9, 0x1989, 0x19aa, 0x19aa, 0x19aa,
0x19cb, 0x1a2d, 0x1a6f, 0x2b74, 0x3c97, 0x3d17, 0x45b9, 0x45d9, 0x1a2d,
0x224e, 0x22d0, 0x33b5, 0x2b53, 0x2353, 0x2bb4, 0x33f5, 0x44f8, 0x3d58,
0x3cd7, 0x3d18, 0x34f7, 0x3d58, 0x3d18, 0x3476, 0x3435, 0x3c96, 0x3cb6,
0x33f5, 0x1ad1, 0x22d1, 0x22b1, 0x1a4e, 0x228f, 0x22b1, 0x1ad1, 0x1a4f,
0x1a0c, 0x1169, 0x1106, 0x3c14, 0x46ba, 0x5ed8, 0x7d0c, 0xac08, 0x7d4e,
0x4659, 0x850d, 0x5cac, 0x5eba, 0x1128, 0x22b0, 0x226f, 0x19aa, 0x1169,
0x19ec, 0x224f, 0x226f, 0x2ab1, 0x3290, 0x39cd, 0x620c, 0x7a0b, 0xa9e8,
0xb965, 0xc9a5, 0xd983, 0xe163, 0xe123, 0xd8a2, 0xc084, 0xd043, 0xd044,
0xc844, 0xc044, 0xc844, 0xb065, 0xb024, 0xb845, 0xa824, 0xb024, 0xb044,
0xb865, 0xb844, 0xb824, 0xc044, 0xc023, 0xd042, 0xd843, 0xd842, 0xe062,
0xe882, 0xe8c2, 0xe902, 0xf163, 0xe9a3, 0xf224, 0xf224, 0xe9e3, 0xf244,
0xea64, 0xea44, 0xf284, 0xea43, 0xe202, 0xd982, 0xe203, 0xea84, 0xf368,
0xf2a5, 0xf3a7, 0xd2c7, 0xb248, 0x9acc, 0x51cb, 0x3a0d, 0x2a2e, 0x22b0,
0x2312, 0x2333, 0x33b4, 0x2b94, 0x3394, 0x33f5, 0x2b73, 0x1af2, 0x118a,
0x928, 0x19ca, 0x222d, 0x1a90, 0x2312, 0x2b53, 0x2b53, 0x33d5, 0x3415,
0x33d4, 0x3c96, 0x3cb6, 0x3455, 0x3cf7, 0x3cf7, 0x3d78, 0x45d9, 0x4e3a,
0x3d38, 0x3d17, 0x2312, 0x1a4e, 0x19ab, 0x19aa, 0x19aa, 0x198a, 0x19aa,
0x19aa, 0x198a, 0x19aa, 0x19aa, 0x19cb, 0x224e, 0x1a70, 0x1ab0, 0x2b94,
0x3455, 0x3cd7, 0x3d38, 0x3d78, 0x3578, 0x4639, 0x2290, 0x1a2e, 0x2290,
0x19ec, 0x2b53, 0x2b54, 0x2353, 0x33f5, 0x33f5, 0x3475, 0x34f7, 0x3d38,
0x3d18, 0x4538, 0x4579, 0x3d38, 0x3476, 0x3456, 0x3476, 0x3cd7, 0x33f5,
0x2b53, 0x22d1, 0x22d1, 0x2290, 0x1a4e, 0x22b1, 0x22b0, 0x22b0, 0x198a,
0x1169, 0x1106, 0x3dd9, 0x467a, 0x467a, 0x64cb, 0xb3c7, 0xad2d, 0x3d58,
0x5ccd, 0x858e, 0x4eda, 0x1927, 0x2290, 0x1a4f, 0x1969, 0x1989, 0x19cb,
0x226f, 0x226f, 0x22d1, 0x3290, 0x39ed, 0x61ec, 0x824b, 0xaa08, 0xb985,
0xe246, 0xd9a4, 0xe163, 0xd0c2, 0xd922, 0xb844, 0xc843, 0xc844, 0xd843,
0xc844, 0xc044, 0xd043, 0xc044, 0xb064, 0xc024, 0xb844, 0xc043, 0xc844,
0xc023, 0xc043, 0xc843, 0xd043, 0xe062, 0xe062, 0xe881, 0xf0e3, 0xf103,
0xe963, 0xf9e4, 0xf1e4, 0xe9c3, 0xf224, 0xf264, 0xf2e5, 0xfb68, 0xf264,
0xf243, 0xea43, 0xd983, 0xf244, 0xf2c5, 0xf2c6, 0xeac4, 0xfbe7, 0xba06,
0x9a8a, 0x830e, 0x420c, 0x3a4e, 0x222e, 0x1a70, 0x2b33, 0x2b53, 0x2b94,
0x33d5, 0x2b73, 0x2b93, 0x2b73, 0x2312, 0x10e7, 0x1148, 0x19ca, 0x19ec,
0x1a70, 0x2313, 0x2332, 0x2b73, 0x2b73, 0x33f5, 0x2bb4, 0x3c56, 0x3c96,
0x3415, 0x4599, 0x34b6, 0x3db9, 0x45f9, 0x45f9, 0x4538, 0x3cf8, 0x2290,
0x224e, 0x19ca, 0x220d, 0x19cb, 0x19aa, 0x198a, 0x19aa, 0x19ca, 0x19cb,
0x1a2e, 0x1a90, 0x22d1, 0x2333, 0x2b93, 0x2c14, 0x3496, 0x34d7, 0x3d78,
0x3d58, 0x463a, 0x4d72, 0x3beb, 0x22f2, 0x2270, 0x2290, 0x22d2, 0x228f,
0x2b94, 0x2b74, 0x2b74, 0x2bb4, 0x3415, 0x44b7, 0x3d38, 0x3d38, 0x3d38,
0x4579, 0x3d38, 0x2c55, 0x3496, 0x3cb7, 0x3476, 0x3496, 0x3476, 0x3394,
0x22d1, 0x22d2, 0x1a70, 0x1a4e, 0x22b0, 0x22f2, 0x1ab1, 0x19ec, 0x1189,
0x1107, 0x465a, 0x3df9, 0x3e3a, 0x5d30, 0xb449, 0xad8e, 0x3517, 0x65f2,
0x7cec, 0x67bc, 0x1107, 0x22b0, 0x1a4e, 0x1107, 0x19ab, 0x19ec, 0x226f,
0x1a4f, 0x22b0, 0x3290, 0x39ed, 0x59cb, 0x7a2c, 0xaa29, 0xb9c6, 0xdaa6,
0xc903, 0xe163, 0xd8a2, 0xe943, 0xc863, 0xc064, 0xd863, 0xc843, 0xd843,
0xd043, 0xd043, 0xc843, 0xd863, 0xd043, 0xc043, 0xc864, 0xc843, 0xd063,
0xd862, 0xd842, 0xe062, 0xe8a2, 0xe903, 0xf163, 0xe962, 0xe923, 0xf183,
0xf1e4, 0xf204, 0xfac6, 0xf264, 0xea23, 0xf244, 0xea23, 0xe1e3, 0xd983,
0xea23, 0xf327, 0xda42, 0xf366, 0xfbe8, 0xb1e6, 0x92ac, 0x62ad, 0x3a0d,
0x322e, 0x2a50, 0x2af1, 0x2312, 0x2b73, 0x3394, 0x2b94, 0x2b73, 0x2b73,
0x22f2, 0x22d1, 0x1065, 0x1969, 0x19aa, 0x222d, 0x1a70, 0x22d1, 0x2312,
0x2332, 0x2b53, 0x3394, 0x2bb3, 0x3415, 0x3c56, 0x3435, 0x4599, 0x3cf7,
0x3db9, 0x3dd9, 0x3d58, 0x3cf7, 0x3455, 0x22b1, 0x220d, 0x19cb, 0x220d,
0x19cb, 0x198a, 0x198a, 0x19aa, 0x220d, 0x1a0c, 0x2311, 0x2353, 0x33d5,
0x3415, 0x3415, 0x3456, 0x2c55, 0x3d18, 0x3d38, 0x461a, 0x4e16, 0x4531,
0x446d, 0x43eb, 0x3435, 0x2b73, 0x228f, 0x22b1, 0x1ad1, 0x2b12, 0x2b73,
0x2b73, 0x2b53, 0x2bb4, 0x3c97, 0x3476, 0x4559, 0x3d78, 0x3d17, 0x3d18,
0x3517, 0x3cf7, 0x34d7, 0x3cd7, 0x3c96, 0x3cb7, 0x3435, 0x33d5, 0x1ab0,
0x22f2, 0x2290, 0x2270, 0x2290, 0x22d1, 0x22d1, 0x226f, 0x118a, 0x1127,
0x3537, 0x3dd8, 0x45f9, 0x4e36, 0x846b, 0x6d4f, 0x3c75, 0x4d10, 0xb52c,
0x5e55, 0x1948, 0x2af1, 0x226e, 0x1147, 0x1189, 0x222d, 0x1a2f, 0x22b0,
0x2ad1, 0x32b0, 0x31ad, 0x51ec, 0x828d, 0x9a09, 0xc248, 0xeae7, 0xb0e3,
0xe1a3, 0xe143, 0xe963, 0xe0e3, 0xc064, 0xc843, 0xd063, 0xd063, 0xd863,
0xd862, 0xd042, 0xd043, 0xd042, 0xd842, 0xe062, 0xe061, 0xe061, 0xe881,
0xe8a1, 0xe8c2, 0xe8c2, 0xe0c1, 0xe101, 0xe983, 0xf1c3, 0xf224, 0xf224,
0xea24, 0xea03, 0xea03, 0xe203, 0xd982, 0xd163, 0xea64, 0xf2c6, 0xea84,
0xfc08, 0xc245, 0xa208, 0x82cc, 0x4a0c, 0x3a4e, 0x2a4f, 0x2270, 0x22f2,
0x2b33, 0x2b94, 0x2b73, 0x2b53, 0x2333, 0x2b53, 0x22b0, 0x22b0, 0x2066,
0x1107, 0x19ab, 0x1a0d, 0x1a90, 0x2313, 0x2332, 0x2312, 0x2312, 0x2b74,
0x2b94, 0x3bf5, 0x2bf4, 0x2bb4, 0x4559, 0x3475, 0x45b9, 0x45f9, 0x3d18,
0x34f7, 0x3415, 0x1a6f, 0x19ec, 0x19ec, 0x1a0d, 0x19cb, 0x19cb, 0x19cb,
0x1a2e, 0x1a2e, 0x1a6e, 0x33d4, 0x3c36, 0x3456, 0x3456, 0x3456, 0x3435,
0x3cd7, 0x3d17, 0x3d58, 0x56ba, 0x45b4, 0x4d32, 0x44af, 0x4d10, 0x440b,
0x3c97, 0x2bf4, 0x2b53, 0x22b1, 0x22d1, 0x2333, 0x2b54, 0x2b53, 0x2b74,
0x2b73, 0x2bb4, 0x3435, 0x3cd7, 0x3496, 0x3d58, 0x3d18, 0x3d17, 0x3d38,
0x3d18, 0x2c75, 0x3496, 0x3496, 0x3cf7, 0x3c96, 0x33b4, 0x22f1, 0x2b52,
0x22b1, 0x226f, 0x2290, 0x1ad1, 0x1ab1, 0x2270, 0x19cb, 0x1108, 0x45d9,
0x2352, 0x3495, 0x4679, 0x7d2d, 0x4eb9, 0x3455, 0x6590, 0xacca, 0x5ed8,
0x1107, 0x1a70, 0x224f, 0x1148, 0x21eb, 0x224e, 0x226f, 0x22b1, 0x2af1,
0x3ab1, 0x31ed, 0x49ec, 0x7a8d, 0xa26b, 0xba28, 0xdae7, 0xa0a3, 0xe1a3,
0xe143, 0xd902, 0xd8c2, 0xc063, 0xc064, 0xd063, 0xe083, 0xd043, 0xe062,
0xe062, 0xe062, 0xe042, 0xe882, 0xe081, 0xe8a3, 0xf0e3, 0xe8e2, 0xf122,
0xe922, 0xe101, 0xf1e4, 0xe9a3, 0xe982, 0xe9e3, 0xe9c3, 0xe9e3, 0xea03,
0xd9a3, 0xd143, 0xd9a3, 0xf2a5, 0xf2e6, 0xeb66, 0xfc6a, 0xba89, 0x92cc,
0x6ace, 0x31ec, 0x2a0e, 0x2a4f, 0x2290, 0x22d1, 0x2312, 0x2b73, 0x2b94,
0x2b53, 0x2312, 0x2b53, 0x1a70, 0x1a70, 0x48ca, 0x1147, 0x19aa, 0x1a0c,
0x22b1, 0x2313, 0x2312, 0x1ab1, 0x22f1, 0x2b73, 0x2b94, 0x3c16, 0x33f5,
0x2b94, 0x3d18, 0x3cb7, 0x4599, 0x4e1a, 0x3cf7, 0x3d38, 0x2bb4, 0x224e,
0x19cb, 0x1a0d, 0x226f, 0x1a2d, 0x19eb, 0x1a0c, 0x224e, 0x22d1, 0x3394,
0x3c56, 0x34b6, 0x3cb7, 0x3476, 0x3455, 0x3cb7, 0x3cd7, 0x3d38, 0x467a,
0x4e79, 0x4e38, 0x4e16, 0x4d73, 0x4511, 0x44ae, 0x43eb, 0x3415, 0x4539,
0x3c35, 0x33d4, 0x22f2, 0x22d2, 0x2333, 0x2b94, 0x2b73, 0x2b73, 0x2b33,
0x33d5, 0x3435, 0x3cd7, 0x3cf7, 0x3d58, 0x3d17, 0x3d18, 0x4599, 0x3538,
0x3d17, 0x3cf7, 0x3476, 0x3cb7, 0x3cd7, 0x33d4, 0x22f1, 0x2312, 0x1a90,
0x1a4f, 0x1a4f, 0x22b0, 0x1ab1, 0x1a6f, 0x19ab, 0x907, 0x3d58, 0x224e,
0x22af, 0x3e9a, 0x5eb7, 0x2c34, 0x3cb6, 0x55b1, 0xa52d, 0x4eda, 0x1128,
0x1a4f, 0x1a0c, 0x1169, 0x220d, 0x1a2d, 0x2290, 0x1ab1, 0x2af1, 0x32b1,
0x29ee, 0x41ec, 0x830f, 0x8a4b, 0xba49, 0xca67, 0xc124, 0xe1c4, 0xe163,
0xd902, 0xe102, 0xd882, 0xc063, 0xc043, 0xc843, 0xe082, 0xd842, 0xd842,
0xf0c2, 0xe8c2, 0xf102, 0xf143, 0xe922, 0xf183, 0xe963, 0xe983, 0xe962,
0xe9e3, 0xe982, 0xe983, 0xe163, 0xe182, 0xe1a3, 0xd942, 0xd163, 0xe203,
0xf2e6, 0xe2c5, 0xfc4a, 0xbae8, 0x92cb, 0x72ee, 0x424d, 0x29ed, 0x2a4f,
0x224f, 0x2af1, 0x2b12, 0x2333, 0x2b73, 0x2353, 0x2b53, 0x1ad1, 0x2b53,
0x228f, 0x2a6f, 0x58ca, 0x8e6, 0x19aa, 0x19cb, 0x1a90, 0x22f2, 0x2b33,
0x2b12, 0x1ad1, 0x2b93, 0x2bb4, 0x3415, 0x3c36, 0x33d4, 0x3cf7, 0x3496,
0x3d58, 0x3d78, 0x34f7, 0x3d18, 0x33d4, 0x224e, 0x1a0c, 0x1a2e, 0x22b0,
0x1a70, 0x2290, 0x2290, 0x3353, 0x228f, 0x2bd4, 0x3476, 0x34d7, 0x3496,
0x3cd7, 0x3cf7, 0x34d7, 0x3cf7, 0x3df9, 0x4679, 0x4659, 0x4658, 0x4e58,
0x4e16, 0x4d73, 0x44f1, 0x44af, 0x4cae, 0x2b33, 0x33d4, 0x3496, 0x3456,
0x2b73, 0x22b1, 0x1ad1, 0x2333, 0x2332, 0x2b32, 0x2b94, 0x2312, 0x2bb4,
0x3456, 0x3cd7, 0x34d7, 0x3d58, 0x4579, 0x3cf7, 0x3d38, 0x3d38, 0x3d37,
0x34b6, 0x3455, 0x3cf7, 0x3cf7, 0x33f5, 0x2312, 0x22f2, 0x22d1, 0x1a6f,
0x1a4f, 0x22d1, 0x22d1, 0x22d1, 0x19ec, 0x1107, 0x3435, 0x1a4f, 0x228f,
0x4578, 0x45fa, 0x1a2e, 0x3d37, 0x65b1, 0x6ced, 0x569a, 0x19cb, 0x1a4f,
0x19ec, 0x224e, 0x1a0d, 0x226f, 0x1a6f, 0x2312, 0x2b32, 0x2ab0, 0x2a0e,
0x39ed, 0x732f, 0x7a6c, 0xa229, 0xcac8, 0xc165, 0xc0e2, 0xe163, 0xe123,
0xe102, 0xf184, 0xd882, 0xc863, 0xc843, 0xc043, 0xc043, 0xd841, 0xf0c2,
0xf943, 0xf983, 0xe983, 0xf183, 0xe102, 0xe0e2, 0xe122, 0xe142, 0xd922,
0xe163, 0xe184, 0xd122, 0xc8e1, 0xd9c3, 0xe285, 0xe307, 0xf40a, 0xec8d,
0x9b2c, 0x730e, 0x422d, 0x324f, 0x324e, 0x224e, 0x2291, 0x22f2, 0x22d1,
0x22f2, 0x2b74, 0x2333, 0x2333, 0x22f2, 0x2312, 0x2290, 0x224e, 0x70cb,
0x10a6, 0x118a, 0x19ab, 0x2290, 0x2312, 0x22d1, 0x22f2, 0x1a90, 0x2b73,
0x33f5, 0x3415, 0x3435, 0x33b4, 0x3476, 0x3496, 0x2cd6, 0x3d79, 0x3d17,
0x3cf7, 0x33d4, 0x222e, 0x1a2d, 0x224f, 0x22b0, 0x1a6f, 0x224f, 0x2b72,
0x3c14, 0x2b32, 0x3456, 0x3cb7, 0x34b6, 0x3d18, 0x4558, 0x34f7, 0x3517,
0x3db8, 0x467a, 0x465a, 0x4639, 0x4e9a, 0x4e99, 0x4638, 0x45d5, 0x4db4,
0x4d95, 0x446d, 0x5429, 0x22b0, 0x1a91, 0x2393, 0x2bf5, 0x2c35, 0x2b53,
0x1ad1, 0x22f2, 0x2312, 0x2b74, 0x2b73, 0x2b93, 0x2353, 0x33d5, 0x3456,
0x3cf7, 0x3cf7, 0x4599, 0x3d99, 0x34f7, 0x3d58, 0x3537, 0x4558, 0x3cd7,
0x3496, 0x3cf7, 0x3496, 0x33b4, 0x2b73, 0x2312, 0x1ad1, 0x2290, 0x1a4f,
0x22d1, 0x1ab1, 0x22b1, 0x19eb, 0x1128, 0x33b3, 0x224e, 0x1a0d, 0x1a4e,
0x1a2d, 0x222e, 0x3d78, 0x5635, 0x55d1, 0x2370, 0x198a, 0x1a4e, 0x224f,
0x1a2d, 0x1a0c, 0x1a4f, 0x1a6f, 0x2b33, 0x2312, 0x2ab1, 0x2a2e, 0x320e,
0x62ee, 0x7aae, 0xa26a, 0xc2e9, 0xc9c5, 0xc903, 0xe1e3, 0xe143, 0xe143,
0xe942, 0xe903, 0xe082, 0xd862, 0xd063, 0xd063, 0xd883, 0xd862, 0xd882,
0xd882, 0xd881, 0xd8c2, 0xe102, 0xe122, 0xe142, 0xd0c1, 0xd943, 0xc8e3,
0xd9a4, 0xda45, 0xe307, 0xec2a, 0xf4ac, 0x92ca, 0x836f, 0x52ae, 0x3a8f,
0x324f, 0x222f, 0x2270, 0x22d1, 0x22d2, 0x22f2, 0x2313, 0x2b94, 0x2312,
0x2b13, 0x2312, 0x2332, 0x1a2e, 0x1a0d, 0xa12e, 0x1065, 0x1168, 0x1148,
0x222d, 0x22f2, 0x22d2, 0x2290, 0x22b1, 0x2312, 0x2b93, 0x3476, 0x33d4,
0x3415, 0x3415, 0x33f4, 0x3d58, 0x3517, 0x3d38, 0x3d38, 0x3c35, 0x226f,
0x224e, 0x1a2e, 0x224e, 0x222d, 0x3415, 0x34f7, 0x22f1, 0x2b33, 0x3436,
0x3476, 0x3cf7, 0x3d17, 0x3d78, 0x3d38, 0x3dd9, 0x4e9b, 0x4e9a, 0x465a,
0x467a, 0x467a, 0x4659, 0x4618, 0x4e58, 0x4617, 0x4d93, 0x444d, 0x43c8,
0x4409, 0x19ca, 0x1a6d, 0x226f, 0x2b74, 0x3456, 0x3456, 0x2311, 0x1ab1,
0x22d1, 0x22f2, 0x2bb5, 0x3394, 0x2b94, 0x22f2, 0x2bb4, 0x3c76, 0x3476,
0x3d18, 0x3517, 0x45b9, 0x4558, 0x3d58, 0x3d58, 0x4579, 0x3cf7, 0x3496,
0x3d38, 0x3cb7, 0x3c35, 0x2b73, 0x2312, 0x22f1, 0x2290, 0x1a6f, 0x22d1,
0x1ab1, 0x2290, 0x220c, 0x1969, 0x2b52, 0x224f, 0x19ca, 0x1a0d, 0x224e,
0x224e, 0x3db9, 0x6696, 0x4e76, 0x222c, 0x224e, 0x1a6f, 0x224e, 0x1a0d,
0x1a0d, 0x1a6f, 0x1a90, 0x2b33, 0x2b33, 0x2ad1, 0x2a6f, 0x324f, 0x5b30,
0x5a2c, 0x92ab, 0xbb0a, 0xca87, 0xc965, 0xe1e5, 0xd982, 0xe122, 0xe0e2,
0xe0c2, 0xf163, 0xe902, 0xd861, 0xe0c2, 0xd882, 0xd882, 0xe0c2, 0xd8e2,
0xd0a2, 0xd0c1, 0xe183, 0xc8e2, 0xc0e3, 0xd9c4, 0xd246, 0xd2c6, 0xe3ea,
0xf4ee, 0x92ec, 0x838f, 0x52ae, 0x42af, 0x326f, 0x222e, 0x224f, 0x1a70,
0x22f2, 0x22d2, 0x2312, 0x2333, 0x2b53, 0x22f2, 0x22f1, 0x22f2, 0x2b33,
0x228f, 0x19ec, 0xa8ed, 0x1845, 0x1989, 0x1128, 0x19cb, 0x1a90, 0x2290,
0x1a90, 0x22d2, 0x22b1, 0x2332, 0x3c36, 0x2bb4, 0x33f5, 0x3415, 0x3415,
0x4579, 0x3d18, 0x3cf7, 0x34b6, 0x3455, 0x22b0, 0x226f, 0x1a0d, 0x19ec,
0x3435, 0x3d58, 0x3cd7, 0x1a6f, 0x2b54, 0x33f4, 0x3476, 0x34b6, 0x3d78,
0x3d78, 0x3d57, 0x4edb, 0x4edb, 0x465a, 0x35d8, 0x465a, 0x465a, 0x4e9a,
0x3e38, 0x4e79, 0x35d6, 0x4e16, 0x446e, 0x3bc9, 0x442c, 0x3baa, 0x1988,
0x19cb, 0x226f, 0x226f, 0x2b33, 0x3415, 0x3456, 0x22f2, 0x22f2, 0x22f2,
0x1ad1, 0x2b74, 0x33b4, 0x33d5, 0x2b53, 0x33d4, 0x3476, 0x34b6, 0x4538,
0x3d58, 0x4599, 0x3d18, 0x3d58, 0x3d38, 0x3d58, 0x3d18, 0x3496, 0x3d18,
0x3cf7, 0x33f4, 0x2b74, 0x2312, 0x1ad1, 0x1a6f, 0x1a6f, 0x22d1, 0x22d1,
0x22b1, 0x1a0d, 0x1189, 0x3c15, 0x226f, 0x19ab, 0x19cb, 0x1a4f, 0x224e,
0x3d97, 0x6614, 0x4f3a, 0x1948, 0x2270, 0x1a4f, 0x220d, 0x220d, 0x1a2d,
0x1a6f, 0x22d2, 0x2332, 0x2312, 0x2290, 0x224f, 0x32b0, 0x63d1, 0x522d,
0x8b0e, 0xaaea, 0xba68, 0xd267, 0xd184, 0xea85, 0xe9e4, 0xd8e2, 0xd8c2,
0xe0e2, 0xe0e2, 0xe0e2, 0xe102, 0xd8e2, 0xe123, 0xd903, 0xc8c2, 0xd123,
0xd1a3, 0xe246, 0xca25, 0xe389, 0xec4b, 0xecae, 0x932d, 0x836f, 0x52ae,
0x5331, 0x3290, 0x222e, 0x222e, 0x2290, 0x22d2, 0x22f2, 0x1ad2, 0x2312,
0x3394, 0x2312, 0x2313, 0x22d2, 0x2b12, 0x2313, 0x1a0d, 0x19ec, 0xc12c,
0x4068, 0x1127, 0x1128, 0x19aa, 0x226f, 0x1a4f, 0x22b0, 0x2b33, 0x1a90,
0x22f2, 0x33d5, 0x2b74, 0x33f5, 0x33f5, 0x2b53, 0x3cd7, 0x34b6, 0x3496,
0x3476, 0x3476, 0x22b0, 0x1a0c, 0x222e, 0x3456, 0x4558, 0x3cf7, 0x33f5,
0x1a6f, 0x2313, 0x33d4, 0x3455, 0x3d17, 0x3d58, 0x3d78, 0x4e7a, 0x4eba,
0x467a, 0x465a, 0x3e19, 0x4639, 0x3e39, 0x467a, 0x467a, 0x3e18, 0x4e79,
0x45d5, 0x4caf, 0x446e, 0x44d0, 0x4c4d, 0x440a, 0x1189, 0x19aa, 0x19ec,
0x226f, 0x19ec, 0x2b74, 0x3455, 0x3455, 0x22f1, 0x22f1, 0x2b53, 0x22f1,
0x2b53, 0x33b4, 0x33d5, 0x2353, 0x33f5, 0x3496, 0x3cd7, 0x4559, 0x3558,
0x3d99, 0x3d18, 0x4578, 0x3d37, 0x3d58, 0x3d17, 0x2c75, 0x3d58, 0x3455,
0x3c15, 0x2b93, 0x2332, 0x1af1, 0x1a90, 0x1a6f, 0x22b1, 0x22b1, 0x22f2,
0x21eb, 0x1968, 0x22d0, 0x22d2, 0x198a, 0x19aa, 0x226f, 0x2351, 0x4efa,
0x573a, 0x4599, 0x1129, 0x22b1, 0x224e, 0x1a0d, 0x222d, 0x226f, 0x226f,
0x1ab1, 0x2b53, 0x2b13, 0x22d1, 0x2ab0, 0x2a90, 0x6413, 0x39ec, 0x72ee,
0x9b0c, 0xc30b, 0xcac9, 0xd267, 0xc964, 0xe225, 0xeae5, 0xea44, 0xea45,
0xe9c4, 0xd963, 0xe1a4, 0xd9c4, 0xda25, 0xd245, 0xe307, 0xe388, 0xf42a,
0xec6b, 0x9a8a, 0x934e, 0x734f, 0x5aef, 0x4acf, 0x3ab0, 0x2a90, 0x2a90,
0x2250, 0x22b1, 0x2b33, 0x22d2, 0x1ad1, 0x2332, 0x2312, 0x1ab1, 0x2b33,
0x1ab1, 0x22f2, 0x2312, 0x222e, 0x1189, 0xc149, 0x60ea, 0x10c6, 0x1147,
0x1127, 0x19cb, 0x226f, 0x226f, 0x1ab1, 0x1a6f, 0x1a6f, 0x33b5, 0x2b73,
0x33d4, 0x33b4, 0x2b73, 0x3c97, 0x3476, 0x3456, 0x3476, 0x3c15, 0x1ab0,
0x224e, 0x3c35, 0x3d58, 0x34b6, 0x3435, 0x2332, 0x1a6f, 0x2312, 0x2b93,
0x3496, 0x3d78, 0x3d58, 0x4e7a, 0x571b, 0x4efb, 0x3e19, 0x4639, 0x465a,
0x465a, 0x4659, 0x467a, 0x465a, 0x4659, 0x4e78, 0x45f5, 0x4d72, 0x4d52,
0x44cf, 0x440c, 0x446d, 0x444e, 0x22d1, 0x1989, 0x19cb, 0x1a0d, 0x222d,
0x19cb, 0x33d5, 0x33d4, 0x3c97, 0x2353, 0x22d1, 0x22f2, 0x2353, 0x22f2,
0x2bb3, 0x33f5, 0x2b74, 0x33d5, 0x3c56, 0x3476, 0x3d38, 0x3d58, 0x3d78,
0x34f7, 0x3d58, 0x3d17, 0x3d58, 0x3517, 0x3c96, 0x3d99, 0x3cb7, 0x3c55,
0x33b4, 0x2353, 0x2312, 0x1a90, 0x228f, 0x22d1, 0x22d1, 0x2290, 0x21ec,
0x1127, 0x198a, 0x19cb, 0x19aa, 0x1a4f, 0x224f, 0x3d17, 0x573b, 0x467a,
0x1a6e, 0x1a0c, 0x2290, 0x1a2d, 0x1a0d, 0x224e, 0x226f, 0x2290, 0x22f2,
0x2b33, 0x2b74, 0x1a70, 0x2290, 0x32d1, 0x4b92, 0x322d, 0x4a2d, 0x7aee,
0x9aeb, 0xaa69, 0xcac9, 0xd287, 0xca06, 0xd205, 0xc965, 0xc9e4, 0xf348,
0xf3a8, 0xfbe9, 0xf40a, 0xdb6a, 0xaa48, 0xa2aa, 0xa34c, 0x8b4d, 0x7bb0,
0x426d, 0x4b10, 0x3290, 0x2a70, 0x224f, 0x2ab0, 0x22d1, 0x2332, 0x22f2,
0x2313, 0x2312, 0x2313, 0x2313, 0x22d1, 0x2312, 0x22f2, 0x2312, 0x2af1,
0x1a2e, 0x48e7, 0xc126, 0x890b, 0x1885, 0x8c5, 0x1085, 0x19ab, 0x19cb,
0x1a0d, 0x1a6f, 0x2291, 0x2291, 0x2b74, 0x2b93, 0x2b94, 0x33f5, 0x2b74,
0x3435, 0x3476, 0x2bd4, 0x3415, 0x3415, 0x2333, 0x2b94, 0x3d17, 0x3496,
0x3415, 0x33f5, 0x22b0, 0x22f2, 0x2332, 0x3394, 0x34b6, 0x3d58, 0x3db8,
0x4f1b, 0x4eb9, 0x46ba, 0x56db, 0x465a, 0x3e39, 0x4659, 0x3e59, 0x4679,
0x3e39, 0x4659, 0x4678, 0x45b4, 0x4552, 0x4511, 0x44cf, 0x4cae, 0x448e,
0x43e9, 0x4bc9, 0x1a0d, 0x2291, 0x198a, 0x19ec, 0x22b0, 0x11ab, 0x19ec,
0x2b94, 0x3c56, 0x3435, 0x2b73, 0x22d1, 0x22d2, 0x3394, 0x1a8f, 0x33b4,
0x33d5, 0x3c36, 0x33f4, 0x3456, 0x3cf7, 0x3d58, 0x3d38, 0x3578, 0x3d17,
0x3d58, 0x3d37, 0x3d78, 0x3d38, 0x3496, 0x4599, 0x3496, 0x3435, 0x2bb4,
0x2353, 0x2b33, 0x2290, 0x22b0, 0x22d1, 0x2af2, 0x22b0, 0x198a, 0x10c7,
0x1168, 0x198a, 0x19cb, 0x1a4f, 0x1a4f, 0x4679, 0x4efb, 0x3c56, 0x21aa,
0x22b0, 0x2290, 0x224e, 0x226f, 0x222e, 0x2290, 0x1a70, 0x2b33, 0x2b32,
0x2313, 0x22d1, 0x2290, 0x2290, 0x1a2d, 0x4330, 0x3a0e, 0x526d, 0x7acd,
0xa2ec, 0xb32c, 0xa229, 0xb248, 0xb227, 0xba68, 0xc2c9, 0xb2c9, 0xb30a,
0xab0b, 0xa30c, 0x932d, 0x8b8f, 0x5aad, 0x5b30, 0x3aaf, 0x2a70, 0x2270,
0x1a50, 0x2290, 0x1a91, 0x22f2, 0x22f2, 0x1ab1, 0x22f2, 0x2313, 0x2312,
0x22f2, 0x22f2, 0x2312, 0x2b12, 0x2312, 0x226f, 0x222e, 0xeaeb, 0xe32c,
0xa16a, 0x608a, 0x1885, 0x60ab, 0x1148, 0x19aa, 0x19ec, 0x228f, 0x1ab1,
0x22b0, 0x2b74, 0x3415, 0x3cb7, 0x3c36, 0x2b73, 0x3415, 0x3c76, 0x2bd4,
0x33f5, 0x3435, 0x3435, 0x3cf7, 0x3d18, 0x3c96, 0x3cf7, 0x33b4, 0x1a90,
0x2b33, 0x2312, 0x33d4, 0x4518, 0x4579, 0x465a, 0x4eda, 0x4efa, 0x4699,
0x3e59, 0x571c, 0x467a, 0x4edb, 0x4659, 0x4679, 0x465a, 0x4eba, 0x4e16,
0x4d72, 0x4573, 0x444c, 0x442c, 0x4ccf, 0x43ea, 0x43c9, 0x4bc8, 0x6c2a,
0x19aa, 0x2270, 0x19ca, 0x1989, 0x224e, 0x2bb4, 0x11ca, 0x19ec, 0x2b73,
0x3456, 0x3c97, 0x2353, 0x2290, 0x22f1, 0x33b4, 0x124e, 0x33b5, 0x33d4,
0x3456, 0x2bf4, 0x3456, 0x3496, 0x3d17, 0x3d37, 0x3d98, 0x3537, 0x4599,
0x3537, 0x4578, 0x3d58, 0x34b6, 0x4578, 0x3c96, 0x3435, 0x33f4, 0x2b94,
0x22f1, 0x22b0, 0x22b0, 0x1ab0, 0x22d1, 0x22b1, 0x198a, 0x1169, 0x198a,
0x198a, 0x224e, 0x1a6f, 0x228f, 0x4f3b, 0x3415, 0x2b74, 0x1128, 0x1a4e,
0x2290, 0x1a90, 0x1a4e, 0x224e, 0x1a4e, 0x1a70, 0x2312, 0x2312, 0x22f2,
0x1ab1, 0x22b1, 0x2291, 0x3312, 0x5434, 0x3a6f, 0x422d, 0x4a2d, 0x6aad,
0x7acd, 0x8acc, 0x930c, 0xa32c, 0x9b0c, 0x930c, 0x82ec, 0x836e, 0x734f,
0x4a4d, 0x322d, 0x2a2e, 0x2a4f, 0x2250, 0x1a90, 0x22b1, 0x22b1, 0x22f2,
0x2b33, 0x22f2, 0x22f2, 0x1ab1, 0x2313, 0x2312, 0x22d2, 0x22d1, 0x22d2,
0x2312, 0x22d1, 0x1af1, 0x1a0d, 0xec4f, 0xecd3, 0xa94a, 0xa90b, 0x608b,
0x90ed, 0x1865, 0x1107, 0x19cb, 0x19ec, 0x1ab0, 0x1a90, 0x2b53, 0x34d7,
0x34f6, 0x3496, 0x33d4, 0x2b73, 0x3c76, 0x3455, 0x3c96, 0x3435, 0x3496,
0x3d17, 0x3455, 0x3d58, 0x4558, 0x3c76, 0x2312, 0x2b53, 0x2311, 0x33f4,
0x3d17, 0x45b9, 0x4edb, 0x4f1b, 0x4edb, 0x46ba, 0x46ba, 0x46ba, 0x3e59,
0x4699, 0x4678, 0x4e99, 0x469a, 0x4638, 0x5636, 0x4dd4, 0x4d72, 0x3c0a,
0x444c, 0x4cf0, 0x4c2a, 0x4c4a, 0x4be9, 0x43a9, 0x7c4a, 0x19aa, 0x19ca,
0x2af3, 0x1189, 0x19aa, 0x1a4e, 0x3c36, 0x19aa, 0x1a2e, 0x33d5, 0x3c97,
0x3455, 0x22f2, 0x1a2e, 0x22f2, 0x3394, 0x22b0, 0x2bb3, 0x3bf5, 0x3435,
0x3415, 0x3456, 0x3cd7, 0x4599, 0x4599, 0x3558, 0x3d17, 0x3537, 0x3cd6,
0x45b9, 0x3d38, 0x3cf7, 0x4579, 0x3435, 0x33d4, 0x33f4, 0x2b73, 0x22f1,
0x1a90, 0x1a90, 0x22f1, 0x22d2, 0x22b0, 0x1949, 0x1126, 0x19aa, 0x19aa,
0x228f, 0x1a4f, 0x1a6f, 0x4e7a, 0x2b33, 0x22b1, 0x192a, 0x1a4f, 0x2291,
0x1a70, 0x224e, 0x1a0d, 0x1a4f, 0x1a4f, 0x2312, 0x2b33, 0x22d1, 0x22f1,
0x22b1, 0x2291, 0x22b0, 0x2290, 0x53f3, 0x3ab0, 0x31ed, 0x39ed, 0x39cc,
0x39cc, 0x522c, 0x4a0c, 0x4a2d, 0x39ed, 0x31ed, 0x322e, 0x2a4f, 0x2270,
0x2290, 0x2b12, 0x1ad1, 0x22b1, 0x1ad1, 0x1ad2, 0x1ad2, 0x22f2, 0x22f2,
0x2312, 0x22f2, 0x22f2, 0x22f2, 0x22d2, 0x22f2, 0x2312, 0x2b54, 0x1a6f,
0x81e9, 0xdcf3, 0xed13, 0xb12b, 0xc949, 0x990e, 0xb92e, 0x88ed, 0x1885,
0x1969, 0x19ec, 0x22b0, 0x2270, 0x2b74, 0x3d17, 0x3dd9, 0x3d78, 0x3415,
0x3435, 0x3c56, 0x3476, 0x3d58, 0x3496, 0x3cb7, 0x3d58, 0x3455, 0x467a,
0x3d38, 0x3435, 0x2b73, 0x2312, 0x2332, 0x3455, 0x3d17, 0x3db8, 0x46ba,
0x3e79, 0x46ba, 0x467a, 0x469a, 0x4698, 0x56fa, 0x4678, 0x4e57, 0x4e78,
0x56b9, 0x4e17, 0x4d93, 0x5552, 0x4cae, 0x3be9, 0x3bea, 0x44d0, 0x5c4a,
0x4c09, 0x43a7, 0x4be9, 0x642a, 0x946a, 0x19aa, 0x19aa, 0x1a2e, 0x22b0,
0x198a, 0x19ec, 0x22d1, 0x2b53, 0x19cb, 0x228f, 0x33d4, 0x3435, 0x3456,
0x22f1, 0x224f, 0x2332, 0x2b94, 0x2b72, 0x2b94, 0x33f5, 0x33f5, 0x3456,
0x3c96, 0x3cf7, 0x3d38, 0x461a, 0x3d37, 0x3517, 0x3517, 0x34f7, 0x3db9,
0x4538, 0x3cd7, 0x3d37, 0x3435, 0x3c76, 0x33f5, 0x2b94, 0x2333, 0x22f1,
0x1a90, 0x2312, 0x22b0, 0x22b1, 0x1127, 0x1086, 0x1989, 0x19a9, 0x226f,
0x226f, 0x2b51, 0x3cd7, 0x33b4, 0x226e, 0x1129, 0x22b1, 0x1a70, 0x226f,
0x226f, 0x1a6f, 0x224f, 0x2290, 0x2b33, 0x22f2, 0x22f2, 0x22f2, 0x22b1,
0x22b1, 0x2291, 0x22b1, 0x32f1, 0x32d0, 0x4bb3, 0x3af0, 0x3a90, 0x324f,
0x322e, 0x324f, 0x3290, 0x2a90, 0x2ad1, 0x22f2, 0x22d1, 0x22d1, 0x22b1,
0x22d2, 0x22f2, 0x22f2, 0x22f2, 0x22d1, 0x22d1, 0x22f2, 0x22d1, 0x2b12,
0x22f2, 0x22d2, 0x2333, 0x2333, 0x3c36, 0x1a2d, 0xf4f2, 0xd4d2, 0xdbad,
0xb909, 0xd926, 0xb94e, 0xc92c, 0xb14f, 0x4089, 0x1128, 0x19ec, 0x22b0,
0x226f, 0x2b94, 0x3cf7, 0x465a, 0x3e19, 0x3496, 0x3435, 0x3c97, 0x3cd7,
0x4e7a, 0x3517, 0x3d17, 0x3d58, 0x3476, 0x46bb, 0x3dd8, 0x3c76, 0x2bd4,
0x3394, 0x3394, 0x3456, 0x4538, 0x3df9, 0x56fb, 0x4edb, 0x4659, 0x4ebb,
0x46ba, 0x4eda, 0x4eb9, 0x4e98, 0x4e36, 0x4617, 0x4e78, 0x4d73, 0x44ce,
0x4cae, 0x444c, 0x4c09, 0x544b, 0x446d, 0x6c6a, 0x4bea, 0x4c0a, 0x5c29,
0x6c4a, 0x73e9, 0x93a8, 0x1168, 0x19aa, 0x19cb, 0x2b12, 0x11aa, 0x1168,
0x1a4f, 0x2332, 0x22f1, 0x198a, 0x1ab0, 0x2bd4, 0x3c76, 0x3496, 0x22d1,
0x224e, 0x2b53, 0x2b93, 0x33f4, 0x2bb4, 0x33b4, 0x33f5, 0x3c76, 0x3496,
0x3cd7, 0x3d78, 0x3d98, 0x34d6, 0x3d37, 0x3d58, 0x3d17, 0x3d58, 0x3d38,
0x3d38, 0x3d58, 0x3435, 0x3c76, 0x3c15, 0x3394, 0x22f1, 0x22b0, 0x1ab0,
0x22f2, 0x22b1, 0x1a90, 0x1107, 0x1845, 0x1189, 0x19cb, 0x1a4f, 0x1a6f,
0x3435, 0x2bf5, 0x2b53, 0x11cb, 0x1129, 0x22b0, 0x1a90, 0x224f, 0x1a2e,
0x1a4e, 0x1a70, 0x2270, 0x2312, 0x2b33, 0x22f2, 0x22d1, 0x22d1, 0x22b1,
0x1a90, 0x22b0, 0x22d1, 0x22b1, 0x2b12, 0x22b0, 0x2af1, 0x2af1, 0x22f1,
0x22d1, 0x2b12, 0x2312, 0x2312, 0x22f2, 0x2312, 0x22d1, 0x1ab1, 0x1a90,
0x1a90, 0x1ab1, 0x22d2, 0x22f2, 0x22d2, 0x22d1, 0x22b1, 0x2b32, 0x2333,
0x3435, 0x33d4, 0x2886, 0xdc0e, 0xe38e, 0xe32c, 0xd146, 0xd9c7, 0xc129,
0xc94c, 0xa92e, 0x4088, 0x10e7, 0x21ec, 0x1a70, 0x1a8f, 0x3c36, 0x461a,
0x4ebb, 0x569b, 0x3496, 0x4538, 0x3cd7, 0x34f7, 0x465b, 0x463a, 0x3db8,
0x3d38, 0x3cb7, 0x465a, 0x3578, 0x3cd7, 0x3435, 0x33f5, 0x33f4, 0x3496,
0x3d38, 0x46bb, 0x467a, 0x46ba, 0x3e79, 0x467a, 0x4eba, 0x46ba, 0x4eba,
0x4eb9, 0x4e78, 0x4616, 0x4e36, 0x4d51, 0x4cae, 0x442c, 0x4c2a, 0x5c4a,
0x5409, 0x440b, 0x4367, 0x6c6b, 0x6c8b, 0x53e9, 0x642a, 0x7c4a, 0x8c08,
0x9429, 0x22f1, 0x19aa, 0x19ab, 0x1a2e, 0x22f2, 0x19aa, 0x11cb, 0x1a70,
0x3c35, 0x1a4e, 0x19ca, 0x2b12, 0x33f5, 0x3455, 0x3435, 0x22d1, 0x2290,
0x3394, 0x33b4, 0x3415, 0x33f5, 0x33d4, 0x3415, 0x3456, 0x3455, 0x3d18,
0x4dda, 0x461a, 0x3d58, 0x3537, 0x3db9, 0x3517, 0x3d37, 0x3d58, 0x4579,
0x3d38, 0x3476, 0x3c76, 0x33f4, 0x2bb4, 0x2312, 0x22d0, 0x1a70, 0x2312,
0x22b0, 0x22b1, 0x1148, 0x2086, 0x19ca, 0x19ec, 0x1a6f, 0x2290, 0x3c95,
0x2b73, 0x2332, 0x198a, 0x19ab, 0x22b0, 0x2290, 0x224e, 0x226f, 0x226f,
0x1a6f, 0x2290, 0x22d1, 0x2312, 0x22f1, 0x22d1, 0x22d1, 0x22d1, 0x22d1,
0x22b1, 0x22d1, 0x1a70, 0x1a90, 0x1a91, 0x1a90, 0x22d2, 0x22f2, 0x1ab1,
0x1ab1, 0x1ab1, 0x22d1, 0x2291, 0x22d1, 0x1ab1, 0x22d1, 0x22f2, 0x2b33,
0x22f1, 0x22b1, 0x2291, 0x22f1, 0x2353, 0x3415, 0x3435, 0x1a4f, 0xf36c,
0xe166, 0xc9e9, 0xd987, 0xe248, 0xe187, 0xd948, 0xa92e, 0x990e, 0x2887,
0x1148, 0x19cb, 0x22b0, 0x2b11, 0x3c76, 0x3dd8, 0x46db, 0x56fb, 0x3cd6,
0x3d38, 0x3cf7, 0x4518, 0x3dd8, 0x4efc, 0x45b9, 0x3d37, 0x2b93, 0x465a,
0x3dd9, 0x3d17, 0x3455, 0x33b4, 0x3415, 0x34d7, 0x3d58, 0x465a, 0x467a,
0x467a, 0x467a, 0x4edb, 0x46ba, 0x4eba, 0x4eba, 0x4678, 0x4e98, 0x4636,
0x4df5, 0x4d30, 0x4c4c, 0x4c8d, 0x4c6c, 0x43a9, 0x5c6b, 0x4c2a, 0x644a,
0x642a, 0x5be9, 0x4bc9, 0x644a, 0x5368, 0x8c49, 0x93c8, 0x9ba8, 0x2c15,
0x19ca, 0x19ab, 0x19cb, 0x1ad2, 0x1a4e, 0x21cb, 0x2290, 0x22b1, 0x3435,
0x19a9, 0x19ec, 0x2b73, 0x2bf4, 0x3496, 0x2bb4, 0x1a6f, 0x22f2, 0x2b94,
0x2b32, 0x3415, 0x33f4, 0x3c76, 0x3435, 0x3476, 0x3c96, 0x34d7, 0x3d79,
0x4e1a, 0x3d58, 0x3d37, 0x3db9, 0x3d17, 0x3d78, 0x3d38, 0x3578, 0x3d37,
0x3476, 0x3cb7, 0x3435, 0x33f5, 0x2312, 0x2290, 0x22b1, 0x2312, 0x22b0,
0x1a90, 0x1989, 0x885, 0x198a, 0x1a2d, 0x1a4f, 0x228f, 0x23d2, 0x2b53,
0x22f2, 0x19aa, 0x929, 0x22b0, 0x1a91, 0x2290, 0x1a70, 0x2290, 0x22b1,
0x22b1, 0x22d2, 0x2312, 0x2312, 0x2b32, 0x2b13, 0x22f2, 0x22d1, 0x22d1,
0x22b0, 0x1a91, 0x22b1, 0x1ab1, 0x22b1, 0x1a90, 0x22d1, 0x1ab1, 0x22d1,
0x1ab1, 0x1ab1, 0x1ad1, 0x22d1, 0x22b1, 0x22d1, 0x22b1, 0x22b1, 0x1ad1,
0x2b73, 0x3c56, 0x3455, 0x2b73, 0xb18b, 0xa92b, 0x10e6, 0xdac9, 0xe207,
0xe207, 0xd166, 0xd96b, 0x78ec, 0x68cc, 0x10e7, 0x1989, 0x19ec, 0x2290,
0x2b32, 0x3476, 0x45b9, 0x4efb, 0x467a, 0x3d77, 0x45b9, 0x3d38, 0x4579,
0x3db8, 0x4efb, 0x3cb6, 0x3cb7, 0x3414, 0x4e7b, 0x45d9, 0x34f7, 0x3415,
0x33d4, 0x3c76, 0x3d58, 0x3e3a, 0x3e19, 0x465a, 0x469b, 0x467a, 0x465a,
0x467a, 0x3e79, 0x4679, 0x56d9, 0x56b9, 0x4e79, 0x4df4, 0x44ae, 0x43ea,
0x442c, 0x4c4a, 0x5c6b, 0x542a, 0x442c, 0x6c8b, 0x6c4a, 0x7429, 0x7cab,
0x6409, 0x848b, 0x8c49, 0x9429, 0x83a7, 0x9367, 0x3455, 0x33f5, 0x21eb,
0x19cb, 0x2290, 0x22d2, 0x19ab, 0x19ab, 0x22b0, 0x2b53, 0x2312, 0x1989,
0x2290, 0x2b94, 0x3c56, 0x34b6, 0x2312, 0x1a90, 0x2b12, 0x33d5, 0x2af1,
0x3415, 0x3415, 0x3476, 0x3455, 0x2c35, 0x34b6, 0x34f7, 0x3558, 0x461a,
0x3d58, 0x3d58, 0x461a, 0x3d78, 0x3d37, 0x34b6, 0x3db8, 0x3d17, 0x3476,
0x3476, 0x3415, 0x33d4, 0x2312, 0x22b0, 0x22d1, 0x2b32, 0x22d0, 0x22d1,
0x19aa, 0x8a5, 0x19aa, 0x226f, 0x2290, 0x1a6f, 0x2bd3, 0x2c75, 0x2b32,
0x19cb, 0x1149, 0x228f, 0x1a6f, 0x1ab0, 0x22d1, 0x1a90, 0x22b0, 0x22d2,
0x22f1, 0x1af2, 0x2b32, 0x2312, 0x22f2, 0x2312, 0x22d1, 0x22d1, 0x2b32,
0x22d2, 0x22d1, 0x22b1, 0x22d1, 0x1ab1, 0x22d1, 0x22f1, 0x22d2, 0x22b0,
0x22d1, 0x22d1, 0x22d1, 0x1a90, 0x1ad1, 0x2b74, 0x3415, 0x3c56, 0x2b32,
0xc1ec, 0xb949, 0x1989, 0xaa4d, 0xd289, 0xd9e7, 0xd946, 0xe145, 0xa12f,
0x2887, 0x1886, 0x1969, 0x19aa, 0x21ed, 0x22b0, 0x3454, 0x3c55, 0x3d38,
0x467a, 0x463a, 0x461a, 0x3d58, 0x3d78, 0x3d58, 0x3d78, 0x4e3a, 0x33b4,
0x2b73, 0x2b73, 0x463a, 0x3d78, 0x3d17, 0x2c15, 0x3415, 0x34b6, 0x3d38,
0x4e7b, 0x463a, 0x463a, 0x4e7b, 0x465a, 0x467a, 0x467a, 0x46ba, 0x4699,
0x4eb9, 0x4e99, 0x4e79, 0x45b4, 0x4d30, 0x4c4c, 0x4c8e, 0x440b, 0x544a,
0x544b, 0x4c09, 0x646a, 0x6c4a, 0x8c8a, 0x844a, 0x7c6b, 0x8449, 0x8c69,
0x9449, 0x8bc7, 0xa3a7, 0xb347, 0x3cd7, 0x3d37, 0x19cb, 0x11ab, 0x220d,
0x22f2, 0x1a4e, 0x198a, 0x226f, 0x22f2, 0x3436, 0x2b33, 0x19aa, 0x1af2,
0x33d5, 0x3476, 0x44f8, 0x22f2, 0x22f1, 0x2332, 0x33d4, 0x22b0, 0x3c56,
0x3435, 0x3496, 0x3476, 0x3476, 0x3c96, 0x3d17, 0x3db9, 0x45fa, 0x3d17,
0x3578, 0x4e3a, 0x34f7, 0x2cf6, 0x3518, 0x4dfa, 0x3cf7, 0x3cb7, 0x3cb7,
0x3435, 0x33d4, 0x22f2, 0x22b0, 0x22b1, 0x2332, 0x1a6f, 0x1ab0, 0x1a0c,
0x1127, 0x19ab, 0x226f, 0x22b0, 0x1a4f, 0x22af, 0x4eb9, 0x3353, 0x19cb,
0x118a, 0x1a4e, 0x22f1, 0x22b1, 0x2312, 0x22d1, 0x22f2, 0x22d1, 0x2b33,
0x2b53, 0x2b53, 0x2332, 0x2312, 0x2b33, 0x22f2, 0x1ad1, 0x22f1, 0x22d1,
0x1ab1, 0x22d1, 0x22d1, 0x22f2, 0x22f2, 0x22d1, 0x22d1, 0x22b0, 0x1ab1,
0x2312, 0x2b73, 0x2bb3, 0x2bb4, 0x81ca, 0xea48, 0x810b, 0x19ca, 0x19cc,
0xda27, 0xf1e7, 0xd148, 0xe164, 0xc96b, 0x1865, 0x10a5, 0x1148, 0x118a,
0x1a0c, 0x224f, 0x2b52, 0x4619, 0x3c56, 0x3d38, 0x3d78, 0x3df9, 0x4ebb,
0x3d58, 0x3516, 0x3db8, 0x3d99, 0x4598, 0x22d1, 0x2290, 0x3434, 0x4619,
0x3dd9, 0x3d58, 0x34b6, 0x3496, 0x3d38, 0x3537, 0x463a, 0x4619, 0x3df9,
0x463a, 0x461a, 0x465a, 0x467a, 0x46ba, 0x46da, 0x4eda, 0x4e78, 0x4e99,
0x4df4, 0x4d31, 0x546d, 0x442b, 0x440b, 0x5ccb, 0x43ea, 0x442c, 0x5c8b,
0x746a, 0x744b, 0x94ab, 0x5bea, 0x7c4a, 0x948a, 0x8c09, 0x8bc7, 0x8b46,
0xa366, 0xb326, 0x3435, 0x3d79, 0x3435, 0x19ec, 0x19cb, 0x1a90, 0x22f1,
0x19ec, 0x19cb, 0x22d1, 0x2b53, 0x2353, 0x1a0c, 0x1a0e, 0x2b32, 0x3415,
0x3476, 0x3496, 0x2b32, 0x2312, 0x2b74, 0x33f5, 0x1a6f, 0x3436, 0x3415,
0x3cd7, 0x3c96, 0x3c96, 0x34b6, 0x3d17, 0x45d9, 0x463a, 0x3d78, 0x3db9,
0x4e3a, 0x3d57, 0x3516, 0x3d17, 0x45d9, 0x34f7, 0x3cb7, 0x3cb7, 0x3435,
0x3415, 0x2b32, 0x2290, 0x1ab1, 0x2352, 0x1a91, 0x2af1, 0x1a0c, 0x10e7,
0x11aa, 0x1a4e, 0x1a6f, 0x226f, 0x226e, 0x679a, 0x2353, 0x224d, 0x19eb,
0x1128, 0x1a90, 0x22b1, 0x2b33, 0x2312, 0x2312, 0x2312, 0x1ad2, 0x22f2,
0x2312, 0x2b53, 0x2312, 0x2312, 0x2312, 0x22f2, 0x22f1, 0x22f2, 0x22d1,
0x22d1, 0x1ad1, 0x2b32, 0x22f2, 0x2332, 0x2333, 0x2b33, 0x2b93, 0x2b32,
0x18a7, 0x885, 0x2065, 0x19cc, 0x1a90, 0x2109, 0xd9c8, 0x10e7, 0xd987,
0xe187, 0x592a, 0x8c6, 0x1969, 0x19cb, 0x19ec, 0x1a0d, 0x2ad1, 0x4e1a,
0x2c14, 0x3455, 0x3517, 0x3d58, 0x3d37, 0x4efc, 0x3d17, 0x45d9, 0x45fa,
0x3d98, 0x3475, 0x226f, 0x226f, 0x2bf4, 0x45d9, 0x465a, 0x461a, 0x3d58,
0x3d58, 0x3d58, 0x461a, 0x3dd9, 0x465a, 0x4619, 0x3df9, 0x4619, 0x3e19,
0x465a, 0x46bb, 0x4eda, 0x4eda, 0x4eda, 0x5efa, 0x4e15, 0x4d30, 0x4cae,
0x446c, 0x440a, 0x4c2a, 0x4c49, 0x440a, 0x4c0b, 0x648b, 0x746b, 0x8c69,
0x8c8a, 0x8c08, 0x9429, 0x8c08, 0x83e9, 0x9bc8, 0x9b47, 0xab87, 0xab06,
0x22b0, 0x3d58, 0x3496, 0x19ca, 0x220d, 0x1a2e, 0x1ad1, 0x222d, 0x19ec,
0x226f, 0x2b33, 0x2b73, 0x2312, 0x198a, 0x2290, 0x33b4, 0x3455, 0x3cd7,
0x3435, 0x22f2, 0x2332, 0x2b93, 0x3bf5, 0x1a8f, 0x3c56, 0x3496, 0x3cb6,
0x3c96, 0x3cf7, 0x34d7, 0x3517, 0x3d58, 0x45d9, 0x4599, 0x3db9, 0x4e3a,
0x3d78, 0x3537, 0x3517, 0x3dd9, 0x34d7, 0x3cb7, 0x3cb7, 0x3455, 0x3c15,
0x2312, 0x22d1, 0x1a8f, 0x2312, 0x22b1, 0x22b1, 0x2ad0, 0x1168, 0x1189,
0x226f, 0x226f, 0x224e, 0x226e, 0x569a, 0x5edb, 0x3353, 0x220c, 0x198a,
0x19ab, 0x22b1, 0x2312, 0x3c15, 0x33f5, 0x2bb4, 0x2b73, 0x2b53, 0x2b32,
0x2b74, 0x33b4, 0x33d4, 0x33f5, 0x33d4, 0x33b4, 0x33f5, 0x3c36, 0x3c55,
0x2b93, 0x2312, 0x2b53, 0x1a70, 0x1a4e, 0x22b0, 0x22b0, 0x1a4e, 0x1a6f,
0x226f, 0x2290, 0x19cb, 0x1a2f, 0xb98d, 0xe189, 0x2066, 0x10e7, 0x19ca,
0x19cb, 0x1a0d, 0x226f, 0x222e, 0x2c75, 0x4f3a, 0x4dfa, 0x3496, 0x34b6,
0x4d79, 0x3537, 0x45f9, 0x3c96, 0x3d78, 0x3d98, 0x3e39, 0x2b11, 0x224e,
0x22d1, 0x4559, 0x4599, 0x3d58, 0x3d98, 0x4619, 0x3db9, 0x3d58, 0x463a,
0x3df9, 0x463a, 0x4619, 0x3dd9, 0x3df9, 0x3e19, 0x463a, 0x4e9b, 0x4edb,
0x4eda, 0x4edb, 0x56d9, 0x4df4, 0x5572, 0x4cad, 0x4cae, 0x442c, 0x440a,
0x4c6d, 0x4c6b, 0x440a, 0x5c49, 0x642a, 0x7c49, 0x946a, 0x9408, 0x9449,
0x8c6a, 0x9429, 0x9bc8, 0x93a7, 0xaba7, 0xab26, 0xab67, 0x19cb, 0x34f7,
0x4558, 0x228f, 0x1a4e, 0x1a2e, 0x22d1, 0x22b0, 0x1a0d, 0x19cb, 0x1a91,
0x2b53, 0x3c77, 0x2b33, 0x19ab, 0x2333, 0x33f5, 0x3456, 0x3cd7, 0x2b73,
0x2312, 0x2b33, 0x33b4, 0x33f5, 0x22d0, 0x3476, 0x3c96, 0x3cb6, 0x3c96,
0x3cd7, 0x34b6, 0x3d58, 0x45b9, 0x4619, 0x45b9, 0x3dd9, 0x465a, 0x3557,
0x3d78, 0x3537, 0x45f9, 0x3cd7, 0x3cf8, 0x3cb6, 0x3455, 0x3415, 0x2b53,
0x22f1, 0x22d1, 0x2332, 0x1ab1, 0x2291, 0x22af, 0x1189, 0x19aa, 0x224e,
0x228f, 0x226e, 0x226f, 0x22f0, 0x5df2, 0x23b2, 0x226f, 0x19ec, 0x18c8,
0x118a, 0x22f1, 0x2b93, 0x3c35, 0x4518, 0x3cf7, 0x3cd7, 0x3455, 0x3476,
0x3cd7, 0x3cb6, 0x3476, 0x3476, 0x3476, 0x3415, 0x33f4, 0x3435, 0x3476,
0x3cd7, 0x3d17, 0x3cb7, 0x33f4, 0x33d5, 0x2332, 0x22b1, 0x2332, 0x2b53,
0x5909, 0xc12c, 0x10a5, 0x1949, 0x19ab, 0x1a0c, 0x226f, 0x1a70, 0x226f,
0x2373, 0x4f5b, 0x571b, 0x2bd4, 0x3cd7, 0x4579, 0x22b0, 0x45d9, 0x4dd9,
0x2b73, 0x3435, 0x3d17, 0x469b, 0x19ed, 0x1a2d, 0x33b4, 0x3d38, 0x45d9,
0x45b9, 0x3d58, 0x461a, 0x3df9, 0x461a, 0x3df9, 0x3db8, 0x463a, 0x45f9,
0x463a, 0x4619, 0x4619, 0x465a, 0x467a, 0x469a, 0x4edb, 0x46ba, 0x4eb9,
0x4e36, 0x4d92, 0x44cf, 0x448d, 0x4c4c, 0x4cae, 0x4c4d, 0x548d, 0x442b,
0x546b, 0x6cab, 0x6c2a, 0x8c69, 0x948a, 0xa46a, 0x9c29, 0x9c49, 0xa409,
0x9429, 0x9bc8, 0xab67, 0xa3a7, 0xab47, 0x19aa, 0x33d4, 0x4578, 0x3c75,
0x222e, 0x19ec, 0x1a6f, 0x2b33, 0x1a0d, 0x19ab, 0x1a6e, 0x2332, 0x33f5,
0x22f1, 0x19aa, 0x226e, 0x2b94, 0x3415, 0x3c56, 0x3d17, 0x2353, 0x2b53,
0x2353, 0x2b93, 0x33d4, 0x2311, 0x3cd7, 0x3476, 0x3476, 0x3cd7, 0x3d18,
0x34b6, 0x3d58, 0x45d9, 0x463a, 0x4599, 0x3517, 0x4e5b, 0x3d37, 0x3d98,
0x3d78, 0x3df9, 0x3d18, 0x3cd7, 0x3496, 0x3c96, 0x3415, 0x2333, 0x22d1,
0x2af1, 0x2b33, 0x1ab1, 0x22b0, 0x1a90, 0x19a9, 0x19aa, 0x1a2e, 0x22b0,
0x2ad1, 0x1a6f, 0x22d0, 0x6ef9, 0x6674, 0x2311, 0x122d, 0x220d, 0x18a7,
0x21cb, 0x22f1, 0x33d4, 0x3435, 0x4518, 0x34f7, 0x3d17, 0x3cf7, 0x3d58,
0x3d58, 0x3d78, 0x4599, 0x3db8, 0x45fa, 0x34d7, 0x3d37, 0x34d6, 0x3cb7,
0x2bd3, 0x33d4, 0x3435, 0x2c15, 0x33f4, 0x48eb, 0x50ca, 0x1128, 0x1169,
0x19ec, 0x1a0d, 0x22b0, 0x22b0, 0x226f, 0x3c76, 0x577b, 0x4efa, 0x23b3,
0x2c14, 0x45da, 0x2af1, 0x2373, 0x4e3a, 0x3cf7, 0x2312, 0x3456, 0x3d38,
0x4d78, 0x224e, 0x33f4, 0x3496, 0x3d58, 0x461a, 0x3db8, 0x45b9, 0x3d78,
0x3df9, 0x4619, 0x45f9, 0x45d9, 0x45d9, 0x3db8, 0x35b8, 0x463a, 0x4619,
0x56fc, 0x467a, 0x4ebb, 0x4edb, 0x4edb, 0x3e79, 0x56d8, 0x4e36, 0x4510,
0x4d10, 0x44ae, 0x4d10, 0x54ad, 0x4d32, 0x442c, 0x4c2b, 0x544a, 0x746a,
0x9caa, 0x9cab, 0x9bc7, 0x93a7, 0x93c8, 0x9b87, 0x9ba7, 0x8b87, 0xa367,
0xa387, 0xb387, 0xab27, 0x1a0d, 0x1a0d, 0x3d38, 0x3d17, 0x19ab, 0x224e,
0x1a4e, 0x2312, 0x1a2d, 0x220d, 0x19ec, 0x22d2, 0x2b73, 0x3c76, 0x2b53,
0x19cb, 0x2312, 0x33f4, 0x3455, 0x3cb7, 0x3cd7, 0x2333, 0x2b53, 0x2353,
0x33f4, 0x33d4, 0x2b32, 0x3cb7, 0x3c96, 0x3476, 0x3c96, 0x3d18, 0x3496,
0x2cb6, 0x45d9, 0x461a, 0x3d78, 0x3db8, 0x565b, 0x34f7, 0x3d98, 0x3d58,
0x461a, 0x3cf7, 0x3cf7, 0x3cd7, 0x3cb6, 0x3435, 0x33b4, 0x22f2, 0x22d1,
0x2312, 0x1ab0, 0x22d1, 0x22b1, 0x1a0c, 0x11aa, 0x1a2e, 0x1a6f, 0x22b1,
0x22b0, 0x226f, 0x22d1, 0x5f39, 0x5f18, 0x2af1, 0x1a0d, 0x220d, 0x19cc,
0x28a8, 0x1169, 0x2b12, 0x2bd4, 0x3d18, 0x3d18, 0x34b6, 0x3c76, 0x3476,
0x3455, 0x3435, 0x2bf4, 0x3435, 0x3c96, 0x3cd7, 0x3cd7, 0x2c55, 0x226e,
0x28c9, 0x1085, 0x8c6, 0x118a, 0x1a0c, 0x226f, 0x2270, 0x22f1, 0x1a6f,
0x2af1, 0x45f9, 0x575b, 0x45d9, 0x3415, 0x4e3a, 0x4e9b, 0x2bd3, 0x2333,
0x3cf7, 0x3df9, 0x2bd4, 0x3373, 0x3435, 0x3cd7, 0x2392, 0x2311, 0x3496,
0x3db9, 0x3df9, 0x45d9, 0x3db8, 0x45f9, 0x3d78, 0x3d78, 0x45d9, 0x45d9,
0x3d98, 0x3d78, 0x3df9, 0x2d37, 0x3e19, 0x3df9, 0x465a, 0x465a, 0x573c,
0x4efb, 0x4edb, 0x4eba, 0x4678, 0x4e77, 0x4db3, 0x4d72, 0x4cae, 0x44ef,
0x4c8d, 0x4cae, 0x4d52, 0x4cef, 0x43ea, 0x6c6b, 0x8449, 0x94aa, 0x9bc8,
0x9c09, 0x9c09, 0x9be8, 0x93a7, 0x9387, 0x93a7, 0x9b47, 0x8b46, 0xc346,
0xd2e7, 0x22f2, 0x19cb, 0x3cd7, 0x3d78, 0x198a, 0x1a4f, 0x1a4f, 0x22d1,
0x2332, 0x1a0d, 0x19ec, 0x2290, 0x2311, 0x33f5, 0x2311, 0x1a4e, 0x1a0c,
0x2b53, 0x3435, 0x3456, 0x3cd7, 0x3cb7, 0x2b53, 0x2b94, 0x2332, 0x33d4,
0x33d4, 0x2b32, 0x3496, 0x3c96, 0x3476, 0x3cd7, 0x4558, 0x34b6, 0x3d38,
0x461a, 0x463a, 0x3db9, 0x3d78, 0x3dd9, 0x3537, 0x3db8, 0x45d9, 0x45d9,
0x3d37, 0x3d18, 0x4518, 0x2c35, 0x3456, 0x33d4, 0x22f1, 0x22d1, 0x22f2,
0x2312, 0x22b0, 0x1a91, 0x228f, 0x11cb, 0x224f, 0x228f, 0x228f, 0x22d1,
0x2270, 0x22b0, 0x2311, 0x573b, 0x579b, 0x2b93, 0x2b12, 0x19cb, 0x1a0c,
0x1a0d, 0x20a8, 0x50cb, 0x18c8, 0x118a, 0x226e, 0x3332, 0x33b3, 0x3b72,
0x22d0, 0x2a4d, 0x118a, 0x10e6, 0x845, 0x8a6, 0x1108, 0x19ab, 0x1a2d,
0x226f, 0x1a90, 0x22b1, 0x22b0, 0x1a8f, 0x34b6, 0x4ebb, 0x469b, 0x34d7,
0x3d78, 0x571c, 0x3db8, 0x3454, 0x2352, 0x2bb4, 0x4e3a, 0x465a, 0x2b52,
0x2bb4, 0x33f4, 0x3cb7, 0x2bd3, 0x3435, 0x3d78, 0x45f9, 0x4e9b, 0x3d78,
0x45d9, 0x3db9, 0x3578, 0x3d98, 0x45b9, 0x3dd9, 0x45fa, 0x3db8, 0x3db9,
0x3db8, 0x4e1a, 0x3df9, 0x467a, 0x46ba, 0x46ba, 0x46da, 0x469a, 0x4e9a,
0x4eb9, 0x4e98, 0x4dd4, 0x4db3, 0x4d93, 0x4ccf, 0x44cf, 0x4d11, 0x44af,
0x4c4b, 0x43ea, 0x5c49, 0x8d0d, 0x9c8a, 0x9c6a, 0xa3e8, 0xa3a7, 0x9be8,
0x8ba8, 0x9bc7, 0xa387, 0x6348, 0xab67, 0xb347, 0xcb26, 0xcb06, 0x2b32,
0x19cb, 0x3415, 0x3d58, 0x226e, 0x226f, 0x1a4e, 0x22d2, 0x3394, 0x224e,
0x1a0d, 0x1a2d, 0x22d1, 0x2b94, 0x3435, 0x2b12, 0x19cb, 0x22b0, 0x2bb3,
0x3435, 0x3c96, 0x34d7, 0x3cd7, 0x2b12, 0x2b94, 0x2b93, 0x33d4, 0x33d5,
0x2b52, 0x3475, 0x3c76, 0x3456, 0x3cb7, 0x4579, 0x34d7, 0x4579, 0x45d9,
0x4e7b, 0x45b9, 0x3558, 0x35b8, 0x3d57, 0x461a, 0x3d58, 0x3d98, 0x3537,
0x3d17, 0x4518, 0x3c56, 0x3456, 0x2bd4, 0x2332, 0x22d1, 0x22d1, 0x2b53,
0x1ab1, 0x22d1, 0x1a8f, 0x1a4e, 0x1a6f, 0x22b0, 0x2290, 0x22b0, 0x22b1,
0x1a6f, 0x2290, 0x22b0, 0x3d77, 0x46fa, 0x34f6, 0x2b12, 0x2311, 0x22d0,
0x222d, 0x1a0c, 0x228f, 0x224f, 0x1a4e, 0x222d, 0x1a2d, 0x222d, 0x224e,
0x226e, 0x1a6f, 0x226f, 0x1a6f, 0x1a90, 0x2ad1, 0x1ab0, 0x1a6f, 0x2b73,
0x45d9, 0x35d8, 0x4e9b, 0x3d17, 0x2392, 0x465a, 0x3537, 0x463b, 0x33f3,
0x22af, 0x2bb3, 0x465a, 0x46ba, 0x4edb, 0x3d17, 0x2b53, 0x33f5, 0x3456,
0x34b6, 0x3496, 0x3db8, 0x461a, 0x463a, 0x3d58, 0x3d58, 0x3d78, 0x3dd9,
0x3d98, 0x3d78, 0x3d98, 0x45f9, 0x3db9, 0x45f9, 0x45f9, 0x3dd9, 0x3dd9,
0x4619, 0x465a, 0x4edb, 0x4edb, 0x46ba, 0x46ba, 0x4ed9, 0x4e98, 0x45b4,
0x55f4, 0x4df4, 0x4cef, 0x4d51, 0x4cef, 0x44ef, 0x54ad, 0x442b, 0x4c4a,
0x6cab, 0x94aa, 0x9c49, 0x8c49, 0xa408, 0x9c0a, 0x9387, 0x9449, 0x9b67,
0x9b87, 0xab87, 0xb326, 0xb326, 0xbae6, 0xdb27, 0x2b73, 0x1a4e, 0x22d1,
0x3d17, 0x3c56, 0x2270, 0x1a4e, 0x22b1, 0x2b73, 0x22f1, 0x1a2d, 0x1a2d,
0x1ab1, 0x2b53, 0x3415, 0x22d1, 0x2b12, 0x19ec, 0x2b53, 0x3415, 0x3435,
0x3c96, 0x3d17, 0x3cb6, 0x22f1, 0x33b4, 0x33b4, 0x2bd4, 0x33f5, 0x22d0,
0x3435, 0x3c76, 0x3455, 0x3cd7, 0x4558, 0x34b6, 0x3d78, 0x461a, 0x463a,
0x3d98, 0x3d78, 0x3d78, 0x3537, 0x4e5a, 0x3d98, 0x3d78, 0x45d9, 0x3d17,
0x4558, 0x3c96, 0x3c96, 0x3436, 0x2b73, 0x22f1, 0x2af1, 0x22f2, 0x2312,
0x22d1, 0x22d1, 0x1a90, 0x1a90, 0x2290, 0x22b1, 0x22b0, 0x1ab1, 0x1a90,
0x228f, 0x226f, 0x22b1, 0x1ad0, 0x3d17, 0x45d9, 0x45fa, 0x2c35, 0x2b52,
0x22d0, 0x22d1, 0x2b32, 0x2312, 0x2b32, 0x22f2, 0x22f1, 0x2ad1, 0x1a8f,
0x1ab0, 0x2b52, 0x2cb5, 0x56fb, 0x4619, 0x4e1a, 0x461a, 0x2b92, 0x2bb2,
0x461a, 0x3dd9, 0x3d78, 0x4558, 0x2b53, 0x1a2d, 0x3353, 0x461a, 0x577b,
0x46da, 0x56f8, 0x4efb, 0x2b52, 0x2b73, 0x3c56, 0x34b6, 0x4538, 0x3d98,
0x4e5b, 0x3537, 0x4578, 0x4578, 0x3d78, 0x463a, 0x3e19, 0x3d58, 0x3d58,
0x3537, 0x45f9, 0x45f9, 0x45f9, 0x461a, 0x3dd8, 0x3e5a, 0x469a, 0x4ebb,
0x46db, 0x469a, 0x3e79, 0x4eda, 0x56da, 0x4e57, 0x5635, 0x4e16, 0x4d31,
0x44ef, 0x4531, 0x4cce, 0x4cce, 0x4c4b, 0x4c4c, 0x5c6b, 0x846a, 0x63c9,
0x9be8, 0xa3a7, 0xa3a8, 0x9b87, 0xa3a7, 0x9c09, 0x8b47, 0xab66, 0x9b67,
0xbb06, 0xc367, 0xc326, 0xcac5, 0x2b93, 0x2332, 0x19cb, 0x3435, 0x34b6,
0x222d, 0x1a6f, 0x2290, 0x2b73, 0x2bd4, 0x1a4f, 0x1a2e, 0x1a4f, 0x2312,
0x3415, 0x3c76, 0x2b32, 0x19eb, 0x1a90, 0x2bb3, 0x3435, 0x3c96, 0x34b6,
0x3d58, 0x3cd7, 0x2353, 0x33f4, 0x2bb4, 0x33d4, 0x33d4, 0x22d1, 0x3435,
0x3435, 0x3456, 0x3cd7, 0x3cb6, 0x3476, 0x3d58, 0x4e5b, 0x463a, 0x3df9,
0x3d78, 0x4dfa, 0x3598, 0x3dd9, 0x45b9, 0x3d58, 0x463a, 0x3d38, 0x3d17,
0x3496, 0x3cb7, 0x4496, 0x3c15, 0x2312, 0x22d1, 0x1ad1, 0x2b53, 0x22f2,
0x1a90, 0x22d1, 0x22d1, 0x2290, 0x1ad1, 0x22f1, 0x22d1, 0x22b1, 0x1a90,
0x1a6f, 0x226f, 0x1a6f, 0x1ab0, 0x22b0, 0x3c35, 0x3d17, 0x3df8, 0x3e39,
0x3eb9, 0x46ba, 0x467a, 0x3db8, 0x3577, 0x3d57, 0x3517, 0x35b8, 0x3517,
0x1a4d, 0x19cc, 0x3392, 0x3d58, 0x3d78, 0x34d7, 0x3c76, 0x2b11, 0x228f,
0x19ec, 0x1a0d, 0x2bd3, 0x3e39, 0x3e99, 0x46da, 0x4f1a, 0x46d9, 0x4f1b,
0x2352, 0x2b12, 0x44b7, 0x34f6, 0x3d58, 0x3d78, 0x3db8, 0x3476, 0x45b9,
0x4579, 0x3d17, 0x461a, 0x465a, 0x3dd9, 0x3d78, 0x3d78, 0x3db9, 0x3dd9,
0x461a, 0x45f9, 0x463a, 0x465a, 0x4ebb, 0x46ba, 0x469a, 0x571c, 0x4eda,
0x4eda, 0x4eb9, 0x4e57, 0x4e56, 0x5677, 0x4db3, 0x4cef, 0x4d92, 0x4d72,
0x44ce, 0x442a, 0x54ae, 0x4c4a, 0x6c4a, 0x9ccb, 0x9c8b, 0x9be8, 0x9c28,
0xa387, 0xa387, 0xaba8, 0x9ba7, 0xa386, 0xb347, 0xab67, 0xa2e5, 0xcb88,
0xb2c5, 0xa307, 0x33f5, 0x33f4, 0x220c, 0x2b73, 0x4599, 0x19cb, 0x22b1,
0x1ab0, 0x2b53, 0x3435, 0x1ab1, 0x1a4e, 0x1a4e, 0x22d1, 0x2b93, 0x3455,
0x22d1, 0x2b32, 0x1a0c, 0x2b33, 0x2bd4, 0x3476, 0x34d7, 0x34d7, 0x3d37,
0x3cd7, 0x2b53, 0x3415, 0x33d4, 0x3415, 0x33f5, 0x22f1, 0x3435, 0x3414,
0x3456, 0x3cf7, 0x34b6, 0x3496, 0x4558, 0x461a, 0x465a, 0x463a, 0x3d98,
0x3dd9, 0x4e5b, 0x3d78, 0x3d78, 0x3d78, 0x463a, 0x3d58, 0x3cf7, 0x34b6,
0x3455, 0x3496, 0x3415, 0x2332, 0x2312, 0x2312, 0x2353, 0x2312, 0x1ab1,
0x22f1, 0x22d1, 0x2290, 0x22b1, 0x22f2, 0x22d1, 0x1ab1, 0x22d1, 0x22b0,
0x1a6f, 0x2290, 0x1a4e, 0x2290, 0x1a90, 0x1a90, 0x1a90, 0x22d0, 0x1ab0,
0x3393, 0x44d7, 0x4538, 0x3d17, 0x3cd6, 0x4496, 0x3c35, 0x2b72, 0x1ab0,
0x1a6f, 0x1ab1, 0x1a4e, 0x19ec, 0x1a0c, 0x220d, 0x2b10, 0x4578, 0x5eb8,
0x5e55, 0x5ccc, 0x6d0d, 0x5d50, 0x5f18, 0x3e39, 0x2bb4, 0x2b53, 0x34b6,
0x3d18, 0x4599, 0x3d98, 0x44d7, 0x3c96, 0x4579, 0x3d78, 0x3d37, 0x45d9,
0x465a, 0x463a, 0x45d9, 0x3d78, 0x3d78, 0x45d9, 0x461a, 0x45f9, 0x3df9,
0x469b, 0x469a, 0x46ba, 0x469a, 0x573c, 0x4edb, 0x4eda, 0x4679, 0x3e58,
0x4636, 0x4e57, 0x4e36, 0x5591, 0x4552, 0x4d52, 0x5db2, 0x4cae, 0x4c2b,
0x4c4b, 0x646a, 0x8caa, 0x9c89, 0x93c7, 0x9c28, 0xa388, 0xa3a7, 0x9ba8,
0x9326, 0xa367, 0xa306, 0xc367, 0xc326, 0xbb47, 0xbb27, 0xcb07, 0xdae6,
0x3435, 0x33f5, 0x19ed, 0x22f2, 0x45b9, 0x19cb, 0x22d1, 0x22d1, 0x2b53,
0x3414, 0x2bb4, 0x22b1, 0x1a6f, 0x2291, 0x2b94, 0x3435, 0x3c56, 0x2b32,
0x19eb, 0x1a6f, 0x2b73, 0x3476, 0x3cb6, 0x3d17, 0x34f7, 0x3d17, 0x3d17,
0x2b93, 0x3c56, 0x3415, 0x33f5, 0x33d4, 0x1ad0, 0x3456, 0x33f4, 0x3c55,
0x3496, 0x3496, 0x3517, 0x3d58, 0x45d9, 0x465a, 0x3df9, 0x45d9, 0x3db9,
0x3df9, 0x3537, 0x45fa, 0x3d98, 0x45f9, 0x2cb6, 0x4599, 0x2c95, 0x3cb6,
0x3496, 0x3476, 0x33f5, 0x2312, 0x2312, 0x2312, 0x2b12, 0x2332, 0x1ad1,
0x22b0, 0x1ab1, 0x22d2, 0x22d1, 0x22f2, 0x22d1, 0x22d1, 0x2af1, 0x22b1,
0x2290, 0x1a90, 0x22b1, 0x2312, 0x2290, 0x2b93, 0x33b4, 0x33d4, 0x33d4,
0x2b53, 0x2312, 0x2b94, 0x3c15, 0x3352, 0x226f, 0x22b0, 0x1a4e, 0x222d,
0x1a0d, 0x2b11, 0x3456, 0x4e1a, 0x6695, 0x5ccd, 0x6d0c, 0x850c, 0x854e,
0x85af, 0x4657, 0x463a, 0x3394, 0x33d4, 0x45f9, 0x3d17, 0x34d6, 0x3517,
0x2b73, 0x3c96, 0x4599, 0x4578, 0x4558, 0x3537, 0x463a, 0x465a, 0x469a,
0x4e5a, 0x3598, 0x3db8, 0x461a, 0x3dd9, 0x3dd9, 0x463a, 0x3e19, 0x469a,
0x46ba, 0x4efb, 0x46ba, 0x469a, 0x3e79, 0x4eb9, 0x4e98, 0x4e36, 0x5697,
0x4e15, 0x4cce, 0x4551, 0x4d31, 0x4cce, 0x4c4b, 0x4c2b, 0x64aa, 0x8ccb,
0x848a, 0x9428, 0x9c2a, 0xa3c8, 0xa3a7, 0x946a, 0xa3c8, 0xb387, 0xb388,
0xbb26, 0xb366, 0xbb67, 0xbb47, 0xbb06, 0xd347, 0xe2e6, 0x3415, 0x33f4,
0x1a2e, 0x1a4f, 0x3d58, 0x19aa, 0x22f2, 0x22d2, 0x2332, 0x33f4, 0x3cb7,
0x2353, 0x22b1, 0x1a6f, 0x2b53, 0x33f4, 0x3cb7, 0x1af1, 0x2b53, 0x226f,
0x22f2, 0x2bb4, 0x3475, 0x3cb6, 0x3d38, 0x3d38, 0x3537, 0x3d17, 0x2bb3,
0x3c76, 0x3415, 0x33d4, 0x3c35, 0x2311, 0x3415, 0x2bb4, 0x3415, 0x3496,
0x4538, 0x34f7, 0x3d58, 0x3d58, 0x461a, 0x463a, 0x3d98, 0x3db9, 0x3db8,
0x3517, 0x461a, 0x4dfa, 0x45d9, 0x3d98, 0x3d58, 0x3d38, 0x3496, 0x3cf7,
0x34b6, 0x3c96, 0x2b53, 0x2312, 0x22f1, 0x2312, 0x2b33, 0x226f, 0x22d2,
0x22b1, 0x22b0, 0x22d1, 0x2b12, 0x22f1, 0x22d1, 0x22d2, 0x22d1, 0x22b0,
0x22d1, 0x1a2e, 0x2270, 0x22b0, 0x1a91, 0x22d1, 0x22d1, 0x22b0, 0x2ab0,
0x228f, 0x22d0, 0x2b11, 0x3c15, 0x3455, 0x33f4, 0x2bb4, 0x3456, 0x3d58,
0x467a, 0x4efa, 0x46d9, 0x5719, 0x4e76, 0x5ef8, 0x4efa, 0x465a, 0x33b3,
0x2b73, 0x3475, 0x465a, 0x3d78, 0x3d58, 0x2c55, 0x2b32, 0x3415, 0x3d78,
0x3d58, 0x3d38, 0x45b9, 0x45f9, 0x463a, 0x56fc, 0x465a, 0x35d8, 0x3e19,
0x4e9b, 0x467a, 0x3577, 0x465a, 0x3df9, 0x4ebb, 0x46ba, 0x46da, 0x469a,
0x46ba, 0x4eda, 0x56fa, 0x4eb9, 0x4eb8, 0x4e57, 0x4e15, 0x44cf, 0x55f4,
0x55b3, 0x5571, 0x442a, 0x54ac, 0x546a, 0x5409, 0x746b, 0x9c49, 0x9c29,
0xa409, 0xabc8, 0xa3e8, 0xaba8, 0xa367, 0xab26, 0xab67, 0xb3a9, 0xbb47,
0xc388, 0xc367, 0xbb47, 0xdb27, 0xdaa5, 0x2bf4, 0x3435, 0x1a8f, 0x1a0c,
0x3537, 0x19aa, 0x22d2, 0x22f2, 0x2332, 0x33f5, 0x3cd7, 0x33d4, 0x22d1,
0x1ad1, 0x2312, 0x33f4, 0x3476, 0x2352, 0x2b93, 0x1a4e, 0x2290, 0x2b53,
0x3435, 0x3cd7, 0x34f7, 0x3d37, 0x4599, 0x3db9, 0x3d17, 0x33f4, 0x3455,
0x3435, 0x33f4, 0x3c56, 0x2b72, 0x3415, 0x33b4, 0x2bb4, 0x3476, 0x4579,
0x3d38, 0x3d38, 0x3d38, 0x4e3a, 0x4e9b, 0x3df9, 0x461a, 0x4e7b, 0x5edd,
0x3db8, 0x3db8, 0x3537, 0x463a, 0x3d78, 0x3d17, 0x34d7, 0x34d7, 0x4538,
0x3476, 0x3415, 0x2333, 0x2312, 0x2b12, 0x2b53, 0x2b53, 0x2332, 0x1ad1,
0x22d1, 0x2af1, 0x22f2, 0x22f1, 0x1ab1, 0x1ab1, 0x2311, 0x22f2, 0x22f2,
0x2290, 0x22b1, 0x22d1, 0x1a90, 0x3d58, 0x463a, 0x469a, 0x4e9b, 0x465a,
0x573b, 0x4f1b, 0x573b, 0x4f1b, 0x4f3b, 0x3d58, 0x573c, 0x4e7b, 0x4e1a,
0x4d99, 0x3cd6, 0x3435, 0x2b94, 0x2b73, 0x3415, 0x3496, 0x4f1c, 0x3517,
0x4538, 0x3517, 0x33b4, 0x2333, 0x3394, 0x4599, 0x3d79, 0x3d58, 0x3517,
0x3d98, 0x45f9, 0x467a, 0x4ebb, 0x4e9b, 0x465a, 0x3e79, 0x467a, 0x4e7b,
0x3e39, 0x465a, 0x469a, 0x467a, 0x3e59, 0x469a, 0x4efb, 0x4edb, 0x4efa,
0x4678, 0x56fa, 0x4e77, 0x4e78, 0x5634, 0x4d92, 0x55b3, 0x4d72, 0x44ef,
0x546c, 0x442b, 0x5c8b, 0x646b, 0x9ceb, 0x7c2a, 0x9c08, 0xa3e8, 0xa3c8,
0xa3c9, 0xaba8, 0xab46, 0xbb47, 0xbb47, 0xb326, 0xc388, 0xc347, 0xcb68,
0xcb06, 0xdac6, 0xdaa6, 0x3415, 0x2c55, 0x22f1, 0x1a0d, 0x3476, 0x19aa,
0x22d2, 0x22f2, 0x2b53, 0x33f5, 0x3476, 0x3c96, 0x2b73, 0x2312, 0x22b1,
0x3415, 0x3415, 0x3cd7, 0x2312, 0x2353, 0x2270, 0x2b12, 0x33d4, 0x3c96,
0x3cf7, 0x3d58, 0x3d78, 0x3d98, 0x3db8, 0x3d38, 0x3435, 0x3476, 0x2bf4,
0x33d4, 0x3455, 0x33f4, 0x3c15, 0x2b73, 0x33d5, 0x3476, 0x3d18, 0x3d38,
0x3cd7, 0x3d78, 0x4e7b, 0x4e7b, 0x3df9, 0x45f9, 0x45f9, 0x3df9, 0x3d58,
0x3db9, 0x45fa, 0x45d9, 0x3db9, 0x4598, 0x3d18, 0x34f7, 0x3d38, 0x3cb6,
0x3476, 0x33f4, 0x2b53, 0x2312, 0x2b53, 0x2b53, 0x33b4, 0x2b33, 0x2312,
0x22d1, 0x22f2, 0x22f2, 0x22d1, 0x1ad0, 0x22d1, 0x2312, 0x3455, 0x33d4,
0x2290, 0x22f2, 0x2332, 0x4538, 0x4619, 0x577b, 0x5739, 0x56f9, 0x4eb8,
0x469a, 0x4efc, 0x46da, 0x46fa, 0x33b4, 0x3496, 0x463a, 0x3df9, 0x4659,
0x46ba, 0x46ba, 0x4f1b, 0x3578, 0x34b6, 0x4559, 0x4599, 0x2b93, 0x2312,
0x22d1, 0x22f2, 0x3d38, 0x3d78, 0x3d58, 0x3d58, 0x3d78, 0x45d9, 0x4619,
0x4ebb, 0x3e39, 0x46ba, 0x4efb, 0x469b, 0x4efb, 0x465a, 0x46db, 0x3e79,
0x3e79, 0x469a, 0x4efb, 0x46db, 0x4efa, 0x46ba, 0x4ed9, 0x4678, 0x4eb9,
0x56b8, 0x4635, 0x4573, 0x44ef, 0x4df5, 0x55f5, 0x4c2b, 0x548c, 0x548c,
0x646a, 0x84ac, 0x9c8a, 0x9be8, 0xa3e8, 0xa3c7, 0x9c09, 0xa3e8, 0xa326,
0xb346, 0xcb68, 0xbb26, 0xbb06, 0xaba8, 0x9ba8, 0xcb68, 0xdb27, 0xdac6,
0xe265, 0x2bf4, 0x3476, 0x3373, 0x1a4e, 0x3435, 0x19ca, 0x1ad1, 0x2b33,
0x2b93, 0x3415, 0x3456, 0x3cd7, 0x33f5, 0x2332, 0x22b1, 0x33f4, 0x3476,
0x3475, 0x22f1, 0x33b4, 0x2290, 0x1a6f, 0x2b33, 0x3415, 0x34b6, 0x3d58,
0x4599, 0x45b9, 0x3d98, 0x3db8, 0x3d78, 0x2c35, 0x33f4, 0x3455, 0x3415,
0x3c76, 0x3435, 0x2b73, 0x2b94, 0x2bb4, 0x3c35, 0x3496, 0x3d17, 0x34f7,
0x3d98, 0x3db8, 0x465a, 0x35d8, 0x45f9, 0x3d98, 0x461a, 0x45f9, 0x3d98,
0x3db9, 0x3db9, 0x4e5a, 0x3d78, 0x3d58, 0x3d17, 0x3d38, 0x3d18, 0x34b6,
0x3476, 0x2bb4, 0x2332, 0x22f1, 0x2b52, 0x2b33, 0x2b73, 0x33b4, 0x2312,
0x22f2, 0x22f2, 0x1ad1, 0x22d2, 0x22f2, 0x22f2, 0x2333, 0x2bb3, 0x3394,
0x22d1, 0x22f2, 0x22b1, 0x2b52, 0x2332, 0x2352, 0x2332, 0x1b11, 0x2bd4,
0x4e19, 0x4efb, 0x4efb, 0x46fb, 0x4ebb, 0x4e1a, 0x2cb6, 0x4538, 0x3517,
0x44f8, 0x3cb7, 0x3c56, 0x2332, 0x2b12, 0x1ab1, 0x1a90, 0x22f2, 0x3435,
0x3517, 0x3d78, 0x3d18, 0x4578, 0x3d99, 0x45d9, 0x45f9, 0x4e7b, 0x467a,
0x4edb, 0x4efb, 0x46db, 0x4efb, 0x4efa, 0x4f1b, 0x46da, 0x469a, 0x4edb,
0x4efb, 0x4edb, 0x571b, 0x4efa, 0x4678, 0x4ed9, 0x4eb9, 0x4615, 0x5636,
0x550f, 0x5636, 0x5615, 0x4c6c, 0x4c4a, 0x546a, 0x648b, 0x746b, 0x9cea,
0x9c49, 0x9429, 0xabc8, 0xa3c7, 0xaba7, 0xab88, 0xa2e6, 0xb326, 0xd367,
0xbb27, 0xc306, 0xc367, 0xc367, 0xaaa5, 0xd2e5, 0xd285, 0xe245, 0x3cd7,
0x3496, 0x2bb4, 0x22d1, 0x2bd4, 0x220c, 0x22d1, 0x33b4, 0x2b93, 0x3435,
0x3455, 0x3cf7, 0x3456, 0x2b94, 0x2332, 0x2b73, 0x3455, 0x34b6, 0x33f4,
0x2b53, 0x2b73, 0x22b1, 0x22d1, 0x2b73, 0x3455, 0x34f7, 0x3d38, 0x3d78,
0x45d9, 0x3dd9, 0x3db8, 0x3d78, 0x34b6, 0x3496, 0x3476, 0x33f4, 0x3435,
0x3456, 0x2311, 0x2b73, 0x2b73, 0x3415, 0x34b6, 0x3517, 0x3d38, 0x3d58,
0x3d98, 0x3e3a, 0x56dc, 0x3dd9, 0x4e3a, 0x463a, 0x45f9, 0x3d78, 0x4e7b,
0x45f9, 0x3dd8, 0x45d9, 0x3558, 0x3d38, 0x3517, 0x4558, 0x34b6, 0x3cb6,
0x3496, 0x33d4, 0x2b53, 0x2312, 0x22f1, 0x2332, 0x2332, 0x2333, 0x2b53,
0x2312, 0x2b53, 0x2b12, 0x22f1, 0x2312, 0x22f1, 0x2312, 0x3394, 0x22f2,
0x22f2, 0x22d0, 0x22b0, 0x2290, 0x1a90, 0x3cb6, 0x3e59, 0x3d98, 0x3d58,
0x3d58, 0x4538, 0x3496, 0x3c76, 0x3435, 0x2bb4, 0x2b73, 0x22d0, 0x1a6f,
0x1a0d, 0x220d, 0x222d, 0x1a6f, 0x22d1, 0x2b94, 0x4578, 0x3d37, 0x3d17,
0x4579, 0x3d78, 0x3537, 0x3d78, 0x45f9, 0x4639, 0x465a, 0x467a, 0x46ba,
0x469a, 0x4edb, 0x4f1b, 0x469a, 0x4efb, 0x46ba, 0x46da, 0x46ba, 0x46ba,
0x46ba, 0x4ed9, 0x56fa, 0x4678, 0x4637, 0x5e97, 0x4db3, 0x4d30, 0x4db2,
0x4530, 0x6d2f, 0x4c0a, 0x546b, 0x646a, 0x94ec, 0x9c8a, 0xa429, 0xabc8,
0xa3c8, 0x9b66, 0xabc8, 0xab67, 0xab67, 0xcb26, 0xbb67, 0xc327, 0xab47,
0xb367, 0xaba8, 0xd326, 0xe2a6, 0xe286, 0xe245, 0x3cf7, 0x3cd7, 0x33f4,
0x2312, 0x1b12, 0x19cb, 0x1ab0, 0x33d4, 0x33b4, 0x3415, 0x3c96, 0x3d18,
0x34f7, 0x3415, 0x2b53, 0x22f1, 0x3455, 0x3cb6, 0x3cf7, 0x2b32, 0x33d4,
0x22d1, 0x1a8f, 0x2b53, 0x2bf4, 0x3c76, 0x3d17, 0x3d38, 0x45b9, 0x45f9,
0x3dd9, 0x3577, 0x3d98, 0x3d17, 0x3c96, 0x3c96, 0x3415, 0x3c56, 0x2c35,
0x2312, 0x2b73, 0x2b32, 0x33d4, 0x3cf7, 0x4579, 0x3d18, 0x3d17, 0x3558,
0x4efc, 0x4e9b, 0x4e7b, 0x463a, 0x3db9, 0x56bc, 0x3d78, 0x3577, 0x3db9,
0x3598, 0x4e5b, 0x3d98, 0x3578, 0x3d78, 0x3517, 0x3cf7, 0x3cd7, 0x3cb7,
0x2c35, 0x33d4, 0x3394, 0x2b33, 0x22f2, 0x2333, 0x2b53, 0x2b53, 0x33b4,
0x2b94, 0x2333, 0x2312, 0x2b33, 0x2333, 0x2312, 0x2332, 0x2313, 0x22af,
0x22d1, 0x22f1, 0x22d1, 0x1a6f, 0x2291, 0x3d58, 0x3d17, 0x4dda, 0x34b6,
0x3415, 0x2b74, 0x2332, 0x1a90, 0x1a2e, 0x19ec, 0x19ec, 0x19ec, 0x19cc,
0x19ec, 0x226f, 0x1ab1, 0x2bf4, 0x3d78, 0x3d37, 0x3d58, 0x4579, 0x45b9,
0x3557, 0x3d98, 0x3578, 0x3e19, 0x3597, 0x469b, 0x467a, 0x46db, 0x573c,
0x4efb, 0x4f1b, 0x46da, 0x4eda, 0x4efb, 0x46ba, 0x4efb, 0x4eda, 0x56d9,
0x4ed9, 0x4698, 0x4e56, 0x4dd4, 0x3cf0, 0x55d3, 0x4dd3, 0x4cce, 0x4c49,
0x442b, 0x544b, 0x644b, 0x94ec, 0x9c29, 0x9be8, 0x9c28, 0xac2a, 0xa387,
0xa367, 0xa3a8, 0xc306, 0xc306, 0xd347, 0xcb27, 0xbb26, 0xbb27, 0xdb27,
0xb2a6, 0xe2a6, 0xda66, 0xe225, 0x3cd7, 0x34d7, 0x3435, 0x2312, 0x22f2,
0x1a0d, 0x22d1, 0x33f4, 0x2bb4, 0x3476, 0x3cb7, 0x3d37, 0x3d99, 0x3456,
0x2b73, 0x22d1, 0x3496, 0x3496, 0x3d38, 0x2b53, 0x33b4, 0x2b32, 0x2312,
0x1ab1, 0x33d4, 0x3455, 0x34b6, 0x3d38, 0x3d58, 0x3577, 0x4619, 0x3df9,
0x463a, 0x3db8, 0x3d18, 0x3cb7, 0x3475, 0x3435, 0x3435, 0x3c76, 0x33f4,
0x2b53, 0x2b73, 0x33d4, 0x3cb7, 0x3cf7, 0x3d17, 0x34f7, 0x3d98, 0x45f9,
0x467a, 0x465a, 0x3df9, 0x4619, 0x3df9, 0x3db8, 0x3d78, 0x45f9, 0x461a,
0x461a, 0x3db8, 0x3db8, 0x45d9, 0x3d78, 0x3d38, 0x3d17, 0x3cf7, 0x3cf7,
0x3476, 0x3415, 0x2b53, 0x2353, 0x2b53, 0x2333, 0x2b73, 0x2b53, 0x2b93,
0x2b94, 0x2b73, 0x2353, 0x22f2, 0x2b53, 0x2b33, 0x2312, 0x22f2, 0x22f1,
0x1a8f, 0x22f2, 0x2312, 0x1ab0, 0x1a70, 0x3415, 0x3d57, 0x45da, 0x3c56,
0x2b94, 0x33d4, 0x1a90, 0x1a4e, 0x1a2d, 0x224e, 0x1a4e, 0x220c, 0x222d,
0x22d1, 0x3475, 0x3d37, 0x4599, 0x3d58, 0x3d38, 0x3d58, 0x4599, 0x3db8,
0x461a, 0x3db8, 0x3e19, 0x465a, 0x4ebb, 0x4edb, 0x4efb, 0x4f1b, 0x4ed9,
0x4efa, 0x4eb9, 0x46b9, 0x571b, 0x4efa, 0x4eb9, 0x4eb8, 0x4eb8, 0x4e57,
0x4e77, 0x55d4, 0x5656, 0x4dd4, 0x4d92, 0x4c6d, 0x442c, 0x546d, 0x646a,
0x94eb, 0x9c8a, 0x9429, 0x93e8, 0xa42a, 0xa387, 0xaba7, 0xaba7, 0xc367,
0xb326, 0xb306, 0xd367, 0xcb27, 0xc367, 0xbae6, 0xdb06, 0xbac6, 0xeaa6,
0xe266, 0xd9e4, 0x4518, 0x3d17, 0x3c75, 0x2b53, 0x2290, 0x222e, 0x22d1,
0x3415, 0x3c36, 0x3476, 0x3cf7, 0x3d58, 0x3d78, 0x3cb6, 0x2bb4, 0x2312,
0x3496, 0x34f7, 0x34d7, 0x2bb4, 0x2332, 0x33f4, 0x3353, 0x22d1, 0x22f2,
0x33f5, 0x3476, 0x3cd7, 0x3d58, 0x3db9, 0x4619, 0x4e9b, 0x3e19, 0x467a,
0x4639, 0x3537, 0x34d7, 0x3496, 0x3455, 0x3415, 0x3496, 0x3435, 0x2312,
0x2b74, 0x2b73, 0x3456, 0x3cb6, 0x3d17, 0x3d17, 0x4599, 0x3d98, 0x467a,
0x469b, 0x4e7b, 0x3e19, 0x45fa, 0x3db8, 0x45f9, 0x45b9, 0x45fa, 0x461a,
0x4e3a, 0x3dd9, 0x4e5b, 0x3d98, 0x3d38, 0x3517, 0x34f7, 0x4518, 0x3cf7,
0x3476, 0x3415, 0x2b73, 0x2b53, 0x2b32, 0x2312, 0x2b53, 0x2b52, 0x2353,
0x2b53, 0x2b53, 0x2b94, 0x2b93, 0x2b73, 0x2b53, 0x2b52, 0x2312, 0x2312,
0x22b0, 0x22f2, 0x22d1, 0x2b33, 0x1a90, 0x22b0, 0x3cb6, 0x45b9, 0x3d98,
0x3cd7, 0x3435, 0x2bb4, 0x33b4, 0x2b73, 0x22b0, 0x21ec, 0x1a90, 0x3cf7,
0x3d58, 0x3d38, 0x3d38, 0x3d58, 0x3d58, 0x3d78, 0x45d9, 0x45d9, 0x4e3a,
0x45d9, 0x3e19, 0x467a, 0x469b, 0x4efb, 0x4edb, 0x4efa, 0x571a, 0x571a,
0x4eb9, 0x4eba, 0x4efa, 0x4699, 0x4e77, 0x56b9, 0x4e77, 0x4df4, 0x4e15,
0x4dd4, 0x5615, 0x4cad, 0x5ccc, 0x5c8c, 0x648a, 0x6c8c, 0xa50b, 0xa50c,
0x9b87, 0xa3c7, 0x9b87, 0xa3e8, 0xa3e9, 0xab46, 0xa3a8, 0xcb67, 0xcb67,
0xc327, 0xbb26, 0xb367, 0xd327, 0xc2a6, 0xe285, 0xda65, 0xda45, 0xe245,
0x3cf7, 0x3d17, 0x3c76, 0x33b4, 0x1a4e, 0x224e, 0x22d1, 0x3435, 0x3c76,
0x3455, 0x3d38, 0x3d78, 0x4619, 0x3cf7, 0x3435, 0x33d4, 0x3475, 0x3d38,
0x3d38, 0x3d17, 0x2353, 0x2bd4, 0x2b53, 0x2b74, 0x1af1, 0x2b53, 0x3435,
0x34b6, 0x3517, 0x3d78, 0x3598, 0x465a, 0x4edb, 0x463a, 0x4ebb, 0x4edb,
0x3d58, 0x34d6, 0x34d7, 0x3c96, 0x3415, 0x3c96, 0x3496, 0x22d1, 0x2b53,
0x2311, 0x33d4, 0x3cb7, 0x4579, 0x3d58, 0x4579, 0x3db9, 0x467a, 0x35b8,
0x3e19, 0x4e5a, 0x463a, 0x461a, 0x35b8, 0x35b8, 0x3df9, 0x3d98, 0x3db9,
0x45f9, 0x3d78, 0x45f9, 0x3dd9, 0x3d38, 0x3517, 0x4558, 0x3cd7, 0x44f8,
0x4518, 0x3c76, 0x2bb4, 0x2b53, 0x2312, 0x2b73, 0x2312, 0x33b4, 0x22f1,
0x2b73, 0x2b53, 0x2b73, 0x3394, 0x3bf4, 0x3394, 0x2b74, 0x2353, 0x2312,
0x22b0, 0x22b1, 0x22f1, 0x22f1, 0x22d1, 0x226f, 0x3393, 0x34f7, 0x4599,
0x3d18, 0x3cf7, 0x3476, 0x22f1, 0x19ec, 0x22d1, 0x3d58, 0x3d38, 0x3d38,
0x3d58, 0x4579, 0x3d58, 0x3d98, 0x3db9, 0x45f9, 0x45f9, 0x461a, 0x3577,
0x4e7a, 0x465a, 0x4edb, 0x4f1b, 0x571a, 0x56f9, 0x4ed8, 0x4ed9, 0x56d9,
0x4eb8, 0x4e77, 0x4e56, 0x4e57, 0x4e77, 0x4e35, 0x45b4, 0x4e35, 0x4d31,
0x5cad, 0x54ae, 0x64cb, 0x74cc, 0x8ceb, 0x9c69, 0xa449, 0xa3e8, 0x9c09,
0x9386, 0xabc7, 0xa387, 0xab87, 0xcb88, 0xd326, 0xb348, 0xc326, 0xbb46,
0xd388, 0xd2a5, 0xeac6, 0xe2c6, 0xe2a6, 0xe2a6, 0xd265, 0x3cd6, 0x3d58,
0x3435, 0x33f5, 0x224e, 0x1a70, 0x22f2, 0x3435, 0x3c96, 0x3c76, 0x3d38,
0x45d9, 0x465a, 0x3d38, 0x3496, 0x33f5, 0x3435, 0x3d58, 0x3d38, 0x3d58,
0x2bb4, 0x2b93, 0x3455, 0x2b73, 0x2b73, 0x2b53, 0x3415, 0x3456, 0x3d18,
0x3d17, 0x4598, 0x3db8, 0x467a, 0x4edb, 0x469a, 0x46db, 0x4f1b, 0x3d78,
0x3d38, 0x34d7, 0x3455, 0x3415, 0x3c96, 0x3cb6, 0x22f1, 0x2312, 0x33d4,
0x33f4, 0x3496, 0x3d38, 0x3517, 0x34d6, 0x3558, 0x3df9, 0x469b, 0x56fc,
0x45f9, 0x463a, 0x3dd8, 0x3e19, 0x3e3a, 0x45b9, 0x4e9b, 0x45f9, 0x3db8,
0x4e7b, 0x3db9, 0x45d9, 0x4dfa, 0x3d17, 0x3d38, 0x34d7, 0x34f7, 0x3d17,
0x3496, 0x3456, 0x33f5, 0x2b94, 0x2b73, 0x2b53, 0x2b53, 0x2b73, 0x3394,
0x2b33, 0x2b73, 0x2b73, 0x3394, 0x2b94, 0x33b4, 0x2b94, 0x2b94, 0x2b73,
0x22b1, 0x22b0, 0x22f1, 0x22d1, 0x22f2, 0x22b0, 0x1a6f, 0x2332, 0x33f5,
0x2b93, 0x22b0, 0x1a2d, 0x22f1, 0x4599, 0x3d78, 0x4558, 0x4578, 0x3d38,
0x4599, 0x3558, 0x3d98, 0x45fa, 0x4619, 0x463a, 0x3df9, 0x3e19, 0x4e7a,
0x46da, 0x4efa, 0x5f1a, 0x56f9, 0x56d9, 0x4efa, 0x56b8, 0x4678, 0x4e56,
0x4615, 0x4e56, 0x4e77, 0x4e15, 0x4df4, 0x5636, 0x54ad, 0x54ab, 0x5cac,
0x546c, 0x84ec, 0x9c8a, 0x94aa, 0xa46a, 0xabc7, 0xa367, 0xabc8, 0xaba8,
0xb3a8, 0xb388, 0xb306, 0xa3c9, 0xc347, 0xcb67, 0xcb47, 0xe348, 0xdaa5,
0xe2c5, 0xcae6, 0xe2c6, 0xe2e6, 0xe266, 0x34b6, 0x3d78, 0x3c76, 0x3456,
0x1a0c, 0x1ab1, 0x2312, 0x3415, 0x34d7, 0x3c96, 0x3d58, 0x45b9, 0x4e9b,
0x3db9, 0x3cd7, 0x3415, 0x3415, 0x4599, 0x3d58, 0x3d99, 0x2bd4, 0x2bb4,
0x3435, 0x2b73, 0x3415, 0x2332, 0x33d5, 0x3455, 0x3c96, 0x3d17, 0x4599,
0x3db8, 0x4619, 0x469a, 0x4edb, 0x4eda, 0x46ba, 0x46db, 0x45d9, 0x3d58,
0x3d17, 0x3cd7, 0x3455, 0x3476, 0x3cb7, 0x33f4, 0x22f1, 0x3435, 0x2b93,
0x3476, 0x34d6, 0x3d58, 0x3d58, 0x3d37, 0x3d98, 0x4ebb, 0x467a, 0x3e59,
0x3e39, 0x4ebb, 0x461a, 0x4edb, 0x4ebb, 0x3d78, 0x4e5a, 0x45f9, 0x3df9,
0x461a, 0x45d9, 0x3dd9, 0x3d78, 0x3538, 0x3d38, 0x3d18, 0x3d17, 0x4518,
0x4518, 0x3496, 0x33f5, 0x2353, 0x3374, 0x2b53, 0x2b53, 0x2332, 0x2b73,
0x33b4, 0x2b52, 0x2b93, 0x3394, 0x2b73, 0x2b94, 0x3394, 0x2b53, 0x2b52,
0x22b0, 0x1ab1, 0x22d1, 0x22d2, 0x22f1, 0x22f2, 0x22f2, 0x22f1, 0x22f2,
0x22f1, 0x3455, 0x3d99, 0x3d58, 0x3d17, 0x3d58, 0x4558, 0x4578, 0x3558,
0x45b9, 0x45fa, 0x45f9, 0x4e5b, 0x461a, 0x3df9, 0x469a, 0x469a, 0x4f1b,
0x56f9, 0x4ed9, 0x56d8, 0x4e56, 0x5676, 0x4e55, 0x4e35, 0x4e35, 0x4636,
0x4e15, 0x5655, 0x4e35, 0x4d71, 0x4cae, 0x54ab, 0x650c, 0x6ced, 0x9d0b,
0x9ccb, 0xac6a, 0xa3e8, 0xa3a8, 0xaba8, 0xabc8, 0xab67, 0xb347, 0xa3a9,
0xcb67, 0xbb48, 0xb2e5, 0xbb47, 0xd306, 0xdae7, 0xd2c6, 0xe2c5, 0xe2a5,
0xe2e6, 0xdaa5, 0xdae6, 0x3476, 0x3d37, 0x3c96, 0x3c56, 0x1a0c, 0x22d1,
0x2332, 0x3415, 0x3d17, 0x3cb6, 0x4558, 0x3d98, 0x4edb, 0x3df9, 0x3cf7,
0x33f4, 0x2bb4, 0x3557, 0x3537, 0x3db9, 0x3455, 0x33f4, 0x3415, 0x3435,
0x33d4, 0x3415, 0x2332, 0x33f4, 0x34d6, 0x34b6, 0x3d17, 0x45b9, 0x461a,
0x3e39, 0x467a, 0x3637, 0x56fa, 0x4eda, 0x46ba, 0x45f9, 0x3d58, 0x3d17,
0x3cd7, 0x3476, 0x3c96, 0x3cb7, 0x3cb7, 0x22b0, 0x3496, 0x2353, 0x3435,
0x3cf7, 0x4599, 0x4579, 0x3d17, 0x45f9, 0x4619, 0x463a, 0x46ba, 0x469a,
0x465a, 0x3df9, 0x465a, 0x3577, 0x3db8, 0x3d78, 0x3d98, 0x45f9, 0x463a,
0x3e19, 0x467b, 0x3df9, 0x3d98, 0x3d38, 0x4579, 0x3d17, 0x3d17, 0x3cd7,
0x3cd7, 0x2c35, 0x3435, 0x2b93, 0x33b4, 0x2b73, 0x2332, 0x33b4, 0x2b73,
0x33f5, 0x2332, 0x2373, 0x33d4, 0x33b4, 0x33b4, 0x2312, 0x2b33, 0x2312,
0x22d1, 0x22d1, 0x2290, 0x22b1, 0x2312, 0x33b4, 0x3415, 0x34b6, 0x3d98,
0x4578, 0x4599, 0x3d17, 0x3d58, 0x34d6, 0x4579, 0x3d58, 0x3d99, 0x45f9,
0x45d9, 0x565b, 0x461a, 0x3e19, 0x469b, 0x469a, 0x469a, 0x4efa, 0x4ef9,
0x4e98, 0x4e97, 0x56b8, 0x5656, 0x5656, 0x4e56, 0x4e36, 0x5e97, 0x4e35,
0x4e15, 0x54ad, 0x546b, 0x5cac, 0x6ccc, 0x8d2d, 0x9cec, 0x9c8a, 0xa409,
0xb42a, 0xabc8, 0x93c8, 0xaba8, 0xa387, 0xb306, 0xd367, 0xd326, 0xdb47,
0xcb47, 0xdb26, 0xe306, 0xdaa5, 0xdaa5, 0xe2c6, 0xe306, 0xe347, 0xd2e6,
0xe2c6, 0x3cd7, 0x3d57, 0x3455, 0x3455, 0x1a0d, 0x2333, 0x2b73, 0x3435,
0x3d38, 0x3cd7, 0x3d78, 0x45f9, 0x4e9b, 0x461a, 0x3d58, 0x3455, 0x2b94,
0x3db9, 0x3dd9, 0x3d98, 0x3cf7, 0x3415, 0x33f4, 0x3476, 0x33f5, 0x3496,
0x33f4, 0x2b94, 0x3435, 0x3d17, 0x3d17, 0x3d37, 0x4619, 0x3df9, 0x467a,
0x469a, 0x4eb9, 0x45f5, 0x4efa, 0x46d9, 0x4619, 0x3d78, 0x34d7, 0x34f7,
0x3c96, 0x3c96, 0x3c96, 0x3cf7, 0x1ad0, 0x3cb6, 0x33d4, 0x33f5, 0x3cd7,
0x3d38, 0x3d37, 0x3d58, 0x3db9, 0x45d9, 0x56fc, 0x467a, 0x4efb, 0x4e7b,
0x3e39, 0x465a, 0x467b, 0x35b8, 0x3db8, 0x3598, 0x3d98, 0x3d98, 0x463a,
0x35d8, 0x467b, 0x3e19, 0x3d58, 0x3d38, 0x3d78, 0x34d7, 0x3cf7, 0x3cd7,
0x3496, 0x3c96, 0x3415, 0x2b53, 0x2b73, 0x2b93, 0x2b73, 0x2b94, 0x3394,
0x33f4, 0x2312, 0x2b32, 0x3415, 0x33b4, 0x33b4, 0x2b94, 0x2b33, 0x22d1,
0x22d1, 0x1a90, 0x22d1, 0x3415, 0x3c56, 0x45fa, 0x3db9, 0x3d58, 0x4558,
0x3d17, 0x3cd7, 0x3d38, 0x3d38, 0x3d58, 0x3d99, 0x45d9, 0x45d9, 0x461a,
0x461a, 0x463a, 0x469b, 0x46ba, 0x4efa, 0x571a, 0x4ef9, 0x4ed9, 0x56b8,
0x4ed9, 0x5677, 0x45f4, 0x4e77, 0x4e56, 0x4e36, 0x4e98, 0x4cce, 0x546a,
0x4c6d, 0x6cec, 0x748b, 0xa4eb, 0xa4ca, 0x9428, 0xa408, 0xa46b, 0xaba7,
0xa3e8, 0xaba8, 0xbbc8, 0xb388, 0xb327, 0xdb88, 0xbb46, 0xbb47, 0xdb07,
0xeae6, 0xdae6, 0xdb06, 0xe2e6, 0xcb06, 0xe307, 0xdb07, 0xe1e5, 0x3d17,
0x3d98, 0x3496, 0x34b6, 0x1a2e, 0x2353, 0x2bd4, 0x3435, 0x3d17, 0x3cb7,
0x3d58, 0x4619, 0x46ba, 0x4619, 0x3d58, 0x3cb6, 0x2bd4, 0x3db8, 0x461a,
0x461a, 0x45b9, 0x3435, 0x3455, 0x3435, 0x3435, 0x3cf7, 0x3cd7, 0x2b93,
0x3475, 0x3476, 0x3d18, 0x3d58, 0x34f6, 0x463a, 0x3e39, 0x467a, 0x56fa,
0x4e98, 0x4df4, 0x4e77, 0x46b8, 0x465a, 0x3d78, 0x3d37, 0x34f7, 0x3c96,
0x3496, 0x44f7, 0x3475, 0x22f1, 0x3cb6, 0x3476, 0x2b93, 0x3c96, 0x3cd6,
0x3d78, 0x4578, 0x3d17, 0x45d9, 0x45f9, 0x4659, 0x4ebb, 0x469a, 0x3dd9,
0x4e5a, 0x3e19, 0x4edb, 0x4ebc, 0x45b9, 0x56dc, 0x4e1a, 0x461a, 0x467a,
0x463a, 0x463a, 0x3dd9, 0x3d79, 0x3d58, 0x3537, 0x34d7, 0x3cd7, 0x34b6,
0x3cd7, 0x3cb7, 0x2bb3, 0x2b53, 0x2b93, 0x2b73, 0x2b74, 0x2b73, 0x33b4,
0x33d4, 0x1af1, 0x3373, 0x33f5, 0x2bd4, 0x33b4, 0x2b53, 0x22f2, 0x1ab1,
0x2b32, 0x22f1, 0x33f5, 0x3d38, 0x3d98, 0x3d78, 0x3d38, 0x3d38, 0x3cf7,
0x3d17, 0x3d58, 0x3d38, 0x3d78, 0x3d98, 0x3db9, 0x45f9, 0x3dd9, 0x4e9b,
0x3e39, 0x46db, 0x46ba, 0x46b9, 0x4699, 0x56fa, 0x56f9, 0x56b8, 0x4e76,
0x5676, 0x5677, 0x56b9, 0x4e15, 0x5e77, 0x446c, 0x4c8d, 0x440a, 0x6ccc,
0x7c6b, 0x948a, 0xb56d, 0x9ccb, 0x9bc7, 0xabc7, 0xa408, 0x9b66, 0xab67,
0x9b67, 0xbb67, 0xcb68, 0xd367, 0xdb47, 0xe306, 0xe307, 0xeb07, 0xe306,
0xdac5, 0xc327, 0xd307, 0xc326, 0xda46, 0xe1e5, 0x3d17, 0x3d57, 0x3455,
0x3d18, 0x1a6f, 0x2b93, 0x3455, 0x3c76, 0x3d38, 0x3cf7, 0x3578, 0x465a,
0x4eda, 0x3e19, 0x45d9, 0x3cd7, 0x33f4, 0x45d9, 0x3e39, 0x2d57, 0x3dd9,
0x3476, 0x3476, 0x3476, 0x3496, 0x3455, 0x45b9, 0x3496, 0x2b53, 0x3cf7,
0x3d17, 0x3517, 0x3d38, 0x3d78, 0x465a, 0x4e9b, 0x4eba, 0x4656, 0x4df5,
0x55f4, 0x5656, 0x4e78, 0x3e39, 0x3d78, 0x3537, 0x3cf7, 0x34b6, 0x3c96,
0x3cf7, 0x3cd7, 0x2bd4, 0x3c36, 0x3c96, 0x2312, 0x2bf4, 0x2cd6, 0x3d58,
0x4598, 0x4579, 0x45d9, 0x3536, 0x467b, 0x465a, 0x46da, 0x4e7a, 0x3e39,
0x4e7b, 0x467a, 0x467a, 0x467a, 0x45b9, 0x467b, 0x461a, 0x45b9, 0x4e7b,
0x3dd9, 0x35d8, 0x3db8, 0x4578, 0x3d58, 0x3d17, 0x3cf7, 0x3cf7, 0x3d17,
0x3c96, 0x3455, 0x33d4, 0x33b4, 0x33f5, 0x2332, 0x2b94, 0x2b73, 0x2b93,
0x33f5, 0x2332, 0x2b53, 0x3c36, 0x3c15, 0x2b53, 0x2312, 0x22d1, 0x22f1,
0x1a90, 0x33b4, 0x3d79, 0x3d78, 0x3d58, 0x3d17, 0x3d18, 0x34f7, 0x3d18,
0x3d37, 0x3d38, 0x3558, 0x3db9, 0x45f9, 0x45b9, 0x3df9, 0x465a, 0x4edb,
0x46ba, 0x4efb, 0x4edb, 0x3e78, 0x4699, 0x4698, 0x4e98, 0x4e35, 0x5698,
0x5677, 0x56d9, 0x5550, 0x4c6c, 0x5ccc, 0x546b, 0x8d2d, 0x8c6a, 0xa4ca,
0xa449, 0xa46a, 0xac6a, 0xa48a, 0xac09, 0xb388, 0x9b47, 0xbb47, 0xd326,
0xb307, 0xcb26, 0xe306, 0xdae6, 0xdac6, 0xe2c5, 0xdac5, 0xd306, 0xd306,
0xc327, 0xe245, 0xea26, 0xd986, 0x3d57, 0x3dd9, 0x44d7, 0x34b6, 0x2270,
0x2bb4, 0x3cb7, 0x3476, 0x3d78, 0x3d18, 0x3d98, 0x467a, 0x4eb9, 0x465a,
0x3d98, 0x4558, 0x2c35, 0x463a, 0x467a, 0x3e19, 0x463a, 0x3cf7, 0x3cb7,
0x3476, 0x3cb7, 0x33b4, 0x3d57, 0x4538, 0x2b93, 0x3496, 0x3cb7, 0x4598,
0x3d78, 0x3d98, 0x3dd8, 0x46ba, 0x4659, 0x4ed9, 0x4573, 0x5530, 0x4cae,
0x5e76, 0x5678, 0x467a, 0x3d78, 0x3d58, 0x3d17, 0x3d18, 0x3cb6, 0x3d18,
0x3cd7, 0x3415, 0x33f4, 0x3496, 0x2332, 0x3435, 0x3d38, 0x4579, 0x3537,
0x3d58, 0x3d78, 0x3dd9, 0x4639, 0x3e19, 0x469a, 0x3e59, 0x467b, 0x467b,
0x3db8, 0x573c, 0x4659, 0x3df9, 0x3d98, 0x3598, 0x3d98, 0x3e19, 0x465a,
0x3e5a, 0x3e19, 0x3d99, 0x3d78, 0x3d79, 0x3d38, 0x3d38, 0x3d18, 0x3496,
0x3cb7, 0x3c35, 0x2bb4, 0x33d4, 0x33b4, 0x2b53, 0x2b94, 0x2b73, 0x3c15,
0x2b53, 0x2332, 0x33d4, 0x33d4, 0x2b53, 0x22f1, 0x22d1, 0x22d0, 0x1ab0,
0x2b94, 0x4dda, 0x3d99, 0x34f7, 0x4518, 0x34d7, 0x3d18, 0x3d58, 0x3d37,
0x3d78, 0x45d9, 0x3df9, 0x3537, 0x461a, 0x4e9b, 0x4edb, 0x4edb, 0x4f1c,
0x4efb, 0x46db, 0x571b, 0x4eda, 0x5636, 0x4e56, 0x4636, 0x5677, 0x4d72,
0x54ce, 0x4c4b, 0x5cab, 0x84ec, 0x642a, 0x9cec, 0xacca, 0xacec, 0x9c48,
0x9c28, 0xa408, 0x942a, 0xabc8, 0xab27, 0xbb67, 0xd327, 0xcb46, 0xcae6,
0xdac6, 0xe2e5, 0xe2c5, 0xdae5, 0xdb06, 0xdb47, 0xab67, 0xe286, 0xea26,
0xd9a5, 0xd125, 0x3d98, 0x469a, 0x3cf7, 0x3d17, 0x22b1, 0x3415, 0x3cf7,
0x3cd7, 0x4599, 0x3d18, 0x3d78, 0x4ebb, 0x4656, 0x467a, 0x45f9, 0x3d38,
0x3455, 0x3df9, 0x4efb, 0x467a, 0x469a, 0x34f7, 0x34d6, 0x3cb6, 0x3cb7,
0x3435, 0x3476, 0x45d9, 0x3c76, 0x2b53, 0x3d58, 0x34b6, 0x45d9, 0x45b9,
0x3db8, 0x3db8, 0x4eda, 0x46ba, 0x55f4, 0x44ef, 0x4cae, 0x4cef, 0x5615,
0x5615, 0x46ba, 0x4598, 0x3578, 0x3d99, 0x3d18, 0x3cf8, 0x3d17, 0x3cd7,
0x3cb7, 0x2bb4, 0x2c35, 0x2393, 0x3bf5, 0x4538, 0x4558, 0x3d58, 0x4dfb,
0x3537, 0x3d98, 0x3db8, 0x469b, 0x56db, 0x46da, 0x4edb, 0x3e59, 0x465a,
0x4e7b, 0x4ebb, 0x4ebb, 0x45d9, 0x4edb, 0x4e7b, 0x4e7b, 0x4ebc, 0x4619,
0x3e19, 0x45d9, 0x3d38, 0x45fa, 0x34f7, 0x3d17, 0x3d18, 0x3496, 0x3cd7,
0x3455, 0x2bb4, 0x33b4, 0x3c35, 0x2b53, 0x33b4, 0x2b73, 0x2b73, 0x3c55,
0x2333, 0x33b4, 0x2bb4, 0x2b73, 0x2311, 0x1ab1, 0x1a4f, 0x22f1, 0x2b73,
0x45b9, 0x3d38, 0x34b6, 0x3cd7, 0x34d7, 0x3d18, 0x34d6, 0x3d58, 0x3db9,
0x45b9, 0x3d98, 0x4619, 0x3e19, 0x467a, 0x46bb, 0x4edb, 0x4edb, 0x46db,
0x46ba, 0x4ed9, 0x4e36, 0x5635, 0x56b8, 0x5697, 0x44ae, 0x548c, 0x548c,
0x74ec, 0x84cc, 0x94ec, 0x94ab, 0xa4cb, 0xa469, 0xa48a, 0xa3c8, 0xabe8,
0xa387, 0xb367, 0xc326, 0xd347, 0xcb68, 0xd306, 0xe2c5, 0xdac6, 0xbac5,
0xdae6, 0xdb27, 0xcb06, 0xabc9, 0xe2c6, 0xe205, 0xe1e5, 0xd9a5, 0xe186,
0x465a, 0x4639, 0x3517, 0x3cb6, 0x2af2, 0x3455, 0x4599, 0x34d7, 0x3d78,
0x3d17, 0x45f9, 0x4eba, 0x4e35, 0x3df8, 0x4e3a, 0x3517, 0x34b6, 0x35b8,
0x4efb, 0x4e9a, 0x4eba, 0x3517, 0x3d58, 0x3cd7, 0x3cd7, 0x3476, 0x3476,
0x463a, 0x3537, 0x2bb4, 0x3476, 0x3d38, 0x45fa, 0x3db8, 0x45f9, 0x3d98,
0x571a, 0x46da, 0x4e99, 0x64ee, 0x548c, 0x64ab, 0x54ad, 0x4d71, 0x56b7,
0x46bb, 0x3d98, 0x3d58, 0x3d38, 0x34f7, 0x3cf7, 0x3517, 0x34f7, 0x3496,
0x33f4, 0x33d4, 0x2b93, 0x33f5, 0x3d17, 0x3d17, 0x45b9, 0x3d99, 0x3d58,
0x45d9, 0x3df9, 0x3e5a, 0x3e39, 0x4efa, 0x3e99, 0x467a, 0x469b, 0x3e39,
0x46fa, 0x467a, 0x3db8, 0x3dd9, 0x3df9, 0x45f9, 0x465a, 0x45f9, 0x4ebb,
0x461a, 0x3d57, 0x45f9, 0x3537, 0x34f7, 0x3cf7, 0x34b6, 0x3cd7, 0x3455,
0x2bb3, 0x33f5, 0x3415, 0x2b94, 0x33f4, 0x2b73, 0x33d4, 0x3435, 0x2b32,
0x2b94, 0x33f5, 0x2b53, 0x2b73, 0x22b1, 0x1a90, 0x1ab0, 0x2b73, 0x4599,
0x3d17, 0x3cd7, 0x3496, 0x3cd7, 0x3d17, 0x3d38, 0x3d58, 0x3d98, 0x45d9,
0x45fa, 0x3e19, 0x469a, 0x469a, 0x469a, 0x469a, 0x469a, 0x469a, 0x5ed8,
0x4e35, 0x5635, 0x4eb8, 0x4d91, 0x4cad, 0x652e, 0x548d, 0x6c8b, 0x8cec,
0xad2c, 0x948a, 0xaccb, 0x9be8, 0xa428, 0xa429, 0xac09, 0xb409, 0xc347,
0xc347, 0xcb68, 0xdb26, 0xdac6, 0xe2e6, 0xeb27, 0xdb06, 0xdae6, 0xcae6,
0xb326, 0xeae6, 0xda45, 0xe206, 0xd985, 0xd9e6, 0xd164, 0x4e7b, 0x4e9b,
0x3d38, 0x3d17, 0x2312, 0x3476, 0x45b9, 0x3517, 0x3d98, 0x3d38, 0x465a,
0x4658, 0x4dd4, 0x46ba, 0x463a, 0x3db9, 0x3cd7, 0x3e39, 0x4e99, 0x4eba,
0x46ba, 0x45d9, 0x4598, 0x3d58, 0x3c96, 0x3d17, 0x3435, 0x3db8, 0x3d98,
0x3435, 0x3435, 0x3d78, 0x3d78, 0x463a, 0x45f9, 0x45f9, 0x3e19, 0x5676,
0x4eba, 0x4d71, 0x644a, 0x7d0d, 0x954e, 0x5d30, 0x5593, 0x5656, 0x3e59,
0x45d9, 0x45d9, 0x3d58, 0x3cf7, 0x34f7, 0x3d58, 0x3d17, 0x3496, 0x3435,
0x2bd4, 0x2bd4, 0x33d4, 0x3cd7, 0x3d38, 0x45fa, 0x4599, 0x3d58, 0x3d58,
0x461a, 0x3df9, 0x4659, 0x4edb, 0x46da, 0x46bb, 0x465a, 0x3e19, 0x3e59,
0x3df9, 0x465a, 0x4598, 0x4679, 0x461a, 0x4619, 0x467a, 0x3e19, 0x567b,
0x3d78, 0x3d78, 0x3d78, 0x3d38, 0x3cf7, 0x3cf7, 0x3cf7, 0x3455, 0x33b4,
0x3435, 0x3435, 0x2b73, 0x33d4, 0x2b93, 0x33f5, 0x3c76, 0x2312, 0x2bb4,
0x33d4, 0x2332, 0x33b4, 0x2290, 0x1a90, 0x1ad1, 0x2bb4, 0x3cb7, 0x3cb7,
0x3c96, 0x3476, 0x3cd7, 0x34d6, 0x4558, 0x3d57, 0x3db9, 0x3db9, 0x465a,
0x463a, 0x3e3a, 0x467a, 0x467a, 0x46bb, 0x46da, 0x4e77, 0x4df4, 0x5698,
0x4e57, 0x5db3, 0x4c6c, 0x4c4c, 0x74cc, 0x952e, 0x9d2d, 0xad6d, 0xa52d,
0xa4cc, 0x9c49, 0x93c8, 0xabc8, 0x946c, 0x9346, 0xbb67, 0xbb26, 0xdb27,
0xe306, 0xe348, 0xe306, 0xe306, 0xdae5, 0xcb27, 0x9387, 0xe2c6, 0xe265,
0xe205, 0xd9a4, 0xd9a5, 0xd9a4, 0xd9e6, 0x4e5a, 0x4e7a, 0x3d78, 0x3cf7,
0x2b33, 0x3cb6, 0x4e3a, 0x3d78, 0x45b9, 0x4599, 0x4ebb, 0x4e78, 0x45f5,
0x4678, 0x467a, 0x3db9, 0x4558, 0x467a, 0x35f7, 0x4eb9, 0x4efb, 0x461a,
0x45d9, 0x3d98, 0x34b6, 0x3d17, 0x33f5, 0x3d78, 0x463a, 0x3cd7, 0x3455,
0x3d38, 0x3d98, 0x465a, 0x3db8, 0x463a, 0x3dd9, 0x5eb7, 0x56fa, 0x4e57,
0x7cec, 0x8cec, 0xaceb, 0x950d, 0x5cad, 0x550f, 0x4699, 0x3df9, 0x45f9,
0x45f9, 0x45b9, 0x34d7, 0x3517, 0x3d58, 0x3476, 0x3c76, 0x3456, 0x3415,
0x33f4, 0x33f5, 0x3cf7, 0x45b9, 0x4e3b, 0x3d98, 0x4599, 0x34f7, 0x461a,
0x4619, 0x467a, 0x4efb, 0x46ba, 0x4edb, 0x467a, 0x3e7a, 0x3e39, 0x4edb,
0x571c, 0x3578, 0x4e5a, 0x463a, 0x3df9, 0x4e9b, 0x3dd8, 0x4619, 0x3d98,
0x3db9, 0x3537, 0x3d38, 0x3d38, 0x34f7, 0x3496, 0x3456, 0x33f4, 0x3415,
0x34b6, 0x2b73, 0x3c15, 0x2b53, 0x2bb4, 0x3c76, 0x2332, 0x2b93, 0x33d4,
0x2311, 0x2af1, 0x2290, 0x2353, 0x1ab1, 0x3476, 0x3cb6, 0x3cb7, 0x3476,
0x34f7, 0x3cf7, 0x3d17, 0x3517, 0x3d98, 0x3db8, 0x3df9, 0x4e9b, 0x467a,
0x465a, 0x4ebb, 0x4ebb, 0x4eda, 0x56b8, 0x5697, 0x4eb8, 0x55d3, 0x44ae,
0x54ad, 0x6d0c, 0x852d, 0x94eb, 0x9d0c, 0x9d0b, 0x950d, 0xa4aa, 0x9c28,
0xa3e8, 0xabe8, 0xa409, 0xa387, 0xbb47, 0xcb47, 0xe2e6, 0xf327, 0xe326,
0xdac5, 0xdb06, 0xcb47, 0xbb67, 0xdae6, 0xe265, 0xea45, 0xe205, 0xe206,
0xe205, 0xd9e5, 0xd1a4, 0x4eba, 0x465a, 0x3d98, 0x3d57, 0x2b73, 0x3cd7,
0x3e19, 0x3d98, 0x3dd9, 0x45b9, 0x4eba, 0x45f6, 0x4e36, 0x4e98, 0x467a,
0x4619, 0x3d37, 0x469a, 0x4e35, 0x571a, 0x4699, 0x3db8, 0x3df9, 0x45b9,
0x3d37, 0x3d58, 0x3c36, 0x3d58, 0x4eba, 0x3d17, 0x3c96, 0x3d17, 0x3df9,
0x46db, 0x465a, 0x4619, 0x4e3a, 0x4678, 0x4dd4, 0x4e98, 0x4c8d, 0xa429,
0xac29, 0xac48, 0x850c, 0x4c4c, 0x4d51, 0x4efb, 0x4619, 0x3df9, 0x465a,
0x3dd9, 0x3cd7, 0x3d38, 0x3d58, 0x3d38, 0x3435, 0x3c97, 0x3435, 0x2b93,
0x33d4, 0x3cf7, 0x3d78, 0x3dd9, 0x3d98, 0x45b9, 0x3558, 0x45f9, 0x4619,
0x4ebb, 0x46ba, 0x4efb, 0x4efb, 0x4edb, 0x3e5a, 0x4e7b, 0x4efb, 0x4edb,
0x45b9, 0x469a, 0x463a, 0x4e5a, 0x3e18, 0x3dd8, 0x467a, 0x3517, 0x45fa,
0x3d37, 0x3d38, 0x34f7, 0x3cd7, 0x3cd7, 0x3455, 0x3415, 0x3c56, 0x3c76,
0x33f5, 0x3415, 0x2b52, 0x2bb3, 0x3c76, 0x2b53, 0x3c15, 0x2b32, 0x33b4,
0x1a8f, 0x2ad0, 0x2b73, 0x3394, 0x3c96, 0x3476, 0x3c76, 0x2cf7, 0x3d38,
0x3d78, 0x3d78, 0x3d98, 0x3e19, 0x3df9, 0x467a, 0x3e39, 0x367a, 0x4e9b,
0x467a, 0x56f9, 0x4e77, 0x4698, 0x5656, 0x4d92, 0x5510, 0x5cab, 0x6ccc,
0x850d, 0x7c6a, 0x8d0c, 0x8ccc, 0xa50b, 0x9c48, 0xa3c7, 0xa449, 0xac09,
0xab66, 0xc367, 0xdb06, 0xe306, 0xeae6, 0xdae6, 0xe306, 0xdb47, 0xbb47,
0xb387, 0xe327, 0xe2a6, 0xea66, 0xe225, 0xd9e4, 0xe245, 0xea66, 0xd9c4,
0xe2e7, 0x4e99, 0x35d8, 0x463a, 0x3db8, 0x2332, 0x34d6, 0x4e9b, 0x3db9,
0x45fa, 0x463a, 0x4699, 0x4ccf, 0x4e16, 0x4677, 0x469a, 0x3df9, 0x3d58,
0x4eda, 0x55f4, 0x56b8, 0x4eb9, 0x4619, 0x463a, 0x3dd9, 0x3d38, 0x3cf7,
0x33d4, 0x3d58, 0x4edb, 0x3d58, 0x3cf7, 0x3d58, 0x463a, 0x46ba, 0x4659,
0x467a, 0x3e19, 0x571b, 0x4551, 0x4e97, 0x4c8d, 0xbbc8, 0xabc8, 0xb3c8,
0xac29, 0x6cab, 0x6d0c, 0x5677, 0x4e9b, 0x4e7b, 0x3df9, 0x3df9, 0x4dda,
0x3d38, 0x3d78, 0x3d58, 0x3d58, 0x3c15, 0x3435, 0x3476, 0x2352, 0x33f5,
0x34b6, 0x3d78, 0x3537, 0x3d78, 0x45b9, 0x3d58, 0x461a, 0x4619, 0x4edc,
0x4efb, 0x4f1b, 0x46da, 0x46ba, 0x465a, 0x3e7a, 0x575c, 0x56fb, 0x45f9,
0x4e9b, 0x4e5b, 0x461a, 0x4e5a, 0x4e3a, 0x465a, 0x3d98, 0x45f9, 0x3d58,
0x3d38, 0x3cd7, 0x34d7, 0x3455, 0x3455, 0x3c96, 0x2bd4, 0x2bb3, 0x33d4,
0x33b4, 0x2bb4, 0x3c76, 0x2bb3, 0x2b73, 0x3c36, 0x22f1, 0x1ad1, 0x2290,
0x22f1, 0x2332, 0x3c96, 0x3c96, 0x3456, 0x3496, 0x34f7, 0x4dda, 0x3517,
0x3d78, 0x3db9, 0x45d9, 0x463a, 0x465a, 0x3e39, 0x465a, 0x4efc, 0x4699,
0x4ed9, 0x4ef9, 0x4db3, 0x4d0f, 0x54ce, 0x5c6a, 0x7ced, 0x84ac, 0x84ab,
0x8d0d, 0x8d0d, 0x94cc, 0x9c49, 0xabc7, 0xa3a8, 0xbb87, 0xb388, 0xcb06,
0xe346, 0xe2e5, 0xe347, 0xe306, 0xdae6, 0xb326, 0xb3a9, 0xab68, 0xe2a6,
0xe265, 0xe245, 0xea66, 0xd286, 0xeaa6, 0xd2c7, 0xeb07, 0xc2c5, 0x4e78,
0x3dd8, 0x469b, 0x45b9, 0x2b94, 0x3517, 0x4ebb, 0x3db9, 0x4619, 0x461a,
0x4637, 0x4c8d, 0x4e16, 0x4df4, 0x4eba, 0x4e7b, 0x3d98, 0x4e98, 0x4df4,
0x5677, 0x56d9, 0x4619, 0x465a, 0x461a, 0x3d58, 0x3cb7, 0x3415, 0x45d9,
0x4edb, 0x3d78, 0x34d6, 0x3d78, 0x4edb, 0x4e98, 0x46b9, 0x3e18, 0x3e59,
0x4e77, 0x4c8d, 0x5636, 0x6d0d, 0xb346, 0xbae5, 0xd347, 0xbb87, 0x950d,
0x4c0a, 0x55f3, 0x46ba, 0x463a, 0x4e9b, 0x467a, 0x463a, 0x3d38, 0x3d38,
0x4dda, 0x3d58, 0x3d17, 0x2353, 0x3435, 0x44f7, 0x2b53, 0x3415, 0x34b6,
0x45d9, 0x461a, 0x3d98, 0x45b9, 0x34f7, 0x3dd9, 0x463a, 0x4e9b, 0x46ba,
0x571b, 0x4efb, 0x46bb, 0x467a, 0x4ebb, 0x573b, 0x4eba, 0x3df9, 0x56dc,
0x4619, 0x463a, 0x4639, 0x4e9b, 0x35b8, 0x3db9, 0x3db8, 0x4558, 0x3d17,
0x3cd7, 0x3496, 0x3476, 0x3c56, 0x3cb7, 0x3cb6, 0x33f5, 0x33b4, 0x2bb4,
0x3c15, 0x3476, 0x2332, 0x3415, 0x2b33, 0x2b73, 0x22d1, 0x22b0, 0x2b52,
0x3476, 0x3c96, 0x3cb7, 0x3476, 0x3d17, 0x3d58, 0x3d37, 0x3db9, 0x4e3a,
0x465a, 0x3e19, 0x465a, 0x3df8, 0x465a, 0x4efb, 0x571a, 0x4eb9, 0x5635,
0x55d3, 0x4cad, 0x5ced, 0x74ec, 0x6cac, 0x7ced, 0x7ccc, 0x6c8b, 0x8d0d,
0xa489, 0xac08, 0xa3c7, 0xaba8, 0xc387, 0xc2e5, 0xe306, 0xe306, 0xeb67,
0xcaa5, 0xcb06, 0xbb67, 0xa387, 0xd307, 0xe2c6, 0xe265, 0xda05, 0xea86,
0xe2a6, 0xeae6, 0xda45, 0xd327, 0xd307, 0xe267, 0x4e57, 0x4e7a, 0x465a,
0x3d78, 0x3415, 0x3d98, 0x4edb, 0x45f9, 0x3df9, 0x465a, 0x4df5, 0x4c4a,
0x4db4, 0x4d72, 0x46ba, 0x4edb, 0x3d78, 0x5657, 0x4d72, 0x4dd3, 0x4eda,
0x3e19, 0x4ebb, 0x3df9, 0x3558, 0x3c56, 0x3c96, 0x465a, 0x4699, 0x3d37,
0x3d98, 0x4e5a, 0x4699, 0x5636, 0x4677, 0x469a, 0x56bb, 0x4cf0, 0x54ad,
0x4d30, 0x9ccb, 0xcb67, 0xdac5, 0xe326, 0xcb67, 0x9d0b, 0x7cac, 0x4cce,
0x4eb9, 0x469b, 0x4e7a, 0x4ebb, 0x3e5a, 0x3dd9, 0x3d38, 0x3d78, 0x3d98,
0x3d38, 0x3d17, 0x3c76, 0x3cb6, 0x3cd7, 0x22f1, 0x3456, 0x3d37, 0x3d98,
0x45f9, 0x3557, 0x3d98, 0x3d98, 0x461a, 0x465a, 0x4edb, 0x3e39, 0x4f3b,
0x4efb, 0x469a, 0x467a, 0x46ba, 0x4f1b, 0x573c, 0x3db8, 0x465a, 0x3dd9,
0x3e19, 0x3db8, 0x4619, 0x3d98, 0x45f9, 0x3d58, 0x4558, 0x3d17, 0x3cf7,
0x3496, 0x3c96, 0x3496, 0x3455, 0x2bb4, 0x2b73, 0x33f5, 0x33d4, 0x3415,
0x3415, 0x2b93, 0x33b4, 0x2b33, 0x22d0, 0x2290, 0x22b0, 0x3455, 0x3c96,
0x3c96, 0x3476, 0x3d38, 0x3d99, 0x3d58, 0x45b9, 0x461a, 0x461a, 0x3e19,
0x465a, 0x461a, 0x3e19, 0x4eda, 0x4eda, 0x5698, 0x45d4, 0x550f, 0x54ac,
0x64cc, 0x64ac, 0x74cc, 0x4c2a, 0x74cc, 0x5c6b, 0xad0b, 0xa428, 0xac49,
0xa3e8, 0xbb67, 0xc306, 0xdae6, 0xcaa5, 0xe306, 0xd327, 0xe368, 0xb306,
0xabc8, 0xcac5, 0xe2a5, 0xe285, 0xea45, 0xda85, 0xe2a6, 0xd328, 0xda65,
0xbb27, 0xd307, 0xda25, 0xd1e4, 0x4dd4, 0x467a, 0x463a, 0x45b9, 0x3c76,
0x45f9, 0x4659, 0x3df9, 0x3dd8, 0x3e19, 0x4573, 0x4c4a, 0x5572, 0x6656,
0x469a, 0x467a, 0x3d78, 0x4d72, 0x55d4, 0x5636, 0x4699, 0x4ebb, 0x4efb,
0x3df9, 0x4599, 0x2bf4, 0x3cf7, 0x3e38, 0x3e79, 0x3d17, 0x4619, 0x4eba,
0x4658, 0x5592, 0x56b9, 0x4679, 0x45f4, 0x74ac, 0x4cad, 0x6cac, 0xb367,
0xea85, 0xe2e6, 0xeb06, 0xcb67, 0x9d0d, 0xa50b, 0x54ab, 0x4e77, 0x469a,
0x56dc, 0x4f1b, 0x4edb, 0x465a, 0x3cf7, 0x45d9, 0x45d9, 0x4e1a, 0x45d9,
0x3415, 0x3455, 0x3d18, 0x3435, 0x1ad1, 0x3476, 0x45b9, 0x45f9, 0x3df9,
0x3d58, 0x45fa, 0x3d98, 0x45f9, 0x469a, 0x4efc, 0x3e79, 0x46db, 0x4efb,
0x469a, 0x35f8, 0x467a, 0x4edb, 0x4679, 0x3db8, 0x3dd9, 0x4619, 0x3e59,
0x4639, 0x463a, 0x3db9, 0x45d9, 0x3d78, 0x3cd7, 0x3d38, 0x3496, 0x3496,
0x3496, 0x3cb7, 0x3496, 0x3c56, 0x3415, 0x3394, 0x33f5, 0x3455, 0x2332,
0x33f5, 0x3c15, 0x2b93, 0x1a6f, 0x2b73, 0x3496, 0x3476, 0x3cb7, 0x3496,
0x3d58, 0x3d78, 0x4599, 0x3db9, 0x45f9, 0x35b8, 0x3e19, 0x3df9, 0x3e19,
0x4edb, 0x573c, 0x4ed9, 0x5697, 0x55b2, 0x5ccd, 0x548b, 0x548b, 0x648b,
0x4c6d, 0x5cab, 0x5c8b, 0x9cec, 0xa4cb, 0xb46a, 0xa3a7, 0xab47, 0xcb47,
0xe306, 0xe2e5, 0xd327, 0xcb47, 0xbb47, 0xab66, 0xab87, 0xdac6, 0xe2e6,
0xe285, 0xea86, 0xe285, 0xcaa6, 0xe2e6, 0xe2c6, 0xc367, 0xdaa6, 0xe245,
0xe225, 0xe225, 0x4d72, 0x463a, 0x45f9, 0x3d98, 0x3cd7, 0x4e3a, 0x4639,
0x463a, 0x3db8, 0x45f6, 0x44af, 0x546c, 0x5552, 0x4cef, 0x4eba, 0x46ba,
0x3dd9, 0x4cef, 0x5593, 0x4dd4, 0x4699, 0x4eda, 0x469a, 0x45d9, 0x3d17,
0x3455, 0x3d99, 0x4e37, 0x4edb, 0x3d78, 0x4ebb, 0x4e77, 0x444c, 0x4db3,
0x4678, 0x4678, 0x64cb, 0x9c69, 0x4c8c, 0xbc4a, 0xeae6, 0xe266, 0xeb06,
0xe306, 0xabc7, 0xa4cb, 0x9caa, 0x6cec, 0x4d92, 0x46ba, 0x465a, 0x469a,
0x46ba, 0x46bb, 0x4599, 0x3d78, 0x45fa, 0x463a, 0x45d9, 0x3d38, 0x3c56,
0x3cd7, 0x3d17, 0x2b73, 0x2b94, 0x3cf7, 0x45fa, 0x4619, 0x3e19, 0x3d58,
0x4599, 0x3db9, 0x465a, 0x465a, 0x46bb, 0x4edb, 0x46ba, 0x46ba, 0x46bb,
0x3e7a, 0x4f1a, 0x4659, 0x4619, 0x4edb, 0x465a, 0x4619, 0x3df9, 0x3df9,
0x3dd9, 0x45d9, 0x3d57, 0x3d17, 0x3d17, 0x3c96, 0x3cb6, 0x3496, 0x3cd7,
0x3455, 0x2b94, 0x3415, 0x33d4, 0x2bd4, 0x3435, 0x2332, 0x33f5, 0x3415,
0x2b73, 0x1a8f, 0x2b32, 0x3476, 0x3c96, 0x3476, 0x3cd7, 0x3d58, 0x3d58,
0x3d78, 0x3557, 0x3db9, 0x463a, 0x45f9, 0x3df9, 0x467a, 0x4efb, 0x46ba,
0x4e36, 0x5677, 0x54cd, 0x4c8d, 0x4c4b, 0x6d2e, 0x4c6d, 0x4c8c, 0x4c8d,
0x7ced, 0x8ccc, 0xa46a, 0x9be8, 0xc347, 0xcb27, 0xd2e6, 0xd327, 0xe326,
0xbb06, 0xb387, 0xaba8, 0xb387, 0xcac5, 0xe2c6, 0xea86, 0xe265, 0xe2a6,
0xe2e6, 0xd326, 0xe2e6, 0x8b66, 0xe2c6, 0xe286, 0xe245, 0xea66, 0xe246,
0x4dd4, 0x45f9, 0x463a, 0x3d38, 0x34f7, 0x569b, 0x4e7b, 0x4e9b, 0x3e19,
0x4510, 0x448e, 0x5c8b, 0x4cae, 0x4cf0, 0x4698, 0x3df8, 0x5699, 0x548c,
0x5592, 0x4d0f, 0x4679, 0x4678, 0x469a, 0x45f9, 0x3496, 0x3d18, 0x467a,
0x4db2, 0x3dd9, 0x3e39, 0x4e77, 0x44af, 0x5ccb, 0x4530, 0x4679, 0x4c6c,
0x9469, 0x6cab, 0xb429, 0xe326, 0xea66, 0xe265, 0xe2e6, 0xcb26, 0xa4ca,
0xbb67, 0xc409, 0x9cec, 0x5571, 0x46fa, 0x46ba, 0x4efa, 0x4efb, 0x4edb,
0x45f9, 0x3d78, 0x4619, 0x463a, 0x463a, 0x3578, 0x3c76, 0x3476, 0x3d18,
0x3cf7, 0x2b53, 0x3c36, 0x3d17, 0x463a, 0x463a, 0x4e5a, 0x45f9, 0x3db8,
0x3dd8, 0x465a, 0x46bb, 0x469a, 0x4eda, 0x46ba, 0x469a, 0x469a, 0x4edb,
0x575b, 0x4efb, 0x3df9, 0x3e59, 0x3dd8, 0x4edb, 0x3e19, 0x2d57, 0x3d98,
0x45b9, 0x45d9, 0x3d18, 0x3cd7, 0x3cd7, 0x3cb7, 0x3496, 0x3455, 0x2bb3,
0x3435, 0x3415, 0x33d4, 0x3c56, 0x2b93, 0x2bd4, 0x2b93, 0x3373, 0x1a6f,
0x2332, 0x3476, 0x3476, 0x3476, 0x3d18, 0x2cd6, 0x4558, 0x4578, 0x3d98,
0x45b9, 0x3db9, 0x45fa, 0x461a, 0x4edb, 0x467a, 0x3e57, 0x4e76, 0x4572,
0x4c4b, 0x548d, 0x5cec, 0x548c, 0x4cce, 0x446d, 0x74cc, 0x950d, 0x9c8a,
0xa429, 0xab26, 0xd327, 0xe2c5, 0xcac5, 0xc2e6, 0xaba9, 0xa429, 0x8cac,
0xcb48, 0xe2e6, 0xe2c5, 0xdaa5, 0xe2a6, 0xe285, 0xe2e6, 0xd347, 0xcb47,
0x9409, 0xe326, 0xd265, 0xe285, 0xe266, 0xda25, 0xe1e5, 0x4dd5, 0x3df8,
0x465a, 0x3cf7, 0x3db8, 0x4e7a, 0x4e9a, 0x4eba, 0x4e9a, 0x446e, 0x644a,
0x6c8a, 0x448d, 0x44ae, 0x4636, 0x3e19, 0x4d94, 0x64cb, 0x3c0b, 0x45b5,
0x4e77, 0x3e78, 0x463a, 0x461a, 0x3476, 0x3dd9, 0x5698, 0x5677, 0x3db8,
0x5efa, 0x5551, 0x5409, 0x546b, 0x4e36, 0x4ccf, 0xa469, 0xa48a, 0xa50d,
0xeb47, 0xe205, 0xea25, 0xf2a6, 0xd367, 0xa3a7, 0xcb87, 0xca64, 0xb366,
0xb54c, 0x4eb9, 0x571b, 0x56d9, 0x4eb8, 0x4ed9, 0x4eda, 0x465a, 0x4599,
0x3e19, 0x463a, 0x467a, 0x3e5a, 0x3d37, 0x3c97, 0x3d38, 0x3d78, 0x3c35,
0x2333, 0x3c96, 0x3d78, 0x3e59, 0x4e7a, 0x3db8, 0x463a, 0x45d9, 0x4e5a,
0x4e9b, 0x46db, 0x4edb, 0x4f1b, 0x4efb, 0x46bb, 0x4619, 0x46da, 0x4659,
0x3e19, 0x463a, 0x4e7b, 0x467a, 0x4619, 0x4619, 0x3d78, 0x461a, 0x45d9,
0x34f7, 0x3cd7, 0x34d6, 0x4538, 0x34b6, 0x3476, 0x3414, 0x33f5, 0x3415,
0x33f5, 0x33f4, 0x3c76, 0x2353, 0x2b53, 0x2312, 0x228f, 0x3436, 0x3cd7,
0x3c96, 0x3476, 0x3cd7, 0x3cf7, 0x34d7, 0x3d17, 0x3d78, 0x4dfa, 0x4e1a,
0x3598, 0x465a, 0x3e59, 0x56fa, 0x56d8, 0x4e77, 0x4cce, 0x54ad, 0x548c,
0x4cef, 0x4cef, 0x4d31, 0x5c6b, 0x542c, 0x94ed, 0xac6a, 0xb387, 0xdb06,
0xe327, 0xdb26, 0xb326, 0xab47, 0xa449, 0x9c29, 0xd327, 0xe306, 0xe2e6,
0xc266, 0xe307, 0xe2a6, 0xe327, 0xaae6, 0x93c8, 0xb387, 0xc2e6, 0xdb27,
0xe2c6, 0xeaa6, 0xe246, 0xd986, 0xc969, 0x4d93, 0x45d8, 0x463a, 0x3cb6,
0x465a, 0x4e78, 0x4639, 0x4e9a, 0x4636, 0x74eb, 0x8c89, 0x8ccb, 0x546b,
0x4cad, 0x4572, 0x4619, 0x440a, 0x544b, 0x442a, 0x4e58, 0x5656, 0x46ba,
0x3db8, 0x3d37, 0x4579, 0x4e7a, 0x5cce, 0x465a, 0x56db, 0x448d, 0x8cec,
0x74ad, 0x4d2f, 0x4d73, 0xa408, 0xbb47, 0xad0b, 0xcae6, 0xd9a4, 0xe1e5,
0xea66, 0xc326, 0xc367, 0xf327, 0xea86, 0xeae6, 0xbbc8, 0x5592, 0x4e97,
0x4699, 0x4e57, 0x5eb8, 0x4e97, 0x4698, 0x467a, 0x4dfa, 0x467a, 0x46bb,
0x46ba, 0x467a, 0x45f9, 0x3435, 0x34d7, 0x45b9, 0x3d38, 0x2bb4, 0x2332,
0x3cf7, 0x4639, 0x465a, 0x4619, 0x3d98, 0x463a, 0x3db8, 0x46bb, 0x46ba,
0x4edb, 0x3e7a, 0x4eba, 0x467a, 0x4efb, 0x46ba, 0x4f1b, 0x4f1b, 0x3dd9,
0x3dd8, 0x4619, 0x3e19, 0x4e7b, 0x45d9, 0x3db9, 0x45b9, 0x3d38, 0x3cb7,
0x3d58, 0x3d38, 0x3d17, 0x3cd7, 0x3435, 0x33f4, 0x33f4, 0x3415, 0x3435,
0x3455, 0x2b94, 0x2b73, 0x22f2, 0x226f, 0x4578, 0x3496, 0x3c96, 0x3455,
0x3cb6, 0x3cd7, 0x3d17, 0x4579, 0x3d78, 0x4598, 0x3d98, 0x461a, 0x4e7b,
0x4edb, 0x56d9, 0x4699, 0x55d3, 0x44cf, 0x54ef, 0x4c6c, 0x5571, 0x55d4,
0x54ad, 0x6ccc, 0x7c8b, 0xa408, 0xab26, 0xdb47, 0xdb06, 0xd347, 0xbb87,
0x9c29, 0x846a, 0xa3a8, 0xd327, 0xe306, 0xdb07, 0xdac6, 0xe2e6, 0xeb07,
0xbb07, 0xa3c8, 0x4c2b, 0x9c08, 0x8be9, 0xcb47, 0xdae6, 0xe2e7, 0xe206,
0xd167, 0xc149, 0xa92a, 0x3caf, 0x4679, 0x3e18, 0x3d18, 0x467a, 0x4dd5,
0x3df8, 0x4e36, 0x4531, 0x7c8b, 0xa428, 0x9c49, 0x4c0a, 0x4d52, 0x44ce,
0x3e59, 0x74ac, 0x4c29, 0x4d30, 0x45b4, 0x5698, 0x465a, 0x45f9, 0x3cd7,
0x463a, 0x4d10, 0x4593, 0x469a, 0x548c, 0x84ec, 0x7c8b, 0x4cae, 0x4d10,
0xabc8, 0xcb27, 0xa3e8, 0xea86, 0xe1a6, 0xe1e5, 0xea86, 0xd326, 0xeb26,
0xe244, 0xd9a4, 0xe2a5, 0xb388, 0x55d4, 0x5e97, 0x56fa, 0x4d71, 0x54ee,
0x4d50, 0x4e14, 0x4eb8, 0x463a, 0x3dd8, 0x3e7a, 0x46bb, 0x571b, 0x4efb,
0x467a, 0x3496, 0x2c15, 0x3d78, 0x45b9, 0x3476, 0x33b4, 0x3c96, 0x4599,
0x46bb, 0x4edb, 0x4619, 0x45f9, 0x3d57, 0x469b, 0x4659, 0x4efb, 0x3e39,
0x4eda, 0x4eda, 0x46ba, 0x465a, 0x46da, 0x3df8, 0x3dd8, 0x46db, 0x45d9,
0x4edb, 0x467a, 0x4619, 0x3db8, 0x4599, 0x3d57, 0x3cf7, 0x3d58, 0x4558,
0x3517, 0x3cf7, 0x3476, 0x33d4, 0x3c56, 0x3435, 0x3455, 0x3475, 0x2bb4,
0x2b53, 0x22f2, 0x1a70, 0x3d58, 0x3476, 0x3c76, 0x3455, 0x3cb7, 0x3d18,
0x4559, 0x4558, 0x3d58, 0x45d9, 0x4599, 0x45d9, 0x4639, 0x4ed9, 0x4edb,
0x56d8, 0x4dd4, 0x4cad, 0x4cce, 0x4d71, 0x4e15, 0x4d30, 0x5cad, 0x648b,
0x9ccb, 0xb3a7, 0xb347, 0xd347, 0xbb67, 0xabc7, 0x74cd, 0x848b, 0xc326,
0xdb06, 0xe2e6, 0xdae6, 0xdae6, 0xe2e6, 0xb327, 0xa3c8, 0x64ac, 0x3c6d,
0x6c6b, 0x8ba7, 0xcb47, 0xeae6, 0xd9c4, 0xe185, 0xd168, 0xc9ab, 0xc1ab,
0xb96c, 0x4cf0, 0x3e17, 0x4ebb, 0x34f7, 0x4679, 0x4d94, 0x4658, 0x45b4,
0x444c, 0x8c6a, 0xa3e9, 0x9408, 0x84cc, 0x5571, 0x5616, 0x4d71, 0x7c8b,
0x4c4a, 0x4df6, 0x4d92, 0x4637, 0x3df9, 0x45b9, 0x4599, 0x4df4, 0x64ab,
0x4e7a, 0x5510, 0x7d0d, 0xac8b, 0x74cb, 0x54ef, 0x944a, 0xcb67, 0xb326,
0xe1c4, 0xd986, 0xe1e5, 0xf306, 0xf2e7, 0xda24, 0xd9c6, 0xe1c5, 0xd2c6,
0x9d6f, 0x4e98, 0x4d30, 0x55d3, 0x5592, 0x5c8b, 0x548b, 0x54ac, 0x5571,
0x56f9, 0x461a, 0x469a, 0x46da, 0x46ba, 0x4eda, 0x573b, 0x4edb, 0x4599,
0x3c97, 0x3d98, 0x3df9, 0x45b9, 0x33d4, 0x2b93, 0x3d38, 0x463a, 0x46da,
0x3e19, 0x45f9, 0x463a, 0x3dd8, 0x469a, 0x4edb, 0x469a, 0x571b, 0x46da,
0x469a, 0x3e59, 0x46da, 0x467a, 0x4639, 0x3df9, 0x4619, 0x469a, 0x465a,
0x4619, 0x3db9, 0x3578, 0x45b9, 0x34b6, 0x3d58, 0x3517, 0x3d38, 0x4538,
0x3476, 0x3415, 0x3415, 0x3455, 0x3435, 0x3c96, 0x2b94, 0x33d4, 0x1ad1,
0x2312, 0x3d58, 0x3455, 0x3cb7, 0x3455, 0x3c96, 0x3cf7, 0x3d18, 0x3d38,
0x3d58, 0x3d78, 0x3d98, 0x4619, 0x4edb, 0x4efb, 0x4699, 0x450f, 0x5530,
0x4d92, 0x5635, 0x4e77, 0x4db3, 0x54ad, 0x4c8d, 0xacaa, 0x9c8c, 0xcb47,
0xbb06, 0xa387, 0x8cac, 0x546b, 0x9c2a, 0xd2e6, 0xdb06, 0xd306, 0xe326,
0xe367, 0xdb27, 0xa3c8, 0x6cec, 0x3d98, 0x45f9, 0x5657, 0x84cb, 0xc2e6,
0xeaa7, 0xd9c4, 0xd965, 0xc926, 0xc189, 0xc98a, 0xb94a, 0xb96c, 0x4d73,
0x4e38, 0x4e9a, 0x4598, 0x4617, 0x4cf0, 0x4db4, 0x55f4, 0x546b, 0xaba7,
0xc326, 0xbb88, 0x8c8b, 0x4db3, 0x3df7, 0x7cab, 0x6c6a, 0x4c8c, 0x4d31,
0x4e15, 0x4699, 0x3e19, 0x3538, 0x3db7, 0x84cc, 0x4dd4, 0x45d5, 0x7cec,
0xabe9, 0x7c8a, 0x544b, 0xcbc8, 0xe347, 0xcb06, 0xda06, 0xe187, 0xe1c5,
0xe2a6, 0xda25, 0xd146, 0xd9a7, 0xda65, 0xaccd, 0x3e18, 0x4c8d, 0x858f,
0x7cec, 0x850d, 0x7ced, 0xa52c, 0x74cc, 0x54ee, 0x5d70, 0x467a, 0x467a,
0x46da, 0x4efa, 0x4ed9, 0x4f1a, 0x4ef9, 0x4f1b, 0x3d78, 0x3c96, 0x3db9,
0x465a, 0x467a, 0x3cf7, 0x3415, 0x3cb7, 0x4619, 0x46ba, 0x4edb, 0x3d57,
0x465a, 0x4e3a, 0x46da, 0x4edb, 0x4f1b, 0x46ba, 0x46ba, 0x4efb, 0x4efb,
0x469a, 0x571b, 0x575b, 0x3df9, 0x4639, 0x4659, 0x3df9, 0x465a, 0x3db9,
0x3d98, 0x45f9, 0x3476, 0x3d78, 0x4578, 0x3d38, 0x3cf7, 0x3c35, 0x3455,
0x3c76, 0x3476, 0x3455, 0x3c96, 0x3c35, 0x2b73, 0x22b0, 0x33f4, 0x3cd6,
0x3455, 0x3455, 0x3476, 0x3496, 0x3d18, 0x3d17, 0x3d38, 0x4558, 0x3d58,
0x3db9, 0x3e59, 0x4eda, 0x46ba, 0x5697, 0x4510, 0x55b3, 0x5697, 0x571a,
0x5656, 0x4db3, 0x548a, 0x8c6a, 0xbc09, 0xbb26, 0xb387, 0xa50c, 0x4cce,
0x4c6c, 0xab67, 0xe2e6, 0xc326, 0xd306, 0xd2e6, 0xd347, 0xa428, 0x4cae,
0x4e7a, 0x22f0, 0x2b32, 0x4577, 0x646b, 0xd2e6, 0xeaa7, 0xe205, 0xd985,
0xd166, 0xc128, 0xc169, 0xc16a, 0xb98a, 0xc16a, 0x4df6, 0x4e16, 0x4e9a,
0x3d78, 0x4dd5, 0x4d11, 0x4d10, 0x44f0, 0x94cc, 0xb387, 0xd368, 0xbbe8,
0x8cec, 0x4c8d, 0x4e17, 0xac8a, 0x6c6b, 0x4594, 0x3c4d, 0x5615, 0x3e39,
0x3db8, 0x3e39, 0x5c6b, 0x64cc, 0x4e15, 0x746b, 0xbb87, 0xa449, 0x542a,
0xc347, 0xab06, 0xe2c6, 0xc98a, 0xd9a8, 0xf2e7, 0xe225, 0xd9c8, 0xd988,
0xdaa7, 0xa4cd, 0x4659, 0x4d31, 0x64ec, 0x94ec, 0x9c69, 0xa489, 0xa4eb,
0xa3e8, 0xa489, 0x648b, 0x550e, 0x4eba, 0x3e39, 0x573b, 0x4e98, 0x4e36,
0x4e77, 0x56f9, 0x56b8, 0x4efa, 0x3d78, 0x3cb6, 0x3df9, 0x3dd8, 0x46bb,
0x34d6, 0x3c35, 0x3415, 0x3d98, 0x4639, 0x46da, 0x4e5a, 0x3dd9, 0x3df9,
0x469a, 0x46ba, 0x4eda, 0x4edb, 0x4efb, 0x46ba, 0x3e59, 0x469a, 0x4f3a,
0x577c, 0x3df9, 0x3df9, 0x4e5a, 0x3df9, 0x3e19, 0x3db8, 0x45b9, 0x3df9,
0x3517, 0x3d78, 0x3d58, 0x3d17, 0x3cf7, 0x3435, 0x3455, 0x3455, 0x3cb6,
0x3476, 0x3c56, 0x3c15, 0x2bb4, 0x1a6f, 0x3cf7, 0x3496, 0x3476, 0x3476,
0x3cb7, 0x3cb6, 0x3d18, 0x34b6, 0x3d58, 0x3d18, 0x3d58, 0x45f9, 0x56fb,
0x467a, 0x4f1a, 0x45f5, 0x5635, 0x4698, 0x4efa, 0x4e99, 0x4e77, 0x54cd,
0x84cb, 0xa386, 0xa48b, 0x944a, 0x4c6d, 0x4e37, 0x74ac, 0xcb06, 0xd327,
0xdb47, 0xa2e6, 0xcb88, 0x948c, 0x4d74, 0x3557, 0x2b32, 0x2b53, 0x2b53,
0x2b93, 0x4db3, 0xbb06, 0xe245, 0xea66, 0xd9c5, 0xd965, 0xd146, 0xd167,
0xc989, 0xc988, 0xc968, 0xc927, 0x4d94, 0x4df6, 0x4619, 0x463a, 0x5531,
0x4d73, 0x440b, 0x54cf, 0x9bc7, 0xd347, 0xe306, 0x944a, 0x4c6d, 0x4593,
0x7cab, 0x6c4b, 0x6d0c, 0x4c6c, 0x4d10, 0x4e57, 0x467a, 0x3d98, 0x55d4,
0x442c, 0x3e38, 0x8ccb, 0xb387, 0x9be9, 0x644a, 0xcb06, 0xcae6, 0xe1e5,
0xc1ed, 0xd188, 0xeaa6, 0xd965, 0xd9a8, 0xd287, 0x950e, 0x4d72, 0xa54e,
0xbba8, 0xabe8, 0xdb87, 0xc387, 0xab87, 0xcb47, 0xabc8, 0xb4aa, 0x850d,
0x5d91, 0x3e7a, 0x4ebb, 0x5697, 0x55d3, 0x550f, 0x4dd4, 0x5614, 0x5e35,
0x4615, 0x3e99, 0x3d38, 0x34f7, 0x463a, 0x465a, 0x4efb, 0x4eda, 0x4578,
0x3c76, 0x3d17, 0x3dd9, 0x4efb, 0x3e39, 0x45b8, 0x465a, 0x45f9, 0x46ba,
0x4eda, 0x4eda, 0x4edb, 0x46da, 0x469a, 0x4e9b, 0x4efa, 0x4ebb, 0x45f9,
0x3e39, 0x4e3a, 0x45f8, 0x3df9, 0x3db8, 0x45d9, 0x3dd9, 0x3d17, 0x3db8,
0x3d57, 0x3d58, 0x34b6, 0x3c76, 0x3476, 0x3cb7, 0x34b6, 0x3496, 0x2b73,
0x33f5, 0x2312, 0x226f, 0x3d17, 0x3476, 0x3496, 0x3435, 0x3c96, 0x34b6,
0x3cf7, 0x3cf7, 0x3d18, 0x3cf7, 0x3d78, 0x46bb, 0x467a, 0x469a, 0x573a,
0x4e98, 0x4eba, 0x4edb, 0x46ba, 0x4699, 0x5cef, 0x6cac, 0xacaa, 0x9c29,
0x7d0d, 0x4678, 0x4658, 0xa4ab, 0xc347, 0xc346, 0xbb27, 0xabe8, 0x8d0d,
0x5d30, 0x2311, 0x2b32, 0x2b94, 0x2b93, 0x33d4, 0x33f5, 0x4558, 0x8c6a,
0xc2c6, 0xeaa6, 0xe225, 0xd9a4, 0xd164, 0xd165, 0xd145, 0xd146, 0xd124,
0xd966, 0xc945});
}
void loop() {
tft.pushImage(0, 0, 160, 80, img1.data());
delay(3000);
tft.pushImage(0, 0, 160, 80, img2.data());
delay(3000);
tft.pushImage(0, 0, 160, 80, img3.data());
delay(3000);
tft.pushImage(0, 0, 160, 80, img4.data());
delay(3000);
tft.pushImage(0, 0, 160, 80, img5.data());
delay(3000);
}
|
/**
@purpose This is a simplified vi editor.
@file main.cpp
@input A text file and keywords file.
@output a display of the text file that was input*/
#include<iostream>
#include"Editor.h"
using namespace std;
int main(int argc, const char* argv[])
{
int numberOfCmdLineArgs = 0;
// argv[] reads in from the command line.
if (argc < 1)
{
cerr << "argc is less than 1.\n";
exit(1);
}
//if user specifies 2 parameters then read in argv[2]
Editor miniVi(argv[1], argv[2]);
system("CLS"); // clears screen
miniVi.run();
}
|
vector<pair<int,int>> v;
for(int i=0;i<n;i++)
{
v.push_back({arr[i],-1});
v.push_back({dep[i],1});
}
sort(v.begin(),v.end());
int count=0;
int c1=0;int c2=0;
for(int i=0;i<2*n;i++)
{
if(v[i].second==-1)c1++;
else c2++;
count=max(count,c1-c2);
}
return count;
|
/*
* SkyBox.h
*
* Created on: 10 сент. 2017 г.
* Author: Соня
*/
#ifndef SKYBOX_H_
#define SKYBOX_H_
#include "Common.h"
class SkyBox {
public:
SkyBox(String frontImage, String backImage, String leftImage, String rightImage, String topImage, String bottomImage);
virtual ~SkyBox();
};
#endif /* SKYBOX_H_ */
|
#include "..\config.h"
#include "..\inc\decode.h"
DecodeStatus decode(uint32_t code, RV32I &instr, RV32_reg &rd, RV32_reg &rs1, RV32_reg &rs2, uint32_t &imm) {
OpcodeMap opcode = (OpcodeMap)slice(code, 0, 6);
switch (opcode) {
case OpcodeMap::LOAD: {
uint8_t funct3 = slice(code, 12, 14);
rd = slice(code, 7, 11);
rs1 = slice(code, 15, 19);
imm = slice(code, 20, 31);
switch (funct3) {
case 0:
instr = RV32I::LB;
return DECODE_SUCCESS;
case 1:
instr = RV32I::LH;
return DECODE_SUCCESS;
case 2:
instr = RV32I::LW;
return DECODE_SUCCESS;
case 4:
instr = RV32I::LBU;
return DECODE_SUCCESS;
case 5:
instr = RV32I::LHU;
return DECODE_SUCCESS;
default:
return DECODE_LOAD_ERROR;
}
}
case OpcodeMap::MISC_MEM: {
uint8_t funct3 = slice(code, 12, 14);
switch (funct3) {
case 0:
instr = RV32I::FENCE;
imm = slice(code, 20, 27);
return DECODE_SUCCESS;
case 1:
instr = RV32I::FENCE_I;
return DECODE_SUCCESS;
default:
return DECODE_MISC_MEM_ERROR;
}
}
case OpcodeMap::OP_IMM: {
uint8_t funct3 = slice(code, 12, 14);
rd = slice(code, 7, 11);
rs1 = slice(code, 15, 19);
imm = slice(code, 25, 31);
switch (funct3) {
case 0:
instr = RV32I::ADDI;
return DECODE_SUCCESS;
case 2:
instr = RV32I::SLTI;
return DECODE_SUCCESS;
case 3:
instr = RV32I::SLTIU;
return DECODE_SUCCESS;
case 4:
instr = RV32I::XORI;
return DECODE_SUCCESS;
case 6:
instr = RV32I::ORI;
return DECODE_SUCCESS;
case 7:
instr = RV32I::ANDI;
return DECODE_SUCCESS;
default:
return DECODE_OP_IMM_ERROR;
}
}
case OpcodeMap::AUIPC: {
instr = RV32I::AUIPC;
rd = slice(code, 7, 11);
imm = slice(code, 12, 31);
return DECODE_SUCCESS;
}
case OpcodeMap::STORE: {
uint8_t funct3 = slice(code, 12, 14);
rs1 = slice(code, 15, 19);
rs2 = slice(code, 20, 24);
imm = slice(code, 7, 11) + (slice(code, 25, 31) << 5);
switch (funct3) {
case 0:
instr = RV32I::SB;
return DECODE_SUCCESS;
case 1:
instr = RV32I::SH;
return DECODE_SUCCESS;
case 3:
instr = RV32I::SW;
return DECODE_SUCCESS;
default:
return DECODE_STORE_ERROR;
}
}
case OpcodeMap::OP: {
uint8_t funct3 = slice(code, 12, 14);
uint8_t funct7 = slice(code, 25, 31);
rd = slice(code, 7, 11);
rs1 = slice(code, 15, 19);
rs2 = slice(code, 20, 24);
switch (funct7) {
case 0: {
switch (funct3) {
case 0:
instr = RV32I::ADD;
return DECODE_SUCCESS;
case 1:
instr = RV32I::SLL;
return DECODE_SUCCESS;
case 2:
instr = RV32I::SLT;
return DECODE_SUCCESS;
case 3:
instr = RV32I::SLTU;
return DECODE_SUCCESS;
case 4:
instr = RV32I::XOR;
return DECODE_SUCCESS;
case 5:
instr = RV32I::SRL;
return DECODE_SUCCESS;
case 6:
instr = RV32I::OR;
return DECODE_SUCCESS;
case 7:
instr = RV32I::AND;
return DECODE_SUCCESS;
default:
return DECODE_OP_ERROR;
}
}
case 0x20: {
switch (funct3) {
case 0:
instr = RV32I::SUB;
return DECODE_SUCCESS;
case 5:
instr = RV32I::SRA;
return DECODE_SUCCESS;
default:
return DECODE_OP_ERROR;
}
}
default:
return DECODE_OP_ERROR;
}
}
case OpcodeMap::LUI: {
instr = RV32I::AUIPC;
rd = slice(code, 7, 11);
imm = slice(code, 12, 31);
return DECODE_SUCCESS;
}
case OpcodeMap::BRANCH:
uint8_t funct3 = slice(code, 12, 14);
rs1 = slice(code, 15, 19);
rs2 = slice(code, 20, 24);
imm = 0;
switch (funct3) {
case 0:
instr = RV32I::BEQ;
return DECODE_SUCCESS;
case 1:
instr = RV32I::BNE;
return DECODE_SUCCESS;
case 4:
instr = RV32I::BLT;
return DECODE_SUCCESS;
case 5:
instr = RV32I::BGE;
return DECODE_SUCCESS;
case 6:
instr = RV32I::BLTU;
return DECODE_SUCCESS;
case 7:
instr = RV32I::BGEU;
return DECODE_SUCCESS;
default:
return DECODE_BRANCH_ERROR;
}
// ÄÎÏÈÑÀÒÜ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
case OpcodeMap::JALR:
IType(code);
if (funct3) {
throw DecodeError("Decode Error: Incorrect JALR instruction");
}
else {
instr = RV32G::JALR;
}
break;
case OpcodeMap::JAL:
JType(code);
instr = RV32G::JAL;
break;
case OpcodeMap::SYSTEM:
IType(code);
switch (funct3)
{
case 0:
if (rd || rs1) {
throw DecodeError("Decode Error: Incorrect ECALL\EBREAK instruction");
}
else {
instr = (funct7) ? RV32G::EBREAK : RV32G::ECALL;
}
break;
case 1:
instr = RV32G::CSRRW;
break;
case 2:
instr = RV32G::CSRRS;
break;
case 3:
instr = RV32G::CSRRC;
break;
case 5:
instr = RV32G::CSRRWI;
break;
case 6:
instr = RV32G::CSRRSI;
break;
case 7:
instr = RV32G::CSRRCI;
break;
default:
throw DecodeError("Decode Error: Incorrect BRANCH instruction");
break;
}
break;
default:
throw DecodeError("Decode Error: Wrong opcode");
break;
}
}
catch (DecodeError err) {
std::cout << err.msg << std::endl;
}
}
|
#ifndef WORKER_H
#define WORKER_H
#include "employee.h"
#include <qfile.h>
#include <qtextstream.h>
#include <qlist.h>
class Worker : public Employee
{
public:
Worker(QString fio, size_t uniqueNumber,
QString login, QString password, QString department);
~Worker();
QString getTaskName();
void readTasks();
void saveTasks();
void taskDone(const QString& _task);
private:
QList<taskie> tasks;
};
#endif // WORKER_H
|
#ifndef DATASTRUCTURE_TESTLINEARLIST_H
#define DATASTRUCTURE_TESTLINEARLIST_H
#include "linearList.h"
#include "status.h"
#define LEN 100
void testLinearList() {
int temp = 0;
long op = 1;
int cur = 0, next = 0, pre = 0, elem = 0;
int list_index = 0;
int temp_index = 0;
int index;
LinearList<int> lists[LEN];
Compare<int> comp = [](const int &a, const int &b) -> bool { return a == b; };
Visit<int> visit = [](const int &a) { std::cout << a << std::endl; };
while (op != 0) {
cls();
std::cout << "\n\n";
std::cout << " Menu for Linked Table On Chain Structure \n";
std::cout << "-------------------------------------------------\n";
std::cout << " 1. IntiaList 7. LocateElem\n";
std::cout << " 2. DestroyList 8. PriorElem\n";
std::cout << " 3. ClearList 9. NextElem \n";
std::cout << " 4. ListEmpty 10.ListInsert\n";
std::cout << " 5. ListLength 11.ListDelete\n";
std::cout << " 6. GetElem 12.ListTraverse\n";
std::cout << " 13.Change list 14.Save List\n";
std::cout << " 0. Exit\n";
std::cout << "-------------------------------------------------\n";
std::cout << " list using: " << list_index << "\n";
std::cout << " please select your operation[0~14]:";
std::cin >> op;
auto &L = lists[list_index];
switch (op) {
case 1:
std::cout << "InitaList Function\n";
if (L.InitaList() == OK) std::cout << "Initialze successful.\n";
else std::cout << "Initailze failed.\n";
getchar();
getchar();
break;
case 2:
std::cout << "\nDestroyList Function\n";
if (L.DestroyList() == OK) std::cout << "Destroy successfully.\n";
else std::cout << "Destroy failed.\n";
getchar();
getchar();
break;
case 3:
std::cout << "\nClearList Function\n";
if (L.ClearList() == OK) std::cout << "Clear successfully\n";
else std::cout << "CLear failed.\n";
getchar();
getchar();
break;
case 4:
std::cout << "\nListEmpty Function\n";
if (L.ListEmpty()) {
std::cout << "The list is empty.\n";
}
else {
std::cout << "The list is not empty.\n";
}
getchar();
getchar();
break;
case 5:
std::cout << "\nListLength Function\n";
std::cout << "The length of list: " << L.ListLength() << std::endl;
getchar();
getchar();
break;
case 6:
std::cout << "\nGetElem Function\n";
std::cout << "Please enter the index: ";
std::cin >> index;
if (L.GetElem(index, elem) == OK) {
std::cout << "Get the element: " << elem << "\n";
}
else std::cout << "Get element failed.\n";
getchar();
getchar();
break;
case 7:
std::cout << "\nLocateElem Function\n";
std::cout << "Please enter the element: ";
std::cin >> elem;
if (L.LocateElem(elem, index, comp) == OK) {
std::cout << "The index of element:" << index << std::endl;
}
else {
std::cout << "Locate element failed.\n";
}
getchar();
getchar();
break;
case 8:
std::cout << "\nPriorElem Function\n";
std::cout << "Please enter the element: ";
std::cin >> cur;
if (L.PriorElem(cur, pre, comp) == OK) {
std::cout << "Get the result: " << pre << "\n";
}
else {
std::cout << "Get the element failed.\n";
}
getchar();
getchar();
break;
case 9:
std::cout << "\nNextElem Function\n";
std::cout << "PLease enter the element: ";
std::cin >> cur;
if (L.NextElem(cur, next, comp) == OK) {
std::cout << "Get the element: " << next << "\n";
}
else {
std::cout << "Operate failed.\n";
}
getchar();
getchar();
break;
case 10:
std::cout << "\nListInsert Function\n";
std::cout << "Please enter the element: ";
std::cin >> elem;
std::cout << "Please enter the index: ";
scanf_s("%d", &index);
if (L.ListInsert(index, elem) == OK) {
std::cout << "Insert successfully.\n";
}
else {
std::cout << "Insert failed.\n";
}
getchar();
getchar();
break;
case 11:
std::cout << "\nListDelete Function\n";
std::cout << "Please enter the index: ";
std::cin >> index;
if (L.ListDelete(index, elem) == OK) {
std::cout << "Delete " << elem << " successfullyy.\n";
}
else {
std::cout << "Delete failed.\n";
}
getchar();
getchar();
break;
case 12:
std::cout << "\nListTraverse Function\n";
if (L.ListTraverse(visit)) {
std::cout << "Traverse successfully.\n";
}
else {
std::cout << "Traverse failed.\n";
}
getchar();
getchar();
break;
case 13:
std::cout << "Enter the index of list:[0-99] ";
std::cin >> temp_index;
if (temp_index >= LEN || temp_index < 0) {
std::cout << "Change failed\n";
}
else {
list_index = temp_index;
std::cout << "Change successfully\n";
}
getchar();
getchar();
break;
case 14:
if (L.ListSave() == OK) {
std::cout << "Save to file successfully\n";
}
else {
std::cout << "Save to file failed.\n";
}
getchar();
getchar();
break;
case 0:
break;
default:
break;
}//end of switch
}//end of while
std::cout << "Good bye.\n";
}
#endif //DATASTRUCTURE_TESTLINEARLIST_H
|
#include <iostream>
#include<Windows.h>
using namespace std;
//Prototipos
void cambioresiduos(int a[], int izq,int der,int b);
unsigned bits (int a, int k, int j);
void llenarArray(int a[], int n);
void mostrarArray(int a[],int n);
double PCFreq = 0.0;
__int64 CounterStart = 0;
void StartCounter()
{
LARGE_INTEGER li;
if(!QueryPerformanceFrequency(&li))
cout << "QueryPerformanceFrequency failed!\n";
PCFreq = double(li.QuadPart)/1000.0;
QueryPerformanceCounter(&li);
CounterStart = li.QuadPart;
}
double GetCounter()
{
LARGE_INTEGER li;
QueryPerformanceCounter(&li);
return double(li.QuadPart-CounterStart)/(PCFreq/1000);
}
unsigned bits (int a,int k, int j){
return (a>>k)&~(~0<<j);
}
void cambioresiduos(int a[], int izq, int der, int b){
int i,j,temp=0;
if (der>izq && b>0){
i= izq; j=der;
while(j!=i){
while(!bits(a[i],b,1) && i<j)i++;
while(bits(a[j],b,1) && j>i)j--;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
if (!bits(a[i],b,1)) j++;
cambioresiduos(a, izq, j-1, b-1);
cambioresiduos(a, j, der, b-1);
}
}
int main(int argc, char *argv[]) {
int n;
cout<<"Digite N: ";
cin>>n;
int a[n];
llenarArray(a,n);
mostrarArray(a,n);
StartCounter();
cambioresiduos(a,0,n-1,5);
cout<<GetCounter();
cout<<" ms"<<endl;
mostrarArray(a,n);
}
void llenarArray(int a[],int n){
int i;
for(i=n-1;i>=0;i--){
a[i]=n-i;
}
}
void mostrarArray(int a[],int n){
int i;
for(i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<"\n";
}
|
// OnHScrollPageRight.h
#ifndef _ONHSCROLLPAGERIGHT_H
#define _ONHSCROLLPAGERIGHT_H
#include "HorizontalScroll.h"
#include "ScrollAction.h"
class OnHScrollPageRight : public ScrollAction {
public:
OnHScrollPageRight(HorizontalScroll *horizontalScroll);
OnHScrollPageRight(const OnHScrollPageRight& source);
virtual ~OnHScrollPageRight();
OnHScrollPageRight& operator=(const OnHScrollPageRight& source);
virtual void Action(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
private:
HorizontalScroll *horizontalScroll;
};
#endif //_ONHSCROLLPAGERIGHT_H
|
#include <bits/stdc++.h>
using namespace std;
int getPairsCount(int arr[],int n, int sum){
unordered_map<int , int> m;
for(int i=0; i<n; i++)
m[arr[i]]++;
int twice_count=0;
for(int j=0 ; j<n; j++){
twice_count += m[sum-arr[j]];
if(sum-arr[j] == arr[j])
twice_count--;
}
return twice_count/2;
}
int main() {
int arr[40];
int n;
cin>>n;
for(int i=0; i<n; i++)
cin>>arr[i];
int sum;
cin>>sum;
int result = getPairsCount(arr,n,sum);
cout<<"Result : "<<result;
return 0;
}
|
class ConferenceReference: public Reference{
public:
ConferenceReference(string _lastName, string _firstName,string _title, string _edPlace, string _editor,int _year):
Reference(_lastName,_firstName,_title, _edPlace,_editor,_year){
}
void print(){
Reference::print();
cout<<" "<<title<<". En: "<<editor<<", "<<editionPlace<<endl;
}
};
|
int sum(const int size, const int iarr[]) {
int sum;
for (int i = 0; i < size; ++i) {
sum += iarr[i];
}
return sum;
}
|
#ifndef MAZE_GENERATOR_H
#define MAZE_GENERATOR_H
#include "Room.h"
#include "Door.h"
#include "Wall.h"
#include "Maze.h"
class MazeGenerator {
public:
Maze* CreateMazeStupidly();
};
#endif
|
#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;
// 利用感兴趣区域ROI实现图像叠加
bool LinearBlending() {
// [0]定义一些局部变量
double alphaValue = 0.5;
double betaValue;
Mat srcImage2, srcImage3, dstImage;
// [1]读取图像(两幅图片需为同样的类型和尺寸)
srcImage2 = imread("cat2.jpg");
srcImage3 = imread("baboon2.jpg");
if (!srcImage2.data) {
printf("读取srcImage2错误~! \n");
return false;
}
if (!srcImage3.data) {
printf("读取srcImage3错误~! \n");
return false;
}
// [2]做图像混合加权操作
betaValue = (1.0 - alphaValue);
addWeighted(srcImage2, alphaValue, srcImage3, betaValue, 0.0, dstImage);
// [3]创建并显示原图窗口
namedWindow("<2>线性混合示例窗口[原图]", 1);
imshow("<2>线性混合窗口[原图]", srcImage2);
namedWindow("<3>线性混合示例窗口[效果图]", 1);
imshow("<3>线性混合示例窗口[效果图]", dstImage);
return true;
}
int main(int argc, char** argv) {
bool result = LinearBlending();
waitKey(0);
return 0;
}
|
#pragma once
#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"
#include <Windows.h>
#include <string.h>
#include <iostream>
using namespace cv;
using namespace std;
class ex11
{
public:
// 테스트 코드
static void Run();
// 파일을 읽는 다이얼로그 호출
static string OpenFileDialog();
// 영상을 읽는 다이얼로그 호출
static Mat OpenImageDialog();
static bool CheckMatch(Mat img, Point start, Mat mask, int mode = 0);
// 침식
static void Erosion(Mat img, Mat& dst, Mat mask);
// 팽창
static void Dilation(Mat img, Mat& dst, Mat mask);
// 열림
static void Opening(Mat img, Mat& dst, Mat mask);
// 닫힘
static void Closing(Mat img, Mat& dst, Mat mask);
// 과제
static uchar CheckMatch2(Mat img, Point start, Mat mask, int mode = 0);
static void ErosionGray(Mat img, Mat& dst, Mat mask);
static void DilationGray(Mat img, Mat& dst, Mat mask);
};
void ex11::Dilation(Mat img, Mat& dst, Mat mask)
{
dst = Mat(img.size(), CV_8U, Scalar(0));
if (mask.empty())
mask = Mat(3, 3, CV_8UC1, Scalar(0));
Point maskHalf = mask.size() / 2;
for (int i = maskHalf.y; i < img.rows - maskHalf.y; i++) {
for (int j = maskHalf.x; j < img.cols - maskHalf.x; j++) {
Point start = Point(j, i) - maskHalf;
bool check = CheckMatch(img, start, mask, 1);
dst.at<uchar>(i, j) = (check) ? 0 : 255;
}
}
}
void ex11::Opening(Mat img, Mat& dst, Mat mask)
{
Mat dst1;
ErosionGray(img, dst1, mask);
DilationGray(dst1, dst, mask);
}
void ex11::Closing(Mat img, Mat& dst, Mat mask)
{
Mat dst1;
DilationGray(img, dst1, mask);
ErosionGray(dst1, dst, mask);
}
Mat ex11::OpenImageDialog()
{
auto fileName = OpenFileDialog();
Mat image = imread(fileName, IMREAD_GRAYSCALE);
if (image.empty()) {
cout << "파일 읽기 실패" << endl;
exit(1);
}
return image;
}
string ex11::OpenFileDialog()
{
char name[MAX_PATH] = { 0, };
OPENFILENAMEA ofn;
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(OPENFILENAMEA);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = "모든파일(*.*)\0*.*\0";
ofn.lpstrFile = name;
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
ofn.lpstrDefExt = "";
string strName;
if (GetOpenFileNameA(&ofn)) {
strName = name;
}
return strName;
}
bool ex11::CheckMatch(Mat img, Point start, Mat mask, int mode)
{
for (int u = 0; u < mask.rows; u++)
{
for (int v = 0; v < mask.cols; v++)
{
Point pt(v, u);
int m = mask.at<uchar>(pt);
int p = img.at<uchar>(start + pt);
bool ch = (p == 255);
if ((m == 1) && (ch == mode))
return false;
// 배열로 retrun 하고 최대 최소로 바꿔주면 됨
}
}
return true;
}
|
#include "Meteor.h"
const ofVec2f & Meteor::GetPosition() const { return m_position; }
const bool &Meteor::Collided() const { return m_collided; }
Meteor::Meteor() {
m_position = ofVec2f((rand() % 2) * ofGetWidth(), rand() % ofGetHeight());
float tmp = (1000 + rand() % 5000) / 100.0f;
m_radius = 5 + rand() % 20;
m_mass = m_radius * 1.5f;
m_momentum = ofVec2f(ofGetWidth() / 2.0f - m_position.x ,
((rand() % 2) * 2 - 1) * ofGetHeight() / 2.0f + ofGetHeight() / 2.0f).normalized() * tmp;
m_collided = false;
}
void Meteor::Update(const std::vector<Planet> &planets, const float &deltatime) {
ofVec2f forces = ofVec2f(0, 0);
// Percorre a lista de planetas e adiona as forcas de atracao se o meteoro estiver na area de atracao
for (int i = 0; i < 3; i++) {
float distance = m_position.distance(planets[i].GetPosition());
if (distance <= planets[i].GetRadiusAtraction()) {
m_collided = m_collided || distance <= planets[i].GetSize();
// Calcula a forca de atracao
float atraction = (m_mass * planets[i].GetMass() * 250.0f) / pow(m_position.distance(planets[i].GetPosition()), 2);
// Gera a direcao para onde deve ser a plicado a gravidade
ofVec2f direction = planets[i].GetPosition() - m_position;
// Soma das forcas
forces += direction.normalized() * atraction;
}
}
ofVec2f acceleration = forces / m_mass;
m_position += (m_momentum + acceleration / 2.0f) * deltatime;
m_momentum += acceleration * deltatime;
}
void Meteor::Draw() {
ofDrawCircle(m_position, m_radius);
}
bool Meteor::OnScreen() {
return ((m_position.x > -10 && m_position.x < ofGetWidth() + 10) &&
(m_position.y > -10 && m_position.y < ofGetHeight() + 10));
}
|
#include "GraphNode.h"
GraphNode::GraphNode()
{
costToGetHere = 0 ;
}
GraphNode::~GraphNode()
{
// !! DO NOT DELETE THE EDGES.
// They are simply mirrored copies
// of the edges in the global list.
// the main game object will take care
// of the global list.
}
// priority.
bool GraphNode::operator<( const GraphNode& other )
{
return costToGetHere < other.costToGetHere ;
}
// This is used when backtracing
// the lowest cost path from the
// endPos to the startPos.
GraphNode* GraphNode::getLowestCostAdjacentNodeInSet( SetGraphNode list )
{
if( edges.empty() )
puts( "ERROR!! getLowestCostAdjacent node has an empty list" ) ;
float lowestCostSoFar = FLOAT_POSITIVE_INFINITY ;
GraphNode* lowestCostNeighbour = (*edges.begin())->dst ;
for( vector<Edge*>::iterator edgeIter = edges.begin() ;
edgeIter != edges.end() ;
++edgeIter )
{
Edge* edge = *edgeIter ;
// I am src, so other is dst.
GraphNode *n = edge->dst ;
// only valid if n is in the closedList
if( list.find( n ) != list.end() &&
n->costToGetHere < lowestCostSoFar )
{
lowestCostSoFar = edge->dst->costToGetHere;
lowestCostNeighbour = edge->dst ;
}
}
return lowestCostNeighbour ;
}
|
#include <iostream>
#include <cstring>
using namespace std;
int main() {
char a[100],b[100];
cout << "输入两个字符串：" << endl;
cin >> a >> b;
auto result=strcmp(a,b);
switch(result){
case 1:
cout << "a>b";
break;
case 0:
cout << "a=b";
break;
case -1:
cout << "a<b";
break;
}
return 0;
}
|
#ifndef EX3_2_PSET_H
#define EX3_2_PSET_H
#include <fstream>
#include <iostream>
#include <string>
#include <set>
#include "persistence_traits.h"
using namespace std;
template<typename T, typename P=persistence_traits<T>>
class pset : public set<T> {
string f;
void read() {
ifstream ifs(f);
for(;;) {
T el;
P::read(ifs, el);
if (!ifs.good()) break;
set<T>::insert(el);
}
}
void write() {
ofstream ofs(f);
for (const T& t : *this) {
P::write(ofs, t);
}
}
public:
pset(string file) : f(file) {
read();
}
~pset() {
write();
}
};
#endif //EX3_2_PSET_H
|
#include<iostream>
using namespace std;
int main()
{
int a=2;
int b=2;
b=a+b/a+ b*a;
cout<<b<<endl;
}
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/filters/pipeline_integration_test_base.h"
#include "base/bind.h"
#include "media/base/decoder_buffer.h"
#include "media/base/decryptor_client.h"
#include "media/base/test_data_util.h"
#include "media/crypto/aes_decryptor.h"
#include "media/filters/chunk_demuxer_client.h"
namespace media {
static const char kSourceId[] = "SourceId";
static const char kClearKeySystem[] = "org.w3.clearkey";
static const uint8 kInitData[] = { 0x69, 0x6e, 0x69, 0x74 };
// Key used to encrypt video track in test file "bear-320x240-encrypted.webm".
static const uint8 kSecretKey[] = {
0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
};
// Helper class that emulates calls made on the ChunkDemuxer by the
// Media Source API.
class MockMediaSource : public ChunkDemuxerClient {
public:
MockMediaSource(const std::string& filename, int initial_append_size,
bool has_audio, bool has_video)
: url_(GetTestDataURL(filename)),
current_position_(0),
initial_append_size_(initial_append_size),
has_audio_(has_audio),
has_video_(has_video) {
file_data_ = ReadTestDataFile(filename);
DCHECK_GT(initial_append_size_, 0);
DCHECK_LE(initial_append_size_, file_data_->GetDataSize());
}
virtual ~MockMediaSource() {}
void set_decryptor_client(DecryptorClient* decryptor_client) {
decryptor_client_ = decryptor_client;
}
void Seek(int new_position, int seek_append_size) {
chunk_demuxer_->StartWaitingForSeek();
chunk_demuxer_->Abort(kSourceId);
DCHECK_GE(new_position, 0);
DCHECK_LT(new_position, file_data_->GetDataSize());
current_position_ = new_position;
AppendData(seek_append_size);
}
void AppendData(int size) {
DCHECK(chunk_demuxer_.get());
DCHECK_LT(current_position_, file_data_->GetDataSize());
DCHECK_LE(current_position_ + size, file_data_->GetDataSize());
CHECK(chunk_demuxer_->AppendData(
kSourceId, file_data_->GetData() + current_position_, size));
current_position_ += size;
}
void EndOfStream() {
chunk_demuxer_->EndOfStream(PIPELINE_OK);
}
void Abort() {
if (!chunk_demuxer_.get())
return;
chunk_demuxer_->Shutdown();
}
// ChunkDemuxerClient methods.
virtual void DemuxerOpened(ChunkDemuxer* demuxer) {
chunk_demuxer_ = demuxer;
std::vector<std::string> codecs;
if (has_audio_)
codecs.push_back("vorbis");
if (has_video_)
codecs.push_back("vp8");
chunk_demuxer_->AddId(kSourceId, "video/webm", codecs);
AppendData(initial_append_size_);
}
virtual void DemuxerClosed() {
chunk_demuxer_ = NULL;
}
virtual void DemuxerNeedKey(scoped_array<uint8> init_data,
int init_data_size) {
DCHECK(init_data.get());
DCHECK_GT(init_data_size, 0);
DCHECK(decryptor_client_);
decryptor_client_->NeedKey("", "", init_data.Pass(), init_data_size);
}
private:
std::string url_;
scoped_refptr<DecoderBuffer> file_data_;
int current_position_;
int initial_append_size_;
bool has_audio_;
bool has_video_;
scoped_refptr<ChunkDemuxer> chunk_demuxer_;
DecryptorClient* decryptor_client_;
};
class FakeDecryptorClient : public DecryptorClient {
public:
FakeDecryptorClient() : decryptor_(this) {}
AesDecryptor* decryptor() {
return &decryptor_;
}
// DecryptorClient implementation.
virtual void KeyAdded(const std::string& key_system,
const std::string& session_id) {
EXPECT_EQ(kClearKeySystem, key_system);
EXPECT_FALSE(session_id.empty());
}
virtual void KeyError(const std::string& key_system,
const std::string& session_id,
AesDecryptor::KeyError error_code,
int system_code) {
NOTIMPLEMENTED();
}
virtual void KeyMessage(const std::string& key_system,
const std::string& session_id,
scoped_array<uint8> message,
int message_length,
const std::string& default_url) {
EXPECT_EQ(kClearKeySystem, key_system);
EXPECT_FALSE(session_id.empty());
EXPECT_TRUE(message.get());
EXPECT_GT(message_length, 0);
current_key_system_ = key_system;
current_session_id_ = session_id;
}
virtual void NeedKey(const std::string& key_system,
const std::string& session_id,
scoped_array<uint8> init_data,
int init_data_length) {
current_key_system_ = key_system;
current_session_id_ = session_id;
// When NeedKey is called from the demuxer, the |key_system| will be empty.
// In this case, we need to call GenerateKeyRequest() to initialize a
// session (which will call KeyMessage).
if (current_key_system_.empty()) {
DCHECK(current_session_id_.empty());
decryptor_.GenerateKeyRequest(kClearKeySystem,
kInitData, arraysize(kInitData));
}
EXPECT_FALSE(current_key_system_.empty());
EXPECT_FALSE(current_session_id_.empty());
decryptor_.AddKey(current_key_system_, kSecretKey, arraysize(kSecretKey),
init_data.get(), init_data_length, current_session_id_);
}
private:
AesDecryptor decryptor_;
std::string current_key_system_;
std::string current_session_id_;
};
class PipelineIntegrationTest
: public testing::Test,
public PipelineIntegrationTestBase {
public:
void StartPipelineWithMediaSource(MockMediaSource* source) {
pipeline_->Start(
CreateFilterCollection(source),
base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
QuitOnStatusCB(PIPELINE_OK));
ASSERT_TRUE(decoder_.get());
message_loop_.Run();
}
void StartPipelineWithEncryptedMedia(
MockMediaSource* source,
FakeDecryptorClient* encrypted_media) {
pipeline_->Start(
CreateFilterCollection(source),
base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
QuitOnStatusCB(PIPELINE_OK));
ASSERT_TRUE(decoder_.get());
decoder_->set_decryptor(encrypted_media->decryptor());
source->set_decryptor_client(encrypted_media);
message_loop_.Run();
}
// Verifies that seeking works properly for ChunkDemuxer when the
// seek happens while there is a pending read on the ChunkDemuxer
// and no data is available.
bool TestSeekDuringRead(const std::string& filename,
int initial_append_size,
base::TimeDelta start_seek_time,
base::TimeDelta seek_time,
int seek_file_position,
int seek_append_size,
bool has_audio,
bool has_video) {
MockMediaSource source(filename, initial_append_size, has_audio, has_video);
StartPipelineWithMediaSource(&source);
if (pipeline_status_ != PIPELINE_OK)
return false;
Play();
if (!WaitUntilCurrentTimeIsAfter(start_seek_time))
return false;
source.Seek(seek_file_position, seek_append_size);
if (!Seek(seek_time))
return false;
source.EndOfStream();
source.Abort();
Stop();
return true;
}
};
TEST_F(PipelineIntegrationTest, BasicPlayback) {
ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
Play();
ASSERT_TRUE(WaitUntilOnEnded());
}
TEST_F(PipelineIntegrationTest, BasicPlaybackHashed) {
ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK, true));
Play();
ASSERT_TRUE(WaitUntilOnEnded());
EXPECT_EQ(GetVideoHash(), "f0be120a90a811506777c99a2cdf7cc1");
EXPECT_EQ(GetAudioHash(), "6138555be3389e6aba4c8e6f70195d50");
}
TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource) {
MockMediaSource source("bear-320x240.webm", 219229, true, true);
StartPipelineWithMediaSource(&source);
source.EndOfStream();
ASSERT_EQ(pipeline_status_, PIPELINE_OK);
EXPECT_EQ(pipeline_->GetBufferedTimeRanges().size(), 1u);
EXPECT_EQ(pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds(), 0);
EXPECT_EQ(pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds(), 2737);
Play();
ASSERT_TRUE(WaitUntilOnEnded());
source.Abort();
Stop();
}
TEST_F(PipelineIntegrationTest, BasicPlayback_16x9AspectRatio) {
ASSERT_TRUE(Start(GetTestDataURL("bear-320x240-16x9-aspect.webm"),
PIPELINE_OK));
Play();
ASSERT_TRUE(WaitUntilOnEnded());
}
TEST_F(PipelineIntegrationTest, EncryptedPlayback) {
MockMediaSource source("bear-320x240-encrypted.webm", 220788, true, true);
FakeDecryptorClient encrypted_media;
StartPipelineWithEncryptedMedia(&source, &encrypted_media);
source.EndOfStream();
ASSERT_EQ(PIPELINE_OK, pipeline_status_);
Play();
ASSERT_TRUE(WaitUntilOnEnded());
source.Abort();
Stop();
}
// TODO(acolwell): Fix flakiness http://crbug.com/117921
TEST_F(PipelineIntegrationTest, DISABLED_SeekWhilePaused) {
ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
base::TimeDelta duration(pipeline_->GetMediaDuration());
base::TimeDelta start_seek_time(duration / 4);
base::TimeDelta seek_time(duration * 3 / 4);
Play();
ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
Pause();
ASSERT_TRUE(Seek(seek_time));
EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
Play();
ASSERT_TRUE(WaitUntilOnEnded());
// Make sure seeking after reaching the end works as expected.
Pause();
ASSERT_TRUE(Seek(seek_time));
EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
Play();
ASSERT_TRUE(WaitUntilOnEnded());
}
// TODO(acolwell): Fix flakiness http://crbug.com/117921
TEST_F(PipelineIntegrationTest, DISABLED_SeekWhilePlaying) {
ASSERT_TRUE(Start(GetTestDataURL("bear-320x240.webm"), PIPELINE_OK));
base::TimeDelta duration(pipeline_->GetMediaDuration());
base::TimeDelta start_seek_time(duration / 4);
base::TimeDelta seek_time(duration * 3 / 4);
Play();
ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(start_seek_time));
ASSERT_TRUE(Seek(seek_time));
EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
ASSERT_TRUE(WaitUntilOnEnded());
// Make sure seeking after reaching the end works as expected.
ASSERT_TRUE(Seek(seek_time));
EXPECT_GE(pipeline_->GetMediaTime(), seek_time);
ASSERT_TRUE(WaitUntilOnEnded());
}
// Verify audio decoder & renderer can handle aborted demuxer reads.
TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", 8192,
base::TimeDelta::FromMilliseconds(464),
base::TimeDelta::FromMilliseconds(617),
0x10CA, 19730, true, false));
}
// Verify video decoder & renderer can handle aborted demuxer reads.
TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", 32768,
base::TimeDelta::FromMilliseconds(200),
base::TimeDelta::FromMilliseconds(1668),
0x1C896, 65536, false, true));
}
} // namespace media
|
#include <omp.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <Windows.h>
#include <cstdint>
#include "immintrin.h"
#include "assert.h"
#define SIZE 1024
int main() {
int THR = 4;
int i, j, k;
uint64_t start, end;
double time_s, time_f;
omp_set_dynamic(0);
omp_set_num_threads(THR);
register double(*__restrict A)[SIZE] = (double(*)[SIZE])malloc(SIZE * SIZE * sizeof(double));
register double(*__restrict B)[SIZE] = (double(*)[SIZE])malloc(SIZE * SIZE * sizeof(double));
register double(*__restrict C)[SIZE] = (double(*)[SIZE])malloc(SIZE * SIZE * sizeof(double));
register double(*__restrict C2)[SIZE] = (double(*)[SIZE])malloc(SIZE * SIZE * sizeof(double));
register double(*__restrict C3)[SIZE] = (double(*)[SIZE])malloc(SIZE * SIZE * sizeof(double));
srand((unsigned int)time(NULL));
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
A[i][j] = rand() % 5;
B[i][j] = rand() % 5;
}
}
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
C[i][j] = 0;
}
}
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
C3[i][j] = 0;
}
}
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
C2[i][j] = 0;
}
}
// start = GetTickCount64();
//
// double sum;
//
//#pragma omp parallel for
// for (k = 0; k < SIZE; k++) {
// for (j = 0; j < SIZE; j++) {
// for (i = 0; i < SIZE; i++) {
// C[j][i] += A[k][i] * B[j][k];
// }
// }
// }
//
// end = GetTickCount64();
// printf("time not vect %f\n", (float)(end - start));
//
//time_s = omp_get_wtime();
//start = GetTickCount64();
//#pragma omp parallel for
// for (int i = 0; i < SIZE; i++) {
// double *temp = C[i];
// for (int j = 0; j < SIZE; j++) {
// int temp1 = A[i][j];
// double *temp2 = B[j];
// for (int k = 0; k < SIZE; k++) {
// temp[k] += temp1 * temp2[k];
// }
// }
// }
time_s = omp_get_wtime();
//#pragma omp parallel for
for (i = 0; i < SIZE; i++) {
for (j = 0; j < SIZE; j++) {
for (k = 0; k < SIZE; k++) {
C[j][i] += A[j][k] * B[k][i];
}
}
}
time_f = omp_get_wtime();
printf("Calculation time : %f \n",
(time_f - time_s));
time_s = omp_get_wtime();
#pragma omp parallel for
for (i = 0; i < SIZE; i++) {
for (j = 0; j < SIZE; j++) {
for (k = 0; k < SIZE; k++) {
C2[j][i] += A[j][k] * B[k][i];
}
}
}
time_f = omp_get_wtime();
printf("Calculation time omp: %f \n",
(time_f - time_s));
//end = GetTickCount64();
//printf("time vect %f\n", (float)(end - start));
const int BlockSize = 256;
const int GridSize = int(SIZE / double(BlockSize));
const int BlockSizeMedium = 64;
const int GridSizeMedium = int(BlockSize / double(BlockSizeMedium));
const int BlockSizeSmall = 32;
const int GridSizeSmall = int(BlockSizeMedium / double(BlockSizeSmall));
//
// time_s = omp_get_wtime();
//#pragma omp parallel for
//for (int n = 0; n < GridSize; n++)
// for (int m = 0; m < GridSize; m++)
// for (int iter = 0; iter < GridSize; iter++)
// for (int i = n * BlockSize; i < (n + 1)*BlockSize; i++)
// for (int j = m * BlockSize; j < (m + 1)*BlockSize; j++)
// for (int k = iter * BlockSize; k < (iter + 1)*BlockSize; k++) {
// C3[j][i] += A[j][k] * B[k][i];
// }
//
// time_f = omp_get_wtime();
// printf("Calculation time K3+omp: %f \n",
// (time_f - time_s));
//
// time_s = omp_get_wtime();
//
//#pragma omp parallel for
//for (int n = 0; n < GridSize; n++) {
// for (int m = 0; m < GridSize; m++) {
// for (int nM = 0; nM < GridSizeMedium; nM++)
// {
// for (int mM = 0; mM < GridSizeMedium; mM++) {
// for (int iterM = 0; iterM < GridSize*GridSizeMedium; iterM++) {
// for (int i = n * BlockSize + nM * BlockSizeMedium; i < n * BlockSize + (nM + 1)*BlockSizeMedium; i++)
// {
// for (int j = m * BlockSize + mM * BlockSizeMedium; j < m * BlockSize + (mM + 1)*BlockSizeMedium; j++)
// {
// for (int k = iterM * BlockSizeMedium; k < (iterM + 1)*BlockSizeMedium; k++)
// {
// C3[j][i] += A[j][k] * B[k][i];
// }
// }
// }
// }
// }
// }
// }
//}
// time_f = omp_get_wtime();
// printf("Calculation time K3+K2+omp: %f \n",
// (time_f - time_s));
//
time_s = omp_get_wtime();
#pragma omp parallel for
for (int n = 0; n < GridSize; n++) {
for (int m = 0; m < GridSize; m++) {
for (int nM = 0; nM < GridSizeMedium; nM++){
for (int mM = 0; mM < GridSizeMedium; mM++) {
for (int nS = 0; nS < GridSizeSmall; nS++)
for (int mS = 0; mS < GridSizeSmall; mS++) {
for (int iterS = 0; iterS <GridSize*GridSizeMedium*GridSizeSmall; iterS++) {
for (int i = n * BlockSize + nM * BlockSizeMedium + nS * BlockSizeSmall;
i < n * BlockSize + (nS+1) * BlockSizeSmall + nM*BlockSizeMedium; i++)
{
for (int j = m * BlockSize + mM * BlockSizeMedium+ mS * BlockSizeSmall;
j < m * BlockSize + (mS + 1) * BlockSizeSmall + mM * BlockSizeMedium; j++)
{
for (int k = iterS* BlockSizeSmall; k < (iterS + 1)*BlockSizeSmall; k++)
{
C3[j][i] += A[j][k] * B[k][i];
}
}
}
}
}
}
}
}
}
time_f = omp_get_wtime();
printf("Calculation time K3+K2+K1+omp: %f \n",
(time_f - time_s));
int k1 = 0, k2 = 0;
//for (int i = 0; i < SIZE; i++) {
// for (int j = 0; j < SIZE; j++) {
// printf("%5.3f ", C[i][j]);
// }
// printf("\n");
//}
//printf("\n");
//
//for (int i = 0; i < SIZE; i++) {
// for (int j = 0; j < SIZE; j++) {
// printf("%5.3f ", C3[i][j]);
// }
// printf("\n");
//}
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
if (C[i][j] != C2[i][j]) {
k1 = 1;
}
}
}
for (int i = 0; i < SIZE; i++) {
for (int j = 0; j < SIZE; j++) {
if (C[i][j] != C3[i][j]) {
k2 = 1;
}
}
}
if (k1 == 1) {
printf("not omp!=omp \n");
}
if (k2 == 1) {
printf("not omp!=K1+K2+K3+omp\n");
}
/*end = GetTickCount64();
printf("time k opm %f\n", (float)(end - start));*/
free(A);
free(B);
free(C);
free(C2);
free(C3);
system("pause");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s[3];
int a, b;
cin >> s[0];
cin >> s[1];
cin >> s[2];
for(int i=0; i<3; i++) {
for(int j=0; j<10; j++) {
if(s[i][j] == '=') {
a = i;
b = j;
i = j = 10;
}
}
}
b++;
for(int i=b; i<10; i++) {
if(s[a][i] != '.') {
printf("%c\n", s[a][i]);
return 0;
}
}
puts("You shall pass!!!");
}
|
// Source file for the Task class
#include "stdafx.h"
#include "Task.h"
#include <iostream>
#include <string>
using namespace std;
Task::Task(string str, tm myTime, bool complete) : t(str), time(myTime), isComp(complete) {
};
// Displays the name of the task, followed by a properly formed date and time (assembled below)
void Task::display()
{
int yr = time.tm_year + 1900;
int mo = time.tm_mon + 1;
if (time.tm_hour < 10 && time.tm_min < 10)
{
cout << t << " " << mo << "/" << time.tm_mday << "/" << yr;
cout << " " << 0 << time.tm_hour << ":" << 0 << time.tm_min;
}
else if (time.tm_hour < 10 && time.tm_min >= 10)
{
cout << t << " " << mo << "/" << time.tm_mday << "/" << yr;
cout << " " << 0 << time.tm_hour << ":" << time.tm_min;
}
else if (time.tm_hour >= 10 && time.tm_min < 10)
{
cout << t << " " << mo << "/" << time.tm_mday << "/" << yr;
cout << " " << time.tm_hour << ":" << 0 << time.tm_min;
}
else
{
cout << t << " " << mo << "/" << time.tm_mday << "/" << yr;
cout << " " << time.tm_hour << ":" << time.tm_min;
}
if (isComp == true)
{
cout << " COMPLETE" << endl;
}
else
{
cout << " TODO" << endl;
}
}
void Task::setComplete()
{
isComp = true;
}
|
#pragma once
#pragma once
#ifndef STRING
#include <string>
#endif
#ifndef IOSTREAM
#include <iostream>
#endif
using namespace std;
bool isAnagram(const string str1, const string str2);
namespace Anagram
{
void run();
}
|
#include "cargador_recursos.h"
|
/***********************************************************************
created: Tue Feb 17 2009
author: Paul D Turner
*************************************************************************/
/***************************************************************************
* Copyright (C) 2004 - 2011 Paul D Turner & The CEGUI Development Team
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#include "CEGUI/RendererModules/Ogre/Renderer.h"
#ifndef CEGUI_USE_OGRE_TEXTURE_GPU
#include "CEGUI/RendererModules/Ogre/TextureTarget.h"
#include "CEGUI/RendererModules/Ogre/Texture.h"
#include "CEGUI/PropertyHelper.h"
#include <OgreTextureManager.h>
#include <OgreHardwarePixelBuffer.h>
#include <OgreRenderTexture.h>
#include <OgreRenderSystem.h>
#include <OgreViewport.h>
// Start of CEGUI namespace section
namespace CEGUI
{
//----------------------------------------------------------------------------//
const float OgreTextureTarget::DEFAULT_SIZE = 128.0f;
std::uint32_t OgreTextureTarget::s_textureNumber = 0;
//----------------------------------------------------------------------------//
OgreTextureTarget::OgreTextureTarget(OgreRenderer& owner,
Ogre::RenderSystem& rs,
bool addStencilBuffer) :
OgreRenderTarget(owner, rs),
TextureTarget(addStencilBuffer),
d_CEGUITexture(0)
{
d_CEGUITexture = static_cast<OgreTexture*>(
&d_owner.createTexture(generateTextureName()));
// setup area and cause the initial texture to be generated.
declareRenderSize(Sizef(DEFAULT_SIZE, DEFAULT_SIZE));
}
//----------------------------------------------------------------------------//
OgreTextureTarget::~OgreTextureTarget()
{
d_owner.destroyTexture(*d_CEGUITexture);
}
//----------------------------------------------------------------------------//
bool OgreTextureTarget::isImageryCache() const
{
return true;
}
//----------------------------------------------------------------------------//
void OgreTextureTarget::clear()
{
if (!d_viewportValid)
updateViewport();
Ogre::Viewport* const saved_vp = d_renderSystem._getViewport();
d_renderSystem._setViewport(d_viewport);
d_renderSystem.clearFrameBuffer(Ogre::FBT_COLOUR,
Ogre::ColourValue(0, 0, 0, 0));
#if OGRE_VERSION < 0x10800
if (saved_vp)
d_renderSystem._setViewport(saved_vp);
#else
d_renderSystem._setViewport(saved_vp);
#endif
}
//----------------------------------------------------------------------------//
Texture& OgreTextureTarget::getTexture() const
{
return *d_CEGUITexture;
}
//----------------------------------------------------------------------------//
void OgreTextureTarget::declareRenderSize(const Sizef& sz)
{
// exit if current size is enough
if ((d_area.getWidth() >= sz.d_width) && (d_area.getHeight() >=sz.d_height))
return;
Ogre::TexturePtr rttTex = Ogre::TextureManager::getSingleton().createManual(OgreTexture::getUniqueName(),
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,
static_cast<Ogre::uint>(sz.d_width),
static_cast<Ogre::uint>(sz.d_height),
1,
0,
Ogre::PF_A8R8G8B8,
Ogre::TU_RENDERTARGET);
d_renderTarget = rttTex->getBuffer()->getRenderTarget();
const Rectf init_area(
glm::vec2(0.0f, 0.0f),
Sizef(
static_cast<float>(d_renderTarget->getWidth()),
static_cast<float>(d_renderTarget->getHeight())
)
);
setArea(init_area);
// delete viewport and reset ptr so a new one is generated. This is
// required because we have changed d_renderTarget so need a new VP also.
OGRE_DELETE d_viewport;
d_viewport = 0;
// because Texture takes ownership, the act of setting the new ogre texture
// also ensures any previous ogre texture is released.
d_CEGUITexture->setOgreTexture(rttTex, true);
clear();
}
//----------------------------------------------------------------------------//
String OgreTextureTarget::generateTextureName()
{
String tmp("_ogre_tt_tex_");
tmp.append(PropertyHelper<std::uint32_t>::toString(s_textureNumber++));
return tmp;
}
//----------------------------------------------------------------------------//
} // End of CEGUI namespace section
#ifdef __APPLE__
template class CEGUI::OgreRenderTarget<CEGUI::RenderTarget>;
template class CEGUI::OgreRenderTarget<CEGUI::TextureTarget>;
#endif
#endif // CEGUI_USE_OGRE_TEXTURE_GPU
|
#include "Animation.h"
#include"Effects.h"
Animation::Animation(int x, int y, int width, int height, int count, const Surface & s,float ht, Color chroma)
:
sprite(s),
holdTime(ht),
chroma(chroma)
{
for (int i = 0; i < count; i++)
{
frames.emplace_back(RectI(x + width*i, y, width, height));
}
}
void Animation::Update(float dt)
{
curFrameTime += dt;
while (curFrameTime >= holdTime)
{
Advance();
curFrameTime -= holdTime;
}
}
void Animation::Draw(const Location & l, Graphics & gfx)
{
//negative effect
gfx.DrawSprite(l.x, l.y, frames[iCurFrame], sprite, [this](Color cSrc,int xDest,int yDest,Graphics& gfx) {
if (cSrc != chroma)
{
gfx.PutPixel(xDest,yDest,
{255u-cSrc.GetR(),255u - cSrc.GetG(), 255u - cSrc.GetB()}
);
}
});
}
void Animation::Draw(const Location & l, Graphics & gfx, RectI & clip)
{
SpriteEffects::Chroma e = { chroma };
gfx.DrawSprite(l.x, l.y, frames[iCurFrame], clip, sprite, e);
}
void Animation::Advance()
{
iCurFrame++;
if (iCurFrame >= frames.size())
{
iCurFrame = 0;
}
}
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkExtractExodusGlobalTemporalVariables.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkExtractExodusGlobalTemporalVariables
* @brief extract global temporal arrays generated by vtkExodusIIReader
*
* vtkExtractExodusGlobalTemporalVariables is intended to extract global
* temporal arrays generated by vtkExodusIIReader.
*
* Global temporal variables are special arrays that have values per timestep.
* vtkExodusIIReader can read these values for all timestep and provide them
* easily, thus avoiding the need to read all timesteps to extract these values
* over timesteps. A slight complication is with ParaView, where ParaView
* supports what are referred to as restarts i.e. instead of a single file
* having all timesteps, the timesteps are arbitrarily split among multiple
* files. For such cases, this filter needs to iterate over all the files to
* accumulate the data. Since there's no information about files or ability to
* request the upstream reader to read a particular file, this filter request
* specific timesteps using some smarts to determine which timestep to request
* and not simply loop over all timesteps.
*
* @sa vtkExodusIIReader, vtkExodusIIReader::GLOBAL_TEMPORAL_VARIABLE.
*/
#ifndef vtkExtractExodusGlobalTemporalVariables_h
#define vtkExtractExodusGlobalTemporalVariables_h
#include "vtkFiltersExtractionModule.h" // For export macro
#include "vtkTableAlgorithm.h"
#include <memory> // for std::unique_ptr
class VTKFILTERSEXTRACTION_EXPORT vtkExtractExodusGlobalTemporalVariables : public vtkTableAlgorithm
{
public:
static vtkExtractExodusGlobalTemporalVariables* New();
vtkTypeMacro(vtkExtractExodusGlobalTemporalVariables, vtkTableAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent) override;
protected:
vtkExtractExodusGlobalTemporalVariables();
~vtkExtractExodusGlobalTemporalVariables() override;
int FillInputPortInformation(int port, vtkInformation* info) override;
int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector) override;
int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector) override;
int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector) override;
//@{
/**
* These methods are used by vtkPExtractExodusGlobalTemporalVariables to
* synchronize internal state between ranks.
*/
void GetContinuationState(bool& continue_executing_flag, size_t& offset) const;
void SetContinuationState(bool continue_executing_flag, size_t offset);
//@}
private:
vtkExtractExodusGlobalTemporalVariables(const vtkExtractExodusGlobalTemporalVariables&) = delete;
void operator=(const vtkExtractExodusGlobalTemporalVariables&) = delete;
class vtkInternals;
std::unique_ptr<vtkInternals> Internals;
};
#endif
|
// Copyright (c) 2015 University of Szeged.
// Copyright (c) 2015 The Chromium Authors.
// All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/public/app/content_main.h"
#include "sprocket/app/main_delegate.h"
int main(int argc, const char** argv) {
// The embedder can also pass in NULL for |delegate| if they don't want to
// override default startup.
SprocketMainDelegate delegate;
content::ContentMainParams params(&delegate);
params.argc = argc;
params.argv = argv;
// ContentMain should be called from the embedder's main() function to do the
// initial setup for every process.
return content::ContentMain(params);
}
|
#ifndef GYROSCOPE_H_
#define GYROSCOPE_H_
extern "C" {
#include <stdint.h>
}
#include "RegisterDevice.h"
#include "I2CController.h"
#define GYRO_ADDR_BASE 0b1101000
#define GYRO_REG_WHO_AM_I 0x0F
#define GYRO_REG_CTRL_REG1 0x20
#define GYRO_REG_CTRL_REG2 0x21
#define GYRO_REG_CTRL_REG3 0x22
#define GYRO_REG_CTRL_REG4 0x23
#define GYRO_REG_CTRL_REG5 0x24
#define GYRO_REG_REFERENCE 0x25
#define GYRO_REG_OUT_TEMP 0x26
#define GYRO_REG_STATUS_REG 0x27
#define GYRO_REG_OUT_X_L 0x28
#define GYRO_REG_OUT_X_H 0x29
#define GYRO_REG_OUT_Y_L 0x2A
#define GYRO_REG_OUT_Y_H 0x2B
#define GYRO_REG_OUT_Z_L 0x2C
#define GYRO_REG_OUT_Z_H 0x2D
#define GYRO_REG_FIFO_CTRL_REG 0x2E
#define GYRO_REG_FIFO_SRC_REG 0x2F
#define GYRO_REG_INT1_CFG 0x30
#define GYRO_REG_INT1_SRC 0x31
#define GYRO_REG_INT1_TSH_XH 0x32
#define GYRO_REG_INT1_TSH_XL 0x33
#define GYRO_REG_INT1_TSH_YH 0x34
#define GYRO_REG_INT1_TSH_YL 0x35
#define GYRO_REG_INT1_TSH_ZH 0x36
#define GYRO_REG_INT1_TSH_ZL 0x37
#define GYRO_REG_INT1_DURATION 0x38
class Gyroscope: public RegisterDevice {
public:
Gyroscope(I2CController* i2c, bool sdo);
inline void queueReadData() {
queueRead(GYRO_REG_OUT_X_L | 0x80, 6);
// queueRead(GYRO_REG_OUT_Z_L | 0x80, 2);
}
};
#endif /* GYROSCOPE_H_ */
|
#pragma once
#include "value.h"
class cBaseShader;
class cGeomNode
{
public:
LPDIRECT3DVERTEXBUFFER9 m_pVB;
int m_nNumTri;
bool m_IsRender;
ST_MTL_TEX* m_pTexMtl;
std::vector<cGeomNode*> m_vecChildren;
std::vector<ST_POS_TRACK> m_vecPosTrack;
std::vector<ST_ROT_TRACK> m_vecRotTrack;
D3DXMATRIXA16 m_matWorldTM;
D3DXMATRIXA16 m_matLocalTM;
public:
void Update( int nKey, D3DXMATRIXA16* pmatParent);
void Render( cBaseShader* pShader );
void DrawGeom();
void Release();
void AddChild( cGeomNode* pGeomNode );
void CalcLocalTM( D3DXMATRIXA16* pmatParentTM );
void AnimLocalPos( int nKey, D3DXMATRIXA16& mT );
void AnimLocalRot( int nKey, D3DXMATRIXA16& mR );
void AnimLerp( int nKey, D3DXVECTOR3& v );
void AnimSLerp( int nKey, D3DXQUATERNION& q );
public:
cGeomNode(void);
~cGeomNode(void);
};
|
#pragma once
#include "Lexer.h"
namespace filtering
{
class syntaxer
{
public:
private:
// E
// E ::= T T2
// T2::= +T | -T | .
// T ::= F F2
// F2 ::= *F | /F | .
// F ::= ( E ) | s | n
// a+b+c
// E => TX => FYX => aYX => aX => a+TX =>
// => a+bX
void R(); /** R := W \n W */
void R2();
void W(); /** W ::= Q && Q */
void W2();
void Q(); /** Q ::= E < E */
void Q2();
void E(); /** E ::= T + T */
void E2();
void T(); /** T ::= F * F */
void T2();
void F(); /** number, variable, (R), -W or !W */
public:
lexeme top();
void pop();
unsigned size() const;
void out(const lexeme &lex);
template<class I> syntaxer(I begin, I end)
{
process(begin, end);
}
template<class I> void process(I begin, I end)
{
try
{
output_.clear();
while (process_tree_.size()) process_tree_.pop();
reader_.assign(begin, end);
R();
syntax_error::assert_unexpected(
!reader_.size(), "unexpected token", size() ? top() : lexeme("??"));
} LogExceptionPath("syntaxer::process(I begin, I end) ");
}
node get_process_tree() const;
std::vector<lexeme>::const_iterator begin() const;
std::vector<lexeme>::const_iterator end() const;
private:
std::stack<shared_ptr<node> > process_tree_;
std::vector<lexeme> reader_;
std::vector<lexeme> output_;
};
}
|
#ifdef TIME_H_
#define TIME_H_
#include <iostream>
#include "support.h"
using namespace std;
class Time{
protected:
int arrivalTime;
int serviceTime;
};
#endif /*TIME_H_*/
|
#include "Continent.h"
Continent::Continent(void)
{
}
Continent::Continent(string name,int unit)
{
this->name = name;
this->unit = unit;
}
Continent::~Continent(void)
{
}
string Continent::getName(){
return this->name;
}
void Continent::setName(string name){
this->name=name;
}
int Continent::getUnit(){
return this->unit;
}
void Continent::setUnit(int unit){
this->unit=unit;
}
|
// C++ for the Windows Runtime vv1.0.170303.6
// Copyright (c) 2017 Microsoft Corporation. All rights reserved.
#pragma once
#include "Windows.Networking.ServiceDiscovery.Dnssd.1.h"
#include "Windows.Foundation.1.h"
WINRT_EXPORT namespace winrt {
namespace ABI::Windows::Foundation::Collections {
#ifndef WINRT_GENERIC_ac7f26f2_feb7_5b2a_8ac4_345bc62caede
#define WINRT_GENERIC_ac7f26f2_feb7_5b2a_8ac4_345bc62caede
template <> struct __declspec(uuid("ac7f26f2-feb7-5b2a-8ac4-345bc62caede")) __declspec(novtable) IMapView<hstring, hstring> : impl_IMapView<hstring, hstring> {};
#endif
#ifndef WINRT_GENERIC_f6d1f700_49c2_52ae_8154_826f9908773c
#define WINRT_GENERIC_f6d1f700_49c2_52ae_8154_826f9908773c
template <> struct __declspec(uuid("f6d1f700-49c2-52ae-8154-826f9908773c")) __declspec(novtable) IMap<hstring, hstring> : impl_IMap<hstring, hstring> {};
#endif
#ifndef WINRT_GENERIC_60310303_49c5_52e6_abc6_a9b36eccc716
#define WINRT_GENERIC_60310303_49c5_52e6_abc6_a9b36eccc716
template <> struct __declspec(uuid("60310303-49c5-52e6-abc6-a9b36eccc716")) __declspec(novtable) IKeyValuePair<hstring, hstring> : impl_IKeyValuePair<hstring, hstring> {};
#endif
}
namespace ABI::Windows::Foundation {
#ifndef WINRT_GENERIC_e617711e_cdd5_5975_8fb3_8eaaaed24e7b
#define WINRT_GENERIC_e617711e_cdd5_5975_8fb3_8eaaaed24e7b
template <> struct __declspec(uuid("e617711e-cdd5-5975-8fb3-8eaaaed24e7b")) __declspec(novtable) TypedEventHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceWatcher, Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> : impl_TypedEventHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceWatcher, Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> {};
#endif
#ifndef WINRT_GENERIC_6a6cc5d5_9f43_545a_91d7_3a40055475da
#define WINRT_GENERIC_6a6cc5d5_9f43_545a_91d7_3a40055475da
template <> struct __declspec(uuid("6a6cc5d5-9f43-545a-91d7-3a40055475da")) __declspec(novtable) TypedEventHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceWatcher, Windows::Foundation::IInspectable> : impl_TypedEventHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceWatcher, Windows::Foundation::IInspectable> {};
#endif
#ifndef WINRT_GENERIC_0c251e73_52c9_5026_a875_f685a50cbffd
#define WINRT_GENERIC_0c251e73_52c9_5026_a875_f685a50cbffd
template <> struct __declspec(uuid("0c251e73-52c9-5026-a875-f685a50cbffd")) __declspec(novtable) IAsyncOperation<Windows::Networking::ServiceDiscovery::Dnssd::DnssdRegistrationResult> : impl_IAsyncOperation<Windows::Networking::ServiceDiscovery::Dnssd::DnssdRegistrationResult> {};
#endif
}
namespace ABI::Windows::Foundation::Collections {
#ifndef WINRT_GENERIC_f75ff82a_7e10_5cf6_8064_6ae585e0bd8d
#define WINRT_GENERIC_f75ff82a_7e10_5cf6_8064_6ae585e0bd8d
template <> struct __declspec(uuid("f75ff82a-7e10-5cf6-8064-6ae585e0bd8d")) __declspec(novtable) IVectorView<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> : impl_IVectorView<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> {};
#endif
#ifndef WINRT_GENERIC_1de3a3e5_387e_5328_b864_3f0e3475d343
#define WINRT_GENERIC_1de3a3e5_387e_5328_b864_3f0e3475d343
template <> struct __declspec(uuid("1de3a3e5-387e-5328-b864-3f0e3475d343")) __declspec(novtable) IIterable<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> : impl_IIterable<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> {};
#endif
}
namespace ABI::Windows::Foundation {
#ifndef WINRT_GENERIC_f3632f52_894a_5345_9be6_8389751c5189
#define WINRT_GENERIC_f3632f52_894a_5345_9be6_8389751c5189
template <> struct __declspec(uuid("f3632f52-894a-5345-9be6-8389751c5189")) __declspec(novtable) AsyncOperationCompletedHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdRegistrationResult> : impl_AsyncOperationCompletedHandler<Windows::Networking::ServiceDiscovery::Dnssd::DnssdRegistrationResult> {};
#endif
}
namespace ABI::Windows::Foundation::Collections {
#ifndef WINRT_GENERIC_6fdec6e8_71f2_5821_9955_238d32989f7c
#define WINRT_GENERIC_6fdec6e8_71f2_5821_9955_238d32989f7c
template <> struct __declspec(uuid("6fdec6e8-71f2-5821-9955-238d32989f7c")) __declspec(novtable) IVector<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> : impl_IVector<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> {};
#endif
#ifndef WINRT_GENERIC_bc0cca83_44e5_5544_ab5b_e09d66f5fd5f
#define WINRT_GENERIC_bc0cca83_44e5_5544_ab5b_e09d66f5fd5f
template <> struct __declspec(uuid("bc0cca83-44e5-5544-ab5b-e09d66f5fd5f")) __declspec(novtable) IIterator<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> : impl_IIterator<Windows::Networking::ServiceDiscovery::Dnssd::DnssdServiceInstance> {};
#endif
#ifndef WINRT_GENERIC_e9bdaaf0_cbf6_5c72_be90_29cbf3a1319b
#define WINRT_GENERIC_e9bdaaf0_cbf6_5c72_be90_29cbf3a1319b
template <> struct __declspec(uuid("e9bdaaf0-cbf6-5c72-be90-29cbf3a1319b")) __declspec(novtable) IIterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> : impl_IIterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> {};
#endif
#ifndef WINRT_GENERIC_05eb86f1_7140_5517_b88d_cbaebe57e6b1
#define WINRT_GENERIC_05eb86f1_7140_5517_b88d_cbaebe57e6b1
template <> struct __declspec(uuid("05eb86f1-7140-5517-b88d-cbaebe57e6b1")) __declspec(novtable) IIterator<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> : impl_IIterator<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> {};
#endif
}
namespace Windows::Networking::ServiceDiscovery::Dnssd {
struct IDnssdRegistrationResult :
Windows::Foundation::IInspectable,
impl::consume<IDnssdRegistrationResult>
{
IDnssdRegistrationResult(std::nullptr_t = nullptr) noexcept {}
};
struct IDnssdServiceInstance :
Windows::Foundation::IInspectable,
impl::consume<IDnssdServiceInstance>
{
IDnssdServiceInstance(std::nullptr_t = nullptr) noexcept {}
};
struct IDnssdServiceInstanceFactory :
Windows::Foundation::IInspectable,
impl::consume<IDnssdServiceInstanceFactory>
{
IDnssdServiceInstanceFactory(std::nullptr_t = nullptr) noexcept {}
};
struct IDnssdServiceWatcher :
Windows::Foundation::IInspectable,
impl::consume<IDnssdServiceWatcher>
{
IDnssdServiceWatcher(std::nullptr_t = nullptr) noexcept {}
};
}
}
|
#include <map>
#ifndef MYPROJECT_DAO_STU_H
#define MYPROJECT_DAO_STU_H
using namespace std;
int insertStu(char* content);
int removeStu(int line);
int changeStu(int line,char* content);
int findStuLines(int col, const char *keys, map<int, int> &lines);
string findStu(int line);
#endif
|
//
// Vector3.H
//
//
#ifndef Vector3_h
#define Vector3_h
class Vector3{
public:
float x,y,z;
Vector3(){}
Vector3(const Vector3 &vector) {
x = vector.x; y = vector.y; z = vector.z;
}
Vector3(float nx, float ny, float nz) {
x = nx; y = ny; z = nz;
}
Vector3 &operator =(const Vector3 &vector){
x = vector.x; y = vector.y; z = vector.z;
return *this;
}
bool operator ==(const Vector3 &vector){
return x == vector.x && y == vector.y && z == vector.z;
}
bool operator !=(const Vector3 &vector){
return x != vector.x || y != vector.y || z != vector.z;
}
void zero() { x = 0.0f; y =0.0f; z = 0.0f; }
Vector3 operator -() const { return Vector3(-x,-y,-z); }
Vector3 operator +(const Vector3 &vector) const {
return Vector3( x + vector.x, y + vector.y, z + vector.z);
}
Vector3 operator -(const Vector3 &vector) const{
return Vector3( x - vector.x, y - vector.y, z - vector.z);
}
Vector3 operator *(float s){
return Vector3( x*s, y*s, z*s);
}
Vector3 operator /(float s){
float oneOverS = 1.0f / s;
return Vector3( x*oneOverS, y*oneOverS, z*oneOverS);
}
Vector3 &operator +=(const Vector3 &vector){
x += vector.x; y += vector.y; z += vector.z;
return *this;
}
Vector3 &operator -=(const Vector3 &vector){
x -= vector.x; y -= vector.y; z -= vector.z;
return *this;
}
Vector3 &operator *=(float s){
x *= s; y *= s; z *= s;
return *this;
}
Vector3 &operator /=(float s){
float oneOverS = 1.0f / s;
x *= oneOverS; y *= oneOverS; z *= oneOverS;
return *this;
}
//
//Normalize Vector
//Vnorm = V / ||v||
//
void normalize(){
float magSqrd = x*x + y*y + z*z;
if (magSqrd > 0.0f) {
float oneOverMag = 1.0f / sqrt(magSqrd);
x *= oneOverMag;
y *= oneOverMag;
z *= oneOverMag;
}
}
//
//Dot Product
// sum of products of vectors
//
float operator *(const Vector3 &vector){
return (x * vector.x) + (y * vector.y) + (z * vector.z);
}
};
//
//Magnitude
//
inline float vectorMag(const Vector3 &vector){
return sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
}
//
//Cross Product
//
inline Vector3 crossProduct(const Vector3 &a, const Vector3 &b){
return Vector3(
(a.y * b.z) - (a.z * b.y),
(a.z * b.x) - (a.x * b.z),
(a.x * b.y) - (a.y * b.x)
);
}
//
//multiply by scalar
inline Vector3 operator *(float s, const Vector3 &vector){
return Vector3(s * vector.x, s * vector.y, s * vector.z);
}
//
//Distance between two points
//
inline float distance(const Vector3 &a, const Vector3 &b){
float dx = a.x - b.x;
float dy = a.y - b.y;
float dz = a.z - b.z;
return sqrt(dx * dx + dy * dy + dz * dy);
}
extern const Vector3 kZeroVector;
#endif
|
#include <iostream>
using namespace std;
int NWD(int a, int b)
{
while(a!=b)
if(a>b)
a-=b; //lub a = a - b;
else
b-=a; //lub b = b-a
return a; // lub b - obie zmienne przechowują wynik NWD(a,b)
}
int NWD(int a, int b, int c, int d)
{
int temp = NWD(NWD(a,b), c);
return NWD(temp, d);
}
int NWW(int a, int b){
return a/NWD(a, b)*b;
}
int NWW(int a, int b, int c, int d){
return NWW(NWW(NWW(a,b),c),d);
}
int main(){
int tries = 0;
cin >> tries;
for(int i = 0; i < tries; i++){
int * tab = new int[4];
for(int j = 0; j < 4; j++){
cin >> tab[j];
}
int nww = 0;
nww = NWW(tab[0], tab[1], tab[2], tab[3]);
cout<<nww;
delete [] tab;
}
}
|
//
// Copyright Jason Rice 2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef NBDL_DETAIL_CONCEPT_PRED_HPP
#define NBDL_DETAIL_CONCEPT_PRED_HPP
#include <boost/hana/bool.hpp>
namespace nbdl { namespace detail
{
namespace hana = boost::hana;
template <template <typename ...> class Concept>
struct concept_pred_fn
{
template <typename T>
constexpr auto operator()(T const&) const
-> hana::bool_<Concept<T>::value>
{ return {}; }
};
template <template <typename ...> class Concept>
constexpr concept_pred_fn<Concept> concept_pred{};
}} // nbdl::detail
#endif
|
// -*- C++ -*-
//
// Copyright (C) 1998, 1999, 2000, 2002 Los Alamos National Laboratory,
// Copyright (C) 1998, 1999, 2000, 2002 CodeSourcery, LLC
//
// This file is part of FreePOOMA.
//
// FreePOOMA is free software; you can redistribute it and/or modify it
// under the terms of the Expat license.
//
// 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 Expat
// license for more details.
//
// You should have received a copy of the Expat license along with
// FreePOOMA; see the file LICENSE.
//
//-----------------------------------------------------------------------------
// Classes:
// ViewIndexer - A utility class for doing index calculations
// for view-type engines.
//-----------------------------------------------------------------------------
#ifndef POOMA_UTILITIES_VIEWINDEXER_H
#define POOMA_UTILITIES_VIEWINDEXER_H
/** @file
* @ingroup Utilities
* @brief
* ViewIndexer translates a set of "local" indices for a view of some domain
* into the "base" coordinates of the domain that ultimately spawned the view.
*/
//-----------------------------------------------------------------------------
// Includes:
//-----------------------------------------------------------------------------
#include "Domain/Interval.h"
#include "Domain/Loc.h"
#include "Domain/Range.h"
#include "Domain/SliceDomain.h"
/**
* ViewIndexer translates indices in a Dim-dimensional domain back to the
* corresponding indices in the original Dim2-dimensional domain, taking into
* account things like slices.
*
* Exported typedefs:
* - BaseDomain_t - the type of base domain for this ViewIndexer.
* - Domain_t - the type of domain for this ViewIndexer.
* - Mask_t - the type of mask for this ViewIndexer.
* - This_t - this class.
*
* Constructors:
* - ViewIndexer() - default initialization creates empty domains and leaves
* the rest uninitialized. Initialization can be completed with operator=().
* - ViewIndexer(const SliceDomain<DT> &) - constructs a ViewIndexer for
* the first slice-type view of a domain.
* - ViewIndexer(const ViewIndexer<Dim, Dim2> &, const Domain<Dim, DT> &) -
* constructs a new ViewIndexer from another one by taking a non-slice
* view.
* - ViewIndexer(const ViewIndexer<OrigDim, Dim2> &, const SliceDomain<DT> &)
* constructs a new ViewIndexer from another one by taking a slice.
* - ViewIndexer(const This_t &) - copy constructor.
*
* Operators:
* - operator=(const This_t &) - copy assignment operator.
*
* Accessors:
* - baseDomain() - returns the base domain.
* - domain() - returns the domain.
* - indirection(int i ) - returns the ith indirection index.
* - mask() - returns the mask.
* - offset(int i ) - returns the ith offset.
* - stride(int i ) - returns the ith stride.
* - translate(int i0[, ... int i6], Loc<Dim2>) - translates 1-7 indices to
* a Loc in the base coordinate system.
*
* Utility functions:
* - localToBase - transforms a domain in the local coordinate system to
* the corresponding domain in base coordinates.
* - baseToLocal - transforms a domain in the base coordinate system to
* the corresponding domain in local coordinates.
*/
template<int Dim, int Dim2>
class ViewIndexer
{
public:
//---------------------------------------------------------------------------
// Exported typedefs and enumerations.
// This class.
typedef ViewIndexer<Dim, Dim2> This_t;
// The domain type.
typedef Interval<Dim> Domain_t;
// The base domain type.
typedef Range<Dim2> BaseDomain_t;
// The mask type.
typedef Loc<Dim2> Mask_t;
//---------------------------------------------------------------------------
// Constructors.
// Sometimes it is convenient to use the default initializer and then
// assign a new instance to an object, so we provide a default constructor
// that initializes ViewIndexer with empty domains and leaves everything
// else uninitialized.
ViewIndexer() { }
template<class DT>
ViewIndexer(const SliceDomain<DT> &dom)
: domain_m(Pooma::NoInit()), baseDomain_m(dom.totalDomain())
{
// We are a slice and our dimensions must be consistent with us and the
// slice-domain we're being spawned by.
CTAssert(Dim == DT::sliceDimensions);
CTAssert(Dim2 == DT::dimensions);
// Set up our offsets, domains, and strides. We are a slice so me must
// do this using the non-ignorable domains. We set the mask according to
// the ignorable domains
int dt, d;
const typename DT::TotalDomain_t &domain = dom.totalDomain();
for (d = 0, dt = 0; dt < Dim2; ++dt)
{
if (!dom.ignorable(dt))
{
PAssert(d < Dim);
offset_m[d] = domain[dt].first();
stride_m[d] = domain[dt].stride();
domain_m[d] = Interval<1>(domain[dt].length());
ind_m[d] = dt;
++d;
}
else
{
PAssert(domain[dt].first() == domain[dt].last());
mask_m[dt] = domain[dt].first();
}
}
}
template<class DT>
ViewIndexer(const ViewIndexer<Dim, Dim2> &orig,
const Domain<Dim, DT> &dom)
: domain_m(Pooma::NoInit()),
baseDomain_m(Pooma::NoInit()),
mask_m(orig.mask())
{
// Fill in the base domain from the previous indexer. We'll overwrite
// some dimensions below but we need to have the sliced out dimensions
// in place.
baseDomain_m = orig.baseDomain();
// Set up our offsets, domains, and strides. This is easy since we're not
// not being sliced by this domain meaning we don't need to fiddle with
// the mask and indirection vectors.
const typename DT::Domain_t &domain = dom.unwrap();
for (int d = 0; d < Dim; ++d)
{
offset_m[d] = orig.offset(d) + orig.stride(d) *
domain[d].first();
stride_m[d] = orig.stride(d) * domain[d].stride();
domain_m[d] = Interval<1>(domain[d].length());
ind_m[d] = orig.indirection(d);
}
localToBase(domain_m, baseDomain_m);
}
template<int OrigDim, class DT>
ViewIndexer(const ViewIndexer<OrigDim, Dim2> &orig,
const SliceDomain<DT> &dom)
: domain_m(Pooma::NoInit()),
baseDomain_m(orig.baseDomain()), mask_m(orig.mask())
{
// Our dimensionality must be the same as the slice's reduced
// dimensionality.
CTAssert(DT::sliceDimensions == Dim);
// The slice's dimensionality must match that of the previous view.
CTAssert(DT::dimensions == OrigDim);
// Set up our offsets, domains, and strides. We are a slice so me must
// do this using the non-ignorable domains. We set the mask according to
// the ignorable domains
int dt, d;
const typename DT::TotalDomain_t &domain = dom.totalDomain();
for (d = 0, dt = 0; dt < OrigDim; ++dt)
{
if (!dom.ignorable(dt))
{
PAssert(d < Dim);
offset_m[d] = orig.offset(dt) + orig.stride(dt) *
domain[dt].first();
stride_m[d] = orig.stride(dt) * domain[dt].stride();
domain_m[d] = Interval<1>(domain[dt].length());
ind_m[d] = orig.indirection(dt);
// Translate this part of the domain to base coordinates and
// store.
baseDomain_m[ind_m[d]] = Range<1>(
offset_m[d],
offset_m[d] + stride_m[d] * domain_m[d].last(),
stride_m[d]);
++d;
}
else
{
PAssert(domain[dt].first() == domain[dt].last());
int m = orig.offset(dt) + orig.stride(dt) *
domain[dt].first();
mask_m[orig.indirection(dt)] = m;
baseDomain_m[orig.indirection(dt)] =
Range<1>(m, m, 1);
}
}
}
//---------------------------------------------------------------------------
// Copy constructor.
ViewIndexer(const This_t &model)
: domain_m(model.domain()), baseDomain_m(model.baseDomain()),
mask_m(model.mask())
{
for (int d = 0; d < Dim; d++)
{
ind_m[d] = model.indirection(d);
offset_m[d] = model.offset(d);
stride_m[d] = model.stride(d);
}
}
//---------------------------------------------------------------------------
// Assignment operator.
This_t &operator=(const This_t &rhs)
{
domain_m = rhs.domain();
baseDomain_m = rhs.baseDomain();
mask_m = rhs.mask();
for (int d = 0; d < Dim; d++)
{
ind_m[d] = rhs.indirection(d);
offset_m[d] = rhs.offset(d);
stride_m[d] = rhs.stride(d);
}
return *this;
}
//---------------------------------------------------------------------------
// Accessors.
const Domain_t &domain() const { return domain_m; }
const BaseDomain_t &baseDomain() const { return baseDomain_m; }
int indirection(int i) const { return ind_m[i]; }
const Mask_t &mask() const { return mask_m; }
int offset(int i) const { return offset_m[i]; }
int stride(int i) const { return stride_m[i]; }
//---------------------------------------------------------------------------
// Translate the indices from the local coordinates to base coordinates.
void translate(const Loc<Dim> &loc, Loc<Dim2> &oloc) const
{
oloc = mask_m;
for (int d = 0; d < Dim; d++)
oloc[ind_m[d]] = Loc<1>(offset_m[d] + stride_m[d] * loc[d].first());
}
void translate(int i0, Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
}
void translate(int i0, int i1, Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
}
void translate(int i0, int i1, int i2,
Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
loc[ind_m[2]] = offset_m[2] + stride_m[2] * i2;
}
void translate(int i0, int i1, int i2, int i3,
Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
loc[ind_m[2]] = offset_m[2] + stride_m[2] * i2;
loc[ind_m[3]] = offset_m[3] + stride_m[3] * i3;
}
void translate(int i0, int i1, int i2, int i3,
int i4, Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
loc[ind_m[2]] = offset_m[2] + stride_m[2] * i2;
loc[ind_m[3]] = offset_m[3] + stride_m[3] * i3;
loc[ind_m[4]] = offset_m[4] + stride_m[4] * i4;
}
void translate(int i0, int i1, int i2, int i3,
int i4, int i5, Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
loc[ind_m[2]] = offset_m[2] + stride_m[2] * i2;
loc[ind_m[3]] = offset_m[3] + stride_m[3] * i3;
loc[ind_m[4]] = offset_m[4] + stride_m[4] * i4;
loc[ind_m[5]] = offset_m[5] + stride_m[5] * i5;
}
void translate(int i0, int i1, int i2, int i3,
int i4, int i5, int i6, Loc<Dim2> &loc) const
{
// Assign our masked loc, with the sliced out dimensions already filled in.
loc = mask_m;
// Compute the indices in the domain of the original view.
// Use our indirection array to slot the indices into the current loc.
loc[ind_m[0]] = offset_m[0] + stride_m[0] * i0;
loc[ind_m[1]] = offset_m[1] + stride_m[1] * i1;
loc[ind_m[2]] = offset_m[2] + stride_m[2] * i2;
loc[ind_m[3]] = offset_m[3] + stride_m[3] * i3;
loc[ind_m[4]] = offset_m[4] + stride_m[4] * i4;
loc[ind_m[5]] = offset_m[5] + stride_m[5] * i5;
loc[ind_m[6]] = offset_m[6] + stride_m[6] * i6;
}
//---------------------------------------------------------------------------
// Utility functions
// Transforms a domain in the current coordinate system to one in base
// coordinate system.
template<class DT>
BaseDomain_t &localToBase(const Domain<Dim, DT> &dlocal,
BaseDomain_t &base) const
{
// The base domain contains the appropriate information for the
// sliced out dimensions.
base = baseDomain_m;
// We just need to fill in the non-sliced dimensions and transform
// back to base coordinates.
const typename DT::Domain_t &local = dlocal.unwrap();
for (int d = 0; d < Dim; d++)
{
base[ind_m[d]] = Range<1>(
offset_m[d] + stride_m[d] * local[d].first(),
offset_m[d] + stride_m[d] * local[d].last(),
stride_m[d] * local[d].stride());
}
return base;
}
// Transforms a domain in the current coordinate system to one in base
// coordinate system, returning a slice-range suitable for making a view.
template<class DT>
SliceRange<Dim2, Dim> &localToBase(const Domain<Dim, DT> &dlocal,
SliceRange<Dim2, Dim> &base) const
{
// The base domain contains the appropriate information for the
// sliced out dimensions.
base.totalDomain() = baseDomain_m;
// We need to transform to base coordinates and fill in the appropriate
// slots in the total domain and slice domain. We also need to label
// the non-sliced dimensions as non-ignorable.
const typename DT::Domain_t &local = dlocal.unwrap();
for (int d = 0; d < Dim; d++)
{
Range<1> r(
offset_m[d] + stride_m[d] * local[d].first(),
offset_m[d] + stride_m[d] * local[d].last(),
stride_m[d] * local[d].stride());
base.totalDomain()[ind_m[d]] = r;
base.sliceDomain()[d] = r;
base.cantIgnoreDomain(ind_m[d]);
}
return base;
}
// Transforms a domain in the base coordinate system to one in the
// local coordinate system.
Interval<Dim> &baseToLocal(const BaseDomain_t &base,
Interval<Dim> &local) const
{
// We just need to strip out the sliced dimensions and transform back to
// local coordinates. We check to make sure that stride really works out
// to one.
int j;
for (int d = 0; d < Dim; d++)
{
j = ind_m[d];
local[d] = Interval<1>(
(base[j].first() - offset_m[d]) / stride_m[d],
(base[j].last() - offset_m[d]) / stride_m[d]);
PAssert(base[j].stride() / stride_m[d] == 1);
}
return local;
}
Range<Dim> &baseToLocal(const BaseDomain_t &base,
Range<Dim> &local) const
{
// We just need to strip out the sliced dimensions and transform back to
// local coordinates.
int j;
for (int d = 0; d < Dim; d++)
{
j = ind_m[d];
local[d] = Range<1>(
(base[j].first() - offset_m[d]) / stride_m[d],
(base[j].last() - offset_m[d]) / stride_m[d],
base[j].stride() / stride_m[d]);
}
return local;
}
Interval<Dim> &baseToLocalInterval(const Interval<Dim2> &base,
Interval<Dim> &local) const
{
// We just need to strip out the sliced dimensions and transform back to
// local coordinates.
int j;
for (int d = 0; d < Dim; d++)
{
j = ind_m[d];
local[d] = Interval<1>((base[j].first() - offset_m[d]) / stride_m[d],
(base[j].last() - offset_m[d]) / stride_m[d]);
PAssert(local[d].first() * stride_m[d] + offset_m[d] == base[j].first());
PAssert(local[d].last() * stride_m[d] + offset_m[d] == base[j].last());
}
return local;
}
private:
// The current domain.
Domain_t domain_m;
// The base domain.
BaseDomain_t baseDomain_m;
// Strides and offsets.
int stride_m[Dim], offset_m[Dim];
// Mask loc and indirection vector.
int ind_m[Dim];
Mask_t mask_m;
};
/**
* This is an extra-special version of View indexer that optimizes indexing for
* the case where we have not taken a slice.
*
* Exported typedefs:
* - BaseDomain_t - the type of base domain for this ViewIndexer.
* - Domain_t - the type of domain for this ViewIndexer.
* - Mask_t - the type of mask for this ViewIndexer.
* - This_t - this class.
*
* Constructors:
* - ViewIndexer() - default initialization creates empty domains and leaves
* the rest uninitialized. Initialization can be completed with
* operator=().
* - ViewIndexer(const Domain<Dim, DT> &) - constructs a ViewIndexer for
* the first non-slice view of a domain.
* - ViewIndexer(const ViewIndexer<Dim, Dim> &, const Domain<Dim, DT> &) -
* constructs a new ViewIndexer from another one by taking a non-slice
* view.
* - ViewIndexer(const This_t &) - copy constructor.
*
* Operators:
* - operator=(const This_t &) - copy assignment operator.
*
* Accessors:
* - baseDomain() - returns the base domain.
* - domain() - returns the domain.
* - indirection(int i ) - returns the ith indirection index.
* - mask() - returns the mask.
* - offset(int i ) - returns the ith offset.
* - stride(int i ) - returns the ith stride.
* - translate(int i0[, ... int i6], Loc<Dim>) - translates 1-7 indices to
* a Loc in the base coordinate system.
*
* Utility functions:
* - localToBase - transforms a domain in the local coordinate system to
* the corresponding domain in base coordinates.
* - baseToLocal - transforms a domain in the base coordinate system to
* the corresponding domain in local coordinates.
* - baseToLocalInterval - transforms an interval in the base coordinate
* system to an interval in the local coordinates while ingnoring the
* fact that the stride doesn't work. (The endpoints are transformed.)
*/
template<int Dim>
class ViewIndexer<Dim, Dim>
{
public:
//---------------------------------------------------------------------------
// Exported typedefs and enumerations.
// This class.
typedef ViewIndexer<Dim, Dim> This_t;
// The domain type.
typedef Interval<Dim> Domain_t;
// The base domain type.
typedef Range<Dim> BaseDomain_t;
// The mask type.
typedef Loc<Dim> Mask_t;
//---------------------------------------------------------------------------
// Constructors.
ViewIndexer() { }
template<class DT>
ViewIndexer(const Domain<Dim, DT> &dom)
: domain_m(Pooma::NoInit()), baseDomain_m(dom.unwrap())
{
// Set up our offsets, domains, and strides. This is easy since we're not
// a slice. The mask is initialized to according to the default constructor
// and we don't need to do anything. The indirection vector is a one-to-one
// linear mapping.
const typename DT::Domain_t &domain = dom.unwrap();
for (int d = 0; d < Dim; ++d)
{
offset_m[d] = domain[d].first();
stride_m[d] = domain[d].stride();
domain_m[d] = Interval<1>(domain[d].length());
}
}
// We can take a non-slice subset of an existing non-sliced view.
template<class DT>
ViewIndexer(const ViewIndexer<Dim, Dim> &orig,
const Domain<Dim, DT> &dom)
: domain_m(Pooma::NoInit()),
baseDomain_m(dom.unwrap()),
mask_m(orig.mask())
{
// Set up our offsets, domains, and strides. This is easy since we're not
// not being sliced by this domain meaning we don't need to fiddle with
// the mask and indirection vectors.
const typename DT::Domain_t &domain = dom.unwrap();
for (int d = 0; d < Dim; ++d)
{
offset_m[d] = orig.offset(d) + orig.stride(d) *
domain[d].first();
stride_m[d] = orig.stride(d) * domain[d].stride();
domain_m[d] = Interval<1>(domain[d].length());
}
localToBase(domain_m, baseDomain_m);
}
//---------------------------------------------------------------------------
// Copy constructor.
ViewIndexer(const This_t &model)
: domain_m(model.domain()), baseDomain_m(model.baseDomain()),
mask_m(model.mask())
{
for (int d = 0; d < Dim; d++)
{
offset_m[d] = model.offset(d);
stride_m[d] = model.stride(d);
}
}
//---------------------------------------------------------------------------
// Assignment operator.
This_t &operator=(const This_t &rhs)
{
domain_m = rhs.domain();
baseDomain_m = rhs.baseDomain();
mask_m = rhs.mask();
for (int d = 0; d < Dim; d++)
{
offset_m[d] = rhs.offset(d);
stride_m[d] = rhs.stride(d);
}
return *this;
}
//---------------------------------------------------------------------------
// Accessors.
const Domain_t &domain() const { return domain_m; }
const BaseDomain_t &baseDomain() const { return baseDomain_m; }
int indirection(int i) const { return i; }
const Mask_t &mask() const { return mask_m; }
int offset(int i) const { return offset_m[i]; }
int stride(int i) const { return stride_m[i]; }
//---------------------------------------------------------------------------
// Translate the indices from the local coordinates to base coordinates.
void translate(const Loc<Dim> &loc, Loc<Dim> &oloc) const
{
for (int d = 0; d < Dim; d++)
oloc[d] = Loc<1>(offset_m[d] + stride_m[d] * loc[d].first());
}
void translate(int i0, Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
}
void translate(int i0, int i1, Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
}
void translate(int i0, int i1, int i2,
Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
loc[2] = offset_m[2] + stride_m[2] * i2;
}
void translate(int i0, int i1, int i2, int i3,
Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
loc[2] = offset_m[2] + stride_m[2] * i2;
loc[3] = offset_m[3] + stride_m[3] * i3;
}
void translate(int i0, int i1, int i2, int i3,
int i4, Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
loc[2] = offset_m[2] + stride_m[2] * i2;
loc[3] = offset_m[3] + stride_m[3] * i3;
loc[4] = offset_m[4] + stride_m[4] * i4;
}
void translate(int i0, int i1, int i2, int i3,
int i4, int i5, Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
loc[2] = offset_m[2] + stride_m[2] * i2;
loc[3] = offset_m[3] + stride_m[3] * i3;
loc[4] = offset_m[4] + stride_m[4] * i4;
loc[5] = offset_m[5] + stride_m[5] * i5;
}
void translate(int i0, int i1, int i2, int i3,
int i4, int i5, int i6, Loc<Dim> &loc) const
{
// Compute the indices in the domain of the original view.
loc[0] = offset_m[0] + stride_m[0] * i0;
loc[1] = offset_m[1] + stride_m[1] * i1;
loc[2] = offset_m[2] + stride_m[2] * i2;
loc[3] = offset_m[3] + stride_m[3] * i3;
loc[4] = offset_m[4] + stride_m[4] * i4;
loc[5] = offset_m[5] + stride_m[5] * i5;
loc[6] = offset_m[6] + stride_m[6] * i6;
}
//---------------------------------------------------------------------------
// Utility functions
// Transforms a domain in the current coordinate system to one in base
// coordinate system.
template<class DT>
BaseDomain_t &localToBase(const Domain<Dim, DT> &dlocal,
BaseDomain_t &base) const
{
// We just transform back to base coordinates.
const typename DT::Domain_t &local = dlocal.unwrap();
for (int d = 0; d < Dim; d++)
{
base[d] = Range<1>(
offset_m[d] + stride_m[d] * local[d].first(),
offset_m[d] + stride_m[d] * local[d].last(),
stride_m[d] * local[d].stride());
}
return base;
}
// Transforms a domain in the current coordinate system to one in base
// coordinate system, returning a slice-range suitable for making a view.
// Do we even need this version? SliceRange<D,D> is never used, is it???
template<class DT>
SliceRange<Dim, Dim> &localToBase(const Domain<Dim, DT> &dlocal,
SliceRange<Dim, Dim> &base) const
{
// The base domain contains the appropriate information for the
// sliced out dimensions.
base.totalDomain() = baseDomain_m;
// We need to transform to base coordinates and fill in the appropriate
// slots in the total domain and slice domain. We also need to label
// the non-sliced dimensions as non-ignorable.
const typename DT::Domain_t &local = dlocal.unwrap();
for (int d = 0; d < Dim; d++)
{
Range<1> r(
offset_m[d] + stride_m[d] * local[d].first(),
offset_m[d] + stride_m[d] * local[d].last(),
stride_m[d] * local[d].stride());
base.totalDomain()[d] = r;
base.sliceDomain()[d] = r;
base.cantIgnoreDomain(d);
}
return base;
}
// Transforms a domain in the base coordinate system to one in the
// local coordinate system.
Interval<Dim> &baseToLocal(const BaseDomain_t &base,
Interval<Dim> &local) const
{
// We just transform back to local coordinates.
// We check to make sure that stride really works out
// to one.
for (int d = 0; d < Dim; d++)
{
local[d] = Interval<1>(
(base[d].first() - offset_m[d]) / stride_m[d],
(base[d].last() - offset_m[d]) / stride_m[d]);
PAssert(base[d].stride() / stride_m[d] == 1);
}
return local;
}
Range<Dim> &baseToLocal(const BaseDomain_t &base,
Range<Dim> &local) const
{
// We just transform back to local coordinates.
for (int d = 0; d < Dim; d++)
{
local[d] = Range<1>(
(base[d].first() - offset_m[d]) / stride_m[d],
(base[d].last() - offset_m[d]) / stride_m[d],
base[d].stride() / stride_m[d]);
}
return local;
}
// This version ignores strides.
Interval<Dim> &baseToLocalInterval(const Interval<Dim> &base,
Interval<Dim> &local) const
{
// We just transform back to local coordinates.
for (int d = 0; d < Dim; d++)
{
local[d] = Interval<1>((base[d].first() - offset_m[d]) / stride_m[d],
(base[d].last() - offset_m[d]) / stride_m[d]);
PAssert(local[d].first() * stride_m[d] + offset_m[d] == base[d].first());
PAssert(local[d].last() * stride_m[d] + offset_m[d] == base[d].last());
}
return local;
}
private:
// The current domain.
Domain_t domain_m;
// The base domain.
BaseDomain_t baseDomain_m;
// Strides and offsets.
int stride_m[Dim], offset_m[Dim];
// Mask loc and indirection vector.
Mask_t mask_m;
};
#endif // POOMA_UTILITIES_VIEWINDEXER_H
// ACL:rcsinfo
// ----------------------------------------------------------------------
// $RCSfile: ViewIndexer.h,v $ $Author: richard $
// $Revision: 1.11 $ $Date: 2004/11/01 18:17:18 $
// ----------------------------------------------------------------------
// ACL:rcsinfo
|
#pragma once
/* Show Negative Stats
* PATCHES: Pleione.dll
*/
#include "../Main.h"
#include "../Singleton.h"
#include "GenericPatcher.h"
class CPatcher_ShowNegativeStats : public IGenericPatcher {
public:
CPatcher_ShowNegativeStats();
bool ReadINI(void);
bool WriteINI(void);
private:
// Hook functions
// Variables for hook functions
};
typedef Singleton<CPatcher_ShowNegativeStats> SngPatcher_ShowNegativeStats;
|
#include "playerinfolabel.h"
PlayerInfoLabel::PlayerInfoLabel(std::string nickname, size_t money) : TotalMoney(money), Bet(0) {
mNickname = new QLabel;
mTotalMoney = new QLabel;
mStatus = new QLabel;
QString name = QString::fromStdString(nickname);
mNickname->setText(name);
QString total = "Bank 💰: " + QString::number(money);
mTotalMoney->setText(total);
mNickname->setParent(this);
mNickname->setGeometry(0, 50, 300, 30);
mNickname->setStyleSheet("background:rgba(33,33,33,0.5);font-size:21px;color:rgb(242, 224, 22)");
mNickname->setAlignment(Qt::AlignCenter);
mTotalMoney->setParent(this);
mTotalMoney->setGeometry(0, 80, 300, 30);
mTotalMoney->setStyleSheet("background:rgba(33,33,33,0.5);font-size:21px;color:rgb(242, 224, 22)");
mTotalMoney->setAlignment(Qt::AlignCenter);
mStatus->setParent(this);
mStatus->setGeometry(0, 110, 300, 30);
mStatus->setStyleSheet("background:rgba(33,33,33,0.5);font-size:21px;color:rgb(0, 255, 255);");
mStatus->setAlignment(Qt::AlignCenter);
}
void PlayerInfoLabel::setTotal(size_t total) {
TotalMoney = total;
QString totalm = "Bank 💰: " + QString::number(TotalMoney);
mTotalMoney->setText(totalm);
}
void PlayerInfoLabel::setBet(size_t bet) {
QString total = "Bet 🌝: " + QString::number(bet);
mStatus->setText(total);
}
void PlayerInfoLabel::setMoney(size_t money) {
QString totalm = "Bank 💰: " + QString::number(money);
mTotalMoney->setText(totalm);
}
void PlayerInfoLabel::setRaise(size_t bet) {
QString total = "Raise 🌝: " + QString::number(bet);
mStatus->setText(total);
}
void PlayerInfoLabel::setFold() {
QString status = "Fold ❎";
mStatus->setText(status);
}
void PlayerInfoLabel::setCheck() {
QString status = "Check ✅";
mStatus->setText(status);
}
void PlayerInfoLabel::setCall() {
QString status = "Call";
mStatus->setText(status);
}
void PlayerInfoLabel::ClearStatus() {
mStatus->setText("");
}
PlayerInfoLabel::~PlayerInfoLabel() {
delete mNickname;
delete mTotalMoney;
delete mStatus;
}
size_t PlayerInfoLabel::GetBet() {
return Bet;
}
size_t PlayerInfoLabel::GetTotal() {
return TotalMoney;
}
QString PlayerInfoLabel::GetName() {
return mNickname->text();
}
|
//QUEUE 사용 문제
//숨바꼭질
//BFS문제
/*
X
/ | \
X-1 X+1 2X
이미 지나왔던 길은 제외하고 찾는다
*/
#include <iostream>
#include <queue>
using namespace std;
queue<int> q;
int isvisit[100001] = { 0, };
int dist[100001] = { 0, };
int que_val;
void isvalid(int i) {
if (i <= 100000 && i >= 0) { //방문하지않았다면
if (isvisit[i] == 0) {
q.push(i);
isvisit[i] = 1;
dist[i] = dist[que_val] + 1;
}
}
}
int main() {
int subin;
int dest;
int ans;
cin >> subin >> dest;
q.push(subin);
isvisit[subin] = 1;
dist[subin] = 0;
while (!q.empty()) { //queue가 비어 있지 않을때까지
que_val = q.front(); //맨 앞 위치
if (que_val == dest) {
ans = dist[dest];
break;
}
q.pop();
isvalid(que_val - 1);
isvalid(que_val + 1);
isvalid(que_val * 2);
}
cout << ans;
}
|
#include <iostream>
using namespace std;
struct Rectangle{
int length;
int breadth;
};
int main()
{
struct Rectangle *p ;
p = new struct Rectangle;
p->length =10;
p->breadth = 6;
cout<< p->length <<endl;
cout<< p->breadth <<endl;
return 0;
}
|
//
// Texture.cpp
// cheetah
//
// Copyright (c) 2013 cafaxo. All rights reserved.
//
#include "RenderWindow.h"
#include "BufferManager.h"
#include "Texture.h"
Texture::Texture(BufferManager &bufferManager, const std::string &fileName) : mCoordinates(bufferManager.create(16)) {
glGenTextures(1, &mId);
bind();
if (glfwLoadTexture2D(fileName.c_str(), GLFW_NO_RESCALE_BIT) == GL_FALSE) {
throw std::string("Error loading texture from file: " + fileName + ".");
}
initSettings();
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, (int *)&mWidth);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, (int *)&mHeight);
generateCoordinates();
}
Texture::Texture(BufferManager &bufferManager, const unsigned int &width, const unsigned int &height) : mWidth(width), mHeight(height), mCoordinates(bufferManager.create(16)) {
glGenTextures(1, &mId);
bind();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
initSettings();
generateCoordinates();
}
Texture::Texture(const unsigned int id, const unsigned int &width, const unsigned int &height, const Buffer &coordinates) : mId(id), mWidth(width), mHeight(height), mCoordinates(coordinates) {
bind();
initSettings();
}
void Texture::bind() {
if (this != mBoundTexture) {
glBindTexture(GL_TEXTURE_2D, mId);
mBoundTexture = this;
}
}
void Texture::initSettings() {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
void Texture::generateCoordinates() {
mCoordinates.setData({
0.f, 0.f,
static_cast<float>(mWidth), 0.f,
static_cast<float>(mWidth), static_cast<float>(mHeight),
0.f, static_cast<float>(mHeight),
0.f, 0.f,
1.f, 0.f,
1.f, 1.f,
0.f, 1.f
});
mCoordinates.refresh();
}
Texture *Texture::mBoundTexture = nullptr;
|
#ifndef __COMMAND_B_H__
#define __COMMAND_B_H__
#include "Command.h"
#include "Receiver.h"
#include <memory>
class CommandB : public Command
{
public:
CommandB(std::shared_ptr<Receiver> receiver);
virtual void execute() override;
virtual void undo() override;
private:
int m_status;
std::shared_ptr<Receiver> m_receiver;
};
#endif // __COMMAND_B_H__
|
#include "DeployHook.h"
DeployHook::DeployHook()
{
Requires(hook);
// Use Requires() here to declare subsystem dependencies
// eg. Requires(chassis);
}
// Called just before this Command runs the first time
void DeployHook::Initialize()
{
hook->deploy();
}
// Called repeatedly when this Command is scheduled to run
void DeployHook::Execute()
{
}
// Make this return true when this Command no longer needs to run execute()
bool DeployHook::IsFinished()
{
return !oi->getDriveStick()->GetRawButton(1);
}
// Called once after isFinished returns true
void DeployHook::End()
{
hook->stop();
}
// Called when another command which requires one or more of the same
// subsystems is scheduled to run
void DeployHook::Interrupted()
{
}
|
#include "WindingOrder.h"
namespace revel
{
namespace renderer
{
//Intentionally left blank
}
}
|
#ifndef _TEXTURE_H_
#define _TEXTURE_H_
#include "Base.h"
//used to identify which texture to load
enum TexID
{
WATER,
ISLAND1,
ISLAND2,
CHEST,
BOAT2,
BOAT1,
SPLASH,
VICTORY,
DEFEAT,
CHECKPOINTON,
CHECKPOINTOFF
};
class Texture
{
GLuint m_id;
public:
Texture(){}
~Texture(){}
inline GLuint id() const { return m_id; }
//loads a texture based on the TexID
void Load(uint16 id);
//binds this texture
inline void Bind() { glBindTexture(GL_TEXTURE_2D, m_id); }
};
#endif
|
/*******************************************************************************
* Cristian Alexandrescu *
* 2163013577ba2bc237f22b3f4d006856 *
* 11a4bb2c77aca6a9927b85f259d9af10db791ce5cf884bb31e7f7a889d4fb385 *
* bc9a53289baf23d369484f5343ed5d6c *
*******************************************************************************/
/* Problem 11069 - A Graph Problem */
#include <iostream>
#include <vector>
using namespace std;
int main() {
const int MAX_NODES = 76;
vector<int> oVecnCount(MAX_NODES + 1);
oVecnCount[1] = oVecnCount[2] = oVecnCount[3] = 1;
for (int nLoop = 4; nLoop <= MAX_NODES; nLoop++)
oVecnCount[nLoop] = oVecnCount[nLoop - 2] + oVecnCount[nLoop - 3];
for (int nNoNodes; cin >> nNoNodes; )
cout << oVecnCount[nNoNodes - 1] + oVecnCount[nNoNodes] << endl;
return 0;
}
|
/**
* Date: 2019-11-09 22:19:58
* LastEditors: Aliver
* LastEditTime: 2019-11-09 23:43:18
*/
#include <iostream>
#include "test7.h"
int main()
{
int fd = open(filename, O_WRONLY | O_CREAT);
if (fd == -1)
exitWithError("open");
setNonBlock(fd);
// writeLock(fd, true);
// cout << "文件锁由进程" << getpid() << "持有" << endl;
char *buff = (char *)"1750817 高鹏";
write(fd, buff, strlen(buff));
cout << "进程" << getpid() << " 写入 : " << buff << endl;
// unLock(fd);
while (true)
sleep(1);
close(fd);
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <sstream>
using namespace std;
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<vector<int> > FindPath(TreeNode* root, int exp) {
res = vector<vector<int> >();
if(root == NULL) return res;
helper(root, vector<int>(), exp);
sort(res.begin(), res.end(), cmp); // 这一行不加也能过，好像样例太弱了
return res;
}
private:
static bool cmp(vector<int> a, vector<int> b){
return a.size()>b.size();
}
void helper(TreeNode* r, vector<int> cur, int e){
e -= r->val;
cur.push_back(r->val);
if(r->left == NULL && r->right == NULL){
if(e == 0) res.push_back(cur);
} else{
if(r->left) helper(r->left, cur, e);
if(r->right) helper(r->right, cur, e);
} return;
}
vector<vector<int> > res;
};
int main(){
return 0;
}
|
/***********************************************************************
created: Wed Aug 5 2009
author: Paul D Turner <paul@cegui.org.uk>
*************************************************************************/
/***************************************************************************
* Copyright (C) 2004 - 2009 Paul D Turner & The CEGUI Development Team
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#include "CEGUI/Config.h"
#include "CEGUI/text/BidiVisualMapping.h"
#include "CEGUI/Logger.h"
#if defined (CEGUI_USE_FRIBIDI)
#include <fribidi.h>
#include <memory>
#include <cstring>
#elif defined (CEGUI_USE_MINIBIDI)
// https://gitlab.com/arabeyes-dev/adawat/-/blob/master/minibidi/minibidi.c
// TODO: check for modifications against our copy
#include "minibidi.cpp" // include minibidi code directly
#endif
namespace CEGUI
{
//----------------------------------------------------------------------------//
BidiCharType BidiVisualMapping::getBidiCharType(const char32_t codepoint)
{
#if defined (CEGUI_USE_FRIBIDI)
switch (fribidi_get_bidi_type((FriBidiChar)codepoint))
{
case FRIBIDI_TYPE_RTL: return BidiCharType::RIGHT_TO_LEFT;
case FRIBIDI_TYPE_LTR: return BidiCharType::LEFT_TO_RIGHT;
default: return BidiCharType::NEUTRAL;
}
#elif defined (CEGUI_USE_MINIBIDI)
switch (getType(codepoint))
{
case R: return BidiCharType::RIGHT_TO_LEFT;
case L: return BidiCharType::LEFT_TO_RIGHT;
default: return BidiCharType::NEUTRAL;
}
#else
return BidiCharType::NEUTRAL;
#endif
}
//----------------------------------------------------------------------------//
bool BidiVisualMapping::applyBidi(const String& logical, String& outVisual,
std::vector<int>& l2v, std::vector<int>& v2l, DefaultParagraphDirection& dir)
{
#if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UTF_32
return applyBidi(logical.getString(), outVisual.getString(), l2v, v2l, dir);
#else
std::u32string utf32Str = String::convertUtf8ToUtf32(logical.c_str());
if (utf32Str.empty())
return false;
if (!applyBidiInplace(utf32Str, l2v, v2l, dir))
return false;
outVisual = String::convertUtf32ToUtf8(utf32Str.c_str());
return true;
#endif
}
//----------------------------------------------------------------------------//
bool BidiVisualMapping::applyBidi(const String& logical, std::u32string& outVisual,
std::vector<int>& l2v, std::vector<int>& v2l, DefaultParagraphDirection& dir)
{
#if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UTF_32
return applyBidi(logical.getString(), outVisual, l2v, v2l, dir);
#else
outVisual = String::convertUtf8ToUtf32(logical.c_str());
return !outVisual.empty() && applyBidiInplace(outVisual, l2v, v2l, dir);
#endif
}
//----------------------------------------------------------------------------//
bool BidiVisualMapping::applyBidi(const char32_t* start, size_t length, std::u32string& outVisual,
std::vector<int>& l2v, std::vector<int>& v2l, DefaultParagraphDirection& dir)
{
const bool inplace = (start == outVisual.c_str());
// Forbid aliasing other than exact matching of source and destination pointers
if (!inplace && start > outVisual.c_str() && start <= (outVisual.c_str() + length))
return false;
l2v.resize(length);
v2l.resize(length);
if (length <= 1)
{
if (!inplace)
outVisual.assign(start, length);
if (length)
{
l2v[0] = 0;
v2l[0] = 0;
}
return true;
}
#if defined (CEGUI_USE_FRIBIDI)
FriBidiChar* outputBuffer;
std::unique_ptr<FriBidiChar[]> outputFribidiStr;
if (inplace)
{
outputFribidiStr.reset(new FriBidiChar[length]);
outputBuffer = outputFribidiStr.get();
}
else
{
outVisual.resize(length);
outputBuffer = reinterpret_cast<FriBidiChar*>(const_cast<char32_t*>(outVisual.c_str()));
}
FriBidiCharType baseDir =
(dir == DefaultParagraphDirection::RightToLeft) ? FRIBIDI_PAR_RTL :
(dir == DefaultParagraphDirection::Automatic) ? FRIBIDI_PAR_ON :
FRIBIDI_PAR_LTR;
fribidi_boolean success = fribidi_log2vis(
reinterpret_cast<const FriBidiChar*>(start), static_cast<FriBidiStrIndex>(length),
&baseDir, outputBuffer, &l2v[0], &v2l[0], nullptr);
if (!success)
{
if (!inplace)
outVisual.assign(start, length);
Logger::getSingleton().logEvent(
"FribidiVisualMapping::reorderFromLogicalToVisual: fribidi_log2vis "
"call failed on logical string: " + String(start, length), LoggingLevel::Error);
return false;
}
// Get resolved paragraph direction
dir = (baseDir == FRIBIDI_PAR_RTL) ? DefaultParagraphDirection::RightToLeft :
(baseDir == FRIBIDI_PAR_ON) ? DefaultParagraphDirection::Automatic :
DefaultParagraphDirection::LeftToRight;
if (inplace)
{
outVisual.resize(length);
std::memcpy(const_cast<char32_t*>(outVisual.c_str()), outputBuffer, length);
}
return true;
#elif defined (CEGUI_USE_MINIBIDI)
if (!inplace)
outVisual.assign(start, length);
doBidi(reinterpret_cast<unsigned int*>(const_cast<char32_t*>(outVisual.c_str())),
static_cast<int>(length), true, false, &v2l[0], &l2v[0]);
return true;
#else
return false;
#endif
}
}
|
#ifndef KB_32FT_h
#define KB_32FT_h
#include <Arduino.h>
#include <Wire.h>
class KB_32FT
{
public:
void begin(void);
uint16_t readTempSTM1();
uint16_t readTempSTM2();
uint16_t readTempSTM3();
protected:
private:
uint16_t tempSTM;
uint16_t tmp = 0;
uint16_t tmp1 = 0;
uint16_t tmp2 = 0;
};
#endif /* KB_LM73_h */
|
/******************多重背包问题*********************/
#include <iostream>
#include <vector>
#include <math.h>
#include<stdio.h>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
#define EMPTY
#define INF -65536
#define max(a,b) a<b?b:a
int V ;//定义体积
int T ;//定义物品种类
int f[10000 + 1];
int c[200] ;
int w[200] ;
int n[200] ;
vector <int> n_list;//存储分解后的每一个系数
vector <int> c_list;//将分解后的每一个系数乘以每一个体积
vector <int> w_list;//将分解后的每一个系数乘以每一个价值
void initpackage()//将每个系数分解
{
int x = 0;
for (int i = 0; i < T; i++)
{
int p = 1;
while ((n[i] - pow(2, p) + 1) >= 0)
{
n_list.push_back(pow(2, p - 1));
c_list.push_back(c[i] * pow(2, p - 1));
w_list.push_back(w[i] * pow(2, p - 1));
p++;
}
x = n[i] - pow(2, p - 1) + 1;
if (x > 0)
{
n_list.push_back(x);
c_list.push_back(c[i] * x);
w_list.push_back(w[i] * x);
}
}
}
int package()
{
initpackage();
int size;
size = n_list.size();
#ifdef EMPTY
for (int i = 0; i <= V; i++)
{
f[i] = 0;
}
#else
f[0] = 0;
for (int i = 1; i <= V; i++)
{
f[i] = INF;
}
#endif // EMPTY
for (int i = 0; i < size; i++)
{
for (int v = V; v >= c_list[i]; v--)
{
f[v] = max(f[v], f[v - c_list[i]] + w_list[i]);
}
}
return f[V];
}
int main()
{
int temp,i;
scanf("%d", &T);
scanf("%d", &V);
for (i = 0; i < T; i++)
{
scanf("%d %d %d", &c[i], &w[i], &n[i]);
}
temp = package();
cout << temp << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <cstddef>
#include <cassert>
#include "myclass.hpp"
using namespace std::string_literals;
int freePlainFunction(int a, int b)
{
return a + b;
}
int main()
{
MyClass myObject;
cpp::reflection<MyClass>().field("field").get(myObject) = 12;
assert(myObject.field == 12);
for(const auto& keyValue : cpp::reflection<MyClass>().fields())
{
const auto& field = keyValue.second;
std::cout << " -- " << field.name() << ": Type " << field.type().type().name()
<< ", sizeof " << field.type().type().sizeOf()
<< ", alignment " << field.type().type().alignment()
<< std::endl;
}
for (const auto& keyValue : cpp::reflection<MyClass>().functions())
{
const auto& function = keyValue.second;
std::cout << " -- " << function.name() << ": Return type " << function.returnType().type().name()
<< ", parameter types [";
for (const auto& type : function.parameterTypes())
std::cout << "'" << type.type().name() << "', ";
std::cout << "], const: " << std::boolalpha << function.isConst() << std::endl;
}
cpp::MetaObject result = cpp::reflection<MyClass>().function("f")(myObject)(1, 2);
std::cout << myObject.field << std::endl;
std::cout << freePlainFunction(
cpp::reflection(myObject).function("f")(1, 10),
cpp::reflection(myObject).field("field")
) << std::endl;
}
|
#include <bits/stdc++.h>
#include <conio.h>
using namespace std;
int main()
{
freopen("in", "r", stdin);
freopen("out", "w", stdout);
int T;
scanf("%d", &T);
for(int tt=1; tt<=T; tt++)
{
printf("Case #%d: ", tt);
int n, k;
bool rWon = false, bWon = false, ansF = false;
scanf("%d %d", &n, &k);
char a[n][n];
for(int i=0; i<n; i++)
{
scanf("%s", a[i]);
}
for(int k=0; k<n; k++)
{
for(int i=0; i<n; i++)
{
bool blank = false;
for(int j=n-1; j>=0; j--)
{
if(a[i][j]!='.' && blank)
{
a[i][j+1] = a[i][j];
a[i][j] = '.';
}
else if(a[i][j]=='.')
blank = true;
}
}
}
// cout<<endl;
// for(int i=0; i<n; i++)
// {
// for(int j=0; j<n; j++)
// printf("%c", a[i][j]);
// cout<<endl;
// }
// cout<<endl;
//horizontal
for(int i=0; i<n; i++)
{
int r=0, b=0;
for(int j=0; j<n; j++)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
{
rWon = true;
}
if(b>=k)
{
bWon = true;
}
if(rWon && bWon)
{
ansF = true;
break;
break;
}
}
}
//vertical
if(!ansF)
{
for(int j=0; j<n; j++)
{
int r=0, b=0;
for(int i=0; i<n; i++)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
{
rWon = true;
}
if(b>=k)
{
bWon = true;
}
if(rWon && bWon)
{
ansF = true;
break;
break;
}
}
}
}
//diagonals-->
if(!ansF)
{
for(int t=0; t<n-1; t++)
{
int i = n-1, j = t;
int r = 0, b = 0;
while(j<n)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
rWon = true;
if(b>=k)
bWon = true;
if(rWon && bWon)
{
ansF = true;
break;
break;
}
i--;
j++;
}
}
}
if(!ansF)
{
for(int t=0; t<n-1; t++)
{
int i = t, j = 0;
int r = 0, b = 0;
while(i<n)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
rWon = true;
if(b>=k)
bWon = true;
if(rWon && bWon)
{
ansF = true;
break;
break;
}
i++;
j++;
}
}
}
if(!ansF)
{
for(int t=0; t<n-1; t++)
{
int i = 0, j = t;
int r = 0, b = 0;
while(i<n)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
rWon = true;
if(b>=k)
bWon = true;
if(rWon && bWon)
{
ansF = true;
break;
break;
}
i++;
j++;
}
}
}
if(!ansF)
{
for(int t=n-1; t>0; t--)
{
int i = t, j = 0;
int r = 0, b = 0;
while(i>0)
{
switch(a[i][j])
{
case 'R':
if(b!=0)
{
b = 0;
r++;
}
else
r++;
break;
case 'B':
if(r!=0)
{
r = 0;
b++;
}
else
b++;
break;
}
if(r>=k)
rWon = true;
if(b>=k)
bWon = true;
if(rWon && bWon)
{
ansF = true;
break;
break;
}
i--;
j++;
}
}
}
if(ansF)
printf("Both");
else if(rWon && !bWon)
printf("Red");
else if(bWon && !rWon)
printf("Blue");
else
printf("Neither");
cout<<endl;
}
}
|
// -*- C++ -*-
//
// Copyright (C) 1998, 1999, 2000, 2002 Los Alamos National Laboratory,
// Copyright (C) 1998, 1999, 2000, 2002 CodeSourcery, LLC
//
// This file is part of FreePOOMA.
//
// FreePOOMA is free software; you can redistribute it and/or modify it
// under the terms of the Expat license.
//
// 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 Expat
// license for more details.
//
// You should have received a copy of the Expat license along with
// FreePOOMA; see the file LICENSE.
//
//-----------------------------------------------------------------------------
// A tour of the new Field class.
//-----------------------------------------------------------------------------
#include "Pooma/Fields.h"
#if POOMA_MESSAGING
typedef DistributedTag LayoutTag_t;
typedef Remote<Brick> BrickTag_t;
#else
typedef ReplicatedTag LayoutTag_t;
typedef Brick BrickTag_t;
#endif
int main(int argc, char *argv[])
{
Pooma::initialize(argc, argv);
// To declare a field, you first need to set up a layout. This requires
// knowing the physical vertex-domain and the number of external guard
// cell layers. Vertex domains contain enough points to hold all of the
// rectilinear centerings that POOMA is likely to support for quite
// awhile. Also, it means that the same layout can be used for all
// fields, regardless of centering.
Interval<2> physicalVertexDomain(4, 4); // 0..3 x 0..3
Loc<2> blocks(1, 2); // x-direction has one block, y-dir has two blocks
UniformGridPartition<2> partition(blocks, GuardLayers<2>(1)); // add one layer of guard cells in each direction
UniformGridLayout<2> layout(physicalVertexDomain, partition, LayoutTag_t());
std::cout << layout << std::endl;
std::cout << layout.domain() << std::endl;
// Now, we can declare a field.
Centering<2> allFace = canonicalCentering<2>(FaceType, Continuous);
typedef
Field<UniformRectilinearMesh<2>, double,
MultiPatch<UniformTag, BrickTag_t> > Field_t;
Field_t f(allFace, layout, Vector<2>(0.0), Vector<2>(1.0, 2.0));
std::cout << f.centering() << std::endl;
std::cout << f[0].centering() << std::endl;
std::cout << f[1].centering() << std::endl;
// Ask for the field's physical cell domain.
std::cout << f.physicalCellDomain() << std::endl;
// If we ask for the physical domain, we should get the physical cell
// domain back because of the all-face centering. We can get the
// face-domains by specifying the sub-fields.
std::cout << f.physicalDomain() << std::endl; // cell orientation
std::cout << f.physicalDomain(0) << std::endl; // x face orientation
std::cout << f.physicalDomain(1) << std::endl; // y face orientation
// Total domains work similarly.
std::cout << f.totalDomain() << std::endl;
std::cout << f.totalDomain(0) << std::endl;
std::cout << f.totalDomain(1) << std::endl;
// We can do a similar sort of thing by taking sub-field views.
std::cout << f[0].physicalDomain() << std::endl; // x faces
std::cout << f[1].physicalDomain() << std::endl; // y faces
// Total domains work similarly. Note: taking a sub-field view doesn't
// remove the guard layers.
std::cout << f[0].totalDomain() << std::endl;
std::cout << f[1].totalDomain() << std::endl;
// We can actually index fields after taking a sub-field view. The
// indices refer to the actual domain.
f[0](1, 2) = 3.0;
f[1](1, 2) = f[0](1, 2) + 1.2;
std::cout << f[0](1, 2) << std::endl;
std::cout << f[1](1, 2) << std::endl;
// Same thing after taking domain & sub-field views.
Interval<1> I(1,2);
std::cout << f[0](I, I)(0, 1) << std::endl;
std::cout << f(I, I)[1](0, 1) << std::endl;
// The guard layers are removed when you take a domain view.
std::cout << f(I, I).physicalDomain() << std::endl;
std::cout << f(I, I).totalDomain() << std::endl;
std::cout << f(I, I).physicalDomain(0) << std::endl;
std::cout << f(I, I).totalDomain(0) << std::endl;
// Check assignment of a scalar.
f = -1.0; // assign physical domain
f(I, I) = -2.0;
std::cout << f << std::endl;
// Declare another field. Note how we can reuse the layout for a field
// with a different centering.
Centering<2> face1 = canonicalCentering<2>(FaceType, Continuous, YDim);
Field_t g(face1, layout, Vector<2>(0.0), Vector<2>(1.0, 2.0));
g = -3.0;
g(I, I) = -4.0;
f[1] = g;
std::cout << f.all() << std::endl;
std::cout << g.all() << std::endl;
/*
typedef
Field<Lagrangian<2>, double,
MultiPatch<UniformTag, BrickTag_t> >
LagrField_t;
LagrField_t h(allFace, layout, Vector<2>(0.0), Vector<2>(1.0, 2.0));
std::cout << h.fieldEngine().vertexPositions() << std::endl;
// Try assigning to a field with a Lagrangian mesh.
h.all() = 3.0; // .all means also set guards as well as physical
h = -6.0;
std::cout << h.all() << std::endl;
*/
// Check out the patch function.
f.all() = 1.0;
f = 2.0;
f[0](1, 1) = 3.0;
f[1](1, 1) = 3.0;
int nLocal = f[0].numPatchesLocal();
std::cout << "context " << Pooma::context() << " has "
<< nLocal << " patches" << std::endl;
if (nLocal > 0)
{
std::cout << "context " << Pooma::context()
<< " local patch 0: " << f[0].patchLocal(0) << std::endl;
}
if (nLocal > 1)
{
std::cout << "context " << Pooma::context()
<< " local patch 1: " << f[0].patchLocal(1) << std::endl;
}
// Play with relations.
Pooma::addAllPosReflectFaceBC(f);
std::cout << f.all() << std::endl;
// Try to create a vector field.
typedef
Field<UniformRectilinearMesh<2>, Vector<2>,
MultiPatch<UniformTag, BrickTag_t> >
VectorField_t;
VectorField_t l(allFace, layout, Vector<2>(0.0), Vector<2>(1.0, 2.0));
l.all() = Vector<2>(-1.0, 2.0);
l = Vector<2>(4.0, 6.0);
std::cout << l.all().comp(0) << std::endl;
Pooma::finalize();
return 0;
}
// ACL:rcsinfo
// ----------------------------------------------------------------------
// $RCSfile: FieldTour1.cpp,v $ $Author: richard $
// $Revision: 1.3 $ $Date: 2004/11/01 18:16:48 $
// ----------------------------------------------------------------------
// ACL:rcsinfo
|
/*
ID: hjl11841
TASK: sprime
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
int n;
bool prime(int x) {
if(x<2)return false;
for(int i=2; i<=sqrt(x); i++) {
if(x%i==0)return false;
}
return true;
}
void dfs(int dep,int last) {
if(dep>n) {
if(prime(last))cout<<last<<endl;
return;
} else {
for(int i=1; i<=9; i++) {
if(prime(last*10+i)) {
dfs(dep+1,last*10+i);
}
}
}
}
int main() {
freopen("sprime.in","r",stdin);
freopen("sprime.out","w",stdout);
cin>>n;
dfs(1,0);
return 0;
}
|
SORTING
In sorting, if order of duplicates remains same after soting, then stable,and if order of duplicates change after sorting,then unsorted.
//comparision based sortings:
bubble
insertion
selection
quick
merge
1.Bubble Sort: in one pass,greatest element comes at its original position. time complexity=O(n^2) ,maximum swap=(n-1)+(n-2)+......+1=n^2.
stable sorting.
have to make it adaptive.ie if passa sorted array,then complexity reduces.(if after one pass,if there is no swap,then it means sorted and can do this by introducing flag)
2.Insertion Sort:insert already in sorted order by comparing inserting element from backward side and shifting.
worst case complexity:O(n)
best case complexity:O(1)
k
(take one element from unsorted array and insert in sorted aray by comparing element from vacant -1 element)
adaptive byitself
more useful in linked list(coz no shifting)
3.SelectionSort:not adaptive and can't make it adaptive.(min element will come at its origuinal position opp of bubble sort
Also NOT Stable.
worst O(n*n)
best O(n)
4.Quick Sort: take one element and all smaller elements at left side and greater at right.
Best:O(nlogn)=average (partition at middle for best)
worst:O(n^2) (when array is sorted or reverse sorted)
RandomizedQuickSort i.e. randomize pivot by using rand() function (which generates random numbers) to remove worst case
not stable and not adaptive
5.Merge Sort:no average,best or worst case
so time complexity in every scenario is O(nlog n).
space complexity: max entry in stack =height of binary tree=log n.
for merge sort: n for array+n for extra array(for result) + log n for stack.
//inplace sorting algorithm:if algo don't need extra space,then implace sorting algoritm
merge sort is not inplace. (stack cox recursion)
6.Cout Sort:count[0]=index based orting
comlexity=o(n+k) => linear complexity and fastest but should be feasible
whwere k = max element,n=no.of elements
space complexity=n+k (n for output array amd k for count array)
for negATIVE numbers,add largest negative to all elements and then after sorting,again subtract.
7.Radix Sort: sort on basis of radix
8.Shell Sort:
we have to manage/select gap.
when gap=1 i.e.last paas, then similar to insertion sort.
Not stable
best case
|
/*
* Copyright (c) 2012, Jan-Philipp Litza <janphilipp@litza.de>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* little programm serial communication with for IVT Solar Controller
* For details of the protocol and product, see manual:
* http://www.ivt-hirschau.de/media/Bedienungsanleitungen/200014_19.pdf
*/
#include <iostream>
#include <cstring>
#include <sstream>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include <SerialPort.h>
#include <lockdev.h>
#include <getopt.h>
using namespace std;
const char GET[] = { 'F', 0 };
const char RESET[] = { 'L', 0 };
const int BUFFERSIZE = 64;
const int TIMEOUT = 100; // ms
enum FIELDS {
CUR_VOLTAGE,
CUR_CURRENT,
CUR_TEMP,
MIN_VOLTAGE,
MAX_VOLTAGE,
MIN_CURRENT,
MAX_CURRENT
};
int main(int argc, char **argv) {
// sane defaults
bool resetMode = false;
bool rawMode = false;
char *format = (char*)
"CUR_VOLTAGE: %v V\n"
"CUR_CURRENT: %c A\n"
"CUR_TEMP: %t C\n"
"MIN_VOLTAGE: %m V\n"
"MAX_VOLTAGE: %n V\n"
"MIN_CURRENT: %o A\n"
"MAX_CURRENT: %p A\n";
char *device = (char*) "/dev/ttyS0";
// option parsing as we now it...
int c;
opterr = 0;
while (true) {
int option_index = 0;
static struct option long_options[] = {
{ "raw", 0, NULL, 'a' }, { "device", 1, NULL, 'D' },
{ "format", 1, NULL, 'f' }, { "help", 0, NULL, 'h' },
{ "reset", 0, NULL, 'r' }, { NULL, 0, NULL, 0 } };
c = getopt_long(argc, argv, "aD:f:hr", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0: {
break;
}
case 'a':
rawMode = true;
break;
case 'D':
device = optarg;
break;
case 'f':
format = optarg;
break;
case 'h':
cout << "Options:" << endl;
cout << " -a, --raw output raw data sent from device without parsing" << endl;
cout << " -D, --device DEVICE use DEVICE instead of /dev/ttyS0" << endl;
cout << " -f, --format FORMAT output current data using FORMAT, which may contain" << endl;
cout << " following variables:" << endl;
cout << " %v current voltage" << endl;
cout << " %c current current" << endl;
cout << " %t current temperature" << endl;
cout << " %m current minimum voltage" << endl;
cout << " %n current maximum voltage" << endl;
cout << " %o current minimum current" << endl;
cout << " %p current maximum current" << endl;
cout << " Additionally, escape sequences like \\n may be used." << endl;
cout << " -h, --help obvious" << endl;
cout << " -r, --reset reset minimum and maximum values in device" << endl;
return 0;
case 'r':
resetMode = true;
break;
case '?':
cerr << "unkown option: ";
if (optopt != 0)
cerr << (char) optopt << endl;
else
cerr << argv[optind - 1] << endl;
break;
}
}
// try to lock serial device up to 10 times
char i = 0;
while (dev_testlock(device) != 0) {
sleep(1);
if (i++ > 10) {
cerr << "serial device locked" << endl;
return 1;
}
}
pid_t lock = dev_lock(device);
if (lock != 0)
return 0;
// open serial device
SerialPort serial(device);
try {
serial.Open(
SerialPort::BAUD_1200,
SerialPort::CHAR_SIZE_8,
SerialPort::PARITY_NONE,
SerialPort::STOP_BITS_1,
SerialPort::FLOW_CONTROL_NONE);
} catch(SerialPort::OpenFailed& e) {
cerr << "cannot open " << device << ": " << e.what() << endl;
dev_unlock(device, 0);
return 2;
}
// RESET minimum/maximum values? device's response is identical to GET
if (resetMode) {
serial.Write(RESET);
} else {
serial.Write(GET);
}
// initialize variables
char buffer[BUFFERSIZE];
double fields[7];
memset(buffer, 0, BUFFERSIZE);
try {
if (rawMode) {
// read whole line with timeout
cout << serial.ReadLine(TIMEOUT);
} else {
// strip off any beginning NUL-bytes, timeouting with each delayed read
while (buffer[0] == '\0')
*buffer = serial.ReadByte(TIMEOUT);
// read another byte so we can check that the response begins with "R:"
*(buffer+1) = serial.ReadByte(TIMEOUT);
if (strcmp(buffer, "R:")) {
cerr << "unknown response, aborting: " << buffer << endl;
dev_unlock(device, 0);
return 3;
}
// read field-wise
memset(buffer, 0, BUFFERSIZE);
for(int i = 0, j = 0; i < BUFFERSIZE; ) {
char bufchar;
bufchar = serial.ReadByte(TIMEOUT);
switch(bufchar) {
case ';':
// end of field, fill another array entry
fields[j++] = strtod(buffer, NULL);
memset(buffer, 0, i);
i = 0;
break;
case ' ':
// ignore spaces and NUL
break;
case '\n':
case '\0':
// jump out of the reading-loop
// we do NOT break on \r as that would leave the \n unread
i = BUFFERSIZE;
break;
case ',':
// we need dots instead of commata for double parsing
bufchar = '.';
default:
buffer[i++] = bufchar;
break;
}
}
}
} catch (SerialPort::ReadTimeout&) {
cerr << "no response" << endl;
return 3;
}
// close serial device
serial.Close();
dev_unlock(device, 0);
// output formatted data if not in raw mode
if (!rawMode && format != NULL) {
ostringstream output;
for (int i = 0; i < strlen(format); i++) {
if (format[i] == '%') {
// parse data field
switch (format[++i]) {
case 'v': output << fields[CUR_VOLTAGE]; break;
case 'c': output << fields[CUR_CURRENT]; break;
case 't': output << fields[CUR_TEMP]; break;
case 'm': output << fields[MIN_VOLTAGE]; break;
case 'n': output << fields[MAX_VOLTAGE]; break;
case 'o': output << fields[MIN_CURRENT]; break;
case 'p': output << fields[MAX_CURRENT]; break;
case '%': output << '%'; break;
default:
cerr << "Invalid format: " << format << endl;
return 1;
}
}
else if(format[i] == '\\') {
// parse special character
switch (format[++i]) {
case 'n': output << '\n'; break;
case 'r': output << '\r'; break;
case 't': output << '\t'; break;
default:
output << '\\' << format[i]; break;
break;
}
}
else
// simply copy format-input
output << format[i];
}
// if nothing went wrong, output result
cout << output.str();
}
return 0;
}
|
#include <Servo.h>
void invK(float tempX, float tempY);
float x = 40;
float y = 120;
float l1 = 105;
float l2 = 121;
float e = 0;
float s = 0;
float ang = 0;
int a = 40;//x start
int b = 120;//x end
int c = 120;
int d = 180;
Servo servo1;
Servo servo2;
void setup() {
Serial.begin(9600);
servo1.attach(13);
servo2.attach(12);
}
void loop() {
// top left -> right
for(x = a; x < b; x++) invK(x,y); // 80w
// top right V bottom right
for(y = c; y < d; y++) invK(x,y); // 40h
// bottom right > bottom left
for(x = b; x > a; x--) invK(x,y); // 80w
// bottom left ^ top left
for(y = d; y > c; y--) invK(x,y); // 40h
// top left > mid-top
for(x = a; x < 80; x++) invK(x,y); // 40w
// circle
for (int i = 0; i < 200; i++) {
ang = (float)i * 2.0 * 3.141592 / 200.0;
x = 80.0 - sin(ang) * 40.0;
y = 150.0 - cos(ang) * 30.0;
invK(x,y);
}
// s -- top semi
for (int i = 0; i < 200; i++) {
ang = (float)i * 2.0 * 3.141592 / 400.0;
x = 80.0 - sin(ang) * 15.0;
y = 135.0 - cos(ang) * 15.0;
invK(x,y);
}
// s -- bottom semi
for (int i = 0; i < 200; i++) {
ang = ((2.0 * 3.141592)/400.0) * (float)i;
x = 80 + sin(ang) * 15;
y = 165 - cos(ang) * 15;
invK(x,y);
}
}
void invK(float tempX, float tempY) {
e = degrees(acos((tempX*tempX+tempY*tempY-l1*l1-l2*l2) / (2.0*l1*l2)));
s = degrees(atan(tempY/tempX) - acos((tempX*tempX+tempY*tempY+l1*l1-l2*l2) / (2*l1*sqrt(tempX*tempX+tempY*tempY))));
Serial.println(e, 5);
Serial.println(s, 5);
servo1.write(e);
delay(10);
servo2.write(s);
delay(10);
}
|
#include "inc/texture_manager.hpp"
#include <sstream>
#include <tinyxml2.h>
#include <inc/utility.hpp>
namespace astroblaster {
bool TextureManager::add_texture(std::string filename, unsigned int mode) {
if (!this->textures.count(filename)) {
if (mode & static_cast<unsigned int>(TextureModes::Sheet)) {
tinyxml2::XMLDocument sheet;
sheet.LoadFile(this->get_full_resource_path(filename).c_str());
if (sheet.ErrorID()) {
return false;
}
this->textures[filename] = std::make_unique<sf::Texture>();
if (!this->textures.at(filename)->loadFromFile(this->get_full_resource_path(sheet.RootElement()->Attribute("imagePath")))) {
this->textures.erase(this->textures.find(filename));
return false;
}
const sf::Texture *atlas = this->textures.at(filename).get();
tinyxml2::XMLElement *subtexture = sheet.RootElement()->FirstChildElement("SubTexture");
while (subtexture) {
this->subtextures.emplace(subtexture->Attribute("name"), std::pair(atlas, sf::Rect(subtexture->IntAttribute("x"), subtexture->IntAttribute("y"), subtexture->IntAttribute("width"), subtexture->IntAttribute("height"))));
subtexture = subtexture->NextSiblingElement("SubTexture");
}
}
else {
this->textures[filename] = std::make_unique<sf::Texture>();
if (!this->textures.at(filename)->loadFromFile(this->get_full_resource_path(filename))) {
this->textures.erase(this->textures.find(filename));
return false;
}
}
if (mode & static_cast<unsigned int>(TextureModes::Repeat)) {
this->textures.at(filename)->setRepeated(true);
}
}
return true;
}
const sf::Texture* TextureManager::get_texture(std::string name) const {
try {
return this->textures.at(name).get();
}
catch (std::out_of_range) {
// we'll prefer default return below
}
return nullptr;
}
std::pair<const sf::Texture*, sf::Rect<int>> TextureManager::get_subtexture(std::string name) const {
try {
return this->subtextures.at(name);
}
catch (std::out_of_range) {
// we'll prefer default return below
}
return std::pair(nullptr, sf::Rect<int>(0, 0, 0, 0));
}
std::string TextureManager::get_full_resource_path(std::string_view filename) const {
std::stringstream ss;
ss << "res/img/" << filename;
return ss.str();
}
}
|
/*
ID: hjl11841
TASK: ride
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
string ufo;
string group;
int main(){
freopen("ride.in","r",stdin);
freopen("ride.out","w",stdout);
cin>>ufo;
cin>>group;
int a,b;
a=b=1;
for(int i=0;i<ufo.size();i++){
int tmp1;
tmp1=ufo[i]-'A'+1;
a*=tmp1;
}
for(int i=0;i<group.size();i++){
int tmp2;
tmp2=group[i]-'A'+1;
b*=tmp2;
}
a%=47;
b%=47;
if(a==b) cout<<"GO"<<endl;
else cout<<"STAY"<<endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.