git.sesse.net Git - freerainbowtables/blob - Client Applications/rcracki_mt/lm2ntlm.cpp

   1 /*
   2  * rcracki_mt is a multithreaded implementation and fork of the original
   3  * RainbowCrack
   4  *
   5  * Copyright 2009, 2010 Daniël Niggebrugge <niggebrugge@fox-it.com>
   6  * Copyright 2009, 2010 James Nobis <frt@quelrod.net>
   7  *
   8  * This file is part of rcracki_mt.
   9  *
  10  * rcracki_mt is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * rcracki_mt is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with rcracki_mt.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #if defined(_WIN32) && !defined(__GNUC__)
  25         #pragma warning(disable : 4786 4267 4018)
  26 #endif
  27
  28 #include "lm2ntlm.h"
  29
  30 LM2NTLMcorrector::LM2NTLMcorrector()
  31 {
  32         progressCurrentCombination = 0;
  33         totalCurrentCombination = 1;
  34         counterOverall = 0;
  35         countCombinations = 0;
  36         countTotalCombinations = 0;
  37         counter = 0;
  38         fillMapW();
  39         aborting = false;
  40         sBinary = "";
  41
  42 }
  43
  44 string LM2NTLMcorrector::getBinary()
  45 {
  46         return sBinary;
  47 }
  48
  49 bool LM2NTLMcorrector::LMPasswordCorrectUnicode(string hexPassword, unsigned char* pNTLMHash, string& sNTLMPassword) //, unsigned char* pLMPassword
  50 {
  51         string sPlain = "";
  52
  53         UINT4 i;
  54         for (i = 0; i < hexPassword.size() / 2; i++)
  55         {
  56                 string sSub = hexPassword.substr(i * 2, 2);
  57                 int nValue;
  58                 sscanf(sSub.c_str(), "%02x", &nValue);
  59                 sPlain += (unsigned char)nValue;
  60         }
  61
  62         memcpy(NTLMHash, pNTLMHash, MD4_DIGEST_LENGTH);
  63
  64
  65         unsigned long int tmpLength = sPlain.size() * 2;
  66         unsigned char* pLMPassword = new unsigned char[tmpLength];
  67
  68         //printf("Searching for unicode password.\n");
  69         printf("Failed case correction, trying unicode correction for: %s\n", sPlain.c_str());
  70         //printf("NTLM hash:          %s\n\n", sNTLMHash.c_str());
  71
  72         setvbuf(stdout, NULL, _IONBF,0);
  73
  74         startClock = clock();
  75         previousClock = clock();
  76
  77 #ifndef _WIN32
  78         tty_init();
  79 #endif
  80
  81         if (startCorrecting(sPlain, sNTLMPassword, pLMPassword))
  82         {
  83                 sBinary = ByteToStr(pLMPassword, tmpLength).c_str();
  84                 //printf("\nFound unicode password: %s\n", sNTLMPassword.c_str());
  85                 //printf("Password in hex: %s\n", sBinary.c_str());
  86                 writeEndStats();
  87 #ifndef _WIN32
  88                 tty_done();
  89 #endif
  90                 return true;
  91         }
  92         else
  93         {
  94                 //printf("\ncase correction for password %s fail!\n", sPlain.c_str());
  95                 writeEndStats();
  96 #ifndef _WIN32
  97                 tty_done();
  98 #endif
  99                 return false;
 100         }
 101 }
 102
 103 bool LM2NTLMcorrector::startCorrecting(string sLMPassword, string& sNTLMPassword, unsigned char* pLMPassword)
 104 {
 105         if (sLMPassword.size() == 0)
 106         {
 107                 sNTLMPassword = "";
 108                 return true;
 109         }
 110
 111         string muteMe = sLMPassword;
 112         int length = muteMe.size();
 113
 114         unsigned char* pMuteMe = new unsigned char[length];
 115         unsigned char* pTempMute = new unsigned char[length * 2];
 116
 117         int i;
 118         for (i = 0; i < length; i++)
 119         {
 120                 pMuteMe[i] = muteMe[i];
 121                 pTempMute[i * 2    ] = muteMe[i];
 122                 pTempMute[i * 2 + 1] = 0x00;
 123                 unsigned char muteChar = pMuteMe[i];
 124                 int sizeMapForChar = m_mapChar[muteChar].size();
 125                 int j;
 126                 for (j = 0; j < sizeMapForChar; j++)
 127                 {
 128                         currentCharmap[i][j] = m_mapChar[muteChar][j];
 129                 }
 130         }
 131
 132         int* jAtPos = new int[length];
 133         int* sizeAtPos = new int[length];
 134         bool* fullAtPos = new bool[length];
 135
 136         int setSize;
 137         for (setSize = 0; setSize <= length; setSize++)
 138         {
 139                 int cntFull = 0;
 140
 141                 // clear all 'fullatpos' before new setSize
 142                 int i;
 143                 for (i=0; i < length; i++)
 144                 {
 145                         fullAtPos[i] = false;
 146                 }
 147
 148                 //printf("Trying full unicode map for %d/%d characters...\t\t\n", setSize, length);
 149                 printf("Trying full unicode map for %d/%d characters...%-20s\n", setSize, length, "");
 150
 151                 bool notFirst = true;
 152
 153                 // start at end and set 'full' combination
 154                 countCombinations = 0;
 155                 countTotalCombinations = calculateTotalCombinations(length, setSize);
 156
 157                 int sPos = length - 1;
 158                 while (sPos >= 0 && notFirst) // finding combinations for current 'setSize'
 159                 {
 160                         if (aborting)
 161                                 return false;
 162
 163                         if (cntFull < setSize)
 164                         {
 165                                 if (fullAtPos[sPos] == false)
 166                                 {
 167                                         fullAtPos[sPos] = true;
 168                                         cntFull++;
 169                                 }
 170                                 sPos--;
 171                         }
 172                         else
 173                         {
 174                                 if (fullAtPos[sPos] == false && setSize > 0)
 175                                 {
 176                                         fullAtPos[sPos] = true;
 177                                         cntFull++;
 178
 179                                         // reset positions after sPos
 180                                         int k;
 181                                         for (k = sPos+1; k < length; k++)
 182                                         {
 183                                                 if (fullAtPos[k] == true)
 184                                                 {
 185                                                         fullAtPos[k] = false;
 186                                                         cntFull--;
 187                                                 }
 188                                         }
 189                                         // start at end again
 190                                         sPos = length - 1;
 191                                 }
 192                                 else
 193                                 {
 194                                         sPos--;
 195                                 }
 196                         }
 197                         // we have a combination
 198                         if (cntFull == setSize)
 199                         {
 200                                 countCombinations++;
 201
 202                                 setupCombinationAtPositions(length, pMuteMe, pTempMute, jAtPos, fullAtPos, sizeAtPos);
 203
 204                                 if (checkPermutations(length, pTempMute, jAtPos, sizeAtPos, pLMPassword, sNTLMPassword))
 205                                 {
 206                                         return true;
 207                                 }
 208                         }
 209
 210                         if (setSize == 0)
 211                                 notFirst = false;
 212                 }
 213         }
 214         return false;
 215 }
 216
 217 // set up combination at positions
 218 void LM2NTLMcorrector::setupCombinationAtPositions(int length, unsigned char* pMuteMe, unsigned char* pTempMute, int* jAtPos, bool* fullAtPos, int* sizeAtPos)
 219 {
 220         progressCurrentCombination = 0;
 221         totalCurrentCombination = 1;
 222
 223         int i;
 224         for (i=0; i < length; i++)
 225         {
 226                 pTempMute[i*2] = currentCharmap[i][0];
 227                 pTempMute[i*2+1] = currentCharmap[i][1]; // reset to first char in map
 228
 229                 jAtPos[i] = 0; // reset charcounter for this char (that is all chars)
 230
 231                 // based on combination, set full map or only upper/lowercase
 232                 if (fullAtPos[i] == true)
 233                 {
 234                         unsigned char muteChar = pMuteMe[i];
 235                         long unsigned int sizeMapForChar = m_mapChar[muteChar].size()/2; // 2 bytes per char
 236                         sizeAtPos[i] = sizeMapForChar;
 237                 }
 238                 else
 239                 {
 240                         sizeAtPos[i] = 2;
 241                 }
 242
 243                 totalCurrentCombination *= sizeAtPos[i];
 244         }
 245         //printf("Trying %I64u passwords for current combination\t\t\r", totalCurrentCombination);
 246 }
 247
 248 // go check all permutations for this combination
 249 bool LM2NTLMcorrector::checkPermutations(int length, unsigned char* pTempMute, int* jAtPos, int* sizeAtPos, unsigned char* pLMPassword, string& sNTLMPassword)
 250 {
 251         int pos = length - 1;
 252
 253         while (pos >= 0)
 254         {
 255                 counter++;
 256
 257                 pos = length - 1;
 258
 259                 int jAtCurPos = jAtPos[pos];
 260                 int sizeMapForCharPos = sizeAtPos[pos];
 261                 // move to start of string and find character with permutations left
 262                 while (jAtCurPos >= sizeMapForCharPos-1 && pos >= -1)
 263                 {
 264                         pos--;
 265                         if (pos >= 0 )
 266                         {
 267                                 jAtCurPos = jAtPos[pos];
 268                                 sizeMapForCharPos = sizeAtPos[pos];
 269                         }
 270                 }
 271                 if (pos < 0)
 272                         continue;
 273
 274                 // next permutation for character
 275                 jAtCurPos++;
 276                 jAtPos[pos] = jAtCurPos;
 277
 278                 pTempMute[pos*2] = currentCharmap[pos][jAtCurPos*2];
 279                 pTempMute[pos*2+1] = currentCharmap[pos][jAtCurPos*2+1];
 280
 281                 // reset positions after pos
 282                 int k;
 283                 for (k = pos+1; k < length; k++)
 284                 {
 285                         jAtPos[k] = 0;
 286                         pTempMute[k*2] = currentCharmap[k][0]; // reset to first char in map
 287                         pTempMute[k*2+1] = currentCharmap[k][1];
 288                 }
 289
 290                 if (checkNTLMPassword(pTempMute, length, sNTLMPassword) == true)
 291                 {
 292                         int i;
 293                         for (i = 0; i < length*2; i++)
 294                                 pLMPassword[i] = pTempMute[i];
 295                         return true;
 296                 }
 297
 298                 if (counter > 10000) // don't check clocks too often
 299                 {
 300                         clock_t currentClock = clock();
 301                         float fTime = 1.0f * (currentClock - previousClock);
 302                         if (fTime > 1.0f * CLOCKS_PER_SEC)
 303                         {
 304                                 float progressPercentageCurrentCombination = progressCurrentCombination * 100.0f / totalCurrentCombination;
 305                                 float fTime = 1.0f * (currentClock - startClock) / CLOCKS_PER_SEC;
 306                                 float currentSpeed = (counterOverall + progressCurrentCombination) / fTime / 1000000;
 307
 308                                 //printf("%.2f%% of combination %d/%d (%.2f Mhashes/s)\t\t\t\t\r", progressPercentageCurrentCombination, countCombinations, countTotalCombinations, currentSpeed);
 309                                 printf("%.2f%% of combination %d/%d (%.2f Mhashes/s)%-30s\r", progressPercentageCurrentCombination, countCombinations, countTotalCombinations, currentSpeed, "");
 310
 311                                 previousClock = clock();
 312                                 #ifdef _WIN32
 313                                 if (_kbhit())
 314                                 {
 315                                         int ch = _getch();
 316                                         ch = toupper(ch);
 317                                         if (ch == 'S')
 318                                         {
 319                                                 aborting = true;
 320                                                 printf( "\nAborting unicode correction for this hash...\n");
 321                                         }
 322                                         else
 323                                         {
 324                                                 printf( "\nPress 'S' to skip unicode correction for this hash...\n");
 325                                         }
 326                                 }
 327                                 #else
 328                                 int c = tty_getchar();
 329                                 if (c >= 0) {
 330                                         tty_flush();
 331                                         if (c==115) { // = s
 332                                                 aborting = true;
 333                                                 printf( "\nAborting unicode correction for this hash...\n");
 334                                         }
 335                                         else {
 336                                                 printf( "\nPress 's' to skip unicode correction for this hash...\n");
 337                                         }
 338                                 }
 339                                 #endif
 340                                 if (aborting)
 341                                         return false;
 342                         }
 343                         counter = 0;
 344                 }
 345
 346                 progressCurrentCombination++;
 347                 counterOverall++;
 348         }
 349         return false;
 350 }
 351
 352 // check password, maybe integrate this function in checkPermutations() for performance reasons.
 353 bool LM2NTLMcorrector::checkNTLMPassword(unsigned char* pLMPassword, int nLMPasswordLen, string& sNTLMPassword)
 354 {
 355         unsigned char md[MD4_DIGEST_LENGTH];
 356
 357         //MD4(pLMPassword, nLMPasswordLen * 2, md);
 358         /*
 359         MD4_CTX ctx;
 360         MD4_Init(&ctx);
 361         MD4_Update(&ctx, pLMPassword, nLMPasswordLen * 2);
 362         MD4_Final(md, &ctx);*/
 363
 364         MD4_NEW( pLMPassword, nLMPasswordLen * 2, md );
 365
 366         if (memcmp(md, NTLMHash, MD4_DIGEST_LENGTH) == 0)
 367         {
 368                 sNTLMPassword = "";
 369                 int i;
 370                 for (i = 0; i < nLMPasswordLen; i++) {
 371                         sNTLMPassword += char(pLMPassword[i * 2]);
 372                 }
 373                 return true;
 374         }
 375         else
 376                 return false;
 377 }
 378
 379 void LM2NTLMcorrector::checkAbort()
 380 {
 381 #ifdef _WIN32
 382         if (_kbhit())
 383         {
 384                 int ch = _getch();
 385                 ch = toupper(ch);
 386                 if (ch == 'S')
 387                 {
 388                         aborting = true;
 389                         printf( "\nAborting unicode correction for this hash...\n");
 390                 }
 391                 else
 392                 {
 393                         printf( "\nPress 'S' to skip unicode correction for this hash...\n");
 394                 }
 395         }
 396 #endif
 397 }
 398
 399 void LM2NTLMcorrector::writeEndStats()
 400 {
 401         clock_t endClock = clock();
 402         if (endClock - startClock > 0)
 403         {
 404                 float fTime = 1.0f * (endClock - startClock) / CLOCKS_PER_SEC;
 405                 float speedOverall = counterOverall / fTime / 1000000;
 406                 printf("\nTried %s passwords in %.2f s (%.2f Mhashes/s)\n", uint64tostr(counterOverall).c_str(), fTime, speedOverall);
 407         }
 408
 409         printf("\n");
 410 }
 411
 412 int LM2NTLMcorrector::calculateTotalCombinations(int length, int setSize)
 413 {
 414         return factorial(length) / (factorial(setSize) * factorial(length-setSize));
 415 }
 416
 417 int LM2NTLMcorrector::factorial (int num)
 418 {
 419         int result = 1;
 420         int i;
 421         for (i = 1; i <= num; ++i)
 422                 result *= i;
 423         return result;
 424 }
 425
 426 // convert some bytes into a string
 427 string LM2NTLMcorrector::ByteToStr(const unsigned char* pData, int nLen)
 428 {
 429         string sRet = "";
 430         int i;
 431         for (i = 0; i < nLen/2; i++)
 432         {
 433                 char szByte[3];
 434                 sprintf(szByte, "%02x", pData[i*2+1]); // swap 2-byte characters again
 435                 sRet += szByte;
 436                 sprintf(szByte, "%02x", pData[i*2]);
 437                 sRet += szByte;
 438         }
 439
 440         return sRet;
 441 }
 442
 443 void LM2NTLMcorrector::addToMapW(unsigned char key, unsigned char value1, unsigned char value2)
 444 {
 445         unsigned long int cnt = m_mapChar[key].size();
 446         m_mapChar[key][cnt] = value2;
 447         m_mapChar[key][cnt+1] = value1; //reverse for endiannes
 448 }
 449
 450 // construct the mappings, would be nicer in a separate (importable) file
 451 void LM2NTLMcorrector::fillMapW()
 452 {
 453         addToMapW(0x01, 0x00, 0x01);
 454         addToMapW(0x01, 0x26, 0x3A);
 455         addToMapW(0x02, 0x00, 0x02);
 456         addToMapW(0x02, 0x26, 0x3B);
 457         addToMapW(0x03, 0x00, 0x03);
 458         addToMapW(0x03, 0x26, 0x65);
 459         addToMapW(0x04, 0x00, 0x04);
 460         addToMapW(0x04, 0x26, 0x66);
 461         addToMapW(0x05, 0x00, 0x05);
 462         addToMapW(0x05, 0x26, 0x63);
 463         addToMapW(0x06, 0x00, 0x06);
 464         addToMapW(0x06, 0x26, 0x60);
 465         addToMapW(0x07, 0x00, 0x07);
 466         addToMapW(0x07, 0x00, 0xB7);
 467         addToMapW(0x07, 0x20, 0x22);
 468         addToMapW(0x07, 0x20, 0x24);
 469         addToMapW(0x07, 0x20, 0x26);
 470         addToMapW(0x07, 0x22, 0x19);
 471         addToMapW(0x07, 0x22, 0xC5);
 472         addToMapW(0x07, 0x30, 0xFB);
 473         addToMapW(0x08, 0x00, 0x08);
 474         addToMapW(0x08, 0x25, 0xD8);
 475         addToMapW(0x09, 0x00, 0x09);
 476         addToMapW(0x09, 0x20, 0xDD);
 477         addToMapW(0x09, 0x25, 0xCB);
 478         addToMapW(0x09, 0x30, 0x07);
 479         addToMapW(0x0a, 0x00, 0x0A);
 480         addToMapW(0x0a, 0x25, 0xD9);
 481         addToMapW(0x0b, 0x00, 0x0B);
 482         addToMapW(0x0b, 0x26, 0x42);
 483         addToMapW(0x0c, 0x00, 0x0C);
 484         addToMapW(0x0c, 0x26, 0x40);
 485         addToMapW(0x0d, 0x00, 0x0D);
 486         addToMapW(0x0d, 0x26, 0x6A);
 487         addToMapW(0x0e, 0x00, 0x0E);
 488         addToMapW(0x0e, 0x26, 0x6B);
 489         addToMapW(0x0f, 0x00, 0x0F);
 490         addToMapW(0x0f, 0x00, 0xA4);
 491         addToMapW(0x0f, 0x26, 0x3C);
 492         addToMapW(0x10, 0x00, 0x10);
 493         addToMapW(0x10, 0x25, 0xBA);
 494         addToMapW(0x11, 0x00, 0x11);
 495         addToMapW(0x11, 0x25, 0xC4);
 496         addToMapW(0x12, 0x00, 0x12);
 497         addToMapW(0x12, 0x21, 0x95);
 498         addToMapW(0x13, 0x00, 0x13);
 499         addToMapW(0x13, 0x20, 0x3C);
 500         addToMapW(0x14, 0x00, 0x14);
 501         addToMapW(0x14, 0x00, 0xB6);
 502         addToMapW(0x15, 0x00, 0x15);
 503         addToMapW(0x15, 0x00, 0xA7);
 504         addToMapW(0x16, 0x00, 0x16);
 505         addToMapW(0x16, 0x02, 0xC9);
 506         addToMapW(0x16, 0x25, 0xAC);
 507         addToMapW(0x17, 0x00, 0x17);
 508         addToMapW(0x17, 0x21, 0xA8);
 509         addToMapW(0x18, 0x00, 0x18);
 510         addToMapW(0x18, 0x21, 0x91);
 511         addToMapW(0x19, 0x00, 0x19);
 512         addToMapW(0x19, 0x21, 0x93);
 513         addToMapW(0x1a, 0x00, 0x1A);
 514         addToMapW(0x1a, 0x21, 0x92);
 515         addToMapW(0x1b, 0x00, 0x1B);
 516         addToMapW(0x1b, 0x21, 0x90);
 517         addToMapW(0x1c, 0x00, 0x1C);
 518         addToMapW(0x1c, 0x22, 0x1F);
 519         addToMapW(0x1d, 0x00, 0x1D);
 520         addToMapW(0x1d, 0x21, 0x94);
 521         addToMapW(0x1e, 0x00, 0x1E);
 522         addToMapW(0x1e, 0x25, 0xB2);
 523         addToMapW(0x1f, 0x00, 0x1F);
 524         addToMapW(0x1f, 0x25, 0xBC);
 525         addToMapW(0x20, 0x00, 0x20);
 526         addToMapW(0x20, 0x20, 0x00);
 527         addToMapW(0x20, 0x20, 0x01);
 528         addToMapW(0x20, 0x20, 0x02);
 529         addToMapW(0x20, 0x20, 0x03);
 530         addToMapW(0x20, 0x20, 0x04);
 531         addToMapW(0x20, 0x20, 0x05);
 532         addToMapW(0x20, 0x20, 0x06);
 533         addToMapW(0x20, 0x30, 0x00);
 534         addToMapW(0x21, 0x00, 0x21);
 535         addToMapW(0x21, 0x00, 0xA1);
 536         addToMapW(0x21, 0x01, 0xC3);
 537         addToMapW(0x21, 0xFF, 0x01);
 538         addToMapW(0x22, 0x00, 0x22);
 539         addToMapW(0x22, 0x00, 0xA8);
 540         addToMapW(0x22, 0x02, 0xBA);
 541         addToMapW(0x22, 0x03, 0x08);
 542         addToMapW(0x22, 0x03, 0x0E);
 543         addToMapW(0x22, 0x20, 0x1C);
 544         addToMapW(0x22, 0x20, 0x1D);
 545         addToMapW(0x22, 0x20, 0x1E);
 546         addToMapW(0x22, 0x20, 0x33);
 547         addToMapW(0x22, 0x20, 0x35);
 548         addToMapW(0x22, 0x27, 0x5D);
 549         addToMapW(0x22, 0x27, 0x5E);
 550         addToMapW(0x22, 0x30, 0x1D);
 551         addToMapW(0x22, 0x30, 0x1E);
 552         addToMapW(0x22, 0x30, 0x1F);
 553         addToMapW(0x22, 0xFF, 0x02);
 554         addToMapW(0x23, 0x00, 0x23);
 555         addToMapW(0x23, 0xFF, 0x03);
 556         addToMapW(0x24, 0x00, 0x24);
 557         addToMapW(0x24, 0xFF, 0x04);
 558         addToMapW(0x25, 0x00, 0x25);
 559         addToMapW(0x25, 0x06, 0x6A);
 560         addToMapW(0x25, 0x20, 0x30);
 561         addToMapW(0x25, 0xFF, 0x05);
 562         addToMapW(0x26, 0x00, 0x26);
 563         addToMapW(0x26, 0xFF, 0x06);
 564         addToMapW(0x27, 0x00, 0x27);
 565         addToMapW(0x27, 0x00, 0xB4);
 566         addToMapW(0x27, 0x02, 0xB9);
 567         addToMapW(0x27, 0x02, 0xBB);
 568         addToMapW(0x27, 0x02, 0xBC);
 569         addToMapW(0x27, 0x02, 0xC8);
 570         addToMapW(0x27, 0x02, 0xCA);
 571         addToMapW(0x27, 0x02, 0xCB);
 572         addToMapW(0x27, 0x03, 0x00);
 573         addToMapW(0x27, 0x03, 0x01);
 574         addToMapW(0x27, 0x20, 0x18);
 575         addToMapW(0x27, 0x20, 0x19);
 576         addToMapW(0x27, 0x20, 0x1A);
 577         addToMapW(0x27, 0x20, 0x32);
 578         addToMapW(0x27, 0x27, 0x5B);
 579         addToMapW(0x27, 0x27, 0x5C);
 580         addToMapW(0x27, 0xFF, 0x07);
 581         addToMapW(0x28, 0x00, 0x28);
 582         addToMapW(0x28, 0x23, 0x20);
 583         addToMapW(0x28, 0xFF, 0x08);
 584         addToMapW(0x29, 0x00, 0x29);
 585         addToMapW(0x29, 0x23, 0x21);
 586         addToMapW(0x29, 0xFF, 0x09);
 587         addToMapW(0x2a, 0x00, 0x2A);
 588         addToMapW(0x2a, 0x22, 0x17);
 589         addToMapW(0x2a, 0xFF, 0x0A);
 590         addToMapW(0x2b, 0x00, 0x2B);
 591         addToMapW(0x2b, 0x00, 0xB1);
 592         addToMapW(0x2b, 0x20, 0x20);
 593         addToMapW(0x2b, 0x20, 0x21);
 594         addToMapW(0x2b, 0xFF, 0x0B);
 595         addToMapW(0x2c, 0x00, 0x2C);
 596         addToMapW(0x2c, 0x00, 0xB8);
 597         addToMapW(0x2c, 0x03, 0x27);
 598         addToMapW(0x2c, 0x20, 0x1A);
 599         addToMapW(0x2c, 0x20, 0x1E);
 600         addToMapW(0x2c, 0xFF, 0x0C);
 601         addToMapW(0x2d, 0x00, 0x2D);
 602         addToMapW(0x2d, 0x00, 0xAC);
 603         addToMapW(0x2d, 0x00, 0xAD);
 604         addToMapW(0x2d, 0x20, 0x10);
 605         addToMapW(0x2d, 0x20, 0x11);
 606         addToMapW(0x2d, 0x20, 0x13);
 607         addToMapW(0x2d, 0x20, 0x14);
 608         addToMapW(0x2d, 0x22, 0x12);
 609         addToMapW(0x2d, 0x22, 0x13);
 610         addToMapW(0x2d, 0xFF, 0x0D);
 611         addToMapW(0x2e, 0x00, 0x2E);
 612         addToMapW(0x2e, 0x20, 0x26);
 613         addToMapW(0x2e, 0xFF, 0x0E);
 614         addToMapW(0x2f, 0x00, 0x2F);
 615         addToMapW(0x2f, 0x20, 0x44);
 616         addToMapW(0x2f, 0x22, 0x15);
 617         addToMapW(0x2f, 0x22, 0x16);
 618         addToMapW(0x2f, 0xFF, 0x0F);
 619         addToMapW(0x30, 0x00, 0x30);
 620         addToMapW(0x30, 0x20, 0x70);
 621         addToMapW(0x30, 0x20, 0x80);
 622         addToMapW(0x30, 0xFF, 0x10);
 623         addToMapW(0x31, 0x00, 0x31);
 624         addToMapW(0x31, 0x00, 0xB9);
 625         addToMapW(0x31, 0x00, 0xBC);
 626         addToMapW(0x31, 0x00, 0xBD);
 627         addToMapW(0x31, 0x20, 0x81);
 628         addToMapW(0x31, 0xFF, 0x11);
 629         addToMapW(0x32, 0x00, 0x32);
 630         addToMapW(0x32, 0x00, 0xB2);
 631         addToMapW(0x32, 0x20, 0x82);
 632         addToMapW(0x32, 0xFF, 0x12);
 633         addToMapW(0x33, 0x00, 0x33);
 634         addToMapW(0x33, 0x00, 0xB3);
 635         addToMapW(0x33, 0x00, 0xBE);
 636         addToMapW(0x33, 0x20, 0x83);
 637         addToMapW(0x33, 0xFF, 0x13);
 638         addToMapW(0x34, 0x00, 0x34);
 639         addToMapW(0x34, 0x20, 0x74);
 640         addToMapW(0x34, 0x20, 0x84);
 641         addToMapW(0x34, 0xFF, 0x14);
 642         addToMapW(0x35, 0x00, 0x35);
 643         addToMapW(0x35, 0x20, 0x75);
 644         addToMapW(0x35, 0x20, 0x85);
 645         addToMapW(0x35, 0xFF, 0x15);
 646         addToMapW(0x36, 0x00, 0x36);
 647         addToMapW(0x36, 0x20, 0x76);
 648         addToMapW(0x36, 0x20, 0x86);
 649         addToMapW(0x36, 0xFF, 0x16);
 650         addToMapW(0x37, 0x00, 0x37);
 651         addToMapW(0x37, 0x20, 0x77);
 652         addToMapW(0x37, 0x20, 0x87);
 653         addToMapW(0x37, 0xFF, 0x17);
 654         addToMapW(0x38, 0x00, 0x38);
 655         addToMapW(0x38, 0x20, 0x78);
 656         addToMapW(0x38, 0x20, 0x88);
 657         addToMapW(0x38, 0x22, 0x1E);
 658         addToMapW(0x38, 0xFF, 0x18);
 659         addToMapW(0x39, 0x00, 0x39);
 660         addToMapW(0x39, 0x20, 0x78);
 661         addToMapW(0x39, 0x20, 0x89);
 662         addToMapW(0x39, 0xFF, 0x19);
 663         addToMapW(0x3a, 0x00, 0x3A);
 664         addToMapW(0x3a, 0x05, 0x89);
 665         addToMapW(0x3a, 0x20, 0x26);
 666         addToMapW(0x3a, 0x22, 0x36);
 667         addToMapW(0x3a, 0xFF, 0x1A);
 668         addToMapW(0x3b, 0x00, 0x3B);
 669         addToMapW(0x3b, 0x03, 0x7E);
 670         addToMapW(0x3b, 0xFF, 0x1B);
 671         addToMapW(0x3c, 0x00, 0x3C);
 672         addToMapW(0x3c, 0x00, 0xAB);
 673         addToMapW(0x3c, 0x20, 0x39);
 674         addToMapW(0x3c, 0x23, 0x29);
 675         addToMapW(0x3c, 0x30, 0x08);
 676         addToMapW(0x3c, 0xFF, 0x1C);
 677         addToMapW(0x3d, 0x00, 0x3D);
 678         addToMapW(0x3d, 0x22, 0x61);
 679         addToMapW(0x3d, 0x22, 0x64);
 680         addToMapW(0x3d, 0x22, 0x65);
 681         addToMapW(0x3d, 0xFF, 0x1D);
 682         addToMapW(0x3e, 0x00, 0x3E);
 683         addToMapW(0x3e, 0x00, 0xBB);
 684         addToMapW(0x3e, 0x20, 0x3A);
 685         addToMapW(0x3e, 0x23, 0x2A);
 686         addToMapW(0x3e, 0x30, 0x09);
 687         addToMapW(0x3e, 0xFF, 0x1E);
 688         addToMapW(0x3f, 0x00, 0x3F);
 689         addToMapW(0x40, 0x00, 0x40);
 690         addToMapW(0x40, 0xFF, 0x20);
 691         addToMapW(0x41, 0x00, 0x41);
 692         addToMapW(0x41, 0x00, 0x61);
 693         addToMapW(0x41, 0x00, 0xAA);
 694         addToMapW(0x41, 0x00, 0xC0);
 695         addToMapW(0x41, 0x00, 0xC1);
 696         addToMapW(0x41, 0x00, 0xC2);
 697         addToMapW(0x41, 0x00, 0xC3);
 698         addToMapW(0x41, 0x00, 0xC4);
 699         addToMapW(0x41, 0x00, 0xC5);
 700         addToMapW(0x41, 0x00, 0xC6);
 701         addToMapW(0x41, 0x00, 0xE0);
 702         addToMapW(0x41, 0x00, 0xE1);
 703         addToMapW(0x41, 0x00, 0xE2);
 704         addToMapW(0x41, 0x00, 0xE3);
 705         addToMapW(0x41, 0x00, 0xE4);
 706         addToMapW(0x41, 0x00, 0xE5);
 707         addToMapW(0x41, 0x00, 0xE6);
 708         addToMapW(0x41, 0x01, 0x00);
 709         addToMapW(0x41, 0x01, 0x01);
 710         addToMapW(0x41, 0x01, 0x02);
 711         addToMapW(0x41, 0x01, 0x03);
 712         addToMapW(0x41, 0x01, 0x04);
 713         addToMapW(0x41, 0x01, 0x05);
 714         addToMapW(0x41, 0x01, 0xCD);
 715         addToMapW(0x41, 0x01, 0xCE);
 716         addToMapW(0x41, 0x01, 0xDE);
 717         addToMapW(0x41, 0x01, 0xDF);
 718         addToMapW(0x41, 0x03, 0xB1);
 719         addToMapW(0x41, 0x21, 0x2B);
 720         addToMapW(0x41, 0xFF, 0x21);
 721         addToMapW(0x41, 0xFF, 0x41);
 722         addToMapW(0x42, 0x00, 0x42);
 723         addToMapW(0x42, 0x00, 0x62);
 724         addToMapW(0x42, 0x01, 0x80);
 725         addToMapW(0x42, 0x21, 0x2C);
 726         addToMapW(0x42, 0xFF, 0x22);
 727         addToMapW(0x42, 0xFF, 0x42);
 728         addToMapW(0x43, 0x00, 0x43);
 729         addToMapW(0x43, 0x00, 0x63);
 730         addToMapW(0x43, 0x00, 0xA2);
 731         addToMapW(0x43, 0x00, 0xA9);
 732         addToMapW(0x43, 0x00, 0xC7);
 733         addToMapW(0x43, 0x00, 0xE7);
 734         addToMapW(0x43, 0x00, 0xE8);
 735         addToMapW(0x43, 0x01, 0x06);
 736         addToMapW(0x43, 0x01, 0x07);
 737         addToMapW(0x43, 0x01, 0x08);
 738         addToMapW(0x43, 0x01, 0x09);
 739         addToMapW(0x43, 0x01, 0x0A);
 740         addToMapW(0x43, 0x01, 0x0B);
 741         addToMapW(0x43, 0x01, 0x0C);
 742         addToMapW(0x43, 0x01, 0x0D);
 743         addToMapW(0x43, 0x21, 0x02);
 744         addToMapW(0x43, 0x21, 0x2D);
 745         addToMapW(0x43, 0xFF, 0x23);
 746         addToMapW(0x43, 0xFF, 0x43);
 747         addToMapW(0x44, 0x00, 0x44);
 748         addToMapW(0x44, 0x00, 0x64);
 749         addToMapW(0x44, 0x00, 0xD0);
 750         addToMapW(0x44, 0x00, 0xF0);
 751         addToMapW(0x44, 0x01, 0x0E);
 752         addToMapW(0x44, 0x01, 0x0F);
 753         addToMapW(0x44, 0x01, 0x10);
 754         addToMapW(0x44, 0x01, 0x11);
 755         addToMapW(0x44, 0x01, 0x89);
 756         addToMapW(0x44, 0x03, 0xB4);
 757         addToMapW(0x44, 0x26, 0x6A);
 758         addToMapW(0x44, 0x26, 0x6B);
 759         addToMapW(0x44, 0xFF, 0x24);
 760         addToMapW(0x44, 0xFF, 0x44);
 761         addToMapW(0x45, 0x00, 0x45);
 762         addToMapW(0x45, 0x00, 0x65);
 763         addToMapW(0x45, 0x00, 0xC8);
 764         addToMapW(0x45, 0x00, 0xC9);
 765         addToMapW(0x45, 0x00, 0xCA);
 766         addToMapW(0x45, 0x00, 0xCB);
 767         addToMapW(0x45, 0x00, 0xE8);
 768         addToMapW(0x45, 0x00, 0xE9);
 769         addToMapW(0x45, 0x00, 0xEA);
 770         addToMapW(0x45, 0x00, 0xEB);
 771         addToMapW(0x45, 0x01, 0x12);
 772         addToMapW(0x45, 0x01, 0x13);
 773         addToMapW(0x45, 0x01, 0x14);
 774         addToMapW(0x45, 0x01, 0x15);
 775         addToMapW(0x45, 0x01, 0x16);
 776         addToMapW(0x45, 0x01, 0x17);
 777         addToMapW(0x45, 0x01, 0x18);
 778         addToMapW(0x45, 0x01, 0x19);
 779         addToMapW(0x45, 0x01, 0x1A);
 780         addToMapW(0x45, 0x01, 0x1B);
 781         addToMapW(0x45, 0x03, 0xB5);
 782         addToMapW(0x45, 0x21, 0x07);
 783         addToMapW(0x45, 0x21, 0x2E);
 784         addToMapW(0x45, 0x21, 0x2F);
 785         addToMapW(0x45, 0x21, 0x30);
 786         addToMapW(0x45, 0xFF, 0x25);
 787         addToMapW(0x45, 0xFF, 0x45);
 788         addToMapW(0x46, 0x00, 0x46);
 789         addToMapW(0x46, 0x00, 0x66);
 790         addToMapW(0x46, 0x01, 0x91);
 791         addToMapW(0x46, 0x01, 0x92);
 792         addToMapW(0x46, 0x03, 0xA6);
 793         addToMapW(0x46, 0x03, 0xC6);
 794         addToMapW(0x46, 0x21, 0x31);
 795         addToMapW(0x46, 0xFF, 0x26);
 796         addToMapW(0x46, 0xFF, 0x46);
 797         addToMapW(0x47, 0x00, 0x47);
 798         addToMapW(0x47, 0x00, 0x67);
 799         addToMapW(0x47, 0x01, 0x1C);
 800         addToMapW(0x47, 0x01, 0x1D);
 801         addToMapW(0x47, 0x01, 0x1E);
 802         addToMapW(0x47, 0x01, 0x1F);
 803         addToMapW(0x47, 0x01, 0x20);
 804         addToMapW(0x47, 0x01, 0x21);
 805         addToMapW(0x47, 0x01, 0x22);
 806         addToMapW(0x47, 0x01, 0x23);
 807         addToMapW(0x47, 0x01, 0xE4);
 808         addToMapW(0x47, 0x01, 0xE5);
 809         addToMapW(0x47, 0x01, 0xE6);
 810         addToMapW(0x47, 0x01, 0xE7);
 811         addToMapW(0x47, 0x02, 0x61);
 812         addToMapW(0x47, 0x03, 0x93);
 813         addToMapW(0x47, 0x21, 0x0A);
 814         addToMapW(0x47, 0xFF, 0x27);
 815         addToMapW(0x47, 0xFF, 0x47);
 816         addToMapW(0x48, 0x00, 0x48);
 817         addToMapW(0x48, 0x00, 0x68);
 818         addToMapW(0x48, 0x01, 0x24);
 819         addToMapW(0x48, 0x01, 0x25);
 820         addToMapW(0x48, 0x01, 0x26);
 821         addToMapW(0x48, 0x01, 0x27);
 822         addToMapW(0x48, 0x04, 0xBB);
 823         addToMapW(0x48, 0x21, 0x0B);
 824         addToMapW(0x48, 0x21, 0x0C);
 825         addToMapW(0x48, 0x21, 0x0D);
 826         addToMapW(0x48, 0x21, 0x0E);
 827         addToMapW(0x48, 0xFF, 0x28);
 828         addToMapW(0x48, 0xFF, 0x48);
 829         addToMapW(0x49, 0x00, 0x49);
 830         addToMapW(0x49, 0x00, 0x69);
 831         addToMapW(0x49, 0x00, 0xCC);
 832         addToMapW(0x49, 0x00, 0xCD);
 833         addToMapW(0x49, 0x00, 0xCE);
 834         addToMapW(0x49, 0x00, 0xCF);
 835         addToMapW(0x49, 0x00, 0xEC);
 836         addToMapW(0x49, 0x00, 0xED);
 837         addToMapW(0x49, 0x00, 0xEE);
 838         addToMapW(0x49, 0x00, 0xEF);
 839         addToMapW(0x49, 0x01, 0x28);
 840         addToMapW(0x49, 0x01, 0x29);
 841         addToMapW(0x49, 0x01, 0x2A);
 842         addToMapW(0x49, 0x01, 0x2B);
 843         addToMapW(0x49, 0x01, 0x2C);
 844         addToMapW(0x49, 0x01, 0x2D);
 845         addToMapW(0x49, 0x01, 0x2E);
 846         addToMapW(0x49, 0x01, 0x2F);
 847         addToMapW(0x49, 0x01, 0x30);
 848         addToMapW(0x49, 0x01, 0x31);
 849         addToMapW(0x49, 0x01, 0x97);
 850         addToMapW(0x49, 0x01, 0xCF);
 851         addToMapW(0x49, 0x01, 0xD0);
 852         addToMapW(0x49, 0x21, 0x10);
 853         addToMapW(0x49, 0x21, 0x11);
 854         addToMapW(0x49, 0xFF, 0x29);
 855         addToMapW(0x49, 0xFF, 0x49);
 856         addToMapW(0x4a, 0x00, 0x4A);
 857         addToMapW(0x4a, 0x00, 0x6A);
 858         addToMapW(0x4a, 0x01, 0x34);
 859         addToMapW(0x4a, 0x01, 0x35);
 860         addToMapW(0x4a, 0x01, 0xF0);
 861         addToMapW(0x4a, 0xFF, 0x2A);
 862         addToMapW(0x4a, 0xFF, 0x4A);
 863         addToMapW(0x4b, 0x00, 0x4B);
 864         addToMapW(0x4b, 0x00, 0x6B);
 865         addToMapW(0x4b, 0x01, 0x36);
 866         addToMapW(0x4b, 0x01, 0x37);
 867         addToMapW(0x4b, 0x01, 0xE8);
 868         addToMapW(0x4b, 0x01, 0xE9);
 869         addToMapW(0x4b, 0x21, 0x2A);
 870         addToMapW(0x4b, 0xFF, 0x2B);
 871         addToMapW(0x4b, 0xFF, 0x4B);
 872         addToMapW(0x4c, 0x00, 0x4C);
 873         addToMapW(0x4c, 0x00, 0x6C);
 874         addToMapW(0x4c, 0x00, 0xA3);
 875         addToMapW(0x4c, 0x01, 0x39);
 876         addToMapW(0x4c, 0x01, 0x3A);
 877         addToMapW(0x4c, 0x01, 0x3B);
 878         addToMapW(0x4c, 0x01, 0x3C);
 879         addToMapW(0x4c, 0x01, 0x3D);
 880         addToMapW(0x4c, 0x01, 0x3E);
 881         addToMapW(0x4c, 0x01, 0x41);
 882         addToMapW(0x4c, 0x01, 0x42);
 883         addToMapW(0x4c, 0x01, 0x9A);
 884         addToMapW(0x4c, 0x20, 0xA4);
 885         addToMapW(0x4c, 0x21, 0x12);
 886         addToMapW(0x4c, 0x21, 0x13);
 887         addToMapW(0x4c, 0xFF, 0x2C);
 888         addToMapW(0x4c, 0xFF, 0x4C);
 889         addToMapW(0x4d, 0x00, 0x4D);
 890         addToMapW(0x4d, 0x00, 0x6D);
 891         addToMapW(0x4d, 0x21, 0x33);
 892         addToMapW(0x4d, 0xFF, 0x2D);
 893         addToMapW(0x4d, 0xFF, 0x4D);
 894         addToMapW(0x4e, 0x00, 0x4E);
 895         addToMapW(0x4e, 0x00, 0x6E);
 896         addToMapW(0x4e, 0x00, 0xD1);
 897         addToMapW(0x4e, 0x00, 0xF1);
 898         addToMapW(0x4e, 0x01, 0x43);
 899         addToMapW(0x4e, 0x01, 0x44);
 900         addToMapW(0x4e, 0x01, 0x45);
 901         addToMapW(0x4e, 0x01, 0x46);
 902         addToMapW(0x4e, 0x01, 0x47);
 903         addToMapW(0x4e, 0x01, 0x48);
 904         addToMapW(0x4e, 0x20, 0x7F);
 905         addToMapW(0x4e, 0x21, 0x15);
 906         addToMapW(0x4e, 0x22, 0x29);
 907         addToMapW(0x4e, 0xFF, 0x2E);
 908         addToMapW(0x4e, 0xFF, 0x4E);
 909         addToMapW(0x4f, 0x00, 0x4F);
 910         addToMapW(0x4f, 0x00, 0x6F);
 911         addToMapW(0x4f, 0x00, 0xB0);
 912         addToMapW(0x4f, 0x00, 0xBA);
 913         addToMapW(0x4f, 0x00, 0xD2);
 914         addToMapW(0x4f, 0x00, 0xD3);
 915         addToMapW(0x4f, 0x00, 0xD4);
 916         addToMapW(0x4f, 0x00, 0xD5);
 917         addToMapW(0x4f, 0x00, 0xD6);
 918         addToMapW(0x4f, 0x00, 0xD8);
 919         addToMapW(0x4f, 0x00, 0xF2);
 920         addToMapW(0x4f, 0x00, 0xF3);
 921         addToMapW(0x4f, 0x00, 0xF4);
 922         addToMapW(0x4f, 0x00, 0xF5);
 923         addToMapW(0x4f, 0x00, 0xF6);
 924         addToMapW(0x4f, 0x00, 0xF8);
 925         addToMapW(0x4f, 0x01, 0x4C);
 926         addToMapW(0x4f, 0x01, 0x4D);
 927         addToMapW(0x4f, 0x01, 0x4E);
 928         addToMapW(0x4f, 0x01, 0x4F);
 929         addToMapW(0x4f, 0x01, 0x50);
 930         addToMapW(0x4f, 0x01, 0x51);
 931         addToMapW(0x4f, 0x01, 0x52);
 932         addToMapW(0x4f, 0x01, 0x53);
 933         addToMapW(0x4f, 0x01, 0x9F);
 934         addToMapW(0x4f, 0x01, 0xA0);
 935         addToMapW(0x4f, 0x01, 0xA1);
 936         addToMapW(0x4f, 0x01, 0xD1);
 937         addToMapW(0x4f, 0x01, 0xD2);
 938         addToMapW(0x4f, 0x01, 0xEA);
 939         addToMapW(0x4f, 0x01, 0xEB);
 940         addToMapW(0x4f, 0x01, 0xEC);
 941         addToMapW(0x4f, 0x01, 0xED);
 942         addToMapW(0x4f, 0x03, 0xA9);
 943         addToMapW(0x4f, 0x20, 0xDD);
 944         addToMapW(0x4f, 0x21, 0x26);
 945         addToMapW(0x4f, 0x21, 0x34);
 946         addToMapW(0x4f, 0x22, 0x05);
 947         addToMapW(0x4f, 0x30, 0x07);
 948         addToMapW(0x4f, 0xFF, 0x2F);
 949         addToMapW(0x4f, 0xFF, 0x4F);
 950         addToMapW(0x50, 0x00, 0x50);
 951         addToMapW(0x50, 0x00, 0x70);
 952         addToMapW(0x50, 0x03, 0xC0);
 953         addToMapW(0x50, 0x20, 0xA7);
 954         addToMapW(0x50, 0x21, 0x18);
 955         addToMapW(0x50, 0x21, 0x19);
 956         addToMapW(0x50, 0xFF, 0x30);
 957         addToMapW(0x50, 0xFF, 0x50);
 958         addToMapW(0x51, 0x00, 0x51);
 959         addToMapW(0x51, 0x00, 0x71);
 960         addToMapW(0x51, 0x21, 0x1A);
 961         addToMapW(0x51, 0xFF, 0x31);
 962         addToMapW(0x51, 0xFF, 0x51);
 963         addToMapW(0x52, 0x00, 0x52);
 964         addToMapW(0x52, 0x00, 0x72);
 965         addToMapW(0x52, 0x00, 0xAE);
 966         addToMapW(0x52, 0x01, 0x54);
 967         addToMapW(0x52, 0x01, 0x55);
 968         addToMapW(0x52, 0x01, 0x56);
 969         addToMapW(0x52, 0x01, 0x57);
 970         addToMapW(0x52, 0x01, 0x58);
 971         addToMapW(0x52, 0x01, 0x59);
 972         addToMapW(0x52, 0x21, 0x1B);
 973         addToMapW(0x52, 0x21, 0x1C);
 974         addToMapW(0x52, 0x21, 0x1D);
 975         addToMapW(0x52, 0xFF, 0x32);
 976         addToMapW(0x52, 0xFF, 0x52);
 977         addToMapW(0x53, 0x00, 0x53);
 978         addToMapW(0x53, 0x00, 0x73);
 979         addToMapW(0x53, 0x00, 0xDF);
 980         addToMapW(0x53, 0x01, 0x5A);
 981         addToMapW(0x53, 0x01, 0x5B);
 982         addToMapW(0x53, 0x01, 0x5C);
 983         addToMapW(0x53, 0x01, 0x5D);
 984         addToMapW(0x53, 0x01, 0x5E);
 985         addToMapW(0x53, 0x01, 0x5F);
 986         addToMapW(0x53, 0x01, 0x60);
 987         addToMapW(0x53, 0x01, 0x61);
 988         addToMapW(0x53, 0x01, 0xA9);
 989         addToMapW(0x53, 0x03, 0xA3);
 990         addToMapW(0x53, 0x03, 0xC3);
 991         addToMapW(0x53, 0x22, 0x11);
 992         addToMapW(0x53, 0xFF, 0x33);
 993         addToMapW(0x53, 0xFF, 0x53);
 994         addToMapW(0x54, 0x00, 0x54);
 995         addToMapW(0x54, 0x00, 0x74);
 996         addToMapW(0x54, 0x00, 0xDE);
 997         addToMapW(0x54, 0x00, 0xFE);
 998         addToMapW(0x54, 0x01, 0x62);
 999         addToMapW(0x54, 0x01, 0x63);
1000         addToMapW(0x54, 0x01, 0x64);
1001         addToMapW(0x54, 0x01, 0x65);
1002         addToMapW(0x54, 0x01, 0x66);
1003         addToMapW(0x54, 0x01, 0x67);
1004         addToMapW(0x54, 0x01, 0xAB);
1005         addToMapW(0x54, 0x01, 0xAE);
1006         addToMapW(0x54, 0x03, 0xC4);
1007         addToMapW(0x54, 0x21, 0x22);
1008         addToMapW(0x54, 0xFF, 0x34);
1009         addToMapW(0x54, 0xFF, 0x54);
1010         addToMapW(0x55, 0x00, 0x55);
1011         addToMapW(0x55, 0x00, 0x75);
1012         addToMapW(0x55, 0x00, 0xB5);
1013         addToMapW(0x55, 0x00, 0xD9);
1014         addToMapW(0x55, 0x00, 0xDA);
1015         addToMapW(0x55, 0x00, 0xDB);
1016         addToMapW(0x55, 0x00, 0xDC);
1017         addToMapW(0x55, 0x00, 0xF9);
1018         addToMapW(0x55, 0x00, 0xFA);
1019         addToMapW(0x55, 0x00, 0xFB);
1020         addToMapW(0x55, 0x00, 0xFC);
1021         addToMapW(0x55, 0x01, 0x68);
1022         addToMapW(0x55, 0x01, 0x69);
1023         addToMapW(0x55, 0x01, 0x6A);
1024         addToMapW(0x55, 0x01, 0x6B);
1025         addToMapW(0x55, 0x01, 0x6C);
1026         addToMapW(0x55, 0x01, 0x6D);
1027         addToMapW(0x55, 0x01, 0x6E);
1028         addToMapW(0x55, 0x01, 0x6F);
1029         addToMapW(0x55, 0x01, 0x70);
1030         addToMapW(0x55, 0x01, 0x71);
1031         addToMapW(0x55, 0x01, 0x72);
1032         addToMapW(0x55, 0x01, 0x73);
1033         addToMapW(0x55, 0x01, 0xAF);
1034         addToMapW(0x55, 0x01, 0xB0);
1035         addToMapW(0x55, 0x01, 0xD3);
1036         addToMapW(0x55, 0x01, 0xD4);
1037         addToMapW(0x55, 0x01, 0xD5);
1038         addToMapW(0x55, 0x01, 0xD6);
1039         addToMapW(0x55, 0x01, 0xD7);
1040         addToMapW(0x55, 0x01, 0xD8);
1041         addToMapW(0x55, 0x01, 0xD9);
1042         addToMapW(0x55, 0x01, 0xDA);
1043         addToMapW(0x55, 0x01, 0xDB);
1044         addToMapW(0x55, 0x01, 0xDC);
1045         addToMapW(0x55, 0x03, 0xBC);
1046         addToMapW(0x55, 0xFF, 0x35);
1047         addToMapW(0x55, 0xFF, 0x55);
1048         addToMapW(0x56, 0x00, 0x56);
1049         addToMapW(0x56, 0x00, 0x76);
1050         addToMapW(0x56, 0x22, 0x1A);
1051         addToMapW(0x56, 0x27, 0x13);
1052         addToMapW(0x56, 0xFF, 0x36);
1053         addToMapW(0x56, 0xFF, 0x56);
1054         addToMapW(0x57, 0x00, 0x57);
1055         addToMapW(0x57, 0x00, 0x77);
1056         addToMapW(0x57, 0x01, 0x74);
1057         addToMapW(0x57, 0x01, 0x75);
1058         addToMapW(0x57, 0xFF, 0x37);
1059         addToMapW(0x57, 0xFF, 0x57);
1060         addToMapW(0x58, 0x00, 0x58);
1061         addToMapW(0x58, 0x00, 0x78);
1062         addToMapW(0x58, 0x00, 0xD7);
1063         addToMapW(0x58, 0xFF, 0x38);
1064         addToMapW(0x58, 0xFF, 0x58);
1065         addToMapW(0x59, 0x00, 0x59);
1066         addToMapW(0x59, 0x00, 0x79);
1067         addToMapW(0x59, 0x00, 0xA5);
1068         addToMapW(0x59, 0x00, 0xDD);
1069         addToMapW(0x59, 0x00, 0xFD);
1070         addToMapW(0x59, 0x00, 0xFF);
1071         addToMapW(0x59, 0x01, 0x76);
1072         addToMapW(0x59, 0x01, 0x77);
1073         addToMapW(0x59, 0x01, 0x78);
1074         addToMapW(0x59, 0xFF, 0x39);
1075         addToMapW(0x59, 0xFF, 0x59);
1076         addToMapW(0x5a, 0x00, 0x5A);
1077         addToMapW(0x5a, 0x00, 0x7A);
1078         addToMapW(0x5a, 0x01, 0x79);
1079         addToMapW(0x5a, 0x01, 0x7A);
1080         addToMapW(0x5a, 0x01, 0x7B);
1081         addToMapW(0x5a, 0x01, 0x7C);
1082         addToMapW(0x5a, 0x01, 0x7D);
1083         addToMapW(0x5a, 0x01, 0x7E);
1084         addToMapW(0x5a, 0x01, 0xB6);
1085         addToMapW(0x5a, 0x21, 0x24);
1086         addToMapW(0x5a, 0x21, 0x28);
1087         addToMapW(0x5a, 0xFF, 0x3A);
1088         addToMapW(0x5a, 0xFF, 0x5A);
1089         addToMapW(0x5b, 0x00, 0x5B);
1090         addToMapW(0x5b, 0x30, 0x1A);
1091         addToMapW(0x5b, 0xFF, 0x3B);
1092         addToMapW(0x5c, 0x00, 0x5C);
1093         addToMapW(0x5c, 0x00, 0xA5);
1094         addToMapW(0x5c, 0x22, 0x16);
1095         addToMapW(0x5c, 0xFF, 0x3C);
1096         addToMapW(0x5d, 0x00, 0x5D);
1097         addToMapW(0x5d, 0x30, 0x1B);
1098         addToMapW(0x5d, 0xFF, 0x3D);
1099         addToMapW(0x5e, 0x00, 0x5E);
1100         addToMapW(0x5e, 0x02, 0xC4);
1101         addToMapW(0x5e, 0x02, 0xC6);
1102         addToMapW(0x5e, 0x02, 0xC7);
1103         addToMapW(0x5e, 0x02, 0xD8);
1104         addToMapW(0x5e, 0x03, 0x02);
1105         addToMapW(0x5e, 0x03, 0x06);
1106         addToMapW(0x5e, 0x03, 0x0C);
1107         addToMapW(0x5e, 0x23, 0x03);
1108         addToMapW(0x5e, 0xFF, 0x3E);
1109         addToMapW(0x5f, 0x00, 0x5F);
1110         addToMapW(0x5f, 0x00, 0xAF);
1111         addToMapW(0x5f, 0x00, 0xBE);
1112         addToMapW(0x5f, 0x00, 0xDE);
1113         addToMapW(0x5f, 0x00, 0xFE);
1114         addToMapW(0x5f, 0x02, 0xCD);
1115         addToMapW(0x5f, 0x03, 0x31);
1116         addToMapW(0x5f, 0x03, 0x32);
1117         addToMapW(0x5f, 0x20, 0x17);
1118         addToMapW(0x5f, 0x30, 0xFC);
1119         addToMapW(0x5f, 0xFF, 0x3F);
1120         addToMapW(0x60, 0x00, 0x60);
1121         addToMapW(0x60, 0x02, 0xCB);
1122         addToMapW(0x60, 0x03, 0x00);
1123         addToMapW(0x60, 0x20, 0x18);
1124         addToMapW(0x60, 0x20, 0x35);
1125         addToMapW(0x60, 0xFF, 0x40);
1126         addToMapW(0x7b, 0x00, 0x7B);
1127         addToMapW(0x7b, 0xFF, 0x5B);
1128         addToMapW(0x7c, 0x00, 0x7C);
1129         addToMapW(0x7c, 0x00, 0xA6);
1130         addToMapW(0x7c, 0x01, 0xC0);
1131         addToMapW(0x7c, 0x22, 0x23);
1132         addToMapW(0x7c, 0x27, 0x58);
1133         addToMapW(0x7c, 0xFF, 0x5C);
1134         addToMapW(0x7d, 0x00, 0x7D);
1135         addToMapW(0x7d, 0x30, 0x1B);
1136         addToMapW(0x7d, 0xFF, 0x5D);
1137         addToMapW(0x7e, 0x00, 0x7E);
1138         addToMapW(0x7e, 0x02, 0xDC);
1139         addToMapW(0x7e, 0x03, 0x03);
1140         addToMapW(0x7e, 0x22, 0x3C);
1141         addToMapW(0x7e, 0x22, 0x48);
1142         addToMapW(0x7e, 0xFF, 0x5E);
1143         addToMapW(0x7f, 0x00, 0x7F);
1144         addToMapW(0x7f, 0x23, 0x02);
1145         addToMapW(0x7f, 0x26, 0x60);
1146         addToMapW(0x7f, 0x26, 0x63);
1147         addToMapW(0x7f, 0x26, 0x65);
1148         addToMapW(0x7f, 0x26, 0x66);
1149         addToMapW(0x80, 0x00, 0x80);
1150         addToMapW(0x80, 0x00, 0xC7);
1151         addToMapW(0x80, 0x00, 0xE7);
1152         addToMapW(0x80, 0x01, 0x06);
1153         addToMapW(0x80, 0x01, 0x07);
1154         addToMapW(0x80, 0x03, 0x91);
1155         addToMapW(0x80, 0x03, 0xB1);
1156         addToMapW(0x80, 0x04, 0x10);
1157         addToMapW(0x80, 0x04, 0x30);
1158         addToMapW(0x80, 0x05, 0xD0);
1159         addToMapW(0x80, 0x20, 0xAC);
1160         addToMapW(0x81, 0x00, 0x81);
1161         addToMapW(0x81, 0x03, 0x92);
1162         addToMapW(0x81, 0x03, 0xB2);
1163         addToMapW(0x81, 0x04, 0x02);
1164         addToMapW(0x81, 0x04, 0x11);
1165         addToMapW(0x81, 0x04, 0x31);
1166         addToMapW(0x81, 0x04, 0x52);
1167         addToMapW(0x81, 0x05, 0xD1);
1168         addToMapW(0x82, 0x00, 0x82);
1169         addToMapW(0x82, 0x03, 0x93);
1170         addToMapW(0x82, 0x03, 0xB3);
1171         addToMapW(0x82, 0x04, 0x12);
1172         addToMapW(0x82, 0x04, 0x32);
1173         addToMapW(0x82, 0x05, 0xD2);
1174         addToMapW(0x82, 0x20, 0x1A);
1175         addToMapW(0x83, 0x00, 0x83);
1176         addToMapW(0x83, 0x03, 0x94);
1177         addToMapW(0x83, 0x03, 0xB4);
1178         addToMapW(0x83, 0x04, 0x03);
1179         addToMapW(0x83, 0x04, 0x13);
1180         addToMapW(0x83, 0x04, 0x33);
1181         addToMapW(0x83, 0x04, 0x53);
1182         addToMapW(0x83, 0x05, 0xD3);
1183         addToMapW(0x84, 0x00, 0x84);
1184         addToMapW(0x84, 0x03, 0x95);
1185         addToMapW(0x84, 0x03, 0xB5);
1186         addToMapW(0x84, 0x04, 0x14);
1187         addToMapW(0x84, 0x04, 0x34);
1188         addToMapW(0x84, 0x05, 0xD4);
1189         addToMapW(0x84, 0x20, 0x1E);
1190         addToMapW(0x85, 0x03, 0x96);
1191         addToMapW(0x85, 0x03, 0xB6);
1192         addToMapW(0x85, 0x04, 0x01);
1193         addToMapW(0x85, 0x04, 0x15);
1194         addToMapW(0x85, 0x04, 0x35);
1195         addToMapW(0x85, 0x04, 0x51);
1196         addToMapW(0x85, 0x05, 0xD5);
1197         addToMapW(0x85, 0x20, 0x26);
1198         addToMapW(0x86, 0x00, 0x86);
1199         addToMapW(0x86, 0x03, 0x97);
1200         addToMapW(0x86, 0x03, 0xB7);
1201         addToMapW(0x86, 0x04, 0x16);
1202         addToMapW(0x86, 0x04, 0x36);
1203         addToMapW(0x86, 0x05, 0xD6);
1204         addToMapW(0x86, 0x20, 0x20);
1205         addToMapW(0x87, 0x00, 0x87);
1206         addToMapW(0x87, 0x03, 0x98);
1207         addToMapW(0x87, 0x03, 0xB8);
1208         addToMapW(0x87, 0x04, 0x04);
1209         addToMapW(0x87, 0x04, 0x17);
1210         addToMapW(0x87, 0x04, 0x37);
1211         addToMapW(0x87, 0x04, 0x54);
1212         addToMapW(0x87, 0x05, 0xD7);
1213         addToMapW(0x87, 0x20, 0x21);
1214         addToMapW(0x88, 0x00, 0x88);
1215         addToMapW(0x88, 0x02, 0xC6);
1216         addToMapW(0x88, 0x03, 0x99);
1217         addToMapW(0x88, 0x03, 0xB9);
1218         addToMapW(0x88, 0x04, 0x18);
1219         addToMapW(0x88, 0x04, 0x38);
1220         addToMapW(0x88, 0x05, 0xD8);
1221         addToMapW(0x89, 0x00, 0x89);
1222         addToMapW(0x89, 0x03, 0x9A);
1223         addToMapW(0x89, 0x03, 0xBA);
1224         addToMapW(0x89, 0x04, 0x05);
1225         addToMapW(0x89, 0x04, 0x19);
1226         addToMapW(0x89, 0x04, 0x39);
1227         addToMapW(0x89, 0x04, 0x55);
1228         addToMapW(0x89, 0x05, 0xD9);
1229         addToMapW(0x89, 0x20, 0x30);
1230         addToMapW(0x8a, 0x00, 0x8A);
1231         addToMapW(0x8a, 0x01, 0x50);
1232         addToMapW(0x8a, 0x01, 0x51);
1233         addToMapW(0x8a, 0x01, 0x56);
1234         addToMapW(0x8a, 0x01, 0x57);
1235         addToMapW(0x8a, 0x03, 0x9B);
1236         addToMapW(0x8a, 0x03, 0xBB);
1237         addToMapW(0x8a, 0x04, 0x1A);
1238         addToMapW(0x8a, 0x04, 0x3A);
1239         addToMapW(0x8a, 0x05, 0xDA);
1240         addToMapW(0x8b, 0x00, 0x8B);
1241         addToMapW(0x8b, 0x03, 0x9C);
1242         addToMapW(0x8b, 0x03, 0xBC);
1243         addToMapW(0x8b, 0x04, 0x06);
1244         addToMapW(0x8b, 0x04, 0x1B);
1245         addToMapW(0x8b, 0x04, 0x3B);
1246         addToMapW(0x8b, 0x04, 0x56);
1247         addToMapW(0x8b, 0x05, 0xDB);
1248         addToMapW(0x8b, 0x20, 0x39);
1249         addToMapW(0x8c, 0x00, 0x8C);
1250         addToMapW(0x8c, 0x01, 0x52);
1251         addToMapW(0x8c, 0x01, 0x53);
1252         addToMapW(0x8c, 0x03, 0x9D);
1253         addToMapW(0x8c, 0x03, 0xBD);
1254         addToMapW(0x8c, 0x04, 0x1C);
1255         addToMapW(0x8c, 0x04, 0x3C);
1256         addToMapW(0x8c, 0x05, 0xDC);
1257         addToMapW(0x8d, 0x00, 0x8D);
1258         addToMapW(0x8d, 0x01, 0x31);
1259         addToMapW(0x8d, 0x01, 0x79);
1260         addToMapW(0x8d, 0x01, 0x7A);
1261         addToMapW(0x8d, 0x03, 0x9E);
1262         addToMapW(0x8d, 0x03, 0xBE);
1263         addToMapW(0x8d, 0x04, 0x07);
1264         addToMapW(0x8d, 0x04, 0x1D);
1265         addToMapW(0x8d, 0x04, 0x3D);
1266         addToMapW(0x8d, 0x04, 0x57);
1267         addToMapW(0x8d, 0x05, 0xDD);
1268         addToMapW(0x8e, 0x00, 0x8E);
1269         addToMapW(0x8e, 0x00, 0xC4);
1270         addToMapW(0x8e, 0x00, 0xE4);
1271         addToMapW(0x8e, 0x03, 0x9F);
1272         addToMapW(0x8e, 0x03, 0xBF);
1273         addToMapW(0x8e, 0x04, 0x1E);
1274         addToMapW(0x8e, 0x04, 0x3E);
1275         addToMapW(0x8e, 0x05, 0xDE);
1276         addToMapW(0x8f, 0x00, 0x8F);
1277         addToMapW(0x8f, 0x00, 0xC5);
1278         addToMapW(0x8f, 0x00, 0xE5);
1279         addToMapW(0x8f, 0x01, 0x06);
1280         addToMapW(0x8f, 0x01, 0x07);
1281         addToMapW(0x8f, 0x03, 0xA0);
1282         addToMapW(0x8f, 0x03, 0xC0);
1283         addToMapW(0x8f, 0x04, 0x08);
1284         addToMapW(0x8f, 0x04, 0x1F);
1285         addToMapW(0x8f, 0x04, 0x3F);
1286         addToMapW(0x8f, 0x04, 0x58);
1287         addToMapW(0x8f, 0x05, 0xDF);
1288         addToMapW(0x8f, 0x21, 0x2B);
1289         addToMapW(0x90, 0x00, 0x90);
1290         addToMapW(0x90, 0x00, 0xC9);
1291         addToMapW(0x90, 0x00, 0xE9);
1292         addToMapW(0x90, 0x03, 0xA1);
1293         addToMapW(0x90, 0x03, 0xC1);
1294         addToMapW(0x90, 0x04, 0x20);
1295         addToMapW(0x90, 0x04, 0x40);
1296         addToMapW(0x90, 0x05, 0xE0);
1297         addToMapW(0x91, 0x01, 0x39);
1298         addToMapW(0x91, 0x01, 0x3A);
1299         addToMapW(0x91, 0x03, 0xA3);
1300         addToMapW(0x91, 0x03, 0xC2);
1301         addToMapW(0x91, 0x03, 0xC3);
1302         addToMapW(0x91, 0x04, 0x09);
1303         addToMapW(0x91, 0x04, 0x21);
1304         addToMapW(0x91, 0x04, 0x41);
1305         addToMapW(0x91, 0x04, 0x59);
1306         addToMapW(0x91, 0x05, 0xE1);
1307         addToMapW(0x91, 0x06, 0x51);
1308         addToMapW(0x91, 0x20, 0x18);
1309         addToMapW(0x91, 0xFE, 0x7C);
1310         addToMapW(0x91, 0xFE, 0x7D);
1311         addToMapW(0x92, 0x00, 0xC6);
1312         addToMapW(0x92, 0x00, 0xE6);
1313         addToMapW(0x92, 0x03, 0xA4);
1314         addToMapW(0x92, 0x03, 0xC4);
1315         addToMapW(0x92, 0x04, 0x22);
1316         addToMapW(0x92, 0x04, 0x42);
1317         addToMapW(0x92, 0x05, 0xE2);
1318         addToMapW(0x92, 0x06, 0x52);
1319         addToMapW(0x92, 0x20, 0x19);
1320         addToMapW(0x92, 0xFE, 0x7E);
1321         addToMapW(0x92, 0xFE, 0x7F);
1322         addToMapW(0x93, 0x03, 0xA5);
1323         addToMapW(0x93, 0x03, 0xC5);
1324         addToMapW(0x93, 0x04, 0x0A);
1325         addToMapW(0x93, 0x04, 0x23);
1326         addToMapW(0x93, 0x04, 0x43);
1327         addToMapW(0x93, 0x04, 0x5A);
1328         addToMapW(0x93, 0x05, 0xE3);
1329         addToMapW(0x93, 0x20, 0x1C);
1330         addToMapW(0x94, 0x00, 0xA4);
1331         addToMapW(0x94, 0x03, 0xA6);
1332         addToMapW(0x94, 0x03, 0xC6);
1333         addToMapW(0x94, 0x04, 0x24);
1334         addToMapW(0x94, 0x04, 0x44);
1335         addToMapW(0x94, 0x05, 0xE4);
1336         addToMapW(0x94, 0x20, 0x1D);
1337         addToMapW(0x95, 0x01, 0x22);
1338         addToMapW(0x95, 0x01, 0x23);
1339         addToMapW(0x95, 0x01, 0x3D);
1340         addToMapW(0x95, 0x01, 0x3E);
1341         addToMapW(0x95, 0x03, 0xA7);
1342         addToMapW(0x95, 0x03, 0xC7);
1343         addToMapW(0x95, 0x04, 0x0B);
1344         addToMapW(0x95, 0x04, 0x25);
1345         addToMapW(0x95, 0x04, 0x45);
1346         addToMapW(0x95, 0x04, 0x5B);
1347         addToMapW(0x95, 0x05, 0xE5);
1348         addToMapW(0x95, 0x06, 0x40);
1349         addToMapW(0x95, 0x20, 0x22);
1350         addToMapW(0x96, 0x00, 0xA2);
1351         addToMapW(0x96, 0x03, 0xA8);
1352         addToMapW(0x96, 0x03, 0xC8);
1353         addToMapW(0x96, 0x04, 0x26);
1354         addToMapW(0x96, 0x04, 0x46);
1355         addToMapW(0x96, 0x05, 0xE6);
1356         addToMapW(0x96, 0x20, 0x13);
1357         addToMapW(0x97, 0x00, 0xB5);
1358         addToMapW(0x97, 0x01, 0x5A);
1359         addToMapW(0x97, 0x01, 0x5B);
1360         addToMapW(0x97, 0x03, 0xA9);
1361         addToMapW(0x97, 0x03, 0xC9);
1362         addToMapW(0x97, 0x04, 0x0C);
1363         addToMapW(0x97, 0x04, 0x27);
1364         addToMapW(0x97, 0x04, 0x47);
1365         addToMapW(0x97, 0x04, 0x5C);
1366         addToMapW(0x97, 0x05, 0xE7);
1367         addToMapW(0x97, 0x20, 0x14);
1368         addToMapW(0x98, 0x00, 0x98);
1369         addToMapW(0x98, 0x01, 0x30);
1370         addToMapW(0x98, 0x02, 0xDC);
1371         addToMapW(0x98, 0x04, 0x28);
1372         addToMapW(0x98, 0x04, 0x48);
1373         addToMapW(0x98, 0x05, 0xE8);
1374         addToMapW(0x98, 0x06, 0x21);
1375         addToMapW(0x98, 0xFE, 0x80);
1376         addToMapW(0x99, 0x00, 0x99);
1377         addToMapW(0x99, 0x00, 0xD6);
1378         addToMapW(0x99, 0x00, 0xF6);
1379         addToMapW(0x99, 0x04, 0x0E);
1380         addToMapW(0x99, 0x04, 0x29);
1381         addToMapW(0x99, 0x04, 0x49);
1382         addToMapW(0x99, 0x04, 0x5E);
1383         addToMapW(0x99, 0x05, 0xE9);
1384         addToMapW(0x99, 0x06, 0x22);
1385         addToMapW(0x99, 0x21, 0x22);
1386         addToMapW(0x99, 0xFE, 0x81);
1387         addToMapW(0x99, 0xFE, 0x82);
1388         addToMapW(0x9a, 0x00, 0x9A);
1389         addToMapW(0x9a, 0x00, 0xDC);
1390         addToMapW(0x9a, 0x00, 0xFC);
1391         addToMapW(0x9a, 0x04, 0x2A);
1392         addToMapW(0x9a, 0x04, 0x4A);
1393         addToMapW(0x9a, 0x05, 0xEA);
1394         addToMapW(0x9a, 0x06, 0x23);
1395         addToMapW(0x9a, 0xFE, 0x83);
1396         addToMapW(0x9a, 0xFE, 0x84);
1397         addToMapW(0x9b, 0x00, 0x9B);
1398         addToMapW(0x9b, 0x00, 0xA2);
1399         addToMapW(0x9b, 0x01, 0x64);
1400         addToMapW(0x9b, 0x01, 0x65);
1401         addToMapW(0x9b, 0x04, 0x0F);
1402         addToMapW(0x9b, 0x04, 0x2B);
1403         addToMapW(0x9b, 0x04, 0x4B);
1404         addToMapW(0x9b, 0x04, 0x5F);
1405         addToMapW(0x9b, 0x06, 0x24);
1406         addToMapW(0x9b, 0x20, 0x3A);
1407         addToMapW(0x9b, 0xFE, 0x85);
1408         addToMapW(0x9b, 0xFE, 0x86);
1409         addToMapW(0x9c, 0x00, 0x9C);
1410         addToMapW(0x9c, 0x00, 0xA3);
1411         addToMapW(0x9c, 0x04, 0x2C);
1412         addToMapW(0x9c, 0x04, 0x4C);
1413         addToMapW(0x9c, 0x20, 0xA4);
1414         addToMapW(0x9d, 0x00, 0x9D);
1415         addToMapW(0x9d, 0x00, 0xA5);
1416         addToMapW(0x9d, 0x00, 0xD8);
1417         addToMapW(0x9d, 0x00, 0xF8);
1418         addToMapW(0x9d, 0x01, 0x41);
1419         addToMapW(0x9d, 0x01, 0x42);
1420         addToMapW(0x9d, 0x02, 0x78);
1421         addToMapW(0x9d, 0x03, 0x98);
1422         addToMapW(0x9d, 0x04, 0x2D);
1423         addToMapW(0x9d, 0x04, 0x2E);
1424         addToMapW(0x9d, 0x04, 0x4D);
1425         addToMapW(0x9d, 0x04, 0x4E);
1426         addToMapW(0x9d, 0x06, 0x25);
1427         addToMapW(0x9d, 0x22, 0x05);
1428         addToMapW(0x9d, 0xFE, 0x87);
1429         addToMapW(0x9d, 0xFE, 0x88);
1430         addToMapW(0x9e, 0x00, 0x9E);
1431         addToMapW(0x9e, 0x00, 0xD7);
1432         addToMapW(0x9e, 0x01, 0x5E);
1433         addToMapW(0x9e, 0x01, 0x5F);
1434         addToMapW(0x9e, 0x04, 0x2E);
1435         addToMapW(0x9e, 0x04, 0x4E);
1436         addToMapW(0x9e, 0x06, 0x26);
1437         addToMapW(0x9e, 0x20, 0xA7);
1438         addToMapW(0x9e, 0xFE, 0x89);
1439         addToMapW(0x9e, 0xFE, 0x8A);
1440         addToMapW(0x9e, 0xFE, 0x8B);
1441         addToMapW(0x9e, 0xFE, 0x8C);
1442         addToMapW(0x9f, 0x00, 0x9F);
1443         addToMapW(0x9f, 0x00, 0xA4);
1444         addToMapW(0x9f, 0x00, 0xFF);
1445         addToMapW(0x9f, 0x01, 0x78);
1446         addToMapW(0x9f, 0x01, 0x91);
1447         addToMapW(0x9f, 0x01, 0x92);
1448         addToMapW(0x9f, 0x04, 0x2A);
1449         addToMapW(0x9f, 0x04, 0x2F);
1450         addToMapW(0x9f, 0x04, 0x4A);
1451         addToMapW(0x9f, 0x04, 0x4F);
1452         addToMapW(0x9f, 0x06, 0x27);
1453         addToMapW(0x9f, 0xFE, 0x8D);
1454         addToMapW(0x9f, 0xFE, 0x8E);
1455         addToMapW(0xa0, 0x00, 0xA0);
1456         addToMapW(0xa0, 0x01, 0x00);
1457         addToMapW(0xa0, 0x01, 0x01);
1458         addToMapW(0xa0, 0x06, 0x28);
1459         addToMapW(0xa0, 0xF8, 0xF0);
1460         addToMapW(0xa0, 0xFE, 0x8F);
1461         addToMapW(0xa0, 0xFE, 0x90);
1462         addToMapW(0xa0, 0xFE, 0x91);
1463         addToMapW(0xa0, 0xFE, 0x92);
1464         addToMapW(0xa1, 0x00, 0xA1);
1465         addToMapW(0xa1, 0x01, 0x2A);
1466         addToMapW(0xa1, 0x01, 0x2B);
1467         addToMapW(0xa1, 0x04, 0x10);
1468         addToMapW(0xa1, 0x04, 0x30);
1469         addToMapW(0xa1, 0x06, 0x29);
1470         addToMapW(0xa1, 0x0E, 0x01);
1471         addToMapW(0xa1, 0xFE, 0x93);
1472         addToMapW(0xa1, 0xFE, 0x94);
1473         addToMapW(0xa1, 0xFF, 0x61);
1474         addToMapW(0xa2, 0x00, 0xA2);
1475         addToMapW(0xa2, 0x06, 0x2A);
1476         addToMapW(0xa2, 0x0E, 0x02);
1477         addToMapW(0xa2, 0xFE, 0x95);
1478         addToMapW(0xa2, 0xFE, 0x96);
1479         addToMapW(0xa2, 0xFE, 0x97);
1480         addToMapW(0xa2, 0xFE, 0x98);
1481         addToMapW(0xa2, 0xFF, 0x62);
1482         addToMapW(0xa3, 0x00, 0xA3);
1483         addToMapW(0xa3, 0x01, 0x7B);
1484         addToMapW(0xa3, 0x01, 0x7C);
1485         addToMapW(0xa3, 0x04, 0x11);
1486         addToMapW(0xa3, 0x04, 0x31);
1487         addToMapW(0xa3, 0x06, 0x2B);
1488         addToMapW(0xa3, 0x0E, 0x03);
1489         addToMapW(0xa3, 0xFE, 0x99);
1490         addToMapW(0xa3, 0xFE, 0x9A);
1491         addToMapW(0xa3, 0xFE, 0x9B);
1492         addToMapW(0xa3, 0xFE, 0x9C);
1493         addToMapW(0xa3, 0xFF, 0x63);
1494         addToMapW(0xa4, 0x00, 0xA4);
1495         addToMapW(0xa4, 0x01, 0x04);
1496         addToMapW(0xa4, 0x01, 0x05);
1497         addToMapW(0xa4, 0x06, 0x2C);
1498         addToMapW(0xa4, 0x0E, 0x04);
1499         addToMapW(0xa4, 0xFE, 0x9D);
1500         addToMapW(0xa4, 0xFE, 0x9E);
1501         addToMapW(0xa4, 0xFE, 0x9F);
1502         addToMapW(0xa4, 0xFE, 0xA0);
1503         addToMapW(0xa4, 0xFF, 0x64);
1504         addToMapW(0xa5, 0x00, 0xA5);
1505         addToMapW(0xa5, 0x00, 0xD1);
1506         addToMapW(0xa5, 0x00, 0xF1);
1507         addToMapW(0xa5, 0x04, 0x26);
1508         addToMapW(0xa5, 0x04, 0x46);
1509         addToMapW(0xa5, 0x06, 0x2D);
1510         addToMapW(0xa5, 0x0E, 0x05);
1511         addToMapW(0xa5, 0xFE, 0xA1);
1512         addToMapW(0xa5, 0xFE, 0xA2);
1513         addToMapW(0xa5, 0xFE, 0xA3);
1514         addToMapW(0xa5, 0xFE, 0xA4);
1515         addToMapW(0xa5, 0xFF, 0x65);
1516         addToMapW(0xa6, 0x00, 0xA6);
1517         addToMapW(0xa6, 0x00, 0xAA);
1518         addToMapW(0xa6, 0x01, 0x1E);
1519         addToMapW(0xa6, 0x01, 0x1F);
1520         addToMapW(0xa6, 0x01, 0x7D);
1521         addToMapW(0xa6, 0x01, 0x7E);
1522         addToMapW(0xa6, 0x06, 0x2E);
1523         addToMapW(0xa6, 0x0E, 0x06);
1524         addToMapW(0xa6, 0x20, 0x1D);
1525         addToMapW(0xa6, 0xFE, 0xA5);
1526         addToMapW(0xa6, 0xFE, 0xA6);
1527         addToMapW(0xa6, 0xFE, 0xA7);
1528         addToMapW(0xa6, 0xFE, 0xA8);
1529         addToMapW(0xa6, 0xFF, 0x66);
1530         addToMapW(0xa7, 0x00, 0xA6);
1531         addToMapW(0xa7, 0x00, 0xA7);
1532         addToMapW(0xa7, 0x00, 0xBA);
1533         addToMapW(0xa7, 0x04, 0x14);
1534         addToMapW(0xa7, 0x04, 0x34);
1535         addToMapW(0xa7, 0x06, 0x2F);
1536         addToMapW(0xa7, 0x0E, 0x07);
1537         addToMapW(0xa7, 0xFE, 0xA9);
1538         addToMapW(0xa7, 0xFE, 0xAA);
1539         addToMapW(0xa7, 0xFF, 0x67);
1540         addToMapW(0xa8, 0x00, 0xA8);
1541         addToMapW(0xa8, 0x00, 0xA9);
1542         addToMapW(0xa8, 0x00, 0xBF);
1543         addToMapW(0xa8, 0x01, 0x18);
1544         addToMapW(0xa8, 0x01, 0x19);
1545         addToMapW(0xa8, 0x06, 0x30);
1546         addToMapW(0xa8, 0x0E, 0x08);
1547         addToMapW(0xa8, 0xFE, 0xAB);
1548         addToMapW(0xa8, 0xFE, 0xAC);
1549         addToMapW(0xa8, 0xFF, 0x68);
1550         addToMapW(0xa9, 0x00, 0xA9);
1551         addToMapW(0xa9, 0x00, 0xAE);
1552         addToMapW(0xa9, 0x04, 0x15);
1553         addToMapW(0xa9, 0x04, 0x35);
1554         addToMapW(0xa9, 0x06, 0x31);
1555         addToMapW(0xa9, 0x0E, 0x09);
1556         addToMapW(0xa9, 0x23, 0x10);
1557         addToMapW(0xa9, 0xFE, 0xAD);
1558         addToMapW(0xa9, 0xFE, 0xAE);
1559         addToMapW(0xa9, 0xFF, 0x69);
1560         addToMapW(0xaa, 0x00, 0xAA);
1561         addToMapW(0xaa, 0x00, 0xAC);
1562         addToMapW(0xaa, 0x06, 0x32);
1563         addToMapW(0xaa, 0x0E, 0x0A);
1564         addToMapW(0xaa, 0x23, 0x10);
1565         addToMapW(0xaa, 0xFE, 0xAF);
1566         addToMapW(0xaa, 0xFE, 0xB0);
1567         addToMapW(0xaa, 0xFF, 0x6A);
1568         addToMapW(0xab, 0x00, 0xAB);
1569         addToMapW(0xab, 0x00, 0xBD);
1570         addToMapW(0xab, 0x04, 0x24);
1571         addToMapW(0xab, 0x04, 0x44);
1572         addToMapW(0xab, 0x06, 0x33);
1573         addToMapW(0xab, 0x0E, 0x0B);
1574         addToMapW(0xab, 0xFE, 0xB1);
1575         addToMapW(0xab, 0xFE, 0xB2);
1576         addToMapW(0xab, 0xFE, 0xB3);
1577         addToMapW(0xab, 0xFE, 0xB4);
1578         addToMapW(0xab, 0xFF, 0x6B);
1579         addToMapW(0xac, 0x00, 0xAC);
1580         addToMapW(0xac, 0x00, 0xBC);
1581         addToMapW(0xac, 0x01, 0x0C);
1582         addToMapW(0xac, 0x01, 0x0D);
1583         addToMapW(0xac, 0x06, 0x34);
1584         addToMapW(0xac, 0x0E, 0x0C);
1585         addToMapW(0xac, 0xFE, 0xB5);
1586         addToMapW(0xac, 0xFE, 0xB6);
1587         addToMapW(0xac, 0xFE, 0xB7);
1588         addToMapW(0xac, 0xFE, 0xB8);
1589         addToMapW(0xac, 0xFF, 0x6C);
1590         addToMapW(0xad, 0x00, 0xA1);
1591         addToMapW(0xad, 0x00, 0xAD);
1592         addToMapW(0xad, 0x01, 0x41);
1593         addToMapW(0xad, 0x01, 0x42);
1594         addToMapW(0xad, 0x04, 0x13);
1595         addToMapW(0xad, 0x04, 0x33);
1596         addToMapW(0xad, 0x06, 0x35);
1597         addToMapW(0xad, 0x0E, 0x0D);
1598         addToMapW(0xad, 0xFE, 0xB9);
1599         addToMapW(0xad, 0xFE, 0xBA);
1600         addToMapW(0xad, 0xFE, 0xBB);
1601         addToMapW(0xad, 0xFE, 0xBC);
1602         addToMapW(0xad, 0xFF, 0x6D);
1603         addToMapW(0xae, 0x00, 0xAB);
1604         addToMapW(0xae, 0x00, 0xAE);
1605         addToMapW(0xae, 0x0E, 0x0E);
1606         addToMapW(0xae, 0x22, 0x6A);
1607         addToMapW(0xae, 0x30, 0x0A);
1608         addToMapW(0xae, 0xFF, 0x6E);
1609         addToMapW(0xaf, 0x00, 0xAF);
1610         addToMapW(0xaf, 0x00, 0xBB);
1611         addToMapW(0xaf, 0x0E, 0x0F);
1612         addToMapW(0xaf, 0x22, 0x6B);
1613         addToMapW(0xaf, 0x30, 0x0B);
1614         addToMapW(0xaf, 0xFF, 0x6F);
1615         addToMapW(0xb0, 0x00, 0xB0);
1616         addToMapW(0xb0, 0x0E, 0x10);
1617         addToMapW(0xb0, 0x25, 0x91);
1618         addToMapW(0xb0, 0xFF, 0x70);
1619         addToMapW(0xb1, 0x00, 0xB1);
1620         addToMapW(0xb1, 0x0E, 0x11);
1621         addToMapW(0xb1, 0x25, 0x92);
1622         addToMapW(0xb1, 0xFF, 0x71);
1623         addToMapW(0xb2, 0x00, 0xB2);
1624         addToMapW(0xb2, 0x0E, 0x12);
1625         addToMapW(0xb2, 0x25, 0x93);
1626         addToMapW(0xb2, 0xFF, 0x72);
1627         addToMapW(0xb3, 0x00, 0xA6);
1628         addToMapW(0xb3, 0x00, 0xB3);
1629         addToMapW(0xb3, 0x01, 0xC0);
1630         addToMapW(0xb3, 0x0E, 0x13);
1631         addToMapW(0xb3, 0x22, 0x23);
1632         addToMapW(0xb3, 0x25, 0x02);
1633         addToMapW(0xb3, 0x27, 0x58);
1634         addToMapW(0xb3, 0xFF, 0x73);
1635         addToMapW(0xb4, 0x00, 0xB4);
1636         addToMapW(0xb4, 0x0E, 0x14);
1637         addToMapW(0xb4, 0x25, 0x24);
1638         addToMapW(0xb4, 0xFF, 0x74);
1639         addToMapW(0xb5, 0x00, 0xB5);
1640         addToMapW(0xb5, 0x00, 0xC1);
1641         addToMapW(0xb5, 0x00, 0xE1);
1642         addToMapW(0xb5, 0x01, 0x04);
1643         addToMapW(0xb5, 0x01, 0x05);
1644         addToMapW(0xb5, 0x0E, 0x15);
1645         addToMapW(0xb5, 0x25, 0x61);
1646         addToMapW(0xb5, 0xFF, 0x75);
1647         addToMapW(0xb6, 0x00, 0xB6);
1648         addToMapW(0xb6, 0x00, 0xC2);
1649         addToMapW(0xb6, 0x00, 0xE2);
1650         addToMapW(0xb6, 0x01, 0x0C);
1651         addToMapW(0xb6, 0x01, 0x0D);
1652         addToMapW(0xb6, 0x04, 0x25);
1653         addToMapW(0xb6, 0x04, 0x45);
1654         addToMapW(0xb6, 0x0E, 0x16);
1655         addToMapW(0xb6, 0x25, 0x62);
1656         addToMapW(0xb6, 0xFF, 0x76);
1657         addToMapW(0xb7, 0x00, 0xB7);
1658         addToMapW(0xb7, 0x00, 0xC0);
1659         addToMapW(0xb7, 0x00, 0xE0);
1660         addToMapW(0xb7, 0x01, 0x18);
1661         addToMapW(0xb7, 0x01, 0x19);
1662         addToMapW(0xb7, 0x01, 0x1A);
1663         addToMapW(0xb7, 0x01, 0x1B);
1664         addToMapW(0xb7, 0x0E, 0x17);
1665         addToMapW(0xb7, 0x25, 0x56);
1666         addToMapW(0xb7, 0xFF, 0x77);
1667         addToMapW(0xb8, 0x00, 0xA9);
1668         addToMapW(0xb8, 0x00, 0xB8);
1669         addToMapW(0xb8, 0x01, 0x16);
1670         addToMapW(0xb8, 0x01, 0x17);
1671         addToMapW(0xb8, 0x01, 0x5E);
1672         addToMapW(0xb8, 0x01, 0x5F);
1673         addToMapW(0xb8, 0x04, 0x18);
1674         addToMapW(0xb8, 0x04, 0x38);
1675         addToMapW(0xb8, 0x0E, 0x18);
1676         addToMapW(0xb8, 0x25, 0x55);
1677         addToMapW(0xb8, 0xFF, 0x78);
1678         addToMapW(0xb9, 0x00, 0xB9);
1679         addToMapW(0xb9, 0x0E, 0x19);
1680         addToMapW(0xb9, 0x25, 0x61);
1681         addToMapW(0xb9, 0x25, 0x62);
1682         addToMapW(0xb9, 0x25, 0x63);
1683         addToMapW(0xb9, 0xFF, 0x79);
1684         addToMapW(0xba, 0x00, 0xBA);
1685         addToMapW(0xba, 0x0E, 0x1A);
1686         addToMapW(0xba, 0x25, 0x51);
1687         addToMapW(0xba, 0xFF, 0x7A);
1688         addToMapW(0xbb, 0x00, 0xBB);
1689         addToMapW(0xbb, 0x0E, 0x1B);
1690         addToMapW(0xbb, 0x25, 0x55);
1691         addToMapW(0xbb, 0x25, 0x56);
1692         addToMapW(0xbb, 0x25, 0x57);
1693         addToMapW(0xbb, 0xFF, 0x7B);
1694         addToMapW(0xbc, 0x00, 0xBC);
1695         addToMapW(0xbc, 0x0E, 0x1C);
1696         addToMapW(0xbc, 0x25, 0x5B);
1697         addToMapW(0xbc, 0x25, 0x5C);
1698         addToMapW(0xbc, 0x25, 0x5D);
1699         addToMapW(0xbc, 0xFF, 0x7C);
1700         addToMapW(0xbd, 0x00, 0xA2);
1701         addToMapW(0xbd, 0x00, 0xBD);
1702         addToMapW(0xbd, 0x01, 0x2E);
1703         addToMapW(0xbd, 0x01, 0x2F);
1704         addToMapW(0xbd, 0x01, 0x7B);
1705         addToMapW(0xbd, 0x01, 0x7C);
1706         addToMapW(0xbd, 0x0E, 0x1D);
1707         addToMapW(0xbd, 0x25, 0x5C);
1708         addToMapW(0xbd, 0xFF, 0x7D);
1709         addToMapW(0xbe, 0x00, 0xA5);
1710         addToMapW(0xbe, 0x00, 0xBE);
1711         addToMapW(0xbe, 0x01, 0x60);
1712         addToMapW(0xbe, 0x01, 0x61);
1713         addToMapW(0xbe, 0x04, 0x19);
1714         addToMapW(0xbe, 0x04, 0x39);
1715         addToMapW(0xbe, 0x0E, 0x1E);
1716         addToMapW(0xbe, 0x25, 0x5B);
1717         addToMapW(0xbe, 0xFF, 0x7E);
1718         addToMapW(0xbf, 0x00, 0xAC);
1719         addToMapW(0xbf, 0x00, 0xBF);
1720         addToMapW(0xbf, 0x0E, 0x1F);
1721         addToMapW(0xbf, 0x25, 0x10);
1722         addToMapW(0xbf, 0xFF, 0x7F);
1723         addToMapW(0xc0, 0x00, 0xC0);
1724         addToMapW(0xc0, 0x00, 0xE0);
1725         addToMapW(0xc0, 0x0E, 0x20);
1726         addToMapW(0xc0, 0x25, 0x14);
1727         addToMapW(0xc0, 0xFF, 0x80);
1728         addToMapW(0xc1, 0x00, 0xC1);
1729         addToMapW(0xc1, 0x00, 0xE1);
1730         addToMapW(0xc1, 0x0E, 0x21);
1731         addToMapW(0xc1, 0x25, 0x34);
1732         addToMapW(0xc1, 0xFF, 0x81);
1733         addToMapW(0xc2, 0x00, 0xC2);
1734         addToMapW(0xc2, 0x00, 0xE2);
1735         addToMapW(0xc2, 0x0E, 0x22);
1736         addToMapW(0xc2, 0x25, 0x2C);
1737         addToMapW(0xc2, 0xFF, 0x82);
1738         addToMapW(0xc3, 0x01, 0x02);
1739         addToMapW(0xc3, 0x01, 0x03);
1740         addToMapW(0xc3, 0x0E, 0x23);
1741         addToMapW(0xc3, 0x25, 0x1C);
1742         addToMapW(0xc3, 0xFF, 0x83);
1743         addToMapW(0xc4, 0x00, 0xAF);
1744         addToMapW(0xc4, 0x00, 0xC4);
1745         addToMapW(0xc4, 0x00, 0xE4);
1746         addToMapW(0xc4, 0x02, 0xC9);
1747         addToMapW(0xc4, 0x03, 0x04);
1748         addToMapW(0xc4, 0x03, 0x05);
1749         addToMapW(0xc4, 0x0E, 0x24);
1750         addToMapW(0xc4, 0x25, 0x00);
1751         addToMapW(0xc4, 0xFF, 0x84);
1752         addToMapW(0xc5, 0x00, 0xC5);
1753         addToMapW(0xc5, 0x00, 0xE5);
1754         addToMapW(0xc5, 0x0E, 0x25);
1755         addToMapW(0xc5, 0x20, 0x20);
1756         addToMapW(0xc5, 0x20, 0x21);
1757         addToMapW(0xc5, 0x25, 0x3C);
1758         addToMapW(0xc5, 0xFF, 0x85);
1759         addToMapW(0xc6, 0x00, 0xC6);
1760         addToMapW(0xc6, 0x00, 0xE6);
1761         addToMapW(0xc6, 0x01, 0x02);
1762         addToMapW(0xc6, 0x01, 0x03);
1763         addToMapW(0xc6, 0x01, 0x72);
1764         addToMapW(0xc6, 0x01, 0x73);
1765         addToMapW(0xc6, 0x0E, 0x26);
1766         addToMapW(0xc6, 0x25, 0x5E);
1767         addToMapW(0xc6, 0xFF, 0x86);
1768         addToMapW(0xc7, 0x00, 0xC3);
1769         addToMapW(0xc7, 0x00, 0xC7);
1770         addToMapW(0xc7, 0x00, 0xE3);
1771         addToMapW(0xc7, 0x00, 0xE7);
1772         addToMapW(0xc7, 0x01, 0x6A);
1773         addToMapW(0xc7, 0x01, 0x6B);
1774         addToMapW(0xc7, 0x04, 0x1A);
1775         addToMapW(0xc7, 0x04, 0x3A);
1776         addToMapW(0xc7, 0x0E, 0x27);
1777         addToMapW(0xc7, 0x25, 0x5F);
1778         addToMapW(0xc7, 0xFF, 0x87);
1779         addToMapW(0xc8, 0x00, 0xC8);
1780         addToMapW(0xc8, 0x00, 0xE8);
1781         addToMapW(0xc8, 0x0E, 0x28);
1782         addToMapW(0xc8, 0x25, 0x58);
1783         addToMapW(0xc8, 0x25, 0x59);
1784         addToMapW(0xc8, 0x25, 0x5A);
1785         addToMapW(0xc8, 0xFF, 0x88);
1786         addToMapW(0xc9, 0x00, 0xC9);
1787         addToMapW(0xc9, 0x00, 0xE9);
1788         addToMapW(0xc9, 0x0E, 0x29);
1789         addToMapW(0xc9, 0x25, 0x52);
1790         addToMapW(0xc9, 0x25, 0x53);
1791         addToMapW(0xc9, 0x25, 0x54);
1792         addToMapW(0xc9, 0xFF, 0x89);
1793         addToMapW(0xca, 0x00, 0xCA);
1794         addToMapW(0xca, 0x00, 0xEA);
1795         addToMapW(0xca, 0x0E, 0x2A);
1796         addToMapW(0xca, 0x25, 0x67);
1797         addToMapW(0xca, 0x25, 0x68);
1798         addToMapW(0xca, 0x25, 0x69);
1799         addToMapW(0xca, 0xFF, 0x8A);
1800         addToMapW(0xcb, 0x00, 0xCB);
1801         addToMapW(0xcb, 0x00, 0xEB);
1802         addToMapW(0xcb, 0x0E, 0x2B);
1803         addToMapW(0xcb, 0x25, 0x64);
1804         addToMapW(0xcb, 0x25, 0x65);
1805         addToMapW(0xcb, 0x25, 0x66);
1806         addToMapW(0xcb, 0xFF, 0x8B);
1807         addToMapW(0xcc, 0x03, 0x00);
1808         addToMapW(0xcc, 0x0E, 0x2C);
1809         addToMapW(0xcc, 0x25, 0x5E);
1810         addToMapW(0xcc, 0x25, 0x5F);
1811         addToMapW(0xcc, 0x25, 0x60);
1812         addToMapW(0xcc, 0xFF, 0x8C);
1813         addToMapW(0xcd, 0x00, 0xCD);
1814         addToMapW(0xcd, 0x00, 0xED);
1815         addToMapW(0xcd, 0x0E, 0x2D);
1816         addToMapW(0xcd, 0x25, 0x50);
1817         addToMapW(0xcd, 0xFF, 0x8D);
1818         addToMapW(0xce, 0x00, 0xCE);
1819         addToMapW(0xce, 0x00, 0xEE);
1820         addToMapW(0xce, 0x0E, 0x2E);
1821         addToMapW(0xce, 0x20, 0x21);
1822         addToMapW(0xce, 0x25, 0x6A);
1823         addToMapW(0xce, 0x25, 0x6B);
1824         addToMapW(0xce, 0x25, 0x6C);
1825         addToMapW(0xce, 0xFF, 0x8E);
1826         addToMapW(0xcf, 0x00, 0xA4);
1827         addToMapW(0xcf, 0x00, 0xCF);
1828         addToMapW(0xcf, 0x00, 0xEF);
1829         addToMapW(0xcf, 0x01, 0x7D);
1830         addToMapW(0xcf, 0x01, 0x7E);
1831         addToMapW(0xcf, 0x0E, 0x2F);
1832         addToMapW(0xcf, 0x25, 0x67);
1833         addToMapW(0xcf, 0xFF, 0x8F);
1834         addToMapW(0xd0, 0x00, 0xBA);
1835         addToMapW(0xd0, 0x01, 0x10);
1836         addToMapW(0xd0, 0x01, 0x11);
1837         addToMapW(0xd0, 0x0E, 0x30);
1838         addToMapW(0xd0, 0x25, 0x68);
1839         addToMapW(0xd0, 0xFF, 0x90);
1840         addToMapW(0xd1, 0x00, 0xAA);
1841         addToMapW(0xd1, 0x00, 0xD0);
1842         addToMapW(0xd1, 0x00, 0xD1);
1843         addToMapW(0xd1, 0x00, 0xF0);
1844         addToMapW(0xd1, 0x00, 0xF1);
1845         addToMapW(0xd1, 0x01, 0x10);
1846         addToMapW(0xd1, 0x01, 0x11);
1847         addToMapW(0xd1, 0x01, 0x89);
1848         addToMapW(0xd1, 0x04, 0x1B);
1849         addToMapW(0xd1, 0x04, 0x3B);
1850         addToMapW(0xd1, 0x0E, 0x31);
1851         addToMapW(0xd1, 0x25, 0x64);
1852         addToMapW(0xd1, 0xFF, 0x91);
1853         addToMapW(0xd2, 0x00, 0xCA);
1854         addToMapW(0xd2, 0x00, 0xEA);
1855         addToMapW(0xd2, 0x01, 0x0E);
1856         addToMapW(0xd2, 0x01, 0x0F);
1857         addToMapW(0xd2, 0x03, 0x09);
1858         addToMapW(0xd2, 0x0E, 0x32);
1859         addToMapW(0xd2, 0x25, 0x65);
1860         addToMapW(0xd2, 0xFF, 0x92);
1861         addToMapW(0xd3, 0x00, 0xCB);
1862         addToMapW(0xd3, 0x00, 0xD3);
1863         addToMapW(0xd3, 0x00, 0xEB);
1864         addToMapW(0xd3, 0x00, 0xF3);
1865         addToMapW(0xd3, 0x04, 0x1C);
1866         addToMapW(0xd3, 0x04, 0x3C);
1867         addToMapW(0xd3, 0x0E, 0x33);
1868         addToMapW(0xd3, 0x25, 0x59);
1869         addToMapW(0xd3, 0xFF, 0x93);
1870         addToMapW(0xd4, 0x00, 0xC8);
1871         addToMapW(0xd4, 0x00, 0xD4);
1872         addToMapW(0xd4, 0x00, 0xE8);
1873         addToMapW(0xd4, 0x00, 0xF4);
1874         addToMapW(0xd4, 0x0E, 0x34);
1875         addToMapW(0xd4, 0x25, 0x58);
1876         addToMapW(0xd4, 0xFF, 0x94);
1877         addToMapW(0xd5, 0x01, 0x31);
1878         addToMapW(0xd5, 0x01, 0x47);
1879         addToMapW(0xd5, 0x01, 0x48);
1880         addToMapW(0xd5, 0x01, 0xA0);
1881         addToMapW(0xd5, 0x01, 0xA1);
1882         addToMapW(0xd5, 0x04, 0x1D);
1883         addToMapW(0xd5, 0x04, 0x3D);
1884         addToMapW(0xd5, 0x0E, 0x35);
1885         addToMapW(0xd5, 0x25, 0x52);
1886         addToMapW(0xd5, 0xF8, 0xBB);
1887         addToMapW(0xd5, 0xFF, 0x95);
1888         addToMapW(0xd6, 0x00, 0xCD);
1889         addToMapW(0xd6, 0x00, 0xD6);
1890         addToMapW(0xd6, 0x00, 0xED);
1891         addToMapW(0xd6, 0x00, 0xF6);
1892         addToMapW(0xd6, 0x0E, 0x36);
1893         addToMapW(0xd6, 0x25, 0x53);
1894         addToMapW(0xd6, 0xFF, 0x96);
1895         addToMapW(0xd7, 0x00, 0xCE);
1896         addToMapW(0xd7, 0x00, 0xD7);
1897         addToMapW(0xd7, 0x00, 0xEE);
1898         addToMapW(0xd7, 0x04, 0x1E);
1899         addToMapW(0xd7, 0x04, 0x3E);
1900         addToMapW(0xd7, 0x0E, 0x37);
1901         addToMapW(0xd7, 0x25, 0x6B);
1902         addToMapW(0xd7, 0xFF, 0x97);
1903         addToMapW(0xd8, 0x00, 0xCF);
1904         addToMapW(0xd8, 0x00, 0xD8);
1905         addToMapW(0xd8, 0x00, 0xEF);
1906         addToMapW(0xd8, 0x00, 0xF8);
1907         addToMapW(0xd8, 0x0E, 0x38);
1908         addToMapW(0xd8, 0x20, 0x21);
1909         addToMapW(0xd8, 0x25, 0x6A);
1910         addToMapW(0xd8, 0xFF, 0x98);
1911         addToMapW(0xd9, 0x00, 0xD9);
1912         addToMapW(0xd9, 0x00, 0xF9);
1913         addToMapW(0xd9, 0x0E, 0x39);
1914         addToMapW(0xd9, 0x25, 0x18);
1915         addToMapW(0xd9, 0xFF, 0x99);
1916         addToMapW(0xda, 0x00, 0xDA);
1917         addToMapW(0xda, 0x00, 0xFA);
1918         addToMapW(0xda, 0x0E, 0x3A);
1919         addToMapW(0xda, 0x25, 0x0C);
1920         addToMapW(0xda, 0xFF, 0x9A);
1921         addToMapW(0xdb, 0x00, 0xDB);
1922         addToMapW(0xdb, 0x00, 0xFB);
1923         addToMapW(0xdb, 0x25, 0x88);
1924         addToMapW(0xdb, 0x25, 0x8C);
1925         addToMapW(0xdb, 0x25, 0x90);
1926         addToMapW(0xdb, 0xF8, 0xC1);
1927         addToMapW(0xdb, 0xFF, 0x9B);
1928         addToMapW(0xdc, 0x00, 0xDC);
1929         addToMapW(0xdc, 0x00, 0xFC);
1930         addToMapW(0xdc, 0x25, 0x84);
1931         addToMapW(0xdc, 0xF8, 0xC2);
1932         addToMapW(0xdc, 0xFF, 0x9C);
1933         addToMapW(0xdd, 0x00, 0xA6);
1934         addToMapW(0xdd, 0x01, 0x62);
1935         addToMapW(0xdd, 0x01, 0x63);
1936         addToMapW(0xdd, 0x01, 0xAF);
1937         addToMapW(0xdd, 0x01, 0xB0);
1938         addToMapW(0xdd, 0x04, 0x1F);
1939         addToMapW(0xdd, 0x04, 0x3F);
1940         addToMapW(0xdd, 0x25, 0x8C);
1941         addToMapW(0xdd, 0xF8, 0xC3);
1942         addToMapW(0xdd, 0xFF, 0x9D);
1943         addToMapW(0xde, 0x00, 0xCC);
1944         addToMapW(0xde, 0x00, 0xEC);
1945         addToMapW(0xde, 0x01, 0x6E);
1946         addToMapW(0xde, 0x01, 0x6F);
1947         addToMapW(0xde, 0x03, 0x03);
1948         addToMapW(0xde, 0x25, 0x90);
1949         addToMapW(0xde, 0xF8, 0xC4);
1950         addToMapW(0xde, 0xFF, 0x9E);
1951         addToMapW(0xdf, 0x00, 0xDF);
1952         addToMapW(0xdf, 0x0E, 0x3F);
1953         addToMapW(0xdf, 0x25, 0x80);
1954         addToMapW(0xdf, 0xFF, 0x9F);
1955         addToMapW(0xe0, 0x00, 0xD3);
1956         addToMapW(0xe0, 0x00, 0xF3);
1957         addToMapW(0xe0, 0x03, 0x91);
1958         addToMapW(0xe0, 0x03, 0xB1);
1959         addToMapW(0xe0, 0x04, 0x2F);
1960         addToMapW(0xe0, 0x04, 0x4F);
1961         addToMapW(0xe0, 0x06, 0x36);
1962         addToMapW(0xe0, 0x0E, 0x40);
1963         addToMapW(0xe0, 0xFE, 0xBD);
1964         addToMapW(0xe0, 0xFE, 0xBE);
1965         addToMapW(0xe0, 0xFE, 0xBF);
1966         addToMapW(0xe0, 0xFE, 0xC0);
1967         addToMapW(0xe1, 0x00, 0xDF);
1968         addToMapW(0xe1, 0x03, 0xB2);
1969         addToMapW(0xe1, 0x06, 0x37);
1970         addToMapW(0xe1, 0x0E, 0x41);
1971         addToMapW(0xe1, 0xFE, 0xC1);
1972         addToMapW(0xe1, 0xFE, 0xC2);
1973         addToMapW(0xe1, 0xFE, 0xC3);
1974         addToMapW(0xe1, 0xFE, 0xC4);
1975         addToMapW(0xe2, 0x00, 0xD4);
1976         addToMapW(0xe2, 0x00, 0xF4);
1977         addToMapW(0xe2, 0x01, 0x4C);
1978         addToMapW(0xe2, 0x01, 0x4D);
1979         addToMapW(0xe2, 0x03, 0x93);
1980         addToMapW(0xe2, 0x04, 0x20);
1981         addToMapW(0xe2, 0x04, 0x40);
1982         addToMapW(0xe2, 0x06, 0x38);
1983         addToMapW(0xe2, 0x0E, 0x42);
1984         addToMapW(0xe2, 0xFE, 0xC5);
1985         addToMapW(0xe2, 0xFE, 0xC6);
1986         addToMapW(0xe2, 0xFE, 0xC7);
1987         addToMapW(0xe2, 0xFE, 0xC8);
1988         addToMapW(0xe3, 0x00, 0xD2);
1989         addToMapW(0xe3, 0x00, 0xF2);
1990         addToMapW(0xe3, 0x01, 0x43);
1991         addToMapW(0xe3, 0x01, 0x44);
1992         addToMapW(0xe3, 0x03, 0xA0);
1993         addToMapW(0xe3, 0x03, 0xC0);
1994         addToMapW(0xe3, 0x06, 0x39);
1995         addToMapW(0xe3, 0x0E, 0x43);
1996         addToMapW(0xe3, 0xFE, 0xC9);
1997         addToMapW(0xe3, 0xFE, 0xCA);
1998         addToMapW(0xe3, 0xFE, 0xCB);
1999         addToMapW(0xe3, 0xFE, 0xCC);
2000         addToMapW(0xe4, 0x01, 0xA9);
2001         addToMapW(0xe4, 0x03, 0xA3);
2002         addToMapW(0xe4, 0x03, 0xC3);
2003         addToMapW(0xe4, 0x04, 0x21);
2004         addToMapW(0xe4, 0x04, 0x41);
2005         addToMapW(0xe4, 0x06, 0x3A);
2006         addToMapW(0xe4, 0x0E, 0x44);
2007         addToMapW(0xe4, 0x22, 0x11);
2008         addToMapW(0xe4, 0xFE, 0xCD);
2009         addToMapW(0xe4, 0xFE, 0xCE);
2010         addToMapW(0xe4, 0xFE, 0xCF);
2011         addToMapW(0xe4, 0xFE, 0xD0);
2012         addToMapW(0xe5, 0x00, 0xD5);
2013         addToMapW(0xe5, 0x00, 0xF5);
2014         addToMapW(0xe5, 0x06, 0x41);
2015         addToMapW(0xe5, 0x0E, 0x45);
2016         addToMapW(0xe5, 0xFE, 0xD1);
2017         addToMapW(0xe5, 0xFE, 0xD2);
2018         addToMapW(0xe5, 0xFE, 0xD3);
2019         addToMapW(0xe5, 0xFE, 0xD4);
2020         addToMapW(0xe6, 0x00, 0xB5);
2021         addToMapW(0xe6, 0x01, 0x60);
2022         addToMapW(0xe6, 0x01, 0x61);
2023         addToMapW(0xe6, 0x03, 0xBC);
2024         addToMapW(0xe6, 0x04, 0x22);
2025         addToMapW(0xe6, 0x04, 0x42);
2026         addToMapW(0xe6, 0x0E, 0x46);
2027         addToMapW(0xe7, 0x03, 0xA4);
2028         addToMapW(0xe7, 0x03, 0xC4);
2029         addToMapW(0xe7, 0x06, 0x42);
2030         addToMapW(0xe7, 0x0E, 0x47);
2031         addToMapW(0xe7, 0xF8, 0xBC);
2032         addToMapW(0xe7, 0xFE, 0xD5);
2033         addToMapW(0xe7, 0xFE, 0xD6);
2034         addToMapW(0xe7, 0xFE, 0xD7);
2035         addToMapW(0xe7, 0xFE, 0xD8);
2036         addToMapW(0xe8, 0x00, 0xD7);
2037         addToMapW(0xe8, 0x00, 0xDE);
2038         addToMapW(0xe8, 0x00, 0xFE);
2039         addToMapW(0xe8, 0x01, 0x36);
2040         addToMapW(0xe8, 0x01, 0x37);
2041         addToMapW(0xe8, 0x01, 0x54);
2042         addToMapW(0xe8, 0x01, 0x55);
2043         addToMapW(0xe8, 0x02, 0x78);
2044         addToMapW(0xe8, 0x03, 0xA6);
2045         addToMapW(0xe8, 0x03, 0xC6);
2046         addToMapW(0xe8, 0x04, 0x23);
2047         addToMapW(0xe8, 0x04, 0x43);
2048         addToMapW(0xe8, 0x06, 0x43);
2049         addToMapW(0xe8, 0x0E, 0x48);
2050         addToMapW(0xe8, 0x22, 0x05);
2051         addToMapW(0xe8, 0xFE, 0xD9);
2052         addToMapW(0xe8, 0xFE, 0xDA);
2053         addToMapW(0xe8, 0xFE, 0xDB);
2054         addToMapW(0xe8, 0xFE, 0xDC);
2055         addToMapW(0xe9, 0x00, 0xDA);
2056         addToMapW(0xe9, 0x00, 0xFA);
2057         addToMapW(0xe9, 0x03, 0x98);
2058         addToMapW(0xe9, 0x06, 0x44);
2059         addToMapW(0xe9, 0x0E, 0x49);
2060         addToMapW(0xe9, 0xFE, 0xDD);
2061         addToMapW(0xe9, 0xFE, 0xDE);
2062         addToMapW(0xe9, 0xFE, 0xDF);
2063         addToMapW(0xe9, 0xFE, 0xE0);
2064         addToMapW(0xea, 0x00, 0xDB);
2065         addToMapW(0xea, 0x00, 0xFB);
2066         addToMapW(0xea, 0x01, 0x3B);
2067         addToMapW(0xea, 0x01, 0x3C);
2068         addToMapW(0xea, 0x03, 0x86);
2069         addToMapW(0xea, 0x03, 0xA9);
2070         addToMapW(0xea, 0x03, 0xAC);
2071         addToMapW(0xea, 0x04, 0x16);
2072         addToMapW(0xea, 0x04, 0x36);
2073         addToMapW(0xea, 0x06, 0x45);
2074         addToMapW(0xea, 0x0E, 0x4A);
2075         addToMapW(0xea, 0x21, 0x26);
2076         addToMapW(0xea, 0xFE, 0xE1);
2077         addToMapW(0xea, 0xFE, 0xE2);
2078         addToMapW(0xea, 0xFE, 0xE3);
2079         addToMapW(0xea, 0xFE, 0xE4);
2080         addToMapW(0xeb, 0x00, 0xD9);
2081         addToMapW(0xeb, 0x00, 0xF9);
2082         addToMapW(0xeb, 0x01, 0x70);
2083         addToMapW(0xeb, 0x01, 0x71);
2084         addToMapW(0xeb, 0x03, 0x88);
2085         addToMapW(0xeb, 0x03, 0x94);
2086         addToMapW(0xeb, 0x03, 0xAD);
2087         addToMapW(0xeb, 0x03, 0xB4);
2088         addToMapW(0xeb, 0x06, 0x46);
2089         addToMapW(0xeb, 0x0E, 0x4B);
2090         addToMapW(0xeb, 0xFE, 0xE5);
2091         addToMapW(0xeb, 0xFE, 0xE6);
2092         addToMapW(0xeb, 0xFE, 0xE7);
2093         addToMapW(0xeb, 0xFE, 0xE8);
2094         addToMapW(0xec, 0x03, 0x01);
2095         addToMapW(0xec, 0x03, 0x89);
2096         addToMapW(0xec, 0x03, 0xAE);
2097         addToMapW(0xec, 0x04, 0x12);
2098         addToMapW(0xec, 0x04, 0x32);
2099         addToMapW(0xec, 0x06, 0x47);
2100         addToMapW(0xec, 0x0E, 0x4C);
2101         addToMapW(0xec, 0x22, 0x1E);
2102         addToMapW(0xec, 0xFE, 0xE9);
2103         addToMapW(0xec, 0xFE, 0xEA);
2104         addToMapW(0xec, 0xFE, 0xEB);
2105         addToMapW(0xec, 0xFE, 0xEC);
2106         addToMapW(0xed, 0x00, 0xDD);
2107         addToMapW(0xed, 0x00, 0xFD);
2108         addToMapW(0xed, 0x01, 0x12);
2109         addToMapW(0xed, 0x01, 0x13);
2110         addToMapW(0xed, 0x03, 0x8A);
2111         addToMapW(0xed, 0x03, 0xAF);
2112         addToMapW(0xed, 0x06, 0x48);
2113         addToMapW(0xed, 0x0E, 0x4D);
2114         addToMapW(0xed, 0xFE, 0xED);
2115         addToMapW(0xed, 0xFE, 0xEE);
2116         addToMapW(0xee, 0x00, 0xAF);
2117         addToMapW(0xee, 0x01, 0x45);
2118         addToMapW(0xee, 0x01, 0x46);
2119         addToMapW(0xee, 0x03, 0x04);
2120         addToMapW(0xee, 0x03, 0x05);
2121         addToMapW(0xee, 0x03, 0x8C);
2122         addToMapW(0xee, 0x03, 0x95);
2123         addToMapW(0xee, 0x03, 0xB5);
2124         addToMapW(0xee, 0x03, 0xCC);
2125         addToMapW(0xee, 0x04, 0x2C);
2126         addToMapW(0xee, 0x04, 0x4C);
2127         addToMapW(0xee, 0x06, 0x49);
2128         addToMapW(0xee, 0x0E, 0x4E);
2129         addToMapW(0xee, 0xFE, 0xEF);
2130         addToMapW(0xee, 0xFE, 0xF0);
2131         addToMapW(0xef, 0x00, 0xB4);
2132         addToMapW(0xef, 0x02, 0xB9);
2133         addToMapW(0xef, 0x02, 0xCA);
2134         addToMapW(0xef, 0x03, 0x01);
2135         addToMapW(0xef, 0x03, 0x8E);
2136         addToMapW(0xef, 0x03, 0xCD);
2137         addToMapW(0xef, 0x06, 0x4A);
2138         addToMapW(0xef, 0x0E, 0x4F);
2139         addToMapW(0xef, 0x20, 0x19);
2140         addToMapW(0xef, 0x20, 0x32);
2141         addToMapW(0xef, 0x20, 0x35);
2142         addToMapW(0xef, 0x21, 0x16);
2143         addToMapW(0xef, 0x22, 0x29);
2144         addToMapW(0xef, 0xFE, 0xF1);
2145         addToMapW(0xef, 0xFE, 0xF2);
2146         addToMapW(0xef, 0xFE, 0xF3);
2147         addToMapW(0xef, 0xFE, 0xF4);
2148         addToMapW(0xf0, 0x00, 0xAD);
2149         addToMapW(0xf0, 0x03, 0x8F);
2150         addToMapW(0xf0, 0x03, 0xCE);
2151         addToMapW(0xf0, 0x04, 0x01);
2152         addToMapW(0xf0, 0x04, 0x51);
2153         addToMapW(0xf0, 0x0E, 0x50);
2154         addToMapW(0xf0, 0x22, 0x61);
2155         addToMapW(0xf1, 0x00, 0xB1);
2156         addToMapW(0xf1, 0x02, 0xDD);
2157         addToMapW(0xf1, 0x06, 0x4B);
2158         addToMapW(0xf1, 0x0E, 0x51);
2159         addToMapW(0xf1, 0x22, 0x13);
2160         addToMapW(0xf1, 0xFE, 0x70);
2161         addToMapW(0xf1, 0xFE, 0x71);
2162         addToMapW(0xf2, 0x02, 0xDB);
2163         addToMapW(0xf2, 0x03, 0x23);
2164         addToMapW(0xf2, 0x04, 0x04);
2165         addToMapW(0xf2, 0x04, 0x2B);
2166         addToMapW(0xf2, 0x04, 0x4B);
2167         addToMapW(0xf2, 0x04, 0x54);
2168         addToMapW(0xf2, 0x06, 0x4C);
2169         addToMapW(0xf2, 0x0E, 0x52);
2170         addToMapW(0xf2, 0x20, 0x17);
2171         addToMapW(0xf2, 0x20, 0x1C);
2172         addToMapW(0xf2, 0x22, 0x65);
2173         addToMapW(0xf2, 0xF8, 0xBD);
2174         addToMapW(0xf2, 0xFE, 0x72);
2175         addToMapW(0xf3, 0x00, 0xBE);
2176         addToMapW(0xf3, 0x02, 0xC7);
2177         addToMapW(0xf3, 0x03, 0x0C);
2178         addToMapW(0xf3, 0x06, 0x4D);
2179         addToMapW(0xf3, 0x0E, 0x53);
2180         addToMapW(0xf3, 0x22, 0x64);
2181         addToMapW(0xf3, 0xFE, 0x74);
2182         addToMapW(0xf4, 0x00, 0xB6);
2183         addToMapW(0xf4, 0x02, 0xD8);
2184         addToMapW(0xf4, 0x03, 0x06);
2185         addToMapW(0xf4, 0x03, 0xAA);
2186         addToMapW(0xf4, 0x03, 0xCA);
2187         addToMapW(0xf4, 0x04, 0x07);
2188         addToMapW(0xf4, 0x04, 0x17);
2189         addToMapW(0xf4, 0x04, 0x37);
2190         addToMapW(0xf4, 0x04, 0x57);
2191         addToMapW(0xf4, 0x06, 0x4E);
2192         addToMapW(0xf4, 0x0E, 0x54);
2193         addToMapW(0xf4, 0x23, 0x20);
2194         addToMapW(0xf4, 0xFE, 0x76);
2195         addToMapW(0xf4, 0xFE, 0x77);
2196         addToMapW(0xf5, 0x00, 0xA7);
2197         addToMapW(0xf5, 0x03, 0xAB);
2198         addToMapW(0xf5, 0x03, 0xCB);
2199         addToMapW(0xf5, 0x06, 0x4F);
2200         addToMapW(0xf5, 0x0E, 0x55);
2201         addToMapW(0xf5, 0x23, 0x21);
2202         addToMapW(0xf5, 0xFE, 0x78);
2203         addToMapW(0xf5, 0xFE, 0x79);
2204         addToMapW(0xf6, 0x00, 0xF7);
2205         addToMapW(0xf6, 0x04, 0x0E);
2206         addToMapW(0xf6, 0x04, 0x28);
2207         addToMapW(0xf6, 0x04, 0x48);
2208         addToMapW(0xf6, 0x04, 0x5E);
2209         addToMapW(0xf6, 0x06, 0x50);
2210         addToMapW(0xf6, 0x0E, 0x56);
2211         addToMapW(0xf6, 0xFE, 0x7A);
2212         addToMapW(0xf6, 0xFE, 0x7B);
2213         addToMapW(0xf7, 0x00, 0xB8);
2214         addToMapW(0xf7, 0x00, 0xF7);
2215         addToMapW(0xf7, 0x02, 0xDB);
2216         addToMapW(0xf7, 0x03, 0x27);
2217         addToMapW(0xf7, 0x0E, 0x57);
2218         addToMapW(0xf7, 0x20, 0x1E);
2219         addToMapW(0xf7, 0x22, 0x48);
2220         addToMapW(0xf8, 0x00, 0xB0);
2221         addToMapW(0xf8, 0x02, 0xDA);
2222         addToMapW(0xf8, 0x03, 0x0A);
2223         addToMapW(0xf8, 0x04, 0x2D);
2224         addToMapW(0xf8, 0x04, 0x4D);
2225         addToMapW(0xf8, 0x0E, 0x58);
2226         addToMapW(0xf8, 0x20, 0x70);
2227         addToMapW(0xf8, 0x22, 0x18);
2228         addToMapW(0xf9, 0x00, 0xA8);
2229         addToMapW(0xf9, 0x02, 0xDD);
2230         addToMapW(0xf9, 0x03, 0x08);
2231         addToMapW(0xf9, 0x0E, 0x59);
2232         addToMapW(0xf9, 0x22, 0x19);
2233         addToMapW(0xfa, 0x00, 0xB7);
2234         addToMapW(0xfa, 0x02, 0xD9);
2235         addToMapW(0xfa, 0x03, 0x07);
2236         addToMapW(0xfa, 0x04, 0x29);
2237         addToMapW(0xfa, 0x04, 0x49);
2238         addToMapW(0xfa, 0x0E, 0x5A);
2239         addToMapW(0xfa, 0x20, 0x24);
2240         addToMapW(0xfa, 0x22, 0xC5);
2241         addToMapW(0xfa, 0x30, 0xFB);
2242         addToMapW(0xfb, 0x00, 0xB9);
2243         addToMapW(0xfb, 0x0E, 0x5B);
2244         addToMapW(0xfb, 0x20, 0x81);
2245         addToMapW(0xfb, 0x22, 0x1A);
2246         addToMapW(0xfb, 0x27, 0x13);
2247         addToMapW(0xfc, 0x00, 0xB3);
2248         addToMapW(0xfc, 0x01, 0x58);
2249         addToMapW(0xfc, 0x01, 0x59);
2250         addToMapW(0xfc, 0x04, 0x27);
2251         addToMapW(0xfc, 0x04, 0x47);
2252         addToMapW(0xfc, 0x20, 0x7F);
2253         addToMapW(0xfc, 0x20, 0x83);
2254         addToMapW(0xfc, 0x21, 0x16);
2255         addToMapW(0xfc, 0xF8, 0xC5);
2256         addToMapW(0xfd, 0x00, 0xA4);
2257         addToMapW(0xfd, 0x00, 0xA7);
2258         addToMapW(0xfd, 0x00, 0xB2);
2259         addToMapW(0xfd, 0x20, 0x82);
2260         addToMapW(0xfd, 0xF8, 0xC6);
2261         addToMapW(0xfd, 0xF8, 0xF1);
2262         addToMapW(0xfe, 0x20, 0xAB);
2263         addToMapW(0xfe, 0x25, 0xA0);
2264         addToMapW(0xfe, 0xF8, 0xC7);
2265         addToMapW(0xfe, 0xF8, 0xF2);
2266         addToMapW(0xff, 0x00, 0xA0);
2267         addToMapW(0xff, 0xF8, 0xC8);
2268         addToMapW(0xff, 0xF8, 0xF3);
2269 }