From 9685fa074b135145114d4e0ccf83a74c6f83bb44 Mon Sep 17 00:00:00 2001 From: jean-marcharvengt Date: Tue, 12 Oct 2021 21:28:12 +0200 Subject: [PATCH] add initial psram support and 8086 emulator for PICO --- MCUME_pico/CMakeLists.txt | 26 + MCUME_pico/config/iopins.h | 8 + MCUME_pico/config/platform_config.h | 5 +- MCUME_pico/pico8086/AudioPlaySystem.cpp | 176 ++ MCUME_pico/pico8086/AudioPlaySystem.h | 26 + MCUME_pico/pico8086/cpu.cpp | 2267 ++++++++++++++ MCUME_pico/pico8086/disk.cpp | 257 ++ MCUME_pico/pico8086/emu.h | 159 + MCUME_pico/pico8086/emuapi.cpp | 1274 ++++++++ MCUME_pico/pico8086/emuapi.h | 147 + MCUME_pico/pico8086/font.h | 264 ++ MCUME_pico/pico8086/i8253.cpp | 119 + MCUME_pico/pico8086/i8259.cpp | 83 + MCUME_pico/pico8086/keyboard_osd.h | 20 + MCUME_pico/pico8086/network.cpp | 146 + MCUME_pico/pico8086/pc.cpp | 664 ++++ MCUME_pico/pico8086/pc.h | 5 + MCUME_pico/pico8086/pico8086.cpp | 178 ++ MCUME_pico/pico8086/ports.cpp | 98 + MCUME_pico/pico8086/ps2.h | 89 + MCUME_pico/pico8086/rom.h | 3749 +++++++++++++++++++++++ MCUME_pico/psram/psram_t.cpp | 269 ++ MCUME_pico/psram/psram_t.h | 53 + MCUME_pico/testpsram/emuapi.cpp | 957 ++++++ MCUME_pico/testpsram/emuapi.h | 90 + MCUME_pico/testpsram/testpsram.cpp | 126 + 26 files changed, 11253 insertions(+), 2 deletions(-) create mode 100644 MCUME_pico/pico8086/AudioPlaySystem.cpp create mode 100644 MCUME_pico/pico8086/AudioPlaySystem.h create mode 100755 MCUME_pico/pico8086/cpu.cpp create mode 100644 MCUME_pico/pico8086/disk.cpp create mode 100644 MCUME_pico/pico8086/emu.h create mode 100644 MCUME_pico/pico8086/emuapi.cpp create mode 100644 MCUME_pico/pico8086/emuapi.h create mode 100644 MCUME_pico/pico8086/font.h create mode 100644 MCUME_pico/pico8086/i8253.cpp create mode 100755 MCUME_pico/pico8086/i8259.cpp create mode 100644 MCUME_pico/pico8086/keyboard_osd.h create mode 100755 MCUME_pico/pico8086/network.cpp create mode 100644 MCUME_pico/pico8086/pc.cpp create mode 100644 MCUME_pico/pico8086/pc.h create mode 100644 MCUME_pico/pico8086/pico8086.cpp create mode 100755 MCUME_pico/pico8086/ports.cpp create mode 100755 MCUME_pico/pico8086/ps2.h create mode 100644 MCUME_pico/pico8086/rom.h create mode 100644 MCUME_pico/psram/psram_t.cpp create mode 100644 MCUME_pico/psram/psram_t.h create mode 100644 MCUME_pico/testpsram/emuapi.cpp create mode 100644 MCUME_pico/testpsram/emuapi.h create mode 100644 MCUME_pico/testpsram/testpsram.cpp diff --git a/MCUME_pico/CMakeLists.txt b/MCUME_pico/CMakeLists.txt index c543c80..6c5ed42 100644 --- a/MCUME_pico/CMakeLists.txt +++ b/MCUME_pico/CMakeLists.txt @@ -19,6 +19,7 @@ add_subdirectory(FatFs_SPI build) include_directories(config) include_directories(vga_t4) include_directories(tft_t) +include_directories(psram) set(PICO81_SOURCES @@ -193,6 +194,19 @@ set(PICONOFRENDO_SOURCES piconofrendo/AudioPlaySystem.cpp ) +set(PICO8086_SOURCES + pico8086/cpu.cpp + pico8086/disk.cpp + pico8086/network.cpp + pico8086/ports.cpp + pico8086/i8253.cpp + pico8086/i8259.cpp + pico8086/pc.cpp + pico8086/emuapi.cpp + pico8086/pico8086.cpp + pico8086/AudioPlaySystem.cpp + ) + set(PICOSND_SOURCES # picosnd/LibFC14/Dump.cpp # picosnd/LibFC14/FC_Data.cpp @@ -220,6 +234,10 @@ set(VGA_T4_SOURCES vga_t4/scanvideo.c ) +set(PSRAM_SOURCES + psram/psram_t.cpp + ) + set(TFT_T_SOURCES tft_t/tft_t_dma.cpp ) @@ -242,6 +260,11 @@ set(TESTTFT_SOURCES testtft/emuapi.cpp ) +set(TESTPSRAM_SOURCES + testpsram/testpsram.cpp + testpsram/emuapi.cpp + ) + #add_compile_definitions(OVERRULE_WIDTH=320 OVERRULE_HEIGHT=192) add_executable(mcume # ${GFXENGINE_SOURCES} @@ -249,6 +272,7 @@ add_executable(mcume # ${PICO81_SOURCES} # ${PICO800_SOURCES} # ${PICO5200_SOURCES} +# ${PICO8086_SOURCES} # ${PICOCOLEM_SOURCES} # ${PICOO2EM_SOURCES} # ${PICOVCS_SOURCES} @@ -258,6 +282,8 @@ add_executable(mcume # ${TESTIO_SOURCES} # ${TESTVGA_SOURCES} # ${TESTTFT_SOURCES} +# ${TESTPSRAM_SOURCES} + ${PSRAM_SOURCES} ${VGA_T4_SOURCES} ${TFT_T_SOURCES} ) diff --git a/MCUME_pico/config/iopins.h b/MCUME_pico/config/iopins.h index d3cfc5f..5201374 100644 --- a/MCUME_pico/config/iopins.h +++ b/MCUME_pico/config/iopins.h @@ -93,6 +93,14 @@ #define SD_CS 13 #define SD_DETECT 255 // 22 +// PSRAM (exclusive with TFT) +#define PSRAM_SPIREG spi0 +#define PSRAM_SCLK 18 +#define PSRAM_MOSI 19 +#define PSRAM_MISO 16 // DC +#define PSRAM_CS 17 + + #ifdef PICOMPUTER // Keyboard matrix //Cols (out) diff --git a/MCUME_pico/config/platform_config.h b/MCUME_pico/config/platform_config.h index 854e461..a99b91b 100644 --- a/MCUME_pico/config/platform_config.h +++ b/MCUME_pico/config/platform_config.h @@ -37,10 +37,11 @@ #endif #ifdef MCUME_REV2 +//#define HAS_PSRAM 1 #define USE_VGA 1 //#define ILI9341 1 -#define ST7789 1 -#define ST7789_POL 1 +//#define ST7789 1 +//#define ST7789_POL 1 #define INVX 1 #define HAS_SND 1 #endif diff --git a/MCUME_pico/pico8086/AudioPlaySystem.cpp b/MCUME_pico/pico8086/AudioPlaySystem.cpp new file mode 100644 index 0000000..639ad5f --- /dev/null +++ b/MCUME_pico/pico8086/AudioPlaySystem.cpp @@ -0,0 +1,176 @@ +#include "emuapi.h" + +#ifdef HAS_SND + +#include "AudioPlaySystem.h" + +#define SAMPLERATE AUDIO_SAMPLE_RATE_EXACT +#define CLOCKFREQ 985248 + +#ifndef CUSTOM_SND +static const short square[]={ +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +32767,32767,32767,32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767, +}; + +const short noise[] { +-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767, +-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,-32767,32767,-32767, +-32767,-32767,32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,32767,-32767, +-32767,-32767,32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,32767,-32767,-32767,32767,32767,-32767, +-32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,32767,-32767,-32767,32767,32767,-32767, +-32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,32767,-32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,32767,-32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,32767,32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,32767,32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,-32767,-32767,32767,32767,32767,-32767,-32767, +32767,-32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,-32767,32767,32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,-32767,32767,-32767,32767,32767,32767,-32767,-32767, +32767,32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,-32767,32767,32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,-32767,32767,32767,-32767,32767,-32767,32767,-32767,-32767, +32767,32767,-32767,-32767,-32767,32767,-32767,-32767,-32767,-32767,32767,32767,32767,32767,32767,-32767, +32767,-32767,32767,-32767,-32767,32767,32767,32767,32767,32767,-32767,32767,-32767,32767,-32767,-32767, +}; + +#define NOISEBSIZE 0x100 + +typedef struct +{ + unsigned int spos; + unsigned int sinc; + unsigned int vol; +} Channel; + +static Channel chan[6] = { + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0} }; + +#endif + +volatile bool playing = false; + + +static void snd_Reset(void) +{ +#ifndef CUSTOM_SND + chan[0].vol = 0; + chan[1].vol = 0; + chan[2].vol = 0; + chan[3].vol = 0; + chan[4].vol = 0; + chan[5].vol = 0; + chan[0].sinc = 0; + chan[1].sinc = 0; + chan[2].sinc = 0; + chan[3].sinc = 0; + chan[4].sinc = 0; + chan[5].sinc = 0; +#endif +} + + +#ifdef CUSTOM_SND +//extern "C" { +void SND_Process(void *sndbuffer, int sndn); +//} +#endif + +#include +void AudioPlaySystem::snd_Mixer(short * stream, int len ) +{ + if (playing) + { +#ifdef CUSTOM_SND + //printf("s\n"); + SND_Process((void*)stream, len); +#else + int i; + long s; + len = len >> 1; + short v0=chan[0].vol; + short v1=chan[1].vol; + short v2=chan[2].vol; + short v3=chan[3].vol; + short v4=chan[4].vol; + short v5=chan[5].vol; + for (i=0;i>8)&0x3f])>>11); + s+=((v1*square[(chan[1].spos>>8)&0x3f])>>11); + s+=((v2*square[(chan[2].spos>>8)&0x3f])>>11); + s+=((v3*noise[(chan[3].spos>>8)&(NOISEBSIZE-1)])>>11); + s+=((v4*noise[(chan[4].spos>>8)&(NOISEBSIZE-1)])>>11); + s+=((v5*noise[(chan[5].spos>>8)&(NOISEBSIZE-1)])>>11); + *stream++ = (short)(s); + *stream++ = (short)(s); + chan[0].spos += chan[0].sinc; + chan[1].spos += chan[1].sinc; + chan[2].spos += chan[2].sinc; + chan[3].spos += chan[3].sinc; + chan[4].spos += chan[4].sinc; + chan[5].spos += chan[5].sinc; + } +#endif + } +} + +void AudioPlaySystem::begin(void) +{ + this->reset(); +} + +void AudioPlaySystem::start(void) +{ + playing = true; +} + +void AudioPlaySystem::setSampleParameters(float clockfreq, float samplerate) { +} + +void AudioPlaySystem::reset(void) +{ + snd_Reset(); +} + +void AudioPlaySystem::stop(void) +{ + playing = false; +} + +bool AudioPlaySystem::isPlaying(void) +{ + return playing; +} + + + +void AudioPlaySystem::sound(int C, int F, int V) { +#ifndef CUSTOM_SND + if (C < 6) { + chan[C].vol = V; + chan[C].sinc = F>>1; + } +#endif +} + +void AudioPlaySystem::step(void) { +} +#endif diff --git a/MCUME_pico/pico8086/AudioPlaySystem.h b/MCUME_pico/pico8086/AudioPlaySystem.h new file mode 100644 index 0000000..5d2efc0 --- /dev/null +++ b/MCUME_pico/pico8086/AudioPlaySystem.h @@ -0,0 +1,26 @@ +#ifndef audioplaysystem_h_ +#define audioplaysystem_h_ + +#ifdef HAS_SND + +#include "platform_config.h" + +class AudioPlaySystem +{ +public: + AudioPlaySystem(void) { }; + void begin(void); + void setSampleParameters(float clockfreq, float samplerate); + void reset(void); + void start(void); + void stop(void); + bool isPlaying(void); + void sound(int C, int F, int V); + void buzz(int size, int val); + void step(void); + static void snd_Mixer(short * stream, int len ); +}; + +#endif + +#endif diff --git a/MCUME_pico/pico8086/cpu.cpp b/MCUME_pico/pico8086/cpu.cpp new file mode 100755 index 0000000..477478b --- /dev/null +++ b/MCUME_pico/pico8086/cpu.cpp @@ -0,0 +1,2267 @@ +#include +#include +#include "emu.h" +#include "rom.h" + + + +extern void portout(uint16_t portnum, uint16_t value); +extern uint16_t portin(uint16_t portnum); + +extern void readdisk(uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount); +extern void insertdisk(); + +extern void doirq(uint8_t irqnum); +extern uint8_t nextintr(); +extern struct structpic { + uint8_t imr; //mask register + uint8_t irr; //request register + uint8_t isr; //service register + uint8_t icwstep; //used during initialization to keep track of which ICW we're at + uint8_t icw[5]; + uint8_t intoffset; //interrupt vector offset + uint8_t priority; //which IRQ has highest priority + uint8_t autoeoi; //automatic EOI mode + uint8_t readmode; //remember what to return on read register from OCW3 + uint8_t enabled; +} i8259; + +extern uint8_t curkey; +void intcall86(uint8_t intnum); + +uint64_t curtimer, lasttimer, timerfreq; + +char *biosfile = NULL; +uint8_t byteregtable[8] = { regal, regcl, regdl, regbl, regah, regch, regdh, regbh }; + +uint8_t parity[0x100]; + +_bytewordregs_ regs; + +uint16_t segregs[6]; +uint8_t opcode, segoverride, reptype, bootdrive, hdcount = 0; +uint16_t savecs, saveip, ip, useseg, oldsp; +uint8_t tempcf, oldcf, cf, pf, af, zf, sf, tf, ifl, df, of, nt, iopriv, mode, reg, rm, msw = 0; +uint16_t oper1, oper2, res16, disp16, temp16, dummy, stacksize, frametemp; +uint8_t oper1b, oper2b, res8, disp8, temp8, nestlev, addrbyte; +uint16_t cr0 = 0, cr1 = 0, cr2 = 0, cr3 = 0; +uint32_t ldtr = 0, gdtr = 0, gdtlimit = 0, idtr = 0, idtlimit = 0; +uint32_t temp1, temp2, temp3, temp4, temp5, temp32, tempaddr32, ea; +int32_t result, speed = 0; +uint32_t totalexec; +uint32_t ips[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +uint16_t *tempwordptr; + +uint8_t vidmode, cgabg, blankattr, vidgfxmode, vidcolor; +uint16_t cursx, cursy, cols, rows, vgapage, cursorposition, cursorvisible; +uint8_t updatedscreen, port3da, port6, portout16; +//uint16_t VGA_SC[0xFF], VGA_CRTC[0xFF], VGA_ATTR[0xFF], VGA_GC[0xFF]; +uint32_t videobase, textbase, x, y; + +uint8_t debugmode, showcsip, verbose, mouseemu; + + + +extern void write_loram(int address, uint8_t val); +extern uint8_t read_loram(int address); +extern void write_hiram(int address, uint8_t val); +extern uint8_t read_hiram(int address); + +void write86(uint32_t addr32, uint8_t value) { + if (addr32 < NATIVE_RAM) { + write_loram(addr32, value); + return; + } + else if (addr32 < RAM_SIZE) { + write_hiram(addr32, value); + return; + } + else if ((addr32 >= 0xB8000) && (addr32 < 0xC0000)) { + VRAM_write(addr32 - 0xB8000UL, value); + } +} + +#define writew86(addr32,value) {write86((addr32),(uint8_t)(value));write86((addr32)+1,(uint8_t)((uint16_t)(value)>>8));} + +uint8_t read86(uint32_t addr32) { + if (addr32 < NATIVE_RAM) { + switch (addr32) { //some hardcoded values for the BIOS data area + case 0x410: //0040:0010 is the equipment word +#ifdef VGA + return (0x41); //video type (0x41 is VGA/EGA, 0x61 is CGA, 0x31 = MDA) +#else + return (0x61); //video type (0x41 is VGA/EGA, 0x61 is CGA, 0x31 = MDA) +#endif + case 0x475: //hard drive count + return (hdcount); + default: + return read_loram(addr32); + } + } + else if (addr32 < RAM_SIZE) { + return read_hiram(addr32); + } + else if ((addr32 >= 0xB8000) && (addr32 < 0xC0000)) { + addr32 -= 0xB8000UL; + return VRAM_read(addr32); + } + else if (addr32 >= 0xFE000UL) { + addr32 -= 0xFE000UL; + return ROM_READ(BIOS, addr32); //BIOS[addr32]; + } + else if ((addr32 >= 0xD0000) && (addr32 < 0xD0640)) { + return net_read_ram(addr32 - 0xD0000); + } + else if ((addr32 >= 0xE0000) && (addr32 < 0xE0006)) { + return net_mac[addr32 - 0xE0000]; + } +#ifdef INCLUDE_ROM_BASIC + else if ((addr32 >= 0xF6000UL) && (addr32 < 0xFA000UL)) { + addr32 -= 0xF6000UL; + return ROM_READ(BASICL, addr32); //BASICL[addr32]; + } else if ((addr32 >= 0xFA000UL) && (addr32 < 0xFE000UL)) { + addr32 -= 0xFA000UL; + return ROM_READ(BASICH, addr32); //BASICH[addr32]; + } +#endif + else return 0; +} + + + +#define readw86(addr32) ((uint16_t)read86((addr32))|((uint16_t)read86((addr32)+1)<<8)) + +//inline void flag_szp8(uint8_t value) { +#define flag_szp8(value) {\ + if (!(value)) zf = 1; else zf = 0;\ + if ((value) & 0x80) sf = 1; else sf = 0;\ + pf = parity[value];\ +} + +//inline void flag_szp16(uint16_t value) { +#define flag_szp16(value) {\ + if (!(value)) zf = 1; else zf = 0;\ + if (value & 0x8000) sf = 1; else sf = 0;\ + pf = parity[(uint8_t)value];\ +} + +//inline void flag_log8(uint8_t value) { +#define flag_log8(value) {\ + flag_szp8(value);\ + cf = 0; of = 0;\ +} + +//inline void flag_log16(uint16_t value) { +#define flag_log16(value) {\ + flag_szp16(value);\ + cf = 0; of = 0;\ +} + +//inline void flag_adc8(uint8_t v1, uint8_t v2, uint8_t v3) { //v1 = destination operand, v2 = source operand, v3 = carry flag +#define flag_adc8(v1, v2, v3) {\ + uint16_t dst;\ + dst = (uint16_t)(v1) + (uint16_t)(v2) + (uint16_t)(v3);\ + flag_szp8((uint8_t)dst);\ + if (((dst ^ (v1)) & (dst ^ (v2)) & 0x80) == 0x80) of = 1; else of = 0;\ + if (dst & 0xFF00) cf = 1; else cf = 0;\ + if ((((v1) ^ (v2) ^ dst) & 0x10) == 0x10) af = 1; else af = 0;\ +} + +//inline void flag_adc16(uint16_t v1, uint16_t v2, uint16_t v3) { //v1 = destination operand, v2 = source operand, v3 = carry flag +#define flag_adc16(v1, v2, v3) {\ + uint32_t dst;\ + dst = (uint32_t)(v1) + (uint32_t)(v2) + (uint32_t)(v3);\ + flag_szp16((uint16_t)dst);\ + if ((((dst ^ (v1)) & (dst ^ (v2))) & 0x8000) == 0x8000) of = 1; else of = 0;\ + if (dst & 0xFFFF0000UL) cf = 1; else cf = 0;\ + if ((((v1) ^ (v2) ^ dst) & 0x10) == 0x10) af = 1; else af = 0;\ +} + +//inline void flag_add8(uint8_t v1, uint8_t v2) { //v1 = destination operand, v2 = source operand +#define flag_add8(v1, v2) {\ + uint16_t dst;\ + dst = (uint16_t)(v1) + (uint16_t)(v2);\ + flag_szp8((uint8_t)dst);\ + if (dst & 0xFF00) cf = 1; else cf = 0;\ + if (((dst ^ (v1)) & (dst ^ (v2)) & 0x80) == 0x80) of = 1; else of = 0;\ + if ((((v1) ^ (v2) ^ dst) & 0x10) == 0x10) af = 1; else af = 0;\ +} + +//inline void flag_add16(uint16_t v1, uint16_t v2) { //v1 = destination operand, v2 = source operand +#define flag_add16(v1, v2) {\ + uint32_t dst;\ + dst = (uint32_t)(v1) + (uint32_t)(v2);\ + flag_szp16((uint16_t)dst);\ + if (dst & 0xFFFF0000UL) cf = 1; else cf = 0;\ + if (((dst ^ (v1)) & (dst ^ (v2)) & 0x8000) == 0x8000) of = 1; else of = 0;\ + if ((((v1) ^ (v2) ^ dst) & 0x10) == 0x10) af = 1; else af = 0;\ +} + +//inline void flag_sbb8(uint8_t v1, uint8_t v2, uint8_t v3) { //v1 = destination operand, v2 = source operand, v3 = carry flag +#define flag_sbb8(v1, v2, v3) {\ + uint16_t dst;\ + uint16_t newv2;\ + newv2 = (uint16_t)(v2) + (uint16_t)(v3);\ + dst = (uint16_t)(v1) - (uint16_t)newv2;\ + flag_szp8((uint8_t)dst);\ + if (dst & 0xFF00) cf = 1; else cf = 0;\ + if ((dst ^ (v1)) & ((v1) ^ newv2) & 0x80) of = 1; else of = 0;\ + if (((v1) ^ newv2 ^ dst) & 0x10) af = 1; else af = 0;\ +} + +//inline void flag_sbb16(uint16_t v1, uint16_t v2, uint16_t v3) { //v1 = destination operand, v2 = source operand, v3 = carry flag +#define flag_sbb16(v1, v2, v3){\ + uint32_t dst;\ + uint32_t newv2;\ + newv2 = (uint32_t)(v2) + (uint32_t)(v3);\ + dst = (uint32_t)v1 - newv2;\ + flag_szp16((uint16_t)dst);\ + if (dst & 0xFFFF0000UL) cf = 1; else cf = 0;\ + if ((dst ^ (v1)) & (v1 ^ newv2) & 0x8000) of = 1; else of = 0;\ + if (((v1) ^ newv2 ^ dst) & 0x10) af = 1; else af = 0;\ +} + +//inline void flag_sub8(uint8_t v1, uint8_t v2) { //v1 = destination operand, v2 = source operand +#define flag_sub8(v1, v2) {\ + uint16_t dst;\ + dst = (uint16_t)(v1) - (uint16_t)(v2);\ + flag_szp8((uint8_t)dst);\ + if (dst & 0xFF00) cf = 1; else cf = 0;\ + if ((dst ^ (v1)) & ((v1) ^ (v2)) & 0x80) of = 1; else of = 0;\ + if (((v1) ^ (v2) ^ dst) & 0x10) af = 1; else af = 0;\ +} + +//inline void flag_sub16(uint16_t v1, uint16_t v2) { //v1 = destination operand, v2 = source operand +#define flag_sub16(v1, v2) {\ + uint32_t dst;\ + dst = (uint32_t)(v1) - (uint32_t)(v2);\ + flag_szp16((uint16_t)dst);\ + if (dst & 0xFFFF0000UL) cf = 1; else cf = 0;\ + if ((dst ^ (v1)) & ((v1) ^ (v2)) & 0x8000) of = 1; else of = 0;\ + if (((v1) ^ (v2) ^ dst) & 0x10) af = 1; else af = 0;\ +} + +//inline void op_adc8() { +#define op_adc8() {\ + res8 = oper1b + oper2b + cf;\ + flag_adc8(oper1b, oper2b, cf);\ +} + +//inline void op_adc16() { +#define op_adc16() {\ + res16 = oper1 + oper2 + cf;\ + flag_adc16(oper1, oper2, cf);\ +} + +//inline void op_add8() { +#define op_add8() {\ + res8 = oper1b + oper2b;\ + flag_add8(oper1b, oper2b);\ +} + +//inline void op_add16() { +#define op_add16() {\ + res16 = oper1 + oper2;\ + flag_add16(oper1, oper2);\ +} + +//inline void op_and8() { +#define op_and8() {\ + res8 = oper1b & oper2b;\ + flag_log8(res8);\ +} + +//inline void op_and16() { +#define op_and16() {\ + res16 = oper1 & oper2;\ + flag_log16(res16);\ +} + +//inline void op_or8() { +#define op_or8() {\ + res8 = oper1b | oper2b;\ + flag_log8(res8);\ +} + +//inline void op_or16() { +#define op_or16() {\ + res16 = oper1 | oper2;\ + flag_log16(res16);\ +} + +//inline void op_xor8() { +#define op_xor8() {\ + res8 = oper1b ^ oper2b;\ + flag_log8(res8);\ +} + +//inline void op_xor16() { +#define op_xor16() {\ + res16 = oper1 ^ oper2;\ + flag_log16(res16);\ +} + +//inline void op_sub8() { +#define op_sub8() {\ + res8 = oper1b - oper2b;\ + flag_sub8(oper1b, oper2b);\ +} + +//inline void op_sub16() { +#define op_sub16() {\ + res16 = oper1 - oper2;\ + flag_sub16(oper1, oper2);\ +} + +//inline void op_sbb8() { +#define op_sbb8() {\ + res8 = oper1b - (oper2b + cf);\ + flag_sbb8(oper1b, oper2b, cf);\ +} + +//inline void op_sbb16() { +#define op_sbb16() {\ + res16 = oper1 - (oper2 + cf);\ + flag_sbb16(oper1, oper2, cf);\ +} + +//inline void modregrm() { +#define modregrm() {\ + addrbyte = getmem8(segregs[regcs], ip); StepIP(1);\ + mode = addrbyte >> 6;\ + reg = (addrbyte >> 3) & 7;\ + rm = addrbyte & 7;\ + switch (mode) {\ + case 0:\ + if (rm == 6) {\ + disp16 = getmem16(segregs[regcs], ip);\ + StepIP(2);\ + }\ + if (((rm == 2) || (rm == 3)) && !segoverride) useseg = segregs[regss]; break;\ + case 1:\ + disp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1);\ + if (((rm == 2) || (rm == 3) || (rm == 6)) && !segoverride) useseg = segregs[regss]; break;\ + case 2:\ + disp16 = getmem16(segregs[regcs], ip); StepIP(2);\ + if (((rm == 2) || (rm == 3) || (rm == 6)) && !segoverride) useseg = segregs[regss]; break;\ + default:\ + disp8 = 0; disp16 = 0;\ + }\ + if (mode < 3) getea(rm);\ +} + +//inline void getea(uint8_t rmval) { +#define getea(rmval) {\ + uint32_t tempea;\ + tempea = 0;\ + switch (mode) {\ + case 0:\ + switch (rmval) {\ + case 0: tempea = regs.wordregs[regbx] + regs.wordregs[regsi]; break;\ + case 1: tempea = regs.wordregs[regbx] + regs.wordregs[regdi]; break;\ + case 2: tempea = regs.wordregs[regbp] + regs.wordregs[regsi]; break;\ + case 3: tempea = regs.wordregs[regbp] + regs.wordregs[regdi]; break;\ + case 4: tempea = regs.wordregs[regsi]; break;\ + case 5: tempea = regs.wordregs[regdi]; break;\ + case 6: tempea = disp16; break;\ + case 7: tempea = regs.wordregs[regbx]; break;\ + } break;\ + case 1: case 2:\ + switch (rmval) {\ + case 0: tempea = regs.wordregs[regbx] + regs.wordregs[regsi] + disp16; break;\ + case 1: tempea = regs.wordregs[regbx] + regs.wordregs[regdi] + disp16; break;\ + case 2: tempea = regs.wordregs[regbp] + regs.wordregs[regsi] + disp16; break;\ + case 3: tempea = regs.wordregs[regbp] + regs.wordregs[regdi] + disp16; break;\ + case 4: tempea = regs.wordregs[regsi] + disp16; break;\ + case 5: tempea = regs.wordregs[regdi] + disp16; break;\ + case 6: tempea = regs.wordregs[regbp] + disp16; break;\ + case 7: tempea = regs.wordregs[regbx] + disp16; break;\ + } break;\ + }\ + ea = useseg;\ + ea <<= 4;\ + ea += (tempea & 0xFFFF);\ +} + +inline void push(uint16_t pushval) { + putreg16(regsp, getreg16(regsp) - 2); + //printf(" %04X:%04X PUSH\n", segregs[regss], getreg16(regsp)); + putmem16(segregs[regss], getreg16(regsp), pushval); +} + +inline uint16_t pop() { + uint16_t tempval; + //printf(" %04X:%04X POP\n", segregs[regss], getreg16(regsp)); + tempval = getmem16(segregs[regss], getreg16(regsp)); + putreg16(regsp, getreg16(regsp) + 2); + return (tempval); +} + +void reset86() { + uint16_t i, cnt, bitcount; + segregs[regcs] = 0xFFFF; + ip = 0x0000; + segregs[regss] = 0x0000; + regs.wordregs[regsp] = 0xFFFE; + + //generate parity lookup table + for (i = 0; i < 256; i++) { + bitcount = 0; + for (cnt = 0; cnt < 8; cnt++) + bitcount += ((i >> cnt) & 1); + if (bitcount & 1) parity[i] = 0; else parity[i] = 1; + } +} + +/*inline uint16_t readrm16(uint8_t rmval) { + if (mode < 3) { + getea(rmval); + return (read86(ea) | ((uint16_t)read86(ea + 1) << 8)); + } else { + return (getreg16(rmval)); + } +}*/ + +#define readrm16(rmval) ( (mode < 3) ? (read86(ea) | ((uint16_t)read86(ea + 1) << 8)) : (getreg16(rmval)) ) + +/*inline uint8_t readrm8(uint8_t rmval) { + if (mode < 3) { + //getea(rmval); + return (read86(ea)); + } else { + return (getreg8(rmval)); + } +}*/ + +#define readrm8(rmval) ( (mode < 3) ? read86(ea) : getreg8(rmval) ) + +inline void writerm16(uint8_t rmval, uint16_t value) { +//#define writerm16(rmval, value) { + if (mode < 3) {\ + /*getea(rmval);*/\ + write86(ea, value & 0xFF);\ + write86(ea + 1, value >> 8);\ + } else {\ + putreg16(rmval, value);\ + }\ +} + +inline void writerm8(uint8_t rmval, uint8_t value) { +//#define writerm8(rmval, value) { + if (mode < 3) {\ + /*getea(rmval);*/\ + write86(ea, value);\ + } else {\ + putreg8(rmval, value);\ + }\ +} + +inline uint8_t op_grp2_8(uint8_t cnt) { + uint16_t s, oldcf, msb; + uint8_t shift; + s = oper1b; + oldcf = cf; + switch (reg) { + case 0: //ROL r/m8 + for (shift = 1; shift <= cnt; shift++) { + if (s & 0x80) cf = 1; else cf = 0; + s = s << 1; + s = s | cf; + } + if (cnt == 1) of = cf ^ ((s >> 7) & 1); + break; + + case 1: //ROR r/m8 + for (shift = 1; shift <= cnt; shift++) { + cf = s & 1; + s = (s >> 1) | (cf << 7); + } + if (cnt == 1) of = (s >> 7) ^ ((s >> 6) & 1); + break; + + case 2: //RCL r/m8 + for (shift = 1; shift <= cnt; shift++) { + oldcf = cf; + if (s & 0x80) cf = 1; else cf = 0; + s = s << 1; + s = s | oldcf; + } + if (cnt == 1) of = cf ^ ((s >> 7) & 1); + break; + + case 3: //RCR r/m8 + for (shift = 1; shift <= cnt; shift++) { + oldcf = cf; + cf = s & 1; + s = (s >> 1) | (oldcf << 7); + } + if (cnt == 1) of = (s >> 7) ^ ((s >> 6) & 1); + break; + + case 4: case 6: //SHL r/m8 + for (shift = 1; shift <= cnt; shift++) { + if (s & 0x80) cf = 1; else cf = 0; + s = (s << 1) & 0xFF; + } + if ((cnt == 1) && (cf == (s >> 7))) of = 0; else of = 1; + flag_szp8((uint8_t)s); break; + + case 5: //SHR r/m8 + if ((cnt == 1) && (s & 0x80)) of = 1; else of = 0; + for (shift = 1; shift <= cnt; shift++) { + cf = s & 1; + s = s >> 1; + } + flag_szp8((uint8_t)s); break; + + case 7: //SAR r/m8 + for (shift = 1; shift <= cnt; shift++) { + msb = s & 0x80; + cf = s & 1; + s = (s >> 1) | msb; + } + of = 0; + flag_szp8((uint8_t)s); break; + + } + return (s & 0xFF); +} + +inline uint16_t op_grp2_16(uint8_t cnt) { + uint32_t s, oldcf, msb; + uint8_t shift; + s = oper1; + oldcf = cf; + switch (reg) { + case 0: //ROL r/m8 + for (shift = 1; shift <= cnt; shift++) { + if (s & 0x8000) cf = 1; else cf = 0; + s = s << 1; + s = s | cf; + } + if (cnt == 1) of = cf ^ ((s >> 15) & 1); + break; + + case 1: //ROR r/m8 + for (shift = 1; shift <= cnt; shift++) { + cf = s & 1; + s = (s >> 1) | (cf << 15); + } + if (cnt == 1) of = (s >> 15) ^ ((s >> 14) & 1); + break; + + case 2: //RCL r/m8 + for (shift = 1; shift <= cnt; shift++) { + oldcf = cf; + if (s & 0x8000) cf = 1; else cf = 0; + s = s << 1; + s = s | oldcf; + } + if (cnt == 1) of = cf ^ ((s >> 15) & 1); + break; + + case 3: //RCR r/m8 + for (shift = 1; shift <= cnt; shift++) { + oldcf = cf; + cf = s & 1; + s = (s >> 1) | (oldcf << 15); + } + if (cnt == 1) of = (s >> 15) ^ ((s >> 14) & 1); + break; + + case 4: case 6: //SHL r/m8 + for (shift = 1; shift <= cnt; shift++) { + if (s & 0x8000) cf = 1; else cf = 0; + s = (uint16_t)(s << 1); + } + if ((cnt == 1) && (cf == (s >> 15))) of = 0; else of = 1; + flag_szp16((uint16_t)s); break; + + case 5: //SHR r/m8 + if ((cnt == 1) && (s & 0x8000)) of = 1; else of = 0; + for (shift = 1; shift <= cnt; shift++) { + cf = s & 1; + s = s >> 1; + } + flag_szp16((uint16_t)s); break; + + case 7: //SAR r/m8 + for (shift = 1; shift <= cnt; shift++) { + msb = s & 0x8000; + cf = s & 1; + s = (s >> 1) | msb; + } + of = 0; + flag_szp16((uint16_t)s); break; + + } + return ((uint16_t)s); +} + +inline void op_div8(uint16_t valdiv, uint8_t divisor) { + if (divisor == 0) { + intcall86(0); + return; + } + if ((valdiv / (uint16_t)divisor) > 0xFF) { + intcall86(0); + return; + } + regs.byteregs[regah] = valdiv % (uint16_t)divisor; + regs.byteregs[regal] = valdiv / (uint16_t)divisor; +} + +inline void op_idiv8(uint16_t valdiv, uint8_t divisor) { + uint16_t s1, s2, d1, d2, sign; + if (divisor == 0) { + intcall86(0); + return; + } + s1 = valdiv; + s2 = divisor; + sign = (((s1 ^ s2) & 0x8000) != 0); + s1 = (s1 < 0x8000) ? s1 : (uint16_t)(~s1 + 1); + s2 = (s2 < 0x8000) ? s2 : (uint16_t)(~s2 + 1); + d1 = s1 / s2; + d2 = s1 % s2; + if (d1 & 0xFF00) { + intcall86(0); + return; + } + if (sign) { + d1 = (~d1 + 1) & 0xff; + d2 = (~d2 + 1) & 0xff; + } + regs.byteregs[regah] = d2; + regs.byteregs[regal] = d1; +} + +inline void op_grp3_8() { + oper1 = signext(oper1b); oper2 = signext(oper2b); + switch (reg) { + case 0: case 1: //TEST + flag_log8(oper1b & getmem8(segregs[regcs], ip)); StepIP(1); + break; + + case 2: //NOT + res8 = ~oper1b; break; + + case 3: //NEG + res8 = (~oper1b) + 1; + flag_sub8(0, oper1b); + if (res8 == 0) cf = 0; else cf = 1; + break; + + case 4: //MUL + temp1 = (uint32_t)oper1b * (uint32_t)regs.byteregs[regal]; + putreg16(regax, (uint16_t)temp1); + flag_szp8((uint8_t)temp1); + if (regs.byteregs[regah]) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + + case 5: //IMUL + oper1 = signext(oper1b); + temp1 = signext(regs.byteregs[regal]); + temp2 = oper1; + if ((temp1 & 0x80) == 0x80) temp1 = temp1 | 0xFFFFFF00UL; + if ((temp2 & 0x80) == 0x80) temp2 = temp2 | 0xFFFFFF00UL; + temp3 = (uint16_t)(temp1 * temp2); + putreg16(regax, (uint16_t)temp3); + if (regs.byteregs[regah]) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + + case 6: //DIV + op_div8(getreg16(regax), oper1b); + break; + + case 7: //IDIV + op_idiv8(getreg16(regax), oper1b); + break; + } +} + +void op_div16(uint32_t valdiv, uint16_t divisor) { + if (divisor == 0) { + intcall86(0); + return; + } + if ((valdiv / (uint32_t)divisor) > 0xFFFF) { + intcall86(0); + return; + } + putreg16(regdx, valdiv % (uint32_t)divisor); + putreg16(regax, valdiv / (uint32_t)divisor); +} + +void op_idiv16(uint32_t valdiv, uint16_t divisor) { + uint32_t d1, d2, s1, s2, sign; + if (divisor == 0) { + intcall86(0); + return; + } + s1 = valdiv; + s2 = divisor; + s2 = (s2 & 0x8000) ? (s2 | 0xffff0000UL) : s2; + sign = (((s1 ^ s2) & 0x80000000UL) != 0); + s1 = (s1 < 0x80000000UL) ? s1 : ((~s1 + 1) & 0xffffffffUL); + s2 = (s2 < 0x80000000UL) ? s2 : ((~s2 + 1) & 0xffffffffUL); + d1 = s1 / s2; + d2 = s1 % s2; + if (d1 & 0xFFFF0000UL) { + intcall86(0); + return; + } + if (sign) { + d1 = (uint16_t)(~d1 + 1); + d2 = (uint16_t)(~d2 + 1); + } + putreg16(regax, d1); + putreg16(regdx, d2); +} + +inline void op_grp3_16() { + switch (reg) { + case 0: case 1: //TEST + flag_log16(oper1 & getmem16(segregs[regcs], ip)); StepIP(2); break; + case 2: //NOT + res16 = ~oper1; break; + case 3: //NEG + res16 = (~oper1) + 1; + flag_sub16(0, oper1); + if (res16) cf = 1; else cf = 0; + break; + case 4: //MUL + temp1 = (uint32_t)oper1 * (uint32_t)getreg16(regax); + putreg16(regax, (uint16_t)temp1); + putreg16(regdx, temp1 >> 16); + flag_szp16((uint16_t)temp1); + if (getreg16(regdx)) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + case 5: //IMUL + temp1 = getreg16(regax); + temp2 = oper1; + if (temp1 & 0x8000) temp1 |= 0xFFFF0000UL; + if (temp2 & 0x8000) temp2 |= 0xFFFF0000UL; + temp3 = temp1 * temp2; + putreg16(regax, (uint16_t)temp3); //into register ax + putreg16(regdx, temp3 >> 16); //into register dx + if (getreg16(regdx)) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + case 6: //DIV + op_div16(((uint32_t)getreg16(regdx) << 16) + (uint32_t)getreg16(regax), oper1); break; + case 7: //DIV + op_idiv16(((uint32_t)getreg16(regdx) << 16) + (uint32_t)getreg16(regax), oper1); break; + } +} + +//inline void op_grp5() { +#define op_grp5() {\ + switch (reg) {\ + case 0: /*INC Ev*/\ + oper2 = 1;\ + tempcf = cf;\ + op_add16();\ + cf = tempcf;\ + writerm16(rm, res16); break;\ + case 1: /*DEC Ev*/\ + oper2 = 1;\ + tempcf = cf;\ + op_sub16();\ + cf = tempcf;\ + writerm16(rm, res16); break;\ + case 2: /*CALL Ev*/\ + push(ip);\ + ip = oper1; break;\ + case 3: /*CALL Mp*/\ + push(segregs[regcs]); push(ip);\ + /*getea(rm);*/\ + ip = (uint16_t)read86(ea) + ((uint16_t)read86(ea + 1) << 8);\ + segregs[regcs] = (uint16_t)read86(ea + 2) + ((uint16_t)read86(ea + 3) << 8); break;\ + case 4: /*JMP Ev*/\ + ip = oper1; break;\ + case 5: /*JMP Mp*/\ + /*getea(rm);*/\ + ip = (uint16_t)read86(ea) + ((uint16_t)read86(ea + 1) << 8);\ + segregs[regcs] = (uint16_t)read86(ea + 2) + ((uint16_t)read86(ea + 3) << 8); break;\ + case 6: /*PUSH Ev*/\ + push(oper1); break;\ + }\ +} + +uint8_t didintr = 0; + +void intcall86(uint8_t intnum) { + didintr = 1; + + switch (intnum) { + case 0x10: //video services + if (regs.byteregs[regah] == 0) { //video mode set +#ifdef ADVANCED_CLIENT + Serial.write(0xFF); + Serial.write(0x02); + Serial.write(regs.byteregs[regal]); + Serial.write(regs.byteregs[regal]); //duplicate for checksum + Serial.write(0xFE); + Serial.write(0x02); +#endif +#ifdef USE_DISPLAY + if (vidmode != regs.byteregs[regal]) clear_display(); + palettereset(); +#endif + vidmode = regs.byteregs[regal]; + //Serial.print("vidmode = "); Serial.println(vidmode); + } + break; + case 0x13: //disk services + diskhandler(); + return; + case 0x19: //bootstrap + //Serial.println("Bootstrap!"); + if (bootdrive < 255) { //read first sector of boot drive into 07C0:0000 and execute it + regs.byteregs[regdl] = bootdrive; + readdisk((bootdrive & 0x80) ? bootdrive - 126 : bootdrive, 0x07C0, 0x0000, 0, 1, 0, 1); + segregs[regcs] = 0x0000; ip = 0x7C00; + } else { + segregs[regcs] = 0xF600; //start ROM BASIC at bootstrap if requested + ip = 0x0000; + } + return; + case 0xFC: + net_handler(); + return; + default: + break; + } + + push(makeflagsword()); + push(segregs[regcs]); + push(ip); + segregs[regcs] = getmem16(0, ((uint16_t)intnum << 2) + 2); + ip = getmem16(0, (uint16_t)intnum << 2); + ifl = 0; + tf = 0; +} + +uint64_t frametimer = 0, didwhen = 0, didticks = 0; +uint32_t makeupticks = 0; +extern float timercomp; +uint64_t timerticks = 0, realticks = 0; +uint64_t lastcountertimer = 0, counterticks = 10000; + +#ifdef PROFILING +uint32_t startmicros, endmicros; +uint32_t instrtime[0x100]; +#endif + +#ifdef PS2_KEYBOARD +extern uint8_t kbloop; +#endif + +extern volatile uint8_t timerTick; + +void exec86(uint32_t execloops) { + uint32_t loopcount; + uint8_t docontinue; + static uint16_t firstip, trap_toggle = 0; + + for (loopcount = 0; loopcount < execloops; loopcount++) { + /*Serial.print(segregs[regcs], HEX); + Serial.write(':'); + Serial.println(ip, HEX);*/ + #ifdef PS2_KEYBOARD + if (kbloop) { + uint32_t msnow; + msnow = micros(); + while ((micros() - msnow) < 20000) { } + kbloop = 0; + ps2poll(); + } + #endif + + if (timerTick) { + //printf("isr\n"); + timerTick = 0; + doirq(0); + } + + if (trap_toggle) intcall86(1); + if (tf) trap_toggle = 1; + else trap_toggle = 0; + if (!trap_toggle && (ifl && (i8259.irr & (~i8259.imr)))) intcall86(nextintr()); //get next interrupt from the i8259, if any + reptype = 0; segoverride = 0; + useseg = segregs[regds]; docontinue = 0; + firstip = ip; + while (!docontinue) { + segregs[regcs] = segregs[regcs] & 0xFFFF; ip = ip & 0xFFFF; + savecs = segregs[regcs]; saveip = ip; + opcode = getmem8(segregs[regcs], ip); StepIP(1); + + switch (opcode) { + //segment prefix check + case 0x2E: //segment segregs[regcs] + useseg = segregs[regcs]; segoverride = 1; break; + case 0x3E: //segment segregs[regds] + useseg = segregs[regds]; segoverride = 1; break; + case 0x26: //segment segregs[reges] + useseg = segregs[reges]; segoverride = 1; break; + case 0x36: //segment segregs[regss] + useseg = segregs[regss]; segoverride = 1; break; + + //repetition prefix check + case 0xF3: //REP/REPE/REPZ + reptype = 1; break; + case 0xF2: //REPNE/REPNZ + reptype = 2; break; + default: + docontinue = 1; + break; + } + } + totalexec++; + //printf("%04X:%04X %02X\n", segregs[regcs], ip, opcode); + //if ((segregs[regcs]==0xF000) && (ip < 0xE000)) exit(0); + +#ifdef PROFILING + startmicros = micros(); +#endif + switch (opcode) { + case 0x0: //00 ADD Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_add8(); + writerm8(rm, res8); + break; + case 0x1: //01 ADD Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_add16(); + writerm16(rm, res16); + break; + case 0x2: //02 ADD Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_add8(); + putreg8(reg, res8); + break; + case 0x3: //03 ADD Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_add16(); + putreg16(reg, res16); + break; + case 0x4: //04 ADD regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_add8(); + regs.byteregs[regal] = res8; + break; + case 0x5: //05 ADD eAX Iv + oper1 = (getreg16(regax)); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_add16(); + putreg16(regax, res16); + break; + case 0x6: //06 PUSH segregs[reges] + push(segregs[reges]); + break; + case 0x7: //07 POP segregs[reges] + segregs[reges] = pop(); + break; + case 0x8: //08 OR Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_or8(); + writerm8(rm, res8); + break; + case 0x9: //09 OR Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_or16(); + writerm16(rm, res16); + break; + case 0xA: //0A OR Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_or8(); + putreg8(reg, res8); + break; + case 0xB: //0B OR Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_or16(); + if ((oper1 == 0xF802) && (oper2 == 0xF802)) sf = 0; //cheap hack to make Wolf 3D think we're a 286 so it plays + putreg16(reg, res16); + break; + case 0xC: //0C OR regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_or8(); + regs.byteregs[regal] = res8; + break; + case 0xD: //0D OR eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_or16(); + putreg16(regax, res16); + break; + case 0xE: //0E PUSH segregs[regcs] + push(segregs[regcs]); + break; + case 0xF: //0F POP CS + segregs[regcs] = pop(); + break; + /*case 0xF: //0F 80286+ extended opcodes + segregs[regcs] = segregs[regcs] & 0xFFFF; ip = ip & 0xFFFF; + savecs = segregs[regcs]; saveip = ip; + opcode = getmem8(segregs[regcs], ip); StepIP(1); + op_286(); + break;*/ + case 0x10: //10 ADC Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_adc8(); + writerm8(rm, res8); + break; + case 0x11: //11 ADC Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_adc16(); + writerm16(rm, res16); + break; + case 0x12: //12 ADC Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_adc8(); + putreg8(reg, res8); + break; + case 0x13: //13 ADC Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_adc16(); + putreg16(reg, res16); + break; + case 0x14: //14 ADC regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_adc8(); + regs.byteregs[regal] = res8; + break; + case 0x15: //15 ADC eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_adc16(); + putreg16(regax, res16); + break; + case 0x16: //16 PUSH segregs[regss] + push(segregs[regss]); + break; + case 0x17: //17 POP segregs[regss] + segregs[regss] = pop(); + break; + case 0x18: //18 SBB Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_sbb8(); + writerm8(rm, res8); + break; + case 0x19: //19 SBB Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_sbb16(); + writerm16(rm, res16); + break; + case 0x1A: //1A SBB Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_sbb8(); + putreg8(reg, res8); + break; + case 0x1B: //1B SBB Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_sbb16(); + putreg16(reg, res16); + break; + case 0x1C: //1C SBB regs.byteregs[regal] Ib; + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_sbb8(); + regs.byteregs[regal] = res8; + break; + case 0x1D: //1D SBB eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_sbb16(); + putreg16(regax, res16); + break; + case 0x1E: //1E PUSH segregs[regds] + push(segregs[regds]); + break; + case 0x1F: //1F POP segregs[regds] + segregs[regds] = pop(); + break; + case 0x20: //20 AND Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_and8(); + writerm8(rm, res8); + break; + case 0x21: //21 AND Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_and16(); + writerm16(rm, res16); + break; + case 0x22: //22 AND Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_and8(); + putreg8(reg, res8); + break; + case 0x23: //23 AND Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_and16(); + putreg16(reg, res16); + break; + case 0x24: //24 AND regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_and8(); + regs.byteregs[regal] = res8; + break; + case 0x25: //25 AND eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_and16(); + putreg16(regax, res16); + break; + case 0x27: //27 DAA + if (((regs.byteregs[regal] & 0xF) > 9) || (af == 1)) { + oper1 = regs.byteregs[regal] + 6; + regs.byteregs[regal] = oper1 & 255; + if (oper1 & 0xFF00) cf = 1; else cf = 0; + af = 1; + } else af = 0; + if (((regs.byteregs[regal] & 0xF0) > 0x90) || (cf == 1)) { + regs.byteregs[regal] = regs.byteregs[regal] + 0x60; + cf = 1; + } else cf = 0; + regs.byteregs[regal] = regs.byteregs[regal] & 255; + flag_szp8(regs.byteregs[regal]); + break; + case 0x28: //28 SUB Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_sub8(); + writerm8(rm, res8); + break; + case 0x29: //29 SUB Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_sub16(); + writerm16(rm, res16); + break; + case 0x2A: //2A SUB Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_sub8(); + putreg8(reg, res8); + break; + case 0x2B: //2B SUB Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_sub16(); + putreg16(reg, res16); + break; + case 0x2C: //2C SUB regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_sub8(); + regs.byteregs[regal] = res8; + break; + case 0x2D: //2D SUB eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_sub16(); + putreg16(regax, res16); + break; + case 0x2F: //2F DAS + if (((regs.byteregs[regal] & 15) > 9) || (af == 1)) { + oper1 = regs.byteregs[regal] - 6; + regs.byteregs[regal] = oper1 & 255; + if (oper1 & 0xFF00) cf = 1; else cf = 0; + af = 1; + } else af = 0; + if (((regs.byteregs[regal] & 0xF0) > 0x90) || (cf == 1)) { + regs.byteregs[regal] = regs.byteregs[regal] - 0x60; + cf = 1; + } else cf = 0; + flag_szp8(regs.byteregs[regal]); + break; + case 0x30: //30 XOR Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + op_xor8(); + writerm8(rm, res8); + break; + case 0x31: //31 XOR Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + op_xor16(); + writerm16(rm, res16); + break; + case 0x32: //32 XOR Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + op_xor8(); + putreg8(reg, res8); + break; + case 0x33: //33 XOR Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + op_xor16(); + putreg16(reg, res16); + break; + case 0x34: //34 XOR regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + op_xor8(); + regs.byteregs[regal] = res8; + break; + case 0x35: //35 XOR eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + op_xor16(); + putreg16(regax, res16); + break; + case 0x37: //37 AAA ASCII + if (((regs.byteregs[regal] & 0xF) > 9) || (af == 1)) { + regs.byteregs[regal] = regs.byteregs[regal] + 6; + regs.byteregs[regah] = regs.byteregs[regah] + 1; + af = 1; + cf = 1; + } else { + af = 0; + cf = 0; + } + regs.byteregs[regal] = regs.byteregs[regal] & 0xF; + break; + case 0x38: //38 CMP Eb Gb + modregrm(); + oper1b = readrm8(rm); oper2b = getreg8(reg); + flag_sub8(oper1b, oper2b); + break; + case 0x39: //39 CMP Ev Gv + modregrm(); + oper1 = readrm16(rm); oper2 = getreg16(reg); + flag_sub16(oper1, oper2); + break; + case 0x3A: //3A CMP Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + flag_sub8(oper1b, oper2b); + break; + case 0x3B: //3B CMP Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + flag_sub16(oper1, oper2); + break; + case 0x3C: //3C CMP regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + flag_sub8(oper1b, oper2b); + break; + case 0x3D: //3D CMP eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + flag_sub16(oper1, oper2); + break; + case 0x3F: //3F AAS ASCII + if (((regs.byteregs[regal] & 0xF) > 9) || (af == 1)) { + regs.byteregs[regal] = regs.byteregs[regal] - 6; + regs.byteregs[regah] = regs.byteregs[regah] - 1; + af = 1; + cf = 1; + } else { + af = 0; + cf = 0; + } + regs.byteregs[regal] = regs.byteregs[regal] & 0xF; + break; + case 0x40: //40 INC eAX + oldcf = cf; + oper1 = getreg16(regax); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regax, res16); + break; + case 0x41: //41 INC eCX + oldcf = cf; + oper1 = getreg16(regcx); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regcx, res16); + break; + case 0x42: //42 INC eDX + oldcf = cf; + oper1 = getreg16(regdx); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regdx, res16); + break; + case 0x43: //43 INC eBX + oldcf = cf; + oper1 = getreg16(regbx); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regbx, res16); + break; + case 0x44: //44 INC eSP + oldcf = cf; + oper1 = getreg16(regsp); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regsp, res16); + break; + case 0x45: //45 INC eBP + oldcf = cf; + oper1 = getreg16(regbp); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regbp, res16); + break; + case 0x46: //46 INC eSI + oldcf = cf; + oper1 = getreg16(regsi); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regsi, res16); + break; + case 0x47: //47 INC eDI + oldcf = cf; + oper1 = getreg16(regdi); oper2 = 1; + op_add16(); + cf = oldcf; + putreg16(regdi, res16); + break; + case 0x48: //48 DEC eAX + oldcf = cf; + oper1 = getreg16(regax); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regax, res16); + break; + case 0x49: //49 DEC eCX + oldcf = cf; + oper1 = getreg16(regcx); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regcx, res16); + break; + case 0x4A: //4A DEC eDX + oldcf = cf; + oper1 = getreg16(regdx); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regdx, res16); + break; + case 0x4B: //4B DEC eBX + oldcf = cf; + oper1 = getreg16(regbx); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regbx, res16); + break; + case 0x4C: //4C DEC eSP + oldcf = cf; + oper1 = getreg16(regsp); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regsp, res16); + break; + case 0x4D: //4D DEC eBP + oldcf = cf; + oper1 = getreg16(regbp); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regbp, res16); + break; + case 0x4E: //4E DEC eSI + oldcf = cf; + oper1 = getreg16(regsi); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regsi, res16); + break; + case 0x4F: //4F DEC eDI + oldcf = cf; + oper1 = getreg16(regdi); oper2 = 1; + op_sub16(); + cf = oldcf; + putreg16(regdi, res16); + break; + case 0x50: //50 PUSH eAX + push (getreg16(regax)); + break; + case 0x51: //51 PUSH eCX + push (getreg16(regcx)); + break; + case 0x52: //52 PUSH eDX + push (getreg16(regdx)); + break; + case 0x53: //53 PUSH eBX + push (getreg16(regbx)); + break; + case 0x54: //54 PUSH eSP + push (getreg16(regsp) - 2); + break; + case 0x55: //55 PUSH eBP + push (getreg16(regbp)); + break; + case 0x56: //56 PUSH eSI + push (getreg16(regsi)); + break; + case 0x57: //57 PUSH eDI + push (getreg16(regdi)); + break; + case 0x58: //58 POP eAX + putreg16(regax, pop()); + break; + case 0x59: //59 POP eCX + putreg16(regcx, pop()); + break; + case 0x5A: //5A POP eDX + putreg16(regdx, pop()); + break; + case 0x5B: //5B POP eBX + putreg16(regbx, pop()); + break; + case 0x5C: //5C POP eSP + putreg16(regsp, pop()); + break; + case 0x5D: //5D POP eBP + putreg16(regbp, pop()); + break; + case 0x5E: //5E POP eSI + putreg16(regsi, pop()); + break; + case 0x5F: //5F POP eDI + putreg16(regdi, pop()); + break; + case 0x60: //60 PUSHA (80186+) + oldsp = getreg16(regsp); + push(getreg16(regax)); + push(getreg16(regcx)); + push(getreg16(regdx)); + push(getreg16(regbx)); + push(oldsp); + push(getreg16(regbp)); + push(getreg16(regsi)); + push(getreg16(regdi)); + break; + case 0x61: //61 POPA (80186+) + putreg16(regdi, pop()); + putreg16(regsi, pop()); + putreg16(regbp, pop()); + dummy = pop(); + putreg16(regbx, pop()); + putreg16(regdx, pop()); + putreg16(regcx, pop()); + putreg16(regax, pop()); + break; + case 0x68: //68 PUSH Iv (80186+) + push(getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0x69: //69 IMUL Gv Ev Iv (80186+) + //print("WE HIT 69h IMUL\r\n"); + modregrm(); + temp1 = readrm16(rm); + temp2 = getmem16(segregs[regcs], ip); StepIP(2); + if ((temp1 & 0x8000L) == 0x8000L) temp1 = temp1 | 0xFFFF0000L; + if ((temp2 & 0x8000L) == 0x8000L) temp2 = temp2 | 0xFFFF0000L; + temp3 = temp1 * temp2; + putreg16(reg, temp3 & 0xFFFFL); + if (temp3 & 0xFFFF0000L) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + case 0x6A: //6A PUSH Ib (80186+) + push(getmem8(segregs[regcs], ip)); StepIP(1); + break; + case 0x6B: //6B IMUL Gv Eb Ib (80186+) + //print("WE HIT 6Bh IMUL\r\n"); + modregrm(); + temp1 = readrm16(rm); + temp2 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if ((temp1 & 0x8000L) == 0x8000L) temp1 = temp1 | 0xFFFF0000L; + if ((temp2 & 0x8000L) == 0x8000L) temp2 = temp2 | 0xFFFF0000L; + temp3 = temp1 * temp2; + putreg16(reg, temp3 & 0xFFFFL); + if (temp3 & 0xFFFF0000L) { + cf = 1; + of = 1; + } else { + cf = 0; + of = 0; + } + break; + //case 0x6C ... 0x6F: //80186 port operations, just act as if they//re NOPs for now... + // StepIP(1); //they have a modregrm(); byte we must skip... i may properly emulate these later. + // break; + case 0x6E: //6E OUTSB + if (reptype && (getreg16(regcx) == 0)) break; + portout16 = 0; + portout(regs.wordregs[regdx], getmem16(useseg, getreg16(regsi))); + if (df) { + putreg16(regsi, getreg16(regsi) - 1); + putreg16(regdi, getreg16(regdi) - 1); + } + else { + putreg16(regsi, getreg16(regsi) + 1); + putreg16(regdi, getreg16(regdi) + 1); + } + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0x6F: //6F OUTSW + if (reptype && (getreg16(regcx) == 0)) break; + portout16 = 1; + portout(regs.wordregs[regdx], getmem16(useseg, getreg16(regsi))); + if (df) { + putreg16(regsi, getreg16(regsi) - 2); + putreg16(regdi, getreg16(regdi) - 2); + } + else { + putreg16(regsi, getreg16(regsi) + 2); + putreg16(regdi, getreg16(regdi) + 2); + } + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + + case 0x70: //70 JO Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (of) ip = ip + temp16; + break; + case 0x71: //71 JNO Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!of) ip = ip + temp16; + break; + case 0x72: //72 JB Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (cf) ip = ip + temp16; + break; + case 0x73: //73 JNB Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!cf) ip = ip + temp16; + break; + case 0x74: //74 JZ Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (zf) ip = ip + temp16; + break; + case 0x75: //75 JNZ Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!zf) ip = ip + temp16; + break; + case 0x76: //76 JBE Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (cf || zf) ip = ip + temp16; + break; + case 0x77: //77 JA Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!cf && !zf) ip = ip + temp16; + break; + case 0x78: //78 JS Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (sf) ip = ip + temp16; + break; + case 0x79: //79 JNS Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!sf) ip = ip + temp16; + break; + case 0x7A: //7A JPE Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (pf) ip = ip + temp16; + break; + case 0x7B: //7B JPO Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!pf) ip = ip + temp16; + break; + case 0x7C: //7C JL Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (sf != of) ip = ip + temp16; + break; + case 0x7D: //7D JGE Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (sf == of) ip = ip + temp16; + break; + case 0x7E: //7E JLE Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if ((sf != of) || zf) ip = ip + temp16; + break; + case 0x7F: //7F JG Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!zf && (sf == of)) ip = ip + temp16; + break; + case 0x80: case 0x82: //80/82 GRP1 Eb Ib + modregrm(); + oper1b = readrm8(rm); + oper2b = getmem8(segregs[regcs], ip); StepIP(1); + switch (reg) { + case 0: op_add8(); break; + case 1: op_or8(); break; + case 2: op_adc8(); break; + case 3: op_sbb8(); break; + case 4: op_and8(); break; + case 5: op_sub8(); break; + case 6: op_xor8(); break; + case 7: flag_sub8(oper1b, oper2b); break; + default: break; //to avoid compiler warnings + } + if (reg < 7) writerm8(rm, res8); + break; + case 0x81: //81 GRP1 Ev Iv + case 0x83: //83 GRP1 Ev Ib + modregrm(); + oper1 = readrm16(rm); + if (opcode == 0x81) { + oper2 = getmem16(segregs[regcs], ip); StepIP(2); + } else { + oper2 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + } + switch (reg) { + case 0: op_add16(); break; + case 1: op_or16(); break; + case 2: op_adc16(); break; + case 3: op_sbb16(); break; + case 4: op_and16(); break; + case 5: op_sub16(); break; + case 6: op_xor16(); break; + case 7: flag_sub16(oper1, oper2); break; + default: break; //to avoid compiler warnings + } + if (reg < 7) writerm16(rm, res16); + break; + case 0x84: //84 TEST Gb Eb + modregrm(); + oper1b = getreg8(reg); oper2b = readrm8(rm); + flag_log8(oper1b & oper2b); + break; + case 0x85: //85 TEST Gv Ev + modregrm(); + oper1 = getreg16(reg); oper2 = readrm16(rm); + flag_log16(oper1 & oper2); + break; + case 0x86: //86 XCHG Gb Eb + modregrm(); + oper1b = getreg8(reg); + putreg8(reg, readrm8(rm)); + writerm8(rm, oper1b); + break; + case 0x87: //87 XCHG Gv Ev + modregrm(); + oper1 = getreg16(reg); + putreg16(reg, readrm16(rm)); + writerm16(rm, oper1); + break; + case 0x88: //88 MOV Eb Gb + modregrm(); + writerm8(rm, getreg8(reg)); + break; + case 0x89: //89 MOV Ev Gv + modregrm(); + writerm16(rm, getreg16(reg)); + break; + case 0x8A: //8A MOV Gb Eb + modregrm(); + putreg8(reg, readrm8(rm)); + break; + case 0x8B: //8B MOV Gv Ev + modregrm(); + putreg16(reg, readrm16(rm)); + break; + case 0x8C: //8C MOV Ew Sw + modregrm(); + writerm16(rm, getsegreg(reg)); + break; + case 0x8D: //8D LEA Gv M + modregrm(); + //getea(rm); + putreg16(reg, ea - segbase(useseg)); + break; + case 0x8E: //8E MOV Sw Ew + modregrm(); + putsegreg(reg, readrm16(rm)); + break; + case 0x8F: //8F POP Ev + modregrm(); + writerm16(rm, pop()); + break; + case 0x90: //90 NOP + break; + case 0x91: //91 XCHG eCX eAX + oper1 = getreg16(regcx); + putreg16(regcx, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x92: //92 XCHG eDX eAX + oper1 = getreg16(regdx); + putreg16(regdx, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x93: //93 XCHG eBX eAX + oper1 = getreg16(regbx); + putreg16(regbx, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x94: //94 XCHG eSP eAX + oper1 = getreg16(regsp); + putreg16(regsp, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x95: //95 XCHG eBP eAX + oper1 = getreg16(regbp); + putreg16(regbp, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x96: //96 XCHG eSI eAX + oper1 = getreg16(regsi); + putreg16(regsi, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x97: //97 XCHG eDI eAX + oper1 = getreg16(regdi); + putreg16(regdi, getreg16(regax)); + putreg16(regax, oper1); + break; + case 0x98: //98 CBW + if ((regs.byteregs[regal] & 0x80) == 0x80) regs.byteregs[regah] = 0xFF; else regs.byteregs[regah] = 0; + break; + case 0x99: //99 CWD + if ((regs.byteregs[regah] & 0x80) == 0x80) putreg16(regdx, 0xFFFF); else putreg16(regdx, 0); + break; + case 0x9A: //9A CALL Ap + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + oper2 = getmem16(segregs[regcs], ip); StepIP(2); + push(segregs[regcs]); push(ip); ip = oper1; segregs[regcs] = oper2; + break; + case 0x9B: //9B WAIT + break; + case 0x9C: //9C PUSHF + push(makeflagsword() | 0xF800); + break; + case 0x9D: //9D POPF + temp16 = pop(); + decodeflagsword(temp16); + break; + case 0x9E: //9E SAHF + decodeflagsword ((makeflagsword() & 0xFF00) | regs.byteregs[regah]); + break; + case 0x9F: //9F LAHF + regs.byteregs[regah] = makeflagsword() & 0xFF; + break; + case 0xA0: //A0 MOV regs.byteregs[regal] Ob + regs.byteregs[regal] = getmem8(useseg, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xA1: //A1 MOV eAX Ov + oper1 = getmem16(useseg, getmem16(segregs[regcs], ip)); StepIP(2); + putreg16(regax, oper1); + break; + case 0xA2: //A2 MOV Ob regs.byteregs[regal] + putmem8(useseg, getmem16(segregs[regcs], ip), regs.byteregs[regal]); StepIP(2); + break; + case 0xA3: //A3 MOV Ov eAX + putmem16(useseg, getmem16(segregs[regcs], ip), getreg16(regax)); StepIP(2); + break; + case 0xA4: //A4 MOVSB + if (reptype && (getreg16(regcx) == 0)) break; + putmem8(segregs[reges], getreg16(regdi), getmem8(useseg, getreg16(regsi))); + if (df) { + putreg16(regsi, getreg16(regsi) - 1); + putreg16(regdi, getreg16(regdi) - 1); + } + else { + putreg16(regsi, getreg16(regsi) + 1); + putreg16(regdi, getreg16(regdi) + 1); + } + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xA5: //A5 MOVSW + if (reptype && (getreg16(regcx) == 0)) break; + putmem16(segregs[reges], getreg16(regdi), getmem16(useseg, getreg16(regsi))); + if (df) { + putreg16(regsi, getreg16(regsi) - 2); + putreg16(regdi, getreg16(regdi) - 2); + } + else { + putreg16(regsi, getreg16(regsi) + 2); + putreg16(regdi, getreg16(regdi) + 2); + } + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xA6: //A6 CMPSB + if (reptype && (getreg16(regcx) == 0)) break; + oper1b = getmem8(useseg, getreg16(regsi)); oper2b = getmem8(segregs[reges], getreg16(regdi)); + if (df) { + putreg16(regsi, getreg16(regsi) - 1); + putreg16(regdi, getreg16(regdi) - 1); + } + else { + putreg16(regsi, getreg16(regsi) + 1); + putreg16(regdi, getreg16(regdi) + 1); + } + flag_sub8(oper1b, oper2b); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if ((reptype == 1) && !zf) break; + else if ((reptype == 2) && (zf == 1)) break; + if (!reptype) break; + ip = firstip; + break; + case 0xA7: //A7 CMPSW + if (reptype && (getreg16(regcx) == 0)) break; + oper1 = getmem16(useseg, getreg16(regsi)); oper2 = getmem16(segregs[reges], getreg16(regdi)); + if (df) { + putreg16(regsi, getreg16(regsi) - 2); + putreg16(regdi, getreg16(regdi) - 2); + } + else { + putreg16(regsi, getreg16(regsi) + 2); + putreg16(regdi, getreg16(regdi) + 2); + } + flag_sub16(oper1, oper2); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if ((reptype == 1) && !zf) break; + if ((reptype == 2) && (zf == 1)) break; + if (!reptype) break; + ip = firstip; + break; + case 0xA8: //A8 TEST regs.byteregs[regal] Ib + oper1b = regs.byteregs[regal]; oper2b = getmem8(segregs[regcs], ip); StepIP(1); + flag_log8(oper1b & oper2b); + break; + case 0xA9: //A9 TEST eAX Iv + oper1 = getreg16(regax); oper2 = getmem16(segregs[regcs], ip); StepIP(2); + flag_log16(oper1 & oper2); + break; + case 0xAA: //AA STOSB + if (reptype && (getreg16(regcx) == 0)) break; + putmem8(segregs[reges], getreg16(regdi), regs.byteregs[regal]); + if (df) putreg16(regdi, getreg16(regdi) - 1); + else putreg16(regdi, getreg16(regdi) + 1); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xAB: //AB STOSW + if (reptype && (getreg16(regcx) == 0)) break; + putmem16(segregs[reges], getreg16(regdi), getreg16(regax)); + if (df) putreg16(regdi, getreg16(regdi) - 2); + else putreg16(regdi, getreg16(regdi) + 2); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xAC: //AC LODSB + if (reptype && (getreg16(regcx) == 0)) break; + regs.byteregs[regal] = getmem8(useseg, getreg16(regsi)); + if (df) putreg16(regsi, getreg16(regsi) - 1); + else putreg16(regsi, getreg16(regsi) + 1); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xAD: //AD LODSW + if (reptype && (getreg16(regcx) == 0)) break; + oper1 = getmem16(useseg, getreg16(regsi)); + putreg16(regax, oper1); + if (df) putreg16(regsi, getreg16(regsi) - 2); + else putreg16(regsi, getreg16(regsi) + 2); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if (!reptype) break; + ip = firstip; + break; + case 0xAE: //AE SCASB + if (reptype && (getreg16(regcx) == 0)) break; + oper1b = getmem8(segregs[reges], getreg16(regdi)); oper2b = regs.byteregs[regal]; + flag_sub8(oper1b, oper2b); + if (df) putreg16(regdi, getreg16(regdi) - 1); + else putreg16(regdi, getreg16(regdi) + 1); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if ((reptype == 1) && !zf) break; + else if ((reptype == 2) && (zf == 1)) break; + if (!reptype) break; + ip = firstip; + break; + case 0xAF: //AF SCASW + if (reptype && (getreg16(regcx) == 0)) break; + oper1 = getmem16(segregs[reges], getreg16(regdi)); oper2 = getreg16(regax); + flag_sub16(oper1, oper2); + if (df) putreg16(regdi, getreg16(regdi) - 2); + else putreg16(regdi, getreg16(regdi) + 2); + if (reptype) putreg16(regcx, getreg16(regcx) - 1); + if ((reptype == 1) && !zf) break; + else if ((reptype == 2) & (zf == 1)) break; + if (!reptype) break; + ip = firstip; + break; + case 0xB0: //B0 MOV regs.byteregs[regal] Ib + regs.byteregs[regal] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB1: //B1 MOV regs.byteregs[regcl] Ib + regs.byteregs[regcl] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB2: //B2 MOV regs.byteregs[regdl] Ib + regs.byteregs[regdl] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB3: //B3 MOV regs.byteregs[regbl] Ib + regs.byteregs[regbl] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB4: //B4 MOV regs.byteregs[regah] Ib + regs.byteregs[regah] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB5: //B5 MOV regs.byteregs[regch] Ib + regs.byteregs[regch] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB6: //B6 MOV regs.byteregs[regdh] Ib + regs.byteregs[regdh] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB7: //B7 MOV regs.byteregs[regbh] Ib + regs.byteregs[regbh] = getmem8(segregs[regcs], ip); StepIP(1); + break; + case 0xB8: //B8 MOV eAX Iv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + putreg16(regax, oper1); + break; + case 0xB9: //B9 MOV eCX Iv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + putreg16(regcx, oper1); + break; + case 0xBA: //BA MOV eDX Iv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + putreg16(regdx, oper1); + break; + case 0xBB: //BB MOV eBX Iv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + putreg16(regbx, oper1); + break; + case 0xBC: //BC MOV eSP Iv + putreg16(regsp, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xBD: //BD MOV eBP Iv + putreg16(regbp, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xBE: //BE MOV eSI Iv + putreg16(regsi, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xBF: //BF MOV eDI Iv + putreg16(regdi, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xC0: //C0 GRP2 byte imm8 (80186+) + modregrm(); + oper1b = readrm8(rm); + oper2b = getmem8(segregs[regcs], ip); StepIP(1); + writerm8(rm, op_grp2_8(oper2b)); + break; + case 0xC1: //C1 GRP2 word imm8 (80186+) + modregrm(); + oper1 = readrm16(rm); + oper2 = getmem8(segregs[regcs], ip); StepIP(1); + writerm16(rm, op_grp2_16(oper2)); + break; + case 0xC2: //C2 RET Iw + oper1 = getmem16(segregs[regcs], ip); + ip = pop(); + putreg16(regsp, getreg16(regsp) + oper1); + break; + case 0xC3: //C3 RET + ip = pop(); + break; + case 0xC4: //C4 LES Gv Mp + modregrm(); + //getea(rm); + putreg16(reg, read86(ea) + ((uint16_t)read86(ea + 1) << 8)); + segregs[reges] = read86(ea + 2) + ((uint16_t)read86(ea + 3) << 8); + break; + case 0xC5: //C5 LDS Gv Mp + modregrm(); + //getea(rm); + putreg16(reg, read86(ea) + ((uint16_t)read86(ea + 1) << 8)); + segregs[regds] = read86(ea + 2) + ((uint16_t)read86(ea + 3) << 8); + break; + case 0xC6: //C6 MOV Eb Ib + modregrm(); + writerm8(rm, getmem8(segregs[regcs], ip)); StepIP(1); + break; + case 0xC7: //C7 MOV Ev Iv + modregrm(); + writerm16(rm, getmem16(segregs[regcs], ip)); StepIP(2); + break; + case 0xC8: //C8 ENTER (80186+) + stacksize = getmem16(segregs[regcs], ip); StepIP(2); + nestlev = getmem8(segregs[regcs], ip); StepIP(1); + push(getreg16(regbp)); + frametemp = getreg16(regsp); + if (nestlev) { + for (temp16 = 1; temp16 < nestlev; temp16++) { + putreg16(regbp, getreg16(regbp) - 2); + push(getreg16(regbp)); + } + push(getreg16(regsp)); + } + putreg16(regbp, frametemp); + putreg16(regsp, getreg16(regbp) - stacksize); + + break; + case 0xC9: //C9 LEAVE (80186+) + putreg16(regsp, getreg16(regbp)); + putreg16(regbp, pop()); + + break; + case 0xCA: //CA RETF Iw + oper1 = getmem16(segregs[regcs], ip); + ip = pop(); segregs[regcs] = pop(); + putreg16(regsp, getreg16(regsp) + oper1); + break; + case 0xCB: //CB RETF + ip = pop();; segregs[regcs] = pop(); + break; + case 0xCC: //CC INT 3 + intcall86(3); + break; + case 0xCD: //CD INT Ib + oper1 = getmem8(segregs[regcs], ip); StepIP(1); + intcall86(oper1); + break; + case 0xCE: //CE INTO + if (of) intcall86(4); + break; + case 0xCF: //CF IRET + ip = pop(); segregs[regcs] = pop(); + decodeflagsword(pop()); + //if (net.enabled) net.canrecv = 1; + break; + case 0xD0: //D0 GRP2 Eb 1 + modregrm(); + oper1b = readrm8(rm); + writerm8(rm, op_grp2_8(1)); + break; + case 0xD1: //D1 GRP2 Ev 1 + modregrm(); + oper1 = readrm16(rm); + writerm16(rm, op_grp2_16(1)); + break; + case 0xD2: //D2 GRP2 Eb regs.byteregs[regcl] + modregrm(); + oper1b = readrm8(rm); + writerm8(rm, op_grp2_8(regs.byteregs[regcl])); + break; + case 0xD3: //D3 GRP2 Ev regs.byteregs[regcl] + modregrm(); + oper1 = readrm16(rm); + writerm16(rm, op_grp2_16(regs.byteregs[regcl])); + break; + case 0xD4: //D4 AAM I0 + oper1 = getmem8(segregs[regcs], ip); StepIP(1); + if (!oper1) { + intcall86(0); //division by zero + return; + } + regs.byteregs[regah] = (regs.byteregs[regal] / oper1) & 255; + regs.byteregs[regal] = (regs.byteregs[regal] % oper1) & 255; + flag_szp16 (getreg16(regax)); + break; + case 0xD5: //D5 AAD I0 + oper1 = getmem8(segregs[regcs], ip); StepIP(1); + regs.byteregs[regal] = (regs.byteregs[regah] * oper1 + regs.byteregs[regal]) & 255; + regs.byteregs[regah] = 0; + flag_szp16(regs.byteregs[regah] * oper1 + regs.byteregs[regal]); + sf = 0; + break; + case 0xD6: //D6 XLAT on V20/V30, SALC on 8086/8088 + regs.byteregs[regal] = cf; + break; + case 0xD7: //D7 XLAT + putreg8(regal, read86(segbase(useseg) + (uint32_t)getreg16(regbx) + (uint32_t)getreg8(regal))); + break; + case 0xD8: case 0xD9: case 0xDA: case 0xDB: case 0xDC: case 0xDE: case 0xDD: case 0xDF: //escape + StepIP(1); + break; + case 0xE0: //E0 LOOPNZ Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + putreg16(regcx, getreg16(regcx) - 1); + if ((getreg16(regcx)) && !zf) ip = ip + temp16; + break; + case 0xE1: //E1 LOOPZ Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + putreg16(regcx, (getreg16(regcx)) - 1); + if ((getreg16(regcx)) && (zf == 1)) ip = ip + temp16; + break; + case 0xE2: //E2 LOOP Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + putreg16(regcx, (getreg16(regcx)) - 1); + if (getreg16(regcx)) ip = ip + temp16; + break; + case 0xE3: //E3 JCXZ Jb + temp16 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + if (!(getreg16(regcx))) ip = ip + temp16; + break; + case 0xE4: //E4 IN regs.byteregs[regal] Ib + oper1b = getmem8(segregs[regcs], ip); + StepIP(1); + regs.byteregs[regal] = portin(oper1b); + break; + case 0xE5: //E5 IN eAX Ib + oper1b = getmem8(segregs[regcs], ip); + StepIP(1); + putreg16(regax, portin(oper1b)); + break; + case 0xE6: //E6 OUT Ib regs.byteregs[regal] + oper1b = getmem8(segregs[regcs], ip); + StepIP(1); + portout16 = 0; + portout(oper1b, regs.byteregs[regal]); + break; + case 0xE7: //E7 OUT Ib eAX + oper1b = getmem8(segregs[regcs], ip); + StepIP(1); + portout16 = 1; + portout(oper1b, (getreg16(regax))); + break; + case 0xE8: //E8 CALL Jv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + push(ip); + ip = ip + oper1; + break; + case 0xE9: //E9 JMP Jv + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + ip = ip + oper1; + break; + case 0xEA: //EA JMP Ap + oper1 = getmem16(segregs[regcs], ip); StepIP(2); + oper2 = getmem16(segregs[regcs], ip); + ip = oper1; segregs[regcs] = oper2; + break; + case 0xEB: //EB JMP Jb + oper1 = signext(getmem8(segregs[regcs], ip)); StepIP(1); + ip = ip + oper1; + break; + case 0xEC: //EC IN regs.byteregs[regal] regdx + oper1 = (getreg16(regdx)); + regs.byteregs[regal] = portin(oper1); + break; + case 0xED: //ED IN eAX regdx + oper1 = (getreg16(regdx)); + putreg16(regax, portin(oper1)); + break; + case 0xEE: //EE OUT regdx regs.byteregs[regal] + oper1 = (getreg16(regdx)); + portout16 = 0; + portout(oper1, regs.byteregs[regal]); + break; + case 0xEF: //EF OUT regdx eAX + oper1 = (getreg16(regdx)); + portout16 = 1; + portout(oper1, (getreg16(regax))); + break; + case 0xF0: //F0 LOCK + case 0xF4: //F4 HLT + break; + case 0xF5: //F5 CMC + if (!cf) cf = 1; else cf = 0; + break; + case 0xF6: //F6 GRP3a Eb + modregrm(); + oper1b = readrm8(rm); + op_grp3_8(); + if ((reg > 1) && (reg < 4)) writerm8(rm, res8); + + break; + case 0xF7: //F7 GRP3b Ev + modregrm(); + oper1 = readrm16(rm); + op_grp3_16(); + if ((reg > 1) && (reg < 4)) writerm16(rm, res16); + break; + case 0xF8: //F8 CLC + cf = 0; + break; + case 0xF9: //F9 STC + cf = 1; + break; + case 0xFA: //FA CLI + ifl = 0; + break; + case 0xFB: //FB STI + ifl = 1; + break; + case 0xFC: //FC CLD + df = 0; + break; + case 0xFD: //FD STD + df = 1; + break; + case 0xFE: //FE GRP4 Eb + modregrm(); + oper1b = readrm8(rm); oper2b = 1; + if (!reg) { + tempcf = cf; + res8 = oper1b + oper2b; + flag_add8(oper1b, oper2b); + cf = tempcf; writerm8(rm, res8); + } else { + tempcf = cf; + res8 = oper1b - oper2b; + flag_sub8(oper1b, oper2b); + cf = tempcf; writerm8(rm, res8); + } + break; + case 0xFF: //FF GRP5 Ev + modregrm(); + oper1 = readrm16(rm); + op_grp5(); + break; + default: + intcall86(6); //trip invalid opcode exception (this occurs on the 80186+, 8086/8088 CPUs treat them as NOPs + if (verbose) { + //if (opcode==0xF) sprintf(msg, "Illegal opcode: %02X @ %04X:%04X\n", opcode, savecs, saveip); + //else + //sprintf(msg, "Illegal opcode: %02X %02X @ %04X:%04X\n", opcode, getmem8(savecs, saveip + 1), savecs, saveip); + } + + break; + } +#ifdef PROFILING + endmicros = micros(); + if (instrtime[opcode]) { + instrtime[opcode] = (instrtime[opcode] + (endmicros - startmicros)) >> 1; + } else { + instrtime[opcode] = endmicros - startmicros; + } +#endif + //if (!running) return; + } +} + +void testmem() { + +} + diff --git a/MCUME_pico/pico8086/disk.cpp b/MCUME_pico/pico8086/disk.cpp new file mode 100644 index 0000000..3757199 --- /dev/null +++ b/MCUME_pico/pico8086/disk.cpp @@ -0,0 +1,257 @@ +#include +#include +#include "emu.h" +extern "C" { +#include "emuapi.h" +} +extern uint8_t bootdrive, hdcount; +extern uint16_t segregs[6]; +extern uint8_t cf; +extern _bytewordregs_ regs; + +int file; + +struct struct_drive { + uint32_t filesize; + uint16_t cyls; + uint16_t sects; + uint16_t heads; + uint8_t inserted; +} disk[4]; +uint8_t sectorbuffer[512]; + +uint8_t insertdisk(uint8_t drivenum) { + if (drivenum & 0x80) { + drivenum -= 126; + disk[drivenum].sects = 63; + disk[drivenum].heads = 16; + disk[drivenum].cyls = 1023; //up to 512 MB + hdcount = 1; + } else { +#ifdef FDD_144M + disk[drivenum].cyls = 80; + disk[drivenum].sects = 18; + disk[drivenum].heads = 2; +#endif +#ifdef FDD_122M + disk[drivenum].cyls = 80; + disk[drivenum].sects = 15; + disk[drivenum].heads = 2; +#endif +#ifdef FDD_720K + disk[drivenum].cyls = 80; + disk[drivenum].sects = 9; + disk[drivenum].heads = 2; +#endif +#ifdef FDD_360K + disk[drivenum].cyls = 40; + disk[drivenum].sects = 9; + disk[drivenum].heads = 2; +#endif +#ifdef FDD_320K + disk[drivenum].cyls = 40; + disk[drivenum].sects = 8; + disk[drivenum].heads = 2; +#endif +#ifdef FDD_180K + disk[drivenum].cyls = 40; + disk[drivenum].sects = 9; + disk[drivenum].heads = 1; +#endif + } + disk[drivenum].inserted = 1; + return 0; +} + +void ejectdisk(uint8_t drivenum) { + if (drivenum & 0x80) drivenum -= 126; + disk[drivenum].inserted = 0; +} + +extern uint16_t ramseg; +extern "C" { +extern void emu_SdReadBlock(int block, void * buf); +} +uint8_t sectdone; +void getsect(uint32_t lba, uint8_t *dst) { +#ifdef USB_DISK + uint8_t chksum; + uint32_t curmicros; +retrysectget: + Serial.write(0xFF); + Serial.write(0x05); + outByte(lba & 0xFF); chksum = lba & 0xFF; + outByte((lba >> 8) & 0xFF); chksum += (lba >> 8) & 0xFF; + outByte((lba >> 16) & 0xFF); chksum += (lba >> 16) & 0xFF; + outByte((lba >> 24) & 0xFF); chksum += (lba >> 24) & 0xFF; + outByte(chksum); + Serial.write(0xFE); + Serial.write(0x02); + sectdone = 0; + curmicros = micros(); + while (!sectdone) { + if (micros() < curmicros) curmicros = micros(); + if ((micros() - curmicros) >= 200000) goto retrysectget; + net_loop(); + } +#else + if (file) + { + //printf("read block %d\n",lba); + emu_FileSeek(lba*512); + emu_FileRead((char *)dst,1*512); + } +#endif +} + +void putsect(uint32_t lba, uint8_t *src) { +#ifdef USB_DISK + uint8_t chksum; + uint16_t i; + uint32_t curmicros; +retrysectput: + Serial.write(0xFF); + Serial.write(0x06); + outByte(lba & 0xFF); chksum = lba & 0xFF; + outByte((lba >> 8) & 0xFF); chksum += (lba >> 8) & 0xFF; + outByte((lba >> 16) & 0xFF); chksum += (lba >> 16) & 0xFF; + outByte((lba >> 24) & 0xFF); chksum += (lba >> 24) & 0xFF; + for (i=0; i<512; i++) { + outByte(src[i]); + chksum += src[i]; + } + outByte(chksum); + Serial.write(0xFE); + Serial.write(0x02); + sectdone = 0; + curmicros = micros(); + while (!sectdone) { + if (micros() < curmicros) curmicros = micros(); + if ((micros() - curmicros) >= 200000) goto retrysectput; + net_loop(); + } +#else + //card.writeBlock(lba, src); +#endif +} +void readdisk(uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount) { + uint32_t memdest, goodsects, dummy, lba; + if ((sect == 0) || !disk[drivenum].inserted) return; +#ifdef MEGA + SPI.setClockDivider(SPI_CLOCK_SDCARD); +#endif + lba = ((long)cyl * (long)disk[drivenum].heads + (long)head) * (long)disk[drivenum].sects + (long)sect - 1; + memdest = (uint32_t)dstseg * 16 + (uint32_t)dstoff; + for (goodsects = 0; goodsects < sectcount; goodsects++) { + getsect(lba, sectorbuffer); + memdest = (uint32_t)dstseg * 16 + (uint32_t)dstoff; + for (dummy = 0; dummy < 512; dummy++) { + write86(memdest++, sectorbuffer[dummy]); + //Serial.write(sectorbuffer[dummy]); + } + dstoff += 512; + lba++; + } + cf = 0; regs.byteregs[regah] = 0; regs.byteregs[regal] = sectcount; +#ifdef MEGA + SPI.setClockDivider(SPI_CLOCK_SPIRAM); +#endif +} + +void writedisk(uint8_t drivenum, uint16_t dstseg, uint16_t dstoff, uint16_t cyl, uint16_t sect, uint16_t head, uint16_t sectcount) { + uint32_t memdest, goodsects, dummy, lba; + if ((sect == 0) || !disk[drivenum].inserted) return; +#ifdef MEGA + SPI.setClockDivider(SPI_CLOCK_SDCARD); +#endif + lba = ((long)cyl * (long)disk[drivenum].heads + (long)head) * (long)disk[drivenum].sects + (long)sect - 1; + for (goodsects = 0; goodsects < sectcount; goodsects++) { + memdest = (uint32_t)dstseg * 16 + (uint32_t)dstoff; + for (dummy = 0; dummy < 512; dummy++) { + sectorbuffer[dummy] = read86(memdest++); + } + //card.erase(lba, lba); + putsect(lba, sectorbuffer); + dstoff += 512; + lba++; + } + cf = 0; regs.byteregs[regah] = 0; regs.byteregs[regal] = sectcount; +#ifdef MEGA + SPI.setClockDivider(SPI_CLOCK_SPIRAM); +#endif +} + +void diskhandler() { + static uint8_t lastdiskah[4], lastdiskcf[4]; + uint8_t drivenum; + drivenum = regs.byteregs[regdl]; + if (drivenum & 0x80) drivenum -= 126; + switch (regs.byteregs[regah]) { + case 0: //reset disk system + regs.byteregs[regah] = 0; cf = 0; //useless function in an emulator. say success and return. + break; + case 1: //return last status + regs.byteregs[regah] = lastdiskah[drivenum]; + cf = lastdiskcf[drivenum]; + return; + case 2: //read sector(s) into memory + if (disk[drivenum].inserted) { + readdisk(drivenum, segregs[reges], getreg16(regbx), (uint16_t)regs.byteregs[regch] + ((uint16_t)regs.byteregs[regcl] / 64) * 256, regs.byteregs[regcl] & 63, regs.byteregs[regdh], regs.byteregs[regal]); + cf = 0; regs.byteregs[regah] = 0; + } else { + cf = 1; + regs.byteregs[regah] = 1; + } + break; + case 3: //write sector(s) from memory + if (disk[drivenum].inserted) { + writedisk(drivenum, segregs[reges], getreg16(regbx), regs.byteregs[regch] + (regs.byteregs[regcl] / 64) * 256, regs.byteregs[regcl] & 63, regs.byteregs[regdh], regs.byteregs[regal]); + cf = 0; regs.byteregs[regah] = 0; + } else { + cf = 1; + regs.byteregs[regah] = 1; + } + break; + case 4: + case 5: //format track + cf = 0; regs.byteregs[regah] = 0; + break; + case 8: //get drive parameters + if (disk[drivenum].inserted) { + cf = 0; regs.byteregs[regah] = 0; + regs.byteregs[regch] = disk[drivenum].cyls - 1; + regs.byteregs[regcl] = disk[drivenum].sects & 63; + regs.byteregs[regcl] = regs.byteregs[regcl] + (disk[drivenum].cyls / 256) * 64; + regs.byteregs[regdh] = disk[drivenum].heads - 1; + //segregs[reges] = 0; regs.wordregs[regdi] = 0x7C0B; //floppy parameter table + if (drivenum < 2) { + regs.byteregs[regbl] = 4; //else regs.byteregs[regbl] = 0; + regs.byteregs[regdl] = 2; + } else regs.byteregs[regdl] = hdcount; + } else { + cf = 1; regs.byteregs[regah] = 0xAA; + } + break; + default: + cf = 1; + } + lastdiskah[drivenum] = regs.byteregs[regah]; + lastdiskcf[drivenum] = cf; + if (regs.byteregs[regdl] & 0x80) write86(0x474, regs.byteregs[regah]); +} + +void initDisk(char * filename) { + int len=emu_FileSize(filename); + file = emu_FileOpen(filename); + if (len) { + bootdrive = 0x80; + insertdisk(0x80); + hdcount = 1; + } + else { + bootdrive = 0xFF; + emu_FileClose(); + file = NULL; + } +} + diff --git a/MCUME_pico/pico8086/emu.h b/MCUME_pico/pico8086/emu.h new file mode 100644 index 0000000..18e3738 --- /dev/null +++ b/MCUME_pico/pico8086/emu.h @@ -0,0 +1,159 @@ +//Uncomment MEGA define if using a Mega 2560, otherwise leave undefined if using a Teensy 3.6 +//#define MEGA + +extern "C" { +#include "iopins.h" +#include "emuapi.h" +} + +#define NATIVE_RAM (0x20000) // 128k total +#define NATIVE_START 0UL +#ifdef HAS_PSRAM +#define RAM_SIZE (0xA0000) // 640k total +#else +#define RAM_SIZE (0x24000) // 128+16k total +#endif + + +#define ROM_READ(a,b) a[b] + + +//#define INCLUDE_ROM_BASIC + + +//#define BOOT_FDD +#define BOOT_HDD +//#define BOOT_BASIC + +//#define FDD_180K +//#define FDD_320K +//#define FDD_360K +//#define FDD_720K +//#define FDD_122M +//#define FDD_144M + + +#define BAUD_RATE 1000000 + +//#define USE_NETWORKING +//#define USE_PARALLEL + +//#define PROFILING + +// END ARDUINO86 USER CONFIGURABLE OPTIONS + +#define regax 0 +#define regcx 1 +#define regdx 2 +#define regbx 3 +#define regsp 4 +#define regbp 5 +#define regsi 6 +#define regdi 7 +#define reges 0 +#define regcs 1 +#define regss 2 +#define regds 3 + +#define regal 0 +#define regah 1 +#define regcl 2 +#define regch 3 +#define regdl 4 +#define regdh 5 +#define regbl 6 +#define regbh 7 + +#define StepIP(x) ip+=x +#define getmem8(x,y) read86(segbase(x)+(uint32_t)y) +//#define getmem16(x,y) (read86(segbase(x)+y) | ((uint16_t)read86(segbase(x)+y+1)<<8)) +#define getmem16(x,y) readw86(segbase(x)+(uint32_t)y) +#define putmem8(x,y,z) write86(segbase(x)+(uint32_t)y, z) +//#define putmem16(x,y,z) write86(segbase(x)+y, ((z)&0xFF)); write86(segbase(x)+y+1, (((z)>>8)&0xFF)) +#define putmem16(x,y,z) writew86(segbase(x)+(uint32_t)y, z) +#define signext(value) ((((uint16_t)value&0x80)*0x1FE)|(uint16_t)value) +#define signext32(value) ((((uint32_t)value&0x8000)*0x1FFFE)|(uint32_t)value) +#define getreg16(regid) regs.wordregs[regid] +#define getreg8(regid) regs.byteregs[byteregtable[regid]] +#define putreg16(regid, writeval) regs.wordregs[regid] = writeval +#define putreg8(regid, writeval) regs.byteregs[byteregtable[regid]] = writeval +#define getsegreg(regid) segregs[regid] +#define putsegreg(regid, writeval) segregs[regid] = writeval +#define segbase(x) ((uint32_t)x<<4) + +#define makeflagsword() (2 | (uint16_t)cf | ((uint16_t)pf << 2) | ((uint16_t)af << 4) | ((uint16_t)zf << 6) \ + | ((uint16_t)sf << 7) | ((uint16_t)tf << 8) | ((uint16_t)ifl << 9) | ((uint16_t)df << 10) | ((uint16_t)of << 11)) + +#define decodeflagsword(x) {\ + temp16 = x;\ + cf = temp16 & 1;\ + pf = (temp16 >> 2) & 1;\ + af = (temp16 >> 4) & 1;\ + zf = (temp16 >> 6) & 1;\ + sf = (temp16 >> 7) & 1;\ + tf = (temp16 >> 8) & 1;\ + ifl = (temp16 >> 9) & 1;\ + df = (temp16 >> 10) & 1;\ + of = (temp16 >> 11) & 1;\ +} + + + +//#define RAM_write(a,v) { +//} + +//#define RAM_read(a,v) { +//} + + +void setup_memory(); +void setup_timer(); +uint8_t insertdisk(uint8_t drivenum); +void reset86(); +void exec86(uint32_t execloops); +uint8_t read86(uint32_t addr32); +void write86(uint32_t addr32, uint8_t value); +void doirq(uint8_t irqnum); +void incsends(); +void init_display(); +void write_video(uint16_t addr); +void clear_display(); +void palettereset(); +void display_CSIP(); +void ps2poll(); +void setup_ps2(uint8_t data_pin, uint8_t irq_pin); +void video_init(); +uint8_t VRAM_read(uint32_t addr32); +void VRAM_write(uint32_t addr32, uint8_t value); +void setup_ps2(uint8_t data_pin, uint8_t irq_pin); +void ps2poll(); +void out8253 (uint16_t portnum, uint8_t value); +uint8_t in8253 (uint16_t portnum); +void init8259(); +void out8259(uint16_t portnum, uint8_t value); +uint8_t in8259(uint16_t portnum); + +extern uint8_t port3da; + +void initDisk(char * filename); +void init8253(); +void net_init(); +void net_loop(); +void net_handler(); +uint8_t cached_read(uint32_t addr32); +void cached_write(uint32_t addr32, uint8_t value); +void cache_init(); + +uint8_t net_read_ram(uint32_t addr32); +void diskhandler(); + +//extern uint8_t SPI_RAM_pins[8]; +extern uint8_t net_mac[6]; +extern uint8_t bufSerial[1600]; +void outByte(uint8_t cc); + +extern struct i8253_s i8253; +union _bytewordregs_{ + uint16_t wordregs[8]; + uint8_t byteregs[8]; +} ; diff --git a/MCUME_pico/pico8086/emuapi.cpp b/MCUME_pico/pico8086/emuapi.cpp new file mode 100644 index 0000000..bcf2fac --- /dev/null +++ b/MCUME_pico/pico8086/emuapi.cpp @@ -0,0 +1,1274 @@ +#define KEYMAP_PRESENT 1 + +#define PROGMEM + +#include "pico.h" +#include "pico/stdlib.h" +#include "hardware/adc.h" +#include +#include + +extern "C" { + #include "emuapi.h" + #include "iopins.h" +} + +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) +// Dual display config, initialize TFT +#include "tft_t_dma.h" +static TFT_T_DMA tft; +#else +// Non Dual display config +#ifdef USE_VGA +#include "vga_t_dma.h" +#else +#include "tft_t_dma.h" +#endif +extern TFT_T_DMA tft; +#endif + + +#define MAX_FILES 64 +#define MAX_FILENAME_SIZE 24 +#define MAX_MENULINES 9 +#define TEXT_HEIGHT 16 +#define TEXT_WIDTH 8 +#define MENU_FILE_XOFFSET (6*TEXT_WIDTH) +#define MENU_FILE_YOFFSET (2*TEXT_HEIGHT) +#define MENU_FILE_W (MAX_FILENAME_SIZE*TEXT_WIDTH) +#define MENU_FILE_H (MAX_MENULINES*TEXT_HEIGHT) +#define MENU_FILE_BGCOLOR RGBVAL16(0x00,0x00,0x40) +#define MENU_JOYS_YOFFSET (12*TEXT_HEIGHT) +#define MENU_VBAR_XOFFSET (0*TEXT_WIDTH) +#define MENU_VBAR_YOFFSET (MENU_FILE_YOFFSET) + +#define MENU_TFT_XOFFSET (MENU_FILE_XOFFSET+MENU_FILE_W+8) +#define MENU_TFT_YOFFSET (MENU_VBAR_YOFFSET+32) +#define MENU_VGA_XOFFSET (MENU_FILE_XOFFSET+MENU_FILE_W+8) +#define MENU_VGA_YOFFSET (MENU_VBAR_YOFFSET+MENU_FILE_H-32-37) + + + +static char romspath[64]; +static int nbFiles=0; +static int curFile=0; +static int topFile=0; +static char selection[MAX_FILENAME_SIZE+1]=""; +static char files[MAX_FILES][MAX_FILENAME_SIZE]; +static bool menuRedraw=true; + +#ifdef PICOMPUTER +static const unsigned short * keys; +static unsigned char keymatrix[6]; +static int keymatrix_hitrow=-1; +static bool key_fn=false; +static bool key_alt=false; +static uint32_t keypress_t_ms=0; +static uint32_t last_t_ms=0; +static uint32_t hundred_ms_cnt=0; +static bool ledflash_toggle=false; +#endif +static int keyMap; + +static bool joySwapped = false; +static uint16_t bLastState; +static int xRef; +static int yRef; +static uint8_t usbnavpad=0; + +static bool menuOn=true; + + + +/******************************** + * Generic output and malloc +********************************/ +void emu_printf(char * text) +{ + printf("%s\n",text); +} + +void emu_printf(int val) +{ + printf("%d\n",val); +} + +void emu_printi(int val) +{ + printf("%d\n",val); +} + +void emu_printh(int val) +{ + printf("0x%.8\n",val); +} + +static int malbufpt = 0; +static char malbuf[EXTRA_HEAP]; + +void * emu_Malloc(int size) +{ + void * retval = malloc(size); + if (!retval) { + emu_printf("failled to allocate"); + emu_printf(size); + emu_printf("fallback"); + if ( (malbufpt+size) < sizeof(malbuf) ) { + retval = (void *)&malbuf[malbufpt]; + malbufpt += size; + } + else { + emu_printf("failure to allocate"); + } + } + else { + emu_printf("could allocate dynamic "); + emu_printf(size); + } + + return retval; +} + +void * emu_MallocI(int size) +{ + void * retval = NULL; + + if ( (malbufpt+size) < sizeof(malbuf) ) { + retval = (void *)&malbuf[malbufpt]; + malbufpt += size; + emu_printf("could allocate static "); + emu_printf(size); + } + else { + emu_printf("failure to allocate"); + } + + return retval; +} +void emu_Free(void * pt) +{ + free(pt); +} + +void emu_drawText(unsigned short x, unsigned short y, const char * text, unsigned short fgcolor, unsigned short bgcolor, int doublesize) +{ + tft.drawText(x, y, text, fgcolor, bgcolor, doublesize?true:false); +} + + +/******************************** + * OSKB handling +********************************/ +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) +// On screen keyboard position +#define KXOFF 28 //64 +#define KYOFF 96 +#define KWIDTH 11 //22 +#define KHEIGHT 3 + +static bool oskbOn = false; +static int cxpos = 0; +static int cypos = 0; +static int oskbMap = 0; +static uint16_t oskbBLastState = 0; + +static void lineOSKB2(int kxoff, int kyoff, char * str, int row) +{ + char c[2] = {'A',0}; + const char * cpt = str; + for (int i=0; i.,SP ", 2); + if (oskbMap == 0) { + lineOSKB(KXOFF,KYOFF, keylables_map1_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map1_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map1_2, 2); + } + else if (oskbMap == 1) { + lineOSKB(KXOFF,KYOFF, keylables_map2_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map2_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map2_2, 2); + } + else { + lineOSKB(KXOFF,KYOFF, keylables_map3_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map3_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map3_2, 2); + } +} + +void toggleOskb(bool forceoff) { + if (forceoff) oskbOn=true; + if (oskbOn) { + oskbOn = false; + tft.fillScreenNoDma(RGBVAL16(0x00,0x00,0x00)); + tft.drawTextNoDma(0,32, "Press USER2 to toggle onscreen keyboard.", RGBVAL16(0xff,0xff,0xff), RGBVAL16(0x00,0x00,0x00), true); + } else { + oskbOn = true; + tft.fillScreenNoDma(RGBVAL16(0x00,0x00,0x00)); + tft.drawTextNoDma(0,32, " Press USER2 to exit onscreen keyboard. ", RGBVAL16(0xff,0xff,0xff), RGBVAL16(0x00,0x00,0x00), true); + tft.drawTextNoDma(0,64, " (USER1 to toggle between keymaps) ", RGBVAL16(0x00,0xff,0xff), RGBVAL16(0x00,0x00,0xff), true); + tft.drawRectNoDma(KXOFF,KYOFF, 22*8, 3*16, RGBVAL16(0x00,0x00,0xFF)); + drawOskb(); + } +} + +static int handleOskb(void) +{ + int retval = 0; + + uint16_t bClick = bLastState & ~oskbBLastState; + oskbBLastState = bLastState; + /* + static const char * digits = "0123456789ABCDEF"; + char buf[5] = {0,0,0,0,0}; + int val = bClick; + buf[0] = digits[(val>>12)&0xf]; + buf[1] = digits[(val>>8)&0xf]; + buf[2] = digits[(val>>4)&0xf]; + buf[3] = digits[val&0xf]; + tft.drawTextNoDma(0,KYOFF+ 64,buf,RGBVAL16(0x00,0x00,0x00),RGBVAL16(0xFF,0xFF,0xFF),1); + */ + if (bClick & MASK_KEY_USER2) + { + toggleOskb(false); + } + if (oskbOn) + { + bool updated = true; + if (bClick & MASK_KEY_USER1) + { + oskbMap += 1; + if (oskbMap == 3) oskbMap = 0; + } + else if (bClick & MASK_JOY2_LEFT) + { + cxpos++; + if (cxpos >= KWIDTH) cxpos = 0; + } + else if (bClick & MASK_JOY2_RIGHT) + { + cxpos--; + if (cxpos < 0) cxpos = KWIDTH-1; + } + else if (bClick & MASK_JOY2_DOWN) + { + cypos++; + if (cypos >= KHEIGHT) cypos = 0; + } + else if (bClick & MASK_JOY2_UP) + { + cypos--; + if (cypos < 0) cypos = KHEIGHT-1; + } + else if (oskbBLastState & MASK_JOY2_BTN) + { + retval = cypos*KWIDTH+cxpos+1; + if (retval) { + retval--; + //if (retval & 1) retval = key_map2[retval>>1]; + //else retval = key_map1[retval>>1]; + if (oskbMap == 0) { + retval = key_map1[retval]; + } + else if (oskbMap == 1) { + retval = key_map2[retval]; + } + else { + retval = key_map3[retval]; + } + //if (retval) { toggleOskb(true); updated=false; }; + } + } + else { + updated=false; + } + if (updated) drawOskb(); + } + + return retval; +} +#endif + +/******************************** + * Input and keyboard +********************************/ +int emu_ReadAnalogJoyX(int min, int max) +{ + adc_select_input(0); + int val = adc_read(); +#if INVX + val = 4095 - val; +#endif + val = val-xRef; + val = ((val*140)/100); + if ( (val > -512) && (val < 512) ) val = 0; + val = val+2048; + return (val*(max-min))/4096; +} + +int emu_ReadAnalogJoyY(int min, int max) +{ + adc_select_input(1); + int val = adc_read(); +#if INVY + val = 4095 - val; +#endif + val = val-yRef; + val = ((val*120)/100); + if ( (val > -512) && (val < 512) ) val = 0; + //val = (val*(max-min))/4096; + val = val+2048; + //return val+(max-min)/2; + return (val*(max-min))/4096; +} + + +static uint16_t readAnalogJoystick(void) +{ + uint16_t joysval = 0; +#ifdef PIN_JOY2_A1X + int xReading = emu_ReadAnalogJoyX(0,256); + if (xReading > 128) joysval |= MASK_JOY2_LEFT; + else if (xReading < 128) joysval |= MASK_JOY2_RIGHT; + + int yReading = emu_ReadAnalogJoyY(0,256); + if (yReading < 128) joysval |= MASK_JOY2_UP; + else if (yReading > 128) joysval |= MASK_JOY2_DOWN; +#endif + // First joystick +#if INVY +#ifdef PIN_JOY2_1 + if ( !gpio_get(PIN_JOY2_1) ) joysval |= MASK_JOY2_DOWN; +#endif +#ifdef PIN_JOY2_2 + if ( !gpio_get(PIN_JOY2_2) ) joysval |= MASK_JOY2_UP; +#endif +#else +#ifdef PIN_JOY2_1 + if ( !gpio_get(PIN_JOY2_1) ) joysval |= MASK_JOY2_UP; +#endif +#ifdef PIN_JOY2_2 + if ( !gpio_get(PIN_JOY2_2) ) joysval |= MASK_JOY2_DOWN; +#endif +#endif +#if INVX +#ifdef PIN_JOY2_3 + if ( !gpio_get(PIN_JOY2_3) ) joysval |= MASK_JOY2_LEFT; +#endif +#ifdef PIN_JOY2_4 + if ( !gpio_get(PIN_JOY2_4) ) joysval |= MASK_JOY2_RIGHT; +#endif +#else +#ifdef PIN_JOY2_3 + if ( !gpio_get(PIN_JOY2_3) ) joysval |= MASK_JOY2_RIGHT; +#endif +#ifdef PIN_JOY2_4 + if ( !gpio_get(PIN_JOY2_4) ) joysval |= MASK_JOY2_LEFT; +#endif +#endif +#ifdef PIN_JOY2_BTN + joysval |= (gpio_get(PIN_JOY2_BTN) ? 0 : MASK_JOY2_BTN); +#endif + + return (joysval); +} + + +int emu_SwapJoysticks(int statusOnly) { + if (!statusOnly) { + if (joySwapped) { + joySwapped = false; + } + else { + joySwapped = true; + } + } + return(joySwapped?1:0); +} + +int emu_GetPad(void) +{ + return(bLastState/*|((joySwapped?1:0)<<7)*/); +} + +int emu_ReadKeys(void) +{ + uint16_t retval; + uint16_t j1 = readAnalogJoystick(); + uint16_t j2 = 0; + + // Second joystick +#if INVY +#ifdef PIN_JOY1_1 + if ( !gpio_get(PIN_JOY1_1) ) j2 |= MASK_JOY2_DOWN; +#endif +#ifdef PIN_JOY1_2 + if ( !gpio_get(PIN_JOY1_2) ) j2 |= MASK_JOY2_UP; +#endif +#else +#ifdef PIN_JOY1_1 + if ( !gpio_get(PIN_JOY1_1) ) j2 |= MASK_JOY2_UP; +#endif +#ifdef PIN_JOY1_2 + if ( !gpio_get(PIN_JOY1_2) ) j2 |= MASK_JOY2_DOWN; +#endif +#endif +#if INVX +#ifdef PIN_JOY1_3 + if ( !gpio_get(PIN_JOY1_3) ) j2 |= MASK_JOY2_LEFT; +#endif +#ifdef PIN_JOY1_4 + if ( !gpio_get(PIN_JOY1_4) ) j2 |= MASK_JOY2_RIGHT; +#endif +#else +#ifdef PIN_JOY1_3 + if ( !gpio_get(PIN_JOY1_3) ) j2 |= MASK_JOY2_RIGHT; +#endif +#ifdef PIN_JOY1_4 + if ( !gpio_get(PIN_JOY1_4) ) j2 |= MASK_JOY2_LEFT; +#endif +#endif +#ifdef PIN_JOY1_BTN + if ( !gpio_get(PIN_JOY1_BTN) ) j2 |= MASK_JOY2_BTN; +#endif + + + if (joySwapped) { + retval = ((j1 << 8) | j2); + } + else { + retval = ((j2 << 8) | j1); + } + + if (usbnavpad & MASK_JOY2_UP) retval |= MASK_JOY2_UP; + if (usbnavpad & MASK_JOY2_DOWN) retval |= MASK_JOY2_DOWN; + if (usbnavpad & MASK_JOY2_LEFT) retval |= MASK_JOY2_LEFT; + if (usbnavpad & MASK_JOY2_RIGHT) retval |= MASK_JOY2_RIGHT; + if (usbnavpad & MASK_JOY2_BTN) retval |= MASK_JOY2_BTN; + +#ifdef PIN_KEY_USER1 + if ( !gpio_get(PIN_KEY_USER1) ) retval |= MASK_KEY_USER1; +#endif +#ifdef PIN_KEY_USER2 + if ( !gpio_get(PIN_KEY_USER2) ) retval |= MASK_KEY_USER2; +#endif +#ifdef PIN_KEY_USER3 + if ( !gpio_get(PIN_KEY_USER3) ) retval |= MASK_KEY_USER3; +#endif +#ifdef PIN_KEY_USER4 + if ( !gpio_get(PIN_KEY_USER4) ) retval |= MASK_KEY_USER4; +#endif + +#ifdef PICOMPUTER + keymatrix_hitrow = -1; + unsigned char row; + unsigned short cols[6]={1,2,3,4,5,14}; + unsigned char keymatrixtmp[6]; + + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] = row; + } + +#ifdef MULTI_DEBOUNCE + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] |= row; + } + + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] |= row; + } +#endif + +#ifdef SWAP_ALT_DEL + // Swap ALT and DEL + unsigned char alt = keymatrixtmp[0] & 0x02; + unsigned char del = keymatrixtmp[5] & 0x20; + keymatrixtmp[0] &= ~0x02; + keymatrixtmp[5] &= ~0x20; + if (alt) keymatrixtmp[5] |= 0x20; + if (del) keymatrixtmp[0] |= 0x02; +#endif + + bool alt_pressed=false; + if ( keymatrixtmp[5] & 0x20 ) {alt_pressed=true; keymatrixtmp[5] &= ~0x20;}; + + for (int i=0;i<6;i++){ + row = keymatrixtmp[i]; + if (row) keymatrix_hitrow=i; + keymatrix[i] = row; + } + + //6,9,15,8,7,22 +#if INVX + if ( row & 0x2 ) retval |= MASK_JOY2_LEFT; + if ( row & 0x1 ) retval |= MASK_JOY2_RIGHT; +#else + if ( row & 0x1 ) retval |= MASK_JOY2_LEFT; + if ( row & 0x2 ) retval |= MASK_JOY2_RIGHT; +#endif +#if INVY + if ( row & 0x8 ) retval |= MASK_JOY2_DOWN; + if ( row & 0x4 ) retval |= MASK_JOY2_UP; +#else + if ( row & 0x4 ) retval |= MASK_JOY2_DOWN; + if ( row & 0x8 ) retval |= MASK_JOY2_UP; +#endif + if ( row & 0x10 ) retval |= MASK_JOY2_BTN; + + // Handle LED flash + uint32_t time_ms=to_ms_since_boot (get_absolute_time()); + if ((time_ms-last_t_ms) > 100) { + last_t_ms = time_ms; + if (ledflash_toggle == false) { + ledflash_toggle = true; + } + else { + ledflash_toggle = false; + } + } + + if ( alt_pressed ) { + if (key_fn == false) + { + // Release to Press transition + if (hundred_ms_cnt == 0) { + keypress_t_ms=time_ms; + hundred_ms_cnt += 1; // 1 + } + else { + hundred_ms_cnt += 1; // 2 + if (hundred_ms_cnt >= 2) + { + hundred_ms_cnt = 0; + /* + if ( (time_ms-keypress_t_ms) < 500) + { + if (key_alt == false) + { + key_alt = true; + } + else + { + key_alt = false; + } + } + */ + } + } + } + else { + // Keep press + if (hundred_ms_cnt == 1) { + if ((to_ms_since_boot (get_absolute_time())-keypress_t_ms) > 2000) + { + if (key_alt == false) + { + key_alt = true; + } + else + { + key_alt = false; + } + hundred_ms_cnt = 0; + } + } + } + key_fn = true; + } + else { + key_fn = false; + } + + // Handle LED + if (key_alt == true) { + gpio_put(KLED, (ledflash_toggle?1:0)); + } + else { + if (key_fn == true) { + gpio_put(KLED, 1); + } + else { + gpio_put(KLED, 0); + } + } + + if ( key_fn ) retval |= MASK_KEY_USER2; + if ( ( key_fn ) && (keymatrix[0] == 0x02 )) retval |= MASK_KEY_USER1; +#endif + + //Serial.println(retval,HEX); + + if ( ((retval & (MASK_KEY_USER1+MASK_KEY_USER2)) == (MASK_KEY_USER1+MASK_KEY_USER2)) + || (retval & MASK_KEY_USER4 ) ) + { + } + +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) + if (oskbOn) { + retval |= MASK_OSKB; + } +#endif + + return (retval); +} + +unsigned short emu_DebounceLocalKeys(void) +{ + uint16_t bCurState = emu_ReadKeys(); + uint16_t bClick = bCurState & ~bLastState; + bLastState = bCurState; + + return (bClick); +} + +int emu_ReadI2CKeyboard(void) { + int retval=0; +#ifdef PICOMPUTER + if (key_alt) { + keys = (const unsigned short *)key_map3; + } + else if (key_fn) { + keys = (const unsigned short *)key_map2; + } + else { + keys = (const unsigned short *)key_map1; + } + if (keymatrix_hitrow >=0 ) { + unsigned short match = ((unsigned short)keymatrix_hitrow<<8) | keymatrix[keymatrix_hitrow]; + for (int i=0; i=0) { + menuRedraw=true; + curFile -= 9; + } else if (curFile!=0) { + menuRedraw=true; + curFile--; + } + } + else if ( (bClick & MASK_JOY2_DOWN) || (bClick & MASK_JOY1_DOWN) ) { + if ((curFile<(nbFiles-1)) && (nbFiles)) { + curFile++; + menuRedraw=true; + } + } + else if ( (bClick & MASK_JOY2_LEFT) || (bClick & MASK_JOY1_LEFT) ) { + if ((curFile<(nbFiles-9)) && (nbFiles)) { + curFile += 9; + menuRedraw=true; + } + else if ((curFile<(nbFiles-1)) && (nbFiles)) { + curFile++; + menuRedraw=true; + } + } + else if ( (bClick & MASK_KEY_USER2) ) { + emu_SwapJoysticks(0); + menuRedraw=true; + } + + if (menuRedraw && nbFiles) { + int fileIndex = 0; + tft.drawRectNoDma(MENU_FILE_XOFFSET,MENU_FILE_YOFFSET, MENU_FILE_W, MENU_FILE_H, MENU_FILE_BGCOLOR); +// if (curFile <= (MAX_MENULINES/2-1)) topFile=0; +// else topFile=curFile-(MAX_MENULINES/2); + if (curFile <= (MAX_MENULINES-1)) topFile=0; + else topFile=curFile-(MAX_MENULINES/2); + + //Serial.print("curfile: "); + //Serial.println(curFile); + //Serial.print("topFile: "); + //Serial.println(topFile); + + int i=0; + while (i=nbFiles) { + // no more files + break; + } + char * filename = &files[fileIndex][0]; + if (fileIndex >= topFile) { + if ((i+topFile) < nbFiles ) { + if ((i+topFile)==curFile) { + tft.drawTextNoDma(MENU_FILE_XOFFSET,i*TEXT_HEIGHT+MENU_FILE_YOFFSET, filename, RGBVAL16(0xff,0xff,0x00), RGBVAL16(0xff,0x00,0x00), true); + strcpy(selection,filename); + } + else { + tft.drawTextNoDma(MENU_FILE_XOFFSET,i*TEXT_HEIGHT+MENU_FILE_YOFFSET, filename, RGBVAL16(0xff,0xff,0xff), MENU_FILE_BGCOLOR, true); + } + } + i++; + } + fileIndex++; + } + + + tft.drawTextNoDma(48,MENU_JOYS_YOFFSET+8, (emu_SwapJoysticks(1)?(char*)"SWAP=1":(char*)"SWAP=0"), RGBVAL16(0x00,0xff,0xff), RGBVAL16(0x00,0x00,0xff), false); + menuRedraw=false; + } + + return (action); +} + +bool menuActive(void) +{ + return (menuOn); +} + +void toggleMenu(bool on) { + if (on) { + menuOn = true; + backgroundMenu(); + } else { + menuOn = false; + } +} + +char * menuSelection(void) +{ + return (selection); +} + + +/******************************** + * File IO +********************************/ +int emu_FileOpen(char * filename) +{ + int retval = 0; + + char filepath[80]; + strcpy(filepath, romspath); + strcat(filepath, "/"); + strcat(filepath, filename); + emu_printf("FileOpen..."); + emu_printf(filepath); + if( !(f_open(&file, filepath, FA_READ)) ) { + retval = 1; + } + else { + emu_printf("FileOpen failed"); + } + return (retval); +} + +int emu_FileRead(char * buf, int size) +{ + unsigned char buffer[256]; + int remaining = size; + int byteread = 0; + unsigned int retval=0; + if (size < 256) { + if( !(f_read (&file, buffer, size, &retval)) ) + if (retval>0) { + memcpy(buf,buffer,retval); + byteread += retval; + } + } + else { + while (remaining>0) { + if( !(f_read (&file, buffer, 256, &retval)) ) + //f_read (&file, buffer, 256, &retval); + if (retval>0) { + //emu_printi(retval); + memcpy(buf,buffer,retval); + buf += retval; + byteread += retval; + remaining -= retval; + } + else { + break; + } + } + } + return byteread; +} + +unsigned char emu_FileGetc(void) { + unsigned char c; + unsigned int retval=0; + if( !(f_read (&file, &c, 1, &retval)) ) + if (retval != 1) { + emu_printf("emu_FileGetc failed"); + } + return c; +} + +void emu_FileClose(void) +{ + f_close(&file); +} + +int emu_FileSize(char * filename) +{ + int filesize=0; + char filepath[80]; + strcpy(filepath, romspath); + strcat(filepath, "/"); + strcat(filepath, filename); + emu_printf("FileSize..."); + emu_printf(filepath); + FILINFO entry; + f_stat(filepath, &entry); + filesize = entry.fsize; + return(filesize); +} + +int emu_FileSeek(int seek) +{ + f_lseek(&file, seek); + return (seek); +} + +int emu_FileTell(void) +{ + return (f_tell(&file)); +} + +int emu_LoadFile(char * filename, char * buf, int size) +{ + int filesize = 0; + + char filepath[80]; + strcpy(filepath, romspath); + strcat(filepath, "/"); + strcat(filepath, filename); + emu_printf("LoadFile..."); + emu_printf(filepath); + if( !(f_open(&file, filepath, FA_READ)) ) { + filesize = f_size(&file); + emu_printf(filesize); + if (size >= filesize) + { + unsigned int retval=0; + if( (f_read (&file, buf, filesize, &retval)) ) { + emu_printf("File read failed"); + } + } + f_close(&file); + } + + return(filesize); +} + + + + +/******************************** + * Initialization +********************************/ +void emu_init(void) +{ + // Dual display config, initialize TFT +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) + tft.begin(); +#endif + + sd_init_driver(); + FRESULT fr = f_mount(&fatfs, "0:", 1); + + strcpy(romspath,ROMSDIR); + nbFiles = readNbFiles(romspath); + + emu_printf("SD initialized, files found: "); + emu_printi(nbFiles); + + emu_InitJoysticks(); +#ifdef SWAP_JOYSTICK + joySwapped = true; +#else + joySwapped = false; +#endif + +#ifdef PICOMPUTER + // Flip screen if UP pressed + if (emu_ReadKeys() & MASK_JOY2_UP) + { +#ifdef PICOMPUTERMAX + tft.flipscreen(true); +#else + tft.flipscreen(true); +#endif + } + else + { +#ifdef PICOMPUTERMAX + tft.flipscreen(false); +#else + tft.flipscreen(false); +#endif + } +#endif + + toggleMenu(true); +} + + +void emu_start(void) +{ + usbnavpad = 0; + + keyMap = 0; +} diff --git a/MCUME_pico/pico8086/emuapi.h b/MCUME_pico/pico8086/emuapi.h new file mode 100644 index 0000000..28b100c --- /dev/null +++ b/MCUME_pico/pico8086/emuapi.h @@ -0,0 +1,147 @@ +#ifndef EMUAPI_H +#define EMUAPI_H + +#include "platform_config.h" + +#define CUSTOM_SND 1 +//#define TIMER_REND 1 + +#define EXTRA_HEAP 0x10 + +// Title: < > +#define TITLE " 8086 PC Emulator" +#define ROMSDIR "pc" + +#define emu_Init(ROM) {apc_Start(ROM); apc_Init(); } +#define emu_Step(x) { apc_Step(); } +#define emu_Input(x) { apc_Input(x); } + +#define PALETTE_SIZE 256 +#define VID_FRAME_SKIP 0x0 +#define TFT_VBUFFER_YCROP 0 +#define SINGLELINE_RENDERING 1 + +#define ACTION_NONE 0 +#define ACTION_MAXKBDVAL 12 +#define ACTION_EXITKBD 128 +#define ACTION_RUNTFT 129 +#define ACTION_RUNVGA 130 + +#ifdef KEYMAP_PRESENT + +#define keylables_map1_0 (char *)"qwertyuiop\x1a" +#define keylables_map1_1 (char *)" asdfghjkl\x19" +#define keylables_map1_2 (char *)" zxcvbnm.\x10 " +const unsigned short key_map1[] = { + 'Q','W','E','R','T','Y','U','I','O','P',157, + 0,'A','S','D','F','G','H','J','K','L',0x0D, + 0,'Z','X','C','V','B','N','M','.',' ', + 145,157,29,17 + }; + +#define keylables_map2_0 (char *)"1234567890 " +#define keylables_map2_1 (char *)" !@#$%+&*- " +#define keylables_map2_2 (char *)" ()?/\"<>,: " +const unsigned short key_map2[] = { + '1','2','3','4','5','6','7','8','9','0',0, + 0, '!','@','#','$','%','+','&','*','-','\/', + 0, '(',')','?','\/','"','<','>',',',':', + 0,0,0,0 + }; + +#define keylables_map3_0 (char *)"\x11\x12\x13\x14\x15\x16\x17\x18 " +#define keylables_map3_1 (char *)" " +#define keylables_map3_2 (char *)" ;= " +const unsigned short key_map3[] = { + 133,134,135,136,137,138,139,140,0,0,0, // function keys + 0, 0,0,0,0,0,0,0,0,0,0, + 0, 0,0,0,0,0,0,0,';','=', + 0,0,0,0 + }; + +const unsigned short matkeys[] = { + 0x020,0x120,0x220,0x320,0x420,0x408,0x308,0x208,0x108,0x008,0x002, // row 1 + 0x510,0x010,0x110,0x210,0x310,0x410,0x401,0x301,0x201,0x101,0x001, // row 2 + 0x520,0x102,0x202,0x302,0x402,0x404,0x304,0x204,0x104,0x004, // row 3 + 0x508,0x501,0x502,0x504 }; // cursor keys + +#endif + + +#define MASK_JOY2_RIGHT 0x0001 +#define MASK_JOY2_LEFT 0x0002 +#define MASK_JOY2_UP 0x0004 +#define MASK_JOY2_DOWN 0x0008 +#define MASK_JOY2_BTN 0x0010 +#define MASK_KEY_USER1 0x0020 +#define MASK_KEY_USER2 0x0040 +#define MASK_KEY_USER3 0x0080 +#define MASK_JOY1_RIGHT 0x0100 +#define MASK_JOY1_LEFT 0x0200 +#define MASK_JOY1_UP 0x0400 +#define MASK_JOY1_DOWN 0x0800 +#define MASK_JOY1_BTN 0x1000 +#define MASK_KEY_USER4 0x2000 +#define MASK_OSKB 0x8000 + + + +extern void emu_init(void); +extern void emu_start(void); +extern void emu_resetSD(void); + +extern void emu_printf(char * text); +extern void emu_printi(int val); +extern void * emu_Malloc(int size); +extern void emu_Free(void * pt); + + +extern int emu_FileOpen(char * filename); +extern int emu_FileRead(char * buf, int size); +extern unsigned char emu_FileGetc(void); +extern int emu_FileSeek(int seek); +extern void emu_FileClose(void); +extern int emu_FileSize(char * filename); +extern int emu_LoadFile(char * filename, char * buf, int size); +extern int emu_LoadFileSeek(char * filename, char * buf, int size, int seek); +extern void emu_FileTempInit(void); +extern void emu_FileTempRead(int addr, unsigned char * val, int n); +extern void emu_FileTempWrite(int addr, unsigned char val); + +extern void emu_SetPaletteEntry(unsigned char r, unsigned char g, unsigned char b, int index); +extern void emu_DrawScreen(unsigned char * VBuf, int width, int height, int stride); +extern void emu_DrawLine(unsigned char * VBuf, int width, int height, int line); +extern void emu_DrawLine8(unsigned char * VBuf, int width, int height, int line); +extern void emu_DrawLine16(unsigned short * VBuf, int width, int height, int line); +extern void emu_DrawVsync(void); +extern int emu_FrameSkip(void); +extern void * emu_LineBuffer(int line); + +extern void emu_InitJoysticks(void); +extern int emu_SwapJoysticks(int statusOnly); +extern unsigned short emu_DebounceLocalKeys(void); +extern int emu_ReadKeys(void); +extern int emu_GetPad(void); +extern int emu_ReadAnalogJoyX(int min, int max); +extern int emu_ReadAnalogJoyY(int min, int max); +extern int emu_ReadI2CKeyboard(void); +extern unsigned char emu_ReadI2CKeyboard2(int row); +extern void emu_KeyboardOnUp(int keymodifer, int key); +extern void emu_KeyboardOnDown(int keymodifer, int key); +extern int emu_oskbActive(void); + +extern void emu_sndPlaySound(int chan, int volume, int freq); +extern void emu_sndPlayBuzz(int size, int val); +extern void emu_sndInit(); +extern void emu_resetus(void); +extern int emu_us(void); + +extern int emu_setKeymap(int index); + +extern void emu_FileTempInit(void); +extern void emu_FileTempRead(int addr, unsigned char * val, int n); +extern void emu_FileTempWrite(int addr, unsigned char val); +extern void emu_printh(int val); + + +#endif diff --git a/MCUME_pico/pico8086/font.h b/MCUME_pico/pico8086/font.h new file mode 100644 index 0000000..1edec9d --- /dev/null +++ b/MCUME_pico/pico8086/font.h @@ -0,0 +1,264 @@ +#ifdef MEGA +#include + const uint8_t font[2048] PROGMEM = { +#else + const uint8_t font[2048] = { +#endif + 0,0,0,0,0,0,0, + 0,126,129,165,129,189,153,129, + 126,126,255,219,255,195,231,255, + 126,54,127,127,127,62,28,8, + 0,8,28,62,127,62,28,8, + 0,28,62,28,127,127,62,28, + 62,8,8,28,62,127,62,28, + 62,0,0,0,0,0,0,0, + 0,255,255,231,195,195,231,255, + 255,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,254,198,254,198,198,230,103, + 3,153,90,60,231,231,60,90, + 153,1,7,31,127,31,7,1, + 0,64,112,124,127,124,112,64, + 0,24,60,126,24,24,126,60, + 24,102,102,102,102,102,0,102, + 0,254,219,219,222,216,216,216, + 0,124,198,28,54,54,28,51, + 30,0,0,0,0,126,126,126, + 0,24,60,126,24,126,60,24, + 255,24,60,126,24,24,24,24, + 0,24,24,24,24,126,60,24, + 0,0,24,48,127,48,24,0, + 0,0,12,6,127,6,12,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,12,30,30,12,12,0,12, + 0,54,54,54,0,0,0,0, + 0,54,54,127,54,127,54,54, + 0,12,62,3,30,48,31,12, + 0,0,99,51,24,12,102,99, + 0,28,54,28,110,59,51,110, + 0,6,6,3,0,0,0,0, + 0,24,12,6,6,6,12,24, + 0,6,12,24,24,24,12,6, + 0,0,102,60,255,60,102,0, + 0,0,12,12,63,12,12,0, + 0,0,0,0,0,0,12,12, + 6,0,0,0,63,0,0,0, + 0,0,0,0,0,0,12,12, + 0,96,48,24,12,6,3,1, + 0,62,99,115,123,111,103,62, + 0,12,14,12,12,12,12,63, + 0,30,51,48,28,6,51,63, + 0,30,51,48,28,48,51,30, + 0,56,60,54,51,127,48,120, + 0,63,3,31,48,48,51,30, + 0,28,6,3,31,51,51,30, + 0,63,51,48,24,12,12,12, + 0,30,51,51,30,51,51,30, + 0,30,51,51,62,48,24,14, + 0,0,12,12,0,0,12,12, + 0,0,12,12,0,0,12,12, + 6,24,12,6,3,6,12,24, + 0,0,0,63,0,0,63,0, + 0,6,12,24,48,24,12,6, + 0,30,51,48,24,12,0,12, + 0,62,99,123,123,123,3,30, + 0,12,30,51,51,63,51,51, + 0,63,102,102,62,102,102,63, + 0,60,102,3,3,3,102,60, + 0,31,54,102,102,102,54,31, + 0,127,70,22,30,22,70,127, + 0,127,70,22,30,22,6,15, + 0,60,102,3,3,115,102,124, + 0,51,51,51,63,51,51,51, + 0,30,12,12,12,12,12,30, + 0,120,48,48,48,51,51,30, + 0,103,102,54,30,54,102,103, + 0,15,6,6,6,70,102,127, + 0,99,119,127,127,107,99,99, + 0,99,103,111,123,115,99,99, + 0,28,54,99,99,99,54,28, + 0,63,102,102,62,6,6,15, + 0,30,51,51,51,59,30,56, + 0,63,102,102,62,54,102,103, + 0,30,51,7,14,56,51,30, + 0,63,45,12,12,12,12,30, + 0,51,51,51,51,51,51,63, + 0,51,51,51,51,51,30,12, + 0,99,99,99,107,127,119,99, + 0,99,99,54,28,28,54,99, + 0,51,51,51,30,12,12,30, + 0,127,99,49,24,76,102,127, + 0,30,6,6,6,6,6,30, + 0,3,6,12,24,48,96,64, + 0,30,24,24,24,24,24,30, + 0,8,28,54,99,0,0,0, + 0,0,0,0,0,0,0,0, + 255,12,12,24,0,0,0,0, + 0,0,0,30,48,62,51,110, + 0,7,6,6,62,102,102,59, + 0,0,0,30,51,3,51,30, + 0,56,48,48,62,51,51,110, + 0,0,0,30,51,63,3,30, + 0,28,54,6,15,6,6,15, + 0,0,0,110,51,51,62,48, + 31,7,6,54,110,102,102,103, + 0,12,0,14,12,12,12,30, + 0,48,0,48,48,48,51,51, + 30,7,6,102,54,30,54,103, + 0,14,12,12,12,12,12,30, + 0,0,0,51,127,127,107,99, + 0,0,0,31,51,51,51,51, + 0,0,0,30,51,51,51,30, + 0,0,0,59,102,102,62,6, + 15,0,0,110,51,51,62,48, + 120,0,0,59,110,102,6,15, + 0,0,0,62,3,30,48,31, + 0,8,12,62,12,12,44,24, + 0,0,0,51,51,51,51,110, + 0,0,0,51,51,51,30,12, + 0,0,0,99,107,127,127,54, + 0,0,0,99,54,28,54,99, + 0,0,0,51,51,51,62,48, + 31,0,0,63,25,12,38,63, + 0,56,12,12,7,12,12,56, + 0,24,24,24,0,24,24,24, + 0,7,12,12,56,12,12,7, + 0,110,59,0,0,0,0,0, + 0,0,8,28,54,99,99,127, + 0,30,51,3,51,30,24,48, + 30,0,51,0,51,51,51,126, + 0,56,0,30,51,63,3,30, + 0,126,195,60,96,124,102,252, + 0,51,0,30,48,62,51,126, + 0,7,0,30,48,62,51,126, + 0,12,12,30,48,62,51,126, + 0,0,0,30,3,3,30,48, + 28,126,195,60,102,126,6,60, + 0,51,0,30,51,63,3,30, + 0,7,0,30,51,63,3,30, + 0,51,0,14,12,12,12,30, + 0,62,99,28,24,24,24,60, + 0,7,0,14,12,12,12,30, + 0,99,28,54,99,127,99,99, + 0,12,12,0,30,51,63,51, + 0,56,0,63,6,30,6,63, + 0,0,0,254,48,254,51,254, + 0,124,54,51,127,51,51,115, + 0,30,51,0,30,51,51,30, + 0,0,51,0,30,51,51,30, + 0,0,7,0,30,51,51,30, + 0,30,51,0,51,51,51,126, + 0,0,7,0,51,51,51,126, + 0,0,51,0,51,51,62,48, + 31,195,24,60,102,102,60,24, + 0,51,0,51,51,51,51,30, + 0,24,24,126,3,3,126,24, + 24,28,54,38,15,6,103,63, + 0,51,51,30,63,12,63,12, + 12,31,51,51,95,99,243,99, + 227,112,216,24,60,24,24,27, + 14,56,0,30,48,62,51,126, + 0,28,0,14,12,12,12,30, + 0,0,56,0,30,51,51,30, + 0,0,56,0,51,51,51,126, + 0,0,31,0,31,51,51,51, + 0,63,0,51,55,63,59,51, + 0,60,54,54,124,0,126,0, + 0,28,54,54,28,0,62,0, + 0,12,0,12,6,3,51,30, + 0,0,0,0,63,3,3,0, + 0,0,0,0,63,48,48,0, + 0,195,99,51,123,204,102,51, + 240,195,99,51,219,236,246,243, + 192,24,24,0,24,24,24,24, + 0,0,204,102,51,102,204,0, + 0,0,51,102,204,102,51,0, + 0,68,17,68,17,68,17,68, + 17,170,85,170,85,170,85,170, + 85,219,238,219,119,219,238,219, + 119,24,24,24,24,24,24,24, + 24,24,24,24,24,31,24,24, + 24,24,24,31,24,31,24,24, + 24,108,108,108,108,111,108,108, + 108,0,0,0,0,127,108,108, + 108,0,0,31,24,31,24,24, + 24,108,108,111,96,111,108,108, + 108,108,108,108,108,108,108,108, + 108,0,0,127,96,111,108,108, + 108,108,108,111,96,127,0,0, + 0,108,108,108,108,127,0,0, + 0,24,24,31,24,31,0,0, + 0,0,0,0,0,31,24,24, + 24,24,24,24,24,248,0,0, + 0,24,24,24,24,255,0,0, + 0,0,0,0,0,255,24,24, + 24,24,24,24,24,248,24,24, + 24,0,0,0,0,255,0,0, + 0,24,24,24,24,255,24,24, + 24,24,24,248,24,248,24,24, + 24,108,108,108,108,236,108,108, + 108,108,108,236,12,252,0,0, + 0,0,0,252,12,236,108,108, + 108,108,108,239,0,255,0,0, + 0,0,0,255,0,239,108,108, + 108,108,108,236,12,236,108,108, + 108,0,0,255,0,255,0,0, + 0,108,108,239,0,239,108,108, + 108,24,24,255,0,255,0,0, + 0,108,108,108,108,255,0,0, + 0,0,0,255,0,255,24,24, + 24,0,0,0,0,255,108,108, + 108,108,108,108,108,252,0,0, + 0,24,24,248,24,248,0,0, + 0,0,0,248,24,248,24,24, + 24,0,0,0,0,252,108,108, + 108,108,108,108,108,255,108,108, + 108,24,24,255,24,255,24,24, + 24,24,24,24,24,31,0,0, + 0,0,0,0,0,248,24,24, + 24,255,255,255,255,255,255,255, + 255,0,0,0,0,255,255,255, + 255,15,15,15,15,15,15,15, + 15,240,240,240,240,240,240,240, + 240,255,255,255,255,0,0,0, + 0,0,0,110,59,19,59,110, + 0,0,30,51,31,51,31,3, + 3,0,63,51,3,3,3,3, + 0,0,127,54,54,54,54,54, + 0,63,51,6,12,6,51,63, + 0,0,0,126,27,27,27,14, + 0,0,102,102,102,102,62,6, + 3,0,110,59,24,24,24,24, + 0,63,12,30,51,51,30,12, + 63,28,54,99,127,99,54,28, + 0,28,54,99,99,54,54,119, + 0,56,12,24,62,51,51,30, + 0,0,0,126,219,219,126,0, + 0,96,48,126,219,219,126,6, + 3,28,6,3,31,3,6,28, + 0,30,51,51,51,51,51,51, + 0,0,63,0,63,0,63,0, + 0,12,12,63,12,12,0,63, + 0,6,12,24,12,6,0,63, + 0,24,12,6,12,24,0,63, + 0,112,216,216,24,24,24,24, + 24,24,24,24,24,24,27,27, + 14,12,12,0,63,0,12,12, + 0,0,110,59,0,110,59,0, + 0,28,54,54,28,0,0,0, + 0,0,0,0,24,24,0,0, + 0,0,0,0,0,24,0,0, + 0,240,48,48,48,55,54,60, + 56,30,54,54,54,54,0,0, + 0,14,24,12,6,30,0,0, + 0,0,0,60,60,60,60,0, + 0,0,0,0,0,0,0,0,0 +}; + diff --git a/MCUME_pico/pico8086/i8253.cpp b/MCUME_pico/pico8086/i8253.cpp new file mode 100644 index 0000000..24cdad8 --- /dev/null +++ b/MCUME_pico/pico8086/i8253.cpp @@ -0,0 +1,119 @@ +#include +#include + +#ifdef MEGA +#include +#include +#else +#include "pico.h" +#include "pico/stdlib.h" +struct repeating_timer timer; +#endif + +#define PIT_MODE_LATCHCOUNT 0 +#define PIT_MODE_LOBYTE 1 +#define PIT_MODE_HIBYTE 2 +#define PIT_MODE_TOGGLE 3 + + +struct i8253_s { + uint16_t chandata[3]; + uint8_t accessmode[3]; + uint8_t bytetoggle[3]; + uint32_t effectivedata[3]; + float chanfreq[3]; + uint8_t active[3]; + uint16_t counter[3]; +} i8253; + +volatile uint8_t timerTick = 0; + +#ifdef MEGA +void timer_isr() { + timerTick = 1; +} +#else +static bool timer_isr(struct repeating_timer *t) { + timerTick = 1; + return true; +} +#endif + +void out8253 (uint16_t portnum, uint8_t value) { + uint8_t curbyte; + portnum &= 3; + switch (portnum) { + case 0: + case 1: + case 2: //channel data + if ( (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0; + else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1; + if (curbyte == 0) { //low byte + i8253.chandata[portnum] = (i8253.chandata[portnum] & 0xFF00) | value; + } + else { //high byte + i8253.chandata[portnum] = (i8253.chandata[portnum] & 0x00FF) | ( (uint16_t) value << 8); + } + if (i8253.chandata[portnum] == 0) i8253.effectivedata[portnum] = 65536; + else i8253.effectivedata[portnum] = i8253.chandata[portnum]; + i8253.active[portnum] = 1; + if (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) i8253.bytetoggle[portnum] = (~i8253.bytetoggle[portnum]) & 1; + //i8253.chanfreq[portnum] = (float) ( (uint32_t) ( ( (float) 1193182.0 / (float) i8253.effectivedata[portnum]) * (float) 1000.0) ); + //Serial.print("period "); Serial.println((uint32_t) ((float)1000000.0 / ( ( (float) 1193182.0 / (float) i8253.effectivedata[portnum])))); + if (portnum == 0) { + uint32_t period; + period = (uint32_t) ((float)1000000.0 / ( ( (float) 1193182.0 / (float) i8253.effectivedata[portnum]))); +#ifdef MEGA + if (period < 4000) period = 4000; //limit to 250 Hz, or the emulator just can't keep up on a Mega + //Serial.println((float)1000000.0 / (float)period); + Timer1.attachInterrupt(timer_isr, period); +#else + cancel_repeating_timer (&timer); + add_repeating_timer_us(period, timer_isr, NULL, &timer); +#endif + } + break; + case 3: //mode/command + i8253.accessmode[value>>6] = (value >> 4) & 3; + if (i8253.accessmode[value>>6] == PIT_MODE_TOGGLE) i8253.bytetoggle[value>>6] = 0; + break; + } +} + +uint8_t in8253 (uint16_t portnum) { + uint8_t curbyte; + portnum &= 3; + switch (portnum) { + case 0: + case 1: + case 2: //channel data + if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0; + else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1; + if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_LOBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 0) ) ) curbyte = 0; + else if ( (i8253.accessmode[portnum] == PIT_MODE_HIBYTE) || ( (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) && (i8253.bytetoggle[portnum] == 1) ) ) curbyte = 1; + if ( (i8253.accessmode[portnum] == 0) || (i8253.accessmode[portnum] == PIT_MODE_TOGGLE) ) i8253.bytetoggle[portnum] = (~i8253.bytetoggle[portnum]) & 1; + if (curbyte == 0) { //low byte + if (i8253.counter[portnum] < 10) i8253.counter[portnum] = i8253.chandata[portnum]; + i8253.counter[portnum] -= 10; + return ( (uint8_t) i8253.counter[portnum]); + } + else { //high byte + return ( (uint8_t) (i8253.counter[portnum] >> 8) ); + } + break; + } + return (0); +} + +void init8253() { + memset (&i8253, 0, sizeof (i8253) ); +#ifdef MEGA + Timer1.initialize(54925); + Timer1.attachInterrupt(timer_isr, 54925); +#else + add_repeating_timer_us(54925, timer_isr, NULL, &timer); +#endif + //set_port_write_redirector (0x40, 0x43, &out8253); + //set_port_read_redirector (0x40, 0x43, &in8253); +} + diff --git a/MCUME_pico/pico8086/i8259.cpp b/MCUME_pico/pico8086/i8259.cpp new file mode 100755 index 0000000..f26f2cd --- /dev/null +++ b/MCUME_pico/pico8086/i8259.cpp @@ -0,0 +1,83 @@ +/* i8259.c - emulation code for the Intel 8259 controller. + Note: This is not a very complete i8259 interrupt controller + implementation, but for the purposes of a PC, it's all we need. */ + +#include +#include + +struct structpic { + uint8_t imr; //mask register + uint8_t irr; //request register + uint8_t isr; //service register + uint8_t icwstep; //used during initialization to keep track of which ICW we're at + uint8_t icw[5]; + uint8_t intoffset; //interrupt vector offset + uint8_t priority; //which IRQ has highest priority + uint8_t autoeoi; //automatic EOI mode + uint8_t readmode; //remember what to return on read register from OCW3 + uint8_t enabled; +} i8259; + + +void init8259() { + memset((void *)&i8259, 0, sizeof(i8259)); +} + +uint8_t in8259(uint16_t portnum) { + switch (portnum & 1) { + case 0: + if (i8259.readmode==0) return(i8259.irr); else return(i8259.isr); + case 1: //read mask register + return(i8259.imr); + } + return(0); //can't get here, but the compiler bitches +} + +extern uint32_t makeupticks; +void out8259(uint16_t portnum, uint8_t value) { + uint8_t i; + switch (portnum & 1) { + case 0: + if (value & 0x10) { //begin initialization sequence + i8259.icwstep = 1; + i8259.imr = 0; //clear interrupt mask register + i8259.icw[i8259.icwstep++] = value; + return; + } + if ((value & 0x98)==8) { //it's an OCW3 + if (value & 2) i8259.readmode = value & 2; + } + if (value & 0x20) { //EOI command + for (i=0; i<8; i++) + if ((i8259.isr >> i) & 1) { + i8259.isr ^= (1 << i); + if ((i==0) && (makeupticks>0)) { makeupticks = 0; i8259.irr |= 1; } + return; + } + } + break; + case 1: + if ((i8259.icwstep==3) && (i8259.icw[1] & 2)) i8259.icwstep = 4; //single mode, so don't read ICW3 + if (i8259.icwstep<5) { i8259.icw[i8259.icwstep++] = value; return; } + //if we get to this point, this is just a new IMR value + i8259.imr = value; + break; + } +} + +uint8_t nextintr() { + uint8_t i, tmpirr; + tmpirr = i8259.irr & (~i8259.imr); //XOR request register with inverted mask register + for (i=0; i<8; i++) + if ((tmpirr >> i) & 1) { + i8259.irr ^= (1 << i); + i8259.isr |= (1 << i); + return(i8259.icw[2] + i); + } + return(0); //can't get here, but the compiler bitches +} + +void doirq(uint8_t irqnum) { + i8259.irr |= (1 << irqnum); +} + diff --git a/MCUME_pico/pico8086/keyboard_osd.h b/MCUME_pico/pico8086/keyboard_osd.h new file mode 100644 index 0000000..062eb4e --- /dev/null +++ b/MCUME_pico/pico8086/keyboard_osd.h @@ -0,0 +1,20 @@ + +#ifndef keyboard_osd_h_ +#define keyboard_osd_h_ + +extern bool virtualkeyboardIsActive(void); +extern void drawVirtualkeyboard(void); +extern void toggleVirtualkeyboard(bool keepOn); +extern void handleVirtualkeyboard(void); + +extern bool callibrationActive(void); +extern int handleCallibration(uint16_t bClick); + +extern bool menuActive(void); +extern char * menuSelection(void); +extern void toggleMenu(bool on); +extern int handleMenu(uint16_t bClick); + + +#endif + diff --git a/MCUME_pico/pico8086/network.cpp b/MCUME_pico/pico8086/network.cpp new file mode 100755 index 0000000..3c10ff5 --- /dev/null +++ b/MCUME_pico/pico8086/network.cpp @@ -0,0 +1,146 @@ + +#include +#include + +#include "emu.h" + + +#ifdef USE_ENC28J60 +#include + +byte ENC28J60::buffer[1514]; +//uint8_t net_mac[6] = { 0x90, 0xAD, 0xBE, 0xEF, 0x13, 0x37 }; +uint8_t net_mac[6] = { 0x2C, 0xFD, 0x13, 0x37, 0x13, 0x37 }; + +extern union _bytewordregs_ regs; +extern uint16_t segregs[6]; + +struct netstruct { + uint8_t enabled; + uint8_t canrecv; + uint16_t pktlen; +} net; + +void net_handler() { + uint32_t i; + uint16_t j; + //if (ethif==254) return; //networking not enabled + switch (regs.byteregs[regah]) { //function number + case 0x00: //enable packet reception + net.enabled = 1; + net.canrecv = 1; + return; + case 0x01: //send packet of CX at DS:SI + //if (verbose) { + //Serial.println("Sending packet of %u bytes.", regs.wordregs[regcx]); + //} + //sendpkt (&RAM[ ( (uint32_t) segregs[regds] << 4) + (uint32_t) regs.wordregs[regsi]], regs.wordregs[regcx]); + i = ( (uint32_t) segregs[regds] << 4) + (uint32_t) regs.wordregs[regsi]; + for (j=0; j 0) { + for (i=0; i +#include +#include "emu.h" +#include "ps2.h" + + +static uint8_t LOMEM[NATIVE_RAM]; + +#ifdef HAS_PSRAM +#include "psram_t.h" + +PSRAM_T psram = PSRAM_T(PSRAM_CS, PSRAM_MOSI, PSRAM_SCLK, PSRAM_MISO); + +#else +static uint8_t HIMEM[RAM_SIZE-NATIVE_RAM]; +#endif + +extern void write_loram(int address, uint8_t val) { + LOMEM[address] = val; +} + +extern uint8_t read_loram(int address) { + return LOMEM[address]; +} + +extern void write_hiram(int address, uint8_t val) { +#ifdef HAS_PSRAM + psram.pswrite(address,val); +#else + HIMEM[address] = val; +#endif +} + +extern uint8_t read_hiram(int address) { +#ifdef HAS_PSRAM + return (psram.psread(address)); +#else + return HIMEM[address]; +#endif +} + + + + +#define PALMULT8(x) ((x)<<5) +#define RGBVAL16(r,g,b) ( (((r>>3)&0x1f)<<11) | (((g>>2)&0x3f)<<5) | (((b>>3)&0x1f)<<0) ) + +struct i8253_s { + uint16_t chandata[3]; + uint8_t accessmode[3]; + uint8_t bytetoggle[3]; + uint32_t effectivedata[3]; + float chanfreq[3]; + uint8_t active[3]; + uint16_t counter[3]; +}; + +extern struct i8253_s i8253; + +void doirq(uint8_t irqnum); +void write86(uint32_t addr32, uint8_t value); +uint8_t read86(uint32_t addr32); + +uint8_t curkey = 0; + + + +uint8_t VRAM[16384]; + + +uint32_t updateaddrs[64]; +uint8_t updatepos = 0; + +void VRAM_write(uint32_t addr32, uint8_t value) { + + if (addr32 < 16384) { + VRAM[addr32] = value; + +//printf("%d %d\n",addr32,value); + } +} + +uint8_t VRAM_read(uint32_t addr32) { + + if (addr32 < 16384) return VRAM[addr32]; + return 0; +} + +uint8_t ansicolor[16] = { 0, 4, 2, 6, 1, 5, 3, 7, 0, 4, 2, 6, 1, 5, 3, 7 }; +uint16_t palettecga[16], palettevga[256]; + + +void installPalette(void) { + palettecga[0] = RGBVAL16(0, 0, 0); + palettecga[1] = RGBVAL16(0, 0, 0xAA); + palettecga[2] = RGBVAL16(0, 0xAA, 0); + palettecga[3] = RGBVAL16(0, 0xAA, 0xAA); + palettecga[4] = RGBVAL16(0xAA, 0, 0); + palettecga[5] = RGBVAL16(0xAA, 0, 0xAA); + palettecga[6] = RGBVAL16(0xAA, 0x55, 0); + palettecga[7] = RGBVAL16(0xAA, 0xAA, 0xAA); + palettecga[8] = RGBVAL16(0x55, 0x55, 0x55); + palettecga[9] = RGBVAL16(0x55, 0x55, 0xFF); + palettecga[10] = RGBVAL16(0x55, 0xFF, 0x55); + palettecga[11] = RGBVAL16(0x55, 0xFF, 0xFF); + palettecga[12] = RGBVAL16(0xFF, 0x55, 0x55); + palettecga[13] = RGBVAL16(0xFF, 0x55, 0xFF); + palettecga[14] = RGBVAL16(0xFF, 0xFF, 0x55); + palettecga[15] = RGBVAL16(0xFF, 0xFF, 0xFF); + palettevga[0] = RGBVAL16(0, 0, 0); + palettevga[1] = RGBVAL16(0, 0, 169); + palettevga[2] = RGBVAL16(0, 169, 0); + palettevga[3] = RGBVAL16(0, 169, 169); + palettevga[4] = RGBVAL16(169, 0, 0); + palettevga[5] = RGBVAL16(169, 0, 169); + palettevga[6] = RGBVAL16(169, 169, 0); + palettevga[7] = RGBVAL16(169, 169, 169); + palettevga[8] = RGBVAL16(0, 0, 84); + palettevga[9] = RGBVAL16(0, 0, 255); + palettevga[10] = RGBVAL16(0, 169, 84); + palettevga[11] = RGBVAL16(0, 169, 255); + palettevga[12] = RGBVAL16(169, 0, 84); + palettevga[13] = RGBVAL16(169, 0, 255); + palettevga[14] = RGBVAL16(169, 169, 84); + palettevga[15] = RGBVAL16(169, 169, 255); + palettevga[16] = RGBVAL16(0, 84, 0); + palettevga[17] = RGBVAL16(0, 84, 169); + palettevga[18] = RGBVAL16(0, 255, 0); + palettevga[19] = RGBVAL16(0, 255, 169); + palettevga[20] = RGBVAL16(169, 84, 0); + palettevga[21] = RGBVAL16(169, 84, 169); + palettevga[22] = RGBVAL16(169, 255, 0); + palettevga[23] = RGBVAL16(169, 255, 169); + palettevga[24] = RGBVAL16(0, 84, 84); + palettevga[25] = RGBVAL16(0, 84, 255); + palettevga[26] = RGBVAL16(0, 255, 84); + palettevga[27] = RGBVAL16(0, 255, 255); + palettevga[28] = RGBVAL16(169, 84, 84); + palettevga[29] = RGBVAL16(169, 84, 255); + palettevga[30] = RGBVAL16(169, 255, 84); + palettevga[31] = RGBVAL16(169, 255, 255); + palettevga[32] = RGBVAL16(84, 0, 0); + palettevga[33] = RGBVAL16(84, 0, 169); + palettevga[34] = RGBVAL16(84, 169, 0); + palettevga[35] = RGBVAL16(84, 169, 169); + palettevga[36] = RGBVAL16(255, 0, 0); + palettevga[37] = RGBVAL16(255, 0, 169); + palettevga[38] = RGBVAL16(255, 169, 0); + palettevga[39] = RGBVAL16(255, 169, 169); + palettevga[40] = RGBVAL16(84, 0, 84); + palettevga[41] = RGBVAL16(84, 0, 255); + palettevga[42] = RGBVAL16(84, 169, 84); + palettevga[43] = RGBVAL16(84, 169, 255); + palettevga[44] = RGBVAL16(255, 0, 84); + palettevga[45] = RGBVAL16(255, 0, 255); + palettevga[46] = RGBVAL16(255, 169, 84); + palettevga[47] = RGBVAL16(255, 169, 255); + palettevga[48] = RGBVAL16(84, 84, 0); + palettevga[49] = RGBVAL16(84, 84, 169); + palettevga[50] = RGBVAL16(84, 255, 0); + palettevga[51] = RGBVAL16(84, 255, 169); + palettevga[52] = RGBVAL16(255, 84, 0); + palettevga[53] = RGBVAL16(255, 84, 169); + palettevga[54] = RGBVAL16(255, 255, 0); + palettevga[55] = RGBVAL16(255, 255, 169); + palettevga[56] = RGBVAL16(84, 84, 84); + palettevga[57] = RGBVAL16(84, 84, 255); + palettevga[58] = RGBVAL16(84, 255, 84); + palettevga[59] = RGBVAL16(84, 255, 255); + palettevga[60] = RGBVAL16(255, 84, 84); + palettevga[61] = RGBVAL16(255, 84, 255); + palettevga[62] = RGBVAL16(255, 255, 84); + palettevga[63] = RGBVAL16(255, 255, 255); + palettevga[64] = RGBVAL16(255, 125, 125); + palettevga[65] = RGBVAL16(255, 157, 125); + palettevga[66] = RGBVAL16(255, 190, 125); + palettevga[67] = RGBVAL16(255, 222, 125); + palettevga[68] = RGBVAL16(255, 255, 125); + palettevga[69] = RGBVAL16(222, 255, 125); + palettevga[70] = RGBVAL16(190, 255, 125); + palettevga[71] = RGBVAL16(157, 255, 125); + palettevga[72] = RGBVAL16(125, 255, 125); + palettevga[73] = RGBVAL16(125, 255, 157); + palettevga[74] = RGBVAL16(125, 255, 190); + palettevga[75] = RGBVAL16(125, 255, 222); + palettevga[76] = RGBVAL16(125, 255, 255); + palettevga[77] = RGBVAL16(125, 222, 255); + palettevga[78] = RGBVAL16(125, 190, 255); + palettevga[79] = RGBVAL16(125, 157, 255); + palettevga[80] = RGBVAL16(182, 182, 255); + palettevga[81] = RGBVAL16(198, 182, 255); + palettevga[82] = RGBVAL16(218, 182, 255); + palettevga[83] = RGBVAL16(234, 182, 255); + palettevga[84] = RGBVAL16(255, 182, 255); + palettevga[85] = RGBVAL16(255, 182, 234); + palettevga[86] = RGBVAL16(255, 182, 218); + palettevga[87] = RGBVAL16(255, 182, 198); + palettevga[88] = RGBVAL16(255, 182, 182); + palettevga[89] = RGBVAL16(255, 198, 182); + palettevga[90] = RGBVAL16(255, 218, 182); + palettevga[91] = RGBVAL16(255, 234, 182); + palettevga[92] = RGBVAL16(255, 255, 182); + palettevga[93] = RGBVAL16(234, 255, 182); + palettevga[94] = RGBVAL16(218, 255, 182); + palettevga[95] = RGBVAL16(198, 255, 182); + palettevga[96] = RGBVAL16(182, 255, 182); + palettevga[97] = RGBVAL16(182, 255, 198); + palettevga[98] = RGBVAL16(182, 255, 218); + palettevga[99] = RGBVAL16(182, 255, 234); + palettevga[100] = RGBVAL16(182, 255, 255); + palettevga[101] = RGBVAL16(182, 234, 255); + palettevga[102] = RGBVAL16(182, 218, 255); + palettevga[103] = RGBVAL16(182, 198, 255); + palettevga[104] = RGBVAL16(0, 0, 113); + palettevga[105] = RGBVAL16(28, 0, 113); + palettevga[106] = RGBVAL16(56, 0, 113); + palettevga[107] = RGBVAL16(84, 0, 113); + palettevga[108] = RGBVAL16(113, 0, 113); + palettevga[109] = RGBVAL16(113, 0, 84); + palettevga[110] = RGBVAL16(113, 0, 56); + palettevga[111] = RGBVAL16(113, 0, 28); + palettevga[112] = RGBVAL16(113, 0, 0); + palettevga[113] = RGBVAL16(113, 28, 0); + palettevga[114] = RGBVAL16(113, 56, 0); + palettevga[115] = RGBVAL16(113, 84, 0); + palettevga[116] = RGBVAL16(113, 113, 0); + palettevga[117] = RGBVAL16(84, 113, 0); + palettevga[118] = RGBVAL16(56, 113, 0); + palettevga[119] = RGBVAL16(28, 113, 0); + palettevga[120] = RGBVAL16(0, 113, 0); + palettevga[121] = RGBVAL16(0, 113, 28); + palettevga[122] = RGBVAL16(0, 113, 56); + palettevga[123] = RGBVAL16(0, 113, 84); + palettevga[124] = RGBVAL16(0, 113, 113); + palettevga[125] = RGBVAL16(0, 84, 113); + palettevga[126] = RGBVAL16(0, 56, 113); + palettevga[127] = RGBVAL16(0, 28, 113); + palettevga[128] = RGBVAL16(56, 56, 113); + palettevga[129] = RGBVAL16(68, 56, 113); + palettevga[130] = RGBVAL16(84, 56, 113); + palettevga[131] = RGBVAL16(97, 56, 113); + palettevga[132] = RGBVAL16(113, 56, 113); + palettevga[133] = RGBVAL16(113, 56, 97); + palettevga[134] = RGBVAL16(113, 56, 84); + palettevga[135] = RGBVAL16(113, 56, 68); + palettevga[136] = RGBVAL16(113, 56, 56); + palettevga[137] = RGBVAL16(113, 68, 56); + palettevga[138] = RGBVAL16(113, 84, 56); + palettevga[139] = RGBVAL16(113, 97, 56); + palettevga[140] = RGBVAL16(113, 113, 56); + palettevga[141] = RGBVAL16(97, 113, 56); + palettevga[142] = RGBVAL16(84, 113, 56); + palettevga[143] = RGBVAL16(68, 113, 56); + palettevga[144] = RGBVAL16(56, 113, 56); + palettevga[145] = RGBVAL16(56, 113, 68); + palettevga[146] = RGBVAL16(56, 113, 84); + palettevga[147] = RGBVAL16(56, 113, 97); + palettevga[148] = RGBVAL16(56, 113, 113); + palettevga[149] = RGBVAL16(56, 97, 113); + palettevga[150] = RGBVAL16(56, 84, 113); + palettevga[151] = RGBVAL16(56, 68, 113); + palettevga[152] = RGBVAL16(80, 80, 113); + palettevga[153] = RGBVAL16(89, 80, 113); + palettevga[154] = RGBVAL16(97, 80, 113); + palettevga[155] = RGBVAL16(105, 80, 113); + palettevga[156] = RGBVAL16(113, 80, 113); + palettevga[157] = RGBVAL16(113, 80, 105); + palettevga[158] = RGBVAL16(113, 80, 97); + palettevga[159] = RGBVAL16(113, 80, 89); + palettevga[160] = RGBVAL16(113, 80, 80); + palettevga[161] = RGBVAL16(113, 89, 80); + palettevga[162] = RGBVAL16(113, 97, 80); + palettevga[163] = RGBVAL16(113, 105, 80); + palettevga[164] = RGBVAL16(113, 113, 80); + palettevga[165] = RGBVAL16(105, 113, 80); + palettevga[166] = RGBVAL16(97, 113, 80); + palettevga[167] = RGBVAL16(89, 113, 80); + palettevga[168] = RGBVAL16(80, 113, 80); + palettevga[169] = RGBVAL16(80, 113, 89); + palettevga[170] = RGBVAL16(80, 113, 97); + palettevga[171] = RGBVAL16(80, 113, 105); + palettevga[172] = RGBVAL16(80, 113, 113); + palettevga[173] = RGBVAL16(80, 105, 113); + palettevga[174] = RGBVAL16(80, 97, 113); + palettevga[175] = RGBVAL16(80, 89, 113); + palettevga[176] = RGBVAL16(0, 0, 64); + palettevga[177] = RGBVAL16(16, 0, 64); + palettevga[178] = RGBVAL16(32, 0, 64); + palettevga[179] = RGBVAL16(48, 0, 64); + palettevga[180] = RGBVAL16(64, 0, 64); + palettevga[181] = RGBVAL16(64, 0, 48); + palettevga[182] = RGBVAL16(64, 0, 32); + palettevga[183] = RGBVAL16(64, 0, 16); + palettevga[184] = RGBVAL16(64, 0, 0); + palettevga[185] = RGBVAL16(64, 16, 0); + palettevga[186] = RGBVAL16(64, 32, 0); + palettevga[187] = RGBVAL16(64, 48, 0); + palettevga[188] = RGBVAL16(64, 64, 0); + palettevga[189] = RGBVAL16(48, 64, 0); + palettevga[190] = RGBVAL16(32, 64, 0); + palettevga[191] = RGBVAL16(16, 64, 0); + palettevga[192] = RGBVAL16(0, 64, 0); + palettevga[193] = RGBVAL16(0, 64, 16); + palettevga[194] = RGBVAL16(0, 64, 32); + palettevga[195] = RGBVAL16(0, 64, 48); + palettevga[196] = RGBVAL16(0, 64, 64); + palettevga[197] = RGBVAL16(0, 48, 64); + palettevga[198] = RGBVAL16(0, 32, 64); + palettevga[199] = RGBVAL16(0, 16, 64); + palettevga[200] = RGBVAL16(32, 32, 64); + palettevga[201] = RGBVAL16(40, 32, 64); + palettevga[202] = RGBVAL16(48, 32, 64); + palettevga[203] = RGBVAL16(56, 32, 64); + palettevga[204] = RGBVAL16(64, 32, 64); + palettevga[205] = RGBVAL16(64, 32, 56); + palettevga[206] = RGBVAL16(64, 32, 48); + palettevga[207] = RGBVAL16(64, 32, 40); + palettevga[208] = RGBVAL16(64, 32, 32); + palettevga[209] = RGBVAL16(64, 40, 32); + palettevga[210] = RGBVAL16(64, 48, 32); + palettevga[211] = RGBVAL16(64, 56, 32); + palettevga[212] = RGBVAL16(64, 64, 32); + palettevga[213] = RGBVAL16(56, 64, 32); + palettevga[214] = RGBVAL16(48, 64, 32); + palettevga[215] = RGBVAL16(40, 64, 32); + palettevga[216] = RGBVAL16(32, 64, 32); + palettevga[217] = RGBVAL16(32, 64, 40); + palettevga[218] = RGBVAL16(32, 64, 48); + palettevga[219] = RGBVAL16(32, 64, 56); + palettevga[220] = RGBVAL16(32, 64, 64); + palettevga[221] = RGBVAL16(32, 56, 64); + palettevga[222] = RGBVAL16(32, 48, 64); + palettevga[223] = RGBVAL16(32, 40, 64); + palettevga[224] = RGBVAL16(44, 44, 64); + palettevga[225] = RGBVAL16(48, 44, 64); + palettevga[226] = RGBVAL16(52, 44, 64); + palettevga[227] = RGBVAL16(60, 44, 64); + palettevga[228] = RGBVAL16(64, 44, 64); + palettevga[229] = RGBVAL16(64, 44, 60); + palettevga[230] = RGBVAL16(64, 44, 52); + palettevga[231] = RGBVAL16(64, 44, 48); + palettevga[232] = RGBVAL16(64, 44, 44); + palettevga[233] = RGBVAL16(64, 48, 44); + palettevga[234] = RGBVAL16(64, 52, 44); + palettevga[235] = RGBVAL16(64, 60, 44); + palettevga[236] = RGBVAL16(64, 64, 44); + palettevga[237] = RGBVAL16(60, 64, 44); + palettevga[238] = RGBVAL16(52, 64, 44); + palettevga[239] = RGBVAL16(48, 64, 44); + palettevga[240] = RGBVAL16(44, 64, 44); + palettevga[241] = RGBVAL16(44, 64, 48); + palettevga[242] = RGBVAL16(44, 64, 52); + palettevga[243] = RGBVAL16(44, 64, 60); + palettevga[244] = RGBVAL16(44, 64, 64); + palettevga[245] = RGBVAL16(44, 60, 64); + palettevga[246] = RGBVAL16(44, 52, 64); + palettevga[247] = RGBVAL16(44, 48, 64); + palettevga[248] = RGBVAL16(0, 0, 0); + palettevga[249] = RGBVAL16(0, 0, 0); + palettevga[250] = RGBVAL16(0, 0, 0); + palettevga[251] = RGBVAL16(0, 0, 0); + palettevga[252] = RGBVAL16(0, 0, 0); + palettevga[253] = RGBVAL16(0, 0, 0); + palettevga[254] = RGBVAL16(0, 0, 0); + palettevga[255] = RGBVAL16(0, 0, 0); +} + +extern uint8_t vidmode, portram[0x400]; + +#define XRES_MAX 640 +#define XRES_HI 640 +#define XRES_LO 320 +#define YRES 200 + +#include "font.h" + + +static unsigned short line[XRES_MAX]; + +void drawscreentext80(void) { + uint16_t row, col, y, x, xpos; + uint16_t fontdata; + + for (y=0; y<(25*8); y++) + { + row = y>>3; + uint8_t * vrampt=&VRAM[160*row]; + xpos = 0; + for (col=0; col<80; col++) + { + uint8_t bold, attrib, cc, bg, fg; + cc = *vrampt++; + attrib = *vrampt++; + bg = (attrib >> 4) & 7; + fg = attrib & 0x0F; + //if (y == 0) {printf("0x%02X",cc);} + fontdata = ROM_READ(font, ((uint32_t)cc << 3) + (y&0x7)); + for (x=0; x<8; x++) + //for (x=0; x<4; x++) + { + if (fontdata & 1) { + line[xpos++] = palettecga[fg]; + } else { + line[xpos++] = palettecga[bg]; + } + fontdata >>= 1; + //fontdata >>= 2; + } + } + emu_DrawLine16(&line[0], XRES_HI, YRES, y); + } +} + +void drawscreenlorescga(void) { + uint16_t y, x, xpos; + uint8_t intensity, usepal; + uint16_t color; + usepal = (portram[0x3D9]>>5) & 1; + intensity = ( (portram[0x3D9]>>4) & 1) << 3; + + for (y=0; y<(25*8); y++) + { + xpos = 0; + for (x=0; x> 1; + int xchar = x;// >> 1; + uint8_t curchar = VRAM[((ychar & 1) * 8192 + (ychar >> 1) * 80 + (xchar >> 2))]; + switch (xchar & 3) { + case 3: color = curchar & 3; break; + case 2: color = (curchar >> 2) & 3; break; + case 1: color = (curchar >> 4) & 3; break; + case 0: color = (curchar >> 6) & 3; break; + } + color = (color << 1) + usepal + intensity; + if (color == (usepal + intensity)) color = 0; + line[xpos++] = palettecga[color]; + } + emu_DrawLine16(&line[0], XRES_LO, YRES, y); + } +} + + +void drawscreenhirescga(void) { + uint16_t y, x, xpos; + uint16_t color; + for (y=0; y<(25*8); y++) + { + xpos = 0; + for (x=0; x> 1; + int xchar = x; + uint8_t curchar = VRAM[((ychar & 1) * 8192 + (ychar >> 1) * 80 + (xchar >> 3))]; + color = ((curchar >> (7-(x&7))) & 1) ? 15 : 0; + line[xpos++] = palettecga[color]; + } + emu_DrawLine16(&line[0], XRES_HI, YRES, y); + } +} + + +void updatescreen() { + switch (vidmode & 0x7F) { + case 0: + case 1: + //drawtext40(origaddr, value); + break; + case 2: + case 3: + //case 7: + drawscreentext80(); + break; + case 4: + drawscreenlorescga(); + break; + case 5: + drawscreenlorescga(); //change to BW function later + break; + case 6: + drawscreenhirescga(); + break; + } +//printf("%d\n",vidmode & 0x7F); +} + +static uint8_t nbkeys=0; +static uint8_t kcnt=0; +static int toggle=1; + +static char * seq; +static char * seq1="PRINCE.BAT\r"; +static char * seq2="CAT.EXE\r"; +static char * seq3="y\r"; + +static int mouse_x = 160; +static int mouse_y = 100; +static int prev_key = 0; +static int prev_j = 0; +static int prev_mouseb = 0; +static bool isMouse = true; +static int joynum = 1; +static int hk = 0; +static int prev_hk = 0; +static int k = 0; + +static void keyevent(int keysym, int isdown) +{ + uint8_t scancode = translatescancode(keysym); + if (scancode != 0xFF) { + portram[0x60] = scancode; + if (!isdown) portram[0x60] |= 0x80; + portram[0x64] |= 2; + doirq(1); + } +} + +extern void apc_Input(int bClick) { + hk = emu_ReadI2CKeyboard(); + k = emu_ReadKeys(); + + if (nbkeys == 0) { + if ( (bClick & MASK_KEY_USER1) && (bClick & MASK_KEY_USER2) ) { + nbkeys = strlen(seq3); + seq=seq3; + kcnt=0; + } + else if (bClick & MASK_KEY_USER1) { + nbkeys = strlen(seq1); + seq=seq1; + kcnt=0; + } + else if (bClick & MASK_KEY_USER2) { + nbkeys = strlen(seq2); + seq=seq2; + kcnt=0; + } + + } + else { + char k = seq[kcnt]; + if (k == 13) keyevent(0xFF0D,toggle); + else keyevent(k,toggle); + //setKey(ascii2scan[k],toggle); + if (!toggle) { + kcnt++; + nbkeys--; + toggle = true; + } + else { + toggle = false; + } + } +} + +static void do_events(void) +{ + if (hk != prev_hk) { + prev_hk == hk; + if ( (hk != 0) && (hk != prev_key) ) { + prev_key = hk; + keyevent ( hk, 0 ); + if (hk == 68) { + if (isMouse) isMouse = false; + else isMouse = true; + } + } + } + if ( (hk == 0) && (prev_key) ) { + keyevent ( prev_key, 1 ); + prev_key = 0; + } + + + if (!isMouse) + { + int j = 0; + if (( k & MASK_JOY1_RIGHT) || ( k & MASK_JOY2_RIGHT)) { + j |= 0x08; + } + if (( k & MASK_JOY1_LEFT) || ( k & MASK_JOY2_LEFT)) { + j |= 0x04; + } + if (( k & MASK_JOY1_UP) || ( k & MASK_JOY2_UP)) { + j |= 0x01; + } + if (( k & MASK_JOY1_DOWN) || ( k & MASK_JOY2_DOWN)) { + j |= 0x02; + } + if ( k & MASK_JOY2_BTN) { + j |= 0x80; + } + if (j != prev_j) { + //IkbdJoystickChange(joynum,j); + prev_j = j; + } + } + else { + if (( k & MASK_JOY1_RIGHT) || ( k & MASK_JOY2_RIGHT)) { + if ( mouse_x < XRES_HI ) { + mouse_x += 1; + } + } + else if (( k & MASK_JOY1_LEFT) || ( k & MASK_JOY2_LEFT)) { + if ( mouse_x > 1 ) { + mouse_x -= 1; + } + } + else if (( k & MASK_JOY1_UP) || ( k & MASK_JOY2_UP)) { + if ( mouse_y > 1 ) { + mouse_y -= 1; + } + } + else if (( k & MASK_JOY1_DOWN) || ( k & MASK_JOY2_DOWN)) { + if ( mouse_y < YRES ) { + mouse_y += 1; + } + } + + int mouseb=0; + if ( ( k & MASK_JOY2_BTN) ){ + mouseb=1; + } + if ( (mouseb != prev_mouseb) ){ + prev_mouseb = mouseb; + } + } +} + +void emu_KeyboardOnDown(int keymodifer, int key) { +} + +void emu_KeyboardOnUp(int keymodifer, int key) { +} + +void apc_Step(void) +{ + exec86(8000); + updatescreen(); + do_events(); + emu_DrawVsync(); +} + + + +void apc_Init(void) +{ +#ifdef HAS_PSRAM + psram.begin(); +#endif + installPalette(); + init8253(); + reset86(); + init8259(); +} + +void apc_Start(char * filename) +{ + emu_printf("init started"); + initDisk(filename); + emu_printf("init done"); +} diff --git a/MCUME_pico/pico8086/pc.h b/MCUME_pico/pico8086/pc.h new file mode 100644 index 0000000..2b13c4a --- /dev/null +++ b/MCUME_pico/pico8086/pc.h @@ -0,0 +1,5 @@ +extern void apc_Init(void); +extern void apc_Step(void); +extern void apc_Start(char * filename); +extern void apc_Input(int click); + diff --git a/MCUME_pico/pico8086/pico8086.cpp b/MCUME_pico/pico8086/pico8086.cpp new file mode 100644 index 0000000..8692588 --- /dev/null +++ b/MCUME_pico/pico8086/pico8086.cpp @@ -0,0 +1,178 @@ +#include "pico.h" +#include "pico/stdlib.h" + +extern "C" { + #include "iopins.h" + #include "emuapi.h" +} +#include "keyboard_osd.h" + +#include "pc.h" +#include + +#ifdef USE_VGA +#include "vga_t_dma.h" +#else +#include "tft_t_dma.h" +#endif +volatile bool vbl=true; + +bool repeating_timer_callback(struct repeating_timer *t) { + if (vbl) { + vbl = false; + } else { + vbl = true; + } + return true; +} +TFT_T_DMA tft; + +static int skip=0; + +#include "hardware/clocks.h" +#include "hardware/vreg.h" + +int main(void) { + vreg_set_voltage(VREG_VOLTAGE_1_05); +// set_sys_clock_khz(125000, true); +// set_sys_clock_khz(150000, true); +// set_sys_clock_khz(133000, true); +// set_sys_clock_khz(200000, true); +// set_sys_clock_khz(225000, true); + set_sys_clock_khz(150000, true); + stdio_init_all(); +#ifdef USE_VGA +// tft.begin(VGA_MODE_400x240); + tft.begin(VGA_MODE_320x240); +#else + tft.begin(); +#endif + emu_init(); + while (true) { + if (menuActive()) { + uint16_t bClick = emu_DebounceLocalKeys(); + int action = handleMenu(bClick); + char * filename = menuSelection(); + if (action == ACTION_RUNTFT) { + toggleMenu(false); + emu_start(); + emu_Init(filename); + tft.fillScreenNoDma( RGBVAL16(0x00,0x00,0x00) ); + tft.startDMA(); + struct repeating_timer timer; + add_repeating_timer_ms(15, repeating_timer_callback, NULL, &timer); + } + tft.waitSync(); + } + else { + uint16_t bClick = emu_DebounceLocalKeys(); + emu_Input(bClick); + emu_Step(); + } + //int c = getchar_timeout_us(0); + //switch (c) { + // case ' ': + // printf("test: %d\n", 1); + // break; + //} + } +} + +static unsigned char palette8[PALETTE_SIZE]; +static unsigned short palette16[PALETTE_SIZE]; + +void emu_SetPaletteEntry(unsigned char r, unsigned char g, unsigned char b, int index) +{ + if (index +#include "emu.h" + +volatile uint16_t pit0counter = 65535; +volatile uint32_t speakercountdown, latch42, pit0latch, pit0command, pit0divisor; +uint8_t portram[0x400]; +uint8_t crt_controller_idx, crt_controller[256], port3D9 = 0; + +void portout(uint16_t portnum, uint16_t value) { + if (portnum < 0x400) portram[portnum] = value; + switch (portnum) { + case 0x20: + case 0x21: //i8259 + out8259(portnum, value); + return; + case 0x40: + case 0x41: + case 0x42: + case 0x43: //i8253 + out8253(portnum, value); + break; + case 0x3D4: + crt_controller_idx = value; + break; + case 0x3D5: + crt_controller[crt_controller_idx] = value; + if ((crt_controller_idx == 0x0E) || (crt_controller_idx == 0x0F)) { + //setcursor(((uint16_t)crt_controller[0x0E] << 8) | crt_controller[0x0F]); + //Serial.write(27); Serial.write('['); Serial.print(crt_controller[0x0E] + 1); Serial.write(';'); Serial.print(crt_controller[0x0F] + 1); Serial.write('H'); + } + break; + case 0x3D9: + port3D9 = value; + break; + } + +#ifdef ADVANCED_CLIENT + if ((portnum >= 0x3C0) && (portnum <= 0x3DA)) { + uint8_t chksum; + Serial.write(0xFF); + Serial.write(0x04); + outByte(portnum & 0xFF); chksum = portnum & 0xFF; + outByte(portnum >> 8); chksum += portnum >> 8; + outByte(value); chksum += value; + outByte(chksum); + Serial.write(0xFE); + Serial.write(0x02); + } +#endif + +#ifdef VGA + if ((portnum >= 0x3C0) && (portnum <= 0x3DA)) outVGA(portnum, value); +#endif +} + +uint16_t portin(uint16_t portnum) { +#ifdef VGA + if ((portnum >= 0x3C0) && (portnum <= 0x3DA)) return inVGA(portnum); +#endif +/* uint8_t chksum; + Serial.write(0xFF); + Serial.write(0x07); + outByte(portnum & 0xFF); chksum = portnum & 0xFF; + outByte((portnum >> 8) & 0xFF); chksum += (portnum >> 8) & 0xFF; + outByte(chksum); + Serial.write(0xFE); + Serial.write(0x02);*/ + switch (portnum) { + case 0x20: + case 0x21: //i8259 + return (in8259(portnum)); + case 0x40: + case 0x41: + case 0x42: + case 0x43: //i8253 + return in8253(portnum); + case 0x60: + case 0x64: + return portram[portnum]; + case 0x3D4: + return crt_controller_idx; + break; + case 0x3D5: + return crt_controller[crt_controller_idx]; + break; + case 0x3DA: + port3da ^= 1; + if (!(port3da & 1)) port3da ^= 8; + //port3da = random(256) & 9; + return (port3da); + default: + return (0xFF); + } +} + + diff --git a/MCUME_pico/pico8086/ps2.h b/MCUME_pico/pico8086/ps2.h new file mode 100755 index 0000000..dc6f578 --- /dev/null +++ b/MCUME_pico/pico8086/ps2.h @@ -0,0 +1,89 @@ +uint8_t translatescancode(uint32_t keysym) { + if ((keysym >= 'a') && (keysym <= 'z')) { + keysym -= 0x20; + } + switch (keysym) { + case 0xFF08: return 0x0E; //backspace + case 0xFF09: return 0x0F; //tab + case 0xFF0D: return 0x1C; //enter + case 0xFF1B: return 0x01; //escape + case 0xFF63: return 0x52; //KP 0 / insert + case 0xFFFF: return 0x53; //KP . / delete + case 0xFF55: return 0x49; //pgup + case 0xFF56: return 0x51; //pgdn + case 0xFF50: return 0x47; //home + case 0xFF57: return 0x4F; //end + case 'A': return 0x1E; + case 'B': return 0x30; + case 'C': return 0x2E; + case 'D': return 0x20; + case 'E': return 0x12; + case 'F': return 0x21; + case 'G': return 0x22; + case 'H': return 0x23; + case 'I': return 0x17; + case 'J': return 0x24; + case 'K': return 0x25; + case 'L': return 0x26; + case 'M': return 0x32; + case 'N': return 0x31; + case 'O': return 0x18; + case 'P': return 0x19; + case 'Q': return 0x10; + case 'R': return 0x13; + case 'S': return 0x1F; + case 'T': return 0x14; + case 'U': return 0x16; + case 'V': return 0x2F; + case 'W': return 0x11; + case 'X': return 0x2D; + case 'Y': return 0x15; + case 'Z': return 0x2C; + case '0': case ')': return 0x0B; + case '1': case '!': return 0x02; + case '2': case '@': return 0x03; + case '3': case '#': return 0x04; + case '4': case '$': return 0x05; + case '5': case '%': return 0x06; + case '6': case '^': return 0x07; + case '7': case '&': return 0x08; + case '8': case '*': return 0x09; + case '9': case '(': return 0x0A; + case '`': case '~': return 0x29; + case '-': case '_': return 0x0C; + case '=': case '+': return 0x0D; + case '[': case '{': return 0x1A; + case ']': case '}': return 0x1B; + case '\\': case '|': return 0x2B; + case ';': case ':': return 0x27; + case '\'': case '"': return 0x28; + case ' ': return 0x39; + case ',': case '<': return 0x33; + case '.': case '>': return 0x34; + case '/': case '?': return 0x35; + case 0xFFBE: return 0x3B; //F1 + case 0xFFBF: return 0x3C; //F2 + case 0xFFC0: return 0x3D; //F3 + case 0xFFC1: return 0x3E; //F4 + case 0xFFC2: return 0x3F; //F5 + case 0xFFC3: return 0x40; //F6 + case 0xFFC4: return 0x41; //F7 + case 0xFFC5: return 0x42; //F8 + case 0xFFC6: return 0x43; //F9 + case 0xFFC7: return 0x44; //F10 + case 0xFFC8: return 0x57; //F11 + case 0xFFC9: return 0x58; //F12 + case 0xFFE1: return 0x2A; //left shift + case 0xFFE2: return 0x36; //right shift + case 0xFFE3: case 0xFFE4: return 0x1D; //control + case 0xFFE9: case 0xFFEA: return 0x38; //alt + case 0xFF51: return 0x4B; //left + case 0xFF52: return 0x48; //up + case 0xFF53: return 0x4D; //right + case 0xFF54: return 0x50; //down + } + return 0xFF; +} + + + diff --git a/MCUME_pico/pico8086/rom.h b/MCUME_pico/pico8086/rom.h new file mode 100644 index 0000000..ca3cb84 --- /dev/null +++ b/MCUME_pico/pico8086/rom.h @@ -0,0 +1,3749 @@ +#ifdef MEGA + #include + const uint8_t BIOS[8192] PROGMEM = { +#else + const uint8_t BIOS[8192] = { +#endif + 0x54, 0x75, 0x72, 0x62, 0x6F, 0x20, 0x58, 0x54, 0x20, 0x42, 0x49, + 0x4F, 0x53, 0x20, 0x76, 0x32, 0x2E, 0x35, 0x20, 0x66, 0x6F, 0x72, + 0x20, 0x38, 0x30, 0x38, 0x38, 0x2F, 0x56, 0x32, 0x30, 0x00, 0xC3, + 0x20, 0x45, 0x47, 0x41, 0x2F, 0x56, 0x47, 0x41, 0x20, 0x47, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x00, 0xC3, 0x20, 0x50, 0x61, + 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, 0x20, 0x50, 0x6F, 0x72, 0x74, + 0x20, 0x61, 0x74, 0x20, 0x00, 0xC3, 0x20, 0x47, 0x61, 0x6D, 0x65, + 0x20, 0x50, 0x6F, 0x72, 0x74, 0x20, 0x61, 0x74, 0x20, 0x32, 0x30, + 0x31, 0x68, 0x00, 0xB8, 0x40, 0x00, 0x8E, 0xD8, 0xC7, 0x06, 0x72, + 0x00, 0x00, 0x00, 0xFA, 0xFC, 0xB0, 0x00, 0xE6, 0xA0, 0xBA, 0xD8, + 0x03, 0xEE, 0xBA, 0xB8, 0x03, 0xFE, 0xC0, 0xEE, 0xB0, 0x99, 0xE6, + 0x63, 0xB0, 0xA5, 0xE6, 0x61, 0xB0, 0x54, 0xE6, 0x43, 0xB0, 0x12, + 0xE6, 0x41, 0xB0, 0x40, 0xE6, 0x43, 0xB0, 0x00, 0xE6, 0x81, 0xE6, + 0x82, 0xE6, 0x83, 0xE6, 0x0D, 0xB0, 0x58, 0xE6, 0x0B, 0xB0, 0x41, + 0xE6, 0x0B, 0xB0, 0x42, 0xE6, 0x0B, 0xB0, 0x43, 0xE6, 0x0B, 0xB0, + 0xFF, 0xE6, 0x01, 0xE6, 0x01, 0xB0, 0x00, 0xE6, 0x08, 0xE6, 0x0A, + 0xB0, 0x36, 0xE6, 0x43, 0xB0, 0x00, 0xE6, 0x40, 0xE6, 0x40, 0xBA, + 0x13, 0x02, 0xB0, 0x01, 0xEE, 0xB8, 0x40, 0x00, 0x8E, 0xD8, 0x8B, + 0x36, 0x72, 0x00, 0x33, 0xC0, 0x8B, 0xE8, 0x8B, 0xD8, 0xBA, 0xAA, + 0x55, 0xFC, 0x33, 0xFF, 0x8E, 0xC3, 0x26, 0x89, 0x15, 0x26, 0x3B, + 0x15, 0x75, 0x0D, 0xB9, 0x00, 0x20, 0xF3, 0xAB, 0x80, 0xC7, 0x04, + 0x80, 0xFF, 0xA0, 0x72, 0xE7, 0x33, 0xC0, 0x8E, 0xC0, 0xB8, 0x80, + 0x00, 0x8E, 0xD0, 0xBC, 0x00, 0x01, 0x55, 0x53, 0xBD, 0x02, 0x00, + 0xE8, 0x19, 0x19, 0x89, 0x36, 0x72, 0x00, 0x58, 0xB1, 0x06, 0xD3, + 0xE8, 0xA3, 0x13, 0x00, 0x58, 0x73, 0x02, 0x0C, 0x10, 0xA2, 0x15, + 0x00, 0x33, 0xC0, 0x50, 0x50, 0x50, 0x50, 0x50, 0xB8, 0x30, 0x00, + 0x8E, 0xD0, 0xBC, 0x00, 0x01, 0x1E, 0xBB, 0x00, 0xE0, 0x0E, 0x1F, + 0xB4, 0x01, 0xE8, 0xDE, 0x18, 0x1F, 0x74, 0x05, 0x80, 0x0E, 0x15, + 0x00, 0x01, 0xFA, 0xB0, 0x13, 0xE6, 0x20, 0xB0, 0x08, 0xE6, 0x21, + 0xB0, 0x09, 0xE6, 0x21, 0xB0, 0xFF, 0xE6, 0x21, 0x1E, 0x33, 0xC0, + 0x8E, 0xC0, 0x0E, 0x1F, 0xB9, 0x08, 0x00, 0x33, 0xFF, 0xB8, 0x23, + 0xFF, 0xAB, 0x8C, 0xC8, 0xAB, 0xE2, 0xF7, 0xBE, 0xF3, 0xFE, 0xB9, + 0x18, 0x00, 0xA5, 0x8C, 0xC8, 0xAB, 0xE2, 0xFA, 0xB8, 0x00, 0xF6, + 0x8E, 0xD8, 0x33, 0xDB, 0xB4, 0x04, 0x8B, 0xEC, 0x0E, 0xBA, 0x88, + 0xE1, 0x52, 0xBA, 0x90, 0xEA, 0x52, 0xBA, 0x8B, 0x17, 0x52, 0x16, + 0x8B, 0xD4, 0x83, 0xC2, 0x02, 0x52, 0xCB, 0x8B, 0xE5, 0x3A, 0xD6, + 0x74, 0x0C, 0x1F, 0xBF, 0x60, 0x00, 0x33, 0xC0, 0xAB, 0xB8, 0x00, + 0xF6, 0xAB, 0x1E, 0x1F, 0x26, 0xC7, 0x06, 0x08, 0x00, 0x5F, 0xF8, + 0x26, 0xC7, 0x06, 0x14, 0x00, 0x54, 0xFF, 0x26, 0xC7, 0x06, 0x7C, + 0x00, 0x00, 0x00, 0x26, 0xC7, 0x06, 0x7E, 0x00, 0x00, 0x00, 0xBA, + 0x61, 0x00, 0xEC, 0x0C, 0x30, 0xEE, 0x24, 0xCF, 0xEE, 0xB0, 0x80, + 0xE6, 0xA0, 0xB8, 0x30, 0x00, 0xA3, 0x10, 0x00, 0xCD, 0x10, 0xB8, + 0x20, 0x00, 0xA3, 0x10, 0x00, 0xCD, 0x10, 0xE4, 0x62, 0x24, 0x0F, + 0x8A, 0xE0, 0xB0, 0xAD, 0xEE, 0xE4, 0x62, 0xB1, 0x04, 0xD2, 0xE0, + 0x0A, 0xC4, 0xB4, 0x00, 0xA3, 0x10, 0x00, 0x24, 0x30, 0x75, 0x09, + 0xB8, 0x53, 0xFF, 0x26, 0xA3, 0x40, 0x00, 0xEB, 0x03, 0xE8, 0xCC, + 0x17, 0xB0, 0x08, 0xEE, 0xB9, 0x56, 0x29, 0xE2, 0xFE, 0xB0, 0xC8, + 0xEE, 0x34, 0x80, 0xEE, 0xB8, 0x1E, 0x00, 0xA3, 0x1A, 0x00, 0xA3, + 0x1C, 0x00, 0xA3, 0x80, 0x00, 0x05, 0x20, 0x00, 0xA3, 0x82, 0x00, + 0xB8, 0x14, 0x14, 0xA3, 0x78, 0x00, 0xA3, 0x7A, 0x00, 0xB8, 0x01, + 0x01, 0xA3, 0x7C, 0x00, 0xA3, 0x7E, 0x00, 0xBE, 0x13, 0xF9, 0x33, + 0xFF, 0xB9, 0x03, 0x00, 0x2E, 0x8B, 0x14, 0xB0, 0xAA, 0xEE, 0xB0, + 0xFF, 0xE6, 0xC0, 0xEC, 0x3C, 0xAA, 0x75, 0x05, 0x89, 0x55, 0x08, + 0x47, 0x47, 0x46, 0x46, 0xE2, 0xE8, 0x8B, 0xC7, 0xB1, 0x03, 0xD2, + 0xC8, 0xA2, 0x11, 0x00, 0x33, 0xFF, 0xBA, 0xFB, 0x03, 0xB0, 0x1A, + 0xEE, 0xB0, 0xFF, 0xE6, 0xC0, 0xEC, 0x3C, 0x1A, 0x75, 0x06, 0xC7, + 0x05, 0xF8, 0x03, 0x47, 0x47, 0xBA, 0xFB, 0x02, 0xB0, 0x1A, 0xEE, + 0xB0, 0xFF, 0xE6, 0xC0, 0xEC, 0x3C, 0x1A, 0x75, 0x06, 0xC7, 0x05, + 0xF8, 0x02, 0x47, 0x47, 0x8B, 0xC7, 0x08, 0x06, 0x11, 0x00, 0xB9, + 0x64, 0x00, 0xBA, 0x01, 0x02, 0xEC, 0x3C, 0xFF, 0x75, 0x05, 0x49, + 0xE3, 0x07, 0xEB, 0xF6, 0x80, 0x0E, 0x11, 0x00, 0x10, 0xE8, 0x65, + 0x04, 0xBA, 0x00, 0xC0, 0x8B, 0x1E, 0x72, 0x00, 0x53, 0x1E, 0xE4, + 0x61, 0x34, 0x0C, 0xE6, 0x61, 0x8E, 0xDA, 0xEB, 0x13, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xE9, 0x99, 0x15, 0x33, 0xDB, 0x8B, 0x07, 0x3D, + 0x55, 0xAA, 0x75, 0x36, 0xB8, 0x40, 0x00, 0x8E, 0xC0, 0xB4, 0x00, + 0x8A, 0x47, 0x02, 0xB1, 0x05, 0xD3, 0xE0, 0x03, 0xD0, 0xB1, 0x04, + 0xD3, 0xE0, 0x8B, 0xC8, 0xE8, 0x27, 0x17, 0x75, 0x15, 0x52, 0x26, + 0xC7, 0x06, 0x67, 0x00, 0x03, 0x00, 0x26, 0x8C, 0x1E, 0x69, 0x00, + 0x26, 0xFF, 0x1E, 0x67, 0x00, 0x5A, 0xEB, 0x0A, 0x26, 0x80, 0x0E, + 0x15, 0x00, 0x20, 0x81, 0xC2, 0x80, 0x00, 0x81, 0xFA, 0x00, 0xF6, + 0x7C, 0xA0, 0x1F, 0x5B, 0x89, 0x1E, 0x72, 0x00, 0xE4, 0x21, 0x24, + 0xBC, 0xE6, 0x21, 0xB4, 0x12, 0xBB, 0x10, 0xFF, 0xCD, 0x10, 0x80, + 0xFF, 0xFF, 0x74, 0x07, 0x80, 0x26, 0x10, 0x00, 0xCF, 0xEB, 0x09, + 0xA0, 0x49, 0x00, 0xE8, 0xDF, 0x0B, 0xE8, 0x90, 0x16, 0xB4, 0x01, + 0xB5, 0xF0, 0xCD, 0x10, 0xE8, 0xDB, 0x01, 0xC6, 0x06, 0x96, 0x00, + 0x10, 0x81, 0x3E, 0x72, 0x00, 0x34, 0x12, 0x1E, 0x07, 0x0E, 0x1F, + 0x75, 0x05, 0xB7, 0xFD, 0xE9, 0x28, 0x01, 0xBE, 0x00, 0xE0, 0xE8, + 0x3E, 0x16, 0xBE, 0x5C, 0xE5, 0xE8, 0x20, 0x16, 0x26, 0xF6, 0x06, + 0x15, 0x00, 0xFF, 0x74, 0x3E, 0xB8, 0x00, 0x03, 0xE8, 0x1D, 0x16, + 0xBE, 0xF9, 0xE7, 0xE8, 0x0C, 0x16, 0x26, 0xA0, 0x15, 0x00, 0xE8, + 0xE2, 0x15, 0xBE, 0x42, 0xF9, 0xE8, 0xFF, 0x15, 0xB3, 0x02, 0xE8, + 0x60, 0x16, 0xE8, 0x58, 0x16, 0x50, 0xE8, 0xE8, 0x15, 0x58, 0x3C, + 0x59, 0x74, 0x09, 0x3C, 0x79, 0x74, 0x05, 0xEA, 0x5B, 0xE0, 0x00, + 0xF0, 0x26, 0xC6, 0x06, 0x15, 0x00, 0x00, 0xE8, 0x75, 0x01, 0xEB, + 0xAE, 0xB8, 0x00, 0x03, 0xE8, 0xDF, 0x15, 0xE8, 0x84, 0x01, 0xBE, + 0xB1, 0xE5, 0xB8, 0x07, 0x04, 0xE8, 0xD3, 0x15, 0x26, 0xA0, 0x49, + 0x00, 0x3C, 0x07, 0x74, 0x10, 0x26, 0xA0, 0x10, 0x00, 0x24, 0x30, + 0x75, 0x05, 0xBE, 0x20, 0xE0, 0xEB, 0x03, 0xBE, 0x36, 0xF0, 0xE8, + 0xAD, 0x15, 0xBB, 0x07, 0x05, 0x26, 0xA0, 0x11, 0x00, 0x50, 0xB1, + 0x06, 0xD2, 0xC8, 0x24, 0x03, 0x74, 0x09, 0xBD, 0x08, 0x00, 0xBE, + 0x33, 0xE0, 0xE8, 0xC9, 0x00, 0x58, 0x50, 0xBE, 0x19, 0xF9, 0xD0, + 0xC8, 0x24, 0x03, 0x74, 0x05, 0x33, 0xED, 0xE8, 0xB9, 0x00, 0x58, + 0xBE, 0x47, 0xE0, 0xA8, 0x10, 0x74, 0x0A, 0x8B, 0xC3, 0xE8, 0x82, + 0x15, 0xE8, 0x74, 0x15, 0xFE, 0xC7, 0xE8, 0xF0, 0x00, 0x72, 0x0D, + 0x8B, 0xC3, 0xE8, 0x73, 0x15, 0xFE, 0xC7, 0xBE, 0xC2, 0xFF, 0xE8, + 0x60, 0x15, 0xFE, 0xCF, 0xB3, 0x07, 0x8B, 0xC3, 0xE8, 0x62, 0x15, + 0xBE, 0xA2, 0xF0, 0xE8, 0x51, 0x15, 0xFE, 0xC7, 0xFE, 0xC7, 0x32, + 0xDB, 0x8B, 0xC3, 0xE8, 0x51, 0x15, 0xBE, 0x9C, 0xE5, 0xE8, 0x40, + 0x15, 0x06, 0x26, 0x8B, 0x2E, 0x13, 0x00, 0x4D, 0x4D, 0xBE, 0x02, + 0x00, 0x8B, 0xD6, 0xB8, 0x80, 0x00, 0x8E, 0xC0, 0x80, 0xC3, 0x0D, + 0x53, 0x58, 0x50, 0x8C, 0xC1, 0x83, 0xFD, 0x01, 0x74, 0x09, 0xF7, + 0xC1, 0xFF, 0x01, 0x74, 0x02, 0x32, 0xED, 0x4A, 0xE8, 0x20, 0x15, + 0xE8, 0x69, 0x00, 0x42, 0xE8, 0xA5, 0x15, 0x72, 0x2D, 0x4D, 0x75, + 0xDF, 0x5B, 0x07, 0xE8, 0x13, 0x13, 0xB3, 0x01, 0xE8, 0x65, 0x15, + 0xE8, 0x95, 0x00, 0x33, 0xC0, 0x8E, 0xD8, 0xC7, 0x06, 0x72, 0x04, + 0x34, 0x12, 0xB4, 0x01, 0xB9, 0x0C, 0x0B, 0x80, 0x3E, 0x49, 0x04, + 0x07, 0x74, 0x03, 0xB9, 0x07, 0x06, 0xCD, 0x10, 0xCD, 0x19, 0x4D, + 0x5B, 0x07, 0x26, 0x80, 0x0E, 0x15, 0x00, 0x02, 0xFE, 0xC7, 0xFE, + 0xC7, 0x32, 0xDB, 0x8B, 0xC3, 0xE9, 0xB6, 0xFE, 0x8A, 0xD0, 0x8B, + 0xC3, 0xE8, 0xCF, 0x14, 0x56, 0xE8, 0xC0, 0x14, 0x26, 0x8B, 0x46, + 0x00, 0xE8, 0xA3, 0x14, 0xBE, 0x4E, 0xFF, 0xE8, 0xB3, 0x14, 0x5E, + 0x45, 0x45, 0xFE, 0xC7, 0xFE, 0xCA, 0x75, 0xE1, 0xC3, 0xF8, 0x8A, + 0xC2, 0xFE, 0xC0, 0x27, 0x8A, 0xD0, 0x73, 0x07, 0x8A, 0xC6, 0x14, + 0x00, 0x27, 0x8A, 0xF0, 0x80, 0xFD, 0x00, 0x74, 0x13, 0x8A, 0xC6, + 0xE8, 0x5B, 0x14, 0x8A, 0xC2, 0xB1, 0x04, 0xD2, 0xC8, 0xE8, 0x52, + 0x14, 0x8A, 0xC2, 0xE8, 0x4D, 0x14, 0xC3, 0xBA, 0x41, 0x02, 0xFA, + 0xEC, 0xFB, 0x3C, 0x99, 0x76, 0x0C, 0xBA, 0x41, 0x03, 0xFA, 0xEC, + 0xFB, 0x3C, 0x99, 0x76, 0x02, 0xF9, 0xC3, 0xF8, 0xC3, 0xBA, 0x4F, + 0x18, 0x33, 0xC9, 0xB8, 0x00, 0x06, 0xB7, 0x07, 0xCD, 0x10, 0xB4, + 0x02, 0x33, 0xD2, 0xB7, 0x00, 0xCD, 0x10, 0xB8, 0x00, 0x05, 0xCD, + 0x10, 0xC3, 0xBE, 0xE1, 0xF7, 0xE8, 0x47, 0x14, 0xE8, 0xB7, 0x01, + 0xE8, 0x41, 0x14, 0xBE, 0x00, 0xF8, 0x26, 0xF6, 0x06, 0x10, 0x00, + 0x02, 0x74, 0x03, 0xBE, 0x08, 0xF8, 0xE8, 0x30, 0x14, 0xC3, 0x50, + 0x8A, 0xC4, 0xE8, 0x06, 0x14, 0xE9, 0x16, 0x14, 0x0D, 0x0A, 0x42, + 0x49, 0x4F, 0x53, 0x20, 0x62, 0x79, 0x20, 0x59, 0x2E, 0x20, 0x4D, + 0x69, 0x6C, 0x65, 0x73, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x4A, 0x2E, + 0x20, 0x50, 0x65, 0x74, 0x72, 0x6F, 0x73, 0x6B, 0x79, 0x2C, 0x20, + 0x41, 0x72, 0x64, 0x75, 0x69, 0x6E, 0x6F, 0x38, 0x36, 0x20, 0x62, + 0x79, 0x20, 0x4D, 0x69, 0x6B, 0x65, 0x20, 0x43, 0x68, 0x61, 0x6D, + 0x62, 0x65, 0x72, 0x73, 0x00, 0x00, 0x54, 0x65, 0x73, 0x74, 0x69, + 0x6E, 0x67, 0x20, 0x52, 0x41, 0x4D, 0x3A, 0x20, 0x20, 0x20, 0x20, + 0x4B, 0x20, 0x4F, 0x4B, 0x00, 0xC3, 0x20, 0x4D, 0x6F, 0x6E, 0x6F, + 0x2F, 0x48, 0x65, 0x72, 0x63, 0x75, 0x6C, 0x65, 0x73, 0x20, 0x47, + 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x00, 0x49, 0x6E, 0x73, + 0x65, 0x72, 0x74, 0x20, 0x42, 0x4F, 0x4F, 0x54, 0x20, 0x64, 0x69, + 0x73, 0x6B, 0x20, 0x69, 0x6E, 0x20, 0x41, 0x3A, 0x0D, 0x0A, 0x50, + 0x72, 0x65, 0x73, 0x73, 0x20, 0x61, 0x6E, 0x79, 0x20, 0x6B, 0x65, + 0x79, 0x20, 0x77, 0x68, 0x65, 0x6E, 0x20, 0x72, 0x65, 0x61, 0x64, + 0x79, 0x0D, 0x0A, 0x0A, 0x00, 0xFF, 0xFF, 0xFB, 0x33, 0xC0, 0x8E, + 0xD8, 0xC7, 0x06, 0x78, 0x00, 0xC7, 0xEF, 0x8C, 0x0E, 0x7A, 0x00, + 0xB8, 0x06, 0x00, 0x50, 0x33, 0xD2, 0x3C, 0x02, 0x77, 0x03, 0x80, + 0xCA, 0x80, 0x52, 0xB4, 0x00, 0xCD, 0x13, 0x5A, 0x72, 0x17, 0x33, + 0xC0, 0x8E, 0xC0, 0xB8, 0x01, 0x02, 0xBB, 0x00, 0x7C, 0xB1, 0x01, + 0xB5, 0x00, 0xCD, 0x13, 0x72, 0x05, 0xEA, 0x00, 0x7C, 0x00, 0x00, + 0x58, 0xFE, 0xC8, 0x75, 0xD2, 0x0A, 0xE4, 0x75, 0x10, 0x0E, 0x1F, + 0xBE, 0xCA, 0xE5, 0xE8, 0x36, 0x13, 0xE8, 0x94, 0x13, 0xB8, 0x08, + 0xFF, 0xEB, 0xBE, 0x33, 0xC0, 0x8E, 0xD8, 0xA1, 0x62, 0x00, 0x3D, + 0x00, 0xF6, 0x75, 0xE4, 0xCD, 0x18, 0x3C, 0xE0, 0x75, 0x10, 0x80, + 0xCB, 0x02, 0x59, 0x50, 0x55, 0x8B, 0xEC, 0xC7, 0x46, 0x02, 0xB3, + 0xE9, 0x5D, 0xEB, 0x54, 0x3C, 0x57, 0x74, 0x55, 0x3C, 0x58, 0x74, + 0x51, 0xF6, 0xC3, 0x02, 0x74, 0x47, 0x80, 0xE3, 0xFD, 0x3C, 0xAA, + 0x75, 0x06, 0x8A, 0xC7, 0x0C, 0x80, 0x8A, 0xE0, 0x8A, 0xF8, 0x8A, + 0xC8, 0x80, 0xE1, 0x7F, 0x80, 0xF9, 0x2A, 0x74, 0xCD, 0x80, 0xF9, + 0x36, 0x74, 0xC8, 0x3C, 0x35, 0x74, 0x25, 0x3C, 0x1C, 0x74, 0x21, + 0x3C, 0x1D, 0x74, 0x1D, 0x3C, 0x38, 0x74, 0x19, 0x3C, 0x46, 0x74, + 0x15, 0xE8, 0x88, 0x08, 0xE8, 0xFA, 0x04, 0x72, 0x0D, 0xB0, 0xE0, + 0x59, 0x50, 0x55, 0x8B, 0xEC, 0xC7, 0x46, 0x02, 0xA4, 0xEB, 0x5D, + 0x89, 0x1E, 0x96, 0x00, 0xC3, 0x80, 0xC4, 0x2E, 0xA0, 0x17, 0x00, + 0xA8, 0x08, 0x75, 0x0A, 0xA8, 0x04, 0x75, 0x09, 0xA8, 0x03, 0x75, + 0x08, 0xEB, 0x09, 0x80, 0xC4, 0x02, 0x80, 0xC4, 0x02, 0x80, 0xC4, + 0x02, 0x32, 0xC0, 0xEB, 0xCF, 0xFF, 0xFF, 0xE9, 0x0B, 0xFF, 0x32, + 0xC0, 0xB0, 0x40, 0xF6, 0xE0, 0x74, 0x04, 0xBE, 0xEB, 0xF7, 0xC3, + 0xBE, 0xF6, 0xF7, 0xC3, 0xDB, 0xE3, 0xBE, 0x00, 0x02, 0xC6, 0x44, + 0x01, 0x00, 0xD9, 0x3C, 0x8A, 0x64, 0x01, 0x80, 0xFC, 0x03, 0x75, + 0x06, 0x80, 0x0E, 0x10, 0x00, 0x02, 0xC3, 0x80, 0x26, 0x10, 0x00, + 0xFD, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x17, 0x04, 0x00, 0x03, + 0x80, 0x01, 0xC0, 0x00, 0x60, 0x00, 0x30, 0x00, 0x18, 0x00, 0x0C, + 0x00, 0xFB, 0x1E, 0x52, 0x56, 0x57, 0x51, 0x53, 0xBB, 0x40, 0x00, + 0x8E, 0xDB, 0x8B, 0xFA, 0x8B, 0xDA, 0xD1, 0xE3, 0x8B, 0x17, 0x0B, + 0xD2, 0x74, 0x10, 0x0A, 0xE4, 0x74, 0x13, 0xFE, 0xCC, 0x74, 0x3A, + 0xFE, 0xCC, 0x74, 0x53, 0xFE, 0xCC, 0x74, 0x63, 0x5B, 0x59, 0x5F, + 0x5E, 0x5A, 0x1F, 0xCF, 0x50, 0x8A, 0xD8, 0x83, 0xC2, 0x03, 0xB0, + 0x80, 0xEE, 0xB1, 0x04, 0xD2, 0xC3, 0x83, 0xE3, 0x0E, 0x2E, 0x8B, + 0x87, 0x29, 0xE7, 0x83, 0xEA, 0x03, 0xEE, 0x42, 0x8A, 0xC4, 0xEE, + 0x58, 0x42, 0x42, 0x24, 0x1F, 0xEE, 0xB0, 0x00, 0x4A, 0x4A, 0xEE, + 0x4A, 0xEB, 0x31, 0x50, 0xB0, 0x03, 0xB7, 0x30, 0xB3, 0x20, 0xE8, + 0x48, 0x00, 0x75, 0x09, 0x83, 0xEA, 0x05, 0x59, 0x8A, 0xC1, 0xEE, + 0xEB, 0xB9, 0x59, 0x8A, 0xC1, 0x80, 0xCC, 0x80, 0xEB, 0xB1, 0xB0, + 0x01, 0xB7, 0x20, 0xB3, 0x01, 0xE8, 0x2C, 0x00, 0x75, 0xF0, 0x80, + 0xE4, 0x1E, 0x83, 0xEA, 0x05, 0xEC, 0xEB, 0x9D, 0x83, 0xC2, 0x05, + 0xEC, 0x8A, 0xE0, 0x42, 0xEC, 0xEB, 0x93, 0x8A, 0x5D, 0x7C, 0x2B, + 0xC9, 0xEC, 0x8A, 0xE0, 0x22, 0xC7, 0x3A, 0xC7, 0x74, 0x08, 0xE2, + 0xF5, 0xFE, 0xCB, 0x75, 0xEF, 0x0A, 0xFF, 0xC3, 0x83, 0xC2, 0x04, + 0xEE, 0x42, 0x42, 0x53, 0xE8, 0xDF, 0xFF, 0x5B, 0x75, 0x06, 0x4A, + 0x8A, 0xFB, 0xE8, 0xD6, 0xFF, 0xC3, 0x53, 0x79, 0x73, 0x74, 0x65, + 0x6D, 0x20, 0x45, 0x72, 0x72, 0x6F, 0x72, 0x3A, 0x20, 0x00, 0xFA, + 0x8B, 0x1E, 0x1A, 0x00, 0x3B, 0x1E, 0x1C, 0x00, 0x8B, 0x07, 0xFB, + 0x5B, 0x1F, 0xCA, 0x02, 0x00, 0xA1, 0x17, 0x00, 0xEB, 0x2E, 0x8B, + 0xC1, 0xE8, 0xBA, 0x03, 0xB0, 0x00, 0x73, 0x25, 0xFE, 0xC0, 0xEB, + 0x21, 0xFF, 0xFF, 0xFF, 0xFB, 0x1E, 0x53, 0xBB, 0x40, 0x00, 0x8E, + 0xDB, 0x80, 0xFC, 0x05, 0x74, 0xE3, 0x8B, 0xD8, 0x80, 0xE4, 0x0F, + 0x0A, 0xE4, 0x74, 0x0B, 0xFE, 0xCC, 0x74, 0xC0, 0xFE, 0xCC, 0x74, + 0xCD, 0x5B, 0x1F, 0xCF, 0xFA, 0xA1, 0x1A, 0x00, 0x3B, 0x06, 0x1C, + 0x00, 0x75, 0x03, 0xFB, 0xEB, 0xF3, 0xF6, 0xC7, 0x10, 0x9C, 0x93, + 0x8B, 0x07, 0x9D, 0x75, 0x06, 0x3C, 0xE0, 0x75, 0x02, 0x32, 0xC0, + 0x43, 0x43, 0x89, 0x1E, 0x1A, 0x00, 0x3B, 0x1E, 0x82, 0x00, 0x75, + 0xD4, 0x8B, 0x1E, 0x80, 0x00, 0x89, 0x1E, 0x1A, 0x00, 0xEB, 0xCA, + 0xFF, 0xFF, 0xFF, 0x00, 0x37, 0x2E, 0x20, 0x2F, 0x30, 0x31, 0x21, + 0x32, 0x33, 0x34, 0x35, 0x22, 0x36, 0x38, 0x3E, 0x11, 0x17, 0x05, + 0x12, 0x14, 0x19, 0x15, 0x09, 0x0F, 0x10, 0x39, 0x3A, 0x3B, 0x84, + 0x01, 0x13, 0x04, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C, 0x3F, 0x40, + 0x41, 0x82, 0x3C, 0x1A, 0x18, 0x03, 0x16, 0x02, 0x0E, 0x0D, 0x42, + 0x43, 0x44, 0x81, 0x3D, 0x88, 0x2D, 0xC0, 0x23, 0x24, 0x25, 0x26, + 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0xA0, 0x90, 0x32, 0x36, 0x2D, + 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0x20, + 0x31, 0x33, 0x34, 0x35, 0x37, 0x38, 0x39, 0x30, 0x3D, 0x1B, 0x08, + 0x5B, 0x5D, 0x0D, 0x5C, 0x2A, 0x09, 0x3B, 0x27, 0x60, 0x2C, 0x2E, + 0x2F, 0x40, 0x5E, 0x5F, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, + 0xDB, 0xDC, 0xDD, 0x20, 0x21, 0x23, 0x24, 0x25, 0x26, 0x2A, 0x28, + 0x29, 0x2B, 0x1B, 0x08, 0x7B, 0x7D, 0x0D, 0x7C, 0x05, 0x8F, 0x3A, + 0x22, 0x7E, 0x3C, 0x3E, 0x3F, 0x03, 0x1E, 0x1F, 0xDE, 0xDF, 0xE0, + 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0x20, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x1B, 0x7F, 0x1B, 0x1D, 0x0A, + 0x1C, 0xF2, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0xF9, 0xFD, + 0x02, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, + 0x20, 0xF8, 0xFA, 0xFB, 0xFC, 0xFE, 0xFF, 0x00, 0x01, 0x03, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x37, 0x38, 0x39, 0x2D, 0x34, 0x35, 0x36, 0x2B, 0x31, + 0x32, 0x33, 0x30, 0x2E, 0xF7, 0x05, 0x04, 0x05, 0xF3, 0x05, 0xF4, + 0x05, 0xF5, 0x05, 0xF6, 0x05, 0x05, 0xC7, 0xC8, 0xC9, 0x2D, 0xCB, + 0x05, 0xCD, 0x2B, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xFB, 0x50, 0x53, + 0x51, 0x52, 0x56, 0x57, 0x1E, 0xFC, 0xB8, 0x40, 0x00, 0x8E, 0xD8, + 0xE4, 0x60, 0x50, 0xE4, 0x61, 0x50, 0x0C, 0x80, 0xE6, 0x61, 0x58, + 0xE6, 0x61, 0x58, 0x8A, 0xE0, 0x8B, 0x1E, 0x96, 0x00, 0xE8, 0xB6, + 0xFC, 0x3C, 0xFF, 0x75, 0x0F, 0xE9, 0xF6, 0x01, 0xB0, 0x20, 0xE6, + 0x20, 0x1F, 0x5F, 0x5E, 0x5A, 0x59, 0x5B, 0x58, 0xCF, 0x24, 0x7F, + 0x3C, 0x46, 0x76, 0x03, 0xE9, 0x22, 0x01, 0xBB, 0x85, 0xE8, 0x2E, + 0xD7, 0x0A, 0xC0, 0x78, 0x06, 0x0A, 0xE4, 0x78, 0xDE, 0xEB, 0x4D, + 0x24, 0x7F, 0x0A, 0xE4, 0x78, 0x21, 0x3C, 0x10, 0x73, 0x06, 0x08, + 0x06, 0x17, 0x00, 0xEB, 0xCC, 0xF6, 0x06, 0x17, 0x00, 0x04, 0x75, + 0x36, 0x84, 0x06, 0x18, 0x00, 0x75, 0xBF, 0x08, 0x06, 0x18, 0x00, + 0x30, 0x06, 0x17, 0x00, 0xEB, 0xB5, 0x3C, 0x10, 0x73, 0x1A, 0xF6, + 0xD0, 0x20, 0x06, 0x17, 0x00, 0x3C, 0xF7, 0x75, 0xA7, 0xA0, 0x19, + 0x00, 0xB4, 0x00, 0x88, 0x26, 0x19, 0x00, 0x3A, 0xC4, 0x74, 0x9A, + 0xE9, 0x95, 0x01, 0xF6, 0xD0, 0x20, 0x06, 0x18, 0x00, 0xEB, 0x8F, + 0xF6, 0x06, 0x18, 0x00, 0x08, 0x74, 0x0D, 0x80, 0xFC, 0x45, 0x74, + 0x05, 0x80, 0x26, 0x18, 0x00, 0xF7, 0xE9, 0x7B, 0xFF, 0x8A, 0x16, + 0x17, 0x00, 0xF6, 0xC2, 0x08, 0x75, 0x1D, 0xF6, 0xC2, 0x04, 0x75, + 0x2B, 0xF6, 0xC2, 0x03, 0x75, 0x7E, 0x3C, 0x1A, 0x77, 0x05, 0x04, + 0x60, 0xE9, 0x16, 0x01, 0xBB, 0xCC, 0xE8, 0x2C, 0x20, 0x2E, 0xD7, + 0xE9, 0x0C, 0x01, 0x3C, 0x1A, 0x77, 0x05, 0xB0, 0x00, 0xE9, 0x3D, + 0x01, 0xBB, 0x3B, 0xE9, 0x2C, 0x20, 0x2E, 0xD7, 0xE9, 0xF9, 0x00, + 0x80, 0xFC, 0x46, 0x75, 0x15, 0xC6, 0x06, 0x71, 0x00, 0x80, 0xA1, + 0x80, 0x00, 0xA3, 0x1C, 0x00, 0xA3, 0x1A, 0x00, 0xCD, 0x1B, 0x2B, + 0xC0, 0xE9, 0xF1, 0x00, 0x80, 0xFC, 0x45, 0x75, 0x21, 0x80, 0x0E, + 0x18, 0x00, 0x08, 0xB0, 0x20, 0xE6, 0x20, 0x80, 0x3E, 0x49, 0x00, + 0x07, 0x74, 0x07, 0xBA, 0xD8, 0x03, 0xA0, 0x65, 0x00, 0xEE, 0xF6, + 0x06, 0x18, 0x00, 0x08, 0x75, 0xF9, 0xE9, 0x06, 0xFF, 0x80, 0xFC, + 0x03, 0x75, 0x05, 0xB0, 0x00, 0xE9, 0xE9, 0x00, 0x3C, 0x1A, 0x76, + 0xF9, 0xBB, 0x16, 0xE9, 0x2C, 0x20, 0x2E, 0xD7, 0xE9, 0xA1, 0x00, + 0x80, 0xFC, 0x37, 0x75, 0x09, 0xB0, 0x20, 0xE6, 0x20, 0xCD, 0x05, + 0xE9, 0xE0, 0xFE, 0x3C, 0x1A, 0x77, 0x05, 0x04, 0x40, 0xE9, 0x8A, + 0x00, 0xBB, 0xF1, 0xE8, 0x2C, 0x20, 0x2E, 0xD7, 0xE9, 0x80, 0x00, + 0x2C, 0x47, 0x8A, 0x1E, 0x17, 0x00, 0xF6, 0xC3, 0x08, 0x75, 0x18, + 0xF6, 0xC3, 0x04, 0x75, 0x50, 0xF6, 0xC3, 0x20, 0x74, 0x07, 0xF6, + 0xC3, 0x03, 0x75, 0x51, 0xEB, 0x5B, 0xF6, 0xC3, 0x03, 0x74, 0x4A, + 0xEB, 0x54, 0x0A, 0xE4, 0x78, 0x36, 0xF6, 0x06, 0x17, 0x00, 0x04, + 0x74, 0x16, 0x80, 0xFC, 0x53, 0x75, 0x09, 0xC7, 0x06, 0x72, 0x00, + 0x34, 0x12, 0xE9, 0x40, 0xF5, 0x80, 0xFC, 0x4A, 0x75, 0x03, 0xE8, + 0xD1, 0x00, 0xBB, 0x60, 0xE9, 0x2E, 0xD7, 0x3C, 0x30, 0x72, 0x10, + 0x2C, 0x30, 0x8A, 0xD8, 0xA0, 0x19, 0x00, 0xB4, 0x0A, 0xF6, 0xE4, + 0x02, 0xC3, 0xA2, 0x19, 0x00, 0xE9, 0x69, 0xFE, 0x0A, 0xE4, 0x78, + 0xF9, 0xBB, 0x6D, 0xE9, 0x2E, 0xD7, 0xEB, 0x15, 0xE8, 0x5D, 0x00, + 0x72, 0xED, 0xBB, 0x7A, 0xE9, 0x2E, 0xD7, 0xEB, 0x09, 0x0A, 0xE4, + 0x78, 0xE2, 0xBB, 0x60, 0xE9, 0x2E, 0xD7, 0x3C, 0x05, 0x74, 0x40, + 0x3C, 0x04, 0x77, 0x04, 0x0C, 0x80, 0xEB, 0x06, 0xA8, 0x80, 0x74, + 0x06, 0x24, 0x7F, 0x8A, 0xE0, 0xB0, 0x00, 0xF6, 0x06, 0x17, 0x00, + 0x40, 0x74, 0x1D, 0xF6, 0x06, 0x17, 0x00, 0x03, 0x74, 0x0C, 0x3C, + 0x41, 0x72, 0x12, 0x3C, 0x5A, 0x77, 0x0E, 0x04, 0x20, 0xEB, 0x0A, + 0x3C, 0x61, 0x72, 0x06, 0x3C, 0x7A, 0x77, 0x02, 0x2C, 0x20, 0xE8, + 0x36, 0x00, 0x73, 0x05, 0xB3, 0x01, 0xE8, 0x3A, 0x0E, 0xE9, 0x02, + 0xFE, 0xB4, 0x38, 0xEB, 0xEF, 0x80, 0xFC, 0xD2, 0x75, 0x07, 0x80, + 0x26, 0x18, 0x00, 0x7F, 0xF9, 0xC3, 0x0A, 0xE4, 0x78, 0xFA, 0x80, + 0xFC, 0x52, 0x75, 0x11, 0xF6, 0x06, 0x18, 0x00, 0x80, 0x75, 0x0A, + 0x80, 0x36, 0x17, 0x00, 0x80, 0x80, 0x0E, 0x18, 0x00, 0x80, 0xF8, + 0xC3, 0x8B, 0x1E, 0x1C, 0x00, 0x8B, 0xFB, 0x43, 0x43, 0x3B, 0x1E, + 0x82, 0x00, 0x75, 0x04, 0x8B, 0x1E, 0x80, 0x00, 0x3B, 0x1E, 0x1A, + 0x00, 0x75, 0x02, 0xF9, 0xC3, 0x89, 0x05, 0x89, 0x1E, 0x1C, 0x00, + 0xF8, 0xC3, 0x50, 0x53, 0x51, 0xE4, 0x61, 0x34, 0x0C, 0xE6, 0x61, + 0xBB, 0x89, 0x0F, 0x24, 0x04, 0x74, 0x03, 0xBB, 0x2E, 0x05, 0xB0, + 0xB6, 0xE6, 0x43, 0x8B, 0xC3, 0xE6, 0x42, 0x8A, 0xC4, 0xE6, 0x42, + 0xE4, 0x61, 0x50, 0x0C, 0x03, 0xE6, 0x61, 0xB9, 0x00, 0x20, 0xE2, + 0xFE, 0x58, 0xE6, 0x61, 0x59, 0x5B, 0x58, 0xC3, 0x4E, 0x6F, 0x20, + 0x52, 0x4F, 0x4D, 0x20, 0x42, 0x41, 0x53, 0x49, 0x43, 0x2C, 0x20, + 0x62, 0x6F, 0x6F, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x64, 0x69, 0x73, 0x6B, 0x2E, 0x2E, 0x2E, 0x00, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0x55, 0x56, 0x57, 0x1E, 0x06, 0x53, + 0x8B, 0xF8, 0x33, 0xC0, 0x8E, 0xD8, 0xC4, 0x36, 0x78, 0x00, 0xB8, + 0x40, 0x00, 0x8E, 0xD8, 0xBB, 0x05, 0x00, 0x26, 0x8B, 0x00, 0x50, + 0x4B, 0x4B, 0x26, 0x8B, 0x00, 0x50, 0x86, 0xCE, 0x86, 0xD1, 0x52, + 0x51, 0x57, 0x8B, 0xEC, 0xE8, 0x22, 0x00, 0x26, 0x8A, 0x64, 0x02, + 0x88, 0x26, 0x40, 0x00, 0x8A, 0x26, 0x41, 0x00, 0x80, 0xFC, 0x01, + 0xF5, 0x5B, 0x59, 0x5A, 0x86, 0xD1, 0x86, 0xCE, 0x5B, 0x5B, 0x5B, + 0x07, 0x1F, 0x5F, 0x5E, 0x5D, 0xCA, 0x02, 0x00, 0x8A, 0x46, 0x01, + 0x0A, 0xC0, 0x74, 0x1B, 0xFE, 0xC8, 0x74, 0x13, 0x80, 0x7E, 0x02, + 0x03, 0x77, 0x04, 0x3C, 0x05, 0x76, 0x06, 0xC6, 0x06, 0x41, 0x00, + 0x01, 0xC3, 0xE9, 0x81, 0x00, 0xA0, 0x41, 0x00, 0xC3, 0xBA, 0xF2, + 0x03, 0xFA, 0x80, 0x26, 0x3F, 0x00, 0x0F, 0xA0, 0x3F, 0x00, 0xB1, + 0x04, 0xD2, 0xE0, 0xA8, 0x20, 0x75, 0x0C, 0xA8, 0x40, 0x75, 0x06, + 0xA8, 0x80, 0x74, 0x06, 0xFE, 0xC0, 0xFE, 0xC0, 0xFE, 0xC0, 0xC6, + 0x06, 0x3E, 0x00, 0x00, 0xC6, 0x06, 0x41, 0x00, 0x00, 0x0C, 0x08, + 0xEE, 0x0C, 0x04, 0xEE, 0xFB, 0xE8, 0xB3, 0x01, 0xE8, 0x66, 0x02, + 0xA0, 0x42, 0x00, 0x3C, 0xC0, 0x74, 0x07, 0xC6, 0x06, 0x41, 0x00, + 0x20, 0xEB, 0x12, 0xB0, 0x03, 0xE8, 0x7B, 0x02, 0x26, 0x8A, 0x04, + 0xE8, 0x75, 0x02, 0x26, 0x8A, 0x44, 0x01, 0xE8, 0x6E, 0x02, 0xC3, + 0x03, 0x00, 0xE6, 0xC5, 0xE6, 0x4D, 0x00, 0x00, 0x46, 0x4A, 0x42, + 0x4A, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x01, 0x02, 0x04, 0x08, + 0x80, 0x20, 0x10, 0x04, 0x02, 0x01, 0x04, 0x10, 0x08, 0x04, 0x03, + 0x02, 0x20, 0xFA, 0xC6, 0x06, 0x41, 0x00, 0x00, 0x8A, 0x46, 0x01, + 0xB4, 0x00, 0x8B, 0xF8, 0xE6, 0x0C, 0x2E, 0x8A, 0x85, 0x2C, 0xED, + 0xE6, 0x0B, 0x8B, 0x46, 0x0C, 0xB1, 0x04, 0xD3, 0xC0, 0x8A, 0xE8, + 0x80, 0xE5, 0x0F, 0x24, 0xF0, 0x03, 0x46, 0x0A, 0x80, 0xD5, 0x00, + 0x8B, 0xD0, 0xE6, 0x04, 0x8A, 0xC4, 0xE6, 0x04, 0x8A, 0xC5, 0xE6, + 0x81, 0x8A, 0x66, 0x00, 0xB0, 0x00, 0xD1, 0xE8, 0x8A, 0x4E, 0x06, + 0xD3, 0xE0, 0x48, 0xE6, 0x05, 0x86, 0xC4, 0xE6, 0x05, 0x86, 0xC4, + 0x03, 0xC2, 0x73, 0x09, 0xFB, 0xC6, 0x06, 0x41, 0x00, 0x09, 0xE9, + 0x11, 0x01, 0xB0, 0x02, 0xE6, 0x0A, 0xC6, 0x06, 0x40, 0x00, 0xFF, + 0x8A, 0x5E, 0x02, 0xB7, 0x00, 0x2E, 0x8A, 0x87, 0x38, 0xED, 0x8A, + 0xE8, 0xB1, 0x04, 0xD2, 0xE0, 0x0A, 0xC3, 0x0C, 0x0C, 0xBA, 0xF2, + 0x03, 0xEE, 0xFB, 0x2E, 0x8A, 0x85, 0x32, 0xED, 0x08, 0x06, 0x3F, + 0x00, 0x0A, 0xC0, 0x79, 0x11, 0x26, 0x8A, 0x64, 0x0A, 0x0A, 0xE4, + 0x74, 0x09, 0x84, 0x2E, 0x3F, 0x00, 0x75, 0x03, 0xE8, 0x27, 0x01, + 0x08, 0x2E, 0x3F, 0x00, 0x84, 0x2E, 0x3E, 0x00, 0x75, 0x14, 0x08, + 0x2E, 0x3E, 0x00, 0xB0, 0x07, 0xE8, 0x9F, 0x01, 0x8A, 0xC3, 0xE8, + 0x9A, 0x01, 0xE8, 0xB9, 0x00, 0xE8, 0xBB, 0x01, 0xB0, 0x0F, 0xE8, + 0x8F, 0x01, 0x8A, 0xC3, 0xE8, 0x8A, 0x01, 0x8A, 0x46, 0x03, 0xE8, + 0x84, 0x01, 0xE8, 0xA3, 0x00, 0xE8, 0x56, 0x01, 0x26, 0x8A, 0x44, + 0x09, 0x0A, 0xC0, 0x74, 0x09, 0xB9, 0x26, 0x02, 0xE2, 0xFE, 0xFE, + 0xC8, 0x75, 0xF7, 0x2E, 0x8A, 0x85, 0x26, 0xED, 0xE8, 0x65, 0x01, + 0x8A, 0x46, 0x04, 0x24, 0x01, 0xD0, 0xE0, 0xD0, 0xE0, 0x0A, 0xC3, + 0xE8, 0x57, 0x01, 0x80, 0x7E, 0x01, 0x05, 0x75, 0x1C, 0x8A, 0x46, + 0x06, 0xE8, 0x4B, 0x01, 0x8A, 0x46, 0x07, 0xE8, 0x45, 0x01, 0x26, + 0x8A, 0x44, 0x07, 0xE8, 0x3E, 0x01, 0x26, 0x8A, 0x44, 0x08, 0xE8, + 0x37, 0x01, 0xEB, 0x0E, 0xB9, 0x07, 0x00, 0xBF, 0x03, 0x00, 0x8A, + 0x03, 0xE8, 0x2A, 0x01, 0x47, 0xE2, 0xF8, 0xE8, 0x46, 0x00, 0xE8, + 0xFE, 0x00, 0xA0, 0x42, 0x00, 0x24, 0xC0, 0x74, 0x25, 0x3C, 0x40, + 0x74, 0x07, 0xC6, 0x06, 0x41, 0x00, 0x20, 0xEB, 0x1A, 0xA0, 0x43, + 0x00, 0xB9, 0x06, 0x00, 0x33, 0xDB, 0x2E, 0x84, 0x87, 0x3C, 0xED, + 0x75, 0x03, 0x43, 0xE2, 0xF6, 0x2E, 0x8A, 0x87, 0x42, 0xED, 0xA2, + 0x41, 0x00, 0xA0, 0x45, 0x00, 0x3A, 0x46, 0x03, 0xA0, 0x47, 0x00, + 0x74, 0x05, 0x8A, 0x46, 0x07, 0xFE, 0xC0, 0x2A, 0x46, 0x05, 0xC3, + 0xB0, 0x00, 0xC3, 0xFB, 0x33, 0xC9, 0xB0, 0x02, 0xF6, 0x06, 0x3E, + 0x00, 0x80, 0xF8, 0x75, 0x10, 0xE2, 0xF6, 0xFE, 0xC8, 0x75, 0xF2, + 0xC6, 0x06, 0x41, 0x00, 0x80, 0x58, 0xB0, 0x00, 0xF9, 0xC3, 0x80, + 0x26, 0x3E, 0x00, 0x7F, 0xC3, 0x51, 0x33, 0xC9, 0xBA, 0xF4, 0x03, + 0xEC, 0x0A, 0xC0, 0x78, 0x09, 0xE2, 0xF9, 0xC6, 0x06, 0x41, 0x00, + 0x80, 0xEB, 0x09, 0xA8, 0x40, 0x75, 0x08, 0xC6, 0x06, 0x41, 0x00, + 0x20, 0x59, 0xF9, 0xC3, 0x42, 0xEC, 0x50, 0xB9, 0x0A, 0x00, 0xE2, + 0xFE, 0x4A, 0xEC, 0xA8, 0x10, 0xF8, 0x58, 0x59, 0xC3, 0x51, 0x33, + 0xC9, 0xE2, 0xFE, 0xFE, 0xCC, 0x75, 0xF8, 0x59, 0xC3, 0xBD, 0x04, + 0x00, 0xBB, 0x00, 0xB0, 0x3C, 0x07, 0x74, 0x06, 0xBD, 0x10, 0x00, + 0xBB, 0x00, 0xB8, 0x53, 0x07, 0xA0, 0x65, 0x00, 0x24, 0xF7, 0x8B, + 0x16, 0x63, 0x00, 0x83, 0xC2, 0x04, 0xEE, 0xE8, 0xE4, 0x0A, 0x4D, + 0x75, 0xFA, 0x73, 0x05, 0x80, 0x0E, 0x15, 0x00, 0x04, 0xC3, 0x3C, + 0x53, 0x75, 0x11, 0x8A, 0x0E, 0x17, 0x00, 0xF6, 0xC1, 0x04, 0x74, + 0x08, 0xF6, 0xC1, 0x08, 0x74, 0x03, 0xE9, 0xC8, 0xFB, 0xC3, 0xFF, + 0xFB, 0x1E, 0x50, 0xB8, 0x40, 0x00, 0x8E, 0xD8, 0x80, 0x0E, 0x3E, + 0x00, 0x80, 0xB0, 0x20, 0xE6, 0x20, 0x58, 0x1F, 0xCF, 0xB0, 0x08, + 0xE8, 0x23, 0x00, 0x53, 0x51, 0xB9, 0x07, 0x00, 0x33, 0xDB, 0xE8, + 0x5E, 0xFF, 0x72, 0x0D, 0x88, 0x47, 0x42, 0x74, 0x0F, 0x43, 0xE2, + 0xF3, 0xC6, 0x06, 0x41, 0x00, 0x20, 0xF9, 0x59, 0x5B, 0x58, 0xB0, + 0x00, 0xC3, 0x59, 0x5B, 0xC3, 0x51, 0x52, 0x50, 0x33, 0xC9, 0xBA, + 0xF4, 0x03, 0xEC, 0x0A, 0xC0, 0x78, 0x09, 0xE2, 0xF9, 0xC6, 0x06, + 0x41, 0x00, 0x80, 0xEB, 0x12, 0xA8, 0x40, 0x74, 0x07, 0xC6, 0x06, + 0x41, 0x00, 0x20, 0xEB, 0x07, 0x42, 0x58, 0xEE, 0xF8, 0x5A, 0x59, + 0xC3, 0x58, 0x5A, 0x59, 0x58, 0xB0, 0x00, 0xF9, 0xC3, 0xFF, 0xFF, + 0xFF, 0xFF, 0xCF, 0x02, 0x25, 0x02, 0x08, 0x2A, 0xFF, 0x50, 0xF6, + 0x19, 0x04, 0xFB, 0x1E, 0x53, 0x51, 0x52, 0xBB, 0x40, 0x00, 0x8E, + 0xDB, 0x8B, 0xDA, 0xD1, 0xE3, 0x8B, 0x57, 0x08, 0x0B, 0xD2, 0x74, + 0x0C, 0x0A, 0xE4, 0x74, 0x0D, 0xFE, 0xCC, 0x74, 0x39, 0xFE, 0xCC, + 0x74, 0x29, 0x5A, 0x59, 0x5B, 0x1F, 0xCF, 0xEE, 0x42, 0x8A, 0x7F, + 0x78, 0x8A, 0xE0, 0x33, 0xC9, 0xEC, 0x0A, 0xC0, 0x78, 0x0C, 0xE2, + 0xF9, 0xFE, 0xCF, 0x75, 0xF3, 0x0C, 0x01, 0x24, 0xF9, 0xEB, 0x10, + 0x42, 0xB0, 0x0D, 0xEE, 0xB0, 0x0C, 0xEE, 0x4A, 0xEB, 0x03, 0x8A, + 0xE0, 0x42, 0xEC, 0x24, 0xF8, 0x34, 0x48, 0x86, 0xC4, 0xEB, 0xCB, + 0x8A, 0xE0, 0x42, 0x42, 0xB0, 0x08, 0xEE, 0xB9, 0xDC, 0x05, 0xE2, + 0xFE, 0xEB, 0xE0, 0xC3, 0x20, 0x43, 0x47, 0x41, 0x20, 0x47, 0x72, + 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x00, 0x15, 0xF1, 0xBC, 0xF1, + 0xC9, 0xF1, 0xD9, 0xF1, 0xF5, 0xF1, 0x76, 0xF2, 0x96, 0xF2, 0x96, + 0xF2, 0xE2, 0xF3, 0xE2, 0xF3, 0xE2, 0xF3, 0xBC, 0xF5, 0xE7, 0xF5, + 0x2A, 0xF6, 0x53, 0xF6, 0xD1, 0xF6, 0xFB, 0xFC, 0x55, 0x06, 0x1E, + 0x56, 0x57, 0x52, 0x51, 0x53, 0x50, 0xBB, 0x40, 0x00, 0x8E, 0xDB, + 0x8A, 0x1E, 0x10, 0x00, 0x80, 0xE3, 0x30, 0x80, 0xFB, 0x30, 0xBB, + 0x00, 0xB8, 0x75, 0x03, 0xBB, 0x00, 0xB0, 0x53, 0x8B, 0xEC, 0xE8, + 0x77, 0x00, 0x5E, 0x58, 0x5B, 0x59, 0x5A, 0x5F, 0x5E, 0x1F, 0x07, + 0x5D, 0xCF, 0x52, 0xB4, 0x00, 0xF7, 0xE3, 0x5A, 0x8B, 0x4E, 0x00, + 0xC3, 0xC0, 0x00, 0x38, 0x28, 0x2D, 0x0A, 0x1F, 0x06, 0x19, 0x1C, + 0x02, 0x07, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x71, 0x50, 0x5A, + 0x0A, 0x1F, 0x06, 0x19, 0x1C, 0x02, 0x07, 0x06, 0x07, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x28, 0x2D, 0x0A, 0x7F, 0x06, 0x64, 0x70, 0x02, + 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x61, 0x50, 0x52, 0x0F, + 0x19, 0x06, 0x19, 0x19, 0x02, 0x0D, 0x0B, 0x0C, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x40, 0x00, 0x40, 0x28, 0x28, + 0x50, 0x50, 0x28, 0x28, 0x50, 0x50, 0x2C, 0x28, 0x2D, 0x29, 0x2A, + 0x2E, 0x1E, 0x29, 0x00, 0x00, 0x10, 0x10, 0x20, 0x20, 0x20, 0x30, + 0x80, 0xFC, 0x0F, 0x76, 0x01, 0xC3, 0xD0, 0xE4, 0x8A, 0xDC, 0xB7, + 0x00, 0x2E, 0xFF, 0xA7, 0x45, 0xF0, 0xA0, 0x10, 0x00, 0xBA, 0xB4, + 0x03, 0x24, 0x30, 0x3C, 0x30, 0xB0, 0x01, 0xB3, 0x07, 0x74, 0x07, + 0x8A, 0x5E, 0x02, 0xB2, 0xD4, 0xFE, 0xC8, 0x89, 0x16, 0x63, 0x00, + 0x80, 0xC2, 0x04, 0xEE, 0x88, 0x1E, 0x49, 0x00, 0x1E, 0x33, 0xC0, + 0x8E, 0xD8, 0xC4, 0x36, 0x74, 0x00, 0x1F, 0xB7, 0x00, 0x53, 0x2E, + 0x8A, 0x9F, 0xFC, 0xF0, 0x03, 0xF3, 0xB9, 0x10, 0x00, 0x26, 0x8A, + 0x04, 0xE8, 0x2D, 0x06, 0xFE, 0xC4, 0x46, 0xE2, 0xF5, 0x8B, 0x5E, + 0x00, 0x8E, 0xC3, 0x33, 0xFF, 0xE8, 0x80, 0x05, 0xB9, 0x00, 0x20, + 0xB8, 0x00, 0x00, 0x72, 0x08, 0x75, 0x03, 0xB9, 0x00, 0x08, 0xB8, + 0x20, 0x07, 0xF3, 0xAB, 0x8B, 0x16, 0x63, 0x00, 0x80, 0xC2, 0x04, + 0x5B, 0x2E, 0x8A, 0x87, 0xF4, 0xF0, 0xEE, 0xA2, 0x65, 0x00, 0x42, + 0xB0, 0x30, 0x80, 0xFB, 0x06, 0x75, 0x02, 0xB0, 0x3F, 0xA2, 0x66, + 0x00, 0xEE, 0x33, 0xC0, 0xA3, 0x4E, 0x00, 0xA2, 0x62, 0x00, 0xB9, + 0x08, 0x00, 0xBF, 0x50, 0x00, 0x89, 0x05, 0x47, 0xE2, 0xFB, 0x2E, + 0x8A, 0x87, 0xEC, 0xF0, 0xA3, 0x4A, 0x00, 0x80, 0xE3, 0xFE, 0x2E, + 0x8B, 0x87, 0xE4, 0xF0, 0xA3, 0x4C, 0x00, 0xC3, 0x8B, 0x4E, 0x06, + 0x89, 0x0E, 0x60, 0x00, 0xB4, 0x0A, 0xE8, 0xB1, 0x05, 0xC3, 0x8A, + 0x5E, 0x05, 0xD0, 0xE3, 0xB7, 0x00, 0x8B, 0x46, 0x08, 0x89, 0x47, + 0x50, 0xE9, 0x8B, 0x05, 0x8A, 0x5E, 0x05, 0xD0, 0xE3, 0xB7, 0x00, + 0x8B, 0x47, 0x50, 0x89, 0x46, 0x08, 0xA1, 0x60, 0x00, 0x89, 0x46, + 0x06, 0xC3, 0x03, 0x03, 0x05, 0x05, 0x03, 0x03, 0x03, 0x04, 0x8B, + 0x16, 0x63, 0x00, 0x80, 0xC2, 0x06, 0xC6, 0x46, 0x03, 0x00, 0xEC, + 0xA8, 0x04, 0x74, 0x68, 0xA8, 0x02, 0x75, 0x01, 0xC3, 0xB4, 0x10, + 0xE8, 0x10, 0x05, 0x8A, 0x1E, 0x49, 0x00, 0x8A, 0xCB, 0xB7, 0x00, + 0x2E, 0x8A, 0x9F, 0xED, 0xF1, 0x2B, 0xCB, 0x79, 0x02, 0x33, 0xC0, + 0xE8, 0xBF, 0x04, 0x73, 0x25, 0xB5, 0x28, 0xF6, 0xF2, 0x8A, 0xDC, + 0xB7, 0x00, 0xB1, 0x03, 0xD3, 0xE3, 0x8A, 0xE8, 0xD0, 0xE5, 0x8A, + 0xD4, 0x8A, 0xF0, 0xD0, 0xEE, 0xD0, 0xEE, 0x80, 0x3E, 0x49, 0x00, + 0x06, 0x75, 0x1A, 0xD0, 0xE2, 0xD1, 0xE3, 0xEB, 0x14, 0xF6, 0x36, + 0x4A, 0x00, 0x86, 0xC4, 0x8B, 0xD0, 0xB1, 0x03, 0xD2, 0xE4, 0x8A, + 0xEC, 0x8A, 0xD8, 0xB7, 0x00, 0xD3, 0xE3, 0xC6, 0x46, 0x03, 0x01, + 0x89, 0x56, 0x08, 0x89, 0x5E, 0x04, 0x88, 0x6E, 0x07, 0x8B, 0x16, + 0x63, 0x00, 0x83, 0xC2, 0x07, 0xEE, 0xC3, 0x8A, 0x46, 0x02, 0xA2, + 0x62, 0x00, 0xB4, 0x00, 0x50, 0x8B, 0x1E, 0x4C, 0x00, 0xF7, 0xE3, + 0xA3, 0x4E, 0x00, 0xD1, 0xE8, 0x8B, 0xC8, 0xB4, 0x0C, 0xE8, 0xE8, + 0x04, 0x5B, 0xE8, 0xD7, 0x04, 0xC3, 0xE8, 0x4B, 0x04, 0x73, 0x03, + 0xE9, 0x9B, 0x00, 0xFC, 0x80, 0x3E, 0x49, 0x00, 0x02, 0x72, 0x15, + 0x80, 0x3E, 0x49, 0x00, 0x03, 0x77, 0x0E, 0xBA, 0xDA, 0x03, 0xEC, + 0xA8, 0x08, 0x74, 0xFB, 0xBA, 0xD8, 0x03, 0xB0, 0x25, 0xEE, 0x8B, + 0x46, 0x08, 0x50, 0x80, 0x7E, 0x03, 0x07, 0x74, 0x03, 0x8B, 0x46, + 0x06, 0xE8, 0x75, 0x04, 0x03, 0x06, 0x4E, 0x00, 0x8B, 0xF0, 0x8B, + 0xF8, 0x5A, 0x2B, 0x56, 0x06, 0x81, 0xC2, 0x01, 0x01, 0x8B, 0x1E, + 0x4A, 0x00, 0xD1, 0xE3, 0x1E, 0x8A, 0x46, 0x02, 0xE8, 0xB0, 0xFD, + 0x8E, 0xC1, 0x8E, 0xD9, 0x80, 0x7E, 0x03, 0x06, 0x74, 0x05, 0xF7, + 0xD8, 0xF7, 0xDB, 0xFD, 0x8A, 0x4E, 0x02, 0x0A, 0xC9, 0x74, 0x1A, + 0x03, 0xF0, 0x2A, 0x76, 0x02, 0xB5, 0x00, 0x8A, 0xCA, 0x57, 0x56, + 0xF3, 0xA5, 0x5E, 0x5F, 0x03, 0xF3, 0x03, 0xFB, 0xFE, 0xCE, 0x75, + 0xEE, 0x8A, 0x76, 0x02, 0xB5, 0x00, 0x8A, 0x66, 0x05, 0xB0, 0x20, + 0x8A, 0xCA, 0x57, 0xF3, 0xAB, 0x5F, 0x03, 0xFB, 0xFE, 0xCE, 0x75, + 0xF4, 0x1F, 0xE8, 0xB5, 0x03, 0x74, 0x07, 0xA0, 0x65, 0x00, 0xBA, + 0xD8, 0x03, 0xEE, 0xC3, 0xFC, 0x8B, 0x46, 0x08, 0x50, 0x80, 0x7E, + 0x03, 0x07, 0x74, 0x03, 0x8B, 0x46, 0x06, 0xE8, 0x07, 0x04, 0x8B, + 0xF8, 0x5A, 0x2B, 0x56, 0x06, 0x81, 0xC2, 0x01, 0x01, 0xD0, 0xE6, + 0xD0, 0xE6, 0x8A, 0x46, 0x03, 0x80, 0x3E, 0x49, 0x00, 0x06, 0x74, + 0x09, 0xD0, 0xE2, 0xD1, 0xE7, 0x3C, 0x07, 0x75, 0x01, 0x47, 0x3C, + 0x07, 0x75, 0x04, 0x81, 0xC7, 0xF0, 0x00, 0x8A, 0x5E, 0x02, 0xD0, + 0xE3, 0xD0, 0xE3, 0x53, 0x2A, 0xF3, 0xB0, 0x50, 0xF6, 0xE3, 0xBB, + 0xB0, 0x1F, 0x80, 0x7E, 0x03, 0x06, 0x74, 0x06, 0xF7, 0xD8, 0xBB, + 0x50, 0x20, 0xFD, 0x8B, 0xF7, 0x03, 0xF0, 0x58, 0x0A, 0xC0, 0x8B, + 0x4E, 0x00, 0x8E, 0xD9, 0x8E, 0xC1, 0x74, 0x26, 0x50, 0xB5, 0x00, + 0x8A, 0xCA, 0x56, 0x57, 0xF3, 0xA4, 0x5F, 0x5E, 0x81, 0xC6, 0x00, + 0x20, 0x81, 0xC7, 0x00, 0x20, 0x8A, 0xCA, 0x56, 0x57, 0xF3, 0xA4, + 0x5F, 0x5E, 0x2B, 0xF3, 0x2B, 0xFB, 0xFE, 0xCE, 0x75, 0xDE, 0x58, + 0x8A, 0xF0, 0x8A, 0x46, 0x05, 0xB5, 0x00, 0x8A, 0xCA, 0x57, 0xF3, + 0xAA, 0x5F, 0x81, 0xC7, 0x00, 0x20, 0x8A, 0xCA, 0x57, 0xF3, 0xAA, + 0x5F, 0x2B, 0xFB, 0xFE, 0xCE, 0x75, 0xEA, 0xC3, 0xE8, 0xFF, 0x02, + 0x72, 0x70, 0x8A, 0x5E, 0x05, 0xB7, 0x00, 0x53, 0xE8, 0x49, 0x03, + 0x8B, 0xF8, 0x58, 0xF7, 0x26, 0x4C, 0x00, 0x03, 0xF8, 0x8B, 0xF7, + 0x8B, 0x16, 0x63, 0x00, 0x83, 0xC2, 0x06, 0x1E, 0x8B, 0x5E, 0x00, + 0x8E, 0xDB, 0x8E, 0xC3, 0x8A, 0x46, 0x03, 0x3C, 0x08, 0x75, 0x14, + 0xEC, 0xA8, 0x01, 0x75, 0xFB, 0xFA, 0xEC, 0xA8, 0x01, 0x74, 0xFB, + 0xAD, 0x1F, 0x88, 0x46, 0x02, 0x88, 0x66, 0x03, 0xC3, 0x8A, 0x5E, + 0x02, 0x8A, 0x7E, 0x04, 0x8B, 0x4E, 0x06, 0x3C, 0x0A, 0x74, 0x12, + 0xEC, 0xA8, 0x01, 0x75, 0xFB, 0xFA, 0xEC, 0xA8, 0x01, 0x74, 0xFB, + 0x8B, 0xC3, 0xAB, 0xE2, 0xF0, 0x1F, 0xC3, 0xEC, 0xA8, 0x01, 0x75, + 0xFB, 0xFA, 0xEC, 0xA8, 0x01, 0x74, 0xFB, 0x8A, 0xC3, 0xAA, 0x47, + 0xE2, 0xEF, 0x1F, 0xC3, 0x80, 0x7E, 0x03, 0x08, 0x75, 0x03, 0xE9, + 0xB8, 0x00, 0xA1, 0x50, 0x00, 0xE8, 0xEB, 0x02, 0x8B, 0xF8, 0x1E, + 0x8A, 0x46, 0x02, 0xB4, 0x00, 0x0A, 0xC0, 0x78, 0x07, 0x8C, 0xCA, + 0xBE, 0x6E, 0xFA, 0xEB, 0x0C, 0x24, 0x7F, 0x33, 0xDB, 0x8E, 0xDB, + 0xC5, 0x36, 0x7C, 0x00, 0x8C, 0xDA, 0x1F, 0xB1, 0x03, 0xD3, 0xE0, + 0x03, 0xF0, 0x8B, 0x46, 0x00, 0x8E, 0xC0, 0x8B, 0x4E, 0x06, 0x80, + 0x3E, 0x49, 0x00, 0x06, 0x1E, 0x8E, 0xDA, 0x74, 0x51, 0xD1, 0xE7, + 0x8A, 0x46, 0x04, 0x25, 0x03, 0x00, 0xBB, 0x55, 0x55, 0xF7, 0xE3, + 0x8B, 0xD0, 0x8A, 0x5E, 0x04, 0xB7, 0x08, 0x57, 0x56, 0xAC, 0x51, + 0x53, 0x33, 0xDB, 0xB9, 0x08, 0x00, 0xD0, 0xE8, 0xD1, 0xDB, 0xD1, + 0xFB, 0xE2, 0xF8, 0x8B, 0xC3, 0x5B, 0x59, 0x23, 0xC2, 0x86, 0xE0, + 0x0A, 0xDB, 0x79, 0x03, 0x26, 0x33, 0x05, 0x26, 0x89, 0x05, 0x81, + 0xF7, 0x00, 0x20, 0xF7, 0xC7, 0x00, 0x20, 0x75, 0x03, 0x83, 0xC7, + 0x50, 0xFE, 0xCF, 0x75, 0xCD, 0x5E, 0x5F, 0x47, 0x47, 0xE2, 0xC3, + 0x1F, 0xC3, 0x8A, 0x5E, 0x04, 0xBA, 0x00, 0x20, 0xB7, 0x08, 0x57, + 0x56, 0xAC, 0x0A, 0xDB, 0x79, 0x03, 0x26, 0x32, 0x05, 0x26, 0x88, + 0x05, 0x33, 0xFA, 0x85, 0xFA, 0x75, 0x03, 0x83, 0xC7, 0x50, 0xFE, + 0xCF, 0x75, 0xE8, 0x5E, 0x5F, 0x47, 0xE2, 0xDF, 0x1F, 0xC3, 0xFC, + 0xA1, 0x50, 0x00, 0xE8, 0x32, 0x02, 0x8B, 0xF0, 0x83, 0xEC, 0x08, + 0x8B, 0xFC, 0x80, 0x3E, 0x49, 0x00, 0x06, 0x8B, 0x46, 0x00, 0x1E, + 0x57, 0x8E, 0xD8, 0x74, 0x31, 0xB6, 0x08, 0xD1, 0xE6, 0xBB, 0x00, + 0x20, 0x8B, 0x04, 0x86, 0xE0, 0xB9, 0x00, 0xC0, 0xB2, 0x00, 0x85, + 0xC1, 0xF8, 0x74, 0x01, 0xF9, 0xD0, 0xD2, 0xD1, 0xE9, 0xD1, 0xE9, + 0x73, 0xF2, 0x36, 0x88, 0x15, 0x47, 0x33, 0xF3, 0x85, 0xF3, 0x75, + 0x03, 0x83, 0xC6, 0x50, 0xFE, 0xCE, 0x75, 0xD8, 0xEB, 0x17, 0xB6, + 0x04, 0x8A, 0x24, 0x36, 0x88, 0x25, 0x47, 0x8A, 0xA4, 0x00, 0x20, + 0x36, 0x88, 0x25, 0x47, 0x83, 0xC6, 0x50, 0xFE, 0xCE, 0x75, 0xEB, + 0x8C, 0xCA, 0xBF, 0x6E, 0xFA, 0x8E, 0xC2, 0x8C, 0xD2, 0x8E, 0xDA, + 0x5E, 0xB0, 0x00, 0xBA, 0x80, 0x00, 0x56, 0x57, 0xB9, 0x08, 0x00, + 0xF3, 0xA6, 0x5F, 0x5E, 0x74, 0x1C, 0xFE, 0xC0, 0x83, 0xC7, 0x08, + 0x4A, 0x75, 0xED, 0x0A, 0xC0, 0x74, 0x10, 0x33, 0xDB, 0x8E, 0xDB, + 0xC4, 0x3E, 0x7C, 0x00, 0x8C, 0xC3, 0x0B, 0xDF, 0x74, 0x02, 0xEB, + 0xD6, 0x88, 0x46, 0x02, 0x1F, 0x83, 0xC4, 0x08, 0xC3, 0x8B, 0x16, + 0x63, 0x00, 0x83, 0xC2, 0x05, 0xA0, 0x66, 0x00, 0x8A, 0x66, 0x05, + 0x0A, 0xE4, 0x8A, 0x66, 0x04, 0x75, 0x09, 0x24, 0xE0, 0x80, 0xE4, + 0x1F, 0x0A, 0xC4, 0xEB, 0x09, 0x24, 0xDF, 0xF6, 0xC4, 0x01, 0x74, + 0x02, 0x0C, 0x20, 0xA2, 0x66, 0x00, 0xEE, 0xC3, 0x8B, 0x46, 0x00, + 0x8E, 0xC0, 0x8B, 0x56, 0x08, 0x8B, 0x4E, 0x06, 0xE8, 0x01, 0x01, + 0x75, 0x0D, 0x8A, 0x46, 0x02, 0x8A, 0xD8, 0x24, 0x01, 0xD0, 0xC8, + 0xB4, 0x7F, 0xEB, 0x0F, 0xD0, 0xE1, 0x8A, 0x46, 0x02, 0x8A, 0xD8, + 0x24, 0x03, 0xD0, 0xC8, 0xD0, 0xC8, 0xB4, 0x3F, 0xD2, 0xCC, 0xD2, + 0xE8, 0x26, 0x8A, 0x0C, 0x0A, 0xDB, 0x79, 0x04, 0x32, 0xC8, 0xEB, + 0x04, 0x22, 0xCC, 0x0A, 0xC8, 0x26, 0x88, 0x0C, 0xC3, 0x8B, 0x46, + 0x00, 0x8E, 0xC0, 0x8B, 0x56, 0x08, 0x8B, 0x4E, 0x06, 0xE8, 0xBE, + 0x00, 0x26, 0x8A, 0x04, 0x75, 0x08, 0xD2, 0xE0, 0xD0, 0xC0, 0x24, + 0x01, 0xEB, 0x0A, 0xD0, 0xE1, 0xD2, 0xE0, 0xD0, 0xC0, 0xD0, 0xC0, + 0x24, 0x03, 0x88, 0x46, 0x02, 0xC3, 0x8A, 0x1E, 0x62, 0x00, 0xD0, + 0xE3, 0xB7, 0x00, 0x8B, 0x57, 0x50, 0x8A, 0x46, 0x02, 0x3C, 0x08, + 0x74, 0x22, 0x3C, 0x0A, 0x74, 0x3D, 0x3C, 0x07, 0x74, 0x23, 0x3C, + 0x0D, 0x74, 0x25, 0x8A, 0x5E, 0x04, 0xB4, 0x0A, 0xB9, 0x01, 0x00, + 0xCD, 0x10, 0xFE, 0xC2, 0x3A, 0x16, 0x4A, 0x00, 0x75, 0x15, 0xB2, + 0x00, 0xEB, 0x1F, 0x80, 0xFA, 0x00, 0x74, 0x0C, 0xFE, 0xCA, 0xEB, + 0x08, 0xB3, 0x01, 0xE8, 0x53, 0x03, 0xC3, 0xB2, 0x00, 0x8A, 0x1E, + 0x62, 0x00, 0xD0, 0xE3, 0xB7, 0x00, 0x89, 0x57, 0x50, 0xE9, 0xBE, + 0x00, 0x80, 0xFE, 0x18, 0x74, 0x04, 0xFE, 0xC6, 0x75, 0xE9, 0xB4, + 0x02, 0xCD, 0x10, 0xE8, 0x2E, 0x00, 0xB7, 0x00, 0x72, 0x06, 0xB4, + 0x08, 0xCD, 0x10, 0x8A, 0xFC, 0xB4, 0x06, 0xB0, 0x01, 0x33, 0xC9, + 0xB6, 0x18, 0x8A, 0x16, 0x4A, 0x00, 0xFE, 0xCA, 0xCD, 0x10, 0xC3, + 0xA0, 0x4A, 0x00, 0x88, 0x46, 0x03, 0xA0, 0x49, 0x00, 0x88, 0x46, + 0x02, 0xA0, 0x62, 0x00, 0x88, 0x46, 0x05, 0xC3, 0x50, 0xA0, 0x49, + 0x00, 0x3C, 0x07, 0x74, 0x08, 0x3C, 0x04, 0xF5, 0x73, 0x03, 0x1A, + 0xC0, 0xF9, 0x58, 0xC3, 0xB0, 0x50, 0x33, 0xF6, 0xD0, 0xEA, 0x73, + 0x03, 0xBE, 0x00, 0x20, 0xF6, 0xE2, 0x03, 0xF0, 0x8B, 0xD1, 0xB9, + 0x02, 0x03, 0x80, 0x3E, 0x49, 0x00, 0x06, 0x9C, 0x75, 0x03, 0xB9, + 0x03, 0x07, 0x22, 0xEA, 0xD3, 0xEA, 0x03, 0xF2, 0x86, 0xCD, 0x9D, + 0xC3, 0xE8, 0x0A, 0x00, 0x8A, 0xE8, 0xFE, 0xC4, 0xE8, 0x03, 0x00, + 0x8A, 0xC8, 0xC3, 0x52, 0x8B, 0x16, 0x63, 0x00, 0x86, 0xC4, 0xEE, + 0xFE, 0xC2, 0xEC, 0x5A, 0xC3, 0xB7, 0x00, 0xD1, 0xE3, 0x8B, 0x47, + 0x50, 0x53, 0x8A, 0xD8, 0x8A, 0xC4, 0xF6, 0x26, 0x4A, 0x00, 0xB7, + 0x00, 0x03, 0xC3, 0xD1, 0xE0, 0x5B, 0xC3, 0x53, 0x8A, 0xD8, 0x8A, + 0xC4, 0xF6, 0x26, 0x4A, 0x00, 0xD1, 0xE0, 0xD1, 0xE0, 0xB7, 0x00, + 0x03, 0xC3, 0x5B, 0xC3, 0xD0, 0xEB, 0x38, 0x1E, 0x62, 0x00, 0x75, + 0x24, 0xE8, 0xCA, 0xFF, 0x03, 0x06, 0x4E, 0x00, 0xD1, 0xE8, 0x8B, + 0xC8, 0xB4, 0x0E, 0x8A, 0xC5, 0xE8, 0x04, 0x00, 0xFE, 0xC4, 0x8A, + 0xC1, 0x52, 0x8B, 0x16, 0x63, 0x00, 0x86, 0xC4, 0xEE, 0x86, 0xC4, + 0xFE, 0xC2, 0xEE, 0x5A, 0xC3, 0x33, 0xC9, 0x8E, 0xC1, 0x26, 0x8B, + 0x0E, 0x62, 0x00, 0x32, 0xDB, 0x80, 0xC7, 0x03, 0x8B, 0xC3, 0xE8, + 0xE9, 0x01, 0xBE, 0x31, 0xEC, 0x32, 0xD2, 0x81, 0xF9, 0x00, 0xF6, + 0x75, 0x05, 0xBE, 0x12, 0xF8, 0xFE, 0xC2, 0xE8, 0xCB, 0x01, 0xFB, + 0xBB, 0x36, 0x00, 0x26, 0x03, 0x1E, 0x6C, 0x04, 0xB4, 0x01, 0xCD, + 0x16, 0x75, 0x0B, 0x26, 0x8B, 0x0E, 0x6C, 0x04, 0x2B, 0xCB, 0x72, + 0xF1, 0xFA, 0xC3, 0x32, 0xE4, 0xCD, 0x16, 0x0A, 0xD2, 0x74, 0xF6, + 0x3C, 0x20, 0x74, 0x02, 0xEB, 0xF0, 0xCD, 0x18, 0x53, 0x79, 0x73, + 0x74, 0x65, 0x6D, 0x20, 0xC2, 0x20, 0x00, 0x38, 0x30, 0x38, 0x38, + 0x20, 0x43, 0x50, 0x55, 0x20, 0x28, 0x00, 0x56, 0x32, 0x30, 0x20, + 0x43, 0x50, 0x55, 0x20, 0x28, 0x00, 0x4E, 0x6F, 0x20, 0x46, 0x50, + 0x55, 0x29, 0x00, 0x38, 0x30, 0x38, 0x37, 0x20, 0x46, 0x50, 0x55, + 0x29, 0x00, 0x50, 0x72, 0x65, 0x73, 0x73, 0x20, 0x53, 0x50, 0x41, + 0x43, 0x45, 0x20, 0x74, 0x6F, 0x20, 0x62, 0x6F, 0x6F, 0x74, 0x20, + 0x52, 0x4F, 0x4D, 0x20, 0x42, 0x41, 0x53, 0x49, 0x43, 0x2E, 0x2E, + 0x2E, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0x1E, 0xB8, 0x40, 0x00, 0x8E, + 0xD8, 0xA1, 0x13, 0x00, 0x1F, 0xCF, 0xFB, 0x1E, 0xB8, 0x40, 0x00, + 0x8E, 0xD8, 0xA1, 0x10, 0x00, 0x1F, 0xCF, 0xF9, 0xB4, 0x86, 0xCA, + 0x02, 0x00, 0x50, 0xE4, 0x62, 0xA8, 0xC0, 0x75, 0x03, 0xE9, 0xA8, + 0x00, 0x53, 0x51, 0x52, 0x56, 0x57, 0x55, 0x1E, 0x06, 0xB8, 0x40, + 0x00, 0x8E, 0xD8, 0xE8, 0x4E, 0x01, 0x1E, 0x0E, 0x1F, 0xBE, 0x2B, + 0xF9, 0xE8, 0x00, 0x01, 0x1F, 0xB8, 0x11, 0x00, 0xE8, 0x04, 0x01, + 0xB0, 0x00, 0xE6, 0xA0, 0xBA, 0x61, 0x00, 0xEC, 0x0C, 0x30, 0xEE, + 0x24, 0xCF, 0xEE, 0xB1, 0x06, 0x8B, 0x1E, 0x13, 0x00, 0xD3, 0xE3, + 0x42, 0x33, 0xC0, 0x8E, 0xD8, 0xB9, 0x10, 0x00, 0x33, 0xF6, 0x8A, + 0x24, 0xEC, 0xA8, 0xC0, 0x75, 0x0E, 0x46, 0xE2, 0xF6, 0x8C, 0xD8, + 0x40, 0x8E, 0xD8, 0x3B, 0xC3, 0x75, 0xE8, 0xEB, 0x0C, 0x88, 0x24, + 0x8C, 0xD8, 0xE8, 0x8E, 0xEC, 0x8B, 0xC6, 0xE8, 0x85, 0x00, 0xB8, + 0x16, 0x00, 0xE8, 0xBD, 0x00, 0x1E, 0x0E, 0x1F, 0xBE, 0x42, 0xF9, + 0xE8, 0xA9, 0x00, 0x1F, 0xE4, 0x21, 0x50, 0xB0, 0xFC, 0xE6, 0x21, + 0xFB, 0xE8, 0xFE, 0x00, 0x50, 0xE8, 0x8E, 0x00, 0x58, 0x3C, 0x59, + 0x74, 0x07, 0x3C, 0x79, 0x74, 0x03, 0xE9, 0x66, 0xE7, 0xE8, 0x23, + 0xEC, 0x58, 0xE6, 0x21, 0xBA, 0x61, 0x00, 0xEC, 0x0C, 0x30, 0xEE, + 0x24, 0xCF, 0xEE, 0xB0, 0x80, 0xE6, 0xA0, 0x07, 0x1F, 0x5D, 0x5F, + 0x5E, 0x5A, 0x59, 0x5B, 0x58, 0xCF, 0xBC, 0x03, 0x78, 0x03, 0x78, + 0x02, 0xC3, 0x20, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6C, 0x20, 0x50, + 0x6F, 0x72, 0x74, 0x20, 0x61, 0x74, 0x20, 0x00, 0x50, 0x61, 0x72, + 0x69, 0x74, 0x79, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x61, + 0x74, 0x3A, 0x20, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x00, 0x0D, 0x0A, + 0x43, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, 0x3F, 0x20, 0x00, + 0x50, 0x24, 0x0F, 0x3C, 0x09, 0x76, 0x02, 0x04, 0x07, 0x04, 0x30, + 0xE8, 0x1A, 0x00, 0x58, 0xC3, 0x50, 0xB1, 0x04, 0xD2, 0xE8, 0xE8, + 0xE8, 0xFF, 0x58, 0xE8, 0xE4, 0xFF, 0xC3, 0x50, 0x8A, 0xC4, 0xE8, + 0xDD, 0xFF, 0x58, 0xE8, 0xE9, 0xFF, 0xC3, 0x53, 0x50, 0xB4, 0x0E, + 0xB3, 0x07, 0xCD, 0x10, 0x58, 0x5B, 0xC3, 0xAC, 0x0A, 0xC0, 0x74, + 0x05, 0xE8, 0xED, 0xFF, 0xEB, 0xF6, 0xC3, 0x52, 0x53, 0x8B, 0xD0, + 0xB4, 0x02, 0xB7, 0x00, 0xCD, 0x10, 0x5B, 0x5A, 0xC3, 0xBB, 0x70, + 0x00, 0x26, 0x80, 0x3E, 0x49, 0x00, 0x07, 0x74, 0x03, 0xBB, 0x1F, + 0x00, 0xB9, 0x01, 0x00, 0xAC, 0x0A, 0xC0, 0x74, 0x05, 0xE8, 0x05, + 0x00, 0xEB, 0xF3, 0xB9, 0x31, 0x00, 0xB4, 0x09, 0xCD, 0x10, 0xB4, + 0x03, 0xCD, 0x10, 0xB4, 0x02, 0xFE, 0xC2, 0xCD, 0x10, 0xC3, 0x8A, + 0x26, 0x10, 0x00, 0x80, 0xE4, 0x30, 0xB0, 0x00, 0x80, 0xFC, 0x30, + 0x74, 0x09, 0xB0, 0x01, 0x80, 0xFC, 0x10, 0x74, 0x02, 0xB0, 0x03, + 0xB4, 0x00, 0xCD, 0x10, 0xC3, 0xB4, 0x00, 0xCD, 0x16, 0xC3, 0x50, + 0x51, 0xB0, 0xB6, 0xE6, 0x43, 0xB8, 0x28, 0x05, 0xE6, 0x42, 0x8A, + 0xC4, 0xE6, 0x42, 0xE4, 0x61, 0x50, 0x0C, 0x03, 0xE6, 0x61, 0x33, + 0xC9, 0xE2, 0xFE, 0xFE, 0xCB, 0x75, 0xFA, 0x58, 0xE6, 0x61, 0x59, + 0x58, 0xC3, 0xB9, 0x00, 0x20, 0xB0, 0x00, 0x02, 0x07, 0x43, 0xE2, + 0xFB, 0x0A, 0xC0, 0xC3, 0xBB, 0x00, 0x04, 0xB0, 0x55, 0x33, 0xFF, + 0x8B, 0xCB, 0x32, 0xC0, 0xF3, 0xAA, 0x8C, 0xC0, 0x05, 0x40, 0x00, + 0x8E, 0xC0, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x81, + 0xA5, 0x81, 0xBD, 0x99, 0x81, 0x7E, 0x7E, 0xFF, 0xDB, 0xFF, 0xC3, + 0xE7, 0xFF, 0x7E, 0x6C, 0xFE, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, + 0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x38, 0x7C, 0x38, + 0xFE, 0xFE, 0x7C, 0x38, 0x7C, 0x10, 0x10, 0x38, 0x7C, 0xFE, 0x7C, + 0x38, 0x7C, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0xFF, + 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF, 0x00, 0x3C, 0x66, 0x42, + 0x42, 0x66, 0x3C, 0x00, 0xFF, 0xC3, 0x99, 0xBD, 0xBD, 0x99, 0xC3, + 0xFF, 0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78, 0x3C, 0x66, + 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x3F, 0x33, 0x3F, 0x30, 0x30, + 0x70, 0xF0, 0xE0, 0x7F, 0x63, 0x7F, 0x63, 0x63, 0x67, 0xE6, 0xC0, + 0x99, 0x5A, 0x3C, 0xE7, 0xE7, 0x3C, 0x5A, 0x99, 0x80, 0xE0, 0xF8, + 0xFE, 0xF8, 0xE0, 0x80, 0x00, 0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, + 0x02, 0x00, 0x18, 0x3C, 0x7E, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x66, + 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00, 0x7F, 0xDB, 0xDB, 0x7B, + 0x1B, 0x1B, 0x1B, 0x00, 0x3E, 0x63, 0x38, 0x6C, 0x6C, 0x38, 0xCC, + 0x78, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00, 0x18, 0x3C, + 0x7E, 0x18, 0x7E, 0x3C, 0x18, 0xFF, 0x18, 0x3C, 0x7E, 0x18, 0x18, + 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x3C, 0x18, 0x00, + 0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60, + 0xFE, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, + 0x00, 0x00, 0x00, 0x24, 0x66, 0xFF, 0x66, 0x24, 0x00, 0x00, 0x00, + 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7E, + 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x30, 0x78, 0x78, 0x30, 0x30, 0x00, 0x30, 0x00, 0x6C, 0x6C, + 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, 0x6C, 0xFE, 0x6C, 0xFE, + 0x6C, 0x6C, 0x00, 0x30, 0x7C, 0xC0, 0x78, 0x0C, 0xF8, 0x30, 0x00, + 0x00, 0xC6, 0xCC, 0x18, 0x30, 0x66, 0xC6, 0x00, 0x38, 0x6C, 0x38, + 0x76, 0xDC, 0xCC, 0x76, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x60, + 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00, 0x00, 0x66, 0x3C, 0xFF, + 0x3C, 0x66, 0x00, 0x00, 0x00, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x60, 0x00, 0x00, + 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x30, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00, + 0x7C, 0xC6, 0xCE, 0xDE, 0xF6, 0xE6, 0x7C, 0x00, 0x30, 0x70, 0x30, + 0x30, 0x30, 0x30, 0xFC, 0x00, 0x78, 0xCC, 0x0C, 0x38, 0x60, 0xCC, + 0xFC, 0x00, 0x78, 0xCC, 0x0C, 0x38, 0x0C, 0xCC, 0x78, 0x00, 0x1C, + 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x1E, 0x00, 0xFC, 0xC0, 0xF8, 0x0C, + 0x0C, 0xCC, 0x78, 0x00, 0x38, 0x60, 0xC0, 0xF8, 0xCC, 0xCC, 0x78, + 0x00, 0xFC, 0xCC, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00, 0x78, 0xCC, + 0xCC, 0x78, 0xCC, 0xCC, 0x78, 0x00, 0x78, 0xCC, 0xCC, 0x7C, 0x0C, + 0x18, 0x70, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00, + 0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x60, 0x18, 0x30, 0x60, + 0xC0, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFC, + 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60, 0x00, 0x78, + 0xCC, 0x0C, 0x18, 0x30, 0x00, 0x30, 0x00, 0x7C, 0xC6, 0xDE, 0xDE, + 0xDE, 0xC0, 0x78, 0x00, 0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, + 0x00, 0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00, 0x3C, 0x66, + 0xC0, 0xC0, 0xC0, 0x66, 0x3C, 0x00, 0xF8, 0x6C, 0x66, 0x66, 0x66, + 0x6C, 0xF8, 0x00, 0xFE, 0x62, 0x68, 0x78, 0x68, 0x62, 0xFE, 0x00, + 0xFE, 0x62, 0x68, 0x78, 0x68, 0x60, 0xF0, 0x00, 0x3C, 0x66, 0xC0, + 0xC0, 0xCE, 0x66, 0x3E, 0x00, 0xCC, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, + 0xCC, 0x00, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00, 0x1E, + 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0x00, 0xE6, 0x66, 0x6C, 0x78, + 0x6C, 0x66, 0xE6, 0x00, 0xF0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, + 0x00, 0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00, 0xC6, 0xE6, + 0xF6, 0xDE, 0xCE, 0xC6, 0xC6, 0x00, 0x38, 0x6C, 0xC6, 0xC6, 0xC6, + 0x6C, 0x38, 0x00, 0xFC, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00, + 0x78, 0xCC, 0xCC, 0xCC, 0xDC, 0x78, 0x1C, 0x00, 0xFC, 0x66, 0x66, + 0x7C, 0x6C, 0x66, 0xE6, 0x00, 0x78, 0xCC, 0xE0, 0x70, 0x1C, 0xCC, + 0x78, 0x00, 0xFC, 0xB4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFC, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0x78, 0x30, 0x00, 0xC6, 0xC6, 0xC6, 0xD6, 0xFE, 0xEE, 0xC6, + 0x00, 0xC6, 0xC6, 0x6C, 0x38, 0x38, 0x6C, 0xC6, 0x00, 0xCC, 0xCC, + 0xCC, 0x78, 0x30, 0x30, 0x78, 0x00, 0xFE, 0xC6, 0x8C, 0x18, 0x32, + 0x66, 0xFE, 0x00, 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00, + 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x02, 0x00, 0x78, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x78, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x30, + 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0C, + 0x7C, 0xCC, 0x76, 0x00, 0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0xDC, + 0x00, 0x00, 0x00, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x00, 0x1C, 0x0C, + 0x0C, 0x7C, 0xCC, 0xCC, 0x76, 0x00, 0x00, 0x00, 0x78, 0xCC, 0xFC, + 0xC0, 0x78, 0x00, 0x38, 0x6C, 0x60, 0xF0, 0x60, 0x60, 0xF0, 0x00, + 0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0xE0, 0x60, 0x6C, + 0x76, 0x66, 0x66, 0xE6, 0x00, 0x30, 0x00, 0x70, 0x30, 0x30, 0x30, + 0x78, 0x00, 0x0C, 0x00, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0xE0, + 0x60, 0x66, 0x6C, 0x78, 0x6C, 0xE6, 0x00, 0x70, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x78, 0x00, 0x00, 0x00, 0xCC, 0xFE, 0xFE, 0xD6, 0xC6, + 0x00, 0x00, 0x00, 0xF8, 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x00, 0x00, + 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00, 0x00, 0x00, 0xDC, 0x66, 0x66, + 0x7C, 0x60, 0xF0, 0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0x1E, + 0x00, 0x00, 0xDC, 0x76, 0x66, 0x60, 0xF0, 0x00, 0x00, 0x00, 0x7C, + 0xC0, 0x78, 0x0C, 0xF8, 0x00, 0x10, 0x30, 0x7C, 0x30, 0x30, 0x34, + 0x18, 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, 0x00, + 0x00, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00, 0x00, 0x00, 0xC6, 0xD6, + 0xFE, 0xFE, 0x6C, 0x00, 0x00, 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, + 0x00, 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, 0x00, 0x00, + 0xFC, 0x98, 0x30, 0x64, 0xFC, 0x00, 0x1C, 0x30, 0x30, 0xE0, 0x30, + 0x30, 0x1C, 0x00, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00, + 0xE0, 0x30, 0x30, 0x1C, 0x30, 0x30, 0xE0, 0x00, 0x76, 0xDC, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, + 0xFE, 0x00, 0xFB, 0x1E, 0x50, 0xB8, 0x40, 0x00, 0x8E, 0xD8, 0x58, + 0xFA, 0x0A, 0xE4, 0x74, 0x13, 0xFE, 0xCC, 0x75, 0x1A, 0x89, 0x16, + 0x6C, 0x00, 0x89, 0x0E, 0x6E, 0x00, 0xC6, 0x06, 0x70, 0x00, 0x00, + 0xEB, 0x0B, 0x8B, 0x0E, 0x6E, 0x00, 0x8B, 0x16, 0x6C, 0x00, 0xE8, + 0x03, 0x00, 0xFB, 0x1F, 0xCF, 0xA0, 0x70, 0x00, 0x30, 0x06, 0x70, + 0x00, 0xC3, 0xFB, 0x1E, 0x52, 0x50, 0xB8, 0x40, 0x00, 0x8E, 0xD8, + 0xFE, 0x0E, 0x40, 0x00, 0x75, 0x0B, 0x80, 0x26, 0x3F, 0x00, 0xF0, + 0xB0, 0x0C, 0xBA, 0xF2, 0x03, 0xEE, 0xFF, 0x06, 0x6C, 0x00, 0x75, + 0x04, 0xFF, 0x06, 0x6E, 0x00, 0x83, 0x3E, 0x6E, 0x00, 0x18, 0x75, + 0x19, 0x81, 0x3E, 0x6C, 0x00, 0xB0, 0x00, 0x75, 0x11, 0xC7, 0x06, + 0x6E, 0x00, 0x00, 0x00, 0xC7, 0x06, 0x6C, 0x00, 0x00, 0x00, 0xC6, + 0x06, 0x70, 0x00, 0x01, 0xCD, 0x1C, 0xB0, 0x20, 0xE6, 0x20, 0x58, + 0x5A, 0x1F, 0xCF, 0xA5, 0xFE, 0x87, 0xE9, 0x23, 0xFF, 0x23, 0xFF, + 0x23, 0xFF, 0x23, 0xFF, 0x57, 0xEF, 0x23, 0xFF, 0x65, 0xF0, 0x4D, + 0xF8, 0x41, 0xF8, 0x59, 0xEC, 0x39, 0xE7, 0x59, 0xF8, 0x2E, 0xE8, + 0xD2, 0xEF, 0x23, 0xFF, 0xF2, 0xE6, 0x6E, 0xFE, 0x53, 0xFF, 0x53, + 0xFF, 0xA4, 0xF0, 0xC7, 0xEF, 0x00, 0x00, 0x1E, 0x52, 0x50, 0xB8, + 0x40, 0x00, 0x8E, 0xD8, 0xB0, 0x0B, 0xE6, 0x20, 0x90, 0xE4, 0x20, + 0x8A, 0xE0, 0x0A, 0xC0, 0x75, 0x04, 0xB0, 0xFF, 0xEB, 0x0A, 0xE4, + 0x21, 0x0A, 0xC4, 0xE6, 0x21, 0xB0, 0x20, 0xE6, 0x20, 0x88, 0x26, + 0x6B, 0x00, 0x58, 0x5A, 0x1F, 0xCF, 0x68, 0x00, 0xFF, 0xFF, 0xFF, + 0xCF, 0xFB, 0x1E, 0x50, 0x53, 0x51, 0x52, 0xB8, 0x40, 0x00, 0x8E, + 0xD8, 0x80, 0x3E, 0x00, 0x01, 0x01, 0x74, 0x56, 0xC6, 0x06, 0x00, + 0x01, 0x01, 0xE8, 0x5D, 0x00, 0xB4, 0x0F, 0xCD, 0x10, 0x50, 0xB4, + 0x03, 0xCD, 0x10, 0x58, 0x52, 0xB5, 0x19, 0x8A, 0xCC, 0x33, 0xD2, + 0xB4, 0x02, 0xCD, 0x10, 0xB4, 0x08, 0xCD, 0x10, 0x0A, 0xC0, 0x75, + 0x02, 0xB0, 0x20, 0x52, 0x33, 0xD2, 0x8A, 0xE2, 0xCD, 0x17, 0x5A, + 0xF6, 0xC4, 0x25, 0x74, 0x07, 0xC6, 0x06, 0x00, 0x01, 0xFF, 0xEB, + 0x16, 0xFE, 0xC2, 0x3A, 0xCA, 0x75, 0xD8, 0xB2, 0x00, 0xE8, 0x1F, + 0x00, 0xFE, 0xC6, 0x3A, 0xF5, 0x75, 0xCD, 0xC6, 0x06, 0x00, 0x01, + 0x00, 0x5A, 0xB4, 0x02, 0xCD, 0x10, 0x5A, 0x59, 0x5B, 0x58, 0x1F, + 0xCF, 0xC3, 0x20, 0x54, 0x69, 0x6D, 0x65, 0x72, 0x00, 0xFF, 0x52, + 0x33, 0xD2, 0x8A, 0xE2, 0xB0, 0x0A, 0xCD, 0x17, 0xB4, 0x00, 0xB0, + 0x0D, 0xCD, 0x17, 0x5A, 0xC3, 0xC7, 0x06, 0x60, 0x00, 0x07, 0x06, + 0x80, 0x3E, 0x49, 0x00, 0x07, 0x75, 0x06, 0xC7, 0x06, 0x60, 0x00, + 0x0C, 0x0B, 0xC3, 0xEA, 0x5B, 0xE0, 0x00, 0xF0, 0x30, 0x35, 0x2F, + 0x30, 0x32, 0x2F, 0x31, 0x32, 0xFF, 0xFE, 0xE2 +}; + +#ifdef INCLUDE_ROM_BASIC +#ifdef MEGA + const uint8_t BASICL[16384] PROGMEM = { +#else + const uint8_t BASICL[16384] = { +#endif + 0xE9, 0x8F, 0x7E, 0xE8, 0xA7, 0x6B, 0xCB, 0xE8, 0x2, 0x65, 0xCB, + 0x5D, 0xE8, 0xC7, 0x2F, 0x74, 0xD, 0x8B, 0x36, 0xE9, 0x4, 0x8A, + 0x44, 0x2E, 0x3C, 0xFE, 0x74, 0x2, 0x3C, 0xFD, 0xC3, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x33, 0x2E, 0x94, 0xD, 0x68, 0x73, 0x5B, + 0x11, 0x59, 0x15, 0x66, 0x37, 0x3E, 0x16, 0x8F, 0x11, 0xED, 0x10, + 0xB6, 0x10, 0xF8, 0x12, 0xC, 0x2E, 0xCE, 0x10, 0x35, 0x11, 0x5F, + 0x11, 0x2D, 0x2E, 0x48, 0x13, 0x50, 0x2F, 0x35, 0x1F, 0x1B, 0x2D, + 0xFE, 0x11, 0x58, 0x1E, 0xF0, 0x1B, 0x91, 0x22, 0x85, 0x2E, 0xBE, + 0x7, 0xBE, 0x7, 0x53, 0x1E, 0x43, 0x13, 0x2E, 0x1F, 0x0, 0x0, + 0x8A, 0x1E, 0x5F, 0x11, 0x9C, 0x2E, 0x9D, 0x2E, 0xA3, 0x2E, 0xF3, + 0x2E, 0xDF, 0x36, 0xA9, 0x12, 0x58, 0x12, 0x39, 0x22, 0xB8, 0x12, + 0xD8, 0x22, 0xFB, 0xF, 0xFE, 0xF, 0x1, 0x10, 0x4, 0x10, 0xD9, + 0x14, 0x4, 0x3D, 0x30, 0x3D, 0xA0, 0x5D, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0xA9, 0x3D, 0x3F, 0x24, 0x9E, 0x24, 0x4, 0x40, 0x52, + 0x43, 0x6C, 0x41, 0x6D, 0x41, 0xCE, 0x41, 0x2F, 0x53, 0xE7, 0x52, + 0x26, 0x5D, 0x13, 0x46, 0x33, 0x46, 0x29, 0x58, 0xD, 0x58, 0xD1, + 0x47, 0xCD, 0x47, 0x93, 0x51, 0x2A, 0x50, 0x17, 0x54, 0x68, 0x29, + 0xA5, 0x29, 0xB1, 0x29, 0x1C, 0x65, 0x80, 0x7E, 0x96, 0x7D, 0xF1, + 0x70, 0x87, 0x78, 0xE, 0x7A, 0xC, 0x73, 0x84, 0x62, 0xF4, 0x79, + 0xAD, 0x7A, 0xCD, 0x7A, 0x8C, 0x2B, 0x3D, 0x1E, 0x7A, 0x1B, 0xE8, + 0x28, 0x17, 0x26, 0xE9, 0x29, 0xF8, 0x28, 0xB, 0x29, 0x80, 0x22, + 0x47, 0x29, 0xD, 0x26, 0x12, 0x26, 0x75, 0x1B, 0xAD, 0x6B, 0x51, + 0x6B, 0x82, 0x6B, 0x9C, 0x65, 0xFA, 0x55, 0x98, 0x56, 0x12, 0x57, + 0xC0, 0x44, 0x98, 0x44, 0xAC, 0x44, 0x37, 0x1, 0x48, 0x1, 0x57, + 0x1, 0x8B, 0x1, 0xB4, 0x1, 0xD9, 0x1, 0xE5, 0x1, 0xF4, 0x1, + 0xF9, 0x1, 0x15, 0x2, 0x16, 0x2, 0x1A, 0x2, 0x50, 0x2, 0x62, + 0x2, 0x6D, 0x2, 0x86, 0x2, 0xA9, 0x2, 0xAA, 0x2, 0xDF, 0x2, + 0x23, 0x3, 0x3A, 0x3, 0x43, 0x3, 0x4D, 0x3, 0x65, 0x3, 0x69, + 0x3, 0x6A, 0x3, 0x55, 0x54, 0xCF, 0xAA, 0x4E, 0xC4, 0xEE, 0x42, + 0xD3, 0x6, 0x54, 0xCE, 0xE, 0x53, 0xC3, 0x15, 0x0, 0x53, 0x41, + 0x56, 0xC5, 0xC2, 0x4C, 0x4F, 0x41, 0xC4, 0xC3, 0x45, 0x45, 0xD0, + 0xC5, 0x0, 0x4F, 0x4C, 0x4F, 0xD2, 0xBF, 0x4C, 0x4F, 0x53, 0xC5, + 0xBB, 0x4F, 0x4E, 0xD4, 0x99, 0x4C, 0x45, 0x41, 0xD2, 0x92, 0x53, + 0x52, 0x4C, 0x49, 0xCE, 0xDB, 0x49, 0x4E, 0xD4, 0x1C, 0x53, 0x4E, + 0xC7, 0x1D, 0x44, 0x42, 0xCC, 0x1E, 0x4F, 0xD3, 0xC, 0x48, 0x52, + 0xA4, 0x16, 0x41, 0x4C, 0xCC, 0xB3, 0x4C, 0xD3, 0xC0, 0x0, 0x45, + 0x4C, 0x45, 0x54, 0xC5, 0xA9, 0x41, 0x54, 0xC1, 0x84, 0x49, 0xCD, + 0x86, 0x45, 0x46, 0x53, 0x54, 0xD2, 0xAC, 0x45, 0x46, 0x49, 0x4E, + 0xD4, 0xAD, 0x45, 0x46, 0x53, 0x4E, 0xC7, 0xAE, 0x45, 0x46, 0x44, + 0x42, 0xCC, 0xAF, 0x45, 0xC6, 0x97, 0x0, 0x4C, 0x53, 0xC5, 0xA1, + 0x4E, 0xC4, 0x81, 0x52, 0x41, 0x53, 0xC5, 0xA5, 0x44, 0x49, 0xD4, + 0xA6, 0x52, 0x52, 0x4F, 0xD2, 0xA7, 0x52, 0xCC, 0xD4, 0x52, 0xD2, + 0xD5, 0x58, 0xD0, 0xB, 0x4F, 0xC6, 0x23, 0x51, 0xD6, 0xF1, 0x0, + 0x4F, 0xD2, 0x82, 0xCE, 0xD1, 0x52, 0xC5, 0xF, 0x49, 0xD8, 0x1F, + 0x0, 0x4F, 0x54, 0xCF, 0x89, 0x4F, 0x20, 0x54, 0xCF, 0x89, 0x4F, + 0x53, 0x55, 0xC2, 0x8D, 0x0, 0x45, 0x58, 0xA4, 0x1A, 0x0, 0x4E, + 0x50, 0x55, 0xD4, 0x85, 0xC6, 0x8B, 0x4E, 0x53, 0x54, 0xD2, 0xD8, + 0x4E, 0xD4, 0x5, 0x4E, 0xD0, 0x10, 0x4D, 0xD0, 0xF2, 0x4E, 0x4B, + 0x45, 0x59, 0xA4, 0xDE, 0x0, 0x0, 0x45, 0xD9, 0xC9, 0x0, 0x4F, + 0x43, 0x41, 0x54, 0xC5, 0xCA, 0x50, 0x52, 0x49, 0x4E, 0xD4, 0x9D, + 0x4C, 0x49, 0x53, 0xD4, 0x9E, 0x50, 0x4F, 0xD3, 0x1B, 0x45, 0xD4, + 0x88, 0x49, 0x4E, 0xC5, 0xB0, 0x4F, 0x41, 0xC4, 0xBC, 0x49, 0x53, + 0xD4, 0x93, 0x4F, 0xC7, 0xA, 0x4F, 0xC3, 0x24, 0x45, 0xCE, 0x12, + 0x45, 0x46, 0x54, 0xA4, 0x1, 0x4F, 0xC6, 0x25, 0x0, 0x4F, 0x54, + 0x4F, 0xD2, 0xC1, 0x45, 0x52, 0x47, 0xC5, 0xBD, 0x4F, 0xC4, 0xF3, + 0x49, 0x44, 0xA4, 0x3, 0x0, 0x45, 0x58, 0xD4, 0x83, 0x45, 0xD7, + 0x94, 0x4F, 0xD4, 0xD3, 0x0, 0x50, 0x45, 0xCE, 0xBA, 0x55, 0xD4, + 0x9C, 0xCE, 0x95, 0xD2, 0xEF, 0x43, 0x54, 0xA4, 0x19, 0x50, 0x54, + 0x49, 0x4F, 0xCE, 0xB8, 0x46, 0xC6, 0xDD, 0x0, 0x52, 0x49, 0x4E, + 0xD4, 0x91, 0x4F, 0x4B, 0xC5, 0x98, 0x4F, 0xD3, 0x11, 0x45, 0x45, + 0xCB, 0x17, 0x53, 0x45, 0xD4, 0xC6, 0x52, 0x45, 0x53, 0x45, 0xD4, + 0xC7, 0x4F, 0x49, 0x4E, 0xD4, 0xDC, 0x45, 0xCE, 0x20, 0x0, 0x0, + 0x55, 0xCE, 0x8A, 0x45, 0x54, 0x55, 0x52, 0xCE, 0x8E, 0x45, 0x41, + 0xC4, 0x87, 0x45, 0x53, 0x54, 0x4F, 0x52, 0xC5, 0x8C, 0x45, 0xCD, + 0x8F, 0x45, 0x53, 0x55, 0x4D, 0xC5, 0xA8, 0x49, 0x47, 0x48, 0x54, + 0xA4, 0x2, 0x4E, 0xC4, 0x8, 0x45, 0x4E, 0x55, 0xCD, 0xAB, 0x41, + 0x4E, 0x44, 0x4F, 0x4D, 0x49, 0x5A, 0xC5, 0xB9, 0x0, 0x43, 0x52, + 0x45, 0x45, 0xCE, 0xC8, 0x54, 0x4F, 0xD0, 0x90, 0x57, 0x41, 0xD0, + 0xA4, 0x41, 0x56, 0xC5, 0xBE, 0x50, 0x43, 0xA8, 0xD2, 0x54, 0x45, + 0xD0, 0xCF, 0x47, 0xCE, 0x4, 0x51, 0xD2, 0x7, 0x49, 0xCE, 0x9, + 0x54, 0x52, 0xA4, 0x13, 0x54, 0x52, 0x49, 0x4E, 0x47, 0xA4, 0xD6, + 0x50, 0x41, 0x43, 0x45, 0xA4, 0x18, 0x4F, 0x55, 0x4E, 0xC4, 0xC4, + 0x54, 0x49, 0x43, 0xCB, 0x21, 0x54, 0x52, 0x49, 0xC7, 0x22, 0x0, + 0x48, 0x45, 0xCE, 0xCD, 0x52, 0x4F, 0xCE, 0xA2, 0x52, 0x4F, 0x46, + 0xC6, 0xA3, 0x41, 0x42, 0xA8, 0xCE, 0xCF, 0xCC, 0x41, 0xCE, 0xD, + 0x0, 0x53, 0x49, 0x4E, 0xC7, 0xD7, 0x53, 0xD2, 0xD0, 0x0, 0x41, + 0xCC, 0x14, 0x41, 0x52, 0x50, 0x54, 0xD2, 0xDA, 0x0, 0x49, 0x44, + 0x54, 0xC8, 0xA0, 0x41, 0x49, 0xD4, 0x96, 0x48, 0x49, 0x4C, 0xC5, + 0xB1, 0x45, 0x4E, 0xC4, 0xB2, 0x52, 0x49, 0x54, 0xC5, 0xB7, 0x0, + 0x4F, 0xD2, 0xF0, 0x0, 0x0, 0x0, 0xAB, 0xE9, 0xAD, 0xEA, 0xAA, + 0xEB, 0xAF, 0xEC, 0xDE, 0xED, 0xDC, 0xF4, 0xA7, 0xD9, 0xBE, 0xE6, + 0xBD, 0xE7, 0xBC, 0xE8, 0x0, 0x79, 0x79, 0x7C, 0x7C, 0x7F, 0x50, + 0x46, 0x3C, 0x32, 0x28, 0x7A, 0x7B, 0x82, 0x6B, 0x0, 0x0, 0xAD, + 0x6B, 0x3B, 0x64, 0x51, 0x6B, 0xA8, 0x66, 0x3, 0x63, 0x53, 0x6C, + 0x20, 0x63, 0x74, 0x65, 0x12, 0x63, 0x19, 0x63, 0x41, 0x63, 0x28, + 0x63, 0x31, 0x64, 0x6A, 0x63, 0x4F, 0x63, 0x89, 0x63, 0xD7, 0x18, + 0xB4, 0x65, 0x0, 0x4E, 0x45, 0x58, 0x54, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x6F, 0x75, 0x74, 0x20, 0x46, 0x4F, 0x52, 0x0, 0x53, 0x79, + 0x6E, 0x74, 0x61, 0x78, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x0, + 0x52, 0x45, 0x54, 0x55, 0x52, 0x4E, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x6F, 0x75, 0x74, 0x20, 0x47, 0x4F, 0x53, 0x55, 0x42, 0x0, 0x4F, + 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x44, 0x41, 0x54, 0x41, 0x0, + 0x49, 0x6C, 0x6C, 0x65, 0x67, 0x61, 0x6C, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x63, 0x61, 0x6C, 0x6C, 0x0, + 0x4F, 0x76, 0x65, 0x72, 0x66, 0x6C, 0x6F, 0x77, 0x0, 0x4F, 0x75, + 0x74, 0x20, 0x6F, 0x66, 0x20, 0x6D, 0x65, 0x6D, 0x6F, 0x72, 0x79, + 0x0, 0x55, 0x6E, 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x20, + 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, + 0x0, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x20, + 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x72, 0x61, 0x6E, 0x67, + 0x65, 0x0, 0x44, 0x75, 0x70, 0x6C, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x20, 0x44, 0x65, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x6F, 0x6E, + 0x0, 0x44, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6F, 0x6E, 0x20, 0x62, + 0x79, 0x20, 0x7A, 0x65, 0x72, 0x6F, 0x0, 0x49, 0x6C, 0x6C, 0x65, + 0x67, 0x61, 0x6C, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x0, + 0x54, 0x79, 0x70, 0x65, 0x20, 0x6D, 0x69, 0x73, 0x6D, 0x61, 0x74, + 0x63, 0x68, 0x0, 0x4F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x73, + 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, + 0x0, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x20, 0x74, 0x6F, 0x6F, + 0x20, 0x6C, 0x6F, 0x6E, 0x67, 0x0, 0x53, 0x74, 0x72, 0x69, 0x6E, + 0x67, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x75, 0x6C, 0x61, 0x20, 0x74, + 0x6F, 0x6F, 0x20, 0x63, 0x6F, 0x6D, 0x70, 0x6C, 0x65, 0x78, 0x0, + 0x43, 0x61, 0x6E, 0x27, 0x74, 0x20, 0x63, 0x6F, 0x6E, 0x74, 0x69, + 0x6E, 0x75, 0x65, 0x0, 0x55, 0x6E, 0x64, 0x65, 0x66, 0x69, 0x6E, + 0x65, 0x64, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x66, 0x75, 0x6E, + 0x63, 0x74, 0x69, 0x6F, 0x6E, 0x0, 0x4E, 0x6F, 0x20, 0x52, 0x45, + 0x53, 0x55, 0x4D, 0x45, 0x0, 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x65, 0x72, + 0x72, 0x6F, 0x72, 0x0, 0x55, 0x6E, 0x70, 0x72, 0x69, 0x6E, 0x74, + 0x61, 0x62, 0x6C, 0x65, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x0, + 0x4D, 0x69, 0x73, 0x73, 0x69, 0x6E, 0x67, 0x20, 0x6F, 0x70, 0x65, + 0x72, 0x61, 0x6E, 0x64, 0x0, 0x4C, 0x69, 0x6E, 0x65, 0x20, 0x62, + 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6F, 0x76, 0x65, 0x72, 0x66, + 0x6C, 0x6F, 0x77, 0x0, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, + 0x54, 0x69, 0x6D, 0x65, 0x6F, 0x75, 0x74, 0x0, 0x44, 0x65, 0x76, + 0x69, 0x63, 0x65, 0x20, 0x46, 0x61, 0x75, 0x6C, 0x74, 0x0, 0x46, + 0x4F, 0x52, 0x20, 0x57, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, + 0x4E, 0x45, 0x58, 0x54, 0x0, 0x4F, 0x75, 0x74, 0x20, 0x6F, 0x66, + 0x20, 0x50, 0x61, 0x70, 0x65, 0x72, 0x0, 0x3F, 0x0, 0x57, 0x48, + 0x49, 0x4C, 0x45, 0x20, 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, + 0x20, 0x57, 0x45, 0x4E, 0x44, 0x0, 0x57, 0x45, 0x4E, 0x44, 0x20, + 0x77, 0x69, 0x74, 0x68, 0x6F, 0x75, 0x74, 0x20, 0x57, 0x48, 0x49, + 0x4C, 0x45, 0x0, 0x46, 0x49, 0x45, 0x4C, 0x44, 0x20, 0x6F, 0x76, + 0x65, 0x72, 0x66, 0x6C, 0x6F, 0x77, 0x0, 0x49, 0x6E, 0x74, 0x65, + 0x72, 0x6E, 0x61, 0x6C, 0x20, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x0, + 0x42, 0x61, 0x64, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6E, 0x75, + 0x6D, 0x62, 0x65, 0x72, 0x0, 0x46, 0x69, 0x6C, 0x65, 0x20, 0x6E, + 0x6F, 0x74, 0x20, 0x66, 0x6F, 0x75, 0x6E, 0x64, 0x0, 0x42, 0x61, + 0x64, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x6D, 0x6F, 0x64, 0x65, + 0x0, 0x46, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x6C, 0x72, 0x65, 0x61, + 0x64, 0x79, 0x20, 0x6F, 0x70, 0x65, 0x6E, 0x0, 0x3F, 0x0, 0x44, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x20, 0x49, 0x2F, 0x4F, 0x20, 0x45, + 0x72, 0x72, 0x6F, 0x72, 0x0, 0x46, 0x69, 0x6C, 0x65, 0x20, 0x61, + 0x6C, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x65, 0x78, 0x69, 0x73, + 0x74, 0x73, 0x0, 0x3F, 0x0, 0x3F, 0x0, 0x44, 0x69, 0x73, 0x6B, + 0x20, 0x66, 0x75, 0x6C, 0x6C, 0x0, 0x49, 0x6E, 0x70, 0x75, 0x74, + 0x20, 0x70, 0x61, 0x73, 0x74, 0x20, 0x65, 0x6E, 0x64, 0x0, 0x42, + 0x61, 0x64, 0x20, 0x72, 0x65, 0x63, 0x6F, 0x72, 0x64, 0x20, 0x6E, + 0x75, 0x6D, 0x62, 0x65, 0x72, 0x0, 0x42, 0x61, 0x64, 0x20, 0x66, + 0x69, 0x6C, 0x65, 0x20, 0x6E, 0x61, 0x6D, 0x65, 0x0, 0x3F, 0x0, + 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x69, 0x6E, 0x20, 0x66, 0x69, + 0x6C, 0x65, 0x0, 0x54, 0x6F, 0x6F, 0x20, 0x6D, 0x61, 0x6E, 0x79, + 0x20, 0x66, 0x69, 0x6C, 0x65, 0x73, 0x0, 0x0, 0x0, 0x0, 0xC3, + 0x1E, 0x10, 0x0, 0x52, 0xC7, 0x4F, 0x80, 0x52, 0xC7, 0x4F, 0x80, + 0xE4, 0x0, 0xCB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x1, 0x0, 0x0, 0x50, 0x38, 0x0, 0x72, 0x7, 0xFE, 0xFF, + 0xF, 0x7, 0xA, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x7, 0x7, 0x20, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x18, 0x18, 0x0, 0x0, 0x0, 0x0, 0x50, 0x0, 0x1, 0x0, 0x0, + 0x0, 0x7, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, + 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x20, 0x69, 0x6E, 0x20, 0x0, + 0x4F, 0x6B, 0xFF, 0xD, 0x0, 0x42, 0x72, 0x65, 0x61, 0x6B, 0x0, + 0xBB, 0x4, 0x0, 0x3, 0xDC, 0x43, 0x8A, 0x7, 0x43, 0x3C, 0xB1, + 0x75, 0x7, 0xB9, 0x6, 0x0, 0x3, 0xD9, 0xEB, 0xF1, 0x3C, 0x82, + 0x74, 0x1, 0xC3, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x43, 0x53, 0x8B, + 0xD9, 0xB, 0xD2, 0x87, 0xDA, 0x74, 0x4, 0x87, 0xDA, 0x3B, 0xDA, + 0xB9, 0x10, 0x0, 0x5B, 0x74, 0xE6, 0x3, 0xD9, 0xEB, 0xCF, 0xB9, + 0xB5, 0x8, 0xE9, 0x91, 0x0, 0xCD, 0x86, 0x8B, 0x1E, 0x2E, 0x0, + 0x8A, 0xC7, 0x22, 0xC3, 0xFE, 0xC0, 0x74, 0x9, 0xA0, 0x4F, 0x3, + 0xA, 0xC0, 0xB2, 0x13, 0x75, 0x4D, 0xE9, 0xBD, 0x26, 0xB2, 0x3D, + 0xB9, 0xB2, 0x39, 0xB9, 0xB2, 0x36, 0xB9, 0xB2, 0x35, 0xB9, 0xB2, + 0x34, 0xB9, 0xB2, 0x33, 0xB9, 0xB2, 0x3E, 0xB9, 0xB2, 0x37, 0xB9, + 0xB2, 0x40, 0xB9, 0xB2, 0x3F, 0xB9, 0xB2, 0x32, 0xB9, 0xB2, 0x43, + 0xB9, 0xB2, 0x3A, 0xEB, 0x22, 0x8B, 0x1E, 0x37, 0x3, 0x89, 0x1E, + 0x2E, 0x0, 0xB2, 0x2, 0xB9, 0xB2, 0xB, 0xB9, 0xB2, 0x1, 0xB9, + 0xB2, 0xA, 0xB9, 0xB2, 0x12, 0xB9, 0xB2, 0x14, 0xB9, 0xB2, 0x6, + 0xB9, 0xB2, 0x16, 0xB9, 0xB2, 0xD, 0x32, 0xC0, 0xA2, 0x36, 0x5, + 0xA2, 0x5F, 0x0, 0xA2, 0x62, 0x4, 0xA2, 0x60, 0x0, 0x8B, 0x1E, + 0x2E, 0x0, 0x89, 0x1E, 0x47, 0x3, 0x32, 0xC0, 0xA2, 0x65, 0x4, + 0xA2, 0x6B, 0x4, 0x8A, 0xC7, 0x22, 0xC3, 0xFE, 0xC0, 0x74, 0x4, + 0x89, 0x1E, 0x49, 0x3, 0xB9, 0xC, 0x8, 0x8B, 0x1E, 0x45, 0x3, + 0xE9, 0xB1, 0x25, 0x59, 0x8A, 0xC2, 0x8A, 0xCA, 0xA2, 0x28, 0x0, + 0x8B, 0x1E, 0x43, 0x3, 0x89, 0x1E, 0x4B, 0x3, 0x87, 0xDA, 0x8B, + 0x1E, 0x47, 0x3, 0x8A, 0xC7, 0x22, 0xC3, 0xFE, 0xC0, 0x74, 0xA, + 0x89, 0x1E, 0x54, 0x3, 0x87, 0xDA, 0x89, 0x1E, 0x56, 0x3, 0x8B, + 0x1E, 0x4D, 0x3, 0xB, 0xDB, 0x87, 0xDA, 0xBB, 0x4F, 0x3, 0x74, + 0xB, 0x22, 0x7, 0x75, 0x7, 0xFE, 0xF, 0x87, 0xDA, 0xE9, 0x73, + 0x6, 0x32, 0xC0, 0x88, 0x7, 0x8A, 0xD1, 0xE8, 0x8, 0x24, 0xBB, + 0xB4, 0x3, 0xCD, 0x87, 0x8A, 0xC2, 0x3C, 0x44, 0x73, 0x8, 0x3C, + 0x32, 0x73, 0x6, 0x3C, 0x1F, 0x72, 0x6, 0xB0, 0x28, 0x2C, 0x13, + 0x8A, 0xD0, 0x2E, 0x8A, 0x7, 0x43, 0xA, 0xC0, 0x75, 0xF8, 0x4B, + 0x43, 0xFE, 0xCA, 0x75, 0xF2, 0x53, 0x8B, 0x1E, 0x47, 0x3, 0x5E, + 0x87, 0xDE, 0x56, 0xCD, 0x88, 0x2E, 0x8A, 0x7, 0x3C, 0x3F, 0x75, + 0x6, 0x5B, 0xBB, 0xB4, 0x3, 0xEB, 0xD4, 0xE8, 0xBE, 0x72, 0x5B, + 0xBA, 0xFE, 0xFF, 0x3B, 0xDA, 0xCD, 0x89, 0x75, 0x3, 0xE9, 0xEE, + 0x75, 0x8A, 0xC7, 0x22, 0xC3, 0xFE, 0xC0, 0x74, 0x3, 0xE8, 0x99, + 0x5C, 0xB0, 0xFF, 0xE8, 0xF1, 0x22, 0xB0, 0x59, 0xCD, 0x8A, 0x32, + 0xC0, 0xA2, 0x6F, 0x0, 0xE8, 0x3B, 0x3C, 0xE8, 0x9A, 0x23, 0xBB, + 0x2D, 0x7, 0xE8, 0x8C, 0x72, 0xA0, 0x28, 0x0, 0x2C, 0x2, 0x75, + 0x3, 0xE8, 0xEE, 0x2D, 0xCD, 0x8B, 0xBB, 0xFF, 0xFF, 0x89, 0x1E, + 0x2E, 0x0, 0xA0, 0x3E, 0x3, 0xA, 0xC0, 0x74, 0x49, 0x8B, 0x1E, + 0x3F, 0x3, 0x53, 0xE8, 0x65, 0x5C, 0x5A, 0x52, 0xE8, 0x77, 0x1, + 0xB0, 0x2A, 0x72, 0x2, 0xB0, 0x20, 0xE8, 0xAC, 0x22, 0xE8, 0x84, + 0x28, 0x5A, 0x73, 0xE, 0x32, 0xC0, 0xA2, 0x3E, 0x3, 0xEB, 0xB0, + 0x32, 0xC0, 0xA2, 0x3E, 0x3, 0xEB, 0x15, 0x8B, 0x1E, 0x41, 0x3, + 0x3, 0xDA, 0x72, 0xF1, 0x52, 0xBA, 0xF9, 0xFF, 0x3B, 0xDA, 0x5A, + 0x73, 0xE8, 0x89, 0x1E, 0x3F, 0x3, 0xA0, 0xF7, 0x1, 0xA, 0xC0, + 0x74, 0xAA, 0xE9, 0xA8, 0x2D, 0xE8, 0x51, 0x28, 0x72, 0xA2, 0xE8, + 0xE9, 0x5, 0xFE, 0xC0, 0xFE, 0xC8, 0x74, 0x99, 0x9C, 0xE8, 0x2D, + 0x7, 0x73, 0x8, 0xE8, 0x93, 0x26, 0x75, 0x3, 0xE9, 0x76, 0xFE, + 0xE8, 0x38, 0x4, 0x8A, 0x7, 0x3C, 0x20, 0x75, 0x3, 0xE8, 0xF0, + 0x5B, 0x52, 0xE8, 0x31, 0x1, 0x5A, 0x9D, 0x89, 0x1E, 0x43, 0x3, + 0xCD, 0x8C, 0x72, 0x3, 0xE9, 0x6F, 0x3B, 0x52, 0x51, 0xE8, 0xEE, + 0x3D, 0xE8, 0xB0, 0x5, 0xA, 0xC0, 0x9C, 0x89, 0x16, 0x49, 0x3, + 0xE8, 0xF0, 0x0, 0x72, 0x9, 0x9D, 0x9C, 0x75, 0x3, 0xE9, 0xB0, + 0x7, 0xA, 0xC0, 0x51, 0x9C, 0x53, 0xE8, 0xAD, 0x1A, 0x5B, 0x9D, + 0x59, 0x51, 0x73, 0x3, 0xE8, 0xD6, 0x18, 0x5A, 0x9D, 0x52, 0x74, + 0x47, 0x5A, 0xA0, 0x6B, 0x4, 0xA, 0xC0, 0x75, 0x8, 0x8B, 0x1E, + 0xA, 0x3, 0x89, 0x1E, 0x2F, 0x3, 0x8B, 0x1E, 0x58, 0x3, 0x5E, + 0x87, 0xDE, 0x56, 0x59, 0x53, 0x3, 0xD9, 0x53, 0xE8, 0x15, 0x5B, + 0x5B, 0x89, 0x1E, 0x58, 0x3, 0x87, 0xDA, 0x88, 0x3F, 0x59, 0x5A, + 0x53, 0x43, 0x43, 0x89, 0x17, 0x43, 0x43, 0xBA, 0xB8, 0x0, 0x49, + 0x49, 0x49, 0x49, 0x8B, 0xF2, 0xAC, 0x88, 0x7, 0x43, 0x42, 0x49, + 0x8A, 0xC1, 0xA, 0xC5, 0x75, 0xF2, 0xCD, 0x8D, 0x5A, 0xE8, 0x1E, + 0x0, 0x8B, 0x1E, 0xE9, 0x4, 0x89, 0x1E, 0x52, 0x3, 0xE8, 0x49, + 0x23, 0xCD, 0x8E, 0x8B, 0x1E, 0x52, 0x3, 0x89, 0x1E, 0xE9, 0x4, + 0xE9, 0xD8, 0xFE, 0x8B, 0x1E, 0x30, 0x0, 0x87, 0xDA, 0x8A, 0xFE, + 0x8A, 0xDA, 0x8A, 0x7, 0x43, 0xA, 0x7, 0x75, 0x1, 0xC3, 0x43, + 0x43, 0x43, 0x8A, 0x7, 0xA, 0xC0, 0x74, 0x10, 0x3C, 0x20, 0x73, + 0xF5, 0x3C, 0xB, 0x72, 0xF1, 0xE8, 0xFD, 0x4, 0xE8, 0xF9, 0x4, + 0xEB, 0xEC, 0x43, 0x87, 0xDA, 0x89, 0x17, 0xEB, 0xD4, 0xBA, 0x0, + 0x0, 0x52, 0x74, 0x17, 0x3C, 0x2C, 0x74, 0x13, 0x5A, 0xE8, 0x23, + 0x6, 0x52, 0x74, 0x1D, 0x3C, 0x2C, 0x74, 0x19, 0xE8, 0xAF, 0x23, + 0xEA, 0x74, 0x2, 0x3C, 0x2C, 0xBA, 0xFA, 0xFF, 0x74, 0x3, 0xE8, + 0xC, 0x6, 0x74, 0x7, 0x3C, 0x2C, 0x74, 0x3, 0xE9, 0x63, 0xFD, + 0x89, 0x1E, 0x3B, 0x3, 0x87, 0xDA, 0x5A, 0x5E, 0x87, 0xDE, 0x56, + 0x53, 0x8B, 0x1E, 0x30, 0x0, 0x8B, 0xCB, 0x8A, 0x7, 0x43, 0xA, + 0x7, 0x9F, 0x4B, 0x9E, 0x74, 0x95, 0x43, 0x43, 0x8B, 0x1F, 0x3B, + 0xDA, 0x8B, 0xD9, 0x8B, 0x1F, 0xF5, 0x74, 0x88, 0xF5, 0x73, 0x85, + 0xEB, 0xE2, 0x32, 0xC0, 0xA2, 0xFD, 0x2, 0xA2, 0xFC, 0x2, 0xCD, + 0x8F, 0xB9, 0x3B, 0x1, 0xBA, 0xB8, 0x0, 0x8A, 0x7, 0xA, 0xC0, + 0x75, 0x20, 0xBB, 0x40, 0x1, 0x8A, 0xC3, 0x2A, 0xC1, 0x8A, 0xC8, + 0x8A, 0xC7, 0x1A, 0xC5, 0x8A, 0xE8, 0xBB, 0xB7, 0x0, 0x32, 0xC0, + 0x8B, 0xFA, 0xAA, 0x42, 0x8B, 0xFA, 0xAA, 0x42, 0x8B, 0xFA, 0xAA, + 0xC3, 0x3C, 0x22, 0x75, 0x3, 0xE9, 0x33, 0x0, 0x3C, 0x20, 0x74, + 0x9, 0xA0, 0xFC, 0x2, 0xA, 0xC0, 0x8A, 0x7, 0x74, 0x2F, 0x43, + 0x50, 0xE8, 0x54, 0x2, 0x58, 0x2C, 0x3A, 0x74, 0x6, 0x3C, 0x4A, + 0x75, 0x8, 0xB0, 0x1, 0xA2, 0xFC, 0x2, 0xA2, 0xFD, 0x2, 0x2C, + 0x55, 0x75, 0xAC, 0x50, 0x8A, 0x7, 0xA, 0xC0, 0x58, 0x74, 0xAA, + 0x3A, 0x7, 0x74, 0xDA, 0x50, 0x8A, 0x7, 0x43, 0xE8, 0x2C, 0x2, + 0xEB, 0xEC, 0x43, 0xA, 0xC0, 0x78, 0x92, 0x4B, 0x3C, 0x3F, 0xB0, + 0x91, 0x52, 0x51, 0x75, 0x3, 0xE9, 0xE2, 0x0, 0xBA, 0x6B, 0x3, + 0xE8, 0xD2, 0xE, 0xE8, 0x29, 0x24, 0x73, 0x3, 0xE9, 0x2E, 0x1, + 0x53, 0xBA, 0x5E, 0xB, 0xE8, 0x20, 0x0, 0x75, 0x3E, 0xE8, 0xF0, + 0x3, 0xBA, 0x62, 0xB, 0xE8, 0x15, 0x0, 0xB0, 0x89, 0x75, 0x3, + 0xEB, 0xB, 0x90, 0xBA, 0x65, 0xB, 0xE8, 0x8, 0x0, 0x75, 0x26, + 0xB0, 0x8D, 0x59, 0xE9, 0xAD, 0x0, 0x8B, 0xF2, 0x2E, 0xAC, 0xA, + 0xC0, 0x75, 0x1, 0xC3, 0x8A, 0xC8, 0xE8, 0x95, 0xE, 0x3A, 0xC1, + 0x75, 0xF6, 0x43, 0x42, 0xEB, 0xEA, 0x47, 0x4F, 0x20, 0x0, 0x54, + 0x4F, 0x0, 0x55, 0x42, 0x0, 0x5B, 0xE8, 0x7F, 0xE, 0x53, 0xCD, + 0x90, 0xBB, 0x3, 0x1, 0x2C, 0x41, 0x2, 0xC0, 0x8A, 0xC8, 0xB5, + 0x0, 0x3, 0xD9, 0x2E, 0x8B, 0x17, 0x5B, 0x43, 0x53, 0xE8, 0x66, + 0xE, 0x8A, 0xC8, 0x8B, 0xF2, 0x2E, 0xAC, 0x24, 0x7F, 0x75, 0x3, + 0xE9, 0xAB, 0x1, 0x43, 0x3A, 0xC1, 0x75, 0x50, 0x8B, 0xF2, 0x2E, + 0xAC, 0x42, 0xA, 0xC0, 0x79, 0xE2, 0x8A, 0xC1, 0x3C, 0x28, 0x74, + 0x1D, 0x8B, 0xF2, 0x2E, 0xAC, 0x3C, 0xD1, 0x74, 0x15, 0x3C, 0xD0, + 0x74, 0x11, 0xE8, 0x36, 0xE, 0x3C, 0x2E, 0x74, 0x3, 0xE8, 0xC7, + 0x15, 0xB0, 0x0, 0x72, 0x3, 0xE9, 0x7A, 0x1, 0x58, 0x8B, 0xF2, + 0x2E, 0xAC, 0xCD, 0x91, 0xA, 0xC0, 0x79, 0x3, 0xE9, 0x23, 0x0, + 0x59, 0x5A, 0xC, 0x80, 0x50, 0xB0, 0xFF, 0xE8, 0x51, 0x1, 0x32, + 0xC0, 0xA2, 0xFD, 0x2, 0x58, 0xE8, 0x48, 0x1, 0xE9, 0xB2, 0xFE, + 0x5B, 0x8B, 0xF2, 0x2E, 0xAC, 0x42, 0xA, 0xC0, 0x79, 0xF7, 0x42, + 0xEB, 0x8D, 0x4B, 0x50, 0xCD, 0x92, 0xBA, 0xC, 0xC, 0x8A, 0xC8, + 0x8B, 0xF2, 0x2E, 0xAC, 0xA, 0xC0, 0x74, 0x17, 0x42, 0x3A, 0xC1, + 0x75, 0xF3, 0xEB, 0x14, 0x8C, 0xAA, 0xAB, 0xA9, 0xA6, 0xA8, 0xD4, + 0xA1, 0x8A, 0x93, 0x9E, 0x89, 0x8E, 0xCD, 0x8D, 0x0, 0x32, 0xC0, + 0xEB, 0x2, 0xB0, 0x1, 0xA2, 0xFD, 0x2, 0x58, 0x59, 0x5A, 0x3C, + 0xA1, 0x50, 0x75, 0x3, 0xE8, 0xFA, 0x0, 0x58, 0x3C, 0xB1, 0x75, + 0x5, 0xE8, 0xF4, 0x0, 0xB0, 0xE9, 0x3C, 0xD9, 0x74, 0x3, 0xE9, + 0xC6, 0x0, 0x50, 0xE8, 0xE5, 0x0, 0xB0, 0x8F, 0xE8, 0xE2, 0x0, + 0x58, 0x50, 0xE9, 0xAD, 0xFE, 0x8A, 0x7, 0x3C, 0x2E, 0x74, 0xE, + 0x3C, 0x3A, 0x72, 0x3, 0xE9, 0x90, 0x0, 0x3C, 0x30, 0x73, 0x3, + 0xE9, 0x89, 0x0, 0xA0, 0xFD, 0x2, 0xA, 0xC0, 0x8A, 0x7, 0x59, + 0x5A, 0x79, 0x3, 0xE9, 0x62, 0xFE, 0x74, 0x27, 0x3C, 0x2E, 0x75, + 0x3, 0xE9, 0x59, 0xFE, 0xB0, 0xE, 0xE8, 0xAD, 0x0, 0x52, 0xE8, + 0xE8, 0x3, 0xE8, 0xFD, 0x0, 0x5E, 0x87, 0xDE, 0x56, 0x87, 0xDA, + 0x8A, 0xC3, 0xE8, 0x9B, 0x0, 0x8A, 0xC7, 0x5B, 0xE8, 0x95, 0x0, + 0xE9, 0xFF, 0xFD, 0x52, 0x51, 0x8A, 0x7, 0xE8, 0x1F, 0x5D, 0xE8, + 0xDF, 0x0, 0x59, 0x5A, 0x53, 0xA0, 0xFB, 0x2, 0x3C, 0x2, 0x75, + 0x1A, 0x8B, 0x1E, 0xA3, 0x4, 0x8A, 0xC7, 0xA, 0xC0, 0xB0, 0x2, + 0x75, 0xE, 0x8A, 0xC3, 0x8A, 0xFB, 0xB3, 0xF, 0x3C, 0xA, 0x73, + 0xC8, 0x4, 0x11, 0xEB, 0xCB, 0x50, 0xD0, 0xC8, 0x4, 0x1B, 0xE8, + 0x5C, 0x0, 0xBB, 0xA3, 0x4, 0xE8, 0x4F, 0xE, 0x72, 0x3, 0xBB, + 0x9F, 0x4, 0x58, 0x50, 0x8A, 0x7, 0xE8, 0x4A, 0x0, 0x58, 0x43, + 0xFE, 0xC8, 0x75, 0xF4, 0x5B, 0xE9, 0xAD, 0xFD, 0xBA, 0x6A, 0x3, + 0x42, 0x8B, 0xF2, 0x2E, 0xAC, 0x24, 0x7F, 0x75, 0x3, 0xE9, 0x6B, + 0x0, 0x42, 0x3A, 0x7, 0x8B, 0xF2, 0x2E, 0xAC, 0x75, 0xEB, 0xE9, + 0x6F, 0x0, 0x3C, 0x26, 0x74, 0x3, 0xE9, 0xC5, 0xFD, 0x53, 0xE8, + 0xB, 0x2, 0x5B, 0xE8, 0xD7, 0xC, 0x3C, 0x48, 0xB0, 0xB, 0x75, + 0x2, 0xB0, 0xC, 0xE8, 0xB, 0x0, 0x52, 0x51, 0xE8, 0xD9, 0xC, + 0x59, 0xE9, 0x5C, 0xFF, 0xB0, 0x3A, 0x8B, 0xFA, 0xAA, 0x42, 0x49, + 0x8A, 0xC1, 0xA, 0xC5, 0x74, 0x1, 0xC3, 0xB2, 0x17, 0xE9, 0x9B, + 0xFA, 0xCD, 0x93, 0x5B, 0x4B, 0xFE, 0xC8, 0xA2, 0xFD, 0x2, 0x59, + 0x5A, 0xE8, 0xA0, 0xC, 0xE8, 0xDE, 0xFF, 0x43, 0xE8, 0x99, 0xC, + 0xE8, 0xF0, 0x21, 0x73, 0xF4, 0x3C, 0x3A, 0x73, 0x8, 0x3C, 0x30, + 0x73, 0xEC, 0x3C, 0x2E, 0x74, 0xE8, 0xE9, 0x33, 0xFD, 0x8A, 0x7, + 0x3C, 0x20, 0x73, 0xA, 0x3C, 0x9, 0x74, 0x6, 0x3C, 0xA, 0x74, + 0x2, 0xB0, 0x20, 0x50, 0xA0, 0xFD, 0x2, 0xFE, 0xC0, 0x74, 0x2, + 0xFE, 0xC8, 0xE9, 0x9F, 0xFE, 0x4B, 0x8A, 0x7, 0x3C, 0x20, 0x74, + 0xF9, 0x3C, 0x9, 0x74, 0xF5, 0x3C, 0xA, 0x74, 0xF1, 0x43, 0xC3, + 0xB0, 0x64, 0xA2, 0x39, 0x3, 0xE8, 0xD2, 0x29, 0xE8, 0x55, 0x20, + 0xE7, 0x52, 0x89, 0x16, 0x3B, 0x3, 0xA0, 0xFB, 0x2, 0x50, 0xE8, + 0x7B, 0x9, 0x58, 0x53, 0xE8, 0x29, 0x10, 0xBB, 0x56, 0x4, 0xE8, + 0x45, 0x56, 0x5B, 0x5A, 0x59, 0x53, 0xE8, 0x9D, 0x3, 0x89, 0x1E, + 0x35, 0x3, 0xBB, 0x2, 0x0, 0x3, 0xDC, 0xE8, 0x73, 0xF9, 0x75, + 0x1E, 0x3, 0xD9, 0x52, 0x4B, 0x8A, 0x37, 0x4B, 0x8A, 0x17, 0x43, + 0x43, 0x53, 0x8B, 0x1E, 0x35, 0x3, 0x3B, 0xDA, 0x5B, 0x5A, 0x75, + 0xE5, 0x5A, 0x8B, 0xE3, 0x89, 0x1E, 0x45, 0x3, 0xB1, 0x5A, 0x87, + 0xDA, 0xB1, 0x8, 0xE8, 0xE3, 0x1E, 0x53, 0x8B, 0x1E, 0x35, 0x3, + 0x5E, 0x87, 0xDE, 0x56, 0x53, 0x8B, 0x1E, 0x2E, 0x0, 0x5E, 0x87, + 0xDE, 0x56, 0xE8, 0xED, 0x1F, 0xCC, 0xE8, 0x1A, 0xD, 0x75, 0x3, + 0xE9, 0xC6, 0xF9, 0x72, 0x3, 0xE9, 0xC1, 0xF9, 0x9C, 0xE8, 0xE, + 0x9, 0x9D, 0x53, 0x78, 0x3, 0xE9, 0x1C, 0x0, 0xE8, 0x8A, 0x5D, + 0x5E, 0x87, 0xDE, 0x56, 0xBA, 0x1, 0x0, 0x8A, 0x7, 0x3C, 0xCF, + 0x75, 0x3, 0xE8, 0xD4, 0x10, 0x52, 0x53, 0x87, 0xDA, 0xE8, 0xC6, + 0x56, 0xEB, 0x27, 0xE8, 0x12, 0x5D, 0xE8, 0xB1, 0x55, 0x5B, 0x51, + 0x52, 0xB9, 0x0, 0x81, 0x8A, 0xF1, 0x8A, 0xD6, 0xCD, 0x94, 0x8A, + 0x7, 0x3C, 0xCF, 0xB0, 0x1, 0x75, 0xE, 0xE8, 0xCF, 0x8, 0x53, + 0xE8, 0xF4, 0x5C, 0xE8, 0x93, 0x55, 0xE8, 0x12, 0x6D, 0x5B, 0x51, + 0x52, 0x8A, 0xC8, 0xE8, 0xBA, 0xC, 0x8A, 0xE8, 0x51, 0x4B, 0xE8, + 0xAB, 0x0, 0x74, 0x3, 0xE9, 0x47, 0xF9, 0xE8, 0x81, 0x16, 0xE8, + 0xA0, 0x0, 0x53, 0x53, 0x8B, 0x1E, 0x5A, 0x4, 0x89, 0x1E, 0x2E, + 0x0, 0x8B, 0x1E, 0x3B, 0x3, 0x5E, 0x87, 0xDE, 0x56, 0xB5, 0x82, + 0x51, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x9F, 0x86, 0xC4, 0x50, + 0x86, 0xC4, 0xE9, 0xCF, 0x64, 0xB5, 0x82, 0x51, 0xEB, 0x42, 0xE9, + 0xCB, 0xF8, 0xE9, 0x12, 0xF9, 0xC3, 0xE8, 0x75, 0x0, 0xEB, 0x50, + 0xCD, 0x95, 0xE9, 0x63, 0xF, 0xE9, 0xD5, 0x2, 0xA, 0xC0, 0x75, + 0xEB, 0x43, 0x8A, 0x7, 0x43, 0xA, 0x7, 0x74, 0xE0, 0x43, 0x8B, + 0x17, 0x43, 0x89, 0x16, 0x2E, 0x0, 0xF6, 0x6, 0x76, 0x4, 0xFF, + 0x74, 0x26, 0x53, 0xB0, 0x5B, 0xE8, 0xCA, 0x1C, 0x87, 0xDA, 0xE8, + 0x70, 0x56, 0xB0, 0x5D, 0xE8, 0xC0, 0x1C, 0x5B, 0xEB, 0x13, 0xCD, + 0x96, 0xE8, 0x9B, 0x1D, 0x89, 0x26, 0x45, 0x3, 0x89, 0x1E, 0x43, + 0x3, 0x8A, 0x7, 0x3C, 0x3A, 0x75, 0xBF, 0x43, 0x8A, 0x7, 0x3C, + 0x3A, 0x72, 0xAB, 0xBA, 0xE8, 0xE, 0x52, 0x74, 0xA4, 0x2C, 0x81, + 0x72, 0xAB, 0x3C, 0x4A, 0x73, 0xA2, 0x32, 0xE4, 0x2, 0xC0, 0x8B, + 0xF0, 0xCD, 0x97, 0x2E, 0xFF, 0xB4, 0x25, 0x0, 0x43, 0x8A, 0x7, + 0x3C, 0x3A, 0x72, 0x1, 0xC3, 0x3C, 0x20, 0x74, 0xF4, 0x72, 0x8, + 0x3C, 0x30, 0xF5, 0xFE, 0xC0, 0xFE, 0xC8, 0xC3, 0xA, 0xC0, 0x74, + 0xFB, 0x3C, 0xB, 0x72, 0x72, 0x3C, 0x1E, 0x75, 0x6, 0xA0, 0x0, + 0x3, 0xA, 0xC0, 0xC3, 0x3C, 0x10, 0x74, 0x3C, 0x50, 0x43, 0xA2, + 0x0, 0x3, 0x2C, 0x1C, 0x73, 0x39, 0x2C, 0xF5, 0x73, 0x7, 0x3C, + 0xFE, 0x75, 0x1B, 0x8A, 0x7, 0x43, 0x89, 0x1E, 0xFE, 0x2, 0xB7, + 0x0, 0x8A, 0xD8, 0x89, 0x1E, 0x2, 0x3, 0xB0, 0x2, 0xA2, 0x1, + 0x3, 0xBB, 0x4, 0x0, 0x58, 0xA, 0xC0, 0xC3, 0x8A, 0x7, 0x43, + 0x43, 0x89, 0x1E, 0xFE, 0x2, 0x4B, 0x8A, 0x3F, 0xEB, 0xE1, 0xE8, + 0x37, 0x0, 0x8B, 0x1E, 0xFE, 0x2, 0xEB, 0x93, 0xFE, 0xC0, 0xD0, + 0xC0, 0xA2, 0x1, 0x3, 0x52, 0x51, 0xBA, 0x2, 0x3, 0x87, 0xDA, + 0x8A, 0xE8, 0xE8, 0x13, 0x55, 0x87, 0xDA, 0x59, 0x5A, 0x89, 0x1E, + 0xFE, 0x2, 0x58, 0xBB, 0x4, 0x0, 0xA, 0xC0, 0xC3, 0x3C, 0x9, + 0x72, 0x3, 0xE9, 0x69, 0xFF, 0x3C, 0x30, 0xF5, 0xFE, 0xC0, 0xFE, + 0xC8, 0xC3, 0xA0, 0x0, 0x3, 0x3C, 0xF, 0x73, 0x17, 0x3C, 0xD, + 0x72, 0x13, 0x8B, 0x1E, 0x2, 0x3, 0x75, 0xA, 0x43, 0x43, 0x43, + 0x8A, 0x17, 0x43, 0x8A, 0x37, 0x87, 0xDA, 0xE9, 0x6A, 0x54, 0xA0, + 0x1, 0x3, 0xA2, 0xFB, 0x2, 0x3C, 0x8, 0x74, 0x11, 0x8B, 0x1E, + 0x2, 0x3, 0x89, 0x1E, 0xA3, 0x4, 0x8B, 0x1E, 0x4, 0x3, 0x89, + 0x1E, 0xA5, 0x4, 0xC3, 0xBB, 0x2, 0x3, 0xE9, 0x9D, 0x54, 0xB2, + 0x3, 0xB9, 0xB2, 0x2, 0xB9, 0xB2, 0x4, 0xB9, 0xB2, 0x8, 0xE8, + 0x3A, 0x1F, 0xB9, 0xBE, 0x7, 0x51, 0x72, 0xE5, 0x2C, 0x41, 0x8A, + 0xC8, 0x8A, 0xE8, 0xE8, 0x5, 0xFF, 0x3C, 0xEA, 0x75, 0xF, 0xE8, + 0xFE, 0xFE, 0xE8, 0x21, 0x1F, 0x72, 0xD0, 0x2C, 0x41, 0x8A, 0xE8, + 0xE8, 0xF2, 0xFE, 0x8A, 0xC5, 0x2A, 0xC1, 0x72, 0xC3, 0xFE, 0xC0, + 0x5E, 0x87, 0xDE, 0x56, 0xBB, 0x60, 0x3, 0xB5, 0x0, 0x3, 0xD9, + 0x88, 0x17, 0x43, 0xFE, 0xC8, 0x75, 0xF9, 0x5B, 0x8A, 0x7, 0x3C, + 0x2C, 0x75, 0xA8, 0xE8, 0xCE, 0xFE, 0xEB, 0xB5, 0xE8, 0xC9, 0xFE, + 0xE8, 0xB3, 0xE, 0x79, 0x9B, 0xB2, 0x5, 0xE9, 0x7A, 0xF7, 0x8A, + 0x7, 0x3C, 0x2E, 0x8B, 0x16, 0x49, 0x3, 0x75, 0x3, 0xE9, 0xB2, + 0xFE, 0x4B, 0xE8, 0xAE, 0xFE, 0x3C, 0xE, 0x74, 0x2, 0x3C, 0xD, + 0x8B, 0x16, 0x2, 0x3, 0x75, 0x3, 0xE9, 0x9F, 0xFE, 0x32, 0xC0, + 0xA2, 0x0, 0x3, 0x4B, 0xBA, 0x0, 0x0, 0xE8, 0x93, 0xFE, 0x72, + 0x1, 0xC3, 0x53, 0x9F, 0x50, 0xBB, 0x98, 0x19, 0x3B, 0xDA, 0x72, + 0x1B, 0x8A, 0xFE, 0x8A, 0xDA, 0x3, 0xDA, 0x3, 0xDB, 0x3, 0xDA, + 0x3, 0xDB, 0x58, 0x9E, 0x2C, 0x30, 0x8A, 0xD0, 0xB6, 0x0, 0x3, + 0xDA, 0x87, 0xDA, 0x5B, 0xEB, 0xD5, 0x58, 0x9E, 0x5B, 0xC3, 0x75, + 0x3, 0xE9, 0x7C, 0x1C, 0x3C, 0xE, 0x74, 0x7, 0x3C, 0xD, 0x74, + 0x3, 0xE9, 0xA3, 0x30, 0xE8, 0x75, 0x1C, 0xB9, 0xE8, 0xE, 0xEB, + 0x1E, 0xB1, 0x3, 0xE8, 0x2, 0x1C, 0xE8, 0x95, 0xFF, 0x59, 0x53, + 0x53, 0x8B, 0x1E, 0x2E, 0x0, 0x5E, 0x87, 0xDE, 0x56, 0xB0, 0x8D, + 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x51, 0xEB, 0x4, 0x51, 0xE8, + 0x7B, 0xFF, 0xA0, 0x0, 0x3, 0x3C, 0xD, 0x87, 0xDA, 0x74, 0xBC, + 0x3C, 0xE, 0x74, 0x3, 0xE9, 0xBE, 0xF6, 0x87, 0xDA, 0x53, 0x8B, + 0x1E, 0xFE, 0x2, 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0x51, 0x0, 0x43, + 0x53, 0x8B, 0x1E, 0x2E, 0x0, 0x3B, 0xDA, 0x5B, 0x73, 0x3, 0xE8, + 0x4F, 0xF9, 0x72, 0x3, 0xE8, 0x46, 0xF9, 0x73, 0xD, 0x49, 0xB0, + 0xD, 0xA2, 0x3D, 0x3, 0x5B, 0xE8, 0xFC, 0x12, 0x8B, 0xD9, 0xC3, + 0xB2, 0x8, 0xE9, 0xA3, 0xF6, 0xCD, 0x98, 0x75, 0xF6, 0xB6, 0xFF, + 0xE8, 0xFA, 0xF5, 0x8B, 0xE3, 0x89, 0x1E, 0x45, 0x3, 0x3C, 0x8D, + 0xB2, 0x3, 0x74, 0x3, 0xE9, 0x8B, 0xF6, 0x5B, 0x89, 0x1E, 0x2E, + 0x0, 0xBB, 0xE8, 0xE, 0x5E, 0x87, 0xDE, 0x56, 0xB0, 0x5B, 0xB1, + 0x3A, 0xEB, 0x2, 0xB1, 0x0, 0xB5, 0x0, 0x8A, 0xC1, 0x8A, 0xCD, + 0x8A, 0xE8, 0x4B, 0xE8, 0xB0, 0xFD, 0xA, 0xC0, 0x74, 0xBE, 0x3A, + 0xC5, 0x74, 0xBA, 0x43, 0x3C, 0x22, 0x74, 0xE9, 0xFE, 0xC0, 0x74, + 0xEC, 0x2C, 0x8C, 0x75, 0xE7, 0x3A, 0xC5, 0x12, 0xC6, 0x8A, 0xF0, + 0xEB, 0xDF, 0x58, 0x4, 0x3, 0xEB, 0x14, 0xE8, 0xDC, 0x25, 0xE8, + 0x5F, 0x1C, 0xE7, 0x89, 0x16, 0x3B, 0x3, 0x52, 0xA0, 0xFB, 0x2, + 0x50, 0xE8, 0x85, 0x5, 0x58, 0x5E, 0x87, 0xDE, 0x56, 0x8A, 0xE8, + 0xA0, 0xFB, 0x2, 0x3A, 0xC5, 0x8A, 0xC5, 0x74, 0x6, 0xE8, 0x25, + 0xC, 0xA0, 0xFB, 0x2, 0xBA, 0xA3, 0x4, 0x3C, 0x5, 0x72, 0x3, + 0xBA, 0x9F, 0x4, 0x53, 0x3C, 0x3, 0x75, 0x31, 0x8B, 0x1E, 0xA3, + 0x4, 0x53, 0x43, 0x8B, 0x17, 0x8B, 0x1E, 0x30, 0x0, 0x3B, 0xDA, + 0x73, 0x11, 0x8B, 0x1E, 0x5C, 0x3, 0x3B, 0xDA, 0x5A, 0x73, 0x11, + 0xBB, 0x2C, 0x3, 0x3B, 0xDA, 0x73, 0xA, 0xB0, 0x5A, 0xE8, 0xE6, + 0x16, 0x87, 0xDA, 0xE8, 0x33, 0x14, 0xE8, 0xDE, 0x16, 0x5E, 0x87, + 0xDE, 0x56, 0xE8, 0xBE, 0x52, 0x5A, 0x5B, 0xC3, 0x3C, 0xA7, 0x75, + 0x32, 0xE8, 0x18, 0xFD, 0xE8, 0xEC, 0x1B, 0x89, 0xE8, 0x5F, 0xFE, + 0xB, 0xD2, 0x74, 0xD, 0xE8, 0x4F, 0xF8, 0x8A, 0xF5, 0x8A, 0xD1, + 0x5B, 0x72, 0x3, 0xE9, 0x13, 0xFF, 0x89, 0x16, 0x4D, 0x3, 0x72, + 0xDA, 0xA0, 0x4F, 0x3, 0xA, 0xC0, 0x8A, 0xC2, 0x74, 0xD1, 0xA0, + 0x28, 0x0, 0x8A, 0xD0, 0xE9, 0xCE, 0xF5, 0xE8, 0xE5, 0xC, 0x8A, + 0x7, 0x8A, 0xE8, 0x3C, 0x8D, 0x74, 0x5, 0xE8, 0xB2, 0x1B, 0x89, + 0x4B, 0x8A, 0xCA, 0xFE, 0xC9, 0x8A, 0xC5, 0x75, 0x3, 0xE9, 0xB9, + 0xFC, 0xE8, 0x1A, 0xFE, 0x3C, 0x2C, 0x75, 0xA7, 0xEB, 0xEE, 0xA0, + 0x4F, 0x3, 0xA, 0xC0, 0x75, 0x8, 0x33, 0xC0, 0xA3, 0x4D, 0x3, + 0xE9, 0x66, 0xF5, 0xFE, 0xC0, 0xA2, 0x28, 0x0, 0x80, 0x3F, 0x83, + 0x74, 0x12, 0xE8, 0xF7, 0xFD, 0x75, 0xC, 0xB, 0xD2, 0x74, 0x10, + 0xE8, 0x73, 0xFE, 0x32, 0xC0, 0xA2, 0x4F, 0x3, 0xC3, 0xE8, 0x97, + 0xFC, 0x75, 0xFA, 0xEB, 0x7, 0x32, 0xC0, 0xA2, 0x4F, 0x3, 0xFE, + 0xC0, 0xA1, 0x47, 0x3, 0xA3, 0x2E, 0x0, 0x8B, 0x1E, 0x4B, 0x3, + 0x75, 0xE5, 0x80, 0x3F, 0x0, 0x75, 0x3, 0x83, 0xC3, 0x4, 0x43, + 0xE9, 0x17, 0x19, 0xE8, 0x70, 0xC, 0x75, 0xDA, 0xA, 0xC0, 0x75, + 0x3, 0xE9, 0xA4, 0xFD, 0xE9, 0x20, 0xF5, 0xBA, 0xA, 0x0, 0x52, + 0x74, 0x1F, 0xE8, 0x9D, 0xFD, 0x87, 0xDA, 0x5E, 0x87, 0xDE, 0x56, + 0x74, 0x16, 0x87, 0xDA, 0xE8, 0x26, 0x1B, 0x2C, 0x8B, 0x16, 0x41, + 0x3, 0x74, 0x8, 0xE8, 0x93, 0xFD, 0x74, 0x3, 0xE9, 0xE1, 0xF4, + 0x87, 0xDA, 0x8A, 0xC7, 0xA, 0xC3, 0x75, 0x3, 0xE9, 0x71, 0xFD, + 0x89, 0x1E, 0x41, 0x3, 0xA2, 0x3E, 0x3, 0x5B, 0x89, 0x1E, 0x3F, + 0x3, 0x59, 0xE9, 0xDB, 0xF5, 0xE8, 0x2C, 0x4, 0x8A, 0x7, 0x3C, + 0x2C, 0x75, 0x3, 0xE8, 0x19, 0xFC, 0x3C, 0x89, 0x74, 0x5, 0xE8, + 0xE9, 0x1A, 0xCD, 0x4B, 0x53, 0xE8, 0xD2, 0x51, 0x5B, 0x74, 0x19, + 0xE8, 0x6, 0xFC, 0x75, 0x1, 0xC3, 0x3C, 0xE, 0x75, 0x3, 0xE9, + 0xCC, 0xFD, 0x3C, 0xD, 0x74, 0x3, 0xE9, 0xE0, 0xFB, 0x8B, 0x1E, + 0x2, 0x3, 0xC3, 0xB6, 0x1, 0xE8, 0x29, 0xFE, 0xA, 0xC0, 0x74, + 0xF6, 0xE8, 0xE4, 0xFB, 0x3C, 0xA1, 0x75, 0xF2, 0xFE, 0xCE, 0x75, + 0xEE, 0xEB, 0xD1, 0xE8, 0x6A, 0x1, 0xEB, 0x3, 0xE8, 0x9B, 0x31, + 0x4B, 0xE8, 0xCE, 0xFB, 0x75, 0x3, 0xE8, 0x1D, 0x19, 0x75, 0x3, + 0xE9, 0x3F, 0x1, 0x3C, 0xD7, 0x75, 0x3, 0xE9, 0x6B, 0x27, 0x3C, + 0xCE, 0x75, 0x3, 0xE9, 0xAB, 0x0, 0x3C, 0xD2, 0x75, 0x3, 0xE9, + 0xA4, 0x0, 0x53, 0x3C, 0x2C, 0x74, 0x6D, 0x3C, 0x3B, 0x75, 0x3, + 0xE9, 0x17, 0x1, 0x59, 0xE8, 0xA9, 0x3, 0x53, 0xE8, 0xA3, 0x7, + 0x74, 0xF, 0xE8, 0x41, 0x5D, 0xE8, 0xC2, 0x12, 0xC6, 0x7, 0x20, + 0x8B, 0x1E, 0xA3, 0x4, 0xFE, 0x7, 0xCD, 0x99, 0x8B, 0x1E, 0xA3, + 0x4, 0x53, 0xE8, 0x39, 0x1C, 0x74, 0xD, 0xE8, 0x31, 0x1, 0x78, + 0x3, 0xE9, 0x31, 0x0, 0xE8, 0x81, 0x45, 0xEB, 0x3, 0xA0, 0x29, + 0x0, 0x8A, 0xE8, 0xFE, 0xC0, 0x74, 0x23, 0xE8, 0x1E, 0x1C, 0x74, + 0x7, 0xE8, 0x66, 0x45, 0x8A, 0x7, 0xEB, 0x3, 0xE8, 0x68, 0x3B, + 0x5B, 0x53, 0xA, 0xC0, 0x74, 0xE, 0x2, 0x7, 0xF5, 0x73, 0x4, + 0xFE, 0xC8, 0x3A, 0xC5, 0x72, 0x3, 0xE8, 0x99, 0x18, 0x5B, 0xE8, + 0xDE, 0x12, 0x5B, 0xE9, 0x6B, 0xFF, 0xCD, 0x9A, 0xB9, 0x32, 0x0, + 0x8B, 0x1E, 0xE9, 0x4, 0x3, 0xD9, 0xE8, 0xE8, 0x1B, 0x8A, 0x7, + 0x75, 0x18, 0xA0, 0x2A, 0x0, 0x8A, 0xE8, 0xE8, 0x32, 0x3B, 0x3C, + 0xFF, 0x74, 0xC, 0x3A, 0xC5, 0x72, 0x3, 0xE8, 0x6C, 0x18, 0x72, + 0x3, 0xE9, 0x87, 0x0, 0x2C, 0xE, 0x73, 0xFC, 0xF6, 0xD0, 0xEB, + 0x72, 0x50, 0xE8, 0x7, 0xFB, 0xE8, 0xF1, 0xA, 0x58, 0x50, 0x3C, + 0xD2, 0x74, 0x1, 0x4A, 0x8A, 0xC6, 0xA, 0xC0, 0x78, 0x3, 0xE9, + 0x3, 0x0, 0xBA, 0x0, 0x0, 0x53, 0xE8, 0xA6, 0x1B, 0x74, 0xD, + 0xE8, 0x9E, 0x0, 0x78, 0x3, 0xE9, 0x15, 0x0, 0xE8, 0xEE, 0x44, + 0xEB, 0x3, 0xA0, 0x29, 0x0, 0x8A, 0xD8, 0xFE, 0xC0, 0x74, 0x7, + 0xB7, 0x0, 0xE8, 0x7C, 0x51, 0x87, 0xDA, 0x5B, 0xE8, 0xA1, 0x19, + 0x29, 0x4B, 0x58, 0x2C, 0xD2, 0x53, 0x74, 0x13, 0xB9, 0x32, 0x0, + 0x8B, 0x1E, 0xE9, 0x4, 0x3, 0xD9, 0xE8, 0x6F, 0x1B, 0x8A, 0x7, + 0x75, 0x3, 0xE8, 0xBE, 0x3A, 0xF6, 0xD0, 0x2, 0xC2, 0x72, 0x10, + 0xFE, 0xC0, 0x74, 0x19, 0xE8, 0xF6, 0x17, 0x8A, 0xC2, 0xFE, 0xC8, + 0x79, 0x3, 0xE9, 0xD, 0x0, 0xFE, 0xC0, 0x8A, 0xE8, 0xB0, 0x20, + 0xE8, 0x18, 0x17, 0xFE, 0xCD, 0x75, 0xF9, 0x5B, 0xE8, 0x88, 0xFA, + 0xE9, 0xBC, 0xFE, 0xCD, 0x9B, 0x32, 0xC0, 0x53, 0x52, 0x51, 0xE8, + 0x86, 0x2C, 0x59, 0x5A, 0x32, 0xC0, 0x8A, 0xF8, 0x8A, 0xD8, 0x89, + 0x1E, 0xE9, 0x4, 0x5B, 0xC3, 0x53, 0x32, 0xC0, 0x9F, 0x86, 0xC4, + 0x50, 0x86, 0xC4, 0xE8, 0xE9, 0x2A, 0x74, 0x3, 0xE9, 0xE2, 0xF2, + 0x53, 0xB9, 0x2E, 0x0, 0xB2, 0x2, 0xB6, 0xFD, 0x3, 0xD9, 0x88, + 0x37, 0xB0, 0x0, 0x5B, 0xE9, 0xE6, 0x29, 0xE8, 0x33, 0x2E, 0xA, + 0xC0, 0xC3, 0x3C, 0x85, 0x74, 0x3, 0xE9, 0xA2, 0x33, 0xE8, 0x11, + 0x19, 0x85, 0x3C, 0x23, 0x75, 0x3, 0xE9, 0x28, 0x30, 0xE8, 0x30, + 0x1D, 0xE8, 0x73, 0x0, 0xE8, 0x7A, 0x22, 0xE8, 0x44, 0x4F, 0x52, + 0x53, 0xE8, 0xA7, 0x1C, 0x5A, 0x59, 0x73, 0x3, 0xE9, 0x45, 0x19, + 0x51, 0x52, 0xB5, 0x0, 0xE8, 0x45, 0x11, 0x5B, 0xB0, 0x3, 0xE9, + 0x93, 0xFC, 0x3F, 0x52, 0x65, 0x64, 0x6F, 0x20, 0x66, 0x72, 0x6F, + 0x6D, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0xD, 0x0, 0x43, 0x8A, + 0x7, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x92, 0xF2, 0x3C, 0x22, 0x75, + 0xF2, 0xE9, 0x9B, 0x0, 0x5B, 0x5B, 0xEB, 0xC, 0xCD, 0x9C, 0xA0, + 0x3A, 0x3, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0x73, 0xF2, 0x59, 0xBB, + 0x10, 0x15, 0xE8, 0xB, 0x66, 0x8B, 0x1E, 0x43, 0x3, 0xC3, 0xE8, + 0x94, 0x2F, 0x53, 0xBB, 0xF6, 0x1, 0xE9, 0xE0, 0x0, 0x3C, 0x23, + 0x74, 0xF2, 0xE8, 0xBE, 0x1C, 0xB9, 0x8C, 0x15, 0x51, 0x3C, 0x22, + 0xB0, 0x0, 0xB0, 0xFF, 0xA2, 0x5F, 0x4, 0x75, 0xDF, 0xE8, 0xDB, + 0x10, 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0xA, 0x32, 0xC0, 0xA2, 0x5F, + 0x4, 0xE8, 0x9D, 0xF9, 0xEB, 0x4, 0xE8, 0x6F, 0x18, 0x3B, 0x53, + 0xE8, 0x30, 0x11, 0x5B, 0xC3, 0x53, 0xA0, 0x5F, 0x4, 0xA, 0xC0, + 0x74, 0xA, 0xB0, 0x3F, 0xE8, 0xC, 0x16, 0xB0, 0x20, 0xE8, 0x7, + 0x16, 0xE8, 0x2, 0x1C, 0x59, 0x73, 0x3, 0xE9, 0xA1, 0x18, 0x51, + 0x32, 0xC0, 0xA2, 0x3A, 0x3, 0xC6, 0x7, 0x2C, 0x87, 0xDA, 0x5B, + 0x53, 0x52, 0x52, 0x4B, 0xB0, 0x80, 0xA2, 0x39, 0x3, 0xE8, 0x5E, + 0xF9, 0xE8, 0xA5, 0x22, 0x8A, 0x7, 0x4B, 0x3C, 0x28, 0x75, 0x20, + 0x43, 0xB5, 0x0, 0xFE, 0xC5, 0xE8, 0x4C, 0xF9, 0x75, 0x3, 0xE9, + 0xE8, 0xF1, 0x3C, 0x22, 0x75, 0x3, 0xE9, 0x45, 0xFF, 0x3C, 0x28, + 0x74, 0xEB, 0x3C, 0x29, 0x75, 0xE9, 0xFE, 0xCD, 0x75, 0xE5, 0xE8, + 0x31, 0xF9, 0x74, 0x7, 0x3C, 0x2C, 0x74, 0x3, 0xE9, 0xC9, 0xF1, + 0x5E, 0x87, 0xDE, 0x56, 0x8A, 0x7, 0x3C, 0x2C, 0x74, 0x3, 0xE9, + 0x31, 0xFF, 0xB0, 0x1, 0xA2, 0xA9, 0x4, 0xE8, 0x62, 0x0, 0xA0, + 0xA9, 0x4, 0xFE, 0xC8, 0x74, 0x3, 0xE9, 0x1F, 0xFF, 0x53, 0xE8, + 0xD, 0x5, 0x75, 0x3, 0xE8, 0x8C, 0x12, 0x5B, 0x4B, 0xE8, 0xFB, + 0xF8, 0x5E, 0x87, 0xDE, 0x56, 0x8A, 0x7, 0x3C, 0x2C, 0x74, 0x8B, + 0x5B, 0x4B, 0xE8, 0xEC, 0xF8, 0xA, 0xC0, 0x5B, 0x74, 0x3, 0xE9, + 0xA, 0xFF, 0xC6, 0x7, 0x2C, 0xEB, 0x6, 0x53, 0x8B, 0x1E, 0x5E, + 0x3, 0xD, 0x32, 0xC0, 0xA2, 0x3A, 0x3, 0x5E, 0x87, 0xDE, 0x56, + 0xEB, 0x4, 0xE8, 0xA2, 0x17, 0x2C, 0xE8, 0x18, 0x21, 0x5E, 0x87, + 0xDE, 0x56, 0x52, 0x8A, 0x7, 0x3C, 0x2C, 0x74, 0xA, 0xA0, 0x3A, + 0x3, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0x8B, 0x0, 0xD, 0x32, 0xC0, + 0xA2, 0x52, 0x4, 0xE8, 0x62, 0x19, 0x74, 0x3, 0xE9, 0x8B, 0x2E, + 0xE8, 0xA9, 0x4, 0x50, 0x75, 0x38, 0xE8, 0x9B, 0xF8, 0x8A, 0xF0, + 0x8A, 0xE8, 0x3C, 0x22, 0x74, 0xE, 0xA0, 0x3A, 0x3, 0xA, 0xC0, + 0x8A, 0xF0, 0x74, 0x2, 0xB6, 0x3A, 0xB5, 0x2C, 0x4B, 0xE8, 0xB6, + 0xF, 0x58, 0x4, 0x3, 0x8A, 0xC8, 0xA0, 0x52, 0x4, 0xA, 0xC0, + 0x75, 0x1, 0xC3, 0x8A, 0xC1, 0x87, 0xDA, 0xBB, 0xCA, 0x16, 0x5E, + 0x87, 0xDE, 0x56, 0x52, 0xE9, 0xF0, 0xFA, 0xE8, 0x63, 0xF8, 0x58, + 0x50, 0x3C, 0x5, 0xB9, 0x9B, 0x16, 0x51, 0x73, 0x3, 0xE9, 0xF9, + 0x52, 0xE9, 0xFD, 0x52, 0x4B, 0xE8, 0x4F, 0xF8, 0x74, 0x7, 0x3C, + 0x2C, 0x74, 0x3, 0xE9, 0x60, 0xFE, 0x5E, 0x87, 0xDE, 0x56, 0x4B, + 0xE8, 0x3E, 0xF8, 0x74, 0x3, 0xE9, 0x6B, 0xFF, 0x5A, 0xA0, 0x3A, + 0x3, 0xA, 0xC0, 0x87, 0xDA, 0x74, 0x3, 0xE9, 0x35, 0x17, 0x52, + 0x5B, 0xE9, 0xA2, 0xFD, 0xE8, 0x62, 0xFA, 0xA, 0xC0, 0x75, 0x15, + 0x43, 0x8A, 0x7, 0x43, 0xA, 0x7, 0xB2, 0x4, 0x75, 0x3, 0xE9, + 0xCE, 0xF0, 0x43, 0x8B, 0x17, 0x43, 0x89, 0x16, 0x37, 0x3, 0xE8, + 0x8, 0xF8, 0x3C, 0x84, 0x75, 0xDD, 0xE9, 0x4F, 0xFF, 0xE8, 0xD5, + 0x16, 0xE7, 0xE9, 0x4, 0x0, 0xE8, 0xCE, 0x16, 0x28, 0x4B, 0xB6, + 0x0, 0x52, 0xB1, 0x1, 0xE8, 0xA5, 0x15, 0xCD, 0x9D, 0xE8, 0xB2, + 0x1, 0x32, 0xC0, 0xA2, 0xA8, 0x4, 0x89, 0x1E, 0x52, 0x3, 0x8B, + 0x1E, 0x52, 0x3, 0x59, 0x8A, 0x7, 0x89, 0x1E, 0x31, 0x3, 0x3C, + 0xE6, 0x73, 0x1, 0xC3, 0x3C, 0xE9, 0x72, 0x75, 0x2C, 0xE9, 0x8A, + 0xD0, 0x75, 0xC, 0xA0, 0xFB, 0x2, 0x3C, 0x3, 0x8A, 0xC2, 0x75, + 0x3, 0xE9, 0xD6, 0x10, 0x3C, 0xC, 0x73, 0xE5, 0xBB, 0x80, 0x3, + 0xB6, 0x0, 0x3, 0xDA, 0x8A, 0xC5, 0x2E, 0x8A, 0x37, 0x3A, 0xC6, + 0x73, 0xD5, 0x51, 0xB9, 0x3E, 0x17, 0x51, 0x8A, 0xC6, 0xCD, 0x9E, + 0x3C, 0x7F, 0x74, 0x64, 0x3C, 0x51, 0x72, 0x6D, 0x24, 0xFE, 0x3C, + 0x7A, 0x74, 0x67, 0xA0, 0xFB, 0x2, 0x2C, 0x3, 0x75, 0x3, 0xE9, + 0x3D, 0xF0, 0xA, 0xC0, 0xFF, 0x36, 0xA3, 0x4, 0x79, 0x3, 0xE9, + 0x11, 0x0, 0xFF, 0x36, 0xA5, 0x4, 0x7A, 0x3, 0xE9, 0x8, 0x0, + 0xFF, 0x36, 0x9F, 0x4, 0xFF, 0x36, 0xA1, 0x4, 0x4, 0x3, 0x8A, + 0xCA, 0x8A, 0xE8, 0x51, 0xB9, 0x23, 0x18, 0x51, 0x8B, 0x1E, 0x31, + 0x3, 0xE9, 0x63, 0xFF, 0xB6, 0x0, 0x2C, 0xE6, 0x72, 0x34, 0x3C, + 0x3, 0x73, 0x30, 0x3C, 0x1, 0xD0, 0xD0, 0x32, 0xC6, 0x3A, 0xC6, + 0x8A, 0xF0, 0x73, 0x3, 0xE9, 0xDE, 0xEF, 0x89, 0x1E, 0x31, 0x3, + 0xE8, 0x36, 0xF7, 0xEB, 0xE0, 0xE8, 0x65, 0x53, 0xE8, 0x37, 0x4C, + 0xB9, 0x29, 0x65, 0xB6, 0x7F, 0xEB, 0xC9, 0x52, 0xE8, 0xB3, 0x53, + 0x5A, 0x53, 0xB9, 0x31, 0x1B, 0xEB, 0xBE, 0x8A, 0xC5, 0x3C, 0x64, + 0x72, 0x1, 0xC3, 0x51, 0x52, 0xBA, 0x4, 0x64, 0xBB, 0x3, 0x1B, + 0x53, 0xE8, 0x11, 0x3, 0x74, 0x3, 0xE9, 0x76, 0xFF, 0x8B, 0x1E, + 0xA3, 0x4, 0x53, 0xB9, 0xC8, 0x25, 0xEB, 0x9C, 0x59, 0x8A, 0xC1, + 0xA2, 0xFC, 0x2, 0xA0, 0xFB, 0x2, 0x3A, 0xC5, 0x75, 0xD, 0x3C, + 0x2, 0x74, 0x28, 0x3C, 0x4, 0x75, 0x3, 0xE9, 0x7F, 0x0, 0x73, + 0x39, 0x8A, 0xF0, 0x8A, 0xC5, 0x3C, 0x8, 0x74, 0x2E, 0x8A, 0xC6, + 0x3C, 0x8, 0x74, 0x57, 0x8A, 0xC5, 0x3C, 0x4, 0x74, 0x66, 0x8A, + 0xC6, 0x3C, 0x3, 0x75, 0x3, 0xE9, 0x7C, 0xEF, 0x73, 0x65, 0xBB, + 0xAA, 0x3, 0xB5, 0x0, 0x3, 0xD9, 0x3, 0xD9, 0x2E, 0x8A, 0xF, + 0x43, 0x2E, 0x8A, 0x2F, 0x5A, 0x8B, 0x1E, 0xA3, 0x4, 0x51, 0xC3, + 0xE8, 0xC, 0x53, 0xE8, 0x25, 0x4C, 0x5B, 0x89, 0x1E, 0xA1, 0x4, + 0x5B, 0x89, 0x1E, 0x9F, 0x4, 0x59, 0x5A, 0xE8, 0x5A, 0x4B, 0xE8, + 0xF7, 0x52, 0xBB, 0x96, 0x3, 0xA0, 0xFC, 0x2, 0xD0, 0xC0, 0x2, + 0xC3, 0x8A, 0xD8, 0x12, 0xC7, 0x2A, 0xC3, 0x8A, 0xF8, 0x2E, 0x8B, + 0x1F, 0xFF, 0xE3, 0x8A, 0xC5, 0x50, 0xE8, 0xF6, 0x4B, 0x58, 0xA2, + 0xFB, 0x2, 0x3C, 0x4, 0x74, 0xD3, 0x5B, 0x89, 0x1E, 0xA3, 0x4, + 0xEB, 0xD1, 0xE8, 0x97, 0x52, 0x59, 0x5A, 0xBB, 0xA0, 0x3, 0xEB, + 0xCD, 0x5B, 0xE8, 0x61, 0x4B, 0xE8, 0x65, 0x4A, 0xE8, 0x28, 0x4B, + 0x5B, 0x89, 0x1E, 0xA5, 0x4, 0x5B, 0x89, 0x1E, 0xA3, 0x4, 0xEB, + 0xE5, 0x53, 0x87, 0xDA, 0xE8, 0x50, 0x4A, 0x5B, 0xE8, 0x45, 0x4B, + 0xE8, 0x49, 0x4A, 0xE9, 0x3B, 0x4C, 0xE8, 0x33, 0xF6, 0x75, 0x3, + 0xE9, 0xE4, 0xEE, 0x73, 0x3, 0xE9, 0xCC, 0x50, 0xE8, 0x4E, 0x16, + 0x72, 0x3, 0xE9, 0xDB, 0x0, 0x3C, 0x20, 0x73, 0x3, 0xE9, 0x7F, + 0xF6, 0xCD, 0x9F, 0xFE, 0xC0, 0x75, 0x3, 0xE9, 0x6A, 0x1, 0xFE, + 0xC8, 0x3C, 0xE9, 0x74, 0xD5, 0x3C, 0xEA, 0x75, 0x3, 0xE9, 0xAF, + 0x0, 0x3C, 0x22, 0x75, 0x3, 0xE9, 0x2D, 0xD, 0x3C, 0xD3, 0x75, + 0x3, 0xE9, 0xEC, 0x1, 0x3C, 0x26, 0x75, 0x3, 0xE9, 0xD1, 0x0, + 0x3C, 0xD5, 0x75, 0xC, 0xE8, 0xE8, 0xF5, 0xA0, 0x28, 0x0, 0x53, + 0xE8, 0x43, 0x2, 0x5B, 0xC3, 0x3C, 0xD4, 0x75, 0xD, 0xE8, 0xD8, + 0xF5, 0x53, 0x8B, 0x1E, 0x47, 0x3, 0xE8, 0xF7, 0x4A, 0x5B, 0xC3, + 0x3C, 0xDA, 0x75, 0x2E, 0xE8, 0xC7, 0xF5, 0xE8, 0x9B, 0x14, 0x28, + 0x3C, 0x23, 0x75, 0xD, 0xE8, 0xB8, 0x5, 0x53, 0xE8, 0x40, 0x26, + 0x87, 0xDA, 0x5B, 0xE9, 0x3, 0x0, 0xE8, 0xF9, 0x1E, 0xE8, 0x83, + 0x14, 0x29, 0x53, 0x87, 0xDA, 0xB, 0xDB, 0x75, 0x3, 0xE9, 0xDD, + 0xF6, 0xE8, 0x8D, 0x4B, 0x5B, 0xC3, 0x3C, 0xD0, 0x75, 0x3, 0xE9, + 0x0, 0x2, 0x3C, 0xD8, 0x75, 0x3, 0xE9, 0x8B, 0x10, 0x3C, 0xC8, + 0x75, 0x3, 0xE9, 0xD0, 0x3B, 0x3C, 0xDC, 0x75, 0x3, 0xE9, 0x4C, + 0x2E, 0x3C, 0xDE, 0x75, 0x3, 0xE9, 0xF9, 0x12, 0x3C, 0xD6, 0x75, + 0x3, 0xE9, 0x70, 0xF, 0x3C, 0x85, 0x75, 0x3, 0xE9, 0x38, 0x2A, + 0x3C, 0xDB, 0x75, 0x3, 0xE9, 0xA4, 0x3B, 0x3C, 0xD1, 0x75, 0x3, + 0xE9, 0x7E, 0x2, 0xE8, 0x60, 0xFD, 0xE8, 0x2E, 0x14, 0x29, 0xC3, + 0xB6, 0x7D, 0xE8, 0x5D, 0xFD, 0x8B, 0x1E, 0x52, 0x3, 0x53, 0xE8, + 0xD6, 0x63, 0x5B, 0xC3, 0xE8, 0x94, 0x1D, 0x53, 0x87, 0xDA, 0x89, + 0x1E, 0xA3, 0x4, 0xE8, 0x41, 0x1, 0x74, 0x3, 0xE8, 0xAF, 0x4A, + 0x5B, 0xC3, 0x8A, 0x7, 0x3C, 0x61, 0x72, 0xF9, 0x3C, 0x7B, 0x73, + 0xF5, 0x24, 0x5F, 0xC3, 0x3C, 0x26, 0x74, 0x3, 0xE9, 0x6C, 0xF6, + 0xBA, 0x0, 0x0, 0xE8, 0x18, 0xF5, 0xE8, 0xE5, 0xFF, 0x3C, 0x4F, + 0x74, 0x39, 0x3C, 0x48, 0x75, 0x34, 0xB5, 0x5, 0x43, 0x8A, 0x7, + 0xE8, 0xD5, 0xFF, 0xE8, 0x2A, 0x15, 0x87, 0xDA, 0x73, 0xA, 0x3C, + 0x3A, 0x73, 0x4D, 0x2C, 0x30, 0x72, 0x49, 0xEB, 0x6, 0x3C, 0x47, + 0x73, 0x43, 0x2C, 0x37, 0x3, 0xDB, 0x3, 0xDB, 0x3, 0xDB, 0x3, + 0xDB, 0xA, 0xC3, 0x8A, 0xD8, 0x87, 0xDA, 0xFE, 0xCD, 0x75, 0xD1, + 0xE9, 0x8C, 0xED, 0x4B, 0xE8, 0xD5, 0xF4, 0x87, 0xDA, 0x73, 0x24, + 0x3C, 0x38, 0x72, 0x3, 0xE9, 0x6B, 0xED, 0xB9, 0xD0, 0x7, 0x51, + 0x3, 0xDB, 0x72, 0x9C, 0x3, 0xDB, 0x72, 0x98, 0x3, 0xDB, 0x72, + 0x94, 0x59, 0xB5, 0x0, 0x2C, 0x30, 0x8A, 0xC8, 0x3, 0xD9, 0x87, + 0xDA, 0xEB, 0xD5, 0xE8, 0x99, 0x4A, 0x87, 0xDA, 0xC3, 0x43, 0x8A, + 0x7, 0x2C, 0x81, 0x3C, 0x7, 0x75, 0xE, 0x53, 0xE8, 0x9A, 0xF4, + 0x3C, 0x28, 0x5B, 0x74, 0x3, 0xE9, 0xE0, 0x49, 0xB0, 0x7, 0xB5, + 0x0, 0xD0, 0xC0, 0x8A, 0xC8, 0x51, 0xE8, 0x86, 0xF4, 0x8A, 0xC1, + 0x3C, 0x5, 0x73, 0x22, 0xE8, 0x83, 0xFC, 0xE8, 0x51, 0x13, 0x2C, + 0xE8, 0x94, 0x49, 0x87, 0xDA, 0x8B, 0x1E, 0xA3, 0x4, 0x5E, 0x87, + 0xDE, 0x56, 0x53, 0x87, 0xDA, 0xE8, 0x65, 0x4, 0x87, 0xDA, 0x5E, + 0x87, 0xDE, 0x56, 0xEB, 0x21, 0xE8, 0xFE, 0xFE, 0x5E, 0x87, 0xDE, + 0x56, 0x8A, 0xC3, 0x3C, 0xC, 0x72, 0xB, 0x3C, 0x1B, 0xCD, 0xA1, + 0x53, 0x73, 0x3, 0xE8, 0x7B, 0x50, 0x5B, 0xBA, 0xD5, 0x19, 0x52, + 0xB0, 0x1, 0xA2, 0xA8, 0x4, 0xB9, 0xB9, 0x0, 0xCD, 0xA0, 0x3, + 0xD9, 0x2E, 0xFF, 0x27, 0xFE, 0xCE, 0x3C, 0xEA, 0x74, 0x85, 0x3C, + 0x2D, 0x74, 0x81, 0xFE, 0xC6, 0x3C, 0x2B, 0x75, 0x1, 0xC3, 0x3C, + 0xE9, 0x74, 0xFB, 0x9F, 0x4B, 0x9E, 0xC3, 0xFE, 0xC0, 0x12, 0xC0, + 0x59, 0x22, 0xC5, 0x4, 0xFF, 0x1A, 0xC0, 0xE8, 0xF8, 0x49, 0xEB, + 0xF, 0xB6, 0x5A, 0xE8, 0x12, 0xFC, 0xE8, 0x92, 0x50, 0xF7, 0xD3, + 0x89, 0x1E, 0xA3, 0x4, 0x59, 0xE9, 0x19, 0xFC, 0xA0, 0xFB, 0x2, + 0x3C, 0x8, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xC8, 0xC3, 0x8A, 0xC5, + 0x50, 0xE8, 0x76, 0x50, 0x58, 0x5A, 0x3C, 0x7A, 0x75, 0x3, 0xE9, + 0x89, 0x4A, 0x3C, 0x7B, 0x75, 0x3, 0xE9, 0x66, 0x48, 0xB9, 0xC, + 0x65, 0x51, 0x3C, 0x46, 0x75, 0x3, 0xB, 0xDA, 0xC3, 0x3C, 0x50, + 0x75, 0x3, 0x23, 0xDA, 0xC3, 0x3C, 0x3C, 0x75, 0x3, 0x33, 0xDA, + 0xC3, 0x3C, 0x32, 0x75, 0x5, 0x33, 0xDA, 0xF7, 0xD3, 0xC3, 0xF7, + 0xD3, 0x23, 0xDA, 0xF7, 0xD3, 0xC3, 0x2B, 0xDA, 0xE9, 0xCF, 0x48, + 0xA0, 0x63, 0x0, 0xEB, 0x3, 0xE8, 0xAF, 0x33, 0xFE, 0xC0, 0x8A, + 0xD8, 0x32, 0xC0, 0x8A, 0xF8, 0xE9, 0x84, 0x49, 0xE8, 0x2E, 0x0, + 0x52, 0xE8, 0x31, 0xFE, 0x5E, 0x87, 0xDE, 0x56, 0x8B, 0x17, 0x80, + 0xFA, 0xFF, 0x75, 0x3, 0xE9, 0xBC, 0xF4, 0xE, 0xBB, 0x7, 0x65, + 0x53, 0xFF, 0x36, 0x50, 0x3, 0x52, 0xA0, 0xFB, 0x2, 0x50, 0x3C, + 0x3, 0x75, 0x3, 0xE8, 0xF7, 0xC, 0x58, 0x87, 0xDA, 0xBB, 0xA3, + 0x4, 0xCB, 0xE8, 0x61, 0xF3, 0xB9, 0x0, 0x0, 0x3C, 0x1B, 0x73, + 0x10, 0x3C, 0x11, 0x72, 0xC, 0xE8, 0x53, 0xF3, 0xA0, 0x2, 0x3, + 0xA, 0xC0, 0xD0, 0xD0, 0x8A, 0xC8, 0x87, 0xDA, 0xBB, 0x12, 0x0, + 0x3, 0xD9, 0x87, 0xDA, 0xC3, 0xE8, 0xD9, 0xFF, 0x52, 0xE8, 0x10, + 0x12, 0xE7, 0xE8, 0xC2, 0x6, 0x5E, 0x87, 0xDE, 0x56, 0x89, 0x17, + 0x5B, 0xC3, 0x3C, 0xD0, 0x74, 0xE9, 0x3C, 0xD1, 0x74, 0x1C, 0xE8, + 0xF9, 0x11, 0x53, 0xE8, 0xF5, 0x11, 0x45, 0xE8, 0xF1, 0x11, 0x47, + 0x8C, 0xDA, 0x74, 0x7, 0xE8, 0xE9, 0x11, 0xE7, 0xE8, 0x9B, 0x6, + 0x89, 0x16, 0x50, 0x3, 0xC3, 0xE8, 0xF3, 0x1, 0xE8, 0xE0, 0x1, + 0x87, 0xDA, 0x89, 0x17, 0x87, 0xDA, 0x8A, 0x7, 0x3C, 0x28, 0x74, + 0x3, 0xE9, 0x32, 0xF5, 0xE8, 0xF1, 0xF2, 0xE8, 0x3F, 0x1B, 0x8A, + 0x7, 0x3C, 0x29, 0x75, 0x3, 0xE9, 0x23, 0xF5, 0xE8, 0xB9, 0x11, + 0x2C, 0xEB, 0xEE, 0xE8, 0xC9, 0x1, 0xA0, 0xFB, 0x2, 0xA, 0xC0, + 0x50, 0x89, 0x1E, 0x52, 0x3, 0x87, 0xDA, 0x8B, 0x1F, 0xB, 0xDB, + 0x75, 0x3, 0xE9, 0x74, 0xEB, 0x8A, 0x7, 0x3C, 0x28, 0x74, 0x3, + 0xE9, 0xCE, 0x0, 0xE8, 0xBB, 0xF2, 0x89, 0x1E, 0x31, 0x3, 0x87, + 0xDA, 0x8B, 0x1E, 0x52, 0x3, 0xE8, 0x85, 0x11, 0x28, 0x32, 0xC0, + 0x50, 0x53, 0x87, 0xDA, 0xB0, 0x80, 0xA2, 0x39, 0x3, 0xE8, 0xF0, + 0x1A, 0x87, 0xDA, 0x5E, 0x87, 0xDE, 0x56, 0xA0, 0xFB, 0x2, 0x50, + 0x52, 0xE8, 0x9B, 0xFA, 0x89, 0x1E, 0x52, 0x3, 0x5B, 0x89, 0x1E, + 0x31, 0x3, 0x58, 0xE8, 0x41, 0x1, 0xB1, 0x4, 0xE8, 0x37, 0x10, + 0xBB, 0xF8, 0xFF, 0x3, 0xDC, 0x8B, 0xE3, 0xE8, 0xF9, 0x47, 0xA0, + 0xFB, 0x2, 0x50, 0x8B, 0x1E, 0x52, 0x3, 0x8A, 0x7, 0x3C, 0x29, + 0x74, 0x13, 0xE8, 0x3B, 0x11, 0x2C, 0x53, 0x8B, 0x1E, 0x31, 0x3, + 0xE8, 0x32, 0x11, 0x2C, 0xEB, 0xB1, 0x58, 0xA2, 0xE4, 0x3, 0x58, + 0xA, 0xC0, 0x74, 0x4E, 0xA2, 0xFB, 0x2, 0xBB, 0x0, 0x0, 0x3, + 0xDC, 0xE8, 0xBF, 0x47, 0xBB, 0x8, 0x0, 0x3, 0xDC, 0x8B, 0xE3, + 0x5A, 0xB3, 0x3, 0xFE, 0xC3, 0x4A, 0x8B, 0xF2, 0xAC, 0xA, 0xC0, + 0x78, 0xF6, 0x4A, 0x4A, 0x4A, 0xA0, 0xFB, 0x2, 0x2, 0xC3, 0x8A, + 0xE8, 0xA0, 0xE4, 0x3, 0x8A, 0xC8, 0x2, 0xC5, 0x3C, 0x64, 0x72, + 0x3, 0xE9, 0x54, 0xF3, 0x50, 0x8A, 0xC3, 0xB5, 0x0, 0xBB, 0xE6, + 0x3, 0x3, 0xD9, 0x8A, 0xC8, 0xE8, 0xDF, 0x0, 0xB9, 0xC5, 0x1C, + 0x51, 0x51, 0xE9, 0x99, 0xF4, 0x8B, 0x1E, 0x52, 0x3, 0xE8, 0xFA, + 0xF1, 0x53, 0x8B, 0x1E, 0x31, 0x3, 0xE8, 0xC9, 0x10, 0x29, 0xB0, + 0x52, 0x89, 0x1E, 0x31, 0x3, 0xA0, 0x7C, 0x3, 0x4, 0x4, 0x50, + 0xD0, 0xC8, 0x8A, 0xC8, 0xE8, 0x96, 0xF, 0x58, 0x8A, 0xC8, 0xF6, + 0xD0, 0xFE, 0xC0, 0x8A, 0xD8, 0xB7, 0xFF, 0x3, 0xDC, 0x8B, 0xE3, + 0x53, 0xBA, 0x7A, 0x3, 0xE8, 0x9E, 0x0, 0x5B, 0x89, 0x1E, 0x7A, + 0x3, 0x8B, 0x1E, 0xE4, 0x3, 0x89, 0x1E, 0x7C, 0x3, 0x8B, 0xCB, + 0xBB, 0x7E, 0x3, 0xBA, 0xE6, 0x3, 0xE8, 0x86, 0x0, 0x8A, 0xF8, + 0x8A, 0xD8, 0x89, 0x1E, 0xE4, 0x3, 0x8B, 0x1E, 0x50, 0x4, 0x43, + 0x89, 0x1E, 0x50, 0x4, 0x8A, 0xC7, 0xA, 0xC3, 0xA2, 0x4D, 0x4, + 0x8B, 0x1E, 0x31, 0x3, 0xE8, 0x90, 0xF9, 0x4B, 0xE8, 0x8D, 0xF1, + 0x74, 0x3, 0xE9, 0x29, 0xEA, 0xE8, 0x8D, 0xFD, 0x75, 0x11, 0xBA, + 0x2C, 0x3, 0x8B, 0x1E, 0xA3, 0x4, 0x3B, 0xDA, 0x72, 0x6, 0xE8, + 0x7C, 0x8, 0xE8, 0xE6, 0x8, 0x8B, 0x1E, 0x7A, 0x3, 0x8A, 0xF7, + 0x8A, 0xD3, 0x43, 0x43, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x41, 0x41, + 0x41, 0x41, 0xBB, 0x7A, 0x3, 0xE8, 0x2F, 0x0, 0x87, 0xDA, 0x8B, + 0xE3, 0x8B, 0x1E, 0x50, 0x4, 0x4B, 0x89, 0x1E, 0x50, 0x4, 0x8A, + 0xC7, 0xA, 0xC3, 0xA2, 0x4D, 0x4, 0x5B, 0x58, 0x53, 0x24, 0x7, + 0xBB, 0x8C, 0x3, 0x8A, 0xC8, 0xB5, 0x0, 0x3, 0xD9, 0xE8, 0xFC, + 0xFC, 0x5B, 0xC3, 0x8B, 0xF2, 0xAC, 0x88, 0x7, 0x43, 0x42, 0x49, + 0x8A, 0xC5, 0xA, 0xC1, 0x75, 0xF2, 0xC3, 0x53, 0x8B, 0x1E, 0x2E, + 0x0, 0x43, 0xB, 0xDB, 0x5B, 0x75, 0xF4, 0xB2, 0xC, 0xE9, 0xCE, + 0xE9, 0xE8, 0xE7, 0xF, 0xD1, 0xB0, 0x80, 0xA2, 0x39, 0x3, 0xA, + 0x7, 0x8A, 0xC8, 0xE9, 0x5B, 0x19, 0x3C, 0x7E, 0x74, 0x3, 0xE9, + 0x9D, 0xE9, 0x43, 0x8A, 0x7, 0x43, 0x3C, 0x83, 0x75, 0x3, 0xE9, + 0xA4, 0xC, 0x3C, 0xA0, 0x75, 0x3, 0xE9, 0xAF, 0x37, 0x3C, 0xA2, + 0x75, 0x3, 0xE9, 0xC0, 0x38, 0xE9, 0x81, 0xE9, 0xE8, 0x75, 0x4, + 0x87, 0xDA, 0xEC, 0xE9, 0x39, 0xFD, 0xE8, 0x61, 0x4, 0x52, 0xE8, + 0xA7, 0xF, 0x2C, 0xE8, 0xCB, 0x0, 0x5A, 0xC3, 0xE8, 0xF0, 0xFF, + 0xEE, 0xC3, 0xE8, 0xEB, 0xFF, 0x52, 0x50, 0xB2, 0x0, 0x4B, 0xE8, + 0xBA, 0xF0, 0x74, 0x7, 0xE8, 0x8C, 0xF, 0x2C, 0xE8, 0xB0, 0x0, + 0x58, 0x8A, 0xF0, 0x5E, 0x87, 0xDE, 0x56, 0xA0, 0x5E, 0x0, 0xA, + 0xC0, 0x75, 0xB, 0x87, 0xDA, 0xEC, 0x87, 0xDA, 0x32, 0xC2, 0x22, + 0xC6, 0x74, 0xEE, 0x5B, 0xC3, 0xE9, 0x34, 0xE9, 0x3C, 0x23, 0x74, + 0x3C, 0xE8, 0x96, 0xF8, 0xE8, 0x91, 0xFC, 0x75, 0x58, 0xE8, 0x7D, + 0x20, 0x8A, 0xC6, 0xB6, 0x0, 0xF6, 0xD0, 0xA, 0xC0, 0x79, 0x3, + 0xE9, 0xB3, 0xF1, 0x8A, 0xD0, 0x52, 0xE8, 0x48, 0xF, 0x2C, 0xE8, + 0x6C, 0x0, 0x5A, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x53, 0x52, + 0x8A, 0xC2, 0x2, 0xC0, 0x8A, 0xD0, 0xB0, 0x14, 0x9F, 0x86, 0xC4, + 0x50, 0x86, 0xC4, 0xE9, 0x8, 0x20, 0xE8, 0x50, 0xF0, 0xE8, 0x4C, + 0x0, 0x50, 0xE8, 0x20, 0xF, 0x2C, 0xE8, 0x44, 0x0, 0x58, 0x53, + 0x52, 0xE8, 0xC7, 0x20, 0xE8, 0x32, 0x3A, 0xA, 0xC0, 0x79, 0x3, + 0xE9, 0x71, 0xF1, 0x43, 0x5A, 0x88, 0x17, 0x5B, 0xC3, 0xE8, 0x2E, + 0x0, 0xE8, 0xB8, 0x33, 0xA2, 0x29, 0x0, 0x2C, 0xE, 0x73, 0xFC, + 0x4, 0x1C, 0xF6, 0xD0, 0xFE, 0xC0, 0x2, 0xC2, 0xA2, 0x2A, 0x0, + 0xC3, 0xE8, 0x13, 0xF0, 0xE8, 0x1A, 0xF8, 0x53, 0xE8, 0x9C, 0x4C, + 0x87, 0xDA, 0x5B, 0x8A, 0xC6, 0xA, 0xC0, 0xC3, 0xE8, 0x1, 0xF0, + 0xE8, 0x8, 0xF8, 0xE8, 0xEB, 0xFF, 0x74, 0x3, 0xE9, 0x32, 0xF1, + 0x4B, 0xE8, 0xF2, 0xEF, 0x8A, 0xC2, 0xC3, 0xE8, 0x7F, 0xF5, 0x4B, + 0xE8, 0xE8, 0xEF, 0xCD, 0xA2, 0x59, 0xE8, 0xF2, 0xEA, 0x51, 0xE8, + 0x19, 0x28, 0x8B, 0x1E, 0x3B, 0x3, 0x4B, 0xE8, 0xD6, 0xEF, 0x74, + 0xE, 0xE8, 0xA8, 0xE, 0x2C, 0xE8, 0xC3, 0x1F, 0xB2, 0x2, 0x32, + 0xC0, 0xE8, 0x96, 0x21, 0xBB, 0xFF, 0xFF, 0x89, 0x1E, 0x2E, 0x0, + 0xE8, 0x75, 0x10, 0x75, 0x5, 0xB0, 0x1, 0xA2, 0x6F, 0x0, 0x5B, + 0x5A, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x43, 0x8A, 0xC5, 0xA, 0xC1, + 0x75, 0x3, 0xE9, 0x3D, 0xE9, 0xE8, 0x90, 0xE0, 0x75, 0x3, 0xE8, + 0x7, 0xD, 0x51, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x43, 0x51, 0x5E, + 0x87, 0xDE, 0x56, 0x87, 0xDA, 0x3B, 0xDA, 0x59, 0x73, 0x3, 0xE9, + 0x1E, 0xE9, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0x51, 0x87, 0xDA, 0x89, + 0x1E, 0x49, 0x3, 0xE8, 0xAA, 0x45, 0x5B, 0x8A, 0x7, 0x3C, 0x9, + 0x74, 0x5, 0xB0, 0x20, 0xE8, 0xF3, 0xB, 0xE8, 0x18, 0x0, 0xBB, + 0xF7, 0x1, 0xE8, 0x5, 0x0, 0xE8, 0xB3, 0xC, 0xEB, 0x97, 0x8A, + 0x7, 0xA, 0xC0, 0x75, 0x1, 0xC3, 0xE8, 0x69, 0x17, 0x43, 0xEB, + 0xF3, 0xB9, 0xF7, 0x1, 0xB6, 0xFF, 0x32, 0xC0, 0xA2, 0xFC, 0x2, + 0x32, 0xC0, 0xA2, 0x5E, 0x4, 0xE8, 0x79, 0x27, 0xEB, 0x6, 0x41, + 0x43, 0xFE, 0xCE, 0x74, 0xDF, 0x8A, 0x7, 0xA, 0xC0, 0x8B, 0xF9, + 0xAA, 0x74, 0xD6, 0x3C, 0xB, 0x72, 0x28, 0x3C, 0x20, 0x8A, 0xD0, + 0x72, 0x38, 0x3C, 0x22, 0x75, 0xA, 0xA0, 0xFC, 0x2, 0x34, 0x1, + 0xA2, 0xFC, 0x2, 0xB0, 0x22, 0x3C, 0x3A, 0x75, 0x10, 0xA0, 0xFC, + 0x2, 0xD0, 0xD8, 0x72, 0x7, 0xD0, 0xD0, 0x24, 0xFD, 0xA2, 0xFC, + 0x2, 0xB0, 0x3A, 0xA, 0xC0, 0x79, 0x3, 0xE9, 0x3C, 0x0, 0x8A, + 0xD0, 0x3C, 0x2E, 0x74, 0x9, 0xE8, 0x57, 0x1, 0x73, 0x4, 0x32, + 0xC0, 0xEB, 0x18, 0xA0, 0x5E, 0x4, 0xA, 0xC0, 0x74, 0xF, 0xFE, + 0xC0, 0x75, 0xB, 0xB0, 0x20, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, + 0x75, 0x1, 0xC3, 0xB0, 0x1, 0xA2, 0x5E, 0x4, 0x8A, 0xC2, 0x3C, + 0xB, 0x72, 0x7, 0x3C, 0x20, 0x73, 0x3, 0xE9, 0x37, 0x1, 0x8B, + 0xF9, 0xAA, 0xEB, 0x82, 0xA0, 0xFC, 0x2, 0xD0, 0xD8, 0x72, 0x43, + 0xD0, 0xD8, 0xD0, 0xD8, 0x73, 0x52, 0x8A, 0x7, 0x3C, 0xD9, 0x53, + 0x51, 0xBB, 0xA5, 0x20, 0x53, 0x75, 0xCF, 0x49, 0x8B, 0xF1, 0xAC, + 0x3C, 0x4D, 0x75, 0xC7, 0x49, 0x8B, 0xF1, 0xAC, 0x3C, 0x45, 0x75, + 0xBF, 0x49, 0x8B, 0xF1, 0xAC, 0x3C, 0x52, 0x75, 0xB7, 0x49, 0x8B, + 0xF1, 0xAC, 0x3C, 0x3A, 0x75, 0xAF, 0x58, 0x58, 0x5B, 0xFE, 0xC6, + 0xFE, 0xC6, 0xFE, 0xC6, 0xFE, 0xC6, 0xEB, 0x2D, 0x59, 0x5B, 0x8A, + 0x7, 0xE9, 0x35, 0xFF, 0xA0, 0xFC, 0x2, 0xC, 0x2, 0xA2, 0xFC, + 0x2, 0x32, 0xC0, 0xC3, 0xA0, 0xFC, 0x2, 0xC, 0x4, 0xEB, 0xF3, + 0xD0, 0xD0, 0x72, 0xE7, 0x8A, 0x7, 0x3C, 0x84, 0x75, 0x3, 0xE8, + 0xE1, 0xFF, 0x3C, 0x8F, 0x75, 0x3, 0xE8, 0xE5, 0xFF, 0x8A, 0x7, + 0xFE, 0xC0, 0x8A, 0x7, 0x75, 0x5, 0x43, 0x8A, 0x7, 0x24, 0x7F, + 0x43, 0x3C, 0xA1, 0x75, 0x3, 0xE8, 0xF8, 0x43, 0x3C, 0xB1, 0x75, + 0xA, 0x8A, 0x7, 0x43, 0x3C, 0xE9, 0xB0, 0xB1, 0x74, 0x1, 0x4B, + 0x53, 0x51, 0x52, 0xCD, 0xA3, 0xBB, 0x36, 0x1, 0x8A, 0xE8, 0xB1, + 0x40, 0xFE, 0xC1, 0x43, 0x8A, 0xF7, 0x8A, 0xD3, 0x2E, 0x8A, 0x7, + 0xA, 0xC0, 0x74, 0xF2, 0x9F, 0x43, 0x9E, 0x79, 0xF4, 0x2E, 0x8A, + 0x7, 0x3A, 0xC5, 0x75, 0xE8, 0x87, 0xDA, 0x3C, 0xD0, 0x74, 0x2, + 0x3C, 0xD1, 0x8A, 0xC1, 0x5A, 0x59, 0x8A, 0xD0, 0x75, 0xC, 0xA0, + 0x5E, 0x4, 0xA, 0xC0, 0xB0, 0x0, 0xA2, 0x5E, 0x4, 0xEB, 0x15, + 0x3C, 0x5B, 0x75, 0x7, 0x32, 0xC0, 0xA2, 0x5E, 0x4, 0xEB, 0x1D, + 0xA0, 0x5E, 0x4, 0xA, 0xC0, 0xB0, 0xFF, 0xA2, 0x5E, 0x4, 0x74, + 0xD, 0xB0, 0x20, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, 0x75, 0x3, + 0xE9, 0xA4, 0x5, 0x8A, 0xC2, 0xEB, 0x6, 0x2E, 0x8A, 0x7, 0x43, + 0x8A, 0xD0, 0x24, 0x7F, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, 0x75, + 0x3, 0xE9, 0x8D, 0x5, 0xA, 0xC2, 0x79, 0xE9, 0x3C, 0xA8, 0x75, + 0x5, 0x32, 0xC0, 0xA2, 0x5E, 0x4, 0x5B, 0xE9, 0x64, 0xFE, 0xE8, + 0xBF, 0xD, 0x72, 0x1, 0xC3, 0x3C, 0x30, 0x72, 0xFB, 0x3C, 0x3A, + 0xF5, 0xC3, 0x4B, 0xE8, 0x88, 0xED, 0x52, 0x51, 0x50, 0xE8, 0x21, + 0xEE, 0x58, 0xB9, 0xB5, 0x21, 0x51, 0x3C, 0xB, 0x75, 0x3, 0xE9, + 0x60, 0x42, 0x3C, 0xC, 0x75, 0x3, 0xE9, 0x63, 0x42, 0x8B, 0x1E, + 0x2, 0x3, 0xE9, 0x13, 0x4F, 0x59, 0x5A, 0xA0, 0x0, 0x3, 0xB2, + 0x4F, 0x3C, 0xB, 0x74, 0x6, 0x3C, 0xC, 0xB2, 0x48, 0x75, 0x14, + 0xB0, 0x26, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, 0x74, 0xC0, 0x8A, + 0xC2, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, 0x74, 0xB6, 0xA0, 0x1, + 0x3, 0x3C, 0x4, 0xB2, 0x0, 0x72, 0x6, 0xB2, 0x21, 0x74, 0x2, + 0xB2, 0x23, 0x8A, 0x7, 0x3C, 0x20, 0x75, 0x3, 0xE8, 0x52, 0x43, + 0x8A, 0x7, 0x43, 0xA, 0xC0, 0x74, 0x2A, 0x8B, 0xF9, 0xAA, 0x41, + 0xFE, 0xCE, 0x74, 0x8F, 0xA0, 0x1, 0x3, 0x3C, 0x4, 0x72, 0xEA, + 0x9F, 0x49, 0x9E, 0x8B, 0xF1, 0xAC, 0x9F, 0x41, 0x9E, 0x75, 0x4, + 0x3C, 0x2E, 0x74, 0x8, 0x3C, 0x44, 0x74, 0x4, 0x3C, 0x45, 0x75, + 0xD3, 0xB2, 0x0, 0xEB, 0xCF, 0x8A, 0xC2, 0xA, 0xC0, 0x74, 0x9, + 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, 0x75, 0x1, 0xC3, 0x8B, 0x1E, + 0xFE, 0x2, 0xE9, 0xAE, 0xFD, 0xE8, 0xF1, 0xE7, 0x51, 0xE8, 0xF5, + 0x1, 0x59, 0x5A, 0x51, 0x51, 0xE8, 0x20, 0xE8, 0x73, 0xB, 0x8A, + 0xF7, 0x8A, 0xD3, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0x3B, 0xDA, 0x72, + 0x3, 0xE9, 0x0, 0xEE, 0xBB, 0x2D, 0x7, 0xE8, 0xF6, 0x58, 0x59, + 0xBB, 0xDD, 0x9, 0x5E, 0x87, 0xDE, 0x56, 0x87, 0xDA, 0x8B, 0x1E, + 0x58, 0x3, 0x8B, 0xF2, 0xAC, 0x8B, 0xF9, 0xAA, 0x41, 0x42, 0x3B, + 0xDA, 0x75, 0xF4, 0x8B, 0xD9, 0x89, 0x1E, 0x58, 0x3, 0xC3, 0xE8, + 0x32, 0x0, 0xE8, 0xC3, 0x24, 0x1E, 0x8E, 0x1E, 0x50, 0x3, 0x8A, + 0x7, 0x1F, 0xE9, 0xEE, 0xF8, 0xE8, 0x16, 0x0, 0x52, 0xE8, 0xB1, + 0x24, 0xE8, 0x59, 0xB, 0x2C, 0xE8, 0x7D, 0xFC, 0x5A, 0x6, 0x8E, + 0x6, 0x50, 0x3, 0x8B, 0xFA, 0xAA, 0x7, 0xC3, 0xE8, 0x7A, 0xF4, + 0x53, 0xE8, 0x4, 0x0, 0x87, 0xDA, 0x5B, 0xC3, 0xB9, 0xAD, 0x6B, + 0x51, 0xE8, 0x69, 0xF8, 0x78, 0xF6, 0xCD, 0xA4, 0xA0, 0xA6, 0x4, + 0x3C, 0x90, 0x75, 0xED, 0xE8, 0xAB, 0x58, 0x78, 0xE8, 0xE8, 0x82, + 0x48, 0xB9, 0x80, 0x91, 0xBA, 0x0, 0x0, 0xE9, 0x3A, 0x40, 0xB9, + 0xA, 0x0, 0x51, 0x8A, 0xF5, 0x8A, 0xD5, 0x74, 0x35, 0x3C, 0x2C, + 0x74, 0xB, 0x52, 0xE8, 0x74, 0xED, 0x8A, 0xEE, 0x8A, 0xCA, 0x5A, + 0x74, 0x26, 0xE8, 0x0, 0xB, 0x2C, 0xE8, 0x66, 0xED, 0x74, 0x1D, + 0x58, 0xE8, 0xF6, 0xA, 0x2C, 0x52, 0xE8, 0x68, 0xED, 0x74, 0x3, + 0xE9, 0xB6, 0xE4, 0xB, 0xD2, 0x75, 0x3, 0xE9, 0x4A, 0xED, 0x87, + 0xDA, 0x5E, 0x87, 0xDE, 0x56, 0x87, 0xDA, 0x51, 0xE8, 0x4C, 0xE7, + 0x5A, 0x52, 0x51, 0xE8, 0x46, 0xE7, 0x8B, 0xD9, 0x5A, 0x3B, 0xDA, + 0x87, 0xDA, 0x73, 0x3, 0xE9, 0x2C, 0xED, 0x5A, 0x59, 0x58, 0x53, + 0x52, 0xEB, 0x15, 0x3, 0xD9, 0x73, 0x3, 0xE9, 0x1E, 0xED, 0x87, + 0xDA, 0x53, 0xBB, 0xF9, 0xFF, 0x3B, 0xDA, 0x5B, 0x73, 0x3, 0xE9, + 0x10, 0xED, 0x52, 0x8B, 0x17, 0xB, 0xD2, 0x87, 0xDA, 0x5A, 0x74, + 0xC, 0x8A, 0x7, 0x43, 0xA, 0x7, 0x9F, 0x4B, 0x9E, 0x87, 0xDA, + 0x75, 0xD5, 0x51, 0xE8, 0x24, 0x0, 0x59, 0x5A, 0x5B, 0x52, 0x8B, + 0x17, 0x43, 0xB, 0xD2, 0x74, 0x14, 0x87, 0xDA, 0x5E, 0x87, 0xDE, + 0x56, 0x87, 0xDA, 0x43, 0x89, 0x17, 0x87, 0xDA, 0x3, 0xD9, 0x87, + 0xDA, 0x5B, 0xEB, 0xE4, 0xB9, 0xB5, 0x8, 0x51, 0x3C, 0xD, 0x32, + 0xC0, 0xA2, 0x3D, 0x3, 0x8B, 0x1E, 0x30, 0x0, 0x4B, 0x43, 0x8A, + 0x7, 0x43, 0xA, 0x7, 0x75, 0x1, 0xC3, 0x43, 0x8B, 0x17, 0x43, + 0xE8, 0x7B, 0xEB, 0xA, 0xC0, 0x74, 0xEC, 0x8A, 0xC8, 0xA0, 0x3D, + 0x3, 0xA, 0xC0, 0x8A, 0xC1, 0x74, 0x5B, 0xCD, 0xA5, 0x3C, 0xA7, + 0x75, 0x18, 0xE8, 0x63, 0xEB, 0x3C, 0x89, 0x75, 0xE4, 0xE8, 0x5C, + 0xEB, 0x3C, 0xE, 0x75, 0xDD, 0x52, 0xE8, 0xAC, 0xEC, 0xB, 0xD2, + 0x75, 0xA, 0xEB, 0x29, 0x3C, 0xE, 0x75, 0xCC, 0x52, 0xE8, 0x9E, + 0xEC, 0x53, 0xE8, 0x8C, 0xE6, 0x9F, 0x49, 0x9E, 0xB0, 0xD, 0x72, + 0x3F, 0xE8, 0x78, 0x8, 0xBB, 0xFC, 0x23, 0x52, 0xE8, 0x69, 0x57, + 0x5B, 0xE8, 0x60, 0x41, 0x59, 0x5B, 0x53, 0x51, 0xE8, 0x51, 0x41, + 0x5B, 0x5A, 0x4B, 0xEB, 0xA3, 0x55, 0x6E, 0x64, 0x65, 0x66, 0x69, + 0x6E, 0x65, 0x64, 0x20, 0x6C, 0x69, 0x6E, 0x65, 0x20, 0x0, 0x3C, + 0xD, 0x75, 0xEA, 0x52, 0xE8, 0x61, 0xEC, 0x53, 0x87, 0xDA, 0x43, + 0x43, 0x43, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0xB0, 0xE, 0xBB, 0xF7, + 0x23, 0x53, 0x8B, 0x1E, 0xFE, 0x2, 0x53, 0x4B, 0x88, 0x2F, 0x4B, + 0x88, 0xF, 0x4B, 0x88, 0x7, 0x5B, 0xC3, 0xA0, 0x3D, 0x3, 0xA, + 0xC0, 0x74, 0xF8, 0xE9, 0x49, 0xFF, 0xE8, 0xB2, 0x9, 0x42, 0xE8, + 0xAE, 0x9, 0x41, 0xE8, 0xAA, 0x9, 0x53, 0xE8, 0xA6, 0x9, 0x45, + 0xA0, 0x5D, 0x4, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0x6E, 0xE3, 0x53, + 0x8B, 0x1E, 0x5A, 0x3, 0x87, 0xDA, 0x8B, 0x1E, 0x5C, 0x3, 0x3B, + 0xDA, 0x74, 0x3, 0xE9, 0x5C, 0xE3, 0x5B, 0x8A, 0x7, 0x2C, 0x30, + 0x73, 0x3, 0xE9, 0x49, 0xE3, 0x3C, 0x2, 0x72, 0x3, 0xE9, 0x42, + 0xE3, 0xA2, 0x5C, 0x4, 0xFE, 0xC0, 0xA2, 0x5D, 0x4, 0xE8, 0x96, + 0xEA, 0xC3, 0x2E, 0x8A, 0x7, 0xA, 0xC0, 0x74, 0xF8, 0xE8, 0x3, + 0x0, 0x43, 0xEB, 0xF3, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0xE9, + 0x19, 0x7, 0x74, 0x9, 0xE8, 0x84, 0xF2, 0x53, 0xE8, 0x6, 0x47, + 0xEB, 0x20, 0x53, 0xBB, 0xD2, 0x24, 0xE8, 0xA5, 0x56, 0xE8, 0xE1, + 0xC, 0x5A, 0x73, 0x3, 0xE9, 0x8F, 0x9, 0x52, 0x43, 0x8A, 0x7, + 0xE8, 0x0, 0x45, 0x8A, 0x7, 0xA, 0xC0, 0x75, 0xE4, 0xE8, 0xE4, + 0x46, 0x89, 0x1E, 0xC, 0x0, 0xE8, 0x9E, 0x3F, 0x5B, 0xC3, 0x52, + 0x61, 0x6E, 0x64, 0x6F, 0x6D, 0x20, 0x6E, 0x75, 0x6D, 0x62, 0x65, + 0x72, 0x20, 0x73, 0x65, 0x65, 0x64, 0x20, 0x28, 0x2D, 0x33, 0x32, + 0x37, 0x36, 0x38, 0x20, 0x74, 0x6F, 0x20, 0x33, 0x32, 0x37, 0x36, + 0x37, 0x29, 0x0, 0xB1, 0x1D, 0xEB, 0x2, 0xB1, 0x1A, 0xB5, 0x0, + 0x87, 0xDA, 0x8B, 0x1E, 0x2E, 0x0, 0x89, 0x1E, 0x5A, 0x4, 0x87, + 0xDA, 0xFE, 0xC5, 0x4B, 0xE8, 0xC, 0xEA, 0x74, 0x17, 0x3C, 0x22, + 0x75, 0xB, 0xE8, 0x3, 0xEA, 0xA, 0xC0, 0x74, 0xC, 0x3C, 0x22, + 0x75, 0xF5, 0x3C, 0xA1, 0x74, 0x1D, 0x3C, 0xCD, 0x75, 0xE4, 0xA, + 0xC0, 0x75, 0x15, 0x43, 0x8A, 0x7, 0x43, 0xA, 0x7, 0x8A, 0xD1, + 0x75, 0x3, 0xE9, 0x9D, 0xE2, 0x43, 0x8B, 0x17, 0x43, 0x89, 0x16, + 0x5A, 0x4, 0xE8, 0xD7, 0xE9, 0x3C, 0x8F, 0x75, 0x7, 0x51, 0xE8, + 0x11, 0xEC, 0x59, 0xEB, 0xD9, 0x3C, 0x84, 0x75, 0x7, 0x51, 0xE8, + 0x2, 0xEC, 0x59, 0xEB, 0xCE, 0x8A, 0xC1, 0x3C, 0x1A, 0x8A, 0x7, + 0x74, 0xD, 0x3C, 0xB1, 0x74, 0xA3, 0x3C, 0xB2, 0x75, 0xA1, 0xFE, + 0xCD, 0x75, 0x9D, 0xC3, 0x3C, 0x82, 0x74, 0x96, 0x3C, 0x83, 0x75, + 0x94, 0xFE, 0xCD, 0x74, 0xF3, 0xE8, 0x9D, 0xE9, 0x74, 0xA8, 0x87, + 0xDA, 0x8B, 0x1E, 0x2E, 0x0, 0x53, 0x8B, 0x1E, 0x5A, 0x4, 0x89, + 0x1E, 0x2E, 0x0, 0x87, 0xDA, 0x51, 0xE8, 0xD7, 0x11, 0x59, 0x4B, + 0xE8, 0x81, 0xE9, 0xBA, 0x2A, 0x25, 0x74, 0x8, 0xE8, 0x50, 0x8, + 0x2C, 0x4B, 0xBA, 0x79, 0x25, 0x5E, 0x87, 0xDE, 0x56, 0x89, 0x1E, + 0x2E, 0x0, 0x5B, 0x52, 0xC3, 0x9F, 0x50, 0xA0, 0xA8, 0x4, 0xA2, + 0xA9, 0x4, 0x58, 0x9E, 0x9F, 0x50, 0x32, 0xC0, 0xA2, 0xA8, 0x4, + 0x58, 0x9E, 0xC3, 0xE8, 0xDB, 0x2, 0x8A, 0x7, 0x43, 0x8A, 0xF, + 0x43, 0x8A, 0x2F, 0x5A, 0x51, 0x50, 0xE8, 0xD6, 0x2, 0x58, 0x8A, + 0xF0, 0x8A, 0x17, 0x43, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x5B, 0x8A, + 0xC2, 0xA, 0xC6, 0x75, 0x1, 0xC3, 0x8A, 0xC6, 0x2C, 0x1, 0x72, + 0xF9, 0x32, 0xC0, 0x3A, 0xC2, 0xFE, 0xC0, 0x73, 0xF1, 0xFE, 0xCE, + 0xFE, 0xCA, 0x8B, 0xF1, 0xAC, 0x41, 0x3A, 0x7, 0x9F, 0x43, 0x9E, + 0x74, 0xDC, 0xF5, 0xE9, 0x72, 0x3F, 0xE8, 0xF7, 0x3D, 0xEB, 0x8, + 0xE8, 0xFC, 0x3D, 0xEB, 0x3, 0xE8, 0xAE, 0x4A, 0xE8, 0x2F, 0x0, + 0xE8, 0x89, 0x2, 0xB9, 0x17, 0x29, 0x51, 0x8A, 0x7, 0x43, 0x53, + 0xE8, 0xAB, 0x0, 0x5B, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0xE8, 0xD, + 0x0, 0x53, 0x8A, 0xD8, 0xE8, 0x5B, 0x2, 0x5A, 0xC3, 0xB0, 0x1, + 0xE8, 0x95, 0x0, 0xBB, 0x2C, 0x3, 0x53, 0x88, 0x7, 0x43, 0x89, + 0x17, 0x5B, 0xC3, 0x4B, 0xB5, 0x22, 0x8A, 0xF5, 0x53, 0xB1, 0xFF, + 0x43, 0x8A, 0x7, 0xFE, 0xC1, 0xA, 0xC0, 0x74, 0x8, 0x3A, 0xC6, + 0x74, 0x4, 0x3A, 0xC5, 0x75, 0xEF, 0x3C, 0x22, 0x75, 0x3, 0xE8, + 0xB1, 0xE8, 0x53, 0x8A, 0xC5, 0x3C, 0x2C, 0x75, 0xD, 0xFE, 0xC1, + 0xFE, 0xC9, 0x74, 0x7, 0x4B, 0x8A, 0x7, 0x3C, 0x20, 0x74, 0xF5, + 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0x43, 0x87, 0xDA, 0x8A, 0xC1, 0xE8, + 0xB4, 0xFF, 0xBA, 0x2C, 0x3, 0xB0, 0x52, 0x8B, 0x1E, 0xC, 0x3, + 0x89, 0x1E, 0xA3, 0x4, 0xB0, 0x3, 0xA2, 0xFB, 0x2, 0xE8, 0x17, + 0x3E, 0xBA, 0x2F, 0x3, 0x3B, 0xDA, 0x89, 0x1E, 0xC, 0x3, 0x5B, + 0x8A, 0x7, 0x75, 0x9B, 0xBA, 0x10, 0x0, 0xE9, 0x22, 0xE1, 0x43, + 0xE8, 0x92, 0xFF, 0xE8, 0xEC, 0x1, 0xE8, 0x7C, 0x3E, 0xFE, 0xC6, + 0xFE, 0xCE, 0x74, 0x85, 0x8B, 0xF1, 0xAC, 0xE8, 0xD9, 0x4, 0x3C, + 0xD, 0x75, 0x3, 0xE8, 0xA5, 0x5, 0x41, 0xEB, 0xEC, 0xA, 0xC0, + 0xEB, 0x2, 0x58, 0x9E, 0x9F, 0x50, 0x8B, 0x1E, 0x5C, 0x3, 0x87, + 0xDA, 0x8B, 0x1E, 0x2F, 0x3, 0xF6, 0xD0, 0x8A, 0xC8, 0xB5, 0xFF, + 0x3, 0xD9, 0x43, 0x3B, 0xDA, 0x72, 0xF, 0x89, 0x1E, 0x2F, 0x3, + 0x43, 0x87, 0xDA, 0x58, 0x9E, 0xC3, 0x58, 0x86, 0xC4, 0x9E, 0xC3, + 0x58, 0x9E, 0xBA, 0xE, 0x0, 0x75, 0x3, 0xE9, 0xCA, 0xE0, 0x3A, + 0xC0, 0x9F, 0x50, 0xB9, 0xDA, 0x26, 0x51, 0x8B, 0x1E, 0xA, 0x3, + 0x89, 0x1E, 0x2F, 0x3, 0xBB, 0x0, 0x0, 0x53, 0x8B, 0x1E, 0x5C, + 0x3, 0x53, 0xBB, 0xE, 0x3, 0x8B, 0x16, 0xC, 0x3, 0x3B, 0xDA, + 0xB9, 0x2A, 0x27, 0x74, 0x3, 0xE9, 0x9C, 0x0, 0xBB, 0xE2, 0x3, + 0x89, 0x1E, 0x4E, 0x4, 0x8B, 0x1E, 0x5A, 0x3, 0x89, 0x1E, 0x4B, + 0x4, 0x8B, 0x1E, 0x58, 0x3, 0x8B, 0x16, 0x4B, 0x4, 0x3B, 0xDA, + 0x74, 0x1B, 0x8A, 0x7, 0x43, 0x43, 0x43, 0x50, 0xE8, 0x45, 0x13, + 0x58, 0x3C, 0x3, 0x75, 0x5, 0xE8, 0x71, 0x0, 0x32, 0xC0, 0x8A, + 0xD0, 0xB6, 0x0, 0x3, 0xDA, 0xEB, 0xDD, 0x8B, 0x1E, 0x4E, 0x4, + 0x8B, 0x17, 0xB, 0xD2, 0x8B, 0x1E, 0x5A, 0x3, 0x74, 0x19, 0x87, + 0xDA, 0x89, 0x1E, 0x4E, 0x4, 0x43, 0x43, 0x8B, 0x17, 0x43, 0x43, + 0x87, 0xDA, 0x3, 0xDA, 0x89, 0x1E, 0x4B, 0x4, 0x87, 0xDA, 0xEB, + 0xB7, 0x59, 0x8B, 0x16, 0x5C, 0x3, 0x3B, 0xDA, 0x75, 0x3, 0xE9, + 0x6C, 0x0, 0x8A, 0x7, 0x43, 0x50, 0x43, 0x43, 0xE8, 0xF8, 0x12, + 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x43, 0x58, 0x53, 0x3, 0xD9, 0x3C, + 0x3, 0x75, 0xDD, 0x89, 0x1E, 0x33, 0x3, 0x5B, 0x8A, 0xF, 0xB5, + 0x0, 0x3, 0xD9, 0x3, 0xD9, 0x43, 0x87, 0xDA, 0x8B, 0x1E, 0x33, + 0x3, 0x87, 0xDA, 0x3B, 0xDA, 0x74, 0xC4, 0xB9, 0xC5, 0x27, 0x51, + 0x32, 0xC0, 0xA, 0x7, 0x9F, 0x43, 0x9E, 0x8A, 0x17, 0x9F, 0x43, + 0x9E, 0x8A, 0x37, 0x9F, 0x43, 0x9E, 0x75, 0x1, 0xC3, 0x8B, 0xCB, + 0x8B, 0x1E, 0x2F, 0x3, 0x3B, 0xDA, 0x8B, 0xD9, 0x72, 0xF3, 0x5B, + 0x5E, 0x87, 0xDE, 0x56, 0x3B, 0xDA, 0x5E, 0x87, 0xDE, 0x56, 0x53, + 0x8B, 0xD9, 0x73, 0xE3, 0x59, 0x58, 0x58, 0x53, 0x52, 0x51, 0xC3, + 0x5A, 0x5B, 0xB, 0xDB, 0x74, 0xF9, 0x4B, 0x8A, 0x2F, 0x4B, 0x8A, + 0xF, 0x53, 0x4B, 0x8A, 0x1F, 0xB7, 0x0, 0x3, 0xD9, 0x8A, 0xF5, + 0x8A, 0xD1, 0x4B, 0x8B, 0xCB, 0x8B, 0x1E, 0x2F, 0x3, 0xE8, 0xA0, + 0x3C, 0x5B, 0x88, 0xF, 0x43, 0x88, 0x2F, 0x8B, 0xD9, 0x4B, 0xE9, + 0xE0, 0xFE, 0x51, 0x53, 0x8B, 0x1E, 0xA3, 0x4, 0x5E, 0x87, 0xDE, + 0x56, 0xE8, 0xA0, 0xF0, 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0xED, 0x3B, + 0x8A, 0x7, 0x53, 0x8B, 0x1E, 0xA3, 0x4, 0x53, 0x2, 0x7, 0xBA, + 0xF, 0x0, 0x73, 0x3, 0xE9, 0x78, 0xDF, 0xE8, 0xDB, 0xFD, 0x5A, + 0xE8, 0x48, 0x0, 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0x3F, 0x0, 0x53, + 0x8B, 0x1E, 0x2D, 0x3, 0x87, 0xDA, 0xE8, 0xE, 0x0, 0xE8, 0xB, + 0x0, 0xBB, 0x3A, 0x17, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0xE9, 0x7, + 0xFE, 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0x8A, 0x7, 0x43, 0x8A, 0xF, + 0x43, 0x8A, 0x2F, 0x8A, 0xD8, 0xFE, 0xC3, 0xFE, 0xCB, 0x75, 0x1, + 0xC3, 0x8B, 0xF1, 0xAC, 0x8B, 0xFA, 0xAA, 0x41, 0x42, 0xEB, 0xF1, + 0xE8, 0x92, 0x3B, 0x8B, 0x1E, 0xA3, 0x4, 0x87, 0xDA, 0xE8, 0x20, + 0x0, 0x87, 0xDA, 0x75, 0xE5, 0x52, 0x8A, 0xF5, 0x8A, 0xD1, 0x4A, + 0x8A, 0xF, 0x8B, 0x1E, 0x2F, 0x3, 0x3B, 0xDA, 0x75, 0xA, 0x32, + 0xC0, 0x8A, 0xE8, 0x3, 0xD9, 0x89, 0x1E, 0x2F, 0x3, 0x5B, 0xC3, + 0xCD, 0xEE, 0x8B, 0x1E, 0xC, 0x3, 0x4B, 0x8A, 0x2F, 0x4B, 0x8A, + 0xF, 0x4B, 0x3B, 0xDA, 0x75, 0xEE, 0x89, 0x1E, 0xC, 0x3, 0xC3, + 0xB9, 0x7F, 0x1B, 0x51, 0xE8, 0xB7, 0xFF, 0x32, 0xC0, 0x8A, 0xF0, + 0x8A, 0x7, 0xA, 0xC0, 0xC3, 0xB9, 0x7F, 0x1B, 0x51, 0xE8, 0xED, + 0xFF, 0x75, 0x3, 0xE9, 0x55, 0xE7, 0x43, 0x8B, 0x17, 0x8B, 0xF2, + 0xAC, 0xC3, 0xE8, 0x2E, 0xFD, 0xE8, 0xE, 0xF6, 0x8B, 0x1E, 0x2D, + 0x3, 0x88, 0x17, 0x59, 0xE9, 0x72, 0xFD, 0xE8, 0xFF, 0xE5, 0xE8, + 0xD3, 0x4, 0x28, 0xE8, 0xF7, 0xF5, 0x52, 0xE8, 0xCB, 0x4, 0x2C, + 0xE8, 0xFA, 0xED, 0xE8, 0xC4, 0x4, 0x29, 0x5E, 0x87, 0xDE, 0x56, + 0x53, 0xE8, 0xEC, 0xF1, 0x74, 0x5, 0xE8, 0xE1, 0xF5, 0xEB, 0x3, + 0xE8, 0xB9, 0xFF, 0x5A, 0xE8, 0x5, 0x0, 0xE8, 0xD5, 0xF5, 0xB0, + 0x20, 0x50, 0x8A, 0xC2, 0xE8, 0xEC, 0xFC, 0x8A, 0xE8, 0x58, 0xFE, + 0xC5, 0xFE, 0xCD, 0x74, 0xBC, 0x8B, 0x1E, 0x2D, 0x3, 0x88, 0x7, + 0x43, 0xFE, 0xCD, 0x75, 0xF9, 0xEB, 0xAF, 0xE8, 0xA3, 0x0, 0x32, + 0xC0, 0x5E, 0x87, 0xDE, 0x56, 0x8A, 0xC8, 0xB0, 0x53, 0x53, 0x8A, + 0x7, 0x3A, 0xC5, 0x72, 0x3, 0x8A, 0xC5, 0xBA, 0xB1, 0x0, 0x51, + 0xE8, 0x51, 0xFD, 0x59, 0x5B, 0x53, 0x43, 0x8A, 0x2F, 0x43, 0x8A, + 0x3F, 0x8A, 0xDD, 0xB5, 0x0, 0x3, 0xD9, 0x8B, 0xCB, 0xE8, 0xA8, + 0xFC, 0x8A, 0xD8, 0xE8, 0xF7, 0xFE, 0x5A, 0xE8, 0xD, 0xFF, 0xE9, + 0xE8, 0xFC, 0xE8, 0x66, 0x0, 0x5A, 0x52, 0x8B, 0xF2, 0xAC, 0x2A, + 0xC5, 0xEB, 0xBC, 0x87, 0xDA, 0x8A, 0x7, 0xE8, 0x5C, 0x0, 0xFE, + 0xC5, 0xFE, 0xCD, 0x75, 0x3, 0xE9, 0x98, 0xE6, 0x51, 0xE8, 0xB5, + 0x1, 0x58, 0x86, 0xC4, 0x9E, 0x5E, 0x87, 0xDE, 0x56, 0xB9, 0x75, + 0x29, 0x51, 0xFE, 0xC8, 0x3A, 0x7, 0xB5, 0x0, 0x72, 0x1, 0xC3, + 0x8A, 0xC8, 0x8A, 0x7, 0x2A, 0xC1, 0x3A, 0xC2, 0x8A, 0xE8, 0x72, + 0xF3, 0x8A, 0xEA, 0xC3, 0xE8, 0x0, 0xFF, 0x75, 0x3, 0xE9, 0x8E, + 0xF1, 0x8A, 0xD0, 0x43, 0x8B, 0x1F, 0x53, 0x3, 0xDA, 0x8A, 0x2F, + 0x88, 0x37, 0x5E, 0x87, 0xDE, 0x56, 0x51, 0x4B, 0xE8, 0x17, 0xE5, + 0xE8, 0xBE, 0x3F, 0x59, 0x5B, 0x88, 0x2F, 0xC3, 0x87, 0xDA, 0xE8, + 0xE1, 0x3, 0x29, 0x59, 0x5A, 0x51, 0x8A, 0xEA, 0xC3, 0xE8, 0x0, + 0xE5, 0xE8, 0x3, 0xED, 0xE8, 0x2, 0xF1, 0xB0, 0x1, 0x50, 0x74, + 0x16, 0x58, 0xE8, 0xF3, 0xF4, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x26, + 0xE6, 0x50, 0xE8, 0xBD, 0x3, 0x2C, 0xE8, 0xEC, 0xEC, 0xE8, 0xFD, + 0x39, 0xE8, 0xB3, 0x3, 0x2C, 0x53, 0x8B, 0x1E, 0xA3, 0x4, 0x5E, + 0x87, 0xDE, 0x56, 0xE8, 0xD9, 0xEC, 0xE8, 0xA3, 0x3, 0x29, 0x53, + 0xE8, 0x50, 0xFE, 0x87, 0xDA, 0x59, 0x5B, 0x58, 0x51, 0xB9, 0x7, + 0x65, 0x51, 0xB9, 0x7F, 0x1B, 0x51, 0x50, 0x52, 0xE8, 0x44, 0xFE, + 0x5A, 0x58, 0x8A, 0xE8, 0xFE, 0xC8, 0x8A, 0xC8, 0x3A, 0x7, 0xB0, + 0x0, 0x73, 0xA2, 0x8B, 0xF2, 0xAC, 0xA, 0xC0, 0x8A, 0xC5, 0x74, + 0x99, 0x8A, 0x7, 0x43, 0x8A, 0x2F, 0x43, 0x8A, 0x3F, 0x8A, 0xDD, + 0xB5, 0x0, 0x3, 0xD9, 0x2A, 0xC1, 0x8A, 0xE8, 0x51, 0x52, 0x5E, + 0x87, 0xDE, 0x56, 0x8A, 0xF, 0x43, 0x8B, 0x17, 0x5B, 0x53, 0x52, + 0x51, 0x8B, 0xF2, 0xAC, 0x3A, 0x7, 0x75, 0x1E, 0x42, 0xFE, 0xC9, + 0x74, 0xC, 0x43, 0xFE, 0xCD, 0x75, 0xEF, 0x5A, 0x5A, 0x59, 0x5A, + 0x32, 0xC0, 0xC3, 0x5B, 0x5A, 0x5A, 0x59, 0x8A, 0xC5, 0x2A, 0xC7, + 0x2, 0xC1, 0xFE, 0xC0, 0xC3, 0x59, 0x5A, 0x5B, 0x43, 0xFE, 0xCD, + 0x75, 0xD0, 0xEB, 0xE5, 0xE8, 0x21, 0x3, 0x28, 0xE8, 0x97, 0xC, + 0xE8, 0x61, 0x39, 0x53, 0x52, 0x87, 0xDA, 0x43, 0x8B, 0x17, 0x8B, + 0x1E, 0x5C, 0x3, 0x3B, 0xDA, 0x72, 0x12, 0x8B, 0x1E, 0x30, 0x0, + 0x3B, 0xDA, 0x73, 0xA, 0x5B, 0x53, 0xE8, 0x2E, 0xFB, 0x5B, 0x53, + 0xE8, 0xBE, 0x39, 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0xF1, 0x2, + 0x2C, 0xE8, 0x15, 0xF4, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x4B, 0xE5, + 0x50, 0x8A, 0x7, 0xE8, 0x66, 0x0, 0x52, 0xE8, 0x4, 0xEC, 0x53, + 0xE8, 0x8A, 0xFD, 0x87, 0xDA, 0x5B, 0x59, 0x58, 0x8A, 0xE8, 0x5E, + 0x87, 0xDE, 0x56, 0x53, 0xBB, 0x7, 0x65, 0x5E, 0x87, 0xDE, 0x56, + 0x8A, 0xC1, 0xA, 0xC0, 0x74, 0x90, 0x8A, 0x7, 0x2A, 0xC5, 0x73, + 0x3, 0xE9, 0x1B, 0xE5, 0xFE, 0xC0, 0x3A, 0xC1, 0x72, 0x2, 0x8A, + 0xC1, 0x8A, 0xCD, 0xFE, 0xC9, 0xB5, 0x0, 0x52, 0x43, 0x8A, 0x17, + 0x43, 0x8A, 0x3F, 0x8A, 0xDA, 0x3, 0xD9, 0x8A, 0xE8, 0x5A, 0x87, + 0xDA, 0x8A, 0xF, 0x43, 0x8B, 0x1F, 0x87, 0xDA, 0x8A, 0xC1, 0xA, + 0xC0, 0x75, 0x1, 0xC3, 0x8B, 0xF2, 0xAC, 0x88, 0x7, 0x42, 0x43, + 0xFE, 0xC9, 0x74, 0xF4, 0xFE, 0xCD, 0x75, 0xF1, 0xC3, 0xB2, 0xFF, + 0x3C, 0x29, 0x74, 0x7, 0xE8, 0x71, 0x2, 0x2C, 0xE8, 0x95, 0xF3, + 0xE8, 0x6A, 0x2, 0x29, 0xC3, 0xE8, 0x96, 0xEF, 0x74, 0x3, 0xE9, + 0x6, 0x0, 0xE8, 0x12, 0xFD, 0xE8, 0x7C, 0xFB, 0x8B, 0x16, 0x5C, + 0x3, 0x8B, 0x1E, 0x2F, 0x3, 0xE9, 0xCB, 0xEF, 0xCD, 0xB4, 0x9F, + 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x53, 0xE8, 0x25, 0x4, 0x74, 0x3, + 0xE9, 0xDD, 0x17, 0x5B, 0x58, 0x86, 0xC4, 0x9E, 0x51, 0x9F, 0x50, + 0xEB, 0x12, 0x32, 0xC0, 0xA2, 0x4F, 0x3, 0xE9, 0x93, 0xE5, 0x19, + 0xFE, 0xC8, 0xE8, 0x63, 0x23, 0xB0, 0x8, 0xEB, 0x38, 0x3C, 0x9, + 0x75, 0x10, 0xB0, 0x20, 0xE8, 0xCA, 0xFF, 0xE8, 0x4E, 0x23, 0x24, + 0x7, 0x75, 0xF4, 0x58, 0x9E, 0x59, 0xC3, 0x3C, 0x20, 0x72, 0x20, + 0xA0, 0x29, 0x0, 0x8A, 0xE8, 0xE8, 0x3A, 0x23, 0xFE, 0xC5, 0x74, + 0xB, 0xFE, 0xCD, 0x3A, 0xC5, 0x75, 0x3, 0xE8, 0x72, 0x0, 0x74, + 0x9, 0x3C, 0xFF, 0x74, 0x5, 0xFE, 0xC0, 0xE8, 0x27, 0x23, 0x58, + 0x9E, 0x59, 0x9F, 0x50, 0x58, 0x9E, 0xE8, 0x7C, 0x22, 0xC3, 0xCD, + 0xB5, 0xE8, 0xBC, 0x3, 0x74, 0x3D, 0xE8, 0xB6, 0x17, 0x73, 0xF3, + 0x51, 0x52, 0x53, 0xA0, 0x36, 0x5, 0x24, 0xC8, 0xA2, 0x36, 0x5, + 0xE8, 0xCC, 0x18, 0x5B, 0x5A, 0x59, 0xA0, 0x6B, 0x4, 0xA, 0xC0, + 0x74, 0x3, 0xE9, 0xA, 0x31, 0xA0, 0xEF, 0x4, 0xA, 0xC0, 0x74, + 0x7, 0xBB, 0xE8, 0xE, 0x53, 0xE9, 0xED, 0x0, 0x53, 0x51, 0x52, + 0xBB, 0x2D, 0x7, 0xE8, 0x2, 0x4F, 0x5A, 0x59, 0xB0, 0xD, 0x5B, + 0xC3, 0xE8, 0x12, 0x21, 0xC3, 0xE8, 0xCC, 0x22, 0xA, 0xC0, 0x74, + 0xF8, 0xEB, 0xB, 0xC6, 0x7, 0x0, 0xE8, 0x6A, 0x3, 0xBB, 0xF6, + 0x1, 0x75, 0x7, 0xCD, 0xB6, 0xB0, 0xD, 0xE8, 0x2D, 0xFF, 0xE8, + 0x5B, 0x3, 0x74, 0x3, 0x32, 0xC0, 0xC3, 0x32, 0xC0, 0xE8, 0xAC, + 0x22, 0x32, 0xC0, 0xC3, 0xCD, 0xB7, 0xA0, 0x5E, 0x0, 0xA, 0xC0, + 0x75, 0x1, 0xC3, 0xE8, 0xC4, 0xFF, 0x75, 0x3, 0xE8, 0xDC, 0x1, + 0xE9, 0x90, 0x1, 0xE8, 0xEF, 0x32, 0x53, 0xE8, 0xAF, 0x20, 0x74, + 0x21, 0xE8, 0xB0, 0xFF, 0xA, 0xC0, 0x75, 0x10, 0x50, 0xB0, 0x2, + 0xE8, 0x8B, 0xF9, 0x8B, 0x1E, 0x2D, 0x3, 0x5A, 0x89, 0x17, 0xE9, + 0xD0, 0xF9, 0x50, 0xE8, 0x7B, 0xF9, 0x58, 0x8A, 0xD0, 0xE8, 0x4A, + 0xFC, 0xBB, 0x6, 0x0, 0x89, 0x1E, 0xA3, 0x4, 0xB0, 0x3, 0xA2, + 0xFB, 0x2, 0x5B, 0xC3, 0x53, 0x8B, 0x1E, 0xA, 0x3, 0xB5, 0x0, + 0x3, 0xD9, 0x3, 0xD9, 0xB0, 0x26, 0x2A, 0xC3, 0x8A, 0xD8, 0xB0, + 0xFF, 0x1A, 0xC7, 0x8A, 0xF8, 0x72, 0x6, 0x3, 0xDC, 0x5B, 0x73, + 0x1, 0xC3, 0x8B, 0x1E, 0x2C, 0x0, 0x4B, 0x4B, 0x89, 0x1E, 0x45, + 0x3, 0xBA, 0x7, 0x0, 0xE9, 0xD4, 0xDA, 0x39, 0x1E, 0x2F, 0x3, + 0x73, 0xE9, 0x51, 0x52, 0x53, 0xE8, 0x6, 0xFA, 0x5B, 0x5A, 0x59, + 0x39, 0x1E, 0x2F, 0x3, 0x73, 0xDA, 0xEB, 0xE3, 0x75, 0xD6, 0x8B, + 0x1E, 0x30, 0x0, 0xE8, 0x79, 0x1, 0xA2, 0x64, 0x4, 0xA2, 0x3E, + 0x3, 0xA2, 0x3D, 0x3, 0x88, 0x7, 0x43, 0x88, 0x7, 0x43, 0x89, + 0x1E, 0x58, 0x3, 0xCD, 0xAE, 0x8B, 0x1E, 0x30, 0x0, 0x4B, 0xCD, + 0xAF, 0x89, 0x1E, 0x3B, 0x3, 0xA0, 0x65, 0x4, 0xA, 0xC0, 0x75, + 0x17, 0x32, 0xC0, 0xA2, 0x5D, 0x4, 0xA2, 0x5C, 0x4, 0xB5, 0x1A, + 0xBB, 0x60, 0x3, 0xCD, 0xB0, 0xC6, 0x7, 0x4, 0x43, 0xFE, 0xCD, + 0x75, 0xF8, 0xBA, 0x7, 0x0, 0xBB, 0xB, 0x0, 0xE8, 0xC6, 0x37, + 0x32, 0xC0, 0xA2, 0x4F, 0x3, 0x8A, 0xD8, 0x8A, 0xF8, 0x89, 0x1E, + 0x4D, 0x3, 0x89, 0x1E, 0x56, 0x3, 0x8B, 0x1E, 0xA, 0x3, 0xA0, + 0x6B, 0x4, 0xA, 0xC0, 0x75, 0x4, 0x89, 0x1E, 0x2F, 0x3, 0x32, + 0xC0, 0xE8, 0x7C, 0x0, 0x8B, 0x1E, 0x58, 0x3, 0x89, 0x1E, 0x5A, + 0x3, 0x89, 0x1E, 0x5C, 0x3, 0xA0, 0x65, 0x4, 0xA, 0xC0, 0x75, + 0x3, 0xE8, 0xB4, 0x15, 0xA0, 0x36, 0x5, 0x24, 0x1, 0x75, 0x3, + 0xA2, 0x36, 0x5, 0x59, 0x8B, 0x1E, 0x2C, 0x0, 0x4B, 0x4B, 0x89, + 0x1E, 0x45, 0x3, 0x43, 0x43, 0xCD, 0xB1, 0x8B, 0xE3, 0xBB, 0xE, + 0x3, 0x89, 0x1E, 0xC, 0x3, 0xE8, 0xF3, 0xF7, 0xE8, 0xCA, 0xE6, + 0x32, 0xC0, 0x8A, 0xF8, 0x8A, 0xD8, 0x89, 0x1E, 0x7C, 0x3, 0xA2, + 0x4D, 0x4, 0x89, 0x1E, 0xE4, 0x3, 0x89, 0x1E, 0x50, 0x4, 0x89, + 0x1E, 0x7A, 0x3, 0xA2, 0x39, 0x3, 0x53, 0x51, 0x8B, 0x1E, 0x3B, + 0x3, 0xC3, 0x3B, 0xDA, 0xC3, 0x5E, 0x8B, 0xFB, 0xFC, 0x2E, 0xA6, + 0x56, 0x8B, 0xDF, 0x75, 0xA, 0x8A, 0x7, 0x3C, 0x3A, 0x72, 0x1, + 0xC3, 0xE9, 0x1C, 0xE1, 0xE9, 0xB2, 0xD9, 0x87, 0xDA, 0x8B, 0x1E, + 0x30, 0x0, 0x74, 0x11, 0x87, 0xDA, 0xE8, 0x52, 0xE2, 0x53, 0xE8, + 0x4A, 0xDC, 0x8B, 0xD9, 0x5A, 0x72, 0x3, 0xE9, 0xB, 0xE3, 0x4B, + 0x89, 0x1E, 0x5E, 0x3, 0x87, 0xDA, 0xC3, 0x75, 0xFD, 0xFE, 0xC0, + 0xEB, 0x9, 0x75, 0xF7, 0x9C, 0x75, 0x3, 0xE8, 0x9F, 0xA, 0x9D, + 0x89, 0x1E, 0x43, 0x3, 0xBB, 0xE, 0x3, 0x89, 0x1E, 0xC, 0x3, + 0xBB, 0xC, 0xFF, 0x59, 0x8B, 0x1E, 0x2E, 0x0, 0x53, 0x9C, 0x8A, + 0xC3, 0x22, 0xC7, 0xFE, 0xC0, 0x74, 0xC, 0x89, 0x1E, 0x54, 0x3, + 0x8B, 0x1E, 0x43, 0x3, 0x89, 0x1E, 0x56, 0x3, 0xE8, 0xF5, 0xFD, + 0x9D, 0xBB, 0x32, 0x7, 0x74, 0x3, 0xE9, 0x14, 0xDA, 0xE9, 0x41, + 0xDA, 0xB0, 0xF, 0x50, 0xB0, 0x5E, 0xE8, 0x29, 0xFD, 0x58, 0x4, + 0x40, 0xE8, 0x23, 0xFD, 0xE9, 0xEC, 0xFD, 0x8B, 0x1E, 0x56, 0x3, + 0xB, 0xDB, 0xBA, 0x11, 0x0, 0x75, 0x3, 0xE9, 0x45, 0xD9, 0x8B, + 0x16, 0x54, 0x3, 0x89, 0x16, 0x2E, 0x0, 0xC3, 0xB8, 0x32, 0xC0, + 0xA2, 0x76, 0x4, 0xC3, 0xE8, 0xC8, 0x8, 0x52, 0x53, 0xBB, 0x6E, + 0x4, 0xE8, 0xB, 0x36, 0x8B, 0x1E, 0x5A, 0x3, 0x5E, 0x87, 0xDE, + 0x56, 0xE8, 0x6C, 0xEC, 0x50, 0xE8, 0x37, 0xFF, 0x2C, 0xE8, 0xAD, + 0x8, 0x58, 0x8A, 0xE8, 0xE8, 0x5E, 0xEC, 0x3A, 0xC5, 0x74, 0x3, + 0xE9, 0x8, 0xD9, 0x5E, 0x87, 0xDE, 0x56, 0x87, 0xDA, 0x53, 0x8B, + 0x1E, 0x5A, 0x3, 0x3B, 0xDA, 0x75, 0x13, 0x5A, 0x5B, 0x5E, 0x87, + 0xDE, 0x56, 0x52, 0xE8, 0xD2, 0x35, 0x5B, 0xBA, 0x6E, 0x4, 0xE8, + 0xCB, 0x35, 0x5B, 0xC3, 0xE9, 0x66, 0xE1, 0xB0, 0x1, 0xA2, 0x39, + 0x3, 0xE8, 0x73, 0x8, 0x75, 0xF3, 0x53, 0xA2, 0x39, 0x3, 0x8A, + 0xFD, 0x8A, 0xD9, 0x49, 0x49, 0x49, 0x8B, 0xF1, 0xAC, 0x49, 0xA, + 0xC0, 0x78, 0xF8, 0x49, 0x49, 0x3, 0xDA, 0x87, 0xDA, 0x8B, 0x1E, + 0x5C, 0x3, 0x3B, 0xDA, 0x8B, 0xF2, 0xAC, 0x8B, 0xF9, 0xAA, 0x9F, + 0x42, 0x9E, 0x9F, 0x41, 0x9E, 0x75, 0xF0, 0x49, 0x8B, 0xD9, 0x89, + 0x1E, 0x5C, 0x3, 0x5B, 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0xB7, 0xE8, + 0xE2, 0xDF, 0xEB, 0xB6, 0x58, 0x86, 0xC4, 0x9E, 0x5B, 0xC3, 0x8A, + 0x7, 0x3C, 0x41, 0x72, 0xF9, 0x3C, 0x5B, 0xF5, 0xC3, 0xE9, 0xEE, + 0xFD, 0x74, 0xFB, 0x3C, 0x2C, 0x74, 0x9, 0xE8, 0xFB, 0xE0, 0x4B, + 0xE8, 0xC0, 0xDF, 0x74, 0xEE, 0xE8, 0x92, 0xFE, 0x2C, 0x74, 0xE8, + 0x8B, 0x16, 0x2C, 0x0, 0x3C, 0x2C, 0x74, 0x3, 0xE8, 0x47, 0x0, + 0x4B, 0xE8, 0xA9, 0xDF, 0x52, 0x74, 0x4E, 0xE8, 0x7A, 0xFE, 0x2C, + 0x74, 0x48, 0xE8, 0x37, 0x0, 0x4B, 0xE8, 0x99, 0xDF, 0x74, 0x3, + 0xE9, 0x35, 0xD8, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0xBB, 0xEE, 0x0, + 0x3B, 0xDA, 0x73, 0x2D, 0x5B, 0xE8, 0x36, 0x0, 0x72, 0x27, 0x53, + 0x8B, 0x1E, 0x58, 0x3, 0xB9, 0x14, 0x0, 0x3, 0xD9, 0x3B, 0xDA, + 0x73, 0x19, 0x87, 0xDA, 0x89, 0x1E, 0xA, 0x3, 0x5B, 0x89, 0x1E, + 0x2C, 0x0, 0x5B, 0xEB, 0x96, 0xE8, 0xF0, 0xF2, 0xB, 0xD2, 0x75, + 0x3, 0xE9, 0x98, 0xE0, 0xC3, 0xE9, 0x2F, 0xFD, 0x8B, 0x16, 0x2C, + 0x0, 0x2B, 0x16, 0xA, 0x3, 0xEB, 0xBA, 0x8B, 0xC3, 0x2B, 0xC2, + 0x8B, 0xD0, 0xC3, 0xCD, 0xB2, 0x53, 0x8B, 0x1E, 0xE9, 0x4, 0xB, + 0xDB, 0x5B, 0xC3, 0x1, 0x30, 0x4E, 0x30, 0xE1, 0x30, 0xFD, 0x2F, + 0xF1, 0x2F, 0x5B, 0x30, 0x30, 0x30, 0x1B, 0x30, 0x8B, 0x1E, 0x56, + 0x0, 0xE8, 0x4A, 0x0, 0x74, 0x1, 0xC3, 0xEB, 0x4, 0xB0, 0x1, + 0xEB, 0x2, 0xB0, 0xFF, 0xA2, 0x70, 0x0, 0xFE, 0xC0, 0xE8, 0x65, + 0x1, 0xB7, 0x1, 0xE8, 0xB, 0x0, 0x75, 0xE8, 0xE8, 0xB, 0x1F, + 0xE8, 0x5E, 0x0, 0x32, 0xC0, 0xC3, 0xA0, 0x5C, 0x0, 0x3A, 0xC3, + 0x74, 0xF8, 0x73, 0x7, 0x8A, 0xD8, 0x32, 0xC0, 0xE9, 0xF5, 0x1E, + 0xFE, 0xC3, 0xE9, 0xF0, 0x1E, 0xA0, 0x5B, 0x0, 0x3A, 0xC3, 0x74, + 0xE3, 0xB0, 0x1, 0x3A, 0xC3, 0x74, 0xDD, 0xFE, 0xCB, 0xE9, 0xDE, + 0x1E, 0xA0, 0x29, 0x0, 0x3A, 0xC7, 0x74, 0xD1, 0xFE, 0xC7, 0xE9, + 0xD2, 0x1E, 0x8B, 0x1E, 0x5B, 0x0, 0xB7, 0x1, 0x89, 0x1E, 0x58, + 0x0, 0xE9, 0xC5, 0x1E, 0x8B, 0x1E, 0x56, 0x0, 0xE8, 0x9, 0x0, + 0x75, 0xB6, 0xA0, 0x29, 0x0, 0x8A, 0xF8, 0xEB, 0xC5, 0xB0, 0x1, + 0x3A, 0xC7, 0x74, 0xA9, 0xFE, 0xCF, 0xE9, 0xAA, 0x1E, 0xA0, 0x5B, + 0x0, 0x8A, 0xF8, 0xA0, 0x5C, 0x0, 0x8A, 0xD8, 0x2A, 0xC7, 0x72, + 0x96, 0xFE, 0xC0, 0x50, 0xE8, 0x99, 0x0, 0xA0, 0x58, 0x0, 0xFE, + 0xC3, 0x3A, 0xC3, 0xFE, 0xCB, 0x73, 0xD, 0x3A, 0xC7, 0x72, 0x9, + 0x75, 0x2, 0xB0, 0x1, 0xFE, 0xC8, 0xA2, 0x58, 0x0, 0x58, 0xFE, + 0xC8, 0x75, 0x3, 0xE9, 0x3, 0x0, 0xE8, 0xDE, 0x1E, 0xC3, 0xA0, + 0x5B, 0x0, 0x8A, 0xD8, 0xA0, 0x5C, 0x0, 0x8A, 0xF8, 0x2A, 0xC3, + 0x72, 0xF1, 0xFE, 0xC0, 0x50, 0xE8, 0x7F, 0x0, 0xA0, 0x58, 0x0, + 0x3A, 0xC3, 0x72, 0x10, 0x3A, 0xC7, 0x78, 0x3, 0xE9, 0x9, 0x0, + 0x75, 0x2, 0xB0, 0xFF, 0xFE, 0xC0, 0xA2, 0x58, 0x0, 0x58, 0xFE, + 0xC8, 0x74, 0xCF, 0xE9, 0xBB, 0x1E, 0x8B, 0x1E, 0x5B, 0x0, 0xA0, + 0x5D, 0x0, 0x8A, 0xE8, 0x8A, 0xC5, 0x3A, 0xC3, 0x73, 0x2, 0x8A, + 0xD8, 0x3A, 0xC7, 0x73, 0x2, 0x8A, 0xF8, 0x8A, 0xC7, 0xB7, 0x0, + 0x2A, 0xC3, 0xFE, 0xC0, 0xBA, 0x72, 0x0, 0x50, 0x87, 0xDA, 0x3, + 0xDA, 0x88, 0x7, 0x43, 0x88, 0x7, 0x43, 0xFE, 0xC8, 0x75, 0xF9, + 0x87, 0xDA, 0x58, 0x32, 0xC0, 0xA2, 0x58, 0x0, 0xA2, 0x59, 0x0, + 0xA2, 0x5A, 0x0, 0xE9, 0x2B, 0xFF, 0x50, 0xE8, 0x37, 0x0, 0xB5, + 0x1, 0x8A, 0xC8, 0x8A, 0xC5, 0x8B, 0xFA, 0xAA, 0x4A, 0x8B, 0xF2, + 0xAC, 0x8A, 0xE9, 0x8A, 0xC8, 0x58, 0xFE, 0xC8, 0x75, 0x1, 0xC3, + 0x50, 0xEB, 0xEA, 0x50, 0xB5, 0x1, 0xE8, 0x17, 0x0, 0x8A, 0xC8, + 0x8A, 0xC5, 0x8B, 0xFA, 0xAA, 0x42, 0x8B, 0xF2, 0xAC, 0x8A, 0xE9, + 0x8A, 0xC8, 0x58, 0xFE, 0xC8, 0x74, 0xE2, 0x50, 0xEB, 0xEB, 0x53, + 0xBA, 0x74, 0x0, 0xB7, 0x0, 0xFE, 0xCB, 0x3, 0xDA, 0x8A, 0x7, + 0x87, 0xDA, 0x5B, 0x22, 0xC0, 0xC3, 0x53, 0xBA, 0x74, 0x0, 0xB7, + 0x0, 0xFE, 0xCB, 0x3, 0xDA, 0x88, 0x7, 0x87, 0xDA, 0x5B, 0xC3, + 0xCD, 0xA6, 0xE8, 0x41, 0x1, 0x8B, 0x1E, 0x56, 0x0, 0x89, 0x1E, + 0x58, 0x0, 0xA0, 0x29, 0x0, 0xFE, 0xC0, 0xEB, 0x1E, 0xB0, 0x3F, + 0xE8, 0xC, 0xFA, 0xB0, 0x20, 0xE8, 0x7, 0xFA, 0x32, 0xC0, 0xA2, + 0x27, 0x0, 0xCD, 0xA7, 0xE8, 0x1E, 0x1, 0x8B, 0x1E, 0x56, 0x0, + 0x89, 0x1E, 0x58, 0x0, 0x8A, 0xC7, 0xA2, 0x5A, 0x0, 0xE8, 0xE1, + 0x4, 0xFE, 0xCB, 0x74, 0x5, 0xB0, 0x1, 0xE8, 0xAF, 0xFF, 0xE8, + 0xC, 0x23, 0xE8, 0x41, 0x23, 0xE8, 0xA4, 0x1B, 0xE8, 0x8, 0x23, + 0xE8, 0x38, 0x23, 0xA, 0xC0, 0x75, 0x3, 0xE8, 0x77, 0x1C, 0x50, + 0x8B, 0x1E, 0x56, 0x0, 0x8A, 0x26, 0x29, 0x0, 0xFE, 0xC4, 0x3A, + 0x1E, 0x58, 0x0, 0x75, 0x12, 0x3A, 0x3E, 0x59, 0x0, 0x73, 0x4, + 0x88, 0x3E, 0x59, 0x0, 0x3A, 0x3E, 0x5A, 0x0, 0x76, 0x6, 0x8A, + 0xE7, 0x88, 0x26, 0x5A, 0x0, 0x58, 0xE8, 0x2F, 0x0, 0x72, 0x10, + 0x74, 0xBB, 0xE8, 0x3, 0x2, 0xE8, 0x99, 0xF9, 0xEB, 0xB3, 0x1, + 0xE8, 0x93, 0xF9, 0xEB, 0xAD, 0x3C, 0x3, 0xF9, 0x74, 0x1, 0xF5, + 0xBB, 0xF6, 0x1, 0xC3, 0x3C, 0x3B, 0x75, 0xFB, 0xE9, 0xF8, 0xDC, + 0x4B, 0x43, 0xFE, 0xC9, 0x78, 0xF2, 0x2E, 0x3A, 0x7, 0x75, 0xF6, + 0xC3, 0xBB, 0x94, 0x32, 0xB1, 0xE, 0xE8, 0xEC, 0xFF, 0x79, 0x3, + 0xE9, 0x7, 0x0, 0x50, 0x32, 0xC0, 0xA2, 0x72, 0x0, 0x58, 0xBB, + 0xA2, 0x32, 0xB1, 0xC, 0xE8, 0xD8, 0xFF, 0x79, 0x3, 0xE9, 0x20, + 0x0, 0x50, 0x8A, 0xC1, 0xA, 0xC0, 0xD0, 0xC0, 0x8A, 0xC8, 0x32, + 0xC0, 0x8A, 0xE8, 0xBB, 0xAE, 0x32, 0x3, 0xD9, 0x2E, 0x8A, 0x17, + 0x43, 0x2E, 0x8A, 0x37, 0x58, 0x52, 0x8B, 0x1E, 0x56, 0x0, 0xC3, + 0xA, 0xC0, 0xC3, 0x3, 0x22, 0xC0, 0xC3, 0x8B, 0x1E, 0x56, 0x0, + 0x80, 0xFF, 0x1, 0x75, 0xB, 0xFE, 0xCB, 0xE8, 0xD7, 0xFE, 0x75, + 0x7, 0x8A, 0x3E, 0x29, 0x0, 0xE8, 0x90, 0x1C, 0xE9, 0xDE, 0xF9, + 0xC3, 0xD, 0x2, 0x6, 0x5, 0x3, 0xB, 0xC, 0x1C, 0x1D, 0x1E, + 0x1F, 0xE, 0x7F, 0x1B, 0x9, 0xA, 0x8, 0x12, 0x2, 0x6, 0x5, + 0x3, 0xD, 0xE, 0x7F, 0x1B, 0xFF, 0x34, 0x56, 0x34, 0xCA, 0x34, + 0x39, 0x33, 0xAF, 0x33, 0x7, 0x35, 0x25, 0x35, 0x4D, 0x35, 0x1, + 0x34, 0x77, 0x34, 0xF3, 0x32, 0xC1, 0x33, 0xE8, 0xD, 0xFD, 0x74, + 0xC8, 0x58, 0xB5, 0xFE, 0xBB, 0xF7, 0x1, 0xE8, 0x41, 0xF9, 0x88, + 0x7, 0x3C, 0xD, 0x74, 0x11, 0x3C, 0xA, 0x75, 0x6, 0x8A, 0xC5, + 0x3C, 0xFE, 0x74, 0xED, 0x43, 0xFE, 0xCD, 0x75, 0xE8, 0xFE, 0xCD, + 0x32, 0xC0, 0x88, 0x7, 0xBB, 0xF6, 0x1, 0xC3, 0xA0, 0x72, 0x0, + 0xA, 0xC0, 0x74, 0x3A, 0xE8, 0x61, 0xFE, 0x50, 0x87, 0xDA, 0xC6, + 0x7, 0x0, 0x87, 0xDA, 0xFE, 0xC3, 0xE8, 0x29, 0x3, 0xA0, 0x29, + 0x0, 0x2A, 0xC7, 0x74, 0xB, 0xFE, 0xC0, 0x50, 0xE8, 0xF5, 0x0, + 0x58, 0xFE, 0xC8, 0x75, 0xF7, 0x8B, 0x1E, 0x56, 0x0, 0xE8, 0x3B, + 0xFE, 0x58, 0x8A, 0xC8, 0x32, 0xC0, 0x8B, 0xFA, 0xAA, 0x42, 0x8A, + 0xC1, 0x8B, 0xFA, 0xAA, 0x32, 0xC0, 0xC3, 0xB0, 0xA, 0xA, 0xC0, + 0xC3, 0xE8, 0x5A, 0x2, 0xBA, 0xF7, 0x1, 0xB5, 0xFE, 0xA0, 0x58, + 0x0, 0x3A, 0xC3, 0xB7, 0x1, 0xA0, 0x29, 0x0, 0x75, 0x13, 0x8B, + 0x1E, 0x58, 0x0, 0x52, 0xE8, 0x9, 0xFE, 0x5A, 0xA0, 0x29, 0x0, + 0x74, 0x5, 0xA0, 0x5A, 0x0, 0xFE, 0xC8, 0xA2, 0x5A, 0x0, 0xE8, + 0x3C, 0x2, 0x8A, 0xC5, 0x22, 0xC0, 0x74, 0x10, 0x52, 0xE8, 0xEE, + 0xFD, 0x5A, 0x75, 0x9, 0xB7, 0x1, 0xFE, 0xC3, 0xA0, 0x29, 0x0, + 0xEB, 0xE4, 0x87, 0xDA, 0xB0, 0xFE, 0x2A, 0xC6, 0x8A, 0xF0, 0x4B, + 0x8A, 0x7, 0x3C, 0x20, 0x74, 0x8, 0xA, 0xC0, 0x75, 0x7, 0xFE, + 0xCE, 0x74, 0x3, 0x4B, 0xEB, 0xEF, 0x43, 0xC6, 0x7, 0x0, 0x87, + 0xDA, 0xB0, 0xD, 0x50, 0xB7, 0x1, 0xE8, 0x7C, 0x1B, 0xB0, 0xD, + 0xE8, 0xFC, 0xF7, 0xBB, 0xF6, 0x1, 0x58, 0xF9, 0xC3, 0x32, 0xC0, + 0xA2, 0xF7, 0x1, 0xE8, 0xA7, 0xFD, 0x75, 0x4, 0xFE, 0xC3, 0xEB, + 0xF7, 0xB0, 0x3, 0xEB, 0xDD, 0x8A, 0xC7, 0xFE, 0xC8, 0x24, 0xF8, + 0x4, 0x8, 0xFE, 0xC0, 0x8A, 0xE8, 0xA0, 0x29, 0x0, 0x3A, 0xC5, + 0x73, 0x2, 0x8A, 0xE8, 0x8A, 0xC5, 0xA0, 0x72, 0x0, 0xA, 0xC0, + 0x8A, 0xC5, 0x75, 0xC, 0x3A, 0xC7, 0x74, 0x5, 0x8A, 0xF8, 0xE8, + 0x36, 0x1B, 0x32, 0xC0, 0xC3, 0x2A, 0xC7, 0x74, 0xFB, 0x50, 0xA0, + 0x50, 0x0, 0xE8, 0x14, 0x0, 0xE8, 0xAA, 0xF7, 0x58, 0xFE, 0xC8, + 0x75, 0xF1, 0xC3, 0xA0, 0x72, 0x0, 0xF6, 0xD0, 0xA2, 0x72, 0x0, + 0x32, 0xC0, 0xC3, 0x53, 0x8B, 0x1E, 0x56, 0x0, 0x50, 0xA0, 0x72, + 0x0, 0xA, 0xC0, 0x74, 0x3, 0xE8, 0x3, 0x0, 0x58, 0x5B, 0xC3, + 0xA0, 0x58, 0x0, 0x3A, 0xC3, 0x75, 0x10, 0x53, 0xBB, 0x5A, 0x0, + 0xFE, 0x7, 0xA0, 0x29, 0x0, 0x3A, 0x7, 0x73, 0x2, 0x88, 0x7, + 0x5B, 0xA0, 0x50, 0x0, 0x8A, 0xC8, 0xE8, 0x8F, 0x1, 0x72, 0x10, + 0x74, 0xDC, 0x50, 0x32, 0xC0, 0xE8, 0x28, 0xFD, 0xFE, 0xC3, 0xE8, + 0xE6, 0x1, 0x58, 0xFE, 0xCB, 0xFE, 0xC3, 0xB7, 0x1, 0xEB, 0xE3, + 0x53, 0xA0, 0x29, 0x0, 0x3A, 0xC7, 0x75, 0xB, 0xB7, 0x0, 0xA0, + 0x5D, 0x0, 0x3A, 0xC3, 0x75, 0x0, 0xFE, 0xC3, 0xFE, 0xC7, 0xE8, + 0x9, 0x0, 0x5B, 0x53, 0xE8, 0xAD, 0x1A, 0x32, 0xC0, 0x5B, 0xC3, + 0xB0, 0x1, 0x3A, 0xC7, 0x74, 0x4, 0xFE, 0xCF, 0xEB, 0x14, 0x53, + 0xFE, 0xCB, 0x74, 0xE, 0xA0, 0x29, 0x0, 0x8A, 0xF8, 0xE8, 0xD0, + 0xFC, 0x75, 0x4, 0x5E, 0x87, 0xDE, 0x56, 0x5B, 0xE8, 0x88, 0x1A, + 0xA0, 0x58, 0x0, 0x3A, 0xC3, 0x75, 0xA, 0xA0, 0x5A, 0x0, 0xFE, + 0xC8, 0x74, 0x3, 0xA2, 0x5A, 0x0, 0xE8, 0x42, 0x1, 0x53, 0xE8, + 0xAE, 0xFC, 0x75, 0x11, 0xFE, 0xC3, 0xB7, 0x1, 0xE8, 0x5, 0x2, + 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0xFB, 0x1, 0x5B, 0xEB, 0xE6, 0x5B, + 0xE8, 0x55, 0x1A, 0x32, 0xC0, 0xC3, 0xE8, 0x91, 0xFC, 0x75, 0xB, + 0xA0, 0x5B, 0x0, 0x3A, 0xC3, 0x74, 0x4, 0xFE, 0xC3, 0xEB, 0xF0, + 0xA0, 0x29, 0x0, 0x8A, 0xF8, 0xA0, 0x50, 0x0, 0x8A, 0xC8, 0x51, + 0xE8, 0x22, 0x1A, 0x59, 0xA, 0xC0, 0x74, 0xC, 0x3A, 0xC1, 0x74, + 0x8, 0xFE, 0xC7, 0xE8, 0x2A, 0x1A, 0x32, 0xC0, 0xC3, 0xFE, 0xCF, + 0x74, 0xF4, 0xEB, 0xE5, 0xE8, 0x94, 0x0, 0xB7, 0x1, 0xE8, 0x19, + 0x1A, 0x53, 0xA0, 0x50, 0x0, 0xE8, 0xAD, 0x1, 0x5B, 0xFE, 0xC7, + 0xA0, 0x29, 0x0, 0xFE, 0xC0, 0x3A, 0xC7, 0x75, 0xED, 0xE8, 0x41, + 0xFC, 0x75, 0xA5, 0xB7, 0x1, 0xFE, 0xC3, 0xEB, 0xE2, 0xC6, 0x6, + 0x70, 0x0, 0x0, 0xEB, 0x8, 0xE8, 0xE5, 0x19, 0xE8, 0x4A, 0x1, + 0x72, 0xF, 0xE8, 0x40, 0x0, 0x74, 0x13, 0xEB, 0xF1, 0xE8, 0xD6, + 0x19, 0xE8, 0x3B, 0x1, 0x73, 0x7, 0xE8, 0x31, 0x0, 0x74, 0x4, + 0xEB, 0xF1, 0x32, 0xC0, 0xC3, 0x32, 0xC0, 0xA2, 0x70, 0x0, 0xEB, + 0x8, 0xE8, 0xBD, 0x19, 0xE8, 0x22, 0x1, 0x73, 0xF, 0xE8, 0x26, + 0x0, 0x74, 0xEB, 0xEB, 0xF1, 0xE8, 0xAE, 0x19, 0xE8, 0x13, 0x1, + 0x72, 0x7, 0xE8, 0x17, 0x0, 0x74, 0xDC, 0xEB, 0xF1, 0xE8, 0x2, + 0x0, 0xEB, 0xD3, 0x8B, 0x1E, 0x56, 0x0, 0xE8, 0xC4, 0xFA, 0x75, + 0xCC, 0xB7, 0x1, 0xE9, 0x96, 0xFA, 0x8B, 0x1E, 0x56, 0x0, 0xE8, + 0xDF, 0xFA, 0x75, 0xBE, 0xA0, 0x29, 0x0, 0x8A, 0xF8, 0xE9, 0x9A, + 0xFA, 0xFE, 0xCB, 0x74, 0x5, 0xE8, 0xC1, 0xFB, 0x74, 0xF7, 0xFE, + 0xC3, 0xC3, 0x51, 0xA0, 0x5A, 0x0, 0x3A, 0xC7, 0x72, 0x1A, 0xE8, + 0x67, 0x19, 0xE8, 0x16, 0x0, 0x8B, 0xFA, 0xAA, 0x42, 0x5E, 0x87, + 0xDE, 0x56, 0xFE, 0xCF, 0x5E, 0x87, 0xDE, 0x56, 0x74, 0x4, 0xFE, + 0xC7, 0xEB, 0xDF, 0x59, 0xC3, 0xA, 0xC0, 0x75, 0x2, 0xB0, 0x20, + 0xC3, 0xE8, 0x45, 0x0, 0x50, 0xE8, 0x8A, 0xFB, 0x74, 0x15, 0x58, + 0x22, 0xC0, 0x74, 0xF1, 0x3C, 0x20, 0x74, 0xED, 0xA0, 0x50, 0x0, + 0x3A, 0xC1, 0x74, 0xE6, 0x8A, 0xC1, 0x22, 0xC0, 0xC3, 0x58, 0xF9, + 0xC3, 0xA0, 0x29, 0x0, 0x3A, 0xC7, 0x74, 0x19, 0xFE, 0xC7, 0xE8, + 0xC4, 0x0, 0x53, 0xFE, 0xCF, 0xE8, 0xBB, 0x0, 0x5B, 0xFE, 0xC7, + 0xA0, 0x29, 0x0, 0xFE, 0xC0, 0x3A, 0xC7, 0x75, 0xEB, 0xFE, 0xCF, + 0xA0, 0x50, 0x0, 0xE8, 0xA7, 0x0, 0xC3, 0x53, 0x51, 0xE8, 0xA4, + 0x0, 0x59, 0x50, 0x8A, 0xC1, 0xE8, 0x9A, 0x0, 0x58, 0x8A, 0xC8, + 0xA0, 0x29, 0x0, 0xFE, 0xC0, 0xFE, 0xC7, 0x3A, 0xC7, 0x75, 0xE7, + 0x8A, 0xC1, 0x5B, 0xC3, 0x53, 0xA0, 0x5C, 0x0, 0x2A, 0xC3, 0x72, + 0x2F, 0x74, 0x22, 0x8B, 0x1E, 0x5B, 0x0, 0x5E, 0x87, 0xDE, 0x56, + 0x53, 0x8A, 0xC3, 0xA2, 0x5B, 0x0, 0xA0, 0x5D, 0x0, 0xA2, 0x5C, + 0x0, 0xE8, 0x5A, 0xFA, 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0x89, 0x1E, + 0x5B, 0x0, 0x5B, 0x53, 0xB7, 0x1, 0xE8, 0xF9, 0x18, 0x5B, 0xB0, + 0x1, 0xE9, 0x6, 0xFB, 0x8B, 0x1E, 0x56, 0x0, 0xFE, 0xCB, 0x74, + 0x3, 0xE8, 0xAB, 0x18, 0xE8, 0xFE, 0xF9, 0x5B, 0xFE, 0xCB, 0xC3, + 0x3C, 0x30, 0x72, 0xFB, 0x3C, 0x3A, 0x72, 0x12, 0x3C, 0x41, 0x72, + 0xF3, 0x3C, 0x5B, 0x72, 0xA, 0x3C, 0x61, 0x72, 0xEB, 0x3C, 0x7B, + 0x72, 0x2, 0xF9, 0xC3, 0x22, 0xC0, 0xC3, 0x53, 0xB7, 0x1, 0xA0, + 0x29, 0x0, 0x8A, 0xE8, 0x51, 0xE8, 0x65, 0x18, 0x59, 0x3C, 0xFF, + 0x74, 0x8, 0xFE, 0xC7, 0xFE, 0xCD, 0x75, 0xF1, 0x5B, 0xC3, 0x5B, + 0x53, 0xB7, 0x1, 0xE8, 0xA4, 0x18, 0x5B, 0xC3, 0xE9, 0x43, 0x18, + 0xE9, 0x49, 0x18, 0xA2, 0x28, 0x0, 0x8B, 0x1E, 0x47, 0x3, 0xA, + 0xC7, 0x22, 0xC3, 0xFE, 0xC0, 0x87, 0xDA, 0x74, 0xE8, 0xEB, 0x13, + 0xBB, 0xF6, 0x1, 0x74, 0xE1, 0xF9, 0x9C, 0x43, 0xE9, 0x75, 0xD2, + 0xE8, 0x7C, 0xD9, 0x74, 0x3, 0xE9, 0x72, 0xD9, 0x5B, 0x89, 0x16, + 0x49, 0x3, 0xE8, 0x78, 0xD3, 0x72, 0x3, 0xE9, 0x3C, 0xDA, 0x8B, + 0xD9, 0x43, 0x43, 0x8B, 0x17, 0x43, 0x43, 0x53, 0x87, 0xDA, 0xE8, + 0x4E, 0x2E, 0x5B, 0x8A, 0x7, 0x3C, 0x9, 0x74, 0x5, 0xB0, 0x20, + 0xE8, 0x97, 0xF4, 0xE8, 0xBC, 0xE8, 0xBB, 0xF7, 0x1, 0xE8, 0xA9, + 0xE8, 0xE8, 0x5F, 0xFB, 0x8B, 0x1E, 0x56, 0x0, 0xFE, 0xCB, 0x74, + 0x9, 0xFE, 0xCB, 0x74, 0x5, 0xE8, 0x35, 0xFA, 0x74, 0xF7, 0xFE, + 0xC3, 0xE8, 0xF0, 0x17, 0xE9, 0xA0, 0xD1, 0x3C, 0xA, 0x74, 0x3, + 0xE9, 0x6B, 0xF4, 0x53, 0x8B, 0x1E, 0xE9, 0x4, 0x8A, 0xC7, 0xA, + 0xC3, 0x5B, 0xB0, 0xA, 0x75, 0x8, 0x50, 0xB0, 0xD, 0xE8, 0x57, + 0xF4, 0x58, 0xC3, 0xE8, 0x52, 0xF4, 0xB0, 0xD, 0xE8, 0x4D, 0xF4, + 0xB0, 0xA, 0xC3, 0x4B, 0xE8, 0xBE, 0xD7, 0x75, 0x1, 0xC3, 0xE8, + 0x8F, 0xF6, 0x2C, 0xB9, 0x5B, 0x37, 0x51, 0xB0, 0xC8, 0xEB, 0x2, + 0x32, 0xC0, 0xA2, 0xFA, 0x2, 0x8A, 0xF, 0xCD, 0xB3, 0xE8, 0xC9, + 0xF7, 0x73, 0x3, 0xE9, 0x3F, 0xD0, 0x32, 0xC0, 0x8A, 0xE8, 0xA2, + 0x8E, 0x0, 0x43, 0x8A, 0x7, 0x3C, 0x2E, 0x72, 0x42, 0x74, 0xD, + 0x3C, 0x3A, 0x73, 0x4, 0x3C, 0x30, 0x73, 0x5, 0xE8, 0xAB, 0xF7, + 0x72, 0x33, 0x8A, 0xE8, 0x51, 0xB5, 0xFF, 0xBA, 0x8E, 0x0, 0xC, + 0x80, 0xFE, 0xC5, 0x8B, 0xFA, 0xAA, 0x42, 0x43, 0x8A, 0x7, 0x3C, + 0x3A, 0x73, 0x4, 0x3C, 0x30, 0x73, 0xED, 0xE8, 0x8B, 0xF7, 0x73, + 0xE8, 0x3C, 0x2E, 0x74, 0xE4, 0x8A, 0xC5, 0x3C, 0x27, 0x72, 0x3, + 0xE9, 0xF5, 0xCF, 0x59, 0xA2, 0x8E, 0x0, 0x8A, 0x7, 0x3C, 0x26, + 0x73, 0x1E, 0xBA, 0x3, 0x38, 0x52, 0xB6, 0x2, 0x3C, 0x25, 0x74, + 0x84, 0xFE, 0xC6, 0x3C, 0x24, 0x75, 0x1, 0xC3, 0xFE, 0xC6, 0x3C, + 0x21, 0x74, 0xF9, 0xB6, 0x8, 0x3C, 0x23, 0x74, 0xF3, 0x58, 0x8A, + 0xC1, 0x24, 0x7F, 0x8A, 0xD0, 0xB6, 0x0, 0x53, 0xBB, 0x1F, 0x3, + 0x3, 0xDA, 0x8A, 0x37, 0x5B, 0x4B, 0x8A, 0xC6, 0xA2, 0xFB, 0x2, + 0xE8, 0x12, 0xD7, 0xA0, 0x39, 0x3, 0xFE, 0xC8, 0x75, 0x3, 0xE9, + 0x7A, 0x1, 0x78, 0x3, 0xE9, 0x10, 0x0, 0x8A, 0x7, 0x2C, 0x28, + 0x75, 0x3, 0xE9, 0xCD, 0x0, 0x2C, 0x33, 0x75, 0x3, 0xE9, 0xC6, + 0x0, 0x32, 0xC0, 0xA2, 0x39, 0x3, 0x53, 0xA0, 0x4D, 0x4, 0xA, + 0xC0, 0xA2, 0x4A, 0x4, 0x74, 0x1E, 0x8B, 0x1E, 0x7C, 0x3, 0xBA, + 0x7E, 0x3, 0x3, 0xDA, 0x89, 0x1E, 0x4B, 0x4, 0x87, 0xDA, 0xE9, + 0xF7, 0x2D, 0xA0, 0x4A, 0x4, 0xA, 0xC0, 0x74, 0x24, 0x32, 0xC0, + 0xA2, 0x4A, 0x4, 0x8B, 0x1E, 0x5A, 0x3, 0x89, 0x1E, 0x4B, 0x4, + 0x8B, 0x1E, 0x58, 0x3, 0xE9, 0xDC, 0x2D, 0xE8, 0x4, 0xFF, 0xC3, + 0x32, 0xC0, 0x8A, 0xF0, 0x8A, 0xD0, 0x59, 0x5E, 0x87, 0xDE, 0x56, + 0xC3, 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0x52, 0xBA, 0x6A, 0x38, 0x3B, + 0xDA, 0x74, 0xE7, 0xBA, 0xDA, 0x19, 0x3B, 0xDA, 0x5A, 0x74, 0x49, + 0x5E, 0x87, 0xDE, 0x56, 0x53, 0x51, 0xA0, 0xFB, 0x2, 0x8A, 0xE8, + 0xA0, 0x8E, 0x0, 0x2, 0xC5, 0xFE, 0xC0, 0x8A, 0xC8, 0x51, 0xB5, + 0x0, 0x41, 0x41, 0x41, 0x8B, 0x1E, 0x5C, 0x3, 0x53, 0x3, 0xD9, + 0x59, 0x53, 0xE8, 0x19, 0x2C, 0x5B, 0x89, 0x1E, 0x5C, 0x3, 0x8B, + 0xD9, 0x89, 0x1E, 0x5A, 0x3, 0x4B, 0xC6, 0x7, 0x0, 0x3B, 0xDA, + 0x75, 0xF8, 0x5A, 0x88, 0x37, 0x43, 0x5A, 0x89, 0x17, 0x43, 0xE8, + 0xDD, 0x1, 0x87, 0xDA, 0x42, 0x5B, 0xC3, 0xE8, 0x86, 0x42, 0xEB, + 0x8, 0xC6, 0x6, 0x4F, 0x3, 0x0, 0xE9, 0x78, 0xA, 0xE8, 0x40, + 0xE2, 0x75, 0x7, 0xBB, 0x6, 0x0, 0x89, 0x1E, 0xA3, 0x4, 0x5B, + 0xC3, 0x53, 0x8B, 0x1E, 0xFA, 0x2, 0x5E, 0x87, 0xDE, 0x56, 0x8A, + 0xF0, 0x52, 0x51, 0xBA, 0x8E, 0x0, 0x8B, 0xF2, 0xAC, 0xA, 0xC0, + 0x74, 0x3D, 0x87, 0xDA, 0x4, 0x2, 0xD0, 0xD8, 0x8A, 0xC8, 0xE8, + 0xC3, 0xF3, 0x8A, 0xC1, 0x8A, 0xF, 0x43, 0x8A, 0x2F, 0x43, 0x51, + 0xFE, 0xC8, 0x75, 0xF5, 0x53, 0xA0, 0x8E, 0x0, 0x50, 0x87, 0xDA, + 0xE8, 0x28, 0xD7, 0x58, 0x89, 0x1E, 0xB5, 0x0, 0x5B, 0x4, 0x2, + 0xD0, 0xD8, 0x59, 0x4B, 0x88, 0x2F, 0x4B, 0x88, 0xF, 0xFE, 0xC8, + 0x75, 0xF5, 0x8B, 0x1E, 0xB5, 0x0, 0xEB, 0x8, 0xE8, 0xA, 0xD7, + 0x32, 0xC0, 0xA2, 0x8E, 0x0, 0xA0, 0x5C, 0x4, 0xA, 0xC0, 0x74, + 0x8, 0xB, 0xD2, 0x75, 0x3, 0xE9, 0x5F, 0x0, 0x4A, 0x59, 0x58, + 0x86, 0xC4, 0x9E, 0x87, 0xDA, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0x87, + 0xDA, 0xFE, 0xC0, 0x8A, 0xF0, 0x8A, 0x7, 0x3C, 0x2C, 0x74, 0x88, + 0x3C, 0x29, 0x74, 0x7, 0x3C, 0x5D, 0x74, 0x3, 0xE9, 0x40, 0xCE, + 0xE8, 0x9C, 0xD5, 0x89, 0x1E, 0x52, 0x3, 0x5B, 0x89, 0x1E, 0xFA, + 0x2, 0xB2, 0x0, 0x52, 0xEB, 0x7, 0x53, 0x9F, 0x86, 0xC4, 0x50, + 0x86, 0xC4, 0x8B, 0x1E, 0x5A, 0x3, 0xE9, 0xAF, 0x2C, 0xA0, 0xFA, + 0x2, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0x20, 0xCE, 0x58, 0x86, 0xC4, + 0x9E, 0x8B, 0xCB, 0x75, 0x3, 0xE9, 0x55, 0x2B, 0x2A, 0x7, 0x75, + 0x3, 0xE9, 0x98, 0x0, 0xBA, 0x9, 0x0, 0xE9, 0x19, 0xCE, 0xA0, + 0xFB, 0x2, 0x88, 0x7, 0x43, 0x8A, 0xD0, 0xB6, 0x0, 0x58, 0x86, + 0xC4, 0x9E, 0x75, 0x3, 0xE9, 0xCA, 0x0, 0x88, 0xF, 0x43, 0x88, + 0x2F, 0xE8, 0xD3, 0x0, 0x43, 0x8A, 0xC8, 0xE8, 0xF5, 0xF2, 0x43, + 0x43, 0x89, 0x1E, 0x31, 0x3, 0x88, 0xF, 0x43, 0xA0, 0xFA, 0x2, + 0xD0, 0xD0, 0x8A, 0xC1, 0x72, 0xF, 0x9F, 0x50, 0xA0, 0x5C, 0x4, + 0x34, 0xB, 0x8A, 0xC8, 0xB5, 0x0, 0x58, 0x9E, 0x73, 0x4, 0x59, + 0x9F, 0x41, 0x9E, 0x88, 0xF, 0x9F, 0x50, 0x43, 0x88, 0x2F, 0x43, + 0xE8, 0x7A, 0x2A, 0x58, 0x9E, 0xFE, 0xC8, 0x75, 0xDA, 0x9F, 0x50, + 0x8A, 0xEE, 0x8A, 0xCA, 0x87, 0xDA, 0x3, 0xDA, 0x73, 0x3, 0xE9, + 0xCF, 0xF2, 0xE8, 0xDC, 0xF2, 0x89, 0x1E, 0x5C, 0x3, 0x4B, 0xC6, + 0x7, 0x0, 0x3B, 0xDA, 0x75, 0xF8, 0x32, 0xC0, 0x41, 0x8A, 0xF0, + 0x8B, 0x1E, 0x31, 0x3, 0x8A, 0x17, 0x87, 0xDA, 0x3, 0xDB, 0x3, + 0xD9, 0x87, 0xDA, 0x4B, 0x4B, 0x89, 0x17, 0x43, 0x43, 0x58, 0x9E, + 0x72, 0x46, 0x8A, 0xE8, 0x8A, 0xC8, 0x8A, 0x7, 0x43, 0xB6, 0x5B, + 0x8B, 0x17, 0x43, 0x43, 0x5E, 0x87, 0xDE, 0x56, 0x50, 0x3B, 0xDA, + 0x72, 0x3, 0xE9, 0x4F, 0xFF, 0xE8, 0x1D, 0x2A, 0x3, 0xDA, 0x58, + 0xFE, 0xC8, 0x8B, 0xCB, 0x75, 0xE3, 0xA0, 0xFB, 0x2, 0x8B, 0xCB, + 0x3, 0xDB, 0x2C, 0x4, 0x72, 0x8, 0x3, 0xDB, 0xA, 0xC0, 0x74, + 0xB, 0x3, 0xDB, 0xA, 0xC0, 0x7A, 0x3, 0xE9, 0x2, 0x0, 0x3, + 0xD9, 0x59, 0x3, 0xD9, 0x87, 0xDA, 0x8B, 0x1E, 0x52, 0x3, 0xC3, + 0xF9, 0x1A, 0xC0, 0x5B, 0xC3, 0x8A, 0x7, 0x43, 0x51, 0xB5, 0x0, + 0x8A, 0xC8, 0x3, 0xD9, 0x59, 0xC3, 0x51, 0x52, 0x9F, 0x50, 0xBA, + 0x8E, 0x0, 0x8B, 0xF2, 0xAC, 0x8A, 0xE8, 0xFE, 0xC5, 0x8B, 0xF2, + 0xAC, 0x42, 0x43, 0x88, 0x7, 0xFE, 0xCD, 0x75, 0xF5, 0x58, 0x9E, + 0x5A, 0x59, 0xC3, 0xE8, 0x5A, 0xDC, 0xE8, 0x6A, 0x29, 0xE8, 0x20, + 0xF3, 0x3B, 0x87, 0xDA, 0x8B, 0x1E, 0xA3, 0x4, 0xEB, 0xA, 0xA0, + 0x3A, 0x3, 0xA, 0xC0, 0x74, 0x11, 0x5A, 0x87, 0xDA, 0x53, 0x32, + 0xC0, 0xA2, 0x3A, 0x3, 0xFE, 0xC0, 0x9C, 0x52, 0x8A, 0x2F, 0xA, + 0xED, 0x75, 0x3, 0xE9, 0x5F, 0xD5, 0x43, 0x8B, 0x1F, 0xEB, 0x24, + 0x8A, 0xD5, 0x53, 0xB1, 0x2, 0x8A, 0x7, 0x43, 0x3C, 0x5C, 0x75, + 0x3, 0xE9, 0x9D, 0x1, 0x3C, 0x20, 0x75, 0x6, 0xFE, 0xC1, 0xFE, + 0xCD, 0x75, 0xEC, 0x5B, 0x8A, 0xEA, 0xB0, 0x5C, 0xE8, 0xD6, 0x1, + 0xE8, 0x82, 0xF0, 0x32, 0xC0, 0x8A, 0xD0, 0x8A, 0xF0, 0xE8, 0xCA, + 0x1, 0x8A, 0xF0, 0x8A, 0x7, 0x43, 0x3C, 0x21, 0x75, 0x3, 0xE9, + 0x6F, 0x1, 0x3C, 0x23, 0x74, 0x52, 0x3C, 0x26, 0x75, 0x3, 0xE9, + 0x60, 0x1, 0xFE, 0xCD, 0x75, 0x3, 0xE9, 0x2E, 0x1, 0x3C, 0x2B, + 0xB0, 0x8, 0x74, 0xD9, 0x4B, 0x8A, 0x7, 0x43, 0x3C, 0x2E, 0x74, + 0x55, 0x3C, 0x5F, 0x75, 0x3, 0xE9, 0x37, 0x1, 0x3C, 0x5C, 0x74, + 0x9C, 0x3A, 0x7, 0x75, 0xB6, 0x3C, 0x24, 0x74, 0x18, 0x3C, 0x2A, + 0x75, 0xAE, 0x8A, 0xC5, 0x43, 0x3C, 0x2, 0x72, 0x4, 0x8A, 0x7, + 0x3C, 0x24, 0xB0, 0x20, 0x75, 0xA, 0xFE, 0xCD, 0xFE, 0xC2, 0xBE, + 0x32, 0xC0, 0x4, 0x10, 0x43, 0xFE, 0xC2, 0x2, 0xC6, 0x8A, 0xF0, + 0xFE, 0xC2, 0xB1, 0x0, 0xFE, 0xCD, 0x74, 0x61, 0x8A, 0x7, 0x43, + 0x3C, 0x2E, 0x74, 0x1E, 0x3C, 0x23, 0x74, 0xED, 0x3C, 0x2C, 0x75, + 0x23, 0x8A, 0xC6, 0xC, 0x40, 0x8A, 0xF0, 0xEB, 0xE1, 0x8A, 0x7, + 0x3C, 0x23, 0xB0, 0x2E, 0x74, 0x3, 0xE9, 0x65, 0xFF, 0xB1, 0x1, + 0x43, 0xFE, 0xC1, 0xFE, 0xCD, 0x74, 0x36, 0x8A, 0x7, 0x43, 0x3C, + 0x23, 0x74, 0xF3, 0x52, 0xBA, 0xF4, 0x3B, 0x52, 0x8A, 0xF7, 0x8A, + 0xD3, 0x3C, 0x5E, 0x74, 0x1, 0xC3, 0x3A, 0x7, 0x75, 0xFB, 0x43, + 0x3A, 0x7, 0x75, 0xF6, 0x43, 0x3A, 0x7, 0x75, 0xF1, 0x43, 0x8A, + 0xC5, 0x2C, 0x4, 0x72, 0xEA, 0x5A, 0x5A, 0x8A, 0xE8, 0xFE, 0xC6, + 0x43, 0xEB, 0x3, 0x87, 0xDA, 0x5A, 0x8A, 0xC6, 0x4B, 0xFE, 0xC2, + 0x24, 0x8, 0x75, 0x1C, 0xFE, 0xCA, 0x8A, 0xC5, 0xA, 0xC0, 0x74, + 0x14, 0x8A, 0x7, 0x2C, 0x2D, 0x74, 0x6, 0x3C, 0xFE, 0x75, 0xA, + 0xB0, 0x8, 0x4, 0x4, 0x2, 0xC6, 0x8A, 0xF0, 0xFE, 0xCD, 0x5B, + 0x9D, 0x74, 0x65, 0x51, 0x52, 0xE8, 0x2, 0xDB, 0x5A, 0x59, 0x51, + 0x53, 0x8A, 0xEA, 0x8A, 0xC5, 0x2, 0xC1, 0x3C, 0x19, 0x72, 0x3, + 0xE9, 0x23, 0xD4, 0x8A, 0xC6, 0xC, 0x80, 0xE8, 0x5C, 0x3B, 0xE8, + 0x77, 0xEA, 0x5B, 0x4B, 0xE8, 0xD8, 0xD2, 0xF9, 0x74, 0x11, 0xA2, + 0x3A, 0x3, 0x3C, 0x3B, 0x74, 0x7, 0x3C, 0x2C, 0x74, 0x3, 0xE9, + 0x68, 0xCB, 0xE8, 0xC4, 0xD2, 0x59, 0x87, 0xDA, 0x5B, 0x53, 0x9C, + 0x52, 0x8A, 0x7, 0x2A, 0xC5, 0x43, 0xB6, 0x0, 0x8A, 0xD0, 0x8B, + 0x1F, 0x3, 0xDA, 0x8A, 0xC5, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0xAD, + 0xFE, 0xEB, 0x6, 0xE8, 0x7B, 0x0, 0xE8, 0x27, 0xEF, 0x5B, 0x9D, + 0x74, 0x3, 0xE9, 0x58, 0xFE, 0x73, 0x3, 0xE8, 0xE7, 0xEF, 0x5E, + 0x87, 0xDE, 0x56, 0xE8, 0x1C, 0xEC, 0x5B, 0xE9, 0x3, 0xD8, 0xC3, + 0xE8, 0x5D, 0x0, 0xFE, 0xCD, 0x8A, 0x7, 0x43, 0xE8, 0x4, 0xEF, + 0xEB, 0xCA, 0xB1, 0x0, 0xEB, 0x5, 0xB1, 0x1, 0xEB, 0x1, 0x58, + 0xFE, 0xCD, 0xE8, 0x45, 0x0, 0x5B, 0x9D, 0x74, 0xD0, 0x51, 0xE8, + 0x6E, 0xDA, 0xE8, 0x7F, 0x27, 0x59, 0x51, 0x53, 0x8B, 0x1E, 0xA3, + 0x4, 0x8A, 0xE9, 0xB1, 0x0, 0x8A, 0xC5, 0x50, 0x8A, 0xC5, 0xA, + 0xC0, 0x74, 0x3, 0xE8, 0xA1, 0xEC, 0xE8, 0xE4, 0xE9, 0x8B, 0x1E, + 0xA3, 0x4, 0x58, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x5E, 0xFF, 0x2A, + 0x7, 0x8A, 0xE8, 0xB0, 0x20, 0xFE, 0xC5, 0xFE, 0xCD, 0x75, 0x3, + 0xE9, 0x4F, 0xFF, 0xE8, 0xB1, 0xEE, 0xEB, 0xF4, 0x50, 0x8A, 0xC6, + 0xA, 0xC0, 0xB0, 0x2B, 0x74, 0x3, 0xE8, 0xA3, 0xEE, 0x58, 0xC3, + 0x89, 0x1E, 0x35, 0x3, 0xE8, 0xEC, 0xE7, 0xE8, 0xF, 0xD2, 0x87, + 0xDA, 0xE8, 0x66, 0x0, 0x9F, 0x44, 0x9E, 0x9F, 0x44, 0x9E, 0x75, + 0x8, 0x3, 0xD9, 0x8B, 0xE3, 0x89, 0x1E, 0x45, 0x3, 0x8B, 0x1E, + 0x2E, 0x0, 0x53, 0x8B, 0x1E, 0x35, 0x3, 0x53, 0x52, 0xEB, 0x28, + 0x74, 0x3, 0xE9, 0x89, 0xCA, 0x87, 0xDA, 0xE8, 0x3F, 0x0, 0x75, + 0x67, 0x8B, 0xE3, 0x89, 0x1E, 0x45, 0x3, 0x8B, 0x16, 0x2E, 0x0, + 0x89, 0x16, 0x5A, 0x4, 0x43, 0x43, 0x8B, 0x17, 0x43, 0x43, 0x8B, + 0x1F, 0x89, 0x1E, 0x2E, 0x0, 0x87, 0xDA, 0xE8, 0xCC, 0xD9, 0x53, + 0xE8, 0x84, 0x27, 0x5B, 0x74, 0x9, 0xB9, 0xB1, 0x0, 0x8A, 0xE9, + 0x51, 0xE9, 0x7D, 0xD1, 0x8B, 0x1E, 0x5A, 0x4, 0x89, 0x1E, 0x2E, + 0x0, 0x5B, 0x59, 0x59, 0xE9, 0x6F, 0xD1, 0xBB, 0x4, 0x0, 0x3, + 0xDC, 0x43, 0x8A, 0x7, 0x43, 0xB9, 0x82, 0x0, 0x3A, 0xC1, 0x75, + 0x7, 0xB9, 0x12, 0x0, 0x3, 0xD9, 0xEB, 0xEE, 0xB9, 0xB1, 0x0, + 0x3A, 0xC1, 0x74, 0x1, 0xC3, 0x39, 0x17, 0xB9, 0x6, 0x0, 0x74, + 0xF8, 0x3, 0xD9, 0xEB, 0xDB, 0xBA, 0x1E, 0x0, 0xE9, 0x2F, 0xCA, + 0xE8, 0x3A, 0x7, 0x4B, 0xE8, 0x6D, 0xD1, 0x74, 0x55, 0xE8, 0x72, + 0xD9, 0x53, 0xE8, 0x6C, 0xDD, 0x74, 0x3D, 0xE8, 0xA, 0x33, 0xE8, + 0x8B, 0xE8, 0x8B, 0x1E, 0xA3, 0x4, 0x43, 0x8A, 0x17, 0x43, 0x8A, + 0x37, 0x8B, 0xF2, 0xAC, 0x3C, 0x20, 0x75, 0x9, 0x42, 0x88, 0x37, + 0x4B, 0x88, 0x17, 0x4B, 0xFE, 0xF, 0xE8, 0xDC, 0xE8, 0x5B, 0x4B, + 0xE8, 0x3A, 0xD1, 0x74, 0x22, 0x3C, 0x3B, 0x74, 0x5, 0xE8, 0x8, + 0xF0, 0x2C, 0x4B, 0xE8, 0x2C, 0xD1, 0xB0, 0x2C, 0xE8, 0xAF, 0xED, + 0xEB, 0xBA, 0xB0, 0x22, 0xE8, 0xA8, 0xED, 0xE8, 0xBA, 0xE8, 0xB0, + 0x22, 0xE8, 0xA0, 0xED, 0xEB, 0xD7, 0xE8, 0x67, 0xEE, 0xE9, 0x8B, + 0xD6, 0xCD, 0xA8, 0x53, 0x8A, 0xF2, 0xE8, 0x87, 0x1, 0x74, 0x9, + 0x3C, 0x3A, 0x74, 0xF, 0xE8, 0x7E, 0x1, 0x79, 0xF7, 0x8A, 0xD6, + 0x5B, 0x32, 0xC0, 0xB0, 0xFC, 0xCD, 0xAB, 0xC3, 0x8A, 0xC6, 0x2A, + 0xC2, 0xFE, 0xC8, 0x3C, 0x2, 0x73, 0x5, 0xCD, 0xAC, 0xE9, 0x61, + 0xC9, 0x3C, 0x5, 0x72, 0x3, 0xE9, 0x5A, 0xC9, 0x59, 0x52, 0x51, + 0x8A, 0xC8, 0x8A, 0xE8, 0xBA, 0x9C, 0x3E, 0x5E, 0x87, 0xDE, 0x56, + 0x53, 0x8A, 0x7, 0x3C, 0x61, 0x72, 0x6, 0x3C, 0x7B, 0x73, 0x2, + 0x2C, 0x20, 0x51, 0x8A, 0xE8, 0x8B, 0xF2, 0x2E, 0xAC, 0x43, 0x42, + 0x3A, 0xC5, 0x59, 0x75, 0x15, 0xFE, 0xC9, 0x75, 0xE2, 0x8B, 0xF2, + 0x2E, 0xAC, 0xA, 0xC0, 0x78, 0x3, 0xE9, 0x6, 0x0, 0x5B, 0x5B, + 0x5A, 0xA, 0xC0, 0xC3, 0xA, 0xC0, 0x78, 0xEB, 0x8B, 0xF2, 0x2E, + 0xAC, 0xA, 0xC0, 0x9F, 0x42, 0x9E, 0x79, 0xF5, 0x8A, 0xCD, 0x5B, + 0x53, 0x8B, 0xF2, 0x2E, 0xAC, 0xA, 0xC0, 0x75, 0xB6, 0xE9, 0xFE, + 0xC8, 0x4B, 0x59, 0x42, 0x44, 0xFF, 0x53, 0x43, 0x52, 0x4E, 0xFE, + 0x4C, 0x50, 0x54, 0x31, 0xFD, 0x43, 0x41, 0x53, 0x31, 0xFC, 0x0, + 0x7B, 0x58, 0x91, 0x58, 0xA7, 0x58, 0xBD, 0x58, 0xCD, 0xA9, 0x53, + 0x52, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0xBA, 0x2E, 0x0, 0x3, + 0xDA, 0xB0, 0xFF, 0x2A, 0x7, 0x2, 0xC0, 0x8A, 0xD0, 0xCD, 0xAA, + 0xB6, 0x0, 0xBB, 0xB1, 0x3E, 0x3, 0xDA, 0x2E, 0x8A, 0x17, 0x43, + 0x2E, 0x8A, 0x37, 0x58, 0x86, 0xC4, 0x9E, 0x8A, 0xD8, 0xB7, 0x0, + 0x3, 0xDA, 0x2E, 0x8A, 0x17, 0x43, 0x2E, 0x8A, 0x37, 0x87, 0xDA, + 0x5A, 0x5E, 0x87, 0xDE, 0x56, 0xC3, 0x47, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xE8, + 0x11, 0xD8, 0x53, 0xE8, 0x8C, 0xE9, 0x8A, 0x7, 0xA, 0xC0, 0x74, + 0x4F, 0x43, 0x8A, 0x17, 0x43, 0x8A, 0x3F, 0x8A, 0xDA, 0x8A, 0xD0, + 0x32, 0xC0, 0xA2, 0xFF, 0x6, 0xE8, 0xDB, 0xFE, 0x9F, 0x86, 0xC4, + 0x50, 0x86, 0xC4, 0xB9, 0xF0, 0x4, 0xB6, 0xB, 0xFE, 0xC2, 0xFE, + 0xCA, 0x74, 0x4D, 0x8A, 0x7, 0x3C, 0x20, 0x72, 0x26, 0x3C, 0x2E, + 0x74, 0x28, 0x8B, 0xF9, 0xAA, 0x41, 0x43, 0xFE, 0xCE, 0x75, 0xE9, + 0x58, 0x86, 0xC4, 0x9E, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x8A, + 0xF0, 0xA0, 0xF0, 0x4, 0xFE, 0xC0, 0x74, 0x6, 0x58, 0x86, 0xC4, + 0x9E, 0x5B, 0xC3, 0xE9, 0x28, 0xC8, 0x43, 0xEB, 0xCA, 0xB0, 0x1, + 0xA2, 0xFF, 0x6, 0x8A, 0xC6, 0x3C, 0xB, 0x74, 0xEF, 0x3C, 0x3, + 0x72, 0xEB, 0x74, 0xEC, 0xB0, 0x20, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, + 0xCE, 0xEB, 0xEA, 0xB0, 0x20, 0x8B, 0xF9, 0xAA, 0x41, 0xFE, 0xCE, + 0x75, 0xF6, 0xEB, 0xBA, 0x8A, 0x7, 0x43, 0xFE, 0xCA, 0xC3, 0xE8, + 0x7A, 0xDF, 0x8A, 0xD8, 0xA0, 0xDF, 0x4, 0x3A, 0xC3, 0x73, 0x3, + 0xE9, 0xE9, 0xC7, 0xB7, 0x0, 0x3, 0xDB, 0x87, 0xDA, 0x8B, 0x1E, + 0xE0, 0x4, 0x3, 0xDA, 0x8B, 0x1F, 0xA0, 0x36, 0x5, 0xFE, 0xC0, + 0x74, 0xDB, 0x8A, 0x7, 0xA, 0xC0, 0x74, 0xD5, 0x53, 0xBA, 0x2E, + 0x0, 0x3, 0xDA, 0x8A, 0x7, 0x3C, 0x9, 0x73, 0x5, 0xCD, 0xDC, + 0xE9, 0xC0, 0xC7, 0x5B, 0x8A, 0x7, 0xA, 0xC0, 0xF9, 0xC3, 0x4B, + 0xE8, 0x35, 0xCF, 0x3C, 0x23, 0x75, 0x3, 0xE8, 0x2E, 0xCF, 0xE8, + 0x2A, 0xDF, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0xE8, 0xAB, 0xFF, 0x75, + 0x3, 0xE9, 0x9B, 0xC7, 0x89 +}; + +#ifdef MEGA + const uint8_t BASICH[16384] PROGMEM = { +#else + const uint8_t BASICH[16384] = { +#endif + 0x1E, 0xE9, 0x4, 0xC3, 0xB9, 0x98, 0x14, 0x51, 0xE8, 0x1C, 0xD7, + 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0x59, 0x53, 0xE8, 0x91, 0xE8, 0x8A, + 0x7, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x7C, 0xC7, 0x43, 0x8B, 0x1F, + 0x8A, 0x7, 0x24, 0xDF, 0xB2, 0x1, 0x3C, 0x49, 0x74, 0x15, 0xB2, + 0x2, 0x3C, 0x4F, 0x74, 0xF, 0xB2, 0x4, 0x3C, 0x52, 0x74, 0x9, + 0xB2, 0x8, 0x3C, 0x41, 0x74, 0x3, 0xE9, 0x54, 0xC7, 0x5B, 0x52, + 0xE8, 0xAF, 0xED, 0x2C, 0x3C, 0x23, 0x75, 0x3, 0xE8, 0xD0, 0xCE, + 0xE8, 0xCC, 0xDE, 0xE8, 0xA1, 0xED, 0x2C, 0x8A, 0xC2, 0xA, 0xC0, + 0x75, 0x3, 0xE9, 0x3D, 0xC7, 0x50, 0xE8, 0xB2, 0xFE, 0x58, 0x59, + 0x8A, 0xD1, 0xCD, 0xDD, 0xE9, 0x83, 0x0, 0xE8, 0xA9, 0xFE, 0x8A, + 0x7, 0x3C, 0x82, 0xB2, 0x4, 0x75, 0x59, 0xE8, 0xA5, 0xCE, 0x3C, + 0x85, 0xB2, 0x1, 0x74, 0x4D, 0x3C, 0x4F, 0x74, 0x20, 0x3C, 0x49, + 0x74, 0x37, 0xE8, 0x6B, 0xED, 0x41, 0xE8, 0x67, 0xED, 0x50, 0xE8, + 0x63, 0xED, 0x50, 0xE8, 0x5F, 0xED, 0x45, 0xE8, 0x5B, 0xED, 0x4E, + 0xE8, 0x57, 0xED, 0x44, 0xB2, 0x8, 0xEB, 0x2C, 0xE8, 0x78, 0xCE, + 0xE8, 0x4C, 0xED, 0x55, 0xE8, 0x48, 0xED, 0x54, 0xE8, 0x44, 0xED, + 0x50, 0xE8, 0x40, 0xED, 0x55, 0xE8, 0x3C, 0xED, 0x54, 0xB2, 0x2, + 0xEB, 0x11, 0xE8, 0x5D, 0xCE, 0xE8, 0x31, 0xED, 0x42, 0xE8, 0x2D, + 0xED, 0x4D, 0xB2, 0x20, 0x4B, 0xE8, 0x4F, 0xCE, 0xE8, 0x23, 0xED, + 0x41, 0xE8, 0x1F, 0xED, 0x53, 0x52, 0x8A, 0x7, 0x3C, 0x23, 0x75, + 0x3, 0xE8, 0x3D, 0xCE, 0xE8, 0x39, 0xDE, 0xA, 0xC0, 0x75, 0x3, + 0xE9, 0xB0, 0xC6, 0xCD, 0xDE, 0xB4, 0x52, 0x4B, 0x8A, 0xD0, 0xE8, + 0x29, 0xCE, 0x74, 0x3, 0xE9, 0xC5, 0xC6, 0x5E, 0x87, 0xDE, 0x56, + 0x8A, 0xC2, 0x9F, 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x53, 0xE8, 0x9C, + 0xFE, 0x74, 0x3, 0xE9, 0x95, 0xC6, 0x5A, 0x8A, 0xC6, 0x3C, 0x9, + 0xCD, 0xDF, 0x73, 0x3, 0xE9, 0x83, 0xC6, 0x53, 0xB9, 0x2E, 0x0, + 0x3, 0xD9, 0x88, 0x37, 0xB0, 0x0, 0x5B, 0xE9, 0x91, 0xFD, 0x53, + 0xA, 0xC0, 0x75, 0xA, 0xA0, 0x36, 0x5, 0x24, 0x1, 0x74, 0x3, + 0xE9, 0x46, 0x3, 0xE8, 0x6B, 0xFE, 0x74, 0x15, 0x89, 0x1E, 0xE9, + 0x4, 0x53, 0xB0, 0x2, 0x73, 0x3, 0xE9, 0x71, 0xFD, 0xCD, 0xE0, + 0xE9, 0x50, 0xC6, 0xE8, 0x24, 0x3, 0x5B, 0x53, 0xBA, 0x31, 0x0, + 0x3, 0xDA, 0x88, 0x7, 0x8A, 0xF8, 0x8A, 0xD8, 0x89, 0x1E, 0xE9, + 0x4, 0x5B, 0x2, 0x7, 0xC6, 0x7, 0x0, 0x5B, 0xC3, 0xF9, 0xEB, + 0x3, 0xD, 0x32, 0xC0, 0x9F, 0x50, 0xE8, 0x9F, 0xFD, 0xCD, 0xE9, + 0x58, 0x9E, 0x9F, 0x50, 0x74, 0x14, 0x8A, 0x7, 0x2C, 0x2C, 0xA, + 0xC0, 0x75, 0xC, 0xE8, 0x96, 0xCD, 0xE8, 0x6A, 0xEC, 0x52, 0x58, + 0x9E, 0xF9, 0x9F, 0x50, 0x9F, 0x50, 0x32, 0xC0, 0xB2, 0x1, 0xE8, + 0x54, 0xFF, 0x8B, 0x1E, 0xE9, 0x4, 0xB9, 0x31, 0x0, 0x3, 0xD9, + 0x58, 0x9E, 0x1A, 0xC0, 0x24, 0x80, 0xC, 0x1, 0xA2, 0x36, 0x5, + 0x58, 0x9E, 0x9F, 0x50, 0x1A, 0xC0, 0xA2, 0xEF, 0x4, 0x8A, 0x7, + 0xA, 0xC0, 0x79, 0x3, 0xE9, 0xD8, 0x0, 0x58, 0x9E, 0x74, 0x3, + 0xE8, 0x57, 0xEB, 0x32, 0xC0, 0xE8, 0x2C, 0xFE, 0xE9, 0x5, 0xC7, + 0xE8, 0x42, 0xFD, 0xCD, 0xEA, 0x4B, 0xE8, 0x46, 0xCD, 0xB2, 0x80, + 0xF9, 0x75, 0x3, 0xE8, 0x79, 0x5, 0x74, 0x18, 0xE8, 0x10, 0xEC, + 0x2C, 0x3C, 0x50, 0xB2, 0x92, 0x75, 0x6, 0xE8, 0x2F, 0xCD, 0xF9, + 0xEB, 0x8, 0xE8, 0x0, 0xEC, 0x41, 0xA, 0xC0, 0xB2, 0x2, 0x9F, + 0x50, 0x8A, 0xC2, 0x24, 0x10, 0xA2, 0x62, 0x4, 0x58, 0x9E, 0x9F, + 0x50, 0xFE, 0xC0, 0xA2, 0x5F, 0x0, 0x32, 0xC0, 0xE8, 0xDD, 0xFE, + 0x58, 0x9E, 0x53, 0x8B, 0x1E, 0xE9, 0x4, 0x8A, 0x7, 0x5B, 0x24, + 0x80, 0x75, 0x3, 0xE9, 0x14, 0xDD, 0x53, 0xE8, 0x63, 0xE1, 0xA0, + 0x62, 0x4, 0xA, 0xC0, 0x74, 0x3, 0xE8, 0x79, 0x4, 0x8B, 0x1E, + 0x58, 0x3, 0x89, 0x1E, 0x4, 0x7, 0x8B, 0x1E, 0x30, 0x0, 0x53, + 0x8B, 0x1E, 0xE9, 0x4, 0xE8, 0xC6, 0x0, 0xA, 0xC0, 0x79, 0x3, + 0xE9, 0x16, 0x0, 0xE9, 0x4D, 0xC5, 0xA0, 0x62, 0x4, 0xA, 0xC0, + 0x74, 0x3, 0xE8, 0xA2, 0x4, 0x5B, 0x32, 0xC0, 0xA2, 0x62, 0x4, + 0xE9, 0xC8, 0xFE, 0x5B, 0xE8, 0x2, 0x0, 0xEB, 0xE7, 0xE8, 0xA0, + 0x0, 0x3C, 0xFC, 0x75, 0x3, 0xE9, 0xD, 0x1A, 0xCD, 0xEB, 0xE9, + 0x1F, 0xC5, 0x8B, 0x1E, 0x30, 0x0, 0xA, 0xC0, 0xE8, 0x3, 0x0, + 0xE9, 0x46, 0x0, 0x9F, 0x50, 0xE8, 0x83, 0x0, 0x3C, 0xFC, 0x75, + 0x3, 0xE9, 0x36, 0x1A, 0x58, 0x9E, 0xCD, 0xEC, 0xE9, 0x0, 0xC5, + 0x58, 0x9E, 0xC3, 0x24, 0x20, 0xA2, 0x63, 0x4, 0x58, 0x9E, 0x75, + 0x3, 0xE9, 0xF1, 0xC4, 0xE8, 0x77, 0xEA, 0xA0, 0x63, 0x4, 0xA2, + 0x64, 0x4, 0xE8, 0xAB, 0x0, 0x32, 0xC0, 0xE8, 0xF1, 0xFC, 0xC6, + 0x7, 0x80, 0x89, 0x1E, 0xE9, 0x4, 0xE8, 0x4B, 0x0, 0xA, 0xC0, + 0x78, 0xB3, 0xCD, 0xED, 0xE9, 0xD3, 0xC4, 0xA0, 0x64, 0x4, 0xA, + 0xC0, 0x74, 0x3, 0xE8, 0x28, 0x4, 0xE8, 0x27, 0xC7, 0x43, 0x43, + 0x89, 0x1E, 0x58, 0x3, 0xE8, 0x5A, 0xEA, 0x32, 0xC0, 0xA2, 0x36, + 0x5, 0xE8, 0x43, 0xFE, 0xA0, 0xEF, 0x4, 0xA, 0xC0, 0x74, 0x3, + 0xE9, 0xF9, 0xCB, 0xE9, 0xC4, 0xC5, 0x87, 0xDA, 0x8B, 0x1E, 0x2F, + 0x3, 0x87, 0xDA, 0x3B, 0xDA, 0x72, 0x98, 0xE8, 0x1C, 0xEA, 0x32, + 0xC0, 0xA2, 0x36, 0x5, 0xE9, 0xEB, 0xE9, 0x53, 0x52, 0x8B, 0x1E, + 0xE9, 0x4, 0xBA, 0x2E, 0x0, 0x3, 0xDA, 0x8A, 0x7, 0x5A, 0x5B, + 0xC3, 0x75, 0x1E, 0x53, 0x51, 0x50, 0xBA, 0x26, 0x43, 0x52, 0x51, + 0xA, 0xC0, 0xC3, 0x58, 0x59, 0xFE, 0xC8, 0x79, 0xF0, 0x5B, 0xC3, + 0x59, 0x5B, 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0xF7, 0xE8, 0xE4, 0xCB, + 0x51, 0x8A, 0x7, 0x3C, 0x23, 0x75, 0x3, 0xE8, 0xDA, 0xCB, 0xE8, + 0xD6, 0xDB, 0x5E, 0x87, 0xDE, 0x56, 0x53, 0xBA, 0x2E, 0x43, 0x52, + 0xF9, 0xFF, 0xE3, 0xB9, 0x28, 0x41, 0xA0, 0xDF, 0x4, 0xEB, 0xBF, + 0xA0, 0x36, 0x5, 0xA, 0xC0, 0x78, 0xCC, 0xB9, 0x28, 0x41, 0x32, + 0xC0, 0xA0, 0xDF, 0x4, 0xEB, 0xAE, 0x32, 0xC0, 0x8A, 0xE8, 0x8A, + 0xC5, 0xE8, 0x31, 0xFC, 0xC6, 0x7, 0x0, 0xA0, 0xDF, 0x4, 0xFE, + 0xC5, 0x2A, 0xC5, 0x73, 0xEF, 0x32, 0xC0, 0xA2, 0x36, 0x5, 0xE8, + 0x95, 0xE9, 0x8B, 0x1E, 0x30, 0x0, 0x4B, 0xC6, 0x7, 0x0, 0xE9, + 0xDB, 0xC3, 0x5B, 0x58, 0x86, 0xC4, 0x9E, 0x53, 0x52, 0x51, 0x9F, + 0x86, 0xC4, 0x50, 0x86, 0xC4, 0x8B, 0x1E, 0xE9, 0x4, 0xB0, 0x6, + 0xE8, 0x5, 0x0, 0xCD, 0xE3, 0xE9, 0xEB, 0xC3, 0x9F, 0x86, 0xC4, + 0x50, 0x86, 0xC4, 0x52, 0x87, 0xDA, 0xBB, 0x2E, 0x0, 0x3, 0xDA, + 0x8A, 0x7, 0x87, 0xDA, 0x5A, 0x3C, 0x9, 0x73, 0x3, 0xE9, 0xCA, + 0x0, 0x58, 0x86, 0xC4, 0x9E, 0x5E, 0x87, 0xDE, 0x56, 0x5B, 0xE9, + 0xE4, 0xFA, 0x51, 0x53, 0x52, 0x8B, 0x1E, 0xE9, 0x4, 0xB0, 0x8, + 0xE8, 0xCE, 0xFF, 0xCD, 0xE4, 0xE9, 0xB4, 0xC3, 0x5A, 0x5B, 0x59, + 0xC3, 0xE8, 0x30, 0xCB, 0xE8, 0x4, 0xEA, 0x24, 0xE8, 0x0, 0xEA, + 0x28, 0x53, 0x8B, 0x1E, 0xE9, 0x4, 0x53, 0xBB, 0x0, 0x0, 0x89, + 0x1E, 0xE9, 0x4, 0x5B, 0x5E, 0x87, 0xDE, 0x56, 0xE8, 0x12, 0xDB, + 0x52, 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0xB, 0xE8, 0x9, 0xCB, 0xE8, + 0xCD, 0xFB, 0x5B, 0x32, 0xC0, 0x8A, 0x7, 0x9F, 0x50, 0xE8, 0xD3, + 0xE9, 0x29, 0x58, 0x9E, 0x5E, 0x87, 0xDE, 0x56, 0x9F, 0x50, 0x8A, + 0xC3, 0xA, 0xC0, 0x75, 0x3, 0xE9, 0x26, 0xCC, 0x53, 0xE8, 0x7, + 0xE2, 0x87, 0xDA, 0x59, 0x58, 0x9E, 0x9F, 0x50, 0x74, 0x28, 0xE8, + 0x16, 0xE8, 0x3C, 0x3, 0x74, 0x13, 0x88, 0x7, 0x43, 0xFE, 0xC9, + 0x75, 0xEC, 0x58, 0x9E, 0x59, 0x5B, 0x89, 0x1E, 0xE9, 0x4, 0x51, + 0xE9, 0x33, 0xE2, 0x58, 0x9E, 0x8B, 0x1E, 0x2E, 0x0, 0x89, 0x1E, + 0x47, 0x3, 0x5B, 0xE9, 0x6, 0xC3, 0xE8, 0x6A, 0xFF, 0x73, 0x3, + 0xE9, 0x30, 0xC3, 0xEB, 0xD5, 0xCD, 0xE5, 0xE8, 0x12, 0x0, 0x53, + 0xB5, 0x1, 0xE8, 0x2, 0x0, 0x5B, 0xC3, 0x32, 0xC0, 0x88, 0x7, + 0x43, 0xFE, 0xCD, 0x75, 0xF9, 0xC3, 0x8B, 0x1E, 0xE9, 0x4, 0xBA, + 0x33, 0x0, 0x3, 0xDA, 0xC3, 0x58, 0x86, 0xC4, 0x9E, 0xC3, 0xE8, + 0x7, 0xFB, 0x75, 0x3, 0xE9, 0xFA, 0xC2, 0xB0, 0xA, 0x73, 0x3, + 0xE9, 0x12, 0xFA, 0xCD, 0xE6, 0xE9, 0xEE, 0xC2, 0xE8, 0xF3, 0xFA, + 0x75, 0x3, 0xE9, 0xE6, 0xC2, 0xB0, 0xC, 0x73, 0x3, 0xE9, 0xFE, + 0xF9, 0xCD, 0xE7, 0xE9, 0xDA, 0xC2, 0xE8, 0xDF, 0xFA, 0x75, 0x3, + 0xE9, 0xD2, 0xC2, 0xB0, 0xE, 0x73, 0x3, 0xE9, 0xEA, 0xF9, 0xCD, + 0xE8, 0xE9, 0xC6, 0xC2, 0xE8, 0xFF, 0xEA, 0x75, 0x3, 0xE9, 0x1F, + 0xCA, 0x32, 0xC0, 0xE8, 0x47, 0xFC, 0xB2, 0x42, 0xE9, 0xF2, 0xC2, + 0x3C, 0x23, 0x75, 0xAD, 0xE8, 0x2C, 0xDA, 0xE8, 0x4, 0xE9, 0x2C, + 0x8A, 0xC2, 0x53, 0xE8, 0x0, 0xFB, 0x5B, 0x8A, 0x7, 0xC3, 0xB9, + 0xEC, 0x2D, 0x51, 0x32, 0xC0, 0xE9, 0x24, 0xFC, 0xE8, 0x1E, 0xD6, + 0xB9, 0x9B, 0x16, 0xBA, 0x20, 0x2C, 0x75, 0x1B, 0x8A, 0xD6, 0xEB, + 0x17, 0xB9, 0x98, 0x14, 0x51, 0xE8, 0xCC, 0xFF, 0xE8, 0x51, 0xF2, + 0xE8, 0x1B, 0x1F, 0x52, 0xB9, 0x8A, 0x11, 0x32, 0xC0, 0x8A, 0xF0, + 0x8A, 0xD0, 0x50, 0x51, 0x53, 0xE8, 0xA5, 0xFE, 0x73, 0x3, 0xE9, + 0x6B, 0xC2, 0x3C, 0x20, 0x75, 0x6, 0xFE, 0xC6, 0xFE, 0xCE, 0x75, + 0xEE, 0x3C, 0x22, 0x75, 0x13, 0x8A, 0xE8, 0x8A, 0xC2, 0x3C, 0x2C, + 0x8A, 0xC5, 0x75, 0x9, 0x8A, 0xF5, 0x8A, 0xD5, 0xE8, 0x81, 0xFE, + 0x72, 0x53, 0xBB, 0xF7, 0x1, 0xB5, 0xFF, 0x8A, 0xC8, 0x8A, 0xC6, + 0x3C, 0x22, 0x8A, 0xC1, 0x74, 0x2E, 0x3C, 0xD, 0x53, 0x74, 0x59, + 0x5B, 0x3C, 0xA, 0x75, 0x24, 0x8A, 0xC8, 0x8A, 0xC2, 0x3C, 0x2C, + 0x8A, 0xC1, 0x74, 0x3, 0xE8, 0x89, 0x0, 0x53, 0xE8, 0x55, 0xFE, + 0x5B, 0x72, 0x26, 0x3C, 0xD, 0x75, 0xC, 0x8A, 0xC2, 0x3C, 0x20, + 0x74, 0x15, 0x3C, 0x2C, 0xB0, 0xD, 0x74, 0xF, 0xA, 0xC0, 0x74, + 0xB, 0x3A, 0xC6, 0x74, 0xE, 0x3A, 0xC2, 0x74, 0xA, 0xE8, 0x63, + 0x0, 0x53, 0xE8, 0x2F, 0xFE, 0x5B, 0x73, 0xB2, 0x53, 0x3C, 0x22, + 0x74, 0x4, 0x3C, 0x20, 0x75, 0x25, 0xE8, 0x20, 0xFE, 0x72, 0x20, + 0x3C, 0x20, 0x74, 0xF7, 0x3C, 0x2C, 0x74, 0x18, 0x3C, 0xD, 0x75, + 0x4, 0xCD, 0xE1, 0x74, 0x10, 0x8B, 0x1E, 0xE9, 0x4, 0x8A, 0xC8, + 0xB0, 0x12, 0xE8, 0xDD, 0xFD, 0xCD, 0xE2, 0xE9, 0xC3, 0xC1, 0x5B, + 0xC6, 0x7, 0x0, 0xBB, 0xF6, 0x1, 0x8A, 0xC2, 0x2C, 0x20, 0x74, + 0x7, 0xB5, 0x0, 0xE8, 0x66, 0xE0, 0x5B, 0xC3, 0xE8, 0x37, 0xD5, + 0x9F, 0x50, 0xE8, 0x2A, 0xC9, 0x58, 0x9E, 0x9F, 0x50, 0x73, 0x3, + 0xE8, 0xC4, 0x23, 0x58, 0x9E, 0x72, 0x3, 0xE8, 0xC4, 0x23, 0x5B, + 0xC3, 0xA, 0xC0, 0x74, 0xFB, 0x88, 0x7, 0x43, 0xFE, 0xCD, 0x75, + 0xF4, 0x59, 0xEB, 0xC5, 0xE8, 0x46, 0x0, 0xA2, 0x60, 0x0, 0xFE, + 0xC0, 0x74, 0x3, 0xE9, 0x9E, 0xC1, 0x53, 0x51, 0xB2, 0x2, 0xE8, + 0xC6, 0xFA, 0x5B, 0xE8, 0x3B, 0xFC, 0x32, 0xC0, 0xA2, 0x60, 0x0, + 0xE9, 0x1A, 0xFC, 0xE8, 0x26, 0x0, 0xA, 0xC0, 0x74, 0x7, 0xFE, + 0xC0, 0x75, 0x3, 0xE9, 0x7D, 0xC1, 0xFE, 0xC8, 0xA2, 0x60, 0x0, + 0x53, 0x51, 0x32, 0xC0, 0xB2, 0x1, 0xE8, 0x9E, 0xFA, 0x5B, 0xE8, + 0x2E, 0xFC, 0x32, 0xC0, 0xA2, 0x60, 0x0, 0x5B, 0xE9, 0xCC, 0xFA, + 0xE8, 0xB4, 0xF8, 0x52, 0x4B, 0xE8, 0xB9, 0xC8, 0x5A, 0x75, 0x3, + 0xB0, 0x1, 0xC3, 0x52, 0xE8, 0x86, 0xE7, 0x2C, 0xE8, 0x2B, 0x0, + 0x52, 0x4B, 0xE8, 0xA6, 0xC8, 0x75, 0x5, 0x59, 0x5A, 0x32, 0xC0, + 0xC3, 0xE8, 0x73, 0xE7, 0x2C, 0xE8, 0x18, 0x0, 0x59, 0x87, 0xDA, + 0x3, 0xD9, 0x89, 0x1E, 0x4, 0x7, 0x87, 0xDA, 0x4B, 0xE8, 0x89, + 0xC8, 0x74, 0x3, 0xE9, 0x25, 0xC1, 0x5A, 0xB0, 0xFF, 0xC3, 0xE8, + 0x87, 0xD0, 0x53, 0xE8, 0x11, 0xDC, 0x5A, 0x87, 0xDA, 0xC3, 0xB9, + 0xB, 0xD, 0x8B, 0x1E, 0x30, 0x0, 0x87, 0xDA, 0x8B, 0x1E, 0x58, + 0x3, 0x3B, 0xDA, 0x75, 0x1, 0xC3, 0xBB, 0x17, 0x62, 0x8A, 0xC3, + 0x2, 0xC1, 0x8A, 0xD8, 0x8A, 0xC7, 0x14, 0x0, 0x8A, 0xF8, 0x8B, + 0xF2, 0xAC, 0x2A, 0xC5, 0x2E, 0x32, 0x7, 0x50, 0xBB, 0x76, 0x61, + 0x8A, 0xC3, 0x2, 0xC5, 0x8A, 0xD8, 0x8A, 0xC7, 0x14, 0x0, 0x8A, + 0xF8, 0x58, 0x2E, 0x32, 0x7, 0x2, 0xC1, 0x8B, 0xFA, 0xAA, 0x42, + 0xFE, 0xC9, 0x75, 0x2, 0xB1, 0xB, 0xFE, 0xCD, 0x75, 0xBC, 0xB5, + 0xD, 0xEB, 0xB8, 0xB9, 0xB, 0xD, 0x8B, 0x1E, 0x30, 0x0, 0x87, + 0xDA, 0x8B, 0x1E, 0x58, 0x3, 0x3B, 0xDA, 0x74, 0xAF, 0xBB, 0x76, + 0x61, 0x8A, 0xC3, 0x2, 0xC5, 0x8A, 0xD8, 0x8A, 0xC7, 0x14, 0x0, + 0x8A, 0xF8, 0x8B, 0xF2, 0xAC, 0x2A, 0xC1, 0x2E, 0x32, 0x7, 0x50, + 0xBB, 0x17, 0x62, 0x8A, 0xC3, 0x2, 0xC1, 0x8A, 0xD8, 0x8A, 0xC7, + 0x14, 0x0, 0x8A, 0xF8, 0x58, 0x2E, 0x32, 0x7, 0x2, 0xC5, 0x8B, + 0xFA, 0xAA, 0x42, 0xFE, 0xC9, 0x75, 0x2, 0xB1, 0xB, 0xFE, 0xCD, + 0x75, 0xBD, 0xB5, 0xD, 0xEB, 0xB9, 0x53, 0x8B, 0x1E, 0x2E, 0x0, + 0x8A, 0xC7, 0x22, 0xC3, 0x5B, 0xFE, 0xC0, 0x74, 0x1, 0xC3, 0x9F, + 0x50, 0xA0, 0x64, 0x4, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0xF5, 0xC8, + 0x58, 0x9E, 0xC3, 0x8A, 0x7, 0x3C, 0x40, 0x75, 0x3, 0xE8, 0xAD, + 0xC7, 0xB9, 0x0, 0x0, 0x8A, 0xF5, 0x8A, 0xD1, 0x3C, 0xEA, 0x74, + 0x1F, 0x8A, 0x7, 0x3C, 0xCF, 0x9C, 0x75, 0x3, 0xE8, 0x98, 0xC7, + 0xE8, 0x6C, 0xE6, 0x28, 0xE8, 0x7E, 0xD7, 0x52, 0xE8, 0x64, 0xE6, + 0x2C, 0xE8, 0x76, 0xD7, 0xE8, 0x5D, 0xE6, 0x29, 0x59, 0x9D, 0x53, + 0x8B, 0x1E, 0x3D, 0x5, 0x74, 0x3, 0xBB, 0x0, 0x0, 0x9F, 0x3, + 0xD9, 0xD1, 0xDE, 0x9E, 0xD1, 0xD6, 0x89, 0x1E, 0x3D, 0x5, 0x89, + 0x1E, 0x37, 0x5, 0x8B, 0xCB, 0x8B, 0x1E, 0x3B, 0x5, 0x74, 0x3, + 0xBB, 0x0, 0x0, 0x3, 0xDA, 0x89, 0x1E, 0x3B, 0x5, 0x89, 0x1E, + 0x39, 0x5, 0x87, 0xDA, 0x5B, 0xC3, 0x32, 0xC0, 0xEB, 0x2, 0xB0, + 0x3, 0x50, 0xE8, 0xA4, 0xFF, 0x58, 0xE8, 0x2E, 0x0, 0x53, 0xE8, + 0x28, 0x3, 0x73, 0x6, 0xE8, 0x7F, 0x2, 0xE8, 0x55, 0x2, 0x5B, + 0xC3, 0xE8, 0x31, 0xC7, 0xE8, 0x8C, 0xFF, 0x53, 0xE8, 0x14, 0x3, + 0xBB, 0xFF, 0xFF, 0x73, 0xA, 0xE8, 0x68, 0x2, 0xE8, 0x1B, 0x2, + 0x8A, 0xD8, 0xB7, 0x0, 0xE8, 0x7, 0x1D, 0x5B, 0xC3, 0xB0, 0x3, + 0x51, 0x52, 0x8A, 0xD0, 0x4B, 0xE8, 0xC, 0xC7, 0x74, 0xB, 0xE8, + 0xDE, 0xE5, 0x2C, 0x3C, 0x2C, 0x74, 0x3, 0xE8, 0xFE, 0xD6, 0x8A, + 0xC2, 0x53, 0xE8, 0xC1, 0x2, 0x73, 0x3, 0xE9, 0x30, 0xC8, 0x5B, + 0x5A, 0x59, 0xE9, 0xEF, 0xC6, 0x8B, 0x1E, 0x37, 0x5, 0x8A, 0xC3, + 0x2A, 0xC1, 0x8A, 0xD8, 0x8A, 0xC7, 0x1A, 0xC5, 0x8A, 0xF8, 0x73, + 0xC5, 0x32, 0xC0, 0x2A, 0xC3, 0x8A, 0xD8, 0x1A, 0xC7, 0x2A, 0xC3, + 0x8A, 0xF8, 0xF9, 0xC3, 0x8B, 0x1E, 0x39, 0x5, 0x8A, 0xC3, 0x2A, + 0xC2, 0x8A, 0xD8, 0x8A, 0xC7, 0x1A, 0xC6, 0x8A, 0xF8, 0xEB, 0xDE, + 0x53, 0x8B, 0x1E, 0x39, 0x5, 0x87, 0xDA, 0x89, 0x1E, 0x39, 0x5, + 0x5B, 0xC3, 0xE8, 0xF0, 0xFF, 0x53, 0x51, 0x8B, 0x1E, 0x37, 0x5, + 0x5E, 0x87, 0xDE, 0x56, 0x89, 0x1E, 0x37, 0x5, 0x59, 0x5B, 0xC3, + 0xE8, 0xE2, 0xFE, 0x51, 0x52, 0xE8, 0x6A, 0xE5, 0xEA, 0xE8, 0xED, + 0xFE, 0xE8, 0x76, 0xFF, 0x5A, 0x59, 0x74, 0x53, 0xE8, 0x5C, 0xE5, + 0x2C, 0xE8, 0x58, 0xE5, 0x42, 0x75, 0x3, 0xE9, 0x60, 0x0, 0xE8, + 0x4F, 0xE5, 0x46, 0x53, 0xE8, 0x5D, 0x2, 0xE8, 0xC1, 0xFF, 0xE8, + 0x57, 0x2, 0xE8, 0x9C, 0xFF, 0x73, 0x3, 0xE8, 0xA9, 0xFF, 0x43, + 0x53, 0xE8, 0x72, 0xFF, 0x73, 0x3, 0xE8, 0xAF, 0xFF, 0x43, 0x53, + 0xE8, 0x9C, 0x1, 0x5A, 0x59, 0x52, 0x51, 0xE8, 0xDB, 0x0, 0x50, + 0x53, 0x87, 0xDA, 0xE8, 0x69, 0x2, 0x5B, 0x58, 0xE8, 0xD7, 0x0, + 0xE8, 0xF8, 0x0, 0x59, 0x5A, 0x49, 0x8A, 0xC5, 0xA, 0xC1, 0x75, + 0xE3, 0x5B, 0xC3, 0x51, 0x52, 0x53, 0xE8, 0x45, 0x0, 0x8B, 0x1E, + 0x3D, 0x5, 0x89, 0x1E, 0x37, 0x5, 0x8B, 0x1E, 0x3B, 0x5, 0x89, + 0x1E, 0x39, 0x5, 0x5B, 0x5A, 0x59, 0xC3, 0x53, 0x8B, 0x1E, 0x39, + 0x5, 0x53, 0x52, 0x87, 0xDA, 0xE8, 0xDA, 0xFF, 0x5B, 0x89, 0x1E, + 0x39, 0x5, 0x87, 0xDA, 0xE8, 0xD0, 0xFF, 0x5B, 0x89, 0x1E, 0x39, + 0x5, 0x8B, 0x1E, 0x37, 0x5, 0x51, 0x8B, 0xCB, 0xE8, 0xC1, 0xFF, + 0x5B, 0x89, 0x1E, 0x37, 0x5, 0x8B, 0xCB, 0xE8, 0xB7, 0xFF, 0x5B, + 0xC3, 0xCD, 0xB8, 0xE8, 0xCF, 0x1, 0xE8, 0x33, 0xFF, 0xE8, 0xC9, + 0x1, 0xE8, 0xE, 0xFF, 0x73, 0x3, 0xE8, 0x28, 0xFF, 0x52, 0x53, + 0xE8, 0xE4, 0xFE, 0x87, 0xDA, 0xBB, 0xF1, 0x49, 0x73, 0x3, 0xBB, + 0x5, 0x4A, 0x5E, 0x87, 0xDE, 0x56, 0x3B, 0xDA, 0x73, 0x14, 0x89, + 0x1E, 0xFD, 0x6, 0x5B, 0x89, 0x1E, 0xF7, 0x6, 0xBB, 0xD5, 0x49, + 0x89, 0x1E, 0xF9, 0x6, 0x87, 0xDA, 0xEB, 0x16, 0x5E, 0x87, 0xDE, + 0x56, 0x89, 0x1E, 0xF9, 0x6, 0xBB, 0xD5, 0x49, 0x89, 0x1E, 0xF7, + 0x6, 0x87, 0xDA, 0x89, 0x1E, 0xFD, 0x6, 0x5B, 0x5A, 0x53, 0x89, + 0x1E, 0xFB, 0x6, 0xE8, 0xD3, 0x0, 0x5A, 0x52, 0xE8, 0x5, 0x0, + 0x59, 0x41, 0xE9, 0x20, 0x2, 0x8A, 0xC6, 0xA, 0xC0, 0xD0, 0xD8, + 0x8A, 0xF0, 0x8A, 0xC2, 0xD0, 0xD8, 0x8A, 0xD0, 0xC3, 0x8B, 0x1E, + 0xF3, 0x6, 0xA0, 0xF5, 0x6, 0xC3, 0x89, 0x1E, 0xF3, 0x6, 0xA2, + 0xF5, 0x6, 0xC3, 0x8B, 0x1E, 0xF3, 0x6, 0x81, 0xFB, 0x0, 0x20, + 0x72, 0x9, 0x81, 0xEB, 0x0, 0x20, 0x89, 0x1E, 0xF3, 0x6, 0xC3, + 0x81, 0xC3, 0x50, 0x20, 0x89, 0x1E, 0xF3, 0x6, 0xC3, 0x8B, 0x1E, + 0xF3, 0x6, 0x81, 0xFB, 0x0, 0x20, 0x72, 0x9, 0x81, 0xEB, 0xB0, + 0x1F, 0x89, 0x1E, 0xF3, 0x6, 0xC3, 0x81, 0xC3, 0x0, 0x20, 0x89, + 0x1E, 0xF3, 0x6, 0xC3, 0x8A, 0xC1, 0x8A, 0xE, 0x55, 0x0, 0xD2, + 0xE, 0xF5, 0x6, 0x8A, 0xC8, 0x72, 0x1, 0xC3, 0xFF, 0x6, 0xF3, + 0x6, 0xC3, 0x8A, 0xC1, 0x8A, 0xE, 0x55, 0x0, 0xD2, 0x6, 0xF5, + 0x6, 0x8A, 0xC8, 0x72, 0x1, 0xC3, 0xFF, 0xE, 0xF3, 0x6, 0xC3, + 0x8C, 0xC6, 0xBF, 0x0, 0xB8, 0x8E, 0xC7, 0x8B, 0x1E, 0xF3, 0x6, + 0x26, 0x8A, 0x7, 0x8A, 0x16, 0xF5, 0x6, 0x22, 0xC2, 0x8A, 0xE, + 0x55, 0x0, 0xD2, 0xEA, 0x72, 0x4, 0xD2, 0xE8, 0xEB, 0xF8, 0x8E, + 0xC6, 0xC3, 0x8C, 0xC6, 0xBF, 0x0, 0xB8, 0x8E, 0xC7, 0x8B, 0x1E, + 0xF3, 0x6, 0x8B, 0xE9, 0xA0, 0xF5, 0x6, 0xF6, 0xD0, 0x26, 0x22, + 0x7, 0x8A, 0xE, 0xF6, 0x6, 0x22, 0xE, 0xF5, 0x6, 0xA, 0xC1, + 0x26, 0x88, 0x7, 0x8B, 0xCD, 0x8E, 0xC6, 0xC3, 0x8B, 0xE9, 0xD1, + 0xEA, 0x9F, 0x8B, 0xDA, 0xB1, 0x2, 0xD3, 0xE2, 0x3, 0xD3, 0xB1, + 0x4, 0xD3, 0xE2, 0x9E, 0x73, 0x4, 0x81, 0xC2, 0x0, 0x20, 0x89, + 0x16, 0xF3, 0x6, 0x8B, 0xD5, 0x8A, 0xCA, 0xF6, 0x6, 0x55, 0x0, + 0x1, 0x74, 0x14, 0xB0, 0x7, 0x22, 0xC8, 0xB0, 0x80, 0xD2, 0xE8, + 0xA2, 0xF5, 0x6, 0xB1, 0x3, 0xD3, 0xEA, 0x1, 0x16, 0xF3, 0x6, + 0xC3, 0xB0, 0x3, 0x22, 0xC8, 0x2, 0xC9, 0xB0, 0xC0, 0xD2, 0xE8, + 0xA2, 0xF5, 0x6, 0xB1, 0x2, 0xD3, 0xEA, 0x1, 0x16, 0xF3, 0x6, + 0xC3, 0xA0, 0x48, 0x0, 0xC7, 0x6, 0x3B, 0x5, 0x64, 0x0, 0x3C, + 0x6, 0x74, 0x12, 0x73, 0x1C, 0x3C, 0x4, 0x72, 0x18, 0xC6, 0x6, + 0x55, 0x0, 0x2, 0xC7, 0x6, 0x3D, 0x5, 0xA0, 0x0, 0xC3, 0xC6, + 0x6, 0x55, 0x0, 0x1, 0xC7, 0x6, 0x3D, 0x5, 0x40, 0x1, 0xC3, + 0xC6, 0x6, 0x55, 0x0, 0x0, 0xC3, 0x3C, 0x4, 0x73, 0xF, 0xF6, + 0x6, 0x55, 0x0, 0x1, 0x74, 0xC, 0x24, 0x1, 0xF6, 0xD8, 0xA2, + 0xF6, 0x6, 0xF8, 0xC3, 0xE9, 0x5D, 0xC5, 0x24, 0x3, 0xB1, 0x55, + 0xF6, 0xE1, 0xA2, 0xF6, 0x6, 0xF8, 0xC3, 0xA0, 0x55, 0x0, 0xA, + 0xC0, 0x74, 0xEB, 0xA, 0xED, 0x78, 0x27, 0xBB, 0x80, 0x2, 0x84, + 0x6, 0x1, 0x0, 0x74, 0x3, 0xBB, 0x40, 0x1, 0x3B, 0xCB, 0x9F, + 0x72, 0x3, 0x4B, 0x8B, 0xCB, 0xA, 0xF6, 0x78, 0xC, 0x81, 0xFA, + 0xC8, 0x0, 0x72, 0x4, 0xBA, 0xC7, 0x0, 0xC3, 0x9E, 0xC3, 0x33, + 0xD2, 0xC3, 0x33, 0xC9, 0x9F, 0xEB, 0xE8, 0x8C, 0xC6, 0xBF, 0x0, + 0xB8, 0x8E, 0xC7, 0x8B, 0xD3, 0xB, 0xD2, 0x74, 0x6C, 0x8B, 0x1E, + 0xF3, 0x6, 0x26, 0x8A, 0x2F, 0xA0, 0xF5, 0x6, 0x8A, 0xE0, 0xF6, + 0xD0, 0x8A, 0xE, 0x55, 0x0, 0x8A, 0x1E, 0xF6, 0x6, 0x22, 0xE8, + 0x8A, 0xFC, 0x22, 0xFB, 0xA, 0xEF, 0x4A, 0x74, 0x40, 0xD2, 0xC8, + 0xD2, 0xCC, 0x73, 0xEF, 0x8B, 0x1E, 0xF3, 0x6, 0x26, 0x88, 0x2F, + 0xFF, 0x6, 0xF3, 0x6, 0x88, 0x26, 0xF5, 0x6, 0x8B, 0xCA, 0xD1, + 0xE9, 0xD1, 0xE9, 0xF6, 0x6, 0x55, 0x0, 0x1, 0x75, 0x6, 0x81, + 0xE2, 0x3, 0x0, 0xEB, 0x6, 0x81, 0xE2, 0x7, 0x0, 0xD1, 0xE9, + 0xE3, 0xAB, 0xFC, 0xA0, 0xF6, 0x6, 0x8B, 0x3E, 0xF3, 0x6, 0xF3, + 0xAA, 0x89, 0x3E, 0xF3, 0x6, 0xEB, 0x9B, 0x8B, 0x1E, 0xF3, 0x6, + 0x26, 0x88, 0x2F, 0x88, 0x26, 0xF5, 0x6, 0x8E, 0xC6, 0xC3, 0xE8, + 0x7F, 0xFE, 0x3, 0x16, 0xFD, 0x6, 0x3B, 0x16, 0xFB, 0x6, 0x72, + 0x9, 0x2B, 0x16, 0xFB, 0x6, 0x3E, 0xFF, 0x16, 0xF9, 0x6, 0x3E, + 0xFF, 0x16, 0xF7, 0x6, 0xE2, 0xE3, 0xC3, 0x53, 0xE8, 0xA3, 0xCF, + 0x5B, 0xC3, 0x53, 0xE8, 0x27, 0x19, 0x5B, 0xC3, 0xF6, 0x80, 0x3E, + 0x71, 0x0, 0x0, 0x74, 0x3, 0xE9, 0xF9, 0x4, 0xC3, 0xA0, 0x29, + 0x0, 0x8A, 0xD0, 0xE8, 0xFF, 0xD2, 0xE9, 0xED, 0x4, 0x0, 0x0, + 0x0, 0xB4, 0xF, 0xCD, 0x10, 0xA2, 0x48, 0x0, 0xB4, 0x28, 0x3C, + 0x2, 0x72, 0xD, 0xB4, 0x50, 0x3C, 0x7, 0x75, 0x7, 0xB9, 0xC, + 0xB, 0x89, 0xE, 0x68, 0x0, 0x88, 0x26, 0x29, 0x0, 0xFA, 0x8C, + 0xDB, 0x89, 0x1E, 0x50, 0x3, 0x1E, 0xBA, 0x0, 0x0, 0x8E, 0xDA, + 0x89, 0x1E, 0x10, 0x5, 0xBB, 0x34, 0x4D, 0x89, 0x1E, 0x6C, 0x0, + 0xBB, 0x44, 0x57, 0x89, 0x1E, 0x70, 0x0, 0x8C, 0xE, 0x6E, 0x0, + 0x8C, 0xE, 0x72, 0x0, 0x1F, 0xE8, 0x32, 0x0, 0xBB, 0x18, 0x2, + 0xB9, 0x0, 0x0, 0x8E, 0xC1, 0xB9, 0x7A, 0x0, 0x26, 0x8C, 0x8F, + 0x2, 0x0, 0x26, 0xC7, 0x7, 0x94, 0x4C, 0x83, 0xC3, 0x4, 0xE0, + 0xF1, 0x8C, 0xDB, 0x8E, 0xC3, 0xE8, 0x48, 0xE1, 0xFB, 0xB4, 0x1, + 0xCD, 0x17, 0xE8, 0x77, 0x6, 0xBB, 0x9B, 0x4C, 0xE8, 0xDF, 0x2E, + 0xE9, 0x63, 0x32, 0xBE, 0xED, 0x4C, 0xBB, 0x53, 0x6, 0xB9, 0xA, + 0x0, 0x53, 0xFC, 0x2E, 0xAC, 0x88, 0x7, 0x43, 0xA, 0xC0, 0x75, + 0xF6, 0x5B, 0x83, 0xC3, 0x10, 0xE0, 0xEF, 0xC3, 0xCF, 0x3E, 0xFF, + 0x2E, 0x0, 0x7, 0xCB, 0x54, 0x68, 0x65, 0x20, 0x49, 0x42, 0x4D, + 0x20, 0x50, 0x65, 0x72, 0x73, 0x6F, 0x6E, 0x61, 0x6C, 0x20, 0x43, + 0x6F, 0x6D, 0x70, 0x75, 0x74, 0x65, 0x72, 0x20, 0x42, 0x61, 0x73, + 0x69, 0x63, 0xFF, 0xD, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, + 0x20, 0x43, 0x31, 0x2E, 0x31, 0x30, 0x20, 0x43, 0x6F, 0x70, 0x79, + 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x49, 0x42, 0x4D, 0x20, 0x43, + 0x6F, 0x72, 0x70, 0x20, 0x31, 0x39, 0x38, 0x31, 0xFF, 0xD, 0x0, + 0x32, 0x35, 0x2D, 0x41, 0x70, 0x72, 0x2D, 0x38, 0x31, 0x4C, 0x49, + 0x53, 0x54, 0x20, 0x0, 0x52, 0x55, 0x4E, 0xD, 0x0, 0x4C, 0x4F, + 0x41, 0x44, 0x22, 0x0, 0x53, 0x41, 0x56, 0x45, 0x22, 0x0, 0x43, + 0x4F, 0x4E, 0x54, 0xD, 0x0, 0x2C, 0x22, 0x4C, 0x50, 0x54, 0x31, + 0x3A, 0x22, 0xD, 0x0, 0x54, 0x52, 0x4F, 0x4E, 0xD, 0x0, 0x54, + 0x52, 0x4F, 0x46, 0x46, 0xD, 0x0, 0x4B, 0x45, 0x59, 0x20, 0x0, + 0x53, 0x43, 0x52, 0x45, 0x45, 0x4E, 0x20, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0xD, 0x0, 0x9C, 0x50, 0x1E, 0x52, 0xBA, 0x0, 0x0, 0x8E, + 0xDA, 0x8E, 0x1E, 0x10, 0x5, 0xE8, 0x3A, 0xA, 0x88, 0x16, 0x6A, + 0x0, 0xFE, 0xCA, 0x88, 0x16, 0x5E, 0x0, 0x5A, 0x1F, 0x58, 0x9D, + 0xCF, 0x56, 0xA0, 0x5E, 0x0, 0xA, 0xC0, 0x75, 0x11, 0xA0, 0x6A, + 0x0, 0xA, 0xC0, 0x75, 0xA, 0xB4, 0x1, 0xCD, 0x16, 0xB0, 0x0, + 0x74, 0x2, 0xFE, 0xC8, 0x5E, 0xC3, 0xA0, 0x5E, 0x0, 0xA, 0xC0, + 0x74, 0x8, 0x32, 0xC0, 0xA2, 0x5E, 0x0, 0xB0, 0x3, 0xC3, 0x56, + 0x57, 0xA0, 0x6A, 0x0, 0xA, 0xC0, 0x75, 0x74, 0xB4, 0x0, 0xCD, + 0x16, 0xA, 0xC0, 0x74, 0x3, 0x5F, 0x5E, 0xC3, 0x53, 0x80, 0xFC, + 0x3B, 0x72, 0x5, 0x80, 0xFC, 0x45, 0x72, 0x3C, 0x8B, 0x1E, 0x2E, + 0x0, 0x43, 0xB, 0xDB, 0x75, 0x13, 0xBB, 0x34, 0x4E, 0xB1, 0x1A, + 0x2E, 0x3A, 0x27, 0x74, 0xC, 0x43, 0xFE, 0xC0, 0xFE, 0xC9, 0x75, + 0xF4, 0x32, 0xC0, 0x5B, 0xEB, 0xD3, 0x32, 0xE4, 0xD0, 0xE0, 0x8B, + 0xD8, 0x2E, 0x8B, 0x9F, 0x3, 0x1, 0x89, 0x1E, 0x6B, 0x0, 0xFE, + 0xE, 0x6A, 0x0, 0xD0, 0xE8, 0x4, 0x41, 0x8C, 0xE, 0x6D, 0x0, + 0xEB, 0xE0, 0x50, 0x86, 0xC4, 0x2C, 0x3B, 0xB3, 0x10, 0xF6, 0xE3, + 0xBB, 0x53, 0x6, 0x3, 0xD8, 0xF6, 0x7, 0xFF, 0x58, 0x74, 0xCC, + 0x89, 0x1E, 0x6B, 0x0, 0x8C, 0x1E, 0x6D, 0x0, 0xFE, 0xE, 0x6A, + 0x0, 0xEB, 0xC, 0x53, 0xFE, 0xC8, 0x75, 0x7, 0xA2, 0x6A, 0x0, + 0xB0, 0x20, 0xEB, 0xB2, 0x1E, 0xC5, 0x1E, 0x6B, 0x0, 0x8A, 0x7, + 0x1F, 0xFF, 0x6, 0x6B, 0x0, 0xA, 0xC0, 0x74, 0x2, 0x79, 0xA0, + 0x32, 0xE4, 0x8C, 0xCB, 0x8A, 0x1E, 0x6E, 0x0, 0x3A, 0xDF, 0x72, + 0x4, 0xFE, 0xC4, 0x24, 0x7F, 0x88, 0x26, 0x6A, 0x0, 0xA, 0xC0, + 0x75, 0x88, 0x5B, 0xE9, 0x77, 0x11, 0x1E, 0x30, 0x2E, 0x20, 0x12, + 0x21, 0x22, 0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, 0x19, + 0x10, 0x13, 0x1F, 0x14, 0x16, 0x2F, 0x11, 0x2D, 0x15, 0x2C, 0x53, + 0x51, 0x56, 0xBE, 0x6C, 0x4E, 0xB1, 0xE, 0xFC, 0x2E, 0xAC, 0x3A, + 0xE0, 0x74, 0x9, 0x46, 0xFE, 0xC9, 0x75, 0xF4, 0x32, 0xC0, 0xEB, + 0x2, 0x2E, 0xAC, 0x5E, 0x59, 0x5B, 0xC3, 0x47, 0xB, 0x48, 0x1E, + 0x4B, 0x1D, 0x4D, 0x1C, 0x50, 0x1F, 0x1C, 0xA, 0x74, 0x6, 0x73, + 0x2, 0x76, 0x1, 0x52, 0x12, 0x53, 0x7F, 0x4F, 0xE, 0x75, 0x5, + 0x77, 0xC, 0x1F, 0x1E, 0x1D, 0x1C, 0xD, 0xC, 0xB, 0xA, 0x9C, + 0x53, 0x51, 0x52, 0x50, 0x3C, 0x7, 0x74, 0x4D, 0x3C, 0xD, 0x75, + 0xA, 0xF6, 0x6, 0x6F, 0x0, 0xFF, 0x74, 0x3, 0xE8, 0x8B, 0x0, + 0xE8, 0x2C, 0x2, 0x74, 0x4, 0x3C, 0xFF, 0x74, 0x39, 0x3C, 0xC, + 0x74, 0x22, 0xBB, 0x87, 0x4E, 0xB9, 0x8, 0x0, 0x43, 0xFE, 0xC9, + 0x78, 0x1C, 0x2E, 0x3A, 0x7, 0x75, 0xF6, 0xD0, 0xE1, 0x8B, 0xD9, + 0xB9, 0xE9, 0x4E, 0x51, 0x2E, 0xFF, 0xB7, 0xE1, 0x2F, 0x8B, 0x1E, + 0x56, 0x0, 0xC3, 0xE8, 0xE, 0x4, 0xEB, 0xE, 0xE8, 0x3E, 0x0, + 0xE8, 0xE, 0x0, 0xE8, 0xD, 0xE1, 0xEB, 0x3, 0xE8, 0x24, 0x9, + 0x58, 0x5A, 0x59, 0x5B, 0x9D, 0xC3, 0x50, 0x8A, 0x3E, 0x49, 0x0, + 0x8A, 0x1E, 0x4E, 0x0, 0xB9, 0x1, 0x0, 0xB4, 0x9, 0xCD, 0x10, + 0x58, 0xC3, 0x53, 0xE8, 0x71, 0x0, 0xE8, 0xE7, 0xFF, 0x5B, 0xC3, + 0x53, 0xE8, 0x68, 0x0, 0xB4, 0x8, 0xCD, 0x10, 0x5B, 0xC3, 0xE8, + 0xF3, 0xFF, 0x8A, 0xE8, 0x8A, 0xCC, 0xC3, 0x8B, 0x1E, 0x56, 0x0, + 0x89, 0x1E, 0x56, 0x0, 0x9C, 0x53, 0xE8, 0x4D, 0x0, 0x5B, 0x9D, + 0xC3, 0xA0, 0x57, 0x0, 0xFE, 0xC8, 0xC3, 0x50, 0x8A, 0xE, 0x29, + 0x0, 0x2A, 0xE, 0x57, 0x0, 0xFE, 0xC1, 0xB5, 0x0, 0x8A, 0x3E, + 0x49, 0x0, 0x8A, 0x1E, 0x4F, 0x0, 0xB0, 0x20, 0xB4, 0x9, 0xCD, + 0x10, 0x8B, 0x16, 0x56, 0x0, 0x86, 0xF2, 0xFE, 0xCE, 0xFE, 0xCA, + 0xB4, 0x2, 0xCD, 0x10, 0x58, 0xC3, 0x53, 0xE8, 0x15, 0x0, 0x8A, + 0x3E, 0x49, 0x0, 0x8A, 0x1E, 0x4F, 0x0, 0x8A, 0xE, 0x29, 0x0, + 0xB5, 0x0, 0xB0, 0x20, 0xB4, 0x9, 0xCD, 0x10, 0x5B, 0x50, 0x52, + 0x8B, 0xD3, 0x86, 0xF2, 0xFE, 0xCE, 0xFE, 0xCA, 0x8A, 0x3E, 0x49, + 0x0, 0xB4, 0x2, 0xCD, 0x10, 0x5A, 0x58, 0xC3, 0x53, 0x52, 0xB1, + 0x0, 0x8A, 0xEF, 0x8A, 0xF3, 0xE8, 0x1B, 0x0, 0xB4, 0x6, 0xCD, + 0x10, 0xEB, 0xF, 0x53, 0x52, 0xB1, 0x0, 0x8A, 0xEB, 0x8A, 0xF7, + 0xE8, 0xA, 0x0, 0xB4, 0x7, 0xCD, 0x10, 0xE8, 0x1C, 0x0, 0x5A, + 0x5B, 0xC3, 0xE8, 0x11, 0x0, 0x8A, 0x16, 0x29, 0x0, 0xFE, 0xCA, + 0xFE, 0xCE, 0xFE, 0xCD, 0xB0, 0x1, 0x8A, 0x3E, 0x4F, 0x0, 0xC3, + 0xA0, 0x49, 0x0, 0xEB, 0x3, 0xA0, 0x4A, 0x0, 0xE8, 0x6, 0x1, + 0x75, 0x20, 0x8A, 0x26, 0x48, 0x0, 0x80, 0xFC, 0x7, 0x74, 0x17, + 0x52, 0xBA, 0x0, 0x8, 0x80, 0xFC, 0x2, 0x72, 0x2, 0xD0, 0xE6, + 0x32, 0xE4, 0xF7, 0xE2, 0x1E, 0x8E, 0xDA, 0xA3, 0x4E, 0x4, 0x1F, + 0x5A, 0xC3, 0x9C, 0x53, 0x52, 0x50, 0xBA, 0x0, 0x0, 0xB4, 0x0, + 0xCD, 0x17, 0x8A, 0xC4, 0x80, 0xE4, 0x28, 0x80, 0xFC, 0x28, 0x74, + 0xD, 0xF6, 0xC4, 0x8, 0x75, 0xC, 0xA8, 0x1, 0x74, 0xD, 0xB2, + 0x18, 0xEB, 0x6, 0xB2, 0x1B, 0xEB, 0x2, 0xB2, 0x19, 0xE9, 0xBA, + 0xB7, 0x58, 0x50, 0x3C, 0xD, 0xE9, 0x5D, 0xF, 0x58, 0x5A, 0x5B, + 0x9D, 0xC3, 0x3C, 0x93, 0x74, 0x60, 0x3C, 0x95, 0x74, 0x46, 0x3C, + 0xDD, 0x74, 0x46, 0xE8, 0xE3, 0xCE, 0xA, 0xC0, 0x74, 0x38, 0xFE, + 0xC8, 0x3C, 0xA, 0x73, 0x32, 0xBA, 0x10, 0x0, 0xF6, 0xE2, 0x8A, + 0xD0, 0x81, 0xC2, 0x53, 0x6, 0x52, 0xE8, 0xA2, 0xDD, 0x2C, 0xE8, + 0xD1, 0xC6, 0x53, 0xE8, 0x4C, 0xD8, 0x8A, 0xF, 0x80, 0xF9, 0xF, + 0x72, 0x2, 0xB1, 0xF, 0x43, 0x8B, 0x37, 0x5B, 0x5F, 0x53, 0xB5, + 0x0, 0xFC, 0xF3, 0xA4, 0x88, 0x2D, 0xE8, 0x72, 0xFB, 0x5B, 0xC3, + 0xE9, 0xE1, 0xBF, 0xB0, 0xFF, 0xEB, 0x2, 0xB0, 0x0, 0x3A, 0x6, + 0x71, 0x0, 0xA2, 0x71, 0x0, 0x74, 0x3, 0xE8, 0x5E, 0x0, 0xE8, + 0x90, 0xBE, 0xC3, 0x53, 0xBE, 0x53, 0x6, 0xB9, 0xA, 0x0, 0xFE, + 0xC5, 0x56, 0xB0, 0x46, 0xE8, 0x8, 0xDB, 0x51, 0x8A, 0xDD, 0xB7, + 0x0, 0xE8, 0xAB, 0x14, 0xB0, 0x20, 0xE8, 0xFB, 0xDA, 0x59, 0x5E, + 0x56, 0x51, 0xFC, 0xAC, 0xA, 0xC0, 0x74, 0x5, 0xE8, 0x13, 0x0, + 0xEB, 0xF5, 0xB0, 0xD, 0xE8, 0xE7, 0xDA, 0x59, 0x5E, 0x83, 0xC6, + 0x10, 0xFE, 0xC9, 0x75, 0xCE, 0x5B, 0xEB, 0xC0, 0x56, 0x3C, 0xD, + 0x75, 0x2, 0xB0, 0x1B, 0xE8, 0xD1, 0xDA, 0x5E, 0xC3, 0x50, 0xA0, + 0x48, 0x0, 0x3C, 0x7, 0x74, 0x4, 0x3C, 0x4, 0x73, 0x2, 0x32, + 0xC0, 0xA, 0xC0, 0x58, 0xC3, 0x53, 0xCD, 0xAD, 0xB6, 0x18, 0xB2, + 0x0, 0x8A, 0x3E, 0x49, 0x0, 0xB4, 0x2, 0xCD, 0x10, 0xA0, 0x71, + 0x0, 0xA, 0xC0, 0x75, 0x13, 0x8A, 0x1E, 0x4F, 0x0, 0x8A, 0xE, + 0x29, 0x0, 0xB5, 0x0, 0xB4, 0x9, 0xCD, 0x10, 0xE8, 0xD, 0xFE, + 0x5B, 0xC3, 0xB3, 0x7, 0xE8, 0xC0, 0xFF, 0x75, 0x9, 0xA0, 0x4C, + 0x0, 0xA, 0xC0, 0x75, 0x2, 0xB3, 0x70, 0xBE, 0x53, 0x6, 0xB5, + 0x5, 0xA0, 0x29, 0x0, 0x3C, 0x28, 0xB0, 0x31, 0x74, 0x2, 0xB5, + 0xA, 0x50, 0x53, 0x8A, 0x1E, 0x4E, 0x0, 0xE8, 0x37, 0x0, 0x5B, + 0x56, 0xB1, 0x6, 0x51, 0xFC, 0xAC, 0xA, 0xC0, 0x9C, 0x56, 0x75, + 0x2, 0x32, 0xC0, 0xE8, 0x25, 0x0, 0x5E, 0x9D, 0x75, 0x1, 0x4E, + 0x59, 0xFE, 0xC9, 0x75, 0xE8, 0xE8, 0x16, 0x0, 0x5E, 0x83, 0xC6, + 0x10, 0x58, 0xFE, 0xC0, 0x3C, 0x3A, 0x72, 0x2, 0xB0, 0x30, 0xFE, + 0xCD, 0x75, 0xC7, 0xE8, 0xAF, 0xFD, 0x5B, 0xC3, 0x32, 0xC0, 0x53, + 0xA, 0xC0, 0x75, 0x6, 0xB0, 0x20, 0x8A, 0x1E, 0x4F, 0x0, 0x3C, + 0xD, 0x75, 0x2, 0xB0, 0x1B, 0x51, 0xB9, 0x1, 0x0, 0xB4, 0x9, + 0xCD, 0x10, 0xFE, 0xC2, 0xB4, 0x2, 0xCD, 0x10, 0x59, 0x5B, 0xC3, + 0x8A, 0xE, 0x49, 0x0, 0xB5, 0x0, 0x8A, 0x26, 0x48, 0x0, 0xF6, + 0xC4, 0x1, 0x74, 0x3, 0x80, 0xCD, 0x80, 0x80, 0xFC, 0x4, 0x72, + 0x9, 0xFE, 0xC5, 0x80, 0xFC, 0x6, 0x72, 0x2, 0xFE, 0xC5, 0x51, + 0x3C, 0x2C, 0x74, 0xC, 0xE8, 0x61, 0xCD, 0x59, 0x8A, 0xE8, 0x51, + 0xE8, 0x5C, 0xBD, 0x74, 0x40, 0xE8, 0x2D, 0xDC, 0x2C, 0x3C, 0x2C, + 0x74, 0x15, 0xE8, 0x4D, 0xCD, 0xA, 0xC0, 0x74, 0x2, 0xB0, 0x80, + 0x59, 0x80, 0xE5, 0x3, 0xA, 0xE8, 0x51, 0xE8, 0x3F, 0xBD, 0x74, + 0x23, 0xE8, 0x10, 0xDC, 0x2C, 0x3C, 0x2C, 0x74, 0xC, 0xE8, 0x30, + 0xCD, 0x59, 0x8A, 0xC8, 0x51, 0xE8, 0x2B, 0xBD, 0x74, 0xF, 0xE8, + 0xFC, 0xDB, 0x2C, 0xE8, 0x20, 0xCD, 0x8A, 0xF0, 0x59, 0xEB, 0x6, + 0xE9, 0x55, 0xBE, 0x59, 0x8A, 0xF1, 0x8A, 0x26, 0x29, 0x0, 0x8A, + 0xC5, 0x24, 0x7F, 0xA, 0xC0, 0x74, 0xA, 0x32, 0xD2, 0xA, 0xD6, + 0xA, 0xD1, 0x75, 0xE6, 0xEB, 0x1B, 0x80, 0xFC, 0x28, 0x74, 0xC, + 0x80, 0xFE, 0x4, 0x73, 0xDA, 0x80, 0xF9, 0x4, 0x72, 0xC, 0xEB, + 0xD3, 0x80, 0xFE, 0x8, 0x73, 0xCE, 0x80, 0xF9, 0x8, 0x73, 0xC9, + 0x8A, 0xD1, 0xA, 0xC0, 0x74, 0x20, 0x80, 0x3E, 0x48, 0x0, 0x7, + 0x74, 0x5C, 0xB1, 0x6, 0x3C, 0x2, 0xB4, 0x50, 0x74, 0x2A, 0xB4, + 0x28, 0xFE, 0xC9, 0xFE, 0xC8, 0x75, 0xAC, 0xF6, 0xC5, 0x80, 0x75, + 0x1D, 0xFE, 0xC9, 0xEB, 0x19, 0xB1, 0x2, 0x80, 0xFC, 0x28, 0x74, + 0x9, 0xF6, 0xC5, 0x80, 0x74, 0xD, 0xFE, 0xC1, 0xEB, 0x9, 0xFE, + 0xC9, 0xF6, 0xC5, 0x80, 0x75, 0x2, 0xFE, 0xC9, 0x88, 0x26, 0x29, + 0x0, 0xA1, 0x48, 0x0, 0x88, 0xE, 0x48, 0x0, 0x89, 0x16, 0x49, + 0x0, 0x3A, 0xC1, 0x74, 0x1A, 0xB8, 0x7, 0x0, 0xA3, 0x4B, 0x0, + 0x86, 0xC4, 0xA3, 0x4D, 0x0, 0x88, 0x26, 0x4F, 0x0, 0xE8, 0x3A, + 0xFE, 0x74, 0x3, 0xA2, 0x4F, 0x0, 0xE8, 0x6E, 0x0, 0xA0, 0x4A, + 0x0, 0xB4, 0x5, 0xCD, 0x10, 0xC3, 0x3A, 0x6, 0x29, 0x0, 0x74, + 0x34, 0x8A, 0x26, 0x48, 0x0, 0x3C, 0x50, 0x74, 0x7, 0x3C, 0x28, + 0x74, 0x3, 0xE9, 0x98, 0xBD, 0x80, 0xFC, 0x7, 0x75, 0x4, 0xB0, + 0x50, 0xEB, 0x1C, 0x80, 0xF4, 0x2, 0x80, 0xFC, 0x7, 0x75, 0x2, + 0xFE, 0xCC, 0x50, 0xA2, 0x29, 0x0, 0x88, 0x26, 0x48, 0x0, 0xC7, + 0x6, 0x49, 0x0, 0x0, 0x0, 0xE8, 0x2D, 0x0, 0x58, 0xC3, 0x53, + 0xE8, 0xDA, 0xFC, 0xB2, 0x27, 0x80, 0x3E, 0x29, 0x0, 0x28, 0x74, + 0x2, 0xB2, 0x4F, 0xB6, 0x18, 0x8A, 0x3E, 0x4F, 0x0, 0xB9, 0x0, + 0x0, 0x8A, 0xC1, 0xB4, 0x6, 0xCD, 0x10, 0xBA, 0x0, 0x0, 0x8A, + 0x3E, 0x49, 0x0, 0xB4, 0x2, 0xCD, 0x10, 0xEB, 0xF, 0x53, 0xB9, + 0x0, 0x0, 0x89, 0xE, 0x49, 0x0, 0xA0, 0x48, 0x0, 0xB4, 0x0, + 0xCD, 0x10, 0xE8, 0xBD, 0xDD, 0xE8, 0xC9, 0xF8, 0xE8, 0x8A, 0xF7, + 0xE8, 0x9D, 0xFC, 0x5B, 0xC3, 0xE8, 0xA4, 0xFD, 0x74, 0x5B, 0xB1, + 0x0, 0xBE, 0x51, 0x0, 0x80, 0x3E, 0x48, 0x0, 0x6, 0x75, 0x3, + 0xE9, 0x16, 0xBD, 0x8A, 0x2C, 0x56, 0x51, 0xE8, 0xD4, 0xBB, 0x74, + 0x40, 0x3C, 0x2C, 0x74, 0x7, 0xE8, 0xC9, 0xCB, 0x59, 0x8A, 0xE8, + 0x51, 0x59, 0x51, 0x53, 0x8A, 0xF9, 0x8A, 0xDD, 0x80, 0xFF, 0x0, + 0x75, 0x8, 0x80, 0xFB, 0x8, 0x72, 0x3, 0x80, 0xCB, 0x10, 0xB4, + 0xB, 0xCD, 0x10, 0x5B, 0xE8, 0xAB, 0xBB, 0x74, 0x3, 0xE8, 0xA5, + 0xBB, 0x59, 0x5E, 0x88, 0x2C, 0x74, 0x8, 0x46, 0xFE, 0xC1, 0x80, + 0xF9, 0x4, 0x72, 0xBD, 0xC6, 0x6, 0x4F, 0x0, 0x0, 0xC3, 0x59, + 0x5E, 0xC3, 0xFF, 0x36, 0x4D, 0x0, 0xFF, 0x36, 0x4B, 0x0, 0x3C, + 0x2C, 0x74, 0x10, 0xE8, 0x7E, 0xCB, 0x3C, 0x20, 0x73, 0x18, 0x59, + 0x8A, 0xC8, 0x51, 0xE8, 0x75, 0xBB, 0x74, 0x2C, 0xE8, 0x46, 0xDA, + 0x2C, 0x3C, 0x2C, 0x74, 0x13, 0xE8, 0x66, 0xCB, 0x3C, 0x10, 0x72, + 0x3, 0xE9, 0x9C, 0xBC, 0x59, 0x8A, 0xE8, 0x51, 0xE8, 0x5A, 0xBB, + 0x74, 0x11, 0xE8, 0x2B, 0xDA, 0x2C, 0xE8, 0x4F, 0xCB, 0x3C, 0x10, + 0x73, 0xE9, 0x59, 0x5A, 0x8A, 0xD0, 0x52, 0x51, 0x59, 0x5A, 0x8A, + 0xF1, 0x80, 0xE6, 0xF, 0x89, 0xE, 0x4B, 0x0, 0x8A, 0xC5, 0xD0, + 0xE0, 0x24, 0x10, 0xA, 0xC2, 0x80, 0xE5, 0x7, 0xD0, 0xE5, 0xD0, + 0xE5, 0xD0, 0xE5, 0xD0, 0xE5, 0xF6, 0xC1, 0x10, 0x74, 0x3, 0x80, + 0xCD, 0x80, 0xA, 0xEE, 0x53, 0x8A, 0xD8, 0xB7, 0x0, 0x24, 0xF, + 0xA2, 0x4D, 0x0, 0x88, 0x2E, 0x4E, 0x0, 0x88, 0x2E, 0x4F, 0x0, + 0xB4, 0xB, 0xCD, 0x10, 0x5B, 0xC3, 0xFF, 0x36, 0x56, 0x0, 0x3C, + 0x2C, 0x74, 0x20, 0xE8, 0xFA, 0xCA, 0xA, 0xC0, 0x74, 0x5B, 0x3C, + 0x1A, 0x73, 0x57, 0x8A, 0x26, 0x71, 0x0, 0xA, 0xE4, 0x74, 0x4, + 0x3C, 0x19, 0x73, 0x4B, 0x5A, 0x8A, 0xD0, 0x52, 0xE8, 0xE1, 0xBA, + 0x74, 0x7B, 0xE8, 0xB2, 0xD9, 0x2C, 0x3C, 0x2C, 0x74, 0x18, 0xE8, + 0xD2, 0xCA, 0xA, 0xC0, 0x74, 0x33, 0x8A, 0x26, 0x29, 0x0, 0x3A, + 0xE0, 0x72, 0x2B, 0x5A, 0x8A, 0xF0, 0x52, 0xE8, 0xC1, 0xBA, 0x74, + 0x5B, 0xFF, 0x36, 0x68, 0x0, 0xE8, 0x8E, 0xD9, 0x2C, 0x3C, 0x2C, + 0x74, 0x19, 0xE8, 0xAE, 0xCA, 0xA, 0xC0, 0xB0, 0x0, 0x75, 0x2, + 0xB0, 0x20, 0x59, 0xA, 0xE8, 0x51, 0xE8, 0xA1, 0xBA, 0x74, 0x2D, + 0xEB, 0x3, 0xE9, 0xD5, 0xBB, 0xE8, 0x6D, 0xD9, 0x2C, 0xE8, 0x91, + 0xCA, 0x3C, 0x20, 0x73, 0xF2, 0x59, 0x80, 0xE5, 0x20, 0xA, 0xE8, + 0x8A, 0xC8, 0x51, 0xE8, 0x83, 0xBA, 0x74, 0xF, 0xE8, 0x54, 0xD9, + 0x2C, 0xE8, 0x78, 0xCA, 0x3C, 0x20, 0x73, 0xD9, 0x59, 0x8A, 0xC8, + 0x51, 0x59, 0x51, 0x80, 0xE5, 0xF, 0x89, 0xE, 0x68, 0x0, 0x59, + 0xB4, 0x1, 0xCD, 0x10, 0x5A, 0x89, 0x16, 0x56, 0x0, 0x86, 0xF2, + 0xFE, 0xCE, 0xFE, 0xCA, 0x53, 0x8A, 0x3E, 0x49, 0x0, 0xB4, 0x2, + 0xCD, 0x10, 0x5B, 0xC3, 0x50, 0xB0, 0x0, 0xEB, 0x3, 0x50, 0xB0, + 0x20, 0x9C, 0x51, 0x53, 0x50, 0xE8, 0x3D, 0xFA, 0x58, 0x5B, 0x8B, + 0xE, 0x68, 0x0, 0xF6, 0x6, 0x72, 0x0, 0xFF, 0x74, 0x2, 0xB5, + 0x4, 0xA, 0xE8, 0xB4, 0x1, 0xCD, 0x10, 0x59, 0x9D, 0x58, 0xC3, + 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x50, 0x9C, 0xE8, 0xC9, 0xFB, 0x74, + 0x4B, 0x53, 0x51, 0x52, 0x8C, 0xC6, 0xBF, 0x0, 0x0, 0x8E, 0xC7, + 0x26, 0xFF, 0x36, 0x7C, 0x0, 0x26, 0xFF, 0x36, 0x7E, 0x0, 0x26, + 0xC7, 0x6, 0x7C, 0x0, 0xF8, 0x54, 0x26, 0x8C, 0xE, 0x7E, 0x0, + 0x8E, 0xC6, 0xB0, 0x81, 0x2, 0x6, 0x72, 0x0, 0xB3, 0x83, 0x8A, + 0x3E, 0x49, 0x0, 0xB9, 0x1, 0x0, 0xB4, 0x9, 0xCD, 0x10, 0x8C, + 0xC6, 0xBF, 0x0, 0x0, 0x8E, 0xC7, 0x26, 0x8F, 0x6, 0x7E, 0x0, + 0x26, 0x8F, 0x6, 0x7C, 0x0, 0x8E, 0xC6, 0x5A, 0x59, 0x5B, 0x9D, + 0x58, 0xC3, 0xE8, 0xBD, 0xB9, 0xA0, 0x56, 0x0, 0xE9, 0x72, 0xF6, + 0xE8, 0xB4, 0xB9, 0xE8, 0x65, 0x0, 0xA, 0xEE, 0x75, 0x56, 0xA, + 0xEA, 0xA, 0xE9, 0x74, 0x50, 0x8A, 0x26, 0x29, 0x0, 0x3A, 0xE2, + 0x72, 0x48, 0x80, 0xF9, 0x1A, 0x73, 0x43, 0xA0, 0x71, 0x0, 0xA, + 0xC0, 0x74, 0x5, 0x80, 0xF9, 0x19, 0x73, 0x37, 0x53, 0x8A, 0xF1, + 0xFE, 0xCE, 0xFE, 0xCA, 0x8A, 0x3E, 0x49, 0x0, 0xB4, 0x2, 0xCD, + 0x10, 0xB4, 0x8, 0xCD, 0x10, 0x5B, 0x50, 0xE8, 0x77, 0xB9, 0x3C, + 0x2C, 0x74, 0x4, 0xB0, 0x0, 0xEB, 0x7, 0xE8, 0x42, 0xD8, 0x2C, + 0xE8, 0x66, 0xC9, 0x50, 0xE8, 0x3A, 0xD8, 0x29, 0x58, 0xA, 0xC0, + 0x58, 0x74, 0x2, 0x8A, 0xC4, 0xE9, 0x12, 0xF6, 0xE9, 0x90, 0xBA, + 0xE8, 0x5, 0x0, 0xE8, 0x25, 0xD8, 0x29, 0xC3, 0xE8, 0x20, 0xD8, + 0x28, 0xE8, 0x32, 0xC9, 0x52, 0xE8, 0x18, 0xD8, 0x2C, 0xE8, 0x2A, + 0xC9, 0x59, 0xC3, 0xE8, 0x38, 0xB9, 0x3C, 0x95, 0x74, 0x8, 0xE8, + 0x8, 0xD8, 0xDD, 0x32, 0xC0, 0xEB, 0x5, 0xE8, 0x29, 0xB9, 0xB0, + 0xFF, 0xA2, 0x34, 0x0, 0xC3, 0xA0, 0x34, 0x0, 0xA, 0xC0, 0x74, + 0x30, 0xE8, 0x1B, 0xC9, 0x3C, 0xA, 0x73, 0x29, 0x53, 0x56, 0xBA, + 0x1A, 0x56, 0x52, 0x32, 0xE4, 0xD1, 0xE0, 0x8B, 0xF0, 0x2E, 0xFF, + 0xB4, 0x1D, 0x56, 0xC3, 0x5E, 0x5B, 0xC3, 0x34, 0x56, 0x3F, 0x56, + 0x46, 0x56, 0x4C, 0x56, 0x6B, 0x56, 0x72, 0x56, 0x78, 0x56, 0x80, + 0x56, 0x88, 0x56, 0x90, 0x56, 0xE9, 0x25, 0xBA, 0xBB, 0x35, 0x0, + 0x8A, 0x7, 0xC6, 0x7, 0x0, 0xE9, 0x9F, 0xF5, 0x8B, 0x1E, 0x37, + 0x0, 0xE9, 0xC6, 0xE, 0xA0, 0x39, 0x0, 0xE9, 0x8C, 0xF5, 0xB4, + 0x4, 0xCD, 0x10, 0x50, 0xA, 0xE4, 0x74, 0xC, 0x89, 0x1E, 0x3A, + 0x0, 0x88, 0x2E, 0x3C, 0x0, 0x89, 0x16, 0x3F, 0x0, 0x58, 0x8A, + 0xC4, 0xFE, 0xC8, 0xF6, 0xD0, 0xE9, 0x73, 0xF5, 0x8B, 0x1E, 0x3A, + 0x0, 0xE9, 0x9A, 0xE, 0xA0, 0x3C, 0x0, 0xE9, 0x60, 0xF5, 0xA0, + 0x3E, 0x0, 0xFE, 0xC0, 0xE9, 0x58, 0xF5, 0xA0, 0x3D, 0x0, 0xFE, + 0xC0, 0xE9, 0x50, 0xF5, 0xA0, 0x40, 0x0, 0xFE, 0xC0, 0xE9, 0x48, + 0xF5, 0xA0, 0x3F, 0x0, 0xFE, 0xC0, 0xE9, 0x40, 0xF5, 0xE8, 0x84, + 0xC8, 0xA, 0xC0, 0x74, 0x12, 0x3C, 0x4, 0x73, 0x54, 0xB4, 0x0, + 0x53, 0xBB, 0x41, 0x0, 0x3, 0xD8, 0x8A, 0x7, 0x5B, 0xE9, 0x27, + 0xF5, 0x53, 0xBA, 0x1, 0x2, 0xB9, 0x1, 0x1, 0xBB, 0xF, 0x0, + 0xFA, 0xEE, 0xEC, 0x24, 0xF, 0x3A, 0xC3, 0xE1, 0xF9, 0xE3, 0xB, + 0x32, 0xC3, 0x8A, 0xE1, 0x50, 0xFE, 0xC7, 0x32, 0xD8, 0xEB, 0xEC, + 0xA, 0xFF, 0x74, 0x1A, 0x8A, 0xD7, 0xBB, 0x41, 0x0, 0xB9, 0x4, + 0x0, 0x58, 0xF6, 0xD4, 0x2, 0xE2, 0xD0, 0xE8, 0x73, 0x2, 0x88, + 0x27, 0x43, 0xE2, 0xF7, 0xFE, 0xCA, 0x75, 0xE8, 0xFB, 0x5B, 0xA0, + 0x41, 0x0, 0xE9, 0xE1, 0xF4, 0xE9, 0x5F, 0xB9, 0xE8, 0x20, 0xB8, + 0x3C, 0x95, 0x74, 0x8, 0xE8, 0xF0, 0xD6, 0xDD, 0x32, 0xC0, 0xEB, + 0x5, 0xE8, 0x11, 0xB8, 0xB0, 0xFF, 0xA2, 0x45, 0x0, 0xC3, 0xA0, + 0x45, 0x0, 0xA, 0xC0, 0x74, 0xDE, 0xE8, 0x3, 0xC8, 0x3C, 0x4, + 0x73, 0xD7, 0xA8, 0x1, 0x74, 0xE, 0xB4, 0x10, 0xFE, 0xC8, 0x74, + 0x2, 0xB4, 0x40, 0xE8, 0xD0, 0x0, 0xE9, 0xAC, 0xF4, 0x53, 0xBB, + 0x46, 0x0, 0xA, 0xC0, 0x74, 0x1, 0x43, 0x8A, 0x7, 0xC6, 0x7, + 0x0, 0x5B, 0xE9, 0x9A, 0xF4, 0x9C, 0x50, 0x55, 0x56, 0x57, 0x1E, + 0xBA, 0x0, 0x0, 0x8E, 0xDA, 0x8E, 0x1E, 0x10, 0x5, 0xA1, 0x66, + 0x0, 0xA, 0xC4, 0x74, 0x9, 0xFF, 0xE, 0x66, 0x0, 0x75, 0x3, + 0xE8, 0x27, 0x0, 0xA0, 0x34, 0x0, 0xA, 0xC0, 0x74, 0x3, 0xE8, + 0x36, 0x0, 0xA0, 0x45, 0x0, 0xA, 0xC0, 0x74, 0x3, 0xE8, 0x69, + 0x0, 0x1F, 0x5F, 0x5E, 0x5D, 0x58, 0x9D, 0xCF, 0xC6, 0x6, 0x65, + 0x0, 0x0, 0xA1, 0x66, 0x0, 0xB, 0xC0, 0x74, 0x18, 0x52, 0xFA, + 0xF6, 0x6, 0x65, 0x0, 0xFF, 0x75, 0x7, 0xBA, 0x61, 0x0, 0xEC, + 0x24, 0xFC, 0xEE, 0xC7, 0x6, 0x66, 0x0, 0x0, 0x0, 0xFB, 0x5A, + 0xC3, 0x53, 0x51, 0x52, 0xB4, 0x4, 0xCD, 0x10, 0x50, 0xA, 0xE4, + 0x74, 0xC, 0x89, 0x1E, 0x3A, 0x0, 0x88, 0x2E, 0x3C, 0x0, 0x89, + 0x16, 0x3F, 0x0, 0x58, 0xA0, 0x36, 0x0, 0x32, 0xC4, 0x74, 0x19, + 0xA, 0xE4, 0x88, 0x26, 0x36, 0x0, 0x74, 0x11, 0x89, 0x1E, 0x37, + 0x0, 0x88, 0x2E, 0x39, 0x0, 0x89, 0x16, 0x3D, 0x0, 0xB0, 0xFF, + 0xA2, 0x35, 0x0, 0x5A, 0x59, 0x5B, 0xC3, 0x53, 0xBB, 0x46, 0x0, + 0x80, 0x3F, 0x0, 0x75, 0x7, 0xB4, 0x10, 0xE8, 0x11, 0x0, 0x88, + 0x7, 0x43, 0x80, 0x3F, 0x0, 0x75, 0x7, 0xB4, 0x40, 0xE8, 0x4, + 0x0, 0x88, 0x7, 0x5B, 0xC3, 0x52, 0xBA, 0x1, 0x2, 0xEC, 0x22, + 0xC4, 0xFE, 0xC8, 0x98, 0x8A, 0xC4, 0x5A, 0xC3, 0xE8, 0x9, 0x0, + 0xB8, 0xD3, 0x5, 0xBA, 0x4, 0x0, 0x52, 0xEB, 0x38, 0x8B, 0x16, + 0x66, 0x0, 0xA, 0xF2, 0x74, 0x7, 0xC6, 0x6, 0x65, 0x0, 0xFF, + 0xEB, 0xF1, 0xC3, 0xE8, 0xDE, 0xC6, 0x83, 0xFA, 0x25, 0x72, 0x12, + 0x52, 0xE8, 0xBF, 0xD5, 0x2C, 0xE8, 0x71, 0xCA, 0x59, 0x52, 0xB, + 0xD2, 0x75, 0x7, 0x5A, 0xE9, 0x3B, 0xFF, 0xE9, 0x13, 0xB8, 0xE8, + 0xD0, 0xFF, 0xBA, 0x12, 0x0, 0xB8, 0xDC, 0x34, 0xF7, 0xF1, 0xF6, + 0x6, 0x65, 0x0, 0xFF, 0x75, 0x8, 0x50, 0xBA, 0x43, 0x0, 0xB0, + 0xB6, 0xEE, 0x58, 0xBA, 0x42, 0x0, 0xEE, 0x8A, 0xC4, 0xEE, 0x75, + 0x7, 0xBA, 0x61, 0x0, 0xEC, 0xC, 0x3, 0xEE, 0x5A, 0x89, 0x16, + 0x66, 0x0, 0xC6, 0x6, 0x65, 0x0, 0x0, 0xC3, 0xA, 0x5A, 0x4D, + 0x41, 0x59, 0x10, 0x59, 0x10, 0x19, 0x5A, 0x59, 0x10, 0x59, 0x10, + 0x59, 0x10, 0x59, 0x10, 0x2D, 0x5A, 0x59, 0x10, 0x34, 0x5A, 0x4D, + 0x41, 0x59, 0x10, 0x45, 0x5A, 0x59, 0x10, 0x59, 0x10, 0x59, 0x10, + 0x59, 0x10, 0x59, 0x10, 0x59, 0x10, 0x5D, 0x5A, 0x63, 0x5A, 0x4D, + 0x41, 0x59, 0x10, 0x7C, 0x5A, 0x59, 0x10, 0x59, 0x10, 0x59, 0x10, + 0x59, 0x10, 0x59, 0x10, 0x59, 0x10, 0xAA, 0x5A, 0xB1, 0x5A, 0x6E, + 0x5B, 0x59, 0x10, 0xAB, 0x5B, 0xF0, 0x5B, 0x59, 0x10, 0x59, 0x10, + 0x6C, 0x5C, 0x59, 0x10, 0x76, 0x5C, 0x59, 0x10, 0x22, 0xC2, 0x75, + 0x22, 0x9C, 0x50, 0x53, 0x89, 0x1E, 0xE9, 0x4, 0x88, 0x17, 0x83, + 0xC3, 0x2D, 0xC6, 0x7, 0x0, 0x43, 0x43, 0x88, 0x2F, 0x43, 0xC6, + 0x7, 0x0, 0x43, 0x88, 0xF, 0x43, 0xC6, 0x7, 0x0, 0x5B, 0x58, + 0x9D, 0xC3, 0xE9, 0x98, 0xAE, 0x58, 0x5B, 0xC3, 0x80, 0xFA, 0x80, + 0x75, 0x2, 0xB2, 0x2, 0xC3, 0x58, 0x86, 0xC4, 0x9E, 0x59, 0x5A, + 0x5B, 0xC3, 0x5A, 0x5B, 0x59, 0xC3, 0x83, 0xC3, 0x2E, 0x8A, 0x7, + 0xF6, 0xD0, 0xC3, 0x8B, 0x1E, 0xE9, 0x4, 0x83, 0xC3, 0x2B, 0xC3, + 0x8B, 0x1E, 0xE9, 0x4, 0x83, 0xC3, 0x32, 0xC3, 0x8B, 0x1E, 0xE9, + 0x4, 0x8A, 0x87, 0x2F, 0x0, 0xC3, 0x56, 0x57, 0x51, 0xC6, 0x6, + 0x3F, 0x5, 0xA5, 0xBE, 0xF0, 0x4, 0xBF, 0x40, 0x5, 0xB9, 0x8, + 0x0, 0xFC, 0xA4, 0xE2, 0xFD, 0x59, 0x5F, 0x5E, 0xC3, 0x53, 0x51, + 0xBB, 0x40, 0x5, 0xB1, 0x8, 0x80, 0x3F, 0x20, 0x75, 0xD, 0x43, + 0xFE, 0xC9, 0x75, 0xF6, 0xBE, 0x5C, 0x5, 0xBF, 0x48, 0x5, 0xEB, + 0x10, 0xBE, 0x54, 0x5, 0xBF, 0x40, 0x5, 0xB1, 0x8, 0xFC, 0xA6, + 0x75, 0x27, 0xFE, 0xC9, 0x75, 0xF9, 0x8A, 0x5, 0x3A, 0x4, 0x74, + 0x9, 0xA, 0xC0, 0x75, 0x19, 0xF6, 0x4, 0x1, 0x75, 0x14, 0x8A, + 0x4, 0x8B, 0x1E, 0xE9, 0x4, 0x88, 0x87, 0x31, 0x0, 0xBB, 0xF4, + 0x59, 0xE8, 0xE, 0x0, 0x32, 0xC0, 0xEB, 0x7, 0xBB, 0xFE, 0x59, + 0xE8, 0x4, 0x0, 0xF9, 0x59, 0x5B, 0xC3, 0x53, 0x8B, 0x1E, 0x2E, + 0x0, 0x43, 0xB, 0xDB, 0x74, 0x2, 0x5B, 0xC3, 0xBB, 0x53, 0x5, + 0x53, 0x43, 0xB1, 0x8, 0x8A, 0x7, 0xE8, 0xD5, 0xF4, 0x43, 0xFE, + 0xC9, 0x75, 0xF6, 0xB0, 0x2E, 0xE8, 0xCB, 0xF4, 0x5B, 0x83, 0xC3, + 0x9, 0xB0, 0x44, 0xF6, 0x7, 0xE1, 0x74, 0x17, 0xB0, 0x50, 0xF6, + 0x7, 0x20, 0x75, 0x10, 0xB0, 0x42, 0xF6, 0x7, 0x80, 0x75, 0x9, + 0xB0, 0x41, 0xF6, 0x7, 0x40, 0x75, 0x2, 0xB0, 0x4D, 0x5B, 0xE8, + 0xA5, 0xF4, 0x2E, 0x8A, 0x7, 0x43, 0xA, 0xC0, 0x75, 0xF5, 0xC3, + 0x20, 0x46, 0x6F, 0x75, 0x6E, 0x64, 0x2E, 0xFF, 0xD, 0x0, 0x20, + 0x53, 0x6B, 0x69, 0x70, 0x70, 0x65, 0x64, 0x2E, 0xFF, 0xD, 0x0, + 0xB9, 0x0, 0x0, 0x88, 0xE, 0x52, 0x5, 0xB0, 0xEA, 0xE8, 0xBD, + 0xFE, 0xE9, 0xE3, 0xFE, 0xBB, 0x52, 0x5, 0x8A, 0x7, 0xC6, 0x7, + 0x0, 0xA, 0xC0, 0x75, 0x5, 0xE8, 0x46, 0xF3, 0xA, 0xC0, 0xE9, + 0xE2, 0xFE, 0x88, 0xE, 0x52, 0x5, 0xE9, 0xA3, 0xEB, 0xE8, 0xC8, + 0xFE, 0x8A, 0x2E, 0x29, 0x0, 0xB1, 0x0, 0xB0, 0xED, 0xE8, 0x91, + 0xFE, 0xE9, 0xB7, 0xFE, 0x58, 0x50, 0x86, 0xC4, 0xE8, 0x44, 0xF4, + 0x8A, 0xE, 0x57, 0x0, 0xFE, 0xC9, 0x8B, 0x1E, 0xE9, 0x4, 0x88, + 0x8F, 0x32, 0x0, 0xE9, 0xAA, 0xFE, 0x58, 0x86, 0xC4, 0xE9, 0x49, + 0xF8, 0x8A, 0x2E, 0x62, 0x0, 0xB1, 0x0, 0xE8, 0x93, 0xFE, 0xB0, + 0x6D, 0xE8, 0x62, 0xFE, 0xE8, 0xAF, 0xFE, 0xA0, 0x63, 0x0, 0x88, + 0x7, 0xE9, 0x80, 0xFE, 0x58, 0x50, 0x86, 0xC4, 0xE8, 0x3, 0x0, + 0xE9, 0x81, 0xFE, 0xE8, 0x6A, 0xF5, 0xBB, 0x63, 0x0, 0x3C, 0xD, + 0x75, 0x3, 0xE9, 0xE4, 0x4, 0x3C, 0x20, 0x73, 0x1, 0xC3, 0xFE, + 0x7, 0x53, 0xE8, 0x8D, 0xFE, 0x5B, 0xFE, 0xC0, 0x74, 0xF4, 0xFE, + 0xC8, 0x38, 0x7, 0xE9, 0xC5, 0x4, 0x58, 0x86, 0xC4, 0xA2, 0x62, + 0x0, 0xC3, 0xA0, 0x61, 0x0, 0xA, 0xC0, 0x74, 0x3, 0xE9, 0xE8, + 0xAC, 0x80, 0xE2, 0xFB, 0x75, 0x2, 0xB2, 0x1, 0xA2, 0x51, 0x5, + 0xFE, 0xC0, 0xA2, 0x50, 0x5, 0x8A, 0xCA, 0x80, 0xE1, 0x80, 0x80, + 0xE9, 0x1, 0xF5, 0x1A, 0xC9, 0x80, 0xE1, 0x80, 0xF6, 0xC2, 0x10, + 0x74, 0x3, 0x80, 0xC9, 0x20, 0xA0, 0x60, 0x0, 0xA, 0xC0, 0x74, + 0x2, 0xB1, 0x1, 0xA, 0xC9, 0x75, 0x9, 0xF6, 0x6, 0x5F, 0x0, + 0xFF, 0x74, 0x2, 0xB1, 0x40, 0x88, 0xE, 0x48, 0x5, 0xB5, 0xFF, + 0xB0, 0x68, 0xE8, 0xD2, 0xFD, 0x8A, 0x27, 0xE8, 0x2E, 0xFE, 0xF6, + 0xC4, 0x1, 0x75, 0xC, 0xF6, 0xC1, 0x81, 0x75, 0x3, 0xE8, 0x2F, + 0x0, 0xB0, 0xFF, 0xEB, 0x1F, 0xE8, 0x33, 0x0, 0xE8, 0x30, 0xFE, + 0x72, 0xF8, 0x8B, 0x1E, 0xE9, 0x4, 0xF6, 0x87, 0x31, 0x0, 0x81, + 0x75, 0xA, 0xE8, 0x11, 0x1, 0x73, 0x5, 0xC6, 0x6, 0x50, 0x5, + 0x0, 0xB0, 0x1, 0xA2, 0x61, 0x0, 0xE8, 0xE7, 0xFD, 0xC6, 0x7, + 0x1, 0xE9, 0xBA, 0xFD, 0xBB, 0x3F, 0x5, 0xB9, 0x11, 0x0, 0xB4, + 0x3, 0xCD, 0x15, 0xC3, 0xBB, 0x53, 0x5, 0xB9, 0x11, 0x0, 0x53, + 0xB4, 0x2, 0xCD, 0x15, 0x73, 0x3, 0xE9, 0x2, 0x1, 0x5B, 0xA0, + 0x5E, 0x0, 0xA, 0xC0, 0x75, 0x6, 0x80, 0x3F, 0xA5, 0x75, 0xE6, + 0xC3, 0xE9, 0x29, 0xAC, 0xA0, 0x61, 0x0, 0xFE, 0xC0, 0x74, 0xB, + 0x32, 0xC0, 0xA2, 0x61, 0x0, 0xA2, 0x60, 0x0, 0xE9, 0xCD, 0xE5, + 0x8B, 0x1E, 0xE9, 0x4, 0xF6, 0x87, 0x31, 0x0, 0x81, 0x75, 0xEA, + 0xE8, 0x3B, 0x0, 0xE8, 0x1F, 0x1, 0xEB, 0xE2, 0x53, 0xBB, 0x61, + 0x0, 0x38, 0x27, 0x75, 0xD, 0x8B, 0x1E, 0xE9, 0x4, 0xF6, 0x87, + 0x31, 0x0, 0x81, 0x5B, 0x75, 0x1, 0xC3, 0xE9, 0xE9, 0xAB, 0xB4, + 0xFF, 0xE8, 0xE3, 0xFF, 0x58, 0x50, 0x86, 0xC4, 0xE8, 0x3, 0x0, + 0xE9, 0x4D, 0xFD, 0xE8, 0x26, 0x0, 0x88, 0x7, 0xFE, 0xC1, 0x74, + 0xB, 0xE8, 0x5D, 0xFD, 0x88, 0xF, 0xC3, 0xE8, 0x57, 0xFD, 0x8A, + 0xF, 0xBB, 0x53, 0x5, 0xB5, 0x0, 0xFE, 0xC9, 0x41, 0x88, 0xF, + 0xB4, 0x3, 0xCD, 0x15, 0xE8, 0x44, 0xFD, 0xC6, 0x7, 0x1, 0xC3, + 0xE8, 0x3D, 0xFD, 0x8A, 0xF, 0xB5, 0x0, 0xBB, 0x53, 0x5, 0x3, + 0xD9, 0xC3, 0xB4, 0x1, 0xE8, 0x9E, 0xFF, 0xE8, 0x3, 0x0, 0xE9, + 0x14, 0xFD, 0xA0, 0x50, 0x5, 0x2C, 0x1, 0x73, 0x1, 0xC3, 0xBB, + 0x51, 0x5, 0x8A, 0x7, 0xC6, 0x7, 0x0, 0xA, 0xC0, 0x74, 0x1, + 0xC3, 0xE8, 0xA, 0x0, 0x73, 0x7, 0xC6, 0x6, 0x50, 0x5, 0x0, + 0xA, 0xC0, 0xC3, 0xE8, 0xC3, 0xFF, 0x8A, 0x7, 0xFE, 0xC1, 0xE8, + 0xFC, 0xFC, 0x88, 0xF, 0xE8, 0xEF, 0xFC, 0x3A, 0xF, 0x74, 0x3, + 0xA, 0xC0, 0xC3, 0x80, 0x3F, 0x0, 0x75, 0xDD, 0x50, 0xE8, 0x2, + 0x0, 0x58, 0xC3, 0xBB, 0x53, 0x5, 0xB9, 0x0, 0x1, 0xB4, 0x2, + 0xCD, 0x15, 0x72, 0x15, 0xA0, 0x53, 0x5, 0xE8, 0xCB, 0xFC, 0x88, + 0x7, 0xE8, 0xCE, 0xFC, 0xC6, 0x7, 0x1, 0xFE, 0xC8, 0xF9, 0x74, + 0x1, 0xF8, 0xC3, 0x80, 0xFC, 0x4, 0x75, 0x5, 0xB2, 0x18, 0xE9, + 0x6F, 0xAB, 0xE9, 0x25, 0xAB, 0xA0, 0x50, 0x5, 0x2C, 0x1, 0x1A, + 0xC0, 0xE9, 0x93, 0x8, 0x88, 0xE, 0x51, 0x5, 0xE9, 0x5A, 0xE9, + 0xC6, 0x6, 0x5F, 0x0, 0x0, 0x53, 0x89, 0x1E, 0x4D, 0x5, 0x8B, + 0x16, 0x50, 0x3, 0x89, 0x16, 0x4B, 0x5, 0x8B, 0xE, 0x4, 0x7, + 0x2B, 0xCB, 0x89, 0xE, 0x49, 0x5, 0x51, 0x52, 0xE8, 0xA4, 0xFE, + 0x5A, 0x59, 0x5B, 0xA0, 0x60, 0x0, 0xA, 0xC0, 0x6, 0x74, 0x2, + 0x8E, 0xC2, 0xB4, 0x3, 0xCD, 0x15, 0x7, 0xE8, 0x89, 0x0, 0xBA, + 0x5, 0x0, 0xB9, 0x0, 0x0, 0x49, 0x75, 0xFD, 0x4A, 0x75, 0xFA, + 0xE8, 0x76, 0x0, 0xC3, 0xBE, 0x53, 0x5, 0x8B, 0x8C, 0xA, 0x0, + 0xA0, 0x60, 0x0, 0xA, 0xC0, 0x9C, 0x51, 0x75, 0xD, 0x50, 0x53, + 0x51, 0x56, 0x3, 0xD9, 0xE8, 0x16, 0xE6, 0x5E, 0x59, 0x5B, 0x58, + 0x3C, 0x1, 0x75, 0x4, 0x8B, 0x9C, 0xE, 0x0, 0x6, 0xA, 0xC0, + 0x74, 0xE, 0x8B, 0x94, 0xC, 0x0, 0xFE, 0xC8, 0x74, 0x4, 0x8B, + 0x16, 0x50, 0x3, 0x8E, 0xC2, 0xB4, 0x2, 0xCD, 0x15, 0x7, 0x72, + 0x12, 0x59, 0x9D, 0x75, 0xB, 0x8B, 0x1E, 0x30, 0x0, 0x3, 0xD9, + 0x43, 0x89, 0x1E, 0x58, 0x3, 0xE9, 0x80, 0xE5, 0x50, 0xE8, 0x5, + 0xD0, 0x58, 0x80, 0xFC, 0x4, 0x75, 0x5, 0xB2, 0x18, 0xE9, 0xB5, + 0xAA, 0xE9, 0x6B, 0xAA, 0x4B, 0xE8, 0xF3, 0xB1, 0x75, 0x5, 0xA0, + 0x64, 0x0, 0xEB, 0x3, 0xE8, 0xE8, 0xC1, 0xA, 0xC0, 0x75, 0x4, + 0xB0, 0x1, 0xEB, 0x2, 0xB0, 0x0, 0xA2, 0x64, 0x0, 0x8A, 0xE0, + 0xCD, 0x15, 0xC3, 0xCD, 0xDB, 0xF9, 0xEB, 0x1, 0xF8, 0x8B, 0xF3, + 0x9C, 0x8B, 0xE, 0xA5, 0x4, 0x8A, 0xC3, 0x32, 0xC1, 0xA2, 0xA7, + 0x4, 0x8A, 0xC7, 0x32, 0xE4, 0x8A, 0xDD, 0x32, 0xFF, 0x9D, 0x73, + 0x7, 0x3, 0xC3, 0x2D, 0x1, 0x1, 0xEB, 0x2, 0x2B, 0xC3, 0xA, + 0xE4, 0x78, 0xD, 0x3D, 0x80, 0x0, 0x72, 0x15, 0x8B, 0xDE, 0x83, + 0xC4, 0x2, 0xE9, 0x5D, 0x17, 0x5, 0x80, 0x0, 0x79, 0xB, 0x8B, + 0xDE, 0x83, 0xC4, 0x2, 0xE9, 0xDF, 0x1D, 0x5, 0x80, 0x0, 0xA2, + 0xA6, 0x4, 0xBB, 0xA5, 0x4, 0x80, 0xF, 0x80, 0x8B, 0xDE, 0x32, + 0xFF, 0x80, 0xCB, 0x80, 0xC3, 0xC6, 0x6, 0x39, 0x3, 0x80, 0xE8, + 0xC6, 0xD9, 0x53, 0x8B, 0xDA, 0xE8, 0xEA, 0x6, 0xE8, 0x4, 0xC5, + 0x89, 0x1E, 0x5E, 0x4, 0xB1, 0x20, 0xE8, 0x1B, 0xCF, 0x5B, 0xE8, + 0x60, 0xB1, 0x74, 0x17, 0xE8, 0x31, 0xD0, 0x28, 0xE8, 0xA7, 0xD9, + 0x52, 0x8A, 0x7, 0x3C, 0x2C, 0x75, 0x5, 0xE8, 0x4C, 0xB1, 0xEB, + 0xF1, 0xE8, 0x1E, 0xD0, 0x29, 0x89, 0x1E, 0x3B, 0x3, 0xE, 0xB8, + 0xE9, 0x5D, 0x50, 0xFF, 0x36, 0x50, 0x3, 0xFF, 0x36, 0x5E, 0x4, + 0xCB, 0x8B, 0x1E, 0x3B, 0x3, 0xC3, 0x53, 0xE8, 0xE, 0x5, 0x3C, + 0x6C, 0x74, 0xA, 0x3C, 0x4C, 0x74, 0x6, 0x3C, 0x71, 0x74, 0x2, + 0x3C, 0x51, 0x5B, 0xC3, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x25, 0x25, 0x25, 0x24, + 0x24, 0x24, 0x23, 0x23, 0x23, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, + 0x21, 0x20, 0x20, 0x20, 0x1F, 0x1F, 0x1F, 0x1F, 0x1E, 0x1E, 0x1E, + 0x1D, 0x1D, 0x1D, 0x1D, 0x1C, 0x1C, 0x1C, 0x1B, 0x1B, 0x1B, 0x1A, + 0x1A, 0x1A, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x17, 0x17, + 0x17, 0x17, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, + 0x14, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, + 0x10, 0x10, 0x10, 0x10, 0xF, 0xF, 0xF, 0xE, 0xE, 0xE, 0xD, + 0xD, 0xD, 0xD, 0xC, 0xC, 0xC, 0xB, 0xB, 0xB, 0xA, 0xA, + 0xA, 0xA, 0x9, 0x9, 0x9, 0x8, 0x8, 0x8, 0x7, 0x7, 0x7, + 0x6, 0x6, 0x6, 0x6, 0x5, 0x5, 0x5, 0x4, 0x4, 0x4, 0x3, + 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x0, 0x0, + 0x0, 0x0, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD, 0xFD, 0xFD, + 0xFD, 0xFC, 0xFC, 0xFC, 0xFB, 0xFB, 0xFB, 0xFA, 0xFA, 0xFA, 0xFA, + 0xF9, 0xF9, 0xF9, 0xF8, 0xF8, 0xF8, 0xF7, 0xF7, 0xF7, 0xF7, 0xF6, + 0xF6, 0xF6, 0xF5, 0xF5, 0xF5, 0xF4, 0xF4, 0xF4, 0xF4, 0xF3, 0xF3, + 0xF3, 0xF2, 0xF2, 0xF2, 0xF1, 0xF1, 0xF1, 0xF1, 0xF0, 0xF0, 0xF0, + 0xEF, 0xEF, 0xEF, 0xEE, 0xEE, 0xEE, 0xEE, 0xED, 0xED, 0xED, 0xEC, + 0xEC, 0xEC, 0xEB, 0xEB, 0xEB, 0xEB, 0xEA, 0xEA, 0xEA, 0xE9, 0xE9, + 0xE9, 0xE8, 0xE8, 0xE8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE6, 0xE6, 0xE6, + 0xE5, 0xE5, 0xE5, 0xE4, 0xE4, 0xE4, 0xE4, 0xE3, 0xE3, 0xE3, 0xE2, + 0xE2, 0xE2, 0xE1, 0xE1, 0xE1, 0xE1, 0xE0, 0xB, 0xF6, 0x79, 0x2, + 0xF7, 0xDA, 0x2B, 0xD7, 0x70, 0x3D, 0x74, 0x3A, 0x53, 0xE8, 0x90, + 0x1C, 0x9C, 0x73, 0x3, 0xE8, 0x6A, 0xC, 0xB, 0xD2, 0x78, 0xF, + 0x83, 0xFA, 0x27, 0x72, 0x1D, 0x9D, 0x73, 0x3, 0xE8, 0x3D, 0xC, + 0x5B, 0xE9, 0xB1, 0x15, 0x83, 0xFA, 0xDA, 0x7D, 0xE, 0x83, 0xC2, + 0x26, 0x83, 0xFA, 0xDA, 0x7C, 0x11, 0xE8, 0x13, 0x0, 0xBA, 0xDA, + 0xFF, 0xE8, 0xD, 0x0, 0x9D, 0x73, 0x3, 0xE8, 0x1D, 0xC, 0x5B, + 0xC3, 0xE8, 0x1F, 0x1C, 0xEB, 0xF3, 0xB, 0xD2, 0x9C, 0x79, 0x2, + 0xF7, 0xDA, 0xB9, 0x3, 0x0, 0xD3, 0xE2, 0x81, 0xC2, 0x32, 0x60, + 0x87, 0xDA, 0xE8, 0x25, 0x1D, 0x9D, 0x78, 0x3, 0xE9, 0xEC, 0xC, + 0xE8, 0xEC, 0x1C, 0xE9, 0xD4, 0x8, 0x72, 0x9, 0xB0, 0xD, 0x90, + 0xE9, 0xF, 0xFB, 0xC6, 0x7, 0x0, 0x8A, 0x7, 0xE8, 0xA4, 0xF9, + 0x88, 0x7, 0xC3, 0x75, 0x6, 0xB0, 0xA, 0x90, 0xE8, 0x69, 0xF0, + 0x58, 0x5A, 0x5B, 0x9D, 0xC3, 0x80, 0x3E, 0x6A, 0x0, 0x0, 0x74, + 0x12, 0x1E, 0x53, 0xC5, 0x1E, 0x6B, 0x0, 0x80, 0x3F, 0x0, 0x5B, + 0x1F, 0x75, 0x5, 0xC6, 0x6, 0x6A, 0x0, 0x0, 0xE9, 0x72, 0xAF, + 0x5F, 0x5E, 0xE9, 0xBE, 0xED, 0x75, 0x10, 0x5B, 0x88, 0x36, 0xA7, + 0x4, 0xBB, 0x0, 0x10, 0xC6, 0x6, 0xFB, 0x2, 0x4, 0xE9, 0x28, + 0x15, 0xC7, 0x6, 0xA5, 0x4, 0x0, 0x0, 0xC3, 0x10, 0x5B, 0x88, + 0x36, 0xA7, 0x4, 0xBB, 0x0, 0x10, 0xC6, 0x6, 0xFB, 0x2, 0x4, + 0xE9, 0x10, 0x15, 0xC7, 0x6, 0xA5, 0x4, 0x0, 0x0, 0xC3, 0x5C, + 0xD6, 0xED, 0xBD, 0xCE, 0xFE, 0xE6, 0x5B, 0x5F, 0xA6, 0xB4, 0x36, + 0x41, 0x5F, 0x70, 0x9, 0x63, 0xCF, 0x61, 0x84, 0x11, 0x77, 0xCC, + 0x2B, 0x66, 0x43, 0x7A, 0xE5, 0xD5, 0x94, 0xBF, 0x56, 0x69, 0x6A, + 0x6C, 0xAF, 0x5, 0xBD, 0x37, 0x6, 0x6D, 0x85, 0x47, 0x1B, 0x47, + 0xAC, 0xC5, 0x27, 0x70, 0x66, 0x19, 0xE2, 0x58, 0x17, 0xB7, 0x51, + 0x73, 0xE0, 0x4F, 0x8D, 0x97, 0x6E, 0x12, 0x3, 0x77, 0xD8, 0xA3, + 0x70, 0x3D, 0xA, 0xD7, 0x23, 0x7A, 0xCD, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0x4C, 0x7D, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x81, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x84, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x48, 0x87, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x7A, 0x8A, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x1C, 0x8E, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x50, 0x43, 0x91, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x24, 0x74, 0x94, 0x0, 0x0, 0x0, 0x0, 0x80, 0x96, 0x18, + 0x98, 0x0, 0x0, 0x0, 0x0, 0x20, 0xBC, 0x3E, 0x9B, 0x0, 0x0, + 0x0, 0x0, 0x28, 0x6B, 0x6E, 0x9E, 0x0, 0x0, 0x0, 0x0, 0xF9, + 0x2, 0x15, 0xA2, 0x0, 0x0, 0x0, 0x40, 0xB7, 0x43, 0x3A, 0xA5, + 0x0, 0x0, 0x0, 0x10, 0xA5, 0xD4, 0x68, 0xA8, 0x0, 0x0, 0x0, + 0x2A, 0xE7, 0x84, 0x11, 0xAC, 0x0, 0x0, 0x80, 0xF4, 0x20, 0xE6, + 0x35, 0xAF, 0x0, 0x0, 0xA0, 0x31, 0xA9, 0x5F, 0x63, 0xB2, 0x0, + 0x0, 0x4, 0xBF, 0xC9, 0x1B, 0xE, 0xB6, 0x0, 0x0, 0xC5, 0x2E, + 0xBC, 0xA2, 0x31, 0xB9, 0x0, 0x40, 0x76, 0x3A, 0x6B, 0xB, 0x5E, + 0xBC, 0x0, 0xE8, 0x89, 0x4, 0x23, 0xC7, 0xA, 0xC0, 0x0, 0x62, + 0xAC, 0xC5, 0xEB, 0x78, 0x2D, 0xC3, 0x80, 0x7A, 0x17, 0xB7, 0x26, + 0xD7, 0x58, 0xC6, 0x90, 0xAC, 0x6E, 0x32, 0x78, 0x86, 0x7, 0xCA, + 0xB5, 0x57, 0xA, 0x3F, 0x16, 0x68, 0x29, 0xCD, 0xA2, 0xED, 0xCC, + 0xCE, 0x1B, 0xC2, 0x53, 0xD0, 0x85, 0x14, 0x40, 0x61, 0x51, 0x59, + 0x4, 0xD4, 0xA6, 0x19, 0x90, 0xB9, 0xA5, 0x6F, 0x25, 0xD7, 0x10, + 0x20, 0xF4, 0x27, 0x8F, 0xCB, 0x4E, 0xDA, 0xA, 0x94, 0xF8, 0x78, + 0x39, 0x3F, 0x1, 0xDE, 0xC, 0xB9, 0x36, 0xD7, 0x7, 0x8F, 0x21, + 0xE1, 0x4F, 0x67, 0x4, 0xCD, 0xC9, 0xF2, 0x49, 0xE4, 0x23, 0x81, + 0x45, 0x40, 0x7C, 0x6F, 0x7C, 0xE7, 0xB6, 0x70, 0x2B, 0xA8, 0xAD, + 0xC5, 0x1D, 0xEB, 0xE4, 0x4C, 0x36, 0x12, 0x19, 0x37, 0x45, 0xEE, + 0x1C, 0xE0, 0xC3, 0x56, 0xDF, 0x84, 0x76, 0xF1, 0x12, 0x6C, 0x3A, + 0x96, 0xB, 0x13, 0x1A, 0xF5, 0x16, 0x7, 0xC9, 0x7B, 0xCE, 0x97, + 0x40, 0xF8, 0xDC, 0x48, 0xBB, 0x1A, 0xC2, 0xBD, 0x70, 0xFB, 0x89, + 0xD, 0xB5, 0x50, 0x99, 0x76, 0x16, 0xFF, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x80, 0xF1, 0x4, 0x35, 0x80, 0x4, 0x9A, 0xF7, + 0x19, 0x83, 0x24, 0x63, 0x43, 0x83, 0x75, 0xCD, 0x8D, 0x84, 0xA9, + 0x7F, 0x83, 0x82, 0x4, 0x0, 0x0, 0x0, 0x81, 0xE2, 0xB0, 0x4D, + 0x83, 0xA, 0x72, 0x11, 0x83, 0xF4, 0x4, 0x35, 0x7F, 0x18, 0x72, + 0x31, 0x80, 0x2E, 0x65, 0x45, 0x25, 0x23, 0x21, 0x44, 0x64, 0x2C, + 0x30, 0x0, 0x80, 0xC6, 0xA4, 0x7E, 0x8D, 0x3, 0x0, 0x40, 0x7A, + 0x10, 0xF3, 0x5A, 0x0, 0x0, 0xA0, 0x72, 0x4E, 0x18, 0x9, 0x0, + 0x0, 0x10, 0xA5, 0xD4, 0xE8, 0x0, 0x0, 0x0, 0xE8, 0x76, 0x48, + 0x17, 0x0, 0x0, 0x0, 0xE4, 0xB, 0x54, 0x2, 0x0, 0x0, 0x0, + 0xCA, 0x9A, 0x3B, 0x0, 0x0, 0x0, 0x0, 0xE1, 0xF5, 0x5, 0x0, + 0x0, 0x0, 0x80, 0x96, 0x98, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, + 0xF, 0x0, 0x0, 0x0, 0x0, 0x40, 0x42, 0xF, 0xA0, 0x86, 0x1, + 0x10, 0x27, 0x0, 0x10, 0x27, 0xE8, 0x3, 0x64, 0x0, 0xA, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x80, 0x90, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0x3B, 0xAA, 0x38, 0x81, 0x7, 0x7C, 0x88, 0x59, 0x74, 0xE0, 0x97, + 0x26, 0x77, 0xC4, 0x1D, 0x1E, 0x7A, 0x5E, 0x50, 0x63, 0x7C, 0x1A, + 0xFE, 0x75, 0x7E, 0x18, 0x72, 0x31, 0x80, 0x0, 0x0, 0x0, 0x81, + 0x5, 0xFB, 0xD7, 0x1E, 0x86, 0x65, 0x26, 0x99, 0x87, 0x58, 0x34, + 0x23, 0x87, 0xE1, 0x5D, 0xA5, 0x86, 0xDB, 0xF, 0x49, 0x83, 0x2, + 0xD7, 0xB3, 0x5D, 0x81, 0x0, 0x0, 0x80, 0x81, 0x4, 0x62, 0x35, + 0x83, 0x7E, 0x50, 0x24, 0x4C, 0x7E, 0x79, 0xA9, 0xAA, 0x7F, 0x0, + 0x0, 0x0, 0x81, 0xB, 0x44, 0x4E, 0x6E, 0x83, 0xF9, 0x22, 0x7E, + 0xFD, 0x43, 0x3, 0xC3, 0x9E, 0x26, 0x1, 0x0, 0x0, 0x30, 0x31, + 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, + 0x44, 0x45, 0x46, 0xBA, 0x3B, 0xAA, 0xBB, 0x38, 0x81, 0xE8, 0x72, + 0xA, 0xA0, 0xA6, 0x4, 0x3C, 0x88, 0x73, 0x3C, 0x3C, 0x68, 0x72, + 0x4B, 0xFF, 0x36, 0xA3, 0x4, 0xFF, 0x36, 0xA5, 0x4, 0xE8, 0x60, + 0x10, 0x8A, 0xE2, 0x80, 0xC4, 0x81, 0x74, 0x23, 0x50, 0xF6, 0x6, + 0xA7, 0x4, 0x80, 0xE8, 0x43, 0x10, 0x32, 0xE4, 0xE8, 0xE6, 0x11, + 0x58, 0x5B, 0x5A, 0x50, 0xE8, 0xA8, 0x4, 0xBB, 0x17, 0x62, 0xE8, + 0x8D, 0x12, 0x5B, 0x33, 0xD2, 0x8A, 0xDA, 0xE9, 0x32, 0xA, 0x83, + 0xC4, 0x4, 0x80, 0x26, 0xA5, 0x4, 0x80, 0x74, 0x3, 0xE9, 0x91, + 0x18, 0x32, 0xE4, 0x88, 0x26, 0xA7, 0x4, 0xE9, 0xF9, 0x11, 0xBF, + 0xA3, 0x4, 0x90, 0x33, 0xC0, 0xFC, 0xAB, 0xC7, 0x5, 0x0, 0x81, + 0xC3, 0xE8, 0xAF, 0x18, 0x75, 0x3, 0xE9, 0xDE, 0xA4, 0xC3, 0xFC, + 0xAB, 0xC7, 0x5, 0x0, 0x81, 0xC3, 0xE9, 0x1A, 0xAC, 0xCD, 0xB9, + 0x80, 0x36, 0xA5, 0x4, 0x80, 0x80, 0x36, 0xB1, 0x4, 0x80, 0xE9, + 0x8A, 0x3, 0xCD, 0xBA, 0x87, 0xD9, 0xE9, 0x5A, 0x4, 0xCD, 0xBB, + 0x87, 0xD9, 0xE9, 0x47, 0x4, 0xCD, 0xBC, 0xE8, 0x33, 0x19, 0xE9, + 0x1B, 0x5, 0x87, 0xD9, 0xE9, 0xB1, 0x5, 0xCD, 0xBD, 0x89, 0x1E, + 0xA3, 0x4, 0xE9, 0x6B, 0x8, 0xCD, 0xBE, 0x52, 0x98, 0x8B, 0xD0, + 0xE8, 0xEE, 0x8, 0x5A, 0xC3, 0xCD, 0xBF, 0x87, 0xD9, 0xE9, 0xB7, + 0x9, 0xCD, 0xC0, 0x87, 0xD9, 0xE9, 0xED, 0xD, 0x81, 0xFB, 0x0, + 0x80, 0x75, 0x13, 0xCD, 0xC1, 0xE8, 0xD3, 0x8, 0x33, 0xD2, 0xBB, + 0x80, 0x90, 0xE8, 0x5, 0x4, 0xE8, 0x4B, 0x1A, 0xE9, 0x45, 0x8, + 0xF7, 0xDB, 0x53, 0x3, 0xDA, 0x70, 0x4, 0x58, 0xE9, 0x99, 0x1, + 0xCD, 0xC2, 0xE8, 0xB5, 0x8, 0x5A, 0xFF, 0x36, 0xA3, 0x4, 0xFF, + 0x36, 0xA5, 0x4, 0xE8, 0xA9, 0x8, 0x5B, 0x5A, 0xE9, 0xEA, 0x3, + 0x8B, 0xC3, 0x52, 0xF7, 0xEA, 0x5A, 0x72, 0x5, 0x8B, 0xD8, 0xE9, + 0x76, 0x1, 0xCD, 0xC3, 0x53, 0xE8, 0x91, 0x8, 0x5A, 0xFF, 0x36, + 0xA3, 0x4, 0xFF, 0x36, 0xA5, 0x4, 0xE8, 0x85, 0x8, 0x5B, 0x5A, + 0xE9, 0x52, 0x9, 0xB, 0xDB, 0x75, 0xC, 0x88, 0x36, 0xA7, 0x4, + 0xC6, 0x6, 0xFB, 0x2, 0x4, 0xE9, 0x2D, 0x11, 0x89, 0x1E, 0xA3, + 0x4, 0xB8, 0x0, 0x0, 0xA3, 0xA5, 0x4, 0x92, 0xB, 0xC0, 0x79, + 0x3, 0xBA, 0xFF, 0xFF, 0xB, 0xDB, 0x79, 0x6, 0xC7, 0x6, 0xA5, + 0x4, 0xFF, 0xFF, 0xF7, 0x3E, 0xA3, 0x4, 0x8B, 0xD8, 0xE9, 0x2A, + 0x1, 0x87, 0xD9, 0xE8, 0xD7, 0x18, 0x87, 0xD9, 0xC3, 0x53, 0xE8, + 0x45, 0x1A, 0x5B, 0x83, 0xC3, 0x4, 0xC3, 0x8B, 0x16, 0xA3, 0x4, + 0x8B, 0xE, 0xA5, 0x4, 0xC3, 0x9C, 0x53, 0xE8, 0x19, 0x1A, 0x5B, + 0x83, 0xC3, 0x4, 0x9D, 0xC3, 0xE8, 0xAB, 0xBE, 0x89, 0x1E, 0xA3, + 0x4, 0xE9, 0x67, 0xA, 0xE8, 0xA1, 0xBE, 0x89, 0x1E, 0xA3, 0x4, + 0xE9, 0x65, 0xA, 0xCD, 0xC4, 0x8B, 0x17, 0x8B, 0x9F, 0x2, 0x0, + 0xE9, 0x4D, 0x3, 0x5E, 0xFF, 0x36, 0xA3, 0x4, 0xFF, 0x36, 0xA5, + 0x4, 0xFF, 0xE6, 0xCD, 0xC5, 0x87, 0xD9, 0xE8, 0xA0, 0x18, 0x87, + 0xD9, 0xC3, 0xE8, 0x64, 0x17, 0x74, 0x3, 0xE9, 0x93, 0xA3, 0xC3, + 0x87, 0xDA, 0xE8, 0xCD, 0x0, 0x32, 0xC0, 0xB5, 0x98, 0xCD, 0xC6, + 0xBB, 0xA6, 0x4, 0x8A, 0xC8, 0x88, 0x2F, 0xB5, 0x0, 0x43, 0x88, + 0x2F, 0xD0, 0xD0, 0xCD, 0xC7, 0x73, 0x3, 0xE8, 0x20, 0x1, 0x8A, + 0xE5, 0x8A, 0xD9, 0xE9, 0x33, 0x10, 0xE8, 0x92, 0xFE, 0x53, 0x33, + 0xDB, 0x89, 0x1E, 0xA3, 0x4, 0xB7, 0x81, 0x89, 0x1E, 0xA5, 0x4, + 0xC6, 0x6, 0xFB, 0x2, 0x4, 0xE8, 0x4, 0x14, 0x5B, 0xC6, 0x6, + 0xFB, 0x2, 0x4, 0xC3, 0x8B, 0xC1, 0xF7, 0xE2, 0x92, 0x73, 0x3, + 0xE9, 0x25, 0xD5, 0xC3, 0xBB, 0xAB, 0x4, 0xBA, 0xB7, 0x64, 0xE9, + 0x6, 0x0, 0xBB, 0xAB, 0x4, 0xBA, 0xB9, 0x64, 0x52, 0xBA, 0xA3, + 0x4, 0xE8, 0xF7, 0x16, 0x72, 0x3, 0xBA, 0x9F, 0x4, 0xC3, 0x8A, + 0xCD, 0x32, 0xED, 0xEB, 0x8, 0x87, 0xDA, 0xA0, 0xFB, 0x2, 0x98, + 0x8B, 0xC8, 0xFC, 0x8B, 0xF2, 0x8B, 0xFB, 0xF3, 0xA4, 0x8B, 0xD6, + 0x8B, 0xDF, 0xC3, 0xE8, 0x36, 0xC8, 0x8B, 0xF1, 0x8B, 0xFB, 0xFD, + 0x2B, 0xCA, 0x41, 0xF3, 0xA4, 0x8B, 0xDA, 0x8B, 0xCF, 0x41, 0xFC, + 0xC3, 0x9C, 0x49, 0x9D, 0xC3, 0xE8, 0xBC, 0x16, 0x75, 0x3, 0xE9, + 0xEB, 0xA2, 0xCD, 0xC8, 0x78, 0x3, 0xE9, 0x83, 0x16, 0xA1, 0xA3, + 0x4, 0xB, 0xC0, 0x74, 0x6, 0xB0, 0x1, 0x79, 0x2, 0xB0, 0xFF, + 0xC3, 0x33, 0xC0, 0xB, 0xDB, 0x75, 0xF3, 0xC3, 0x5B, 0xC3, 0x98, + 0x8B, 0xD8, 0xC6, 0x6, 0xFB, 0x2, 0x2, 0x89, 0x1E, 0xA3, 0x4, + 0xC3, 0xC6, 0x6, 0xFB, 0x2, 0x4, 0xC3, 0xE8, 0xC4, 0xFF, 0xE9, + 0xE7, 0xFF, 0xCD, 0xC9, 0x5B, 0x5A, 0xE9, 0xB5, 0x3, 0xE8, 0x25, + 0x6, 0x5B, 0x5A, 0xE9, 0xB, 0xC, 0xB9, 0x4, 0x0, 0xE9, 0x88, + 0xFF, 0x9C, 0x8A, 0x17, 0x43, 0x9D, 0x9C, 0x8A, 0x37, 0x43, 0x8B, + 0xF, 0x43, 0x9D, 0x9C, 0x43, 0x9D, 0xC3, 0x53, 0xBB, 0x28, 0x7, + 0xE8, 0x6, 0x16, 0x5B, 0xB9, 0xB6, 0x26, 0x51, 0xE8, 0xB5, 0xFF, + 0x32, 0xC0, 0xCD, 0xCA, 0xA2, 0x31, 0x3, 0xBB, 0xB4, 0x4, 0xC6, + 0x7, 0x20, 0xA, 0x7, 0x43, 0xC6, 0x7, 0x30, 0xE9, 0x6A, 0xB, + 0xCD, 0xCB, 0xA0, 0xA5, 0x4, 0xEB, 0x9, 0xCD, 0xCC, 0xE8, 0xE5, + 0x17, 0x74, 0x8, 0xF6, 0xD0, 0xD0, 0xE0, 0x1A, 0xC0, 0x74, 0x3D, + 0xC3, 0xCD, 0xCD, 0x80, 0x36, 0xA7, 0x4, 0x80, 0x33, 0xDB, 0xF6, + 0xDD, 0x8B, 0xC3, 0x1B, 0xC2, 0x8B, 0xD0, 0x8A, 0xC3, 0x1A, 0xC1, + 0x8A, 0xC8, 0xC3, 0xE8, 0x3, 0x16, 0x78, 0xFA, 0xCD, 0xCE, 0xE8, + 0xCF, 0x15, 0x78, 0x3, 0xE9, 0xD5, 0x18, 0xE8, 0x2, 0x18, 0xE8, + 0xCF, 0x18, 0xE9, 0xFC, 0x17, 0x8B, 0xC3, 0x2B, 0xC2, 0x74, 0xE, + 0x70, 0x7, 0x78, 0x7, 0x32, 0xC0, 0xFE, 0xC0, 0xC3, 0x78, 0xF9, + 0xF9, 0x1A, 0xC0, 0xC3, 0x3B, 0xDA, 0x75, 0x5, 0x33, 0xDB, 0xE9, + 0x26, 0x0, 0x8B, 0xC2, 0x89, 0x1E, 0xA3, 0x4, 0xB, 0xDB, 0xE8, + 0xD3, 0xF9, 0x90, 0x90, 0x90, 0x79, 0x6, 0xC7, 0x6, 0xA5, 0x4, + 0xFF, 0xFF, 0xB, 0xC0, 0xBA, 0x0, 0x0, 0x79, 0x3, 0xBA, 0xFF, + 0xFF, 0xF7, 0x3E, 0xA3, 0x4, 0x8B, 0xDA, 0x89, 0x1E, 0xA3, 0x4, + 0xC3, 0xAD, 0x3A, 0xE1, 0x74, 0x11, 0x46, 0x2, 0x4, 0xFE, 0xC0, + 0x98, 0x3, 0xF0, 0x3B, 0xF5, 0x75, 0xEF, 0x8B, 0xD6, 0xE9, 0x39, + 0xD2, 0x3A, 0x6, 0xFB, 0x2, 0x75, 0xE9, 0x3A, 0x2C, 0x75, 0xE5, + 0x46, 0x8A, 0xD0, 0xAC, 0x3A, 0x6, 0x8E, 0x0, 0x74, 0x4, 0x2, + 0xC2, 0xEB, 0xDC, 0xA, 0xC0, 0x74, 0x10, 0x98, 0x91, 0xBF, 0x8F, + 0x0, 0xF3, 0xA6, 0x91, 0x74, 0x6, 0x3, 0xF0, 0x8A, 0xC2, 0xEB, + 0xC8, 0x8B, 0xD6, 0x5B, 0xC3, 0x8B, 0xF3, 0x8B, 0x2E, 0x4B, 0x4, + 0xFC, 0xEB, 0xBE, 0x8B, 0xF3, 0x8B, 0x2E, 0x5C, 0x3, 0xFC, 0xE9, + 0xD, 0x0, 0xAD, 0x3A, 0xE1, 0x74, 0x11, 0x46, 0xAC, 0x98, 0x3, + 0xF0, 0xAD, 0x3, 0xF0, 0x3B, 0xEE, 0x75, 0xEF, 0x8B, 0xDE, 0xE9, + 0x53, 0xD3, 0x3A, 0x6, 0xFB, 0x2, 0x75, 0xE9, 0x3A, 0x2C, 0x75, + 0xE5, 0x46, 0xAC, 0x3A, 0x6, 0x8E, 0x0, 0x75, 0xDF, 0xA, 0xC0, + 0x74, 0xE, 0x98, 0x91, 0xBF, 0x8F, 0x0, 0xF3, 0xA6, 0x91, 0x74, + 0x4, 0x3, 0xF0, 0xEB, 0xD0, 0xAD, 0x8B, 0xD0, 0x8B, 0xDE, 0xE9, + 0x5, 0xD3, 0xE8, 0x18, 0x16, 0xC3, 0xA1, 0xA5, 0x4, 0xA, 0xE4, + 0x74, 0xF5, 0x80, 0x36, 0xA5, 0x4, 0x80, 0xCD, 0xD7, 0xB0, 0x0, + 0xA2, 0x9E, 0x4, 0xA2, 0xAA, 0x4, 0xA0, 0xB2, 0x4, 0xA, 0xC0, + 0x74, 0xE2, 0xA1, 0xA5, 0x4, 0xA, 0xE4, 0x74, 0xD8, 0x8B, 0x1E, + 0xB1, 0x4, 0x80, 0xE, 0xA5, 0x4, 0x80, 0x80, 0xE, 0xB1, 0x4, + 0x80, 0x8A, 0xCC, 0x2A, 0xCF, 0xA2, 0xA7, 0x4, 0x74, 0x22, 0x73, + 0x12, 0x86, 0xC3, 0xF6, 0xD9, 0xA2, 0xA7, 0x4, 0x88, 0x3E, 0xA6, + 0x4, 0x50, 0x51, 0xE8, 0x6F, 0x15, 0x59, 0x58, 0x80, 0xF9, 0x39, + 0x73, 0x5F, 0x53, 0xF8, 0xE8, 0x21, 0x15, 0xA0, 0xA7, 0x4, 0x5B, + 0x32, 0xC3, 0xBB, 0x9E, 0x4, 0xBE, 0xAA, 0x4, 0xB9, 0x4, 0x0, + 0xF8, 0xFC, 0x78, 0x1E, 0xAD, 0x11, 0x7, 0x43, 0x43, 0xE2, 0xF9, + 0x73, 0x12, 0xBB, 0xA6, 0x4, 0xFE, 0x7, 0x74, 0x34, 0x4B, 0x4B, + 0xB9, 0x4, 0x0, 0xD1, 0x1F, 0x4B, 0x4B, 0xE2, 0xFA, 0xE9, 0xE9, + 0x11, 0xAD, 0x19, 0x7, 0x43, 0x43, 0xE2, 0xF9, 0x73, 0x1A, 0xF6, + 0x97, 0x1, 0x0, 0xB9, 0x4, 0x0, 0x4B, 0x4B, 0xF7, 0x17, 0xE2, + 0xFA, 0xB9, 0x4, 0x0, 0xFF, 0x7, 0x75, 0x6, 0x43, 0x43, 0xE2, + 0xF8, 0x74, 0xC8, 0xE9, 0xF4, 0xC, 0xE9, 0x8D, 0xD, 0xA0, 0xA7, + 0x4, 0x24, 0x80, 0x80, 0x26, 0xA5, 0x4, 0x7F, 0x8, 0x6, 0xA5, + 0x4, 0xC3, 0x89, 0x1E, 0xA5, 0x4, 0x89, 0x16, 0xA3, 0x4, 0xC3, + 0xA1, 0xA5, 0x4, 0xA, 0xE4, 0x74, 0xF0, 0x80, 0x36, 0xA5, 0x4, + 0x80, 0xA, 0xFF, 0x74, 0xEF, 0xA1, 0xA5, 0x4, 0xA, 0xE4, 0x74, + 0xE0, 0x33, 0xC9, 0x8B, 0x36, 0xA3, 0x4, 0xA2, 0xA7, 0x4, 0x8A, + 0xCC, 0x2A, 0xCF, 0x73, 0xD, 0xF6, 0xD9, 0x86, 0xDF, 0x89, 0x1E, + 0xA6, 0x4, 0x86, 0xDF, 0x93, 0x87, 0xD6, 0x8A, 0xE0, 0x32, 0xE3, + 0x9C, 0xB4, 0x80, 0xA, 0xC4, 0xA, 0xDC, 0x32, 0xE4, 0x8A, 0xFC, + 0xB, 0xC9, 0x74, 0x46, 0x83, 0xF9, 0x19, 0x72, 0x12, 0x9D, 0x89, + 0x36, 0xA3, 0x4, 0x8A, 0x26, 0xA7, 0x4, 0x25, 0x7F, 0x80, 0xA, + 0xC4, 0xA2, 0xA5, 0x4, 0xC3, 0x80, 0xF9, 0x8, 0x72, 0x1C, 0xE9, + 0x5, 0x3, 0x90, 0x8A, 0xF3, 0x32, 0xDB, 0x80, 0xE9, 0x8, 0xF6, + 0xC4, 0x1F, 0x74, 0xD0, 0x80, 0xCC, 0x20, 0xEB, 0xCB, 0x80, 0xCC, + 0x20, 0xE2, 0x3, 0xEB, 0xE, 0xF8, 0xD0, 0xDB, 0xD1, 0xDA, 0xD0, + 0xDC, 0xF6, 0xC4, 0x10, 0x75, 0xED, 0xE2, 0xF3, 0x9D, 0x79, 0x25, + 0x2A, 0xCC, 0x8A, 0xE1, 0x1B, 0xF2, 0x8B, 0xD6, 0x1A, 0xC3, 0x8A, + 0xD8, 0x73, 0x2F, 0xF6, 0x16, 0xA7, 0x4, 0xF6, 0xD4, 0xF7, 0xD2, + 0xF6, 0xD3, 0xFE, 0xC4, 0x75, 0x21, 0x42, 0x75, 0x1E, 0xFE, 0xC3, + 0x75, 0x1A, 0xEB, 0x6, 0x3, 0xD6, 0x12, 0xD8, 0x73, 0xC, 0xFE, + 0x6, 0xA6, 0x4, 0x74, 0x9, 0xD0, 0xDB, 0xD1, 0xDA, 0xD0, 0xDC, + 0xE9, 0x24, 0x11, 0xE9, 0xA9, 0xC, 0xE9, 0x68, 0xC, 0xE8, 0x25, + 0x13, 0xC3, 0xA0, 0xB1, 0x4, 0xA2, 0xA7, 0x4, 0xE9, 0xA7, 0xC, + 0xF6, 0x6, 0xA6, 0x4, 0xFF, 0x74, 0xF0, 0xF6, 0x6, 0xB2, 0x4, + 0xFF, 0x74, 0xE5, 0x8B, 0x1E, 0xB1, 0x4, 0xE8, 0xF3, 0xF4, 0x89, + 0x1E, 0xB1, 0x4, 0xBB, 0xA4, 0x4, 0xF8, 0xE8, 0xA1, 0x13, 0xBB, + 0xB0, 0x4, 0xF8, 0xE8, 0x9A, 0x13, 0xFF, 0x36, 0xA6, 0x4, 0xE8, + 0x5E, 0x15, 0x8F, 0x6, 0xA6, 0x4, 0xB9, 0x40, 0x0, 0x51, 0xEB, + 0x8, 0x51, 0xF8, 0xBB, 0xAA, 0x4, 0xE8, 0x77, 0x13, 0x8B, 0xFC, + 0x83, 0xEC, 0x8, 0x83, 0xEF, 0x2, 0xBE, 0xB0, 0x4, 0xB9, 0x4, + 0x0, 0xFD, 0xF3, 0xA5, 0xBE, 0x78, 0x4, 0xB9, 0x4, 0x0, 0xBB, + 0xAA, 0x4, 0xF8, 0xFC, 0xAD, 0x19, 0x7, 0x43, 0x43, 0xE2, 0xF9, + 0x73, 0x10, 0xB9, 0x4, 0x0, 0x8B, 0xF4, 0xBF, 0xAA, 0x4, 0xFC, + 0xF3, 0xA5, 0x8B, 0xE6, 0xF8, 0xEB, 0x4, 0x83, 0xC4, 0x8, 0xF9, + 0xBB, 0x9E, 0x4, 0xE8, 0x38, 0x13, 0x59, 0xE2, 0xB6, 0xF6, 0x6, + 0xA5, 0x4, 0x80, 0x74, 0x9, 0xFF, 0x6, 0xA6, 0x4, 0x75, 0x9, + 0xE9, 0x7, 0xC, 0xBB, 0x9E, 0x4, 0xE8, 0x1F, 0x13, 0xE9, 0x31, + 0x10, 0xE8, 0x94, 0x12, 0x75, 0x7, 0x88, 0x1E, 0xA7, 0x4, 0xE9, + 0x0, 0xC, 0xA, 0xFF, 0x75, 0x3, 0xE9, 0x7A, 0x12, 0xE8, 0x57, + 0xF4, 0x8B, 0xFA, 0x33, 0xD2, 0x8A, 0xFE, 0x8B, 0xF3, 0x8A, 0xDF, + 0xB9, 0x20, 0x0, 0x55, 0x8B, 0x2E, 0xA3, 0x4, 0xA0, 0xA5, 0x4, + 0x8A, 0xE7, 0xEB, 0x5, 0xF8, 0xD1, 0xD7, 0xD1, 0xD6, 0x56, 0x57, + 0x2B, 0xFD, 0x1B, 0xF0, 0x73, 0x4, 0x5F, 0x5E, 0xEB, 0x4, 0x83, + 0xC4, 0x4, 0xF8, 0xF5, 0xD1, 0xD2, 0xD1, 0xD3, 0xE2, 0xE4, 0xB, + 0xDB, 0x79, 0xA, 0xFE, 0x6, 0xA6, 0x4, 0x75, 0x8, 0x5D, 0xE9, + 0xA5, 0xB, 0xD1, 0xD2, 0xD1, 0xD3, 0x8A, 0xE2, 0x8A, 0xD6, 0x8A, + 0xF3, 0x8A, 0xDF, 0x5D, 0xE9, 0xD, 0x10, 0x13, 0xF9, 0x53, 0x57, + 0x51, 0x2C, 0x30, 0x50, 0xE8, 0x50, 0x12, 0x58, 0x98, 0x79, 0x1E, + 0x8B, 0x1E, 0xA3, 0x4, 0x81, 0xFB, 0xCD, 0xC, 0x73, 0x19, 0x8B, + 0xCB, 0xD1, 0xE3, 0xD1, 0xE3, 0x3, 0xD9, 0xD1, 0xE3, 0x3, 0xD8, + 0x78, 0xB, 0x89, 0x1E, 0xA3, 0x4, 0xEB, 0x48, 0x50, 0x72, 0x8, + 0xEB, 0x33, 0x50, 0xE8, 0x24, 0x2, 0xEB, 0x14, 0xC7, 0x6, 0x7C, + 0x4, 0x0, 0x24, 0xC7, 0x6, 0x7E, 0x4, 0x74, 0x94, 0xBB, 0x7E, + 0x4, 0xE8, 0x83, 0x13, 0x79, 0x16, 0xE8, 0x3C, 0x12, 0x5A, 0xFF, + 0x36, 0xA3, 0x4, 0xFF, 0x36, 0xA5, 0x4, 0xE8, 0x8B, 0x2, 0x5B, + 0x5A, 0xE8, 0xCC, 0xFD, 0xEB, 0x13, 0xE8, 0xE7, 0x1, 0xE8, 0x23, + 0x12, 0xE8, 0xEE, 0x12, 0x5A, 0xE8, 0x77, 0x2, 0xE8, 0xDA, 0x1, + 0xE8, 0xEE, 0xFC, 0x59, 0x5F, 0x5B, 0xC3, 0xCD, 0xD9, 0x32, 0xC0, + 0xE9, 0x9, 0x0, 0xCD, 0xDA, 0xB0, 0x1, 0xC6, 0x6, 0xFB, 0x2, + 0x8, 0xC6, 0x6, 0xA8, 0x4, 0x1, 0xBE, 0xB4, 0x25, 0x56, 0x33, + 0xFF, 0x8B, 0xCF, 0x8B, 0xF7, 0xF7, 0xD1, 0x50, 0xE8, 0x86, 0x11, + 0x58, 0xA, 0xC0, 0x75, 0x5, 0xC6, 0x6, 0xFB, 0x2, 0x2, 0x8A, + 0x7, 0x3C, 0x26, 0x75, 0x3, 0xE9, 0x7, 0xB0, 0x3C, 0x2D, 0x9C, + 0x74, 0x5, 0x3C, 0x2B, 0x74, 0x1, 0x4B, 0xE8, 0xFB, 0xF8, 0x73, + 0x6, 0xE8, 0x3D, 0xFF, 0xE9, 0xF5, 0xFF, 0xBD, 0xA3, 0x61, 0x33, + 0xD2, 0x8B, 0xF2, 0x2E, 0x3A, 0x86, 0x0, 0x0, 0x74, 0xA, 0x81, + 0xFD, 0x9C, 0x61, 0x74, 0x24, 0x4D, 0xE9, 0xEF, 0xFF, 0x81, 0xED, + 0x9C, 0x61, 0xD1, 0xE5, 0x2E, 0xFF, 0xA6, 0x30, 0x6A, 0x4B, 0x6A, + 0x5F, 0x6A, 0x5F, 0x6A, 0x67, 0x6A, 0x6D, 0x6A, 0x73, 0x6A, 0x40, + 0x6A, 0x40, 0x6A, 0x32, 0xC0, 0xE8, 0x9C, 0x0, 0xE8, 0x41, 0x0, + 0xE9, 0x2D, 0x0, 0x41, 0x75, 0xF7, 0xE8, 0x51, 0x11, 0x79, 0xAF, + 0x51, 0x53, 0x57, 0xE8, 0x48, 0x1, 0x5F, 0x5B, 0x59, 0xE9, 0xA3, + 0xFF, 0xE8, 0x8C, 0xF3, 0x74, 0xE1, 0xE9, 0xDB, 0xFF, 0x43, 0xEB, + 0xDB, 0xE9, 0xB, 0x0, 0xE8, 0xBC, 0x0, 0xE9, 0x5, 0x0, 0x32, + 0xC0, 0xE8, 0xB6, 0x0, 0x9D, 0x75, 0xD, 0xE8, 0x2D, 0x13, 0xE8, + 0x21, 0x11, 0x7A, 0x5, 0x53, 0xE8, 0xED, 0x12, 0x5B, 0xC3, 0xE9, + 0x76, 0xF4, 0xC6, 0x6, 0x55, 0x4, 0xFF, 0xE8, 0x89, 0xA4, 0x8B, + 0xD4, 0xE9, 0xE3, 0x8, 0xA, 0xFF, 0x75, 0x5, 0xE8, 0xE8, 0x10, + 0xF9, 0xC3, 0xA0, 0xA6, 0x4, 0xA, 0xC0, 0x75, 0x8, 0x8A, 0xC3, + 0xF6, 0xD0, 0xE8, 0xE4, 0x10, 0xF9, 0xC3, 0xE8, 0xE4, 0xFF, 0x5D, + 0x72, 0x14, 0xEB, 0x10, 0x53, 0x8B, 0x1F, 0xE8, 0xD9, 0xFF, 0x5B, + 0x5D, 0x72, 0x8, 0x53, 0x57, 0xBF, 0xA5, 0x4, 0x90, 0x55, 0xC3, + 0xFE, 0xC0, 0x2C, 0x1, 0xC3, 0xF6, 0xC4, 0xFF, 0x8A, 0xE2, 0x74, + 0x3, 0x80, 0xCC, 0x20, 0x8A, 0xD6, 0xE9, 0xED, 0xFC, 0x10, 0x9F, + 0x80, 0x3E, 0xFB, 0x2, 0x8, 0x75, 0x4, 0x9E, 0xE9, 0x8, 0x0, + 0x9E, 0x53, 0x57, 0xE8, 0x5C, 0x0, 0x5F, 0x5B, 0x33, 0xF6, 0x8B, + 0xD6, 0xE8, 0x4, 0xF8, 0x72, 0x13, 0x3C, 0x2D, 0x75, 0x4, 0xF7, + 0xD6, 0xEB, 0x5, 0x3C, 0x2B, 0x74, 0x1, 0xC3, 0xE8, 0xF2, 0xF7, + 0x72, 0x1, 0xC3, 0x81, 0xFA, 0xCC, 0xC, 0x72, 0x5, 0xBA, 0xFF, + 0x7F, 0xEB, 0xEF, 0x50, 0xB8, 0xA, 0x0, 0xF7, 0xE2, 0x5A, 0x80, + 0xEA, 0x30, 0x32, 0xF6, 0x3, 0xD0, 0xEB, 0xDF, 0xC, 0x1, 0x53, + 0x57, 0x75, 0x7, 0xE8, 0x1C, 0x0, 0xEB, 0x5, 0x90, 0x90, 0xE8, + 0x46, 0x0, 0x5F, 0x5B, 0x33, 0xF6, 0x8B, 0xD6, 0xE8, 0xBD, 0xF3, + 0x43, 0xC3, 0xE8, 0x58, 0x10, 0x78, 0xF9, 0xE9, 0x6F, 0x9C, 0x74, + 0x31, 0xE8, 0x4E, 0x10, 0x7B, 0x56, 0x75, 0x3, 0xE9, 0x7B, 0x9C, + 0xCD, 0xCF, 0x79, 0x5, 0xE8, 0x3F, 0x0, 0xEB, 0x48, 0xB0, 0x4, + 0xA2, 0xFB, 0x2, 0x8A, 0x1E, 0xA5, 0x4, 0x88, 0x1E, 0xA7, 0x4, + 0x8B, 0x16, 0xA3, 0x4, 0x8A, 0x26, 0xA2, 0x4, 0x80, 0xCC, 0x40, + 0x80, 0xCB, 0x80, 0xE9, 0xD5, 0xD, 0xE8, 0x1D, 0x10, 0x73, 0x25, + 0x75, 0x3, 0xE9, 0x4A, 0x9C, 0xCD, 0xD0, 0x79, 0x3, 0xE8, 0xE, + 0x0, 0xB0, 0x8, 0xA2, 0xFB, 0x2, 0x33, 0xC0, 0xA3, 0x9F, 0x4, + 0xA3, 0xA1, 0x4, 0xC3, 0x52, 0x56, 0x8B, 0x16, 0xA3, 0x4, 0xE8, + 0x83, 0x0, 0x5E, 0x5A, 0xC3, 0xE8, 0xF2, 0xF, 0x79, 0x5, 0x8B, + 0x1E, 0xA3, 0x4, 0xC3, 0xCD, 0xD1, 0x75, 0x3, 0xE9, 0x18, 0x9C, + 0xA0, 0xA6, 0x4, 0x3C, 0x90, 0x72, 0x31, 0x74, 0x3, 0xE9, 0x6, + 0x9C, 0xA0, 0xA5, 0x4, 0xA, 0xC0, 0x78, 0x3, 0xE9, 0xFC, 0x9B, + 0xBA, 0x0, 0x0, 0xBB, 0x0, 0x80, 0xE8, 0x8A, 0xFB, 0xE8, 0xCB, + 0x6, 0xE8, 0xCD, 0x11, 0xBA, 0x0, 0x0, 0xBB, 0x80, 0x90, 0xE8, + 0xEC, 0x10, 0x74, 0x3, 0xE9, 0xDF, 0x9B, 0xBB, 0x0, 0x80, 0xEB, + 0x2D, 0xA0, 0xA5, 0x4, 0xA, 0xC0, 0x9C, 0x79, 0x5, 0x24, 0x7F, + 0xA2, 0xA5, 0x4, 0xBA, 0x0, 0x0, 0xBB, 0x0, 0x80, 0xE8, 0x67, + 0xFB, 0xA0, 0xA6, 0x4, 0x3C, 0x90, 0x75, 0x6, 0x9D, 0x78, 0xDB, + 0xE9, 0xB7, 0x9B, 0xE8, 0xE7, 0x6, 0x8B, 0xDA, 0x9D, 0x79, 0x2, + 0xF7, 0xDB, 0x89, 0x1E, 0xA3, 0x4, 0xC6, 0x6, 0xFB, 0x2, 0x2, + 0xC3, 0x33, 0xDB, 0x32, 0xE4, 0xBE, 0xA7, 0x4, 0xC6, 0x84, 0xFF, + 0xFF, 0x90, 0xC6, 0x4, 0x0, 0xB, 0xD2, 0x79, 0x5, 0xF7, 0xDA, + 0xC6, 0x4, 0x80, 0x8A, 0xDE, 0x8A, 0xF2, 0x8A, 0xD7, 0xC6, 0x6, + 0xFB, 0x2, 0x4, 0xE9, 0x4B, 0x8, 0xCD, 0xD6, 0xA0, 0xA6, 0x4, + 0xA, 0xC0, 0x74, 0xA, 0xA0, 0xB2, 0x4, 0xA, 0xC0, 0x75, 0x4, + 0xE9, 0xF8, 0xE, 0xC3, 0x8B, 0x1E, 0xB1, 0x4, 0xE8, 0xDA, 0xF0, + 0xFF, 0x36, 0xA6, 0x4, 0x89, 0x1E, 0xB1, 0x4, 0xE8, 0x56, 0x11, + 0x8B, 0xF0, 0xA3, 0xA6, 0x4, 0xBB, 0x78, 0x4, 0xA3, 0xB2, 0x4, + 0xBD, 0xAB, 0x4, 0x8B, 0x0, 0xB, 0xC0, 0x74, 0x2C, 0xBF, 0x0, + 0x0, 0x8B, 0xCF, 0x8B, 0x0, 0xF7, 0x23, 0x53, 0x8B, 0xDE, 0x3, + 0xDF, 0x81, 0xC3, 0x97, 0x4, 0x3, 0x7, 0x73, 0x1, 0x42, 0x3, + 0xC1, 0x73, 0x1, 0x42, 0x89, 0x7, 0x8B, 0xCA, 0x5B, 0x83, 0xFF, + 0x6, 0x74, 0x4, 0x47, 0x47, 0xEB, 0xDB, 0x8B, 0xC1, 0x53, 0xBB, + 0x9F, 0x4, 0x89, 0x0, 0x5B, 0x83, 0xFE, 0x6, 0x74, 0x4, 0x46, + 0x46, 0xEB, 0xBE, 0xBE, 0x9D, 0x4, 0xFD, 0xB9, 0x7, 0x0, 0xAC, + 0xA, 0xC0, 0xE1, 0xFB, 0x74, 0x5, 0x80, 0xE, 0x9E, 0x4, 0x20, + 0xA0, 0xA5, 0x4, 0xA, 0xC0, 0x8F, 0x6, 0xA6, 0x4, 0x78, 0xF, + 0xBB, 0x9E, 0x4, 0xB9, 0x4, 0x0, 0xD1, 0x17, 0x43, 0x43, 0xE2, + 0xFA, 0xE9, 0x19, 0xC, 0xFE, 0x6, 0xA6, 0x4, 0x75, 0xF7, 0xE9, + 0xDD, 0x7, 0xE8, 0x73, 0xE, 0x74, 0x4, 0xA, 0xFF, 0x75, 0x3, + 0xE9, 0x60, 0xE, 0xE8, 0x3A, 0xF0, 0x8B, 0xE, 0xA5, 0x4, 0x32, + 0xED, 0xA1, 0xA3, 0x4, 0x8A, 0xFD, 0x53, 0x51, 0x52, 0x51, 0x50, + 0xF7, 0xE2, 0x8B, 0xCA, 0x58, 0xF7, 0xE3, 0x3, 0xC8, 0x73, 0x1, + 0x42, 0x8B, 0xDA, 0x5A, 0x58, 0xF7, 0xE2, 0x3, 0xC8, 0x73, 0x1, + 0x42, 0x3, 0xDA, 0x5A, 0x58, 0xF6, 0xE2, 0x3, 0xD8, 0x73, 0xD, + 0xD1, 0xDB, 0xD1, 0xD9, 0xFE, 0x6, 0xA6, 0x4, 0x75, 0x3, 0xE9, + 0x90, 0x7, 0xA, 0xFF, 0x79, 0x9, 0xFE, 0x6, 0xA6, 0x4, 0x75, + 0x7, 0xE9, 0x83, 0x7, 0xD1, 0xD1, 0xD1, 0xD3, 0x8A, 0xD5, 0x8A, + 0xF3, 0x8A, 0xDF, 0x8A, 0xE1, 0xE9, 0xEC, 0xB, 0xC3, 0x53, 0xB0, + 0x8, 0x72, 0x2, 0xB0, 0x11, 0x8A, 0xE8, 0x8A, 0xC8, 0x51, 0x9C, + 0xE8, 0x48, 0x2, 0xA, 0xC0, 0x74, 0x2, 0x79, 0xC, 0x9D, 0x59, + 0x50, 0x7B, 0xB, 0x4, 0x10, 0x58, 0x79, 0x1A, 0xEB, 0x9, 0x9D, + 0x59, 0xEB, 0x26, 0x4, 0x7, 0x58, 0x79, 0xF, 0x50, 0xE8, 0xF6, + 0xB, 0x58, 0x8A, 0xE0, 0x2, 0xE1, 0x7E, 0x16, 0x2, 0xE8, 0xEB, + 0xC, 0x2, 0xC5, 0xFE, 0xC5, 0x3A, 0xE8, 0xB5, 0x3, 0x72, 0xC, + 0x8A, 0xE8, 0xFE, 0xC5, 0xB0, 0x2, 0xEB, 0x4, 0x2, 0xC5, 0xB5, + 0x3, 0xFE, 0xC8, 0xFE, 0xC8, 0x5B, 0x50, 0x9C, 0x32, 0xC9, 0xE8, + 0x4D, 0x0, 0xC6, 0x7, 0x30, 0x75, 0x1, 0x43, 0xE8, 0xE8, 0x0, + 0x4B, 0x80, 0x3F, 0x30, 0x74, 0xFA, 0x80, 0x3F, 0x2E, 0x74, 0x1, + 0x43, 0x9D, 0x58, 0x74, 0x2B, 0x9C, 0x50, 0xE8, 0xBF, 0xD, 0xB4, + 0x45, 0x7B, 0x2, 0xB4, 0x44, 0x88, 0x27, 0x43, 0x58, 0x9D, 0xC6, + 0x7, 0x2B, 0x79, 0x5, 0xC6, 0x7, 0x2D, 0xF6, 0xD8, 0xB4, 0x2F, + 0xFE, 0xC4, 0x2C, 0xA, 0x73, 0xFA, 0x4, 0x3A, 0x43, 0x86, 0xC4, + 0x89, 0x7, 0x43, 0x43, 0xC6, 0x7, 0x0, 0x87, 0xD9, 0xBB, 0xB4, + 0x4, 0xC3, 0xFE, 0xCD, 0x79, 0x16, 0x89, 0x1E, 0x52, 0x3, 0xC6, + 0x7, 0x2E, 0x43, 0xC6, 0x7, 0x30, 0xFE, 0xC5, 0x75, 0xF8, 0x43, + 0x33, 0xC9, 0xEB, 0x1A, 0xFE, 0xCD, 0x75, 0xC, 0xC6, 0x7, 0x2E, + 0x89, 0x1E, 0x52, 0x3, 0x43, 0x33, 0xC9, 0xEB, 0xA, 0xFE, 0xC9, + 0x75, 0x6, 0xC6, 0x7, 0x2C, 0x43, 0xB1, 0x3, 0x89, 0xE, 0x81, + 0x4, 0xC3, 0xB4, 0x5, 0xBD, 0xF5, 0x61, 0xE8, 0xD9, 0xFF, 0x2E, + 0x8B, 0x96, 0x0, 0x0, 0x45, 0x45, 0x8B, 0x36, 0xA3, 0x4, 0xB0, + 0x2F, 0xFE, 0xC0, 0x2B, 0xF2, 0x73, 0xFA, 0x3, 0xF2, 0x88, 0x7, + 0x43, 0x89, 0x36, 0xA3, 0x4, 0xFE, 0xCC, 0x75, 0xDD, 0xE8, 0xB6, + 0xFF, 0xC6, 0x7, 0x0, 0xC3, 0xB9, 0x1, 0x3, 0xBE, 0x6, 0x0, + 0xEB, 0x6, 0xB9, 0x4, 0x4, 0xBE, 0x4, 0x0, 0xBF, 0xB3, 0x4, + 0xFC, 0xBB, 0x74, 0x62, 0x8B, 0x16, 0xA3, 0x4, 0x56, 0x8A, 0xC6, + 0x32, 0xE4, 0xD3, 0xE0, 0x86, 0xE0, 0x2E, 0xD7, 0xAA, 0xD3, 0xE2, + 0x8A, 0xCD, 0x4E, 0x75, 0xEE, 0xC6, 0x5, 0x0, 0xBB, 0xB3, 0x4, + 0x59, 0xFE, 0xC9, 0x80, 0x3F, 0x30, 0x75, 0x3, 0x43, 0xE2, 0xF8, + 0xC3, 0xE8, 0xE9, 0xC, 0x7B, 0x77, 0x51, 0x53, 0xBE, 0x9F, 0x4, + 0xBF, 0xAB, 0x4, 0xB9, 0x4, 0x0, 0xFC, 0xF3, 0xA5, 0xE8, 0x75, + 0x3, 0x53, 0xBB, 0xB1, 0x4, 0xE8, 0xFD, 0xD, 0x5B, 0xBE, 0xAB, + 0x4, 0xBF, 0x9F, 0x4, 0xB9, 0x4, 0x0, 0xFC, 0xF3, 0xA5, 0x74, + 0x3, 0xE8, 0xCE, 0xC, 0x8A, 0xE, 0xA6, 0x4, 0x80, 0xE9, 0xB8, + 0xF6, 0xD9, 0xF8, 0xE8, 0x5A, 0x3, 0x5B, 0x59, 0xBE, 0xA6, 0x61, + 0xB0, 0x9, 0xE8, 0x2E, 0xFF, 0x50, 0xB0, 0x2F, 0x50, 0x58, 0xFE, + 0xC0, 0x50, 0xE8, 0x94, 0x0, 0x73, 0xF7, 0xE8, 0xA3, 0x0, 0x58, + 0xEB, 0xB, 0x75, 0x9, 0xC6, 0x7, 0x31, 0x43, 0xC6, 0x7, 0x30, + 0xEB, 0x2, 0x88, 0x7, 0x43, 0x58, 0xFE, 0xC8, 0x75, 0xD7, 0x51, + 0xBE, 0x9F, 0x4, 0xBF, 0xA3, 0x4, 0xB9, 0x2, 0x0, 0xFC, 0xF3, + 0xA5, 0x59, 0xEB, 0x29, 0x53, 0x51, 0xE8, 0x18, 0xF, 0xE8, 0x71, + 0x3, 0x5A, 0x5B, 0xE8, 0x99, 0xD, 0x74, 0xB, 0x89, 0x1E, 0xA5, + 0x4, 0x89, 0x16, 0xA3, 0x4, 0xE8, 0x73, 0xC, 0xB0, 0x1, 0xE8, + 0xB2, 0x3, 0x89, 0x1E, 0xA5, 0x4, 0x89, 0x16, 0xA3, 0x4, 0x59, + 0x5B, 0xB0, 0x3, 0xBA, 0xEC, 0x61, 0xE8, 0xC7, 0xFE, 0x50, 0x53, + 0x52, 0xE8, 0x5E, 0xD, 0x5D, 0xB0, 0x2F, 0x50, 0x58, 0xFE, 0xC0, + 0x50, 0xE8, 0x17, 0xE, 0x73, 0xF7, 0x2E, 0x3, 0x96, 0x0, 0x0, + 0x2E, 0x12, 0x9E, 0x2, 0x0, 0x45, 0x45, 0x45, 0xE8, 0x38, 0xD, + 0x58, 0x87, 0xD5, 0x5B, 0x88, 0x7, 0x43, 0x58, 0xFE, 0xC8, 0x75, + 0xCE, 0x42, 0x42, 0x8B, 0xEA, 0xB4, 0x4, 0xE9, 0xB3, 0xFE, 0x51, + 0x56, 0xB9, 0x7, 0x0, 0xBF, 0x9F, 0x4, 0xF8, 0xFC, 0x2E, 0xAC, + 0x18, 0x5, 0x47, 0xE2, 0xF9, 0x5E, 0x59, 0xC3, 0x51, 0xB9, 0x7, + 0x0, 0xBF, 0x9F, 0x4, 0xF8, 0xFC, 0x2E, 0xAC, 0x10, 0x5, 0x47, + 0xE2, 0xF9, 0x59, 0xC3, 0x53, 0x51, 0x33, 0xFF, 0x57, 0xBB, 0x2, + 0x5E, 0xA0, 0xA6, 0x4, 0x2E, 0xD7, 0xA, 0xC0, 0x74, 0xC, 0x5F, + 0x98, 0x2B, 0xF8, 0x57, 0x8B, 0xD0, 0xE8, 0x32, 0xEF, 0xEB, 0xE8, + 0xBB, 0x66, 0x60, 0xE8, 0x88, 0xC, 0xE8, 0x2D, 0xD, 0x73, 0x6, + 0xE8, 0xE6, 0xB, 0x5F, 0x4F, 0x57, 0xE8, 0xB0, 0xB, 0x72, 0x1F, + 0xBB, 0x7A, 0x60, 0xE8, 0x8E, 0xC, 0xE8, 0x58, 0xFC, 0x58, 0x2C, + 0x9, 0x50, 0xBB, 0xF6, 0x7F, 0xE8, 0x6D, 0xC, 0xE8, 0x57, 0xD, + 0x76, 0x7, 0xE8, 0xB9, 0xB, 0x58, 0xFE, 0xC0, 0x50, 0x58, 0x59, + 0x5B, 0xA, 0xC0, 0xC3, 0x58, 0x59, 0x5B, 0xA, 0xC0, 0xC3, 0xBB, + 0xB4, 0x4, 0x8A, 0x2F, 0xB1, 0x20, 0x8A, 0x26, 0x83, 0x4, 0xF6, + 0xC4, 0x20, 0x74, 0xD, 0x3A, 0xE9, 0xB1, 0x2A, 0x75, 0x7, 0xF6, + 0xC4, 0x4, 0x75, 0x2, 0x8A, 0xE9, 0x88, 0xF, 0xE8, 0xBF, 0xF2, + 0x74, 0x32, 0xBD, 0xA5, 0x61, 0x2E, 0x3A, 0x86, 0x0, 0x0, 0x74, + 0x9, 0x81, 0xFD, 0x9C, 0x61, 0x74, 0x26, 0x4D, 0xEB, 0xF0, 0x81, + 0xED, 0x9C, 0x61, 0xD1, 0xE5, 0x2E, 0xFF, 0xA6, 0x61, 0x70, 0x75, + 0x70, 0x75, 0x70, 0x79, 0x70, 0x79, 0x70, 0x79, 0x70, 0x79, 0x70, + 0x75, 0x70, 0x79, 0x70, 0x3C, 0x70, 0x3C, 0x70, 0x4B, 0xC6, 0x7, + 0x30, 0x8A, 0x26, 0x83, 0x4, 0xF6, 0xC4, 0x10, 0x74, 0x4, 0x4B, + 0xC6, 0x7, 0x24, 0xF6, 0xC4, 0x4, 0x75, 0x5, 0x4B, 0x88, 0x2F, + 0x32, 0xED, 0xC3, 0xA, 0xC0, 0xEB, 0x6, 0xC6, 0x7, 0x30, 0x43, + 0xFE, 0xC8, 0x75, 0xF8, 0xC3, 0xE8, 0x89, 0xFD, 0xC6, 0x7, 0x30, + 0x43, 0xFE, 0xC8, 0x75, 0xF5, 0xC3, 0xBB, 0xB4, 0x4, 0xC6, 0x7, + 0x20, 0x53, 0xE8, 0xC1, 0xA, 0x5B, 0x9C, 0x79, 0xA, 0xC6, 0x7, + 0x2D, 0x53, 0xE8, 0xEC, 0xC, 0x5B, 0xC, 0x1, 0x43, 0xC6, 0x7, + 0x30, 0x9D, 0xC3, 0xCD, 0xD8, 0xE8, 0xDD, 0xFF, 0x75, 0x8, 0x43, + 0xC6, 0x7, 0x0, 0xBB, 0xB4, 0x4, 0xC3, 0xE8, 0xC8, 0xA, 0x79, + 0x12, 0xB9, 0x0, 0x7, 0x33, 0xC0, 0xA3, 0x83, 0x4, 0x89, 0xE, + 0x81, 0x4, 0xE8, 0x5E, 0xFD, 0xE9, 0x31, 0xFF, 0xE9, 0x78, 0xFC, + 0xE8, 0x81, 0xA, 0x79, 0x3, 0xE9, 0x60, 0x9F, 0x75, 0x1, 0xC3, + 0xA0, 0xA6, 0x4, 0xD0, 0xE8, 0x50, 0xC6, 0x6, 0xA6, 0x4, 0x40, + 0xD0, 0x16, 0xA6, 0x4, 0xBB, 0xAB, 0x4, 0xE8, 0x9, 0xD, 0xB9, + 0x4, 0x0, 0x51, 0xE8, 0x37, 0xD, 0x8B, 0x16, 0xAB, 0x4, 0x8B, + 0x1E, 0xAD, 0x4, 0xE8, 0xBB, 0xF7, 0x5A, 0x5B, 0xE8, 0x4B, 0xF6, + 0xFE, 0xE, 0xA6, 0x4, 0x59, 0x74, 0xA, 0xE2, 0xE3, 0x58, 0x4, + 0xC0, 0x0, 0x6, 0xA6, 0x4, 0xC3, 0xE9, 0x2F, 0xA, 0xBF, 0xBE, + 0x25, 0x57, 0xBF, 0xA8, 0x4, 0xC6, 0x5, 0x1, 0xE8, 0x2C, 0xA, + 0x75, 0x3, 0xE9, 0x36, 0xF1, 0x79, 0x7, 0xA, 0xFF, 0x75, 0xA, + 0xE9, 0x93, 0x3, 0xA, 0xFF, 0x75, 0x3, 0xE9, 0xD, 0xA, 0xA, + 0xDB, 0x79, 0x26, 0x80, 0x3E, 0xA6, 0x4, 0x99, 0x72, 0x3, 0xE9, + 0xED, 0x9E, 0x52, 0x53, 0xFF, 0x36, 0xA3, 0x4, 0xFF, 0x36, 0xA5, + 0x4, 0xE8, 0x32, 0x1, 0x5B, 0x5A, 0xE8, 0x5A, 0xB, 0xE8, 0x3D, + 0xB, 0x5B, 0x5A, 0x74, 0x3, 0xE9, 0xD1, 0x9E, 0xA0, 0xA5, 0x4, + 0xA, 0xC0, 0x79, 0x9, 0xBF, 0xC4, 0x71, 0x57, 0x24, 0x7F, 0xA2, + 0xA5, 0x4, 0x53, 0x52, 0x80, 0xCB, 0x7F, 0x9C, 0xFF, 0x36, 0xA5, + 0x4, 0xFF, 0x36, 0xA3, 0x4, 0xE8, 0x2, 0x1, 0x5A, 0x5B, 0xE8, + 0x2A, 0xB, 0x75, 0x1C, 0x52, 0x53, 0x33, 0xD2, 0xBB, 0x0, 0x90, + 0xE8, 0x1E, 0xB, 0x5B, 0x5A, 0x79, 0xE, 0x9D, 0x5A, 0x5B, 0xEB, + 0x3C, 0x90, 0x33, 0xD2, 0xBB, 0x0, 0x81, 0xE9, 0x12, 0xF7, 0x9D, + 0x79, 0xE, 0x53, 0x52, 0xE8, 0x2F, 0x1, 0x8A, 0xC2, 0xE8, 0xC5, + 0x2, 0x5A, 0x5B, 0xD0, 0xD8, 0x8F, 0x6, 0xA3, 0x4, 0x8F, 0x6, + 0xA5, 0x4, 0x9F, 0x80, 0x26, 0xA5, 0x4, 0x7F, 0x9E, 0x73, 0x4, + 0xBF, 0xB0, 0x7D, 0x57, 0x53, 0x52, 0xE8, 0x15, 0x1, 0x5A, 0x5B, + 0xE8, 0x3, 0xFB, 0xE9, 0x85, 0xF0, 0x53, 0x52, 0xE8, 0xFF, 0x0, + 0x89, 0x16, 0xB2, 0x4, 0xC7, 0x6, 0xA3, 0x4, 0x0, 0x0, 0xC7, + 0x6, 0xA5, 0x4, 0x0, 0x81, 0xD1, 0x2E, 0xB2, 0x4, 0x73, 0x7, + 0x5A, 0x5B, 0x53, 0x52, 0xE8, 0xDE, 0xFA, 0xF7, 0x6, 0xB2, 0x4, + 0xFF, 0xFF, 0x74, 0x15, 0x5A, 0x5B, 0xE8, 0x21, 0xC, 0xE8, 0x8D, + 0xA, 0xE8, 0xCB, 0xFA, 0x5A, 0x5B, 0xE8, 0x16, 0xC, 0xE8, 0x82, + 0xA, 0xEB, 0xD6, 0x5A, 0x5B, 0xC3, 0x8A, 0xE, 0xA6, 0x4, 0x80, + 0xE9, 0xB8, 0x73, 0x39, 0xF6, 0xD9, 0x9C, 0xBB, 0xA4, 0x4, 0x8A, + 0x87, 0x1, 0x0, 0x88, 0x87, 0x3, 0x0, 0xA, 0xC0, 0x9C, 0xC, + 0x80, 0x88, 0x87, 0x1, 0x0, 0xC6, 0x87, 0x2, 0x0, 0xB8, 0x9D, + 0x9C, 0x79, 0x3, 0xE8, 0x22, 0x0, 0x32, 0xED, 0xE8, 0x12, 0x0, + 0x9D, 0x79, 0x3, 0xE8, 0x26, 0x0, 0xC6, 0x6, 0x9E, 0x4, 0x0, + 0x9D, 0x73, 0x3, 0xE9, 0xBD, 0x1, 0xC3, 0x51, 0x53, 0xF8, 0xE8, + 0x7A, 0x9, 0x5B, 0x59, 0xE2, 0xF6, 0xC3, 0x53, 0xBB, 0x9F, 0x4, + 0x83, 0x2F, 0x1, 0x73, 0x4, 0x43, 0x43, 0xEB, 0xF7, 0x5B, 0xC3, + 0x53, 0xBB, 0x9F, 0x4, 0xFE, 0x7, 0x75, 0x3, 0x43, 0xEB, 0xF9, + 0x5B, 0xC3, 0x8A, 0xE, 0xA6, 0x4, 0x80, 0xE9, 0x98, 0x73, 0x41, + 0xF6, 0xD9, 0x9C, 0x8B, 0x16, 0xA3, 0x4, 0x8B, 0x1E, 0xA5, 0x4, + 0xA, 0xDB, 0x9C, 0x88, 0x1E, 0xA7, 0x4, 0xC6, 0x6, 0xA6, 0x4, + 0x98, 0x80, 0xCB, 0x80, 0x9D, 0x9C, 0x79, 0x6, 0x83, 0xEA, 0x1, + 0x80, 0xDB, 0x0, 0x32, 0xED, 0xA, 0xC9, 0x74, 0x6, 0xD0, 0xEB, + 0xD1, 0xDA, 0xE2, 0xFA, 0x9D, 0x9F, 0x79, 0x5, 0x42, 0x75, 0x2, + 0xFE, 0xC3, 0x9D, 0x73, 0x5, 0x32, 0xE4, 0xE9, 0xA9, 0x1, 0x9E, + 0x79, 0xA, 0xF7, 0xD2, 0xF6, 0xD3, 0x83, 0xC2, 0x1, 0x80, 0xD3, + 0x0, 0xC3, 0xB1, 0x98, 0x2A, 0xE, 0xA6, 0x4, 0xF8, 0xEB, 0xAA, + 0xE8, 0x66, 0x8, 0x7E, 0x51, 0xBA, 0x0, 0x0, 0xBB, 0x0, 0x81, + 0xE8, 0xBE, 0x9, 0x75, 0x9, 0x89, 0x16, 0xA3, 0x4, 0x89, 0x16, + 0xA5, 0x4, 0xC3, 0xA0, 0xA6, 0x4, 0x2C, 0x80, 0x98, 0x50, 0xC6, + 0x6, 0xA6, 0x4, 0x80, 0xE8, 0x1B, 0xB, 0xBB, 0x76, 0x61, 0xE8, + 0x18, 0x2, 0x5A, 0x5B, 0xE8, 0x10, 0xB, 0xE8, 0x7C, 0x9, 0xBB, + 0x87, 0x61, 0xE8, 0xA, 0x2, 0x5A, 0x5B, 0xE8, 0x91, 0xF5, 0x5A, + 0xE8, 0xFE, 0xA, 0xE8, 0xD9, 0xF8, 0x5A, 0x5B, 0xE8, 0x1A, 0xF4, + 0xBB, 0x31, 0x80, 0xBA, 0x18, 0x72, 0xE9, 0x9D, 0xF9, 0xE9, 0xF4, + 0x9C, 0xE9, 0x5C, 0x94, 0x9F, 0x86, 0xE0, 0x50, 0xB0, 0x1, 0xEB, + 0x2, 0x32, 0xC0, 0xA2, 0x55, 0x4, 0x58, 0x86, 0xC4, 0x9E, 0xBA, + 0x0, 0x0, 0x89, 0x1E, 0x53, 0x4, 0x74, 0x3, 0xE8, 0xE9, 0xC3, + 0x89, 0x1E, 0x3B, 0x3, 0xE8, 0xAC, 0x93, 0x75, 0xD7, 0x8B, 0xE3, + 0x8B, 0x36, 0x53, 0x4, 0x39, 0x37, 0x75, 0xCD, 0x52, 0x8A, 0xA7, + 0x2, 0x0, 0x50, 0x52, 0x83, 0xC3, 0x4, 0xF6, 0x87, 0xFF, 0xFF, + 0x80, 0x78, 0x41, 0xB9, 0x2, 0x0, 0xFC, 0x8B, 0xF3, 0xBF, 0xA3, + 0x4, 0xF3, 0xA5, 0x5B, 0x56, 0x53, 0xF6, 0x6, 0x55, 0x4, 0xFF, + 0x75, 0xF, 0xBE, 0x56, 0x4, 0x83, 0xEF, 0x4, 0xB9, 0x2, 0x0, + 0xF3, 0xA5, 0x32, 0xC0, 0x74, 0x3, 0xE8, 0x4B, 0xF0, 0x5F, 0xBE, + 0xA3, 0x4, 0xB9, 0x2, 0x0, 0xFC, 0xF3, 0xA5, 0x5E, 0x8B, 0x14, + 0x8B, 0x8C, 0x2, 0x0, 0x83, 0xC6, 0x4, 0x56, 0xE8, 0x49, 0xF0, + 0xEB, 0x27, 0x83, 0xC3, 0x4, 0x8B, 0xF, 0x43, 0x43, 0x5E, 0x8B, + 0x14, 0xF6, 0x6, 0x55, 0x4, 0xFF, 0x75, 0x6, 0x8B, 0x16, 0x56, + 0x4, 0xEB, 0x4, 0x3, 0xD1, 0x70, 0x35, 0x89, 0x14, 0x52, 0x8B, + 0x17, 0x43, 0x43, 0x58, 0x53, 0xE8, 0xA5, 0xF1, 0x5B, 0x59, 0x2A, + 0xC5, 0xE8, 0x1F, 0xF1, 0x74, 0xB, 0x89, 0x16, 0x2E, 0x0, 0x8B, + 0xD1, 0x87, 0xD3, 0xE9, 0x7C, 0x9A, 0x8B, 0xE3, 0x89, 0x1E, 0x45, + 0x3, 0x8B, 0x1E, 0x3B, 0x3, 0x80, 0x3F, 0x2C, 0x75, 0x9, 0xE8, + 0x55, 0xF6, 0xE8, 0x42, 0xFF, 0xE9, 0x93, 0x93, 0xE9, 0xA8, 0x9A, + 0x51, 0x53, 0x56, 0x57, 0x52, 0xB2, 0x39, 0xBB, 0x9E, 0x4, 0xBF, + 0xA5, 0x4, 0xBE, 0xA6, 0x4, 0xEB, 0x19, 0x53, 0xB9, 0x4, 0x0, + 0xF8, 0xD1, 0x17, 0x43, 0x43, 0xE2, 0xFA, 0x5B, 0xF6, 0x7, 0x40, + 0x75, 0x29, 0xFE, 0xC, 0x74, 0x2A, 0xFE, 0xCA, 0x74, 0x26, 0xF6, + 0x5, 0xFF, 0x78, 0x21, 0x75, 0xE0, 0x80, 0x2C, 0x8, 0x76, 0x1A, + 0x80, 0xEA, 0x8, 0x76, 0x15, 0xBE, 0xA4, 0x4, 0xB9, 0x7, 0x0, + 0xFD, 0xF3, 0xA4, 0x80, 0x26, 0x9E, 0x4, 0x20, 0xEB, 0xBE, 0x80, + 0xF, 0x20, 0xEB, 0xD2, 0x5A, 0x5F, 0x5E, 0x5B, 0x59, 0x76, 0x3, + 0xE9, 0x74, 0x4, 0xE9, 0xC0, 0x6, 0x8A, 0x3E, 0xA6, 0x4, 0xB9, + 0x4, 0x0, 0xA, 0xDB, 0x78, 0x21, 0x75, 0x11, 0x80, 0xEF, 0x8, + 0x72, 0x17, 0x8A, 0xDE, 0x8A, 0xF2, 0x8A, 0xD4, 0x32, 0xE4, 0xE2, + 0xEB, 0x74, 0xB, 0xF8, 0xD0, 0xD4, 0xD1, 0xD2, 0xD0, 0xD3, 0xFE, + 0xCF, 0x75, 0xDE, 0xE9, 0xA1, 0x6, 0x88, 0x3E, 0xA6, 0x4, 0xE9, + 0x83, 0x4, 0xCC, 0x20, 0xEB, 0xF4, 0x88, 0x3E, 0xA6, 0x4, 0xE9, + 0x78, 0x4, 0x53, 0xE8, 0x2, 0x0, 0x5B, 0xC3, 0xE8, 0x2D, 0x0, + 0xBB, 0xA, 0x4, 0xEB, 0xC, 0x53, 0xE8, 0x2, 0x0, 0x5B, 0xC3, + 0xE8, 0x1F, 0x0, 0xBB, 0x63, 0x4, 0x80, 0x3E, 0xA8, 0x4, 0x1, + 0x78, 0x7, 0x75, 0x12, 0xC6, 0x6, 0xA8, 0x4, 0x2, 0xE8, 0x81, + 0xAF, 0xB0, 0xD, 0xE8, 0x89, 0xAF, 0xB0, 0xA, 0xE8, 0x84, 0xAF, + 0xC3, 0xFC, 0xA, 0xFF, 0xBE, 0x3, 0x62, 0x74, 0xA, 0xF6, 0x6, + 0xA7, 0x4, 0x80, 0x79, 0x3, 0xBE, 0xB, 0x62, 0xE8, 0x7B, 0x6, + 0x72, 0x8, 0xBF, 0x9F, 0x4, 0xB9, 0x4, 0x0, 0xEB, 0x9, 0x83, + 0xC6, 0x4, 0xBF, 0xA3, 0x4, 0xB9, 0x2, 0x0, 0x2E, 0xA5, 0xE2, + 0xFC, 0xC3, 0xE8, 0xD, 0x9, 0x53, 0xE8, 0x81, 0x7, 0xE8, 0xB6, + 0xF7, 0x5B, 0xE8, 0x5, 0x0, 0x5A, 0x5B, 0xE9, 0xAD, 0xF7, 0x2E, + 0x8A, 0x7, 0x98, 0xE8, 0xF6, 0x8, 0x50, 0x43, 0x2E, 0x8B, 0x7, + 0xA3, 0xA3, 0x4, 0x83, 0xC3, 0x2, 0x2E, 0x8B, 0x7, 0xA3, 0xA5, + 0x4, 0x83, 0xC3, 0x2, 0x58, 0x5A, 0x59, 0x48, 0x74, 0x1C, 0x51, + 0x52, 0x50, 0x53, 0x87, 0xD9, 0xE8, 0x83, 0xF7, 0x5B, 0x53, 0x2E, + 0x8B, 0x17, 0x2E, 0x8B, 0x9F, 0x2, 0x0, 0xE8, 0xEA, 0xF1, 0x5B, + 0x83, 0xC3, 0x4, 0xEB, 0xDE, 0xC3, 0x53, 0xD0, 0xE8, 0x73, 0x3, + 0xE9, 0x9, 0x1, 0xBB, 0xB2, 0x60, 0xE8, 0xD6, 0x6, 0xE8, 0x2F, + 0x7, 0x72, 0x9, 0x5B, 0xE8, 0x23, 0xFB, 0x4B, 0xC6, 0x7, 0x25, + 0xC3, 0xE8, 0xF3, 0x5, 0xB5, 0x10, 0x73, 0x2, 0xB5, 0x7, 0xE8, + 0xBD, 0x5, 0x74, 0x3, 0xE8, 0x4, 0xFA, 0x5B, 0x78, 0x3F, 0x8A, + 0xD0, 0x2, 0xC5, 0x2A, 0x6, 0x82, 0x4, 0x79, 0x5, 0xF6, 0xD8, + 0xE8, 0xC2, 0xFA, 0x32, 0xC9, 0xE8, 0xB1, 0x0, 0xFF, 0x36, 0x81, + 0x4, 0x52, 0xE8, 0xDA, 0xF8, 0x5A, 0x8F, 0x6, 0x81, 0x4, 0xFF, + 0x36, 0x81, 0x4, 0x32, 0xC0, 0xA, 0xC2, 0x74, 0x6, 0xE8, 0xB3, + 0xFA, 0xE8, 0x39, 0xF8, 0x8F, 0x6, 0x81, 0x4, 0xFF, 0x36, 0x81, + 0x4, 0xA0, 0x81, 0x4, 0xE9, 0x72, 0x2, 0x8A, 0xD0, 0xA0, 0x81, + 0x4, 0xA, 0xC0, 0x74, 0x2, 0xFE, 0xC8, 0x8A, 0xF0, 0x2, 0xC2, + 0x8A, 0xC8, 0x78, 0x4, 0x32, 0xC0, 0x8A, 0xC8, 0x79, 0x11, 0x50, + 0x51, 0x52, 0x53, 0xE8, 0xA9, 0x5, 0x5B, 0x5A, 0x59, 0x58, 0xFE, + 0xC0, 0x78, 0xF1, 0x8A, 0xE1, 0x8A, 0xC2, 0x2A, 0xC1, 0x2, 0xC5, + 0x79, 0x17, 0xA0, 0x82, 0x4, 0xE8, 0x5A, 0xFA, 0xC6, 0x7, 0x2E, + 0x89, 0x1E, 0x52, 0x3, 0x43, 0x32, 0xC9, 0x8A, 0xC6, 0x2A, 0xC5, + 0xE9, 0xA1, 0x9, 0xA0, 0x82, 0x4, 0x52, 0xFF, 0x36, 0x81, 0x4, + 0x2A, 0xC5, 0x2A, 0xC2, 0x2, 0xC1, 0x78, 0x3, 0xE8, 0x36, 0xFA, + 0xE8, 0x27, 0x0, 0xFF, 0x36, 0x81, 0x4, 0xE8, 0x51, 0xF8, 0xA0, + 0x82, 0x4, 0x8F, 0x6, 0x81, 0x4, 0xA, 0xC0, 0x58, 0x5A, 0x75, + 0x7, 0x8B, 0x1E, 0x52, 0x3, 0xE9, 0x67, 0x1, 0x2, 0xC2, 0xFE, + 0xC8, 0x78, 0x3, 0xE8, 0xF, 0xFA, 0xE9, 0x5B, 0x1, 0x8A, 0xC5, + 0x2, 0xC2, 0x2A, 0xC1, 0xFE, 0xC0, 0x8A, 0xE8, 0x2C, 0x3, 0x7F, + 0xFC, 0x4, 0x3, 0x8A, 0xC8, 0xA0, 0x83, 0x4, 0x24, 0x40, 0x75, + 0x2, 0x8A, 0xC8, 0xC3, 0xE8, 0xFE, 0x4, 0xB4, 0x7, 0x72, 0x2, + 0xB4, 0x10, 0xE8, 0xC8, 0x4, 0x5B, 0xF9, 0x74, 0x9, 0x53, 0x50, + 0xE8, 0xB, 0xF9, 0x5A, 0x5B, 0x8A, 0xE6, 0x9C, 0x50, 0x8B, 0x16, + 0x81, 0x4, 0xA, 0xF6, 0x9C, 0xA, 0xD2, 0x74, 0x2, 0xFE, 0xCA, + 0x2, 0xF2, 0x9D, 0x74, 0x9, 0xF6, 0x6, 0x83, 0x4, 0x4, 0x75, + 0x2, 0xFE, 0xCE, 0x2A, 0xF4, 0x8A, 0xE6, 0x50, 0x78, 0x3, 0xE9, + 0x4E, 0x0, 0x53, 0x50, 0x50, 0xE8, 0xE1, 0x4, 0x58, 0xFE, 0xC4, + 0x75, 0xF7, 0xE8, 0xBF, 0x4, 0xE8, 0x8E, 0x7, 0x58, 0x50, 0xB9, + 0x3, 0x0, 0xD2, 0xE4, 0xE8, 0xA6, 0x4, 0x72, 0x10, 0x8A, 0xC4, + 0x98, 0xBB, 0xB2, 0x60, 0x3, 0xD8, 0xE8, 0x6B, 0x5, 0xE8, 0x55, + 0x6, 0xEB, 0xE, 0xBB, 0x6E, 0x60, 0x8A, 0xC4, 0x98, 0x3, 0xD8, + 0xE8, 0x53, 0x5, 0xE8, 0xF8, 0x5, 0x58, 0x5B, 0x78, 0x11, 0x58, + 0x59, 0xFE, 0xC1, 0x51, 0x50, 0x53, 0x50, 0xE8, 0x9D, 0x4, 0x58, + 0x5B, 0xEB, 0x2, 0x32, 0xE4, 0xF6, 0xDC, 0xA0, 0x82, 0x4, 0x2, + 0xE0, 0xFE, 0xC4, 0xA, 0xC0, 0x74, 0x9, 0xF6, 0x6, 0x83, 0x4, + 0x4, 0x75, 0x2, 0xFE, 0xCC, 0x8A, 0xEC, 0x32, 0xC9, 0x58, 0xFF, + 0x36, 0x81, 0x4, 0x50, 0x88, 0x2E, 0x82, 0x4, 0xE8, 0x5E, 0xF7, + 0x58, 0xA, 0xE4, 0x7E, 0x5, 0x8A, 0xC4, 0xE8, 0x3F, 0xF9, 0x58, + 0xA3, 0x81, 0x4, 0xA, 0xC0, 0x75, 0xC, 0x4B, 0x8A, 0x7, 0x3C, + 0x2E, 0x74, 0x1, 0x43, 0x89, 0x1E, 0x52, 0x3, 0x58, 0x9D, 0x72, + 0x15, 0x2, 0xC4, 0x8A, 0x26, 0x82, 0x4, 0x2A, 0xC4, 0xA, 0xE4, + 0x74, 0x9, 0xF6, 0x6, 0x83, 0x4, 0x4, 0x75, 0x2, 0xFE, 0xC0, + 0xA, 0xC0, 0xE8, 0x4A, 0xF6, 0x8B, 0xD9, 0xE9, 0x47, 0x0, 0x8A, + 0xE0, 0xF6, 0xC4, 0x40, 0xB4, 0x3, 0x75, 0x2, 0x32, 0xE4, 0xA3, + 0x83, 0x4, 0x89, 0xE, 0x81, 0x4, 0x8A, 0xE0, 0xBB, 0xB4, 0x4, + 0xC6, 0x7, 0x20, 0xF6, 0xC4, 0x8, 0x74, 0x3, 0xC6, 0x7, 0x2B, + 0x53, 0xE8, 0xB6, 0x3, 0x5B, 0x79, 0x8, 0xC6, 0x7, 0x2D, 0x53, + 0xE8, 0xE2, 0x5, 0x5B, 0x43, 0xC6, 0x7, 0x30, 0xE8, 0xD1, 0x3, + 0xA1, 0x83, 0x4, 0x8B, 0xE, 0x81, 0x4, 0x78, 0x3, 0xE9, 0xB3, + 0xFD, 0xE9, 0x68, 0x0, 0x53, 0xE8, 0x3B, 0xF8, 0x5B, 0x74, 0x3, + 0x88, 0x2F, 0x43, 0xC6, 0x7, 0x0, 0xBB, 0xB3, 0x4, 0x43, 0x8B, + 0x3E, 0x52, 0x3, 0x8B, 0x16, 0x81, 0x4, 0xA0, 0x82, 0x4, 0x32, + 0xE4, 0x2B, 0xFB, 0x2B, 0xF8, 0x74, 0x43, 0x8A, 0x7, 0x3C, 0x20, + 0x74, 0xE6, 0x3C, 0x2A, 0x74, 0xE2, 0xB4, 0x1, 0x4B, 0x53, 0x50, + 0xE8, 0xEA, 0xEA, 0x32, 0xE4, 0x3C, 0x2D, 0x74, 0xF6, 0x3C, 0x2B, + 0x74, 0xF2, 0x3C, 0x24, 0x74, 0xEE, 0x3C, 0x30, 0x75, 0x16, 0x43, + 0xE8, 0xD4, 0xEA, 0x73, 0x10, 0x4B, 0xEB, 0x3, 0x4B, 0x88, 0x7, + 0x58, 0xA, 0xE4, 0x74, 0xF8, 0x83, 0xC4, 0x2, 0xEB, 0xB3, 0x58, + 0xA, 0xE4, 0x74, 0xFB, 0x5B, 0xC6, 0x7, 0x25, 0xC3, 0xA1, 0x83, + 0x4, 0x8A, 0xCC, 0xB5, 0x6, 0xD0, 0xE8, 0x8B, 0x16, 0x81, 0x4, + 0x73, 0xB, 0x53, 0x52, 0xE8, 0x45, 0xF3, 0x32, 0xC0, 0x5A, 0xE9, + 0x3F, 0xFE, 0x8A, 0xC6, 0x2C, 0x5, 0x78, 0x3, 0xE8, 0x26, 0xF8, + 0x52, 0xE8, 0xDA, 0xF5, 0x58, 0x50, 0xA, 0xC0, 0x75, 0x1, 0x4B, + 0xFE, 0xC8, 0x78, 0x6, 0xE8, 0x14, 0xF8, 0xC6, 0x7, 0x0, 0x8F, + 0x6, 0x81, 0x4, 0xE9, 0x59, 0xFF, 0xE8, 0xEB, 0x2, 0x74, 0x6D, + 0x79, 0xC, 0xA1, 0xA3, 0x4, 0xA3, 0xB, 0x0, 0xA0, 0xA5, 0x4, + 0xA2, 0xD, 0x0, 0xA1, 0xB, 0x0, 0x2E, 0xF7, 0x26, 0x6B, 0x62, + 0x8B, 0xF8, 0x8A, 0xCA, 0x2E, 0xA0, 0x6D, 0x62, 0xF6, 0x26, 0xB, + 0x0, 0x2, 0xC8, 0x2E, 0xA0, 0xD, 0x0, 0x2E, 0xF6, 0x26, 0x6B, + 0x62, 0x2, 0xC8, 0x32, 0xC0, 0x2E, 0x8B, 0x16, 0x6E, 0x62, 0x3, + 0xD7, 0x2E, 0x8A, 0x1E, 0x70, 0x62, 0x12, 0xD9, 0xA2, 0xA7, 0x4, + 0xB0, 0x80, 0xA2, 0xA6, 0x4, 0x89, 0x16, 0xB, 0x0, 0x88, 0x1E, + 0xD, 0x0, 0xB0, 0x4, 0xA2, 0xFB, 0x2, 0xE9, 0xBB, 0xFB, 0x0, + 0x0, 0x0, 0xBB, 0xB3, 0x4, 0xB9, 0x20, 0x0, 0x3, 0x7, 0x43, + 0x43, 0xE2, 0xFA, 0x24, 0xFE, 0xA3, 0xB, 0x0, 0xEB, 0xA1, 0x8B, + 0x16, 0xB, 0x0, 0x8A, 0x1E, 0xD, 0x0, 0x33, 0xC0, 0xB0, 0x80, + 0xA2, 0xA6, 0x4, 0x88, 0x26, 0xA7, 0x4, 0xE9, 0x8F, 0xFB, 0x53, + 0x51, 0xBB, 0x9E, 0x4, 0x81, 0x7, 0x80, 0x0, 0xB9, 0x3, 0x0, + 0x73, 0xE, 0x43, 0x43, 0xFF, 0x7, 0x75, 0x8, 0xE2, 0xF8, 0xFE, + 0x6, 0xA6, 0x4, 0xD1, 0x1F, 0x59, 0x74, 0x20, 0xF6, 0x6, 0x9E, + 0x4, 0xFF, 0x75, 0x5, 0x80, 0x26, 0x9F, 0x4, 0xFE, 0xBB, 0xA5, + 0x4, 0x8A, 0x7, 0x8A, 0xA7, 0x2, 0x0, 0x24, 0x7F, 0x80, 0xE4, + 0x80, 0xA, 0xE0, 0x88, 0x27, 0x5B, 0xC3, 0x90, 0x90, 0x90, 0xE9, + 0x88, 0xFB, 0x80, 0xE4, 0xE0, 0x80, 0xC4, 0x80, 0x73, 0x1C, 0x9C, + 0x42, 0x75, 0x12, 0x9D, 0xFE, 0xC3, 0x75, 0x13, 0xF9, 0xD0, 0xDB, + 0xFE, 0x6, 0xA6, 0x4, 0x75, 0xA, 0x90, 0xE9, 0x6A, 0xFB, 0x9D, + 0x75, 0x3, 0x80, 0xE2, 0xFE, 0x56, 0xBE, 0xA3, 0x4, 0x89, 0x14, + 0x46, 0x46, 0x8A, 0x3E, 0xA7, 0x4, 0x81, 0xE3, 0x7F, 0x80, 0xA, + 0xDF, 0x88, 0x1C, 0x5E, 0xC3, 0x8B, 0xF1, 0xE8, 0xB4, 0x4, 0x8B, + 0xCE, 0x51, 0xE8, 0x9, 0x2, 0x72, 0x9, 0x80, 0x3E, 0xA6, 0x4, + 0xB8, 0x79, 0xF, 0xEB, 0x7, 0x80, 0x3E, 0xA6, 0x4, 0x98, 0x79, + 0x6, 0xE8, 0x0, 0x2, 0xE8, 0xCF, 0x4, 0xBB, 0x86, 0x4, 0xE8, + 0x51, 0x4, 0x59, 0x51, 0xBF, 0x8E, 0x4, 0xBB, 0x86, 0x4, 0xE8, + 0x35, 0x4, 0xBB, 0x86, 0x4, 0xE8, 0x5D, 0x4, 0xE8, 0xFD, 0x1, + 0xE8, 0xB2, 0x4, 0xBB, 0x86, 0x4, 0xE8, 0x34, 0x4, 0xE8, 0xFB, + 0x1, 0xBB, 0x94, 0x4, 0xE8, 0xC5, 0x1, 0x73, 0x3, 0x83, 0xEB, + 0x4, 0xE8, 0x57, 0x4, 0x59, 0x75, 0x4, 0xFE, 0xC1, 0xEB, 0xCC, + 0x8B, 0xE9, 0xE8, 0x75, 0x4, 0x8B, 0xCD, 0xC3, 0x80, 0x26, 0xA5, + 0x4, 0x7F, 0xE8, 0x86, 0x0, 0xE8, 0xA5, 0x0, 0xC6, 0x6, 0xB2, + 0x4, 0x7F, 0xE8, 0xA3, 0xEC, 0xE8, 0x84, 0x0, 0xEB, 0x1B, 0x65, + 0xED, 0xA1, 0xA5, 0x4, 0x80, 0xFC, 0x77, 0x73, 0x1, 0xC3, 0xA, + 0xC0, 0x79, 0x9, 0x24, 0x7F, 0xA2, 0xA5, 0x4, 0xB8, 0xB0, 0x7D, + 0x50, 0xE8, 0x5B, 0x0, 0xA0, 0xA6, 0x4, 0xA, 0xC0, 0x74, 0x5, + 0x80, 0x6, 0xA6, 0x4, 0x2, 0xE8, 0x61, 0x0, 0xA1, 0xB1, 0x4, + 0x80, 0xFC, 0x82, 0x9C, 0xF6, 0xC4, 0x1, 0x75, 0x2, 0xA8, 0x40, + 0x9C, 0xE8, 0x49, 0x0, 0x9D, 0x74, 0x9, 0xBB, 0x32, 0x60, 0xE8, + 0x37, 0x2, 0xE8, 0x48, 0xEC, 0x80, 0x2E, 0xA6, 0x4, 0x2, 0x73, + 0x3, 0xE8, 0x0, 0x1, 0xE8, 0x3, 0xF1, 0xA0, 0xA6, 0x4, 0x3C, + 0x74, 0x73, 0xB, 0xBA, 0xDB, 0xF, 0xBB, 0x49, 0x83, 0xE8, 0x8E, + 0xF2, 0xEB, 0x6, 0xBB, 0x34, 0x62, 0xE8, 0xC6, 0xFA, 0x9D, 0x75, + 0x5, 0x80, 0x36, 0xA5, 0x4, 0x80, 0xC3, 0xBB, 0x63, 0x62, 0xE8, + 0x0, 0x2, 0xE8, 0x8, 0xF1, 0xE8, 0xC7, 0xF1, 0xE8, 0x6, 0x0, + 0xE8, 0x8, 0xEC, 0xE9, 0x19, 0x3, 0xE8, 0xAD, 0x3, 0xE8, 0xA4, + 0xF7, 0xE8, 0x0, 0x2, 0xE8, 0xC3, 0x3, 0xC3, 0xBB, 0x32, 0x60, + 0xE9, 0xDE, 0x1, 0xB8, 0xF0, 0xC3, 0xFF, 0x36, 0xA5, 0x4, 0xFF, + 0x36, 0xA3, 0x4, 0xE8, 0x56, 0xFF, 0x5A, 0x5B, 0xFF, 0x36, 0xA3, + 0x4, 0xFF, 0x36, 0xA5, 0x4, 0xE8, 0xF9, 0x1, 0xE8, 0x2C, 0xFF, + 0x5B, 0x5A, 0xE9, 0x11, 0xEE, 0xA1, 0xA5, 0x4, 0xA, 0xC0, 0x79, + 0x9, 0xBF, 0xB0, 0x7D, 0x57, 0x24, 0x7F, 0xA2, 0xA5, 0x4, 0x80, + 0xFC, 0x81, 0x72, 0xC, 0xBF, 0x39, 0x7B, 0x57, 0x33, 0xD2, 0xBB, + 0x0, 0x81, 0xE8, 0xF0, 0xED, 0xBA, 0xA2, 0x30, 0xBB, 0x9, 0x7F, + 0xE8, 0xE1, 0x1, 0x78, 0x3A, 0xBF, 0x42, 0x7B, 0x57, 0xFF, 0x36, + 0xA3, 0x4, 0xFF, 0x36, 0xA5, 0x4, 0xBA, 0xD7, 0xB3, 0xBB, 0x5D, + 0x81, 0xE8, 0x65, 0xEC, 0x5B, 0x5A, 0xFF, 0x36, 0xA3, 0x4, 0xFF, + 0x36, 0xA5, 0x4, 0xE8, 0xA3, 0x1, 0xBB, 0x49, 0x62, 0xE8, 0x31, + 0xFA, 0x5B, 0x5A, 0xFF, 0x36, 0xA3, 0x4, 0xFF, 0x36, 0xA5, 0x4, + 0xE8, 0x90, 0x1, 0x5B, 0x5A, 0xE8, 0xAB, 0xED, 0xBB, 0x52, 0x62, + 0xE9, 0x6, 0xFA, 0xBA, 0xDB, 0xF, 0xBB, 0x49, 0x81, 0xE9, 0x25, + 0xEC, 0xBA, 0x92, 0xA, 0xBB, 0x6, 0x80, 0xE9, 0x28, 0xEC, 0xE8, + 0x57, 0xB0, 0x3C, 0xD, 0x75, 0x3, 0xE8, 0x23, 0xB1, 0x2E, 0x8A, + 0x7, 0x43, 0xA, 0xC0, 0x75, 0xEE, 0xC3, 0xBF, 0x9F, 0x4, 0xB9, + 0x4, 0x0, 0xB8, 0x0, 0x0, 0xFC, 0xF3, 0xAB, 0xC3, 0xB8, 0x0, + 0x0, 0xA3, 0xA3, 0x4, 0xA3, 0xA5, 0x4, 0xC3, 0xE8, 0x78, 0xE7, + 0x79, 0xE, 0xA1, 0xA3, 0x4, 0xB, 0xC0, 0x74, 0x20, 0xB0, 0x1, + 0x79, 0x1C, 0xF6, 0xD8, 0xC3, 0xCD, 0xD4, 0xA0, 0xA6, 0x4, 0xA, + 0xC0, 0x74, 0x10, 0xA0, 0xA5, 0x4, 0xA, 0xC0, 0x74, 0x7, 0xB0, + 0x1, 0x79, 0x5, 0xF6, 0xD8, 0xC3, 0xC, 0x1, 0xC3, 0xA0, 0xFB, + 0x2, 0x3C, 0x8, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xC8, 0xC3, 0xE8, + 0xF1, 0xFF, 0x72, 0xC, 0x53, 0xBB, 0x6A, 0x61, 0xE8, 0xCE, 0x0, + 0xE8, 0xED, 0xEA, 0x5B, 0xC3, 0x33, 0xD2, 0xBB, 0x0, 0x80, 0xE8, + 0xAC, 0xEB, 0xC3, 0xE8, 0xD7, 0xFF, 0xBB, 0x2A, 0x60, 0x72, 0x11, + 0xEB, 0x8, 0xE8, 0xCD, 0xFF, 0xBB, 0x3A, 0x60, 0x72, 0x7, 0xE8, + 0xAB, 0x0, 0xE8, 0x75, 0xF0, 0xC3, 0xFF, 0x36, 0xA5, 0x4, 0xFF, + 0x36, 0xA3, 0x4, 0xC6, 0x6, 0xFB, 0x2, 0x8, 0xE8, 0x9C, 0x0, + 0xE8, 0x70, 0xEF, 0x5A, 0x5B, 0xE8, 0x6, 0xF1, 0xC3, 0xB9, 0x4, + 0x0, 0xD1, 0x17, 0x43, 0x43, 0xE2, 0xFA, 0xC3, 0xB9, 0x4, 0x0, + 0xD1, 0x1F, 0x4B, 0x4B, 0xE2, 0xFA, 0xC3, 0x80, 0x8F, 0x2, 0x0, + 0x20, 0xE2, 0x1, 0xC3, 0xBB, 0xB0, 0x4, 0x80, 0xF9, 0x8, 0x72, + 0x26, 0x51, 0xB9, 0x7, 0x0, 0xBB, 0xAA, 0x4, 0x8A, 0x27, 0x8A, + 0x87, 0x1, 0x0, 0x88, 0x7, 0x43, 0xE2, 0xF7, 0x32, 0xC0, 0x88, + 0x7, 0x59, 0x80, 0xE9, 0x8, 0x80, 0xE4, 0x20, 0x74, 0xD9, 0x8, + 0x26, 0xAA, 0x4, 0xE9, 0xD2, 0xFF, 0xA, 0xC9, 0x74, 0xF, 0x51, + 0xF8, 0xE8, 0xB7, 0xFF, 0x59, 0xF6, 0x87, 0x2, 0x0, 0x10, 0x75, + 0xB9, 0xE2, 0xBF, 0xC3, 0xBE, 0x9F, 0x4, 0xBF, 0xAB, 0x4, 0xFC, + 0xB9, 0x4, 0x0, 0x8B, 0x5, 0xA5, 0x89, 0x84, 0xFE, 0xFF, 0xE2, + 0xF7, 0xC3, 0xBF, 0x7C, 0x4, 0xB9, 0x2, 0x0, 0xEB, 0x6, 0xBF, + 0x78, 0x4, 0xB9, 0x4, 0x0, 0xFC, 0x2E, 0x8B, 0x7, 0xAB, 0x43, + 0x43, 0xE2, 0xF8, 0x8B, 0xDF, 0x4B, 0x4B, 0xC3, 0xBF, 0xAB, 0x4, + 0xEB, 0xEA, 0xBF, 0x9F, 0x4, 0xEB, 0xE5, 0xBF, 0xAB, 0x4, 0xB9, + 0x4, 0x0, 0x87, 0xDE, 0xFC, 0xF3, 0xA5, 0x87, 0xDE, 0xC3, 0x51, + 0x53, 0x57, 0xBB, 0x9F, 0x4, 0xBF, 0xAB, 0x4, 0xB9, 0x4, 0x0, + 0xE8, 0xE9, 0xFF, 0x5F, 0x5B, 0x59, 0xC3, 0x51, 0x53, 0x57, 0xBB, + 0xAB, 0x4, 0xBF, 0x9F, 0x4, 0xEB, 0xEB, 0x89, 0x16, 0xA3, 0x4, + 0x89, 0x1E, 0xA5, 0x4, 0xC3, 0x8B, 0x16, 0xA3, 0x4, 0x8B, 0x1E, + 0xA5, 0x4, 0xC3, 0xE8, 0xCF, 0xFE, 0x72, 0x3F, 0xE9, 0x89, 0x0, + 0xE8, 0xD7, 0xED, 0x53, 0x57, 0x8A, 0xC3, 0x32, 0x6, 0xA5, 0x4, + 0x78, 0x3C, 0xA, 0xDB, 0x78, 0x10, 0xA1, 0xA5, 0x4, 0x2B, 0xC3, + 0x72, 0x3F, 0x75, 0x37, 0xA1, 0xA3, 0x4, 0x2B, 0xC2, 0xEB, 0x10, + 0x8B, 0xC3, 0x2B, 0x6, 0xA5, 0x4, 0x72, 0x2E, 0x75, 0x26, 0x8B, + 0xC2, 0x2B, 0x6, 0xA3, 0x4, 0x72, 0x24, 0x75, 0x1C, 0x32, 0xC0, + 0xEB, 0x4A, 0xC0, 0xEB, 0x47, 0xE8, 0xA3, 0xED, 0x90, 0x90, 0x8B, + 0x7, 0x32, 0x6, 0xA5, 0x4, 0x79, 0x13, 0x8A, 0x26, 0xA5, 0x4, + 0xA, 0xE4, 0x78, 0x6, 0xB0, 0x1, 0xA, 0xC0, 0xEB, 0x2C, 0xB0, + 0xFF, 0xF9, 0xEB, 0x27, 0x51, 0xB9, 0x2, 0x0, 0x87, 0xDE, 0xA0, + 0xA5, 0x4, 0xA, 0xC0, 0x79, 0x2, 0x87, 0xF7, 0xFD, 0xA7, 0x75, + 0x6, 0xE2, 0xFB, 0xB0, 0x0, 0xEB, 0xD, 0x73, 0x6, 0xB0, 0x1, + 0xA, 0xC0, 0xEB, 0x5, 0xB0, 0xFF, 0xA, 0xC0, 0xF9, 0x59, 0x5F, + 0x5B, 0xC3, 0xBB, 0xB1, 0x4, 0xE8, 0x56, 0xED, 0x90, 0x90, 0x8A, + 0x5, 0x32, 0x7, 0x79, 0x2, 0xEB, 0xB3, 0x51, 0xB9, 0x4, 0x0, + 0xEB, 0xC4, 0xBB, 0xFF, 0x61, 0xE8, 0xF2, 0xFE, 0xE8, 0x97, 0xFF, + 0x75, 0xB, 0xC6, 0x6, 0xFB, 0x2, 0x2, 0xC7, 0x6, 0xA3, 0x4, + 0x0, 0x80, 0xC3, 0x2E, 0x2B, 0x96, 0x0, 0x0, 0x2E, 0x1A, 0x9E, + 0x2, 0x0, 0xC3, 0xE8, 0x9, 0xFE, 0x78, 0x8, 0xA0, 0xA5, 0x4, + 0xA, 0xC0, 0x78, 0xE, 0xC3, 0xA1, 0xA3, 0x4, 0xB, 0xC0, 0x78, + 0x11, 0xC3, 0xE8, 0xF4, 0xFD, 0x78, 0x8, 0xCD, 0xD2, 0x80, 0x36, + 0xA5, 0x4, 0x80, 0xC3, 0xA1, 0xA3, 0x4, 0x3D, 0x0, 0x80, 0x75, + 0xA, 0xCD, 0xD3, 0x53, 0xE8, 0xDB, 0xED, 0x5B, 0xE9, 0xE6, 0xFF, + 0xF7, 0x1E, 0xA3, 0x4, 0xC3, 0xBB, 0x79, 0x4, 0xE8, 0x33, 0x0, + 0xBF, 0x97, 0x4, 0xB9, 0x8, 0x0, 0xB8, 0x0, 0x0, 0xFC, 0xF3, + 0xAB, 0xA2, 0x78, 0x4, 0xA2, 0xAA, 0x4, 0xC3, 0xE8, 0xB7, 0xFD, + 0x72, 0x3, 0xE9, 0xA2, 0xFE, 0x8B, 0x17, 0x8B, 0x9F, 0x2, 0x0, + 0xC3, 0xB9, 0x4, 0x0, 0xE8, 0xA5, 0xFD, 0x72, 0x3, 0xE9, 0x96, + 0xFE, 0xB9, 0x2, 0x0, 0xE9, 0x90, 0xFE, 0xB9, 0x4, 0x0, 0x87, + 0xFB, 0xBB, 0x9F, 0x4, 0xE8, 0x8F, 0xFD, 0x72, 0x3, 0xE9, 0x80, + 0xFE, 0x87, 0xDF, 0xB9, 0x2, 0x0, 0xBF, 0xA3, 0x4, 0x87, 0xFB, + 0xE9, 0x73, 0xFE, 0xB9, 0x4, 0x0, 0xBF, 0x9F, 0x4, 0xE8, 0x74, + 0xFD, 0x72, 0x3, 0xE9, 0x65, 0xFE, 0xB9, 0x2, 0x0, 0xBF, 0xA3, + 0x4, 0xE9, 0x5C, 0xFE, 0xE8, 0x63, 0xFD, 0x72, 0x3, 0xE9, 0x1D, + 0xFF, 0xE9, 0xCD, 0xFE, 0xE8, 0x58, 0xFD, 0xB9, 0x4, 0x0, 0x73, + 0x3, 0xB9, 0x2, 0x0, 0x5D, 0xBF, 0xA5, 0x4, 0xFF, 0x35, 0x4F, + 0x4F, 0xE2, 0xFA, 0x55, 0xC3, 0xBF, 0xAB, 0x4, 0xB9, 0x4, 0x0, + 0xEB, 0x11, 0xE8, 0x39, 0xFD, 0xBF, 0x9F, 0x4, 0xB9, 0x4, 0x0, + 0x73, 0x6, 0xBF, 0xA3, 0x4, 0xB9, 0x2, 0x0, 0x58, 0x8F, 0x5, + 0x47, 0x47, 0xE2, 0xFA, 0x50, 0xC3, 0xE8, 0x1F, 0xFD, 0x79, 0x1, + 0xC3, 0xCD, 0xD5, 0x72, 0x3, 0xE9, 0xB4, 0xF3, 0xE9, 0x1B, 0xF4, + 0x0, 0x0, 0xFA, 0xBA, 0x60, 0x0, 0x8E, 0xDA, 0x8E, 0xC2, 0x8E, + 0xD2, 0x32, 0xC0, 0xA2, 0x64, 0x4, 0xB5, 0x91, 0xBB, 0x0, 0x0, + 0xBA, 0x9A, 0x6, 0x8B, 0xF2, 0x2E, 0xAC, 0x88, 0x7, 0x43, 0x42, + 0xFE, 0xCD, 0x75, 0xF4, 0xBC, 0xE, 0x7, 0xCD, 0x12, 0xFA, 0xBB, + 0x40, 0x0, 0xF7, 0xE3, 0x8C, 0xDB, 0x2B, 0xC3, 0xBB, 0x0, 0x0, + 0xF6, 0xC4, 0xF0, 0x75, 0x6, 0xB1, 0x4, 0xD3, 0xE0, 0x8B, 0xD8, + 0x4B, 0x89, 0x1E, 0x2C, 0x0, 0x8B, 0xE3, 0xE9, 0x22, 0xCD, 0xB0, + 0x2C, 0xA2, 0xF6, 0x1, 0xBB, 0xB7, 0x0, 0xC6, 0x7, 0x3A, 0x32, + 0xC0, 0xA2, 0xF9, 0x2, 0xA2, 0x6, 0x0, 0xA2, 0x6B, 0x4, 0xA2, + 0x65, 0x4, 0xA2, 0x28, 0x0, 0xBB, 0xE, 0x3, 0x89, 0x1E, 0xC, + 0x3, 0xBB, 0x7A, 0x3, 0x89, 0x1E, 0xE2, 0x3, 0x8B, 0x1E, 0x2C, + 0x0, 0x4B, 0x89, 0x1E, 0xA, 0x3, 0x4B, 0x53, 0xBB, 0xE, 0x7, + 0xB0, 0x4, 0xA2, 0xDF, 0x4, 0x53, 0x89, 0x1E, 0xE0, 0x4, 0xA0, + 0xDF, 0x4, 0xFE, 0xC0, 0x2, 0xC0, 0x8A, 0xD0, 0xB6, 0x0, 0x3, + 0xDA, 0x5A, 0x87, 0xDA, 0x8B, 0x1E, 0xE0, 0x4, 0x88, 0x17, 0x43, + 0x88, 0x37, 0x43, 0xA0, 0xDF, 0x4, 0xB9, 0x34, 0x0, 0xA, 0xC0, + 0x74, 0xE, 0x87, 0xDA, 0x3, 0xD9, 0x87, 0xDA, 0x89, 0x17, 0x43, + 0x43, 0xFE, 0xC8, 0x75, 0xF2, 0x87, 0xDA, 0x3, 0xD9, 0x43, 0x53, + 0xFE, 0xC8, 0xA2, 0x36, 0x5, 0x8B, 0x1E, 0xE0, 0x4, 0x8B, 0x17, + 0xBB, 0x33, 0x0, 0x3, 0xDA, 0x89, 0x1E, 0xE4, 0x4, 0x5B, 0x43, + 0x89, 0x1E, 0x30, 0x0, 0x89, 0x1E, 0x45, 0x3, 0x5A, 0x8A, 0xC2, + 0x24, 0xFE, 0x8A, 0xD0, 0x8A, 0xC2, 0x2A, 0xC3, 0x8A, 0xD8, 0x8A, + 0xC6, 0x1A, 0xC7, 0x8A, 0xF8, 0x73, 0x3, 0xE9, 0x68, 0xAD, 0xB1, + 0x3, 0xD3, 0xEB, 0x8A, 0xC7, 0x3C, 0x2, 0x72, 0x3, 0xBB, 0x0, + 0x2, 0x8A, 0xC2, 0x2A, 0xC3, 0x8A, 0xD8, 0x8A, 0xC6, 0x1A, 0xC7, + 0x8A, 0xF8, 0x73, 0x3, 0xE9, 0x4A, 0xAD, 0x89, 0x1E, 0xA, 0x3, + 0x87, 0xDA, 0x89, 0x1E, 0x2C, 0x0, 0x89, 0x1E, 0x2F, 0x3, 0x8B, + 0xE3, 0x89, 0x1E, 0x45, 0x3, 0x8B, 0x1E, 0x30, 0x0, 0x87, 0xDA, + 0xE8, 0x3D, 0xAD, 0x2B, 0xDA, 0x4B, 0x4B, 0x53, 0x5B, 0xE8, 0x80, + 0xE5, 0xBB, 0xDC, 0x7F, 0xE8, 0x7F, 0xFB, 0xE8, 0x98, 0xAC, 0xE9, + 0x8F, 0xC3, 0x20, 0x42, 0x79, 0x74, 0x65, 0x73, 0x20, 0x66, 0x72, + 0x65, 0x65, 0x0, 0x14, 0xE8, 0xA5, 0xF0, 0x33, 0xC9, 0x52, 0xFF, + 0x36, 0x81, 0x4, 0xE9, 0x68, 0xF6, 0xFD, 0xFF, 0x3, 0xBF, 0xC9, + 0x1B, 0xE, 0xB6, 0x0, 0x0 +}; +#endif + diff --git a/MCUME_pico/psram/psram_t.cpp b/MCUME_pico/psram/psram_t.cpp new file mode 100644 index 0000000..b7664fb --- /dev/null +++ b/MCUME_pico/psram/psram_t.cpp @@ -0,0 +1,269 @@ +/* + PSRAM driver for IPS6404 +*/ + +#include "iopins.h" + +#include "psram_t.h" + +#ifdef HAS_PSRAM + +Page PSRAM_T::pages[MAX_PAGES]; +uint8_t PSRAM_T::nbPages=0; +int8_t PSRAM_T::top=0; +int8_t PSRAM_T::last=0; + +#include "pico/stdlib.h" +#include "hardware/spi.h" + +#define digitalWrite(pin, val) gpio_put(pin, val) + +static void SPItransfer(uint8_t val) +{ + uint8_t dat8=val; + spi_write_blocking(PSRAM_SPIREG, &dat8, 1); +} + +static uint8_t SPItransferRD(uint8_t val) +{ + uint8_t dat8=0xff; + spi_read_blocking(PSRAM_SPIREG, val, &dat8, 1); + return dat8; +} + + + +#define SPICLOCK 104000000 +//#define SPICLOCK 70000000 +//#define SPICLOCK 50000000 + +#define SPI_MODE SPI_CPOL_0 + +#define RAM_READ 0xB +//#define RAM_READ 0x3 +#define RAM_WRITE 0x2 + + +uint8_t PSRAM_T::_cs, PSRAM_T::_miso, PSRAM_T::_mosi, PSRAM_T::_sclk; + + +PSRAM_T::PSRAM_T(uint8_t cs, uint8_t mosi, uint8_t sclk, uint8_t miso) +{ + _cs = cs; + _mosi = mosi; + _sclk = sclk; + _miso = miso; +} + + +void PSRAM_T::begin(void) +{ + spi_init(PSRAM_SPIREG, SPICLOCK); + spi_set_format(PSRAM_SPIREG, 8, SPI_MODE, SPI_CPHA_0, SPI_MSB_FIRST); + gpio_set_function(_miso , GPIO_FUNC_SPI); + gpio_set_function(_cs , GPIO_FUNC_SPI); + gpio_set_function(_sclk , GPIO_FUNC_SPI); + gpio_set_function(_mosi , GPIO_FUNC_SPI); + gpio_init(_cs); + gpio_set_dir(_cs, GPIO_OUT); + digitalWrite(_cs, 1); + sleep_ms(1); + digitalWrite(_cs, 0); + SPItransfer(0x66); + digitalWrite(_cs, 1); + sleep_ms(1); + digitalWrite(_cs, 0); + SPItransfer(0x99); + digitalWrite(_cs, 1); + sleep_ms(20); +} + + +void PSRAM_T::psram_write(uint32_t addr, uint8_t val) +{ + digitalWrite(_cs, 0); + SPItransfer(RAM_WRITE); + SPItransfer((addr>>16)&0xff); + SPItransfer((addr>>8)&0xff); + SPItransfer(addr&0xff); + SPItransfer(val); + digitalWrite(_cs, 1); +} + +uint8_t PSRAM_T::psram_read(uint32_t addr) +{ + uint8_t val=0; + + digitalWrite(_cs, 0); + SPItransfer(RAM_READ); + SPItransfer((addr>>16)&0xff); + SPItransfer((addr>>8)&0xff); + SPItransfer(addr&0xff); +#if RAM_READ == 0xB + SPItransfer(0xFF); +#endif + val = SPItransferRD(0xFF); + digitalWrite(_cs, 1); + return val; +} + + +void PSRAM_T::psram_read_n(uint32_t addr, uint8_t * val, int n) +{ + digitalWrite(_cs, 0); + SPItransfer(RAM_READ); + SPItransfer((addr>>16)&0xff); + SPItransfer((addr>>8)&0xff); + SPItransfer(addr&0xff); +#if RAM_READ == 0xB + SPItransferRD(0xFF); +#endif + //while (n > 0) { + // *val++ = SPItransferRD(0xFF); + // n--; + //} + spi_read_blocking(PSRAM_SPIREG, 0xFF, val, n); + digitalWrite(_cs, 1); +} + + +static uint8_t resp[PAGE_SIZE]; + + +void PSRAM_T::psram_write_n(uint32_t addr, uint8_t * val, int n) +{ + digitalWrite(_cs, 0); + SPItransfer(RAM_WRITE); + SPItransfer((addr>>16)&0xff); + SPItransfer((addr>>8)&0xff); + SPItransfer(addr&0xff); + + while (n > 0) { + SPItransfer(*val++); + n--; + } + //SPItransfer(val,&resp[0],n); + digitalWrite(_cs, 1); +} + + +void PSRAM_T::pswrite(uint32_t addr, uint8_t val) +{ + psram_write(addr, val); + //return + uint32_t curPage=addr&(~(PAGE_SIZE-1)); + for (int i=0; i +#include + + +#define PAGE_SIZE 256 //2048 //16 //32 //2048 //1024 +#define MAX_PAGES 16//8 + +struct Page { + uint8_t page[PAGE_SIZE]; + uint32_t pageid; + int8_t next; + int8_t prev; +}; + +class PSRAM_T +{ + public: + PSRAM_T(uint8_t _CS, uint8_t _MOSI=11, uint8_t _SCLK=13, uint8_t _MISO=12); + void begin(void); + void pswrite(uint32_t addr, uint8_t val); + uint8_t psread(uint32_t addr); + uint16_t psread_w(uint32_t addr); + + private: + static uint8_t psram_read(uint32_t addr); + static void psram_read_n(uint32_t addr, uint8_t * val, int n); + static void psram_write(uint32_t addr, uint8_t val); + static void psram_write_n(uint32_t addr, uint8_t * val, int n); + + protected: + static uint8_t _cs, _miso, _mosi, _sclk; + static Page pages[MAX_PAGES]; + static uint8_t nbPages; + static int8_t top; + static int8_t last; +}; +#endif + +#endif + +#endif + diff --git a/MCUME_pico/testpsram/emuapi.cpp b/MCUME_pico/testpsram/emuapi.cpp new file mode 100644 index 0000000..b990cf5 --- /dev/null +++ b/MCUME_pico/testpsram/emuapi.cpp @@ -0,0 +1,957 @@ +#define KEYMAP_PRESENT 1 + +#define PROGMEM + +#include "pico.h" +#include "pico/stdlib.h" +#include "hardware/adc.h" +#include +#include + +extern "C" { + #include "emuapi.h" + #include "iopins.h" +} + +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) +// Dual display config, initialize TFT +#include "tft_t_dma.h" +static TFT_T_DMA tft; +#else +// Non Dual display config +#ifdef USE_VGA +#include "vga_t_dma.h" +#else +#include "tft_t_dma.h" +#endif +extern TFT_T_DMA tft; +#endif + + +#define MAX_FILES 64 +#define MAX_FILENAME_SIZE 24 +#define MAX_MENULINES 9 +#define TEXT_HEIGHT 16 +#define TEXT_WIDTH 8 +#define MENU_FILE_XOFFSET (6*TEXT_WIDTH) +#define MENU_FILE_YOFFSET (2*TEXT_HEIGHT) +#define MENU_FILE_W (MAX_FILENAME_SIZE*TEXT_WIDTH) +#define MENU_FILE_H (MAX_MENULINES*TEXT_HEIGHT) +#define MENU_FILE_BGCOLOR RGBVAL16(0x00,0x00,0x40) +#define MENU_JOYS_YOFFSET (12*TEXT_HEIGHT) +#define MENU_VBAR_XOFFSET (0*TEXT_WIDTH) +#define MENU_VBAR_YOFFSET (MENU_FILE_YOFFSET) + +#define MENU_TFT_XOFFSET (MENU_FILE_XOFFSET+MENU_FILE_W+8) +#define MENU_TFT_YOFFSET (MENU_VBAR_YOFFSET+32) +#define MENU_VGA_XOFFSET (MENU_FILE_XOFFSET+MENU_FILE_W+8) +#define MENU_VGA_YOFFSET (MENU_VBAR_YOFFSET+MENU_FILE_H-32-37) + + + +static char romspath[64]; +static int nbFiles=0; +static int curFile=0; +static int topFile=0; +static char selection[MAX_FILENAME_SIZE+1]=""; +static char files[MAX_FILES][MAX_FILENAME_SIZE]; +static bool menuRedraw=true; + +#ifdef PICOMPUTER +static const unsigned short * keys; +static unsigned char keymatrix[6]; +static int keymatrix_hitrow=-1; +static bool key_fn=false; +static bool key_alt=false; +static uint32_t keypress_t_ms=0; +static uint32_t last_t_ms=0; +static uint32_t hundred_ms_cnt=0; +static bool ledflash_toggle=false; +#endif +static int keyMap; + +static bool joySwapped = false; +static uint16_t bLastState; +static int xRef; +static int yRef; +static uint8_t usbnavpad=0; + +static bool menuOn=true; + + + +/******************************** + * Generic output and malloc +********************************/ +void emu_printf(char * text) +{ + printf("%s\n",text); +} + +void emu_printf(int val) +{ + printf("%d\n",val); +} + +void emu_printi(int val) +{ + printf("%d\n",val); +} + +void emu_printh(int val) +{ + printf("0x%.8\n",val); +} + +static int malbufpt = 0; +static char malbuf[EXTRA_HEAP]; + +void * emu_Malloc(int size) +{ + void * retval = malloc(size); + if (!retval) { + emu_printf("failled to allocate"); + emu_printf(size); + emu_printf("fallback"); + if ( (malbufpt+size) < sizeof(malbuf) ) { + retval = (void *)&malbuf[malbufpt]; + malbufpt += size; + } + else { + emu_printf("failure to allocate"); + } + } + else { + emu_printf("could allocate dynamic "); + emu_printf(size); + } + + return retval; +} + +void * emu_MallocI(int size) +{ + void * retval = NULL; + + if ( (malbufpt+size) < sizeof(malbuf) ) { + retval = (void *)&malbuf[malbufpt]; + malbufpt += size; + emu_printf("could allocate static "); + emu_printf(size); + } + else { + emu_printf("failure to allocate"); + } + + return retval; +} +void emu_Free(void * pt) +{ + free(pt); +} + +void emu_drawText(unsigned short x, unsigned short y, const char * text, unsigned short fgcolor, unsigned short bgcolor, int doublesize) +{ + tft.drawText(x, y, text, fgcolor, bgcolor, doublesize?true:false); +} + + +/******************************** + * OSKB handling +********************************/ +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) +// On screen keyboard position +#define KXOFF 28 //64 +#define KYOFF 96 +#define KWIDTH 11 //22 +#define KHEIGHT 3 + +static bool oskbOn = false; +static int cxpos = 0; +static int cypos = 0; +static int oskbMap = 0; +static uint16_t oskbBLastState = 0; + +static void lineOSKB2(int kxoff, int kyoff, char * str, int row) +{ + char c[2] = {'A',0}; + const char * cpt = str; + for (int i=0; i.,SP ", 2); + if (oskbMap == 0) { + lineOSKB(KXOFF,KYOFF, keylables_map1_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map1_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map1_2, 2); + } + else if (oskbMap == 1) { + lineOSKB(KXOFF,KYOFF, keylables_map2_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map2_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map2_2, 2); + } + else { + lineOSKB(KXOFF,KYOFF, keylables_map3_0, 0); + lineOSKB(KXOFF,KYOFF, keylables_map3_1, 1); + lineOSKB(KXOFF,KYOFF, keylables_map3_2, 2); + } +} + +void toggleOskb(bool forceoff) { + if (forceoff) oskbOn=true; + if (oskbOn) { + oskbOn = false; + tft.fillScreenNoDma(RGBVAL16(0x00,0x00,0x00)); + tft.drawTextNoDma(0,32, "Press USER2 to toggle onscreen keyboard.", RGBVAL16(0xff,0xff,0xff), RGBVAL16(0x00,0x00,0x00), true); + } else { + oskbOn = true; + tft.fillScreenNoDma(RGBVAL16(0x00,0x00,0x00)); + tft.drawTextNoDma(0,32, " Press USER2 to exit onscreen keyboard. ", RGBVAL16(0xff,0xff,0xff), RGBVAL16(0x00,0x00,0x00), true); + tft.drawTextNoDma(0,64, " (USER1 to toggle between keymaps) ", RGBVAL16(0x00,0xff,0xff), RGBVAL16(0x00,0x00,0xff), true); + tft.drawRectNoDma(KXOFF,KYOFF, 22*8, 3*16, RGBVAL16(0x00,0x00,0xFF)); + drawOskb(); + } +} + +static int handleOskb(void) +{ + int retval = 0; + + uint16_t bClick = bLastState & ~oskbBLastState; + oskbBLastState = bLastState; + /* + static const char * digits = "0123456789ABCDEF"; + char buf[5] = {0,0,0,0,0}; + int val = bClick; + buf[0] = digits[(val>>12)&0xf]; + buf[1] = digits[(val>>8)&0xf]; + buf[2] = digits[(val>>4)&0xf]; + buf[3] = digits[val&0xf]; + tft.drawTextNoDma(0,KYOFF+ 64,buf,RGBVAL16(0x00,0x00,0x00),RGBVAL16(0xFF,0xFF,0xFF),1); + */ + if (bClick & MASK_KEY_USER2) + { + toggleOskb(false); + } + if (oskbOn) + { + bool updated = true; + if (bClick & MASK_KEY_USER1) + { + oskbMap += 1; + if (oskbMap == 3) oskbMap = 0; + } + else if (bClick & MASK_JOY2_LEFT) + { + cxpos++; + if (cxpos >= KWIDTH) cxpos = 0; + } + else if (bClick & MASK_JOY2_RIGHT) + { + cxpos--; + if (cxpos < 0) cxpos = KWIDTH-1; + } + else if (bClick & MASK_JOY2_DOWN) + { + cypos++; + if (cypos >= KHEIGHT) cypos = 0; + } + else if (bClick & MASK_JOY2_UP) + { + cypos--; + if (cypos < 0) cypos = KHEIGHT-1; + } + else if (oskbBLastState & MASK_JOY2_BTN) + { + retval = cypos*KWIDTH+cxpos+1; + if (retval) { + retval--; + //if (retval & 1) retval = key_map2[retval>>1]; + //else retval = key_map1[retval>>1]; + if (oskbMap == 0) { + retval = key_map1[retval]; + } + else if (oskbMap == 1) { + retval = key_map2[retval]; + } + else { + retval = key_map3[retval]; + } + } + } + else { + updated=false; + } + if (updated) drawOskb(); + } + + return retval; +} +#endif + +/******************************** + * Input and keyboard +********************************/ +int emu_ReadAnalogJoyX(int min, int max) +{ + adc_select_input(0); + int val = adc_read(); +#if INVX + val = 4095 - val; +#endif + val = val-xRef; + val = ((val*140)/100); + if ( (val > -512) && (val < 512) ) val = 0; + val = val+2048; + return (val*(max-min))/4096; +} + +int emu_ReadAnalogJoyY(int min, int max) +{ + adc_select_input(1); + int val = adc_read(); +#if INVY + val = 4095 - val; +#endif + val = val-yRef; + val = ((val*120)/100); + if ( (val > -512) && (val < 512) ) val = 0; + //val = (val*(max-min))/4096; + val = val+2048; + //return val+(max-min)/2; + return (val*(max-min))/4096; +} + + +static uint16_t readAnalogJoystick(void) +{ + uint16_t joysval = 0; +#ifdef PIN_JOY2_A1X + int xReading = emu_ReadAnalogJoyX(0,256); + if (xReading > 128) joysval |= MASK_JOY2_LEFT; + else if (xReading < 128) joysval |= MASK_JOY2_RIGHT; + + int yReading = emu_ReadAnalogJoyY(0,256); + if (yReading < 128) joysval |= MASK_JOY2_UP; + else if (yReading > 128) joysval |= MASK_JOY2_DOWN; +#endif + // First joystick +#if INVY +#ifdef PIN_JOY2_1 + if ( !gpio_get(PIN_JOY2_1) ) joysval |= MASK_JOY2_DOWN; +#endif +#ifdef PIN_JOY2_2 + if ( !gpio_get(PIN_JOY2_2) ) joysval |= MASK_JOY2_UP; +#endif +#else +#ifdef PIN_JOY2_1 + if ( !gpio_get(PIN_JOY2_1) ) joysval |= MASK_JOY2_UP; +#endif +#ifdef PIN_JOY2_2 + if ( !gpio_get(PIN_JOY2_2) ) joysval |= MASK_JOY2_DOWN; +#endif +#endif +#if INVX +#ifdef PIN_JOY2_3 + if ( !gpio_get(PIN_JOY2_3) ) joysval |= MASK_JOY2_LEFT; +#endif +#ifdef PIN_JOY2_4 + if ( !gpio_get(PIN_JOY2_4) ) joysval |= MASK_JOY2_RIGHT; +#endif +#else +#ifdef PIN_JOY2_3 + if ( !gpio_get(PIN_JOY2_3) ) joysval |= MASK_JOY2_RIGHT; +#endif +#ifdef PIN_JOY2_4 + if ( !gpio_get(PIN_JOY2_4) ) joysval |= MASK_JOY2_LEFT; +#endif +#endif +#ifdef PIN_JOY2_BTN + joysval |= (gpio_get(PIN_JOY2_BTN) ? 0 : MASK_JOY2_BTN); +#endif + + return (joysval); +} + + +int emu_SwapJoysticks(int statusOnly) { + if (!statusOnly) { + if (joySwapped) { + joySwapped = false; + } + else { + joySwapped = true; + } + } + return(joySwapped?1:0); +} + +int emu_GetPad(void) +{ + return(bLastState/*|((joySwapped?1:0)<<7)*/); +} + +int emu_ReadKeys(void) +{ + uint16_t retval; + uint16_t j1 = readAnalogJoystick(); + uint16_t j2 = 0; + + // Second joystick +#if INVY +#ifdef PIN_JOY1_1 + if ( !gpio_get(PIN_JOY1_1) ) j2 |= MASK_JOY2_DOWN; +#endif +#ifdef PIN_JOY1_2 + if ( !gpio_get(PIN_JOY1_2) ) j2 |= MASK_JOY2_UP; +#endif +#else +#ifdef PIN_JOY1_1 + if ( !gpio_get(PIN_JOY1_1) ) j2 |= MASK_JOY2_UP; +#endif +#ifdef PIN_JOY1_2 + if ( !gpio_get(PIN_JOY1_2) ) j2 |= MASK_JOY2_DOWN; +#endif +#endif +#if INVX +#ifdef PIN_JOY1_3 + if ( !gpio_get(PIN_JOY1_3) ) j2 |= MASK_JOY2_LEFT; +#endif +#ifdef PIN_JOY1_4 + if ( !gpio_get(PIN_JOY1_4) ) j2 |= MASK_JOY2_RIGHT; +#endif +#else +#ifdef PIN_JOY1_3 + if ( !gpio_get(PIN_JOY1_3) ) j2 |= MASK_JOY2_RIGHT; +#endif +#ifdef PIN_JOY1_4 + if ( !gpio_get(PIN_JOY1_4) ) j2 |= MASK_JOY2_LEFT; +#endif +#endif +#ifdef PIN_JOY1_BTN + if ( !gpio_get(PIN_JOY1_BTN) ) j2 |= MASK_JOY2_BTN; +#endif + + + if (joySwapped) { + retval = ((j1 << 8) | j2); + } + else { + retval = ((j2 << 8) | j1); + } + + if (usbnavpad & MASK_JOY2_UP) retval |= MASK_JOY2_UP; + if (usbnavpad & MASK_JOY2_DOWN) retval |= MASK_JOY2_DOWN; + if (usbnavpad & MASK_JOY2_LEFT) retval |= MASK_JOY2_LEFT; + if (usbnavpad & MASK_JOY2_RIGHT) retval |= MASK_JOY2_RIGHT; + if (usbnavpad & MASK_JOY2_BTN) retval |= MASK_JOY2_BTN; + +#ifdef PIN_KEY_USER1 + if ( !gpio_get(PIN_KEY_USER1) ) retval |= MASK_KEY_USER1; +#endif +#ifdef PIN_KEY_USER2 + if ( !gpio_get(PIN_KEY_USER2) ) retval |= MASK_KEY_USER2; +#endif +#ifdef PIN_KEY_USER3 + if ( !gpio_get(PIN_KEY_USER3) ) retval |= MASK_KEY_USER3; +#endif +#ifdef PIN_KEY_USER4 + if ( !gpio_get(PIN_KEY_USER4) ) retval |= MASK_KEY_USER4; +#endif + +#ifdef PICOMPUTER + keymatrix_hitrow = -1; + unsigned char row; + unsigned short cols[6]={1,2,3,4,5,14}; + unsigned char keymatrixtmp[6]; + + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] = row; + } + +#ifdef MULTI_DEBOUNCE + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] |= row; + } + + for (int i=0;i<6;i++){ + gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 0); +#ifdef SWAP_ALT_DEL + sleep_us(1); + //__asm volatile ("nop\n"); // 4-8ns +#endif + row=0; + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(9) ? 0 : 0x01); + row |= (gpio_get(8) ? 0 : 0x02); + row |= (gpio_get(6) ? 0 : 0x04); + row |= (gpio_get(15) ? 0 : 0x08); + row |= (gpio_get(7) ? 0 : 0x10); + row |= (gpio_get(22) ? 0 : 0x20); + //gpio_set_dir(cols[i], GPIO_OUT); + gpio_put(cols[i], 1); + gpio_set_dir(cols[i], GPIO_IN); + gpio_disable_pulls(cols[i]); + keymatrixtmp[i] |= row; + } +#endif + + +#ifdef SWAP_ALT_DEL + // Swap ALT and DEL + unsigned char alt = keymatrixtmp[0] & 0x02; + unsigned char del = keymatrixtmp[5] & 0x20; + keymatrixtmp[0] &= ~0x02; + keymatrixtmp[5] &= ~0x20; + if (alt) keymatrixtmp[5] |= 0x20; + if (del) keymatrixtmp[0] |= 0x02; +#endif + + bool alt_pressed=false; + if ( keymatrixtmp[5] & 0x20 ) {alt_pressed=true; keymatrixtmp[5] &= ~0x20;}; + + for (int i=0;i<6;i++){ + row = keymatrixtmp[i]; + if (row) keymatrix_hitrow=i; + keymatrix[i] = row; + } + + //6,9,15,8,7,22 +#if INVX + if ( row & 0x2 ) retval |= MASK_JOY2_LEFT; + if ( row & 0x1 ) retval |= MASK_JOY2_RIGHT; +#else + if ( row & 0x1 ) retval |= MASK_JOY2_LEFT; + if ( row & 0x2 ) retval |= MASK_JOY2_RIGHT; +#endif +#if INVY + if ( row & 0x8 ) retval |= MASK_JOY2_DOWN; + if ( row & 0x4 ) retval |= MASK_JOY2_UP; +#else + if ( row & 0x4 ) retval |= MASK_JOY2_DOWN; + if ( row & 0x8 ) retval |= MASK_JOY2_UP; +#endif + if ( row & 0x10 ) retval |= MASK_JOY2_BTN; + + // Handle LED flash + uint32_t time_ms=to_ms_since_boot (get_absolute_time()); + if ((time_ms-last_t_ms) > 100) { + last_t_ms = time_ms; + if (ledflash_toggle == false) { + ledflash_toggle = true; + } + else { + ledflash_toggle = false; + } + } + + if ( alt_pressed ) { + if (key_fn == false) + { + // Release to Press transition + if (hundred_ms_cnt == 0) { + keypress_t_ms=time_ms; + hundred_ms_cnt += 1; // 1 + } + else { + hundred_ms_cnt += 1; // 2 + if (hundred_ms_cnt >= 2) + { + hundred_ms_cnt = 0; + /* + if ( (time_ms-keypress_t_ms) < 500) + { + if (key_alt == false) + { + key_alt = true; + } + else + { + key_alt = false; + } + } + */ + } + } + } + else { + // Keep press + if (hundred_ms_cnt == 1) { + if ((to_ms_since_boot (get_absolute_time())-keypress_t_ms) > 2000) + { + if (key_alt == false) + { + key_alt = true; + } + else + { + key_alt = false; + } + hundred_ms_cnt = 0; + } + } + } + key_fn = true; + } + else { + key_fn = false; + } + + // Handle LED + if (key_alt == true) { + gpio_put(KLED, (ledflash_toggle?1:0)); + } + else { + if (key_fn == true) { + gpio_put(KLED, 1); + } + else { + gpio_put(KLED, 0); + } + } + + if ( key_fn ) retval |= MASK_KEY_USER2; + if ( ( key_fn ) && (keymatrix[0] == 0x02 )) retval |= MASK_KEY_USER1; +#endif + + //Serial.println(retval,HEX); + + if ( ((retval & (MASK_KEY_USER1+MASK_KEY_USER2)) == (MASK_KEY_USER1+MASK_KEY_USER2)) + || (retval & MASK_KEY_USER4 ) ) + { + } + +#if (defined(ILI9341) || defined(ST7789)) && defined(USE_VGA) + if (oskbOn) { + retval |= MASK_OSKB; + } +#endif + + return (retval); +} + +unsigned short emu_DebounceLocalKeys(void) +{ + uint16_t bCurState = emu_ReadKeys(); + uint16_t bClick = bCurState & ~bLastState; + bLastState = bCurState; + + return (bClick); +} + +int emu_ReadI2CKeyboard(void) { + int retval=0; +#ifdef PICOMPUTER + if (key_alt) { + keys = (const unsigned short *)key_map3; + } + else if (key_fn) { + keys = (const unsigned short *)key_map2; + } + else { + keys = (const unsigned short *)key_map1; + } + if (keymatrix_hitrow >=0 ) { + unsigned short match = ((unsigned short)keymatrix_hitrow<<8) | keymatrix[keymatrix_hitrow]; + for (int i=0; i,: " +const unsigned short key_map2[] = { + '1','2','3','4','5','6','7','8','9','0',0, + 0, '!','@','#','$','%','+','&','*','-','\/', + 0, '(',')','?','\/','"','<','>',',',':', + 0,0,0,0 + }; + +#define keylables_map3_0 (char *)"\x11\x12\x13\x14\x15\x16\x17\x18 " +#define keylables_map3_1 (char *)" " +#define keylables_map3_2 (char *)" ;= " +const unsigned short key_map3[] = { + 133,134,135,136,137,138,139,140,0,0,0, // function keys + 0, 0,0,0,0,0,0,0,0,0,0, + 0, 0,0,0,0,0,0,0,';','=', + 0,0,0,0 + }; + +const unsigned short matkeys[] = { + 0x020,0x120,0x220,0x320,0x420,0x408,0x308,0x208,0x108,0x008,0x002, // row 1 + 0x510,0x010,0x110,0x210,0x310,0x410,0x401,0x301,0x201,0x101,0x001, // row 2 + 0x520,0x102,0x202,0x302,0x402,0x404,0x304,0x204,0x104,0x004, // row 3 + 0x508,0x501,0x502,0x504 }; // cursor keys + + +#endif + + +#define MASK_JOY2_RIGHT 0x0001 +#define MASK_JOY2_LEFT 0x0002 +#define MASK_JOY2_UP 0x0004 +#define MASK_JOY2_DOWN 0x0008 +#define MASK_JOY2_BTN 0x0010 +#define MASK_KEY_USER1 0x0020 +#define MASK_KEY_USER2 0x0040 +#define MASK_KEY_USER3 0x0080 +#define MASK_JOY1_RIGHT 0x0100 +#define MASK_JOY1_LEFT 0x0200 +#define MASK_JOY1_UP 0x0400 +#define MASK_JOY1_DOWN 0x0800 +#define MASK_JOY1_BTN 0x1000 +#define MASK_KEY_USER4 0x2000 + + + +extern void emu_init(void); +extern void emu_start(void); + +extern void emu_InitJoysticks(void); +extern int emu_SwapJoysticks(int statusOnly); +extern unsigned short emu_DebounceLocalKeys(void); +extern int emu_ReadKeys(void); +extern int emu_GetPad(void); +extern int emu_ReadAnalogJoyX(int min, int max); +extern int emu_ReadAnalogJoyY(int min, int max); +extern int emu_ReadI2CKeyboard(void); +extern unsigned char emu_ReadI2CKeyboard2(int row); +extern void emu_KeyboardOnUp(int keymodifer, int key); +extern void emu_KeyboardOnDown(int keymodifer, int key); + + +extern int emu_setKeymap(int index); + + +#endif diff --git a/MCUME_pico/testpsram/testpsram.cpp b/MCUME_pico/testpsram/testpsram.cpp new file mode 100644 index 0000000..d1c9daa --- /dev/null +++ b/MCUME_pico/testpsram/testpsram.cpp @@ -0,0 +1,126 @@ +#include "pico.h" +#include "pico/stdlib.h" + +extern "C" { + #include "iopins.h" + #include "emuapi.h" +} + +#include +#include "psram_t.h" + +#ifdef USE_VGA +#include "vga_t_dma.h" +#else +#include "tft_t_dma.h" +#endif + + +TFT_T_DMA tft; + +#define BLUE RGBVAL16(0, 0, 170) +#define LIGHT_BLUE RGBVAL16(0, 136, 255) + +static int fb_width, fb_height; + + +#include "hardware/clocks.h" +#include "hardware/vreg.h" + +static const char * digits = "0123456789ABCDEF"; +static int hk = 0; + +void emu_Input(uint16_t bClick) { + hk = emu_ReadI2CKeyboard(); +} + +bool repeating_timer_callback(struct repeating_timer *t) { + uint16_t bClick = emu_DebounceLocalKeys(); + emu_Input(bClick); + return true; +} + + +PSRAM_T psram = PSRAM_T(PSRAM_CS, PSRAM_MOSI, PSRAM_SCLK, PSRAM_MISO); + +extern void write_loram(int address, uint8_t val) { + psram.pswrite(address,val); +} + +extern uint8_t read_loram(int address) { + return (psram.psread(address)); +} + + + +int main(void) { + vreg_set_voltage(VREG_VOLTAGE_1_05); +// set_sys_clock_khz(125000, true); +// set_sys_clock_khz(150000, true); +// set_sys_clock_khz(133000, true); +// set_sys_clock_khz(200000, true); +// set_sys_clock_khz(225000, true); + set_sys_clock_khz(250000, true); + + stdio_init_all(); + + printf("start\n"); +#ifdef USE_VGA +// tft.begin(VGA_MODE_400x240); + tft.begin(VGA_MODE_320x240); +#else + tft.begin(); +#endif + psram.begin(); + emu_init(); + emu_start(); + tft.startDMA(); + struct repeating_timer timer; + add_repeating_timer_ms(20, repeating_timer_callback, NULL, &timer); + + tft.fillScreenNoDma(LIGHT_BLUE); + tft.get_frame_buffer_size(&fb_width, &fb_height); + tft.drawRect((fb_width-320)/2,(fb_height-200)/2, 320,200, BLUE); + + char buf[4] = {32,32,32,0}; + uint sys_clk = clock_get_hz(clk_sys)/1000000; + uint r1 = sys_clk/100; + uint r = sys_clk - r1*100; + uint r2 = r/10; + r = sys_clk - r1*100 - r2*10; + uint r3 = r; + buf[0] = digits[r1]; + buf[1] = digits[r2]; + buf[2] = digits[r3]; + tft.drawText(0,0,buf,BLUE,LIGHT_BLUE,false); + int addr = 0; + while (true) { + char buf[5] = {0,0,0,0,0}; + buf[0] = digits[(addr>>12)&0xf]; + buf[1] = digits[(addr>>8)&0xf]; + buf[2] = digits[(addr>>4)&0xf]; + buf[3] = digits[addr&0xf]; + buf[4] = 0; + tft.drawText(8,64+0,buf,RGBVAL16(0x00,0x00,0x00),RGBVAL16(0xFF,0xFF,0xFF),false); + + for (int i=0; i<0x10; i++) { + write_loram(addr,i); + uint8_t val = 0xff; + val = read_loram(addr); + buf[0] = digits[(val>>4)&0xf]; + buf[1] = digits[val&0xf]; + buf[2] = 0; + tft.drawText(8,64+16+i*8,buf,RGBVAL16(0x00,0x00,0x00),RGBVAL16(0xFF,0xFF,0xFF),false); + addr += 1; + addr &= 0x1fff; + } + + sleep_ms(100); + } +} + + + + + +