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

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