using System; using System.Drawing; using System.Drawing.Text; using System.Linq; using System.Runtime.InteropServices; using PKHeX.Properties; namespace PKHeX { internal static class PKX { internal const int SIZE_3PARTY = 100; internal const int SIZE_3STORED = 80; internal const int SIZE_3BLOCK = 12; internal const int SIZE_4PARTY = 236; internal const int SIZE_4STORED = 136; internal const int SIZE_4BLOCK = 32; internal const int SIZE_5PARTY = 220; internal const int SIZE_5STORED = 136; internal const int SIZE_5BLOCK = 32; internal const int SIZE_6PARTY = 0x104; internal const int SIZE_6STORED = 0xE8; internal const int SIZE_6BLOCK = 56; internal static bool getIsPKM(long len) { return new[] {SIZE_3STORED, SIZE_3PARTY, SIZE_4STORED, SIZE_4PARTY, SIZE_5PARTY, SIZE_6STORED, SIZE_6PARTY}.Contains((int)len); } // C# PKX Function Library // No WinForm object related code, only to calculate information. // May require re-referencing to main form for string array referencing. // Relies on Util for some common operations. // Data internal static uint LCRNG(uint seed) { const uint a = 0x41C64E6D; const uint c = 0x00006073; return seed * a + c; } internal static uint LCRNG(ref uint seed) { const uint a = 0x41C64E6D; const uint c = 0x00006073; return seed = seed * a + c; } #region ExpTable internal static readonly uint[,] ExpTable = { {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {8, 15, 4, 9, 6, 10}, {27, 52, 13, 57, 21, 33}, {64, 122, 32, 96, 51, 80}, {125, 237, 65, 135, 100, 156}, {216, 406, 112, 179, 172, 270}, {343, 637, 178, 236, 274, 428}, {512, 942, 276, 314, 409, 640}, {729, 1326, 393, 419, 583, 911}, {1000, 1800, 540, 560, 800, 1250}, {1331, 2369, 745, 742, 1064, 1663}, {1728, 3041, 967, 973, 1382, 2160}, {2197, 3822, 1230, 1261, 1757, 2746}, {2744, 4719, 1591, 1612, 2195, 3430}, {3375, 5737, 1957, 2035, 2700, 4218}, {4096, 6881, 2457, 2535, 3276, 5120}, {4913, 8155, 3046, 3120, 3930, 6141}, {5832, 9564, 3732, 3798, 4665, 7290}, {6859, 11111, 4526, 4575, 5487, 8573}, {8000, 12800, 5440, 5460, 6400, 10000}, {9261, 14632, 6482, 6458, 7408, 11576}, {10648, 16610, 7666, 7577, 8518, 13310}, {12167, 18737, 9003, 8825, 9733, 15208}, {13824, 21012, 10506, 10208, 11059, 17280}, {15625, 23437, 12187, 11735, 12500, 19531}, {17576, 26012, 14060, 13411, 14060, 21970}, {19683, 28737, 16140, 15244, 15746, 24603}, {21952, 31610, 18439, 17242, 17561, 27440}, {24389, 34632, 20974, 19411, 19511, 30486}, {27000, 37800, 23760, 21760, 21600, 33750}, {29791, 41111, 26811, 24294, 23832, 37238}, {32768, 44564, 30146, 27021, 26214, 40960}, {35937, 48155, 33780, 29949, 28749, 44921}, {39304, 51881, 37731, 33084, 31443, 49130}, {42875, 55737, 42017, 36435, 34300, 53593}, {46656, 59719, 46656, 40007, 37324, 58320}, {50653, 63822, 50653, 43808, 40522, 63316}, {54872, 68041, 55969, 47846, 43897, 68590}, {59319, 72369, 60505, 52127, 47455, 74148}, {64000, 76800, 66560, 56660, 51200, 80000}, {68921, 81326, 71677, 61450, 55136, 86151}, {74088, 85942, 78533, 66505, 59270, 92610}, {79507, 90637, 84277, 71833, 63605, 99383}, {85184, 95406, 91998, 77440, 68147, 106480}, {91125, 100237, 98415, 83335, 72900, 113906}, {97336, 105122, 107069, 89523, 77868, 121670}, {103823, 110052, 114205, 96012, 83058, 129778}, {110592, 115015, 123863, 102810, 88473, 138240}, {117649, 120001, 131766, 109923, 94119, 147061}, {125000, 125000, 142500, 117360, 100000, 156250}, {132651, 131324, 151222, 125126, 106120, 165813}, {140608, 137795, 163105, 133229, 112486, 175760}, {148877, 144410, 172697, 141677, 119101, 186096}, {157464, 151165, 185807, 150476, 125971, 196830}, {166375, 158056, 196322, 159635, 133100, 207968}, {175616, 165079, 210739, 169159, 140492, 219520}, {185193, 172229, 222231, 179056, 148154, 231491}, {195112, 179503, 238036, 189334, 156089, 243890}, {205379, 186894, 250562, 199999, 164303, 256723}, {216000, 194400, 267840, 211060, 172800, 270000}, {226981, 202013, 281456, 222522, 181584, 283726}, {238328, 209728, 300293, 234393, 190662, 297910}, {250047, 217540, 315059, 246681, 200037, 312558}, {262144, 225443, 335544, 259392, 209715, 327680}, {274625, 233431, 351520, 272535, 219700, 343281}, {287496, 241496, 373744, 286115, 229996, 359370}, {300763, 249633, 390991, 300140, 240610, 375953}, {314432, 257834, 415050, 314618, 251545, 393040}, {328509, 267406, 433631, 329555, 262807, 410636}, {343000, 276458, 459620, 344960, 274400, 428750}, {357911, 286328, 479600, 360838, 286328, 447388}, {373248, 296358, 507617, 377197, 298598, 466560}, {389017, 305767, 529063, 394045, 311213, 486271}, {405224, 316074, 559209, 411388, 324179, 506530}, {421875, 326531, 582187, 429235, 337500, 527343}, {438976, 336255, 614566, 447591, 351180, 548720}, {456533, 346965, 639146, 466464, 365226, 570666}, {474552, 357812, 673863, 485862, 379641, 593190}, {493039, 367807, 700115, 505791, 394431, 616298}, {512000, 378880, 737280, 526260, 409600, 640000}, {531441, 390077, 765275, 547274, 425152, 664301}, {551368, 400293, 804997, 568841, 441094, 689210}, {571787, 411686, 834809, 590969, 457429, 714733}, {592704, 423190, 877201, 613664, 474163, 740880}, {614125, 433572, 908905, 636935, 491300, 767656}, {636056, 445239, 954084, 660787, 508844, 795070}, {658503, 457001, 987754, 685228, 526802, 823128}, {681472, 467489, 1035837, 710266, 545177, 851840}, {704969, 479378, 1071552, 735907, 563975, 881211}, {729000, 491346, 1122660, 762160, 583200, 911250}, {753571, 501878, 1160499, 789030, 602856, 941963}, {778688, 513934, 1214753, 816525, 622950, 973360}, {804357, 526049, 1254796, 844653, 643485, 1005446}, {830584, 536557, 1312322, 873420, 664467, 1038230}, {857375, 548720, 1354652, 902835, 685900, 1071718}, {884736, 560922, 1415577, 932903, 707788, 1105920}, {912673, 571333, 1460276, 963632, 730138, 1140841}, {941192, 583539, 1524731, 995030, 752953, 1176490}, {970299, 591882, 1571884, 1027103, 776239, 1212873}, {1000000, 600000, 1640000, 1059860, 800000, 1250000}, }; #endregion internal static readonly string[][] SpeciesLang = { Util.getStringList("species", "ja"), // none Util.getStringList("species", "ja"), // 1 Util.getStringList("species", "en"), // 2 Util.getStringList("species", "fr"), // 3 Util.getStringList("species", "it"), // 4 Util.getStringList("species", "de"), // 5 Util.getStringList("species", "es"), // none Util.getStringList("species", "es"), // 7 Util.getStringList("species", "ko"), // 8 }; internal static string getSpeciesName(int species, int lang) { try { return SpeciesLang[lang][species]; } catch { return ""; } } internal static bool getIsNicknamed(int species, string nick) { try { return SpeciesLang.All(list => list[species].ToUpper() != nick); } catch { return false; } } internal static PersonalTable Personal = PersonalTable.AO; // Stat Fetching internal static int getMovePP(int move, int ppup) { return getBasePP(move) * (5 + ppup) / 5; } internal static int getBasePP(int move) { byte[] movepptable = { 00, 35, 25, 10, 15, 20, 20, 15, 15, 15, 35, 30, 05, 10, 20, 30, 35, 35, 20, 15, 20, 20, 25, 20, 30, 05, 10, 15, 15, 15, 25, 20, 05, 35, 15, 20, 20, 10, 15, 30, 35, 20, 20, 30, 25, 40, 20, 15, 20, 20, 20, 30, 25, 15, 30, 25, 05, 15, 10, 05, 20, 20, 20, 05, 35, 20, 25, 20, 20, 20, 15, 25, 15, 10, 20, 25, 10, 35, 30, 15, 10, 40, 10, 15, 30, 15, 20, 10, 15, 10, 05, 10, 10, 25, 10, 20, 40, 30, 30, 20, 20, 15, 10, 40, 15, 10, 30, 10, 20, 10, 40, 40, 20, 30, 30, 20, 30, 10, 10, 20, 05, 10, 30, 20, 20, 20, 05, 15, 10, 20, 10, 15, 35, 20, 15, 10, 10, 30, 15, 40, 20, 15, 10, 05, 10, 30, 10, 15, 20, 15, 40, 20, 10, 05, 15, 10, 10, 10, 15, 30, 30, 10, 10, 20, 10, 01, 01, 10, 25, 10, 05, 15, 25, 15, 10, 15, 30, 05, 40, 15, 10, 25, 10, 30, 10, 20, 10, 10, 10, 10, 10, 20, 05, 40, 05, 05, 15, 05, 10, 05, 10, 10, 10, 10, 20, 20, 40, 15, 10, 20, 20, 25, 05, 15, 10, 05, 20, 15, 20, 25, 20, 05, 30, 05, 10, 20, 40, 05, 20, 40, 20, 15, 35, 10, 05, 05, 05, 15, 05, 20, 05, 05, 15, 20, 10, 05, 05, 15, 10, 15, 15, 10, 10, 10, 20, 10, 10, 10, 10, 15, 15, 15, 10, 20, 20, 10, 20, 20, 20, 20, 20, 10, 10, 10, 20, 20, 05, 15, 10, 10, 15, 10, 20, 05, 05, 10, 10, 20, 05, 10, 20, 10, 20, 20, 20, 05, 05, 15, 20, 10, 15, 20, 15, 10, 10, 15, 10, 05, 05, 10, 15, 10, 05, 20, 25, 05, 40, 15, 05, 40, 15, 20, 20, 05, 15, 20, 20, 15, 15, 05, 10, 30, 20, 30, 15, 05, 40, 15, 05, 20, 05, 15, 25, 25, 15, 20, 15, 20, 15, 20, 10, 20, 20, 05, 05, 10, 05, 40, 10, 10, 05, 10, 10, 15, 10, 20, 15, 30, 10, 20, 05, 10, 10, 15, 10, 10, 05, 15, 05, 10, 10, 30, 20, 20, 10, 10, 05, 05, 10, 05, 20, 10, 20, 10, 15, 10, 20, 20, 20, 15, 15, 10, 15, 15, 15, 10, 10, 10, 20, 10, 30, 05, 10, 15, 10, 10, 05, 20, 30, 10, 30, 15, 15, 15, 15, 30, 10, 20, 15, 10, 10, 20, 15, 05, 05, 15, 15, 05, 10, 05, 20, 05, 15, 20, 05, 20, 20, 20, 20, 10, 20, 10, 15, 20, 15, 10, 10, 05, 10, 05, 05, 10, 05, 05, 10, 05, 05, 05, 15, 10, 10, 10, 10, 10, 10, 15, 20, 15, 10, 15, 10, 15, 10, 20, 10, 15, 10, 20, 20, 20, 20, 20, 15, 15, 15, 15, 15, 15, 20, 15, 10, 15, 15, 15, 15, 10, 10, 10, 10, 10, 15, 15, 15, 15, 05, 05, 15, 05, 10, 10, 10, 20, 20, 20, 10, 10, 30, 15, 15, 10, 15, 25, 10, 15, 10, 10, 10, 20, 10, 10, 10, 10, 10, 15, 15, 05, 05, 10, 10, 10, 05, 05, 10, 05, 05, 15, 10, 05, 05, 05, 10, 10, 10, 10, 20, 25, 10, 20, 30, 25, 20, 20, 15, 20, 15, 20, 20, 10, 10, 10, 10, 10, 20, 10, 30, 15, 10, 10, 10, 20, 20, 05, 05, 05, 20, 10, 10, 20, 15, 20, 20, 10, 20, 30, 10, 10, 40, 40, 30, 20, 40, 20, 20, 10, 10, 10, 10, 05, 10, 10, 05, 05 }; if (move < 0) move = 0; return movepptable[move]; } internal static byte[] getRandomEVs() { byte[] evs = new byte[6]; do { evs[0] = (byte)Math.Min(Util.rnd32() % 300, 252); // bias two to get maybe 252 evs[1] = (byte)Math.Min(Util.rnd32() % 300, 252); evs[2] = (byte)Math.Min(Util.rnd32() % (510 - evs[0] - evs[1]), 252); evs[3] = (byte)Math.Min(Util.rnd32() % (510 - evs[0] - evs[1] - evs[2]), 252); evs[4] = (byte)Math.Min(Util.rnd32() % (510 - evs[0] - evs[1] - evs[2] - evs[3]), 252); evs[5] = (byte)Math.Min(510 - evs[0] - evs[1] - evs[2] - evs[3] - evs[4], 252); } while (evs.Sum(b => b) > 510); // recalculate random EVs... Util.Shuffle(evs); return evs; } internal static int getBaseFriendship(int species) { return Personal[species].BaseFriendship; } internal static int getLevel(int species, uint exp) { int growth = Personal[species].EXPGrowth; int tl = 1; // Initial Level. Iterate upwards to find the level while (ExpTable[++tl, growth] <= exp) if (tl == 100) return 100; return --tl; } internal static bool getIsShiny(uint PID, uint TID, uint SID) { uint PSV = getPSV(PID); uint TSV = getTSV(TID, SID); return TSV == PSV; } internal static uint getEXP(int level, int species) { if (level <= 1) return 0; if (level > 100) level = 100; return ExpTable[level, Personal[species].EXPGrowth]; } internal static int[] getAbilities(int species, int formnum) { return Personal[Personal[species].FormeIndex(species, formnum)].Abilities; } internal static int getAbilityNumber(int species, int ability, int formnum) { int[] spec_abilities = getAbilities(species, formnum); int abilval = Array.IndexOf(spec_abilities, ability); if (abilval >= 0) return 1 << abilval; return -1; } internal static int getGender(string s) { if (s == null) return -1; if (s == "♂" || s == "M") return 0; if (s == "♀" || s == "F") return 1; return 2; } internal static string[] getCountryRegionText(int country, int region, string lang) { // Get Language we're fetching for int index = Array.IndexOf(new[] { "ja", "en", "fr", "de", "it", "es", "zh", "ko"}, lang); // Return value storage string[] data = new string[2]; // country, region // Get Country Text try { string[] inputCSV = Util.getStringList("countries"); // Set up our Temporary Storage string[] unsortedList = new string[inputCSV.Length - 1]; int[] indexes = new int[inputCSV.Length - 1]; // Gather our data from the input file for (int i = 1; i < inputCSV.Length; i++) { string[] countryData = inputCSV[i].Split(','); if (countryData.Length <= 1) continue; indexes[i - 1] = Convert.ToInt32(countryData[0]); unsortedList[i - 1] = countryData[index + 1]; } int countrynum = Array.IndexOf(indexes, country); data[0] = unsortedList[countrynum]; } catch { data[0] = "Illegal"; } // Get Region Text try { string[] inputCSV = Util.getStringList("sr_" + country.ToString("000")); // Set up our Temporary Storage string[] unsortedList = new string[inputCSV.Length - 1]; int[] indexes = new int[inputCSV.Length - 1]; // Gather our data from the input file for (int i = 1; i < inputCSV.Length; i++) { string[] countryData = inputCSV[i].Split(','); if (countryData.Length <= 1) continue; indexes[i - 1] = Convert.ToInt32(countryData[0]); unsortedList[i - 1] = countryData[index + 1]; } int regionnum = Array.IndexOf(indexes, region); data[1] = unsortedList[regionnum]; } catch { data[1] = "Illegal"; } return data; } internal static string getLocation(PKM pk, bool egg) { return getLocation(egg, pk.Version, egg ? pk.Egg_Location : pk.Met_Location, pk.Format); } internal static string getLocation(bool eggmet, int gameorigin, int locval, int format) { if (gameorigin < 0x10 && (eggmet || format < 5)) { if (locval < 2000) return Main.metHGSS_00000[locval]; if (locval < 3000) return Main.metHGSS_02000[locval % 2000]; return Main.metHGSS_03000[locval % 3000]; } if (gameorigin < 24) { if (locval < 30000) return Main.metBW2_00000[locval]; if (locval < 40000) return Main.metBW2_30000[locval % 10000 - 1]; if (locval < 60000) return Main.metBW2_40000[locval % 10000 - 1]; return Main.metBW2_60000[locval % 10000 - 1]; } if (gameorigin > 23) { if (locval < 30000) return Main.metXY_00000[locval]; if (locval < 40000) return Main.metXY_30000[locval % 10000 - 1]; if (locval < 60000) return Main.metXY_40000[locval % 10000 - 1]; return Main.metXY_60000[locval % 10000 - 1]; } return null; // Shouldn't happen. } internal static string[] getQRText(PKM pkm) { string[] response = new string[3]; // Summarize string filename = pkm.Nickname; if (pkm.Nickname != Main.specieslist[pkm.Species] && Main.specieslist[pkm.Species] != null) filename += $" ({Main.specieslist[pkm.Species]})"; response[0] = $"{filename} [{Main.abilitylist[pkm.Ability]}] lv{pkm.Stat_Level} @ {Main.itemlist[pkm.HeldItem]} -- {Main.natures[pkm.Nature]}"; response[1] = $"{Main.movelist[pkm.Move1]} / {Main.movelist[pkm.Move2]} / {Main.movelist[pkm.Move3]} / {Main.movelist[pkm.Move4]}"; response[2] = String.Format( "IVs:{0}{1}{2}{3}{4}{5}" + Environment.NewLine + Environment.NewLine + "EVs:{6}{7}{8}{9}{10}{11}", Environment.NewLine + pkm.IV_HP.ToString("00"), Environment.NewLine + pkm.IV_ATK.ToString("00"), Environment.NewLine + pkm.IV_DEF.ToString("00"), Environment.NewLine + pkm.IV_SPA.ToString("00"), Environment.NewLine + pkm.IV_SPD.ToString("00"), Environment.NewLine + pkm.IV_SPE.ToString("00"), Environment.NewLine + pkm.EV_HP, Environment.NewLine + pkm.EV_ATK, Environment.NewLine + pkm.EV_DEF, Environment.NewLine + pkm.EV_SPA, Environment.NewLine + pkm.EV_SPD, Environment.NewLine + pkm.EV_SPE); return response; } internal static string getFileName(PKM pkm) { return $"{pkm.Species.ToString("000")}{(pkm.IsShiny ? " ★" : "")} - {pkm.Nickname} - {pkm.Checksum.ToString("X4")}{pkm.EncryptionConstant.ToString("X8")}.{pkm.Extension}"; } internal static ushort[] getStats(PKM pkm) { return getStats(pkm.Species, pkm.Stat_Level, pkm.Nature, pkm.AltForm, pkm.EV_HP, pkm.EV_ATK, pkm.EV_DEF, pkm.EV_SPA, pkm.EV_SPD, pkm.EV_SPE, pkm.IV_HP, pkm.IV_ATK, pkm.IV_DEF, pkm.IV_SPA, pkm.IV_SPD, pkm.IV_SPE); } internal static ushort[] getStats(int species, int level, int nature, int form, int HP_EV, int ATK_EV, int DEF_EV, int SPA_EV, int SPD_EV, int SPE_EV, int HP_IV, int ATK_IV, int DEF_IV, int SPA_IV, int SPD_IV, int SPE_IV) { PersonalInfo p = Personal[Personal[species].FormeIndex(species, form)]; // Calculate Stats ushort[] stats = new ushort[6]; // Stats are stored as ushorts in the PKX structure. We'll cap them as such. stats[0] = (ushort)(p.HP == 1 ? 1 : (HP_IV + 2 * p.HP + HP_EV / 4 + 100) * level / 100 + 10); stats[1] = (ushort)((ATK_IV + 2 * p.ATK + ATK_EV / 4) * level / 100 + 5); stats[2] = (ushort)((DEF_IV + 2 * p.DEF + DEF_EV / 4) * level / 100 + 5); stats[4] = (ushort)((SPA_IV + 2 * p.SPA + SPA_EV / 4) * level / 100 + 5); stats[5] = (ushort)((SPD_IV + 2 * p.SPD + SPD_EV / 4) * level / 100 + 5); stats[3] = (ushort)((SPE_IV + 2 * p.SPE + SPE_EV / 4) * level / 100 + 5); // Account for nature int incr = nature / 5 + 1; int decr = nature % 5 + 1; if (incr == decr) return stats; // if neutral return stats without mod stats[incr] *= 11; stats[incr] /= 10; stats[decr] *= 9; stats[decr] /= 10; // Return Result return stats; } // PKX Manipulation internal static readonly byte[][] blockPosition = { new byte[] {0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 2, 3, 1, 1, 2, 3, 2, 3, 1, 1, 2, 3, 2, 3}, new byte[] {1, 1, 2, 3, 2, 3, 0, 0, 0, 0, 0, 0, 2, 3, 1, 1, 3, 2, 2, 3, 1, 1, 3, 2}, new byte[] {2, 3, 1, 1, 3, 2, 2, 3, 1, 1, 3, 2, 0, 0, 0, 0, 0, 0, 3, 2, 3, 2, 1, 1}, new byte[] {3, 2, 3, 2, 1, 1, 3, 2, 3, 2, 1, 1, 3, 2, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0}, }; internal static readonly byte[] blockPositionInvert = { 0, 1, 2, 4, 3, 5, 6, 7, 12, 18, 13, 19, 8, 10, 14, 20, 16, 22, 9, 11, 15, 21, 17, 23 }; internal static byte[] shuffleArray(byte[] data, uint sv) { byte[] sdata = new byte[data.Length]; Array.Copy(data, sdata, 8); // Copy unshuffled bytes // Shuffle Away! for (int block = 0; block < 4; block++) Array.Copy(data, 8 + 56*blockPosition[block][sv], sdata, 8 + 56*block, 56); // Fill the Battle Stats back if (data.Length > 232) Array.Copy(data, 232, sdata, 232, 28); return sdata; } internal static byte[] decryptArray(byte[] ekx) { byte[] pkx = (byte[])ekx.Clone(); uint pv = BitConverter.ToUInt32(pkx, 0); uint sv = (pv >> 0xD & 0x1F) % 24; uint seed = pv; // Decrypt Blocks with RNG Seed for (int i = 8; i < 232; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(pkx, i) ^ LCRNG(ref seed) >> 16)).CopyTo(pkx, i); // Deshuffle pkx = shuffleArray(pkx, sv); // Decrypt the Party Stats seed = pv; if (pkx.Length <= 232) return pkx; for (int i = 232; i < 260; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(pkx, i) ^ LCRNG(ref seed) >> 16)).CopyTo(pkx, i); return pkx; } internal static byte[] encryptArray(byte[] pkx) { // Shuffle uint pv = BitConverter.ToUInt32(pkx, 0); uint sv = (pv >> 0xD & 0x1F) % 24; byte[] ekx = (byte[])pkx.Clone(); ekx = shuffleArray(ekx, blockPositionInvert[sv]); uint seed = pv; // Encrypt Blocks with RNG Seed for (int i = 8; i < 232; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(ekx, i) ^ LCRNG(ref seed) >> 16)).CopyTo(ekx, i); // If no party stats, return. if (ekx.Length <= 232) return ekx; // Encrypt the Party Stats seed = pv; for (int i = 232; i < 260; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(ekx, i) ^ LCRNG(ref seed) >> 16)).CopyTo(ekx, i); // Done return ekx; } internal static ushort getCHK(byte[] data) { ushort chk = 0; for (int i = 8; i < 232; i += 2) // Loop through the entire PKX chk += BitConverter.ToUInt16(data, i); return chk; } internal static bool verifychk(byte[] input) { ushort checksum = 0; if (input.Length == 100 || input.Length == 80) // Gen 3 Files { for (int i = 32; i < 80; i += 2) checksum += BitConverter.ToUInt16(input, i); return checksum == BitConverter.ToUInt16(input, 28); } if (input.Length == 236 || input.Length == 220 || input.Length == 136) // Gen 4/5 Array.Resize(ref input, 136); else if (input.Length == 232 || input.Length == 260) // Gen 6 Array.Resize(ref input, 232); else throw new ArgumentException("Wrong sized input array to verifychecksum"); ushort chk = 0; for (int i = 8; i < input.Length; i += 2) chk += BitConverter.ToUInt16(input, i); return chk == BitConverter.ToUInt16(input, 0x6); } internal static uint getPSV(uint PID) { return (PID >> 16 ^ PID & 0xFFFF) >> 4; } internal static uint getTSV(uint TID, uint SID) { return (TID ^ SID) >> 4; } internal static uint getRandomPID(int species, int cg, int origin, int nature, int form) { int gt = Personal[species].Gender; if (origin >= 24) return Util.rnd32(); bool g3unown = origin <= 5 && species == 201; while (true) // Loop until we find a suitable PID { uint pid = Util.rnd32(); // Gen 3/4: Nature derived from PID if (origin <= 15 && pid%25 != nature) continue; // Gen 3 Unown: Letter/form derived from PID if (g3unown) { uint pidLetter = ((pid & 0x3000000) >> 18 | (pid & 0x30000) >> 12 | (pid & 0x300) >> 6 | pid & 0x3) % 28; if (pidLetter != form) continue; } // Gen 3/4/5: Gender derived from PID uint gv = pid & 0xFF; if (gt == 255 || gt == 254 || gt == 0) // Set Gender(less) return pid; // PID can be anything if (cg == 1 && gv <= gt) // Female return pid; // PID Passes if (cg == 0 && gv > gt) // Male return pid; // PID Passes } } // Data Requests internal static Image getSprite(int species, int form, int gender, int item, bool isegg, bool shiny) { if (species == 0) return (Image)Resources.ResourceManager.GetObject("_0"); if (new[] { 664, 665, 414, 493 }.Contains(species)) // Species who show their default sprite regardless of Form form = 0; string file = "_" + species; if (form > 0) // Alt Form Handling file = file + "_" + form; else if (gender == 1 && new[] { 592, 593, 521, 668 }.Contains(species)) // Frillish & Jellicent, Unfezant & Pyroar file = file + "_" + gender; // Redrawing logic Image baseImage = (Image)Resources.ResourceManager.GetObject(file); if (baseImage == null) { if (species < 722) { baseImage = Util.LayerImage( (Image)Resources.ResourceManager.GetObject("_" + species), Resources.unknown, 0, 0, .5); } else baseImage = Resources.unknown; } if (isegg) { // Start with a partially transparent species by layering the species with partial opacity onto a blank image. baseImage = Util.LayerImage((Image)Resources.ResourceManager.GetObject("_0"), baseImage, 0, 0, 0.33); // Add the egg layer over-top with full opacity. baseImage = Util.LayerImage(baseImage, (Image)Resources.ResourceManager.GetObject("egg"), 0, 0, 1); } if (shiny) { // Add shiny star to top left of image. baseImage = Util.LayerImage(baseImage, Resources.rare_icon, 0, 0, 0.7); } if (item > 0) { Image itemimg = (Image)Resources.ResourceManager.GetObject("item_" + item) ?? Resources.helditem; // Redraw baseImage = Util.LayerImage(baseImage, itemimg, 22 + (15 - itemimg.Width) / 2, 15 + (15 - itemimg.Height), 1); } return baseImage; } internal static Image getSprite(PKM pkm) { return getSprite(pkm.Species, pkm.AltForm, pkm.Gender, pkm.HeldItem, pkm.IsEgg, pkm.IsShiny); } // Font Related [DllImport("gdi32.dll")] private static extern IntPtr AddFontMemResourceEx(IntPtr pbFont, uint cbFont, IntPtr pdv, [In] ref uint pcFonts); private static readonly PrivateFontCollection s_FontCollection = new PrivateFontCollection(); private static FontFamily[] FontFamilies { get { if (s_FontCollection.Families.Length == 0) setPKXFont(); return s_FontCollection.Families; } } internal static Font getPKXFont(float size) { return new Font(FontFamilies[0], size); } private static void setPKXFont() { try { byte[] fontData = Resources.pgldings_normalregular; IntPtr fontPtr = Marshal.AllocCoTaskMem(fontData.Length); Marshal.Copy(fontData, 0, fontPtr, fontData.Length); s_FontCollection.AddMemoryFont(fontPtr, Resources.pgldings_normalregular.Length); uint dummy = 0; AddFontMemResourceEx(fontPtr, (uint)Resources.pgldings_normalregular.Length, IntPtr.Zero, ref dummy); Marshal.FreeCoTaskMem(fontPtr); } catch { Util.Error("Unable to add ingame font."); } } // Personal.dat internal static string[] getFormList(int species, string[] t, string[] f, string[] g) { // Mega List if (Array.IndexOf(new[] { // XY 003, 009, 065, 094, 115, 127, 130, 142, 181, 212, 214, 229, 248, 257, 282, 303, 306, 308, 310, 354, 359, 380, 381, 445, 448, 460, // ORAS 015, 018, 080, 208, 254, 260, 302, 319, 323, 334, 362, 373, 376, 384, 428, 475, 531, 719, }, species) > -1) { // ... return new[] { t[000], // Normal f[723], // Mega };} // MegaXY List switch (species) { case 6: case 150: return new[] { t[000], // Normal f[724], // Mega X f[725], // Mega Y }; case 025: return new[] { t[000], // Normal f[729], // Rockstar f[730], // Belle f[731], // Pop f[732], // PhD f[733], // Libre f[734], // Cosplay }; case 201: return new[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "!", "?", }; case 351: return new[] { t[000], // Normal f[789], // Sunny f[790], // Rainy f[791], // Snowy }; case 382: case 383: return new[] { t[000], // Normal f[800], // Primal }; case 386: return new[] { t[000], // Normal f[802], // Attack f[803], // Defense f[804], // Speed }; case 412: case 413: case 414: return new[] { f[412], // Plant f[805], // Sandy f[806], // Trash }; case 421: return new[] { f[421], // Overcast f[809], // Sunshine }; case 422: case 423: return new[] { f[422], // West f[811], // East }; case 479: return new[] { t[000], // Normal f[817], // Heat f[818], // Wash f[819], // Frost f[820], // Fan f[821], // Mow }; case 487: return new[] { f[487], // Altered f[822], // Origin }; case 492: return new[] { f[492], // Land f[823], // Sky }; case 493: return new[] { t[00], // Normal t[01], // Fighting t[02], // Flying t[03], // Poison t[04], // etc t[05], t[06], t[07], t[08], t[09], t[10], t[11], t[12], t[13], t[14], t[15], t[16], t[17], }; case 550: return new[] { f[550], // Red f[842], // Blue }; case 555: return new[] { f[555], // Standard f[843], // Zen }; case 585: case 586: return new[] { f[585], // Spring f[844], // Summer f[845], // Autumn f[846], // Winter }; case 641: case 642: case 645: return new[] { f[641], // Incarnate f[852], // Therian }; case 646: return new[] { t[000], // Normal f[853], // White f[854], // Black }; case 647: return new[] { f[647], // Ordinary f[855], // Resolute }; case 648: return new[] { f[648], // Aria f[856], // Pirouette }; case 649: return new[] { t[000], // Normal t[010], // Douse t[012], // Shock t[009], // Burn t[014], // Chill }; case 664: case 665: case 666: return new[] { f[666], // Icy Snow f[861], // Polar f[862], // Tundra f[863], // Continental f[864], // Garden f[865], // Elegant f[866], // Meadow f[867], // Modern f[868], // Marine f[869], // Archipelago f[870], // High-Plains f[871], // Sandstorm f[872], // River f[873], // Monsoon f[874], // Savannah f[875], // Sun f[876], // Ocean f[877], // Jungle f[878], // Fancy f[879], // Poké Ball }; case 669: case 671: return new[] { f[669], // Red f[884], // Yellow f[885], // Orange f[886], // Blue f[887], // White }; case 670: return new[] { f[669], // Red f[884], // Yellow f[885], // Orange f[886], // Blue f[887], // White f[888], // Eternal }; case 676: return new[] { f[676], // Natural f[893], // Heart f[894], // Star f[895], // Diamond f[896], // Deputante f[897], // Matron f[898], // Dandy f[899], // La Reine f[900], // Kabuki f[901], // Pharaoh }; case 678: return new[] { g[000], // Male g[001], // Female }; case 681: return new[] { f[681], // Shield f[903], // Blade }; case 710: case 711: return new[] { f[904], // Small f[710], // Average f[905], // Large f[906], // Super }; case 716: return new[] { t[000], // Normal f[910], // Active }; case 720: return new[] { t[000], // Normal f[912], // Unbound }; } return new[] {""}; } /// Calculate the Hidden Power Type of the entered IVs. /// Hidden Power Type /// Order: HP,ATK,DEF,SPEED,SPA,SPD /// Hidden Power Type internal static int[] setHPIVs(int type, int[] ivs) { for (int i = 0; i < 6; i++) ivs[i] = (ivs[i] & 0x1E) + hpivs[type, i]; return ivs; } internal static readonly int[,] hpivs = { { 1, 1, 0, 0, 0, 0 }, // Fighting { 0, 0, 0, 0, 0, 1 }, // Flying { 1, 1, 0, 0, 0, 1 }, // Poison { 1, 1, 1, 0, 0, 1 }, // Ground { 1, 1, 0, 1, 0, 0 }, // Rock { 1, 0, 0, 1, 0, 1 }, // Bug { 1, 0, 1, 1, 0, 1 }, // Ghost { 1, 1, 1, 1, 0, 1 }, // Steel { 1, 0, 1, 0, 1, 0 }, // Fire { 1, 0, 0, 0, 1, 1 }, // Water { 1, 0, 1, 0, 1, 1 }, // Grass { 1, 1, 1, 0, 1, 1 }, // Electric { 1, 0, 1, 1, 1, 0 }, // Psychic { 1, 0, 0, 1, 1, 1 }, // Ice { 1, 0, 1, 1, 1, 1 }, // Dragon { 1, 1, 1, 1, 1, 1 }, // Dark }; internal static string TrimFromFFFF(string input) { int index = input.IndexOf((char)0xFFFF); return index < 0 ? input : input.Substring(0, index); } // Past Gen Manipulation internal static byte[] shuffleArray45(byte[] data, uint sv) { byte[] sdata = new byte[data.Length]; Array.Copy(data, sdata, 8); // Copy unshuffled bytes // Shuffle Away! for (int block = 0; block < 4; block++) Array.Copy(data, 8 + 32 * blockPosition[block][sv], sdata, 8 + 32 * block, 32); // Fill the Battle Stats back if (data.Length > 136) Array.Copy(data, 136, sdata, 136, data.Length - 136); return sdata; } internal static byte[] decryptArray45(byte[] ekm) { byte[] pkm = (byte[])ekm.Clone(); uint pv = BitConverter.ToUInt32(pkm, 0); uint chk = BitConverter.ToUInt16(pkm, 6); uint sv = ((pv & 0x3E000) >> 0xD) % 24; uint seed = chk; // Decrypt Blocks with RNG Seed for (int i = 8; i < 136; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(pkm, i) ^ LCRNG(ref seed) >> 16)).CopyTo(pkm, i); // Deshuffle pkm = shuffleArray45(pkm, sv); // Decrypt the Party Stats seed = pv; if (pkm.Length <= 136) return pkm; for (int i = 136; i < pkm.Length; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(pkm, i) ^ LCRNG(ref seed) >> 16)).CopyTo(pkm, i); return pkm; } internal static byte[] encryptArray45(byte[] pkm) { uint pv = BitConverter.ToUInt32(pkm, 0); uint sv = ((pv & 0x3E000) >> 0xD) % 24; uint chk = BitConverter.ToUInt16(pkm, 6); byte[] ekm = (byte[])pkm.Clone(); ekm = shuffleArray45(ekm, blockPositionInvert[sv]); uint seed = chk; // Encrypt Blocks with RNG Seed for (int i = 8; i < 136; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(ekm, i) ^ LCRNG(ref seed) >> 16)).CopyTo(ekm, i); // If no party stats, return. if (ekm.Length <= 136) return ekm; // Encrypt the Party Stats seed = pv; for (int i = 136; i < ekm.Length; i += 2) BitConverter.GetBytes((ushort)(BitConverter.ToUInt16(ekm, i) ^ LCRNG(ref seed) >> 16)).CopyTo(ekm, i); // Done return ekm; } internal static int getUnownForm(uint PID) { byte[] data = BitConverter.GetBytes(PID); return (((data[3] & 3) << 6) + ((data[2] & 3) << 4) + ((data[1] & 3) << 2) + ((data[0] & 3) << 0)) % 28; } internal static ushort val2charG4(ushort val) { int index = Array.IndexOf(G4Values, val); return index > -1 ? G4Chars[index] : (ushort)0xFFFF; } internal static ushort char2valG4(ushort chr) { int index = Array.IndexOf(G4Chars, chr); return index > -1 ? G4Values[index] : (ushort)0xFFFF; } internal static string array2strG4(byte[] strdata) { string s = ""; for (int i = 0; i < strdata.Length; i += 2) { ushort val = BitConverter.ToUInt16(strdata, i); if (val == 0xFFFF) break; ushort chr = val2charG4(val); if (chr == 0xFFFF) break; s += (char)chr; } return s; } internal static byte[] str2arrayG4(string str) { byte[] strdata = new byte[str.Length * 2 + 2]; // +2 for 0xFFFF for (int i = 0; i < str.Length; i++) { ushort chr = str[i]; ushort val = char2valG4(chr); if (val == 0xFFFF || chr == 0xFFFF) { Array.Resize(ref strdata, i * 2); break; } BitConverter.GetBytes(val).CopyTo(strdata, i * 2); } BitConverter.GetBytes((ushort)0xFFFF).CopyTo(strdata, strdata.Length - 2); return strdata; } // Gen3 && 3->4 Conversion has two character tables, and translates to the same character map. internal static ushort getG4Val(byte val, bool jp) { return jp ? G34_4J[val] : G34_4E[val]; } internal static ushort getG3Char(byte val, bool jp) { return val2charG4(getG4Val(val, jp)); } internal static byte setG3Char(ushort chr, bool jp) { int index = Array.IndexOf(jp ? G34_4J : G34_4E, char2valG4(chr)); return (byte)(index > -1 ? index : 0xFF); } internal static string getG3Str(byte[] strdata, bool jp) { return strdata .TakeWhile(val => val < 247) // Take valid values .Select(val => getG3Char(val, jp)) // Convert to Unicode .TakeWhile(chr => chr != 0xFF) // Stop if Terminator .Aggregate("", (current, chr) => current + (char)chr); } internal static byte[] setG3Str(string str, bool jp) { byte[] strdata = new byte[str.Length + 1]; // +1 for 0xFF for (int i = 0; i < str.Length; i++) { ushort chr = str[i]; byte val = setG3Char(chr, jp); if (val == 0xFF || chr == 0xFF) { Array.Resize(ref strdata, i); break; } strdata[i] = val; } strdata[str.Length] = 0xFF; return strdata; } internal static int getG4Species(int g3index) { int index = Array.IndexOf(oldindex, g3index); return newindex[index > -1 ? index : 0]; } internal static int getG3Species(int g4index) { int index = Array.IndexOf(newindex, g4index); return oldindex[index > -1 ? index : 0]; } internal static int getGender(int species, uint PID) { int genderratio = Personal[species].Gender; switch (genderratio) { case 255: return 2; case 254: return 1; case 0: return 0; default: return (PID & 0xFF) <= genderratio ? 1 : 0; } } #region Gen 3 Species Table internal static int[] newindex => new[] { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30, 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58, 59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86, 87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110, 111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131, 132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152, 153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173, 174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194, 195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236, 237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257, 258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,290,291,292, 276,277,285,286,327,278,279,283,284,320,321,300,301,352,343,344,299,324,302,339,340, 370,341,342,349,350,318,319,328,329,330,296,297,309,310,322,323,363,364,365,331,332, 361,362,337,338,298,325,326,311,312,303,307,308,333,334,360,355,356,315,287,288,289, 316,317,357,293,294,295,366,367,368,359,353,354,336,335,369,304,305,306,351,313,314, 345,346,347,348,280,281,282,371,372,373,374,375,376,377,378,379,382,383,384,380,381, 385,386,358, }; internal static int[] oldindex => new[] { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30, 31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58, 59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86, 87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110, 111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131, 132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152, 153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173, 174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194, 195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236, 237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,277,278,279,280,281,282, 283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303, 304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324, 325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345, 346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366, 367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387, 388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408, 409,410,411, }; #endregion #region Gen 3 Ability Table internal static readonly byte[][] Gen3Abilities = { new byte[] {0x00, 0x00}, // 000 new byte[] {0x41, 0x41}, // 001 new byte[] {0x41, 0x41}, // 002 new byte[] {0x41, 0x41}, // 003 new byte[] {0x42, 0x42}, // 004 new byte[] {0x42, 0x42}, // 005 new byte[] {0x42, 0x42}, // 006 new byte[] {0x43, 0x43}, // 007 new byte[] {0x43, 0x43}, // 008 new byte[] {0x43, 0x43}, // 009 new byte[] {0x13, 0x13}, // 010 new byte[] {0x3d, 0x3d}, // 011 new byte[] {0x0e, 0x0e}, // 012 new byte[] {0x13, 0x13}, // 013 new byte[] {0x3d, 0x3d}, // 014 new byte[] {0x44, 0x44}, // 015 new byte[] {0x33, 0x33}, // 016 new byte[] {0x33, 0x33}, // 017 new byte[] {0x33, 0x33}, // 018 new byte[] {0x32, 0x3e}, // 019 new byte[] {0x32, 0x3e}, // 020 new byte[] {0x33, 0x33}, // 021 new byte[] {0x33, 0x33}, // 022 new byte[] {0x3d, 0x16}, // 023 new byte[] {0x3d, 0x16}, // 024 new byte[] {0x09, 0x09}, // 025 new byte[] {0x09, 0x09}, // 026 new byte[] {0x08, 0x08}, // 027 new byte[] {0x08, 0x08}, // 028 new byte[] {0x26, 0x26}, // 029 new byte[] {0x26, 0x26}, // 030 new byte[] {0x26, 0x26}, // 031 new byte[] {0x26, 0x26}, // 032 new byte[] {0x26, 0x26}, // 033 new byte[] {0x26, 0x26}, // 034 new byte[] {0x38, 0x38}, // 035 new byte[] {0x38, 0x38}, // 036 new byte[] {0x12, 0x12}, // 037 new byte[] {0x12, 0x12}, // 038 new byte[] {0x38, 0x38}, // 039 new byte[] {0x38, 0x38}, // 040 new byte[] {0x27, 0x27}, // 041 new byte[] {0x27, 0x27}, // 042 new byte[] {0x22, 0x22}, // 043 new byte[] {0x22, 0x22}, // 044 new byte[] {0x22, 0x22}, // 045 new byte[] {0x1b, 0x1b}, // 046 new byte[] {0x1b, 0x1b}, // 047 new byte[] {0x0e, 0x0e}, // 048 new byte[] {0x13, 0x13}, // 049 new byte[] {0x08, 0x47}, // 050 new byte[] {0x08, 0x47}, // 051 new byte[] {0x35, 0x35}, // 052 new byte[] {0x07, 0x07}, // 053 new byte[] {0x06, 0x0d}, // 054 new byte[] {0x06, 0x0d}, // 055 new byte[] {0x48, 0x48}, // 056 new byte[] {0x48, 0x48}, // 057 new byte[] {0x16, 0x12}, // 058 new byte[] {0x16, 0x12}, // 059 new byte[] {0x06, 0x0b}, // 060 new byte[] {0x06, 0x0b}, // 061 new byte[] {0x06, 0x0b}, // 062 new byte[] {0x1c, 0x27}, // 063 new byte[] {0x1c, 0x27}, // 064 new byte[] {0x1c, 0x27}, // 065 new byte[] {0x3e, 0x3e}, // 066 new byte[] {0x3e, 0x3e}, // 067 new byte[] {0x3e, 0x3e}, // 068 new byte[] {0x22, 0x22}, // 069 new byte[] {0x22, 0x22}, // 070 new byte[] {0x22, 0x22}, // 071 new byte[] {0x1d, 0x40}, // 072 new byte[] {0x1d, 0x40}, // 073 new byte[] {0x45, 0x05}, // 074 new byte[] {0x45, 0x05}, // 075 new byte[] {0x45, 0x05}, // 076 new byte[] {0x32, 0x12}, // 077 new byte[] {0x32, 0x12}, // 078 new byte[] {0x0c, 0x14}, // 079 new byte[] {0x0c, 0x14}, // 080 new byte[] {0x2a, 0x05}, // 081 new byte[] {0x2a, 0x05}, // 082 new byte[] {0x33, 0x27}, // 083 new byte[] {0x32, 0x30}, // 084 new byte[] {0x32, 0x30}, // 085 new byte[] {0x2f, 0x2f}, // 086 new byte[] {0x2f, 0x2f}, // 087 new byte[] {0x01, 0x3c}, // 088 new byte[] {0x01, 0x3c}, // 089 new byte[] {0x4b, 0x4b}, // 090 new byte[] {0x4b, 0x4b}, // 091 new byte[] {0x1a, 0x1a}, // 092 new byte[] {0x1a, 0x1a}, // 093 new byte[] {0x1a, 0x1a}, // 094 new byte[] {0x45, 0x05}, // 095 new byte[] {0x0f, 0x0f}, // 096 new byte[] {0x0f, 0x0f}, // 097 new byte[] {0x34, 0x4b}, // 098 new byte[] {0x34, 0x4b}, // 099 new byte[] {0x2b, 0x09}, // 100 new byte[] {0x2b, 0x09}, // 101 new byte[] {0x22, 0x22}, // 102 new byte[] {0x22, 0x22}, // 103 new byte[] {0x45, 0x1f}, // 104 new byte[] {0x45, 0x1f}, // 105 new byte[] {0x07, 0x07}, // 106 new byte[] {0x33, 0x33}, // 107 new byte[] {0x0c, 0x14}, // 108 new byte[] {0x1a, 0x1a}, // 109 new byte[] {0x1a, 0x1a}, // 110 new byte[] {0x45, 0x1f}, // 111 new byte[] {0x45, 0x1f}, // 112 new byte[] {0x1e, 0x20}, // 113 new byte[] {0x22, 0x22}, // 114 new byte[] {0x30, 0x30}, // 115 new byte[] {0x21, 0x21}, // 116 new byte[] {0x26, 0x26}, // 117 new byte[] {0x21, 0x29}, // 118 new byte[] {0x21, 0x29}, // 119 new byte[] {0x23, 0x1e}, // 120 new byte[] {0x23, 0x1e}, // 121 new byte[] {0x2b, 0x2b}, // 122 new byte[] {0x44, 0x44}, // 123 new byte[] {0x0c, 0x0c}, // 124 new byte[] {0x09, 0x09}, // 125 new byte[] {0x31, 0x31}, // 126 new byte[] {0x34, 0x34}, // 127 new byte[] {0x16, 0x16}, // 128 new byte[] {0x21, 0x21}, // 129 new byte[] {0x16, 0x16}, // 130 new byte[] {0x0b, 0x4b}, // 131 new byte[] {0x07, 0x07}, // 132 new byte[] {0x32, 0x32}, // 133 new byte[] {0x0b, 0x0b}, // 134 new byte[] {0x0a, 0x0a}, // 135 new byte[] {0x12, 0x12}, // 136 new byte[] {0x24, 0x24}, // 137 new byte[] {0x21, 0x4b}, // 138 new byte[] {0x21, 0x4b}, // 139 new byte[] {0x21, 0x04}, // 140 new byte[] {0x21, 0x04}, // 141 new byte[] {0x45, 0x2e}, // 142 new byte[] {0x11, 0x2f}, // 143 new byte[] {0x2e, 0x2e}, // 144 new byte[] {0x2e, 0x2e}, // 145 new byte[] {0x2e, 0x2e}, // 146 new byte[] {0x3d, 0x3d}, // 147 new byte[] {0x3d, 0x3d}, // 148 new byte[] {0x27, 0x27}, // 149 new byte[] {0x2e, 0x2e}, // 150 new byte[] {0x1c, 0x1c}, // 151 new byte[] {0x41, 0x41}, // 152 new byte[] {0x41, 0x41}, // 153 new byte[] {0x41, 0x41}, // 154 new byte[] {0x42, 0x42}, // 155 new byte[] {0x42, 0x42}, // 156 new byte[] {0x42, 0x42}, // 157 new byte[] {0x43, 0x43}, // 158 new byte[] {0x43, 0x43}, // 159 new byte[] {0x43, 0x43}, // 160 new byte[] {0x32, 0x33}, // 161 new byte[] {0x32, 0x33}, // 162 new byte[] {0x0f, 0x33}, // 163 new byte[] {0x0f, 0x33}, // 164 new byte[] {0x44, 0x30}, // 165 new byte[] {0x44, 0x30}, // 166 new byte[] {0x0f, 0x44}, // 167 new byte[] {0x0f, 0x44}, // 168 new byte[] {0x27, 0x27}, // 169 new byte[] {0x0a, 0x23}, // 170 new byte[] {0x0a, 0x23}, // 171 new byte[] {0x09, 0x09}, // 172 new byte[] {0x38, 0x38}, // 173 new byte[] {0x38, 0x38}, // 174 new byte[] {0x37, 0x20}, // 175 new byte[] {0x37, 0x20}, // 176 new byte[] {0x1c, 0x30}, // 177 new byte[] {0x1c, 0x30}, // 178 new byte[] {0x09, 0x09}, // 179 new byte[] {0x09, 0x09}, // 180 new byte[] {0x09, 0x09}, // 181 new byte[] {0x22, 0x22}, // 182 new byte[] {0x2f, 0x25}, // 183 new byte[] {0x2f, 0x25}, // 184 new byte[] {0x45, 0x05}, // 185 new byte[] {0x06, 0x0b}, // 186 new byte[] {0x22, 0x22}, // 187 new byte[] {0x22, 0x22}, // 188 new byte[] {0x22, 0x22}, // 189 new byte[] {0x32, 0x35}, // 190 new byte[] {0x22, 0x22}, // 191 new byte[] {0x22, 0x22}, // 192 new byte[] {0x03, 0x0e}, // 193 new byte[] {0x06, 0x0b}, // 194 new byte[] {0x06, 0x0b}, // 195 new byte[] {0x1c, 0x1c}, // 196 new byte[] {0x1c, 0x1c}, // 197 new byte[] {0x0f, 0x0f}, // 198 new byte[] {0x0c, 0x14}, // 199 new byte[] {0x1a, 0x1a}, // 200 new byte[] {0x1a, 0x1a}, // 201 new byte[] {0x17, 0x17}, // 202 new byte[] {0x27, 0x30}, // 203 new byte[] {0x05, 0x05}, // 204 new byte[] {0x05, 0x05}, // 205 new byte[] {0x20, 0x32}, // 206 new byte[] {0x08, 0x34}, // 207 new byte[] {0x45, 0x05}, // 208 new byte[] {0x16, 0x32}, // 209 new byte[] {0x16, 0x16}, // 210 new byte[] {0x21, 0x26}, // 211 new byte[] {0x44, 0x44}, // 212 new byte[] {0x05, 0x05}, // 213 new byte[] {0x44, 0x3e}, // 214 new byte[] {0x27, 0x33}, // 215 new byte[] {0x35, 0x35}, // 216 new byte[] {0x3e, 0x3e}, // 217 new byte[] {0x28, 0x31}, // 218 new byte[] {0x28, 0x31}, // 219 new byte[] {0x0c, 0x0c}, // 220 new byte[] {0x0c, 0x0c}, // 221 new byte[] {0x37, 0x1e}, // 222 new byte[] {0x37, 0x37}, // 223 new byte[] {0x15, 0x15}, // 224 new byte[] {0x37, 0x48}, // 225 new byte[] {0x21, 0x0b}, // 226 new byte[] {0x33, 0x05}, // 227 new byte[] {0x30, 0x12}, // 228 new byte[] {0x30, 0x12}, // 229 new byte[] {0x21, 0x21}, // 230 new byte[] {0x35, 0x35}, // 231 new byte[] {0x05, 0x05}, // 232 new byte[] {0x24, 0x24}, // 233 new byte[] {0x16, 0x16}, // 234 new byte[] {0x14, 0x14}, // 235 new byte[] {0x3e, 0x3e}, // 236 new byte[] {0x16, 0x16}, // 237 new byte[] {0x0c, 0x0c}, // 238 new byte[] {0x09, 0x09}, // 239 new byte[] {0x31, 0x31}, // 240 new byte[] {0x2f, 0x2f}, // 241 new byte[] {0x1e, 0x20}, // 242 new byte[] {0x2e, 0x2e}, // 243 new byte[] {0x2e, 0x2e}, // 244 new byte[] {0x2e, 0x2e}, // 245 new byte[] {0x3e, 0x3e}, // 246 new byte[] {0x3d, 0x3d}, // 247 new byte[] {0x2d, 0x2d}, // 248 new byte[] {0x2e, 0x2e}, // 249 new byte[] {0x2e, 0x2e}, // 250 new byte[] {0x1e, 0x1e}, // 251 new byte[] {0x41, 0x41}, // 252 new byte[] {0x41, 0x41}, // 253 new byte[] {0x41, 0x41}, // 254 new byte[] {0x42, 0x42}, // 255 new byte[] {0x42, 0x42}, // 256 new byte[] {0x42, 0x42}, // 257 new byte[] {0x43, 0x43}, // 258 new byte[] {0x43, 0x43}, // 259 new byte[] {0x43, 0x43}, // 260 new byte[] {0x32, 0x32}, // 261 new byte[] {0x16, 0x16}, // 262 new byte[] {0x35, 0x35}, // 263 new byte[] {0x35, 0x35}, // 264 new byte[] {0x13, 0x13}, // 265 new byte[] {0x3d, 0x3d}, // 266 new byte[] {0x44, 0x44}, // 267 new byte[] {0x3d, 0x3d}, // 268 new byte[] {0x13, 0x13}, // 269 new byte[] {0x21, 0x2c}, // 270 new byte[] {0x21, 0x2c}, // 271 new byte[] {0x21, 0x2c}, // 272 new byte[] {0x22, 0x30}, // 273 new byte[] {0x22, 0x30}, // 274 new byte[] {0x22, 0x30}, // 275 new byte[] {0x3e, 0x3e}, // 276 new byte[] {0x3e, 0x3e}, // 277 new byte[] {0x33, 0x33}, // 278 new byte[] {0x33, 0x33}, // 279 new byte[] {0x1c, 0x24}, // 280 new byte[] {0x1c, 0x24}, // 281 new byte[] {0x1c, 0x24}, // 282 new byte[] {0x21, 0x21}, // 283 new byte[] {0x16, 0x16}, // 284 new byte[] {0x1b, 0x1b}, // 285 new byte[] {0x1b, 0x1b}, // 286 new byte[] {0x36, 0x36}, // 287 new byte[] {0x48, 0x48}, // 288 new byte[] {0x36, 0x36}, // 289 new byte[] {0x0e, 0x0e}, // 290 new byte[] {0x03, 0x03}, // 291 new byte[] {0x19, 0x19}, // 292 new byte[] {0x2b, 0x2b}, // 293 new byte[] {0x2b, 0x2b}, // 294 new byte[] {0x2b, 0x2b}, // 295 new byte[] {0x2f, 0x3e}, // 296 new byte[] {0x2f, 0x3e}, // 297 new byte[] {0x2f, 0x3e}, // 298 new byte[] {0x05, 0x2a}, // 299 new byte[] {0x38, 0x38}, // 300 new byte[] {0x38, 0x38}, // 301 new byte[] {0x33, 0x33}, // 302 new byte[] {0x34, 0x16}, // 303 new byte[] {0x45, 0x05}, // 304 new byte[] {0x45, 0x05}, // 305 new byte[] {0x45, 0x05}, // 306 new byte[] {0x4a, 0x4a}, // 307 new byte[] {0x4a, 0x4a}, // 308 new byte[] {0x09, 0x1f}, // 309 new byte[] {0x09, 0x1f}, // 310 new byte[] {0x39, 0x39}, // 311 new byte[] {0x3a, 0x3a}, // 312 new byte[] {0x23, 0x44}, // 313 new byte[] {0x0c, 0x0c}, // 314 new byte[] {0x1e, 0x26}, // 315 new byte[] {0x40, 0x3c}, // 316 new byte[] {0x40, 0x3c}, // 317 new byte[] {0x18, 0x18}, // 318 new byte[] {0x18, 0x18}, // 319 new byte[] {0x29, 0x0c}, // 320 new byte[] {0x29, 0x0c}, // 321 new byte[] {0x0c, 0x0c}, // 322 new byte[] {0x28, 0x28}, // 323 new byte[] {0x49, 0x49}, // 324 new byte[] {0x2f, 0x14}, // 325 new byte[] {0x2f, 0x14}, // 326 new byte[] {0x14, 0x14}, // 327 new byte[] {0x34, 0x47}, // 328 new byte[] {0x1a, 0x1a}, // 329 new byte[] {0x1a, 0x1a}, // 330 new byte[] {0x08, 0x08}, // 331 new byte[] {0x08, 0x08}, // 332 new byte[] {0x1e, 0x1e}, // 333 new byte[] {0x1e, 0x1e}, // 334 new byte[] {0x11, 0x11}, // 335 new byte[] {0x3d, 0x3d}, // 336 new byte[] {0x1a, 0x1a}, // 337 new byte[] {0x1a, 0x1a}, // 338 new byte[] {0x0c, 0x0c}, // 339 new byte[] {0x0c, 0x0c}, // 340 new byte[] {0x34, 0x4b}, // 341 new byte[] {0x34, 0x4b}, // 342 new byte[] {0x1a, 0x1a}, // 343 new byte[] {0x1a, 0x1a}, // 344 new byte[] {0x15, 0x15}, // 345 new byte[] {0x15, 0x15}, // 346 new byte[] {0x04, 0x04}, // 347 new byte[] {0x04, 0x04}, // 348 new byte[] {0x21, 0x21}, // 349 new byte[] {0x3f, 0x3f}, // 350 new byte[] {0x3b, 0x3b}, // 351 new byte[] {0x10, 0x10}, // 352 new byte[] {0x0f, 0x0f}, // 353 new byte[] {0x0f, 0x0f}, // 354 new byte[] {0x1a, 0x1a}, // 355 new byte[] {0x2e, 0x2e}, // 356 new byte[] {0x22, 0x22}, // 357 new byte[] {0x1a, 0x1a}, // 358 new byte[] {0x2e, 0x2e}, // 359 new byte[] {0x17, 0x17}, // 360 new byte[] {0x27, 0x27}, // 361 new byte[] {0x27, 0x27}, // 362 new byte[] {0x2f, 0x2f}, // 363 new byte[] {0x2f, 0x2f}, // 364 new byte[] {0x2f, 0x2f}, // 365 new byte[] {0x4b, 0x4b}, // 366 new byte[] {0x21, 0x21}, // 367 new byte[] {0x21, 0x21}, // 368 new byte[] {0x21, 0x45}, // 369 new byte[] {0x21, 0x21}, // 370 new byte[] {0x45, 0x45}, // 371 new byte[] {0x45, 0x45}, // 372 new byte[] {0x16, 0x16}, // 373 new byte[] {0x1d, 0x1d}, // 374 new byte[] {0x1d, 0x1d}, // 375 new byte[] {0x1d, 0x1d}, // 376 new byte[] {0x1d, 0x1d}, // 377 new byte[] {0x1d, 0x1d}, // 378 new byte[] {0x1d, 0x1d}, // 379 new byte[] {0x1a, 0x1a}, // 380 new byte[] {0x1a, 0x1a}, // 381 new byte[] {0x02, 0x02}, // 382 new byte[] {0x46, 0x46}, // 383 new byte[] {0x4d, 0x4d}, // 384 new byte[] {0x20, 0x20}, // 385 new byte[] {0x2e, 0x2e}, // 386 }; #endregion #region Gen 3/4 Character Tables (Val->Unicode) internal static readonly ushort[] G4Values = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 488, 489, 490, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521, 2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 2554, 2555, 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569, 2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583, 2584, 2585, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, 2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761, 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777, 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, 2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873, 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131, 3132, 3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177, 3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, 3226, 3227, 3228, 3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241, 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273, 3274, 3275, 3276, 3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288, 3289, 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302, 3303, 3304, 3305, 3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324, 3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336, 3337, 3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348, 3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385, 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3425, 3426, 3427, 3428, 3429, 65535 }; internal static readonly ushort[] G4Chars = { 12288, 12353, 12354, 12355, 12356, 12357, 12358, 12359, 12360, 12361, 12362, 12363, 12364, 12365, 12366, 12367, 12368, 12369, 12370, 12371, 12372, 12373, 12374, 12375, 12376, 12377, 12378, 12379, 12380, 12381, 12382, 12383, 12384, 12385, 12386, 12387, 12388, 12389, 12390, 12391, 12392, 12393, 12394, 12395, 12396, 12397, 12398, 12399, 12400, 12401, 12402, 12403, 12404, 12405, 12406, 12407, 12408, 12409, 12410, 12411, 12412, 12413, 12414, 12415, 12416, 12417, 12418, 12419, 12420, 12421, 12422, 12423, 12424, 12425, 12426, 12427, 12428, 12429, 12431, 12434, 12435, 12449, 12450, 12451, 12452, 12453, 12454, 12455, 12456, 12457, 12458, 12459, 12460, 12461, 12462, 12463, 12464, 12465, 12466, 12467, 12468, 12469, 12470, 12471, 12472, 12473, 12474, 12475, 12476, 12477, 12478, 12479, 12480, 12481, 12482, 12483, 12484, 12485, 12486, 12487, 12488, 12489, 12490, 12491, 12492, 12493, 12494, 12495, 12496, 12497, 12498, 12499, 12500, 12501, 12502, 12503, 12504, 12505, 12506, 12507, 12508, 12509, 12510, 12511, 12512, 12513, 12514, 12515, 12516, 12517, 12518, 12519, 12520, 12521, 12522, 12523, 12524, 12525, 12527, 12530, 12531, 65296, 65297, 65298, 65299, 65300, 65301, 65302, 65303, 65304, 65305, 65313, 65314, 65315, 65316, 65317, 65318, 65319, 65320, 65321, 65322, 65323, 65324, 65325, 65326, 65327, 65328, 65329, 65330, 65331, 65332, 65333, 65334, 65335, 65336, 65337, 65338, 65345, 65346, 65347, 65348, 65349, 65350, 65351, 65352, 65353, 65354, 65355, 65356, 65357, 65358, 65359, 65360, 65361, 65362, 65363, 65364, 65365, 65366, 65367, 65368, 65369, 65370, 65281, 65311, 12289, 12290, 8943, 12539, 65295, 12300, 12301, 12302, 12303, 65288, 65289, 9325, 9326, 65291, 65293, 9319, 9320, 65309, 65370, 65306, 65307, 65294, 65292, 9327, 9328, 9329, 9330, 9331, 9332, 9333, 9334, 9335, 9336, 65312, 9337, 65285, 9338, 9339, 9341, 10052, 9739, 9812, 9813, 9738, 8663, 8664, 9790, 165, 9800, 9801, 9802, 9803, 9804, 9805, 9806, 9807, 8592, 8593, 8595, 8594, 8227, 65286, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 338, 339, 350, 351, 170, 186, 185, 178, 179, 36, 161, 191, 33, 63, 44, 46, 9324, 65381, 47, 8216, 8217, 8220, 8221, 8222, 12298, 12299, 40, 41, 9794, 9792, 43, 45, 42, 35, 61, 38, 126, 58, 59, 9327, 9328, 9329, 9330, 9331, 9332, 9333, 9334, 9335, 9336, 64, 9337, 37, 9338, 9339, 9340, 9341, 9342, 9343, 9344, 9345, 9346, 9347, 9348, 32, 9349, 9350, 9351, 176, 95, 65343, 44032, 44033, 44036, 44039, 44040, 44041, 44042, 44048, 44049, 44050, 44051, 44052, 44053, 44054, 44055, 44057, 44058, 44059, 44060, 44061, 44064, 44068, 44076, 44077, 44079, 44080, 44081, 44088, 44089, 44092, 44096, 44107, 44109, 44116, 44120, 44124, 44144, 44145, 44148, 44151, 44152, 44154, 44160, 44161, 44163, 44164, 44165, 44166, 44169, 44170, 44171, 44172, 44176, 44180, 44188, 44189, 44191, 44192, 44193, 44200, 44201, 44202, 44204, 44207, 44208, 44216, 44217, 44219, 44220, 44221, 44225, 44228, 44232, 44236, 44245, 44247, 44256, 44257, 44260, 44263, 44264, 44266, 44268, 44271, 44272, 44273, 44275, 44277, 44278, 44284, 44285, 44288, 44292, 44294, 44300, 44301, 44303, 44305, 44312, 44316, 44320, 44329, 44332, 44333, 44340, 44341, 44344, 44348, 44356, 44357, 44359, 44361, 44368, 44372, 44376, 44385, 44387, 44396, 44397, 44400, 44403, 44404, 44405, 44406, 44411, 44412, 44413, 44415, 44417, 44418, 44424, 44425, 44428, 44432, 44444, 44445, 44452, 44471, 44480, 44481, 44484, 44488, 44496, 44497, 44499, 44508, 44512, 44516, 44536, 44537, 44540, 44543, 44544, 44545, 44552, 44553, 44555, 44557, 44564, 44592, 44593, 44596, 44599, 44600, 44602, 44608, 44609, 44611, 44613, 44614, 44618, 44620, 44621, 44622, 44624, 44628, 44630, 44636, 44637, 44639, 44640, 44641, 44645, 44648, 44649, 44652, 44656, 44664, 44665, 44667, 44668, 44669, 44676, 44677, 44684, 44732, 44733, 44734, 44736, 44740, 44748, 44749, 44751, 44752, 44753, 44760, 44761, 44764, 44776, 44779, 44781, 44788, 44792, 44796, 44807, 44808, 44813, 44816, 44844, 44845, 44848, 44850, 44852, 44860, 44861, 44863, 44865, 44866, 44867, 44872, 44873, 44880, 44892, 44893, 44900, 44901, 44921, 44928, 44932, 44936, 44944, 44945, 44949, 44956, 44984, 44985, 44988, 44992, 44999, 45000, 45001, 45003, 45005, 45006, 45012, 45020, 45032, 45033, 45040, 45041, 45044, 45048, 45056, 45057, 45060, 45068, 45072, 45076, 45084, 45085, 45096, 45124, 45125, 45128, 45130, 45132, 45134, 45139, 45140, 45141, 45143, 45145, 45149, 45180, 45181, 45184, 45188, 45196, 45197, 45199, 45201, 45208, 45209, 45210, 45212, 45215, 45216, 45217, 45218, 45224, 45225, 45227, 45228, 45229, 45230, 45231, 45233, 45235, 45236, 45237, 45240, 45244, 45252, 45253, 45255, 45256, 45257, 45264, 45265, 45268, 45272, 45280, 45285, 45320, 45321, 45323, 45324, 45328, 45330, 45331, 45336, 45337, 45339, 45340, 45341, 45347, 45348, 45349, 45352, 45356, 45364, 45365, 45367, 45368, 45369, 45376, 45377, 45380, 45384, 45392, 45393, 45396, 45397, 45400, 45404, 45408, 45432, 45433, 45436, 45440, 45442, 45448, 45449, 45451, 45453, 45458, 45459, 45460, 45464, 45468, 45480, 45516, 45520, 45524, 45532, 45533, 45535, 45544, 45545, 45548, 45552, 45561, 45563, 45565, 45572, 45573, 45576, 45579, 45580, 45588, 45589, 45591, 45593, 45600, 45620, 45628, 45656, 45660, 45664, 45672, 45673, 45684, 45685, 45692, 45700, 45701, 45705, 45712, 45713, 45716, 45720, 45721, 45722, 45728, 45729, 45731, 45733, 45734, 45738, 45740, 45744, 45748, 45768, 45769, 45772, 45776, 45778, 45784, 45785, 45787, 45789, 45794, 45796, 45797, 45798, 45800, 45803, 45804, 45805, 45806, 45807, 45811, 45812, 45813, 45815, 45816, 45817, 45818, 45819, 45823, 45824, 45825, 45828, 45832, 45840, 45841, 45843, 45844, 45845, 45852, 45908, 45909, 45910, 45912, 45915, 45916, 45918, 45919, 45924, 45925, 45927, 45929, 45931, 45934, 45936, 45937, 45940, 45944, 45952, 45953, 45955, 45956, 45957, 45964, 45968, 45972, 45984, 45985, 45992, 45996, 46020, 46021, 46024, 46027, 46028, 46030, 46032, 46036, 46037, 46039, 46041, 46043, 46045, 46048, 46052, 46056, 46076, 46096, 46104, 46108, 46112, 46120, 46121, 46123, 46132, 46160, 46161, 46164, 46168, 46176, 46177, 46179, 46181, 46188, 46208, 46216, 46237, 46244, 46248, 46252, 46261, 46263, 46265, 46272, 46276, 46280, 46288, 46293, 46300, 46301, 46304, 46307, 46308, 46310, 46316, 46317, 46319, 46321, 46328, 46356, 46357, 46360, 46363, 46364, 46372, 46373, 46375, 46376, 46377, 46378, 46384, 46385, 46388, 46392, 46400, 46401, 46403, 46404, 46405, 46411, 46412, 46413, 46416, 46420, 46428, 46429, 46431, 46432, 46433, 46496, 46497, 46500, 46504, 46506, 46507, 46512, 46513, 46515, 46516, 46517, 46523, 46524, 46525, 46528, 46532, 46540, 46541, 46543, 46544, 46545, 46552, 46572, 46608, 46609, 46612, 46616, 46629, 46636, 46644, 46664, 46692, 46696, 46748, 46749, 46752, 46756, 46763, 46764, 46769, 46804, 46832, 46836, 46840, 46848, 46849, 46853, 46888, 46889, 46892, 46895, 46896, 46904, 46905, 46907, 46916, 46920, 46924, 46932, 46933, 46944, 46948, 46952, 46960, 46961, 46963, 46965, 46972, 46973, 46976, 46980, 46988, 46989, 46991, 46992, 46993, 46994, 46998, 46999, 47000, 47001, 47004, 47008, 47016, 47017, 47019, 47020, 47021, 47028, 47029, 47032, 47047, 47049, 47084, 47085, 47088, 47092, 47100, 47101, 47103, 47104, 47105, 47111, 47112, 47113, 47116, 47120, 47128, 47129, 47131, 47133, 47140, 47141, 47144, 47148, 47156, 47157, 47159, 47160, 47161, 47168, 47172, 47185, 47187, 47196, 47197, 47200, 47204, 47212, 47213, 47215, 47217, 47224, 47228, 47245, 47272, 47280, 47284, 47288, 47296, 47297, 47299, 47301, 47308, 47312, 47316, 47325, 47327, 47329, 47336, 47337, 47340, 47344, 47352, 47353, 47355, 47357, 47364, 47384, 47392, 47420, 47421, 47424, 47428, 47436, 47439, 47441, 47448, 47449, 47452, 47456, 47464, 47465, 47467, 47469, 47476, 47477, 47480, 47484, 47492, 47493, 47495, 47497, 47498, 47501, 47502, 47532, 47533, 47536, 47540, 47548, 47549, 47551, 47553, 47560, 47561, 47564, 47566, 47567, 47568, 47569, 47570, 47576, 47577, 47579, 47581, 47582, 47585, 47587, 47588, 47589, 47592, 47596, 47604, 47605, 47607, 47608, 47609, 47610, 47616, 47617, 47624, 47637, 47672, 47673, 47676, 47680, 47682, 47688, 47689, 47691, 47693, 47694, 47699, 47700, 47701, 47704, 47708, 47716, 47717, 47719, 47720, 47721, 47728, 47729, 47732, 47736, 47747, 47748, 47749, 47751, 47756, 47784, 47785, 47787, 47788, 47792, 47794, 47800, 47801, 47803, 47805, 47812, 47816, 47832, 47833, 47868, 47872, 47876, 47885, 47887, 47889, 47896, 47900, 47904, 47913, 47915, 47924, 47925, 47926, 47928, 47931, 47932, 47933, 47934, 47940, 47941, 47943, 47945, 47949, 47951, 47952, 47956, 47960, 47969, 47971, 47980, 48008, 48012, 48016, 48036, 48040, 48044, 48052, 48055, 48064, 48068, 48072, 48080, 48083, 48120, 48121, 48124, 48127, 48128, 48130, 48136, 48137, 48139, 48140, 48141, 48143, 48145, 48148, 48149, 48150, 48151, 48152, 48155, 48156, 48157, 48158, 48159, 48164, 48165, 48167, 48169, 48173, 48176, 48177, 48180, 48184, 48192, 48193, 48195, 48196, 48197, 48201, 48204, 48205, 48208, 48221, 48260, 48261, 48264, 48267, 48268, 48270, 48276, 48277, 48279, 48281, 48282, 48288, 48289, 48292, 48295, 48296, 48304, 48305, 48307, 48308, 48309, 48316, 48317, 48320, 48324, 48333, 48335, 48336, 48337, 48341, 48344, 48348, 48372, 48373, 48374, 48376, 48380, 48388, 48389, 48391, 48393, 48400, 48404, 48420, 48428, 48448, 48456, 48457, 48460, 48464, 48472, 48473, 48484, 48488, 48512, 48513, 48516, 48519, 48520, 48521, 48522, 48528, 48529, 48531, 48533, 48537, 48538, 48540, 48548, 48560, 48568, 48596, 48597, 48600, 48604, 48617, 48624, 48628, 48632, 48640, 48643, 48645, 48652, 48653, 48656, 48660, 48668, 48669, 48671, 48708, 48709, 48712, 48716, 48718, 48724, 48725, 48727, 48729, 48730, 48731, 48736, 48737, 48740, 48744, 48746, 48752, 48753, 48755, 48756, 48757, 48763, 48764, 48765, 48768, 48772, 48780, 48781, 48783, 48784, 48785, 48792, 48793, 48808, 48848, 48849, 48852, 48855, 48856, 48864, 48867, 48868, 48869, 48876, 48897, 48904, 48905, 48920, 48921, 48923, 48924, 48925, 48960, 48961, 48964, 48968, 48976, 48977, 48981, 49044, 49072, 49093, 49100, 49101, 49104, 49108, 49116, 49119, 49121, 49212, 49233, 49240, 49244, 49248, 49256, 49257, 49296, 49297, 49300, 49304, 49312, 49313, 49315, 49317, 49324, 49325, 49327, 49328, 49331, 49332, 49333, 49334, 49340, 49341, 49343, 49344, 49345, 49349, 49352, 49353, 49356, 49360, 49368, 49369, 49371, 49372, 49373, 49380, 49381, 49384, 49388, 49396, 49397, 49399, 49401, 49408, 49412, 49416, 49424, 49429, 49436, 49437, 49438, 49439, 49440, 49443, 49444, 49446, 49447, 49452, 49453, 49455, 49456, 49457, 49462, 49464, 49465, 49468, 49472, 49480, 49481, 49483, 49484, 49485, 49492, 49493, 49496, 49500, 49508, 49509, 49511, 49512, 49513, 49520, 49524, 49528, 49541, 49548, 49549, 49550, 49552, 49556, 49558, 49564, 49565, 49567, 49569, 49573, 49576, 49577, 49580, 49584, 49597, 49604, 49608, 49612, 49620, 49623, 49624, 49632, 49636, 49640, 49648, 49649, 49651, 49660, 49661, 49664, 49668, 49676, 49677, 49679, 49681, 49688, 49689, 49692, 49695, 49696, 49704, 49705, 49707, 49709, 49711, 49713, 49714, 49716, 49736, 49744, 49745, 49748, 49752, 49760, 49765, 49772, 49773, 49776, 49780, 49788, 49789, 49791, 49793, 49800, 49801, 49808, 49816, 49819, 49821, 49828, 49829, 49832, 49836, 49837, 49844, 49845, 49847, 49849, 49884, 49885, 49888, 49891, 49892, 49899, 49900, 49901, 49903, 49905, 49910, 49912, 49913, 49915, 49916, 49920, 49928, 49929, 49932, 49933, 49939, 49940, 49941, 49944, 49948, 49956, 49957, 49960, 49961, 49989, 50024, 50025, 50028, 50032, 50034, 50040, 50041, 50044, 50045, 50052, 50056, 50060, 50112, 50136, 50137, 50140, 50143, 50144, 50146, 50152, 50153, 50157, 50164, 50165, 50168, 50184, 50192, 50212, 50220, 50224, 50228, 50236, 50237, 50248, 50276, 50277, 50280, 50284, 50292, 50293, 50297, 50304, 50324, 50332, 50360, 50364, 50409, 50416, 50417, 50420, 50424, 50426, 50431, 50432, 50433, 50444, 50448, 50452, 50460, 50472, 50473, 50476, 50480, 50488, 50489, 50491, 50493, 50500, 50501, 50504, 50505, 50506, 50508, 50509, 50510, 50515, 50516, 50517, 50519, 50520, 50521, 50525, 50526, 50528, 50529, 50532, 50536, 50544, 50545, 50547, 50548, 50549, 50556, 50557, 50560, 50564, 50567, 50572, 50573, 50575, 50577, 50581, 50583, 50584, 50588, 50592, 50601, 50612, 50613, 50616, 50617, 50619, 50620, 50621, 50622, 50628, 50629, 50630, 50631, 50632, 50633, 50634, 50636, 50638, 50640, 50641, 50644, 50648, 50656, 50657, 50659, 50661, 50668, 50669, 50670, 50672, 50676, 50678, 50679, 50684, 50685, 50686, 50687, 50688, 50689, 50693, 50694, 50695, 50696, 50700, 50704, 50712, 50713, 50715, 50716, 50724, 50725, 50728, 50732, 50733, 50734, 50736, 50739, 50740, 50741, 50743, 50745, 50747, 50752, 50753, 50756, 50760, 50768, 50769, 50771, 50772, 50773, 50780, 50781, 50784, 50796, 50799, 50801, 50808, 50809, 50812, 50816, 50824, 50825, 50827, 50829, 50836, 50837, 50840, 50844, 50852, 50853, 50855, 50857, 50864, 50865, 50868, 50872, 50873, 50874, 50880, 50881, 50883, 50885, 50892, 50893, 50896, 50900, 50908, 50909, 50912, 50913, 50920, 50921, 50924, 50928, 50936, 50937, 50941, 50948, 50949, 50952, 50956, 50964, 50965, 50967, 50969, 50976, 50977, 50980, 50984, 50992, 50993, 50995, 50997, 50999, 51004, 51005, 51008, 51012, 51018, 51020, 51021, 51023, 51025, 51026, 51027, 51028, 51029, 51030, 51031, 51032, 51036, 51040, 51048, 51051, 51060, 51061, 51064, 51068, 51069, 51070, 51075, 51076, 51077, 51079, 51080, 51081, 51082, 51086, 51088, 51089, 51092, 51094, 51095, 51096, 51098, 51104, 51105, 51107, 51108, 51109, 51110, 51116, 51117, 51120, 51124, 51132, 51133, 51135, 51136, 51137, 51144, 51145, 51148, 51150, 51152, 51160, 51165, 51172, 51176, 51180, 51200, 51201, 51204, 51208, 51210, 51216, 51217, 51219, 51221, 51222, 51228, 51229, 51232, 51236, 51244, 51245, 51247, 51249, 51256, 51260, 51264, 51272, 51273, 51276, 51277, 51284, 51312, 51313, 51316, 51320, 51322, 51328, 51329, 51331, 51333, 51334, 51335, 51339, 51340, 51341, 51348, 51357, 51359, 51361, 51368, 51388, 51389, 51396, 51400, 51404, 51412, 51413, 51415, 51417, 51424, 51425, 51428, 51445, 51452, 51453, 51456, 51460, 51461, 51462, 51468, 51469, 51471, 51473, 51480, 51500, 51508, 51536, 51537, 51540, 51544, 51552, 51553, 51555, 51564, 51568, 51572, 51580, 51592, 51593, 51596, 51600, 51608, 51609, 51611, 51613, 51648, 51649, 51652, 51655, 51656, 51658, 51664, 51665, 51667, 51669, 51670, 51673, 51674, 51676, 51677, 51680, 51682, 51684, 51687, 51692, 51693, 51695, 51696, 51697, 51704, 51705, 51708, 51712, 51720, 51721, 51723, 51724, 51725, 51732, 51736, 51753, 51788, 51789, 51792, 51796, 51804, 51805, 51807, 51808, 51809, 51816, 51837, 51844, 51864, 51900, 51901, 51904, 51908, 51916, 51917, 51919, 51921, 51923, 51928, 51929, 51936, 51948, 51956, 51976, 51984, 51988, 51992, 52000, 52001, 52033, 52040, 52041, 52044, 52048, 52056, 52057, 52061, 52068, 52088, 52089, 52124, 52152, 52180, 52196, 52199, 52201, 52236, 52237, 52240, 52244, 52252, 52253, 52257, 52258, 52263, 52264, 52265, 52268, 52270, 52272, 52280, 52281, 52283, 52284, 52285, 52286, 52292, 52293, 52296, 52300, 52308, 52309, 52311, 52312, 52313, 52320, 52324, 52326, 52328, 52336, 52341, 52376, 52377, 52380, 52384, 52392, 52393, 52395, 52396, 52397, 52404, 52405, 52408, 52412, 52420, 52421, 52423, 52425, 52432, 52436, 52452, 52460, 52464, 52481, 52488, 52489, 52492, 52496, 52504, 52505, 52507, 52509, 52516, 52520, 52524, 52537, 52572, 52576, 52580, 52588, 52589, 52591, 52593, 52600, 52616, 52628, 52629, 52632, 52636, 52644, 52645, 52647, 52649, 52656, 52676, 52684, 52688, 52712, 52716, 52720, 52728, 52729, 52731, 52733, 52740, 52744, 52748, 52756, 52761, 52768, 52769, 52772, 52776, 52784, 52785, 52787, 52789, 52824, 52825, 52828, 52831, 52832, 52833, 52840, 52841, 52843, 52845, 52852, 52853, 52856, 52860, 52868, 52869, 52871, 52873, 52880, 52881, 52884, 52888, 52896, 52897, 52899, 52900, 52901, 52908, 52909, 52929, 52964, 52965, 52968, 52971, 52972, 52980, 52981, 52983, 52984, 52985, 52992, 52993, 52996, 53000, 53008, 53009, 53011, 53013, 53020, 53024, 53028, 53036, 53037, 53039, 53040, 53041, 53048, 53076, 53077, 53080, 53084, 53092, 53093, 53095, 53097, 53104, 53105, 53108, 53112, 53120, 53125, 53132, 53153, 53160, 53168, 53188, 53216, 53217, 53220, 53224, 53232, 53233, 53235, 53237, 53244, 53248, 53252, 53265, 53272, 53293, 53300, 53301, 53304, 53308, 53316, 53317, 53319, 53321, 53328, 53332, 53336, 53344, 53356, 53357, 53360, 53364, 53372, 53373, 53377, 53412, 53413, 53416, 53420, 53428, 53429, 53431, 53433, 53440, 53441, 53444, 53448, 53449, 53456, 53457, 53459, 53460, 53461, 53468, 53469, 53472, 53476, 53484, 53485, 53487, 53488, 53489, 53496, 53517, 53552, 53553, 53556, 53560, 53562, 53568, 53569, 53571, 53572, 53573, 53580, 53581, 53584, 53588, 53596, 53597, 53599, 53601, 53608, 53612, 53628, 53636, 53640, 53664, 53665, 53668, 53672, 53680, 53681, 53683, 53685, 53690, 53692, 53696, 53720, 53748, 53752, 53767, 53769, 53776, 53804, 53805, 53808, 53812, 53820, 53821, 53823, 53825, 53832, 53852, 53860, 53888, 53889, 53892, 53896, 53904, 53905, 53909, 53916, 53920, 53924, 53932, 53937, 53944, 53945, 53948, 53951, 53952, 53954, 53960, 53961, 53963, 53972, 53976, 53980, 53988, 53989, 54000, 54001, 54004, 54008, 54016, 54017, 54019, 54021, 54028, 54029, 54030, 54032, 54036, 54038, 54044, 54045, 54047, 54048, 54049, 54053, 54056, 54057, 54060, 54064, 54072, 54073, 54075, 54076, 54077, 54084, 54085, 54140, 54141, 54144, 54148, 54156, 54157, 54159, 54160, 54161, 54168, 54169, 54172, 54176, 54184, 54185, 54187, 54189, 54196, 54200, 54204, 54212, 54213, 54216, 54217, 54224, 54232, 54241, 54243, 54252, 54253, 54256, 54260, 54268, 54269, 54271, 54273, 54280, 54301, 54336, 54340, 54364, 54368, 54372, 54381, 54383, 54392, 54393, 54396, 54399, 54400, 54402, 54408, 54409, 54411, 54413, 54420, 54441, 54476, 54480, 54484, 54492, 54495, 54504, 54508, 54512, 54520, 54523, 54525, 54532, 54536, 54540, 54548, 54549, 54551, 54588, 54589, 54592, 54596, 54604, 54605, 54607, 54609, 54616, 54617, 54620, 54624, 54629, 54632, 54633, 54635, 54637, 54644, 54645, 54648, 54652, 54660, 54661, 54663, 54664, 54665, 54672, 54693, 54728, 54729, 54732, 54736, 54738, 54744, 54745, 54747, 54749, 54756, 54757, 54760, 54764, 54772, 54773, 54775, 54777, 54784, 54785, 54788, 54792, 54800, 54801, 54803, 54804, 54805, 54812, 54816, 54820, 54829, 54840, 54841, 54844, 54848, 54853, 54856, 54857, 54859, 54861, 54865, 54868, 54869, 54872, 54876, 54887, 54889, 54896, 54897, 54900, 54915, 54917, 54924, 54925, 54928, 54932, 54941, 54943, 54945, 54952, 54956, 54960, 54969, 54971, 54980, 54981, 54984, 54988, 54993, 54996, 54999, 55001, 55008, 55012, 55016, 55024, 55029, 55036, 55037, 55040, 55044, 55057, 55064, 55065, 55068, 55072, 55080, 55081, 55083, 55085, 55092, 55093, 55096, 55100, 55108, 55111, 55113, 55120, 55121, 55124, 55126, 55127, 55128, 55129, 55136, 55137, 55139, 55141, 55145, 55148, 55152, 55156, 55164, 55165, 55169, 55176, 55177, 55180, 55184, 55192, 55193, 55195, 55197, 4352, 4353, 4354, 4355, 4356, 4357, 4358, 4359, 4360, 4361, 4362, 4363, 4364, 4365, 4366, 4367, 4368, 4369, 4370, 4449, 4450, 4451, 4452, 4453, 4454, 4455, 4456, 4457, 4461, 4462, 4466, 4467, 4469, 47252, 49968, 50108, 50388, 52012, 65535 }; internal static readonly ushort[] G34_4E = { 478, 351, 352, 353, 358, 359, 360, 361, 362, 363, 020, 365, 366, 369, 370, 371, 415, 376, 377, 378, 368, 382, 383, 384, 046, 358, 359, 392, 393, 394, 395, 396, 397, 398, 401, 402, 403, 416, 408, 409, 410, 400, 420, 419, 479, 450, 445, 003, 004, 006, 008, 010, 068, 449, 072, 013, 015, 017, 019, 021, 023, 025, 027, 029, 031, 033, 035, 038, 040, 042, 049, 052, 055, 058, 061, 050, 053, 056, 059, 062, 036, 426, 425, 480, 481, 091, 092, 094, 096, 098, 364, 100, 102, 106, 108, 110, 112, 114, 117, 119, 121, 123, 124, 125, 385, 127, 128, 131, 134, 137, 140, 396, 144, 145, 146, 147, 149, 151, 153, 154, 155, 156, 157, 158, 159, 160, 161, 082, 084, 086, 088, 090, 148, 150, 152, 093, 095, 097, 099, 101, 103, 105, 107, 109, 111, 113, 115, 118, 120, 122, 129, 132, 135, 138, 141, 130, 133, 136, 139, 142, 116, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 427, 428, 430, 241, 230, 431, 436, 437, 434, 435, 443, 444, 424, 429, 242, 433, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 289, 452, 355, 373, 379, 387, 405, 411 }; internal static readonly ushort[] G34_4J = { 001, 003, 005, 007, 009, 011, 012, 014, 016, 018, 020, 022, 024, 026, 028, 030, 032, 034, 037, 039, 041, 043, 044, 045, 046, 047, 048, 051, 054, 057, 060, 063, 064, 065, 066, 067, 069, 071, 073, 074, 075, 076, 077, 078, 079, 080, 081, 002, 004, 006, 008, 010, 068, 070, 072, 013, 015, 017, 019, 021, 023, 025, 027, 029, 031, 033, 035, 038, 040, 042, 049, 052, 055, 058, 061, 050, 053, 056, 059, 062, 036, 083, 085, 087, 089, 091, 092, 094, 096, 098, 100, 102, 104, 106, 108, 110, 112, 114, 117, 119, 121, 123, 124, 125, 126, 127, 128, 131, 134, 137, 140, 143, 144, 145, 146, 147, 149, 151, 153, 154, 155, 156, 157, 158, 159, 160, 161, 082, 084, 086, 088, 090, 148, 150, 152, 093, 095, 097, 099, 101, 103, 105, 107, 109, 111, 113, 115, 118, 120, 122, 129, 132, 135, 138, 141, 130, 133, 136, 139, 142, 116, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 225, 226, 228, 241, 230, 229, 234, 235, 232, 233, 443, 444, 424, 430, 242, 433, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 289, 452, 355, 373, 379, 387, 405, 411 }; #endregion internal static readonly byte[][] G4TransferTrashBytes = { new byte[] { }, // Unused new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, new byte[] { 0x18, 0x20, 0x0D, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0xA1, 0x0C, 0x02, 0xE0, 0xFF }, new byte[] { 0x74, 0x20, 0x0D, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA4, 0xA1, 0x0C, 0x02, 0xE0, 0xFF }, new byte[] { 0x54, 0x20, 0x0D, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xA1, 0x0C, 0x02, 0xE0, 0xFF }, new byte[] { 0x74, 0x20, 0x0D, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA4, 0xA1, 0x0C, 0x02, 0xE0, 0xFF }, new byte[] { }, // Unused new byte[] { 0x74, 0x20, 0x0D, 0x02, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA4, 0xA1, 0x0C, 0x02, 0xE0, 0xFF }, }; internal static byte[] decryptArray3(byte[] ekm) { if (ekm.Length != SIZE_3PARTY && ekm.Length != SIZE_3STORED) return null; uint PID = BitConverter.ToUInt32(ekm, 0); uint OID = BitConverter.ToUInt32(ekm, 4); uint seed = PID ^ OID; byte[] xorkey = BitConverter.GetBytes(seed); for (int i = 32; i < 80; i++) ekm[i] ^= xorkey[i % 4]; return shuffleArray3(ekm, PID%24); } internal static byte[] shuffleArray3(byte[] data, uint sv) { byte[] sdata = new byte[data.Length]; Array.Copy(data, sdata, 32); // Copy unshuffled bytes // Shuffle Away! for (int block = 0; block < 4; block++) Array.Copy(data, 32 + 12 * blockPosition[block][sv], sdata, 32 + 12 * block, 12); // Fill the Battle Stats back if (data.Length > SIZE_3STORED) Array.Copy(data, SIZE_3STORED, sdata, SIZE_3STORED, data.Length - SIZE_3STORED); return sdata; } internal static byte[] encryptArray3(byte[] pkm) { if (pkm.Length != SIZE_3PARTY && pkm.Length != SIZE_3STORED) return null; uint PID = BitConverter.ToUInt32(pkm, 0); uint OID = BitConverter.ToUInt32(pkm, 4); uint seed = PID ^ OID; byte[] ekm = shuffleArray3(pkm, blockPositionInvert[PID%24]); byte[] xorkey = BitConverter.GetBytes(seed); for (int i = 32; i < 80; i++) ekm[i] ^= xorkey[i % 4]; return ekm; } internal static ushort getG4Item(ushort g3val) { ushort[] arr = { 0,1,2,3,4,5,6,7,8,9, 10,11,12,17,18,19,20,21,22,23, 24,25,26,27,28,29,30,31,32,33, 34,35,36,37,38,39,40,41,42,65, 66,67,68,69,43,44,70,71,72,73, 74,75,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,45,46,47,48,49,50,51, 52,53,0xFFFF,55,56,57,58,59,60,0xFFFF, 63,64,0xFFFF,76,77,78,79,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,80,81,82,83,84,85,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,86,87,0xFFFF,88,89,90,91, 92,93,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,149,150,151,152,153,154,155, 156,157,158,159,160,161,162,163,164,165, 166,167,168,169,170,171,172,173,174,175, 176,177,178,179,180,181,182,183,201,202, 203,204,205,206,207,208,0xFFFF,0xFFFF,0xFFFF,213, 214,215,216,217,218,219,220,221,222,223, 224,225,226,227,228,229,230,231,232,233, 234,235,236,237,238,239,240,241,242,243, 244,245,246,247,248,249,250,251,252,253, 254,255,256,257,258,259,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF, 0xFFFF,0xFFFF,0xFFFF,0xFFFF,260,261,262,263,264, }; if (g3val > arr.Length) return 0xFFFF; return arr[g3val]; } } }