From ed302d83ecb0ab012e8252e64c6903e457f84777 Mon Sep 17 00:00:00 2001 From: Sjef Verhoeven PE5PVB <76666293+PE5PVB@users.noreply.github.com> Date: Thu, 1 Jun 2023 16:12:24 +0200 Subject: [PATCH] Add files via upload --- TEF6686_ESP32.ino | 2614 ++++++++++++++++++++++++++++ src/TEF6686.cpp | 425 +++++ src/TEF6686.h | 80 + src/TFT_Colors.h | 8 + src/Tuner_Api.cpp | 106 ++ src/Tuner_Api.h | 7 + src/Tuner_Drv_Lithio.cpp | 223 +++ src/Tuner_Drv_Lithio.h | 70 + src/Tuner_Interface.cpp | 226 +++ src/Tuner_Interface.h | 8 + src/Tuner_Patch_Lithio_V101_p119.h | 275 +++ src/Tuner_Patch_Lithio_V102_p224.h | 287 +++ src/Tuner_Patch_Lithio_V205_p512.h | 273 +++ src/constants.h | 224 +++ 14 files changed, 4826 insertions(+) create mode 100644 TEF6686_ESP32.ino create mode 100644 src/TEF6686.cpp create mode 100644 src/TEF6686.h create mode 100644 src/TFT_Colors.h create mode 100644 src/Tuner_Api.cpp create mode 100644 src/Tuner_Api.h create mode 100644 src/Tuner_Drv_Lithio.cpp create mode 100644 src/Tuner_Drv_Lithio.h create mode 100644 src/Tuner_Interface.cpp create mode 100644 src/Tuner_Interface.h create mode 100644 src/Tuner_Patch_Lithio_V101_p119.h create mode 100644 src/Tuner_Patch_Lithio_V102_p224.h create mode 100644 src/Tuner_Patch_Lithio_V205_p512.h create mode 100644 src/constants.h diff --git a/TEF6686_ESP32.ino b/TEF6686_ESP32.ino new file mode 100644 index 0000000..114df66 --- /dev/null +++ b/TEF6686_ESP32.ino @@ -0,0 +1,2614 @@ +/* +******************************************************************************** + Advanced Tuner software for NXP TEF668x ESP32 + (c) 2023 Sjef Verhoeven pe5pvb@het-bar.net + Based on Catena / NXP semiconductors API +******************************************************************************** + v1.00 - Release + v1.01 - Add interrupt on both Rotary pins + - Add default settings + - Add Standby function + - Forced reboot after XDR-GTK disconnect + v1.02 - Fixed signalstrenght display when + value is 0 after boot or isn't changed + after menu close + - Added stepsize option + - Show "<" when signallevel is below + 0dBuV. Showing negative value is very + unstable. + - Cosmetic improvements + v1.03 - When signallevel is < set value all + statusses will only be updated + every 0.5 seconds. Threshold can be + set in the menu. RDS is then disabled + This will also improve I2C and ADC + noise on low level signals. + - System can now show negative dBuV. + v1.04 - Optimised TEF initialisation + - Fix on peakhold modulation meter + - Added Stereo squelch (turn knob right) + - Added Squelch off (turn knob left) + - Show current Squelch threshold + v1.05 - Fixed bug: Patch was not loaded + correctly into tuner after boot + - In Low level mode, RDS logo disabled + - Fix Stereo/mono toggle when using + XDR-GTK + - Fixed Squelch level readout when + leaving menu. This could cause auto- + scan to not work. + - Fix: RDS logo was not disabled in low + signal level mode + - Changed advice for TFT frequency to + reduce unwanted noise + - Optimised soft-boot + v1.06 - Slow down I2C speed to reduce noise + - Fix auto scan when squelch level is + below 0dBuV + - Fix show Hz (not kHz) on high cut + corner frequency + v1.07 - Added multipath suppresion (iMS) and + Channel Equalizer (EQ) + - Long press rotary to toggle iMS and EQ + - Added standby LED on D19 + - XDR-GTK: Use the antenna rotor buttons + to start scan up or down + - XDR-GTK: Enable IF+ to force low + signal level mode + - XDR-GTK: DX1 = Normal + DX2 = iMS enabled + DX3 = EQ enabled + DX4 = Both enabled + - Small modifications on XDR-GTK routine + for compatibility with modified + XDR-GTK TEF6686 edition + - Fixed small bug with displaytext in + scan mode + v1.08 - Fixed interrupted canvas lines on TFT + - Added function to mute TFT using XDR- + GTK. Use RF+ to use this function + - Level offset is still as set when + using XDR-GTK + - Detach interrupts when writing + frequency to display, to prevent + display crash + - Fixed bug when squelch is set to -1 + - Fixed bug that volume offset was reset + to 0 after changing frequency + v1.09 - Stereo indication didn't work when RF+ + was set in XDR-GTK + - Minor fix: When for some reason the + signallevel was an invalid value, now + the limit is -10 to +120dBuV + - No more short mute when changing frequency + - tuned indication only on when signal + valid. + - In Auto mode frequency is now shown and + direction can be changed on the fly. + to stop searching, just press any key. + - Minor bugfix in low signal lever timer. + v1.10 - Stand-by function was bricked after last update. + - Code optimised for compiler v2.0.0. + - Startup frequency was always 100.0MHz. Fixed. + v1.11 - Maximum frequency changed to 108MHz. (110MHz is not possible). + - Added AM reception. + - Hold BW button during boot to change direction of + rotary encoder. + - Hold Mode button during boot to flip the screen. + - When RT was too long the canvas was overwritten. + v1.12 - Stand-by key caused an issue when in menu mode. + - Canvas was broken on some points in the screen. + - Added possibility to connect analog signalmeter (thanks David DSP) + - Added slow signalmeter riding (thanks David DSP) + - S-meter for AM is corrected to the right values. + v1.13 - Fix for frequency offset in AM. + - Fix for flickering signalmeter when fluctuation is < 1dBuV. + - Added support for David DSP's converter board. + v1.14 - Bugfix: When signallevel drops down in digits, old digits were still displayed. + v1.15 - Fix AM bandwidth setting on F6805 chipset + - Added microcode for whole TEF668x family (Lithio) + - Added C/N readout + - S-meter and modulation meter update (Thanks David DSP) + - Added splash screen with tuner info + - Fixed problem when tuning beyond bandlimits on AM + - FM level calibrated + - Function added to choose between regular and optical rotary encoder (hold rotary button during boot) + v1.16 - Fixed some bugs to make the script compatible with new boardmanagers (v2.x) + - Rewritten rotary encoder routines + - New RDS routine + - Massive code cleanup + - Fixed canvas when changing bands + - Radiotext auto scroll when it does not fit in the window + - Added RDS CT (clock only) + - Added FullSearchRDS for TEF6687 & TEF6689 + - Added AM/FM indicator + - Fixed S-meter averaging + - Improved XDRGTK RDS output + - On signal dropout, RDS PTY, PI and PS stays on screen in blue +******************************************************************************** + + Analog signalmeter: + to meter + | + R V + IO27 -------=====-----=====---| + 1 k 5 k POT + +******************************************************************************** + Setup: + During boot: + Hold BW button to change rotary encoder direction + Hold Mode button the flip screen + Hold Standby button to calibrate analogue s-meter + Hold rotary button to switch between normal and optical rotary encoder + + Manual: + STANDBY SHORT PRESS: Switch band + STANDBY LONG PRESS: Standby + ROTARY SHORT PRESS: Set stepsize or navigate + ROTARY LONG PRESS: Toggle iMS & EQ + MODE SHORT PRESS: Switch between auto/manual + or exit menu + MODE LONG PRESS: Open menu + BW SHORT PRESS: Switch bandwidth setting + BW LONG PRESS: Switch mono, or auto stereo +* *********************************************** + + + Use this settings in TFT_eSPI User_Setup.h + #define ILI9341_DRIVER + #define TFT_CS 5 + #define TFT_DC 17 + #define TFT_RST 16 + #define LOAD_GLCD + #define LOAD_FONT2 + #define LOAD_FONT4 + #define LOAD_FONT6 + #define LOAD_FONT7 + #define LOAD_FONT8 + #define LOAD_GFXFF + #define SMOOTH_FONT + #define SPI_FREQUENCY 10000000 + + ALL OTHER SETTINGS SHOULD BE REMARKED!!!! + +*/ + +#include "src/TEF6686.h" +#include "src/constants.h" +#include +#include +#include // https://github.com/Bodmer/TFT_eSPI +#include // https://github.com/PaulStoffregen/Time + +#define TFT_GREYOUT 0x38E7 +#define ROTARY_PIN_A 34 +#define ROTARY_PIN_B 36 +#define ROTARY_BUTTON 39 +#define PIN_POT 35 +#define PWRBUTTON 4 +#define BWBUTTON 25 +#define MODEBUTTON 26 +#define CONTRASTPIN 2 +#define STANDBYLED 19 +#define SMETERPIN 27 +//#define ARS // uncomment for BGR type display (ARS version) + +#ifdef ARS +#define VERSION "v1.16ARS" +#include "TFT_Colors.h" +TFT_eSPI tft = TFT_eSPI(320, 240); +#else +#define VERSION "v1.16" +TFT_eSPI tft = TFT_eSPI(240, 320); +#endif + +bool BWreset; +bool change2; +bool cleanup; +bool direction; +bool dropout; +bool fullsearchrds; +bool LowLevelInit = false; +bool menu; +bool menuopen = false; +bool power = true; +bool RDSstatusold; +bool screenmute = false; +bool seek; +bool setupmode; +bool SQ; +bool Stereostatusold; +bool StereoToggle = true; +bool store; +bool tuned; +bool tunemode = false; +bool USBstatus = false; +bool XDRMute; +byte band; +byte BWset; +byte ContrastSet; +byte displayflip; +byte EQset; +byte freqoldcount; +byte iMSEQ; +byte iMSset; +byte LowLevelSet; +byte optenc; +byte rotarymode; +byte SNR; +byte SNRold; +byte SStatusoldcount; +byte stepsize; +byte TEF; +char buff[16]; +char programServicePrevious[9]; +char programTypePrevious[17]; +char radioIdPrevious[5]; +char radioTextPrevious[65]; +int AGC; +int BWOld; +int charWidth = tft.textWidth("AA"); +int ConverterSet; +int DeEmphasis; +int ForceMono; +int freqold; +int HighCutLevel; +int HighCutOffset; +int HighEdgeSet; +int LevelOffset; +int LowEdgeSet; +int lowsignaltimer; +int menuoption = 30; +int MStatusold; +int OStatusold; +int peakholdold; +int peakholdtimer; +int rotary; +int scanner_filter; +int Sqstatusold; +int Squelch; +int Squelchold; +int SStatusold; +int StereoLevel; +int Stereostatus; +int VolSet; +int volume; +int XDRBWset; +int XDRBWsetold; +int xPos = 6; +int yPos = 2; +int16_t OStatus; +int16_t SAvg; +int16_t SAvg2; +int16_t SStatus; +String ContrastString; +String ConverterString; +String HighCutLevelString; +String HighCutOffsetString; +String HighEdgeString; +String LevelOffsetString; +String LowEdgeString; +String LowLevelString; +String PIold; +String PSold; +String PTYold; +String rds_clock; +String rds_clockold; +String RTold; +String StereoLevelString; +String VolString; +String XDRGTKRDS; +String XDRGTKRDSold; +uint16_t BW; +uint16_t MStatus; +uint16_t USN; +uint16_t WAM; +uint8_t buff_pos = 0; +uint8_t RDSstatus; +unsigned int change; +unsigned int freq_scan; +unsigned int frequency; +unsigned int frequency_AM; +unsigned int frequencyold; +unsigned int scanner_end; +unsigned int scanner_start; +unsigned int scanner_step; +unsigned long peakholdmillis; +unsigned long rtticker; + +TEF6686 radio; +TFT_eSprite sprite = TFT_eSprite(&tft); + +void setup() { + setupmode = true; + EEPROM.begin(56); + if (EEPROM.readByte(41) != 15) { + EEPROM.writeByte(2, 0); + EEPROM.writeByte(3, 0); + EEPROM.writeUInt(0, 10000); + EEPROM.writeInt(4, 0); + EEPROM.writeInt(8, 0); + EEPROM.writeInt(12, 87); + EEPROM.writeInt(16, 108); + EEPROM.writeInt(20, 50); + EEPROM.writeInt(24, 0); + EEPROM.writeInt(28, 0); + EEPROM.writeInt(32, 70); + EEPROM.writeInt(36, 0); + EEPROM.writeByte(41, 15); + EEPROM.writeByte(42, 0); + EEPROM.writeByte(43, 20); + EEPROM.writeByte(44, 1); + EEPROM.writeByte(45, 1); + EEPROM.writeByte(46, 0); + EEPROM.writeUInt(47, 828); + EEPROM.writeByte(52, 0); + EEPROM.writeByte(53, 0); + EEPROM.writeByte(54, 0); + EEPROM.writeByte(55, 0); + EEPROM.commit(); + } + frequency = EEPROM.readUInt(0); + VolSet = EEPROM.readInt(4); + ConverterSet = EEPROM.readInt(8); + LowEdgeSet = EEPROM.readInt(12); + HighEdgeSet = EEPROM.readInt(16); + ContrastSet = EEPROM.readInt(20); + LevelOffset = EEPROM.readInt(24); + StereoLevel = EEPROM.readInt(28); + HighCutLevel = EEPROM.readInt(32); + HighCutOffset = EEPROM.readInt(36); + stepsize = EEPROM.readByte(42); + LowLevelSet = EEPROM.readByte(43); + iMSset = EEPROM.readByte(44); + EQset = EEPROM.readByte(45); + band = EEPROM.readByte(46); + frequency_AM = EEPROM.readUInt(47); + rotarymode = EEPROM.readByte(52); + displayflip = EEPROM.readByte(53); + TEF = EEPROM.readByte(54); + optenc = EEPROM.readByte(55); + EEPROM.commit(); + btStop(); + Serial.begin(115200); + + if (iMSset == 1 && EQset == 1) { + iMSEQ = 2; + } + if (iMSset == 0 && EQset == 1) { + iMSEQ = 3; + } + if (iMSset == 1 && EQset == 0) { + iMSEQ = 4; + } + if (iMSset == 0 && EQset == 0) { + iMSEQ = 1; + } + + tft.init(); + + if (displayflip == 0) { +#ifdef ARS + tft.setRotation(0); +#else + tft.setRotation(3); +#endif + } else { +#ifdef ARS + tft.setRotation(2); +#else + tft.setRotation(1); +#endif + } + + TEF = EEPROM.readByte(54); + + if (TEF != 101 && TEF != 102 && TEF != 205) SetTunerPatch(); + + radio.init(TEF); + uint16_t device; + uint16_t hw; + uint16_t sw; + radio.getIdentification(device, hw, sw); + if (TEF != (highByte(hw) * 100 + highByte(sw))) SetTunerPatch(); + + analogWrite(CONTRASTPIN, ContrastSet * 2 + 27); + analogWrite(SMETERPIN, 0); + + radio.getIdentification(device, hw, sw); + uint8_t version = highByte(hw) * 100 + highByte(sw); + + pinMode(MODEBUTTON, INPUT); + pinMode(BWBUTTON, INPUT); + pinMode(ROTARY_BUTTON, INPUT); + pinMode(ROTARY_PIN_A, INPUT); + pinMode(ROTARY_PIN_B, INPUT); + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A), read_encoder, CHANGE); + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B), read_encoder, CHANGE); + + if (digitalRead(BWBUTTON) == LOW) { + if (rotarymode == 0) rotarymode = 1; else rotarymode = 0; + EEPROM.writeByte(52, rotarymode); + EEPROM.commit(); + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Rotary direction changed", 150, 70, 4); + tft.drawCentreString("Please release button", 150, 100, 4); + while (digitalRead(BWBUTTON) == LOW) delay(50); + } + + if (digitalRead(MODEBUTTON) == LOW) { + if (displayflip == 0) { + displayflip = 1; + tft.setRotation(1); + } else { + displayflip = 0; + tft.setRotation(3); + } + EEPROM.writeByte(53, displayflip); + EEPROM.commit(); + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Screen flipped", 150, 70, 4); + tft.drawCentreString("Please release button", 150, 100, 4); + while (digitalRead(MODEBUTTON) == LOW) delay(50); + } + + if (digitalRead(PWRBUTTON) == LOW) { + analogWrite(SMETERPIN, 511); + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Calibrate analog meter", 150, 70, 4); + tft.drawCentreString("Release button when ready", 150, 100, 4); + while (digitalRead(PWRBUTTON) == LOW) delay(50); + analogWrite(SMETERPIN, 0); + } + + if (digitalRead(ROTARY_BUTTON) == LOW) { + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_WHITE); + if (optenc == 0) { + optenc = 1; + tft.drawCentreString("encoder set to optical", 150, 70, 4); + } else { + optenc = 0; + tft.drawCentreString("encoder set to standard", 150, 70, 4); + } + EEPROM.writeByte(55, optenc); + EEPROM.commit(); + tft.drawCentreString("Please release button", 150, 100, 4); + while (digitalRead(ROTARY_BUTTON) == LOW) delay(50); + } + + tft.setSwapBytes(true); + tft.fillScreen(TFT_BLACK); + tft.pushImage (0, 99, 211, 140, pe5pvblogo); + tft.pushImage (239, 200, 80, 30, nxplogo); + tft.setTextColor(TFT_SKYBLUE); + tft.drawCentreString("FM/AM receiver", 160, 10, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawCentreString("Software " + String(VERSION), 160, 30, 2); + tft.setTextColor(TFT_WHITE); + tft.drawString("Lithio", 260, 180, 2); + + if (lowByte(device) == 14) { + fullsearchrds = false; + tft.drawString("Tuner: TEF6686 Lithio (" + String(version) + ")", 80, 60, 2); + } else if (lowByte(device) == 1) { + fullsearchrds = true; + tft.drawString("Tuner: TEF6687 Lithio FMSI (" + String(version) + ")", 80, 60, 2); + } else if (lowByte(device) == 9) { + fullsearchrds = false; + tft.drawString("Tuner: TEF6688 Lithio DR (" + String(version) + ")", 80, 60, 2); + } else if (lowByte(device) == 3) { + fullsearchrds = true; + tft.drawString("Tuner: TEF6689 Lithio FMSI DR (" + String(version) + ")", 80, 60, 2); + } else { + tft.setTextColor(TFT_RED); + tft.drawString("Tuner: !None!", 80, 60, 2); + while (true); + for (;;); + } + tft.drawString("Patch: v" + String(TEF), 80, 75, 2); + delay(1500); + + radio.setVolume(VolSet); + radio.setOffset(LevelOffset); + radio.setStereoLevel(StereoLevel); + radio.setHighCutLevel(HighCutLevel); + radio.setHighCutOffset(HighCutOffset); + radio.clearRDS(fullsearchrds); + radio.setMute(); + LowLevelInit = true; + + if (ConverterSet >= 200) { + Wire.beginTransmission(0x12); + Wire.write(ConverterSet >> 8); + Wire.write(ConverterSet & (0xFF)); + Wire.endTransmission(); + } + + SelectBand(); + ShowSignalLevel(); + ShowBW(); + setupmode = false; + sprite.createSprite(313, 18); +} + +void loop() { + if (digitalRead(PWRBUTTON) == LOW && USBstatus == false) PWRButtonPress(); + + if (power == true) { + if (seek == true) Seek(direction); + + if ((SStatus / 10 > LowLevelSet) && LowLevelInit == false && menu == false && band == 0) { + if (screenmute == false) { + tft.setTextColor(TFT_WHITE); + tft.drawString("20", 20, 153, 1); + tft.drawString("40", 50, 153, 1); + tft.drawString("60", 80, 153, 1); + tft.drawString("80", 110, 153, 1); + tft.drawString("100", 134, 153, 1); + tft.drawString("120", 164, 153, 1); + tft.drawString("%", 196, 153, 1); + tft.drawString("M", 6, 136, 2); + tft.drawString("PI:", 216, 195, 2); + tft.drawString("PS:", 6, 195, 2); + tft.drawString("PTY:", 6, 168, 2); + tft.drawLine(20, 150, 200, 150, TFT_DARKGREY); + } + LowLevelInit = true; + } + + if ((SStatus / 10 <= LowLevelSet) && band == 0) { + if (LowLevelInit == true && menu == false) { + if (screenmute == false) { + tft.fillRect(20, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(34, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(48, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(62, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(76, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(90, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(104, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(118, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(132, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(146, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(160, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(174, 139, 12, 8, TFT_GREYOUT); + tft.fillRect(188, 139, 12, 8, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawString("20", 20, 153, 1); + tft.drawString("40", 50, 153, 1); + tft.drawString("60", 80, 153, 1); + tft.drawString("80", 110, 153, 1); + tft.drawString("100", 134, 153, 1); + tft.drawString("120", 164, 153, 1); + tft.drawString("%", 196, 153, 1); + tft.drawString("M", 6, 136, 2); + tft.drawString("PI:", 216, 195, 2); + tft.drawString("PS:", 6, 195, 2); + tft.drawString("PTY:", 6, 168, 2); + tft.drawLine(20, 150, 200, 150, TFT_GREYOUT); + tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT); + } + LowLevelInit = false; + } + + if (millis() >= lowsignaltimer + 300) { + lowsignaltimer = millis(); + if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus); + if (screenmute == true) readRds(); + if (menu == false) doSquelch(); + } + + } else { + if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus); + if (menu == false) { + doSquelch(); + readRds(); + if (screenmute == false) { + ShowModLevel(); + } + } + } + + if (menu == false) { + if (screenmute == false) { + if (band == 0) { + showPI(); + showPTY(); + showCT(); + showPS(); + showRadioText(); + showPS(); + ShowStereoStatus(); + } + ShowOffset(); + ShowSignalLevel(); + ShowBW(); + } + } + + XDRGTKRoutine(); + + if (menu == true && menuopen == true && menuoption == 110) + { + if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus); + if (millis() >= lowsignaltimer + 500 || change2 == true) { + lowsignaltimer = millis(); + change2 = false; + if (SStatus > SStatusold || SStatus < SStatusold) + { + String count = String(SStatus / 10, DEC); + if (screenmute == false) { + tft.setTextColor(TFT_BLACK); + if (SStatusold >= 0) { + if (SStatusoldcount <= 1) tft.setCursor (100, 140); + if (SStatusoldcount == 2) tft.setCursor (73, 140); + if (SStatusoldcount >= 3) tft.setCursor (46, 140); + } else { + if (SStatusoldcount <= 1) tft.setCursor (100, 140); + if (SStatusoldcount == 2) tft.setCursor (83, 140); + if (SStatusoldcount >= 3) tft.setCursor (56, 140); + } + tft.setTextFont(6); + tft.print(SStatusold / 10); + tft.print("."); + if (SStatusold < 0) + { + String negative = String (SStatusold % 10, DEC); + if (SStatusold % 10 == 0) tft.print("0"); else tft.print(negative[1]); + } else { + tft.print(SStatusold % 10); + } + + tft.setTextColor(TFT_YELLOW, TFT_BLACK); + if (SStatus >= 0) { + if (count.length() == 1) tft.setCursor (100, 140); + if (count.length() == 2) tft.setCursor (73, 140); + if (count.length() == 3) tft.setCursor (46, 140); + } else { + if (count.length() == 1) tft.setCursor (100, 140); + if (count.length() == 2) tft.setCursor (83, 140); + if (count.length() >= 3) tft.setCursor (56, 140); + } + tft.setTextFont(6); + tft.print(SStatus / 10); + tft.print("."); + if (SStatus < 0) + { + String negative = String (SStatus % 10, DEC); + if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]); + } else { + tft.print(SStatus % 10); + } + SStatusold = SStatus; + SStatusoldcount = count.length(); + } + } + } + } + + if (rotary == -1) KeyUp(); + if (rotary == 1) KeyDown(); + + if (digitalRead(ROTARY_BUTTON) == LOW) ButtonPress(); + if (digitalRead(MODEBUTTON) == LOW && screenmute == false) ModeButtonPress(); + if (digitalRead(BWBUTTON) == LOW && screenmute == false) BWButtonPress(); + + if (store == true) change++; + + if (change > 200 && store == true) { + detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A)); + detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B)); + EEPROM.writeUInt(0, radio.getFrequency()); + EEPROM.writeUInt(47, radio.getFrequency_AM()); + EEPROM.writeByte(46, band); + EEPROM.commit(); + store = false; + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A), read_encoder, CHANGE); + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B), read_encoder, CHANGE); + } + } +} + +void PWRButtonPress() { + if (menu == false) { + unsigned long counterold = millis(); + unsigned long counter = millis(); + while (digitalRead(PWRBUTTON) == LOW && counter - counterold <= 1000) counter = millis(); + + if (counter - counterold < 1000) { + if (power == false) { + ESP.restart(); + } else { + if (band == 0) band = 1; else band = 0; + StoreFrequency(); + SelectBand(); + } + } else { + if (power == false) { + ESP.restart(); + } else { + power = false; + analogWrite(SMETERPIN, 0); + analogWrite(CONTRASTPIN, 0); + pinMode (STANDBYLED, OUTPUT); + digitalWrite(STANDBYLED, LOW); + StoreFrequency(); + radio.power(1); + } + } + while (digitalRead(PWRBUTTON) == LOW) delay(50); + delay(100); + } +} + +void StoreFrequency() { + EEPROM.writeUInt(0, radio.getFrequency()); + EEPROM.writeUInt(47, radio.getFrequency_AM()); + EEPROM.writeByte(46, band); + EEPROM.commit(); +} + +void SelectBand() { + if (band == 1) { + seek = false; + tunemode = false; + BWreset = true; + BWset = 2; + if (radio.getFrequency_AM() > 0) frequency_AM = radio.getFrequency_AM(); + radio.setFrequency_AM(frequency_AM); + freqold = frequency_AM; + doBW; + radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus); + if (screenmute == false) BuildDisplay(); + tft.drawString("PI:", 216, 195, 2); + tft.drawString("PS:", 6, 195, 2); + tft.drawString("PTY:", 6, 168, 2); + tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT); + tft.drawRoundRect(249, 56, 30, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("iMS", 265, 58, 2); + tft.drawRoundRect(287, 56, 30, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("EQ", 303, 58, 2); + } else { + LowLevelInit == false; + BWreset = true; + BWset = 0; + radio.power(0); + delay(50); + radio.setFrequency(frequency, LowEdgeSet, HighEdgeSet, fullsearchrds); + freqold = frequency_AM; + doBW; + radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); + if (screenmute == false) BuildDisplay(); + } +} + +void BWButtonPress() { + if (menu == false) { + seek = false; + unsigned long counterold = millis(); + unsigned long counter = millis(); + while (digitalRead(BWBUTTON) == LOW && counter - counterold <= 1000) counter = millis(); + + if (counter - counterold < 1000) { + BWset++; + doBW(); + } else { + doStereoToggle(); + } + } + while (digitalRead(BWBUTTON) == LOW) delay(50); + delay(100); +} + +void doStereoToggle() { + if (StereoToggle == true) { + if (screenmute == false) { + tft.drawCircle(81, 15, 10, TFT_BLACK); + tft.drawCircle(81, 15, 9, TFT_BLACK); + tft.drawCircle(91, 15, 10, TFT_BLACK); + tft.drawCircle(91, 15, 9, TFT_BLACK); + tft.drawCircle(86, 15, 10, TFT_SKYBLUE); + tft.drawCircle(86, 15, 9, TFT_SKYBLUE); + } + radio.setMono(2); + StereoToggle = false; + } else { + if (screenmute == false) { + tft.drawCircle(86, 15, 10, TFT_BLACK); + tft.drawCircle(86, 15, 9, TFT_BLACK); + } + radio.setMono(0); + Stereostatusold = false; + StereoToggle = true; + } +} + +void ModeButtonPress() { + if (menu == false) { + seek = false; + unsigned long counterold = millis(); + unsigned long counter = millis(); + while (digitalRead(MODEBUTTON) == LOW && counter - counterold <= 1000) counter = millis(); + + if (counter - counterold <= 1000) { + doTuneMode(); + } else { + if (USBstatus == true) { + ShowFreq(1); + tft.setTextFont(4); + tft.setTextColor(TFT_WHITE, TFT_BLACK); + tft.setCursor (70, 60); + tft.print("NOT POSSIBLE"); + delay(1000); + tft.setTextFont(4); + tft.setTextColor(TFT_BLACK); + tft.setCursor (70, 60); + tft.print("NOT POSSIBLE"); + ShowFreq(0); + } else { + if (menu == false) { + BuildMenu(); + menu = true; + } + } + } + } else { + OStatusold = 1000; + Stereostatusold = false; + SStatusold = 2000; + BWOld = 0; + radio.clearRDS(fullsearchrds); + RDSstatus = 0; + BuildDisplay(); + ShowSignalLevel(); + ShowBW(); + menu = false; + menuopen = false; + LowLevelInit = true; + EEPROM.writeInt(4, VolSet); + EEPROM.writeInt(8, ConverterSet); + EEPROM.writeInt(12, LowEdgeSet); + EEPROM.writeInt(16, HighEdgeSet); + EEPROM.writeInt(20, ContrastSet); + EEPROM.writeInt(24, LevelOffset); + EEPROM.writeInt(28, StereoLevel); + EEPROM.writeInt(32, HighCutLevel); + EEPROM.writeInt(36, HighCutOffset); + EEPROM.writeByte(43, LowLevelSet); + EEPROM.commit(); + } + while (digitalRead(MODEBUTTON) == LOW) delay(50); + delay(100); +} + +void ShowStepSize() { + tft.fillRect(224, 38, 15, 4, TFT_GREYOUT); + tft.fillRect(193, 38, 15, 4, TFT_GREYOUT); + if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREYOUT); else tft.fillRect(162, 38, 15, 4, TFT_GREYOUT); + if (stepsize == 1) tft.fillRect(224, 38, 15, 4, TFT_GREEN); + if (stepsize == 2) tft.fillRect(193, 38, 15, 4, TFT_GREEN); + if (stepsize == 3) { + if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREEN); else tft.fillRect(162, 38, 15, 4, TFT_GREEN); + } +} + +void RoundStep() { + if (band == 0) { + int freq = radio.getFrequency(); + if (freq % 10 < 3) { + radio.setFrequency(freq - (freq % 10 - 5) - 5, LowEdgeSet, HighEdgeSet, fullsearchrds); + } + else if (freq % 10 > 2 && freq % 10 < 8) { + radio.setFrequency(freq - (freq % 10 - 5) , LowEdgeSet, HighEdgeSet, fullsearchrds); + } + else if (freq % 10 > 7) { + radio.setFrequency(freq - (freq % 10 - 5) + 5, LowEdgeSet, HighEdgeSet, fullsearchrds); + } + } else { + int freq = radio.getFrequency_AM(); + if (freq < 2000) radio.setFrequency_AM((freq / 9) * 9); else radio.setFrequency_AM((freq / 5) * 5); + } + while (digitalRead(ROTARY_BUTTON) == LOW) delay(50); + + if (band == 0) EEPROM.writeUInt(0, radio.getFrequency()); else EEPROM.writeUInt(47, radio.getFrequency_AM()); + EEPROM.commit(); +} + +void ButtonPress() { + if (menu == false) { + seek = false; + unsigned long counterold = millis(); + unsigned long counter = millis(); + while (digitalRead(ROTARY_BUTTON) == LOW && counter - counterold <= 1000) counter = millis(); + + if (counter - counterold < 1000) { + if (tunemode == false) { + stepsize++; + if (stepsize > 3) stepsize = 0; + + if (screenmute == false) ShowStepSize(); + + EEPROM.writeByte(42, stepsize); + EEPROM.commit(); + if (stepsize == 0) { + RoundStep(); + ShowFreq(0); + } + } + } else { + if (iMSEQ == 0) iMSEQ = 1; + + if (iMSEQ == 4) { + iMSset = 0; + EQset = 0; + updateiMS(); + updateEQ(); + iMSEQ = 0; + } + if (iMSEQ == 3) { + iMSset = 1; + EQset = 0; + updateiMS(); + updateEQ(); + iMSEQ = 4; + } + if (iMSEQ == 2) { + iMSset = 0; + EQset = 1; + updateiMS(); + updateEQ(); + iMSEQ = 3; + } + if (iMSEQ == 1) { + iMSset = 1; + EQset = 1; + updateiMS(); + updateEQ(); + iMSEQ = 2; + } + EEPROM.writeByte(44, iMSset); + EEPROM.writeByte(45, EQset); + EEPROM.commit(); + } + } else { + if (menuopen == false) { + menuopen = true; + tft.drawRoundRect(30, 40, 240, 160, 5, TFT_WHITE); + tft.fillRoundRect(32, 42, 236, 156, 5, TFT_BLACK); + switch (menuoption) { + case 30: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Volume:", 150, 70, 4); + tft.drawString("dB", 170, 110, 4); + + tft.setTextColor(TFT_YELLOW); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 165, 110, 4); else tft.drawRightString(String(VolSet, DEC), 165, 110, 4); + break; + + case 50: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Converter:", 150, 70, 4); + tft.drawString("MHz", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + + tft.drawRightString(String(ConverterSet, DEC), 165, 110, 4); + break; + + case 70: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Low bandedge:", 150, 70, 4); + tft.drawString("MHz", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 90: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("High bandedge:", 150, 70, 4); + tft.drawString("MHz", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 110: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("RF Level offset:", 150, 70, 4); + tft.drawString("dB", 170, 110, 4); + tft.drawString("dBuV", 190, 157, 4); + tft.setTextColor(TFT_YELLOW); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 165, 110, 4); else tft.drawRightString(String(LevelOffset, DEC), 165, 110, 4); + SStatusold = 2000; + change2 = true; + break; + + case 130: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Stereo threshold:", 150, 70, 4); + if (StereoLevel != 0) tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (StereoLevel != 0) tft.drawRightString(String(StereoLevel, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + break; + + case 150: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("High Cut corner:", 150, 70, 4); + if (HighCutLevel != 0) tft.drawString("Hz", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (HighCutLevel != 0) tft.drawRightString(String(HighCutLevel * 100, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + break; + + case 170: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Highcut threshold:", 150, 70, 4); + if (HighCutOffset != 0) tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (HighCutOffset != 0) tft.drawRightString(String(HighCutOffset, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + break; + + case 190: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Low level threshold:", 150, 70, 4); + tft.drawString("dBuV", 150, 110, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowLevelSet, DEC), 145, 110, 4); + break; + + case 210: + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Contrast:", 150, 70, 4); + tft.drawString("%", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(ContrastSet, DEC), 165, 110, 4); + break; + } + } else { + menuopen = false; + BuildMenu(); + } + } + while (digitalRead(ROTARY_BUTTON) == LOW) delay(50); +} + +void KeyUp() { + rotary = 0; + if (menu == false) { + if (tunemode == true) { + direction = true; + seek = true; + Seek(direction); + } else { + if (band == 0) frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneUp_AM(stepsize); + } + if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM)); + radio.clearRDS(fullsearchrds); + change = 0; + ShowFreq(0); + store = true; + } else { + if (menuopen == false) { + tft.drawRoundRect(10, menuoption, 300, 18, 5, TFT_BLACK); + menuoption += 20; + if (menuoption > 210) menuoption = 30; + tft.drawRoundRect(10, menuoption, 300, 18, 5, TFT_WHITE); + } else { + switch (menuoption) { + case 30: + tft.setTextColor(TFT_BLACK); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 165, 110, 4); else tft.drawRightString(String(VolSet, DEC), 165, 110, 4); + VolSet++; + if (VolSet > 10) VolSet = 10; + tft.setTextColor(TFT_YELLOW); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 165, 110, 4); else tft.drawRightString(String(VolSet, DEC), 165, 110, 4); + radio.setVolume(VolSet); + break; + + case 50: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(ConverterSet, DEC), 165, 110, 4); + ConverterSet++; + if (ConverterSet > 2400 || ConverterSet <= 200) if (ConverterSet == 1) ConverterSet = 200; else ConverterSet = 0; + if (ConverterSet >= 200) { + Wire.beginTransmission(0x12); + Wire.write(ConverterSet >> 8); + Wire.write(ConverterSet & (0xFF)); + Wire.endTransmission(); + } + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(ConverterSet, DEC), 165, 110, 4); + break; + + case 70: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 165, 110, 4); + LowEdgeSet ++; + if (LowEdgeSet > 107) LowEdgeSet = 65; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 90: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 165, 110, 4); + HighEdgeSet ++; + if (HighEdgeSet > 108) HighEdgeSet = 66; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 110: + tft.setTextColor(TFT_BLACK); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 165, 110, 4); else tft.drawRightString(String(LevelOffset, DEC), 165, 110, 4); + LevelOffset++; + if (LevelOffset > 15) LevelOffset = -25; + tft.setTextColor(TFT_YELLOW); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 165, 110, 4); else tft.drawRightString(String(LevelOffset, DEC), 165, 110, 4); radio.setOffset(LevelOffset); + change2 = true; + break; + + case 130: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(StereoLevel, DEC), 165, 110, 4); + StereoLevel ++; + if (StereoLevel > 60 || StereoLevel <= 30) if (StereoLevel == 1) StereoLevel = 30; else StereoLevel = 0; + tft.setTextColor(TFT_BLACK); + tft.drawRightString("Off", 165, 110, 4); + tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_WHITE); + if (StereoLevel != 0) tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (StereoLevel != 0) tft.drawRightString(String(StereoLevel, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + radio.setStereoLevel(StereoLevel); + break; + + case 150: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighCutLevel * 100, DEC), 165, 110, 4); + HighCutLevel ++; + if (HighCutLevel > 70) HighCutLevel = 15; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(HighCutLevel * 100, DEC), 165, 110, 4); + radio.setHighCutLevel(HighCutLevel); + break; + + case 170: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighCutOffset, DEC), 165, 110, 4); + HighCutOffset ++; + if (HighCutOffset > 60 || HighCutOffset <= 20) if (HighCutOffset == 1) HighCutOffset = 20; else HighCutOffset = 0; + tft.setTextColor(TFT_BLACK); + tft.drawRightString("Off", 165, 110, 4); + tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_WHITE); + if (HighCutOffset != 0) tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (HighCutOffset != 0) tft.drawRightString(String(HighCutOffset, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + radio.setHighCutOffset(HighCutOffset); + break; + + case 190: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(LowLevelSet, DEC), 145, 110, 4); + LowLevelSet++; + if (LowLevelSet > 40 || LowLevelSet <= 0) LowLevelSet = 0; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowLevelSet, DEC), 145, 110, 4); + break; + + case 210: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(ContrastSet, DEC), 165, 110, 4); + ContrastSet ++; + if (ContrastSet > 100) ContrastSet = 1; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(ContrastSet, DEC), 165, 110, 4); + analogWrite(CONTRASTPIN, ContrastSet * 2 + 27); + break; + } + } + } +} + +void KeyDown() { + rotary = 0; + if (menu == false) { + if (tunemode == true) { + direction = false; + seek = true; + Seek(direction); + } else { + if (band == 0) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneDown_AM(stepsize); + } + if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM)); + radio.clearRDS(fullsearchrds); + change = 0; + ShowFreq(0); + store = true; + } else { + if (menuopen == false) { + tft.drawRoundRect(10, menuoption, 300, 18, 5, TFT_BLACK); + menuoption -= 20; + if (menuoption < 30) { + menuoption = 210; + } + tft.drawRoundRect(10, menuoption, 300, 18, 5, TFT_WHITE); + } else { + switch (menuoption) { + case 30: + tft.setTextColor(TFT_BLACK); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 165, 110, 4); else tft.drawRightString(String(VolSet, DEC), 165, 110, 4); + VolSet--; + if (VolSet < -10) VolSet = -10; + tft.setTextColor(TFT_YELLOW); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 165, 110, 4); else tft.drawRightString(String(VolSet, DEC), 165, 110, 4); radio.setVolume(VolSet); + break; + + case 50: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(ConverterSet, DEC), 165, 110, 4); + ConverterSet--; + if (ConverterSet < 200) if (ConverterSet < 0) ConverterSet = 2400; else ConverterSet = 0; + if (ConverterSet >= 200) { + Wire.beginTransmission(0x12); + Wire.write(ConverterSet >> 8); + Wire.write(ConverterSet & (0xFF)); + Wire.endTransmission(); + } + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(ConverterSet, DEC), 165, 110, 4); + break; + + case 70: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 165, 110, 4); + LowEdgeSet --; + if (LowEdgeSet < 65) LowEdgeSet = 107; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 90: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 165, 110, 4); + HighEdgeSet --; + if (HighEdgeSet < 66) HighEdgeSet = 108; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 165, 110, 4); + break; + + case 110: + tft.setTextColor(TFT_BLACK); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 165, 110, 4); else tft.drawRightString(String(LevelOffset, DEC), 165, 110, 4); + LevelOffset--; + if (LevelOffset < -25) LevelOffset = 15; + tft.setTextColor(TFT_YELLOW); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 165, 110, 4); else tft.drawRightString(String(LevelOffset, DEC), 165, 110, 4); radio.setOffset(LevelOffset); + change2 = true; + break; + + case 130: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(StereoLevel, DEC), 165, 110, 4); + StereoLevel --; + if (StereoLevel < 30) if (StereoLevel < 0) StereoLevel = 60; else StereoLevel = 0; + tft.setTextColor(TFT_BLACK); + tft.drawRightString("Off", 165, 110, 4); + tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_WHITE); + if (StereoLevel != 0) { + tft.drawString("dBuV", 170, 110, 4); + } + tft.setTextColor(TFT_YELLOW); + if (StereoLevel != 0) tft.drawRightString(String(StereoLevel, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + radio.setStereoLevel(StereoLevel); + break; + + case 150: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighCutLevel * 100, DEC), 165, 110, 4); + HighCutLevel --; + if (HighCutLevel < 15) HighCutLevel = 70; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(HighCutLevel * 100, DEC), 165, 110, 4); + radio.setHighCutLevel(HighCutLevel); + break; + + case 170: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(HighCutOffset, DEC), 165, 110, 4); + HighCutOffset --; + if (HighCutOffset < 20) if (HighCutOffset < 0) HighCutOffset = 60; else HighCutOffset = 0; + tft.setTextColor(TFT_BLACK); + tft.drawRightString("Off", 165, 110, 4); + tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_WHITE); + if (HighCutOffset != 0) tft.drawString("dBuV", 170, 110, 4); + tft.setTextColor(TFT_YELLOW); + if (HighCutOffset != 0) tft.drawRightString(String(HighCutOffset, DEC), 165, 110, 4); else tft.drawRightString("Off", 165, 110, 4); + radio.setHighCutOffset(HighCutOffset); + break; + + case 190: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(LowLevelSet, DEC), 145, 110, 4); + LowLevelSet--; + if (LowLevelSet > 40) LowLevelSet = 40; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(LowLevelSet, DEC), 145, 110, 4); + break; + + + case 210: + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(ContrastSet, DEC), 165, 110, 4); + ContrastSet --; + if (ContrastSet < 1) ContrastSet = 100; + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String(ContrastSet, DEC), 165, 110, 4); + analogWrite(CONTRASTPIN, ContrastSet * 2 + 27); + break; + } + } + } +} + + + +void readRds() { + if (band == 0) { + RDSstatus = radio.readRDS(); + ShowRDSLogo(RDSstatus); + + if (RDSstatus == 0) { + tft.setTextColor(TFT_SKYBLUE); + tft.drawString(PIold, 244, 192, 4); + tft.drawString(PSold, 38, 192, 4); + tft.drawString(PTYold, 38, 168, 2); + tft.setTextColor(TFT_BLACK); + tft.drawString(RTold, 6, 222, 2); + dropout = true; + } else { + if (dropout == true && PIold.length() != 0) { + tft.setTextColor(TFT_YELLOW); + tft.drawString(PIold, 244, 192, 4); + tft.drawString(PSold, 38, 192, 4); + tft.drawString(PTYold, 38, 168, 2); + dropout = false; + } + } + + if (RDSstatus == 1 && USBstatus == true) { + Serial.print ("P"); + Serial.print (String(((radio.rds.rdsA >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsA >> 8) & 0xF, HEX)); + Serial.print (String(((radio.rds.rdsA) >> 4) & 0xF, HEX) + String((radio.rds.rdsA) & 0xF, HEX)); + Serial.print ("\n"); + + XDRGTKRDS = "R"; + XDRGTKRDS += String(((radio.rds.rdsB >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsB >> 8) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.rdsB) >> 4) & 0xF, HEX) + String((radio.rds.rdsB) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.rdsC >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsC >> 8) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.rdsC) >> 4) & 0xF, HEX) + String((radio.rds.rdsC) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.rdsD >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsD >> 8) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.rdsD) >> 4) & 0xF, HEX) + String((radio.rds.rdsD) & 0xF, HEX); + XDRGTKRDS += String(((radio.rds.errors >> 8) >> 4) & 0xF, HEX) + String((radio.rds.errors >> 8) & 0xF, HEX); + XDRGTKRDS += "\n"; + + if (XDRGTKRDS != XDRGTKRDSold) { + Serial.print(XDRGTKRDS); + XDRGTKRDSold = XDRGTKRDS; + } + } + } +} + +void showPI() { + if (strcmp(radio.rds.picode, radioIdPrevious)) { + tft.setTextColor(TFT_BLACK); + tft.drawString(PIold, 244, 192, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawString(radio.rds.picode, 244, 192, 4); + PIold = radio.rds.picode; + strcpy(radioIdPrevious, radio.rds.picode); + } +} + +void showPTY() { + if (strcmp(radio.rds.stationType, programTypePrevious)) { + tft.setTextColor(TFT_BLACK); + tft.drawString(PTYold, 38, 168, 2); + tft.setTextColor(TFT_YELLOW); + tft.drawString(radio.rds.stationType, 38, 168, 2); + PTYold = radio.rds.stationType; + strcpy(programTypePrevious, radio.rds.stationType); + } +} + +void showPS() { + if (strcmp(radio.rds.stationName, programServicePrevious)) { + tft.setTextColor(TFT_BLACK); + tft.drawString(PSold, 38, 192, 4); + tft.setTextColor(TFT_YELLOW); + tft.drawString(radio.rds.stationName, 38, 192, 4); + PSold = radio.rds.stationName; + strcpy(programServicePrevious, radio.rds.stationName); + } +} + +void showRadioText() { + if (RDSstatus == 1) { + if (millis() - rtticker >= 350) { + xPos -= charWidth; + if (xPos < -tft.textWidth(radio.rds.stationText) + (charWidth * 42)) xPos = 6; + sprite.fillSprite(TFT_BLACK); + sprite.setTextColor(TFT_YELLOW); + sprite.drawString(radio.rds.stationText, xPos, yPos, 2); + sprite.pushSprite(6, 220); + rtticker = millis(); + RTold = radio.rds.stationText; + strcpy(radioTextPrevious, radio.rds.stationText); + cleanup = true; + } + } else if (cleanup == true) { + sprite.fillSprite(TFT_BLACK); + sprite.pushSprite(6, 220); + cleanup = false; + } +} + +void showCT() { + if (radio.rds.hasCT == true) { + int timeoffset; + if (radio.rds.offsetplusmin == true) timeoffset = (-1 * radio.rds.offset) / 2; else timeoffset = radio.rds.offset / 2; + byte rdshour = radio.rds.hours + timeoffset; + rdshour = (((int)rdshour + 24) % 24); + setTime((radio.rds.hours + timeoffset), radio.rds.minutes, 0, 0, 0, 0); + rds_clock = ((hour() < 10 ? "0" : "") + String(hour()) + ":" + (minute() < 10 ? "0" : "") + String(minute())); + } else { + rds_clock = ""; + } + if (rds_clock != rds_clockold) { + tft.setTextColor(TFT_BLACK); + tft.drawRightString(rds_clockold, 205, 168, 2); + tft.setTextColor(TFT_YELLOW); + tft.drawRightString(rds_clock, 205, 168, 2); + rds_clockold = rds_clock; + } +} + +void BuildMenu() { + tft.fillScreen(TFT_BLACK); + tft.drawRect(0, 0, 320, 240, TFT_BLUE); + tft.drawLine(0, 23, 320, 23, TFT_BLUE); + tft.setTextColor(TFT_SKYBLUE); + tft.drawString("PRESS MODE TO EXIT AND STORE", 20, 4, 2); + tft.setTextColor(TFT_WHITE); + tft.drawRightString(VERSION, 305, 4, 2); + tft.drawRoundRect(10, menuoption, 300, 18, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawRightString("dB", 305, 30, 2); + tft.drawRightString("MHz", 305, 50, 2); + tft.drawRightString("MHz", 305, 70, 2); + tft.drawRightString("MHz", 305, 90, 2); + tft.drawRightString("dB", 305, 110, 2); + if (StereoLevel != 0) tft.drawRightString("dBuV", 305, 130, 2); + if (HighCutLevel != 0) tft.drawRightString("Hz", 305, 150, 2); + if (HighCutOffset != 0) tft.drawRightString("dBuV", 305, 170, 2); + tft.drawRightString("dBuV", 305, 190, 2); + tft.drawRightString("%", 305, 210, 2); + tft.drawString("Set volume", 20, 30, 2); + tft.drawString("Set converter offset", 20, 50, 2); + tft.drawString("Set low bandedge", 20, 70, 2); + tft.drawString("Set high bandedge", 20, 90, 2); + tft.drawString("Set level offset", 20, 110, 2); + tft.drawString("Set Stereo sep. threshold", 20, 130, 2); + tft.drawString("Set high cut corner frequency", 20, 150, 2); + tft.drawString("Set High cut threshold", 20, 170, 2); + tft.drawString("Set low level threshold", 20, 190, 2); + tft.drawString("Set Display brightness", 20, 210, 2); + tft.setTextColor(TFT_YELLOW); + if (VolSet > 0) tft.drawRightString("+" + String(VolSet, DEC), 270, 30, 2); else tft.drawRightString(String(VolSet, DEC), 270, 30, 2); + tft.drawRightString(String(ConverterSet, DEC), 270, 50, 2); + tft.drawRightString(String(LowEdgeSet + ConverterSet, DEC), 270, 70, 2); + tft.drawRightString(String(HighEdgeSet + ConverterSet, DEC), 270, 90, 2); + if (LevelOffset > 0) tft.drawRightString("+" + String(LevelOffset, DEC), 270, 110, 2); else tft.drawRightString(String(LevelOffset, DEC), 270, 110, 2); + if (StereoLevel != 0) tft.drawRightString(String(StereoLevel, DEC), 270, 130, 2); else tft.drawRightString("Off", 270, 130, 2); + if (HighCutLevel != 0) tft.drawRightString(String(HighCutLevel * 100, DEC), 270, 150, 2); else tft.drawRightString("Off", 270, 150, 2); + if (HighCutOffset != 0) tft.drawRightString(String(HighCutOffset, DEC), 270, 170, 2); else tft.drawRightString("Off", 270, 170, 2); + tft.drawRightString(String(LowLevelSet, DEC), 270, 190, 2); + tft.drawRightString(String(ContrastSet, DEC), 270, 210, 2); + analogWrite(SMETERPIN, 0); +} + +void MuteScreen(int setting) { + if (setting == 0) { + screenmute = 0; + setupmode = true; + BuildDisplay(); + setupmode = false; + } else { + screenmute = 1; + tft.fillScreen(TFT_BLACK); + tft.drawRect(0, 0, 320, 240, TFT_BLUE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("Screen is muted!", 160, 30, 4); + tft.drawCentreString("To unmute uncheck RF+ box", 160, 60, 2); + } +} + +void BuildDisplay() { + tft.fillScreen(TFT_BLACK); + tft.drawRect(0, 0, 320, 240, TFT_BLUE); + tft.drawLine(0, 30, 320, 30, TFT_BLUE); + tft.drawLine(0, 100, 320, 100, TFT_BLUE); + tft.drawLine(64, 30, 64, 0, TFT_BLUE); + tft.drawLine(210, 100, 210, 218, TFT_BLUE); + tft.drawLine(268, 30, 268, 0, TFT_BLUE); + tft.drawLine(0, 165, 210, 165, TFT_BLUE); + tft.drawLine(0, 187, 320, 187, TFT_BLUE); + tft.drawLine(0, 218, 320, 218, TFT_BLUE); + tft.drawLine(108, 30, 108, 0, TFT_BLUE); + tft.drawLine(174, 30, 174, 0, TFT_BLUE); + tft.drawLine(20, 120, 200, 120, TFT_DARKGREY); + tft.drawLine(20, 150, 200, 150, TFT_DARKGREY); + for (uint16_t segments = 0; segments < 94; segments++) { + if (segments > 54) { + if (((segments - 53) % 10) == 0) + tft.fillRect(16 + (2 * segments), 117, 2, 3, TFT_RED); + } else { + if (((segments + 1) % 6) == 0) + tft.fillRect(16 + (2 * segments), 117, 2, 3, TFT_GREEN); + } + } + tft.setTextColor(TFT_WHITE); + tft.drawString("SQ:", 216, 155, 2); + tft.drawString("S/N", 250, 168, 2); + tft.drawString("dB", 300, 168, 2); + tft.drawString("S", 6, 106, 2); + tft.drawString("M", 6, 136, 2); + tft.drawString("PI:", 216, 195, 2); + tft.drawString("PS:", 6, 195, 2); + tft.drawString("PTY:", 6, 168, 2); + tft.drawString("%", 196, 153, 1); + tft.drawString("1", 24, 123, 1); + tft.drawString("3", 48, 123, 1); + tft.drawString("5", 72, 123, 1); + tft.drawString("7", 96, 123, 1); + tft.drawString("9", 120, 123, 1); + tft.drawString("+10", 134, 123, 1); + tft.drawString("+30", 174, 123, 1); + tft.drawString("20", 20, 153, 1); + tft.drawString("40", 50, 153, 1); + tft.drawString("60", 80, 153, 1); + tft.drawString("80", 110, 153, 1); + tft.drawString("100", 134, 153, 1); + tft.drawString("120", 164, 153, 1); + tft.setTextColor(TFT_WHITE); + tft.drawString("kHz", 225, 6, 4); + tft.setTextColor(TFT_WHITE); + if (band == 0) tft.drawString("MHz", 256, 78, 4); else tft.drawString("kHz", 256, 78, 4); + tft.setTextColor(TFT_WHITE); + tft.drawString("dBuV", 280, 155, 2); + tft.drawPixel(295, 166, TFT_WHITE); + tft.drawPixel(295, 167, TFT_WHITE); + tft.drawPixel(295, 168, TFT_WHITE); + tft.drawPixel(295, 169, TFT_WHITE); + tft.drawPixel(295, 170, TFT_WHITE); + RDSstatusold = false; + Stereostatusold = false; + ShowFreq(0); + updateTuneMode(); + updateBW(); + ShowUSBstatus(); + ShowStepSize(); + updateiMS(); + updateEQ(); + Squelchold = -2; + SStatusold = 2000; + SStatus = 100; + rds_clockold = ""; + strcpy(programTypePrevious, ""); + strcpy(radioIdPrevious, ""); + strcpy(programServicePrevious, ""); + strcpy(radioTextPrevious, ""); + tft.drawCircle(81, 15, 10, TFT_GREYOUT); + tft.drawCircle(81, 15, 9, TFT_GREYOUT); + tft.drawCircle(91, 15, 10, TFT_GREYOUT); + tft.drawCircle(91, 15, 9, TFT_GREYOUT); + tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT); + if (StereoToggle == false) { + tft.drawCircle(86, 15, 10, TFT_SKYBLUE); + tft.drawCircle(86, 15, 9, TFT_SKYBLUE); + } + tft.setTextColor(TFT_SKYBLUE); + if (band == 1) tft.drawString("AM", 50, 30, 2); else tft.drawString("FM", 50, 30, 2); +} + +void ShowFreq(int mode) { + if (setupmode == false) { + if (band == 1) { + if (freqold < 2000 && radio.getFrequency_AM() >= 2000 && stepsize == 0) if (radio.getFrequency_AM() != 27000 && freqold != 144) radio.setFrequency_AM(2000); + if (freqold >= 2000 && radio.getFrequency_AM() < 2000 && stepsize == 0) if (radio.getFrequency_AM() != 144 && freqold != 27000) radio.setFrequency_AM(1998); + } + } + + if (screenmute == false) { + detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A)); + detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B)); + if (band == 1) { + unsigned int freq = radio.getFrequency_AM(); + String count = String(freq, DEC); + if (count.length() != freqoldcount || mode != 0) { + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String(freqold), 248, 45, 7); + } + tft.setTextColor(TFT_YELLOW, TFT_BLACK); + tft.drawRightString(String(freq), 248, 45, 7); + freqold = freq; + freqoldcount = count.length(); + } else { + unsigned int freq = radio.getFrequency() + ConverterSet * 100; + String count = String(freq / 100, DEC); + if (count.length() != freqoldcount || mode != 0) { + tft.setTextColor(TFT_BLACK); + if (freqoldcount <= 2) tft.setCursor (108, 45); + if (freqoldcount == 3) tft.setCursor (76, 45); + if (freqoldcount >= 4) tft.setCursor (44, 45); + tft.setTextFont(7); + tft.print(freqold / 100); + tft.print("."); + if (freqold % 100 < 10) tft.print("0"); + tft.print(freqold % 100); + } + + tft.setTextColor(TFT_YELLOW, TFT_BLACK); + if (mode == 0) { + if (count.length() <= 2) tft.setCursor (108, 45); + if (count.length() == 3) tft.setCursor (76, 45); + if (count.length() >= 4) tft.setCursor (44, 45); + tft.setTextFont(7); + tft.print(freq / 100); + tft.print("."); + if (freq % 100 < 10) tft.print("0"); + tft.print(freq % 100); + freqold = freq; + freqoldcount = count.length(); + } else if (mode == 1) { + tft.setTextColor(TFT_BLACK); + if (freqoldcount <= 2) tft.setCursor (98, 45); + if (freqoldcount == 3) tft.setCursor (71, 45); + if (freqoldcount == 4) tft.setCursor (44, 45); + tft.setTextFont(1); + tft.print(freqold / 100); + tft.print("."); + if (freqold % 100 < 10) tft.print("0"); + tft.print(freqold % 100); + } + } + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A), read_encoder, CHANGE); + attachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B), read_encoder, CHANGE); + } +} + +void ShowSignalLevel() { + if (band == 0) SNR = int(0.46222375 * (float)(SStatus / 10) - 0.082495118 * (float)(USN / 10)) + 10; else SNR = -((int8_t)(USN / 10)); + + if (SNR > (SNRold + 1) || SNR < (SNRold - 1)) { + tft.setTextFont(2); + tft.setCursor (280, 168); + tft.setTextColor(TFT_BLACK); + if (SNRold == 99) tft.print("--"); else tft.print(SNRold); + tft.setCursor (280, 168); + tft.setTextColor(TFT_YELLOW, TFT_BLACK); + if (tuned == true) { + tft.print(SNR); + SNRold = SNR; + } else { + tft.print("--"); + SNRold = 99; + } + } + + SAvg = (((SAvg * 9) + 5) / 10) + SStatus; + SAvg2 = (((SAvg2 * 9) + 5) / 10) + SNR; + + float sval = 0; + int16_t smeter = 0; + int16_t segments; + + if (SStatus > 0) + { + if (SStatus < 1000) + { + sval = 51 * ((pow(10, (((float)SStatus) / 1000))) - 1); + smeter = int16_t(sval); + } else { + smeter = 511; + } + } + + smeter = int16_t(sval); + SStatus = SAvg / 10; + SNR = SAvg2 / 10; + + if (menu == false) analogWrite(SMETERPIN, smeter); + + if (SStatus > (SStatusold + 3) || SStatus < (SStatusold - 3)) + { + if (SStatus > 1200) SStatus = 1200; + if (SStatus < -400) SStatus = -400; + String count = String(abs(SStatus / 10), DEC); + tft.setTextColor(1, TFT_BLACK); + tft.setCursor (213, 110); + tft.setTextFont(6); + if (SStatus >= 0) { + if (count.length() == 1) tft.print("00"); + if (count.length() == 2) tft.print("0"); + } else { + if (count.length() == 1) tft.print("0 "); + if (count.length() == 2) tft.print(" "); + } + tft.setTextColor(TFT_YELLOW, TFT_BLACK); //DSP + if (SStatus < 0) tft.print("-"); + tft.print(abs(SStatus / 10)); + tft.setCursor (294, 110); + tft.setTextFont(4); + tft.print("."); + if (SStatus < 0) + { + String negative = String (SStatus % 10, DEC); + if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]); + } else { + tft.print(SStatus % 10); + } + + if (band == 0) segments = (SStatus + 200) / 10; else segments = (SStatus + 200) / 10; + + tft.fillRect(16, 109, 2 * constrain(segments, 0, 54), 8, TFT_GREEN); + tft.fillRect(16 + 2 * 54, 109, 2 * (constrain(segments, 54, 94) - 54), 8, TFT_RED); + tft.fillRect(16 + 2 * constrain(segments, 0, 94), 109, 2 * (94 - constrain(segments, 0, 94)), 8, TFT_GREYOUT); + + SStatusold = SStatus; + SStatusoldcount = count.length(); + } +} + +void ShowRDSLogo(bool RDSstatus) { + if (screenmute == false) { + if (RDSstatus != RDSstatusold) + { + if (RDSstatus == true) tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_SKYBLUE); else tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT); + RDSstatusold = RDSstatus; + } + } +} + +void ShowStereoStatus() { + if (StereoToggle == true) + { + if (band == 0) Stereostatus = radio.getStereoStatus(); else Stereostatus = 0; + if (Stereostatus != Stereostatusold) + { + if (Stereostatus == true && screenmute == false) + { + tft.drawCircle(81, 15, 10, TFT_RED); + tft.drawCircle(81, 15, 9, TFT_RED); + tft.drawCircle(91, 15, 10, TFT_RED); + tft.drawCircle(91, 15, 9, TFT_RED); + } else { + if (screenmute == false) { + tft.drawCircle(81, 15, 10, TFT_GREYOUT); + tft.drawCircle(81, 15, 9, TFT_GREYOUT); + tft.drawCircle(91, 15, 10, TFT_GREYOUT); + tft.drawCircle(91, 15, 9, TFT_GREYOUT); + } + } + Stereostatusold = Stereostatus; + } + } +} + +void ShowOffset() { + if (OStatus != OStatusold) { + if (band == 0) { + if (OStatus < -500) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_RED); + tuned = false; + } else if (OStatus < -250 && OStatus > -500) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_RED); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else if (USN < 250 && WAM < 250 && OStatus > -250 && OStatus < 250 && SQ == false) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREEN); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = true; + } else if (OStatus > 250 && OStatus < 500) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_RED); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else if (OStatus > 500) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_RED); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } + } else { + if (OStatus <= -3) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_RED); + tuned = false; + } else if (OStatus < -2 && OStatus > -3) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_RED); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else if (OStatus > -2 && OStatus < 2 && SQ == false) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREEN); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = true; + } else if (OStatus > 2 && OStatus < 3) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_RED); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else if (OStatus >= 3) { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_RED); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } else { + tft.fillTriangle(6, 8, 6, 22, 14, 14, TFT_GREYOUT); + tft.fillTriangle(18, 8, 18, 22, 26, 14, TFT_GREYOUT); + tft.fillCircle(32, 15, 3, TFT_GREYOUT); + tft.fillTriangle(38, 14, 46, 8, 46, 22, TFT_GREYOUT); + tft.fillTriangle(50, 14, 58, 8, 58, 22, TFT_GREYOUT); + tuned = false; + } + } + OStatusold = OStatus; + } +} + +void ShowBW() { + if (BW != BWOld || BWreset == true) { + tft.setTextColor(TFT_BLACK); + tft.drawRightString(String (BWOld, DEC), 218, 6, 4); + if (BWset == 0) tft.setTextColor(TFT_SKYBLUE); else tft.setTextColor(TFT_YELLOW); + tft.drawRightString(String (BW, DEC), 218, 6, 4); + BWOld = BW; + BWreset = false; + } +} + +void ShowModLevel() { + int segments; + int color; + int hold = 0; + + if (SQ != false) { + MStatus = 0; + MStatusold = 1; + } + + if (MStatus != MStatusold || MStatus < 10) { + for (segments = 0; segments < 13; segments++) { + color = TFT_GREEN; + if (segments > 8) color = TFT_ORANGE; + if (segments > 9) color = TFT_RED; + if (MStatus > (segments + 1) * 10) + { + hold = segments; + tft.fillRect(20 + segments * 14, 139, 12, 8, color); + } else { + if (segments != peakholdold) tft.fillRect(20 + segments * 14, 139, 12, 8, TFT_GREYOUT); + } + } + + if (peakholdold < hold) peakholdold = hold; + + if (peakholdmillis > peakholdtimer + 3000) { + peakholdtimer += 3000; + peakholdold = hold; + } + peakholdmillis = millis(); + MStatusold = MStatus; + } +} + +void doSquelch() { + if (USBstatus == false) { + Squelch = analogRead(PIN_POT) / 4 - 100; + if (Squelch > 920) Squelch = 920; + + if (seek == false && menu == false && Squelch != Squelchold) { + tft.setTextFont(2); + tft.setTextColor(TFT_BLACK); + tft.setCursor (216, 168); + if (Squelchold == -100) { + tft.print("OFF"); + } else if (Squelchold == 920) { + tft.print("ST"); + } else { + tft.print(Squelchold / 10); + } + tft.setTextColor(TFT_WHITE); + tft.setCursor (216, 168); + if (Squelch == -100) { + tft.print("OFF"); + } else if (Squelch == 920) { + tft.print("ST"); + } else { + tft.print(Squelch / 10); + } + Squelchold = Squelch; + } + } + if (seek == false && USBstatus == true) { + if (XDRMute == false) { + if (Squelch != -1) { + if (Squelch < SStatus || Squelch == -100) { + radio.setUnMute(); + SQ = false; + } else { + radio.setMute(); + SQ = true; + } + } else { + if (Stereostatus == true) { + radio.setUnMute(); + SQ = false; + } else { + radio.setMute(); + SQ = true; + } + } + if (screenmute == false) { + if (Squelch != Squelchold) { + tft.setTextFont(2); + tft.setTextColor(TFT_BLACK); + tft.setCursor (216, 168); + if (Squelchold == -1) tft.print("ST"); else tft.print(Squelchold / 10); + tft.setTextColor(TFT_WHITE); + tft.setCursor (216, 168); + if (Squelch == -1) tft.print("ST"); else tft.print(Squelch / 10); + Squelchold = Squelch; + } + } + } + } else { + if (seek == false && Squelch != 920) { + if (Squelch < SStatus || Squelch == -100) { + radio.setUnMute(); + SQ = false; + } else { + radio.setMute(); + SQ = true; + } + } else { + if (seek == false && Stereostatus == true) { + radio.setUnMute(); + SQ = false; + } else { + radio.setMute(); + SQ = true; + } + } + } + ShowSquelch(); +} + +void ShowSquelch() { + if (menu == false) { + if (SQ == false) { + tft.drawRoundRect(3, 79, 40, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("MUTE", 24, 81, 2); + } else { + tft.drawRoundRect(3, 79, 40, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("MUTE", 24, 81, 2); + } + } +} + + +void updateBW() { + if (BWset == 0) { + if (screenmute == false) { + tft.drawRoundRect(249, 35, 68, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("AUTO BW", 283, 37, 2); + } + radio.setFMABandw(); + } else { + if (screenmute == false) { + tft.drawRoundRect(249, 35, 68, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("AUTO BW", 283, 37, 2); + } + } +} + +void updateiMS() { + if (band == 0) { + if (iMSset == 0) { + if (screenmute == false) { + tft.drawRoundRect(249, 56, 30, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("iMS", 265, 58, 2); + } + radio.setiMS(1); + } else { + if (screenmute == false) { + tft.drawRoundRect(249, 56, 30, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("iMS", 265, 58, 2); + } + radio.setiMS(0); + } + } +} + +void updateEQ() { + if (band == 0) { + if (EQset == 0) { + if (screenmute == false) { + tft.drawRoundRect(287, 56, 30, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("EQ", 303, 58, 2); + } + radio.setEQ(1); + } else { + if (screenmute == false) { + tft.drawRoundRect(287, 56, 30, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("EQ", 303, 58, 2); + } + radio.setEQ(0); + } + } +} + +void doBW() { + if (band == 0) { + if (BWset > 16) BWset = 0; + + switch (BWset) { + case 1: + radio.setFMBandw(56); + break; + + case 2: + radio.setFMBandw(64); + break; + + case 3: + radio.setFMBandw(72); + break; + + case 4: + radio.setFMBandw(84); + break; + + case 5: + radio.setFMBandw(97); + break; + + case 6: + radio.setFMBandw(114); + break; + + case 7: + radio.setFMBandw(133); + break; + + case 8: + radio.setFMBandw(151); + break; + + case 9: + radio.setFMBandw(168); + break; + + case 10: + radio.setFMBandw(184); + break; + + case 11: + radio.setFMBandw(200); + break; + + case 12: + radio.setFMBandw(217); + break; + + case 13: + radio.setFMBandw(236); + break; + + case 14: + radio.setFMBandw(254); + break; + + case 15: + radio.setFMBandw(287); + break; + + case 16: + radio.setFMBandw(311); + break; + } + } else { + if (BWset > 4) BWset = 1; + + switch (BWset) { + case 1: + radio.setAMBandw(3); + break; + + case 2: + radio.setAMBandw(4); + break; + + case 3: + radio.setAMBandw(6); + break; + + case 4: + radio.setAMBandw(8); + break; + } + } + updateBW(); + BWreset = true; +} + +void doTuneMode() { + if (band == 0) { + if (tunemode == true) tunemode = false; else tunemode = true; + updateTuneMode(); + if (stepsize != 0) { + stepsize = 0; + RoundStep(); + ShowStepSize(); + ShowFreq(0); + } + } +} + +void updateTuneMode() { + if (tunemode == true) { + tft.drawRoundRect(3, 57, 40, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("AUTO", 24, 59, 2); + + tft.drawRoundRect(3, 35, 40, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("MAN", 24, 37, 2); + } else { + tft.drawRoundRect(3, 57, 40, 20, 5, TFT_GREYOUT); + tft.setTextColor(TFT_GREYOUT); + tft.drawCentreString("AUTO", 24, 59, 2); + + tft.drawRoundRect(3, 35, 40, 20, 5, TFT_WHITE); + tft.setTextColor(TFT_WHITE); + tft.drawCentreString("MAN", 24, 37, 2); + } +} +void ShowUSBstatus() { + if (USBstatus == true) tft.drawBitmap(272, 6, USBLogo, 43, 21, TFT_SKYBLUE); else tft.drawBitmap(272, 6, USBLogo, 43, 21, TFT_GREYOUT); +} + +void XDRGTKRoutine() { + if (Serial.available() > 0) + { + buff[buff_pos] = Serial.read(); + if (buff[buff_pos] != '\n' && buff_pos != 16 - 1) { + buff_pos++; + } else { + buff[buff_pos] = 0; + buff_pos = 0; + + switch (buff[0]) + { + case 'x': + Serial.println("OK"); + if (band != 0) { + band = 0; + SelectBand(); + } + Serial.print("T" + String(frequency * 10) + "A0\nD0\nG00\n"); + USBstatus = true; + ShowUSBstatus(); + if (menu == true) ModeButtonPress(); + if (Squelch != Squelchold) { + if (screenmute == false) { + tft.setTextFont(2); + tft.setTextColor(TFT_BLACK); + tft.setCursor (240, 168); + if (Squelchold == -100) tft.print("OFF"); else if (Squelchold > 920) tft.print("ST"); else tft.print(Squelchold / 10); + } + } + break; + + case 'A': + AGC = atol(buff + 1); + Serial.print("A" + String(AGC) + "\n"); + radio.setAGC(AGC); + break; + + case 'C': + byte scanmethod; + scanmethod = atol(buff + 1); + if (seek == false) { + if (scanmethod == 1) { + Serial.print("C1\n"); + direction = true; + seek = true; + Seek(direction); + } + if (scanmethod == 2) { + Serial.print("C2\n"); + direction = false; + seek = true; + Seek(direction); + } + } else { + seek = false; + } + Serial.print("C0\n"); + break; + + case 'N': + doStereoToggle(); + break; + + case 'D': + DeEmphasis = atol(buff + 1); + Serial.print("D" + String(DeEmphasis) + "\n"); + radio.setDeemphasis(DeEmphasis); + break; + + case 'F': + XDRBWset = atol(buff + 1); + if (XDRBWset < 16) { + XDRBWsetold = XDRBWset; + BWset = XDRBWset + 1; + } else { + XDRBWset = XDRBWsetold; + } + doBW(); + Serial.print("F" + String(XDRBWset) + "\n"); + break; + + case 'G': + LevelOffset = atol(buff + 1); + if (LevelOffset == 0) { + MuteScreen(0); + LowLevelSet = EEPROM.readByte(43); + EEPROM.commit(); + Serial.print("G00\n"); + } + if (LevelOffset == 10) { + MuteScreen(1); + LowLevelSet = EEPROM.readByte(43); + EEPROM.commit(); + Serial.print("G10\n"); + } + if (LevelOffset == 1) { + MuteScreen(0); + LowLevelSet = 120; + Serial.print("G01\n"); + } + if (LevelOffset == 11) { + LowLevelSet = 120; + MuteScreen(1); + Serial.print("G11\n"); + } + break; + + case 'M': + byte XDRband; + XDRband = atol(buff + 1); + if (XDRband == 0) { + band = 0; + SelectBand(); + Serial.print("M0\nT" + String(frequency * 10) + "\n"); + } else { + band = 1; + SelectBand(); + Serial.print("M1\nT" + String(frequency_AM) + "\n"); + } + break; + + case 'T': + unsigned int freqtemp; + freqtemp = atoi(buff + 1); + if (seek == true) seek = false; + if (freqtemp > 143 && freqtemp < 27001) { + frequency_AM = freqtemp; + if (band != 1) { + band = 1; + SelectBand(); + } else { + radio.setFrequency_AM(frequency_AM); + } + Serial.print("M1\n"); + } else if (freqtemp > 64999 && freqtemp < 108001) { + frequency = freqtemp / 10; + if (band != 0) { + band = 0; + SelectBand(); + Serial.print("M0\n"); + } else { + radio.setFrequency(frequency, 65, 108, fullsearchrds); + } + } + if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n"); + radio.clearRDS(fullsearchrds); + RDSstatus = 0; + ShowFreq(0); + break; + + case 'S': + if (buff[1] == 'a') + { + scanner_start = (atol(buff + 2) + 5) / 10; + } else if (buff[1] == 'b') + { + scanner_end = (atol(buff + 2) + 5) / 10; + } else if (buff[1] == 'c') + { + scanner_step = (atol(buff + 2) + 5) / 10; + } else if (buff[1] == 'f') + { + scanner_filter = atol(buff + 2); + } else if (scanner_start > 0 && scanner_end > 0 && scanner_step > 0 && scanner_filter >= 0) + { + frequencyold = radio.getFrequency(); + radio.setFrequency(scanner_start, 65, 108, fullsearchrds); + Serial.print('U'); + if (scanner_filter < 0) { + BWset = 0; + } else if (scanner_filter == 0) { + BWset = 1; + } else if (scanner_filter == 26) { + BWset = 2; + } else if (scanner_filter == 1) { + BWset = 3; + } else if (scanner_filter == 28) { + BWset = 4; + } else if (scanner_filter == 29) { + BWset = 5; + } else if (scanner_filter == 3) { + BWset = 6; + } else if (scanner_filter == 4) { + BWset = 7; + } else if (scanner_filter == 5) { + BWset = 8; + } else if (scanner_filter == 7) { + BWset = 9; + } else if (scanner_filter == 8) { + BWset = 10; + } else if (scanner_filter == 9) { + BWset = 11; + } else if (scanner_filter == 10) { + BWset = 12; + } else if (scanner_filter == 11) { + BWset = 13; + } else if (scanner_filter == 12) { + BWset = 14; + } else if (scanner_filter == 13) { + BWset = 15; + } else if (scanner_filter == 15) { + BWset = 16; + } + doBW(); + if (screenmute == false) { + ShowFreq(1); + tft.setTextFont(4); + tft.setTextColor(TFT_WHITE, TFT_BLACK); + tft.setCursor (90, 60); + tft.print("SCANNING..."); + } + frequencyold = frequency / 10; + for (freq_scan = scanner_start; freq_scan <= scanner_end; freq_scan += scanner_step) + { + radio.setFrequency(freq_scan, 65, 108, fullsearchrds); + Serial.print(freq_scan * 10, DEC); + Serial.print('='); + delay(10); + if (band == 0) { + radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); + } else { + radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus); + } + Serial.print((SStatus / 10) + 10, DEC); + Serial.print(','); + } + Serial.print('\n'); + if (screenmute == false) { + tft.setTextFont(4); + tft.setTextColor(TFT_BLACK); + tft.setCursor (90, 60); + tft.print("SCANNING..."); + } + radio.setFrequency(frequencyold, 65, 108, fullsearchrds); + if (screenmute == false) ShowFreq(0); + radio.setFMABandw(); + } + break; + + case 'Y': + VolSet = atoi(buff + 1); + if (VolSet == 0) { + radio.setMute(); + XDRMute = true; + SQ = true; + } else { + radio.setVolume((VolSet - 70) / 10); + XDRMute = false; + } + Serial.print("Y" + String(VolSet) + "\n"); + break; + + case 'X': + Serial.print("X\n"); + ESP.restart(); + break; + + case 'Z': + byte iMSEQX; + iMSEQX = atol(buff + 1); + if (iMSEQX == 0) { + iMSset = 1; + EQset = 1; + iMSEQ = 2; + } + if (iMSEQX == 1) { + iMSset = 0; + EQset = 1; + iMSEQ = 3; + } + if (iMSEQX == 2) { + iMSset = 1; + EQset = 0; + iMSEQ = 4; + } + if (iMSEQX == 3) { + iMSset = 0; + EQset = 0; + iMSEQ = 1; + } + updateiMS(); + updateEQ(); + Serial.print("Z" + String(iMSEQX) + "\n"); + break; + } + } + } + + if (USBstatus == true) { + Stereostatus = radio.getStereoStatus(); + if (StereoToggle == false) { + Serial.print("SS"); + } else if (Stereostatus == true && band == 0) { + Serial.print("Ss"); + } else { + Serial.print("Sm"); + } + if (SStatus > (SStatusold + 10) || SStatus < (SStatusold - 10)) { + Serial.print(String(((SStatus * 100) + 10875) / 1000) + "." + String(((SStatus * 100) + 10875) / 100 % 10)); + } else { + Serial.print(String(((SStatusold * 100) + 10875) / 1000) + "." + String(((SStatus * 100) + 10875) / 100 % 10)); + } + Serial.print("," + String(WAM / 10, DEC) + "," + String(SNR, DEC) + "\n"); + } +} + +void Seek(bool mode) { + if (band == 0) { + radio.setMute(); + if (mode == false) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); + delay(50); + ShowFreq(0); + if (USBstatus == true) if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n"); + radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); + + if ((USN < 200) && (WAM < 230) && (OStatus < 80 && OStatus > -80) && (Squelch < SStatus || Squelch == 920)) { + seek = false; + radio.setUnMute(); + store = true; + } else { + seek = true; + } + } +} + +void SetTunerPatch() { + if (TEF != 101 && TEF != 102 && TEF != 205) { + radio.init(102); + uint16_t device; + uint16_t hw; + uint16_t sw; + radio.getIdentification(device, hw, sw); + TEF = highByte(hw) * 100 + highByte(sw); + tft.fillScreen(TFT_BLACK); + tft.setTextColor(TFT_WHITE); + analogWrite(CONTRASTPIN, ContrastSet * 2 + 27); + if (TEF == 0) tft.drawCentreString("Tuner not detected", 150, 70, 4); else tft.drawCentreString(String("Tuner version set: v") + String(TEF), 150, 70, 4); + tft.drawCentreString("Please restart tuner", 150, 100, 4); + EEPROM.writeByte(54, TEF); + EEPROM.commit(); + while (true); + for (;;); + } +} + +void read_encoder() { + static uint8_t old_AB = 3; + static int8_t encval = 0; + static const int8_t enc_states[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0}; + + old_AB <<= 2; + + if (digitalRead(ROTARY_PIN_A)) old_AB |= 0x02; + if (digitalRead(ROTARY_PIN_B)) old_AB |= 0x01; + encval += enc_states[( old_AB & 0x0f )]; + + if (optenc == 1) { + if (encval > 2) { + if (rotarymode == true) rotary = -1; else rotary = 1; + encval = 0; + } else if (encval < -2) { + if (rotarymode == true) rotary = 1; else rotary = -1; + encval = 0; + } + } else { + if (encval > 3) { + if (rotarymode == true) rotary = -1; else rotary = 1; + encval = 0; + } else if (encval < -3) { + if (rotarymode == true) rotary = 1; else rotary = -1; + encval = 0; + } + } +} diff --git a/src/TEF6686.cpp b/src/TEF6686.cpp new file mode 100644 index 0000000..e1c6758 --- /dev/null +++ b/src/TEF6686.cpp @@ -0,0 +1,425 @@ +#include "TEF6686.h" + +const char* const PTY[] +{ + "None", + "News", + "Current Affairs", + "Information", + "Sport", + "Education", + "Drama", + "Cultures", + "Science", + "Varied Speech", + "Pop Music", + "Rock Music", + "Easy Listening", + "Light Classics", + "Serious Classics", + "Other Music", + "Weather", + "Finance", + "Children's Progs", + "Social Affair", + "Religion", + "Phone In", + "Travel & Touring", + "Leisure & Hobby", + "Jazz Music", + "Country Music", + "National Music", + "Oldies Music", + "Folk Music", + "Documentary", + "Alarm Test", + "Alarm!!!", + " " +}; + +void TEF6686::init(byte TEF) { + uint8_t bootstatus; + Tuner_I2C_Init(); + getBootStatus(bootstatus); + if (bootstatus == 0) { + Tuner_Patch(TEF); + delay(50); + if (digitalRead(15) == LOW) { + Tuner_Init9216(); + } else { + Tuner_Init4000(); + } + power(1); + Tuner_Init(); + } +} + +void TEF6686::power(uint8_t mode) { + devTEF_APPL_Set_OperationMode(mode); + if (mode == 0) { + devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000); + } +} + +bool TEF6686::getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version) { + bool result = devTEF_Radio_Get_Identification(&device, &hw_version, &sw_version); + return device; + return hw_version; + return sw_version; +} + +void TEF6686::setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) { + Radio_SetFreq(frequency, LowEdge, HighEdge, fullsearchrds); +} + +void TEF6686::setFrequency_AM(uint16_t frequency) { + Radio_SetFreq_AM(frequency); +} + +uint16_t TEF6686::getFrequency() { + return Radio_GetCurrentFreq(); +} + +uint16_t TEF6686::getFrequency_AM() { + return Radio_GetCurrentFreq_AM(); +} + +void TEF6686::setOffset(int16_t offset) { + devTEF_Radio_Set_LevelOffset(offset * 10); +} + +void TEF6686::setFMBandw(uint16_t bandwidth) { + devTEF_Radio_Set_Bandwidth(0, bandwidth * 10, 1000, 1000); +} +void TEF6686::setFMABandw() { + devTEF_Radio_Set_Bandwidth(1, 3110, 1000, 1000); +} + +void TEF6686::setAMBandw(uint16_t bandwidth) { + devTEF_Radio_Set_Bandwidth_AM(0, bandwidth * 10, 1000, 1000); +} + +void TEF6686::setiMS(uint16_t mph) { + devTEF_Radio_Set_MphSuppression(mph); +} + +void TEF6686::setEQ(uint16_t eq) { + devTEF_Radio_Set_ChannelEqualizer(eq); +} + +bool TEF6686::getStereoStatus() { + return Radio_CheckStereo(); +} + +void TEF6686::setMono(uint8_t mono) { + devTEF_Radio_Set_Stereo_Min(mono); +} + +uint16_t TEF6686::tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) { + return tune(1, stepsize, LowEdge, HighEdge, fullsearchrds); +} + +uint16_t TEF6686::tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) { + return tune(0, stepsize, LowEdge, HighEdge, fullsearchrds); +} + +uint16_t TEF6686::tuneUp_AM(uint8_t stepsize) { + return tune_AM(1, stepsize); +} + +uint16_t TEF6686::tuneDown_AM(uint8_t stepsize) { + return tune_AM(0, stepsize); +} + +void TEF6686::setVolume(int16_t volume) { + devTEF_Audio_Set_Volume(volume); +} + +void TEF6686::setMute() { + devTEF_Audio_Set_Mute(1); +} + +void TEF6686::setUnMute() { + devTEF_Audio_Set_Mute(0); +} + +void TEF6686::setAGC(uint8_t start) { + if (start == 0) { + devTEF_Radio_Set_RFAGC(920); + } + if (start == 1) { + devTEF_Radio_Set_RFAGC(900); + } + if (start == 2) { + devTEF_Radio_Set_RFAGC(870); + } + if (start == 3) { + devTEF_Radio_Set_RFAGC(840); + } +} + +void TEF6686::setDeemphasis(uint8_t timeconstant) { + if (timeconstant == 0) { + devTEF_Radio_Set_Deemphasis(500); + } + if (timeconstant == 1) { + devTEF_Radio_Set_Deemphasis(750); + } + if (timeconstant == 2) { + devTEF_Radio_Set_Deemphasis(0); + } +} + +void TEF6686::setStereoLevel(uint16_t start) { + if (start == 0) { + devTEF_Radio_Set_Stereo_Level(0, start * 10, 60); + devTEF_Radio_Set_Stereo_Noise(0, 240, 200); + devTEF_Radio_Set_Stereo_Mph(0, 240, 200); + } else { + devTEF_Radio_Set_Stereo_Level(3, start * 10, 60); + devTEF_Radio_Set_Stereo_Noise(3, 240, 200); + devTEF_Radio_Set_Stereo_Mph(3, 240, 200); + } +} + +void TEF6686::setHighCutOffset(uint16_t start) { + if (start == 0) { + devTEF_Radio_Set_Highcut_Level(0, start * 10, 300); + devTEF_Radio_Set_Highcut_Noise(0, 360, 300); + devTEF_Radio_Set_Highcut_Mph(0, 360, 300); + } else { + devTEF_Radio_Set_Highcut_Level(3, start * 10, 300); + devTEF_Radio_Set_Highcut_Noise(3, 360, 300); + devTEF_Radio_Set_Highcut_Mph(3, 360, 300); + } +} + +void TEF6686::setHighCutLevel(uint16_t limit) { + devTEF_Radio_Set_Highcut_Max(1, limit * 100); +} + +bool TEF6686::getBootStatus(uint8_t &bootstatus) { + uint8_t result = devTEF_APPL_Get_Operation_Status(&bootstatus); + return bootstatus; +} + +bool TEF6686::getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) { + uint8_t result = devTEF_Radio_Get_Quality_Status(&level, &USN, &WAM, &offset, &bandwidth, &modulation); + return level; + return USN; + return WAM; + return bandwidth; + return modulation; +} + +bool TEF6686::getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) { + uint8_t result = devTEF_Radio_Get_Quality_Status_AM(&level, &USN, &WAM, &offset, &bandwidth, &modulation); + return level; + return USN; + return WAM; + return bandwidth; + return modulation; +} + +bool TEF6686::readRDS() +{ + char status; + uint16_t rdsStat = 0, rdsErr = 65535, rdsErrA = 65535, rdsErrB = 65535, rdsErrC = 65535, rdsErrD = 65535; + uint16_t result = devTEF_Radio_Get_RDS_Data(&rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rdsErr); + uint8_t rds_group; + uint8_t offset; + bool rdsErrCheck = false, rdsDataReady = false; + + rdsErrA = ((rdsErr >> 14) & 0x02); + rdsErrB = ((rdsErr >> 12) & 0x02); + rdsErrC = ((rdsErr >> 10) & 0x02); + rdsErrD = ((rdsErr >> 8) & 0x02); + + rdsErrCheck = rdsErr == 0; + rdsDataReady = ((rdsStat & (1 << 15)) && (rdsStat & (1 << 9))); + rds.errors = rdsErr; + if (rdsDataReady && rdsErrCheck) + { + //RDS PI + if (rds.stationID == 0) rds.stationID = rds.rdsA; + char Hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; + rds.picode[0] = Hex[(rds.rdsA & 0xF000U) >> 12]; + rds.picode[1] = Hex[(rds.rdsA & 0x0F00U) >> 8]; + rds.picode[2] = Hex[(rds.rdsA & 0x00F0U) >> 4]; + rds.picode[3] = Hex[(rds.rdsA & 0x000FU)]; + rds.picode[4] = '\0'; + rds_group = (rds.rdsB >> 11); + switch (rds_group) + { + case RDS_GROUP_0A: + case RDS_GROUP_0B: + { + //RDS PS + offset = rds.rdsB & 0x03; + + if ((offset == 0) && (ps_process == 0))ps_process = 1; + + if (ps_process == 1) + { + ps_buffer[(offset * 2) + 0] = ascii_converter(rds.rdsD >> 8); + ps_buffer[(offset * 2) + 1] = ascii_converter(rds.rdsD & 0xFF); + ps_buffer[(offset * 2) + 2] = 0; + ps_process = strlen(ps_buffer) == 8 ? 2 : 1; + } + + if (ps_process == 2) + { + strcpy(rds.stationName, ps_buffer); + for (int i = 0; i < 9; i++) + ps_buffer[i] = '\0'; + ps_process = 0; + } + + //RDS PTY Code + rds.stationTypeCode = (rds.rdsB >> 5) & 0x1F; + strcpy(rds.stationType, PTY[rds.stationTypeCode]); + } break; + + case RDS_GROUP_2A: + case RDS_GROUP_2B: + { + //RDS RT Code + boolean limit_reached = false; + offset = (rds.rdsB & 0xf) * 4; + rds.rtAB = (bitRead(rds.rdsB, 4)); + limit_reached = (offset == 60 || (rds.rdsC >> 8) == '\r' || (rds.rdsC & 0xFF) == '\r' || (rds.rdsD >> 8) == '\r' || (rds.rdsD & 0xFF) == '\r') ? true : false; + rt_process = (rt_process == 0) && (offset == 0) ? 1 : rt_process; + + if (rds.rtAB != ABold) { + offsetold = 0; + for (int i = 0; i < 65; i++) { + rds.stationText[i] = 0; + } + if (rt_timer == 64) { + strcpy(rds.stationText, stationTextBuffer); + } + for (int i = 0; i < 65; i++) { + rt_buffer[i] = 0; + stationTextBuffer[i] = 0; + } + rt_process = 0; + } + ABold = rds.rtAB; + + if ((!limit_reached) && (offset - rds.stationTextOffset > 4) && (rt_process == 1)) + { + rds.stationTextOffset = 0; + rt_process = 0; + } + + if (rt_process == 1) + { + rds.stationTextOffset = offset; + rt_buffer[offset + 0] = ascii_converter(rds.rdsC >> 8); + rt_buffer[offset + 1] = ascii_converter(rds.rdsC & 0xff); + rt_buffer[offset + 2] = ascii_converter(rds.rdsD >> 8); + rt_buffer[offset + 3] = ascii_converter(rds.rdsD & 0xff); + + if (offset > offsetold) { + offsetold = offset; + } + if (offset == offsetold) { + strcpy(stationTextBuffer, rt_buffer); + if (rt_timer < 64) { + strcpy(rds.stationText, stationTextBuffer); + rt_timer++; + } else { + rt_timer = 64; + } + } + } + + rt_process = (rt_process == 1) && (strlen(rt_buffer)) && (limit_reached) ? 2 : rt_process; + if ((rt_process == 2) && (strlen(rt_buffer) != 0)) + { + for (int i = 0; i < 64; i++) + { + rt_buffer[i] = 0; + } + } + } break; + + case RDS_GROUP_4A: + case RDS_GROUP_4B: + { + //RDS CT + rds.hours = ((rds.rdsD >> 12) & 0x0f); + rds.hours += ((rds.rdsC << 4) & 0x0010); + rds.minutes = ((rds.rdsD >> 6) & 0x3f); + rds.offsetplusmin = ((bitRead(rds.rdsD, 5)) & 0x3f); + rds.offset = (rds.rdsD & 0x3f); + rds.hasCT = true; + } break; + } + } + return rdsDataReady; +} + +uint8_t TEF6686::ascii_converter (uint8_t src) +{ + char dest = src; + switch (src) + { + case 0x91: dest = 225; break; //ä + case 0x97: dest = 239; break; //ö + case 0x99: dest = 245; break; //ü + case 0xD1: dest = 225; break; //Ä + case 0xD7: dest = 239; break; //Ö + case 0xD9: dest = 245; break; //Ü + case 0x8D: dest = 226; break; //ß + case 0xBB: dest = 223; break; //° + } + return (dest); +} + +void TEF6686::clearRDS (bool fullsearchrds) +{ + devTEF_Radio_Set_RDS(fullsearchrds); + uint8_t i; + for (i = 0; i < 9; i++) { + rds.stationName[i] = 0; + ps_buffer[i] = 0; + } + for (i = 0; i < 65; i++) { + rds.stationText[i] = 0; + stationTextBuffer[i] = 0; + rt_buffer[i] = 0; + } + for (i = 0; i < 17; i++) { + rds.stationType[i] = 0; + } + + for (i = 0; i < 5; i++) { + rds.picode[i] = 0; + } + + rds.stationType[i] = '\0'; + rds.stationID = 0; + offsetold = 0; + rds.stationTypeCode = 32; + rds.hasCT = false; + rds.stationTextOffset = 0; + rt_process = 0; + ps_process = 1; + af_counter = 0; + rt_timer = 0; + rds.errors = 0; +} + +uint16_t TEF6686::tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) { + Radio_ChangeFreqOneStep(up, stepsize, LowEdge, HighEdge, fullsearchrds); + Radio_SetFreq(Radio_GetCurrentFreq(), LowEdge, HighEdge, fullsearchrds); + + return Radio_GetCurrentFreq(); +} + +uint16_t TEF6686::tune_AM(uint8_t up, uint8_t stepsize) { + Radio_ChangeFreqOneStep_AM(up, stepsize); + Radio_SetFreq_AM(Radio_GetCurrentFreq_AM()); + return Radio_GetCurrentFreq_AM(); +} diff --git a/src/TEF6686.h b/src/TEF6686.h new file mode 100644 index 0000000..07e4fb3 --- /dev/null +++ b/src/TEF6686.h @@ -0,0 +1,80 @@ +#define TEF6686_h + +#include "Arduino.h" +#include "Tuner_Api.h" +#include "Tuner_Drv_Lithio.h" +#include "Tuner_Interface.h" + + +enum RDS_GROUPS +{ + RDS_GROUP_0A, RDS_GROUP_0B, RDS_GROUP_1A, RDS_GROUP_1B, RDS_GROUP_2A, RDS_GROUP_2B, RDS_GROUP_3A, RDS_GROUP_3B, + RDS_GROUP_4A, RDS_GROUP_4B, RDS_GROUP_5A, RDS_GROUP_5B, RDS_GROUP_6A, RDS_GROUP_6B, RDS_GROUP_7A, RDS_GROUP_7B, + RDS_GROUP_8A, RDS_GROUP_8B, RDS_GROUP_9A, RDS_GROUP_9B, RDS_GROUP_10A, RDS_GROUP_10B, RDS_GROUP_11A, RDS_GROUP_11B, + RDS_GROUP_12A, RDS_GROUP_12B, RDS_GROUP_13A, RDS_GROUP_13B, RDS_GROUP_14A, RDS_GROUP_14B, RDS_GROUP_15A, RDS_GROUP_15B +}; + +typedef struct _rds_ +{ + char picode[5]; + char stationName[9]; + char stationText[65]; + byte stationTypeCode; + char stationType[17]; + uint16_t hours, minutes, days, offsetplusmin, stationID = 0, rdsA, rdsB, rdsC, rdsD, rdsError, errors = 0; + int8_t offset; + uint8_t stationTextOffset = 0; + bool hasCT = false; + bool rtAB = false; +} rds_; + +class TEF6686 { + public: + rds_ rds; + bool readRDS(void); + uint16_t getFrequency(); + uint16_t getFrequency_AM(); + uint16_t tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); + uint16_t tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); + uint16_t tuneDown_AM(uint8_t stepsize); + uint16_t tuneUp_AM(uint8_t stepsize); + bool getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation); + bool getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation); + bool getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version); + bool getBootStatus(uint8_t &bootstatus); + void setMono(uint8_t mono); + bool getStereoStatus(); + void init(byte TEF); + void clearRDS(bool fullsearchrds); + void power(uint8_t mode); + void setAGC(uint8_t start); + void setiMS(uint16_t mph); + void setEQ(uint16_t eq); + void setDeemphasis(uint8_t timeconstant); + void setFMABandw(); + void setFMBandw(uint16_t bandwidth); + void setAMBandw(uint16_t bandwidth); + void setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); + void setFrequency_AM(uint16_t frequency); + void setHighCutLevel(uint16_t limit); + void setHighCutOffset(uint16_t start); + void setMute(); + void setOffset(int16_t offset); + void setStereoLevel(uint16_t start); + void setUnMute(); + void setVolume(int16_t volume); + uint8_t af_counter; + + private: + uint16_t tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); + uint16_t tune_AM(uint8_t up, uint8_t stepsize); + uint8_t ascii_converter (uint8_t src); + uint8_t ps_process; + uint8_t rt_process; + char ps_buffer[9]; + char rt_buffer[65]; + bool ABold; + byte rt_timer; + byte offsetold; + char stationTextBuffer[65]; +}; diff --git a/src/TFT_Colors.h b/src/TFT_Colors.h new file mode 100644 index 0000000..0122aaa --- /dev/null +++ b/src/TFT_Colors.h @@ -0,0 +1,8 @@ +#define TFT_BLACK 0x0000 /* 0, 0, 0 */ +#define TFT_DARKGREY 0x7BEF /* 128, 128, 128 */ +#define TFT_BLUE 0xF800 /* 255, 0, 0 */ +#define TFT_GREEN 0x07E0 /* 0, 255, 0 */ +#define TFT_RED 0x001F /* 0, 0, 255 */ +#define TFT_YELLOW 0x07FF /* 0, 255, 255 */ +#define TFT_WHITE 0xFFFF /* 255, 255, 255 */ +#define TFT_SKYBLUE 0x867D /* 235, 206, 135 */ diff --git a/src/Tuner_Api.cpp b/src/Tuner_Api.cpp new file mode 100644 index 0000000..760e5b8 --- /dev/null +++ b/src/Tuner_Api.cpp @@ -0,0 +1,106 @@ +#include "TEF6686.h" + +uint16_t Radio_CurrentFreq; +uint16_t Radio_CurrentFreq_AM; + +void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) +{ + if ((Freq > HighEdge * 100) || (Freq < LowEdge * 100)) { + Freq = LowEdge * 100; + } + Radio_CurrentFreq = Freq; + devTEF_Radio_Tune_To(Freq); + devTEF_Radio_Set_RDS(fullsearchrds); +} + +void Radio_SetFreq_AM(uint16_t Freq) +{ + if (Freq > 27000) { + Freq = 144; + } + if (Freq < 144) { + Freq = 27000; + } + Radio_CurrentFreq_AM = Freq; + devTEF_Radio_Tune_To_AM(Freq); +} + +void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullseachrds) +{ + byte temp; + if (stepsize == 0) { + temp = 5; + } + if (stepsize == 1) { + temp = 1; + } + if (stepsize == 2) { + temp = 10; + } + if (stepsize == 3) { + temp = 100; + } + if (UpDown == 1) { + Radio_CurrentFreq += temp; + if (Radio_CurrentFreq > HighEdge * 100) { + Radio_CurrentFreq = LowEdge * 100; + } + } else { + Radio_CurrentFreq -= temp; + if (Radio_CurrentFreq < LowEdge * 100) { + Radio_CurrentFreq = HighEdge * 100; + } + } +} + +void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize) +{ + byte temp; + if (stepsize == 0) { + if (Radio_CurrentFreq_AM < 2000) { + temp = 9; + } else { + temp = 5; + } + } + if (stepsize == 1) { + temp = 1; + } + if (stepsize == 2) { + temp = 10; + } + if (stepsize == 3) { + temp = 100; + } + if (UpDown == 1) { + Radio_CurrentFreq_AM += temp; + if (Radio_CurrentFreq_AM > 27000) { + Radio_CurrentFreq_AM = 144; + } + } else { + Radio_CurrentFreq_AM -= temp; + if (Radio_CurrentFreq_AM < 144) { + Radio_CurrentFreq_AM = 27000; + } + } +} + +uint16_t Radio_GetCurrentFreq(void) +{ + return Radio_CurrentFreq; +} + +uint16_t Radio_GetCurrentFreq_AM(void) +{ + return Radio_CurrentFreq_AM; +} + +bool Radio_CheckStereo(void) +{ + uint16_t status; + uint8_t stereo = 0; + if (1 == devTEF_Radio_Get_Stereo_Status(&status)) { + stereo = ((status >> 15) & 1) ? 1 : 0; + } + return stereo; +} diff --git a/src/Tuner_Api.h b/src/Tuner_Api.h new file mode 100644 index 0000000..31046d7 --- /dev/null +++ b/src/Tuner_Api.h @@ -0,0 +1,7 @@ +extern uint16_t Radio_GetCurrentFreq(void); +extern uint16_t Radio_GetCurrentFreq_AM(void); +extern void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); +extern void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize); +extern void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds); +extern void Radio_SetFreq_AM(uint16_t Freq); +bool Radio_CheckStereo(void); diff --git a/src/Tuner_Drv_Lithio.cpp b/src/Tuner_Drv_Lithio.cpp new file mode 100644 index 0000000..98aac14 --- /dev/null +++ b/src/Tuner_Drv_Lithio.cpp @@ -0,0 +1,223 @@ +#include "TEF6686.h" +#include + +#define High_16bto8b(a) ((uint8_t)((a) >> 8)) +#define Low_16bto8b(a) ((uint8_t)(a )) +#define Convert8bto16b(a) ((uint16_t)(((uint16_t)(*(a))) << 8 |((uint16_t)(*(a+1))))) + +bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...) +{ + uint16_t i; + uint8_t buf[20]; + uint16_t temp; + va_list vArgs; + + va_start(vArgs, len); + + buf[0] = module; + buf[1] = cmd; + buf[2] = 1; + + for (i = 3; i < len; i++) + { + temp = va_arg(vArgs, int); + buf[i++] = High_16bto8b(temp); + buf[i] = Low_16bto8b(temp); + } + + va_end(vArgs); + + return Tuner_WriteBuffer(buf, len); +} + + +bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len) +{ + uint8_t buf[3]; + + buf[0] = module; + buf[1] = cmd; + buf[2] = 1; + + Tuner_WriteBuffer(buf, 3); + return Tuner_ReadBuffer(receive, len); +} + +bool devTEF_Radio_Tune_To (uint16_t frequency) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, frequency); +} + +bool devTEF_Radio_Tune_To_AM (uint16_t frequency) +{ + return devTEF_Set_Cmd(TEF_AM, Cmd_Tune_To, 7, 1, frequency); +} + +bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 11, mode, bandwidth, control_sensitivity, low_level_sensitivity); +} + +bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) +{ + return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Bandwidth, 7, mode, bandwidth, control_sensitivity, low_level_sensitivity); +} + +bool devTEF_Radio_Set_LevelOffset(int16_t offset) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_LevelOffset, 5, offset - 70); +} + +bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 7, mode, limit); +} + +bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 9, mode, start, slope); +} + +bool devTEF_Radio_Set_MphSuppression(uint16_t mph) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_MphSuppression, 5, mph, 0); +} + +bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_ChannelEqualizer, 5, eq, 0); +} + +bool devTEF_Radio_Set_Stereo_Min(uint16_t mode) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Min, 7, mode); +} + +bool devTEF_Radio_Set_RFAGC(uint16_t start) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, start, 0, 0); +} + +bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant) +{ + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, timeconstant, 0); +} + +bool devTEF_Audio_Set_Volume(int16_t volume) +{ + return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Volume, 5, volume * 10); +} + +bool devTEF_Audio_Set_Mute(uint16_t mode) +{ + return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, mode); +} + +bool devTEF_APPL_Set_OperationMode(uint16_t mode) +{ + return devTEF_Set_Cmd(TEF_APPL, Cmd_Set_OperationMode, 5, mode); +} + +bool devTEF_APPL_Get_Operation_Status (uint8_t *bootstatus) +{ + uint8_t buf[2]; + uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Operation_Status, buf, sizeof(buf)); + *bootstatus = Convert8bto16b(buf); + return r; +} + +bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) +{ + uint8_t buf[14]; + uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Status, buf, sizeof(buf)); + + *level = Convert8bto16b(buf + 2); + *usn = Convert8bto16b(buf + 4); + *wam = Convert8bto16b(buf + 6); + *offset = Convert8bto16b(buf + 8); + *bandwidth = Convert8bto16b(buf + 10) / 10; + *mod = Convert8bto16b(buf + 12) / 10; + return r; +} + +bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) +{ + uint8_t buf[14]; + uint16_t r = devTEF_Get_Cmd(TEF_AM, Cmd_Get_Quality_Status, buf, sizeof(buf)); + + *level = Convert8bto16b(buf + 2); + *usn = Convert8bto16b(buf + 4); + *wam = Convert8bto16b(buf + 6); + *offset = Convert8bto16b(buf + 8); + *bandwidth = Convert8bto16b(buf + 10) / 10; + *mod = Convert8bto16b(buf + 12) / 10; + return r; +} + +bool devTEF_Radio_Get_RDS_Data (uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error) +{ + uint8_t buf[12]; + uint8_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_RDS_Status, buf, sizeof(buf)); + + *status = Convert8bto16b(buf); + *A_block = Convert8bto16b(buf + 2); + *B_block = Convert8bto16b(buf + 4); + *C_block = Convert8bto16b(buf + 6); + *D_block = Convert8bto16b(buf + 8); + *dec_error = Convert8bto16b(buf + 10); + return r; +} + +bool devTEF_Radio_Get_Stereo_Status(uint16_t *status) +{ + uint8_t buf[2]; + uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Signal_Status, buf, sizeof(buf)); + + *status = Convert8bto16b(buf); + return r; +} + +bool devTEF_Radio_Set_RDS(bool fullsearchrds) +{ + if (fullsearchrds == true) { + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 3, 1, 0); + } else { + return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 1, 1, 0); + } +} + +bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version) +{ + uint8_t buf[6]; + uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Identification, buf, sizeof(buf)); + + *device = Convert8bto16b(buf); + *hw_version = Convert8bto16b(buf + 2); + *sw_version = Convert8bto16b(buf + 4); + return r; +} diff --git a/src/Tuner_Drv_Lithio.h b/src/Tuner_Drv_Lithio.h new file mode 100644 index 0000000..72c91db --- /dev/null +++ b/src/Tuner_Drv_Lithio.h @@ -0,0 +1,70 @@ +typedef enum +{ TEF_FM = 32, + TEF_AM = 33, + TEF_AUDIO = 48, + TEF_APPL = 64 +} TEF_MODULE; + +typedef enum +{ Cmd_Tune_To = 1, + Cmd_Set_Bandwidth = 10, + Cmd_Set_RFAGC = 11, + Cmd_Set_MphSuppression = 20, + Cmd_Set_ChannelEqualizer= 22, + Cmd_Set_Deemphasis = 31, + Cmd_Set_LevelOffset = 39, + Cmd_Set_Softmute_Max = 45, + Cmd_Set_Highcut_Level = 52, + Cmd_Set_Highcut_Noise = 53, + Cmd_Set_Highcut_Mph = 54, + Cmd_Set_Highcut_Max = 55, + Cmd_Set_Stereo_Level = 62, + Cmd_Set_Stereo_Noise = 63, + Cmd_Set_Stereo_Mph = 64, + Cmd_Set_Stereo_Min = 66, + Cmd_Set_RDS = 81, + Cmd_Get_Quality_Status = 128, + Cmd_Get_RDS_Status = 130, + Cmd_Get_Signal_Status = 133, +} TEF_RADIO_COMMAND; + +typedef enum +{ Cmd_Set_Volume = 10, + Cmd_Set_Mute = 11, +} TEF_AUDIO_COMMAND; + +typedef enum +{ + Cmd_Set_OperationMode = 1, + Cmd_Get_Operation_Status = 128, + Cmd_Get_Identification = 130 +} TEF_APPL_COMMAND; + +bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...); +bool devTEF_Radio_Tune_To (uint16_t frequency); +bool devTEF_Radio_Tune_To_AM (uint16_t frequency); +bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version); +bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod); +bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod); +bool devTEF_APPL_Get_Operation_Status(uint8_t *bootstatus); +bool devTEF_Audio_Set_Mute(uint16_t mode); +bool devTEF_Audio_Set_Volume(int16_t volume); +bool devTEF_Radio_Get_Stereo_Status(uint16_t *status); +bool devTEF_APPL_Set_OperationMode(uint16_t mode); +bool devTEF_Radio_Get_RDS_Data(uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error); +bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity); +bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity); +bool devTEF_Radio_Set_LevelOffset(int16_t offset); +bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_Stereo_Min(uint16_t mode); +bool devTEF_Radio_Set_MphSuppression(uint16_t mph); +bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq); +bool devTEF_Radio_Set_RFAGC(uint16_t start); +bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant); +bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit); +bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope); +bool devTEF_Radio_Set_RDS(bool fullsearchrds); diff --git a/src/Tuner_Interface.cpp b/src/Tuner_Interface.cpp new file mode 100644 index 0000000..9716888 --- /dev/null +++ b/src/Tuner_Interface.cpp @@ -0,0 +1,226 @@ +#include "TEF6686.h" +#include "Tuner_Patch_Lithio_V101_p119.h" +#include "Tuner_Patch_Lithio_V102_p224.h" +#include "Tuner_Patch_Lithio_V205_p512.h" +#include + +bool debug_tx = false; +bool debug_rx = false; + +static const unsigned char tuner_init_tab[] = { + 7, 0x20, 0x0B, 0x01, 0x03, 0x98, 0x00, 0x00, + 5, 0x20, 0x14, 0x01, 0x00, 0x00, + 5, 0x20, 0x16, 0x01, 0x00, 0x00, + 7, 0x20, 0x17, 0x01, 0x00, 0x00, 0x03, 0xE8, + 5, 0x20, 0x20, 0x01, 0x00, 0x01, + 5, 0x20, 0x1F, 0x01, 0x01, 0xF4, + 9, 0x20, 0x2A, 0x01, 0x00, 0x02, 0x00, 0x96, 0x00, 0xDC, + 9, 0x21, 0x2A, 0x01, 0x00, 0x02, 0x00, 0x96, 0x00, 0xDC, + 7, 0x20, 0x2D, 0x01, 0x00, 0x00, 0x00, 0xC8, + 11, 0x20, 0x32, 0x01, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xC8, 0x00, 0xC8, + 11, 0x20, 0x33, 0x01, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x82, 0x01, 0xF4, + 9, 0x20, 0x36, 0x01, 0x00, 0x00, 0x01, 0x68, 0x01, 0x2C, + 7, 0x20, 0x37, 0x01, 0x00, 0x00, 0x0F, 0xA0, + 7, 0x20, 0x39, 0x01, 0x00, 0x00, 0x00, 0x64, + 7, 0x20, 0x3A, 0x01, 0x00, 0x00, 0x00, 0xAA, + 5, 0x20, 0x3B, 0x01, 0x00, 0x01, + 11, 0x20, 0x3C, 0x01, 0x00, 0x3C, 0x00, 0x78, 0x00, 0x64, 0x00, 0xC8, + 11, 0x20, 0x3D, 0x01, 0x00, 0x00, 0x00, 0xD2, 0x00, 0x5A, 0x01, 0xF4, + 11, 0x20, 0x46, 0x01, 0x01, 0xF4, 0x07, 0xD0, 0x00, 0xC8, 0x00, 0xC8, + 11, 0x20, 0x47, 0x01, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x78, 0x02, 0x9E, + 9, 0x20, 0x48, 0x01, 0x00, 0x00, 0x02, 0x58, 0x00, 0xF0, + 9, 0x20, 0x49, 0x01, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x8C, + 9, 0x20, 0x4A, 0x01, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x8C, + 7, 0x20, 0x4B, 0x01, 0x00, 0x00, 0x0F, 0xA0, + 5, 0x20, 0x56, 0x01, 0x03, 0x84, + 7, 0x30, 0x15, 0x01, 0x00, 0x80, 0x00, 0x01 +}; + +static const unsigned char tuner_init_tab4000[] = { + 3, 0x14, 0x00, 0x01, + 2, 0xff, 50, + 9, 0x40, 0x04, 0x01, 0x00, 0x3D, 0x09, 0x00, 0x00, 0x00, + 5, 0x40, 0x05, 0x01, 0x00, 0x01, + 2, 0xff, 100, +}; + +static const unsigned char tuner_init_tab9216[] = { + 3, 0x14, 0x00, 0x01, + 2, 0xff, 50, + 9, 0x40, 0x04, 0x01, 0x00, 0x8C, 0xA0, 0x00, 0x00, 0x00, + 5, 0x40, 0x05, 0x01, 0x00, 0x01, + 2, 0xff, 100, +}; + +bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len) +{ + Wire.beginTransmission(0x64); + if (debug_tx == true) { + Serial.println(); + } + for (uint16_t i = 0; i < len; i++) { + if (debug_tx == true) { + if (buf[i] < 0x10) { + Serial.print("0"); + } + Serial.print(buf[i], HEX); + Serial.print(" "); + } + Wire.write(buf[i]); + } + uint8_t r = Wire.endTransmission(); + delay(2); + return (r == 0) ? 1 : 0; +} + +bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len) +{ + Wire.requestFrom(0x64, len); + if (debug_rx == true) { + Serial.println(); + } + if (Wire.available() == len) { + for (uint16_t i = 0; i < len; i++) { + if (debug_rx == true) { + if (buf[i] < 0x10) { + Serial.print("0"); + } + Serial.print(buf[i], HEX); + Serial.print(" "); + } + buf[i] = Wire.read(); + } + return 1; + } + return 0; +} + +bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size) +{ + unsigned char buf[24 + 1]; + uint16_t i, len; + uint16_t r; + buf[0] = 0x1b; + + while (size) + { + len = (size > 24) ? 24 : size; + size -= len; + + for (i = 0; i < len; i++) + buf[1 + i] = pLutBytes[i]; + + pLutBytes += len; + + if (1 != (r = Tuner_WriteBuffer(buf, len + 1))) + { + break; + } + } + return r; +} + + +bool Tuner_Table_Write(const unsigned char *tab) +{ + if (tab[1] == 0xff) + { + delay(tab[2]); + return 1; + } else { + return Tuner_WriteBuffer((unsigned char *)&tab[1], tab[0]); + } +} + +void Tuner_Patch(byte TEF) { + Wire.beginTransmission(0x64); + Wire.write(0x1e); + Wire.write(0x5a); + Wire.write(0x01); + Wire.write(0x5a); + Wire.write(0x5a); + Wire.endTransmission(); + delay(100); + Wire.beginTransmission(0x64); + Wire.write(0x1c); + Wire.write(0x00); + Wire.write(0x00); + Wire.endTransmission(); + delay(100); + Wire.beginTransmission(0x64); + Wire.write(0x1c); + Wire.write(0x00); + Wire.write(0x74); + Wire.endTransmission(); + if (TEF == 101) { + Tuner_Patch_Load(pPatchBytes101, PatchSize101); + } else if (TEF == 102) { + Tuner_Patch_Load(pPatchBytes102, PatchSize102); + } else if (TEF == 205) { + Tuner_Patch_Load(pPatchBytes205, PatchSize205); + } + Wire.beginTransmission(0x64); + Wire.write(0x1c); + Wire.write(0x00); + Wire.write(0x00); + Wire.endTransmission(); + delay(100); + Wire.beginTransmission(0x64); + Wire.write(0x1c); + Wire.write(0x00); + Wire.write(0x75); + Wire.endTransmission(); + if (TEF == 101) { + Tuner_Patch_Load(pLutBytes101, LutSize101); + } else if (TEF == 102) { + Tuner_Patch_Load(pLutBytes102, LutSize102); + } else if (TEF == 205) { + Tuner_Patch_Load(pLutBytes205, LutSize205); + } + Wire.beginTransmission(0x64); + Wire.write(0x1c); + Wire.write(0x00); + Wire.write(0x00); + Wire.endTransmission(); +} + +void Tuner_I2C_Init() { + Wire.begin(); + delay(5); +} + +bool Tuner_Init(void) { + uint16_t r; + const unsigned char *p = tuner_init_tab; + + for (uint16_t i = 0; i < sizeof(tuner_init_tab); i += (p[i] + 1)) + { + if (1 != (r = Tuner_Table_Write(p + i))) + break; + } + return r; +} + +bool Tuner_Init4000(void) { + uint16_t r; + const unsigned char *p = tuner_init_tab4000; + + for (uint16_t i = 0; i < sizeof(tuner_init_tab4000); i += (p[i] + 1)) + { + if (1 != (r = Tuner_Table_Write(p + i))) + break; + } + return r; +} + +bool Tuner_Init9216(void) { + uint16_t r; + const unsigned char *p = tuner_init_tab9216; + + for (uint16_t i = 0; i < sizeof(tuner_init_tab9216); i += (p[i] + 1)) + { + if (1 != (r = Tuner_Table_Write(p + i))) + break; + } + return r; +} diff --git a/src/Tuner_Interface.h b/src/Tuner_Interface.h new file mode 100644 index 0000000..dce829a --- /dev/null +++ b/src/Tuner_Interface.h @@ -0,0 +1,8 @@ +void Tuner_I2C_Init(); +void Tuner_Patch(byte TEF); +bool Tuner_Init(); +bool Tuner_Init4000(); +bool Tuner_Init9216(); +bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len); +bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len); +bool Tuner_Table_Write(const unsigned char *tab); diff --git a/src/Tuner_Patch_Lithio_V101_p119.h b/src/Tuner_Patch_Lithio_V101_p119.h new file mode 100644 index 0000000..57744ca --- /dev/null +++ b/src/Tuner_Patch_Lithio_V101_p119.h @@ -0,0 +1,275 @@ +extern const size_t PatchSize101; +extern const unsigned char *pPatchBytes101; +static const unsigned char PatchByteValues101[] = +{ + 0xF0, 0x00, 0x38, 0x40, 0xD0, 0x80, 0x32, 0x81, 0x38, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x52, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x64, 0xD0, 0x80, + 0xC4, 0xCB, 0x38, 0x68, 0xD0, 0x80, 0x80, 0x20, 0x38, 0xA9, 0xD0, 0x80, 0x90, 0x41, 0x38, 0xAE, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0xB7, 0xD0, 0x80, + 0x80, 0x08, 0x38, 0xD8, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x2D, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x57, 0xD0, 0x80, + 0xC4, 0xA2, 0x01, 0x13, 0x60, 0x04, 0xF0, 0x00, 0x39, 0x01, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x5B, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x35, 0xD0, 0x80, + 0xF0, 0x00, 0x39, 0x8A, 0xD0, 0x80, 0x40, 0x30, 0x39, 0x91, 0xD0, 0x80, 0xF0, 0x00, 0x19, 0x70, 0xD0, 0x80, 0x33, 0x22, 0x39, 0x96, 0xD0, 0x80, + 0xF0, 0x00, 0x39, 0xA5, 0xD0, 0x80, 0xAA, 0x10, 0x39, 0xA8, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0xB6, 0xD0, 0x80, 0x90, 0x41, 0x39, 0xDC, 0xD0, 0x80, + 0xF0, 0x00, 0x39, 0xDF, 0xD0, 0x80, 0x31, 0x81, 0x39, 0xEE, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x26, 0x07, 0x3A, 0x13, 0xD0, 0x80, + 0x56, 0x02, 0x3A, 0x17, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x25, 0x2A, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x84, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0x87, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x96, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x98, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xAF, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0xB2, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xB5, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xBB, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xC5, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0xD0, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xDA, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xDD, 0xD0, 0x80, 0x90, 0x00, 0x3A, 0xE1, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0xE7, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xEB, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xF7, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x02, 0xD0, 0x80, + 0xF0, 0x00, 0x3B, 0x0A, 0xD0, 0x80, 0x2B, 0xB0, 0x3B, 0x0D, 0xD0, 0x80, 0x8E, 0xD4, 0x08, 0xFB, 0x60, 0x03, 0x35, 0xC2, 0x08, 0xFB, 0x60, 0x06, + 0xF0, 0x00, 0x3B, 0x24, 0xD0, 0x80, 0x3C, 0xC3, 0x3B, 0x30, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x3F, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x52, 0xD0, 0x80, + 0xF0, 0x00, 0x3B, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x5B, 0xD0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xB6, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x28, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xFB, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x6D, + 0xF0, 0x00, 0x70, 0x00, 0xA1, 0x5B, 0xF0, 0x00, 0x70, 0x00, 0xA1, 0xAE, 0xF0, 0x00, 0x70, 0x00, 0xA2, 0x39, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x04, + 0xF0, 0x00, 0x70, 0x00, 0xA2, 0x51, 0xF0, 0x00, 0x70, 0x00, 0xA2, 0xCF, 0xF0, 0x00, 0x70, 0x00, 0xA2, 0xB2, 0xF0, 0x00, 0x25, 0xAB, 0xD0, 0x80, + 0x08, 0x11, 0x60, 0x08, 0xF0, 0x00, 0x43, 0x10, 0x60, 0x00, 0xA3, 0x2C, 0xF0, 0x00, 0x3F, 0x80, 0xF0, 0x00, 0x0D, 0xD2, 0x60, 0x08, 0xF0, 0x00, + 0x26, 0x07, 0x60, 0x00, 0xA3, 0x29, 0xF0, 0x00, 0x30, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x03, 0x70, 0x60, 0x00, 0xF0, 0x00, 0x0D, 0xD2, 0x60, 0x0A, + 0x82, 0x40, 0x21, 0xE4, 0x60, 0x00, 0x26, 0x07, 0x60, 0x00, 0xEE, 0x00, 0xF0, 0x00, 0x07, 0xEF, 0x60, 0x08, 0x30, 0x20, 0x07, 0x08, 0xD0, 0x80, + 0xF0, 0x00, 0x07, 0xEF, 0x60, 0x08, 0xF0, 0x00, 0x03, 0xA2, 0xD2, 0x80, 0x40, 0x02, 0x08, 0x11, 0x60, 0x09, 0x00, 0xA8, 0x60, 0x02, 0xE6, 0x00, + 0x21, 0x11, 0x70, 0x00, 0xA0, 0x4F, 0x8C, 0x41, 0x21, 0x00, 0xA3, 0x1C, 0x82, 0x08, 0x32, 0x81, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xDC, 0x09, + 0x90, 0x40, 0x07, 0xBF, 0xD0, 0x80, 0xF0, 0x00, 0x0F, 0xD0, 0x60, 0x09, 0xD2, 0xFF, 0xC7, 0xFF, 0x60, 0x02, 0xF0, 0x00, 0x08, 0x21, 0xD0, 0x80, + 0x0D, 0xD2, 0x60, 0x0A, 0xA3, 0x15, 0xF0, 0x00, 0x20, 0x23, 0xF0, 0x00, 0x08, 0x00, 0x60, 0x0A, 0xA3, 0x13, 0x20, 0xA1, 0x08, 0x30, 0xD0, 0x80, + 0xCA, 0x09, 0x30, 0x23, 0xF0, 0x00, 0xC2, 0xCB, 0x08, 0x4E, 0xD0, 0x80, 0x40, 0x61, 0x1D, 0x26, 0x60, 0x09, 0x40, 0x92, 0x06, 0x17, 0x60, 0x0A, + 0x40, 0x13, 0x07, 0x91, 0x60, 0x0B, 0x42, 0x04, 0x07, 0x84, 0x60, 0x0C, 0x40, 0x85, 0x07, 0x88, 0x60, 0x0D, 0x37, 0x91, 0x1D, 0x51, 0x60, 0x0E, + 0x30, 0x22, 0xC0, 0x00, 0x60, 0x06, 0x30, 0x33, 0x1D, 0x57, 0x60, 0x0F, 0x31, 0x44, 0xC0, 0x00, 0x60, 0x07, 0x30, 0x55, 0x40, 0x00, 0xF0, 0x00, + 0x30, 0x66, 0x70, 0x00, 0xF0, 0x00, 0x30, 0xE0, 0x70, 0x00, 0xF0, 0x00, 0x31, 0x60, 0x70, 0x00, 0xF0, 0x00, 0x31, 0xE0, 0x70, 0x00, 0xF0, 0x00, + 0x32, 0x60, 0x70, 0x00, 0xF0, 0x00, 0x32, 0xE0, 0x70, 0x00, 0xF0, 0x00, 0x30, 0x77, 0x70, 0x00, 0xF0, 0x00, 0x30, 0xF0, 0x70, 0x00, 0xF0, 0x00, + 0x31, 0x70, 0x70, 0x00, 0xF0, 0x00, 0x31, 0xF0, 0x1D, 0x5D, 0x60, 0x09, 0x32, 0x70, 0x18, 0x00, 0x60, 0x01, 0x32, 0xF0, 0xE8, 0x00, 0x60, 0x02, + 0x30, 0x11, 0x70, 0x00, 0xF0, 0x00, 0x30, 0x92, 0x70, 0x00, 0xF0, 0x00, 0x31, 0x10, 0x70, 0x00, 0xF0, 0x00, 0x31, 0x90, 0x70, 0x00, 0xF0, 0x00, + 0x32, 0x10, 0x17, 0x07, 0x60, 0x08, 0x32, 0x90, 0x00, 0x00, 0x60, 0x01, 0x10, 0x00, 0x09, 0xBE, 0x60, 0x02, 0x10, 0x01, 0x02, 0x9E, 0x60, 0x03, + 0x10, 0x02, 0x08, 0x1D, 0x60, 0x04, 0x10, 0x03, 0x0B, 0x23, 0x60, 0x05, 0x10, 0x04, 0xE5, 0xD8, 0x60, 0x06, 0x10, 0x05, 0x05, 0xC3, 0x60, 0x07, + 0x10, 0x06, 0xF5, 0x9C, 0x60, 0x00, 0x10, 0x07, 0xE9, 0x50, 0x60, 0x01, 0x10, 0x00, 0x17, 0xE8, 0x60, 0x02, 0x10, 0x01, 0xEA, 0x8C, 0x60, 0x03, + 0x10, 0x02, 0xF2, 0x6E, 0x60, 0x04, 0x10, 0x03, 0xFE, 0x31, 0x60, 0x05, 0x10, 0x04, 0xF2, 0xD0, 0x60, 0x06, 0x10, 0x05, 0xF5, 0xC3, 0x60, 0x07, + 0x10, 0x06, 0xFF, 0xD8, 0x60, 0x00, 0x10, 0x07, 0x06, 0x0F, 0x60, 0x01, 0x10, 0x00, 0xF3, 0x19, 0x60, 0x02, 0x10, 0x01, 0x15, 0xD4, 0x60, 0x03, + 0x10, 0x02, 0x17, 0x7A, 0x60, 0x04, 0x10, 0x03, 0x14, 0x7B, 0x60, 0x05, 0x10, 0x04, 0x23, 0x7E, 0x60, 0x06, 0x10, 0x05, 0x30, 0x15, 0x60, 0x07, + 0x10, 0x06, 0x34, 0x26, 0x60, 0x00, 0x10, 0x07, 0x34, 0x2A, 0x60, 0x01, 0x10, 0x00, 0x4D, 0x01, 0x60, 0x02, 0x10, 0x01, 0x40, 0x3E, 0x60, 0x03, + 0x10, 0x02, 0x44, 0x34, 0x60, 0x04, 0x10, 0x03, 0x4F, 0x6D, 0x60, 0x05, 0x10, 0x04, 0x06, 0xAB, 0x60, 0x0D, 0x10, 0x05, 0x40, 0xA3, 0xF0, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0x40, 0x64, 0xF0, 0x00, 0x30, 0x53, 0x46, 0x45, 0xF0, 0x00, 0x30, 0xD4, 0x41, 0xE6, 0xF0, 0x00, 0x31, 0x55, 0xF0, 0x00, + 0xF0, 0x00, 0x31, 0xD6, 0xD0, 0x08, 0x0D, 0xD3, 0x60, 0x09, 0xA2, 0xD0, 0xF0, 0x00, 0x20, 0x14, 0xA2, 0xCF, 0x80, 0x20, 0x0C, 0x46, 0xD0, 0x80, + 0x0D, 0xD3, 0x60, 0x0A, 0xA2, 0xCD, 0xF0, 0x00, 0x30, 0x22, 0xD0, 0x08, 0x7F, 0xFF, 0x60, 0x02, 0xE6, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0x37, 0x12, 0x0D, 0x21, 0xD0, 0x80, 0xF0, 0x00, 0x00, 0x6D, 0x60, 0x08, 0xF0, 0x00, 0x10, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x07, 0x00, 0x60, 0x01, + 0x30, 0x00, 0x7F, 0xFF, 0x60, 0x02, 0x31, 0x01, 0x70, 0x00, 0xF0, 0x00, 0x31, 0x82, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x01, 0x00, 0x60, 0x03, + 0xF0, 0x00, 0x0F, 0x25, 0xD2, 0x80, 0xF0, 0x00, 0x0F, 0x79, 0xD0, 0x80, 0xF0, 0x00, 0x01, 0x4E, 0x60, 0x03, 0xF0, 0x00, 0x10, 0x61, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x07, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x16, 0xD1, 0x80, 0x40, 0x70, 0x0F, 0xEC, 0xD2, 0x80, + 0xF0, 0x00, 0x10, 0x10, 0x60, 0x03, 0xF0, 0x00, 0x00, 0xFF, 0x60, 0x01, 0x83, 0x5D, 0x70, 0x00, 0xF0, 0x00, 0xC3, 0x0C, 0x70, 0x00, 0x94, 0x09, + 0x40, 0x20, 0x0F, 0xEC, 0xD2, 0x80, 0x9F, 0x24, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x03, 0x40, 0x40, 0x0F, 0xEC, 0xD2, 0x80, + 0x40, 0x50, 0x0F, 0xEC, 0xD2, 0x80, 0xF0, 0x00, 0x10, 0x12, 0xD0, 0x80, 0x40, 0x40, 0x0F, 0xED, 0xD2, 0x80, 0x40, 0x50, 0x0F, 0xED, 0xD2, 0x80, + 0xF0, 0x00, 0x10, 0x12, 0xD0, 0x80, 0xF0, 0x00, 0x40, 0x20, 0xAF, 0xEC, 0x9F, 0x24, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x02, + 0x40, 0x40, 0x0F, 0xEC, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x01, 0x40, 0x40, 0x0F, 0xED, 0xD2, 0x80, 0x40, 0x50, 0x0F, 0xE6, 0xD2, 0x80, + 0xF0, 0x00, 0x0F, 0x61, 0x60, 0x09, 0x41, 0x73, 0x0F, 0x25, 0xD2, 0x80, 0x91, 0xC0, 0x0E, 0x27, 0x60, 0x09, 0x40, 0xB3, 0x0F, 0x25, 0xD0, 0x80, + 0x90, 0x82, 0x70, 0x00, 0x90, 0x11, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x06, 0x4F, 0x90, 0x0F, 0xEA, 0xD2, 0x80, 0x4F, 0xF0, 0x0F, 0xEA, 0xD2, 0x80, + 0x0E, 0x26, 0x60, 0x09, 0xF0, 0x00, 0x00, 0xE4, 0x60, 0x03, 0xF0, 0x00, 0x00, 0x05, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x05, + 0x4F, 0x90, 0x0F, 0xEB, 0xD2, 0x80, 0x4F, 0xF0, 0x0F, 0xEB, 0xD2, 0x80, 0x0E, 0x26, 0x60, 0x09, 0xF0, 0x00, 0x00, 0xA5, 0x60, 0x03, 0xF0, 0x00, + 0x00, 0x0D, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x13, 0xF0, 0x00, 0xFF, 0xE0, 0x60, 0x01, 0xF0, 0x00, 0x82, 0x92, 0x0F, 0x62, 0x60, 0x09, + 0xF0, 0x00, 0x0F, 0x21, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x02, 0x4F, 0x90, 0x0F, 0xE6, 0xD2, 0x80, 0x4F, 0xF0, 0x0F, 0xE6, 0xD2, 0x80, + 0x0E, 0x25, 0x60, 0x09, 0xF0, 0x00, 0x00, 0xE5, 0x60, 0x03, 0xA2, 0x8C, 0x91, 0xC7, 0x30, 0x13, 0xF0, 0x00, 0x00, 0xF1, 0x60, 0x00, 0xE6, 0x00, + 0x00, 0x53, 0x60, 0x00, 0xE2, 0x00, 0x0F, 0x64, 0x60, 0x09, 0xA2, 0x88, 0xF0, 0x00, 0x30, 0x10, 0xF0, 0x00, 0x82, 0x92, 0x0F, 0x63, 0x60, 0x09, + 0x00, 0x12, 0x60, 0x00, 0xF0, 0x00, 0xFF, 0xE0, 0x60, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x0F, 0x21, 0xD0, 0x80, 0xF0, 0x00, 0x08, 0x58, 0x60, 0x08, + 0x7F, 0xFF, 0x60, 0x03, 0xA2, 0x81, 0x33, 0x03, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x00, 0xE0, 0x60, 0x00, 0x0D, 0xD4, 0x60, 0x08, 0xA2, 0x7E, + 0xF0, 0x00, 0x30, 0x00, 0xF0, 0x00, 0x30, 0x80, 0x70, 0x00, 0xD0, 0x08, 0x08, 0x4C, 0x60, 0x09, 0xF0, 0x00, 0x82, 0x49, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x33, 0x11, 0xD0, 0x08, 0x00, 0x00, 0x60, 0x03, 0xA2, 0x78, 0x82, 0xD3, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x40, 0x70, 0x00, 0x94, 0x03, + 0x08, 0x96, 0x60, 0x04, 0xA2, 0x75, 0x91, 0x1D, 0x70, 0x00, 0xF0, 0x00, 0x91, 0x26, 0x70, 0x00, 0x80, 0x18, 0x00, 0x04, 0x60, 0x03, 0xA2, 0x72, + 0x82, 0xD3, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x03, 0x08, 0x4C, 0x60, 0x04, 0xA2, 0x6F, 0x93, 0x05, 0x70, 0x00, 0xF0, 0x00, + 0x93, 0x0E, 0x70, 0x00, 0x80, 0x12, 0x00, 0x20, 0x60, 0x03, 0xA2, 0x6C, 0x82, 0xD3, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x03, + 0x08, 0x65, 0x60, 0x04, 0xA2, 0x69, 0x91, 0x0D, 0x70, 0x00, 0xF0, 0x00, 0x91, 0x16, 0x70, 0x00, 0x80, 0x0C, 0x00, 0xE0, 0x60, 0x03, 0xA2, 0x66, + 0x82, 0xD3, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x03, 0x08, 0x96, 0x60, 0x04, 0xA2, 0x63, 0x91, 0x1D, 0x70, 0x00, 0xF0, 0x00, + 0x91, 0x26, 0x70, 0x00, 0x80, 0x06, 0x00, 0xF0, 0x60, 0x03, 0xA2, 0x60, 0x82, 0xD3, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, + 0x08, 0x56, 0x60, 0x0A, 0xA2, 0x5D, 0x20, 0x25, 0x70, 0x00, 0xF0, 0x00, 0x20, 0xA6, 0x70, 0x00, 0x80, 0x00, 0x00, 0x21, 0x60, 0x03, 0xA2, 0x5A, + 0x82, 0xC3, 0x0D, 0xD4, 0x60, 0x09, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x04, 0x08, 0x6F, 0x60, 0x08, 0xA2, 0x57, 0xF0, 0x00, 0x30, 0x12, 0xF0, 0x00, + 0xF0, 0x00, 0x33, 0x05, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x86, 0xD0, 0x08, 0x00, 0x80, 0x60, 0x03, 0xA2, 0x53, 0x82, 0xC3, 0x0D, 0xD4, 0x60, 0x09, + 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0x08, 0x58, 0x60, 0x08, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x92, 0xF0, 0x00, 0xF0, 0x00, 0x35, 0x05, 0xF0, 0x00, + 0xF0, 0x00, 0x35, 0x86, 0xD0, 0x08, 0x20, 0x16, 0x70, 0x00, 0x94, 0x03, 0x20, 0x97, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0xC6, 0xF0, 0x00, + 0xF0, 0x00, 0x34, 0x47, 0xF0, 0x00, 0x0D, 0xD4, 0x60, 0x09, 0xA2, 0x48, 0xF0, 0x00, 0x20, 0x11, 0xA2, 0x47, 0x82, 0x59, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0x94, 0x03, 0x08, 0x6F, 0x60, 0x08, 0xA2, 0x44, 0xF0, 0x00, 0x33, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x87, 0xF0, 0x00, + 0xF0, 0x00, 0x20, 0x91, 0xA2, 0x41, 0x82, 0x59, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0x08, 0x58, 0x60, 0x08, 0xA2, 0x3E, + 0xF0, 0x00, 0x35, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x35, 0x87, 0xD0, 0x08, 0x17, 0xCB, 0x60, 0x07, 0xF0, 0x00, 0x00, 0x07, 0x60, 0x01, 0xF0, 0x00, + 0x40, 0xD0, 0x70, 0x00, 0xA0, 0x0F, 0x18, 0x18, 0x60, 0x06, 0xF0, 0x00, 0x90, 0x40, 0x05, 0x9F, 0xD2, 0x80, 0x18, 0x22, 0x60, 0x06, 0xF0, 0x00, + 0xF0, 0x00, 0x05, 0x9F, 0xD2, 0x80, 0x18, 0x2C, 0x60, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x05, 0x9F, 0xD2, 0x80, 0x17, 0xDC, 0x60, 0x07, 0xF0, 0x00, + 0x00, 0x35, 0x60, 0x01, 0xF0, 0x00, 0x43, 0xB0, 0x70, 0x00, 0xA0, 0x06, 0x18, 0x1B, 0x60, 0x06, 0xF0, 0x00, 0x90, 0x40, 0x05, 0x9F, 0xD2, 0x80, + 0x18, 0x25, 0x60, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x05, 0x9F, 0xD2, 0x80, 0x18, 0x2F, 0x60, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x05, 0x9F, 0xD0, 0x80, + 0xD7, 0xCA, 0x00, 0xFF, 0x60, 0x04, 0x81, 0xD7, 0x0D, 0xCA, 0x60, 0x09, 0xD0, 0x56, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x76, 0x30, 0x17, 0xF0, 0x00, + 0xD0, 0xF6, 0x40, 0x83, 0xF0, 0x00, 0xC1, 0xA4, 0x20, 0x19, 0xF0, 0x00, 0x82, 0xF6, 0x70, 0x00, 0xF0, 0x00, 0xC1, 0x80, 0x20, 0x17, 0xA2, 0x22, + 0xC3, 0xE7, 0x70, 0x00, 0xF0, 0x00, 0xC5, 0xC7, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x17, 0xD0, 0x08, 0x39, 0x82, 0x60, 0x00, 0xA2, 0x1E, + 0x80, 0x08, 0x70, 0x00, 0xA2, 0x1D, 0x9F, 0xF3, 0x70, 0x00, 0xD0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x28, 0x50, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0x01, 0xF0, 0x00, 0x28, 0x4C, 0xD2, 0x80, 0xF0, 0x00, 0x26, 0x66, 0xD2, 0x80, 0x40, 0x10, 0x29, 0x19, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xA1, 0xEF, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x72, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x97, 0xF0, 0x00, 0x17, 0x84, 0xD2, 0x80, + 0xF0, 0x00, 0x2A, 0x1F, 0xD2, 0x80, 0x9F, 0xF3, 0x70, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x28, 0xAB, 0xD5, 0x80, 0xF0, 0x00, 0x28, 0xDE, 0xD0, 0x80, + 0xF0, 0x00, 0x06, 0x50, 0xD5, 0x80, 0xF0, 0x00, 0x26, 0x68, 0xD2, 0x80, 0x40, 0x10, 0x29, 0x19, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x68, + 0xF0, 0x00, 0x28, 0xDF, 0xD0, 0x80, 0xF0, 0x00, 0x06, 0x50, 0xD5, 0x80, 0xF0, 0x00, 0x26, 0x66, 0xD2, 0x80, 0x40, 0x10, 0x29, 0x19, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x63, 0xF0, 0x00, 0x28, 0xE0, 0xD0, 0x80, 0xF0, 0x00, 0x06, 0x50, 0xD5, 0x80, 0xF0, 0x00, 0x26, 0x68, 0xD2, 0x80, + 0x40, 0x10, 0x29, 0x19, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x5E, 0xF0, 0x00, 0x28, 0xE1, 0xD0, 0x80, 0xF0, 0x00, 0x06, 0x50, 0xD5, 0x80, + 0xF0, 0x00, 0x00, 0x08, 0x60, 0x00, 0xF0, 0x00, 0x28, 0x4F, 0xD2, 0x80, 0xF0, 0x00, 0x27, 0x8A, 0xD1, 0x80, 0xF0, 0x00, 0x26, 0x69, 0xD2, 0x80, + 0x90, 0x02, 0x26, 0x66, 0xD2, 0x80, 0xF0, 0x00, 0x27, 0x8A, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xDB, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xDB, + 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xDC, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xE6, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xEA, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xEE, + 0x40, 0x14, 0x06, 0x4E, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xF1, 0xF0, 0x00, 0x26, 0x6E, 0xD2, 0x80, 0x40, 0x10, 0x29, 0x19, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xA1, 0xC7, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x4A, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x6F, 0xF0, 0x00, 0x17, 0x84, 0xD2, 0x80, + 0xF0, 0x00, 0x06, 0x8E, 0xD0, 0x80, 0x42, 0x71, 0x16, 0xE0, 0xD2, 0x80, 0x00, 0x00, 0x60, 0x01, 0xF0, 0x00, 0x01, 0x90, 0x60, 0x02, 0xF0, 0x00, + 0xF0, 0x00, 0x20, 0xBB, 0xD2, 0x80, 0x40, 0x11, 0x20, 0xB7, 0xD0, 0x80, 0xF0, 0x00, 0x0D, 0xD7, 0x60, 0x0C, 0x23, 0x10, 0x60, 0x05, 0xA1, 0xE2, + 0x30, 0x45, 0x23, 0x16, 0x60, 0x03, 0xF0, 0x00, 0x41, 0x8E, 0x60, 0x04, 0x36, 0x33, 0x70, 0x00, 0xF0, 0x00, 0x36, 0xB4, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x1B, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x0A, 0x18, 0x60, 0x08, 0xFD, 0x40, 0x60, 0x00, 0xA1, 0xDB, 0x30, 0x00, 0x1B, 0xD5, 0xD0, 0x80, + 0x40, 0x50, 0x0C, 0xC0, 0x60, 0x08, 0x2B, 0x00, 0x60, 0x01, 0xF0, 0x00, 0x30, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x3B, 0x81, 0x23, 0x12, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0xCE, 0xF0, 0x00, 0x24, 0xEB, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x12, 0xF0, 0x00, 0x1C, 0x93, 0xD0, 0x80, + 0xB1, 0xE8, 0x26, 0x93, 0xF0, 0x00, 0xBA, 0x11, 0x2F, 0x92, 0xF0, 0x00, 0x82, 0x18, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0x10, 0x27, 0x14, 0xF0, 0x00, + 0x80, 0x18, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x61, 0x36, 0x90, 0xF0, 0x00, 0xA2, 0x51, 0x70, 0x00, 0xF0, 0x00, 0x80, 0x61, 0x09, 0xA9, 0x60, 0x08, + 0xF0, 0x00, 0x37, 0x11, 0xF0, 0x00, 0xF0, 0x00, 0x21, 0x98, 0xD2, 0x80, 0xF0, 0x00, 0x0A, 0x7B, 0x60, 0x08, 0xF0, 0x00, 0x23, 0xAA, 0xD2, 0x80, + 0x0A, 0x6B, 0x60, 0x08, 0xA0, 0x82, 0xF0, 0x00, 0x1C, 0xFE, 0xD0, 0x80, 0xF0, 0x00, 0x09, 0xC4, 0x60, 0x07, 0xF0, 0x00, 0x65, 0xC1, 0x60, 0x06, + 0xF0, 0x00, 0x1D, 0x64, 0xD0, 0x80, 0xF0, 0x00, 0x09, 0x26, 0x60, 0x0D, 0xF0, 0x00, 0x09, 0x2E, 0x60, 0x0E, 0xF0, 0x00, 0x0C, 0xA1, 0x60, 0x08, + 0xB0, 0x03, 0x04, 0xA8, 0x60, 0x0F, 0x22, 0x06, 0x0C, 0x78, 0x60, 0x0A, 0x24, 0x83, 0x0C, 0x80, 0x60, 0x0B, 0x91, 0x86, 0x00, 0x70, 0x40, 0x17, + 0x23, 0x89, 0x1E, 0x03, 0xD5, 0x80, 0x23, 0x01, 0x70, 0x00, 0xCD, 0x48, 0xA1, 0xD8, 0x00, 0x22, 0xF0, 0x00, 0x82, 0x0D, 0x70, 0x00, 0xF0, 0x00, + 0x86, 0x0F, 0x70, 0x00, 0xF0, 0x00, 0xA3, 0x7E, 0x70, 0x00, 0xF0, 0x00, 0x91, 0x40, 0x70, 0x00, 0x9C, 0x02, 0x91, 0xC7, 0x7F, 0xFF, 0x60, 0x05, + 0xF0, 0x00, 0x58, 0x05, 0xEA, 0x00, 0x90, 0x44, 0x70, 0x00, 0x58, 0x07, 0xA1, 0x51, 0x10, 0x60, 0xF0, 0x00, 0xA1, 0xCA, 0x7F, 0xFF, 0x60, 0x07, + 0xA8, 0xF3, 0x00, 0x32, 0xF0, 0x00, 0xC2, 0xFB, 0x1D, 0xF1, 0xD2, 0x80, 0xA2, 0x10, 0x10, 0x51, 0xF0, 0x00, 0x85, 0x07, 0x70, 0x00, 0x21, 0x06, + 0x81, 0x02, 0x70, 0x00, 0xF0, 0x00, 0x8F, 0xBD, 0x70, 0x00, 0x21, 0x84, 0x81, 0xB2, 0x70, 0x00, 0xE0, 0xC0, 0x8F, 0xE5, 0x00, 0x70, 0x40, 0x17, + 0x81, 0x22, 0x58, 0x06, 0xE0, 0xC0, 0x89, 0x12, 0x18, 0x12, 0xF0, 0x00, 0xB1, 0x92, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x1D, 0xE0, 0xD0, 0x80, + 0x40, 0x00, 0x09, 0xAD, 0x60, 0x08, 0x4F, 0xF1, 0x09, 0x86, 0x60, 0x09, 0xF0, 0x00, 0x31, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x3E, 0x91, 0x80, 0x87, + 0x7F, 0xFF, 0x60, 0x02, 0xE6, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x37, 0x12, 0x20, 0xB0, 0xD0, 0x80, 0x3C, 0x01, 0xC6, 0xA8, 0x60, 0x00, + 0x35, 0x01, 0x00, 0x48, 0x60, 0x05, 0xA0, 0x18, 0x70, 0x00, 0xF0, 0x00, 0xAB, 0xB0, 0x0C, 0x6E, 0x60, 0x09, 0x80, 0x28, 0x03, 0xE9, 0x60, 0x05, + 0xF0, 0x00, 0x33, 0x10, 0xF0, 0x00, 0x8F, 0x2D, 0x0C, 0x52, 0x60, 0x08, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x02, 0x40, 0x45, 0xB1, 0x5C, 0x60, 0x06, + 0x46, 0x66, 0x60, 0x07, 0x80, 0x02, 0x40, 0x65, 0xAA, 0xCE, 0x60, 0x06, 0xC6, 0x66, 0x60, 0x07, 0x80, 0x00, 0xA1, 0xA0, 0x70, 0x00, 0x43, 0x84, + 0xAF, 0x48, 0x70, 0x00, 0x41, 0xD5, 0xF0, 0x00, 0x21, 0x34, 0xD0, 0x80, 0xF0, 0x00, 0xBE, 0x77, 0x60, 0x03, 0xF0, 0x00, 0x4B, 0x00, 0x60, 0x04, + 0xA0, 0xD0, 0x70, 0x00, 0xF0, 0x00, 0xAA, 0x42, 0x70, 0x00, 0xF0, 0x00, 0x80, 0xA2, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x3B, 0x82, 0xD0, 0x08, + 0xF0, 0x00, 0x0C, 0xC0, 0x60, 0x0A, 0xF0, 0x00, 0xFF, 0xFF, 0x60, 0x04, 0xF0, 0x00, 0x2B, 0x00, 0x60, 0x05, 0x3C, 0x24, 0x0A, 0x7B, 0x60, 0x0B, + 0x3C, 0xA4, 0x06, 0x40, 0x60, 0x06, 0x3B, 0xA5, 0x0C, 0xAD, 0x60, 0x0C, 0x30, 0x36, 0x00, 0x04, 0x60, 0x07, 0xF0, 0x00, 0xAD, 0x84, 0x60, 0x06, + 0x32, 0x47, 0x00, 0x42, 0x60, 0x05, 0x32, 0xC6, 0x0B, 0x5E, 0x60, 0x04, 0x31, 0x45, 0x01, 0xFD, 0x60, 0x03, 0x31, 0xC4, 0x0C, 0x67, 0x60, 0x0D, + 0x33, 0x43, 0x03, 0xD7, 0x60, 0x00, 0xF0, 0x00, 0x4D, 0x78, 0x60, 0x01, 0x31, 0x50, 0xF6, 0xB4, 0x60, 0x02, 0x32, 0xD1, 0x0C, 0x59, 0x60, 0x0E, + 0x33, 0x52, 0x00, 0x05, 0x60, 0x03, 0x40, 0x17, 0x40, 0x02, 0x60, 0x04, 0x32, 0x63, 0xFF, 0xF8, 0x60, 0x05, 0x32, 0xE4, 0x0C, 0x6E, 0x60, 0x0F, + 0x33, 0x65, 0x00, 0xA4, 0x60, 0x00, 0x52, 0x06, 0xD9, 0x24, 0x60, 0x01, 0x31, 0x70, 0x00, 0x3A, 0x60, 0x02, 0x32, 0xF1, 0x0D, 0xD8, 0x60, 0x08, + 0x33, 0x72, 0x08, 0xD7, 0x60, 0x09, 0x30, 0x07, 0x7F, 0xFF, 0x60, 0x05, 0x33, 0x16, 0x0C, 0x3B, 0x60, 0x0A, 0x82, 0xDB, 0x35, 0x15, 0x40, 0x74, + 0xF0, 0x00, 0x1E, 0x7E, 0x60, 0x0B, 0xF0, 0x00, 0x3F, 0x24, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x33, 0xD0, 0x08, 0xF0, 0x00, 0x0D, 0xD6, 0x60, 0x09, + 0x91, 0xC7, 0x70, 0x00, 0xF0, 0x00, 0x20, 0x10, 0x22, 0x80, 0xE6, 0x40, 0xF0, 0x00, 0x21, 0xE3, 0xD0, 0x80, 0x20, 0x11, 0x0D, 0xD8, 0x60, 0x08, + 0xA2, 0x82, 0x09, 0xB5, 0x60, 0x0B, 0x20, 0x07, 0x2B, 0xFD, 0x60, 0x04, 0xF0, 0x00, 0xAD, 0x1D, 0x60, 0x05, 0x9F, 0xFB, 0x39, 0x1D, 0x60, 0x06, + 0x9F, 0xF3, 0x70, 0x00, 0x90, 0x04, 0x7F, 0xFF, 0x60, 0x03, 0x90, 0x0E, 0xA2, 0x41, 0x7F, 0xFF, 0x60, 0x03, 0xF0, 0x00, 0x30, 0x21, 0xF0, 0x00, + 0xF0, 0x00, 0x3F, 0xB3, 0xD0, 0x08, 0xA3, 0x0B, 0x30, 0x22, 0xF0, 0x00, 0xA2, 0x4A, 0x70, 0x00, 0xF0, 0x00, 0xA3, 0x50, 0x70, 0x00, 0xF0, 0x00, + 0x80, 0xC3, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0x8A, 0x70, 0x00, 0xF0, 0x00, 0xA3, 0x90, 0xFD, 0x95, 0x60, 0x07, 0x80, 0xC3, 0x07, 0xFF, 0x60, 0x04, + 0x80, 0xFB, 0x70, 0x00, 0xF0, 0x00, 0x8A, 0xE3, 0x70, 0x00, 0xF0, 0x00, 0xD9, 0x1B, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x3F, 0xB3, 0xD0, 0x08, + 0x30, 0x22, 0x69, 0x25, 0x60, 0x04, 0x3F, 0xB3, 0xF8, 0x0A, 0x60, 0x05, 0xA1, 0x08, 0x70, 0x00, 0xF0, 0x00, 0xAA, 0x14, 0x70, 0x00, 0xF0, 0x00, + 0x81, 0x2C, 0x09, 0x36, 0x60, 0x0C, 0xA3, 0x04, 0x09, 0x3D, 0x60, 0x0D, 0x90, 0x04, 0x70, 0x00, 0xE1, 0x40, 0xF0, 0x00, 0x32, 0xC4, 0xF0, 0x00, + 0xF0, 0x00, 0x32, 0xD4, 0xD0, 0x08, 0x0D, 0xD8, 0x60, 0x08, 0xA1, 0x44, 0xF0, 0x00, 0x30, 0x01, 0xD0, 0x08, 0xF0, 0x00, 0x0D, 0xD7, 0x60, 0x0F, + 0xF0, 0x00, 0x09, 0x22, 0x60, 0x0E, 0x20, 0x7C, 0x0A, 0x6B, 0x60, 0x08, 0x20, 0x60, 0x70, 0x00, 0xF0, 0x00, 0x20, 0xE1, 0x70, 0x00, 0xF0, 0x00, + 0x26, 0x09, 0x1B, 0x33, 0x60, 0x0A, 0x18, 0x40, 0x70, 0x00, 0xF0, 0x00, 0x18, 0x41, 0x70, 0x00, 0xF0, 0x00, 0xA0, 0x03, 0x00, 0x21, 0x08, 0x10, + 0x00, 0x21, 0x08, 0x10, 0xC0, 0x0A, 0xA0, 0x09, 0x00, 0x21, 0x08, 0x10, 0xA0, 0x09, 0x30, 0x7C, 0xF0, 0x00, 0xA4, 0x0A, 0x7A, 0x9D, 0xF0, 0x00, + 0xF0, 0x00, 0x36, 0x09, 0xF0, 0x00, 0x26, 0x89, 0x1B, 0x33, 0x60, 0x0A, 0xF0, 0x00, 0x37, 0x02, 0xF0, 0x00, 0xA0, 0x03, 0x00, 0x21, 0x08, 0x10, + 0x00, 0x21, 0x08, 0x10, 0xC0, 0x0A, 0xA0, 0x09, 0x00, 0x21, 0x08, 0x10, 0xA0, 0x09, 0x7B, 0x9D, 0xF0, 0x00, 0xA4, 0x0A, 0x7A, 0x9D, 0xF0, 0x00, + 0xF0, 0x00, 0x36, 0x89, 0xF0, 0x00, 0x37, 0x82, 0x23, 0x84, 0xD0, 0x80, 0xF0, 0x00, 0x0C, 0x52, 0x60, 0x08, 0xF0, 0x00, 0x1E, 0x7E, 0x60, 0x0F, + 0x22, 0x80, 0x0C, 0x6E, 0x60, 0x09, 0x23, 0x01, 0x0C, 0x67, 0x60, 0x0A, 0x22, 0x92, 0x0C, 0x4B, 0x60, 0x0B, 0x23, 0x13, 0x30, 0xF0, 0xF0, 0x00, + 0x21, 0x24, 0x31, 0x71, 0xF0, 0x00, 0x21, 0xA5, 0x31, 0xF2, 0xF0, 0x00, 0x21, 0x36, 0x32, 0x73, 0xF0, 0x00, 0x21, 0xB7, 0x32, 0xF4, 0xF0, 0x00, + 0x33, 0x75, 0x00, 0x00, 0x60, 0x00, 0x33, 0xF6, 0x60, 0x00, 0x60, 0x01, 0x34, 0x77, 0xC0, 0xA4, 0x60, 0x02, 0x32, 0x80, 0x00, 0xF5, 0x60, 0x03, + 0x33, 0x01, 0x07, 0x00, 0x60, 0x04, 0x32, 0x92, 0x07, 0x10, 0x60, 0x05, 0x33, 0x13, 0x07, 0x00, 0x60, 0x06, 0x31, 0x24, 0x07, 0x10, 0x60, 0x07, + 0x31, 0xA5, 0x40, 0x10, 0xF0, 0x00, 0x31, 0x36, 0x70, 0x00, 0xF0, 0x00, 0x31, 0xB7, 0x30, 0x70, 0xD0, 0x08, 0xF0, 0x00, 0x1E, 0x7E, 0x60, 0x0F, + 0xF0, 0x00, 0x0C, 0x52, 0x60, 0x08, 0x20, 0x77, 0x0C, 0x6E, 0x60, 0x09, 0x20, 0xF0, 0x0C, 0x67, 0x60, 0x0A, 0x91, 0xC7, 0x0C, 0x4B, 0x60, 0x0B, + 0x21, 0x71, 0x70, 0x00, 0xD0, 0x09, 0x21, 0xF2, 0x32, 0x80, 0xF0, 0x00, 0x22, 0x73, 0x33, 0x01, 0xF0, 0x00, 0x22, 0xF4, 0x32, 0x92, 0xF0, 0x00, + 0x23, 0x75, 0x33, 0x13, 0xF0, 0x00, 0x23, 0xF6, 0x31, 0x24, 0xF0, 0x00, 0x24, 0x77, 0x31, 0xA5, 0xF0, 0x00, 0x82, 0x00, 0x31, 0x36, 0xF0, 0x00, + 0x30, 0x70, 0x31, 0xB7, 0xD0, 0x08, 0x0D, 0xD6, 0x60, 0x08, 0xA1, 0x08, 0xF0, 0x00, 0x30, 0x07, 0xD0, 0x08, 0xF0, 0x00, 0x0C, 0x4B, 0x60, 0x08, + 0xF0, 0x00, 0x00, 0xE5, 0x60, 0x00, 0xF0, 0x00, 0x00, 0x04, 0x60, 0x02, 0x31, 0x00, 0x55, 0xE9, 0x60, 0x03, 0x32, 0x02, 0xF6, 0x65, 0x60, 0x04, + 0x32, 0x83, 0x0C, 0x52, 0x60, 0x09, 0x33, 0x04, 0x00, 0x1D, 0x60, 0x00, 0xF0, 0x00, 0x00, 0x38, 0x60, 0x01, 0x31, 0x10, 0x00, 0x0B, 0x60, 0x02, + 0x31, 0x91, 0x28, 0x4A, 0x60, 0x03, 0x32, 0x12, 0xD6, 0xF9, 0x60, 0x04, 0x32, 0x93, 0x70, 0x00, 0xF0, 0x00, 0x33, 0x14, 0x70, 0x00, 0xD0, 0x08, + 0x40, 0x66, 0x0C, 0xD8, 0x60, 0x08, 0x40, 0xA7, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0x87, 0xD0, 0x08, + 0x22, 0x93, 0x25, 0x36, 0xD2, 0x80, 0xF0, 0x00, 0x25, 0x66, 0xD2, 0x80, 0xF0, 0x00, 0x25, 0x5E, 0xD0, 0x80, 0x22, 0x13, 0x25, 0x36, 0xD2, 0x80, + 0xF0, 0x00, 0x25, 0x66, 0xD0, 0x80, 0xF0, 0x00, 0x40, 0x11, 0x40, 0x60, 0xF0, 0x00, 0x40, 0xF3, 0x40, 0x12, 0x40, 0x64, 0x0C, 0xD8, 0x60, 0x08, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0x04, 0xF0, 0x00, 0x40, 0x11, 0x40, 0x60, 0xF0, 0x00, 0x40, 0xA3, 0x40, 0x12, 0x40, 0x44, 0x0C, 0xD8, 0x60, 0x08, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0x00, 0xF0, 0x00, 0x33, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x81, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x02, 0xF0, 0x00, + 0xF0, 0x00, 0x31, 0x83, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0x04, 0xD0, 0x08, 0x40, 0x20, 0x05, 0x10, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xF5, + 0x40, 0x30, 0x05, 0x10, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xEF, 0x40, 0x30, 0x0D, 0x2F, 0x60, 0x08, 0xF0, 0x00, 0x27, 0x12, 0x60, 0x01, + 0x10, 0x00, 0x00, 0x24, 0x60, 0x00, 0x10, 0x01, 0x27, 0x11, 0x60, 0x01, 0x10, 0x00, 0x00, 0x14, 0x60, 0x00, 0x10, 0x01, 0x0D, 0x1F, 0x60, 0x09, + 0x10, 0x00, 0x3A, 0xC9, 0x60, 0x02, 0xF0, 0x00, 0x3A, 0xD3, 0x60, 0x03, 0x31, 0x92, 0x0D, 0xD9, 0x60, 0x08, 0x34, 0x93, 0x22, 0x04, 0x60, 0x00, + 0xF0, 0x00, 0x10, 0x10, 0x60, 0x01, 0x30, 0x00, 0x0D, 0xDB, 0x60, 0x09, 0x30, 0x81, 0x22, 0x04, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x10, 0x60, 0x01, + 0x30, 0x10, 0x0D, 0x13, 0x60, 0x08, 0x30, 0x91, 0x3A, 0xC1, 0x60, 0x00, 0xF0, 0x00, 0x3A, 0xC4, 0x60, 0x01, 0x30, 0x80, 0x00, 0x00, 0x60, 0x00, + 0x31, 0x81, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x80, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x04, 0x55, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xA7, 0xF0, 0x00, 0x27, 0x2A, 0xD0, 0x80, 0xF0, 0x00, 0x24, 0x3A, 0xD2, 0x80, 0xF0, 0x00, 0x25, 0x2A, 0xD2, 0x80, + 0xF0, 0x00, 0x27, 0x40, 0xD0, 0x80, 0xF0, 0x00, 0x08, 0x9D, 0xD2, 0x80, 0x3A, 0xB8, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x26, 0x60, 0xD0, 0x80, + 0x40, 0x11, 0x13, 0xE7, 0xD2, 0x80, 0x27, 0x55, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x26, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x1B, 0xFA, 0xD2, 0x80, + 0x3A, 0xBE, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x11, 0x26, 0x60, 0xD0, 0x80, 0x40, 0x11, 0x13, 0xE7, 0xD2, 0x80, 0xF0, 0x00, 0x27, 0xA5, 0x60, 0x00, + 0xF0, 0x00, 0x26, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x27, 0xAA, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x8B, 0xF0, 0x00, 0x25, 0x5E, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0x8F, 0x9E, 0x3A, 0xC7, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x26, 0x55, 0xD0, 0x80, 0x27, 0xE7, 0x60, 0x00, 0xF0, 0x00, + 0x40, 0x11, 0x26, 0x60, 0xD0, 0x80, 0xF0, 0x00, 0x25, 0x2E, 0xD2, 0x80, 0xF0, 0x00, 0x1C, 0x13, 0xD2, 0x80, 0xF0, 0x00, 0x24, 0x39, 0xD2, 0x80, + 0xF0, 0x00, 0x1B, 0x75, 0xD2, 0x80, 0xF0, 0x00, 0x1F, 0x99, 0xD2, 0x80, 0xF0, 0x00, 0x0F, 0x89, 0xD2, 0x80, 0xF0, 0x00, 0x26, 0x8A, 0xD0, 0x80, + 0xF0, 0x00, 0x25, 0x2A, 0xD2, 0x80, 0xF0, 0x00, 0x24, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x28, 0x1A, 0xD0, 0x80, 0xF0, 0x00, 0x25, 0x2E, 0xD2, 0x80, + 0xF0, 0x00, 0x1C, 0x13, 0xD2, 0x80, 0xF0, 0x00, 0x24, 0x39, 0xD2, 0x80, 0xF0, 0x00, 0x1B, 0x75, 0xD2, 0x80, 0xF0, 0x00, 0x1F, 0x99, 0xD2, 0x80, + 0xF0, 0x00, 0x0F, 0x89, 0xD2, 0x80, 0xF0, 0x00, 0x26, 0x8A, 0xD0, 0x80, 0xF0, 0x00, 0x25, 0x2A, 0xD2, 0x80, 0xF0, 0x00, 0x24, 0xE0, 0xD2, 0x80, + 0xF0, 0x00, 0x28, 0x42, 0xD0, 0x80, 0x0D, 0xD9, 0x60, 0x08, 0xA0, 0x9C, 0xF0, 0x00, 0x20, 0x04, 0xF0, 0x00, 0x20, 0x85, 0x70, 0x00, 0xAD, 0xDC, + 0xF0, 0x00, 0x12, 0x40, 0xD0, 0x80, 0x40, 0xA7, 0x41, 0x17, 0xE6, 0x40, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x8E, 0xF0, 0x00, 0x25, 0x49, 0xD2, 0x80, + 0xF0, 0x00, 0x0E, 0xB8, 0xD2, 0x80, 0xF0, 0x00, 0x21, 0xE8, 0xD5, 0x80, 0xF0, 0x00, 0x21, 0xE6, 0xD0, 0x80, 0x0D, 0xDB, 0x60, 0x08, 0xA0, 0x92, + 0xF0, 0x00, 0x20, 0x04, 0xF0, 0x00, 0x20, 0x85, 0x70, 0x00, 0xAD, 0xD2, 0xF0, 0x00, 0x12, 0x40, 0xD0, 0x80, 0xF0, 0x00, 0x21, 0x00, 0xA0, 0x8E, + 0x90, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x0E, 0x8A, 0xD5, 0x80, 0xF0, 0x00, 0x0E, 0x88, 0xD0, 0x80, 0x0D, 0xD9, 0x60, 0x08, 0xA0, 0x03, + 0x4F, 0xF1, 0x28, 0x5D, 0xD0, 0x80, 0x0D, 0xDB, 0x60, 0x08, 0xA0, 0x01, 0x4F, 0xF1, 0x28, 0x73, 0xD0, 0x80, 0x9F, 0xAE, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0xF0, 0x00, 0x30, 0x02, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x83, 0xD0, 0x08, 0xF0, 0x00, 0x25, 0xC1, 0xD2, 0x80, + 0xF0, 0x00, 0x28, 0xC2, 0xD0, 0x80, 0x0D, 0x7F, 0x60, 0x08, 0xF0, 0x00, 0x02, 0x9D, 0x60, 0x00, 0xA0, 0x7F, 0xF0, 0x00, 0x30, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x04, 0x24, 0xD0, 0x80, 0xF0, 0x00, 0x0D, 0x5D, 0x60, 0x08, 0xF0, 0x00, 0x00, 0x73, 0x60, 0x00, 0xF0, 0x00, 0x00, 0xE1, 0x60, 0x01, + 0xF0, 0x00, 0x39, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x39, 0x81, 0xD0, 0x08, 0xF0, 0x00, 0x00, 0x2C, 0xD2, 0x80, 0xAB, 0xF8, 0x2B, 0x30, 0xF0, 0x00, + 0xAA, 0x86, 0x00, 0x2C, 0xD2, 0x80, 0xAB, 0xF8, 0x33, 0xB6, 0xF0, 0x00, 0xAB, 0x98, 0x00, 0x3A, 0xD2, 0x80, 0x34, 0x21, 0x34, 0x10, 0xF0, 0x00, + 0xF0, 0x00, 0x2C, 0xB0, 0xA0, 0x71, 0xD0, 0x41, 0x70, 0x00, 0x80, 0x0E, 0x40, 0xF0, 0x02, 0xAB, 0xD2, 0x80, 0x40, 0xB0, 0x02, 0xA8, 0xD2, 0x80, + 0xF0, 0x00, 0x01, 0x47, 0xD0, 0x80, 0x40, 0x02, 0x0E, 0x8B, 0x60, 0x08, 0xFF, 0xC0, 0x60, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x02, 0xA4, 0xD2, 0x80, + 0xF0, 0x00, 0x0E, 0x8C, 0x60, 0x08, 0x00, 0x03, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x02, 0xA8, 0xD2, 0x80, 0xF0, 0x00, 0x0E, 0x9B, 0x60, 0x08, + 0x82, 0x00, 0x02, 0xA2, 0xD2, 0x80, 0xF0, 0x00, 0x2C, 0xB1, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x01, 0xF0, 0x00, 0x01, 0x79, 0xD0, 0x80, + 0x90, 0x40, 0x01, 0x85, 0xD0, 0x80, 0xF0, 0x00, 0x0E, 0xBA, 0xD2, 0x80, 0x05, 0x00, 0x60, 0x09, 0xD0, 0x09, 0x1D, 0x91, 0x60, 0x0A, 0xF0, 0x00, + 0x0B, 0x60, 0x60, 0x01, 0xF0, 0x00, 0x5B, 0x06, 0x60, 0x02, 0xA0, 0x5C, 0x32, 0x22, 0x32, 0x11, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x01, 0xF0, 0x00, + 0x59, 0xD8, 0x60, 0x02, 0xF0, 0x00, 0x82, 0x00, 0x0D, 0xDD, 0x60, 0x08, 0x30, 0x22, 0x30, 0x11, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x00, 0xD0, 0x08, + 0x0D, 0xDD, 0x60, 0x0B, 0xA0, 0x06, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x03, 0x0D, 0xDE, 0x60, 0x0B, 0xA0, 0x04, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x01, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0x05, 0xF0, 0x00, 0x03, 0x42, 0xD2, 0x80, 0x21, 0xC6, 0x03, 0x3B, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x20, 0x36, 0xA0, 0x4D, 0x91, 0x86, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x00, 0x40, 0xD2, 0x80, 0xF0, 0x00, 0x03, 0x2E, 0xD0, 0x80, + 0xF0, 0x00, 0x1C, 0x6C, 0x60, 0x08, 0xF0, 0x00, 0x26, 0xC1, 0xF0, 0x00, 0xF0, 0x00, 0x00, 0x02, 0xA0, 0x47, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, + 0x82, 0x8A, 0x70, 0x00, 0x90, 0x03, 0x90, 0x8A, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, 0x82, 0x80, 0x70, 0x00, 0xF0, 0x00, + 0x1C, 0x9B, 0x60, 0x08, 0xA0, 0x41, 0xF0, 0x00, 0x00, 0x02, 0xA0, 0x40, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x8A, 0x40, 0x07, 0x90, 0x02, + 0xF0, 0x00, 0x40, 0x17, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, 0xF0, 0x00, 0x70, 0x00, 0x8D, 0x22, 0xF0, 0x00, 0x1C, 0xA8, 0x60, 0x0D, + 0xF0, 0x00, 0x21, 0x40, 0xF0, 0x00, 0xF0, 0x00, 0x00, 0x51, 0xA0, 0x38, 0x90, 0x41, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x41, 0x40, 0x07, 0x90, 0x02, + 0xF0, 0x00, 0x40, 0x17, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, 0xF0, 0x00, 0x70, 0x00, 0xAD, 0x1A, 0x4F, 0xF6, 0x24, 0xC2, 0x60, 0x01, + 0x40, 0x03, 0x0D, 0xDE, 0x60, 0x0B, 0x82, 0x09, 0x3F, 0xFF, 0x60, 0x02, 0x40, 0x05, 0x44, 0x03, 0xE2, 0x00, 0x40, 0x17, 0x1C, 0x8C, 0x60, 0x0D, + 0x30, 0x33, 0x70, 0x00, 0xF0, 0x00, 0x9F, 0x7D, 0x00, 0x51, 0xA0, 0x2C, 0xC2, 0x53, 0x70, 0x00, 0xF0, 0x00, 0x82, 0xC4, 0x03, 0x7C, 0xD1, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0x97, 0xFC, 0x91, 0x46, 0x03, 0x80, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x93, 0x9C, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0x9D, + 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xA4, 0x0D, 0xDD, 0x60, 0x08, 0xA0, 0x24, 0xF0, 0x00, 0x30, 0x02, 0xD0, 0x08, 0xF0, 0x00, 0x03, 0xBC, 0xD0, 0x80, + 0xF0, 0x00, 0x2A, 0x3A, 0xD2, 0x80, 0xF0, 0x00, 0x3B, 0x7B, 0xD2, 0x80, 0xF0, 0x00, 0x29, 0xA4, 0xD0, 0x80, 0xF0, 0x00, 0x00, 0xA4, 0x60, 0x00, + 0x0E, 0x91, 0x60, 0x08, 0xA0, 0x1B, 0xF0, 0x00, 0x03, 0xA1, 0x60, 0x00, 0x0E, 0x23, 0x60, 0x08, 0xA0, 0x19, 0xF0, 0x00, 0x01, 0x80, 0x60, 0x00, + 0x0E, 0x9B, 0x60, 0x08, 0xA0, 0x17, 0x41, 0x40, 0x29, 0xFD, 0xD2, 0x80, 0xF0, 0x00, 0x00, 0x08, 0x60, 0x00, 0x0F, 0xE6, 0x60, 0x08, 0xA0, 0x14, + 0xF0, 0x00, 0x01, 0x04, 0x60, 0x00, 0xF0, 0x00, 0x29, 0xFD, 0xD2, 0x80, 0x0F, 0xE6, 0x60, 0x08, 0xA0, 0x12, 0x90, 0x00, 0x0D, 0xCA, 0x60, 0x09, + 0xF0, 0x00, 0x70, 0x00, 0x97, 0xFB, 0x0F, 0xE5, 0x60, 0x08, 0xA0, 0x0F, 0x90, 0x04, 0x30, 0x10, 0xF0, 0x00, 0x0F, 0xE4, 0x60, 0x08, 0xA0, 0x0D, + 0x90, 0x05, 0x30, 0x90, 0xF0, 0x00, 0x91, 0x01, 0x01, 0x4A, 0x60, 0x00, 0x91, 0x42, 0x29, 0xFC, 0xD5, 0x80, 0x83, 0x42, 0x70, 0x00, 0x93, 0xF2, + 0xF0, 0x00, 0x29, 0xFC, 0xD9, 0x80, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x0E, 0x9B, 0x60, 0x08, 0xA0, 0x05, 0xF0, 0x00, 0x00, 0x92, 0x60, 0x00, + 0x0E, 0x91, 0x60, 0x08, 0xA0, 0x03, 0xF0, 0x00, 0x00, 0xCF, 0x60, 0x00, 0x0E, 0x6A, 0x60, 0x08, 0xA0, 0x01, 0xF0, 0x00, 0x29, 0xE1, 0xD0, 0x80, + 0xF0, 0x00, 0x2A, 0x02, 0xD0, 0x80, 0xF0, 0x00, 0x2A, 0x0B, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x1C, 0x6C, 0x60, 0x08, + 0xF0, 0x00, 0x01, 0xCC, 0x60, 0x00, 0xF0, 0x00, 0x01, 0xCD, 0x60, 0x00, 0x10, 0x00, 0x01, 0xE1, 0x60, 0x00, 0x10, 0x00, 0x01, 0xEA, 0x60, 0x00, + 0x10, 0x00, 0x01, 0xEB, 0x60, 0x00, 0x10, 0x00, 0x01, 0xF5, 0x60, 0x00, 0x10, 0x00, 0x02, 0xA9, 0x60, 0x00, 0x10, 0x00, 0x02, 0xF4, 0x60, 0x00, + 0x10, 0x00, 0x02, 0xF5, 0x60, 0x00, 0x10, 0x00, 0x03, 0x01, 0x60, 0x00, 0x10, 0x00, 0x03, 0x02, 0x60, 0x00, 0x10, 0x00, 0x03, 0x4F, 0x60, 0x00, + 0x10, 0x00, 0x03, 0x66, 0x60, 0x00, 0x10, 0x00, 0x03, 0x9B, 0x60, 0x00, 0x10, 0x00, 0x03, 0xFD, 0x60, 0x00, 0x10, 0x00, 0x04, 0x6E, 0x60, 0x00, + 0x10, 0x00, 0x04, 0x6F, 0x60, 0x00, 0x10, 0x00, 0x04, 0xBA, 0x60, 0x00, 0x10, 0x00, 0x05, 0x06, 0x60, 0x00, 0x10, 0x00, 0x05, 0x1C, 0x60, 0x00, + 0x10, 0x00, 0x06, 0x9D, 0x60, 0x00, 0x10, 0x00, 0x07, 0x29, 0x60, 0x00, 0x10, 0x00, 0x07, 0xAB, 0x60, 0x00, 0x10, 0x00, 0x07, 0xAC, 0x60, 0x00, + 0x10, 0x00, 0x08, 0x6E, 0x60, 0x00, 0x10, 0x00, 0x09, 0xB7, 0x60, 0x00, 0x10, 0x00, 0x0A, 0x17, 0x60, 0x00, 0x10, 0x00, 0x0A, 0x3A, 0x60, 0x00, + 0x10, 0x00, 0x0A, 0x9F, 0x60, 0x00, 0x10, 0x00, 0x0A, 0xBD, 0x60, 0x00, 0x10, 0x00, 0x0B, 0x27, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x1C, 0x8C, 0x60, 0x08, 0xF0, 0x00, 0x43, 0xCA, 0x60, 0x00, + 0xF0, 0x00, 0x46, 0x68, 0x60, 0x00, 0x10, 0x00, 0x9E, 0x64, 0x60, 0x00, 0x10, 0x00, 0xA0, 0x6C, 0x60, 0x00, 0x10, 0x00, 0x21, 0xC5, 0x60, 0x00, + 0x10, 0x00, 0xA4, 0xC2, 0x60, 0x00, 0x10, 0x00, 0xE6, 0xC0, 0x60, 0x00, 0x10, 0x00, 0xE6, 0xC5, 0x60, 0x00, 0x10, 0x00, 0xA8, 0x41, 0x60, 0x00, + 0x10, 0x00, 0xA8, 0x55, 0x60, 0x00, 0x10, 0x00, 0xA8, 0x5A, 0x60, 0x00, 0x10, 0x00, 0x28, 0xDC, 0x60, 0x00, 0x10, 0x00, 0x29, 0x9A, 0x60, 0x00, + 0x10, 0x00, 0x29, 0xA9, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x1C, 0x9B, 0x60, 0x08, 0xF0, 0x00, 0x01, 0xEC, 0x60, 0x00, 0xF0, 0x00, 0x02, 0x12, 0x60, 0x00, 0x10, 0x00, 0x02, 0x41, 0x60, 0x00, + 0x10, 0x00, 0x02, 0x5D, 0x60, 0x00, 0x10, 0x00, 0x02, 0x8E, 0x60, 0x00, 0x10, 0x00, 0x02, 0xDB, 0x60, 0x00, 0x10, 0x00, 0x03, 0x9C, 0x60, 0x00, + 0x10, 0x00, 0x03, 0xC2, 0x60, 0x00, 0x10, 0x00, 0x04, 0x82, 0x60, 0x00, 0x10, 0x00, 0x05, 0x51, 0x60, 0x00, 0x10, 0x00, 0x05, 0x52, 0x60, 0x00, + 0x10, 0x00, 0x06, 0xCC, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x1C, 0xA8, 0x60, 0x08, 0xF0, 0x00, 0x02, 0xF2, 0x60, 0x00, 0xF0, 0x00, 0x02, 0xF3, 0x60, 0x00, 0x10, 0x00, 0x02, 0xF4, 0x60, 0x00, + 0x10, 0x00, 0x02, 0xF5, 0x60, 0x00, 0x10, 0x00, 0x02, 0xF6, 0x60, 0x00, 0x10, 0x00, 0x02, 0xF7, 0x60, 0x00, 0x10, 0x00, 0x02, 0xF8, 0x60, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08 +}; + +const size_t PatchSize101 = sizeof(PatchByteValues101); +const unsigned char * pPatchBytes101 = &PatchByteValues101[0]; + +extern const size_t LutSize101; +extern const unsigned char * pLutBytes101; +static unsigned char LutByteValues101[] = +{ + 0x40, 0x13, 0x46, 0xEA, 0x47, 0x07, 0x48, 0x2E, + 0x48, 0x4D, 0x4C, 0x45, 0x4D, 0x20, 0x4F, 0x78, + 0x50, 0x33, 0x53, 0xC7, 0x54, 0x0F, 0x54, 0x10, + 0x45, 0xF8, 0x46, 0x23, 0x46, 0x2F, 0x46, 0x73, + 0x46, 0x8D, 0x56, 0xA0, 0x59, 0x6D, 0x5B, 0xD0, + 0x5C, 0x92, 0x5C, 0xF7, 0x5D, 0x62, 0x60, 0xAF, + 0x61, 0x26, 0x61, 0x4A, 0x61, 0x9F, 0x61, 0xE0, + 0x61, 0xED, 0x65, 0x19, 0x65, 0x29, 0x65, 0x30, + 0x65, 0x34, 0x66, 0x02, 0x66, 0x20, 0x67, 0x29, + 0x67, 0x3F, 0x67, 0x52, 0x67, 0xA2, 0x67, 0xE6, + 0x68, 0x19, 0x68, 0x41, 0x68, 0x6A, 0x68, 0x6C, + 0x68, 0x80, 0x68, 0x8C, 0x68, 0xBB, 0x40, 0xF4, + 0x41, 0x46, 0x41, 0x74, 0x42, 0xE0, 0x42, 0xEB, + 0x43, 0x2D, 0x43, 0x75, 0x43, 0x7A, 0x43, 0xCE, + 0x69, 0xA3, 0x69, 0xC0 +}; + +const size_t LutSize101 = sizeof(LutByteValues101); +const unsigned char *pLutBytes101 = &LutByteValues101[0]; diff --git a/src/Tuner_Patch_Lithio_V102_p224.h b/src/Tuner_Patch_Lithio_V102_p224.h new file mode 100644 index 0000000..139a1d7 --- /dev/null +++ b/src/Tuner_Patch_Lithio_V102_p224.h @@ -0,0 +1,287 @@ +extern const size_t PatchSize102; +extern const unsigned char *pPatchBytes102; +static const unsigned char PatchByteValues102[] = +{ + 0xF0, 0x00, 0x38, 0x3B, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x43, 0xD0, 0x80, 0x43, 0xB2, 0x38, 0x46, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xC2, 0xF7, + 0xF0, 0x00, 0x38, 0x77, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x7B, 0xDF, 0x80, 0x80, 0xFC, 0x39, 0x0E, 0xD0, 0x80, 0xC2, 0x38, 0x20, 0x11, 0x40, 0xB7, + 0x9F, 0xA7, 0x39, 0x13, 0xD2, 0x80, 0x9F, 0xA7, 0x39, 0x1D, 0xD2, 0x80, 0xF0, 0x00, 0x39, 0x24, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x27, 0xD0, 0x80, + 0x90, 0x41, 0x39, 0x49, 0xDD, 0x80, 0xF0, 0x00, 0x3A, 0x25, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x4D, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x27, 0xD0, 0x80, + 0xC4, 0xA2, 0x02, 0x18, 0x60, 0x04, 0xF0, 0x00, 0x39, 0xBF, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0xE7, 0xD0, 0x80, 0x90, 0x01, 0x39, 0x4F, 0xD0, 0x80, + 0xF0, 0x00, 0x38, 0xF0, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x56, 0xD2, 0x80, 0xF0, 0x00, 0x39, 0x5A, 0xD0, 0x80, 0x43, 0x84, 0x39, 0x64, 0xD0, 0x80, + 0xF0, 0x00, 0x39, 0x67, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x6B, 0xD0, 0x80, 0x78, 0x4D, 0x39, 0x71, 0xD0, 0x80, 0x9E, 0x30, 0x18, 0xF9, 0xD2, 0x80, + 0xF0, 0x00, 0x39, 0x76, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x79, 0xD0, 0x80, 0x30, 0x77, 0x39, 0xDE, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x7C, 0xD0, 0x80, + 0x32, 0x00, 0x39, 0x7E, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x80, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0xC7, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0xF5, 0xD0, 0x80, + 0xA8, 0x01, 0x3A, 0x13, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x32, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x39, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x3B, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0x4F, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x52, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x3A, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x3A, 0x5D, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0x1E, 0xD2, 0x80, + 0xF0, 0x00, 0x3A, 0x6B, 0xD0, 0x80, 0x00, 0x43, 0x3A, 0x7A, 0xD9, 0x80, 0xF0, 0x00, 0x3A, 0x84, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xDA, 0xD0, 0x80, + 0xF0, 0x00, 0x3A, 0xDD, 0xD0, 0x80, 0xF0, 0x00, 0x3A, 0xEE, 0xD0, 0x80, 0x2E, 0x40, 0x3B, 0x8C, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x96, 0xD0, 0x80, + 0xF0, 0x00, 0x0E, 0x3F, 0x60, 0x00, 0x50, 0x10, 0x28, 0xD8, 0xD2, 0x80, 0x91, 0x01, 0x01, 0x36, 0x60, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x18, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xCC, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xED, 0xF0, 0x00, 0x70, 0x00, 0xA1, 0xAE, 0xF0, 0x00, 0x70, 0x00, 0xA2, 0x02, + 0xF0, 0x00, 0x70, 0x00, 0xA2, 0x2D, 0xF0, 0x00, 0x70, 0x00, 0xA2, 0x45, 0xF0, 0x00, 0x20, 0x31, 0xD0, 0x80, 0xF0, 0x00, 0x04, 0xC1, 0x60, 0x08, + 0xF0, 0x00, 0x01, 0x01, 0xD2, 0x80, 0xF0, 0x00, 0x00, 0x30, 0xD0, 0x80, 0x00, 0x7F, 0x60, 0x02, 0xE2, 0x00, 0xF0, 0x00, 0x0E, 0x22, 0x60, 0x0A, + 0xF0, 0x00, 0x00, 0xFF, 0x60, 0x03, 0xF0, 0x00, 0x01, 0x42, 0xD2, 0x80, 0x90, 0x03, 0x40, 0x02, 0xF0, 0x00, 0x90, 0x43, 0x01, 0x70, 0xD1, 0x80, + 0xF0, 0x00, 0x01, 0x69, 0xD0, 0x80, 0x0E, 0x69, 0x60, 0x0A, 0xA3, 0x4C, 0x20, 0x23, 0x00, 0x01, 0x60, 0x01, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xC4, 0xCB, 0x70, 0x00, 0xF0, 0x00, 0xCA, 0x09, 0x30, 0x23, 0xF0, 0x00, 0xC2, 0xCB, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x23, 0xD0, 0x08, + 0x82, 0x00, 0x0D, 0x50, 0x60, 0x08, 0xF0, 0x00, 0x0D, 0x51, 0x60, 0x09, 0x30, 0x00, 0x21, 0x80, 0x60, 0x01, 0xF0, 0x00, 0x40, 0x32, 0xF0, 0x00, + 0x30, 0x11, 0x45, 0xF3, 0xF0, 0x00, 0x30, 0x92, 0x2D, 0x30, 0x60, 0x04, 0x31, 0x13, 0x2D, 0x40, 0x60, 0x05, 0x31, 0x94, 0x7F, 0xFF, 0x60, 0x06, + 0x32, 0x15, 0x0D, 0x61, 0x60, 0x0A, 0x32, 0x96, 0x0D, 0x6B, 0x60, 0x0B, 0x33, 0x10, 0x0D, 0x50, 0x60, 0x01, 0x33, 0x90, 0x0D, 0x5C, 0x60, 0x02, + 0x30, 0x21, 0x0D, 0x63, 0x60, 0x03, 0x30, 0x31, 0x0D, 0x75, 0x60, 0x0C, 0x30, 0xA2, 0x8D, 0x00, 0x60, 0x01, 0x30, 0xB3, 0x01, 0x73, 0x60, 0x02, + 0x30, 0x41, 0x00, 0x25, 0x60, 0x03, 0x30, 0xC2, 0x40, 0x44, 0xF0, 0x00, 0x31, 0x43, 0x40, 0x35, 0xF0, 0x00, 0x31, 0xC4, 0x64, 0x00, 0x60, 0x06, + 0x32, 0x45, 0x1F, 0x40, 0x60, 0x07, 0x32, 0xC6, 0x70, 0x00, 0xF0, 0x00, 0x33, 0x47, 0x1E, 0xBC, 0x60, 0x0D, 0x33, 0xC0, 0x01, 0x22, 0x60, 0x01, + 0x34, 0x40, 0xFD, 0xEE, 0x60, 0x02, 0x30, 0x51, 0x7B, 0x8F, 0x60, 0x03, 0x30, 0xD2, 0xC4, 0x29, 0x60, 0x04, 0x31, 0x51, 0x1E, 0xC2, 0x60, 0x0E, + 0x32, 0x53, 0xFF, 0x0D, 0x60, 0x02, 0x32, 0xD4, 0x7D, 0x2E, 0x60, 0x03, 0x30, 0x61, 0xC1, 0x9A, 0x60, 0x04, 0x30, 0xE2, 0x70, 0x00, 0xF0, 0x00, + 0x31, 0x61, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x63, 0x05, 0x2C, 0x60, 0x08, 0x32, 0xE4, 0x40, 0x00, 0x83, 0x22, 0xF0, 0x00, 0x03, 0x70, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x08, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x4D, 0xF0, 0x00, 0x02, 0x15, 0xD0, 0x80, 0x40, 0x15, 0x20, 0x53, 0xA3, 0x1E, + 0xA0, 0xE8, 0x58, 0x06, 0xA3, 0x1D, 0xA0, 0x72, 0x20, 0x64, 0xF0, 0x00, 0xA8, 0x61, 0x70, 0x00, 0xF0, 0x00, 0xA1, 0x28, 0x70, 0x00, 0xF0, 0x00, + 0xA0, 0xB2, 0x02, 0xBB, 0xD0, 0x80, 0xF0, 0x00, 0x0D, 0x51, 0x60, 0x0F, 0xF0, 0x00, 0x05, 0x17, 0x60, 0x0E, 0x23, 0xF6, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x21, 0x63, 0x41, 0xF5, 0x91, 0x8F, 0x21, 0xF8, 0x40, 0x74, 0xC3, 0xEF, 0x21, 0xE0, 0xF0, 0x00, 0xC3, 0xA4, 0x33, 0xF7, 0xF0, 0x00, + 0xD8, 0x5B, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x18, 0x70, 0x00, 0xF0, 0x00, 0x9F, 0xAF, 0x18, 0x00, 0xF0, 0x00, 0x9F, 0x0F, 0x31, 0xF8, 0x90, 0x02, + 0xF0, 0x00, 0x70, 0x00, 0x90, 0x28, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x22, 0x78, 0xF0, 0x00, 0x16, 0xD3, 0x60, 0x09, 0xA0, 0x6D, + 0x35, 0xF0, 0x1E, 0xBC, 0x60, 0x0D, 0xF0, 0x00, 0x0D, 0x61, 0x60, 0x08, 0xF0, 0x00, 0x03, 0xA5, 0xD2, 0x80, 0xF0, 0x00, 0x1E, 0xC2, 0x60, 0x0D, + 0xF0, 0x00, 0x0D, 0x6B, 0x60, 0x08, 0xF0, 0x00, 0x03, 0xA5, 0xD2, 0x80, 0xF0, 0x00, 0x21, 0x00, 0xF0, 0x00, 0x83, 0x6D, 0x22, 0xF1, 0xF0, 0x00, + 0xF0, 0x00, 0x23, 0x77, 0xF0, 0x00, 0x90, 0x41, 0x36, 0x70, 0xF0, 0x00, 0x9E, 0x79, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x32, 0xF1, 0xD0, 0x08, + 0x91, 0xC7, 0x33, 0x75, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x70, 0xE6, 0x00, 0xF0, 0x00, 0x34, 0xF0, 0xE6, 0x00, 0xF0, 0x00, 0x24, 0x74, 0xF0, 0x00, + 0xF0, 0x00, 0x24, 0xF3, 0xF0, 0x00, 0x8C, 0x24, 0x26, 0xF2, 0x40, 0x16, 0x8A, 0x1B, 0x34, 0x74, 0x4F, 0xF5, 0x82, 0xB7, 0x34, 0xF3, 0xF0, 0x00, + 0xF0, 0x00, 0x20, 0x71, 0x90, 0x05, 0x83, 0x04, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0x67, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x02, + 0xF0, 0x00, 0x36, 0xF6, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0xF0, 0x80, 0x06, 0x82, 0xAF, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x1B, 0x70, 0x00, 0xD0, 0x09, + 0x8E, 0x5F, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x09, 0xF0, 0x00, 0x36, 0xF5, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x70, 0xF0, 0x00, + 0x40, 0x11, 0x27, 0x72, 0xA2, 0xE9, 0x90, 0x8A, 0x20, 0xF3, 0xA2, 0xE8, 0x8E, 0xD7, 0x37, 0x72, 0xF0, 0x00, 0xF0, 0x00, 0x37, 0xF1, 0xE6, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x22, 0x7A, 0xF0, 0x00, 0x16, 0xC3, 0x60, 0x09, 0xA0, 0x46, 0xF0, 0x00, 0x18, 0x20, 0xF0, 0x00, + 0xF0, 0x00, 0x35, 0x70, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x7A, 0xD0, 0x08, 0x0D, 0x51, 0x60, 0x08, 0xA2, 0xDF, 0x82, 0x00, 0x21, 0x06, 0x40, 0x03, + 0x33, 0x80, 0x0D, 0x63, 0x60, 0x09, 0x37, 0x00, 0x0D, 0x6D, 0x60, 0x0A, 0x37, 0x80, 0x0D, 0x30, 0x60, 0x0B, 0x36, 0x83, 0x0D, 0x40, 0x60, 0x0C, + 0x35, 0x80, 0x70, 0x00, 0xC8, 0x88, 0xF0, 0x00, 0x10, 0x10, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x20, 0xF0, 0x00, 0x32, 0x86, 0x40, 0x15, 0xC8, 0x90, + 0xF0, 0x00, 0x10, 0x30, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x40, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x05, 0xD0, 0x08, 0xF0, 0x00, 0x0D, 0x75, 0x60, 0x0F, + 0xF0, 0x00, 0x05, 0x63, 0x60, 0x0E, 0x24, 0xF7, 0x05, 0x1D, 0x60, 0x0D, 0x25, 0x76, 0x70, 0x00, 0xF0, 0x00, 0x91, 0xC7, 0x20, 0xE8, 0x40, 0x15, + 0x91, 0x8F, 0x21, 0xE9, 0xD4, 0x09, 0xC3, 0xEF, 0x20, 0x00, 0x40, 0x12, 0x9F, 0xBE, 0x20, 0x11, 0x58, 0x03, 0xA0, 0x80, 0x35, 0x77, 0x90, 0x01, + 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x21, 0xF5, 0xF0, 0x00, 0xA0, 0xCA, 0x22, 0x54, 0xF0, 0x00, 0xCC, 0x09, 0x05, 0x17, 0x60, 0x0C, + 0x83, 0x2C, 0x70, 0x00, 0xF0, 0x00, 0x8A, 0x61, 0x70, 0x00, 0xF0, 0x00, 0xAE, 0x48, 0x22, 0x45, 0xA2, 0xC3, 0xA2, 0x28, 0x20, 0x78, 0xF0, 0x00, + 0xF0, 0x00, 0x35, 0xF0, 0xF0, 0x00, 0xF0, 0x00, 0x18, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x78, 0xF0, 0x00, 0x16, 0xE3, 0x60, 0x09, 0xA0, 0x27, + 0x89, 0x01, 0x23, 0xF4, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0xF2, 0xF0, 0x00, 0x82, 0x61, 0x21, 0x73, 0xF0, 0x00, 0xA0, 0x50, 0x36, 0x70, 0xF0, 0x00, + 0xA0, 0x58, 0x23, 0x72, 0xE1, 0x40, 0xA8, 0x01, 0x22, 0xF3, 0xF0, 0x00, 0x90, 0x49, 0x22, 0x75, 0xE0, 0x40, 0x80, 0x61, 0x70, 0x00, 0xF0, 0x00, + 0x8A, 0x51, 0x33, 0xF1, 0xF0, 0x00, 0xA0, 0x58, 0x70, 0x00, 0xF0, 0x00, 0xAF, 0x48, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x70, 0xD0, 0x08, + 0x82, 0x00, 0x0D, 0x75, 0x60, 0x08, 0x90, 0x09, 0x0D, 0x00, 0x60, 0x09, 0xF0, 0x00, 0x35, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x80, 0xC0, 0x28, + 0xF0, 0x00, 0x10, 0x10, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x81, 0xD0, 0x08, 0x82, 0x49, 0x0D, 0x75, 0x60, 0x08, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFD, + 0x04, 0x00, 0x60, 0x00, 0xA2, 0xA9, 0x8E, 0xC0, 0x40, 0x00, 0x60, 0x05, 0x60, 0x00, 0x60, 0x05, 0xE6, 0x00, 0xC8, 0x1B, 0x70, 0x00, 0xF0, 0x00, + 0xD8, 0xDB, 0x0D, 0x51, 0x60, 0x08, 0x83, 0x5B, 0x70, 0x00, 0xF0, 0x00, 0x9E, 0xBA, 0x30, 0x03, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x84, 0xD4, 0x09, + 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xC1, 0xF0, 0x00, 0x0D, 0x75, 0x60, 0x08, 0xF0, 0x00, 0x0D, 0x51, 0x60, 0x09, 0xF0, 0x00, 0x24, 0x03, 0xF0, 0x00, + 0xF0, 0x00, 0x27, 0x94, 0xD0, 0x08, 0xA0, 0x03, 0x70, 0x00, 0xF0, 0x00, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x00, 0x00, 0x11, 0x08, 0x00, 0xC0, 0x0E, + 0xA0, 0x09, 0x00, 0x11, 0x08, 0x00, 0xA0, 0x09, 0x70, 0x00, 0xF0, 0x00, 0xA4, 0x08, 0x70, 0x00, 0xD0, 0x08, 0xA0, 0x03, 0x70, 0x00, 0xF0, 0x00, + 0x00, 0x11, 0x08, 0x00, 0xF0, 0x00, 0x00, 0x11, 0x08, 0x00, 0xC0, 0x26, 0xA0, 0x09, 0x00, 0x11, 0x08, 0x00, 0xA0, 0x09, 0x70, 0x00, 0xF0, 0x00, + 0xA4, 0x08, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x1D, 0x01, 0x60, 0x08, 0xF0, 0x00, 0x0A, 0x2C, 0x60, 0x00, 0xF0, 0x00, 0x01, 0x1A, 0x60, 0x01, + 0x31, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x31, 0x81, 0x70, 0x00, 0xD0, 0x08, 0xA8, 0x01, 0x7F, 0xFF, 0x60, 0x06, 0xCC, 0x0A, 0x70, 0x00, 0xF0, 0x00, + 0x8E, 0xA1, 0x31, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x06, 0xD4, 0x09, 0xAE, 0xE8, 0x04, 0xDF, 0xD0, 0x80, 0x90, 0x87, 0x70, 0x00, 0x98, 0x07, + 0xF0, 0x00, 0x0F, 0xB1, 0xD2, 0x80, 0x9E, 0x08, 0x41, 0x89, 0x60, 0x06, 0x14, 0x92, 0x60, 0x00, 0x90, 0x04, 0xA1, 0x98, 0x1D, 0x01, 0x60, 0x08, + 0xAA, 0x56, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0x20, 0x32, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x80, 0xF0, 0x00, 0x91, 0xC2, 0x06, 0x9A, 0x60, 0x08, + 0x41, 0xE6, 0x06, 0x00, 0xD0, 0x80, 0x82, 0x13, 0x70, 0x00, 0xD8, 0x09, 0xF0, 0x00, 0x0F, 0xB1, 0xD2, 0x80, 0x9E, 0x08, 0x10, 0x62, 0x60, 0x01, + 0x05, 0x1F, 0x60, 0x05, 0xD0, 0x09, 0xF0, 0x00, 0x06, 0xE6, 0x60, 0x08, 0xA3, 0x65, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x85, 0xD0, 0x08, + 0x10, 0x00, 0x60, 0x03, 0xA2, 0x75, 0x30, 0x23, 0x07, 0x73, 0xD2, 0x80, 0xF0, 0x00, 0x07, 0xC6, 0xD0, 0x80, 0x08, 0x00, 0x60, 0x03, 0xA0, 0x02, + 0x0E, 0x6F, 0x60, 0x09, 0xF0, 0x00, 0x02, 0x00, 0x60, 0x03, 0x80, 0x00, 0xF0, 0x00, 0x07, 0x73, 0xD0, 0x80, 0x40, 0xE0, 0x00, 0x1F, 0x60, 0x01, + 0x13, 0xD5, 0x60, 0x07, 0xA0, 0x11, 0x90, 0x40, 0x70, 0x00, 0xF0, 0x00, 0x13, 0xFB, 0x60, 0x06, 0xA0, 0x0E, 0x14, 0x05, 0x60, 0x06, 0xA0, 0x0D, + 0x14, 0x0F, 0x60, 0x06, 0xA0, 0x0C, 0x45, 0x60, 0x00, 0x3A, 0x60, 0x01, 0x13, 0xB6, 0x60, 0x07, 0xA0, 0x0B, 0x90, 0x40, 0x70, 0x00, 0xF0, 0x00, + 0x13, 0xF7, 0x60, 0x06, 0xA0, 0x08, 0x14, 0x01, 0x60, 0x06, 0xA0, 0x07, 0x14, 0x0B, 0x60, 0x06, 0xA0, 0x06, 0x41, 0x80, 0x00, 0x3B, 0x60, 0x01, + 0x13, 0xB6, 0x60, 0x07, 0xA0, 0x05, 0x90, 0x40, 0x70, 0x00, 0xF0, 0x00, 0x13, 0xF7, 0x60, 0x06, 0xA0, 0x02, 0x14, 0x01, 0x60, 0x06, 0xA0, 0x01, + 0x14, 0x0B, 0x60, 0x06, 0x80, 0x00, 0xF0, 0x00, 0x0D, 0x28, 0xD0, 0x80, 0xD7, 0xCA, 0x00, 0xFF, 0x60, 0x04, 0x81, 0xD7, 0x0C, 0xF7, 0x60, 0x09, + 0xD0, 0x56, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x76, 0x30, 0x17, 0xF0, 0x00, 0xD0, 0xF6, 0x40, 0x83, 0xF0, 0x00, 0xC1, 0xA4, 0x20, 0x19, 0xF0, 0x00, + 0x82, 0xF6, 0x70, 0x00, 0xF0, 0x00, 0xC1, 0x80, 0x20, 0x17, 0xA2, 0x54, 0xC3, 0xE7, 0x70, 0x00, 0xF0, 0x00, 0xC5, 0xC7, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x30, 0x17, 0xD0, 0x08, 0x9A, 0x78, 0x70, 0x00, 0xF0, 0x00, 0x9A, 0x70, 0x70, 0x00, 0x90, 0xE3, 0xF0, 0x00, 0x70, 0x00, 0x90, 0xE3, + 0xF0, 0x00, 0x0D, 0x67, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA1, 0x19, 0xF0, 0x00, 0x70, 0x00, 0x80, 0xD2, 0x1E, 0xC8, 0x60, 0x08, 0xA2, 0x4A, + 0xF0, 0x00, 0x20, 0x00, 0xA2, 0x49, 0x90, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xA5, + 0x1E, 0xC8, 0x60, 0x08, 0xA2, 0x45, 0xF0, 0x00, 0x30, 0x00, 0xD0, 0x08, 0x00, 0x28, 0x60, 0x00, 0xA2, 0x43, 0x9E, 0x38, 0x0E, 0xF4, 0x60, 0x09, + 0x9E, 0x38, 0x70, 0x00, 0x9F, 0xFF, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x40, 0x40, 0x0C, 0x8A, 0xD5, 0x80, 0xF0, 0x00, 0x0C, 0x8B, 0xD2, 0x80, + 0xF0, 0x00, 0x0F, 0xB1, 0xD2, 0x80, 0x9C, 0x39, 0x70, 0x00, 0xF0, 0x00, 0x9C, 0x31, 0x70, 0x00, 0x90, 0x03, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x02, + 0x40, 0x10, 0x70, 0x00, 0xAF, 0xF3, 0x41, 0xF1, 0x40, 0x40, 0x80, 0x0D, 0x40, 0x00, 0x70, 0x00, 0xAF, 0xF1, 0x41, 0xF1, 0x40, 0x40, 0x80, 0x0C, + 0x03, 0xE8, 0x60, 0x02, 0xA2, 0x35, 0x90, 0x83, 0x10, 0x44, 0xD1, 0x80, 0xF0, 0x00, 0x10, 0x42, 0xD0, 0x80, 0x40, 0x71, 0x40, 0x20, 0xA0, 0x08, + 0x43, 0xA1, 0x40, 0x30, 0xA0, 0x07, 0x43, 0xB1, 0x40, 0x30, 0xA0, 0x06, 0xF0, 0x00, 0x10, 0x75, 0xD0, 0x80, 0x40, 0x71, 0x40, 0x20, 0xA0, 0x04, + 0x43, 0xA1, 0x40, 0x30, 0xA0, 0x02, 0x43, 0xB1, 0x40, 0x30, 0xA0, 0x01, 0xF0, 0x00, 0x10, 0x81, 0xD0, 0x80, 0xF0, 0x00, 0x0C, 0x92, 0xD0, 0x80, + 0xF0, 0x00, 0x0C, 0x94, 0xD0, 0x80, 0xA0, 0x10, 0x70, 0x00, 0x31, 0x7C, 0xA6, 0x50, 0x7C, 0x4D, 0x20, 0x83, 0x80, 0x09, 0x21, 0xF8, 0xF0, 0x00, + 0xA0, 0xD0, 0x70, 0x00, 0x18, 0x41, 0xA6, 0x53, 0x15, 0x36, 0xD0, 0x80, 0xF0, 0x00, 0x0B, 0xC9, 0x60, 0x08, 0xF0, 0x00, 0x1D, 0x8D, 0xD2, 0x80, + 0xF0, 0x00, 0x16, 0xD5, 0xD0, 0x80, 0xF0, 0x00, 0x0B, 0xC9, 0x60, 0x08, 0xF0, 0x00, 0x1D, 0x8F, 0xD2, 0x80, 0xF0, 0x00, 0x16, 0xDA, 0xD0, 0x80, + 0x3E, 0x91, 0x1F, 0x5F, 0xD2, 0x80, 0xF0, 0x00, 0x23, 0x8A, 0xD0, 0x80, 0x0D, 0x85, 0x60, 0x08, 0xA2, 0x1B, 0xF0, 0x00, 0x30, 0x00, 0xD0, 0x08, + 0xF0, 0x00, 0x0F, 0x88, 0x60, 0x0B, 0xF0, 0x00, 0x02, 0x30, 0x60, 0x03, 0xF0, 0x00, 0x09, 0x38, 0x60, 0x04, 0x9F, 0x98, 0x01, 0x2C, 0x60, 0x05, + 0xF0, 0x00, 0x2E, 0xB3, 0xEE, 0x00, 0xF0, 0x00, 0x0F, 0xB1, 0xD2, 0x80, 0x9E, 0x09, 0x0D, 0x87, 0x60, 0x0C, 0x9F, 0x90, 0x70, 0x00, 0x90, 0x02, + 0x9F, 0x88, 0x2F, 0x34, 0xEE, 0x00, 0xF0, 0x00, 0x2F, 0xB5, 0xEE, 0x00, 0x30, 0x43, 0x0B, 0x42, 0x60, 0x08, 0xF0, 0x00, 0x30, 0xC4, 0xF0, 0x00, + 0xF0, 0x00, 0x31, 0x45, 0xF0, 0x00, 0xF0, 0x00, 0x2C, 0xB1, 0x40, 0x17, 0xF0, 0x00, 0x2D, 0x32, 0xF0, 0x00, 0xC6, 0x79, 0x22, 0x05, 0xF0, 0x00, + 0xF0, 0x00, 0x3D, 0x81, 0xF0, 0x00, 0xF0, 0x00, 0x3D, 0x01, 0xF0, 0x00, 0xDD, 0x6D, 0x1B, 0x93, 0xD2, 0x80, 0x90, 0x46, 0x0D, 0x85, 0x60, 0x0A, + 0x20, 0x42, 0x1B, 0x93, 0xD2, 0x80, 0xDA, 0xC9, 0x20, 0x25, 0xA2, 0x04, 0x8C, 0x69, 0x2D, 0xB3, 0xF0, 0x00, 0xDD, 0x49, 0x32, 0x01, 0xF0, 0x00, + 0x8D, 0x89, 0x70, 0x00, 0xF0, 0x00, 0x3C, 0x81, 0xFE, 0x35, 0x60, 0x00, 0x35, 0x81, 0x00, 0x16, 0x60, 0x01, 0xA0, 0x18, 0x21, 0x46, 0xF0, 0x00, + 0xAA, 0x07, 0x01, 0x2D, 0x60, 0x00, 0x81, 0xCF, 0x70, 0x00, 0xF0, 0x00, 0x8F, 0x80, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x02, + 0x40, 0x45, 0x57, 0x4B, 0x60, 0x00, 0xE0, 0x00, 0x60, 0x01, 0x80, 0x02, 0x40, 0x65, 0x40, 0x00, 0x60, 0x00, 0xC6, 0x66, 0x60, 0x01, 0x80, 0x00, + 0xA0, 0x30, 0x40, 0x00, 0x60, 0x04, 0xAF, 0x4E, 0x00, 0xA4, 0x60, 0x05, 0x81, 0x8E, 0x0B, 0x75, 0x60, 0x08, 0xF0, 0x00, 0x14, 0x74, 0xD2, 0x80, + 0xF0, 0x00, 0x1B, 0x90, 0xD2, 0x80, 0x2E, 0x34, 0x04, 0x00, 0x60, 0x06, 0x20, 0xC2, 0x1B, 0x93, 0xD2, 0x80, 0xD2, 0xC9, 0x03, 0xE9, 0x60, 0x05, + 0x81, 0x8E, 0x0B, 0x59, 0x60, 0x08, 0x8F, 0x2D, 0x31, 0xC6, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x02, 0x40, 0x45, 0xB1, 0x5C, 0x60, 0x03, + 0x46, 0x66, 0x60, 0x07, 0x80, 0x02, 0x40, 0x65, 0xAA, 0xCE, 0x60, 0x03, 0xC6, 0x66, 0x60, 0x07, 0x80, 0x00, 0xA0, 0xE0, 0x00, 0x38, 0x60, 0x04, + 0xAF, 0x48, 0x00, 0x1D, 0x60, 0x05, 0x81, 0xC7, 0x31, 0x84, 0xF0, 0x00, 0x31, 0x05, 0x14, 0x74, 0xD2, 0x80, 0xF0, 0x00, 0x1B, 0x90, 0xD2, 0x80, + 0xF0, 0x00, 0xD8, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x0B, 0x67, 0x60, 0x08, 0x21, 0xC6, 0x20, 0x00, 0x60, 0x04, 0xF0, 0x00, 0x13, 0x33, 0x60, 0x05, + 0x81, 0x86, 0x31, 0x84, 0x40, 0x07, 0x31, 0x05, 0x14, 0x74, 0xD2, 0x80, 0xF0, 0x00, 0x1B, 0x90, 0xD0, 0x80, 0xF0, 0x00, 0x6E, 0x6C, 0x60, 0x03, + 0x40, 0x07, 0x00, 0xE5, 0x60, 0x05, 0xA0, 0x58, 0xFF, 0xFF, 0x60, 0x03, 0xAA, 0x24, 0x0B, 0x52, 0x60, 0x08, 0x81, 0x1C, 0x70, 0x00, 0xF0, 0x00, + 0x31, 0x05, 0x7F, 0xDF, 0x60, 0x06, 0x31, 0x84, 0x14, 0x74, 0xD2, 0x80, 0xF0, 0x00, 0x1B, 0x90, 0xD0, 0x80, 0x91, 0x83, 0x2E, 0x85, 0xF0, 0x00, + 0xF0, 0x00, 0x2F, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x2F, 0x87, 0xF0, 0x00, 0x0B, 0xC9, 0x60, 0x09, 0xA1, 0xCF, 0x3E, 0x11, 0x0D, 0x82, 0x60, 0x0A, + 0xF0, 0x00, 0x27, 0x11, 0xA1, 0xCD, 0xA0, 0x50, 0x27, 0x92, 0xF0, 0x00, 0xAA, 0x41, 0x0B, 0xB4, 0x60, 0x0C, 0x80, 0x52, 0x20, 0x21, 0xA1, 0xCA, + 0x9E, 0xCB, 0x35, 0x92, 0xF0, 0x00, 0x90, 0x41, 0x70, 0x00, 0xD8, 0x09, 0x88, 0x2D, 0x70, 0x00, 0xD4, 0x09, 0xF0, 0x00, 0x36, 0x15, 0xF0, 0x00, + 0xF0, 0x00, 0x36, 0x95, 0xF0, 0x00, 0x91, 0x00, 0x30, 0xA6, 0xF0, 0x00, 0x31, 0x27, 0x14, 0x62, 0xD2, 0x80, 0x90, 0x04, 0x31, 0xC0, 0xF0, 0x00, + 0x21, 0x45, 0x8C, 0xCD, 0x60, 0x06, 0xF0, 0x00, 0xFF, 0x55, 0x60, 0x07, 0xF0, 0x00, 0x14, 0x74, 0xD2, 0x80, 0xF0, 0x00, 0x32, 0x40, 0xF0, 0x00, + 0xF0, 0x00, 0x32, 0xC1, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x42, 0x80, 0x00, 0xF0, 0x00, 0x0D, 0x82, 0x60, 0x09, 0xF0, 0x00, 0x0B, 0xC9, 0x60, 0x0A, + 0xF0, 0x00, 0x20, 0x15, 0xA1, 0xB9, 0x91, 0x45, 0x7F, 0xEC, 0x60, 0x06, 0x40, 0x47, 0x70, 0x00, 0xD4, 0x09, 0x20, 0x90, 0x14, 0x47, 0xD2, 0x80, + 0xF0, 0x00, 0x34, 0xA0, 0xF0, 0x00, 0x21, 0x10, 0x14, 0x47, 0xD2, 0x80, 0xF0, 0x00, 0x35, 0x20, 0xD0, 0x08, 0x0A, 0x3D, 0x60, 0x07, 0xA1, 0xB2, + 0xA2, 0x79, 0x0B, 0xC9, 0x60, 0x09, 0xA2, 0xBA, 0x70, 0x00, 0xF0, 0x00, 0x90, 0xC0, 0x3B, 0x91, 0xF0, 0x00, 0x3B, 0x12, 0x14, 0x62, 0xD2, 0x80, + 0xF0, 0x00, 0x3C, 0x10, 0xD0, 0x08, 0xF0, 0x00, 0x0B, 0x60, 0x60, 0x0E, 0xF0, 0x00, 0x00, 0x04, 0x60, 0x03, 0x40, 0xA7, 0x3F, 0xFC, 0x60, 0x04, + 0x32, 0x63, 0x80, 0x08, 0x60, 0x05, 0x32, 0xE4, 0x19, 0x9A, 0x60, 0x06, 0x33, 0x65, 0x0D, 0x86, 0x60, 0x0F, 0x31, 0xE6, 0x70, 0x00, 0xF0, 0x00, + 0x30, 0x77, 0x70, 0x00, 0xD0, 0x08, 0x0D, 0x82, 0x60, 0x0A, 0xA1, 0xA4, 0xF0, 0x00, 0x30, 0x20, 0xF0, 0x00, 0x00, 0xD2, 0x60, 0x01, 0x94, 0x0B, + 0xF0, 0x00, 0x00, 0xD2, 0x60, 0x02, 0x00, 0xFA, 0x60, 0x03, 0xAF, 0xED, 0xF0, 0x00, 0xBE, 0x77, 0x60, 0x06, 0xF0, 0x00, 0x4B, 0x00, 0x60, 0x07, + 0x37, 0x06, 0x00, 0x01, 0x60, 0x01, 0x37, 0x87, 0x03, 0xE8, 0x60, 0x02, 0xF0, 0x00, 0x03, 0x84, 0x60, 0x04, 0xF0, 0x00, 0x00, 0x01, 0x60, 0x05, + 0xF0, 0x00, 0x00, 0x8C, 0x60, 0x06, 0xF0, 0x00, 0x0A, 0xF0, 0x60, 0x07, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xC7, 0xF0, 0x00, 0x0B, 0xB4, 0x60, 0x09, + 0xF0, 0x00, 0x00, 0x11, 0x60, 0x05, 0xF0, 0x00, 0x00, 0x11, 0x60, 0x06, 0x3B, 0x05, 0x10, 0x00, 0x60, 0x07, 0x3B, 0x86, 0x00, 0x04, 0x60, 0x00, + 0x3C, 0x07, 0xAD, 0x84, 0x60, 0x01, 0x32, 0x10, 0x01, 0xFD, 0x60, 0x02, 0x32, 0x91, 0x0B, 0x5E, 0x60, 0x03, 0x33, 0x12, 0x0C, 0x80, 0x60, 0x04, + 0x31, 0x93, 0x00, 0xA0, 0x60, 0x05, 0x34, 0x84, 0xFF, 0xD0, 0x60, 0x06, 0x35, 0x05, 0xE3, 0x54, 0x60, 0x07, 0x36, 0x06, 0x34, 0x00, 0x60, 0x00, + 0x36, 0x86, 0x00, 0x01, 0x60, 0x01, 0x37, 0x07, 0x03, 0xE8, 0x60, 0x02, 0x37, 0x80, 0x70, 0x00, 0x8F, 0xB7, 0x80, 0xE5, 0x7F, 0xFF, 0x60, 0x00, + 0xCC, 0x0A, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0xA9, 0x33, 0x70, 0xF0, 0x00, 0xAF, 0x20, 0x34, 0x70, 0xD4, 0x09, 0xAE, 0xE8, 0x70, 0x00, 0xF0, 0x00, + 0xA8, 0x05, 0x00, 0x80, 0x60, 0x07, 0xA8, 0xF6, 0x33, 0x75, 0xF0, 0x00, 0xC3, 0x86, 0x70, 0x00, 0xF0, 0x00, 0x8F, 0x7F, 0x33, 0xF6, 0xF0, 0x00, + 0xA8, 0x85, 0x1D, 0xE4, 0xD1, 0x80, 0xF0, 0x00, 0x34, 0x75, 0xD0, 0x08, 0x0D, 0x86, 0x60, 0x09, 0xA1, 0x7B, 0x20, 0x12, 0x1F, 0x32, 0xD2, 0x80, + 0xF0, 0x00, 0x35, 0x82, 0xD0, 0x08, 0x90, 0x82, 0x0D, 0x86, 0x60, 0x09, 0x40, 0xA7, 0x40, 0x77, 0xE6, 0x40, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x30, 0x17, 0xD0, 0x08, 0x0B, 0xB4, 0x60, 0x08, 0xA1, 0x74, 0xF0, 0x00, 0x31, 0x82, 0xD0, 0x08, 0xF0, 0x00, 0x09, 0x61, 0x60, 0x08, + 0xF0, 0x00, 0x09, 0xC9, 0x60, 0x09, 0xF0, 0x00, 0x21, 0x80, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0x91, 0xA1, 0x6F, 0xA2, 0x08, 0x70, 0x00, 0xD0, 0x08, + 0x00, 0xCF, 0x60, 0x02, 0xA0, 0x01, 0x01, 0x51, 0x60, 0x02, 0x80, 0x01, 0x0D, 0x8B, 0x60, 0x08, 0x80, 0x01, 0x0D, 0x8C, 0x60, 0x08, 0x80, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x02, 0xD0, 0x08, 0x0F, 0xF2, 0x60, 0x09, 0xA1, 0x67, 0x20, 0x11, 0x0D, 0x8B, 0x60, 0x0A, + 0xF0, 0x00, 0x2C, 0x92, 0xF0, 0x00, 0x90, 0x41, 0x20, 0x11, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x93, 0xFE, 0xF0, 0x00, 0x70, 0x00, 0xF2, 0x00, + 0x31, 0x22, 0x20, 0x31, 0xD0, 0x80, 0x0D, 0x8B, 0x60, 0x08, 0xA0, 0x03, 0xF0, 0x00, 0x20, 0x22, 0xD0, 0x80, 0x0D, 0x8C, 0x60, 0x08, 0xA0, 0x01, + 0xF0, 0x00, 0x20, 0x1E, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x20, 0x00, 0x0E, 0x69, 0x60, 0x08, 0xF0, 0x00, 0x01, 0xD0, 0x60, 0x01, + 0xF0, 0x00, 0x30, 0x80, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x01, 0xD0, 0x08, 0x83, 0x6D, 0x0C, 0x35, 0x60, 0x08, 0x40, 0x60, 0x3A, 0x4D, 0x60, 0x01, + 0x41, 0xE2, 0x21, 0x96, 0x60, 0x03, 0x33, 0x00, 0x41, 0x44, 0xF0, 0x00, 0x33, 0x81, 0x70, 0x00, 0xF0, 0x00, 0x34, 0x02, 0x70, 0x00, 0xF0, 0x00, + 0x34, 0x83, 0x0C, 0x29, 0x60, 0x09, 0x35, 0x04, 0x3A, 0x5B, 0x60, 0x00, 0x35, 0x85, 0x3A, 0x60, 0x60, 0x03, 0x30, 0x90, 0x70, 0x00, 0xF0, 0x00, + 0x33, 0x93, 0x70, 0x00, 0x8F, 0xDF, 0xF0, 0x00, 0x70, 0x00, 0xAE, 0x6C, 0xF0, 0x00, 0x70, 0x00, 0x8E, 0x9F, 0xF0, 0x00, 0x70, 0x00, 0xAE, 0x98, + 0xF0, 0x00, 0x0C, 0x51, 0xD2, 0x80, 0xF0, 0x00, 0x21, 0xA0, 0xD0, 0x80, 0xF0, 0x00, 0x05, 0x2E, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x0E, + 0xF0, 0x00, 0x21, 0xB7, 0xD0, 0x80, 0xF0, 0x00, 0x1F, 0x32, 0xD2, 0x80, 0xF0, 0x00, 0x1E, 0x84, 0xD2, 0x80, 0xF0, 0x00, 0x21, 0xE0, 0xD0, 0x80, + 0xF0, 0x00, 0x1E, 0xA4, 0xD2, 0x80, 0xF0, 0x00, 0x07, 0xF7, 0xD2, 0x80, 0xF0, 0x00, 0x22, 0x15, 0xD0, 0x80, 0xF0, 0x00, 0x07, 0xFB, 0xD2, 0x80, + 0xF0, 0x00, 0x22, 0x8F, 0xD0, 0x80, 0x40, 0x40, 0x22, 0xE1, 0xD2, 0x80, 0x40, 0x80, 0x22, 0xE2, 0xD2, 0x80, 0xF0, 0x00, 0x22, 0x9C, 0xD0, 0x80, + 0xF0, 0x00, 0x07, 0xFB, 0xD2, 0x80, 0xF0, 0x00, 0x22, 0xB6, 0xD0, 0x80, 0xF0, 0x00, 0x20, 0xF0, 0xD2, 0x80, 0x90, 0x02, 0x27, 0xDF, 0xD2, 0x80, + 0x9E, 0x69, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x07, 0x00, 0xD1, 0x80, 0xF0, 0x00, 0x23, 0x20, 0xD0, 0x80, 0x90, 0x82, 0x0C, 0x29, 0x60, 0x09, + 0x40, 0x17, 0x40, 0x67, 0xE6, 0x40, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x17, 0xD0, 0x08, 0xF0, 0x00, 0x07, 0xF7, 0xD2, 0x80, + 0xF0, 0x00, 0x27, 0xEA, 0xD2, 0x80, 0xF0, 0x00, 0x11, 0xB5, 0xD0, 0x80, 0x40, 0x55, 0x15, 0x17, 0x60, 0x08, 0xF0, 0x00, 0x1D, 0x40, 0x60, 0x00, + 0x31, 0x05, 0x1E, 0x60, 0x60, 0x01, 0x31, 0x85, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x05, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x85, 0x70, 0x00, 0xF0, 0x00, + 0x33, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x33, 0x81, 0x0D, 0x8E, 0x60, 0x09, 0x34, 0x00, 0x02, 0x54, 0x60, 0x02, 0x34, 0x81, 0x38, 0x80, 0x60, 0x03, + 0x30, 0x12, 0x70, 0x00, 0xF0, 0x00, 0x30, 0x93, 0x70, 0x00, 0xD0, 0x08, 0x17, 0x0B, 0x60, 0x0C, 0xA1, 0x1F, 0x00, 0x40, 0x40, 0x05, 0xF0, 0x00, + 0x00, 0x41, 0x24, 0x3F, 0xD0, 0x80, 0xF0, 0x00, 0x0C, 0x83, 0x60, 0x08, 0x90, 0x00, 0x0C, 0x6B, 0x60, 0x0B, 0xF0, 0x00, 0x70, 0x0C, 0xE6, 0x00, + 0xF0, 0x00, 0x20, 0x03, 0xF0, 0x00, 0xF0, 0x00, 0x22, 0x04, 0xF0, 0x00, 0xF0, 0x00, 0x3B, 0xB3, 0xF0, 0x00, 0xF0, 0x00, 0x3C, 0x34, 0xD0, 0x08, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xC8, 0xF0, 0x00, 0x0C, 0x8D, 0x60, 0x08, 0xF0, 0x00, 0x26, 0x0A, 0xD0, 0x80, 0x83, 0xFF, 0x0D, 0x9B, 0x60, 0x08, + 0xF0, 0x00, 0x01, 0xF4, 0x60, 0x00, 0xF0, 0x00, 0x03, 0xB1, 0x60, 0x01, 0x10, 0x00, 0x03, 0xB2, 0x60, 0x02, 0x10, 0x01, 0x04, 0x0E, 0x60, 0x00, + 0x10, 0x02, 0x04, 0x0F, 0x60, 0x01, 0x10, 0x00, 0x04, 0x5C, 0x60, 0x02, 0x10, 0x01, 0x04, 0x5D, 0x60, 0x00, 0x10, 0x02, 0x13, 0x80, 0x60, 0x01, + 0x10, 0x00, 0x0D, 0xAB, 0x60, 0x09, 0x10, 0x01, 0x02, 0xEE, 0x60, 0x00, 0x10, 0x07, 0x43, 0x06, 0x60, 0x01, 0x10, 0x10, 0x04, 0x69, 0x60, 0x02, + 0x10, 0x11, 0x44, 0x87, 0x60, 0x00, 0x10, 0x12, 0x05, 0xE3, 0x60, 0x01, 0x10, 0x10, 0x46, 0x08, 0x60, 0x02, 0x10, 0x11, 0x06, 0xAE, 0x60, 0x00, + 0x10, 0x12, 0x0D, 0xA4, 0x60, 0x08, 0x10, 0x10, 0x9E, 0x3C, 0x60, 0x00, 0x10, 0x17, 0x0D, 0xB3, 0x60, 0x09, 0x10, 0x00, 0x25, 0xDA, 0x60, 0x00, + 0x10, 0x07, 0x80, 0x3D, 0x60, 0x01, 0x10, 0x10, 0x28, 0x82, 0x60, 0x02, 0x10, 0x11, 0xC0, 0x3D, 0x60, 0x00, 0x10, 0x12, 0x28, 0x87, 0x60, 0x01, + 0x10, 0x10, 0xC0, 0x3B, 0x60, 0x02, 0x10, 0x11, 0x28, 0x8C, 0x60, 0x00, 0x10, 0x12, 0xC0, 0x3B, 0x60, 0x01, 0x10, 0x10, 0x28, 0x91, 0x60, 0x02, + 0x10, 0x11, 0xC0, 0x3B, 0x60, 0x00, 0x10, 0x12, 0x28, 0x96, 0x60, 0x01, 0x10, 0x10, 0xC0, 0x3B, 0x60, 0x02, 0x10, 0x11, 0x28, 0x9B, 0x60, 0x00, + 0x10, 0x12, 0xC0, 0x3B, 0x60, 0x01, 0x10, 0x10, 0x28, 0xA0, 0x60, 0x02, 0x10, 0x11, 0x40, 0x3C, 0x60, 0x00, 0x10, 0x12, 0x28, 0xA5, 0x60, 0x01, + 0x10, 0x10, 0xC0, 0x3C, 0x60, 0x02, 0x10, 0x11, 0x28, 0xAA, 0x60, 0x00, 0x10, 0x12, 0xC0, 0x3C, 0x60, 0x01, 0x10, 0x10, 0x28, 0xAF, 0x60, 0x02, + 0x10, 0x11, 0xC0, 0x3C, 0x60, 0x00, 0x10, 0x12, 0x28, 0xB4, 0x60, 0x01, 0x10, 0x10, 0xC0, 0x3C, 0x60, 0x02, 0x10, 0x11, 0x28, 0xB9, 0x60, 0x00, + 0x10, 0x12, 0xC0, 0x3C, 0x60, 0x01, 0x10, 0x10, 0x28, 0xBE, 0x60, 0x02, 0x10, 0x11, 0xC0, 0x3C, 0x60, 0x00, 0x10, 0x12, 0x29, 0xCC, 0x60, 0x01, + 0x10, 0x10, 0x00, 0x37, 0x60, 0x02, 0x10, 0x11, 0x29, 0xD1, 0x60, 0x00, 0x10, 0x12, 0x00, 0x37, 0x60, 0x01, 0x10, 0x10, 0x29, 0xD6, 0x60, 0x02, + 0x10, 0x11, 0x00, 0x37, 0x60, 0x00, 0x10, 0x12, 0x29, 0xDB, 0x60, 0x01, 0x10, 0x10, 0x00, 0x37, 0x60, 0x02, 0x10, 0x11, 0x0D, 0xD8, 0x60, 0x08, + 0x10, 0x12, 0x27, 0x15, 0x60, 0x00, 0x10, 0x17, 0x40, 0x3E, 0x60, 0x01, 0x10, 0x00, 0x27, 0x1A, 0x60, 0x02, 0x10, 0x01, 0x80, 0x3C, 0x60, 0x00, + 0x10, 0x02, 0x28, 0x64, 0x60, 0x01, 0x10, 0x00, 0x40, 0x3C, 0x60, 0x02, 0x10, 0x01, 0x28, 0x69, 0x60, 0x00, 0x10, 0x02, 0x40, 0x3C, 0x60, 0x01, + 0x10, 0x00, 0x28, 0x6E, 0x60, 0x02, 0x10, 0x01, 0x80, 0x3A, 0x60, 0x00, 0x10, 0x02, 0x28, 0x73, 0x60, 0x01, 0x10, 0x00, 0x80, 0x3A, 0x60, 0x02, + 0x10, 0x01, 0x28, 0xA0, 0x60, 0x00, 0x10, 0x02, 0x40, 0x3C, 0x60, 0x01, 0x10, 0x00, 0x29, 0xCC, 0x60, 0x02, 0x10, 0x01, 0x00, 0x37, 0x60, 0x00, + 0x10, 0x02, 0x29, 0xD1, 0x60, 0x01, 0x10, 0x00, 0x00, 0x37, 0x60, 0x02, 0x10, 0x01, 0x29, 0xD6, 0x60, 0x00, 0x10, 0x02, 0x00, 0x37, 0x60, 0x01, + 0x10, 0x00, 0x29, 0xDB, 0x60, 0x02, 0x10, 0x01, 0x00, 0x37, 0x60, 0x00, 0x10, 0x02, 0x0D, 0xEF, 0x60, 0x09, 0x10, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0x10, 0x07, 0x70, 0x00, 0xF0, 0x00, 0x10, 0x17, 0x70, 0x00, 0xD0, 0x08, 0x0C, 0xDF, 0x60, 0x0B, 0xA0, 0xBF, 0x30, 0x30, 0x23, 0xD6, 0xD2, 0x80, + 0xF0, 0x00, 0x26, 0xE8, 0xD0, 0x80, 0x0D, 0x9B, 0x60, 0x08, 0xA0, 0xBC, 0xF0, 0x00, 0x00, 0x02, 0xA0, 0xBB, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, + 0x82, 0x8A, 0x70, 0x00, 0x90, 0x03, 0x90, 0x8A, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, 0x82, 0xBF, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x01, 0x99, 0xD2, 0x80, 0xF0, 0x00, 0x0D, 0x9A, 0x60, 0x08, 0xF0, 0x00, 0x26, 0xC1, 0xF0, 0x00, 0xF0, 0x00, 0x00, 0x02, 0xA0, 0xB2, + 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x8A, 0x70, 0x00, 0x90, 0x03, 0x90, 0x8A, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, + 0x82, 0x80, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x0D, 0xAB, 0x60, 0x0D, 0xF0, 0x00, 0x3F, 0xFF, 0x60, 0x02, + 0xF0, 0x00, 0x00, 0x51, 0xA0, 0xA9, 0xC2, 0x53, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0xC4, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x97, 0xFC, + 0xD4, 0x8F, 0x01, 0x99, 0xD2, 0x80, 0x40, 0x05, 0x0D, 0xA4, 0x60, 0x0D, 0x40, 0x17, 0x3F, 0xFF, 0x60, 0x02, 0x9F, 0x7D, 0x00, 0x51, 0xA0, 0xA2, + 0xC2, 0x53, 0x70, 0x00, 0xF0, 0x00, 0x82, 0xC4, 0x27, 0x1C, 0xD1, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x97, 0xFC, 0x91, 0x46, 0x27, 0x20, 0xD0, 0x80, + 0x40, 0x07, 0x01, 0x99, 0xD2, 0x80, 0xF0, 0x00, 0x0D, 0x8E, 0x60, 0x0E, 0x40, 0x07, 0x25, 0xC1, 0xA0, 0x9B, 0x9E, 0x79, 0x2E, 0x40, 0x40, 0x14, + 0x40, 0x36, 0x31, 0x67, 0x90, 0x19, 0x2F, 0x45, 0x19, 0x64, 0x60, 0x02, 0x4F, 0xF0, 0x1A, 0x5E, 0x60, 0x03, 0x83, 0x54, 0x40, 0x36, 0xF0, 0x00, + 0x83, 0x5C, 0x40, 0x00, 0xE2, 0x00, 0xF0, 0x00, 0x40, 0x10, 0xE2, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0x9C, 0x11, 0xF0, 0x00, 0x0D, 0xD8, 0x60, 0x0D, 0x40, 0x36, 0x22, 0xF0, 0xD2, 0x80, 0x0D, 0xB3, 0x60, 0x0D, 0xE6, 0x00, + 0x40, 0x14, 0x21, 0x40, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0x51, 0xA0, 0x8C, 0x90, 0x41, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x45, 0x70, 0x00, 0x90, 0x1D, + 0xF0, 0x00, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0xDC, 0x8F, 0xFB, 0x20, 0xD1, 0x3F, 0xFF, 0x60, 0x02, 0xF0, 0x00, 0x0C, 0xDF, 0x60, 0x0B, + 0xC2, 0x53, 0x31, 0x61, 0xF0, 0x00, 0xD4, 0x8E, 0x30, 0x33, 0xF0, 0x00, 0xD4, 0x4A, 0x37, 0xC6, 0xF0, 0x00, 0xC6, 0xA2, 0x70, 0x00, 0xF0, 0x00, + 0xC3, 0xA0, 0x3D, 0x42, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0xE0, 0xD0, 0x08, 0xC6, 0x24, 0x31, 0xE0, 0xF0, 0x00, 0x90, 0x00, 0x3D, 0x44, 0xF0, 0x00, + 0x83, 0xB6, 0x70, 0x00, 0xE0, 0x40, 0x40, 0xD5, 0x21, 0x41, 0xA0, 0x7C, 0xCC, 0x0B, 0x40, 0x00, 0xF0, 0x00, 0x80, 0xED, 0x23, 0xEA, 0xD2, 0x80, + 0xBF, 0x60, 0x20, 0x60, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0xE1, 0xF0, 0x00, 0xF0, 0x00, 0x23, 0xEA, 0xD2, 0x80, 0x90, 0xC6, 0x23, 0xDE, 0xD2, 0x80, + 0x4F, 0x95, 0x40, 0x14, 0xA0, 0x75, 0x81, 0x75, 0x70, 0x00, 0xF0, 0x00, 0xAF, 0x43, 0x70, 0x00, 0xF0, 0x00, 0xC2, 0xE0, 0x70, 0x00, 0xF0, 0x00, + 0x80, 0xC3, 0x0C, 0xDF, 0x60, 0x0B, 0xF0, 0x00, 0x33, 0x63, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0xE3, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x33, 0xA0, 0x41, + 0xF0, 0x00, 0x70, 0x00, 0x80, 0x12, 0x40, 0xD5, 0x21, 0x41, 0xA0, 0x6C, 0xCC, 0x0B, 0x40, 0x00, 0xF0, 0x00, 0x80, 0xED, 0x23, 0xEA, 0xD2, 0x80, + 0xBF, 0x60, 0x20, 0x60, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0xE1, 0xF0, 0x00, 0xF0, 0x00, 0x23, 0xEA, 0xD2, 0x80, 0x90, 0xC6, 0x23, 0xDE, 0xD2, 0x80, + 0x4F, 0x95, 0x40, 0x14, 0xA0, 0x65, 0x81, 0x75, 0x70, 0x00, 0x40, 0x06, 0xAF, 0x43, 0x70, 0x00, 0xF0, 0x00, 0xC2, 0xE0, 0x0C, 0xDF, 0x60, 0x0B, + 0xF0, 0x00, 0x31, 0xE0, 0xF0, 0x00, 0x80, 0xC3, 0x40, 0x36, 0xE6, 0x00, 0xC6, 0x24, 0x30, 0x33, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x63, 0xF0, 0x00, + 0xF0, 0x00, 0x34, 0xE3, 0xF0, 0x00, 0xF0, 0x00, 0x3D, 0x44, 0xF0, 0x00, 0xF0, 0x00, 0x37, 0xC6, 0xA0, 0x2E, 0xF0, 0x00, 0x23, 0x66, 0xA0, 0x31, + 0x82, 0x92, 0x0B, 0xB8, 0x60, 0x03, 0x47, 0xF4, 0x23, 0xE0, 0xD2, 0x80, 0x52, 0x08, 0x60, 0x05, 0x98, 0x03, 0x82, 0x92, 0x52, 0x08, 0x60, 0x03, + 0x47, 0xF4, 0x23, 0xE0, 0xD2, 0x80, 0x52, 0x08, 0x60, 0x05, 0x98, 0x23, 0xF0, 0x00, 0x33, 0xE4, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x65, 0xF0, 0x00, + 0xF0, 0x00, 0x35, 0x64, 0xF0, 0x00, 0xF0, 0x00, 0x35, 0xE5, 0xF0, 0x00, 0xF0, 0x00, 0x23, 0x66, 0xA0, 0x4F, 0x91, 0x8E, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x33, 0x66, 0xA0, 0x24, 0x82, 0x92, 0x52, 0x08, 0x60, 0x03, 0xF0, 0x00, 0x23, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x9C, 0x05, + 0x82, 0x92, 0x0B, 0xB8, 0x60, 0x03, 0xF0, 0x00, 0x23, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x9B, 0xF7, 0x0D, 0x94, 0x60, 0x0D, 0xA0, 0x2B, + 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xF5, 0xF0, 0x00, 0x24, 0xE6, 0xA0, 0x44, 0x9F, 0xBE, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0xE6, 0xA0, 0x19, + 0x82, 0x92, 0x52, 0x08, 0x60, 0x03, 0xF0, 0x00, 0x23, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x9C, 0x05, 0x82, 0x92, 0x0B, 0xB8, 0x60, 0x03, + 0xF0, 0x00, 0x23, 0xE0, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x9B, 0xF7, 0x0D, 0x97, 0x60, 0x0D, 0xA0, 0x20, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xF5, + 0x40, 0x14, 0x23, 0xE1, 0xA0, 0x39, 0xC2, 0x63, 0x25, 0x62, 0xF0, 0x00, 0xF0, 0x00, 0x24, 0x65, 0x90, 0x07, 0xC2, 0xA3, 0x25, 0xE6, 0xF0, 0x00, + 0x90, 0x80, 0x70, 0x00, 0x90, 0x02, 0x83, 0x77, 0x70, 0x00, 0xF0, 0x00, 0x25, 0x60, 0x23, 0xE0, 0xEB, 0xC0, 0x0C, 0xDF, 0x60, 0x0B, 0xA0, 0x32, + 0xF0, 0x00, 0x30, 0x30, 0xF0, 0x00, 0xF0, 0x00, 0x21, 0xE0, 0xD0, 0x08, 0xC2, 0xA3, 0x25, 0xE6, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x93, 0xF9, + 0x90, 0x40, 0x70, 0x00, 0x8F, 0xFA, 0xF0, 0x00, 0x21, 0xE0, 0xAF, 0x0F, 0xF0, 0x00, 0x24, 0x62, 0xD2, 0x80, 0xF0, 0x00, 0x32, 0x60, 0xF0, 0x00, + 0xF0, 0x00, 0x32, 0xE1, 0xD0, 0x08, 0xF0, 0x00, 0x23, 0xED, 0xD2, 0x80, 0xB8, 0x68, 0x22, 0x60, 0xF0, 0x00, 0xF0, 0x00, 0x22, 0xE1, 0xF0, 0x00, + 0xF0, 0x00, 0x23, 0xEA, 0xD2, 0x80, 0xF0, 0x00, 0x23, 0xDE, 0xD2, 0x80, 0xA9, 0x88, 0x70, 0x00, 0xF0, 0x00, 0xAB, 0xF8, 0x23, 0xE4, 0xD2, 0x80, + 0x46, 0x43, 0x21, 0x42, 0xA0, 0x21, 0xA0, 0x98, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x23, 0xE7, 0xD2, 0x80, 0xF0, 0x00, 0x23, 0xC6, 0xD2, 0x80, + 0x90, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xDC, 0x09, 0xF0, 0x00, 0x23, 0xCE, 0xD0, 0x80, 0x47, 0xE5, 0x70, 0x00, 0xF0, 0x00, + 0x40, 0x16, 0x20, 0xD3, 0xA0, 0x19, 0x83, 0x5D, 0x20, 0x52, 0xF0, 0x00, 0xC2, 0xF5, 0x21, 0x54, 0x98, 0x07, 0xC2, 0xB6, 0x70, 0x00, 0x90, 0x02, + 0xF0, 0x00, 0x70, 0x00, 0x90, 0x05, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x02, 0xC2, 0xB6, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, + 0x82, 0x64, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xDC, 0x09, 0xF0, 0x00, 0x31, 0x51, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0xD2, 0xD0, 0x08, + 0x0D, 0xEF, 0x60, 0x0B, 0xA0, 0x0D, 0x9E, 0x79, 0x20, 0x36, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0x45, 0xF0, 0x00, 0x9F, 0xBC, 0x70, 0x00, 0xE0, 0x40, + 0x91, 0x45, 0x70, 0x00, 0xD0, 0x09, 0x26, 0x44, 0x27, 0x2D, 0xD5, 0x80, 0x91, 0x86, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x27, 0x32, 0xD5, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x67, 0x2F, 0x41, 0x27, 0x36, 0xD0, 0x80, 0xF0, 0x00, 0x29, 0x15, 0xD2, 0x80, 0xF0, 0x00, 0x3B, 0x9B, 0xD2, 0x80, + 0xF0, 0x00, 0x28, 0x88, 0xD0, 0x80, 0xF0, 0x00, 0x28, 0xDD, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x16, 0xC3, 0x60, 0x08, + 0xF0, 0x00, 0x00, 0x9A, 0x60, 0x00, 0xF0, 0x00, 0x02, 0xE3, 0x60, 0x00, 0x10, 0x00, 0x04, 0xF4, 0x60, 0x00, 0x10, 0x00, 0x06, 0xFF, 0x60, 0x00, + 0x10, 0x00, 0x09, 0x07, 0x60, 0x00, 0x10, 0x00, 0x0B, 0x10, 0x60, 0x00, 0x10, 0x00, 0x0D, 0x1F, 0x60, 0x00, 0x10, 0x00, 0x0F, 0x65, 0x60, 0x00, + 0x10, 0x00, 0x0F, 0x65, 0x60, 0x00, 0x10, 0x00, 0x0D, 0x1F, 0x60, 0x00, 0x10, 0x00, 0x0B, 0x10, 0x60, 0x00, 0x10, 0x00, 0x09, 0x07, 0x60, 0x00, + 0x10, 0x00, 0x06, 0xFF, 0x60, 0x00, 0x10, 0x00, 0x04, 0xF4, 0x60, 0x00, 0x10, 0x00, 0x02, 0xE3, 0x60, 0x00, 0x10, 0x00, 0x00, 0x9A, 0x60, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x16, 0xD3, 0x60, 0x08, 0xF0, 0x00, 0xFF, 0x93, 0x60, 0x00, + 0xF0, 0x00, 0xFE, 0x37, 0x60, 0x00, 0x10, 0x00, 0xFD, 0xD9, 0x60, 0x00, 0x10, 0x00, 0xFE, 0x9F, 0x60, 0x00, 0x10, 0x00, 0x03, 0x85, 0x60, 0x00, + 0x10, 0x00, 0x0D, 0x6B, 0x60, 0x00, 0x10, 0x00, 0x16, 0x84, 0x60, 0x00, 0x10, 0x00, 0x1E, 0x49, 0x60, 0x00, 0x10, 0x00, 0x1E, 0x49, 0x60, 0x00, + 0x10, 0x00, 0x16, 0x84, 0x60, 0x00, 0x10, 0x00, 0x0D, 0x6B, 0x60, 0x00, 0x10, 0x00, 0x03, 0x85, 0x60, 0x00, 0x10, 0x00, 0xFE, 0x9F, 0x60, 0x00, + 0x10, 0x00, 0xFD, 0xD9, 0x60, 0x00, 0x10, 0x00, 0xFE, 0x37, 0x60, 0x00, 0x10, 0x00, 0xFF, 0x93, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x16, 0xE3, 0x60, 0x08, 0xF0, 0x00, 0x00, 0x64, 0x60, 0x00, 0xF0, 0x00, 0xFF, 0xA8, 0x60, 0x00, + 0x10, 0x00, 0xFF, 0xA6, 0x60, 0x00, 0x10, 0x00, 0xFF, 0xDF, 0x60, 0x00, 0x10, 0x00, 0x00, 0x01, 0x60, 0x00, 0x10, 0x00, 0x01, 0x28, 0x60, 0x00, + 0x10, 0x00, 0x01, 0x2F, 0x60, 0x00, 0x10, 0x00, 0xFD, 0x23, 0x60, 0x00, 0x10, 0x00, 0xFD, 0xA1, 0x60, 0x00, 0x10, 0x00, 0x03, 0x89, 0x60, 0x00, + 0x10, 0x00, 0x02, 0x54, 0x60, 0x00, 0x10, 0x00, 0xFE, 0x7D, 0x60, 0x00, 0x10, 0x00, 0x00, 0x8C, 0x60, 0x00, 0x10, 0x00, 0xFB, 0xE1, 0x60, 0x00, + 0x10, 0x00, 0xF9, 0x42, 0x60, 0x00, 0x10, 0x00, 0x0C, 0x47, 0x60, 0x00, 0x10, 0x00, 0x0E, 0xA2, 0x60, 0x00, 0x10, 0x00, 0xEC, 0x43, 0x60, 0x00, + 0x10, 0x00, 0xEA, 0xCE, 0x60, 0x00, 0x10, 0x00, 0x17, 0x46, 0x60, 0x00, 0x10, 0x00, 0x17, 0x46, 0x60, 0x00, 0x10, 0x00, 0xEA, 0xCE, 0x60, 0x00, + 0x10, 0x00, 0xEC, 0x43, 0x60, 0x00, 0x10, 0x00, 0x0E, 0xA2, 0x60, 0x00, 0x10, 0x00, 0x0C, 0x47, 0x60, 0x00, 0x10, 0x00, 0xF9, 0x42, 0x60, 0x00, + 0x10, 0x00, 0xFB, 0xE1, 0x60, 0x00, 0x10, 0x00, 0x00, 0x8C, 0x60, 0x00, 0x10, 0x00, 0xFE, 0x7D, 0x60, 0x00, 0x10, 0x00, 0x02, 0x54, 0x60, 0x00, + 0x10, 0x00, 0x03, 0x89, 0x60, 0x00, 0x10, 0x00, 0xFD, 0xA1, 0x60, 0x00, 0x10, 0x00, 0xFD, 0x23, 0x60, 0x00, 0x10, 0x00, 0x01, 0x2F, 0x60, 0x00, + 0x10, 0x00, 0x01, 0x28, 0x60, 0x00, 0x10, 0x00, 0x00, 0x01, 0x60, 0x00, 0x10, 0x00, 0xFF, 0xDF, 0x60, 0x00, 0x10, 0x00, 0xFF, 0xA6, 0x60, 0x00, + 0x10, 0x00, 0xFF, 0xA8, 0x60, 0x00, 0x10, 0x00, 0x00, 0x64, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x17, 0x0B, 0x60, 0x08, 0xF0, 0x00, 0x00, 0x03, 0x60, 0x00, 0xF0, 0x00, 0x54, 0xC0, 0x60, 0x00, 0x10, 0x00, 0x00, 0x05, 0x60, 0x00, + 0x10, 0x00, 0x00, 0x05, 0x60, 0x00, 0x10, 0x00, 0x00, 0x0F, 0x60, 0x00, 0x10, 0x00, 0x00, 0x0F, 0x60, 0x00, 0x10, 0x00, 0x09, 0xC0, 0x60, 0x00, + 0x10, 0x00, 0x0A, 0x20, 0x60, 0x00, 0x10, 0x00, 0x1D, 0x40, 0x60, 0x00, 0x10, 0x00, 0x1E, 0x60, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08 +}; + +const size_t PatchSize102 = sizeof(PatchByteValues102); +const unsigned char * pPatchBytes102 = &PatchByteValues102[0]; + +extern const size_t LutSize102; +extern const unsigned char * pLutBytes102; +static unsigned char LutByteValues102[] = +{ + 0x40, 0x13, 0x40, 0x2F, 0x41, 0x68, 0x41, 0xC1, + 0x42, 0x14, 0x42, 0xA6, 0x44, 0xDE, 0x44, 0xE9, + 0x45, 0xFB, 0x46, 0x11, 0x47, 0xC5, 0x47, 0xFC, + 0x4D, 0x5D, 0x4E, 0x56, 0x4E, 0x58, 0x4E, 0x5B, + 0x4D, 0x83, 0x4E, 0x0A, 0x4E, 0x0B, 0x4E, 0x49, + 0x4E, 0x53, 0x4F, 0x92, 0x4F, 0xEA, 0x50, 0x41, + 0x50, 0x74, 0x50, 0x80, 0x55, 0x31, 0x56, 0x60, + 0x56, 0xD4, 0x56, 0xD9, 0x58, 0x29, 0x59, 0xB4, + 0x5A, 0x3A, 0x5B, 0x79, 0x5B, 0xA2, 0x5B, 0xEF, + 0x5D, 0xDC, 0x60, 0x3A, 0x60, 0x88, 0x60, 0xA8, + 0x61, 0x9F, 0x61, 0xB6, 0x61, 0xDF, 0x61, 0xF5, + 0x62, 0x14, 0x62, 0x59, 0x62, 0x9B, 0x62, 0xA1, + 0x63, 0x69, 0x64, 0x3B, 0x66, 0x09, 0x66, 0xE7, + 0x67, 0x0B, 0x67, 0x1A, 0x67, 0x29, 0x68, 0x87, + 0x68, 0x99, 0x68, 0xA7, 0x68, 0xB2 +}; + +const size_t LutSize102 = sizeof(LutByteValues102); +const unsigned char *pLutBytes102 = &LutByteValues102[0]; diff --git a/src/Tuner_Patch_Lithio_V205_p512.h b/src/Tuner_Patch_Lithio_V205_p512.h new file mode 100644 index 0000000..09547f3 --- /dev/null +++ b/src/Tuner_Patch_Lithio_V205_p512.h @@ -0,0 +1,273 @@ +extern const size_t PatchSize205; +extern const unsigned char *pPatchBytes205; +static const unsigned char PatchByteValues205[] = +{ + 0xF0, 0x00, 0x60, 0x40, 0xD0, 0x80, 0x20, 0x87, 0x60, 0x4C, 0xD0, 0x80, 0x90, 0x00, 0x60, 0x4E, 0xD0, 0x80, 0x22, 0x02, 0x00, 0x55, 0x60, 0x04, + 0xF0, 0x00, 0x60, 0x65, 0xDF, 0x80, 0xF0, 0x00, 0x05, 0xBA, 0x60, 0x0E, 0x20, 0x90, 0x60, 0x9B, 0xD0, 0x80, 0x31, 0x40, 0x60, 0x9F, 0xD0, 0x80, + 0x9E, 0xB9, 0x60, 0xAD, 0xD0, 0x80, 0xF0, 0x00, 0x60, 0xAF, 0xD0, 0x80, 0x20, 0x15, 0x60, 0xB3, 0xD2, 0x80, 0xF0, 0x00, 0x60, 0xCE, 0xD0, 0x80, + 0x90, 0x01, 0x60, 0xD3, 0xD0, 0x80, 0x91, 0x01, 0x60, 0xD4, 0xD0, 0x80, 0xF0, 0x00, 0x60, 0xD5, 0xD0, 0x80, 0xA2, 0x64, 0x70, 0x00, 0xF0, 0x00, + 0x31, 0xA0, 0x61, 0x06, 0xD0, 0x80, 0x40, 0x57, 0x61, 0x2B, 0xD0, 0x80, 0x22, 0x04, 0x61, 0x30, 0xD0, 0x80, 0x20, 0x13, 0x63, 0x7D, 0xD0, 0x80, + 0xF0, 0x00, 0x61, 0x52, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0x60, 0xD2, 0x80, 0xF0, 0x00, 0x61, 0x6C, 0xD0, 0x80, 0x4F, 0xD0, 0x61, 0x69, 0xD1, 0x80, + 0x9E, 0x73, 0x61, 0xA2, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0xAD, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0xB5, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0xCA, 0xD0, 0x80, + 0x2C, 0x87, 0x61, 0xD6, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0xDA, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0xDD, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x62, 0x0D, 0xD2, 0x80, 0x57, 0xF2, 0x62, 0x0F, 0xD5, 0x80, 0xA8, 0x80, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x08, 0x20, 0x55, 0xE1, 0xC0, + 0xF0, 0x00, 0x62, 0x18, 0xD0, 0x80, 0xF0, 0x00, 0x62, 0x1F, 0xD2, 0x80, 0x4F, 0xA0, 0x61, 0x69, 0xD2, 0x80, 0x4F, 0xC0, 0x61, 0x69, 0xD2, 0x80, + 0xF0, 0x00, 0x62, 0x32, 0xD2, 0x80, 0x9A, 0x0A, 0x62, 0x33, 0xD0, 0x80, 0x50, 0x14, 0x62, 0x3A, 0xD2, 0x80, 0xF0, 0x00, 0x62, 0x3D, 0xD0, 0x80, + 0xF0, 0x00, 0x62, 0x42, 0xD0, 0x80, 0x41, 0x20, 0x14, 0xF6, 0xD2, 0x80, 0xF0, 0x00, 0x62, 0xB4, 0xD0, 0x80, 0xF0, 0x00, 0x62, 0xC4, 0xD0, 0x80, + 0xF0, 0x00, 0x62, 0xCD, 0xD0, 0x80, 0xF0, 0x00, 0x62, 0xEA, 0xD0, 0x80, 0xF0, 0x00, 0x62, 0xF0, 0xD0, 0x80, 0xF0, 0x00, 0x62, 0xF2, 0xD2, 0x80, + 0x40, 0x11, 0x62, 0xFC, 0xD0, 0x80, 0xF0, 0x00, 0x63, 0x0E, 0xD0, 0x80, 0xF0, 0x00, 0x63, 0x10, 0xD0, 0x80, 0x2D, 0xC5, 0x18, 0xFF, 0x60, 0x06, + 0x21, 0xC6, 0x63, 0x3B, 0xD0, 0x80, 0xF0, 0x00, 0x63, 0x43, 0xD0, 0x80, 0xF0, 0x00, 0x63, 0x45, 0xD0, 0x80, 0x82, 0x09, 0x0D, 0xA4, 0x60, 0x0D, + 0xF0, 0x00, 0x63, 0x57, 0xD2, 0x80, 0xF0, 0x00, 0x63, 0x57, 0xD2, 0x80, 0xF0, 0x00, 0x63, 0x56, 0xD5, 0x80, 0xF0, 0x00, 0x63, 0x7F, 0xD2, 0x80, + 0x82, 0x00, 0x70, 0x00, 0xA0, 0x12, 0x82, 0x00, 0x70, 0x00, 0xA0, 0x4E, 0x82, 0x00, 0x70, 0x00, 0xA0, 0xAC, 0x82, 0x00, 0x70, 0x00, 0xA1, 0x04, + 0x82, 0x00, 0x70, 0x00, 0xA1, 0xAC, 0x82, 0x00, 0x70, 0x00, 0xA3, 0x37, 0x82, 0x00, 0x70, 0x00, 0xA1, 0xE7, 0x82, 0x00, 0x70, 0x00, 0xA2, 0x0F, + 0x82, 0x00, 0x70, 0x00, 0xA2, 0x26, 0x82, 0x00, 0x70, 0x00, 0xA2, 0xC8, 0x82, 0x00, 0x70, 0x00, 0xA3, 0x32, 0xF0, 0x00, 0x27, 0xAA, 0xD0, 0x80, + 0xF0, 0x00, 0x01, 0xA9, 0xD5, 0x80, 0x8C, 0x79, 0x00, 0x46, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0xF0, 0x00, 0x00, 0x97, 0xD0, 0x80, + 0x40, 0x11, 0x0E, 0x72, 0x60, 0x09, 0xD0, 0x7F, 0x70, 0x00, 0xF0, 0x00, 0xC5, 0xC9, 0x01, 0xB6, 0xD0, 0x80, 0x05, 0x44, 0x60, 0x08, 0xA3, 0x29, + 0x30, 0x80, 0x05, 0x78, 0x60, 0x00, 0x06, 0x1A, 0x60, 0x08, 0xA3, 0x28, 0xF0, 0x00, 0x6F, 0x3F, 0x60, 0x00, 0x05, 0x76, 0x60, 0x08, 0xA3, 0x26, + 0xF0, 0x00, 0x1C, 0x17, 0x60, 0x00, 0x05, 0x77, 0x60, 0x08, 0x83, 0x24, 0xF0, 0x00, 0x07, 0x69, 0x60, 0x08, 0xF0, 0x00, 0x05, 0x19, 0x60, 0x09, + 0xF0, 0x00, 0x20, 0x00, 0xF0, 0x00, 0x26, 0x92, 0x54, 0xA3, 0x60, 0x01, 0xA2, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0x08, 0x70, 0x00, 0xF0, 0x00, + 0xA2, 0x10, 0x70, 0x00, 0xF0, 0x00, 0xD8, 0x40, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x90, 0xF0, 0x00, 0xF0, 0x00, 0x35, 0x90, 0xF0, 0x00, + 0xF0, 0x00, 0x36, 0x90, 0xD0, 0x08, 0x40, 0x15, 0x20, 0x53, 0xA3, 0x17, 0xA0, 0xE8, 0x58, 0x06, 0xA3, 0x16, 0xA0, 0x72, 0x20, 0x64, 0xF0, 0x00, + 0xA8, 0x61, 0x70, 0x00, 0xF0, 0x00, 0xA1, 0x28, 0x70, 0x00, 0xF0, 0x00, 0xA0, 0xB2, 0x70, 0x00, 0xF0, 0x00, 0xA8, 0x62, 0x70, 0x00, 0xD0, 0x08, + 0x05, 0x79, 0x60, 0x08, 0x83, 0x11, 0xF0, 0x00, 0x10, 0x68, 0x60, 0x01, 0xF0, 0x00, 0x60, 0x03, 0x80, 0x02, 0xF0, 0x00, 0x08, 0x34, 0x60, 0x01, + 0xF8, 0x00, 0x60, 0x03, 0x80, 0x00, 0x18, 0x31, 0x60, 0x08, 0xA3, 0x0B, 0xF0, 0x00, 0x30, 0x01, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0x03, 0xD0, 0x08, + 0x06, 0x1A, 0x60, 0x08, 0xF0, 0x00, 0x06, 0x3B, 0x60, 0x09, 0x80, 0x00, 0xF0, 0x00, 0x0F, 0x84, 0xD2, 0x80, 0x83, 0xFF, 0x7F, 0xFF, 0x60, 0x06, + 0x32, 0x90, 0x03, 0xE8, 0x60, 0x00, 0x33, 0x11, 0x07, 0x63, 0x60, 0x0A, 0x80, 0x99, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0x08, 0x31, 0x22, 0xF0, 0x00, + 0x90, 0xC0, 0x70, 0x00, 0x90, 0x0B, 0x83, 0x6D, 0x70, 0x00, 0xA0, 0xAF, 0x90, 0x04, 0x0F, 0xC1, 0xD2, 0x80, 0x32, 0x00, 0x03, 0xE8, 0x60, 0x00, + 0x32, 0x81, 0x70, 0x00, 0xA0, 0xAC, 0x90, 0x04, 0x21, 0x20, 0xF0, 0x00, 0x31, 0x84, 0x70, 0x00, 0xA0, 0xAA, 0xF0, 0x00, 0x22, 0x87, 0xF0, 0x00, + 0xB0, 0x03, 0x22, 0x06, 0xF0, 0x00, 0xB1, 0xC2, 0x31, 0x00, 0xF0, 0x00, 0xBF, 0x8A, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x02, 0xD0, 0x08, + 0x80, 0x98, 0x70, 0x00, 0xA0, 0xA4, 0x90, 0x04, 0x31, 0x80, 0xF0, 0x00, 0x90, 0x80, 0x70, 0x00, 0xA0, 0xA2, 0x90, 0x05, 0x31, 0x00, 0xF0, 0x00, + 0x90, 0x05, 0x0F, 0xC1, 0xD2, 0x80, 0xF0, 0x00, 0x32, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x81, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x02, 0xD0, 0x08, + 0xF0, 0x00, 0x1D, 0x10, 0x60, 0x09, 0x40, 0x11, 0x7F, 0xFF, 0x60, 0x02, 0x30, 0x10, 0x00, 0x82, 0x60, 0x03, 0xF0, 0x00, 0x30, 0x92, 0xF0, 0x00, + 0xF0, 0x00, 0x31, 0x11, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0x90, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x12, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0x90, 0xF0, 0x00, + 0xF0, 0x00, 0x33, 0x13, 0xF0, 0x00, 0x1D, 0x0F, 0x60, 0x08, 0xA2, 0xE4, 0xF0, 0x00, 0x70, 0x00, 0x82, 0xE2, 0x9A, 0x62, 0x1D, 0x0F, 0x60, 0x0A, + 0x82, 0x92, 0x70, 0x00, 0x94, 0x01, 0x90, 0x8A, 0x00, 0x00, 0x60, 0x01, 0x30, 0x22, 0x08, 0x0C, 0xD0, 0x80, 0xF0, 0x00, 0x09, 0x44, 0xD2, 0x80, + 0xF0, 0x00, 0x07, 0xFD, 0xD2, 0x80, 0xF0, 0x00, 0x08, 0x11, 0xD0, 0x80, 0xF0, 0x00, 0x18, 0x72, 0x60, 0x08, 0xF0, 0x00, 0x1D, 0x0F, 0x60, 0x09, + 0xF0, 0x00, 0x2D, 0x80, 0xA2, 0xD8, 0x9A, 0x02, 0x20, 0x11, 0xF0, 0x00, 0x90, 0x8A, 0x70, 0x00, 0xD0, 0x09, 0x90, 0x41, 0x70, 0x00, 0xD0, 0x08, + 0x18, 0x72, 0x60, 0x08, 0xA2, 0xD4, 0xF0, 0x00, 0x2D, 0x80, 0xA2, 0xD3, 0x98, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x08, 0x70, 0x00, 0xD0, 0x09, + 0x82, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x90, 0xC1, 0x08, 0xEC, 0xD1, 0x80, 0xF0, 0x00, 0x08, 0xDC, 0xD0, 0x80, 0xF0, 0x00, 0x1D, 0x0F, 0x60, 0x0A, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x20, 0x23, 0x70, 0x00, 0xA2, 0xCB, 0x80, 0x59, 0x09, 0x49, 0xD0, 0x80, 0x1D, 0x10, 0x60, 0x0E, 0xA2, 0xC9, + 0x22, 0x61, 0x7F, 0xFF, 0x60, 0x07, 0xF0, 0x00, 0x21, 0xE0, 0xF0, 0x00, 0x82, 0x7C, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x00, 0x22, 0xE4, 0xE0, 0x40, + 0x90, 0x00, 0x70, 0x00, 0xD0, 0x09, 0x9F, 0x3C, 0x70, 0x00, 0x98, 0x06, 0x83, 0x24, 0x70, 0x00, 0xE1, 0x40, 0xF0, 0x00, 0x32, 0xE4, 0x94, 0x03, + 0x80, 0x41, 0x70, 0x00, 0xF0, 0x00, 0x91, 0xC1, 0x40, 0x00, 0xEB, 0x40, 0xA2, 0x8A, 0x32, 0x61, 0x80, 0x04, 0xA2, 0x8A, 0x32, 0x61, 0x80, 0x03, + 0x80, 0x41, 0x70, 0x00, 0xF0, 0x00, 0x82, 0x49, 0x40, 0x00, 0xEB, 0x40, 0xA2, 0x8A, 0x32, 0x61, 0x80, 0x00, 0xA2, 0xCB, 0x31, 0xE0, 0xD0, 0x08, + 0x03, 0x13, 0x60, 0x06, 0x80, 0x01, 0xFC, 0xED, 0x60, 0x06, 0x80, 0x00, 0x1D, 0x10, 0x60, 0x0E, 0xA2, 0xB6, 0xF0, 0x00, 0x30, 0x66, 0xD0, 0x08, + 0x03, 0x13, 0x60, 0x06, 0x80, 0x01, 0xFC, 0xED, 0x60, 0x06, 0x80, 0x00, 0x1D, 0x10, 0x60, 0x0E, 0xA2, 0xB2, 0xF0, 0x00, 0x31, 0xE6, 0xF0, 0x00, + 0xF0, 0x00, 0x23, 0x66, 0xA2, 0xB0, 0xF0, 0x00, 0x32, 0xE6, 0xD0, 0x08, 0x1D, 0x0F, 0x60, 0x0B, 0xA2, 0xAE, 0xF0, 0x00, 0x20, 0x37, 0xA2, 0xAD, + 0x91, 0xC7, 0x21, 0x91, 0xF0, 0x00, 0x90, 0xC3, 0x0B, 0x0B, 0xD1, 0x80, 0x82, 0x49, 0x0B, 0x14, 0xD0, 0x80, 0x31, 0x91, 0x0B, 0x14, 0xD0, 0x80, + 0x31, 0x91, 0x0B, 0x14, 0xD0, 0x80, 0x1D, 0x10, 0x60, 0x0D, 0xA2, 0xA7, 0xF0, 0x00, 0x21, 0x57, 0xA2, 0xA6, 0x91, 0xC7, 0x31, 0x50, 0xF0, 0x00, + 0x90, 0x00, 0x70, 0x00, 0x94, 0x02, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0xE9, 0xF0, 0x00, 0x7F, 0xFF, 0x60, 0x04, + 0x82, 0x00, 0x20, 0x57, 0xA2, 0xA0, 0x91, 0xC7, 0x20, 0xD3, 0xA2, 0x9F, 0x80, 0xFB, 0x70, 0x00, 0x90, 0x06, 0x82, 0xE2, 0x30, 0xD3, 0x98, 0x01, + 0xF0, 0x00, 0x70, 0x00, 0x98, 0x04, 0x91, 0xC7, 0x30, 0x50, 0xF0, 0x00, 0x91, 0x00, 0x70, 0x00, 0xE1, 0xC0, 0x30, 0xD0, 0x70, 0x00, 0xF0, 0x00, + 0x90, 0x03, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0xED, 0x70, 0x00, 0xF0, 0x00, 0xA2, 0xF6, 0x31, 0x05, 0xF0, 0x00, 0xF0, 0x00, 0x0B, 0x22, 0xD0, 0x80, + 0xF0, 0x00, 0x0B, 0xFD, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x98, 0xD9, 0xF0, 0x00, 0x70, 0x00, 0x80, 0xDB, 0xF0, 0x00, 0x2D, 0xBB, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0x81, 0x08, 0xF0, 0x00, 0x70, 0x00, 0x81, 0x0B, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0x85, 0x83, 0xFF, 0x1D, 0x17, 0x60, 0x08, + 0xF0, 0x00, 0x1D, 0x19, 0x60, 0x09, 0x10, 0x07, 0x00, 0x00, 0x60, 0x02, 0x10, 0x07, 0x01, 0xF4, 0x60, 0x03, 0x10, 0x12, 0x03, 0xE8, 0x60, 0x04, + 0x10, 0x13, 0x00, 0x00, 0x60, 0x05, 0x10, 0x14, 0x00, 0x3C, 0x60, 0x06, 0x10, 0x15, 0x00, 0x00, 0x60, 0x07, 0x10, 0x16, 0x01, 0xF4, 0x60, 0x00, + 0x10, 0x17, 0x03, 0xE8, 0x60, 0x01, 0x10, 0x10, 0x00, 0x00, 0x60, 0x00, 0x10, 0x11, 0x00, 0x3C, 0x60, 0x01, 0x10, 0x10, 0x00, 0x00, 0x60, 0x02, + 0x10, 0x11, 0x00, 0x64, 0x60, 0x03, 0x10, 0x12, 0x00, 0xC8, 0x60, 0x04, 0x10, 0x13, 0x70, 0x00, 0xF0, 0x00, 0x10, 0x14, 0x70, 0x00, 0xA2, 0x7D, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x20, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x25, 0xF0, 0x00, 0x1D, 0x17, 0x60, 0x06, 0xF0, 0x00, 0x0C, 0xFC, 0xD0, 0x80, + 0xF0, 0x00, 0x1D, 0x17, 0x60, 0x06, 0xF0, 0x00, 0x0C, 0xFF, 0xD0, 0x80, 0x2F, 0xA0, 0x17, 0x8D, 0x60, 0x09, 0x20, 0x21, 0x1D, 0x17, 0x60, 0x06, + 0xD2, 0x02, 0x00, 0x13, 0x4F, 0xF0, 0xC4, 0x8A, 0x70, 0x00, 0xF0, 0x00, 0x90, 0xC3, 0x40, 0x05, 0xF0, 0x00, 0x82, 0xD3, 0x00, 0x13, 0x90, 0x13, + 0x90, 0x08, 0x70, 0x00, 0x97, 0xFD, 0xF0, 0x00, 0x2E, 0x24, 0x40, 0x15, 0x32, 0x20, 0x60, 0xEB, 0x60, 0x07, 0x32, 0xA5, 0x0C, 0xFA, 0xD2, 0x80, + 0x90, 0x03, 0x0C, 0xA8, 0xD5, 0x80, 0xD0, 0x98, 0x17, 0x92, 0x60, 0x06, 0x80, 0x20, 0x0C, 0xFA, 0xD2, 0x80, 0x90, 0xC0, 0x0C, 0xCE, 0xD1, 0x80, + 0xF0, 0x00, 0x0D, 0x92, 0x60, 0x09, 0xD0, 0x42, 0x17, 0x93, 0x60, 0x06, 0x20, 0x21, 0x00, 0x7F, 0x60, 0x03, 0x81, 0x96, 0x70, 0x00, 0xF0, 0x00, + 0x82, 0x5B, 0x30, 0x16, 0x77, 0x0C, 0x82, 0xDB, 0x0C, 0x7F, 0xDD, 0x80, 0xC0, 0x51, 0x20, 0x19, 0xA2, 0x62, 0x20, 0x12, 0x70, 0x00, 0xF0, 0x00, + 0x20, 0x98, 0x70, 0x00, 0xF0, 0x00, 0x20, 0x99, 0x0D, 0x23, 0xD2, 0x80, 0xF0, 0x00, 0x0C, 0x7F, 0xD0, 0x80, 0x21, 0xA0, 0x0E, 0xD3, 0x60, 0x01, + 0x32, 0xA5, 0x0C, 0x70, 0xD0, 0x80, 0xF0, 0x00, 0x61, 0x23, 0x60, 0x00, 0x19, 0x22, 0x60, 0x08, 0x82, 0x5B, 0x9C, 0x48, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x0D, 0x34, 0xD5, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA1, 0xD1, 0xF0, 0x00, 0x70, 0x00, 0x80, 0xEE, 0xF0, 0x00, 0x05, 0x0C, 0x60, 0x00, + 0x07, 0xE9, 0x60, 0x08, 0xA2, 0x55, 0xF0, 0x00, 0x00, 0x6B, 0x60, 0x00, 0x07, 0xE8, 0x60, 0x08, 0x82, 0x53, 0xF0, 0x00, 0x0F, 0x94, 0xD2, 0x80, + 0x88, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x51, 0xEC, 0x60, 0x01, 0xA2, 0x4F, 0xA0, 0x08, 0x70, 0x00, 0xF0, 0x00, 0xAB, 0xE0, 0x70, 0x00, 0xD0, 0x08, + 0xF0, 0x00, 0x21, 0x83, 0xF0, 0x00, 0x91, 0x04, 0x70, 0x00, 0xF0, 0x00, 0x88, 0x24, 0x5F, 0x86, 0xEF, 0xC0, 0x82, 0x08, 0x0F, 0xF8, 0xD0, 0x80, + 0xF0, 0x00, 0x0D, 0x9A, 0x60, 0x0C, 0xF0, 0x00, 0x08, 0x2E, 0x60, 0x0F, 0xF0, 0x00, 0x20, 0x48, 0x40, 0x17, 0xF0, 0x00, 0x20, 0xC9, 0x58, 0x06, + 0xF0, 0x00, 0x21, 0xCA, 0xF0, 0x00, 0xF0, 0x00, 0x22, 0x4B, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0x11, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0x00, 0xF0, 0x00, + 0xA1, 0xC8, 0x21, 0x42, 0xF0, 0x00, 0xA1, 0x82, 0x20, 0x33, 0xF0, 0x00, 0xAE, 0x88, 0x20, 0x22, 0xF0, 0x00, 0xA1, 0xD8, 0x22, 0xC4, 0xF0, 0x00, + 0xA1, 0x92, 0x61, 0x34, 0x60, 0x07, 0xAF, 0x0B, 0x33, 0x40, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0xC3, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x77, 0xD0, 0x08, + 0x00, 0x6E, 0x60, 0x0C, 0xA2, 0x38, 0xF0, 0x00, 0x21, 0x47, 0xA2, 0x37, 0xC3, 0xC7, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x14, 0xD7, 0xD0, 0x80, + 0x44, 0xD0, 0x1D, 0x26, 0x60, 0x08, 0xF0, 0x00, 0x45, 0xF2, 0x45, 0x51, 0x30, 0x00, 0x46, 0x93, 0xF0, 0x00, 0x30, 0x81, 0x47, 0xF4, 0xF0, 0x00, + 0x31, 0x02, 0x05, 0x69, 0x60, 0x01, 0x31, 0x83, 0x05, 0x42, 0x60, 0x02, 0x32, 0x04, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x81, 0x70, 0x00, 0xF0, 0x00, + 0x33, 0x02, 0x70, 0x00, 0x80, 0x66, 0x1D, 0x2D, 0x60, 0x08, 0x82, 0x2C, 0xF0, 0x00, 0x4F, 0xA0, 0xA0, 0x16, 0xF0, 0x00, 0x4F, 0xB0, 0xA0, 0x15, + 0xF0, 0x00, 0x4F, 0xC0, 0xA0, 0x14, 0xF0, 0x00, 0x4F, 0xD0, 0xA0, 0x13, 0xF0, 0x00, 0x4F, 0xE0, 0xA0, 0x12, 0xF0, 0x00, 0x4F, 0xF0, 0xA0, 0x11, + 0xF0, 0x00, 0x40, 0x20, 0xA0, 0x10, 0xF0, 0x00, 0x40, 0x40, 0xA0, 0x0F, 0xF0, 0x00, 0x40, 0x50, 0xA0, 0x0E, 0xF0, 0x00, 0x40, 0x60, 0xA0, 0x0D, + 0x40, 0x00, 0x15, 0x35, 0xD2, 0x80, 0x40, 0x10, 0x15, 0x35, 0xD2, 0x80, 0x40, 0x30, 0x15, 0x35, 0xD2, 0x80, 0xF0, 0x00, 0x15, 0x2D, 0xD0, 0x80, + 0x9A, 0xD9, 0x15, 0x35, 0x60, 0x01, 0x61, 0x64, 0x60, 0x01, 0xEE, 0x00, 0x9A, 0xDB, 0x70, 0x00, 0xE1, 0xC0, 0x80, 0x59, 0x70, 0x00, 0x82, 0x19, + 0x1D, 0x26, 0x60, 0x09, 0x80, 0x06, 0x1D, 0x27, 0x60, 0x09, 0x80, 0x05, 0x1D, 0x28, 0x60, 0x09, 0x80, 0x04, 0x1D, 0x29, 0x60, 0x09, 0x80, 0x03, + 0x1D, 0x2A, 0x60, 0x09, 0x80, 0x02, 0x1D, 0x2B, 0x60, 0x09, 0x80, 0x01, 0x1D, 0x2C, 0x60, 0x09, 0x80, 0x00, 0xF0, 0x00, 0x15, 0x4A, 0xD0, 0x80, + 0x9F, 0xBA, 0x41, 0xA0, 0x40, 0xF3, 0x9F, 0xB2, 0x41, 0xA1, 0x90, 0x05, 0x9F, 0xAA, 0x70, 0x00, 0x90, 0x1A, 0x00, 0x00, 0x60, 0x02, 0x90, 0x1B, + 0xF0, 0x00, 0x32, 0x20, 0xF0, 0x00, 0xF0, 0x00, 0x32, 0xA1, 0xF0, 0x00, 0xF0, 0x00, 0x34, 0x22, 0x80, 0x1D, 0xD6, 0x21, 0x1D, 0x2D, 0x60, 0x09, + 0xC2, 0x59, 0x10, 0x00, 0x60, 0x03, 0x9E, 0x72, 0x41, 0xA0, 0xF0, 0x00, 0x9E, 0x6A, 0x40, 0xE0, 0xE2, 0x00, 0x9C, 0x6A, 0x41, 0x20, 0xE2, 0x00, + 0xF0, 0x00, 0x20, 0x12, 0xF0, 0x00, 0x92, 0x50, 0x70, 0x00, 0xE1, 0xC0, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, 0xC3, 0x5B, 0x41, 0xB0, 0xE2, 0x00, + 0xD5, 0x22, 0x70, 0x00, 0x90, 0x06, 0x9E, 0xB3, 0x41, 0xA1, 0xF0, 0x00, 0x9E, 0xAB, 0x40, 0xE1, 0xE2, 0x00, 0x9C, 0xAB, 0x41, 0x21, 0xE2, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x92, 0x91, 0x70, 0x00, 0xE1, 0xC0, 0x00, 0x01, 0x60, 0x02, 0x8F, 0xED, 0x9E, 0xB3, 0x41, 0xA1, 0xF0, 0x00, + 0x9E, 0xAB, 0x41, 0x11, 0xE2, 0x00, 0x9C, 0xAB, 0x41, 0x21, 0xE2, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x92, 0x91, 0x70, 0x00, 0xE1, 0xC0, + 0x00, 0x0B, 0x60, 0x02, 0x8F, 0xE7, 0xF0, 0x00, 0x40, 0xD1, 0x40, 0xD0, 0x00, 0x1F, 0x60, 0x02, 0x8F, 0xE5, 0xF0, 0x00, 0x10, 0x00, 0x60, 0x03, + 0xF0, 0x00, 0x41, 0xB0, 0xF0, 0x00, 0xC3, 0x5B, 0x00, 0x0A, 0x60, 0x02, 0x00, 0x00, 0x60, 0x02, 0xE6, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xE0, + 0x9F, 0xF9, 0x41, 0xA0, 0x40, 0xF3, 0xF0, 0x00, 0x41, 0xA1, 0x90, 0x01, 0x00, 0x06, 0x60, 0x02, 0x80, 0x0B, 0xC3, 0x19, 0x10, 0x00, 0x60, 0x03, + 0x9E, 0x72, 0x41, 0xA0, 0xF0, 0x00, 0x9E, 0x6A, 0x40, 0xE0, 0xE2, 0x00, 0x9E, 0x62, 0x41, 0x20, 0xE2, 0x00, 0x9C, 0x6A, 0x41, 0x00, 0xE2, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x92, 0x50, 0x70, 0x00, 0xE1, 0xC0, 0xC3, 0x5B, 0x70, 0x00, 0xF0, 0x00, 0x41, 0xA1, 0x00, 0x17, 0x60, 0x02, + 0x00, 0x37, 0x60, 0x02, 0xE6, 0x00, 0x90, 0x01, 0x70, 0x00, 0xE0, 0xC0, 0x44, 0x03, 0x20, 0xA7, 0xA1, 0xDE, 0x91, 0xC4, 0x70, 0x00, 0xF0, 0x00, + 0x41, 0xA1, 0x41, 0xA0, 0xE2, 0x40, 0xF0, 0x00, 0x15, 0x93, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x98, 0x05, 0x9E, 0x6B, 0x70, 0x00, 0x90, 0x05, + 0x9C, 0x43, 0x70, 0x00, 0x90, 0x05, 0x9C, 0x6B, 0x70, 0x00, 0x9C, 0x02, 0xF0, 0x00, 0x70, 0x00, 0x9C, 0x04, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x00, + 0x41, 0xA3, 0x70, 0x00, 0x80, 0x03, 0x40, 0x83, 0x70, 0x00, 0x80, 0x02, 0x41, 0x53, 0x70, 0x00, 0x80, 0x01, 0x94, 0xEB, 0x70, 0x00, 0x80, 0x00, + 0x4F, 0xE0, 0x15, 0x32, 0xD0, 0x80, 0xF0, 0x00, 0x4F, 0xF0, 0xA0, 0x02, 0xD7, 0x12, 0x4F, 0xB0, 0xA0, 0x01, 0xF0, 0x00, 0x15, 0xC5, 0xD0, 0x80, + 0xF0, 0x00, 0x40, 0xF3, 0xA1, 0xCC, 0xC2, 0x9B, 0x70, 0x00, 0xF0, 0x00, 0x9C, 0xEB, 0x70, 0x00, 0xF0, 0x00, 0x82, 0xDB, 0x70, 0x00, 0xE1, 0x40, + 0x94, 0xEB, 0x15, 0x32, 0xD0, 0x80, 0x4F, 0xB0, 0x70, 0x00, 0xAF, 0xB3, 0x4F, 0xF0, 0x70, 0x00, 0x8F, 0xB2, 0xF0, 0x00, 0x08, 0xCC, 0x60, 0x09, + 0xF0, 0x00, 0x61, 0xBD, 0x60, 0x01, 0xF0, 0x00, 0x61, 0xC0, 0x60, 0x02, 0x35, 0x91, 0x70, 0x00, 0xF0, 0x00, 0x36, 0x12, 0x08, 0x7F, 0x60, 0x00, + 0x08, 0xC3, 0x60, 0x08, 0x81, 0xC1, 0xF0, 0x00, 0x16, 0x95, 0xD2, 0x80, 0x05, 0x44, 0x60, 0x03, 0xF0, 0x00, 0x0E, 0x21, 0x60, 0x09, 0x8F, 0x87, + 0xF0, 0x00, 0x16, 0x9B, 0xD2, 0x80, 0xF0, 0x00, 0x24, 0xB3, 0xF0, 0x00, 0x0E, 0x21, 0x60, 0x09, 0x8F, 0x84, 0x00, 0x26, 0x60, 0x00, 0xA0, 0x05, + 0x80, 0x12, 0x60, 0x03, 0xF0, 0x00, 0x0E, 0x20, 0x60, 0x09, 0x8F, 0x81, 0x00, 0x30, 0x60, 0x00, 0xA0, 0x02, 0x80, 0x03, 0x60, 0x03, 0xF0, 0x00, + 0x0E, 0x20, 0x60, 0x09, 0x8F, 0x7E, 0xF0, 0x00, 0x16, 0xCB, 0xD0, 0x80, 0x0A, 0x15, 0x60, 0x08, 0xF0, 0x00, 0xF0, 0x00, 0x21, 0x5B, 0xD2, 0x80, + 0xF0, 0x00, 0x1B, 0xCD, 0x60, 0x08, 0x22, 0x10, 0x70, 0x00, 0xF0, 0x00, 0x2C, 0x87, 0x70, 0x00, 0xF0, 0x00, 0x22, 0x91, 0x7F, 0xFF, 0x60, 0x06, + 0x91, 0xC7, 0x2D, 0x0C, 0xF0, 0x00, 0x2E, 0x0A, 0x17, 0xCE, 0xD5, 0x80, 0xF0, 0x00, 0x33, 0x06, 0xF0, 0x00, 0xF0, 0x00, 0x33, 0x86, 0xF0, 0x00, + 0xF0, 0x00, 0x34, 0x06, 0xF0, 0x00, 0x34, 0x86, 0x17, 0xCE, 0xD0, 0x80, 0xF0, 0x00, 0x32, 0x94, 0xF0, 0x00, 0x91, 0xC7, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x17, 0xF7, 0xD5, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x9E, 0xB7, 0x39, 0x12, 0xE2, 0x00, 0x83, 0x8F, 0x39, 0x12, 0xE2, 0x00, + 0xF0, 0x00, 0x18, 0x8F, 0xD0, 0x80, 0x82, 0x00, 0x03, 0xE0, 0x60, 0x08, 0x0C, 0x1D, 0x60, 0x09, 0xC0, 0x10, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0x33, 0x10, 0x1A, 0xA2, 0xD0, 0x80, 0x82, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x09, 0x5D, 0x60, 0x08, 0xA1, 0x9A, 0xF0, 0x00, 0x34, 0x80, 0xF0, 0x00, + 0xF0, 0x00, 0x34, 0x00, 0xD0, 0x08, 0x82, 0x00, 0x04, 0xA8, 0x60, 0x0A, 0xF0, 0x00, 0x06, 0x98, 0x60, 0x01, 0x09, 0xE2, 0x60, 0x08, 0xC0, 0x08, + 0xF0, 0x00, 0x10, 0x21, 0xF0, 0x00, 0xF0, 0x00, 0x31, 0x80, 0xD0, 0x08, 0xF0, 0x00, 0x18, 0x93, 0xD2, 0x80, 0x08, 0x46, 0x60, 0x08, 0xA1, 0x91, + 0xF0, 0x00, 0x29, 0x00, 0xA1, 0x90, 0x9E, 0x30, 0x70, 0x00, 0xF0, 0x00, 0x09, 0x97, 0x60, 0x08, 0xD4, 0x09, 0x09, 0x6E, 0x60, 0x00, 0xA1, 0x8D, + 0xF0, 0x00, 0x30, 0x80, 0xD0, 0x08, 0x4F, 0xD0, 0x09, 0x7D, 0x60, 0x08, 0x4F, 0xE1, 0x40, 0x02, 0xF0, 0x00, 0x36, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0x33, 0x81, 0x70, 0x00, 0x80, 0x20, 0x0A, 0x66, 0x60, 0x08, 0xF0, 0x00, 0x0A, 0x87, 0x60, 0x09, 0xA0, 0x0D, 0xF0, 0x00, 0x0F, 0x84, 0xD2, 0x80, + 0x83, 0xFF, 0x1D, 0x3E, 0xD0, 0x80, 0x0A, 0x6D, 0x60, 0x08, 0xF0, 0x00, 0x0A, 0x87, 0x60, 0x09, 0xA0, 0x09, 0xF0, 0x00, 0x0F, 0x84, 0xD2, 0x80, + 0x31, 0x90, 0x03, 0xE8, 0x60, 0x00, 0x32, 0x11, 0x0F, 0xBE, 0xD2, 0x80, 0x90, 0x07, 0x70, 0x00, 0xF0, 0x00, 0x80, 0x98, 0x0F, 0xBE, 0xD2, 0x80, + 0x8B, 0xC7, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x04, 0x31, 0x87, 0x40, 0x07, 0x90, 0x80, 0x0F, 0xBE, 0xD2, 0x80, 0x31, 0x00, 0x1D, 0x67, 0xD0, 0x80, + 0x58, 0x07, 0x22, 0x25, 0xF0, 0x00, 0x91, 0x04, 0x03, 0x87, 0x60, 0x00, 0x7F, 0xFC, 0x60, 0x06, 0xD0, 0x09, 0x82, 0x2A, 0x0F, 0x9C, 0xD2, 0x80, + 0x80, 0xB8, 0x27, 0x14, 0xA1, 0x74, 0x81, 0x39, 0x0F, 0xE7, 0xD2, 0x80, 0xA2, 0x76, 0x20, 0x21, 0xF0, 0x00, 0xF0, 0x00, 0x20, 0xA2, 0xF0, 0x00, + 0xF0, 0x00, 0x21, 0x23, 0xD0, 0x08, 0xF7, 0xCF, 0x60, 0x03, 0xF0, 0x00, 0x28, 0x00, 0x60, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x70, 0x00, 0xC0, 0x08, + 0xF0, 0x00, 0x10, 0x32, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x0D, 0xA2, 0x60, 0x09, 0xA1, 0x6A, 0x20, 0x12, 0x22, 0x63, 0xD2, 0x80, + 0xF0, 0x00, 0x35, 0x82, 0xD0, 0x08, 0x90, 0x82, 0x0D, 0xA2, 0x60, 0x08, 0x40, 0xA0, 0x40, 0x70, 0xE6, 0x40, 0xF0, 0x00, 0x70, 0x00, 0x81, 0x66, + 0x23, 0x3E, 0x60, 0x05, 0xA1, 0x64, 0x8E, 0x2D, 0x23, 0x43, 0x60, 0x06, 0x91, 0xC1, 0x22, 0xF1, 0xD5, 0x80, 0x8F, 0x86, 0x3E, 0xE6, 0x60, 0x03, + 0x91, 0xC1, 0x22, 0xF1, 0xD5, 0x80, 0x80, 0x18, 0x70, 0x00, 0xF0, 0x00, 0x91, 0xC1, 0x22, 0xF1, 0xD0, 0x80, 0x0C, 0x78, 0x60, 0x08, 0xA0, 0x01, + 0x40, 0x11, 0x40, 0x94, 0x81, 0x5C, 0x90, 0x00, 0xFF, 0xEF, 0x60, 0x06, 0xF0, 0x00, 0x23, 0xB8, 0xD1, 0x80, 0x41, 0x06, 0x23, 0xB6, 0xD0, 0x80, + 0x00, 0x02, 0x60, 0x03, 0x80, 0x05, 0x00, 0x04, 0x60, 0x03, 0x80, 0x04, 0x00, 0x06, 0x60, 0x03, 0x80, 0x03, 0xF0, 0x00, 0x23, 0x18, 0xD0, 0x80, + 0xF0, 0x00, 0x23, 0x18, 0xD0, 0x80, 0x00, 0x10, 0x60, 0x03, 0x80, 0x00, 0xF0, 0x00, 0x20, 0x84, 0xA1, 0x52, 0xC2, 0xE3, 0x70, 0x00, 0xF0, 0x00, + 0x90, 0x41, 0x23, 0x8C, 0xD1, 0x80, 0xF0, 0x00, 0x23, 0x77, 0xD0, 0x80, 0x40, 0xC0, 0x0C, 0x95, 0x60, 0x08, 0x40, 0x81, 0x0C, 0x92, 0x60, 0x09, + 0xF0, 0x00, 0x30, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x11, 0xD0, 0x08, 0x20, 0x02, 0x58, 0x01, 0x81, 0x4A, 0xD0, 0x40, 0x25, 0x21, 0xD5, 0x80, + 0x40, 0xC2, 0x62, 0x36, 0x60, 0x01, 0xA0, 0x06, 0x60, 0x00, 0x81, 0x47, 0x54, 0x55, 0x60, 0x01, 0x81, 0x46, 0x55, 0x55, 0x60, 0x01, 0x81, 0x45, + 0x15, 0x11, 0x60, 0x01, 0x81, 0x44, 0x00, 0x01, 0x60, 0x01, 0x81, 0x43, 0xF0, 0x00, 0x1C, 0x29, 0x60, 0x09, 0xC5, 0x04, 0x30, 0x80, 0xF0, 0x00, + 0x83, 0x24, 0x3D, 0x14, 0xD0, 0x08, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x02, 0xF0, 0x00, 0x40, 0x30, 0xAE, 0xC3, 0xF0, 0x00, 0x26, 0x10, 0xD0, 0x80, + 0xF0, 0x00, 0x40, 0x30, 0xAE, 0xC3, 0xF0, 0x00, 0x26, 0x11, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x0E, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x08, + 0xF0, 0x00, 0x00, 0x7A, 0x60, 0x08, 0x40, 0x01, 0x19, 0x32, 0x60, 0x09, 0xF0, 0x00, 0x21, 0x80, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x11, 0xF0, 0x00, + 0x90, 0x00, 0x25, 0xD6, 0xD2, 0x80, 0x00, 0x00, 0x60, 0x02, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x03, 0xA1, 0x2D, 0x00, 0x00, 0x60, 0x01, 0x80, 0x07, + 0xF0, 0x00, 0x19, 0x30, 0x60, 0x09, 0xF0, 0x00, 0x03, 0x4E, 0x60, 0x01, 0xF0, 0x00, 0x5A, 0xCC, 0x60, 0x02, 0x10, 0x11, 0x00, 0x01, 0x60, 0x03, + 0x10, 0x12, 0x70, 0x00, 0xF0, 0x00, 0x10, 0x13, 0x2C, 0xB6, 0xD2, 0x80, 0x00, 0x03, 0x60, 0x01, 0x80, 0x00, 0xF0, 0x00, 0x19, 0x34, 0x60, 0x08, + 0xF0, 0x00, 0x33, 0x03, 0x60, 0x02, 0x30, 0x01, 0x10, 0x10, 0x60, 0x03, 0xF0, 0x00, 0x27, 0x25, 0xD0, 0x80, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x1C, 0x75, 0x60, 0x08, 0xA1, 0x25, 0xF0, 0x00, 0x62, 0x5B, 0x60, 0x00, 0x1C, 0x77, 0x60, 0x08, 0x81, 0x23, 0x82, 0x00, 0x29, 0x01, 0xF0, 0x00, + 0xF0, 0x00, 0x3A, 0x02, 0xF0, 0x00, 0xF0, 0x00, 0x3B, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x39, 0x80, 0xF0, 0x00, 0x9E, 0x7F, 0x37, 0x01, 0x40, 0x23, + 0x9E, 0x77, 0x27, 0x15, 0xD1, 0x80, 0x90, 0x47, 0x27, 0x18, 0xD1, 0x80, 0x9E, 0x6F, 0x27, 0x12, 0xD1, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, + 0xF0, 0x00, 0x39, 0x03, 0xF0, 0x00, 0xF0, 0x00, 0x38, 0x83, 0xF0, 0x00, 0x40, 0x21, 0x26, 0x37, 0xD2, 0x80, 0xF0, 0x00, 0x27, 0x39, 0xD2, 0x80, + 0x19, 0x64, 0x60, 0x02, 0xF0, 0x00, 0x19, 0x64, 0x60, 0x03, 0xA1, 0x0E, 0x40, 0x00, 0x27, 0x1B, 0xD0, 0x80, 0x1C, 0x67, 0x60, 0x08, 0xA1, 0x11, + 0xF0, 0x00, 0x27, 0x00, 0x81, 0x10, 0xF0, 0x00, 0x01, 0x8E, 0x60, 0x00, 0x1C, 0x92, 0x60, 0x08, 0x81, 0x0F, 0x82, 0x92, 0x1C, 0xAF, 0x60, 0x0E, + 0x62, 0xE8, 0x60, 0x06, 0xA0, 0x86, 0x30, 0x66, 0x1C, 0xA2, 0x60, 0x0F, 0xF0, 0x00, 0x62, 0xDD, 0x60, 0x07, 0xF0, 0x00, 0x62, 0xDF, 0x60, 0x00, + 0x30, 0x77, 0x62, 0xE4, 0x60, 0x01, 0x32, 0x70, 0x1C, 0xD8, 0x60, 0x08, 0x34, 0x71, 0x62, 0x8E, 0x60, 0x00, 0xF0, 0x00, 0x62, 0x8C, 0x60, 0x01, + 0x31, 0x80, 0x1C, 0xBA, 0x60, 0x09, 0x30, 0x81, 0x62, 0xC2, 0x60, 0x02, 0xF0, 0x00, 0x62, 0xBD, 0x60, 0x03, 0x33, 0x12, 0x62, 0xD9, 0x60, 0x04, + 0x32, 0x93, 0x1C, 0x94, 0x60, 0x0A, 0x35, 0x94, 0x62, 0x9D, 0x60, 0x05, 0xF0, 0x00, 0x62, 0x9B, 0x60, 0x06, 0x30, 0xA5, 0x62, 0xA3, 0x60, 0x07, + 0x30, 0x26, 0x1C, 0xEA, 0x60, 0x0B, 0x34, 0xA7, 0x62, 0x94, 0x60, 0x00, 0xF0, 0x00, 0x62, 0x97, 0x60, 0x01, 0x31, 0xB0, 0x62, 0x99, 0x60, 0x02, + 0x32, 0x31, 0x1C, 0xD0, 0x60, 0x0C, 0x32, 0xB2, 0x62, 0xA5, 0x60, 0x03, 0xF0, 0x00, 0x62, 0xAC, 0x60, 0x04, 0x30, 0xC3, 0x62, 0xB0, 0x60, 0x05, + 0x31, 0xC4, 0x62, 0xAE, 0x60, 0x06, 0x32, 0xC5, 0x70, 0x00, 0xF0, 0x00, 0x32, 0x46, 0x70, 0x00, 0x8F, 0xE2, 0xF0, 0x00, 0x28, 0x70, 0xD0, 0x80, + 0x82, 0x00, 0x70, 0x00, 0xAD, 0xDF, 0xF0, 0x00, 0x29, 0x46, 0xD0, 0x80, 0xF0, 0x00, 0x31, 0xE4, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x02, + 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xCA, 0xF0, 0x00, 0x29, 0x61, 0xD0, 0x80, 0xF0, 0x00, 0x60, 0x6D, 0xD1, 0x80, 0xF0, 0x00, 0x70, 0x00, 0x8D, 0xDB, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xC5, 0xF0, 0x00, 0x23, 0xBD, 0xD2, 0x80, 0xF0, 0x00, 0x29, 0xB4, 0xD0, 0x80, 0xF0, 0x00, 0x23, 0xD7, 0xD2, 0x80, + 0xF0, 0x00, 0x29, 0xBA, 0xD0, 0x80, 0xF0, 0x00, 0x23, 0xD5, 0xD2, 0x80, 0xF0, 0x00, 0x29, 0xBE, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x4E, + 0xF0, 0x00, 0x29, 0xE7, 0xD0, 0x80, 0x40, 0x12, 0x28, 0x76, 0xD2, 0x80, 0xF0, 0x00, 0x29, 0xF4, 0xD1, 0x80, 0x00, 0x40, 0x60, 0x00, 0xAE, 0xA4, + 0x00, 0x40, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x2C, 0x7A, 0xD7, 0x80, 0xF0, 0x00, 0x11, 0x7C, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x3D, + 0xF0, 0x00, 0x2A, 0x35, 0xD0, 0x80, 0x0C, 0xB2, 0x60, 0x0D, 0xF0, 0x00, 0xF0, 0x00, 0x28, 0x6A, 0xD2, 0x80, 0xF0, 0x00, 0x19, 0x05, 0xD2, 0x80, + 0xF0, 0x00, 0x0B, 0xE9, 0xD2, 0x80, 0xF0, 0x00, 0x0B, 0xF7, 0xD2, 0x80, 0xF0, 0x00, 0x01, 0xF1, 0xD2, 0x80, 0xF0, 0x00, 0x2A, 0x7B, 0xD0, 0x80, + 0xF0, 0x00, 0x23, 0xBD, 0xD2, 0x80, 0xF0, 0x00, 0x2A, 0x8A, 0xD0, 0x80, 0xF0, 0x00, 0x18, 0x7C, 0xD2, 0x80, 0xF0, 0x00, 0x2A, 0x91, 0xD0, 0x80, + 0xF0, 0x00, 0x0B, 0xF8, 0xD2, 0x80, 0xF0, 0x00, 0x0B, 0xEC, 0xD2, 0x80, 0xF0, 0x00, 0x01, 0xF5, 0xD2, 0x80, 0xF0, 0x00, 0x2A, 0x9B, 0xD0, 0x80, + 0x62, 0xB6, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x28, 0x89, 0xD0, 0x80, 0xF0, 0x00, 0x28, 0x92, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x43, + 0x62, 0xBA, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x28, 0x89, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xBB, 0xF0, 0x00, 0x11, 0x7C, 0xD2, 0x80, + 0x2B, 0x03, 0x60, 0x00, 0x8F, 0xCE, 0xF0, 0x00, 0x2B, 0x0D, 0xD2, 0x80, 0x62, 0xC0, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x51, 0x28, 0x89, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x24, 0xF0, 0x00, 0x2B, 0x14, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAE, 0x25, 0xF0, 0x00, 0x2B, 0x19, 0xD0, 0x80, + 0x62, 0xC6, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x28, 0x89, 0xD0, 0x80, 0xF0, 0x00, 0x28, 0x90, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0x32, + 0x62, 0xCA, 0x60, 0x00, 0xF0, 0x00, 0x40, 0x21, 0x28, 0x89, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xA0, 0xAB, 0xF0, 0x00, 0x11, 0x7C, 0xD2, 0x80, + 0x2B, 0x21, 0x60, 0x00, 0x8F, 0xBE, 0xF0, 0x00, 0x19, 0x1F, 0xD2, 0x80, 0x40, 0x01, 0x26, 0xEE, 0xD2, 0x80, 0x40, 0x11, 0x26, 0xF0, 0xD2, 0x80, + 0x40, 0x11, 0x26, 0xF2, 0xD2, 0x80, 0xF0, 0x00, 0x0B, 0xF1, 0xD2, 0x80, 0xF0, 0x00, 0x0B, 0xEC, 0xD2, 0x80, 0xF0, 0x00, 0x0C, 0x00, 0xD2, 0x80, + 0x00, 0x80, 0x60, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x2C, 0x7B, 0xD2, 0x80, 0x40, 0x11, 0x0B, 0x90, 0xD7, 0x80, 0x2B, 0x4F, 0x60, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x2B, 0x4E, 0xD0, 0x80, 0x40, 0x21, 0x0B, 0x90, 0xD2, 0x80, 0xF0, 0x00, 0x1B, 0x32, 0xD2, 0x80, 0xF0, 0x00, 0x19, 0x21, 0xD2, 0x80, + 0xF0, 0x00, 0x2B, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x0C, 0xF0, 0x00, 0x2B, 0x7A, 0xD0, 0x80, 0x0C, 0xB2, 0x60, 0x0D, 0xF0, 0x00, + 0xF0, 0x00, 0x28, 0x6A, 0xD2, 0x80, 0xF0, 0x00, 0x21, 0xA2, 0xD2, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x2F, 0xF0, 0x00, 0x2B, 0x9D, 0xD0, 0x80, + 0xF0, 0x00, 0x2B, 0xC0, 0xD2, 0x80, 0xF0, 0x00, 0x0D, 0xA3, 0x60, 0x08, 0x2B, 0xC9, 0x60, 0x00, 0xF0, 0x00, 0x20, 0x01, 0x28, 0x87, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x01, 0xF0, 0x00, 0x2B, 0xE7, 0xD0, 0x80, 0xF0, 0x00, 0x28, 0x73, 0xD2, 0x80, 0x9C, 0x2F, 0x40, 0x01, 0xF0, 0x00, + 0x9C, 0x0F, 0x0A, 0xA7, 0xD1, 0x80, 0x9A, 0x1F, 0x0A, 0xA7, 0xD1, 0x80, 0xF0, 0x00, 0x0A, 0xA7, 0xD1, 0x80, 0xF0, 0x00, 0x0A, 0x91, 0xD0, 0x80, + 0x0C, 0xC4, 0x60, 0x08, 0xF0, 0x00, 0xF0, 0x00, 0x2C, 0x8A, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAF, 0x78, 0x90, 0x47, 0x70, 0x00, 0xF0, 0x00, + 0x9E, 0x2F, 0x70, 0x00, 0xE0, 0x40, 0xF0, 0x00, 0x40, 0x31, 0xE2, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x90, 0x82, 0x0D, 0xA3, 0x60, 0x08, + 0x40, 0x10, 0x40, 0x60, 0xE6, 0x40, 0xF0, 0x00, 0x70, 0x00, 0x80, 0x84, 0x40, 0x02, 0x40, 0x01, 0x80, 0x32, 0x40, 0x12, 0x40, 0x01, 0x80, 0x31, + 0x0D, 0x15, 0x60, 0x08, 0xA0, 0x80, 0x3F, 0x01, 0x27, 0x2E, 0xD2, 0x80, 0x9E, 0x38, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0x94, 0x04, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xA1, 0xF0, 0x00, 0x70, 0x00, 0x90, 0x02, 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xC2, 0x43, 0xE1, 0x70, 0x00, 0x80, 0x04, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xA3, 0x41, 0x31, 0x70, 0x00, 0x90, 0x02, 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xC2, 0x43, 0xE1, 0x70, 0x00, 0x80, 0x00, + 0xF0, 0x00, 0x63, 0x0B, 0x60, 0x02, 0x40, 0x10, 0x2D, 0x5D, 0xD2, 0x80, 0xF0, 0x00, 0x2D, 0xB2, 0xD0, 0x80, 0xF0, 0x00, 0x26, 0x41, 0xD2, 0x80, + 0xF0, 0x00, 0x2F, 0xC2, 0xD2, 0x80, 0xF0, 0x00, 0x28, 0x5A, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xB5, 0x40, 0x10, 0x32, 0x14, 0xD0, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xAD, 0xB7, 0xF0, 0x00, 0x30, 0x1E, 0xD0, 0x80, 0xF0, 0x00, 0x0D, 0x15, 0x60, 0x08, 0xF0, 0x00, 0x17, 0x9B, 0x60, 0x00, + 0xF0, 0x00, 0x17, 0x9B, 0x60, 0x01, 0x3F, 0x80, 0x0D, 0xAC, 0x60, 0x09, 0x30, 0x01, 0x56, 0xA5, 0x60, 0x02, 0xF0, 0x00, 0x5E, 0x86, 0x60, 0x03, + 0x10, 0x12, 0x59, 0x89, 0x60, 0x04, 0x10, 0x13, 0x61, 0xAD, 0x60, 0x05, 0x10, 0x14, 0x5C, 0x6C, 0x60, 0x06, 0x10, 0x15, 0x64, 0xD3, 0x60, 0x07, + 0x10, 0x16, 0x55, 0x2D, 0x60, 0x00, 0x10, 0x17, 0x5C, 0xEB, 0x60, 0x01, 0x10, 0x10, 0x58, 0x04, 0x60, 0x02, 0x10, 0x11, 0x60, 0x04, 0x60, 0x03, + 0x10, 0x12, 0x5A, 0xDB, 0x60, 0x04, 0x10, 0x13, 0x63, 0x1D, 0x60, 0x05, 0x10, 0x14, 0x0D, 0xA4, 0x60, 0x0A, 0x10, 0x15, 0x02, 0xE1, 0x60, 0x06, + 0xF0, 0x00, 0x43, 0x14, 0x60, 0x07, 0x10, 0x26, 0x04, 0x5B, 0x60, 0x00, 0x10, 0x27, 0x44, 0x95, 0x60, 0x01, 0x10, 0x20, 0x05, 0xD5, 0x60, 0x02, + 0x10, 0x21, 0x46, 0x16, 0x60, 0x03, 0x10, 0x22, 0x06, 0xAE, 0x60, 0x04, 0x10, 0x23, 0x00, 0x00, 0x60, 0x05, 0x10, 0x24, 0x70, 0x00, 0xF0, 0x00, + 0x10, 0x25, 0x70, 0x00, 0xD0, 0x08, 0x40, 0x05, 0x0D, 0x4F, 0x60, 0x0C, 0xF0, 0x00, 0x02, 0x09, 0x60, 0x03, 0x35, 0xC2, 0x08, 0xFB, 0x60, 0x06, + 0x8F, 0x4D, 0x31, 0x40, 0xF0, 0x00, 0x8E, 0xC4, 0x20, 0x47, 0x90, 0x06, 0x81, 0x65, 0x70, 0x00, 0xF0, 0x00, 0x8F, 0x84, 0x40, 0x12, 0xF0, 0x00, + 0x81, 0x65, 0x08, 0xFB, 0x60, 0x03, 0x8E, 0xA9, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0xC2, 0x70, 0x00, 0xF0, 0x00, 0xC2, 0x51, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x36, 0x41, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0x45, 0xF0, 0x00, 0xF0, 0x00, 0x30, 0xC7, 0x80, 0x38, 0xD1, 0xC2, 0x35, 0x71, 0x35, 0x60, + 0xD6, 0x0B, 0x1C, 0x29, 0x60, 0x0B, 0xC4, 0x9A, 0x40, 0x27, 0xF0, 0x00, 0xD2, 0x0B, 0x3D, 0xB2, 0xF0, 0x00, 0xC4, 0xF3, 0x3B, 0xB7, 0xF0, 0x00, + 0x83, 0xB6, 0x3E, 0x33, 0xF0, 0x00, 0xF0, 0x00, 0x3B, 0x36, 0xF0, 0x00, 0xF0, 0x00, 0x3C, 0x36, 0xD0, 0x08, 0x82, 0x0A, 0x00, 0x61, 0x90, 0x09, + 0xF0, 0x00, 0x30, 0xE3, 0xD0, 0x80, 0x17, 0xB4, 0x60, 0x08, 0xA0, 0x37, 0xF0, 0x00, 0x00, 0x02, 0xA0, 0x36, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, + 0x82, 0x8A, 0x70, 0x00, 0x90, 0x03, 0x90, 0x8A, 0x70, 0x00, 0x90, 0x01, 0xF0, 0x00, 0x70, 0x00, 0x8F, 0xFB, 0x82, 0xBF, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x01, 0xB7, 0xD0, 0x80, 0x17, 0xAC, 0x60, 0x0E, 0xA0, 0x2F, 0x4F, 0xF6, 0x00, 0x61, 0xA0, 0x2E, 0x90, 0x41, 0x70, 0x00, 0xF0, 0x00, + 0x82, 0x0A, 0x00, 0x61, 0x90, 0x04, 0x91, 0x8E, 0x70, 0x00, 0x97, 0xFD, 0x37, 0x46, 0x70, 0x00, 0xF0, 0x00, 0xD7, 0xB1, 0x17, 0xB2, 0x60, 0x00, + 0xF0, 0x00, 0x30, 0xF3, 0xD0, 0x80, 0xF0, 0x00, 0x30, 0xE7, 0xD0, 0x80, 0x21, 0x40, 0x31, 0x91, 0xD0, 0x80, 0xF0, 0x00, 0x2C, 0x86, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xD4, 0x09, 0xF0, 0x00, 0x27, 0x2E, 0xD2, 0x80, 0x90, 0x00, 0x70, 0x00, 0xD0, 0x08, 0x0D, 0x4F, 0x60, 0x0C, 0xA0, 0x21, + 0x26, 0x42, 0x41, 0xD7, 0xA0, 0x20, 0x90, 0x82, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x60, 0x50, 0xD1, 0x80, 0xF0, 0x00, 0x31, 0xFE, 0xD2, 0x80, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0x90, 0x00, 0x0D, 0xAC, 0x60, 0x08, 0x0D, 0xB2, 0x60, 0x08, 0xE6, 0x00, 0xF0, 0x00, 0x30, 0x6F, 0xD2, 0x80, + 0x83, 0xFF, 0x00, 0xFF, 0x60, 0x04, 0x7F, 0xFF, 0x60, 0x02, 0xCA, 0x86, 0xF0, 0x00, 0x00, 0x01, 0xA0, 0x16, 0xA2, 0x09, 0x00, 0x80, 0x60, 0x03, + 0xC2, 0x61, 0x0D, 0xB9, 0x60, 0x0B, 0x82, 0x59, 0x0D, 0xB8, 0x60, 0x0A, 0x89, 0x09, 0x70, 0x00, 0xF0, 0x00, 0x8E, 0x55, 0x70, 0x00, 0xF0, 0x00, + 0xD1, 0xCB, 0x40, 0x15, 0x90, 0x02, 0x90, 0x42, 0x30, 0x33, 0xF0, 0x00, 0x91, 0xC6, 0x30, 0x27, 0xF0, 0x00, 0x91, 0xCF, 0x70, 0x00, 0xF0, 0x00, + 0xC3, 0xAF, 0x01, 0xB7, 0xD2, 0x80, 0xD7, 0xF3, 0x70, 0x00, 0xF0, 0x00, 0x96, 0xEF, 0x70, 0x00, 0x8C, 0xDD, 0x40, 0x10, 0x2F, 0xB7, 0xD2, 0x80, + 0xF0, 0x00, 0x2E, 0x60, 0xD2, 0x80, 0xF0, 0x00, 0x31, 0xBE, 0xD0, 0x80, 0x0D, 0x4F, 0x60, 0x08, 0xA0, 0x06, 0x2F, 0x00, 0x31, 0xF7, 0xD0, 0x80, + 0x0D, 0x4F, 0x60, 0x08, 0xA0, 0x04, 0x3E, 0x82, 0x19, 0xDD, 0x60, 0x09, 0x3E, 0x03, 0x1A, 0x33, 0x60, 0x0A, 0x30, 0x12, 0x70, 0x00, 0xF0, 0x00, + 0x30, 0x23, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08, 0xF0, 0x00, 0x33, 0x57, 0xD0, 0x80, 0xF0, 0x00, 0x33, 0x95, 0xD2, 0x80, + 0xF0, 0x00, 0x63, 0x81, 0xD0, 0x80, 0xF0, 0x00, 0x17, 0x8D, 0x60, 0x08, 0xF0, 0x00, 0x40, 0x87, 0x60, 0x00, 0xF0, 0x00, 0x20, 0x2B, 0x60, 0x00, + 0x10, 0x00, 0x20, 0x2C, 0x60, 0x00, 0x10, 0x00, 0x21, 0x35, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x17, 0x92, 0x60, 0x08, 0xF0, 0x00, 0xEE, 0xEE, 0x60, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x17, 0x93, 0x60, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x0D, 0x92, 0x60, 0x00, + 0x10, 0x00, 0x00, 0x05, 0x60, 0x00, 0x10, 0x00, 0x1D, 0x19, 0x60, 0x00, 0x10, 0x00, 0x00, 0x05, 0x60, 0x00, 0x10, 0x00, 0x1D, 0x1E, 0x60, 0x00, + 0x10, 0x00, 0x00, 0x03, 0x60, 0x00, 0x10, 0x00, 0x1D, 0x23, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x17, 0x9B, 0x60, 0x08, 0xF0, 0x00, 0x19, 0x04, 0x60, 0x00, 0xF0, 0x00, 0x00, 0x60, 0x60, 0x00, 0x10, 0x00, 0x19, 0x1C, 0x60, 0x00, + 0x10, 0x00, 0x00, 0x60, 0x60, 0x00, 0x10, 0x00, 0x19, 0x1F, 0x60, 0x00, 0x10, 0x00, 0xC0, 0x5E, 0x60, 0x00, 0x10, 0x00, 0x19, 0x25, 0x60, 0x00, + 0x10, 0x00, 0xC0, 0x5E, 0x60, 0x00, 0x10, 0x00, 0x1E, 0x28, 0x60, 0x00, 0x10, 0x00, 0xC0, 0x52, 0x60, 0x00, 0x10, 0x00, 0x1E, 0x2D, 0x60, 0x00, + 0x10, 0x00, 0xC0, 0x52, 0x60, 0x00, 0x10, 0x00, 0x29, 0x18, 0x60, 0x00, 0x10, 0x00, 0xC0, 0x3A, 0x60, 0x00, 0x10, 0x00, 0x29, 0x18, 0x60, 0x00, + 0x10, 0x00, 0x80, 0x38, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x17, 0xAC, 0x60, 0x08, 0xF0, 0x00, 0x02, 0xA8, 0x60, 0x00, 0xF0, 0x00, 0x03, 0x5C, 0x60, 0x00, 0x10, 0x00, 0x06, 0x99, 0x60, 0x00, + 0x10, 0x00, 0x10, 0x3B, 0x60, 0x00, 0x10, 0x00, 0x15, 0x06, 0x60, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x17, 0xB2, 0x60, 0x08, 0xF0, 0x00, 0x55, 0x04, 0x60, 0x00, 0xF0, 0x00, 0x00, 0x03, 0x60, 0x00, + 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x17, 0xB4, 0x60, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x00, + 0xF0, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x10, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0x70, 0x00, 0xD0, 0x08 +}; + +const size_t PatchSize205 = sizeof(PatchByteValues205); +const unsigned char * pPatchBytes205 = &PatchByteValues205[0]; + +extern const size_t LutSize205; +extern const unsigned char * pLutBytes205; +static unsigned char LutByteValues205[] = +{ + 0x80, 0x17, 0x80, 0x45, 0x80, 0x96, 0x81, 0x5B, + 0x82, 0xD6, 0x83, 0x76, 0x88, 0x0B, 0x88, 0x10, + 0x88, 0xDB, 0x89, 0x48, 0x89, 0xE9, 0x8B, 0x0A, + 0x8B, 0x12, 0x8B, 0x13, 0x8B, 0x21, 0x8B, 0x26, + 0x8C, 0x6F, 0x8F, 0x91, 0x8F, 0xF6, 0x94, 0xD0, + 0x95, 0x20, 0x95, 0x33, 0x95, 0x6F, 0x95, 0xA8, + 0x95, 0xAC, 0x95, 0xC3, 0x95, 0xE1, 0x97, 0xC9, + 0x97, 0xF6, 0x98, 0x8D, 0x99, 0x00, 0x9A, 0x00, + 0x9E, 0x73, 0xA0, 0x12, 0xA1, 0x03, 0xA1, 0x68, + 0xA2, 0xF0, 0xA3, 0x0D, 0xA3, 0x4C, 0xA3, 0x52, + 0xA3, 0xED, 0xA5, 0x20, 0xA5, 0x25, 0xA6, 0x0F, + 0xA6, 0x1D, 0xA8, 0x31, 0xAB, 0x01, 0xAB, 0x1F, + 0xAB, 0x4C, 0xAC, 0x76, 0xAC, 0x88, 0xAC, 0x97, + 0xAD, 0xB0, 0xAD, 0xB7, 0xAD, 0xB8, 0xB0, 0x55, + 0xB0, 0xC6, 0xB0, 0xE2, 0xB1, 0x01, 0xB1, 0x0B, + 0xB1, 0x35, 0xB1, 0x3B, 0xB1, 0x97, 0xB3, 0x03 +}; + +const size_t LutSize205 = sizeof(LutByteValues205); +const unsigned char *pLutBytes205 = &LutByteValues205[0]; diff --git a/src/constants.h b/src/constants.h new file mode 100644 index 0000000..1e2e9e2 --- /dev/null +++ b/src/constants.h @@ -0,0 +1,224 @@ +static const uint8_t RDSLogo[] PROGMEM = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00, + 0x07, 0xfc, 0x00, 0x1f, 0xe8, 0x00, 0x03, 0xf8, 0x00, + 0x07, 0xff, 0x00, 0x1f, 0xfc, 0x00, 0x0f, 0xfe, 0x00, + 0x0f, 0xff, 0x80, 0x3f, 0xff, 0x00, 0x1f, 0xfc, 0x00, + 0x0f, 0xff, 0xc0, 0x1f, 0xff, 0x00, 0x3f, 0xf8, 0x00, + 0x0f, 0x8f, 0xc0, 0x3e, 0x3f, 0x80, 0x3e, 0x10, 0x00, + 0x0f, 0x0f, 0x80, 0x3e, 0x0f, 0xc0, 0x3e, 0x00, 0x00, + 0x1f, 0x0f, 0x80, 0x3c, 0x0f, 0x80, 0x7e, 0x00, 0x00, + 0x1f, 0x0f, 0x9c, 0x7e, 0x0f, 0xce, 0x7f, 0x80, 0x00, + 0x1f, 0xbf, 0x1e, 0x7c, 0x07, 0xce, 0x3f, 0xf0, 0x00, + 0x1f, 0xfe, 0x1c, 0x7c, 0x0f, 0x9e, 0x3f, 0xf8, 0x00, + 0x1f, 0xfc, 0x1c, 0x7c, 0x0f, 0x9c, 0x1f, 0xf8, 0x00, + 0x3f, 0xf0, 0x3c, 0x78, 0x0f, 0x9c, 0x03, 0xf8, 0x00, + 0x3e, 0xf8, 0x10, 0xf8, 0x1f, 0x14, 0x00, 0xf8, 0x00, + 0x3e, 0xf8, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0xf8, 0x00, + 0x3e, 0x7c, 0x00, 0xf8, 0xfe, 0x00, 0xe1, 0xf8, 0x00, + 0x3c, 0x7e, 0x00, 0xff, 0xfc, 0x00, 0xf7, 0xf0, 0x00, + 0x7c, 0x7e, 0x01, 0xff, 0xf8, 0x01, 0xff, 0xe0, 0x00, + 0x7c, 0x3f, 0x01, 0xff, 0xe0, 0x03, 0xff, 0xe0, 0x00, + 0x7c, 0x3f, 0x01, 0xff, 0x80, 0x00, 0xff, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static const uint8_t USBLogo[] PROGMEM = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0b, 0xff, 0xff, 0xf0, 0x00, + 0x00, 0x3f, 0xff, 0xff, 0xf0, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xe0, 0x00, + 0x01, 0xdf, 0xae, 0x5f, 0x7f, 0x80, + 0x03, 0x87, 0x08, 0x06, 0x00, 0x40, + 0x07, 0x8f, 0x18, 0x03, 0x00, 0x40, + 0x2f, 0x0e, 0x00, 0xc2, 0x10, 0x20, + 0x3f, 0x0f, 0x10, 0xfe, 0x3c, 0x40, + 0x7f, 0x0e, 0x18, 0x1e, 0x00, 0x80, + 0x7f, 0x1e, 0x18, 0x04, 0x00, 0x80, + 0x7f, 0x0e, 0x3e, 0x06, 0x30, 0x40, + 0x7e, 0x1c, 0x13, 0xc4, 0x38, 0x40, + 0xaf, 0x08, 0x21, 0xc4, 0x28, 0x40, + 0x0f, 0x00, 0x60, 0x04, 0x00, 0x80, + 0x0f, 0x00, 0xf0, 0x08, 0x01, 0x80, + 0x07, 0xeb, 0xfe, 0xbe, 0xf6, 0x00, + 0x03, 0xff, 0xff, 0xff, 0x80, 0x00, + 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x7f, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +static const uint16_t pe5pvblogo[] PROGMEM = { + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ab, 0x73f0, 0x7bf1, 0x7bf1, 0x424a, 0x39e8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x2104, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x8c94, 0xc65c, 0xce9e, 0xce9d, 0xb5fa, 0xadb9, 0x6b6f, 0x52cc, 0x18e4, 0x18e3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c7, 0x8431, 0x94b3, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634e, 0xbe1b, 0xc69f, 0xc67f, 0xc67e, 0xc69e, 0xce9e, 0xcebe, 0xbe1b, 0x8c94, 0x8452, 0x4a6a, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x630c, 0x8c52, 0xc65a, 0xd6dc, 0xb597, 0x630c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4229, 0xad78, 0xc69e, 0xbe5e, 0xb61d, 0xb61c, 0xb61d, 0xbe3d, 0xbe5d, 0xc67e, 0xcebf, 0xc67d, 0x8453, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x52ab, 0x9cf4, 0xbdf9, 0xd6bb, 0xdf1d, 0xdf1d, 0xce9b, 0xb5d8, 0x5b0d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a3, 0x73d0, 0xce9d, 0xbe5e, 0xb61d, 0xb61d, 0xb61d, 0xb61c, 0xb61c, 0xb61c, 0xb63d, 0xbe7e, 0xc67f, 0x8cb6, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6e, 0xbdd8, 0xc619, 0xdefd, 0xe73e, 0xe75e, 0xef5e, 0xe75e, 0xe73e, 0xdf1e, 0xbe1a, 0x4a8b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x9d17, 0xc67e, 0xbe3d, 0xb63d, 0xbe3e, 0xbe3e, 0xbe3e, 0xbe3e, 0xb63d, 0xb63d, 0xbe5e, 0xc67f, 0x94d6, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x8c92, 0xdefd, 0xe71e, 0xe75e, 0xe75e, 0xe75e, 0xe75e, 0xe75e, 0xe75e, 0xe75f, 0xdf3f, 0xcebe, 0xb5fa, 0x52ab, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10c3, 0x8c73, 0xc67d, 0xbe3e, 0xb63d, 0xb63e, 0xbe3e, 0xbe5e, 0xbe5f, 0xbe5f, 0xbe5e, 0xbe3e, 0xbe5e, 0xc67e, 0x94f6, 0x2987, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x9cf4, 0xe77f, 0xe75f, 0xe75f, 0xe75e, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xef5f, 0xdf3e, 0xc67e, 0xc69e, 0x94d5, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4229, 0xc65c, 0xc67e, 0xbe3d, 0xb63d, 0xbe3e, 0xbe5e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xc67e, 0x9d17, 0x3187, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8431, 0xdf1e, 0xe75f, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xef7f, 0xdf3f, 0xc65d, 0xbe5e, 0xc65d, 0x73b0, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0xad98, 0xc67e, 0xbe3e, 0xb63d, 0xbe3e, 0xbe5e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xc67e, 0x9d37, 0x31a7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aec, 0xce9c, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xef7f, 0xe73f, 0xc67d, 0xb61d, 0xbe5e, 0xc65c, 0x8432, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8432, 0xc65d, 0xbe5e, 0xb63d, 0xbe3e, 0xbe3e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xc67e, 0x9d15, 0x3186, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528a, 0xc63a, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xc67e, 0xb61d, 0xb61d, 0xc67e, 0xc67d, 0x7c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4209, 0xbe3b, 0xc67e, 0xbe3d, 0xb63d, 0xbe3e, 0xbe5e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe1c, 0x73b0, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x9cd4, 0xe75e, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xce9e, 0xb61d, 0xb61d, 0xb61d, 0xc67e, 0xb5da, 0x424a, 0x0000, 0x8411, 0x9d15, 0x9cf5, 0x94d5, 0x94d5, 0x94d5, 0xad78, 0xbe3d, 0xbe3d, 0xb61d, 0xbe3e, 0xbe3e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe5f, 0xb5fb, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8431, 0xe73e, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xcebe, 0xbe3e, 0xb61d, 0xb61d, 0xb61d, 0xbe3d, 0xb5fb, 0xadba, 0xc65c, 0xcebe, 0xc69e, 0xc69e, 0xc67e, 0xc67d, 0xbe5d, 0xb61d, 0xb61d, 0xb63e, 0xbe3e, 0xbe5f, 0xb63f, 0x9d5d, 0x8d1d, 0xa5de, 0xae1f, 0xb65f, 0xbe5f, 0xbe5f, 0xbe5e, 0xbe1c, 0x5aed, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5acb, 0xc63a, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xcede, 0xbe3e, 0xb61f, 0x9d7d, 0x955c, 0xb61d, 0xbe3d, 0xbe5d, 0xbe5d, 0xbe5d, 0xbe3d, 0xbe3d, 0xbe3d, 0xb61d, 0xb61d, 0xb61d, 0xbe3e, 0xbe3e, 0xbe5e, 0xbe5f, 0xa5be, 0x63fb, 0x5bdc, 0x6c5d, 0x7cbd, 0x8d1d, 0x9d7e, 0xb63f, 0xbe5f, 0xbe3c, 0x5aed, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0xb5b7, 0xe77f, 0xe77f, 0xe77f, 0xe75f, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xcedf, 0xadfe, 0x84dc, 0x5379, 0x5bb9, 0x955d, 0xb61e, 0xb61d, 0xb63d, 0xb63d, 0xb63d, 0xbe3e, 0xbe3e, 0xbe5e, 0xbe5e, 0xbe5e, 0xc67f, 0xc67f, 0xc67f, 0xb63f, 0x84fd, 0x53dd, 0x4b9c, 0x435b, 0x4b7c, 0x5bfd, 0x5bdc, 0x63da, 0x9d7d, 0xc67d, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0xa556, 0xe75e, 0xe77f, 0xe77f, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xdf5f, 0xbe5e, 0x749d, 0x5bdc, 0x53dd, 0x53dd, 0x747d, 0xadde, 0xbe7f, 0xbe7f, 0xbe7f, 0xc67f, 0xc67f, 0xc69f, 0xc69f, 0xc69f, 0xcebf, 0xcebf, 0xcebf, 0xcebf, 0xadfe, 0x641d, 0x433b, 0x2a78, 0x2236, 0x2257, 0x32da, 0x4b9d, 0x4b9c, 0x953c, 0xc69d, 0x632e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x4a4a, 0x7bf0, 0x632d, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bf0, 0xd6dc, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xd71f, 0xcebe, 0xadff, 0x63db, 0x32b9, 0x2a98, 0x3b1a, 0x53bc, 0x851d, 0xb63f, 0xbe7f, 0xc67e, 0xc65e, 0xc65e, 0xc67e, 0xc67e, 0xc67e, 0xc67e, 0xc67e, 0xc69f, 0xbe5f, 0x7cdd, 0x435b, 0x2a99, 0x2258, 0x2258, 0x2278, 0x2a99, 0x331c, 0x4b9d, 0x955d, 0xc67d, 0x6b6e, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x5acc, 0x94b4, 0xbe1a, 0xd6bd, 0xadb8, 0x5b0d, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73af, 0xce9c, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe73f, 0xcebe, 0xc67e, 0xb63f, 0x5378, 0x2237, 0x2237, 0x2257, 0x32d9, 0x53bc, 0x8cfd, 0xb63e, 0xad99, 0xa538, 0xa558, 0xa578, 0xa578, 0xa558, 0xa558, 0xad99, 0xbe5d, 0x955d, 0x53bc, 0x32da, 0x2a79, 0x2aba, 0x2abb, 0x2adb, 0x2adb, 0x32fc, 0x4b9d, 0x9d5d, 0xc67e, 0x9d37, 0x39c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6e, 0x8c94, 0xbe1a, 0xdf1f, 0xd6ff, 0xd6ff, 0xdeff, 0xbdfa, 0x632d, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0xbdf9, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xd6df, 0xbe5e, 0xb65f, 0x63da, 0x2a99, 0x2a99, 0x2a78, 0x2278, 0x3afa, 0x5bfc, 0xadfe, 0x8453, 0x31c7, 0x31a7, 0x31a7, 0x31a7, 0x31a7, 0x2986, 0x632d, 0xa579, 0x747c, 0x3b3b, 0x2a99, 0x2a9a, 0x32dc, 0x32fd, 0x32fd, 0x331d, 0x331d, 0x539c, 0x9d7d, 0xbe5e, 0xc69e, 0xa578, 0x8452, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0x5acc, 0x73d0, 0x9d36, 0x9d16, 0x9d37, 0xad98, 0x39c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x52ab, 0x94f5, 0xc67b, 0xd6de, 0xd6de, 0xcebe, 0xce9d, 0xce9d, 0xd6be, 0xd6fe, 0xbe1a, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xad77, 0xe75f, 0xe75f, 0xe75f, 0xe77f, 0xef7f, 0xdf1f, 0xbe5e, 0xb65f, 0x749d, 0x3b1b, 0x32fc, 0x2abb, 0x2a99, 0x2278, 0x3b1a, 0x747c, 0x84b7, 0x18e4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b8e, 0x7c7a, 0x537b, 0x2a99, 0x2a99, 0x2abb, 0x32fc, 0x32fd, 0x331d, 0x3b3d, 0x331d, 0x5bbc, 0xa5be, 0xbe3e, 0xbe5e, 0xc6be, 0xc67c, 0x8c93, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a3, 0x73d0, 0x9d16, 0xa557, 0xbdfb, 0xc65c, 0xcebe, 0xcebf, 0xcebf, 0xc65d, 0x8433, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ab, 0xad77, 0xbe1a, 0xd6de, 0xd6de, 0xce9d, 0xc67d, 0xc67d, 0xc67d, 0xc67d, 0xc67d, 0xcebe, 0xd6ff, 0xbe1a, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73cf, 0xce9c, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xef7f, 0xdf3f, 0xc67e, 0xbe5f, 0x8d3e, 0x435c, 0x32fd, 0x32dc, 0x2aba, 0x2a79, 0x2a78, 0x3b1a, 0x6c3b, 0x5b73, 0x426e, 0x31ec, 0x8c95, 0xaddb, 0xa59b, 0xa59c, 0x63fb, 0x32b9, 0x2a79, 0x2aba, 0x32dc, 0x32fd, 0x32fd, 0x331d, 0x331d, 0x331d, 0x63fc, 0xadff, 0xbe7e, 0xbe3e, 0xbe5e, 0xc69e, 0xc67c, 0x8c73, 0x4a6a, 0x632e, 0x6b8f, 0xbe1a, 0xbe1b, 0xc65c, 0xce9e, 0xc67e, 0xc67e, 0xc65d, 0xbe5d, 0xbe5d, 0xc67e, 0xce9e, 0xbe3b, 0x73d0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x8452, 0xce7c, 0xd6de, 0xd6de, 0xce9d, 0xc67d, 0xc67d, 0xc67d, 0xce9d, 0xce9e, 0xce9e, 0xce9d, 0xce9d, 0xcebe, 0xd6de, 0x9cf5, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x738f, 0xce9b, 0xe75f, 0xe73f, 0xe75f, 0xe77f, 0xef7f, 0xe77f, 0xdf3f, 0xc69e, 0xbe5f, 0xa5de, 0x53bc, 0x331d, 0x32fd, 0x32dc, 0x2aba, 0x2279, 0x2278, 0x3af9, 0x63fb, 0x745c, 0x63fc, 0x641c, 0x6c5d, 0x641d, 0x53bc, 0x32da, 0x2aba, 0x32db, 0x3b1c, 0x3b1d, 0x331d, 0x331d, 0x331d, 0x331d, 0x32fd, 0x641c, 0xae1f, 0xc69f, 0xbe7e, 0xbe5e, 0xbe3d, 0xc67d, 0xbe3c, 0xbe1b, 0xce9d, 0xc67d, 0xce9e, 0xc67e, 0xc65d, 0xbe3d, 0xbe3d, 0xbe1c, 0xbe1c, 0xbe1c, 0xbe3d, 0xbe3d, 0xbe5e, 0xce9e, 0xa536, 0x39e8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a09, 0xce9c, 0xd6ff, 0xd6de, 0xce9d, 0xc67d, 0xc67d, 0xce9e, 0xcebe, 0xcebf, 0xcebf, 0xcebf, 0xcebe, 0xce9d, 0xce9d, 0xcebe, 0xce9d, 0x8c94, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x632d, 0xce9b, 0xe75f, 0xe73f, 0xe75f, 0xe75f, 0xe77f, 0xe75f, 0xdf1d, 0xb5b8, 0xa578, 0xbe5e, 0xadff, 0x5bfc, 0x3b1d, 0x32fd, 0x32fd, 0x32fc, 0x32fb, 0x2adb, 0x2aba, 0x32db, 0x3b1c, 0x433d, 0x433d, 0x3b3d, 0x331c, 0x32fc, 0x3b3c, 0x4b7d, 0x53bd, 0x53de, 0x53be, 0x4b9d, 0x435d, 0x331d, 0x32fd, 0x32fc, 0x745c, 0xadfe, 0xc67e, 0xc69f, 0xc67e, 0xbe3e, 0xbe3d, 0xbe3c, 0xbe3d, 0xbe5d, 0xbe3d, 0xbe3d, 0xbe1c, 0xbe1c, 0xbe1c, 0xbe1c, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe5d, 0xc69e, 0xb5fb, 0x630d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4209, 0xd6bd, 0xd6de, 0xce9e, 0xc67d, 0xce9d, 0xcebe, 0xcebe, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcebf, 0xcebe, 0xce9d, 0xce9d, 0xd6de, 0xce9d, 0x8c93, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0861, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xa556, 0xe75f, 0xe73f, 0xe73f, 0xe75f, 0xe77f, 0xe75f, 0xd6bc, 0x94d3, 0x4a69, 0x9d37, 0xbe5e, 0xb63f, 0x6c5d, 0x3b3d, 0x3b3d, 0x435d, 0x4b9d, 0x4bbd, 0x4b9d, 0x437d, 0x3b3d, 0x32fc, 0x32db, 0x32db, 0x32db, 0x32db, 0x32fb, 0x435c, 0x4bbd, 0x5c1e, 0x645f, 0x645f, 0x643e, 0x53de, 0x4b7d, 0x331d, 0x3b1b, 0x84db, 0xadda, 0xb5fc, 0xc67e, 0xc69f, 0xc67e, 0xbe5d, 0xb63d, 0xb61c, 0xb61c, 0xb61c, 0xb61d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe3e, 0xbe5e, 0xbe5e, 0xbe5e, 0xbe5e, 0xbe5e, 0xbe3e, 0xbe5e, 0xcedf, 0x9cf6, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x632d, 0xbe1a, 0xcebe, 0xce9d, 0xce9e, 0xcebe, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcebe, 0xcebe, 0xce9d, 0xce9d, 0xd6de, 0xce9d, 0x8c73, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x8432, 0x8c93, 0x94b3, 0x8431, 0x5aec, 0x52ab, 0x52ab, 0x52ab, 0x52ab, 0x52ab, 0x4228, 0x1081, 0x0000, 0x0020, 0x8c72, 0xdf3e, 0xe73f, 0xe73f, 0xe75f, 0xe75f, 0xe75f, 0xce7b, 0x738f, 0x1082, 0x0000, 0x6b90, 0xaddc, 0xbe5f, 0x84dd, 0x435c, 0x4b7d, 0x53de, 0x5c1e, 0x643e, 0x5bfd, 0x437c, 0x3b1a, 0x4b39, 0x5378, 0x42f6, 0x3ab5, 0x42f6, 0x3ad5, 0x42d6, 0x5bb8, 0x4b79, 0x4b7b, 0x53bc, 0x641e, 0x643e, 0x5bfe, 0x437d, 0x3b1b, 0x7c9b, 0x8496, 0x94b5, 0xb61c, 0xc67e, 0xc69f, 0xc67f, 0xbe5e, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe5e, 0xbe5e, 0xb63e, 0xbe3e, 0xbe5f, 0xbe5f, 0xbe5f, 0xbe7f, 0xbe7f, 0xbe5e, 0xbe5e, 0xbe5e, 0xc67e, 0xce9d, 0x6b6f, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x4a6a, 0x8473, 0xbe3b, 0xcebe, 0xce9d, 0xce9e, 0xcebe, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xce9d, 0xcebe, 0xd6ff, 0xcebd, 0x7bf0, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x630c, 0xd6dd, 0xe75f, 0xe77f, 0xdefd, 0xc63a, 0xbe1a, 0xc61a, 0xc63a, 0xc63a, 0xc639, 0xb5b8, 0x9cf4, 0x94b3, 0x94d4, 0xd6bc, 0xe73e, 0xdf3f, 0xe75f, 0xe75f, 0xe75f, 0xd6dc, 0x7bf0, 0x0000, 0x0000, 0x0000, 0x73b0, 0xb5fc, 0xbe5f, 0x9d9f, 0x53dc, 0x5bfe, 0x643e, 0x5bfd, 0x4b7b, 0x3b19, 0x63d9, 0x5b75, 0x5b74, 0x7434, 0x530f, 0x3a4e, 0x428f, 0x3a6e, 0x52cf, 0x8475, 0x5b54, 0x5b76, 0x63d9, 0x4319, 0x4b7b, 0x53bd, 0x4b9e, 0x3b1d, 0x4b7c, 0x747b, 0x63b4, 0x8c74, 0xb63c, 0xc67e, 0xc69f, 0xc69f, 0xbe7f, 0xbe5f, 0xb63f, 0xa5de, 0x9d7d, 0x8cfc, 0x953c, 0xb63f, 0xbe5f, 0xbe7f, 0xbe7f, 0xbe7f, 0xbe7f, 0xbe7f, 0xbe7f, 0xbe7e, 0xc67e, 0x94d5, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aec, 0x94f5, 0xb5b9, 0xd6fe, 0xcede, 0xc69d, 0xce9e, 0xcebe, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xcebe, 0xcedf, 0xd6ff, 0xb5b9, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x94b3, 0xdf1e, 0xdf3f, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf3e, 0xdf3f, 0xe73f, 0xe75f, 0xe75f, 0xdf3e, 0xdf1e, 0xdefe, 0xdefd, 0xdf1e, 0xdf3e, 0xe73f, 0xe75f, 0xe75f, 0xdf3e, 0x9cf4, 0x2104, 0x0000, 0x0000, 0x0000, 0x8432, 0xbe3c, 0xbe5e, 0xae3f, 0x747c, 0x5c1e, 0x4b7c, 0x4b39, 0x5b77, 0x7436, 0x6392, 0x4aad, 0x31a9, 0x3a09, 0x2124, 0x0000, 0x0000, 0x0000, 0x2103, 0x424a, 0x2988, 0x4a8d, 0x73f3, 0x8497, 0x63b7, 0x42f8, 0x3b1b, 0x3b3d, 0x331d, 0x4b9d, 0x6c1b, 0x5b74, 0x9d37, 0xbe5e, 0xbe7f, 0xbe5f, 0xa5de, 0x955e, 0x84fd, 0x747d, 0x641d, 0x53bc, 0x5bda, 0x9d9d, 0xbe5f, 0xbe7f, 0xbe7f, 0xc67f, 0xc69f, 0xc69f, 0xc69f, 0xbe5e, 0xc67e, 0x9d37, 0x2987, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x73b0, 0xb5f9, 0xd6de, 0xd6de, 0xce9d, 0xc67d, 0xc67d, 0xce9e, 0xcebe, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xcedf, 0xd6de, 0xb5b9, 0x4249, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0xa556, 0xdf1f, 0xdf1e, 0xdefe, 0xdefe, 0xdefe, 0xdefe, 0xdefe, 0xdefe, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf3f, 0xe75f, 0xe75f, 0xe73e, 0xad97, 0x4a49, 0x0020, 0x0000, 0x0000, 0x632d, 0xb5da, 0xbe5e, 0xb63e, 0xbe5f, 0x8d1d, 0x4319, 0x63d8, 0x84b8, 0x5310, 0x4aac, 0x10c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2985, 0x52ed, 0x6371, 0x84b8, 0x5378, 0x2ab9, 0x32fc, 0x331d, 0x4b7c, 0x63fb, 0x7c99, 0x9d9e, 0x851e, 0x7cbd, 0x6c3d, 0x53bb, 0x4b5a, 0x433a, 0x433b, 0x4b7c, 0x53bd, 0x84dd, 0xb63f, 0xbe7f, 0xc67f, 0xc69f, 0xcebf, 0xcebf, 0xc67e, 0xc67e, 0xad99, 0x5b0d, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x630d, 0xad77, 0xce9c, 0xd6de, 0xcebe, 0xc69d, 0xc67d, 0xc69d, 0xce9e, 0xcebe, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xcebe, 0xcebd, 0x8c73, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4249, 0xd6bd, 0xdf1f, 0xdf1e, 0xdefe, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf1e, 0xdf3e, 0xdf3f, 0xe73f, 0xe75f, 0xe75f, 0xbdf9, 0x5acb, 0x0021, 0x0000, 0x0000, 0x18c3, 0x8474, 0xc65e, 0xbe3e, 0xbe3f, 0xbe3f, 0x9d5c, 0x6bf7, 0x8476, 0x422a, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x4a6b, 0x4ab0, 0x6bf8, 0x32b9, 0x32fc, 0x32fc, 0x3b1b, 0x4b5a, 0x4b7a, 0x433a, 0x3af9, 0x32b8, 0x2a77, 0x2256, 0x2236, 0x2236, 0x2a78, 0x3b3b, 0x63fd, 0xa5be, 0xbe7f, 0xc69f, 0xcebf, 0xcebf, 0xc67e, 0xc65d, 0xad99, 0x632d, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x39c7, 0x632d, 0xc67c, 0xd6de, 0xcede, 0xce9d, 0xc67d, 0xc67d, 0xce9d, 0xcebe, 0xcebe, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6df, 0xce9d, 0x94b4, 0x31a7, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aec, 0xd6fe, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xe75f, 0xd6dd, 0x94b3, 0x2145, 0x0841, 0x0862, 0x2125, 0x7c12, 0xbe3c, 0xbe5e, 0xb63e, 0xb63e, 0xb61d, 0xa59a, 0x7412, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2146, 0x73f3, 0x7c79, 0x32d9, 0x32fc, 0x32fc, 0x2a9a, 0x2258, 0x2237, 0x2236, 0x2236, 0x2236, 0x2257, 0x2a78, 0x2a78, 0x2a99, 0x32db, 0x433c, 0x7cdd, 0xbe7f, 0xcebf, 0xcebf, 0xc67e, 0xbe5d, 0xb5f9, 0x634e, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x10c3, 0x8c52, 0xb5d9, 0xd6bd, 0xd6de, 0xce9d, 0xc67d, 0xc67d, 0xce9d, 0xce9e, 0xcebe, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xcebe, 0xad98, 0x4209, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc63a, 0xdf1e, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xd6ff, 0xb61c, 0xbe3d, 0xc67e, 0xc69e, 0xcebe, 0xcebd, 0x8c74, 0x632f, 0x634f, 0x8433, 0xce9d, 0xbe3e, 0xb61e, 0xb61e, 0xb5fd, 0xadba, 0x424a, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1081, 0x3185, 0x31c5, 0x31a5, 0x31c5, 0x2144, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x7413, 0x7c79, 0x3afa, 0x3b3c, 0x3b1c, 0x2ab9, 0x2a78, 0x2a78, 0x2a99, 0x2aba, 0x2adb, 0x32fb, 0x32fc, 0x331c, 0x331c, 0x331c, 0x4b7b, 0xadde, 0xc6bf, 0xc67e, 0xb5fb, 0x8c74, 0x39c7, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x4a6a, 0x8c73, 0xc65c, 0xd6df, 0xcede, 0xc69d, 0xc67d, 0xc69d, 0xce9e, 0xcebe, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6ff, 0xd6ff, 0xd6ff, 0xcebe, 0xbe1a, 0x7bf1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4249, 0xce7b, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xc69e, 0xadfd, 0xb61e, 0xb61e, 0xb61e, 0xb61d, 0xb63d, 0xbe3e, 0xbe5e, 0xc67e, 0xbe5e, 0xb61d, 0xae1e, 0xb61e, 0xb61d, 0xadba, 0x52cc, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c6, 0x7c0d, 0x7c2c, 0x7c2b, 0x846d, 0x634b, 0x10c2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0x6bd3, 0x5bb8, 0x433b, 0x4b9d, 0x435d, 0x3b1c, 0x32fc, 0x32fc, 0x32fc, 0x331d, 0x3b3d, 0x437d, 0x4bbe, 0x437d, 0x32db, 0x433b, 0x955d, 0xbe3e, 0xbe1b, 0x8473, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0xa536, 0xd6fe, 0xcebe, 0xcebf, 0xcebe, 0xcebe, 0xcebe, 0xcebe, 0xcebf, 0xcebf, 0xc67e, 0xc67e, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6de, 0xc65c, 0x7bf1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c93, 0xd6dd, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf1f, 0xbe5e, 0xae1f, 0xa5dd, 0xa59c, 0xa59b, 0xa59b, 0xa59b, 0xa5bc, 0xadbc, 0xadbc, 0xadbc, 0xaddd, 0xae1e, 0xb61e, 0xb61c, 0x8c73, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632a, 0xa570, 0x7ca9, 0x7ca8, 0x8cec, 0xa531, 0x2944, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1905, 0x8496, 0x5bb9, 0x437c, 0x4bbe, 0x437d, 0x3b3d, 0x331d, 0x3b1d, 0x3b5d, 0x4bbd, 0x5bfe, 0x53fe, 0x3b3b, 0x4319, 0x7cbc, 0xaddd, 0xbe1b, 0x8c94, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x73af, 0xb5d9, 0xc67d, 0xcebe, 0xcede, 0xd6ff, 0xd6df, 0xcedf, 0xc69f, 0xadfe, 0x8cfc, 0x8d1b, 0xbe5e, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6de, 0xce9d, 0xa557, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73d0, 0xd6bd, 0xdefe, 0xdf1f, 0xe73f, 0xe75f, 0xe73f, 0xdf3f, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xd6ff, 0xb63e, 0xa5de, 0x9d9d, 0x9d7c, 0x9d9c, 0xa59b, 0xa59c, 0xa59c, 0xa59c, 0xa5bc, 0xaddd, 0xadfe, 0xb61e, 0xbe3d, 0xa558, 0x3a09, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x9490, 0xadb3, 0xbe72, 0x84e7, 0x7ce5, 0x8d29, 0xceb5, 0x9d11, 0x73ad, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73d0, 0x63d6, 0x3b1a, 0x4b9d, 0x4b9e, 0x435d, 0x3b3d, 0x435d, 0x53be, 0x5c1e, 0x5bfe, 0x435b, 0x4b39, 0x84dc, 0xb61e, 0x9d17, 0x7c11, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c8, 0x94d5, 0xce9d, 0xcebe, 0xd6ff, 0xcebf, 0xb63e, 0x9d9e, 0x84dd, 0x7c9d, 0x7c9c, 0x9d5d, 0xc67f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcedf, 0xcedf, 0xd6ff, 0xd6ff, 0xd6ff, 0xcebd, 0xa557, 0x52ab, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x8432, 0xc65b, 0xd6fe, 0xdf1f, 0xe73f, 0xe75f, 0xe75f, 0xdf3f, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xcebf, 0xadfe, 0xa5be, 0xa5bd, 0xa5bd, 0xa5bd, 0xa5bd, 0xa5bd, 0xa5bd, 0xa5dd, 0xaddd, 0xadfe, 0xb61e, 0xb61e, 0xb5db, 0x6b8f, 0x0841, 0x0000, 0x0841, 0x630b, 0xa512, 0x73ad, 0x4a68, 0xa552, 0xb5f2, 0xadd0, 0xa5af, 0x8d0a, 0x6c23, 0x6402, 0x7445, 0x9d6d, 0xa5cf, 0xadb1, 0xadb3, 0x7c0e, 0x73ad, 0x9cf0, 0xad72, 0x4247, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c55, 0x5357, 0x435c, 0x4b9e, 0x437d, 0x437d, 0x53be, 0x5c1e, 0x53dd, 0x431a, 0x5378, 0x955d, 0xbe5e, 0x9d37, 0x424a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c7, 0x94b4, 0xbe3c, 0xb61e, 0x9d9d, 0x8d1d, 0x747c, 0x63fa, 0x63fa, 0x6c5c, 0x7cdd, 0x9d9e, 0xc69f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xcebe, 0xc63b, 0x52ab, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a3, 0x5b0c, 0xa536, 0xc63a, 0xdf1e, 0xdf3f, 0xe75f, 0xe75f, 0xe73f, 0xdf3f, 0xdf3f, 0xdf1f, 0xdf1f, 0xbe7e, 0xa5bd, 0xa5be, 0xadfe, 0xadfe, 0xadfe, 0xadde, 0xa5de, 0xa5de, 0xadde, 0xadfe, 0xb61f, 0xb61e, 0xb5fd, 0x9d17, 0x4a4a, 0x0000, 0x1082, 0x634c, 0xbe15, 0xc676, 0xc655, 0xc675, 0xbe32, 0x9d8d, 0x8508, 0x7464, 0x6422, 0x6421, 0x6422, 0x6401, 0x6c22, 0x7ca6, 0x8d2a, 0xa5af, 0xbe53, 0xc694, 0x9d4e, 0x8ccd, 0xa551, 0x31c5, 0x0000, 0x0000, 0x0000, 0x0000, 0x424a, 0x8cf9, 0x3afa, 0x4b9d, 0x4bbe, 0x53be, 0x5bfe, 0x53bd, 0x3af9, 0x5bb9, 0xa5bd, 0xbe5e, 0xa558, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x8c95, 0x9d5b, 0x8cfd, 0x749c, 0x63da, 0x4b57, 0x4317, 0x4316, 0x4b57, 0x63fa, 0x84dd, 0xa5be, 0xc69f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6de, 0xce7c, 0x8432, 0x18e4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3186, 0x73af, 0xc65a, 0xd6dd, 0xdf1e, 0xe73f, 0xe75f, 0xe75f, 0xe73f, 0xdf3f, 0xdf1f, 0xbe5e, 0xa59d, 0xa59d, 0xae1e, 0xb63f, 0xb63f, 0xae1e, 0xadfe, 0xadde, 0xadde, 0xadfe, 0xb61f, 0xb61e, 0xb61c, 0x8c73, 0x0000, 0x0000, 0x2144, 0x9d12, 0xceb6, 0xd6d6, 0xceb4, 0xa58e, 0x7ca7, 0x6c64, 0x6c42, 0x6c42, 0x74a3, 0x7ce4, 0x8505, 0x7cc4, 0x7482, 0x6c42, 0x6c43, 0x7465, 0x84e9, 0x952a, 0x8d28, 0x7ca5, 0x84ab, 0xb5f4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x4acf, 0x4b59, 0x435c, 0x4bbe, 0x53de, 0x4bbd, 0x431a, 0x6c1a, 0xb61e, 0xc67f, 0xbe3c, 0x8453, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0xa579, 0x8d1c, 0x747c, 0x5399, 0x4b37, 0x4b37, 0x5378, 0x5399, 0x5358, 0x4b58, 0x63fb, 0x84dd, 0xa5de, 0xc6bf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xd6de, 0xce9d, 0x7c12, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x39e8, 0x8431, 0xc63a, 0xdefe, 0xdf1f, 0xe73f, 0xe75f, 0xe73f, 0xdf3f, 0xd6ff, 0xbe5e, 0xa59c, 0xa5bd, 0xb61e, 0xb65f, 0xb65f, 0xb63f, 0xadfe, 0xadfe, 0xadfe, 0xae1e, 0xb61e, 0x94f8, 0x2104, 0x0000, 0x0000, 0x2965, 0xad73, 0xceb6, 0xced5, 0xc6b4, 0x9d8e, 0x6c25, 0x6c22, 0x7482, 0x74a3, 0x74a3, 0x74a4, 0x74a4, 0x74a4, 0x74a3, 0x74a3, 0x6c62, 0x6421, 0x5be1, 0x63e2, 0x7483, 0x7ce5, 0x8cca, 0xad91, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x424c, 0x7c9a, 0x3afa, 0x4b9e, 0x4bbe, 0x435b, 0x745b, 0xadfe, 0xbe7f, 0xbe5e, 0xbe5d, 0x9d16, 0x39c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x3a0a, 0x8477, 0x7c9b, 0x5399, 0x4b58, 0x5399, 0x5bdb, 0x5bfc, 0x5bfc, 0x5bdb, 0x5399, 0x5399, 0x6c3c, 0x84fd, 0xadfe, 0xcebf, 0xcedf, 0xcedf, 0xd6ff, 0xd6ff, 0xd6ff, 0xcebd, 0xb5d9, 0x52ab, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ab, 0xb5b8, 0xcebc, 0xd6fe, 0xdf3f, 0xe75f, 0xe73f, 0xdf3f, 0xdf1f, 0xcebe, 0xadfc, 0xa5bc, 0xaddd, 0xb63f, 0xbe5f, 0xb63f, 0xb61f, 0xb61f, 0xadff, 0xb61e, 0x9d38, 0x18e4, 0x0000, 0x0000, 0x10a2, 0x73cd, 0xd6b7, 0xceb5, 0xc694, 0xbe72, 0x954b, 0x7ca4, 0x7483, 0x6c42, 0x6442, 0x6c42, 0x6c62, 0x6c42, 0x6422, 0x6c42, 0x7483, 0x74a3, 0x6c62, 0x6401, 0x6421, 0x7cc6, 0xc6b4, 0x6b6b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a09, 0x7c56, 0x32d8, 0x32fb, 0x32fb, 0x6c1b, 0xadfe, 0xbe3d, 0xb61c, 0xbe5d, 0xc69d, 0xb5f9, 0x52cb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a6b, 0x8474, 0x9d5a, 0x84dc, 0x5bb9, 0x4b79, 0x53ba, 0x5bfc, 0x641d, 0x643d, 0x641d, 0x5c1d, 0x5bdb, 0x53ba, 0x5bfb, 0x6c5d, 0x7cbc, 0xb63e, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xcebe, 0xb5fa, 0x634e, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c72, 0xad77, 0xdefd, 0xe73f, 0xe73f, 0xdf3f, 0xdf3f, 0xdf3f, 0xd6de, 0xadba, 0xadbb, 0xaddc, 0xb61e, 0xb63f, 0xb63f, 0xb61f, 0xadfe, 0xaddc, 0x8453, 0x0861, 0x0000, 0x0000, 0x1081, 0x6b8c, 0xceb6, 0xce94, 0xceb4, 0xced5, 0xb650, 0x7ca6, 0x7483, 0x8544, 0x9605, 0xa646, 0xa666, 0x9e26, 0x95a4, 0x7d03, 0x6c62, 0x7483, 0x7ce4, 0x74a3, 0x6c62, 0x7ca6, 0xc694, 0x844f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e5, 0x7415, 0x5359, 0x2a79, 0x2278, 0x743b, 0xa578, 0x9cf6, 0x9d36, 0xce9c, 0xc67a, 0xadb6, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1904, 0x6b91, 0x8cd8, 0xa5bd, 0x747b, 0x5bb9, 0x5378, 0x53ba, 0x5bfc, 0x641d, 0x643e, 0x643e, 0x643e, 0x643d, 0x643d, 0x643d, 0x643d, 0x643d, 0x6c3b, 0xadde, 0xcebf, 0xd6ff, 0xd6ff, 0xd6df, 0xc67c, 0x7c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0x9d15, 0xc65b, 0xe73f, 0xdf3f, 0xdf3f, 0xdf1f, 0xd6dd, 0x634e, 0x8c94, 0x9d38, 0xaddc, 0xadfe, 0xb63f, 0xae1f, 0xadfe, 0xa57b, 0x5b0e, 0x0000, 0x0000, 0x0000, 0x2985, 0xb5b4, 0xced6, 0xc694, 0xced5, 0xced5, 0xc6b3, 0xa5ed, 0xa627, 0xaee7, 0xb729, 0xb70b, 0xb6eb, 0xb70a, 0xb708, 0xaea6, 0x95c5, 0x7482, 0x74a3, 0x7ce4, 0x7482, 0x6c62, 0x954c, 0xc675, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x10c4, 0x73d2, 0x9d5b, 0x745a, 0x63fa, 0x7c7a, 0x6bd1, 0x8c8e, 0x848d, 0xadd3, 0x950f, 0x950f, 0x7bed, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a68, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6f, 0x8476, 0x9d5c, 0x84dc, 0x6c1a, 0x5378, 0x4b58, 0x5399, 0x5bdb, 0x641d, 0x643e, 0x643e, 0x643e, 0x643e, 0x645e, 0x6c7e, 0x749e, 0x6c7d, 0x5bfb, 0x8d1c, 0xbe7f, 0xcedf, 0xd6ff, 0xd6df, 0xce9d, 0x9d16, 0x39c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0xa536, 0xe73f, 0xdf3f, 0xdf1f, 0xdf1f, 0xd6bd, 0x10a3, 0x0861, 0x52cc, 0x8475, 0xaddc, 0xadfe, 0xadff, 0xadde, 0xa59b, 0x634f, 0x0000, 0x0000, 0x0000, 0x31c6, 0xd6d7, 0xceb4, 0xc694, 0xceb4, 0xceb4, 0xced4, 0xd753, 0xc72e, 0xaeae, 0x8dce, 0x8552, 0x7d53, 0x8570, 0x9e2d, 0xb70b, 0xb6e7, 0x95e5, 0x7482, 0x74a3, 0x74a2, 0x6c61, 0x7cc7, 0xb611, 0x8c50, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x7c11, 0x6bd2, 0x7c76, 0x6bf4, 0x6bce, 0x8d0c, 0x8d28, 0x84e6, 0x84e5, 0x954b, 0xb5f3, 0x632b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x94b0, 0x9d31, 0x9cf0, 0x73cd, 0x0000, 0x52cc, 0x6371, 0x8cf9, 0x953d, 0x747c, 0x5bb9, 0x4b37, 0x4b38, 0x5379, 0x5bdb, 0x5bfc, 0x641d, 0x643e, 0x643e, 0x643e, 0x645e, 0x6c7e, 0x7cbe, 0x7cde, 0x643c, 0x747a, 0xb61e, 0xcebf, 0xcedf, 0xd6df, 0xd6df, 0xbe1a, 0x3a08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xa536, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd6bd, 0x18e4, 0x0000, 0x0000, 0x3a09, 0xb5da, 0xadfe, 0xa5de, 0xa5de, 0xa59b, 0x6b6f, 0x0000, 0x0020, 0x18c2, 0xb594, 0xceb6, 0xc694, 0xc694, 0xceb4, 0xc6b4, 0xdf35, 0xe7b6, 0xcf56, 0x7cf4, 0x6439, 0x53fb, 0x53db, 0x5c1b, 0x6457, 0x858f, 0xb70b, 0xaec6, 0x8d64, 0x6c61, 0x6c82, 0x6c41, 0x7484, 0x9d6d, 0xa552, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x31e8, 0x94b1, 0x9d50, 0x84c7, 0x7cc5, 0x6c43, 0x6c43, 0x7ca7, 0xced5, 0xc635, 0x842f, 0x7bed, 0x5288, 0x4a68, 0x4a88, 0x3185, 0x0000, 0x52a9, 0xad92, 0x84ab, 0x950d, 0x9d2f, 0x632b, 0x7434, 0x7459, 0x7cbd, 0x6c5d, 0x5bba, 0x4b78, 0x5379, 0x53ba, 0x5bfc, 0x641d, 0x643d, 0x643e, 0x643e, 0x643e, 0x643e, 0x6c5e, 0x749e, 0x7cde, 0x747d, 0x6c1a, 0xa5bd, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xce9d, 0x94b4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xa536, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd6bd, 0x2966, 0x0000, 0x0000, 0x2945, 0xb5fa, 0xadfe, 0xa5de, 0xa5de, 0xa59b, 0x634f, 0x5289, 0x94b1, 0xa512, 0xceb7, 0xc695, 0xc673, 0xc693, 0xc693, 0xcef4, 0xe796, 0xe798, 0xc6da, 0xa5bc, 0x5bda, 0x32b8, 0x2a98, 0x3afa, 0x4bbb, 0x5c38, 0x960e, 0xb728, 0xa645, 0x74a2, 0x6c61, 0x6c41, 0x6422, 0x952b, 0xc674, 0x94cf, 0x73ac, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c6, 0xb613, 0x8d09, 0x6402, 0x5380, 0x5380, 0x5bc2, 0x954c, 0xae10, 0xadcf, 0xadcf, 0xadd0, 0xbe33, 0xc675, 0xb5b3, 0xa552, 0xbe14, 0x9d8e, 0x8508, 0x8508, 0x8d09, 0x84ae, 0x7c96, 0x6c5b, 0x643c, 0x643d, 0x641c, 0x641c, 0x641c, 0x641d, 0x641d, 0x643e, 0x643e, 0x643e, 0x643e, 0x643e, 0x6c5e, 0x749e, 0x7cde, 0x74be, 0x641a, 0x953b, 0xcebf, 0xcedf, 0xcedf, 0xcebf, 0xcebf, 0xcebe, 0xb5b9, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xa536, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdefe, 0x9cf4, 0x0000, 0x0000, 0x2145, 0xadb9, 0xadde, 0xa5be, 0xa5de, 0xa59b, 0x634f, 0x73ad, 0xbe15, 0xce95, 0xceb5, 0xc673, 0xc673, 0xc693, 0xc693, 0xd735, 0xe7b6, 0xdf79, 0xbe7c, 0xb63e, 0x84bb, 0x3296, 0x2236, 0x2258, 0x32fb, 0x4bbb, 0x74f1, 0xb70c, 0xb6e7, 0x8543, 0x6c61, 0x6c41, 0x6401, 0x7465, 0x8d09, 0x8ceb, 0x94f0, 0x5b0a, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x31a5, 0x4a68, 0xce75, 0x8cea, 0x63e1, 0x5bc1, 0x5bc1, 0x5380, 0x5ba2, 0x63e5, 0x7446, 0x7ca7, 0x84e8, 0x8d09, 0x954b, 0x9d8c, 0xb610, 0xb610, 0x7ca7, 0x6c24, 0x6c63, 0x7cc5, 0x74a7, 0x84b0, 0x8d18, 0x63f9, 0x641c, 0x749e, 0x7cbe, 0x747e, 0x6c5e, 0x643e, 0x643e, 0x643e, 0x643e, 0x643e, 0x645e, 0x747e, 0x7cde, 0x7cbe, 0x641b, 0x7c9a, 0xc67f, 0xd6ff, 0xd6df, 0xcedf, 0xcebf, 0xcebe, 0xcebe, 0xce7c, 0x7c11, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xa556, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1e, 0xb5d8, 0x0000, 0x0000, 0x0000, 0x6350, 0x9d9c, 0xa5be, 0xa5be, 0xaddc, 0x8453, 0x73cd, 0xbe34, 0xc694, 0xc693, 0xc673, 0xc693, 0xc693, 0xc693, 0xdf55, 0xe7b6, 0xd739, 0xb65d, 0xb63e, 0xa5de, 0x7c9b, 0x4319, 0x32ba, 0x32db, 0x3b3b, 0x6453, 0xb70f, 0xbf28, 0x8da4, 0x6c60, 0x6c61, 0x6c41, 0x6c41, 0x7482, 0x7ca6, 0xbe13, 0x844f, 0x0000, 0x0000, 0x0000, 0x18c2, 0x632b, 0x9d10, 0xc654, 0xa58e, 0x6c04, 0x63e1, 0x6401, 0x6401, 0x5bc1, 0x5380, 0x5340, 0x4b40, 0x5340, 0x5361, 0x5ba1, 0x5bc2, 0x63e3, 0x63e3, 0x5ba2, 0x5360, 0x5360, 0x5bc0, 0x6c62, 0x7ca5, 0x9d70, 0xadb6, 0x7415, 0x6bf9, 0x6c3c, 0x7cfe, 0x7cde, 0x749e, 0x6c5e, 0x643e, 0x643e, 0x643e, 0x643e, 0x6c7e, 0x7cbe, 0x7cde, 0x6c5c, 0x7459, 0xb63d, 0xcedf, 0xd6ff, 0xd6df, 0xcedf, 0xcebf, 0xcebe, 0xcebe, 0xcebe, 0x9d16, 0x18e4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0xa536, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1e, 0xb5d8, 0x0000, 0x0000, 0x0000, 0x6bb1, 0xa5bc, 0xa5be, 0xa5be, 0xb61e, 0xa578, 0x7bee, 0xbe55, 0xc694, 0xc673, 0xc693, 0xc693, 0xc693, 0xc693, 0xdf55, 0xe7b6, 0xd739, 0xb63d, 0xb63e, 0xbe5f, 0xb61f, 0x84fd, 0x53dc, 0x435d, 0x32fa, 0x6472, 0xb70f, 0xbf28, 0x8da4, 0x6c60, 0x6c81, 0x7482, 0x7482, 0x7482, 0x7ca6, 0xbe34, 0x844f, 0x0000, 0x0000, 0x2965, 0x73ac, 0xadb2, 0xadf0, 0x8ce9, 0x6403, 0x5ba0, 0x63e1, 0x6421, 0x6c41, 0x6422, 0x6402, 0x63e2, 0x63c2, 0x5bc2, 0x5ba2, 0x5361, 0x5340, 0x4b40, 0x4b40, 0x5360, 0x5380, 0x5bc1, 0x6401, 0x6c40, 0x954c, 0x9d30, 0x4247, 0x2967, 0x7c15, 0x6c18, 0x6c5c, 0x7cfe, 0x7cde, 0x747e, 0x6c5e, 0x643e, 0x643e, 0x6c5e, 0x749e, 0x7cde, 0x747d, 0x63f9, 0x9d59, 0xc65b, 0xcebe, 0xd6ff, 0xd6ff, 0xcedf, 0xcebf, 0xcebe, 0xce9e, 0xd6de, 0xbe1b, 0x4a8a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x8452, 0xcebd, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1e, 0xc63a, 0x4229, 0x0000, 0x0000, 0x8c95, 0xaddd, 0xa59d, 0x9d9d, 0xadfe, 0x94f8, 0x6b4c, 0xad93, 0xadd3, 0xbe54, 0xc694, 0xc6b4, 0xc693, 0xc693, 0xd735, 0xe7b6, 0xdf79, 0xbe5b, 0xb61d, 0xbe5f, 0xc69f, 0xbe7f, 0x955e, 0x4b9b, 0x32f7, 0x7d31, 0xbf4c, 0xb708, 0x8d64, 0x6c61, 0x6c82, 0x74c3, 0x84e7, 0xa5ae, 0xb631, 0xceb6, 0x840e, 0x0000, 0x2965, 0x94d0, 0xadd1, 0xa5ae, 0x7ca6, 0x63e2, 0x5380, 0x5bc0, 0x6422, 0x7483, 0x74a4, 0x7ce5, 0x84e6, 0x8507, 0x8507, 0x8507, 0x84e7, 0x7ca6, 0x7465, 0x6c24, 0x63e2, 0x63e1, 0x6401, 0x6421, 0x6421, 0x6420, 0xadf0, 0x94ef, 0x2144, 0x0000, 0x2967, 0x7415, 0x6c18, 0x6c5c, 0x7cde, 0x7cbe, 0x6c7e, 0x645e, 0x645e, 0x6c7e, 0x7cbe, 0x74be, 0x63fa, 0x8cf8, 0x4aac, 0x6b6f, 0xc67c, 0xcedf, 0xd6ff, 0xd6df, 0xcedf, 0xcebe, 0xcebe, 0xcebe, 0xce9d, 0x8c52, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x94d4, 0xd6de, 0xdeff, 0xdefe, 0xdf1f, 0xdf1f, 0xd6bd, 0x6b6e, 0x0000, 0x73f2, 0xaddb, 0xa5bd, 0x9d7d, 0x9d9d, 0xa5bd, 0xadbb, 0x73d0, 0x5289, 0x5aea, 0xbe35, 0xbe54, 0xc694, 0xc693, 0xc693, 0xd6f4, 0xe796, 0xe7b8, 0xcefa, 0xb61b, 0xb61d, 0xbe5e, 0xbe7f, 0xae1e, 0x7cba, 0x6415, 0xa670, 0xc76a, 0xaea8, 0x7d03, 0x6c41, 0x7482, 0x7cc3, 0x954c, 0xe758, 0xdf16, 0xc695, 0xb5b4, 0x5b0a, 0x9d11, 0xbe33, 0x956c, 0x7464, 0x5bc2, 0x5380, 0x5bc1, 0x6c43, 0x7ca5, 0x8507, 0x8d48, 0x9568, 0x9569, 0x9569, 0x9569, 0x9569, 0x9569, 0x9569, 0x9548, 0x8d27, 0x84e6, 0x7484, 0x6c62, 0x6c41, 0x6441, 0x6420, 0x8d0a, 0xb612, 0x7c0d, 0x10c2, 0x0000, 0x29a8, 0x6393, 0x6c19, 0x747d, 0x7cde, 0x749e, 0x6c5e, 0x6c5e, 0x6c7e, 0x74be, 0x6c3c, 0x8cfa, 0x8453, 0x2125, 0x4a8b, 0xb5d9, 0xcebe, 0xd6ff, 0xd6df, 0xcedf, 0xcebe, 0xcebe, 0xcebe, 0xd6de, 0xa557, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x9cd4, 0xd6dd, 0xdefe, 0xdefe, 0xdf1e, 0xdf1e, 0xdf1f, 0xd6fe, 0xa577, 0x8cb5, 0xa59b, 0xa5bd, 0x9d7c, 0x9d7c, 0x9d7d, 0xa59d, 0xb61d, 0x94f7, 0x31c8, 0x0000, 0x840e, 0xc655, 0xc673, 0xc693, 0xc673, 0xceb4, 0xdf76, 0xe7b7, 0xe799, 0xcefa, 0xb63b, 0xb5fc, 0xb61c, 0xb61c, 0xbe7b, 0xc6d7, 0xc750, 0xc72b, 0x9de7, 0x6c82, 0x6c41, 0x6c82, 0x74a4, 0xadcf, 0xef99, 0xadcf, 0x954b, 0xb5f1, 0xc654, 0xbe53, 0x8d2b, 0x6c24, 0x5ba1, 0x5380, 0x6402, 0x7484, 0x8506, 0x8d48, 0x9548, 0x8d27, 0x84c6, 0x7485, 0x6c45, 0x6c24, 0x6c44, 0x7465, 0x7ca6, 0x8507, 0x8d48, 0x9548, 0x8d27, 0x7ce5, 0x7483, 0x6421, 0x63e0, 0x6c23, 0x954b, 0xbe12, 0x8c6f, 0x18c3, 0x0000, 0x424b, 0x7c56, 0x745a, 0x749d, 0x7cbe, 0x747e, 0x6c5e, 0x6c7e, 0x6c7d, 0x6c3a, 0x6bd3, 0x2987, 0x0000, 0x2104, 0x8473, 0xcebd, 0xd6df, 0xd6df, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xd6de, 0xc63b, 0x634e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x39c7, 0x9493, 0xd6dd, 0xdf1e, 0xd6fe, 0xdefe, 0xdeff, 0xdeff, 0xdeff, 0xd6ff, 0xc69e, 0xb5fd, 0xa5bd, 0x9d5c, 0x9d5c, 0x9d7c, 0x9d7d, 0x9d7d, 0xaddd, 0xa59a, 0x5aed, 0x0000, 0x4227, 0xd6b7, 0xbe73, 0xc693, 0xbe73, 0xc673, 0xced5, 0xe797, 0xefb8, 0xe799, 0xdf5a, 0xd71a, 0xd71a, 0xdf3a, 0xe79a, 0xe7d8, 0xe7b5, 0xbeae, 0x7cc5, 0x6401, 0x6421, 0x6c82, 0x7ca7, 0xcef3, 0xce94, 0x7ca6, 0x7484, 0x7c86, 0x8ccb, 0x7c69, 0x5bc3, 0x5380, 0x5ba0, 0x6c22, 0x7ca5, 0x8d07, 0x8d48, 0x8507, 0x7465, 0x6c05, 0x6be7, 0x7c6b, 0x950e, 0xa570, 0x9d6f, 0x8ccc, 0x7429, 0x6be6, 0x6c45, 0x84c6, 0x8d47, 0x8d27, 0x84e5, 0x7483, 0x63e1, 0x5bc0, 0x7464, 0x954c, 0xbe34, 0x6b6c, 0x0000, 0x10a2, 0x6bb1, 0x7c58, 0x6c3b, 0x7cbe, 0x74be, 0x6c7e, 0x6c5e, 0x6c5d, 0x953a, 0x5b2d, 0x0000, 0x0000, 0x0000, 0x73d0, 0xd6bd, 0xcede, 0xd6ff, 0xcedf, 0xcedf, 0xcebe, 0xce9e, 0xcebe, 0xc67c, 0x73b0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x6b4e, 0xb5d8, 0xdefe, 0xdefe, 0xd6fe, 0xd6fe, 0xd6ff, 0xdeff, 0xdeff, 0xd6ff, 0xc67e, 0xae1e, 0xa59d, 0x953c, 0x953c, 0x9d5d, 0x9d7d, 0x9d7d, 0x9d7d, 0xa59d, 0xb63e, 0x8474, 0x2145, 0x18e3, 0x844f, 0xce95, 0xc673, 0xbe73, 0xbe53, 0xc673, 0xd6f5, 0xe777, 0xefb8, 0xefd8, 0xefd9, 0xefb9, 0xefd9, 0xefd9, 0xefb8, 0xdf77, 0xc6b3, 0x9d6d, 0x6c46, 0x6c42, 0x7483, 0xa5ae, 0xdf56, 0x8d2a, 0x6c42, 0x6401, 0x5ba0, 0x5381, 0x5361, 0x5360, 0x5bc1, 0x6c42, 0x7cc5, 0x8d27, 0x8d27, 0x7ca5, 0x6c06, 0x84ac, 0xb5f3, 0xd6d7, 0xe739, 0xe73a, 0xe73a, 0xe73a, 0xe75a, 0xdf39, 0xc675, 0x9d50, 0x7429, 0x7465, 0x8507, 0x8d27, 0x7ce5, 0x6c63, 0x5bc0, 0x5bc1, 0x7ca6, 0xa58e, 0xa551, 0x2124, 0x0000, 0x10a3, 0x8475, 0x7439, 0x747d, 0x7cbe, 0x6c7e, 0x643d, 0x6c3d, 0x84b9, 0x52ad, 0x0000, 0x0000, 0x0000, 0x2945, 0x9cf6, 0xd6df, 0xd6df, 0xd6df, 0xcedf, 0xcebf, 0xcebe, 0xcebe, 0xd6de, 0x9cf5, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x630d, 0xce7b, 0xdf1e, 0xdefe, 0xd6fe, 0xd6fe, 0xd6fe, 0xdeff, 0xd6ff, 0xd6df, 0xbe3e, 0xadfe, 0x9d7d, 0x953b, 0x953c, 0x955d, 0x9d7d, 0x9d9e, 0x9d9e, 0x9d9d, 0x9d9d, 0xa5de, 0xaddc, 0x6b90, 0x2945, 0x73ad, 0xce96, 0xc673, 0xc693, 0xc673, 0xbe53, 0xc693, 0xced5, 0xd716, 0xe777, 0xe798, 0xefb8, 0xe798, 0xdf57, 0xd716, 0xced5, 0xce94, 0xc693, 0xb610, 0x952a, 0x8508, 0xced4, 0xb611, 0x6c42, 0x6c62, 0x6c41, 0x63e1, 0x5bc1, 0x5ba0, 0x5be1, 0x6c22, 0x7ca4, 0x8506, 0x8506, 0x7465, 0x7449, 0xadd2, 0xdf19, 0xe71b, 0xdeda, 0xce58, 0xbdf7, 0xbdd7, 0xbdf7, 0xc638, 0xd6ba, 0xe73c, 0xe75b, 0xced7, 0x8ccd, 0x6c25, 0x84e6, 0x8d26, 0x7cc5, 0x6c42, 0x5bc0, 0x6402, 0x84e8, 0xb5f2, 0x8c4f, 0x1082, 0x2123, 0x5b0d, 0x84b8, 0x6c3b, 0x749e, 0x747e, 0x643d, 0x641c, 0x84fc, 0x73d3, 0x2125, 0x0000, 0x0000, 0x18c3, 0x94d5, 0xd6de, 0xd6df, 0xd6df, 0xcedf, 0xcebf, 0xcebe, 0xce9e, 0xd6de, 0xa557, 0x4a4a, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x73af, 0xc65b, 0xdf1e, 0xd6fe, 0xd6de, 0xd6fe, 0xd6fe, 0xdeff, 0xdeff, 0xcedf, 0xb5fe, 0xa5be, 0x9d9e, 0x953c, 0x953c, 0x955d, 0x9d7e, 0x9d9e, 0xa5be, 0xa5de, 0xa5de, 0xa5be, 0xa5be, 0xa5be, 0xb61c, 0x634e, 0x844f, 0xc654, 0xbe73, 0xc6b4, 0xceb4, 0xc694, 0xc673, 0xc673, 0xc694, 0xceb5, 0xced5, 0xced5, 0xced5, 0xceb5, 0xceb5, 0xce95, 0xceb5, 0xced5, 0xd6f6, 0xceb3, 0xadef, 0xc672, 0xa5b0, 0x8ceb, 0x7463, 0x74a3, 0x7482, 0x6c41, 0x6c41, 0x6c41, 0x74a3, 0x84e5, 0x8506, 0x7444, 0x848b, 0xc675, 0xe73a, 0xd6ba, 0xbdf7, 0xad55, 0xa535, 0xa556, 0xa536, 0xa556, 0xa556, 0xad55, 0xbdd7, 0xd6ba, 0xef5c, 0xdf39, 0x9d50, 0x6c25, 0x7ce5, 0x8506, 0x7ca4, 0x6402, 0x5ba0, 0x6c23, 0x952c, 0xc674, 0x842d, 0x7c2d, 0x8c8f, 0xbe5a, 0x7c99, 0x6c5d, 0x749e, 0x643d, 0x5bfc, 0x747d, 0x8cf9, 0x3a2a, 0x0000, 0x0000, 0x0000, 0x6b6e, 0xbe1b, 0xd6df, 0xd6df, 0xcedf, 0xcebf, 0xcebe, 0xce9e, 0xcebe, 0xb5fa, 0x9d36, 0x8432, 0x634e, 0x4a4a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4249, 0x9d15, 0xce9c, 0xdefe, 0xd6de, 0xd6de, 0xd6de, 0xd6fe, 0xd6ff, 0xd6ff, 0xdf1f, 0xbe7e, 0x9d7d, 0x9d9e, 0x955e, 0x955d, 0x955d, 0x9d7e, 0x9d9e, 0xa5be, 0xadff, 0xb61f, 0xb61f, 0xadfe, 0xa59e, 0xa59d, 0xadfd, 0x9d36, 0xc677, 0xc674, 0xbe32, 0xc673, 0xceb4, 0xceb4, 0xc6b4, 0xc693, 0xc673, 0xbe73, 0xbe53, 0xc674, 0xc674, 0xc694, 0xc694, 0xceb5, 0xced6, 0xd6d6, 0xd6d6, 0xceb5, 0xc694, 0xc654, 0xceb6, 0xadb2, 0x9d6e, 0x7ce6, 0x74c3, 0x7482, 0x6c61, 0x7482, 0x7cc4, 0x8505, 0x7464, 0x7c8a, 0xc696, 0xdf1a, 0xc658, 0xad96, 0xad76, 0xad78, 0xa559, 0x9d5a, 0x9d5b, 0x9d5b, 0xa57a, 0xadb9, 0xb5b8, 0xb5b7, 0xce59, 0xef5c, 0xe77a, 0x9d6f, 0x6c24, 0x84e5, 0x84e5, 0x7483, 0x5be1, 0x5ba1, 0x7446, 0xadcf, 0xbe32, 0xa58e, 0x8ced, 0xbe57, 0x9d7a, 0x641b, 0x6c7e, 0x643d, 0x5bfc, 0x643c, 0x9d7d, 0x52ee, 0x0041, 0x0000, 0x0000, 0x632d, 0xbe1a, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcebf, 0xce9e, 0xc69d, 0xcebd, 0xd6de, 0xcebd, 0xc67c, 0xb5b8, 0x8c73, 0x6b4e, 0x31a7, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a7, 0xad77, 0xdf1e, 0xdf1e, 0xd6de, 0xd6de, 0xd6de, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xd71f, 0xcedf, 0xa5bd, 0x955e, 0x957e, 0x9d9e, 0x9d9e, 0xa5be, 0xa5de, 0xadff, 0xb61f, 0xae1e, 0xadde, 0x9d9c, 0xa59c, 0xbe3d, 0xa59a, 0xadb8, 0xad74, 0xce96, 0xbe33, 0xce95, 0xce96, 0xc695, 0xc694, 0xc694, 0xc694, 0xc694, 0xc673, 0xc674, 0xc694, 0xceb5, 0xceb5, 0xc695, 0xceb5, 0xc676, 0xbe35, 0xce96, 0xceb6, 0xce97, 0x94b0, 0x632b, 0xb5f3, 0xa5cf, 0x7cc5, 0x6c61, 0x6c61, 0x74a3, 0x7ce5, 0x7ca4, 0x7447, 0xbe14, 0xdf1a, 0xce59, 0xb596, 0xb5b8, 0xa57a, 0x8d1b, 0x7c9b, 0x6c3b, 0x641b, 0x6c3b, 0x747c, 0x8d1c, 0xa59b, 0xbe1a, 0xbe18, 0xce79, 0xef7d, 0xe759, 0x8ccc, 0x7463, 0x84e5, 0x7cc4, 0x6422, 0x5ba0, 0x5380, 0x5bc3, 0x7446, 0x7cc6, 0x7ca5, 0xadb1, 0xcedc, 0x6c39, 0x6c5d, 0x6c5e, 0x5bfc, 0x63fc, 0x7c9c, 0x8cd7, 0x2966, 0x0000, 0x0000, 0x52cb, 0xb5d9, 0xcede, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcebe, 0xce9d, 0xc69d, 0xc67d, 0xce9d, 0xcede, 0xd6fe, 0xd6fe, 0xc65b, 0xb5b9, 0x94d4, 0x7c11, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0xad77, 0xd6fe, 0xdeff, 0xd6de, 0xd6de, 0xd6fe, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xd71f, 0xd71f, 0xbe5e, 0x955d, 0x9d7e, 0xa5df, 0xadff, 0xae1f, 0xb61f, 0xb61f, 0xadde, 0xa59c, 0xa59b, 0xb61c, 0x9d37, 0x8453, 0x632e, 0x5aec, 0x3a07, 0x9d12, 0xc676, 0x9d31, 0x844f, 0x844e, 0xc675, 0xc695, 0xceb4, 0xceb5, 0xced5, 0xced5, 0xced5, 0xceb5, 0xc675, 0xc676, 0xbe15, 0x7bed, 0x6b6c, 0xb5b4, 0xce98, 0x842f, 0x0841, 0x18e3, 0x94f0, 0xced4, 0xb650, 0x9d8c, 0x84c7, 0x7ca5, 0x7cc5, 0x6c43, 0x9d4f, 0xdf19, 0xd6ba, 0xbdf7, 0xbdfa, 0xa57b, 0x7c9c, 0x643c, 0x53ba, 0x4b59, 0x4b38, 0x4b59, 0x539a, 0x641c, 0x7c9c, 0xa59c, 0xce7c, 0xce59, 0xdefb, 0xf7dd, 0xceb6, 0x6c24, 0x7ca4, 0x7cc4, 0x6c62, 0x6401, 0x5bc1, 0x53a0, 0x5bc0, 0x6c42, 0x7ca4, 0x954c, 0xdf5c, 0x951b, 0x643c, 0x6c7e, 0x641d, 0x5bdb, 0x747c, 0x953a, 0x2988, 0x0000, 0x0000, 0x18c3, 0x9cf6, 0xcebe, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcebf, 0xcebe, 0xce9e, 0xc69d, 0xc67d, 0xc67d, 0xc67d, 0xce9d, 0xd6be, 0xd6fe, 0xd6bd, 0xce9c, 0xbe1a, 0xad77, 0x73af, 0x2945, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x8c93, 0xd6dd, 0xd6ff, 0xd6ff, 0xd6de, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xdf1f, 0xdf1f, 0xd6ff, 0xa5bc, 0x953c, 0xa5be, 0xadff, 0xae1e, 0xadde, 0x9d9d, 0xa5bc, 0xa599, 0x8452, 0x5b0d, 0x4a4a, 0x10a2, 0x0000, 0x0000, 0x0000, 0x39e7, 0x632b, 0x39c6, 0x1082, 0x1903, 0xb5b4, 0xe759, 0xe759, 0xd717, 0xced5, 0xceb5, 0xce95, 0xbe14, 0xb5b4, 0x8c90, 0x5aca, 0x0020, 0x0000, 0x4a89, 0x632b, 0x18e3, 0x0000, 0x6b8d, 0xceb7, 0xced6, 0xced5, 0xceb4, 0xc6b2, 0xb650, 0x9dad, 0x8d0c, 0xc675, 0xe71b, 0xce59, 0xc63a, 0xad9b, 0x747c, 0x5bfc, 0x4339, 0x32b7, 0x3296, 0x3296, 0x3296, 0x32b6, 0x4318, 0x5bdb, 0x745c, 0xaddc, 0xd6bc, 0xd6ba, 0xef7d, 0xef9b, 0x9d6f, 0x6c41, 0x7cc4, 0x74a3, 0x6c41, 0x6421, 0x6421, 0x6c42, 0x6c62, 0x6c62, 0x7ca6, 0xdf19, 0x9d59, 0x641b, 0x6c7e, 0x643d, 0x5bbb, 0x641b, 0x8cda, 0x52cc, 0x10a3, 0x0000, 0x0000, 0x94d5, 0xcebe, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xcebe, 0xce9d, 0xc67d, 0xc67d, 0xc67d, 0xc67d, 0xce9d, 0xcebe, 0xd6de, 0xd6fe, 0xcebd, 0xc65b, 0xa536, 0x8432, 0x39e8, 0x10a2, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x5b0c, 0xce9c, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xcebe, 0x953b, 0x951c, 0x955c, 0x955c, 0x953b, 0x9d5b, 0xb5db, 0x7c11, 0x2145, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4227, 0xa532, 0xa573, 0x73cd, 0x39e6, 0x4227, 0xce97, 0xced7, 0xdf39, 0xe759, 0xc674, 0xc673, 0xce75, 0x9cf1, 0x4a48, 0x2944, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73ad, 0xd6d7, 0xced6, 0xced5, 0xced5, 0xd6f6, 0xd6f6, 0xced5, 0xd6d7, 0xef9c, 0xef5c, 0xd6bb, 0xc65b, 0x84ba, 0x641c, 0x4339, 0x3ad7, 0x3af8, 0x3b19, 0x4319, 0x3b19, 0x3af8, 0x3ad7, 0x3b19, 0x5bdc, 0x747b, 0xc69e, 0xdefc, 0xe73c, 0xf7de, 0xc675, 0x6c43, 0x74a3, 0x74a3, 0x6c61, 0x7482, 0x74a3, 0x7ce4, 0x74a4, 0x6423, 0x7465, 0xc695, 0x6bb2, 0x6c5b, 0x6c5d, 0x643d, 0x5bbb, 0x539a, 0x7c7b, 0x9d5a, 0x9d37, 0x2968, 0x2146, 0x9cf6, 0xcebe, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xce9e, 0xce9d, 0xc67d, 0xc67d, 0xc67d, 0xc67d, 0xce9d, 0xcebe, 0xd6de, 0xd6fe, 0xd6dd, 0xc65b, 0xbe1a, 0x8c72, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3187, 0xadb8, 0xd6fe, 0xd6ff, 0xd71f, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xdf1f, 0xdf3f, 0xe73f, 0xe73f, 0xdf1f, 0xbe3e, 0xa59c, 0x9d7b, 0xa59b, 0x9518, 0xa578, 0x7bf0, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x73cc, 0xbe54, 0xc694, 0xced6, 0xceb5, 0xc695, 0xc694, 0xc694, 0xdf18, 0xe759, 0xc675, 0xbe34, 0xce96, 0x94b1, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b8c, 0xce96, 0xced5, 0xced5, 0xced6, 0xd6f6, 0xd6f6, 0xd6f6, 0xe73a, 0xf7bd, 0xf79e, 0xf79e, 0xdefe, 0xadfd, 0x8cfc, 0x6c3a, 0x5bb9, 0x539b, 0x4b7c, 0x4b7c, 0x4b7c, 0x437c, 0x433a, 0x3af9, 0x4b5b, 0x5bfc, 0xaddd, 0xe73d, 0xef5d, 0xffde, 0xdf17, 0x84c8, 0x7482, 0x74a3, 0x6c82, 0x74a3, 0x84e5, 0x8506, 0x7ca8, 0x84cb, 0xa590, 0xadb3, 0x73f2, 0x84db, 0x643d, 0x645e, 0x5bdc, 0x5379, 0x5378, 0x6c3a, 0x84fc, 0x9d7d, 0x9d5a, 0xa59a, 0xc67e, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xcedf, 0xcebf, 0xcebe, 0xcebe, 0xce9e, 0xce9d, 0xc67d, 0xc67c, 0xc67c, 0xc67d, 0xce9d, 0xcebe, 0xd6fe, 0xd6fe, 0xce7c, 0x8411, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x5aec, 0xcebd, 0xd6ff, 0xdf1f, 0xdf1f, 0xd71f, 0xd6ff, 0xd71f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdefe, 0xd6de, 0xc69d, 0xb5fa, 0x94f6, 0x634f, 0x39e8, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x9cf0, 0xceb5, 0xc693, 0xc693, 0xc693, 0xc693, 0xc673, 0xc673, 0xceb5, 0xdf18, 0xad93, 0x738c, 0x73ad, 0x4a89, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10c2, 0x7bed, 0xce95, 0xced5, 0xceb5, 0xced5, 0xd6d6, 0xd6f6, 0xd6f6, 0xe75b, 0xf7be, 0xf7be, 0xf7bf, 0xdf1f, 0xcedf, 0xc69f, 0xbe5f, 0xb61e, 0x955d, 0x7c9c, 0x641d, 0x53bd, 0x4b9d, 0x437c, 0x435b, 0x435b, 0x53bd, 0x8d1c, 0xe73e, 0xef7e, 0xf7de, 0xe759, 0x8cec, 0x7462, 0x7cc4, 0x74a3, 0x74a3, 0x7ce4, 0x84e8, 0xc653, 0xb5b3, 0x7c0d, 0x630b, 0x636f, 0x84b9, 0x643c, 0x645e, 0x63fc, 0x539a, 0x4b58, 0x4b57, 0x5b99, 0x6c3b, 0x7cbc, 0x8d1c, 0x955c, 0xa5bd, 0xb63e, 0xc67e, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xce9e, 0xce9d, 0xc67d, 0xc67d, 0xc67d, 0xce9d, 0xd6de, 0xd6ff, 0xb5f9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x94d5, 0xd6de, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf1f, 0xcebc, 0xb5f9, 0xa556, 0x8c72, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52aa, 0x4a69, 0x9cf1, 0xceb6, 0xc673, 0xbe72, 0xc692, 0xc6b2, 0xc692, 0xc672, 0xbe72, 0xbe73, 0xce95, 0xbe14, 0x94af, 0x6b8c, 0x2123, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0xad73, 0xd6d6, 0xceb5, 0xceb5, 0xced5, 0xced5, 0xced6, 0xd6f7, 0xef7b, 0xffdf, 0xffdf, 0xf7bf, 0xdf1f, 0xcebf, 0xcebf, 0xcebf, 0xcebf, 0xcebf, 0xc69f, 0xadff, 0x953d, 0x749c, 0x5bdc, 0x4b7c, 0x437c, 0x4b9d, 0x7c9c, 0xe73f, 0xef7e, 0xf79d, 0xe77a, 0x950d, 0x6c42, 0x84e5, 0x8506, 0x7cc5, 0x7ca4, 0x84c9, 0xb5d3, 0x7bee, 0x39c7, 0x0841, 0x2127, 0x6bf7, 0x643c, 0x645e, 0x641d, 0x5bdb, 0x539a, 0x4b58, 0x4b17, 0x4316, 0x5376, 0x6415, 0x7494, 0x84d4, 0x84f4, 0x9539, 0xa5dd, 0xb61e, 0xbe5e, 0xc69f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebe, 0xcebe, 0xce9e, 0xce9d, 0xc69d, 0xcebe, 0xd6ff, 0xbe1a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x73b0, 0xce9c, 0xd6fe, 0xdf1f, 0xdf3f, 0xe73f, 0xe73f, 0xdf3f, 0xdf1f, 0xdf1e, 0xce9c, 0x8c93, 0x528a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x94d1, 0x9d31, 0xce95, 0xc673, 0xbe72, 0xc6b2, 0xd734, 0xcf14, 0xced3, 0xc6b3, 0xc693, 0xbe72, 0xbe72, 0xc694, 0xceb5, 0xb5f4, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x94b1, 0xceb6, 0xceb5, 0xceb5, 0xced5, 0xced5, 0xced5, 0xd6f7, 0xef5b, 0xffdf, 0xffdf, 0xf7df, 0xdeff, 0xcebe, 0xcebf, 0xcebf, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcebf, 0xbe5f, 0xa5be, 0x84fd, 0x641c, 0x4b9c, 0x7c9b, 0xe75f, 0xef7e, 0xef7d, 0xe75a, 0x9d2e, 0x5be0, 0x7484, 0x8d47, 0x8d48, 0x8507, 0x84e8, 0xb612, 0xb5d4, 0x8c50, 0x7bef, 0x3a09, 0x7c78, 0x643c, 0x643e, 0x643e, 0x641d, 0x5bfc, 0x5bdb, 0x5399, 0x5377, 0x5391, 0x640b, 0x6c67, 0x6c66, 0x7489, 0x7490, 0x74b7, 0x84fd, 0x84fc, 0x953b, 0xc67f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcede, 0xcebf, 0xcedf, 0xd6de, 0xbe3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0x9d15, 0xcebd, 0xd6fe, 0xdf1e, 0xdf1f, 0xdefe, 0xdefe, 0xdf1e, 0xce9c, 0x9d16, 0x4229, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6c, 0xb5b3, 0xbe32, 0xbe52, 0xbe71, 0xc692, 0xdf54, 0xd735, 0xc695, 0xbe56, 0xc695, 0xcef4, 0xced3, 0xbe72, 0xc673, 0xced6, 0xb5f5, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c2, 0x842f, 0xa552, 0xce95, 0xce95, 0xceb5, 0xced5, 0xced5, 0xceb5, 0xd6f6, 0xe75b, 0xf7be, 0xffdf, 0xffdf, 0xdf1e, 0xce9e, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcebf, 0xcebf, 0xcedf, 0xcedf, 0xcedf, 0xc69f, 0xadfe, 0x84dc, 0x9d5b, 0xef7f, 0xef5d, 0xe71b, 0xe73a, 0xce95, 0x8d0c, 0x63e4, 0x7464, 0x8507, 0x9548, 0x9548, 0x9d8c, 0xb612, 0xb5d3, 0xad93, 0x7bcf, 0x84b9, 0x6c3c, 0x643e, 0x643e, 0x643e, 0x641d, 0x641d, 0x641c, 0x6417, 0x6c4d, 0x74a6, 0x7cc5, 0x7cc5, 0x7cc4, 0x7487, 0x642f, 0x6c39, 0x749d, 0x6c3b, 0xbe5e, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6de, 0xc63b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ab, 0xbdf9, 0xd6fe, 0xd6dd, 0xd6dd, 0xd6dd, 0xb5d9, 0x8c73, 0x7bf0, 0x4a4a, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a48, 0xb5d4, 0xc674, 0xbe51, 0xbe71, 0xcef3, 0xdf75, 0xc697, 0xadfa, 0xaddb, 0xb618, 0xcef6, 0xd755, 0xc6b2, 0xc673, 0xd6f7, 0x8c6f, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa553, 0xad73, 0xce96, 0xce96, 0xc695, 0xc694, 0xceb5, 0xceb5, 0xced5, 0xceb5, 0xd6d6, 0xe73a, 0xf7be, 0xffdf, 0xffdf, 0xef7f, 0xce9d, 0xcebe, 0xd6ff, 0xd6df, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6ff, 0xd6ff, 0xcedf, 0xc67e, 0xd6fe, 0xf7bf, 0xef7d, 0xdedb, 0xd6ba, 0xe75b, 0xe75a, 0xc674, 0x7c8a, 0x63e4, 0x7465, 0x8507, 0x8d48, 0x9549, 0x9d8c, 0x9d6e, 0xadb3, 0xa5da, 0x6c5b, 0x643d, 0x643e, 0x643e, 0x643e, 0x643e, 0x643c, 0x6c53, 0x74a9, 0x84e6, 0x8507, 0x8d27, 0x8506, 0x7cc5, 0x6c4a, 0x5bf4, 0x6c5c, 0x747d, 0xbe5f, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6de, 0xbe3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x7bf0, 0xbdd8, 0xa536, 0x632d, 0x5acc, 0x4229, 0x1904, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a68, 0xbe54, 0xbe51, 0xbe71, 0xd734, 0xd715, 0xb63a, 0xadfd, 0xadfe, 0xadfb, 0xc6b8, 0xdf76, 0xced3, 0xbe72, 0xd6d6, 0x7bcd, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc636, 0xce95, 0xced6, 0xceb5, 0xc694, 0xc695, 0xceb5, 0xceb5, 0xceb5, 0xceb5, 0xceb6, 0xdf39, 0xf79d, 0xffdf, 0xffff, 0xf7bf, 0xd6de, 0xce9e, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xdf1f, 0xd6ff, 0xcede, 0xd6de, 0xf7bf, 0xffff, 0xf7be, 0xe71c, 0xce79, 0xce59, 0xe71b, 0xf7bc, 0xe77a, 0xbe13, 0x84ab, 0x63e5, 0x7465, 0x8507, 0x9548, 0x954a, 0x954c, 0x8d30, 0x7474, 0x643a, 0x643c, 0x643d, 0x643e, 0x643d, 0x6459, 0x746e, 0x7ce6, 0x8d27, 0x956a, 0x9d8c, 0x8d28, 0x8506, 0x74a8, 0x6431, 0x643b, 0x749d, 0xbe7f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xce9d, 0x8c93, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x31a6, 0x2945, 0x0041, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e2, 0xbe54, 0xbe32, 0xbe71, 0xdf35, 0xcf16, 0xb63b, 0xadfe, 0xadfe, 0xb63c, 0xcef9, 0xdf76, 0xc6b2, 0xbe72, 0xced5, 0xb5b4, 0x4a69, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xce77, 0xceb5, 0xceb5, 0xceb4, 0xceb5, 0xceb5, 0xced5, 0xced5, 0xceb5, 0xceb5, 0xceb5, 0xd6f7, 0xef7b, 0xf7be, 0xffff, 0xffff, 0xef9f, 0xcebd, 0xce9e, 0xd6df, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd6ff, 0xd6de, 0xcebe, 0xef7f, 0xffff, 0xffff, 0xffff, 0xf7be, 0xe73c, 0xce59, 0xbdf7, 0xce59, 0xe73b, 0xf79c, 0xe77a, 0xbe54, 0x848b, 0x6c06, 0x7465, 0x8507, 0x9549, 0x8d4a, 0x84ed, 0x7cb0, 0x6c74, 0x6459, 0x643c, 0x645b, 0x6c74, 0x74aa, 0x84e5, 0x84e6, 0xa58d, 0xbe32, 0x84e9, 0x84e5, 0x7cc6, 0x6c6f, 0x6439, 0x749d, 0xbe7f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xc67c, 0x528b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4248, 0xc695, 0xbe32, 0xbe51, 0xd715, 0xdf77, 0xc6b9, 0xb65b, 0xb65c, 0xbe7a, 0xd718, 0xcf14, 0xc672, 0xbe52, 0xc673, 0xceb7, 0x94b1, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632b, 0xc675, 0xc694, 0xced5, 0xd6f6, 0xd6f6, 0xd6f6, 0xd6d6, 0xceb5, 0xceb5, 0xce95, 0xced6, 0xe739, 0xf79d, 0xffdf, 0xffff, 0xffff, 0xef7f, 0xcebd, 0xce9d, 0xcebe, 0xd6df, 0xd6ff, 0xd6df, 0xd6de, 0xcebe, 0xd6dd, 0xe75e, 0xffdf, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xef7d, 0xd6ba, 0xc618, 0xbdd7, 0xce59, 0xe73c, 0xef9c, 0xe75a, 0xbe14, 0x8ccd, 0x6c27, 0x7465, 0x8507, 0x8d48, 0x8d49, 0x850c, 0x74b1, 0x6c75, 0x6c75, 0x748d, 0x7cc7, 0x7cc4, 0x6c46, 0xad91, 0xbe35, 0x7c89, 0x74a4, 0x7cc5, 0x748c, 0x6436, 0x7cdc, 0xbe7f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xc67c, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9cf2, 0xc674, 0xb611, 0xb610, 0xc672, 0xdf57, 0xdf58, 0xcef8, 0xceb8, 0xced6, 0xcef4, 0xc6b2, 0xbe52, 0xbe52, 0xc694, 0xbe35, 0x632b, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632b, 0xceb7, 0xc674, 0xc694, 0xced6, 0xd6f7, 0xd717, 0xd6f6, 0xced6, 0xceb5, 0xc695, 0xceb5, 0xd6f7, 0xef5b, 0xf79d, 0xffdf, 0xffff, 0xffff, 0xef9f, 0xdf1e, 0xcebd, 0xce9d, 0xce9d, 0xce9d, 0xcebd, 0xdf1e, 0xef9f, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffdf, 0xe73c, 0xd69a, 0xbdf7, 0xbdd7, 0xce38, 0xdefb, 0xef7c, 0xe739, 0xbe34, 0x8ced, 0x6c06, 0x7465, 0x84e7, 0x8d49, 0x8d49, 0x850b, 0x84ed, 0x84e8, 0x84e5, 0x6c42, 0x94ed, 0xd6d8, 0xdf1a, 0xa590, 0x6c24, 0x7ca4, 0x74a9, 0x6c51, 0x84fb, 0xc69f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xc67c, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa532, 0xc695, 0xc694, 0xb611, 0xb611, 0xc693, 0xd736, 0xdf57, 0xd736, 0xcef4, 0xc6b2, 0xbe51, 0xbe32, 0xbe54, 0xb5d4, 0x94d1, 0x31c6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a89, 0xc656, 0xceb6, 0xb5d3, 0xc635, 0xceb6, 0xd6f6, 0xd6f6, 0xd6f6, 0xceb5, 0xce95, 0xc695, 0xceb6, 0xdf19, 0xef7c, 0xf7bd, 0xffdf, 0xffff, 0xffff, 0xffdf, 0xf7bf, 0xef7e, 0xe75e, 0xe75e, 0xef9f, 0xffdf, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7de, 0xffde, 0xffdf, 0xffff, 0xffff, 0xffff, 0xffff, 0xf7be, 0xe73c, 0xd69a, 0xbdf7, 0xb5b6, 0xc638, 0xdefa, 0xef5c, 0xe75a, 0xbe34, 0x950e, 0x7427, 0x6c43, 0x84e7, 0x8d49, 0x8d49, 0x8d28, 0x7484, 0x7447, 0xc675, 0xef9d, 0xf79d, 0xd6f7, 0x7447, 0x7483, 0x74a6, 0x6c4c, 0x8d1a, 0xc69f, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xc67c, 0x4a8b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b0b, 0x9cf1, 0xa572, 0xceb6, 0xb611, 0xb610, 0xbe31, 0xc692, 0xc692, 0xbe72, 0xb631, 0xb631, 0xc674, 0xb5f4, 0x4a69, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x7c0e, 0x9cf2, 0x632b, 0x73cd, 0xadb4, 0xce96, 0xced6, 0xd6f6, 0xd6d6, 0xceb5, 0xc695, 0xc695, 0xceb6, 0xdf39, 0xef7c, 0xf79d, 0xf7de, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffdf, 0xf7be, 0xef7c, 0xe73b, 0xe75b, 0xef7d, 0xf7be, 0xffde, 0xffff, 0xffff, 0xffff, 0xffdf, 0xf79e, 0xe73c, 0xd69a, 0xbdf7, 0xb5b7, 0xc618, 0xd6ba, 0xe75b, 0xe73a, 0xc675, 0x9d4e, 0x6c06, 0x6c24, 0x7485, 0x7464, 0x63e2, 0x9d2f, 0xe73a, 0xef7d, 0xef9d, 0xe77b, 0x952e, 0x6c43, 0x7ca4, 0x7469, 0x9578, 0xc6bf, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xd71f, 0xd6ff, 0xcede, 0xce9c, 0x528b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2103, 0x39c6, 0x94b0, 0xb5d3, 0xb612, 0xadf0, 0xb5f0, 0xb5f1, 0xb611, 0xb611, 0xbe53, 0xbe35, 0x6b6c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x2104, 0x0000, 0x0000, 0x6b8d, 0xbe35, 0xce95, 0xd6f6, 0xd6f6, 0xced5, 0xce95, 0xc695, 0xc695, 0xceb6, 0xdf18, 0xe75b, 0xef9c, 0xf79e, 0xf7be, 0xffdf, 0xffdf, 0xffff, 0xffff, 0xffdf, 0xffbe, 0xf7be, 0xf79d, 0xef7c, 0xe73a, 0xdf19, 0xdf39, 0xe73a, 0xe75b, 0xef7c, 0xf79e, 0xf7de, 0xffdf, 0xffff, 0xffdf, 0xf7be, 0xef7d, 0xe71c, 0xd69a, 0xbdf8, 0xb5b6, 0xbdf7, 0xd6ba, 0xe73b, 0xe75a, 0xc696, 0x952e, 0x6c06, 0x5bc2, 0x7c68, 0xc675, 0xe75b, 0xdedb, 0xdefb, 0xef9c, 0xbe33, 0x6c24, 0x74a3, 0x7486, 0xa5b5, 0xcedd, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf1f, 0xd6de, 0xcebe, 0xce9c, 0x52ab, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x31c6, 0x7c2e, 0xc674, 0xbe53, 0xceb6, 0xd6d7, 0xdf39, 0xd6f8, 0xceb6, 0xb5f4, 0x2965, 0x0000, 0xa535, 0xbe19, 0xad77, 0x4a4a, 0x2125, 0x2125, 0x2104, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x844f, 0xc655, 0xceb5, 0xd6f6, 0xd6f6, 0xced5, 0xce95, 0xc675, 0xc675, 0xceb6, 0xd6f7, 0xdf39, 0xe75b, 0xef9c, 0xf79d, 0xef9d, 0xef9d, 0xef9d, 0xf79d, 0xf79d, 0xef7b, 0xe75a, 0xdf39, 0xdef8, 0xd6f8, 0xd6f8, 0xdef8, 0xdf19, 0xe75a, 0xef5b, 0xef9c, 0xf79d, 0xf7be, 0xffff, 0xffdf, 0xf7be, 0xf79e, 0xef7d, 0xe73c, 0xd69a, 0xbdf7, 0xb5b6, 0xbdd7, 0xce99, 0xe73b, 0xe75a, 0xd6d7, 0xadd1, 0xadd1, 0xdf19, 0xd699, 0xc638, 0xd69a, 0xef7c, 0xdf38, 0x7447, 0x7483, 0x74a4, 0x9d90, 0xcefb, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd71f, 0xd6ff, 0xd6fe, 0xd6de, 0xcebe, 0xce9d, 0xcebe, 0xc63a, 0x4229, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e8, 0xd6dc, 0xdf1c, 0xd6f9, 0xd719, 0xef9c, 0xf7be, 0xf7de, 0xef9d, 0xc658, 0x52aa, 0x0020, 0x0000, 0xb5b8, 0xbe3c, 0xbe3c, 0xbe3c, 0xbe3c, 0xbe3b, 0xb5f9, 0x634e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4248, 0xb5d5, 0xc675, 0xceb5, 0xd6f6, 0xd6d6, 0xceb5, 0xce95, 0xc675, 0xc675, 0xc695, 0xceb6, 0xd6f8, 0xdf19, 0xe73a, 0xe75a, 0xe75a, 0xe75a, 0xe73a, 0xdf39, 0xdf19, 0xd6f8, 0xd6d7, 0xceb7, 0xd6b7, 0xceb7, 0xd6b7, 0xd6d7, 0xdef8, 0xdf39, 0xe73a, 0xef7c, 0xef7c, 0xf79d, 0xf7be, 0xffdf, 0xf7be, 0xf79e, 0xf79e, 0xef7d, 0xe73c, 0xd69a, 0xbdf7, 0xb5b6, 0xbdd7, 0xce79, 0xdefa, 0xdef9, 0xce98, 0xc637, 0xc618, 0xce59, 0xd69a, 0xe71c, 0xef9b, 0x9d4e, 0x6c41, 0x7ca4, 0x84e9, 0xced9, 0xdf3f, 0xdf1f, 0xdf1f, 0xd6ff, 0xd6ff, 0xd6de, 0xd6de, 0xcebe, 0xce9d, 0xce7c, 0xce7c, 0xce9c, 0xbe3b, 0xb5b9, 0xb5f9, 0xbe3a, 0x8c52, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e8, 0xd6dc, 0xe75f, 0xe75f, 0xe75e, 0xe75e, 0xe75f, 0xe77f, 0xe77f, 0xd6bc, 0x73af, 0x0000, 0x0000, 0x8432, 0xb61c, 0xc67f, 0xc67e, 0xc67e, 0xc69e, 0xc67d, 0x8c94, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634c, 0xc656, 0xc695, 0xced6, 0xd6f6, 0xced5, 0xceb5, 0xce95, 0xc695, 0xc675, 0xc675, 0xc695, 0xceb6, 0xceb6, 0xd6d7, 0xd6d7, 0xd6d7, 0xd6d7, 0xceb7, 0xceb7, 0xceb6, 0xceb6, 0xd6b7, 0xd6d7, 0xd6d7, 0xd6d7, 0xd6b7, 0xd6b7, 0xd6d7, 0xdef8, 0xdf39, 0xe75a, 0xe75b, 0xef7c, 0xf79d, 0xf7be, 0xf79e, 0xf79e, 0xf79e, 0xf79e, 0xef7d, 0xe73c, 0xd69a, 0xbdf7, 0xb596, 0xb596, 0xb596, 0xb5b6, 0xbdf7, 0xce79, 0xdedb, 0xdedb, 0xdefb, 0xef9c, 0xceb5, 0x6400, 0x74a3, 0x7ca5, 0xae14, 0xcebc, 0xce9d, 0xce9d, 0xce9d, 0xc65b, 0xbe3b, 0xc65b, 0xce9c, 0xb5b8, 0x7bf1, 0x7c11, 0x8431, 0x6b4d, 0x2986, 0x2125, 0x2145, 0x10c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x9d15, 0xe75f, 0xe75f, 0xe73e, 0xdf3e, 0xdf3e, 0xe73e, 0xe75f, 0xe73e, 0xa515, 0x0021, 0x0000, 0x5b0d, 0xbe3c, 0xbe7e, 0xb63d, 0xb61d, 0xbe3d, 0xc69e, 0xadb9, 0x424a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x52c9, 0xbe15, 0xceb6, 0xced5, 0xced5, 0xced5, 0xceb5, 0xceb5, 0xce95, 0xc695, 0xc675, 0xc675, 0xc675, 0xc675, 0xc696, 0xce96, 0xce96, 0xce96, 0xce96, 0xceb6, 0xd6d6, 0xd6f7, 0xdf18, 0xdf39, 0xdf38, 0xd6f8, 0xd6f8, 0xd6d8, 0xd6b7, 0xd6d8, 0xdf18, 0xdf39, 0xe75a, 0xef7b, 0xef7c, 0xef7d, 0xef5c, 0xef5d, 0xf79e, 0xf79e, 0xf79e, 0xef7d, 0xe73c, 0xd6ba, 0xce59, 0xc638, 0xc638, 0xd69a, 0xdefb, 0xe73c, 0xe71c, 0xdefb, 0xef7d, 0xdf39, 0x84c9, 0x7482, 0x7ca4, 0x952e, 0xadd5, 0xa577, 0xb5b8, 0xad97, 0x6b8e, 0x18e4, 0x2145, 0x2945, 0x1904, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x73d0, 0xdefd, 0xe73f, 0xe73f, 0xdf3e, 0xdf3e, 0xdf1e, 0xdf3e, 0xe75f, 0xce7b, 0x52ab, 0x0000, 0x39e8, 0xadb9, 0xbe5e, 0xb61d, 0xb5fd, 0xb5fc, 0xbe3d, 0xcebe, 0x8cb4, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x73ac, 0xd6d7, 0xceb5, 0xced5, 0xced5, 0xd6d6, 0xd6f6, 0xd6d6, 0xd6d6, 0xced6, 0xceb6, 0xceb6, 0xce96, 0xce96, 0xceb6, 0xceb6, 0xceb6, 0xd6d6, 0xd6f7, 0xd6f7, 0xdf38, 0xdf38, 0xdf38, 0xdef8, 0xceb7, 0xc636, 0xc636, 0xd6b8, 0xd6d8, 0xd6d8, 0xd6d8, 0xdef8, 0xdf39, 0xe75a, 0xe75b, 0xdf1a, 0xd6b9, 0xdefb, 0xef5d, 0xf79e, 0xf79e, 0xf79e, 0xef7d, 0xef5d, 0xe73c, 0xe71c, 0xe73c, 0xef7d, 0xef7e, 0xef5d, 0xdefb, 0xe73c, 0xef9b, 0xa5b0, 0x6c42, 0x7ca4, 0x8d0a, 0xa550, 0x2963, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a6a, 0xc65a, 0xe75f, 0xe73f, 0xe73f, 0xe73f, 0xdf3e, 0xdf3e, 0xe73e, 0xdf1e, 0xa515, 0x2124, 0x0000, 0xad98, 0xbe3d, 0xb63e, 0xb61e, 0xb61d, 0xb61d, 0xbe5e, 0xc65c, 0x5b0d, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8c6f, 0xceb6, 0xceb5, 0xced5, 0xd6f6, 0xd717, 0xd717, 0xdf17, 0xdf18, 0xdf18, 0xdf17, 0xd717, 0xd6f7, 0xd6f7, 0xd6f7, 0xd6f7, 0xd6f7, 0xd6f7, 0xd6f7, 0xdf18, 0xdf38, 0xdf18, 0xd6d7, 0xc656, 0xa553, 0x4a68, 0x52ca, 0x94b1, 0xad73, 0xce97, 0xd6f8, 0xd6d8, 0xd6d8, 0xdef8, 0xdf19, 0xe73a, 0xd6d8, 0xbe15, 0xc657, 0xdf1b, 0xef7d, 0xf7be, 0xf7be, 0xf7be, 0xf79e, 0xf79e, 0xf7be, 0xf7be, 0xf7be, 0xef7d, 0xe71c, 0xe71c, 0xf7bd, 0xc675, 0x6c45, 0x74a3, 0x7cc5, 0xc674, 0x6b6c, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0x9d15, 0xe73f, 0xe75f, 0xe75f, 0xe75f, 0xe73f, 0xe73f, 0xdf3e, 0xe75f, 0xce7b, 0x632d, 0x424a, 0xb5da, 0xb63d, 0xb61e, 0xb63e, 0xb63e, 0xb61d, 0xb61d, 0xc67d, 0xb5d9, 0x39c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a88, 0xc656, 0xc695, 0xceb5, 0xd6f6, 0xd717, 0xd717, 0xd717, 0xd6f7, 0xd6f7, 0xdf17, 0xdf18, 0xdf38, 0xdf38, 0xdf38, 0xdf38, 0xdf18, 0xdf17, 0xd717, 0xd717, 0xdf18, 0xdf18, 0xdef8, 0xc657, 0x73ad, 0x5289, 0x0000, 0x0000, 0x0000, 0x3a07, 0x844f, 0xad73, 0xce98, 0xd6d8, 0xd6d8, 0xd6d8, 0xdef8, 0xdf18, 0xc695, 0xa56f, 0xadb2, 0xceb8, 0xef7c, 0xf7be, 0xf7be, 0xf7be, 0xf7be, 0xf7be, 0xf7bf, 0xffdf, 0xf7be, 0xef5d, 0xe73c, 0xf79d, 0xdf39, 0x84c9, 0x6c82, 0x74a4, 0x9d8e, 0xbdf5, 0x1081, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bf0, 0xe73f, 0xe73f, 0xe73f, 0xe75f, 0xe73f, 0xe73f, 0xe73f, 0xe73e, 0xe75e, 0xb5b8, 0xb5da, 0xbe3d, 0xb5fd, 0xb5fd, 0xb61e, 0xb63e, 0xb61d, 0xb61d, 0xbe3d, 0xce9e, 0xad98, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x5aea, 0xd6d7, 0xc695, 0xc694, 0xceb5, 0xced6, 0xced6, 0xce96, 0xbe55, 0xceb7, 0xce96, 0xceb6, 0xceb6, 0xd6d6, 0xd6f7, 0xdf18, 0xdf18, 0xdf18, 0xdf18, 0xdf17, 0xdf17, 0xdf18, 0x94b0, 0x630b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x39e7, 0x7bef, 0xc638, 0xd6fa, 0xd6d8, 0xd6d8, 0xd6d8, 0xd6d6, 0xb610, 0x8cea, 0x8cec, 0xc676, 0xf79d, 0xf7be, 0xf7be, 0xf7be, 0xf7de, 0xffdf, 0xffdf, 0xffdf, 0xf7be, 0xf7be, 0xffde, 0xf7bc, 0xadd0, 0x6c40, 0x7483, 0x7ca7, 0xc694, 0x4a69, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x94d4, 0xe73f, 0xdf3f, 0xe73f, 0xe75f, 0xe75f, 0xe73f, 0xe73f, 0xdf3e, 0xe73f, 0xd6de, 0xc67e, 0xb61d, 0xadfd, 0xb61d, 0xb63e, 0xbe3e, 0xb63e, 0xb61d, 0xb61d, 0xbe5d, 0xc65c, 0x73b0, 0x0020, 0x0000, 0x0000, 0x0000, 0x39e7, 0x94d1, 0xceb7, 0xc675, 0xc654, 0xc674, 0xc676, 0x840e, 0x634c, 0x8c70, 0xa553, 0xd6f9, 0xd6d8, 0xd6b7, 0xceb7, 0xd6d7, 0xd6f8, 0xdf18, 0xdf38, 0xdf18, 0xdf17, 0xd6f8, 0x73cd, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a49, 0xad97, 0xdf1e, 0xd6fc, 0xd6fb, 0xd6d9, 0xd6d8, 0xd6f7, 0xceb4, 0x9d6c, 0x7465, 0x950d, 0xef7b, 0xf7be, 0xf7be, 0xffdf, 0xffdf, 0xffdf, 0xffdf, 0xffdf, 0xffff, 0xffff, 0xffdf, 0xf7bd, 0xce95, 0x7c86, 0x6c61, 0x7484, 0xadd0, 0x9cf1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x6b6e, 0xce7b, 0xe73f, 0xdf3f, 0xdf3f, 0xe73f, 0xe73f, 0xdf3f, 0xe73f, 0xdf3f, 0xdf1f, 0xce9e, 0xbe3e, 0xaddc, 0xadfd, 0xb61e, 0xb63e, 0xbe3f, 0xb63e, 0xb61d, 0xb61d, 0xb61d, 0xc67e, 0xbe3b, 0x6b6f, 0x18c3, 0x0000, 0x0000, 0x0020, 0x2124, 0x6b6c, 0xbdf5, 0xce96, 0xce96, 0xce77, 0x5289, 0x0881, 0x18e3, 0x2965, 0x4228, 0x4227, 0x4207, 0x4207, 0x52a9, 0xce77, 0xd6d7, 0xd6f7, 0xd717, 0xd6d7, 0xd6d7, 0xdef9, 0x2985, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0x9cf5, 0xdf1e, 0xd6fe, 0xd6dd, 0xd6fd, 0xd6fd, 0xdf1b, 0xd719, 0xd717, 0xbe73, 0x84e9, 0xc674, 0xf79d, 0xf7be, 0xffdf, 0xffdf, 0xffdf, 0xffdf, 0xffdf, 0xffff, 0xffdf, 0xffdf, 0xef7d, 0xef5c, 0xdf38, 0x8d2b, 0x6440, 0x6c62, 0x8d0c, 0x9d10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x632d, 0xce7b, 0xe73f, 0xdf1e, 0xdf3e, 0xdf3f, 0xe73f, 0xe73f, 0xe75f, 0xe73f, 0xdf1f, 0xcebe, 0xbe3e, 0xaddc, 0xaddc, 0xb5fd, 0xb61e, 0xb63f, 0xb63f, 0xb63f, 0xb63e, 0xb61d, 0xb5fc, 0xb61d, 0xc67e, 0xbe1b, 0x73b0, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x52a9, 0x94b0, 0xad53, 0x5aea, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x94b1, 0xd6d7, 0xceb6, 0xceb6, 0xceb6, 0xd6f8, 0xce98, 0x2944, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4229, 0x7bf1, 0xcebc, 0xd6fe, 0xd6de, 0xd6de, 0xd6fe, 0xdefe, 0xdf1c, 0xdf19, 0xdf38, 0xd717, 0xc674, 0xe75a, 0xf7be, 0xffdf, 0xffdf, 0xffdf, 0xffff, 0xffff, 0xffdf, 0xf7be, 0xef7d, 0xdefa, 0xceb7, 0xdf18, 0xbe73, 0x7ca8, 0x6400, 0x6c42, 0x84cb, 0x94cf, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0xc639, 0xe73f, 0xdf1e, 0xdf1e, 0xdf3f, 0xdf3f, 0xe73f, 0xe73f, 0xe73f, 0xdf3f, 0xcedf, 0xbe5e, 0xadfd, 0xaddc, 0xadfd, 0xb61e, 0xb63e, 0xb63f, 0xb63f, 0xb63f, 0xb63e, 0xb63e, 0xb61d, 0xb5fc, 0xb61d, 0xc67e, 0xb5fb, 0x73d1, 0x39e8, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x0840, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x632b, 0xd6b8, 0xc676, 0xbe35, 0xb5b4, 0xbdf5, 0x6b4c, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x528a, 0xad97, 0xdefe, 0xd6fe, 0xd6dd, 0xd6de, 0xd6de, 0xd6ff, 0xd71e, 0xdf1b, 0xdf39, 0xdf39, 0xdf18, 0xef7b, 0xf7de, 0xffde, 0xffdf, 0xffff, 0xffdf, 0xf7be, 0xef7d, 0xe73b, 0xce77, 0xbe14, 0xb612, 0xadd0, 0x8d0b, 0x6c25, 0x5ba1, 0x5be1, 0x6c23, 0x9d8f, 0x94d1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x9cf4, 0xdefd, 0xdf3e, 0xdf1e, 0xdf3e, 0xdf3f, 0xe73f, 0xe73f, 0xe73f, 0xe73f, 0xd6ff, 0xbe7e, 0xb5fd, 0xadbc, 0xaddd, 0xadfe, 0xb61e, 0xb63e, 0xb63f, 0xb63f, 0xb63f, 0xb63f, 0xb63e, 0xb63e, 0xb61d, 0xb5fc, 0xb61c, 0xc67e, 0xbe3c, 0xa557, 0x4209, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0x842f, 0x842f, 0x738d, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x7bf0, 0xb5d9, 0xdf1e, 0xd6de, 0xcebe, 0xd6be, 0xd6de, 0xd6ff, 0xd6ff, 0xd71c, 0xdf1a, 0xdf38, 0xdf18, 0xe73a, 0xf7bd, 0xffde, 0xef7d, 0xef7d, 0xe75c, 0xdf1a, 0xd6b8, 0xbe35, 0xadd1, 0xa58e, 0x954b, 0x7ca7, 0x6c44, 0x5bc2, 0x5360, 0x5380, 0x63e2, 0x950c, 0xbe13, 0x5aea, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x94b3, 0xdefd, 0xdf3e, 0xdf1e, 0xdf1e, 0xdf3f, 0xdf3f, 0xe73f, 0xe73f, 0xe73f, 0xdf1f, 0xc67e, 0xb61d, 0xa5bc, 0xadbc, 0xadfd, 0xb61e, 0xb61e, 0xb61e, 0xb63f, 0xb63f, 0xb63f, 0xb63f, 0xb63f, 0xb63e, 0xb63e, 0xb61d, 0xb5fc, 0xb5fc, 0xbe5d, 0xce9e, 0xadb9, 0x94b4, 0x5aec, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4229, 0x9cd4, 0xcebc, 0xdefe, 0xd6de, 0xcebd, 0xcebe, 0xd6de, 0xd6ff, 0xd6ff, 0xd71e, 0xd71b, 0xdf19, 0xdf18, 0xdf19, 0xef7c, 0xffde, 0xf7be, 0xe73c, 0xce77, 0xbe35, 0xadd1, 0xa58e, 0x952b, 0x84c8, 0x7465, 0x63e3, 0x5381, 0x4b40, 0x4b20, 0x63a5, 0x8ccc, 0xa58f, 0xa571, 0x7c0e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aec, 0xc65b, 0xdf3f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf1f, 0xc69f, 0xb63e, 0xaddd, 0xa5bc, 0xaddd, 0xadfe, 0xb61e, 0xb61f, 0xb61e, 0xb63f, 0xb63f, 0xb63f, 0xb63f, 0xb63f, 0xbe5f, 0xbe5e, 0xbe5e, 0xbe3e, 0xb61d, 0xb5fd, 0xbe3d, 0xc69e, 0xc69d, 0xbe3a, 0x8452, 0x2966, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e8, 0xa515, 0xbe1a, 0xd6dd, 0xd6fe, 0xcebe, 0xce9d, 0xcebd, 0xd6de, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71d, 0xd71a, 0xdf18, 0xdf18, 0xe739, 0xf7bd, 0xffff, 0xf7be, 0xe77b, 0xb612, 0x954c, 0x84e9, 0x7445, 0x63e4, 0x5b82, 0x5341, 0x4b21, 0x5342, 0x6c08, 0xadb0, 0xbe14, 0x9d11, 0x8c6f, 0x5ae9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a6b, 0x52cd, 0x52cd, 0x52cd, 0x52ee, 0xad99, 0xd6df, 0xd6df, 0xd6df, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xc67f, 0xb61f, 0xadde, 0xa59d, 0xa5bd, 0xadfe, 0xae1e, 0xb61f, 0xb61f, 0xb61f, 0xb61f, 0xb63f, 0xb63e, 0xbe3f, 0xbe5f, 0xbe7f, 0xc67f, 0xc69f, 0xc69f, 0xc67e, 0xbe3e, 0xb61d, 0xb61d, 0xbe5d, 0xce9e, 0xce9d, 0xc65b, 0x8c93, 0x632d, 0x2986, 0x1904, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x2104, 0x2125, 0x632d, 0x7bd0, 0xce9c, 0xd6fe, 0xd6de, 0xcebe, 0xce9d, 0xce9d, 0xcebe, 0xd6de, 0xd6df, 0xd6ff, 0xd6ff, 0xd6fe, 0xd71c, 0xd6f9, 0xd718, 0xdef8, 0xe739, 0xef9b, 0xe75b, 0xe75a, 0xe739, 0xbe53, 0x6c06, 0x5382, 0x5341, 0x4b42, 0x5364, 0x6be8, 0x8cee, 0xadb2, 0xbe15, 0x840e, 0x5aea, 0x4227, 0x2944, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x8c95, 0x9d3a, 0x9d3b, 0x9d3b, 0x951b, 0x9d3c, 0x9d3c, 0x9d3c, 0x9d3c, 0x9d3c, 0x9d3c, 0x9d3c, 0x9d5c, 0x9d3c, 0x9d3d, 0x951c, 0x8cfd, 0x8cfc, 0x951c, 0xa5be, 0xadfe, 0xb61f, 0xb61f, 0xb61f, 0xb61e, 0xb61e, 0xb63e, 0xbe3f, 0xbe5f, 0xc67f, 0xc69f, 0xcebf, 0xcebf, 0xcebf, 0xcebf, 0xc69f, 0xc67e, 0xbe3e, 0xb61d, 0xb63d, 0xbe5d, 0xce9e, 0xcebe, 0xce9d, 0xadb9, 0xad98, 0x8c73, 0x4209, 0x4229, 0x4229, 0x4249, 0x4249, 0x4249, 0x4229, 0x4209, 0x8432, 0xb5d9, 0xb5b8, 0xd6bd, 0xd6de, 0xd6de, 0xcebe, 0xce9d, 0xce9d, 0xcebe, 0xcebe, 0xd6df, 0xd6df, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fc, 0xd6f9, 0xd718, 0xd6f8, 0xd6f8, 0xd6f8, 0xd6d8, 0xd6f8, 0xd6f8, 0xceb6, 0x84ab, 0x5345, 0x63a8, 0x848e, 0xa594, 0xbe58, 0xced9, 0x634b, 0x39e6, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aec, 0x8cb8, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0xa5be, 0xb61f, 0xb61f, 0xb61e, 0xb61f, 0xb61e, 0xb63e, 0xbe5f, 0xc67f, 0xc69f, 0xc69f, 0xc69f, 0xc67e, 0xc65d, 0xbe3c, 0xc65d, 0xc69e, 0xc69f, 0xc69f, 0xc67e, 0xbe3d, 0xb61d, 0xbe1c, 0xbe5d, 0xc67e, 0xce9e, 0xcebe, 0xcebe, 0xce9d, 0xcebd, 0xd6dd, 0xd6dd, 0xd6fd, 0xd6dd, 0xd6dd, 0xcebd, 0xd6de, 0xd6fe, 0xd6de, 0xcebe, 0xce9e, 0xce9d, 0xce9d, 0xcebe, 0xd6de, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fd, 0xd6fa, 0xd6f8, 0xd6f7, 0xd6f7, 0xd6d8, 0xd6d8, 0xd6d8, 0xd6d8, 0xceb8, 0xbe55, 0x9d52, 0xbe57, 0xc6bb, 0xce9d, 0xcede, 0xc67b, 0x4a8b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c32, 0x9d3b, 0x84dc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951d, 0xa57d, 0xa57d, 0xa57d, 0xa57d, 0xa57d, 0xa57d, 0xa57d, 0x9d7d, 0x951d, 0x8cfd, 0x9d5d, 0xadff, 0xb63f, 0xb61e, 0xb61e, 0xb63f, 0xbe3f, 0xbe7f, 0xc69f, 0xc69f, 0xc69f, 0xbe5e, 0xb61d, 0xb5fc, 0x9d37, 0x8453, 0x9d17, 0xb5fb, 0xbe3d, 0xc67e, 0xc69f, 0xc69f, 0xbe7e, 0xbe3d, 0xb61c, 0xb61c, 0xbe1c, 0xbe3d, 0xc65d, 0xc67d, 0xc67d, 0xc69e, 0xce9e, 0xcebe, 0xce9e, 0xce9e, 0xce9d, 0xc69d, 0xc67d, 0xc67d, 0xc69d, 0xcebe, 0xcede, 0xd6ff, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd71f, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fe, 0xd6fc, 0xd6f9, 0xd6f8, 0xd6f8, 0xd6d9, 0xd6d9, 0xd6da, 0xdf1b, 0xc638, 0xa554, 0xce9b, 0xcede, 0xcebe, 0xce9e, 0xcebe, 0xd6de, 0xa536, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6bb2, 0x94fb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xb61e, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd71f, 0xbe5e, 0xa5bd, 0xb61e, 0xbe5f, 0xbe5f, 0xb63e, 0xbe5e, 0xbe5f, 0xc67f, 0xc69f, 0xc69f, 0xbe5e, 0xb61d, 0xb61c, 0xc67d, 0xc63b, 0x52cb, 0x18e3, 0x2105, 0x8432, 0xa558, 0xadba, 0xbe5d, 0xc69e, 0xc69f, 0xc67e, 0xbe5e, 0xbe3d, 0xb61c, 0xb61c, 0xb61c, 0xb61c, 0xbe1c, 0xbe1c, 0xbe3c, 0xbe3c, 0xbe3c, 0xbe3c, 0xbe5c, 0xc67d, 0xc69e, 0xcebe, 0xcedf, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fe, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf1f, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fe, 0xd6fc, 0xd6fb, 0xd6fb, 0xd6fb, 0xd6fc, 0xd6fd, 0xdf1e, 0xd6fd, 0x6b6e, 0xa557, 0xd6de, 0xcebe, 0xce9e, 0xce9e, 0xd6de, 0xce9d, 0x5acc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6351, 0x8cdb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dc, 0xc67e, 0xdf3f, 0xe73f, 0xdf3f, 0xdf3f, 0xe73f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf1f, 0xbe3d, 0xaddc, 0xb63e, 0xbe7f, 0xbe7f, 0xc69f, 0xc69f, 0xc67f, 0xbe5e, 0xb5fc, 0xb61c, 0xc67d, 0xd6de, 0xdf1e, 0xdefd, 0xb5d8, 0x8411, 0x2104, 0x0000, 0x52ab, 0x6b90, 0x9d16, 0xc65d, 0xc69e, 0xc69f, 0xc67f, 0xbe5e, 0xbe5e, 0xbe5d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe5d, 0xbe5d, 0xc65d, 0xc67d, 0xc69e, 0xcebf, 0xd6df, 0xd6ff, 0xd6df, 0xcebe, 0xcebe, 0xcebd, 0xc67c, 0xad98, 0xad77, 0xc65c, 0xd6de, 0xdeff, 0xdf1f, 0xdf1f, 0xdf1f, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6fe, 0xd6fe, 0xd6fe, 0xd71e, 0xd6fe, 0xd6fe, 0xdf1f, 0xdefe, 0xa556, 0x6b4e, 0xc67c, 0xcedf, 0xcebe, 0xce9e, 0xcebe, 0xd6be, 0xa536, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52cf, 0x849b, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xcebf, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xe73f, 0xdf3f, 0xdf3f, 0xd6ff, 0xb61d, 0xadbc, 0xb63e, 0xbe7f, 0xbe7f, 0xbe3e, 0xb5fd, 0xb5fc, 0xc67d, 0xd6ff, 0xdf3f, 0xe73f, 0xe73e, 0xe73e, 0xdf3e, 0xce9c, 0xa515, 0x6b4e, 0x2966, 0x0000, 0x3a09, 0x7c12, 0xa57a, 0xc69f, 0xc69f, 0xc67f, 0xc67f, 0xc67f, 0xc67f, 0xc67e, 0xc67e, 0xc67e, 0xc67e, 0xc67e, 0xc69e, 0xcebe, 0xcedf, 0xd6df, 0xd6df, 0xcebe, 0xce9d, 0xbe3b, 0xbe1a, 0x8c93, 0x6b8f, 0x4a49, 0x4229, 0x8431, 0xcebd, 0xd6be, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xd71f, 0xd6ff, 0xd6ff, 0xd6ff, 0xd6ff, 0xd71f, 0xdf1f, 0xdf1f, 0xdeff, 0xdefe, 0xce9c, 0x73d0, 0xa537, 0xd6df, 0xcebf, 0xce9e, 0xce9e, 0xd6de, 0xc67c, 0x6b6f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632f, 0x6bb3, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6bb4, 0x6bb4, 0x73f5, 0x8456, 0x94d7, 0x8c94, 0x0001, 0x0862, 0x0000, 0x0000, 0x0000, 0x2105, 0x634f, 0x73f4, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x6bb4, 0x73b3, 0x422a, 0x0000, 0x18e3, 0x8c96, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xd6df, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xe73f, 0xdf3f, 0xdf3f, 0xd6ff, 0xb61d, 0xa59c, 0xa5bc, 0xadbc, 0xadbc, 0xa57c, 0xa59d, 0xb5fd, 0xbe3d, 0xbe1d, 0xbe1d, 0xbe1d, 0xbe1d, 0xbe3d, 0xbe3d, 0xbe3d, 0xbe1c, 0xb5d9, 0x9cf5, 0x5aec, 0x3a09, 0x9517, 0xbe7e, 0xb5fe, 0xa5bd, 0xa59e, 0xa59e, 0xa5be, 0xa5bd, 0xadbd, 0xbe3f, 0xc69f, 0xc69f, 0xc69f, 0xcebf, 0xcedf, 0xcedf, 0xd6de, 0xbe1d, 0xb5fd, 0x8cd8, 0x8c97, 0x8453, 0x4a4a, 0x73d2, 0x7415, 0x8cb7, 0xb5fc, 0xaddd, 0xaddd, 0xb5fd, 0xb61e, 0xbe3e, 0xbe3e, 0xc67f, 0xcebf, 0xd6ff, 0xd71f, 0xdf1f, 0xdf3f, 0xdf1f, 0xd6fe, 0xd6fe, 0xc65b, 0x4a8a, 0x73d0, 0xc65c, 0xcedf, 0xcebe, 0xce9e, 0xcebe, 0xd6de, 0xa557, 0x2104, 0x0000, 0x6371, 0x6bb4, 0x6b94, 0x73f4, 0x7bf2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x424c, 0x6373, 0x6b94, 0x6bb4, 0x7c13, 0x31a7, 0x0000, 0x7bf1, 0x8455, 0x6b94, 0x6b94, 0x6b94, 0x6b94, 0x73d4, 0x73b1, 0x39e8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c35, 0x8cdb, 0x84bc, 0x84bc, 0x84bc, 0x849c, 0x84bc, 0x849c, 0x84bc, 0x84bc, 0x8cdb, 0x8cdb, 0x8cda, 0x9d3a, 0x8475, 0x3a0b, 0x18c4, 0x0000, 0x2987, 0x8455, 0x951c, 0x849c, 0x84bc, 0x84bc, 0x849c, 0x84bc, 0x84bc, 0x849c, 0x84bc, 0x849c, 0x84bc, 0x84bc, 0x84bc, 0x8cda, 0x5aee, 0x0000, 0x39e8, 0x9d39, 0x8cfd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5d, 0xd6df, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xe73f, 0xe73f, 0xdf3f, 0xdf3f, 0xdf3f, 0xd6ff, 0xbe3d, 0xb5fd, 0xbe5d, 0xd6df, 0xaddd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cfc, 0x8cfc, 0x951c, 0x951b, 0xad9c, 0xc65c, 0xbe3b, 0xbe1b, 0xbe5e, 0xa59e, 0x8cdd, 0x84dd, 0x8cdd, 0x8cdd, 0x84dd, 0x8cdc, 0xa5be, 0xc67f, 0xc69f, 0xce9f, 0xcebf, 0xcebf, 0xcede, 0xd6de, 0xa59c, 0x8cdd, 0x84bc, 0x951c, 0xbdfa, 0x8c94, 0xa57b, 0x84bc, 0x84bc, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cdd, 0x8cfc, 0x8cfc, 0x951c, 0xa59c, 0xc67e, 0xd71f, 0xdf1f, 0xdefe, 0xd6bd, 0xc67b, 0x5acc, 0x0841, 0x4249, 0xad98, 0xcebe, 0xcebe, 0xcebe, 0xce9e, 0xcede, 0xbe1a, 0x52ab, 0x0000, 0x8478, 0x84bc, 0x84bc, 0x8cbb, 0x9d3a, 0x8433, 0x10c2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b11, 0x7c7b, 0x849c, 0x84bc, 0x9d3a, 0x424a, 0x0000, 0xa536, 0xa59c, 0x849c, 0x84bc, 0x84bc, 0x849c, 0x8cfc, 0x94d8, 0x528b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x8cdc, 0x8cdc, 0x84bc, 0x84bd, 0x84bd, 0x84bc, 0x8cdc, 0x94fa, 0x52ee, 0x1083, 0x3187, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x8cdc, 0x8cdc, 0x8cdc, 0x8cdc, 0x8cdc, 0x8cfc, 0x951a, 0x5b0e, 0x0000, 0x5acc, 0x9d1a, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa59e, 0xd6ff, 0xdf1f, 0xdf1f, 0xdf1f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xe73f, 0xdf3f, 0xdf1f, 0xdf1f, 0xe75f, 0xe75f, 0xb5fd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x8cdc, 0x8cdc, 0x84bc, 0x84bd, 0x84bd, 0x84bc, 0x8cfc, 0xaddd, 0xc67e, 0xbe5e, 0xadde, 0x8cfd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x953d, 0xbe5f, 0xc69f, 0xcebf, 0xcebf, 0xce9e, 0xd6de, 0xc69e, 0x951c, 0x84bd, 0x84bc, 0xa59c, 0xd6bd, 0xce7c, 0xaddd, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xaddd, 0xcebe, 0xd6bd, 0x9cf5, 0x4a6a, 0x0841, 0x0000, 0x0000, 0x94d4, 0xcebd, 0xcebf, 0xcebe, 0xce9e, 0xcebe, 0xd6fe, 0xa536, 0x10a2, 0x8479, 0x84bd, 0x84bd, 0x84bd, 0x94fc, 0xa559, 0x634e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b11, 0x7c9b, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0x9d3a, 0x9d18, 0x8477, 0x8cdb, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84dc, 0x8cda, 0x52cd, 0x3188, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xaddd, 0x9d19, 0x9d39, 0x9d19, 0x9d39, 0x9d39, 0x9d38, 0x9d17, 0x5aec, 0x0000, 0x18e4, 0x8cb8, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa59e, 0xc67e, 0xc69e, 0xc69e, 0xc69e, 0xc69e, 0xcebe, 0xcebf, 0xd6df, 0xdf1f, 0xdf3f, 0xe73f, 0xe75f, 0xe75f, 0xe77f, 0xe77f, 0xe77f, 0xe73f, 0xaddd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x953d, 0xbe3e, 0xbe3d, 0xaddd, 0x953c, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x9d7d, 0xb61f, 0xb63f, 0x953d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0xb5fe, 0xc69f, 0xcebf, 0xcebf, 0xc69e, 0xd6de, 0xb5fd, 0x84bd, 0x84bd, 0x8cdc, 0xbe3d, 0xe77f, 0xdf3f, 0xaddd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0x9d3a, 0x8cd9, 0x94fc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xb5fd, 0xb5d9, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x2986, 0xbdfa, 0xd6df, 0xcebf, 0xcebe, 0xce9e, 0xcede, 0xc67c, 0x6b8f, 0x8479, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x94fc, 0x7415, 0x3188, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b11, 0x849c, 0x84bd, 0x84dd, 0x9d3b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b10, 0x0000, 0x0020, 0x7bf4, 0x94fa, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x94d7, 0x4a6b, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x94fb, 0xb5f9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0883, 0x7c57, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dc, 0x84bc, 0x84bb, 0x849b, 0x84bb, 0x84bc, 0x8cdc, 0x951d, 0xa57d, 0xb5fe, 0xc65e, 0xd6ff, 0xe75f, 0xe77f, 0xe75f, 0xe75f, 0xe73e, 0xc63b, 0x9d5b, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa57d, 0xe75f, 0xef7f, 0xe75f, 0xcebe, 0x9d3d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0xa5be, 0xbe5f, 0xa59e, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa59d, 0xc67f, 0xcebf, 0xc69f, 0xce9e, 0xce9e, 0x9d3d, 0x84bd, 0x84bd, 0x951c, 0xd6ff, 0xe73e, 0xdf1e, 0xaddd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x94fb, 0x7bf1, 0x634f, 0x9519, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa59c, 0xa557, 0x4229, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa536, 0xcebe, 0xcedf, 0xcebe, 0xce9e, 0xcebe, 0xcebe, 0xad77, 0x94fa, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x94fb, 0x8456, 0x3188, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b11, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x2126, 0x7c56, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa57c, 0x632f, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xb5da, 0x2988, 0x31a9, 0x31a9, 0x31a9, 0x4209, 0x2125, 0x0000, 0x0000, 0x0000, 0x8411, 0x94fa, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x8cfc, 0x951c, 0x951c, 0x951c, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xa57d, 0xc67e, 0xdf3f, 0xdf1e, 0xce7b, 0xa556, 0x5aed, 0x7417, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa57c, 0xdf3f, 0xe77f, 0xef7f, 0xe77f, 0xb5fd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d7d, 0xbe5f, 0xb61f, 0x8cfd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x953d, 0xbe5f, 0xc69f, 0xc69e, 0xce9e, 0xbe1e, 0x8cdc, 0x84bd, 0x84bc, 0xaddd, 0xdf1e, 0xc65a, 0xce9c, 0xaddd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84b9, 0x632e, 0x0000, 0x6371, 0x8cdb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa59c, 0xa537, 0x3a08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73af, 0xce9c, 0xcedf, 0xcebf, 0xcebe, 0xce9e, 0xd6de, 0xd6fe, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d3c, 0x94b6, 0x4209, 0x0000, 0x0000, 0x0000, 0x5b11, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424a, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x2146, 0x8455, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa59c, 0x632f, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x953b, 0x7417, 0x7437, 0x7417, 0x7c38, 0x9d18, 0x632e, 0x0021, 0x0000, 0x0000, 0xa557, 0xa57b, 0x84bb, 0x84bb, 0x8cdb, 0x9d3c, 0xaddd, 0xbe5e, 0xc67e, 0xc69e, 0xce9e, 0xc69e, 0xc65e, 0xb5fe, 0x951c, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x951c, 0xb5fd, 0xa537, 0x73af, 0x18e3, 0x18e6, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa57c, 0xbe1b, 0xe75f, 0xe75f, 0xe77f, 0xbe1e, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5d, 0xb63f, 0xbe5f, 0x9d5d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dc, 0xb61f, 0xc69f, 0xc67e, 0xc69e, 0xa59d, 0x84bc, 0x84bd, 0x8cdc, 0xce9e, 0xad97, 0x7bf0, 0xa557, 0xad9c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951b, 0x7c12, 0x0000, 0x73d3, 0x8cbb, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xad9c, 0x8433, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a08, 0xbe1a, 0xcebe, 0xcedf, 0xcebe, 0xce9e, 0xcebe, 0xd6ff, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa57c, 0x94d5, 0x2945, 0x0000, 0x0000, 0x5b11, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424a, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x2967, 0x7c56, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xad9b, 0x632e, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x84dc, 0xb5dc, 0x73b0, 0x0841, 0x0000, 0x0000, 0x52cc, 0x94d5, 0xb5fa, 0xbe1b, 0x8cb5, 0xce9d, 0xd6fe, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf3f, 0xdf1f, 0xc69e, 0x9d3d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0x8456, 0x31a8, 0x0000, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa55c, 0x632e, 0x94b3, 0xce9b, 0xdf1e, 0xaddd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d7d, 0xbe3f, 0xbe5f, 0xa5be, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d7d, 0xc67f, 0xc67e, 0xc65e, 0x951d, 0x84bd, 0x84bd, 0xa57c, 0xb5fa, 0x4a8a, 0x39c7, 0x8c74, 0xa57b, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cba, 0x73b1, 0x3a2b, 0x8cb9, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xb5db, 0x7bf1, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bf1, 0xce9d, 0xd6df, 0xcebf, 0xcebe, 0xcebe, 0xcedf, 0xa57d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x951a, 0x4a6c, 0x0000, 0x0000, 0x5b11, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424a, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x6351, 0x2126, 0x2967, 0x8cb6, 0x9d3c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x8c76, 0x3a09, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x9d7d, 0xa59d, 0xa59d, 0xa59d, 0xa59d, 0xa57a, 0x52cc, 0x0020, 0x0000, 0x0000, 0x0021, 0x31c7, 0x4a8a, 0x4a8a, 0x39c8, 0x8c73, 0xd6bc, 0xdf1e, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe73f, 0xbe3e, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa57c, 0x634f, 0x0020, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5c, 0x422b, 0x31c8, 0x634f, 0x9d39, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951d, 0xadfe, 0xbe3e, 0xbe5f, 0xb63f, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xb63f, 0xc67e, 0xb63e, 0x84bc, 0x84bd, 0x84bc, 0xb61d, 0x8c93, 0x73af, 0xa536, 0xce9c, 0xadbd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0x9d5c, 0x8cfb, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0xaddd, 0xb5d9, 0x5acc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2966, 0xcebd, 0xd6df, 0xcedf, 0xcedf, 0xcedf, 0xcedf, 0x9d7d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x8cb9, 0x5b0e, 0x0000, 0x5b11, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424a, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0xa59d, 0xadbc, 0x951b, 0x8cfb, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x951a, 0x424b, 0x3187, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x94fc, 0xb61a, 0x424c, 0x4a6c, 0x4a6c, 0x4a6c, 0x3a0a, 0x10a3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x8c93, 0xd6bd, 0xdf1e, 0xe75f, 0xe75f, 0xe75f, 0xe75f, 0xe73f, 0xdf1e, 0xce9e, 0x9d5c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0xa558, 0x4249, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951d, 0xadbd, 0xad9c, 0x951b, 0x8cbb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x8458, 0x9d18, 0xbe5e, 0xbe5f, 0xbe7f, 0x9d7d, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dc, 0xa5bd, 0xc67f, 0x9d7d, 0x84bd, 0x84bd, 0x8cfc, 0xcebe, 0xce9b, 0xd69b, 0xd6bb, 0xd6bd, 0xadbc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x953d, 0xc65d, 0xadb8, 0x52cc, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10c3, 0xb5f9, 0xd6de, 0xd6df, 0xd6df, 0xd6df, 0xcedf, 0x9d7d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0x94f9, 0x5aed, 0x5b32, 0x849b, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x84bc, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x951b, 0x8498, 0x8c73, 0x2966, 0x3187, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x8c73, 0xce9c, 0xdf1e, 0xdf3f, 0xe73f, 0xdf1e, 0xd6fd, 0xbdf9, 0xad77, 0x9d3a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x9d3b, 0x422b, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x84bc, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x8cdb, 0x8c98, 0x424c, 0x8474, 0xb61d, 0xbe5e, 0xc69f, 0xbe3f, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d3d, 0xbe5e, 0x84dc, 0x84bd, 0x84bd, 0xa59c, 0xbe1a, 0xa556, 0x8c52, 0x3186, 0x6b70, 0x951a, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0x8cda, 0x8cfa, 0x951c, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x94fc, 0xaddc, 0x9d37, 0x4a6a, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x8432, 0xd6de, 0xd6ff, 0xd6ff, 0xd6ff, 0xcedf, 0x9d7d, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0x8d1d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0xa579, 0x8476, 0x849c, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x849b, 0x849a, 0x84ba, 0x8cdb, 0x94fb, 0x951a, 0x8cb8, 0x94d6, 0x52cc, 0x0000, 0x0000, 0x2987, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0882, 0x94b4, 0xce9c, 0xdefd, 0xd6bc, 0xbe3a, 0x9cf4, 0x3186, 0x1080, 0x7c36, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8499, 0x31ca, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x849b, 0x849a, 0x84ba, 0x8cdb, 0x94fb, 0x8499, 0x7c57, 0x6bb3, 0x31c9, 0x0000, 0x4a8c, 0xa579, 0xb61d, 0xbe5e, 0xbe7f, 0x953d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x9d5e, 0x84bd, 0x84bd, 0x8cbc, 0xb61c, 0x634e, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa57c, 0x94d5, 0x8c93, 0x9d18, 0x94fb, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xb5dc, 0x9d16, 0x3a08, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52ab, 0xc65b, 0xdf1f, 0xd71f, 0xd6de, 0xce9e, 0x9d5d, 0x84bd, 0x84bd, 0x84bc, 0x9d3b, 0xa59b, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d3c, 0xa57c, 0x8cdd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x73d5, 0x5b30, 0x6351, 0x6b91, 0x7c13, 0x7c12, 0x4208, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x94b4, 0xad97, 0x8c93, 0x4a8a, 0x0000, 0x0000, 0x0000, 0x8477, 0x8cbc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x7c59, 0x29a9, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x953c, 0x6372, 0x5b30, 0x6351, 0x6bb2, 0x7c13, 0x5b0e, 0x0840, 0x0000, 0x0000, 0x0000, 0x31a8, 0x9d38, 0xbe3d, 0xb61d, 0xb61d, 0x9d7d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5d, 0x9d17, 0x4209, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d3b, 0x8452, 0x0000, 0x0000, 0x8474, 0x951b, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xbe1c, 0x6b8f, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0xa536, 0xd6fe, 0xd6de, 0xcebd, 0xa578, 0x94fb, 0x84bd, 0x84bd, 0x84bc, 0x7c35, 0x7c12, 0xa55b, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b10, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x2987, 0x39ea, 0x31a9, 0x2988, 0x2126, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x39c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8477, 0x8cbc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x7c59, 0x29a9, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5c, 0x31c9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x632e, 0x8453, 0x7c33, 0x7c13, 0x8cd8, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xb5dd, 0x7c12, 0x0862, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951a, 0x8431, 0x0000, 0x0000, 0x4a6a, 0xb5dc, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d7c, 0x7c12, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x632e, 0xd6bd, 0xcebd, 0xad98, 0x4a6a, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x2124, 0x7c13, 0x9d1b, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x6bb3, 0x8cda, 0x8479, 0x7c58, 0x8476, 0x4a8b, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4229, 0x8c98, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cb9, 0x31ca, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa55b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0862, 0x5b2f, 0x951b, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xa55a, 0x632e, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951a, 0x8411, 0x0000, 0x0000, 0x18c4, 0x7c14, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0xad99, 0x2125, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x632d, 0xc65a, 0x8c93, 0x52ab, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x0000, 0x2125, 0x73d2, 0x951b, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x7415, 0x951c, 0x84bd, 0x84bd, 0x8cdb, 0x6351, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632f, 0x94fa, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cbc, 0xa55a, 0x424a, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa55b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2125, 0x6b94, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5d, 0xa558, 0x528a, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d1a, 0x8431, 0x0000, 0x0000, 0x1083, 0x6372, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0xc67c, 0x94b3, 0x18e3, 0x18e4, 0x18e4, 0x4229, 0x4a6b, 0x52ab, 0x52ab, 0x630c, 0x2945, 0x0000, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x0000, 0x0000, 0x2126, 0x6330, 0x94fb, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa557, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x73d3, 0x94fb, 0x84bd, 0x84bd, 0x84dc, 0x9d1b, 0x6bb2, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x7c15, 0x8cdb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xa57c, 0x6b70, 0x0882, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa55b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6352, 0x953d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0xadbc, 0x8c94, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951a, 0x7c11, 0x0000, 0x0000, 0x4229, 0xb5dc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5c, 0x8453, 0x8431, 0x9493, 0x9d16, 0x8455, 0xa57a, 0xb5fd, 0xad9b, 0x7c14, 0x31a8, 0x2125, 0x0000, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x0000, 0x0000, 0x0000, 0x18c4, 0x6351, 0x8cfb, 0x84bc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f8, 0x52ac, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfb, 0xa577, 0x3187, 0x31a8, 0x31a8, 0x31a8, 0x31a8, 0x31a8, 0x31a7, 0x1082, 0x6b4f, 0x9d19, 0x8cfc, 0x84bd, 0x84bd, 0x8cdc, 0x8cda, 0x6b72, 0x4a6b, 0x31a8, 0x31c8, 0x39c7, 0x39e8, 0x31a8, 0x3a0a, 0x7c15, 0x8cfb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bc, 0x951c, 0x8456, 0x39c8, 0x0000, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39ea, 0x7c37, 0x8cdd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0xbe1c, 0x8452, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d3b, 0x8c93, 0x2966, 0x39e9, 0xa579, 0x94fb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x94f9, 0x420a, 0x4229, 0xa537, 0xb5dc, 0x8cdc, 0x84dc, 0x84dd, 0x84dc, 0x8cfb, 0x94f8, 0x7bf1, 0x0000, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e8, 0xad99, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x94f9, 0x5b0e, 0x31a7, 0x31a8, 0x31a8, 0x31a8, 0x31a8, 0x31a7, 0x18e4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2987, 0x8456, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfc, 0xaddb, 0x8c96, 0x8c96, 0x8c96, 0x8c96, 0x8c96, 0x8c96, 0x8c74, 0x4a8b, 0x0000, 0x73b1, 0x9d3a, 0x94fc, 0x84bd, 0x84bd, 0x84bc, 0x953c, 0x9d1a, 0x8476, 0x8cb6, 0x94b5, 0x94d6, 0x8476, 0x94d9, 0x9d5d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x9d3b, 0x8476, 0x422a, 0x0000, 0x0000, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a8, 0x7c36, 0x8cfc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa59d, 0xa578, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x9d5c, 0xa579, 0x8455, 0x8cb8, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0x951a, 0x8c94, 0x2945, 0x424a, 0xa559, 0x8cdb, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x7c35, 0x2105, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73d5, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x52cc, 0xa579, 0x951c, 0x84bd, 0x84bd, 0x84bd, 0x84dd, 0x9d5b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x9d3b, 0x94d7, 0x8c96, 0x8c96, 0x8c96, 0x8c96, 0x8c96, 0x8c95, 0x5acc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdb, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3187, 0x8456, 0x951d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x953d, 0x953d, 0x953d, 0x953d, 0x953d, 0x9d3c, 0x9d3b, 0x5b2f, 0x0000, 0x0000, 0x6b90, 0x8456, 0x94fb, 0x8cdc, 0x84bc, 0x84bc, 0x84bc, 0x8cfc, 0x9d3d, 0x9d3c, 0x9d3d, 0x951d, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x8cfc, 0x9d3a, 0x8474, 0x422a, 0x0000, 0x0000, 0x0000, 0x1906, 0x6bd6, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0xa55b, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0840, 0x6372, 0x8cdb, 0x84bd, 0x84bd, 0x84bd, 0x8cdc, 0xadbc, 0x94d5, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634f, 0x951a, 0x84dd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cdd, 0x951d, 0x951d, 0x8cdc, 0x84bc, 0x84bd, 0x84bc, 0x8cdd, 0x8cfc, 0x9d3a, 0x7bf3, 0x1905, 0x0000, 0x3a0a, 0x94d8, 0x8cdc, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x951c, 0x9d18, 0x31a7, 0x0000, 0x8479, 0x84bd, 0x84bd, 0x84bc, 0x73f5, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x630e, 0x9d19, 0x94fc, 0x84bd, 0x84bd, 0x84dd, 0x9d3b, 0x424b, 0x0000, 0xa557, 0xa59d, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x84bd, 0x8cfd, 0x951d, 0x953d, 0x953d, 0x951d, 0x951d, 0x953d, 0x9d3b, 0x6350, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c36, 0x8cfc, 0x84dd, 0x84dd, 0x84bc, 0x84bc, 0x8cba, 0x5b0f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2126, 0x8455, 0x951c, 0x84bc, 0x84bc, 0x84dc, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84bd, 0x84bc, 0x84bc, 0x84bc, 0x8cda, 0x52ce, 0x0000, 0x0000, 0x0000, 0x0841, 0x6b92, 0x8456, 0x94f9, 0xa59d, 0x8cfd, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x8cfc, 0x9d7d, 0x8cb9, 0x8477, 0x7bf4, 0x6b90, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0065, 0x6bb5, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x84bc, 0x9d5b, 0x2988, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b0f, 0x8cd9, 0x8cdc, 0x84dd, 0x84dd, 0x953c, 0xb5fb, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6f, 0x9d3a, 0x8cdc, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x8cdd, 0x94fd, 0x9d5d, 0x9d7c, 0x7c57, 0x8455, 0x6b90, 0x39c8, 0x0000, 0x0000, 0x2946, 0x73b2, 0x8cd9, 0x8cfc, 0x84bc, 0x84bc, 0x84bc, 0x8cfc, 0x9d5b, 0x73d1, 0x18e4, 0x0000, 0x8478, 0x8cdc, 0x8cdc, 0x8cdb, 0x73f4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aee, 0x94d9, 0x8cfc, 0x8cdc, 0x8cdc, 0xa55b, 0x424b, 0x0000, 0xa557, 0xadbd, 0x84bc, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84dd, 0x84bd, 0x84bc, 0x8cda, 0x5b30, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x6b6d, 0xad95, 0xa554, 0xa554, 0xa554, 0xa554, 0x52aa, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1903, 0x73ce, 0xad75, 0xa534, 0xa554, 0xa554, 0xa554, 0xa534, 0x6b8d, 0x0000, 0x0000, 0x4a8d, 0x5b11, 0x52f1, 0x6373, 0xbe1c, 0xaddb, 0xb5fa, 0xad96, 0x9d13, 0x4248, 0x9cf3, 0xa554, 0xa554, 0xa554, 0xa554, 0xa554, 0xa554, 0xa554, 0xa555, 0xb5d8, 0xb5fb, 0xaddb, 0xaddb, 0x6bb4, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x4ad1, 0xa57a, 0xaddb, 0xa59a, 0xb5fa, 0xad96, 0xa554, 0xad75, 0x630b, 0x0000, 0x0000, 0x3a09, 0x5b0e, 0x73d3, 0x7c35, 0xa57a, 0xa59b, 0xa57a, 0xa59b, 0xadbb, 0xad9a, 0xbe3c, 0xc65c, 0xb5f9, 0xb5b7, 0x73ae, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0xad95, 0xadb8, 0xaddb, 0xaddb, 0xa57a, 0xa579, 0xaddb, 0xbe1a, 0xa575, 0xa554, 0xa554, 0xa554, 0xa554, 0xa554, 0x94f3, 0x94f4, 0x94f4, 0x94f4, 0x94d3, 0x52cc, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2946, 0x52ce, 0x5311, 0x52f2, 0x52f2, 0x6351, 0x7bf2, 0x39e8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4209, 0x6330, 0x5311, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x5b11, 0x5b52, 0x6bb3, 0x73b2, 0x3a0a, 0x39c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e4, 0x52ae, 0x94d8, 0xadbc, 0xa57c, 0xadbc, 0x8c96, 0x6b70, 0x18e4, 0x0000, 0x0000, 0x52cf, 0x5311, 0x52f1, 0x52f1, 0x4a6c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0040, 0x52ad, 0x5b11, 0x52f1, 0x5311, 0x6350, 0x2946, 0x0000, 0x6b4e, 0x6b92, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x52f1, 0x5b10, 0x39e9, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x632c, 0x94b2, 0x73ce, 0x73ce, 0x73ce, 0x73ee, 0x8c91, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a69, 0x9d34, 0x73ee, 0x8471, 0x7c2f, 0x73ce, 0x73ce, 0x73ce, 0x52aa, 0x0000, 0x0000, 0x0020, 0x0021, 0x0021, 0x4208, 0xad75, 0x6baf, 0x73cf, 0x73ce, 0x6bad, 0x2986, 0x6b8d, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73cf, 0x73cf, 0x73cf, 0x31c7, 0x0001, 0x0021, 0x0021, 0x0021, 0x0000, 0x4228, 0x7bf0, 0x7c30, 0x73ef, 0x73cf, 0x73ce, 0x73ce, 0x9cf3, 0x630c, 0x0000, 0x0000, 0x0000, 0x0020, 0x0021, 0x4249, 0x6bae, 0x6baf, 0x6baf, 0x73d0, 0x8c92, 0x73cf, 0x8451, 0x73cf, 0x73ef, 0x7bef, 0x52ca, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x9d13, 0x73cf, 0x73cf, 0x73cf, 0x6b8e, 0xad75, 0x8471, 0x73cf, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x73ce, 0x6bae, 0x6bae, 0x6bae, 0x6bae, 0x73d0, 0x4a6a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0021, 0x0021, 0x0021, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0841, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x422a, 0x5aed, 0x52cd, 0x5aed, 0x3a09, 0x0841, 0x0000, 0x0000, 0x0000, 0x0020, 0x0021, 0x0021, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0021, 0x0021, 0x0021, 0x0021, 0x0000, 0x0000, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x4208, 0x94d2, 0x5b2b, 0x4ac9, 0x4ac9, 0x4ac9, 0x842f, 0x738d, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0x94d2, 0x6bad, 0x7c0f, 0x9d33, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d13, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x4ac9, 0x4ac9, 0x4aa9, 0x8450, 0xb5b5, 0xb5d6, 0xb5d6, 0xb5d6, 0xb5d6, 0xb5d6, 0xb5d6, 0xb5b6, 0x52ca, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0x8c91, 0x73ce, 0x5b0b, 0x52ea, 0x4ac9, 0x4ac9, 0x4aa9, 0x8c71, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x4aca, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x638c, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4ac9, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x4ac9, 0x4ac9, 0x4ac9, 0x8450, 0xb5d6, 0xb5d6, 0xb5d6, 0xad96, 0xa575, 0xa575, 0xa576, 0xa556, 0x632d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0020, 0x52ca, 0x8c91, 0x4ac9, 0x4ac9, 0x52c9, 0x5b2b, 0x7c0f, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x4228, 0x7c0f, 0x634c, 0x6b8d, 0x7c0f, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x4aca, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x6b8d, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aeb, 0x73ae, 0x73ce, 0x73ce, 0x52ca, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8450, 0x2124, 0x2965, 0x2945, 0x2145, 0x2145, 0x2145, 0x2145, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e8, 0x39e7, 0x3a07, 0x3a08, 0x4208, 0x4208, 0x4228, 0x4a69, 0x2124, 0x0000, 0x0000, 0x0000, 0x39c7, 0x4228, 0x4208, 0x4208, 0x4208, 0x4208, 0x4228, 0x4a49, 0x31a6, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x4228, 0x3a07, 0x39e7, 0x4208, 0x4a69, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x31a6, 0x4208, 0x4208, 0x39e7, 0x18c3, 0x39e7, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x3a07, 0x10a2, 0x0000, 0x1082, 0x39e7, 0x4228, 0x3a07, 0x3a07, 0x3a08, 0x18c3, 0x0000, 0x1082, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x4208, 0x39c6, 0x0000, 0x0000, 0x2965, 0x4248, 0x4207, 0x39e7, 0x4208, 0x39e7, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x31a6, 0x73ae, 0x6b8d, 0x4ac9, 0x4ac9, 0x52ea, 0x7c0f, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x6b6d, 0x6bad, 0x636c, 0x632c, 0x73ee, 0x6bad, 0x4ac9, 0x4aca, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x2965, 0x632c, 0x636c, 0x9d13, 0x4a49, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x52ea, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9cf4, 0x8cb2, 0x94d2, 0x94f3, 0x9cf2, 0x9cf3, 0x9d33, 0xad95, 0x632c, 0x3a07, 0x4a69, 0x0000, 0x94b2, 0xad75, 0x9cf2, 0x9cf3, 0x9cf3, 0x9cf2, 0x9d13, 0xad75, 0x7c0f, 0x31c7, 0x4a89, 0x5aeb, 0x0861, 0x0000, 0x18e3, 0x31c6, 0x39e7, 0x634c, 0x9d33, 0x94d2, 0x94b2, 0x9cf3, 0xadb5, 0x73ce, 0x5aeb, 0x2985, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x3a07, 0x8c91, 0x9cf3, 0x9cf3, 0x8c91, 0x6b6d, 0x94b2, 0x9cf3, 0x9cf3, 0x9cf3, 0x94f2, 0x94f2, 0x94f2, 0x94f2, 0x9cf3, 0x9cf3, 0x4248, 0x4a89, 0x52aa, 0x94b2, 0x9d13, 0x94d2, 0x94f2, 0x94d2, 0x52aa, 0x39e7, 0x4a69, 0xa534, 0x9d13, 0x94f2, 0x94f2, 0x9cf3, 0x9cf2, 0x9cf2, 0x9cf3, 0x9cf2, 0x94f2, 0x9d13, 0x94d2, 0x39e7, 0x52aa, 0x7bce, 0xa554, 0x9cf2, 0x94b2, 0x9d13, 0x8c91, 0x4a69, 0x4248, 0x10a2, 0x0000, + 0x0000, 0x10a2, 0x6b8d, 0x8470, 0x52ea, 0x4ac9, 0x4ac9, 0x5b2b, 0x94f2, 0x4208, 0x0000, 0x0000, 0x0000, 0x52ca, 0x94d2, 0x5b2b, 0x8c71, 0x5aeb, 0x73ce, 0x6bad, 0x4ac9, 0x4aca, 0x4aca, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x634d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x632c, 0x73ce, 0x73ce, 0x4a69, 0x1081, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x52ca, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8451, 0x52eb, 0x4aca, 0x4ac9, 0x73ad, 0x8c91, 0x8470, 0x7bef, 0x5b2b, 0x6b8d, 0x7c2f, 0x4a89, 0x94f2, 0x7c30, 0x4aa9, 0x4ac9, 0x5b0b, 0x8c91, 0x8c71, 0x842f, 0x636c, 0x5b2b, 0x8450, 0x94f3, 0x4228, 0x2965, 0x6b8d, 0x73ae, 0x6b8d, 0x52ea, 0x5b2b, 0x7c2f, 0x73ce, 0x73ee, 0x52ea, 0x5b2b, 0x94d2, 0x6b6d, 0x39c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d34, 0x4aa9, 0x4ac9, 0x4248, 0xad75, 0x73ce, 0x4ac9, 0x4ac9, 0x5b4b, 0x8450, 0x8c91, 0x8c91, 0x8c91, 0x8c91, 0x8c71, 0x73ce, 0x8c91, 0x73ee, 0x52ca, 0x634c, 0x73ee, 0x5b0b, 0x7c2f, 0x73ce, 0x6b8d, 0x73ee, 0x9d13, 0x8c91, 0x8450, 0x7c2f, 0x530a, 0x4ac9, 0x4ac9, 0x5b2b, 0x8430, 0x8450, 0x8c91, 0x9d13, 0x8430, 0x8cb1, 0x73ce, 0x7c0f, 0x4aa9, 0x4aa9, 0x6b8d, 0x6b8d, 0x7c0f, 0x8450, 0x5b0b, 0x18e3, + 0x0000, 0x0000, 0x4228, 0x7c0f, 0x638c, 0x4ac9, 0x4ac9, 0x52ea, 0x6b8d, 0x634c, 0x0000, 0x0000, 0x1082, 0x73ce, 0x5b2b, 0x73ce, 0x7bef, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x52ca, 0x4248, 0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x4a69, 0x9d13, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x6b8d, 0x2965, 0x2985, 0x2985, 0x2985, 0x2985, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0020, 0x4a48, 0x7bee, 0x73ae, 0x6b8d, 0x3186, 0x0861, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4a89, 0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x31c6, 0x8cb1, 0x4aca, 0x4ac9, 0x4ae9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8450, 0x2144, 0x2985, 0x2985, 0x2965, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8451, 0x52ea, 0x4ac9, 0x530a, 0x8430, 0x9cf3, 0x94d2, 0x7c0f, 0x52ca, 0x5b2b, 0x4ac9, 0x5b4b, 0x94f2, 0x7c0f, 0x4ac9, 0x4ac9, 0x634c, 0x94f2, 0x94d2, 0x8c71, 0x634c, 0x636c, 0x52ea, 0x52ea, 0x636c, 0x7c0f, 0x8450, 0x636c, 0x4ac9, 0x5b0b, 0x636c, 0x8450, 0x7bef, 0x8470, 0x6bad, 0x52ea, 0x4aa9, 0x6b8d, 0x4a89, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d33, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ca, 0x4ac9, 0x636c, 0x9cf2, 0x9d13, 0x9d13, 0x9d13, 0x9cf2, 0x8c71, 0x8450, 0x5b0b, 0x4aa9, 0x6bad, 0x6bad, 0x7c0f, 0x52aa, 0x8471, 0x8450, 0x8c50, 0x73ae, 0x8c71, 0x94b2, 0x94b2, 0x8c91, 0x73ce, 0x4ac9, 0x4ac9, 0x73ee, 0x8cb1, 0x94b2, 0x8c91, 0x73ce, 0x7c0f, 0x52ea, 0x73ee, 0x8cb1, 0x31c6, 0x3186, 0x6b6d, 0x8c71, 0x7c0f, 0x634c, 0x7bef, 0x31a6, + 0x0000, 0x0000, 0x0000, 0x73ae, 0x7c2f, 0x52ea, 0x4ae9, 0x4ae9, 0x634c, 0x73ce, 0x0861, 0x0000, 0x39e7, 0x636c, 0x5b2b, 0x8450, 0x2124, 0x0000, 0x73ee, 0x6bad, 0x4ac9, 0x4ac9, 0x52ea, 0x6b8d, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x7c0f, 0x844f, 0x4ac9, 0x4ac9, 0x52c9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4ac9, 0x7c0f, 0x8430, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x8c91, 0x73ae, 0x0000, 0x0000, 0x0000, 0x2945, 0x73ce, 0x73ee, 0x7c2f, 0x52ca, 0x0000, 0x0861, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x530a, 0x73ce, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x7bef, 0x73ee, 0x4aca, 0x4ac9, 0x52c9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52c9, 0x73ee, 0x8c70, 0x73ee, 0x7bef, 0x7bef, 0x73ef, 0x73cf, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8451, 0x530a, 0x4ac9, 0x5b2b, 0x5aeb, 0x0000, 0x0020, 0x0020, 0x2144, 0x8470, 0x4ac9, 0x4ac9, 0x73ee, 0x6b8d, 0x4ac9, 0x52c9, 0x52ca, 0x0861, 0x0020, 0x0000, 0x0861, 0x94d2, 0x634c, 0x4ac9, 0x636c, 0x8c91, 0x52ea, 0x52ea, 0x4ac9, 0x73ee, 0x6b6d, 0x1082, 0x0000, 0x634c, 0x8c70, 0x5b2b, 0x4ac9, 0x52ea, 0x632c, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d33, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ea, 0x4ac9, 0x5b2b, 0x73ce, 0x7bef, 0x7bef, 0x7bef, 0x6b8d, 0x4a69, 0x5b0b, 0x4ac9, 0x4ac9, 0x842f, 0x5289, 0x0861, 0x0000, 0x0000, 0x528a, 0x6b8d, 0x2965, 0x0000, 0x0020, 0x0840, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x7bee, 0x31c6, 0x0020, 0x0000, 0x3a07, 0x636c, 0x4ac9, 0x636c, 0x8c71, 0x634c, 0x2965, 0x0000, 0x528a, 0x8c70, 0x94d2, 0x7bee, 0x4a69, + 0x0000, 0x0000, 0x0000, 0x39e7, 0x8450, 0x6b8d, 0x4ac9, 0x4ac9, 0x52ea, 0x8430, 0x8430, 0x0000, 0x7bef, 0x636c, 0x7bef, 0x8c71, 0x0861, 0x0000, 0x73ce, 0x6bad, 0x4aca, 0x4ac9, 0x52ea, 0x5b2b, 0x634c, 0x634c, 0x634c, 0x634c, 0x634c, 0x634c, 0x5b2b, 0x4ac9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aca, 0x5b2b, 0x634c, 0x634c, 0x634c, 0x634c, 0x634c, 0x94b2, 0x8c50, 0x0000, 0x0000, 0x10c2, 0x6b8d, 0x7c0f, 0x5b2c, 0x5aeb, 0x2144, 0x0000, 0x0861, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x52ea, 0x5b2b, 0x634c, 0x634c, 0x634c, 0x634c, 0x634c, 0x634c, 0x5b2b, 0x4ac9, 0x52c9, 0x52c9, 0x4aa9, 0xad55, 0x73ce, 0x4aea, 0x4ae9, 0x4ac9, 0x5b0b, 0x636c, 0x634c, 0x634c, 0x634c, 0x634c, 0x7c0f, 0x8451, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x530a, 0x4ac9, 0x5b2b, 0x5b0b, 0x2965, 0x2965, 0x2124, 0x94d2, 0x73ce, 0x4ac9, 0x52ca, 0x8470, 0x73ee, 0x4ac9, 0x52c9, 0x52ca, 0x2985, 0x2965, 0x10a2, 0x8c91, 0x94b1, 0x5b0b, 0x52ea, 0x7bee, 0xa554, 0x4268, 0x52ea, 0x4ac9, 0x8450, 0x73ce, 0x1082, 0x0000, 0x6b6d, 0x94b2, 0x5b4b, 0x4ac9, 0x530a, 0x9492, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d33, 0x4ac9, 0x4ac9, 0x4268, 0xa575, 0x73ce, 0x4aea, 0x4ac9, 0x530a, 0x636c, 0x634c, 0x634c, 0x634c, 0x9d13, 0x738d, 0x5b2b, 0x4ac9, 0x4ac9, 0x52ca, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x73ee, 0x31c6, 0x0000, 0x0000, 0x6b4d, 0x9cf3, 0x4ac9, 0x52ea, 0x6b8d, 0x6b8d, 0x7bef, 0x1903, 0x0861, 0x4228, 0x6b8d, 0x4a69, 0x2965, + 0x0000, 0x0000, 0x0000, 0x0000, 0x52ca, 0x636c, 0x52ea, 0x4ac9, 0x4ac9, 0x634c, 0x73ee, 0x634c, 0x634c, 0x5b0b, 0x8450, 0x39e7, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a27, 0x18e3, 0x18e3, 0x18e3, 0x18e3, 0x18e3, 0x4208, 0x94d2, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4ac9, 0x8c91, 0x634c, 0x10e2, 0x18e3, 0x18e3, 0x18e3, 0x31a6, 0x31a6, 0x0000, 0x0000, 0x2965, 0x6b6d, 0x636c, 0x7c0f, 0x4a69, 0x0000, 0x0000, 0x0861, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c71, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x18e3, 0x18e3, 0x18e3, 0x18e3, 0x18e3, 0x2144, 0x8470, 0x4aca, 0x4ac9, 0x52c9, 0x4aa9, 0xad55, 0x73ce, 0x52ea, 0x4ac9, 0x52ca, 0x8450, 0x7c0f, 0x08a1, 0x18e3, 0x18e3, 0x18e3, 0x2965, 0x31c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x530a, 0x4ac9, 0x52ea, 0x7c0f, 0x94d2, 0x8cb1, 0x73ee, 0x638d, 0x52ea, 0x5b2b, 0x7c0f, 0xad75, 0x7c50, 0x4ac9, 0x4ac9, 0x5b4b, 0x94d2, 0x94d2, 0x8450, 0x73ae, 0x5b2b, 0x52ea, 0x6bad, 0x8430, 0x4a89, 0x4aa9, 0x52ea, 0x4ac9, 0x8450, 0x7bcf, 0x1082, 0x0000, 0x6b6d, 0x94b2, 0x5b4b, 0x4ac9, 0x530a, 0x8c91, 0x2945, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d33, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ea, 0x4aca, 0x6b8d, 0x73ce, 0x08a2, 0x18e3, 0x18e3, 0x4a69, 0x8430, 0x636c, 0x4ac9, 0x52ea, 0x3a27, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x73ee, 0x31c6, 0x0000, 0x0000, 0x39c6, 0x73ae, 0x7c0f, 0x5b4b, 0x52ca, 0x52ea, 0x5b2b, 0x636c, 0x73ae, 0x5acb, 0x18e3, 0x0841, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x73ce, 0x5b2b, 0x4ac9, 0x4ac9, 0x52ea, 0x636c, 0x6bad, 0x530a, 0x7bef, 0x528a, 0x0040, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0xa513, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0xa554, 0x636c, 0x634c, 0x39e7, 0x0861, 0x0000, 0x0000, 0x0861, 0x4aa9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c91, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31c6, 0x52ca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8cb1, 0x530a, 0x4ac9, 0x52ea, 0x52ea, 0x52ca, 0x52ca, 0x52ea, 0x636c, 0x8c91, 0xa534, 0x39e7, 0x94b2, 0x7c30, 0x4ac9, 0x4ac9, 0x52ca, 0x52ea, 0x5b2b, 0x6b8d, 0x5b2b, 0x52ea, 0x52ea, 0x73ee, 0x5b0b, 0x31a6, 0x4aa9, 0x52ea, 0x4ac9, 0x8450, 0x7bcf, 0x1082, 0x0000, 0x6b6d, 0x94b2, 0x5b4b, 0x4ac9, 0x530a, 0x9cd2, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d33, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ca, 0x4aea, 0x4a89, 0x2144, 0x0000, 0x0000, 0x0000, 0x2124, 0x8430, 0x636c, 0x4ac9, 0x52ea, 0x3a27, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x73ee, 0x31c6, 0x0000, 0x0000, 0x0020, 0x10c2, 0x3a07, 0x5b0b, 0x6bad, 0x5b2b, 0x52ea, 0x52ea, 0x634c, 0x8c71, 0x73ae, 0x2945, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x636c, 0x52ea, 0x4ac9, 0x4ac9, 0x530b, 0x5b2b, 0x5b2b, 0x4a69, 0x1082, 0x0000, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52ca, 0x4ac9, 0x4aa9, 0x94d2, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a48, 0x6b8d, 0x6bad, 0x8450, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x52a9, 0x52ca, 0x4ac9, 0x4aa9, 0x8c71, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0x4aca, 0x52ea, 0x4ac9, 0x5b2b, 0x7c2f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad55, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x530a, 0x4ac9, 0x5b2b, 0x5aea, 0x0000, 0x0020, 0x0020, 0x0841, 0x1082, 0x10a2, 0x0000, 0x8c91, 0x8450, 0x4ac9, 0x4ac9, 0x52ca, 0x0000, 0x6b6d, 0xa554, 0x7bef, 0x634c, 0x52ea, 0x52ea, 0x73ce, 0x6b6d, 0x4aa9, 0x52ea, 0x4ac9, 0x8450, 0x7bce, 0x1082, 0x0000, 0x6b6d, 0x94b2, 0x5b4b, 0x4ac9, 0x530a, 0x9cf3, 0x39e7, 0x31a6, 0x0000, 0x0000, 0x0000, 0x0881, 0x634c, 0x9d34, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ea, 0x4ae9, 0x4268, 0x10a2, 0x0000, 0x0000, 0x0000, 0x2124, 0x8430, 0x636c, 0x4ac9, 0x52ea, 0x3a27, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0x31a6, 0x0000, 0x0000, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x73ee, 0x31c6, 0x0000, 0x0000, 0x0861, 0x39c7, 0x3186, 0x0000, 0x94d2, 0x7c0f, 0x6b8d, 0x636c, 0x52ca, 0x4ac9, 0x6bad, 0x5aeb, 0x2965, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x52eb, 0x5b2b, 0x52ca, 0x4ac9, 0x4ac9, 0x4ac9, 0x6b6d, 0x3a07, 0x0040, 0x0000, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x52ea, 0x4aa9, 0x1903, 0x4a89, 0x52c9, 0x4ac9, 0x4aa9, 0x94d2, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x632c, 0x5b2b, 0x8c71, 0x528a, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x634c, 0x4aca, 0x4ac9, 0x4ac9, 0x7c2f, 0x52ca, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52aa, 0x5b0b, 0x4ac9, 0x4ac9, 0x634c, 0x94b2, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad54, 0x73ce, 0x52ca, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x530a, 0x4ac9, 0x5b2b, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x8450, 0x4ac9, 0x52c9, 0x52ca, 0x0020, 0x0000, 0x0000, 0x10a2, 0x7c0f, 0x5b2b, 0x4ac9, 0x634b, 0x8430, 0x4a89, 0x52ea, 0x4ac9, 0x8450, 0x73ce, 0x0020, 0x0000, 0x6b4d, 0x8c91, 0x5b2b, 0x4ac9, 0x530a, 0x94b2, 0x6b6d, 0x73ce, 0x2104, 0x0000, 0x0000, 0x0020, 0x632c, 0x9d13, 0x4ac9, 0x4ac9, 0x4268, 0xad75, 0x73ce, 0x52ea, 0x4ac9, 0x4268, 0x10a2, 0x0000, 0x0000, 0x0000, 0x18e3, 0x738e, 0x632c, 0x4ac9, 0x52ca, 0x4268, 0x10c2, 0x0000, 0x0000, 0x0000, 0x2104, 0x7c0f, 0x6b8d, 0x2985, 0x0861, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x73ee, 0x31c6, 0x0000, 0x10a2, 0x4228, 0x73ce, 0x6b6d, 0x1082, 0x0000, 0x39e7, 0x5aeb, 0x8470, 0x634c, 0x52ea, 0x4ac9, 0x7bef, 0x5b0b, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a08, 0x73ee, 0x52ea, 0x4ac9, 0x4ac9, 0x6b8d, 0x73ae, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ae9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d33, 0x4aa9, 0x4ac9, 0x4ac9, 0x4aa9, 0x1903, 0x4a89, 0x52c9, 0x4ac9, 0x4aa9, 0x94d2, 0x6b4d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b8d, 0x6bad, 0x8450, 0x632c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x8430, 0x636c, 0x4ac9, 0x4ac9, 0x5b2b, 0x636c, 0x6b6d, 0x18c3, 0x0861, 0x4a89, 0x634c, 0x73ae, 0x636c, 0x4ac9, 0x4ac9, 0x634c, 0x7c0f, 0x5b0b, 0x6b8d, 0x4ac9, 0x4ac9, 0x5b0b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4aca, 0x4ac9, 0x4ac9, 0x4aa9, 0xad54, 0x73ce, 0x52e9, 0x4ac9, 0x52ca, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x530a, 0x4aca, 0x5b2b, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c71, 0x8430, 0x4ac9, 0x52ca, 0x52ca, 0x0020, 0x0000, 0x0000, 0x18e3, 0x8450, 0x5b2b, 0x4ac9, 0x5b0a, 0x73ee, 0x636c, 0x52ca, 0x4ac9, 0x6bad, 0x73ee, 0x6b4d, 0x3a07, 0x8430, 0x7bef, 0x530a, 0x4ac9, 0x5b4b, 0x8c91, 0x5b0b, 0x73ee, 0x7bef, 0x4a89, 0x18c3, 0x5aeb, 0x738d, 0x8450, 0x4ac9, 0x4ac9, 0x5b2b, 0xad95, 0x73ce, 0x52ea, 0x4ac9, 0x4aa9, 0x31a6, 0x0000, 0x0000, 0x0000, 0x0000, 0x2144, 0x636c, 0x4ac9, 0x4ac9, 0x636c, 0x634c, 0x5aeb, 0x18e3, 0x4a89, 0x6b8d, 0x73ae, 0x5b0b, 0x634c, 0x2124, 0x0000, 0x4228, 0x7c0f, 0x4ac9, 0x4ac9, 0x740e, 0x31c6, 0x0000, 0x2965, 0x634c, 0x5b0b, 0x6b8d, 0x5b0b, 0x73ae, 0x2124, 0x0020, 0x5b0b, 0x94b2, 0x636c, 0x4ac9, 0x6bad, 0x52aa, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x5aeb, 0x5b2b, 0x4ac9, 0x52ea, 0x6b8d, 0x39e7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73ce, 0x6bad, 0x4ac9, 0x4ac9, 0x4ac9, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3a07, 0x9d13, 0x4aa9, 0x4ac9, 0x4ac9, 0x4a89, 0x1903, 0x4a89, 0x4ac9, 0x4ac9, 0x4aa9, 0x94d2, 0x634d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a89, 0x7bef, 0x6b8d, 0x7c0f, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x5acb, 0x73ce, 0x6b8d, 0x530a, 0x4aca, 0x636c, 0x7c0f, 0x4248, 0x4268, 0x636c, 0x73ce, 0x4ac9, 0x52ca, 0x530a, 0x6bad, 0x4248, 0x18e3, 0x52ca, 0x638c, 0x4ac9, 0x4ac9, 0x530b, 0x4248, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x8cb1, 0x4ac9, 0x4ac9, 0x4ac9, 0x4aa9, 0xad75, 0x73ce, 0x4ac9, 0x4ac9, 0x4ac9, 0x8c91, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0x52ea, 0x4ac9, 0x5b2b, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c71, 0x7c2f, 0x4aa9, 0x4ac9, 0x52ca, 0x0020, 0x0000, 0x0000, 0x18e3, 0x8450, 0x5b2b, 0x4ac9, 0x530a, 0x73ae, 0x7bef, 0x73ce, 0x52ea, 0x52ea, 0x6b8d, 0x7bef, 0x5aeb, 0x7c2f, 0x5b0b, 0x52ea, 0x5b2b, 0x8470, 0x8c71, 0x8c91, 0x636c, 0x7c0f, 0x636c, 0x4248, 0x73ae, 0x6b8d, 0x530a, 0x52ea, 0x6b8d, 0x6b8d, 0xad95, 0x73ce, 0x4ac9, 0x4ac9, 0x52ca, 0x4a89, 0x39e7, 0x39e7, 0x39e7, 0x3a07, 0x52aa, 0x6b8d, 0x6b8d, 0x52ea, 0x5b4c, 0x73ce, 0x6bad, 0x4248, 0x634c, 0x73ce, 0x636c, 0x8c91, 0x6b8d, 0x18e3, 0x0000, 0x4228, 0x7c0f, 0x4aa9, 0x4aa9, 0x73ee, 0x31c6, 0x0000, 0x10a2, 0x6b8d, 0x8cb1, 0x634c, 0x6b8d, 0x8450, 0x4a69, 0x3a27, 0x634c, 0x7c2f, 0x636c, 0x6b8d, 0x52ea, 0x2965, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x8430, 0x7c2f, 0x8450, 0x6b4d, 0x1903, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c71, 0x94d2, 0x7c2f, 0x7c2f, 0x7c0f, 0x5aea, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0xb5b6, 0x7c0f, 0x7c2f, 0x7c2f, 0x7bef, 0x31a6, 0x73ce, 0x7c2f, 0x7c2f, 0x7c2f, 0xad75, 0x6b8e, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c7, 0x94b2, 0x94d2, 0x7c0f, 0x31c6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0040, 0x39e7, 0x632c, 0x73ce, 0x7c2f, 0x8cb1, 0x8430, 0x7c0f, 0x73ee, 0x7c0f, 0x8450, 0x8430, 0x634c, 0x73ce, 0x5b0b, 0x10a2, 0x10c2, 0x6b8d, 0x8cb1, 0x7c2f, 0x7c2f, 0x8450, 0x5aeb, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0xa554, 0x7c2f, 0x7c2f, 0x7c2f, 0x7bef, 0x94d2, 0x8c70, 0x7c2f, 0x7c2f, 0x7c2f, 0x94d2, 0x73ae, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xa534, 0x8450, 0x7c2f, 0x8470, 0x73ce, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x94d2, 0x9d13, 0x7c2f, 0x7c2f, 0x7c0f, 0x0841, 0x0000, 0x0000, 0x20e3, 0x9cf3, 0x8470, 0x7c2f, 0x8450, 0x7c0f, 0x3a07, 0x8450, 0x6b8d, 0x8c91, 0x8470, 0x7c2f, 0x7c0f, 0x8450, 0x94b2, 0x73ae, 0x8c91, 0x630b, 0x3186, 0x73ae, 0x73ce, 0x7c0f, 0x8c91, 0x7c0f, 0x7c2f, 0x8470, 0x8c91, 0x6b8d, 0x7bef, 0x4208, 0x8c71, 0x8c70, 0x7c2f, 0x7c2f, 0x7c2f, 0x7c2f, 0x7c2f, 0x7c2f, 0x7c2f, 0x8430, 0x8450, 0x52aa, 0x73ce, 0x6b8d, 0x8450, 0x8450, 0x7c2f, 0x7c0f, 0x8c71, 0x8470, 0x5aeb, 0x634d, 0x31c6, 0x0000, 0x0000, 0x528a, 0x9cf3, 0x7c2f, 0x7c2f, 0x94d2, 0x4228, 0x0000, 0x0000, 0x3a07, 0x73ae, 0x634c, 0x6b6d, 0x8450, 0x7c0f, 0x7c0f, 0x8c70, 0x842f, 0x7bef, 0x73ae, 0x2945, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x4a69, 0x630c, 0x5aeb, 0x39e7, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52cb, 0x634c, 0x5b0b, 0x5b0b, 0x5b0b, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0x73ae, 0x5b0b, 0x5b0b, 0x5b0b, 0x5aeb, 0x2124, 0x5acb, 0x5b0b, 0x5b0b, 0x5b0b, 0x6b8d, 0x4228, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x5b0b, 0x6b4d, 0x52aa, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x31a6, 0x5aeb, 0x6b6d, 0x5b0b, 0x5aeb, 0x52ca, 0x5aeb, 0x632c, 0x630b, 0x39e7, 0x31c6, 0x18e3, 0x0000, 0x0861, 0x4a69, 0x634c, 0x5b0b, 0x5b0b, 0x630c, 0x3a07, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x6b6d, 0x5b0b, 0x5b0b, 0x5b0b, 0x5aeb, 0x4248, 0x5aeb, 0x5b0b, 0x5b0b, 0x5b0b, 0x5aeb, 0x31a6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x634c, 0x632c, 0x5b0b, 0x632c, 0x528a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aeb, 0x6b6d, 0x5b0b, 0x5b0b, 0x5aeb, 0x0020, 0x0000, 0x0000, 0x0861, 0x632c, 0x632c, 0x5b0b, 0x632c, 0x52aa, 0x0000, 0x39c7, 0x31a6, 0x6b6d, 0x634c, 0x5b0b, 0x5aeb, 0x632c, 0x6b8d, 0x4a69, 0x4228, 0x1082, 0x0000, 0x2104, 0x31c6, 0x52ca, 0x634c, 0x5b0b, 0x5b0b, 0x634c, 0x634c, 0x31c6, 0x31a6, 0x0861, 0x31c6, 0x5aeb, 0x5b0b, 0x5b0b, 0x5b0b, 0x5b0b, 0x5b0b, 0x5b0b, 0x5b0b, 0x5b0b, 0x630c, 0x2945, 0x3186, 0x39c7, 0x632c, 0x632c, 0x5b0b, 0x5b0b, 0x634c, 0x630c, 0x2124, 0x0861, 0x0000, 0x0000, 0x0000, 0x31a6, 0x6b6d, 0x5b0b, 0x5b0b, 0x6b4c, 0x2965, 0x0000, 0x0000, 0x0000, 0x18e3, 0x2965, 0x4228, 0x5b0b, 0x5b0b, 0x5b0b, 0x634c, 0x5aeb, 0x39c7, 0x2965, 0x0020, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x5aeb, 0x8c91, 0x8430, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0x8410, 0x8c91, 0x8c71, 0x8c51, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x5acb, 0x8c91, 0x8c71, 0x8c71, 0x8430, 0x39e7, 0x8430, 0x8c71, 0x8c71, 0x8c91, 0x6b4c, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52aa, 0x8410, 0x4a69, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x31a6, 0x39c7, 0x5aeb, 0x8c50, 0x8c71, 0x8c51, 0x8c71, 0x8c51, 0x630b, 0x31a6, 0x3186, 0x0841, 0x0000, 0x0000, 0x4228, 0x840f, 0x8c91, 0x8c71, 0x8430, 0x4228, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x52aa, 0x8c71, 0x8c71, 0x8c91, 0x8430, 0x4208, 0x840f, 0x8c71, 0x8c71, 0x8c71, 0x6b6d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0x8c71, 0x8c71, 0x8c51, 0x5aeb, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x7bef, 0x8c71, 0x8c71, 0x8430, 0x0861, 0x0000, 0x0000, 0x0000, 0x5acb, 0x8c51, 0x8c71, 0x8c50, 0x52aa, 0x0000, 0x18c3, 0x3186, 0x4208, 0x7c0f, 0x8c71, 0x8c71, 0x8450, 0x5b0b, 0x31c6, 0x2104, 0x0020, 0x0000, 0x0861, 0x2965, 0x4a69, 0x7c0f, 0x8c71, 0x8c71, 0x8410, 0x39e7, 0x3186, 0x18e3, 0x0000, 0x0000, 0x8410, 0x8c71, 0x8c71, 0x8c71, 0x8c71, 0x8c71, 0x8c71, 0x8c71, 0x8c71, 0x7bcf, 0x2104, 0x18e3, 0x3186, 0x528a, 0x8430, 0x8c71, 0x8c71, 0x73ae, 0x39e7, 0x2965, 0x1082, 0x0000, 0x0000, 0x0000, 0x2124, 0x6b6d, 0x8c91, 0x8c91, 0x7bcf, 0x2965, 0x0000, 0x0000, 0x0000, 0x18c3, 0x3186, 0x39e7, 0x7bef, 0x8c71, 0x8c71, 0x7bcf, 0x39e7, 0x2985, 0x10a2, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4a49, 0xce58, 0xd6ba, 0xc658, 0x8410, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9d13, 0xd69a, 0xd69a, 0xd6ba, 0xce79, 0x8c71, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0xbdd7, 0xd6ba, 0xd6ba, 0xd6ba, 0xc658, 0x5aeb, 0xc638, 0xd69a, 0xd69a, 0xd6ba, 0xb596, 0x4a69, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bef, 0xc638, 0xa534, 0x39e7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x39c7, 0x7bef, 0xb5d6, 0xb5d6, 0xbdf7, 0xce79, 0xce99, 0xce79, 0xce99, 0xce99, 0xbdf7, 0xbdd7, 0xad96, 0x634c, 0x2124, 0x18c3, 0x8c71, 0xd69a, 0xd69a, 0xd6ba, 0xce99, 0x7bef, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x2144, 0xc618, 0xd69a, 0xd69a, 0xd6ba, 0xc638, 0x634c, 0xbe17, 0xd69a, 0xd69a, 0xd69a, 0xa534, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xb5b6, 0xd699, 0xd69a, 0xd6ba, 0xa534, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bcf, 0xc638, 0xd6ba, 0xd69a, 0xc638, 0x10a2, 0x0000, 0x0000, 0x18e3, 0xb5d6, 0xd69a, 0xd6ba, 0xce99, 0xa514, 0x2124, 0x7bef, 0xb596, 0xb5d6, 0xce79, 0xce99, 0xce99, 0xce79, 0xbe17, 0xbdf7, 0x8c91, 0x52aa, 0x1082, 0x5acb, 0xa554, 0xbdf7, 0xce59, 0xce99, 0xce99, 0xce79, 0xb5b6, 0xb596, 0x8c50, 0x39e7, 0x0020, 0xc618, 0xd69a, 0xd69a, 0xd69a, 0xce99, 0xce99, 0xce99, 0xce99, 0xce99, 0xc618, 0x5acb, 0x8430, 0xb5b6, 0xbdf7, 0xce79, 0xce99, 0xce79, 0xc638, 0xbdd7, 0xad55, 0x5aeb, 0x0020, 0x0000, 0x0000, 0x630c, 0xce79, 0xd6ba, 0xd6ba, 0xce79, 0x52ca, 0x0000, 0x0000, 0x1082, 0x738e, 0xb596, 0xb5d6, 0xce58, 0xce99, 0xce99, 0xc638, 0xb5b6, 0xad75, 0x73ae, 0x3186, 0x0020, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10a2, 0x8410, 0xd6ba, 0xd6ba, 0xd6ba, 0xad95, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xad55, 0xd6da, 0xd6ba, 0xd6ba, 0xce79, 0x8c71, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x9cd3, 0xd6ba, 0xd6ba, 0xd6ba, 0xc658, 0x5aeb, 0xc638, 0xd6ba, 0xd6ba, 0xd6ba, 0x94b2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6b6d, 0xb5d6, 0xd6ba, 0x8430, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0xad75, 0xce99, 0xd6ba, 0xd6b9, 0xc658, 0xad95, 0xa534, 0xa554, 0xad55, 0xbdf7, 0xce99, 0xd6ba, 0xd6ba, 0xd6ba, 0x8c51, 0x4207, 0x9cf3, 0xdedb, 0xd6ba, 0xd6ba, 0xd6ba, 0x8c51, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0xd6da, 0xd6ba, 0xd6ba, 0xd6ba, 0xc638, 0x634c, 0xbe17, 0xd6ba, 0xd69a, 0xd6ba, 0xa534, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xce79, 0xd6ba, 0xd6ba, 0xd6da, 0xad75, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632c, 0xc617, 0xd6ba, 0xd6ba, 0xce58, 0x10a2, 0x0000, 0x0000, 0x2124, 0xc658, 0xd6ba, 0xd6ba, 0xd6ba, 0xb596, 0x8c71, 0xce79, 0xd6ba, 0xd6ba, 0xce79, 0xa534, 0xa534, 0xbdd6, 0xd6ba, 0xd6ba, 0xd6ba, 0xc638, 0x738e, 0xad55, 0xd699, 0xc617, 0xad75, 0xa534, 0xa534, 0xc658, 0xd69a, 0xd6ba, 0xd6da, 0xad55, 0x39e7, 0xc618, 0xd6ba, 0xd6ba, 0xce58, 0xa554, 0xa534, 0xa534, 0xa534, 0xa534, 0xa534, 0xad55, 0xd6da, 0xd6ba, 0xce79, 0xc638, 0xa554, 0xa534, 0xad55, 0xc638, 0xce99, 0xad95, 0x5aeb, 0x10a2, 0x0000, 0x738e, 0xdefb, 0xd6ba, 0xd6ba, 0xd6da, 0x5aeb, 0x0000, 0x18e3, 0x6b8d, 0xbdf7, 0xce79, 0xbdf7, 0xa554, 0xa534, 0xa534, 0xa534, 0xb596, 0xce79, 0xd6da, 0x94b2, 0x2945, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0xbdd7, 0xdeda, 0xdefa, 0xdefb, 0xd6ba, 0x8410, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c51, 0xd699, 0xdefb, 0xdedb, 0xd6ba, 0x9492, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x73ae, 0xdefb, 0xdefb, 0xdefb, 0xce99, 0x5b0b, 0xce79, 0xdedb, 0xdedb, 0xdefb, 0x9cd3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x632c, 0xce79, 0xc638, 0x31a6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x8c71, 0xdefb, 0xdedb, 0xdefb, 0xdeda, 0x94b2, 0x39c7, 0x0000, 0x0000, 0x2124, 0x632c, 0xad55, 0xd6ba, 0xdefb, 0xdedb, 0xd69a, 0x73ae, 0x9cd3, 0xdefb, 0xdedb, 0xdefb, 0xdedb, 0x8c71, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0xd6ba, 0xdefb, 0xdefb, 0xdefb, 0xce79, 0x6b6d, 0xc638, 0xdedb, 0xdedb, 0xdefb, 0xad75, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xc638, 0xdedb, 0xdedb, 0xdefb, 0xb596, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2945, 0xbdf7, 0xdefb, 0xdedb, 0xce79, 0x18c3, 0x0000, 0x0000, 0x18e3, 0xbdd7, 0xdedb, 0xdefb, 0xdeda, 0xc618, 0xb5d6, 0xdefb, 0xdedb, 0xd69a, 0x9492, 0x0000, 0x0000, 0x632c, 0xbe17, 0xdedb, 0xdedb, 0xd6ba, 0xce59, 0xdeda, 0xbdf7, 0x6b8d, 0x31a6, 0x0000, 0x0020, 0x8410, 0xc638, 0xdefb, 0xdefb, 0xce79, 0x632c, 0xc658, 0xdedb, 0xdefb, 0xc618, 0x39e7, 0x0000, 0x0000, 0x0000, 0x0000, 0x528a, 0xce79, 0xdefb, 0xdefb, 0xb5d6, 0x7bcf, 0x18c3, 0x0000, 0x2945, 0x73ce, 0xbdf7, 0xdefb, 0xa534, 0x31a6, 0x0000, 0x6b6d, 0xdefb, 0xdedb, 0xdedb, 0xdefb, 0x630c, 0x0000, 0x4a49, 0xbdd7, 0xdefb, 0xad75, 0x5aeb, 0x10c3, 0x0000, 0x0000, 0x0000, 0x73ae, 0xce79, 0xdefb, 0xc638, 0x52aa, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x630c, 0xd69a, 0xe71c, 0xe73c, 0xe73c, 0xe73c, 0xbdf7, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0000, 0x630c, 0xce79, 0xe73c, 0xe71c, 0xdefb, 0x94d2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x7bef, 0xe73c, 0xe73c, 0xe73c, 0xd6da, 0x630c, 0xd69a, 0xe73c, 0xe73c, 0xe73c, 0x9cf3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0xa514, 0xdeda, 0x94b2, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0xce79, 0xe71c, 0xe71c, 0xe73c, 0xbe17, 0x528a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7bce, 0xd6ba, 0xe73c, 0xe71c, 0xdedb, 0x8430, 0x8450, 0xdeda, 0xe73c, 0xe71c, 0xe71b, 0x9492, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0xa514, 0xe71c, 0xe73c, 0xe73c, 0xd6ba, 0x6b8d, 0xce79, 0xe71c, 0xe71c, 0xe71c, 0xb596, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8c91, 0xdefb, 0xe71c, 0xe71c, 0xad75, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3185, 0xc638, 0xe73c, 0xe73c, 0xd6da, 0x18c3, 0x0000, 0x0000, 0x0861, 0xa534, 0xdefb, 0xe73c, 0xdefb, 0xad55, 0xce59, 0xe73c, 0xe71c, 0xc638, 0x39c7, 0x0000, 0x0000, 0x0000, 0x9d13, 0xdf1b, 0xe71c, 0xdf1b, 0xb5d6, 0x94b2, 0x73ce, 0x1082, 0x0000, 0x0000, 0x0000, 0x39c7, 0xb5b6, 0xe73c, 0xe73c, 0xd6ba, 0x6b6d, 0xce79, 0xe71c, 0xe73c, 0xce58, 0x4a48, 0x0000, 0x0000, 0x0000, 0x0000, 0x5acb, 0xd6ba, 0xe73c, 0xe73c, 0xb5b6, 0x4208, 0x0000, 0x0000, 0x0000, 0x2124, 0x7bef, 0x9cd3, 0x7bcf, 0x2945, 0x0000, 0x5aeb, 0xce59, 0xe73c, 0xe73c, 0xdeda, 0x5aeb, 0x0000, 0x39c7, 0x8c71, 0x9cd3, 0x6b6d, 0x0000, 0x0000, 0x0020, 0x528a, 0x94b2, 0xc658, 0xe71c, 0xe73c, 0xc658, 0x52aa, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x94b2, 0xdedb, 0xdedb, 0xd6ba, 0xce99, 0xce79, 0xce59, 0x6b6d, 0x1082, 0x0000, 0x0000, 0x0000, 0x5aeb, 0xc638, 0xdefb, 0xdedb, 0xd6ba, 0x8410, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x73ae, 0xdefb, 0xdedb, 0xdedb, 0xce79, 0x5aeb, 0xce59, 0xdedb, 0xdedb, 0xdefb, 0x9cd3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c7, 0x9cd3, 0xbdf7, 0x4228, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0xb596, 0xdedb, 0xdedb, 0xdefb, 0x9cf3, 0x10a2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5aeb, 0xc617, 0xdedb, 0xdedb, 0xd69a, 0x7bef, 0x632c, 0xc638, 0xdefb, 0xdedb, 0xce79, 0x632c, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x6b6d, 0xdedb, 0xdedb, 0xdedb, 0xbdd7, 0x52aa, 0xc638, 0xdedb, 0xdedb, 0xdefb, 0xad75, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528a, 0xd6ba, 0xdefb, 0xce79, 0x7bef, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0xbdf7, 0xdefb, 0xdedb, 0xb5b6, 0x1082, 0x0000, 0x0000, 0x18c3, 0xb5b6, 0xdedb, 0xd6da, 0xa554, 0x632c, 0xbdd7, 0xdedb, 0xdedb, 0xc638, 0x39e7, 0x0000, 0x0000, 0x0000, 0x9cd3, 0xd6ba, 0xdedb, 0xd6ba, 0x8430, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0xb5b6, 0xdefb, 0xdedb, 0xce79, 0x632c, 0xc638, 0xd6ba, 0xdedb, 0xc618, 0x4228, 0x0000, 0x0000, 0x0000, 0x0000, 0x52aa, 0xd69a, 0xdefb, 0xdefb, 0xad75, 0x4208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39e7, 0xa554, 0xdefb, 0xdefb, 0xa534, 0x39c7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x630c, 0xb596, 0xd69a, 0xdefb, 0xdefb, 0xbdf7, 0x8410, 0x2124, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528a, 0x6b4d, 0x6b4d, 0x632c, 0x630c, 0x5acb, 0x630c, 0x31a6, 0x0020, 0x0000, 0x0000, 0x0000, 0x2945, 0x5aeb, 0x6b6d, 0x6b4d, 0x632c, 0x31a6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x31a6, 0x6b4d, 0x6b4d, 0x6b4d, 0x630c, 0x2945, 0x630c, 0x6b4d, 0x6b4d, 0x6b4d, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2965, 0x5aeb, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x4a69, 0x6b4d, 0x6b4d, 0x6b6d, 0x4a69, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x5acb, 0x6b4d, 0x6b4d, 0x632c, 0x39c7, 0x2945, 0x5aeb, 0x6b4d, 0x6b4d, 0x5aeb, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3186, 0x6b4d, 0x6b4d, 0x6b4d, 0x528a, 0x18c3, 0x5aeb, 0x6b4d, 0x6b4d, 0x6b4d, 0x52aa, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18e3, 0x632c, 0x6b6d, 0x5aeb, 0x2965, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x5acb, 0x6b4d, 0x6b4d, 0x4a49, 0x0000, 0x0000, 0x0000, 0x0841, 0x5aeb, 0x6b4d, 0x632c, 0x39e7, 0x18e3, 0x52aa, 0x6b4d, 0x6b4d, 0x5aeb, 0x18c3, 0x0000, 0x0000, 0x0000, 0x4a49, 0x632c, 0x6b4d, 0x6b2d, 0x4207, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18c3, 0x52aa, 0x6b4d, 0x6b4d, 0x630c, 0x2965, 0x5aeb, 0x632c, 0x6b4d, 0x5aeb, 0x18e3, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x632c, 0x6b6d, 0x6b4d, 0x528a, 0x18c3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x4a69, 0x6b4d, 0x6b4d, 0x4208, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39c7, 0x632c, 0x6b4d, 0x6b4d, 0x6b6d, 0x4a69, 0x18e3, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +}; + +static const uint16_t nxplogo[] PROGMEM = { +0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xcce1, 0xdd41, 0xdd41, 0xdd41, 0xdd41, 0xdd41, 0xdd41, 0xdd41, 0xd521, 0x5200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8b84, 0x83c7, 0x83c7, 0x83c7, 0x83c7, 0x83c7, 0x83c7, 0x83c7, 0x83e9, 0x8519, 0x74b7, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2188, 0x7d19, 0x7cf5, 0x7466, 0x7467, 0x7467, 0x7467, 0x7467, 0x7467, 0x7467, 0x7467, 0xb5e4, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe23, 0xbe03, 0xb5c3, 0xa523, 0x7c22, 0x52c1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xdd41, 0x3960, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbc81, 0x9c47, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x5330, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x7cb7, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xa5a6, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x52c1, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x28e0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xd543, 0x9407, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x855a, 0x2167, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x42ce, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x84c7, 0xc664, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xc664, 0x73e1, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xbca1, 0x0840, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xb4a6, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x7475, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1926, 0x8539, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xb605, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xc664, 0x5b01, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xa3e1, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xe582, 0x9427, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x3a6c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6c34, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x9546, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xbe03, 0x0040, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0x8b40, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xcd04, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8519, 0x10c4, 0x0000, 0x0000, 0x0000, 0x322b, 0x8d7a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7cc7, 0xc644, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x5b01, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x72c0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xe582, 0xa467, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x5bb2, 0x0000, 0x0000, 0x0883, 0x7cf8, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xada5, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x8442, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe561, 0x5200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xdd63, 0x9427, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7a, 0x31ea, 0x0000, 0x5371, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x8ce7, 0xc664, 0xce84, 0xce84, 0xce84, 0x8c82, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x52a0, 0x5ae1, 0x73c1, 0xad63, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xa543, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd521, 0x3140, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xb4a6, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x7496, 0x2188, 0x8d5a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0xbe24, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0xad63, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5a3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xcce1, 0x20a0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x9c47, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8519, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x9546, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x73c1, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xbc81, 0x1040, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xcd04, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x84c7, 0xc664, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6341, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xdd41, 0xe582, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0xa401, 0x0000, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xac86, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0xadc5, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6341, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x7ae0, 0xe582, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x8320, 0x0000, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xdd63, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x8d06, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7c02, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0000, 0x9380, 0xe582, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x6a80, 0x0000, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xbce8, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0xbe24, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xad83, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0820, 0xac21, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe561, 0x51e0, 0x0000, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd548, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d77, 0xce83, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x8422, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xada3, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x1060, 0xc4a1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd521, 0x3120, 0xbca1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe5a2, 0xa489, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0xada5, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xc644, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc643, 0xc664, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x94e2, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x1880, 0xd501, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xc4c1, 0xc4a1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xc505, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7cc7, 0xc644, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x73a1, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x3940, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x9427, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x9526, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xc664, 0x39e0, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x6240, 0xe582, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xb4a6, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0xb605, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0x94c2, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7b00, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd543, 0x9407, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d5a, 0x5bb2, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x8ce7, 0xc684, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xbe23, 0x2980, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x93a0, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0xa447, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x5b92, 0x0000, 0x7cb7, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0xa586, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xb5e3, 0x3a00, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xac21, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xc4e5, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x7cf8, 0x0041, 0x0000, 0x322b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x84c7, 0xc644, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xce84, 0xc664, 0xb5c3, 0x8442, 0x0860, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18a0, 0xc4c1, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe582, 0x9427, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x3a6c, 0x0000, 0x0000, 0x0000, 0x63f3, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x9526, 0xce84, 0xce84, 0xce84, 0x8462, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4a60, 0x4220, 0x10a0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3100, 0xd521, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xe5a2, 0xac86, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x8d7b, 0x6c34, 0x0000, 0x0000, 0x0000, 0x0000, 0x1926, 0x8539, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xb605, 0xce84, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3960, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd544, 0x9407, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x855a, 0x2167, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x428d, 0x8d7b, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x84c7, 0xc664, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5a20, 0xe581, 0xeda2, 0xeda2, 0xe582, 0x9c27, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x8d7b, 0x4aee, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0041, 0x74b7, 0x8d7b, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xa586, 0xce84, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8300, 0xeda2, 0xeda2, 0xc4e5, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d7b, 0x7cd7, 0x0862, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2167, 0x855a, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0xbe24, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0xdd41, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xeda2, 0xd501, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9bc0, 0xdd63, 0x9427, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c07, 0x8c2a, 0x8d7b, 0x8d5a, 0x29c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5b92, 0x8d7b, 0x8537, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x7ca7, 0x9527, 0x7c02, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +0x0000, 0x8b60, 0x93a0, 0x93a0, 0x93a0, 0x93a0, 0x93a0, 0x93a0, 0x93a0, 0x8340, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x6ac3, 0x5a84, 0x5a84, 0x5a84, 0x5a84, 0x5a84, 0x5a84, 0x5a84, 0x5aa6, 0x5b71, 0x4b0f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5350, 0x534e, 0x4ae4, 0x4ae4, 0x4ae4, 0x4ae4, 0x4ae4, 0x4ae4, 0x4ae4, 0x4ae4, 0x3a01, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 +};